springboot+jwt令牌简单登录案例

news2024/9/20 9:08:07

1. 什么是JWT？JSON Web Token

JSON Web Token (JWT)是⼀个开放标准(RFC 7519)，它定义了⼀种紧凑的、⾃包含的⽅式，⽤于作为JSON对象在各⽅之间安全地传输信息。该信息可以被验证和信任，因为它是数字签名的。

1.1 什么时候应该⽤JWT？

Authorization (授权) : 这是使⽤JWT的最常⻅场景。⼀旦⽤⼾登录，后续每个请求都将包含 JWT，允许⽤⼾访问该令牌允许的路由、服务和资源。单点登录是现在⼴泛使⽤的JWT的⼀个特性，因为它的开销很⼩，并且可以轻松地跨域使⽤。

• Information Exchange (信息交换) : 对于安全的在各⽅之间传输信息⽽⾔，JSON Web Tokens⽆疑是⼀种很好的⽅式。因为JWT可以被签名，例如，⽤公钥/私钥对，你可以确定发送⼈就是它们所说的那个⼈。另外，由于签名是使⽤头和有效负载计算的，您还可以验证内容没有被篡改。

1.2 认证流程

1.3 JWT优势在哪?

1. 简洁(Compact): 可以通过URL，POST参数或者在HTTP header发送，数据量⼩，传输速度快 2. ⾃包含(Self-contained):负载中包含了所有⽤⼾所需要的信息，避免了多次查询数据库因为Token是以JSON加密的形式保存在客⼾端的，所以JWT是跨语⾔的，原则上任何web形式都⽀持。 3.因为Token是以JSON加密的形式保存在客⼾端的，所以JWT是跨语⾔的，原则上任何web形式都⽀持。

4. 不需要在服务端保存会话信息，特别适⽤于分布式微服务。

2.具体实现

2.1 创建实体类

@Data
@NoArgsConstructor
@AllArgsConstructor
@Accessors(chain = true)
public class User {
    private Integer id;
    private String name;
    private String password;
}

2.2 创建jwt工具类


public class JWTUtil {

    /**
     * 密钥要
     */
    private static String SECRET = "axingixngixng%!save";

    /**
     * 传入payload信息获取token
     * @param map payload
     * @return token
     */
    public static String getToken(Map<String, String> map) {
        JWTCreator.Builder builder = JWT.create();

        //payload
        map.forEach(builder::withClaim);

        Calendar instance = Calendar.getInstance();
        instance.add(Calendar.DATE, 3); //默认3天过期

        builder.withExpiresAt(instance.getTime());//指定令牌的过期时间
        return builder.sign(Algorithm.HMAC256(SECRET));
    }

    /**
     * 验证token
     */
    public static DecodedJWT verify(String token) {
        //如果有任何验证异常，此处都会抛出异常
        return JWT.require(Algorithm.HMAC256(SECRET)).build().verify(token);
    }

    /**
     * 获取token中的payload
     */
    public static Map<String, Claim> getPayloadFromToken(String token) {
        return JWT.require(Algorithm.HMAC256(SECRET)).build().verify(token).getClaims();
    }
}

2.3 写个mybatis的mapper.xml和dao

mapper.xml

    <select id="login" parameterType="User" resultType="User">
        select * from user2 where name = #{name} and password = #{password}
    </select>

@Mapper
public interface UserDao {
    User login(User user); // 直接根据用户名密码进行登录
}

2.4 实现类

service

public interface UserService {
    User login(User user); // 登录接口
}

impl

@Service
public class UserServiceImpl implements UserService {

    @Resource
    private UserDao userDao;

    @Override
    @Transactional(propagation = Propagation.SUPPORTS)
    public User login(User user) {
        User login = userDao.login(user); // 根据用户名和密码
        if (login != null) {
            return login;
        }
        throw new RuntimeException("登录失败...");
    }
}

2.5 控制层


@RestController
@Slf4j
public class UserController {

    @Resource
    private UserService userService;

    @GetMapping("/user/login")
    public Map<String, Object> login(User user){
        log.info(user.getName());
        log.info(user.getPassword());
        Map<String, Object> map = new HashMap<>();
        try{
            User login = userService.login(user);
            Map<String, String> payload = new HashMap<>();
            payload.put("id", String.valueOf(login.getId()));
            payload.put("name", login.getName());
            payload.put("password", login.getPassword());

            // 生成token
            String token = JWTUtil.getToken(payload);

            map.put("status", true);
            map.put("msg", "登录成功");
            map.put("token", token); // 响应token，存储在客户端
        }catch (Exception e) {
            log.info("登录失败...");
            map.put("status", false);
            map.put("msg", "登录失败");
        }
        return map;
    }

    @PostMapping("/user/test")
    public Map<String, Object> test(HttpServletRequest request) {
        String token = request.getHeader("token");
        DecodedJWT verify = JWTUtil.verify(token);
        String id = verify.getClaim("id").asString(); // 我前面存的时候转字符串了
        String name = verify.getClaim("name").asString();
        log.info("用户id：{}", id);
        log.info("用户名: {}", name);

        //TODO:业务逻辑
        Map<String, Object> map = new HashMap<>();
        map.put("status", true);
        map.put("msg", "请求成功");
        return map;
    }

}

2.6 拦截器

@Slf4j
public class JWTInterceptor implements HandlerInterceptor {

    @Override
    public boolean preHandle(HttpServletRequest request,
                             HttpServletResponse response,
                             Object handler) throws Exception {

        //获取请求头中的令牌
        String token = request.getHeader("token");
        log.info("当前token为：{}", token);

        Map<String, Object> map = new HashMap<>();
        try {
            JWTUtil.verify(token);
            return true;
        } catch (SignatureVerificationException e) {
            e.printStackTrace();
            map.put("msg", "签名不一致");
        } catch (TokenExpiredException e) {
            e.printStackTrace();
            map.put("msg", "令牌过期");
        } catch (AlgorithmMismatchException e) {
            e.printStackTrace();
            map.put("msg", "算法不匹配");
        } catch (InvalidClaimException e) {
            e.printStackTrace();
            map.put("msg", "失效的payload");
        } catch (Exception e) {
            e.printStackTrace();
            map.put("msg", "token无效");
        }

        map.put("status", false);

        //响应到前台: 将map转为json
        String json = new ObjectMapper().writeValueAsString(map);
        response.setContentType("application/json;charset=UTF-8");
        response.getWriter().println(json);
        return false;
    }
}