外卖项目day09---微信登录/HttpClient

这里是初学的文章，大家可以去看看 HttpClient初学-CSDN博客

下面是微信登录的流程

微信登录产品原型

UserController代码

@RestController
@RequestMapping("/user/user")
@Api(tags = "C端用户相关接口")
@Slf4j
public class UserController {

    @Autowired
    private UserService userService;
    @Autowired
    private JwtProperties jwtProperties;


    /**
     * 微信登录
     * @param userLoginDTO
     * @return
     */
    @PostMapping("/login")
    @ApiOperation("微信登录")
    public Result<UserLoginVO> login(@RequestBody UserLoginDTO userLoginDTO){
        log.info("微信用户登录: {}",userLoginDTO.getCode());

        //微信登录
        User user = userService.wxLogin(userLoginDTO);

        //为微信用户生成jwt令牌
        Map<String, Object> claims = new HashMap<>();
        claims.put(JwtClaimsConstant.USER_ID,user.getId());
        String token = JwtUtil.createJWT(jwtProperties.getUserSecretKey(), jwtProperties.getUserTtl(), claims);


        UserLoginVO userLoginVO = UserLoginVO.builder()
                .id(user.getId())
                .openid(user.getOpenid())
                .token(token)
                .build();

        return Result.success(userLoginVO);

    }
}

主要定义了一个用于处理微信登录请求的接口。这个接口通过HTTP POST方法接收用户发送的登录信息，并返回登录结果。下面是对这个类及其方法的详细解释：

类注解

@RestController：这是一个Spring MVC的注解，用于表明该类是一个控制器（Controller），并且它的返回值会自动地转换为JSON或XML等格式的数据，具体取决于HTTP请求头中的Accept字段。
@RequestMapping("/user/user")：这是一个请求映射的注解，用于将HTTP请求映射到特定的处理器上。在这个例子中，它指定了所有在这个类中定义的请求映射都会以/user/user作为前缀。但是，请注意，在实际应用中，通常不会在类级别和方法级别都使用@RequestMapping来指定完整的路径，因为这可能会导致路径的冗余。在这个例子中，方法级别的@PostMapping("/login")已经足够，除非您确实需要在类级别上指定一个共享的前缀。
@Api(tags = "C端用户相关接口")：这不是Spring MVC的标准注解，而是Swagger或Springfox等API文档生成工具使用的注解。它用于为生成的API文档添加标签或分类，以便更好地组织和管理API接口。
@Slf4j：这是一个Lombok库的注解，用于自动生成一个log字段，该字段是org.slf4j.Logger类型的实例，并且可以通过静态方法log.info()、log.error()等记录日志信息。

方法

login(@RequestBody UserLoginDTO userLoginDTO)：这是一个处理HTTP POST请求的方法，它使用了@PostMapping("/login")注解来指定请求的URL路径和HTTP方法。@RequestBody注解表示请求体中的JSON数据会被自动反序列化为UserLoginDTO类型的对象。

方法内部，首先通过日志记录了接收到的登录码（假设是微信登录码）。然后，调用了userService.wxLogin(userLoginDTO)方法来处理登录逻辑，这个方法会验证登录码的有效性，并返回用户的信息（如果验证成功）。

接下来，方法创建了一个JWT令牌，将用户ID作为claims（声明）包含在令牌中，并通过JwtUtil.createJWT方法生成了令牌。

最后，方法将用户信息和JWT令牌封装在UserLoginVO对象中，并通过Result.success(userLoginVO)方法返回给前端。这里假设Result是一个泛型类，用于封装API的响应结果，其中包含了状态码、消息和数据等字段。

UserService接口代码

public interface UserService {

    /**
     * 微信登录
     * @param userLoginDTO
     * @return
     */
    User wxLogin(UserLoginDTO userLoginDTO);
}

UserServiceImpl实现类代码

@Service
@Slf4j
public class UserServiceImpl implements UserService  {

    //微信服务接口地址
    public static final String WX_LOGIN = "https://api.weixin.qq.com/sns/jscode2session";

    @Autowired
    private WeChatProperties weChatProperties;
    @Autowired
    private UserMapper userMapper;


    /**
     * 用户登录
     * @param userLoginDTO
     * @return
     */
    public User wxLogin(UserLoginDTO userLoginDTO) {

        String openid = getOpenid(userLoginDTO.getCode());

        //判断openid是否为空，如果为空表示登录失败，抛出业务异常
        if(openid == null){
            throw new LoginFailedException(MessageConstant.LOGIN_FAILED);
        }

        //判断当前用户是否为新用户
        User user = userMapper.getByOpenid(openid);

        //如果是新用户，自动完成注册
        if(user == null){
            user = User.builder()
                    .openid(openid)
                    .createTime(LocalDateTime.now())
                    .build();
            userMapper.insert(user);
        }

        //返回这个用户对象
        return user;
    }

    /**
     * 调用微信接口服务
     * @param code
     * @return
     */
    private String getOpenid(String code){

        //调用微信接口服务，获取当前用户的openid
        Map<String, String> map = new HashMap<>();
        map.put("appid",weChatProperties.getAppid());
        map.put("secret",weChatProperties.getSecret());
        map.put("js_code",code);
        map.put("grant_type","authorization_code");
        String json = HttpClientUtil.doGet(WX_LOGIN, map);

        JSONObject jsonObject = JSON.parseObject(json);
        String openid = jsonObject.getString("openid");
        return openid;
    }
}

UserMapper接口代码

@Mapper
public interface UserMapper {

    /**
     * 根据openid查询用户
     * @param openid
     * @return
     */
    @Select("select * from user where openid = #{openid}")
    User getByOpenid(String openid);

    /**
     * 插入数据
     * @param user
     */
    void insert(User user);
}

UserMapper.xml代码

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
<mapper namespace="com.sky.mapper.UserMapper">


    <insert id="insert" useGeneratedKeys="true" keyProperty="id">
        insert into user (openid,name,phone,sex,id_number,avatar,create_time)
        values (#{openid},#{name},#{phone},#{sex},#{idNumber},#{avatar},#{createTime})

    </insert>


</mapper>

新建JwtTokenUserInterceptor 拦截器

package com.sky.interceptor;

import com.sky.constant.JwtClaimsConstant;
import com.sky.context.BaseContext;
import com.sky.properties.JwtProperties;
import com.sky.utils.JwtUtil;
import io.jsonwebtoken.Claims;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.web.method.HandlerMethod;
import org.springframework.web.servlet.HandlerInterceptor;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

/**
 * jwt令牌校验的拦截器
 */
@Component
@Slf4j
public class JwtTokenUserInterceptor implements HandlerInterceptor {

    @Autowired
    private JwtProperties jwtProperties;

    /**
     * 校验jwt
     *
     * @param request
     * @param response
     * @param handler
     * @return
     * @throws Exception
     */
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        //判断当前拦截到的是Controller的方法还是其他资源
        if (!(handler instanceof HandlerMethod)) {
            //当前拦截到的不是动态方法，直接放行
            return true;
        }

        //1、从请求头中获取令牌
        String token = request.getHeader(jwtProperties.getUserTokenName());

        //2、校验令牌
        try {
            log.info("jwt校验:{}", token);
            Claims claims = JwtUtil.parseJWT(jwtProperties.getUserSecretKey(), token);
            Long userId = Long.valueOf(claims.get(JwtClaimsConstant.USER_ID).toString());
            BaseContext.setCurrentId(userId);
            log.info("当前用户id：", userId);
            //3、通过，放行
            return true;
        } catch (Exception ex) {
            //4、不通过，响应401状态码
            response.setStatus(401);
            return false;
        }
    }
}

这个JwtTokenUserInterceptor类是一个实现了HandlerInterceptor接口的Spring组件，用于在Spring MVC的Web应用中作为拦截器，以校验HTTP请求中的JWT（JSON Web Token）令牌。下面是对该类及其方法的详细解释：

类注解

@Component：这个注解表明JwtTokenUserInterceptor是一个Spring管理的组件，Spring容器会自动扫描并实例化这个类。
@Slf4j：这是Lombok库提供的一个注解，用于自动生成log字段，该字段是org.slf4j.Logger类型的实例，允许你在类中使用log.info()、log.error()等方法记录日志。

字段

@Autowired private JwtProperties jwtProperties;：通过@Autowired注解，Spring会自动将JwtProperties类型的bean注入到这个字段中。JwtProperties可能是一个配置类，包含了JWT相关的配置信息，如密钥、令牌名等。

方法

public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception：这是HandlerInterceptor接口必须实现的方法之一，用于在请求处理之前进行调用。
- 参数：
  - HttpServletRequest request：当前HTTP请求对象。
  - HttpServletResponse response：当前HTTP响应对象。
  - Object handler：当前请求的处理器（如Controller中的方法），这里通过判断它是否是HandlerMethod的实例来确定是否拦截动态方法。
- 逻辑：
  1. 判断拦截器是否应该拦截：首先检查handler是否是HandlerMethod的实例，即是否是一个Controller中的方法。如果不是，则直接放行（返回true）。
  2. 从请求头中获取JWT令牌：使用jwtProperties中配置的令牌名（通过getUserTokenName()方法获取）作为请求头的key，从HttpServletRequest中获取JWT令牌。
  3. 校验JWT令牌：
    - 调用JwtUtil.parseJWT方法，使用jwtProperties中配置的密钥（通过getUserSecretKey()方法获取）和从请求头中获取的令牌进行解析。
    - 解析成功后，从JWT的claims中获取用户ID（这里假设用户ID的key是JwtClaimsConstant.USER_ID），并将其转换为Long类型。
    - 使用BaseContext.setCurrentId(userId)方法将用户ID设置到某个全局上下文中（可能是线程局部变量），以便在后续的处理过程中使用。
    - 记录日志，显示JWT令牌和用户ID。
    - 最后，返回true以放行请求。
  4. JWT令牌校验失败：如果在解析JWT令牌或获取用户ID时发生异常，则捕获该异常，将HTTP响应状态码设置为401（未授权），并返回false以阻止请求继续执行。

总结

JwtTokenUserInterceptor是一个用于校验HTTP请求中JWT令牌的拦截器。它会在请求处理之前被调用，从请求头中获取JWT令牌，并使用配置的密钥进行解析。如果令牌有效且包含有效的用户ID，则将该用户ID设置到全局上下文中，并放行请求；如果令牌无效或无法解析，则返回401状态码并阻止请求继续执行。这种机制有助于保护Web应用中的受保护资源，确保只有持有有效JWT令牌的用户才能访问这些资源。