Netty中的設計模式

時間  2019-11-06
標籤 netty 設計 模式 欄目 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());
            }
        }
    };

}
複製代碼

責任鏈模式

避免請求發送者與接收者耦合在一塊兒，讓多個對象都有可能接收請求，將這些對象鏈接成一條鏈，而且沿着這條鏈傳遞請求，直到有對象處理它爲止。bash

組成

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原理解讀。app

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程