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 `@AllArgsConstructor
  33 public class MultipleBeansApplicationContextInitializer
  34     implements
  35       ApplicationContextInitializer
  36 {
  37   private final String[] sites;
  38   @Override
  39   public void initialize(ConfigurableApplicationContext context)
  40   {
  41     ConfigurableListableBeanFactory factory =
  42         context.getBeanFactory();
  43     for (String site : sites)
  44     {
  45       SiteController controller =
  46           new SiteController(site, "Descrition of site " + site);
  47       factory.registerSingleton("/" + site, controller);
  48     }
  49   }
  50 }
  51 `
  52
  53 This simplified example is configured with a list of strings that should be registered as controllers with the `DispatcherServlet`.
  54 All "sites" are insances of the same controller `SiteController`, which are instanciated and registered dynamically.
  55
  56 The instances are registered as beans with the method **`registerSingleton(String name, Object bean)`**
  57 of a `ConfigurableListableBeanFactory` that can be accessed through the provided `ConfigurableApplicationContext`
  58
  59 The array of strings represents the accessed configuration properties in the simplified example.
  60 The array will most probably hold more complex data-structures in a real-world application.
  61
  62 _But how do we get access to the configuration-parameters, that are injected in this array here...?_
  63
  64 ## Accessing the Configured Property-Sources
  65
  66 Instantiating and registering the additionally beans is easy.
  67 The real problem is to access the configuration properties in the early plumbing-stage of the application-context, in that our `ApplicationContextInitializer` runs in:
  68
  69 _The initializer cannot be instantiated and autowired by Spring!_
  70
  71 **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.
  72
  73 **The Good News:** We will present a way, how to access initialized instances of all property sources, that will be presented to your app
  74
  75 ## Write an EnvironmentPostProcessor
  76
  77 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.
  78
  79 `public class MultipleBeansEnvironmentPostProcessor
  80     implements
  81       EnvironmentPostProcessor
  82 {
  83   @Override
  84   public void postProcessEnvironment(
  85       ConfigurableEnvironment environment,
  86       SpringApplication application)
  87   {
  88     String sites =
  89         environment.getRequiredProperty("juplo.sites", String.class);
  90     application.addInitializers(
  91         new MultipleBeansApplicationContextInitializer(
  92             Arrays
  93                 .stream(sites.split(","))
  94                 .map(site -> site.trim())
  95                 .toArray(size -> new String[size])));
  96   }
  97 }
  98 `
  99
 100 **The Bad News:**
 101 Unfortunately, you have to scan all property-sources for the parameters, that you are interested in.
 102 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.
 103 So, you have to convert any values by yourself and stuff them in more complex data-structures as needed.
 104
 105 **The Good News:**
 106 The property names are consistently represented in standard Java-Properties-Notation, regardless of the actual type ( `.properties` / `.yml`) of the property source.
 107
 108 ## Register the EnvironmentPostProcessor
 109
 110 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.
 111 This is done in the **`META-INF/spring.factories`**:
 112
 113 `org.springframework.boot.env.EnvironmentPostProcessor=\
 114   de.juplo.demos.multiplebeans.MultipleBeansEnvironmentPostProcessor
 115 `
 116
 117 **That's it, your done!**
 118
 119 ## Source Code
 120
 121 You can find the whole source code in a working mini-application on juplo.de and GitHub:
 122
 123 - [/git/demos/multiple-beans/](/git/demos/multiple-beans/)
 124 - [https://github.com/juplo/demos-multiple-beans](https://github.com/juplo/demos-multiple-beans)
 125
 126 ## Other Blog-Posts On The Topic
 127
 128 - 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 `
 129 - 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