Netty学习之读netty权威指南（一）

全栈程序员站长

发布于 2022-11-11 14:58:08

2060

发布于 2022-11-11 14:58:08

大家好，又见面了，我是你们的朋友全栈君。

大家问我为什么读这个来学netty，嗯嗯嗯？？我也说不上来，因为我以前看过某个培训班的课程，初步了解了一下netty，但是现在回想一下发现我所有的知识基本忘光了，不过没关系，慢慢来，一点一点的找回来不久好了吗，现在开始咱们读一读Netty权威指南这本书，学习一下Netty。当然了不会全部按照这本书来，我会加上自己学习的东西。

I/O 演进之路

JDK 1.4 以前Java对 IO 的支持不完善，Java开发大佬在开发高并发的程序的时候不如 C 或者 C++，会面临一些挑战：没有数据缓冲区啦，没有Channel的概念啦，BIO 性能太菜啦，支持的字符集有限呀之类的问题。后来大佬们开始励精图治，改变改变再改变最后终于达成所愿的励志故事，这个咱们就不细说了，百度一下子Linux的网络IO模型看一看，咱们就往后简单的说说BIO、NIO、AIO的简单例子，大家看看有啥不懂的先百度搜一下这三个东西。

BIO

现在我们就以客户端向服务端发送请求获取当前时间的指令，而服务端返回当前时间给客户端的例子开始BIO。

TimeServer 也就是服务端代码

package BIO;
import javax.sound.midi.Soundbank;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.text.SimpleDateFormat;
import java.util.Date;
public class TimeServer {
public static void main(String[] args) {
int port = 8989;//服务端启动的端口号
ServerSocket serverSocket = null;
try{
serverSocket = new ServerSocket(port);//server端启动对接口的监听
System.out.println("服务端启动了端口号是: "+ port);
Socket socket = null;
while (true){ //无限循环监听客户端的连接
System.out.println("开始等待客户端连接");
socket = serverSocket.accept();
//启动一个线程用来处理客户端的连接
System.out.println("客户端连接了");
new Thread(new TimeServerHandler(socket)).start();
}
}catch (Exception e){
System.out.println("服务端发生异常");
}finally {
if (serverSocket != null){
try {
serverSocket.close();
} catch (IOException e) {
System.out.println("服务端关闭异常");
e.printStackTrace();
}
}
}
}
}
class TimeServerHandler implements Runnable{
private  Socket socket;
public TimeServerHandler(Socket socket) {
this.socket = socket;
}
@Override
public void run() {
//定义输入输出流
BufferedReader in = null;
PrintWriter out = null;
try {
in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
out = new PrintWriter(socket.getOutputStream(),true);
String order = null;//接收客户端的数据
String response = null ;//返回客户端的数据
while (true){
order = in.readLine();
if (null == order) break;//如果读不到数据了就跳出循环
response = "获取当前时间".equals(order)?new SimpleDateFormat("yyyy-MM-dd hh:mm:ss").format(new Date()):"指令有误";
//将当前时间返回去
out.println(response);
System.out.println("向客户端响应成功");
}
} catch (IOException e) {
e.printStackTrace();
}finally {
try {
if (in !=null)
in.close();
if (out !=null)
out.close();
} catch (IOException e) {
e.printStackTrace();
}
try {
if (socket !=null)
socket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}

Timeclient 也就是客户端代码

package BIO;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.Socket;
public class TimeClient {
public static void main(String[] args) {
int port = 8989;
Socket socket = null;
BufferedReader in = null;
PrintWriter out = null;
try {
socket = new Socket("127.0.0.1",port);
//获取输入流()
in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
//获取输出流
out = new PrintWriter(socket.getOutputStream(),true);
String order = "获取当前时间";
out.println(order);//向服务器发送数据
System.out.println("向服务器发送指令完成，指令内容是:"+order);
String recive = in.readLine();
System.out.println("从服务器获取到的当前时间是："+ recive);
} catch (IOException e) {
e.printStackTrace();
}finally {
try {
if (socket !=null)
socket.close();
} catch (IOException e) {
e.printStackTrace();
}
try {
if (in != null)
in.close();
if (out != null)
out.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}

上边的例子挺简单的，具体咱们就不分析了。BIO是同步阻塞的，一个客户端连接了，服务端就会启动一个线程来响应，太浪费资源了。BIO大家不是很了解的话建议先了解一下再往下看。

NIO

书上的太官方了，我通俗的解释一下。烧开水，去厨房烧开水，烧上水之后就爱干啥干啥去，隔段时间过来看看水开没开。NIO有三大组件

Selector：多路复用器。轮询注册在其上的Channel，当发现某个或者多个Channel处于“就绪状态”后（accept接收连接事件、connect连接完成事件、read读事件、write写事件），从阻塞状态返回就绪的Channel的SelectionKey集合，之后进行IO操作。
Channel：封装了socket。
- ServerSocketChannel：封装了ServerSocket，用于accept客户端连接请求；
- SocketChannel：一对SocketChannel组成一条虚电路，进行读写通信
Buffer：用于存取数据，最主要的是ByteBuffer
- position：下一个将被操作的字节位置
- limit：在写模式下表示可以进行写的字节数，在读模式下表示可以进行读的字节数
- capacity：Buffer的大小

现在咱们看一下NIO写的这个时间服务器的例子我理解的都写在注释里了

TimeServer

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.text.SimpleDateFormat;
import java.util.Date;
import java.util.Iterator;
import java.util.Set;
public class TimeServer {
public static void main(String[] args) {
int port = 8999;
//创建Handler
MultiplexerTimeServer multiplexerTimeServer = new MultiplexerTimeServer(port);
new Thread(multiplexerTimeServer,"Nio-00001").start();
}
}
class MultiplexerTimeServer implements Runnable{
private int port;
private Selector selector;
private ServerSocketChannel serverSocketChannel;
private volatile boolean stop;
public MultiplexerTimeServer(int port) {
try {
//开启一个通道
serverSocketChannel = ServerSocketChannel.open();
//将通道设置为非阻塞
//在该socket上的读写都不阻塞，也就是读写操作立即返回，无论有没有数据。
serverSocketChannel.configureBlocking(false);
// serverSocketChannel.socket() 返回的是serverSocket
//serverSocket.bind()的解释是开发中需要开启服务端的时候，本地测试都是直接写端口，实际环境也是需要指定要邦定的IP才可以。
//因为对于服务器来说，有时它不止一块网卡，而我们系统一定是通过指定的IP和端口进行通信的，所以服务端所使用的IP和端口都需要定义配置文件。
//那么在平常测试时，在没有指定IP的情况下，ServerSocket到底邦定到哪里了？
//在这种情况下，服务器会把此端口绑定到0.0.0.0上面，即在所有IP上面都绑定，即能在每个ip上面收到请求。
//1024 是最大连接数
serverSocketChannel.socket().bind(new InetSocketAddress(port),1024);
//启动多路复用器
selector = Selector.open();
//将channel注册进多路复用器 OP_CONNECT代表有客户端连接
serverSocketChannel.register(selector,SelectionKey.OP_ACCEPT);
//相当于做个开关
this.stop = false;
} catch (IOException e) {
e.printStackTrace();
}
}
public void stop(){
this.stop = true;
}
//run正式处理业务
@Override
public void run() {
//不执行stop()就是死循环
while (!stop){
try {
//轮询器阻塞1秒钟
selector.select(1000);
//查询就绪的通道返回
//SelectionKey是一个抽象类,
// 表示selectableChannel在Selector中注册的标识.
// 每个Channel向Selector注册时,都将会创建一个selectionKey
Set<SelectionKey> selectionKeySet = selector.selectedKeys();
//Iterator遍历
Iterator<SelectionKey> it = selectionKeySet.iterator();
SelectionKey key = null;
while (it.hasNext()){
key = it.next();
try {
handleInput(key);
}catch (Exception e){
}
//处理过key之后关闭 ???
if(key != null) {
key.cancel();
if(key.channel() != null) {
key.channel().close();
}
}
}
} catch (IOException e) {
e.printStackTrace();
}
}
//多路复用器关闭以后，所有注册在上面的Channel和Pipe等资源都会自动去注册并关闭，所以不需要重复释放资源
if(selector != null) {
try{
selector.close();
}catch(IOException e){
e.printStackTrace();
}
}
}
public void handleInput(SelectionKey key) throws IOException {
//判断这个key是否有效
if (key.isValid()){
//判断是哪种事件
//SelectionKey.OP_ACCEPT —— 接收连接继续事件，表示服务器监听到了客户连接，服务器可以接收这个连接了
//SelectionKey.OP_CONNECT —— 连接就绪事件，表示客户与服务器的连接已经建立成功
//SelectionKey.OP_READ —— 读就绪事件，表示通道中已经有了可读的数据，可以执行读操作了（通道目前有数据，可以进行读操作了）
//SelectionKey.OP_WRITE —— 写就绪事件，表示已经可以向通道写数据了（通道目前可以用于写操作）
if (key.isAcceptable()){
ServerSocketChannel serverSocketChannel = (ServerSocketChannel) key.channel();
//获得处理请求的通道
SocketChannel sc = serverSocketChannel.accept();
//将channel设置为非阻塞
sc.configureBlocking(false);
//将此通道注册进轮询器，并监听输入事件
sc.register(selector,SelectionKey.OP_READ);
}
}
//判读是输入事件时处理
if (key.isReadable()){
SocketChannel sc = (SocketChannel)key.channel();
ByteBuffer readBuffer = ByteBuffer.allocate(1024);
//将通道的内容读到buffer
int readBytes = sc.read(readBuffer);
//如果有数据
if (readBytes > 0){
readBuffer.flip();
//创建一个跟buffer一样容量的字节数组
byte[] bytes = new byte[readBuffer.remaining()];
//将数据从buffer读到字节数组
readBuffer.get(bytes);
String body = new String(bytes, "UTF-8");
String response = "获取当前时间".equals(body)?new SimpleDateFormat("yyyy-MM-dd hh:mm:ss").format(new Date()):"指令有误";
byte[] bytes1 = response.getBytes();
ByteBuffer writeBuffer  = ByteBuffer.allocate(bytes1.length);
writeBuffer.put(bytes1);
writeBuffer.flip();
sc.write(writeBuffer);
}else{
key.cancel();
sc.close();
}
}
}
}

AIO

咱们暂且先不用AIO，因为netty4没有用到，所以略过了，后边有机会补上。

发布者：全栈程序员栈长，转载请注明出处：https://javaforall.cn/186654.html原文链接：https://javaforall.cn

本文参与腾讯云自媒体同步曝光计划，分享自作者个人站点/博客。

原始发表：2022年10月2日，如有侵权请联系 cloudcommunity@tencent.com 删除

自动驾驶