<!-- honey-redis-->
    <dependency>
        <groupId>red.honey</groupId>
        <artifactId>honey-redis</artifactId>
        <version>1.1.0</version>
    </dependency>

  @EnableHoneyRedis
  public class DemoApplication {
      public static void main(String[] args) {
          SpringApplication.run(DemoApplication.class, args);
      }
  }

    @Autowired
    private HoneyRedis honeyRedis; 

    public boolean isReqDuplicate(String userId, String method, String deDuplicateParam)
  
    public boolean isReqDuplicate(String key)

   @SpringBootTest
   @RunWith(SpringRunner.class)
   @Slf4j
   public class HoneyRedisTest {
       // 请求总数
       public static int clientTotal = 50000;
       // 同时并发执行的线程数
       public static int threadTotal = 50000;
       @Autowired
       private HoneyRedisId honeyRedisId;
      
       @Test
       public void test() throws InterruptedException {
           ExecutorService executorService = Executors.newCachedThreadPool();
           // 信号量，此处用于控制并发的线程数
           final Semaphore semaphore = new Semaphore(threadTotal);
           // 闭锁，可实现计数器递减
           final CountDownLatch countDownLatch = new CountDownLatch(clientTotal);
           final List<String> rs = new LinkedList<>();
           for (int i = 0; i < clientTotal; i++) {
               executorService.execute(() -> {
                   try {
                       // 执行此方法用于获取执行许可，当总计未释放的许可数不超过规定threadTotal时，
                       // 允许通行，否则线程阻塞等待，直到获取到许可。
                       semaphore.acquire();
                       String id = honeyRedisId.getGloballyUniqueId("honeyRedis");
                       // 此处可替代为插入数据库，uid建立唯一索引
                       xxxService.insert(id);
                       log.info(id);
                       rs.add(id);
                       // 释放许可
                       semaphore.release();
                   } catch (Exception e) {
                       log.warn(e.getMessage());
                   }
                   // 闭锁减一
                   countDownLatch.countDown();
               });
           }
           //线程阻塞，直到闭锁值为0时，阻塞才释放，继续往下执行
           countDownLatch.await();
           executorService.shutdown();
           // 如果你不想建立数据表来验证的话，可以考虑下面这个来测试是否会
           // 生成重复的id哦
           log.info("去重前个数：{}", rs.size());
           Map<String, Long> map = rs.stream().collect(Collectors.groupingBy(p -> p, Collectors.counting()));
           List<String> repeat = new ArrayList<>();
           map.keySet().forEach(key -> {
               if (map.get(key) > 1) {
                   repeat.add(key);
               }
           });
           log.info("重复个数：{}", repeat.size());
           log.info(JSON.toJSONString(repeat));
           log.info("去重后个数：{}", rs.size() - repeat.size());
       }
   }

 @RestController
 @RequestMapping("/honeyRedis")
 @Slf4j
 public class HoneyRedisController {
     @Autowired
     private HoneyRedisLock honeyRedisLock;
     @GetMapping("/lock")
     @AuthSkip
     public String lock(@RequestParam("key") String key) {
         ExecutorService executorService = Executors.newCachedThreadPool();
         for (int i = 0; i < 10; i++) {
             executorService.execute(() -> {
                 boolean lock = honeyRedisLock.tryLock(key,4);
                 if (lock) {
                     try {
                         // 模拟处理业业务
                         log.info("我拿到锁了，进来执行业务处理");
                         Thread.sleep(1000L);
                     } catch (InterruptedException e) {
                         log.warn(e.getMessage());
                     }
                     log.info(DateFormatUtils.format(new Date(), "yyyy-MM-dd HH:mm:ss"));
                     honeyRedisLock.unlock(key);
                 } else {
                     log.info("我拿不到锁，还等了4秒，还是拿不到锁，老子不干了");
                 }
             });
         }
         executorService.shutdown();
         return "SUCCESS";
     }
 }

    @Before
    public void init() {

        positionInfos = new ArrayList<>();
        positionInfos.add(new PositionInfo("合肥", 117.17, 31.52));
        positionInfos.add(new PositionInfo("安庆", 117.02, 30.31));
        positionInfos.add(new PositionInfo("淮北", 116.47, 33.57));
        positionInfos.add(new PositionInfo("宿州", 116.58, 33.38));
        positionInfos.add(new PositionInfo("阜阳", 115.48, 32.54));
        positionInfos.add(new PositionInfo("蚌埠", 117.21, 32.56));
        positionInfos.add(new PositionInfo("黄山", 118.18, 29.43));
    }

    @Test
    public void testAddGeo() {
        honeyGeo.addGeoBean("HB_GEO_KEY", positionInfos);
    }

    @Test
    public void testAddGeo() {
        honeyGeo.addGeoBean("HB_GEO_KEY", positionInfos);
    }

    @Test
    public void testGet() {
        List<Point> position = honeyGeo.getPosition("HB_GEO_KEY", "合肥");
        System.out.println(JSON.toJSONString(position));
    }

    @Test
    public void testDistance() {
        Distance distance = honeyGeo.distance("HB_GEO_KEY", "合肥", "黄山", Metrics.KILOMETERS);
        System.out.println(JSON.toJSONString(distance));
    }