SpringApplicationBuilder 结合小型 SpringBoot 应用程序（模块化单体）

Question

I am trying to build a "Main" SpringBoot application which shall be composed out of many small independent SpringBoot Applications. The main application talks with each of the small SpringBoot applications to query data or to modify data. Each of the small application fulfills a certain domain. For example a dependency / SpringBoot Application for user management, mail transfer, product management, order fulfilling. Each of the small application uses an own database which is separated from the others.

I've added the small applications as dependency to my main application. What I'm now facing is the problem or the fact that the main instantiates all beans from the dependency applications. I know, this is how SpringBoot works. The problem is that there are some components or classes in each dependency with the same name. So running the application just crashes because there are beans with the same name which is correct. Further the main tries to instantiate a Hikari DB connection but should not have any db connection. I think that is because the other applications have a db connection. Therefore, the main also tries to build up a db connection.

The idea behind this is to build a modular monolith so in future one or more of the dependencies can be replaced by a microservice. Currently, building a microservice architecture is not required and not claimed. Therefore, I would like to build a modular monolith architecture.

Is there a way that each of the Spring Boot application just uses their own Beans and the main application can just invoke a certain interface / API of the others? Just like the other services expose a REST API but without exposing a REST API.

Would be the SpringBootApplicationBuilder ( https://docs.spring.io/spring-boot/docs/current/api/org/springframework/boot/builder/SpringApplicationBuilder.html ) using child / siblings a way to achieve my goal? Or do I miss something and there is no way to achieve my goal?

Answer 1

In case of Spring Boot's children - there will be potential conflicts in resources and bindings: you'll not be able to bind 2 servlet container instances to same port anyway, so be required to separate them.

Think will be better to use single Spring Boot application and use dedicated classes with @Configuration annotation per child 'application' as starting point:

@Configuration
public class SomeModuleConfig {

@Bean
public Bean myModuleBean() {}

}

To avoid global scan,you can play with @ComponentScan include/exclude filters: https://docs.spring.io/spring/docs/current/javadoc-api/org/springframework/context/annotation/ComponentScan.html

Answer 2

Maybe you can try to separate modules using context hierarchy, but of course, as @Alex said you must take care of proper component scanning:

public class Bootstrap {

    private static final Logger LOGGER = LoggerFactory.getLogger(Bootstrap.class);

    private static final String CONFIG_LOCATION = "spring.config.location=classpath:/config/";

    public static void main(String[] args) {

        SpringApplicationBuilder parentBuilder = new SpringApplicationBuilder(CtxParent.class).web(WebApplicationType.NONE);

        ConfigurableApplicationContext context =
            parentBuilder.parent(CtxParent.class)
                .web(WebApplicationType.SERVLET)
                .properties("spring.config.name=application",CONFIG_LOCATION).run(args);
            parentBuilder.child(CtxModuleOne.class)
                .web(WebApplicationType.NONE) // whatever
                .properties("spring.config.name=module-one",CONFIG_LOCATION).run(args);
            parentBuilder.sibling(CtxModuleTwo.class)
                .web(WebApplicationType.NONE) // whatever
                .properties("spring.config.name=module-two",CONFIG_LOCATION).run(args);

    }
}

Answer 3

Please ignore my first paragraph (For the problem of bean instanciation, if you have @ComponentScan in your root application, you could try to remove it and add @SpringBootApplication(scanBasePackages = "com....") to each individual module's exposed service or controller. The main application should not see everything inside the child modules. The components (beans) stay only in the contexts of each module whilst the main application interacts with each module's API.)

For the database issue, implement separate configurations for each module. Bellow is an example of a module's database configuration in my application:

@Configuration
@EnableTransactionManagement
@EnableJpaRepositories(
        basePackages = "com.path.to.academy.persistency",
        entityManagerFactoryRef = "academyEntityManager",
        transactionManagerRef = "academyTransactionManager"
)
public class PersistenceAcademyAutoConfig {

    @Autowired
    ExternalConfigurations externalConfigurations;

    @Autowired
    AcademyExternalConfigurations academyExternalConfigurations;

    public PersistenceAcademyAutoConfig(
    ) {
        super();
    }

    @Bean
    public LocalContainerEntityManagerFactoryBean academyEntityManager() {
        final LocalContainerEntityManagerFactoryBean em = new LocalContainerEntityManagerFactoryBean();
        em.setDataSource(academyDataSource());
        em.setPackagesToScan("com.path.to.academy.domain");

        final HibernateJpaVendorAdapter vendorAdapter = new HibernateJpaVendorAdapter();
        em.setJpaVendorAdapter(vendorAdapter);
        final HashMap<String, Object> properties = new HashMap<String, Object>();
        properties.put("hibernate.hbm2ddl.auto", externalConfigurations.getHibernateDdl());
        properties.put("javax.persistence.create-database-schemas", externalConfigurations.getDbSchemaCreationDirective());
        properties.put("hibernate.dialect", externalConfigurations.getHibernateDialect());
        properties.put("hibernate.show_sql", externalConfigurations.getShowSql());

        em.setJpaPropertyMap(properties);

        return em;
    }

    @Bean
    public DataSource academyDataSource() {
        DataSourceBuilder dataSourceBuilder = DataSourceBuilder.create();
        dataSourceBuilder.url(academyExternalConfigurations.getDbUrl());
        dataSourceBuilder.username(externalConfigurations.getDbUser());
        dataSourceBuilder.password(externalConfigurations.getDbPassword());
        dataSourceBuilder.driverClassName(externalConfigurations.getDbDriverClassName());
        return dataSourceBuilder.build();
    }

    @Bean
    public PlatformTransactionManager academyTransactionManager() {
        final JpaTransactionManager transactionManager = new JpaTransactionManager();
        transactionManager.setEntityManagerFactory(academyEntityManager().getObject());
        return transactionManager;
    }
}

Hope it helps!