1. Plug-In Architecture Pattern

2. Problem
The functionality of a system needs to be extended after the software is shipped
The set of possible post-shipment extensions is large
Specific details on future extensions are not available, but their general nature is predictable
It should be possible to extend the system without access to the system's source code, by people who were not the system's original developers
It should be easy to add and remove extensions in whatever combination is desired by the customer

3. Example : Syntax Highlighting
You are writing a text editor intended for use by software developers
You want to support syntax highlighting, but the set of possible programming languages is unbounded
Even if you could list all of the possible languages, you don't have enough resources to implement syntax highlighting for them all
Third-party developers and end-users will need the ability to add syntax highlighting for their favorite languages without your help

4. Solution
Define an abstract interface that captures the general nature of the necessary extensions
interface ISyntaxHighlighter { … }
Extensions are components that implement the abstract interface
class PerlSyntaxHighlighter implements ISyntaxHighlighter { … }
How does the application know when to use our plug-in class?
How can the application instantiate our plug-in class?
It doesn’t know the class name to call “new” on (PerlSyntaxHighlighter)
At installation time, a new plug-in has to “register” with the application

5. Solution
Extensions are called "plug-ins" because they can be "plugged in" to the system without recompilation
The system instantiates plug-in components indirectly through a registry
The system invokes plug-in functionality through an abstract interface

6. Solution

7. Dynamic Behavior : Plug-in Registration

8. Dynamic Behavior : Plug-in Selection and Execution

9. Dynamic Behavior : Plug-in Un-registration

10. Known Uses Web browser plug-ins for different file formats
PDF, PowerPoint, Word, etc.
Web servers
Apache Modules
SSL, user authentication, caching, logging, etc.
IIS ISAPI Extensions
MS-Windows compound documents
"Insert Object" menu in many Windows applications

11. Known Uses Syntax Highlighting Eclipse
Framework for building integrated development environments (IDEs)
Provides basic shell for IDE UI
All actual work is done by plug-ins for specific development tasks
Editors, compilers, debuggers, wizards
Database drivers
Generic database APIs: ODBC, JDBC
Plug-in drivers for specific DBs: SqlServer, MySQL, Postgres, etc.

12. Consequences Results in a system that can be extended:
After it's shipped
By people other than the original developers
Without recompiling the system
Users are free to choose which plug-ins they want to install
Commercial opportunities for third-party plug-in developers
Buggy plug-ins can destabilize the system since they're usually loaded directly into the host application process (crashes, memory leaks, etc.)

13. Implementation: Windows
Plug-ins are frequently implemented as dynamically-linked libraries in Windows applications
The host application loads the plug-in DLLs that have been registered
Registration techniques
Just copy the plug-in DLL into a special directory. The host application loads all DLLs in the plug-in directory, and queries each DLL for information about its plug-in
Installer puts an entry in a configuration file that indicates where the plug-in DLL is located

14. Implementation: Java
In Java a plug-in could be a .class file containing the plug-in class
In most cases, plugins will consist of multiple classes, so they will exist in a .jar file
Registration could be as simple as putting the name of the plug-in jar file name and implementation class in a configuration file
The host application uses reflection to instantiate plug-in classes by name, which causes the classes to be loaded into the JVM
Plugins are meant to be loaded dynamically, meaning they aren’t on the application’s classpath. Use a Java classloader to make the class(es) from the plugin’s .jar file available to the application at runtime.

15. A Simple Plugin Example: The Plugin Interface
package plugin; public interface MessagePlugin { String getMessage(); }
Needs to be in two places
The application that will load the plugin
The plugin that will be loaded
In Intellij (similar in other IDEs):
Put the interface in a separate module in the application’s project so you can generate a jar file containing only the interface
Include the interface jar file as an external dependency in the plugin project

16. A Simple Plugin Example: The Application
public class Application { public static final void main(String [] args) throws Exception { if(args.length != 3) { printUsage(); } else { Application application = new Application(); application.start(args[0], args[1], args[2]); } } public static void printUsage() { System.out.println("Usage: java Application pluginDirectory " + "pluginJarFileName pluginClassName"); } …

17. A Simple Plugin Example: The Application
… private void start(String pluginDirectory, String pluginJarName,
String pluginClassName) throws Exception {
MessagePlugin messagePlugin = getMessagePluginInstance(
pluginDirectory, pluginJarName, pluginClassName); System.out.println(messagePlugin.getMessage()); } private MessagePlugin getMessagePluginInstance(String pluginDirectory,
String pluginJarName, String pluginClassName) throws Exception {
// Get a class loader and set it up to load the jar file File pluginJarFile = new File(pluginDirectory, pluginJarName); URL pluginURL = pluginJarFile.toURI().toURL(); URLClassLoader loader = new URLClassLoader(new URL[]{pluginURL}); // Load the jar file's plugin class, create and return an instance Class<? extends MessagePlugin> messagePluginClass = (Class<MessagePlugin>)
loader.loadClass(pluginClassName); return messagePluginClass.getDeclaredConstructor(null).newInstance(); } }

18. A Simple Plugin Example: The Plugin
import plugin.MessagePlugin; public class HelloMessage implements MessagePlugin { @Override public String getMessage() { return "Hello from the plugin"; } }
Exists in a separate project (separate from the application)
Has a dependency on the MessagePlugin jar
Create a jar containing the HelloMessage class and place it in some directory
Specify the directory, jar file name, and class name (HelloMessage in this case) when invoking the application that uses the plugin