java代码整合kettle9.3实现读取表中的数据，生成excel文件

于 2023-02-13 15:28:41 发布
阅读量1.1k 收藏 5
点赞数 1
分类专栏： java方面 文章标签： java excel kettle
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zh123456_789/article/details/129005619
版权

java代码整合kettle9.3实现读取表中的数据，生成excel文件

1.简介
本次使用java代码整合kettle9.3版本，数据库使用mysql。

2.jar包导入
项目需要依赖部分kettle中的jar包，请将这部分jar包自行导入maven仓库。

		<dependency>
            <groupId>com.kettle</groupId>
            <artifactId>kettle-engine</artifactId>
            <version>9.3</version>
        </dependency>

        <dependency>
            <groupId>com.kettle</groupId>
            <artifactId>metastore</artifactId>
            <version>9.3</version>
        </dependency>

        <dependency>
            <groupId>com.kettle</groupId>
            <artifactId>kettle-core</artifactId>
            <version>9.3</version>
        </dependency>

        <dependency>
            <groupId>com.kettle</groupId>
            <artifactId>pentaho-encryption-support</artifactId>
            <version>9.3</version>
        </dependency>

        <dependency>
            <groupId>com.kettle</groupId>
            <artifactId>monetdb-jdbc</artifactId>
            <version>2.8</version>
        </dependency>

        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-vfs2</artifactId>
            <version>2.6.0</version>
        </dependency>

        <dependency>
            <groupId>com.kettle</groupId>
            <artifactId>jxl</artifactId>
            <version>2.6</version>
        </dependency>

        <dependency>
            <groupId>com.kettle</groupId>
            <artifactId>commons-dbcp</artifactId>
            <version>1.4</version>
        </dependency>

        <dependency>
            <groupId>com.kettle</groupId>
            <artifactId>commons-pool</artifactId>
            <version>1.5</version>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.47</version>
            <scope>runtime</scope>
        </dependency>

可以通过maven命令的形式导入：
mvn install:install-file -Dfile=jar包地址 -DgroupId=jar包分组id -DartifactId=jar包名称id -Dversion=jar包版本 -Dpackaging=jar
如：
mvn install:install-file -Dfile=D:\worktool\kettle\pdi-ce-7.1.0.0-12\data-integration\lib\kettle-core-9.3.0.0-12.jar -DgroupId=com.kettle -DartifactId=kettle-core -Dversion=9.3 -Dpackaging=jar

3.项目所需xml配置
项目整合kettle启动时会爆需要kettle-password-encoder-plugins.xml文件。
kettle-password-encoder-plugins.xml

<password-encoder-plugins>
    <password-encoder-plugin id="Kettle">
        <description>Kettle Password Encoder</description>
        <classname>org.pentaho.di.core.encryption.KettleTwoWayPasswordEncoder</classname>
    </password-encoder-plugin>
</password-encoder-plugins>

mysql的xml配置文件
用的时候需要改成自己的数据库配置，name要和代码中的kettle数据库保持一致。

<?xml version="1.0" encoding="UTF-8"?>
<connection>
    <!--数据库名称-->
    <name>kettle</name>
    <!--连接地址-->
    <server>127.0.0.1</server>
    <!--数据库类型-->
    <type>Mysql</type>
    <access>Native</access>
    <!--连接的库的名称-->
    <database>aweb</database>
    <!--端口-->
    <port>3306</port>
    <!--账号-->
    <username>root</username>
    <!--密码-->
    <password>root</password>
    <attributes>
        <attribute>
            <code>USE_POOLING</code>
            <attribute>Y</attribute>
        </attribute>
        <attribute>
            <code>EXTRA_OPTION_MYSQL.characterEncoding</code>
            <attribute>utf8</attribute>
        </attribute>
        <attribute>
            <code>EXTRA_OPTION_MYSQL.defaultFetchSize</code>
            <attribute>500</attribute>
        </attribute>
        <attribute>
            <code>EXTRA_OPTION_MYSQL.serverTimeZone</code>
            <attribute>UTC</attribute>
        </attribute>
        <attribute>
            <code>serverTimeZone</code>
            <attribute>UTC</attribute>
        </attribute>
        <attribute>
            <code>serverTimezone</code>
            <attribute>UTC</attribute>
        </attribute>
    </attributes>
</connection>

4.java代码

package com.kettle.utils;

import org.pentaho.di.core.KettleEnvironment;
import org.pentaho.di.core.exception.KettleException;
import org.pentaho.di.core.plugins.PluginRegistry;

import javax.servlet.http.HttpServletRequest;

/**
 * kettle配置
 */
public class KettleConfig {

    /**
     * 运行环境初始化
     *
     * @param request HttpServletRequest
     * @throws KettleException 异常
     */
    public static void initKettleEnvironment(HttpServletRequest request) throws KettleException {
        if (KettleEnvironment.isInitialized()) {
            return;
        }
        if (request == null) {
            KettleEnvironment.init();
        }
    }

    /**
     * 插件注册，用于注册转换中需要用到的插件
     *
     * @return PluginRegistry
     */
    public static PluginRegistry getRegistry() {
        return PluginRegistry.getInstance();
    }

}


package com.kettle.utils;

import org.pentaho.di.core.database.Database;
import org.pentaho.di.core.database.DatabaseMeta;
import org.pentaho.di.core.exception.KettleException;
import org.pentaho.di.core.exception.KettleXMLException;
import org.pentaho.di.trans.Trans;
import org.pentaho.di.trans.TransHopMeta;
import org.pentaho.di.trans.TransMeta;
import org.pentaho.di.trans.step.StepMeta;

/**
 * kettle转换操作
 */
public class KettleTransformation {

    /**
     * 构建TransMeta转换
     *
     * @param metaName 名称
     * @param transXML 数据库配置xml
     * @return TransMeta
     * @throws KettleXMLException 异常
     */
    public static TransMeta buildTransMeta(String metaName, String... transXML) throws KettleXMLException {
        TransMeta transMeta = new TransMeta();
        // 设置转化元的名称
        transMeta.setName(metaName);
        // 添加转换的数据库连接
        for (int i = 0; i < transXML.length; i++) {
            transMeta.addDatabase(new DatabaseMeta(transXML[i]));
        }
        return transMeta;
    }

    /**
     * 用于将表输入步骤与第二步骤绑定
     *
     * @param transMeta TransMeta
     * @param from      第一个步骤
     * @param to        第二个步骤
     */
    public static void addTransHop(TransMeta transMeta, StepMeta from, StepMeta to) {
        transMeta.addTransHop(new TransHopMeta(from, to));
    }

    /**
     * 执行抽取
     *
     * @param transMeta    TransMeta
     * @param targetDbName 数据库名
     */
    public static void executeTrans(TransMeta transMeta, String targetDbName) {
        try {
            Database database = new Database(null, transMeta.findDatabase(targetDbName));
            database.connect();
            Trans trans = new Trans(transMeta);
            trans.execute(new String[]{"com.kettle.start..."});
            trans.waitUntilFinished();
            // 关闭数据库连接
            database.disconnect();
            if (trans.getErrors() > 0) {
                System.out.println(trans.getErrors());
            }
        } catch (KettleException e) {
            e.printStackTrace();
        }
    }

}


package com.kettle.utils;

import org.pentaho.di.core.database.DatabaseMeta;
import org.pentaho.di.core.plugins.PluginRegistry;
import org.pentaho.di.core.plugins.StepPluginType;
import org.pentaho.di.trans.TransMeta;
import org.pentaho.di.trans.step.StepMeta;
import org.pentaho.di.trans.steps.exceloutput.ExcelField;
import org.pentaho.di.trans.steps.exceloutput.ExcelOutputMeta;
import org.pentaho.di.trans.steps.tableinput.TableInputMeta;

/**
 * kettle步骤
 */
public class KettleStep {

    /**
     * 设置表输入步骤
     *
     * @param transMeta    TransMeta
     * @param registry     PluginRegistry
     * @param sourceDbName 数据库名
     * @param sql          sql
     * @param stepName     步骤名
     * @return StepMeta
     */
    public static StepMeta setTableInputStep(TransMeta transMeta, PluginRegistry registry, String sourceDbName, String sql,
                                      String stepName) {
        // 创建表输入
        TableInputMeta tableInputMeta = new TableInputMeta();
        String pluginId = registry.getPluginId(StepPluginType.class, tableInputMeta);
        // 指定数据源数据库配置名
        DatabaseMeta source = transMeta.findDatabase(sourceDbName);
        tableInputMeta.setDatabaseMeta(source);
        tableInputMeta.setSQL(sql);
        // 将表输入添加到转换中
        StepMeta stepMeta = new StepMeta(pluginId, stepName, tableInputMeta);
        // 将表输入添加到步骤中
        transMeta.addStep(stepMeta);
        return stepMeta;
    }

    /**
     * 设置Excel输出步骤
     *
     * @param transMeta TransMeta
     * @param registry  PluginRegistry
     * @param stepName  步骤名
     * @param fileName  文件名
     * @return StepMeta
     */
    public static StepMeta setExcelOutput(TransMeta transMeta, PluginRegistry registry, String stepName, String fileName) {
        // 创建表输出
        ExcelOutputMeta excelOutputMeta = new ExcelOutputMeta();
        String pluginId = registry.getPluginId(StepPluginType.class, excelOutputMeta);
        excelOutputMeta.setHeaderEnabled(true);
        excelOutputMeta.setFooterEnabled(false);
        excelOutputMeta.setAppend(false);
        excelOutputMeta.setFileName(fileName);
        excelOutputMeta.setDoNotOpenNewFileInit(false);
        excelOutputMeta.setCreateParentFolder(false);
        excelOutputMeta.setOutputFields(new ExcelField[]{});
        // 将表输出添加到转换中
        StepMeta stepMeta = new StepMeta(pluginId, stepName, excelOutputMeta);
        // 添加到步骤中
        transMeta.addStep(stepMeta);
        return stepMeta;
    }

}


package com.kettle.utils;

import com.kettle.common.enums.Kettle;
import org.pentaho.di.core.exception.KettleException;
import org.pentaho.di.core.plugins.PluginRegistry;
import org.pentaho.di.trans.TransMeta;
import org.pentaho.di.trans.step.StepMeta;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
import org.w3c.dom.Document;
import org.xml.sax.SAXException;

import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerException;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.IOException;

@Component
public class KettleClient {

    private String databaseName = "kettle";

    /**
     * 读取文件内容
     *
     * @param path 文件地址
     * @return 文件中的内容
     */
    public String getDatabase(String path) {
        try {
            Document document = DocumentBuilderFactory.newInstance().newDocumentBuilder().parse(new File(path));
            Transformer t = TransformerFactory.newInstance().newTransformer();
            ByteArrayOutputStream bos = new ByteArrayOutputStream();
            t.transform(new DOMSource(document), new StreamResult(bos));
            return bos.toString();
        } catch (SAXException | IOException | TransformerException | ParserConfigurationException e) {
            e.printStackTrace();
        }
        return "";
    }

    public void getExcel(String sql) {
        try {
            KettleConfig.initKettleEnvironment(null);
            String fileName = "D:/workProject/kettle/src/main/resources/excel/text.xls";
            String transXML = getDatabase("src/main/resources/jdbc/mysql.xml");
            TransMeta meta = KettleTransformation.buildTransMeta(databaseName, transXML);
            PluginRegistry registry = KettleConfig.getRegistry();
            StepMeta step1 = KettleStep.setTableInputStep(meta, registry, databaseName, sql, "table input");
            StepMeta step2 = KettleStep.setExcelOutput(meta, registry, "excel out", fileName);
            KettleTransformation.addTransHop(meta, step1, step2);
            KettleTransformation.executeTrans(meta, databaseName);
        } catch (KettleException e) {
            e.printStackTrace();
        }
    }

}

注意kettle数据库的名称要和xml中配置的一样。

整理借鉴了很多大佬写的，在此无法一一说明，这只是个人用来查漏补缺的文章，如果对你有帮助我很高兴。

越知越无知
关注
  • 1
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
kettle中集成Excel&Sql;&JS;所需jar
02-26
kettle中集成Excel&Sql;&JS;所需jar，导入项目中，初始化便可以使用！
java集成kettle教程（附示例代码）
热门推荐
pingweicheng的博客
12-15 1万+
java集成kettle后，可通过java程序调用kettle转换文件、kettle任务，对数据进行抽取转换清洗。 整合步骤如下： 第一步声明必须的依赖 pom.xml文件如下： <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:...
Kettle的使用（二）：将Excel（Windows）中的数据导入MySQL（Linux）
何止是执迷不悟
12-21 586
预备工作： 建立数据库：CREATE DATABASE kettle_demo; 将驱动包：mysql-connector-java-5.1.47.jar，mysql-connector-java-8.0.13.jar导入到 data-integration\lib 中 具体步骤： 1.建立转换 2.配置文件 （1）配置输入文件 1）文件 2）工作表 ...
ETL学习心得：探求数据仓库关键环节ETL的本质
石头记
01-13 2433
原文链接：http://hi.baidu.com/horsewhite/blog/item/b167f81f6924ef0a304e15a0.html 做数据仓库系统，ETL是关键的一环。说大了，ETL是数据整合解决方案，说小了，就是倒数据的工具。回忆一下工作这么些年来，处理数据迁移、转换的工作倒还真的不少。但是那些工作基本上是一次性工作或者很小数据量，使用access、DTS或是自己编个小程序搞
Kettle操作数据库导出多Excel多Sheet
大耳根图图的博客
12-02 191
点击蓝色字关注我们！一个努力中的公众号长的好看的人都关注了前言Kettle简介Kettle是一款国外开源的ETL工具，纯java编写，可以在Window、Linux、Unix上运行， 数据抽取高效稳定。Kettle 中文名称叫水壶，该项目的主程序员MATT 希望把各种数据放到一个壶里，然后以一种指定的格式流出。Kettle这个ETL工具集，它允许你管理来自不同数据库的数据，通过提供一个图形化的用户...
kettle集成java+完整jar包
12-19
kettle集成java做数据清洗，执行脚本，外加完整jar下载，一键启动，无需添加任何代码，可以和自己的业务代码结合，亲测可用高效
kettle demo9 调用JAVA代码
weixin_34252686的博客
03-26 1313
2019独角兽企业重金招聘Python工程师标准>>> ...
java web集成kettle_如何将kettle 集成到java应用
weixin_39665302的博客
02-16 178
展开全部|在Java应用程序中调用Kettle的Transformationpackage com.ggd543.kettle.transimport org.pentaho.di.core.util.EnvUtilimport org.pentaho.di.core.KettleEnvironmentimport org.pentaho.di.trans.{Trans, TransMeta}/*...
Kettle实践之嵌入JAVA项目环境
cqstart116的专栏
06-18 947
Kettle之嵌入JAVA项目环境实践，该实践采用插件+pom的方式集成。
Java调用Kettle工具方法
不如一默
03-24 2520
Java调用Kettle工具方法 /** * Java调用Kettle工具类 * * @classname KettleUtil * @date 2020/3/24 16:24 */ public final class KettleUtil { private static final Logger log = LoggerFactory.getLogger(KettleUt...
java调用kettle示例
01-04
java调用kettle使用示例，包含数据库到数据库，csv到数据库及数据库到excel数据同步调用代码。
《kettle中调用java类》示例代码
10-12
《kettle中调用java类》示例代码；http://blog.csdn.net/neweastsun/article/details/40022823
java整合kettle所需jar包
12-15
此资源是java整合kettle项目所需要的依赖jar包，由于本项目用了springboot技术，故还包括了springboot相关的jar包
web应用集成kettle
12-05
将kettle集成值web应用中，不再需打开kettle窗口运行，并通过spring自动任务进行数据抽取，数据库采用数据源（jndi）的方式进行管理。配置简单方便。（之前需要kettle打开其运行环境，并配置数据库连接的相关信息）
kettle9.0 第一卷
08-04
ETL工具kettle, 使用 Pentaho Kettle 9.0.0.0 源码编译后的可运行版本，2018年7月刚出的新版本
springboot代码整合kettle实现数据增量同步：1、kettle同步文件编写说明；2、java整合代码
06-12
实现数据库的增量同步，需要编写好kettle转换文件以配置文件的形式，整合到springboot，有改动只需要更换转换文件，不需要更新jar包，job用于灵活调整定时同步，再结合jenkins自动部署，十分方便。
Kettle转换中的Java代码步骤应用入门与实战
02-24
Java代码步骤，位于Kettle转换的核心对象/脚本类别中，属于典型的需要编程基础才能掌控的步骤类型。而Java代码步骤，适用于熟悉Java语言的开发人员，用好这个步骤，需要对类、接口、多线程等语言相关知识有所掌握，...
生成kettle作业的Java代码.rar
12-06
生成kettle作业的Java代码
ETL工具-kettle9.3环境部署+数据迁移实操
最新发布
02-27
ETL工具-kettle9.3环境部署+数据迁移实操
编写java整合kettle9.3实现读取表中的数据，生成excel文件的代码
02-21
可以参考如下代码： import java.io.File; import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.InputStream; import java.io.OutputStream; import org.pentaho.di.core....

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值