Java PluginRegistry.getPlugin方法代码示例

import org.pentaho.di.core.plugins.PluginRegistry; //导入方法依赖的package包/类
public JobEntryDialogInterface getJobEntryDialog(JobEntryInterface jobEntryInterface, JobMeta jobMeta)
{
	PluginRegistry registry = PluginRegistry.getInstance();
	String dialogClassName = jobEntryInterface.getDialogClassName();
	try
	{
		Class<?> dialogClass;
		Class<?>[] paramClasses = new Class[] { spoon.getShell().getClass(), JobEntryInterface.class,
				Repository.class, JobMeta.class };
		Object[] paramArgs = new Object[] { spoon.getShell(), jobEntryInterface, spoon.getRepository(), jobMeta };
		Constructor<?> dialogConstructor;
		
		PluginInterface plugin = registry.getPlugin(JobEntryPluginType.class, jobEntryInterface);
		dialogClass = PluginRegistry.getInstance().getClass(plugin, dialogClassName);
		dialogConstructor = dialogClass.getConstructor(paramClasses);
		return (JobEntryDialogInterface) dialogConstructor.newInstance(paramArgs);
	} catch (Throwable t)
	{
		t.printStackTrace();
		spoon.getLog().logError(spoon.toString(), "Could not create dialog for " + dialogClassName, t);
	}
	return null;
}
 

import org.pentaho.di.core.plugins.PluginRegistry; //导入方法依赖的package包/类
public static final RepositoryRevisionBrowserDialogInterface getVersionBrowserDialog(Shell shell, Repository repository, final RepositoryElementInterface element) throws Exception {
	
	String className = repository.getRepositoryMeta().getRevisionBrowserDialogClassName();
	PluginRegistry registry = PluginRegistry.getInstance();
	PluginInterface plugin = registry.getPlugin(RepositoryPluginType.class, repository.getRepositoryMeta().getId());
	Class<? extends RepositoryRevisionBrowserDialogInterface> dialogClass = registry.getClass(plugin, className);
	Constructor<?> constructor = dialogClass.getConstructor(Shell.class, Integer.TYPE, Repository.class, RepositoryElementInterface.class);
	return (RepositoryRevisionBrowserDialogInterface) constructor.newInstance(new Object[] { shell, Integer.valueOf(SWT.NONE), repository, element, });
}
 

import org.pentaho.di.core.plugins.PluginRegistry; //导入方法依赖的package包/类
/**
 * Search for the right type of DatabaseInterface object and return it.
 * 
 * @param databaseType the type of DatabaseInterface to look for (id or description)
 * @return The requested DatabaseInterface
 * 
 * @throws KettleDatabaseException when the type could not be found or referenced.
 */
private static final DatabaseInterface findDatabaseInterface(String databaseTypeDesc) throws KettleDatabaseException
{
	PluginRegistry registry = PluginRegistry.getInstance();
	PluginInterface plugin = registry.getPlugin(DatabasePluginType.class, databaseTypeDesc);
	if (plugin==null) {
		plugin = registry.findPluginWithName(DatabasePluginType.class, databaseTypeDesc); 
	}
	
	if (plugin==null) {
		throw new KettleDatabaseException("database type with plugin id ["+databaseTypeDesc+"] couldn't be found!");
	}
	
	return getDatabaseInterfacesMap().get(plugin.getIds()[0]);
}
 

import org.pentaho.di.core.plugins.PluginRegistry; //导入方法依赖的package包/类
public DatabaseFactoryInterface getDatabaseFactory() throws Exception
{
	PluginRegistry registry = PluginRegistry.getInstance();
	PluginInterface plugin = registry.getPlugin(DatabasePluginType.class, databaseInterface.getPluginId());
	if (plugin==null) {
		throw new KettleDatabaseException("database type with plugin id ["+databaseInterface.getPluginId()+"] couldn't be found!");
	}
	
	ClassLoader loader = registry.getClassLoader(plugin);
	
	Class<?> clazz = Class.forName(databaseInterface.getDatabaseFactoryName(),true,loader);
	return (DatabaseFactoryInterface)clazz.newInstance();
}
 

import org.pentaho.di.core.plugins.PluginRegistry; //导入方法依赖的package包/类
public static final RepositoryRevisionBrowserDialogInterface getVersionBrowserDialog( Shell shell,
  Repository repository, final RepositoryElementInterface element ) throws Exception {

  String className = repository.getRepositoryMeta().getRevisionBrowserDialogClassName();
  PluginRegistry registry = PluginRegistry.getInstance();
  PluginInterface plugin =
    registry.getPlugin( RepositoryPluginType.class, repository.getRepositoryMeta().getId() );
  Class<? extends RepositoryRevisionBrowserDialogInterface> dialogClass = registry.getClass( plugin, className );
  Constructor<?> constructor =
    dialogClass.getConstructor( Shell.class, Integer.TYPE, Repository.class, RepositoryElementInterface.class );
  return (RepositoryRevisionBrowserDialogInterface) constructor.newInstance( new Object[] {
    shell, Integer.valueOf( SWT.NONE ), repository, element, } );
}
 

import org.pentaho.di.core.plugins.PluginRegistry; //导入方法依赖的package包/类
public StepDialogInterface getStepDialog( StepMetaInterface stepMeta, TransMeta transMeta, String stepName ) throws KettleException {
  Class<?>[] paramClasses = new Class<?>[] { Shell.class, Object.class, TransMeta.class, String.class };
  Object[] paramArgs = new Object[] { spoon.getShell(), stepMeta, transMeta, stepName };

  PluginRegistry registry = PluginRegistry.getInstance();
  PluginInterface plugin = registry.getPlugin( StepPluginType.class, stepMeta );
  String dialogClassName = plugin.getClassMap().get( StepDialogInterface.class );
  if ( dialogClassName == null ) {
    // try the deprecated way
    log.logDebug( "Use of StepMetaInterface#getDialogClassName is deprecated, use StepDialog annotation instead." );
    dialogClassName = stepMeta.getDialogClassName();
  }

  try {
    Class<StepDialogInterface> dialogClass = registry.getClass( plugin, dialogClassName );
    Constructor<StepDialogInterface> dialogConstructor = dialogClass.getConstructor( paramClasses );
    return dialogConstructor.newInstance( paramArgs );
  } catch ( Exception e ) {
    // try the old way for compatibility
    try {
      Class<?>[] sig = new Class<?>[] { Shell.class, StepMetaInterface.class, TransMeta.class, String.class };
      Method method = stepMeta.getClass().getDeclaredMethod( "getDialog", sig );
      if ( method != null ) {
        log.logDebug( "Use of StepMetaInterface#getDialog is deprecated, use StepDialog annotation instead." );
        return (StepDialogInterface) method.invoke( stepMeta, paramArgs );
      }
    } catch ( Throwable ignored ) { }

    String errorTitle = BaseMessages.getString( PKG, "Spoon.Dialog.ErrorCreatingStepDialog.Title" );
    String errorMsg = BaseMessages.getString( PKG, "Spoon.Dialog.ErrorCreatingStepDialog.Message", dialogClassName );
    new ErrorDialog( spoon.getShell(), errorTitle, errorMsg, e );
    throw new KettleException( e );
  }
}
 

import org.pentaho.di.core.plugins.PluginRegistry; //导入方法依赖的package包/类
public JobEntryDialogInterface getJobEntryDialog( JobEntryInterface jobEntryInterface, JobMeta jobMeta ) {
  PluginRegistry registry = PluginRegistry.getInstance();
  String dialogClassName = jobEntryInterface.getDialogClassName();
  try {
    Class<?> dialogClass;
    Class<?>[] paramClasses =
      new Class<?>[] { spoon.getShell().getClass(), JobEntryInterface.class, Repository.class, JobMeta.class };
    Object[] paramArgs = new Object[] { spoon.getShell(), jobEntryInterface, spoon.getRepository(), jobMeta };
    Constructor<?> dialogConstructor;

    try {
      PluginInterface plugin = registry.getPlugin( JobEntryPluginType.class, jobEntryInterface );
      dialogClass = PluginRegistry.getInstance().getClass( plugin, dialogClassName );
    } catch ( Exception e ) {
      dialogClass = Class.forName( dialogClassName, true, jobEntryInterface.getClass().getClassLoader() );
    }
    dialogConstructor = dialogClass.getConstructor( paramClasses );
    JobEntryDialogInterface entryDialogInterface =
      (JobEntryDialogInterface) dialogConstructor.newInstance( paramArgs );
    entryDialogInterface.setMetaStore( spoon.getMetaStore() );
    return entryDialogInterface;
  } catch ( Throwable t ) {
    t.printStackTrace();
    spoon.getLog().logError( spoon.toString(), "Could not create dialog for " + dialogClassName, t );
    return null;
  }
}
 

import org.pentaho.di.core.plugins.PluginRegistry; //导入方法依赖的package包/类
/**
 * Search for the right type of DatabaseInterface object and return it.
 *
 * @param databaseTypeDesc
 *          the type of DatabaseInterface to look for (id or description)
 * @return The requested DatabaseInterface
 *
 * @throws KettleDatabaseException
 *           when the type could not be found or referenced.
 */
private static final DatabaseInterface findDatabaseInterface( String databaseTypeDesc ) throws KettleDatabaseException {
  PluginRegistry registry = PluginRegistry.getInstance();
  PluginInterface plugin = registry.getPlugin( DatabasePluginType.class, databaseTypeDesc );
  if ( plugin == null ) {
    plugin = registry.findPluginWithName( DatabasePluginType.class, databaseTypeDesc );
  }

  if ( plugin == null ) {
    throw new KettleDatabaseException( "database type with plugin id ["
      + databaseTypeDesc + "] couldn't be found!" );
  }

  return getDatabaseInterfacesMap().get( plugin.getIds()[0] );
}
 

import org.pentaho.di.core.plugins.PluginRegistry; //导入方法依赖的package包/类
public DatabaseFactoryInterface getDatabaseFactory() throws Exception {
  PluginRegistry registry = PluginRegistry.getInstance();
  PluginInterface plugin = registry.getPlugin( DatabasePluginType.class, databaseInterface.getPluginId() );
  if ( plugin == null ) {
    throw new KettleDatabaseException( "database type with plugin id ["
      + databaseInterface.getPluginId() + "] couldn't be found!" );
  }

  ClassLoader loader = registry.getClassLoader( plugin );

  Class<?> clazz = Class.forName( databaseInterface.getDatabaseFactoryName(), true, loader );
  return (DatabaseFactoryInterface) clazz.newInstance();
}