单点登录之CAS SSO从入门到精通（第三天）

开场白

各位新年好，上海的新年好冷，冷到我手发抖。

做好准备全身心投入到新的学习和工作中去了吗？因为今天开始的教程很“变态”啊，我们要完成下面几件事：

1. 自定义CAS SSO登录界面
2. 在CAS SSO登录界面增加我们自定义的登录用元素
3. 使用LDAP带出登录用户在LDAP内存储的更多的信息
4. 实现CAS SSO支持多租户登录的功能

好，开始正文！

正文

上次我们说到了CAS SSO的一些基本用法如：连数据库怎么用，连LDAP怎么用，这次我们要来讲一个网上几乎没有人去过多涉及到的一个问题即：在多租户的环境下我们的cas sso如何去更好的支持，即cas sso multi tentant 的问题，这个问题在很多国外的一些网站包括CAS的官网也很少有人得到解决，在此呢我们把它给彻底的解决掉吧，呵呵。

多租户环境下的单点登录

什么是多租户环境呢？举个例子吧：

我们知道，在有一些云平台或者是电商中的B2B中，经常会存在这样的情况：

在同一个域名下如taobao.com下会有多个商铺（就是租户）好比：

• taobao.com/company_101/张飞
• taobao.com/company_102/张飞
• taobao.com/company_103/赵云

看张飞这个名字，看！！！

不同的company（租户）下有着相同的用户，但其实这是两个不用的用户，中国同名同姓的人多了去了，对吧，这时company_101的张飞登录是因该只看到它所属的company_101这个租户下所有的数据和信息吧，而不能跑到company_102中看到别人家的信息，对吧？

国外很多解决方案说是在我们的CAS SSO的配置文件里在绑定LDAP的context时写上多条这样的东西：

可是，我们想想：

1. 我们的租户在我们的后台系统中是自动“开户”的，companyid是一个自动增加的，我从companyid_101现在增加到了companyid_110时，你是不是每次用户一开户，你就要去手动改这个CAS SSO中的配置文件呢？
2. 如果你不嫌烦，好好好，你够狠，你就手工改吧！但是当你每次在配置文件中新增一条配置语句时，你的CAS SSO是不是要断服务重启啊？那你还怎么做到24*7的这种不间断服务啊

一般来说，我们的开户是用程序自动写入LDAP中去的，即LDAP中的company_101, company_102, company_103是由程序自动生成的，那我们的程序就需要能够让用户在登录后台B2B系统时自动可以根据用户选择的租户来为用户正确登录的这么一种自动识别功能，就好比下面这样的一个登录界面：

看到这个界面了吗？

对的，这个就是CAS SSO的主登录界面， 我把它都给改了，还加入了支持多租户登录的功能，我们今天就要来讲这个功能是怎么做出来的，包括如何去定制自己的CAS SSO的登录界面。

再来看看用于今天练习的我们在LDAP中的组织结构是怎么样的吧。

看到上面这张图了吧，这就是我说的“多租户”的概念，大家应该记得我们在CAS SSO第二天中怎么去拿CAS SSO绑定LDAP中的一条UserDN然后去搜索的吧？

对吧！！！

现在我们要做到的就是：

p:searchBase="xxx.xxx.xx"

这条要做成动态的，比如说:

• 用户是company_id=101的，这时这个p:searchBase就应该变为：“p:searchBase="uid=sky,o=101,o=company,dc=sky,dc=org"
• 用户是company_id=102的，这时这个p:searchBase就应该变为：“p:searchBase="uid=jason,o=102,o=company,dc=sky,dc=org"

前面我们提到过，这些配置是放在XML文件中的，因此每次增加一个”租户“我们要手工在XML配置文件中新增一条，这个不现实，它是实现不了我们的24*7的这种服务的要求的，我们要做的是可以让这个p:searchBase能够动态的去组建这个userDN，所以重点是要解决这个问题。

该问题在国外的YALE CAS论坛上有两种解决方案：

• 一种是直接通过CAS的登录界面然后在输入用户名时要求用户以这种形式“uid=sky,o=101"去输入它的用户名，这种做法先不去说会造成用户登录时的困扰，而且CAS SSO的登录界面也不支持这样格式的用户名输入。
• 一种就是很笨的在CAS SSO的配置文件中绑定多个p:searchBase，这个方法已经被我们否掉了。

因此，笔者在这边要提的将是独创的可以做到全动态的去根据用户名，密码和所该用户所属组织自动在后台创建p:searchBase的最完美的解决方案，下面我们就开始吧。

创建工程

我们这次是要在CAS SSO这个产品上做扩展了，为此，我们不能再像我们第一天和第二天中那样直接拿个文本编辑器去改CAS SSO里的配置文件了，我们需要创建一个eclipse工程，来看我们的eclipse工程。

look，今天我们把这个cas-server放到了eclipse工程中去了，然后在eclipse里随改随测试，现在我们就来讲述如何创建这个工程以使得cas server可以运行在我们的eclipse的工程中。

因此 我们在eclipse中新建一个java工程-是java工程你可千万不要建成j2ee工程啊，然后按照上图建立相应的目录。

CAS SERVER工程的组建

导入所有的配置文件

这是我们在第一天，第二天中布署在tomcat下的cas server工程的目录：

D:\tomcat\webapps\cas-server\WEB-INF\classes

把这个目录下所有的内容，除去以下2个目录：

• org
• META-INF

外所有的东西统统拷贝入eclipse中的cas-server工程中的src/main/resources目录下

构建WEB-INF目录

将D:\tomcat\webapps\cas-server\WEB-INF目录下这几个目录放入cas-server工程的src/main/webapp/WEB-INF目录下

构建cas-server基本源码

解压开我们下载的”cas-server-3.5.2-release"包，内含源码，它位于这样的一个目录cas-server-3.5.2\cas-server-webapp\src\main\java“

将这个目录下所有的文件置于cas-server工程的src/main/java目录下

并在eclipse工程中做如下设置

此处需要注意的是我们把：

• src/main/java
• src/main/resources

这两个目录做成编译路径，而 src/main/webapp不作为编译路径。

别忘了把所有的src/main/webapp/WEB-INF/lib目录下的jar加到cas-server工程的Libraries中去。

构建webapp目录

将我们在第一天、第二天中布署在tomcat中的case-server中以下这些目录

拷贝到eclipse的cas-server工程中的src/main/webapp目录

CAS SSO在jboss/weblogic下的bug的修正

由于我们的eclipse中的cas-server将和我们的cas-sample-site1以及cas-sample-site2启动在jboss下，因此cas sso在jboss或者是在weblogic下有两个小问题，在此需要修正。

1. META-INF文件内的persistence.xml中报HSQLDialect错误
2. 报log4jConfiguration.xml文件在启动时找不到的错误

下面我们来看如何修正这两个小BUG。

修正CAS SSO的persistence.xml文件中的HSQLDialect错误

这是原始的/META-INF/persistence.xml文件的内容：

        org.jasig.cas.services.AbstractRegisteredService
        org.jasig.cas.services.RegexRegisteredService
        org.jasig.cas.services.RegisteredServiceImpl
        org.jasig.cas.ticket.TicketGrantingTicketImpl
        org.jasig.cas.ticket.ServiceTicketImpl
        org.jasig.cas.ticket.registry.support.JpaLockingStrategy$Lock

我们在文件最后加入以下配置代码

        org.jasig.cas.services.AbstractRegisteredService
        org.jasig.cas.services.RegexRegisteredService
        org.jasig.cas.services.RegisteredServiceImpl
        org.jasig.cas.ticket.TicketGrantingTicketImpl
        org.jasig.cas.ticket.ServiceTicketImpl
        org.jasig.cas.ticket.registry.support.JpaLockingStrategy$Lock
        
	      
	

这是完整的改完后的persistence.xml文件的内容：

	
        org.jasig.cas.services.AbstractRegisteredService
        org.jasig.cas.services.RegexRegisteredService
        org.jasig.cas.services.RegisteredServiceImpl
        org.jasig.cas.ticket.TicketGrantingTicketImpl
        org.jasig.cas.ticket.ServiceTicketImpl
        org.jasig.cas.ticket.registry.support.JpaLockingStrategy$Lock
        
		
	
	

改完后请保存。

修正CAS SSO中log4jConfiguration.xml文件在启动时找不到的错误

找到eclipse的cas-server工程中WEB-INF/spring-configuration/log4jConfiguration.xml文件，将这段内容注释掉

     
         
         
         
             
                 ${log4j.config.location:classpath:log4j.xml}
                 ${log4j.refresh.interval:60000}
             
         
    

整个log4jConfiguration.xml文件修改后是这个样子的：

改完后请保存。

将CAS-SERVER从eclipse java工程改为j2ee工程

右键单击cas-sso工程，选择project properties，然后选择project facet，按照如下截图来做选择。

组装可在eclipse中启动的cas-server web工程

右键单击cas-sso工程，选择project properties，然后选择Deployment Assembly，这个基本功我已经在 通向架构师的道路（第二十天）万能框架spring(二)maven结合spring与ibatis中详细讲述过这个Deployment Assembly是干什么用的了。

在eclipse中启动cas-server工程

一切无误后请在eclipse中启动cas-sso吧。

开始修改源码

如何让cas-server支持动态的p:searchBase呢

我们的p:searchBase从这一层o=company,dc=sky,dc=org开始要进行动态组装，因此我们将在deployConfiguration.xml文件中将我们的ldap的p:searchBase的绑定改成如下：

p:searchBase="o=company,dc=sky,dc=org"，然后我们使用程序动态组建o=company,dc=sky,dc=org之前的内容到底是该“o=101”呢还是因该是“o=102” 这样的串。

为cas server的登录增加一个项

原来的cas sso的登录项只有两个属性：

• username
• password

我们需要增加一个companyid，用于判断当前登录的用户是属于哪个租户的。

新建CASCredential类

public class CASCredential extends RememberMeUsernamePasswordCredentials {
	private static final long serialVersionUID = 1L;

	private Map param;


	private String companyid;

	/**
	 * @return the companyid
	 */
	public String getCompanyid() {
		return companyid;
	}

	/**
	 * @param companyid the companyid to set
	 */
	public void setCompanyid(String companyid) {
		this.companyid = companyid;
	}

	public Map getParam() {
		return param;
	}

	public void setParam(Map param) {
		this.param = param;
	}
}

这就是我们扩展的CASCredential类，该类除了拥有原来CAS SSO基本credential中的username和password两个属性外还有一个叫companyid的属性。

将新增的companyid绑定至cas sso的登录页面

修改src/main/webapp/WEB-INF/login-webflow.xml文件，找到以下这段：

将其改成：

扩展CAS SSO登录页面的submit行为以支持我们在页面中新增的companyid属性可以被提交到CAS SSO的后台

新建一个类CASAuthenticationViaFormAction，内容如下：

package org.sky.cas.auth;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.validation.constraints.NotNull;

import org.jasig.cas.CentralAuthenticationService;
import org.jasig.cas.authentication.handler.AuthenticationException;
import org.jasig.cas.authentication.principal.Credentials;
import org.jasig.cas.authentication.principal.Service;
import org.jasig.cas.ticket.TicketException;
import org.jasig.cas.web.bind.CredentialsBinder;
import org.jasig.cas.web.support.WebUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.binding.message.MessageBuilder;
import org.springframework.binding.message.MessageContext;
import org.springframework.util.StringUtils;
import org.springframework.web.util.CookieGenerator;
import org.springframework.webflow.core.collection.MutableAttributeMap;
import org.springframework.webflow.execution.RequestContext;

@SuppressWarnings("deprecation")
public class CASAuthenticationViaFormAction {
	/**
	 * Binder that allows additional binding of form object beyond Spring
	 * defaults.
	 */
	private CredentialsBinder credentialsBinder;

	/** Core we delegate to for handling all ticket related tasks. */
	@NotNull
	private CentralAuthenticationService centralAuthenticationService;

	@NotNull
	private CookieGenerator warnCookieGenerator;

	protected Logger logger = LoggerFactory.getLogger(getClass());

	public final void doBind(final RequestContext context, final Credentials credentials) throws Exception {
		final HttpServletRequest request = WebUtils.getHttpServletRequest(context);

		if (this.credentialsBinder != null && this.credentialsBinder.supports(credentials.getClass())) {
			this.credentialsBinder.bind(request, credentials);
		}
	}

	public final String submit(final RequestContext context, final Credentials credentials, final MessageContext messageContext)
			throws Exception {
		String companyid = "";
		// Validate login ticket
		final String authoritativeLoginTicket = WebUtils.getLoginTicketFromFlowScope(context);
		final String providedLoginTicket = WebUtils.getLoginTicketFromRequest(context);
		if (credentials instanceof CASCredential) {
			String companyCode = "compnayid";
			CASCredential rmupc = (CASCredential) credentials;
			companyid = rmupc.getCompanyid();

		}

		if (!authoritativeLoginTicket.equals(providedLoginTicket)) {
			this.logger.warn("Invalid login ticket " + providedLoginTicket);
			final String code = "INVALID_TICKET";
			messageContext.addMessage(new MessageBuilder().error().code(code).arg(providedLoginTicket).defaultText(code).build());
			return "error";
		}

		final String ticketGrantingTicketId = WebUtils.getTicketGrantingTicketId(context);
		final Service service = WebUtils.getService(context);
		if (StringUtils.hasText(context.getRequestParameters().get("renew")) && ticketGrantingTicketId != null && service != null) {

			try {
				final String serviceTicketId = this.centralAuthenticationService.grantServiceTicket(ticketGrantingTicketId,
						service, credentials);
				WebUtils.putServiceTicketInRequestScope(context, serviceTicketId);
				putWarnCookieIfRequestParameterPresent(context);
				return "warn";
			} catch (final TicketException e) {
				if (isCauseAuthenticationException(e)) {
					populateErrorsInstance(e, messageContext);
					return getAuthenticationExceptionEventId(e);
				}

				this.centralAuthenticationService.destroyTicketGrantingTicket(ticketGrantingTicketId);
				if (logger.isDebugEnabled()) {
					logger.debug("Attempted to generate a ServiceTicket using renew=true with different credentials", e);
				}
			}
		}

		try {

			CASCredential rmupc = (CASCredential) credentials;
			WebUtils.putTicketGrantingTicketInRequestScope(context,
					centralAuthenticationService.createTicketGrantingTicket(rmupc));
			putWarnCookieIfRequestParameterPresent(context);

			return "success";
		} catch (final TicketException e) {
			populateErrorsInstance(e, messageContext);
			if (isCauseAuthenticationException(e))
				return getAuthenticationExceptionEventId(e);
			return "error";
		}
	}

	private void populateErrorsInstance(final TicketException e, final MessageContext messageContext) {

		try {
			messageContext.addMessage(new MessageBuilder().error().code(e.getCode()).defaultText(e.getCode()).build());
		} catch (final Exception fe) {
			logger.error(fe.getMessage(), fe);
		}
	}

	private void putWarnCookieIfRequestParameterPresent(final RequestContext context) {
		final HttpServletResponse response = WebUtils.getHttpServletResponse(context);

		if (StringUtils.hasText(context.getExternalContext().getRequestParameterMap().get("warn"))) {
			this.warnCookieGenerator.addCookie(response, "true");
		} else {
			this.warnCookieGenerator.removeCookie(response);
		}
	}

	private AuthenticationException getAuthenticationExceptionAsCause(final TicketException e) {
		return (AuthenticationException) e.getCause();
	}

	private String getAuthenticationExceptionEventId(final TicketException e) {
		final AuthenticationException authEx = getAuthenticationExceptionAsCause(e);

		if (this.logger.isDebugEnabled())
			this.logger.debug("An authentication error has occurred. Returning the event id " + authEx.getType());

		return authEx.getType();
	}

	private boolean isCauseAuthenticationException(final TicketException e) {
		return e.getCause() != null && AuthenticationException.class.isAssignableFrom(e.getCause().getClass());
	}

	public final void setCentralAuthenticationService(final CentralAuthenticationService centralAuthenticationService) {
		this.centralAuthenticationService = centralAuthenticationService;
	}

	/**
	 * Set a CredentialsBinder for additional binding of the HttpServletRequest
	 * to the Credentials instance, beyond our default binding of the
	 * Credentials as a Form Object in Spring WebMVC parlance. By the time we
	 * invoke this CredentialsBinder, we have already engaged in default binding
	 * such that for each HttpServletRequest parameter, if there was a JavaBean
	 * property of the Credentials implementation of the same name, we have set
	 * that property to be the value of the corresponding request parameter.
	 * This CredentialsBinder plugin point exists to allow consideration of
	 * things other than HttpServletRequest parameters in populating the
	 * Credentials (or more sophisticated consideration of the
	 * HttpServletRequest parameters).
	 *
	 * @param credentialsBinder the credentials binder to set.
	 */
	public final void setCredentialsBinder(final CredentialsBinder credentialsBinder) {
		this.credentialsBinder = credentialsBinder;
	}

	public final void setWarnCookieGenerator(final CookieGenerator warnCookieGenerator) {
		this.warnCookieGenerator = warnCookieGenerator;
	}
}

这个类很简单，主要是第59行到第64行的：

if (credentials instanceof CASCredential) {
			String companyCode = "compnayid";
			CASCredential rmupc = (CASCredential) credentials;
			companyid = rmupc.getCompanyid();

}

以及第98行到第100行的：

			CASCredential rmupc = (CASCredential) credentials;
			WebUtils.putTicketGrantingTicketInRequestScope(context,
					centralAuthenticationService.createTicketGrantingTicket(rmupc));

它告诉了CAS SSO使用我们自定义的CASCredential来验证用户在CAS SSO中的登录信息，而不是原来CAS SSO默认的UsernameAndPasswordCredential。

把”CASAuthenticationViaFormAction“类注册给CAS SSO，告诉CAS SSO在登录页面点击”登录“按钮后能够使用这个我们自定义的submit action：

修改配置文件：src/main/webapp/WEB-INF/cas-servlet.xml

找到以下这行：

把它注释掉改成：

此时，CAS SSO的登录界面在用户点击submit按钮时，就会使用我们自定义的这个CASAuthenticationViaFormAction类了。

增加p:searchBase使得CAS SSO的LDAP可以根据不同的companyid动态搜索用户的功能

新增一个类CASLDAPAuthenticationHandler，代码如下：

package org.sky.cas.auth;

import org.jasig.cas.adaptors.ldap.AbstractLdapUsernamePasswordAuthenticationHandler;
import org.jasig.cas.authentication.handler.AuthenticationException;
import org.jasig.cas.authentication.principal.UsernamePasswordCredentials;
import org.jasig.cas.util.LdapUtils;
import org.springframework.ldap.NamingSecurityException;
import org.springframework.ldap.core.ContextSource;
import org.springframework.ldap.core.LdapTemplate;
import org.springframework.ldap.core.NameClassPairCallbackHandler;
import org.springframework.ldap.core.SearchExecutor;

import javax.naming.NameClassPair;
import javax.naming.NamingEnumeration;
import javax.naming.NamingException;
import javax.naming.directory.DirContext;
import javax.naming.directory.SearchControls;
import javax.validation.constraints.Max;
import javax.validation.constraints.Min;
import java.util.ArrayList;
import java.util.List;

public class CASLDAPAuthenticationHandler extends AbstractLdapUsernamePasswordAuthenticationHandler {
	/** The default maximum number of results to return. */
	private static final int DEFAULT_MAX_NUMBER_OF_RESULTS = 1000;

	/** The default timeout. */
	private static final int DEFAULT_TIMEOUT = 1000;

	/** The search base to find the user under. */
	private String searchBase;

	/** The scope. */
	@Min(0)
	@Max(2)
	private int scope = SearchControls.ONELEVEL_SCOPE;

	/** The maximum number of results to return. */
	private int maxNumberResults = DEFAULT_MAX_NUMBER_OF_RESULTS;

	/** The amount of time to wait. */
	private int timeout = DEFAULT_TIMEOUT;

	/** Boolean of whether multiple accounts are allowed. */
	private boolean allowMultipleAccounts;

	protected final boolean authenticateUsernamePasswordInternal(final UsernamePasswordCredentials credentials)
			throws AuthenticationException {
		CASCredential rmupc = (CASCredential) credentials;
		final String companyid = rmupc.getCompanyid();
		final List cns = new ArrayList();

		final SearchControls searchControls = getSearchControls();

		final String transformedUsername = getPrincipalNameTransformer().transform(credentials.getUsername());
		final String filter = LdapUtils.getFilterWithValues(getFilter(), transformedUsername);
		try {
			this.getLdapTemplate().search(new SearchExecutor() {
				public NamingEnumeration executeSearch(final DirContext context) throws NamingException {
					String baseDN = "";
					if (companyid != null && companyid.trim().length() > 0) {
						baseDN = "o=" + companyid + "," + searchBase;
					} else {
						baseDN = searchBase;
					}
					//System.out.println("searchBase=====" + baseDN);
					return context.search(baseDN, filter, searchControls);
				}
			}, new NameClassPairCallbackHandler() {

				public void handleNameClassPair(final NameClassPair nameClassPair) {
					cns.add(nameClassPair.getNameInNamespace());
				}
			});
		} catch (Exception e) {
			log.error("search ldap error casue: " + e.getMessage(), e);
			return false;
		}
		if (cns.isEmpty()) {
			log.debug("Search for " + filter + " returned 0 results.");
			return false;
		}
		if (cns.size() > 1 && !this.allowMultipleAccounts) {
			log.warn("Search for " + filter + " returned multiple results, which is not allowed.");
			return false;
		}

		for (final String dn : cns) {
			DirContext test = null;
			String finalDn = composeCompleteDnToCheck(dn, credentials);
			try {
				this.log.debug("Performing LDAP bind with credential: " + dn);
				test = this.getContextSource().getContext(finalDn, getPasswordEncoder().encode(credentials.getPassword()));

				if (test != null) {
					return true;
				}
			} catch (final NamingSecurityException e) {
				log.debug("Failed to authenticate user {} with error {}", credentials.getUsername(), e.getMessage());
				return false;
			} catch (final Exception e) {
				this.log.error(e.getMessage(), e);
				return false;
			} finally {
				LdapUtils.closeContext(test);
			}
		}

		return false;
	}

	protected String composeCompleteDnToCheck(final String dn, final UsernamePasswordCredentials credentials) {
		return dn;
	}

	private SearchControls getSearchControls() {
		final SearchControls constraints = new SearchControls();
		constraints.setSearchScope(this.scope);
		constraints.setReturningAttributes(new String[0]);
		constraints.setTimeLimit(this.timeout);
		constraints.setCountLimit(this.maxNumberResults);

		return constraints;
	}

	/**
	 * Method to return whether multiple accounts are allowed.
	 * @return true if multiple accounts are allowed, false otherwise.
	 */
	protected boolean isAllowMultipleAccounts() {
		return this.allowMultipleAccounts;
	}

	/**
	 * Method to return the max number of results allowed.
	 * @return the maximum number of results.
	 */
	protected int getMaxNumberResults() {
		return this.maxNumberResults;
	}

	/**
	 * Method to return the scope.
	 * @return the scope
	 */
	protected int getScope() {
		return this.scope;
	}

	/**
	 * Method to return the search base.
	 * @return the search base.
	 */
	protected String getSearchBase() {
		return this.searchBase;
	}

	/**
	 * Method to return the timeout. 
	 * @return the timeout.
	 */
	protected int getTimeout() {
		return this.timeout;
	}

	public final void setScope(final int scope) {
		this.scope = scope;
	}

	/**
	 * @param allowMultipleAccounts The allowMultipleAccounts to set.
	 */
	public void setAllowMultipleAccounts(final boolean allowMultipleAccounts) {
		this.allowMultipleAccounts = allowMultipleAccounts;
	}

	/**
	 * @param maxNumberResults The maxNumberResults to set.
	 */
	public final void setMaxNumberResults(final int maxNumberResults) {
		this.maxNumberResults = maxNumberResults;
	}

	/**
	 * @param searchBase The searchBase to set.
	 */
	public final void setSearchBase(final String searchBase) {
		this.searchBase = searchBase;
	}

	/**
	 * @param timeout The timeout to set.
	 */
	public final void setTimeout(final int timeout) {
		this.timeout = timeout;
	}

	/**
	 * Sets the context source for LDAP searches.  This method may be used to
	 * support use cases like the following:
	 * 

	 * 
Pooling of LDAP connections used for searching (e.g. via instance
	 * of {@link org.springframework.ldap.pool.factory.PoolingContextSource}).
	 * 
Searching with client certificate credentials.
	 * 
	 * 

	 * If this is not defined, the context source defined by
	 * {@link #setContextSource(ContextSource)} is used.
	 *
	 * @param contextSource LDAP context source.
	 */
	public final void setSearchContextSource(final ContextSource contextSource) {
		setLdapTemplate(new LdapTemplate(contextSource));
	}

}

这个类的作用就是给src/main/webapp/WEB-INF/deployerConfiguration.xml中以下这段用的：

请注意代码50行处：

final String companyid = rmupc.getCompanyid();

以及59行到69行处：

public NamingEnumeration executeSearch(final DirContext context) throws NamingException {
					String baseDN = "";
					if (companyid != null && companyid.trim().length() > 0) {
						baseDN = "o=" + companyid + "," + searchBase;
					} else {
						baseDN = searchBase;
					}
					//System.out.println("searchBase=====" + baseDN);
					return context.search(baseDN, filter, searchControls);
				}
}, new NameClassPairCallbackHandler() {

这就是在根据用户在登录界面中选择的companyid不同，而动态的去重组这个searchBase，以使得这个searchBase可以是o=101,o=company,dc=sky,dc=org, 也可以是o=102,o=company,dc=sky,dc=org同时它也可以变成o=103,o=company,dc=sky,dc=org。

有了这个类我们要修改我们的src/main/webapp/WEB-INF/deployerConfiguration.xml文件了，注意这个bean中的写法 ，已经被我修改掉了

看到这个 CASLDAPAuthenticationHandler类在这边的作用了吧。

将LDAP中登录用户的其它信息也带入到客户端登录成功后跳转的页面中去

我们知道，CAS SSO可以把username(uid)带入到客户端登录成功后的页面中去，可是一个uid在LDAP中还关联着许多其它有用的信息如：email。 还有就是我们刚才新增的companyid，我们也想把这些信息同时带到客户端登录成功的画面中去呢？

这边就需要使用到CAS SSO中的一个特殊的属性，它叫attributeRepository。

attributeRepository的作用

attributeRepository关联着一个dao和一个resolver，它们的作用如下：

• attributeDAO是用于根据searchBase在LDAP中定位到一条数据，然后把该条数据所有的属性取出来用的一个工具类
• credentialsToPrincipalResolvers，该类用于向客户端（就是我们的cas-samples-site1/site2)返回用户在CAS SSO中登录画面中输入的登录相关信息用的一个工具类
  

先来说attributeDAO的作用吧。

CASLdapPersonAttributeDao

比如说我们这边想要把ldap中某个uid的mail属性也带给到客户端中去

我们就要按照下面这段代码来书写CASLdapPersonAttributeDao类，该类扩展自”AbstractQueryPersonAttributeDao“类，它被置于”package org.jasig.services.persondir.support.ldap“包中，因为该包中还有其它相关的此类需要”引用"的工具类，我们不想到处import来import去了，因此直接把这个我们自定义的attributeDao类就直接放置于该包中了。

但是，嘿嘿嘿，在package org.jasig.services.persondir.support.ldap包中没有其它这个类需要引用的那些外部类，如下图所示：

怎么办？

很简单，直接找到cas-server 3.5.2的源码，将这两个外部类置于我们自定义的CASLdapPersonAttributeDao同一层的包路径下即可，我会在本文结束后直接给出完整的eclipse中可运行的cas-server的全部源码。

/**
 * Licensed to Jasig under one or more contributor license
 * agreements. See the NOTICE file distributed with this work
 * for additional information regarding copyright ownership.
 * Jasig licenses this file to you under the Apache License,
 * Version 2.0 (the "License"); you may not use this file
 * except in compliance with the License. You may obtain a
 * copy of the License at:
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on
 * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied. See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */

package org.jasig.services.persondir.support.ldap;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import javax.naming.directory.SearchControls;

import org.apache.commons.lang.StringUtils;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.jasig.cas.util.CASCredentialHelper;
import org.jasig.services.persondir.IPersonAttributes;
import org.jasig.services.persondir.support.AbstractQueryPersonAttributeDao;
import org.jasig.services.persondir.support.CaseInsensitiveAttributeNamedPersonImpl;
import org.jasig.services.persondir.support.CaseInsensitiveNamedPersonImpl;
import org.jasig.services.persondir.support.QueryType;
import org.sky.cas.auth.LdapPersonInfoBean;
import org.springframework.beans.factory.BeanCreationException;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.ldap.core.AttributesMapper;
import org.springframework.ldap.core.ContextSource;
import org.springframework.ldap.core.LdapTemplate;
import org.springframework.ldap.filter.EqualsFilter;
import org.springframework.ldap.filter.Filter;
import org.springframework.ldap.filter.LikeFilter;
import org.springframework.util.Assert;

/**
 * LDAP implementation of {@link org.jasig.services.persondir.IPersonAttributeDao}.
 * 
 * In the case of multi valued attributes a {@link java.util.List} is set as the value.
 * 
 * 

 * 

 * Configuration:
 * 
 *     
 *         
 *         
 *         
 *         
 *     
 *     
 *         
 *         
 *         
 *         
 *     
 *     
 *         
 *         
 *         
 *         
 *     
 *     
 *         
 *         
 *         
 *         
 *     
 *     
 *         
 *         
 *         
 *         
 *     
 *     
 *         
 *         
 *         
 *         
 *     
 * 
Property
Description
Required
Default
searchControls

 *             Set the {@link SearchControls} used for executing the LDAP query.
 *         
No
Default instance with SUBTREE scope.
baseDN

 *             The base DistinguishedName to use when executing the query filter.
 *         
No
""
contextSource

 *             A {@link ContextSource} from the Spring-LDAP framework. Provides a DataSource
 *             style object that this DAO can retrieve LDAP connections from.
 *         
Yes
null
setReturningAttributes

 *             If the ldap attributes set in the ldapAttributesToPortalAttributes Map should be copied
 *             into the {@link SearchControls#setReturningAttributes(String[])}. Setting this helps reduce
 *             wire traffic of ldap queries.
 *         
No
true
queryType

 *             How multiple attributes in a query should be concatenated together. The other option is OR.
 *         
No
AND
 * 
 * @author [email protected]
 * @author Eric Dalquist
 * @version $Revision$ $Date$
 * @since uPortal 2.5
 */
public class CASLdapPersonAttributeDao extends AbstractQueryPersonAttributeDao implements InitializingBean {
	private static final Pattern QUERY_PLACEHOLDER = Pattern.compile("\\{0\\}");
	private final static AttributesMapper MAPPER = new AttributeMapAttributesMapper();
	protected final Log logger = LogFactory.getLog(getClass());
	/**
	 * The LdapTemplate to use to execute queries on the DirContext
	 */
	private LdapTemplate ldapTemplate = null;

	private String baseDN = "";
	private String queryTemplate = null;
	private ContextSource contextSource = null;
	private SearchControls searchControls = new SearchControls();
	private boolean setReturningAttributes = true;
	private QueryType queryType = QueryType.AND;

	public CASLdapPersonAttributeDao() {
		this.searchControls.setSearchScope(SearchControls.SUBTREE_SCOPE);
		this.searchControls.setReturningObjFlag(false);
	}

	/* (non-Javadoc)
	 * @see org.springframework.beans.factory.InitializingBean#afterPropertiesSet()
	 */
	public void afterPropertiesSet() throws Exception {
		final Map> resultAttributeMapping = this.getResultAttributeMapping();
		if (this.setReturningAttributes && resultAttributeMapping != null) {
			this.searchControls.setReturningAttributes(resultAttributeMapping.keySet().toArray(
					new String[resultAttributeMapping.size()]));
		}

		if (this.contextSource == null) {
			throw new BeanCreationException("contextSource must be set");
		}
	}

	/* (non-Javadoc)
	 * @see org.jasig.services.persondir.support.AbstractQueryPersonAttributeDao#appendAttributeToQuery(java.lang.Object, java.lang.String, java.util.List)
	 */
	@Override
	protected LogicalFilterWrapper appendAttributeToQuery(LogicalFilterWrapper queryBuilder, String dataAttribute,
			List