Java Plug-in Framework (JPF) Project
Welcome to the Java Plug-in Framework project, the open source, LGPL licensed plug-in infrastructure library for new or existing Java projects. JPF can greatly improve the modularity and extensibility of your Java systems and minimize support and maintenance costs.
What is JPF?
JPF provides a runtime engine that dynamically discovers and loads "plug-ins". A plug-in is a structured component that describes itself to JPF using a "manifest". JPF maintains a registry of available plug-ins and the functions they provide (via extension points and extensions).
One major goal of JPF is that the application (and its end-user) should not pay any memory or performance penalty for plug-ins that are installed, but not used. Plug-ins are added to the registry at application start-up or while the application is running but they are not loaded until they are called.
- Open framework architecture
- The framework API is designed as a set of Java interfaces and abstract classes. Developers can choose to implement their own "vision" of plug-ins and Framework runtime behavior. "Standard" or default implementations are provided by JPF so developers can start using the framework quickly and easily.
- Clear and consistent API design
- The JPF API has been carefully designed in order to reduce the the time developers need to become familiar with it.
- Built-in integrity check
- Registered plug-ins are checked for consistency during JPF start up and a detailed report of results is available.
- Plug-ins are self-documenting
- Plug-in developers may include documentation in the plug-in manifest. This includes inline comments or references to documents bundled with the plug-in.
- Plug-in dependency check
- Plug-in developers can declare dependencies between plug-ins. Dependency declarations can include the desired version ID and versions matching rules.
- Strongly typed extension parameters
- The plug-in manifest syntax provides a mechanism for declaring typed extension points parameters. This information is used by JPF when finding and loading extensions.
- Lazy plug-in activation
- Plug-in classes are loaded into memory only when they are actually needed. This feature is provided by specially designed Java class loaders instantiated for each plug-in.
- "On the fly" plug-in registration and activation
- Plug-ins can be "hot-registered" and even de-registered during application execution. What's more, registered plug-ins can be activated and deactivated "on the fly", minimizing runtime resource usage.
What can JPF bring to your Java project?
- Plug-in component model
- A JPF Plug-in is a component that has: a name (ID), a version identifier, code and/or other resources, a well-defined import interface, a well-defined export interface, and well-defined places where it can be extended (extension points). You can think of plug-ins as a module for your application.
- Divide large applications into smaller, more manageable parts
- Building applications as a set of independent, cooperating components is particularly useful when developing in teams.
- Explicitly define the systems architecture
- Plug-ins, prerequisites, extension points and extensions allow you to clearly define the architecture of your system in an easy-to-understand and standard way.
- Make the application easily extendable
- With extension points you can allow other developers to extend your application simply.
- Documentation embedded into the system
- This is more than javadoc. You can include documentation in the plug-in manifest and link it with any additional resources.
- Tight control over application consistency
- JPF's built-in integrity check keeps a close watch on your application's health, reducing maintenance costs.
- Improved resource reuse
- The JPF extension points mechanism lets you easily share your code and other resources among different applications.
Current version and status
The latest framework version is 1.0.2 for Java 2 and 1.5.1 for Java 5. It was released on May 19, 2007 and has been designated as production quality. The framework API is considered to be stable and "frozen". The runtime behavior of the framework has been reported as very stable (some projects using JPF have reported containing dozens and hundreds of plug-ins, see references).
If JPF starts successfully - it just works and works :)
The best way to get a feel for JPF and how to use it is to look at the example modular application provided with JPF and try to write your own JPF plug-ins. This demo application is available from the JPF download page.
The demo application includes a "Plug-in Browser Tool" that may be useful to analyze the plug-in structure and dependencies.
This project was inspired by and continues to be influenced by the Eclipse Platform - an open source Java IDE and "rich client" GUI applications platform.
The plug-in architecture used by Eclipse was taken as the basic model for JPF in early 2004. JPF is can be considered as an attempt to "decouple" the plug-in framework from Eclipse 2.x for use in any Java project. Note that although Eclipse plug-ins are visually very similar to JPF plug-ins, they are NOT compatible and thus can't be used together.