黑马程序员java web学习笔记--后端实战（六）登录认证--JWT令牌、Filter

[1 登录功能](#1 登录功能)

[1.1 实体类 LoginInfo](#1.1 实体类 LoginInfo)

[1.2 LoginController](#1.2 LoginController)

[1.3 EmpService](#1.3 EmpService)

[1.4 EmpMapper](#1.4 EmpMapper)

[1.5 测试](#1.5 测试)

[2 登录校验](#2 登录校验)

[2.1 会话技术](#2.1 会话技术)

[2.1.1 Cookie (客户端会话跟踪技术) ×](#2.1.1 Cookie (客户端会话跟踪技术) ×)

[2.1.2 Session (服务端会话跟踪技术) ×](#2.1.2 Session (服务端会话跟踪技术) ×)

[2.1.3 令牌技术 Token ❤](#2.1.3 令牌技术 Token ❤)

[2.2 JWT 令牌](#2.2 JWT 令牌)

[2.2.1 JWT 令牌的生成 / 解析](#2.2.1 JWT 令牌的生成 / 解析)

[2.2.2 登录时下发令牌](#2.2.2 登录时下发令牌)

[2.3 过滤器 Filter](#2.3 过滤器 Filter)

[2.3.1 Filter快速入门](#2.3.1 Filter快速入门)

[2.3.2 登录校验过滤器](#2.3.2 登录校验过滤器)

[2.3.3 Filter详解](#2.3.3 Filter详解)

[2.4 拦截器 Interceptor](#2.4 拦截器 Interceptor)

[2.4.1 Interceptor快速入门](#2.4.1 Interceptor快速入门)

[2.4.2 令牌校验Interceptor](#2.4.2 令牌校验Interceptor)

[2.4.3 Interceptor详解](#2.4.3 Interceptor详解)

1 登录功能

1.1 实体类 LoginInfo

准备实体类 LoginInfo，封装登录成功后，返回给前端的数据。

java 复制代码

/**
 * 封装登录结果
 */
@Data
@NoArgsConstructor
@AllArgsConstructor
public class LoginInfo {
    private Integer id;
    private String username;
    private String name;
    private String token;
}

1.2 LoginController

java 复制代码

/**
 * 登录Controller
 */
@Slf4j
@RestController
public class LoginController {

    @Autowired
    private EmpService empService;

    /**
     * 登录
     *
     * @return
     */
    @PostMapping("/login")
    public Result login(@RequestBody Emp emp) {
        log.info("登录: {}", emp);
        LoginInfo loginInfo = empService.login(emp);
        if(loginInfo != null) {
            return Result.success(loginInfo);
        }else {
            return Result.error("用户名或密码错误!");
        }
    }
}

1.3 EmpService

java 复制代码

public interface EmpService {
    /**
     * 员工登录
     * @param emp
     * @return
     */
    LoginInfo login(Emp emp);
}

java 复制代码

@Slf4j
@Service
public class EmpServiceImpl implements EmpService {

    @Autowired
    private EmpMapper empMapper;

    @Override
    public LoginInfo login(Emp emp) {
        // 1. 调用mapper接口，根据用户名和密码查询员工信息
        Emp e = empMapper.getByUsernameAndPassword(emp);
        // 2. 判断员工信息是否为空，若不为空，则组装员工信息并返回
        if(e != null){
            log.info("登录成功：{}", e);
            return new LoginInfo(e.getId(), e.getUsername(), e.getName(), "");
        }
        // 3. 否则，返回null
        return null;
    }
}

1.4 EmpMapper

java 复制代码

/**
 * 员工信息
 */
@Mapper
public interface EmpMapper {
    /**
     * 根据用户名和密码查询员工信息
     *
     * @param emp
     * @return
     */
    @Select("select id, username, name from emp where username = #{username} and password = #{password}")
    Emp getByUsernameAndPassword(Emp emp);
}

1.5 测试

POST http://localhost:8080/login

问题：我们登录成功后就可以进入到后台管理系统中进行数据的操作。但是当我们在浏览器中直接输入地址 http://localhost:90/index，发现没有登录仍然可以进入到后端管理系统页面。而真正的登录功能应该是：**登陆后才能访问后端系统页面，不登陆则跳转登陆页面进行登陆。**

因此出现了问题！！

原因是我们在服务器端并没有做任何的判断，没有去判断用户是否登录了，所以无论用户是否登录，都可以访问部门管理以及员工管理的相关数据。所以我们目前所开发的登录功能，它只是徒有其表。而我们要想解决这个问题，我们就需要完成一步非常重要的操作：登录校验。

2 登录校验

登录校验具体的实现思路：

在员工登录成功后，需要将用户登录成功的信息存起来，存储一个登录成功的标记，记录用户已经登录成功的标记。
在浏览器发起请求时，需要在服务端进行统一拦截 ，拦截后进行登录校验。

实现以上功能使用到的web开发中的两个技术：

会话技术：用户登录成功之后，在后续的每一次请求中，都可以获取到该标记。
统一拦截技术：过滤器Filter、拦截器Interceptor

2.1 会话技术

在web开发当中，会话指的就是浏览器与服务器之间的一次连接。在用户打开浏览器第一次访问服务器的时候，这个会话就建立了，直到有任何一方断开连接，此时会话就结束了。在一次会话当中，是可以包含多次请求和响应的。

会话跟踪： 一种维护浏览器状态的方法，服务器需要识别多次请求是否来自于同一浏览器，以便在同一次会话的多次请求间共享数据。

Cookie（客户端会话跟踪技术）：数据存储在客户端浏览器当中
Session（服务端会话跟踪技术）：数据存储在储在服务端
令牌技术 ❤ （此处不好奇cookie、session可以跳过直接看2.2）

我们使用 cookie 来跟踪会话，我们就可以在浏览器第一次发起请求来请求服务器的时候，我们在服务器端来设置一个cookie。

服务器端在给客户端在响应数据的时候，会自动的将 cookie 响应给浏览器，浏览器接收到响应回来的 cookie 之后，会自动的将 cookie 的值存储在浏览器本地。接下来在后续的每一次请求当中，都会将浏览器本地所存储的 cookie 自动地携带到服务端。

为什么这一切都是自动化进行的？

是因为 cookie 它是 HTP 协议当中所支持的技术，在 HTTP 协议官方给我们提供了一个响应头和请求头：

响应头 Set-Cookie ：设置Cookie数据的
请求头 Cookie：携带Cookie数据的

优缺点：

优点：HTTP协议中支持的技术（像Set-Cookie 响应头的解析以及 Cookie 请求头数据的携带，都是浏览器自动进行的，是无需我们手动操作的）
缺点：
- 移动端APP(Android、IOS)中无法使用Cookie
- 不安全，用户可以自己禁用Cookie
- Cookie不能跨域（现在都前后端分离，会使用到跨域操作）

2.1.2 Session (服务端会话跟踪技术) ×

Session 的底层是基于 Cookie 实现的。

浏览器在第一次请求服务器的时候，我们就可以直接在服务器当中来获取到会话对象Session。如果是第一次请求，会话对象不存在，此时服务器会自动创建一个会话对象Session，每个会话对象Session都有一个ID。

服务器端在给浏览器响应数据的时候，它会将 Session 的 ID 通过 Cookie 响应给浏览器，浏览器会自动识别这个响应头，然后自动将Cookie存储在浏览器本地。

接下来，在后续的每一次请求当中，都会将 Cookie 的数据获取出来，并且携带到服务端。服务器拿到JSESSIONID这个 Cookie 的值，也就是 Session 的ID，就会从众多的 Session 当中来找到当前请求对应的会话对象Session。

优缺点

优点：Session是存储在服务端的，安全
缺点：
- 服务器集群环境下无法直接使用Session
- Cookie的全部缺点

2.1.3 令牌技术 Token ❤

令牌，其实它就是一个用户身份的标识，看似很高大上，很神秘，其实本质就是一个字符串。

① 通过令牌技术来跟踪会话，在浏览器发起请求，如果登录成功，我就可以生成一个令牌（合法身份凭证），接下来我在响应数据的时候，我就可以直接将令牌响应给前端。

② 前端程序接收到令牌之后，将其存储起来（可以存储在 cookie或其他的存储空间当中）。在后续的每一次请求当中，都需要将令牌携带到服务端。

③ 之后只需要校验令牌的有效性，如果是在同一次会话的多次请求之间，我们想共享数据，我们就可以将共享的数据存储在令牌当中就可以了。

优缺点

优点：
- 支持PC端、移动端
- 解决集群环境下的认证问题
- 减轻服务器的存储压力（无需在服务器端存储）
缺点：需要自己实现（包括令牌的生成、令牌的传递、令牌的校验）

2.2 JWT 令牌

JSON Web Token（官网：https://jwt.io/）

定义了一种简洁的、自包含的格式，用于在通信双方以json数据格式 安全的传输信息。

JWT的组成：（JWT令牌由三个部分组成，三个部分之间使用英文的点来分割）

第一部分：Header(头），记录令牌类型、签名算法等。例如：{"alg":"HS256","type":"JWT"}

第二部分：Payload(有效载荷），携带一些自定义信息、默认信息等。例如：{"id":"1","username":"Tom"}

第三部分：Signature(签名），防止Token被篡改、确保安全性。将header、payload，并加入指定秘钥，通过指定签名算法计算而来。

2.2.1 JWT 令牌的生成 / 解析

第一步，引入JWT的依赖（pom.xml）：

XML 复制代码

<!-- JWT依赖-->
<dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt</artifactId>
    <version>0.9.1</version>
</dependency>

第二步，调用工具包中提供的API来完成JWT令牌的生成和校验。（工具类：Jwts）

生成：

java 复制代码

/**
 * 生成JWT令牌
 */
@Test
public void testGenerateJwt() {
    Map<String, Object> dataMap = new HashMap<>();
    dataMap.put("id", 1);
    dataMap.put("username", "admin");
    String jwt = Jwts.builder() //创建JwtBuilder
            .signWith(SignatureAlgorithm.HS256, "aXRoZWltYQ==") //指定加密算法和密钥
            .addClaims(dataMap) //添加自定义信息
            .setExpiration(new Date(System.currentTimeMillis() + 1000 * 60 * 60 * 24)) //设置令牌过期时间
            .compact(); //生成令牌
    System.out.println(jwt);
}

eyJhbGciOiJIUzI1NiJ9.eyJpZCI6MSwidXNlcm5hbWUiOiJhZG1pbiIsImV4cCI6MTc2OTA3NDE1MX0.vUu0QoENyfkaOvPmNqVxQXoERelQQ5UOab_j1w3jLTs

校验：

java 复制代码

/**
 * 解析JWT令牌
 */
@Test
public void testParseJwt() {
    String token = "eyJhbGciOiJIUzI1NiJ9.eyJpZCI6MSwidXNlcm5hbWUiOiJhZG1pbiIsImV4cCI6MTc2OTA3MzE0NX0.S4fXooq6PNepZmG7cBr2ULBMnt_uDNa6cHFvBDlNMgo";
    Claims claims = Jwts.parser() //创建JwtParser
            .setSigningKey("aXRoZWltYQ==") //指定密钥
            .parseClaimsJws(token) //解析令牌
            .getBody(); //获取自定义信息
    System.out.println(claims);
}

使用JWT令牌时需要注意：

JWT校验时使用的签名秘钥，必须和生成JWT令牌时使用的秘钥是配套的。
如果JWT令牌解析校验时报错，则说明 JWT令牌 被篡改 或 失效了，令牌非法。

2.2.2 登录时下发令牌

在案例当中通过JWT令牌技术来跟踪会话，主要就是两步操作：

生成令牌：在登录成功之后来生成一个JWT令牌，并且把这个令牌直接返回给前端。
校验令牌：拦截前端请求，从请求中获取到令牌，对令牌进行解析校验。

java 复制代码

public class JwtUtils {
    private static final String SECRET_KEY = "aXRoZWltYQ=="; //密钥
    private static final long EXPIRATION_TIME = 1000 * 60 * 60 * 24;

    /**
     * 生成JWT令牌
     *
     * @param claims JWT令牌中包含的信息
     * @return JWT令牌
     */
    public static String generateToken(Map<String, Object> claims) {
        return Jwts.builder()
                .signWith(SignatureAlgorithm.HS256, SECRET_KEY)
                .addClaims(claims)
                .setExpiration(new Date(System.currentTimeMillis() + EXPIRATION_TIME))
                .compact();
    }

    /**
     * 解析JWT令牌
     *
     * @param token JWT令牌
     * @return 解析后的JWT令牌信息
     */
    public static Claims parseToken(String token) {
        return Jwts.parser()
                .setSigningKey(SECRET_KEY)
                .parseClaimsJws(token)
                .getBody();
    }
}

完善 EmpServiceImpl中的 login 方法逻辑，登录成功，生成JWT令牌并返回。

java 复制代码

@Override
public LoginInfo login(Emp emp) {
    // 1. 调用mapper接口，根据用户名和密码查询员工信息
    Emp e = empMapper.getByUsernameAndPassword(emp);
    // 2. 判断员工信息是否为空，若不为空，则组装员工信息并返回
    if(e != null){
        log.info("登录成功：{}", e);
        //生成Jwt令牌
        Map<String, Object> claims=new HashMap<>();
        claims.put("id", e.getId());
        claims.put("username", e.getUsername());
        String jwt = JwtUtils.generateToken(claims);
        return new LoginInfo(e.getId(), e.getUsername(), e.getName(), jwt);
    }
    // 3. 否则，返回null
    return null;
}

2.3 过滤器 Filter

过滤器可以把对资源的请求拦截下来，从而实现一些特殊的功能。使用了过滤器之后，要想访问web服务器上的资源，必须先经过滤器，过滤器处理完毕之后，才可以访问对应的资源。

过滤器一般完成一些通用的操作，比如：登录校验、统一编码处理、敏感字符处理等。

2.3.1 Filter快速入门

基本使用操作：

第1步，定义过滤器：1.定义一个类，实现 Filter 接口，并重写其所有方法。

init方法：过滤器的初始化方法。在web服务器启动的时候会自动的创建Filter过滤器对象，在创建过滤器对象的时候会自动调用init初始化方法，这个方法只会被调用一次。
doFilter方法：这个方法是在每一次拦截到请求之后都会被调用，所以这个方法是会被调用多次的，每拦截到一次请求就会调用一次doFilter()方法。
destroy方法：是销毁的方法。当我们关闭服务器的时候，它会自动的调用销毁方法destroy，而这个销毁方法也只会被调用一次。

第2步，配置过滤器：Filter类上加 @WebFilter 注解，配置拦截资源的路径。引导类上加 @ServletComponentScan 开启Servlet组件支持。

java 复制代码

@WebFilter(urlPatterns = "/*") // 拦截所有请求
@Slf4j
public class DemoFilter implements Filter {

    // 初始化,web服务启动时执行,只执行一次
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        log.info("DemoFilter初始化...");
    }

    // 拦截到请求时执行，每次请求都会执行
    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        log.info("拦截到了请求,DemoFilter执行...");
        // 放行
        filterChain.doFilter(servletRequest, servletResponse);
    }

    // 销毁,web服务停止时执行,只执行一次
    @Override
    public void destroy() {
        log.info("DemoFilter销毁...");
    }
}

java 复制代码

@ServletComponentScan // 开启了SpringBoot对Servlet组件的支持,如Filter、Servlet、Listener(后两种已经不常使用)
@SpringBootApplication
public class TliasWebManagementApplication {

    public static void main(String[] args) {
        SpringApplication.run(TliasWebManagementApplication.class, args);
    }

}

注意事项： 在过滤器Filter中，拦截到请求之后，需要放行，如果不执行放行操作，将无法访问后面的资源。放行操作：filterChain.doFilter(servletRequest, servletResponse);

2.3.2 登录校验过滤器

用户登录成功后，系统会下发JWT令牌，然后在后续的每次请求中，都需要在请求头header中携带到服务端，请求头的名称为 token，值为登录时下发的JWT令牌。如果检测到用户未登录，则直接响应 401 状态码。

所有的请求，拦截到了之后，都需要校验令牌吗？登录请求例外。

拦截到请求后，什么情况下才可以放行，执行业务操作？有令牌，且令牌校验通过(合法)；否则都返回未登录错误结果。

java 复制代码

@Slf4j
@WebFilter(urlPatterns = "/*")
public class TokenFilter implements Filter {

    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        HttpServletRequest request = (HttpServletRequest) servletRequest;
        HttpServletResponse response = (HttpServletResponse) servletResponse;

        //1.获取到请求路径
        String requestURI = request.getRequestURI();

        //2.判断是否是登录请求，如果是登录请求，则放行
        if(requestURI.contains("/login")){
            log.info("登录请求，放行: {}", requestURI);
            filterChain.doFilter(request,response);
            return;
        }

        //3.获取请求头中的token
        String token = request.getHeader("token");

        //4.判断token是否为空，如果为空，说明用户未登录，则返回错误信息401
        if(token == null || token.isEmpty()){
            log.info("令牌为空，响应401");
            response.setStatus(HttpServletResponse.SC_UNAUTHORIZED);
            return;
        }

        //5.如果token存在，则解析token，如果校验失败，则返回错误信息401
        try {
            JwtUtils.parseToken(token);
        } catch (Exception e) {
            log.info("令牌解析失败，响应401");
            response.setStatus(HttpServletResponse.SC_UNAUTHORIZED);
            return;
        }

        //6.校验通过，则放行
        log.info("令牌解析成功，放行");
        filterChain.doFilter(request,response);
    }
}

2.3.3 Filter详解

1. 执行流程

在放行后，访问完 web 资源之后，还会回到过滤器当中，回到过滤器之后，如有需求还可以执行放行之后的逻辑。

拦截路径

|----------|------------------|-----------------------|
| 拦截路径 | urlPatterns值 | 含义 |
| 拦截具体路径 | /login | 只有访问 /login 路径时，才会被拦截 |
| 目录拦截 | /emps/* | 访问/emps下的所有资源，都会被拦截 |
| 拦截所有 | /* | 访问所有资源，都会被拦截 |

过滤器链

多个过滤器形成一个过滤器链。

过滤器链上过滤器的执行顺序：注解配置的Filter，优先级是按照过滤器类名（字符串）的自然排序。比如：

AbcFilter
DemoFilter

这两个过滤器来说，AbcFilter 会先执行，DemoFilter会后执行。

2.4 拦截器 Interceptor

什么是拦截器？

是一种动态拦截方法调用的机制，类似于过滤器。

拦截器是Spring框架中提供的，用来动态拦截控制器方法的执行。

拦截器的作用：拦截请求，在指定方法调用前后，根据业务需要执行预先设定的代码。

2.4.1 Interceptor快速入门

拦截器的使用步骤和过滤器类似，也分为两步：

定义拦截器 - 实现HandlerInterceptor接口，并重写其所有方法

java 复制代码

@Slf4j
@Component // 将当前组件注册到Spring容器中
public class DemoInterceptor implements HandlerInterceptor {
    //在目标资源方法执行之前执行，返回值表示是否放行，true表示放行，false表示不放行
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        log.info("preHandle ...");
        return true;
    }

    //在目标资源方法执行之后执行
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        log.info("postHandle ...");
    }

    //视图渲染之后执行
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        log.info("afterCompletion ...");
    }
}

preHandle方法：目标资源方法执行前执行。 true放行，false不放行。
postHandle方法：目标资源方法执行后执行。
afterCompletion方法：视图渲染完毕后执行，最后执行。(现在前后端分离了，弃用了)

注册配置拦截器

java 复制代码

/**
 * 配置类
 */
@Configuration // 标识当前类是一个配置类
public class WebConfig implements WebMvcConfigurer {
    @Autowired
    private DemoInterceptor demoInterceptor;

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(demoInterceptor).addPathPatterns("/**"); // 添加拦截器，拦截所有请求
    }
}

2.4.2 令牌校验Interceptor

java 复制代码

@Slf4j
@Component
public class TokenInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        //1.获取到请求路径
        String requestURI = request.getRequestURI();

        //2.判断是否是登录请求，如果是登录请求，则放行
        if(requestURI.contains("/login")){
            log.info("登录请求，放行: {}", requestURI);
            return true;
        }

        //3.获取请求头中的token
        String token = request.getHeader("token");

        //4.判断token是否为空，如果为空，说明用户未登录，则返回错误信息401
        if(token == null || token.isEmpty()){
            log.info("令牌为空，响应401");
            response.setStatus(HttpServletResponse.SC_UNAUTHORIZED);
            return false;
        }

        //5.如果token存在，则解析token，如果校验失败，则返回错误信息401
        try {
            JwtUtils.parseToken(token);
        } catch (Exception e) {
            log.info("令牌解析失败，响应401");
            response.setStatus(HttpServletResponse.SC_UNAUTHORIZED);
            return false;
        }

        //6.校验通过，则放行
        log.info("令牌解析成功，放行");
        return true;
    }
}

java 复制代码

/**
 * 配置类
 */
@Configuration // 标识当前类是一个配置类
public class WebConfig implements WebMvcConfigurer {
//    @Autowired
//    private DemoInterceptor demoInterceptor;
    @Autowired
    private TokenInterceptor tokenInterceptor;

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(tokenInterceptor).addPathPatterns("/**"); // 添加拦截器，拦截所有请求
    }
}

2.4.3 Interceptor详解

拦截路径

addPathPatterns("要拦截路径") 方法，就可以指定要拦截哪些资源。

excludePathPatterns("不拦截路径")方法，指定哪些资源不需要拦截。

java 复制代码

//注册自定义拦截器对象
registry.addInterceptor(demoInterceptor)
    .addPathPatterns("/**")//设置拦截器拦截的请求路径（ /** 表示拦截所有请求）
    .excludePathPatterns("/login");//设置不拦截的请求路径

|-------------|---------------|-------------------------------------------|
| 拦截路径 | 含义 | 举例 |
| /* | 一级路径 | 能匹配/depts，/emps，/login，不能匹配 /depts/1 |
| /** | 任意级路径 | 能匹配/depts，/depts/1，/depts/1/2 |
| /depts/* | /depts下的一级路径 | 能匹配/depts/1，不能匹配/depts/1/2，/depts |
| /depts/** | /depts下的任意级路径 | 能匹配/depts，/depts/1，/depts/1/2，不能匹配/emps/1 |

执行流程

过滤器和拦截器之间的区别，其实它们之间的区别主要是两点：

接口规范不同：过滤器需要实现Filter接口，而拦截器需要实现HandlerInterceptor接口。
拦截范围不同：过滤器Filter会拦截所有的资源，而Interceptor只会拦截Spring环境中的资源。