1 Netty 网络高并发框架

纯手打,总结!

Netty是什么?

Netty是当前非常流行的网络通讯开源框架,高并发和高可靠,底层就可以用Netty支撑。

Netty 官网:https://netty.io/

学习视频:https://www.bilibili.com/video/BV1DJ411m7NR?from=search&seid=17854453460358540907

Netty 特点

异步、基于事件驱动的网络应用架构

快速开发高性能、高可用的 IO 程序

针对 TCP/IP 协议下 面向Client端 高并发应用

本质是NIO框架,适用于服务器通讯的多种场景

什么是同步 和 异步

同步: 浏览器发送请求,等待服务端进行相应后浏览器在做操作 这个过程就叫同步

异步:浏览器发送请求,无需服务器响应出结果,继续浏览器渲染接下来的操作,这个过程就叫异步

Netty 结构图

Netty 是基于 JDK下的NIO 的框架

Netty 场景

RPC框架 :阿里的分布式框架Dubbo用到了

手游、网游服务器

可以理解成PRC框架 都会

I/O模型

I/O模型简单理解:就是用什么样的通道进行数据的发送和接收,很大程度决定程序的性能

Java支持3中网络编程模型:BIO、NIO、AIO

什么是BIO?

特点:同步并阻塞、一个连接一个线程:即客户端有连接请求,服务端就开一个线程,如果客户端连接了服务器不操作,就会造成服务端线程的浪费。阻塞:如果没有读取到,那就一直等待。

什么NIO?

特点:同步非阻塞、一个线程处理多个连接:即客户端发送的连接请求都会转到多路复用器上,进行轮询检查连接状态,进行处理,避免连接闲置。提高服务器资源的不必要开支。

什么是AIO?

特点 NIO.2 异步非阻塞,AIO 引入异步通道概念,采用Proactor,简化程序编写,有效的请求,才会启动线程。现在暂时并没有有效的应用。

I/O模型使用场景

BIO:适用于连接数目少且固定的架构,高并发不适用,是JDK1.4之前唯一选择

NIO:适用于连接数目多,但是连接短。JDK1.4 开始支持。场景有:聊天服务器、弹幕服务器、地图服务器之间的通讯。

AIO:适用于连接数目多,连接长。比如相册服务器(这里不理解)。会利用OS惨与并发操作,编程较为复杂。JDK7开始支持

JAVA BIO 基本介绍

BIO :blocking I/O 同步阻塞 实现类和接口在 java.io

编程的简单流程

  1. 服务器端启动一个ServerSocket。
  2. 客户端启动一个Secork 连接服务器,默认情况下,服务器端需要对每个客户建立一个线程与之通讯。
  3. 客户端发出请求,先咨询服务器是否有线程响应,如果没有则会等待,或者被拒绝。
  4. 如果有相应,客户端线程会等待请求结束后,才继续执行。

BIO 应用实例

实例说明:使用BIO模型编写一个服务器端,使用6666端口,客户端连接时,就启动一个线程与之通讯。

要求使用线程池机制改善,可以连接多个客户端

服务器端可以接收客户端发送的数据(telnet 方式即可)

测试方式 需要安装的内容

代码实现

package com.zlk.BIO;

import java.io.IOException;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class bioServer {
    public static void main(String[] args) throws IOException {
        /* 线程池机制  思路
        1、创建一个线程池
        2、如果有客户端连接,就创建一个线程,与之通讯
        */

        // 具体实现
        ExecutorService newCachedThreadPool = Executors.newCachedThreadPool();
        //创建ServerSocket
        ServerSocket serverSocket = new ServerSocket(6666);
        System.out.println("服务端已经启动了");

        while (true) {
            // 监听,等待客户端连接
            final Socket socket = serverSocket.accept();
            System.out.println("连接到一个客户端...");
            // 创建一个线程 与之通讯
            newCachedThreadPool.execute(new Runnable() {
                public void run() {
                    // 可以和客户端通讯了
                    handler(socket);
                }
            });
        }
    }

    // handler方法与客户端通讯
    public static void handler(Socket socket) {
        try {
            System.out.println("线程ID:" + Thread.currentThread().getId() + " 线程名称:" + Thread.currentThread().getName());
            byte[] bytes = new byte[1024];
            // 通过socket获取输入流
            InputStream inputStream = socket.getInputStream();
            while (true) {
                System.out.println("等待发送信息...");
                int read = inputStream.read(bytes);
                if (read != -1) {
                    System.out.print("执行Read ... -->");
                    System.out.print("线程ID:" + Thread.currentThread().getId() + " 线程名称:" + Thread.currentThread().getName() + " 输入了:");
                    System.out.println(new String(bytes, 0, read)); //输出客户端发送的数据
                } else {
                    break;
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            System.out.println("关闭 和 cilent的连接");
            try {
                socket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

测试:

按一下 Ctrl + ] 键 ,然后输入命令 send XXXXX 回车 就可以按照一长串输入

控制台结果

Java NIO 编程

JDK 在1.4之后 追加 在java.nio包 及其子包下,并对java.io包很多类进行改写

NIO 三大核心部分

  • Channel(通道)
  • Buffer(缓冲区)
  • Selector(选择器)

具体三者结构逻辑

NIO 是面向缓冲区,或者面向块编程。数据读取到一个 稍后处理的缓冲区,需要时可在缓冲器中前后移动,提高了网络处理过程的灵活性、伸缩性

Http2.0 引入的多路复用技术,做到一个连接处理多个请求,并发请求数量提高很多倍

NIO Buff基本使用

import java.nio.IntBuffer;

/*
    举例说明Buffer的使用
 */
public class basicBuffer {
    public static void main(String[] args) {
        // 创建一个Buffer:可以存放5个int
        IntBuffer intBuffer = IntBuffer.allocate(5);
        // 向Buffer 存放数据 有序
        intBuffer.put(10);
        intBuffer.put(11);
        intBuffer.put(12);
        intBuffer.put(13);
        intBuffer.put(14);

        // 从Buffer读取数据
        // 将Buffer转换:读写切换 ,默认是写
        intBuffer.flip();
        while (intBuffer.hasRemaining()){
            System.out.println(intBuffer.get());
        }
    }
}

NIO BIO 对比

BIO 是以流的方式 进行处理数据,NIO以块的方式处理数据。块I/O比流I/O效率高很多。

BIO 是同步阻塞、NIO是同步非阻塞

BIO基于 字节、字符流进行操作、NIO基于 Channel、Buffer 进行操作。

NIO 原理分析

NIO是 数据从Buffer 传输到 Channel 再通过 Selector监听很多个Channel事件,所以 单个线程 就做到了非阻塞

NIO 中 一个 Buffer 对应一个Channel,一个Selector 对应多个 Channel 。一个Selector 对应一个线程,

程序切换到那个 Channel 取决于 事件。

Selector会根据不同 Event事件,在各个Channel切换

Buffer就是一个内存块,底层是一个数组

数据读取、写入都是要通过Buffer,这个和BIO有区别(BIO 无Buffer)

BIO 是单向流,而NIO传输Buffer是双向的,需要手动 filp() 切换。

Channel也是双向的,可以很好的反应底层操作系统情况。例如:Linux 。

Buffer

本质就是一个读写数据的内存块,可以理解成一个容器

我们可以点进 java.nio包下的 Buffer 按一下 Alt + H 看到

同时上图 有 4个属性,具体含义如下:


    // Invariants: mark <= position <= limit <= capacity
    private int mark = -1;   // 标记
    private int position = 0;//下一个要被 读或写 元素的索引(每次读或写都会变化):作用是 为下一次读或写做准备
    private int limit;      // 缓冲区终点
    private int capacity;   // 容量

先看一下 反转的方法 flip 仔细看

在看一下 clear的 内容

用的最多的子类是 ByteBuffer,因为网络传输是以字节形式传输,下面会详细讲解

通道 Channel

NIO的Channel类似于流 通道与流的区别

通道可以同时写或读,而流是单向的

常见的 通道 方法 Channel(下面方法经常需要复习)

FileChannel 常用方法:

read(ByteBuffer dst) 从通道读取数据放入缓冲 buffer 区

write(ByteBuffer src) 把缓冲区的数据写道通道

transferFrom(ReadableByteChannel src, long position, long count) 从目标通道复制到当前通道

transferTo(long position, long count, WritableByteChannel target) 把数据从当前通道复制给目标通道。

Channel应用实例1 – 写进文件

实例要求:使用ByteBuffer 和 FileChannel 将Hello 世界,写入 file01.txt中,如果文件不存在,就创建。

代码

import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;

public class NIOFileChannel {
    public static void main(String[] args) throws IOException {
        String str = "hello 世界";

        //创建输出流 包装到Channel
        FileOutputStream fileOutputStream = new FileOutputStream("d:\\file01.txt");
        //通过fileOutputStream 整合FileChannel  但是真实的实现是 FileChannelImpl 所有的真实实现都是 XXXImpl
        FileChannel fileChannel = fileOutputStream.getChannel();

        //创建一个缓冲区
        ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
        //数据放入缓存区
        byteBuffer.put(str.getBytes());

        //写完后 开始反转 开始读
        byteBuffer.flip();
        //将byteBuffer 写入到Channel
        fileChannel.write(byteBuffer);
        fileOutputStream.close();
    }
}

结果

Channel应用实例2 – 读取文件

实验实例:读取上个实例

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;

public class NIOFileChannel2 {
    public static void main(String[] args) throws IOException {
        // 得到文件对象
        File file = new File("d:\\file01.txt");
        // 创建文件输入流
        FileInputStream fileInputStream = new FileInputStream(file);
        // 根据文件输入流创建通道
        FileChannel channel = fileInputStream.getChannel();
        // 获取缓冲区,因为知道文件长度,就没必要设置1024
        ByteBuffer byteBuffer = ByteBuffer.allocate((int) file.length());
        // 通道读取缓冲区数据
        channel.read(byteBuffer);
        // 将byteBuffer的字节数据转为String
        System.out.println(new String(byteBuffer.array()));
        // 释放输入流资源
        fileInputStream.close();
    }
}

结果:

Channel应用实例3 – 复制文件

案例要求: 复制文件内容 放到一个新文件

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;

public class NIOFileChannel3 {
    public static void main(String[] args) throws IOException {
        FileInputStream fileInputStream = new FileInputStream("d:\\file01.txt");
        FileChannel channelIn = fileInputStream.getChannel();
        FileOutputStream fileOutputStream = new FileOutputStream("d:\\file02.txt");
        FileChannel channelOut = fileOutputStream.getChannel();

        ByteBuffer byteBuffer = ByteBuffer.allocate(512);
        // 开始读取数据
        while (true){
            //重置Buffer属性  不加就会死循环
            byteBuffer.clear();
            int read = channelIn.read(byteBuffer);
            System.out.println("read is "+read);
            if(read == -1){
                break;
            }else {
                byteBuffer.flip();
                channelOut.write(byteBuffer);
            }
        }
        System.out.println("文件复制成功");
        fileOutputStream.close();
        fileInputStream.close();
    }
}

不加clear 会造成死循环 产生的原因 分析:

read(Buffer) 返回的是读取的行数结果

read 一开始从 position = 0 开始读取 一致读到 limit 此时 position 变为最后读取的最后一位

以后 不论怎么样 read 或 write 都是从 position = limit 只有 flip执行 将 position = 0,才读取第一次的内容,并且写入,会就造成文件一些被写入第一次写入的内容,并且不换行!

正常代码最终结果:

Channel应用实例3 – 通道复制文件

实例要求:使用FileChannel的transferFrom() 完成文件拷贝

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.channels.FileChannel;

public class NIOFileChannel4 {
    public static void main(String[] args) throws IOException {
        // 创建流 以及 相关通道
        FileInputStream fileInputStream = new FileInputStream("d:\\java.png");
        FileChannel channelIn = fileInputStream.getChannel();
        FileOutputStream fileOutputStream = new FileOutputStream("d:\\java2.png");
        FileChannel channelOut = fileOutputStream.getChannel();

        // 使用transferFrom 完成拷贝
        channelOut.transferFrom(channelIn,0,channelIn.size());
        System.out.println("拷贝完成");

        // 释放资源
        channelOut.close();
        channelIn.close();
        fileOutputStream.close();
        fileInputStream.close();
    }
}

结果:

Buffer类型化 与 只读

import java.nio.ByteBuffer;

public class ReadOnlyBuffer {
    public static void main(String[] args) {
        //创建BUffer
        ByteBuffer byteBuffer = ByteBuffer.allocate(64);
        //循环添加
        for (int i = 0; i < 64; i++) {
            // byteBuffer.putInt((byte) i); // 记得 int 转成 byte 他依旧占用4个字节
            byteBuffer.put((byte)i);    // 一开始 就是byte 就是1字节了
        }
        //反转去读取
        byteBuffer.flip();
        //获取只读buffer
        ByteBuffer readOnlyBuffer = byteBuffer.asReadOnlyBuffer();
        //读取
        while (readOnlyBuffer.hasRemaining()) {
            System.out.println(readOnlyBuffer.get());
        }
        // java.nio.ReadOnlyBufferException 一旦设置只读后 就不能在添加数据了    readOnlyBuffer.put((byte) 1);
    }
}

Buffer 分散与聚合

Scattering :将数据写入到Buffer。 可以采用buffer数组,依次写入(一个buffer写满了 写入到第二个buffer)

Gathering :从buffer读取数据时。可以采用buffer数组,依次读取()

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

/**
 * Scattering:将数据写入到Buffer。 可以采用buffer数组,依次写入(一个buffer写满了 写入到第二个buffer)
 * Gathering:从buffer读取数据时。可以采用buffer数组,依次读取()
 */
public class ScatteringAndGatheringTest {
    public static void main(String[] args) throws IOException {
        // 使用ServerSocketChannel 和 SockerChannel
        ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();

        InetSocketAddress inetSocketAddress = new InetSocketAddress(7000);

        serverSocketChannel.socket().bind(inetSocketAddress);
        ByteBuffer[] byteBuffers = new ByteBuffer[2];
        // 第一个5 放满了 就会转到 第二个去放
        byteBuffers[0] = ByteBuffer.allocate(5);
        byteBuffers[1] = ByteBuffer.allocate(3);
        System.out.println("服务器已经启动");
        // 等待客户端连接
        SocketChannel socketChannel = serverSocketChannel.accept();
        // 规定只从客户端读取8字节
        int messageLength = 8;
        while (true) {
            int byteRead = 0;
            if (byteRead < messageLength) {
                long read = socketChannel.read(byteBuffers);
                byteRead += read; // 累计读取的字节数
                System.out.println("本地读取了" + byteRead + "个字节");
                // 使用流打印,看看当前buffer的 position 和 limit
                Arrays.asList(byteBuffers).stream().map(buffer -> "position is " + buffer.position() + ",limit is " + buffer.limit()).forEach(System.out::println);
            }
            //将所有的buffer 进行反转
            Arrays.asList(byteBuffers).forEach(byteBuffer -> {
                byteBuffer.flip();
            });

            //将数据显示到客户端
            long bytewrite = 0;
            while (bytewrite < messageLength){
                long write = socketChannel.write(byteBuffers);
                bytewrite += write;
            }
            // 将所有的Buffer进行clear 操作
            Arrays.asList(byteBuffers).forEach(byteBuffer -> {byteBuffer.clear();});
            System.out.println("byteRead is "+byteRead+" ,bytewrite is  "+bytewrite+" messageLength is "+messageLength);
        }


    }
}

测试

Selector

Selector 是个抽象类,常用方法和说明如下:

常用方法

open 得到一个选择器对象

selectorKeys 从内部集合 获取所有sekectorkey

selector(1000) 设置阻塞时间1秒

wakeup() 唤醒selector

selectorNow() 自动返回 不会阻塞

NIO 非阻塞网络编程快速入门

案例要求: 编写一个NIO入门案例,实现服务器端与客户端之间的数据简单通讯(非阻塞)

目的:理解NIO非阻塞网络编程机制

服务端

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.*;
import java.util.Iterator;
import java.util.Set;

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

        //创建ServerScocketChannle 并获取 ServerSocker
        ServerSocketChannel channel = ServerSocketChannel.open();
        //创建Selector对象
        Selector selector = Selector.open();
        //让 ServerSocker 绑定6666端口,并在服务器端监听
        channel.socket().bind(new InetSocketAddress(6666));
        //ServerSocker 设置为非阻塞
        channel.configureBlocking(false);
        //把ServerSocker注册到 selector关心的事件 用枚举 SelectionKey.XXXX
        channel.register(selector, SelectionKey.OP_ACCEPT);
        //循环等待客户端连接
        while (true){
            if(selector.select(1000) == 0){ //等待1秒
                System.out.println("服务器等待1秒 没有响应");
                continue;
            }
            //如果返回值>0 就去获取关住SelecotrKeys ,以便于便利出 selectorkey获取通道
            Set<SelectionKey> selectionKeys = selector.selectedKeys();
            Iterator<SelectionKey> iterator = selectionKeys.iterator();
            while (iterator.hasNext()){
                SelectionKey key = iterator.next();
                if(key.isAcceptable()){ //如果是OP_ACCEPT ,有新的客户端连接
                    //为客户端生成一个Socket
                    SocketChannel newsocketChannel = channel.accept();
                    //为新客户端设置非阻塞状态
                    newsocketChannel.configureBlocking(false);
                    System.out.println("客户端连接成功 生成一个"+newsocketChannel.hashCode());
                    //将新的socket 注册到 Selecotr上
                    newsocketChannel.register(selector,SelectionKey.OP_READ, ByteBuffer.allocate(1024));
                }
                if(key.isReadable()) { //发生如果是 OP_READ
                    //通过key获取channel
                    SocketChannel newchannel2 = (SocketChannel)key.channel();
                    //获取该channel绑定的buffer
                    ByteBuffer byteBuffer = (ByteBuffer)key.attachment();
                    newchannel2.read(byteBuffer);
                    System.out.println("从客户端读取到的数据是"+new String(byteBuffer.array()));
                }
                //手动从集合移动当前的SelectionKey ,防止重复操作
                iterator.remove();
            }

        }

    }
}

客户端

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);
        //设置服务器的ip和端口
        InetSocketAddress inetSocketAddress = new InetSocketAddress("127.0.0.1", 6666);
        //连接服务器
        if (!socketChannel.connect(inetSocketAddress)) {
            while (!socketChannel.finishConnect()) {
                System.out.println("连接服务器需要时间,客户端不会阻塞,仍可以做其他工作");
            }
        }
        String str = "Hello 张三";
        //wrap放法是将Byte数组 写入到一个buffer
        ByteBuffer byteBuffer = ByteBuffer.wrap(str.getBytes());
        //发送数据,将buffer数据写入通道channle
        int write = socketChannel.write(byteBuffer);
        System.in.read();
    }
}

在客户端编码设置一下允许并行运行 并应用

最终结果:

Netty 群聊系统

要求:

编写一个NIO群聊系统,实现服务器与客户端之间的数据简单通讯,

实现多人群聊

服务端检测用户上线、离线,并实现消息转发功能

客户端,通过Channle 无阻塞发送消息给其他用户,同时可以接收其他用户发送的消息(由服务器转发)

先编写服务器端

  • 服务器启动并监听6667
  • 服务器接收客户端消息,实现转发,上下线等
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.*;
import java.util.Iterator;
import java.util.Set;

public class chatServer {
    //1 定义属性
    private Selector selector;
    private ServerSocketChannel listenChannle;
    private static final int PORT = 6667;

    //2 无参构造 对属性进行赋值
    public chatServer() {
        try {
            //创建选择器
            selector = Selector.open();
            //创建通道
            listenChannle = ServerSocketChannel.open();
            //通道道绑创建的Socket 定端口
            listenChannle.socket().bind(new InetSocketAddress(PORT));
            //设置非阻塞
            listenChannle.configureBlocking(false);
            //将通道注册到Selector 监听事件
            listenChannle.register(selector, SelectionKey.OP_ACCEPT);

        } catch (
                IOException e) {
            e.printStackTrace();
        }

    }

    public void listen() {
        try {
            while (true) {
                // 如果count > 0 说明有事件
                int count = selector.select(2000);
                if (count > 0) {
                    Set<SelectionKey> selectionKeys = selector.selectedKeys();
                    Iterator<SelectionKey> iterator = selectionKeys.iterator();
                    while (iterator.hasNext()) {
                        SelectionKey key = iterator.next();
                        // 通道发生连接事件
                        if (key.isAcceptable()) {
                            SocketChannel sc = listenChannle.accept();
                            sc.configureBlocking(false);
                            //将改sc 注册到 selector
                            sc.register(selector, SelectionKey.OP_READ);
                            System.out.println(sc.getRemoteAddress() + " 已经上线了");
                        }
                        // 通道发生Read事件
                        if (key.isReadable()) {
                            //处理读 专门写方法
                            readData(key);
                        }
                        // 将当前的key删除,防止重复处理
                        iterator.remove();
                    }
                } else {
                    System.out.println("等待中...");
                }
            }
        } catch (
                Exception e) {
            e.printStackTrace();
        } finally {
        }
    }

    // 读取客户端消息 传递 selectionKey的原因是 通过key 获取事件发生的通道
    private void readData(SelectionKey selectionKey) {
        //定义一个SocketChannel
        SocketChannel socketChannel = null;
        try {
            socketChannel = (SocketChannel) selectionKey.channel();
            socketChannel.configureBlocking(false);
            ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
            int count = socketChannel.read(byteBuffer);
            //根据count的值做处理
            if (count > 0) {
                //把缓冲区的数据转成String
                String s = new String(byteBuffer.array());
                System.out.println("客户端消息是:" + s);
                //向其他客户端发送消息 专门写一个方法处理
                sendInfoToOtherClients(s, socketChannel);
            }

        } catch (IOException e) {
            //e.printStackTrace();
            try {
                System.out.println(socketChannel.getRemoteAddress() + "离线了");
                // 关闭通道
                socketChannel.close();
            } catch (IOException e2) {
                e2.printStackTrace();
            }
        }
    }

    // 转发消息给其他客户(通道) 参数 msg是消息
    private void sendInfoToOtherClients(String msg, SocketChannel self) throws IOException {
        System.out.println("服务器转发消息中");
        // 获取所有注册到Selector的所有通道 并派出self
        for (SelectionKey key : selector.keys()) {
            //通过 key去除对应的通道
            Channel targetchannel = key.channel();
            //排除自己
            if (targetchannel instanceof SocketChannel && targetchannel != self) {
                // 转型
                SocketChannel dest = (SocketChannel) targetchannel;
                dest.configureBlocking(false);
                // 将msg存储到buffer
                ByteBuffer buffer = ByteBuffer.wrap(msg.getBytes());
                // 将buffer写入通道
                dest.write(buffer);
            }
        }
    }

    public static void main(String[] args) {
        //创建一个服务器对象
        chatServer chatServer = new chatServer();
        //开始监听
        chatServer.listen();
    }
}

再编写客户端

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

public class chatClient {
    // 定义一下全局变量
    private static final String Host = "127.0.0.1";
    private static final int PORT = 6667;
    private Selector selector;
    private SocketChannel socketChannel;
    private String username;

    // 构造器赋值
    public chatClient() {
        try {
            selector = selector.open();
            socketChannel = SocketChannel.open(new InetSocketAddress(Host, PORT));
            // 设置非阻塞
            socketChannel.configureBlocking(false);
            // 将通道注册到服务器
            socketChannel.register(selector, SelectionKey.OP_READ);
            username = socketChannel.getRemoteAddress().toString().substring(1);
            System.out.println("客户端准备好了");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    //向服务器发送消息
    public void sendInfo(String info) {
        try {
            info = username + " 说 " + info;
            socketChannel.write(ByteBuffer.wrap(info.getBytes()));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    //从服务器端读取数据
    public void readInfo() {
        try {
            int readChannle = selector.select();
            // 通道有事件发生了
            if (readChannle > 0) {
                Set<SelectionKey> selectionKeys = selector.selectedKeys();
                Iterator<SelectionKey> iterator = selectionKeys.iterator();
                while (iterator.hasNext()) {
                    SelectionKey key = iterator.next();
                    if (key.isReadable()) {
                        SocketChannel sc = (SocketChannel) key.channel();
                        //设置非阻塞
                        sc.configureBlocking(false);
                        ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
                        // 将通道数据写入buffer
                        sc.read(byteBuffer);
                        //将缓冲区的数据 转成字符串
                        String s = new String(byteBuffer.array());
                        System.out.println(s.trim());
                    }else {
                        System.out.println("没有可以读取消息的通道");
                    }
                    iterator.remove();
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        // 启动客户端
        chatClient chatClient = new chatClient();
        // 开启一个新线程 读取客户端 发送、转发的消息
        new Thread(){
            public void run(){
                while (true){
                    chatClient.readInfo();
                    try {
                        // 不知道为什么这里没有代码提示
                        Thread.currentThread().sleep(3000);
                    }catch (Exception e){
                        e.printStackTrace();
                    }
                }
            }
        }.start();

        // 发送数据 给客户端
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNext()){
            String s = scanner.nextLine();
            // 将控制台结果发送给服务器
            chatClient.sendInfo(s);
        }
    }
}

本片文章过长,后续内容请查看 Netty2 https://www.zanglikun.com/3840.html

还是那句话,你只看到了大佬轻松解决问题的光鲜,却不记得当初人家死磕Bug的痛苦。

万物皆入轮回,谁也躲不掉!

以上文章,均是我实际体验,写出来的笔记资料,不会出现全文盗用别人文章!烦请各位,支持下原创,请勿直接盗用,有条件的可以开通个会员支持下,谢谢!!!

Java Code Study » 1 Netty 网络高并发框架

招聘、单纯问问题,都可以联系我

加我QQ 公司缺人,拉我入伙