Netty-Pipeline流水线

详解Pipeline流水线

背景

一条netty通道需要很多的handler业务处理器来处理业务，每条通道内部都有一条流水线Pipeline将handler装配起来Netty的业务处理器流水线是基于责任链设计模式来设计的, 内部是一个双向链表结构，支持动态添加或删除Handler业务处理器

pipeline入站处理流程

为了完整的延时Pipeline入站处理流程，新建三个入站处理器，然后加入到流水线中

code

package com.wangyg.netty.ch06;

import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.Channel;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.embedded.EmbeddedChannel;
import org.junit.Test;
import util.Logger;

import java.nio.ByteBuffer;

public class InPipeline {
    static class SimpleInhandlerA extends ChannelInboundHandlerAdapter{
        @Override
        public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
            Logger.info("入站处理器A： 被回调 ");
            super.channelRead(ctx, msg);
        }
    }

    static  class SimpleInHandlerB extends  ChannelInboundHandlerAdapter{
        @Override
        public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
            Logger.info("入站处理器B: 被回调 ");
            super.channelRead(ctx, msg);
        }
    }

    static  class SimpleInhandlerC extends ChannelInboundHandlerAdapter{
        @Override
        public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
            Logger.info(" 入站处理器C ： 被回调");
            super.channelRead(ctx, msg);
        }
    }

    @Test
    public void testPipelineInBound(){
        ChannelInitializer i = new ChannelInitializer<EmbeddedChannel>() {

            @Override
            protected void initChannel(EmbeddedChannel ch) throws Exception {
                //添加A
                ch.pipeline().addLast(new SimpleInhandlerA());
                //添加B
                ch.pipeline().addLast(new SimpleInHandlerB());
                //添加C
                ch.pipeline().addLast(new SimpleInhandlerC());
            }
        };


        EmbeddedChannel channel = new EmbeddedChannel(i); //传入channel 初始化
        ByteBuf buffer = Unpooled.buffer();
        buffer.writeInt(1); //写入1
        //相同到写入一个入站报文(数据包)
        channel.writeInbound(buffer);

        try {
            Thread.sleep(10);
        } catch (Exception e) {
            e.printStackTrace();
        }

    }
}

入站顺序

A -> B ->C

Pipeline出站处理流程

新建三个出站处理器，添加顺序为 A ->B ->C

code

package com.wangyg.netty.ch06;

import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.*;
import io.netty.channel.embedded.EmbeddedChannel;
import org.junit.Test;
import util.Logger;

public class OutPipeline {
    public class SimpleOutHandlerA extends ChannelOutboundHandlerAdapter {
        @Override
        public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) throws Exception {
            Logger.info("出站处理器A： 被回调");
            super.write(ctx, msg, promise);
        }
    }

    public class SimpleOutHandlerB extends ChannelOutboundHandlerAdapter {
        @Override
        public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) throws Exception {
            Logger.info("出站处理器B： 被回调");
            super.write(ctx, msg, promise);
        }
    }

    public class SimpleOutHandlerC extends ChannelOutboundHandlerAdapter {
        @Override
        public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) throws Exception {
            Logger.info("出站处理器C： 被回调");
            super.write(ctx, msg, promise);
        }
    }

    @Test
    public void testPipelineOutBound() {
        ChannelInitializer i = new ChannelInitializer<EmbeddedChannel>() {
            @Override
            protected void initChannel(EmbeddedChannel ch) throws Exception {
                ch.pipeline().addLast(new SimpleOutHandlerA());
                ch.pipeline().addLast(new SimpleOutHandlerB());
                ch.pipeline().addLast(new SimpleOutHandlerC());
            }
        };
        EmbeddedChannel channel = new EmbeddedChannel(i);

        ByteBuf buffer = Unpooled.buffer();
        buffer.writeInt(1);
        //向通道写入一个出站报文(数据包)
        channel.writeOutbound(buffer);
        try {
            Thread.sleep(Integer.MAX_VALUE);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

出站处理流程

package com.wangyg.netty.ch06;

import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.*;
import io.netty.channel.embedded.EmbeddedChannel;
import org.junit.Test;
import util.Logger;

public class OutPipeline {
    public class SimpleOutHandlerA extends ChannelOutboundHandlerAdapter {
        @Override
        public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) throws Exception {
            Logger.info("出站处理器A： 被回调");
            super.write(ctx, msg, promise);
        }
    }

    public class SimpleOutHandlerB extends ChannelOutboundHandlerAdapter {
        @Override
        public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) throws Exception {
            Logger.info("出站处理器B： 被回调");
            super.write(ctx, msg, promise);
        }
    }

    public class SimpleOutHandlerC extends ChannelOutboundHandlerAdapter {
        @Override
        public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) throws Exception {
            Logger.info("出站处理器C： 被回调");
            super.write(ctx, msg, promise);
        }
    }

    @Test
    public void testPipelineOutBound() {
        ChannelInitializer i = new ChannelInitializer<EmbeddedChannel>() {
            @Override
            protected void initChannel(EmbeddedChannel ch) throws Exception {
                ch.pipeline().addLast(new SimpleOutHandlerA());
                ch.pipeline().addLast(new SimpleOutHandlerB());
                ch.pipeline().addLast(new SimpleOutHandlerC());
            }
        };
        EmbeddedChannel channel = new EmbeddedChannel(i);

        ByteBuf buffer = Unpooled.buffer();
        buffer.writeInt(1);
        //向通道写入一个出站报文(数据包)
        channel.writeOutbound(buffer);
        try {
            Thread.sleep(Integer.MAX_VALUE);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

出站顺序

C-> B ->A