netty设计模式-策略模式

素颜马尾好姑娘i 2022-05-19 07:21 110阅读 0赞

策略模式的特点大致如下：

1、封装一系列可替换的算法家族

2、支持动态选择某一个策略

常见的策略模式实现方式

/**
     * @see DefaultEventExecutorChooserFactory#newChooser(EventExecutor[])
     */
    public class Strategy {
        private Cache cacheMemory = new CacheMemoryImpl();
        private Cache cacheRedis = new CacheRedisImpl();
    
        public interface Cache {
            boolean add(String key, Object object);
        }
    
        public class CacheMemoryImpl implements Cache {
            @Override
            public boolean add(String key, Object object) {
                // 保存到map
                return false;
            }
        }
    
        public class CacheRedisImpl implements Cache {
            @Override
            public boolean add(String key, Object object) {
                // 保存到redis
                return false;
            }
        }
    
        public Cache getCache(String key) {
            if (key.length() < 10) {
                return cacheRedis;
            }
            return cacheMemory;
        }
    }

在netty的DefaultEventExecutorChooserFactory 的里面，就是如此实现策略模式的：

@UnstableApi
    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 PowerOfTowEventExecutorChooser(executors);
            } else {
                return new GenericEventExecutorChooser(executors);
            }
        }
    
        private static boolean isPowerOfTwo(int val) {
            return (val & -val) == val;
        }
    
        private static final class PowerOfTowEventExecutorChooser implements EventExecutorChooser {
            private final AtomicInteger idx = new AtomicInteger();
            private final EventExecutor[] executors;
    
            PowerOfTowEventExecutorChooser(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)];
            }
        }
    }