单点登录，java实现

Posted 2023-04-16

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了单点登录，java实现相关的知识，希望对你有一定的参考价值。

可以直接通过玉符科技IDAAS平台来实现单点登录，支持所有的标准协议，如果是老旧或者自研的系统，也有SDK去适配所有的开发语言，不止是java。

玉符单点登录

参考技术A 单点登陆的话,你可以使用token来实现,比如一个用户一次只生成一个token,这样别人在访问的时候,就会重新生成一个,之前的就会被踢出线参考技术B import java.io.IOException;
import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
public class LoginFilter implements Filter
private String loginInfoPath;
public void destroy()
   loginInfoPath = null;

public void doFilter(ServletRequest sreq, ServletResponse sresp,
    FilterChain chain) throws IOException, ServletException
   HttpServletRequest req = (HttpServletRequest) sreq;
   HttpServletResponse resp = (HttpServletResponse) sresp;
   Class loginInfoClass = null;
   LoginInfoBase loginInfo = null;
   try
    loginInfoClass = Class.forName(loginInfoPath);
    loginInfo = (LoginInfoBase) loginInfoClass.newInstance();
    catch (ClassNotFoundException e)
    e.printStackTrace();
    catch (InstantiationException e)
    e.printStackTrace();
    catch (IllegalAccessException e)
    e.printStackTrace();

   loginInfo.setReq(req);
   loginInfo.setResp(resp);
   //session值为空
   if(loginInfo.isSessionEmpty())
    if(loginInfo.init())
     boolean loginResult = loginInfo.doLogin();
     if(loginResult)
      loginInfo.saveCookie();


   else
    if(loginInfo.init())
     //另外一套系统已经退出
     if("out".equals(loginInfo.getLoginState()))
      loginInfo.doLogout();
      CookieUtil.delCookie(resp, LoginInfoBase.COOKIE_NAME);



   chain.doFilter(sreq, sresp);

public void init(FilterConfig config) throws ServletException
   this.loginInfoPath = config.getInitParameter("loginInfoPath");

public String getLoginInfoPath()
   return loginInfoPath;

public void setLoginInfoPath(String loginInfoPath)
   this.loginInfoPath = loginInfoPath;

loginInfoPath 在web.xml中配置指明LoginInfoBase的子类的完整路径用来反射
LoginInfoBase代码：
package com.yt.util;
import java.text.SimpleDateFormat;
import java.util.Date;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
public abstract class LoginInfoBase
public static final String SEPARATION = "-->";
public static final String DATE_FORMAT = "yyyy-MM-dd HH:mm:ss";
public static final long COOKIE_TIME = 1800000;
public static final String COOKIE_NAME = "loginInfo";
public static final String COOKIE_PATH = "/";

protected HttpServletRequest req;
protected HttpServletResponse resp;

protected Date sessionTime;
protected String userName;
protected String userPass;
protected String loginState;

public LoginInfoBase()
   super();

public LoginInfoBase(HttpServletRequest req, HttpServletResponse resp)
   super();
   this.req = req;
   this.resp = resp;

public LoginInfoBase(String userName, String pwd, Date sessionTime)
   this.userName = userName;
   this.userPass = pwd;
   this.sessionTime = sessionTime;

abstract void doLogout();
abstract boolean isSessionEmpty();
abstract boolean doLogin();

public HttpServletRequest getReq()
   return req;

public void setReq(HttpServletRequest req)
   this.req = req;

public HttpServletResponse getResp()
   return resp;

public void setResp(HttpServletResponse resp)
   this.resp = resp;

//初始化登录对象
protected boolean init()
   String loginInfoStr = CookieUtil.getValue(req, LoginInfoBase.COOKIE_NAME);
   if(loginInfoStr == null || "".equals(loginInfoStr))
    return false;

   String[] infoArray = loginInfoStr.split(SEPARATION);
   if(infoArray.length>3)
    this.userName = DigestUtil.getFromBASE64(infoArray[0]);
    this.userPass = DigestUtil.getFromBASE64(infoArray[1]);
    this.sessionTime = buildDate(infoArray[2]);
    this.loginState = infoArray[3];

   if(new Date().getTime() - getSessionTime().getTime() > LoginInfo.COOKIE_TIME)
    CookieUtil.delCookie(resp, LoginInfo.COOKIE_NAME);
    return false;

   return true;

protected void saveCookie()
   setSessionTime(new Date());
   setLoginState("in");
   CookieUtil.addCookie(resp, LoginInfo.COOKIE_NAME, toString(), "/");

public void clearCookie()
   setUserName("XX");
   setUserPass("XX");
   setSessionTime(new Date());
   setLoginState("out");
   CookieUtil.addCookie(resp, LoginInfo.COOKIE_NAME, toString(), "/");

@Override
public String toString()
   return DigestUtil.getBASE64(userName)+SEPARATION+DigestUtil.getBASE64(userPass)+SEPARATION+formateSessionTime()+SEPARATION+loginState;

private String formateSessionTime()
   SimpleDateFormat df = new SimpleDateFormat(DATE_FORMAT);
   String timeStr =df.format(sessionTime);
   return timeStr;

private Date buildDate(String sessionTime)
   SimpleDateFormat df = new SimpleDateFormat(DATE_FORMAT);
   Date date = null;
     try
         date = df.parse(sessionTime);
     catch (Exception ex)
         System.out.println(ex.getMessage());

   return date;

public Date getSessionTime()
   return sessionTime;

public void setSessionTime(Date sessionTime)
   this.sessionTime = sessionTime;

public String getUserName()
   return userName;

public void setUserName(String userName)
   this.userName = userName;

public String getUserPass()
   return userPass;

public void setUserPass(String userPass)
   this.userPass = userPass;

public String getLoginState()
   return loginState;

public void setLoginState(String loginState)
   this.loginState = loginState;

参考技术C public boolean login() throws LoginException
try
if (Cookielogin()) return true;
catch (IOException ex)
ex.printStackTrace();

if (passwordlogin()) return true;
throw new FailedLoginException();
参考技术D 看你怎么做了，有开源框架可以帮助你，！
一般用spring 的security比较不错本回答被提问者采纳

单点登录系统实现

单点登录系统实现基于SpringBoot

今天的干货有点湿，里面夹杂着我的泪水。可能也只有代码才能让我暂时的平静。通过本章内容你将学到单点登录系统和传统登录系统的区别，单点登录系统设计思路，Spring4 Java配置方式整合HttpClient，整合SolrJ ，HttpClient简易教程。还在等什么？撸起袖子开始干吧！

效果图：8081端口是sso系统，其他两个8082和8083端口模拟两个系统。登录成功后检查Redis数据库中是否有值。

技术：SpringBoot，SpringMVC，Spring，SpringData，Redis，HttpClient

说明：本章的用户登录注册的代码部分已经在SpringBoot基础入门中介绍过了，这里不会重复贴代码。

源码：见文章底部

SpringBoot基础入门：http://www.cnblogs.com/itdragon/p/8047132.html

单点登录系统简介

在传统的系统，或者是只有一个服务器的系统中。Session在一个服务器中，各个模块都可以直接获取，只需登录一次就进入各个模块。若在服务器集群或者是分布式系统架构中，每个服务器之间的Session并不是共享的，这会出现每个模块都要登录的情况。这时候需要通过单点登录系统（Single Sign On）将用户信息存在Redis数据库中实现Session共享的效果。从而实现一次登录就可以访问所有相互信任的应用系统。

单点登录系统实现

Maven项目核心配置文件 pom.xml 需要在原来的基础上添加 httpclient和jedis jar包

 
   
   
 
  
    
    
      <dependency>    <!-- http client version is 4.5.3 -->
  
    
    
          <groupId>org.apache.httpcomponents</groupId>
  
    
    
          <artifactId>httpclient</artifactId>
  
    
    
      </dependency>
  
    
    
      <dependency>    <!-- redis java client version is 2.9.0  -->
  
    
    
          <groupId>redis.clients</groupId>
  
    
    
          <artifactId>jedis</artifactId>
  
    
    
      </dependency>

Spring4 Java配置方式

这里，我们需要整合httpclient用于各服务之间的通讯(也可以用okhttp)。同时还需要整合redis用于存储用户信息(Session共享)。在Spring3.x之前，一般在应用的基本配置用xml，比如数据源、资源文件等。业务开发用注解，比如Component，Service，Controller等。其实在Spring3.x的时候就已经提供了Java配置方式。现在的Spring4.x和SpringBoot都开始推荐使用Java配置方式配置bean。它可以使bean的结构更加的清晰。

整合 HttpClient

HttpClient 是 Apache Jakarta Common 下的子项目，用来提供高效的、最新的、功能丰富的支持 HTTP 协议的客户端编程工具包，并且它支持 HTTP 协议最新的版本和建议。 HttpClient4.5系列教程 : http://blog.csdn.net/column/details/httpclient.html

首先在src/main/resources 目录下创建 httpclient.properties 配置文件

 
   
   
 
  
    
    
  #设置整个连接池默认最大连接数
  
    
    
  http.defaultMaxPerRoute=100
  
    
    
  #设置整个连接池最大连接数
  
    
    
  http.maxTotal=300
  
    
    
  #设置请求超时
  
    
    
  http.connectTimeout=1000
  
    
    
  #设置从连接池中获取到连接的最长时间
  
    
    
  http.connectionRequestTimeout=500
  
    
    
  #设置数据传输的最长时间
  
    
    
  http.socketTimeout=10000

然后在 src/main/java/com/itdragon/config 目录下创建 HttpclientSpringConfig.java 文件

这里用到了四个很重要的注解

@Configuration：作用于类上，指明该类就相当于一个xml配置文件
@Bean：作用于方法上，指明该方法相当于xml配置中的，注意方法名的命名规范
@PropertySource：指定读取的配置文件，引入多个value={"xxx:xxx","xxx:xxx"},ignoreResourceNotFound=true 文件不存在是忽略
@Value：获取配置文件的值，该注解还有很多语法知识，这里暂时不扩展开

 
   
   
 
  
    
    
  package com.itdragon.config;
  
    
    
  
  
    
    
  import java.util.concurrent.TimeUnit;
  
    
    
  import org.apache.http.client.config.RequestConfig;
  
    
    
  import org.apache.http.impl.client.CloseableHttpClient;
  
    
    
  import org.apache.http.impl.client.HttpClients;
  
    
    
  import org.apache.http.impl.client.IdleConnectionEvictor;
  
    
    
  import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;
  
    
    
  import org.springframework.beans.factory.annotation.Autowired;
  
    
    
  import org.springframework.beans.factory.annotation.Value;
  
    
    
  import org.springframework.context.annotation.Bean;
  
    
    
  import org.springframework.context.annotation.Configuration;
  
    
    
  import org.springframework.context.annotation.PropertySource;
  
    
    
  import org.springframework.context.annotation.Scope;
  
    
    
  
  
    
    
  /**
  
    
    
   * @Configuration     作用于类上，相当于一个xml配置文件
  
    
    
   * @Bean             作用于方法上，相当于xml配置中的<bean>
  
    
    
   * @PropertySource    指定读取的配置文件
  
    
    
   * @Value            获取配置文件的值
  
    
    
   */
  
    
    
  @Configuration
  
    
    
  @PropertySource(value = "classpath:httpclient.properties")
  
    
    
  public class HttpclientSpringConfig {
  
    
    
  
  
    
    
      @Value("${http.maxTotal}")
  
    
    
      private Integer httpMaxTotal;
  
    
    
  
  
    
    
      @Value("${http.defaultMaxPerRoute}")
  
    
    
      private Integer httpDefaultMaxPerRoute;
  
    
    
  
  
    
    
      @Value("${http.connectTimeout}")
  
    
    
      private Integer httpConnectTimeout;
  
    
    
  
  
    
    
      @Value("${http.connectionRequestTimeout}")
  
    
    
      private Integer httpConnectionRequestTimeout;
  
    
    
  
  
    
    
      @Value("${http.socketTimeout}")
  
    
    
      private Integer httpSocketTimeout;
  
    
    
  
  
    
    
      @Autowired
  
    
    
      private PoolingHttpClientConnectionManager manager;
  
    
    
  
  
    
    
      @Bean
  
    
    
      public PoolingHttpClientConnectionManager poolingHttpClientConnectionManager() {
  
    
    
          PoolingHttpClientConnectionManager poolingHttpClientConnectionManager = new PoolingHttpClientConnectionManager();
  
    
    
          // 最大连接数
  
    
    
          poolingHttpClientConnectionManager.setMaxTotal(httpMaxTotal);
  
    
    
          // 每个主机的最大并发数
  
    
    
          poolingHttpClientConnectionManager.setDefaultMaxPerRoute(httpDefaultMaxPerRoute);
  
    
    
          return poolingHttpClientConnectionManager;
  
    
    
      }
  
    
    
  
  
    
    
      @Bean    // 定期清理无效连接
  
    
    
      public IdleConnectionEvictor idleConnectionEvictor() {
  
    
    
          return new IdleConnectionEvictor(manager, 1L, TimeUnit.HOURS);
  
    
    
      }
  
    
    
  
  
    
    
      @Bean    // 定义HttpClient对象 注意该对象需要设置scope="prototype":多例对象
  
    
    
      @Scope("prototype")
  
    
    
      public CloseableHttpClient closeableHttpClient() {
  
    
    
          return HttpClients.custom().setConnectionManager(this.manager).build();
  
    
    
      }
  
    
    
  
  
    
    
      @Bean    // 请求配置
  
    
    
      public RequestConfig requestConfig() {
  
    
    
          return RequestConfig.custom().setConnectTimeout(httpConnectTimeout) // 创建连接的最长时间
  
    
    
                  .setConnectionRequestTimeout(httpConnectionRequestTimeout) // 从连接池中获取到连接的最长时间
  
    
    
                  .setSocketTimeout(httpSocketTimeout) // 数据传输的最长时间
  
    
    
                  .build();
  
    
    
      }
  
    
    
  }

整合 Redis

SpringBoot官方其实提供了spring-boot-starter-redis pom 帮助我们快速开发，但我们也可以自定义配置，这样可以更方便地掌控。

Redis 系列教程 : http://www.cnblogs.com/itdragon/category/1122427.html

首先在src/main/resources 目录下创建 redis.properties 配置文件

 
   
   
 
  
    
    
  redis.node.host=192.168.225.131
  
    
    
  redis.node.port=6379
  
    
    
  
  
    
    
  REDIS_USER_SESSION_KEY=REDIS_USER_SESSION
  
    
    
  SSO_SESSION_EXPIRE=30

在src/main/java/com/itdragon/config 目录下创建 RedisSpringConfig.java 文件

 
   
   
 
  
    
    
  package com.itdragon.config;
  
    
    
  
  
    
    
  import java.util.ArrayList;
  
    
    
  import java.util.List;
  
    
    
  import org.springframework.beans.factory.annotation.Value;
  
    
    
  import org.springframework.context.annotation.Bean;
  
    
    
  import org.springframework.context.annotation.Configuration;
  
    
    
  import org.springframework.context.annotation.PropertySource;
  
    
    
  import redis.clients.jedis.JedisPool;
  
    
    
  import redis.clients.jedis.JedisPoolConfig;
  
    
    
  import redis.clients.jedis.JedisShardInfo;
  
    
    
  import redis.clients.jedis.ShardedJedisPool;
  
    
    
  
  
    
    
  @Configuration
  
    
    
  @PropertySource(value = "classpath:redis.properties")
  
    
    
  public class RedisSpringConfig {
  
    
    
  
  
    
    
      @Value("${redis.maxTotal}")
  
    
    
      private Integer redisMaxTotal;
  
    
    
  
  
    
    
      @Value("${redis.node.host}")
  
    
    
      private String redisNodeHost;
  
    
    
  
  
    
    
      @Value("${redis.node.port}")
  
    
    
      private Integer redisNodePort;
  
    
    
  
  
    
    
      private JedisPoolConfig jedisPoolConfig() {
  
    
    
          JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
  
    
    
          jedisPoolConfig.setMaxTotal(redisMaxTotal);
  
    
    
          return jedisPoolConfig;
  
    
    
      }
  
    
    
  
  
    
    
      @Bean 
  
    
    
      public JedisPool getJedisPool(){    // 省略第一个参数则是采用 Protocol.DEFAULT_DATABASE
  
    
    
          JedisPool jedisPool = new JedisPool(jedisPoolConfig(), redisNodeHost, redisNodePort);
  
    
    
          return jedisPool;
  
    
    
      }
  
    
    
  
  
    
    
      @Bean
  
    
    
      public ShardedJedisPool shardedJedisPool() {
  
    
    
          List<JedisShardInfo> jedisShardInfos = new ArrayList<JedisShardInfo>();
  
    
    
          jedisShardInfos.add(new JedisShardInfo(redisNodeHost, redisNodePort));
  
    
    
          return new ShardedJedisPool(jedisPoolConfig(), jedisShardInfos);
  
    
    
      }
  
    
    
  }

Service 层

在src/main/java/com/itdragon/service 目录下创建 UserService.java 文件，它负责三件事情第一件事件：验证用户信息是否正确，并将登录成功的用户信息保存到Redis数据库中。第二件事件：负责判断用户令牌是否过期，若没有则刷新令牌存活时间。第三件事件：负责从Redis数据库中删除用户信息。这里用到了一些工具类，不影响学习，可以从源码中直接获取。

 
   
   
 
  
    
    
  package com.itdragon.service;
  
    
    
  
  
    
    
  import java.util.UUID;
  
    
    
  import javax.servlet.http.HttpServletRequest;
  
    
    
  import javax.servlet.http.HttpServletResponse;
  
    
    
  import javax.transaction.Transactional;
  
    
    
  import org.springframework.beans.factory.annotation.Autowired;
  
    
    
  import org.springframework.beans.factory.annotation.Value;
  
    
    
  import org.springframework.context.annotation.PropertySource;
  
    
    
  import org.springframework.stereotype.Service;
  
    
    
  import org.springframework.util.StringUtils;
  
    
    
  import com.itdragon.pojo.ItdragonResult;
  
    
    
  import com.itdragon.pojo.User;
  
    
    
  import com.itdragon.repository.JedisClient;
  
    
    
  import com.itdragon.repository.UserRepository;
  
    
    
  import com.itdragon.utils.CookieUtils;
  
    
    
  import com.itdragon.utils.ItdragonUtils;
  
    
    
  import com.itdragon.utils.JsonUtils;
  
    
    
  
  
    
    
  @Service
  
    
    
  @Transactional
  
    
    
  @PropertySource(value = "classpath:redis.properties")
  
    
    
  public class UserService {
  
    
    
  
  
    
    
      @Autowired
  
    
    
      private UserRepository userRepository;
  
    
    
  
  
    
    
      @Autowired
  
    
    
      private JedisClient jedisClient;
  
    
    
  
  
    
    
      @Value("${REDIS_USER_SESSION_KEY}")
  
    
    
      private String REDIS_USER_SESSION_KEY;
  
    
    
  
  
    
    
      @Value("${SSO_SESSION_EXPIRE}")
  
    
    
      private Integer SSO_SESSION_EXPIRE;
  
    
    
  
  
    
    
      public ItdragonResult userLogin(String account, String password,
  
    
    
              HttpServletRequest request, HttpServletResponse response) {
  
    
    
          // 判断账号密码是否正确
  
    
    
          User user = userRepository.findByAccount(account);
  
    
    
          if (!ItdragonUtils.decryptPassword(user, password)) {
  
    
    
              return ItdragonResult.build(400, "账号名或密码错误");
  
    
    
          }
  
    
    
          // 生成token
  
    
    
          String token = UUID.randomUUID().toString();
  
    
    
          // 清空密码和盐避免泄漏
  
    
    
          String userPassword = user.getPassword();
  
    
    
          String userSalt = user.getSalt();
  
    
    
          user.setPassword(null);
  
    
    
          user.setSalt(null);
  
    
    
          // 把用户信息写入 redis
  
    
    
          jedisClient.set(REDIS_USER_SESSION_KEY + ":" + token, JsonUtils.objectToJson(user));
  
    
    
          // user 已经是持久化对象，被保存在session缓存当中，若user又重新修改属性值，那么在提交事务时，此时 hibernate对象就会拿当前这个user对象和保存在session缓存中的user对象进行比较，如果两个对象相同，则不会发送update语句，否则会发出update语句。
  
    
    
          user.setPassword(userPassword);
  
    
    
          user.setSalt(userSalt);
  
    
    
          // 设置 session 的过期时间
  
    
    
          jedisClient.expire(REDIS_USER_SESSION_KEY + ":" + token, SSO_SESSION_EXPIRE);
  
    
    
          // 添加写 cookie 的逻辑，cookie 的有效期是关闭浏览器就失效。
  
    
    
          CookieUtils.setCookie(request, response, "USER_TOKEN", token);
  
    
    
          // 返回token
  
    
    
          return ItdragonResult.ok(token);
  
    
    
      }
  
    
    
  
  
    
    
      public void logout(String token) {
  
    
    
          jedisClient.del(REDIS_USER_SESSION_KEY + ":" + token);
  
    
    
      }
  
    
    
  
  
    
    
      public ItdragonResult queryUserByToken(String token) {
  
    
    
          // 根据token从redis中查询用户信息
  
    
    
          String json = jedisClient.get(REDIS_USER_SESSION_KEY + ":" + token);
  
    
    
          // 判断是否为空
  
    
    
          if (StringUtils.isEmpty(json)) {
  
    
    
              return ItdragonResult.build(400, "此session已经过期，请重新登录");
  
    
    
          }
  
    
    
          // 更新过期时间
  
    
    
          jedisClient.expire(REDIS_USER_SESSION_KEY + ":" + token, SSO_SESSION_EXPIRE);
  
    
    
          // 返回用户信息
  
    
    
          return ItdragonResult.ok(JsonUtils.jsonToPojo(json, User.class));
  
    
    
      }
  
    
    
  }

Controller 层

负责跳转登录页面跳转

 
   
   
 
  
    
    
  package com.itdragon.controller;
  
    
    
  
  
    
    
  import org.springframework.stereotype.Controller;
  
    
    
  import org.springframework.ui.Model;
  
    
    
  import org.springframework.web.bind.annotation.RequestMapping;
  
    
    
  
  
    
    
  @Controller
  
    
    
  public class PageController {
  
    
    
  
  
    
    
      @RequestMapping("/login")
  
    
    
      public String showLogin(String redirect, Model model) {
  
    
    
          model.addAttribute("redirect", redirect);
  
    
    
          return "login";
  
    
    
      }
  
    
    
  
  
    
    
  }

负责用户的登录，退出，获取令牌的操作

 
   
   
 
  
    
    
  package com.itdragon.controller;
  
    
    
  
  
    
    
  import javax.servlet.http.HttpServletRequest;
  
    
    
  import javax.servlet.http.HttpServletResponse;
  
    
    
  import org.springframework.beans.factory.annotation.Autowired;
  
    
    
  import org.springframework.stereotype.Controller;
  
    
    
  import org.springframework.web.bind.annotation.PathVariable;
  
    
    
  import org.springframework.web.bind.annotation.RequestMapping;
  
    
    
  import org.springframework.web.bind.annotation.RequestMethod;
  
    
    
  import org.springframework.web.bind.annotation.ResponseBody;
  
    
    
  import com.itdragon.pojo.ItdragonResult;
  
    
    
  import com.itdragon.service.UserService;
  
    
    
  
  
    
    
  @Controller
  
    
    
  @RequestMapping("/user")
  
    
    
  public class UserController {
  
    
    
  
  
    
    
      @Autowired
  
    
    
      private UserService userService;
  
    
    
  
  
    
    
      @RequestMapping(value="/login", method=RequestMethod.POST)
  
    
    
      @ResponseBody
  
    
    
      public ItdragonResult userLogin(String username, String password,
  
    
    
              HttpServletRequest request, HttpServletResponse response) {
  
    
    
          try {
  
    
    
              ItdragonResult result = userService.userLogin(username, password, request, response);
  
    
    
              return result;
  
    
    
          } catch (Exception e) {
  
    
    
              e.printStackTrace();
  
    
    
              return ItdragonResult.build(500, "");
  
    
    
          }
  
    
    
      }
  
    
    
  
  
    
    
      @RequestMapping(value="/logout/{token}")
  
    
    
      public String logout(@PathVariable String token) {
  
    
    
          userService.logout(token); // 思路是从Redis中删除key，实际情况请和业务逻辑结合
  
    
    
          return "index";
  
    
    
      }
  
    
    
  
  
    
    
      @RequestMapping("/token/{token}")
  
    
    
      @ResponseBody
  
    
    
      public Object getUserByToken(@PathVariable String token) {
  
    
    
          ItdragonResult result = null;
  
    
    
          try {
  
    
    
              result = userService.queryUserByToken(token);
  
    
    
          } catch (Exception e) {
  
    
    
              e.printStackTrace();
  
    
    
              result = ItdragonResult.build(500, "");
  
    
    
          }
  
    
    
          return result;
  
    
    
      }
  
    
    
  }

视图层

一个简单的登录页面

 
   
   
 
  
    
    
  <%@ page language="java" contentType="text/html; charset=UTF-8"
  
    
    
      pageEncoding="UTF-8"%>
  
    
    
  <!doctype html>
  
    
    
  <html lang="zh">
  
    
    
      <head>
  
    
    
          <meta name="viewport" content="initial-scale=1.0, width=device-width, user-scalable=no" />
  
    
    
          <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
  
    
    
          <meta http-equiv="X-UA-Compatible" content="IE=edge,Chrome=1" />
  
    
    
          <meta http-equiv="X-UA-Compatible" content="IE=8" />
  
    
    
          <title>欢迎登录</title>
  
    
    
          <link type="image/x-icon" href="images/favicon.ico" rel="shortcut icon">
  
    
    
          <link rel="stylesheet" href="static/css/main.css" />
  
    
    
      </head>
  
    
    
      <body>
  
    
    
          <div class="wrapper">
  
    
    
              <div class="container">
  
    
    
                  <h1>Welcome</h1>
  
    
    
                  <form method="post" onsubmit="return false;" class="form">
  
    
    
                      <input type="text" value="itdragon" name="username" placeholder="Account"/>
  
    
    
                      <input type="password" value="123456789" name="password" placeholder="Password"/>
  
    
    
                      <button type="button" id="login-button">Login</button>
  
    
    
                  </form>
  
    
    
              </div>
  
    
    
              <ul class="bg-bubbles">
  
    
    
                  <li></li>
  
    
    
                  <li></li>
  
    
    
                  <li></li>
  
    
    
                  <li></li>
  
    
    
                  <li></li>
  
    
    
                  <li></li>
  
    
    
                  <li></li>
  
    
    
                  <li></li>
  
    
    
                  <li></li>
  
    
    
                  <li></li>
  
    
    
              </ul>
  
    
    
          </div>
  
    
    
          <script type="text/javascript" src="static/js/jquery-1.10.1.min.js" ></script>
  
    
    
          <script type="text/javascript">
  
    
    
              var redirectUrl = "${redirect}"; // 浏览器中返回的URL
  
    
    
              function doLogin() {
  
    
    
                  $.post("/user/login", $(".form").serialize(),function(data){
  
    
    
                      if (data.status == 200) {
  
    
    
                          if (redirectUrl == "") {
  
    
    
                              location.href = "http://localhost:8082";
  
    
    
                          } else {
  
    
    
                              location.href = redirectUrl;
  
    
    
                          }
  
    
    
                      } else {
  
    
    
                          alert("登录失败，原因是：" + data.msg);
  
    
    
                      }
  
    
    
                  });
  
    
    
              }
  
    
    
              $(function(){
  
    
    
                  $("#login-button").click(function(){
  
    
    
                      doLogin();
  
    
    
                  });
  
    
    
              });
  
    
    
          </script>
  
    
    
      </body>
  
    
    
  </html>

HttpClient 基础语法

这里封装了get，post请求的方法

 
   
   
 
  
    
    
  package com.itdragon.utils;
  
    
    
  
  
    
    
  import java.io.IOException;
  
    
    
  import java.net.URI;
  
    
    
  import java.util.ArrayList;
  
    
    
  import java.util.List;
  
    
    
  import java.util.Map;
  
    
    
  import org.apache.http.NameValuePair;
  
    
    
  import org.apache.http.client.entity.UrlEncodedFormEntity;
  
    
    
  import org.apache.http.client.methods.CloseableHttpResponse;
  
    
    
  import org.apache.http.client.methods.HttpGet;
  
    
    
  import org.apache.http.client.methods.HttpPost;
  
    
    
  import org.apache.http.client.utils.URIBuilder;
  
    
    
  import org.apache.http.entity.ContentType;
  
    
    
  import org.apache.http.entity.StringEntity;
  
    
    
  import org.apache.http.impl.client.CloseableHttpClient;
  
    
    
  import org.apache.http.impl.client.HttpClients;
  
    
    
  import org.apache.http.message.BasicNameValuePair;
  
    
    
  import org.apache.http.util.EntityUtils;
  
    
    
  
  
    
    
  public class HttpClientUtil {
  
    
    
  
  
    
    
      public static String doGet(String url) {                            // 无参数get请求
  
    
    
          return doGet(url, null);
  
    
    
      }
  
    
    
  
  
    
    
      public static String doGet(String url, Map<String, String> param) { // 带参数get请求
  
    
    
          CloseableHttpClient httpClient = HttpClients.createDefault();   // 创建一个默认可关闭的Httpclient 对象
  
    
    
          String resultMsg = "";                                          // 设置返回值
  
    
    
          CloseableHttpResponse response = null;                          // 定义HttpResponse 对象
  
    
    
          try {
  
    
    
              URIBuilder builder = new URIBuilder(url);                   // 创建URI,可以设置host，设置参数等
  
    
    
              if (param != null) {
  
    
    
                  for (String key : param.keySet()) {
  
    
    
                      builder.addParameter(key, param.get(key));
  
    
    
                  }
  
    
    
              }
  
    
    
              URI uri = builder.build();
  
    
    
              HttpGet httpGet = new HttpGet(uri);                         // 创建http GET请求
  
    
    
              response = httpClient.execute(httpGet);                     // 执行请求
  
    
    
              if (response.getStatusLine().getStatusCode() == 200) {      // 判断返回状态为200则给返回值赋值
  
    
    
                  resultMsg = EntityUtils.toString(response.getEntity(), "UTF-8");
  
    
    
              }
  
    
    
          } catch (Exception e) {
  
    
    
              e.printStackTrace();
  
    
    
          } finally {                                                     // 不要忘记关闭
  
    
    
              try {
  
    
    
                  if (response != null) {
  
    
    
                      response.close();
  
    
    
                  }
  
    
    
                  httpClient.close();
  
    
    
              } catch (IOException e) {
  
    
    
                  e.printStackTrace();
  
    
    
              }
  
    
    
          }
  
    
    
          return resultMsg;
  
    
    
      }
  
    
    
  
  
    
    
      public static String doPost(String url) {                           // 无参数post请求
  
    
    
          return doPost(url, null);
  
    
    
      }
  
    
    
  
  
    
    
      public static String doPost(String url, Map<String, String> param) {// 带参数post请求
  
    
    
          CloseableHttpClient httpClient = HttpClients.createDefault();   // 创建一个默认可关闭的Httpclient 对象
  
    
    
          CloseableHttpResponse response = null;
  
    
    
          String resultMsg = "";
  
    
    
          try {
  
    
    
              HttpPost httpPost = new HttpPost(url);                      // 创建Http Post请求
  
    
    
              if (param != null) {                                        // 创建参数列表
  
    
    
                  List<NameValuePair> paramList = new ArrayList<NameValuePair>();
  
    
    
                  for (String key : param.keySet()) {
  
    
    
                      paramList.add(new BasicNameValuePair(key, param.get(key)));
  
    
    
                  }
  
    
    
                  UrlEncodedFormEntity entity = new UrlEncodedFormEntity(paramList);// 模拟表单
  
    
    
                  httpPost.setEntity(entity);
  
    
    
              }
  
    
    
              response = httpClient.execute(httpPost);                    // 执行http请求
  
    
    
              if (response.getStatusLine().getStatusCode() == 200) {
  
    
    
                  resultMsg = EntityUtils.toString(response.getEntity(), "utf-8");
  
    
    
              }
  
    
    
          } catch (Exception e) {
  
    
    
              e.printStackTrace();
  
    
    
          } finally {
  
    
    
              try {
  
    
    
                  if (response != null) {
  
    
    
                      response.close();
  
    
    
                  }
  
    
    
                  httpClient.close();
  
    
    
              } catch (IOException e) {
  
    
    
                  e.printStackTrace();
  
    
    
              }
  
    
    
          }
  
    
    
          return resultMsg;
  
    
    
      }
  
    
    
  
  
    
    
      public static String doPostJson(String url, String json) {
  
    
    
          CloseableHttpClient httpClient = HttpClients.createDefault();
  
    
    
          CloseableHttpResponse response = null;
  
    
    
          String resultString = "";
  
    
    
          try {
  
    
    
              HttpPost httpPost = new HttpPost(url);
  
    
    
              StringEntity entity = new StringEntity(json, ContentType.APPLICATION_JSON);
  
    
    
              httpPost.setEntity(entity);
  
    
    
              response = httpClient.execute(httpPost);
  
    
    
              if (response.getStatusLine().getStatusCode() == 200) {
  
    
    
                  resultString = EntityUtils.toString(response.getEntity(), "utf-8");
  
    
    
              }
  
    
    
          } catch (Exception e) {
  
    
    
              e.printStackTrace();
  
    
    
          } finally {
  
    
    
              try {
  
    
    
                  if (response != null) {
  
    
    
                      response.close();
  
    
    
                  }
  
    
    
                  httpClient.close();
  
    
    
              } catch (IOException e) {
  
    
    
                  e.printStackTrace();
  
    
    
              }
  
    
    
          }
  
    
    
          return resultString;
  
    
    
      }
  
    
    
  }

Spring 自定义拦截器

这里是另外一个项目 itdragon-service-test-sso 中的代码，首先在src/main/resources/spring/springmvc.xml 中配置拦截器，设置那些请求需要拦截

 
   
   
 
  
    
    
      <!-- 拦截器配置 -->
  
    
    
      <mvc:interceptors>
  
    
    
          <mvc:interceptor>
  
    
    
              <mvc:mapping path="/github/**"/>
  
    
    
              <bean class="com.itdragon.interceptors.UserLoginHandlerInterceptor"/>
  
    
    
          </mvc:interceptor>
  
    
    
      </mvc:interceptors>

然后在 src/main/java/com/itdragon/interceptors 目录下创建 UserLoginHandlerInterceptor.java 文件

 
   
   
 
  
    
    
  package com.itdragon.interceptors;
  
    
    
  
  
    
    
  import javax.servlet.http.HttpServletRequest;
  
    
    
  import javax.servlet.http.HttpServletResponse;
  
    
    
  import org.springframework.beans.factory.annotation.Autowired;
  
    
    
  import org.springframework.util.StringUtils;
  
    
    
  import org.springframework.web.servlet.HandlerInterceptor;
  
    
    
  import org.springframework.web.servlet.ModelAndView;
  
    
    
  import com.itdragon.pojo.User;
  
    
    
  import com.itdragon.service.UserService;
  
    
    
  import com.itdragon.utils.CookieUtils;
  
    
    
  
  
    
    
  public class UserLoginHandlerInterceptor implements HandlerInterceptor {
  
    
    
  
  
    
    
      public static final String COOKIE_NAME = "USER_TOKEN";
  
    
    
  
  
    
    
      @Autowired
  
    
    
      private UserService userService;
  
    
    
  
  
    
    
      @Override
  
    
    
      public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
  
    
    
              throws Exception {
  
    
    
          String token = CookieUtils.getCookieValue(request, COOKIE_NAME);
  
    
    
          User user = this.userService.getUserByToken(token);
  
    
    
          if (StringUtils.isEmpty(token) || null == user) {
  
    
    
              // 跳转到登录页面，把用户请求的url作为参数传递给登录页面。
  
    
    
              response.sendRedirect("http://localhost:8081/login?redirect=" + request.getRequestURL());
  
    
    
              // 返回false
  
    
    
              return false;
  
    
    
          }
  
    
    
          // 把用户信息放入Request
  
    
    
          request.setAttribute("user", user);
  
    
    
          // 返回值决定handler是否执行。true：执行，false：不执行。
  
    
    
          return true;
  
    
    
      }
  
    
    
  
  
    
    
      @Override
  
    
    
      public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler,
  
    
    
              ModelAndView modelAndView) throws Exception {
  
    
    
      }
  
    
    
  
  
    
    
      @Override
  
    
    
      public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler,
  
    
    
              Exception ex) throws Exception {
  
    
    
      }
  
    
    
  }

可能存在的问题

SpringData 自动更新问题

SpringData 是基于Hibernate的。当User 已经是持久化对象，被保存在session缓存当中。若User又重新修改属性值，在提交事务时，此时hibernate对象就会拿当前这个User对象和保存在session缓存中的User对象进行比较，如果两个对象相同，则不会发送update语句，否则，会发出update语句。笔者采用比较傻的方法，就是在提交事务之前把数据还原。各位如果有更好的办法请告知，谢谢！参考博客：http://www.cnblogs.com/xiaoluo501395377/p/3380270.html

检查用户信息是否保存

登录成功后，进入Redis客户端查看用户信息是否保存成功。同时为了方便测试，也可以删除这个key。

 
   
   
 
  
    
    
  [root@localhost bin]# ./redis-cli -h 192.168.225.131 -p 6379
  
    
    
  192.168.225.131:6379> 
  
    
    
  192.168.225.131:6379> keys *
  
    
    
  1) "REDIS_USER_SESSION:1d869ac0-3d22-4e22-bca0-37c8dfade9ad"
  
    
    
  192.168.225.131:6379> get REDIS_USER_SESSION:1d869ac0-3d22-4e22-bca0-37c8dfade9ad
  
    
    
  "{\"id\":3,\"account\":\"itdragon\",\"userName\":\"ITDragonGit\",\"plainPassword\":null,\"password\":null,\"salt\":null,\"iphone\":\"12349857999\",\"email\":\"itdragon@git.com\",\"platform\":\"github\",\"createdDate\":\"2017-12-22 21:11:19\",\"updatedDate\":\"2017-12-22 21:11:19\"}"

总结

1 单点登录系统通过将用户信息放在Redis数据库中实现共享Session效果。 2 Java 配置方式使用四个注解 @Configuration @Bean @PropertySource @Value 。 3 Spring 拦截器的设置。 4 HttpClient 的使用 5 祝大家圣诞节快乐

源码：https://github.com/ITDragonBlog/daydayup/tree/master/SpringBoot/SSO

到这里，基于SpringBoot的单点登录系统就结束了，有什么不对的地方请指出。

觉得本文对你有帮助？请分享给更多人。

以上是关于单点登录，java实现的主要内容，如果未能解决你的问题，请参考以下文章

PHP怎么实现单点登录

用java来实现单点登录大概都有哪些种方法

单点登录原理和java实现简单的单点登录

CAS单点登录，怎么实现注册后自动登录。用java实现

java实现的单点登录

java实现简单的单点登录