Распределённый инструмент Redis

<dependency>
    <groupId>top.crossoverjie.opensource</groupId>
    <artifactId>distributed-redis-tool</artifactId>
    <version>1.0.3</version>
</dependency>

@Configuration
public class RedisLockConfig {

    @Bean
    public RedisLock build(){
        // Необходимо получить соединение с Redis
        RedisLock redisLock = new RedisLock();
        HostAndPort hostAndPort = new HostAndPort("127.0.0.1",7000);
        JedisCluster jedisCluster = new JedisCluster(hostAndPort);
        RedisLock redisLock = new RedisLock.Builder(jedisCluster)
                .lockPrefix("lock_test")
                .sleepTime(100)
                .build();

        return redisLock;
    }
}

@Autowired
private RedisLock redisLock;

public void use() {
    String key = "ключ";
    String request = UUID.randomUUID().toString();
    try {
        boolean lockTest = redisLock.tryLock(key, request);
        if (!lockTest) {
            System.out.println("Ошибка при получении блока");
            return;
        }

        // выполнение действий

    } finally {
        redisLock.unlock(key, request);
    }
}

redisLock.lock(String key, String request);
```#### Блокирующий замок с пользовательским временем блокировки

```java
redisLock.lock(String key, String request, int blockTime);

<dependency>
    <groupId>top.crossoverjie.opensource</groupId>
    <artifactId>distributed-redis-tool</artifactId>
    <version>1.0.3</version>
</dependency>

@Configuration
public class RedisLimitConfig {
    private Logger logger = LoggerFactory.getLogger(RedisLimitConfig.class);
    @Value("${redis.limit}")
    private int limit;
    @Autowired
    private JedisConnectionFactory jedisConnectionFactory;
    @Bean
    public RedisLimit build() {
        RedisLimit redisLimit = new RedisLimit.Builder(jedisConnectionFactory, RedisToolsConstant.SINGLE)
                .limit(limit)
                .build();
        return redisLimit;
    }
}

@ComponentScan(value = "com.crossoverjie.distributed.intercept")

boolean limit = redisLimit.limit();
if (!limit){
    res.setCode(StatusEnum.REQUEST_LIMIT.getCode());
    res.setMessage(StatusEnum.REQUEST_LIMIT.getMessage());
    return res ;
}

@ControllerLimit
public BaseResponse<OrderNoResVO> getOrderNoLimit(@RequestBody OrderNoReqVO orderNoReq) {
    BaseResponse<OrderNoResVO> res = new BaseResponse();
    res.setReqNo(orderNoReq.getReqNo());
    if (null == orderNoReq.getAppId()) {
        throw new SBCException(StatusEnum.FAIL);
    }
    OrderNoResVO orderNoRes = new OrderNoResVO();
    orderNoRes.setOrderId(DateUtil.getLongTime());
    res.setCode(StatusEnum.SUCCESS.getCode());
    res.setMessage(StatusEnum.SUCCESS.getMessage());
    res.setDataBody(orderNoRes);
    return res;
}
```Используется для `@RequestMapping`.


#### **@SpringControllerLimit**

Если вы используете нативный Spring:

```java
@SpringControllerLimit(errorCode = 200, errorMsg = "ограничение запроса превышено")
@RequestMapping("/createOptimisticLimitOrderByRedis/{sid}")
@ResponseBody
public String createOptimisticLimitOrderByRedis(@PathVariable int sid) {
    logger.info("sid=[{}]", sid);
    int id = 0;
    try {
        id = orderService.createOptimisticOrderUseRedis(sid);
    } catch (Exception e) {
        logger.error("Exception", e);
    }
    return String.valueOf(id);
}

<mvc:interceptors>
    <mvc:interceptor>
        <mvc:mapping path="/**"/>
        <bean class="com.crossoverjie.distributed.intercept.SpringMVCIntercept"/>
    </mvc:interceptor>
</mvc:interceptors>

@CommonLimit
public void anyMethod() {}