学了好久springBoot但是每一次使用都没有一个固定的方法或者是代码的模版，于是乎使用的时候吗，每次都会遇到很多的问题，所以，总结一篇博客用于日后方便自己开发使用，其中包含项目创建，坐标导入，登录注册逻辑，使用到jwt令牌技术进行登录认证，ThreadLocal优化等等~~废话不多说，直接开始！！

1，创建springBoot工程-手动版本

        第一步：首先创建一个新的项目

                指定maven工程，指定项目名称，组织id，以及jdk版本，我这里使用jdk17

        第二步：引入springBoot相关依赖 

                在pom文件中让当前工程继承自父工程，指定springboot版本为3.1.3，具体引入如下：

<parent>
    <artifactId>spring-boot-starter-parent</artifactId>
    <groupId>org.springframework.boot</groupId>
    <version>3.1.3</version>
</parent> 

                引入springboot-web起步依赖，如下：

<!--springboot依赖-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

 

        第三步：创建springboot核心配置文件 

                创建application.yml核心配置文件：格式如下

        第四步：编写启动类，启动springboot工程

                默认启动类在组织包之下,且工程启动的时候会扫描启动类所在包机器子包，默认启动类命名格式为：项目名+Application 代码如下：

@SpringBootApplication//springboot启动类注解
public class BigEventApplication {
    public static void main(String[] args) {
        //传入springboot启动需要的启动类的字节码文件以及参数
        SpringApplication.run(BigEventApplication.class,args);
    }
}

 到此springboot工程创建完成！！！

2，搭建项目结构整合mybatis完成注册接口开发！！ 

        第一步：导入相关坐标

                导入mysql8的驱动，导入mybatis坐标，lambok坐标：

<!--mybatis依赖-->
<dependency>
    <groupId>org.mybatis.spring.boot</groupId>
    <artifactId>mybatis-spring-boot-starter</artifactId>
    <version>3.0.0</version>
</dependency>
<!--mysql驱动依赖-->
<dependency>
    <groupId>com.mysql</groupId>
    <artifactId>mysql-connector-j</artifactId>
</dependency>
<!--lombok-->
<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
</dependency>

        第二步：封装统一响应结构Result 

                

@Data
@NoArgsConstructor
@AllArgsConstructor
public class Result<T> {
    private Integer code;//业务状态码，0-成功，1-失败
    private String mesage;//提示信息
    private T data;

    public static <E> Result<E> success(E data){
        return new Result<>(0,"操作成功",data);
    }
    public static Result success(){
        return new Result(0,"操作成功",null);
    }
    public static Result error(String msg){
        return new Result(1,msg,null);
    }
}

        第三步：配置数据库相关信息

        1，配置数据库连接信息

spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/数据名
    username: 用户名
    password: 你的密码
server:
  port: 8090

        2，导入相关实体类

        3，开启驼峰命名：

mybatis:
  configuration:
    map-underscore-to-camel-case: true

        第四步：创建包结构，编写代码

                编写三层架构代码，这里control，service，以及mapper，不要忘记，加上@RestControl注解，@service注解，@Mapper注解，编写相关代码，简单查询可以直接在mapper层使用注解查询，

包的层级结构如下：

  

3，实现登录逻辑-jwt令牌

        第一步：引入jwt依赖：

<!--引入一个jwt依赖-->
<dependency>
    <groupId>com.auth0</groupId>
    <artifactId>java-jwt</artifactId>
    <version>4.3.0</version>
</dependency>

        第二步：编写登录接口的controller代码

                实现如下：首先进行参数校验，其中MD5Utils是自己封装好的工具类，是用来对存入数据库的用户密码进行加密操作，JWTUtils也是自己编写好的工具类用于生成jwt令牌以及解析jwt令牌

//用户登录
@PostMapping("/login")
public Result login(String username,String password){
    //进行参数校验，判断输入用户是否合法
    //查询当前用户判断是否存在
    User loginUser = userService.findByUsername(username);
    if(loginUser==null){
        return Result.error("当前用户不合法！！");
    }
    //用户是合法的需要校验密码
    if(!Md5Util.getMD5String(password).equals(loginUser.getPassword())){
        //密码校验不正确
        return Result.error("密码错误");
    }
    //用户名和密码校验正确，下发jwt令牌
    //封装载荷，也就是当前用户的一些自定义信息
    HashMap<String, Object> claims = new HashMap<>();
    claims.put("id",loginUser.getId());
    claims.put("username",loginUser.getUsername());
    //下发jwt令牌
    return Result.success(JwtUtil.genToken(claims));
}

        MD5Utils代码如下：

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);
    }

}

        JWTUtils代码如下：

public class JwtUtil {

    private static final String KEY = "qmlx";
   
   //接收业务数据,生成token并返回
    public static String genToken(Map<String, Object> claims) {
        return JWT.create()
                .withClaim("claims", claims)
                .withExpiresAt(new Date(System.currentTimeMillis() + 1000 * 60 * 60 * 3))
                .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();
    }

}

        第三步： 定义全局异常处理器

                用于捕获全局异常，返回给用户，实现方法，在类上添加@RestControlAdvice注解

在方法上添加@ExceptionHandler(Exception.class)，指定拦截所有异常

        

/**
 * 定义全局异常处理器
 */
@RestControllerAdvice
public class GlobalExceptionHandler {
    @ExceptionHandler(Exception.class)//表示拦截所有异常
    public Result handlerException(Exception e){
        //判断当前异常信息是否存在，如果存在，打印，不存在返回操作失败
        return Result.error(StringUtils.hasLength(e.getMessage())?e.getMessage():"操作失败！");
    }
}

        第四步：定义拦截器 

                拦截器实现对所有进入的请求进行拦截，获取请求头中的jwt令牌，解析jwt令牌，如果解析成功，放行，如果解析不成功跳转到登录页面，目前没有前端页面于是先不放行即可

       实现方式，定义一个拦截器类实现HandlerInterceptor，重写其中的preHandler方法，实现对应的代码即可，完整代码如下：

@Component
public class LoginInterceptor implements HandlerInterceptor {
    //重写prehandler方法，定义拦截器
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        //进行令牌验证
        //1，在令牌中得到token
        String token = request.getHeader("Authorization");
        //2,解析token
        try {
            Map<String, Object> parseToken = JwtUtil.parseToken(token);
            //解析成功方形
            return true;
        } catch (Exception e) {
            //解析失败捕获到异常，不放行,设置相应状态码401
            response.setStatus(401);
            //不放行
            return false;
        }
    }
}

 至此，使用jwt令牌实现登录完成，后续会继续优化！！

4，使用ThreadLocal优化登录

        假设一个场景，需要查询当前用户信息，但是并没有传递任何参数，我们需要根据当前用户id或者其他信息进行查询，但是并不知道是那个用户，于是乎问题边的不好解决。

        我们在每次请求发出的时候拦截器都会校验jwt令牌，请求头中是会携带jwt令牌的，于是我们使用RequestHeader注解获取请求头中的令牌，解析jwt令牌进而获取用户信息，查询需要的结果，代码实现如下：

//获取用户详细信息
@GetMapping("/userInfo")
public Result<User> userInfo(@RequestHeader(name = "Authorization") String token){
    //当前请求是没有携带任何参数的，使用requestheader注解从请求头中获取token解析
    Map<String, Object> map = JwtUtil.parseToken(token);
    String username = String.valueOf(map.get("username"));

    User userInfo = userService.findByUsername(username);
    return Result.success(userInfo);
}

        但是上述实现方式存在问题，那就是在之前我们登录的时候已经解析过jwt令牌获取了map集合，再次解析代码不够优雅，我们需要多次进行服用，于是ThreadLocal登场了！！

ThreadLocal：提供线程局部变量，他提供了set以及get方法来进行存取数据，最重要的是他能保证线程安全，也就是说每个线程独立，互不影响！！使用测试代码进行实验如下：

public class ThreadLocalTest {
    @Test
    public void testThreadLocal(){
        ThreadLocal tl = new ThreadLocal();

        //开启两个线程
        new Thread(()->{
            tl.set("用户id-1");
            System.out.println(Thread.currentThread().getName()+":"+tl.get());
            System.out.println(Thread.currentThread().getName()+":"+tl.get());
            System.out.println(Thread.currentThread().getName()+":"+tl.get());
        }, "蓝色线程").start();
        new Thread(()->{
            tl.set("用户id-2");
            System.out.println(Thread.currentThread().getName()+":"+tl.get());
            System.out.println(Thread.currentThread().getName()+":"+tl.get());
            System.out.println(Thread.currentThread().getName()+":"+tl.get());
        },"红色线程").start();
    }
}

可以看到用户一直存在于同一个线程中：

 代码实现ThreadLocal优化

在拦截器中将解析后的map集合放入ThreadLocal，之后在接口中使用，使用完成之后，重写拦截器中的afterCompletion方法，将ThreadLocal中存储的信息释放，避免内存泄露

1，ThreadUtils工具类：

/**
 * ThreadLocal 工具类
 */
@SuppressWarnings("all")
public class ThreadLocalUtil {
    //提供ThreadLocal对象,
    private static final ThreadLocal THREAD_LOCAL = new ThreadLocal();

    //根据键获取值
    public static <T> T get(){
        return (T) THREAD_LOCAL.get();
    }
   
    //存储键值对
    public static void set(Object value){
        THREAD_LOCAL.set(value);
    }


    //清除ThreadLocal 防止内存泄漏
    public static void remove(){
        THREAD_LOCAL.remove();
    }
}

 2，拦截器中的方法实现：

@Component
public class LoginInterceptor implements HandlerInterceptor {
    //重写prehandler方法，定义拦截器
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        //进行令牌验证
        //1，在令牌中得到token
        String token = request.getHeader("Authorization");
        //2,解析token
        try {
            Map<String, Object> parseToken = JwtUtil.parseToken(token);
            //将解析出来的map集合放入ThreadLocal中存储
            ThreadLocalUtil.set(parseToken);
            //解析成功放行
            return true;
        } catch (Exception e) {
            //解析失败捕获到异常，不放行,设置相应状态码401
            response.setStatus(401);
            //不放行
            return false;
        }
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        //当前请求结束之后需要释放ThreadLocal中存储的信息，避免内存泄露
        ThreadLocalUtil.remove();

    }
}

3，controller中实现：

//获取用户详细信息
@GetMapping("/userInfo")
public Result<User> userInfo(@RequestHeader(name = "Authorization") String token){
    //当前请求是没有携带任何参数的，使用requestheader注解从请求头中获取token解析
    // Map<String, Object> map = JwtUtil.parseToken(token);
    //String username = String.valueOf(map.get("username"));

    //从Thread中取出map集合进而得到当前登录的用户信息
    Map<String,Object> map= ThreadLocalUtil.get();
    String username = String.valueOf(map.get("username"));
    User userInfo = userService.findByUsername(username);
    return Result.success(userInfo);
}

 

后续就可以使用ThreadLocal便捷的获取当前登录的用户信息了！！！持续更新ing~~~