netty-Netty中pipeline设计模式的一个高仿示例

深入理解Netty的Pipeline机制:原理与实践详解 在Netty中,Pipeline是一个责任链模式的实现,它将多个处理器(Handler)串联起来,每个处理器都可以对数据进行处理或转换。Pipeline机制主要包括两个重要的组件:`ChannelPipeline`和`ChannelHandler`。 阅读详情

下属是一个Netty中pipeline设计模式的高仿示例。下述代码中:Channel对应netty中的AbstractChannel, AbstractContext对应netty中的 AbstractChannelHandlerContext , Inhander对应netty中的ChannelInboundHandler,OutHandler对应netty中的ChannelOutboundHandler,Initializer对应netty中的ChannelInitializer, ChannelPipeLine对应netty中的DefaultChannelPipeline,测试的main方法在Channel中。感兴趣的同学可以拷贝运行代码,并对照netty源码研究。

Context:
public interface Context {


    public Handler handler();




}
AbstractContext:
public abstract class AbstractContext implements Context {

    volatile AbstractContext next;
    volatile AbstractContext prev;

    private final boolean inbound;
    private final boolean outbound;
    private final ChannelPipeLine pipeline;
    private final String name;


    public AbstractContext(String name, ChannelPipeLine pipeline, boolean inbound, boolean outbound) {
        this.inbound = inbound;
        this.outbound = outbound;
        this.name = name;
        this.pipeline = pipeline;
    }

    public ChannelPipeLine pipeline() {
        return pipeline;
    }

    public Channel channel() {
        return pipeline.channel();
    }

    public String getName() {
        return name;
    }


    private AbstractContext findContextInbound() {
        AbstractContext ctx = this;
        do {
            ctx = ctx.next;
        } while (!ctx.inbound);
        return ctx;
    }

    private AbstractContext findContextOutbound() {
        AbstractContext ctx = this;
        do {
            ctx = ctx.prev;
        } while (!ctx.outbound);
        return ctx;
    }


    public void request() {
        final AbstractContext next = findContextOutbound();
        next.invokeRequest();
    }



    private void invokeRequest() {
        OutHandler outhandler = (OutHandler)handler();
        outhandler.request(this);
    }


    public void response() {
        final AbstractContext next = findContextInbound();
        next.invokeResponse();

    }


    private void invokeResponse() {
        InHandler inhandler = (InHandler)handler();
        inhandler.response(this);
    }

    public void register() {
        AbstractContext contextInbound = findContextInbound();
        contextInbound.invokeRegister();

    }

    private void invokeRegister() {
        InHandler inhandler = (InHandler)handler();
        inhandler.register(this);

    }

}

DefaultContext:
public class DefaultContext extends AbstractContext {

    private Handler handler;

    public DefaultContext(String name, ChannelPipeLine pipeline, Handler handler) {
        super(name, pipeline, isInbout(handler), isOutbound(handler));
        this.handler = handler;
    }



    @Override
    public Handler handler() {
        return handler;
    }

    private static boolean isInbout(Handler handler) {
        return handler instanceof InHandler;
    }

    private static boolean isOutbound(Handler handler) {
        return handler instanceof OutHandler;
    }
}
Handler:
public interface Handler {




}
InHandler:
public interface InHandler extends Handler {

    public void response(AbstractContext ctx);

    public void register(AbstractContext ctx);

}

OutHandler:
public interface OutHandler extends Handler {

    public void request(AbstractContext ctx);

}

HeadCtx:
public class HeadCtx extends AbstractContext implements OutHandler {

    public HeadCtx(ChannelPipeLine pipeline) {
        super("Head", pipeline, false, true);
    }

    @Override
    public Handler handler() {
        return this;
    }


    @Override
    public void request(AbstractContext ctx) {
        System.out.println("head connect method is called!!!");
       /* ChannelPipeLine pipeLine = getPipeline();
        pipeLine.response();*/
    }


    public void fireRegister() {
    }
}

TailCtx:
public class TailCtx extends AbstractContext implements InHandler {

    public TailCtx(ChannelPipeLine pipeline) {
        super("Tail", pipeline, true, false);
    }



    @Override
    public Handler handler() {
        return this;
    }


    @Override
    public void response(AbstractContext ctx) {

        System.out.println("taill response is called !!!");
       /* ChannelPipeLine pipeline = getPipeline();
        pipeline.request();*/
    }


    @Override
    public void register(AbstractContext ctx) {
    }
}

ChannelPipeLine:
import java.util.NoSuchElementException;
import java.util.concurrent.atomic.AtomicInteger;

public class ChannelPipeLine {


    private Channel channel;
    final AbstractContext head;
    final AbstractContext tail;
    final AtomicInteger inCounter = new AtomicInteger(0);
    final AtomicInteger outCounter = new AtomicInteger(0);


    public ChannelPipeLine(Channel channel) {

        this.channel = channel;
        head = new HeadCtx(this);
        tail = new TailCtx(this);

        head.next = tail;
        tail.prev = head;
    }

    public Channel channel() {
        return channel;
    }



    public final AbstractContext context(Handler handler) {
        if (handler == null) {
            throw new NullPointerException("handler");
        }

        AbstractContext ctx = head.next;
        for (;;) {

            if (ctx == null) {
                return null;
            }

            if (ctx.handler() == handler) {
                return ctx;
            }

            ctx = ctx.next;
        }
    }


    public final ChannelPipeLine remove(Handler handler) {
        remove(getContextOrDie(handler));
        return this;
    }

    private AbstractContext getContextOrDie(Handler handler) {
        AbstractContext ctx =  context(handler);
        if (ctx == null) {
            throw new NoSuchElementException(handler.getClass().getName());
        } else {
            return ctx;
        }
    }


    private AbstractContext remove(final AbstractContext ctx) {
        assert ctx != head && ctx != tail;

        synchronized (this) {
            remove0(ctx);
        }
        return ctx;
    }

    private static void remove0(AbstractContext ctx) {
        AbstractContext prev = ctx.prev;
        AbstractContext next = ctx.next;
        prev.next = next;
        next.prev = prev;
    }


    public ChannelPipeLine addLast(Handler handler) {

        DefaultContext newCtx = null;
        if (handler instanceof OutHandler) {

            newCtx = new DefaultContext("OutHandler#" + inCounter.getAndAdd(1), this, handler);

        } else if (handler instanceof InHandler) {

            newCtx = new DefaultContext("InHandler#" + outCounter.getAndAdd(1), this, handler);

        } else {
            throw new IllegalArgumentException("handler must be InHandler or OutHandler");
        }
        addLast0(newCtx);
        return this;
    }

    private void addLast0(AbstractContext newCtx) {
        AbstractContext prev = tail.prev;
        newCtx.prev = prev;
        newCtx.next = tail;
        prev.next = newCtx;
        tail.prev = newCtx;
    }


    public void request() {
        tail.request();
    }

    public void response() {
        head.response();
    }


    public ChannelPipeLine register() {
        head.register();
        return this;
    }







}

Initializer:
public abstract class Initializer implements InHandler {

    private String name = "initializer";

    @Override
    public void response(AbstractContext ctx) {
    }


    @Override
    public void register(AbstractContext ctx) {
        initChannel(ctx);
        ctx.register();
    }


    private void initChannel(AbstractContext ctx) {
        try {
            Channel channel = ctx.channel();
            initChannel(channel);
        } finally {
            remove(ctx);
        }
    }


    public abstract void initChannel(Channel channel);


    private void remove(AbstractContext ctx) {
        ChannelPipeLine pipeline = ctx.pipeline();
        if (pipeline.context(this) != null) {
            pipeline.remove(this);
        }
    }
}

Channel:
public class Channel {

    private ChannelPipeLine pipeLine;

    public Channel() {
        this.pipeLine = new ChannelPipeLine(this);
    }

    public ChannelPipeLine pipeLine() {
        return this.pipeLine;
    }

    public static void main(String[] args) {
        Handler inHandler1 = new InHandler() {
            private String name = "InHandler1";

            @Override
            public void response(AbstractContext ctx) {
                System.out.println("InHandler1 response called !!!");
                ctx.response();
            }

            @Override
            public void register(AbstractContext ctx) {
                System.out.println("inHandler 1 register called !!!");
                ctx.register();

            }
        };

        Handler outHandler1 = new OutHandler() {
            private String name = "OutHandler1";

            @Override
            public void request(AbstractContext ctx) {
                System.out.println("OutHandler1 connect called !!!");
                ctx.request();
            }
        };

        Handler inHandler2 = new InHandler() {
            private String name = "InHandler2";

            @Override
            public void response(AbstractContext ctx) {
                System.out.println("InHandler2 response called !!!");
                ctx.response();
            }

            @Override
            public void register(AbstractContext ctx) {
                System.out.println("inHandler 2 register called !!!");
                ctx.register();
            }
        };

        Handler outHandler2 = new OutHandler() {
            private String name = "OutHandler2";

            @Override
            public void request(AbstractContext ctx) {
                System.out.println("OutHandler2 connect called !!!");
                ctx.request();
            }
        };

        Channel channel = new Channel();
        ChannelPipeLine pipeLine = channel.pipeLine();
        pipeLine.addLast(new Initializer() {
            @Override
            public void initChannel(Channel channel) {
                ChannelPipeLine pipeLine = channel.pipeLine();
                pipeLine.addLast(inHandler1);
                pipeLine.addLast(outHandler1);
                pipeLine.addLast(inHandler2);
                pipeLine.addLast(outHandler2);
            }
        });


        pipeLine.register();

        System.out.println("add done !!!");
        System.out.println();

        System.out.println("out bount event start !!!");
        pipeLine.request();
        System.out.println();


        System.out.println("in bount event start !!!");
        pipeLine.response();
    }


}





深入 Netty Pipeline:揭秘 ChannelHandler 链路魔法 🚀 Netty 管道之美:ChannelHandler 链路处理全解析 深入理解 Pipeline 处理机制,提升系统性能的终极指南 🚀 解密 Netty Pipeline:ChannelHandler 链路处理的艺术 高性能网络编程必知必会:从原理到实践 🚀 Netty ChannelHandler 链路:从源码到实战的完美蜕变 一文精通 Pipeline 处理机制,构建高性能网络应用 阅读详情

相关推荐

Ventoy引导自定义菜单配置详解:手把手教你用ventoy_grub.cfg启动硬盘里的Manjaro

本文详细解析了Ventoy引导自定义菜单配置方法,重点介绍如何通过ventoy_grub.cfg文件启动硬盘中的Manjaro系统。从Ventoy与GRUB2的协作原理到具体配置步骤,包括分区布局设计、关键参数解析及常见问题解决方案,帮助用户实现多系统引导的灵活管理。

weixin_28738165的博客 302

Netty4.0源码解析:管道模型ChannelPipeline

一、引言 在Netty中每个Channel都持有一个ChannelPipeline,ChannelPipeline持有多个ChannelHandler用于处理IO事件,这些ChannelHandler的顺序由一个双向链表维护,双向链表的头尾结点为HeadContext的实例和TailContext实例。 双向链表由ChannelHandler持有的ChannelHandlerContext绑定。...

APlus 931

Qwen2.5-7B大模型实战:从零部署到高效推理全流程解析

本文详细解析了Qwen2.5-7B大模型从零部署到高效推理的全流程。内容涵盖环境准备、模型下载、使用Transformers进行核心对话推理,并深入介绍了vLLM与TGI生产级服务部署、GPTQ/AWQ量化技术以降低显存消耗,以及llama.cpp、Ollama等本地推理方案。旨在帮助开发者快速掌握部署技巧,实现大模型在消费级硬件上的高效运行。

weixin_29061425的博客 491

模仿netty实现责任链模式

模仿nettty实现责任链模式

weixin_44652738的博客 256

一种车内UWB圆极化天线的理论推导及具体实现

本文详细描述了一款工作于UWB channel 9也即中心频率为7987.2MHz,带宽为499.2MHz的圆极化天线。首先是理论推导圆极化天线的物理尺寸参数,分析物理尺寸参数对天线性能指标的影响。然后分析圆极化天线在汽车驾驶室这种狭窄空间应用中带来的优势,也即可以最大化的极化损失多径,提高主径接收信号的信噪比。

weixin_44555637的博客 2966

QTableView为例:Qt模型视图委托(MVD)(Model-View-Delegate)

QT中的MVD(模型-视图-委托)模式是一种类似于MVC的设计模式,将数据、界面和交互逻辑分离。模型负责数据管理,视图负责显示界面,而委托则嵌入在视图中处理数据的显示和编辑。QT提供了多种视图组件(如QListView、QTreeView、QTableView)和模型类(如QStandardItemModel、QAbstractItemModel),支持数据的多样化呈现。委托(Delegate)通过定制显示和编辑行为增强了视图的灵活性。该模式适用于各类数据结构展示(列表、表格、树形),能够高效处理数据与界面

菜一头包的博客 1991

02-从管道模式看Netty的核心组件以及Netty的编解码

从管道模式看Netty的核心组件以及Netty的编解码 什么是编解码 关于编解码,这里先和大家看一下例子,下面这段代码实现了一个很简单的功能,启动服务端,在启动客户端,当客户端启动成功建立连接后,会向服务端发送一个字符串Hello World,服务端收到数据后打印这条消息。但是如果我们把flag1和flag2处的代码注释掉,会发现服务端是收不到这条消息的。当我们把上述两行代码放开,服务端才能收到消息。这是为什么呢?因为网络只能传输二进制的流数据,是不能传递字符串对象这些东西的。因此我们必须在将数据发送到服务

阿星的博客 428

用树莓派搭建全功能NAS服务器(01):树莓派基础操作&OMV搭建

写在前面 对于文件互传来说,局域网和云盘的操作总是独立的,而且很难将两者的优势合为一体。如果想要集多种优势为一体,那么NAS应该就是较为完美的解决方案了。 在这个系列中我们尽量跳过一些枯燥的理论知识,专注于说明两件事:   1.NAS是什么&能做什么 2.搭建思路&怎么做   这中间也会涉及到一些方案的选择,同类方案我也会列出来和大家分享我已知的优缺点,有兴趣可以多种尝试。(侧重于软件) 虽然是用树莓派搭建的,但是对于debian linux系统下的NAS搭建有着很好的参

斯塔克家的真维斯的工作间 2万+

Netty 基础-组件之Handler & Pipeline

ChannelHandler 用来处理 Channel 上的各种事件,分为入站、出站两种。所有 ChannelHandler 被连成一串,就是 Pipeline 入站处理器通常是 ChannelInboundHandlerAdapter 的子类,主要用来读取客户端数据,写回结果 出站处理器通常是 ChannelOutboundHandlerAdapter 的子类,主要对写回结果进行加工

秃头的博客 237

别再只用STM32了!手把手教你用STM32F4+FPGA EP2C8搭建低成本多轴运动控制器(附S形加减速算法避坑)

本文详细介绍了如何利用STM32F4与FPGA EP2C8搭建低成本多轴运动控制器,解决传统方案在脉冲输出频率、多轴同步性和实时响应方面的瓶颈。通过硬件设计、软件架构和S形加减速算法的优化,实现商用级性能,成本控制在500元以内,适合创客和小型自动化设备开发。

weixin_28693683的博客 304

Codex 的 AGENTS.md 到底怎么写?前端、后端两套实战模板,照抄就能用

文件名是大写AGENTS.md,放在项目根目录构建、测试、类型检查命令都是可直接复制执行的只写了 Agent 从代码里推断不出来的约定红线规则用了明确的否定句式(禁止/不要/Never)标注了自动生成目录和禁止修改的模块写清了交付要求(改动清单 + 验证命令 + 风险说明)没有任何密钥、密码、连接串整体一页能看完,核心要点 10 条以内每一条都能通过"删掉会不会更容易犯错"的测试一份短小精准的 AGENTS.md,比一份充斥模糊规则的长文件有用得多。

篮球界最会写bug的人;程序猿中打球最菜的人。 619

Pipeline 设计模式的优缺点和实践案例

之前文章中介绍了 Pipeline 设计模式,核心思想是创建一组操作(管道)并将数据在这些操作中传递,每个操作可以独立工作,同时处理多个数据流。有同学提到几个问题,本文简单探讨下。 (1)例子中 Pipeline 的代码使用硬编码也可以实现,为什么要用这个模式,有什么好处? (2)Pipeline 设计模式在实际的编码中是怎样体现的? (3)Pipeline 设计模式有什么缺点?如何避免?

悟鸣的技术博客 3815

光芯片Photodiode 原理,设计与版图

但是光电二极管相对较大,因为需要接收足够的入射光线,此外,光电二极管的厚度比较小,通常位于 1 um 以下(为了波导模式更好地在波导中传输,减少损耗)。从下图中可以看出,当反偏时,即有光在耗尽层被吸收被转换为电流信号时,增加反向偏压几乎不影响反向电流,因此,对于光电二极管来说,反向电压并不影响反向电流的大小。不施加外部电压(开路状态),光生电压直接输出,流出的电流受到抑制,在两端积累一定的电位差,类似太阳能电池,具体特点是噪声低,但响应速度慢。因此,需要尽可能的减少暗电流,以增加元件对光的灵敏度。

u011699626的博客 982

通过 Netty 的 Pipeline 学习责任链设计模式

责任链模式是一种解耦发送者和处理者的行为设计模式,通过链式传递请求让多个处理对象有机会处理。Netty框架的ChannelPipeline完美运用了这一模式,通过添加多个ChannelHandler形成双向链表,每个Handler处理特定业务逻辑或传递请求。源码分析显示,Netty通过ChannelHandlerContext包装Handler,使用ctx.fireXXX()方法实现链式调用。该模式支持动态插拔Handler、顺序执行和灵活组合等特性,在保持代码扩展性的同时降低了模块耦合度。LoggingH

shemuel的技术笔记 471

android 蓝牙通讯demo

android 下蓝牙通讯demo,实现了发现蓝牙,使能蓝牙,通过蓝牙发送消息。

VB摄像头监控

该VB模块可对摄像头捕获的画面进行录像等,可在创建的窗口进行控制

Netty从0到1系列之Netty Pipeline【上】

Netty Pipeline 责任链模式解析 Netty Pipeline 是 Netty 框架实现责任链模式的核心组件,它采用双向链表结构管理 ChannelHandler 的执行流程。

编程技术圈 1466

jdk-8u144-linux-x64.tar.gz.

该资源为搭建Linux系统Java环境用,资源的后缀为tar.gz格式的压缩包

netty中Pipeline的ChannelHandler执行顺序案例详解

一、netty的Pipeline模型 netty的Pipeline模型用的是责任链 设计模式,当boss线程监控到绑定端口上有accept事件,此时会为该socket连接实例化Pipeline,并将InboundHandler和OutboundHandler按序加载到Pipeline中,然后将该socket连接(也就是Channel对象)挂载到selector上。一个selector对应一个线程,...

songfei_dream的专栏 3467

Data-Structures-and-Algorithm-Analysis-in-Java.pdf

作者: Weiss, Mark A. 出版社: Addison Wesley Data Structures and Algorithm Analysis in Java is an “advanced algorithms” book that fits between traditional CS2 and Algorithms Analysis courses. In the old ACM Curriculum Guidelines, this course was known as CS7. This text is for readers who want to learn good programming and algorithm analysis skills simultaneously so that they can develop such programs with the maximum amo...

【netty】netty的pipeline理解

Netty 的 Pipeline 是一种非常重要的概念,它负责对 Channel 上的事件进行处理,并提供了一种灵活的扩展机制。整个 Pipeline 的处理流程就像一个工厂的生产线一样,每个 Handler 扮演着不同的角色。Pipeline 是 Netty 中非常重要的一个组件,它通过灵活的 Handler 链式处理机制实现了高效、稳定、可扩展的网络编程。Pipeline 由一系列的 Handler 组成,Handler 通常会被添加到 Pipeline 中,从而形成一个有序的 Handler 链。

热爱技术,享受生活 1万+

Netty之Pipeline总结

一、 一个channel,拥有一个pipeline——handler容器

moneywenxue的博客 935

Netty从0到1系列之Netty Pipeline【下】

本文深入剖析了Netty中Pipeline的底层实现原理。Pipeline采用双向链表结构管理ChannelHandler,每个Handler被包装在ChannelHandlerContext中。关键实现包括:通过head和tail虚拟节点构建双向链表;addLast()方法将Handler添加到链表尾部;事件传播机制分为入站(head→tail)和出站(tail→head)两种方向。

编程技术圈 1305

详细讲解Netty中Pipeline责任链

模拟Netty中Pipeline责任链 在前段时间给我们公司band6,band7同事进行netty相关培训时,写了这样一个小程序。这个小程序虽然很简单,但能有帮助你很好的理解netty中的pipeline是怎么回事?到底在netty中如何使用的,我在文章的最后也会进行总结。 首先你得明白什么是责任链模式? 责任链模式(Chain of Responsibility Pattern)为请求创建了一个处理对象的链。就好比于工厂的流水线作业一样,工人干完一个程序交由下一个工人进行操作,下一个工人干完后又交由下下

wangkang19890121的博客 4859

【Netty篇】Handler & Pipeline 详解

就像车间里的各路特种兵,不同的 Handler 负责不同的加工任务——有的负责“进料”(入站),有的负责“出货”(出站)。则是连接这些特种兵的生产线,就像流水线一样确保数据能够逐个被加工、转换后顺利送出。执行顺序入站:按照 Handler 添加的先后顺序依次处理(正序)。出站:按照 Handler 添加的逆序处理(倒序)。这一切就好像是一场精心设计的接力赛,数据作为接力棒在各个 Handler 之间传递、加工,最终将高质量的产品“送达”客户端!🍔🚀。

qq_56158663的博客 1644

Netty pipeline

本文介绍了Netty pipeline对链接创建, IO处理和消息处理的过程,并进一步探讨了pipeline的结构的特点。

技术进步那些的事 699

【Netty4核心原理⑪】【Netty 大动脉 Pipeline】

本系列虽说本意是作为 《Netty4 核心原理》一书的读书笔记,但在实际阅读记录过程中加入了大量个人阅读的理解和内容,因此对书中内容存在大量删改。第九章 Netty 大动脉 Pipeline</</</</【Netty4核心原理】【全系列文章目录】我们在【Netty4核心原理⑦】【揭开Bootstrap的神秘面纱 - 客户端Bootstrap ❷】的【ChannelPipeline 的初始化。

猫吻鱼的博客 1135

Netty学习——源码篇6 Pipeline设计原理

在Netty中每个Channel都有且仅有一个ChannelPipeline与之对应,它们的组成关系如下图:通过上图可以看到,一个Channel包含了一个ChannelPipeline,而ChannelPipeline中又维护了一个由ChannelHandlerContext组成的双向链表。这个链表的头是HeadContext,链表的尾是TailContext,并且每个ChannelHandlerContext又关联着一个ChannelHandler。

geminigoth的博客 1749

三、netty的SocketChannel和Pipeline

本来打算socketchannel和pipeline分开说的,因为它们就是截然不同的东西,但是看NioSocketChannel的实现中,很多地方都是调用了pipeline.write()这样的方法来实现功能的,所以分开说好像又不是很nice,那就把他们放在一起,先从pipel...

chizaochun5934的博客 2678
上一篇: 一个日志记录工具类
下一篇: 一种重置生产者消费者模式的消费队列的线程安全的做法(java)
lhever_
博客等级 码龄14年 213粉丝 130原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值