Java ConfigurationListener类代码示例

import org.codehaus.plexus.component.configurator.ConfigurationListener; //导入依赖的package包/类
@Override
public void configureComponent(final Object component,
                               final PlexusConfiguration configuration,
                               final ExpressionEvaluator expressionEvaluator,
                               final ClassRealm containerRealm,
                               final ConfigurationListener listener)
        throws ComponentConfigurationException {

    addProjectDependenciesToClassRealm(expressionEvaluator, containerRealm);

    this.converterLookup.registerConverter(new ClassRealmConverter(containerRealm));

    final ObjectWithFieldsConverter converter = new ObjectWithFieldsConverter();

    converter.processConfiguration(this.converterLookup, component,
            containerRealm, configuration,
            expressionEvaluator, listener);

}
 

import org.codehaus.plexus.component.configurator.ConfigurationListener; //导入依赖的package包/类
public ValidatingConfigurationListener( Object mojo, MojoDescriptor mojoDescriptor, ConfigurationListener delegate )
{
    this.mojo = mojo;
    this.delegate = delegate;
    this.missingParameters = new HashMap<String, Parameter>();

    if ( mojoDescriptor.getParameters() != null )
    {
        for ( Parameter param : mojoDescriptor.getParameters() )
        {
            if ( param.isRequired() )
            {
                missingParameters.put( param.getName(), param );
            }
        }
    }
}
 

import org.codehaus.plexus.component.configurator.ConfigurationListener; //导入依赖的package包/类
@SuppressWarnings("rawtypes")
public Object fromConfiguration(ConverterLookup converterLookup,
		PlexusConfiguration configuration, Class type, Class baseType,
		ClassLoader classLoader, ExpressionEvaluator expressionEvaluator,
		ConfigurationListener listener)
		throws ComponentConfigurationException {
	if (isPropertyEditorSupportConversion(configuration, type, baseType,
			classLoader, expressionEvaluator, listener)) {

		return null;
	} else {
		ConfigurationConverter lookupConverterForType = converterLookup
				.lookupConverterForType(type);
		return lookupConverterForType.fromConfiguration(converterLookup,
				configuration, type, baseType, classLoader,
				expressionEvaluator);
	}
}
 

import org.codehaus.plexus.component.configurator.ConfigurationListener; //导入依赖的package包/类
@Override
public void configureComponent(Object component, PlexusConfiguration configuration,
                               ExpressionEvaluator evaluator, ClassRealm realm, ConfigurationListener listener) throws ComponentConfigurationException {
    addProjectDependenciesToClassRealm(evaluator, realm);
    converterLookup.registerConverter(new ClassRealmConverter(realm));
    ObjectWithFieldsConverter converter = new ObjectWithFieldsConverter();
    converter.processConfiguration(converterLookup, component, realm.getParentClassLoader(), configuration,
            evaluator, listener);
}
 

import org.codehaus.plexus.component.configurator.ConfigurationListener; //导入依赖的package包/类
public void configureComponent(Object component, PlexusConfiguration configuration,
    ExpressionEvaluator expressionEvaluator, ClassRealm containerRealm, ConfigurationListener listener)
    throws ComponentConfigurationException
{
  addProjectDependenciesToClassRealm(expressionEvaluator, containerRealm);
  converterLookup.registerConverter(new ClassRealmConverter(containerRealm));
  ObjectWithFieldsConverter converter = new ObjectWithFieldsConverter();
  converter.processConfiguration(converterLookup, component, containerRealm, configuration, expressionEvaluator,
      listener);
}
 

import org.codehaus.plexus.component.configurator.ConfigurationListener; //导入依赖的package包/类
public void configureComponent(Object component, PlexusConfiguration configuration,
        ExpressionEvaluator expressionEvaluator, ClassRealm containerRealm, ConfigurationListener listener)
        throws ComponentConfigurationException {

    addProjectDependenciesToClassRealm(expressionEvaluator, containerRealm);
    converterLookup.registerConverter(new ClassRealmConverter(containerRealm));
    ObjectWithFieldsConverter converter = new ObjectWithFieldsConverter();
    converter.processConfiguration(converterLookup, component, containerRealm.getClassLoader(), configuration,
            expressionEvaluator, listener);
}
 

import org.codehaus.plexus.component.configurator.ConfigurationListener; //导入依赖的package包/类
public void configureComponent(Object component, PlexusConfiguration configuration,
        ExpressionEvaluator expressionEvaluator, ClassRealm containerRealm,
        ConfigurationListener listener)
        throws ComponentConfigurationException
{

    addProjectDependenciesToClassRealm(expressionEvaluator, containerRealm);
    converterLookup.registerConverter(new ClassRealmConverter(containerRealm));
    ObjectWithFieldsConverter converter = new ObjectWithFieldsConverter();
    converter.processConfiguration(converterLookup, component, containerRealm.getClassLoader(), configuration,
            expressionEvaluator, listener);
}
 

import org.codehaus.plexus.component.configurator.ConfigurationListener; //导入依赖的package包/类
@Override
public void configureComponent(final Object mojoInstance, //
    final PlexusConfiguration pluginConfigurationFromMaven, //
    final ExpressionEvaluator evaluator, //
    final ClassRealm realm, //
    final ConfigurationListener listener) throws ComponentConfigurationException {

  super.configureComponent(mojoInstance, pluginConfigurationFromMaven, evaluator, realm, listener);
}
 

import org.codehaus.plexus.component.configurator.ConfigurationListener; //导入依赖的package包/类
/**
 * @see org.codehaus.plexus.component.configurator.converters.ConfigurationConverter#fromConfiguration(org.codehaus.plexus.component.configurator.converters.lookup.ConverterLookup, org.codehaus.plexus.configuration.PlexusConfiguration, java.lang.Class, java.lang.Class, java.lang.ClassLoader, org.codehaus.plexus.component.configurator.expression.ExpressionEvaluator, org.codehaus.plexus.component.configurator.ConfigurationListener)
 */
public Object fromConfiguration( ConverterLookup converterLookup, PlexusConfiguration configuration, Class type,
                                 Class baseType, ClassLoader classLoader, ExpressionEvaluator expressionEvaluator,
                                 ConfigurationListener listener )
    throws ComponentConfigurationException
{
    return fromConfiguration( configuration, expressionEvaluator );
}
 

import org.codehaus.plexus.component.configurator.ConfigurationListener; //导入依赖的package包/类
public ComponentValueSetter(final String fieldName,
		final Class implementation, final Object object,
		final ConverterLookup lookup, final ConfigurationListener listener)
		throws ComponentConfigurationException {
	this.fieldName = fieldName;
	this.object = object;
	this.lookup = lookup;
	this.listener = listener;

	if (object == null) {
		throw new ComponentConfigurationException("Component is null");
	}

	initSetter(implementation);

	initField(implementation);

	if (setter == null && field == null) {
		throw new ComponentConfigurationException(
				"Cannot find setter, adder nor field in "
						+ object.getClass().getName() + " for '"
						+ fieldName + "'");
	}

	if (setterTypeConverter == null && fieldTypeConverter == null) {
		throw new ComponentConfigurationException(
				"Cannot find converter for "
						+ setterParamType.getName()
						+ (fieldType != null
								&& !fieldType.equals(setterParamType) ? " or "
								+ fieldType.getName()
								: ""));
	}
}
 

import org.codehaus.plexus.component.configurator.ConfigurationListener; //导入依赖的package包/类
private boolean isPropertyEditorSupportConversion(
		PlexusConfiguration configuration, Class<?> type,
		Class<?> baseType, ClassLoader classLoader,
		ExpressionEvaluator expressionEvaluator,
		ConfigurationListener listener) {
	// TODO Auto-generated method stub
	return false;
}
 

import org.codehaus.plexus.component.configurator.ConfigurationListener; //导入依赖的package包/类
@Override
public void configureComponent(final Object component,
		final PlexusConfiguration configuration,
		final ExpressionEvaluator expressionEvaluator,
		final ClassRealm containerRealm,
		final ConfigurationListener listener)
		throws ComponentConfigurationException {
	converterLookup.registerConverter(new ClassRealmConverter(
			containerRealm));
	PropertyEditorLookup propertyEditorLookup = new PropertyEditorLookup(container);
	PropertyEditorSupportConverter converter = new PropertyEditorSupportConverter(propertyEditorLookup);

	converter.processConfiguration(converterLookup, component,
			containerRealm, configuration, expressionEvaluator, listener);
}
 

import org.codehaus.plexus.component.configurator.ConfigurationListener; //导入依赖的package包/类
@Override
public void configureComponent(Object component, PlexusConfiguration configuration,
                               ExpressionEvaluator expressionEvaluator, ClassRealm containerRealm,
                               ConfigurationListener listener)
        throws ComponentConfigurationException {
    addProjectDependenciesToClassRealm(expressionEvaluator, containerRealm);

    ObjectWithFieldsConverter converter = new ObjectWithFieldsConverter();
    converter.processConfiguration(converterLookup, component, containerRealm.getClassLoader(), configuration,
            expressionEvaluator, listener);
}
 

import org.codehaus.plexus.component.configurator.ConfigurationListener; //导入依赖的package包/类
@Override
public void configureComponent(Object component, PlexusConfiguration configuration,
		ExpressionEvaluator expressionEvaluator, ClassRealm containerRealm, ConfigurationListener listener)
		throws ComponentConfigurationException {

	addProjectDependenciesToClassRealm(expressionEvaluator, containerRealm);

	converterLookup.registerConverter(new ClassRealmConverter(containerRealm));

	ObjectWithFieldsConverter converter = new ObjectWithFieldsConverter();

	converter.processConfiguration(converterLookup, component, containerRealm.getClassLoader(), configuration,
			expressionEvaluator, listener);
}
 

import org.codehaus.plexus.component.configurator.ConfigurationListener; //导入依赖的package包/类
public void processConfiguration(final ConverterLookup converterLookup,
		final Object object, final ClassLoader classLoader,
		final PlexusConfiguration configuration,
		final ExpressionEvaluator expressionEvaluator,
		final ConfigurationListener listener)
		throws ComponentConfigurationException {
	final int items = configuration.getChildCount();

	for (int i = 0; i < items; i++) {
		final PlexusConfiguration childConfiguration = configuration
				.getChild(i);

		final String elementName = childConfiguration.getName();

		Class<?> implementation;
		try {
			implementation = getClassForImplementationHint(null,
					childConfiguration, classLoader);
		} catch (final Exception e) {
			implementation = null; // fall back to original behavior
		}

		final ComponentValueSetter valueSetter = new ComponentValueSetter(
				fromXML(elementName), implementation, object,
				converterLookup, listener);

		valueSetter.configure(childConfiguration, classLoader,
				expressionEvaluator);
	}

	Class<?> mojoClass = object.getClass();

	while (mojoClass != Object.class) {
		Field[] declaredFields = mojoClass.getDeclaredFields();
		List<PropertyEditorField> editorSupportFields = new ArrayList<PropertyEditorField>();
		for (Field declaredField : declaredFields) {
			if (declaredField.isAnnotationPresent(PropertyEditor.class)) {
				PropertyEditorField propertyEditorField = new PropertyEditorField(
						object, declaredField);
				editorSupportFields.add(propertyEditorField);
			}
		}

		handlePropertyEditorFields(object, editorSupportFields,
				expressionEvaluator);
		mojoClass = mojoClass.getSuperclass();
	}
}