多级缓存

在实际开发项目，为了减少数据库的访问压力，都会将数据缓存到内存中

比如：Redis(分布式缓存)、EHCHE（JVM内置缓存）.

例如在早期中，项目比较小可能不会使用Redis做为缓存，使用JVM内置的缓存框架，项目比较大的时候开始采用Redis分布式缓存框架，

这时候需要设计一级与二级缓存。

缓存机制

1、JVM内置缓存：将数据缓存在当前的jvm中，缺陷：占用我们的JVM内存，存在内存溢出问题，集群很难保证各个节点之间数据同步问题。

2、分布式缓存：Redis，数据可以集群共享

装饰模式

不改变原有代码的基础之上，新增附加功能 ，mybatis、hibernate的二级缓存都属于开发者自己去扩展功能。

装饰模式与代理模式区别


装饰模式对我们的装饰对象实现增强，而代理模式及对我们目标对象实现增强。

类图

• Component (抽象构件)
  
  抽象构件它是具体构件和抽象装饰类的共同父类，声明了在具体构件中实现的业务方法。
• ConcreteComponent (具体构件 [被装饰类] )
  
  具体构件ConcreteComponent是最核心、最原始、最基本的接口或抽象类的实现，要装饰的就是它。
• Decorator (抽象装饰类)
  
  抽象装饰类也是抽象构件类的子类，用于给具体构件增加职责，但是具体职责在其子类中实现。它维护一个指向抽象构
  
  件对象的引用，通过该引用可以调用装饰之前构件对象的方法，并通过其子类扩展该方法，以达到装饰的目的。
• ConcreteDecorator ( 具体装饰类)
  
  具体装饰类是抽象装饰类的子类，负责向构件添加新的职责。每一个具体装饰类都定义了一些新的行为，它可以调用在
  
  抽象装饰类中定义的方法，并可以增加新的方法用以扩充对象的行为。

实现装饰器模式思路：

使用场景

• 需要扩展一个类的功能时
• 需要动态地给一个对象增加功能，并可以动态地撤销时
• 需要为一批的兄弟类进行改装或加装功能时

优缺点

优点

• 装饰类和被装饰类可以独立发展，而不会相互耦合。它有效地把类的核心职责和装饰功能分开了
• 装饰模式是继承关系的一一个替代方案。我们看装饰类Decorator,不管装饰多少层，返回的对象还是Component,实现的还是is-a的关系。
• 装饰模式可以动态地扩展一个实现类的功能

缺点

• 使用装饰模式进行系统设计时将产生很多小对象，这些对象的区别在于它们之间相互连接的方式有所不同，而不是它们的类或者属性值有所不同，大量小对象的产生势必会占用更多的系统资源，在-定程序上影响程序的性能。
• 装饰模式提供了一种比继承更加灵活机动的解决方案，但同时也意味着比继承更加易于出错，排错也很困难，对于多次装饰的对象，调试时寻找错误可能需要逐级排查，较为繁琐。

实现逻辑

装饰者类内部含有被装饰者（组合关系），且被装饰者与装饰者都继承自共同的父类。这样可以通过将被装饰者的子类实例对象 传入-> 装饰者子类的实例对象中，拓展被装饰者继承类即可实现动态的将新功能 附加到装饰者子类实例对象上。在对象功能扩展方面，它比继承更有弹性，装饰者模式也体现了开闭原则(ocp)。

使用装饰模式实现二级缓存

设计思路

代码案例

1、准备两个工具类（jvm缓存和redis缓存）

public class JvmMapCacheUtils {
    /**
     * 缓存容器
     */
    private static Map<String, String> caches = new ConcurrentHashMap<>();

    public static  <T> T getEntity(String key, Class<T> t) {
        // 缓存存放对象的情况
        String json = caches.get(key);
        return JSONObject.parseObject(json, t);
    }

    public static void putEntity(String key, Object o) {
        String json = JSONObject.toJSONString(o);
        caches.put(key, json);
    }
}

@Component
public class RedisUtils {
    private final Map<String, String> map = new ConcurrentHashMap<>();

    /**
     * 存放string类型
     *
     * @param key     key
     * @param data    数据
     */
    public void setString(String key, String data) {
        map.put(key, data);
    }
    /**
     * 根据key查询string类型
     *
     * @param key
     * @return
     */
    public String getString(String key) {
        String value = map.get(key);
        return value;
    }

    public <T> T getEntity(String key, Class<T> t) {
        String json = getString(key);
        return JSONObject.parseObject(json, t);
    }

    public void putEntity(String key, Object object) {
        String json = JSONObject.toJSONString(object);
        setString(key, json);
    }
    /**
     * 根据对应的key删除key
     *
     * @param key
     */
    public void delKey(String key) {
        map.put(key, null);
    }

}

2、编写缓存接口和装饰者抽象类（抽象构件），抽象类继承接口

public interface ComponentCache {

    /**
     * 根据key查询缓存数据
     *
     * @param
     * @return
     */
    <T> T getCacheEntity(String key, Class<T> t);
}

public interface AbstractDecorate extends  ComponentCache {
}

3、编写jvm缓存（具体构件）也是一级缓存

userMapper.findByUser(1)：这里查询数据库的代码就不提供。

@Component
public class JvmComponentCache implements ComponentCache {

    @Autowired
    private UserMapper userMapper;

    /**
     * @param key
     * @param t         返回的数据类型
     * @param joinPoint
     * @return T
     * @Author kaico
     * @Description //TODO
     * @Date 21:02 2022/7/5
     * @Param
     */
    @Override
    public <T> T getCacheEntity(String key, Class<T> t, ProceedingJoinPoint joinPoint) {
        // 先查询我们的一级缓存（Jvm内置）
        T jvmUser = JvmMapCacheUtils.getEntity(key,t);
        if (jvmUser != null) {
            return (T) jvmUser;
        }
//          查询我们的db 通过aop直接获取到我们的目标对象方法
        try {
            Object resultDb = joinPoint.proceed();
            // 数据库DB有的情况 将该内容缓存到当前Jvm中
            JvmMapCacheUtils.putEntity(key, resultDb);
            return (T) resultDb;
        } catch (Throwable throwable) {
            throwable.printStackTrace();
            return null;
        }
    }
    
    /**
     * @Author kaico
     * @Description //TODO 直接查询数据库查询数据
     * @Date 8:02 2022/7/6
     */
    @Override
    public <T> T getCacheEntity(String key, Class<T> t ) {
        // 先查询我们的一级缓存（Jvm内置）
        T jvmUser = JvmMapCacheUtils.getEntity(key,t);
        if (jvmUser != null) {
            return (T) jvmUser;
        }
        // 查询我们的db 通过aop直接获取到我们的目标对象方法
        UserEntity byUser = userMapper.findByUser(1);
        if(byUser == null){
            return null;
        }
        // 数据库DB有的情况 将该内容缓存到当前Jvm中
        JvmMapCacheUtils.putEntity(key, byUser);
        return (T) byUser;
    }
}

4、编写redis二级缓存（这里使用继承的方式）

@Component
public class RedisDecorate extends JvmComponentCache implements AbstractDecorate {
    @Autowired
    private RedisUtils redisUtils;

    @Override
    public <T> T getCacheEntity(String key, Class<T> t, ProceedingJoinPoint joinPoint) {
        // 查询我们的二级缓存
        // 先查询二级缓存
        T redisUser = redisUtils.getEntity(key, t);
        if (redisUser != null) {
            return (T) redisUser;
        }
        // 如果一级缓存存在数据
        T jvmUser = super.getCacheEntity(key, t, joinPoint);
        if (jvmUser == null) {
            return null;
        }
        // 将该缓存数据放入到二级缓存中
        redisUtils.putEntity(key, jvmUser);
        return (T) jvmUser;
    }
}

5、使用装饰过后的缓存类

@Component
public class KaicoCache {
    @Autowired
    private RedisDecorate redisDecorate;

    public <T> T getCacheEntity(String key, Class<T> t, ProceedingJoinPoint joinPoint) {
        return redisDecorate.getCacheEntity(key, t, joinPoint);
    }
}

分析Java的jdk中的装饰器模式

以下是Java I/O流InputStream的部分类图

通过图中可以看出：

• 抽象构件(Component)角色：由InputStream扮演。这是-个抽象类，为各种子类型提供统一的接口。
• 具体构件(ConcreteComponent)角色：由ByteArrayInputStream、 FilelnputStream、 PipedInputStream、
  
  StringBufferlnputStream等类扮演。它们实现了抽象构件角色所规定的接口。
• 抽象装饰(Decorator)角色：由FilterInputStream扮演。它实现了InputStream所规定的接口。
• 具体装饰(ConcreteDecorator)角色：由几个类扮演，分别是BufferedInputStream、DatalnputStream以及 两个不常用到的类LineNumberlnputStream、PushbackInputStream。