eddie J2EE开源软件爱好者,如Spring,Mule,jbossCache,MemCached,CAS等等。 http://eddie.javaeye.com UTF-8 Copyright 2003-2008, JavaEye.com http://blogs.law.harvard.edu/tech/rss JavaEye - 做最棒的软件开发交流社区 一个简单实际可用的CAS配置日志 eddie 作者: eddie  链接：http://eddie.javaeye.com/blog/78490  发表时间: 2007年05月10日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

1      目的
撰写本文的目的是记录一个简单、以数据库为验证用户的单点登陆的CAS配置过程，看过其他文档，要么没有配置过程，要么过于复杂。配置之前建议先仔细研究下相关的参考文档，只有明白了相关原理，配置起来其实很简单。
2      名词解说
Single Sign On - 通过用户登录一次，即可获得需访问系统和应用软件的授权。
Yale CAS - 耶鲁大学开发的单点登录（Single Sign On）系统称为CAS（Central Authentication Server）被设计成一个独立的Web应用程序(cas.war)。
CAS 网址http://www.ja-sig.org/products/cas/index.html
3      参考
Keytool使用指南：
http://java.sun.com/j2se/1.4.2/docs/tooldocs/windows/keytool.html
 
Tomcat-ssl配置指南：
http://tomcat.apache.org/tomcat-5.5-doc/ssl-howto.html
 
Cas文档：
http://www.ja-sig.org/products/cas/server/index.html
4      安装环境
WINXP + JDK1.5 + Tomcat 5.5.30 + CAS Server 3.0.7 + Yale CAS Client 2.1.1
5      配置过程
5.1         安装和配置Tomcat的SSL
参考以下帖子-Tomcat SSL配置大全：
http://www.javaeye.com/topic/78274
5.2         配置CAS服务器端
解压 cas-server-3.0.6.zip，把 \target\cas.war copy 到 %CATALINA_HOME%\webapps\ 下
5.3         配置CAS 客户端
我们要将tomcat的jsp-examples 及servlets-examples2个应用全部经过SSO的验证，CAS缺省验证方式的类是：org.jasig.cas.authentication.handler.support.SimpleTestUsernamePasswordAuthenticationHandler
这种配置只是用于测试目的，只要用户名和密码相同就可以验证通过了。
5.3.1   配置应用servlets-examples
修改\webapps\servlets-examples\WEB-INF\web.xml

在 servlet 及 servlet-mapping 中间加上以下设置：

xml 代码
  1. <filter>  
  2.     <filter-name>CASFilterfilter-name>  
  3.     <filter-class>  
  4.         edu.yale.its.tp.cas.client.filter.CASFilter   
  5.     filter-class>  
  6.     <init-param>  
  7.         <param-name>  
  8.             edu.yale.its.tp.cas.client.filter.loginUrl   
  9.         param-name>  
  10.         <param-value>https://localhost:8443/cas/loginparam-value>  
  11.     init-param>  
  12.     <init-param>  
  13.         <param-name>  
  14.             edu.yale.its.tp.cas.client.filter.validateUrl   
  15.         param-name>  
  16.         <param-value>  
  17.             https://localhost:8443/cas/proxyValidate   
  18.         param-value>  
  19.     init-param>  
  20.     <init-param>  
  21.         <param-name>  
  22.             edu.yale.its.tp.cas.client.filter.serverName   
  23.         param-name>  
  24.         <param-value>localhost:8080param-value>  
  25.     init-param>  
  26.     <init-param>  
  27.         <param-name>  
  28.             edu.yale.its.tp.cas.client.filter.serverName2   
  29.         param-name>  
  30.         <param-value>192.168.5.13:8080param-value>  
  31.     init-param>  
  32. filter>  
  33. <filter-mapping>  
  34.     <filter-name>CASFilterfilter-name>  
  35.     <url-pattern>/servlet/*url-pattern>  
  36. filter-mapping>  

 

注: edu.yale.its.tp.cas.client.filter.serverName 是表示需要 redirect 的网址，如果有1个以上的网址, 则可以一直增加上去，注意 param-name 要不一样
edu.yale.its.tp.cas.client.filter.loginUrl 是 redirect 的网址。
 
 

 

5.3.2     配置应用jsp-examples
修改%CATALINA_HOME%\webapps\jsp-examples\WEB-INF\web.xml在 servlet 及 servlet-mapping中间加上以下设置：
xml 代码
  1. <filter>  
  2.     <filter-name>CASFilterfilter-name>  
  3.     <filter-class>  
  4.         edu.yale.its.tp.cas.client.filter.CASFilter   
  5.     filter-class>  
  6.     <init-param>  
  7.         <param-name>  
  8.             edu.yale.its.tp.cas.client.filter.loginUrl   
  9.         param-name>  
  10.         <param-value>https://localhost:8443/cas/loginparam-value>  
  11.     init-param>  
  12.     <init-param>  
  13.         <param-name>  
  14.             edu.yale.its.tp.cas.client.filter.validateUrl   
  15.         param-name>  
  16.         <param-value>  
  17.             https://localhost:8443/cas/proxyValidate   
  18.         param-value>  
  19.     init-param>  
  20.     <init-param>  
  21.         <param-name>  
  22.             edu.yale.its.tp.cas.client.filter.serverName   
  23.         param-name>  
  24.         <param-value>localhost:8080param-value>  
  25.     init-param>  
  26.     <init-param>  
  27.         <param-name>  
  28.             edu.yale.its.tp.cas.client.filter.serverName2   
  29.         param-name>  
  30.         <param-value>192.168.5.13:8080param-value>  
  31.     init-param>  
  32. filter>  
  33. <filter-mapping>  
  34.     <filter-name>CASFilterfilter-name>  
  35.     <url-pattern>/*url-pattern>  
  36. filter-mapping>  

 

注: jsp-examples，和 servlets-examples 基本上大同小异，唯一不一样就是 filter-mapping 的 url-pattern，jsp-examples 是 /*，servlets-examples 是 /servlet/*。
 
5.3.3   设置需要用到的cas-client库
将casclient-2.1.1.zip改名为casclient-2.1.1.jar， copy 到jsp-examples 及 servlets-examples的lib下。
 
5.4   测试配置
启动tomcat,访问如下地址：
 
这时，系统会提示你将要访问的是加密网站，并问你接受该网站提供的证书，点接受后，将显示CAS单点登陆页面，地址变成如下：
 
输入任意的用户名，密码和用户名相同就可以进入刚才要访问的页面。
这时再访问servlets-examples 应用下面的任一个servlet,如：
 
访问后，你会发现地址栏的地址变为：
 
后面增加了?ticket=ST-3-6EuKFN4M2aLj9cVup6sABykzheEnAnY3Zmb-20,这就是CAS的ticket(票据)
刚才我们其实配置了2个应用都是需要验证用户的，如果用户先访问servlets-examples应用下面的servlet,同样会提示登陆，再访问jsp-examples，也不会提示登陆了，说明我们的单点登陆配置成功。
5.5         配置CAS通过数据库验证用户
CAS缺省配置只是用于测试目的，实际应用中，通过数据库进行验证用户最为常见，所以，我们现在测试通过数据库验证用户。先停止tomcat.
5.5.1   创建数据库表
我们测试使用的是oracle数据库，可以选用任何一个支持JDBC的数据库。用scott/tiger登陆sqlplus,输入如下语句创建用户表和输入测试数据：
create table app_user(username varchar(100), password varchar(100));
insert into app_user values('tomcat', 'tomcat');
insert into app_user values('cas', 'cas');
commit;
 
5.5.2   修改CAS 服务器端配置
修改%CATALINA_HOME%\webapps\cas\WEB-INF\ deployerConfigContext.xm把以下的程序代码屏蔽掉：
xml 代码
  1. <bean class="org.jasig.cas.authentication.handler.support.SimpleTestUsernamePasswordAuthenticationHandler" />  

 在同一地方加上以下程序代码:

xml 代码
  1. <bean class="org.jasig.cas.adaptors.jdbc.QueryDatabaseAuthenticationHandler">  
  2. <property name="sql" value="select password from app_user where username=?" />  
  3. <property name="dataSource" ref="dataSource" />  
  4. bean>  

 定义 dataSource bean,注意，配置的地方应该在之前，不要放错了位置，不是和以上验证bean放在一起。

xml 代码
  1. <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource" destroy-method="close">  
  2. <property name="driverClassName"><value>oracle.jdbc.driver.OracleDrivervalue>property>  
  3. <property name="url"><value>jdbc:oracle:thin:@127.0.0.1:1521:oracle9ivalue>property>  
  4. <property name="username"><value>scottvalue>property>  
  5. <property name="password"><value>tigervalue>property>  
  6. bean>  

 

5.5.3   添加CAS 服务器需要用到的jar
把 cas-server-3.0.6.zip里的 \target\cas-server-jdbc-3.0.6.jar copy 到%CATALINA_HOME%\webapps\cas\WEB-INF\lib下。
 
把 Oracle jdbc jar即ojdbc14.jar copy到%CATALINA_HOME%\webapps\cas\WEB-INF\lib下。
 
5.5.4  再次测试

启动tomcsat,重复刚才的测试，哈哈，输入tomcat/tomcat，可以了。
本文的讨论也很精彩，浏览讨论>>


JavaEye推荐



]]> Thu, 10 May 2007 15:15:00 +0800 http://eddie.javaeye.com/blog/78490 http://eddie.javaeye.com/blog/78490 Tomcat SSL配置大全 eddie 作者: eddie  链接：http://eddie.javaeye.com/blog/78274  发表时间: 2007年05月09日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

由于配置CAS的单点登陆系统，需要先配置Tomcat的SSL, 在配置tomcat的SSL过程中，我配置的版本是tomcat5.5.20,参考了很多资料，但发现一直不行，后来我换到了5.5.9,结果非常顺利，我于是换了总共4个主要版本，发现SSL的配置还真有些不同，现在我将这些配置记录下来，供下次参考。

参考文档

Keytool使用指南：
http://java.sun.com/j2se/1.4.2/docs/tooldocs/windows/keytool.html
 
Tomcat-ssl配置指南：
http://tomcat.apache.org/tomcat-5.5-doc/ssl-howto.html

配置过程

1.      生成 server key ：

以命令行方式切换到目录%TOMCAT_HOME%，在command命令行输入如下命令（jdk1.4以上带的工具）： 
keytool -genkey -alias tomcat -keyalg RSA -keypass changeit -storepass changeit -keystore server.keystore -validity 3600
用户名输入域名，如localhost（开发或测试用）或hostname.domainname(用户拥有的域名)，其它全部以 enter 跳过，最后确认，此时会在%TOMCAT_HOME%下生成server.keystore 文件。
注：参数 -validity 指证书的有效期(天)，缺省有效期很短，只有90天。

2.  将证书导入的JDK的证书信任库中:

这步对于Tomcat的SSL配置不是必须，但对于CAS SSO是必须的，否则会出现如下错误：edu.yale.its.tp.cas.client.CASAuthenticationException: Unable to validate ProxyTicketValidator。。。
导入过程分2步，第一步是导出证书，第二步是导入到证书信任库，命令如下：
keytool -export -trustcacerts -alias tomcat -file server.cer -keystore  server.keystore -storepass changeit
keytool -import -trustcacerts -alias tomcat -file server.cer -keystore  %JAVA_HOME%/jre/lib/security/cacerts -storepass changeit
如果有提示，输入Y就可以了。
其他有用keytool命令（列出信任证书库中所有已有证书，删除库中某个证书）：
keytool -list -v -keystore D:/sdks/jdk1.5.0_11/jre/lib/security/cacerts
keytool -delete -trustcacerts -alias tomcat  -keystore  D:/sdks/jdk1.5.0_11/jre/lib/security/cacerts -storepass changeit

3.  配置TOMCAT :

修改%TOMCAT_HOME%\conf\server.xml，以文字编辑器打开，查找这一行：
xml 代码
  1.   
将之后的那段的注释去掉，并加上 keystorePass及keystoreFile属性。
注意，tomcat不同版本配置是不同的:

Tomcat4.1.34配置：

xml 代码
  1.   
  2.    <Connector className="org.apache.coyote.tomcat4.CoyoteConnector"  
  3.            port="8443" enableLookups="true" scheme="https" secure="true"  
  4.            acceptCount="100"  
  5.            useURIValidationHack="false" disableUploadTimeout="true"  
  6.            clientAuth="false" sslProtocol="TLS"    
  7.            keystoreFile="server.keystore"    
  8.            keystorePass="changeit"/>  

Tomcat5.5.9配置：
 
xml 代码
  1.   
  2. <Connector port="8443" maxHttpHeaderSize="8192"  
  3.            maxThreads="150" minSpareThreads="25" maxSpareThreads="75"  
  4.            enableLookups="false" disableUploadTimeout="true"  
  5.            acceptCount="100" scheme="https" secure="true"  
  6.            clientAuth="false" sslProtocol="TLS"    
  7.            keystoreFile="server.keystore"    
  8.            keystorePass="changeit"/>  

Tomcat5.5.20配置(此配置同样可用于Tomcat6.0)：
 

xml 代码
  1.   
  2. <Connector protocol="org.apache.coyote.http11.Http11Protocol"    
  3.                      port="8443" maxHttpHeaderSize="8192"  
  4.            maxThreads="150" minSpareThreads="25" maxSpareThreads="75"  
  5.            enableLookups="false" disableUploadTimeout="true"  
  6.            acceptCount="100" scheme="https" secure="true"  
  7.            clientAuth="false" sslProtocol="TLS"                   
  8.            keystoreFile="server.keystore"    
  9.            keystorePass="changeit"/>  

Tomcat6.0.10配置：

xml 代码
  1. <Connector protocol="org.apache.coyote.http11.Http11NioProtocol"  
  2.            port="8443" minSpareThreads="5" maxSpareThreads="75"  
  3.            enableLookups="true" disableUploadTimeout="true"    
  4.            acceptCount="100"  maxThreads="200"  
  5.            scheme="https" secure="true" SSLEnabled="true"  
  6.            clientAuth="false" sslProtocol="TLS"  
  7.            keystoreFile="D:/tools/apache-tomcat-6.0.10/server.keystore"    
  8.            keystorePass="changeit"/>  
tomcat6支持3种，请参考以下文档：

验证配置
本文的讨论也很精彩，浏览讨论>>


JavaEye推荐



]]> Wed, 09 May 2007 17:11:39 +0800 http://eddie.javaeye.com/blog/78274 http://eddie.javaeye.com/blog/78274 MemCached 压力测试 eddie 作者: eddie  链接：http://eddie.javaeye.com/blog/77560  发表时间: 2007年05月07日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

MemCached安装完成后，进行了压力测试，主要参考了MemCached的javaclient的 类com.danga.MemCached.test.MemCachedTest。它的类主要问题是没有一个总的处理能力的描述。我进行了改写，提供了get和put的总吞吐量的汇总。

测试环境如下，

服务器：RedHat9, 512内存，P4内存，跑2个MemCached实例，运行memcached-1.2.1

客户端：单独一台机器，和服务器在一个局域网，100M网络带宽，运行java_memcached-release_1.5.1, jdk5.0

测试代码：

 

java 代码
  1. import com.danga.MemCached.MemCachedClient;   
  2. import com.danga.MemCached.SockIOPool;   
  3.   
  4. public class TestMemCache {   
  5.     static SockIOPool pool;   
  6.   
  7.     static int threads; // 运行的测试线程数   
  8.   
  9.     static int runs; // 每个线程运行的次数   
  10.   
  11.     static int size; // 设置到memcache中的数据包大小，单位k   
  12.   
  13.     static Integer myLock;// 锁定以下计数器   
  14.   
  15.     static long putTimes = 0; // put总时间，单位微秒   
  16.   
  17.     static long getTimes = 0; // get总时间，单位微秒   
  18.   
  19.     /**  
  20.      * @param args  
  21.      */  
  22.     public static void main(String[] args) {   
  23.         String[] serverlist = { "192.168.0.56:11211", "192.168.0.56:11212" };   
  24.   
  25.         // initialize the pool for memcache servers   
  26.         pool = SockIOPool.getInstance();   
  27.         pool.setServers(serverlist);   
  28.   
  29.         pool.setInitConn(5);   
  30.         pool.setMinConn(5);   
  31.         pool.setMaxConn(50);   
  32.         pool.setMaintSleep(30);   
  33.   
  34.         pool.setNagle(false);   
  35.         pool.initialize();   
  36.   
  37.         if (args.length < 3) {   
  38.             System.out.println("用法：TestMemCache 启动线程数 每线程执行测试数量 测试数据大小(k)");   
  39.             System.exit(1);   
  40.         }   
  41.   
  42.         threads = Integer.parseInt(args[0]);   
  43.         runs = Integer.parseInt(args[1]);   
  44.         size = 100 * Integer.parseInt(args[2]);   
  45.   
  46.         myLock = new Integer(threads);   
  47.   
  48.         for (int i = 0; i < threads; i++) {   
  49.             Thread thread = new WorkerThread();   
  50.             thread.start();   
  51.         }   
  52.     }   
  53.   
  54.     private static class WorkerThread extends Thread {   
  55.   
  56.         // 构造函数   
  57.         WorkerThread() {   
  58.         }   
  59.   
  60.         public void run() {   
  61.             // get client instance   
  62.             MemCachedClient mc = new MemCachedClient();   
  63.   
  64.             mc.setCompressEnable(false);   
  65.             mc.setCompressThreshold(0);   
  66.   
  67.             // get object to store   
  68.             int[] obj = new int[size];   
  69.             for (int i = 0; i < size; i++) {   
  70.                 obj[i] = i;   
  71.             }   
  72.   
  73.             String[] keys = new String[runs];   
  74.             for (int i = 0; i < runs; i++) {   
  75.                 keys[i] = "test_key" + i;   
  76.             }   
  77.   
  78.             for (int i = 0; i < runs; i++) {   
  79.                 mc.delete(keys[i]);   
  80.             }   
  81.   
  82.             long startTime = System.currentTimeMillis();   
  83.             for (int i = 0; i < runs; i++) {   
  84.                 mc.set(keys[i], obj);   
  85.             }   
  86.             long time = System.currentTimeMillis() - startTime;   
  87.   
  88.             synchronized (myLock) {   
  89.                 putTimes += time;   
  90.             }   
  91.   
  92.             startTime = System.currentTimeMillis();   
  93.             for (int i = 0; i < runs; i++) {   
  94.                 mc.get(keys[i]);   
  95.             }   
  96.             time = System.currentTimeMillis() - startTime;   
  97.   
  98.             synchronized (myLock) {   
  99.                 getTimes += time;   
  100.                 myLock--;   
  101.   
  102.                 if (myLock.equals(0)) {   
  103.                     System.out.println("测试完成! 启动线程数:" + threads   
  104.                             + ", 每线程执行测试数量: " + runs + ", 测试数据大小(byte):" + size);   
  105.   
  106.                     System.out.println("put处理时间:" + putTimes   
  107.                             + "微秒，处理put速度: 每秒 " + runs * threads * 1000 / putTimes   
  108.                             + " 次");   
  109.                     System.out.println("get处理时间:" + getTimes   
  110.                             + "微秒，处理get速度: 每秒 " + runs * threads * 1000 / getTimes   
  111.                             + " 次");   
  112.   
  113.                     pool.shutDown();   
  114.                 }   
  115.             }   
  116.         }   
  117.     }   
  118.   
  119. }   

 测试结果：

测试完成! 启动线程数:1, 每线程执行测试数量: 1000, 测试数据大小(byte):1024
put处理时间:2515微秒，处理put速度: 每秒 789 次
get处理时间:1266微秒，处理get速度: 每秒 789 次

测试完成! 启动线程数:2, 每线程执行测试数量: 1000, 测试数据大小(byte):1024
put处理时间:3595微秒，处理put速度: 每秒 1471 次
get处理时间:2734微秒，处理get速度: 每秒 1471 次

测试完成! 启动线程数:3, 每线程执行测试数量: 1000, 测试数据大小(byte):1024
put处理时间:6250微秒，处理put速度: 每秒 1846 次
get处理时间:4829微秒，处理get速度: 每秒 1846 次

测试完成! 启动线程数:4, 每线程执行测试数量: 1000, 测试数据大小(byte):1024
put处理时间:8673微秒，处理put速度: 每秒 2063 次
get处理时间:7858微秒，处理get速度: 每秒 2063 次

测试完成! 启动线程数:5, 每线程执行测试数量: 1000, 测试数据大小(byte):1024
put处理时间:10655微秒，处理put速度: 每秒 2352 次
get处理时间:10625微秒，处理get速度: 每秒 2352 次

测试完成! 启动线程数:6, 每线程执行测试数量: 1000, 测试数据大小(byte):1024
put处理时间:14702微秒，处理put速度: 每秒 2042 次
get处理时间:16844微秒，处理get速度: 每秒 2042 次

测试完成! 启动线程数:7, 每线程执行测试数量: 1000, 测试数据大小(byte):1024
put处理时间:18766微秒，处理put速度: 每秒 2502 次
get处理时间:20265微秒，处理get速度: 每秒 2502 次

测试完成! 启动线程数:8, 每线程执行测试数量: 1000, 测试数据大小(byte):1024
put处理时间:23828微秒，处理put速度: 每秒 2586 次
get处理时间:25062微秒，处理get速度: 每秒 2586 次

测试完成! 启动线程数:9, 每线程执行测试数量: 1000, 测试数据大小(byte):1024
put处理时间:29515微秒，处理put速度: 每秒 2654 次
get处理时间:31141微秒，处理get速度: 每秒 2654 次

测试完成! 启动线程数:10, 每线程执行测试数量: 1000, 测试数据大小(byte):1024
put处理时间:37780微秒，处理put速度: 每秒 2285 次
get处理时间:42876微秒，处理get速度: 每秒 2285 次

没有测试下去了，看来8~9个线程效率最高，服务端测试的时候，CPU一直使用率很低，最多到5%.

以上测试结果最多到了2500左右，但有位朋友的测试结果非常惊人，一个线程都超过了3300和4800的处理量，他的传输数据量小点，只有0.1k,我测试了下，用这个数据量，顶多也是到3000多的并发。他的测试结果请看如下网址：

 http://hi.baidu.com/jabber/blog/category/Memcached

 


本文的讨论也很精彩，浏览讨论>>


JavaEye推荐



]]> Mon, 07 May 2007 18:03:00 +0800 http://eddie.javaeye.com/blog/77560 http://eddie.javaeye.com/blog/77560 MemCached 安装日志 eddie 作者: eddie  链接：http://eddie.javaeye.com/blog/76990  发表时间: 2007年05月04日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

1、下载memcached-1.2.1.tar.gz和libevent-1.3b.tar.gz；

2、安装libevent

tar xvfz  libevent-1.3b.tar.gz

cd libevent-1.3b

./configure && make

make install

3、安装memcache

tar xvfz  memcached-1.2.1.tar.gz

cd  memcached-1.2.1

./configure

make && make install

4、将libevent安装的/usr/local/lib输出到引用库路径

# vi ~/.bash_profile

加入如下一行：

export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/usr/local/lib

5、启动(安装后位置：/usr/local/bin/memcached)

memcached  -d  -m 128 -l 192.168.0.50 -p 11211 -u root

即以root用户，分配最大2GM内存启动memcache

memcached  -d  -m 128 -l 192.168.0.50 -p 11212 -u root

在另外一个端口11212启动另外一个memcache实例


本文的讨论也很精彩，浏览讨论>>


JavaEye推荐



]]> Fri, 04 May 2007 15:55:24 +0800 http://eddie.javaeye.com/blog/76990 http://eddie.javaeye.com/blog/76990 开源数据集成工具: jitterbit eddie 作者: eddie  链接：http://eddie.javaeye.com/blog/76955  发表时间: 2007年05月04日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

最近，《InfoWorld》选出了15家IT新兴厂商，其中包括：jitterbit 请看：

http://www.linux-cn.com/html/linux/beginner/20070422/9519.html

 

Jitterbit 是一款集成工具, 用户可以使用Jitterbit 来集成不同的应用, 不同的databases, 以及不同的数据来源.

Jitterbit的使用

基本原理

  • 定义消息源（可以是Database表数据，HTTP，FTP上的文件，已共享文件，WebService方法）
  • 定义目标源（可以是Database表数据，HTTP，FTP上的文件（可定义XML格式、普通文本格式），已共享文件，WebService方法）
  • 定义Transformation，规定消息源数据如何映射到目标。
  • 部署Jitterbit项目到Jitterbit Server，设置调度规则（定时、频率）

 

取文件

  • 可以通过HTTP请求、FTP上的文件、已共享文件

取其它系统的库表

  • 通过定义库表的Source

消息通讯的几种方式

  • Database表数据
  • HTTP请求
  • FTP上的文件
  • 已共享文件
  • WebService方法

交互方式及协议

  • 在客户端建立工程，上传到服务器即可，工程会在服务器调度执行
  • 由Jitterbit服务器控制执行，Jitterbit服务在服务器要一直处于运行状态才能调度系统集成任务！

常用的功能

  • Database表数据，HTTP，FTP上的文件（可定义XML格式、普通文本格式），已共享文件，WebService方法 之间的交互

 

个人评价：

  • 支持常用的对数据库、文件、FTP、WebService,HTTP的数据源的访问，基本满足了中小企业数据转换需要。
  • IDE使用JAVA开发，调度器采用C开发；
  • 流程较清晰，使用起来极为方便，用户不需要了解更多技术细节；
  • 但不支持JMS、TCP等企业常用数据源，也不支持脚本扩展，如果想支持这些恐怕很难，后端采用的C开发的，你如果自己想支持，需要同时会JAVA和C；

本文的讨论也很精彩，浏览讨论>>


JavaEye推荐



]]> Fri, 04 May 2007 11:11:58 +0800 http://eddie.javaeye.com/blog/76955 http://eddie.javaeye.com/blog/76955 开源ETL：Kettle eddie 作者: eddie  链接：http://eddie.javaeye.com/blog/76952  发表时间: 2007年05月04日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

原作者：tiger119

引用地址：http://blog.csdn.net/tiger119/archive/2007/01/21/1489062.aspx

现在是一个Google的时代，而对于开发者，开源已成为最重要的参考书。对于某课题，不管你是深入研究还是初窥门径。估且google一把，勾一勾同行的成就，你必会获益良多。

    说到ETL开源项目，Kettle当属翘首，因此，偶决定花点时间了解一下。
    项目名称很有意思，水壶。按项目负责人Matt的说法：把各种数据放到一个壶里，然后呢，以一种你希望的格式流出。呵呵，外国人都很有联想力。
    看了提供的文档，然后对发布程序的简单试用后，可以很清楚得看到Kettle的四大块：
    Chef——工作(job)设计工具 (GUI方式)                  注：kettle2.4.0以后已经被spoon代替
    Kitchen——工作(job)执行器 (命令行方式)
    Spoon——转换(transform)设计工具 (GUI方式)
    Span——转换(trasform)执行器 (命令行方式)

    Carte——远程执行转换(trasform)的web服务器，通过内置jetty实现.



    嗯，厨师已经在厨房里，勺子和盘子一应俱全，且看能做出如何的大餐？

    一：Chef——工作(job)设计器
    这是一个GUI工具，操作方式主要通过拖拖拉拉，勿庸多言，一看就会。
    何谓工作？ 多个作业项，按特定的工作流串联起来，开成一项工作。正如：我的工作是软件开发。我的作业项是：设计、编码、测试！先设计，如果成功，则编码，否则继续设计，编码完成则开始设计，周而复始，作业完成。
    来，看看Chef中的作业项：
    1.1： 转换：指定更细的转换任务，通过Spoon生成。通过Field来输入参数。
    1.2： SQL：sql语句执行，
    1.3： FTP：下载ftp文件。
    1.4： 邮件：发送邮件。
    1.5： 检查表是否存在，
    1.6： 检查文件是否存在，
    1.7： 执行shell脚本。如：dos命令。
    1.8： 批处理。(注意：windows批处理不能有输出到控制台)。
    1.9： Job包。作为嵌套作业使用。
    1.10：JavaScript执行。这个比较有意思，我看了一下源码，如果你有自已的Script引擎，可以很方便的替换成自定义Script，来扩充其功能。
    1.11：SFTP：安全的Ftp协议传输。
    1.12：HTTP方式的上/下传。

    好了，看看工作流：
    如上文所述，工作流是作业项的连接方式。分为三种：无条件，成功，失败。这个没啥好说的，从名字就能知道它的意图。
   嗯，为了方便工作流使用，提供了几个辅助结点单元(你也可将其作为简单的作业项)：
    1：Start单元，任务必须由此开始。设计作业时，以此为起点。
    2：OK单元：可以编制做为中间任务单元，且进行脚本编制，用来控制流程。
    3：ERROR单元：用途同上。
    4：DUMMY单元：啥都不做，主要是用来支持多分支的情况。文档中有例子，不再多说。

    存储方式：
    支持XML存储，或存储到指定数据库中。
    一些默认的配置(如数据库存储位置……)，在系统的用户目录下，单独建立了一个.Kettle目录，用来保存用户的这些设置。 
    LogView：可查看执行日志。

    二：Kitchen——作业执行器
    是一个作业执行引擎，用来执行作业。这是一个命令行执行工具，没啥可讲的，就把它的参数说明列一下。
    -rep      : Repository name   任务包所在存储名
    -user     : Repository username   执行人
    -pass     : Repository password   执行人密码
    -job      : The name of the job to launch 任务包名称
    -dir      : The directory (don't forget the leading / or \)
    -file     : The filename (Job XML) to launch
    -level    : The logging level (Basic, Detailed, Debug, Rowlevel, Error, Nothing) 指定日志级别
    -log      : The logging file to write to  指定日志文件
    -listdir  : List the directories in the repository 列出指定存储中的目录结构。
    -listjobs : List the jobs in the specified directory 列出指定目录下的所有任务
    -listrep  : List the defined repositories 列出所有的存储
    -norep    : Don't log into the repository  不写日志
    嗯，居然不支持调度。看了一下文档，建议使用操作系统提供的调度器来实现调度，比如：Windows可以使用它的任务计划工具。

     注：其实是支持调度的，在job的start单元，可以设置调度的时间。

    三：Spoon——转换过程设计器
    GUI工作，用来设计数据转换过程，创建的转换可以由Pan来执行，也可以被Chef所包含，作为作业中的一个作业项。
    下面简单列举一下所有的转换过程。(简单描述，详细的可见Spoon文档)

    3.1：Input-Steps：输入步骤
    3.1.1：Text file input：文本文件输入，
           可以支持多文件合并，有不少参数，基本一看参数名就能明白其意图。
    3.1.2：Table input：数据表输入
           实际上是视图方式输入，因为输入的是sql语句。当然，需要指定数据源(数据源的定制方式在后面讲一下)
    3.1.3：Get system info：取系统信息
           就是取一些固定的系统环境值，如本月最后一天的时间，本机的IP地址之类。
    3.1.4：Generate Rows：生成多行。
           这个需要匹配使用，主要用于生成多行的数据输入，比如配合Add sequence可以生成一个指定序号的数据列。
    3.1.5：XBase Input：
    3.1.6：Excel Input：
    3.1.7：XML Input：
           这三个没啥可讲的，看看参数就明了。

    3.2：Output-Steps： 输出步聚
    3.2.1：Text file output：文本文件输出。
         这个用来作测试蛮好，呵呵。很方便的看到转换的输出。
    3.2.2：Table output：输出到目的表。
    3.2.3：Insert/Update：目的表和输入数据行进行比较，然后有选择的执行增加，更新操作。
    3.2.4：Update：同上，只是不支持增加操作。
    3.2.5：XML Output：

    3.3：Look-up：查找操作
    DataBase:
    Stream：
    Procedure：
    Database join：
    很简单，看看参数就明白了。

    3.4：Transform  转换 (嗯，重点)
    3.4.1：Select values： 对输入的行记录数据 的字段进行更改 (更改数据类型，更改字段名或删除)
   数据类型变更时，数据的转换有固定规则，可简单定制参数。可用来进行数据表的改装。
    3.4.2： Filter rows： 对输入的行记录进行 指定复杂条件 的过滤。
          用途可扩充sql语句现有的过滤功能。但现有提供逻辑功能超出标准sql的不多。
    3.4.3：Sort rows：对指定的列以升序或降序排序，当排序的行数超过5000时需要临时表。
    3.4.4：Add sequence：为数据流增加一个序列，
          这个配合其它Step(Generate rows, rows join)，可以生成序列表，如日期维度表(年、月、日)。
    3.4.5：Dummy：不做任何处理，主要用来作为分支节点。
    3.4.6：Join Rows：对所有输入流做笛卡儿乘积。
    3.4.7：Aggregate：聚合，分组处理，不推荐使用了，被Group by代替
    3.4.8：Group by：分组
   用途可扩充sql语句现有的分组，聚合函数。但我想可能会有其它方式的sql语句能实现。
    3.4.9：Java Script value：使用mozilla的rhino作为脚本语言，并提供了很多函数，用户可以在脚本中使用这些函数。
    3.4.10. Row Normaliser：该步骤可以从透视表中还原数据到事实表，
          通过指定维度字段及其分类值，度量字段，最终还原出事实表数据。
    3.4.11. Unique rows：去掉输入流中的重复行
   在使用该节点前要先排序，否则只能删除连续的重复行。 
    3.4.12. Calculator：提供了一组函数对列值进行运算，
          所介绍，使用该方式比用户自定义JAVA SCRIPT脚本速度更快。
    3.4.13. Merge Rows：用于比较两组输入数据，一般用于更新后的数据重新导入到数据仓库中。
    3.4.14. Add constants：增加常量值。
         这个我没弄明白它的用法？？？
    3.4.15. Row denormaliser：同Normaliser过程相反。
    3.4.16. Row flattener：表扁平化处理
  指定需处理的字段和扃平化后的新字段，将其它字段做为组合Key进行扃平化处理。

    3.5：Extra：除了上述基本节点类型外还定义了扩展节点类型 
    3.5.1：SPLIT FIELDS， 按指定分隔符拆分字段
    3.5.2：EXECUTE SQL SCRIPT，执行SQL语句
    3.5.3：CUBE INPUT，
    3.5.4：CUBE OUTPUT等。
    这两个没明白是啥意思。
   
    3.6：其它
    存储方式： 与Chef相同。
    数据源(Connection)；见后。
    Hops：setp连接起来，形成Hops。
    Plugin step types等节点：这个没仔细看，不知如何制作Plugin step。
    LogView：可查看执行日志。

    四：Pan——转换的执行工具
    命令行执行方式，可以执行由Spoon生成的转换任务。
    同样，不支持调度。
    参数与Kitchen类似，可参见Pan的文档。

    五：其它
    Connection：
    可以配置多个数据源，在Job或是Trans中使用，这意味着可以实现跨数据库的任务。
    支持大多数市面上流行的数据库。

    个人感觉：(本人不成熟的看法)
    1：转换功能全，使用简洁。作业项丰富，流程合理。
    2：java代码，支持的数据源范围广，所以，跨平台性较好。
    3：从实际项目的角度看，和其它开源项目类似，主要还是程序员的思维，缺少与实际应用项目(专业领域)的更多接轨，当然，项目实施者的专注点可能在于一个平台框架，而非实际应用(实际应用需要二次开发)。
    4：看过了大多数源码，发现源码的可重用性不是太好(缺少大粒度封装)，有些关键部分好象有Bug。
          比如：个别class过于臃肿，线程实现的同步有问题。
    5：提供的工具有些小错，如参数的容错处理。

    好，对Kettle有了浅浅的了解，其它的容后再说。


本文的讨论也很精彩，浏览讨论>>


JavaEye推荐



]]> Fri, 04 May 2007 10:43:54 +0800 http://eddie.javaeye.com/blog/76952 http://eddie.javaeye.com/blog/76952 rosifox关于tomcat集群和treecache的文章 eddie 作者: eddie  链接：http://eddie.javaeye.com/blog/52025  发表时间: 2007年02月03日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

http://www.blogcn.com/u2/38/21/ayufox/index.html


本文的讨论也很精彩，浏览讨论>>


JavaEye推荐



]]> Sat, 03 Feb 2007 19:38:14 +0800 http://eddie.javaeye.com/blog/52025 http://eddie.javaeye.com/blog/52025 jbosscache1.4 invalidation模式的疑问 eddie 作者: eddie  链接：http://eddie.javaeye.com/blog/51907  发表时间: 2007年02月02日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

项目中需要用jbosscache解决分布式cache问题。我们想实现如下cache模式：

假设集群有2个节点，分别是node1和node2，我们要缓存的对象叫test.table1,

1、node1 检索test.table1的id为“id1”的值, 这时，由于缓存中没有相应数据，它会先访问数据库，然后缓存在本地，即调用类似treecache.put("/test/table1","id1" "value1")的语法保存在缓存中；这时其他节点的cache不受影响；下次node1再次访问该值，就会从缓存中取到该值。

2、同样，node2访问test.table1的id为“id1”的值，这时缓存中也没有该值，同样访问数据库，然后放到缓存中。

3、node1修改了test.table1的id为“id1”的值，这时，应该调用treecache的remove方法，将改对象清除出缓存，并向node2发送invalidation通知，使node2也清除相应的对象。

我们在考察了jbosscache支持的4种同布方法（REPL_ASYNC，REPL_SYNC，INVALIDATION_ASYNC，INVALIDATION_SYNC）后，觉得INVALIDATION_SYNC这种方式满足我们的需求。即各个节点都单独保留自己的cache数据，在查询数据库后，保存在本地的缓存中，这时不同步数据到其他节点。但当某个节点修改了缓存中的数据，这时需要发送

invalidation消息到其他节点，使得其他节点删除相应的缓存。

 

在通过1个下午的测试后，结果和我们设想的有很大出入，以下就是测试结果：

1.node1 加入新的数据 /test1，正常，node2相应的缓存没有变化；

2.node2加入新的数据/test1，奇怪的事情发生了，node1的 /test1节点不见了，我看日志，确认它受到了Eviction消息，即数据失效消息；

3、同样，我们再次在node1加入数据/test1，结果，node2的/test1数据不见了，同样是收到了相应的数据失效消息。

 

以上现象，会导致node1到数据库取数据，更新缓存，node2的缓存中相应数据会因此失效，下次node2取同样的数据时，由于数据失效，还要去数据库取，再次更新node2缓存后，此时，node1将收到缓存失效消息。这样循环往复，实际上缓存一点也没有起到分布式的作用。

实际上，应该是node1和node2分别保存自己的缓存，只有在我们更新的数据或删除了数据时，这时才能发送invalidation消息，其他节点清除相应缓存数据。

 

有没有朋友用过INVALIDATION模式，帮我解答下这个问题，谢谢！

 

 


本文的讨论也很精彩，浏览讨论>>


JavaEye推荐



]]> Fri, 02 Feb 2007 20:53:55 +0800 http://eddie.javaeye.com/blog/51907 http://eddie.javaeye.com/blog/51907 jbosscache1.4 invalidation模式下put会导致发送invalidation的问题 eddie 作者: eddie  链接：http://eddie.javaeye.com/blog/51887  发表时间: 2007年02月02日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

    我们在项目中使用jbosscache来做分布式缓存部分数据库数据。打算用INVALIDATION_SYNC来将remove的数据失效掉，

但令人失望的是，我们在put数据的时候，发现它也会广播invalidation消息，导致数据失效。这样的结果是，只有1台服务器有

缓存数据，其他服务器从数据库取到相同数据put到缓存时，就会导致其他服务器缓存失效，但这个操作实际上没有修改数据。

实在是不合理。可能是我们的使用方式有问题，或者有其他配置方法，请有这方面的朋友能帮助下，谢谢！

 

配置文件如下（就是标准的那个invalidationSync-service.xml文件）：





  


  
  
  

             name="jboss.cache:service=TreeCache">

      jboss:service=Naming
      jboss:service=TransactionManager

     
      org.jboss.cache.DummyTransactionManagerLookup

     
      REPEATABLE_READ

     
      INVALIDATION_SYNC

     
      false

     
      0

     
      0

     
      JBossCache-Cluster

     
     

     
     
        
           
           
                             ip_ttl="64" ip_mcast="true"
                 mcast_send_buf_size="150000" mcast_recv_buf_size="80000"
                 ucast_send_buf_size="150000" ucast_recv_buf_size="80000"
                 loopback="false"/>
                              up_thread="false" down_thread="false"/>
           
           
           
                                        up_thread="false" down_thread="false"/>
&nbs