接口请求耗时和接口的访问次数是我们比较关注点之一，接口请求时间的快慢就代表着获取到对应的数据的快慢，也代表着用户请求页面数据的快慢

以往我们的做法可能是在每一个接口的方法中的开始添加当前时间，结尾用当前时间减去开始时间就表示该接口的访问时间

1.  
   @RequestMapping("/test")
2.  
   public String test02(){
3.  
       long startTime = System.currentTimeMillis();
4.  
       //此处的调用业务代码省略
5.  
       System.out.println("访问时间为：" (System.currentTimeMillis()-startTime));
6.  
       return "访问接口成功";
7.  
   }

那如果有几百个接口的话，每一个接口都需要统计对应的访问时间的话，那就要写几百遍，这很不符合我们的常理，所以有没有一种办法是可以不修改对应的接口方法，并且只需要写一遍就能够应用到所有的接口上面或者指定的接口上面

我们第一时间就可以想到AOP技术，AOP是在Spring当中比较常见的技术， AOP就是在不修改原来的代码就可以对接口方法进行增强的作用，利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率

https://pic.imgdb.cn/item/62ea80a616f2c2beb1826938.png

有了解决方案我们就可以进行代码的构建，首先我们直接新建一个SpringBoot项目即可，然后进行下面的操作

1、引入依赖

所以要用到AOP技术，我们首先需要导入对应的依赖，Redis依赖也导入一下，后面统计接口访问的次数时也需要用到

1.  
   <!--引入AOP依赖-->
2.  
   <dependency>
3.  
       <groupId>org.springframework.boot</groupId>
4.  
       <artifactId>spring-boot-starter-aop</artifactId>
5.  
   </dependency>
6.  
   <!--引入Redis依赖-->
7.  
   <dependency>
8.  
       <groupId>org.springframework.boot</groupId>
9.  
       <artifactId>spring-boot-starter-data-redis</artifactId>
10.  
    </dependency>

2、自定义注解

统计接口的耗时和访问次数也不需要每一个接口都使用，比如说一些不经常访问的接口就没有统计他的访问次数，所以我们可以自定义一个注解，只要对应的接口方法上应用了这个注解，Spring会进行扫描，并执行对应的操作

1.  
   //统计接口的耗时以及再规定事件内的访问次数，作用域为方法上
2.  
   @Target(ElementType.METHOD)
3.  
   @Retention(RetentionPolicy.RUNTIME)
4.  
   public @interface TakeCount {
5.  
    
6.  
       //表示统计接口次数的时间，默认为60秒
7.  
       int time() default 60;
8.  
    
9.  
   }

3、配置Redis过期键监听以及对应配置类

统计接口在指定时间内的访问次数，我们可以监听Redis对应过期的key来获取对应的访问次数，过期的时间是自己在注解的参数中设置的时间，如果没有设置，默认就是60秒

1.  
   //对Redis过期的key进行监听
2.  
   @Slf4j
3.  
   public class KeyExpiredListener extends KeyExpirationEventMessageListener {
4.  
    
5.  
       @Autowired
6.  
       @Qualifier("myRedisTemplate")
7.  
       private RedisTemplate redisTemplate;
8.  
    
9.  
       public KeyExpiredListener(RedisMessageListenerContainer listenerContainer) {
10.  
            super(listenerContainer);
11.  
        }
12.  
     
13.  
        @Override
14.  
        public void onMessage(Message message, byte[] pattern) {
15.  
            //获取对应的接口的访问次数
16.  
            log.info("{}接口在规定时间内被访问{}次",message,redisTemplate.opsForValue().get(message.toString() ":count"));
17.  
            //将对应接口的访问数据的key进行删除
18.  
            redisTemplate.delete(message.toString() ":count");
19.  
        }
20.  
    }

接着还需要写一个Redis的配置类，将刚刚的监听类注入到Spring的容器当中，并且自定义Redis的字符串序列化，默认的为jdk本身的序列化，存储时会乱码

1.  
   //Redis配置类
2.  
   @Configuration
3.  
   public class RedisConfiguration {
4.  
    
5.  
       @Autowired
6.  
       private RedisConnectionFactory redisConnectionFactory;
7.  
    
8.  
       @Bean
9.  
       public RedisMessageListenerContainer redisMessageListenerContainer() {
10.  
            RedisMessageListenerContainer redisMessageListenerContainer = new RedisMessageListenerContainer();
11.  
            redisMessageListenerContainer.setConnectionFactory(redisConnectionFactory);
12.  
            return redisMessageListenerContainer;
13.  
        }
14.  
     
15.  
        @Bean
16.  
        public KeyExpiredListener keyExpiredListener() {
17.  
            return new KeyExpiredListener(this.redisMessageListenerContainer());
18.  
        }
19.  
     
20.  
        //配置Redis的字符串序列化，默认的为jdk本身的序列化，存储时会乱码
21.  
        @Bean("myRedisTemplate")
22.  
        @SuppressWarnings("all")
23.  
        public RedisTemplate redisTemplate(RedisConnectionFactory factory){
24.  
            RedisTemplate<String, Object> template = new RedisTemplate<>();
25.  
     
26.  
            //key序列化
27.  
            template.setKeySerializer(new StringRedisSerializer());
28.  
            //value序列化
29.  
            template.setValueSerializer(new GenericJackson2JsonRedisSerializer());
30.  
            //hash的key序列化
31.  
            template.setHashKeySerializer(new StringRedisSerializer());
32.  
            //hash的value序列化
33.  
            template.setHashValueSerializer(new GenericJackson2JsonRedisSerializer());
34.  
     
35.  
            template.setConnectionFactory(factory);
36.  
            return template;
37.  
        }
38.  
     
39.  
    }

4、定义AOP切面

如果接口方法上应用了自定义的注解，那么就会被Spring扫描到，当接口方法被执行的时候，就会先执行doBefore方法，记录开始的时间并且将该接口方法对应的访问次数加一，在接口方法执行完毕之后就会执行doAfter，将接口调用的时间输出到控制台上

1.  
   @Aspect
2.  
   @Component
3.  
   @Slf4j
4.  
   public class TakeCountAspect {
5.  
    
6.  
       @Autowired
7.  
       @Qualifier("myRedisTemplate")
8.  
       private RedisTemplate redisTemplate;
9.  
    
10.  
        //用ThreadLocal记录当前线程访问接口的开始时间
11.  
        private ThreadLocal<Long> startTime = new ThreadLocal<>();
12.  
     
13.  
        //扫描所有添加了@TakeCount注解的方法
14.  
        @Before("@annotation(takeCount)")
15.  
        public void doBefore(TakeCount takeCount){
16.  
            //记录接口的开始时间
17.  
            startTime.set(System.currentTimeMillis());
18.  
            //接收到请求，记录请求内容
19.  
            ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
20.  
            HttpServletRequest request = attributes.getRequest();
21.  
            //记录请求的内容
22.  
            String url = request.getRequestURL().toString();
23.  
            //如果缓存当中没有当前接口的key就进行存储，如果有的话就对应接口的访问数据自增加一
24.  
            Boolean ifAbsent = redisTemplate.opsForValue().setIfAbsent(url, "num",takeCount.time(), TimeUnit.SECONDS);
25.  
            if(ifAbsent){
26.  
                redisTemplate.opsForValue().set(url ":count",1);
27.  
            }else{
28.  
                redisTemplate.opsForValue().increment(url ":count");
29.  
            }
30.  
        }
31.  
     
32.  
        //接口方法执行完成之后
33.  
        @After("@annotation(TakeCount)")
34.  
        public void doAfter(JoinPoint joinPoint){
35.  
            //将当前的事件减去之前的事件
36.  
            log.info("{}访问时间为：{}ms",joinPoint.getSignature().getName(),(System.currentTimeMillis()-startTime.get()));
37.  
        }
38.  
     
39.  
    }

5、定义接口方法

在Controller层中自定义一个接口，然后添加上 @TakeCount注解，time根据自己可设置可不设置 （默认单位为秒）

1.  
   @RestController
2.  
   @RequestMapping("/test")
3.  
   public class TestController {
4.  
    
5.  
       @RequestMapping("/02")
6.  
       @TakeCount(time = 15)
7.  
       public String test02(){
8.  
           //此处的逻辑代码省略
9.  
           return "访问接口成功";
10.  
        }
11.  
        
12.  
    }

6、运行测试

最后在浏览器中访问localhost:8080/test/02就能看到对应的效果啦

image-20220803222336174

已上SpringBoot统计接口请求耗时以及在指定时间内的访问次数的方法，希望文章内容对大家有所帮助，也纯属是个人的做法，如果有好的方法也可以自己试一试！

这篇好文章是转载于：学新通技术网