Java应用程序中集成Kettle
JAVA应用程序中集成KETTLE
Java应用程序中集成Kettle摘要:本文主要讨论如何在你自己的Java应用程序中集成Kettle如果你需要在自己的Java应用程序中集成Kettle,一般来说有两种应用需求,一种是通过纯设计器来设计ETL转换任务,然后保存成某种格式,比如xml或者在数据库中都可以,然后自己调用程序解析这个格式,执行这种转换,是比较抽象的一种执行方式,ETL里面转换了什么东西我们并不关心,只关心它有没有正常执行。
另一种是通过完全编程的方式来实现,详细的控制每一个步骤,需要知道转换执行的成功与否,这种方式可能需要更多的理解kettle的API以便更好的跟你的应用程序紧密结合,不过难度也比较大,可以很好的定制你的应用程序,代价自然是入门门槛比较高。
本文主要向你解释第一种Kettle的集成方式,文中所列出的代码节选自pentaho,不过应用程序本身跟pentaho没有什么关系。
Pentaho集成kettle的代码主要是两个类,KettleSystemListener和KettleComponent,看名字就猜出KettleSystemListener主要是起监听器的作用,它主要负责初始化kettle的一些环境变量,这个类主要包含四个方法:startup(),readProperties(),environmentInit(),shutdown(),程序入口自然是startup()方法,然后它会调用environmentInit()方法,这个方法就调用readProperties()方法读一个配置文件kettle。
properties,这个文件主要记录者kettle运行时可以调用的一些环境变量,关于kettle。
properties文件怎么用,第二篇文章“使用Kettle设计动态转换”有提到,readProperties()方法读完这个文件之后就把里面的键值对转换成变量传给kettle运行环境。
当kettle运行完了之后就调用shutdown()方法结束转换。
Java调用Kettle执行任务或转换
Java调⽤Kettle执⾏任务或转换Java调⽤Kettle执⾏任务或转换,需要使⽤Kettle中的jar,可以先导⼊lib⽬录中的⼏个基本的jar,如:kettle-core.jar、kettle-db.jar、kettle-engine.jar ,其它jar根据情况进⾏添加,所需的jar在<kettle-home>\lib、<kettle-home>\libext下⾯都可以找到,本⽰例引⽤的jar如下图:之后编写代码测试Java调⽤,调⽤前先使⽤Kettle的设计器设计了⼀个转换,取名为voucher.ktr。
另外,本⽰例使⽤的是Kettle3.2的版本,据说4.1版本调⽤⽅法会有不同。
[java]01. import org.pentaho.di.core.database.DatabaseMeta;02. import org.pentaho.di.core.exception.KettleException;03. import org.pentaho.di.core.logging.LogWriter;04. import org.pentaho.di.core.util.EnvUtil;05. import org.pentaho.di.job.Job;06. import org.pentaho.di.job.JobEntryLoader;07. import org.pentaho.di.job.JobMeta;08. import org.pentaho.di.repository.Repository;09. import org.pentaho.di.repository.RepositoryDirectory;10. import org.pentaho.di.repository.RepositoryMeta;11. import erInfo;12. import org.pentaho.di.trans.StepLoader;13. import org.pentaho.di.trans.Trans;14. import org.pentaho.di.trans.TransMeta;15.16. /**17. * Java调⽤Kettle⽰例代码18. *19. * @author 李⽂锴20. * @since 2012-8-14 下午03:50:0021. *22. */23. public class KettleTest {24.25. public static void main(String[] args) throws KettleException {26. String filename = "voucher.ktr";27. // callNativeTrans(filename);28. // executeTrans();29. // executeJobs();30. callNativeTransWithParam(filename);31. System.out.println("ok");32. }33.34. /**35. * 调⽤本地的转换⽂件36. *37. * @Description:38. * @param transFileName39. * @throws KettleException40. * @author 李⽂锴41. * @since:2012-8-15 下午02:58:4142. */43. public static void callNativeTrans(String transFileName) throws KettleException {44. // 初始化45. EnvUtil.environmentInit();46. StepLoader.init();47. // 转换元对象48. TransMeta transMeta = new TransMeta(transFileName);49. // 转换50. Trans trans = new Trans(transMeta);51. // 执⾏转换52. trans.execute(null);53. // 等待转换执⾏结束54. trans.waitUntilFinished();55. }56.57. /**58. * 调⽤本地的转换⽂件(带参数)59. *60. * @Description:61. * @param transFileName62. * @throws KettleException63. * @author 李⽂锴64. * @since:2012-8-15 下午02:58:5465. */66. public static void callNativeTransWithParam(String transFileName) throws KettleException {67. // 初始化68. EnvUtil.environmentInit();69. StepLoader.init();70. // 转换元对象71. TransMeta transMeta = new TransMeta(transFileName);72. // 转换73. Trans trans = new Trans(transMeta);74. String[] params = {};75. // 执⾏转换76. trans.execute(params);77. // 等待转换执⾏结束78. trans.waitUntilFinished();79.80. }81.82. /**83. * 执⾏存储在数据库资源库中的转换84. *85. * @Description:86. * @throws KettleException87. * @author 李⽂锴88. * @since:2012-8-15 下午02:59:1489. */90. public static void executeTrans() throws KettleException {91. // 初始化92. EnvUtil.environmentInit();93. StepLoader.init();94. // ⽇志95. LogWriter log = LogWriter.getInstance("TransTest.log", true, LogWriter.LOG_LEVEL_DEBUG);96. // ⽤户97. UserInfo userInfo = new UserInfo();98. userInfo.setLogin("admin");99. userInfo.setPassword("admin");100. // 数据库连接元对象(连接名称,不必与kettle中配置的保持⼀致:数据库类型:连接⽅式(kettle⽀持的连接⽅式):资源库IP:资源库实例名:资源库端⼝:资源库⽤户名:资源库⽤户密码)101. DatabaseMeta connection = new DatabaseMeta("", "Oracle", "Native", "192.168.3.232", "NSDEV", "1521", "nstcsa3441", "671468");102. // 资源库元对象103. RepositoryMeta repinfo = new RepositoryMeta();104. repinfo.setConnection(connection);105. // 资源库106. Repository rep = new Repository(log, repinfo, userInfo);107. // 连接资源库108. rep.connect("");109. // 资源库⽬录对象110. RepositoryDirectory dir = new RepositoryDirectory(rep);111. // 转换元对象112. TransMeta transMeta = new TransMeta(rep, "凭证(N9->EVC2)", dir);113. // 转换114. Trans trans = new Trans(transMeta);115. // 执⾏转换116. trans.execute(null);117. // 等待转换执⾏结束118. trans.waitUntilFinished();119. }120.121. /**122. * 执⾏本地的任务⽂件123. *124. * @Description:125. * @param jobFileName126. * @throws KettleException127. * @author 李⽂锴128. * @since:2012-8-15 下午02:59:34129. */130. public static void callNativeJob(String jobFileName) throws KettleException {131. // 初始化132. EnvUtil.environmentInit();133. JobEntryLoader.init();134. StepLoader.init();135. // ⽇志136. LogWriter log = LogWriter.getInstance("TransTest.log", true, LogWriter.LOG_LEVEL_DETAILED);137. // job元对象138. JobMeta jobMeta = new JobMeta(log, jobFileName, null);139. // job140. Job job = new Job(log, StepLoader.getInstance(), null, jobMeta);141. jobMeta.setInternalKettleVariables(job);142. // 执⾏job143. job.execute();144. // 等待job执⾏结束145. job.waitUntilFinished();146. }147.148. /**149. * 执⾏数据库资源库中的任务150. *151. * @Description:152. * @throws KettleException153. * @author 李⽂锴154. * @since:2012-8-15 下午02:59:45154. * @since:2012-8-15 下午02:59:45155. */156. public static void executeJobs() throws KettleException {157. // 初始化158. EnvUtil.environmentInit();159. JobEntryLoader.init();160. StepLoader.init();161. // ⽇志162. LogWriter log = LogWriter.getInstance("TransTest.log", true, LogWriter.LOG_LEVEL_DETAILED);163. // ⽤户164. UserInfo userInfo = new UserInfo();165. userInfo.setLogin("admin");166. userInfo.setPassword("admin");167. // 数据库连接元对象168. DatabaseMeta connection = new DatabaseMeta("", "Oracle", "Native", "192.168.3.232", "NSDEV", "1521", "nstcsa3441", "671468"); 169. // 资源库元对象170. RepositoryMeta repinfo = new RepositoryMeta();171. repinfo.setConnection(connection);172. // 资源库173. Repository rep = new Repository(log, repinfo, userInfo);174. // 连接资源库175. rep.connect("");176. // 资源库⽬录对象177. RepositoryDirectory dir = new RepositoryDirectory(rep);178. // 步骤加载对象179. StepLoader steploader = StepLoader.getInstance();180. // job元对象181. JobMeta jobmeta = new JobMeta(log, rep, "4.账户每⽇余额", dir);182. // job183. Job job = new Job(log, steploader, rep, jobmeta);184. // 执⾏job185. job.execute();186. // 等待job执⾏结束187. job.waitUntilFinished();188.189. }190.191. }。
用java开发kettle的原理
用java开发kettle的原理
Kettle是一款开源的ETL工具,用于抽取、转换和加载数据。
它是以Java语言开发的,原理如下:
1. 数据抽取:Kettle通过使用各种输入组件(如数据库读取器、文件读取器等)从源系统中抽取数据。
这些数据可以来自各种不同的数据源,如关系数据库、文件、Web服务等。
2. 数据转换:抽取到的数据可能需要进行转换,以适应目标系统的要求。
Kettle 提供了大量的转换功能,如数据清洗、字段转换、数据过滤、行合并等。
3. 数据加载:转换后的数据可以加载到目标系统中。
Kettle提供了各种输出组件,可以将数据加载到各种目标系统中,如关系数据库、文件、Hadoop等。
4. 任务调度:Kettle还提供了任务调度功能,可以将一系列的数据抽取、转换和加载操作组合成一个完整的工作流,并按照一定的时间计划进行自动执行。
Kettle的原理是通过使用各种输入组件、转换功能和输出组件,以及任务调度功能,实现数据抽取、转换和加载的全过程。
它提供了丰富的功能和灵活的配置选项,使开发人员能够方便地构建和管理复杂的ETL任务。
同时,由于是基于Java 开发的,Kettle还提供了Java API,可以进行二次开发和定制。
kettle解析 java解析
主题:Kettle解析Java解析1. Kettle简介Kettle是一款开源的ETL工具,用于提取、转换和加载数据。
它是由PDI(Pentaho Data Integration)项目开发的一款基于元数据驱动的工具,可以帮助用户在数据库、文件和流数据之间移动和转换数据。
Kettle提供了一个直观的用户界面和强大的数据集成功能,使得用户可以轻松地创建复杂的数据处理流程。
2. Java解析Java是一种通用的面向对象编程语言,它具有评台无关性、可移植性和强大的性能。
Java可以用于开发各种类型的应用程序,包括桌面应用程序、Web应用程序、移动应用程序和企业级应用程序。
Java的语法简洁清晰,易于学习和使用,因此备受开发者青睐。
3. Kettle与Java的结合Kettle作为一款强大的数据集成工具,与Java的结合可以实现更加复杂和灵活的数据处理功能。
通过Kettle可以轻松实现数据的抽取、转换和加载,而Java的编程能力则可以帮助用户实现更加精细化的数据处理逻辑。
将Kettle和Java结合起来可以实现更加灵活、高效的数据集成和处理。
4. Kettle的数据处理能力Kettle提供了丰富的数据处理组件和功能,用户可以利用Kettle实现数据的抽取、清洗、转换和加载。
Kettle提供了多种数据连接和输入输出方式,可以方便地将数据从不同的数据源中抽取出来,并进行灵活的数据处理。
Kettle还提供了丰富的数据转换组件,用户可以通过简单的拖拽操作实现不同数据之间的转换和关联。
Kettle还提供了数据加载组件,用户可以将处理好的数据重新加载回目标数据源。
5. Java的编程能力Java作为一种强大的编程语言,具有丰富的编程能力和库函数。
使用Java可以实现更加复杂和精细化的数据处理逻辑,包括数据格式化、算法处理、业务逻辑等。
Java还提供了诸如多线程、网络编程、数据库访问等丰富的编程库,可以帮助用户实现更加复杂和高效的数据处理功能。
java调用kettle向job(任务)和transformation(转换)传递参数实例(精品)
java调用kettle向job(任务)和transformation (转换)传递参数实例(精品)Kettle是一款强大的ETL工具,可以帮助开发人员快速、方便地进行数据的抽取、转换和加载。
在Kettle中,可以通过向Job(任务)和Transformation(转换)传递参数来实现更加灵活的数据处理。
下面是一个Java调用Kettle向Job和Transformation传递参数的实例,让我们一起来了解一下。
接下来,让我们来看一下如何向Job传递参数。
示例代码如下:```public class JobParameterExamplepublic static void main(String[] args)try// 1. 创建一个JobMeta对象,用于加载Job的定义文件JobMeta jobMeta = new JobMeta("path/to/your/job.kjb", null);// 2. 创建一个Job对象,用于执行JobJob job = new Job(null, jobMeta);// 3. 设置Job参数// 通过job.setVariable(方法来设置参数,参数名为"param1"job.setVariable("param1", "value1");// 4. 执行Jobjob.start(;job.waitUntilFinished(;// 5. 处理Job的执行结果if (job.getErrors( > 0)System.out.println("Job execution failed, please check the log.");} elseSystem.out.println("Job execution succeeded.");}} catch (Exception e)e.printStackTrace(;}}```在上述示例代码中,我们通过以下步骤向Job传递参数:1. 创建一个JobMeta对象,用于加载Job的定义文件。
Kettle变量和自己定义java代码的实例应用
Kettle变量和⾃⼰定义java代码的实例应⽤1 kettle.properties參数配置数据源连接和FTP连接因为測试环境和⽣产环境中数据库连接FTP等配置会在部署过程中变更,所以预先定义成配置项,在配置⽂件⾥改动。
这样測试和公布将会变得简单,以下以数据库为例说明这类配置的使⽤。
(1)⾸先要找到配置⽂件,不同的操作系统路径也不⼀样。
本⼈⽤win7进⾏开发,配置⽂件的路径为“C:\Users\chenpeng\.kettle\kettle.properties”。
例如以下:(2)配置⽂件⾥的详细配置例如以下:还能够可视化设置:(3)详细使⽤演⽰样例l 下⽅是数据库连接配置:l 下⽅是FTP连接配置:1.1.2 kettle.properties參数设置和路径及与正则配合使⽤(1)在kettle.properties中设置变量值(2)kettle.properties设置例如以下(win7下的路径为:C:\Users\chenpeng\.kettle)(4)在输出⽂件时使⽤參数中指定的路径:注:假设路径出现错误,如把某个⽬录删除则会报错。
仅仅要是报错,即使把⽬录建好了也仍然会报⽬录错误(好像有记忆功能),这时必须⼜⼀次启动kettle才⼲正常执⾏。
l 在输出⽂件时使⽤參数中和正則表達式混合使⽤场景:1.1.3 kettle.properties參数在java代码中的应⽤1.1.4 作业中变量使⽤并⽤javascript设置变量值上⾯的样例都是kettle.properties中声明的变量的应⽤。
这些都是全局范围内通⽤的,但⾮常多时间。
⼦作业须要有内部专⽤的变量參数。
这时就不能使⽤kettle.properties中声明的变量了。
须要在流程中声明变量,并把作⽤域设置为当前作业有效。
下⾯应⽤场景业务例如以下:⽂件名称要命名成当前⽇期格式的。
所以在作业级别定义了⼀个变量,但⽆法给它赋值。
如是採⽤了javascript脚本⽅式给该变量赋值,然后在输出⽂件名称的位置应⽤该变量就可以,后⾯⽂件的删除上传都是公⽤部分都须要⽤到这个变量做为接⼝參数来做处理。
kettle java 代码
kettle java 代码kettle是一款简单易用的开源ETL工具,由Pentaho公司开发,可以用来实现数据的抽取、转换和加载等任务。
Kettle使用基于XML 的元数据来定义数据流程,通过连接输入和输出源,可以通过转换步骤来对数据进行转换和转换,然后将结果加载到目标系统中。
它提供了丰富的数据处理和转换方式,例如分割、过滤、聚合、连接和排序等。
Kettle的主要特点是它易于学习和使用。
虽然Kettle不是Java 开发语言编写的,但是Kettle包含了可利用Java代码扩展的机制。
这使得开发人员可以使用Java代码来扩展Kettle的功能,使其更适合特定的实际情况。
在Kettle中,使用Java代码的主要方式是在步骤中编写Java脚本。
在步骤中编写的Java脚本可以访问任何Java库,并可以在ETL 过程中执行任何任务。
在步骤中编写的Java脚本通常被称为用户定义的Java步骤。
Kettle的Java步骤支持通过Java代码调用Web服务,调用EJB 和JMS等消息传递系统,以及从数据库中执行SQL查询等操作。
除此之外,Kettle还支持通过Java代码对文件进行操作,包括读取和写入文件,并支持使用Java代码实现自定义数据处理步骤。
Kettle的Java步骤包括在输入流中处理数据的JavaScript脚本步骤,以及实现ETL过程中自定义处理逻辑的Java脚本步骤。
Kettle 还支持使用JavaScript脚本编写步骤,在ETL流程的不同步骤之间进行数据转换和数据处理。
Java脚本步骤通常用于实现Kettle中缺少的功能或者为特定的ETL流程提供定制化的处理逻辑。
总之,Kettle是一款易于学习和使用的开源ETL工具,它包含了可扩展的Java代码编写机制,开发人员可以通过Java代码实现自定义的数据处理逻辑和数据转换操作。
Kettle的Java步骤支持Java脚本、JavaScript脚本和用户自定义数据处理步骤,可以满足各种不同的数据转换和数据处理需求。
java程序控制KETTLEJOB的执行
java程序控制KETTLEJOB的执⾏有时候我们想在java程序中触发远程服务器上kettle job的执⾏,并且获得执⾏结果。
kettle的carte提供了远程执⾏job和transfer的功能。
我使⽤的kettle是6.1版本,部署在linux服务器上,没有使⽤资源库。
下⾯介绍下各个步骤:为了⽅便以windows系统为例1、开启carte服务,在kettle安装⽬录下,运⾏Carte.bat,直接上图直接打Carte.bat后⾯不带任何参数就可以看到参数介绍,我这⾥在本机8081端⼝开启服务,看到最后的⽂字说明服务启动成功。
2、在浏览器中查看kettle 状态在浏览器中输⼊http://172.20.17.113:8081,会提⽰输⼊密码,这⾥先直接输⼊cluster/cluster,然后可以进⼊,页⾯上会显⽰通过carte执⾏的job和transfer的状态。
那么这个⽤户名密码在哪设置呢?我找了半天,也是⽹上看前辈指引,原来是在kettle安装⽬录/pwd下⾯,⼤家可以看到有carte-config-8081到8084这些配置⽂件,还有carte-config-master-8080.xml,应该是做主从集群⽤的,先不管了。
打开carte-config-8081.xml就可以看到<slaveserver><name>slave1-8081</name><hostname>localhost</hostname><port>8081</port><username>cluster</username><password>cluster</password><master>N</master></slaveserver>端⼝号跟⽤户名密码的默认配置都在这⾥了。
kettle集成应用之---java调用执行transformation和job
本文介绍如何在java应用程序中调用执行transformation和job。
(一)起步,配置资源库和数据库连接运行Spoon.bat,启动登录界面,如下图所示:第一次运行时,Repository为空,需要创建Repository。
(什么是Repository?Repository即资源库,是kettle用于存储元数据的多张数据表,在资源库模式下设计的transformation和job都被存储在这些数据表中。
)如果点击界面上的“No repository”,可以在无资源库模式下进行设计,设计的对象最终以xml文件的形式存储到本地目录。
点击“New”配置新的Repository,点击“Edit”编辑现有的Repository,点击“Delete”删除现有的Repository。
资源库配置:配置Repository需要先配置Database Connection(数据库连接)。
(什么是Database Connection?简单的来说,就是在数据库中分配一个空间存储资源库的元数据表,以Oracle为例,就是分配一个用户给kettle,具体配置见数据库连接配置)配置好Database Connection后,填写Name和Description,点击“Create or Upgrade”按钮,就可以将kettle的元数据表创建到你指定的数据库中。
RepositoryName : kettle默认的用户名和密码都是admin(登录后可以进行修改)数据库连接配置:用于存储Repository元数据。
配置信息如下:Connection Name : merit113(名称,自定义)Connection Type : Oracle (如果数据库是Oracle)Access : Native(选这个即可)Host Name : localhost(主机名)Database Name : merit113(数据库SID)Port Number : 1521(端口)User Name : kettle(用户名)Password : merit(密码)配置结束,可以点击界面上的“Test”进行测试。
kettle 调用 java 方法
kettle 调用 java 方法Kettle是一款开源的ETL工具,可以用于数据抽取、转换和加载。
它提供了丰富的组件和插件,可以方便地实现各种数据处理任务。
同时,Kettle还支持Java扩展,可以通过调用Java方法来扩展Kettle的功能。
在Kettle中调用Java方法需要使用Java脚本步骤。
Java脚本步骤是一种特殊的转换步骤,可以在其中编写Java代码,并将其与Kettle的数据流进行集成。
下面是一个简单的例子,演示了如何在Kettle中调用Java方法:1. 创建一个新的转换,并添加一个Java脚本步骤。
2. 在Java脚本步骤中编写Java代码,例如:```import java.util.Date;public class MyJavaClass {public static void myMethod(String arg) {System.out.println("Hello, " + arg + "!");System.out.println("Today is " + new Date() + ".");}}```3. 在Java脚本步骤的“脚本”选项卡中,将Java类的路径和方法名输入到“类名”和“方法名”字段中,例如:```类名:MyJavaClass方法名:myMethod```4. 在Kettle的数据流中添加一个输入步骤和一个输出步骤,将它们与Java脚本步骤连接起来。
5. 运行转换,输入数据将被传递到Java脚本步骤中,Java方法将被调用,并将输出传递回Kettle的数据流中。
通过调用Java方法,Kettle可以实现更加复杂的数据处理任务。
例如,可以使用Java方法来连接外部系统、处理复杂的数据结构、执行高级算法等等。
同时,Kettle还提供了许多与Java集成相关的插件和组件,例如Java脚本步骤、Java过滤器、Java转换器等等,可以方便地扩展Kettle的功能。
kettle-core 解析
Kettle-core是Kettle的核心组件之一,它是一个开源的ETL(Extract, Transform, Load)工具,用于数据抽取、转换和加载。
Kettle-core提供了Kettle的基础功能和API,开发人员可以使用这些API来编程方式使用Kettle的功能,实现数据仓库和数据集成。
在Kettle-core中,包含了许多重要的包和类。
例如,core包中是kettle的核心类,包括应用程序的核心配置类、异常处理类等。
同时,Kettle-core还提供了一系列API,用于创建和管理ETL流程,读取和写入数据源以及执行转换操作。
这些API可用于自动化数据处理过程,并将其集成到Java应用程序中。
除此之外,Kettle-core还包括了兼容性处理、界面字符串显示、目录结构管理等方面的功能。
它支持多种数据源和数据格式,能够轻松实现数据的抽取、清洗、转换、加载等操作,并且提供了灵活的配置和扩展接口,方便用户根据实际需求进行定制开发。
总之,Kettle-core是Kettle的重要组成部分,它提供了强大的数据处理功能和API接口,帮助开发人员轻松实现数据仓库和数据集成。
kettle使用java代码
kettle使用java代码一、Kettle简介Kettle(以前也被称作Pentaho Data Integration)是知名的开源ETL工具,由Pentaho公司开发,并由Pentaho实时维护和改进,是一款功能强大的企业级ETL(Extract-Transformat-Load)解决方案。
它可以集成/抓取所有地方的数据,包括结构化,半结构化和非结构化数据,数据可以从各种源,如数据库,文件,Excel,XML,Web服务,文本文件等中抓取。
Kettle支持各种目的地居,即支持将数据发送到各种目的地,如数据库,文件,Excel,XML,Web服务,文本文件等。
Kettle使用Java开发,具有丰富的可扩展性,可以通过其多种插件扩展Kettle的功能,可支持定制开发,可以通过使用Java API 开发抓取和转换器的Java类来扩展Kettle的功能。
二、Kettle使用Java代码1.编写Java代码:首先,我们需要使用Java编写抓取和过滤器的代码,Kettle提供了基于Java的API来实现抓取和过滤器操作,可以通过这套API 实现自定义的抓取和过滤器操作,使用Kettle的Java API可以实现快速的编码和测试,节省时间和费用。
//示例代码import org.pentaho.di.core.row.*; //引入Kettle Java APIpublic class MyExampleCode {//定义抓取类public class MyExampleFetch{public void processRow(RowMetaInterface rowMeta, Object[] rowData) throws Exception {//TODO: 写入你的处理程序}}//定义过滤器public class MyExampleFilter{public boolean processRow(RowMetaInterface rowMeta, Object[] rowData) throws Exception {//TODO: 写入你的处理程序return true;}}}2.配置Kettle编写完成Java代码之后,我们需要将其配置到Kettle中,在Kettle中,我们可以在“资源”窗口中找到抓取和过滤器选项,点击“新建”按钮,填写对应的名称,然后点击“程序”选项,选择“自定义”,将刚刚编写的Java代码路径填入即可,然后点击确认。
ETL工具kettle与java结合使用程序生成一个简单的转化文件
ETL工具kettle与java结合使用程序生成一个简单的转化文件最近项目中使用ETL工具kettle(4.+)对数据库的数据进行清洗,使用工具spoon来使用一些图形化的操作比较简单,抽空研究了下用使用kettle的一些jar包,把kettle结合到java(web项目一样)程序中。
留作一个记录,以后备用查看。
先看看网站上下了很多资料看(主要看Developer Guides/Embedding and Extending Pentaho Data Inte gration/...)下载kettle的api和源码看看,也可以帮你解决不少问题的。
下面是我自己写(加参考)的一个生成.ktr文件的代码。
(添加的jar包,我也没有太多的注意,看例子加入(有些可能没有必要,可以尝试的去掉一些测试下)的:avalon-framework-4.1.3.jarcommons-collections-3.2.jarcommons-io-1.4.jarcommons-lang-2.4.jarcommons-logging-1.1.jarcommons-vfs-20091118-pentaho.jarkettle-core-4.4.0-GA.jarkettle-db-4.4.0-GA.jarkettle-engine-4.4.0-GA.jarlog4j-1.2.12.jarlogkit-1.0.1.jarservlet-api-2.3.jar)Java code12345678910 11 1213 14 1516 17 18 192021 22 package com.yoodo.trans; import java.io.File; import mons.io.FileUtils; import org.pentaho.di.core.KettleEnvironment; import org.pentaho.di.core.database.DatabaseMeta; import org.pentaho.di.core.exception.KettleXMLException; import org.pentaho.di.core.plugins.PluginRegistry; import org.pentaho.di.core.plugins.StepPluginType;import org.pentaho.di.trans.TransHopMeta;import org.pentaho.di.trans.TransMeta; import org.pentaho.di.trans.step.StepMeta; import org.pentaho.di.trans.steps.insertupdate.InsertUpdateMeta; import org.pentaho.di.trans.steps.tableinput.TableInputMeta;publicclass TransDemo {public static TransDemo transDemo; /** * 两个库中的表名*/public static String bjdt_tablename = "T_USER"; public static String kettle_tablename = "T_USER"; /** * 数据库连接信息,适用于DatabaseMeta 其中 一个构造器DatabaseMeta(String xml) */public static final String[] databasesXML = { "<?xml version=\"1.0\" encoding=\"UTF-8\"?>" +2 32 42 52 62 72 82 93 03 13 23 33 43 53 63 73 83 94 04"<connection>" +"<name>bjdt</name>" +"<server>192.168.1.101</server>"+"<type>Oracle</type>" +"<access>Native</access>" +"<database>orcl</database>" +"<port>1521</port>" +"<username>bjdtuser</username>" +"<password>password</password>" +"</connection>","<?xml version=\"1.0\" encoding=\"UT F-8\"?>" +"<connection>" +"<name>kettle</name>" +"<server>192.168.1.101</server>" +"<type>Oracle</type>" +"<access>Native</access>" +"<database>orcl</database>" +"<port>1521</port>" +"<username>kettleuser</username>" +"<password>password</password>" +"</connection>"};/*** @param args*/public static void main(String[] args) {try {KettleEnvironment.init();14 24 34 44 54 64 74 84 95 05 15 25 35 45 55 65 75 85transDemo = new TransDemo(); TransMeta transMeta = transDemo.generateMyOwnTrans();String transXml = transMeta.getXML();//System.out.println("transXml:"+transXml) ;String transName = "etl/update_insert_T rans.ktr";File file = new File(transName);FileUtils.writeStringToFile(file, transXm l, "UTF-8");// System.out.println(databasesXML.length+"\ n"+databasesXML[0]+"\n"+databasesXML[1]);} catch (Exception e) {e.printStackTrace();return;}}/*** 生成一个转化,把一个数据库中的数据转移到另一个数据库中,只有两个步骤,第一个是表输入,第二个是表插入与更新操作* @return* @throws KettleXMLException*/public TransMeta generateMyOwnTrans() throws KettleXML Exception{System.out.println("************start to generat e my own transformation***********");TransMeta transMeta = new TransMeta();6 06 16 26 36 46 56 66 76 86 97 07 17 27 37 47 57 67//设置转化的名称transMeta.setName("insert_update");//添加转换的数据库连接for (int i=0;i<databasesXML.length;i++){DatabaseMeta databaseMeta = new DatabaseMeta(databasesXML[i]);transMeta.addDatabase(databaseMeta);}//registry是给每个步骤生成一个标识Id用PluginRegistry registry = PluginRegistry.getIns tance();//************************************************ ******************//第一个表输入步骤(TableInputMeta)TableInputMeta tableInput = new TableInputMeta ();String tableInputPluginId = registry.getPluginI d(StepPluginType.class, tableInput);//给表输入添加一个DatabaseMeta连接数据库DatabaseMeta database_bjdt = transMeta.findData base("bjdt");tableInput.setDatabaseMeta(database_bjdt);String select_sql = "SELECT ID, USERNAME, PA SSWORD, SEX, AGE, TELEPHONE, ADDRESS FROM "+bjdt_tablename;tableInput.setSQL(select_sql);//添加TableInputMeta到转换中StepMeta tableInputMetaStep = new StepMeta(tab leInputPluginId,"table input",tableInput);7 87 98 08 18 28 38 48 58 68 78 88 99 09 19 29 39 49//给步骤添加在spoon工具中的显示位置tableInputMetaStep.setDraw(true); tableInputMetaStep.setLocation(100, 100);transMeta.addStep(tableInputMetaStep);//******************************************************************//************************************************ ******************//第二个步骤插入与更新InsertUpdateMeta insertUpdateMeta = new Insert UpdateMeta();String insertUpdateMetaPluginId = registry.getP luginId(StepPluginType.class,insertUpdateMeta);//添加数据库连接DatabaseMeta database_kettle = transMeta.findDa tabase("kettle");insertUpdateMeta.setDatabaseMeta(database_kettle);//设置操作的表insertUpdateMeta.setTableName(kettle_tablename);//设置用来查询的关键字insertUpdateMeta.setKeyLookup(new String[]{"ID"}) ;insertUpdateMeta.setKeyStream(new String[]{"ID"}) ;insertUpdateMeta.setKeyStream2(new String[]{""}); //一定要加上insertUpdateMeta.setKeyCondition(new String[]{"=" });//设置要更新的字段59 69 79 89 91 0 01 0 11 0 21 0 31 0 41 0 51 0 61 0 71 0 81 0String[] updatelookup = {"ID","USERNAME","PASSWORD","SEX","AGE","TELEPHONE","ADDRESS"} ;String [] updateStream = {"ID","USERNAME","P ASSWORD","SEX","AGE","TELEPHONE","ADDRESS"};Boolean[] updateOrNot = {false,true,true,true ,true,true,true};insertUpdateMeta.setUpdateLookup(updatelookup);insertUpdateMeta.setUpdateStream(updateStream);insertUpdateMeta.setUpdate(updateOrNot);String[] lookup = insertUpdateMeta.getUpdateLoo kup();//System.out.println("******:"+lookup[1]);//System.out.println("insertUpdateMetaXMl:"+insert UpdateMeta.getXML());//添加步骤到转换中StepMeta insertUpdateStep = new StepMeta(inser tUpdateMetaPluginId,"insert_update",insertUpdateMeta);insertUpdateStep.setDraw(true);insertUpdateStep.setLocation(250,100);transMeta.addStep(insertUpdateStep);//************************************************ ******************//************************************************ ******************//添加hop把两个步骤关联起来transMeta.addTransHop(new TransHopMeta(tableInput MetaStep, insertUpdateStep));System.out.println("***********the end*********** *");return transMeta;}}1 1 01 1 11 1 21 1 31 1 41 1 51 1 61 1 71 1 81 1 91 2 01 2 11 21 2 31 2 41 2 51 2 61 2 71 2 81 2 91 3 01 3 11 3 21 3 31 3 41 31 3 61 3 71 3 81 3 91 4 01 4 11 4 21 4 31 4 41 4 51 4 61 4 71 481 4 91 5 01 5 11 5 21 5 31 5 41 5 51 5 61 5 71 5 8。
kettle引用stringentity -回复
kettle引用stringentity -回复如何使用Java中的StringEntity类来引用Kettle。
Kettle是一种开源的ETL(Extract, Transform, Load)工具,可以用于数据集成和数据转换。
它提供了一种简单而强大的方式来处理各种数据源和数据目标的连接、转换和加载。
在Java应用程序中,我们可以使用Kettle来实现数据处理流程,并通过StringEntity类来引用Kettle中的数据。
StringEntity是Java中的一个实用工具类,用于将字符串表示的实体转换为HTTP消息的实体。
使用该类,我们可以将Kettle转换的数据以字符串形式传输给其他应用程序或进行其他操作。
在以下的文章中,我们将一步一步讨论如何使用StringEntity来引用Kettle。
第一步是导入所需的库。
在Java中,我们需要导入相关的库来使用StringEntity和Kettle。
以下是所需的库:import org.apache.http.HttpEntity;import org.apache.http.client.methods.HttpPost;import org.apache.http.entity.StringEntity;import org.apache.http.impl.client.DefaultHttpClient;第二步是创建Kettle作业。
使用Kettle,我们可以创建一个作业,其中包含了数据的抽取、转换和加载步骤。
对于本文,我们将假设已经创建了一个名为"my_job.kjb"的Kettle作业。
第三步是将Kettle作业的输出转换为字符串。
要将Kettle作业的输出转换为字符串,我们可以使用以下代码:String jobPath = "path/to/my_job.kjb";String jobOutput = "";try {Job job = new Job(null, jobPath, null);job.run();Result result = job.getResult();jobOutput = result.getLogText();} catch (Exception e) {e.printStackTrace();}在上面的代码中,我们首先使用作业的路径创建一个作业对象。
JAVA应用程序中集成KETTLE
Java应用程序中集成Kettle摘要:本文主要讨论如何在你自己的Java应用程序中集成Kettle如果你需要在自己的Java应用程序中集成Kettle,一般来说有两种应用需求,一种是通过纯设计器来设计ETL转换任务,然后保存成某种格式,比如xml或者在数据库中都可以,然后自己调用程序解析这个格式,执行这种转换,是比较抽象的一种执行方式,ETL里面转换了什么东西我们并不关心,只关心它有没有正常执行。
另一种是通过完全编程的方式来实现,详细的控制每一个步骤,需要知道转换执行的成功与否,这种方式可能需要更多的理解kettle的API以便更好的跟你的应用程序紧密结合,不过难度也比较大,可以很好的定制你的应用程序,代价自然是入门门槛比较高。
本文主要向你解释第一种Kettle的集成方式,文中所列出的代码节选自pentaho,不过应用程序本身跟pentaho没有什么关系。
Pentaho集成kettle的代码主要是两个类,KettleSystemListener和KettleComponent,看名字就猜出KettleSystemListener主要是起监听器的作用,它主要负责初始化kettle的一些环境变量,这个类主要包含四个方法:startup(),readProperties(),environmentInit(),shutdown(),程序入口自然是startup()方法,然后它会调用environmentInit()方法,这个方法就调用readProperties()方法读一个配置文件kettle。
properties,这个文件主要记录者kettle运行时可以调用的一些环境变量,关于kettle。
properties文件怎么用,第二篇文章“使用Kettle设计动态转换”有提到,readProperties()方法读完这个文件之后就把里面的键值对转换成变量传给kettle运行环境。
当kettle运行完了之后就调用shutdown()方法结束转换。
Kettle与Java集成——Java代码调取运行资源库的Transformation
Kettle与Java集成——Java代码调取运行资源库的Transformation下面代码是Java代码调用Kettle4.0版本的Trans for mation1、Java读取资源库运行Transformation(1)目录类型资源库Java代码view pla in1.import org.pentaho.di.core.KettleEnvironment;2.import org.pentaho.di.core.exception.KettleException;3.import org.pentaho.di.repository.filerep.KettleFileReposit ory;4.import org.pentaho.di.repository.filerep.KettleFileReposit oryMeta;5.import org.pentaho.di.trans.Trans;6.import org.pentaho.di.trans.TransMeta;7.public class Reader TransFromRep {8.private static String tranName = "IM_KSDM"; // 传输名称9.public static void main(String[] args) throws KettleExcepti on {10.Trans trans=null;11.try {12.// 初始化13.KettleEnvironment.init();这个是4.0版本的初始化,和3.x 版本的不同14.// 资源库元对象15.KettleFileRepositoryMeta repinfo = new KettleFileRep ositoryMeta("","","数据采集","file:///E:/Workspaces/Kettle");16.// 文件形式的资源库17.KettleFileRepository rep = new KettleFileRepository();18.rep.init(repinfo);19.// 转换元对象20.if(tranName!=null){21.TransMeta transMetadel = rep.loadTransformation(rep .getTransformationID(tranName, null), null);22.// 转换23.trans = new Trans(transMetadel);24.// 执行转换25.trans.execute(null);26.// 等待转换执行结束27.trans.waitUntilFinished();28.//抛出异常29.if(trans.getErrors()>0){30.throw new Exception("There are errors during transfor mation exception!(传输过程中发生异常)");31.}32.}else{33.throw new KettleException("传输名为空!");34.}35.} catch (Exception e) {36.if(trans!=null){37.trans.stopAll();38.}39. e.printStackTrace();40.throw new KettleException(e);41.}42.}43.}(2)数据库类型资源库view plain1.import org.pentaho.di.core.KettleEnvironment;2.import org.pentaho.di.core.database.DatabaseMeta;3.import org.pentaho.di.core.exception.KettleException;4.import org.pentaho.di.repository.RepositoryDirectory;5.import org.pentaho.di.repository.RepositoryDirectoryInte rface;6.import org.pentaho.di.repository.kdr.KettleDatabaseRepo sitory;7.import org.pentaho.di.repository.kdr.KettleDatabaseRepo sitoryMeta;8.import org.pentaho.di.trans.Trans;9.import org.pentaho.di.trans.TransMeta;10.11.public class ReaderTransFromDBRep {12.private static String transName="t1";13.public static void main(String[] args) {14.15.try {16.KettleEnvironment.init();17.DatabaseMeta dataMeta = new DatabaseMeta("Kettle DBRep","MS SQL","Native","127.0.0.1","etl","1433","sa","bsoft");18.KettleDatabaseRepositoryMeta repInfo = new KettleD atabaseRepositoryMeta();19.repInfo.setConnection(dataMeta);20.KettleDatabaseRepository rep = new KettleDatabaseRepository();21.rep.init(repInfo);22.rep.connect("admin", "admin");23.24.RepositoryDirectoryInterface dir = new RepositoryDire ctory();25.dir.setObjectId(rep.getRootDirectoryID());26.27.TransMeta tranMeta = rep.loadTransformation(rep.get TransformationID(transName, dir), null);28.Trans trans = new Trans(tranMeta);29.trans.execute(null);30.trans.waitUntilFinished();31.} catch (KettleException e) {32. e.printStackTrace();33.}34.}35.}。
Kettle 工具介绍
目录1.1 kettle工具的优势 (2)1.1.1 kettle开源、高效 (2)1.1.2 kettle 非常强大而且易于使用的设计界面 (2)1.1.3 有非常强大而且众多的使用群体,应用广泛 (2)1.1.4 可用java进行集成开发 (2)1.2 kettle工具使用介绍 (3)1.2.1 资源库连接 (3)1.2.2 创建转换(transformation)或工作(job) (3)1.2.3 数据库连接 (3)1.2.4.1 数据抽取 (4)1.2.4.1 数据转换 (6)1.2.5 其他转换数据功能 (6)1.3 Java应用程序中集成Kettle (9)1.3.1 java程序分析 (9)1.3.2代码演示 (12)数据抽取之kettle工具1.1 kettle工具的优势1.1.1 kettle开源、高效Kettle是一款国外开源的etl工具,纯java编写,绿色无需安装,数据抽取高效稳定。
Kettle中有两种脚本文件,transformation和job,transformation完成针对数据的基础转换,job则完成整个工作流的控制。
1.1.2 kettle 非常强大而且易于使用的设计界面1.1.3 有非常强大而且众多的使用群体,应用广泛1.1.4 可用java进行集成开发提供了基于JAVA的脚步编写功能,可以灵活地自定义ETL过程,使自行定制、批量处理等成为可能,这才是一个程序员需要做的工作,而不仅是象使用Word一样操作kettle用户界面。
1.2 kettle工具使用介绍1.2.1 资源库连接kettle 有两种方式连接资源库:一种是纯数据库式,也就是你所有的转换全部都保存在一个数据库中,一般你在开始使用kettle的时候,它都会要求你建立一个资源仓库,这个资源仓库的连接方式就是你的数据库连接,你需要能够有相应的数据库驱动和对应的连接用户名和密码。
另外一种连接方式是使用文本文件,也就是xml文件,在做完任何转换之后,我们都可以把转换或者Job变成xml文件输出,这个输出文件包含你所有转换的全部信息。
kettle技术手册
Kettle 技术手册Etl 介绍ETL(Extract-Transform-Load的缩写,即数据抽取、转换、装载的过程),对于金融IT 来说,经常会遇到大数据量的处理,转换,迁移,所以了解并掌握一种etl工具的使用,必不可少。
Kettle是一款国外开源的etl工具,纯java编写,绿色无需安装,数据抽取高效稳定。
Kettle中有两种脚本文件,transformation和job,transformation完成针对数据的基础转换,job则完成整个工作流的控制。
kettle 部署运行将kettle2.5.1文件夹拷贝到本地路径,例如D 盘根目录。
双击运行kettle文件夹下的spoon.bat文件,出现kettle欢迎界面:稍等几秒选择没有资源库,打开kettle主界面创建transformation,job点击页面左上角的创建一个新的transformation,点击保存到本地路径,例如保存到D:/etltest下,保存文件名为EtltestTrans,kettle默认transformation文件保存后后缀名为ktr点击页面左上角的创建一个新的job,点击保存到本地路径,例如保存到D:/etltest下,保存文件名为EtltestJob,kettle默认job文件保存后后缀名为kjb 创建数据库连接在transformation页面下,点击左边的【Main Tree】,双击【DB连接】,进行数据库连接配置。
connection name自命名连接名称Connection type选择需要连接的数据库Method of access选择连接类型Server host name写入数据库服务器的ip地址Database name写入数据库名Port number写入端口号Username写入用户名Password写入密码例如如下配置:点击【test】,如果出现如下提示则说明配置成功点击关闭,再点击确定保存数据库连接。
开发技术:KETTLE+JAVA+API+开发实战记录
前言:为什么要用Kettle和KETTLE JA V A API?Kettle是什么?kettle:是一个开源ETL工具。
kettle提供了基于java的图形化界面,使用很方便,kettle的ETL工具集合也比较多,常用的ETL工具都包含了。
为什么使用KETTLE JA V A API:就像kettle文档所说:KETTLE JA V A API :Program your own Kettle transformation,kettle提供了基于JA V A的脚步编写功能,可以灵活地自定义ETL过程,使自行定制、批量处理等成为可能,这才是一个程序员需要做的工作,而不仅是象使用word一样操作kettle用户界面。
KETTLE JA V A API 实战操作记录:一、搭建环境:到http://www.kettle.be网站下载kettle的源码包,加压缩,例如解压缩到d:\kettle目录二、打开eclipse,新建一个项目,要使用jdk1.5.0,因为kettle的要使用System.getenv(),只有在jdk1.5.0才被支持。
提起getenv(),好像有一段几起几落的记录,曾一度被抛弃,现在又被jdk1.5支持了。
三、建一个class :TransBuilder.java,可以把d:\kettle\ extra\TransBuilder.java 的内容原样拷贝到你的TransBuilder.java里。
四、根据需要编辑源码。
并需要对原程序进行如下修改,在头部增加:import org.eclipse.swt.dnd.Transfer;//这个包被遗漏了,原始位置kettle根目录\libswt\win32\swt.jar//add by chq()on 2006.07.20(后来发现,不必加这个引用,因为编译时不需要)五、编译准备,在eclipse中增加jar包,主要包括(主要依据extra\TransBuilder.bat):\lib\kettle.jar\libext\CacheDB.jar\libext\SQLBaseJDBC.jar\libext\activation.jar\libext\db2jcc.jar\libext\db2jcc_license_c.jar\libext\edtftpj-1.4.5.jar\libext\firebirdsql-full.jar\libext\firebirdsql.jar\libext\gis-shape.jar\libext\hsqldb.jar\libext\ifxjdbc.jar\libext\javadbf.jar\libext\jconn2.jar\libext\js.jar\libext\jt400.jar\libext\jtds-1.1.jar\libext\jxl.jar\libext\ktable.jar\libext\log4j-1.2.8.jar\libext\mail.jar\libext\mysql-connector-java-3.1.7-bin.jar\libext\ojdbc14.jar\libext\orai18n.jar\libext\pg74.215.jdbc3.jar\libext\edbc.jar(注意:下面这个包被遗漏了,要加上。
KETTLE使用说明及带输入参数JAVA调用
ETL工具——kettle使用说明1简介ETL(Extract-Transform-Load的缩写,即数据抽取、转换、装载的过程),Kettle是一款国外开源的etl工具,纯java编写,数据抽取高效稳定。
2运行环境:OS:Window、Linux、Unix均可Jdk1.4以上3开始使用:Kettle可以在/网站下载。
下载kettle压缩包,因kettle为绿色软件,解压缩到任意本地路径即可。
(本文着重介绍kettle3.2.0稳定版)Spoon是一个图形用户界面,在不同平台上运行Spoon需要不同的脚本:Spoon.bat:在windows平台运行Spoon(或直接点击Kettle.exe)。
Spoon.sh:在Linux、Apple OSX、Solaris平台运行Spoon。
登陆一般选择没有资源库:Kettle中有两种脚本文件,transformation和job,transformation完成针对数据的基础转换,job则完成整个工作流的控制。
4转换(Transformation)新建一个转换kettle默认transformation文件保存后后缀名为ktr新建数据库连接(此链接也可在用到的节点处配置)填写数据源配置内容点击Test测试连接成功:核心对象切换到核心对象,菜单列出的是Transformation中可以调用的环节列表,可以通过鼠标拖动的方式对环节进行添加。
并且可通过shift+鼠标拖动,实现环节之间的连接。
常用节点介绍(红色节点后面逐一演示)类别环节名称功能说明输入文本文件输入从本地文本文件输入数据表输入从数据库表中输入数据获取系统信息读取系统信息输入数据输出文本文件输出将处理结果输出到文本文件表输出将处理结果输出到数据库表插入/更新根据处理结果对数据库表机型插入更新,如果数据库中不存在相关记录则插入,否则为更新。
会根据查询条件中字段进行判断更新根据处理结果对数据库进行更新,若需要更新的数据在数据库表中无记录,则会报错停止删除根据处理结果对数据库记录进行删除,若需要删除的数据在数据库表中无记录,则会报错停止查询数据库查询根据设定的查询条件,对目标表进行查询,返回需要的结果字段流查询将目标表读取到内存,通过查询条件对内存中数据集进行查询调用DB存储过程调用数据库存储过程转换字段选择选择需要的字段,过滤掉不要的字段,也可做数据库字段对应过滤记录根据条件对记录进行分类排序记录将数据根据某以条件,进行排序空操作无操作增加常量增加需要的常量字段脚本Modified Java扩展功能,编写JavaScript脚本,对数据进行相应处理Script Value映射映射(子转换)数据映射作业Sat Variables设置环境变量Get Variables获取环境变量表输入双击拖动到工作面板上的表输入结点,选择(或者新建)所需要的数据库连接,点击获取SQL查询语句或自行编辑SQL。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
Java应用程序中集成Kettle摘要:本文主要讨论如何在你自己的Java应用程序中集成Kettle如果你需要在自己的Java应用程序中集成Kettle ,一般来说有两种应用需求,一种是通过纯设计器来设计ETL转换任务,然后保存成某种格式,比如xml或者在数据库中都可以,然后自己调用程序解析这个格式,执行这种转换,是比较抽象的一种执行方式,ETL里面转换了什么东西我们并不关心,只关心它有没有正常执行。
另一种是通过完全编程的方式来实现,详细的控制每一个步骤,需要知道转换执行的成功与否,这种方式可能需要更多的理解kettle的API 以便更好的跟你的应用程序紧密结合,不过难度也比较大,可以很好的定制你的应用程序,代价自然是入门门槛比较高。
本文主要向你解释第一种Kettle的集成方式,文中所列出的代码节选自pentaho,不过应用程序本身跟pentaho 没有什么关系。
Pentaho 集成kettle的代码主要是两个类,KettleSystemListener和KettleComponent,看名字就猜出KettleSystemListener 主要是起监听器的作用,它主要负责初始化kettle的一些环境变量,这个类主要包含四个方法: startup() ,readProperties(),environmentInit(),shutdown(),程序入口自然是startup()方法,然后它会调用 environmentInit() 方法,这个方法就调用readProperties()方法读一个配置文件kettle。
properties,这个文件主要记录者kettle运行时可以调用的一些环境变量,关于kettle。
properties文件怎么用,第二篇文章“使用Kettle设计动态转换”有提到,readProperties()方法读完这个文件之后就把里面的键值对转换成变量传给kettle运行环境。
当kettle运行完了之后就调用 shutdown()方法结束转换。
KettleSystemListener相对逻辑比较简单,就不多介绍,下面主要介绍重点类:KettleComponentKettleComponent的方法主要有三种类型,一类是用来初始化工作,做一些验证工作,第二类是执行转换的方法,也是主要需要讨论的方法,第三类是取得数据结果的,有时候你需要得到转换的结果交给下一个步骤处理。
下面分别讨论这三类方法。
初始化KettleComponent的初始化工作主要是验证这个转换,包括有validateSystemSettings(),init(),validateAction(),全部都是public 方法,validateSystemSettings()会检查kettle 使用何种方式来连接资源库。
kettle有两种方式连接资源库,一种是纯数据库式,也就是你所有的转换全部都保存在一个数据库中,一般你在开始使用kettle的时候,它都会要求你建立一个资源仓库,这个资源仓库的连接方式就是你的数据库连接,你需要能够有相应的数据库驱动和对应的连接用户名和密码。
另外一种连接方式是使用文本文件,也就是xml文件,在做完任何转换之后,我们都可以把转换或者Job变成xml文件输出,这个输出文件包含你所有转换的全部信息。
在示例应用中使用的是文件的连接方式,下面看一下初始化的一段代码:Boolean useRepository =PentahoSystem.getSystemSetting("kettle/settings.xml","repository.type","files").equal s("rdbms");PentahoSystem.getSystemSetting()方法只是返回一个字符串,使用的xpath读一个xml的对应字段,下面列出settings.xml文件:filesadminadmin可以看到其中的repositories.xml.file 上面的一段注释,如果这个值为空会默认使用$HOME/.kettle/repository.xml文件当作资源库的连接文件,由于示例中使用的是文本文件所以没有用数据库连接,下面的erid和repository.password是指的kettle的资源库连接的用户名和密码,一般默认安装就两个,admin/admin 和guest/guest ,这里的用户名和密码不是连接数据库的用户名和密码,连接数据库的用户名和密码是在另外一个文件repositories.xml。
file指定的值所定义的一般默认的kettle安装并且运行了一段时间之后,会在$HOME/.kettle 目录下创建一些文件,如果你要在自己的系统中集成kettle的话,也需要保留这些文件,当然不一定位置是在原来的位置,关键是要让kettle知道这些文件放在哪。
执行转换当读完了这些配置文件并且验证了之后,KettleComponent就开始把前面读到的转换文件或者资源库类型变成Kettle的API,这主要是在executeAction()方法里面进行,它当然根据连接方式也分两种执行类型:1. 文本执行方式2. 资源库连接方式文本执行方式需要接受一个你指定的运行转换的文件或者Job的文件,然后把这个xml文件解析成Kettle能够执行的模式,根据执行的类型又可以分成两种:1. Trans任务2. Job任务两个执行的逻辑差不多,下面先介绍Trans的执行方式:执行Trans任务transMeta = new TransMeta(fileAddress, repository, true);transMeta.setFilename(fileAddress);然后它会调用:executeTransformation(TransMeta transMeta, LogWriter logWriter)这个方法是真正的把前面的来的transMeta转换成trans对象,等待下一步的执行:Trans trans = new Trans(logWriter, transMeta);List stepList = trans.getSteps();for (int stepNo = 0; stepNo < stepList.size(); stepNo++) {StepMetaDataCombi step = (StepMetaDataCombi) stepList.get(stepNo);if (step.stepname.equals(stepName)) {① Row row = transMeta.getStepFields(stepName);// create the metadata that the Pentaho result set needsString fieldNames[] = row.getFieldNames();String columns[][] = new String[1][fieldnames.length];for (int column = 0; column < fieldnames.length; column++) {columns[0][column] = fieldNames[column];}② MemoryMetaData metaData = new MemoryMetaData(columns, null);results = new MemoryResultSet(metaData);// add ourself as a row listener③ step.step.addRowListener(this);foundStep = true;break;}}1. Row对象是kettle用来表示一行数据的标准对象,跟jdbc取出来的一条数据转化后成为的一个POJO是一样的。
里面可以包含多个字段。
2 . MemoryMetaData对象是pentaho特有的,是专门用来返回ETL任务执行后的结果的,与标准的JDBC里面的resultSet 对应的resultSetMetaData 是一样的。
3. 对于如何处理数据的一个Listener,实现的是一个RowListener,数据是每一行每一行处理的,后面会介绍如果需要输出数据怎么取得这些输出数据。
如果不需要放回任何对象,则从1处开始都可以不要,只要初始化step对象即可。
所有的step对象都已经初始化之后就可以开始执行了,trans.startThreads();trans.waitUntilFinished();结束之后还有一些清理工作就不列出了。
执行Job任务执行Job任务之前还是会读取Job任务的描述文件,然后把这个描述文件(kettle的 .ktr文件)变成一个xml文档的dom :org.w3c.dom.Document doc = XmlW3CHelper.getDomFromString(jobXmlStr);之后也是初始化对应的元数据对象JobMetajobMeta = new JobMeta(logWriter, doc.getFirstChild(), repository);得到了jobMeta 之后就可以执行这个Job了,这里跟trans是一样的。
job = new Job(logWriter, StepLoader.getInstance(), repository, jobMeta);由于Job一般都没有什么返回值,所以Job不需要初始化它下面的对象,直接开始运行就可以了job.start();job.waitUntilFinished(5000000);连接资源库连接资源库使用的是connectToRepository()方法,先取得RepositoriesMeta 对象,然后根据你在setting。
xml文件里面定义的repository的名字来连接对应的repository。
理论上来说我们一般都只使用一个 repository ,但如果在产品中需要使用多个repository的话,你需要自己配置多个repository的名字和对应的用户名和密码。
只列出几行关键代码,repositoriesMeta = new RepositoriesMeta(logWriter);repositoriesMeta.readData(); // 从$HOME/。
kettle/repositories.xml 读数据。
repositoryMeta = repositoriesMeta.findRepository(repositoryName);repository = new Repository(logWriter, repositoryMeta, userInfo);userInfo = new UserInfo(repository, username, password);从资源库读取Trans连接到资源库之后自然是想办法读取数据库的表,把里面的记录转换成为Trans 对象,使用的是loadTransformFromRepository,这个方法的函数原型需要解释一下:TransMetaloadTransformFromRepository(String directoryName, String transformationName, Repository repository, LogWriter logWriter)第一个参数String directoryName 代表是你储存转换的目录,当你使用kettle 图形界面的时候,点击repository菜单的explorer repository ,你会发现你所有的东西都是存储在一个虚拟的类似与目录结构的地方,其中包括database connections , transformations , job , users 等,所以你需要的是指定你连接的目录位置,你也可以在目录里面再创建目录。