Day76(2)-F:\code\hm-dianping\hm-dianping
黑马点评
企业实战
基于session实现登录
HttpSession不是自带的，而是由后端按需创建的。
- 当你的 Controller 方法参数中写了
HttpSession session时，Spring MVC 会自动帮你执行request.getSession()。 - 如果这是用户第一次访问：服务器会在内存中创建一个新的 Session 对象，并生成一个唯一的
JSESSIONID。 - 如果用户不是第一次访问：服务器会根据请求中携带的 ID 找到之前那个 Session 对象。
2. 前端每次都会携带吗？
是的，只要浏览器里存了那个 Cookie。
- 自动携带机制：一旦服务器通过响应头（Set-Cookie）把
JSESSIONID发给了浏览器，浏览器就会把它存入 Cookie。 - 同源策略：之后只要前端访问同一个域名下的后端接口，浏览器就会在 HTTP 请求头中自动带上这个 Cookie。
- 无感状态：前端开发者通常不需要手动写代码去发送这个 ID，这是浏览器的标准行为。
3. 在“黑马点评”这个项目中的实际情况
虽然你在代码中看到了 HttpSession，但在你正在做的这个实战项目中，后续会发生变化：
- 当前阶段（Session 模式）：确实是靠浏览器携带
JSESSIONID来识别用户。 - 进阶阶段（Redis + Token 模式）：
- 为了解决分布式集群下的 Session 共享问题，老师会教你抛弃
HttpSession。 - 到那时，前端登录后会拿到一个
token（一串随机字符串），前端需要手动把这个 token 放在请求头（Headers）里发送给后端。 - 后端再去 Redis 里根据这个 token 查用户信息。
- 为了解决分布式集群下的 Session 共享问题，老师会教你抛弃
技术栈
- 后端在controller层接收session
- 往session存入信息
- 通过引入import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;简化sql语句
- 编写一个拦截器（设置）
- 注册拦截器于配置类中MvcConfig
1.后端在controller层接收session（28行）
2.往session存入信息（37行）
package com.hmdp.service.impl;
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.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import javax.servlet.http.HttpSession;
/**
* <p>
* 服务实现类
* </p>
*
* @author 虎哥
* @since 2021-12-22
*/
@Slf4j
@Service
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements IUserService {
@Override
public Result sendCode(String phone, HttpSession session) {
//1.校验手机号
if (RegexUtils.isPhoneInvalid(phone)){
//2.如果不符合，返回错误信息
return Result.fail("手机号格式错误！");
}
//3.符合，生成验证码
String code = RandomUtil.randomNumbers(6);
//4.保存验证码到session
session.setAttribute("code",code);
//5.发送验证码
log.debug("发送短信验证码成功，验证码：{}",code);
//6.返回ok
return Result.ok();
}
}
3.通过extends ServiceImpl引入import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;简化sql语句（64,82行）
package com.hmdp.service.impl;
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 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>
*
* @author 虎哥
* @since 2021-12-22
*/
@Slf4j
@Service
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements IUserService {
@Override
public Result sendCode(String phone, HttpSession session) {
//1.校验手机号
if (RegexUtils.isPhoneInvalid(phone)){
//2.如果不符合，返回错误信息
return Result.fail("手机号格式错误！");
}
//3.符合，生成验证码
String code = RandomUtil.randomNumbers(6);
//4.保存验证码到session
session.setAttribute("code",code);
//5.发送验证码
log.debug("发送短信验证码成功，验证码：{}",code);
//6.返回ok
return Result.ok();
}
@Override
public Result login(LoginFormDTO loginForm, HttpSession session) {
//1.校验手机号
String phone = loginForm.getPhone();
if (RegexUtils.isPhoneInvalid(phone)){
//2.如果不符合，返回错误信息
return Result.fail("手机号格式错误！");
}
//2.校验验证码
Object cacheCode = session.getAttribute("code");
String code = loginForm.getCode();
if (cacheCode == null || !cacheCode.toString().equals(code)){
//3.不一致，报错
return Result.fail("验证码错误");
}
//4.一致，根据手机号查询用户 select * from tb_user where phone = ?
User user = query().eq("phone", phone).one();
//5.判断用户是否存在
if (user == null){
//6.不存在，创建新用户并保存
user = createUserWithPhone(phone);
}
//7.保存用户信息到session
session.setAttribute("user",user);
return Result.ok();
}
private User createUserWithPhone(String phone){
//1.创建用户
User user = User.builder()
.phone(phone)
.nickName(USER_NICK_NAME_PREFIX + RandomUtil.randomString(10))
.build();
//2.保存用户
save(user);
return user;
}
}
4.编写一个拦截器（设置）接入HandlerInterceptor接口，从HttpServletRequest获取session
package com.hmdp.utils;
import com.hmdp.dto.UserDTO;
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 {
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
//1.获取session
HttpSession session = request.getSession();
//2.获取session中的用户
Object user = session.getAttribute("user");
//3.判断用户是否存在
if (user == null){
//4.不存在，拦截
response.setStatus(401);
return false;
}
//5.存在，保存用户信息到ThreadLocal
UserHolder.saveUser((UserDTO)user);
//6.放行
return true;
}
@Override
public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
//移除用户
UserHolder.removeUser();
}
}
5.注册拦截器于配置类中MvcConfig接入WebMvcConfigurer接口
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(
"/user/code",
"/user/login",
"/blog/hot",
"/shop/**",
"/shop-type/**",
"/upload/**",
"/voucher/**"
);
}
}
集群共享问题
技术栈
- 获取验证码后将验证码存入redis
- 登录过程需要从redis中获取验证码来校验，成功则将token传入redis
- 将对象通过BeanUtil.beanToMap转换为map用以存储到redis，并设置转换格式因为StringRedisTemplate的key和value都需要是string类型的
- 将查询到的hash里面的string格式的内容转换为对象
1.获取验证码后将验证码存入redis（57-58）
2.登录过程需要从redis中获取验证码来校验（81-82），成功则将token传入redis（100-110），生成UUID作为存储token的key
3.将对象通过BeanUtil.beanToMap转换为map用以存储到redis（103-106），并设置转换格式因为StringRedisTemplate的key和value都需要是string类型的
package com.hmdp.service.impl;
import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.bean.copier.CopyOptions;
import cn.hutool.core.lang.UUID;
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.dto.UserDTO;
import com.hmdp.entity.User;
import com.hmdp.mapper.UserMapper;
import com.hmdp.service.IUserService;
import com.hmdp.utils.RegexUtils;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import javax.servlet.http.HttpSession;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.TimeUnit;
import static com.hmdp.utils.RedisConstants.*;
import static com.hmdp.utils.SystemConstants.USER_NICK_NAME_PREFIX;
/**
* <p>
* 服务实现类
* </p>
*
* @author 虎哥
* @since 2021-12-22
*/
@Slf4j
@Service
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements IUserService {
@Resource//属于Java标准的注解，匹配顺序先名称，后类型；而@Autowird是基于Spring框架的注解，先类型，后名称
private StringRedisTemplate stringRedisTemplate;
@Override
public Result sendCode(String phone, HttpSession session) {
//1.校验手机号
if (RegexUtils.isPhoneInvalid(phone)){
//2.如果不符合，返回错误信息
return Result.fail("手机号格式错误！");
}
//3.符合，生成验证码
String code = RandomUtil.randomNumbers(6);
// //4.保存验证码到session
// session.setAttribute("code",code);
//4.保存验证码到redis //set key value ex 120
stringRedisTemplate.opsForValue().set(LOGIN_CODE_KEY+phone,code,LOGIN_CODE_TTL, TimeUnit.MINUTES);
//5.发送验证码
log.debug("发送短信验证码成功，验证码：{}",code);
//6.返回ok
return Result.ok();
}
@Override
public Result login(LoginFormDTO loginForm, HttpSession session) {
//1.校验手机号
String phone = loginForm.getPhone();
if (RegexUtils.isPhoneInvalid(phone)){
//2.如果不符合，返回错误信息
return Result.fail("手机号格式错误！");
}
// //3.校验验证码
// Object cacheCode = session.getAttribute("code");
// String code = loginForm.getCode();
// if (cacheCode == null || !cacheCode.toString().equals(code)){
// //.不一致，报错
// return Result.fail("验证码错误");
// }
//3.从redis中获取验证码并校验
String cacheCode = stringRedisTemplate.opsForValue().get(LOGIN_CODE_KEY + phone);
String code = loginForm.getCode();
if (cacheCode == null || !cacheCode.equals(code)){
//.不一致，报错
return Result.fail("验证码错误");
}
//4.一致，根据手机号查询用户 select * from tb_user where phone = ?
User user = query().eq("phone", phone).one();
//5.判断用户是否存在
if (user == null){
//6.不存在，创建新用户并保存
user = createUserWithPhone(phone);
}
// //7.保存用户信息到session
// UserDTO userDTO = BeanUtil.copyProperties(user, UserDTO.class);
// session.setAttribute("user",userDTO);
//7.保存用户信息到redis
//7.1生成token作为登录令牌
String token = UUID.randomUUID().toString(true);
//7.2将user对象转为hash存储
UserDTO userDTO = BeanUtil.copyProperties(user, UserDTO.class);
Map<String, Object> userMap = BeanUtil.beanToMap(userDTO,new HashMap<>(),
CopyOptions.create()
.setIgnoreNullValue(true)
.setFieldValueEditor((fieldName,fieldValue)->fieldValue.toString()));
//7.3存储
stringRedisTemplate.opsForHash().putAll(LOGIN_USER_KEY+token,userMap);
//7.4设置有效期
stringRedisTemplate.expire(LOGIN_USER_KEY+token,LOGIN_USER_TTL,TimeUnit.MINUTES);
//8.返回token
return Result.ok(token);
}
private User createUserWithPhone(String phone){
//1.创建用户
User user = User.builder()
.phone(phone)
.nickName(USER_NICK_NAME_PREFIX + RandomUtil.randomString(10))
.build();
//2.保存用户
save(user);
return user;
}
}
4.将查询到的hash里面的string格式的内容通过BeanUtil.fillBeanWithMap转换为对象（50）
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.data.redis.core.StringRedisTemplate;
import org.springframework.web.servlet.HandlerInterceptor;
import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import java.util.Map;
import java.util.concurrent.TimeUnit;
public class LoginInterceptor implements HandlerInterceptor {
//不被spring管理的类无法使用@Resource注入
private StringRedisTemplate stringRedisTemplate;
public LoginInterceptor(StringRedisTemplate stringRedisTemplate) {
this.stringRedisTemplate = stringRedisTemplate;
}
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
// //1.获取session
// HttpSession session = request.getSession();
// //2.获取session中的用户
// Object user = session.getAttribute("user");
//1.获取请求头中的token
String token = request.getHeader("authorization");
if (StrUtil.isBlank(token)) {
//2.不存在，拦截
response.setStatus(401);
return false;
}
//3.基于token获取redis中的用户
String key = RedisConstants.LOGIN_USER_KEY + token;
Map<Object, Object> userMap = stringRedisTemplate.opsForHash().entries(key);
//.判断用户是否存在
if (userMap.isEmpty()){
//4.不存在，拦截
response.setStatus(401);
return false;
}
//5.将查询到的hash数据转为userDTO对象，不忽略转换过程中的异常
UserDTO userDTO = BeanUtil.fillBeanWithMap(userMap, new UserDTO(), false);
//6.存在，保存用户信息到ThreadLocal
// UserHolder.saveUser((UserDTO)user);
UserHolder.saveUser((userDTO));
//7.刷新token有效期
stringRedisTemplate.expire(key,RedisConstants.LOGIN_USER_TTL, TimeUnit.MINUTES);
//8.放行
return true;
}
@Override
public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
//移除用户
UserHolder.removeUser();
}
}
技术栈
- 双拦截器拦截
- 控制拦截器的拦截顺序（执行顺序）
1.双拦截器拦截（先全部拦截重设更新时间，然后再单独校验是否需要token）
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;
public class RefreshTokenInterceptor implements HandlerInterceptor {
//不被spring管理的类无法使用@Resource注入
private StringRedisTemplate stringRedisTemplate;
public RefreshTokenInterceptor(StringRedisTemplate stringRedisTemplate) {
this.stringRedisTemplate = stringRedisTemplate;
}
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
// //1.获取session
// HttpSession session = request.getSession();
// //2.获取session中的用户
// Object user = session.getAttribute("user");
//1.获取请求头中的token
String token = request.getHeader("authorization");
if (StrUtil.isBlank(token)) {
return true;
}
//2.基于token获取redis中的用户
String key = RedisConstants.LOGIN_USER_KEY + token;
Map<Object, Object> userMap = stringRedisTemplate.opsForHash().entries(key);
//3.判断用户是否存在
if (userMap.isEmpty()){
return true;
}
//5.将查询到的hash数据转为userDTO对象，不忽略转换过程中的异常
UserDTO userDTO = BeanUtil.fillBeanWithMap(userMap, new UserDTO(), false);
//6.存在，保存用户信息到ThreadLocal
// UserHolder.saveUser((UserDTO)user);
UserHolder.saveUser((userDTO));
//7.刷新token有效期
stringRedisTemplate.expire(key,RedisConstants.LOGIN_USER_TTL, TimeUnit.MINUTES);
//8.放行
return true;
}
// @Override
// public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
// //移除用户
// UserHolder.removeUser();
// }
}
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.data.redis.core.StringRedisTemplate;
import org.springframework.web.servlet.HandlerInterceptor;
import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import java.util.Map;
import java.util.concurrent.TimeUnit;
public class LoginInterceptor implements HandlerInterceptor {
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
//1. 判断是否需要去拦截（threadlocal中是否有我们这个用户）
if (UserHolder.getUser() == null){
//没有，需要拦截，设置状态码
response.setStatus(401);
//拦截
return false;
}
//有用户，放行
return true;
}
@Override
public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
//移除用户
UserHolder.removeUser();
}
}
2.控制拦截器的拦截顺序（执行顺序），默认是谁先注册谁优先拦截，也可以通过.order(0)设置优先级（28和30）
package com.hmdp.config;
import com.hmdp.utils.LoginInterceptor;
import com.hmdp.utils.RefreshTokenInterceptor;
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;
import javax.annotation.Resource;
@Configuration
public class MvcConfig implements WebMvcConfigurer {
@Resource
private StringRedisTemplate stringRedisTemplate;
@Override
public void addInterceptors(InterceptorRegistry registry) {
//登录拦截器
registry.addInterceptor(new LoginInterceptor())
.excludePathPatterns(
"/user/code",
"/user/login",
"/blog/hot",
"/shop/**",
"/shop-type/**",
"/upload/**",
"/voucher/**"
).order(1);
//token刷新的拦截器
registry.addInterceptor(new RefreshTokenInterceptor(stringRedisTemplate)).addPathPatterns("/**").order(0);
}
}
浙公网安备 33010602011771号