kettle（二）java调用kettle api

已于 2023-12-30 11:08:13 修改
阅读量1.2k 收藏 6
点赞数 1
分类专栏： 常用技术 文章标签： java 开发语言
于 2020-11-19 14:38:24 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/w_t_y_y/article/details/95315480
版权

背景：现需要定时执行数据抽取功能，kettle工具是可以直接新建job的，不过这样比较麻烦，时间都浪费在新建kettle上，也不便于监控和维护。其实不同的ktr文件模板基本都是一样的，只是里面的数据不一样而已，这时就可以只新建一个kettle转换的ktr文件，java后台新建任务，这个任务包括频率、参数，由job调度根据每个task设置的频率去执行，读取这个ktr文件，把ktr文件里面的参数用当前任务的参数替换掉。

举例：

一、txt抽取到mysql：

模板：

其中：textFileInput：

除了一些公共的东西，剩下数据全部由代码设置：

public static KettleResult runTxtToMysqlTemplateKtr(Map<String, String> param) throws KettleException, InvalidKeyException, UnsupportedEncodingException {
    	 //模板文件
    	TransMeta transMeta = new TransMeta(DirectoryUtil.txtToMysqlTemplatePath);
        // 步骤：获取文件名
        StepMeta findStep = transMeta.findStep("getFileName");
        GetFileNamesMeta fileNamesMeta = (GetFileNamesMeta) findStep.getStepMetaInterface();
        String fileName = param.get("sourcePath");
        if (StringUtils.isNotEmpty(fileName)) {
            if (fileName.contains("${PART}")) {
                fileName = fileName.replace("${PART}", new SimpleDateFormat("yyyy-MM-dd").format(new Date()));
            }
            fileNamesMeta.setFileName(new String[]{fileName});
        }

        // 步骤：文本文件输入
        StepMeta textStep = transMeta.findStep("textFileInput");
        TextFileInputMeta fileInputMeta = (TextFileInputMeta) textStep.getStepMetaInterface();
        List<FieldMeta> fieldMetas = JSONUtils.parseList(param.get("mapping"), FieldMeta.class);
        // 字段
        BaseFileField[] baseFileInputFields = new BaseFileField[fieldMetas.size()];
        // 映射
        String[] inputFields = new String[fieldMetas.size()];
        if (!CollectionUtils.isEmpty(fieldMetas)) {
            for (int i = 0; i < fieldMetas.size(); i++) {
                BaseFileField bf = new BaseFileField();
                bf.setName(fieldMetas.get(i).getName());
                bf.setType(fieldMetas.get(i).getDataType());
                baseFileInputFields[i] = bf;
                inputFields[i] = fieldMetas.get(i).getName();
            }
        }
        fileInputMeta.inputFields = baseFileInputFields;
        //fileInputMeta.inputFiles.includeSubFolders = includeSubFolderBoolean;
        fileInputMeta.content.separator = param.get("division");
        // 步骤：表输出
        StepMeta tableStep = transMeta.findStep("tableOutput");
        TableOutputMeta tableOutputMeta = (TableOutputMeta) tableStep.getStepMetaInterface();

        String host = param.get("host");
        String port = param.get("port");
        String db = param.get("dataBase");
        String table = param.get("tableName");
        String user = param.get("user");
        String password = PwdUtil.decrypt(param.get("password"));

        MySQLDatabaseMeta mySQLDatabaseMeta = (MySQLDatabaseMeta) tableOutputMeta.getDatabaseMeta().getDatabaseInterface();
        if (StringUtils.isNotEmpty(host)) {
            mySQLDatabaseMeta.setHostname(host);
        }
        if (StringUtils.isNotEmpty(port)) {
            mySQLDatabaseMeta.setDatabasePortNumberString(port);
        }
        if (StringUtils.isNotEmpty(db)) {
            mySQLDatabaseMeta.setDatabaseName(db);
        }
        if (StringUtils.isNotEmpty(user)) {
            mySQLDatabaseMeta.setUsername(user);
        }
        if (StringUtils.isNotEmpty(password)) {
            mySQLDatabaseMeta.setPassword(password);
        }
        if (StringUtils.isNotEmpty(table)) {
            tableOutputMeta.setTableName(table);
        }
        tableOutputMeta.setFieldStream(inputFields);
        tableOutputMeta.setFieldDatabase(inputFields);
        //是否全量,全量则删除表
        if(Boolean.valueOf(param.get("isTruncateTable"))){
        	tableOutputMeta.setTruncateTable(true);
        }    
        // 转换
        Trans trans = new Trans(transMeta);
        trans.execute(null);
        // 等待转换执行结束
        trans.waitUntilFinished();
        // 抛出异常
        if (trans.getErrors() > 0) {
            throw new KettleException("There are errors during transformation exception!(传输过程中发生异常)");
        }
        Result result = trans.getResult();
        KettleResult kettleResult = transResult(result);
        return kettleResult;
    }

 二、mysql抽取到txt：

public static KettleResult runMysqlToTxtTemplateKtr(Map<String, String> param) throws KettleException, InvalidKeyException, UnsupportedEncodingException {
		//读取模板文件
    	TransMeta transMeta = new TransMeta(DirectoryUtil.mysqlToTxtTemplatePath);
    	//1、表输入
    	StepMeta tableStep = transMeta.findStep("tableInput");
    	TableInputMeta tableInputMeta = (TableInputMeta) tableStep.getStepMetaInterface();
    	String host = param.get("host");
        String port = param.get("port");
        String db = param.get("dataBase");
        String table = param.get("tableName");
        String user = param.get("user");
        String columnName = param.get("columnName");
        String password = PwdUtil.decrypt(param.get("password"));
        DatabaseMeta mySQLDatabaseMeta = new DatabaseMeta();
        mySQLDatabaseMeta.setDatabaseType("mySQL");
        String columns = "*";
        if (StringUtils.isNotEmpty(host)) {
            mySQLDatabaseMeta.setHostname(host);
        }
        if (StringUtils.isNotEmpty(port)) {
            mySQLDatabaseMeta.setDBPort(port);
        }
        if (StringUtils.isNotEmpty(db)) {
            mySQLDatabaseMeta.setDBName(db);
        }
        if (StringUtils.isNotEmpty(user)) {
            mySQLDatabaseMeta.setUsername(user);
        }
        if (StringUtils.isNotEmpty(password)) {
            mySQLDatabaseMeta.setPassword(password);
        }
        if (StringUtils.isNotEmpty(table)) {
        	tableInputMeta.setDatabaseMeta(mySQLDatabaseMeta);
        }
        if(StringUtils.isNotEmpty(columnName)){
        	columns = columnName;
        }
        tableInputMeta.setSQL("select "+columns+" from "+table);
       //2、文本文件输出
       StepMeta textStep = transMeta.findStep("textFileOutput");
       //文本文件
       String mysqlToTxtTemplatePath = param.get("outPutFileName");
       TextFileOutputMeta textFileOutputMeta = (TextFileOutputMeta) textStep.getStepMetaInterface();
       textFileOutputMeta.setFileName(mysqlToTxtTemplatePath);
       //是否追加
       if(Boolean.valueOf(param.get("appendFile"))){
    	   textFileOutputMeta.setFileAppended(true);
       }
       
       //3、转换
       Trans trans = new Trans(transMeta);
       trans.execute(null);
       // 等待转换执行结束
       trans.waitUntilFinished();
       // 抛出异常
       if (trans.getErrors() > 0) {
           throw new KettleException("There are errors during transformation exception!(传输过程中发生异常)");
       }
       Result result = trans.getResult();
       KettleResult kettleResult = transResult(result);
       return kettleResult;
	}

 三、抽取mongo到txt：

public static KettleResult runMongoTotxt(Map<String, String> param) throws KettleException, NoSuchMethodException, InvocationTargetException, IllegalAccessException, ClassNotFoundException, InstantiationException, UnsupportedEncodingException, InvalidKeyException {
        String mongo = DirectoryUtil.mongoToTxtTemplatePath;
        //读取模板文件
        TransMeta transMeta = new TransMeta(mongo);
        //获取MongoDBInput
        StepMeta mongoStep = transMeta.findStep("MongoDBInput");
        MongoDbInputMeta mongoDbInputMeta = new MongoDbInputMeta();
        String host = param.get("host");
        String port = param.get("port");
        String db = param.get("dataBase");
        String collection = param.get("collection");
        String user = param.get("user");
        String password = PwdUtil.decrypt(param.get("password"));
        String mongoDb = param.get("mongoDb");
        mongoDbInputMeta.setHostnames(host);
        mongoDbInputMeta.setPort(port);
        if(StringUtils.isNotEmpty(db)  && StringUtils.isNotEmpty(user)  && StringUtils.isNotEmpty(password)){
            mongoDbInputMeta.setAuthenticationMechanism("MONGODB-CR");
            mongoDbInputMeta.setAuthenticationDatabaseName(db);
            mongoDbInputMeta.setAuthenticationUser(user);
            mongoDbInputMeta.setAuthenticationPassword(password);
        }
        mongoDbInputMeta.setDbName(mongoDb);
        mongoDbInputMeta.setCollection(collection);
    
        List<MongoField> mongoFields = new ArrayList<>();
        List<MongoFieldMeta> fieldMetas = JSONUtils.parseList(param.get("mongoMapping"), MongoFieldMeta.class);
        for(MongoFieldMeta mongoFieldMeta :fieldMetas ){
            MongoField mongoField = new MongoField();
            mongoField.m_fieldName = mongoFieldMeta.getName();
            mongoField.m_fieldPath = mongoFieldMeta.getPath();
            mongoField.m_kettleType = mongoFieldMeta.getType();
            mongoFields.add(mongoField);
        }
        mongoDbInputMeta.setMongoFields(mongoFields);
       mongoDbInputMeta.setOutputJson(false);
       //mongoDbInputMeta.setJsonFieldName("json");
        mongoStep.setStepMetaInterface(mongoDbInputMeta);
        //获取fileOutPut
        StepMeta txtStep = transMeta.findStep("fileOutPut");
        TextFileOutputMeta textFileOutputMeta = (TextFileOutputMeta) txtStep.getStepMetaInterface();
       //不加后缀
        String mongoToTxtTemplatePath = param.get("outPutFileName");
        textFileOutputMeta.setFileName(mongoToTxtTemplatePath);

        //3、转换
        Trans trans = new Trans(transMeta);


        trans.execute(null);
        // 等待转换执行结束
        trans.waitUntilFinished();

        // 抛出异常
        if (trans.getErrors() > 0) {
            throw new KettleException("There are errors during transformation exception!(传输过程中发生异常)");
        }
        Result result = trans.getResult();
        KettleResult kettleResult = transResult(result);
        return kettleResult;
    }

 说明：mysql是kettle自带的，mongo这些属于插件，所以需要加载plugins插件，如我是从本地加载的pentaho-mongodb-plugin的jar包。这里MongoDbInputMeta 之所以不是从ktr文件里面获取

MongoDbInputMeta mongoDbInputMeta =(MongoDbInputMeta) mongoStep.getStepMetaInterface();

，而是new一个出来，是因为MongoDbInputMeta左值是java自带的类加载器加载出来的，而右值是pentaho自定义的加载器加载出来的，类加载器不一样，可以把两个来加载器打印出来看是不一样的。这样，即使是同一个包下的同一个类，=赋值也会报ClassCastException转换异常。这个问题我没有解决，所以单独new了一个。

四、抽取sqlserver到txt，模板同二：

 /**
     * sqlserver-txt抽取
     */
    public static KettleResult runSqlServerToTxtTemplateKtr(Map<String, String> param) throws KettleException, InvalidKeyException, UnsupportedEncodingException {
        //读取模板文件
        TransMeta transMeta = new TransMeta(DirectoryUtil.mysqlToTxtTemplatePath);
        //1、表输入
        //表输入
        StepMeta tableStep = transMeta.findStep("tableInput");
        TableInputMeta tableInputMeta = (TableInputMeta) tableStep.getStepMetaInterface();
        //MSSQLServerDatabaseMeta dbServer = (MSSQLServerDatabaseMeta)tableInputMeta.getDatabaseMeta().getDatabaseInterface();
        MSSQLServerDatabaseMeta dbServer = new MSSQLServerDatabaseMeta();
        String host = param.get("host");
        String port = param.get("port");
        String db = param.get("dataBase");
        String table = param.get("tableName");
        String user = param.get("user");
        String columnName = param.get("columnName");
        String password = PwdUtil.decrypt(param.get("password"));
        String columns = "*";
        if (StringUtils.isNotEmpty(host)) {
            dbServer.setHostname(host);
        }
        if (StringUtils.isNotEmpty(port)) {
            dbServer.setDatabasePortNumberString(port);
        }
        if (StringUtils.isNotEmpty(db)) {
            dbServer.setDatabaseName(db);
        }
        if (StringUtils.isNotEmpty(user)) {
            dbServer.setUsername(user);
        }
        if (StringUtils.isNotEmpty(password)) {
            dbServer.setPassword(password);
        }
        tableInputMeta.getDatabaseMeta().setDatabaseInterface(dbServer);
        if(StringUtils.isNotEmpty(columnName)){
            columns = columnName;
        }
        String sql = "SELECT ";
        String limit = param.get("limit");
        if(StringUtils.isNotEmpty(limit)){
            sql += " TOP "+limit;
        }
        sql += columns+" FROM "+table;
        tableInputMeta.setSQL(sql);
        //2、文本文件输出
        StepMeta textStep = transMeta.findStep("textFileOutput");
        //文本文件
        String mysqlToTxtTemplatePath = param.get("outPutFileName");
        TextFileOutputMeta textFileOutputMeta = (TextFileOutputMeta) textStep.getStepMetaInterface();
        textFileOutputMeta.setFileName(mysqlToTxtTemplatePath);
        //是否追加
        if(Boolean.valueOf(param.get("appendFile"))){
            textFileOutputMeta.setFileAppended(true);
        }

        //3、转换
        Trans trans = new Trans(transMeta);
        trans.execute(null);
        // 等待转换执行结束
        trans.waitUntilFinished();
        // 抛出异常
        if (trans.getErrors() > 0) {
            throw new KettleException("There are errors during transformation exception!(传输过程中发生异常)");
        }
        Result result = trans.getResult();
        KettleResult kettleResult = transResult(result);
        return kettleResult;
    }

五、执行SQL：

 /**
     * 执行sql
     * @param param
     */
    public static KettleResult runSql(Map<String,String> param) throws KettleException, UnsupportedEncodingException, InvalidKeyException {
        //读取模板文件
        TransMeta transMeta = new TransMeta(DirectoryUtil.sqlTemplatePath);
        StepMeta sqlStep = transMeta.findStep("sqlStep");
        ExecSQLMeta execSQLMeta = (ExecSQLMeta)sqlStep.getStepMetaInterface();
        //参数
        String host = param.get("host");
        String port = param.get("port");
        String dbName = param.get("dataBase");
        String userName = param.get("user");
        String pwd = PwdUtil.decrypt(param.get("password"));
        String sql = param.get("sql");
        String dbType = param.get("targetType");
        if(DatabaseType.mysql.toString().equals(dbType)){
            DatabaseInterface mysqlDb = new MySQLDatabaseMeta();
            mysqlDb.setHostname(host);
            mysqlDb.setDatabasePortNumberString(port);
            mysqlDb.setDatabaseName(dbName);
            mysqlDb.setUsername(userName);
            mysqlDb.setPassword(pwd);
            execSQLMeta.getDatabaseMeta().setDatabaseInterface(mysqlDb);
        }else if(DatabaseType.sqlServer.toString().equals(dbType)){
            MSSQLServerDatabaseMeta sqlServerDb = new MSSQLServerDatabaseMeta();
            sqlServerDb.setHostname(host);
            sqlServerDb.setDatabasePortNumberString(port);
            sqlServerDb.setDatabaseName(dbName);
            sqlServerDb.setUsername(userName);
            sqlServerDb.setPassword(pwd);
            execSQLMeta.getDatabaseMeta().setDatabaseInterface(sqlServerDb);
        }
        execSQLMeta.setSql(sql);
        //替换数据库相关
        //3、转换
        Trans trans = new Trans(transMeta);
        trans.execute(null);
        trans.waitUntilFinished();
        if (trans.getErrors() > 0) {
            throw new KettleException("There are errors during transformation exception!(传输过程中发生异常)");
        }
        Result result = trans.getResult();
        KettleResult kettleResult = transResult(result);
        return kettleResult;
    }

总的代码为：

<dependency>
            <groupId>pentaho-kettle</groupId>
            <artifactId>kettle-core</artifactId>
            <version>${kettle.version}</version>
        </dependency>
 <dependency>
            <groupId>pentaho-kettle</groupId>
            <artifactId>kettle-engine</artifactId>
            <version>${kettle.version}</version>
        </dependency>
        <dependency>
            <groupId>pentaho</groupId>
            <artifactId>metastore</artifactId>
            <version>${kettle.version}</version>
        </dependency>
        <dependency>

            <groupId>pentaho</groupId>

            <artifactId>pentaho-mongodb-plugin</artifactId>

            <version>${kettle.version}</version>


        </dependency>

   <!--sqlserver抽取驱动 -->
        <dependency>
            <groupId>net.sourceforge.jtds</groupId>
            <artifactId>jtds</artifactId>
            <version>1.3.1</version>
        </dependency>

 我这里的kettle.version版本为8.2.0.0-342

public class KettleUtil {

    private static final Logger logger = LoggerFactory.getLogger(KettleUtil.class);

    static {
        try {
            String kettlePluginFolder = "D://javas//kettle//data-integration//plugins";
           StepPluginType.getInstance().getPluginFolders().add(new PluginFolder(kettlePluginFolder, false, true));
            // 初始化
            KettleEnvironment.init();
            EnvUtil.environmentInit();
        } catch (KettleException e) {
            logger.error(e.getMessage(), e);
        }
    }

    public static KettleFileRepository initFileRepository(Node node) {
        Assert.notNull(node, "node must be not null.");
        Assert.notEmpty(node.getProperties(), "node's properties must be not empty.");
        String templatePath = node.getProperties().get("templatePath");
        Assert.hasLength(templatePath, "template path must be not empty.");
        KettleFileRepository repository = null;
        try {
            KettleEnvironment.init();
            KettleFileRepositoryMeta repositoryMeta = new KettleFileRepositoryMeta(node.getId(), node.getName(), node.getDescription(), templatePath.substring(0, templatePath.lastIndexOf("/")));
            repository = new KettleFileRepository();
            repository.init(repositoryMeta);
        } catch (Exception e) {
            logger.error("加载kettle环境失败：" + e.getMessage(), e);
        }
        return repository;
    }

    public static void executeTrans(KettleFileRepository repository, String filePath, Map<String, String> properties) throws Exception {
        Assert.notNull(repository, "kettle repository must be nut null.");
        Assert.hasLength(filePath, "file path must be not empty.");
        String fileName = filePath.substring(filePath.lastIndexOf('/') + 1, filePath.lastIndexOf('.'));
        TransMeta transMeta = repository.loadTransformation(repository.getTransformationID(fileName, null), null);
        Trans trans = new Trans(transMeta);
        if (!CollectionUtils.isEmpty(properties)) {
            for (Map.Entry<String, String> entry : properties.entrySet()) {
                trans.setVariable(entry.getKey(), entry.getValue());
            }
        }
        // 执行转换
        trans.execute(null);
        // 等待转换执行结束
        trans.waitUntilFinished();
        // 抛出异常
        if (trans.getErrors() > 0) {
            trans.stopAll();
            throw new Exception("传输过程中发生异常");
        }
    }

  

    public static KettleResult runTxtToMysqlTemplateKtr(Map<String, String> param) throws KettleException, InvalidKeyException, UnsupportedEncodingException {
    	 //模板文件
    	TransMeta transMeta = new TransMeta(DirectoryUtil.txtToMysqlTemplatePath);
        // 步骤：获取文件名
        StepMeta findStep = transMeta.findStep("getFileName");
        GetFileNamesMeta fileNamesMeta = (GetFileNamesMeta) findStep.getStepMetaInterface();
        String fileName = param.get("sourcePath");
        if (StringUtils.isNotEmpty(fileName)) {
            if (fileName.contains("${PART}")) {
                fileName = fileName.replace("${PART}", new SimpleDateFormat("yyyy-MM-dd").format(new Date()));
            }
            fileNamesMeta.setFileName(new String[]{fileName});
        }

        // 步骤：文本文件输入
        StepMeta textStep = transMeta.findStep("textFileInput");
        TextFileInputMeta fileInputMeta = (TextFileInputMeta) textStep.getStepMetaInterface();
        List<FieldMeta> fieldMetas = JSONUtils.parseList(param.get("mapping"), FieldMeta.class);
        // 字段
        BaseFileField[] baseFileInputFields = new BaseFileField[fieldMetas.size()];
        // 映射
        String[] inputFields = new String[fieldMetas.size()];
        if (!CollectionUtils.isEmpty(fieldMetas)) {
            for (int i = 0; i < fieldMetas.size(); i++) {
                BaseFileField bf = new BaseFileField();
                bf.setName(fieldMetas.get(i).getName());
                bf.setType(fieldMetas.get(i).getDataType());
                baseFileInputFields[i] = bf;
                inputFields[i] = fieldMetas.get(i).getName();
            }
        }
        fileInputMeta.inputFields = baseFileInputFields;
        //fileInputMeta.inputFiles.includeSubFolders = includeSubFolderBoolean;
        fileInputMeta.content.separator = param.get("division");
        // 步骤：表输出
        StepMeta tableStep = transMeta.findStep("tableOutput");
        TableOutputMeta tableOutputMeta = (TableOutputMeta) tableStep.getStepMetaInterface();

        String host = param.get("host");
        String port = param.get("port");
        String db = param.get("dataBase");
        String table = param.get("tableName");
        String user = param.get("user");
        String password = PwdUtil.decrypt(param.get("password"));

        MySQLDatabaseMeta mySQLDatabaseMeta = (MySQLDatabaseMeta) tableOutputMeta.getDatabaseMeta().getDatabaseInterface();
        if (StringUtils.isNotEmpty(host)) {
            mySQLDatabaseMeta.setHostname(host);
        }
        if (StringUtils.isNotEmpty(port)) {
            mySQLDatabaseMeta.setDatabasePortNumberString(port);
        }
        if (StringUtils.isNotEmpty(db)) {
            mySQLDatabaseMeta.setDatabaseName(db);
        }
        if (StringUtils.isNotEmpty(user)) {
            mySQLDatabaseMeta.setUsername(user);
        }
        if (StringUtils.isNotEmpty(password)) {
            mySQLDatabaseMeta.setPassword(password);
        }
        if (StringUtils.isNotEmpty(table)) {
            tableOutputMeta.setTableName(table);
        }
        tableOutputMeta.setFieldStream(inputFields);
        tableOutputMeta.setFieldDatabase(inputFields);
        //是否全量,全量则删除表
        if(Boolean.valueOf(param.get("isTruncateTable"))){
        	tableOutputMeta.setTruncateTable(true);
        }    
        // 转换
        Trans trans = new Trans(transMeta);
        trans.execute(null);
        // 等待转换执行结束
        trans.waitUntilFinished();
        // 抛出异常
        if (trans.getErrors() > 0) {
            throw new KettleException("There are errors during transformation exception!(传输过程中发生异常)");
        }
        Result result = trans.getResult();
        KettleResult kettleResult = transResult(result);
        return kettleResult;
    }

    
  


	public static KettleResult runMysqlToTxtTemplateKtr(Map<String, String> param) throws KettleException, InvalidKeyException, UnsupportedEncodingException {
		//读取模板文件
    	TransMeta transMeta = new TransMeta(DirectoryUtil.mysqlToTxtTemplatePath);
    	//1、表输入
    	StepMeta tableStep = transMeta.findStep("tableInput");
    	TableInputMeta tableInputMeta = (TableInputMeta) tableStep.getStepMetaInterface();
    	String host = param.get("host");
        String port = param.get("port");
        String db = param.get("dataBase");
        String table = param.get("tableName");
        String user = param.get("user");
        String columnName = param.get("columnName");
        String password = PwdUtil.decrypt(param.get("password"));
        DatabaseMeta mySQLDatabaseMeta = new DatabaseMeta();
        mySQLDatabaseMeta.setDatabaseType("mySQL");
        String columns = "*";
        if (StringUtils.isNotEmpty(host)) {
            mySQLDatabaseMeta.setHostname(host);
        }
        if (StringUtils.isNotEmpty(port)) {
            mySQLDatabaseMeta.setDBPort(port);
        }
        if (StringUtils.isNotEmpty(db)) {
            mySQLDatabaseMeta.setDBName(db);
        }
        if (StringUtils.isNotEmpty(user)) {
            mySQLDatabaseMeta.setUsername(user);
        }
        if (StringUtils.isNotEmpty(password)) {
            mySQLDatabaseMeta.setPassword(password);
        }
        if (StringUtils.isNotEmpty(table)) {
        	tableInputMeta.setDatabaseMeta(mySQLDatabaseMeta);
        }
        if(StringUtils.isNotEmpty(columnName)){
        	columns = columnName;
        }
        tableInputMeta.setSQL("select "+columns+" from "+table);
       //2、文本文件输出
       StepMeta textStep = transMeta.findStep("textFileOutput");
       //文本文件
       String mysqlToTxtTemplatePath = param.get("outPutFileName");
       TextFileOutputMeta textFileOutputMeta = (TextFileOutputMeta) textStep.getStepMetaInterface();
       textFileOutputMeta.setFileName(mysqlToTxtTemplatePath);
       //是否追加
       if(Boolean.valueOf(param.get("appendFile"))){
    	   textFileOutputMeta.setFileAppended(true);
       }
       
       //3、转换
       Trans trans = new Trans(transMeta);
       trans.execute(null);
       // 等待转换执行结束
       trans.waitUntilFinished();
       // 抛出异常
       if (trans.getErrors() > 0) {
           throw new KettleException("There are errors during transformation exception!(传输过程中发生异常)");
       }
       Result result = trans.getResult();
       KettleResult kettleResult = transResult(result);
       return kettleResult;
	}
	
	private static KettleResult transResult(Result result) {
		KettleResult kettleResult = new KettleResult();
		kettleResult.setEntryNr(result.getEntryNr());
		kettleResult.setExitStatus(result.getExitStatus());
		kettleResult.setLogChannelId(result.getLogChannelId());
		kettleResult.setLogText(result.getLogText());
		kettleResult.setNrErrors(result.getNrErrors());
		kettleResult.setNrFilesRetrieved(result.getNrFilesRetrieved());
		kettleResult.setNrLinesDeleted(result.getNrLinesDeleted());
		kettleResult.setNrLinesInput(result.getNrLinesInput());
		kettleResult.setNrLinesOutput(result.getNrLinesOutput());
		kettleResult.setNrLinesRead(result.getNrLinesRead());
		kettleResult.setNrLinesRejected(result.getNrLinesRejected());
		kettleResult.setNrLinesUpdated(result.getNrLinesUpdated());
		kettleResult.setNrLinesWritten(result.getNrLinesWritten());
		kettleResult.setResult(result.getResult());
		kettleResult.setStopped(result.stopped);
		kettleResult.setRows(result.getRows());
		kettleResult.setResultFiles(result.getResultFiles());
		return kettleResult;
	}


   


    public static KettleResult runMongoTotxt(Map<String, String> param) throws KettleException, NoSuchMethodException, InvocationTargetException, IllegalAccessException, ClassNotFoundException, InstantiationException, UnsupportedEncodingException, InvalidKeyException {
        String mongo = DirectoryUtil.mongoToTxtTemplatePath;
        //读取模板文件
        TransMeta transMeta = new TransMeta(mongo);
        //获取MongoDBInput
        StepMeta mongoStep = transMeta.findStep("MongoDBInput");
        MongoDbInputMeta mongoDbInputMeta = new MongoDbInputMeta();
        String host = param.get("host");
        String port = param.get("port");
        String db = param.get("dataBase");
        String collection = param.get("collection");
        String user = param.get("user");
        String password = PwdUtil.decrypt(param.get("password"));
        String mongoDb = param.get("mongoDb");
        mongoDbInputMeta.setHostnames(host);
        mongoDbInputMeta.setPort(port);
        if(StringUtils.isNotEmpty(db)  && StringUtils.isNotEmpty(user)  && StringUtils.isNotEmpty(password)){
            mongoDbInputMeta.setAuthenticationMechanism("MONGODB-CR");
            mongoDbInputMeta.setAuthenticationDatabaseName(db);
            mongoDbInputMeta.setAuthenticationUser(user);
            mongoDbInputMeta.setAuthenticationPassword(password);
        }
        mongoDbInputMeta.setDbName(mongoDb);
        mongoDbInputMeta.setCollection(collection);

       /* mongoDbInputMeta.setHostnames("127.0.0.1");
        mongoDbInputMeta.setPort("27017");
        mongoDbInputMeta.setDbName("wechatMsg");
        mongoDbInputMeta.setCollection("wechatmsg");*/
        List<MongoField> mongoFields = new ArrayList<>();
        List<MongoFieldMeta> fieldMetas = JSONUtils.parseList(param.get("mongoMapping"), MongoFieldMeta.class);
        for(MongoFieldMeta mongoFieldMeta :fieldMetas ){
            MongoField mongoField = new MongoField();
            mongoField.m_fieldName = mongoFieldMeta.getName();
            mongoField.m_fieldPath = mongoFieldMeta.getPath();
            mongoField.m_kettleType = mongoFieldMeta.getType();
            mongoFields.add(mongoField);
        }
        mongoDbInputMeta.setMongoFields(mongoFields);
       mongoDbInputMeta.setOutputJson(false);
       //mongoDbInputMeta.setJsonFieldName("json");
        mongoStep.setStepMetaInterface(mongoDbInputMeta);
        //获取fileOutPut
        StepMeta txtStep = transMeta.findStep("fileOutPut");
        TextFileOutputMeta textFileOutputMeta = (TextFileOutputMeta) txtStep.getStepMetaInterface();
       //不加后缀
        String mongoToTxtTemplatePath = param.get("outPutFileName");
        textFileOutputMeta.setFileName(mongoToTxtTemplatePath);

        //3、转换
        Trans trans = new Trans(transMeta);


        trans.execute(null);
        // 等待转换执行结束
        trans.waitUntilFinished();

        // 抛出异常
        if (trans.getErrors() > 0) {
            throw new KettleException("There are errors during transformation exception!(传输过程中发生异常)");
        }
        Result result = trans.getResult();
        KettleResult kettleResult = transResult(result);
        return kettleResult;
    }

}

w_t_y_y
关注
  • 1
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
java调用kettle提供的API实现数据抽取DEMO
10-30
通过调用kettle的API接口,实现将一个库的数据转移到另一个数据库中。附件中同时提供了抽取需要的jar包
java调用kettle示例
01-04
java调用kettle使用示例，包含数据库到数据库，csv到数据库及数据库到excel数据同步调用代码。
kettle组件之java代码，快速上手必看
最新发布
信徒博客
05-28 751
难点：1、我不想要把处理后的值覆盖掉原来的值，而是创建一个新的字段，给这个新的字段赋值。3、get(Fields.in,"字段名").getString(r);功能、获取记事本里面的数据，把这个数据进行简单的处理，然后输出;获取这一行数据中，对应的字段名并且是值是字符串类型的数据。2、其次我不想要之前的字段，很冗余。我们先了解不同于java代码的kettle的一些方法。2、get(Fields.in,"字段名");6、logBasic("数据是: " +b);获取具体的某个字段的名称。
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转储接口数据
weixin_30879833的博客
04-11 361
1. 项目背景 1.1. 项目背景 数据接口 API：应用程序接口（Application Program Interface）的简称，是实现计算机软件之间数据通信的工具。同时API也是一种中间件，为各个平台提供数据共享。在大数据与物联网发展的背景下，目前有大量的数据接口被提供或发掘出来，提供给开发者使用，应用到生活中的每一个细节中。本文旨在阐述kettl...
用Kettle调用金蝶云星空API实现数据清洗
dujunwoaini的博客
07-18 1621
kettle 中文名称叫水壶，是纯 java 开发，开源的 ETL工具，用于数据库间的数据迁移。可以在 Linux、windows、unix 中运行。根据上一个（REST 登录云星空）所返回的result来获取Cookies。根据字段选择节点返回的值写入REST client 云星空查询单对应字段。根据生成记录里的登录URL、登录账号、密码登录云星空并返回数据。6）、登录云星空后需要获取Cookies并传入查询json里。1）、云星空所有的接口请求方式都是：POST。
用Kettle调用Restful API 接口
helloworldchina的博客
01-08 5583
基于组件REST Client 请求 Restful API ，先访问获取token的Restful API，在得到包含token的结果集后，再用组件JSON input 从中抽取token，然后再用另一个组件REST Client 携带得到的token，访问包含业务数据的Restful API，经组件字段选择过滤后，再经组件表输出，将数据写入目标数据库对应的表。
kettle实现从api接口全量抽取数据到数据库中
Yuyuyu666dhdh的博客
12-02 5568
kettle实现从api接口全量抽取数据到数据库中
ETL工具 - JAVA 调用 Kettle 转换、作业脚本
小毕超博客
05-03 3971
JAVA 调用 Kettle 转换、作业脚本。
java以api的方式集成调用kettle
qq_32577829的博客
03-31 8482
一、kettle集成调用的多种方式。 kettle提供了多种方式集成调用，比如： 1、脚本的方式，windows下以bat脚本调用，Linux下以sh脚本调用。 2、http请求carte服务的方式进行集成调用。java端可以采用httpclient api去调用carte。 3、以java工程引入kettle依赖，采用api集成的方式调用。 二、为什么要以api的方式集成kettle 因为第一点提到的1、2两点，都需要在服务节点端安装kettle，且脚本的方式调用要维护多套系统执行脚本。而以c
通过kettle API接口创建转换和任务
qq_41982570的博客
12-07 2018
公司需求，通过页面配置kettle相关任务，定时调度运行 以下为后端生成kettle转换和任务部分示例代码 导入依赖：maven上无kettle相关依赖，故本地直接导入，kettle安装目录\lib 下的包全部导入（后续发现导入部分即可，未做深究）
Kettle java API
11-18
Kettle java API Kettle java API
Kettle API - Java调用示例
07-12
Kettle API 是一个强大的工具，允许开发者通过Java代码与Pentaho Data Integration (Kettle) 进行交互，实现数据提取、转换和加载（ETL）过程的自动化。在给定的示例中，主要展示了如何使用Kettle API 创建、保存和...
java调用kettle的依赖包
02-19
Java调用Kettle的能力使得这种集成成为可能，为业务流程提供了更大的灵活性。以下是一些关于如何在Java项目中使用Kettle的依赖包以及相关知识点的详细说明： 1. **Kettle Java API**：Kettle提供了Java API，使得...
Kettle-API FOR java
03-16
二、Kettle API的使用 1. 导入依赖：在Java项目中使用Kettle API，首先需要添加对应的库依赖，通常是pentaho-kettle的jar包。这些库包含了所有必要的类和接口，用于与Kettle引擎进行交互。 2. 创建转换和作业对象：...
Kettle项目实践
tang5615的博客
02-19 1004
本文编写两个kettle常用的用法，方便快速掌握kettle的使用。
java集成kettle 9.2.0开发
qq_42796953的博客
08-09 3901
java集成Kettle以及Kettle简介
KETTLE调用接口数据（HTTP，API接口，包含list集合）
热门推荐
m0_46521990的博客
05-12 1万+
先看流程在调用接口之前首先先需要知道一些必要的参数 url：就是接口地址 body：相当于sql语句中的where条件（select * from dual where body=） 再不明白请看图，其中百度就相当于body token：就相当于打开接口的钥匙，URL就是门，想进门你就得有钥匙，请看具体解释 关于这个token看具体情况，有的接口需要token，有的接口不需要，我展示的这个接口需要token但是他会一直在变，苦苦找寻办法没有解决，最后让做ESB的同事给我代理出来了 page：从第几页开
kettle调用API--HTTP client,HTTP post和REST client组件的使用
qq844385029的博客
08-09 1万+
kettle调用API----HTTP client,HTTP post和REST client组件的使用 1.开发流程简介： 第一步，选择Generate rows组件，可用来配置api的URL或者参数. 这里需要特别注意，虽然api组件里可以直接设置URL和参数，但是他们并不是输入流组件，所以这里一定要存在一个类似Generate rows的输入流组件. 第二步，根据需求选择合适的api组件，这里以HTTP client组件为例： 这里可以在URL一栏输入具体的URL，也可以勾选Accept UR
kettle定时任务
08-19
您好！关于 kettle 定时任务的问题，我可以给您一些基本的指导。 Kettle 是一款开源的数据集成工具，它可以用来处理和转换大量的数据。在 Kettle 中，您可以创建定时任务来自动执行一系列数据处理和转换操作。下面是一些关于 kettle 定时任务的常见问题和解答： 1. 如何创建一个定时任务？ 在 Kettle 中，您可以使用“Job”步骤来创建一个定时任务。首先，在 Kettle 的图形界面中创建一个 Job，并将需要执行的转换操作添加到 Job 中。然后，使用“Simple Scheduler”或“Cron Scheduler”来配置任务的定时触发器。 2. 什么是 Simple Scheduler 和 Cron Scheduler？ Simple Scheduler 是 Kettle 中的一种简单的定时触发器，它允许您设置任务在指定的日期和时间触发执行。而 Cron Scheduler 则是一种更灵活的触发器，它基于 Cron 表达式来配置任务的执行时间，可以实现更复杂的定时调度需求。 3. 如何配置 Simple Scheduler？ 在 Job 的图形界面中，选择要配置定时触发器的 Job 步骤，在右侧的属性栏中找到“Scheduler Type”选项，选择“Simple Scheduler”。然后，设置触发器的开始日期、开始时间和重复间隔等参数，以及任务的执行次数限制。 4. 如何配置 Cron Scheduler？ 类似于 Simple Scheduler 的配置方法，选择要配置定时触发器的 Job 步骤，在属性栏中选择“Cron Scheduler”。然后，在“Cron expression”字段中输入符合 Cron 表达式规则的时间表达式，以设置任务的执行时间。 这些是关于 kettle 定时任务的基本指导，希望对您有所帮助。如果您有更多问题，欢迎继续提问！

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

w_t_y_y

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值