Java代码调用kettle任务
java调用kettle7传递参数并执行作业
java调⽤kettle7传递参数并执⾏作业java代码如下所⽰:public static void runJob(String fileName, String beginTime, String endTime) throws KettleException {// 初始化KettleEnvironment.init();// 任务元对象 fileName为作业的绝对路径C:\Users\Administrator\Desktop\参数传递测试作业.kjbJobMeta jm = new JobMeta(fileName, null); // 任务Job job = new Job(null, jm);// 传参job.setVariable("beginTime", beginTime);job.setVariable("endTime", endTime);// 开始任务job.start();// 等待任务结束job.waitUntilFinished();}作业与转换作业中添加转换1和转换2转换1中需添加获取系统信息步骤,获取需要的参数,表输⼊中需勾选替换SQL语句中的变量。
内容如下图所⽰(转换2同转换1): '${beginTime}' 转换中加单引号的原因:java中若参数定义为 String beginTime = "2021-04-07 00:00:00";传递到转换中${beginTime}的值就是2021-04-07 00:00:00 PS: 也可以直接这样定义String beginTime = "'2021-04-07 00:00:00'"; 则对应转换中的参数不需添加单引号 BETWEEN to_date(${beginTime},'yyyy-MM-dd hh24:mi:ss') and to_date(${endTime},'yyyy-MM-dd hh24:mi:ss')测试时可以采⽤以下⽅法:。
KETTLE API JAVA调用示例
tostep.setDraw(true); tostep.setDescription("Write information to table [" + targetTableName + "] on database [" + targetDBInfo + "]"); transMeta.addStep(tostep);
public static final TransMeta buildCopyTable(String transformationName, String sourceDatabaseName, String sourceTableName, String[] sourceFields, String targetDatabaseName, String targetTableName, String[] targetFields) throws KettleException {
EnvUtil.environmentInit();
try {
// Create a new transformation... // TransMeta transMeta = new TransMeta(); transMeta.setName(transformationName);
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. }。
调用kettle作业
调用kettle作业调用Kettle作业Kettle是一款开源的ETL(Extract-Transform-Load)工具,可以用于数据抽取、转换和加载。
在大数据处理和数据仓库等领域,Kettle被广泛应用于数据集成和数据处理的工作中。
本文将介绍如何调用Kettle作业,以及如何在作业中实现数据转换和加载的功能。
一、Kettle作业的基本概念和组成Kettle作业是由一系列步骤组成的,每个步骤都是一个独立的任务单元,可以按照顺序执行。
常见的Kettle作业步骤包括数据输入、数据转换、数据输出等。
在Kettle中,作业的执行结果可以被保存为日志文件或输出到数据库等位置。
二、调用Kettle作业的方法要调用Kettle作业,可以通过以下几种方法实现:1. 使用Kettle图形界面:Kettle提供了一个图形界面工具,可以通过拖拽和连接组件的方式来创建作业。
在图形界面中,可以直接运行和调试作业。
但是,这种方式需要手动操作,不适合自动化调用。
2. 使用Kettle命令行工具:Kettle提供了一个命令行工具,可以通过命令行参数来指定要执行的作业文件和作业参数。
通过命令行工具,可以将Kettle作业集成到脚本或其他程序中,实现自动化调用。
3. 使用Kettle API:Kettle还提供了一个Java API,可以通过编写Java代码来调用Kettle作业。
通过API,可以实现更精细的控制和定制化需求。
三、实现数据转换和加载的方法Kettle作为一个强大的ETL工具,可以实现多种数据转换和加载的需求。
下面介绍几个常见的数据处理场景和相应的实现方法:1. 数据清洗:Kettle提供了多种数据清洗的步骤,如过滤、去重、替换等。
可以根据具体的需求选择合适的步骤进行配置。
2. 数据转换:Kettle支持多种数据格式的转换,如文本文件到数据库、数据库到文本文件、XML到数据库等。
可以通过选择合适的输入和输出步骤,以及相应的映射关系,实现数据的转换。
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的定义文件。
java调用kettle动态传参修改数据库连接
java调⽤kettle动态传参修改数据库连接感⾔:⽹络的确帮助了我们,但是kettle的资料真实太少,英语学好是有必要的;整体思路:创建javaproject→导⼊kettle所需要的包→实现kettle中的对象→重写对象内容→调⽤对象执⾏;1 package kettle;23//需要导⼊的包4 import java.util.List;5 import java.util.Map;6 import java.util.Set;78 import org.pentaho.di.core.KettleEnvironment;9 import org.pentaho.di.core.database.DatabaseMeta;10 import org.pentaho.di.trans.Trans;11 import org.pentaho.di.trans.TransMeta;1213 import mon.utils.StringUtils;1415161718public class ExecuteLocalTran {19/**20 * java调⽤本地的tran并且传递参数(包括给SQL传参和动态修改数据库连接)21 *22 *23*/24public static void main(String arg[]) throws Exception25 {2627//前台页⾯传递的参数28 String idname="7";//作为参数值29 String filename="./test.ktr";//ktr路径3031 String conn_name="output_dbconnection";32 String host_name="128.8.28.124";33 String db_name="TestWork";34 String db_port="1433";35 String user_name="wxj";36 String pass_word="wxj1988";3738 KettleEnvironment.init();//初始化kettle环境39 TransMeta transMeta = new TransMeta(filename);//new tran的源数据对象4041//DatabaseMeta dm =transMeta.getDatabase(1);42 List<DatabaseMeta> dmlist=transMeta.getDatabases();43for(DatabaseMeta dm : dmlist)44 {45 String connection_name=StringUtils.trimNull(dm.getName());46if(connection_name.equals(conn_name))47 {48 dm.setHostname(host_name); //连接地址49 dm.setDBName(db_name); //数据库名称50 dm.setDBPort(db_port); //端⼝51 dm.setUsername(user_name); //⽤户52 dm.setPassword(pass_word); //密码53/*54 System.out.println("DatabaseMeta:"+dm.getName());55 System.out.println("AccessType:"+dm.getAccessType());56 System.out.println("DatabaseName:"+dm.getDatabaseName());57 System.out.println("Hostname:"+dm.getHostname());58 System.out.println("Username:"+dm.getUsername());59 System.out.println("Password:"+dm.getPassword());60*/61 }6263 }64 Trans trans = new Trans(transMeta);//创建tran对象65 trans.setVariable("namevalue",idname);//给对象传参66 trans.prepareExecution(null);//异常处理67 trans.startThreads();//开始执⾏68 trans.waitUntilFinished();//等待执⾏完毕69if(trans.getErrors()!=0)70 {71 System.out.println("Error encountered!");72 }73 }7475 }View Code。
kettle类型转换时间格式使用java代码
Kettle 是一款数据转换工具,可以实现多种数据格式之间的转换。
在使用Kettle 时,可以编写Java 代码来实现自定义的类型转换。
以下是一个将日期时间格式从XML 文件转换为JSON 文件的示例:1. 首先,确保已正确导入所需的类库:```javaimport java.text.SimpleDateFormat;import java.util.Date;import org.json.JSONObject;import org.json.XML;```2. 编写一个方法,用于将XML 中的日期时间格式转换为JSON 格式:```javapublic static JSONObject convertXMLToJSON(String xmlData) {JSONObject jsonObject = new JSONObject();try {// 解析XML 数据org.json.XML jsonXML = new org.json.XML(xmlData);// 获取XML 中包含的第一个日期时间元素org.json.JSONArray dateTimeElements = jsonXML.getJSONArray("//dateTime");// 遍历日期时间元素,将其转换为JSON 格式for (int i = 0; i < dateTimeElements.length(); i++) {org.json.JSONObject dateTimeObject = new org.json.JSONObject();// 获取日期时间元素的值String dateTimeValue = dateTimeElements.getString(i);// 创建SimpleDateFormat 对象,用于解析XML 中的日期时间格式SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS");// 将XML 中的日期时间格式转换为Java 日期对象Date date = sdf.parse(dateTimeValue);// 将日期对象转换为JSON 格式dateTimeObject.put("dateTime", date.toString());// 将dateTimeObject 添加到JSON 对象的数组中jsonObject.put("dateTime", dateTimeObject);}} catch (Exception e) {e.printStackTrace();}return jsonObject;}```3. 在主方法中调用`convertXMLToJSON` 方法,传入XML 数据,并输出转换后的JSON 数据:```javapublic static void main(String[] args) {String xmlData = "<root><dateTime>2022-01-01T00:00:00.000</dateTime><dateTime>2022-01-02T00:00:00.000</dateTime></root>";JSONObject jsonObject = convertXMLToJSON(xmlData);System.out.println(jsonObject.toString(4));}```。
kettle使用JAVA代码进行执行
kettle使⽤JAVA代码进⾏执⾏kettle 设计完成之后,可以在设计⼯具中进⾏调⽤,也可以使⽤java代码进⾏调⽤。
1.通过⽂件⽅式执⾏转换。
public static void runTransfer(String[] params, String ktrPath) {Trans trans = null;try {//// 初始化// 转换元对象KettleEnvironment.init();// 初始化EnvUtil.environmentInit();TransMeta transMeta = new TransMeta(ktrPath);// 转换trans = new Trans(transMeta);// 执⾏转换trans.execute(params);// 等待转换执⾏结束trans.waitUntilFinished();// 抛出异常if (trans.getErrors() > 0) {throw new Exception("There are errors during transformation exception!(传输过程中发⽣异常)");}} catch (Exception e) {e.printStackTrace();}}2.通过⽂件⽅式执⾏jobpublic static void runJob(Map<String,String> maps, String jobPath) {try {KettleEnvironment.init();// jobname 是Job脚本的路径及名称JobMeta jobMeta = new JobMeta(jobPath, null);Job job = new Job(null, jobMeta);// 向Job 脚本传递参数,脚本中获取参数值:${参数名}// job.setVariable(paraname, paravalue);Set<Entry<String, String>> set=maps.entrySet();for(Iterator<Entry<String, String>> it=set.iterator();it.hasNext();){Entry<String, String> ent=it.next();job.setVariable(ent.getKey(), ent.getValue());}job.start();job.waitUntilFinished();if (job.getErrors() > 0) {throw new Exception("There are errors during job exception!(执⾏job发⽣异常)");}} catch (Exception e) {e.printStackTrace();}}3.执⾏资源库的中的转换。
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 script代码
kettle java script代码1.新建Java测试类,导出Jar包,放在kettle目录中的libext文件中package test;public class Test{public static final String getMyName(String name){return name+"12345";}}2.抽数据--经过java处理--输出文件到桌面import test.Test;public boolean processRow(StepMetaInterface smi, StepDataInterface sdi) throws KettleException{Object[] r = getRow();if (r == null) {setOutputDone();return false;}if (first){first = false;}// It is always safest to call createOutputRow() to ensure that your output row's Object[] is large// enough to handle any new fields you are creating in this step.//r = createOutputRow(r, outputRowSize);/* TODO: Your code here. (See Sample)/ Get the value from an input fieldString foobar = get(Fields.In, "a_fieldname").getString(r);foobar += "bar";// Set a value in a new output fieldget(Fields.Out, "output_fieldname").setValue(r, foobar);*///调用jarString foobar = get(Fields.In, "ENAME").getString(r); //输入参数foobar += Test.getMyName("我是谁的水");get(Fields.Out, "ENAME").setValue(r, foobar);//获取参数String AGEField = getParameter("AGE");get(Fields.Out, "AGE").setValue(r, AGEField); //输出参数// Send the row on to the next step.putRow(data.outputRowMeta, r);return true;}。
java中调用kettle转换文件
java中调⽤kettle转换⽂件java中调⽤kettle转换⽂件通过命令⾏也能够调⽤,然后java中调⽤命令⾏代码也能够。
这样没有和java代码逻辑⽆缝集成。
本⽂说明kettle5.1中假设通过其它API 和java代码⽆缝集成;⽹上⼤多数资料都是低版本号的。
在kettle5.x中已经不能执⾏。
1、须要哪些jar⽂件以kettle开头的是必须,上图最以下三个也要;红⾊框中的两个是我測试转换⽤到的。
各⾃是⽣成UUID和⽂件。
要是少了jar⽂件,执⾏程序⼀定报错。
⼤家依据错误到kettle安装⽂件夹LIB中找对应的jar加到编译路径中。
2、演⽰样例说明怎样通过java调⽤转换演⽰样例是把⼀个excel的内容导⼊到数据中。
excel仅仅有两列,所以须要在kettle中⽣成⼀列uuid,然后导⼊到数据库中。
默认⽣成的uuid有‘-’间隔符,所以通过“Replace in string”替换为空;excel步骤,使⽤了命名參数,所以要在转换配置设置命名參数。
演⽰样例代码例如以下:publicclass KettleUtil2 {public String RES_DIR = "res";private String fullFileName ;public KettleUtil2(String fileName){fullFileName = System.getProperty("user.dir") + File.separator + RES_DIR;fullFileName += File.separator + fileName;}/*** 没有參数是,设置參数为null* @param paras*/publicvoid runTransformation(Map<String,String> paras) {try {KettleEnvironment.init();TransMeta transMeta = new TransMeta(fullFileName);Trans transformation =new Trans(transMeta);for(Map.Entry<String, String> entry: paras.entrySet()) {transformation.setParameterValue(entry.getKey(), entry.getValue());}transformation.execute(null);transformation.waitUntilFinished();if (transformation.getErrors() > 0) {thrownew RuntimeException("There wereerrors during transformation execution."); }} catch (KettleException e) {System.out.println(e);}}}最后调⽤代码例如以下:publicclass EtlTest {publicstaticvoid main(String[] args) {KettleUtil2 etl = new KettleUtil2("testimport.ktr");Map<String,String> para = new HashMap<String,String>();//给转换中命名參数赋值para.put("XlsName", "data");etl.runTransformation(para);}}。
Kettle4.4.0通过Java代码输出日志到表
Kettle4.4.0通过Java代码输出⽇志到表之所以选择4.4.0,因为公司还在⽤Java6编程……但是项⽬的需求是:实施⼈员上传kettle的⽂件,然后在界⾯上点击运⾏,运⾏完之后需要在页⾯上看⽇志。
当然 kettle 是⾃带⽇志输出功能的,不过我们总不能跟客户说:“你在kettle⾥⾯定义好⽇志输出,然后⾃⼰去数据库或者某个⽂件夹中查询⽇志即可”当然不可能让客户去看数据库或者服务器上⽣成的⽇志⽂件。
那现在的问题是怎样让⾃⼰的代码控制 kettle 的⽇志。
只要能够通过程序获取,或者按照我们的规则重定向输出,那么事情就好办了,我们就可以按照⾃⼰的意愿存储和查询⽇志(job和trans运⾏⽅式不⼀样,但是在代码层⾯编程的⽅式是类似的,下⾯只说Job,看懂了Job,Trans⾃然就明⽩了)Kettle中⾃带⽇志输出功能,先说下在kettle中怎么输出⽇志到数据库表1、切换到主对象树选项卡2、双击⾃⼰写的 Job ,就会弹出⼀个窗⼝切换到⽇志选项卡左边选择Job右边配⼀下数据库连接(这个窗⼝的最下⽅有个SQL按钮,点击⼀下可以看到建表的SQL)然后配置连接下⾯的⼀些属性然后运⾏ Job 的时候,就会记录⽇志到数据库中:会记录很多字段,图中只是⼀部分。
关键字段有3个:CHANNEL_ID 可以关联到某个Job(下⾯会讲怎么关联。
可以通过此运⾏记录找到这条数据,然后找到⽇志信息)ERRORS 某个Job的错误个数,0表⽰完美运⾏完毕(如果不为0,说明有错误)LOG_FIELD 这个是BLOB或者TEXT字段,存放的是⽇志详情(这就是我们需要的内容)这样⽣成的⽇志我们能够查询,在Job中有个⽅法 job.getLogChannelId() ,可以获取CHANNEL_ID,通过这个字段可以关联到⽇志表。
但是这么做需要什么前提呢?前提是⽤ kettle 的⼈要⼿动去配置⼀下我上⾯所说的步骤:打开⽇志功能,配置连接如果条件允许,这么做也⾏,但是有两个问题:1、⽤kettle⽂件的⼈知道⽇志要放到那个数据库的哪张表吗?就算知道,他有权访问数据库吗?就算知道并且有权访问,那这位实施⼈员要待在客户那⾥实施吗?当然啦,可以通过在 kettle 中配置变量的⽅式解决,就是数据库连接信息和表信息等⽤变量占位符。
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使用说明及带输入参数的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+鼠标拖动,实现环节之间的连接。
常用节点介绍(红色节点后面逐一演示)表输入双击拖动到工作面板上的表输入结点,选择(或者新建)所需要的数据库连接,点击获取SQL查询语句或自行编辑SQL。
若需根据前一步获取数据进行查询,可用“?”号代替,变量顺序与前一节点相同字段选择界面如下:选择和修改:指定需要流到输出流中的字段的精确顺序和名称删除:指定从输出流中删除的字段(以后输出流将不会获取到此数据) 元数据:修改元数据字段的名称、类型、长度和精度✓插入/更新如下图,表示当原表的id=new_test.id时,比较createdate和account,若不同就进行更新,如果没有此id就插入该数据运行Transformation:一个简单的Transformation如下:这里可以不用配置直接启动执行结果中可以查到执行步骤以及输出日志新建一个Job核心对象菜单列出的是Job中可以调用的环节列表,可以通过鼠标拖动的方式对环节进行添加。
kettle 程序调用执行ktr转换示例代码
kettle 程序调用执行ktr转换示例代码package com.***.dci;import java.io.File;import java.io.FileNotFoundException;import java.io.FileOutputStream;import java.io.FileWriter;import java.io.IOException;import java.util.ArrayList;import java.util.Date;import java.util.HashMap;import java.util.Iterator;import java.util.List;import java.util.Map;import java.util.Map.Entry;import org.logicalcobwebs.proxool.admin.servlet.AdminServlet;import org.pentaho.di.core.exception.KettleException;import org.pentaho.di.core.util.EnvUtil;import org.pentaho.di.trans.StepLoader;import org.pentaho.di.trans.Trans;import org.pentaho.di.trans.TransMeta;import org.pentaho.di.trans.performance.StepPerformanceSnapShot;public class Test {/*** @param args* @throws IOException*/public static void main(String[] args) throws IOException {// 解释runTransformation("c:/ss.ktr");}public static void runTransformation(String filename) throws IOException {try {//初始化任务StepLoader.init();EnvUtil.environmentInit();TransMeta transMeta = new TransMeta(filename);transMeta.setCapturingStepPerformanceSnapShots(true);Trans trans = new Trans(transMeta);trans.setMonitored(true);trans.setInitializing(true);trans.setPreparing(true);trans.setRunning(true);trans.setSafeModeEnabled(true);trans.execute(null); // You can pass arguments instead of null.//放入一个MAP存储结果HashMap map = new HashMap();trans.setStepPerformanceSnapShots(map);while (!trans.isFinished()) {if (trans.getStepPerformanceSnapShots() != null&& trans.getStepPerformanceSnapShots().size() > 0) {//得到所有步骤Map<String, List<StepPerformanceSnapShot>> SnapShots = trans.getStepPerformanceSnapShots();//输出动态监控情况Iterator it = SnapShots.entrySet().iterator();String oneTimeOneStepInfo = "";String ontTimeAllStepInfo = "";while(it.hasNext()){Entry en = (Entry)it.next();//步骤当前情况ArrayList SnapShotList = (ArrayList) en.getV alue();if (SnapShotList != null && SnapShotList.size() > 0) {StepPerformanceSnapShot SnapShot = (StepPerformanceSnapShot) SnapShotList.get(SnapShotList.size() - 1);oneTimeOneStepInfo = ( "StepName:"+SnapShot.getStepName()+";"+"Errors: " + SnapShot.getErrors() + ";"+ "InputBufferSize: "+ SnapShot.getInputBufferSize()+ ";"+ "LinesInput: " + SnapShot.getLinesInput()+ ";"+ "LinesOutput: "+ SnapShot.getLinesOutput() + ";"+ "LinesRead: "+ SnapShot.getLinesRead()+ ";"+ "LinesRejected: "+ SnapShot.getLinesRejected()+ ";"+ "LinesUpdated: "+ SnapShot.getLinesUpdated()+ ";"+ "LinesWritten: "+ SnapShot.getLinesWritten()+ ";"+ "OutputBufferSize: "+ SnapShot.getOutputBufferSize()+ ";"+ "StepCopy: " + SnapShot.getStepCopy()+ ";"+ "TimeDifference: "+ SnapShot.getTimeDifference()+ ";"+ "TotalErrors: "+ SnapShot.getTotalErrors()+ ";"+ "TotalLinesInput: "+ SnapShot.getTotalLinesInput()+ ";"+ "TotalLinesOutput: "+ SnapShot.getTotalLinesOutput()+ ";"+ "TotalLinesRead: "+ SnapShot.getTotalLinesRead()+ ";"+ "TotalLinesRejected: "+ SnapShot.getTotalLinesRejected()+ ";"+ "TotalLinesUpdated: "+ SnapShot.getTotalLinesUpdated()+ ";"+ "TotalLinesWritten: "+ SnapShot.getTotalLinesWritten()+ ";"+ "Date:"+ SnapShot.getDate() + "\n");ontTimeAllStepInfo+=oneTimeOneStepInfo;}System.out.println(ontTimeAllStepInfo+"\n\n\n\n");}}}System.out.println("end............");} catch (KettleException e) {// TODO Put your exception-handling code here.System.out.println(e);}}}。
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代码路径填入即可,然后点击确认。
使用idea 编译kettle
使用idea 编译kettle使用IntelliJ IDEA编译Kettle需要按照以下步骤进行操作:1. 下载和安装Java Development Kit (JDK),首先,确保你的计算机上已经安装了JDK。
你可以从Oracle官方网站下载适合你操作系统的JDK版本,并按照安装向导进行安装。
2. 下载和安装IntelliJ IDEA,接下来,从JetBrains官方网站下载IntelliJ IDEA的最新版本,并按照安装向导进行安装。
3. 导入Kettle项目,打开IntelliJ IDEA,选择“Open”或者“Import Project”,然后导航到Kettle项目的根目录,并选择它。
IDEA会自动检测项目的类型并进行导入。
4. 配置项目依赖,在IntelliJ IDEA的项目结构中,找到项目的依赖项配置。
你需要添加Kettle的相关依赖,包括Kettle核心库、数据库驱动程序等。
你可以通过手动添加JAR文件或者使用Maven等构建工具来管理依赖。
5. 配置编译选项,在IntelliJ IDEA的项目设置中,找到编译选项。
确保你选择了正确的Java SDK版本,并设置输出目录和其他编译选项。
6. 构建项目,点击IntelliJ IDEA工具栏上的“Build”或者“Rebuild Project”按钮,开始构建Kettle项目。
IDEA将编译项目源代码,并生成可执行的二进制文件。
7. 运行Kettle,在构建成功后,你可以在IntelliJ IDEA中运行Kettle。
你需要配置Kettle的运行参数,例如输入文件路径、输出文件路径等。
确保你已经正确配置了数据库连接等必要的参数。
8. 调试Kettle,如果需要调试Kettle代码,你可以在IntelliJ IDEA中设置断点,并使用调试工具进行代码调试。
这将帮助你找到和修复潜在的问题。
通过以上步骤,你可以使用IntelliJ IDEA编译和运行Kettle项目。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
Java代码调用kettle任务
工具kettle4.2版本
下载地址/s/1gmn5R
所需的包(这几个包是必须要的,它们相互调用,不引用就报错。
)
kettle-core.jar ,
kettle-engine.jar,
kettle-db.jar,
commons-vfs.jar,
commons-logging.jar,
log4j.jar
这些包都可以去kettle 目录下面去找(lib,libext,libswt这几个目录里面有各种包。
)测试用例excel数据导入到txt文本文档(需要添加jxl.jar)1.先在kettle中创建test.ktr 保存在E:/Workspaces/Kettle中
创建完成并且测试kettle任务是否成功。
2.创建java程序
package com.start;
import org.pentaho.di.core.KettleEnvironment;
import org.pentaho.di.core.exception.KettleException; import
org.pentaho.di.repository.filerep.KettleFileRepository; import
org.pentaho.di.repository.filerep.KettleFileRepositoryMeta; import org.pentaho.di.trans.Trans;
import org.pentaho.di.trans.TransMeta;
public class Main {
private static String tranName = "test"; // 文件名称
public static void main(String[] args) {
System.out.println("启动中....................");
Trans trans=null;
try {
// 初始化
KettleEnvironment.init(false);
// 资源库元对象
KettleFileRepositoryMeta repinfo = new KettleFileRepositoryMeta("","","数据采集
","file:///E:/Workspaces/Kettle");
// 文件形式的资源库
KettleFileRepository rep = new
KettleFileRepository();
rep.init(repinfo);
// 转换元对象
if(tranName!=null){
TransMeta transMetadel =
rep.loadTransformation(rep.getTransformationID(tranName, null), null);
// 转换
trans = new Trans(transMetadel);
// 执行转换
trans.execute(null);
// 等待转换执行结束
trans.waitUntilFinished();
//抛出异常
if(trans.getErrors()>0){
throw new Exception("传输过程中发生异常"); }
}else{
throw new KettleException("传输名为空!");
}
} catch (Exception e) {
if(trans!=null){
trans.stopAll();
}
e.printStackTrace();
}
}
}
测试调用kettle资源库中的Job任务(需要数据库的jar包)我用的是ORACLE数据库所以需用到ojdbc.jar
1.先在kettle中创建资源库等任务。
创建好了并测试是否正确。
2.java 代码
package com.start;
import org.pentaho.di.core.KettleEnvironment;
import org.pentaho.di.core.database.DatabaseMeta;
import org.pentaho.di.core.exception.KettleException;
import org.pentaho.di.job.Job;
import org.pentaho.di.job.JobMeta;
import org.pentaho.di.repository.RepositoryDirectoryInterface; import org.pentaho.di.repository.kdr.KettleDatabaseRepository; import
org.pentaho.di.repository.kdr.KettleDatabaseRepositoryMeta; public class StartJob {
private static String jobname="test_job";
public static void main(String[] args) {
try {
// 初始化
KettleEnvironment.init(false);
//资源库地址(名称,数据类型,数据库连接方式,连接地址,数据库名称,端口,用户名,密码)
DatabaseMeta dataMeta = new
DatabaseMeta("kettle","ORACLE","Native","127.0.0.1","XE","1521 ","kettle","...");
//资源库元对象
KettleDatabaseRepositoryMeta repInfo = new KettleDatabaseRepositoryMeta();
repInfo.setConnection(dataMeta);
//资源库对象
KettleDatabaseRepository rep = new KettleDatabaseRepository();
//给资源库赋值
rep.init(repInfo);
//连接资源库用户、密码
rep.connect("admin", "password");
//根据变量查找到模型所在的目录对象
RepositoryDirectoryInterface directory =
rep.findDirectory("/");
//创建Job元对象
JobMeta jobMeta = rep.loadJob(jobname, directory, null, null);
//创建Job对象
Job job = new Job(rep, jobMeta);
//执行
job.start();
System.out.println("start.............");
//等待执行完毕自动停止任务,重复执行JOB 则不会停止
//job.waitUntilFinished();
//等待执行10000毫秒,需停止否则不会自动停止任务
job.waitUntilFinished(10000);
System.out.println("end.................");
job.stopAll();
if (job.getErrors() > 0) {
System.out.println("执行job失败!");
}
} catch (KettleException e) {
e.printStackTrace();
}
}
}。