Netty簡介

Netty是由JBOSS提供的一個java開源框架。Netty提供非同步的、事件驅動的網路應用程式框架和工具，用以快速開發高效能、高可靠性的網路伺服器和客戶端程式。

也就是說，Netty 是一個基於NIO的客戶、伺服器端程式設計框架，使用Netty 可以確保你快速和簡單的開發出一個網路應用，例如實現了某種協議的客戶，服務端應用。Netty相當簡化和流線化了網路應用的程式設計開發過程，例如，TCP和UDP的socket服務開發。

“快速”和“簡單”並不用產生維護性或效能上的問題。Netty 是一個吸收了多種協議的實現經驗，這些協議包括FTP,SMTP,HTTP，各種二進位制，文字協議，並經過相當精心設計的專案，最終，Netty 成功的找到了一種方式，在保證易於開發的同時還保證了其應用的效能，穩定性和伸縮性。
 

本文的目的

使用Netty實現一個Socket通訊，包括客戶端和服務端，通過服務端進行監聽，客戶端傳送資訊，服務端可進行接收，並進行返回資料，完成一個完整的通訊。

工程結構

POM檔案配置

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
 

    <modelVersion>4.0.0</modelVersion>
    <groupId>com.taowd.socket</groupId>
    <artifactId>SocketDemo2</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <dependencies>
        <!-- https://mvnrepository.com/artifact/io.netty/netty-all -->
        <dependency
 
>
            <groupId>io.netty</groupId>
            <artifactId>netty-all</artifactId>
            <version>4.1.6.Final</version>
        </dependency>
    </dependencies>
</project>

服務端程式碼

EchoServer.java

package Server;

import java.nio.charset.Charset;

import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelOption;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import io.netty.handler.codec.bytes.ByteArrayEncoder;
import io.netty.handler.codec.string.StringEncoder;

public class EchoServer {
    private final int port;

    public EchoServer(int port) {
        this.port = port;
    }

    public void start() throws Exception {
        EventLoopGroup bossGroup = new NioEventLoopGroup();

        EventLoopGroup group = new NioEventLoopGroup();
        try {
            ServerBootstrap sb = new ServerBootstrap();
            sb.option(ChannelOption.SO_BACKLOG, 1024);
            sb.group(group, bossGroup) // 繫結執行緒池
                    .channel(NioServerSocketChannel.class) // 指定使用的channel
                    .localAddress(this.port)// 繫結監聽埠
                    .childHandler(new ChannelInitializer<SocketChannel>() { // 繫結客戶端連線時候觸發操作

                        @Override
                        protected void initChannel(SocketChannel ch) throws Exception {
                            System.out.println("報告");
                            System.out.println("資訊：有一客戶端連結到本服務端");
                            System.out.println("IP:" + ch.localAddress().getHostName());
                            System.out.println("Port:" + ch.localAddress().getPort());
                            System.out.println("報告完畢");

                            ch.pipeline().addLast(new StringEncoder(Charset.forName("GBK")));
                            ch.pipeline().addLast(new EchoServerHandler()); // 客戶端觸發操作
                            ch.pipeline().addLast(new ByteArrayEncoder());
                        }
                    });
            ChannelFuture cf = sb.bind().sync(); // 伺服器非同步建立繫結
            System.out.println(EchoServer.class + " 啟動正在監聽： " + cf.channel().localAddress());
            cf.channel().closeFuture().sync(); // 關閉伺服器通道
        } finally {
            group.shutdownGracefully().sync(); // 釋放執行緒池資源
            bossGroup.shutdownGracefully().sync();
        }
    }

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

        new EchoServer(8888).start(); // 啟動
    }
}

EchoServerHandler.java

package Server;

import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.text.SimpleDateFormat;
import java.util.Date;

import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelFutureListener;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;

public class EchoServerHandler extends ChannelInboundHandlerAdapter {

    /*
     * channelAction
     *
     * channel 通道 action 活躍的
     *
     * 當客戶端主動連結服務端的連結後，這個通道就是活躍的了。也就是客戶端與服務端建立了通訊通道並且可以傳輸資料
     *
     */
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        System.out.println(ctx.channel().localAddress().toString() + " 通道已啟用！");
    }

    /*
     * channelInactive
     *
     * channel 通道 Inactive 不活躍的
     *
     * 當客戶端主動斷開服務端的連結後，這個通道就是不活躍的。也就是說客戶端與服務端的關閉了通訊通道並且不可以傳輸資料
     *
     */
    public void channelInactive(ChannelHandlerContext ctx) throws Exception {
        System.out.println(ctx.channel().localAddress().toString() + " 通道不活躍！");
        // 關閉流

    }

    /**
     * 
     * @author Taowd
     * TODO  此處用來處理收到的資料中含有中文的時  出現亂碼的問題
     * 2017年8月31日 下午7:57:28
     * @param buf
     * @return
     */
    private String getMessage(ByteBuf buf) {
        byte[] con = new byte[buf.readableBytes()];
        buf.readBytes(con);
        try {
            return new String(con, "UTF-8");
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 功能：讀取伺服器傳送過來的資訊
     */
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        // 第一種：接收字串時的處理
        ByteBuf buf = (ByteBuf) msg;
        String rev = getMessage(buf);
        System.out.println("客戶端收到伺服器資料:" + rev);

    }

    /**
     * 功能：讀取完畢客戶端傳送過來的資料之後的操作
     */
    @Override
    public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
        System.out.println("服務端接收資料完畢..");
        // 第一種方法：寫一個空的buf，並重新整理寫出區域。完成後關閉sock channel連線。
        ctx.writeAndFlush(Unpooled.EMPTY_BUFFER).addListener(ChannelFutureListener.CLOSE);
        // ctx.flush();
        // ctx.flush(); //
        // 第二種方法：在client端關閉channel連線，這樣的話，會觸發兩次channelReadComplete方法。
        // ctx.flush().close().sync(); // 第三種：改成這種寫法也可以，但是這中寫法，沒有第一種方法的好。
    }

    /**
     * 功能：服務端發生異常的操作
     */
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        ctx.close();
        System.out.println("異常資訊：\r\n" + cause.getMessage());
    }
}

客戶端程式碼

EchoClient.java

package Cilent;

import java.net.InetSocketAddress;
import java.nio.charset.Charset;

import io.netty.bootstrap.Bootstrap;
import io.netty.channel.ChannelFuture;
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.handler.codec.bytes.ByteArrayEncoder;
import io.netty.handler.codec.string.StringEncoder;
import io.netty.handler.stream.ChunkedWriteHandler;

public class EchoClient {
    private final String host;
    private final int port;

    public EchoClient() {
        this(0);
    }

    public EchoClient(int port) {
        this("localhost", port);
    }

    public EchoClient(String host, int port) {
        this.host = host;
        this.port = port;
    }

    public void start() throws Exception {
        EventLoopGroup group = new NioEventLoopGroup();
        try {
            Bootstrap b = new Bootstrap();
            b.group(group) // 註冊執行緒池
                    .channel(NioSocketChannel.class) // 使用NioSocketChannel來作為連線用的channel類
                    .remoteAddress(new InetSocketAddress(this.host, this.port)) // 繫結連線埠和host資訊
                    .handler(new ChannelInitializer<SocketChannel>() { // 繫結連線初始化器
                        @Override
                        protected void initChannel(SocketChannel ch) throws Exception {
                            System.out.println("正在連線中...");
                            ch.pipeline().addLast(new StringEncoder(Charset.forName("GBK")));
                            ch.pipeline().addLast(new EchoClientHandler());
                            ch.pipeline().addLast(new ByteArrayEncoder());
                            ch.pipeline().addLast(new ChunkedWriteHandler());

                        }
                    });
            // System.out.println("服務端連線成功..");

            ChannelFuture cf = b.connect().sync(); // 非同步連線伺服器
            System.out.println("服務端連線成功..."); // 連線完成

            cf.channel().closeFuture().sync(); // 非同步等待關閉連線channel
            System.out.println("連線已關閉.."); // 關閉完成

        } finally {
            group.shutdownGracefully().sync(); // 釋放執行緒池資源
        }
    }

    public static void main(String[] args) throws Exception {
        new EchoClient("127.0.0.1", 8888).start(); // 連線127.0.0.1/65535，並啟動

    }
}

EchoClientHandler.java

package Cilent;

import java.nio.charset.Charset;

import io.netty.buffer.ByteBuf;
import io.netty.buffer.ByteBufUtil;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;
import io.netty.util.CharsetUtil;

public class EchoClientHandler extends SimpleChannelInboundHandler<ByteBuf> {

    /**
     * 向服務端傳送資料
     */
    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        System.out.println("客戶端與服務端通道-開啟：" + ctx.channel().localAddress() + "channelActive");

        String sendInfo = "Hello 這裡是客戶端  你好啊！";
        System.out.println("客戶端準備傳送的資料包：" + sendInfo);
        ctx.writeAndFlush(Unpooled.copiedBuffer(sendInfo, CharsetUtil.UTF_8)); // 必須有flush

    }

    /**
     * channelInactive
     *
     * channel 通道 Inactive 不活躍的
     *
     * 當客戶端主動斷開服務端的連結後，這個通道就是不活躍的。也就是說客戶端與服務端的關閉了通訊通道並且不可以傳輸資料
     *
     */
    public void channelInactive(ChannelHandlerContext ctx) throws Exception {
        System.out.println("客戶端與服務端通道-關閉：" + ctx.channel().localAddress() + "channelInactive");
    }

    @Override
    protected void channelRead0(ChannelHandlerContext ctx, ByteBuf msg) throws Exception {
        System.out.println("讀取客戶端通道資訊..");
        ByteBuf buf = msg.readBytes(msg.readableBytes());
        System.out.println(
                "客戶端接收到的服務端資訊:" + ByteBufUtil.hexDump(buf) + "; 資料包為:" + buf.toString(Charset.forName("utf-8")));
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        ctx.close();
        System.out.println("異常退出:" + cause.getMessage());
    }
}

執行結果圖