Session-526互联

Java中的Session是一种用于跟踪用户状态（根据session是否存在信息判断登录状态）和在多个请求之间共享数据（存在session对象的信息）的机制。

用户短信验证码登录是基于sesion登录的，发请求访问Tomcat的时候,sessionid已经自动写到cookie中，以后再请求都会带着这个sessionid,就可以找到这个session对象。拿到里面的用户状态信息。

拦截器LoginInterceptor.java

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 {
        HandlerInterceptor.super.afterCompletion(request, response, handler, ex);
    }
}

View Code

配置拦截器MvcConfig.java

@Configuration
public class MvcConfig implements WebMvcConfigurer {

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new LoginInterceptor())
                .excludePathPatterns(
                        "/shop/**",
                        "/voucher/**",
                        "/shop-type/**",
                        "/upload/**",
                        "/blog/hot",
                        "/user/code",
                        "/user/login"
                );
    }
}

View Code

登录校验功能

@GetMapping("/me")
    public Result me(){
        // 获取当前登录的用户并返回
        UserDTO user = UserHolder.getUser();
        return Result.ok(user);
    }

集群的session共享问题

每个tomcat中都有一份属于自己的session,假设用户第一次访问第一台tomcat，并且把自己的信息存放到第一台服务器的session中，但是第二次这个用户访问到了第二台tomcat，那么在第二台服务器上，肯定没有第一台服务器存放的session，所以此时整个登录拦截功能就会出现问题，我们能如何解决这个问题呢？早期的方案是session拷贝，就是说虽然每个tomcat上都有不同的session，但是每当任意一台服务器的session修改时，都会同步给其他的Tomcat服务器的session，这样的话，就可以实现session的共享了

　　但是这种方案存在两大问题：

每台服务器中都有完整的一份session数据，服务器压力过大。
session拷贝数据时，可能会出现延迟

　　解决方案：

基于Redis来完成，我们把session换成Redis，Redis数据本身就是共享的，就可以避免session共享的问题了。
使用Redis的原因：数据共享、内存存储、key-value结构。

基于Redis实现共享Session登录

用户登录--生成token--存入redis--返回token

需在登录状态下才能使用的功能，前端发来请求时，需先校验登录状态：

根据携带的token查询用户数据--数据存在与否=是否登录

--有则将信息线程隔离化

--无则拦截

发送短信将验证码保存到redis

// 4.保存验证码到redis
        //session.setAttribute("code", code);
        stringRedisTemplate.opsForValue().set(LOGIN_CODE_KEY + phone, code, LOGIN_CODE_TTL, TimeUnit.MINUTES);

短信验证码登录

@Override
    public Result login(LoginFormDTO loginForm, HttpSession session) {
        // 1.校验手机号
        String phone = loginForm.getPhone();
        if (RegexUtils.isPhoneInvalid(phone)) {
            return Result.fail("手机号格式错误");
        }
        // 2，校验验证码
        Object cacheCode = stringRedisTemplate.opsForValue().get(LOGIN_CODE_KEY + phone);
        //Object cacheCode = session.getAttribute("code");
        String code = loginForm.getCode();
        if (cacheCode == null || !cacheCode.equals(code)) {
            // 3.不一致，报错
            return Result.fail("验证码错误");
        }

        // 4.一致，根据手机号查询用户
        User user = query().eq("phone", phone).one();

        // 5.判断用户是否存在
        if (user == null) {
            // 6.不存在，创建新用户并保存
            user = createUserWithPhone(phone);
        }

        // 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);
        // 7.3 存储
        stringRedisTemplate.opsForHash().putAll(LOGIN_USER_KEY + token, userMap);
        // 7.4 设置token有效期
        stringRedisTemplate.expire(LOGIN_USER_KEY + token, LOGIN_USER_TTL, TimeUnit.MINUTES);
        //session.setAttribute("user", BeanUtil.copyProperties(user, UserDTO.class));
        // 8.返回token
        return Result.ok(token);
    }

View Code

登陆拦截功能

public class LoginInterceptor implements HandlerInterceptor {


    private StringRedisTemplate stringRedisTemplate;

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

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        // 1.获取请求头的token
        String token = request.getHeader("authorization");
        if (StrUtil.isBlank(token)) {
            // 不存在，拦截，返回401状态码
            response.setStatus(401);
            return false;
        }
        // 2.基于token获取redis中的用户
        Map<Object, Object> userMap = stringRedisTemplate.opsForHash().entries(RedisConstants.LOGIN_USER_KEY + token);
        // 3.判断用户是否存在
        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);

        // 7.刷新cookie的有效期
        stringRedisTemplate.expire(RedisConstants.LOGIN_USER_KEY + token, RedisConstants.LOGIN_USER_TTL, TimeUnit.MINUTES);

        // 8.放行
        return true;
    }

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

View Code

@Configuration
public class MvcConfig implements WebMvcConfigurer {

    @Resource
    private StringRedisTemplate stringRedisTemplate;

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new LoginInterceptor(stringRedisTemplate))
                .excludePathPatterns(
                        "/shop/**",
                        "/voucher/**",
                        "/shop-type/**",
                        "/upload/**",
                        "/blog/hot",
                        "/user/code",
                        "/user/login"
                );
    }
}

View Code

问题：只有经过拦截器时redis才刷新，如果访问的是不经过拦截器的url，则redis不会刷新。

解决方法：加一个新拦截器，确保一切请求都会触发刷新redi

redis刷新拦截器

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");
        if (StrUtil.isBlank(token)) {
            return true;
        }
        // 2.基于token获取redis中的用户
        Map<Object, Object> userMap = stringRedisTemplate.opsForHash().entries(RedisConstants.LOGIN_USER_KEY + token);
        // 3.判断用户是否存在
        if (userMap.isEmpty()) {
            return true;
        }
        // 5.将查询到的Hash数据转换为UserDTO对象
        UserDTO userDTO = BeanUtil.fillBeanWithMap(userMap, new UserDTO(), false);
        // 6.存在，保存用户到ThreadLocal
        UserHolder.saveUser(userDTO);

        // 7.刷新cookie的有效期
        stringRedisTemplate.expire(RedisConstants.LOGIN_USER_KEY + token, RedisConstants.LOGIN_USER_TTL, TimeUnit.MINUTES);

        // 8.放行
        return true;
    }

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

View Code

登录拦截器

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;
}
}

@Configuration
public class MvcConfig implements WebMvcConfigurer {

    @Resource
    private StringRedisTemplate stringRedisTemplate;

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new LoginInterceptor())
                .excludePathPatterns(
                        "/shop/**",
                        "/voucher/**",
                        "/shop-type/**",
                        "/upload/**",
                        "/blog/hot",
                        "/user/code",
                        "/user/login"
                ).order(1);
        registry.addInterceptor(new RefreshTokenInterceptor(stringRedisTemplate)).order(0);
    }
}

View Code

session内容补充：

在Java中，Session数据通常存储在服务器端。具体来说，Session数据可以存储在内存中，也可以存储在数据库或其他持久化存储中。

当用户访问Web应用程序时，服务器会为该用户创建一个Session对象，并将一些属性存储在该Session对象中。这些属性可以包含用户的状态信息、购物车中的商品信息等。

在默认情况下，Session数据会存储在服务器的内存中。当服务器重启或Session超时时，这些数据会丢失。为了解决这个问题，可以将Session数据存储在数据库或其他持久化存储中，以便在服务器重启或Session超时时能够恢复数据。

Session的优点主要包括以下几点：

唯一性：每个客户端在服务器端都会生成唯一的session_id，这个session_id是唯一的，不会和其他客户端混淆。
方便调用：在任何页面都可以方便地调用session，不需要传递参数，只需要通过session_id就可以获取到存储在服务器端的数据。
不会过多占用资源：session是存储在服务器端的一组临时数据，不会占用客户端的资源。
安全性：由于session是存储在服务器端的数据，因此可以有效地防止恶意用户通过修改客户端数据来获取敏感信息。

综上所述，Session的优点在于唯一性、方便调用、不会过多占用资源以及安全性。

Session的缺点主要包括以下几点：

服务器资源消耗：Session需要将所有状态都写在服务器端，这会增加服务器的资源消耗，尤其是在并发访问量大的时候，服务器可能会因为过多的Session而变得压力巨大。
无法跨服务器共享：Session无法在不同的服务器之间共享，如果需要在多个服务器之间共享状态，需要进行额外的处理，比如使用分布式缓存方案，如Redis集群保存Session。
数据类型限制：Session只能保存数据类型为String的字符串，对于其他类型的数据，需要进行序列化后再保存。
数据大小限制：Session保存的数据大小有限制，一般来说，单个Session的大小不能超过服务器内存的大小，否则会导致内存溢出。
数据安全问题：如果Session中保存了敏感信息，比如用户密码等，可能会被黑客窃取，因此需要采取额外的安全措施来保护Session数据。

综上所述，虽然Session在某些情况下可以方便地实现用户状态的保持，但是也存在一些缺点需要注意。

针对Session的缺点，可以采取以下措施来解决：

使用缓存或分布式缓存方案：将Session数据存储在缓存或分布式缓存中，可以减轻服务器资源消耗，并实现跨服务器共享状态。例如，使用Redis等分布式缓存方案，可以将Session数据存储在Redis集群中，实现高可用性和可扩展性。
限制Session大小：可以通过限制单个Session的大小来避免内存溢出问题。例如，可以设置Session的最大大小，当Session数据超过限制时，可以将其保存到数据库或其他持久化存储中。
加密Session数据：为了保护Session数据的安全性，可以对Session数据进行加密处理。例如，可以使用对称加密算法或非对称加密算法对Session数据进行加密，以防止黑客窃取敏感信息。
使用短Session和频繁的Session续约：为了避免Session过期导致的问题，可以使用短Session和频繁的Session续约。例如，可以设置Session的较短的有效期，并在每个请求处理完成后进行续约，以确保Session不会过期。
启用Cookie的安全选项：在Cookie中启用安全选项可以保护Session数据的安全性。例如，可以将Cookie设置为HttpOnly属性，以防止JavaScript等客户端脚本访问Cookie数据。

综上所述，通过使用缓存或分布式缓存方案、限制Session大小、加密Session数据、使用短Session和频繁的Session续约以及启用Cookie的安全选项等措施，可以有效地解决Session的缺点。