1. 注释ruoyi-admin下的application中redis配置
注释掉redis相关配置即可
2. 在ruoyi-common的core/redis下新建MyCache类
@Component
public class MyCache implements Cache {
// 使用ConcurrentHashMap作为数据的存储
private Map<String, Object> storage = new ConcurrentHashMap<>();
// getName获取cache的名称,存取数据的时候用来区分是针对哪个cache操作
@Override
public String getName() {
return null;
}
@Override
public Object getNativeCache() {
return null;
}
public boolean hasKey(String key) {
return storage.containsKey(key);
}
@Override
public ValueWrapper get(Object key) {
String k = key.toString();
Object value = storage.get(k);
// 注意返回的数据,要和存放时接收到数据保持一致,要将数据反序列化回来。
return Objects.isNull(value) ? null : new SimpleValueWrapper(value);
}
@Override
public <T> T get(Object key, Class<T> type) {
return null;
}
@Override
public <T> T get(Object key, Callable<T> valueLoader) {
return null;
}
// put方法,就是执行将数据进行缓存
@Override
public void put(Object key, Object value) {
if (Objects.isNull(value)) {
return;
}
//存值
storage.put(key.toString(), value);
}
// evict方法,是用来清除某个缓存项
@Override
public void evict(Object key) {
storage.remove(key.toString());
}
// 删除集合
public boolean deleteObject(final Collection collection) {
collection.forEach(o -> {
storage.remove(o.toString());
});
return true;
}
// 获取所有的keys
public Collection<String> keys(final String pattern) {
return storage.keySet();
}
@Override
public void clear() {
}
}
3. 注释ruoyi-framework下RedisConfig的配置
直接注释@Bean、@Configuration和@EnableCaching注解就可以了,不用删除RedisConfig,防止后期又要使用redis,直接放开就可以了。
4. 修改ruoyi-common的core/redis下RedisCache类
内容如下,原代码不删除,注释掉,防止后期又使用redis。
@SuppressWarnings(value = {"unchecked", "rawtypes"})
@Component
public class RedisCache {
// @Autowired
// public RedisTemplate redisTemplate;
@Resource
public MyCache myCache;
/**
* 缓存基本的对象,Integer、String、实体类等
*
* @param key 缓存的键值
* @param value 缓存的值
*/
public <T> void setCacheObject(final String key, final T value) {
myCache.put(key,value);
// redisTemplate.opsForValue().set(key, value);
}
/**
* 缓存基本的对象,Integer、String、实体类等
*
* @param key 缓存的键值
* @param value 缓存的值
* @param timeout 时间
* @param timeUnit 时间颗粒度
*/
public <T> void setCacheObject(final String key, final T value, final Integer timeout, final TimeUnit timeUnit) {
myCache.put(key,value);
// redisTemplate.opsForValue().set(key, value, timeout, timeUnit);
}
/**
* 设置有效时间
*
* @param key Redis键
* @param timeout 超时时间
* @return true=设置成功;false=设置失败
*/
public boolean expire(final String key, final long timeout) {
return expire(key, timeout, TimeUnit.SECONDS);
}
/**
* 设置有效时间
*
* @param key Redis键
* @param timeout 超时时间
* @param unit 时间单位
* @return true=设置成功;false=设置失败
*/
public boolean expire(final String key, final long timeout, final TimeUnit unit) {
return true;
// return redisTemplate.expire(key, timeout, unit);
}
/**
* 获取有效时间
*
* @param key Redis键
* @return 有效时间
*/
// public long getExpire(final String key) {
// return redisTemplate.getExpire(key);
// }
/**
* 判断 key是否存在
*
* @param key 键
* @return true 存在 false不存在
*/
public Boolean hasKey(String key) {
return myCache.hasKey(key);
// return redisTemplate.hasKey(key);
}
/**
* 获得缓存的基本对象。
*
* @param key 缓存键值
* @return 缓存键值对应的数据
*/
public <T> T getCacheObject(final String key) {
Cache.ValueWrapper valueWrapper = myCache.get(key);
if (valueWrapper == null){
return null;
}else {
return (T) valueWrapper.get();
}
// ValueOperations<String, T> operation = redisTemplate.opsForValue();
// return operation.get(key);
}
/**
* 删除单个对象
*
* @param key
*/
public boolean deleteObject(final String key) {
myCache.evict(key);
return true;
// return redisTemplate.delete(key);
}
/**
* 删除集合对象
*
* @param collection 多个对象
* @return
*/
public boolean deleteObject(final Collection collection) {
return myCache.deleteObject(collection);
// return redisTemplate.delete(collection) > 0;
}
/**
* 缓存List数据
*
* @param key 缓存的键值
* @param dataList 待缓存的List数据
* @return 缓存的对象
*/
// public <T> long setCacheList(final String key, final List<T> dataList) {
// Long count = redisTemplate.opsForList().rightPushAll(key, dataList);
// return count == null ? 0 : count;
// }
/**
* 获得缓存的list对象
*
* @param key 缓存的键值
* @return 缓存键值对应的数据
*/
// public <T> List<T> getCacheList(final String key) {
// return redisTemplate.opsForList().range(key, 0, -1);
// }
/**
* 缓存Set
*
* @param key 缓存键值
* @param dataSet 缓存的数据
* @return 缓存数据的对象
*/
// public <T> BoundSetOperations<String, T> setCacheSet(final String key, final Set<T> dataSet) {
// BoundSetOperations<String, T> setOperation = redisTemplate.boundSetOps(key);
// Iterator<T> it = dataSet.iterator();
// while (it.hasNext()) {
// setOperation.add(it.next());
// }
// return setOperation;
// }
/**
* 获得缓存的set
*
* @param key
* @return
*/
// public <T> Set<T> getCacheSet(final String key) {
// return redisTemplate.opsForSet().members(key);
// }
/**
* 缓存Map
*
* @param key
* @param dataMap
*/
// public <T> void setCacheMap(final String key, final Map<String, T> dataMap) {
// if (dataMap != null) {
// redisTemplate.opsForHash().putAll(key, dataMap);
// }
// }
/**
* 获得缓存的Map
*
* @param key
* @return
*/
// public <T> Map<String, T> getCacheMap(final String key) {
// return redisTemplate.opsForHash().entries(key);
// }
/**
* 往Hash中存入数据
*
* @param key Redis键
* @param hKey Hash键
* @param value 值
*/
// public <T> void setCacheMapValue(final String key, final String hKey, final T value) {
// redisTemplate.opsForHash().put(key, hKey, value);
// }
/**
* 获取Hash中的数据
*
* @param key Redis键
* @param hKey Hash键
* @return Hash中的对象
*/
// public <T> T getCacheMapValue(final String key, final String hKey) {
// HashOperations<String, String, T> opsForHash = redisTemplate.opsForHash();
// return opsForHash.get(key, hKey);
// }
/**
* 获取多个Hash中的数据
*
* @param key Redis键
* @param hKeys Hash键集合
* @return Hash对象集合
*/
// public <T> List<T> getMultiCacheMapValue(final String key, final Collection<Object> hKeys) {
// return redisTemplate.opsForHash().multiGet(key, hKeys);
// }
/**
* 删除Hash中的某条数据
*
* @param key Redis键
* @param hKey Hash键
* @return 是否成功
*/
// public boolean deleteCacheMapValue(final String key, final String hKey) {
// return redisTemplate.opsForHash().delete(key, hKey) > 0;
// }
/**
* 获得缓存的基本对象列表
*
* @param pattern 字符串前缀
* @return 对象列表
*/
public Collection<String> keys(final String pattern) {
return myCache.keys(pattern);
// return redisTemplate.keys(pattern);
}
}
5. 修改ruoyi-common下utils/DictUtils
/**
* 获取字典缓存
*
* @param key 参数键
* @return dictDatas 字典数据列表
*/
public static List<SysDictData> getDictCache(String key) {
JSONArray arrayCache = JSONArray.parseArray(JSON.toJSONString(SpringUtils.getBean(RedisCache.class).getCacheObject(getCacheKey(key))));
// JSONArray arrayCache = SpringUtils.getBean(RedisCache.class).getCacheObject(getCacheKey(key));
if (StringUtils.isNotNull(arrayCache)) {
return arrayCache.toList(SysDictData.class);
}
return null;
}
6. 基于redis的限流处理就无法使用了,先注释掉
这里先注释相关注解,暂时不删除,防止以后,又需要redis了,放开就行。
7. 重启即可,不再需要启动redis
8. 补充,基于令牌桶方法的限流策略
@Aspect
@Component
public class RateLimiterAspect {
private static final Logger log = LoggerFactory.getLogger(RateLimiterAspect.class);
private ConcurrentMap<String, TokenBucket> buckets = new ConcurrentHashMap<>();
@Before("@annotation(rateLimiter)")
public void doBefore(JoinPoint point, RateLimiter rateLimiter) throws Throwable {
String key = rateLimiter.key();
int time = rateLimiter.time();
int count = rateLimiter.count();
String combineKey = getCombineKey(rateLimiter, point);
TokenBucket bucket = buckets.computeIfAbsent(combineKey, k -> new TokenBucket(count, time));
if (!bucket.tryConsume()) {
throw new ServiceException("访问过于频繁,请稍候再试");
}
log.info("限制请求'{}',当前请求数'{}',缓存key'{}'", count, bucket.getTokens(), key);
}
public String getCombineKey(RateLimiter rateLimiter, JoinPoint point) {
StringBuilder stringBuilder = new StringBuilder(rateLimiter.key());
if (rateLimiter.limitType() == LimitType.IP) {
stringBuilder.append(IpUtils.getIpAddr(ServletUtils.getRequest())).append("-");
}
MethodSignature signature = (MethodSignature) point.getSignature();
Method method = signature.getMethod();
Class<?> targetClass = method.getDeclaringClass();
stringBuilder.append(targetClass.getName()).append("-").append(method.getName());
return stringBuilder.toString();
}
private static class TokenBucket {
private final int capacity;
private long lastRefillTime;
private double tokens;
TokenBucket(int capacity, long refillInterval) {
this.capacity = capacity;
this.tokens = capacity;
this.lastRefillTime = System.currentTimeMillis();
// Start a background thread to refill the bucket periodically
Executors.newSingleThreadScheduledExecutor().scheduleAtFixedRate(
() -> {
synchronized (TokenBucket.this) {
long now = System.currentTimeMillis();
double elapsedSeconds = (now - lastRefillTime) / 1000.0;
tokens = Math.min(capacity, tokens + elapsedSeconds * capacity / refillInterval);
lastRefillTime = now;
}
},
refillInterval,
refillInterval,
TimeUnit.MILLISECONDS
);
}
synchronized boolean tryConsume() {
if (tokens > 0) {
tokens--;
return true;
} else {
return false;
}
}
synchronized int getTokens() {
return (int) tokens;
}
}
}