手把手教你使用Kettle JAVA API进行数据抽取

Kettle作为一款优秀的数据抽取程序,因为高效稳定的性能,一直被广大使用者所喜爱,并且还在国内广受好评。因为其本身使用纯JAVA编写,所以其JAVA API使用起来自然也是非常简便。虽然其本身自带的组件已经非常好用,并且能够满足丰富的场景。但可能有些场景下,我们可能需要通过其他的方式来实现,本篇我们将介绍Kettle的JAVA API的使用。

一、环境搭建

Pentaho官方仓库:https://nexus.pentaho.org/content/groups/omni

核心jar包的pom.xml配置如下:


  
  
  1. <dependency>
  2. <groupId>pentaho-kettle </groupId>
  3. <artifactId>kettle-engine </artifactId>
  4. <version>4.4.0-stable </version>
  5. </dependency>
  6. <dependency>
  7. <groupId>pentaho-kettle </groupId>
  8. <artifactId>kettle-core </artifactId>
  9. <version>4.4.0-stable </version>
  10. </dependency>
  11. <dependency>
  12. <groupId>pentaho-kettle </groupId>
  13. <artifactId>kettle-db </artifactId>
  14. <version>4.4.0-stable </version>
  15. </dependency>

 

二、代码部分

1、初始化环境


 
 
  1. public void initKettleEnvironment(HttpServletRequest request) throws KettleException {
  2. if (KettleEnvironment.isInitialized()) {
  3. return;
  4. }
  5. /**
  6. * 为避免在部分网络环境中无法完成初始化,需要自行处理
  7. */
  8. if (request == null) {
  9. // 运行环境初始化
  10. KettleEnvironment.init();
  11. } else {
  12. String userDir = System.getProperty( "user.dir");
  13. String kettleHome = request.getSession().getServletContext().getRealPath(File.separator "WEB-INF");
  14. // 设置用户路径和系统环境,包括用户路径和主目录
  15. System.setProperty( "user.dir", kettleHome);
  16. System.setProperty( "KETTLE_HOME", kettleHome);
  17. // 运行环境初始化
  18. KettleEnvironment.init();
  19. // 避免造成影响其他程序的运行,还原用户路径
  20. System.setProperty( "user.dir", userDir);
  21. }
  22. }

2、创建转化元

添加配置数组,配置转化元


 
 
  1. public TransMeta buildTransMeta(String metaName, String... transXML) throws KettleXMLException {
  2. TransMeta transMeta = new TransMeta();
  3. // 设置转化元的名称
  4. transMeta.setName(metaName);
  5. // 添加转换的数据库连接
  6. for ( int i = 0; i < transXML.length; i ) {
  7. transMeta.addDatabase( new DatabaseMeta(transXML[i]));
  8. }
  9. return transMeta;
  10. }

3、添加日志(可选操作)


 
 
  1. public void setStepLogTable(TransMeta transMeta, String connDbName, String tableName) {
  2. VariableSpace space = new Variables();
  3. // 将step日志数据库配置名加入到变量集中
  4. space.setVariable(Const.KETTLE_TRANS_LOG_DB, connDbName);
  5. space.initializeVariablesFrom( null);
  6. StepLogTable stepLogTable = StepLogTable.getDefault(space, transMeta);
  7. // 配置StepLogTable使用的数据库配置名称
  8. stepLogTable.setConnectionName(connDbName);
  9. // 设置Step日志的表名
  10. stepLogTable.setTableName(tableName);
  11. // 设置TransMeta的StepLogTable
  12. transMeta.setStepLogTable(stepLogTable);
  13. }

4、创建插件注册器


 
 
  1. public PluginRegistry getRegistry() {
  2. // 插件注册,用于注册转换中需要用到的插件
  3. return PluginRegistry.getInstance();
  4. }

5、设置表输入步骤元

该步骤用于获取源数据


 
 
  1. /**
  2. * 设置表输入步骤
  3. * @param transMeta
  4. * @param registry
  5. * @param sourceDbName
  6. * @param sql
  7. * @param stepName
  8. * @return
  9. */
  10. public StepMeta setTableInputStep(TransMeta transMeta, PluginRegistry registry, String sourceDbName, String sql,
  11. String stepName) {
  12. // 创建表输入
  13. TableInputMeta tableInputMeta = new TableInputMeta();
  14. String pluginId = registry.getPluginId(StepPluginType.class, tableInputMeta);
  15. // 指定数据源数据库配置名
  16. DatabaseMeta source = transMeta.findDatabase(sourceDbName);
  17. tableInputMeta.setDatabaseMeta(source);
  18. tableInputMeta.setSQL(sql);
  19. // 将表输入添加到转换中
  20. StepMeta stepMeta = new StepMeta(pluginId, stepName, tableInputMeta);
  21. // 给步骤添加在spoon工具中的显示位置
  22. stepMeta.setDraw( true);
  23. stepMeta.setLocation( 100, 100);
  24. // 将表输入添加到步骤中
  25. transMeta.addStep(stepMeta);
  26. return stepMeta;
  27. }

6、更新步骤元

该步骤用于将获取到的数据更新到目标数据库中


 
 
  1. /**
  2. * 设置表输出步骤,用于整表抽取
  3. * @param transMeta
  4. * @param registry
  5. * @param targetDbName
  6. * @param targetTableName
  7. * @param stepName
  8. * @return
  9. */
  10. public StepMeta setTableOutput(TransMeta transMeta, PluginRegistry registry, String targetDbName,
  11. String targetTableName, String stepName) {
  12. // 创建表输出
  13. TableOutputMeta tableOutputMeta = new TableOutputMeta();
  14. String pluginId = registry.getPluginId(StepPluginType.class, tableOutputMeta);
  15. // 配置表输出的目标数据库配置名
  16. DatabaseMeta targetDb = transMeta.findDatabase(targetDbName);
  17. tableOutputMeta.setDatabaseMeta(targetDb);
  18. tableOutputMeta.setTableName(targetTableName);
  19. // 将表输出添加到转换中
  20. StepMeta stepMeta = new StepMeta(pluginId, stepName, tableOutputMeta);
  21. transMeta.addStep(stepMeta);
  22. return stepMeta;
  23. }
  24. /**
  25. * 设置表插入与更新步骤,用于表中部分字段更新
  26. * @param transMeta
  27. * @param registry
  28. * @param targetDbName
  29. * @param targetTableName
  30. * @param updatelookup lookup检索字段
  31. * @param updateStream lookup更新字段
  32. * @param updateStream2 lookup更新字段2
  33. * @param conditions lookup条件
  34. * @param updateOrNot lookup更新标记
  35. * @param stepName
  36. * @return
  37. */
  38. public StepMeta setInsertUpdateMeta(TransMeta transMeta, PluginRegistry registry, String targetDbName,
  39. String targetTableName, String[] updatelookup, String[] updateStream, String[] updateStream2,
  40. String[] conditions, Boolean[] updateOrNot, String stepName) {
  41. // 创建插入与更新
  42. InsertUpdateMeta insertUpdateMeta = new InsertUpdateMeta();
  43. String pluginId = registry.getPluginId(StepPluginType.class, insertUpdateMeta);
  44. // 配置目标数据库配置名
  45. DatabaseMeta database_target = transMeta.findDatabase(targetDbName);
  46. insertUpdateMeta.setDatabaseMeta(database_target);
  47. // 设置目标表名
  48. insertUpdateMeta.setTableName(targetTableName);
  49. // 设置用来查询的关键字
  50. insertUpdateMeta.setKeyLookup(updatelookup);
  51. insertUpdateMeta.setKeyStream(updateStream);
  52. insertUpdateMeta.setKeyStream2(updateStream2); // 这一步不能省略
  53. insertUpdateMeta.setKeyCondition(conditions);
  54. // 设置要更新的字段
  55. insertUpdateMeta.setUpdateLookup(updatelookup);
  56. insertUpdateMeta.setUpdateStream(updateStream);
  57. insertUpdateMeta.setUpdate(updateOrNot);
  58. // 添加步骤到转换中
  59. StepMeta stepMeta = new StepMeta(pluginId, stepName, insertUpdateMeta);
  60. stepMeta.setDraw( true);
  61. stepMeta.setLocation( 250, 100);
  62. transMeta.addStep(stepMeta);
  63. return stepMeta;
  64. }

7、绑定关联步骤

该步骤用于将数据获取和导入更新的步骤关联绑定


 
 
  1. /**
  2. * 用于将表输入步骤与第二步骤绑定
  3. * @param transMeta
  4. * @param from
  5. * @param to
  6. */
  7. public void addTransHop(TransMeta transMeta, StepMeta from, StepMeta to) {
  8. transMeta.addTransHop( new TransHopMeta(from, to));
  9. }

8、执行抽取

执行数据抽取


 
 
  1. /**
  2. * 执行抽取
  3. * @param transMeta
  4. * @param targetDbName
  5. */
  6. public void executeTrans(TransMeta transMeta, String targetDbName) {
  7. try {
  8. Database database = new Database( null, transMeta.findDatabase(targetDbName));
  9. database.connect();
  10. Trans trans = new Trans(transMeta);
  11. trans.execute( new String[] { "start..." });
  12. trans.waitUntilFinished();
  13. // 关闭数据库连接
  14. database.disconnect();
  15. if (trans.getErrors() > 0) {
  16. throw new RuntimeException( "There were errors during transformation execution.");
  17. }
  18. } catch (KettleDatabaseException e) {
  19. e.printStackTrace();
  20. } catch (KettleException e) {
  21. e.printStackTrace();
  22. }
  23. }

9、抽取示例

数据库配置xml:


 
 
  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <connection>
  3.      <name>smy </name>
  4.      <server>127.0.0.1 </server>
  5.      <type>Mysql </type>
  6.      <access>Native </access>
  7.      <database>test_db </database>
  8.      <port>3306 </port>
  9.      <username>root </username>
  10.      <password>123456 </password>
  11.      <attributes>
  12.          <attribute>
  13.              <code>USE_POOLING </code>
  14.              <attribute>Y </attribute>
  15.          </attribute>
  16.          <attribute>
  17.              <code>EXTRA_OPTION_MYSQL.characterEncoding </code>
  18.              <attribute>utf8 </attribute>
  19.          </attribute>
  20.          <attribute>
  21.              <code>EXTRA_OPTION_MYSQL.defaultFetchSize </code>
  22.              <attribute>500 </attribute>
  23.          </attribute>
  24.      </attributes>
  25. </connection> 

运行函数:


 
 
  1. public static void main(String[] args) {
  2. try {
  3. KettleClient client = new KettleClient();
  4. client.initEnvironment( null);
  5. String transXML = ""; // 此处为上例的数据库配置
  6. TransMeta meta = client.buildTransMeta( "kettle", transXML);
  7. PluginRegistry registry = client.getRegistry();
  8. StepMeta step1 = client.setTableInputStep(meta, registry, "kettle", "select * from test1", "table input");
  9. StepMeta step2 = client.setTableOutput(meta, registry, "kettle", "test2", "table insert");
  10. client.addTransHop(meta, step1, step2);
  11. client.executeTrans(meta, "kettle");
  12. } catch (KettleException e) {
  13. e.printStackTrace();
  14. }
  15. }

 

  • 0
    点赞
  • 3
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
使用Java语言通过API实现Kettle数据的预览,您可以借助KettleAPI和相关类库来实现。下面是一个示例代码,展示了如何使用KettleAPI来实现数据的预览: ```java import org.pentaho.di.core.KettleEnvironment; import org.pentaho.di.core.database.DatabaseMeta; import org.pentaho.di.core.exception.KettleDatabaseException; import org.pentaho.di.core.row.RowMetaInterface; import org.pentaho.di.trans.Trans; import org.pentaho.di.trans.TransMeta; import org.pentaho.di.trans.step.StepMetaDataCombi; import org.pentaho.di.trans.steps.tableinput.TableInput; public class KettlePreviewExample { public static void main(String[] args) { try { // 初始化Kettle环境 KettleEnvironment.init(); // 创建转换元数据对象 TransMeta transMeta = new TransMeta("your_transformation_file.ktr"); // 创建数据库连接元数据对象 DatabaseMeta databaseMeta = new DatabaseMeta("your_connection_name", "mysql", "native", "localhost", "your_database", "your_username", "your_password"); // 添加数据库连接元数据到转换元数据对象 transMeta.addDatabase(databaseMeta); // 获取表输入步骤的元数据对象 TableInput tableInput = (TableInput) transMeta.findStep("Table Input"); // 设置表输入步骤的连接信息 tableInput.setDatabaseMeta(databaseMeta); // 创建转换对象 Trans trans = new Trans(transMeta); // 初始化转换 trans.prepareExecution(null); // 获取表输入步骤的输出字段结构 RowMetaInterface outputRowMeta = trans.getStepFields(tableInput); // 输出字段结构 String[] fieldNames = outputRowMeta.getFieldNames(); for (String fieldName : fieldNames) { System.out.println(fieldName); } // 执行转换中的步骤,获取预览数据 StepMetaDataCombi stepMetaDataCombi = trans.findStep(tableInput.getName()); while (stepMetaDataCombi.processRow()) { Object[] rowData = stepMetaDataCombi.getRow(); // 处理预览数据 // ... } // 结束转换 trans.cleanup(); } catch (KettleDatabaseException e) { e.printStackTrace(); } catch (Exception e) { e.printStackTrace(); } } } ``` 请注意,上述示例代码假设您已经有一个已定义好的Kettle转换文件(.ktr文件),其中包含了表输入步骤(Table Input)以及相关的连接和查询信息。您需要根据自己的实际情况进行相应的修改。同时,您还需要在项目中引入Kettle的相关依赖库。希望这个示例对您有所帮助!
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值