用户信息、账号设置。换做是你会怎么做代码实现？

古城微笑少年丶 2023-09-27 16:06 127阅读 0赞

在网站的应用场景下，对于用户的信息展示与账号设置的都是一个绕不过的问题。解决这个问题，最重要的是，怎么拦截未登录用户进入这个功能内？这就意味着必须在每次动态请求时，校验登录状态以及让请求持有用户（在服务器端可查询到对应用户）。当然，我们必须考虑多线程并发的情况，简单地将用户信息放在一个公共的类或者一个容器内，可能会导致数据冲突。现在流行的做法就是利用拦截器去保证动态请求的合法性，而不是在重复造轮子式一次次检查，并且利用 ThreadLocal 进行数据线程隔离保护。本文就将介绍在拦截器的作用下，用户的信息展示与账户设置该如何正确地处理。当然，接下来，也会有更多更有技术力的文章等候着你，欢迎大家关注本人的博客。

#### 文章目录 ####

*   *  实现思路
     *   *  拦截动态请求思路：
         *  登录信息展示思路：
         *  账户设置之修改用户头像思路：
         *  账户设置之修改用户密码思路:
     *  代码实现
     *   *  拦截动态请求配置类 WebConfig 设置
         *  用户信息工具类 hostHolder
         *  查询 cookie 中信息工具类 CookieUtil
         *  请求持有用户拦截器 LoginTicketInterceptor
         *  自定义注解配置 @LoginRequired
         *  检查登录状态拦截器 LoginRequiredInterceptor
         *  修改用户头像核心类 uploadHeader
         *  修改密码 updatePassword
     *  相关Bug
     *   *  java.io.FileNotFoundException: xxxxx (系统找不到指定的路径。)

### 实现思路 ###

关于注册部分的相关知识可看，博主的另一篇文章：[一文教你学会实现以邮件激活的注册账户代码][Link 1]，而关于登录部分的相关知识可看博主这一篇文章：[基于验证码检验的登录就该这么实现][Link 2]，欢迎关注博主本人专栏：[后端开发][Link 3]

#### 拦截动态请求思路： ####

1.  利用 ThreadLocal 实现保存用户信息工具类 hostHolder
2.  利用实现 HandlerInterceptor 来进行拦截用户动态请求
    
     *  请求开始前，查询并检查登录凭证是否有效，有效则返回根据凭证字符查询登录凭证，并利用其中的 userId 查询用户，再调用 hostHolder 存储用户信息，到该线程里。
     *  请求模板引擎返回前，将线程保存的需要进行展示的用户信息存入模板中
     *  请求结束时，清理线程存储的用户信息，以免占用太多内存空间
3.  设置拦截目标路径
    
     *  第一种方法：通过实现 WebMvcConfigurer 来直接完成拦截器配置目标路径。
     *  第二种方法：通过自定义注解，并放置在需要拦截的方法之上，配合 WebMvcConfigurer 实现拦截指定方法
4.  检查登录状态：
    
     *  在实现了 WebMvcConfigurer 的配置类中配置注解拦截器拦截所有请求。
     *  通过自定义注解 @LoginRequired 实现拦截方法，并检查登录状态
     *  利用拦截器判断请求的方法是否存在 @LoginRequired 注解，存在的话，利用 hostHolder 检查登录状态
     *  如果为未登录状态，并且请求了登录后才能使用的方法，必须将请求重定向至登录页面
     *  如果为已登录状态，则不管请求方法。

当然，可能会有这样的疑惑，为什么要使用第一种方法实现请求持有用户信息，为什么要额外使用第二种方法实现检查登录状态？因为请求持有用户信息是需要绝大多数请求都要实现的，毕竟前端头部的用户信息展示都在每个页面中存在，并且，未登录状态的用户也可以访问首页信息，如果也进行拦截，会较为麻烦，需要在 config 方法进行配置，解耦较为困难。而检查登录状态，只需要拦截特定方法即可。

如果存在多个拦截器，并且都是拦截所有请求的开始之前，那它们的拦截顺序又是怎么样的呢？拦截顺序按的是实现了 WebMvcConfigurer 的配置类 WebConfig 的注册顺序决定的。

#### 登录信息展示思路： ####

在拦截器拦截请求方式完成后，已经让需要展示的登录信息存入模板引擎中，直接在模板引擎中调用即可。

#### 账户设置之修改用户头像思路： ####

1.  利用 MultipartFile 来获取上传的文件，如果是多个文件，即为数组，单个文件即为个体。
2.  先判断上传的用户头像是否为空，为空返回错误信息，否则，继续
3.  利用 MultipartFile 的 getOriginalFilename() 实现获取文件原始名称
4.  通过判断文件名称最后一个 “.” 的位置，截取字符串，获取文件后缀名
5.  如果后缀名为空，返回错误信息，否则，继续
6.  为了防止用户上传文件名与已有用户上传的文件名重复，故采取数字加字母结合的一段随机字符串并加上后缀名组成文件名
7.  在 application.yml 配置上传路径，并注入到修改方法所属的类中
8.  利用 java.io.File 对象存储文件，并配合 MultipartFile.transferTo()方法实现上传文件到对应目录。注意捕获异常，记录日志。
9.  更新数据库中的用户头像路径为 web 路径：域名/user/header/\*\*\*.suffix
10. 实现一个获取头像方法，实现读取服务器指定路径（物理路径）下的用户头像文件，并将文件输出到 域名/user/header/\*\*\*.suffix 中。

#### 账户设置之修改用户密码思路: ####

1.  判断新密码是否为空，两次输入的新密码是否一致，新密码长度是否符合要求等等基本格式检查
2.  比较旧密码是否与数据库中的密码一致，注意采用了加盐 md5 加密
3.  如果旧密码校验成功，就可以生成新的盐值，更新用户数据库，并与新密码组成新密码字符，再经过 md5 加密，更新用户数据库即可。

![求关注点赞][263395688c5684b07553ee5e6018eff9.png]  
项目代码已上传：[项目代码][Link 4]

### 代码实现 ###

#### 拦截动态请求配置类 WebConfig 设置 ####

*  loginTicketInterceptor：请求持有用户拦截器
 *  loginRequiredInterceptor：检查登录状态拦截器
 *  excludePathPatterns：拦截器不拦截的静态请求配置

@Configuration
    public class WebConfig implements WebMvcConfigurer {
        
        @Autowired
        private LoginTicketInterceptor loginTicketInterceptor;
    
        @Autowired
        private LoginRequiredInterceptor loginRequiredInterceptor;
    
        @Override
        public void addInterceptors(InterceptorRegistry registry) {
        
            registry.addInterceptor(loginTicketInterceptor)
            .excludePathPatterns("/**/*.css", "/**/*.js", "/**/*.png", "/**/*.jpg","/**/*.jpeg","/**/*.webp");
    
            registry.addInterceptor(loginRequiredInterceptor)
                    .excludePathPatterns("/**/*.css", "/**/*.js", "/**/*.png", "/**/*.jpg","/**/*.jpeg","/**/*.webp");
        }
    }

#### 用户信息工具类 hostHolder ####

*  ThreadLocal 底层方法：都是获取线程，并统一在 ThreadLocalMap 统一存储对应线程的 map 内容，不同线程拥有不同的 ThreadLocalMap 空间。
    
    set 方法：
    
        public void set(T value) {
              
            Thread t = Thread.currentThread();
            ThreadLocalMap map = getMap(t);
            if (map != null) {
              
                map.set(this, value);
            } else {
              
                createMap(t, value);
            }
        }
    
    get 方法：
    
        public T get() {
              
            Thread t = Thread.currentThread();
            ThreadLocalMap map = getMap(t);
            if (map != null) {
              
                ThreadLocalMap.Entry e = map.getEntry(this);
                if (e != null) {
              
                    @SuppressWarnings("unchecked")
                    T result = (T)e.value;
                    return result;
                }
            }
            return setInitialValue();
        }
    
    remove方法：
    
        public void remove() {
              
            ThreadLocalMap m = getMap(Thread.currentThread());
            if (m != null) {
              
                m.remove(this);
            }
        }
 *  实现方案就是在 hostHolder 封装多个关于 user 的方法，底层实现是利用 ThreadLocal 实现线程隔离
 *  set()：存入用户，get()：获取用户，remove()：移除用户

@Component
    public class HostHolder {
        
    
        private ThreadLocal<User> users = new ThreadLocal<>();
    
        public void setUser(User user){
        
            users.set(user);
        }
    
        public User getUser(){
        
            return users.get();
        }
    
        public void clear(){
        
            users.remove();
        }
    
    }

#### 查询 cookie 中信息工具类 CookieUtil ####

*  request.getCookies()：获取所有 cookie 内容
 *  遍历所有 cookie 内容，找到对应信息并返回 cookie.getValue() 对应的值

// 查询 cookie 中指定的信息
    public class CookieUtil {
        
        public static String getValue(HttpServletRequest request, String cookieName){
        
            if (request == null || cookieName == null){
        
                throw new IllegalArgumentException("参数为空！");
            }
    
    
            Cookie[] cookies = request.getCookies();
    
            if (cookies != null){
        
                for (Cookie cookie : cookies){
        
                    if (cookie.getName().equals(cookieName)){
        
                        return cookie.getValue();
                    }
                }
            }
            return null;
        }
    }

#### 请求持有用户拦截器 LoginTicketInterceptor ####

*  preHandle 拦截器返回的是布尔值，为 true 表示请求可以继续，为 false 表示请求不可继续
 *  调用 CookieUtil 从 cookie 中获取登录凭证字符，通过登录凭证字符查询数据库对应登录凭证对象，再根据对象存有的 userId 获取登录用户对象
 *  hostHolder.setUser(user)：存入线程空间中，位于服务器

// 让请求持有用户
    @Component
    public class LoginTicketInterceptor implements HandlerInterceptor {
        
    
        @Resource
        @Qualifier("userServiceImpl")
        private UserService userServiceImpl;
    
        @Autowired
        private HostHolder hostHolder;
    
        // 拦截需要登录却未登录的接口
        @Override
        public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        
            // 查询凭证
            String loginTicket = CookieUtil.getValue(request, "loginTicket");
    
            if (loginTicket != null){
        
                LoginTicket userTicket = userServiceImpl.getLoginTicket(loginTicket);
                // 查询凭证是否有效
                if (userTicket != null && userTicket.getStatus() ==1 && userTicket.getExpired().after(new Date())){
        
                    // 根据凭证查询用户
                    User user = userServiceImpl.findUserById(userTicket.getUserId());
                    // 多线程情况下，不能使用简单的公共方法或者容器可能会发生冲突，必须实现线程隔离
                    // 在本次请求中持有用户
                    hostHolder.setUser(user);
                }
            }
            return true;
        }
    
        // 往模板里存入用户
        @Override
        public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        
            User user = hostHolder.getUser();
            if (user != null && modelAndView != null){
        
                modelAndView.addObject("loginUser", user);
            }
        }
    
        // 请求结束，清理用户
        @Override
        public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        
            hostHolder.clear();
        }
    }

#### 自定义注解配置 @LoginRequired ####

*  @Target(ElementType.METHOD)：指定注解放置位置为 Method
 *  @Retention(RetentionPolicy.RUNTIME)：指定注解生效时间，生命周期

@Target(ElementType.METHOD)
    @Retention(RetentionPolicy.RUNTIME)
    public @interface LoginRequired {
        
        // 检查登录状态注解
    }

#### 检查登录状态拦截器 LoginRequiredInterceptor ####

*  handlerMethod.getMethod()：获取请求方法
 *  method.getAnnotation(LoginRequired.class)：检查请求方法上是否存在 @LoginRequired 注解
 *  loginRequired != null && hostHolder.getUser() == null：存在注解说明需要进行检查，检查登录状态为未登录，需要进行处理
 *  response.sendRedirect(request.getContextPath() + “/login”)：重定向到登录方法

// 检查登录状态请求
    @Component
    public class LoginRequiredInterceptor implements HandlerInterceptor {
        
    
        @Autowired
        private HostHolder hostHolder;
    
        @Override
        public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        
            if (handler instanceof HandlerMethod){
        
                HandlerMethod handlerMethod = (HandlerMethod) handler;
                // 获取请求方法
                Method method = handlerMethod.getMethod();
                // 检查请求方法上是否存在 @LoginRequired 注解
                LoginRequired loginRequired = method.getAnnotation(LoginRequired.class);
                if (loginRequired != null && hostHolder.getUser() == null){
        
                    // 存在注解说明需要进行检查，检查登录状态为未登录，故重定向到登录请求。
                    response.sendRedirect(request.getContextPath() + "/login");
                    return false;
                }
            }
            return true;
        }
    }

#### 修改用户头像核心类 uploadHeader ####

*  添加了拦截注解的有 uploadHeader，而没有 getHeader 是因为未登录用户也能查看其他用户的头像，不可拦截
 *  new FileInputStream(filenamePath)：为自建输出流，spingboot 不会自动管理该 bean，需要自行关闭该输出流
 *  upload：application.yml 配置的上传文件路径，尽可能为绝对路径，否则，请看相关 Bug 部分，在这里不多赘述
 *  throw new RuntimeException()：异常先抛出，后续再进行统一处理，本文暂不涉及，欢迎关注博主博客。
 *  fileInputStream.read(buffer)：利用缓存区传输数据较为快速

@LoginRequired
    @RequestMapping(path = "/setting",method = RequestMethod.GET)
    public String getSettingPage(){
        
        return "/site/setting";
    }
    
    @LoginRequired
    @RequestMapping(path = "/upload",method = RequestMethod.POST)
    public String uploadHeader(MultipartFile headerImage, Model model){
        
        if (headerImage == null){
        
            model.addAttribute("imageError","您还没有上传图片！");
            return "/site/setting";
        }
    
        // 获取上传的文件原始名称
        String filename = headerImage.getOriginalFilename();
        String suffix = filename.substring(filename.lastIndexOf("."));
    
        if (StringUtils.isBlank(suffix)){
        
            model.addAttribute("imageError","图片格式不正确！");
            return "/site/setting";
        }
        // 生成随机名称，防止覆盖
        filename = CommunityUtil.generateUUID() + suffix;
        // 确定文件路径
        File file = new File(upload+"/"+filename);
        try {
        
            headerImage.transferTo(file);
        } catch (IOException e) {
        
            logger.error("上传文件失败！"+e.getMessage());
            throw new RuntimeException("上传文件失败，服务器异常！"+e.getMessage());
        }
    
        // 更新用户头像路径（web路径）
        // 路径：域名/user/header/***.suffix
        User user = hostHolder.getUser();
        String headerUrl = domain + "/user/headerUrl/" + filename;
        userServiceImpl.updateHeaderUrl(user.getId(),headerUrl);
    
        return "redirect:/index";
    }
    
    // 获取头像
    @RequestMapping(path = "/headerUrl/{filename}",method = RequestMethod.GET)
    public void getHeader(@PathVariable("filename") String filename, HttpServletResponse response){
        
        // 服务器路径
        String filenamePath =  upload + "/" + filename;
        // 文件后缀
        String suffix = filenamePath.substring(filename.lastIndexOf("."));
        // 响应图片
        response.setContentType("image/" + suffix);
        try(
                OutputStream outputStream = response.getOutputStream();
                FileInputStream fileInputStream = new FileInputStream(filenamePath);
        ) {
        
            byte[] buffer = new byte[1024];
            int b = 0;
            while ((b = fileInputStream.read(buffer)) != -1){
        
                outputStream.write(buffer, 0, b);
            }
        } catch (IOException e) {
        
            logger.error("读取头像失败："+ e.getMessage());
        }
    }

#### 修改密码 updatePassword ####

// 修改密码
    @LoginRequired
    @RequestMapping(path = "/updatePassword", method = RequestMethod.POST)
    public String updatePassword(Model model, String newPassword, String oldPassword, String confirmPassword){
        
        if (!newPassword.equals(confirmPassword)){
        
            model.addAttribute("newPasswordError","两次填写的新密码不一致");
            return "/site/setting";
        }
    
        if (newPassword.length() <= 8){
        
            model.addAttribute("newPasswordError","新密码长度不能小于8位!");
            return "/site/setting";
        }
    
        if (oldPassword.equals(newPassword)){
        
            model.addAttribute("newPasswordError","新旧密码相同！请重新输入！");
            return "/site/setting";
        }
        User user = hostHolder.getUser();
        // 比较原密码是否正确
        if (StringUtils.isBlank(oldPassword) || !user.getPassword().equals(CommunityUtil.md5(oldPassword + user.getSalt()))){
        
            model.addAttribute("oldPasswordError","您输入的原密码错误！");
            return "/site/setting";
        }
        // 更新密码
        String salt = CommunityUtil.generateUUID().substring(0,5);
        userServiceImpl.updatePassword(user.getId(),CommunityUtil.md5(newPassword+ salt));
        userServiceImpl.updateSalt(user.getId(),salt);
        model.addAttribute("msg","您的密码已修改完成，可用新密码登录！");
        model.addAttribute("target","/index");
        model.addAttribute("url",domain+"/index");
        return "/site/operate-result";
    }

![求关注点赞][527964442ccc5746c55fc355a8c62a0f.png]  
项目代码已上传：[项目代码][Link 4]

### 相关Bug ###

#### java.io.FileNotFoundException: xxxxx (系统找不到指定的路径。) ####

出现原因：

*  文件夹未建立
    
    自行创建路径，或者添加以下代码：
    
        File dir = new File("目录路径");
        if (!dir.exists()) {
              
            dir.mkdirs(); // 创建目录
        }
        try {
              
            String realPath = dir.getCanonicalPath(); // 获取真实路径
            file.transferTo(new File(realPath + "/" + fileName)); // 转存
        } catch (IOException e) {
              
            System.err.println(e);
            throw new BadRequestException("上传失败");
        }
 *  路径书写为相对路径

当MultipartFile的 transferTo 的入参是相对路径时，会自动拼接成一个绝对路径，但这个绝对路径并不是真实存在的，所以转存时会报错。要么修改为绝对路径，要么使用第一个出现原因的解决代码。

[Link 1]: https://blog.csdn.net/yumuing/article/details/129344410
[Link 2]: https://blog.csdn.net/yumuing/article/details/129502314
[Link 3]: https://blog.csdn.net/yumuing/category_11675950.html
[263395688c5684b07553ee5e6018eff9.png]: https://img-blog.csdnimg.cn/img_convert/263395688c5684b07553ee5e6018eff9.png
[Link 4]: https://yumuing.top/archives/27.html
[527964442ccc5746c55fc355a8c62a0f.png]: https://img-blog.csdnimg.cn/img_convert/527964442ccc5746c55fc355a8c62a0f.png