专栏首页老付的网络博客Netty01--- Netty实现简单通信

Netty01--- Netty实现简单通信

这个Demo的功能是客户端向服务端发送一个Hello Netty的消息,然后服务端又把消息返回给客户端

Server端

这些都是一些公共的代码,代码比较简单,服务端负责监听端口,Handler负责处理业务逻辑

public class ServerProcessor {
     public void process(){
          EventLoopGroup bossGroup = new NioEventLoopGroup();
          EventLoopGroup workGroup = new NioEventLoopGroup();
          ServerBootstrap bootStrap = new ServerBootstrap();
          ChannelFuture cf;
          bootStrap.group(bossGroup,workGroup)
                    .channel(NioServerSocketChannel.class)
                    .option(ChannelOption.SO_BACKLOG, 1024)
                    .childHandler(new ChannelInitializer<SocketChannel>() {
                         @Override
                         public void initChannel(SocketChannel ch) throws Exception {
                              ChannelPipeline p = ch.pipeline();
                              p.addLast(new ServerMessageHandler());//server的handler
                         }
                    });

          try {
               cf =  bootStrap.bind(8099).sync();//监听8099端口
               System.out.println("8099:binded...");
               cf.channel().closeFuture().sync();
          } catch (InterruptedException e) {
               e.printStackTrace();
          }finally{
               bossGroup.shutdownGracefully();
               workGroup.shutdownGracefully();
          }
     }

     public static void main(String[] args) {
          ServerProcessor serverProcessor = new ServerProcessor();
          serverProcessor.process();
     }
}
@ChannelHandler.Sharable
public class ServerMessageHandler extends ChannelInboundHandlerAdapter {

     @Override
     public void channelRegistered(ChannelHandlerContext ctx) throws Exception {
          System.out.println("服务已启动,等待客户连接");
     }

     
     //接收客户端发送的消息
     @Override
     public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
          ByteBuf in = (ByteBuf)msg;/*netty实现的缓冲区*/
          System.out.println("Server Accept:"+in.toString(CharsetUtil.UTF_8));
          ctx.write(in);
     }

     @Override
     public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
          ctx.writeAndFlush(Unpooled.EMPTY_BUFFER)/*flush掉所有的数据*/
                    .addListener(ChannelFutureListener.CLOSE);/*当flush完成后,关闭连接*/
     }
}

Client端

public class ClientProcessor {

     public void process() {
          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
                         public void initChannel(SocketChannel ch) throws Exception {
                              ChannelPipeline p = ch.pipeline();
                              p.addLast(new ClientMessageHandler());

                         }
                         });

               ChannelFuture future = b.connect("127.0.0.1", 8099).sync();//连接端口

               future.channel().closeFuture().sync();
          } catch (InterruptedException e) {
               e.printStackTrace();
          } finally {
               group.shutdownGracefully();
          }

     }

     public static void main(String[] args) {
          ClientProcessor clientProcessor = new ClientProcessor();
          clientProcessor.process();
     }
}
public class ClientMessageHandler extends SimpleChannelInboundHandler<ByteBuf> {

     @Override
     public void channelActive(ChannelHandlerContext ctx) throws Exception {
          ctx.channel().writeAndFlush(Unpooled.copiedBuffer("Hello Netty", CharsetUtil.UTF_8));
          ctx.fireChannelActive();
     }


     @Override
     protected void channelRead0(ChannelHandlerContext channelHandlerContext, ByteBuf byteBuf) throws Exception {
          System.out.println("NettyClient accetp:" + byteBuf.toString(CharsetUtil.UTF_8));
     }

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

}

(本文完)

作者:付威 博客地址:http://blog.laofu.online 如有任何知识产权、版权问题或理论错误,还请指正。 本文是付威的网络博客原创,自由转载-非商用-非衍生-保持署名,请遵循:创意共享3.0许可证

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

我来说两句

0 条评论
登录 后参与评论

相关文章

  • 手写Java类解析器-01.class文件的基本结构

    这个系列的文章是为了探讨Java字节码是什么样的结构,如何能够准确的表达我们代码的含义。

    付威
  • 设计模式---05.访问者模式

    访问者模式是一种对象和对象的访问者分开的一种设计模式,在一个对象稳定的情况下,使用访问者模式可以更好的扩展对数据的访问。 相当于是我们在对象里面安插了一个“眼...

    付威
  • js如何操作本地程序

    假设有这样一个产品,一个web和一个winform客户端,在客户在web的网页上面点击启动客户端来处理,这个时候开始调用本地的客户端,来完成指定的工作。这种场景...

    付威
  • Netty自动重连机制的Demo

    官方案例地址:https://netty.io/4.1/xref/io/netty/example/uptime/package-summary.html

    Java猫说
  • netty案例,netty4.1基础入门篇零《初入JavaIO之门BIO、NIO、AIO实战练习》

    在Java中,提供了一些关于使用IO的API,可以供开发者来读写外部数据和文件,我们称这些API为Java IO。IO是Java中比较重要知识点,且比较难学习的...

    小傅哥
  • Netty入门学习系列--helloworld服务端(一)

    public class NettyServerHandle extends ChannelInboundHandlerAdapter {

    用户1257393
  • Android :RxJava2.0到底更新了什么?(含使用建议)

    在`RxJava 2.0 `中,创建被观察者(`Observable`) & 观察者(Observer)的方式也与`RxJava 1.0 `有些区别:

    Carson.Ho
  • Spring框架中的设计模式(二)

    在 上一篇 中我们在Spring中所谈到的设计模式涉及到了创建模式三剑客和1个行为模式(解释器模式)。这次我们会将眼光更多地关注在具有结构性和行为性的设计模式上...

    程序猿DD
  • Android技能树 — Rxjava取消订阅小结(1):自带方式

    现在很多项目都在使用Rxjava了,对于RxJava的使用,估计都很熟悉了,但是很多人在使用RxJava的时候容易产生内存泄漏问题,比如我们在用RxJava配合...

    青蛙要fly
  • 检查app的activity是否在当前

    APP开发中经常会遇到这种需求,需要检查当前的APP是不是可见的,比如,如果是可见的就维持一个socket长连接,如果切到后台不可见了,就断开这个连接。And...

    xiangzhihong

扫码关注云+社区

领取腾讯云代金券