SSO系列之——同域下单点登录系统介绍

Single-Sign-On即单点登录，从一个页面登录，就可以访问其他互信系统，避免用户重新登录，例如登录了百度，则百度云等其他百度旗下其他网站均可免登录访问。在整个业务服务群中起到了辅助、集成的作用。 

SSO体系结构

1. 客户端调用模块

2. 认证中心

   认证中心是SSO系统的核心，它先验证用户是否有权限访问系统，如果有让用户访问系统资源；如果没有，提供一个登录页面。

3. 用户管理系统和用户数据获取接口

   用于为认证中心提供用户验证数据支持

4. 令牌 token

   用户验证期间，生成token，保存，如果用户再次登入其他授信系统，则直接验证token信息是否正确以确定用户是否进入资源访问，无需第二次重复登录。

5. 整体流程：客户端调用应用系统，通过同一的认证中心进行信息验证，认证中心通过访问数据库接口，进行用户信息核对，生成token允许用户访问应用系统资源。 

SSO认证流程

1. 获取唯一标识token

2. 验证该标识是否存在且有效，若不存在，或者token无效，均重定向到指定登录页，生成token；

3. 再次验证，判断用户是否进入系统

SSO系统的必要模块

例如创建一个user表及其对应实体，SSOServer 代码演示,创建服务端loginServlet，用于获取request用户信息、认证用户、生成token操作

[html]  view plain  copy

1. @WebServlet("/login")  
2. public class UserLoginServlet extends HttpServlet{  
3.     private static final long serialVersionUID = 1L;  
4.     private UserAccountService accountService;  
5.     @Override  
6.     protected void doGet(HttpServletRequest req, HttpServletResponse resp)  
7.             throws ServletException, IOException {  
8.         //获得原始请求的URL并保存传递，登录成功时，让浏览器再次跳转到该URL  
9.         String origURL =req.getParameter("origURL");  
10.         req.setAttribute("origURL", origURL);//目的在于在整个会话中，把原始的请求地址保存到req中  
11.         req.getRequestDispatcher("WEB-INFO/view/login.jsp").forward(req, resp);  
12.     }  
13.   
14.     @Override  
15.     protected void doPost(HttpServletRequest req, HttpServletResponse resp)  
16.             throws ServletException, IOException {  
17.         String account=req.getParameter("account");  
18.         String password=req.getParameter("password");  
19.         String origURL=req.getParameter("origURL");  
20.           
21.         //按照account查找用户  
22.         User user=null;  
23.         try{  
24.             user=accountService.findUserByAccout(account);  
25.             if(user!=null)  
26.             {  
27.                 if(user.getPassword()==password)//.equals(password)  
28.                 {  
29.                     //1、生成token java UUID随机生成  
30.                         String token=UUID.randomUUID().toString().replace("-", "").toLowerCase();  
31.                     //2、将token存到全局唯一数据结构中  
32.                         TokenUserData.addToken(token, user);  
33.                     //3、写入cookie  
34.                         Cookie tokenCookie=new Cookie("token", token);  
35.                         tokenCookie.setPath("/");//localhost:8091 同一个域，不同路径；  
36.                         tokenCookie.setHttpOnly(true);  
37.                         resp.addCookie(tokenCookie);  
38.                     //4、跳转请求  
39.                         if(origURL!=null)  
40.                         {  
41.                             origURL="login_success";  
42.                         }else{  
43.                             origURL=URLDecoder.decode(origURL,"utf-8");  
44.                         }  
45.                         resp.sendRedirect(origURL);  
46.                     }else  
47.                     {  
48.                         backToLoginPage(req, resp, account, origURL, "密码不正确");  
49.                     }  
50.             }else  
51.             {  
52.                 this.backToLoginPage(req, resp, account, origURL, "用户不存在");  
53.             }  
54.         }catch(Exception e)  
55.         {  
56.             e.printStackTrace();  
57.             backToLoginPage(req, resp, account, origURL, "系统错误");  
58.               
59.         }  
60.               
61.     }  
62.       
63.     private void backToLoginPage(HttpServletRequest req,  
64.             HttpServletResponse resp, String account, String origURL,  
65.             String errInfo) throws ServletException, IOException {  
66.         req.setAttribute("origURL", origURL);  
67.         req.setAttribute("account", account);  
68.         req.setAttribute("errInfo", errInfo);  
69.         req.getRequestDispatcher("/WEB-INF/view/login.jsp").forward(req, resp);  
70.   
71.     }  

SSO客户端模块Filter

[html]  view plain  copy

1. public class SSOFilter implements Filter {  
2.     // SSO Server登录页面URL  
3.     private static final String SSO_LOGIN_URL = "/server/login",  
4.             SSO_VALIDATE_URL = <a target=_blank href="http://localhost:8080/server/validate">http://localhost:8080/server/validate</a>;  
5.     // 拦截操作  
6.     @Override  
7.     public void doFilter(ServletRequest request, ServletResponse response,  
8.             FilterChain chain) throws IOException, ServletException {  
9.         HttpServletRequest req = (HttpServletRequest) request;  
10.         HttpServletResponse resp = (HttpServletResponse) response;  
11.   
12.         // 从请求中提取token-已从服务端将token信息写入cookie  
13.         String token = CookieUtil.getCookie(req, "token");  
14.   
15.         // 本次请求的完整路径  
16.         String origUrl = req.getRequestURL().toString();  
17.         String queryStr = req.getQueryString();  
18.         if (queryStr != null) {  
19.             origUrl += "?" + queryStr;  
20.         }  
21.         // token 不存在，跳转到SSOServer用户登录页  
22.         if (token == null) {  
23.             resp.sendRedirect(SSO_LOGIN_URL + "?origUrl="  
24.                     + URLEncoder.encode(origUrl, "utf-8"));  
25.         } else { // token存在，验证有效性  
26.             URL validateUrl = new URL(SSO_VALIDATE_URL + "?token=" + token);  
27.             HttpURLConnection conn = (HttpURLConnection) validateUrl  
28.                     .openConnection();  
29.             conn.connect();  
30.             InputStream is = conn.getInputStream();  
31.             byte[] buffer = new byte[is.available()];  
32.             is.read(buffer);  
33.             String ret = new String(buffer);  
34.   
35.             if (ret.length() == 0) { // 返回空字符串，表示 token无效  
36.                 resp.sendRedirect(SSO_LOGIN_URL + "?origUrl="  
37.                         + URLEncoder.encode(origUrl, "utf-8"));  
38.             } else {  
39.                 String[] tmp = ret.split(";");  
40.                 User user = new User();  
41.                 for (int i = 0; i < tmp.length; ++i) {  
42.                     String[] attrs = tmp[i].split("=");  
43.                     switch (attrs[0]) {  
44.                     case "id":  
45.                         user.setId(Integer.parseInt(attrs[1]));  
46.                         break;  
47.                     case "name":  
48.                         user.setName(attrs[1]);  
49.                         break;  
50.                     case "account":  
51.                         user.setAccount(attrs[1]);  
52.                         break;  
53.                     }  
54.                 }  
55.                 request.setAttribute("user", user);  
56.                 chain.doFilter(request, response);  
57.             }  
58.         }  
59.     }  

客户端调用模块：直接在客户端的web.xml中配置上面SSOClient的Filter，对所有的jsp页面进行拦截；而SSOClient通过从cookie获取服务器写入的token进行认证；并保留生成的token信息，实现单点登录。

[html]  view plain  copy

1. <filter>  
2.     <filter-name>sso</filter-name>  
3.     <filter-class>demo.sso.client.SSOFilter</filter-class>  
4.  </filter>  
5.    
6.  <filter-mapping>  
7.     <filter-name>sso</filter-name>  
8.     <url-pattern>*.jsp</url-pattern>  
9.  </filter-mapping>  

    本文介绍的是同域下单点登录的实现思路和验证流程，接下来会对其他应用场景的SSO应用进行学习，敬请期待。