Source/BladeX-Tool/blade-starter-cache/src/main/java/org/springblade/core/cache/utils/CacheUtil.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,331 @@
/*
 *      Copyright (c) 2018-2028, Chill Zhuang All rights reserved.
 *
 *  Redistribution and use in source and binary forms, with or without
 *  modification, are permitted provided that the following conditions are met:
 *
 *  Redistributions of source code must retain the above copyright notice,
 *  this list of conditions and the following disclaimer.
 *  Redistributions in binary form must reproduce the above copyright
 *  notice, this list of conditions and the following disclaimer in the
 *  documentation and/or other materials provided with the distribution.
 *  Neither the name of the dreamlu.net developer nor the names of its
 *  contributors may be used to endorse or promote products derived from
 *  this software without specific prior written permission.
 *  Author: Chill åº„骞 (smallchill@163.com)
 */
package org.springblade.core.cache.utils;

import org.springblade.core.secure.utils.AuthUtil;
import org.springblade.core.tool.constant.BladeConstant;
import org.springblade.core.tool.utils.*;
import org.springframework.cache.Cache;
import org.springframework.cache.CacheManager;
import org.springframework.lang.Nullable;

import java.lang.reflect.Field;
import java.util.List;
import java.util.concurrent.Callable;

/**
 * ç¼“存工具类
 *
 * @author Chill
 */
public class CacheUtil {

   private static CacheManager cacheManager;

   private static final Boolean TENANT_MODE = Boolean.TRUE;

   /**
    * èŽ·å–缓存工具
    *
    * @return CacheManager
    */
   private static CacheManager getCacheManager() {
      if (cacheManager == null) {
         cacheManager = SpringUtil.getBean(CacheManager.class);
      }
      return cacheManager;
   }

   /**
    * èŽ·å–缓存对象
    *
    * @param cacheName ç¼“存名
    * @return Cache
    */
   public static Cache getCache(String cacheName) {
      return getCache(cacheName, TENANT_MODE);
   }

   /**
    * èŽ·å–缓存对象
    *
    * @param cacheName  ç¼“存名
    * @param tenantMode ç§Ÿæˆ·æ¨¡å¼
    * @return Cache
    */
   public static Cache getCache(String cacheName, Boolean tenantMode) {
      return getCacheManager().getCache(formatCacheName(cacheName, tenantMode));
   }

   /**
    * èŽ·å–缓存对象
    *
    * @param cacheName ç¼“存名
    * @param tenantId  ç§Ÿæˆ·ID
    * @return Cache
    */
   public static Cache getCache(String cacheName, String tenantId) {
      return getCacheManager().getCache(formatCacheName(cacheName, tenantId));
   }

   /**
    * æ ¹æ®ç§Ÿæˆ·ä¿¡æ¯æ ¼å¼åŒ–缓存名
    *
    * @param cacheName  ç¼“存名
    * @param tenantMode ç§Ÿæˆ·æ¨¡å¼
    * @return String
    */
   public static String formatCacheName(String cacheName, Boolean tenantMode) {
      if (!tenantMode) {
         return cacheName;
      }
      return formatCacheName(cacheName, AuthUtil.getTenantId());
   }

   /**
    * æ ¹æ®ç§Ÿæˆ·ä¿¡æ¯æ ¼å¼åŒ–缓存名
    *
    * @param cacheName ç¼“存名
    * @param tenantId  ç§Ÿæˆ·ID
    * @return String
    */
   public static String formatCacheName(String cacheName, String tenantId) {
      return (StringUtil.isBlank(tenantId) ? cacheName : tenantId.concat(StringPool.COLON).concat(cacheName));
   }

   /**
    * èŽ·å–缓存
    *
    * @param cacheName ç¼“存名
    * @param keyPrefix ç¼“存键前缀
    * @param key       ç¼“存键值
    * @return Object
    */
   @Nullable
   public static Object get(String cacheName, String keyPrefix, Object key) {
      return get(cacheName, keyPrefix, key, TENANT_MODE);
   }

   /**
    * èŽ·å–缓存
    *
    * @param cacheName  ç¼“存名
    * @param keyPrefix  ç¼“存键前缀
    * @param key        ç¼“存键值
    * @param tenantMode ç§Ÿæˆ·æ¨¡å¼
    * @return Object
    */
   @Nullable
   public static Object get(String cacheName, String keyPrefix, Object key, Boolean tenantMode) {
      if (Func.hasEmpty(cacheName, keyPrefix, key)) {
         return null;
      }
      Cache.ValueWrapper valueWrapper = getCache(cacheName, tenantMode).get(keyPrefix.concat(String.valueOf(key)));
      if (Func.isEmpty(valueWrapper)) {
         return null;
      }
      return valueWrapper.get();
   }

   /**
    * èŽ·å–缓存
    *
    * @param cacheName ç¼“存名
    * @param keyPrefix ç¼“存键前缀
    * @param key       ç¼“存键值
    * @param type      ç±»åž‹
    * @param <T>       æ³›åž‹
    * @return T
    */
   @Nullable
   public static <T> T get(String cacheName, String keyPrefix, Object key, @Nullable Class<T> type) {
      return get(cacheName, keyPrefix, key, type, TENANT_MODE);
   }

   /**
    * èŽ·å–缓存
    *
    * @param cacheName  ç¼“存名
    * @param keyPrefix  ç¼“存键前缀
    * @param key        ç¼“存键值
    * @param type       ç±»åž‹
    * @param tenantMode ç§Ÿæˆ·æ¨¡å¼
    * @param <T>        æ³›åž‹
    * @return T
    */
   @Nullable
   public static <T> T get(String cacheName, String keyPrefix, Object key, @Nullable Class<T> type, Boolean tenantMode) {
      if (Func.hasEmpty(cacheName, keyPrefix, key)) {
         return null;
      }
      return getCache(cacheName, tenantMode).get(keyPrefix.concat(String.valueOf(key)), type);
   }

   /**
    * èŽ·å–缓存
    *
    * @param cacheName   ç¼“存名
    * @param keyPrefix   ç¼“存键前缀
    * @param key         ç¼“存键值
    * @param valueLoader é‡è½½å¯¹è±¡
    * @param <T>         æ³›åž‹
    * @return T
    */
   @Nullable
   public static <T> T get(String cacheName, String keyPrefix, Object key, Callable<T> valueLoader) {
      return get(cacheName, keyPrefix, key, valueLoader, TENANT_MODE);
   }

   /**
    * èŽ·å–缓存
    *
    * @param cacheName   ç¼“存名
    * @param keyPrefix   ç¼“存键前缀
    * @param key         ç¼“存键值
    * @param valueLoader é‡è½½å¯¹è±¡
    * @param tenantMode  ç§Ÿæˆ·æ¨¡å¼
    * @param <T>         æ³›åž‹
    * @return T
    */
   @Nullable
   public static <T> T get(String cacheName, String keyPrefix, Object key, Callable<T> valueLoader, Boolean tenantMode) {
      if (Func.hasEmpty(cacheName, keyPrefix, key)) {
         return null;
      }
      try {
         Cache.ValueWrapper valueWrapper = getCache(cacheName, tenantMode).get(keyPrefix.concat(String.valueOf(key)));
         Object value = null;
         if (valueWrapper == null) {
            T call = valueLoader.call();
            if (ObjectUtil.isNotEmpty(call)) {
               Field field = ReflectUtil.getField(call.getClass(), BladeConstant.DB_PRIMARY_KEY);
               if (ObjectUtil.isNotEmpty(field) && ObjectUtil.isEmpty(ClassUtil.getMethod(call.getClass(), BladeConstant.DB_PRIMARY_KEY_METHOD).invoke(call))) {
                  return null;
               }
               getCache(cacheName, tenantMode).put(keyPrefix.concat(String.valueOf(key)), call);
               value = call;
            }
         } else {
            value = valueWrapper.get();
         }
         return (T) value;
      } catch (Exception ex) {
         ex.printStackTrace();
         return null;
      }
   }

   /**
    * è®¾ç½®ç¼“å­˜
    *
    * @param cacheName ç¼“存名
    * @param keyPrefix ç¼“存键前缀
    * @param key       ç¼“存键值
    * @param value     ç¼“存值
    */
   public static void put(String cacheName, String keyPrefix, Object key, @Nullable Object value) {
      put(cacheName, keyPrefix, key, value, TENANT_MODE);
   }

   /**
    * è®¾ç½®ç¼“å­˜
    *
    * @param cacheName  ç¼“存名
    * @param keyPrefix  ç¼“存键前缀
    * @param key        ç¼“存键值
    * @param value      ç¼“存值
    * @param tenantMode ç§Ÿæˆ·æ¨¡å¼
    */
   public static void put(String cacheName, String keyPrefix, Object key, @Nullable Object value, Boolean tenantMode) {
      getCache(cacheName, tenantMode).put(keyPrefix.concat(String.valueOf(key)), value);
   }

   /**
    * æ¸…除缓存
    *
    * @param cacheName ç¼“存名
    * @param keyPrefix ç¼“存键前缀
    * @param key       ç¼“存键值
    */
   public static void evict(String cacheName, String keyPrefix, Object key) {
      evict(cacheName, keyPrefix, key, TENANT_MODE);
   }

   /**
    * æ¸…除缓存
    *
    * @param cacheName  ç¼“存名
    * @param keyPrefix  ç¼“存键前缀
    * @param key        ç¼“存键值
    * @param tenantMode ç§Ÿæˆ·æ¨¡å¼
    */
   public static void evict(String cacheName, String keyPrefix, Object key, Boolean tenantMode) {
      if (Func.hasEmpty(cacheName, keyPrefix, key)) {
         return;
      }
      getCache(cacheName, tenantMode).evict(keyPrefix.concat(String.valueOf(key)));
   }

   /**
    * æ¸…空缓存
    *
    * @param cacheName ç¼“存名
    */
   public static void clear(String cacheName) {
      clear(cacheName, TENANT_MODE);
   }

   /**
    * æ¸…空缓存
    *
    * @param cacheName  ç¼“存名
    * @param tenantMode ç§Ÿæˆ·æ¨¡å¼
    */
   public static void clear(String cacheName, Boolean tenantMode) {
      if (Func.isEmpty(cacheName)) {
         return;
      }
      getCache(cacheName, tenantMode).clear();
   }

   /**
    * æ¸…空缓存
    *
    * @param cacheName ç¼“存名
    * @param tenantId  ç§Ÿæˆ·ID
    */
   public static void clear(String cacheName, String tenantId) {
      if (Func.isEmpty(cacheName)) {
         return;
      }
      getCache(cacheName, tenantId).clear();
   }

   /**
    * æ¸…空缓存
    *
    * @param cacheName ç¼“存名
    * @param tenantIds ç§Ÿæˆ·ID集合
    */
   public static void clear(String cacheName, List<String> tenantIds) {
      if (Func.isEmpty(cacheName)) {
         return;
      }
      tenantIds.forEach(tenantId -> getCache(cacheName, tenantId).clear());
   }

}