juplo.de Git - website/blob

   1 ---
   2 _edit_last: "2"
   3 categories:
   4   - demos
   5   - explained
   6   - howto
   7   - java
   8   - spring
   9   - spring-boot
  10 classic-editor-remember: classic-editor
  11 date: "2020-11-21T10:12:57+00:00"
  12 guid: http://juplo.de/?p=1185
  13 parent_post_id: null
  14 post_id: "1185"
  15 title: How To Instantiatiate Multiple Beans Dinamically in Spring-Boot Depending on Configuration-Properties
  16 url: /how-to-instantiatiate-multiple-beans-dinamically-in-spring-boot-based-on-configuration-properties/
  17
  18 ---
  19 ## TL;DR
  20
  21 In this mini-HowTo I will show a way, how to instantiate multiple beans dinamically in Spring-Boot, depending on configuration-properties.
  22 We will:
  23
  24 - write a **`ApplicationContextInitializer`** to add the beans to the context, before it is refreshed
  25 - write a **`EnvironmentPostProcessor`** to access the configured configuration sources
  26 - register the `EnvironmentPostProcessor` with Spring-Boot
  27
  28 ## Write an ApplicationContextInitializer
  29
  30 Additionally Beans can be added programatically very easy with the help of an `ApplicationContextInitializer`:
  31
  32 ```
  33 @AllArgsConstructor
  34 public class MultipleBeansApplicationContextInitializer
  35     implements
  36       ApplicationContextInitializer
  37 {
  38   private final String[] sites;
  39   @Override
  40   public void initialize(ConfigurableApplicationContext context)
  41   {
  42     ConfigurableListableBeanFactory factory =
  43         context.getBeanFactory();
  44     for (String site : sites)
  45     {
  46       SiteController controller =
  47           new SiteController(site, "Descrition of site " + site);
  48       factory.registerSingleton("/" + site, controller);
  49     }
  50   }
  51 }
  52 ```
  53
  54 This simplified example is configured with a list of strings that should be registered as controllers with the `DispatcherServlet`.
  55 All "sites" are insances of the same controller `SiteController`, which are instanciated and registered dynamically.
  56
  57 The instances are registered as beans with the method **`registerSingleton(String name, Object bean)`**
  58 of a `ConfigurableListableBeanFactory` that can be accessed through the provided `ConfigurableApplicationContext`
  59
  60 The array of strings represents the accessed configuration properties in the simplified example.
  61 The array will most probably hold more complex data-structures in a real-world application.
  62
  63 _But how do we get access to the configuration-parameters, that are injected in this array here...?_
  64
  65 ## Accessing the Configured Property-Sources
  66
  67 Instantiating and registering the additionally beans is easy.
  68 The real problem is to access the configuration properties in the early plumbing-stage of the application-context, in that our `ApplicationContextInitializer` runs in:
  69
  70 _The initializer cannot be instantiated and autowired by Spring!_
  71
  72 **The Bad News:** In the early stage we are running in, we cannot use autowiring or access any of the other beans that will be instantiated by spring - especially not any of the beans, that are instantiated via `@ConfigurationProperties`, we are intrested in.
  73
  74 **The Good News:** We will present a way, how to access initialized instances of all property sources, that will be presented to your app
  75
  76 ## Write an EnvironmentPostProcessor
  77
  78 If you write an **`EnvironmentPostProcessor`**, you will get access to an instance of `ConfigurableEnvironment`, that contains a complete list of all `PropertySource`'s, that are configured for your Spring-Boot-App.
  79
  80 ```
  81 public class MultipleBeansEnvironmentPostProcessor
  82     implements
  83       EnvironmentPostProcessor
  84 {
  85   @Override
  86   public void postProcessEnvironment(
  87       ConfigurableEnvironment environment,
  88       SpringApplication application)
  89   {
  90     String sites =
  91         environment.getRequiredProperty("juplo.sites", String.class);
  92     application.addInitializers(
  93         new MultipleBeansApplicationContextInitializer(
  94             Arrays
  95                 .stream(sites.split(","))
  96                 .map(site -> site.trim())
  97                 .toArray(size -> new String[size])));
  98   }
  99 }
 100 ```
 101
 102 **The Bad News:**
 103 Unfortunately, you have to scan all property-sources for the parameters, that you are interested in.
 104 Also, all values are represented as stings in this early startup-phase of the application-context, because Spring's convenient conversion mechanisms are not available yet.
 105 So, you have to convert any values by yourself and stuff them in more complex data-structures as needed.
 106
 107 **The Good News:**
 108 The property names are consistently represented in standard Java-Properties-Notation, regardless of the actual type ( `.properties` / `.yml`) of the property source.
 109
 110 ## Register the EnvironmentPostProcessor
 111
 112 Finally, you have to [register](https://docs.spring.io/spring-boot/docs/current/reference/html/howto.html#howto-customize-the-environment-or-application-context "Read more on details and/or alternatives of the mechanism") the `EnvironmentPostProcessor` with your Spring-Boot-App.
 113 This is done in the **`META-INF/spring.factories`**:
 114
 115 ```
 116 org.springframework.boot.env.EnvironmentPostProcessor=\
 117   de.juplo.demos.multiplebeans.MultipleBeansEnvironmentPostProcessor
 118 ```
 119
 120 **That's it, your done!**
 121
 122 ## Source Code
 123
 124 You can find the whole source code in a working mini-application on juplo.de and GitHub:
 125
 126 - [/git/demos/multiple-beans/](/git/demos/multiple-beans/)
 127 - [https://github.com/juplo/demos-multiple-beans](https://github.com/juplo/demos-multiple-beans)
 128
 129 ## Other Blog-Posts On The Topic
 130
 131 - The blog-post [Dynamic Beans in Spring](https://blog.pchudzik.com/201705/dynamic-beans/) shows a way to register beans dynamically, but does not show how to access the configuration. Also, meanwhile another interface was added to spring, that facilitates this approach: `BeanDefinitionRegistryPostProcessor `
 132 - Benjamin shows in [How To Create Your Own Dynamic Bean Definitions In Spring](https://comsystoreply.de/blog-post/how-to-create-your-own-dynamic-bean-definitions-in-spring), how this interface can be applied and how one can access the configuration. But his example only works with plain Spring in a Servlet Container