sso單點登錄的入門（Session跨域、Spring-Session共享）

1、單點登錄，就是多系統，單一位置登錄，實現多系統同時登錄的一種技術。單點登錄一般是用於互相授信的系統，實現單一位置登錄，全系統有效的。

　　注意：區分與三方登錄（第三方登錄） ，三方登錄：某系統，使用其他系統的用戶，實現本系統登錄的方式。如，在王者榮耀中使用微信或者QQ登錄。解決信息孤島和用戶不對等的實現方案。

2、單點登錄方案選擇：

2.1、方案一、Session跨域（熟悉即可）。

所謂Session跨域就是摒棄了系統（Tomcat）提供的Session，而使用自定義的類似Session的機制來保存客戶端數據的一種解決方案。
如：通過設置cookie的domain來實現cookie的跨域傳遞。在cookie中傳遞一個自定義的session_id。這個session_id是客戶端的唯一標記。將這個標記作為key，將客戶端需要保存的數據作為value，在服務端進行保存（數據庫保存或NoSQL保存）。這種機制就是Session的跨域解決。
什么跨域： 客戶端請求的時候，請求的服務器，不是同一個IP，端口，域名，主機名的時候，都稱為跨域。
什么是域：在應用模型，一個完整的，有獨立訪問路徑的功能集合稱為一個域。如：百度稱為一個應用或系統。百度下有若干的域，如：搜索引擎（www.baidu.com），百度貼吧（tie.baidu.com），百度知道（zhidao.baidu.com），百度地圖（map.baidu.com）等。域信息，有時也稱為多級域名。域的划分： 以IP，端口，域名，主機名為標准，實現划分。
localhost / 127.0.0.1

使用cookie跨域共享，是session跨域的一種解決方案。
jsessionid是和servlet綁定的http session的唯一標記。

cookie應用 - new Cookie("", "").  
request.getCookies() -> cookie[] -> 迭代找到需要使用的cookie
response.addCookie().
cookie.setDomain() - 為cookie設定有效域范圍。
cookie.setPath() - 為cookie設定有效URI范圍。

代碼實現如下所示：

package com.bie.controller;

import java.util.UUID;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

import com.bie.utils.CookieUtils;

/**
 * 
 * @author biehl
 * 
 *         1、單點登錄實現方案一，Session跨域實現
 */
@Controller
public class SsoController {

    /**
     * 請求控制層的方法
     * 
     * @param request
     * @param response
     * @return
     */
    @RequestMapping("/sso")
    public String test(HttpServletRequest request, HttpServletResponse response) {
        // JSESSIONID代表了系統中http的唯一標記

        // custom_global_session_id。全局session的id
        String cookieName = "custom_global_session_id";
        String encodeString = "UTF-8";

        // 獲取到cookie的value值
        String cookieValue = CookieUtils.getCookieValue(request, cookieName, encodeString);

        // 判斷cookie的value值是否為空
        if (null == cookieValue || "".equals(cookieValue.trim())) {
            System.out.println("無cookie，生成新的cookie數據");
            // 生成一個cookie的value值
            cookieValue = UUID.randomUUID().toString();
        }

        // 根據cookieValue訪問數據存儲，獲取客戶端數據。
        // 將生產的cookie的value值設置到cookie中
        // 參數0代表關閉瀏覽器自動刪除cookie.
        CookieUtils.setCookie(request, response, cookieName, cookieValue, 0, encodeString);
        
        return "/ok.jsp";
    }

}

解析域名和設置cookie的方法工具類：

package com.bie.utils;

import java.io.UnsupportedEncodingException;
import java.net.URLDecoder;
import java.net.URLEncoder;

import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

/**
 * 
 * Cookie 工具類
 *
 */
public final class CookieUtils {

    /**
     * 得到Cookie的值, 不編碼
     * 
     * @param request
     * @param cookieName
     * @return
     */
    public static String getCookieValue(HttpServletRequest request, String cookieName) {
        return getCookieValue(request, cookieName, false);
    }

    /**
     * 得到Cookie的值,
     * 
     * @param request
     * @param cookieName
     * @return
     */
    public static String getCookieValue(HttpServletRequest request, String cookieName, boolean isDecoder) {
        Cookie[] cookieList = request.getCookies();
        if (cookieList == null || cookieName == null) {
            return null;
        }
        String retValue = null;
        try {
            for (int i = 0; i < cookieList.length; i++) {
                if (cookieList[i].getName().equals(cookieName)) {
                    if (isDecoder) {
                        retValue = URLDecoder.decode(cookieList[i].getValue(), "UTF-8");
                    } else {
                        retValue = cookieList[i].getValue();
                    }
                    break;
                }
            }
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
        return retValue;
    }

    /**
     * 得到Cookie的值,
     * 
     * @param request
     * @param cookieName
     * @return
     */
    public static String getCookieValue(HttpServletRequest request, String cookieName, String encodeString) {
        Cookie[] cookieList = request.getCookies();
        if (cookieList == null || cookieName == null) {
            return null;
        }
        String retValue = null;
        try {
            for (int i = 0; i < cookieList.length; i++) {
                if (cookieList[i].getName().equals(cookieName)) {
                    retValue = URLDecoder.decode(cookieList[i].getValue(), encodeString);
                    break;
                }
            }
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
        return retValue;
    }

    /**
     * 設置Cookie的值 不設置生效時間默認瀏覽器關閉即失效,也不編碼
     */
    public static void setCookie(HttpServletRequest request, HttpServletResponse response, String cookieName,
            String cookieValue) {
        setCookie(request, response, cookieName, cookieValue, -1);
    }

    /**
     * 設置Cookie的值 在指定時間內生效,但不編碼
     */
    public static void setCookie(HttpServletRequest request, HttpServletResponse response, String cookieName,
            String cookieValue, int cookieMaxage) {
        setCookie(request, response, cookieName, cookieValue, cookieMaxage, false);
    }

    /**
     * 設置Cookie的值 不設置生效時間,但編碼
     */
    public static void setCookie(HttpServletRequest request, HttpServletResponse response, String cookieName,
            String cookieValue, boolean isEncode) {
        setCookie(request, response, cookieName, cookieValue, -1, isEncode);
    }

    /**
     * 設置Cookie的值 在指定時間內生效, 編碼參數
     */
    public static void setCookie(HttpServletRequest request, HttpServletResponse response, String cookieName,
            String cookieValue, int cookieMaxage, boolean isEncode) {
        doSetCookie(request, response, cookieName, cookieValue, cookieMaxage, isEncode);
    }

    /**
     * 設置Cookie的值 在指定時間內生效, 編碼參數(指定編碼)
     */
    public static void setCookie(HttpServletRequest request, HttpServletResponse response, String cookieName,
            String cookieValue, int cookieMaxage, String encodeString) {
        doSetCookie(request, response, cookieName, cookieValue, cookieMaxage, encodeString);
    }

    /**
     * 刪除Cookie帶cookie域名
     */
    public static void deleteCookie(HttpServletRequest request, HttpServletResponse response, String cookieName) {
        doSetCookie(request, response, cookieName, "", -1, false);
    }

    /**
     * 設置Cookie的值，並使其在指定時間內生效
     * 
     * @param request
     *            請求，請求對象，分析域信息
     * @param response
     *            響應
     * @param cookieName
     *            cookie的名稱
     * @param cookieValue
     *            cookie的值
     * @param cookieMaxage
     *            cookie生效的最大秒數。不做設定，關閉瀏覽器就無效了
     * @param isEncode
     *            是否需要編碼
     */
    private static final void doSetCookie(HttpServletRequest request, HttpServletResponse response, String cookieName,
            String cookieValue, int cookieMaxage, boolean isEncode) {
        try {
            // 判斷cookie的value值是否等於null
            if (cookieValue == null) {
                cookieValue = "";
            } else if (isEncode) {
                // 判斷是否需要utf8編碼
                cookieValue = URLEncoder.encode(cookieValue, "utf-8");
            }
            // 創建cookie，最好做非空判斷的
            Cookie cookie = new Cookie(cookieName, cookieValue);
            if (cookieMaxage > 0) {
                // 如果cookie生效的最大秒數大於0，就設置這個值
                cookie.setMaxAge(cookieMaxage);
            }
            if (null != request) {
                // 分析解析域名
                String domainName = getDomainName(request);
                // 如果不等於localhost這個值，就設置一個domainName
                if (!"localhost".equals(domainName)) {
                    // 設置域名的cookie
                    cookie.setDomain(domainName);
                }
            }
            // 從根路徑下的后面任意路徑地址,cookie都有效
            cookie.setPath("/");
            // response響應寫入到客戶端即可
            response.addCookie(cookie);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 設置Cookie的值，並使其在指定時間內生效
     * 
     * @param request
     * @param response
     * @param cookieName
     * @param cookieValue
     * @param cookieMaxage
     *            cookie生效的最大秒數
     * @param encodeString
     */
    private static final void doSetCookie(HttpServletRequest request, HttpServletResponse response, String cookieName,
            String cookieValue, int cookieMaxage, String encodeString) {
        try {
            if (cookieValue == null) {
                cookieValue = "";
            } else {
                cookieValue = URLEncoder.encode(cookieValue, encodeString);
            }
            Cookie cookie = new Cookie(cookieName, cookieValue);
            if (cookieMaxage > 0)
                cookie.setMaxAge(cookieMaxage);
            if (null != request) {
                // 根據獲取到的request請求，設置域名的cookie
                String domainName = getDomainName(request);
                if (!"localhost".equals(domainName)) {
                    // 設定一個域名。cookie就可以實現跨域訪問了。
                    cookie.setDomain(domainName);
                }
            }
            cookie.setPath("/");
            response.addCookie(cookie);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 得到cookie的域名
     * 
     * @param request
     *            請求對象，包含了請求的信息
     * @return
     */
    private static final String getDomainName(HttpServletRequest request) {
        // 定義一個變量domainName
        String domainName = null;

        // 獲取完整的請求URL地址。請求url，轉換為字符串類型
        String serverName = request.getRequestURL().toString();
        // 判斷如果請求url地址為空或者為null
        if (serverName == null || serverName.equals("")) {
            domainName = "";
        } else {
            // 不為空或者不為null，將域名轉換為小寫。域名不敏感的。大小寫一樣
            serverName = serverName.toLowerCase();
            // 判斷開始如果以http://開頭的
            if (serverName.startsWith("http://")) {
                // 截取前七位字符
                serverName = serverName.substring(7);
            } else if (serverName.startsWith("https://")) {
                // 否則如果開始以https://開始的。//截取前八位字符
                serverName = serverName.substring(8);
            }
            // 找到/開始的位置，可以判斷end的值是否為-1，如果為-1的話說明沒有這個值
            // 如果存在這個值，找到這個值的位置，否則返回值為-1
            final int end = serverName.indexOf("/");
            // .test.com www.test.com.cn/sso.test.com.cn/.test.com.cn spring.io/xxxx/xxx
            // 然后截取到0開始到/的位置
            if (end != -1) {
                // end等於-1。說明沒有/。否則end不等於-1說明有這個值
                serverName = serverName.substring(0, end);
                // 這是將\\.是轉義為.。然后進行分割操作。
                final String[] domains = serverName.split("\\.");
                // 獲取到長度
                int len = domains.length;
                // 注意，如果是兩截域名，一般沒有二級域名。比如spring.io/xxx/xxx，都是在spring.io后面/拼接的
                // 如果是三截域名，都是以第一截為核心分割的。
                // 如果是兩截的就保留。三截以及多截的就
                // 多截進行匹配域名規則，第一個相當於寫*，然后加.拼接后面的域名地址
                if (len > 3) {
                    // 如果是大於等於3截的，去掉第一個點之前的。留下剩下的域名
                    domainName = "." + domains[len - 3] + "." + domains[len - 2] + "." + domains[len - 1];
                } else if (len <= 3 && len > 1) {
                    // 如果是2截和3截保留
                    domainName = "." + domains[len - 2] + "." + domains[len - 1];
                } else {
                    domainName = serverName;
                }
            }
        }
        // 如果域名不為空並且有這個:
        if (domainName != null && domainName.indexOf(":") > 0) {
            // 將:轉義。去掉端口port號，cookie（cookie的domainName）和端口無關。只看域名的。
            String[] ary = domainName.split("\\:");
            domainName = ary[0];
        }
        // 返回域名
        System.out.println("==============================================" + domainName);
        return domainName;
    }

    public static void main(String[] args) {
        String serverName = "http://www.baidu.com/a";
        String domainName = null;
        // 判斷如果請求url地址為空或者為null
        if (serverName == null || serverName.equals("")) {
            domainName = "";
        } else {
            // 不為空或者不為null，將域名轉換為小寫。域名不敏感的。大小寫一樣
            serverName = serverName.toLowerCase();
            // 判斷開始如果以http://開頭的
            if (serverName.startsWith("http://")) {
                // 截取前七位字符
                serverName = serverName.substring(7);
            } else if (serverName.startsWith("https://")) {
                // 否則如果開始以https://開始的。//截取前八位字符
                serverName = serverName.substring(8);
            }
            // 找到/開始的位置，可以判斷end的值是否為-1，如果為-1的話說明沒有這個值
            final int end = serverName.indexOf("/");
            // .test.com www.test.com.cn/sso.test.com.cn/.test.com.cn spring.io/xxxx/xxx
            // 然后截取到0開始到/的位置
            serverName = serverName.substring(0, end);
            final String[] domains = serverName.split("\\.");
            int len = domains.length;
            if (len > 3) {
                domainName = "." + domains[len - 3] + "." + domains[len - 2] + "." + domains[len - 1];
            } else if (len <= 3 && len > 1) {
                domainName = "." + domains[len - 2] + "." + domains[len - 1];
            } else {
                domainName = serverName;
            }
        }

        if (domainName != null && domainName.indexOf(":") > 0) {
            String[] ary = domainName.split("\\:");
            domainName = ary[0];
        }
    }

}

效果實現如下所示：

C:\Windows\System32\drivers\etc\host配置文件配置一下地址映射。

# sso test
192.168.0.102    www.test.com
192.168.0.102    sso.test.com
192.168.0.102    cart.test.com

 

域名訪問，實現session跨域的效果：

2.2、Spring Session共享（ 了解即可）。

spring-session技術是spring提供的用於處理集群會話共享的解決方案。spring-session技術是將用戶session數據保存到三方存儲容器中，如：mysql，redis等。
Spring-session技術是解決同域名下的多服務器集群session共享問題的。不能解決跨域session共享問題（如果要解決跨域sesion，就要搭建前端服務器nginx來解決這個問題）。
使用要求：
 　　配置一個Spring提供的Filter，實現數據的攔截保存，並轉換為spring-session需要的會話對象。必須提供一個數據庫的表格信息（由spring-session提供，找spring-session-jdbc.jar/org/springframework/session/jdbc/*.sql,根據具體的數據庫找對應的SQL文件，做表格的創建）。
spring-session表：保存客戶端session對象的表格。
spring-session-attributes表：保存客戶端session中的attributes屬性數據的表格。
spring-session框架，是結合Servlet技術中的HTTPSession完成的會話共享機制。在代碼中是直接操作HttpSession對象的。

Spring Session共享、圖示如下所示：

基於Spring-session的代碼實現如下所示：

首先在配置文件中配置spring-session的filter攔截器。

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns="http://java.sun.com/xml/ns/javaee"
    xsi:schemaLocation="http://java.sun.com/xml/ns/javaee 
    http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
    id="WebApp_ID" version="2.5">

    <display-name>sso-cross-domain</display-name>

    <welcome-file-list>
        <welcome-file>index.html</welcome-file>
    </welcome-file-list>

    <!-- 重要:spring-session的filter攔截器 完成數據轉換的攔截器，spring提供的filter實現數據的攔截保存並轉換為spring-session所需的會話對象中。 -->
    <filter>
        <filter-name>springSessionRepositoryFilter</filter-name>
        <filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class>
    </filter>
    <filter-mapping>
        <filter-name>springSessionRepositoryFilter</filter-name>
        <url-pattern>/*</url-pattern>
        <dispatcher>REQUEST</dispatcher>
        <dispatcher>ERROR</dispatcher>
    </filter-mapping>

    <!-- 字符集過濾器 -->
    <filter>
        <filter-name>charSetFilter</filter-name>
        <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
        <init-param>
            <param-name>encoding</param-name>
            <param-value>UTF-8</param-value>
        </init-param>
    </filter>
    <filter-mapping>
        <filter-name>charSetFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

    <!-- 加載springmvc的配置文件 -->
    <servlet>
        <servlet-name>mvc</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:applicationContext-mvc.xml</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>mvc</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>


</web-app>

然后配置提供數據庫的表格信息：

mysql文件路徑在這里，找到以后運行一下sql即可。/org/springframework/session/jdbc/schema-mysql.sql。

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:mvc="http://www.springframework.org/schema/mvc"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:dwr="http://directwebremoting.org/schema/spring-dwr/spring-dwr-3.0.xsd"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/mvc
        http://www.springframework.org/schema/mvc/spring-mvc.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd">
    
    <!-- 指定掃描的包 -->
    <context:component-scan base-package="com.bie.controller" />

    <!-- 為SpringMVC配置注解驅動 -->
    <mvc:annotation-driven />

    <!-- 為Spring基礎容器開啟注解配置信息 -->
    <context:annotation-config />
    <!-- 就是用於提供HttpSession數據持久化操作的Bean對象。 
        對象定義后，可以實現數據庫相關操作配置，自動的實現HttpSession數據的持久化操作（CRUD）
     -->
    <bean class="org.springframework.session.jdbc.config.annotation.web.http.JdbcHttpSessionConfiguration" />


    <bean id="dataSource"
        class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="url"
            value="jdbc:mysql://localhost:3306/springsession?useUnicode=true&amp;characterEncoding=UTF8"></property>
        <property name="username" value="root"></property>
        <property name="password" value="123456"></property>
        <property name="driverClassName"
            value="com.mysql.jdbc.Driver"></property>
    </bean>

    <!-- 事務管理器。為JdbcHttpSessionConfiguration提供的事務管理器。 -->
    <bean
        class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <constructor-arg ref="dataSource" />
    </bean>

</beans>

簡單的控制層代碼；

package com.bie.controller;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

/**
 * 
 * @author biehl
 * 
 *         1、SpringSession
 * 
 *         spring-session表：保存客戶端session對象的表格。
 *         spring-session-attributes表：保存客戶端session中的attributes屬性數據的表格。
 *         spring-session框架，是結合Servlet技術中的HTTPSession完成的會話共享機制。在代碼中是直接操作HttpSession對象的。
 * 
 */
@Controller
public class SpringSessionController {

    @RequestMapping("/springSession")
    public String test(HttpServletRequest request, HttpServletResponse response) {
        // 獲取到attrName屬性值
        Object attrName = request.getSession().getAttribute("attrName");
        // 如果獲取到的獲取到attrName屬性值為空
        if (null == attrName) {
            // 獲取到attrName屬性值設置到session中
            request.getSession().setAttribute("attrName", "attrValue");
        }
        // 后台打印消息
        System.out.println("80: " + attrName);
        // 返回到jsp頁面
        return "/ok.jsp";
    }

}

頁面效果如下所示：

然后發現，請求數據已經自動入庫了，時間到期后自動刪除。