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

目录

• 多级缓存
• 装饰模式
• 类图
• 使用场景
• 优缺点
• 实现逻辑
• 使用装饰模式实现二级缓存
• 设计思路
• 代码案例
• 分析Java的jdk中的装饰器模式

多级缓存

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

比如：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 caches = new ConcurrentHashMap<>();
    public static   T getEntity(String key, Class 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 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 getEntity(String key, Class 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 getCacheEntity(String key, Class 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 getCacheEntity(String key, Class 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 getCacheEntity(String key, Class 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 getCacheEntity(String key, Class 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 getCacheEntity(String key, Class 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。

到此这篇关于Java设计模式之装饰模式详解的文章就介绍到这了,更多相关Java装饰模式内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！