Netty中的设计模式

最新推荐文章于 2025-06-20 21:51:45 发布
转载 最新推荐文章于 2025-06-20 21:51:45 发布 · 959 阅读 · 0 ·
CC 4.0 BY-SA版权
原文链接：https://juejin.im/post/5d04aa52e51d45109b01b18a
文章标签：

#netty #设计模式

文章中整理了部分设计模式，有些设计模式还没有吃透，所以暂且不提。

Netty设计模式应用

单例模式

  • 应用程序中的Singleton对象都使用Singleton类的同一实例
实现方式
  • 实现方式一
public class Singleton1 {

    public static final Singleton1 INSTANCE = new Singleton1();

    private Singleton1(){}

}
复制代码
  • 实现方式二
public class Singleton2_1 {

    private Singleton2_1() {}

    private static Singleton2_1 instance = null;

    public static Singleton2_1 getInstance() {
        if (null == instance) {
            instance = new Singleton2_1();
        }
        return instance;
    }

}
复制代码
public class Singleton2_2 {

    private Singleton2_2() {}

    private static Singleton2_2 instance = null;

    public static Singleton2_2 getInstance() {
        if (null == instance) {
            synchronized(Singleton2_2.class) {
                if (null == instance) {
                    instance = new Singleton2_2();
                }
            }
        }
        return instance;
    }

}
复制代码
public class Singleton2_3 {

    private Singleton2_3() {}

    // 防止指令重排
    private static volatile Singleton2_3 instance = null;

    public static Singleton2_3 getInstance() {
        if (null == instance) {
            synchronized(Singleton2_3.class) {
                if (null == instance) {
                    instance = new Singleton2_3();
                }
            }
        }
        return instance;
    }

}
复制代码
  • 实现方式三
public class Singleton3 {

    private Singleton3() {}

    public static Singleton3 getInstance() {
        return SingletonHolder.instance;
    }

    private static class SingletonHolder {
        private static final Singleton3 instance = new Singleton3();
    }

}
复制代码
  • 实现方式四
public enum Singleton4 {
    INSTANCE;
}
复制代码
Netty中的应用
  • ReadTimeoutException
public final class ReadTimeoutException extends TimeoutException {

    private static final long serialVersionUID = 169287984113283421L;

    public static final ReadTimeoutException INSTANCE = new ReadTimeoutException();

    private ReadTimeoutException() { }
}
复制代码
  • MqttEncoder
@ChannelHandler.Sharable
public final class MqttEncoder extends MessageToMessageEncoder<MqttMessage> {

    public static final MqttEncoder INSTANCE = new MqttEncoder();

    private MqttEncoder() { }

    //...省略代码
}
复制代码

策略模式

  • 对象都具有职责
  • 这些职责不同的具体实现是通过多态完成
  • 相同的算法具有多个不同的实现，需要进行管理
组成
  • 抽象策略角色：通常有一个接口或一个抽象类实现
  • 具体策略角色：包装了相关的算法和行为
  • 环境角色(也称上下文)：持有一个策略类的应用，最终供客户端调用
实现方式
  • 抽象策略角色
public interface PubStrategy {
    void pub(String key);
}
复制代码
  • 具体策略角色
public class RolePubStrategy implements PubStrategy {

    @Override
    public void pub(String key) {
        // get users by role key
        System.out.println("1.Get users by role key...");
        // foreach pub msg to users
        System.out.println("2.Foreach pub msg to users...");
    }

}
复制代码
public class UserPubStrategy implements PubStrategy {

    @Override
    public void pub(String key) {
        // find user by key
        System.out.println("1.Get user by key...");
        // pub msg to user
        System.out.println("2.Pub msg to user...");
    }

}
复制代码
public class StrategyContext {

    private PubStrategy strategy;

    public StrategyContext(PubStrategy strategy) {
        this.strategy = strategy;
    }

    public void pub(String key) {
        strategy.pub(key);
    }

}
复制代码
Netty中的应用
  • 一个变种的策略模式应用EventExecutorChooserFactory#newChooser(EventExecutor[])
@UnstableApi
interface EventExecutorChooser {

    /**
        * Returns the new {@link EventExecutor} to use.
        */
    EventExecutor next();
}
复制代码
public final class DefaultEventExecutorChooserFactory implements EventExecutorChooserFactory {

    public static final DefaultEventExecutorChooserFactory INSTANCE = new DefaultEventExecutorChooserFactory();

    private DefaultEventExecutorChooserFactory() { }

    @SuppressWarnings("unchecked")
    @Override
    public EventExecutorChooser newChooser(EventExecutor[] executors) {
        if (isPowerOfTwo(executors.length)) {
            return new PowerOfTwoEventExecutorChooser(executors);
        } else {
            return new GenericEventExecutorChooser(executors);
        }
    }

    private static boolean isPowerOfTwo(int val) {
        return (val & -val) == val;
    }

    private static final class PowerOfTwoEventExecutorChooser implements EventExecutorChooser {
        private final AtomicInteger idx = new AtomicInteger();
        private final EventExecutor[] executors;

        PowerOfTwoEventExecutorChooser(EventExecutor[] executors) {
            this.executors = executors;
        }

        @Override
        public EventExecutor next() {
            return executors[idx.getAndIncrement() & executors.length - 1];
        }
    }

    private static final class GenericEventExecutorChooser implements EventExecutorChooser {
        private final AtomicInteger idx = new AtomicInteger();
        private final EventExecutor[] executors;

        GenericEventExecutorChooser(EventExecutor[] executors) {
            this.executors = executors;
        }

        @Override
        public EventExecutor next() {
            return executors[Math.abs(idx.getAndIncrement() % executors.length)];
        }
    }
}
复制代码

装饰者模式

  • 动态的给对象添加个职责
组成
  • 装饰接口
  • 装饰者
  • 被装饰者
实现方式

上面策略模式的StrategyContext修改成StrategyContextDecorator。

public class StrategyContextDecorator implements PubStrategy {
    
    private PubStrategy pubStrategy;
    
    public StrategyContextDecorator(PubStrategy pubStrategy) {
        this.pubStrategy = pubStrategy;
    }
    
    @Override
    public void pub(String key) {
        pubStrategy.pub(key);
    }
    
}
复制代码
Netty中的应用
class WrappedByteBuf extends ByteBuf {

    protected final ByteBuf buf;

    protected WrappedByteBuf(ByteBuf buf) {
        if (buf == null) {
            throw new NullPointerException("buf");
        }
        this.buf = buf;
    }

    @Override
    public final boolean hasMemoryAddress() {
        return buf.hasMemoryAddress();
    }

    // ...省略代码
}
复制代码

观察者模式

组成
  • 抽象主题（被观察的对象）：
    • 主题是观察者观察的对象，一个主题必须具备下面三个特征：
      • 持有监听的观察者的引用
      • 支持增加和删除观察者
      • 主题状态改变，通知观察者
  • 观察者：
    • 当主题发生变化，收到通知进行具体的处理是观察者必须具备的特征。
  • 具体的抽象主题
  • 具体的观察者
实现方式
public abstract class Observerable {

    protected List<Observer> observers;
    protected String message;

    /**
     * 添加一个观察者
     * @param observer 观察者对象
     */
    abstract public void registerObserver(Observer observer);

    /**
     * 移除一个观察者
     * @param observer 观察者对象
     */
    abstract public void removeObserver(Observer observer);

    /**
     * 通知所有观察者
     */
    abstract public void notifyObserver(String message);

}
复制代码
public class ConcreteObserverable extends Observerable {

    public ConcreteObserverable() {
        observers = Lists.newArrayList();
    }

    @Override
    public void registerObserver(Observer observer) {
        observers.add(observer);
    }

    @Override
    public void removeObserver(Observer observer) {
        observers.remove(observer);
    }

    @Override
    public void notifyObserver(String message) {
        this.message = message;
        for (Observer observer: observers) {
            observer.update(message);
        }
    }

}
复制代码
public interface Observer {
    public void update(String message);
}
复制代码
public class ConcreteObserver implements Observer {

    @Override
    public void update(String message) {
        System.out.println("message up: " + message);
    }

}
复制代码
Netty中的应用
// 被观察对象
public interface ChannelFuture extends Future<Void> {

    Channel channel();

    // ...省略代码
    @Override
    ChannelFuture addListener(GenericFutureListener<? extends Future<? super Void>> listener);

    @Override
    ChannelFuture removeListener(GenericFutureListener<? extends Future<? super Void>> listener);
   
}
// 具体被观察对象
public class DefaultPromise<V> extends AbstractFuture<V> implements Promise<V> {

    private Object listeners;
  
    @Override
    public Promise<V> setSuccess(V result) {
        if (setSuccess0(result)) {
            notifyListeners();
            return this;
        }
        throw new IllegalStateException("complete already: " + this);
    }
}
// notifyListeners 实现
private void notifyListeners0(DefaultFutureListeners listeners) {
    GenericFutureListener<?>[] a = listeners.listeners();
    int size = listeners.size();
    for (int i = 0; i < size; i ++) {
        notifyListener0(this, a[i]);
    }
}
// 观察者
public interface ChannelFutureListener extends GenericFutureListener<ChannelFuture> {
    ChannelFutureListener FIRE_EXCEPTION_ON_FAILURE = new ChannelFutureListener() {
        @Override
        public void operationComplete(ChannelFuture future) {
            if (!future.isSuccess()) {
                future.channel().pipeline().fireExceptionCaught(future.cause());
            }
        }
    };

}
复制代码

责任链模式

避免请求发送者与接收者耦合在一起，让多个对象都有可能接收请求，将这些对象连接成一条链，并且沿着这条链传递请求，直到有对象处理它为止。

组成
public abstract class AbstractHandler {

    private AbstractHandler next;

    abstract protected void eventSpread();

    public void setNext(AbstractHandler next) {
        this.next = next;
    }

    public void spread() {
        eventSpread();
        // 向下传播
        if (null != next) {
            next.eventSpread();
        }
    }

}
public class Handle1 extends AbstractHandler {

    @Override
    public void eventSpread() {
        System.out.println("Handle1 event spread...");
    }

}
public class Handle2 extends AbstractHandler {

    @Override
    public void eventSpread() {
        System.out.println("Handle2 event spread...");
    }

}
public class TestChain {

    public static void main(String[] args) {

        AbstractHandler h1 = new Handle1();
        AbstractHandler h2 = new Handle2();

        h1.setNext(h2);

        h1.spread();
    }

}
复制代码
Netty中的应用

ChannelPipeline是责任链模式的变种，详见ChannelPipeline原理解读。

转载于:https://juejin.im/post/5d04aa52e51d45109b01b18a

D_SJ
关注
Java读源码之Netty深入剖析2-1-1 netty的设计模式
羽翼天宇
09-06 875
Java读源码之Netty深入剖析2-1-1  netty的设计模式 如果要阅读源码，首先就要学会基本的设计模式。 设计模式是前人总结出来的软件设计方法，有利于使代码更加简洁优雅。 了解了netty的设计模式，再去看源码，会有一种焕然大悟的感觉。 一、单例模式 单例模式是最常见的设计模式： 1、忽略反射的影响，全局只有一个实例 2、有可能会出现延迟创建实例对象，要使用的时候才创建3、...
Netty那点事（四）Netty与Reactor模式
weixin_33866037的博客
02-08 441
2019独角兽企业重金招聘Python工程师标准>>> ...
Java设计模式
06-07 488
*23种设计模式汇总整理&amp;amp;amp;gt;&amp;amp;amp;gt;内容来源 *单例模式 饿汉模式是线程绝对安全的,因为饿汉模式是在类加载的时候就已经初始化了(此时线程还没创建,实例化=初始化+赋值),同时这也是它的缺点,有可能浪费了资源. *策略模式和模板模式 相同点：都是将核心算法进行封装。 不同点：前者是提供给使用者多种选择，而对于后者而言，使用者没得选择，只能按照规定的套路走或者参与其中的某些步骤，但是不能...
跟着Netty 学习 23 种设计模式
csdn_tom_168的博客
06-20 828
Netty框架中广泛运用了23种设计模式，主要分为三类：创建型、结构型和行为型模式。在创建型模式中，Netty采用工厂方法模式创建Channel，抽象工厂模式构建EventLoopGroup，单例模式管理ResourceLeakDetector，建造者模式配置ServerBootstrap，以及原型模式克隆ByteBuf。结构型模式包括适配器模式处理ChannelHandler接口转换，装饰器模式扩展功能，代理模式控制访问，外观模式简化接口，桥接模式解耦抽象与实现，组合模式管理处理器链，享元模式复用对象。行
Netty设计模式
先度过菜鸟阶段
11-10 1452
1 Reactor模式 1.1 概述 • 单线程模型 所有I/O操作都由一个线程完成，即多路复用、事件分发和处理都是在一个Reactor线程上完成的 适合于小容量的场景，高并发的应用场景无法承载压力，单线程无法同时处理高并发时的多条链路，包括编解码，接收响应，性能无法支撑，吞吐量小，而且客户端积压超时率一并提升，增加服务端的负载 • 多线程模型 ...
netty的设计模式
翻身咸鱼的博客
07-22 4786
如果要阅读源码，首先就要学会基本的设计模式。 设计模式是前人总结出来的软件设计方法，有利于使代码更加简洁优雅。 了解了netty的设计模式，再去看源码，会有一种焕然大悟的感觉。 一、单例模式 单例模式是最常见的设计模式： 1、忽略反射的影响，全局只有一个实例 2、有可能会出现延迟创建实例对象，要使用的时候才创建3、这种设计模式能够避免线程安全问题 netty单例模式分析详情 二、策...
Netty源码实战(十一) --- 设计模式的应用
JavaEdge全是干货的技术号
02-21 1158
1 单例模式 1.1 Netty 实例 1.1.1 ReadTimeoutException 可以看出,构造器私有,防止随意创建 static保证延迟加载 1.1.2 MqttEncoder 2 策略模式 3 装饰者模式 Netty 实践 4 观察者模式 4.1 常规操作 4.2 Netty 的实践 在调用 writeAndFlush 后,其实返回的...
Netty(四):Netty模式
张不帅
06-17 481
文章目录 Netty 主要基于主从 Reactors 多线程模型（如图）做了一定的改进，其中主从 Reactor 多线程模型有多个 Reactor BossGroup 线程维护 Selector，只关注 Accecpt当接收到 Accept 事件，获取到对应的 SocketChannel，封装成 NIOScoketChannel 并注册到 Worker 线程（事件循环），并进行维护当 Worker 线程监听到 Selector 中通道发生自己感兴趣的事件后，就进行处理（就由 handler），注意 han
Netty的使用模式
汪翰翔的Blog
01-28 1638
Netty 的组件和设计
五石之瓠 以为大樽 浮于江湖 悠笑人生
05-15 171
本章讲介绍： Netty的技术和架构方面 Channel , EventLoop , 和 ChannelFuture ChannelHandler 和 ChannelPipeline Bootstrapping 在第1章中，我们总结了历史和技术基础 Java 中的高性能网络编程。 这提供了背景 概述Netty的核心概念和构建块。 在第2章中，我们将讨论范围扩展到应用程序开发。 通过构建一个简单...
Netty-IO 模式
Flying_Fish_roe的博客
11-14 586
Netty 是一个提供异步 I/O 操作的网络框架，通过使用事件驱动模型来实现高效的网络通信。Netty 封装了 Java 原生的 NIO API，使得开发者可以更简单地实现复杂的网络通信功能。Netty 的设计目标是简化网络编程，同时提供卓越的性能和可扩展性。
Netty学习笔记九：netty源码分析和设计模式
公子&小白的博客
10-12 467
1. Netty学习笔记九：netty源码分析和设计模式 文章目录1. Netty学习笔记九：netty源码分析和设计模式1.1. Netty核心模块缓冲ByteBuf1.2. ByteBuf的创建方法1.3. ByteBuf使用模式2. Netty里面的设计模式应用分析2.1. Builder构造器模式2.2. 责任链设计模式2.3. 工厂设计模式2.4. 适配器模式2.5. 设计模式推荐书籍 ...
基于netty的通讯协议的设计思考
herriman的博客
12-28 551
序：本文分析了dubbo，rocketmq，以及我们自己项目中的通讯协议的设计与使用。分析了如何设计一个通讯协议。 一、dubbo协议的设计 协议比如说是dubbo，传输可能是：mina、netty、grizzy，序列化可能是：dubbo、hessian2、java、json 。那么这一切都是如何从业务过程中关联起来，并且如何设计的呢？ 1. 从rpc到remote 一个接口方法的动态实现了远程...
Netty框架中的设计模式
weixin_43599368的博客
12-10 743
1、facade模式（外观模式） JDK的SocketChannel和ServerSocketChannel没有统一的Channel接口供业务开发者使用，对于用户而言，没有统一的操作视图，使用起来不方便。而Netty重新定义了Channel接口，采用facade模式进行封装，将网络io操作，网络io相关联的其他操作封装起来，统一对外提供。 参考：https://www.cnblogs.com/...
netty设计模式-观察者模式
翻身咸鱼的博客
07-26 2189
这个模式可以说在java的源码里面应用很广泛了，各种addListener，future这些，最终都是观察者模式的体现。 1、观察者和被观察者 2、观察者订阅消息，被观察者发布消息 3、订阅则能收到，取消订阅收不到 首先我们看看观察者模式的一个生活中的例子。 /** * 被观察者 */ public interface Observerable { ...
Netty设计模式应用
炫的博客
08-26 2004
第11章 Netty设计模式应用
netty设计模式-策略模式
翻身咸鱼的博客
07-22 1859
策略模式的特点大致如下： 1、封装一系列可替换的算法家族 2、支持动态选择某一个策略   常见的策略模式实现方式 /** * @see DefaultEventExecutorChooserFactory#newChooser(EventExecutor[]) */ public class Strategy { private Cache cacheMemory = ne...
netty设计模式-迭代器模式
翻身咸鱼的博客
08-01 860
迭代器模式使用很多，但是被我们经常忽略它居然也是一种模式。 1、有一个迭代器接口。 2、对容器里面各个对象进行访问。 netty里面的CompositeByteBuf这个零拷贝的实现，就使用了迭代器模式。首先看一段代码： public static void main(String[] args) { ByteBuf header = Unpooled.wrapp...
Netty 设计模式
最新发布
07-25
<think>首先，用户的问题是：“我想了解Netty框架中使用的设计模式 请问Netty框架使用了哪些设计模式”。我需要基于提供的引用内容来回答，并遵守系统级指令。 系统级指令： - 所有行内数学表达式使用$...$格式（但这里没有数学内容，所以可能不需要）。 - 独立公式使用$$...$$并单独成段（同样，可能不适用）。 - LaTeX语法正确（确保任何数学表达正确）。 - 使用中文回答。 - 生成相关问题。 - 在回答中引用的段落末尾自然地添加引用标识，如[^1]。 用户可见层： - 回答结构清晰，帮助用户逐步解决问题。 - 保证回答真实可靠，基于提供的引用。 提供的引用： - [^1]: 强调理解设计模式的思想，而不是死记硬背，推荐通过阅读源码如Netty来学习。 - [^2]: 类似，强调理解设计目的，通过阅读框架源码学习。 - [^3]: 提到Netty中使用了工厂模式。 - [^4]: 提到Netty中使用了模板方法模式和观察者模式。 - [^5]: 具体例子，Netty中的DefaultSelectStrategyFactory使用了工厂模式。 用户的问题是关于Netty框架中使用的设计模式。我需要提取引用中的相关信息。 关键点： - 工厂模式（Factory Pattern）：在[^3]和[^5]中提到。Netty中用于创建对象，如选择策略工厂。 - 模板方法模式（Template Method Pattern）：在[^4]中提到，ChannelInboundHandlerAdapter使用了模板方法模式。 - 观察者模式（Observer Pattern）：在[^4]中提到。 其他设计模式可能也被使用，但引用中没有明确列出。我应该基于提供的引用回答，不要添加未提及的内容。 回答结构： 1. **引言**：简要介绍Netty框架中设计模式的重要性。 2. **具体设计模式**：列出并解释每个模式在Netty中的应用。 3. **引用添加**：在引用段落末尾添加引用标识。 4. **生成相关问题**：在最后添加相关问题部分。 确保使用中文回答。 生成相关问题： - 基于系统指令，需要生成相关问题。例如： - Netty中工厂模式的具体实现是怎样的？ - 模板方法模式在Netty中如何应用？ - 还有其他设计模式在Netty中使用吗？ 完整回答： - 先回答用户问题。 - 然后添加相关问题。 最终输出格式： - 回答部分。 - §§相关问题§§部分。</think>### Netty框架中使用的设计模式 Netty 是一个高性能、异步事件驱动的网络应用框架，广泛用于构建服务器和客户端。在 Netty 的设计中，设计模式被巧妙地应用，以提高代码的可扩展性、可维护性和灵活性。以下基于引用内容，总结 Netty 中主要使用的设计模式及其应用场景。设计模式的学习应注重理解其思想，而非死记硬背，通过阅读源码（如 Netty）能有效提升代码设计能力[^1][^2]。 #### 1. **工厂模式（Factory Pattern）** - **定义**：工厂模式是一种创建型设计模式，它定义一个用于创建对象的接口，但将实例化的过程延迟到子类或具体实现类中，从而隐藏对象的创建细节[^3]。 - **在 Netty 中的应用**：Netty 使用工厂模式来创建策略对象或处理器实例。例如，在事件循环组（EventLoopGroup）中，`DefaultSelectStrategyFactory` 负责创建选择策略对象（SelectStrategy）。这确保了策略的创建过程被封装，便于扩展和替换实现[^5]。 - 示例代码片段（基于引用）： ```java public final class DefaultSelectStrategyFactory implements SelectStrategyFactory { public static final SelectStrategyFactory INSTANCE = new DefaultSelectStrategyFactory(); private DefaultSelectStrategyFactory() { } @Override public SelectStrategy newSelectStrategy() { return DefaultSelectStrategy.INSTANCE; // 延迟创建策略对象 } } ``` - **优势**：提高了代码的灵活性和解耦，允许在不修改客户端代码的情况下更换策略实现[^3][^5]。 #### 2. **模板方法模式（Template Method Pattern）** - **定义**：模板方法模式是一种行为型设计模式，它定义一个算法骨架，将某些步骤延迟到子类实现，从而复用公共逻辑[^4]。 - **在 Netty 中的应用**：Netty 的处理器（Handler）设计中广泛使用此模式。例如，`ChannelInboundHandlerAdapter` 类定义了一个模板方法 `channelRead`，其中包含公共逻辑（如解码），而具体处理步骤（如业务逻辑）由子类通过抽象方法 `onChannelRead` 实现[^4]。 - 示例代码片段（基于引用）： ```java public abstract class ChannelInboundHandlerAdapter extends ChannelHandlerAdapter { @Override public void channelRead(ChannelHandlerContext ctx, Object msg) { // 公共逻辑（如解码） onChannelRead(ctx, msg); // 调用子类实现的具体步骤 } protected abstract void onChannelRead(ChannelHandlerContext ctx, Object msg); } ``` - **优势**：简化了处理器开发，子类只需关注特定步骤，而公共逻辑（如错误处理）在父类中统一维护[^4]。 #### 3. **观察者模式（Observer Pattern）** - **定义**：观察者模式是一种行为型设计模式，它定义对象间的一对多依赖关系，当一个对象状态改变时，所有依赖它的对象都会自动收到通知并更新[^4]。 - **在 Netty 中的应用**：Netty 的事件驱动模型核心就是观察者模式。例如，`ChannelPipeline` 中的处理器（Handler）作为观察者，监听事件（如数据到达或连接关闭）。当事件发生时，`ChannelHandlerContext` 会通知所有注册的处理器，实现异步事件处理[^4]。 - **优势**：支持高并发和事件驱动架构，处理器可以动态添加或移除，增强了框架的扩展性[^4]。 ### 总结 Netty 框架通过上述设计模式（工厂模式、模板方法模式、观察者模式）实现了模块化、可扩展和高性能。这些模式的应用不仅提升了代码质量，还体现了设计模式的核心思想：解决特定问题（如对象创建、算法复用、事件通知）而非炫技[^2]。学习 Netty 源码是掌握设计模式的有效途径，建议结合实际项目或阅读 Spring、MyBatis 等框架源码加深理解[^1][^2]。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值