Introduction to Java IO model BIO, NIO, Netty

• The basic model of network programming is the C/S model, that is, communication between two processes.
• The server provides the IP address and monitoring port. The client initiates a connection request to the address monitored by the server through the connection operation. The client initiates a connection request through the three-way handshake.
• In the traditional synchronous blocking model, ServerSocket is responsible for binding IP addresses and starting listening ports. The Socket initiates the connection. After the connection is successful, the two sides communicate synchronously blocking through input and output streams.

The model of the biggest problems is the lack of elastic expansion ability, when the client after concurrent increased traffic, number number of concurrent access to the client and server thread is 1:1 proportion relations, in Java thread is valuable system resources, the rapid expansion of number of threads, after a sharp decline in the performance of the system will be, as the traffic continued to increase, the system eventually failed. This communication model is not applicable in high concurrency scenarios. ** Synchronous blocking BIO to create a Server source ** :Copy the code

package com.scoket.bio;

import java.io.IOException;
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 executor = Executors.newFixedThreadPool(3);
        RequestHandler requestHandler = new RequestHandler();
        try(ServerSocket serverSocket = new ServerSocket(8888)){
            System.out.println("BIOServer has started,listenning on port: "+serverSocket.getLocalSocketAddress());
            // Multiple clients request connections
            while (true) {
                Socket clientSocket = serverSocket.accept();
                System.out.println("Connection from" + clientSocket.getRemoteSocketAddress());
                // To allow the thread pool to execute the task
                executor.submit(newClientHandler(clientSocket,requestHandler)); }}}}Copy the code

Synchronous blocking BIO create Client

package com.scoket.bio;

import java.io.IOException;

import java.net.Socket;
import java.util.Scanner;

public class ClientHandler implements Runnable {
    private final Socket clientSocket;
    private final RequestHandler requestHandler;

    public ClientHandler(Socket clientSocket, RequestHandler requestHandler) {
        this.clientSocket = clientSocket;
        this.requestHandler = requestHandler;
    }
    @Override
    public void run(a) {
        try (Scanner input = new Scanner(clientSocket.getInputStream())) {
            // Unlimited interaction for each request
            while (true) {
                // The real cause of the block is the point where the thread is delayed while waiting for input from the client
                String request = input.nextLine();
                if ("quit".equals(request)) {
                    break; } System.out.println(request); String response = requestHandler.handler(request); clientSocket.getOutputStream().write(response.getBytes()); }}catch (IOException e){
            throw newRuntimeException(e); }}}Copy the code

Synchronous blocking BIO creates RequestHandler

package com.scoket.bio;

public class RequestHandler {
    public String handler(String request){
        return "From BIOServer Hello" + request + "\n"; }}Copy the code

• Netty communication channel: Through THE AOP programming thought (responsibility chain design pattern), the realization of message encoding and decoding.
  
  

  SBT =new ServerBootstrap(); 2) create an EventLoopGroup boss and worker. 3) associate boss and worker> sbt.group(boss,worker); 4) Set ServerSocketChannel implementation class SBT. channel(NioServerSocketChannel); 5) Initialize channel sbt.childHandler(initialize channel); ChannelFuture =sbt.bind(port).sync(); ChannelFuture =sbt.bind(port).sync(); Future.channel ().closeFuture().sync(); 10) Throwing thread resources into the environment where the worker # shutdownexceptionexceptionexception () occurs;

Netty create client source code:

package com.cherry.socket.netty.client;
import io.netty.bootstrap.Bootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.nio.NioSocketChannel;

public class ClientBootStrap {
    public static void main(String[] args) throws InterruptedException {
        //1.Create Bootstrap
        Bootstrap bt = new Bootstrap();
        //2.Create thread pool(worker)
        EventLoopGroup worker = new NioEventLoopGroup();
        //3. Associate the thread pool
        bt.group(worker);
        //4.Set up the client
        bt.channel(NioSocketChannel.class);
        //5.Initialize the communication channel (key point)
        bt.handler(new ClientChannelInitializer());
        / / 6. Connections
        ChannelFuture channelFuture = bt.connect("127.0.0.1".9999).sync();
        //7.Wait for the server to close
        channelFuture.channel().closeFuture().sync();
        //8.release the resourceworker.shutdownGracefully(); }}Copy the code

package com.cherry.socket.netty.client;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelHandlerAdapter;
import io.netty.channel.ChannelHandlerContext;
import io.netty.util.CharsetUtil;
import javax.xml.transform.Source;

public class ClientChannelHander extends ChannelHandlerAdapter {
    /* Catch an exception in the transmission of data in the channel */
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        //super.exceptionCaught(ctx, cause);
        System.out.println("Error:"+cause.getMessage());
    }
    /* Receive data */
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        //super.channelRead(ctx, msg);
        ByteBuf byteBuf = (ByteBuf) msg;
        System.out.println(((ByteBuf)msg).toString(CharsetUtil.UTF_8));
    }
    /* Send data when connecting to the server */
    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        //super.channelActive(ctx);
        ByteBuf buf = Unpooled.buffer();
        buf.writeBytes("Hello, this is the client!".getBytes()); ctx.writeAndFlush(buf); }}Copy the code

package com.cherry.socket.netty.client;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.socket.SocketChannel;

public class ClientChannelInitializer extends ChannelInitializer<SocketChannel> {
    @Override
    protected void initChannel(SocketChannel socketChannel) throws Exception {
        //communication channel
        ChannelPipeline pipeline = socketChannel.pipeline();
        pipeline.addLast(newClientChannelHander()); }}Copy the code

Pom.xml used by BIO NIO Netty above

<! --> <dependency> <groupId>io.netty</groupId> <artifactId>netty-all</artifactId> <version>5.0. 0.Alpha2</version>
</dependency>
Copy the code

Through the analysis of Netty, we summarize its advantages as follows: 1. Simple API and low development threshold; 2. 2. Powerful, preset a lot of coding functions, support a variety of mainstream protocols; 3. With strong customization capability, the communication framework can be flexibly extended through ChannelHandler; 4. High performance. Compared with other mainstream NIO frameworks, Netty has the best overall performance; 5. Mature and stable, Netty has fixed all JDK NIO bugs that have been found, and business developers do not need to worry about NIO bugs any more; 6. Active community, short version iteration cycle; 7. After large-scale commercial application test, the quality has been verified. Netty has been successfully commercialized in Internet, big data, online games, enterprise applications, telecom software and many other fields, and it has proved that it can fully meet the needs of business applications in different industries.