springboot整合redisson实现分布式锁及布隆过滤器

下载安装redisson

整合

maven添加依赖

使用的版本是3.13，因为springboot使用的是2.1.3版本，因此按照官方上的提示，移除redisson-spring-data-22

		<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <dependency>
            <groupId>org.redisson</groupId>
            <artifactId>redisson-spring-boot-starter</artifactId>
            <exclusions>
                <exclusion>
                    <groupId>org.redisson</groupId>
                    <artifactId>redisson-spring-data-22</artifactId>
                </exclusion>
            </exclusions>
            <version>3.13.1</version>
        </dependency>
        <dependency>
            <groupId>org.redisson</groupId>
            <artifactId>redisson-spring-data-21</artifactId>
            <version>3.13.1</version>
        </dependency>

项目配置

spring:
  redis:
    redisson: 
      config: classpath:SentinelConfig-local.yml

SentinelConfig-local.yml文件在项目的resource目录下，具体参数查看redisson依赖包下面的config/SentinelServersConfig.java

#本地开发使用
sentinelServersConfig:
  #baseConfig
  idleConnectionTimeout: 10000
  connectTimeout: 10000
  timeout: 3000
  retryAttempts: 3
  retryInterval: 1500
  password: 123456
  clientName: null
  loadBalancer: !<org.redisson.connection.balancer.RoundRobinLoadBalancer> {}
  #BaseMasterSlaveServersConfig
  slaveConnectionMinimumIdleSize: 24
  slaveConnectionPoolSize: 64
  failedSlaveReconnectionInterval: 3000
  failedSlaveCheckInterval: 180000
  masterConnectionMinimumIdleSize: 24
  masterConnectionPoolSize: 64
  subscriptionConnectionMinimumIdleSize: 1
  subscriptionConnectionPoolSize: 50
  dnsMonitoringInterval: 5000
  #SentinelServersConfig
  database: 8
  sentinelAddresses:
    - "redis://192.168.1.213:26379"
    - "redis://192.168.1.214:26380"
    - "redis://192.168.1.214:26381"
  masterName: "mymaster"
  scanInterval: 1000
threads: 0
# Netty线程池数量,默认值: 当前处理核数量 * 2
nettyThreads: 0
# 编码
codec: !<org.redisson.codec.JsonJacksonCodec> {}
# 传输模式
transportMode : "NIO"

添加工具类

添加DistributeLocker接口，以及它的实现类RedissonDistributeLocker

public interface DistributeLocker {
    /**
     * 加锁
     *
     * @param lockKey key
     */
    void lock(String lockKey);

    /**
     * 释放锁
     *
     * @param lockKey key
     */
    void unlock(String lockKey);

    /**
     * 加锁锁,设置有效期
     *
     * @param lockKey key
     * @param timeout 有效时间，默认时间单位在实现类传入
     */
    void lock(String lockKey, int timeout);

    /**
     * 加锁，设置有效期并指定时间单位
     *
     * @param lockKey key
     * @param timeout 有效时间
     * @param unit    时间单位
     */
    void lock(String lockKey, int timeout, TimeUnit unit);

    /**
     * 尝试获取锁，获取到则持有该锁返回true,未获取到立即返回false
     *
     * @param lockKey
     * @return true-获取锁成功 false-获取锁失败
     */
    boolean tryLock(String lockKey);

    /**
     * 尝试获取锁，获取到则持有该锁leaseTime时间.
     * 若未获取到，在waitTime时间内一直尝试获取，超过waitTime还未获取到则返回false
     *
     * @param lockKey   key
     * @param waitTime  尝试获取时间
     * @param leaseTime 锁持有时间
     * @param unit      时间单位
     * @return true-获取锁成功 false-获取锁失败
     */
    boolean tryLock(String lockKey, long waitTime, long leaseTime, TimeUnit unit);

    /**
     * 锁是否被任意一个线程锁持有
     *
     * @param lockKey
     * @return true-被锁 false-未被锁
     */
    boolean isLocked(String lockKey);

    /**
     * lock.isHeldByCurrentThread()的作用是查询当前线程是否保持此锁定
     * @param lockKey
     * @return
     */
    boolean isHeldByCurrentThread(String lockKey);

    /**
     * 添加元素到布隆过滤器中
     * @param bloomFilterName
     * @param value
     */
    void bfAdd(String bloomFilterName, String value);

    /**
     * 初始化布隆过滤器
     * @param bloomFilterName  默认给了expectedInsertions = 1000000L falseProbability = 0.0001
     * @return 布隆过滤器名称
     */
    RBloomFilter<String> init(String bloomFilterName);

    /**
     * 初始化布隆过滤器
     * @param bloomFilterName 名称
     * @param expectedInsertions 预计插入元素总量
     * @param falseProbability 精度（误判率）
     * @return 布隆过滤器名称
     */
    RBloomFilter<String> init(String bloomFilterName, Long expectedInsertions, Double falseProbability);

    /**
     * 删除布隆过滤器（注意不是删除元素）
     * @param bloomFilterName 名称
     */
    void bfDelete(String bloomFilterName);

    /**
     * 判断  
     * @param bloomFilterName 名称
     * @param value false表示则一定不存在，true 则可能存在
     * @return
     */
    boolean bfContains(String bloomFilterName, String value);
}

public class RedissonDistributeLocker implements DistributeLocker {

    private final RedissonClient redissonClient;

    public RedissonDistributeLocker(RedissonClient redissonClient) {
        this.redissonClient = redissonClient;
    }

    @Override
    public void lock(String lockKey) {
        RLock lock = redissonClient.getLock(lockKey);
        lock.lock();
    }

    @Override
    public void unlock(String lockKey) {
        RLock lock = redissonClient.getLock(lockKey);
        lock.unlock();
    }

    @Override
    public void lock(String lockKey, int leaseTime) {
        RLock lock = redissonClient.getLock(lockKey);
        lock.lock(leaseTime, TimeUnit.MILLISECONDS);
    }

    @Override
    public void lock(String lockKey, int timeout, TimeUnit unit) {
        RLock lock = redissonClient.getLock(lockKey);
        lock.lock(timeout, unit);
    }

    @Override
    public boolean tryLock(String lockKey) {
        RLock lock = redissonClient.getLock(lockKey);
        return lock.tryLock();
    }

    @Override
    public boolean tryLock(String lockKey, long waitTime, long leaseTime,
                           TimeUnit unit) {
        RLock lock = redissonClient.getLock(lockKey);
        try {
            return lock.tryLock(waitTime, leaseTime, unit);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return false;
    }

    @Override
    public boolean isLocked(String lockKey) {
        RLock lock = redissonClient.getLock(lockKey);
        return lock.isLocked();
    }

    @Override
    public boolean isHeldByCurrentThread(String lockKey) {
        RLock lock = redissonClient.getLock(lockKey);
        return lock.isHeldByCurrentThread();
    }

    @Override
    public void bfAdd(String bloomFilterName, String value) {
        RBloomFilter<String> bloomFilter = redissonClient.getBloomFilter(bloomFilterName);
        bloomFilter.add(value);
    }

    @Override
    public RBloomFilter<String> init(String bloomFilterName) {
        long expectedInsertions = 1000000L;
        double falseProbability = 0.0001;
        RBloomFilter<String> bloomFilter = redissonClient.getBloomFilter(bloomFilterName);
        bloomFilter.tryInit(expectedInsertions, falseProbability);
        return bloomFilter;
    }

    @Override
    public RBloomFilter<String> init(String bloomFilterName, Long expectedInsertions, Double falseProbability) {
        RBloomFilter<String> bloomFilter = redissonClient.getBloomFilter(bloomFilterName);
        bloomFilter.tryInit(expectedInsertions, falseProbability);
        return bloomFilter;
    }

    @Override
    public void bfDelete(String bloomFilterName) {
        RBloomFilter<String> bloomFilter = redissonClient.getBloomFilter(bloomFilterName);
        bloomFilter.delete();
    }

    @Override
    public boolean bfContains(String bloomFilterName, String value) {
        RBloomFilter<String> bloomFilter = redissonClient.getBloomFilter(bloomFilterName);
        return bloomFilter.contains(value);
    }
}

添加工具类

public class RedissonUtils {

    private static DistributeLocker locker;

    public static void setLocker(DistributeLocker locker) {
        RedissonUtils.locker = locker;
    }

    public static void lock(String lockKey) {
        locker.lock(lockKey);
    }

    public static void unlock(String lockKey) {
        locker.unlock(lockKey);
    }

    public static void lock(String lockKey, int timeout) {
        locker.lock(lockKey, timeout);
    }

    public static void lock(String lockKey, int timeout, TimeUnit unit) {
        locker.lock(lockKey, timeout, unit);
    }

    public static boolean tryLock(String lockKey) {
        return locker.tryLock(lockKey);
    }

    public static boolean tryLock(String lockKey, long waitTime, long leaseTime,
                                  TimeUnit unit) {
        return locker.tryLock(lockKey, waitTime, leaseTime, unit);
    }

    public static boolean isLocked(String lockKey) {
        return locker.isLocked(lockKey);
    }


    public static boolean isHeldByCurrentThread(String lockKey) {
        return locker.isHeldByCurrentThread(lockKey);
    }

    public static void bfAdd(String bloomFilterName, String value) {
        locker.bfAdd(bloomFilterName, value);
    }

    public static void bfDelete(String bloomFilterName) {
        locker.bfDelete(bloomFilterName);
    }

    public static RBloomFilter<String> init(String bloomFilterName) {
        return locker.init(bloomFilterName);
    }

    public static RBloomFilter<String> init(String bloomFilterName, Long expectedInsertions, Double falseProbability) {
        return locker.init(bloomFilterName, expectedInsertions, falseProbability);
    }

    public static boolean bfContains(String bloomFilterName, String value) {
        return locker.bfContains(bloomFilterName, value);
    }
}

把工具类注入到spring容器中

    @Bean
    public RedissonDistributeLocker redissonLocker(RedissonClient redissonClient) {    
        RedissonDistributeLocker locker = new RedissonDistributeLocker(redissonClient);
        RedissonUtils.setLocker(locker);
        return locker;
    }

测试

布隆过滤器测试

	public static void main(String[] args) {
        Config config = new Config();
        config.useSentinelServers()
                .setMasterName("mymaster")
                .addSentinelAddress("redis://192.168.1.213:26379", "redis://192.168.1.214:26380", "redis://192.168.1.214:26381")
                .setPassword("123456")
                .setDatabase(11)
                .setRetryInterval(5000)
                .setTimeout(10000)
                .setConnectTimeout(10000);
        RedissonClient redissonClient = Redisson.create(config);
        DistributeLocker locker = new RedissonDistributeLocker(redissonClient);
        RedissonUtils.setLocker(locker);
        String bloomFilterName = "bloomFilter";
        RedissonUtils.bfDelete(bloomFilterName);
        long st = System.currentTimeMillis();
        RedissonUtils.isLocked("123");
        log.debug("test connection used time={} ms", System.currentTimeMillis() - st);
        long st2 = System.currentTimeMillis();
        RedissonUtils.isLocked("123");

        log.debug("test connection used time={} ms", System.currentTimeMillis() - st2);
        RBloomFilter<String> bloomFilter = RedissonUtils.init(bloomFilterName);
        for (int i = 0; i < 1000; i++) {
            RedissonUtils.bfAdd(bloomFilterName, bloomFilterName + i);
        }
        log.debug("insert 1000 data used time={} ms", System.currentTimeMillis() - st);
//        log.debug("current bloomFilter count={}", bloomFilter.count());
        log.debug("bfContains 1001={} require false", RedissonUtils.bfContains(bloomFilterName, bloomFilterName + 1001));
        log.debug("bfContains 1002={} require false", RedissonUtils.bfContains(bloomFilterName, bloomFilterName + 1002));
        log.debug("bfContains 1003={} require false", RedissonUtils.bfContains(bloomFilterName, bloomFilterName + 1003));
        log.debug("bfContains 1004={} require false", RedissonUtils.bfContains(bloomFilterName, bloomFilterName + 1004));
        log.debug("bfContains 1005={} require false", RedissonUtils.bfContains(bloomFilterName, bloomFilterName + 1005));
        for (int i = 1000; i < 2000; i++) {
            RedissonUtils.bfAdd(bloomFilterName, bloomFilterName + i);
        }
        log.debug("bfContains 1001={} require true", RedissonUtils.bfContains(bloomFilterName, bloomFilterName + 1001));
        log.debug("bfContains 1002={} require true", RedissonUtils.bfContains(bloomFilterName, bloomFilterName + 1002));
        log.debug("bfContains 1003={} require true", RedissonUtils.bfContains(bloomFilterName, bloomFilterName + 1003));
        log.debug("bfContains 1004={} require true", RedissonUtils.bfContains(bloomFilterName, bloomFilterName + 1004));
        log.debug("bfContains 1005={} require true", RedissonUtils.bfContains(bloomFilterName, bloomFilterName + 1005));
    }

应用

分布式锁-防重复提交

避免用户同一个操作，因为网络延迟等原因，多次提交到服务端，导致的重复操作。
通过切面方法，在切面内实现，方法进来时，尝试加锁，加锁成功则继续操作，加锁失败则返回操作失败

	@Around(value = "pointcut(logAndNoRepeatSubmit)")
    public Object around(ProceedingJoinPoint point, LogAndNoRepeatSubmit logAndNoRepeatSubmit) throws Throwable {
        String key = LogAspectUtil.getKeyFromRequest();
        if (RedissonUtils.tryLock(key)) {
            Object result = LogAspectUtil.getObject(point, key);            
            return result;
        } else {
            return R.fail("操作太频繁，请稍后再试");
        }
    }

    /**
     * 根据用户的uid+用户请求的url路径作为唯一标识
     * @return 用户请求唯一标识
     */
    public static String getKeyFromRequest() {
        ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        HttpServletRequest request = attributes.getRequest();
//        Assert.notNull(request, "request can not null");
        // 此处可以用token或者JSessionId
//        String token = request.getHeader("Authorization");
        String path = request.getServletPath();
        long uid = JwtUtil.getUid();
        return uid + path;
    }
	public static Object getObject(ProceedingJoinPoint point, String key) throws Throwable {
        Object result = null;
        try {
            result = point.proceed();
        } catch (Throwable e) {
            log.error("不重复提交日志", e);
            throw e;
        } finally {
            //双重检查释放锁
            if (RedissonUtils.isLocked(key)) {
                if (RedissonUtils.isHeldByCurrentThread(key)) {
                    RedissonUtils.unlock(key);
                }
            }
        }
        return result;
    }

布隆过滤器-防缓存穿透

待实现
思路：
1、通过任务调度器或者在项目启动完成之后，把项目中免权限的表查询的id初始化到布隆过滤器
2、查询进来之前，先通过布隆过滤器判断，是否存在，不存在则直接返回不存在，可能存在才去查找数据库
3、对于后续增长的id，则可以通过同步的方式或者查询数据库成功时，动态添加到过滤器中