【Springboot】黑马大事件笔记 day1

目录

注册部分

用户密码加密

@Validation 校验

参数校验失败异常处理

登入部分

实现令牌登入

 JWT 生成令牌

后台获取用户信息 

设置用户信息可见性

注册拦截器

ThreadLocal 优化

注册部分

---

用户密码加密

        在 SpringBoot 应用中，密码加密是一个重要的安全措施，用于保护用户信息不被未授权访问。在该项目中采用了 Md5Util 工具类来加密用户密码：

Md5Util：

package com.thz.utils;


import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;

public class Md5Util {
    /**
     * 默认的密码字符串组合，用来将字节转换成 16 进制表示的字符,apache校验下载的文件的正确性用的就是默认的这个组合
     */
    protected static char hexDigits[] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};

    protected static MessageDigest messagedigest = null;

    static {
        try {
            messagedigest = MessageDigest.getInstance("MD5");
        } catch (NoSuchAlgorithmException nsaex) {
            System.err.println(Md5Util.class.getName() + "初始化失败，MessageDigest不支持MD5Util。");
            nsaex.printStackTrace();
        }
    }

    /**
     * 生成字符串的md5校验值
     *
     * @param s
     * @return
     */
    public static String getMD5String(String s) {
        return getMD5String(s.getBytes());
    }

    /**
     * 判断字符串的md5校验码是否与一个已知的md5码相匹配
     *
     * @param password  要校验的字符串
     * @param md5PwdStr 已知的md5校验码
     * @return
     */
    public static boolean checkPassword(String password, String md5PwdStr) {
        String s = getMD5String(password);
        return s.equals(md5PwdStr);
    }


    public static String getMD5String(byte[] bytes) {
        messagedigest.update(bytes);
        return bufferToHex(messagedigest.digest());
    }

    private static String bufferToHex(byte bytes[]) {
        return bufferToHex(bytes, 0, bytes.length);
    }

    private static String bufferToHex(byte bytes[], int m, int n) {
        StringBuffer stringbuffer = new StringBuffer(2 * n);
        int k = m + n;
        for (int l = m; l < k; l++) {
            appendHexPair(bytes[l], stringbuffer);
        }
        return stringbuffer.toString();
    }

    private static void appendHexPair(byte bt, StringBuffer stringbuffer) {
        char c0 = hexDigits[(bt & 0xf0) >> 4];// 取字节中高 4 位的数字转换, >>>
        // 为逻辑右移，将符号位一起右移,此处未发现两种符号有何不同
        char c1 = hexDigits[bt & 0xf];// 取字节中低 4 位的数字转换
        stringbuffer.append(c0);
        stringbuffer.append(c1);
    }

}

        于是在创建用户信息时，我们的 Service 层就可以通过这种方式将用户输入的密码，转化成难破译的校验码 (字符串) 添加到数据库中。

    @Override
    public void register(String username, String password) {
        // 加密
        String md5String = Md5Util.getMD5String(password);
        // 添加
        userMapper.addUser(username,md5String);
    }

         当用户登入时进行密码效验，我们可以把输入密码转化成 “指定” 的校验码与数据库中的校验码进行匹配。如果匹配就进入首页；这样在一定程度上保证了用户账号的安全性。

    public Result<String> login(String username,String password) {
        // 根据用户名查询用户
        User loginUser = userService.findByUserName(username);
        // 判断密码是否正确
        if(Md5Util.getMD5String(password).equals(loginUser.getPassword())) {
        ...
        }
    }

---

@Validation 校验

        Spring 提供的一个参数校验框架，使用预定义的注解 Validation 即可完成参数校验。

使用步骤：

(1)Validation 起步依赖：

    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-validation</artifactId>
    </dependency>

(2)在Controller类上添加@Validated注解

(3)在参数前面添加@Pattern注解

@Pattern 当输入不能满足条件是，就会抛出异常，而后统一由异常中心处理

@Validated
public class UserController {

    // ...
    public Result register(@Pattern(regexp = "^\\S{5,16}$") String username,
                           @Pattern(regexp = "^\\S{5,16}$") String password) {
        User user = userService.findByUserName(username);
        if(user == null) {
            userService.register(username,password);
            return Result.success();
        }else{
            return Result.error("用户名已被注册");
        }
    }
    //...
}

        以下是一个正则表达式说明：参数的长度必须在 [5,16] 这个区间之间，否则便会抛出异常。

regexp = "^\\S{5,16}$"

        以上如果校验失败了，就会抛出 401 或者 500 的错误；如果把这些错误直接展示给用户看会显得不够优雅；于是我们需要把所有校验的异常同一处理

 

参数校验失败异常处理

        @RestControllerAdvice 是 Spring 为我们提供的一个复合注解，它是 @ControllerAdvice 和 @ResponseBody 的结合体。它会自动应用到所有使用 @RequestMapping 的控制器方法上。这意味着，无论在哪个控制器中发生异常，都会被这个全局处理器捕获并处理。

@ControllerAdvice	@ResponseBody
该注解标志着一个类可以为所有的 @RequestMapping 处理方法提供通用的异常处理和数据绑定等增强功能。当应用到一个类上时，该类中定义的方法将在所有控制器类的请求处理链中生效。	表示方法的返回值将被直接写入 HTTP 响应体中，通常配合 Jackson 或 Gson 等 JSON 库将对象转换为 JSON 格式的响应。

@RestControllerAdvice
public class GlobalExceptionHandler {
    @ExceptionHandler(Exception.class)
    public Result handleException(Exception e){
        e.printStackTrace();
        return Result.error(StringUtils.hasLength(e.getMessage())? e.getMessage() : "操作失败");
    }
}

         这样反应的结果就发生了变化。

登入部分

---

实现令牌登入

         简单来说，就是在用户登录成功以后，为用户颁发一个token(令牌)，用户便可以使用这个 token 令牌访问后台的接口。如果没有这个令牌或者使用非法令牌都不能访问后台接口。

令牌的概念：
令牌就是一段字符串，它的运用主要是以下两个功能

承载业务数据，减少后续请求查询数据库的次数

防篡改，保证信息的合法性和有效性

 

 JWT 生成令牌

全称：JSON Web Token

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

组成：

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

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

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

 

JWT依赖：

    <dependency>
      <groupId>com.auth0</groupId>
      <artifactId>java-jwt</artifactId>
      <version>${ava-jwt.version}</version>
    </dependency>

 JwtUtil 工具类

package com.thz.utils;

import com.auth0.jwt.JWT;
import com.auth0.jwt.algorithms.Algorithm;

import java.util.Date;
import java.util.Map;

public class JwtUtil {

    private static final String KEY = "thz";

// 接收业务数据,生成token并返回
    public static String genToken(Map<String, Object> claims) {
        return JWT.create()
                .withClaim("claims", claims)
                .withExpiresAt(new Date(System.currentTimeMillis() + 1000 * 60 * 60 ))
                .sign(Algorithm.HMAC256(KEY));
    }

// 接收token,验证token,并返回业务数据
    public static Map<String, Object> parseToken(String token) {
        return JWT.require(Algorithm.HMAC256(KEY))
                .build()
                .verify(token)
                .getClaim("claims")
                .asMap();
    }

}

 JwtUtil 生成令牌

    // 接收业务数据,生成token并返回
    public static String genToken(Map<String, Object> claims) {
        return JWT.create()
                // 添加载荷
                .withClaim("claims", claims)
                // 添加过期时间
                .withExpiresAt(new Date(System.currentTimeMillis() + 1000 * 60 * 60 ))
                // 指定算法，配置秘钥
                .sign(Algorithm.HMAC256(KEY));
    }

        为了让后台拿到用户的信息，我们可以把用户的 用户名id 作为载荷去生成 token 令牌：

    @PostMapping("/login")
    public Result<String> login(@Pattern(regexp = "^\\S{5,16}$") String username,
                                @Pattern(regexp = "^\\S{5,16}$") String password) {
        // 根据用户名查询用户
        User loginUser = userService.findByUserName(username);
        // 判断用户名是否存在
        if(loginUser == null) {
            return Result.error("用户名不存在");
        }
        // 判断密码是否正确
        if(Md5Util.getMD5String(password).equals(loginUser.getPassword())) {
            // 登入成功
            Map<String,Object> claims = new HashMap<>();
            claims.put("id",loginUser.getId());
            claims.put("username",loginUser.getUsername());
            // 获取token
            String token = JwtUtil.genToken(claims);
            return Result.success(token);
        }
        return Result.error("密码错误");
    }

后台获取用户信息 

         这样我们就可以在后台访问 token 令牌的用户名，查找到用户的详细信息。

    @GetMapping("/userInfo")
    public Result<User> userInfo(@RequestHeader(name = "Authorization") String token) {
        Map<String,Object> claims = JwtUtil.parseToken(token);
        String username = (String) claims.get("username");
        User user = userService.findByUserName(username);
        return Result.success(user);
    }

设置用户信息可见性

        但是为了账号保密性；密码信息需要进行处理，不给予返回。 

        我们可以在 user 实体类中加入 @JsonIgnore 注解；表示将来传递的 json 对象不包含这个属性。

    @JsonIgnore //让springmvc把当前对象转换成json字符串的时候,忽略password,最终的json字符串中就没有password这个属性了
    private String password;//密码

注册拦截器

        令牌的场景一般是用户登入的时候获取令牌，拿着这个令牌就可以访问后台；但是如果没有令牌或者令牌不合法就不能进行访问。所以我们创建一个登录拦截器 LoginInterceptor，用于获取请求的 Token 并进行验证。

注册拦截器：

@Configuration
public class WebConfig implements WebMvcConfigurer {
    @Autowired
    private LoginInterceptor loginInterceptor;

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        // 登入接口和注册接口不拦截
        registry.addInterceptor(loginInterceptor).excludePathPatterns("/user/login","/user/register");
    }
}

 后台入口判断是否拦截：

public class LoginInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        // 验证令牌
        String token = request.getHeader("Authorization");
        // 解析 token
        try{
            Map<String,Object> claims = JwtUtil.parseToken(token);
            // 放行
            return true;
        }catch (Exception e){
            response.setStatus(401);
            // 不放行
            return false;
        }
    }
}

 

ThreadLocal 优化

        ThreadLocal，也称为线程局部变量，是一种特殊的变量。它的特点是，每个线程都有该变量的一个副本，线程之间互不影响，实现了线程间的数据隔离。

ThreadLocal：提供线程局部安全

• 用来存取数据:set()/get()
• 使用ThreadLocal存储的数据，线程安全
• 用完记得调用remove方法释放

         简单来说就是 ThreadLocal 可以将一个代码块或者对象封装起来给多个线程提供使用，而且这多个线程使用这个 ThreadLocal 都是获取自己的部分，各个线程之间不会相互影响。于是我们可以使用 ThreadLocal 来优化代码：

拦截器部分：

public class LoginInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        // 验证令牌
        String token = request.getHeader("Authorization");
        // 解析 token
        try{
            Map<String,Object> claims = JwtUtil.parseToken(token);
            // 放行
            return true;
        }catch (Exception e){
            response.setStatus(401);
            // 不放行
            return false;
        }
    }
}

获取用户信息部分：

    @GetMapping("/userInfo")
    public Result<User> userInfo(@RequestHeader(name = "Authorization") String token) {
        Map<String,Object> claims = JwtUtil.parseToken(token);
        String username = (String) claims.get("username");
        User user = userService.findByUserName(username);
        return Result.success(user);
    }

        不使用 ThreadLocal 之前，获取用户信息需要获取 token 对象；使用 ThreadLocal 后 token 就存在 ThreadLocal 中，就不需要再去等待 token 的传递，可以做到随用随取。

使用 ThreadLocal 后

@Component
public class LoginInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        // 令牌验证
        String token = request.getHeader("Authorization");
        // 解析 token
        try{
            Map<String,Object> claims = JwtUtil.parseToken(token);
            //把业务数据存储到ThreadLocal中
            ThreadLocalUtil.set(claims);
            // 放行
            return true;
        }catch (Exception e){
            // http 响应的状态码
            response.setStatus(401);
            // 不放行
            return false;
        }
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        //清空ThreadLocal中的数据，防止内存泄漏
        ThreadLocalUtil.remove();
    }
}

    @GetMapping("/userInfo")
    public Result<User> userInfo() {
        Map<String,Object> map = ThreadLocalUtil.get();
        String username = (String) map.get("username");
        User user = userService.findByUserName(username);
        return Result.success(user);
    }

原文地址：https://blog.csdn.net/2301_79201049/article/details/143650799

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！