通过kettle API接口创建转换和任务

公司需求，通过页面配置kettle相关任务，定时调度运行
以下为后端生成kettle转换和任务部分示例代码
导入依赖：maven上无kettle相关依赖，故本地直接导入，kettle安装目录\lib
下的包全部导入（后续发现导入部分即可，未做深究）

kettle 作业分为转换和任务，本例中将转换和任务都保存在kettle资源库中

import org.pentaho.di.core.KettleEnvironment;
import org.pentaho.di.core.ObjectLocationSpecificationMethod;
import org.pentaho.di.core.database.DatabaseMeta;
import org.pentaho.di.core.exception.KettleException;
import org.pentaho.di.core.logging.JobLogTable;
import org.pentaho.di.core.variables.VariableSpace;
import org.pentaho.di.core.variables.Variables;
import org.pentaho.di.job.JobHopMeta;
import org.pentaho.di.job.JobMeta;
import org.pentaho.di.job.entries.special.JobEntrySpecial;
import org.pentaho.di.job.entries.success.JobEntrySuccess;
import org.pentaho.di.job.entries.trans.JobEntryTrans;
import org.pentaho.di.job.entry.JobEntryCopy;
import org.pentaho.di.repository.RepositoryDirectoryInterface;
import org.pentaho.di.repository.kdr.KettleDatabaseRepository;
import org.pentaho.di.repository.kdr.KettleDatabaseRepositoryMeta;
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;

public class KettleTest3 {

    public static void main(String[] args) throws Exception {

        KettleTest3 kettleTest = new KettleTest3();
        KettleEnvironment.init();
        //连接到资源库
        KettleDatabaseRepository kettleDatabaseRepository = kettleTest.repositoryCon();
        //创建转换并把转换保存到资源库
        createAndSaveTrans(kettleDatabaseRepository);
        //创建转换并把转换保存到资源库
        JobMeta jobMeta = generateJob(kettleDatabaseRepository);

        VariableSpace space = new Variables();
        //将step日志数据库配置名加入到变量集中
        space.setVariable("kettle_log","log");
        space.initializeVariablesFrom(null);

        JobLogTable jobLogTable = JobLogTable.getDefault(space, jobMeta);
        jobLogTable.setConnectionName("fromDbName");
        jobLogTable.setTableName("log");
        jobMeta.setJobLogTable(jobLogTable);

        System.out.println(jobMeta.getXML());

        //保存作业到资源库
        saveJob(kettleDatabaseRepository, jobMeta);
    }

    /**
     * 连接到资源库
     */
    private KettleDatabaseRepository repositoryCon() throws KettleException {
        // 初始化环境
        if (!KettleEnvironment.isInitialized()) {
            try {
                KettleEnvironment.init();
            } catch (KettleException e) {
                e.printStackTrace();
            }
        }
        //数据库连接元对象
        DatabaseMeta dataMeta = new DatabaseMeta("kettle", "MySQL", "Native(JDBC)", "127.0.0.1", "kettle?serverTimezone=GMT%2B8&useUnicode=yes&characterEncoding=UTF-8&useSSL=false&serverTimezone=UTC", "3306", "root", "root");

        //数据库形式的资源库元对象
        KettleDatabaseRepositoryMeta repInfo = new KettleDatabaseRepositoryMeta();

        repInfo.setConnection(dataMeta);

        //数据库形式的资源库对象
        KettleDatabaseRepository rep = new KettleDatabaseRepository();
        //用资源库元对象初始化资源库对象
        rep.init(repInfo);
        //连接到资源库
        rep.connect("admin", "admin");//默认的连接资源库的用户名和密码
        if (rep.isConnected()) {
            System.out.println("连接成功");
            return rep;
        } else {
            System.out.println("连接失败");
            return null;
        }

    }

    /**
     * 生成作业
     *
     * @param kettleDatabaseRepository
     * @return
     * @throws Exception
     */
    private static JobMeta generateJob(KettleDatabaseRepository kettleDatabaseRepository) throws Exception {
        // 创建作业
        JobMeta jobMeta = createJob();
        // 创建作业中的各个节点
        JobEntryCopy start = createJobStart();
        JobEntryCopy trans1 = createJobTrans1(kettleDatabaseRepository);
        JobEntryCopy success = createJobSuccess();
        // 将节点加入作业中
        jobMeta.addJobEntry(start);
        jobMeta.addJobEntry(trans1);
        jobMeta.addJobEntry(success);
        // 创建并增加节点连接
        jobMeta.addJobHop(createJobHopMeta(start, trans1));
        jobMeta.addJobHop(createJobHopMeta(trans1, success));

        System.out.println("生成作业成功");
        return jobMeta;
    }

    /**
     *  创建作业 
     *  @return
     */
    private static JobMeta createJob() {
        JobMeta jobMeta = new JobMeta();
        jobMeta.setName("JobName");
        jobMeta.setJobstatus(0);
        return jobMeta;
    }

    /**
     *  创建作业开始节点
     *  @return
     */
    private static JobEntryCopy createJobStart() {
        JobEntrySpecial jobEntrySpecial = new JobEntrySpecial();
        jobEntrySpecial.setName("START");
        jobEntrySpecial.setStart(true);

//        jobEntrySpecial.setRepeat(true);
//        jobEntrySpecial.setSchedulerType(1);
//        jobEntrySpecial.setIntervalSeconds(0);
//        jobEntrySpecial.setIntervalMinutes(1);

        JobEntryCopy start = new JobEntryCopy(jobEntrySpecial);
        start.setDrawn();
        start.setLocation(10, 10);
        return start;
    }

    /**
     * 创建作业转换节点
     * @return
     * @throws Exception
     */
    private static JobEntryCopy createJobTrans1(KettleDatabaseRepository kettleDatabaseRepository) throws Exception {
        JobEntryTrans jobEntryTrans = new JobEntryTrans();
        // 指定从资源库中以转换名称的方式找到目标转换TransName对象
        jobEntryTrans
                .setSpecificationMethod(ObjectLocationSpecificationMethod.getSpecificationMethodByCode("rep_name"));
        // 指定从哪个资源库查找转换对象
        jobEntryTrans.setRepository(kettleDatabaseRepository);
        // 指定从资源库的哪个目录下查找转换对象
        jobEntryTrans.setDirectory("/");
        // 指定被查找的转换目标名称
        jobEntryTrans.setTransname("TransName");
        JobEntryCopy jobEntryCopy = new JobEntryCopy(jobEntryTrans);
        // 设置job中的转换名称
        jobEntryCopy.setName("JTrans");
        jobEntryCopy.setDrawn(true);
        // 这个一定要加，不然会报错空指针异常
        jobEntryCopy.setLocation(10, 20);
        return jobEntryCopy;
    }

    /**
     * 创建作业成功节点
     * @return
     */
    private static JobEntryCopy createJobSuccess() {
        JobEntrySuccess jobEntrySuccess = new JobEntrySuccess();
        jobEntrySuccess.setName("Success");
        JobEntryCopy success = new JobEntryCopy(jobEntrySuccess);
        success.setDrawn();
        success.setLocation(10, 30);
        return success;
    }

    /**
     * 创建节点连接
     * @param start
     * @param end
     * @return
     */
    private static JobHopMeta createJobHopMeta(JobEntryCopy start, JobEntryCopy end) {
        return new JobHopMeta(start, end);
    }

    /**
     * 保存作业到资源库
     *
     * @param kettleDatabaseRepository
     * @param jobMeta
     * @throws Exception
     */
    private static void saveJob(KettleDatabaseRepository kettleDatabaseRepository, JobMeta jobMeta) throws Exception {
        RepositoryDirectoryInterface dir = kettleDatabaseRepository.loadRepositoryDirectoryTree().findDirectory("/");
        jobMeta.setRepositoryDirectory(dir);
        kettleDatabaseRepository.save(jobMeta, null);
        System.out.println("保存作业成功");
    }

    /**
     * 创建转换并把转换保存到资源库
     *  @throws Exception
     */
    private static void createAndSaveTrans(KettleDatabaseRepository kettleDatabaseRepository) throws Exception {
        TransMeta transMeta = generateTrans();
        saveTrans(kettleDatabaseRepository, transMeta);
    }

    /**
     *  定义一个转换，但是还没有保存到资源库
     *  @return 
     *  @throws KettleException
     */
    private static TransMeta generateTrans() throws KettleException {
        TransMeta transMeta = createTrans();
        // 创建步骤1并添加到转换中
        StepMeta step1 = createStep1(transMeta);
        transMeta.addStep(step1);
        // 创建步骤2并添加到转换中
        StepMeta step2 = createStep2(transMeta);
        transMeta.addStep(step2);
        // 创建hop连接并添加hop
        TransHopMeta TransHopMeta = createTransHop(step1, step2);
        transMeta.addTransHop(TransHopMeta);
        System.out.println("创建转换成功");
//        System.out.println(transMeta.getXML());
        return transMeta;
    }

    /**
     *  创建步骤：（输入：表输入）
     *  @param transMeta  * @return
     */
    private static StepMeta createStep1(TransMeta transMeta) {
        // 新建一个表输入步骤(TableInputMeta)
        TableInputMeta tableInputMeta = new TableInputMeta();
        // 设置步骤1的数据库连接
        tableInputMeta.setDatabaseMeta(transMeta.findDatabase("fromDbName"));
        // 设置步骤1中的sql
        tableInputMeta.setSQL("SELECT id ,name FROM stu");
        // 设置步骤名称
        StepMeta step1 = new StepMeta("step1name", tableInputMeta);
        return step1;
    }

    /**
     *  创建转换
     *  @return
     */
    private static TransMeta createTrans() {
        TransMeta transMeta = new TransMeta();
        // 设置转化的名称
        transMeta.setName("TransName");
        // 添加转换的数据库连接
        transMeta.addDatabase(new DatabaseMeta("fromDbName", "MySQL",
                "Native(JDBC)", "127.0.0.1",
                "kettle_demo?useSSL=false&useUnicode=yes&characterEncoding=UTF-8&useSSL=false&serverTimezone=UTC",
                "3306", "root", "root"));
        transMeta.addDatabase(new DatabaseMeta("toDbName",   "MySQL",
                "Native(JDBC)", "127.0.0.1",
                "kettle_demo?useSSL=false&useUnicode=yes&characterEncoding=UTF-8&useSSL=false&serverTimezone=UTC",
                "3306", "root", "root"));
        return transMeta;
    }

    /**
     * 创建步骤：（输出：插入/更新）
     * @param transMeta
     * @return
     */
    private static StepMeta createStep2(TransMeta transMeta) {
        // 新建一个插入/更新步骤
        InsertUpdateMeta insertUpdateMeta = new InsertUpdateMeta();
        // 设置步骤2的数据库连接
        insertUpdateMeta.setDatabaseMeta(transMeta.findDatabase("toDbName"));
        // 设置目标表
        insertUpdateMeta.setTableName("stu2");
        // 设置用来查询的关键字
        insertUpdateMeta.setKeyLookup(new String[] {"id"});
        insertUpdateMeta.setKeyCondition(new String[] {"="});
        insertUpdateMeta.setKeyStream(new String[] {"id"});
        insertUpdateMeta.setKeyStream2(new String[] {""});// 一定要加上
        // 设置要更新的字段
        String[] updatelookup = {"id", "name"};
        String[] updateStream = {"id", "name"};
        Boolean[] updateOrNot = {false, true};
        // 设置表字段
        insertUpdateMeta.setUpdateLookup(updatelookup);
        // 设置流字段
        insertUpdateMeta.setUpdateStream(updateStream);
        // 设置是否更新
        insertUpdateMeta.setUpdate(updateOrNot);
        // 设置步骤2的名称
        StepMeta step2 = new StepMeta("step2name", insertUpdateMeta);
        return step2;
    }

    /**
     *  创建节点连接 
     *  @param step1 
     *  @param step2  * @return
     */
    private static TransHopMeta createTransHop(StepMeta step1, StepMeta step2) {
        // 设置起始步骤和目标步骤，把两个步骤关联起来
        TransHopMeta transHopMeta = new TransHopMeta(step1, step2);
        return transHopMeta;
    }

    /**
     *  保存转换到资源库
     *  @param kettleDatabaseRepository
     *  @param transMeta 
     *  @throws Exception
     */
    private static void saveTrans(KettleDatabaseRepository kettleDatabaseRepository, TransMeta transMeta)
            throws Exception {
        RepositoryDirectoryInterface dir = kettleDatabaseRepository.loadRepositoryDirectoryTree().findDirectory("/");
        transMeta.setRepositoryDirectory(dir);
        kettleDatabaseRepository.save(transMeta, null);
    }

}