谷粒随享

第3章用户登录

学习目标：

了解小程序/移动端登录业务需求
认证状态校验
- 自定义注解
- 认证切面类
用户登录
- 微信登录
- 初次登录（初始化账户（余额）记录）
- 非初次登录
- 完成登录（响应登录token）
- 获取用户信息
用户信息修改

1、认证校验注解

1.1 自定义注解

当用户在查询专辑列表的时候，要求用户必须是登录状态。就应该让用户登录，所以在此我们自定义一个注解来表示访问此功能时必须要登录。

注解作用：哪些需要登录才能访问必须要添加，那些需要获取到用户Id控制层方法也必须加这个注解.

在service-util 模块中添加登录注解

package com.atguigu.tingshu.common.login;

import org.springframework.aot.hint.annotation.Reflective;

import java.lang.annotation.*;

/**
 * 认证自定义注解：
 * 属性：要求是否必须登录属性（true：要求必须登录）
 * 元注解：
 *
 * @Target：注解使用位置:指定方法，类（接口），属性，构造器，构造器参数
 * @Retention：注解生命周期 例如设置为SOURCE 编译后注解没了;CLASS 运行是注解没了
 * @Inherited 该注解是否可以被继承
 * @Documented javadoc命令是否生成文档 javadoc -encoding UTF-8 -charset UTF-8 Test.java
 */

@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
public @interface GuiGuLogin {

    //是否要求用户必须登录：默认为必须登录
    boolean required() default true;

}

1.2 切面类

RequestContextHolder类持有上下文的Request容器。

用法：

//  获取请求对象
RequestAttributes requestAttributes = RequestContextHolder.getRequestAttributes();
//  转化为ServletRequestAttributes
ServletRequestAttributes sra = (ServletRequestAttributes) requestAttributes;
//  获取到HttpServletRequest 对象
HttpServletRequest request = sra.getRequest();
//	获取到HttpServletResponse 对象
HttpServletResponse response = sra.getResponse();

request 和 response 如何与当前进行挂钩的？看底层源码

首先分析RequestContextHolder这个类,里面有两个ThreadLocal保存当前线程下的request

public abstract class RequestContextHolder {
    // 得到存储进去的request
    private static final ThreadLocal<RequestAttributes> requestAttributesHolder = new NamedThreadLocal("Request attributes");
    //可被子线程继承的reques
    private static final ThreadLocal<RequestAttributes> inheritableRequestAttributesHolder = new NamedInheritableThreadLocal("Request context");

再看getRequestAttributes() 方法，相当于直接获取ThreadLocal里面的值,这样就保证了每一次获取到的Request是该请求的request.

@Nullable
public static RequestAttributes getRequestAttributes() {
    RequestAttributes attributes = (RequestAttributes)requestAttributesHolder.get();
    if (attributes == null) {
        attributes = (RequestAttributes)inheritableRequestAttributesHolder.get();
    }
    return attributes;
}

request和response等是什么时候设置进去的?

springMVC 核心类DispatcherServlet 继承关系

HttpServletBean 进行初始化工作
FrameworkServlet 初始化 WebApplicationContext,并提供service方法预处理请
DispatcherServlet 具体分发处理.

那么就可以在FrameworkServlet查看到该类重写了service(),doGet(),doPost()...等方法,这些实现里面都有一个预处理方法processRequest(request, response);,所以定位到了我们要找的位置

查看processRequest(request, response);的实现,具体可以分为以下几步:

获取上一个请求的参数
重新建立新的参数
设置到XXContextHolder
父类的service()处理请求
恢复request（恢复原来的LocaleContext和ServiceRequestAttributes到LocaleContextHolder和RequestContextHolder，避免影响Servlet以外的处理，如Filter
发布事件（发布ServletRequestHandlerEvent消息，这个请求是否执行成功都会发布消息）

自定义切面类

package com.atguigu.tingshu.common.login;

import com.atguigu.tingshu.common.constant.RedisConstant;
import com.atguigu.tingshu.common.execption.GuiguException;
import com.atguigu.tingshu.common.result.ResultCodeEnum;
import com.atguigu.tingshu.common.util.AuthContextHolder;
import com.atguigu.tingshu.vo.user.UserInfoVo;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import lombok.SneakyThrows;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.RequestAttributes;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

/**
 * @author: atguigu
 * @create: 2023-11-15 10:21
 */
@Slf4j
@Aspect //声明切面类
@Component //将切面类对象注册到IOC容器
public class GuiGuLoginAspect {

    @Autowired
    private RedisTemplate redisTemplate;

    /**
     * 验证登录状态、获取用户ID通知逻辑
     *
     * @param joinPoint  切点方法对象
     * @param guiGuLogin 自定义登录注解
     * @return
     */
    @SneakyThrows //动态生成try catch(Throwable)
    @Around("execution(* com.atguigu.tingshu.*.api.*.*(..)) && @annotation(guiGuLogin)")
    public Object loginAspect(ProceedingJoinPoint joinPoint, GuiGuLogin guiGuLogin) {
        Object resultObject = new Object();
        log.info("前置通知...");

        //1.获取小程序端（客户端）提交令牌Token
        //1.1 通过请求上下文对象RequestContextHolder获取请求属性对象 - 普通类中获取到请求对象
        RequestAttributes requestAttributes = RequestContextHolder.getRequestAttributes();
        //1.2 将RequestAttributes（接口）转为ServletRequestAttributes（实现类）
        ServletRequestAttributes servletRequestAttributes = (ServletRequestAttributes) requestAttributes;
        //1.3 获取请求对象
        HttpServletRequest request = servletRequestAttributes.getRequest();
        //HttpServletResponse response = servletRequestAttributes.getResponse();

        //1.4 基于请求对象获取请求头：token
        String token = request.getHeader("token");

        //2.查询存放在Redis中用户信息（何时存入：登录成功后）
        //2.1 构建用户登录信息key
        String loginKey = RedisConstant.USER_LOGIN_KEY_PREFIX + token;
        //2.2 查询存入Redis中用户信息
        UserInfoVo UserInfoVo = (UserInfoVo) redisTemplate.opsForValue().get(loginKey);

        //3.判断注解是否要求必须登录，如果要求登录且用户信息为空，抛出异常业务状态：208引导用户登录
        if (guiGuLogin.required() && UserInfoVo == null) {
            throw new GuiguException(ResultCodeEnum.LOGIN_AUTH);
        }

        //4.如果用户信息存在，将用户ID存入ThreadLocal
        if (UserInfoVo != null) {
            AuthContextHolder.setUserId(UserInfoVo.getId());
        }

        //二、执行目标方法
        resultObject = joinPoint.proceed();


        //5.将ThreaLocal中数据手动清理避免OOM出现
        AuthContextHolder.removeUserId();
        log.info("后置通知...");
        return resultObject;
    }
}

在查看专辑列表的时候，添加注解。在点击查看专辑列表的时候，就会提示我们需要进行登录！

1.3 使用认证校验注解

在所有业务微服务中，com.atguigu.tingshu.*.api.XXXXController类中下所有需要登录才可以访问方法上加注解@GuiGuLogin 以下接口测试需要完成登录代码后才进行测试

/**
 *
 * 创作者新增专辑
 *
 * @return
 */
@GuiGuLogin
@Operation(summary = "新增专辑")
@PostMapping("/albumInfo/saveAlbumInfo")
public Result saveAlbumInfo(@RequestBody @Validated AlbumInfoVo albumInfoVo){}




/**
 *
 * 根据专辑ID删除专辑
 *
 * @param id
 * @return
 */
@GuiGuLogin
@Operation(summary = "根据专辑ID删除专辑")
@DeleteMapping("/albumInfo/removeAlbumInfo/{id}")
public Result removeAlbumInfo(@PathVariable("id") Long id);


/**
 *
 * @param trackInfoVo
 * @return
 */
@GuiGuLogin
@Operation(summary = "新增声音")
@PostMapping("/trackInfo/saveTrackInfo")
public Result saveTrackInfo(@RequestBody @Validated TrackInfoVo trackInfoVo)
    
/**
 * 获取当前登录声音分页列表
 *
 * @param page           页码
 * @param limit          页大小
 * @param trackInfoQuery 查询条件
 * @return
 */
@GuiGuLogin
@Operation(summary = "获取当前登录声音分页列表")
@PostMapping("/trackInfo/findUserTrackPage/{page}/{limit}")
public Result<Page<TrackListVo>> getUserTrackByPage(...){}

....

2、用户登录

2.1 微信登录

小程序登录 | 微信开放文档 (qq.com)

说明

小程序微信授权登录（学生测试使用）测试账号申请入口https://mp.weixin.qq.com/wxamp/sandbox?doc=1
调用 wx.login() 获取 临时登录凭证code ，并回传到开发者服务器。
调用 auth.code2Session 接口，换取 用户唯一标识 OpenID 、用户在微信开放平台账号下的唯一标识UnionID（若当前小程序已绑定到微信开放平台账号）和 会话密钥 session_key。

之后开发者服务器可以根据用户标识来生成自定义登录态，用于后续业务逻辑中前后端交互时识别用户身份。

注意事项

会话密钥 session_key 是对用户数据进行加密签名的密钥。为了应用自身的数据安全，开发者服务器不应该把会话密钥下发到小程序，也不应该对外提供这个密钥。
临时登录凭证 code 只能使用一次

这里我们采用微信开发 Java SDK(非官方提供)简化开发。支持微信支付、开放平台、公众号、企业号/企业微信、小程序等的后端开发，官方地址：http://wxjava.fly2you.cn/zh-CN/

在service-user模块中导入依赖

<dependency>
   <groupId>com.github.binarywang</groupId>
   <artifactId>wx-java-miniapp-spring-boot-starter</artifactId>
   <version>4.5.0</version>
</dependency>

在nacos注册中心增加配置信息（已添加）

wx:
 miniapp:
   appid: wxcc651fcbab275e33  # 小程序微信公众平台appId 改成同学申请测试号应用id
   secret: 5f353399a2eae7ff6ceda383e924c5f6  # 小程序微信公众平台api秘钥 改成同学申请测试号秘钥
   msgDataFormat: JSON

在IOC容器中会自动产生对象类型，可以自动注入

WxMaService
WxMaConfig

当时导入小程序，选择测试号，产生用与测试的APPID（微信用不了）

进入微信开发者工具，编辑器->project.config.json文件修改appId: wxcc651fcbab275e33 改为自己申请的应用ID：appid

YAPI接口地址：http://192.168.200.6:3000/project/11/interface/api/41

service-user模块完成微信登录WxLoginApiController

package com.atguigu.tingshu.user.api;

import com.atguigu.tingshu.common.result.Result;
import com.atguigu.tingshu.user.service.UserInfoService;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.tags.Tag;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.Map;

@Tag(name = "微信授权登录接口")
@RestController
@RequestMapping("/api/user/wxLogin")
@Slf4j
public class WxLoginApiController {

    @Autowired
    private UserInfoService userInfoService;


    /**
     * 小程序端携带微信接口访问临时票据获取微信用户唯一标识openId,完成登录
     *
     * @param code
     * @return
     */
    @GetMapping("/wxLogin/{code}")
    @Operation(summary = "小程序端携带微信接口访问临时票据获取微信用户唯一标识openId,完成登录")
    public Result<Map<String, String>> wxLogin(@PathVariable String code) {
        Map<String, String> mapResult = userInfoService.wxLogin(code);
        return Result.ok(mapResult);
    }

}

UserInfoService

package com.atguigu.tingshu.user.service;

import com.atguigu.tingshu.model.user.UserInfo;
import com.baomidou.mybatisplus.extension.service.IService;

import java.util.Map;

public interface UserInfoService extends IService<UserInfo> {

    /**
     * 小程序端携带微信接口访问临时票据获取微信用户唯一标识openId,完成登录
     *
     * @param code
     * @return
     */
    Map<String, String> wxLogin(String code);
}

UserInfoServiceImpl

package com.atguigu.tingshu.user.service.impl;

import cn.binarywang.wx.miniapp.api.WxMaService;
import cn.binarywang.wx.miniapp.bean.WxMaJscode2SessionResult;
import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.util.IdUtil;
import com.atguigu.tingshu.common.constant.RedisConstant;
import com.atguigu.tingshu.model.user.UserInfo;
import com.atguigu.tingshu.user.mapper.UserInfoMapper;
import com.atguigu.tingshu.user.service.UserInfoService;
import com.atguigu.tingshu.vo.user.UserInfoVo;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import lombok.extern.slf4j.Slf4j;
import me.chanjar.weixin.common.error.WxErrorException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.TimeUnit;

@Slf4j
@Service
@SuppressWarnings({"all"})
public class UserInfoServiceImpl extends ServiceImpl<UserInfoMapper, UserInfo> implements UserInfoService {

       @Autowired
    private UserInfoMapper userInfoMapper;

    @Autowired
    private WxMaService wxMaService;

    @Autowired
    private RedisTemplate redisTemplate;


    @Autowired
    private KafkaService kafkaService;

    /**
     * 小程序端携带微信接口访问临时票据获取微信用户唯一标识openId,完成登录
     *
     * @param code
     * @return
     */
    @Override
    public Map<String, String> wxLogin(String code) {
        try {
            //1.调用微信开发SDK提供WxMaService对象调用获取微信唯一标识接口 得到openId
            WxMaJscode2SessionResult sessionInfo = wxMaService.getUserService().getSessionInfo(code);
            if (sessionInfo != null) {
                String wxOpenid = sessionInfo.getOpenid();
                //2.根据获取到OpenID查询用户表是否存在用户记录
                LambdaQueryWrapper<UserInfo> queryWrapper = new LambdaQueryWrapper<>();
                queryWrapper.eq(UserInfo::getWxOpenId, wxOpenid);
                UserInfo userInfo = userInfoMapper.selectOne(queryWrapper);
                if (userInfo == null) {
                    //3.如果用户不存在-说明首次使用微信登录
                    //3.1 新增用户记录
                    userInfo = new UserInfo();
                    userInfo.setNickname("听友" + IdUtil.getSnowflakeNextId());
                    userInfo.setAvatarUrl("https://oss.aliyuncs.com/aliyun_id_photo_bucket/default_handsome.jpg");
                    userInfo.setWxOpenId(wxOpenid);
                    userInfo.setIsVip(0);
                    userInfoMapper.insert(userInfo);
                    //3.2 TODO 基于MQ消息队列异步新增账户（余额）记录
                    kafkaService.sendMessage(KafkaConstant.QUEUE_USER_REGISTER, userInfo.getId().toString());
                }

                //4.封装登录成功后Token
                //4.1 声明用户登录key，生成随机令牌
                String token = IdUtil.fastSimpleUUID();
                String loginKey = RedisConstant.USER_LOGIN_KEY_PREFIX + token;

                //4.2 将用户信息存入Redis UserInfoVO
                UserInfoVo userInfoVo = BeanUtil.copyProperties(userInfo, UserInfoVo.class);
                redisTemplate.opsForValue().set(loginKey, userInfoVo, RedisConstant.USER_LOGIN_KEY_TIMEOUT, TimeUnit.SECONDS);

                //4.3 封装响应结果
                Map<String, String> mapResult = new HashMap<>();
                mapResult.put("token", token);
                return mapResult;
            }
        } catch (Exception e) {
            log.error("[用户服务]微信登录异常：{}", e);
            throw new RuntimeException(e);
        }
        return null;
    }
}

2.2 初始化账户(余额)

在kafka-util模块中定义KafkaService 工具类

package com.atguigu.tingshu.common.service;

import lombok.extern.slf4j.Slf4j;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.kafka.core.KafkaTemplate;
import org.springframework.stereotype.Service;

import java.util.concurrent.CompletableFuture;


@Slf4j
@Service
public class KafkaService {

    private static final Logger logger = LoggerFactory.getLogger(KafkaService.class);

    @Autowired
    private KafkaTemplate kafkaTemplate;


    /**
     * 生产者：发送消息到Kafka话题
     *
     * @param topic 话题名称
     * @param data  消息内容
     */
    public void sendMessage(String topic, String data) {
        kafkaTemplate.send(topic, null, data);
    }

    /**
     * 生产者：发送消息到Kafka话题
     *
     * @param topic 话题名称
     * @param key   消息Key
     * @param data  消息内容
     */
    public void sendMessage(String topic, String key, String data) {
        //1.调用模板对象方法发送消息
        CompletableFuture completableFuture = kafkaTemplate.send(topic, key, data);
        //2.获取发送消息结果
        completableFuture.thenAcceptAsync(result -> {
            logger.info("[发消息工具方法]发送消息成功：{}", result);
        }).exceptionallyAsync(e -> {
            logger.error("[发消息工具方法]发送消息失败：{}", e);
            return null;
        });
    }
}

在service-acount 微服务中监听消息：

package com.atguigu.tingshu.account.receiver;

import com.atguigu.tingshu.account.service.UserAccountService;
import com.atguigu.tingshu.common.constant.KafkaConstant;
import com.atguigu.tingshu.model.account.UserAccount;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.apache.kafka.clients.consumer.ConsumerRecord;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.kafka.annotation.KafkaListener;
import org.springframework.stereotype.Component;

/**
 * @author: atguigu
 * @create: 2023-11-15 15:11
 */
@Slf4j
@Component
public class AccountReceiver {

    @Autowired
    private UserAccountService userAccountService;


    /**
     * 监听器：监听指定话题中数据，拉取到消息后执行业务逻辑
     * 所有监听器考虑：1.是否需要做幂等性处理(消息被执行一次跟多次达到结果一样)、 2.是否需要事务管理
     *
     * @param record 监听到话题中消息封装key跟value
     */
    @KafkaListener(topics = KafkaConstant.QUEUE_USER_REGISTER)
    public void initUserAccount(ConsumerRecord<String, String> record) {
        String value = record.value();
        //org.apache.commons.lang3
        if (StringUtils.isNotBlank(value)) {
            log.info("[账户服务]监听到用户注册消息：{}", value);
            userAccountService.initUserAccount(Long.valueOf(value));
        }

    }


}

**UserAccountService接口 **初始化账户信息：

package com.atguigu.tingshu.account.service;

import com.atguigu.tingshu.model.account.UserAccount;
import com.baomidou.mybatisplus.extension.service.IService;

public interface UserAccountService extends IService<UserAccount> {

    /**
     * 新增账户记录
     * @param userId
     */
    void initUserAccount(Long userId);
}

UserAccountServiceImpl实现类：

package com.atguigu.tingshu.account.service.impl;

import com.atguigu.tingshu.account.mapper.UserAccountMapper;
import com.atguigu.tingshu.account.service.UserAccountService;
import com.atguigu.tingshu.model.account.UserAccount;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.math.BigDecimal;

@Slf4j
@Service
@SuppressWarnings({"all"})
public class UserAccountServiceImpl extends ServiceImpl<UserAccountMapper, UserAccount> implements UserAccountService {

    @Autowired
    private UserAccountMapper userAccountMapper;


    /**
     * 新增账户记录
     *
     * @param userId
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public void initUserAccount(Long userId) {
        //1.根据用户ID查询账户记录（数据表中user_id有唯一索引）
        LambdaQueryWrapper<UserAccount> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(UserAccount::getUserId, userId);
        Long count = userAccountMapper.selectCount(queryWrapper);
        if (count > 0) {
            //2.存在则直接返回，不处理
            return;
        }
        //3.不存在则构建账户对象新增
        UserAccount userAccount = new UserAccount();
        //用户ID
        userAccount.setUserId(userId);
        //总金额
        userAccount.setTotalAmount(new BigDecimal("1000"));
        //锁定、冻结金额
        userAccount.setLockAmount(new BigDecimal("0"));
        //可用金额
        userAccount.setAvailableAmount(new BigDecimal("1000"));
        //总收入=充值，收益
        userAccount.setTotalIncomeAmount(new BigDecimal("0"));
        //总之处
        userAccount.setTotalPayAmount(new BigDecimal("0"));
        userAccountMapper.insert(userAccount);
    }

}

TIPS：以前在AuthContextHolder硬编码的用户ID可以修改为动态获取

3、获取登录用户信息

获取用户信息，将查询到的信息放入这个实体类UserInfoVo中

YAPI接口地址：http://192.168.200.6:3000/project/11/interface/api/43

WxLoginApiController 控制器

/**
 * 获取当前登录用户信息
 *
 * @return
 */
@GuiGuLogin
@Operation(summary = "获取当前登录用户信息")
@GetMapping("/getUserInfo")
public Result<UserInfoVo> getUserInfo() {
    UserInfoVo userInfoVo = userInfoService.getUserInfo();
    return Result.ok(userInfoVo);
}

UserInfoService接口：

/**
 * 获取当前登录用户信息
 * @return
 */
UserInfoVo getUserInfo();

UserInfoServiceImpl实现类：

package com.atguigu.tingshu.user.service.impl;

import com.atguigu.tingshu.model.user.UserInfo;
import com.atguigu.tingshu.user.mapper.UserInfoMapper;
import com.atguigu.tingshu.user.service.UserInfoService;
import com.atguigu.tingshu.vo.user.UserInfoVo;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Slf4j
@Service
@SuppressWarnings({"unchecked", "rawtypes"})
public class UserInfoServiceImpl extends ServiceImpl<UserInfoMapper, UserInfo> implements UserInfoService {

	@Autowired
	private UserInfoMapper userInfoMapper;

      /**
     * 获取当前登录用户信息
     *
     * @return
     */
    @Override
    public UserInfoVo getUserInfo() {
        //1.获取登录用户ID
        Long userId = AuthContextHolder.getUserId();
        //2.根据用户ID查询用户记录UserInfo
        UserInfo userInfo = userInfoMapper.selectById(userId);
        //3.转为UserInfoVo返回
        return BeanUtil.copyProperties(userInfo, UserInfoVo.class);
    }
}

4、更新用户信息方法

需求：登录成功之后，可以修改用户基本信息。

YAPI接口地址：http://192.168.200.6:3000/project/11/interface/api/45

WxLoginApiController控制器

/**
 * 修改登录用户信息
 * @param userInfoVo
 * @return
 */
@GuiGuLogin
@Operation(summary = "修改登录用户信息")
@PostMapping("/updateUser")
public Result updateUser(@RequestBody UserInfoVo userInfoVo){
    userInfoService.updateUser(userInfoVo);
    return Result.ok();
}

UserInfoService接口

/**
 * 修改登录用户信息
 * @param userInfoVo
 * @return
 */
void updateUser(UserInfoVo userInfoVo);

UserInfoServiceImpl实现类

/**
 * 更新用户个人基本信息
 *
 * @param userInfoVo
 * @param userId
 */
@Override
public void updateUser(UserInfoVo userInfoVo) {
    //1.获取登录用户ID
    Long userId = AuthContextHolder.getUserId();
    //2.业务限制只能修改头像跟昵称
    UserInfo userInfo = new UserInfo();
    userInfo.setId(userId);
    userInfo.setNickname(userInfoVo.getNickname());
    userInfo.setAvatarUrl(userInfoVo.getAvatarUrl());
    userInfoMapper.updateById(userInfo);
}

第3章 用户登录.md 26 KB Permalink History Raw

第3章 用户登录