分布式Session共享和单点登录实现

文章目录

• 基于Session的身份认证
• • 简介
  • 实现
• 分布式Session共享
• • 简介
  • 实现
• 单点登陆
• • 简介
  • 实现过程
  • 总结

简介

对于一个Web应用，客户端每次请求时，服务器都会打开一个新的会话，而且服务器不会维护客户端的上下文信息，因此如何管理客户端会话是必须要解决的问题。我们知道HTTP是无状态的协议，所以它提供了一种机制，通过Session来保存上下文信息，为每个用户分配一个sessionId，并且每个用户收到的sessionId都不一样，变量的值保存在服务器端。Session是以COOKIE或URL重写为基础的，默认使用COOKIE来实现，系统会创造一个名为JSESSIONID的值输出到COOKIE中。当用户从客户端向服务端发起HTTP请求时，会携带有sessionId的COOKIE请求， 这样服务端就能根据sessionId进行区分用户了。

实现

只需要简单定义一个Filter，进行拦截非登录请求，然后确认当前请求的Session中是否能够拿到用户信息，如果能拿到用户信息，那么就是登录状态，否则，认定当前请求无效，将请求转发到登录页面即可

//定义登录过滤器
public class LoginFilter implements Filter {
@Override
public void doFilter(ServletRequest servletRequest,
ServletResponse servletResponse, FilterChain filterChain)
throws IOException, ServletException {
HttpServletRequest request = (HttpServletRequest) servletRequest;
HttpServletResponse response = (HttpServletResponse)servletResponse;
Object user = request.getSession().getAttribute(CommonConstants.USER_ATTR);;
String requestUrl = request.getServletPath();
//非登陆页面并且不是登陆状态
if (!requestUrl.startsWith("/login")&& null == user) {
//则拒绝当前请求，请求转发到登陆页面
request.getRequestDispatcher("/login").forward(request,response);
return ;
}
filterChain.doFilter(request,servletResponse);
}
@Override
public void destroy() {
}
@Override
public void init(FilterConfig filterConfig) throws ServletException {
}
}


之后通过@Bean方式注入一个FilterRegistrationBean实例，并为它设置Filter属性，指定自定义的Filter实例，这样自定义的Filter才能在程序中生效

@Configuration
public class WebMvcConfig {
//将过滤器添加到请求中
@Bean
public FilterRegistrationBean sessionFilterRegistration() {
FilterRegistrationBean registration = new FilterRegistrationBean();
registration.setFilter(new LoginFilter());
registration.addUrlPatterns("/*");
registration.addInitParameter("paramName", "paramValue");
registration.setName("loginFilter");
registration.setOrder(1);
return registration;
}
}
分布式Session共享

简介

随着分布式架构的演进，单个服务器已经不能满足系统的需要了，通常都会把系统部署在多台服务器上，通过Nginx负载均衡把请求分发到其中的一台服务器上，这样很可能同一个用户的请求被分发到不同的服务器上，因为Session是保存在服务器上的，那么很有可能第一次请求访问的服务器A，创建了Session，但是第二次访问到了服务器B，这时就会出现取不到Session的情况。因此要在集群环境下使用，最好的解决办法就是使用Session共享。

实现

整个实现的核心点就是通过定义一个Request请求对象的Wrapper包装类，负责对当前Request请求的Session获取逻辑进行重写，将Session信息交由Redis进行存储和管理，包括从Redis获取Session信息以及认证成功后将Session信息提交到Redis中。因为实现比较简单，就不分析了，具体实现可以看下面代码的注释：

//request请求的包装类
public class RedisRequestWrapper extends HttpServletRequestWrapper {
private volatile boolean committed = false;
private String uuid = UUID.randomUUID().toString();
private RedisSession session;
private RedisTemplate redisTemplate;
public RedisRequestWrapper(HttpServletRequest request,RedisTemplate redisTemplate) {
super(request);
this.redisTemplate = redisTemplate;
}
/** * 提交session信息到redis */
public void commitSession() {
//避免请求重复提交session
if (committed) {
return;
}
committed = true;
RedisSession session = this.getSession();
if (session != null && null != session.getAttrs()) {
//将session信息存入redis
redisTemplate.opsForHash().putAll(session.getId(),session.getAttrs());
}
}
/** * 创建新session */
public RedisSession createSession() {
//从COOKIE中获得JSESSIONID
String sessionId = COOKIEUtil.getRequestedSessionId(this);
Map<String,Object> attr ;
if (null != sessionId){
//通过sessionid从redis缓存中，获取session信息
attr = redisTemplate.opsForHash().entries(sessionId);
} else {
//随机生成一个sessionid
sessionId = UUID.randomUUID().toString();
attr = new HashMap<>();
}
//session成员变量持有
session = new RedisSession();
session.setId(sessionId);
session.setAttrs(attr);
return session;
}
/** * 获取session */
public RedisSession getSession() {
return this.getSession(true);
}
public RedisSession getSession(boolean create) {
if (null != session){
return session;
}
return this.createSession();
}

/** * 确认是否登陆 */
public boolean isLogin(){
Object user = getSession().getAttribute(SessionFilter.USER_INFO);
return null != user;
}
}


public class COOKIEUtil{
public static final String COOKIE_NAME_SESSION = "jsession";

/** * 从请求的COOKIE中获取sessionid */
public static String getRequestedSessionId(HttpServletRequest request) {
COOKIE[] COOKIEs = request.getCOOKIEs();
if (COOKIEs == null) {
return null;
}
for (COOKIE COOKIE : COOKIEs) {
if (COOKIE == null) {
continue;
}
//确认是否存在sessionid
if (!COOKIE_NAME_SESSION.equalsIgnoreCase(COOKIE.getName())) {
continue;
}
return COOKIE.getValue();
}
return null;
}
/** * 将session信息保存到COOKIE中 */
public static void onNewSession(HttpServletRequest request,
HttpServletResponse response) {
HttpSession session = request.getSession();
String sessionId = session.getId();
COOKIE COOKIE = new COOKIE(COOKIE_NAME_SESSION, sessionId);
COOKIE.setHttpOnly(true);
COOKIE.setPath(request.getContextPath() + "/");
//指定一级域名
COOKIE.setDomain("xxx.com");
COOKIE.setMaxAge(Integer.MAX_VALUE);
response.addCOOKIE(COOKIE);
}
}


//自定义session,实现HttpSession接口
public class RedisSession implements Serializable,HttpSession {
private String id;
private Map<String,Object> attrs;
...
}


自定义Filter，用于拦截请求，根据Session信息来确认是否为登录状态

//自定义filter，用来拦截非登录请求
public class SessionFilter implements Filter {
public static final String USER_INFO = "user";
private RedisTemplate redisTemplate;
public void setRedisTemplate(RedisTemplate redisTemplate) {
this.redisTemplate = redisTemplate;
}
@Override
public void doFilter(ServletRequest servletRequest,
ServletResponse servletResponse, FilterChain filterChain)
throws IOException, ServletException {
HttpServletRequest request = (HttpServletRequest) servletRequest;
HttpServletResponse response = (HttpServletResponse)servletResponse;
RedisRequestWrapper redisRequestWrapper = new RedisRequestWrapper(request,redisTemplate);

String requestUrl = request.getServletPath();
//非登陆页面并且不是登陆状态
if (!"/toLogin".equals(requestUrl)
&& !requestUrl.startsWith("/login")
&& !redisRequestWrapper.isLogin()) {
//拒绝请求，跳转登陆页面
request.getRequestDispatcher("/toLogin").forward(redisRequestWrapper,response);
return ;
}
try {
filterChain.doFilter(redisRequestWrapper,servletResponse);
} finally {
//提交session信息到redis中
redisRequestWrapper.commitSession();
}
}
@Override
public void init(FilterConfig filterConfig) throws ServletException {
}
@Override
public void destroy() {
}
}


通过@Bean方法向容器中注入Filter，使自定义Filter生效

@Configuration
public class SessionConfig {
@Bean
public FilterRegistrationBean sessionFilterRegistration(SessionFilter sessionFilter) {
FilterRegistrationBean registration = new FilterRegistrationBean();
registration.setFilter(sessionFilter);
registration.addUrlPatterns("/*");
registration.addInitParameter("paramName", "paramValue");
registration.setName("sessionFilter");
registration.setOrder(1);
return registration;
}
//注入自定义过滤器
@Bean
public SessionFilter sessionFilter(RedisTemplate redisTemplate){
SessionFilter sessionFilter = new SessionFilter();
sessionFilter.setRedisTemplate(redisTemplate);
return sessionFilter;
}
}


@Controller
public class IndexController {
@GetMapping("/toLogin")
public String toLogin(Model model,RedisRequestWrapper request) {
UserForm user = new UserForm();
user.setUsername("username");
user.setPassword("password");
user.setBackurl(request.getParameter("url"));
model.addAttribute("user", user);
return "login";
}
@PostMapping("/login")
public void login(@ModelAttribute UserForm user,RedisRequestWrapper request,HttpServletResponse response) throws IOException, ServletException {
request.getSession().setAttribute(SessionFilter.USER_INFO,user);
//将session信息保存到COOKIE中
COOKIEBasedSession.onNewSession(request,response);
//重定向到index页面
response.sendRedirect("/index");
}
@GetMapping("/index")
public ModelAndView index(RedisRequestWrapper request) {
ModelAndView modelAndView = new ModelAndView();
modelAndView.setViewName("index");
modelAndView.addObject("user", request.getSession().getAttribute(SessionFilter.USER_INFO));
request.getSession().setAttribute("test","123");
return modelAndView;
}
}
单点登陆

简介

较大的企业内部，一般都有很多的业务支持系统为其提供相应的管理和 IT 服务。通常来说，每个单独的系统都会有自己的安全体系和身份认证系统。进入每个系统都需要进行登录，这样的局面不仅给管理上带来了很大的困难，对客户来说也极不友好。那么如何让客户只需登陆一次，就可以进入多个系统，而不需要重新登录呢。“单点登录”就是专为解决此类问题的。其大致思想流程如下：通过一个 ticket 进行串接各系统间的用户信息

实现过程

在每一个需要身份认证的服务中，定义一个SSOFilter用于拦截非登录请求。对于每个拦截的请求，会先从当前请求的Session中确认是否能够拿到用户信息，拿不到用户信息又会确认当前请求中是否携带ticket票据这个参数，如果携带就会尝试从Redis中根据该票据拿到用户信息。如果最终都获取不到用户信息就会被重定向到SSO登录服务的登录页面进行登录处理

public class SSOFilter implements Filter {
private RedisTemplate redisTemplate;
public static final String USER_INFO = "user";
public SSOFilter(RedisTemplate redisTemplate){
this.redisTemplate = redisTemplate;
}
@Override
public void init(FilterConfig filterConfig) throws ServletException {
}
@Override
public void doFilter(ServletRequest servletRequest,
ServletResponse servletResponse, FilterChain filterChain)
throws IOException, ServletException {
HttpServletRequest request = (HttpServletRequest) servletRequest;
HttpServletResponse response = (HttpServletResponse)servletResponse;
Object userInfo = request.getSession().getAttribute(USER_INFO);;
//如果未登陆，则拒绝请求，转向登陆页面
String requestUrl = request.getServletPath();
if (!"/toLogin".equals(requestUrl)
&& !requestUrl.startsWith("/login")
&& null == userInfo) {
String ticket = request.getParameter("ticket");
//有票据,则使用票据去尝试拿取用户信息
if (null != ticket){
userInfo = redisTemplate.opsForValue().get(ticket);
}
//无法得到用户信息，则去CAS服务的登陆页面
if (null == userInfo){
response.sendRedirect("http://cas.com:8080/toLogin?url="+request.getRequestURL().toString());
return ;
}
/** * 将用户信息，加载进session中 */
request.getSession().setAttribute(SSOFilter.USER_INFO,userInfo);
//登录成功需要将ticket从redis中删除
redisTemplate.delete(ticket);
}
filterChain.doFilter(request,servletResponse);
}
@Override
public void destroy() {
}
}


在SSO登录服务中，只需要简单定义一个Filter，进行拦截非登录请求，然后确认当前请求的Session中是否能够拿到用户信息，如果能拿到用户信息，那么就是登录状态，否则，认定当前请求无效，将请求转发到登录页面即可

public class LoginFilter implements Filter {
public static final String USER_INFO = "user";
@Override
public void init(FilterConfig filterConfig) throws ServletException {
}
@Override
public void doFilter(ServletRequest servletRequest,
ServletResponse servletResponse, FilterChain filterChain)
throws IOException, ServletException {
HttpServletRequest request = (HttpServletRequest) servletRequest;
HttpServletResponse response = (HttpServletResponse)servletResponse;
Object userInfo = request.getSession().getAttribute(USER_INFO);;
//非登陆页面并且不是登陆状态
String requestUrl = request.getServletPath();
if (!"/toLogin".equals(requestUrl)
&& !requestUrl.startsWith("/login")
&& null == userInfo) {
//则拒绝当前请求，请求转发到登陆页面
request.getRequestDispatcher("/toLogin").forward(request,response);
return ;
}
filterChain.doFilter(request,servletResponse);
}
@Override
public void destroy() {
}
}


在SSO登录处理过程中，当请求已认证登录成功后，会先生成一个ticket票据，并将ticket票据和用户信息存放到Redis中，然后重定向回原先请求服务的Url，并携带上ticket票据参数

@Controller
public class IndexController {
@Autowired
private RedisTemplate redisTemplate;
@GetMapping("/toLogin")
public String toLogin(Model model,HttpServletRequest request) {
Object userInfo = request.getSession().getAttribute(LoginFilter.USER_INFO);
//不为空，则是已登陆状态
if (null != userInfo){
String ticket = UUID.randomUUID().toString();
redisTemplate.opsForValue().set(ticket,userInfo,2, TimeUnit.SECONDS);
return "redirect:"+request.getParameter("url")+"?ticket="+ticket;
}
UserForm user = new UserForm();
user.setUsername("username");
user.setPassword("password");
user.setBackurl(request.getParameter("url"));
model.addAttribute("user", user);
return "login";
}
@PostMapping("/login")
public void login(@ModelAttribute UserForm user,HttpServletRequest request,HttpServletResponse response) throws IOException, ServletException {
request.getSession().setAttribute(LoginFilter.USER_INFO,user);
//登陆成功，创建用户信息票据
String ticket = UUID.randomUUID().toString();
//将ticket和用户信息写入到redis中
redisTemplate.opsForValue().set(ticket,user,20, TimeUnit.SECONDS);
//重定向，回原请求的url,并携带ticket信息
if (null == user.getBackurl() || user.getBackurl().length()==0){
response.sendRedirect("/index");
} else {
response.sendRedirect(user.getBackurl()+"?ticket="+ticket);
}
}
@GetMapping("/index")
public ModelAndView index(HttpServletRequest request) {
ModelAndView modelAndView = new ModelAndView();
modelAndView.setViewName("index");
modelAndView.addObject("user", request.getSession().getAttribute(LoginFilter.USER_INFO));
request.getSession().setAttribute("test","123");
return modelAndView;
}
}


总结

1. 用户访问服务A某个页面时，服务A发现自己未登录，重定向到CAS单点登录服务，CAS服务也发现未登录，则跳转到相应的登录页面
2. 用户输入用户名和密码登录成功后，CAS服务进行认证，将登录状态记录CAS服务的session中，并写入当前CAS服务域名下的COOKIE中
3. CAS服务登录完成后会生成一个Ticket票据，并将Ticket和用户信息记录到Redis中，之后再重定向回服务A，同时将Ticket作为参数传递给服务A
4. 服务A拿到Ticket后，从Redis中进行查找，查询Ticket对应的用户信息，之后服务A再将登录状态写入session并设置到服务A域名下的COOKIE中
5. 至此，单点登录就完成了，之后再访问服务A时，服务A就是登录状态的
6. 当有一个新的服务B被用户访问时，服务B发现自己也未登录，此时也重定向到CAS单点登录服务，但是此时CAS服务发现已经登录了，此时就不需要进行登录认证
7. CAS服务会生成一个Ticket票据，并将Ticket和用户信息记录到Redis中，之后再重定向回服务B，同时将Ticket作为参数传递给服务B
8. 服务B拿到Ticket后，从Redis中进行查找，查询Ticket对应的用户信息，之后服务B再将登录状态写入session并设置到服务B域名下的COOKIE中
9. 因此服务B不需要进行登录过程，就能完成用户登录认证

由于本人能力有限，分析不恰当的地方和文章有错误的地方的欢迎批评指出，非常感谢！