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 {
...
}

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. This is a possible way to get a dependency library component hooked into the Spring application context:

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();
  }
}

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() {
    ...
  }
}

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')
}

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.