单点登录（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.结束语

　　设计模式的用处无处不在，还是需要深入体会啊！对于单点登录我的理解不深，这篇博客主要是讲解的我在实际应用中对于过滤器链的使用，如有不对还请指出！