java23种设计模式之策略模式

ゞ浴缸里的玫瑰 2022-02-24 02:40 317阅读 0赞

上一节说到模板方法模式：[https://blog.csdn.net/zhanglei082319/article/details/88906694][https_blog.csdn.net_zhanglei082319_article_details_88906694]

**模板方法模式**：** java多态使用的一种体现，一个具体业务功能的父类实现中有些不能实现的功能，交给子类来实现，而且每种子类实现的方式都不相同，并且不会影响父类的整体业务实现。**

**    **今天我们说一种新的设计模式：策略模式

所谓的策略模式：就是将一些不定的业务需求抽象出来，作为一种特定的策略方式分开实现，当需要使用哪种策略时，就调用该策略的具体实现。

比如我们在使用缓存的时候，对于缓存结构缓存类功能可能会有诸多变化，定时清理缓存，阻塞缓存，固定大小的缓存等等。

比如天猫做活动，做优惠，针对新用户老用户的优惠策略可能是不同的。这也是一种策略

这里使用缓存的案例来讲解一下策略模式

1、新建一个缓存接口

/**
     * 缓存接口
     * @param <K>
     * @param <V>
     *
     * @author zhanglei
     */
    public interface Cache<K,V> {
    
        /**
         * 获取值
         * @param key 键
         * @return 值
         */
        V  get(K key);
    
    
        /**
         * 删除值
         * @param key  键
         * @return     删除的值
         */
        V  remove(K key);
    
    
        /**
         * 添加键值
         * @param key    键
         * @param value  值
         * @return       添加的值
         */
        V  put(K key, V value);
    
    }

2、添加一个默认的缓存实现

public class DefaultCache<K,V>  implements Cache<K,V> {
    
        private final Map<K,V> cacheMap = new ConcurrentHashMap<>();
    
    
        @Override
        public V get(K key) {
            return this.cacheMap.get(key);
        }
    
        @Override
        public V remove(K key) {
            return this.cacheMap.remove(key);
        }
    
        @Override
        public V put(K key, V value) {
            return this.cacheMap.put(key,value);
        }
    }

3、添加一个阻塞的缓存策略实现

public class BlockingCache<K,V> extends BaseCache<K,V> {
    
        public BlockingCache(){
            super();
        }
    
        public BlockingCache(Cache<K, V> cache) {
            super(cache);
        }
    
    
        @Override
        public V get(K key) {
            return super.get(key);
        }
    
        @Override
        public V remove(K key) {
            synchronized (cache) {
                return super.remove(key);
            }
        }
    
        @Override
        public V put(K key, V value) {
            synchronized (cache) {
                return super.put(key, value);
            }
        }
    }

4、添加一个定时清除的缓存实现

public class ScheduleClearCache<K,V> extends BaseCache<K,V> {
    
        //清除间隔时间  默认毫秒  30秒
        private long clearTime = 30000;
    
    
        //上次清理时间
        private  long  lastClearTime = System.currentTimeMillis();
    
        public ScheduleClearCache(){
            super();
        }
    
        public ScheduleClearCache(Cache<K, V> cache) {
            super(cache);
        }
    
        public ScheduleClearCache(Cache<K,V> cache, long clearTime){
            super(cache);
            this.clearTime = clearTime;
        }
    
        /**
         * 校验是否到清除时间
         *
         * @return   Boolean
         */
        private boolean checkOutTime(){
            return System.currentTimeMillis() - this.lastClearTime > this.clearTime;
        }
    
        private void scheduleClear(){
            if(checkOutTime()){
                this.clear();
            }
        }
    
        @Override
        public V get(K key) {
            scheduleClear();
            return super.get(key);
        }
    
        @Override
        public V remove(K key) {
            scheduleClear();
            return super.remove(key);
        }
    
        @Override
        public V put(K key, V value) {
            scheduleClear();
            return super.put(key,value);
        }
    }

这样结合着实际的业务场景需要使用哪个缓存器，实例化这个缓存器即可。

[https_blog.csdn.net_zhanglei082319_article_details_88906694]: https://blog.csdn.net/zhanglei082319/article/details/88906694