CAS在Tomcat中实现单点登录[jdbc验证用户信息]
一.开发准备：
环境:
OS:windows xp
IDE：myeclipse 6.0
web服务器:tomcat 6.0
JDK: jdk1.6.0_05
数据库:mysql 6.0
准备：
cas-client-java-2.1.1.zip
http://www.ja-sig.org/downloads/cas-clients/cas-client-java-2.1.1.zip? [建议使用迅雷下载]
cas-server-3.3.1-release.zip
http://www.ja-sig.org/downloads/cas/cas-server-3.3.1-release.zip [建议使用迅雷下载]
其他所需jar文件：
/Files/arix04/need.part1.rar
/Files/arix04/need.part2.rar
?
二.开发步骤：
1.修改本机域名：
大家都知道使用http://localhost:8080/ 就可以访问本机web服务，这里的localhost其实就是一个ip，域名映射，我们可以设置自己的本机域名，
在C:\WINDOWS\system32\drivers\etc下面找到hosts文件，用文本打开，加上一行:
127.0.0.1?http://www.test.com/
这样修改后，我们启动tomcat服务后，就可以使用http://www.test.com:8080/来访问了。
这步是为了写cookie做准备，使用localhost是无法写入cookie的，不过这个demo中似乎不该也行，看个人吧，因为我写另外一个sso例子的时候这里需要修改域名，所以就把这步写一下。
2.证书生成及导入，使用jdk自带的keytool工具来生成证书
首先打开cmd，cd到自己的%JAVA_HOME%\jre\lib\security目录下
比如我的是默认目录：
C:\Program Files\Java\jdk1.6.0_05\jre\lib\security
然后执行命令（蓝色是注释不用执行）:
下面2行是删除已经存在的证书，如果没有也不影响keytool -delete -alias tomcatsso -keystore cacerts -storepass changeit keytool -delete -alias tomcatsso -storepass changeitkeytool -list -keystore cacerts -storepass changeit 下面这行要注意，cn要改成你的本机域名，我的如下：keytool -genkey -keyalg RSA -alias tomcatsso -dname "cn=www.test.com" -storepass changeit这里要求输入密码，2次输入一致就OK了keytool -export -alias tomcatsso -file tomcatsso.crt -storepass changeitkeytool -import -alias tomcatsso -file tomcatsso.crt -keystore cacerts -storepass changeitkeytool -list -keystore cacerts -storepass changeit
?把上面的命令都执行一遍就OK了，建议一行一行的执行，避免出错。如果成功的话，
你会在C:\Documents and Settings\当前用户[我的是C:\Documents and Settings\Administrator] 目录下发现.keystore文件，
在%JAVA_HOME%\jre\lib\security目录下发现tomcatsso.crt，如果这2个文件都存在的话，那么恭喜你，证书已经导入成功了。
3.在tomcat中加上对ssl的支持
首先在tomcat中加上对ssl的支持，在conf/server.xml中加入下面内容：
<Connector protocol="org.apache.coyote.http11.Http11Protocol" port="8443" minSpareThreads="5" maxSpareThreads="75" enableLookups="true" disableUploadTimeout="true" acceptCount="100" maxThreads="200" scheme="https" secure="true" SSLEnabled="true" keystoreFile="C:/Documents and Settings/Administrator/.keystore" keystorePass="changeit" truststoreFile="C:/Program Files/Java/jdk1.6.0_05/jre/lib/security/cacerts" clientAuth="false" sslProtocol="TLS"/>
?上面的文件路径填你自己的，密码就是刚才生成证书时你输入的密码。
然后启动你的tomcat服务器，测试这个地址，
https://www.test.com:8443/
如果出来tomcat主页那么你的ssl就配置成功了.
4.测试一个简单的CAS例子
到这里，我们就可以开始测试一个简单的cas单点登录的例子了，
从你的cas-server-3.3.1\modules中找出cas.war放到tomcat/webapps下面(cas-server-webapp-3.3.1.war重命名即可)。
现在cas默认的server端已经有了，下面自己写2个客户端测试一下吧
MyEclipse里面新建web project:SSO_Pro1
新建类HelloWorldExample
package servlet;import java.io.*;import java.util.*;import javax.servlet.*;import javax.servlet.http.*;/** * The simplest possible servlet. * * @author James Duncan Davidson */public class HelloWorldExample extends HttpServlet { public void doGet(HttpServletRequest request, HttpServletResponse response) throws IOException, ServletException { response.setContentType("text/html"); PrintWriter out = response.getWriter(); out.println("<html>"); out.println("<head>"); String title = "hello world!"; out.println("<title>" + title + "</title>"); out.println("</head>"); out.println("<body bgcolor=\"white\">"); out.println("<a href=\"../helloworld.html\">"); out.println("<img src=\"../images/code.gif\" height=24 " + "width=24 align=right border=0 alt=\"view code\"></a>"); out.println("<a href=\"../index.html\">"); out.println("<img src=\"../images/return.gif\" height=24 " + "width=24 align=right border=0 alt=\"return\"></a>"); out.println("<h1>" + title + "</h1>"); out.println("</body>"); out.println("</html>"); }}在web.xml文件添加CASFilter与servlet映射。Code<?xml version="1.0" encoding="GB18030"?><web-app version="2.4" xmlns="http://java.sun.com/xml/ns/j2ee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd"> <filter> <filter-name>CAS Filter</filter-name> <filter-class>edu.yale.its.tp.cas.client.filter.CASFilter</filter-class> <init-param> <param-name>edu.yale.its.tp.cas.client.filter.loginUrl</param-name> <param-value>https://www.test.com:8443/cas/login</param-value> </init-param> <init-param> <param-name>edu.yale.its.tp.cas.client.filter.validateUrl</param-name> <param-value>https://www.test.com:8443/cas/serviceValidate</param-value> </init-param> <init-param> <param-name>edu.yale.its.tp.cas.client.filter.serverName</param-name> <param-value>www.test.com:8080</param-value> </init-param> </filter> <filter-mapping> <filter-name>CAS Filter</filter-name> <url-pattern>/servlet/*</url-pattern> </filter-mapping> <servlet> <servlet-name>HelloWorldExample</servlet-name> <servlet-class>servlet.HelloWorldExample</servlet-class> </servlet> <servlet-mapping> <servlet-name>HelloWorldExample</servlet-name> <url-pattern>/servlet/helloWorldExample</url-pattern> </servlet-mapping> <welcome-file-list> <welcome-file>index.jsp</welcome-file> </welcome-file-list></web-app>?同样，再建一个web project : SSO_Pro2
HelloWorldExample与web.xml直接从SSO_Pro1中copy即可。
OK,现在已经准备就绪，启动tomcat，然后访问：
http://www.test.com:8080/SSO_Pro1/servlet/helloWorldExample
可能会出现如下界面：
?
![CAS在Tomcat中兑现单点登录[jdbc验证用户信息]](http://img.reader8.net/uploadfile/jiaocheng/20140147/2840/2014012800401932046.jpg)
点击继续浏览此网站看看是否跳转到了CAS Server的登录界面。
![CAS在Tomcat中兑现单点登录[jdbc验证用户信息]](http://img.reader8.net/uploadfile/jiaocheng/20140147/2840/2014012800401932047.jpg)
?
如果浏览器框显示为红色，是因为该证书为非信任证书，你可以导入到信任证书即可，操作很简单，在浏览器地址栏上方按提示导入即可，则以后访问就不会出现1图。
cas服务端默认的验证机制是输入2串相同的字符串，随便输入arix04/arix04，点击登录即可。登录成功的页面如下图：![CAS在Tomcat中兑现单点登录[jdbc验证用户信息]](http://img.reader8.net/uploadfile/jiaocheng/20140147/2840/2014012800401932048.jpg)
?
可以看到图 中地址栏里的地址多出了一个 ticket 参数，这就是 CAS 分配给当前应用的 ST(Service Ticket)。
此时，在浏览器中输入：
http://www.test.com:8080/SSO_Pro2/servlet/helloWorldExample，则不用再次登录，到此，简单的单点登录已经实现。
![CAS在Tomcat中兑现单点登录[jdbc验证用户信息]](http://img.reader8.net/uploadfile/jiaocheng/20140147/2840/2014012800401932049.jpg)
?
5.定义自己的CAS验证机制
到这里，估计很多朋友肯定想问如何自定义自己的验证机制，比如使用咱们最常用的数据库:用户名/密码，验证的方式，
呵呵，别着急，下面就来和大家说一说如何来自定义CAS Server端的验证机制，咱们来一起实现一个基于mysql数据库 用户名/密码 验证的列子。
首先先和大家介绍一下CAS的扩展认证接口
CAS Server 负责完成对用户的认证工作，它会处理登录时的用户凭证 (Credentials) 信息，用户名/密码对是最常见的凭证信息。CAS Server 可能需要到数据库检索一条用户帐号信息，也可能在 XML 文件中检索用户名/密码，还可能通过 LDAP Server 获取等，在这种情况下，CAS 提供了一种灵活但统一的接口和实现分离的方式，实际使用中 CAS 采用哪种方式认证是与 CAS 的基本协议分离开的，用户可以根据认证的接口去定制和扩展
扩展 AuthenticationHandler
CAS 提供扩展认证的核心是 AuthenticationHandler 接口，该接口定义如下：
public interface AuthenticationHandler { /** * Method to determine if the credentials supplied are valid. * @param credentials The credentials to validate. * @return true if valid, return false otherwise. * @throws AuthenticationException An AuthenticationException can contain * details about why a particular authentication request failed. */ boolean authenticate(Credentials credentials) throws AuthenticationException;/** * Method to check if the handler knows how to handle the credentials * provided. It may be a simple check of the Credentials class or something * more complicated such as scanning the information contained in the * Credentials object. * @param credentials The credentials to check. * @return true if the handler supports the Credentials, false othewrise. */ boolean supports(Credentials credentials);}?该接口定义了 2 个需要实现的方法，supports ()方法用于检查所给的包含认证信息的Credentials 是否受当前 AuthenticationHandler 支持；而 authenticate() 方法则担当验证认证信息的任务，这也是需要扩展的主要方法，根据情况与存储合法认证信息的介质进行交互，返回 boolean 类型的值，true 表示验证通过，false 表示验证失败。
CAS3中还提供了对AuthenticationHandler 接口的一些抽象实现，比如，可能需要在执行authenticate() 方法前后执行某些其他操作，那么可以让自己的认证类扩展下面的抽象类：
public abstract class AbstractPreAndPostProcessingAuthenticationHandler implements AuthenticateHandler{ protected Log log = LogFactory.getLog(this.getClass()); protected boolean preAuthenticate(final Credentials credentials) { return true; } protected boolean postAuthenticate(final Credentials credentials, final boolean authenticated) { return authenticated; } public final boolean authenticate(final Credentials credentials) throws AuthenticationException { if (!preAuthenticate(credentials)) { return false; } final boolean authenticated = doAuthentication(credentials); return postAuthenticate(credentials, authenticated); } protected abstract boolean doAuthentication(final Credentials credentials) throws AuthenticationException;}?AbstractPreAndPostProcessingAuthenticationHandler 类新定义了 preAuthenticate() 方法和 postAuthenticate() 方法，而实际的认证工作交由 doAuthentication() 方法来执行。因此，如果需要在认证前后执行一些额外的操作，可以分别扩展 preAuthenticate()和 ppstAuthenticate() 方法，而 doAuthentication() 取代 authenticate() 成为了子类必须要实现的方法。
由于实际运用中，最常用的是用户名和密码方式的认证，CAS3 提供了针对该方式的实现，如下所示：
public abstract class AbstractUsernamePasswordAuthenticationHandler extends AbstractPreAndPostProcessingAuthenticationHandler{ protected final boolean doAuthentication(final Credentials credentials) throws AuthenticationException { return authenticateUsernamePasswordInternal((UsernamePasswordCredentials) credentials); } protected abstract boolean authenticateUsernamePasswordInternal( final UsernamePasswordCredentials credentials) throws AuthenticationException; protected final PasswordEncoder getPasswordEncoder() { return this.passwordEncoder; }public final void setPasswordEncoder(final PasswordEncoder passwordEncoder) { this.passwordEncoder = passwordEncoder; }}?
基于用户名密码的认证方式可直接扩展自 AbstractUsernamePasswordAuthenticationHandler，验证用户名密码的具体操作通过实现 authenticateUsernamePasswordInternal() 方法达到，另外，通常情况下密码会是加密过的，setPasswordEncoder() 方法就是用于指定适当的加密器。
从以上清单中可以看到，doAuthentication() 方法的参数是 Credentials 类型，这是包含用户认证信息的一个接口，对于用户名密码类型的认证信息，可以直接使用 UsernamePasswordCredentials，如果需要扩展其他类型的认证信息，需要实现Credentials接口，并且实现相应的 CredentialsToPrincipalResolver 接口，其具体方法可以借鉴 UsernamePasswordCredentials 和 UsernamePasswordCredentialsToPrincipalResolver。
SET FOREIGN_KEY_CHECKS=0;-- ------------------------------ Table structure for user-- ----------------------------CREATE TABLE `user` ( `id` int(11) NOT NULL auto_increment, `username` varchar(20) NOT NULL, `password` varchar(50) NOT NULL, PRIMARY KEY (`id`)) ENGINE=InnoDB DEFAULT CHARSET=utf8;-- ------------------------------ Records -- ----------------------------INSERT INTO `user` VALUES ('1', 'arix04', 'e10adc3949ba59abbe56e057f20f883e');
?这里插了一条记录，用户名/密码：arix04/123456;使用的md5加密。
<bean id="casDataSource" />，我们可以将其注释掉，换成我们希望的一个 AuthenticationHandler，比如，使用QueryDatabaseAuthenticationHandler
deployerConfigContext.xml文件插入下面这段:
<bean ref="casDataSource" /> <property name="sql" value="select password from user where username = ?" /> <property name="passwordEncoder" ref="myPasswordEncoder"/> </bean>
?
上面这段，sql定义了一个查询语句，用来判断用户名，密码是否存在，myPasswordEncoder是我自定义的一个密码的加密类，实现了passwordEncoder接口及其 encode() 方法。
[4].配置passwordEncoder
deployerConfigContext.xml文件插入下面这段:
<bean id="myPasswordEncoder" name="code">package org.jasig.cas.authentication.handler;import java.io.UnsupportedEncodingException;import java.security.MessageDigest;import java.security.NoSuchAlgorithmException;import java.text.SimpleDateFormat;import java.util.Date;import org.springframework.util.StringUtils;// Referenced classes of package org.jasig.cas.authentication.handler:// PasswordEncoderpublic final class MyPasswordEncoder implements PasswordEncoder{ public MyPasswordEncoder(){}; public String encode(String password) { char hexDigits[] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'}; try { byte[] strTemp = password.getBytes(); MessageDigest mdTemp = MessageDigest.getInstance("MD5"); mdTemp.update(strTemp); byte[] md = mdTemp.digest(); int j = md.length; char str[] = new char[j * 2]; int k = 0; for (int i = 0; i < j; i++) { byte byte0 = md[i]; str[k++] = hexDigits[byte0 >>> 4 & 0xf]; str[k++] = hexDigits[byte0 & 0xf]; } return new String(str); } catch (Exception e) { return null; } } public final static String MD5(String s) { char hexDigits[] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'}; try { byte[] strTemp = s.getBytes(); MessageDigest mdTemp = MessageDigest.getInstance("MD5"); mdTemp.update(strTemp); byte[] md = mdTemp.digest(); int j = md.length; char str[] = new char[j * 2]; int k = 0; for (int i = 0; i < j; i++) { byte byte0 = md[i]; str[k++] = hexDigits[byte0 >>> 4 & 0xf]; str[k++] = hexDigits[byte0 & 0xf]; } return new String(str); } catch (Exception e) { return null; } } public static Date getDateByString(String dateString) { try { SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd"); return dateFormat.parse(dateString); } catch (Exception e) { return null; } } public static String getDateString(Date date) { SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd"); return dateFormat.format(date); } }?[6].放入必要的Jar
将开发准备中的need.rar解压后的Jar文件、cas-server-support-jdbc-3.3.1.jar copy到Tomcat 6.0\webapps\cas\WEB-INF\lib\下面，如果你是用的其他数据库，则需要放入相应的数据库驱动包，
我这里给出的是mysql的驱动包。
[7].新建2个测试servlet
分别在上面SSO_Pro1,SSO_Pro2中新建class
WelcomePage
package servlet;import java.io.IOException;import java.io.PrintWriter;import javax.servlet.ServletException;import javax.servlet.http.HttpServlet;import javax.servlet.http.HttpServletRequest;import javax.servlet.http.HttpServletResponse;import javax.servlet.http.HttpSession;import edu.yale.its.tp.cas.client.filter.CASFilter;import edu.yale.its.tp.cas.client.filter.CASFilterRequestWrapper;public class WelcomePage extends HttpServlet { public void doGet(HttpServletRequest request, HttpServletResponse response) throws IOException, ServletException { response.setContentType("text/html"); PrintWriter out = response.getWriter(); out.println("<html>"); out.println("<head>"); out.println("<title>Welcome to SSO_Pro1 sample System!</title>"); out.println("</head>"); out.println("<body>"); out.println("<h1>Welcome to SSO_Pro1 sample System!</h1>"); CASFilterRequestWrapper reqWrapper=new CASFilterRequestWrapper(request); out.println("<p>The logon user:" + reqWrapper.getRemoteUser() + "</p>"); HttpSession session=request.getSession(); out.println("<p>The logon user:" + session.getAttribute(CASFilter.CAS_FILTER_USER) + "</p>"); out.println("<p>The logon user:" + session.getAttribute("edu.yale.its.tp.cas.client.filter.user") + "</p>"); out.println("</body>"); out.println("</html>"); }}?
web.xml中添加
<servlet> <servlet-name>WelcomePage</servlet-name> <servlet-class>servlet.WelcomePage</servlet-class> </servlet> <servlet-mapping> <servlet-name>WelcomePage</servlet-name> <url-pattern>/servlet/welcomePage</url-pattern> </servlet-mapping>
?
[8]OK，测试一下
所有的配置结束后，下面我们启动tomcat来测试一下这个demo，浏览器中输入
http://www.test.com:8080/SSO_Pro1/WelcomePage
将跳转到CAS Server的登录界面，
?
?
输入用户名密码：arix04/123456，登录成功的话则跳转到
![CAS在Tomcat中兑现单点登录[jdbc验证用户信息]](http://img.reader8.net/uploadfile/jiaocheng/20140147/2840/2014012800401932050.jpg)
?
?
同样，浏览器中输入
http://www.test.com:8080/SSO_Pro2/WelcomePage
直接进入：
![CAS在Tomcat中兑现单点登录[jdbc验证用户信息]](http://img.reader8.net/uploadfile/jiaocheng/20140147/2840/2014012800401932051.jpg)
?
session.getAttribute(CASFilter.CAS_FILTER_USER);session.getAttribute("edu.yale.its.tp.cas.client.filter.user");?
通过 JSTL 获取登录用户名
<c:out value="${sessionScope[CAS:'edu.yale.its.tp.cas.client.filter.user']}"/>另外，CAS 提供了一个 CASFilterRequestWrapper 类，该类继承自HttpServletRequestWrapper，主要是重写了 getRemoteUser() 方法，只要在前面配置 CASFilter 的时候为其设置“ edu.yale.its.tp.cas.client.filter.wrapRequest ”参数为 true，就可以通过 getRemoteUser（） 方法来获取登录用户名，具体方法如下所示：
通过 CASFilterRequestWrapper 获取登录用户名
?
CASFilterRequestWrapper reqWrapper=new CASFilterRequestWrapper(request);out.println("The logon user:" + reqWrapper.getRemoteUser());??