Redis专题-实战篇一-基于Session和Redis实现登录业务

varin

发布于 2025-09-28 13:03:20

1100

代码可运行

文章被收录于专栏：/root/root

运行总次数：0

代码可运行

GitHub项目地址：https://github.com/whltaoin/redisLearningProject_hm-dianping 基于Session实现登录业务功能提交版本码：e34399f 基于Redis实现登录业务提交版本码：60bf740

一、导入黑马点评后端项目

项目架构图

1. 前期阶段

2. 后续阶段

导入后端项目需要注意的问题

修改application.yaml文件
1. mysql地址配置
2. redis地址配置
该项目的JDK版本为8,需要修改的地方如下图所示：
1. idea设置

2. 项目结构设置

项目启动报错

报错内容：

Failed to load property source from location ‘classpath:/application.yml‘

解决方法1
1. 查看yaml文件中的配置是否**配置完整，格式正确**
解决方法2
1. 设置yaml文件的文件格式为：UTF-8
2. 设置方法为：file->setting->File Encodings

项目启动测试

喜爱过目正常启动后，访问：http://localhost:8081/shop-type/list
下图为正确启动结果

二、导入并启动前端项目

提示：前端项目已经打包并导入到了nginx-1.18.0文件夹中的。
1. 启动前端项目只需要执行ngin的开启命令即可。

start nginx

访问前端路径：http://localhost:8080

三、基于session实现登录功能

具体实现流程图

实现发送验证码

查询发送验证码请求API

地址：/user/code 请求方式：POST

修改UserController中的发送验证码方法

/**
     * 发送手机验证码
     */
@PostMapping("code")
public Result sendCode(@RequestParam("phone") String phone, HttpSession session) {
    //        // TODO 发送短信验证码并保存验证码
    //        return Result.fail("功能未完成");
    // 实现发送验证码
    return userService.sendCode(phone,session);
}

在service中实现send方法

package com.hmdp.service.impl;

import cn.hutool.Hutool;
import cn.hutool.core.util.RandomUtil;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.hmdp.dto.Result;
import com.hmdp.entity.User;
import com.hmdp.mapper.UserMapper;
import com.hmdp.service.IUserService;
import com.hmdp.utils.RegexUtils;
import lombok.extern.log4j.Log4j;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;

import javax.servlet.http.HttpSession;



/**
 * <p>
 * 服务实现类
 * </p>
 *
 * @since 2021-12-22
 */
@Service
@Slf4j
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements IUserService {

    /**
     * 发送验证码
     * @param phone
     * @param session
     * @return
     */
    @Override
    public Result sendCode(String phone, HttpSession session) {

        // 1 验证手机号
        if (RegexUtils.isPhoneInvalid(phone)) {
            return Result.fail("手机号格式错误，请重新输入");
        }
        // 2 生成验证码
        String code = RandomUtil.randomString(6);
        // 3 存储验证码
        session.setAttribute("code",code);
        // 4 发送验证码,模拟，不调用第三方功能
        log.debug("发送短信验证码成功，验证码：{}",code);

        return Result.ok();
    }
}

深入正确的手机号，点击发送后的效果

登录功能实现

登录API信息

地址：/user/login 请求方式：POST

在UserService中添加Login方法

/**
     * 登录功能
     * @param loginForm 登录参数，包含手机号、验证码；或者手机号、密码
     */
    @PostMapping("/login")
    public Result login(@RequestBody LoginFormDTO loginForm, HttpSession session){
        // TODO 实现登录功能
//        return Result.fail("功能未完成");
        return userService.login(loginForm,session);
    }

实现Login方法

package com.hmdp.service.impl;

import cn.hutool.Hutool;
import cn.hutool.core.util.RandomUtil;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.hmdp.dto.LoginFormDTO;
import com.hmdp.dto.Result;
import com.hmdp.entity.User;
import com.hmdp.mapper.UserMapper;
import com.hmdp.service.IUserService;
import com.hmdp.utils.RegexUtils;
import com.sun.deploy.security.WSeedGenerator;
import lombok.extern.log4j.Log4j;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;

import javax.servlet.http.HttpSession;

import static com.hmdp.utils.SystemConstants.USER_NICK_NAME_PREFIX;


/**
 * <p>
 * 服务实现类
 * </p>
 *
 * @since 2021-12-22
 */
@Service
@Slf4j
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements IUserService {

    

    /**
     * 登录和注册
     * @param loginForm
     * @param session
     * @return
     */

    @Override
    public Result login(LoginFormDTO loginForm, HttpSession session) {
        // 1 判断手机号
        String phone = loginForm.getPhone();
        if (RegexUtils.isPhoneInvalid(phone)) {
            return Result.fail("手机号格式错误，请重新输入");
        }
        // 2 判断验证码
        String webCode = loginForm.getCode();
        String sessionCode = session.getAttribute("code").toString();
        if (webCode==null || !webCode.equals(sessionCode)) {
            return Result.fail("验证码错误");

        }

        //
        log.debug("手机号为：{}；验证码为：{}",phone,sessionCode);

        // 3 查询用户是否存在
        User user = query().eq("phone",phone).one();
        System.out.println("-==--------------");
        System.out.println(user);
        System.out.println("-==--------------");

        // 4 不存在用户创建
        if (user==null){
            user = createUserWithPhone(phone);
            System.out.println(user);
        }
        // 5 存在用户到session中
        session.setAttribute("user",user);


        return Result.ok();
    }

    private User createUserWithPhone(String phone) {
        User user = new User();
        user.setPhone(phone);
        user.setNickName(USER_NICK_NAME_PREFIX+RandomUtil.randomString(6));
        // 保存
        save(user);
        return user;
    }
}

实现效果

实现登录校验功能

涉及到的controller API

地址：/user/me 请求方式：get

编写登录拦截器工具类（LoginInterceptor）

package com.hmdp.utils;


import com.hmdp.entity.User;
import org.springframework.web.servlet.HandlerInterceptor;

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

public class LoginInterceptor implements HandlerInterceptor {

    /**
     * 此方法的作用是在请求进入到Controller进行拦截，有返回值
     * @param request
     * @param response
     * @param handler
     * @return
     * @throws Exception
     */
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {

        // 1 获取session
        HttpSession session = request.getSession();
        // 2 获取用户
        Object user = session.getAttribute("user");

        // 3 判断用户
        if (user==null) {
            response.setStatus(401);
            return false;
        }
        // 4  存储用户
        UserHolder.saveUser((User) user);
        // 5 放行
        return true;
    }

    /**
     * 该方法是在ModelAndView返回给前端渲染后执行
     * @param request
     * @param response
     * @param handler
     * @param ex
     * @throws Exception
     */

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
       UserHolder.removeUser();
    }
}

添加配置MVC拦截器配置类(MvcConfig)

package com.hmdp.config;


import com.hmdp.utils.LoginInterceptor;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

@Configuration
public class MvcConfig  implements WebMvcConfigurer {
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
      registry.addInterceptor(new LoginInterceptor()
      ).excludePathPatterns(
              "/shop/**",
              "/shop-type/**",
              "/upload/**",
              "blog/hot",
              "/user/code",
              "/user/login"

      );
    }
}

让在threadLocal存储用户返回到签到(userController)

    @GetMapping("/me")
    public Result me(){
//        // TODO 获取当前登录的用户并返回
//        return Result.fail("功能未完成");
        return Result.ok(UserHolder.getUser());
    }

运行效果
1. 登录成功后，会跳转到用户个人主页，并显示用户的一些信息

UserDTO类使用

在后端直接返回User类后，可能用用户敏感信息泄露的风险。
1. 所以我们在存如Session时，只存储不太重要的信息即可。
需要修改的地方：
1. UserService中session存储类型

2. 拦截器

效果

集群Session共享存在的问题

存在问题，
1. 因为在tomcat中的Session是不共享的，如果使用了tomcat集群的话，每个tomcat中的Session都需要重新存储数据，同时可能会造成数据的不一致和数据丢失的可能。
为了解决session存在问题，同时需要满足
1. 数据共享
2. 内存存储
3. Key、value结构
从而引入了Redis替代Session

四、Redis替代Session的解决方案流程图

替换流程

Redis替换Session具体实现

首先将生成的验证码存入Redis中

  @Override
    public Result sendCode(String phone, HttpSession session) {

        // 1 验证手机号
        if (RegexUtils.isPhoneInvalid(phone)) {
            return Result.fail("手机号格式错误，请重新输入");
        }
        // 2 生成验证码
        String code = RandomUtil.randomString(6);
//        // 3 存储验证码
//        session.setAttribute("code",code);
        //  3 修改为redis存储

        stringRedisTemplate.opsForValue().set(LOGIN_CODE_KEY+phone,code,LOGIN_CODE_TTL, TimeUnit.MINUTES); // 1分钟过期
        // 4 发送验证码,模拟，不调用第三方功能
        log.debug("发送短信验证码成功，验证码：{}",code);

        return Result.ok();
    }

在用户点击登录时，从Redis中获取验证码进行判断
后续将登录的用户存储到Redis中，并返回Token

  @Override
    public Result login(LoginFormDTO loginForm, HttpSession session) {
        // 1 判断手机号
        String phone = loginForm.getPhone();
        if (RegexUtils.isPhoneInvalid(phone)) {
            return Result.fail("手机号格式错误，请重新输入");
        }
        // 2 判断验证码
        String webCode = loginForm.getCode();
       // String sessionCode = session.getAttribute("code").toString();
        // 从redis中获取验证码
        String sessionCode = stringRedisTemplate.opsForValue().get(LOGIN_CODE_KEY+phone);
        if (webCode==null || !webCode.equals(sessionCode)) {
            return Result.fail("验证码错误");

        }

        //
        log.debug("手机号为：{}；验证码为：{}",phone,sessionCode);

        // 3 查询用户是否存在
        User user = query().eq("phone",phone).one();
        System.out.println("-==--------------");
        System.out.println(user);
        System.out.println("-==--------------");

        // 4 不存在用户创建
        if (user==null){
            user = createUserWithPhone(phone);
            System.out.println(user);
        }
        // 5 存在用户到session中
        // 6 为了防止敏感信息泄露，将user转存到UserDTO中
        session.setAttribute("user", BeanUtil.copyProperties(user, UserDTO.class));
        UserDTO userDTO = BeanUtil.copyProperties(user, UserDTO.class);
        String token = UUID.randomUUID().toString(false);// 不带下划线的UUID

        // 将UserDTO bean转为HashMap
        Map<String, Object> userDTOMap = BeanUtil.beanToMap(userDTO);
//        System.out.println(userDTOMap);
        userDTOMap.put("id",userDTO.getId().toString()); // StringRedisTamplate 只能存String类型的数据，ID为Long，需要单独处理
        String tokenKey = LOGIN_USER_KEY+token;

        stringRedisTemplate.opsForHash().putAll(tokenKey, userDTOMap);
        stringRedisTemplate.expire(tokenKey,LOGIN_USER_TTL, TimeUnit.SECONDS);

        return Result.ok(token);
    }

登录功能验证
1. 用户登录完成后，在访问其他请求时，会进入到拦截器中，从请求的header中获取到Token，再通过Token查询Redis中的用户是否存在。存在就放行，并重新刷新Redis保存数据的TTL，不存在则拦截。

package com.hmdp.utils;


import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.util.StrUtil;
import com.hmdp.dto.UserDTO;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.web.servlet.HandlerInterceptor;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.Map;
import java.util.concurrent.TimeUnit;

import static com.hmdp.utils.RedisConstants.LOGIN_USER_KEY;
import static com.hmdp.utils.RedisConstants.LOGIN_USER_TTL;

/**
 * 刷新Token拦截器
 */

public class RefreshTokenInterceptor implements HandlerInterceptor {
    private StringRedisTemplate stringRedisTemplate;
    public RefreshTokenInterceptor(StringRedisTemplate stringRedisTemplate ){
        this.stringRedisTemplate = stringRedisTemplate;
    }



    /**
     * 此方法的作用是在请求进入到Controller进行拦截，有返回值
     * @param request
     * @param response
     * @param handler
     * @return
     * @throws Exception
     */
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {

//        // 1 获取session
//        HttpSession session = request.getSession();
        // 获取token
        String token = request.getHeader("authorization");
        if (StrUtil.isBlank(token)) {

            return  true;
        }
        // 2 获取用户
//        Object user = session.getAttribute("user");

        Map<Object, Object> userMap = stringRedisTemplate.opsForHash().entries(LOGIN_USER_KEY+token);


        // 3 判断用户
        if (userMap.isEmpty()) {

            return true;
        }
        UserDTO userDTO = BeanUtil.fillBeanWithMap(userMap, new UserDTO(), false);// map转bean
// 4  存储用户
        UserHolder.saveUser(userDTO);
        // 刷新token有效期
        stringRedisTemplate.expire(LOGIN_USER_KEY+token,LOGIN_USER_TTL, TimeUnit.SECONDS);
        // 5 放行
        return true;
    }

    /**
     * 该方法是在ModelAndView返回给前端渲染后执行
     * @param request
     * @param response
     * @param handler
     * @param ex
     * @throws Exception
     */

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
       UserHolder.removeUser();
    }
}

登录遗留问题解决

我们之前在LoginInterceptor中有放行了一些不需要的认证的请求，这样就存在问题了。
1. 例如：如果用户登录了，但是一直停留在不需要认证的请求上，Redis的TTL的刷新TTL功能就不会执行，导致用户被强制退出系统。
解决方案：
1. 我们在LoginInterceptor之前在设置一个全局的拦截起，并设置全局拦截，并将Login拦截器内容判断都移动到RefershToken拦截器上，在Refresh执行后再进入到Login拦截器，在判断线程中是否有登录用户，在进行实际的拦截。
具体实现

LoginInterceptor

package com.hmdp.utils;


import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.util.StrUtil;
import com.hmdp.dto.UserDTO;
import com.hmdp.entity.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisOperations;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.web.servlet.HandlerInterceptor;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import java.util.Map;
import java.util.concurrent.TimeUnit;

import static com.hmdp.utils.RedisConstants.LOGIN_USER_KEY;
import static com.hmdp.utils.RedisConstants.LOGIN_USER_TTL;

/**
 * 登录拦截器
 */

public class LoginInterceptor implements HandlerInterceptor {




    /**
     * 此方法的作用是在请求进入到Controller进行拦截，有返回值
     * @param request
     * @param response
     * @param handler
     * @return
     * @throws Exception
     */
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        // 获取不到用户，拦截
        if (UserHolder.getUser()==null) {
            response.setStatus(401);
            return false;
        }
        return true;
    }

    /**
     * 该方法是在ModelAndView返回给前端渲染后执行
     * @param request
     * @param response
     * @param handler
     * @param ex
     * @throws Exception
     */

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
       UserHolder.removeUser();
    }
}

RefreshTokenInterceptor如上图

MnvConfig配置类修改如下

package com.hmdp.config;


import com.hmdp.utils.LoginInterceptor;

import com.hmdp.utils.RefreshTokenInterceptor;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

@Configuration
public class MvcConfig  implements WebMvcConfigurer {
    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    /**
     * order值越小，拦截顺序越高。
     * @param registry
     */
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor( new RefreshTokenInterceptor(stringRedisTemplate)).order(0);

      registry.addInterceptor(new LoginInterceptor()
      ).excludePathPatterns(
              // 放行的路径
              "/shop/**",
              "/shop-type/**",
              "/upload/**",
              "blog/hot",
              "/user/code",
              "/user/login"

      ).order(1);

    }
}

本文参与腾讯云自媒体同步曝光计划，分享自作者个人站点/博客。

原始发表：2025-09-28，如有侵权请联系 cloudcommunity@tencent.com 删除

session