基于Session实现登录流程
- 发送验证码
用户在提交手机号后，会校验手机号是否合法，如果不合法，则要求用户重新输入手机号
如果手机号合法，后台此时生成对应的验证码，同时将验证码进行保存，然后再通过短信的方式将验证码发送给用户- 短信验证码登录、注册
用户将验证码和手机号进行输入，后台从session中拿到当前验证码，然后和用户输入的验证码进行校验，如果不一致，则无法通过校验，如果一致，则后台根据手机号查询用户，如果用户不存在，则为用户创建账号信息，保存到数据库，无论是否存在，都会将用户信息保存到session中，方便后续获得当前登录信息- 校验登录状态
用户在请求的时候，会从cookie中携带JsessionId到后台，后台通过JsessionId从session中拿到用户信息，如果没有session信息，则进行拦截，如果有session信息，则将用户信息保存到threadLocal中，并放行
实现发送短信验证码功能
- 导入邮箱验证需要的maven坐标
<!-- https://mvnrepository.com/artifact/javax.activation/activation -->
<dependency>
<groupId>javax.activation</groupId>
<artifactId>activation</artifactId>
<version>1.1.1</version>
</dependency>
<!-- https://mvnrepository.com/artifact/javax.mail/mail -->
<dependency>
<groupId>javax.mail</groupId>
<artifactId>mail</artifactId>
<version>1.4.7</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.apache.commons/commons-email -->
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-email</artifactId>
<version>1.4</version>
</dependency>- 然后编写一个工具类，用于发送邮件验证码
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.Properties;
import javax.mail.Authenticator;
import javax.mail.MessagingException;
import javax.mail.PasswordAuthentication;
import javax.mail.Session;
import javax.mail.Transport;
import javax.mail.internet.InternetAddress;
import javax.mail.internet.MimeMessage;
import javax.mail.internet.MimeMessage.RecipientType;
public class MailUtils {
public static void main(String[] args) throws MessagingException {
//可以在这里直接测试方法，填自己的邮箱即可
sendTestMail("1586385296@qq.com", new MailUtils().achieveCode());
}
public static void sendTestMail(String email, String code) throws MessagingException {
// 创建Properties 类用于记录邮箱的一些属性
Properties props = new Properties();
// 表示SMTP发送邮件，必须进行身份验证
props.put("mail.smtp.auth", "true");
//此处填写SMTP服务器
props.put("mail.smtp.host", "smtp.qq.com");
//端口号，QQ邮箱端口587
props.put("mail.smtp.port", "587");
// 此处填写，写信人的账号
props.put("mail.user", "1586385296@qq.com");
// 此处填写16位STMP口令
props.put("mail.password", "tXXXXXXXXXfgjb");
// 构建授权信息，用于进行SMTP进行身份验证
Authenticator authenticator = new Authenticator() {
protected PasswordAuthentication getPasswordAuthentication() {
// 用户名、密码
String userName = props.getProperty("mail.user");
String password = props.getProperty("mail.password");
return new PasswordAuthentication(userName, password);
}
};
// 使用环境属性和授权信息，创建邮件会话
Session mailSession = Session.getInstance(props, authenticator);
// 创建邮件消息
MimeMessage message = new MimeMessage(mailSession);
// 设置发件人
InternetAddress form = new InternetAddress(props.getProperty("mail.user"));
message.setFrom(form);
// 设置收件人的邮箱
InternetAddress to = new InternetAddress(email);
message.setRecipient(RecipientType.TO, to);
// 设置邮件标题
message.setSubject("Kyle's Blog 邮件测试");
// 设置邮件的内容体
message.setContent("尊敬的用户:你好!\n注册验证码为:" + code + "(有效期为一分钟,请勿告知他人)", "text/html;charset=UTF-8");
// 最后当然就是发送邮件啦
Transport.send(message);
}
public static String achieveCode() { //由于数字 1 、 0 和字母 O 、l 有时分不清楚，所以，没有数字 1 、 0
String[] beforeShuffle = new String[]{"2", "3", "4", "5", "6", "7", "8", "9", "A", "B", "C", "D", "E", "F",
"G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z", "a",
"b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v",
"w", "x", "y", "z"};
List<String> list = Arrays.asList(beforeShuffle);//将数组转换为集合
Collections.shuffle(list); //打乱集合顺序
StringBuilder sb = new StringBuilder();
for (String s : list) {
sb.append(s); //将集合转化为字符串
}
return sb.substring(3, 8);
}
}修改sendCode方法
/**
* 发送手机验证码
*/
@PostMapping("/code")
public Result sendCode(@RequestParam("phone") String phone, HttpSession session) throws MessagingException {
// TODO 发送短信验证码并保存验证码
if (RegexUtils.isEmailInvalid(phone)) {
return Result.fail("邮箱格式不正确");
}
String code = MailUtils.achieveCode();
session.setAttribute(phone, code);
log.info("发送登录验证码：{}", code);
MailUtils.sendTestMail(phone, code);
return Result.ok();
}实现login方法
@Data
public class LoginFormDTO {
private String phone;
private String code;
private String password;
}/**
* 登录功能
*
* @param loginForm 登录参数，包含手机号、验证码；或者手机号、密码
*/
@PostMapping("/login")
public Result login(@RequestBody LoginFormDTO loginForm, HttpSession session) {
// TODO 实现登录功能
//获取登录账号
String phone = loginForm.getPhone();
//获取登录验证码
String code = loginForm.getCode();
//获取session中的验证码
Object cacheCode = session.getAttribute(phone);
//1. 校验邮箱
if (RegexUtils.isEmailInvalid(phone)) {
//2. 不符合格式则报错
return Result.fail("邮箱格式不正确！！");
}
//3. 校验验证码
log.info("code:{},cacheCode{}", code, cacheCode);
if (code == null || !cacheCode.toString().equals(code)) {
//4. 不一致则报错
return Result.fail("验证码不一致！！");
}
//5. 根据账号查询用户是否存在
LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.eq(User::getPhone, phone);
User user = userService.getOne(queryWrapper);
//6. 如果不存在则创建
if (user == null) {
// 创建的逻辑封装成了一个方法
user = createUserWithPhone(phone);
}
//7. 保存用户信息到session中
session.setAttribute("user", user);
return Result.ok();
}private User createUserWithPhone(String phone) {
//创建用户
User user = new User();
//设置手机号
user.setPhone(phone);
//设置昵称(默认名)，一个固定前缀+随机字符串
user.setNickName("user_" + RandomUtil.randomString(8));
//保存到数据库
userService.save(user);
return user;
}实现登录拦截功能
- 创建一个LoginInterceptor类，实现HandlerInterceptor接口，重写其中的两个方法，前置拦截器和完成处理方法，前置拦截器主要用于我们登陆之前的权限校验，完成处理方法是用于处理登录后的信息，避免内存泄露
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中的用户信息
User user = (User) session.getAttribute("user");
//3. 判断用户是否存在
if (user == null) {
//4. 不存在，则拦截
response.setStatus(401);
return false;
}
//5. 存在，保存用户信息到ThreadLocal，UserHolder是提供好了的工具类
UserHolder.saveUser(user);
//6. 放行
return true;
}
@Override
public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
UserHolder.removeUser();
}
}public class UserHolder {
private static final ThreadLocal<User> tl = new ThreadLocal<>();
public static void saveUser(User user){
tl.set(user);
}
public static User getUser(){
return tl.get();
}
public static void removeUser(){
tl.remove();
}
}@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/**"
);
}
}@GetMapping("/me")
public Result me() {
// TODO 获取当前登录的用户并返回
User user = UserHolder.getUser();
return Result.ok(user);
}隐藏用户敏感信息
- 我们通过浏览器观察到此时用户的全部信息都在，这样极为不靠谱，所以我们应当在返回用户信息之前，将用户的敏感信息进行隐藏，采用的核心思路就是书写一个UserDto对象，这个UserDto对象就没有敏感信息了，我们在返回前，将有用户敏感信息的User对象转化成没有敏感信息的UserDto对象，那么就能够避免这个尴尬的问题了
- UserDto类如下，将User对象中的属性拷贝给UserDto，就可以避免暴露用户的隐藏信息
@Data
public class UserDTO {
private Long id;
private String nickName;
private String icon;
}- 修改UserHolder，将其User类型都换为UserDto
public class UserHolder {
private static final ThreadLocal<UserDTO> tl = new ThreadLocal<>();
public static void saveUser(UserDTO user){
tl.set(user);
}
public static UserDTO getUser(){
return tl.get();
}
public static void removeUser(){
tl.remove();
}
}- 修改上面的login方法
//6. 如果不存在则创建
if (user == null) {
user = createUserWithPhone(phone);
}
//7. 保存用户信息到session中
- session.setAttribute("user", user);
+ UserDTO userDTO = BeanUtil.copyProperties(user, UserDTO.class);
+ session.setAttribute("user", userDTO);- 修改拦截器
//2. 获取session中的用户信息
- User user = (User) session.getAttribute("user");
+ UserDTO user = (UserDTO) session.getAttribute("user");session共享问题
每个tomcat中都有一份属于自己的session,假设用户第一次访问第一台tomcat，并且把自己的信息存放到第一台服务器的session中，但是第二次这个用户访问到了第二台tomcat，那么在第二台服务器上，肯定没有第一台服务器存放的session，所以此时 整个登录拦截功能就会出现问题，我们能如何解决这个问题呢？早期的方案是session拷贝，就是说虽然每个tomcat上都有不同的session，但是每当任意一台服务器的session修改时，都会同步给其他的Tomcat服务器的session，这样的话，就可以实现session的共享了
但是这种方案具有两个大问题
- 每台服务器中都有完整的一份session数据，服务器压力过大。
- session拷贝数据时，可能会出现延迟
所以我们后面都是基于Redis来完成，我们把session换成Redis，Redis数据本身就是共享的，就可以避免session共享的问题了
Redis替代session的业务流程
整体访问流程
- 当注册完成后，用户去登录，然后校验用户提交的手机号/邮箱和验证码是否一致
- 如果一致，则根据手机号查询用户信息，不存在则新建，最后将用户数据保存到Redis，并生成一个token作为Redis的key
- 当我们校验用户是否登录时，回去携带着token进行访问，从Redis中获取token对应的value，判断是否存在这个数据
- 如果不存在，则拦截
- 如果存在，则将其用户信息(userDto)保存到threadLocal中，并放行
基于Redis实现短信登录
定义的常量类
public class RedisConstants {
public static final String LOGIN_CODE_KEY = "login:code:";
public static final Long LOGIN_CODE_TTL = 2L;
public static final String LOGIN_USER_KEY = "login:token:";
public static final Long LOGIN_USER_TTL = 36000L;
public static final Long CACHE_NULL_TTL = 2L;
public static final Long CACHE_SHOP_TTL = 30L;
public static final String CACHE_SHOP_KEY = "cache:shop:";
public static final String LOCK_SHOP_KEY = "lock:shop:";
public static final Long LOCK_SHOP_TTL = 10L;
public static final String SECKILL_STOCK_KEY = "seckill:stock:";
public static final String BLOG_LIKED_KEY = "blog:liked:";
public static final String FEED_KEY = "feed:";
public static final String SHOP_GEO_KEY = "shop:geo:";
public static final String USER_SIGN_KEY = "sign:";
}- 修改sendCode方法
- session.setAttribute(phone, code);
- stringRedisTemplate.opsForValue().set("login:code:" + phone, code, 2, TimeUnit.MINUTES);
+ stringRedisTemplate.opsForValue().set(LOGIN_CODE_KEY + phone, code, LOGIN_CODE_TTL, TimeUnit.MINUTES);- 修改login方法
@PostMapping("/login")
public Result login(@RequestBody LoginFormDTO loginForm, HttpSession session) {
// TODO 实现登录功能
//获取登录账号
String phone = loginForm.getPhone();
//获取登录验证码
String code = loginForm.getCode();
//获取redis中的验证码
String cacheCode = stringRedisTemplate.opsForValue().get(LOGIN_CODE_KEY + phone);
//1. 校验邮箱
if (RegexUtils.isEmailInvalid(phone)) {
//2. 不符合格式则报错
return Result.fail("邮箱格式不正确！！");
}
//3. 校验验证码
log.info("code:{},cacheCode{}", code, cacheCode);
if (cacheCode == null || !cacheCode.equals(code)) {
// 不一致，报错
return Result.fail("验证码错误");
}
//5. 根据账号查询用户是否存在
LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.eq(User::getPhone, phone);
User user = userService.getOne(queryWrapper);
//6. 如果不存在则创建
if (user == null) {
user = createUserWithPhone(phone);
}
//7. 保存用户信息到session中
//7. 保存用户信息到Redis中
//7.1 随机生成token，作为登录令牌
String token = UUID.randomUUID().toString();
//7.2 将UserDto对象转为HashMap存储
UserDTO userDTO = BeanUtil.copyProperties(user, UserDTO.class);
HashMap<String, String > userMap = new HashMap<>();
userMap.put("icon", userDTO.getIcon());
userMap.put("id", String.valueOf(userDTO.getId()));
userMap.put("nickName", userDTO.getNickName());
//高端写法，现在我还学不来，工具类还不太了解，只能自己手动转换类型然后put了
// Map<String, Object> userMap = BeanUtil.beanToMap(userDTO, new HashMap<>(),
// CopyOptions.create()
// .setIgnoreNullValue(true)
// .setFieldValueEditor((fieldName, fieldValue) -> fieldValue.toString()));
//7.3 存储
String tokenKey = LOGIN_USER_KEY + token;
stringRedisTemplate.opsForHash().putAll(tokenKey, userMap);
//7.4 设置token有效期为30分钟
stringRedisTemplate.expire(tokenKey, 30, TimeUnit.MINUTES);
//7.5 登陆成功则删除验证码信息
stringRedisTemplate.delete(LOGIN_CODE_KEY + phone);
//8. 返回token
return Result.ok(token);
}解决状态登录刷新问题
优化方案
- 既然之前的拦截器无法对不需要拦截的路径生效，那么我们可以添加一个拦截器，在第一个拦截器中拦截所有的路径，把第二个拦截器做的事情放入到第一个拦截器中，同时刷新令牌，因为第一个拦截器有了threadLocal的数据，所以此时第二个拦截器只需要判断拦截器中的user对象是否存在即可，完成整体刷新功能。
- 新建一个
RefreshTokenInterceptor类，其业务逻辑与之前的LoginInterceptor类似，就算遇到用户未登录，也继续放行，交给LoginInterceptor处理
由于这个对象是我们手动在WebConfig里创建的，所以这里不能用@AutoWired自动装配，只能声明一个私有的，到了WebConfig里再自动装配
public class RefreshTokenInterceptor implements HandlerInterceptor {
//这里并不是自动装配，因为RefreshTokenInterceptor是我们手动在WebConfig里new出来的
private StringRedisTemplate stringRedisTemplate;
public RefreshTokenInterceptor(StringRedisTemplate stringRedisTemplate) {
this.stringRedisTemplate = stringRedisTemplate;
}
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
//1. 获取请求头中的token
String token = request.getHeader("authorization");
//2. 如果token是空，直接放行，交给LoginInterceptor处理
if (StrUtil.isBlank(token)) {
return true;
}
String key = RedisConstants.LOGIN_USER_KEY + token;
//3. 基于token获取Redis中的用户数据
Map<Object, Object> userMap = stringRedisTemplate.opsForHash().entries(key);
//4. 判断用户是否存在，不存在，也放行，交给LoginInterceptor
if (userMap.isEmpty()) {
return true;
}
//5. 将查询到的Hash数据转化为UserDto对象
UserDTO userDTO = BeanUtil.fillBeanWithMap(userMap, new UserDTO(), false);
//6. 将用户信息保存到ThreadLocal
UserHolder.saveUser(userDTO);
//7. 刷新tokenTTL，这里的存活时间根据需要自己设置，这里的常量值我改为了30分钟
stringRedisTemplate.expire(key, RedisConstants.LOGIN_USER_TTL, TimeUnit.MINUTES);
return true;
}
@Override
public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
UserHolder.removeUser();
}
}- 修改我们之前的
LoginInterceptor类，只需要判断用户是否存在，不存在，则拦截，存在则放行
public class LoginInterceptor implements HandlerInterceptor {
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
//判断用户是否存在
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();
}
}- 修改
WebConfig配置类，拦截器的执行顺序可以由order来指定，如果未设置拦截路径，则默认是拦截所有路径
@Configuration
public class MvcConfig implements WebMvcConfigurer {
//到了这里才能自动装配
@Autowired
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);
//RefreshTokenInterceptor是我们手动new出来的
registry.addInterceptor(new RefreshTokenInterceptor(stringRedisTemplate)).order(0);
}
}至此，完成！
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
