Netty实践：ChannelInboundHandlerAdapter与ChannelOutboundHandlerAdapter

最新推荐文章于 2024-03-02 19:34:43 发布
最新推荐文章于 2024-03-02 19:34:43 发布
阅读量945 收藏 1
点赞数
文章标签： netty java c/c++
原文链接：http://www.cnblogs.com/use-D/p/7087626.html
版权 
package netty.test1;

import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelHandler;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import io.netty.util.CharsetUtil;
import io.netty.util.concurrent.Future;
import io.netty.util.concurrent.GenericFutureListener;
import org.jboss.netty.channel.ChannelFutureListener;

import java.util.concurrent.ScheduledExecutorService;


/**
 * Created by Administrator on 2017/5/17.
 */
@ChannelHandler.Sharable
public class EchoServerHandler extends ChannelInboundHandlerAdapter {


    public void channelRegistered(ChannelHandlerContext ctx) throws Exception {
        System.out.println("注册事件");
    }

    public void channelUnregistered(ChannelHandlerContext ctx) throws Exception {
        System.out.println("取消注册事件");
    }

    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        System.out.println("有新客户端连接接入。。。"+ctx.channel().remoteAddress());
    }

    public void channelInactive(ChannelHandlerContext ctx) throws Exception {
        System.out.println("失去连接");
    }

    public void channelRead(ChannelHandlerContext ctx, Object msg) {
        ByteBuf in = (ByteBuf) msg;
        System.out.println("读客户端传入数据="+in.toString(CharsetUtil.UTF_8));
        ctx.writeAndFlush(Unpooled.copiedBuffer("channelRead Netty rocks!", CharsetUtil.UTF_8));
        //ctx.fireChannelActive();
    }

    public void channelReadComplete(ChannelHandlerContext ctx){
        ctx.writeAndFlush(Unpooled.EMPTY_BUFFER).addListener(new GenericFutureListener<Future<? super Void>>() {
            @Override
            public void operationComplete(Future<? super Void> future) throws Exception {
                if (future.isSuccess()) {
                    System.out.println("执行成功="+future.isSuccess());
                }
            }
        });
        ctx.writeAndFlush(Unpooled.copiedBuffer("channelReadComplete Netty rocks!", CharsetUtil.UTF_8)).addListener(new GenericFutureListener<Future<? super Void>>() {
            @Override
            public void operationComplete(Future<? super Void> future) throws Exception {
                if (future.isSuccess())  {

                }else {

                }
            }
        });
    }

    public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {
        System.out.println("userEventTriggered");
    }

    public void channelWritabilityChanged(ChannelHandlerContext ctx) throws Exception {
        System.out.println("channelWritabilityChanged");
    }

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

 

package netty.test1;

import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelHandler;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import io.netty.util.CharsetUtil;
import io.netty.util.ReferenceCountUtil;
import io.netty.util.ReferenceCounted;
import io.netty.util.concurrent.Future;
import io.netty.util.concurrent.GenericFutureListener;


/**
 * Created by Administrator on 2017/5/17.
 */
@ChannelHandler.Sharable
public class EchoOtherServerHandler extends ChannelInboundHandlerAdapter {


    public void channelRegistered(ChannelHandlerContext ctx) throws Exception {
        System.out.println("Other注册事件");
        ctx.fireChannelRegistered();
    }

    public void channelUnregistered(ChannelHandlerContext ctx) throws Exception {
        System.out.println("Other取消注册事件");
        ctx.fireChannelUnregistered();
    }

    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        System.out.println("Other有新客户端连接接入。。。"+ctx.channel().remoteAddress());
        ctx.fireChannelActive();
    }

    public void channelInactive(ChannelHandlerContext ctx) throws Exception {
        System.out.println("Other失去连接");
        ctx.fireChannelInactive();
    }

    public void channelRead(ChannelHandlerContext ctx, Object msg) {
        ByteBuf in = (ByteBuf) msg;
        System.out.println("Other读客户端传入数据="+in.toString(CharsetUtil.UTF_8));
        final ByteBuf byteBuf = Unpooled.copiedBuffer("Other channelRead Netty rocks!", CharsetUtil.UTF_8);
        ctx.writeAndFlush(byteBuf);
        ctx.fireChannelRead(msg);
        //ReferenceCountUtil.release(msg);
    }

    public void channelReadComplete(ChannelHandlerContext ctx){
        ctx.writeAndFlush(Unpooled.EMPTY_BUFFER).addListener(new GenericFutureListener<Future<? super Void>>() {
            @Override
            public void operationComplete(Future<? super Void> future) throws Exception {
                if (future.isSuccess()) {
                    System.out.println("Other执行成功="+future.isSuccess());
                }
            }
        });
        final ByteBuf byteBuf = Unpooled.copiedBuffer("Other channelReadComplete Netty rocks!", CharsetUtil.UTF_8);
        ctx.writeAndFlush(byteBuf).addListener(new GenericFutureListener<Future<? super Void>>() {
            @Override
            public void operationComplete(Future<? super Void> future) throws Exception {
                if (future.isSuccess())  {
                }else {

                }
                ReferenceCountUtil.release(byteBuf);
            }
        });
        ctx.fireChannelReadComplete();
    }

    public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {
        System.out.println("Other  userEventTriggered");
    }

    public void channelWritabilityChanged(ChannelHandlerContext ctx) throws Exception {
        System.out.println("Other  channelWritabilityChanged");
    }

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

 

package netty.test1;

import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelOutboundHandler;
import io.netty.channel.ChannelOutboundHandlerAdapter;
import io.netty.channel.ChannelPromise;

import java.nio.charset.Charset;

/**
 * Created by Administrator on 2017/6/8.
 */
public class EchoServerOutHandler extends ChannelOutboundHandlerAdapter {

    public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) throws Exception {
        System.out.println("EchoServerOutHandler   write "+((ByteBuf)msg).toString(Charset.defaultCharset()));
        ctx.write(msg, promise);
    }
}

 

package netty.test1;

import io.netty.bootstrap.ServerBootstrap;
import io.netty.buffer.ByteBufAllocator;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;

import java.net.InetSocketAddress;

/**
 * Created by Administrator on 2017/5/17.
 */
public class EchoServer {

    private final  int port;

    public EchoServer(int port) {
        this.port = port;
    }

    public static void main(String[] args) throws InterruptedException {
        int port = 8080;
        ByteBufAllocator allocator;

        new EchoServer(port).start();
    }

    public void start() throws InterruptedException {
        final EchoServerHandler echoServerHandler = new EchoServerHandler();
        final EchoOtherServerHandler echoOtherServerHandler = new EchoOtherServerHandler();
        final EchoServerOutHandler echoServerOutHandler = new EchoServerOutHandler();
        EventLoopGroup eventLoopGroup = new NioEventLoopGroup();
        try {
            ServerBootstrap serverBootstrap = new ServerBootstrap();
            serverBootstrap.group(eventLoopGroup).
                    channel(NioServerSocketChannel.class).//指定channel使用Nio传输
                    localAddress(new InetSocketAddress(port)).//执行端口设置套接字地址
                    childHandler(new ChannelInitializer<SocketChannel>() {//添加echoServerHandler到Channel的channelpipeline上
                        @Override
                        protected void initChannel(SocketChannel socketChannel) throws Exception {
                            ChannelPipeline channelPipeline = socketChannel.pipeline();
                            channelPipeline.addFirst(echoOtherServerHandler);
                            channelPipeline.addFirst(echoServerOutHandler);
                            channelPipeline.addLast(echoServerHandler);
                        }
                    });
            ChannelFuture f = serverBootstrap.bind().sync();//异步绑定服务器，调用sync()方法阻塞等待直到绑定完成
            f.channel().closeFuture().sync();//获得Channel的closefutrue，并且阻塞当前线程直到它完成
        } catch (InterruptedException e) {
            eventLoopGroup.shutdownGracefully().sync();
        }
    }
}

 

package netty.test1;

import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelHandler;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import io.netty.channel.SimpleChannelInboundHandler;
import io.netty.util.CharsetUtil;
import io.netty.util.concurrent.Future;
import io.netty.util.concurrent.GenericFutureListener;
import org.jboss.netty.channel.ChannelFutureListener;


/**
 * Created by Administrator on 2017/5/17.
 */
@ChannelHandler.Sharable
public class EchoClientHandler extends SimpleChannelInboundHandler<ByteBuf> {

    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        ctx.writeAndFlush(Unpooled.copiedBuffer("Netty rocks!", CharsetUtil.UTF_8));
    }

    public void channelRead0(ChannelHandlerContext ctx, ByteBuf msg) {
        ByteBuf in = msg;
        System.out.println("读取服务端channelRead0="+in.toString(CharsetUtil.UTF_8));
    }

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

 

package netty.test1;

import io.netty.bootstrap.Bootstrap;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.oio.OioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioSocketChannel;
import io.netty.channel.socket.oio.OioSocketChannel;
import io.netty.util.concurrent.Future;
import io.netty.util.concurrent.GenericFutureListener;

import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.charset.Charset;

/**
 * Created by Administrator on 2017/5/17.
 */
public class EchoClient {

    private final  int port;

    public EchoClient(int port) {
        this.port = port;
    }

    public static void main(String[] argsw) {
        ByteBuffer byteBuffer;
        String host = "127.0.0.1";
        int port = 8080;
        try {
            new EchoClient(8080).start();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public void start() throws Exception {
        final EchoClientHandler clientHandler = new EchoClientHandler();
        EventLoopGroup eventLoopGroup = new OioEventLoopGroup();
        try {
            Bootstrap b = new Bootstrap();
            b.group(eventLoopGroup).
                    channel(OioSocketChannel.class).
                    remoteAddress(new InetSocketAddress("localhost",port)).
                    handler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel socketChannel) throws Exception {
                            socketChannel.pipeline().addLast(clientHandler);
                        }
                    });
            //异步连接远程服务，连接远程服务成功后，输出"已经连接到服务器！"
            final ChannelFuture f = b.connect();
            f.addListener(new GenericFutureListener<Future<? super Void>>() {
                @Override
                public void operationComplete(Future<? super Void> future) throws Exception {
                    if (future.isSuccess()) {
                        System.out.println("已经连接到服务器！");
                        ByteBuf byteBuf = Unpooled.copiedBuffer("创建ByteBuf", Charset.defaultCharset());
                        ChannelFuture channelFuture = f.channel().writeAndFlush(byteBuf);
                    }else {
                        Throwable throwable = future.cause();
                        throwable.printStackTrace();
                    }
                }
            });
            f.channel().closeFuture().sync();
        } catch (InterruptedException e) {
            eventLoopGroup.shutdownGracefully().sync();
        }
    }
}

 服务端日志：

Other注册事件
注册事件
Other有新客户端连接接入。。。/127.0.0.1:58678
有新客户端连接接入。。。/127.0.0.1:58678
Other读客户端传入数据=创建ByteBufNetty rocks!
EchoServerOutHandler   write Other channelRead Netty rocks!
读客户端传入数据=创建ByteBufNetty rocks!
EchoServerOutHandler   write channelRead Netty rocks!
EchoServerOutHandler   write
Other执行成功=true
EchoServerOutHandler   write Other channelReadComplete Netty rocks!
EchoServerOutHandler   write
执行成功=true
EchoServerOutHandler   write channelReadComplete Netty rocks!

------------------------------------------------------------------------------------------------

客户端日志：

已经连接到服务器！
读取服务端channelRead0=Other channelRead Netty rocks!
读取服务端channelRead0=channelRead Netty rocks!
读取服务端channelRead0=Other channelReadComplete Netty rocks!
读取服务端channelRead0=channelReadComplete Netty rocks!

转载于:https://www.cnblogs.com/use-D/p/7087626.html

weixin_34082695
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
netty案例，netty4.1基础入门篇十《关于ChannelOutboundHandlerAdapter简单使用》
bugstack虫洞栈
08-28 4421
前言介绍 ChannelOutboundHandlerAdapter与ChannelInboundHandlerAdapter都是继承于ChannelHandler，并实现自己的ChannelXxxHandler。用于在消息管道中不同时机下处理处理消息。 ChannelInboundHandler拦截和处理入站事件，ChannelOutboundHandler拦截和处理出站事件。ChannelH...
Netty入门-Channel
CherishL_的专栏
11-07 907
Netty Channel
Netty源码分析-数据处理器ChannelInboundHandler和ChannelOutboundHandler
源码之下，了无秘密
12-23 8155
概述 Channel接口针对Channel的读入和写出IO事件的处理，定义了两个拓展接口：ChannelInboundHandler用于定义对读入IO事件的处理，ChannelOutboundHandler用于定义写出IO事件的处理。 ChannelInboundHandler ChannelInboundHandler接口定义 /** * {@link ChannelHandler} whic...
Netty的InboundHandler 和OutboundHandler
最新发布
littleschemer的博客
03-02 970
本文说明Netty的InboundHandler 和OutboundHandler的区别，并通过示例演示客户端数据在handler的数据流向。
Netty:ChannelInboundHandlerAdapter和ChannelOutboundHandlerAdapter
TuxedoLinux的博客
07-24 8338
Netty:ChannelInboundHandlerAdapter和ChannelOutboundHandlerAdapter   前面说到，服务端和客户端通讯，我们通常要绑定一个handler（Netty:Bootstrap的handler和childHandler）进行通道的监听，当收到数据时就会触发某个事件，从而进行进一步的处理。 目前我们用的比较多的就是ChannelInbound...
Netty(7)-构建pipeline、channelHandler、Decoder和Encoder
程序员不鸣的博客
02-11 1309
文章目录一.pipeline和channelHandler1.channelHandler的分类1.ChannelInboundHandler2.ChannelOutBoundHandler2.channelHandler的事件传播3.pipeline的结构与channelHandler的执行顺序二.构建客户端和服务端的pipeline与Decoder和Encoder1.ChannelInboun...
netty实现心跳检测
qq_21277357的博客
12-19 142
【代码】netty实现心跳检测。
【Netty】ChannelInboundHandlerAdapter 和 SimpleChannelInboundHandler 对msg传递和flush的影响
CAIBI WORID
01-19 591
Netty强化学习记录 ChannelInboundHandlerAdapter 和 SimpleChannelInboundHandler 对msg传递和flush的影响 区别在于：ChannelInboundHandlerAdapter重写channelRead，SimpleChannelInboundHandler重写channelRead0。其中channelRead0为对channelRead的优化。 SimpleChannelInboundHandler中channelRead0对c.
nettyWebsocket:netty 中的 websocket
06-16
nettyWebsocketwebsocket in netty基于websocket实现的简单聊天服务器
nettyrpc:netty4
05-15
nettyrpcnetty4消息用protobuf
跟闪电侠学Netty：Netty即时聊天实战与底层原理-book-netty.zip
11-07
跟闪电侠学Netty：Netty即时聊天实战与底层原理-book-netty
Netty初探：掌握高性能网络通信框架，提升Java网络编程技能
01-05
Netty是一个高性能、异步的网络通信框架，它解决了JDK自带的NIO API使用复杂的问题，提供了更高的性能和更低的延迟。Netty广泛应用于互联网行业、游戏行业和大数据领域，如阿里的Dubbo和RocketMQ等都使用了Netty作为...
NettyRpc:一个基于Netty，ZooKeeper和Spring的简单RPC框架
04-29
NettyRpc 基于Netty，ZooKeeper和Spring的RPC框架中文详情： 特征： 简单的代码和框架 ZooKeeper的服务注册表/发现支持 高可用性，负载平衡和故障转移 支持不同的负载均衡策略 支持异步/同步调用 支持不同版本的...
Netty之ChannelHandler初解
前者已逝，后者未至。
03-07 843
掌握ChannelHandler基本使用方法。 熟悉入栈ChannelHandler和出栈ChannelHandler的执行顺序。 分析ChannelHandlerContext和NioSocketChannel写入数据时有什么不同。 了解Pipeline添加多个ChannelHandler有什么意义。
netty如何使用 ChannelInboundHandlerAdapter相关理解
热门推荐
jrymos软件工作室
06-01 2万+
pom &amp;lt;?xml version=&quot;1.0&quot; encoding=&quot;UTF-8&quot;?&amp;gt; &amp;lt;project xmlns=&quot;http://maven.apache.org/POM/4.0.0&quot; xmlns:xsi=&quot;http://www.w3.org/2001/XMLSchema-instance&a
java服务器无法响应,【Java】Netty http客户端无法接收到服务器的响应信息
weixin_31842775的博客
08-10 755
这是我的客户端的Handler代码class RobotHandler : ChannelInboundHandlerAdapter() {private val logger = LoggerFactory.getLogger(this.javaClass)override fun channelRead(ctx: ChannelHandlerContext?, msg: Any?) {logg...
Netty使用和常用组件辨析
c243311364的博客
05-18 437
第一个Netty程序 Bootstrap（启动类）,EventLoop(Group)（线程，事件循环处理）,Channel（socket, socketchannel） 事件和ChannelHandler（处理事件），ChannelPipeline ChannelFuture(获取异步结果) 客户端和服务器编程的时候，需要关注客户端是使用.handler添加处理，而服务器是使用.childhandler。因为serversocketchannel，仅仅是接受连接，主要通过子的socketch..
6. Netty中ChannelHandler读取、写入消息
LeoHan
04-11 1886
当我们在Netty中需要写入相关消息，一般都是通过Channel写入，典型的是在Handler中处理，代码如下： class HelloWorldHandler extends ChannelInboundHandlerAdapter { public void channelRead(ChannelHandlerContext ctx, Object msg) throw...
io.netty:netty-all:4.1.6.Final
09-04
io.netty:netty-all:4.1.6.Final是一个Java网络编程框架的依赖包，它提供了异步事件驱动的网络应用程序框架。这个框架可以用于快速开发高性能、高可靠性的网络应用程序，比如TCP/UDP服务器、HTTP服务器、WebSocket...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值