java23种设计模式之策略模式

上一节说到模板方法模式：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);
    }
}

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