redis集群实现

最新推荐文章于 2024-08-15 18:52:07 发布
最新推荐文章于 2024-08-15 18:52:07 发布
阅读量976 收藏
点赞数 1
分类专栏： 框架
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jakeswang/article/details/77570092
版权
1.xml 配置

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:cache="http://www.springframework.org/schema/cache"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
            http://www.springframework.org/schema/beans/spring-beans.xsd
            http://www.springframework.org/schema/cache
            http://www.springframework.org/schema/cache/spring-cache.xsd">

    <!-- 用于java bean存redis序列化  -->
    <bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate">
        <property name="connectionFactory" ref="redisConnectionFactory"/>
        <property name="keySerializer">
            <bean class="org.springframework.data.redis.serializer.StringRedisSerializer"/>
        </property>
        <property name="valueSerializer">
            <bean class="org.springframework.data.redis.serializer.JdkSerializationRedisSerializer"/>
        </property>
        <property name="hashKeySerializer">
            <bean class="org.springframework.data.redis.serializer.StringRedisSerializer"/>
        </property>
        <property name="hashValueSerializer">
            <bean class="org.springframework.data.redis.serializer.JdkSerializationRedisSerializer"/>
        </property>
    </bean>

    <!-- 用于基础对象存储 -->
    <bean id="stringRedisTemplate" class="org.springframework.data.redis.core.RedisTemplate">
        <property name="connectionFactory" ref="redisConnectionFactory"/>
        <property name="keySerializer">
            <bean class="org.springframework.data.redis.serializer.StringRedisSerializer"/>
        </property>
        <property name="valueSerializer">
            <bean class="org.springframework.data.redis.serializer.StringRedisSerializer"/>
        </property>
        <property name="hashKeySerializer">
            <bean class="org.springframework.data.redis.serializer.StringRedisSerializer"/>
        </property>
        <property name="hashValueSerializer">
            <bean class="org.springframework.data.redis.serializer.StringRedisSerializer"/>
        </property>
    </bean>

    <!-- turn on declarative caching -->
    <cache:annotation-driven/>
    <!-- declare Redis Cache Manager -->
    <bean id="cacheManager" class="org.springframework.data.redis.cache.RedisCacheManager">
        <constructor-arg ref="redisTemplate"></constructor-arg>
    </bean>

</beans>


2.redis.propties

system.cache.enable=true
redis.type=cluster
redis.cluster.url=10.200.2.105:7000,10.200.2.105:7001,10.200.2.105:7002,10.200.2.105:7003,10.200.2.105:7004,10.200.2.105:7005
redis.single.url=192.168.0.63:12200


3.pom.xml


    <!-- redis -->
        <dependency>
            <groupId>biz.paluch.redis</groupId>
            <artifactId>lettuce</artifactId>
            <version>4.3.2.Final</version>
        </dependency>

        <dependency>
            <groupId>org.springframework.data</groupId>
            <artifactId>spring-data-redis</artifactId>
            <version>1.8.3.RELEASE</version>
        </dependency>


4.redis config ,java类


package com.lvtu.csa.framework.conf;

import java.util.Set;

import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisClusterConfiguration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.RedisNode;
import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;

import com.google.common.collect.Sets;


@Configuration
public class RedisConfig {

    private static final Logger LOGGER = LoggerFactory.getLogger(RedisConfig.class);

    @Value("${redis.type}")
    private String type;

    @Value("${redis.cluster.url}")
    private String REDIS_CLUSTER_URL;

    @Value("${redis.single.url}")
    private String REDIS_SINGLE_URL;

    @Bean(name = "redisNodes")
    public Iterable<RedisNode> getRedisNodes() {
        if(StringUtils.isBlank(REDIS_CLUSTER_URL)) {
            LOGGER.warn("REDIS配置文件为空");
            return null;
        }

        String[] urls = StringUtils.split(REDIS_CLUSTER_URL, ',');
        Set<RedisNode> nodes = Sets.newHashSetWithExpectedSize(urls.length);

        for (String url : urls) {
            String[] splits = url.split(":");
            nodes.add(new RedisNode(splits[0], Integer.parseInt(splits[1])));
        }
        return nodes;
    }

    @Bean(name = "redisClusterConfiguration")
    public RedisClusterConfiguration getClusterConfiguration(Iterable<RedisNode> redisNodes) {
        if(redisNodes == null) {
            return null;
        }

        RedisClusterConfiguration configuration = new RedisClusterConfiguration();
        configuration.setClusterNodes(redisNodes);
        configuration.setMaxRedirects(5);
        return configuration;
    }

    @Bean(name = "redisConnectionFactory")
    public RedisConnectionFactory getRedisConnectionFactory(RedisClusterConfiguration redisClusterConfiguration) {
        if("single".equals(type)) {
            if(StringUtils.isEmpty(REDIS_SINGLE_URL) || !REDIS_SINGLE_URL.contains(":")) {
                throw new RuntimeException("请检查redis配置，单点配置不正确");
            }

            String[] split = REDIS_SINGLE_URL.split(":");
            return new LettuceConnectionFactory(split[0], Integer.parseInt(split[1]));
        }

        if("cluster".equals(type)) {
            if(redisClusterConfiguration == null) {
                throw new RuntimeException("请检查redis配置，集群配置不正确");
            }

            return new LettuceConnectionFactory(redisClusterConfiguration);
        }
        return null;
    }
}

redis 工具类方法


package com.lvtu.csa.framework.cache;

import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import org.springframework.util.Assert;

import java.util.concurrent.TimeUnit;

/**
 * Created by Administrator on 2016/9/22.
 */
@Component
public class RedisCache {

    @Autowired
    RedisTemplate<String, Object> redisTemplate;

    public Object get(CacheKey cacheKey) {
        Assert.hasText(cacheKey.getKey(), "缓存KEY不能为空");

        if(StringUtils.isEmpty(cacheKey.getName())) {
            return redisTemplate.opsForValue().get(cacheKey.getKey());
        } else {
            return redisTemplate.opsForHash().get(cacheKey.getName(), cacheKey.getKey());
        }
    }

    public void put(CacheKey cacheKey, Object result) {
        Assert.hasText(cacheKey.getKey(), "缓存KEY不能为空");

        if(StringUtils.isEmpty(cacheKey.getName())) {
            redisTemplate.opsForValue().set(cacheKey.getKey(), result);
        } else {
            redisTemplate.opsForHash().put(cacheKey.getName(), cacheKey.getKey(), result);
        }
    }

    public void put(CacheKey cacheKey, Object result, int second) {
        Assert.hasText(cacheKey.getKey(), "缓存KEY不能为空");

        if(StringUtils.isEmpty(cacheKey.getName())) {
            redisTemplate.opsForValue().set(cacheKey.getKey(), result, second, TimeUnit.SECONDS);
        } else {
            redisTemplate.opsForHash().put(cacheKey.getName(), cacheKey.getKey(), result);
            redisTemplate.expire(cacheKey.getName(), second, TimeUnit.SECONDS);
        }
    }

    public void evict(CacheKey cacheKey) {
        Assert.hasText(cacheKey.getKey(), "缓存KEY不能为空");

        if(StringUtils.isEmpty(cacheKey.getName())) {
            redisTemplate.delete(cacheKey.getKey());
        } else {
            redisTemplate.opsForHash().delete(cacheKey.getName(), cacheKey.getKey());
        }
    }

}

redis注解自动生成：

package com.lvtu.csa.framework.cache;

import com.google.common.collect.Lists;
import com.lvtu.csa.framework.annotation.CacheEvict;
import com.lvtu.csa.framework.annotation.Cacheable;
import com.lvtu.csa.framework.aspect.CacheAspect;
import org.springframework.expression.EvaluationContext;
import org.springframework.util.ObjectUtils;
import org.springframework.util.StringUtils;

import java.lang.reflect.Method;
import java.util.List;

/**
 * Created by Administrator on 2016/9/22.
 */
public abstract class CacheAspectSupport {

    private final ExpressionEvaluator evaluator = new ExpressionEvaluator();
    private SimpleKeyGenerator keyGenerator = new SimpleKeyGenerator();

    protected CacheOperationContext getOperationContext(Method method, Object[] args, Object target, Class<?> targetClass) {
        return new CacheOperationContext(method, args, target, targetClass);
    }

    protected class CacheOperationContext {
        private final Method method;
        private final Object[] args;
        private final Object target;
        private final Class<?> targetClass;
        private final MethodCacheKey methodCacheKey;

        public CacheOperationContext(Method method, Object[] args, Object target, Class<?> targetClass) {
            this.method = method;
            this.args = extractArgs(method, args);
            this.target = target;
            this.targetClass = targetClass;
            this.methodCacheKey = new MethodCacheKey(method, targetClass);
        }

        public Object getTarget() {
            return this.target;
        }

        public Method getMethod() {
            return method;
        }

        public Object[] getArgs() {
            return this.args;
        }

        public Class<?> getTargetClass() {
            return targetClass;
        }

        private Object[] extractArgs(Method method, Object[] args) {
            if (!method.isVarArgs()) {
                return args;
            }
            Object[] varArgs = ObjectUtils.toObjectArray(args[args.length - 1]);
            Object[] combinedArgs = new Object[args.length - 1 + varArgs.length];
            System.arraycopy(args, 0, combinedArgs, 0, args.length - 1);
            System.arraycopy(varArgs, 0, combinedArgs, args.length - 1, varArgs.length);
            return combinedArgs;
        }

        /**
         * Compute the key for the given caching operation.
         *
         * @return the generated key, or {@code null} if none can be generated
         */
        public CacheKey generateKey(Cacheable cacheable, CacheOperationContext result) {

            if (StringUtils.hasText(cacheable.key())) {
                EvaluationContext evaluationContext = createEvaluationContext(result);
                String key = evaluator.key(cacheable.key(), this.methodCacheKey, evaluationContext).toString();

                if(StringUtils.hasText(cacheable.name())) {
                    String name = evaluator.key(cacheable.name(), this.methodCacheKey, evaluationContext).toString();
                    return CacheKey.create(CacheAspect.LVTU_CACHE_PREFIX + name, key);
                } else {
                    return CacheKey.create(CacheAspect.LVTU_CACHE_PREFIX + key);
                }
            }
            return CacheKey.create(keyGenerator.generate(this, cacheable));
        }

        public List<CacheKey> generateKey(CacheEvict cacheEvict, CacheOperationContext result) {

            List<CacheKey> cacheKeys = Lists.newArrayList();
            EvaluationContext evaluationContext = createEvaluationContext(result);

            for (String key : cacheEvict.key()) {
                cacheKeys.add(CacheKey.create(evaluator.key(key, this.methodCacheKey, evaluationContext).toString()));
            }
            return cacheKeys;
        }

        private EvaluationContext createEvaluationContext(Object result) {
            return evaluator.createEvaluationContext(this.method, this.args, this.target, this.targetClass, result);
        }

    }

}


package com.lvtu.csa.framework.aspect;

import com.google.common.base.Optional;
import com.lvtu.csa.framework.annotation.CacheEvict;
import com.lvtu.csa.framework.annotation.Cacheable;
import com.lvtu.csa.framework.cache.CacheAspectSupport;
import com.lvtu.csa.framework.cache.CacheKey;
import com.lvtu.csa.framework.cache.RedisCache;
import org.apache.commons.lang3.ArrayUtils;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.reflect.MethodSignature;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.aop.support.AopUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

import java.lang.reflect.Method;
import java.util.List;

@Component
@Aspect
public class CacheAspect extends CacheAspectSupport {

    private final static Logger LOGGER = LoggerFactory.getLogger(CacheAspect.class);
    public final static String LVTU_CACHE_PREFIX = "LVTU_CACHE:";

    @Value("${system.cache.enable}")
    private Boolean cacheEnable;

    @Autowired
    RedisCache redisCache;

    @SuppressWarnings("unchecked")
    @Around("@annotation(cacheable)")
    public Object doAround(ProceedingJoinPoint pjp, Cacheable cacheable) throws Throwable {
        if (!cacheEnable) {
            return pjp.proceed();
        }

        MethodSignature methodSignature = (MethodSignature) pjp.getSignature();
        Method targetMethod = AopUtils.getMostSpecificMethod(methodSignature.getMethod(), pjp.getTarget().getClass());

        CacheOperationContext context = getOperationContext(targetMethod, pjp.getArgs(), pjp.getTarget(), pjp.getTarget().getClass());
        CacheKey key = context.generateKey(cacheable, context);

        Object value = redisCache.get(key);    //从缓存获取数据
        if (LOGGER.isDebugEnabled()) {
            LOGGER.warn("[CacheAspect]缓存Key=" + key + ", Value=" + (value == null ? "MISS" : "HIT"));
        }

        if (value != null) {
            if (methodSignature.getReturnType() == Optional.class) {
                return Optional.of(value);
            }
            
            if (methodSignature.getReturnType() == java.util.Optional.class) {
                return java.util.Optional.of(value);
            }

            if (matchClass(methodSignature.getReturnType(), value.getClass())) {
                return value;       //如果有数据,则直接返回
            } else {
                LOGGER.warn("[CacheAspect]缓存中数据类型不匹配, need=" + methodSignature.getReturnType()
                        + ", actual=" + value.getClass() + ", key=" + key);
                redisCache.evict(key);
            }
        }

        value = pjp.proceed(); //跳过缓存,到后端查询数据

        if (value != null) { //取值存在，才存入缓存
            if (value instanceof java.util.Optional) {
                java.util.Optional optional = (java.util.Optional) value;
                if (optional.isPresent()) {
                    setCache(cacheable, key, optional.get());
                }
            } else if (value instanceof Optional) {
                Optional optional = (Optional) value;
                if (optional.isPresent()) {
                    setCache(cacheable, key, optional.get());
                }
            } else {
                setCache(cacheable, key, value);
            }
        }

        return value;
    }

    @AfterReturning("@annotation(cacheEvict)")
    public void doEvict(JoinPoint jp, CacheEvict cacheEvict) throws Throwable {
        if (!cacheEnable || ArrayUtils.isEmpty(cacheEvict.key())) {
            return;
        }

        MethodSignature methodSignature = (MethodSignature) jp.getSignature();
        Method targetMethod = AopUtils.getMostSpecificMethod(methodSignature.getMethod(), jp.getTarget().getClass());

        CacheOperationContext context = getOperationContext(targetMethod, jp.getArgs(), jp.getTarget(), jp.getTarget().getClass());
        List<CacheKey> keys = context.generateKey(cacheEvict, context);

        for (CacheKey key : keys) {
            redisCache.evict(key);
        }
    }

    private void setCache(Cacheable cacheable, CacheKey key, Object value) {
        if (cacheable.expire() <= 0) {      //如果没有设置过期时间,则无限期缓存
            redisCache.put(key, value);
        } else {                    //否则设置缓存时间
            redisCache.put(key, value, cacheable.expire());
        }
    }

    @SuppressWarnings("unchecked")
    private boolean matchClass(Class need, Class actual) {
        return need.isAssignableFrom(actual)
                || ((need == boolean.class || need == Boolean.class) && (actual == boolean.class || actual == Boolean.class))
                || ((need == byte.class || need == Byte.class) && (actual == byte.class || actual == Byte.class))
                || ((need == short.class || need == Short.class) && (actual == short.class || actual == Short.class))
                || ((need == int.class || need == Integer.class) && (actual == int.class || actual == Integer.class))
                || ((need == long.class || need == Long.class) && (actual == long.class || actual == Long.class))
                || ((need == char.class || need == Character.class) && (actual == char.class || actual == Character.class))
                || ((need == float.class || need == Float.class) && (actual == float.class || actual == Float.class))
                || ((need == double.class || need == Double.class) && (actual == double.class || actual == Double.class));
    }
}


redis配置：

package com.lvmama.cobra.cache;

import com.google.common.collect.Sets;
import org.apache.commons.lang3.StringUtils;
import org.redisson.Redisson;
import org.redisson.api.RedissonClient;
import org.redisson.config.ClusterServersConfig;
import org.redisson.config.Config;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisClusterConfiguration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.RedisNode;
import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;

import java.util.Set;

@Configuration
public class RedisConfig {

    private static final Logger LOGGER = LoggerFactory.getLogger(RedisConfig.class);

    @Value("${redis.blacklist.type}")
    private String blacklistType;

    @Value("${redis.blacklist.cluster.url}")
    private String REDIS_BLACKLIST_CLUSTER_URL;

    @Value("${redis.blacklist.single.url}")
    private String REDIS_BLACKLIST_SINGLE_URL;

    @Value("${redis.token.type}")
    private String tokenType;

    @Value("${redis.token.cluster.url}")
    private String REDIS_TOKEN_CLUSTER_URL;

    @Value("${redis.token.single.url}")
    private String REDIS_TOKEN_SINGLE_URL;

    @Bean(name = "redisBlacklistNodes")
    public Iterable<RedisNode> getRedisBlacklistNodes() {
        return getRedisNodes(REDIS_BLACKLIST_CLUSTER_URL);
    }
    @Bean(name = "redisTokenNodes")
    public Iterable<RedisNode> getRedisTokenNodes() {
        return getRedisNodes(REDIS_TOKEN_CLUSTER_URL);
    }

    private Iterable<RedisNode> getRedisNodes(String clutterUrl) {
        if(StringUtils.isBlank(clutterUrl)) {
            LOGGER.warn("REDIS配置文件为空");
            return null;
        }

        String[] urls = StringUtils.split(clutterUrl, ',');
        Set<RedisNode> nodes = Sets.newHashSetWithExpectedSize(urls.length);

        for (String url : urls) {
            String[] splits = url.split(":");
            nodes.add(new RedisNode(splits[0], Integer.parseInt(splits[1])));
        }
        return nodes;
    }

    @Bean(name = "redisBlacklistClusterConfiguration")
    public RedisClusterConfiguration getBlacklistClusterConfiguration(@Qualifier("redisBlacklistNodes") Iterable<RedisNode> redisNodes) {
        return getRedisClusterConfiguration(redisNodes);
    }
    @Bean(name = "redisTokenClusterConfiguration")
    public RedisClusterConfiguration getTokenClusterConfiguration(@Qualifier("redisTokenNodes") Iterable<RedisNode> redisNodes) {
        return getRedisClusterConfiguration(redisNodes);
    }

    private RedisClusterConfiguration getRedisClusterConfiguration(Iterable<RedisNode> redisNodes) {
        if(redisNodes == null) {
            return null;
        }

        RedisClusterConfiguration configuration = new RedisClusterConfiguration();
        configuration.setClusterNodes(redisNodes);
        configuration.setMaxRedirects(5);
        return configuration;
    }

    @Bean(name = "redisBlacklistConnectionFactory")
    public RedisConnectionFactory getRedisBlacklistConnectionFactory(
            @Qualifier("redisBlacklistClusterConfiguration") RedisClusterConfiguration redisClusterConfiguration) {
        return getRedisConnectionFactory(blacklistType, REDIS_BLACKLIST_SINGLE_URL, redisClusterConfiguration);
    }
    @Bean(name = "redisTokenConnectionFactory")
    public RedisConnectionFactory getRedisTokenConnectionFactory(
            @Qualifier("redisTokenClusterConfiguration") RedisClusterConfiguration redisClusterConfiguration) {
        return getRedisConnectionFactory(tokenType, REDIS_TOKEN_SINGLE_URL, redisClusterConfiguration);
    }

    private RedisConnectionFactory getRedisConnectionFactory(String type, String singleURL, RedisClusterConfiguration redisClusterConfiguration) {
        if("single".equals(type)) {
            if(StringUtils.isEmpty(singleURL) || !singleURL.contains(":")) {
                throw new RuntimeException("请检查redis配置，单点配置不正确");
            }

            String[] split = singleURL.split(":");
            return new LettuceConnectionFactory(split[0], Integer.parseInt(split[1]));
        }

        if("cluster".equals(type)) {
            if(redisClusterConfiguration == null) {
                throw new RuntimeException("请检查redis配置，集群配置不正确");
            }

            return new LettuceConnectionFactory(redisClusterConfiguration);
        }
        return null;
    }

    @Bean(name = "redissionConfig")
    public Config getRedissionConfig() {
        if("single".equals(tokenType)) {
            if(StringUtils.isEmpty(REDIS_TOKEN_SINGLE_URL) || !REDIS_TOKEN_SINGLE_URL.contains(":")) {
                throw new RuntimeException("请检查redis配置，单点配置不正确");
            }

            Config config = new Config();
            config.useSingleServer().setAddress(REDIS_TOKEN_SINGLE_URL);
            return config;
        }

        if("cluster".equals(tokenType)) {
            if(StringUtils.isBlank(REDIS_TOKEN_CLUSTER_URL)) {
                throw new RuntimeException("请检查redis配置，集群配置不正确");
            }

            Config config = new Config();
            ClusterServersConfig clusterConfig = config.useClusterServers()
                    .setScanInterval(2000); // 集群状态扫描间隔时间，单位是毫秒
            String[] urls = StringUtils.split(REDIS_TOKEN_CLUSTER_URL, ',');
            clusterConfig.addNodeAddress(urls);

            return config;
        }
        return null;
    }

    @Bean(name = "redissonClient")
    public RedissonClient getRedissonClient(Config config) {
        if(config == null) {
            throw new RuntimeException("请检查redis配置，Redisson配置不正确");
        }
        return Redisson.create(config);
    }

}

rediscache：

package com.lvmama.cobra.cache;

import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import org.springframework.util.Assert;

import java.util.Set;
import java.util.concurrent.TimeUnit;


@Component
public class RedisCache {

    @Autowired
    @Qualifier("redisBlacklistTemplate")
    RedisTemplate<String, Object> redisTemplate;

    public Object get(CacheKey cacheKey) {
        Assert.hasText(cacheKey.getKey(), "缓存KEY不能为空");

        if(StringUtils.isEmpty(cacheKey.getName())) {
            return redisTemplate.opsForValue().get(cacheKey.getKey());
        } else {
            return redisTemplate.opsForHash().get(cacheKey.getName(), cacheKey.getKey());
        }
    }

    public void put(CacheKey cacheKey, Object result) {
        Assert.hasText(cacheKey.getKey(), "缓存KEY不能为空");

        if(StringUtils.isEmpty(cacheKey.getName())) {
            redisTemplate.opsForValue().set(cacheKey.getKey(), result);
        } else {
            redisTemplate.opsForHash().put(cacheKey.getName(), cacheKey.getKey(), result);
        }
    }

    public void put(CacheKey cacheKey, Object result, int second) {
        Assert.hasText(cacheKey.getKey(), "缓存KEY不能为空");

        if(StringUtils.isEmpty(cacheKey.getName())) {
            redisTemplate.opsForValue().set(cacheKey.getKey(), result, second, TimeUnit.SECONDS);
        } else {
            redisTemplate.opsForHash().put(cacheKey.getName(), cacheKey.getKey(), result);
            redisTemplate.expire(cacheKey.getName(), second, TimeUnit.SECONDS);
        }
    }

    public void evict(CacheKey cacheKey) {
        Assert.hasText(cacheKey.getKey(), "缓存KEY不能为空");

        if(StringUtils.isEmpty(cacheKey.getName())) {
            redisTemplate.delete(cacheKey.getKey());
        } else {
            redisTemplate.opsForHash().delete(cacheKey.getName(), cacheKey.getKey());
        }
    }

    public void putSet(CacheKey cacheKey, Object value) {
        if(StringUtils.isEmpty(cacheKey.getName())) {
            redisTemplate.opsForSet().add(cacheKey.getName(), value);
        } else {
            redisTemplate.opsForHash().put(cacheKey.getName(), cacheKey.getKey(), value);
        }
    }

    /**
     * SET ADD
     * @see http://redis.io/commands/sadd
     * @param cacheKey
     * @param value
     */
    public void sadd(CacheKey cacheKey, Object value) {
        redisTemplate.opsForSet().add(cacheKey.getKey(), value);
    }

    public void srem(CacheKey cacheKey, Object value) {
        redisTemplate.opsForSet().remove(cacheKey.getKey(), value);
    }

    public boolean sismember(CacheKey cacheKey, Object value) {
        return redisTemplate.opsForSet().isMember(cacheKey.getKey(), value);
    }

    public Set<Object> sget(CacheKey cacheKey) {
        Assert.hasText(cacheKey.getKey(), "缓存KEY不能为空");
        return redisTemplate.opsForSet().members(cacheKey.getKey());
    }

    public void removeAll(CacheKey cacheKey) {
        redisTemplate.delete(cacheKey.getKey());
    }
}
 spring-redis 

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
         http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="luaResource" class="org.springframework.scripting.support.ResourceScriptSource">
        <constructor-arg><value>classpath:rate_limiter.lua</value></constructor-arg>
    </bean>

    <bean id="luaScript" class="org.springframework.data.redis.core.script.DefaultRedisScript">
        <property name="scriptSource" ref="luaResource" />
        <property name="resultType" value="java.lang.Boolean"/>
    </bean>

    <!-- 用于存取黑名单，业务用Redis -->
    <bean id="redisBlacklistTemplate" class="org.springframework.data.redis.core.RedisTemplate">
        <property name="connectionFactory" ref="redisBlacklistConnectionFactory"/>
        <property name="keySerializer">
            <bean class="org.springframework.data.redis.serializer.StringRedisSerializer"/>
        </property>
        <property name="valueSerializer">
            <bean class="org.springframework.data.redis.serializer.JdkSerializationRedisSerializer"/>
        </property>
        <property name="hashKeySerializer">
            <bean class="org.springframework.data.redis.serializer.StringRedisSerializer"/>
        </property>
        <property name="hashValueSerializer">
            <bean class="org.springframework.data.redis.serializer.JdkSerializationRedisSerializer"/>
        </property>
    </bean>

    <!-- 用于存取令牌，非业务用Redis -->
    <bean id="redisTokenTemplate" class="org.springframework.data.redis.core.RedisTemplate">
        <property name="connectionFactory" ref="redisTokenConnectionFactory"/>
        <property name="keySerializer">
            <bean class="org.springframework.data.redis.serializer.StringRedisSerializer"/>
        </property>
        <property name="valueSerializer">
            <bean class="org.springframework.data.redis.serializer.JdkSerializationRedisSerializer"/>
        </property>
        <property name="hashKeySerializer">
            <bean class="org.springframework.data.redis.serializer.StringRedisSerializer"/>
        </property>
        <property name="hashValueSerializer">
            <bean class="org.springframework.data.redis.serializer.JdkSerializationRedisSerializer"/>
        </property>
    </bean>

    <!-- 用于执行lua脚本 -->
    <bean id="redisLuaTemplate" class="org.springframework.data.redis.core.RedisTemplate">
        <property name="connectionFactory" ref="redisTokenConnectionFactory"/>
        <property name="keySerializer">
            <bean class="org.springframework.data.redis.serializer.StringRedisSerializer"/>
        </property>
        <property name="valueSerializer">
            <bean class="org.springframework.data.redis.serializer.StringRedisSerializer"/>
        </property>
        <property name="hashKeySerializer">
            <bean class="org.springframework.data.redis.serializer.StringRedisSerializer"/>
        </property>
        <property name="hashValueSerializer">
            <bean class="org.springframework.data.redis.serializer.StringRedisSerializer"/>
        </property>
    </bean>

</beans>











jakeswang
关注
专栏目录
Redis集群实现分布式Session共享
悦分享
01-10 2140
Cookie 保存在客户端浏览器中，而 Session 保存在服务器上。客户端浏览器访问服务器的时候，服务器把客户端信息以某种形式记录在服务器上，这就是 Session。客户端浏览器再次访问时只需要从该 Session 中查找该客户的状态就可以了。在实际工作中我们建议使用外部的缓存设备来共享 Session，避免单个服务器节点挂掉而影响服务，共享数据都会放到外部缓存容器中。
Redis 集群的实现
weixin_48922154的博客
07-12 819
一
Redis：集群（cluster）
m0_46669446的博客
01-23 3959
redis：持久化 redis：主从复制 redis：哨兵 redis：集群 1 概述 集群，即Redis Cluster，是Redis 3.0开始引入的分布式存储方案。 集群由多个节点(Node)组成，Redis的数据分布在这些节点中。集群中的节点分为主节点和从节点：只有主节点负责读写请求和集群信息的维护；从节点只进行主节点数据和状态信息的复制。 集群的作用，可以归纳为两点： 数据分区：数据分区(或称数据分片)是集群最核心的功能。 集群将数据分散到多个节点，一方面突破了Redis单机内存大小的限制，
如何实现Redis集群
ZeroHero99的博客
09-20 397
1.什么是redis集群? Redis 是一个开源的key value 存储系统,redis3.0.0版本之前只支持单例模式,之后支持集群 Redis集群采用p2p模式,是完全去中心化的,不存在中心节点或者代理节点 去中心化:在一个分布有众多节点的系统中，每个节点都具有高度自治的特征。节点之间可以自有链接，形成新的连接单元。任何一个节点都可能成为阶段性的中心，但不具备强制性的中心控制模式。节点与...
Redis的集群-详细操作及理论
最新发布
求你们看我的博客
08-15 1025
广义的集群：只要是多个机器，构成了分布式系统，都可以称为是一个”集群“，前面博客所讲的哨兵模式，也可以称为是”广义的集群“狭义的集群：redis提供的集群模式，这个集群模式之下，主要是要解决，存储空间不足的问题（拓展存储空间）哨兵模式提高了系统的可用性：哨兵模式中，本质还是redis主从节点存储数据，其中就要求一个主节点/从节点，就得存储整个数据的”全集“此处关键问题，就是引入多台机器，每台机器存储一部分数据，设由1TB的数据需要存储，拿两台机器来存，每个机器只需要存512G即可；
Redis集群实现
xianymo的专栏
06-09 2160
简介 前面两篇文章介绍到了Redis的主从节点和Redies的数据分片，但在实际环境中，我们可能需要同时满足这两个要求，即既能实现主从结构（master/slave）解决主节点（master）出现故障，从节点（slave）能够提升为主节点，不影响整个程序的运行；而且又能够满足当业务压力太大，单个master节点的写入无法满足要求时，能够实现数据分片的功能。而Redis 3.0.2提供了Red
如何实现redis集群?
weixin_30776545的博客
01-30 66
由于Redis出众的性能，其在众多的移动互联网企业中得到广泛的应用。Redis在3.0版本前只支持单实例模式，虽然现在的服务器内存可以到100GB、200GB的规模，但是单实例模式限制了Redis没法满足业务的需求（例如新浪微博就曾经用Redis存储了超过1TB的数据）。Redis的开发者Antirez早在博客上就提出在Redis 3.0版本中加入集群的功能，但3.0版本等到2015年才...
如何实现高可用的redis集群(方案介绍)
houzhyan-博客
04-26 4724
原文:点击打开链接 Redis因具有丰富的数据结构和超高的性能以及简单的协议，使其能够很好的作为数据库的上游缓存层。但在大规模的Redis使用过程中，会受限于多个方面：单机内存有限、带宽压力、单点问题、不能动态扩容等。   基于以上，Redis集群方案显得尤为重要。通常有3个途径：官方Redis Cluster；通过Proxy分片；客户端分片(Smart Client)。
Tomcat+Redis集群实现session会话共享
11-07
"Tomcat+Redis集群实现session会话共享"这一主题，正是关注如何在使用Tomcat作为应用服务器的环境中，通过集成Redis缓存系统来构建一个高效的、高可用的会话共享解决方案。 首先，我们来理解一下`session`。在Web...
Redis集群下过期key监听的实现代码
09-09
在讨论Redis集群下过期key监听的实现代码之前，首先需要明确几个核心概念和组件： Redis集群是Redis的一种高可用性解决方案，它通过将数据分布在不同的Redis节点上，并提供一定机制保证数据的复制和高可用性。集群...
NoSQL 之Redis集群模式
m0_68625092的博客
08-12 1441
集群，即 Rediscluster，是 Redis 3.0开始引入的分布式存储方案。集群由多个节点(Node)组成，Redis 的数据分布在这些节点中。集群中的节点分为主节点和从节点;只有主节点负责读写请求和集群信息的维护;从节点只进行主节点数据和状态信息的复制。
Redis的集群功能和实现
沧海一粟的博客
03-30 496
要了解Redis的集群功能，可以从数据分片、数据迁移、集群通讯、故障检测以及故障转移等方面进行了解，Cluster相关的代码也不是很多，注释也很详细，可自行查看，地址是：https://github.com/antirez/redis/blob/unstable/src/cluster.c。 这里由于篇幅的原因，主要从数据分片和数据迁移两方面进行详细介绍： 数据分片 Redis cluste...
搭建Redis集群的几种方式？
毛豆的博客
03-25 296
根据你的具体需求和环境选择最合适的集群搭建方式，并确保对应的运维和监控措施到位，以保证系统的稳定性和高可用性。
redis cluster
qq_36801585的博客
02-17 643
redis cluster 一、如何解决redis 横向扩展 Redis 分布式部署方案： 1、客户端分区：由客户端程序决定 key 写分配和写入的 redis node，但是需要客户端自己处理写入 分配、高可用管理和故障转移等 2、代理方案：基于三方软件实现 redis proxy，客户端先连接之代理层，由代理层实现 key 的写入分 配，对客户端来说是有比较简单，但是对于集群管节点增减相对比较...
Redis的三种集群方案
用于记录学习的过程，不做商业用途。
03-08 3307
目录 一、主从复制模式 基本原理 命令的不同 优点 缺点 二、哨兵模式（Sentinel） 基本原理 哨兵的作用 优点 缺点 三、Cluster模式 基本原理 Cluster模式的特点（采用无中心结构） Cluster模式的具体工作机制 优点 缺点 一、主从复制模式 基本原理 主从复制模式包含一个主数据库实例（master），一个或多个从数据库实例（slave） 客户端可以对主数据库进行读写操作，对从数据库只能进行读操作，主数据库写入的数据会实时自动同步
redis Cluster集群介绍
不忘初心，方得始终
01-18 6688
0、常见的几种模式对比 一、redis cluster 是什么 二、集群架构图 三、集群原理图 四、集群通信 1）集群发现：MEET 2）gossip协议 五、集群概念 1）多slave选举 2）slot（槽） 3）数据分片 4）请求重定向 5）数据迁移 6）故障转移 7）集群slots是否必须完整才能对外提供服务 六、集群健康检查机制 七、各语言的推荐客户端 0、常见的几种模式对比 模式 版本
redis集群原理（简版）
qq_28617019的博客
07-17 3717
　先来一张redis集群的架构图： 　　　　 　　 在这个图中，每一个蓝色的圈都代表着一个redis的服务器节点。它们任何两个节点之间都是相互连通的。客户端可以与任何一个节点相连接，然后就可以访问集群中的任何一个节点。对其进行存取和其他操作。       集群的话，是有好多个redis一起工作的，那么，就需要这个集群不是那么容易挂掉，所以呢，理论上就应该给集群中的每个节点至少一个备用的red...
Redis集群配置
boboxu
09-02 308
1.Java类 package org.atm.dc.app.util; import java.io.Closeable; import java.lang.reflect.Field; import java.util.ArrayList; import java.util.HashMap; import java.util.HashSet; import java.util.Linke...
redis配置类
w1939481704的博客
04-30 1532
redis配置类 package com.aaa.wyl.config; import com.fasterxml.jackson.annotation.JsonAutoDetect; import com.fasterxml.jackson.annotation.PropertyAccessor; import com.fasterxml.jackson.databind.ObjectMapper; import org.springframework.cache.CacheManager; impor
SpringCloud微服务与Redis集群实现单点登录详解
"springcloud微服务基于redis集群的单点登录实现解析" 在微服务架构中，单点登录（Single Sign-On, SSO）是一种让用户在多个相互关联的应用系统中只需登录一次，就能在所有系统中自由切换而无需再次登录的设计模式...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值