基于IO/NIO/Netty的Client/Server的java程序实现

最新推荐文章于 2024-10-12 00:04:43 发布
最新推荐文章于 2024-10-12 00:04:43 发布
阅读量943 收藏 1
点赞数
文章标签： java idea
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/louderIII/article/details/121997271
版权

目录

一.IO实现

1.简介

（1）传送IO特点

（1）服务端阻塞点server.accept();获取套接字的时候
inputStream.read(bytes);输入流读取数据的时候.
（2）传统socket是短连接，可以做短连接服务器，他无法做长连接，属于一问一答的模式，比如老的tomcat底层用的就是socket,用完就会关掉线程，因此不会出现线程一直被占用的情况，支持处理多个客户端连接单线程情况下只能有一个客户端（一个线程维护一个连接，也就是一个socket客户连接）线程一直被占用。用线程池可以有多个客户端连接，但是非常消耗性能(用此案城池，就是老tomcat原理，只不过是用完后就释放)

（2）原理图

在这里插入图片描述

2.项目创建

1.创建两个项目
在这里插入图片描述
2.分别每个项目新建一个类，分别是client和server

在这里插入图片描述

3.代码

client端：

import java.io.IOException;
import java.io.OutputStream;
import java.net.Socket;

public class client {
    public static void main(String[] args) throws IOException{
        //创建客户端的Socket对象
        //Socket (InetAddress adress,int port)创建流套接字并将其连接到指定IP地址的指定端口号
//		Socket s=new Socket(InetAddress.getByName("192.168.224.1"), 10000);
        //Socket (String host,int port)创建流套接字并将其连接到指定主机的指定端口号
        Socket s=new Socket("127.0.0.1", 50000);

        //获取输出流，写数据
        //OutputStream getOutputStream();返回此套接字的输出流
        OutputStream os=s.getOutputStream();
        os.write("like have a good day!".getBytes());

        //释放资源
        s.close();

    }

}

server端：

import java.io.IOException;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;

public class server {
    public static void main(String[] args) throws IOException {
        //创建客户端的Socket对象(SevereSocket)
        //ServerSocket (int port)创建绑定到指定端口的服务器套接字
        ServerSocket ss=new ServerSocket(50000);

        //Socket accept()侦听要连接到此套接字并接受他
        Socket s=ss.accept();

        //获取输入流，读数据，并把数据显示在控制台
        InputStream is=s.getInputStream();
        byte[] bys=new byte[1024];
        int len=is.read(bys);
        String data=new String(bys,0,len);
        System.out.println("数据是："+data);

        //释放资源
        s.close();
        ss.close();
    }

}

4.运行结果

在这里插入图片描述
在这里插入图片描述

二、NIO实现

1.NIO介绍

（1）特点

主要API介绍：
ServerSocketChannel对应传统IO中的ServerSocket。
SocketChannel对应传统IO中的Socket。
Selector 是NIO核心 ，负载监听 ServerSocketChannel与SocketChannel ,支持单线程连多个客户端;类似通道管理器而且底层是c实现的；线程拥有一个selector就可以支持多个客户端。
SelectionKey 相当于map中的key 相当于记录根据不同动作做不同事情，一个key一个事件。

（2）通信步骤

①创建ServerSocketChannel，为其配置非阻塞模式。

②绑定监听，配置TCP参数，录入backlog大小等。

③创建一个独立的IO线程，用于轮询多路复用器Selector。

④创建Selector，将之前创建的ServerSocketChannel注册到Selector上，并设置监听标识位SelectionKey.OP_ACCEPT。

⑤启动IO线程，在循环体中执行Selector.select()方法，轮询就绪的通道。

⑥当轮询到处于就绪状态的通道时，需要进行操作位判断，如果是ACCEPT状态，说明是新的客户端接入，则调用accept方法接收新的客户端。

⑦设置新接入客户端的一些参数，如非阻塞，并将其继续注册到Selector上，设置监听标识位等。

⑧如果轮询的通道标识位是READ，则进行读取，构造Buffer对象等。

⑨更细节的问题还有数据没发送完成继续发送的问题。

（3）原理图

在这里插入图片描述

（4）与IO对比

NIO模型中线程数量大大降低，线程切换效率因此也大幅度提高
1.IO读写以字节为单位
2.NIO解决这个问题的方式是数据读写不再以字节为单位，而是以字节块为单位。IO模型中，每次都是从操作系统底层一个字节一个字节地读取数据，而NIO维护一个缓冲区，每次可以从这个缓冲区里面读取一块的数据， 这就好比一盘美味的豆子放在你面前，你用筷子一个个夹（每次一个），肯定不如要勺子挖着吃（每次一批）效率来得高。
在这里插入图片描述

2.项目创建

在这里插入图片描述

3.代码：

server代码：

import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.Iterator;
import java.util.Set;

public class Server {
    //网络通信IO操作，TCP协议，针对面向流的监听套接字的可选择通道（一般用于服务端）
    private ServerSocketChannel serverSocketChannel;
    private Selector selector;

    /*
     *开启服务端
     */
    public void start(Integer port) throws Exception {
        serverSocketChannel = ServerSocketChannel.open();
        selector = Selector.open();
        //绑定监听端口
        serverSocketChannel.socket().bind(new InetSocketAddress(port));
        //设置为非阻塞模式
        serverSocketChannel.configureBlocking(false);
        //注册到Selector上
        serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
        startListener();
    }
    private void startListener() throws Exception {
        while (true) {
            // 如果客户端有请求select的方法返回值将不为零
            if (selector.select(1000) == 0) {
                System.out.println("当前没有任务！！！");
                continue;
            }
            // 如果有事件集合中就存在对应通道的key
            Set<SelectionKey> selectionKeys = selector.selectedKeys();
            Iterator<SelectionKey> iterator = selectionKeys.iterator();
            // 遍历所有的key找到其中事件类型为Accept的key
            while (iterator.hasNext()) {
                SelectionKey key = iterator.next();
                if (key.isAcceptable())
                    handleConnection();
                if (key.isReadable())
                    handleMsg(key);
                iterator.remove();
            }
        }
    }
    /**
     * 处理建立连接
     */
    private void handleConnection() throws Exception {
        SocketChannel socketChannel = serverSocketChannel.accept();
        socketChannel.configureBlocking(false);
        socketChannel.register(selector, SelectionKey.OP_READ, ByteBuffer.allocate(1024));
    }
    /*
     * 接收信息
     */
    private void handleMsg(SelectionKey key) throws Exception {
        SocketChannel channel = (SocketChannel) key.channel();
        ByteBuffer attachment = (ByteBuffer) key.attachment();
        channel.read(attachment);
        System.out.println("当前信息: " + new String(attachment.array()));
    }

    public static void main(String[] args) throws Exception {
        Server myServer = new Server();
        myServer.start(8887);
    }
}

Click代码:

import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SocketChannel;

public class Click {
    public static void main(String[] args) throws Exception {
        SocketChannel socketChannel = SocketChannel.open();
        socketChannel.configureBlocking(false);

        // 连接服务器
        if (!socketChannel.connect(new InetSocketAddress("127.0.0.1", 8887))) {
            while (!socketChannel.finishConnect()) {
                System.out.println("connecting...");
            }
        }
        //发送数据
        String str = "hello,物联网19级";
        ByteBuffer byteBuffer = ByteBuffer.wrap(str.getBytes());
        socketChannel.write(byteBuffer);
        System.in.read();
    }

}

4.运行结果

在这里插入图片描述

三、Netty

1.简介

Netty封装了JDK的NIO，Netty是一个异步事件驱动的网络应用框架，用于快速开发可维护的高性能服务器和客户端。

(1)特点

1.并发高
Netty是一款基于NIO（Nonblocking I/O，非阻塞IO）开发的网络通信框架，对比于BIO（Blocking I/O，阻塞IO），他的并发性能得到了很大提高。
2.传输快
Netty的传输快其实也是依赖了NIO的一个特性——零拷贝。我们知道，Java的内存有堆内存、栈内存和字符串常量池等等，其中堆内存是占用内存空间最大的一块，也是Java对象存放的地方，一般我们的数据如果需要从IO读取到堆内存，中间需要经过Socket缓冲区，也就是说一个数据会被拷贝两次才能到达他的的终点，如果数据量大，就会造成不必要的资源浪费。
Netty针对这种情况，使用了NIO中的另一大特性——零拷贝，当他需要接收数据的时候，他会在堆内存之外开辟一块内存，数据就直接从IO读到了那块内存中去，在netty里面通过ByteBuf可以直接对这些数据进行直接操作，从而加快了传输速度。
3.封装好

(2)Netty通信的步骤

①创建两个NIO线程组，一个专门用于网络事件处理（接受客户端的连接），另一个则进行网络通信的读写。

②创建一个ServerBootstrap对象，配置Netty的一系列参数，例如接受传出数据的缓存大小等。

③创建一个用于实际处理数据的类ChannelInitializer，进行初始化的准备工作，比如设置接受传出数据的字符集、格式以及实际处理数据的接口。

④绑定端口，执行同步阻塞方法等待服务器端启动即可。

(3)框架组成

在这里插入图片描述

2.项目环境配置

1.FIle->Project Structure
在这里插入图片描述
2.Moudles→Dependencies→右边的加号
在这里插入图片描述
3.Library->From Maven…
在这里插入图片描述
4.下载netty的jar包
搜索输入io.netty:netty-all，等几分钟
在这里插入图片描述
5.选择第一个下载
在这里插入图片描述
6.弹出一个框选择ok

在这里插入图片描述
7.下载完成,记得勾选，点击OK
在这里插入图片描述

3.代码

服务器端代码：

import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.*;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import io.netty.handler.codec.string.StringDecoder;
import io.netty.handler.codec.string.StringEncoder;

import java.net.InetSocketAddress;

/**
 *
 */
public class Server {

    private int port;

    public static void main(String[] args){
        new Server(12345).start();
    }

    public Server(int port) {
        this.port = port;
    }

    public void start() {
        /**
         * 创建两个EventLoopGroup，即两个线程池，boss线程池用于接收客户端的连接，
         * 一个线程监听一个端口，一般只会监听一个端口所以只需一个线程
         * work池用于处理网络连接数据读写或者后续的业务处理（可指定另外的线程处理业务，
         * work完成数据读写）
         */
        EventLoopGroup boss = new NioEventLoopGroup(1);
        EventLoopGroup work = new NioEventLoopGroup();
        try {
            /**
             * 实例化一个服务端启动类，
             * group（）指定线程组
             * channel（）指定用于接收客户端连接的类，对应java.nio.ServerSocketChannel
             * childHandler（）设置编码解码及处理连接的类
             */
            ServerBootstrap server = new ServerBootstrap()
                    .group(boss, work).channel(NioServerSocketChannel.class)
                    .localAddress(new InetSocketAddress(port))
                    .option(ChannelOption.SO_BACKLOG, 128)
                    .childOption(ChannelOption.SO_KEEPALIVE, true)
                    .childHandler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel ch) throws Exception {
                            ch.pipeline()
                                    .addLast("decoder", new StringDecoder())
                                    .addLast("encoder", new StringEncoder())
                                    .addLast(new HelloWorldServerHandler());
                        }
                    });
            //绑定端口
            ChannelFuture future = server.bind().sync();
            System.out.println("server started and listen " + port);
            future.channel().closeFuture().sync();
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            boss.shutdownGracefully();
            work.shutdownGracefully();
        }
    }

    public static class HelloWorldServerHandler extends ChannelInboundHandlerAdapter {

        @Override
        public void channelActive(ChannelHandlerContext ctx) throws Exception {
            System.out.println("HelloWorldServerHandler active");
        }

        @Override
        public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
            System.out.println("server channelRead..");
            System.out.println(ctx.channel().remoteAddress()+"->Server :"+ msg.toString());
            ctx.write("server write"+msg);
            ctx.flush();
        }
    }
}

客户端代码：

import io.netty.bootstrap.Bootstrap;
import io.netty.channel.*;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioSocketChannel;
import io.netty.handler.codec.string.StringDecoder;
import io.netty.handler.codec.string.StringEncoder;

/**
 *
 */
public class Click {
    private static final String HOST = "localhost";
    private static final int PORT= 12345;

    public static void main(String[] args){
        new Click().start(HOST, PORT);
    }

    public void start(String host, int port) {
        EventLoopGroup group = new NioEventLoopGroup();
        try {
            Bootstrap client = new Bootstrap().group(group).channel(NioSocketChannel.class)
                    .option(ChannelOption.TCP_NODELAY, true).handler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel ch) throws Exception {
                            ch.pipeline()
                                    .addLast("decoder", new StringDecoder())
                                    .addLast("encoder", new StringEncoder())
                                    .addLast(new HelloWorldClientHandler());
                        }
                    });
            ChannelFuture future = client.connect(host, port).sync();
            future.channel().writeAndFlush("Hello Netty Server ,I am a netty client");
            future.channel().closeFuture().sync();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            group.shutdownGracefully();

        }

    }

    public static class HelloWorldClientHandler extends ChannelInboundHandlerAdapter {
        @Override
        public void channelActive(ChannelHandlerContext ctx) throws Exception {
            System.out.println("HelloWorldClientHandler Active");
        }

        @Override
        public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
            System.out.println("HelloWorldClientHandler read Message:"+msg);
        }
    }
}

4.结果

在这里插入图片描述

四.总结

此次学习了解到了IO/NIO/Netty三者的原理特点，三种编程方式的特点，性能方面，NIO优于IO，Netty优于NIO，相比JDK原生NIO，Netty提供了相对十分简单易用的API，非常适合网络编程。Netty是完全基于NIO实现的，所以Netty是异步的。通过Future-Listener机制，用户可以方便的主动获取或者通过通知机制获得IO操作结果。

五.参考文献

https://blog.youkuaiyun.com/weixin_56102526/article/details/121805391?spm=1001.2014.3001.5501.
https://blog.youkuaiyun.com/qq_45659777/article/details/121730888?spm=1001.2014.3001.5501.

frozenlli
关注
基于IO、NIO、Netty的Client和Server之间的Java程序
qq_55691662的博客
12-12 726
文章目录一、IO实现1.1 传统IO的特点1.2 项目实现1.3 结果二、NIO实现2.1NIO特点2.2 IO与NIO的差别2.3 项目实现四、参考文献 一、IO实现 1.1 传统IO的特点 代码执行时会存在两个阻塞点 server.accept(); 等待链接 inputStream.read(bytes); 等待输入 单线程情况下只能为一个客户端服务； 用线程池可以有多个客户端连接，但是非常消耗性能； 使用传统的I/O程序读取文件内容, 并写入到另一个文件(或Socket),
JAVA SE 7.IO/NIO/Netty
举目沧桑的博客
07-20 368
1.Java中I/O操作主要是指使用Java进行输入，输出操作 2.Java所有的I/O操作都是基于数据流进行输入输出，数据流表示字符或者字节数据的流动序列 3.Java的I/O流提供了读写数据的标准方法，Java中表示数据源的对象都会提供数据流读写的方法
java nio client_Java NIO学习笔记 - NIO客户端时序图
weixin_34093753的博客
02-24 249
NIO客户端时序图 如下：client.png步骤一：打开SocketChannel，绑定客户端本地地址(可选，默认系统会随机分配一个可用的本地地址)，示例代码如下：SocketChannel clientChannel = SocketChannel.open();步骤二：设置SocketChannel为非阻塞模式，同时设置客户端连接的TCP参数，示例代码如下：clientChannel.con...
java nio client_Java NIO client — oracle-tech
weixin_39783426的博客
02-16 160
I have an example, but it does not workimport java.io.IOException;import java.net.InetAddress;import java.net.InetSocketAddress;import java.net.Socket;import java.nio.ByteBuffer;import java.nio.channe...
java nio 简单例子_Java nio Client端简单示例
weixin_39552874的博客
02-13 170
java nio是一种基于Channel、Selector、Buffer的技术，它是一种非阻塞的IO实现方式以下Client端示例public class ClientNio {public static void main(String[] args) throws IOException, InterruptedException {SocketChannel socketChannel = ...
Netty实例-简单的服务端-客户端实现，注释详细
卓轩&高江涛==> 个人博客
07-25 9690
Netty实例-简单地服务端-客户端实现，注释详细
Netty指南之IO和NIO的介绍(一)
最新发布
baidu_27137821的博客
10-12 1246
在学习 Netty 框架之前，我们需要先理解 Java 的 IO 和 NIO 模型。这两种模型在网络编程中扮演着重要角色，而 Netty 则是基于 NIO 模型构建的高性能网络应用框架。本文将详细介绍 IO 和 NIO 的概念、特点以及它们之间的区别，为后续学习 Netty 打下坚实基础。
基于IO、NIO、Netty的Java网络程序（实现服务端与客户端通信）
YouthBlood9的博客
12-17 2758
录一、IO Java网络聊天程序1.1 IO 介绍1.1.1 简介1.1.2 传统IO特点1.1.3 原理图1.2 IDEA新建Java项目1.3 代码1.4 运行结果二、NIO Java网络聊天程序2.1 NIO 介绍2.1.1 简介2.1.2 NIO的特点2.1.3 NIO的通信步骤2.1.4 原理图2.1.5 IO与NIO的主要区别2.2 新建项目2.3 代码2.4 运行结果三、Netty Java网络程序3.1 Netty 介绍3.1.1 简介3.1.2 特点3.1.3 Netty通信的步骤3.2
netty-all-4.1.97.Final-20230731.020124-2.jar netty最新jar包，可直接导入使用
08-03
Netty is a NIO client server framework which enables quick and easy development of network applications such as protocol servers and clients. It greatly simplifies and streamlines network programming
java nio client_利用Java NIO 实现client端，支持自动重连
weixin_42518930的博客
02-16 629
Java NIO 实现client端，相比较于Server端的实现，相对简单，如果要支持自动重新连接功能，就需要有线程同步的概念。以下代码实现了自动重新连接的功能，增加了一个具体的连接管理类Manager。package com.sof.nio;import java.io.IOException;import org.slf4j.Logger;import org.slf4j.LoggerFac...
java nio im(server+client)
11-20
java基于nio的通信实例，带UML结构图及server、client源码。
java应用netty服务端和客户端
05-30
java应用netty服务端和客户端示例，客户端和服务端的model对象目录必须一致
NIO创建server和client
lhd992692552的博客
02-17 252
server public class NioChatServer { // 端口 private int port; // 设置缓冲区大小，1024字节 private final int BUFFER = 1024; // 读缓冲区 写缓冲区 private ByteBuffer readBuffer = ByteBuffer.allocate(BUFFER); private ByteBuffer writeBuffer = ByteBuffer.allocate(BUFFER);
java nio client sample
勍的空间
04-19 4259
 This code is reference from Mrs sun, a good female author.notice: 1 nio including Buffer Channel Selector and optional Charset. actually there are two Buffers, one for accept ing message and one
利用Java NIO实现简单的服务器与客户端通讯
book_dw5189的博客
05-19 912
Java NIO（New I/O）是 Java 编程语言中用于非阻塞 IO 操作的一组 API。它提供了更为灵活和高效的 IO 操作方式, 特别适用于网络编程和需要高性能的 I/O 场景。
(3) NioClient
Sunshine
10-26 346
import java.io.IOException; import java.net.InetSocketAddress; import java.nio.ByteBuffer; import java.nio.channels.SelectionKey; import java.nio.channels.Selector; import java.nio.channels.SocketCha...
Netty 简单server和client示例
徐泗空的博客
07-29 1126
Netty 基于java NIO 网络通信框架，具有高效、简单、快速的应用特点。在当下互联网高并发场景下得到很好地应用，现在用java写的高并发产品(如dubbo 、zookeeper、hadoop、rocketmq)大都应用了netty作为底层的通信技术。 下面简单的server和client的示例代码： 一、 服务端 ServerNetty：服务端的netty类 ServerHandler ：处理某个客户端请求的类 MarshallingCodefactory：把信息序列化对象用 pack.
netty java client_Netty 4 实现一个 NettyClient
weixin_29197051的博客
02-13 369
本文章为作者原创，有问题的地方请提出指正。1、类继承Diagram2、定义EndPoint类目前仅仅定义了2个方法，分别用来获取本地或远程服务器的地址。packagenetty;importjava.net.InetSocketAddress;/***@authorxfyou* @date 2019/8/28*/public interfaceEndPoint {/*** Return the ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值