介紹下Netty中常用的編碼器和解碼器

作者：花花和Java 2020-12-22 07:58:46

這篇文章，介紹什么是編碼器、解碼器，也講述了如何實戰中運用編碼器和解碼器。希望能對有所幫助。

前面文章介紹Netty相關知識點。接下來將介紹下在通信過程中用的編碼器和解碼器。這里會不會聯想到諜戰戲里面。發送情報者怕情報泄露，所以對情報行加密然后傳給接收者。接收者對情報進行解密，得到情報。這里講的編碼器和解碼器是和情報傳遞很相似?一起查看這篇文章，來揭秘!!!
1一編解碼器

1 1.1 什么叫編解碼器

在網絡傳輸的過程中，數據都是以字節流的方式進行傳遞。客戶端在向服務端發送數據的時候，將業務中其他類型數據轉化為字節，叫編碼。服務端接收到數據為字節流，將字節流轉化為原來的格式，叫解碼。統稱codec。

編解碼器分為兩部分-編碼器和解碼器，編碼器負責出站，解碼器負責入站。

2 1.2 解碼器

1.2.1 概述

解碼器負責入站操作，那么也一定要實現ChannelInboundHandler接口，所以解碼器本質上也是ChannelHandler。我們自定義編解碼器只需要繼承ByteToMessageDecoder(Netty提供抽象類，繼承 ChannelInboundHandlerAdapter)，實現decode()。Netty提供一些常用的解碼器實現，開箱即用。如下：

1 RedisDecoder 基于Redis協議的解碼器 
2 XmlDecoder 基于XML格式的解碼器 
3 JsonObjectDecoder 基于json數據格式的解碼器 
4 HttpObjectDecoder 基于http協議的解碼器

Netty也提供了MessageToMessageDecoder，將⼀種格式轉化為另⼀種格式的解碼器，也提供了⼀些實現，如下：

1 StringDecoder 將接收到ByteBuf轉化為字符串 
2 ByteArrayDecoder 將接收到ByteBuf轉化字節數組 
3 Base64Decoder 將由ByteBuf或US-ASCII字符串編碼的Base64解碼為ByteBuf。

1.2.2 將字節流轉化為Intger類型(案例)

1. 字節解碼器

package com.haopt.netty.codec; 
import io.netty.buffer.ByteBuf; 
import io.netty.channel.ChannelHandlerContext; 
import io.netty.handler.codec.ByteToMessageDecoder; 
 
import java.util.List; 
public class ByteToIntegerDecoder extends ByteToMessageDecoder { 
    /** 
    * 
    * @param ctx 上下⽂ 
    * @param in 輸⼊的ByteBuf消息數據 
    * @param out 轉化后輸出的容器 
    * @throws Exception 
    */ 
    @Override 
    protected void decode(ChannelHandlerContext ctx, ByteBuf in, List<Object> out) throws Exception { 
        if(in.readableBytes() >= 4){ //int類型占⽤4個字節，所以需要判斷是否存在有4個字節，再進⾏讀取 
            out.add(in.readInt()); //讀取到int類型數據，放⼊到輸出，完成數據類型的轉化 
        } 
    } 
}

2. Handler

package com.haopt.netty.codec; 
import io.netty.channel.ChannelHandlerContext; 
import io.netty.channel.ChannelInboundHandlerAdapter; 
public class ServerHandler extends ChannelInboundHandlerAdapter { 
    @Override 
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception { 
        Integer i = (Integer) msg; //這⾥可以直接拿到Integer類型的數據 
        System.out.println("服務端接收到的消息為：" + i); 
    } 
}

3 在pipeline中添加解碼器

@Override 
protected void initChannel(SocketChannel ch) throws Exception { 
    ch.pipeline() 
    .addLast(new ByteToIntegerDecoder()) 
    .addLast(new ServerHandler()); 
}

可以將代碼復制到IDEA運行下，查看下運行效果。

3 1.3 編碼器

1.3.1 概述

將原來的格式轉化為字節。我們要實現自定義解碼器只要繼承MessageToByteEncoder(實現了ChannelOutboundHandler接⼝)，本質上也是ChannelHandler。Netty中一些實現的編碼器,如下：

1 ObjectEncoder 將對象（需要實現Serializable接⼝）編碼為字節流 
2 SocksMessageEncoder 將SocksMessage編碼為字節流 
3 HAProxyMessageEncoder 將HAProxyMessage編碼成字節流

Netty也提供了MessageToMessageEncoder，將⼀種格式轉化為另⼀種格式的編碼器，也提供了⼀些實現：

1 RedisEncoder 將Redis協議的對象進⾏編碼 
2 StringEncoder 將字符串進⾏編碼操作 
3 Base64Encoder 將Base64字符串進⾏編碼操作

1.3.2 將Integer類型編碼為字節進⾏傳遞(案例)

1. 自定義編碼器

package com.haopt.netty.codec.client; 
import io.netty.buffer.ByteBuf; 
import io.netty.channel.ChannelHandlerContext; 
import io.netty.handler.codec.MessageToByteEncoder; 
public class IntegerToByteEncoder extends MessageToByteEncoder<Integer> { 
    @Override 
    protected void encode(ChannelHandlerContext ctx, Integer msg, ByteBuf out) throws Exception { 
       out.writeInt(msg); 
    } 
}

2. Handler

package com.haopt.netty.codec.client; 
import io.netty.buffer.ByteBuf; 
import io.netty.buffer.Unpooled; 
import io.netty.channel.ChannelHandlerContext; 
import io.netty.channel.SimpleChannelInboundHandler; 
import io.netty.util.CharsetUtil; 
public class ClientHandler extends SimpleChannelInboundHandler<ByteBuf> { 
    @Override 
    protected void channelRead0(ChannelHandlerContext ctx, ByteBuf msg) throws Exception { 
        System.out.println("接收到服務端的消息：" + 
        msg.toString(CharsetUtil.UTF_8)); 
    } 
    @Override 
    public void channelActive(ChannelHandlerContext ctx) throws Exception { 
     ctx.writeAndFlush(123); 
    } 
    @Override 
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception { 
     cause.printStackTrace(); 
     ctx.close(); 
    } 
}

3. pipeline

@Override 
protected void initChannel(SocketChannel ch) throws Exception { 
    ch.pipeline().addLast(new IntegerToByteEncoder()); 
    ch.pipeline().addLast(new ClientHandler()); 
}

2 二開發Http服務器

通過Netty中提供的http的解碼器，進行http服務器開發。建議代碼復制下來，執行下看看效果。

4 2.1 Netty配置

1. server

package com.haopt.netty.codec.http; 
import io.netty.bootstrap.ServerBootstrap; 
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.NioServerSocketChannel; 
import io.netty.handler.codec.http.HttpObjectAggregator; 
import io.netty.handler.codec.http.HttpRequestDecoder; 
import io.netty.handler.codec.http.HttpResponseEncoder; 
import io.netty.handler.stream.ChunkedWriteHandler; 
public class NettyHttpServer { 
    public static void main(String[] args) throws Exception { 
        // 主線程，不處理任何業務邏輯，只是接收客戶的連接請求 
        EventLoopGroup boss = new NioEventLoopGroup(1); 
        // ⼯作線程，線程數默認是：cpu*2 
        EventLoopGroup worker = new NioEventLoopGroup(); 
        try { 
        // 服務器啟動類 
        ServerBootstrap serverBootstrap = new ServerBootstrap(); 
        serverBootstrap.group(boss, worker); 
        //配置server通道 
        serverBootstrap.channel(NioServerSocketChannel.class); 
        serverBootstrap.childHandler(new ChannelInitializer<SocketChannel>() { 
            @Override 
            protected void initChannel(SocketChannel ch) throws Exception { 
                ch.pipeline() 
                //http請求的解碼器 
                //將http請求中的uri以及請求體聚合成⼀個完整的FullHttpRequest對象 
                .addLast(new HttpRequestDecoder())  
                .addLast(new HttpObjectAggregator(1024 * 128)) 
                .addLast(new HttpResponseEncoder()) //http響應的編碼器 
                .addLast(new ChunkedWriteHandler()) //⽀持異步的⼤⽂件傳輸，防⽌內存溢出 
                .addLast(new ServerHandler()); 
            } 
          }); //worker線程的處理器 
          ChannelFuture future = serverBootstrap.bind(8080).sync(); 
          System.out.println("服務器啟動完成。。。。。"); 
          //等待服務端監聽端⼝關閉 
          future.channel().closeFuture().sync(); 
        } finally { 
          //優雅關閉 
          boss.shutdownGracefully(); 
          worker.shutdownGracefully(); 
      } 
     } 
}

2. ServerHandler

package com.haopt.netty.codec.http; 
import io.netty.buffer.Unpooled; 
import io.netty.channel.ChannelFutureListener; 
import io.netty.channel.ChannelHandlerContext; 
import io.netty.channel.ChannelInboundHandlerAdapter; 
import io.netty.channel.SimpleChannelInboundHandler; 
import io.netty.handler.codec.http.*; 
import io.netty.util.CharsetUtil; 
import java.util.Map; 
public class ServerHandler extends SimpleChannelInboundHandler<FullHttpRequest>{ 
    @Override 
    public void channelRead0(ChannelHandlerContext ctx, FullHttpRequest request) throws Exception { 
        //解析FullHttpRequest，得到請求參數 
        Map<String, String> paramMap = new RequestParser(request).parse(); 
        String name = paramMap.get("name"); 
        //構造響應對象 
        FullHttpResponse httpResponse = new DefaultFullHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.OK); 
        httpResponse.headers().set(HttpHeaderNames.CONTENT_TYPE,"text/html;charset=utf-8"); 
        StringBuilder sb = new StringBuilder(); 
        sb.append("<h1>"); 
        sb.append("你好，" + name); 
        sb.append("</h1>"); 
        httpResponse.content().writeBytes(Unpooled.copiedBuffer(sb,CharsetUtil.UTF_8)); 
        //操作完成后，將channel關閉 
        ctx.writeAndFlush(httpResponse).addListener(ChannelFutureListener.CLOSE);  
    } 
}

3. RequestParser

package com.haopt.netty.codec.http; 
import io.netty.handler.codec.http.FullHttpRequest; 
import io.netty.handler.codec.http.HttpMethod; 
import io.netty.handler.codec.http.QueryStringDecoder; 
import io.netty.handler.codec.http.multipart.Attribute; 
import io.netty.handler.codec.http.multipart.HttpPostRequestDecoder; 
import io.netty.handler.codec.http.multipart.InterfaceHttpData; 
import java.io.IOException; 
import java.util.HashMap; 
import java.util.List; 
import java.util.Map; 
/** 
* HTTP請求參數解析器, ⽀持GET, POST 
*/ 
public class RequestParser { 
    private FullHttpRequest fullReq; 
    /** 
    * 構造⼀個解析器 
    * @param req 
    */ 
    public RequestParser(FullHttpRequest req) { 
     this.fullReq = req; 
    } 
    /** 
    * 解析請求參數 
    * @return 包含所有請求參數的鍵值對, 如果沒有參數, 則返回空Map 
    * 
    * @throws IOException 
    */ 
    public Map<String, String> parse() throws Exception { 
        HttpMethod method = fullReq.method(); 
        Map<String, String> parmMap = new HashMap<>(); 
        if (HttpMethod.GET == method) { 
          // 是GET請求 
          QueryStringDecoder decoder = new QueryStringDecoder(fullReq.uri()); 
          decoder.parameters().entrySet().forEach( entry -> { 
          // entry.getValue()是⼀個List, 只取第⼀個元素 
          parmMap.put(entry.getKey(), entry.getValue().get(0)); 
          }); 
        } else if (HttpMethod.POST == method) { 
          // 是POST請求 
          HttpPostRequestDecoder decoder = new 
          HttpPostRequestDecoder(fullReq); 
          decoder.offer(fullReq); 
          List<InterfaceHttpData> parmList = decoder.getBodyHttpDatas(); 
          for (InterfaceHttpData parm : parmList) { 
          Attribute data = (Attribute) parm; 
          parmMap.put(data.getName(), data.getValue()); 
          } 
        } else { 
          // 不⽀持其它⽅法 
          throw new RuntimeException("不⽀持其它⽅法"); // 可以用自定義異常來替代 
        } 
        return parmMap; 
    } 
}

4. 對象

package com.haopt.netty.codec.obj; 
public class User implements java.io.Serializable { 
    private static final long serialVersionUID = -89217070354741790L; 
    private Long id; 
    private String name; 
    private Integer age; 
    public Long getId() { 
     return id; 
    } 
    public void setId(Long id) { 
     this.id = id; 
    } 
    public String getName() { 
     return name; 
    } 
    public void setName(String name) { 
     this.name = name; 
    } 
    public Integer getAge() { 
     return age; 
    } 
    public void setAge(Integer age) { 
     this.age = age; 
    } 
    @Override 
    public String toString() { 
      return "User{" + 
        "id=" + id + 
        ", name='" + name + '\'' + 
        ", age=" + age + 
        '}'; 
      } 
}

5 2.2 服務端

1. NettyObjectServer

package com.haopt.netty.codec.obj; 
import io.netty.bootstrap.ServerBootstrap; 
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.NioServerSocketChannel; 
import io.netty.handler.codec.serialization.ClassResolvers; 
import io.netty.handler.codec.serialization.ObjectDecoder; 
public class NettyObjectServer { 
    public static void main(String[] args) throws Exception { 
        // 主線程，不處理任何業務邏輯，只是接收客戶的連接請求 
        EventLoopGroup boss = new NioEventLoopGroup(1); 
        // ⼯作線程，線程數默認是：cpu*2 
        EventLoopGroup worker = new NioEventLoopGroup(); 
        try { 
        // 服務器啟動類 
        ServerBootstrap serverBootstrap = new ServerBootstrap(); 
        serverBootstrap.group(boss, worker); 
        //配置server通道 
        serverBootstrap.channel(NioServerSocketChannel.class); 
        serverBootstrap.childHandler(new ChannelInitializer<SocketChannel> () { 
            @Override 
            protected void initChannel(SocketChannel ch) throws Exception { 
                ch.pipeline() 
                .addLast(new ObjectDecoder(ClassResolvers.weakCachingResolver( 
                this.getClass().getClassLoader() 
                ))) 
                .addLast(new ServerHandler()); 
            } 
        }); //worker線程的處理器 
        ChannelFuture future = serverBootstrap.bind(6677).sync(); 
        System.out.println("服務器啟動完成。。。。。"); 
        //等待服務端監聽端⼝關閉 
        future.channel().closeFuture().sync(); 
        } finally { 
        //優雅關閉 
        boss.shutdownGracefully(); 
        worker.shutdownGracefully(); 
        } 
    } 
}

2. ServerHandler

package com.haopt.netty.codec.obj; 
import io.netty.buffer.Unpooled; 
import io.netty.channel.ChannelHandlerContext; 
import io.netty.channel.SimpleChannelInboundHandler; 
import io.netty.util.CharsetUtil; 
public class ServerHandler extends SimpleChannelInboundHandler<User> { 
    @Override 
    public void channelRead0(ChannelHandlerContext ctx, User user) throws Exception { 
        //獲取到user對象 
        System.out.println(user); 
        ctx.writeAndFlush(Unpooled.copiedBuffer("ok", CharsetUtil.UTF_8)); 
    } 
}

6 2.3 客戶端

1. NettyObjectClient

package com.haopt.netty.codec.obj; 
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.serialization.ObjectEncoder; 
public class NettyObjectClient { 
public static void main(String[] args) throws Exception{ 
    EventLoopGroup worker = new NioEventLoopGroup(); 
        try { 
            // 服務器啟動類 
            Bootstrap bootstrap = new Bootstrap(); 
            bootstrap.group(worker); 
            bootstrap.channel(NioSocketChannel.class); 
            bootstrap.handler(new ChannelInitializer<SocketChannel>() { 
                @Override 
                protected void initChannel(SocketChannel ch) throws Exception { 
                    ch.pipeline().addLast(new ObjectEncoder()); 
                    ch.pipeline().addLast(new ClientHandler()); 
                } 
            }); 
            ChannelFuture future = bootstrap.connect("127.0.0.1", 6677).sync(); 
            future.channel().closeFuture().sync(); 
        } finally { 
            worker.shutdownGracefully(); 
        } 
    } 
}

2. ClientHandler

package com.haopt.netty.codec.obj; 
import io.netty.buffer.ByteBuf; 
import io.netty.channel.ChannelHandlerContext; 
import io.netty.channel.SimpleChannelInboundHandler; 
import io.netty.util.CharsetUtil; 
public class ClientHandler extends SimpleChannelInboundHandler<ByteBuf> { 
    @Override 
    protected void channelRead0(ChannelHandlerContext ctx, ByteBuf msg) throws Exception { 
        System.out.println("接收到服務端的消息：" + 
        msg.toString(CharsetUtil.UTF_8)); 
    } 
    @Override 
    public void channelActive(ChannelHandlerContext ctx) throws Exception { 
        User user = new User(); 
        user.setId(1L); 
        user.setName("張三"); 
        user.setAge(20); 
        ctx.writeAndFlush(user); 
    } 
    @Override 
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception { 
        cause.printStackTrace(); 
        ctx.close(); 
    } 
}

7 2.4 JDK序列化的優化

JDK序列化使⽤是⽐較⽅便，但是性能較差，序列化后的字節⽐較⼤，所以⼀般在項⽬中不會使⽤⾃帶的序列化，⽽是會采⽤第三⽅的序列化框架Hessian編解碼。

1. 導入依賴

<dependency> 
  <groupId>com.caucho</groupId> 
  <artifactId>hessian</artifactId> 
  <version>4.0.63</version> 
</dependency>

2. User對象

package com.haopt.netty.codec.hessian; 
public class User implements java.io.Serializable{ 
    private static final long serialVersionUID = -8200798627910162221L; 
    private Long id; 
    private String name; 
    private Integer age; 
    public Long getId() { 
     return id; 
    } 
    public void setId(Long id) { 
     this.id = id; 
    } 
    public String getName() { 
     return name; 
    } 
    public void setName(String name) { 
     this.name = name; 
    } 
    public Integer getAge() { 
     return age; 
    } 
    public void setAge(Integer age) { 
     this.age = age; 
    } 
    @Override 
    public String toString() { 
      return "User{" + 
      "id=" + id + 
      ", name='" + name + '\'' + 
      ", age=" + age + 
      '}'; 
    } 
}

3. Hessian序列化⼯具類

package com.haopt.netty.codec.hessian.codec; 
import com.caucho.hessian.io.HessianInput; 
import com.caucho.hessian.io.HessianOutput; 
import java.io.ByteArrayInputStream; 
import java.io.ByteArrayOutputStream; 
import java.io.IOException; 
/** 
* Hessian序列化⼯具類 
* 
*/ 
public class HessianSerializer { 
    public <T> byte[] serialize(T obj) { 
        ByteArrayOutputStream os = new ByteArrayOutputStream(); 
        HessianOutput ho = new HessianOutput(os); 
        try { 
          ho.writeObject(obj); 
          ho.flush(); 
          return os.toByteArray(); 
        } catch (IOException e) { 
         throw new RuntimeException(e); 
        } finally { 
          try { 
           ho.close(); 
          } catch (IOException e) { 
           throw new RuntimeException(e); 
          } 
          try { 
           os.close(); 
          } catch (IOException e) { 
          throw new RuntimeException(e); 
          } 
        } 
     } 
      
     public <T> Object deserialize(byte[] bytes, Class<T> clazz) { 
        ByteArrayInputStream is = new ByteArrayInputStream(bytes); 
        HessianInput hi = new HessianInput(is); 
        try { 
          return (T) hi.readObject(clazz); 
        } catch (IOException e) { 
          throw new RuntimeException(e); 
        } finally { 
            try { 
               hi.close(); 
            } catch (Exception e) { 
            throw new RuntimeException(e); 
        } 
        try { 
          is.close(); 
        } catch (IOException e) { 
          throw new RuntimeException(e); 
        } 
      } 
    } 
}

4. 編碼器

package com.haopt.netty.codec.hessian.codec; 
import cn.itcast.netty.coder.hessian.User; 
import io.netty.buffer.ByteBuf; 
import io.netty.channel.ChannelHandlerContext; 
import io.netty.handler.codec.MessageToByteEncoder; 
public class HessianEncoder extends MessageToByteEncoder<User> { 
    private HessianSerializer hessianSerializer = new HessianSerializer(); 
    protected void encode(ChannelHandlerContext ctx, User msg, ByteBuf out) throws Exception { 
          byte[] bytes = hessianSerializer.serialize(msg); 
          out.writeBytes(bytes); 
    } 
}

5. 解碼器

public class HessianDecoder extends ByteToMessageDecoder { 
    private HessianSerializer hessianSerializer = new HessianSerializer(); 
 
    protected void decode(ChannelHandlerContext ctx, ByteBuf in, List<Object> 
            out) throws Exception { 
        //復制⼀份ByteBuf數據，輕復制，⾮完全拷⻉ 
        //避免出現異常：did not read anything but decoded a message 
        //Netty檢測沒有讀取任何字節就會拋出該異常 
        ByteBuf in2 = in.retainedDuplicate(); 
        byte[] dst; 
        if (in2.hasArray()) {//堆緩沖區模式 
            dst = in2.array(); 
        } else { 
            dst = new byte[in2.readableBytes()]; 
            in2.getBytes(in2.readerIndex(), dst); 
        } 
        //跳過所有的字節，表示已經讀取過了 
        in.skipBytes(in.readableBytes()); 
        //反序列化 
        Object obj = hessianSerializer.deserialize(dst, User.class); 
        out.add(obj); 
    } 
}

6. 服務端

public class NettyHessianServer { 
    public static void main(String[] args) throws Exception { 
        // System.setProperty("io.netty.noUnsafe", "true"); 
        // 主線程，不處理任何業務邏輯，只是接收客戶的連接請求 
        EventLoopGroup boss = new NioEventLoopGroup(1); 
        // ⼯作線程，線程數默認是：cpu*2 
        EventLoopGroup worker = new NioEventLoopGroup(); 
        try { 
            // 服務器啟動類 
            ServerBootstrap serverBootstrap = new ServerBootstrap(); 
            serverBootstrap.group(boss, worker); 
            //配置server通道 
            serverBootstrap.channel(NioServerSocketChannel.class); 
            serverBootstrap.childHandler(new ChannelInitializer<SocketChannel> 
                    () { 
                @Override 
                protected void initChannel(SocketChannel ch) throws Exception { 
                    ch.pipeline() 
                            .addLast(new HessianDecoder()) 
                            .addLast(new ServerHandler()); 
                } 
            }); //worker線程的處理器 
            // serverBootstrap.childOption(ChannelOption.ALLOCATOR, 
            UnpooledByteBufAllocator.DEFAULT); 
            ChannelFuture future = serverBootstrap.bind(6677).sync(); 
            System.out.println("服務器啟動完成。。。。。"); 
            //等待服務端監聽端⼝關閉 
            future.channel().closeFuture().sync(); 
        } finally { 
            //優雅關閉 
            boss.shutdownGracefully(); 
            worker.shutdownGracefully(); 
        } 
    } 
}

public class ServerHandler extends SimpleChannelInboundHandler<User> { 
    @Override 
    public void channelRead0(ChannelHandlerContext ctx, User user) throws 
            Exception { 
        //獲取到user對象 
        System.out.println(user); 
        ctx.writeAndFlush(Unpooled.copiedBuffer("ok", CharsetUtil.UTF_8)); 
    } 
}

7. 客戶端(配置類)

public class NettyHessianClient { 
    public static void main(String[] args) throws Exception { 
        EventLoopGroup worker = new NioEventLoopGroup(); 
        try { 
            // 服務器啟動類 
            Bootstrap bootstrap = new Bootstrap(); 
            bootstrap.group(worker); 
            bootstrap.channel(NioSocketChannel.class); 
            bootstrap.handler(new ChannelInitializer<SocketChannel>() { 
                @Override 
                protected void initChannel(SocketChannel ch) throws Exception { 
                    ch.pipeline().addLast(new HessianEncoder()); 
                    ch.pipeline().addLast(new ClientHandler()); 
                } 
            }); 
            ChannelFuture future = bootstrap.connect("127.0.0.1", 6677).sync(); 
            future.channel().closeFuture().sync(); 
        } finally { 
            worker.shutdownGracefully(); 
        } 
    } 
}

public class ClientHandler extends SimpleChannelInboundHandler<ByteBuf> { 
    @Override 
    protected void channelRead0(ChannelHandlerContext ctx, ByteBuf msg) throws 
            Exception { 
        System.out.println("接收到服務端的消息：" + 
                msg.toString(CharsetUtil.UTF_8)); 
    } 
 
    @Override 
    public void channelActive(ChannelHandlerContext ctx) throws Exception { 
        User user = new User(); 
        user.setId(1L); 
        user.setName("張三"); 
        user.setAge(20); 
        ctx.writeAndFlush(user); 
    } 
 
    @Override 
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) 
            throws Exception { 
        cause.printStackTrace(); 
        ctx.close(); 
    } 
}

這篇文章，介紹了什么是編碼器、解碼器，也講述了如何實戰中運用編碼器和解碼器。希望能對有所幫助。在開頭提到的我們本文的編碼器解碼器和情報信息交互是否相似?在我看來，是相似的。發報人將自己看的懂得信息，按照某種規則進行加密。收報人接收到信息是加密后的數據，需要進行按照規則進行解密才能看懂。我們客戶端在進行發送數據，需要將程序中的數據變為二進制流發送。服務端接收到數據，需要將二進制流轉化為程序可以操作數據類型。

責任編輯：姜華來源：花花和Java

Netty 編碼器解碼器