分别基于IO、NIO、Netty的Java网络程序(Client/Server)

最新推荐文章于 2022-01-29 17:26:58 发布

伊木子曦

最新推荐文章于 2022-01-29 17:26:58 发布

阅读量677

点赞数

分类专栏： # 网络通信文章标签： java 网络服务器 IO/NIO/Netty

本文链接：https://blog.csdn.net/Mouer__/article/details/121899581

版权

网络通信专栏收录该内容

11 篇文章 0 订阅

订阅专栏

一、IO实现

1. IO介绍

1.1 传送IO特点

1.服务端阻塞点

server.accept();获取套接字的时候
inputStream.read(bytes);输入流读取数据的时候

2.传统socket是短连接，可以做短连接服务器，他无法做长连接，属于一问一答的模式，比如老的tomcat底层用的就是socket,用完就会关掉线程，因此不会出现线程一直被占用的情况，支持处理多个客户端连接

(1)单线程情况下只能有一个客户端（一个线程维护一个连接，也就是一个socket客户连接）线程一直被占用。

(2)用线程池可以有多个客户端连接，但是非常消耗性能(用此案城池，就是老tomcat原理，只不过是用完后就释放)

  1. 上下文切换(context switch), 此处有4次用户态和内核态的切换
  2. Buffer内存开销, 一个是应用程序buffer, 另一个是系统读取buffer以及socket buffer

使用传统的I/O程序读取文件内容, 并写入到另一个文件(或Socket), 如下程序:

File.read(fileDesc, buf, len);
Socket.send(socket, buf, len);

1.2 原理流程图

在这里插入图片描述

2. 代码

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"), 5000);
        //Socket (String host,int port)创建流套接字并将其连接到指定主机的指定端口号
        Socket s=new Socket("127.0.0.1", 5000);

        //获取输出流，写数据
        OutputStream os=s.getOutputStream();//返回此套接字的输出流
        os.write("伊木子曦".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 ss=new ServerSocket(5000);//ServerSocket (int port)创建绑定到指定端口的服务器套接字

        Socket s=ss.accept();//Socket 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();
    }
}

3. 运行结果

先运行server端,在运行client端
在这里插入图片描述

二、NIO实现

1. NIO介绍

java 1.4版本推出了一种新型的IO API,与原来的IO具有相同的作用和目的；可代替标准java IO，只是实现的方式不一样，NIO是面向缓冲区、基于通道的IO操作;通过NIO可以提高对文件的读写操作。基于这种优势，现在使用NIO的场景越来愈多，很多主流行的框架都使用到了NIO技术，如Tomcat、Netty、Jetty等；所以学习和掌握NIO技术已经是一个java开发的必备技能了。

1.1 NIO特点

NIO在单线程下可以同时为多个客户端服务
NIO技术省去了将操作系统的read buffer拷贝到程序的buffer, 以及从程序buffer拷贝到socket buffer的步骤, 直接将 read buffer 拷贝到 socket buffer. java 的 FileChannel.transferTo() 方法就是这样的实现, 这个实现是依赖于操作系统底层的sendFile()实现的.

public void transferTo(long position, long count, WritableByteChannel target);

他的底层调用的是系统调用sendFile()方法

sendfile(int out_fd, int in_fd, off_t *offset, size_t count);

1.2 原理流程图

在这里插入图片描述

1.3 NIO对比IO

NIO	IO
面向缓冲区Buffer	面向流Stream
双向（基于通道Channel）	单向（分别建立输入流、输出流）
同步非阻塞（non-blocking）	同步阻塞
选择器（Selector，多路复用)	无
支持字符集编码解码解决方案，支持锁，支持内存映射文件的文件访问接口	无

1.4 使用NIO遇到的一些问题

(1)客户端关闭的时候会抛出异常，死循环
解决方案:
// 创建缓冲区,读取数据
int ret = 0;
boolean failure = true;
ByteBuffer buffer = ByteBuffer.allocate(1024);
//防止出现异常
try {
ret = channel.read(buffer);
failure = false;
} catch (Exception e) {
// ignore
}
//如果读取不到数据，或失败则取消key绑定
if (ret <= 0 || failure) {
key.cancel(); // Some JDK implementations run into an infinite loop without this.
System.out.println(“客户端关闭”);
} else {
System.out.println(“服务器端收到数据：” + new String(buffer.array()));
//写数据
ByteBuffer outBuffer = ByteBuffer.wrap(“你好，收到了\n”.getBytes());
channel.write(outBuffer);// 将消息回送给客户端
}
(2)selector.select();阻塞，那为什么说nio是非阻塞的IO？
selector.select()
selector.select(1000);不阻塞
selector.wakeup();也可以唤醒selector
selector.selectNow();也可以立马返回数据
(3)SelectionKey.OP_WRITE是代表什么意思
OP_WRITE表示底层缓冲区是否有空间，是则响应返还true

2. 代码

server:

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.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.Iterator;

public class NIOServer {
    //NIO
    //通道管理器
    private Selector selector;

    /**
     * 启动服务端测试
     * @throws IOException
     */
    public static void main(String[] args) throws IOException {
        NIOServer server = new NIOServer();
        server.initServer(5000);
        server.listen();
    }

    /**
     * 获得一个ServerSocket通道，并对该通道做一些初始化的工作
     * @param port  绑定的端口号
     * @throws IOException
     */
    public void initServer(int port) throws IOException {
        // 获得一个ServerSocket通道
        ServerSocketChannel serverChannel = ServerSocketChannel.open();
        // 设置通道为非阻塞
        serverChannel.configureBlocking(false);
        // 将该通道对应的ServerSocket绑定到port端口
        serverChannel.socket().bind(new InetSocketAddress(port));
        // 获得一个通道管理器
        this.selector = Selector.open();
        //将通道管理器和该通道绑定，并为该通道注册SelectionKey.OP_ACCEPT事件,注册该事件后，
        //当该事件到达时，selector.select()会返回，如果该事件没到达selector.select()会一直阻塞。
        serverChannel.register(selector, SelectionKey.OP_ACCEPT);
    }

    /**
     * 采用轮询的方式监听selector上是否有需要处理的事件，如果有，则进行处理
     * @throws IOException
     */
    public void listen() throws IOException {
        System.out.println("服务端启动成功！");
        // 轮询访问selector
        while (true) {
            //当注册的事件到达时，方法返回；否则,该方法会一直阻塞
            selector.select();
            // 获得selector中选中的项的迭代器，选中的项为注册的事件
            Iterator<SelectionKey> ite = this.selector.selectedKeys().iterator();
            while (ite.hasNext()) {
                SelectionKey key = (SelectionKey) ite.next();
                // 删除已选的key,以防重复处理
                ite.remove();

                handler(key);
            }
        }
    }

    /**
     * 处理请求
     * @param key
     * @throws IOException
     */
    public void handler(SelectionKey key) throws IOException{
        // 客户端请求连接事件
        if (key.isAcceptable()) {
            handlerAccept(key);
            // 获得了可读的事件
        } else if (key.isReadable()) {
            handlerRead(key);
        }
    }


    /**
     * 处理新连接
     * @param key
     */
    public void handlerAccept(SelectionKey key) throws IOException{
        ServerSocketChannel server = (ServerSocketChannel) key
                .channel();
        // 获得和客户端连接的通道
        SocketChannel channel = server.accept();
        // 设置成非阻塞
        channel.configureBlocking(false);

        //在这里可以给客户端发送信息哦
        channel.write(ByteBuffer.wrap(new String("你好\n").getBytes()));
        //在和客户端连接成功之后，为了可以接收到客户端的信息，需要给通道设置读的权限。
        channel.register(this.selector, SelectionKey.OP_READ);

        System.out.println("来人了~~");
    }

    /**
     * 处理读取客户端发来的信息 的事件
     * @param key
     * @throws IOException
     */
    public void handlerRead(SelectionKey key) throws IOException {
        // 服务器可读取消息:得到事件发生的Socket通道
        SocketChannel channel = (SocketChannel) key.channel();

        // 创建缓冲区,读取数据
        int ret = 0;
        boolean failure = true;
        ByteBuffer buffer = ByteBuffer.allocate(1024);
        //防止出现异常
        try {
            ret = channel.read(buffer);
            failure = false;
        } catch (Exception e) {
            // ignore
        }
        //如果读取不到数据，或失败则取消key绑定
        if (ret <= 0 || failure) {
            key.cancel(); // Some JDK implementations run into an infinite loop without this.
            System.out.println("客户端关闭");
        } else {
            System.out.println("服务器端收到数据：" + new String(buffer.array()));

            //写数据
            ByteBuffer outBuffer = ByteBuffer.wrap("你好，收到了\n".getBytes());
            channel.write(outBuffer);// 将消息回送给客户端
        }
    }

}

client:

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

public class NIOClient {
    public static void main(String[] args) throws IOException {

        SocketChannel socketChannel = SocketChannel.open();
        socketChannel.configureBlocking(false);

        // 连接服务器
        if (!socketChannel.connect(new InetSocketAddress("127.0.0.1", 5000))) {
            while (!socketChannel.finishConnect()) {
                System.out.println("connecting...");
            }
        }
        //发送数据
        String str = "hello,伊木子曦";
        ByteBuffer byteBuffer = ByteBuffer.wrap(str.getBytes());
        socketChannel.write(byteBuffer);
        System.in.read();

    }
}

客户端我这没写接收数据。

3. 运行结果

在这里插入图片描述

三、Netty实现

1. Netty介绍

Netty是由JBOSS提供的一个java开源框架。Netty提供异步的、事件驱动的网络应用程序框架和工具，用以快速开发高性能、高可靠性的网络服务器和客户端程序。
也就是说，Netty 是一个基于NIO的客户，服务器端编程框架，使用Netty 可以确保你快速和简单的开发出一个网络应用，例如实现了某种协议的客户，服务端应用。Netty相当简化和流线化了网络应用的编程开发过程，例如，TCP和UDP的socket服务开发。

1.1 Netty特点

优雅的设计
统一的API接口，支持多种传输类型，例如OIO,NIO
简单而强大的线程模型
丰富的文档
卓越的性能
拥有比原生Java API 更高的性能与更低的延迟
基于池化和复用技术，使资源消耗更低
安全性
完整的SSL/TLS以及StartTLS支持
可用于受限环境，如Applet以及OSGI

比较适合客户端数据较大的请求/处理场景，参考https://netty.io/wiki/adopters.html

3. 配置netty

file->Project Structure
按序号选中
输入io.netty:netty-all
弹出对话框ok即可

在这里插入图片描述

3. 代码

server:
NettyServer.java

import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelOption;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;

public class NettyServer {
    public static void main(String[] args) throws Exception {
        //用于处理服务器端接受客户端连接的线程组
        NioEventLoopGroup bossGroup = new NioEventLoopGroup();
        //用于进行网络通讯（读写）的线程组
        NioEventLoopGroup workGroup = new NioEventLoopGroup();

        //创建辅助工具类，用于服务器通道的一系列的配置
        ServerBootstrap sb = new ServerBootstrap();
        sb.group(bossGroup,workGroup)//绑定两个线程组
                .channel(NioServerSocketChannel.class)//指定NIO的网络传输模式为TCP,UDP:NioDatagramChannel
                .option(ChannelOption.SO_BACKLOG,1024)//设置tcp缓冲
                .option(ChannelOption.SO_SNDBUF,32*1024)//设置发送缓冲大小
                .option(ChannelOption.SO_RCVBUF,32*1024)//设置接收缓冲大小
                .option(ChannelOption.SO_KEEPALIVE,true)//保持连接
                .childHandler(new ChannelInitializer<SocketChannel>() {
                    protected void initChannel(SocketChannel socketChannel) throws Exception {
                        socketChannel.pipeline().addLast(new ServerHandler());//这里配置具体数据接收方法的处理
                    }
                });

        ChannelFuture cf1 = sb.bind(5929).sync();//异步的绑定指定的端口
        ChannelFuture cf2 = sb.bind(5614).sync();//netty可以绑定多个端口

        cf1.channel().closeFuture().sync();//等待关闭，相当于Thread.sleep(Integer.MAX_VALUE)
        cf2.channel().closeFuture().sync();

        //关闭线程组
        bossGroup.shutdownGracefully();
        workGroup.shutdownGracefully();
    }

}

ServerHandler.java

import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelHandlerAdapter;
import io.netty.channel.ChannelHandlerContext;

public class ServerHandler extends ChannelHandlerAdapter {
    /**
     * 重写读数据时处理的方法
     * @param ctx
     * @param msg
     * @throws Exception
     */
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {

        ByteBuf buf = (ByteBuf) msg;

        //声明字节数组，buf.readableBytes()返回的是buf缓冲中可读的字节数
        byte[] req = new byte[buf.readableBytes()];
        //将buf缓冲区中的字节读取到字节数组req中
        buf.readBytes(req);
        String body = new String(req, "utf-8");
        System.out.println("Server接收：" + body);
        String response = "Serverd发送：" + body;

        //1.ctx.writeAndFlush()方法相当于连续调用了write()和flush()方法，因为write()方法只是将buf写到了渠道的缓冲区中，flush()方法会将缓冲区中的数据传给客户端
        //2.这里Unpooled工具类的作用就是讲字节数组转成netty的ByteBuf对象
        //3.这里使用了writeAndFlush()方法会自动释放buf缓冲区所以不需要想ClientHandler中那样finally中手动释放buf缓冲区了
        //4.addListener()方法：当监听到服务器将数据写给客户端，并且确认客户端已经收到信息后，
        // 服务器端就会主动去关闭跟客户端的连接，因为客户端调用了cf1.channel().closeFuture().sync()方法，所以客户端这里的阻塞就会打开，继续向后执行代码
        ctx.writeAndFlush(Unpooled.copiedBuffer(response.getBytes()));
//                .addListener(ChannelFutureListener.CLOSE);
    }

    /**
     * 重写读数据出现异常处理的方法
     * @param ctx
     * @param cause
     * @throws Exception
     */
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        ctx.close();
    }

}

client:
NettyClient.java

import io.netty.bootstrap.Bootstrap;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioSocketChannel;

public class NettyClient {
    public static void main(String[] args) throws Exception{

        NioEventLoopGroup group = new NioEventLoopGroup();//用于处理网络通信（读写）的线程组

        Bootstrap b = new Bootstrap();//创建客户端辅助类工具
        b.group(group)//绑定线程组
                .channel(NioSocketChannel.class)//设置通信渠道为TCP协议
                .handler(new ChannelInitializer<SocketChannel>() {
                    protected void initChannel(SocketChannel socketChannel) throws Exception {
                        socketChannel.pipeline().addLast(new ClientHandler());//这里配置具体数据接收方法的处理
                    }
                });

        /*与8787端口通讯*/
        ChannelFuture cf1 = b.connect("127.0.0.1", 5929).sync();//异步建立连接

        cf1.channel().write(Unpooled.copiedBuffer("伊木子曦".getBytes()));//将“hello world”写到buf缓冲区
        cf1.channel().flush();//这里必须使用flush(),只用冲刷才能将buf缓冲区中的数据传给服务器端

        /*与8686端口通讯*/
        ChannelFuture cf2 = b.connect("127.0.0.1", 5614).sync();
        cf2.channel().writeAndFlush(Unpooled.copiedBuffer("hello netty".getBytes()));

        cf1.channel().closeFuture().sync();//等待关闭，相当于Thread.sleep(Integer.MAX_VALUE)
        cf2.channel().closeFuture().sync();

        group.shutdownGracefully();//关闭线程组
    }

}

ClientHandler.java

import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandlerAdapter;
import io.netty.channel.ChannelHandlerContext;
import io.netty.util.ReferenceCountUtil;

public class ClientHandler extends ChannelHandlerAdapter {
    /**
     * 重写读数据时处理的方法
     * @param ctx
     * @param msg
     * @throws Exception
     */
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        try {
            ByteBuf buf = (ByteBuf) msg;

            //声明字节数组，buf.readableBytes()返回的是buf缓冲中可读的字节数
            byte[] req = new byte[buf.readableBytes()];
            buf.readBytes(req);
            String body = new String(req, "utf-8");
            System.out.println("Client接收：" + body);

        }finally {
            ReferenceCountUtil.release(msg);//buf缓冲区使用完了，必须释放
        }

    }

    /**
     * 重写读数据出现异常处理的方法
     * @param ctx
     * @param cause
     * @throws Exception
     */
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        ctx.close();
    }
}