List of usage examples for org.springframework.beans.factory.support BeanDefinitionBuilder genericBeanDefinition
public static BeanDefinitionBuilder genericBeanDefinition(Class<?> beanClass)
From source file:org.springframework.integration.config.xml.DefaultConfiguringBeanFactoryPostProcessor.java
/** * Register a TaskScheduler in the given BeanDefinitionRegistry. *//* ww w .j a va2 s . c om*/ private void registerTaskScheduler(BeanDefinitionRegistry registry) { if (logger.isInfoEnabled()) { logger.info("No bean named '" + IntegrationContextUtils.TASK_SCHEDULER_BEAN_NAME + "' has been explicitly defined. Therefore, a default ThreadPoolTaskScheduler will be created."); } BeanDefinitionBuilder schedulerBuilder = BeanDefinitionBuilder .genericBeanDefinition("org.springframework.scheduling.concurrent.ThreadPoolTaskScheduler"); schedulerBuilder.addPropertyValue("poolSize", 10); schedulerBuilder.addPropertyValue("threadNamePrefix", "task-scheduler-"); schedulerBuilder.addPropertyValue("rejectedExecutionHandler", new CallerRunsPolicy()); BeanDefinitionBuilder errorHandlerBuilder = BeanDefinitionBuilder.genericBeanDefinition( IntegrationNamespaceUtils.BASE_PACKAGE + ".channel.MessagePublishingErrorHandler"); errorHandlerBuilder.addPropertyReference("defaultErrorChannel", IntegrationContextUtils.ERROR_CHANNEL_BEAN_NAME); schedulerBuilder.addPropertyValue("errorHandler", errorHandlerBuilder.getBeanDefinition()); BeanComponentDefinition schedulerComponent = new BeanComponentDefinition( schedulerBuilder.getBeanDefinition(), IntegrationContextUtils.TASK_SCHEDULER_BEAN_NAME); BeanDefinitionReaderUtils.registerBeanDefinition(schedulerComponent, registry); }
From source file:org.springframework.integration.config.xml.PointToPointChannelParser.java
@Override protected BeanDefinitionBuilder buildBeanDefinition(Element element, ParserContext parserContext) { BeanDefinitionBuilder builder = null; Element queueElement = null;//www . jav a2s . c o m // configure a queue-based channel if any queue sub-element is defined if ((queueElement = DomUtils.getChildElementByTagName(element, "queue")) != null) { builder = BeanDefinitionBuilder.genericBeanDefinition(QueueChannel.class); boolean hasStoreRef = this.parseStoreRef(builder, queueElement, element.getAttribute(ID_ATTRIBUTE)); boolean hasQueueRef = this.parseQueueRef(builder, queueElement); if (!hasStoreRef) { boolean hasCapacity = this.parseQueueCapacity(builder, queueElement); if (hasCapacity && hasQueueRef) { parserContext.getReaderContext().error("The 'capacity' attribute is not allowed" + " when providing a 'ref' to a custom queue.", element); } } if (hasStoreRef && hasQueueRef) { parserContext.getReaderContext().error("The 'message-store' attribute is not allowed" + " when providing a 'ref' to a custom queue.", element); } } else if ((queueElement = DomUtils.getChildElementByTagName(element, "priority-queue")) != null) { builder = BeanDefinitionBuilder.genericBeanDefinition(PriorityChannel.class); this.parseQueueCapacity(builder, queueElement); String comparatorRef = queueElement.getAttribute("comparator"); if (StringUtils.hasText(comparatorRef)) { builder.addConstructorArgReference(comparatorRef); } } else if ((queueElement = DomUtils.getChildElementByTagName(element, "rendezvous-queue")) != null) { builder = BeanDefinitionBuilder.genericBeanDefinition(RendezvousChannel.class); } Element dispatcherElement = DomUtils.getChildElementByTagName(element, "dispatcher"); // check for the dispatcher attribute (deprecated) String dispatcherAttribute = element.getAttribute("dispatcher"); boolean hasDispatcherAttribute = StringUtils.hasText(dispatcherAttribute); if (hasDispatcherAttribute && logger.isWarnEnabled()) { logger.warn("The 'dispatcher' attribute on the 'channel' element is deprecated. " + "Please use the 'dispatcher' sub-element instead."); } // verify that a dispatcher is not provided if a queue sub-element exists if (queueElement != null && (dispatcherElement != null || hasDispatcherAttribute)) { parserContext.getReaderContext().error("The 'dispatcher' attribute or sub-element " + "and any queue sub-element are mutually exclusive.", element); return null; } if (queueElement != null) { return builder; } if (dispatcherElement != null && hasDispatcherAttribute) { parserContext.getReaderContext() .error("The 'dispatcher' attribute and 'dispatcher' " + "sub-element are mutually exclusive. NOTE: the attribute is DEPRECATED. " + "Please use the dispatcher sub-element instead.", element); return null; } if (hasDispatcherAttribute) { // this attribute is deprecated, but if set, we need to create a DirectChannel // without any LoadBalancerStrategy and the failover flag set to true (default). builder = BeanDefinitionBuilder.genericBeanDefinition(DirectChannel.class); if ("failover".equals(dispatcherAttribute)) { // round-robin dispatcher is used by default, the "failover" value simply disables it builder.addConstructorArgValue(null); } } else if (dispatcherElement == null) { // configure the default DirectChannel with a RoundRobinLoadBalancingStrategy builder = BeanDefinitionBuilder.genericBeanDefinition(DirectChannel.class); String maxSubscribers = this.getDefaultMaxSubscribers(parserContext, IntegrationNamespaceUtils.DEFAULT_MAX_UNICAST_SUBSCRIBERS_PROPERTY_NAME); if (maxSubscribers != null) { builder.addPropertyValue("maxSubscribers", maxSubscribers); } } else { // configure either an ExecutorChannel or DirectChannel based on existence of 'task-executor' String taskExecutor = dispatcherElement.getAttribute("task-executor"); if (StringUtils.hasText(taskExecutor)) { builder = BeanDefinitionBuilder.genericBeanDefinition(ExecutorChannel.class); builder.addConstructorArgReference(taskExecutor); } else { builder = BeanDefinitionBuilder.genericBeanDefinition(DirectChannel.class); } // unless the 'load-balancer' attribute is explicitly set to 'none', // configure the default RoundRobinLoadBalancingStrategy String loadBalancer = dispatcherElement.getAttribute("load-balancer"); if ("none".equals(loadBalancer)) { builder.addConstructorArgValue(null); } IntegrationNamespaceUtils.setValueIfAttributeDefined(builder, dispatcherElement, "failover"); this.setMaxSubscribersProperty(parserContext, builder, dispatcherElement, IntegrationNamespaceUtils.DEFAULT_MAX_UNICAST_SUBSCRIBERS_PROPERTY_NAME); } return builder; }
From source file:org.springframework.integration.config.xml.PointToPointChannelParser.java
private boolean parseStoreRef(BeanDefinitionBuilder builder, Element queueElement, String channel) { String storeRef = queueElement.getAttribute("message-store"); if (StringUtils.hasText(storeRef)) { BeanDefinitionBuilder queueBuilder = BeanDefinitionBuilder .genericBeanDefinition(MessageGroupQueue.class); queueBuilder.addConstructorArgReference(storeRef); queueBuilder.addConstructorArgValue(new TypedStringValue(storeRef).getValue() + ":" + channel); parseQueueCapacity(queueBuilder, queueElement); builder.addConstructorArgValue(queueBuilder.getBeanDefinition()); return true; }//w ww . j a v a 2 s . c om return false; }
From source file:org.springframework.integration.http.config.HttpIntegrationConfigurationInitializer.java
/** * Registers an {@link IntegrationRequestMappingHandlerMapping} * which could also be overridden by the user by simply registering * a {@link IntegrationRequestMappingHandlerMapping} {@code <bean>} with 'id' * {@link HttpContextUtils#HANDLER_MAPPING_BEAN_NAME}. * <p>/*from w ww . j a v a 2 s .c o m*/ * In addition, checks if the {@code javax.servlet.Servlet} class is present on the classpath. * When Spring Integration HTTP is used only as an HTTP client, there is no reason to use and register * the HTTP server components. */ private void registerRequestMappingHandlerMappingIfNecessary(BeanDefinitionRegistry registry) { if (HttpContextUtils.SERVLET_PRESENT && !registry.containsBeanDefinition(HttpContextUtils.HANDLER_MAPPING_BEAN_NAME)) { BeanDefinitionBuilder requestMappingBuilder = BeanDefinitionBuilder .genericBeanDefinition(IntegrationRequestMappingHandlerMapping.class); requestMappingBuilder.setRole(BeanDefinition.ROLE_INFRASTRUCTURE); requestMappingBuilder.addPropertyValue(IntegrationNamespaceUtils.ORDER, 0); registry.registerBeanDefinition(HttpContextUtils.HANDLER_MAPPING_BEAN_NAME, requestMappingBuilder.getBeanDefinition()); } }
From source file:org.springframework.integration.jdbc.config.StoredProcParserUtils.java
/** * @param storedProcComponent/*from w w w .j a v a 2s . c om*/ * @param parserContext */ public static ManagedList<BeanDefinition> getSqlParameterDefinitionBeanDefinitions(Element storedProcComponent, ParserContext parserContext) { List<Element> sqlParameterDefinitionChildElements = DomUtils.getChildElementsByTagName(storedProcComponent, "sql-parameter-definition"); ManagedList<BeanDefinition> sqlParameterList = new ManagedList<BeanDefinition>(); for (Element childElement : sqlParameterDefinitionChildElements) { String name = childElement.getAttribute("name"); String sqlType = childElement.getAttribute("type"); String direction = childElement.getAttribute("direction"); String scale = childElement.getAttribute("scale"); String typeName = childElement.getAttribute("type-name"); String returnType = childElement.getAttribute("return-type"); if (StringUtils.hasText(typeName) && StringUtils.hasText(scale)) { parserContext.getReaderContext().error("'type-name' and 'scale' attributes are mutually exclusive " + "for 'sql-parameter-definition' element.", storedProcComponent); } if (StringUtils.hasText(returnType) && StringUtils.hasText(scale)) { parserContext.getReaderContext().error("'returnType' and 'scale' attributes are mutually exclusive " + "for 'sql-parameter-definition' element.", storedProcComponent); } final BeanDefinitionBuilder parameterBuilder; if ("OUT".equalsIgnoreCase(direction)) { parameterBuilder = BeanDefinitionBuilder.genericBeanDefinition(SqlOutParameter.class); } else if ("INOUT".equalsIgnoreCase(direction)) { parameterBuilder = BeanDefinitionBuilder.genericBeanDefinition(SqlInOutParameter.class); } else { parameterBuilder = BeanDefinitionBuilder.genericBeanDefinition(SqlParameter.class); if (StringUtils.hasText(returnType)) { parserContext.getReaderContext().error("'return-type' attribute can't be provided " + "for IN 'sql-parameter-definition' element.", storedProcComponent); } } if (StringUtils.hasText(name)) { parameterBuilder.addConstructorArgValue(name); } else { parserContext.getReaderContext().error( "The 'name' attribute must be set for the Sql parameter element.", storedProcComponent); } if (StringUtils.hasText(sqlType)) { JdbcTypesEnum jdbcTypeEnum = JdbcTypesEnum.convertToJdbcTypesEnum(sqlType); if (jdbcTypeEnum != null) { parameterBuilder.addConstructorArgValue(jdbcTypeEnum.getCode()); } else { parameterBuilder.addConstructorArgValue(sqlType); } } else { parameterBuilder.addConstructorArgValue(Types.VARCHAR); } if (StringUtils.hasText(typeName)) { parameterBuilder.addConstructorArgValue(typeName); } else if (StringUtils.hasText(scale)) { parameterBuilder.addConstructorArgValue(new TypedStringValue(scale, Integer.class)); } else { parameterBuilder.addConstructorArgValue(null); } if (StringUtils.hasText(returnType)) { parameterBuilder.addConstructorArgReference(returnType); } sqlParameterList.add(parameterBuilder.getBeanDefinition()); } return sqlParameterList; }
From source file:org.springframework.integration.jdbc.config.StoredProcParserUtils.java
/** * @param storedProcComponent// ww w. jav a2s. c o m * @param parserContext */ public static ManagedList<BeanDefinition> getProcedureParameterBeanDefinitions(Element storedProcComponent, ParserContext parserContext) { ManagedList<BeanDefinition> procedureParameterList = new ManagedList<BeanDefinition>(); List<Element> parameterChildElements = DomUtils.getChildElementsByTagName(storedProcComponent, "parameter"); for (Element childElement : parameterChildElements) { BeanDefinitionBuilder parameterBuilder = BeanDefinitionBuilder .genericBeanDefinition(ProcedureParameter.class); String name = childElement.getAttribute("name"); String expression = childElement.getAttribute("expression"); String value = childElement.getAttribute("value"); String type = childElement.getAttribute("type"); if (StringUtils.hasText(name)) { parameterBuilder.addPropertyValue("name", name); } if (StringUtils.hasText(expression)) { parameterBuilder.addPropertyValue("expression", expression); } if (StringUtils.hasText(value)) { if (!StringUtils.hasText(type)) { if (LOGGER.isInfoEnabled()) { LOGGER.info(String.format("Type attribute not set for Store " + "Procedure parameter '%s'. Defaulting to " + "'java.lang.String'.", value)); } parameterBuilder.addPropertyValue("value", new TypedStringValue(value, String.class)); } else { parameterBuilder.addPropertyValue("value", new TypedStringValue(value, type)); } } procedureParameterList.add(parameterBuilder.getBeanDefinition()); } return procedureParameterList; }
From source file:org.springframework.integration.jdbc.config.StoredProcParserUtils.java
/** * @param storedProcComponent/* w w w. ja v a 2s .c o m*/ * @param parserContext */ public static ManagedMap<String, BeanDefinition> getReturningResultsetBeanDefinitions( Element storedProcComponent, ParserContext parserContext) { List<Element> returningResultsetChildElements = DomUtils.getChildElementsByTagName(storedProcComponent, "returning-resultset"); ManagedMap<String, BeanDefinition> returningResultsetMap = new ManagedMap<String, BeanDefinition>(); for (Element childElement : returningResultsetChildElements) { String name = childElement.getAttribute("name"); String rowMapperAsString = childElement.getAttribute("row-mapper"); BeanDefinitionBuilder rowMapperBuilder = BeanDefinitionBuilder.genericBeanDefinition(rowMapperAsString); returningResultsetMap.put(name, rowMapperBuilder.getBeanDefinition()); } return returningResultsetMap; }
From source file:org.springframework.integration.jdbc.config.StoredProcParserUtils.java
/** * Create a new {@link BeanDefinitionBuilder} for the class {@link StoredProcExecutor}. * Initialize the wrapped {@link StoredProcExecutor} with common properties. * * @param element Must not be Null//from w ww . j av a 2s . co m * @param parserContext Must not be Null * @return The {@link BeanDefinitionBuilder} for the {@link StoredProcExecutor} */ public static BeanDefinitionBuilder getStoredProcExecutorBuilder(final Element element, final ParserContext parserContext) { Assert.notNull(element, "The provided element must not be Null."); Assert.notNull(parserContext, "The provided parserContext must not be Null."); final String dataSourceRef = element.getAttribute("data-source"); final BeanDefinitionBuilder storedProcExecutorBuilder = BeanDefinitionBuilder .genericBeanDefinition(StoredProcExecutor.class); storedProcExecutorBuilder.addConstructorArgReference(dataSourceRef); final String storedProcedureName = element.getAttribute("stored-procedure-name"); final String storedProcedureNameExpression = element.getAttribute("stored-procedure-name-expression"); boolean hasStoredProcedureName = StringUtils.hasText(storedProcedureName); boolean hasStoredProcedureNameExpression = StringUtils.hasText(storedProcedureNameExpression); if (!(hasStoredProcedureName ^ hasStoredProcedureNameExpression)) { parserContext.getReaderContext().error( "Exactly one of 'stored-procedure-name' or 'stored-procedure-name-expression' is required", element); } BeanDefinitionBuilder expressionBuilder; if (hasStoredProcedureNameExpression) { expressionBuilder = BeanDefinitionBuilder.genericBeanDefinition(ExpressionFactoryBean.class); expressionBuilder.addConstructorArgValue(storedProcedureNameExpression); } else { expressionBuilder = BeanDefinitionBuilder.genericBeanDefinition(LiteralExpression.class); expressionBuilder.addConstructorArgValue(storedProcedureName); } storedProcExecutorBuilder.addPropertyValue("storedProcedureNameExpression", expressionBuilder.getBeanDefinition()); IntegrationNamespaceUtils.setValueIfAttributeDefined(storedProcExecutorBuilder, element, "ignore-column-meta-data"); IntegrationNamespaceUtils.setValueIfAttributeDefined(storedProcExecutorBuilder, element, "jdbc-call-operations-cache-size"); final ManagedList<BeanDefinition> procedureParameterList = StoredProcParserUtils .getProcedureParameterBeanDefinitions(element, parserContext); final ManagedList<BeanDefinition> sqlParameterDefinitionList = StoredProcParserUtils .getSqlParameterDefinitionBeanDefinitions(element, parserContext); if (!procedureParameterList.isEmpty()) { storedProcExecutorBuilder.addPropertyValue("procedureParameters", procedureParameterList); } if (!sqlParameterDefinitionList.isEmpty()) { storedProcExecutorBuilder.addPropertyValue("sqlParameters", sqlParameterDefinitionList); } return storedProcExecutorBuilder; }
From source file:org.springframework.integration.jms.SubscribableJmsChannelTests.java
@Test public void contextManagesLifecycle() { BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition(JmsChannelFactoryBean.class); builder.addConstructorArgValue(true); builder.addPropertyValue("connectionFactory", this.connectionFactory); builder.addPropertyValue("destinationName", "dynamicQueue"); builder.addPropertyValue("pubSubDomain", false); StaticApplicationContext context = new StaticApplicationContext(); context.registerBeanDefinition("channel", builder.getBeanDefinition()); SubscribableJmsChannel channel = context.getBean("channel", SubscribableJmsChannel.class); assertFalse(channel.isRunning());/*from w w w .j a va2s. c om*/ context.refresh(); assertTrue(channel.isRunning()); context.stop(); assertFalse(channel.isRunning()); context.close(); }
From source file:org.springframework.integration.jpa.config.xml.JpaParserUtils.java
/** * Create a new {@link BeanDefinitionBuilder} for the class {@link JpaExecutor}. * Initialize the wrapped {@link JpaExecutor} with common properties. * * @param element Must not be null/*w w w . j av a 2 s . co m*/ * @param parserContext Must not be null * @return The BeanDefinitionBuilder for the JpaExecutor */ public static BeanDefinitionBuilder getJpaExecutorBuilder(final Element element, final ParserContext parserContext) { Assert.notNull(element, "The provided element must not be null."); Assert.notNull(parserContext, "The provided parserContext must not be null."); final Object source = parserContext.extractSource(element); final BeanDefinitionBuilder jpaExecutorBuilder = BeanDefinitionBuilder .genericBeanDefinition(JpaExecutor.class); int attributeCount = 0; final String entityManagerRef = element.getAttribute("entity-manager"); final String entityManagerFactoryRef = element.getAttribute("entity-manager-factory"); final String jpaOperationsRef = element.getAttribute("jpa-operations"); if (StringUtils.hasText(jpaOperationsRef)) { attributeCount++; jpaExecutorBuilder.addConstructorArgReference(jpaOperationsRef); } if (StringUtils.hasText(entityManagerRef)) { if (attributeCount > 0) { parserContext.getReaderContext().error("Exactly only one of the attributes 'entity-manager' or " + "'entity-manager-factory' or 'jpa-operations' must be be set.", source); } attributeCount++; jpaExecutorBuilder.addConstructorArgReference(entityManagerRef); } if (StringUtils.hasText(entityManagerFactoryRef)) { if (attributeCount > 0) { parserContext.getReaderContext().error("Exactly only one of the attributes 'entity-manager' or " + "'entity-manager-factory' or 'jpa-operations' must be be set.", source); } attributeCount++; jpaExecutorBuilder.addConstructorArgReference(entityManagerFactoryRef); } if (attributeCount == 0) { parserContext.getReaderContext().error("Exactly one of the attributes 'entity-manager' or " + "'entity-manager-factory' or 'jpa-operations' must be be set.", source); } final ManagedList<BeanDefinition> jpaParameterList = JpaParserUtils.getJpaParameterBeanDefinitions(element, parserContext); if (!jpaParameterList.isEmpty()) { jpaExecutorBuilder.addPropertyValue("jpaParameters", jpaParameterList); } IntegrationNamespaceUtils.setValueIfAttributeDefined(jpaExecutorBuilder, element, "entity-class"); IntegrationNamespaceUtils.setValueIfAttributeDefined(jpaExecutorBuilder, element, "jpa-query"); IntegrationNamespaceUtils.setValueIfAttributeDefined(jpaExecutorBuilder, element, "native-query"); IntegrationNamespaceUtils.setValueIfAttributeDefined(jpaExecutorBuilder, element, "named-query"); return jpaExecutorBuilder; }