改造库存

fs-common/src/main/java/com/fs/common/annotation/RateLimiter.java

@@ -37,4 +37,9 @@ public @interface RateLimiter
      * 限流类型
      */
     public LimitType limitType() default LimitType.DEFAULT;
+
+    /**
+     * 消息提示
+     */
+    public String msg() default "访问过于频繁，请稍后再试";
 }

fs-user-app/src/main/java/com/fs/app/controller/live/LiveOrderController.java

@@ -10,6 +10,7 @@ import com.alibaba.fastjson.TypeReference;
 import com.fs.app.annotation.Login;
 import com.fs.app.controller.AppBaseController;
 import com.fs.common.annotation.Log;
+import com.fs.common.annotation.RateLimiter;
 import com.fs.common.annotation.RepeatSubmit;
 import com.fs.common.core.domain.AjaxResult;
 import com.fs.common.core.domain.R;
@@ -268,6 +269,7 @@ public class LiveOrderController extends AppBaseController
     @Login
     @ApiOperation("确认订单")
     @PostMapping("/confirm")
+    @RateLimiter(time = 10, count = 10000, msg = "当前下单的人比较多，请稍后再试")
     public R confirm(@Validated @RequestBody LiveOrderConfirmParam param, HttpServletRequest request){
         param.setUserId(Long.valueOf(getUserId()));
         return orderService.confirmOrder(param);
@@ -275,6 +277,7 @@ public class LiveOrderController extends AppBaseController
     @Login
     @ApiOperation("计算订单金额")
     @PostMapping("/computed")
+    @RateLimiter(time = 10, count = 10000, msg = "当前下单的人比较多，请稍后再试")
     public R computed(@Validated @RequestBody LiveOrderComputedParam param, HttpServletRequest request){
         LiveOrderComputeDTO dto=orderService.computedOrder(Long.parseLong(getUserId()),param);
         return R.ok().put("data",dto);
@@ -331,6 +334,7 @@ public class LiveOrderController extends AppBaseController
     @Login
     @ApiOperation("创建订单")
     @PostMapping("/create")
+    @RateLimiter(time = 10, count = 10000, msg = "当前下单的人比较多，请稍后再试")
     public R create(@Validated @RequestBody LiveOrder param, HttpServletRequest request){
         // 校验appId
         if (StringUtils.isEmpty(param.getAppId())) {

fs-user-app/src/main/java/com/fs/framework/aspectj/RateLimiterAspect.java

@@ -26,12 +26,10 @@ import java.util.List;
 /**
  * 限流处理
  *
-
  */
 @Aspect
 @Component
-public class RateLimiterAspect
-{
+public class RateLimiterAspect {
     private static final Logger log = LoggerFactory.getLogger(RateLimiterAspect.class);
 
     private RedisTemplate<Object, Object> redisTemplate;
@@ -39,48 +37,39 @@ public class RateLimiterAspect
     private RedisScript<Long> limitScript;
 
     @Autowired
-    public void setRedisTemplate1(RedisTemplate<Object, Object> redisTemplate)
-    {
+    public void setRedisTemplate1(RedisTemplate<Object, Object> redisTemplate) {
         this.redisTemplate = redisTemplate;
     }
 
     @Autowired
-    public void setLimitScript(RedisScript<Long> limitScript)
-    {
+    public void setLimitScript(RedisScript<Long> limitScript) {
         this.limitScript = limitScript;
     }
 
     // 配置织入点
     @Pointcut("@annotation(com.fs.common.annotation.RateLimiter)")
-    public void rateLimiterPointCut()
-    {
+    public void rateLimiterPointCut() {
     }
 
     @Before("rateLimiterPointCut()")
-    public void doBefore(JoinPoint point) throws Throwable
-    {
+    public void doBefore(JoinPoint point) throws Throwable {
         RateLimiter rateLimiter = getAnnotationRateLimiter(point);
         String key = rateLimiter.key();
         int time = rateLimiter.time();
         int count = rateLimiter.count();
+        String msg = rateLimiter.msg();
 
         String combineKey = getCombineKey(rateLimiter, point);
         List<Object> keys = Collections.singletonList(combineKey);
-        try
-        {
+        try {
             Long number = redisTemplate.execute(limitScript, keys, count, time);
-            if (StringUtils.isNull(number) || number.intValue() > count)
-            {
-                throw new ServiceException("访问过于频繁，请稍后再试");
+            if (number.intValue() > count) {
+                throw new ServiceException(msg);
             }
             log.info("限制请求'{}',当前请求'{}',缓存key'{}'", count, number.intValue(), key);
-        }
-        catch (ServiceException e)
-        {
+        } catch (ServiceException e) {
             throw e;
-        }
-        catch (Exception e)
-        {
+        } catch (Exception e) {
             throw new RuntimeException("服务器限流异常，请稍后再试");
         }
     }
@@ -88,24 +77,20 @@ public class RateLimiterAspect
     /**
      * 是否存在注解，如果存在就获取
      */
-    private RateLimiter getAnnotationRateLimiter(JoinPoint joinPoint)
-    {
+    private RateLimiter getAnnotationRateLimiter(JoinPoint joinPoint) {
         Signature signature = joinPoint.getSignature();
         MethodSignature methodSignature = (MethodSignature) signature;
         Method method = methodSignature.getMethod();
 
-        if (method != null)
-        {
+        if (method != null) {
             return method.getAnnotation(RateLimiter.class);
         }
         return null;
     }
 
-    public String getCombineKey(RateLimiter rateLimiter, JoinPoint point)
-    {
-        StringBuffer stringBuffer = new StringBuffer(rateLimiter.key());
-        if (rateLimiter.limitType() == LimitType.IP)
-        {
+    public String getCombineKey(RateLimiter rateLimiter, JoinPoint point) {
+        StringBuilder stringBuffer = new StringBuilder(rateLimiter.key());
+        if (rateLimiter.limitType() == LimitType.IP) {
             stringBuffer.append(IpUtils.getIpAddr(ServletUtils.getRequest()));
         }
         MethodSignature signature = (MethodSignature) point.getSignature();

fs-user-app/src/main/java/com/fs/framework/config/properties/DruidProperties.java

@@ -1,77 +1,77 @@
-package com.fs.framework.config.properties;
-
-import com.alibaba.druid.pool.DruidDataSource;
-import org.springframework.beans.factory.annotation.Value;
-import org.springframework.context.annotation.Configuration;
-
-/**
- * druid 配置属性
- *
-
- */
-@Configuration
-public class DruidProperties
-{
-    @Value("${spring.datasource.mysql.druid.initialSize}")
-    private int initialSize;
-
-    @Value("${spring.datasource.mysql.druid.minIdle}")
-    private int minIdle;
-
-    @Value("${spring.datasource.mysql.druid.maxActive}")
-    private int maxActive;
-
-    @Value("${spring.datasource.mysql.druid.maxWait}")
-    private int maxWait;
-
-    @Value("${spring.datasource.mysql.druid.timeBetweenEvictionRunsMillis}")
-    private int timeBetweenEvictionRunsMillis;
-
-    @Value("${spring.datasource.mysql.druid.minEvictableIdleTimeMillis}")
-    private int minEvictableIdleTimeMillis;
-
-    @Value("${spring.datasource.mysql.druid.maxEvictableIdleTimeMillis}")
-    private int maxEvictableIdleTimeMillis;
-
-    @Value("${spring.datasource.mysql.druid.validationQuery}")
-    private String validationQuery;
-
-    @Value("${spring.datasource.mysql.druid.testWhileIdle}")
-    private boolean testWhileIdle;
-
-    @Value("${spring.datasource.mysql.druid.testOnBorrow}")
-    private boolean testOnBorrow;
-
-    @Value("${spring.datasource.mysql.druid.testOnReturn}")
-    private boolean testOnReturn;
-
-    public DruidDataSource dataSource(DruidDataSource datasource)
-    {
-        /** 配置初始化大小、最小、最大 */
-        datasource.setInitialSize(initialSize);
-        datasource.setMaxActive(maxActive);
-        datasource.setMinIdle(minIdle);
-
-        /** 配置获取连接等待超时的时间 */
-        datasource.setMaxWait(maxWait);
-
-        /** 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒 */
-        datasource.setTimeBetweenEvictionRunsMillis(timeBetweenEvictionRunsMillis);
-
-        /** 配置一个连接在池中最小、最大生存的时间，单位是毫秒 */
-        datasource.setMinEvictableIdleTimeMillis(minEvictableIdleTimeMillis);
-        datasource.setMaxEvictableIdleTimeMillis(maxEvictableIdleTimeMillis);
-
-        /**
-         * 用来检测连接是否有效的sql，要求是一个查询语句，常用select 'x'。如果validationQuery为null，testOnBorrow、testOnReturn、testWhileIdle都不会起作用。
-         */
-        datasource.setValidationQuery(validationQuery);
-        /** 建议配置为true，不影响性能，并且保证安全性。申请连接的时候检测，如果空闲时间大于timeBetweenEvictionRunsMillis，执行validationQuery检测连接是否有效。 */
-        datasource.setTestWhileIdle(testWhileIdle);
-        /** 申请连接时执行validationQuery检测连接是否有效，做了这个配置会降低性能。 */
-        datasource.setTestOnBorrow(testOnBorrow);
-        /** 归还连接时执行validationQuery检测连接是否有效，做了这个配置会降低性能。 */
-        datasource.setTestOnReturn(testOnReturn);
-        return datasource;
-    }
-}
+//package com.fs.framework.config.properties;
+//
+//import com.alibaba.druid.pool.DruidDataSource;
+//import org.springframework.beans.factory.annotation.Value;
+//import org.springframework.context.annotation.Configuration;
+//
+///**
+// * druid 配置属性
+// *
+//
+// */
+//@Configuration
+//public class DruidProperties
+//{
+//    @Value("${spring.datasource.mysql.druid.initialSize}")
+//    private int initialSize;
+//
+//    @Value("${spring.datasource.mysql.druid.minIdle}")
+//    private int minIdle;
+//
+//    @Value("${spring.datasource.mysql.druid.maxActive}")
+//    private int maxActive;
+//
+//    @Value("${spring.datasource.mysql.druid.maxWait}")
+//    private int maxWait;
+//
+//    @Value("${spring.datasource.mysql.druid.timeBetweenEvictionRunsMillis}")
+//    private int timeBetweenEvictionRunsMillis;
+//
+//    @Value("${spring.datasource.mysql.druid.minEvictableIdleTimeMillis}")
+//    private int minEvictableIdleTimeMillis;
+//
+//    @Value("${spring.datasource.mysql.druid.maxEvictableIdleTimeMillis}")
+//    private int maxEvictableIdleTimeMillis;
+//
+//    @Value("${spring.datasource.mysql.druid.validationQuery}")
+//    private String validationQuery;
+//
+//    @Value("${spring.datasource.mysql.druid.testWhileIdle}")
+//    private boolean testWhileIdle;
+//
+//    @Value("${spring.datasource.mysql.druid.testOnBorrow}")
+//    private boolean testOnBorrow;
+//
+//    @Value("${spring.datasource.mysql.druid.testOnReturn}")
+//    private boolean testOnReturn;
+//
+//    public DruidDataSource dataSource(DruidDataSource datasource)
+//    {
+//        /** 配置初始化大小、最小、最大 */
+//        datasource.setInitialSize(initialSize);
+//        datasource.setMaxActive(maxActive);
+//        datasource.setMinIdle(minIdle);
+//
+//        /** 配置获取连接等待超时的时间 */
+//        datasource.setMaxWait(maxWait);
+//
+//        /** 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒 */
+//        datasource.setTimeBetweenEvictionRunsMillis(timeBetweenEvictionRunsMillis);
+//
+//        /** 配置一个连接在池中最小、最大生存的时间，单位是毫秒 */
+//        datasource.setMinEvictableIdleTimeMillis(minEvictableIdleTimeMillis);
+//        datasource.setMaxEvictableIdleTimeMillis(maxEvictableIdleTimeMillis);
+//
+//        /**
+//         * 用来检测连接是否有效的sql，要求是一个查询语句，常用select 'x'。如果validationQuery为null，testOnBorrow、testOnReturn、testWhileIdle都不会起作用。
+//         */
+//        datasource.setValidationQuery(validationQuery);
+//        /** 建议配置为true，不影响性能，并且保证安全性。申请连接的时候检测，如果空闲时间大于timeBetweenEvictionRunsMillis，执行validationQuery检测连接是否有效。 */
+//        datasource.setTestWhileIdle(testWhileIdle);
+//        /** 申请连接时执行validationQuery检测连接是否有效，做了这个配置会降低性能。 */
+//        datasource.setTestOnBorrow(testOnBorrow);
+//        /** 归还连接时执行validationQuery检测连接是否有效，做了这个配置会降低性能。 */
+//        datasource.setTestOnReturn(testOnReturn);
+//        return datasource;
+//    }
+//}