Netty多协议开发
HTTP协议开发
post与get的区别
1）get用于信息获取，post用于更新资源。
2）get数据放在请求行中，post数据放在请求体内。
3）get对数据长度有限制（2083字节），post没有限制。
4）post比get安全性高。
Netty Http+Xml协议栈开发
高效的XML绑定JiBx JOPO <=> XML
package com.netty.ch10; import java.io.IOException; import java.io.StringReader; import java.io.StringWriter; import org.jibx.runtime.BindingDirectory; import org.jibx.runtime.IBindingFactory; import org.jibx.runtime.IMarshallingContext; import org.jibx.runtime.IUnmarshallingContext; import org.jibx.runtime.JiBXException; import com.netty.ch10.httpXML.pojo.Order; import com.netty.ch10.httpXML.pojo.OrderFactory; /** * jiBx类库的使用 * @author Administrator * ANT 脚本生成XML与对象的绑定关系 *1)下载JiBx包 *2）JiBx包 的example下找到一个build.xml 并运行target ==> BindGen 生成 binding.xml 和 pojo.xsd * <target name="bindgen"> <echo message="Running BindGen tool"/> <java classpathref="classpath" fork="true" failonerror="true" classname="org.jibx.binding.generator.BindGen"> <arg value="-s"/> <arg value="${basedir}/src/com/netty/ch10/httpXML/pojo"/> <arg value="com.netty.ch10.httpXML.pojo.Order"/> </java> </target> 3)jibx编译命令 动态修改POJO类 ==> bind <!-- bind as a separate step --> <target name="bind" depends="check-binding"> <echo message="Running JiBX binding compiler"/> <taskdef name="bind" classname="org.jibx.binding.ant.CompileTask"> <classpath> <fileset dir="${jibx-home}/lib" includes="*.jar"/> </classpath> </taskdef> <bind binding="${basedir}/binding.xml"> <classpath refid="classpath"/> </bind> </target> 4)运行测试类 */ public class TestOrder { private IBindingFactory factory = null; private StringWriter write = null; private StringReader reader = null; private final static String CHARSET_NAME = "UTF-8"; /** * pojo to xml * @param order * @return * @throws JiBXException * @throws IOException */ private String encode2Xml(Order order) throws JiBXException, IOException{ factory = BindingDirectory.getFactory(Order.class); write = new StringWriter(); IMarshallingContext mctx = factory.createMarshallingContext(); mctx.setIndent(2); mctx.marshalDocument(order,CHARSET_NAME,null,write); String xmlStr = write.toString(); write.close(); System.out.println(xmlStr); return xmlStr; } private Order decode2Order(String xmlBody) throws JiBXException{ reader = new StringReader(xmlBody); IUnmarshallingContext uctx = factory.createUnmarshallingContext(); Order order = (Order)uctx.unmarshalDocument(reader); return order; } public static void main(String[] args) throws JiBXException, IOException { TestOrder test = new TestOrder(); Order order = OrderFactory.create(); String body = test.encode2Xml(order); Order order2 = test.decode2Order(body); System.out.println(order2); } }
Http请求类
package com.netty.ch10.httpXML.request; import io.netty.handler.codec.http.FullHttpRequest; public class HttpXmlRequest { private FullHttpRequest request; private Object body; /** * @return the body */ public Object getBody() { return body; } /** * @param body the body to set */ public void setBody(Object body) { this.body = body; } public HttpXmlRequest(FullHttpRequest request, Object body) { this.request = request; this.body = body; } public final FullHttpRequest getRequest() { return request; } public final void setRequest(FullHttpRequest request) { this.request = request; } }
Http响应类
package com.netty.ch10.httpXML.response; import io.netty.handler.codec.http.FullHttpRequest; import io.netty.handler.codec.http.FullHttpResponse; public class HttpXmlResponse { private FullHttpResponse httpResponse; private Object result; public HttpXmlResponse(FullHttpResponse httpResponse, Object result) { super(); this.httpResponse = httpResponse; this.result = result; } public HttpXmlResponse() { super(); // TODO Auto-generated constructor stub } /** * @return the httpResponse */ public FullHttpResponse getHttpResponse() { return httpResponse; } /** * @param httpResponse the httpResponse to set */ public void setHttpResponse(FullHttpResponse httpResponse) { this.httpResponse = httpResponse; } /** * @return the result */ public Object getResult() { return result; } /** * @param result the result to set */ public void setResult(Object result) { this.result = result; } }
Encoder编码基类
package com.netty.ch10.httpXML.common; import java.io.StringWriter; import java.nio.charset.Charset; import java.util.List; import org.jibx.runtime.BindingDirectory; import org.jibx.runtime.IBindingFactory; import org.jibx.runtime.IMarshallingContext; import io.netty.buffer.ByteBuf; import io.netty.buffer.Unpooled; import io.netty.channel.ChannelHandlerContext; import io.netty.handler.codec.MessageToMessageCodec; import io.netty.handler.codec.MessageToMessageEncoder; /** * HTTP+XML 请求消息编码基类 * @author Administrator * * @param <T> */ public abstract class AbstractHttpXmlEncoder<T> extends MessageToMessageEncoder<T>{ IBindingFactory factory = null; StringWriter writer = null; final static String CHARSET_NAME ="UTF-8"; final static Charset UTF_8 = Charset.forName(CHARSET_NAME); protected ByteBuf encode0(ChannelHandlerContext ctx,Object body) throws Exception{ factory = BindingDirectory.getFactory(body.getClass()); writer= new StringWriter(); IMarshallingContext mctx = factory.createMarshallingContext(); mctx.setIndent(2); mctx.marshalDocument(body,CHARSET_NAME,null,writer); String xmlStr = writer.toString(); writer.close(); writer = null; ByteBuf encodeBuf = Unpooled.copiedBuffer(xmlStr,UTF_8); return encodeBuf; } /* (non-Javadoc) * @see io.netty.channel.ChannelHandlerAdapter#exceptionCaught(io.netty.channel.ChannelHandlerContext, java.lang.Throwable) */ @Override public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception { // TODO Auto-generated method stub super.exceptionCaught(ctx, cause); if(writer != null){ writer.close(); writer = null; } } }
HTTP请求编码类
package com.netty.ch10.httpXML.request; import java.net.InetAddress; import java.util.List; import com.netty.ch10.httpXML.common.AbstractHttpXmlEncoder; import io.netty.buffer.ByteBuf; import io.netty.channel.ChannelHandlerContext; import io.netty.handler.codec.http.DefaultFullHttpRequest; import io.netty.handler.codec.http.FullHttpRequest; import io.netty.handler.codec.http.HttpHeaderNames; import io.netty.handler.codec.http.HttpHeaderValues; import io.netty.handler.codec.http.HttpHeaders; //import io.netty.handler.codec.http.HttpHeaders; import io.netty.handler.codec.http.HttpMethod; import io.netty.handler.codec.http.HttpVersion; /** * HTTP+XML Http 请求消息编码类 * @author Administrator * */ public class HttpXmlRequestEncoder extends AbstractHttpXmlEncoder<HttpXmlRequest>{ @Override protected void encode(ChannelHandlerContext ctx, HttpXmlRequest msg, List<Object> out) throws Exception { // TODO Auto-generated method stub //将业务需要发送的pojo对象Order实例通过JiBx序列化成字符串，随后封装成Netty的ByteBuf。 ByteBuf body = encode0(ctx, msg.getBody()) ; FullHttpRequest request = msg.getRequest(); //如果业务侧没有设置消息头 则构造新的http请求头 if(request == null){ request = new DefaultFullHttpRequest(HttpVersion.HTTP_1_1,HttpMethod.GET,"/do",body); //从request中获取请求头 HttpHeaders header = request.headers(); //设置一系列的请求头 这边以硬编码的方式 产品化可以做成xml配置文件 header.set(HttpHeaderNames.HOST,InetAddress.getLocalHost().getHostAddress()); header.set(HttpHeaderNames.CONNECTION,HttpHeaderValues.CLOSE); header.set(HttpHeaderNames.ACCEPT_ENCODING,HttpHeaderValues.GZIP.toString() +","+HttpHeaderValues.DEFLATE.toString()); header.set(HttpHeaderNames.ACCEPT_CHARSET,"ISO-8859-1,utf-8;q=0.7,*;q=0.7"); header.set(HttpHeaderNames.USER_AGENT,"Netty xml Http Client side"); header.set(HttpHeaderNames.ACCEPT,"text/html.application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8"); header.set(HttpHeaderNames.CONTENT_LENGTH,Integer.toString(body.readableBytes())); } //完成消息体xml序列化后重新构造http请求消息加入到out中，由http请求编码器继续对http请求消息进行编码 out.add(request); } }
Http响应编码类
package com.netty.ch10.httpXML.response; import java.util.List; import com.netty.ch10.httpXML.common.AbstractHttpXmlEncoder; import io.netty.buffer.ByteBuf; import io.netty.channel.ChannelHandlerContext; import io.netty.handler.codec.AsciiString; import io.netty.handler.codec.http.DefaultFullHttpResponse; import io.netty.handler.codec.http.FullHttpResponse; import io.netty.handler.codec.http.HttpHeaderNames; import io.netty.handler.codec.http.HttpHeaderUtil; import io.netty.handler.codec.http.HttpHeaders; import io.netty.handler.codec.http.HttpResponseStatus; import io.netty.handler.codec.http.HttpVersion; /** * Http+xml 应答消息编码类 * @author Administrator * */ public class HttpXmlResponseEncoder extends AbstractHttpXmlEncoder<HttpXmlResponse> { private static final HttpVersion HTTP_1_1 = HttpVersion.HTTP_1_1; private static final HttpResponseStatus OK = HttpResponseStatus.OK; private static final AsciiString CONTENT_TYPE = HttpHeaderNames.CONTENT_TYPE; @Override protected void encode(ChannelHandlerContext ctx, HttpXmlResponse msg, List<Object> out) throws Exception { ByteBuf body = encode0(ctx,msg.getResult()); FullHttpResponse response = msg.getHttpResponse(); if(response == null){ response = new DefaultFullHttpResponse(HTTP_1_1,OK,body); }else{ new DefaultFullHttpResponse(msg.getHttpResponse().protocolVersion(), msg.getHttpResponse().status(), body); } response.headers().set(CONTENT_TYPE, "text/xml"); response.headers().set(HttpHeaderNames.CONTENT_LENGTH,Integer.toString(body.readableBytes())); //将编码后的response对象添加到编码结果链表中，由后续的Http编码类进行二次编码 out.add(response); } }
Decoder编码基类
package com.netty.ch10.httpXML.common; import java.io.StringReader; import java.net.SocketAddress; import java.nio.charset.Charset; import java.util.List; import org.jibx.runtime.BindingDirectory; import org.jibx.runtime.IBindingFactory; import org.jibx.runtime.IMarshallingContext; import org.jibx.runtime.IUnmarshallingContext; import io.netty.buffer.ByteBuf; import io.netty.channel.ChannelHandlerContext; import io.netty.channel.ChannelPromise; import io.netty.handler.codec.MessageToMessageDecoder; public abstract class AbstractHttpXmlDecoder<T> extends MessageToMessageDecoder<T> { private IBindingFactory factory; private StringReader reader; private Class<?> clazz; private boolean isPrint; private final static String CHARSET_NAME = "UTF-8"; private final static Charset UTF_8 = Charset.forName(CHARSET_NAME); protected AbstractHttpXmlDecoder(Class<?> clazz){ this(clazz, false); } protected AbstractHttpXmlDecoder(Class<?> clazz,boolean isPrint){ this.clazz = clazz; this.isPrint = isPrint; } protected Object decode0(ChannelHandlerContext arg0,ByteBuf body) throws Exception{ factory = BindingDirectory.getFactory(clazz); String context = body.toString(UTF_8); if(isPrint) System.out.println("The body is"+context); reader =new StringReader(context); IUnmarshallingContext uctx = factory.createUnmarshallingContext(); Object result = uctx.unmarshalDocument(reader); reader.close(); reader = null; return result; } @Override public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) throws Exception { // TODO Auto-generated method stub super.write(ctx, msg, promise); if(reader != null){ reader.close(); reader = null; } } }
Http请求解码类
package com.netty.ch10.httpXML.request; import java.util.List; import com.netty.ch10.httpXML.common.AbstractHttpXmlDecoder; import io.netty.buffer.Unpooled; import io.netty.channel.ChannelFutureListener; import io.netty.channel.ChannelHandlerContext; import io.netty.handler.codec.http.DefaultFullHttpResponse; import io.netty.handler.codec.http.FullHttpRequest; import io.netty.handler.codec.http.FullHttpResponse; import io.netty.handler.codec.http.HttpResponseStatus; import io.netty.handler.codec.http.HttpVersion; import io.netty.util.CharsetUtil; /** * HTTP+XML Http请求消息解码类 * @author Administrator * */ public class HttpXmlRequestDecoder extends AbstractHttpXmlDecoder<FullHttpRequest> { public HttpXmlRequestDecoder(Class<?> clazz) { this( clazz,false); } public HttpXmlRequestDecoder(Class<?> clazz,boolean isPrint) { super(clazz,isPrint); } /* (non-Javadoc) * @see com.netty.ch10.httpXML.response.AbstractHttpXmlDecoder#decode(io.netty.channel.ChannelHandlerContext, java.lang.Object, java.util.List) */ @Override protected void decode(ChannelHandlerContext arg0, FullHttpRequest arg1, List<Object> arg2) throws Exception { if(!arg1.decoderResult().isSuccess()){ sendError(arg0, HttpResponseStatus.BAD_REQUEST); return; } //通过FullHttpRequest 和经过decode0将byteBuf反序列化的order对象 构造HttpXmlRequest HttpXmlRequest request = new HttpXmlRequest(arg1, decode0(arg0,arg1.content())); arg2.add(request); } private static void sendError(ChannelHandlerContext ctx,HttpResponseStatus status){ FullHttpResponse response = new DefaultFullHttpResponse(HttpVersion.HTTP_1_1,status ,Unpooled.copiedBuffer("Failure:"+status.toString()+"\r\n", CharsetUtil.UTF_8)); response.headers().set("contextType","text/plain;charset=UTF-8"); ctx.writeAndFlush(response).addListener(ChannelFutureListener.CLOSE); } }
Http响应解码类
package com.netty.ch10.httpXML.response; import java.util.List; import com.netty.ch10.httpXML.common.AbstractHttpXmlDecoder; import io.netty.channel.ChannelHandlerContext; import io.netty.handler.codec.http.DefaultFullHttpResponse; public class HttpXmlResponseDecoder extends AbstractHttpXmlDecoder<DefaultFullHttpResponse> { public HttpXmlResponseDecoder(Class<?> clazz) { this(clazz,false); // TODO Auto-generated constructor stub } public HttpXmlResponseDecoder(Class<?> clazz,boolean isPrintLog) { super(clazz,isPrintLog); // TODO Auto-generated constructor stub } @Override protected void decode(ChannelHandlerContext ctx, DefaultFullHttpResponse msg, List<Object> out) throws Exception { //将反序列化的POJO对象构造成HttpXmlResponse 并添加到解码结果列表中 HttpXmlResponse resHttpXmlResponse = new HttpXmlResponse(msg,decode0(ctx,msg.content())); out.add(resHttpXmlResponse); } }
客户端及客户端请求handler
package com.netty.ch10.httpXML; import java.net.InetSocketAddress; import com.netty.ch10.httpXML.pojo.Order; import com.netty.ch10.httpXML.request.HttpXmlRequestEncoder; import com.netty.ch10.httpXML.response.HttpXmlResponseDecoder; import io.netty.bootstrap.Bootstrap; 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.NioSocketChannel; import io.netty.handler.codec.http.HttpObjectAggregator; import io.netty.handler.codec.http.HttpRequestDecoder; import io.netty.handler.codec.http.HttpRequestEncoder; /** * Http+xml客户端 * @author Administrator *1）发起Http连接请求 *2）构造订购请求消息，将其编码成xml，通过http协议发给服务端 *3）构造http服务端的应答消息，将xml应答消息反序列化为订购消息POJO对象 *4）关闭HTTP连接 * *Handler的执行顺序 ：https://my.oschina.net/jamaly/blog/272385 *https://my.oschina.net/freegarden/blog/300348 * * 执行顺序是：Encoder 先注册的后执行，与OutboundHandler一致；Decoder是先注册的先执行，与InboundHandler一致。 * */ public class HttpXmlClient { public void connect(int port) throws Exception{ //配置客户端NIO线程组 EventLoopGroup group = new NioEventLoopGroup(); try{ Bootstrap b = new Bootstrap(); b.group(group) .channel(NioSocketChannel.class) .option(ChannelOption.TCP_NODELAY, true) .handler(new ChannelInitializer<SocketChannel>() { @Override protected void initChannel(SocketChannel ch) throws Exception { //负责将二进制码流解码成HTTP的应答消息 ch.pipeline().addLast("http-decoder",new HttpRequestDecoder()); //负责将1个http请求消息的多个部分合并成一个完整的http消息 ch.pipeline().addLast("http-aggregator",new HttpObjectAggregator(65535)); //XML解码器 ch.pipeline().addLast("xml-decoder",new HttpXmlResponseDecoder(Order.class, true)); //【注意】：顺序，编码的时候按照从尾到头的顺序 HttpXmlClientHandler-->HttpXmlRequestEncoder-->HttpRequestEncoder ch.pipeline().addLast("http-encoder",new HttpRequestEncoder()); //2)封装成完整的httprequest ch.pipeline().addLast("xml-encoder",new HttpXmlRequestEncoder()); //1)pojo -->bytebuf //write POJO receive POJO ch.pipeline().addLast("xml-client-handler",new HttpXmlClientHandler()); } }); //发起异步连接请求 ChannelFuture f = b.connect(new InetSocketAddress(port)).sync(); //等待客户端链路关闭 f.channel().closeFuture().sync(); }finally{ group.shutdownGracefully(); } } public static void main(String[] args) throws Exception{ int port = 8080; if(args != null && args.length > 0){ try { port = Integer.valueOf(args[0]); } catch (Exception e) { // TODO: handle exception } } new HttpXmlClient().connect(port); } }
package com.netty.ch10.httpXML; import com.netty.ch10.httpXML.request.HttpXmlRequest; import com.netty.ch10.httpXML.response.HttpXmlResponse; import io.netty.channel.ChannelHandlerContext; import io.netty.channel.SimpleChannelInboundHandler; public class HttpXmlClientHandler extends SimpleChannelInboundHandler<HttpXmlResponse> { @Override protected void messageReceived(ChannelHandlerContext ctx, HttpXmlResponse msg) throws Exception { System.out.println("the client receive response of http header is :" + msg.getHttpResponse().headers().names()); System.out.println("the client receive response of http body is :"+ msg.getResult()); } /* (non-Javadoc) * @see io.netty.channel.ChannelHandlerAdapter#channelActive(io.netty.channel.ChannelHandlerContext) */ @Override public void channelActive(ChannelHandlerContext ctx) throws Exception { HttpXmlRequest request = new HttpXmlRequest(null, OrderFactory.create(124)); ctx.writeAndFlush(request); } /* (non-Javadoc) * @see io.netty.channel.ChannelHandlerAdapter#exceptionCaught(io.netty.channel.ChannelHandlerContext, java.lang.Throwable) */ @Override public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception { cause.printStackTrace(); ctx.close(); } }
服务端及服务端响应handler
package com.netty.ch10.httpXML; import java.net.InetSocketAddress; import com.netty.ch10.httpXML.pojo.Order; import com.netty.ch10.httpXML.request.HttpXmlRequestDecoder; import com.netty.ch10.httpXML.response.HttpXmlResponseEncoder; import io.netty.bootstrap.ServerBootstrap; import io.netty.channel.ChannelFuture; import io.netty.channel.ChannelInitializer; 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.HttpResponseDecoder; import io.netty.handler.codec.http.HttpResponseEncoder; /** * Http 服务端的功能如下 * @author Administrator *1）接收Http客户端的连接 *2）接收http客户端的xml请求消息，并将其解码成POJO对象 *3）对pojo对象进行业务处理 *4）通过http+xml的格式返回应答消息 *5）主动关闭http连接 */ public class HttpXmlServer { public void run(final int port) throws Exception{ NioEventLoopGroup workerGroup = new NioEventLoopGroup(); NioEventLoopGroup bossGroup = new NioEventLoopGroup(); try { ServerBootstrap b = new ServerBootstrap(); b.group(bossGroup,workerGroup) .channel(NioServerSocketChannel.class) .childHandler(new ChannelInitializer<SocketChannel>() { @Override protected void initChannel(SocketChannel ch) throws Exception { ch.pipeline().addLast("http-decoder",new HttpRequestDecoder()); ch.pipeline().addLast("http-aggregator",new HttpObjectAggregator(65536)); ch.pipeline().addLast("xml-decoder",new HttpXmlRequestDecoder(Order.class,true)); //下面顺序相反 ch.pipeline().addLast("http-encoder",new HttpResponseEncoder()); ch.pipeline().addLast("xml-encoder",new HttpXmlResponseEncoder()); ch.pipeline().addLast("xmlServerHandler",new HttpXmlServerHandler()); } }); ChannelFuture future = b.bind(new InetSocketAddress(port)).sync(); System.out.println("Http 订购服务器启动，网址是："+"http://localhost:"+port); // Wait until the connection is closed. future.channel().closeFuture().sync(); } catch (Exception e) { // TODO: handle exception } } public static void main(String[] args) throws Exception { int port = 8080; if(args.length>0){ try{ port = Integer.parseInt(args[0]); }catch(Exception e){ e.printStackTrace(); } } new HttpXmlServer().run(port); } }
package com.netty.ch10.httpXML; import java.util.ArrayList; import java.util.List; import com.netty.ch10.httpXML.pojo.Address; import com.netty.ch10.httpXML.pojo.Order; import com.netty.ch10.httpXML.request.HttpXmlRequest; import com.netty.ch10.httpXML.response.HttpXmlResponse; import io.netty.buffer.Unpooled; import io.netty.channel.ChannelFuture; import io.netty.channel.ChannelFutureListener; import io.netty.channel.ChannelHandlerContext; import io.netty.channel.SimpleChannelInboundHandler; import io.netty.handler.codec.http.DefaultFullHttpResponse; import io.netty.handler.codec.http.FullHttpRequest; import io.netty.handler.codec.http.FullHttpResponse; import io.netty.handler.codec.http.HttpHeaderNames; import io.netty.handler.codec.http.HttpResponseStatus; import io.netty.handler.codec.http.HttpVersion; import io.netty.util.CharsetUtil; import io.netty.util.concurrent.Future; import io.netty.util.concurrent.GenericFutureListener; public class HttpXmlServerHandler extends SimpleChannelInboundHandler<HttpXmlRequest> { @Override public void messageReceived(final ChannelHandlerContext ctx, HttpXmlRequest xmlRequest) throws Exception { FullHttpRequest request = xmlRequest.getRequest(); Order order = (Order)xmlRequest.getBody(); System.out.println("Http server receive request :"+ order); dobusiness(order); ChannelFuture future = ctx.writeAndFlush(new HttpXmlResponse(null,order)); if(!ctx.channel().isActive()){ future.addListener(new GenericFutureListener<Future<? super Void>>() { @Override public void operationComplete(Future future) throws Exception { // TODO Auto-generated method stub ctx.close(); } }); } } private void dobusiness(Order order) { order.getCustomer().setFirstName("狄"); order.getCustomer().setLastName("仁杰"); List<String> midNames = new ArrayList<String>(); midNames.add("李元芳"); order.getCustomer().setMiddleNames(midNames); Address address = order.getBillTo(); address.setCity("洛阳"); address.setCountry("大唐"); address.setState("河南道"); address.setPostCode("123456"); order.setBillTo(address); // order.setShiping(address); } /* * (non-Javadoc) * * @see * io.netty.channel.ChannelHandlerAdapter#exceptionCaught(io.netty.channel. * ChannelHandlerContext, java.lang.Throwable) */ @Override public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception { // TODO Auto-generated method stub cause.printStackTrace(); if(ctx.channel().isActive()){ sendError(ctx, HttpResponseStatus.INTERNAL_SERVER_ERROR); } } private static void sendError(ChannelHandlerContext ctx, HttpResponseStatus status) { FullHttpResponse response = new DefaultFullHttpResponse(HttpVersion.HTTP_1_1, status, Unpooled.copiedBuffer("失败：" + status.toString() + "\r\n", CharsetUtil.UTF_8)); response.headers().set(HttpHeaderNames.CONTENT_TYPE, "text/plain;charset=UTF-8"); ctx.writeAndFlush(response).addListener(ChannelFutureListener.CLOSE); } }
WebSocket协议开发
webSocket将网络套接字引入到客户端和服务端，浏览器和服务端之间可以通过套接字建立持久连接，双方随时都可以互发数据给对方，而不是之前由客户端控制的请求-应答模式。
http协议的弊端：
1）同一时刻只能在一个方向上传输数据（半双工）
2）HTTP消息冗余而繁琐
3）针对服务器推送的黑客攻击，如长时间轮询。
webSocket特点：
1）单一的TCP连接，采用全双工模式通信
2）对代理，防火墙和路由器透明
3）无头部信息，Cookie和身份验证
4）无安全开销
5）通过“ping/pong”帧保持链路激活
6）服务器可以主动传递消息给客户端，不再需要客户端轮询。
server
package com.netty.ch11; import io.netty.bootstrap.ServerBootstrap; import io.netty.channel.Channel; import io.netty.channel.ChannelInitializer; import io.netty.channel.ChannelPipeline; 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.HttpServerCodec; import io.netty.handler.stream.ChunkedWriteHandler; /** * webSocketServer 启动端 * * @author Administrator * */ public class WebSocketServer { public void run(int port) throws Exception { NioEventLoopGroup bossGroup = new NioEventLoopGroup(); NioEventLoopGroup workerGroup = new NioEventLoopGroup(); try { ServerBootstrap b = new ServerBootstrap(); b.group(bossGroup, workerGroup).channel(NioServerSocketChannel.class) .childHandler(new ChannelInitializer<SocketChannel>() { @Override protected void initChannel(SocketChannel ch) throws Exception { ChannelPipeline pipeline = ch.pipeline(); //将请求和应答消息编码和解码为http消息 pipeline.addLast("http-codec", new HttpServerCodec()); //将Http消息的多个部分组合成一条完整的http消息 pipeline.addLast("aggregator", new HttpObjectAggregator(65536)); //来向客户端发送html5文件 ch.pipeline().addLast("http-chunked", new ChunkedWriteHandler()); ch.pipeline().addLast("handler", new WebSocketServerHandler()); } }); Channel ch = b.bind(port).sync().channel(); System.out.println("Web socket server started at port " + port + '.'); System.out.println("Open your browser and navigate to http://localhost:" + port + '/'); ch.closeFuture().sync(); } finally { System.out.println("stop server"); bossGroup.shutdownGracefully(); workerGroup.shutdownGracefully(); } } public static void main(String[] args) throws Exception { int port = 8080; if (args.length > 0) { try { port = Integer.parseInt(args[0]); } catch (NumberFormatException e) { e.printStackTrace(); } } new WebSocketServer().run(port); } }
websocket处理类
package com.netty.ch11; import io.netty.buffer.ByteBuf; import io.netty.buffer.Unpooled; import io.netty.channel.ChannelFuture; import io.netty.channel.ChannelFutureListener; import io.netty.channel.ChannelHandlerContext; import io.netty.channel.SimpleChannelInboundHandler; import io.netty.handler.codec.http.DefaultFullHttpResponse; import io.netty.handler.codec.http.FullHttpRequest; import io.netty.handler.codec.http.FullHttpResponse; import io.netty.handler.codec.http.HttpHeaderNames; import io.netty.handler.codec.http.websocketx.*; import io.netty.util.CharsetUtil; import java.util.logging.Level; import java.util.logging.Logger; import static io.netty.handler.codec.http.HttpResponseStatus.BAD_REQUEST; import static io.netty.handler.codec.http.HttpVersion.HTTP_1_1; /** * @version 1.0 * @date 2014年2月14日 */ public class WebSocketServerHandler extends SimpleChannelInboundHandler<Object> { private static final Logger logger = Logger .getLogger(WebSocketServerHandler.class.getName()); //握手处理类 private WebSocketServerHandshaker handshaker; @Override public void messageReceived(ChannelHandlerContext ctx, Object msg) throws Exception { // 传统的HTTP接入 if (msg instanceof FullHttpRequest) { handleHttpRequest(ctx, (FullHttpRequest) msg); } // WebSocket接入 前端请求websocket socket.onmessage else if (msg instanceof WebSocketFrame) { handleWebSocketFrame(ctx, (WebSocketFrame) msg); } } @Override public void channelReadComplete(ChannelHandlerContext ctx) throws Exception { ctx.flush(); } private void handleHttpRequest(ChannelHandlerContext ctx, FullHttpRequest req) throws Exception { // 如果HTTP解码失败，返回HHTP异常 if (!req.decoderResult().isSuccess() || (!"websocket".equals(req.headers().get("Upgrade")))) { sendHttpResponse(ctx, req, new DefaultFullHttpResponse(HTTP_1_1, BAD_REQUEST)); return; } // 构造握手响应返回，本机测试 WebSocketServerHandshakerFactory wsFactory = new WebSocketServerHandshakerFactory( "ws://localhost:8080/websocket", null, false); //创建握手消息处理类 handshaker = wsFactory.newHandshaker(req); //无法处理的websocket if (handshaker == null) { WebSocketServerHandshakerFactory .sendUnsupportedVersionResponse(ctx.channel()); } else { handshaker.handshake(ctx.channel(), req); } } private void handleWebSocketFrame(ChannelHandlerContext ctx, WebSocketFrame frame) { // 判断是否是关闭链路的指令 if (frame instanceof CloseWebSocketFrame) { handshaker.close(ctx.channel(), (CloseWebSocketFrame) frame.retain()); return; } // 判断是否是Ping消息 if (frame instanceof PingWebSocketFrame) { ctx.channel().write( new PongWebSocketFrame(frame.content().retain())); return; } // 本例程仅支持文本消息，不支持二进制消息 if (!(frame instanceof TextWebSocketFrame)) { throw new UnsupportedOperationException(String.format( "%s frame types not supported", frame.getClass().getName())); } // 返回应答消息 String request = ((TextWebSocketFrame) frame).text(); if (logger.isLoggable(Level.FINE)) { logger.fine(String.format("%s received %s", ctx.channel(), request)); } ctx.channel().write( new TextWebSocketFrame(request + " , 欢迎使用Netty WebSocket服务，现在时刻：" + new java.util.Date().toString())); } private static void sendHttpResponse(ChannelHandlerContext ctx, FullHttpRequest req, FullHttpResponse res) { // 返回应答给客户端 if (res.status().code() != 200) { ByteBuf buf = Unpooled.copiedBuffer(res.status().toString(), CharsetUtil.UTF_8); res.content().writeBytes(buf); buf.release(); res.headers().set(HttpHeaderNames.CONTENT_LENGTH ,Integer.toString(res.content().readableBytes())); } // 如果是非Keep-Alive，关闭连接 ChannelFuture f = ctx.channel().writeAndFlush(res); if (!ctx.channel().isActive() || res.status().code() != 200) { f.addListener(ChannelFutureListener.CLOSE); } } @Override public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception { cause.printStackTrace(); ctx.close(); } }
client html
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
Netty WebSocket 时间服务器
</head>
<br>
<body>
<br>
<script type="text/javascript">
var socket;
if (!window.WebSocket) {
window.WebSocket = window.MozWebSocket;
}
if (window.WebSocket) {
socket = new WebSocket("ws://localhost:8080/websocket");
socket.onmessage = function (event) {
var ta = document.getElementById('responseText');
ta.value = "";
ta.value = event.data
};
socket.onopen = function (event) {
var ta = document.getElementById('responseText');
ta.value = "打开WebSocket服务正常，浏览器支持WebSocket!";
};
socket.onclose = function (event) {
var ta = document.getElementById('responseText');
ta.value = "";
ta.value = "WebSocket 关闭!";
};
}
else {
alert("抱歉，您的浏览器不支持WebSocket协议!");
}
function send(message) {
if (!window.WebSocket) {
return;
}
if (socket.readyState == WebSocket.OPEN) {
socket.send(message);
}
else {
alert("WebSocket连接没有建立成功!");
}
}
</script>
<form onsubmit="return false;">
<input type="text" name="message" value="Netty最佳实践"/>
<br><br>
<input type="button" value="发送WebSocket请求消息" onclick="send(this.form.message.value)"/>
<hr color="blue"/>
<h3>服务端返回的应答消息</h3>
<textarea id="responseText" style="width:500px;height:300px;"></textarea>
</form>
</body>
</html>
私有协议栈开发
绝大多数的私有协议传输层都是基于TCP/IP，所以利用Netty的NIO TCP协议栈可以很方便的进行私有协议的定制和开发。
Netty协议栈功能设计
通信模型：
1）Netty协议栈client发送握手消息，携带节点IP等有效身份认证信息。
2）Netty协议栈服务端对握手请求消息进行合法性的认证，包括节点ID有效性检验，节点重复登录校验和IP地址合法性校验，校验通过后，返回登录成功的握手应答消息。
3）链路建立成功后，client发送业务消息。
4）链路成功后，server发送心跳消息。
5)链路建立成功之后，client发送心跳消息。
6）链路建立成功后，server发送业务消息。
7）server退出后，server关闭连接，client感知对方关闭连接后，被动关闭连接。
注意：双方采用全双工的通信方式，并不区分server与client。双方之间采用ping-pong心跳机制。链路断开client主动关闭连接，间隔T周期发起重连，直至成功。
消息定义：消息头，消息体。
链路的建立：创建握手请求消息，同时server基于IP地址进行黑白名单安全认证机制，或者通过密钥+数字证书进行接入认证。
链路的关闭：双方通过心跳和业务消息维持链路的长连接，任何一方都不需要主动关闭连接，但是以下情况需要关闭连接，
1）对方宕机或重启。
2）消息读写发生IO异常。
3）心跳发生IO异常或者超市。
4）发生编码异常等不可恢复。
心跳机制（ping-pong）：在网络空闲时采用心跳机制检验链路的互通性，一旦发现网络故障，立即关闭链路，主动连接。
1）当网络处于空闲状态，连续T周期没有读写，则client主动发送ping心跳消息给服务端。
2）如果在下个周期T到来时client没有收到对方发送的Pong心跳应答消息或者读取到服务端发送的其他业务消息，则心跳计数器+1.
3）一旦收到业务消息或者Pong消息，则心跳计数器=0，N次没有收到服务端应答，则关闭链路，间隔INTERVAL时间后发起重连。
4）server网络空闲状态时间T后，心跳失败计数器+1，N次没有接受到client请求则关闭链路等待client重连，一旦接受到ping或业务消息，计数器清零。
注意：通过Ping-Pong双向心跳机制，保证无论哪一方出现问题，都被及时检测出来。N次检测防止对方短时间繁忙没有及时应答而造成的误判。
重连机制： 间隔INTERVAL时间不断重连，保证服务端有足够的时间释放句柄资源，再发起重新连接，直至成功。
重复登录保护：在缓存地址表中查看client是否已经登录，如果已经登录，则拒绝重复登录，返回错误码-1，并关闭链路。如心跳失败同时也清空该client的地址缓存表信息。
消息缓存重发：链路中断后，待发送的消息缓存在消息队列不能丢失，等恢复链路后消息重新发送，同时设置队列上线，防止OOM，超过上限聚集添加新的消息。
安全性：IP黑白名单，SSL/TSL会话。
私有栈协议开发
数据结构定义：
package com.netty.ch12.msg; import java.util.HashMap; import java.util.Map; public class Header { private int crcCode = 0xabef0101; private int length ;//消息长度 private long sessionID;//会话ID private byte type;//消息类型 private byte priority;//消息优先级 private Map<String,Object> attachment = new HashMap<String,Object>();//附件 同时便于扩展 /** * @return the crcCode */ public int getCrcCode() { return crcCode; } /** * @param crcCode the crcCode to set */ public void setCrcCode(int crcCode) { this.crcCode = crcCode; } /** * @return the length */ public int getLength() { return length; } /** * @param length the length to set */ public void setLength(int length) { this.length = length; } /** * @return the sessionID */ public long getSessionID() { return sessionID; } /** * @param sessionID the sessionID to set */ public void setSessionID(long sessionID) { this.sessionID = sessionID; } /** * @return the type */ public byte getType() { return type; } /** * @param type the type to set */ public void setType(byte type) { this.type = type; } /** * @return the priority */ public byte getPriority() { return priority; } /** * @param priority the priority to set */ public void setPriority(byte priority) { this.priority = priority; } /** * @return the attachment */ public Map<String, Object> getAttachment() { return attachment; } /** * @param attachment the attachment to set */ public void setAttachment(Map<String, Object> attachment) { this.attachment = attachment; } /* (non-Javadoc) * @see java.lang.Object#toString() */ @Override public String toString() { return "Header [crcCode=" + crcCode + ", length=" + length + ", sessionID=" + sessionID + ", type=" + type + ", priority=" + priority + ", attachment=" + attachment + "]"; } }
package com.netty.ch12.msg; /** * 对netty协议栈使用到的数据结构进行定义 * @author Administrator * */ public final class NettyMessage { private Header header; //消息头 private Object body;//消息体 /** * @return the header */ public final Header getHeader() { return header; } /** * @param header the header to set */ public final void setHeader(Header header) { this.header = header; } /** * @return the body */ public final Object getBody() { return body; } /** * @param body the body to set */ public final void setBody(Object body) { this.body = body; } /* (non-Javadoc) * @see java.lang.Object#toString() */ @Override public String toString() { return "NettyMessage [header=" + header + ", body=" + body + "]"; } }
Netty消息编码工具类：
package com.netty.ch12.util; import io.netty.buffer.ByteBuf; import io.netty.channel.ChannelHandlerContext; import io.netty.handler.codec.marshalling.MarshallingDecoder; import io.netty.handler.codec.marshalling.UnmarshallerProvider; public class NettyMarshallingDecoder extends MarshallingDecoder{ public NettyMarshallingDecoder(UnmarshallerProvider provider) { super(provider); } public NettyMarshallingDecoder(UnmarshallerProvider provider, int maxObjectSize){ super(provider, maxObjectSize); } public Object decode(ChannelHandlerContext ctx, ByteBuf in) throws Exception { return super.decode(ctx, in); } }
package com.netty.ch12.util; import io.netty.buffer.ByteBuf; import io.netty.channel.ChannelHandlerContext; import io.netty.handler.codec.marshalling.MarshallerProvider; import io.netty.handler.codec.marshalling.MarshallingDecoder; import io.netty.handler.codec.marshalling.MarshallingEncoder; import io.netty.handler.codec.marshalling.UnmarshallerProvider; public class NettyMarshallingEncoder extends MarshallingEncoder{ public NettyMarshallingEncoder(MarshallerProvider provider) { super(provider); } public void encode(ChannelHandlerContext ctx, Object msg, ByteBuf out) throws Exception{ super.encode(ctx, msg, out); } }
package com.netty.ch12.util; import io.netty.handler.codec.marshalling.DefaultMarshallerProvider; import io.netty.handler.codec.marshalling.DefaultUnmarshallerProvider; import io.netty.handler.codec.marshalling.MarshallerProvider; import io.netty.handler.codec.marshalling.MarshallingDecoder; import io.netty.handler.codec.marshalling.UnmarshallerProvider; import org.jboss.marshalling.MarshallerFactory; import org.jboss.marshalling.Marshalling; import org.jboss.marshalling.MarshallingConfiguration; public class MarshallingCodeCFactory { public static NettyMarshallingDecoder buildMarshallingDecoder(){ MarshallerFactory marshallerFactory = Marshalling.getProvidedMarshallerFactory("serial"); MarshallingConfiguration configuration = new MarshallingConfiguration(); configuration.setVersion(5); UnmarshallerProvider provider = new DefaultUnmarshallerProvider(marshallerFactory, configuration); NettyMarshallingDecoder decoder = new NettyMarshallingDecoder(provider, 1024); return decoder; } public static NettyMarshallingEncoder buildMarshallingEncoder(){ MarshallerFactory marshallerFactory = Marshalling.getProvidedMarshallerFactory("serial"); MarshallingConfiguration configuration = new MarshallingConfiguration(); configuration.setVersion(5); MarshallerProvider provider = new DefaultMarshallerProvider(marshallerFactory, configuration); NettyMarshallingEncoder encoder = new NettyMarshallingEncoder(provider); return encoder; } }
消息编解码：
package com.netty.ch12.handler; import java.io.IOException; import java.util.List; import java.util.Map; import com.netty.ch12.msg.NettyMessage; import com.netty.ch12.util.MarshallingCodeCFactory; import com.netty.ch12.util.NettyMarshallingEncoder; import io.netty.buffer.ByteBuf; import io.netty.buffer.Unpooled; import io.netty.channel.ChannelHandlerContext; import io.netty.handler.codec.MessageToMessageEncoder; /** * nettty 消息编码类 * @author Administrator * */ public class NettyMessageEncoder extends MessageToMessageEncoder<NettyMessage> { private NettyMarshallingEncoder marshallingEncoder; public NettyMessageEncoder(){ marshallingEncoder = MarshallingCodeCFactory.buildMarshallingEncoder(); } @Override protected void encode(ChannelHandlerContext ctx, NettyMessage msg, List<Object> out) throws Exception { if(msg == null || msg.getHeader() == null) throw new Exception("The encode message is null"); ByteBuf sendBuf = Unpooled.buffer(); sendBuf.writeInt(msg.getHeader().getCrcCode()); sendBuf.writeInt(msg.getHeader().getLength()); sendBuf.writeLong(msg.getHeader().getSessionID()); sendBuf.writeByte(msg.getHeader().getType()); sendBuf.writeByte(msg.getHeader().getPriority()); sendBuf.writeInt(msg.getHeader().getAttachment().size()); String key = null; byte[] keyArray = null; Object value = null; for(Map.Entry<String, Object> param : msg.getHeader().getAttachment().entrySet()){ key = param.getKey(); keyArray = key.getBytes("utf-8"); sendBuf.writeInt(keyArray.length); sendBuf.writeBytes(keyArray); value = param.getValue(); marshallingEncoder.encode(ctx,value, sendBuf); } key = null; keyArray = null; value = null; if(msg.getBody() != null){ marshallingEncoder.encode(ctx,msg.getBody(), sendBuf); }//else //sendBuf.writeInt(0); // 在第4个字节处写入Buffer的长度 sendBuf.setInt(4, sendBuf.readableBytes()); // 把Message添加到List传递到下一个Handler out.add(sendBuf); } }
package com.netty.ch12.handler; import io.netty.buffer.ByteBuf; import io.netty.channel.ChannelHandlerContext; import io.netty.handler.codec.LengthFieldBasedFrameDecoder; import java.util.HashMap; import java.util.Map; import com.netty.ch12.msg.Header; import com.netty.ch12.msg.NettyMessage; import com.netty.ch12.util.MarshallingCodeCFactory; import com.netty.ch12.util.NettyMarshallingDecoder; /** * netty 消息解码类 * @author Administrator * */ public class NettyMessageDecoder extends LengthFieldBasedFrameDecoder{ private NettyMarshallingDecoder marshallingDecoder; public NettyMessageDecoder(int maxFrameLength, int lengthFieldOffset, int lengthFieldLength) { super(maxFrameLength, lengthFieldOffset, lengthFieldLength); marshallingDecoder = MarshallingCodeCFactory.buildMarshallingDecoder(); } public NettyMessageDecoder(int maxFrameLength, int lengthFieldOffset, int lengthFieldLength,int lengthAdjustment, int initialBytesToStrip) { super(maxFrameLength, lengthFieldOffset, lengthFieldLength,lengthAdjustment, initialBytesToStrip); marshallingDecoder = MarshallingCodeCFactory.buildMarshallingDecoder(); } public Object decode(ChannelHandlerContext ctx, ByteBuf in) throws Exception{ ByteBuf frame = (ByteBuf)super.decode(ctx, in); //为空说明是半包消息，直接返回由i/o线程读取后续的码流 if(frame == null){ return null; } NettyMessage message = new NettyMessage(); Header header = new Header(); header.setCrcCode(frame.readInt()); header.setLength(frame.readInt()); header.setSessionID(frame.readLong()); header.setType(frame.readByte()); header.setPriority(frame.readByte()); int size = frame.readInt(); if(size > 0){ Map<String, Object> attach = new HashMap<String, Object>(size); int keySize = 0; byte[] keyArray = null; String key = null; for(int i=0; i<size; i++){ keySize = frame.readInt(); keyArray = new byte[keySize]; in.readBytes(keyArray); key = new String(keyArray, "UTF-8"); attach.put(key, marshallingDecoder.decode(ctx, frame)); } key = null; keyArray = null; header.setAttachment(attach); } if(frame.readableBytes() > 0){ message.setBody(marshallingDecoder.decode(ctx, frame)); } message.setHeader(header); return message; } }
common类
package com.netty.ch12.comon; public enum MessageType { LOGIN_REQ{ public byte value(){ return (byte)1; } },LOGIN_RESP{ public byte value(){ return (byte)2; } },HEARTBEAT_REQ{ @Override public byte value() { // TODO Auto-generated method stub return (byte)3; } },HEARTBEAT_RESP{ @Override public byte value() { // TODO Auto-generated method stub return (byte)4; } }; public abstract byte value(); }
package com.netty.ch12.comon; public class NettyConstant { public static final String LOCALIP = "127.0.0.1"; public static final String REMOTEIP = "127.0.0.1"; public static final int LOCAL_PORT = 12088; public static final int PORT = 8080; }
握手和安全认证：
握手的发起是在客户端和服务端TCP链路建立成功通道激活时，握手消息的接入和安全认证在服务端处理。
package com.netty.ch12.handler; import com.netty.ch12.comon.MessageType; import com.netty.ch12.msg.Header; import com.netty.ch12.msg.NettyMessage; import io.netty.channel.ChannelHandlerAdapter; import io.netty.channel.ChannelHandlerContext; public class LoginAuthReqHandler extends ChannelHandlerAdapter { public void channelActive(ChannelHandlerContext ctx) throws Exception { ctx.writeAndFlush(buildLoginReq()); } public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception { NettyMessage message = (NettyMessage) msg; if (message.getHeader() != null && message.getHeader().getType() == MessageType.LOGIN_RESP.value()) { System.out.println("Received from server response"); byte loginResult = (byte) message.getBody(); if (loginResult != (byte) 0) { // 握手失败 关闭连接 ctx.close(); } else { System.out.println("Login is ok :" + message); ctx.fireChannelRead(msg); } } else { ctx.fireChannelRead(msg); } } private NettyMessage buildLoginReq() { NettyMessage message = new NettyMessage(); Header header = new Header(); header.setType(MessageType.LOGIN_REQ.value()); message.setHeader(header); message.setBody("It is request"); return message; } public void channelReadComplete(ChannelHandlerContext ctx) throws Exception { ctx.flush(); } public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) { ctx.close(); } }
package com.netty.ch12.handler; import java.net.InetSocketAddress; import java.util.Map; import java.util.concurrent.ConcurrentHashMap; import com.netty.ch12.comon.MessageType; import com.netty.ch12.msg.Header; import com.netty.ch12.msg.NettyMessage; import io.netty.channel.ChannelHandlerAdapter; import io.netty.channel.ChannelHandlerContext; public class LoginAuthRespHandler extends ChannelHandlerAdapter { //地址缓存 private Map<String,Boolean> nodeCheck = new ConcurrentHashMap<String,Boolean>(); private String[] whiteList = {"127.0.0.1","192.168.1.104"}; public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception { NettyMessage message = (NettyMessage)msg; //如果是握手请求消息则处理 其他消息透传 if(message.getHeader() != null && message.getHeader().getType() == MessageType.LOGIN_REQ.value()){ String nodeIndex = ctx.channel().remoteAddress().toString(); NettyMessage loginResp = null; //重复登录 拒绝 if(nodeCheck.containsKey(nodeIndex)){ loginResp = buildLoginResponse((byte)-1); }else{ InetSocketAddress address = (InetSocketAddress) ctx.channel().remoteAddress(); String ip = address.getAddress().getHostAddress(); System.out.println("获取client连接："+ip); boolean isOk = false; for(String WIP : whiteList){ if(WIP.equals(ip)){ isOk = true; break; } } loginResp = isOk ? buildLoginResponse((byte)0) : buildLoginResponse((byte)-1); if(isOk){ nodeCheck.put(nodeIndex, true); } System.out.println("The login response is :" + loginResp + "body [" + loginResp.getBody() + "]"); ctx.writeAndFlush(loginResp); } }else{ ctx.fireChannelRead(msg); } } private NettyMessage buildLoginResponse(byte result) { NettyMessage message = new NettyMessage(); Header header = new Header(); header.setType(MessageType.LOGIN_RESP.value()); message.setHeader(header); message.setBody(result); return message; } public void channelReadComplete(ChannelHandlerContext ctx) throws Exception { ctx.flush(); } public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) { nodeCheck.remove(ctx.channel().remoteAddress().toString());//删除缓存 ctx.close(); ctx.fireExceptionCaught(cause); } }
心跳检测机制
package com.netty.ch12.handler; import java.util.concurrent.TimeUnit; import com.netty.ch12.comon.MessageType; import com.netty.ch12.msg.Header; import com.netty.ch12.msg.NettyMessage; import io.netty.channel.ChannelHandlerAdapter; import io.netty.channel.ChannelHandlerContext; import io.netty.util.concurrent.ScheduledFuture; public class HeartBeatReqHandler extends ChannelHandlerAdapter{ private volatile ScheduledFuture<?> heartBeat; /* (non-Javadoc) * @see io.netty.channel.ChannelHandlerAdapter#channelRead(io.netty.channel.ChannelHandlerContext, java.lang.Object) */ @Override public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception { // TODO Auto-generated method stub NettyMessage message = (NettyMessage) msg; //握手成功（如果握手不成功，则已经关闭连接，不会执行至此） 主动发送心跳消息 if(message.getHeader() != null && message.getHeader().getType() == MessageType.LOGIN_RESP.value()){ heartBeat = ctx.executor().scheduleAtFixedRate(new HeartBeatTask(ctx), 0, 5000, TimeUnit.MILLISECONDS); }else if(message.getHeader().getType() == MessageType.HEARTBEAT_RESP.value()){ System.out.println("Client receive server heart beat message : -- >" + message); }else{ ctx.fireChannelRead(msg); } } //心跳探测 private class HeartBeatTask implements Runnable{ private final ChannelHandlerContext ctx; public HeartBeatTask(final ChannelHandlerContext ctx){ this.ctx = ctx; } @Override public void run() { NettyMessage heatBeat = buildHeatBeat(); System.out.println("client send heart beat message to server : --> " + heartBeat); ctx.writeAndFlush(heatBeat); } private NettyMessage buildHeatBeat(){ NettyMessage message = new NettyMessage(); Header header = new Header(); header.setType(MessageType.HEARTBEAT_REQ.value()); message.setHeader(header); return message; } } @Override public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception { // TODO Auto-generated method stub if(heartBeat != null){ heartBeat.cancel(true); heartBeat = null; } ctx.fireExceptionCaught(cause); } }
package com.netty.ch12.handler; import com.netty.ch12.comon.MessageType; import com.netty.ch12.msg.Header; import com.netty.ch12.msg.NettyMessage; import io.netty.channel.ChannelHandlerAdapter; import io.netty.channel.ChannelHandlerContext; public class HeartBeatRespHandler extends ChannelHandlerAdapter{ @Override public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception { NettyMessage message = (NettyMessage) msg; //返回心跳应答消息 if(message.getHeader() != null && message.getHeader().getType() == MessageType.HEARTBEAT_REQ.value()){ System.out.println("Receive client heart beat message : ---> " + message); NettyMessage heartBeat = buildHeatBeat(); System.out.println("Send heart beat response message to client : --->" +heartBeat); ctx.writeAndFlush(heartBeat); }else{ ctx.fireChannelRead(message); } } private NettyMessage buildHeatBeat(){ NettyMessage message = new NettyMessage(); Header header = new Header(); header.setType(MessageType.HEARTBEAT_RESP.value()); message.setHeader(header); return message; } }
客户端
package com.netty.ch12; import java.net.InetSocketAddress; import java.util.concurrent.Executor; import java.util.concurrent.Executors; import java.util.concurrent.ScheduledExecutorService; import java.util.concurrent.TimeUnit; import com.netty.ch12.comon.NettyConstant; import com.netty.ch12.handler.HeartBeatReqHandler; import com.netty.ch12.handler.LoginAuthReqHandler; import com.netty.ch12.handler.NettyMessageDecoder; import com.netty.ch12.handler.NettyMessageEncoder; import io.netty.bootstrap.Bootstrap; 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.NioSocketChannel; import io.netty.handler.timeout.ReadTimeoutHandler; /** * 客户端主要用于初始化系统资源，根据配置信息发起连接 * @author Administrator * */ public class NettyClient { private ScheduledExecutorService executor = Executors.newScheduledThreadPool(1); EventLoopGroup group = new NioEventLoopGroup(); public void connect(int port ,String host) throws Exception{ try{ Bootstrap b = new Bootstrap(); b.group(group).channel(NioSocketChannel.class) .option(ChannelOption.TCP_NODELAY, true) .handler(new ChannelInitializer<SocketChannel>() { @Override protected void initChannel(SocketChannel ch) throws Exception { ch.pipeline().addLast(new NettyMessageDecoder(1024 * 1024, 4, 4, -8, 0)); ch.pipeline().addLast("MessageEncoder",new NettyMessageEncoder()); //心跳超时的实现非常简单，利用ReadTimeoutHandler机制，当一定周期内（50s）没有读取到对方任何消息，需要主动关闭连接。 //如果是client，发起重新连接，如果是server，释放资源，清除客户端登录缓存信息，等待服务端重连。 ch.pipeline().addLast("readTimeoutHandler",new ReadTimeoutHandler(50)); ch.pipeline().addLast("LoginAuthHandler",new LoginAuthReqHandler()); ch.pipeline().addLast("HeartBeatHandler",new HeartBeatReqHandler()); } }); //发起异步连接操作 ChannelFuture future = b.connect(new InetSocketAddress(host,port) ,new InetSocketAddress(NettyConstant.LOCALIP ,NettyConstant.LOCAL_PORT)); System.out.println("client to server "+host+":"+port); future.channel().closeFuture().sync(); }catch(Exception e){ e.printStackTrace(); }finally{ //所有资源释放完成之后，清空资源，再次发起重新连接 executor.execute(new Runnable(){ @Override public void run() { try { //等待5s TimeUnit.SECONDS.sleep(5); //发起重新连接 connect(NettyConstant.PORT, NettyConstant.REMOTEIP); } catch (Exception e) { e.printStackTrace(); } } }); } } public static void main(String[] args) throws Exception{ new NettyClient().connect(NettyConstant.PORT, NettyConstant.REMOTEIP); } }
服务端
package com.netty.ch12; import com.netty.ch12.comon.NettyConstant; import com.netty.ch12.handler.HeartBeatRespHandler; import com.netty.ch12.handler.LoginAuthReqHandler; import com.netty.ch12.handler.LoginAuthRespHandler; import com.netty.ch12.handler.NettyMessageDecoder; import com.netty.ch12.handler.NettyMessageEncoder; import io.netty.bootstrap.ServerBootstrap; import io.netty.channel.ChannelFuture; import io.netty.channel.ChannelInitializer; import io.netty.channel.ChannelOption; import io.netty.channel.nio.NioEventLoopGroup; import io.netty.channel.socket.SocketChannel; import io.netty.channel.socket.nio.NioServerSocketChannel; import io.netty.handler.logging.LogLevel; import io.netty.handler.logging.LoggingHandler; import io.netty.handler.timeout.ReadTimeoutHandler; /** * 服务端 ： 主要的工作就是握手的接入认证 不关心断连重连的问题 * @author Administrator * netstat -ano|findstr "8080" */ public class NettyServer { public void bind() throws Exception{ //配置服务端的NIO线程组 NioEventLoopGroup bossGroup = new NioEventLoopGroup(); NioEventLoopGroup workerGroup = new NioEventLoopGroup(); ServerBootstrap b = new ServerBootstrap(); b.group(bossGroup,workerGroup) .channel(NioServerSocketChannel.class) .option(ChannelOption.SO_BACKLOG, 100) .handler(new LoggingHandler(LogLevel.INFO)) .childHandler(new ChannelInitializer<SocketChannel>() { @Override protected void initChannel(SocketChannel ch) throws Exception { ch.pipeline().addLast(new NettyMessageDecoder(1024 * 1024, 4, 4, -8, 0)); ch.pipeline().addLast(new NettyMessageEncoder()); //当一定周期内没有读取对方任何消息 则主动关闭链路 ch.pipeline().addLast("readTimeoutHandler",new ReadTimeoutHandler(50)); ch.pipeline().addLast(new LoginAuthRespHandler()); ch.pipeline().addLast("HeartBeatHandler",new HeartBeatRespHandler()); } }); ChannelFuture f = b.bind(NettyConstant.REMOTEIP,NettyConstant.PORT).sync(); System.out.println("Netty server start ok : " +(NettyConstant.REMOTEIP + ":" + NettyConstant.PORT)); f.channel().closeFuture().sync(); } public static void main(String[] args) throws Exception { new NettyServer().bind(); } }
