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; }
/** * 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(); }
@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);