疯狂创客圈 Java 高并发【 亿级流量聊天室实战】实战系列 【博客园总入口 】
架构师成长+面试必备之 高并发基础书籍 【Netty Zookeeper Redis 高并发实战 】
前言
Crazy-SpringCloud 微服务脚手架 &视频介绍：
Crazy-SpringCloud 微服务脚手架，是为 Java 微服务开发 入门者 准备的 学习和开发脚手架。并配有一系列的使用教程和视频，大致如下：
高并发 环境搭建 图文教程和演示视频，陆续上线：
| 中间件 | 链接地址 |
|---|---|
| Linux Redis 安装（带视频） | Linux Redis 安装（带视频） |
| Linux Zookeeper 安装（带视频） | Linux Zookeeper 安装, 带视频 |
| Windows Redis 安装（带视频） | Windows Redis 安装（带视频） |
| RabbitMQ 离线安装（带视频） | RabbitMQ 离线安装（带视频） |
| ElasticSearch 安装, 带视频 | ElasticSearch 安装, 带视频 |
| Nacos 安装（带视频） | Nacos 安装（带视频） |
Crazy-SpringCloud 微服务脚手架 图文教程和演示视频，陆续上线：
| 组件 | 链接地址 |
|---|---|
| Eureka | Eureka 入门，带视频 |
| SpringCloud Config | springcloud Config 入门，带视频 |
| spring security | spring security 原理+实战 |
| Spring Session | SpringSession 独立使用 |
| 分布式 session 基础 | RedisSession （自定义） |
| 重点： springcloud 开发脚手架 | springcloud 开发脚手架 |
| SpingSecurity + SpringSession 死磕 （写作中） | SpingSecurity + SpringSession 死磕 |
小视频以及所需工具的百度网盘链接，请参见 疯狂创客圈 高并发社群 博客
SpringSession 独立使用 的场景和问题
当Zuul网关接收到http请求后，当请求进入对应的Filter进行过滤，通过 SpringSecurity 认证后，提取 SessionID，转发给各个微服务，通过Spring-Session创建的分布式微服务，实现Session共享！
特点：
（1）浏览器和移动端，和Nginx代理，token 是可见的，但是 session 不可见。
（2）各个微服务，用到共享Session，sessionId是可见的。
（3）各个微服务，可以通过自定义的 SessionHolder 共享类，可以静态的取得分布式Session的公共数据，比如基础的用户信息。提升编程的效率。 具体请参见 SpringCloud 开发脚手架。
具体场景的请求处理流程：
问题：
问题一：需要定制ID解析器
场景1 ：如果Rest请求从Zuul 过来，Zuul 会在头部设置 sessionID，就是这个场景首先从head中去取
String headerValue = request.getHeader(this.headerName);
场景2： 如果是 单体微服务直接访问 ，就是这个场景 SpringSecurity 会将 sessionID，放在 attribute中。这种场景，直接从从attribute中去取sessionID
headerValue = (String) request.getAttribute(SessionConstants.SESSION_SEED);
SpringSession自带的 ID解析器 ，不能满足要求，需要重新定制一个。关于ID解析器，请参见 疯狂创客圈 的另一博文 SpringSession自带的 ID解析器 最全解读
问题二：需要定制sessionRepository 存储器
sessionRepository 负责存储 session 到Redis，需要修改模式为立即提交，以免setAttribute的属性，不能及时写入Redis，这是笔者调试了几个小时发现的坑
问题三：需要定制SessionRepositoryFilter 过滤器
将Session请求，保持到 SessionHolder 的 ThreadLocal 本地变量中，方便统一获取，方便编程。例如：
SessionHolder.getSessionUser().getLoginName());
直接从redissession，读取用户的名称，多方便呀。
总之： 使用集成的默认的SpringSession ，没有办法深入的解决问题。 有两种方法。
- 第一种是自制 分布式 Session。
具体请参考 疯狂创客圈 博客 分布式RedisSession 自制
这种方法的优点：简陋。 缺点：过于简陋。
在流程和思想上，和第下面的第二种是类似的，可供学习使用，方便理解。
- 第二种是 SpringSession 独立使用。
就是本文的内容。
说明： 第二种在流程和思想上第一种是类似的，可供学习使用，方便理解，建议先了解第一种，第二种就好掌握多了。
理论基础： springSession 原理
spring-session分为以下核心模块：
-
过滤器 SessionRepositoryFilter：Servlet规范中Filter的实现，用 Spring Session 替换原来的 HttpSession，具体的方式是使用了自己的两个包装器： HttpServletRequest 和HttpServletResponse。
-
包装器 HttpServerletRequest/HttpServletResponse/HttpSessionWrapper：包装原有的HttpServletRequest、HttpServletResponse和Spring Session，实现切换Session和透明继承HttpSession的关键之所在
-
Session：Spring Session模块
-
存储器 SessionRepository：负责 Spring Session的存储
具体见下图：
Spring Session模块
spring-session中则抽象出单独的Session层接口，让后再使用适配器模式将Session适配层Servlet规范中的HttpSession。
类图如下：
RedisSession 的本质：
内部封装一个 MapSession，MapSession 本质是一个 map。而 RedisSession 的主要职责：负责 MapSession中 Map 的K-V内容的 Redis 存储。
spring-session 原理，请参见博文
第1步： ID解析器 自定义
场景1 ：如果Rest请求从Zuul 过来，Zuul 会在头部设置 sessionID，就是这个场景首先从head中去取
String headerValue = request.getHeader(this.headerName);
场景2： 如果是 单体微服务直接访问 ，就是这个场景 SpringSecurity 会将 sessionID，放在 attribute中。这种场景，直接从从attribute中去取sessionID
headerValue = (String) request.getAttribute(SessionConstants.SESSION_SEED);
实现 HttpSessionIdResolver 接口，定义一个完整的ID解析器，代码如下：
package com.crazymaker.springcloud.standard.config;
//...省略import
@Data
public class CustomedSessionIdResolver implements HttpSessionIdResolver {
private RedisTemplate<Object, Object> redisTemplet = null;
private static final String HEADER_AUTHENTICATION_INFO = "Authentication-Info";
private final String headerName;
/**
* The name of the header to obtain the session id from.
*
*/
public CustomedSessionIdResolver() {
//设置 head头的名称
this.headerName = SessionConstants.SESSION_SEED;
if (headerName == null) {
throw new IllegalArgumentException("headerName cannot be null");
}
}
@Override
public List<String> resolveSessionIds(HttpServletRequest request) {
//step1：首先从head中去取sessionID
// 如果从Zuul 过来，就是这个场景
String headerValue = request.getHeader(this.headerName);
//step1：首先从attribute中去取sessionID
// 如果是 单体微服务直接访问 ，就是这个场景
//SpringSecurity 会将 sessionID，放在 attribute中
if (StringUtils.isEmpty(headerValue)) {
headerValue = (String) request.getAttribute(SessionConstants.SESSION_SEED);
if (!StringUtils.isEmpty(headerValue)) {
headerValue = SessionConstants.getRedisSessionID(headerValue);
}
}
return (headerValue != null) ?
Collections.singletonList(headerValue) : Collections.emptyList();
}
@Override
public void setSessionId(HttpServletRequest request, HttpServletResponse response,
String sessionId) {
//不需要返回sessionId
//到前端
response.setHeader(this.headerName, "");
// response.setHeader(this.headerName, sessionId);
}
@Override
public void expireSession(HttpServletRequest request, HttpServletResponse response) {
response.setHeader(this.headerName, "");
}
//....省略其他
}
第2步：自定义一个SessionRepositoryFilter
这一步，不是必须的。
主要作用： 在过滤器的处理方法 doFilterInternal（....）, 要将 redis session 保存到 SessionHolder 类中，方便后面访问。代码如下：
SessionHolder.setRequest(wrappedRequest);
SessionHolder.setSession(wrappedRequest.getSession());
复制源码中的 SessionRepositoryFilter 类，改名为 CustomedSessionRepositoryFilter， 简单的修改一下，代码如下：
package com.crazymaker.springcloud.standard.security.filter;
//.....
public class CustomedSessionRepositoryFilter<S extends Session> extends OncePerRequestFilter {
private static final String SESSION_LOGGER_NAME = CustomedSessionRepositoryFilter.class
.getName().concat(".SESSION_LOGGER");
//....
//默认的ID解析器，需要替换掉
private HttpSessionIdResolver httpSessionIdResolver = new CookieHttpSessionIdResolver();
/**
* Creates a new instance.
*
* @param sessionRepository the <code>SessionRepository</code> to use. Cannot be null.
*/
public CustomedSessionRepositoryFilter(SessionRepository<S> sessionRepository) {
if (sessionRepository == null) {
throw new IllegalArgumentException("sessionRepository cannot be null");
}
this.sessionRepository = sessionRepository;
}
/**
* Sets the {@link HttpSessionIdResolver} to be used. The default is a
* {@link CookieHttpSessionIdResolver}.
*
* @param httpSessionIdResolver the {@link HttpSessionIdResolver} to use. Cannot be
* null.
*/
public void setHttpSessionIdResolver(HttpSessionIdResolver httpSessionIdResolver) {
if (httpSessionIdResolver == null) {
throw new IllegalArgumentException("httpSessionIdResolver cannot be null");
}
this.httpSessionIdResolver = httpSessionIdResolver;
}
@Override
protected void doFilterInternal(HttpServletRequest request,
HttpServletResponse response, FilterChain filterChain)
throws ServletException, IOException {
request.setAttribute(SESSION_REPOSITORY_ATTR, this.sessionRepository);
if(this.servletContext==null)
{
this.servletContext=request.getServletContext();
}
SessionRepositoryRequestWrapper wrappedRequest =
new SessionRepositoryRequestWrapper(request, response, this.servletContext);
SessionRepositoryResponseWrapper wrappedResponse =
new SessionRepositoryResponseWrapper(wrappedRequest, response);
/**
* 将Session请求，保持到 SessionHolder 的 ThreadLocal 本地变量中，方便统一获取
*/
SessionHolder.setRequest(wrappedRequest);
SessionHolder.setSession(wrappedRequest.getSession());
try {
filterChain.doFilter(wrappedRequest, wrappedResponse);
} finally {
wrappedRequest.commitSession();
}
}
public void setServletContext(ServletContext servletContext) {
this.servletContext = servletContext;
}
/**
* Allows ensuring that the session is saved if the response is committed.
*
* @author Rob Winch
* @since 1.0
*/
private final class SessionRepositoryResponseWrapper
extends OnCommittedResponseWrapper {
//.....
}
/**
* A {@link javax.servlet.http.HttpServletRequest} that retrieves the
* {@link javax.servlet.http.HttpSession} using a
* {@link org.springframework.session.SessionRepository}.
*
* @author Rob Winch
* @since 1.0
*/
private final class SessionRepositoryRequestWrapper
extends HttpServletRequestWrapper {
//....
}
static class HttpSessionAdapter<S extends Session> implements HttpSession {
//....
}
}
第3步：自动配置 Configuration 的定制
简单粗暴，将springsession 默认的自动配置，废掉了。
复制一份 RedisHttpSessionConfiguration， 名字叫做 CustomedRedisHttpSessionConfiguration ，主要作用：
（1） 创建 CustomedSessionIdResolver ID解析器的IOC Bean
（2） 创建 sessionRepository 保存器 的IOC Bean时，修改模式为立即提交
package com.crazymaker.springcloud.standard.config;
//....
@Configuration
@EnableScheduling
public class CustomedRedisHttpSessionConfiguration
implements BeanClassLoaderAware, EmbeddedValueResolverAware, ImportAware,
SchedulingConfigurer {
static final String DEFAULT_CLEANUP_CRON = "0 * * * * *";
//......
@DependsOn("httpSessionIdResolver")
@Bean
public RedisOperationsSessionRepository sessionRepository(CustomedSessionIdResolver httpSessionIdResolver) {
RedisTemplate<Object, Object> redisTemplate = createRedisTemplate();
RedisOperationsSessionRepository sessionRepository =
new RedisOperationsSessionRepository(redisTemplate);
sessionRepository.setApplicationEventPublisher(this.applicationEventPublisher);
if (this.defaultRedisSerializer != null) {
sessionRepository.setDefaultSerializer(this.defaultRedisSerializer);
}
sessionRepository
.setDefaultMaxInactiveInterval(this.maxInactiveIntervalInSeconds);
if (StringUtils.hasText(this.redisNamespace)) {
sessionRepository.setRedisKeyNamespace(this.redisNamespace+":"+SessionConstants.REDIS_SESSION_KEY_PREFIX);
}
//修改模式为立即提交
sessionRepository.setRedisFlushMode(RedisFlushMode.IMMEDIATE);
// sessionRepository.setRedisFlushMode(this.redisFlushMode);
int database = resolveDatabase();
sessionRepository.setDatabase(database);
httpSessionIdResolver.setRedisTemplet(redisTemplate);
this.sessionRepository = sessionRepository;
return sessionRepository;
}
//....
/**
* 配置 ID 解析器，从 header 解析id
*
* @return
*/
@Bean("httpSessionIdResolver")
public CustomedSessionIdResolver httpSessionIdResolver() {
return new CustomedSessionIdResolver(SessionConstants.SESSION_ID);
}
}
第4步： 在SpringSecurityConfig中，使用过滤器
package com.crazymaker.springcloud.user.info.config;
//....
import javax.annotation.Resource;
import java.util.Arrays;
@EnableWebSecurity()
public class UserProviderWebSecurityConfig extends WebSecurityConfigurerAdapter {
@Resource
private UserLoginService userLoginService;
protected void configure(HttpSecurity http) throws Exception {
http.csrf().disable()
.authorizeRequests()
.antMatchers(
"/v2/api-docs",
"/swagger-resources/configuration/ui",
"/swagger-resources",
"/swagger-resources/configuration/security",
"/swagger-ui.html",
"/api/user/login/v1",
.permitAll()
.anyRequest().authenticated()
.and()
.formLogin().disable()
.sessionManagement().disable()
.cors()
.and()
.addFilterAfter(new OptionsRequestFilter(), CorsFilter.class)
.apply(new JsonLoginConfigurer<>()).loginSuccessHandler(jsonLoginSuccessHandler())
.and()
.apply(new JwtLoginConfigurer<>()).tokenValidSuccessHandler(jwtRefreshSuccessHandler()).permissiveRequestUrls("/logout")
.and()
.logout()
.addLogoutHandler(tokenClearLogoutHandler())
.logoutSuccessHandler(new HttpStatusReturningLogoutSuccessHandler())
.and()
.addFilterBefore(springSessionRepositoryFilter(), SessionManagementFilter.class)
.sessionManagement().disable()
;
}
@Resource
RedisOperationsSessionRepository sessionRepository;
@Resource
public CustomedSessionIdResolver httpSessionIdResolver;
@DependsOn({"sessionRepository","httpSessionIdResolver"})
@Bean("jwtAuthenticationProvider")
protected AuthenticationProvider jwtAuthenticationProvider() {
return new JwtAuthenticationProvider(sessionRepository,httpSessionIdResolver);
}
//....
}
具体，请关注 Java 高并发研习社群 【博客园 总入口 】
最后，介绍一下疯狂创客圈：疯狂创客圈，一个Java 高并发研习社群 【博客园 总入口 】
疯狂创客圈，倾力推出：面试必备 + 面试必备 + 面试必备 的基础原理+实战 书籍 《Netty Zookeeper Redis 高并发实战》
疯狂创客圈 Java 死磕系列
- Java (Netty) 聊天程序【 亿级流量】实战 开源项目实战
- Netty 源码、原理、JAVA NIO 原理
- Java 面试题 一网打尽
- 疯狂创客圈 【 博客园 总入口 】
Java 面试题 一网打尽**
- 疯狂创客圈 【 博客园 总入口 】