單點登錄（SSO）對接--過濾器鏈

定義：在多個應用系統中，用戶只需要登錄一次就可以訪問所有相互信任的應用系統。它包括可以將這次主要的登錄映射到其他應用中用於同一個用戶的登錄的機制,這就是單點登錄。

技術實現機制：當用戶第一次訪問應用系統的時候，因為還沒有登錄，會被引導到認證系統中進行登錄；根據用戶提供的登錄信息，認證系統進行身份校驗，如果通過校驗，應該返回給用戶一個認證的憑據－－ticket；用戶再訪問別的應用的時候，就會將這個ticket帶上，作為自己認證的憑據，應用系統接受到請求之后會把ticket送到認證系統進行校驗，檢查ticket的合法性。如果通過校驗，用戶就可以在不用再次登錄的情況下訪問應用系統2和應用系統3了。

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　-----百度百科

　　有這么一個需求，比如你做的產品只是一個大的系統的子系統，比如學校的管理系統中的一部分(比如教務，學工等)，這些都是學校使用系統中的N個系統中的一個，為了方便統一管理，學校會有一個門戶系統，教師和學生只需要登錄門戶系統，就可以進入教務系統查課表，學工系統分配班級等等，這些系統或許來自不同的公司，但是它們都被集成在門戶系統中，做為一個子系統的形式存在，你現在的公司就是其中的一個模塊（子系統）的供應商，那么你在把你做的產品放在學校服務器上的同時，也需要把自己公司的系統集成到學校的門戶系統中，那么就需要集成單點登錄。

　　那么前面這個需求怎么做呢，好吧這就是我的一個任務，我現在就是一個子系統公司的開發人員，我們公司的產品賣給了N個學校，這些學校的門戶系統各異，每賣出一個系統就為那個學校配置一遍單點登錄實在是麻煩，大家也知道單點登錄就是在web.xml配置幾個過濾器，監聽器，然后改造自己的登錄口，把登錄口的地址反饋給集成方就可以，這是一個簡單的過程，但是我深信不疑的墨菲定律在無時無刻的起着作用，如果事情有變壞的可能，不管這種可能性有多小，它總會發生。那么我需要做的就是提供接口和盡可能多的不同對接廠商的實現，讓實施工程師去通過配置直接完成集成單點登錄的功能。

　　思路：前面說了，配置單點登錄很簡單，就是把廠商提供的過濾器和監聽器放到web.xml中，再提供一個cas登錄的action（請求）,這個工作就算完成了，問題就在於不同的集成廠商他們的過濾器不一樣，當然參數是大同小異.那么提起不一樣和一樣，我首先想到的是一樣的接口，不一樣的實現類。然后就是過濾器，不同的過濾器怎么使用呢，這就引入了我寫這篇博客的目的，過濾器鏈。

　　注意：這里引出了過濾器鏈，這是一種設計模式，叫做責任鏈設計模式，我看到有一篇博客對他具有很好的解釋 http://www.flyne.org/article/693，可自行參閱

　　實現：首先你需要有自己的過濾器和監聽器，監聽自然不多說，那過濾器呢，你只需要把廠商的過濾器作為一個過濾器鏈，使用你的過濾器去執行這條鏈，以達到代碼可控的地步。

　　代碼實現：

常量類，因為很多相關類都要用到，這里就寫到接口里面.

public interface CasConst {
    
    public static final String CAS_STATE_ON = "on"; // 開啟統一身份驗證
    public static final String CAS_STATE_OFF = "off"; // 關閉統一身份驗證

    public static final String CAS_STATE = "cas.state";// 開啟 關閉
    public static final String CAS_MANUFACTURER = "cas.manufacturer";// 對接廠商
    public static final String CAS_SERVERURLPREFIX = "cas.serverUrlPrefix";// CAS服務URL
    public static final String CAS_SERVERLOGINURL = "cas.serverLoginUrl";// CAS服務認證頁URL
    public static final String CAS_SERVERNAME = "cas.serverName";// 系統訪問地址
    public static final String CAD_SERVERLOGOUTURL = "cas.serverLogoutUrl";
    public static final String CAS_ENCODING = "cas.encoding";// 認證編碼格式
    public static final String CAS_PARAM = "cas.param";// 反饋賬號參數名
    
}

1.接口，定義一個廠商的接口類，提供了，獲得過濾器集合，獲得監聽器（監聽器只有一個），獲得用戶信息的方法。

public interface Authentication {
    
    /**
     * 獲得統一認證過濾器鏈
     * @param filterConfig filterConfig對象
     * @return
     * @throws ServletException
     */
    List<Filter> getFilters(FilterConfig filterConfig) throws ServletException;

    /**
     * 根據廠商認證信息獲得user對象
     * @param request request對象
     * @return
     * @throws LoginException
     */
    public User authentication(HttpServletRequest request) throws LoginException;
    
    /**
     * 獲得廠商提供監聽器
     * @return
     */
    public HttpSessionListener getListener();
}

2.實現接口

public class AuthenticationForWiscom implements Authentication, CasConst {
    
    private static final Logger LOG = LoggerFactory.getLogger(AuthenticationForWiscom.class);
    
    private SingleSignOutFilter ssoOutFilter;
    private AuthenticationFilter ssoAuthFilter;
    private Cas20ProxyReceivingTicketValidationFilter ssoTicketFilter;
    private HttpServletRequestWrapperFilter ssoQeqWraFilter;
    List<Filter> filters = null;

    @Override
    public List<Filter> getFilters(FilterConfig filterConfig) throws ServletException {
        filters = new ArrayList<>();
        String serverName = SysUtils.getSysParam(CAS_SERVERNAME);
        String casServerLoginUrl = SysUtils.getSysParam(CAS_SERVERLOGINURL);
        String casServerUrlPrefix = SysUtils.getSysParam(CAS_SERVERURLPREFIX);
        LOG.error("serverName:[{}],casServerLoginUrl:[{}],casServerUrlPrefix:[{}]", serverName, casServerLoginUrl, casServerUrlPrefix);
        
        ssoOutFilter = new SingleSignOutFilter();
        ssoOutFilter.init(new CasFilterConfig("CAS Single Sign Out Filter", filterConfig.getServletContext()));
        filters.add(ssoOutFilter);

        ssoAuthFilter = new AuthenticationFilter();
        ssoAuthFilter.init(new CasFilterConfig("CASFilter", filterConfig.getServletContext()).setInitParameter("serverName", serverName)
                .setInitParameter("casServerLoginUrl", casServerLoginUrl));
        filters.add(ssoAuthFilter);

        ssoTicketFilter = new Cas20ProxyReceivingTicketValidationFilter();
        ssoTicketFilter.init(new CasFilterConfig("CAS Validation Filter", filterConfig.getServletContext()).setInitParameter("serverName", serverName)
                .setInitParameter("casServerUrlPrefix", casServerUrlPrefix));
        filters.add(ssoTicketFilter);

        ssoQeqWraFilter = new HttpServletRequestWrapperFilter();
        ssoQeqWraFilter.init(new CasFilterConfig("CAS HttpServletRequest Wrapper Filter", filterConfig.getServletContext()));
        filters.add(ssoQeqWraFilter);

        return filters;
    }

    @Override
    public User authentication(HttpServletRequest request) {
        String account = request.getRemoteUser();
        // 如果沒有通過SSO認證，
        if (StringUtils.isBlank(account)) {
            LOG.error("單點登錄無法獲得用戶登錄信息！");
        } else {
            return new UserBO().getUserByAccount(account);
        }
        return null;
    }

    @Override
    public HttpSessionListener getListener() {
        return new SingleSignOutHttpSessionListener();
    }

}

3.廠商的工廠類，通過spring注入的方式，注入廠商實現類

public class AuthenticationFactory implements CasConst {

    private static AuthenticationFactory factory;

    private Map<String, Authentication> map = new HashMap<String, Authentication>();

    /**
     * 實例化一個工廠對象
     * 
     * @return
     */
    public static AuthenticationFactory getInstance() {
        if (factory == null) {
            factory = SpringContextUtil.getBean("authenticationFactory");
        }
        return factory;
    }

    /**
     * 根據廠商類型返回具體認證類
     * 
     * @param key 廠商名稱
     * @return
     */
    public Authentication getAuthentication(String key) {
        if (map.containsKey(key)) {
            return map.get(key);
        }
        return null;
    }

    public Map<String, Authentication> getMap() {
        return map;
    }

    public void setMap(Map<String, Authentication> map) {
        this.map = map;
    }
}

 4.spring.xml文件

<bean id="authenticationForWiscom" class="com.eplugger.cas.module.AuthenticationForWiscom" scope="singleton"></bean>
    
    <bean id="authenticationFactory" class="com.eplugger.abilities.cas.module.AuthenticationFactory" scope="singleton">
        <property name="map">
            <map>
                <entry key="wiscom" value-ref="authenticationForWiscom"/>
            </map>
        </property>
    </bean>

5.監聽器類，配置監聽器類去啟動cas需要的監聽器類

public class CasListener implements HttpSessionListener,CasConst{
    private static final Logger LOG = LoggerFactory.getLogger(CasListener.class);
    private HttpSessionListener listener;

    @Override
    public void sessionCreated(HttpSessionEvent event) {
        // 初始化單點登錄公司
        String casName = SysUtils.getSysParam(CAS_STATE);
        if (StringUtils.equals(CAS_STATE_ON, casName)) {
            String casManufacturer = SysUtils.getSysParam(CAS_MANUFACTURER);
            // 獲得公司filter
            Authentication authentication = AuthenticationFactory.getInstance().getAuthentication(casManufacturer);
            listener = authentication.getListener();
            if (listener != null) {
                LOG.info("單點登錄監聽類創建");
                listener.sessionCreated(event);
            }
        }
    }

    @Override
    public void sessionDestroyed(HttpSessionEvent event) {
        if (listener != null) {
            listener.sessionDestroyed(event);
        }
    }

    public HttpSessionListener getListener() {
        return listener;
    }

    public void setListener(HttpSessionListener listener) {
        this.listener = listener;
    }
}

6.過濾器類（Filter，FilterChain，FilterConfig）

public class CasClentFilter implements Filter, CasConst {
    private Authentication authen;
    private CasFilterChain casChain = new CasFilterChain();
    private static final Logger LOG = LoggerFactory.getLogger(CasClentFilter.class);

    @Override
    public void destroy() {
        casChain.dostroy();
    }

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        HttpServletRequest hsreq = (HttpServletRequest) request;
        //判斷是否啟用，沒有啟用的直接跳到下一個過濾器
        String state = SysUtils.getSysParam(CAS_STATE);
        if (StringUtils.equals(CAS_STATE_OFF, state)) {
            chain.doFilter(request, response);
            return;
        }
        //獲得用戶緩存
        User user = null;//從session中獲得用戶信息
        String str[] = hsreq.getRequestURI().trim().split("/");
        String actionName = null;
        if (str.length > 0) {
            actionName = str[str.length - 1];
        }
        //判斷發出的請求是否需要過濾，這里這么做是為了留一個口，保證在單點登錄不能使用的情況下系統還能正常登錄
        //比如說你把加入系統和登錄系統的請求作為例外，那么你可以正常登錄
        if(CasClentValidateUtils.isValidateActionName(actionName) || user != null){
            chain.doFilter(request, response);
        }else{
            if (casChain != null) {
                casChain.initChain();
                //執行過濾器鏈
                casChain.doFilter(request, response);
                //過濾器鏈並不知道什么時候停止，所以這里做記錄，最后利用過濾器鏈獲得request，response轉發到下一個過濾器
                if (casChain.isFinishSSO()) {
                    chain.doFilter(casChain.getRequest(), casChain.getResponse());
                }
            }
        }
    }

    @Override
    public void init(FilterConfig config) throws ServletException {
        // 初始化單點登錄公司
        String state = SysUtils.getSysParam(CAS_STATE);
        if (StringUtils.isNotBlank(state) || !StringUtils.equals(CAS_STATE_OFF, state)) {
            String casManufacturer = SysUtils.getSysParam(CAS_MANUFACTURER);
            // 獲得公司filter
            authen = AuthenticationFactory.getInstance().getAuthentication(casManufacturer);
            if (authen != null ) {
                // 初始化casChain
                casChain.list.addAll(authen.getFilters(config));
            }
        }
    }

    public Authentication getAuthen() {
        return authen;
    }

    public void setAuthen(Authentication authen) {
        this.authen = authen;
    }
}

 

public class CasFilterChain implements FilterChain {
    private ServletRequest request;
    private ServletResponse response;
    List<Filter> list = new ArrayList<Filter>();
    int index = 0;

    public CasFilterChain addFilter(Filter filter) {
        this.list.add(filter);
        return this;
    }

    public void initChain() {
        index = 0;
    }

    public boolean isFinishSSO() {
        return index == list.size();
    }

    public void doFilter(ServletRequest request, ServletResponse response) throws IOException, ServletException {
        if (this.request != request)
            this.request = request;
        if (this.response != response)
            this.response = response;
        if (index >= list.size())
            return;
        Filter f = list.get(index);
        index++;
        f.doFilter(request, response, this);
    }

    public ServletRequest getRequest() {
        return request;
    }

    public ServletResponse getResponse() {
        return response;
    }

    public void dostroy() {
        for (Filter filter : list) {
            filter.destroy();
        }
    }
}

 

public class CasFilterConfig implements FilterConfig {
    String filterName = "";
    Map<String, String> initParameters = new HashMap<String, String>();
    ServletContext servletContext;
    
    public CasFilterConfig() {}
    
    public CasFilterConfig(String filterName, ServletContext servletContext) {
        this.filterName = filterName;
        this.servletContext = servletContext;
    }

    public String getFilterName() {
        return filterName;
    }

    public CasFilterConfig setInitParameter(String key, String value) {
        initParameters.put(key, value);
        return this;
    }

    public String getInitParameter(String key) {
        return initParameters.get(key);
    }

    public Enumeration getInitParameterNames() {
        return Collections.enumeration(initParameters.keySet());
    }

    public ServletContext getServletContext() {
        return servletContext;
    }

}

7.登錄的時候獲得用戶信息

　　由於你提供給集成方的請求就是你的登錄入口，所以在入口處的請求發出后，他會在走第一個過濾器的時候跳轉到門戶的登錄頁面，如果用戶登錄成功，會走獲得用戶信息的過濾器，這時request對象里就已經用了用戶的信息

public User authentication(HttpServletRequest request) {
        User user = getCurUserInfo().getUser();
        // 如果已經有用戶登錄了科研系統,直接進入系統
        if (user != null) {
            return user;
        } else {
            // 初始化單點登錄公司
            String casName = SysUtils.getSysParam(CasConst.CAS_MANUFACTURER);
            // 獲得公司filter
            Authentication authen = AuthenticationFactory.getInstance().getAuthentication(casName);
            if (authen == null) {
                return null;
            }
            return authen.authentication(request);
        }
    }

8.差點忘了web.xml配置，由於這里我使用的ssh框架開發，我需要過濾的請求就是*.action，注意這里filter應當放在請求信息編碼轉換器過濾器后面，也就是字符過濾器后面

<!-- 該過濾器用於實現單點登錄功能  -->
    <filter>
        <filter-name>CasClentFilter</filter-name>
        <filter-class>CasClentFilter全路徑</filter-class>
    </filter>
    <filter-mapping>
        <filter-name>CasClentFilter</filter-name>
        <url-pattern>*.action</url-pattern>
    </filter-mapping>
<!-- 統一身份認證監聽類 -->
<listener>
        <listener-class>CasListener全路徑</listener-class>
    </listener>

9.結束語

　　設計模式的用處無處不在，還是需要深入體會啊！對於單點登錄我的理解不深，這篇博客主要是講解的我在實際應用中對於過濾器鏈的使用，如有不對還請指出！