Netty学习笔记十二、NIO 网络编程应用-群聊系统代码实现

最新推荐文章于 2024-04-16 16:30:11 发布
最新推荐文章于 2024-04-16 16:30:11 发布
阅读量176 收藏 1
点赞数
分类专栏： 0805【Netty】
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40996741/article/details/106201136
版权

一、服务端

package com.hao.demo.netty.groupchat;

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

/**
 * @author haoxiansheng
 * @date 2020-05-18
 */
public class GroupChatServer {

    // 定义属性
    private Selector selector = null;

    private ServerSocketChannel listenChannel;

    private static final int PORT = 6667;

    // 构造器 完成初始化工作
    public GroupChatServer() {
        try {
            // 得到选择器
            selector = Selector.open();
            // ServerSocketChannel
            listenChannel = ServerSocketChannel.open();
            // 绑定端口
            listenChannel.socket().bind(new InetSocketAddress(PORT));
            // 设置非阻塞模式
            listenChannel.configureBlocking(false);
            // 将listenChannel 注册到selector上
            listenChannel.register(selector, SelectionKey.OP_ACCEPT);

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


    // 监听
    public void listen() {
        try {

            // 循环处理
            while (true) {
                int count = selector.select(2000);
                if (count > 0) { // 说明有事件处理
                    // 遍历selectionKeys
                    Iterator<SelectionKey> iterator = selector.selectedKeys().iterator();
                    while (iterator.hasNext()) {
                        // 取出selectionKey
                        SelectionKey key = iterator.next();
                        // 监听到accept
                        if (key.isAcceptable()) {
                            SocketChannel socketChannel = listenChannel.accept();
                            // 设置非阻塞模式
                            socketChannel.configureBlocking(false);
                            // 将socketChannel注册到selector
                            socketChannel.register(selector, SelectionKey.OP_READ);
                            // 提示
                            System.out.println(socketChannel.getRemoteAddress() + "上线");
                        }
                        if (key.isReadable()) { // 通道发生读事件，通道可读
                            // 处理读 (专门处理这个逻辑)
                            readData(key);
                        }

                        // 将当前的key 删除防止从新操作
                        iterator.remove();
                    }

                } else {
                    System.out.println("等待中。。。。。");
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {

        }
    }

    // 读取客户端消息
    private void readData(SelectionKey key) {
        // 定义一个SocketChannel
        SocketChannel socketChannel = null;
        try {
            // 得到channel
            socketChannel = (SocketChannel) key.channel();

            // 创建buffer
            ByteBuffer buffer = ByteBuffer.allocate(1024);

            int count = socketChannel.read(buffer);

            // 根据count的值做处理
            if (count > 0) {
                // 把缓冲区的数据转成字符串 输出信息
                String msg = new String(buffer.array());
                System.out.println("from 客户端" + msg);

                // 向其他的客户端转发消息(去掉自己),专门写一个方法来处理
                sendToOtherClient(msg, socketChannel);
            }

        } catch (IOException e) {
            try {
                System.out.println(socketChannel.getRemoteAddress() + "离线");
                // 取消注册
                key.cancel();
                // 关闭通道
                socketChannel.close();
            } catch (IOException e1) {
                e1.fillInStackTrace();
            }

        }

    }


    // 转发消息到其他客户端
    private void sendToOtherClient(String msg, SocketChannel self) throws IOException {

        System.out.println("服务器转发消息");
        // 遍历所有注册到selector 上的SocketChannel 并排除自己

        for (SelectionKey key : selector.keys() ) {
            // 通过key 取出对应的SocketChannel
            Channel targetChannel = key.channel();
            // 排除自己
            if (targetChannel instanceof SocketChannel && targetChannel != self) {

                // 转型
                SocketChannel dest = (SocketChannel) targetChannel;
                // 将信息存储到buffer
                ByteBuffer buffer = ByteBuffer.wrap(msg.getBytes());
                // 将buffer 的数据写入通道
                dest.write(buffer);
            }
        }

    }

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

    }
}

二、客户端

 

由于我自己idea 一个client不能启动多次 所以自己创建了三个一样方法的类。

1、client1

package com.hao.demo.netty.groupchat;

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.SocketChannel;
import java.util.Iterator;
import java.util.Scanner;

/**
 * @author haoxiansheng
 * @date 2020-05-18
 */
public class GroupChatClient {

    private final String HOST = "127.0.0.1"; // 服务器地址

    private final int PORT = 6667; // 端口

    private Selector selector;

    private SocketChannel socketChannel;

    private String userName;

    public GroupChatClient() throws IOException {
        selector = Selector.open();

        // 连接服务器
        socketChannel = SocketChannel.open(new InetSocketAddress(HOST, PORT));

        // 设置非阻塞
        socketChannel.configureBlocking(false);

        // 将socketChannel 注册到selector
        socketChannel.register(selector, SelectionKey.OP_READ);

        // 得到userName
        userName = socketChannel.getLocalAddress().toString().substring(1);

        System.out.println("客户端准备好了");
    }

    // 向服务器发送消息
    public void sendInfo(String info) {
        info = userName + "say" + info;
        try {
            socketChannel.write(ByteBuffer.wrap(info.getBytes()));
        } catch (IOException e) {
            e.fillInStackTrace();
        }
    }

    // 从服务器回复的消息
    public void readInfo() {
        try {
            int readChannel = selector.select();
            if (readChannel > 0) { // 有可用通道

                Iterator<SelectionKey> iterator = selector.selectedKeys().iterator();
                while (iterator.hasNext()) {
                    SelectionKey key = iterator.next();
                    if (key.isReadable()) {
                        // 得到相关通道
                        SocketChannel socketChannel = (SocketChannel) key.channel();
                        // 得到一个buffer
                        ByteBuffer buffer = ByteBuffer.allocate(1024);
                        // 读取
                        socketChannel.read(buffer);
                        String msg = new String(buffer.array());
                        System.out.println(msg.trim());
                    }
                }
                iterator.remove(); //删除当前的SelectionKey 防止重复操作
            } else {
                //System.out.println("没有可用的通道");

            }

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

        }
    }

    public static void main(String[] args) throws IOException {
        // 启动客户端
        GroupChatClient chatClient = new GroupChatClient();

        // 启动一个线程
        new Thread(() -> {
            while (true) {
                chatClient.readInfo();
                try {
                    Thread.currentThread().sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();

        // 发送数据
        Scanner scanner = new Scanner(System.in);

        while (scanner.hasNextLine()) {
            String msg = scanner.nextLine();
            chatClient.sendInfo(msg);
        }
    }


}

2、client2

package com.hao.demo.netty.groupchat;

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.SocketChannel;
import java.util.Iterator;
import java.util.Scanner;

/**
 * @author haoxiansheng
 * @date 2020-05-18
 */
public class GroupChatClient2 {

    private final String HOST = "127.0.0.1"; // 服务器地址

    private final int PORT = 6667; // 端口

    private Selector selector;

    private SocketChannel socketChannel;

    private String userName;

    public GroupChatClient2() throws IOException {
        selector = Selector.open();

        // 连接服务器
        socketChannel = SocketChannel.open(new InetSocketAddress(HOST, PORT));

        // 设置非阻塞
        socketChannel.configureBlocking(false);

        // 将socketChannel 注册到selector
        socketChannel.register(selector, SelectionKey.OP_READ);

        // 得到userName
        userName = socketChannel.getLocalAddress().toString().substring(1);

        System.out.println("客户端准备好了");
    }

    // 向服务器发送消息
    public void sendInfo(String info) {
        info = userName + "say" + info;
        try {
            socketChannel.write(ByteBuffer.wrap(info.getBytes()));
        } catch (IOException e) {
            e.fillInStackTrace();
        }
    }

    // 从服务器回复的消息
    public void readInfo() {
        try {
            int readChannel = selector.select();
            if (readChannel > 0) { // 有可用通道

                Iterator<SelectionKey> iterator = selector.selectedKeys().iterator();
                while (iterator.hasNext()) {
                    SelectionKey key = iterator.next();
                    if (key.isReadable()) {
                        // 得到相关通道
                        SocketChannel socketChannel = (SocketChannel) key.channel();
                        // 得到一个buffer
                        ByteBuffer buffer = ByteBuffer.allocate(1024);
                        // 读取
                        socketChannel.read(buffer);
                        String msg = new String(buffer.array());
                        System.out.println(msg.trim());
                    }
                }
                iterator.remove(); //删除当前的SelectionKey 防止重复操作
            } else {
                //System.out.println("没有可用的通道");

            }

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

        }
    }

    public static void main(String[] args) throws IOException {
        // 启动客户端
        GroupChatClient2 chatClient = new GroupChatClient2();

        // 启动一个线程
        new Thread(() -> {
            while (true) {
                chatClient.readInfo();
                try {
                    Thread.currentThread().sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();

        // 发送数据
        Scanner scanner = new Scanner(System.in);

        while (scanner.hasNextLine()) {
            String msg = scanner.nextLine();
            chatClient.sendInfo(msg);
        }
    }


}

3、client3

package com.hao.demo.netty.groupchat;

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.SocketChannel;
import java.util.Iterator;
import java.util.Scanner;

/**
 * @author haoxiansheng
 * @date 2020-05-18
 */
public class GroupChatClient3 {

    private final String HOST = "127.0.0.1"; // 服务器地址

    private final int PORT = 6667; // 端口

    private Selector selector;

    private SocketChannel socketChannel;

    private String userName;

    public GroupChatClient3() throws IOException {
        selector = Selector.open();

        // 连接服务器
        socketChannel = SocketChannel.open(new InetSocketAddress(HOST, PORT));

        // 设置非阻塞
        socketChannel.configureBlocking(false);

        // 将socketChannel 注册到selector
        socketChannel.register(selector, SelectionKey.OP_READ);

        // 得到userName
        userName = socketChannel.getLocalAddress().toString().substring(1);

        System.out.println("客户端准备好了");
    }

    // 向服务器发送消息
    public void sendInfo(String info) {
        info = userName + "say" + info;
        try {
            socketChannel.write(ByteBuffer.wrap(info.getBytes()));
        } catch (IOException e) {
            e.fillInStackTrace();
        }
    }

    // 从服务器回复的消息
    public void readInfo() {
        try {
            int readChannel = selector.select();
            if (readChannel > 0) { // 有可用通道

                Iterator<SelectionKey> iterator = selector.selectedKeys().iterator();
                while (iterator.hasNext()) {
                    SelectionKey key = iterator.next();
                    if (key.isReadable()) {
                        // 得到相关通道
                        SocketChannel socketChannel = (SocketChannel) key.channel();
                        // 得到一个buffer
                        ByteBuffer buffer = ByteBuffer.allocate(1024);
                        // 读取
                        socketChannel.read(buffer);
                        String msg = new String(buffer.array());
                        System.out.println(msg.trim());
                    }
                }
                iterator.remove(); //删除当前的SelectionKey 防止重复操作
            } else {
                //System.out.println("没有可用的通道");

            }

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

        }
    }

    public static void main(String[] args) throws IOException {
        // 启动客户端
        GroupChatClient3 chatClient = new GroupChatClient3();

        // 启动一个线程
        new Thread(() -> {
            while (true) {
                chatClient.readInfo();
                try {
                    Thread.currentThread().sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();

        // 发送数据
        Scanner scanner = new Scanner(System.in);

        while (scanner.hasNextLine()) {
            String msg = scanner.nextLine();
            chatClient.sendInfo(msg);
        }
    }


}

 

努力的阳光蓝孩
关注
专栏目录
Netty学习笔记（二）java NIO Buffer、Channel、Selector学习及使用，搭建nio群聊系统
yangwen-bo的博客
09-15 242
缓冲区（Buffer） 缓冲区（Buffer）：缓冲区本质上是一个可以读写数据的内存块，可以理解成是一个容器对象(含数组)，该对象提供了一组方法，可以更轻松地使用内存块，，缓冲区对象内置了一些机制，能够跟踪和记录缓冲区的状态变化情况。 Channel 提供从文件、网络读取数据的渠道，但是读取或写入的数据都必须经由 Buffer。 在NIO中，Buffer是一个顶级父类，它是一个抽象类，类的层级关系如图：（每个buffer实现类中都有对应数据类型的数组用来存储数据（所以buffer实际上数据是存在该数组中的）
Netty学习笔记 - 1 (带源码分析部分)
小小一只可乐猪
02-11 622
netty学习笔记，哔哩哔哩尚硅谷课程 韩老师主讲，笔记有4篇，很全面包含源码分析部分，结尾有相关文件 阿里云盘 欢迎下载。
Netty学习笔记 6 Netty应用实例-群聊系统
zyzy123321的博客
07-27 226
Netty应用实例-群聊系统 实例要求: 编写一个 Netty 群聊系统，实现服务器端和客户端之间的数据简单通讯（非阻塞） 实现多人群聊 服务器端：可以监测用户上线，离线，并实现消息转发功能 客户端：通过channel 可以无阻塞发送消息给其它所有用户，同时可以接受其它用户发送的消息(有服务器转发得到) 目的：进一步理解Netty非阻塞网络编程机制 GroupChatServer package com.my.netty.groupchat; import io.netty.bootstrap.
Java NIO 应用案例：实现一个简单的群聊系统
正在努力工作的搬砖人
04-23 2254
本文基于NIO实现了一个简单的群聊系统来巩固NIO所学的知识。该案例实现了服务器端和客户端之间的数据简单通讯。 服务器端功能：监测用户上线，离线；实现客户端消息的转发功能（将该客户端的消息转发给其它客户端）。 客户端功能：通过 channel 无阻塞地发送消息给其它所有用户，同时可以接受其它用户发送的消息（由服务器转发得到）。
Netty实现群聊系统
qq_34125999的博客
12-30 2043
1 需求 (1) 编写一个 Netty群聊系统,实现服务器端和客户端之间的数据简单通讯(非阻塞) (2) 实现多人群聊 (3) 服务器端:可以监测用户上线,离线,并实现消息转发功能 (4) 客户端:通过 channel可以无阻塞发送消息给其它所有用户,同时可以接受其它用 (5) 户发送的消息(有服务器转发得到) 目的:进一步理解Net非阻塞网络编程机制 2 Code 2.1 GroupChatConsts public final class GroupChatConsts { private G
Java网络编程Demo，使用TCP 实现简单群聊功能GroupchatSimple，多个客户端输入消息，显示在服务端的控制台
热门推荐
杨明金的博客
10-13 1万+
服务端 import java.io.IOException; import java.net.ServerSocket; import java.net.Socket; public class SocketServer { public static void main(String[] args) throws IOException { ServerSocket server = new ServerSocket(8888); System.out.println("群聊聊天室开启.
Java网络编程Demo，使用TCP 实现简单群聊功能Groupchat，创建一个服务端，使多个客户端都能收到消息
杨明金的博客
10-13 1万+
客户端类 import java.io.IOException; import java.net.ServerSocket; import java.net.Socket; import java.util.ArrayList; import java.util.List; public class SocketServer { public static List<Socket> socketList=new ArrayList<Socket>(); public st
Netty学习笔记 3.10 NIO 网络编程应用实例-群聊系统
zyzy123321的博客
07-26 3386
Netty学习笔记 3.10 NIO 网络编程应用实例-群聊系统 实例要求: 编写一个 NIO 群聊系统，实现服务器端和客户端之间的数据简单通讯（非阻塞） 实现多人群聊 服务器端：可以监测用户上线，离线，并实现消息转发功能 客户端：通过channel 可以无阻塞发送消息给其它所有用户，同时可以接受其它用户发送的消息(有服务器转发得到) 目的：进一步理解NIO非阻塞网络编程机制 Server 端 服务器接收到消息 时间: [2019-09-29 12:02:35] -> 服务器 ok… 1
Netty学习笔记：二、NIO网络应用实例-群聊系统
象话的博客
06-30 223
实例要求： 编写一个NIO群聊系统，实现服务器端和多个客户端之间的数据简单通讯（非阻塞）； 实现多人群聊； 服务器端：可以监测用户上线、离线，并实现消息转发功能； 客户端：通过channel可以无阻塞发送消息给其他所有用户，同时接受其他用户发送的消息； 目的：进一步理解NIO非阻塞网络编程机制； 代码演示： 群聊系统服务端代码: package com.study.demo.groupchat; import java.io.IOException; import java.net.Ine
Netty学习笔记（四）：Netty应用（群聊、心跳机制、长连接）、Protobfuf、编解码器、TCP粘包和拆包
Miracle42的博客
06-13 1284
第 5 章 Netty 应用实例 一、Netty 应用实例-群聊系统 1、要求 编写一个 Netty 群聊系统，实现服务器端和客户端之间的数据简单通讯（非阻塞） ，实现多人群聊 。 服务器端：可以监测用户上线，离线，并实现消息转发功能 客户端：通过 channel 可以无阻塞发送消息给其它所有用户，同时可以接受其它用户发送的消息(有服务器转发 得到) 2、实现 服务器端 public class ChatGroupServer { private static final int PORT = 6
Netty学习笔记（四）Netty概述及传统阻塞 IO 、Reactor 模式线程模型
yangwen-bo的博客
09-27 582
原生NIO存在的问题 1.NIO 的类库和 API 繁杂，使用麻烦：需要熟练掌握 Selector、ServerSocketChannel、SocketChannel、ByteBuffer 等。 2.需要具备其他的额外技能：要熟悉 Java 多线程编程，因为 NIO 编程涉及到 Reactor 模式，你必须对多线程和网络编程非常熟悉，才能编写出高质量的 NIO 程序。 3.开发工作量和难度都非常大：例如客户端面临断连重连、网络闪断、半包读写、失败缓存、网络拥塞和异常流的处理等等。 4.JDK NIO 的 B
Netty进阶 -- 非阻塞网络编程 实现群聊+私聊+心跳检测系统
最新发布
ehehhahs的博客
04-16 254
ch.writeAndFlush(currentDate + " \n [客户端]" + channel.remoteAddress() + “：” + s + “\n”);ch.writeAndFlush(currentDate + " \n [客户端]" + channel.remoteAddress() + “：” + s + “\n”);System.out.println(currentDate + " – " + ctx.channel().remoteAddress() + “离线”);
NIO实现服务器和客户端简单通讯与群聊系统
洺润Star的博客
09-06 263
参考 相关API汇总 public abstract class Buffer { //JDK1.4时，引入的api public final int capacity( )//返回此缓冲区的容量 public final int position( )//返回此缓冲区的位置 public final Buffer position (int newPositio)//设置此缓冲区的位置 public final int limit( )//返回此缓冲区的限制 pub
netty入门（六）——实现群聊系统
qq_43481350的博客
03-07 152
服务器端代码 import java.io.IOException; import java.net.InetSocketAddress; import java.nio.ByteBuffer; import java.nio.channels.*; import java.util.Iterator; /** * 服务器端启动并监听6667端口，服务器接收客户端消息并实现转发，提示上线和下线 ...
netty学习笔记四、文件读取、写入代码实现
promiseful的博客
05-11 1413
package com.hao.demo.netty.nio; import java.io.FileInputStream; import java.io.FileOutputStream; import java.nio.ByteBuffer; import java.nio.channels.FileChannel; /** * @author haoxiansheng * @date 2020-05-11 */ public class NIOFileChannel03 { pu.
netty学习笔记十、Selector、Channel、Buffer关系说明，NIO原理浅谈
promiseful的博客
05-16 1157
一、 Selector、Channel、Buffer关系 1、每个Channel 都会对应一个Buffer 2、Selector对应一个线程，一个线程对应多个channel连接 3、channel注册到selector 4、程序切换到channel需要有事件决定Event是一个重要的概念。 5、Selector会根据不同的事件，在各个通道上切换。 6、buffer就是一个内存块，底层有一个数组 byte[] hb; 7、数据的读取写入是通过Buffer,BIO中的流只能读或写。Buffer可以调用flip(
Netty学习笔记二十、Netty任务队列Task了解以及Netty再了解
promiseful的博客
05-24 557
一、用户自定义任务 // 用户自定义任务 该任务提交到scheduleTaskQueue 中 ctx.channel().eventLoop().schedule((() -> { try { Thread.sleep(10 * 1000); } catch (Exception e) { System.out.println("发生异常" + e.get
netty学习笔记五、使用transferFrom 完成文件拷贝
promiseful的博客
05-11 496
package com.hao.demo.netty.nio; import java.io.FileInputStream; import java.io.FileOutputStream; import java.nio.channels.FileChannel; /** * @author haoxiansheng * @date 2020-05-11 */ public class NIOFileChannel04 { public static void main(Strin.
Netty学习笔记十八、Netty任务队列Task了解
promiseful的博客
05-24 447
一、使用场景了解 1、用户程序自定义普通任务 2、用户自定义定时任务 3、非当前Reactor 线程调用Channel 的各种用法 1）比如：推送任务系统的业务线程里面，根据用户的标识，找到对应的Channel 引用，然后调用Write 类方法向用户推送消息，就会进入到这种场景。最终的Write会提交到任务队列中后被异步消费。 二、第一种自定义普通任务 1、代码模拟阻塞 、是基于上一节笔记基础之上 客户端会阻塞10s才会得到响应 /** * 读取数据（这里可以读取客.
Netty：高性能NIO网络编程框架与实战应用
NIO网络编程框架Netty是由Reythor雷主讲的一门课程，它是一个异步事件驱动的网络应用程序框架，特别适用于快速开发高性能的服务器和客户端应用。Netty采用NIO（非阻塞I/O）模型，旨在简化网络编程任务，如TCP和UDP套...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值