Implementing a Plugin Architecture in Java and Spring Boot Using SPI and Spring Factories

1. Introduction

The article introduces a plugin‑based approach for Java backend systems, showing how to achieve modularity, extensibility, and low coupling through well‑defined interfaces and dynamic loading.

2. Benefits of Plugin Architecture

Module decoupling – plugins isolate service modules, allowing independent development and replacement.

Improved extensibility – frameworks like Spring expose extension points that plugins can hook into.

Easy third‑party integration – external systems can implement the plugin interface with minimal intrusion, even supporting hot‑loading via configuration.

3. Common Implementation Approaches

Typical ways to realize plugins in Java include:

SPI (Service Provider Interface) mechanism.

Convention‑based configuration with reflection.

Spring Boot’s Factories mechanism.

Java agents.

Built‑in Spring extension points.

Third‑party libraries such as spring‑plugin‑core .

Spring AOP.

4. Java ServiceLoader (SPI) Example

The following code demonstrates a simple SPI setup using ServiceLoader to load implementations of MessagePlugin at runtime.

public interface MessagePlugin {
    String sendMsg(Map msgMap);
}

public class AliyunMsg implements MessagePlugin {
    @Override
    public String sendMsg(Map msgMap) {
        System.out.println("aliyun sendMsg");
        return "aliyun sendMsg";
    }
}

public class TencentMsg implements MessagePlugin {
    @Override
    public String sendMsg(Map msgMap) {
        System.out.println("tencent sendMsg");
        return "tencent sendMsg";
    }
}

public static void main(String[] args) {
    ServiceLoader
loader = ServiceLoader.load(MessagePlugin.class);
    for (MessagePlugin plugin : loader) {
        plugin.sendMsg(new HashMap());
    }
}

5. Custom Configuration Loading

Instead of relying on META‑INF files, a custom YAML/JSON configuration can list implementation class names, which are then loaded via reflection.

server:
  port: 8081
impl:
  name: com.congge.plugins.spi.MessagePlugin
  clazz:
    - com.congge.plugins.impl.TencentMsg
    - com.congge.plugins.impl.AliyunMsg

The utility class reads this file, creates instances with Class.forName(...).newInstance() , and invokes sendMsg on each plugin.

6. Spring Boot Integration via spring.factories

Spring Boot provides its own SPI through META-INF/spring.factories . By declaring the interface and its implementations, Spring can automatically instantiate all beans.

com.congge.plugin.spi.SmsPlugin=\
com.congge.plugin.impl.SystemSmsImpl,\
com.congge.plugin.impl.BizSmsImpl

Loading the plugins:

List<SmsPlugin> smsServices = SpringFactoriesLoader.loadFactories(SmsPlugin.class, null);
for (SmsPlugin sms : smsServices) {
    sms.sendMessage("hello");
}

7. Full Case Study

A complete scenario is presented where three micro‑services share a common MessagePlugin interface. One service (A) defines the interface, while two others (B and C) provide Alibaba Cloud and Tencent Cloud SMS implementations. The case shows how to:

Package the interface as a jar and publish it.

Implement the interface in separate modules and publish their jars.

Configure the consuming service to load the desired implementation via SPI, custom config, or Spring factories.

Fallback to a default implementation when no plugin is found.

Running the sample endpoints (e.g., localhost:8087/sendMsg?msg=hello ) prints the selected implementation’s log messages, confirming that the plugin mechanism works as intended.