【案例实战】分布式应用下登录检验解决方案（JWT）-阿里云开发者社区

1.需求背景以及JWT简介

现实场景中，有些功能是需要登录才能访问的，比如购物车，个人订单等等。登录功能是最常见的功能。

（1）什么是JWT

JWT 是一个开放标准，它定义了一种用于简洁，自包含的用于通信双方之间以 JSON 对象的形式安全传递信息的方法。可以使用 HMAC 算法或者是 RSA 的公钥密钥对进行签名。

简单来说: 就是通过一定规范来生成token，然后可以通过解密算法逆向解密token，这样就可以获取用户信息

优点

生产的token可以包含基本信息，比如id、用户昵称、头像等信息，避免再次查库
存储在客户端，不占用服务端的内存资源

缺点
token是经过base64编码，所以可以解码，因此token加密前的对象不应该包含敏感信息，如用户权限，密码等
如果没有服务端存储，则不能做登录失效处理，除非服务端改秘钥
JWT格式组成头部、负载、签名

header+payload+signature

头部：主要是描述签名算法
负载：主要描述是加密对象的信息，如用户的id等，也可以加些规范里面的东西，如iss签发者，exp 过期时间，sub 面向的用户

签名：主要是把前面两部分进行加密，防止别人拿到token进行base解密后篡改token

关于jwt客户端存储

可以存储在cookie，localstorage和sessionStorage里面

（2）用户登录流程图

2.创建Maven项目，搭建SpringBoot项目

（1）添加maven依赖

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.6.7</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <dependencies>
        <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.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.20</version>
            <scope>compile</scope>
        </dependency>
    </dependencies>

（2）创建yml配置文件

server:
  port: 8001
spring:
  application:
    name: login-server

（3）创建运行主类

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

3.容器化急速部署MySQL

（1）创建目录

mkdir -p /usr/local/docker/mysql/conf
mkdir -p /usr/local/docker/mysql/logs
mkdir -p /usr/local/docker/mysql/data

（2）容器启动mysql服务

docker run -p 3306:3306 --name mysql \ 
-e MYSQL_ROOT_PASSWORD=123456 \
-d mysql:8.0

#查看容器
docker ps

（3）可视化工具连接

4.数据库表准备

（1）创建数据库user库

（2）创建测试用户表

创建表sql脚本

/*
 Navicat Premium Data Transfer
 Source Server         : mysql_test
 Source Server Type    : MySQL
 Source Server Version : 80027
 Source Host           : 192.168.139.100:3306
 Source Schema         : user
 Target Server Type    : MySQL
 Target Server Version : 80027
 File Encoding         : 65001
 Date: 15/11/2022 09:14:11
*/
SET NAMES utf8mb4;
SET FOREIGN_KEY_CHECKS = 0;
-- ----------------------------
-- Table structure for user
-- ----------------------------
DROP TABLE IF EXISTS `user`;
CREATE TABLE `user`  (
  `id` int(0) NOT NULL AUTO_INCREMENT COMMENT '主键ID',
  `username` varchar(128) CHARACTER SET utf8mb4 COLLATE utf8mb4_bin NULL DEFAULT NULL COMMENT '用户名',
  `password` varchar(128) CHARACTER SET utf8mb4 COLLATE utf8mb4_bin NULL DEFAULT NULL COMMENT '密码',
  `phone` varchar(128) CHARACTER SET utf8mb4 COLLATE utf8mb4_bin NULL DEFAULT NULL COMMENT '手机号',
  `name` varchar(128) CHARACTER SET utf8mb4 COLLATE utf8mb4_bin NULL DEFAULT NULL COMMENT '用户姓名',
  `sex` varchar(128) CHARACTER SET utf8mb4 COLLATE utf8mb4_bin NULL DEFAULT NULL COMMENT '用户性别',
  `create_time` datetime(0) NULL DEFAULT NULL COMMENT '创建时间',
  `age` int(0) NULL DEFAULT NULL COMMENT '年龄',
  PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8mb4 COLLATE = utf8mb4_bin ROW_FORMAT = Dynamic;
-- ----------------------------
-- Records of user
-- ----------------------------
SET FOREIGN_KEY_CHECKS = 1;

（3）创建测试登录用户

**注意：**这里只是做演示，正常企业密码不会设置明文的，按照企业自己的加密方式去加密密码，我们现在主要是为了开发登录鉴权这一套流程。

INSERT INTO `user`.`user`(`id`, `username`, `password`, `phone`, `name`, `sex`, `create_time`, `age`) VALUES (1, 'lixiang', '1234567890', '13830567835', '李祥', '男', '2022-11-15 09:19:26', 18);

5.SpringBoot整合MySQL+MyBatisPlus

（1）添加maven依赖

        <!--mybatis plus-->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.4.0</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.1.18</version>
        </dependency>

（2）配置yml文件

  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://192.168.139.100:3306/user?allowPublicKeyRetrieval=true&characterEncoding=UTF-8&allowMultiQueries=true&useUnicode=true&useSSL=false&serverTimezone=Asia/Shanghai
    username: root
    password: 123456
    type: com.alibaba.druid.pool.DruidDataSource
    druid:
      initial-size: 8
      max-active: 20
      max-wait: 60000
      min-evictable-idle-time-millis: 30000

（3）启动主类添加MapperScan()注解

@MapperScan("com.lixiang.mapper")

（4）启动验证

6.MyBatisPlus逆向工程自动生成

（1）加入maven依赖

        <!-- 代码自动生成依赖 begin -->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-generator</artifactId>
            <version>3.4.1</version>
        </dependency>
        <!-- velocity -->
        <dependency>
            <groupId>org.apache.velocity</groupId>
            <artifactId>velocity-engine-core</artifactId>
            <version>2.0</version>
        </dependency>
        <!-- 代码自动生成依赖 end-->

（2）运行代码

package com.lixiang.db;
import com.baomidou.mybatisplus.annotation.DbType;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.generator.AutoGenerator;
import com.baomidou.mybatisplus.generator.config.DataSourceConfig;
import com.baomidou.mybatisplus.generator.config.GlobalConfig;
import com.baomidou.mybatisplus.generator.config.PackageConfig;
import com.baomidou.mybatisplus.generator.config.StrategyConfig;
import com.baomidou.mybatisplus.generator.config.rules.DateType;
import com.baomidou.mybatisplus.generator.config.rules.NamingStrategy;
/**
 * @description mybatis自定生成工具
 */
public class MyBatisPlusGenerator {
    public static void main(String[] args) {
        //1. 全局配置
        GlobalConfig config = new GlobalConfig();
        // 是否支持AR模式
        config.setActiveRecord(true)
                // 作者
                .setAuthor("lixiang")
                // 生成路径，最好使用绝对路径，window路径是不一样的
                //TODO  TODO  TODO  TODO
                .setOutputDir("D:\\IDEAWork\\springboot-login\\src\\test\\java")
                // 文件覆盖
                .setFileOverride(true)
                // 主键策略
                .setIdType(IdType.AUTO)
                .setDateType(DateType.ONLY_DATE)
                // 设置生成的service接口的名字的首字母是否为I，默认Service是以I开头的
                .setServiceName("%sService")
                //实体类结尾名称
                .setEntityName("%sDO")
                //生成基本的resultMap
                .setBaseResultMap(true)
                //不使用AR模式
                .setActiveRecord(false)
                //生成基本的SQL片段
                .setBaseColumnList(true);
        //2. 数据源配置
        DataSourceConfig dsConfig = new DataSourceConfig();
        // 设置数据库类型
        dsConfig.setDbType(DbType.MYSQL)
                .setDriverName("com.mysql.cj.jdbc.Driver")
                //TODO 修改数据库对应的配置
                .setUrl("jdbc:mysql://121.36.81.39:3306/user?useUnicode=true&characterEncoding=utf-8&useSSL=false&serverTimezone=Asia/Shanghai")
                .setUsername("root")
                .setPassword("123456");
        //3. 策略配置globalConfiguration中
        StrategyConfig stConfig = new StrategyConfig();
        //全局大写命名
        stConfig.setCapitalMode(true)
                // 数据库表映射到实体的命名策略
                .setNaming(NamingStrategy.underline_to_camel)
                //使用lombok
                .setEntityLombokModel(true)
                //使用RestController注解
                .setRestControllerStyle(true)
                // 生成的表, 支持多表一起生成，以数组形式填写
                //TODO  TODO  TODO  TODO
                .setInclude("user");
        //4. 包名策略配置
        PackageConfig pkConfig = new PackageConfig();
        pkConfig.setParent("com.lixiang")
                .setMapper("mapper")
                .setService("service")
                .setController("controller")
                .setEntity("model")
                .setXml("mapper");
        //5. 整合配置
        AutoGenerator ag = new AutoGenerator();
        ag.setGlobalConfig(config)
                .setDataSource(dsConfig)
                .setStrategy(stConfig)
                .setPackageInfo(pkConfig);
        //6. 执行操作
        ag.execute();
        System.out.println("=======  相关代码生成完毕  ========");
    }
}

（3）启动验证

7.SpringBoot整合JWT

（1）添加maven依赖

            <!-- JWT相关 -->
            <dependency>
                <groupId>io.jsonwebtoken</groupId>
                <artifactId>jjwt</artifactId>
                <version>0.7.0</version>
            </dependency>

（2）编写登录用户类

/**
 * 登录user实体bean
 * @author lixiang
 * @since 2022-01-13
 */
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class LoginUser {
    /**
     * 主键
     */
    private Long id;
    /**
     * 用户名
     */
    private String username;
    /**
     * 姓名
     */
    private String name;
    /**
     * 手机号
     */
    private String phone;
    /**
     * 用户性别
     */
    private String sex;
    /**
     * 年龄
     */
    private Integer age;
}

（3）编写JWTUtil

/**
 * JWT工具类
 * @author lixiang
 * @since 2022-01-13
 */
@Slf4j
public class JWTUtil {
    /**
     * token过期时间，正常是7天
     */
    private static final long EXPIRE = 1000L * 60 * 60 * 24 * 7;
    /**
     * 加密的密钥
     */
    private static final String SECRET = "lixiang.com";
    /**
     * 令牌前缀
     */
    private static final String TOKEN_PREFIX = "LONGIN-TEST";
    /**
     * subject 颁布地址
     */
    private static final String SUBJECT = "lixiang";
    /**
     * 根据用户信息生成token
     * @param loginUser
     * @return
     */
    public static Map<String,Object> geneJsonWebToken(LoginUser loginUser){
        if(loginUser == null){
            throw new NullPointerException("loginUser对象为空");
        }
        Date endDate = new Date(System.currentTimeMillis() + EXPIRE);
        String token = Jwts.builder().setSubject(SUBJECT)
                .claim("age",loginUser.getAge())
                .claim("id",loginUser.getId())
                .claim("name",loginUser.getName())
                .claim("phone",loginUser.getPhone())
                .claim("sex",loginUser.getSex())
                .setIssuedAt(new Date())
                .setExpiration(endDate)
                .signWith(SignatureAlgorithm.HS256,SECRET)
                .compact();
        token = TOKEN_PREFIX+token;
        Map<String,Object> map = new HashMap<>();
        map.put("accessToken",token);
        map.put("accessTokenExpires",endDate);
        return map;
    }
    /**
     * 检验token方法
     * @param token
     * @return
     */
    public static Claims checkJWT(String token){
        try{
            return Jwts.parser().setSigningKey(SECRET)
                    .parseClaimsJws(token.replace(TOKEN_PREFIX, ""))
                    .getBody();
        }catch (Exception e){
            log.info("JWT token解密失败");
            return null;
        }
    }
}

（4）测试JWT,编写测试方法

public class Main {
    public static void main(String[] args) {
        LoginUser loginUser = LoginUser.builder()
                .age(18)
                .id(1L)
                .name("李祥")
                .phone("13820934720")
                .sex("男")
                .username("lixiang")
                .build();
        Map<String, Object> objectMap = JWTUtil.geneJsonWebToken(loginUser);
        System.out.println("LoginUser加密：");
        objectMap.forEach((k,v)->{
            System.out.println("---key:"+k+",value:"+v);
        });
        String accessToken = String.valueOf(objectMap.get("accessToken"));
        System.out.println("Token解密：");
        Claims claims = JWTUtil.checkJWT(accessToken);
        System.out.println("---name:"+claims.get("name"));
        System.out.println("---age:"+claims.get("age"));
        System.out.println("---phone:"+claims.get("phone"));
        System.out.println("---username:"+claims.get("username"));
        System.out.println("---sex:"+claims.get("sex"));
    }
}

8.开发测试接口

开发两个接口，我们的目的是一个用于不需要登录就能访问，一个需要登录才能访问
查看商品信息列表，查看个人订单信息两个接口
开发测试的UserController，这块全部用的测试接口，主要是给大家演示效果，现在我们想让商品列表的接口可以随便访问，订单列表的接口只有用户登录之后才能访问。

/**
 * @description 测试Controller
 * @author lixiang
 */
@RestController
@RequestMapping("/user")
public class UserController {
    /**
     * 查询商品列表
     * @return
     */
    @GetMapping("/product_list")
    public Object getProductList(){
        return getResult(200,"查询商品列表");
    }
    /**
     * 查询订单列表
     * @return
     */
    @GetMapping("/order_list")
    public Object getOrderList(){
        return getResult(200,"查询订单列表");
    }
    /**
     * 测试返回结果
     * @param code
     * @param msg
     * @return
     */
    private Object getResult(int code, String msg) {
        Map<String,Object> result = new HashMap<>();
        result.put("code",code);
        result.put("msg",msg);
        return result;
    }
}

测试

两个接口访问正常，但是对于订单接口我们是想增加Token检验，才会给予访问，这块我们就需要写一个拦截器，但是我们现在应该先去开发一下登录的接口。

9.开发登录接口

这块我们采用手机号和密码登录

（1）创建登录请求类

@Data
@NoArgsConstructor
@AllArgsConstructor
public class LoginReq {
    /**
     * 手机号
     */
    private String phone;
    /**
     * 密码
     */
    private String password;
}

（2）创建login方法在UserServie

public interface UserService {
    /**
     * 登录方法
     * @param req
     * @return
     */
    Map<String, Object> login(LoginReq req);
}

（3）login实现类编写

@Service
public class UserServiceImpl implements UserService {
    @Autowired
    private UserMapper userMapper;
    @Override
    public Map<String, Object> login(LoginReq req) {
        UserDO user = userMapper.selectOne(new QueryWrapper<UserDO>().eq("phone", req.getPhone()));
        Map<String,Object> result = new HashMap<>();
        //判断是否已经注册的
        if (user == null) {
            //未注册
            result.put("code",10000);
            result.put("msg","用户未注册");
            return result;
        }
        if (req.getPassword().equals(user.getPassword())) {
            //登录成功，生成token，UUID生成token，存储到redis中并设置过期时间
            LoginUser loginUser = LoginUser.builder().build();
            BeanUtils.copyProperties(user, loginUser);
            return JWTUtil.geneJsonWebToken(loginUser);
        }
        result.put("code",10000);
        result.put("msg","密码错误");
        return result;
    }
}

（4）编写Controller

    @Autowired
    private UserService userService;
    /**
     * 登录
     * @return
     */
    @PostMapping("/login")
    public Object login(@RequestBody LoginReq req){
        return userService.login(req);
    }

（5）测试登录接口

10.开发登录拦截器

登录接口开发完成了，那么我们需要开发一个登录拦截器。

/**
 * 全局登录拦截器
 * @author lixiang
 */
@Slf4j
public class LoginInterceptor implements HandlerInterceptor {
    public static ThreadLocal<LoginUser> threadLocal = new ThreadLocal<>();
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        //从请求头中拿token
        String accessToken = request.getHeader("token");
        //从请求参数中拿token
        if (accessToken == null){
            accessToken = request.getParameter("token");
        }
        if(accessToken!=null && !accessToken.equals("")){
            //不为空，判断是否登录过期
            Claims claims = JWTUtil.checkJWT(accessToken);
            if (claims == null){
                sendJsonMessage(response, "账号已过期");
                return false;
            }
            Long userId = Long.valueOf(claims.get("id").toString());
            String headImg = (String) claims.get("username");
            String name = (String) claims.get("name");
            String phone = (String) claims.get("phone");
            String sex = (String) claims.get("sex");
            Integer age = (Integer) claims.get("age");
            //设置LoginUser对象属性，建造者模式
            LoginUser loginUser = LoginUser.builder()
                    .name(name)
                    .username(headImg)
                    .id(userId)
                    .phone(phone)
                    .sex(sex)
                    .age(age).build();
            //通过threadLocal共享用户登录信息
            threadLocal.set(loginUser);
            return true;
        }
        sendJsonMessage(response, "账号未登录");
        return false;
    }
    /**
     *
     * @param response
     * @param msg
     */
    private void sendJsonMessage(HttpServletResponse response, String msg) {
        Map<String,Object> result = new HashMap<>();
        result.put("code",10000);
        result.put("msg",msg);
        ObjectMapper objectMapper = new ObjectMapper();
        response.setContentType("application/json;charset=utf-8");
        PrintWriter writer = null;
        try {
            writer = response.getWriter();
            writer.print(objectMapper.writeValueAsString(result));
            response.flushBuffer();
        } catch (IOException e) {
            log.warn("响应json数据给前端异常");
        }finally {
            if(writer!=null){
                writer.close();
            }
        }
    }
}

（2）配置接口拦截

/**
 * 登录拦截配置类
 * @author lixiang
 */
@Configuration
@Slf4j
public class InterceptorConfig implements WebMvcConfigurer {
    @Bean
    public LoginInterceptor loginInterceptor() {
        return new LoginInterceptor();
    }
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(loginInterceptor())
                .addPathPatterns("/user/*")
                //排查不拦截的路径
                .excludePathPatterns("/user/login","/user/product_list");
    }
}

配置拦截器使用户登录的接口和商品列表查询的接口不进行token验证，将用户的信息放在ThreadLocal中保证每个线程独立内存空间。

11.启动验证

至此，整个登录整合JWT功能已经开发完成，这块其实还可以根据自己的业务去返回一个RefreshToken，Token过期刷新的token。

【案例实战】分布式应用下登录检验解决方案（JWT）

1.需求背景以及JWT简介

2.创建Maven项目，搭建SpringBoot项目

3.容器化急速部署MySQL

4.数据库表准备

5.SpringBoot整合MySQL+MyBatisPlus

6.MyBatisPlus逆向工程自动生成

7.SpringBoot整合JWT

8.开发测试接口

9.开发登录接口

10.开发登录拦截器

11.启动验证

热门文章

最新文章

相关课程

相关电子书

相关实验场景

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

【案例实战】分布式应用下登录检验解决方案（JWT）

1.需求背景以及JWT简介

2.创建Maven项目，搭建SpringBoot项目

3.容器化急速部署MySQL

4.数据库表准备

5.SpringBoot整合MySQL+MyBatisPlus

6.MyBatisPlus逆向工程自动生成

7.SpringBoot整合JWT

8.开发测试接口

9.开发登录接口

10.开发登录拦截器

11.启动验证

热门文章

最新文章

相关课程

相关电子书

相关实验场景