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

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);
    }
}

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

@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;
    }
}

@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;
    }
}

@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);
    }
}