一、导入黑马点评项目

1. 数据库：

⚫ tb_user：用户表

⚫ tb_user_info：用户详情表

⚫ tb_shop：商户信息表

⚫ tb_shop_type：商户类型表

⚫ tb_blog：用户日记表（达人探店日记）

⚫ tb_follow：用户关注表

⚫ tb_voucher：优惠券表

⚫ tb_voucher_order：优惠券的订单表

2. 单体项目介绍：

案例是：前后端分离的单体项目，后端部署在Tomcat，前端部署在Nginx服务器上。

当移动端、客户端、app端发起Nginx请求，得到静态资源。页面再通过Nginx，向服务端发起请求，进行查询数据。查询后，返回给前端，前端在进行渲染。



开启Nginx:


D:\Program Files\Nginx_Test\nginx-1.18.0> start .\nginx.exe


二、基于session实现登录

短信登录包括：

1. 短信的发送
2. 基于短信验证码的登录、注册
3. 对登录状态的校验

1、发送短信验证码

1.理论流程

用户通过手机进行获取验证码，进行登录。

1.那么用户会根据手机号请求一个验证码

2.服务端接收到手机号后，进行验证手机号。

2.1校验失败，重新写手机号

2.2校验成功，服务端生成验证码

3.保存验证码到session

4.发送验证码

请求路径：api是表示当前的请求，是一个发向Tomcat服务的请求，会过滤掉。真正的请求路径是：/user/code

请求参数：phone=888888

2.代码操作：

controller层：
    @PostMapping("code")
    public Result sendCode(@RequestParam("phone") String phone, HttpSession session) {
        /**
         *  发送短信验证码并保存验证码
         *  session：需要把验证码保存到session
         */
        return userService.sendCode(phone,session);
    }
    

----------------------sever层-----------------------



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>
 *
 */
@Slf4j
@Service
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements IUserService {
    @Override
    public Result sendCode(String phone, HttpSession session) {
        //1. 验证手机号
        // RegexUtils 是一个工具类，直接将前端传过来的电话，传过去，判断手机格式字是否正常
        // 如果返回false 是手机号格式正常。 返回true，是手机号错误。
        if (RegexUtils.isPhoneInvalid(phone)){
            //2. 验证不通过返回错误提示
            log.debug("验证码错误.....");
            return Result.fail("手机号错误，请重新填写");
        }
        //3. 验证通过，生成验证码
        // RandomUtil 是一个工具包。该方法生成6位随机数
        String code = RandomUtil.randomNumbers(6);
        //4. 保存验证码到session
        session.setAttribute("code",code);
        //5. 发送验证码
        log.debug("验证码发送成功,{}",code);
        return Result.ok();
    }
}
---------手机号正则---------------
public static final String PHONE_REGEX = "^1([38][0-9]|4[579]|5[0-3,5-9]|6[6]|7[0135678]|9[89])\\d{8}$";

2、短信验证码登录、注册

1.理论流程

用户收到了验证码，就可以进行登录或者注册了。

1.用户将手机号和验证码进行提交。

2.服务端进行校验验证码。从session中取出验证码进行比较

2.1比较失败，拒绝登录

2.2比较成功，说明验证码填写的是正确的，但是手机号不能确定是否正确。

3.根据手机号查询用户信息。用户是否存在

3.1如果不存在说明该用户第一次登录，那么为该用户注册成新的用户。然后在进行登录。

3.2该用户以及存在了，可也进行登录

4.登录-》保存用户信息。保存到session中。

2.代码操作：

-----------controller ---------
    /**
     * 登录功能
     * @RequestBody注解: 前端穿过来的是JSON格式，就必须用requestBody注解。并且实体类来接受
     * @param loginForm 登录参数，包含手机号、验证码；或者手机号、密码.
     * session:登录的时候需要把用户信息存到session，验证码校验也需要用到session
     */
    @PostMapping("/login")
    public Result login(@RequestBody LoginFormDTO loginForm, HttpSession session){
        //  实现登录功能
        return userService.login(loginForm,session);
    }

------------service-------------------------

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)){
            //2.如果不正确则直接返回错误
            log.debug("手机号:{}错误",phone);
            Result.fail("手机号格式错误");
        }
        //3. 判断验证码是否一致，session中对比
        //从session中获取验证码，也就是后端生成的验证码
        Object cacheCode = session.getAttribute("code");
        //前端传过来的验证码
        String code = loginForm.getCode();
        //如果验证码为空，或者不一致，则返回验证码错误
        if (code ==null || cacheCode.toString().equals(code) ){
            log.debug("验证码:{}错误",code);
            Result.fail("验证码错误");
        }
        //4. 用户是否存在  select * from t_user where phone=?
        // 查询表t_user，当“表中字段”中有等于phone的信息，进行查询处理，查询一条。返回的是一个user实体类
        User user = query().eq("phone", phone).one();
        //5 如果用户不存在则创建用户，保存到数据库
        if (user == null){
            user = createUser(phone);
        }
        //5. 如果用户存在，保存到session
        session.setAttribute("user",user);
        return Result.ok();
    }

    /**
     * 创建用户，添加到数据库中
     * @param phone
     * @return
     */
    private User createUser(String phone) {
        User user = new User();
        user.setPhone(phone);
        user.setNickName(USER_NICK_NAME_PREFIX+RandomUtil.randomString(10));
        //将用户信息插入到 t_user表中
        save(user);
        return  user;
    }

3、校验登录状态

1.理论流程

用户登录成功后，在进行访问其他页面的的时候，需要进行校验登录状态。

1.基于session进行校验。 基于cookie中的session的id，拿到session。

之前将用户信息保存到了session。session是基于cookie,每个session都有一个id，保存在浏览器的cookie当中。

当用户来访问其他页面时，那么就会携带着自己的cookie，而cookie有session的id。那么就可以基于session中的id，拿到session。从而在session中获取用户信息。

2.判断session有无用户

2.1如果没有，则拦截请求

2.2如果有，则缓存用户信息，将用户信息保存到ThreadLocal。这样其他业务就可以直接从ThreadLoad中获取用户信息。

ThreadLoad是线程域对象，在业务当中，每一个请求到达微服务，都会是一个独立的线程。

ThreadLoad会将数据保存到每一个线程的内部，在线程内部创建一个map来保存。

每一个请求来了以后，都有独立的存储空间，请求之间相互没有干扰。

3.放行。

后续其他请求，就可以从ThreadLoad中取出自己的用户信息

前端在请求接口时，会携带cookie。而登录的凭证就是session的id，而该id是存在cookie其中。

那么服务端根据这个session的id得到session。

从session中获取用户信息。

在根据该用户信息去数据库判断，有无该用户，

如果没有则拦截。

如果有，则保护信息到ThreadLoad，在进行放行；

在springmvc中，

拦截器

可以在所有controller执行前，进行执行。

那么所有的请求，先经过拦截器，在进行访问各个controller。

拦截器：实现用户登录的校验。

–校验后：

那么后续的业务当中【比如说订单、点赞、评论】，都是需要用户的信息

所有说各个controller也需要的到用户信息。

那么就需要将拦截器拦截后得到的信息，传给各个controller。 需要注意的是：线程安全

–解解方法：ThreadLoad

当拦截器拦截了用户信息后，将用户信息保存到ThreadLoad。

ThreadLoad是一个线程域对象，每一个进入Tomcat的请求都是一个独立的线程。

ThreadLoad就会在线程内开一个内存空间，进行保存对应的用户。这样每个用户相互不干扰

– controller需要用到用户信息时，在从ThreadLoad中取出用户

2.代码操作：

-----------------拦截器：----------
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;

/**
 * 用户登录拦截器
 * @Author Hu
 */
public class LoginInterceptor implements HandlerInterceptor {
    /**
     * pre：前置拦截。 进入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. 从session中获取用户信息
        Object user = session.getAttribute("user");
        //3. 判断用户是否存在
        if (user == null ){
            //4. 如果不存在，则拦截
            response.setStatus(401);
            return false;
        }
        //5. 如果存在则保存到ThreadLoad
        UserHolder.saveUser((User) user);
        //6. 放行
        return true;
    }

    /**
     * 渲染之后，返回用户之前。 用户执行完毕后，销毁对应的用户信息。
     * 避免用户泄露
     * @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();
    }
}

-----------配置拦截器的configuration-----------
package com.hmdp.config;

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

/**
 * 配置拦截器
 * 可以让LoginInterceptor拦截器生效。
 *
 */
@Configuration
public class MvcConfiguration implements WebMvcConfigurer {
    /**
     * 添加拦截器
     * @param registry
     */
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        //添加拦截器
        InterceptorRegistration interceptorRegistration = registry.addInterceptor(new LoginInterceptor());
        // 添加配置可以放行哪些路径
        interceptorRegistration.excludePathPatterns(
                "/shop/**",
                "/voucher/**",
                "/shop-type/**",
                "/upload/**",
                "/blog/hot",
                "/user/code",
                "/user/login"
        );

    }
}

----------------controller类进行返回用户信息--------
    @GetMapping("/me")
    public Result me(){
        //  获取当前登录的用户并返回
        return Result.ok(UserHolder.getUser());
    }
----ThreadLoad类的信息------该信息是隐藏了用户信息累的实体类

package com.hmdp.utils;

import com.hmdp.dto.UserDTO; 

/**
 * 创建ThreadLoad
 */
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();
    }
}

3.隐藏用户敏感信息

登录校验功能，返回的信息比较多。比如密码这些重要信息不应该进行返回到前端。

为什么前端收到了所有的用户信息？


从后往前推：

1. controller接口：校验成功后，将用户信息返回给前端，返回的是User完整的信息。而user信息是从UserHolder中得到的
2. 拦截器： 从session中获取的用户信息，就是完整的用户信息。直接通过UserHolder的save方法，将所有的用户信息，添加到了拦截器。
3. 那么谁给session存的信息呢？是登录业务时：从数据库中查询了所有的用户信息。直接放到了session中。

解决方法：


4. 也就是上的第三步：将数据库查询出来的用户信息，放到新pojo类中，在放到session中。

5. 也就是第二步：获取session中的就是UserDTo了。不在是整个user用户信息了

改动的代码：

三、集群的session共享问题

session共享问题：多台Tomcat并不共享session共享空间，当请求切换到不同Tomcat服务时导致数据丢失的问题。

存储到ATomcat服务器时，在其他的Tomcat服务器中是看不到的。

四、基于redis实现共享session登录

1、发送验证码。如何将验证码存入到redis中？

• redis的数据类型：用String类型
  
  验证码就是6位数字。
• Redis的Key：手机号
  
  确保每一个手机号来验证时，保存的key都是不一样的。那么就用每一个手机号来作为redis的key。
  
  当登录时，取验证码时，将前端传过来的手机号作为key，来获取验证码，进行比较登录成功。
• Redis的value：就是验证码

代码操作：

2、验证码登录。如何将用户信息保存到redis

• 数据类型：hash
  
  保存的是用户信息，用户对象。
• redis的key：随机token为key存储用户数据。比如用UUID来生成。
  
  key的要求：key唯一
• redis的value：保存整个用户信息

String类型：把java对象序列化为Jason字符串，保存在redis。看起来简单，把整个JSON数据变成一个字符串了。占用内存多，除了保存自身外，还有JSON串的格式，比如冒号、大括号

hash类型：value是一个hashMap类型。把java中每一个字段保存在redis。每个字段是独立的，可以针对单个字段做CRUD。占用更少的内存。只需要保存数据本身就可以了。

代码操作：

-----用户登录service层---------- 
    /**
     * 进行登录功能
     * @param loginForm 前端传来的用户信息
     * @param session
     * @return
     */
    @Override
    public Result login(LoginFormDTO loginForm, HttpSession session) {
        //1. 判断手机号格式是否正确
        String phone = loginForm.getPhone();
        if (RegexUtils.isPhoneInvalid(phone)){
            //2.如果不正确则直接返回错误
            log.debug("手机号:{}错误",phone);
            Result.fail("手机号格式错误");
        }
        /*//3. 判断验证码是否一致，session中对比
        //从session中获取验证码，也就是上面方法获取验证码时，后端生成的验证码
        Object cacheCode = session.getAttribute("code");*/

        // 3. 从redis中获取验证码
        String cacheCode = stringRedisTemplate.opsForValue().get(LOGIN_CODE_KEY+phone);

        String code = loginForm.getCode();
        // 4. 如果验证码为空，或者不一致，则返回验证码错误
        if (code ==null || !cacheCode.equals(code) ){
            log.debug("验证码:{}的错误",code);
            return Result.fail("验证码错误");
        }
        //5. 用户是否存在  select * from t_user where phone=?
         /*查询表t_user，当“表中字段”中有等于phone的信息，进行查询处理，查询一条。返回的是一个user实体类*/
        User user = query().eq("phone", phone).one();
        //6 如果用户不存在则创建用户，保存到数据库
        if (user == null){
            // 6.如果用户不存在则创建用户，保存到数据库
            user = createUser(phone);
        }

        /*//7. 如果用户存在，保存到session。
        // 通过hutool类中的对象，将用户的部分信息放到session中。
        session.setAttribute("user",BeanUtil.copyProperties(user, UserDTO.class)); */

        // 7.如果用户存在，以hash的形式保存到redis中
        // 7.1生成token，作为登录令牌
        String token = UUID.randomUUID().toString(true);
        //7.2 将User对象转为Hash存储. UserDTO是用户的部分信息，发送给前端即可。
        UserDTO userDTO = BeanUtil.copyProperties(user, UserDTO.class);
        /**
         * beanToMap是将user实体类转为HashMap类型
         * 而StringRedisTemplate<string,string>都是string类型。而userDTO中的id是Long类型，所以报错了
         * 允许对key/value进行自定义
         *  对字段值的修改器，修改字段值
         */
        Map<String, Object> userMap = BeanUtil.beanToMap(userDTO,new HashMap<>(), CopyOptions.create()
                .setIgnoreNullValue(true) // 忽略空的值
                .setFieldValueEditor((fieldName,fieldVaule)->fieldVaule.toString()));

        //7.3 存储用户信息，保存到redis中。 key：token, key:value是用户信息
        String tokenKey = LOGIN_USER_KEY+ token;
        stringRedisTemplate.opsForHash().putAll(tokenKey,userMap);
        //7.4 为该key，设置有效期
        stringRedisTemplate.expire(tokenKey,LOGIN_USER_TTL, TimeUnit.MINUTES);
        // 8 将token，返回给前端
        return Result.ok(token);
    }

    /**
     * 创建用户，添加到数据库中
     * @param phone
     * @return
     */
    private User createUser(String phone) {
        User user = new User();
        user.setPhone(phone);
        user.setNickName(USER_NICK_NAME_PREFIX+RandomUtil.randomString(10));
        //将用户信息插入到 t_user表中
        save(user);
        return  user;
    }

3、校验登录功能。获取用户信息中的token【hash的key】

将redis中token返回给前端。访问接口时就会携带这token来访问接口，服务端就会根据token，获取用户信息。在进行判断是否存在，能否访问接口等等校验功能，以及业务代码功能。

代码操作：

-------interceptor拦截器代码：-------------
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.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import java.util.Map;
import java.util.concurrent.TimeUnit;

/**
 * 用户登录拦截器
 * @Author Hu
 */
public class LoginInterceptor implements HandlerInterceptor {
    /**
     * pre：前置拦截。 进入controller执行，进行校验。
     * @param request
     * @param response
     * @param handler
     * @return
     * @throws Exception
     */
    private StringRedisTemplate stringRedisTemplate;

    public LoginInterceptor(StringRedisTemplate stringRedisTemplate) {
        this.stringRedisTemplate = stringRedisTemplate;
    }

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        // 1. 获取session对象
        String token = request.getHeader("authorization");
        if (StrUtil.isBlank(token)){
            return false;
        }
        // 2. 基于token，获取用户信息
        String redisKey = RedisConstants.LOGIN_USER_KEY+token;
        Map<Object, Object> userMap = stringRedisTemplate.opsForHash().entries(redisKey);
        //3. 判断用户是否存在
        if (userMap.isEmpty() ){
            //4. 如果不存在，则拦截
            response.setStatus(401);
            return false;
        }
        //5.将查询到的Hash类型数据，转换为userDTO对象
        UserDTO userDTO = BeanUtil.fillBeanWithMap(userMap, new UserDTO(), false);

        // 6.将userDTO对象，保存到ThreadLoad
        UserHolder.saveUser(userDTO);
        //7. 刷新token有效值
        stringRedisTemplate.expire(redisKey,RedisConstants.LOGIN_USER_TTL, TimeUnit.MINUTES);
        // 8.放行
        return true;
    }

    /**
     * 渲染之后，返回用户之前。 用户执行完毕后，销毁对应的用户信息。
     * 避免用户泄露
     * @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();
    }
}

在拦截器中：不能使用@Aotuwired、@Resurces注解，自动导入。

因为interceptor拦截器类是手动new出来的，并不是@Component、@Configuration等注解来构建的。也就是说不是由spring来构建的，就不能进行依赖注入。

所以说通过构造函数注入，谁来注入呢？那就是谁用了类，谁就来注入该类。而MVC的configuration拦截器用到了。从而mvcConfig来帮助redisTemplate来注入到spring中。

4、测试：

五、登录拦截器的优化

用户访问任何一个页面，都会进行刷新登录token的倒计时：

----------拦截所有请求，都进行刷新token----------
package com.hmdp.utils;

import cn.hutool.core.bean.BeanUtil;
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 {

    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获取对象用户信息
        String redisKey = RedisConstants.LOGIN_USER_KEY+token;
        Map<Object, Object> userMap = stringRedisTemplate.opsForHash().entries(redisKey);
        //3.判断用户是否存在
        if (userMap.isEmpty()){
            return true;
        }
        // 4. 将查询到的userMap转为UserDTO
        UserDTO userDTO = BeanUtil.fillBeanWithMap(userMap, new UserDTO(), false);
        // 5. 存在，将用户信息存入ThreadLoad
        UserHolder.saveUser(userDTO);
        // 6. 刷新token有效期
        stringRedisTemplate.expire(redisKey,RedisConstants.LOGIN_USER_TTL, TimeUnit.MINUTES);
        // 7.放行
        return  true;

    }

    /**
     * 渲染之后，返回用户之前。 用户执行完毕后，销毁对应的用户信息。
     * 避免用户泄露
     * @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();
    }
}



---------拦截部分请求，刷洗token---------
package com.hmdp.utils;

import org.springframework.web.servlet.HandlerInterceptor;

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

/**
 * 用户登录拦截器
 * @Author Hu
 */
public class LoginInterceptor implements HandlerInterceptor {

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        // 1. 判断是否拦截： 查看ThreadLoad是否有用户
        if (UserHolder.getUser() == null){
            response.setStatus(401);
            return false;
        }
        // 8.放行
        return true;
    }


}

--------mvcConfig配置拦截器：
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.InterceptorRegistration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

/**
 * 配置拦截器
 * 可以让LoginInterceptor拦截器生效。
 *
 */
@Configuration
public class MvcConfiguration implements WebMvcConfigurer {
    /**
     * 添加拦截器
     * @param registry
     */
    @Autowired
    private StringRedisTemplate stringRedisTemplate;
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        //添加登录拦截器。 拦截部分请求，优先级低
        InterceptorRegistration interceptorRegistration = registry.addInterceptor(new LoginInterceptor());
        // 添加配置可以放行哪些路径
        interceptorRegistration.excludePathPatterns(
                "/shop/**",
                "/voucher/**",
                "/shop-type/**",
                "/upload/**",
                "/blog/hot",
                "/user/code",
                "/user/login"
        ).order(1);
        // 添加刷新拦截所有请求。 设置优先级高于 拦截部分请求
        registry.addInterceptor(new RefreshTokenInterceptor(stringRedisTemplate)).addPathPatterns("/**").order(0);

    }
}