Java 类org.springframework.beans.BeanMetadataElement 实例源码

private AbstractBeanDefinition buildExporter(ServiceMetadata metadata) {
    BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition(EXPORTER_CLASS);
    // add properties
    builder.addPropertyValue(EXPORTER_RANKING_PROP, metadata.getRanking());
    builder.addPropertyValue(EXPORTER_INTFS_PROP, metadata.getInterfaces());
    builder.addPropertyValue(EXPORTER_PROPS_PROP, metadata.getServiceProperties());
    builder.addPropertyValue(EXPORTER_AUTO_EXPORT_PROP,
            DefaultInterfaceDetector.values()[metadata.getAutoExport() - 1]);

    BeanMetadataElement beanMetadata = BeanMetadataElementFactory.buildBeanMetadata(metadata.getServiceComponent());
    if (beanMetadata instanceof RuntimeBeanReference) {
        builder.addPropertyValue(EXPORTER_TARGET_BEAN_NAME_PROP, beanMetadata);
    } else {
        builder.addPropertyValue(EXPORTER_TARGET_BEAN_PROP, beanMetadata);
    }

    // FIXME: add registration listeners

    return builder.getBeanDefinition();
}

private void tag(Collection<ValueHolder> values, String name, BeanDefinition definition) {
    boolean trace = log.isTraceEnabled();

    for (ValueHolder value : values) {
        Object val = value.getValue();
        if (val instanceof BeanMetadataElement) {
            if (val instanceof RuntimeBeanReference) {
                String beanName = ((RuntimeBeanReference) val).getBeanName();

                if (trace) {
                    log.trace("Adding (cycle breaking) depends-on on " + name + " to " + beanName);
                }

                addSyntheticDependsOn(definition, beanName);
            }
        }
    }
}

private void registerHttp(final String id, final Client client, final String factoryId,
        final BeanDefinition converters, final List<BeanMetadataElement> plugins) {
    registry.registerIfAbsent(id, Http.class, () -> {
        log.debug("Client [{}]: Registering Http", id);

        final BeanDefinitionBuilder http = genericBeanDefinition(HttpFactory.class);
        http.setFactoryMethod("create");
        http.addConstructorArgValue(client.getBaseUrl());
        http.addConstructorArgValue(client.getUrlResolution());
        http.addConstructorArgReference(factoryId);
        http.addConstructorArgValue(converters);
        http.addConstructorArgValue(plugins);

        return http;
    });
}

private void registerTemplate(final String id, final Class<?> type, final String factoryId,
        @Nullable final String baseUrl, final BeanDefinition converters, final List<BeanMetadataElement> plugins) {
    registry.registerIfAbsent(id, type, () -> {
        log.debug("Client [{}]: Registering AsyncRestTemplate", id);

        final DefaultUriTemplateHandler handler = new DefaultUriTemplateHandler();
        handler.setBaseUrl(baseUrl);

        final BeanDefinitionBuilder template = genericBeanDefinition(type);
        template.addConstructorArgReference(factoryId);
        template.addPropertyValue("uriTemplateHandler", handler);
        template.addPropertyValue("messageConverters", converters);
        template.addPropertyValue("interceptors", plugins.stream()
                .map(plugin -> genericBeanDefinition(PluginInterceptors.class)
                        .setFactoryMethod("adapt")
                        .addConstructorArgValue(plugin)
                        .getBeanDefinition())
                .collect(toCollection(Registry::list)));

        return template;
    });
}

/**
 * Convert from an internal Spring bean definition to a DTO.
 * 
 * @param beanDefinition The internal Spring bean definition.
 * @return Returns a DTO representation.
 */
public BeanDefinitionInfo toDto(BeanDefinition beanDefinition) {
    if (beanDefinition instanceof GenericBeanDefinition) {
        GenericBeanDefinitionInfo info = new GenericBeanDefinitionInfo();
        info.setClassName(beanDefinition.getBeanClassName());

        if (beanDefinition.getPropertyValues() != null) {
            Map<String, BeanMetadataElementInfo> propertyValues = new HashMap<String, BeanMetadataElementInfo>();
            for (PropertyValue value : beanDefinition.getPropertyValues().getPropertyValueList()) {
                Object obj = value.getValue();
                if (obj instanceof BeanMetadataElement) {
                    propertyValues.put(value.getName(), toDto((BeanMetadataElement) obj));
                } else {
                    throw new IllegalArgumentException("Type " + obj.getClass().getName()
                            + " is not a BeanMetadataElement for property: " + value.getName());
                }
            }
            info.setPropertyValues(propertyValues);
        }
        return info;
    } else {
        throw new IllegalArgumentException("Conversion to DTO of " + beanDefinition.getClass().getName()
                + " not implemented");
    }
}

@Override
protected BeanMetadataElement parseSource(Element element, ParserContext parserContext) {
  final BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition(IronMqMessageSource.class);

  IntegrationNamespaceUtils.setReferenceIfAttributeDefined(builder, element,
    IronMqParserConstants.ATTRIBUTE_CLIENT_FACTORY,
    IronMqParserConstants.PROPERTY_CLIENT_FACTORY);

  IntegrationNamespaceUtils.setValueIfAttributeDefined(builder, element,
    IronMqParserConstants.ATTRIBUTE_EXTRACT_PAYLOAD,
    IronMqParserConstants.PROPERTY_EXTRACT_PAYLOAD);

  IntegrationNamespaceUtils.setValueIfAttributeDefined(builder, element,
    IronMqParserConstants.ATTRIBUTE_RESERVATION_IN_SECONDS,
    IronMqParserConstants.PROPERTY_RESERVATION_IN_SECONDS);

  final BeanDefinition queueNameExpressionDefinition =
    IntegrationNamespaceUtils.createExpressionDefinitionFromValueOrExpression(
      IronMqParserConstants.ATTRIBUTE_QUEUE_NAME,
      IronMqParserConstants.ATTRIBUTE_QUEUE_NAME_EXPRESSION,
      parserContext, element, true);

  builder.addPropertyValue(IronMqParserConstants.PROPERTY_QUEUE_NAME_EXPRESSION, queueNameExpressionDefinition);

  return builder.getBeanDefinition();
}

private static void processBeanMetadata(BeanMetadataElement metadata, Collection<ComponentMetadata> to) {
    if (metadata instanceof BeanDefinition) {
        processBeanDefinition((BeanDefinition) metadata, to);
    }

    else if (metadata instanceof BeanDefinitionHolder) {
        BeanDefinitionHolder bh = (BeanDefinitionHolder) metadata;
        processBeanDefinition(bh.getBeanDefinition(), to);
    }

    else if (metadata instanceof Mergeable && metadata instanceof Iterable) {
        processIterable((Iterable) metadata, to);
    }
}

private static void processIterable(Iterable iterableMetadata, Collection<ComponentMetadata> to) {
    for (Object value : iterableMetadata) {
        if (value instanceof BeanMetadataElement) {
            processBeanMetadata((BeanMetadataElement) value, to);
        }
    }
}

public void testPropertyInline() throws Exception {
    AbstractBeanDefinition def = (AbstractBeanDefinition) context.getBeanDefinition("propertyValueInline");
    assertEquals(Socket.class.getName(), def.getBeanClassName());
    MutablePropertyValues propertyValues = def.getPropertyValues();
    PropertyValue propertyValue = propertyValues.getPropertyValue("keepAlive");
    assertNotNull(propertyValue);
    assertTrue(propertyValue.getValue() instanceof BeanMetadataElement);
}

static private BeanDefinition createDatabasePopulator(Element element, List<Element> scripts, String execution) {
    BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition(CompositeDatabasePopulator.class);

    boolean ignoreFailedDrops = element.getAttribute("ignore-failures").equals("DROPS");
    boolean continueOnError = element.getAttribute("ignore-failures").equals("ALL");

    ManagedList<BeanMetadataElement> delegates = new ManagedList<BeanMetadataElement>();
    for (Element scriptElement : scripts) {
        String executionAttr = scriptElement.getAttribute("execution");
        if (!StringUtils.hasText(executionAttr)) {
            executionAttr = "INIT";
        }
        if (!execution.equals(executionAttr)) {
            continue;
        }
        BeanDefinitionBuilder delegate = BeanDefinitionBuilder.genericBeanDefinition(ResourceDatabasePopulator.class);
        delegate.addPropertyValue("ignoreFailedDrops", ignoreFailedDrops);
        delegate.addPropertyValue("continueOnError", continueOnError);

        // Use a factory bean for the resources so they can be given an order if a pattern is used
        BeanDefinitionBuilder resourcesFactory = BeanDefinitionBuilder.genericBeanDefinition(SortedResourcesFactoryBean.class);
        resourcesFactory.addConstructorArgValue(new TypedStringValue(scriptElement.getAttribute("location")));
        delegate.addPropertyValue("scripts", resourcesFactory.getBeanDefinition());
        if (StringUtils.hasLength(scriptElement.getAttribute("encoding"))) {
            delegate.addPropertyValue("sqlScriptEncoding", new TypedStringValue(scriptElement.getAttribute("encoding")));
        }
        if (StringUtils.hasLength(scriptElement.getAttribute("separator"))) {
            delegate.addPropertyValue("separator", new TypedStringValue(scriptElement.getAttribute("separator")));
        }
        delegates.add(delegate.getBeanDefinition());
    }
    builder.addPropertyValue("populators", delegates);

    return builder.getBeanDefinition();
}

/**
 * Resolve the prepared arguments stored in the given bean definition.
 */
private Object[] resolvePreparedArguments(
        String beanName, RootBeanDefinition mbd, BeanWrapper bw, Member methodOrCtor, Object[] argsToResolve) {

    Class<?>[] paramTypes = (methodOrCtor instanceof Method ?
            ((Method) methodOrCtor).getParameterTypes() : ((Constructor<?>) methodOrCtor).getParameterTypes());
    TypeConverter converter = (this.beanFactory.getCustomTypeConverter() != null ?
            this.beanFactory.getCustomTypeConverter() : bw);
    BeanDefinitionValueResolver valueResolver =
            new BeanDefinitionValueResolver(this.beanFactory, beanName, mbd, converter);
    Object[] resolvedArgs = new Object[argsToResolve.length];
    for (int argIndex = 0; argIndex < argsToResolve.length; argIndex++) {
        Object argValue = argsToResolve[argIndex];
        MethodParameter methodParam = MethodParameter.forMethodOrConstructor(methodOrCtor, argIndex);
        GenericTypeResolver.resolveParameterType(methodParam, methodOrCtor.getDeclaringClass());
        if (argValue instanceof AutowiredArgumentMarker) {
            argValue = resolveAutowiredArgument(methodParam, beanName, null, converter);
        }
        else if (argValue instanceof BeanMetadataElement) {
            argValue = valueResolver.resolveValueIfNecessary("constructor argument", argValue);
        }
        else if (argValue instanceof String) {
            argValue = this.beanFactory.evaluateBeanDefinitionString((String) argValue, mbd);
        }
        Class<?> paramType = paramTypes[argIndex];
        try {
            resolvedArgs[argIndex] = converter.convertIfNecessary(argValue, paramType, methodParam);
        }
        catch (TypeMismatchException ex) {
            String methodType = (methodOrCtor instanceof Constructor ? "constructor" : "factory method");
            throw new UnsatisfiedDependencyException(
                    mbd.getResourceDescription(), beanName, argIndex, paramType,
                    "Could not convert " + methodType + " argument value of type [" +
                    ObjectUtils.nullSafeClassName(argValue) +
                    "] to required type [" + paramType.getName() + "]: " + ex.getMessage());
        }
    }
    return resolvedArgs;
}

static private BeanDefinition createDatabasePopulator(Element element, List<Element> scripts, String execution) {
    BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition(CompositeDatabasePopulator.class);

    boolean ignoreFailedDrops = element.getAttribute("ignore-failures").equals("DROPS");
    boolean continueOnError = element.getAttribute("ignore-failures").equals("ALL");

    ManagedList<BeanMetadataElement> delegates = new ManagedList<BeanMetadataElement>();
    for (Element scriptElement : scripts) {
        String executionAttr = scriptElement.getAttribute("execution");
        if (!StringUtils.hasText(executionAttr)) {
            executionAttr = "INIT";
        }
        if (!execution.equals(executionAttr)) {
            continue;
        }
        BeanDefinitionBuilder delegate = BeanDefinitionBuilder.genericBeanDefinition(ResourceDatabasePopulator.class);
        delegate.addPropertyValue("ignoreFailedDrops", ignoreFailedDrops);
        delegate.addPropertyValue("continueOnError", continueOnError);

        // Use a factory bean for the resources so they can be given an order if a pattern is used
        BeanDefinitionBuilder resourcesFactory = BeanDefinitionBuilder.genericBeanDefinition(SortedResourcesFactoryBean.class);
        resourcesFactory.addConstructorArgValue(new TypedStringValue(scriptElement.getAttribute("location")));
        delegate.addPropertyValue("scripts", resourcesFactory.getBeanDefinition());
        if (StringUtils.hasLength(scriptElement.getAttribute("encoding"))) {
            delegate.addPropertyValue("sqlScriptEncoding", new TypedStringValue(scriptElement.getAttribute("encoding")));
        }
        if (StringUtils.hasLength(scriptElement.getAttribute("separator"))) {
            delegate.addPropertyValue("separator", new TypedStringValue(scriptElement.getAttribute("separator")));
        }
        delegates.add(delegate.getBeanDefinition());
    }
    builder.addPropertyValue("populators", delegates);

    return builder.getBeanDefinition();
}

/**
 * Resolve the prepared arguments stored in the given bean definition.
 */
private Object[] resolvePreparedArguments(
        String beanName, RootBeanDefinition mbd, BeanWrapper bw, Member methodOrCtor, Object[] argsToResolve) {

    Class<?>[] paramTypes = (methodOrCtor instanceof Method ?
            ((Method) methodOrCtor).getParameterTypes() : ((Constructor<?>) methodOrCtor).getParameterTypes());
    TypeConverter converter = (this.beanFactory.getCustomTypeConverter() != null ?
            this.beanFactory.getCustomTypeConverter() : bw);
    BeanDefinitionValueResolver valueResolver =
            new BeanDefinitionValueResolver(this.beanFactory, beanName, mbd, converter);
    Object[] resolvedArgs = new Object[argsToResolve.length];
    for (int argIndex = 0; argIndex < argsToResolve.length; argIndex++) {
        Object argValue = argsToResolve[argIndex];
        MethodParameter methodParam = MethodParameter.forMethodOrConstructor(methodOrCtor, argIndex);
        GenericTypeResolver.resolveParameterType(methodParam, methodOrCtor.getDeclaringClass());
        if (argValue instanceof AutowiredArgumentMarker) {
            argValue = resolveAutowiredArgument(methodParam, beanName, null, converter);
        }
        else if (argValue instanceof BeanMetadataElement) {
            argValue = valueResolver.resolveValueIfNecessary("constructor argument", argValue);
        }
        else if (argValue instanceof String) {
            argValue = this.beanFactory.evaluateBeanDefinitionString((String) argValue, mbd);
        }
        Class<?> paramType = paramTypes[argIndex];
        try {
            resolvedArgs[argIndex] = converter.convertIfNecessary(argValue, paramType, methodParam);
        }
        catch (TypeMismatchException ex) {
            String methodType = (methodOrCtor instanceof Constructor ? "constructor" : "factory method");
            throw new UnsatisfiedDependencyException(
                    mbd.getResourceDescription(), beanName, argIndex, paramType,
                    "Could not convert " + methodType + " argument value of type [" +
                    ObjectUtils.nullSafeClassName(argValue) +
                    "] to required type [" + paramType.getName() + "]: " + ex.getMessage());
        }
    }
    return resolvedArgs;
}

/**
 * Resolve the prepared arguments stored in the given bean definition.
 */
private Object[] resolvePreparedArguments(
        String beanName, RootBeanDefinition mbd, BeanWrapper bw, Member methodOrCtor, Object[] argsToResolve) {

    Class<?>[] paramTypes = (methodOrCtor instanceof Method ?
            ((Method) methodOrCtor).getParameterTypes() : ((Constructor<?>) methodOrCtor).getParameterTypes());
    TypeConverter converter = (this.beanFactory.getCustomTypeConverter() != null ?
            this.beanFactory.getCustomTypeConverter() : bw);
    BeanDefinitionValueResolver valueResolver =
            new BeanDefinitionValueResolver(this.beanFactory, beanName, mbd, converter);
    Object[] resolvedArgs = new Object[argsToResolve.length];
    for (int argIndex = 0; argIndex < argsToResolve.length; argIndex++) {
        Object argValue = argsToResolve[argIndex];
        MethodParameter methodParam = MethodParameter.forMethodOrConstructor(methodOrCtor, argIndex);
        GenericTypeResolver.resolveParameterType(methodParam, methodOrCtor.getDeclaringClass());
        if (argValue instanceof AutowiredArgumentMarker) {
            argValue = resolveAutowiredArgument(methodParam, beanName, null, converter);
        }
        else if (argValue instanceof BeanMetadataElement) {
            argValue = valueResolver.resolveValueIfNecessary("constructor argument", argValue);
        }
        else if (argValue instanceof String) {
            argValue = this.beanFactory.evaluateBeanDefinitionString((String) argValue, mbd);
        }
        Class<?> paramType = paramTypes[argIndex];
        try {
            resolvedArgs[argIndex] = converter.convertIfNecessary(argValue, paramType, methodParam);
        }
        catch (TypeMismatchException ex) {
            throw new UnsatisfiedDependencyException(
                    mbd.getResourceDescription(), beanName, new InjectionPoint(methodParam),
                    "Could not convert argument value of type [" + ObjectUtils.nullSafeClassName(argValue) +
                    "] to required type [" + paramType.getName() + "]: " + ex.getMessage());
        }
    }
    return resolvedArgs;
}

@Override
public void register() {
    settings.getClients().forEach((id, client) -> {
        final String factoryId = registerAsyncClientHttpRequestFactory(id, client);
        final BeanDefinition converters = registerHttpMessageConverters(id);
        final String baseUrl = client.getBaseUrl();
        final List<BeanMetadataElement> plugins = registerPlugins(id, client);

        registerHttp(id, client, factoryId, converters, plugins);
        registerTemplate(id, RestTemplate.class, factoryId, baseUrl, converters, plugins);
        registerTemplate(id, AsyncRestTemplate.class, factoryId, baseUrl, converters, plugins);
    });
}

private BeanMetadataElement registerExecutor(final String id, final Client client) {
    return trace(registry.registerIfAbsent(id, ExecutorService.class, () -> {
        final RiptideSettings.ThreadPool threadPool = client.getThreadPool();
        return genericBeanDefinition(ThreadPoolExecutor.class)
                .addConstructorArgValue(threadPool.getMinSize())
                .addConstructorArgValue(threadPool.getMaxSize())
                .addConstructorArgValue(threadPool.getKeepAlive().getAmount())
                .addConstructorArgValue(threadPool.getKeepAlive().getUnit())
                .addConstructorArgValue(threadPool.getQueueSize() == 0 ?
                        new SynchronousQueue<>() :
                        new ArrayBlockingQueue<>(threadPool.getQueueSize()))
                .addConstructorArgValue(new CustomizableThreadFactory("http-" + id + "-"))
                .setDestroyMethodName("shutdown");
    }));
}

private BeanMetadataElement registerScheduler(final String id) {
    // we allow users to use their own ScheduledExecutorService, but they don't have to configure tracing
    return trace(registry.registerIfAbsent(id, ScheduledExecutorService.class,
            () -> {
                final CustomizableThreadFactory threadFactory = new CustomizableThreadFactory(
                        "http-" + id + "-scheduler-");
                threadFactory.setDaemon(true);

                return genericBeanDefinition(ScheduledThreadPoolExecutor.class)
                        .addConstructorArgValue(1)
                        .addConstructorArgValue(threadFactory)
                        .addPropertyValue("removeOnCancelPolicy", true)
                        .setDestroyMethodName("shutdown");
            }));
}

private BeanMetadataElement trace(final String executor) {
    if (registry.isRegistered("tracer")) {
        return genericBeanDefinition(TracingExecutors.class)
                .setFactoryMethod("preserve")
                .addConstructorArgReference(executor)
                .addConstructorArgReference("tracer")
                .getBeanDefinition();
    } else {
        return ref(executor);
    }
}

private AbstractBeanDefinition serviceBeanDef(XmlEntity entity) {
    final List<BeanMetadataElement> converterRefs = converterRefs(converterNames(entity.getConverters()));
    return BeanDefinitionBuilder.
            rootBeanDefinition(PKG + entity.getClazz() + "Service").
            addConstructorArgReference(repoBeanName(entity.getClazz())).
            addPropertyValue("converters", converterRefs).
            getBeanDefinition();
}

static private BeanDefinition createDatabasePopulator(Element element, List<Element> scripts, String execution) {
    BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition(CompositeDatabasePopulator.class);

    boolean ignoreFailedDrops = element.getAttribute("ignore-failures").equals("DROPS");
    boolean continueOnError = element.getAttribute("ignore-failures").equals("ALL");

    ManagedList<BeanMetadataElement> delegates = new ManagedList<BeanMetadataElement>();
    for (Element scriptElement : scripts) {
        String executionAttr = scriptElement.getAttribute("execution");
        if (!StringUtils.hasText(executionAttr)) {
            executionAttr = "INIT";
        }
        if (!execution.equals(executionAttr)) {
            continue;
        }
        BeanDefinitionBuilder delegate = BeanDefinitionBuilder.genericBeanDefinition(ResourceDatabasePopulator.class);
        delegate.addPropertyValue("ignoreFailedDrops", ignoreFailedDrops);
        delegate.addPropertyValue("continueOnError", continueOnError);

        // Use a factory bean for the resources so they can be given an order if a pattern is used
        BeanDefinitionBuilder resourcesFactory = BeanDefinitionBuilder.genericBeanDefinition(SortedResourcesFactoryBean.class);
        resourcesFactory.addConstructorArgValue(new TypedStringValue(scriptElement.getAttribute("location")));
        delegate.addPropertyValue("scripts", resourcesFactory.getBeanDefinition());
        if (StringUtils.hasLength(scriptElement.getAttribute("encoding"))) {
            delegate.addPropertyValue("sqlScriptEncoding", new TypedStringValue(scriptElement.getAttribute("encoding")));
        }
        if (StringUtils.hasLength(scriptElement.getAttribute("separator"))) {
            delegate.addPropertyValue("separator", new TypedStringValue(scriptElement.getAttribute("separator")));
        }
        delegates.add(delegate.getBeanDefinition());
    }
    builder.addPropertyValue("populators", delegates);

    return builder.getBeanDefinition();
}

/**
 * Resolve the prepared arguments stored in the given bean definition.
 */
private Object[] resolvePreparedArguments(
        String beanName, RootBeanDefinition mbd, BeanWrapper bw, Member methodOrCtor, Object[] argsToResolve) {

    Class<?>[] paramTypes = (methodOrCtor instanceof Method ?
            ((Method) methodOrCtor).getParameterTypes() : ((Constructor<?>) methodOrCtor).getParameterTypes());
    TypeConverter converter = (this.beanFactory.getCustomTypeConverter() != null ?
            this.beanFactory.getCustomTypeConverter() : bw);
    BeanDefinitionValueResolver valueResolver =
            new BeanDefinitionValueResolver(this.beanFactory, beanName, mbd, converter);
    Object[] resolvedArgs = new Object[argsToResolve.length];
    for (int argIndex = 0; argIndex < argsToResolve.length; argIndex++) {
        Object argValue = argsToResolve[argIndex];
        MethodParameter methodParam = MethodParameter.forMethodOrConstructor(methodOrCtor, argIndex);
        GenericTypeResolver.resolveParameterType(methodParam, methodOrCtor.getDeclaringClass());
        if (argValue instanceof AutowiredArgumentMarker) {
            argValue = resolveAutowiredArgument(methodParam, beanName, null, converter);
        }
        else if (argValue instanceof BeanMetadataElement) {
            argValue = valueResolver.resolveValueIfNecessary("constructor argument", argValue);
        }
        else if (argValue instanceof String) {
            argValue = this.beanFactory.evaluateBeanDefinitionString((String) argValue, mbd);
        }
        Class<?> paramType = paramTypes[argIndex];
        try {
            resolvedArgs[argIndex] = converter.convertIfNecessary(argValue, paramType, methodParam);
        }
        catch (TypeMismatchException ex) {
            String methodType = (methodOrCtor instanceof Constructor ? "constructor" : "factory method");
            throw new UnsatisfiedDependencyException(
                    mbd.getResourceDescription(), beanName, argIndex, paramType,
                    "Could not convert " + methodType + " argument value of type [" +
                    ObjectUtils.nullSafeClassName(argValue) +
                    "] to required type [" + paramType.getName() + "]: " + ex.getMessage());
        }
    }
    return resolvedArgs;
}

@SuppressWarnings({"unchecked"})
public static List<BeanMetadataElement> findFilterChain(ParserContext parserContext, String explicitRef) {
  String filterChainRef = explicitRef;
  if (!StringUtils.hasText(filterChainRef)) {
    filterChainRef = findDefaultFilterChainBeanId(parserContext);
  }
  return (List<BeanMetadataElement>)
          parserContext.getRegistry().getBeanDefinition(filterChainRef).getConstructorArgumentValues().getArgumentValue(1,List.class).getValue();
}

@SuppressWarnings({"unchecked"})
public static List<BeanMetadataElement> findFilterChain(ParserContext parserContext, String explicitRef) {
  String filterChainRef = explicitRef;
  if (!StringUtils.hasText(filterChainRef)) {
    filterChainRef = findDefaultFilterChainBeanId(parserContext);
  }
  return (List<BeanMetadataElement>)
          parserContext.getRegistry().getBeanDefinition(filterChainRef).getConstructorArgumentValues().getArgumentValue(1,List.class).getValue();
}

/**
 * Attempts to find the place in the filter chain to insert the spring security oauth filters. Currently,
 * these filters are inserted after the ExceptionTranslationFilter.
 *
 * @param filterChain The filter chain configuration.
 * @return The insert index.
 */
private int insertIndex(List<BeanMetadataElement> filterChain) {
  int i;
  for (i = 0; i < filterChain.size(); i++) {
    BeanMetadataElement filter = filterChain.get(i);
    if (filter instanceof BeanDefinition) {
      String beanName = ((BeanDefinition) filter).getBeanClassName();
      if (beanName.equals(ExceptionTranslationFilter.class.getName())) {
         return i + 1;
      }
    }
  }
  return filterChain.size();
}

static BeanMetadataElement buildBeanMetadata(Metadata metadata) {
    return buildBeanMetadata(metadata, null);
}

private List<BeanMetadataElement> registerPlugins(final String id, final Client client) {
    final List<BeanMetadataElement> plugins = list();

    if (client.getRecordMetrics()) {
        log.debug("Client [{}]: Registering [{}]", id, MetricsPlugin.class.getSimpleName());
        plugins.add(ref("metricsPlugin"));
    }

    if (client.getDetectTransientFaults()) {
        log.debug("Client [{}]: Registering [{}]", id, TransientFaultPlugin.class.getSimpleName());
        plugins.add(genericBeanDefinition(TransientFaultPlugin.class)
                .addConstructorArgReference(findFaultClassifier(id))
                .getBeanDefinition());
    }

    if (client.getRetry() != null || client.getCircuitBreaker() != null) {
        plugins.add(ref(registry.registerIfAbsent(id, FailsafePlugin.class, () ->
                genericBeanDefinition(FailsafePlugin.class)
                        .addConstructorArgValue(registerScheduler(id))
                        .addConstructorArgReference(registerRetryPolicy(id, client))
                        .addConstructorArgReference(registerCircuitBreaker(id, client)))));
    }

    if (client.getBackupRequest() != null) {
        plugins.add(genericBeanDefinition(BackupRequestPlugin.class)
            .addConstructorArgValue(registerScheduler(id))
            .addConstructorArgValue(client.getBackupRequest().getDelay().getAmount())
            .addConstructorArgValue(client.getBackupRequest().getDelay().getUnit())
            .addConstructorArgValue(registerExecutor(id, client))
            .getBeanDefinition());
    }

    if (client.getTimeout() != null) {
        plugins.add(genericBeanDefinition(TimeoutPlugin.class)
                .addConstructorArgValue(registerScheduler(id))
                .addConstructorArgValue(client.getTimeout().getAmount())
                .addConstructorArgValue(client.getTimeout().getUnit())
                .addConstructorArgValue(registerExecutor(id, client))
                .getBeanDefinition());
    }

    if (client.getPreserveStackTrace()) {
        log.debug("Client [{}]: Registering [{}]", id, OriginalStackTracePlugin.class.getSimpleName());
        plugins.add(ref(registry.registerIfAbsent(id, OriginalStackTracePlugin.class)));
    }

    if (registry.isRegistered(id, Plugin.class)) {
        final String plugin = generateBeanName(id, Plugin.class);
        log.debug("Client [{}]: Registering [{}]", plugin);
        plugins.add(ref(plugin));
    }

    return plugins;
}

@Override
protected void doParse(Element element, ParserContext parserContext, BeanDefinitionBuilder builder) {
    List<Element> clientElements = DomUtils.getChildElementsByTagName(element, "client");
    ManagedMap<String, BeanMetadataElement> clients = new ManagedMap<String, BeanMetadataElement>();
    for (Element clientElement : clientElements) {
        BeanDefinitionBuilder client = BeanDefinitionBuilder.rootBeanDefinition(BaseClientDetails.class);
        String clientId = clientElement.getAttribute("client-id");
        if (StringUtils.hasText(clientId)) {
            client.addConstructorArgValue(clientId);
        }
        else {
            parserContext.getReaderContext().error("A client id must be supplied with the definition of a client.",
                    clientElement);
        }

        String secret = clientElement.getAttribute("secret");
        if (StringUtils.hasText(secret)) {
            client.addPropertyValue("clientSecret", secret);
        }
        String resourceIds = clientElement.getAttribute("resource-ids");
        if (StringUtils.hasText(clientId)) {
            client.addConstructorArgValue(resourceIds);
        }
        else {
            client.addConstructorArgValue("");
        }
        String redirectUri = clientElement.getAttribute("redirect-uri");
        String tokenValidity = clientElement.getAttribute("access-token-validity");
        if (StringUtils.hasText(tokenValidity)) {
            client.addPropertyValue("accessTokenValiditySeconds", tokenValidity);
        }
        String refreshValidity = clientElement.getAttribute("refresh-token-validity");
        if (StringUtils.hasText(refreshValidity)) {
            client.addPropertyValue("refreshTokenValiditySeconds", refreshValidity);
        }
        client.addConstructorArgValue(clientElement.getAttribute("scope"));
        client.addConstructorArgValue(clientElement.getAttribute("authorized-grant-types"));
        client.addConstructorArgValue(clientElement.getAttribute("authorities"));
        if (StringUtils.hasText(redirectUri)) {
            client.addConstructorArgValue(redirectUri);
        }
        client.addPropertyValue("autoApproveScopes", clientElement.getAttribute("autoapprove"));

        clients.put(clientId, client.getBeanDefinition());
    }

    builder.addPropertyValue("clientDetailsStore", clients);
}

public BeanDefinition parse(Element element, ParserContext parserContext) {
  BeanDefinitionBuilder consumerContextFilterBean = BeanDefinitionBuilder.rootBeanDefinition(OAuthConsumerContextFilter.class);

  String failureHandlerRef = element.getAttribute("failure-handler-ref");
  if (StringUtils.hasText(failureHandlerRef)) {
    consumerContextFilterBean.addPropertyReference("OAuthFailureHandler", failureHandlerRef);
  }
  else {
    String failurePage = element.getAttribute("oauth-failure-page");
    if (StringUtils.hasText(failurePage)) {
      AccessDeniedHandlerImpl failureHandler = new AccessDeniedHandlerImpl();
      failureHandler.setErrorPage(failurePage);
      consumerContextFilterBean.addPropertyValue("OAuthFailureHandler", failureHandler);
    }
  }

  String resourceDetailsRef = element.getAttribute("resource-details-service-ref");
  String supportRef = element.getAttribute("support-ref");
  if (!StringUtils.hasText(supportRef)) {
    BeanDefinitionBuilder consumerSupportBean = BeanDefinitionBuilder.rootBeanDefinition(CoreOAuthConsumerSupport.class);

    if (StringUtils.hasText(resourceDetailsRef)) {
      consumerSupportBean.addPropertyReference("protectedResourceDetailsService", resourceDetailsRef);
    }
    parserContext.getRegistry().registerBeanDefinition("oauthConsumerSupport", consumerSupportBean.getBeanDefinition());
    supportRef = "oauthConsumerSupport";
  }
  consumerContextFilterBean.addPropertyReference("consumerSupport", supportRef);

  String tokenServicesFactoryRef = element.getAttribute("token-services-ref");
  if (StringUtils.hasText(tokenServicesFactoryRef)) {
    consumerContextFilterBean.addPropertyReference("tokenServices", tokenServicesFactoryRef);
  }

  String rememberMeServicesRef = element.getAttribute("remember-me-services-ref");
  if (StringUtils.hasText(rememberMeServicesRef)) {
    consumerContextFilterBean.addPropertyReference("rememberMeServices", rememberMeServicesRef);
  }

  String redirectStrategyRef = element.getAttribute("redirect-strategy-ref");
  if (StringUtils.hasText(redirectStrategyRef)) {
    consumerContextFilterBean.addPropertyReference("redirectStrategy", redirectStrategyRef);
  }

  parserContext.getRegistry().registerBeanDefinition("oauthConsumerContextFilter", consumerContextFilterBean.getBeanDefinition());
  List<BeanMetadataElement> filterChain = ConfigUtils.findFilterChain(parserContext, element.getAttribute("filter-chain-ref"));
  filterChain.add(filterChain.size(), new RuntimeBeanReference("oauthConsumerContextFilter"));

  BeanDefinition fids = ConfigUtils.createSecurityMetadataSource(element, parserContext);
  if (fids != null) {
    BeanDefinitionBuilder consumerAccessFilterBean = BeanDefinitionBuilder.rootBeanDefinition(OAuthConsumerProcessingFilter.class);

    if (StringUtils.hasText(resourceDetailsRef)) {
      consumerAccessFilterBean.addPropertyReference("protectedResourceDetailsService", resourceDetailsRef);
    }

    String requireAuthenticated = element.getAttribute("requireAuthenticated");
    if (StringUtils.hasText(requireAuthenticated)) {
      consumerAccessFilterBean.addPropertyValue("requireAuthenticated", requireAuthenticated);
    }

    consumerAccessFilterBean.addPropertyValue("objectDefinitionSource", fids);
    parserContext.getRegistry().registerBeanDefinition("oauthConsumerFilter", consumerAccessFilterBean.getBeanDefinition());
    filterChain.add(filterChain.size(), new RuntimeBeanReference("oauthConsumerFilter"));
  }

  return null;
}

@Override
protected void doParse(Element element, ParserContext parserContext, BeanDefinitionBuilder builder) {
    List<Element> consumerElements = DomUtils.getChildElementsByTagName(element, "consumer");
    ManagedMap<String, BeanMetadataElement> consumers = new ManagedMap<String, BeanMetadataElement>();
    for (Object item : consumerElements) {

        BeanDefinitionBuilder consumer = BeanDefinitionBuilder
                .genericBeanDefinition(ConsumerDetailsFactoryBean.class);
        Element consumerElement = (Element) item;
        String key = consumerElement.getAttribute("key");
        if (StringUtils.hasText(key)) {
            consumer.addPropertyValue("consumerKey", key);
        }
        else {
            parserContext.getReaderContext().error(
                    "A consumer key must be supplied with the definition of a consumer.", consumerElement);
        }

        String secret = consumerElement.getAttribute("secret");
        if (StringUtils.hasText(secret)) {
            consumer.addPropertyValue("secret", secret);
            String typeOfSecret = consumerElement.getAttribute("typeOfSecret");
            consumer.addPropertyValue("typeOfSecret", typeOfSecret);
        }
        else {
            parserContext.getReaderContext().error(
                    "A consumer secret must be supplied with the definition of a consumer.", consumerElement);
        }

        String name = consumerElement.getAttribute("name");
        if (StringUtils.hasText(name)) {
            consumer.addPropertyValue("consumerName", name);
        }

        String authorities = consumerElement.getAttribute("authorities");
        if (StringUtils.hasText(authorities)) {
            consumer.addPropertyValue("authorities", authorities);
        }

        String resourceName = consumerElement.getAttribute("resourceName");
        if (StringUtils.hasText(resourceName)) {
            consumer.addPropertyValue("resourceName", resourceName);
        }

        String resourceDescription = consumerElement.getAttribute("resourceDescription");
        if (StringUtils.hasText(resourceDescription)) {
            consumer.addPropertyValue("resourceDescription", resourceDescription);
        }

        String requiredToObtainAuthenticatedToken = consumerElement
                .getAttribute("requiredToObtainAuthenticatedToken");
        if (StringUtils.hasText(requiredToObtainAuthenticatedToken)) {
            consumer.addPropertyValue("requiredToObtainAuthenticatedToken", requiredToObtainAuthenticatedToken);
        }

        consumers.put(key, consumer.getBeanDefinition());
    }

    builder.addPropertyValue("consumerDetailsStore", consumers);
}

public BeanMetadataElement createBeanMetadataElementByIntrospection(Object object) {
    return createMetadataElementByIntrospection(object, new NamedBeanMap(), conversionService);
}

public BeanMetadataElement createBeanMetadataElementByIntrospection(Object object,
        ConversionService conversionService) {
    return createBeanDefinitionByIntrospection(object, new NamedBeanMap(), conversionService);
}

public BeanMetadataElement createBeanMetadataElementByIntrospection(Object object,
        ConversionService conversionService, List<NamedObject> objectList) {
    NamedBeanMap refs = new NamedBeanMap(objectList);
    return createMetadataElementByIntrospection(object, refs, conversionService);
}

public BeanMetadataElement createBeanMetadataElementByIntrospection(Object object, List<NamedObject> objectList) {
    NamedBeanMap refs = new NamedBeanMap(objectList);
    return createMetadataElementByIntrospection(object, refs, conversionService);
}

@Override
protected AbstractBeanDefinition doParse(Element element,
        ParserContext parserContext, String channelName) {

    AbstractBeanDefinition beanDefinitition = null;

    final BeanDefinitionBuilder sqsAdapterBuilder = BeanDefinitionBuilder
            .genericBeanDefinition(SqsSubscribableChannelAdapter.class);

    // create and set sqsExecutor
    final BeanDefinitionBuilder sqsExecutorBuilder = SqsParserUtils
            .getSqsExecutorBuilder(element, parserContext);

    final BeanDefinition sqsExecutorBuilderBeanDefinition = sqsExecutorBuilder
            .getBeanDefinition();
    final String channelAdapterId = this.resolveId(element,
            sqsAdapterBuilder.getRawBeanDefinition(), parserContext);
    final String sqsExecutorBeanName = SqsParserUtils
            .getExecutorBeanName(channelAdapterId);

    parserContext.registerBeanComponent(new BeanComponentDefinition(
            sqsExecutorBuilderBeanDefinition, sqsExecutorBeanName));

    sqsAdapterBuilder.addPropertyReference("sqsExecutor",
            sqsExecutorBeanName);

    SqsParserUtils.registerExecutorProxy(element, sqsExecutorBeanName,
            parserContext);
    // ---

    // Core messaging properties
    sqsAdapterBuilder.addPropertyReference("outputChannel", channelName);
    IntegrationNamespaceUtils.setValueIfAttributeDefined(sqsAdapterBuilder,
            element, "send-timeout");
    IntegrationNamespaceUtils.setValueIfAttributeDefined(sqsAdapterBuilder,
            element, "auto-startup");
    IntegrationNamespaceUtils.setValueIfAttributeDefined(sqsAdapterBuilder,
            element, "phase");
    // ---

    IntegrationNamespaceUtils.setValueIfAttributeDefined(sqsAdapterBuilder,
            element, "worker-shutdown-timeout");

    Element pollerElement = DomUtils.getChildElementByTagName(element,
            "poller");

    if (pollerElement == null) {
        IntegrationNamespaceUtils.setValueIfAttributeDefined(
                sqsAdapterBuilder, element, "concurrent-consumers");

        beanDefinitition = sqsAdapterBuilder.getBeanDefinition();

    } else {
        sqsAdapterBuilder.addPropertyValue("pollableMode", Boolean.TRUE);

        BeanMetadataElement source = sqsAdapterBuilder.getBeanDefinition();
        if (source == null) {
            parserContext.getReaderContext().error(
                    "failed to parse source", element);
        }
        BeanDefinitionBuilder adapterBuilder = BeanDefinitionBuilder
                .genericBeanDefinition(SourcePollingChannelAdapterFactoryBean.class);
        adapterBuilder.addPropertyValue("source", source);
        adapterBuilder.addPropertyReference("outputChannel", channelName);
        IntegrationNamespaceUtils.setValueIfAttributeDefined(
                adapterBuilder, element, "send-timeout");
        IntegrationNamespaceUtils.setValueIfAttributeDefined(
                adapterBuilder, element, "auto-startup");
        IntegrationNamespaceUtils.configurePollerMetadata(pollerElement,
                adapterBuilder, parserContext);

        beanDefinitition = adapterBuilder.getBeanDefinition();
    }

    AwsParserUtils.registerPermissions(element, sqsExecutorBuilder,
            parserContext);

    return beanDefinitition;
}

/**
 * Convert from a DTO to an internal Spring bean definition.
 * 
 * @param beanDefinitionDto The DTO object.
 * @return Returns a Spring bean definition.
 */
BeanMetadataElement toInternal(BeanMetadataElementInfo elementInfo);

/**
 * Creates a bean metadata element by introspecting a Java beans object.
 * 
 * @param object the object to introspect
 * @param conversionService the conversion service to be used to convert simple object types to string
 * @return the bean definition
 */
BeanMetadataElement createBeanMetadataElementByIntrospection(Object object, ConversionService conversionService);

/**
 * Creates a bean metadata by introspecting a Java beans object.
 * 
 * @param object the object to introspect
 * @return the bean definition
 */
BeanMetadataElement createBeanMetadataElementByIntrospection(Object object);

/**
 * Creates a bean metadata element by introspecting a Java beans object.
 * 
 * @param object the object to introspect
 * @param conversionService the conversion service to be used to convert simple object types to string
 * @return the bean definition
 */
BeanMetadataElement createBeanMetadataElementByIntrospection(Object object, ConversionService conversionService,
        List<NamedObject> objectList);

/**
 * Creates a bean metadata by introspecting a Java beans object.
 * 
 * @param object the object to introspect
 * @return the bean definition
 */
BeanMetadataElement createBeanMetadataElementByIntrospection(Object object, List<NamedObject> objectList);