RedisConfig配置

java 复制代码
package io.renren.common.redis;

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.jsontype.impl.LaissezFaireSubTypeValidator;
import org.redisson.Redisson;
import org.redisson.api.RedissonClient;
import org.redisson.config.Config;
import org.redisson.config.SingleServerConfig;
import org.springframework.boot.autoconfigure.data.redis.RedisProperties;
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.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import org.springframework.util.StringUtils;

import javax.annotation.Resource;

/**
 * Redis配置
 **/
@Configuration
public class RedisConfig {
    @Resource
    private RedisConnectionFactory factory;

    // 锁前缀
    private static final String SCHEMA_PREFIX = "redis://";
    @Bean
    public Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer(){
        Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<>(Object.class);
        ObjectMapper objectMapper = new ObjectMapper();
        objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        objectMapper.activateDefaultTyping(LaissezFaireSubTypeValidator.instance, ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(objectMapper);

        return jackson2JsonRedisSerializer;
    }

    @Bean
    public RedisTemplate<String, Object> redisTemplate() {
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setValueSerializer(jackson2JsonRedisSerializer());
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer());
        redisTemplate.setConnectionFactory(factory);

        return redisTemplate;
    }

    /**
     * 创建 RedissonClient,注入IOC容器
     */
    @Bean
    public RedissonClient redissonClient(RedisProperties redisProperties) {
        Config config = new Config();
        //单点redis
        SingleServerConfig singleServerConfig = config.useSingleServer().
                setAddress(SCHEMA_PREFIX + redisProperties.getHost() + ":" + redisProperties.getPort());
        if (StringUtils.hasText(redisProperties.getPassword())) {
            singleServerConfig.setPassword(redisProperties.getPassword());
        }
        singleServerConfig.setTimeout((int) redisProperties.getTimeout().toMillis());
        singleServerConfig.setPingConnectionInterval(30000);
        singleServerConfig.setDatabase(redisProperties.getDatabase());
        // 超时时间
        long lockWatchTimeOut = 3000;
        config.setLockWatchdogTimeout(lockWatchTimeOut);
        return Redisson.create(config);
    }
java 复制代码
@Component
public class RedissonLock {
    @Autowired
    private RedissonClient redissonClient;

    private static final String LOCK_PREFIX = "lock:";

    /**
     * 阻塞方式获取锁
     * @param key
     * @param expireTime
     * @return
     */
    public RLock lock(String key,Integer expireTime){
        //可重入锁
        RLock lock = redissonClient.getLock(LOCK_PREFIX + key);
        //lock.lock(expireTime, TimeUnit.SECONDS); //阻塞方式获取锁,设置过期时间
        lock.lock();
        return lock;
    }


    /**
     * 非阻塞方式获取锁
     * @param key
     */
    public Boolean tryLock(String key){
        try {
            RLock lock = redissonClient.getLock(LOCK_PREFIX + key);

            return lock.tryLock(5L, TimeUnit.SECONDS); //非阻塞方式获取锁,设置在指定时间内失败重试获取锁
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            return false;
        }
    }

    /**
     * 非阻塞方式获取锁
     * @param key key
     * @param expireTime 指定持有时间
     */
    public Boolean tryLock(String key,Integer expireTime){
        try {
            RLock lock = redissonClient.getLock(LOCK_PREFIX + key);

            //非阻塞方式获取锁,设置在指定时间内失败重试获取锁
            return lock.tryLock(5L,expireTime,TimeUnit.SECONDS);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            return false;
        }
    }

    /**
     * 释放锁
     * @param key
     */
    public void unlock(String key) {
        RLock lock = redissonClient.getLock(LOCK_PREFIX+key);
        if (lock.isLocked()) {
            lock.unlock();
        }
    }
}
相关推荐
RainbowSea12 分钟前
补充:问题:CORS ,前后端访问跨域问题
java·spring boot·spring
RainbowSea15 分钟前
15. MySQL 多版本并发控制
java·sql·mysql
倔强的石头10622 分钟前
飞算JavaAI:重构软件开发范式的智能引擎
java·数据库·重构
Q_9709563939 分钟前
java+vue+SpringBoo足球社区管理系统(程序+数据库+报告+部署教程+答辩指导)
java·开发语言·数据库
要开心吖ZSH43 分钟前
微服务架构的演进:迈向云原生
java·微服务·云原生
为了更好的明天而战1 小时前
Java 中的 ArrayList 和 LinkedList 区别详解(源码级理解)
java·开发语言
JosieBook1 小时前
【Java编程动手学】Java中的数组与集合
java·开发语言·python
N_NAN_N2 小时前
类图+案例+代码详解:软件设计模式----单例模式
java·单例模式·设计模式
weixin_399380692 小时前
k8s一键部署tongweb企业版7049m6(by why+lqw)
java·linux·运维·服务器·云原生·容器·kubernetes
lang201509282 小时前
Reactor ConnectableFlux支持多订阅者
java·网络