Enabling Non-Spring Libraries to Access Spring Boot Components

Internal

• Spring Boot

Overview

This article describes a possible approach to give a non-Spring library runtime access to Spring Boot runtime components and inject its own Spring components into the Spring Boot runtime application context.

Playground Example

https://github.com/ovidiuf/playground/tree/master/spring/spring-boot/spring-boot-with-dependency

Approach

Spring Boot Application Changes

From the Spring Boot application's perspective, the (only) active step required to enable component scanning for the dependency package in order to detect the Spring components that come in the dependency library, is to add an extra @ComponentScan annotation in its main class, configured with the dependency library package. Note that @ComponentScans (plural) is required because the Spring Boot application implicitly declares a @ComponentScan for its own package, as part of the @SpringBootApplication annotation:

@SpringBootApplication
@ComponentScans(@ComponentScan(basePackages = "some.experimental.dependency"))
public class MainApplication {
...
}

Alternatively, we can get rid of even this requirement and remove the @ComponentScans annotation, making the Spring Boot application completely oblivious to the presence of the Spring-aware dependency library, if we add a Spring metadata file and a @Configuration class in the library, as described in the "How to Make Dependency Library Autoconfigurable by Spring" section.

Dependency Library Changes

The dependency library contains Spring components it wants managed by the container, while it is bootstrapped by the SpringBoot application in a non-Spring way: Spring Boot application invokes new on one of the dependency library's classes. The situation is encountered when a Spring Boot application instantiates a JPA Converter class specified in a third party library. We can write the dependency library in such a way that it bootstraps itself, as shown in How to Write the Spring Component. Note that the dependency project should be configured with "compile only" access to Spring Framework API packages "org.springframework:spring-beans" and "org.springframework:spring-context". A way to do this that does not involve Spring Boot dependency management is described here: Spring dependency-management Plugin for Gradle.

dependencies {

    compileOnly('org.springframework:spring-beans')
    compileOnly('org.springframework:spring-context')
}

How to Write Bootstrapping Code

package some.experimental.dependency;

/**
 * This is a dependency class that is invoked into by the SpringBoot framework directly, without an assumption of
 * Spring component availability: the Dependency class instance is created with new or by reflection. The situation 
 * is similar to a Spring Boot application instantiating a JPA Converter class specified in a third party library.
 * The Dependency instance gets the Spring-managed singleton instance via a static method call. 
 */
public class Dependency {

  private DependencySpringComponent springComponent;

  public Dependency() {

    //
    // The DependencySpringComponent singleton is initialized by Spring by now and installed into the application
    // context; we get it by calling into DependencySpringComponent static method:
    //
    springComponent = DependencySpringComponent.getSpringBeanInstance();
  }

  public void run() {

    springComponent.run();
  }
}

How to Write the Spring Component

The Spring component exposes itself via a static member variable, during its initialization cycle:

package some.experimental.dependency;
...
/**
 * This is a Spring bean that is identified by component scanning performed by the main application and is installed
 * into the Spring application context. As part of its initialization cycle, it retains a reference to the application
 * context and it is exposing itself via a static method that has access to the application context.
 */
@Component
public class DependencySpringComponent {

  private static ApplicationContext APPLICATION_CONTEXT;

  @Autowired
  public DependencySpringComponent(ApplicationContext applicationContext) {

    APPLICATION_CONTEXT = applicationContext;
  }

  public static DependencySpringComponent getSpringBeanInstance() {

    if (APPLICATION_CONTEXT == null) {

      throw new IllegalStateException("access to Spring ApplicationContext has not been configured");
    }

    return APPLICATION_CONTEXT.getBean(DependencySpringComponent.class);
  }

  public void run() {
    ...
  }
}

DependencySpringComponent must exist and be a valid Spring component, properly annotated with @Component or similar. It is detected by Spring because we configured the Spring Boot application context to @ComponentScan the dependency package.

How to Make Dependency Library Autoconfigurable by Spring

Instead of adding a @ComponentScan annotation that points to the dependency library package to the Spring Boot main application, we can make the dependency library autoconfigurable, by adding a META-INF/spring.factories to the dependency library JAR:

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
  some.experimental.dependency.DependencyAutoConfiguration

We also need to provide a @Configuration class that creates the beans for Spring, as referred from the content of the META-INF/spring.factories file:

package some.experimental.dependency;

@Configuration
public class DependencyAutoConfiguration {

  @Bean
  public DependencySpringComponent dependencySpringComponent(ApplicationContext applicationContext) {

    return new DependencySpringComponent(applicationContext);
  }
}