PF4J

https://pf4j.org
Admin
PF4J is a lightweight open-source plugin framework for Java that enables developers to transform...
Tokens:9,994
Snippets:132
Trust Score:7.4
Update:3 months ago
Show doc for...
Tokens:
Raw
### Create PF4J Quickstart Project

Source: https://pf4j.org/dev/quickstart.html

Use this Maven command to generate a new PF4J quickstart project. Ensure you have Maven installed and configured.

```bash
mvn archetype:generate \
  -DarchetypeGroupId=org.pf4j \
  -DarchetypeArtifactId=pf4j-quickstart \
  -DarchetypeVersion=3.6.0 \
  -DgroupId=com.mycompany \
  -DartifactId=myproject

```

--------------------------------

### Load and Start Plugins

Source: https://pf4j.org/doc/system-extension.html

This snippet demonstrates loading and starting all plugins, then retrieving extensions. It's a comprehensive approach for initializing the plugin system.

```java
public static void main(String[] args) {
    PluginManager pluginManager = new DefaultPluginManager();
    pluginManager.loadPlugins();
    pluginManager.startPlugins();
    List<Greeting> greetings = pluginManager.getExtensions(Greeting.class);
    for (Greeting greeting : greetings) {
        System.out.println(">>> " + greeting.getGreeting());
    }
}
```

--------------------------------

### Initialize and Start Plugin Manager

Source: https://pf4j.org/doc/getting-started.html

Basic setup to load and start all active plugins in your application.

```java
public static void main(String[] args) {
    ...

    PluginManager pluginManager = new DefaultPluginManager();
    pluginManager.loadPlugins();
    pluginManager.startPlugins();

    ...
}
```

--------------------------------

### Load and Start Plugins Synchronously

Source: https://pf4j.org/doc/async.html

Demonstrates the standard synchronous method for loading and starting plugins, followed by retrieving extensions.

```java
// create the plugin manager
final PluginManager pluginManager = new DefaultPluginManager();

// load the plugins
pluginManager.loadPlugins();

// start (active/resolved) the plugins
pluginManager.startPlugins();

// retrieves the extensions for Greeting extension point
List<Greeting> greetings = pluginManager.getExtensions(Greeting.class);

```

--------------------------------

### Load and Start Plugins Asynchronously

Source: https://pf4j.org/doc/async.html

Illustrates the asynchronous loading and starting of plugins using the `AsyncPluginManager`. It shows how to chain `CompletionStage` operations and retrieve extensions.

```java
// create the plugin manager
final AsyncPluginManager pluginManager = new DefaultAsyncPluginManager();

// load the plugins
CompletionStage<Void> stage = pluginManager.loadPluginsAsync();
stage.thenRun(() -> System.out.println("Plugins loaded")); // optional

// start (active/resolved) the plugins
stage.thenCompose(v -> pluginManager.startPluginsAsync());
stage.thenRun(() -> System.out.println("Plugins started")); // optional

// block and wait for the future to complete (not the best approach in real applications)
stage.toCompletableFuture().get();

// retrieves the extensions for Greeting extension point
List<Greeting> greetings = pluginManager.getExtensions(Greeting.class);

```

--------------------------------

### Example Plugin Directory Structure (.jar)

Source: https://pf4j.org/doc/packaging.html

Illustrates the directory structure when using .jar packaging for plugins.

```bash
$ tree plugins
plugins
├── disabled.txt
├── enabled.txt
├── demo-plugin1-2.4.0.jar
└── demo-plugin2-2.4.0.jar


```

--------------------------------

### Example Plugin Directory Structure (.zip)

Source: https://pf4j.org/doc/packaging.html

Illustrates the directory structure when using .zip packaging for plugins.

```bash
$ tree plugins
plugins
├── disabled.txt
├── enabled.txt
├── demo-plugin1-2.4.0.zip
└── demo-plugin2-2.4.0.zip


```

--------------------------------

### Implement an Extension

Source: https://pf4j.org/doc/getting-started.html

Example of a plugin class implementing the Greeting extension point.

```java
public class WelcomePlugin extends Plugin {

    public WelcomePlugin(PluginWrapper wrapper) {
        super(wrapper);
    }

    @Extension
    public static class WelcomeGreeting implements Greeting {

        public String getGreeting() {
            return "Welcome";
        }

    }

}
```

--------------------------------

### Example Plugin Directory Structure (Mixed Formats)

Source: https://pf4j.org/doc/packaging.html

Shows a mixed directory structure with both .jar and .zip plugin formats.

```bash
$ tree plugins
plugins
├── disabled.txt
├── enabled.txt
├── demo-plugin1-2.4.0.jar
└── demo-plugin2-2.4.0.zip


```

--------------------------------

### Output of Retrieving Extensions

Source: https://pf4j.org/doc/getting-started.html

Example output when retrieving and printing greetings from registered extensions.

```text
>>> Welcome
>>> Hello
```

--------------------------------

### Run PF4J Application

Source: https://pf4j.org/dev/quickstart.html

Navigate to your project directory and execute the run script to start your PF4J application. Make sure the script is executable.

```bash
cd myproject
chmod u+x run.sh
./run.sh

```

--------------------------------

### Plugin Manifest Descriptor

Source: https://pf4j.org/doc/getting-started.html

Example of a MANIFEST.MF file defining plugin metadata, including ID, version, main class, and dependencies.

```properties
Manifest-Version: 1.0
Archiver-Version: Plexus Archiver
Created-By: Apache Maven
Built-By: decebal
Build-Jdk: 1.6.0_17
Plugin-Class: org.pf4j.demo.welcome.WelcomePlugin
Plugin-Dependencies: x, y, z
Plugin-Id: welcome-plugin
Plugin-Provider: Decebal Suiu
Plugin-Version: 0.0.1
```

--------------------------------

### Example META-INF/services/extension-point file

Source: https://pf4j.org/doc/serviceloader.html

This is the standard format for Java's ServiceLoader, listing fully qualified class names of extension implementations.

```properties
# Generated by PF4J
org.pf4j.demo.HowdyGreeting
org.pf4j.demo.WhazzupGreeting # pf4j extension

```

--------------------------------

### Implement Extension

Source: https://pf4j.org/doc/extensions.html

An extension is a concrete implementation of an extension point. This example implements MainMenuExtensionPoint to add a menu to the menu bar. The @Extension annotation marks this class as a loadable extension.

```java
import javax.swing.JMenu;
import javax.swing.JMenuBar;
import javax.swing.JMenuItem;
import org.pf4j.Extension;

@Extension
public class MyMainMenuExtension implements MainMenuExtensionPoint {

    public void buildMenuBar(JMenuBar menuBar) {
        JMenu exampleMenu = new JMenu("Example");
        exampleMenu.add(new JMenuItem("Hello World"));
        menuBar.add(exampleMenu);
    }

}
```

--------------------------------

### Retrieve Extensions

Source: https://pf4j.org/doc/getting-started.html

Code to get all registered extensions for a specific extension point and iterate over them.

```java
List<Greeting> greetings = pluginManager.getExtensions(Greeting.class);
for (Greeting greeting : greetings) {
    System.out.println(">>> " + greeting.getGreeting());
}
```

--------------------------------

### Custom Plugin Manager for Jar Plugins Only

Source: https://pf4j.org/doc/custom-manager.html

Example of a custom plugin manager that loads only JAR plugins and reads descriptors from the MANIFEST.MF file.

```java
PluginManager pluginManager = new DefaultPluginManager() {

    @Override
    protected PluginLoader createPluginLoader() {
        // load only jar plugins 
        return new JarPluginLoader(this);
    }

    @Override
    protected PluginDescriptorFinder createPluginDescriptorFinder() {
        // read plugin descriptor from jar's manifest 
        return new ManifestPluginDescriptorFinder();
    }

}; 

```

--------------------------------

### Minimalist Extension Retrieval

Source: https://pf4j.org/doc/system-extension.html

This snippet shows a more minimalist approach by directly retrieving extensions without explicitly loading and starting plugins. Useful when plugins are already managed or not needed for initial extension discovery.

```java
public static void main(String[] args) {
    PluginManager pluginManager = new DefaultPluginManager();
    List<Greeting> greetings = pluginManager.getExtensions(Greeting.class);
    for (Greeting greeting : greetings) {
        System.out.println(">>> " + greeting.getGreeting());
    }
}
```

--------------------------------

### Define Required Plugin Dependency with Minimum Version

Source: https://pf4j.org/doc/plugins.html

Specify that pluginA requires pluginB starting from version 1.0.0. The plugin manager will load pluginA if pluginB version 1.0.0 or higher is available.

```properties
Plugin-Dependencies: pluginB@>=1.0.0
```

--------------------------------

### Define a Custom Plugin Class

Source: https://pf4j.org/doc/plugins.html

Create a custom plugin class by extending the `Plugin` class to handle plugin lifecycle events like start, stop, and delete.

```java
import org.pf4j.Plugin;
import org.pf4j.PluginException;
import org.pf4j.PluginWrapper;

public class MyPlugin extends Plugin {

    public MyPlugin(PluginWrapper wrapper) {
        super(wrapper);
    }

    @Override
    public void start() throws PluginException {
        // This method is called by the application when the plugin is started.
    }

    @Override
    public void stop() throws PluginException {
        // This method is called by the application when the plugin is stopped.
    }

    @Override
    public void delete() throws PluginException {
        // This method is called by the application when the plugin is deleted.
    }

}
```

--------------------------------

### Override Plugin Manager Factory Method

Source: https://pf4j.org/doc/getting-started.html

Example of overriding a factory method in PluginManager to inject a custom component, such as a PropertiesPluginDescriptorFinder.

```java
protected PluginDescriptorFinder createPluginDescriptorFinder() {
    return new PropertiesPluginDescriptorFinder();
}
```

--------------------------------

### Customizing PluginClassLoader with APD Strategy

Source: https://pf4j.org/doc/class-loading.html

Example of overriding DefaultPluginManager to use the APD (Application -> Plugin -> plugin Dependencies) class loading strategy for plugins.

```java
new DefaultPluginManager() {
    
    @Override
    protected PluginClassLoader createPluginClassLoader(Path pluginPath, PluginDescriptor pluginDescriptor) {
        return new PluginClassLoader(pluginManager, pluginDescriptor, getClass().getClassLoader(), ClassLoadingStrategy.APD);
    }

};
```

--------------------------------

### Define Extension Point Interface

Source: https://pf4j.org/doc/extensions.html

An extension point defines a specific behavior for an extension. This example defines an interface for extending a JMenuBar.

```java
import javax.swing.JMenuBar;
import org.pf4j.ExtensionPoint;

interface MainMenuExtensionPoint extends ExtensionPoint {

    void buildMenuBar(JMenuBar menuBar);

}
```

--------------------------------

### Load and Use Extensions

Source: https://pf4j.org/doc/extensions.html

This code demonstrates how to initialize the plugin manager, load plugins, and retrieve extensions to build the application's menu bar. It then displays a dialog with the constructed menu bar.

```java
import javax.swing.JDialog;
import javax.swing.JMenu;
import javax.swing.JMenuBar;
import org.pf4j.DefaultPluginManager;
import org.pf4j.PluginManager;

public static void main(String[] args) {
    // Init the plugin environment.
    // This should be done once during the boot process of the application.
    final PluginManager pluginManager = new DefaultPluginManager();
    pluginManager.loadPlugins();
    pluginManager.startPlugins();

    // Launch Swing application.
    java.awt.EventQueue.invokeLater(new Runnable() {

        public void run() {
            // Build the menu bar by using the available extensions.
            JMenuBar mainMenu = new JMenuBar();
            for (MainMenuExtensionPoint extension : pluginManager.getExtensions(MainMenuExtensionPoint.class)) {
                extension.buildMenuBar(mainMenu);
            }

            // Create and show a dialog with the menu bar.
            JDialog dialog = new JDialog();
            dialog.setTitle("Example dialog");
            dialog.setSize(450,300);
            dialog.setJMenuBar(mainMenu);
            dialog.setVisible(true);
        }

    });

}
```

--------------------------------

### Run Demo Application

Source: https://pf4j.org/doc/demo.html

Execute these scripts to run the demo application on Linux/Unix or Windows.

```shell
./run-demo.sh (for Linux/Unix)
```

```shell
./run-demo.bat (for Windows)
```

--------------------------------

### Enable Specific Plugins with enabled.txt

Source: https://pf4j.org/doc/disable-plugins.html

Use this file to explicitly list the plugins you want to load. All other plugins will be ignored. Place this file in the plugins folder.

```properties
########################################
# - load only these plugins
# - add one plugin id on each line
# - put this file in plugins folder
########################################
welcome-plugin

```

--------------------------------

### Default Extension Instantiation Behavior

Source: https://pf4j.org/doc/extension-instantiation.html

Demonstrates that calling plugin.getExtensions() multiple times creates a new extension instance for each call.

```java
plugin.getExtensions(MyExtensionPoint.class);
plugin.getExtensions(MyExtensionPoint.class);
```

--------------------------------

### Singleton ExtensionFactory Implementation

Source: https://pf4j.org/doc/extension-instantiation.html

Override the createExtensionFactory method in DefaultPluginManager to use SingletonExtensionFactory for returning the same extension instance.

```java
new DefaultPluginManager() {
    
    @Override
    protected ExtensionFactory createExtensionFactory() {
        return SingletonExtensionFactory();
    }

};
```

--------------------------------

### DefaultPluginManager with Compound Components

Source: https://pf4j.org/doc/custom-manager.html

Demonstrates how DefaultPluginManager uses compound components to support multiple plugin types (jar, zip, directory).

```java
public class DefaultPluginManager extends AbstractPluginManager {
   
    // other methods
    
    @Override
    protected PluginDescriptorFinder createPluginDescriptorFinder() {
        return new CompoundPluginDescriptorFinder()
            .add(new PropertiesPluginDescriptorFinder())
            .add(new ManifestPluginDescriptorFinder());
    }
    
    @Override
    protected PluginRepository createPluginRepository() {
        return new CompoundPluginRepository()
            .add(new DefaultPluginRepository(getPluginsRoot(), isDevelopment()))
            .add(new JarPluginRepository(getPluginsRoot()));
    }
    
    @Override
    protected PluginLoader createPluginLoader() {
        return new CompoundPluginLoader()
            .add(new DefaultPluginLoader(this, pluginClasspath))
            .add(new JarPluginLoader(this));
    }

}
```

--------------------------------

### Disable Specific Plugins with disabled.txt

Source: https://pf4j.org/doc/disable-plugins.html

Use this file to list plugins that should NOT be loaded. All other plugins will be loaded by default. Place this file in the plugins folder.

```properties
########################################
# - load all plugins except these
# - add one plugin id on each line
# - put this file in plugins folder
########################################
welcome-plugin

```

--------------------------------

### Define Multiple Required Plugin Dependencies

Source: https://pf4j.org/doc/plugins.html

Specify multiple required dependencies for pluginA, pluginB and pluginC, with specific version constraints for each. All listed dependencies must be met.

```properties
Plugin-Dependencies: pluginB@>=1.0.0 & <=2.0.0, pluginC@>=0.0.1 & <=0.1.0
```

--------------------------------

### Configure Snapshot Repository

Source: https://pf4j.org/dev/maven.html

Add these lines to your pom.xml to enable access to the latest PF4J snapshot versions from the Sonatype Maven Repository. This is useful for development and testing.

```xml
<repositories>
    <repository>
        <id>sonatype-nexus-snapshots</id>
        <url>https://oss.sonatype.org/content/repositories/snapshots</url>
        <releases>
            <enabled>false</enabled>
        </releases>
        <snapshots>
            <enabled>true</enabled>
        </snapshots>
    </repository>
</repositories>
```

--------------------------------

### Plugin Metadata in properties file

Source: https://pf4j.org/doc/plugins.html

Provide plugin metadata in a 'plugin.properties' file located at the root of the plugin folder or ZIP archive. This is a simple key-value approach.

```properties
plugin.class=org.pf4j.demo.welcome.WelcomePlugin
plugin.id=welcome-plugin
plugin.version=0.0.1
plugin.requires=1.0.0
plugin.dependencies=x, y, z
plugin.description=My example plugin
plugin.provider=Decebal Suiu
plugin.license=Apache License 2.0

```

--------------------------------

### Define Optional Plugin Dependency

Source: https://pf4j.org/doc/plugins.html

Specify that pluginA has an optional dependency on pluginB. PluginA will be loaded even if pluginB is not available.

```properties
Plugin-Dependencies: pluginB?
```

--------------------------------

### Define Optional Plugin Dependency with Specific Version

Source: https://pf4j.org/doc/plugins.html

Specify that pluginA has an optional dependency on pluginB, preferably version 1.0. PluginA will still load if pluginB is not present or not version 1.0.

```properties
Plugin-Dependencies: pluginB?@1.0
```

--------------------------------

### Plugin Metadata in MANIFEST.MF

Source: https://pf4j.org/doc/plugins.html

Define plugin metadata directly in the META-INF/MANIFEST.MF file. This is a standard way to provide plugin information.

```properties
Plugin-Class: org.pf4j.demo.welcome.WelcomePlugin
Plugin-Id: welcome-plugin
Plugin-Version: 0.0.1
Plugin-Requires: 1.0.0
Plugin-Dependencies: x, y, z
Plugin-Description: My example plugin
Plugin-Provider: Decebal Suiu
Plugin-License: Apache License 2.0

```

--------------------------------

### Determining Plugin for a Class

Source: https://pf4j.org/doc/class-loading.html

Demonstrates how to use the PluginManager to find out which plugin is responsible for loading a specific class.

```java
pluginManager.whichPlugin(MyClass.class);
```

--------------------------------

### Enabling ServiceLoaderExtensionFinder in DefaultPluginManager

Source: https://pf4j.org/doc/serviceloader.html

Override `createExtensionFinder` in `DefaultPluginManager` to add `ServiceLoaderExtensionFinder`. This allows PF4J to discover extensions located in `META-INF/services`.

```java
final PluginManager pluginManager = new DefaultPluginManager() {

    protected ExtensionFinder createExtensionFinder() {
        DefaultExtensionFinder extensionFinder = (DefaultExtensionFinder) super.createExtensionFinder();
        extensionFinder.addServiceProviderExtensionFinder();

        return extensionFinder;
    }

};

```

--------------------------------

### Add PF4J Core Dependency

Source: https://pf4j.org/dev/maven.html

Include this dependency in your pom.xml to add the main PF4J library. Replace ${pf4j.version} with the latest PF4J version.

```xml
<dependency>
    <groupId>org.pf4j</groupId>
    <artifactId>pf4j</artifactId>
    <version>${pf4j.version}</version>
</dependency>
```

--------------------------------

### Define Required Plugin Dependency with Exact Version

Source: https://pf4j.org/doc/plugins.html

Specify that pluginA requires pluginB with an exact version of 1.0.0. The plugin manager will only load pluginA if pluginB version 1.0.0 is available.

```properties
Plugin-Dependencies: pluginB@1.0
```

--------------------------------

### PluginClassLoader Constructors

Source: https://pf4j.org/doc/class-loading.html

Shows the available constructors for PluginClassLoader, including one that allows specifying a custom class loading strategy.

```java
public PluginClassLoader(PluginManager pluginManager,
                         PluginDescriptor pluginDescriptor,
                         ClassLoader parent)

public PluginClassLoader(PluginManager pluginManager,
                         PluginDescriptor pluginDescriptor,
                         ClassLoader parent,
                         ClassLoadingStrategy classLoadingStrategy)
```

--------------------------------

### Define Required Plugin Dependency with Version Range (Inclusive Upper Bound)

Source: https://pf4j.org/doc/plugins.html

Specify that pluginA requires pluginB from version 1.0.0 up to and including 2.0.0. The plugin manager ensures pluginB is within this version range.

```properties
Plugin-Dependencies: pluginB@>=1.0.0 & <=2.0.0
```

--------------------------------

### Configure Maven Compiler Plugin for Annotation Processing

Source: https://pf4j.org/doc/getting-started.html

Configure the maven-compiler-plugin to include the ExtensionAnnotationProcessor. This is often necessary to resolve issues with Java's annotation processing mechanism, ensuring that PF4J can find extensions.

```xml
<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-compiler-plugin</artifactId>
    <version>2.5.1</version>
    <configuration>
        <annotationProcessors>
            <annotationProcessor>org.pf4j.processor.ExtensionAnnotationProcessor</annotationProcessor>
        </annotationProcessors>
    </configuration>
</plugin>

```

--------------------------------

### Custom ExtensionFactory Implementation

Source: https://pf4j.org/doc/extension-instantiation.html

Override the createExtensionFactory method in DefaultPluginManager to provide a custom ExtensionFactory implementation.

```java
new DefaultPluginManager() {
    
    @Override
    protected ExtensionFactory createExtensionFactory() {
        return MyExtensionFactory();
    }

};
```

--------------------------------

### Define Required Plugin Dependency

Source: https://pf4j.org/doc/plugins.html

Specify that pluginA requires pluginB. The plugin manager ensures pluginB is available before loading pluginA.

```properties
Plugin-Dependencies: pluginB
```

--------------------------------

### Abstract Methods for AbstractPluginManager

Source: https://pf4j.org/doc/custom-manager.html

These are the abstract factory methods that must be implemented when extending AbstractPluginManager to create a custom plugin manager from scratch.

```java
public abstract class AbstractPluginManager implements PluginManager {

    protected abstract PluginRepository createPluginRepository();
    protected abstract PluginFactory createPluginFactory();
    protected abstract ExtensionFactory createExtensionFactory();
    protected abstract PluginDescriptorFinder createPluginDescriptorFinder();
    protected abstract ExtensionFinder createExtensionFinder();
    protected abstract PluginStatusProvider createPluginStatusProvider();
    protected abstract PluginLoader createPluginLoader();

    // other non abstract methods

}
```

--------------------------------

### Custom PluginLoader Interface

Source: https://pf4j.org/doc/class-loading.html

Shows the PluginLoader interface, which can be implemented to customize how plugins are loaded, including returning a shared class loader for all plugins.

```java
public interface PluginLoader {

    boolean isApplicable(Path pluginPath);

    ClassLoader loadPlugin(Path pluginPath, PluginDescriptor pluginDescriptor);

}
```

--------------------------------

### Explicitly Configure Plugin Dependencies for Extensions

Source: https://pf4j.org/doc/extensions.html

Use the 'plugins' attribute in the @Extension annotation to specify required plugins for an extension. This is particularly useful for extensions that have optional dependencies on other plugins, ensuring the extension is only loaded if all specified plugins are available at runtime.

```java
import org.pf4j.Extension;
import javax.swing.JPanel;

@Extension(plugins = {ContactsPlugin.ID, CalendarPlugin.ID})
public class CalendarContactsFormExtension implements ContactsFormExtension {

    public JPanel getPanel() {
        // some implementation...
    }
    public void load(ContactsEntry entry) {
        // some implementation...
    }
    public void load(ContactsEntry save) {
        // some implementation...
    }

}
```

```java
import org.pf4j.Extension;
import javax.swing.JPanel;

@Extension(plugins = {ContactsPlugin.ID, CalendarPlugin.ID})
public class ContactsCalendarFormExtension implements CalendarFormExtension {

    public JPanel getPanel() {
        // some implementation...
    }

    public void load(CalendarEntry entry) {
        // some implementation...
    }

    public void load(CalendarEntry save) {
        // some implementation...
    }

}
```

--------------------------------

### Define Required Plugin Dependency with Version Range (Exclusive Upper Bound)

Source: https://pf4j.org/doc/plugins.html

Specify that pluginA requires pluginB from version 1.0.0 up to (but not including) 2.0.0. The plugin manager ensures pluginB is within this version range.

```properties
Plugin-Dependencies: pluginB@>=1.0.0 & <2.0.0
```

--------------------------------

### Define an Extension Point

Source: https://pf4j.org/doc/getting-started.html

Interface marker for defining an extension point that plugins can implement.

```java
public interface Greeting extends ExtensionPoint {

    String getGreeting();

}
```

--------------------------------

### Plugin Metadata Configuration with Maven Assembly Plugin

Source: https://pf4j.org/doc/plugins.html

Configure plugin metadata within the pom.xml using the maven-assembly-plugin. This is useful for creating plugin archives with dependencies.

```xml
<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-assembly-plugin</artifactId>
    <configuration>
        <descriptorRefs>
            <descriptorRef>jar-with-dependencies</descriptorRef>
        </descriptorRefs>
        <finalName>${project.artifactId}-${project.version}-plugin</finalName>
        <appendAssemblyId>false</appendAssemblyId>
        <attach>false</attach>
        <archive>
            <manifest>
                <addDefaultImplementationEntries>true</addDefaultImplementationEntries>
                <addDefaultSpecificationEntries>true</addDefaultSpecificationEntries>
            </manifest>
            <manifestEntries>
                <Plugin-Class>org.pf4j.demo.welcome.WelcomePlugin</Plugin-Class>
                <Plugin-Id>welcome-plugin</Plugin-Id>
                <Plugin-Version>0.0.1</Plugin-Version>
                <Plugin-Requires>1.0.0</Plugin-Requires>
                <Plugin-Dependencies>x, y, z</Plugin-Dependencies>
                <Plugin-Description>My example plugin</Plugin-Description>
                <Plugin-Provider>Decebal Suiu</Plugin-Provider>
                <Plugin-License>Apache License 2.0</Plugin-License>
            </manifestEntries>
        </archive>
    </configuration>
    <executions>
        <execution>
            <id>make-assembly</id>
            <phase>package</phase>
            <goals>
                <goal>single</goal>
            </goals>
        </execution>
    </executions>
</plugin>

```

--------------------------------

### Plugin Metadata Configuration with Maven Jar Plugin

Source: https://pf4j.org/doc/plugins.html

Configure plugin metadata within the pom.xml using the maven-jar-plugin. This allows for automated manifest generation during the build process.

```xml
<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-jar-plugin</artifactId>
    <configuration>
        <archive>
            <manifest>
                <addDefaultImplementationEntries>true</addDefaultImplementationEntries>
                <addDefaultSpecificationEntries>true</addDefaultSpecificationEntries>
            </manifest>
            <manifestEntries>
                <Plugin-Class>org.pf4j.demo.welcome.WelcomePlugin</Plugin-Class>
                <Plugin-Id>welcome-plugin</Plugin-Id>
                <Plugin-Version>0.0.1</Plugin-Version>
                <Plugin-Requires>1.0.0</Plugin-Requires>
                <Plugin-Dependencies>x, y, z</Plugin-Dependencies>
                <Plugin-Description>My example plugin</Plugin-Description>
                <Plugin-Provider>Decebal Suiu</Plugin-Provider>
                <Plugin-License>Apache License 2.0</Plugin-License>
            </manifestEntries>
        </archive>
    </configuration>
</plugin>

```

--------------------------------

### Add PF4J Test Dependency to Maven POM

Source: https://pf4j.org/doc/testing.html

Include this dependency in your Maven POM file to access PF4J's testing utilities. Ensure the pf4j.version is correctly set.

```xml
<dependency>
    <groupId>org.pf4j</groupId>
    <artifactId>pf4j</artifactId>
    <version>${pf4j.version}</version>
    <!--
    <classifier>tests</classifier>
    -->
    <type>test-jar</type>
    <scope>test</scope>
</dependency>
```

--------------------------------

### Plugin Properties Descriptor

Source: https://pf4j.org/doc/getting-started.html

Content of a plugin.properties file used with PropertiesPluginDescriptorFinder to define plugin metadata.

```properties
plugin.class=org.pf4j.demo.welcome.WelcomePlugin
plugin.dependencies=x, y, z
plugin.id=welcome-plugin
plugin.provider=Decebal Suiu
plugin.version=0.0.1
```

--------------------------------

### Order Extensions with Ordinal

Source: https://pf4j.org/doc/extensions.html

The `ordinal` parameter in the `@Extension` annotation can be used to control the order in which extensions are loaded and applied. Lower ordinal values are loaded first.

```java
@Extension(ordinal = 1)
public class FirstMainMenuExtension implements MainMenuExtensionPoint {

    public void buildMenuBar(JMenuBar menuBar) {
        JMenu menu = new JMenu("First");
        menu.add(new JMenuItem("Hello World"));
        menuBar.add(menu);
    }

}
```

```java
@Extension(ordinal = 2)
public class SecondMainMenuExtension implements MainMenuExtensionPoint {

    public void buildMenuBar(JMenuBar menuBar) {
        JMenu menu = new JMenu("Second");
        menu.add(new JMenuItem("Hello World"));
        menuBar.add(menu);
    }

}
```

--------------------------------

### Explicitly Configure Extension Point

Source: https://pf4j.org/doc/extensions.html

Use the 'points' attribute in the @Extension annotation when an extension class does not directly implement the ExtensionPoint interface, but rather extends an abstract class or an interface that extends ExtensionPoint. This ensures PF4J correctly identifies the extension point.

```java
import org.pf4j.Extension;
import javax.swing.JMenuBar;

@Extension(points = {MainMenuExtensionPoint.class})
public class Plugin1MainMenuExtension extends MainMenuAdapter {

    public void buildMenuBar(JMenuBar menuBar) {
        // some implementation...
    }

}
```
Tokens:
Raw