netty 网络通信示例三

最新推荐文章于 2022-09-29 10:15:00 发布
最新推荐文章于 2022-09-29 10:15:00 发布
阅读量162 收藏
点赞数
分类专栏： Netty 文章标签： netty
netty 网络通信示例一 ：[url]http://donald-draper.iteye.com/blog/2383326[/url]
netty 网络通信示例二：[url]http://donald-draper.iteye.com/blog/2383328[/url]
上一篇文章我们通过一个示例，来展示netty如何处理粘包问题，其中涉及到解码器，今天我们在通过一个实例，来看一个用到编码器与解码器的示例，这个示例作用为服务器提供客户端计算请求，并将结果返回给客户端。
通信协议：

[img]http://dl2.iteye.com/upload/attachment/0125/9302/e55134ec-e433-3a53-ac8a-3eb19b483385.png[/img]

这个协议我们在将Java socket编程的时候有实现过，在mina相关示例中，我们也有说过，不过协议有所不同；
这里我们用netty来实现。
协议常量： 
package netty.constant.math;
/**
 * 协议常量
 * @author donald
 * 2017年6月22日
 * 下午1:10:11
 */
public class ProtocolConstants {
	/**
	 * 加法协议编码
	 */
	public static final String SUM_PROTOCOL_300000 = "300000";
	/**
	 * 乘法协议编码
	 */
	public static final String MULTI_PROTOCOL_300100 = "300100";
	/**
	 * 计算成功协议
	 */
	public static final String ACK_PROTOCOL_300200 = "300200";
	/**
	 * 服务器解析协议失败
	 */
	public static final String ACK_PROTOCOL_300300 = "300300";
	/**
	 * 协议编码长度
	 */
	public static final Integer PROTOCOL_CODE_LENGTH = 6;
	/**
	 * 协议内容长度字段
	 */
	public static final Integer PROTOCOL_DATA_LENGTH = 4;
	/**
	 * 协议操作数长度
	 */
	public static final Integer OPERATE_NUM_LENGTH = 4;
	/**
	 * 协议计算结果长度
	 */
	public static final Integer PROTOCOL_ACK_LENGTH = 4;
	/**
	 * 协议结束符
	 */
	public static final String PROTOCOL_END = "\r\n";
	/**
	 * 协议结束符长度
	 */
	public static final Integer PROTOCOL_END_LENGTH = 2;
	/**
	 * 字符集
	 */
	public static final String CHARSET_UTF8 = "UTF-8";
}


计算请求协议编码器： 
package netty.codec.math;

import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandlerContext;
import io.netty.handler.codec.MessageToByteEncoder;
import netty.constant.math.ProtocolConstants;
import netty.message.MathMessage;
import util.JsonUtil;

import java.io.UnsupportedEncodingException;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * 计算协议编码器
 * @author donald
 * 2017年6月22日
 * 下午10:23:21
 */
public class MathMessageEncoder extends MessageToByteEncoder<MathMessage> {
	private static final Logger log = LoggerFactory.getLogger(MathMessageEncoder.class);
    @Override
    protected void encode(ChannelHandlerContext ctx, MathMessage msg, ByteBuf out) {
        try {
			out.writeBytes(msg.getProtocolCode().
					getBytes(ProtocolConstants.CHARSET_UTF8));
			out.writeInt(msg.getDataLenth());
		    out.writeInt(msg.getFirstNum());
		    out.writeInt(msg.getSecondNum());
		    out.writeBytes(msg.getEndMark().
					getBytes(ProtocolConstants.CHARSET_UTF8));
        } catch (UnsupportedEncodingException e) {
			e.printStackTrace();
		}
        log.info("=======编码计算请求协议成功："+JsonUtil.toJson(msg));
    }
}


计算请求协议解码器： 

package netty.codec.math;

import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandlerContext;
import io.netty.handler.codec.ByteToMessageDecoder;
import io.netty.handler.codec.CorruptedFrameException;
import netty.constant.math.ProtocolConstants;
import netty.message.MathMessage;
import util.JsonUtil;

import java.io.UnsupportedEncodingException;
import java.util.List;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * 计算协议解码器
 * @author donald
 * 2017年6月22日
 * 下午10:47:31
 */
public class MathMessageDecoder extends ByteToMessageDecoder {
	private static final Logger log = LoggerFactory.getLogger(MathMessageDecoder.class);
    @Override
    protected void decode(ChannelHandlerContext ctx, ByteBuf in, List<Object> out) {
        // Wait until the length prefix is available.

        int protocolLenth = ProtocolConstants.PROTOCOL_CODE_LENGTH+
        		ProtocolConstants.PROTOCOL_DATA_LENGTH;
        if (in.readableBytes() < protocolLenth) {
            return;
        }
        in.markReaderIndex();
        byte[] protocolCodeBytes = new byte[ProtocolConstants.PROTOCOL_CODE_LENGTH];
        in.readBytes(protocolCodeBytes);
        String protocolCode = "";
		try {
			protocolCode = new String(protocolCodeBytes,ProtocolConstants.CHARSET_UTF8);
		} catch (UnsupportedEncodingException e) {
			e.printStackTrace();
		}
        if (!protocolCode.equals(ProtocolConstants.SUM_PROTOCOL_300000) &&
        		!protocolCode.equals(ProtocolConstants.MULTI_PROTOCOL_300100) ){
            in.resetReaderIndex();
            throw new CorruptedFrameException("Invalid protocol code: " + protocolCode);
        }
        int dataLength = in.readInt();
        if (in.readableBytes() < dataLength) {
            in.resetReaderIndex();
            return;
        }
        //转换接收的数据为MathMessage
        MathMessage mes = new MathMessage();
        mes.setProtocolCode(protocolCode);
        mes.setDataLenth(dataLength);
        mes.setFirstNum(in.readInt());
        mes.setSecondNum(in.readInt());
        byte[] endMarkBytes = new byte[ProtocolConstants.PROTOCOL_END_LENGTH];
        in.readBytes(endMarkBytes);
        String endMark = "";
		try {
			endMark = new String(endMarkBytes,ProtocolConstants.CHARSET_UTF8);
		} catch (UnsupportedEncodingException e) {
			e.printStackTrace();
		}
		mes.setEndMark(endMark);
        out.add(mes);
      log.info("=======解码计算请求协议成功："+JsonUtil.toJson(mes));
    }
}


计算结果协议编码器： 
package netty.codec.math;

import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandlerContext;
import io.netty.handler.codec.MessageToByteEncoder;
import netty.constant.math.ProtocolConstants;
import netty.message.AckMessage;
import util.JsonUtil;

import java.io.UnsupportedEncodingException;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * 计算结果协议编码器
 * @author donald
 * 2017年6月22日
 * 下午10:23:21
 */
public class AckMessageEncoder extends MessageToByteEncoder<AckMessage> {
	private static final Logger log = LoggerFactory.getLogger(AckMessageEncoder.class);
    @Override
    protected void encode(ChannelHandlerContext ctx, AckMessage msg, ByteBuf out) {
        try {
			out.writeBytes(msg.getProtocolCode().
					getBytes(ProtocolConstants.CHARSET_UTF8));
			out.writeInt(msg.getDataLenth());
		    out.writeInt(msg.getResult());
		    out.writeBytes(msg.getEndMark().
					getBytes(ProtocolConstants.CHARSET_UTF8));
        } catch (UnsupportedEncodingException e) {
			e.printStackTrace();
		}
        log.info("=======编码计算结果协议成功："+JsonUtil.toJson(msg));
    }
}


计算结果协议解码器： 
package netty.codec.math;

import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandlerContext;
import io.netty.handler.codec.ByteToMessageDecoder;
import io.netty.handler.codec.CorruptedFrameException;
import netty.constant.math.ProtocolConstants;
import netty.message.AckMessage;
import util.JsonUtil;

import java.io.UnsupportedEncodingException;
import java.util.List;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * 计算结果协议解码器
 * @author donald
 * 2017年6月22日
 * 下午10:47:31
 */
public class AckMessageDecoder extends ByteToMessageDecoder {
    private static final Logger log = LoggerFactory.getLogger(AckMessageDecoder.class);
    @Override
    protected void decode(ChannelHandlerContext ctx, ByteBuf in, List<Object> out) {
    	//待数据可用时，解码消息
        int protocolLenth = ProtocolConstants.PROTOCOL_CODE_LENGTH+
        		ProtocolConstants.PROTOCOL_DATA_LENGTH;
        if (in.readableBytes() < protocolLenth) {
            return;
        }
        in.markReaderIndex();
        byte[] protocolCodeBytes = new byte[ProtocolConstants.PROTOCOL_CODE_LENGTH];
        in.readBytes(protocolCodeBytes);
        String protocolCode = "";
		try {
			protocolCode = new String(protocolCodeBytes,ProtocolConstants.CHARSET_UTF8);
		} catch (UnsupportedEncodingException e) {
			e.printStackTrace();
		}
        if (!protocolCode.equals(ProtocolConstants.ACK_PROTOCOL_300200) &&
        		!protocolCode.equals(ProtocolConstants.ACK_PROTOCOL_300300) ){
            in.resetReaderIndex();
            throw new CorruptedFrameException("Invalid protocol code: " + protocolCode);
        }
        int dataLength = in.readInt();
        if (in.readableBytes() < dataLength) {
            in.resetReaderIndex();
            return;
        }
        //转换接收的数据为MathMessage
        AckMessage mes = new AckMessage();
        mes.setProtocolCode(protocolCode);
        mes.setDataLenth(dataLength);
        mes.setResult(in.readInt());
        byte[] endMarkBytes = new byte[ProtocolConstants.PROTOCOL_END_LENGTH];
        in.readBytes(endMarkBytes);
        String endMark = "";
		try {
			endMark = new String(endMarkBytes,ProtocolConstants.CHARSET_UTF8);
		} catch (UnsupportedEncodingException e) {
			e.printStackTrace();
		}
		mes.setEndMark(endMark);
        out.add(mes);
        log.info("=======解码计算结果协议成功："+JsonUtil.toJson(mes));
    }
}


服务端： 
package netty.main.math;

import java.net.InetSocketAddress;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelOption;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import io.netty.handler.ssl.SslContext;
import io.netty.handler.ssl.SslContextBuilder;
import io.netty.handler.ssl.util.SelfSignedCertificate;
import netty.initializer.math.MathServerInitializer;

/**
 * 
 * @author donald
 * 2017年6月21日
 * 下午12:48:17
 */
public class MathServer {
	private static final Logger log = LoggerFactory.getLogger(MathServer.class);
	static final boolean SSL = System.getProperty("ssl") != null;
	private static final  String ip = "192.168.31.153";
	private static final  int port = 10010;
    public static void main(String[] args) throws Exception {
      run();
    }
    public static void run() throws Exception {
    	 // Configure SSL.
        final SslContext sslCtx;
        if (SSL) {
            SelfSignedCertificate ssc = new SelfSignedCertificate();
            sslCtx = SslContextBuilder.forServer(ssc.certificate(), ssc.privateKey()).build();
        } else {
            sslCtx = null;
        }

    	/*
    	 * EventLoopGroup（多线程事件loop），处理IO操作，这里我们用了两个事件loop
    	 * 第一个boss用于处理器监听连接请求，第二个worker用于数据的传输；
    	 * 具体线程是多少依赖于事件loop的具体实现
    	 * */
        EventLoopGroup bossGroup = new NioEventLoopGroup(); // (1)
        EventLoopGroup workerGroup = new NioEventLoopGroup();
        try {
        	//ServerBootstrap，用于配置服务端，一般为ServerSocket通道
            ServerBootstrap serverBoot = new ServerBootstrap(); 
            serverBoot.group(bossGroup, workerGroup)
             .channel(NioServerSocketChannel.class) 
             .childHandler(new MathServerInitializer(sslCtx))
             .option(ChannelOption.SO_BACKLOG, 128)//socket监听器连接队列大小、
             .childOption(ChannelOption.SO_KEEPALIVE, true); //保活，此配置针对ServerSocket通道接收连接产生的Socket通道
            InetSocketAddress inetSocketAddress = new InetSocketAddress(ip,port);
            // 绑定地址，开始监听
            ChannelFuture f = serverBoot.bind(inetSocketAddress).sync();
            log.info("=========Server is start=========");
            //等待，直到ServerSocket关闭
            f.channel().closeFuture().sync();
        } finally {
            workerGroup.shutdownGracefully();
            bossGroup.shutdownGracefully();
        }
    }

}

服务端通道处理器Initializer： 

package netty.initializer.math;

import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.socket.SocketChannel;
import io.netty.handler.codec.compression.ZlibCodecFactory;
import io.netty.handler.codec.compression.ZlibWrapper;
import io.netty.handler.ssl.SslContext;
import netty.codec.math.AckMessageEncoder;
import netty.codec.math.MathMessageDecoder;
import netty.handler.math.MathServerHandler;

/**
 * Creates a newly configured {@link ChannelPipeline} for a server-side channel.
 */
public class MathServerInitializer extends ChannelInitializer<SocketChannel> {

    private final SslContext sslCtx;

    public MathServerInitializer(SslContext sslCtx) {
        this.sslCtx = sslCtx;
    }

    @Override
    public void initChannel(SocketChannel ch) {
        ChannelPipeline pipeline = ch.pipeline();

        if (sslCtx != null) {
            pipeline.addLast(sslCtx.newHandler(ch.alloc()));
        }

        // Enable stream compression (you can remove these two if unnecessary)
        pipeline.addLast(ZlibCodecFactory.newZlibEncoder(ZlibWrapper.GZIP));
        pipeline.addLast(ZlibCodecFactory.newZlibDecoder(ZlibWrapper.GZIP));

        // Add the number codec first,
        pipeline.addLast(new MathMessageDecoder());
        pipeline.addLast(new AckMessageEncoder());

        // and then business logic.
        // Please note we create a handler for every new channel
        // because it has stateful properties.
        pipeline.addLast(new MathServerHandler());
    }
}


服务端处理器： 
package netty.handler.math;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;
import netty.constant.math.ProtocolConstants;
import netty.message.AckMessage;
import netty.message.MathMessage;

/**
 * Handler for a server-side channel.  This handler maintains stateful
 * information which is specific to a certain channel using member variables.
 * Therefore, an instance of this handler can cover only one channel.  You have
 * to create a new handler instance whenever you create a new channel and insert
 * this handler  to avoid a race condition.
 * @author donald
 * 2017年6月23日
 * 上午12:21:24
 */
public class MathServerHandler extends SimpleChannelInboundHandler<MathMessage> {
	private static final Logger log = LoggerFactory.getLogger(MathServerHandler.class);
    private MathMessage mathMes = new MathMessage();
    private AckMessage ackMes   = new AckMessage();

    @Override
    public void channelRead0(ChannelHandlerContext ctx, MathMessage msg) throws Exception {
    	mathMes = msg;
    	if(!mathMes.getEndMark().equals(ProtocolConstants.PROTOCOL_END)){
    		ackMes.setProtocolCode(ProtocolConstants.ACK_PROTOCOL_300300);
    	}
    	else{
    		ackMes.setProtocolCode(ProtocolConstants.ACK_PROTOCOL_300200);
    	}
    	String protocolCode = mathMes.getProtocolCode();
    	int result = 0;
    	if(protocolCode.equals(ProtocolConstants.SUM_PROTOCOL_300000)){
    		result = mathMes.getFirstNum() + mathMes.getSecondNum();
    	}
    	if(protocolCode.equals(ProtocolConstants.MULTI_PROTOCOL_300100)){
    		result = mathMes.getFirstNum() * mathMes.getSecondNum();
    	}
    	ackMes.setResult(result);
    	ackMes.setEndMark(ProtocolConstants.PROTOCOL_END);
    	ackMes.setDataLenth(ProtocolConstants.OPERATE_NUM_LENGTH+ProtocolConstants.PROTOCOL_END_LENGTH);
        ctx.writeAndFlush(ackMes);
    }

    @Override
    public void channelInactive(ChannelHandlerContext ctx) throws Exception {
    	ackMes = null;
    	mathMes	= null;	
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        cause.printStackTrace();
        ctx.close();
    }
}


客户端： 
package netty.main.math;

import java.net.InetSocketAddress;

import javax.net.ssl.SSLException;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import io.netty.bootstrap.Bootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelOption;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.nio.NioSocketChannel;
import io.netty.handler.ssl.SslContext;
import io.netty.handler.ssl.SslContextBuilder;
import io.netty.handler.ssl.util.InsecureTrustManagerFactory;
import netty.handler.math.MathClientHandler;
import netty.initializer.math.MathClientInitializer;
import util.JsonUtil;
/**
 * 
 * @author donald
 * 2017年6月21日
 * 下午12:48:10
 */
public final class MathClient {
	private static final Logger log = LoggerFactory.getLogger(MathClient.class);
	private static final boolean SSL = System.getProperty("ssl") != null;
	public static final String ip = System.getProperty("host", "192.168.31.153");
	public static final int port = Integer.parseInt(System.getProperty("port", "10010"));
	public static final int count = Integer.parseInt(System.getProperty("count", "2"));
    public static void main(String[] args) throws Exception {
       run();
    }
    private static void run() throws SSLException, InterruptedException{
    	 //配置安全套接字上下文
        final SslContext sslCtx;
        if (SSL) {
            sslCtx = SslContextBuilder.forClient()
                .trustManager(InsecureTrustManagerFactory.INSTANCE).build();
        } else {
            sslCtx = null;
        }
        EventLoopGroup workerGroup = new NioEventLoopGroup();
        try {
        	//Bootstrap与 ServerBootstrap相似，不同的是Bootstrap用于配置客户端，
        	//一般为Socket通道，或无连接通道
            Bootstrap bootstrap = new Bootstrap();
            //EventLoopGroup有 boss和worker两组,对于客户端只需要用worker
            bootstrap.group(workerGroup);
            bootstrap.channel(NioSocketChannel.class);
            bootstrap.option(ChannelOption.SO_KEEPALIVE, true);
            bootstrap.handler(new MathClientInitializer(sslCtx));
            InetSocketAddress inetSocketAddress = new InetSocketAddress(ip,port);
            //连接socket地址
            ChannelFuture f = bootstrap.connect(inetSocketAddress).sync();
            log.info("=========Client is start=========");
            // Get the handler instance to retrieve the answer.
            MathClientHandler handler =
                (MathClientHandler) f.channel().pipeline().last();
            // Print out the answer.
            log.info("=======Calculat result:"+JsonUtil.toJson(handler.getAckMessage()));
            //等待，直到连接关闭
            f.channel().closeFuture().sync();
        } finally {
        	workerGroup.shutdownGracefully();
        }
    }
}


客户端通道处理器Initializer： 
package netty.initializer.math;

import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.socket.SocketChannel;
import io.netty.handler.codec.compression.ZlibCodecFactory;
import io.netty.handler.codec.compression.ZlibWrapper;
import io.netty.handler.ssl.SslContext;
import netty.codec.math.AckMessageDecoder;
import netty.codec.math.MathMessageEncoder;
import netty.handler.math.MathClientHandler;
import netty.main.math.MathClient;

/**
 * Creates a newly configured {@link ChannelPipeline} for a client-side channel.
 */
public class MathClientInitializer extends ChannelInitializer<SocketChannel> {

    private final SslContext sslCtx;

    public MathClientInitializer(SslContext sslCtx) {
        this.sslCtx = sslCtx;
    }

    @Override
    public void initChannel(SocketChannel ch) {
        ChannelPipeline pipeline = ch.pipeline();

        if (sslCtx != null) {
            pipeline.addLast(sslCtx.newHandler(ch.alloc(), MathClient.ip, MathClient.port));
        }

        // Enable stream compression (you can remove these two if unnecessary)
        pipeline.addLast(ZlibCodecFactory.newZlibEncoder(ZlibWrapper.GZIP));
        pipeline.addLast(ZlibCodecFactory.newZlibDecoder(ZlibWrapper.GZIP));

        // Add the number codec first,
        pipeline.addLast(new AckMessageDecoder());
        pipeline.addLast(new MathMessageEncoder());

        // and then business logic.
        pipeline.addLast(new MathClientHandler());
    }
}



客户端handler： 
package netty.handler.math;

import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelFutureListener;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;
import netty.constant.math.ProtocolConstants;
import netty.main.math.MathClient;
import netty.message.AckMessage;
import netty.message.MathMessage;

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * 
 * Handler for a client-side channel.  This handler maintains stateful
 * information which is specific to a certain channel using member variables.
 * Therefore, an instance of this handler can cover only one channel.  You have
 * to create a new handler instance whenever you create a new channel and insert
 * this handler to avoid a race condition.
 * @author donald
 * 2017年6月23日
 * 上午12:29:00
 */
public class MathClientHandler extends SimpleChannelInboundHandler<AckMessage> {
	private static final Logger log = LoggerFactory.getLogger(MathClientHandler.class);
    private ChannelHandlerContext ctxLocal;
    private int receivedMesCount;
    private int sendedMesCount = 1;
    final BlockingQueue<AckMessage> ackMessQueue = new LinkedBlockingQueue<AckMessage>();

    public AckMessage getAckMessage() {
        boolean interrupted = false;
        try {
            for (;;) {
                try {
                    return ackMessQueue.take();
                } catch (InterruptedException ignore) {
                    interrupted = true;
                }
            }
        } finally {
            if (interrupted) {
                Thread.currentThread().interrupt();
            }
        }
    }

    @Override
    public void channelActive(ChannelHandlerContext ctx) {
        this.ctxLocal = ctx;
        sendMathMessages();
    }

    @Override
    public void channelRead0(ChannelHandlerContext ctx, final AckMessage msg) {
    	receivedMesCount ++;
        if (receivedMesCount == MathClient.count) {
            // Offer the answer after closing the connection.
        	ctxLocal.channel().close().addListener(new ChannelFutureListener() {
                @Override
                public void operationComplete(ChannelFuture future) {
                    boolean offered = ackMessQueue.offer(msg);
                    assert offered;
                }
            });
        }
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
        cause.printStackTrace();
        ctx.close();
    }
    /**
     * 
     */
    private void sendMathMessages() {
        // Do not send more than 1024 message.
        ChannelFuture future = null;
        for (int i = 0; i < 1024 && sendedMesCount <= MathClient.count; i++) {
        	MathMessage mes = new MathMessage();
        	if(i%2 != 0){
        		mes.setProtocolCode(ProtocolConstants.SUM_PROTOCOL_300000);
        	}
        	else{
        		mes.setProtocolCode(ProtocolConstants.MULTI_PROTOCOL_300100);
        	}
        	mes.setFirstNum(17);
        	mes.setSecondNum(8);
        	mes.setEndMark(ProtocolConstants.PROTOCOL_END);
        	mes.setDataLenth(ProtocolConstants.OPERATE_NUM_LENGTH*2+ProtocolConstants.PROTOCOL_END_LENGTH);
            future = ctxLocal.write(mes);
        	sendedMesCount++;
        }
        if (sendedMesCount <= MathClient.count) {
            assert future != null;
            future.addListener(mathMesSendListener);
        }
        ctxLocal.flush();
    }

    private final ChannelFutureListener mathMesSendListener = new ChannelFutureListener() {
        @Override
        public void operationComplete(ChannelFuture future) throws Exception {
            if (future.isSuccess()) {
            	sendMathMessages();
            } else {
                future.cause().printStackTrace();
                future.channel().close();
            }
        }
    };
}


启动服务端与客户端，控制台输出：
服务端:
[INFO ] 2017-07-06 09:03:15 netty.main.math.MathServer =========Server is start=========
[INFO ] 2017-07-06 09:03:24 netty.codec.math.MathMessageDecoder =======解码计算请求协议成功：{"dataLenth":10,"endMark":"\r\n","firstNum":17,"protocolCode":"300100","secondNum":8}
[INFO ] 2017-07-06 09:03:24 netty.codec.math.AckMessageEncoder =======编码计算结果协议成功：{"dataLenth":6,"endMark":"\r\n","protocolCode":"300200","result":136}
[INFO ] 2017-07-06 09:03:24 netty.codec.math.MathMessageDecoder =======解码计算请求协议成功：{"dataLenth":10,"endMark":"\r\n","firstNum":17,"protocolCode":"300000","secondNum":8}
[INFO ] 2017-07-06 09:03:24 netty.codec.math.AckMessageEncoder =======编码计算结果协议成功：{"dataLenth":6,"endMark":"\r\n","protocolCode":"300200","result":25}

客户端：
[INFO ] 2017-07-06 09:03:23 netty.main.math.MathClient =========Client is start=========
[INFO ] 2017-07-06 09:03:24 netty.codec.math.MathMessageEncoder =======编码计算请求协议成功：{"dataLenth":10,"endMark":"\r\n","firstNum":17,"protocolCode":"300100","secondNum":8}
[INFO ] 2017-07-06 09:03:24 netty.codec.math.MathMessageEncoder =======编码计算请求协议成功：{"dataLenth":10,"endMark":"\r\n","firstNum":17,"protocolCode":"300000","secondNum":8}
[INFO ] 2017-07-06 09:03:24 netty.codec.math.AckMessageDecoder =======解码计算结果协议成功：{"dataLenth":6,"endMark":"\r\n","protocolCode":"300200","result":136}
[INFO ] 2017-07-06 09:03:24 netty.codec.math.AckMessageDecoder =======解码计算结果协议成功：{"dataLenth":6,"endMark":"\r\n","protocolCode":"300200","result":25}
[INFO ] 2017-07-06 09:03:24 netty.main.math.MathClient =======Calculat result:{"dataLenth":6,"endMark":"\r\n","protocolCode":"300200","result":25}
Donald_Draper
关注
专栏目录
netty 例子
WangGaozhuo的专栏
03-21 485
客户端： public class TimeClient { public void connect(int port, String host){ EventLoopGroup group = new NioEventLoopGroup(); Bootstrap b = new Bootstrap(); b.group(group).channel(NioSocketChannel.class...
Netty最佳实践-数据通信
北辰
10-16 622
使用一种特殊的长连接，在指定某一时间之内，服务器与某台客户端没有任何通信，则断开连接。下次连接则是客户端向服务器发送请求的时候，再次建立连接。
netty通信完整示例
08-27
netty通信完整示例，含jar包，server端，client端，编码器，解码器 本人亲测成功。
netty 网络通信示例四
Donald_Draper的专栏
07-06 156
：[url]http://donald-draper.iteye.com/blog/2383392[/url] 上一篇我们在通过一个实例，来看一个用到编码器与解码器的示例，示例作用为服务器提供客户端计算请求，并将结果返回给客户端。之前实例的编解码器都是我们自己实现的，今天来看一个Netty基于textline编解码器通信示例： 服务端： [code="java"]package netty.main.telnet; import java.net.InetSocketAddr
网络通信框架——Netty示例
蒋含竹的博客
12-27 2513
文章目录网络通信框架——Netty示例概述Server/Client 聊天示例 网络通信框架——Netty示例 概述 Netty 是基于NIO封装的网络通信库，相较于Java原生IO库来说具有以下优点 API封装性好 简单、易用 功能强大，提供了各种常用库的接口 Server/Client 聊天示例 Maven依赖 pom.xml <dependency> &lt...
Netty服务器与客户端通讯案例
delete_bug的博客
09-29 225
Netty服务器端与客户端通讯案例
基于Netty的客户端与服务器之间的通信实例
Jasper6688的博客
12-13 1761
需要的jar包：https://github.com/Jasper2s/Study_Imooc/tree/master/JavaPractice/lib 1.全局配置类：存储每一个客户端接入进来的配置 package com.java.netty; /** * 全局配置类 * @author qiuzhiwen * */ import io.netty.channel.group....
基于Netty框架的网络通信示例.zip
09-06
基于Netty框架的网络通信示例 内容概要 本项目是一个基于Netty框架的网络通信示例，涵盖了多种网络通信场景，包括TCP、UDP、WebSocket等。项目展示了如何使用Netty进行高性能的异步网络编程，并提供了丰富的示例...
netty-book:netty权威指南示例代码
04-30
《Netty权威指南》是一本深入探讨Java网络编程框架Netty的专业书籍，其示例代码提供了丰富的实践场景，帮助读者更好地理解和应用Netty。Netty是Java领域内广泛使用的高性能、异步事件驱动的网络应用框架，适用于创建...
网络编程及Netty使用Java代码示例.zip
12-27
3. **Pipeline**：Pipeline是Netty的一个重要特性，它是一系列处理器链，每个处理器负责处理特定类型的事件或数据。这允许我们按需定制数据的处理流程，如解码、编码、业务逻辑处理等。 4. **Netty的Handler**：...
基于Netty框架的网络通信项目.zip
最新发布
09-07
本项目通过多个示例代码，展示了如何使用Netty实现不同类型的网络通信，包括HTTP服务器、WebSocket服务器、Protobuf编解码、Thrift服务等。 项目的主要特性和功能 1. HTTP服务器 实现了一个简单的HTTP服务器，...
使用Netty实现客户端和服务端之间的双向通信
weixin_44030476的博客
07-20 4352
在上个月的开发计划中，有一个系统控制喇叭播放的功能。当时就想到了使用netty进行通信操作。于是在调研途中，发现网上写的都是简单案例，不适用于当前的复杂通信模式。比如超时断线，断线重连，通信监听，错误记录存储，以及断线和上线后的钉钉通知等等。所以自己从头到尾重新写了一个完整项目，供大家参考。提示以下是本篇文章正文内容，下面案例可供参考。......
netty系列之:自定义编码解码器
程序那些事
08-16 9568
在之前的netty系列文章中，我们讲到了如何将对象或者String转换成为ByteBuf，通过使用netty自带的encoder和decoder可以实现非常方便的对象和ByteBuf之间的转换，然后就可以向channel中随意写入对象和字符串了。
http请求方式
weixin_52375544的博客
04-14 156
http请求方式 HTTP/1.1协议中共定义了八种方法（有时也叫“动作”）来表明Request-URI指定的资源的不同操作方式： OPTIONS - 返回服务器针对特定资源所支持的HTTP请求方法。 也可以利用向Web服务器发送’*'的请求来测试服务器的功能性。 HEAD - 向服务器索要与GET请求相一致的响应，只不过响应体将不会被返回。这一方法可以在不必传输整个响应内容的情况下，就可以获取包含在响应消息头中的元信息。 GET - 向特定的资源发出请求。注意：GET方法不应当被用于产生“副作用”的操作
Netty简单示例----客户端与服务器通信
wangshuang1631的博客
06-08 7031
本例实现功能为客户端获取服务器的时间并显示，参考《Netty权威指南》一书，不过书中使用Netty5实现的，考虑到Netty已经下架5，本例子使用Netty4.1.6版本。 首先服务器端，包括TimeServer、TimeServerHandler两个类： TimeServerimport io.netty.bootstrap.ServerBootstrap; import io.netty.c
Netty实现长连接简单例子
热门推荐
weihao_的博客
05-27 1万+
public class NettyClientHandler extends SimpleChannelInboundHandler {   @Override protected void messageReceived(ChannelHandlerContext ctx, RequestInfoVO msg) throws Exception { System.out.pri
Netty学习：搭建一个简单的Netty服务
hangge110的博客
06-08 4180
Netty学习：搭建一个简单的Netty服务 Netty 是一个基于 JAVA NIO 类库的异步通信框架，它的架构特点是：异步非阻塞、基于事件驱动、高性能、高可靠性和高可定制性。换句话说，Netty是一个NIO框架，使用它可以简单快速地开发网络应用程序，比如客户端和服务端的协议。Netty大大简化了网络程序的开发过程比如TCP和UDP的 Socket的开发。Netty 已逐渐成为 Ja
java消息压缩发送,Java-Netty(4.0.4)版本压缩/解压缩字符串消息错误
weixin_39623271的博客
03-22 413
我想在Netty客户端/服务器上应用压缩/解压缩,我在客户端和服务器中对管道使用以下代码：@Overrideprotected void initChannel(SocketChannel ch) throws Exception {ChannelPipeline pipeline = ch.pipeline();pipeline.addLast("framer", new DelimiterBa...
Netty实现网络通信
05-10
Netty是一个高性能、异步事件驱动的网络通信框架，它提供了对TCP、UDP和HTTP协议的支持，可以广泛应用于服务器、客户端、网关、...以上是基于Netty实现网络通信的大致步骤，具体实现可以参考Netty官方文档和相关示例。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值