0. Índice de contenidos.
- 1. Introducción.
- 2. Entorno.
- 3. Registro dinámico basado en el escaneo de clases.
- 4. Registro dinámico basado en la lectura de propiedades.
- 5. Referencias.
- 6. Conclusiones.
1. Introducción.
En este tutorial veremos cómo registrar de forma dinámica beans dentro del contexto de Spring, en tiempo de inicialización.
Lo normal es que tengamos el control sobre las instancias de los beans a registrar dentro del contexto de inyección de dependencias de Spring, pero podemos encontrarnos con situaciones en las que el número de beans del mismo tipo sea dinámico y venga dado por la propia configuración de entorno.
Con el soporte de Spring Boot podemos ver ejemplos de dicho registro dinámico, como en el soporte que proporciona de fábrica para definir múltiples datasources.
Pero, ¿cómo lo hace internamente?, ¿cómo podríamos nosotros crear beans, de forma dinámica, en función de nuestras necesidades?, en este tutorial veremos cómo hacerlo.
2. Entorno.
El tutorial está escrito usando el siguiente entorno:
- Hardware: Portátil MacBook Pro 15′ (2.5 GHz Intel Core i7, 16GB DDR3).
- Sistema Operativo: Mac OS Sierra 10.12.5
- Oracle Java: 1.8.0_25
- Spring Boot 1.5.4.RELEASE
- Spring 4.3.9
3. Registro dinámico basado en el escaneo de clases.
En este primer ejemplo vamos a ver cómo podemos registrar un número indeterminado de beans basándonos en el escaneo de clases y, en concreto,
en la búsqueda por reflexión de clases anotadas con una anotación de clientes de servicios web de jax-ws.
Imaginad que tenemos una librería de clientes de servicios web generada o autogenerada en base a una definición de contrato de servicios web
y queremos registrar un proxy de apache-cxf en el contexto de Spring para hacer uso de los mismos de forma transparente.
Podríamos tener un post procesador con un código como el siguiente:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 |
package com.sanchezsuarezjm.tutos.spring; import java.beans.Introspector; import java.util.List; import javax.jws.WebService; import org.apache.cxf.feature.LoggingFeature; import org.apache.cxf.interceptor.Interceptor; import org.apache.cxf.jaxws.JaxWsProxyFactoryBean; import org.apache.cxf.message.Message; import org.reflections.Reflections; import org.reflections.scanners.ResourcesScanner; import org.reflections.scanners.SubTypesScanner; import org.reflections.scanners.TypeAnnotationsScanner; import org.reflections.util.ClasspathHelper; import org.reflections.util.ConfigurationBuilder; import org.reflections.util.FilterBuilder; import org.springframework.beans.BeansException; import org.springframework.beans.factory.config.ConfigurableListableBeanFactory; import org.springframework.beans.factory.support.BeanDefinitionRegistry; import org.springframework.beans.factory.support.BeanDefinitionRegistryPostProcessor; import org.springframework.context.ApplicationContext; import org.springframework.context.ApplicationContextAware; import lombok.extern.slf4j.Slf4j; @Slf4j public class WebServiceContextInitializer implements BeanDefinitionRegistryPostProcessor, ApplicationContextAware { private static final String BEAN_NAME_PREFIX = "jaxws:"; private static final String BEAN_NAME_SUFFIX = "Client"; private List<Interceptor<? extends Message>> interceptors; private Interceptor<? extends Message> faultInterceptor; private ApplicationContext applicationContext; public WebServiceContextInitializer(List<Interceptor<? extends Message>> interceptors, Interceptor<? extends Message> faultInterceptor) { this.interceptors = interceptors; this.faultInterceptor = faultInterceptor; } @Override public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException { String packageName = applicationContext.getEnvironment().getProperty("jaxws.clients.basePackage"); if (packageName == null) { packageName = ""; } log.info("Scanning {} ... ", packageName); final Reflections ref = new Reflections(new ConfigurationBuilder() .setScanners(new SubTypesScanner(), new TypeAnnotationsScanner(), new ResourcesScanner()) .setUrls(ClasspathHelper.forPackage(packageName)) .filterInputsBy(new FilterBuilder().include(FilterBuilder.prefix(packageName)))); ref.getTypesAnnotatedWith(WebService.class) .forEach(clazz -> { final String beanName = Introspector.decapitalize(clazz.getSimpleName()).concat(BEAN_NAME_SUFFIX); log.info("Defining ws-client bean: {} of {}", beanName, clazz.getCanonicalName()); final JaxWsProxyFactoryBean jaxWsProxyFactoryBean = new JaxWsProxyFactoryBean(); jaxWsProxyFactoryBean.setServiceClass(clazz); final String endPointProperty = "jaxws.clients."+ beanName +".endPoint"; final String address = applicationContext.getEnvironment().getProperty(endPointProperty); if (address == null) { throw new IllegalStateException( "EndPoint property definition not found. Please define a value for ".concat(endPointProperty)); } jaxWsProxyFactoryBean.setAddress(address); if (interceptors != null) { jaxWsProxyFactoryBean.getOutInterceptors().addAll(interceptors); } if (faultInterceptor != null){ jaxWsProxyFactoryBean.getInFaultInterceptors().add(faultInterceptor); } jaxWsProxyFactoryBean.getFeatures().add(new LoggingFeature()); final Object runtimeService = jaxWsProxyFactoryBean.create(); beanFactory.registerSingleton(BEAN_NAME_PREFIX.concat(beanName), runtimeService); }); } @Override public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException { // do nothing through the registry } @Override public void setApplicationContext(ApplicationContext applicationContext) throws BeansException { this.applicationContext = applicationContext; } } |
El procesador espera tener definidas únicamente un par de propiedades:
- jaxws.clients.basePackage: con el paquete base de escaneo, sino lo escanea todo,
- jaxws.clients.<webServiceClientName>.endPoint: con la url del endPoint en el entorno correspondiente.
y estas propiedades pueden estar definidas en cualquier fichero dentro de la jerarquía de lectura de propiedades de Spring y/o Spring Boot.
Se ejecuta en el arranque del contexto de Spring justo después de la configuración convencional, pero sin haber instanciado aun ningún bean,
es por ello que para la lectura de propiedades debemos acceder a las mismas programáticamente.
Solo nos quedaría configurar el procesador como cualquier otro bean en una clase de @Configuration, pero con un modificador static.
|
1 2 3 4 5 6 7 8 9 10 |
@Configuration @ConditionalOnProperty(name = "jaxws.clients.enabled", matchIfMissing = true) public class WebServiceClientConfig { @Bean public static WebServiceContextInitializer webServiceContextInitializer(List<Interceptor<? extends Message>> interceptors) { return new WebServiceContextInitializer(interceptors, new SoapFaultInterceptor()); } } |
4. Registro dinámico basado en la lectura de propiedades.
Podemos usar otra técnica que nos permitirá el registro múltiple de beans de forma dinámica basado en la lectura de propiedades.
Imaginad que ahora queremos declarar e instanciar tantos beans de un mismo tipo como propiedades tengamos definidas con un prefijo concreto. Podrían ser clientes de mensajería y necesitaríamos crear tantas plantillas de jms como número de ocurrencias en nuestras properties.
Lo primero que podemos hacer es definir una interfaz para la definición dinámica de múltiples beans, como la siguiente:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
package com.sanchezsuarezjm.tutos.spring; import java.util.Collection; public interface MultiBeanFactory<T> { String getBeanName(String name); T getObject(String name) throws Exception; Class<?> getObjectType(); Collection<String> getNames(); } |
A continuación podemos registrar un postprocesador que recuperando instancias de la factoría de beans ya registrados del tipo de interfaz anterior,
registre de forma dinámica instancias de los mismos.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 |
package com.sanchezsuarezjm.tutos.spring; import lombok.extern.slf4j.Slf4j; import org.springframework.beans.BeansException; import org.springframework.beans.factory.config.BeanDefinition; import org.springframework.beans.factory.config.BeanFactoryPostProcessor; import org.springframework.beans.factory.config.ConfigurableListableBeanFactory; import org.springframework.beans.factory.support.BeanDefinitionBuilder; import org.springframework.beans.factory.support.BeanDefinitionRegistry; import java.util.Map; @Slf4j public class MultiBeanFactoryPostProcessor implements BeanFactoryPostProcessor { @SuppressWarnings({ "rawtypes"}) @Override public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException { BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory; Map<String, MultiBeanFactory> factories = beanFactory.getBeansOfType(MultiBeanFactory.class); registerBeans(registry, factories); } @SuppressWarnings({ "rawtypes", "unchecked" }) private void registerBeans(BeanDefinitionRegistry registry, Map<String, MultiBeanFactory> factories) { factories.forEach((factoryName, factory) -> { factory.getNames().forEach(bean -> { final String beanName = factory.getBeanName( (String) bean); BeanDefinition definition = BeanDefinitionBuilder.genericBeanDefinition(factory.getObjectType()) .setScope(BeanDefinition.SCOPE_SINGLETON).setFactoryMethod("getObject") .addConstructorArgValue(bean).getBeanDefinition(); definition.setFactoryBeanName(factoryName); log.info("Registering {} of {}", beanName, definition); registry.registerBeanDefinition(beanName, definition); }); }); } } |
Quedaría declarar el procesador como sigue:
|
1 2 3 4 5 6 7 8 9 10 |
@Configuration @ConditionalOnProperty(name = "jaxws.clients.enabled", matchIfMissing = true) public class MultiBeanFactoryConfig { @Bean public static MultiBeanFactoryPostProcessor multiBeanFactoryPostProcessor() { return new MultiBeanFactoryPostProcessor(); } } |
Y, a partir de ese momento, podemos definir en cualquier @Configuration beans de tipo MultiBeanFactory, para declarar el posterior registro
de forma dinámica de beans de un tipo concreto.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 |
import java.util.Arrays; import java.util.Collection; import javax.jms.ConnectionFactory; import javax.jms.JMSException; import javax.jms.Session; import org.springframework.beans.factory.BeanFactory; import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty; import org.springframework.boot.bind.PropertySourcesPropertyValues; import org.springframework.boot.bind.RelaxedDataBinder; import org.springframework.context.EnvironmentAware; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframework.context.annotation.Primary; import org.springframework.core.env.AbstractEnvironment; import org.springframework.core.env.Environment; import org.springframework.jms.annotation.EnableJms; import org.springframework.jms.connection.CachingConnectionFactory; import org.springframework.jms.connection.JmsTransactionManager; import org.springframework.jms.core.JmsTemplate; import org.springframework.util.Assert; import lombok.extern.slf4j.Slf4j; @Configuration @ConditionalOnProperty(name = JmsAutoConfiguration.JMS_CONFIG_PREFIX + ".enabled", havingValue="true", matchIfMissing = false) @EnableJms @Slf4j public class JmsAutoConfiguration implements EnvironmentAware{ protected static final String JMS_CONFIG_PREFIX = "jms"; private Environment environment; @Bean public JmsProperties jmsProperties(){ final JmsProperties jmsProperties = new JmsProperties(); new RelaxedDataBinder(jmsProperties, JMS_CONFIG_PREFIX).bind(new PropertySourcesPropertyValues(((AbstractEnvironment) getEnvironment()).getPropertySources())); if (jmsProperties.getChannel() == null){ throw new IllegalStateException("No " + JMS_CONFIG_PREFIX + ".channel.* found in properties"); } log.trace("{} channels found in properties." , jmsProperties.getChannel().size()); return jmsProperties; } @Primary @Bean public MultiBeanFactory<ConnectionFactory> connectionManagerFactory( jmsProperties jmsProperties, BeanFactory beanFactory) { return new MultiBeanFactory<ConnectionFactory>() { @Override public ConnectionFactory getObject(String name) throws Exception { // generación de la factoría de conexiones para jms, con el nombre del canal y las propiedades del mismo return buildConnectionFactory(name, jmsProperties); } @Override public Class<?> getObjectType() { return ConnectionFactory.class; } @Override public String getBeanName(String name) { return (getNames().size() == 1) ? "connectionFactory" : name.concat(ConnectionFactory.class.getSimpleName()); } @Override public Collection<String> getNames() { return Arrays.asList(jmsProperties.getChannel().keySet().toArray(new String[0])); } }; } @Primary @Bean public MultiBeanFactory<JmsTemplate> jmsTemplateFactory ( JmsProperties jmsProperties, BeanFactory beanFactory) { return new MultiBeanFactory<JmsTemplate >() { @Override public JmsTemplate getObject(String name) throws Exception { final JmsTemplate jmsTemplate = new JmsTemplate(beanFactory.getBean((getNames().size() == 1) ? "connectionFactory" : name.concat(ConnectionFactory.class.getSimpleName()), ConnectionFactory.class)); final Integer receiveTimeout = jmsProperties.getChannel().get(name) != null && jmsProperties.getChannel().get(name).getReceiveTimeout() != null ? jmsProperties.getChannel().get(name).getReceiveTimeout() : jmsProperties.getReceiveTimeout(); if (receiveTimeout != null) { jmsTemplate.setReceiveTimeout(receiveTimeout); } // configuración de la plantilla conforme al valor de las propiedades leídas return jmsTemplate; } @Override public Class<?> getObjectType() { return JmsTemplate.class; } @Override public String getBeanName(String name) { return (getNames().size() == 1) ? "jmsTemplate" : name.concat(JmsTemplate.class.getSimpleName()); } @Override public Collection<String> getNames() { return Arrays.asList(jmsProperties.getChannel().keySet().toArray(new String[0])); } }; } } |
Lo más interesante de todo es la lectura de propiedades para, en función del array encontrado se declaren tantos beans
como sea necesario. Para ello nos apoyamos en una clase de propiedades que se enriquece gracias al soporte de la clase RelaxedDataBinder
de Spring Boot.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
@Setter @Getter public class JmsProperties { private String hostName; private Integer port; private String channelName; private Map<String, JmsProperties> channel; } |
Cualquier fichero de propiedades podría tener el siguiente contenido y se generarían tantas plantillas como «channel» se definan:
|
1 2 3 4 5 6 7 8 |
jms.enabled=true jms.channel.testChannel1.channelName=TEST1 jms.channel.testChannel1.hostName=localhost jms.channel.testChannel1.port=9999 jms.channel.testChannel2.channelName=TEST2 jms.channel.testChannel2.hostName=localhost jms.channel.testChannel2.port=9998 |
5. Referencias.
- http://www.logicbig.com/tutorials/spring-framework/spring-core/bean-definition/
- http://www.baeldung.com/spring-data-jpa-multiple-databases
- https://medium.com/@joeclever/using-multiple-datasources-with-spring-boot-and-spring-data-6430b00c02e7
6. Conclusiones.
Hace más de 10 años que escribíamos el primer tutorial sobre registro dinámico de beans en el contexto de Spring, el ecosistema de Spring se ha ampliado
mucho, pero la esencia sigue siendo la misma.
Un saludo.
Jose
