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.执⾏资源库的中的转换。
- 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();
}
}
}。