Extending applications with PF4J plugins

This repository provides a tutorial and an example on how to use PF4J to develop an application that supports extension through the development of third-party plugins.

User Stories:

Initially, we focus on the minimum amount of code to create a java applicaiton with plugin support.

Then, we extend the functionality to include container and plugins built with Spring boot

Next, we add a new Restful endpoint using an annotated class

Finally, we add a reactive Restful endpoint using a Router Function

Contents

Overview ………………….. Explains the reasons behind creation of this repository

Shared Interface…………. Allows plugins to interact with the container and eachother

Baremetal Plugin…………. Minimal java code that creates a functioning plugin

Baremetal Container……. Minimal java code that creates standalone plugin container

Spring boot Plugin………… A plugin that uses Spring boot for DI and adds endpoints created with annotated classes or router functions.

Spring boot Container…… A Spring boot app with plugin support and reactive Restful service

Overview

Plugins are pieces of software, developed by a third-party, that extend the functionality of a given application. There are many benefits to an application that supports plugins, such as flexibility to accommodate new requirements, extensibility to integrate in new environments, and suitability in being able to create tailored solutions by including only the functionality required for a specific use case.

There are multiple ways of adding plugin support to a Java application. The powerful, age-old and very complex OSGI network to the use of simple and limited-functionality mechanisms inherent in Java 8. One good mid-way compromise which is neither too simplistic nor too complicated is Pf4J, although by no means this is to claim that it is the only or even the best solution for the problem.

PF4J is a plugin framework for Java, that allows third party developers to extend the functionality of an application by adding a zip file to the plugins folder that will be loaded at runtime. Extensions can also be added to the application jar file if needed. the PF4J Github repository has an example of how to develop such an application, along with comprehensive documentation on the framework. While these should certainly be studied, in our experience understanding the examples was not easy for the average developers and we decided to contribure by creating this tutorial.

This project demonstrates the same concepts in a more practical way. Three separate maven projects are created, and a scenario is presented on how the solution will be created and deployed.

Actors

In the plugin management system, two main actors are at play. the application owner, who creates the application which accepts the plugin, and published the interfaces that the second actor, the plugin developer, implements to develop extended functionality.

Artifacts

The solution involves three components. the first component is in the form of a java interface, which is developed by the application owner and consists of a series of mehtods that plugin developer implements to extend the application. This component should be typically published in maven repository or some similar place and is added to the other two components as a dependency.

the second component is the container, which is also developed by the application owner. Once started, the plugin container scans the plugins folder and reads and unzips the plugins in that folder, loading the classes and starting and stopping the plugins.

the third component is the plugin itself. it is developed by the plugin developer and implements some of the shared interfaces defined in the first component and together with its own dependencies resides as a zip file in the plugins directory where the container will be looking for it.

The following table summarizes the above concepts

Back to Contents