Java 类org.apache.commons.lang3.reflect.ConstructorUtils 实例源码

public PeriodicUpdateChecker create(final Controller controller) {
    final String clazz = PreferencesFactory.get().getProperty("factory.updater.class");
    if(null == clazz) {
        throw new FactoryException(String.format("No implementation given for factory %s", this.getClass().getSimpleName()));
    }
    try {
        final Class<PeriodicUpdateChecker> name = (Class<PeriodicUpdateChecker>) Class.forName(clazz);
        final Constructor<PeriodicUpdateChecker> constructor = ConstructorUtils.getMatchingAccessibleConstructor(name, controller.getClass());
        if(null == constructor) {
            log.warn(String.format("No matching constructor for parameter %s", controller.getClass()));
            // Call default constructor for disabled implementations
            return name.newInstance();
        }
        return constructor.newInstance(controller);
    }
    catch(InstantiationException | InvocationTargetException | ClassNotFoundException | IllegalAccessException e) {
        log.error(String.format("Failure loading callback class %s. %s", clazz, e.getMessage()));
        return new DisabledPeriodicUpdater();
    }
}

public LoginCallback create(final Controller controller) {
    final String clazz = PreferencesFactory.get().getProperty("factory.logincallback.class");
    if(null == clazz) {
        throw new FactoryException(String.format("No implementation given for factory %s", this.getClass().getSimpleName()));
    }
    try {
        final Class<LoginCallback> name = (Class<LoginCallback>) Class.forName(clazz);
        final Constructor<LoginCallback> constructor = ConstructorUtils.getMatchingAccessibleConstructor(name, controller.getClass());
        if(null == constructor) {
            log.warn(String.format("No matching constructor for parameter %s", controller.getClass()));
            // Call default constructor for disabled implementations
            return name.newInstance();
        }
        return constructor.newInstance(controller);
    }
    catch(InstantiationException | InvocationTargetException | ClassNotFoundException | IllegalAccessException e) {
        log.error(String.format("Failure loading callback class %s. %s", clazz, e.getMessage()));
        return new DisabledLoginCallback();
    }
}

public CertificateStore create(final Controller c) {
    final String clazz = PreferencesFactory.get().getProperty("factory.certificatestore.class");
    if(null == clazz) {
        throw new FactoryException(String.format("No implementation given for factory %s", this.getClass().getSimpleName()));
    }
    try {
        final Class<CertificateStore> name = (Class<CertificateStore>) Class.forName(clazz);
        final Constructor<CertificateStore> constructor = ConstructorUtils.getMatchingAccessibleConstructor(name, c.getClass());
        if(null == constructor) {
            log.warn(String.format("No matching constructor for parameter %s", c.getClass()));
            // Call default constructor for disabled implementations
            return name.newInstance();
        }
        return constructor.newInstance(c);
    }
    catch(InstantiationException | InvocationTargetException | ClassNotFoundException | IllegalAccessException e) {
        throw new FactoryException(e.getMessage(), e);
    }
}

public AlertCallback create(final Controller controller) {
    final String clazz = PreferencesFactory.get().getProperty("factory.alertcallback.class");
    if(null == clazz) {
        throw new FactoryException(String.format("No implementation given for factory %s", this.getClass().getSimpleName()));
    }
    try {
        final Class<AlertCallback> name = (Class<AlertCallback>) Class.forName(clazz);
        final Constructor<AlertCallback> constructor = ConstructorUtils.getMatchingAccessibleConstructor(name, controller.getClass());
        if(null == constructor) {
            log.warn(String.format("No matching constructor for parameter %s", controller.getClass()));
            // Call default constructor for disabled implementations
            return name.newInstance();
        }
        return constructor.newInstance(controller);
    }
    catch(InstantiationException | InvocationTargetException | ClassNotFoundException | IllegalAccessException e) {
        log.error(String.format("Failure loading callback class %s. %s", clazz, e.getMessage()));
        return new DisabledAlertCallback();
    }
}

public HostKeyCallback create(final Controller c, final Protocol protocol) {
    if(Scheme.sftp.equals(protocol.getScheme())) {
        final String clazz = PreferencesFactory.get().getProperty("factory.hostkeycallback.class");
        if(null == clazz) {
            throw new FactoryException(String.format("No implementation given for factory %s", this.getClass().getSimpleName()));
        }
        try {
            final Class<HostKeyCallback> name = (Class<HostKeyCallback>) Class.forName(clazz);
            final Constructor<HostKeyCallback> constructor = ConstructorUtils.getMatchingAccessibleConstructor(name, c.getClass());
            if(null == constructor) {
                log.warn(String.format("No matching constructor for parameter %s", c.getClass()));
                // Call default constructor for disabled implementations
                return name.newInstance();
            }
            return constructor.newInstance(c);
        }
        catch(InstantiationException | InvocationTargetException | ClassNotFoundException | IllegalAccessException e) {
            log.error(String.format("Failure loading callback class %s. %s", clazz, e.getMessage()));
            return new DisabledHostKeyCallback();
        }
    }
    return new DisabledHostKeyCallback();
}

private Vault create(final Path directory, final PasswordStore keychain) {
    final String clazz = PreferencesFactory.get().getProperty("factory.vault.class");
    if(null == clazz) {
        throw new FactoryException(String.format("No implementation given for factory %s", this.getClass().getSimpleName()));
    }
    try {
        final Class<Vault> name = (Class<Vault>) Class.forName(clazz);
        final Constructor<Vault> constructor = ConstructorUtils.getMatchingAccessibleConstructor(name,
                directory.getClass(), keychain.getClass());
        if(null == constructor) {
            log.warn(String.format("No matching constructor for parameter %s", directory.getClass()));
            // Call default constructor for disabled implementations
            return name.newInstance();
        }
        return constructor.newInstance(directory, keychain);
    }
    catch(InstantiationException | InvocationTargetException | ClassNotFoundException | IllegalAccessException e) {
        log.error(String.format("Failure loading callback class %s. %s", clazz, e.getMessage()));
        return Vault.DISABLED;
    }
}

public TransferErrorCallback create(final Controller c) {
    final String clazz = preferences.getProperty("factory.transfererrorcallback.class");
    if(null == clazz) {
        throw new FactoryException(String.format("No implementation given for factory %s", this.getClass().getSimpleName()));
    }
    try {
        final Class<TransferErrorCallback> name = (Class<TransferErrorCallback>) Class.forName(clazz);
        final Constructor<TransferErrorCallback> constructor = ConstructorUtils.getMatchingAccessibleConstructor(name, c.getClass());
        if(null == constructor) {
            log.warn(String.format("No matching constructor for parameter %s", c.getClass()));
            // Call default constructor for disabled implementations
            return name.newInstance();
        }
        return constructor.newInstance(c);
    }
    catch(InstantiationException | InvocationTargetException | ClassNotFoundException | IllegalAccessException e) {
        log.error(String.format("Failure loading callback class %s. %s", clazz, e.getMessage()));
        return new DisabledTransferErrorCallback();
    }
}

/**
 * @param size    Maximum pool size
 * @param handler Uncaught thread exception handler
 */
protected ThreadPool create(final String prefix, final Integer size, final Thread.UncaughtExceptionHandler handler) {
    final String clazz = PreferencesFactory.get().getProperty("factory.threadpool.class");
    if(null == clazz) {
        throw new FactoryException(String.format("No implementation given for factory %s", this.getClass().getSimpleName()));
    }
    try {
        final Class<ThreadPool> name = (Class<ThreadPool>) Class.forName(clazz);
        final Constructor<ThreadPool> constructor = ConstructorUtils.getMatchingAccessibleConstructor(name,
                prefix.getClass(), size.getClass(), handler.getClass());
        if(null == constructor) {
            log.warn(String.format("No matching constructor for parameter %s", handler.getClass()));
            // Call default constructor for disabled implementations
            return name.newInstance();
        }
        return constructor.newInstance(prefix, size, handler);
    }
    catch(InstantiationException | InvocationTargetException | ClassNotFoundException | IllegalAccessException e) {
        throw new FactoryException(e.getMessage(), e);
    }
}

public PasswordCallback create(final Controller controller) {
    final String clazz = PreferencesFactory.get().getProperty("factory.passwordcallback.class");
    if(null == clazz) {
        throw new FactoryException(String.format("No implementation given for factory %s", this.getClass().getSimpleName()));
    }
    try {
        final Class<PasswordCallback> name = (Class<PasswordCallback>) Class.forName(clazz);
        final Constructor<PasswordCallback> constructor = ConstructorUtils.getMatchingAccessibleConstructor(name, controller.getClass());
        if(null == constructor) {
            log.warn(String.format("No matching constructor for parameter %s", controller.getClass()));
            // Call default constructor for disabled implementations
            return name.newInstance();
        }
        return constructor.newInstance(controller);
    }
    catch(InstantiationException | InvocationTargetException | ClassNotFoundException | IllegalAccessException e) {
        log.error(String.format("Failure loading callback class %s. %s", clazz, e.getMessage()));
        return new DisabledPasswordCallback();
    }
}

@Override
public <P extends Packet, A> P createPacket(PacketType<P, A> type, A param) {
    if(type.getSide() == PacketSide.SERVERBOUND) {
        throw new IllegalArgumentException("You can't initialize a serverbound packet");
    }

    PacketFactory<P, A> factory = ((PacketControlType<P, A>)type).getFactory();

    if(factory != null) {
        return factory.create(param);
    }

    try {
        return ConstructorUtils.invokeConstructor(type.getPacketClass(), param);
    } catch(Exception ex) {
        throw new RuntimeException("There was an issue constructing " + type.getName(), ex);
    }
}

@NotNull
public ObjectReader getObjectReader() {
    if (reader == null) {
        if (TomcatStandardSessionObjectReader.class.getName().equals(getObjectReaderClassName())) {
            reader = getTomcatStandardSessionObjectReader();
        } else {
            try {
                reader = (ObjectReader) ConstructorUtils.invokeConstructor(
                        Class.forName(getObjectReaderClassName()));
            } catch (ReflectiveOperationException e) {
                throw new IllegalArgumentException("Unable to construct ObjectReader class [" +
                        getObjectReaderClassName() + "]", e);
            }
        }
    }
    return reader;
}

@Nullable
public InputStreamTransformer getInputStreamTransformer() {
    InputStreamTransformer result;
    if (getInputStreamTransformerClassName() == null) {
        result = null;
    } else {
        try {
            result = (InputStreamTransformer) ConstructorUtils.invokeConstructor(
                    Class.forName(getInputStreamTransformerClassName()));
        } catch (ReflectiveOperationException e) {
            throw new IllegalArgumentException("Could not construct specified transformer [" +
                    getInputStreamTransformerClassName() + "]", e);
        }
    }
    return result;
}

/**
 * Constructs MIME content factory from a given class and constructor arguments.
 * 
 * @param factoryClass MIME content factory class of which should be constructed the instance.
 * @param args Constructor arguments for factory.
 * @return Constructed MIME content factory on success, otherwise null.
 */
protected MimeContentFactory instantizeMimeContentFactory(Class<? extends MimeContentFactory> factoryClass, Object ...args) {
    MimeContentFactory mimeContentFactory = null;

    try {
        /*List<Class<?>> constructorClassesList = new ArrayList<Class<?>>();

        for (Object arg : args) {
            constructorClassesList.add(arg.getClass());
        }

        Class<?> constructorClasses[] = constructorClassesList.toArray(new Class<?>[constructorClassesList.size()]);

        Constructor<? extends MimeContentFactoryBase<?>> mimeContentFactoryConstructor = factoryClass.getConstructor(constructorClasses);
        mimeContentFactory = mimeContentFactoryConstructor.newInstance(args);*/

        Object newInstance = ConstructorUtils.invokeConstructor(factoryClass, args);
        mimeContentFactory = factoryClass.cast(newInstance);

    } catch (Exception e) {
        e.printStackTrace();
    }

    return mimeContentFactory;
}

protected T buildInitializer(Supplier<T> defaultSupplier, Object ... args) {
    List<String> initClassNames = SpringFactoriesLoader.loadFactoryNames(initClass, Thread.currentThread().getContextClassLoader());

    if (initClassNames.isEmpty()) {
        return defaultSupplier.get();
    }

    List<Class<?>> initClasses = ClassUtils.convertClassNamesToClasses(initClassNames);

    initClasses.sort(AnnotationAwareOrderComparator.INSTANCE);

    Class<?> primaryInitClass = initClasses.get(0);

    try {
        return this.initClass.cast(ConstructorUtils.invokeConstructor(primaryInitClass, args));
    } catch (IllegalAccessException | InstantiationException | InvocationTargetException | NoSuchMethodException e) {
        throw new ApplicationContextException(String.format("Unable to instantiate application initializer (class=%s).", primaryInitClass.getName()), e);
    }
}

@Override
public void init() {
    SdcctBeanDefinitionParser beanDefParser;

    for (Class<?> beanDefClass : ClassUtils
        .convertClassNamesToClasses(SpringFactoriesLoader.loadFactoryNames(SdcctBeanDefinitionParser.class, this.getClass().getClassLoader()))) {
        try {
            beanDefParser = ((SdcctBeanDefinitionParser) ConstructorUtils.invokeConstructor(beanDefClass, this));
        } catch (IllegalAccessException | InstantiationException | InvocationTargetException | NoSuchMethodException e) {
            throw new ApplicationContextException(String.format("Unable to instantiate bean definition parser (class=%s).", beanDefClass.getName()), e);
        }

        for (String beanDefParserElemLocalName : beanDefParser.getElementBeanClasses().keySet()) {
            this.beanDefParsers.put(beanDefParserElemLocalName, beanDefParser);

            this.registerBeanDefinitionParser(beanDefParserElemLocalName, beanDefParser);
        }
    }
}

@Override
public synchronized Generator<T> getGenerator() {

    if (isSharedInstance && theSharedInstance != null) {
        return theSharedInstance;
    }

    generatorClass = (Class<Generator<T>>) getGeneratorClass(generatorSpec);

    try {
        Generator<T> generator = ConstructorUtils.invokeConstructor(generatorClass, generatorArgs);
        if (isSharedInstance) {
            theSharedInstance = generator;
            return theSharedInstance;
        }
        return generator;
    } catch (Exception e) {
        logger.error(e.getMessage());
        throw new RuntimeException(e);
    }

}

protected static <T> T buildComponent(Class<T> componentClass, Supplier<T> defaultSupplier, Object ... args) {
    List<String> componentClassNames = SpringFactoriesLoader.loadFactoryNames(componentClass, AbstractCrigttApplicationRunListener.class.getClassLoader());

    if (componentClassNames.isEmpty()) {
        return defaultSupplier.get();
    }

    List<Class<?>> componentClasses = ClassUtils.convertClassNamesToClasses(componentClassNames);

    componentClasses.sort(AnnotationAwareOrderComparator.INSTANCE);

    Class<?> primaryComponentClass = componentClasses.get(0);

    try {
        return componentClass.cast(ConstructorUtils.invokeConstructor(primaryComponentClass, args));
    } catch (IllegalAccessException | InstantiationException | InvocationTargetException | NoSuchMethodException e) {
        throw new ApplicationContextException(String.format("Unable to instantiate component (class=%s).", primaryComponentClass.getName()), e);
    }
}

/**
 * Create a new {@link AuditSink} using the alias or cannonical classname specified at {@value #AUDIT_SINK_CLASS_NAME_KEY} in the <code>config</code>
 * The {@link AuditSink} class MUST have an accessible constructor <code>abc(Config config, TableMetadata tableMetadata)</code>
 * <br>
 * If {@value #AUDIT_SINK_CLASS_NAME_KEY} is not set in <code>config</code>, a default {@link #DEFAULT_AUDIT_SINK_CLASS} is used
 *
 * @param config job configs
 * @param auditRuntimeMetadata runtime table metadata
 *
 * @return a new instance of {@link AuditSink}
 */
public AuditSink create(Config config, ValueAuditRuntimeMetadata auditRuntimeMetadata) {

  String sinkClassName = DEFAULT_AUDIT_SINK_CLASS;
  if (config.hasPath(AUDIT_SINK_CLASS_NAME_KEY)) {
    sinkClassName = config.getString(AUDIT_SINK_CLASS_NAME_KEY);
  }
  log.info("Using audit sink class name/alias " + sinkClassName);

  try {
    return (AuditSink)ConstructorUtils.invokeConstructor(Class.forName(this.aliasResolver.resolve(
        sinkClassName)), config, auditRuntimeMetadata);
  } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException | InstantiationException
      | ClassNotFoundException e) {
    throw new RuntimeException(e);
  }
}

@Override
public Optional<CompactorListener> createCompactorListener(Properties properties)
    throws CompactorListenerCreationException {
  State state = new State(properties);

  if (Strings.isNullOrEmpty(state.getProp(COMPACTOR_LISTENERS))) {
    return Optional.absent();
  }

  List<CompactorListener> listeners = new ArrayList<>();
  for (String listenerClassName : state.getPropAsList(COMPACTOR_LISTENERS)) {
    try {
      listeners.add((CompactorListener) ConstructorUtils
          .invokeConstructor(Class.forName(listenerClassName), properties));
    } catch (ReflectiveOperationException e) {
      throw new CompactorListenerCreationException(String
          .format("Unable to create CompactorListeners from key \"%s\" with value \"%s\"", COMPACTOR_LISTENERS,
              properties.getProperty(COMPACTOR_LISTENERS)), e);
    }
  }
  return Optional.<CompactorListener>of(new SerialCompactorListener(listeners));
}

/**
 * Convenience method on top of {@link ConstructorUtils#invokeConstructor(Class, Object[])} that returns a new
 * instance of the <code>cls</code> based on a constructor priority order. Each {@link List} in the
 * <code>constructorArgs</code> array contains the arguments for a constructor of <code>cls</code>. The first
 * constructor whose signature matches the argument types will be invoked.
 *
 * @param cls the class to be instantiated
 * @param constructorArgs An array of constructor argument list. Order defines the priority of a constructor.
 * @return
 *
 * @throws NoSuchMethodException if no constructor matched was found
 */
@SafeVarargs
public static <T> T invokeFirstConstructor(Class<T> cls, List<Object>... constructorArgs)
    throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {

  for (List<Object> args : constructorArgs) {

    Class<?>[] parameterTypes = new Class[args.size()];
    for (int i = 0; i < args.size(); i++) {
      parameterTypes[i] = args.get(i).getClass();
    }

    if (ConstructorUtils.getMatchingAccessibleConstructor(cls, parameterTypes) != null) {
      return ConstructorUtils.invokeConstructor(cls, args.toArray(new Object[args.size()]));
    }
  }
  throw new NoSuchMethodException("No accessible constructor found");
}

/**
 * Returns a new instance of the <code>cls</code> based on a set of arguments. The method will search for a
 * constructor accepting the first k arguments in <code>args</code> for every k from args.length to 0, and will
 * invoke the first constructor found.
 *
 * For example, {@link #invokeLongestConstructor}(cls, myString, myInt) will first attempt to create an object with
 * of class <code>cls</code> with constructor <init>(String, int), if it fails it will attempt <init>(String), and
 * finally <init>().
 *
 * @param cls the class to instantiate.
 * @param args the arguments to use for instantiation.
 * @throws ReflectiveOperationException
 */
public static <T> T invokeLongestConstructor(Class<T> cls, Object... args) throws ReflectiveOperationException {

  Class<?>[] parameterTypes = new Class[args.length];
  for (int i = 0; i < args.length; i++) {
    parameterTypes[i] = args[i].getClass();
  }

  for (int i = args.length; i >= 0; i--) {
    if (ConstructorUtils.getMatchingAccessibleConstructor(cls, Arrays.copyOfRange(parameterTypes, 0, i)) != null) {
      log.debug(
          String.format("Found accessible constructor for class %s with parameter types %s.", cls,
              Arrays.toString(Arrays.copyOfRange(parameterTypes, 0, i))));
      return ConstructorUtils.invokeConstructor(cls, Arrays.copyOfRange(args, 0, i));
    }
  }
  throw new NoSuchMethodException(String.format("No accessible constructor for class %s with parameters a subset of %s.",
      cls, Arrays.toString(parameterTypes)));
}

@SuppressWarnings("unchecked")
public static KafkaSchemaRegistry getSchemaRegistry(Properties props) {
  Preconditions.checkArgument(props.containsKey(KafkaSchemaRegistryConfigurationKeys.KAFKA_SCHEMA_REGISTRY_CLASS),
      "Missing required property " + KafkaSchemaRegistryConfigurationKeys.KAFKA_SCHEMA_REGISTRY_CLASS);

  boolean tryCache = Boolean.parseBoolean(props.getProperty(KafkaSchemaRegistryConfigurationKeys.KAFKA_SCHEMA_REGISTRY_CACHE,
      DEFAULT_TRY_CACHING));

  Class<?> clazz;
  try {
    clazz =
        (Class<?>) Class.forName(props.getProperty(KafkaSchemaRegistryConfigurationKeys.KAFKA_SCHEMA_REGISTRY_CLASS));
    KafkaSchemaRegistry schemaRegistry = (KafkaSchemaRegistry) ConstructorUtils.invokeConstructor(clazz, props);
    if (tryCache && !schemaRegistry.hasInternalCache())
    {
      schemaRegistry = new CachingKafkaSchemaRegistry(schemaRegistry);
    }
    return schemaRegistry;
  } catch (ClassNotFoundException | NoSuchMethodException | IllegalAccessException | InvocationTargetException
      | InstantiationException e) {
    log.error("Failed to instantiate " + KafkaSchemaRegistry.class, e);
    throw Throwables.propagate(e);
  }
}

/**
 * Get an instance of {@link HiveSerDeManager}.
 *
 * @param type The {@link HiveSerDeManager} type. It should be either AVRO, or the name of a class that implements
 * {@link HiveSerDeManager}. The specified {@link HiveSerDeManager} type must have a constructor that takes a
 * {@link State} object.
 * @param props A {@link State} object. To get a specific implementation of {@link HiveSerDeManager}, specify either
 * one of the values in {@link Implementation} (e.g., AVRO) or the name of a class that implements
 * {@link HiveSerDeManager} in property {@link #HIVE_ROW_FORMAT}. The {@link State} object is also used to
 * instantiate the {@link HiveSerDeManager}.
 */
public static HiveSerDeManager get(State props) {
  String type = props.getProp(HIVE_ROW_FORMAT, Implementation.AVRO.name());
  Optional<Implementation> implementation = Enums.getIfPresent(Implementation.class, type.toUpperCase());

  try {
    if (implementation.isPresent()) {
      return (HiveSerDeManager) ConstructorUtils.invokeConstructor(Class.forName(implementation.get().toString()),
          props);
    }
    return (HiveSerDeManager) ConstructorUtils.invokeConstructor(Class.forName(type), props);
  } catch (ReflectiveOperationException e) {
    throw new RuntimeException(
        "Unable to instantiate " + HiveSerDeManager.class.getSimpleName() + " with type " + type, e);
  }
}

/**
 * @return A {@link SpecExecutor}'s instance defined by <Technology, Location, Communication Mechanism>
 */
public synchronized SpecExecutor getSpecExecutor() {
  if (null == specExecutorInstance) {
    String specExecutorClass = DEFAULT_SPEC_EXECUTOR_INSTANCE;
    if (config.hasPath(SPEC_EXECUTOR_INSTANCE_KEY)) {
      specExecutorClass = config.getString(SPEC_EXECUTOR_INSTANCE_KEY);
    }
    try {
      ClassAliasResolver<SpecExecutor> _aliasResolver =
          new ClassAliasResolver<>(SpecExecutor.class);
      specExecutorInstance = (SpecExecutor) ConstructorUtils
          .invokeConstructor(Class.forName(_aliasResolver
              .resolve(specExecutorClass)), config);
    } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException | InstantiationException
        | ClassNotFoundException e) {
      throw new RuntimeException(e);
    }
  }
  return specExecutorInstance;
}

private void addServicesFromProperties(Properties properties)
    throws IllegalAccessException, InstantiationException, ClassNotFoundException, InvocationTargetException {
  if (properties.containsKey(APP_ADDITIONAL_SERVICES)) {
    for (String serviceClassName : new State(properties).getPropAsSet(APP_ADDITIONAL_SERVICES)) {
      Class<?> serviceClass = Class.forName(serviceClassName);
      if (Service.class.isAssignableFrom(serviceClass)) {
        Service service;
        Constructor<?> constructor =
            ConstructorUtils.getMatchingAccessibleConstructor(serviceClass, Properties.class);
        if (constructor != null) {
          service = (Service) constructor.newInstance(properties);
        } else {
          service = (Service) serviceClass.newInstance();
        }
        addService(service);
      } else {
        throw new IllegalArgumentException(String.format("Class %s specified by %s does not implement %s",
            serviceClassName, APP_ADDITIONAL_SERVICES, Service.class.getSimpleName()));
      }
    }
  }
}

/**
 * Gets an instance of {@link JobLock}.
 *
 * @param properties the properties used to determine which instance of {@link JobLock} to create and the
 *                   relevant settings
 * @param jobLockEventListener the {@link JobLock} event listener
 * @return an instance of {@link JobLock}
 * @throws JobLockException throw when the {@link JobLock} fails to initialize
 */
public static JobLock getJobLock(Properties properties, JobLockEventListener jobLockEventListener)
        throws JobLockException {
  Preconditions.checkNotNull(properties);
  Preconditions.checkNotNull(jobLockEventListener);
  JobLock jobLock;
  if (properties.containsKey(ConfigurationKeys.JOB_LOCK_TYPE)) {
    try {
      Class<?> jobLockClass = Class.forName(
          properties.getProperty(ConfigurationKeys.JOB_LOCK_TYPE, FileBasedJobLock.class.getName()));
      jobLock = (JobLock) ConstructorUtils.invokeConstructor(jobLockClass, properties);
    } catch (ClassNotFoundException | InstantiationException | IllegalAccessException |
        NoSuchMethodException | InvocationTargetException e) {
      throw new JobLockException(e);
    }
  } else {
    jobLock = new FileBasedJobLock(properties);
  }
  if (jobLock instanceof ListenableJobLock) {
    ((ListenableJobLock)jobLock).setEventListener(jobLockEventListener);
  }
  return jobLock;
}

public ScheduledJobConfigurationManager(EventBus eventBus, Config config) {
  super(eventBus, config);

  this.jobSpecs = Maps.newHashMap();
  this.refreshIntervalInSeconds = ConfigUtils.getLong(config, GobblinClusterConfigurationKeys.JOB_SPEC_REFRESH_INTERVAL,
      DEFAULT_JOB_SPEC_REFRESH_INTERVAL);

  this.fetchJobSpecExecutor = Executors.newSingleThreadScheduledExecutor(
      ExecutorsUtils.newThreadFactory(Optional.of(LOGGER), Optional.of("FetchJobSpecExecutor")));

  this.aliasResolver = new ClassAliasResolver<>(SpecConsumer.class);
  try {
    String specConsumerClassName = GobblinClusterConfigurationKeys.DEFAULT_SPEC_CONSUMER_CLASS;
    if (config.hasPath(GobblinClusterConfigurationKeys.SPEC_CONSUMER_CLASS_KEY)) {
      specConsumerClassName = config.getString(GobblinClusterConfigurationKeys.SPEC_CONSUMER_CLASS_KEY);
    }
    LOGGER.info("Using SpecConsumer ClassNameclass name/alias " + specConsumerClassName);
    this._specConsumer = (SpecConsumer) ConstructorUtils
        .invokeConstructor(Class.forName(this.aliasResolver.resolve(specConsumerClassName)), config);
  } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException | InstantiationException
      | ClassNotFoundException e) {
    throw new RuntimeException(e);
  }
}

/**
 * Constructs MIME content factory from a given class and constructor arguments.
 * 
 * @param factoryClass MIME content factory class of which should be constructed the instance.
 * @param args Constructor arguments for factory.
 * @return Constructed MIME content factory on success, otherwise null.
 */
protected MimeContentFactory instantizeMimeContentFactory(Class<? extends MimeContentFactory> factoryClass, Object ...args) {
    MimeContentFactory mimeContentFactory = null;

    try {
        /*List<Class<?>> constructorClassesList = new ArrayList<Class<?>>();

        for (Object arg : args) {
            constructorClassesList.add(arg.getClass());
        }

        Class<?> constructorClasses[] = constructorClassesList.toArray(new Class<?>[constructorClassesList.size()]);

        Constructor<? extends MimeContentFactoryBase<?>> mimeContentFactoryConstructor = factoryClass.getConstructor(constructorClasses);
        mimeContentFactory = mimeContentFactoryConstructor.newInstance(args);*/

        Object newInstance = ConstructorUtils.invokeConstructor(factoryClass, args);
        mimeContentFactory = factoryClass.cast(newInstance);

    } catch (Exception e) {
        e.printStackTrace();
    }

    return mimeContentFactory;
}

protected Object convertFromStringUnresolved(Class parameterClass, String paramValueStr) {
    try {
        Constructor constructor = ConstructorUtils.getAccessibleConstructor(parameterClass, String.class);
        if (constructor != null) {
            return constructor.newInstance(paramValueStr);
        } else {
            Method valueOf = MethodUtils.getAccessibleMethod(parameterClass, "valueOf", String.class);
            if (valueOf != null) {
                return valueOf.invoke(null, paramValueStr);
            }
        }
    } catch (ReflectiveOperationException e) {
        throw new ReportingException(
                String.format("Could not instantiate object with class [%s] from [%s] string.",
                        parameterClass.getCanonicalName(),
                        paramValueStr));
    }
    return paramValueStr;
}

private AwsServiceTagUpdater(CloudInstanceStore store) {
  Preconditions.checkNotNull(store);
  this.cloudStore = store;
  String
      tagsGeneratorClass =
      Configuration.getProperties()
          .getString("aws_tag_generator", "BasicUploadTagsGenerator");
  try {
    this.tagsGenerator =
        (UploadTagsGenerator) ConstructorUtils
            .invokeConstructor(Class.forName(tagsGeneratorClass), null);
  } catch (Exception ex) {

  }
}

public Filesystem create(final Controller controller, final Host bookmark, final Cache<Path> cache) {
    final String clazz = PreferencesFactory.get().getProperty("factory.filesystem.class");
    if(null == clazz) {
        throw new FactoryException(String.format("No implementation given for factory %s", this.getClass().getSimpleName()));
    }
    try {
        final Class<Filesystem> name = (Class<Filesystem>) Class.forName(clazz);
        final Constructor<Filesystem> constructor = ConstructorUtils.getMatchingAccessibleConstructor(name,
                controller.getClass(), bookmark.getClass(), cache.getClass());
        return constructor.newInstance(controller, bookmark, cache);
    }
    catch(InstantiationException | InvocationTargetException | ClassNotFoundException | IllegalAccessException e) {
        throw new FactoryException(e.getMessage(), e);
    }
}

protected Local create(final String path) {
    final String clazz = PreferencesFactory.get().getProperty("factory.local.class");
    if(null == clazz) {
        throw new FactoryException(String.format("No implementation given for factory %s", this.getClass().getSimpleName()));
    }
    try {
        final Class<Local> name = (Class<Local>) Class.forName(clazz);
        final Constructor<Local> constructor = ConstructorUtils.getMatchingAccessibleConstructor(name, path.getClass());
        return constructor.newInstance(path);
    }
    catch(InstantiationException | InvocationTargetException | ClassNotFoundException | IllegalAccessException e) {
        throw new FactoryException(e.getMessage(), e);
    }
}

protected Local create(final Local parent, final String path) {
    final String clazz = PreferencesFactory.get().getProperty("factory.local.class");
    if(null == clazz) {
        throw new FactoryException(String.format("No implementation given for factory %s", this.getClass().getSimpleName()));
    }
    try {
        final Class<Local> name = (Class<Local>) Class.forName(clazz);
        final Constructor<Local> constructor = ConstructorUtils.getMatchingAccessibleConstructor(name, parent.getClass(), path.getClass());
        return constructor.newInstance(parent, path);
    }
    catch(InstantiationException | InvocationTargetException | ClassNotFoundException | IllegalAccessException e) {
        throw new FactoryException(e.getMessage(), e);
    }
}

public Deserializer create(final T dict) {
    if(null == clazz) {
        throw new FactoryException(String.format("No implementation given for factory %s", this.getClass().getSimpleName()));
    }
    try {
        final Class<Deserializer> name = (Class<Deserializer>) Class.forName(clazz);
        final Constructor<Deserializer> constructor = ConstructorUtils.getMatchingAccessibleConstructor(name, dict.getClass());
        return constructor.newInstance(dict);
    }
    catch(InstantiationException | IllegalAccessException | InvocationTargetException | ClassNotFoundException e) {
        throw new FactoryException(e.getMessage(), e);
    }
}

public static Session<?> create(final Host host, final X509TrustManager trust, final X509KeyManager key) {
    if(log.isDebugEnabled()) {
        log.debug(String.format("Create session for %s", host));
    }
    final Protocol protocol = host.getProtocol();
    final String prefix = protocol.getPrefix();

    try {
        final Class<Session> name = (Class<Session>) Class.forName(String.format("%sSession", prefix));
        final Constructor<Session> constructor = ConstructorUtils.getMatchingAccessibleConstructor(name,
                host.getClass(), trust.getClass(), key.getClass());
        final Session<?> session;
        if(null == constructor) {
            log.warn(String.format("No matching constructor for parameter %s, %s, %s", host.getClass(), trust.getClass(), key.getClass()));
            final Constructor<Session> fallback = ConstructorUtils.getMatchingAccessibleConstructor(name,
                    host.getClass());
            if(fallback == null) {
                throw new FactoryException(String.format("No matching constructor for parameter %s", host.getClass()));
            }
            session = fallback.newInstance(host);
        }
        else {
            session = constructor.newInstance(host, trust, key);
        }
        return session;
    }
    catch(InstantiationException | InvocationTargetException | ClassNotFoundException | IllegalAccessException e) {
        throw new FactoryException(String.format("Failure loading session class for %s protocol. Failure %s", protocol, e));
    }
}

public static FMLMessage.OpenGui create (int windowId, String modId, int modGuiId, int x, int y, int z)
     {
try {
    return ConstructorUtils.invokeConstructor(FMLMessage.OpenGui.class, windowId, modId, modGuiId, x, y, z);
} catch (Exception e) {
    Util.logger.logException("Unable to construct FMLMessage.OpenGui using factory!", e);
    return null;
}
     }

@Override
public <P extends Packet> P createPacket(PacketType<P, ?> type) {
    if(type.getSide() == PacketSide.SERVERBOUND) {
        throw new IllegalArgumentException("You can't initialize a serverbound packet");
    }

    try {
        return ConstructorUtils.invokeConstructor(type.getPacketClass());
    } catch(Exception ex) {
        throw new RuntimeException("There was an issue constructing " + type.getName(), ex);
    }
}

/**
 * 调用构造函数.
 */
public static <T> T invokeConstructor(final Class<T> cls, Object... args) {
    try {
        return ConstructorUtils.invokeConstructor(cls, args);
    } catch (Exception e) {
        throw ExceptionUtil.uncheckedAndWrap(e);
    }
}

public static <T> T construct(Class<T> type) throws ConstructionException {
    try {
        return ConstructorUtils.invokeExactConstructor(type);
    } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException | InstantiationException e) {
        throw new ConstructionException(type, e);
    }
}

public static <T> T construct(Class<T> type, Object enclosing) throws ConstructionException {
    assertInnerNoStaticArguments(type, enclosing);
    try {
        return ConstructorUtils.invokeExactConstructor(type, enclosing);
    } catch (NoSuchMethodException | InstantiationException | IllegalAccessException | InvocationTargetException e) {
        throw new ConstructionException(type, e);
    }
}