update 升级 luttuce 为 redisson 性能更强 工具更全

疯狂的狮子li

2021-05-31 99c4692a0de9fd96d93dcf5fce4a13e7bb686523

update 升级 luttuce 为 redisson 性能更强 工具更全

 pom.xml

@@ -31,6 +31,7 @@
        <feign.version>2.2.6.RELEASE</feign.version>
        <feign-okhttp.version>11.0</feign-okhttp.version>
        <spring-boot-admin.version>2.3.1</spring-boot-admin.version>
        <redisson.version>3.15.2</redisson.version>
    </properties>

    <!-- ä¾èµ–声明 -->
@@ -180,6 +181,13 @@
                <version>${ruoyi-vue-plus.version}</version>
            </dependency>

            <!--redisson-->
            <dependency>
                <groupId>org.redisson</groupId>
                <artifactId>redisson-spring-boot-starter</artifactId>
                <version>${redisson.version}</version>
            </dependency>

        </dependencies>
    </dependencyManagement>


 ruoyi-admin/src/main/resources/application-dev.yml

@@ -67,13 +67,38 @@
    password:
    # è¿žæŽ¥è¶…时时间
    timeout: 10s
    lettuce:
      pool:
        # è¿žæŽ¥æ± ä¸­çš„最小空闲连接
        min-idle: 0
        # è¿žæŽ¥æ± ä¸­çš„最大空闲连接
        max-idle: 8
        # è¿žæŽ¥æ± çš„最大数据库连接数
        max-active: 8
        # #连接池最大阻塞等待时间（使用负值表示没有限制）
        max-wait: -1ms
    # æ˜¯å¦å¼€å¯ssl
    ssl: false

--- # redisson å®¢æˆ·ç«¯é…ç½®
redisson:
  # çº¿ç¨‹æ± æ•°é‡
  threads: 16
  # Netty线程池数量
  nettyThreads: 32
  # ä¼ è¾“模式
  transportMode: "NIO"
  # å•èŠ‚点配置
  singleServerConfig:
    # å®¢æˆ·ç«¯åç§°
    clientName: ${ruoyi-vue-plus.name}
    # æœ€å°ç©ºé—²è¿žæŽ¥æ•°
    connectionMinimumIdleSize: 32
    # è¿žæŽ¥æ± å¤§å°
    connectionPoolSize: 64
    # è¿žæŽ¥ç©ºé—²è¶…时，单位：毫秒
    idleConnectionTimeout: 10000
    # å‘½ä»¤ç­‰å¾…超时，单位：毫秒
    timeout: 3000
    # å¦‚果尝试在此限制之内发送成功，则开始启用 timeout è®¡æ—¶ã€‚
    retryAttempts: 3
    # å‘½ä»¤é‡è¯•å‘送时间间隔，单位：毫秒
    retryInterval: 1500
    # å‘布和订阅连接的最小空闲连接数
    subscriptionConnectionMinimumIdleSize: 1
    # å‘布和订阅连接池大小
    subscriptionConnectionPoolSize: 50
    # å•ä¸ªè¿žæŽ¥æœ€å¤§è®¢é˜…数量
    subscriptionsPerConnection: 5
    # DNS监测时间间隔，单位：毫秒
    dnsMonitoringInterval: 5000

 ruoyi-admin/src/main/resources/application-prod.yml

@@ -67,13 +67,38 @@
    password:
    # è¿žæŽ¥è¶…时时间
    timeout: 10s
    lettuce:
      pool:
        # è¿žæŽ¥æ± ä¸­çš„最小空闲连接
        min-idle: 0
        # è¿žæŽ¥æ± ä¸­çš„最大空闲连接
        max-idle: 8
        # è¿žæŽ¥æ± çš„最大数据库连接数
        max-active: 8
        # #连接池最大阻塞等待时间（使用负值表示没有限制）
        max-wait: -1ms
    # æ˜¯å¦å¼€å¯ssl
    ssl: false

--- # redisson å®¢æˆ·ç«¯é…ç½®
redisson:
  # çº¿ç¨‹æ± æ•°é‡
  threads: 16
  # Netty线程池数量
  nettyThreads: 32
  # ä¼ è¾“模式
  transportMode: "NIO"
  # å•èŠ‚点配置
  singleServerConfig:
    # å®¢æˆ·ç«¯åç§°
    clientName: ${ruoyi-vue-plus.name}
    # æœ€å°ç©ºé—²è¿žæŽ¥æ•°
    connectionMinimumIdleSize: 32
    # è¿žæŽ¥æ± å¤§å°
    connectionPoolSize: 64
    # è¿žæŽ¥ç©ºé—²è¶…时，单位：毫秒
    idleConnectionTimeout: 10000
    # å‘½ä»¤ç­‰å¾…超时，单位：毫秒
    timeout: 3000
    # å¦‚果尝试在此限制之内发送成功，则开始启用 timeout è®¡æ—¶ã€‚
    retryAttempts: 3
    # å‘½ä»¤é‡è¯•å‘送时间间隔，单位：毫秒
    retryInterval: 1500
    # å‘布和订阅连接的最小空闲连接数
    subscriptionConnectionMinimumIdleSize: 1
    # å‘布和订阅连接池大小
    subscriptionConnectionPoolSize: 50
    # å•ä¸ªè¿žæŽ¥æœ€å¤§è®¢é˜…数量
    subscriptionsPerConnection: 5
    # DNS监测时间间隔，单位：毫秒
    dnsMonitoringInterval: 5000

 ruoyi-common/pom.xml

@@ -151,6 +151,12 @@
            <artifactId>spring-boot-configuration-processor</artifactId>
        </dependency>

        <!--redisson-->
        <dependency>
            <groupId>org.redisson</groupId>
            <artifactId>redisson-spring-boot-starter</artifactId>
        </dependency>

    </dependencies>

</project>

 ruoyi-common/src/main/java/com/ruoyi/common/core/redis/RedisCache.java

@@ -1,234 +1,219 @@
package com.ruoyi.common.core.redis;

import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;
import com.google.common.collect.Lists;
import org.redisson.api.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.BoundSetOperations;
import org.springframework.data.redis.core.HashOperations;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.stereotype.Component;

import java.util.*;
import java.util.concurrent.TimeUnit;

/**
 * spring redis å·¥å…·ç±»
 *
 * @author ruoyi
 * @author shenxinquan
 **/
@SuppressWarnings(value = { "unchecked", "rawtypes" })
@SuppressWarnings(value = {"unchecked", "rawtypes"})
@Component
public class RedisCache
{
    @Autowired
    public RedisTemplate redisTemplate;
public class RedisCache {

    /**
     * ç¼“存基本的对象，Integer、String、实体类等
     *
     * @param key ç¼“存的键值
     * @param value ç¼“存的值
     */
    public <T> void setCacheObject(final String key, final T value)
    {
        redisTemplate.opsForValue().set(key, value);
    }
    @Autowired
    private RedissonClient redissonClient;

    /**
     * ç¼“存基本的对象，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)
    {
        redisTemplate.opsForValue().set(key, value, timeout, timeUnit);
    }
    /**
     * ç¼“存基本的对象，Integer、String、实体类等
     *
     * @param key   ç¼“存的键值
     * @param value ç¼“存的值
     */
    public <T> void setCacheObject(final String key, final T value) {
        redissonClient.getBucket(key).set(value);
    }

    /**
     * è®¾ç½®æœ‰æ•ˆæ—¶é—´
     *
     * @param key Redis键
     * @param timeout è¶…时时间
     * @return true=设置成功；false=设置失败
     */
    public boolean expire(final String key, final long timeout)
    {
        return expire(key, timeout, TimeUnit.SECONDS);
    }
    /**
     * ç¼“存基本的对象，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) {
        RBucket<T> result = redissonClient.getBucket(key);
        result.set(value);
        result.expire(timeout, timeUnit);
    }

    /**
     * è®¾ç½®æœ‰æ•ˆæ—¶é—´
     *
     * @param key Redis键
     * @param timeout è¶…时时间
     * @param unit æ—¶é—´å•ä½
     * @return true=设置成功；false=设置失败
     */
    public boolean expire(final String key, final long timeout, final TimeUnit unit)
    {
        return redisTemplate.expire(key, timeout, unit);
    }
    /**
     * è®¾ç½®æœ‰æ•ˆæ—¶é—´
     *
     * @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 ç¼“存键值
     * @return ç¼“存键值对应的数据
     */
    public <T> T getCacheObject(final String key)
    {
        ValueOperations<String, T> operation = redisTemplate.opsForValue();
        return operation.get(key);
    }
    /**
     * è®¾ç½®æœ‰æ•ˆæ—¶é—´
     *
     * @param key     Redis键
     * @param timeout è¶…时时间
     * @param unit    æ—¶é—´å•ä½
     * @return true=设置成功；false=设置失败
     */
    public boolean expire(final String key, final long timeout, final TimeUnit unit) {
        RBucket rBucket = redissonClient.getBucket(key);
        return rBucket.expire(timeout, unit);
    }

    /**
     * åˆ é™¤å•ä¸ªå¯¹è±¡
     *
     * @param key
     */
    public boolean deleteObject(final String key)
    {
        return redisTemplate.delete(key);
    }
    /**
     * èŽ·å¾—缓存的基本对象。
     *
     * @param key ç¼“存键值
     * @return ç¼“存键值对应的数据
     */
    public <T> T getCacheObject(final String key) {
        RBucket<T> rBucket = redissonClient.getBucket(key);
        return rBucket.get();
    }

    /**
     * åˆ é™¤é›†åˆå¯¹è±¡
     *
     * @param collection å¤šä¸ªå¯¹è±¡
     * @return
     */
    public long deleteObject(final Collection collection)
    {
        return redisTemplate.delete(collection);
    }
    /**
     * åˆ é™¤å•ä¸ªå¯¹è±¡
     *
     * @param key
     */
    public boolean deleteObject(final String key) {
        return redissonClient.getBucket(key).delete();
    }

    /**
     * ç¼“å­˜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);
    }
    /**
     * åˆ é™¤é›†åˆå¯¹è±¡
     *
     * @param collection å¤šä¸ªå¯¹è±¡
     * @return
     */
    public long deleteObject(final Collection collection) {
        return redissonClient.getKeys().delete(Arrays.toString(collection.toArray()));
    }

    /**
     * ç¼“å­˜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;
    }
    /**
     * ç¼“å­˜List数据
     *
     * @param key      ç¼“存的键值
     * @param dataList å¾…缓存的List数据
     * @return ç¼“存的对象
     */
    public <T> boolean setCacheList(final String key, final List<T> dataList) {
        RList<T> rList = redissonClient.getList(key);
        return rList.addAll(dataList);
    }

    /**
     * èŽ·å¾—缓存的set
     *
     * @param key
     * @return
     */
    public <T> Set<T> getCacheSet(final String key)
    {
        return redisTemplate.opsForSet().members(key);
    }
    /**
     * èŽ·å¾—缓存的list对象
     *
     * @param key ç¼“存的键值
     * @return ç¼“存键值对应的数据
     */
    public <T> List<T> getCacheList(final String key) {
        RList<T> rList = redissonClient.getList(key);
        return rList.readAll();
    }

    /**
     * ç¼“å­˜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);
        }
    }
    /**
     * ç¼“å­˜Set
     *
     * @param key     ç¼“存键值
     * @param dataSet ç¼“存的数据
     * @return ç¼“存数据的对象
     */
    public <T> boolean setCacheSet(final String key, final Set<T> dataSet) {
        RSet<T> rSet = redissonClient.getSet(key);
        return rSet.addAll(dataSet);
    }

    /**
     * èŽ·å¾—缓存的Map
     *
     * @param key
     * @return
     */
    public <T> Map<String, T> getCacheMap(final String key)
    {
        return redisTemplate.opsForHash().entries(key);
    }
    /**
     * èŽ·å¾—缓存的set
     *
     * @param key
     * @return
     */
    public <T> Set<T> getCacheSet(final String key) {
        RSet<T> rSet = redissonClient.getSet(key);
        return rSet.readAll();
    }

    /**
     * å¾€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);
    }
    /**
     * ç¼“å­˜Map
     *
     * @param key
     * @param dataMap
     */
    public <T> void setCacheMap(final String key, final Map<String, T> dataMap) {
        if (dataMap != null) {
            RMap<String, T> rMap = redissonClient.getMap(key);
            rMap.putAll(dataMap);
        }
    }

    /**
     * èŽ·å–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);
    }
    /**
     * èŽ·å¾—缓存的Map
     *
     * @param key
     * @return
     */
    public <T> Map<String, T> getCacheMap(final String key) {
        RMap<String, T> rMap = redissonClient.getMap(key);
        return rMap.getAll(rMap.keySet());
    }

    /**
     * èŽ·å–多个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键
     * @param value å€¼
     */
    public <T> void setCacheMapValue(final String key, final String hKey, final T value) {
        RMap<String, T> rMap = redissonClient.getMap(key);
        rMap.put(hKey, value);
    }

    /**
     * èŽ·å¾—缓存的基本对象列表
     *
     * @param pattern å­—符串前缀
     * @return å¯¹è±¡åˆ—表
     */
    public Collection<String> keys(final String pattern)
    {
        return redisTemplate.keys(pattern);
    }
    /**
     * èŽ·å–Hash中的数据
     *
     * @param key  Redis键
     * @param hKey Hash键
     * @return Hash中的对象
     */
    public <T> T getCacheMapValue(final String key, final String hKey) {
        RMap<String, T> rMap = redissonClient.getMap(key);
        return rMap.get(hKey);
    }

    /**
     * èŽ·å–多个Hash中的数据
     *
     * @param key   Redis键
     * @param hKeys Hash键集合
     * @return Hash对象集合
     */
    public <T> List<T> getMultiCacheMapValue(final String key, final Collection<Object> hKeys) {
        RListMultimap rListMultimap = redissonClient.getListMultimap(key);
        return rListMultimap.getAll(hKeys);
    }

    /**
     * èŽ·å¾—缓存的基本对象列表
     *
     * @param pattern å­—符串前缀
     * @return å¯¹è±¡åˆ—表
     */
    public Collection<String> keys(final String pattern) {
        Iterable<String> iterable = redissonClient.getKeys().getKeysByPattern(pattern);
        return Lists.newArrayList(iterable);
    }
}

 ruoyi-framework/src/main/java/com/ruoyi/framework/config/RedisConfig.java

@@ -1,42 +1,69 @@
package com.ruoyi.framework.config;

import com.alibaba.fastjson.support.spring.GenericFastJsonRedisSerializer;
import com.ruoyi.framework.config.properties.RedissonProperties;
import org.redisson.Redisson;
import org.redisson.api.RedissonClient;
import org.redisson.codec.JsonJacksonCodec;
import org.redisson.config.Config;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.boot.autoconfigure.data.redis.RedisProperties;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.StringRedisSerializer;

import java.io.IOException;

/**
 * redis配置
 *
 * @author ruoyi
 * @author Lion Li
 */
@Configuration
@EnableCaching
public class RedisConfig extends CachingConfigurerSupport
{
    @Bean
    @SuppressWarnings(value = { "unchecked", "rawtypes" })
    public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory connectionFactory)
    {
        RedisTemplate<Object, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(connectionFactory);
public class RedisConfig extends CachingConfigurerSupport {

        GenericFastJsonRedisSerializer serializer = new GenericFastJsonRedisSerializer();
        StringRedisSerializer keySerializer = new StringRedisSerializer();
    private static final String REDIS_PROTOCOL_PREFIX = "redis://";
    private static final String REDISS_PROTOCOL_PREFIX = "rediss://";

        // ä½¿ç”¨StringRedisSerializer来序列化和反序列化redis的key值
        template.setKeySerializer(keySerializer);
        template.setValueSerializer(serializer);
    @Autowired
    private RedisProperties redisProperties;

        // Hash的key也采用StringRedisSerializer的序列化方式
        template.setHashKeySerializer(keySerializer);
        template.setHashValueSerializer(serializer);
    @Autowired
    private RedissonProperties redissonProperties;

        template.afterPropertiesSet();
        return template;
    }
    @Bean(destroyMethod = "shutdown")
    @ConditionalOnMissingBean(RedissonClient.class)
    public RedissonClient redisson() throws IOException {
        String prefix = REDIS_PROTOCOL_PREFIX;
        if (redisProperties.isSsl()) {
            prefix = REDISS_PROTOCOL_PREFIX;
        }
        Config config = new Config();
        config.setThreads(redissonProperties.getThreads())
            .setNettyThreads(redissonProperties.getNettyThreads())
            .setCodec(JsonJacksonCodec.INSTANCE)
            .setTransportMode(redissonProperties.getTransportMode());

        RedissonProperties.SingleServerConfig singleServerConfig = redissonProperties.getSingleServerConfig();
        // ä½¿ç”¨å•æœºæ¨¡å¼
        config.useSingleServer()
            .setAddress(prefix + redisProperties.getHost() + ":" + redisProperties.getPort())
            .setConnectTimeout(((Long) redisProperties.getTimeout().toMillis()).intValue())
            .setDatabase(redisProperties.getDatabase())
            .setPassword(redisProperties.getPassword())
            .setTimeout(singleServerConfig.getTimeout())
            .setRetryAttempts(singleServerConfig.getRetryAttempts())
            .setRetryInterval(singleServerConfig.getRetryInterval())
            .setSubscriptionsPerConnection(singleServerConfig.getSubscriptionsPerConnection())
            .setClientName(singleServerConfig.getClientName())
            .setIdleConnectionTimeout(singleServerConfig.getIdleConnectionTimeout())
            .setSubscriptionConnectionMinimumIdleSize(singleServerConfig.getSubscriptionConnectionMinimumIdleSize())
            .setSubscriptionConnectionPoolSize(singleServerConfig.getSubscriptionConnectionPoolSize())
            .setConnectionMinimumIdleSize(singleServerConfig.getConnectionMinimumIdleSize())
            .setConnectionPoolSize(singleServerConfig.getConnectionPoolSize())
            .setDnsMonitoringInterval(singleServerConfig.getDnsMonitoringInterval());
        return Redisson.create(config);
    }
}

 ruoyi-framework/src/main/java/com/ruoyi/framework/config/properties/RedissonProperties.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,101 @@
package com.ruoyi.framework.config.properties;

import lombok.Data;
import lombok.NoArgsConstructor;
import org.redisson.client.codec.Codec;
import org.redisson.config.TransportMode;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

/**
 * Redisson é…ç½®å±žæ€§
 *
 * @author Lion Li
 */
@Data
@Component
@ConfigurationProperties(prefix = "redisson")
public class RedissonProperties {

    /**
     * çº¿ç¨‹æ± æ•°é‡,默认值 = å½“前处理核数量 * 2
     */
    private int threads;

    /**
     * Netty线程池数量,默认值 = å½“前处理核数量 * 2
     */
    private int nettyThreads;

    /**
     * ä¼ è¾“模式
     */
    private TransportMode transportMode;

    /**
     * å•æœºæœåŠ¡é…ç½®
     */
    private SingleServerConfig singleServerConfig;

    @Data
    @NoArgsConstructor
    public static class SingleServerConfig {

        /**
         * å®¢æˆ·ç«¯åç§°
         */
        private String clientName;

        /**
         * æœ€å°ç©ºé—²è¿žæŽ¥æ•°
         */
        private int connectionMinimumIdleSize;

        /**
         * è¿žæŽ¥æ± å¤§å°
         */
        private int connectionPoolSize;

        /**
         * è¿žæŽ¥ç©ºé—²è¶…时，单位：毫秒
         */
        private int idleConnectionTimeout;

        /**
         * å‘½ä»¤ç­‰å¾…超时，单位：毫秒
         */
        private int timeout;

        /**
         * å¦‚果尝试在此限制之内发送成功，则开始启用 timeout è®¡æ—¶ã€‚
         */
        private int retryAttempts;

        /**
         * å‘½ä»¤é‡è¯•å‘送时间间隔，单位：毫秒
         */
        private int retryInterval;

        /**
         * å‘布和订阅连接的最小空闲连接数
         */
        private int subscriptionConnectionMinimumIdleSize;

        /**
         * å‘布和订阅连接池大小
         */
        private int subscriptionConnectionPoolSize;

        /**
         * å•ä¸ªè¿žæŽ¥æœ€å¤§è®¢é˜…数量
         */
        private int subscriptionsPerConnection;

        /**
         * DNS监测时间间隔，单位：毫秒
         */
        private int dnsMonitoringInterval;

    }

}