Spring boot AOP 配置Redis多数据源

最新推荐文章于 2024-04-30 14:52:10 发布
最新推荐文章于 2024-04-30 14:52:10 发布
阅读量551 收藏 1
点赞数 2
文章标签： redis spring boot 数据库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_32321111/article/details/130679588
版权

1、首先配置application.yml

  # 用户redis 配置
  redis:
    # 地址
    host: 192.168.1.15
    # 端口，默认为6379
    port: 6379
    # 数据库索引
    database: 10
    # 密码
    password: 123456
    # 连接超时时间 单位：s
    timeout: 10
    # 连接池中的最小空闲连接
    lettuce-pool-min-idle: 0
    # 连接池中的最大空闲连接
    lettuce-pool-max-idle: 8
    # 连接池的最大数据库连接数
    lettuce-pool-max-active: 8
    # #连接池最大阻塞等待时间（使用负值表示没有限制）单位：ms
    lettuce-pool-max-wait: -1
  # 订单redis 配置
  redis-order:
    # 地址
    host: 192.168.1.15
    # 端口，默认为6379
    port: 6379
    # 数据库索引
    database: 11
    # 密码
    password: 123456
    # 连接超时时间 单位：s
    timeout: 10
    # 连接池中的最小空闲连接
    lettuce-pool-min-idle: 0
    # 连接池中的最大空闲连接
    lettuce-pool-max-idle: 8
    # 连接池的最大数据库连接数
    lettuce-pool-max-active: 8
    # #连接池最大阻塞等待时间（使用负值表示没有限制）单位：ms
    lettuce-pool-max-wait: -1
  # 其他redis 配置
  redis-other:
    # 地址
    host: 192.168.1.15
    # 端口，默认为6379
    port: 6379
    # 数据库索引
    database: 12
    # 密码
    password: 123456
    # 连接超时时间 单位：s
    timeout: 10
    # 连接池中的最小空闲连接
    lettuce-pool-min-idle: 0
    # 连接池中的最大空闲连接
    lettuce-pool-max-idle: 8
    # 连接池的最大数据库连接数
    lettuce-pool-max-active: 8
    # #连接池最大阻塞等待时间（使用负值表示没有限制）单位：ms
    lettuce-pool-max-wait: -1

2、配置连接参数信息Properties

package com.ruoyi.framework.config.properties;


import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

@Data
@Component
@ConfigurationProperties
public class RedisProperties {
    //最大活跃数
    private int lettucePoolMaxActive;
    //最大等待数
    private int lettucePoolMaxWait;
    //最大核心线程数
    private int lettucePoolMaxIdle;
    //最小核心线程数
    private int lettucePoolMinIdle;
    //redis连接的超时时长
    private int timeOut;
    //redis连接的库
    private int database;
    //单节点情况下redis的ip
    private String host;
    //单节点情况下redis的端口
    private Integer port;
    //redis的连接密码
    private String password;
}

3、配置Config文件

package com.ruoyi.framework.config;

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.JsonTypeInfo;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.jsontype.impl.LaissezFaireSubTypeValidator;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.framework.config.properties.RedisProperties;
import org.apache.commons.pool2.impl.GenericObjectPoolConfig;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.context.properties.ConfigurationProperties;
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.context.annotation.Primary;
import org.springframework.data.redis.connection.RedisStandaloneConfiguration;
import org.springframework.data.redis.connection.lettuce.LettuceClientConfiguration;
import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
import org.springframework.data.redis.connection.lettuce.LettucePoolingClientConfiguration;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.script.DefaultRedisScript;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import org.springframework.stereotype.Component;

import java.time.Duration;


@Configuration
@EnableCaching
@Component
public class RedisConfig extends CachingConfigurerSupport
{
    @Bean
    @ConfigurationProperties(prefix = "spring.redis-other")
    public RedisProperties otherProperties() {
        return new RedisProperties();
    }

    @Bean
    @ConfigurationProperties(prefix = "spring.redis")
    public RedisProperties  defaultProperties() {
        return new RedisProperties();
    }

    @Bean
    @ConfigurationProperties(prefix = "spring.redis-order")
    public RedisProperties  orderProperties() {
        return new RedisProperties();
    }

    /**
     * 用户
     */
    @Primary
    @Bean
    @Qualifier("defaultConnectionFactory")
    public RedisTemplate<String, Object> redisTemplate(@Qualifier("defaultConnectionFactory") LettuceConnectionFactory userConnectionFactory) {
        return getTemplate(userConnectionFactory);
    }

    /**
     * 订单
     */
    @Bean
    @Qualifier("orderConnectionFactory")
    public RedisTemplate<String, Object> redisOrderTemplate(@Qualifier("orderConnectionFactory") LettuceConnectionFactory orderConnectionFactory) {
        return getTemplate(orderConnectionFactory);
    }

    /**
     * 其他
     */
    @Bean
    @Qualifier("otherConnectionFactory")
    public RedisTemplate<String, Object> redisOtherTemplate(@Qualifier("otherConnectionFactory") LettuceConnectionFactory otherConnectionFactory) {
        return getTemplate(otherConnectionFactory);
    }

    private RedisTemplate<String, Object> getTemplate(LettuceConnectionFactory factory) {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(factory);
        Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<>(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES,false);
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.activateDefaultTyping(LaissezFaireSubTypeValidator.instance ,
                ObjectMapper.DefaultTyping.NON_FINAL, JsonTypeInfo.As.PROPERTY);
        jackson2JsonRedisSerializer.setObjectMapper(om);
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
        // key采用String的序列化方式
        template.setKeySerializer(stringRedisSerializer);
        // hash的key也采用String的序列化方式
        template.setHashKeySerializer(stringRedisSerializer);
        // value序列化方式采用jackson
        template.setValueSerializer(jackson2JsonRedisSerializer);
        // hash的value序列化方式采用jackson
        template.setHashValueSerializer(jackson2JsonRedisSerializer);
        template.afterPropertiesSet();
        return template;
    }

    /**
     * 用户连接配置
     */
    @Primary
    @Bean
    public LettuceConnectionFactory defaultConnectionFactory(@Qualifier("defaultConnectionFactory") RedisProperties defaultProperties) {
        return getFactory(defaultProperties);
    }

    /**
     * 其他连接配置
     */
    @Bean
    public LettuceConnectionFactory otherConnectionFactory(@Qualifier("otherConnectionFactory") RedisProperties otherProperties) {
        return getFactory(otherProperties);
    }

    /**
     * 订单连接配置
     */
    @Bean
    public LettuceConnectionFactory orderConnectionFactory(@Qualifier("orderConnectionFactory") RedisProperties orderProperties) {
        return getFactory(orderProperties);
    }

    private LettuceConnectionFactory getFactory(RedisProperties redisProperties) {
        RedisStandaloneConfiguration redisStandaloneConfiguration;
        //连接池配置
        GenericObjectPoolConfig genericObjectPoolConfig =
                new GenericObjectPoolConfig();
        genericObjectPoolConfig.setMaxTotal(redisProperties.getLettucePoolMaxActive());
        genericObjectPoolConfig.setMaxWaitMillis(redisProperties.getLettucePoolMaxWait());
        genericObjectPoolConfig.setMaxIdle(redisProperties.getLettucePoolMaxIdle());
        genericObjectPoolConfig.setMinIdle(redisProperties.getLettucePoolMinIdle());

        //redis客户端配置
        LettucePoolingClientConfiguration.LettucePoolingClientConfigurationBuilder
                builder =  LettucePoolingClientConfiguration.builder().
                commandTimeout(Duration.ofSeconds(redisProperties.getTimeOut()));
        builder.poolConfig(genericObjectPoolConfig);
        LettuceClientConfiguration lettuceClientConfiguration = builder.build();

        //单机模式
        redisStandaloneConfiguration = new RedisStandaloneConfiguration(redisProperties.getHost(),redisProperties.getPort());
        redisStandaloneConfiguration.setDatabase(redisProperties.getDatabase());

        if(!StringUtils.isEmpty(redisProperties.getPassword())){
            redisStandaloneConfiguration.setPassword(redisProperties.getPassword());
        }
        //根据配置和客户端配置创建连接工厂
        LettuceConnectionFactory lettuceConnectionFactory = new
                LettuceConnectionFactory(redisStandaloneConfiguration,lettuceClientConfiguration);
        // 关闭共享链接
        lettuceConnectionFactory.setShareNativeConnection(false);
        return lettuceConnectionFactory;
    }

    @Bean
    public DefaultRedisScript<Long> limitScript() {
        DefaultRedisScript<Long> redisScript = new DefaultRedisScript<>();
        redisScript.setScriptText(limitScriptText());
        redisScript.setResultType(Long.class);
        return redisScript;
    }

    /**
     * 限流脚本
     */
    private String limitScriptText() {
        return "local key = KEYS[1]\n" +
                "local count = tonumber(ARGV[1])\n" +
                "local time = tonumber(ARGV[2])\n" +
                "local current = redis.call('get', key);\n" +
                "if current and tonumber(current) > count then\n" +
                "    return tonumber(current);\n" +
                "end\n" +
                "current = redis.call('incr', key)\n" +
                "if tonumber(current) == 1 then\n" +
                "    redis.call('expire', key, time)\n" +
                "end\n" +
                "return tonumber(current);";
    }
}

4、创建自定义注解

（1）RedisStaticDataSource静态注解

package com.ruoyi.common.annotation;


import java.lang.annotation.*;

/**
 * redis根据指定名称切换注解
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface RedisStaticDataSource {
    /**
     * redis库
     */
    String value() default "";
}

 

（2）RedisDynamicDataSource动态注解

package com.ruoyi.common.annotation;


import java.lang.annotation.*;

/**
 * redis动态识别入参,读取不同的缓存实例
 */
@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface RedisDynamicDataSource {
}

5、创建ContextHolder

package com.ruoyi.common.utils;

import com.alibaba.ttl.TransmittableThreadLocal;
import org.springframework.data.redis.core.RedisTemplate;

public class RedisThreadLocalUtils {
    private static final TransmittableThreadLocal<RedisTemplate<String, Object>> TEMPLATE_THREAD_LOCAL =
            new TransmittableThreadLocal<>();

    public static RedisTemplate<String, Object> getTemplate() {
        return TEMPLATE_THREAD_LOCAL.get();
    }

    public static void setTemplate(RedisTemplate<String, Object> template) {
        TEMPLATE_THREAD_LOCAL.set(template);
    }

    public static void remove() {
        TEMPLATE_THREAD_LOCAL.remove();
    }
}

6、创建AOP切面

package com.ruoyi.framework.config;

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.JsonTypeInfo;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.jsontype.impl.LaissezFaireSubTypeValidator;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.framework.config.properties.RedisProperties;
import org.apache.commons.pool2.impl.GenericObjectPoolConfig;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.context.properties.ConfigurationProperties;
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.context.annotation.Primary;
import org.springframework.data.redis.connection.RedisStandaloneConfiguration;
import org.springframework.data.redis.connection.lettuce.LettuceClientConfiguration;
import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
import org.springframework.data.redis.connection.lettuce.LettucePoolingClientConfiguration;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.script.DefaultRedisScript;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import org.springframework.stereotype.Component;

import java.time.Duration;


@Configuration
@EnableCaching
@Component
public class RedisConfig extends CachingConfigurerSupport
{
    @Bean
    @ConfigurationProperties(prefix = "spring.redis-other")
    public RedisProperties otherProperties() {
        return new RedisProperties();
    }

    @Bean
    @ConfigurationProperties(prefix = "spring.redis")
    public RedisProperties  defaultProperties() {
        return new RedisProperties();
    }

    @Bean
    @ConfigurationProperties(prefix = "spring.redis-order")
    public RedisProperties  orderProperties() {
        return new RedisProperties();
    }

    /**
     * 用户
     */
    @Primary
    @Bean
    @Qualifier("redisTemplate")
    public RedisTemplate<String, Object> redisTemplate(@Qualifier("defaultConnectionFactory") LettuceConnectionFactory userConnectionFactory) {
        return getTemplate(userConnectionFactory);
    }

    /**
     * 订单
     */
    @Bean
    @Qualifier("redisOrderTemplate")
    public RedisTemplate<String, Object> redisOrderTemplate(@Qualifier("orderConnectionFactory") LettuceConnectionFactory orderConnectionFactory) {
        return getTemplate(orderConnectionFactory);
    }

    /**
     * 其他
     */
    @Bean
    @Qualifier("redisOtherTemplate")
    public RedisTemplate<String, Object> redisOtherTemplate(@Qualifier("otherConnectionFactory") LettuceConnectionFactory otherConnectionFactory) {
        return getTemplate(otherConnectionFactory);
    }

    private RedisTemplate<String, Object> getTemplate(LettuceConnectionFactory factory) {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(factory);
        Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<>(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES,false);
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.activateDefaultTyping(LaissezFaireSubTypeValidator.instance ,
                ObjectMapper.DefaultTyping.NON_FINAL, JsonTypeInfo.As.PROPERTY);
        jackson2JsonRedisSerializer.setObjectMapper(om);
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
        // key采用String的序列化方式
        template.setKeySerializer(stringRedisSerializer);
        // hash的key也采用String的序列化方式
        template.setHashKeySerializer(stringRedisSerializer);
        // value序列化方式采用jackson
        template.setValueSerializer(jackson2JsonRedisSerializer);
        // hash的value序列化方式采用jackson
        template.setHashValueSerializer(jackson2JsonRedisSerializer);
        template.afterPropertiesSet();
        return template;
    }

    /**
     * 用户连接配置
     */
    @Primary
    @Bean
    public LettuceConnectionFactory defaultConnectionFactory(@Qualifier("defaultProperties") RedisProperties defaultProperties) {
        return getFactory(defaultProperties);
    }

    /**
     * 其他连接配置
     */
    @Bean
    public LettuceConnectionFactory otherConnectionFactory(@Qualifier("otherProperties") RedisProperties otherProperties) {
        return getFactory(otherProperties);
    }

    /**
     * 订单连接配置
     */
    @Bean
    public LettuceConnectionFactory orderConnectionFactory(@Qualifier("orderProperties") RedisProperties orderProperties) {
        return getFactory(orderProperties);
    }

    private LettuceConnectionFactory getFactory(RedisProperties redisProperties) {
        RedisStandaloneConfiguration redisStandaloneConfiguration;
        //连接池配置
        GenericObjectPoolConfig genericObjectPoolConfig =
                new GenericObjectPoolConfig();
        genericObjectPoolConfig.setMaxTotal(redisProperties.getLettucePoolMaxActive());
        genericObjectPoolConfig.setMaxWaitMillis(redisProperties.getLettucePoolMaxWait());
        genericObjectPoolConfig.setMaxIdle(redisProperties.getLettucePoolMaxIdle());
        genericObjectPoolConfig.setMinIdle(redisProperties.getLettucePoolMinIdle());

        //redis客户端配置
        LettucePoolingClientConfiguration.LettucePoolingClientConfigurationBuilder
                builder =  LettucePoolingClientConfiguration.builder().
                commandTimeout(Duration.ofSeconds(redisProperties.getTimeOut()));
        builder.poolConfig(genericObjectPoolConfig);
        LettuceClientConfiguration lettuceClientConfiguration = builder.build();

        //单机模式
        redisStandaloneConfiguration = new RedisStandaloneConfiguration(redisProperties.getHost(),redisProperties.getPort());
        redisStandaloneConfiguration.setDatabase(redisProperties.getDatabase());

        if(!StringUtils.isEmpty(redisProperties.getPassword())){
            redisStandaloneConfiguration.setPassword(redisProperties.getPassword());
        }
        //根据配置和客户端配置创建连接工厂
        LettuceConnectionFactory lettuceConnectionFactory = new
                LettuceConnectionFactory(redisStandaloneConfiguration,lettuceClientConfiguration);
        // 关闭共享链接
        lettuceConnectionFactory.setShareNativeConnection(false);
        return lettuceConnectionFactory;
    }

    @Bean
    public DefaultRedisScript<Long> limitScript() {
        DefaultRedisScript<Long> redisScript = new DefaultRedisScript<>();
        redisScript.setScriptText(limitScriptText());
        redisScript.setResultType(Long.class);
        return redisScript;
    }

    /**
     * 限流脚本
     */
    private String limitScriptText() {
        return "local key = KEYS[1]\n" +
                "local count = tonumber(ARGV[1])\n" +
                "local time = tonumber(ARGV[2])\n" +
                "local current = redis.call('get', key);\n" +
                "if current and tonumber(current) > count then\n" +
                "    return tonumber(current);\n" +
                "end\n" +
                "current = redis.call('incr', key)\n" +
                "if tonumber(current) == 1 then\n" +
                "    redis.call('expire', key, time)\n" +
                "end\n" +
                "return tonumber(current);";
    }
}

7、创建RedisCache模版

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.ruoyi.common.utils.RedisThreadLocalUtils;
import org.springframework.beans.factory.annotation.Qualifier;
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;

@SuppressWarnings(value = { "unchecked", "rawtypes" })
@Component
public class RedisCache
{
    private final RedisTemplate<String, Object> redisTemplate;

    public RedisCache(@Qualifier("redisTemplate") RedisTemplate<String, Object> redisTemplate) {
        this.redisTemplate = redisTemplate;
    }


    private RedisTemplate<String, Object> getRedsTemplate() {
        RedisTemplate<String, Object> template = RedisThreadLocalUtils.getTemplate();
        if (null == template) {
            return redisTemplate;
        }
        return template;
    }

    /**
     * 缓存基本的对象，Integer、String、实体类等
     *
     * @param key   缓存的键值
     * @param value 缓存的值
     */
    public <T> void setCacheObject(final String key, final T value) {
        getRedsTemplate().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) {
        getRedsTemplate().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 getRedsTemplate().expire(key, timeout, unit);
    }

    /**
     * 获取有效时间
     *
     * @param key Redis键
     * @return 有效时间
     */
    public long getExpire(final String key) {
        return getRedsTemplate().getExpire(key);
    }

    /**
     * 判断 key是否存在
     *
     * @param key 键
     * @return true 存在 false不存在
     */
    public Boolean hasKey(String key) {
        return getRedsTemplate().hasKey(key);
    }

    /**
     * 获得缓存的基本对象。
     *
     * @param key 缓存键值
     * @return 缓存键值对应的数据
     */
    public <T> T getCacheObject(final String key) {
        ValueOperations<String, Object> operation = getRedsTemplate().opsForValue();
        return (T)operation.get(key);
    }

    /**
     * 删除单个对象
     *
     * @param key
     */
    public boolean deleteObject(final String key) {
        return getRedsTemplate().delete(key);
    }

    /**
     * 删除集合对象
     *
     * @param collection 多个对象
     * @return
     */
    public boolean deleteObject(final Collection collection) {
        return getRedsTemplate().delete(collection) > 0;
    }

    /**
     * 缓存List数据
     *
     * @param key      缓存的键值
     * @param dataList 待缓存的List数据
     * @return 缓存的对象
     */
    public <T> long setCacheList(final String key, final List<T> dataList) {
        Long count = getRedsTemplate().opsForList().rightPushAll(key, dataList);
        return count == null ? 0 : count;
    }

    /**
     * 获得缓存的list对象
     *
     * @param key 缓存的键值
     * @return 缓存键值对应的数据
     */
    public <T> List<T> getCacheList(final String key) {
        return (List<T>) getRedsTemplate().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 = (BoundSetOperations<String, T>) getRedsTemplate().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 (Set<T>) getRedsTemplate().opsForSet().members(key);
    }

    /**
     * 缓存Map
     *
     * @param key
     * @param dataMap
     */
    public <T> void setCacheMap(final String key, final Map<String, T> dataMap) {
        if (dataMap != null) {
            getRedsTemplate().opsForHash().putAll(key, dataMap);
        }
    }

    /**
     * 获得缓存的Map
     *
     * @param key
     * @return
     */
    public <T> Map<Object, Object> getCacheMap(final String key) {
        return getRedsTemplate().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) {
        getRedsTemplate().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 = getRedsTemplate().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 (List<T>) getRedsTemplate().opsForHash().multiGet(key, hKeys);
    }

    /**
     * 删除Hash中的某条数据
     *
     * @param key  Redis键
     * @param hKey Hash键
     * @return 是否成功
     */
    public boolean deleteCacheMapValue(final String key, final String hKey) {
        return getRedsTemplate().opsForHash().delete(key, hKey) > 0;
    }

    /**
     * 获得缓存的基本对象列表
     *
     * @param pattern 字符串前缀
     * @return 对象列表
     */
    public Collection<String> keys(final String pattern) {
        return getRedsTemplate().keys(pattern);
    }
}

8、调用redis库多数据源（默认：用户redis实例）

redis库静态数据源切换

    //在需要使用多数据源方法或类上添加@RedisStaticDataSource，其中value用来表示数据源
    @RedisStaticDataSource("redisOrderTemplate")
    public void deleteInfo(String id) {
        redisCache.setCacheObject(id,"100");
    }

redis库动态数据源切换

    //在需要使用动态多数据源方法上添加@RedisDynamicDataSource，入参中需要传入“dynamicKey：0用户 1订单 2其他”
    @RedisDynamicDataSource
    public void selectUserList(Long id,Integer dynamicKey)
    {
        redisCache.setCacheObject(id,"100");
    }

注：当前采用的是Ruoyi分离单体框架做的修改，请结合实际修改。

 

仅供参考，希望对您有所帮助，感谢阅读。

注：本文章，是从各大网站、各位道友以及老师等处学习，自己总结做的一些笔记，不对的地方望海涵，如有问题，请及时联系。

奔跑的曉碼農
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
boot-multi-datasource:SpringBoot项目中的多数据源支持+redis缓存
05-11
在SpringBoot项目中，多数据源支持和Redis缓存是两个重要的技术概念，它们能够帮助企业构建灵活、可扩展的应用系统。下面将详细讲解这两个主题及其相互结合的实践应用。 一、SpringBoot多数据源支持 1. **多数据源...
基于Springboot+Mybatis+ SpringMvc+springsecrity+Redis完整网站后台管理系统
10-31
数据源监控：druid 接口swagger文档 日志查询 邮件管理：发送邮件、搜索邮件 文件管理：上传文件、文件列表、文件删除 公告管理：公告未读提醒、发布公告、查询公告、公告阅读人列表 excel下载：自定义sql导出...
【实践篇】4.11 SpringBoot Redis 配置多数据源
日拱一卒无有尽，功不唐捐终入海
07-20 2405
使用 RedisTemplate 支持多个 Redis 数据库。
Springboot配置Redis多数据源
Print_lin的博客
08-02 3807
Springboot默认支持一路redis，项目中有需求用到redis多数据源。本文仅基于Springboot进行多数据源配置，不依赖其它JAR包支持，理论可配置无限多的redis连接。
springboot + redis 实现多数据源
最新发布
qq_50761817的博客
04-30 211
【代码】springboot + redis 实现多数据源。
Spring Boot 整合多 Redis 数据源配置及操作
qq_45607784的博客
01-04 2768
本文档介绍了如何在Spring Boot应用程序中配置和操作多个Redis数据源。通过配置多个RedisConnectionFactory和RedisTemplate，可以实现对多个Redis数据源的整合，以便在应用程序中灵活地使用不同的Redis实例。通过本文档的指导，您将能够轻松地在Spring Boot应用程序中实现对多个Redis数据源的整合配置和操作，从而满足不同业务场景下对多个Redis实例的需求。
redis配置多数据源发布订阅
henbaidexiaobai的博客
06-29 486
针对于redis在多数据源的场景下进行消息发布，订阅
SpringBoot+redis RedisTemplate/jedis 配置多个数据源 灵活切库 选择库
weixin_45220510的博客
06-26 3451
SpringBoot+redis RedisTemplate/jedis 配置多个数据源 灵活切库 选择库 1.加入依赖并在在yml 文件里面加入配置spring:redis:host: urlport: 6379pool:database:db10: 10db4: 4我这里选择redis的 10号库和4号库，如果不同 请自行添加 db0:0 比如再添加一个0号库使用2.添加配置文件/***/@Bean// 配置redis连接池// 构建工厂对象.build();// 设置使用的redis数据库。
spring 快速开发工具包，读写分离，多数据源，自动集成了mybatis,redis,seata等.zip
01-04
这个工具包包含了多种功能模块，如读写分离、多数据源支持，以及对Mybatis、Sharding-JDBC、Redis和Seata等流行技术的集成。 1. **Spring框架**：Spring是Java开发中最广泛使用的应用框架之一，提供了依赖注入（DI...
Spring、Java、redis、zk、MySQL等面试题总结
05-02
5. Spring Boot：Spring Boot简化了Spring应用的初始搭建以及开发过程，它默认配置了很多常见功能，如嵌入式Web服务器、数据源、缓存等。 6. Spring Data JPA：用于简化数据库访问，支持JPA规范，提供了一种统一的...
jsboot-admin：spring-boot企业项目脚手架
01-29
Redis jwt mybatis / jdbcTemplate任选定时任务内置用户-角色-权限控制多角色免重登切换模块标签页切换免刷新AOP实现多数据源动态切换（分支：multi-datasource）运行截图说明如有任何问题欢迎在问题中讨论
Springboot配置多个redis连接
尚未佩妥剑 转眼便江湖
08-11 3181
【代码】Springboot配置多个redis连接。
SpringBoot连接多个Redis或者Redis里的多个不同的库
Mr_XiMu的博客
11-08 9695
SpringBoot连接多个Redis或者Redis里的多个不同的库
Redis配置多数据源
FirstMrRight的博客
03-15 3269
使用场景 Redis具有多个databases，通过CONFIG GET databases命令可查看，Redis不同的database间具有数据隔离性，即在项目中我们配置一个databases 0信息后，并无法获取其他databases的数据，所以，当我们业务中需要获取其他databases时，便需要配置多Redis数据源。 配置文件 以properties为例 #redis databases 1 spring.redis.database=1 spring.redis.host=127.0.0.1
（Redis使用系列） Springboot 实现Redis 同数据源动态切换db 八
默默不代表沉默
06-02 4316
默认redis使用的是db 0，而我们自己在配置连接的时候可以设置默认使用db ，如： 那么怎么去实现动态去切换自己想使用的db呢？ 先回顾性我们在配置redis的时候，连接redis使用的代码段（举例StirngRedisTemplate）： 那么切换也是同理，就是传入factory的时候，设置好选择的db： 新建RedisDBChangeUtil.java： import org.springframework.beans.factory.annotation.Autowired..
SpringBoot使用Redis缓存
诗人不写诗
08-07 4280
本文基于SpringBoot2.2.8 在SpringBooot中引入一个组件，往往只需要引入一个starter，他会帮你将所有相关依赖自动引入，大大简化了使用流程。 一、使用步骤 通过starter引入所有依赖，只需一个依赖即可完成所有相关依赖的引入： <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-dat
spring-data-redis独立创建对象，针对多个redis数据源
码灵的博客
03-29 227
一般集成spring-boot 使用，当连接多个数据源，不具备初始化加载参数时，独自创建stringRedisTemplate对象。
SpringBoot中实现连接多个Redis分别读写数据
BADAO_LIUMANG_QIZHI的博客
10-11 1909
场景 在SpringBoot项目中需要连接两个Redis实例，并实现从A中获取数据并存取到B中。 另外A中redis的地址和密码不能外漏，则将A的地址和密码写在jar包中，B中redis参数可以在外置 配置文件application.yml中进行动态配置。 注： 博客：BADAO_LIUMANG_QIZHI的博客_霸道流氓气质_CSDN博客 关注公众号 霸道的程序猿 获取编程相关电子书、教程推送与免费下载。 实现 1、新建SpringBoot项目并添加依赖 ​ <de...
spring boot aop
05-13
Spring Boot AOP（面向切面编程）是 Spring Boot 框架的一个重要特性，它可以让你在程序运行期间动态地将代码横切到方法调用的过程中，从而实现一些通用的功能，如日志记录、性能监控、事务管理等。 在 Spring Boot...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值