Proyecto básico de separación de front-end SpringBoot desde cero (3)

Escritura de clase de entidad

En el artículo anterior, hemos completado la construcción del directorio del proyecto y el marco básico. Ahora comenzamos a escribir la clase de la entidad. Primero, creamos un subpaquete pojo bajo el paquete modelo.
Nota : Ya hay mucha información sobre el concepto de PO, VO, POJO, DTO, etc. en Internet. El significado detallado no se explicará en este proyecto, y solo POJO y DTO están divididos por conveniencia. Algunos de estos son ambiguos o Los lectores me perdonan por el uso o método de división incorrecto.
Luego de crear el subpaquete, creamos el pojo correspondiente, una tabla corresponde a una clase, si los alumnos que han escrito un proyecto web deben estar familiarizados con este paso, el autor no explicará el proceso de creación de la clase correspondiente uno por uno, por favor consulte al autor En la página de inicio de GitHub de GitHub, el código completo del proyecto importado directamente se cargará más tarde. Después de la creación, asegúrese de agregar las tres anotaciones @Data, @AllArgsConstructor y @NoArgsConstructor.

Utilice Token para la autenticación de usuarios

Después de escribir la clase de entidad, comenzamos a escribir la función de autenticación de autoridad de usuario En este proyecto, usamos jwt e interceptor para implementarlo.
Primero, solo hay tres roles en este proyecto:

1. Administrador de laboratorio (ADMIN)
2. Miembro de laboratorio (VIP)
3. Usuario ordinario (MIEMBRO)

Este método de división no es lo suficientemente riguroso y seguro. La división actual de permisos generalmente se divide en dos partes: roles de usuario y permisos de usuario. Cada usuario corresponde a un rol determinado y un rol determinado tiene ciertos permisos. Los lectores pueden pensar en ello y perfeccionarlo. Esquema de división de permisos.

Crear clase de herramienta Jwt

Primero, vayamos al paquete util y creemos una clase llamada JwtUtil. El contenido de la clase es el siguiente:
JwtUtil

/**
 * @Author Alfalfa99
 * @Date 2020/9/13 15:54
 * @Version 1.0
 * JWT生成以及校验工具类
 */

@ConfigurationProperties("jwt.config")
@Component
public class JwtUtil {
    
    
    private String key;
    private long ttl;

    public String getKey() {
    
    
        return key;
    }

    public void setKey(String key) {
    
    
        this.key = key;
    }

    public long getTtl() {
    
    
        return ttl;
    }

    public void setTtl(long ttl) {
    
    
        this.ttl = ttl;
    }

    /**
     * 生成JWT
     *
     * @param id
     * @return
     */
    public String createJWT(String id, String roles) {
    
    
        long nowMillis = System.currentTimeMillis();
        Date now = new Date(nowMillis);
        JwtBuilder builder = Jwts.builder().setId(id)	//在这里我们将用户的id存入Jwt中，方便后续使用
                .setIssuedAt(now)
                .signWith(SignatureAlgorithm.HS256, key).claim("roles", roles); //在这里我们将用户的角色存入Jwt中，方便后续鉴权,如果想存别的内容也可以往里写
        if (ttl > 0) {
    
    
            builder.setExpiration(new Date(nowMillis + ttl));
        }
        return builder.compact();
    }

    /**
     * 解析JWT
     *
     * @param jwtStr
     * @return
     */
    public Claims parseJWT(String jwtStr) {
    
    
        return Jwts.parser()
                .setSigningKey(key)
                .parseClaimsJws(jwtStr)
                .getBody();
    }
}

La clave es un texto cifrado que se utiliza para el cifrado en el servidor, que normalmente se genera de forma aleatoria. Ttl es el tiempo de vencimiento del token. Consulte el principio detallado del token por su cuenta. El espacio es limitado y no se repetirá. Aquí usamos @ConfigurationProperties("jwt.config")anotaciones para leer la siguiente configuración del archivo de configuración application.yml e inyectar campos automáticamente

jwt:
  config:
    key: SecretKey #服务端加密所使用的密文（自拟）
    ttl: 21600000 #毫秒
#请将该段复制至application.yml以便于能够启动项目

Volviendo al token, el token es generado por el usuario después de iniciar sesión correctamente y leer el rol y la identificación del usuario. El token generado debe devolverse al front-end después de que el inicio de sesión sea exitoso, y el front-end debe traer este token cada vez que acceda a la interfaz.
Nota : ¡Nunca use tokens para almacenar información confidencial del usuario, los tokens solo pueden usarse para evitar la manipulación, no el cifrado! El contenido transportado por el token en sí se puede analizar directamente sin la clave secreta del servidor. ! !
En este momento podemos crear una instancia de JwtUtil y usar createJWT para generar token o parseJWT para analizar token

Utilice el interceptor (interceptor) para lograr la interceptación y autenticación del acceso del usuario

En lo anterior, hemos podido analizar y generar un token, pero si volvemos a analizar el token en cada interfaz para la autenticación de autorización, será demasiado engorroso y degradará el rendimiento del servidor. Los lectores que tengan experiencia previa en la escritura de proyectos JavaEE deberían haber aprendido los filtros (Filtro), el interceptor es un componente similar al Filtro proporcionado por el marco Spring, pero el interceptor tiene funciones cada vez más poderosas, no hay mucho que decir directamente al código, primero creamos uno en el mismo directorio de nivel de la clase de inicio principal El paquete interceptor se usa para almacenar nuestro interceptor y crear una clase llamada Tokeninterceptor bajo este paquete. El contenido de la clase:

/**
 * @Author Alfalfa99
 * @Date 2020/9/13 18:18
 * @Version 1.0
 * 全局校验Token
 */
@Component
public class TokenInterceptor implements HandlerInterceptor {
    
    

    private final JwtUtil jwtUtil;

    public TokenInterceptor(JwtUtil jwtUtil) {
    
    
        this.jwtUtil = jwtUtil;
    }

    /**
     * 通过拦截器对请求头进行校验
     *
     * @param request
     * @param response
     * @param handler
     * @return
     * @throws Exception
     */
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) {
    
    
        String header = request.getHeader("Authorization");
        if (header != null && !"".equals(header)) {
    
    
            if (header.startsWith("Bearer ")) {
    
    
                //获得token
                String token = header.substring(7);
                //验证token
                try {
    
    
                    Claims claims = jwtUtil.parseJWT(token);
                    String roles = (String) claims.get("roles");
                    if (roles != null) {
    
    
                        request.setAttribute("uid",claims.getId());
                        request.setAttribute("roles",roles);
                        return true;
                    } else {
    
    
                        throw new BadCredentialsException("令牌已失效");
                    }
                } catch (Exception e) {
    
    
                    throw new BadCredentialsException("令牌已失效");
                }
            }
        }
        throw new AuthenticationCredentialsNotFoundException("请先登录");
    }
}

El token debe colocarse en el encabezado de la solicitud cada vez que la interfaz solicita el nombre de la clave Authorization, y el valor es Bearer Token(Token es el token generado por el servidor).

Primero, usamos @Componentanotaciones para registrar la clase como un contenedor Spring, luego usamos la clase que implementa HandlerInterceptorla interfaz, preHandle que se procesa antes de que se ejecute el método de destino. Primero inyectamos JwtUtil a través del constructor para su uso posterior, y luego leemos el token del encabezado de la solicitud. Si el token está vacío, significa que el usuario no ha iniciado sesión. Simplemente lanza una excepción. Si hay un error al analizar el token, lanza un error directamente. OKAY. La idea principal de esta parte es volver al mensaje de error del front-end si el contenido del token no se puede analizar correctamente y dejar que el front-end salte a la página de inicio de sesión para iniciar sesión nuevamente. Si los dos ID de usuario almacenados y la función del usuario se pueden analizar correctamente El contenido se agrega al campo de solicitud y podemos leer la identificación de uidusuario y el rol del usuario directamente desde la solicitud en la interfaz roles.
De esta manera, podemos juzgar si el usuario ha iniciado sesión cada vez que visitamos, y almacenamos la identificación del usuario y el rol del usuario en la solicitud para facilitar nuestro desarrollo posterior del controlador.

Escribir InterceptorConfig

Después de completar la preparación de la clase TokenInterceptor, nuestro contenido sobre la autenticación Token básicamente ha terminado. Por supuesto, también necesitamos escribir una clase InterceptorConfig para configurar nuestro interceptor. Luego creamos una clase llamada InterceptorConfig en el paquete de configuración. El contenido es el siguiente:

/**
 * @author 苜蓿
 * @date 2020/9/13
 * 拦截器配置类
 */
@Configuration
public class InterceptorConfig extends WebMvcConfigurationSupport {
    
    

    private final TokenInterceptor tokenInterceptor;

    public InterceptorConfig(TokenInterceptor tokenInterceptor) {
    
    
        this.tokenInterceptor = tokenInterceptor;
    }


    @Override
    protected void addInterceptors(InterceptorRegistry registry) {
    
    
        //拦截所有目录，除了通向login和register的接口
        registry.addInterceptor(tokenInterceptor)
                .addPathPatterns("/**")
                .excludePathPatterns("/**/login/**", "/**/register/**")
                .excludePathPatterns("/**/*.html", "/**/*.js", "/**/*.css");
}

Luego, nuestro TokenInterceptor se ha configurado para interceptar y autenticar todas las solicitudes de acceso, excepto archivos html, archivos css, archivos js e interfaces de inicio de sesión y registro.

Luego, el contenido de este blog se ha completado y comenzaremos a escribir el controlador en el próximo blog.