Java设计模式之装饰模式详解

多级缓存

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

比如：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。

来源：https://blog.csdn.net/weixin_44044929/article/details/125626357