一、springboot整合redis

application.yml

spring:
  # redis 配置
  redis:
    # 地址
    host: xx.xx.xxx.xxx
    # 端口，默认为6379
    port: 6379
    # 密码
    password: xxxx
    # 连接超时时间
    timeout: 60s
    lettuce:
      pool:
        # 连接池中的最小空闲连接
        min-idle: 1
        # 连接池中的最大空闲连接
        max-idle: 100
        # 连接池的最大数据库连接数
        max-active: 1000
        # #连接池最大阻塞等待时间（使用负值表示没有限制）
        max-wait: -1
    # 数据库
    database: 8

通过 redisTemplate 进行缓存操作

实例
以 布隆过滤器 为例

package com.zxh.projectzxh.controller.redis;

import com.google.common.hash.BloomFilter;
import com.google.common.hash.Funnels;
import jodd.util.StringUtil;
import org.springframework.data.redis.core.RedisTemplate;

import java.util.UUID;
import java.util.concurrent.TimeUnit;

/**
 * @description: 布隆过滤器
 * @author: zxh
 * @create: 2022-11-11 13:46
 **/
public class BloomFilterController {
    RedisTemplate<String, String> redisTemplate;

    //测试使用布隆过滤器解决缓存穿透问题
    //需引入:guava包
    private static final int capacity = 10000000;
    private static final int key = 9222222;
    private static BloomFilter<Integer> bloomFilter = BloomFilter.create(Funnels.integerFunnel(), capacity);

    static {
        for (int i = 0; i < capacity; i++) {
            bloomFilter.put(i);
        }
    }

    public static void main(String[] args) {
        long star = System.nanoTime();//微秒: 1 秒=1000000 微秒
        if (bloomFilter.mightContain(key)) {
            System.out.println("布隆过滤器过滤到" + key);
        }
        long end = System.nanoTime();//微秒: 1 秒=1000000 微秒
        System.out.println("过滤消耗时间:" + (end - star) + "微秒");

    }

    public String getByKey(Integer key) {
        // 通过key获取value
        String value = "";
        if (StringUtil.isEmpty(value)) {
            if (bloomFilter.mightContain(key)) {
                // 从数据库获取数据
                value = "dsfasdfasdfas";
                //放缓存
                redisTemplate.opsForValue().set("key", value);
                return value;
            } else {
                return null;
            }
        }
        return value;
    }

    public void updateUserWithRedisLock() throws InterruptedException {
        String uuid = UUID.randomUUID().toString().replaceAll("-", "");
        // 占分布式锁，去redis占坑
        // 1. 分布式锁占坑
        Boolean lock = redisTemplate.opsForValue().setIfAbsent("SysUserLock" + uuid, "value", 30, TimeUnit.SECONDS);
        if (lock) {
            //加锁成功...
            // todo business

            redisTemplate.delete("SysUserLock" + uuid);   //删除key，释放锁
        } else {
            Thread.sleep(100);   // 加锁失败，重试
            updateUserWithRedisLock();
        }
    }
}

二、springboot整合redisson实现分布式锁

1、引入redisson依赖
pom.xml

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

2、新建redisson配置文件

package com.zxh.projectzxh.config;

import org.redisson.Redisson;
import org.redisson.api.RedissonClient;
import org.redisson.config.Config;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * @Author: zxh
 * @DateTime: 2020/9/1 2:22 下午
 */
@Configuration
public class RedissonConfig {
    @Value("${spring.redis.host}")
    private String host;
    @Value("${spring.redis.port}")
    private String port;
    @Value("${spring.redis.password}")
    private String password;
    @Value("${spring.redis.database}")
    private int database;

    @Bean
    public RedissonClient redissonClient() {
        Config config = new Config();
        config.useSingleServer().setAddress("redis://" + host + ":" + port).setPassword(password).setDatabase(database);
        return Redisson.create(config);
    }
}

3、redisson使用

@Resource
    private RedissonClient redissonClient;

    public void updateUser(String userId) {
        String lockKey = "config" + userId;
        RLock rLock = redissonClient.getLock(lockKey);  //获取锁资源
        try {
            //rLock.lock(10, TimeUnit.SECONDS);   //加锁,可以指定锁定时间
            rLock.lock(); //拿锁失败时会不停的重试;具有Watch Dog 自动延期机制 默认续30s 每隔30/3=10 秒续到30s
            // TODO这里写需要处理业务的业务代码

        } finally {
            rLock.unlock();   //释放锁
        }
    }