feat: use configuration properties

Author: juanmarin-co

async/async-commons-starter/async-commons-starter.gradle

@@ -75,5 +75,8 @@ bintray {
 dependencies {
     compile project(":async-commons")
     api('org.springframework.boot:spring-boot-starter')
+
+    annotationProcessor 'org.springframework.boot:spring-boot-configuration-processor'
+
     testImplementation 'io.projectreactor:reactor-test'
 }

async/async-commons-starter/src/main/java/org/reactivecommons/async/impl/config/MessageListenersConfig.java

@@ -1,5 +1,6 @@
 package org.reactivecommons.async.impl.config;
 
+import lombok.RequiredArgsConstructor;
 import org.reactivecommons.async.api.DefaultCommandHandler;
 import org.reactivecommons.async.api.DefaultQueryHandler;
 import org.reactivecommons.async.api.DynamicRegistry;
@@ -12,6 +13,7 @@
 import org.reactivecommons.async.impl.HandlerResolver;
 import org.reactivecommons.async.impl.communications.ReactiveMessageListener;
 import org.reactivecommons.async.impl.communications.ReactiveMessageSender;
+import org.reactivecommons.async.impl.config.props.AsyncProps;
 import org.reactivecommons.async.impl.converters.MessageConverter;
 import org.reactivecommons.async.impl.listeners.ApplicationCommandListener;
 import org.reactivecommons.async.impl.listeners.ApplicationEventListener;
@@ -22,53 +24,60 @@
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.context.annotation.Import;
-import org.springframework.core.env.Environment;
 import reactor.core.publisher.Mono;
 
 import java.util.Map;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ConcurrentMap;
 
 @Configuration
+@RequiredArgsConstructor
 @Import(RabbitMqConfig.class)
 public class MessageListenersConfig {
 
-    @Value("${app.async.domain.events.exchange:domainEvents}")
-    private String domainEventsExchangeName;
-
     @Value("${spring.application.name}")
     private String appName;
 
-    @Value("${app.async.direct.exchange:directMessages}")
-    private String directMessagesExchangeName;
-
-    @Value("${app.async.maxRetries:10}")
-    private long maxRetries;
-
-    @Value("${app.async.retryDelay:1000}")
-    private int retryDelay;
+    private final AsyncProps asyncProps;
 
-    @Value("${app.async.withDLQRetry:false}")
-    private boolean withDLQRetry;
 
     @Bean //TODO: move to own config (QueryListenerConfig)
-    public ApplicationEventListener eventListener(HandlerResolver resolver, MessageConverter messageConverter, ReactiveMessageListener receiver, DiscardNotifier discardNotifier) throws Exception {
-        final ApplicationEventListener listener = new ApplicationEventListener(receiver, appName + ".subsEvents", resolver, domainEventsExchangeName, messageConverter, withDLQRetry, maxRetries, retryDelay, discardNotifier);
+    public ApplicationEventListener eventListener(HandlerResolver resolver, MessageConverter messageConverter,
+                                                  ReactiveMessageListener receiver, DiscardNotifier discardNotifier) {
+        final ApplicationEventListener listener = new ApplicationEventListener(receiver,
+                appName + ".subsEvents", resolver, asyncProps.getDomain().getEvents().getExchange(),
+                messageConverter, asyncProps.getWithDLQRetry(), asyncProps.getMaxRetries(), asyncProps.getRetryDelay(),
+                discardNotifier);
+
         listener.startListener();
+
         return listener;
     }
 
     @Bean //TODO: move to own config (QueryListenerConfig)
-    public ApplicationQueryListener queryListener(MessageConverter converter, HandlerResolver resolver, ReactiveMessageSender sender, ReactiveMessageListener rlistener, DiscardNotifier discardNotifier) throws Exception {
-        final ApplicationQueryListener listener = new ApplicationQueryListener(rlistener, appName+".query", resolver, sender, directMessagesExchangeName, converter, "globalReply", withDLQRetry, maxRetries, retryDelay, discardNotifier);
+    public ApplicationQueryListener queryListener(MessageConverter converter, HandlerResolver resolver,
+                                                  ReactiveMessageSender sender, ReactiveMessageListener rlistener,
+                                                  DiscardNotifier discardNotifier) {
+        final ApplicationQueryListener listener = new ApplicationQueryListener(rlistener,
+                appName + ".query", resolver, sender, asyncProps.getDirect().getExchange(), converter,
+                "globalReply", asyncProps.getWithDLQRetry(), asyncProps.getMaxRetries(),
+                asyncProps.getRetryDelay(), discardNotifier);
+
         listener.startListener();
+
         return listener;
     }
 
     @Bean
-    public ApplicationCommandListener applicationCommandListener(ReactiveMessageListener listener, HandlerResolver resolver, MessageConverter converter, DiscardNotifier discardNotifier){
-        ApplicationCommandListener commandListener = new ApplicationCommandListener(listener, appName, resolver, directMessagesExchangeName, converter, withDLQRetry, maxRetries, retryDelay, discardNotifier);
+    public ApplicationCommandListener applicationCommandListener(ReactiveMessageListener listener,
+                                                                 HandlerResolver resolver, MessageConverter converter,
+                                                                 DiscardNotifier discardNotifier) {
+        ApplicationCommandListener commandListener = new ApplicationCommandListener(listener, appName, resolver,
+                asyncProps.getDirect().getExchange(), converter, asyncProps.getWithDLQRetry(), asyncProps.getMaxRetries(),
+                asyncProps.getRetryDelay(), discardNotifier);
+
         commandListener.startListener();
+
         return commandListener;
     }
 
@@ -78,26 +87,26 @@ public DynamicRegistry dynamicRegistry(HandlerResolver resolver, ReactiveMessage
     }
 
     @Bean
-    public HandlerResolver resolver(ApplicationContext context, DefaultQueryHandler defaultHandler, Environment env, DefaultCommandHandler defaultCommandHandler) {
+    public HandlerResolver resolver(ApplicationContext context, DefaultCommandHandler defaultCommandHandler) {
         final Map<String, HandlerRegistry> registries = context.getBeansOfType(HandlerRegistry.class);
 
         final ConcurrentMap<String, RegisteredQueryHandler> handlers = registries
-            .values().stream()
-            .flatMap(r -> r.getHandlers().stream())
-            .collect(ConcurrentHashMap::new, (map, handler) -> map.put(handler.getPath(), handler),
-                ConcurrentHashMap::putAll);
+                .values().stream()
+                .flatMap(r -> r.getHandlers().stream())
+                .collect(ConcurrentHashMap::new, (map, handler) -> map.put(handler.getPath(), handler),
+                        ConcurrentHashMap::putAll);
 
         final ConcurrentMap<String, RegisteredEventListener> eventListeners = registries
-            .values().stream()
-            .flatMap(r -> r.getEventListeners().stream())
-            .collect(ConcurrentHashMap::new, (map, handler) -> map.put(handler.getPath(), handler),
-                ConcurrentHashMap::putAll);
+                .values().stream()
+                .flatMap(r -> r.getEventListeners().stream())
+                .collect(ConcurrentHashMap::new, (map, handler) -> map.put(handler.getPath(), handler),
+                        ConcurrentHashMap::putAll);
 
         final ConcurrentMap<String, RegisteredCommandHandler> commandHandlers = registries
-            .values().stream()
-            .flatMap(r -> r.getCommandHandlers().stream())
-            .collect(ConcurrentHashMap::new, (map, handler) -> map.put(handler.getPath(), handler),
-                ConcurrentHashMap::putAll);
+                .values().stream()
+                .flatMap(r -> r.getCommandHandlers().stream())
+                .collect(ConcurrentHashMap::new, (map, handler) -> map.put(handler.getPath(), handler),
+                        ConcurrentHashMap::putAll);
 
         return new HandlerResolver(handlers, eventListeners, commandHandlers) {
             @Override
@@ -113,13 +122,13 @@ public <T> RegisteredCommandHandler<T> getCommandHandler(String path) {
     @ConditionalOnMissingBean
     public DefaultQueryHandler defaultHandler() {
         return (DefaultQueryHandler<Object, Object>) command ->
-            Mono.error(new RuntimeException("No Handler Registered"));
+                Mono.error(new RuntimeException("No Handler Registered"));
     }
 
 
     @Bean
     @ConditionalOnMissingBean
-    public DefaultCommandHandler defaultCommandHandler(){
+    public DefaultCommandHandler defaultCommandHandler() {
         return message -> Mono.error(new RuntimeException("No Handler Registered"));
     }
 }

async/async-commons-starter/src/main/java/org/reactivecommons/async/impl/config/RabbitMqConfig.java

@@ -2,6 +2,7 @@
 
 import com.rabbitmq.client.Connection;
 import com.rabbitmq.client.ConnectionFactory;
+import lombok.RequiredArgsConstructor;
 import lombok.extern.java.Log;
 import org.reactivecommons.api.domain.DomainEventBus;
 import org.reactivecommons.async.impl.DiscardNotifier;
@@ -10,7 +11,9 @@
 import org.reactivecommons.async.impl.communications.ReactiveMessageListener;
 import org.reactivecommons.async.impl.communications.ReactiveMessageSender;
 import org.reactivecommons.async.impl.communications.TopologyCreator;
+import org.reactivecommons.async.impl.config.props.AsyncProps;
 import org.reactivecommons.async.impl.config.props.BrokerConfigProps;
+import org.reactivecommons.async.impl.config.props.FluxProps;
 import org.reactivecommons.async.impl.converters.MessageConverter;
 import org.reactivecommons.async.impl.converters.json.DefaultObjectMapperSupplier;
 import org.reactivecommons.async.impl.converters.json.JacksonMessageConverter;
@@ -24,6 +27,7 @@
 import org.springframework.context.annotation.Import;
 import reactor.core.publisher.Mono;
 import reactor.rabbitmq.*;
+import reactor.util.retry.Retry;
 
 import java.time.Duration;
 import java.util.logging.Level;
@@ -32,17 +36,19 @@
 
 @Log
 @Configuration
-@EnableConfigurationProperties(RabbitProperties.class)
+@RequiredArgsConstructor
+@EnableConfigurationProperties({
+        RabbitProperties.class,
+        AsyncProps.class
+})
 @Import(BrokerConfigProps.class)
 public class RabbitMqConfig {
 
     private static final String LISTENER_TYPE = "listener";
 
     private static final String SENDER_TYPE = "sender";
 
-
-    @Value("${app.async.flux.maxConcurrency:250}")
-    private Integer maxConcurrency;
+    private final AsyncProps asyncProps;
 
     @Value("${spring.application.name}")
     private String appName;
@@ -58,6 +64,8 @@ public ReactiveMessageSender messageSender(ConnectionFactoryProvider provider, M
         map.from(rabbitProperties.getCache().getChannel()::getSize).whenNonNull()
                 .to(channelPoolOptions::maxCacheSize);
 
+
+
         final ChannelPool channelPool = ChannelPoolFactory.createChannelPool(
                 senderConnection,
                 channelPoolOptions
@@ -77,7 +85,9 @@ public ReactiveMessageListener messageListener(ConnectionFactoryProvider provide
         final Receiver receiver = RabbitFlux.createReceiver(new ReceiverOptions().connectionMono(connection));
         final Sender sender = RabbitFlux.createSender(new SenderOptions().connectionMono(connection));
 
-        return new ReactiveMessageListener(receiver, new TopologyCreator(sender), maxConcurrency);
+        return new ReactiveMessageListener(receiver,
+                new TopologyCreator(sender),
+                asyncProps.getFlux().getMaxConcurrency());
     }
 
     @Bean
@@ -89,7 +99,6 @@ public ConnectionFactoryProvider connectionFactory(RabbitProperties properties)
         map.from(properties::determinePort).to(factory::setPort);
         map.from(properties::determineUsername).whenNonNull().to(factory::setUsername);
         map.from(properties::determinePassword).whenNonNull().to(factory::setPassword);
-        map.from(properties::determineVirtualHost).whenNonNull().to(factory::setVirtualHost);
         factory.useNio();
         return () -> factory;
     }
@@ -123,7 +132,8 @@ Mono<Connection> createConnectionMono(ConnectionFactory factory, String connecti
                 .doOnError(err ->
                         log.log(Level.SEVERE, "Error creating connection to RabbitMq Broker. Starting retry process...", err)
                 )
-                .retryBackoff(Long.MAX_VALUE, Duration.ofMillis(300), Duration.ofMillis(3000))
+                .retryWhen(Retry.backoff(Long.MAX_VALUE, Duration.ofMillis(300))
+                        .maxBackoff(Duration.ofMillis(3000)))
                 .cache();
     }
 

async/async-commons-starter/src/main/java/org/reactivecommons/async/impl/config/props/AsyncProps.java

@@ -0,0 +1,29 @@
+package org.reactivecommons.async.impl.config.props;
+
+import lombok.Getter;
+import lombok.Setter;
+import org.springframework.boot.context.properties.ConfigurationProperties;
+import org.springframework.boot.context.properties.NestedConfigurationProperty;
+
+
+@Getter
+@Setter
+@ConfigurationProperties(prefix = "app.async")
+public class AsyncProps {
+
+    @NestedConfigurationProperty
+    private FluxProps flux = new FluxProps();
+
+    @NestedConfigurationProperty
+    private DomainProps domain = new DomainProps();
+
+    @NestedConfigurationProperty
+    private DirectProps direct = new DirectProps();
+
+    private Integer maxRetries = 10;
+
+    private Integer retryDelay = 1000;
+
+    private Boolean withDLQRetry = false;
+
+}

async/async-commons-starter/src/main/java/org/reactivecommons/async/impl/config/props/BrokerConfigProps.java

@@ -1,6 +1,7 @@
 package org.reactivecommons.async.impl.config.props;
 
 import lombok.Getter;
+import lombok.RequiredArgsConstructor;
 import org.reactivecommons.async.impl.config.IBrokerConfigProps;
 import org.springframework.beans.factory.annotation.Value;
 import org.springframework.context.annotation.Configuration;
@@ -13,16 +14,13 @@
 
 @Getter
 @Configuration
+@RequiredArgsConstructor
 public class BrokerConfigProps implements IBrokerConfigProps {
 
     @Value("${spring.application.name}")
     private String appName;
 
-    @Value("${app.async.domain.events.exchange:domainEvents}")
-    private String domainEventsExchangeName;
-
-    @Value("${app.async.direct.exchange:directMessages}")
-    private String directMessagesExchangeName;
+    private final AsyncProps asyncProps;
 
     private final AtomicReference<String> replyQueueName = new AtomicReference<>();
 
@@ -45,7 +43,7 @@ public String getCommandsQueue() {
     public String getReplyQueue() {
         final String name = replyQueueName.get();
         if (name == null) {
-            final String replyName =  newRandomQueueName();
+            final String replyName = newRandomQueueName();
             if (replyQueueName.compareAndSet(null, replyName)) {
                 return replyName;
             } else {
@@ -55,13 +53,23 @@ public String getReplyQueue() {
         return name;
     }
 
+    @Override
+    public String getDomainEventsExchangeName() {
+        return asyncProps.getDomain().getEvents().getExchange();
+    }
+
+    @Override
+    public String getDirectMessagesExchangeName() {
+        return asyncProps.getDirect().getExchange();
+    }
+
     private String newRandomQueueName() {
         UUID uuid = UUID.randomUUID();
         ByteBuffer bb = ByteBuffer.wrap(new byte[16]);
         bb.putLong(uuid.getMostSignificantBits())
-            .putLong(uuid.getLeastSignificantBits());
+                .putLong(uuid.getLeastSignificantBits());
         return appName + Base64Utils.encodeToUrlSafeString(bb.array())
-            .replaceAll("=", "");
+                .replaceAll("=", "");
     }
 
 }

async/async-commons-starter/src/main/java/org/reactivecommons/async/impl/config/props/DirectProps.java

@@ -0,0 +1,12 @@
+package org.reactivecommons.async.impl.config.props;
+
+import lombok.Getter;
+import lombok.Setter;
+
+@Getter
+@Setter
+public class DirectProps {
+
+    private String exchange = "directMessages";
+
+}

async/async-commons-starter/src/main/java/org/reactivecommons/async/impl/config/props/DomainProps.java

@@ -0,0 +1,14 @@
+package org.reactivecommons.async.impl.config.props;
+
+import lombok.Getter;
+import lombok.Setter;
+import org.springframework.boot.context.properties.NestedConfigurationProperty;
+
+@Getter
+@Setter
+public class DomainProps {
+
+    @NestedConfigurationProperty
+    private EventsProps events = new EventsProps();
+
+}

async/async-commons-starter/src/main/java/org/reactivecommons/async/impl/config/props/EventsProps.java

@@ -0,0 +1,12 @@
+package org.reactivecommons.async.impl.config.props;
+
+import lombok.Getter;
+import lombok.Setter;
+
+@Getter
+@Setter
+public class EventsProps {
+
+    private String exchange = "domainEvents";
+
+}

async/async-commons-starter/src/main/java/org/reactivecommons/async/impl/config/props/FluxProps.java

@@ -0,0 +1,12 @@
+package org.reactivecommons.async.impl.config.props;
+
+import lombok.Getter;
+import lombok.Setter;
+
+@Getter
+@Setter
+public class FluxProps {
+
+    private Integer maxConcurrency = 250;
+
+}