5.拦截与切面 | Next-gen Tech Edu

过滤器

Mon, 01 Jan 0001 00:00:00 +0000

Filter | 过滤器

过滤器配置

现在我们通过过滤器来实现记录请求执行时间的功能，其实现如下：

public class LogCostFilter implements Filter {
 @Override
 public void init(FilterConfig filterConfig) throws ServletException {

 }

 @Override
 public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
 long start = System.currentTimeMillis();
 filterChain.doFilter(servletRequest,servletResponse);
 System.out.println("Execute cost="+(System.currentTimeMillis()-start));
 }

 @Override
 public void destroy() {

 }
}

这段代码的逻辑比较简单，就是在方法执行前先记录时间戳，然后通过过滤器链完成请求的执行，在返回结果之间计算执行的时间。这里需要主要，这个类必须继承 Filter 类，这个是 Servlet 的规范，这个跟以前的 Web 项目没区别。但是，有了过滤器类以后，以前的 web 项目可以在 web.xml 中进行配置，但是 spring boot 项目并没有 web.xml 这个文件，那怎么配置？在 Spring boot 中，我们需要 FilterRegistrationBean 来完成配置。其实现过程如下：

@Configuration
public class FilterConfig {

 @Bean
 public FilterRegistrationBean registFilter() {
 FilterRegistrationBean registration = new FilterRegistrationBean();
 registration.setFilter(new LogCostFilter());
 registration.addUrlPatterns("/*");
 registration.setName("LogCostFilter");
 registration.setOrder(1);
 return registration;
 }

}

除了通过 FilterRegistrationBean 来配置以外，还有一种更直接的办法，直接通过注解就可以完成了：

@WebFilter(urlPatterns = "/*", filterName = "logFilter2")
public class LogCostFilter2 implements Filter {
 @Override
 public void init(FilterConfig filterConfig) throws ServletException {

 }

 @Override
 public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
 long start = System.currentTimeMillis();
 filterChain.doFilter(servletRequest, servletResponse);
 System.out.println("LogFilter2 Execute cost=" + (System.currentTimeMillis() - start));
 }

 @Override
 public void destroy() {

 }
}

这里直接用@WebFilter 就可以进行配置，同样，可以设置 url 匹配模式，过滤器名称等。这里需要注意一点的是@WebFilter 这个注解是 Servlet3.0 的规范，并不是 Spring boot 提供的。除了这个注解以外，我们还需在配置类中加另外一个注解：@ServletComponetScan，指定扫描的包。

@SpringBootApplication
@MapperScan("com.pandy.blog.dao")
@ServletComponentScan("com.pandy.blog.filters")
public class Application {
 public static void main(String[] args) throws Exception {
 SpringApplication.run(Application.class, args);
 }
}

监听器

Mon, 01 Jan 0001 00:00:00 +0000

Spring 中的监听器

什么是 web 监听器？web 监听器是一种 Servlet 中特殊的类，它们能帮助开发者监听 web 中特定的事件，比如 ServletContext, HttpSession, ServletRequest 的创建和销毁；变量的创建、销毁和修改等。可以在某些动作前后增加处理，实现监控。

Spring Boot 中监听器的使用

Web 监听器的使用场景很多，比如监听 servlet 上下文用来初始化一些数据、监听 http session 用来获取当前在线的人数、监听客户端请求的 servlet request 对象来获取用户的访问信息等等。

监听 Servlet 上下文对象

监听 servlet 上下文对象可以用来初始化数据，用于缓存。什么意思呢？我举一个很常见的场景，比如用户在点击某个站点的首页时，一般都会展现出首页的一些信息，而这些信息基本上或者大部分时间都保持不变的，但是这些信息都是来自数据库。如果用户的每次点击，都要从数据库中去获取数据的话，用户量少还可以接受，如果用户量非常大的话，这对数据库也是一笔很大的开销。

针对这种首页数据，大部分都不常更新的话，我们完全可以把它们缓存起来，每次用户点击的时候，我们都直接从缓存中拿，这样既可以提高首页的访问速度，又可以降低服务器的压力。如果做的更加灵活一点，可以再加个定时器，定期的来更新这个首页缓存。就类似与 CSDN 个人博客首页中排名的变化一样。


@Service
public class UserService {

 /**
 * 获取用户信息
 * @return
 */
 public User getUser() {
 // 实际中会根据具体的业务场景，从数据库中查询对应的信息
 return new User(1L, "xxx", "123456");
 }
}

然后写一个监听器，实现 ApplicationListener<ContextRefreshedEvent> 接口，重写 onApplicationEvent 方法，将 ContextRefreshedEvent 对象传进去。如果我们想在加载或刷新应用上下文时，也重新刷新下我们预加载的资源，就可以通过监听 ContextRefreshedEvent 来做这样的事情。如下：

/**
 * 使用ApplicationListener来初始化一些数据到application域中的监听器
 */
@Component
public class MyServletContextListener implements ApplicationListener<ContextRefreshedEvent> {
 @Override
 public void onApplicationEvent(ContextRefreshedEvent contextRefreshedEvent) {
 // 先获取到application上下文
 ApplicationContext applicationContext = contextRefreshedEvent.getApplicationContext();
 // 获取对应的service
 UserService userService = applicationContext.getBean(UserService.class);
 User user = userService.getUser();
 // 获取application域对象，将查到的信息放到application域中
 ServletContext application = applicationContext.getBean(ServletContext.class);
 application.setAttribute("user", user);
 }
}

正如注释中描述的一样，首先通过 contextRefreshedEvent 来获取 application 上下文，再通过 application 上下文来获取 UserService 这个 bean，项目中可以根据实际业务场景，也可以获取其他的 bean，然后再调用自己的业务代码获取相应的数据，最后存储到 application 域中，这样前端在请求相应数据的时候，我们就可以直接从 application 域中获取信息，减少数据库的压力。下面写一个 Controller 直接从 application 域中获取 user 信息来测试一下。

@RestController
@RequestMapping("/listener")
public class TestController {
 @GetMapping("/user")
 public User getUser(HttpServletRequest request) {
 ServletContext application = request.getServletContext();
 return (User) application.getAttribute("user");
 }
}

启动项目，在浏览器中输入 http://localhost:8080/listener/user 测试一下即可，如果正常返回 user 信息，那么说明数据已经缓存成功。

监听 HTTP 会话 Session 对象

监听器还有一个比较常用的地方就是用来监听 session 对象，来获取在线用户数量，现在有很多开发者都有自己的网站，监听 session 来获取当前在下用户数量是个很常见的使用场景，下面来介绍一下如何来使用。

/**
 * 使用HttpSessionListener统计在线用户数的监听器

 * @date 2018/07/05
 */
@Component
public class MyHttpSessionListener implements HttpSessionListener {
 private static final Logger logger = LoggerFactory.getLogger(MyHttpSessionListener.class);
 /**
 * 记录在线的用户数量
 */
 public Integer count = 0;
 @Override
 public synchronized void sessionCreated(HttpSessionEvent httpSessionEvent) {
 logger.info("新用户上线了");
 count++;
 httpSessionEvent.getSession().getServletContext().setAttribute("count", count);
 }
 @Override
 public synchronized void sessionDestroyed(HttpSessionEvent httpSessionEvent) {
 logger.info("用户下线了");
 count--;
 httpSessionEvent.getSession().getServletContext().setAttribute("count", count);
 }
}

可以看出，首先该监听器需要实现 HttpSessionListener 接口，然后重写 sessionCreated 和 sessionDestroyed 方法，在 sessionCreated 方法中传递一个 HttpSessionEvent 对象，然后将当前 session 中的用户数量加 1，sessionDestroyed 方法刚好相反，不再赘述。然后我们写一个 Controller 来测试一下。

@RestController
@RequestMapping("/listener")
public class TestController {

 /**
 * 获取当前在线人数，该方法有bug
 * @param request
 * @return
 */
 @GetMapping("/total")
 public String getTotalUser(HttpServletRequest request) {
 Integer count = (Integer) request.getSession().getServletContext().getAttribute("count");
 return "当前在线人数：" + count;
 }
}

该 Controller 中是直接获取当前 session 中的用户数量，启动服务器，在浏览器中输入 localhost:8080/listener/total 可以看到返回的结果是 1，再打开一个浏览器，请求相同的地址可以看到 count 是 2 ，这没有问题。但是如果关闭一个浏览器再打开，理论上应该还是 2，但是实际测试却是 3。原因是 session 销毁的方法没有执行（可以在后台控制台观察日志打印情况），当重新打开时，服务器找不到用户原来的 session，于是又重新创建了一个 session，那怎么解决该问题呢？我们可以将上面的 Controller 方法改造一下：


@GetMapping("/total2")
public String getTotalUser(HttpServletRequest request, HttpServletResponse response) {
 Cookie cookie;
 try {
 // 把sessionId记录在浏览器中
 cookie = new Cookie("JSESSIONID", URLEncoder.encode(request.getSession().getId(), "utf-8"));
 cookie.setPath("/");
 //设置cookie有效期为2天，设置长一点
 cookie.setMaxAge( 48*60 * 60);
 response.addCookie(cookie);
 } catch (UnsupportedEncodingException e) {
 e.printStackTrace();
 }
 Integer count = (Integer) request.getSession().getServletContext().getAttribute("count");
 return "当前在线人数：" + count;
}

可以看出，该处理逻辑是让服务器记得原来那个 session，即把原来的 sessionId 记录在浏览器中，下次再打开时，把这个 sessionId 传过去，这样服务器就不会重新再创建了。重启一下服务器，在浏览器中再次测试一下，即可避免上面的问题。

监听客户端请求 Servlet Request 对象

使用监听器获取用户的访问信息比较简单，实现 ServletRequestListener 接口即可，然后通过 request 对象获取一些信息。如下：


/**
 * 使用ServletRequestListener获取访问信息

 * @date 2018/07/05
 */
@Component
public class MyServletRequestListener implements ServletRequestListener {

 private static final Logger logger = LoggerFactory.getLogger(MyServletRequestListener.class);

 @Override
 public void requestInitialized(ServletRequestEvent servletRequestEvent) {
 HttpServletRequest request = (HttpServletRequest) servletRequestEvent.getServletRequest();
 logger.info("session id为：{}", request.getRequestedSessionId());
 logger.info("request url为：{}", request.getRequestURL());

 request.setAttribute("name", "xxx");
 }

 @Override
 public void requestDestroyed(ServletRequestEvent servletRequestEvent) {

 logger.info("request end");
 HttpServletRequest request = (HttpServletRequest) servletRequestEvent.getServletRequest();
 logger.info("request域中保存的name值为：{}", request.getAttribute("name"));

 }

}

这个比较简单，不再赘述，接下来写一个 Controller 测试一下即可。

@GetMapping("/request")
public String getRequestInfo(HttpServletRequest request) {
 System.out.println("requestListener中的初始化的name数据：" + request.getAttribute("name"));
 return "success";
}

Spring Boot 中自定义事件监听

在实际项目中，我们往往需要自定义一些事件和监听器来满足业务场景，比如在微服务中会有这样的场景：微服务 A 在处理完某个逻辑之后，需要通知微服务 B 去处理另一个逻辑，或者微服务 A 处理完某个逻辑之后，需要将数据同步到微服务 B，这种场景非常普遍，这个时候，我们可以自定义事件以及监听器来监听，一旦监听到微服务 A 中的某事件发生，就去通知微服务 B 处理对应的逻辑。

自定义事件

自定义事件需要继承 ApplicationEvent 对象，在事件中定义一个 User 对象来模拟数据，构造方法中将 User 对象传进来初始化。如下：

public class MyEvent extends ApplicationEvent {

 private User user;

 public MyEvent(Object source, User user) {
 super(source);
 this.user = user;
 }

 // 省去get、set方法
}

自定义监听器

接下来，自定义一个监听器来监听上面定义的 MyEvent 事件，自定义监听器需要实现 ApplicationListener 接口即可。如下：

@Component
public class MyEventListener implements ApplicationListener<MyEvent> {
 @Override
 public void onApplicationEvent(MyEvent myEvent) {
 // 把事件中的信息获取到
 User user = myEvent.getUser();
 // 处理事件，实际项目中可以通知别的微服务或者处理其他逻辑等等
 System.out.println("用户名：" + user.getUsername());
 System.out.println("密码：" + user.getPassword());
 }
}

然后重写 onApplicationEvent 方法，将自定义的 MyEvent 事件传进来，因为该事件中，我们定义了 User 对象（该对象在实际中就是需要处理的数据，在下文来模拟），然后就可以使用该对象的信息了。OK，定义好了事件和监听器之后，需要手动发布事件，这样监听器才能监听到，这需要根据实际业务场景来触发，针对本文的例子，我写个触发逻辑，如下：

@Service
public class UserService {
 @Resource
 private ApplicationContext applicationContext;
 /**
 * 发布事件
 * @return
 */
 public User getUser2() {
 User user = new User(1L, "xxx", "123456");
 // 发布事件
 MyEvent event = new MyEvent(this, user);
 applicationContext.publishEvent(event);
 return user;
 }
}

在 service 中注入 ApplicationContext，在业务代码处理完之后，通过 ApplicationContext 对象手动发布 MyEvent 事件，这样我们自定义的监听器就能监听到，然后处理监听器中写好的业务逻辑。

@GetMapping("/request")
public String getRequestInfo(HttpServletRequest request) {
 System.out.println("requestListener中的初始化的name数据：" + request.getAttribute("name"));
 return "success";
}

在浏览器中输入 http://localhost:8080/listener/publish，然后观察一下控制台打印的用户名和密码，即可说明自定义监听器已经生效。

拦截器

Mon, 01 Jan 0001 00:00:00 +0000

拦截器

拦截器的原理很简单，是 AOP 的一种实现，专门拦截对动态资源的后台请求，即拦截对控制层的请求。使用场景比较多的是判断用户是否有权限请求后台，更拔高一层的使用场景也有，比如拦截器可以结合 websocket 一起使用，用来拦截 websocket 请求，然后做相应的处理等等。拦截器不会拦截静态资源，Spring Boot 的默认静态目录为 resources/static，该目录下的静态页面、js、css、图片等等，不会被拦截。

拦截器的快速使用

定义拦截器

定义拦截器，只需要实现 HandlerInterceptor 接口，HandlerInterceptor 接口是所有自定义拦截器或者 Spring Boot 提供的拦截器的鼻祖，所以，首先来了解下该接口。该接口中有三个方法：preHandle(……)、postHandle(……) 和 afterCompletion(……) 。

preHandle(……) 方法：该方法的执行时机是，当某个 url 已经匹配到对应的 Controller 中的某个方法，且在这个方法执行之前。所以 preHandle(……) 方法可以决定是否将请求放行，这是通过返回值来决定的，返回 true 则放行，返回 false 则不会向后执行。
postHandle(……) 方法：该方法的执行时机是，当某个 url 已经匹配到对应的 Controller 中的某个方法，且在执行完了该方法，但是在 DispatcherServlet 视图渲染之前。所以在这个方法中有个 ModelAndView 参数，可以在此做一些修改动作。
afterCompletion(……) 方法：顾名思义，该方法是在整个请求处理完成后（包括视图渲染）执行，这时做一些资源的清理工作，这个方法只有在 preHandle(……) 被成功执行后并且返回 true 才会被执行。

了解了该接口，接下来自定义一个拦截器。

public class MyInterceptor implements HandlerInterceptor {
 private static final Logger logger = LoggerFactory.getLogger(MyInterceptor.class);

 @Override
 public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
 HandlerMethod handlerMethod = (HandlerMethod) handler;
 Method method = handlerMethod.getMethod();
 String methodName = method.getName();
 logger.info("====拦截到了方法：{}，在该方法执行之前执行====", methodName);
 // 返回true才会继续执行，返回false则取消当前请求
 return true;
 }

 @Override
 public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
 logger.info("执行完方法之后进执行(Controller方法调用之后)，但是此时还没进行视图渲染");
 }

 @Override
 public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
 logger.info("整个请求都处理完咯，DispatcherServlet也渲染了对应的视图咯，此时我可以做一些清理的工作了");
 }
}

配置拦截器

在 Spring Boot 2.0 之前，我们都是直接继承 WebMvcConfigurerAdapter 类，然后重写 addInterceptors 方法来实现拦截器的配置。但是在 Spring Boot 2.0 之后，该方法已经被废弃了（当然，也可以继续用），取而代之的是 WebMvcConfigurationSupport 方法，如下：


@Configuration
public class MyInterceptorConfig extends WebMvcConfigurationSupport {

 @Override
 protected void addInterceptors(InterceptorRegistry registry) {
 registry.addInterceptor(new MyInterceptor()).addPathPatterns("/**");
 super.addInterceptors(registry);
 }
}

在该配置中重写 addInterceptors 方法，将我们上面自定义的拦截器添加进去，addPathPatterns 方法是添加要拦截的请求，这里我们拦截所有的请求。这样就配置好拦截器了，接下来写一个 Controller 测试一下：


@Controller
@RequestMapping("/interceptor")
public class InterceptorController {

 @RequestMapping("/test")
 public String test() {
 return "hello";
 }
}

让其跳转到 hello.html 页面，直接在 hello.html 中输出 hello interceptor 即可。启动项目，在浏览器中输入 localhost:8080/interceptor/test 看一下控制台的日志：

====拦截到了方法：test，在该方法执行之前执行====
执行完方法之后进执行(Controller方法调用之后)，但是此时还没进行视图渲染
整个请求都处理完咯，DispatcherServlet也渲染了对应的视图咯，此时我可以做一些清理的工作了

可以看出拦截器已经生效，并能看出其执行顺序。

解决静态资源被拦截问题

上文中已经介绍了拦截器的定义和配置，但是这样是否就没问题了呢？其实不然，如果使用上面这种配置的话，我们会发现一个缺陷，那就是静态资源被拦截了。可以在 resources/static/ 目录下放置一个图片资源或者 html 文件，然后启动项目直接访问，即可看到无法访问的现象。也就是说，虽然 Spring Boot 2.0 废弃了 WebMvcConfigurerAdapter，但是 WebMvcConfigurationSupport 又会导致默认的静态资源被拦截，这就需要我们手动将静态资源放开。

如何放开呢？除了在 MyInterceptorConfig 配置类中重写 addInterceptors 方法外，还需要再重写一个方法：addResourceHandlers，将静态资源放开：

/**
 * 用来指定静态资源不被拦截，否则继承WebMvcConfigurationSupport这种方式会导致静态资源无法直接访问
 * @param registry
 */
@Override
protected void addResourceHandlers(ResourceHandlerRegistry registry) {
 registry.addResourceHandler("/**").addResourceLocations("classpath:/static/");
 super.addResourceHandlers(registry);
}

这样配置好之后，重启项目，静态资源也可以正常访问了。如果你是个善于学习或者研究的人，那肯定不会止步于此，没错，上面这种方式的确能解决静态资源无法访问的问题，但是，还有更方便的方式来配置。我们不继承 WebMvcConfigurationSupport 类，直接实现 WebMvcConfigurer 接口，然后重写 addInterceptors 方法，将自定义的拦截器添加进去即可，如下：


@Configuration
public class MyInterceptorConfig implements WebMvcConfigurer {
 @Override
 public void addInterceptors(InterceptorRegistry registry) {
 // 实现WebMvcConfigurer不会导致静态资源被拦截
 registry.addInterceptor(new MyInterceptor()).addPathPatterns("/**");
 }
}

这两种方式都可以，具体他们之间的细节，感兴趣的读者可以做进一步的研究，由于这两种方式的不同，继承 WebMvcConfigurationSupport 类的方式可以用在前后端分离的项目中，后台不需要访问静态资源（就不需要放开静态资源了）；实现 WebMvcConfigure 接口的方式可以用在非前后端分离的项目中，因为需要读取一些图片、css、js 文件等等。

拦截器使用实例

判断用户有没有登录

一般用户登录功能我们可以这么做，要么往 session 中写一个 user，要么针对每个 user 生成一个 token，第二种要更好一点，那么针对第二种方式，如果用户登录成功了，每次请求的时候都会带上该用户的 token，如果未登录，则没有该 token，服务端可以检测这个 token 参数的有无来判断用户有没有登录，从而实现拦截功能。我们改造一下 preHandle 方法，如下：

@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
 HandlerMethod handlerMethod = (HandlerMethod) handler;
 Method method = handlerMethod.getMethod();
 String methodName = method.getName();
 logger.info("====拦截到了方法：{}，在该方法执行之前执行====", methodName);
 // 判断用户有没有登陆，一般登陆之后的用户都有一个对应的token
 String token = request.getParameter("token");
 if (null == token || "".equals(token)) {
 logger.info("用户未登录，没有权限执行……请登录");
 return false;
 }
 // 返回true才会继续执行，返回false则取消当前请求
 return true;
}

重启项目，在浏览器中输入 localhost:8080/interceptor/test 后查看控制台日志，发现被拦截，如果在浏览器中输入 localhost:8080/interceptor/test?token=123 即可正常往下走。

取消拦截操作

根据上文，如果我要拦截所有 /admin 开头的 url 请求的话，需要在拦截器配置中添加这个前缀，但是在实际项目中，可能会有这种场景出现：某个请求也是 /admin 开头的，但是不能拦截，比如 /admin/login 等等，这样的话又需要去配置。那么，可不可以做成一个类似于开关的东西，哪里不需要拦截，我就在哪里弄个开关上去，做成这种灵活的可插拔的效果呢？

是可以的，我们可以定义一个注解，该注解专门用来取消拦截操作，如果某个 Controller 中的方法我们不需要拦截掉，即可在该方法上加上我们自定义的注解即可，下面先定义一个注解：


/**
 * 该注解用来指定某个方法不用拦截
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface UnInterception {
}

然后在 Controller 中的某个方法上添加该注解，在拦截器处理方法中添加该注解取消拦截的逻辑，如下：


@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {

 HandlerMethod handlerMethod = (HandlerMethod) handler;
 Method method = handlerMethod.getMethod();
 String methodName = method.getName();
 logger.info("====拦截到了方法：{}，在该方法执行之前执行====", methodName);

 // 通过方法，可以获取该方法上的自定义注解，然后通过注解来判断该方法是否要被拦截
 // @UnInterception 是我们自定义的注解
 UnInterception unInterception = method.getAnnotation(UnInterception.class);
 if (null != unInterception) {
 return true;
 }
 // 返回true才会继续执行，返回false则取消当前请求
 return true;
}

Controller 中的方法代码可以参见源码，重启项目在浏览器中输入 http://localhost:8080/interceptor/test2?token=123 测试一下，可以看出，加了该注解的方法不会被拦截。

接口防刷

首先是写一个注解类：

import java.lang.annotation.Retention;
import java.lang.annotation.Target;

import static java.lang.annotation.ElementType.METHOD;
import static java.lang.annotation.RetentionPolicy.RUNTIME;

@Retention(RUNTIME)
@Target(METHOD)
public @interface AccessLimit {

 int seconds();
 int maxCount();
 boolean needLogin()default true;
}

接着就是在 Interceptor 拦截器中实现：

@Component
public class FangshuaInterceptor extends HandlerInterceptorAdapter {

 @Autowired
 private RedisService redisService;

 @Override
 public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {

 //判断请求是否属于方法的请求
 if(handler instanceof HandlerMethod){

 HandlerMethod hm = (HandlerMethod) handler;

 //获取方法中的注解,看是否有该注解
 AccessLimit accessLimit = hm.getMethodAnnotation(AccessLimit.class);
 if(accessLimit == null){
 return true;
 }
 int seconds = accessLimit.seconds();
 int maxCount = accessLimit.maxCount();
 boolean login = accessLimit.needLogin();
 String key = request.getRequestURI();

 // 如果需要登录
 if(login){
 // 获取登录的session进行判断
 //.....
 key+=""+"1"; //这 里假设用户是1,项目中是动态获取的userId
 }

 // 从redis中获取用户访问的次数
 AccessKey ak = AccessKey.withExpire(seconds);
 Integer count = redisService.get(ak,key,Integer.class);
 if(count == null){
 // 第一次访问
 redisService.set(ak,key,1);
 }else if(count < maxCount){
 // 加1
 redisService.incr(ak,key);
 }else{
 // 超出访问次数
 render(response,CodeMsg.ACCESS_LIMIT_REACHED); // 这里的 CodeMsg 是一个返回参数
 return false;
 }
 }

 return true;

 }

 private void render(HttpServletResponse response, CodeMsg cm)throws Exception {
 response.setContentType("application/json;charset=UTF-8");
 OutputStream out = response.getOutputStream();
 String str = JSON.toJSONString(Result.error(cm));
 out.write(str.getBytes("UTF-8"));
 out.flush();
 out.close();
 }
}

再把 Interceptor 注册到 SpringBoot 中：

@Configuration
public class WebConfig extends WebMvcConfigurerAdapter {

 @Autowired
 private FangshuaInterceptor interceptor;

 @Override
 public void addInterceptors(InterceptorRegistry registry) {
 registry.addInterceptor(interceptor);
 }
}

接着在 Controller 中加入注解：

@Controller
public class FangshuaController {

 @AccessLimit(seconds=5, maxCount=5, needLogin=true)
 @RequestMapping("/fangshua")
 @ResponseBody
 public Result<String> fangshua(){
 return Result.success("请求成功");
 }
}

切面注解

Mon, 01 Jan 0001 00:00:00 +0000

快速开始

Spring Boot 中使用 AOP 非常简单，假如我们要在项目中打印一些 log，在引入了上面的依赖之后，我们新建一个类 LogAspectHandler，用来定义切面和处理方法。只要在类上加个@Aspect 注解即可。@Aspect 注解用来描述一个切面类，定义切面类的时候需要打上这个注解。@Component 注解让该类交给 Spring 来管理。

@Aspect
@Component
public class LogAspectHandler {

}

这里主要介绍几个常用的注解及使用：

@Pointcut：定义一个切面，即上面所描述的关注的某件事入口。
@Before：在做某件事之前做的事。
@After：在做某件事之后做的事。
@AfterReturning：在做某件事之后，对其返回值做增强处理。
@AfterThrowing：在做某件事抛出异常时，处理。

@Pointcut 注解

@Pointcut 注解：用来定义一个切面（切入点），即上文中所关注的某件事情的入口。切入点决定了连接点关注的内容，使得我们可以控制通知什么时候执行。

@Aspect
@Component
public class LogAspectHandler {

 /**
 * 定义一个切面，拦截com.test.controller包和子包下的所有方法
 */
 @Pointcut("execution(* com.test.controller..*.*(..))")
 public void pointCut() {}
}

@Pointcut 注解指定一个切面，定义需要拦截的东西，这里介绍两个常用的表达式：一个是使用 execution()，另一个是使用 annotation()。以 execution(*com.test.controller.*.*(..))) 表达式为例，语法如下：

execution() 为表达式主体，第一个 * 号的位置：表示返回值类型，* 表示所有类型。
包名：表示需要拦截的包名，后面的两个句点表示当前包和当前包的所有子包，com.test.controller 包、子包下所有类的方法
第二个 * 号的位置：表示类名，* 表示所有类
*(..)：这个星号表示方法名，* 表示所有的方法，后面括弧里面表示方法的参数，两个句点表示任何参数

annotation() 方式是针对某个注解来定义切面，比如我们对具有 @GetMapping 注解的方法做切面，可以如下定义切面：

@Pointcut("@annotation(org.springframework.web.bind.annotation.GetMapping)")
public void annotationCut() {}

然后使用该切面的话，就会切入注解是 @GetMapping 的方法。因为在实际项目中，可能对于不同的注解有不同的逻辑处理，比如 @GetMapping、@PostMapping、@DeleteMapping 等。所以这种按照注解的切入方式在实际项目中也很常用。

@Before 注解

@Before 注解指定的方法在切面切入目标方法之前执行，可以做一些 log 处理，也可以做一些信息的统计，比如获取用户的请求 url 以及用户的 ip 地址等等，这个在做个人站点的时候都能用得到，都是常用的方法。例如：


@Aspect
@Component
public class LogAspectHandler {

 private final Logger logger = LoggerFactory.getLogger(this.getClass());

 /**
 * 在上面定义的切面方法之前执行该方法
 * @param joinPoint jointPoint
 */
 @Before("pointCut()")
 public void doBefore(JoinPoint joinPoint) {
 logger.info("====doBefore方法进入了====");

 // 获取签名
 Signature signature = joinPoint.getSignature();
 // 获取切入的包名
 String declaringTypeName = signature.getDeclaringTypeName();
 // 获取即将执行的方法名
 String funcName = signature.getName();
 logger.info("即将执行方法为: {}，属于{}包", funcName, declaringTypeName);

 // 也可以用来记录一些信息，比如获取请求的url和ip
 ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
 HttpServletRequest request = attributes.getRequest();
 // 获取请求url
 String url = request.getRequestURL().toString();
 // 获取请求ip
 String ip = request.getRemoteAddr();
 logger.info("用户请求的url为：{}，ip地址为：{}", url, ip);
 }
}

JointPoint 对象很有用，可以用它来获取一个签名，然后利用签名可以获取请求的包名、方法名，包括参数（通过 joinPoint.getArgs() 获取）等等。

@After 注解

@After 注解和 @Before 注解相对应，指定的方法在切面切入目标方法之后执行，也可以做一些完成某方法之后的 log 处理。


@Aspect
@Component
public class LogAspectHandler {

 private final Logger logger = LoggerFactory.getLogger(this.getClass());

 /**
 * 定义一个切面，拦截com.test.course09.controller包下的所有方法
 */
 @Pointcut("execution(* com.test.course09.controller..*.*(..))")
 public void pointCut() {}

 /**
 * 在上面定义的切面方法之后执行该方法
 * @param joinPoint jointPoint
 */
 @After("pointCut()")
 public void doAfter(JoinPoint joinPoint) {

 logger.info("====doAfter方法进入了====");
 Signature signature = joinPoint.getSignature();
 String method = signature.getName();
 logger.info("方法{}已经执行完", method);
 }
}

到这里，我们来写一个 Controller 来测试一下执行结果，新建一个 AopController 如下：

@RestController
@RequestMapping("/aop")
public class AopController {

 @GetMapping("/{name}")
 public String testAop(@PathVariable String name) {
 return "Hello " + name;
 }
}

启动项目，在浏览器中输入 localhost:8080/aop/CSDN，观察一下控制台的输出信息：

====doBefore方法进入了====
即将执行方法为: testAop，属于com.test.course09.controller.AopController包
用户请求的url为：http://localhost:8080/aop/name，ip地址为：0:0:0:0:0:0:0:1
====doAfter方法进入了====
方法testAop已经执行完

从打印出来的 log 中可以看出程序执行的逻辑与顺序，可以很直观的掌握 @Before 和 @After 两个注解的实际作用。

@AfterReturning 注解

@AfterReturning 注解和 @After 有些类似，区别在于 @AfterReturning 注解可以用来捕获切入方法执行完之后的返回值，对返回值进行业务逻辑上的增强处理，例如：

@Aspect
@Component
public class LogAspectHandler {

 private final Logger logger = LoggerFactory.getLogger(this.getClass());

 /**
 * 在上面定义的切面方法返回后执行该方法，可以捕获返回对象或者对返回对象进行增强
 * @param joinPoint joinPoint
 * @param result result
 */
 @AfterReturning(pointcut = "pointCut()", returning = "result")
 public void doAfterReturning(JoinPoint joinPoint, Object result) {

 Signature signature = joinPoint.getSignature();
 String classMethod = signature.getName();
 logger.info("方法{}执行完毕，返回参数为：{}", classMethod, result);
 // 实际项目中可以根据业务做具体的返回值增强
 logger.info("对返回参数进行业务上的增强：{}", result + "增强版");
 }
}

需要注意的是：在 @AfterReturning 注解中，属性 returning 的值必须要和参数保持一致，否则会检测不到。该方法中的第二个入参就是被切方法的返回值，在 doAfterReturning 方法中可以对返回值进行增强，可以根据业务需要做相应的封装。

@AfterThrowing 注解

顾名思义，@AfterThrowing 注解是当被切方法执行时抛出异常时，会进入 @AfterThrowing 注解的方法中执行，在该方法中可以做一些异常的处理逻辑。要注意的是 throwing 属性的值必须要和参数一致，否则会报错。该方法中的第二个入参即为抛出的异常。

@Aspect
@Component
public class LogAspectHandler {

 private final Logger logger = LoggerFactory.getLogger(this.getClass());

 /**
 * 在上面定义的切面方法执行抛异常时，执行该方法
 * @param joinPoint jointPoint
 * @param ex ex
 */
 @AfterThrowing(pointcut = "pointCut()", throwing = "ex")
 public void afterThrowing(JoinPoint joinPoint, Throwable ex) {
 Signature signature = joinPoint.getSignature();
 String method = signature.getName();
 // 处理异常的逻辑
 logger.info("执行方法{}出错，异常为：{}", method, ex);
 }
}

异步拦截器

Mon, 01 Jan 0001 00:00:00 +0000

异步拦截器

Spring MVC 给提供了异步拦截器，能让我们更深入的参与进去异步 request 的生命周期里面去。其中最为常用的为：AsyncHandlerInterceptor：

public class AsyncHelloInterceptor implements AsyncHandlerInterceptor {

 // 这是Spring3.2提供的方法，专门拦截异步请求的方式
 @Override
 public void afterConcurrentHandlingStarted(
 HttpServletRequest request,
 HttpServletResponse response,
 Object handler
 )
 throws Exception {
 System.out.println(
 Thread.currentThread().getName() +
 "---afterConcurrentHandlingStarted-->" +
 request.getRequestURI()
 );
 }

 @Override
 public boolean preHandle(
 HttpServletRequest request,
 HttpServletResponse response,
 Object handler
 )
 throws Exception {
 System.out.println(
 Thread.currentThread().getName() +
 "---preHandle-->" +
 request.getRequestURI()
 );
 return true;
 }

 @Override
 public void postHandle(
 HttpServletRequest request,
 HttpServletResponse response,
 Object handler,
 ModelAndView modelAndView
 )
 throws Exception {
 System.out.println(
 Thread.currentThread().getName() +
 "---postHandle-->" +
 request.getRequestURI()
 );
 }

 @Override
 public void afterCompletion(
 HttpServletRequest request,
 HttpServletResponse response,
 Object handler,
 Exception ex
 )
 throws Exception {
 System.out.println(
 Thread.currentThread().getName() +
 "---afterCompletion-->" +
 request.getRequestURI()
 );
 }
}

AsyncHandlerInterceptor 提供了一个 afterConcurrentHandlingStarted()方法, 这个方法会在 Controller 方法异步执行时开始执行, 而 Interceptor 的 postHandle 方法则是需要等到 Controller 的异步执行完才能执行。比如我们用 DeferredResult 的话，afterConcurrentHandlingStarted 是在 return 的之后执行，而 postHandle()是执行.setResult()之后执行。

需要说明的是：如果我们不是异步请求，afterConcurrentHandlingStarted 是不会执行的。所以我们可以把它当做加强版的 HandlerInterceptor 来用。平时我们若要使用拦截器，建议使用它。同样可以注册 CallableProcessingInterceptor 或者一个 DeferredResultProcessingInterceptor 用于更深度的集成异步 request 的生命周期：

@Override
public void configureAsyncSupport(AsyncSupportConfigurer configurer) {
 // 注册异步的拦截器、默认的超时时间、任务处理器TaskExecutor等等
 //configurer.registerCallableInterceptors();
 //configurer.registerDeferredResultInterceptors();
 //configurer.setDefaultTimeout();
 //configurer.setTaskExecutor();
}