BIO、NIO、AIO、Netty 、TCP全网最全解析！Netty中提供了哪些线程模型？

已于 2023-10-07 22:37:34 修改
阅读量100 收藏
点赞数
分类专栏： 技术问答 源码解析 文章标签： nio tcp/ip 数据库
于 2023-10-07 21:18:28 首次发布

转载： https://mp.weixin.qq.com/s/3_4tzZpBtOm-YZbiDqhMBw

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

package com.test.io;  
  
import java.io.FileReader;  
import java.io.IOException;  
  
public class TestFileReader {  
    public static void main(String[] args) throws IOException {  
        int num=0;  
        //字符流接收使用的char数组  
        char[] buf=new char[1024];  
        //字符流、节点流打开文件类  
        FileReader fr = new FileReader("D:\\test.txt");//文件必须存在  
        //FileReader.read()：取出字符存到buf数组中,如果读取为-1代表为空即结束读取。  
        //FileReader.read()：读取的是一个字符，但是java虚拟机会自动将char类型数据转换为int数据，  
        //如果你读取的是字符A，java虚拟机会自动将其转换成97，如果你想看到字符可以在返回的字符数前加（char）强制转换如  
        while((num=fr.read(buf))!=-1) { }  
        //检测一下是否取到相应的数据  
        for(int i=0;i<buf.length;i++) {  
            System.out.print(buf[i]);  
        }  
    }  
}

在这里插入图片描述

package com.test.io;  
import java.io.BufferedReader;  
import java.io.FileReader;  
import java.io.IOException;  
  
public class TestBufferedReader {  
    public static void main(String[] args) throws IOException {  
        int num=0;  
        //字符流接收使用的String数组  
        String[] bufstring=new String[1024];  
        //字符流、节点流打开文件类  
        FileReader fr = new FileReader("D:\\test.txt");//文件必须存在  
        //字符流、处理流读取文件类  
        BufferedReader br = new BufferedReader(fr);  
        //临时接收数据使用的变量  
        String line=null;  
        //BufferedReader.readLine()：单行读取，读取为空返回null  
        while((line=br.readLine())!=null) {  
            bufstring[num]=line;  
            num++;  
        }  
        br.close();//关闭文件  
        for(int i=0;i<num;i++) {  
            System.out.println(bufstring[i]);  
        }  
    }  
}

在这里插入图片描述

package com.test.io;  
import java.io.File;  
import java.io.FileWriter;  
import java.io.IOException;  
  
public class TestFileWriter {  
    public static void main(String[] args) throws IOException {  
        //File是操作文件类  
        File file = new File("D:\\test.txt");//文件必须存在  
        //字符流、节点流写出文件类  
        //new FileWriter(file,true)，这个true代表追加，不写就代表覆盖文件  
        FileWriter out=new FileWriter(file,true);  
        //写入的字节,\n代表换行  
        String str="\nholler";  
        //写入  
        out.write(str);  
        out.close();  
    }  
}

在这里插入图片描述

package com.test.io;  
import java.io.*;  
public class TestBufferedWriter {  
    public static void main(String[] args) throws IOException {  
        //File是操作文件类  
        File file = new File("D:\\test.txt");//文件必须存在  
        //字符流、节点流写出文件类  
        //new FileWriter(file)，这个我没加true代表覆盖文件  
        Writer writer = new FileWriter(file);  
        字符流、处理流写出文件类  
        BufferedWriter bw = new BufferedWriter(writer);  
        bw.write("\n小心");  
        bw.close();  
        writer.close();  
    }  
}

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

package com.test.io;  
import java.io.FileInputStream;  
import java.io.FileOutputStream;  
import java.io.IOException;  
public class TestFileOutputStream {  
    public static void main(String[] args) throws IOException {  
        //创建字节输入流、节点流方式读取文件  
        FileInputStream fis = new FileInputStream("D:\\Akie秋绘 - Lemon（Cover：米津玄師）.mp3");  
        //创建字节输入流、节点流方式输出文件  
        FileOutputStream fos = new FileOutputStream("D:\\copy.mp3");  
  
        //根据文件大小做一个字节数组  
        byte[] arr = new byte[fis.available()];  
        //将文件上的所有字节读取到数组中  
        fis.read(arr);  
        //将数组中的所有字节一次写到了文件上  
        fos.write(arr);  
        fis.close();  
        fos.close();  
    }  
}

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

package com.test.io;  
import java.io.*;  
public class TestBufferedOutputStream {  
    //创建文件输入流对象,关联致青春.mp3  
    public static void main(String[] args) throws IOException {  
        FileInputStream fis = new FileInputStream("D:\\copy.mp3");  
        //创建缓冲区对fis装饰  
        BufferedInputStream bis = new BufferedInputStream(fis);  
        //创建输出流对象,关联copy.mp3  
        FileOutputStream fos = new FileOutputStream("D:\\copy2.mp3");  
        //创建缓冲区对fos装饰  
        BufferedOutputStream bos = new BufferedOutputStream(fos);  
        //循环直接输出  
        int i;  
        while((i = bis.read()) != -1) {  
            bos.write(i);  
        }  
        bis.close();  
        bos.close();  
    }  
}

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

package com.test.io;  
import java.io.IOException;  
import java.io.InputStream;  
import java.io.OutputStream;  
import java.net.ServerSocket;  
import java.net.Socket;  
//TCP协议Socket使用BIO进行通信：服务端  
public class BIOServer {  
    // 在main线程中执行下面这些代码  
    public static void main(String[] args) {  
        //使用Socket进行网络通信  
        ServerSocket server = null;  
        Socket socket = null;  
        //基于字节流  
        InputStream in = null;  
        OutputStream out = null;  
        try {  
            server = new ServerSocket(8000);  
            System.out.println("服务端启动成功，监听端口为8000，等待客户端连接...");  
            while (true){  
                socket = server.accept(); //等待客户端连接  
                System.out.println("客户连接成功，客户信息为：" + socket.getRemoteSocketAddress());  
                in = socket.getInputStream();  
                byte[] buffer = new byte[1024];  
                int len = 0;  
                //读取客户端的数据  
                while ((len = in.read(buffer)) > 0) {  
                    System.out.println(new String(buffer, 0, len));  
                }  
                //向客户端写数据  
                out = socket.getOutputStream();  
                out.write("hello!".getBytes());  
            }  
        } catch (IOException e) {  
            e.printStackTrace();  
        }  
    }  
}

在这里插入图片描述

package com.test.io;  
import java.io.IOException;  
import java.io.OutputStream;  
import java.net.Socket;  
import java.util.Scanner;  
//TCP协议Socket使用BIO进行通信：客户端  
public class Client01 {  
    public static void main(String[] args) throws IOException {  
        //创建套接字对象socket并封装ip与port  
        Socket socket = new Socket("127.0.0.1", 8000);  
        //根据创建的socket对象获得一个输出流  
        //基于字节流  
        OutputStream outputStream = socket.getOutputStream();  
        //控制台输入以IO的形式发送到服务器  
        System.out.println("TCP连接成功 \n请输入：");  
        String str = new Scanner(System.in).nextLine();  
        byte[] car = str.getBytes();  
        outputStream.write(car);  
        System.out.println("TCP协议的Socket发送成功");  
        //刷新缓冲区  
        outputStream.flush();  
        //关闭连接  
        socket.close();  
    }  
}

在这里插入图片描述

package com.test.io;  
import java.io.IOException;  
import java.io.OutputStream;  
import java.net.Socket;  
import java.util.Scanner;  
//TCP协议Socket：客户端  
public class Client02 {  
    public static void main(String[] args) throws IOException {  
        //创建套接字对象socket并封装ip与port  
        Socket socket = new Socket("127.0.0.1", 8000);  
        //根据创建的socket对象获得一个输出流  
        //基于字节流  
        OutputStream outputStream = socket.getOutputStream();  
        //控制台输入以IO的形式发送到服务器  
        System.out.println("TCP连接成功 \n请输入：");  
        String str = new Scanner(System.in).nextLine();  
        byte[] car = str.getBytes();  
        outputStream.write(car);  
        System.out.println("TCP协议的Socket发送成功");  
        //刷新缓冲区  
        outputStream.flush();  
        //关闭连接  
        socket.close();  
    }  
}

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

package com.test.io;  
import java.io.IOException;  
import java.io.InputStream;  
import java.io.OutputStream;  
import java.net.ServerSocket;  
import java.net.Socket;  
  
//TCP协议Socket使用多线程BIO进行通行：服务端  
public class BIOThreadService {  
    public static void main(String[] args) {  
        try {  
            ServerSocket server = new ServerSocket(8000);  
            System.out.println("服务端启动成功，监听端口为8000，等待客户端连接... ");  
            while (true) {  
                Socket socket = server.accept();//等待客户连接  
                System.out.println("客户连接成功，客户信息为：" + socket.getRemoteSocketAddress());  
                //针对每个连接创建一个线程， 去处理I0操作  
                //创建多线程创建开始  
                Thread thread = new Thread(new Runnable() {  
                    public void run() {  
                        try {  
                            InputStream in = socket.getInputStream();  
                            byte[] buffer = new byte[1024];  
                            int len = 0;  
                            //读取客户端的数据  
                            while ((len = in.read(buffer)) > 0) {  
                                System.out.println(new String(buffer, 0, len));  
                            }  
                            //向客户端写数据  
                            OutputStream out = socket.getOutputStream();  
                            out.write("hello".getBytes());  
                        } catch (IOException e) {  
                            e.printStackTrace();  
                        }  
                    }  
                });  
                thread.start();  
            }  
        } catch (IOException e) {  
            e.printStackTrace();  
        }  
    }  
}

运行结果：

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

package com.test.io;  
import java.io.IOException;  
import java.io.InputStream;  
import java.io.OutputStream;  
import java.net.ServerSocket;  
import java.net.Socket;  
import java.util.concurrent.ExecutorService;  
import java.util.concurrent.Executors;  
//TCP协议Socket使用线程池BIO进行通行：服务端  
public class BIOThreadPoolService {  
    public static void main(String[] args) {  
        //创建线程池  
        ExecutorService executorService = Executors.newFixedThreadPool(30);  
        try {  
            ServerSocket server = new ServerSocket(8000);  
            System.out.println("服务端启动成功，监听端口为8000，等待客户端连接...");  
            while (true) {  
                Socket socket = server.accept();//等待客户连接  
                System.out.println("客户连接成功，客户信息为：" + socket.getRemoteSocketAddress());  
                //使用线程池中的线程去执行每个对应的任务  
                executorService.execute(new Thread(new Runnable() {  
                    public void run() {  
                        try {  
                            InputStream in = socket.getInputStream();  
                            byte[] buffer = new byte[1024];  
                            int len = 0;  
                            //读取客户端的数据  
                            while ((len = in.read(buffer)) > 0) {  
                                System.out.println(new String(buffer, 0, len));  
                            }  
                            //向客户端写数据  
                            OutputStream out = socket.getOutputStream();  
                            out.write("hello".getBytes());  
                        } catch (IOException e) {  
                            e.printStackTrace();  
                        }  
                    }  
                })  
                );  
            }  
        } catch (IOException e) {  
            e.printStackTrace();  
        }  
    }  
}

运行结果：

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

package com.test.io;   
import com.lijie.iob.RequestHandler;  
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;  
import java.util.Set;  
public class NIOServer {  
    public static void main(String[] args) throws IOException {  
        //111111111  
        //Service端的Channel，监听端口的  
        ServerSocketChannel serverChannel = ServerSocketChannel.open();  
        //设置为非阻塞  
        serverChannel.configureBlocking(false);  
        //nio的api规定这样赋值端口  
        serverChannel.bind(new InetSocketAddress(8000));  
        //显示Channel是否已经启动成功，包括绑定在哪个地址上  
        System.out.println("服务端启动成功，监听端口为8000，等待客户端连接..."+ serverChannel.getLocalAddress());  
  
        //22222222  
        //声明selector选择器  
        Selector selector = Selector.open();  
        //这句话的含义，是把selector注册到Channel上面，  
        //每个客户端来了之后，就把客户端注册到Selector选择器上,默认状态是Accepted  
        serverChannel.register(selector, SelectionKey.OP_ACCEPT);  
  
        //33333333  
        //创建buffer缓冲区，声明大小是1024，底层使用数组来实现的  
        ByteBuffer buffer = ByteBuffer.allocate(1024);  
        RequestHandler requestHandler = new RequestHandler();  
  
        //444444444  
        //轮询，服务端不断轮询，等待客户端的连接  
        //如果有客户端轮询上来就取出对应的Channel，没有就一直轮询  
        while (true) {  
            int select = selector.select();  
            if (select == 0) {  
                continue;  
            }  
            //有可能有很多，使用Set保存Channel  
            Set<SelectionKey> selectionKeys = selector.selectedKeys();  
            Iterator<SelectionKey> iterator = selectionKeys.iterator();  
            while (iterator.hasNext()) {  
                //使用SelectionKey来获取连接了客户端和服务端的Channel  
                SelectionKey key = iterator.next();  
                //判断SelectionKey中的Channel状态如何，如果是OP_ACCEPT就进入  
                if (key.isAcceptable()) {  
                    //从判断SelectionKey中取出Channel  
                    ServerSocketChannel channel = (ServerSocketChannel) key.channel();  
                    //拿到对应客户端的Channel  
                    SocketChannel clientChannel = channel.accept();  
                    //把客户端的Channel打印出来  
                    System.out.println("客户端通道信息打印：" + clientChannel.getRemoteAddress());  
                    //设置客户端的Channel设置为非阻塞  
                    clientChannel.configureBlocking(false);  
                    //操作完了改变SelectionKey中的Channel的状态OP_READ  
                    clientChannel.register(selector, SelectionKey.OP_READ);  
                }  
                //到此轮训到的时候，发现状态是read，开始进行数据交互  
                if (key.isReadable()) {  
                    //以buffer作为数据桥梁  
                    SocketChannel channel = (SocketChannel) key.channel();  
                    //数据要想读要先写，必须先读取到buffer里面进行操作  
                    channel.read(buffer);  
                    //进行读取  
                    String request = new String(buffer.array()).trim();  
                    buffer.clear();  
                    //进行打印buffer中的数据  
                    System.out.println(String.format("客户端发来的消息： %s : %s", channel.getRemoteAddress(), request));  
                    //要返回数据的话也要先返回buffer里面进行返回  
                    String response = requestHandler.handle(request);  
                    //然后返回出去  
                    channel.write(ByteBuffer.wrap(response.getBytes()));  
                }  
                iterator.remove();  
            }  
        }  
    }  
}

运行结果：

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

package com.test.io;  
import java.io.IOException;  
import java.io.OutputStream;  
import java.net.Socket;  
import java.util.Scanner;   
//TCP协议Socket：客户端  
public class Client01 {  
    public static void main(String[] args) throws IOException {  
        //创建套接字对象socket并封装ip与port  
        Socket socket = new Socket("127.0.0.1", 8000);  
        //根据创建的socket对象获得一个输出流  
        OutputStream outputStream = socket.getOutputStream();  
        //控制台输入以IO的形式发送到服务器  
        System.out.println("TCP连接成功 \n请输入：");  
        while(true){  
            byte[] car = new Scanner(System.in).nextLine().getBytes();  
            outputStream.write(car);  
            System.out.println("TCP协议的Socket发送成功");  
            //刷新缓冲区  
            outputStream.flush();  
        }  
    }  
}

在这里插入图片描述

1、先添加依赖：

<dependency>  
    <groupId>io.netty</groupId>  
    <artifactId>netty-all</artifactId>  
    <version>4.1.16.Final</version>  
</dependency>

2、NettyServer 模板，看起来代码那么多，其实只需要添加一行消息就好了

请认真看中间的代码

package com.lijie.iob;  
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.serialization.ClassResolvers;  
import io.netty.handler.codec.serialization.ObjectEncoder;  
import io.netty.handler.codec.string.StringDecoder;  
public class NettyServer {  
    public static void main(String[] args) throws InterruptedException {  
        EventLoopGroup bossGroup = new NioEventLoopGroup();  
        EventLoopGroup workerGroup = new NioEventLoopGroup();  
        try {  
            ServerBootstrap b = new ServerBootstrap();  
            b.group(bossGroup, workerGroup)  
                    .channel(NioServerSocketChannel.class)  
                    .childHandler(new ChannelInitializer<SocketChannel>() {  
                        @Override  
                        protected void initChannel(SocketChannel socketChannel) throws Exception {  
                            ChannelPipeline pipeline = socketChannel.pipeline();  
                            pipeline.addLast(new StringDecoder());  
                            pipeline.addLast("encoder", new ObjectEncoder());  
                            pipeline.addLast(" decoder", new io.netty.handler.codec.serialization.ObjectDecoder(Integer.MAX_VALUE, 
                             ClassResolvers.cacheDisabled(null)));  
                            //重点，其他的都是复用的  
                            //这是真正的I0的业务代码，把他封装成一个个的个Hand1e类就行了  
                            //把他当成 SpringMVC的Controller  
                            pipeline.addLast(new NettyServerHandler());  
                        }  
                    })  
                    .option(ChannelOption.SO_BACKLOG, 128)  
                    .childOption(ChannelOption.SO_KEEPALIVE, true);  
            ChannelFuture f = b.bind(8000).sync();  
            System.out.println("服务端启动成功，端口号为:" + 8000);  
            f.channel().closeFuture().sync();  
        } finally {  
            workerGroup.shutdownGracefully();  
            bossGroup.shutdownGracefully();  
        }  
    }  
}

在这里插入图片描述

package com.lijie.iob;  
import io.netty.channel.Channel;  
import io.netty.channel.ChannelHandlerContext;  
import io.netty.channel.ChannelInboundHandlerAdapter;  
public class NettyServerHandler extends ChannelInboundHandlerAdapter {  
    RequestHandler requestHandler = new RequestHandler();  
  
    @Override  
    public void handlerAdded(ChannelHandlerContext ctx) throws Exception {  
        Channel channel = ctx.channel();  
        System.out.println(String.format("客户端信息： %s", channel.remoteAddress()));  
    }  
  
    @Override  
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {  
        Channel channel = ctx.channel();  
        String request = (String) msg;  
        System.out.println(String.format("客户端发送的消息 %s : %s", channel.remoteAddress(), request));  
        String response = requestHandler.handle(request);  
        ctx.write(response);  
        ctx.flush();  
    }  
}

在这里插入图片描述

package com.test.io;  
import java.io.IOException;  
import java.io.OutputStream;  
import java.net.Socket;  
import java.util.Scanner;  
//TCP协议Socket：客户端  
public class Client01 {  
    public static void main(String[] args) throws IOException {  
        //创建套接字对象socket并封装ip与port  
        Socket socket = new Socket("127.0.0.1", 8000);  
        //根据创建的socket对象获得一个输出流  
        OutputStream outputStream = socket.getOutputStream();  
        //控制台输入以IO的形式发送到服务器  
        System.out.println("TCP连接成功 \n请输入：");  
        while(true){  
            byte[] car = new Scanner(System.in).nextLine().getBytes();  
            outputStream.write(car);  
            System.out.println("TCP协议的Socket发送成功");  
            //刷新缓冲区  
            outputStream.flush();  
        }  
    }  
}

运行结果：

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

Netty中提供了哪些线程模型？

转载：https://zhuanlan.zhihu.com/p/528673178

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

天空～之城
关注
专栏目录
Netty中对象序列化传输机制研究分析
网络
09-18 501
1.      技术点描述本文档主要说明如何利用netty进行对象传输2.      实现方案前提条件：对象须实现序列化。基本思想：借助netty自带的ObjectDecoder和ObjectEncoder类实现对象序列化的传输3.      参考源码包源码包：org.jboss.netty.handler.codec.serialization3.1.    ObjectDecoder此类主要完
netty4 java序列化_netty java序列化
weixin_35683252的博客
02-26 104
netty的java序列化使用.addLast(newObjectEncoder()).addLast(newObjectDecoder(ClassResolvers.weakCachingResolver(this.getClass().getClassLoader())))ObjectDecoder继承了LengthFieldBasedFrameDecoder 首先看LengthFieldBa...
netty 实现rpc框架
weixin_43931625的博客
06-03 250
netty 实现rpc框架
Java序列化编解码器
小黄宝宝的专栏
10-19 334
ServerBootstrap bootstrap = new ServerBootstrap(); bootstrap.group(bossGroup, workerGroup) .channel(NioServerSocketChannel.class) .option(ChannelOp...
Netty 入门
shuaijunlan的专栏
05-11 354
原文地址：http://www.blog.shuaijunlan.cn/2018/05/10/netty-introduction/ Netty is a NIO client server framework which enables quick and easy development of network applications such as protocol servers ...
2024年Java常见的-BIO,NIO,AIO,Netty面试题
04-20
### 2024年Java常见BIO、NIO、AIO、Netty面试题解析 #### 一、基础知识概述 1. **IO概念**： - Java中的I/O（Input/Output）指的是输入输出操作，它以流为基础进行数据的输入输出。所有的数据在Java中都是以流的...
BIO,NIO,AIO,Netty面试题.pdf
04-07
### BIO、NIO、AIO、Netty 面试题解析 #### 1. Java IO 基础概述 Java中的I/O操作是通过流（Stream）来实现的，所有的数据都通过流的方式被串行化处理。串行化的含义在于数据必须按顺序输入输出。Java中的IO操作...
Java BIO、NIO、AIO、Netty知识详解（值得珍藏）
01-11
Netty是一个基于NIO的高性能、高可靠的网络通信框架，它简化了网络应用的开发，提供了事件驱动和异步的编程模型，能够快速构建出TCP、UDP等协议的服务器和客户端。Netty在BIO和NIO的基础上，通过其强大的API和设计...
Netty之传输POJO(使用Java自带的序列化方式)
Learning
12-15 7952
1、使用Netty传输POJO对象，重点在于对象的序列化。序列化的对象通过TCP进行网络传输，结合Netty提供的对象编解码器，可以做到远程传输对象。首先Java需要序列化的对象，需要实现java.io.Serializable接口. 2、工程目录        2.1 项目的目录结构                2.2  关于Request和Response的讲解          
struts2对Ognl的封装--ClassResolver
java12345678
03-19 278
Ognl的扩展点： http://java12345678.iteye.com/blog/2031790   OGNL ClassResolver接口 :     用于由类名到类路径中找到Class文件，并加载生成Class对象，以支持静态属性或方法的调用 Struts对ClassResolver 的扩展：     Struts中ClassResolver的加载：   Ognl...
netty实现简单rpc
feinifi的博客
08-16 2244
RPC是Remote Procedure Call的简称，即远程过程调用，通过rpc，我们可以像调用本地接口一样，调用远程接口。在这个过程中，接口的实现对我们透明。实现rpc的框架很多，比如著名的dubbo框架，这里介绍通过netty来实现一个简单的rpc。 这里分为三个项目，分别是netty-rpc-api（定义接口）,netty-rpc-consumer（客户端）,netty-rpc-reg...
Netty发送序列化对象
Coder_py的博客
06-02 846
Netty发送序列化对象 发送对象： public class Message implements Serializable{ private static final long serialVersionUID = 3663916219982277840L; private String msg; private Long msgId; publi
Java简易RPC框架学习（二）---传输层
Maitianshouwei的专栏
12-04 1628
众做周知七层协议中的传输层的作用，这里的传输层的作用也类似，即封装了tcp，ip协议传输的实现，使用者不需要关系底层传输细节的实现，只需要调用接口来传输所需要的数据。为了实现这一层，可以使用最基本的套接字接口，java现有版本提供了OIO，NIO，BIO等技术，方便开发者创建自己的网络传输应用。但是，本文的重点不在于造轮子，没必要自己写网络传输系统。而且java的OIO（Old IO），和NIO（
超硬核！！！一篇文章搞定BIO、NIO、AIO、Netty（详细基础内容+网络编程内容+代码示例）
小杰爱吃蛋的博客
04-05 1788
BIO、NIO、AIO、NettyBIO、NIO、AIO、Netty什么是IO在了解不同的IO之前先了解：同步与异步，阻塞与非阻塞的区别什么是BIO什么是NIO什么是AIO什么NettyBIO和NIO、AIO的区别IO流的分类什么是内核空间五种IO模型1.阻塞IO（blocking I/O）2.非阻塞IO（noblocking I/O）3.异步IO（asynchronous I/O）4.信号驱动I...
java NIO实现UDP通讯
最新发布
简单，坚持
09-27 102
本文讲解如何以NIO方式接收udp报文，实现单线程接收并处理所有报文。
mysql复合查询 -- 合并查询(union,union all)
m0_74206992的博客
09-23 410
合并查询(union,union all)
java Nio的应用
golove666的博客
09-22 307
Java NIO适合构建需要高并发和高性能的应用程序，特别是在网络通信和文件操作方面。它的非阻塞特性和选择器机制为开发者提供了灵活性和高效性。
Java IO模型解析：BIO、NIO、AIO与Netty面试要点
在Java的IO领域，BIO、NIO、AIO和Netty是四个关键的概念，它们代表了不同类型的I/O模型，对于理解和优化网络通信效率至关重要。 1. BIO（ Blocking I/O）： BIO是一种同步阻塞的I/O模型。在Java中，当一个线程调用...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值