public class UserServiceImpl {
     @Autowired
     UserDAO userDAO;
     @Autowired
     RedisCache redisCache;
 public User findUser(Integer id) {
      Object object = redisCache.get(Integer.toString(id));
      // 缓存中存在，直接返回
      if(object != null) {
           // 检验该对象是否为缓存空对象，是则直接返回null
           if(object instanceof NullValueResultDO) {
                return null;
           }
           return (User)object;
      } else {  
           // 缓存中不存在，查询数据库
           User user = userDAO.getUser(id);
           // 存入缓存
           if(user != null) {
                redisCache.put(Integer.toString(id),user);
           } else {
                // 将空对象存进缓存
                redisCache.put(Integer.toString(id),new NullValueResultDO());
           }
           return user;
      }
 }          
}

public class MyBloomFilter {
    // 布隆过滤器长度
    private static final int SIZE = 2 << 10;
    // 模拟实现不同的哈希函数
    private static final int[] num= new int[] {5,19,23,31,47,71};   
    // 初始化位数组
    private BitSet bits = new BitSet(SIZE);
    // 用于存储哈希函数
    private MyHash[] function = new MyHash[num.length];
// 初始化哈希函数
public MyBloomFilter() {
    for (int i = 0; i < num.length; i++) {
        function [i] = new MyHash(SIZE,num[i]);
    }
}

// 存值Api 
public void add(String value) {
    // 对存入得值进行哈希计算
    for (MyHash f: function) {
        // 将为数组对应的哈希下标得位置得值改为1
        bits.set(f.hash(value),true);
    }
}

// 判断是否存在该值得Api 
public boolean contains(String value) {
    if (value == null) {
        return false;
    }
    boolean result= true;
    for (MyHash f : func) {
        result= result&& bits.get(f.hash(value));
    }
    return result;
}

}

public static class MyHash {
        private int cap;
        private int seed;
        // 初始化数据
        public MyHash(int cap,int seed) {
            this.cap = cap;
            this.seed = seed;
        }
        // 哈希函数
        public int hash(String value) {
            int result = 0;
            int len = value.length();
            for (int i = 0; i < len; i++) {
                result = seed * result + value.charAt(i);
            }
            return (cap - 1) & result;
        }
    }

 public static void test {
        String value = "4243212355312";
        MyBloomFilter filter = new MyBloomFilter();
        System.out.println(filter.contains(value));
        filter.add(value);
        System.out.println(filter.contains(value));
    }

<dependency>
    <groupId>com.google.guava</groupId>
    <artifactId>guava</artifactId>
    <version>27.0.1-jre</version>
</dependency>

public static void MyBloomFilterSysConfig {
 @Autowired
 OrderMapper orderMapper
 
// 1.创建布隆过滤器  第二个参数为预期数据量10000000，第三个参数为错误率0.00001
BloomFilter<CharSequence> bloomFilter =  BloomFilter.create(Funnels.stringFunnel(Charset.forName("utf-8")),10000000,0.00001);
// 2.获取所有的订单，并将订单的id放进布隆过滤器里面
List<Order> orderList = orderMapper.findAll()
for (Order order;orderList ) {
    Long id = order.getId();
    bloomFilter.put("" + id);
}

}

// 判断订单id是否在布隆过滤器中存在
bloomFilter.mightContain("" + id)

// 获取库存数量
public String getProduceNum(String key) {
    try {
        synchronized (this) {   //加锁
            // 缓存中取数据，并存入缓存中
            int num= Integer.parseInt(redisTemplate.opsForValue().get(key));
        if (num> 0) {
            //没查一次库存-1
            redisTemplate.opsForValue().set(key,(num- 1) + "");
            System.out.println("剩余的库存为num：" + (num- 1));
        } else {
            System.out.println("库存为0");
        }
    }
} catch (NumberFormatException e) {
    e.printStackTrace();
} finally {
}
return "OK";

}

public String getProduceNum(String key) {
    // 获取分布式锁
    RLock lock = redissonClient.getLock(key);
    try {
        // 获取库存数
        int num= Integer.parseInt(redisTemplate.opsForValue().get(key));  
        // 上锁           
        lock.lock();
        if (num> 0) {
            //减少库存，并存入缓存中
            redisTemplate.opsForValue().set(key,(num - 1) + "");
            System.out.println("剩余库存为num：" + (num- 1));
        } else {
            System.out.println("库存已经为0");
        }
    } catch (NumberFormatException e) {
        e.printStackTrace();
    } finally {
        //解锁
        lock.unlock();
    }
    return "OK";
}