Java基于IO、NIO和Netty实现简单C/S聊天

最新推荐文章于 2024-03-15 13:54:59 发布
最新推荐文章于 2024-03-15 13:54:59 发布
阅读量879 收藏 2
点赞数 1
分类专栏： 网络通信编程 文章标签： java 服务器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_47281915/article/details/121802536
版权

文章目录

一、IO

简介

IO:每个小朋友配一个老师。每个老师隔段时间询问小朋友是否要上厕所，如果要上，就领他去厕所，100个小朋友就需要100个老师来询问，并且每个小朋友上厕所的时候都需要一个老师领着他去上，这就是IO模型，一个连接对应一个线程。

实现

服务器

package io;

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;
/**
 * author:醉意丶千层梦
 */
public class IOServer {
    @SuppressWarnings("resource")
    public static void main(String[] args) throws Exception {

        ExecutorService newCachedThreadPool = Executors.newCachedThreadPool();
        //创建socket服务,监听8081端口
        ServerSocket server=new ServerSocket(8081);
        System.out.println("服务器启动！");
        int count=0;
        while(true){
            //获取一个套接字（阻塞）
            final Socket socket = server.accept();
            System.out.println("欢迎第"+(++count)+"个客户");
            newCachedThreadPool.execute(new Runnable() {

                @Override
                public void run() {
                    //业务处理
                    handler(socket);
                }
            });

        }
    }

    /**
     * 读取数据
     * @param socket
     * @throws Exception
     */
    public static void handler(Socket socket){
        try {
            byte[] bytes = new byte[1024];
            InputStream inputStream = socket.getInputStream();

            while(true){
                //读取数据（阻塞）
                int read = inputStream.read(bytes);
                if(read != -1){
                    System.out.println(new String(bytes, 0, read));
                }else{
                    break;
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }finally{
            try {
                System.out.println("socket关闭");
                socket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }}

客户端

package io;

import java.io.IOException;
import java.io.OutputStream;
import java.net.Socket;
/**
 * author:醉意丶千层梦
 */
public class IOClient {
    public static void main(String[] args) throws IOException {
        //发送十次
        for (int i=0;i<10;i++){
            Socket socket=new Socket("127.0.0.1", 8081);
            //写数据
            OutputStream os=socket.getOutputStream();
            os.write(("醉意丶千层梦"+i).getBytes());
            //释放资源
            socket.close();
        }
        
    }

}

效果

在这里插入图片描述

二、NIO

简介

NIO:所有的小朋友都配同一个老师。这个老师隔段时间询问所有的小朋友是否有人要上厕所，然后每一时刻把所有要上厕所的小朋友批量领到厕所，这就是NIO模型，所有小朋友都注册到同一个老师，对应的就是所有的连接都注册到一个线程，然后批量轮询。

实现

服务器

package nio;

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;
/**
 * author:醉意丶千层梦
 */

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

    /**
     * 启动服务端测试
     *
     * @throws IOException
     */
    public static void main(String[] args) throws IOException {
        NIOServer server = new NIOServer();
        server.initServer(8081);
        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<?> 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()) {
            handelerRead(key);
        }
    }

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

        // 在这里可以给客户端发送信息哦
        System.out.println("新的客户端连接");
        // 在和客户端连接成功之后，为了可以接收到客户端的信息，需要给通道设置读的权限。
        channel.register(this.selector, SelectionKey.OP_READ);
    }

    /**
     * 处理读的事件
     *
     * @param key
     * @throws IOException
     */
    public void handelerRead(SelectionKey key) throws IOException {
        // 服务器可读取消息:得到事件发生的Socket通道
        SocketChannel channel = (SocketChannel) key.channel();
        // 创建读取的缓冲区
        ByteBuffer buffer = ByteBuffer.allocate(1024);
        int read = channel.read(buffer);
        if(read > 0){
            byte[] data = buffer.array();
            String msg = new String(data).trim();
            System.out.println("服务端收到信息：" + msg);

            //回写数据
            ByteBuffer outBuffer = ByteBuffer.wrap("好的".getBytes());
            channel.write(outBuffer);// 将消息回送给客户端
        }else{
            System.out.println("客户端关闭");
            key.cancel();
        }
    }
}

客户端

package nio;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SocketChannel;
/**
 * author:醉意丶千层梦
 */
public class NIOClient {
    public static void main(String[] args) throws Exception {
        final int count[]=new int[1];
        count[0]=1;
        for(int i=0;i<5;i++){
            new Thread(new Runnable() {
                @Override
                public void run() {
                    SocketChannel socketChannel = null;
                    //发送的数据
                    String str = "醉意丶千层梦"+count[0]++;
                    ByteBuffer byteBuffer = ByteBuffer.wrap(str.getBytes());

                    //接受的数据
                    ByteBuffer buffer = ByteBuffer.allocate(1024);
                    try {
                        //建立连接
                        socketChannel = SocketChannel.open();
                        socketChannel.configureBlocking(false);
                        if (!socketChannel.connect(new InetSocketAddress("127.0.0.1", 8081))) {
                            //等待连接
                            while (!socketChannel.finishConnect()) {
                            }
                        }
                        //写入数据
                        socketChannel.write(byteBuffer);
                    } catch (IOException e) {
                        e.printStackTrace();
                    }

                    //10s后自动断开连接
                    int time=1;
                    while (time<10){
                        time++;
                        try {
                            //读取数据
                            int read=socketChannel.read(buffer);
                            if(read > 0) {
                                byte[] data = buffer.array();
                                String msg = new String(data).trim();
                                System.out.println("客户端收到信息：" + msg);
                            }
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                    }
                    try {
                        socketChannel.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }).start();
            Thread.sleep(100);
        }
    }

}

效果

服务器
在这里插入图片描述
客户端
在这里插入图片描述

三、Netty

简介

Netty 是一个基于NIO的客户、服务器端编程框架

实现

服务器

package netty;

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.util.Scanner;
/**
 * author:醉意丶千层梦
 */


public class NettyServer {
    public static void main(String[] args) {
        //用于处理服务器端接收客户端连接
        NioEventLoopGroup bossGroup = new NioEventLoopGroup(1);
        //进行网络通信（读写）
        NioEventLoopGroup workerGroup = new NioEventLoopGroup();
        try {
            //辅助工具类，用于服务器通道的一系列配置
            ServerBootstrap bootstrap = new ServerBootstrap();
            //绑定两个线程组
            bootstrap.group(bossGroup,workerGroup)
                    //设置boss selector建立channel使用的对象
                    .channel(NioServerSocketChannel.class)
                    //boss 等待连接的 队列长度
                    .option(ChannelOption.SO_BACKLOG,1024)
                    //处理消息对象
                    .childHandler(new ChannelInitializer<SocketChannel>() {
                @Override
                protected void initChannel(SocketChannel ch) throws Exception {
                    //创建管道
                    ChannelPipeline pipeline = ch.pipeline();
                    //解码方式
                    pipeline.addLast("decoder",new StringDecoder());
                    //编码方式
                    pipeline.addLast("encoder",new StringEncoder());
                    //自定义处理消息对象
                    pipeline.addLast(new ServerHandler());
                }
            });
            System.out.println("服务器正在启动");
            //绑定端口号
            ChannelFuture cf = bootstrap.bind(8083).sync();

            cf.addListener(cd->{
                if(cd.isSuccess()){
                    System.out.println("启动成功");
                }else{
                    System.out.println("启动失败");
                }
            });
            //服务端给所有客户端发信息
            Scanner scanner = new Scanner(System.in);
            while (scanner.hasNextLine()){
                String msg = scanner.nextLine();
                ServerHandler.sendAll(msg);
            }
            //阻塞当前线程
            cf.channel().closeFuture().sync();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }

    }


}


package netty;

import io.netty.channel.*;
import io.netty.channel.group.ChannelGroup;
import io.netty.channel.group.DefaultChannelGroup;
import io.netty.util.concurrent.GlobalEventExecutor;
import java.text.SimpleDateFormat;
import java.util.Date;
/**
 * author:醉意丶千层梦
 */

public class ServerHandler extends SimpleChannelInboundHandler<String> {
    private static ChannelGroup channelGroup = new DefaultChannelGroup(GlobalEventExecutor.INSTANCE);
    SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    @Override
    protected void channelRead0(ChannelHandlerContext ctx, String msg) throws Exception {
        Channel channel = ctx.channel();
        System.out.println(channel.remoteAddress()+" == " +msg);
        channelGroup.forEach(ch->{
            if (channel!=ch) {
                ch.writeAndFlush("[ 客户端 ]" + channel.remoteAddress() + "发送了消息 : " + msg + "\n");
            }else{
                ch.writeAndFlush("[ 我 ] 发送了消息: " + msg + "\n");
            }
        });

    }
    //用于服务端发信息给所有客户端
    public static void sendAll(String msg){
        channelGroup.forEach(channel -> {
            channel.writeAndFlush("服务器: "+msg+"\n");
        });
    }

    /**
     * 当有新的用户连接触发
     * @param ctx
     */
    public void channelActive(ChannelHandlerContext ctx){
        Channel channel = ctx.channel();
        channelGroup.writeAndFlush("[ 客户端 ]"+channel.remoteAddress()+" 上线了 "+sf.format(new Date())+"\n");
        //把新来的连接加入
        channelGroup.add(channel);
        System.out.println(ctx.channel().remoteAddress()+" 上线了" + "\n");
    }

    /**
     * 当用户断开连接触发
     * @param ctx
     */
    public void channelInactive(ChannelHandlerContext ctx) {
        Channel channel = ctx.channel();
        channelGroup.writeAndFlush("[ 客户端 ] " +channel.remoteAddress()+ " 下线了"+"\n");
        System.out.println(channel.remoteAddress()+" 下线了.\n");
        System.out.println("channelGroup size = "+ channelGroup.size());
    }
}

客户端

package netty;
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;
import java.util.ArrayList;
import java.util.List;


/**
 * author:醉意丶千层梦
 */
public class NettyClient {
    /**
     * 主函数
     * @param args
     * @throws InterruptedException
     */
    public static void main(String[] args) throws InterruptedException {
        NioEventLoopGroup group = new NioEventLoopGroup();
        List<ChannelFuture> channelFutures = new ArrayList<ChannelFuture>();
        try {
            Bootstrap bootstrap = new Bootstrap();
            //服务器可以主动断开连接
            bootstrap.option(ChannelOption.SO_KEEPALIVE, true);
            //地址复用
            bootstrap.option(ChannelOption.SO_REUSEADDR, true);
            bootstrap.group(group).channel(NioSocketChannel.class)
                    .handler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel socketChannel) throws Exception {
                            ChannelPipeline pipeline = socketChannel.pipeline();
                            pipeline.addLast("decoder",new StringDecoder());
                            pipeline.addLast("encoder",new StringEncoder());
                            pipeline.addLast(new ClientHandler());
                        }
                    });
            final int count[] =new int[1];
            count[0]=0;
            for(int i=0;i<3;i++){
                //添加连接
                channelFutures.add(bootstrap.connect("127.0.0.1",8083).sync());
                //新建线程模拟多用户
                new Thread(new Runnable() {
                    @Override
                    public void run() {
                        int index=count[0]++;
                        //获取对应管道
                        Channel channel = channelFutures.get(index).channel();
                        System.out.println( "======"+channel.localAddress()+"======");
                        int time=0;
                        while (time++<3){
                            //发送数据
                            String msg =" 醉意丶千层梦 "+(index)+": "+time;
                            channel.writeAndFlush(msg);
                            try {
                                Thread.sleep(1000);
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            }
                        }
                        //关闭连接
                        channel.close();

                    }
                }).start();

            }

            //阻塞主线程,否则会直接执行finally关闭EventLoopGroup
            int time=0;
            while (time++<5){
                Thread.sleep(1000);
            }

        } finally {
            //关闭EventLoopGroup
            group.shutdownGracefully();
        }

    }
}



package netty;

import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;
/**
 * author:醉意丶千层梦
 */
public class ClientHandler extends SimpleChannelInboundHandler<String> {
    @Override
    protected void channelRead0(ChannelHandlerContext channelHandlerContext, String msg) throws Exception {
        System.out.println(msg.trim());
    }
}

效果

服务器
在这里插入图片描述

客户端
在这里插入图片描述

四、总结

Netty不好学，但是很好用

五、参考

https://blog.csdn.net/qq_32717909/article/details/91409999
https://blog.csdn.net/qq_40640228/article/details/103433348

醉意丶千层梦
关注
专栏目录
基于IO/NIO/Netty的Client/Server的java程序实现
hh444565的博客
12-19 303
一、IO实现 （一）IO介绍 1.传送IO特点 （1）服务端阻塞点 server.accept();获取套接字的时候 inputStream.read(bytes);输入流读取数据的时候 （2）传统socket是短连接，可以做短连接服务器，他无法做长连接，属于一问一答的模式，比如老的tomcat底层用的就是socket,用完就会关掉线程，因此不会出现线程一直被占用的情况，支持处理多个客户端连接 单线程情况下只能有一个客户端（一个线程维护一个连接，也就是一个socket客户连接）线程一直被占用。 用...
JAVA中的IO和NIO以及Netty
dedsec0x的博客
12-17 601
一、基础知识 (一)IO和NIO的概念 IO Java IO 也称为IO流，IO = 流，它的核心就是对文件的操作，对于字节、字符类型的输入和输出流。IO是指对数据流的输入和输出，也称为IO流，IO流主要分为两大类，字节流和字符流。字节流可以处理任何类型的数据，如图片，视频等，字符流只能处理字符类型的数据。IO流的本质是数据传输，并且流是单向的。 NIO JAVA NIO有两种解释：一种叫非阻塞IO（Non-blocking I/O），另一种也叫新的IO（New I/O），其实是同一个...
基于java GUI界面的简易netty聊天室（实现群聊和私聊）
11-18
所使用netty版本为4 ， 使用fastjson进行json格式的编解码，基于java GUI界面的简易netty聊天室（实现群聊和私聊）
基于IO、NIO、Netty的TCP的C/S模式的聊天程序
m0_59416558的博客
12-15 351
文章目录一、IO实现TCP聊天程序（一）IO简介（二）IO实现网络程序二、NIO实现TCP聊天程序（一）NIO简介（二）NIO实现网络程序三、Netty实现TCP聊天程序（一）Netty简介（二）Netty实现网络程序总结参考 一、IO实现TCP聊天程序 （一）IO简介 服务端阻塞点 server.accept();获取套接字的时候 inputStream.read(bytes);输入流读取数据的时候 传统socket是短连接，可以做短连接服务器，他无法做长连接，属于一问一答的模式，比如老的tom
Java基础之《netty（18）—群聊系统》
csj50的专栏
01-03 875
4、客户端：通过channel可以无阻塞发送消息给其他所有用户，同时可以接受其他用户发送的消息（由服务器转发得到）1、编写一个netty群聊系统，实现服务器端和客户端之间的数据简单通讯（非阻塞）3、服务器端：可以检测用户上线，离线，并实现消息转发功能。5、目的：进一步理解netty非阻塞网络编程机制。
netty框架各种通信C/S端
11-28
找了很久很久，才找到的可用的这个，不是我自己写的，我只是个搬运工，测试过了，并使用了。 评价：好使，不是我手写的，但是我都调试过了
漫谈Java IO之 Netty与NIO服务器
weixin_34380781的博客
03-30 261
前面介绍了基本的网络模型以及IO与NIO，那么有了NIO来开发非阻塞服务器，大家就满足了吗？有了技术支持，就回去追求效率，因此就产生了很多NIO的框架对NIO进行封装——这就是大名鼎鼎的Netty。 前几篇的内容，可以参考： 网络IO的基本知识与概念 普通IO以及BIO服务器 NIO的使用与服务器Hello world Netty的使用与服务器Hello world 为什么要使用开源框架？...
基于JAVA IO, NIO, Netty, 多线程并发实战源码.zip
02-02
Java IO、NIO和Netty是Java平台中用于处理输入/输出操作的重要组件，而多线程并发则是提升程序性能和响应能力的关键技术。在这个压缩包"基于JAVA IO, NIO, Netty, 多线程并发实战源码.zip"中，我们可以期待找到一些...
基于IO、NIO、Netty的Java网络程序（实现服务端与客户端通信）
YouthBlood9的博客
12-17 2720
录一、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的C/S架构网络应用程序
APlus
06-06 1688
一、前言 在基于C/S架构的应用程序中，对于服务端我们需要实现的功能通常有： 保持长连接并随时接收客户端发送的请求 能够主动向客户端发送响应信息 能够实现客户端到客户端信息的传输 对于客户端： - 保持和服务器的长连接 - 能够主动向服务器发送消息 - 能随时接收服务器的响应 下面我们来讨论如何实现上面的功能（最后会附上一个基于C/S的网盘程序） 二、服务端 （1）...
Java-IO系列：Netty中Channel创建过程以及与操作系统系统调用的关系
少年不识愁滋味
12-16 1168
应用代码 public static void start() throws Exception { ServerBootstrap bootstrap = new ServerBootstrap(); EventLoopGroup boss = new NioEventLoopGroup(); EventLoopGroup work = new NioEventLoopGroup(); bootstrap.group(boss, work)
Netty之Codec的Decoders和Encoders概述
Learning
12-14 1292
Netty之Codec的Decoders和Encoders概述  A codec is made up of two parts:  Decoder  Encoder  This  should  make  it  clear  that  the  decoder  is  for  inbound  and  the  encoder  is  for  ou
io.netty学习（三）Channel 概述
码灵的博客
06-19 2776
前两篇文章我们已经对Netty进行了简单的了解和架构设计原理的剖析。本篇文章我们就来开始对Netty源码的分析，首先我们来讲解 Netty 中Channel相关的功能和接口。Channel 顾名思义就是管道，代表网络 Socket 或能够进行 I/O 操作的组件的关系。这些 I/O 操作包括读、写、连接和绑定。简单的说，Channel 就是代表连接，实体之间的连接，程序之间的连接，文件之间的连接，设备之间的连接。同时它也是数据入站和出站的载体。
Java IO流之Netty实现聊天通信功能
最新发布
上善若泪
03-15 1579
点击了解 IO流之IO,NIO和AIO讲解Netty是一个相当优秀的通信框架，大多数的顶级开源框架中都有Netty的身影。应用过程中，它最核心的东西叫handler，我们可以简单理解它为消息处理器。收到的消息和出去的消息都会经过一系列的handler加工处理。收到的消息我们叫它入站消息，发出去的消息我们叫它出站消息，因此handler又分为出站handler和入站handler。收到的消息只会被入站handler处理，发出去的消息只会被出站handler处理。
硬核！十分钟带你看懂Netty如何实现C/S（源码解析）
weixin_51954021的博客
02-03 339
Netty实现服务器和客户端 服务器 话不多说我们直接来实现一个简单的TimerServer(该服务器的提供的服务是接收客户端的指令返回服务器的系统时间)。 import io.netty.bootstrap.ServerBootstrap; import io.netty.channel.ChannelFuture; import io.netty.channel.ChannelOption; import io.netty.channel.EventLoopGroup; import io.ne
Java netty 聊天服务器_使用netty实现im聊天
weixin_42131013的博客
03-01 667
1、新建maven工程2、引入maven依赖io.nettynetty-all4.1.49.Finalcom.alibabafastjson1.2.68org.apache.maven.pluginsmaven-compiler-plugin3.6.11.81.83、定义消息体MsgBodypublic class MsgBody {//发送人名称private String sendUserNa...
编译提示：“idea Error:(7, 24) java: 程序包io.netty.channel不存在”的解决方法
qq_42817360的博客
04-22 1650
编译提示：“idea Error:(7, 24) java: 程序包io.netty.channel不存在”的解决方法
学习 java netty (三) -- Channel
IT小小鸟～～
07-30 5594
学习 java netty (三) – Channel 前言：netty封装的channel，看一下官网的定义 A nexus to a network socket or a component which is capable of I/O operations such as read, write, connect, and bind. 可以I/O操作（如读，写，连接和绑定）
Java BIO、NIO、AIO与Netty详解：I/O模型对比与优化
Java I/O（Input/Output）是Java编程中基础且关键的部分，它基于流进行数据的传输，将数据以串行化的方式进行操作，使得程序能够与外部设备如文件、网络进行交互。Java IO模块包括了标准输入输出、文件操作、网络...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值