Netty入门，一名毕业三年的女程序媛面试头条经验

package com.zy.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 {

ExecutorService newCachedThreadPool = Executors.newCachedThreadPool();

// 创建socket服务，监听10101端口

ServerSocket serverSocket = new ServerSocket(12333);

System.out.println(“服务启动!”);

while (true) {

//获取一个套接字（阻塞）

final Socket socket = serverSocket.accept();

System.out.println(“来一个新客户端!”);

newCachedThreadPool.execute(() -> {

// 业务处理

handler(socket);

});

}

}

/**

• 读取数据

• @param socket

• @throws Exception

*/

private static void handler(Socket socket) {

byte[] bytes = new byte[1024];

try {

InputStream inputStream = socket.getInputStream();

while (true) {

//读取数据（阻塞）

int read = inputStream.read(bytes);

if (read != -1) {

System.out.println(Thread.currentThread().getName() + “:” + new String(bytes, 0, read));

} else {

break;

}

}

} catch (IOException e) {

e.printStackTrace();

} finally {

try {

if (socket != null) {

System.out.println(“socket 关闭”);

socket.close();

}

} catch (IOException e) {

e.printStackTrace();

}

}

}

}

Client:

package com.zy.bio;

import java.io.BufferedWriter;

import java.io.IOException;

import java.io.OutputStreamWriter;

import java.net.Socket;

public class BioClient {

public static void main(String[] args) {

BufferedWriter bufferedWriter = null;

try {

Socket socket = new Socket(“localhost”, 12333);

bufferedWriter = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));

bufferedWriter.write(“zzzzzyyyyy”);

bufferedWriter.flush();

} catch (IOException e) {

e.printStackTrace();

} finally {

try {

if (bufferedWrite

《一线大厂Java面试题解析+后端开发学习笔记+最新架构讲解视频+实战项目源码讲义》

【docs.qq.com/doc/DSmxTbFJ1cmN1R2dB】 完整内容开源分享

r != null) {

bufferedWriter.close();

}

} catch (IOException e) {

e.printStackTrace();

}

}

}

}

会起很多线程，如果十万个客户端，就会有十万个线程。。。。很可怕

NIO

===

Server

package com.zy.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;

public class NioServer {

// 通道管理器

private Selector selector;

/**

• 获得一个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(“新的客户端连接”);

// 在和客户端连接成功之后，为了可以接收到客户端的信息，需要给通道设置读的权限。

// SelectionKey.OP_WRITE表示底层缓冲区是否有空间，是则响应返回false

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);

buffer.clear();

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();

}

}

/**

• 启动服务端测试

• @throws IOException

*/

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

NioServer server = new NioServer();

server.initServer(8009);

server.listen();

}

}

ByteBuffer 很容易出错，读写时，需要不断的切换读写模式，并且还需要获取读写指针

Netty中使用ByteBuf有读写两个指针，不容易出错，并且使用了Zero Copy。可以分配在直接内存中，中间少了一个copy过程，效率很高

Netty：

======

依赖：

io.netty

netty-all

4.1.42.Final

client:

package com.zy.netty.server;

import io.netty.bootstrap.Bootstrap;

import io.netty.buffer.ByteBuf;

import io.netty.buffer.Unpooled;

import io.netty.channel.ChannelFuture;

import io.netty.channel.ChannelHandlerContext;

import io.netty.channel.ChannelInboundHandlerAdapter;

import io.netty.channel.ChannelInitializer;

import io.netty.channel.EventLoopGroup;

import io.netty.channel.nio.NioEventLoopGroup;

import io.netty.channel.socket.SocketChannel;

import io.netty.channel.socket.nio.NioSocketChannel;

import io.netty.util.CharsetUtil;

public class NettyClient {

public static void main(String[] args) {

// 负责服务

EventLoopGroup workerGroup = new NioEventLoopGroup(4);

// 服务类

Bootstrap bootstrap = new Bootstrap();

bootstrap.group(workerGroup);

bootstrap.channel(NioSocketChannel.class);

// netty帮我们内部处理了accept过程

bootstrap.handler(new ChannelInitializer() {

@Override

protected void initChannel(SocketChannel socketChannel) throws Exception {

socketChannel.pipeline().addLast(new MyClientHandler());

}