kettle系列-4.kettle定制化开发工具类

要说的话这个工具类还是比较简单的，每个方法体都比较小，但用起来还是可以的，把开发中一些常用的步骤封装了下，不用去kettle源码中找相关操作的具体实现了。

算了废话不多了，直接上重点，代码如下：

import java.util.List;

import org.apache.log4j.Logger;
import org.pentaho.di.core.KettleEnvironment;
import org.pentaho.di.core.database.DatabaseMeta;
import org.pentaho.di.core.exception.KettleException;
import org.pentaho.di.core.exception.KettleSecurityException;
import org.pentaho.di.job.JobMeta;
import org.pentaho.di.job.entries.job.JobEntryJob;
import org.pentaho.di.job.entries.trans.JobEntryTrans;
import org.pentaho.di.job.entry.JobEntryBase;
import org.pentaho.di.job.entry.JobEntryCopy;
import org.pentaho.di.repository.AbstractRepository;
import org.pentaho.di.repository.LongObjectId;
import org.pentaho.di.repository.RepositoryDirectoryInterface;
import org.pentaho.di.repository.StringObjectId;
import org.pentaho.di.repository.filerep.KettleFileRepository;
import org.pentaho.di.repository.filerep.KettleFileRepositoryMeta;
import org.pentaho.di.repository.kdr.KettleDatabaseRepository;
import org.pentaho.di.repository.kdr.KettleDatabaseRepositoryMeta;
import org.pentaho.di.trans.TransMeta;
import org.pentaho.di.trans.TransPreviewFactory;
import org.pentaho.di.trans.step.BaseStepMeta;
import org.pentaho.di.trans.step.StepMeta;
import org.pentaho.di.trans.step.StepMetaInterface;
import org.pentaho.di.trans.steps.jobexecutor.JobExecutorMeta;
import org.pentaho.di.trans.steps.transexecutor.TransExecutorMeta;

 /**
 * ClassName: KettleUtils <br/>
 * Function: kettle定制化开发工具集. <br/>
 * date: 2015年4月29日 上午8:56:24 <br/>
 * @author jingma
 * @version 0.0.1
 * @since JDK 1.6
 */
public class KettleUtils {
    /**
     * LOG:日志
     */
    public static Logger log = Logger.getLogger(KettleUtils.class);
    /**
     * repository:kettle资源库
     */
    private static AbstractRepository repository;
    /**
    * 转换模板
    */
    private static TransMeta transMetaTemplate;
    /**
    * 作业模板
    */
    private static JobMeta jobMetaTemplate;

    /**
     * getInstance:获取的单例资源库. <br/>
     * @author jingma
     * @return 已经初始化的资源库
     * @throws KettleException 若没有初始化则抛出异常
     * @since JDK 1.6
     */
    public static AbstractRepository getInstanceRep() throws KettleException{
        if(repository!=null){
            return repository;
//        }else if(1==1){
//            //TODO jingma:这里以后添加读取配置初始化连接资源库
        }else{
            throw new KettleException("没有初始化资源库");
        }
    }

    /**
     * createFileRep:创建文件资源库. <br/>
     * @author jingma
     * @param id 资源库id
     * @param name 资源库名称
     * @param description 资源库描述
     * @param baseDirectory 资源库目录
     * @return 已经初始化的资源库
     * @throws KettleException
     * @since JDK 1.6
     */
    public static AbstractRepository createFileRep(String id, String name, String description, String baseDirectory) throws KettleException{
        destroy();
        //初始化kettle环境
        if(!KettleEnvironment.isInitialized()){
            KettleEnvironment.init();
        }
        repository = new KettleFileRepository();
        KettleFileRepositoryMeta fileRepMeta = new KettleFileRepositoryMeta( id, name, description, baseDirectory);
        repository.init(fileRepMeta);
        log.info(repository.getName()+"资源库初始化成功");
        return repository;
    }

    /**
     * createDBRep:创建数据库资源库. <br/>
     * @author jingma
     * @param name 数据库连接名称
     * @param type 数据库类型
     * @param access 访问类型
     * @param host ip地址
     * @param db 数据库名称
     * @param port 端口
     * @param user 数据库用户名
     * @param pass 数据库密码
     * @return 初始化的资源库
     * @throws KettleException
     * @since JDK 1.6
     */
    public static AbstractRepository createDBRep(String name, String type, String access, String host,
            String db, String port, String user, String pass) throws KettleException{
        return createDBRep( name, type, access, host,
             db, port, user, pass, "DBRep", "DBRep", "数据库资源库");
    }

    /**
     * createDBRep:创建数据库资源库. <br/>
     * @author jingma
     * @param name 数据库连接名称
     * @param type 数据库类型
     * @param access 访问类型
     * @param host ip地址
     * @param db 数据库名称
     * @param port 端口
     * @param user 数据库用户名
     * @param pass 数据库密码
     * @param id 资源库id
     * @param repName 资源库名称
     * @param description 资源库描述
     * @return 已经初始化的资源库
     * @throws KettleException
     * @since JDK 1.6
     */
    public static AbstractRepository createDBRep(String name, String type, String access, String host,
            String db, String port, String user, String pass,String id, String repName, String description) throws KettleException{
        destroy();
        //初始化kettle环境
        if(!KettleEnvironment.isInitialized()){
            KettleEnvironment.init();
        }
        //创建资源库对象
        repository = new KettleDatabaseRepository();
        //创建资源库数据库对象，类似我们在spoon里面创建资源库
        DatabaseMeta dataMeta = new DatabaseMeta(name, type, access, host, db, port, user, pass);
        //资源库元对象
        KettleDatabaseRepositoryMeta kettleDatabaseMeta =
                new KettleDatabaseRepositoryMeta(id, repName, description, dataMeta);
        //给资源库赋值
        repository.init(kettleDatabaseMeta);
        log.info(repository.getName()+"资源库初始化成功");
        return repository;
    }

    /**
     * connect:连接资源库. <br/>
     * @author jingma
     * @return 连接后的资源库
     * @throws KettleSecurityException
     * @throws KettleException
     * @since JDK 1.6
     */
    public static AbstractRepository connect() throws KettleSecurityException, KettleException{
        return connect(null,null);
    }

    /**
     * connect:连接资源库. <br/>
     * @author jingma
     * @param username 资源库用户名
     * @param password 资源库密码
     * @return 连接后的资源库
     * @throws KettleSecurityException
     * @throws KettleException
     * @since JDK 1.6
     */
    public static AbstractRepository connect(String username,String password) throws KettleSecurityException, KettleException{
        repository.connect(username, password);
        log.info(repository.getName()+"资源库连接成功");
        return repository;
    }

    /**
     * setRepository:设置资源库. <br/>
     * @author jingma
     * @param repository 外部注入资源库
     * @since JDK 1.6
     */
    public static void setRepository(AbstractRepository repository){
        KettleUtils.repository = repository;
    }

    /**
     * destroy:释放资源库. <br/>
     * @author jingma
     * @since JDK 1.6
     */
    public static void destroy(){
        if(repository!=null){
            repository.disconnect();
            log.info(repository.getName()+"资源库释放成功");
        }
    }

    /**
     * loadJob:通过id加载job. <br/>
     * @author jingma
     * @param jobId 数字型job的id，数据库资源库时用此方法
     * @return job元数据
     * @throws KettleException
     * @since JDK 1.6
     */
    public static JobMeta loadJob(long jobId) throws KettleException {
        return repository.loadJob(new LongObjectId(jobId), null);
    }

    /**
     * loadJob:通过id加载job. <br/>
     * @author jingma
     * @param jobId 字符串job的id，文件资源库时用此方法
     * @return job元数据
     * @throws KettleException
     * @since JDK 1.6
     */
    public static JobMeta loadJob(String jobId) throws KettleException {
        return repository.loadJob(new StringObjectId(jobId), null);
    }

    /**
     * loadTrans:加载作业. <br/>
     * @author jingma
     * @param jobname 作业名称
     * @param directory 作业路径
     * @return 作业元数据
     * @since JDK 1.6
     */
    public static JobMeta loadJob(String jobname, String directory) {
        return loadJob(jobname, directory, repository);
    }
    /**
     * loadTrans:加载作业. <br/>
     * @author jingma
     * @param jobname 作业名称
     * @param directory 作业路径
     * @param repository 资源库
     * @return 作业元数据
     * @since JDK 1.6
     */
    public static JobMeta loadJob(String jobname, String directory,AbstractRepository repository) {
        try {
            RepositoryDirectoryInterface dir = repository.findDirectory(directory);
            return repository.loadJob(jobname,dir,null, null);
        } catch (KettleException e) {
            log.error("获取作业失败,jobname:"+jobname+",directory:"+directory, e);
        }
        return null;
    }

    /**
     * loadTrans:加载转换. <br/>
     * @author jingma
     * @param transname 转换名称
     * @param directory 转换路径
     * @return 转换元数据
     * @since JDK 1.6
     */
    public static TransMeta loadTrans(String transname, String directory) {
        return loadTrans(transname, directory, repository);
    }

    /**
     * loadTrans:加载转换. <br/>
     * @author jingma
     * @param transname 转换名称
     * @param directory 转换路径
     * @param repository 资源库
     * @return 转换元数据
     * @since JDK 1.6
     */
    public static TransMeta loadTrans(String transname, String directory,AbstractRepository repository) {
        try {
            RepositoryDirectoryInterface dir = repository.findDirectory(directory);
            return repository.loadTransformation( transname, dir, null, true, null);
        } catch (KettleException e) {
            log.error("获取转换失败,transname:"+transname+",directory:"+directory, e);
        }
        return null;
    }

    /**
     * loadTrans:根据job元数据获取指定转换元数据. <br/>
     * @author jingma
     * @param jobMeta job元数据
     * @param teansName 转换名称
     * @return 转换元数据
     * @since JDK 1.6
     */
    public static TransMeta loadTrans(JobMeta jobMeta, String teansName) {
        JobEntryTrans trans = (JobEntryTrans)(jobMeta.findJobEntry(teansName).getEntry());
        TransMeta transMeta = KettleUtils.loadTrans(trans.getTransname(), trans.getDirectory());
        return transMeta;
    }

    /**
     * 根据转换元数据和步骤名称获取具体的步骤元数据的复制. <br/>
     * 一般是不需要这用这个方法的，该方法获取的实体不属于该转换，相当于一个复制 ，修改了直接保存transMeta是没有保存到修改的。<br/>
     * 若需要修改转换，可以使用：(T)transMeta.findStep(stepName).getStepMetaInterface()，
     * 这个方法获取的步骤是属于该转换的，修改后，直接保存transMeta就能实现转换修改<br/>
     * @author jingma
     * @param transMeta 转换元数据
     * @param stepName 步骤名称
     * @param stepMeta 具体的步骤元数据对象
     * @return 从资源库获取具体数据的步骤元数据
     * @since JDK 1.6
     */
    public static <T extends BaseStepMeta> T loadStep(TransMeta transMeta, String stepName,
            T stepMeta) {
        StepMeta step = transMeta.findStep(stepName);
        try {
            stepMeta.readRep(KettleUtils.getInstanceRep(), null, step.getObjectId(), KettleUtils.getInstanceRep().readDatabases());
        } catch (KettleException e) {
            log.error("获取步骤失败", e);
        }
        return stepMeta;
    }
    /**
    * 根据作业元数据和作业实体名称获取具体的作业实体元数据的复制。<br/>
    * 一般是不需要这用这个方法的，该方法获取的实体不属于该job了，相当于一个复制 ，修改了直接保存jobMeta是没有保存到修改的。<br/>
    * 若需要修改job，可以使用：(T)jobMeta.findJobEntry(jobEntryName).getEntry()，
    * 这个方法获取的实体是属于job，修改后，直接保存jobMeta就能实现job修改<br/>
    * @author jingma
    * @param jobMeta 作业元数据
    * @param jobEntryName 作业实体名称
    * @param jobEntryMeta 要获取的作业实体对象
    * @return 加载了数据的作业实体对象
    */
    public static <T extends JobEntryBase> T loadJobEntry(JobMeta jobMeta, String jobEntryName,
            T jobEntryMeta) {
        try {
            jobEntryMeta.loadRep(KettleUtils.getInstanceRep(), null,
                    jobMeta.findJobEntry(jobEntryName).getEntry().getObjectId(),
                    KettleUtils.getInstanceRep().readDatabases(),null);
        } catch (KettleException e) {
            log.error("获取作业控件失败", e);
        }
        return jobEntryMeta;
    }

    /**
     * saveTrans:保存转换. <br/>
     * @author jingma
     * @param transMeta 转换元数据
     * @throws KettleException
     * @since JDK 1.6
     */
    public static void saveTrans(TransMeta transMeta) throws KettleException {
//        repository.save(transMeta, null, new RepositoryImporter(repository), true );
        repository.save(transMeta, null, null, true );
    }

    /**
     * saveJob:保存job. <br/>
     * @author jingma
     * @param jobMeta job元数据
     * @throws KettleException
     * @since JDK 1.6
     */
    public static void saveJob(JobMeta jobMeta) throws KettleException {
//        repository.save(jobMeta, null, new RepositoryImporter(repository), true );
        repository.save(jobMeta, null, null, true );
    }

    /**
     * isDirectoryExist:判断指定的job目录是否存在. <br/>
     * @author jingma
     * @param directoryName
     * @return
     * @since JDK 1.6
     */
    public static boolean isDirectoryExist(String directoryName) {
        try {
            RepositoryDirectoryInterface dir = repository.findDirectory(directoryName);
            if(dir==null){
                return false;
            }else{
                return true;
            }
        } catch (KettleException e) {
            log.error("判断job目录是否存在失败！",e);
        }
        return false;
    }

    /**
    * 将步骤smi设置到转换trans中<br/>
    * @author jingma
    * @param teans 转换元数据
    * @param stepName 步骤名称
    * @param smi 步骤
    */
    public static void setStepToTrans(TransMeta teans, String stepName, StepMetaInterface smi) {
        try {
            StepMeta step = teans.findStep(stepName);
            step.setStepMetaInterface(smi);
        } catch (Exception e) {
            log.error("将步骤smi设置到转换trans中-失败",e);
        }
    }

    /**
    * 将步骤smi设置到转换trans中并保存到资源库 <br/>
    * @author jingma
    * @param teans 转换元数据
    * @param stepName 步骤名称
    * @param smi 步骤
    */
    public static void setStepToTransAndSave(TransMeta teans, String stepName, StepMetaInterface smi) {
        setStepToTrans( teans, stepName, smi);
        try {
            KettleUtils.saveTrans(teans);
        } catch (KettleException e) {
            log.error("将步骤smi设置到转换trans中并保存到资源库-失败",e);
        }
    }

    /**
    * 步骤数据预览 <br/>
    * @author jingma
    * @param teans 转换
    * @param testStep 步骤名称
    * @param smi 步骤实体
    * @param previewSize 预览的条数
    * @return 预览结果
    */
    public static List<List<Object>> stepPreview(TransMeta teans,
            String testStep, StepMetaInterface smi, int previewSize) {
        TransMeta previewMeta = TransPreviewFactory.generatePreviewTransformation(
                teans,
                smi,
                testStep);
        TransPreviewUtil tpu = new TransPreviewUtil(
                previewMeta,
                new String[] { testStep },
                new int[] { previewSize } );
        tpu.doPreview();
        return TransPreviewUtil.getData(tpu.getPreviewRowsMeta(testStep),tpu.getPreviewRows(testStep));
    }

    /**
    * 将指定job复制到KettleUtils中的资源库 <br/>
    * @author jingma
    * @param jobName job名称
    * @param jobPath job路径
    * @param repository 来源资源库
    * @throws KettleException
    */
    public static void jobCopy(String jobName,String jobPath,AbstractRepository repository) throws KettleException {
        JobMeta jobMeta = KettleUtils.loadJob(jobName,jobPath,repository);
        for(JobEntryCopy jec:jobMeta.getJobCopies()){
            if(jec.isTransformation()){
                JobEntryTrans jet = (JobEntryTrans)jec.getEntry();
                transCopy(jet.getObjectName(), jet.getDirectory(),repository);
            }else if(jec.isJob()){
                JobEntryJob jej = (JobEntryJob)jec.getEntry();
                jobCopy(jej.getObjectName(),jej.getDirectory(),repository);
            }
        }
        jobMeta.setRepository(KettleUtils.getInstanceRep());
        jobMeta.setMetaStore(KettleUtils.getInstanceRep().getMetaStore());
        if(!isDirectoryExist(jobPath)){
            //所在目录不存在则创建
            KettleUtils.repository.createRepositoryDirectory(KettleUtils.repository.findDirectory("/"), jobPath);
        }
        KettleUtils.saveJob(jobMeta);
    }

    /**
    * 将指定转换复制到KettleUtils中的资源库 <br/>
    * @author jingma
    * @param jobName 转换名称
    * @param jobPath 转换路径
    * @param repository 来源资源库
    * @throws KettleException
    */
    public static void transCopy(String transName,String transPath,AbstractRepository repository) throws KettleException {
        TransMeta tm = KettleUtils.loadTrans(transName, transPath, repository);
        for(StepMeta sm:tm.getSteps()){
            if(sm.isJobExecutor()){
                JobExecutorMeta jem = (JobExecutorMeta)sm.getStepMetaInterface();
                jobCopy(jem.getJobName(),jem.getDirectoryPath(),repository);
            }
            else if(sm.getStepMetaInterface() instanceof TransExecutorMeta){
                TransExecutorMeta te = (TransExecutorMeta)sm.getStepMetaInterface();
                transCopy(te.getTransName(), te.getDirectoryPath(),repository);
            }
        }
        if(!isDirectoryExist(transPath)){
            //所在目录不存在则创建
            KettleUtils.repository.createRepositoryDirectory(KettleUtils.repository.findDirectory("/"), transPath);
        }
        tm.setRepository(KettleUtils.getInstanceRep());
        tm.setMetaStore(KettleUtils.getInstanceRep().getMetaStore());
        KettleUtils.saveTrans(tm);
    }

    /**
     * @return transMetaTemplate
     */
    public static TransMeta getTransMetaTemplate() {
//        if(transMetaTemplate==null){
//            setTransMetaTemplate(KettleUtils.loadTrans(SysCode.TRANS_TEMPLATE_NAME, SysCode.TEMPLATE_DIR));
//        }
        return transMetaTemplate;
    }

    /**
     * @param transMetaTemplate the transMetaTemplate to set
     */
    public static void setTransMetaTemplate(TransMeta transMetaTemplate) {
        KettleUtils.transMetaTemplate = transMetaTemplate;
    }

    /**
     * @return jobMetaTemplate
     */
    public static JobMeta getJobMetaTemplate() {
//        if(jobMetaTemplate==null){
//            setJobMetaTemplate(KettleUtils.loadJob(SysCode.JOB_TEMPLATE_NAME, SysCode.TEMPLATE_DIR));
//        }
        return jobMetaTemplate;
    }

    /**
     * @param jobMetaTemplate the jobMetaTemplate to set
     */
    public static void setJobMetaTemplate(JobMeta jobMetaTemplate) {
        KettleUtils.jobMetaTemplate = jobMetaTemplate;
    }

}

上面就是我定制化开发中编写的工具类，基本是一个独立可用的类，里面的模版jobMetaTemplate、transMetaTemplate可用删除，也可以根据需要使用。其中的步骤预览功能需要依赖另外一个类，这个类是我从kettleUI层提取出来并做了修改的，这里贴出代码吧：

/*! ******************************************************************************
 *
 * Pentaho Data Integration
 *
 * Copyright (C) 2002-2013 by Pentaho : http://www.pentaho.com
 *
 *******************************************************************************
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with
 * the License. You may obtain a copy of the License at
 *
 *    http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 ******************************************************************************/

package com.iflytek.kettle.utils;

import java.util.ArrayList;
import java.util.List;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.pentaho.di.core.Const;
import org.pentaho.di.core.exception.KettleException;
import org.pentaho.di.core.exception.KettleValueException;
import org.pentaho.di.core.logging.KettleLogStore;
import org.pentaho.di.core.row.RowMetaInterface;
import org.pentaho.di.core.row.ValueMetaInterface;
import org.pentaho.di.trans.Trans;
import org.pentaho.di.trans.TransMeta;
import org.pentaho.di.trans.debug.BreakPointListener;
import org.pentaho.di.trans.debug.StepDebugMeta;
import org.pentaho.di.trans.debug.TransDebugMeta;
import org.pentaho.di.trans.step.StepMeta;

/**
 * Takes care of displaying a dialog that will handle the wait while previewing a transformation...
 *
 * @author Matt
 * @since 13-jan-2006
 */
public class TransPreviewUtil {
  public static final int MAX_BINARY_STRING_PREVIEW_SIZE = 1000000;
  private static Log log = LogFactory.getLog(TransPreviewUtil.class);
  private TransMeta transMeta;
  private String[] previewStepNames;
  private int[] previewSize;
  private Trans trans;

  private boolean cancelled;
  private String loggingText;
  private TransDebugMeta transDebugMeta;

  /**
   * Creates a new dialog that will handle the wait while previewing a transformation...
   */
  public TransPreviewUtil( TransMeta transMeta, String[] previewStepNames, int[] previewSize ) {
    this.transMeta = transMeta;
    this.previewStepNames = previewStepNames;
    this.previewSize = previewSize;

    cancelled = false;
  }

  public void doPreview() {
    // This transformation is ready to run in preview!
    trans = new Trans( transMeta );

    // Prepare the execution...
    //
    try {
      trans.prepareExecution( null );
    } catch ( final KettleException e ) {
        log.error("", e);
      return;
    }

    // Add the preview / debugging information...
    //
    transDebugMeta = new TransDebugMeta( transMeta );
    for ( int i = 0; i < previewStepNames.length; i++ ) {
      StepMeta stepMeta = transMeta.findStep( previewStepNames[i] );
      StepDebugMeta stepDebugMeta = new StepDebugMeta( stepMeta );
      stepDebugMeta.setReadingFirstRows( true );
      stepDebugMeta.setRowCount( previewSize[i] );
      transDebugMeta.getStepDebugMetaMap().put( stepMeta, stepDebugMeta );
    }

    // set the appropriate listeners on the transformation...
    //
    transDebugMeta.addRowListenersToTransformation( trans );

    // Fire off the step threads... start running!
    //
    try {
      trans.startThreads();
    } catch ( final KettleException e ) {
        log.error("", e);
      // It makes no sense to continue, so just stop running...
      //
      return;
    }

    final List<String> previewComplete = new ArrayList<String>();

    while ( previewComplete.size() < previewStepNames.length
      && !trans.isFinished() ) {
      // We add a break-point that is called every time we have a step with a full preview row buffer
      // That makes it easy and fast to see if we have all the rows we need
      //
      transDebugMeta.addBreakPointListers( new BreakPointListener() {
        public void breakPointHit( TransDebugMeta transDebugMeta, StepDebugMeta stepDebugMeta,
          RowMetaInterface rowBufferMeta, List<Object[]> rowBuffer ) {
          String stepName = stepDebugMeta.getStepMeta().getName();
          previewComplete.add( stepName );
        }
      } );

      // Change the percentage...
      try {
        Thread.sleep( 500 );
      } catch ( InterruptedException e ) {
          log.error("", e);
        // Ignore errors
      }

    }

    trans.stopAll();

    // Capture preview activity to a String:
    loggingText =
      KettleLogStore.getAppender().getBuffer( trans.getLogChannel().getLogChannelId(), true ).toString();

  }

  /**
   * @param stepname
   *          the name of the step to get the preview rows for
   * @return A list of rows as the result of the preview run.
   */
  public List<Object[]> getPreviewRows( String stepname ) {
    if ( transDebugMeta == null ) {
      return null;
    }

    for ( StepMeta stepMeta : transDebugMeta.getStepDebugMetaMap().keySet() ) {
      if ( stepMeta.getName().equals( stepname ) ) {
        StepDebugMeta stepDebugMeta = transDebugMeta.getStepDebugMetaMap().get( stepMeta );
        return stepDebugMeta.getRowBuffer();
      }
    }
    return null;
  }

  /**
   * @param stepname
   *          the name of the step to get the preview rows for
   * @return A description of the row (metadata)
   */
  public RowMetaInterface getPreviewRowsMeta( String stepname ) {
    if ( transDebugMeta == null ) {
      return null;
    }

    for ( StepMeta stepMeta : transDebugMeta.getStepDebugMetaMap().keySet() ) {
      if ( stepMeta.getName().equals( stepname ) ) {
        StepDebugMeta stepDebugMeta = transDebugMeta.getStepDebugMetaMap().get( stepMeta );
        return stepDebugMeta.getRowBufferMeta();
      }
    }
    return null;
  }

  /**
   * @return true is the preview was canceled by the user
   */
  public boolean isCancelled() {
    return cancelled;
  }

  /**
   * @return The logging text from the latest preview run
   */
  public String getLoggingText() {
    return loggingText;
  }

  /**
   *
   * @return The transformation object that executed the preview TransMeta
   */
  public Trans getTrans() {
    return trans;
  }

  /**
   * @return the transDebugMeta
   */
  public TransDebugMeta getTransDebugMeta() {
    return transDebugMeta;
  }

  /**
   * Copy information from the meta-data input to the dialog fields.
 * @param rowMetaInterface
   */
  public static List<List<Object>> getData(RowMetaInterface rowMeta, List<Object[]> buffer) {
    List<List<Object>> result = new ArrayList<List<Object>>();
    List<Object> row1 = new ArrayList<Object>();
    for ( int i = 0; i < buffer.size(); i++ ) {
      row1 = new ArrayList<Object>();
      Object[] row = buffer.get( i );
      getDataForRow( rowMeta, row1, row );
      result.add(row1);
    }
    return result;
  }

  public static int getDataForRow( RowMetaInterface rowMeta, List<Object> row1, Object[] row ) {
    int nrErrors = 0;

    // Display the correct line item...
    //
    for ( int c = 0; c < rowMeta.size(); c++ ) {
      ValueMetaInterface v = rowMeta.getValueMeta( c );
      String show;
      try {
        show = v.getString( row[c] );
        if ( v.isBinary() && show != null && show.length() > MAX_BINARY_STRING_PREVIEW_SIZE ) {
          // We want to limit the size of the strings during preview to keep all SWT widgets happy.
          //
          show = show.substring( 0, MAX_BINARY_STRING_PREVIEW_SIZE );
        }
      } catch ( KettleValueException e ) {
        nrErrors++;
        if ( nrErrors < 25 ) {
          log.error( Const.getStackTracker( e ) );
        }
        show = null;
      } catch ( ArrayIndexOutOfBoundsException e ) {
        nrErrors++;
        if ( nrErrors < 25 ) {
          log.error( Const.getStackTracker( e ) );
        }
        show = null;
      }

      if ( show != null ) {
          row1.add(show);
      } else {
        // Set null value
          row1.add("<null>");
      }
    }

    return nrErrors;

  }
}

以上两个类复制到自己项目中就可以用了，这个工具类是根据我自己需求编写的，根据使用场景不同，你也可以添加其他方法，丰富该类的功能。

关于使用示例，本来也想贴出来的，但相关代码依赖较多，同时工具类本身注释很详细，方法体很小，自己看一遍就能了解个大概，所以这里就不提供使用示例代码，希望对有需要的人有所帮助。