Spring Plugin

When using a PluginRegistry configured via the Spring Plugin namespace or @EnablePluginRegistries, the registry is an OrderAwarePluginRegistry. This means it respects the ordering of plugins defined via standard Spring mechanisms:

1. Implementing the org.springframework.core.Ordered interface and overriding getOrder().
2. Using the @Order annotation on the plugin implementation class.

This is useful when you need to ensure certain plugins are executed before or after others in a host application.

Spring Plugin provides a metadata module to capture essential information about plugin instances, such as name and version. This metadata serves as a unique identifier for plugins within a PluginRegistry.

There are two primary interfaces used to implement this concept:

1. PluginMetadata: Defines the core properties of a plugin (name and version).
2. MetadataProvider: An interface that application plugin interfaces can implement to indicate they are capable of providing metadata.

Spring Plugin provides SimplePluginMetadata as a standard Java bean-style implementation to capture these properties easily.

public interface PluginMetadata {
  String getName();
  String getVersion();
}

public interface MetadataProvider {
  PluginMetadata getMetadata();
}

Spring Plugin is an appropriate choice when you need to build a modular, extensible application but want to avoid the complexity of a full OSGi environment. Use Spring Plugin if:

• You want to minimize architectural overhead.
• You cannot or do not want to use OSGi's dynamic class loading or runtime installation features.
• You want to express extensibility through dedicated plugin interfaces.
• You want to extend functionality simply by adding JAR files containing interface implementations to your classpath.
• You are already using the Spring framework in your application (though this is not strictly required).

To simplify the creation of plugins that use metadata as selection criteria, you can extend AbstractMetadataBasedPlugin.

This base class automatically uses the plugin's internal metadata to implement the supports(...) method from the Plugin interface. This pattern is useful when you need to select specific plugin instances based on external configuration, such as user-specific settings files.

The Plugin<S> interface allows plugin implementations to decide whether they should be invoked based on a provided delimiter of type S.

To implement a conditional plugin:

1. Define an interface that extends Plugin<S>.
2. Implement the supports(S delimiter) method to return true if the plugin handles that specific delimiter.
3. Implement your core logic in the primary method (e.g., process()).

public enum ProductType {
  SOFTWARE, HARDWARE;
}

public interface ProductProcessor extends Plugin<ProductType> {
  public void process(Product product);
}

// Implementation example
public class SoftwareProcessor implements ProductProcessor {
  @Override
  public boolean supports(ProductType productType) {
    return productType == ProductType.SOFTWARE;
  }

  @Override
  public void process(Product product) {
    // logic here
  }
}

Instead of XML configuration, you can use the @EnablePluginRegistries annotation to automatically register a PluginRegistry in the Spring ApplicationContext.

When you annotate a @Configuration class with @EnablePluginRegistries(MyPluginInterface.class), Spring registers an OrderAwarePluginRegistry for that interface. The registered bean is named myPluginInterfaceRegistry (camelCase version of the interface name) and can be injected using @Qualifier.

@Configuration
@EnablePluginRegistries(MyPluginInterface.class)
class ApplicationConfiguration { 
    // ...
}

// To inject the registry elsewhere:
@Autowired
@Qualifier("myPluginInterfaceRegistry")
private PluginRegistry<MyPluginInterface, SomeDelimiter> registry;

Use SimplePluginRegistry to manage a collection of plugins. It provides static factory methods to create registries from individual plugins, lists of plugins, or as an empty registry. It is a basic implementation that holds plugins in a list and uses the supports(S delimiter) method of each plugin to determine which one matches a given input.

// Create an empty registry
SimplePluginRegistry<MyPlugin, String> registry = SimplePluginRegistry.empty();

// Create a registry with specific plugins
SimplePluginRegistry<MyPlugin, String> registry = SimplePluginRegistry.of(plugin1, plugin2);

// Create a registry from a list
List<MyPlugin> pluginList = Arrays.asList(plugin1, plugin2);
SimplePluginRegistry<MyPlugin, String> registry = SimplePluginRegistry.of(pluginList);