netty自定义协议

男娘i 2022-06-12 12:45 327阅读 0赞

《netty权威指南》一书中关于自定义协议开发的源码中有一部分错误导致代码无法运行，加了一点改变可以完美运行了，

  1. package nettyAgreement.decoder;
  3. import java.util.HashMap;
  4. import java.util.Map;
  6. import io.netty.buffer.ByteBuf;
  7. import io.netty.channel.ChannelHandlerContext;
  8. import io.netty.handler.codec.LengthFieldBasedFrameDecoder;
  9. import nettyAgreement.Header;
  10. import nettyAgreement.MarshallingCodecFactory;
  11. import nettyAgreement.NettyMessage;
  13. /**
  14.  * 消息解码类
  15.  * @author <font color="red"><b>Gong.YiYang</b></font>
  16.  * @Date 2017年7月19日
  17.  * @Version 
  18.  * @Description
  19.  */
  20. public class NettyMessageDecoder extends LengthFieldBasedFrameDecoder {
  22.     NettyMarshallingDecoder marshallingDecoder;
  24.     public NettyMessageDecoder(int maxFrameLength, int lengthFieldOffset, int lengthFieldLength) {
  25.         super(maxFrameLength, lengthFieldOffset, lengthFieldLength);
  26.         // TODO Auto-generated constructor stub
  27.         marshallingDecoder = MarshallingCodecFactory.buMarshallingDecoder();
  28.     }
  30.     public NettyMessageDecoder(int maxFrameLength,
  31.             int lengthFieldOffset, int lengthFieldLength,
  32.             int lengthAdjustment, int initialBytesToStrip) {
  33.         // TODO Auto-generated constructor stub
  34.         super( maxFrameLength,
  35.                  lengthFieldOffset,  lengthFieldLength,
  36.                  lengthAdjustment,  initialBytesToStrip);
  37.         marshallingDecoder = MarshallingCodecFactory.buMarshallingDecoder();
  38.     }
  40.     @Override
  41.     protected Object decode(ChannelHandlerContext ctx, ByteBuf in) throws Exception {
  42.         // TODO Auto-generated method stub
  43.         ByteBuf frame = (ByteBuf)super.decode(ctx, in);
  44.         if (frame == null) {
  45.             return null;
  46.         }
  48.         NettyMessage message = new NettyMessage();
  49.         Header header = new Header();
  50.         header.setCrcCode(frame.readInt());
  51.         header.setLength(frame.readInt());
  52.         header.setSessionID(frame.readLong());
  53.         header.setType(frame.readByte());
  54.         header.setPriority(frame.readByte());
  56.         int size = frame.readInt();
  57.         if (size>0) {
  58.             Map<String, Object> attch = new HashMap<String,Object>(size);
  59.             int keySize = 0;
  60.             byte[] keyArray = null;
  61.             String key = null;
  62.             for (int i = 0; i < size; i++) {
  63.                 keySize = frame.readInt();
  64.                 keyArray = new byte[keySize];
  65.                 frame.readBytes(keyArray);
  66.                 key = new String(keyArray, "UTF-8");
  67.                 attch.put(    key, marshallingDecoder.decode(ctx, frame));
  68.             }
  69.             keyArray = null;
  70.             key = null;
  71.             header.setAttachment(attch);
  72.         }
  73.         if (frame.readableBytes() > 4) {
  74.             message.setBody(marshallingDecoder.decode(ctx, frame));
  75.         }
  76.         message.setHeader(header);
  77.         return message;
  78.     }
  79. }
  84. package nettyAgreement.encoder;
  86. import java.util.List;
  87. import java.util.Map.Entry;
  89. import io.netty.buffer.ByteBuf;
  90. import io.netty.buffer.Unpooled;
  91. import io.netty.channel.ChannelHandlerContext;
  92. import io.netty.handler.codec.MessageToMessageEncoder;
  93. import nettyAgreement.MarshallingCodecFactory;
  94. import nettyAgreement.NettyMessage;
  96. /**
  97.  * 消息编码
  98.  * @author <font color="red"><b>Gong.YiYang</b></font>
  99.  * @Date 2017年7月19日
  100.  * @Version 
  101.  * @Description
  102.  */
  103. public class NettyMessageEncoder extends MessageToMessageEncoder<NettyMessage>{
  105.     private NettyMarshallingEncoder marshallingEncoder;
  107.     public NettyMessageEncoder() {
  108.         this.marshallingEncoder = MarshallingCodecFactory.buildMarshallingEncoder();
  109.     }
  111.     @Override
  112.     public void encode(ChannelHandlerContext ctx, NettyMessage msg, List<Object> out) throws Exception {
  113.         // TODO Auto-generated method stub
  114.         if (msg == null || msg.getHeader() == null) {
  115.             throw new Exception("This encode message is null");
  116.         }
  118.         ByteBuf sendBuffer = Unpooled.buffer();
  119.         sendBuffer.writeInt(msg.getHeader().getCrcCode());
  120.         sendBuffer.writeInt(msg.getHeader().getLength());
  121.         sendBuffer.writeLong(msg.getHeader().getSessionID());
  122.         sendBuffer.writeByte(msg.getHeader().getType());
  123.         sendBuffer.writeByte(msg.getHeader().getPriority());
  124.         sendBuffer.writeInt(msg.getHeader().getAttachment().size());
  126.         String key = null;
  127.         byte[] keyArray = null;
  128.         Object value = null;
  129.         for (Entry<String, Object> param : msg.getHeader().getAttachment().entrySet()) {
  130.              key = param.getKey();
  131.              keyArray = key.getBytes("UTF-8");
  132.              sendBuffer.writeInt(keyArray.length);
  133.              sendBuffer.writeBytes(keyArray);
  134.              value = param.getValue();
  135.              marshallingEncoder.encode(ctx, value, sendBuffer);
  136.         }
  138.         key = null;
  139.         keyArray = null;
  140.         value = null;
  141.         if (msg.getBody() != null) {
  142.             marshallingEncoder.encode(ctx, msg.getBody(), sendBuffer);
  143.         }else
  144.             sendBuffer.writeInt(0);  
  145.             // 在第4个字节出写入Buffer的长度  
  146.             int readableBytes = sendBuffer.readableBytes();  
  147.             sendBuffer.setInt(4, readableBytes);  
  149.             // 把Message添加到List传递到下一个Handler   
  150.             out.add(sendBuffer);  
  151.     }
  153. }
  158. package nettyAgreement;
  159. /**
  160.  * 定义消息头
  161.  * @author <font color="red"><b>Gong.YiYang</b></font>
  162.  * @Date 2017年7月19日
  163.  * @Version 
  164.  * @Description
  165.  */
  167. import java.util.HashMap;
  168. import java.util.Map;
  170. public final class Header {
  172.     private int crcCode = 0xabef0101;//长度32，
  173.     private int length;//消息长度32
  174.     private long sessionID;//会话ID64
  175.     private byte type;//消息类型8
  176.     private byte priority;//消息优先级8
  177.     private Map<String, Object> attachment = new HashMap<String,Object>();//附件
  178.     public final int getCrcCode() {
  179.         return crcCode;
  180.     }
  181.     public final void setCrcCode(int crcCode) {
  182.         this.crcCode = crcCode;
  183.     }
  184.     public final int getLength() {
  185.         return length;
  186.     }
  187.     public final void setLength(int length) {
  188.         this.length = length;
  189.     }
  190.     public final long getSessionID() {
  191.         return sessionID;
  192.     }
  193.     public final void setSessionID(long sessionID) {
  194.         this.sessionID = sessionID;
  195.     }
  196.     public final byte getType() {
  197.         return type;
  198.     }
  199.     public final void setType(byte type) {
  200.         this.type = type;
  201.     }
  202.     public final byte getPriority() {
  203.         return priority;
  204.     }
  205.     public final void setPriority(byte priority) {
  206.         this.priority = priority;
  207.     }
  208.     public final Map<String, Object> getAttachment() {
  209.         return attachment;
  210.     }
  211.     public final void setAttachment(Map<String, Object> attachment) {
  212.         this.attachment = attachment;
  213.     }
  214.     @Override
  215.     public String toString() {
  216.         return "Header [crcCode=" + crcCode + ", length=" + length + ", sessionID=" + sessionID + ", type=" + type
  217.                 + ", priority=" + priority + ", attachment=" + attachment + "]";
  218.     }
  221. }
  226. package nettyAgreement;
  228. import java.util.concurrent.TimeUnit;
  229. import io.netty.channel.ChannelHandlerAdapter;
  230. import io.netty.channel.ChannelHandlerContext;
  231. import io.netty.util.concurrent.ScheduledFuture;
  232. import nettyAgreement.Header;
  233. import nettyAgreement.MessageType;
  234. import nettyAgreement.NettyMessage;
  236. /**
  237.  * 客户端心跳消息
  238.  * @author <font color="red"><b>Gong.YiYang</b></font>
  239.  * @Date 2017年7月20日
  240.  * @Version 
  241.  * @Description
  242.  */
  243. public class HeartBeatReqHandler extends ChannelHandlerAdapter {
  245.     private volatile ScheduledFuture<?> heartBeat;
  247.     @Override
  248.     public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
  249.         // TODO Auto-generated method stub
  250.         NettyMessage message = (NettyMessage)msg;
  251.         //握手成功，主动发送心跳消息
  252.         if (message.getHeader() != null && message.getHeader().getType() == MessageType.LOGIN_RESP.type) {
  253.             heartBeat = ctx.executor().scheduleAtFixedRate(new HeartBeatReqHandler.HeartBeatTask(ctx), 0, 5000, TimeUnit.MILLISECONDS);
  254.         }else if (message.getHeader() != null && message.getHeader().getType() == MessageType.HEART_RESP.type) {
  255.             System.out.println("Client receive server heart beat message : -->"+message);
  256.         }else 
  257.             ctx.fireChannelRead(msg);
  258.     }
  259.     //心跳任务
  260.     private class HeartBeatTask implements Runnable{
  261.         private final ChannelHandlerContext ctx;
  263.         public HeartBeatTask(final ChannelHandlerContext ctx) {
  264.             this.ctx = ctx;
  265.         }
  267.         @Override
  268.         public void run() {
  269.             // TODO Auto-generated method stub
  270.             NettyMessage heartBeat = buildHeartBeat();
  271.             System.out.println("Client send heart beat message to server : -->"+heartBeat);
  272.             ctx.writeAndFlush(heartBeat);
  273.         }
  275.         private NettyMessage buildHeartBeat(){
  276.             NettyMessage message = new NettyMessage();
  277.             Header header = new Header();
  278.             header.setType(MessageType.HEART_REQ.type);
  279.             message.setHeader(header);
  280.             return message;
  281.         }
  282.     }
  285.     @Override
  286.     public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
  287.         // TODO Auto-generated method stub
  288.         if (heartBeat != null) {
  289.             heartBeat.cancel(true);
  290.             heartBeat=null;
  291.         }
  292.         ctx.fireExceptionCaught(cause);
  294.     }
  295. }
  300. package nettyAgreement;
  302. import io.netty.channel.ChannelHandlerAdapter;
  303. import io.netty.channel.ChannelHandlerContext;
  305. /**
  306.  * 服务端心跳消息
  307.  * @author <font color="red"><b>Gong.YiYang</b></font>
  308.  * @Date 2017年7月20日
  309.  * @Version 
  310.  * @Description
  311.  */
  312. public class HeartBeatRespHandler extends ChannelHandlerAdapter {
  314.     @Override
  315.     public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
  316.         // TODO Auto-generated method stub
  317.         NettyMessage message = (NettyMessage)msg;
  318.         if (message.getHeader() != null && message.getHeader().getType() == MessageType.HEART_REQ.type) {
  319.             System.out.println("Receive client beat message : -->"+message);
  320.             NettyMessage heartBeat = buildHeartBeat();
  321.             System.out.println("Send heart beat message to client ： -->"+heartBeat);
  322.             ctx.writeAndFlush(heartBeat);
  323.         }else 
  325.         ctx.fireChannelRead(msg);
  326.     }
  328.     private NettyMessage buildHeartBeat(){
  329.         NettyMessage message = new NettyMessage();
  330.         Header header = new Header();
  331.         header.setType(MessageType.HEART_RESP.type);
  332.         message.setHeader(header);
  333.         return message;
  334.     }
  336. }
  341. package nettyAgreement;
  344. import io.netty.channel.ChannelHandlerAdapter;
  345. import io.netty.channel.ChannelHandlerContext;
  347. /**
  348.  * 客户端握手认证
  349.  * 
  350.  * @author <font color="red"><b>Gong.YiYang</b></font>
  351.  * @Date 2017年7月20日
  352.  * @Version
  353.  * @Description
  354.  */
  355. public class LoginAuthReqHandler extends ChannelHandlerAdapter {
  357.     @Override
  358.     public void channelActive(ChannelHandlerContext ctx) throws Exception {
  359.         // TODO Auto-generated method stub
  360.         ctx.writeAndFlush(buildLoginReq());
  361.     }
  363.     @Override
  364.     public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
  365.         // TODO Auto-generated method stub
  366.         NettyMessage message = (NettyMessage)msg;
  367.         //如果是握手应答消息，需要判断是否认证成功
  368.         if (message.getHeader() != null && message.getHeader().getType() == MessageType.LOGIN_RESP.type) {
  369.             byte loginResult = (byte)message.getBody();
  370.             if (loginResult != (byte)0) {
  371.                 //握手失败，关闭连接;0表示认证通过，握手成功
  372.                 ctx.close();
  373.             }else {
  374.                 System.out.println("login is ok :"+message);
  375.                 ctx.fireChannelRead(msg);
  376.             }
  377.         }else {
  379.             ctx.fireChannelRead(msg);
  380.         }
  382.     }
  384.     private NettyMessage buildLoginReq() {
  385.         // TODO Auto-generated method stub
  386.         NettyMessage message = new NettyMessage();
  387.         Header header = new Header();
  388.         header.setType(MessageType.LOGIN_REQ.type);
  389.         message.setHeader(header);
  390.         return message;
  391.     }
  393.     @Override
  394.     public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
  395.         // TODO Auto-generated method stub
  396.         ctx.fireExceptionCaught(cause);
  397.     }
  398. }
  403. package nettyAgreement;
  405. import java.net.InetSocketAddress;
  406. import java.util.Map;
  407. import java.util.concurrent.ConcurrentHashMap;
  409. import io.netty.channel.ChannelHandlerAdapter;
  410. import io.netty.channel.ChannelHandlerContext;
  411. /**
  412.  * 服务端握手请求，安全认证
  413.  * @author <font color="red"><b>Gong.YiYang</b></font>
  414.  * @Date 2017年7月20日
  415.  * @Version 
  416.  * @Description
  417.  */
  418. public class LoginAuthRespHandler extends ChannelHandlerAdapter {
  420.     private Map<String, Boolean> nodeCheck = new ConcurrentHashMap<String,Boolean>();
  421.     private String[] whiteList = {"127.0.0.1","192.168.1.104"};//白名单
  423.     @Override
  424.     public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
  425.         // TODO Auto-generated method stub
  426.         NettyMessage message = (NettyMessage)msg;
  427.         //如果是握手请求消息处理，其它消息透传
  428.         if (message.getHeader() != null && message.getHeader().getType() == MessageType.LOGIN_REQ.type) {
  429.             String nodeIndex = ctx.channel().remoteAddress().toString();//拿到远程地址
  430.             NettyMessage loginResp = null;
  431.             //重复登录，拒绝
  432.             if (nodeCheck.containsKey(nodeIndex)) {
  433.                 loginResp = buildResponse((byte)-1);
  434.             }else {
  435.                 InetSocketAddress address = (InetSocketAddress)ctx.channel().remoteAddress();
  436.                 String ip = address.getAddress().getHostAddress();
  437.                 boolean isOK = false;
  438.                 for (String Wip : whiteList) {
  439.                     if (Wip.equals(ip)) {
  440.                         isOK = true;
  441.                         break;
  442.                     }
  443.                 }
  444.                 loginResp = isOK ? buildResponse((byte)0) : buildResponse((byte)-1);
  445.                 if (isOK) 
  446.                     nodeCheck.put(nodeIndex, true);
  447.                     ConnectList.list.put(ip, ctx);
  448.                 }
  450.                 System.out.println("The login response is:"+loginResp+"body["+loginResp.getBody()+"]");
  451.                 ctx.writeAndFlush(loginResp);
  452.             }else {
  453.                 ctx.fireChannelRead(msg);
  454.             }
  455.         }
  458.     private NettyMessage buildResponse(byte result) {
  459.         // TODO Auto-generated method stub
  460.         NettyMessage message = new NettyMessage();
  461.         Header header = new Header();
  462.         header.setType(MessageType.LOGIN_RESP.type);
  463.         message.setHeader(header);
  464.         message.setBody(result);
  465.         return message;
  466.     }
  468.     @Override
  469.     public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
  470.         // TODO Auto-generated method stub
  471.         nodeCheck.remove(ctx.channel().remoteAddress().toString());
  472.         ctx.fireExceptionCaught(cause);
  473.     }
  474. }
  479. package nettyAgreement;
  480. /**
  481.  * 消息类型
  482.  * @author <font color="red"><b>Gong.YiYang</b></font>
  483.  * @Date 2017年7月20日
  484.  * @Version 
  485.  * @Description
  486.  */
  487. public enum MessageType {
  489.     BUSINESS_REQ((byte)0,"业务请求消息"),
  490.     BUSINESS_RESP((byte)1,"业务应答消息"),
  491.     ONE_WAY((byte)2,"业务ONE WAY消息"),
  492.     LOGIN_REQ((byte)3,"握手请求消息"),
  493.     LOGIN_RESP((byte)4,"握手应答消息"),
  494.     HEART_REQ((byte)5,"心跳请求消息"),
  495.     HEART_RESP((byte)6,"心跳应答消息");
  497.     public byte type;
  498.     String describe;
  499.     private MessageType(byte type, String describe) {
  500.         this.type = type;
  501.         this.describe = describe;
  502.     }
  505. }
  510. package nettyAgreement;
  512. public class NettyConstant {
  514.     public static final String REMOTEIP = "127.0.0.1";
  515.     public static final int PORT = 8080;
  516.     public static final int LOCAL_PORT = 12088;
  517.     public static final String LOCALIP = "127.0.0.1";
  518. }
  523. package nettyAgreement;
  524. /**
  525.  * 消息定义
  526.  * @author <font color="red"><b>Gong.YiYang</b></font>
  527.  * @Date 2017年7月18日
  528.  * @Version 
  529.  * @Description
  530.  */
  531. public final class NettyMessage {
  532.     private Header header;//消息头
  533.     private Object body;//消息体
  534.     public final Header getHeader() {
  535.         return header;
  536.     }
  537.     public final void setHeader(Header header) {
  538.         this.header = header;
  539.     }
  540.     public final Object getBody() {
  541.         return body;
  542.     }
  543.     public final void setBody(Object body) {
  544.         this.body = body;
  545.     }
  546.     @Override
  547.     public String toString() {
  548.         return "NettyMessage [header=" + header + "]";
  549.     }
  551. }
  556. package nettyAgreement.client;
  557. /**
  558.  * 客户端
  559.  * @author <font color="red"><b>Gong.YiYang</b></font>
  560.  * @Date 2017年7月21日
  561.  * @Version 
  562.  * @Description
  563.  */
  565. import java.net.InetSocketAddress;
  566. import java.util.concurrent.Executors;
  567. import java.util.concurrent.ScheduledExecutorService;
  568. import java.util.concurrent.TimeUnit;
  570. import io.netty.bootstrap.Bootstrap;
  571. import io.netty.channel.ChannelFuture;
  572. import io.netty.channel.ChannelInitializer;
  573. import io.netty.channel.ChannelOption;
  574. import io.netty.channel.EventLoopGroup;
  575. import io.netty.channel.nio.NioEventLoopGroup;
  576. import io.netty.channel.socket.SocketChannel;
  577. import io.netty.channel.socket.nio.NioSocketChannel;
  578. import io.netty.handler.timeout.ReadTimeoutHandler;
  579. import nettyAgreement.HeartBeatReqHandler;
  580. import nettyAgreement.LoginAuthReqHandler;
  581. import nettyAgreement.NettyConstant;
  582. import nettyAgreement.decoder.NettyMessageDecoder;
  583. import nettyAgreement.encoder.NettyMessageEncoder;
  585. public class NettyClient {
  587.     private ScheduledExecutorService executor = Executors.newScheduledThreadPool(1);
  589.     EventLoopGroup group = new NioEventLoopGroup();
  591.     public void connect(int port,String host) throws InterruptedException{
  593.         try {
  594.             Bootstrap b = new Bootstrap();
  595.             b.group(group)
  596.             .channel(NioSocketChannel.class)
  597.             .option(ChannelOption.TCP_NODELAY, true)
  598.             .handler(new ChannelInitializer<SocketChannel>() {
  600.                 @Override
  601.                 protected void initChannel(SocketChannel ch) throws Exception {
  602.                     // TODO Auto-generated method stub
  603.                     ch.pipeline().addLast(new NettyMessageDecoder(1024 * 1024, 4, 4,-8,0));
  604.                     ch.pipeline().addLast("MessageEncoder",new NettyMessageEncoder());
  605.                     ch.pipeline().addLast("readTimeOutHandler",new ReadTimeoutHandler(50));
  606.                     ch.pipeline().addLast("LoginAuthHandler",new LoginAuthReqHandler());
  607.                     ch.pipeline().addLast("HeartBeatHandler",new HeartBeatReqHandler());
  608.                 }
  609.             });
  610.             //发起异步连接操作
  611.             ChannelFuture future = b.connect(
  612.                     new InetSocketAddress(host, port), 
  613.                     new InetSocketAddress(NettyConstant.LOCALIP, NettyConstant.LOCAL_PORT)).sync();
  614.             future.channel().closeFuture().sync();
  615.         }
  616.         finally {
  617.             //所有资源释放完成之后，清空资源，再次发起重连操作
  618.             executor.execute(new Runnable() {
  620.                 @Override
  621.                 public void run() {
  622.                     // TODO Auto-generated method stub
  623.                     try {
  624.                         TimeUnit.SECONDS.sleep(5);
  625.                         try {
  626.                             connect(NettyConstant.PORT, NettyConstant.REMOTEIP);//发起重连操作
  627.                         } catch (Exception e) {
  628.                             // TODO: handle exception
  629.                             e.printStackTrace();
  630.                         }
  631.                     } catch (InterruptedException e) {
  632.                         // TODO: handle exception
  633.                         e.printStackTrace();
  634.                     }
  635.                 }
  636.             });
  637.         } 
  638.     }
  639.     public static void main(String[] args) throws InterruptedException {
  640.         new NettyClient().connect(NettyConstant.PORT, NettyConstant.REMOTEIP);
  641.     }
  642. }
  647. package nettyAgreement.server;
  650. import io.netty.bootstrap.ServerBootstrap;
  651. import io.netty.channel.ChannelFuture;
  652. import io.netty.channel.ChannelInitializer;
  653. import io.netty.channel.ChannelOption;
  654. import io.netty.channel.nio.NioEventLoopGroup;
  655. import io.netty.channel.socket.SocketChannel;
  656. import io.netty.channel.socket.nio.NioServerSocketChannel;
  657. import io.netty.handler.logging.LogLevel;
  658. import io.netty.handler.logging.LoggingHandler;
  659. import io.netty.handler.timeout.ReadTimeoutHandler;
  660. import nettyAgreement.HeartBeatRespHandler;
  661. import nettyAgreement.LoginAuthRespHandler;
  662. import nettyAgreement.NettyConstant;
  663. import nettyAgreement.decoder.NettyMessageDecoder;
  664. import nettyAgreement.encoder.NettyMessageEncoder;
  666. /**
  667.  * 服务端
  668.  * @author <font color="red"><b>Gong.YiYang</b></font>
  669.  * @Date 2017年7月21日
  670.  * @Version 
  671.  * @Description
  672.  */
  673. public class NettyServer {
  675.     public void build() throws InterruptedException{
  676.         NioEventLoopGroup bossGroup = new NioEventLoopGroup();
  677.         NioEventLoopGroup workGroup = new NioEventLoopGroup();
  678.         try {
  679.             ServerBootstrap b = new ServerBootstrap();
  680.             b.group(bossGroup, workGroup)
  681.             .channel(NioServerSocketChannel.class)
  682.             .option(ChannelOption.SO_BACKLOG, 100)
  683.             .handler(new LoggingHandler(LogLevel.INFO))
  684.             .childHandler(new ChannelInitializer<SocketChannel>() {
  686.                 @Override
  687.                 protected void initChannel(SocketChannel ch) throws Exception {
  688.                     // TODO Auto-generated method stub
  689.                     ch.pipeline().addLast(new NettyMessageDecoder(1024 * 1024, 4, 4,-8,0));
  690.                     ch.pipeline().addLast(new NettyMessageEncoder());
  691.                     ch.pipeline().addLast("readTimeOutHandler",new ReadTimeoutHandler(50));
  692.                     ch.pipeline().addLast(new LoginAuthRespHandler());
  693.                     ch.pipeline().addLast("HeartBeatHandler",new HeartBeatRespHandler());
  694.                 }
  695.             });
  697.             //绑定端口，等待同步
  698.              ChannelFuture future = b.bind(NettyConstant.PORT).sync();
  699.             System.out.println("Netty server start ok :"+(NettyConstant.REMOTEIP+":"+NettyConstant.PORT));
  700.             future.channel().closeFuture().sync();
  701.         } finally{
  702.             bossGroup.shutdownGracefully();
  703.             workGroup.shutdownGracefully();
  704.         }
  705.     }
  707.     public static void main(String[] args) throws InterruptedException {
  708.         new NettyServer().build();
  709.     }
  710. }

发表评论

表情：
评论列表 （有 0 条评论，327人围观）

还没有评论，来说两句吧...

相关阅读

    相关 Netty实现自定义协议

    关于协议，使用最为广泛的是HTTP协议，但是在一些服务交互领域，其使用则相对较少，主要原因有三方面： HTTP协议会携带诸如header和cookie等信息，其本身对字

    Bertha 。Bertha 。/ 0 赞/ 137 阅读

    相关 netty自定义协议

    《netty权威指南》一书中关于自定义协议开发的源码中有一部分错误导致代码无法运行，加了一点改变可以完美运行了， package nettyAgreement.dec

    男娘i男娘i/ 0 赞/ 328 阅读