Java中SpringBoot拦截器一般都可以做什么？
可以对URL路径进行拦截，可以用于权限验证、解决乱码、操作日志记录、性能监控、异常处理等。
SpringBoot拦截器实现登录拦截
pom.xml：
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
 <modelVersion>4.0.0</modelVersion>
 <parent>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-parent</artifactId>
 <version>2.0.0.RELEASE</version>
 <relativePath/>
 </parent>
 <groupId>com.wyj</groupId>
 <artifactId>springboot-interceptor01</artifactId>
 <version>0.0.1-SNAPSHOT</version>
 <name>springboot-interceptor01</name>
 <description>springboot拦截器</description>
 
 <properties>
 <java.version>1.8</java.version>
 </properties>
 
 <dependencies>
 <!-- springboot -->
 <dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-web</artifactId>
 </dependency>
 <dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-test</artifactId>
 <scope>test</scope>
 </dependency>
 <dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-devtools</artifactId>
 <scope>runtime</scope>
 <optional>true</optional>
 </dependency>
 
 <!-- lombok -->
 <dependency>
 <groupId>org.projectlombok</groupId>
 <artifactId>lombok</artifactId>
 <optional>true</optional>
 </dependency>
 
 <!-- thymeleaf -->
 <dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-thymeleaf</artifactId>
 </dependency>
 </dependencies>
 
 <build>
 <finalName>springboot-interceptor01</finalName>
 <plugins>
 <plugin>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-maven-plugin</artifactId>
 </plugin>
 </plugins>
 </build>
</project>
WebMvcConfigurer：继承WebMvcConfigurationSupport类，重写addInterceptors方法
/**
 * 在springboot2.0.0之后，WebMvcConfigurerAdapter已经过时了
 * 会使用WebMvcConfigurer或者WebMvcConfigurationSupport替代
 *
 * @author wyj
 * @create 2019-06-01 21:48
 */
@Configuration
public class WebMvcConfigurer extends WebMvcConfigurationSupport {
 
 /**
 * 在springboot2.0.0之前继承WebMvcConfigurerAdapter类，重写addInterceptors方法
 *
 * @param registry
 */
// @Override
// public void addInterceptors(InterceptorRegistry registry) {
// /**
// * 拦截器按照顺序执行,如果不同拦截器拦截存在相同的URL，前面的拦截器会执行，后面的拦截器将不执行
// */
// registry.addInterceptor(new AuthorityInterceptor())
// .addPathPatterns("/user/**");
// super.addInterceptors(registry);
// }
 
 /**
 * 在springboot2.0.0之后实现WebMvcConfigurer接口，重写addInterceptors方法
 *
 * @param registry
 */
// @Override
// public void addInterceptors(InterceptorRegistry registry) {
// /**
// * 拦截器按照顺序执行,如果不同拦截器拦截存在相同的URL，前面的拦截器会执行，后面的拦截器将不执行
// */
// registry.addInterceptor(new AuthorityInterceptor())
// .addPathPatterns("/user/**");
// }
 
 /**
 * 在springboot2.0.0之后继承WebMvcConfigurationSupport类，重写addInterceptors方法
 *
 * @param registry
 */
 @Override
 protected void addInterceptors(InterceptorRegistry registry) {
 /**
 * 拦截器按照顺序执行,如果不同拦截器拦截存在相同的URL，前面的拦截器会执行，后面的拦截器将不执行
 */
 registry.addInterceptor(new AuthorityInterceptor())
 .addPathPatterns("/user/**");
 super.addInterceptors(registry);
 }
}
AuthorityInterceptor：实现HandlerInterceptor接口，重写preHandle、postHandle、afterCompletion方法
preHandle：在请求处理之前进行调用（Controller方法调用之前）
postHandle：请求处理之后进行调用，但是在视图被渲染之前（Controller方法调用之后）
afterCompletion：在整个请求结束之后被调用，也就是在DispatcherServlet 渲染了对应的视图之后执行（主要是用于进行资源清理工作）
@Slf4j
public class AuthorityInterceptor implements HandlerInterceptor {
 
 private static final Set<String> NOT_INTERCEPT_URI = new HashSet<>();//不拦截的URI
 
 static {
 NOT_INTERCEPT_URI.add("/user/login.html");
 NOT_INTERCEPT_URI.add("/user/login");
 }
 
 /**
 * 在请求处理之前进行调用（Controller方法调用之前）
 */
 @Override
 public boolean preHandle(HttpServletRequest request, HttpServletResponse response,
 Object object) throws Exception {
 String uri = request.getRequestURI();
 if (NOT_INTERCEPT_URI.contains(uri)) {
 log.info("不拦截" + uri);
 return true;
 }
 log.info("拦截" + uri);
 HttpSession session = request.getSession();
 UserInfo userInfo = (UserInfo) session.getAttribute("user_info_in_the_session");
 if (userInfo == null) {
 throw new RuntimeException("用户未登陆");
 }
 return true;
 }
 
 /**
 * 请求处理之后进行调用，但是在视图被渲染之前（Controller方法调用之后）
 */
 @Override
 public void postHandle(HttpServletRequest request, HttpServletResponse response, Object object, ModelAndView mv) throws Exception {
 }
 
 /**
 * 在整个请求结束之后被调用，也就是在DispatcherServlet 渲染了对应的视图之后执行
 * （主要是用于进行资源清理工作）
 */
 @Override
 public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object object, Exception ex) throws Exception {
 }
}
UserController：
@Controller
@RequestMapping(value = "/user")
public class UserController {
 
 @RequestMapping(value = "/login.html")
 public String index() {
 return "login";
 }
 
 @RequestMapping(value = "/login")
 public String login(User user) {
 //查询数据库，我这里直接写死
 User dbUser = new User(1, "zhangsan", "123456", "admin");
 if (dbUser.getPassword().equals(user.getPassword())) {
 UserInfo userInfo = new UserInfo(dbUser.getId(), dbUser.getUsername(), dbUser.getRole());
 HttpSession session = getRequest().getSession();
 session.setAttribute("user_info_in_the_session", userInfo);
 return "admin";
 }
 return "login";
 }
 
 @RequestMapping(value = "/userInfo")
 @ResponseBody
 public String userInfo() {
 HttpSession session = getRequest().getSession();
 UserInfo userInfo = (UserInfo) session.getAttribute("user_info_in_the_session");
 return userInfo.toString();
 }
 
 private HttpServletRequest getRequest() {
 return ((ServletRequestAttributes) RequestContextHolder.currentRequestAttributes()).getRequest();
 }
}
User：
@Data
@NoArgsConstructor
@AllArgsConstructor
public class User implements Serializable {
 
 private int id;
 private String username;
 private String password;
 private String role;
 
}
UserInfo： 用于存在用户信息储存在session中
@Data
@NoArgsConstructor
@AllArgsConstructor
public class UserInfo implements Serializable {
 
 private int id;
 private String username; 
 private String role;
 
}
login.html：只是一个很简单的登录表单
<!DOCTYPE html>
<html>
<head>
 <meta charset="UTF-8">
 <title>登陆页面</title>
</head>
<body>
<form action="/user/login" method="post">
 登陆：<br/>
 用户名：<input name="username" id="username" type="text"/><br/>
 密 码：<input name="password" id="password" type="password"/><br/>
 <input type="submit" value="登陆"/>
</form>
</body>
</html>
admin.html：
<!DOCTYPE html>
<html>
<head>
 <meta charset="UTF-8">
 <title>首页</title>
</head>
<body>
<form action="/user/userInfo" method="get">
 <input type="submit" value="用户信息"/></form>
</body>
</html>
欢迎一起学习交流！
点击获取

本例实现登陆时的验证拦截，采用SpringMVC拦截器来实现
当用户点击到网站主页时要进行拦截，用户登录了才能进入网站主页，否则进入登陆页面
核心代码
首先是index.jsp,显示链接
1 
2 
3 String path =request.getContextPath();4 String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";5 %>
6
7 
8 
9   
10     
11
12     
首页
13     
14     
15     
16     
17     
18     
21   
22
23   
24      
25          
登陆
26          
用户中心
27          
触发异常
28      
29   
30 
controller类
1 package com.jikexueyuan.demo.springmvc.lesson4.controller;2
3 import javax.annotation.Resource;4 import javax.servlet.http.HttpServletRequest;5
6 import org.springframework.stereotype.Controller;7 import org.springframework.web.bind.annotation.RequestMapping;8 import org.springframework.web.bind.annotation.RequestMethod;9 import org.springframework.web.bind.annotation.RequestParam;10
11 import com.jikexueyuan.demo.springmvc.lesson4.constant.Global;12 import com.jikexueyuan.demo.springmvc.lesson4.exception.MyException;13 import com.jikexueyuan.demo.springmvc.lesson4.model.User;14 import com.jikexueyuan.demo.springmvc.lesson4.service.LoginService;15
16 /**17 * 这个例子讲解了如何定义MVC三层注解，使用@Resource进行注入，以及使用@RequestMapping、@RequestParam 、@SessionAttributes18  */
19
20 @Controller21 public classLoginController extends BaseController {22
23 @Resource24 LoginService service;25
26 @Resource27 HttpServletRequest request;28
29     @RequestMapping("/exception")30     public voidexception() throws MyException{31         throw new MyException("测试springmvc中的异常捕获");32 }33
34     @RequestMapping("/loginpage")35     publicString toLoginPage(){36         return "/WEB-INF/jsp/login.jsp";37 }38
39     @RequestMapping("/user/home")40     publicString toUserHome(){41         return "/WEB-INF/jsp/userhome.jsp";42 }43
44     @RequestMapping("/logout")45     publicString logout(){46 request.getSession().removeAttribute(Global.USER_SESSION_KEY);47         return "redirect:/";48 }49
50     @RequestMapping(value = "/doLogin", method =RequestMethod.POST)51     publicString doLogin(@RequestParam String userName, @RequestParam String password){52
53         try{54             User user =service.doLogin(userName, password);55 request.getSession().setAttribute(Global.USER_SESSION_KEY, user);56             return "redirect:/user/home.html";57         } catch(Exception e) {58             return "/WEB-INF/jsp/login.jsp";59 }60
61 }62
63 }
当点击用户中心时，触发拦截，相关配置如下
在spring-mvc.xml中加上拦截配置，拦截所有URL中包含/user/的请求，当然请求用户中心时就会触发这个拦截器了
1     
2         
3             
4             
5             
6         
7     
然后是bean指向的具体的interceptor类，如果session保存的用户信息为null，则跳到login页面，postHandle和afterCompletion方法都不执行，反之都执行。
1 package com.jikexueyuan.demo.springmvc.lesson4.interceptor;2
3 import javax.servlet.http.HttpServletRequest;4 import javax.servlet.http.HttpServletResponse;5
6 import org.springframework.web.servlet.HandlerInterceptor;7 import org.springframework.web.servlet.ModelAndView;8
9 import com.jikexueyuan.demo.springmvc.lesson4.constant.Global;10
11 public classLoginInterceptor implements HandlerInterceptor {12
13 @Override14     publicboolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {15         Object user =request.getSession().getAttribute(Global.USER_SESSION_KEY);16         if (user == null) {17             System.out.println("尚未登录，调到登录页面");18             response.sendRedirect("/loginpage.html");19             return false;20 }21
22         return true;23 }24
25 @Override26     public voidpostHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {27         System.out.println("postHandle");28 }29
30 @Override31     public voidafterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {32         System.out.println("afterCompletion");33 }34
35 }
至此，简单的springmvc拦截器就完成了。

介绍
访问 Controller 时，先验证是否登录：
如果 没有登录 就 跳转到登录页
如果已经登录了，就正常访问 controller，执行添加、编辑、删除等功能
分析
如果不知道拦截器，就需要在每个 controller中的开始处，从session中获取当前用户信息，然后做下面判断：
如果已经存在，就说明已经登录，允许继续访问Controller
如果不存在，说明没有登录，就跳转到登录页
缺点：在每个 Controller 开始处写这些代码，过于冗余
所以通过springmvc的拦截器来实现
JAVA代码public class LoginInterceptor implements HandlerInterceptor {
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
HttpSession session=request.getSession();
String username= (String) session.getAttribute("username");
if(username!=null && !"".equals(username)){
return true;
}
response.sendRedirect("/login.html");
return false;
}
}
XML配置
实现拦截器类后，还需要配置到xml配置文件中，才能起作用
解释：
：表示访问 /mgr/ 下的资源，及 子路径 下的资源，都会 拦截
如：/mgr/list、/mgr/user/list 都会被拦截
 表示不拦截的url：
/login：登录Controller，不拦截，否则无法登录
/js/**：该url下都是js，不需要登录校验，所以不拦截
/css/**：该url下都是css，不需要登录校验，所以不拦截
/img/**：该url下都是图片，不需要登录校验，所以不拦截

本例实现登陆时的验证拦截，采用SpringMVC拦截器来实现
核心代码
首先是index.jsp,显示链接
String path = request.getContextPath();
String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";
%>
首页
登陆
用户中心
触发异常
controller类
package com.jikexueyuan.demo.springmvc.lesson4.controller;
import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import com.jikexueyuan.demo.springmvc.lesson4.constant.Global;
import com.jikexueyuan.demo.springmvc.lesson4.exception.MyException;
import com.jikexueyuan.demo.springmvc.lesson4.model.User;
import com.jikexueyuan.demo.springmvc.lesson4.service.LoginService;
/**
* 这个例子讲解了如何定义MVC三层注解，使用@Resource进行注入，以及使用@RequestMapping、@RequestParam 、@SessionAttributes
*/
@Controller
public class LoginController extends BaseController {
@Resource
LoginService service;
@Resource
HttpServletRequest request;
@RequestMapping("/exception")
public void exception() throws MyException{
throw new MyException("测试springmvc中的异常捕获");
}
@RequestMapping("/loginpage")
public String toLoginPage(){
return "/WEB-INF/jsp/login.jsp";
}
@RequestMapping("/user/home")
public String toUserHome(){
return "/WEB-INF/jsp/userhome.jsp";
}
@RequestMapping("/logout")
public String logout(){
request.getSession().removeAttribute(Global.USER_SESSION_KEY);
return "redirect:/";
}
@RequestMapping(value = "/doLogin", method = RequestMethod.POST)
public String doLogin(@RequestParam String userName, @RequestParam String password){
try {
User user = service.doLogin(userName, password);
request.getSession().setAttribute(Global.USER_SESSION_KEY, user);
return "redirect:/user/home.html";
} catch (Exception e) {
return "/WEB-INF/jsp/login.jsp";
}
}
}
当点击用户中心时，触发拦截，相关配置如下
在spring-mvc.xml中加上拦截配置，拦截所有URL中包含/user/的请求，当然请求用户中心时就会触发这个拦截器了
然后是bean指向的具体的interceptor类，如果session保存的用户信息为null，则跳到login页面，postHandle和afterCompletion方法都不执行，反之都执行
package com.jikexueyuan.demo.springmvc.lesson4.interceptor;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;
import com.jikexueyuan.demo.springmvc.lesson4.constant.Global;
public class LoginInterceptor implements HandlerInterceptor {
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
Object user = request.getSession().getAttribute(Global.USER_SESSION_KEY);
if (user == null) {
System.out.println("尚未登录，调到登录页面");
response.sendRedirect("/loginpage.html");
return false;
}
return true;
}
@Override
public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
System.out.println("postHandle");
}
@Override
public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
System.out.println("afterCompletion");
}
}
至此，简单的springmvc拦截器就完成了。