听说过装饰器模式吗?快来看看吧

1.概念

装饰器模式（Decorator Pattern）允许向一个现有的对象添加新的功能，同时又不改变其结构。是继承关系的一个替代方案。

2.针对问题

动态地给一个对象添加一些额外的职责。就增加功能来说，Decorator模式相比生成子类更为灵活。不改变接口的前提下，增强所考虑的类的性能。

何时使用：

1）需要扩展一个类的功能，或给一个类增加附加责任。

2）需要动态地给一个对象增加功能，这些功能可以再动态地撤销。

3）需要增加一些基本功能的排列组合而产生的非常大量的功能，从而使继承变得 不现实。

3.结构

抽象构件(Component)角色：给出一个抽象接口，以规范准备接收附加责任的对象。

具体构件(ConcreteComponent)角色：定义一个将要接收附加责任的类

装饰角色(Decorator)：持有一个构件(Component)对象的实例，并定义一个与抽象构件接口一致的接口

具体装饰角色(ConcreteDecorator)：负责给构件对象“贴上”附加的责任

4。例子：

对缓存的扩展，普通缓存 扩展fifo和lru功能

1:cache

public interface Cache {

    String getId();

    void putObject(Object key, Object value);

    Object getByKey(Object key);

    Object removeByKey(Object key);

    void clear();

    int getSize();

}

2.PerpetualCache

public class PerpetualCache implements Cache {

    private final String id;

    private final Map<Object, Object> cache = new HashMap<>();

    public PerpetualCache(String id) {
        this.id = id;
    }

    @Override
    public String getId() {
        return id;
    }

    @Override
    public void putObject(Object key, Object value) {
        cache.put(key, value);
    }

    @Override
    public Object getByKey(Object key) {
        return cache.get(key);
    }

    @Override
    public Object removeByKey(Object key) {
        return cache.remove(key);
    }

    @Override
    public void clear() {
        cache.clear();
    }

    @Override
    public int getSize() {
        return cache.size();
    }
}

3.Decorator

public interface Decorator extends Cache {
}

4.FifoCache LruCache

public class FifoCache implements Decorator {

    private final Cache delegate;
    private final Deque<Object> keyList;
    private int size;

    public FifoCache(Cache delegate) {
        this.delegate = delegate;
        this.keyList = new LinkedList<>();
        this.size = 1024;
    }

    @Override
    public String getId() {
        return delegate.getId() + "fifo";
    }

    @Override
    public void putObject(Object key, Object value) {
        cycleKeyList(key);
        delegate.putObject(key, value);
    }

    @Override
    public Object getByKey(Object key) {
        return delegate.getByKey(key);
    }

    @Override
    public Object removeByKey(Object key) {
        return delegate.removeByKey(key);
    }

    @Override
    public void clear() {
        delegate.clear();
        keyList.clear();
    }

    @Override
    public int getSize() {
        return delegate.getSize();
    }

    private void cycleKeyList(Object key) {
        keyList.addLast(key);
        if (keyList.size() > size) {
            Object oldestKey = keyList.removeFirst();
            delegate.removeByKey(oldestKey);
        }
    }
}

public interface Decorator extends Cache {
}

5.main

public static void main(String[] args) {

    PerpetualCache cache = new PerpetualCache("cache");
    // 装饰先进先出
    FifoCache fifoCache = new FifoCache(cache);
    System.out.println("fifo" + fifoCache.getId());

    // 装饰lru
    LruCache lruCache = new LruCache(cache);
    System.out.println("lru" + lruCache.getId());
}