public class JvmMapCacheUtils {
    /**
     * 緩存容器
     */
    private static Map<String, String> caches = new ConcurrentHashMap<>();
    public static  <T> T getEntity(String key, Class<T> t) {
        // 緩存存放對(duì)象的情況
        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    數(shù)據(jù)
     */
    public void setString(String key, String data) {
        map.put(key, data);
    }
    /**
     * 根據(jù)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);
    }
    /**
     * 根據(jù)對(duì)應(yīng)的key刪除key
     *
     * @param key
     */
    public void delKey(String key) {
        map.put(key, null);
    }
}

public interface ComponentCache {
    /**
     * 根據(jù)key查詢緩存數(shù)據(jù)
     *
     * @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         返回的數(shù)據(jù)類型
     * @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) {
        // 先查詢我們的一級(jí)緩存（Jvm內(nèi)置）
        T jvmUser = JvmMapCacheUtils.getEntity(key,t);
        if (jvmUser != null) {
            return (T) jvmUser;
        }
//          查詢我們的db 通過(guò)aop直接獲取到我們的目標(biāo)對(duì)象方法
        try {
            Object resultDb = joinPoint.proceed();
            // 數(shù)據(jù)庫(kù)DB有的情況 將該內(nèi)容緩存到當(dāng)前Jvm中
            JvmMapCacheUtils.putEntity(key, resultDb);
            return (T) resultDb;
        } catch (Throwable throwable) {
            throwable.printStackTrace();
            return null;
        }
    }
    /**
     * @Author kaico
     * @Description //TODO 直接查詢數(shù)據(jù)庫(kù)查詢數(shù)據(jù)
     * @Date 8:02 2022/7/6
     */
    @Override
    public <T> T getCacheEntity(String key, Class<T> t ) {
        // 先查詢我們的一級(jí)緩存（Jvm內(nèi)置）
        T jvmUser = JvmMapCacheUtils.getEntity(key,t);
        if (jvmUser != null) {
            return (T) jvmUser;
        }
        // 查詢我們的db 通過(guò)aop直接獲取到我們的目標(biāo)對(duì)象方法
        UserEntity byUser = userMapper.findByUser(1);
        if(byUser == null){
            return null;
        }
        // 數(shù)據(jù)庫(kù)DB有的情況 將該內(nèi)容緩存到當(dāng)前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) {
        // 查詢我們的二級(jí)緩存
        // 先查詢二級(jí)緩存
        T redisUser = redisUtils.getEntity(key, t);
        if (redisUser != null) {
            return (T) redisUser;
        }
        // 如果一級(jí)緩存存在數(shù)據(jù)
        T jvmUser = super.getCacheEntity(key, t, joinPoint);
        if (jvmUser == null) {
            return null;
        }
        // 將該緩存數(shù)據(jù)放入到二級(jí)緩存中
        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);
    }
}