Plug-In Architecture Pattern

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

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

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

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

Solution

Dynamic Behavior : Plug-in Registration

Dynamic Behavior : Plug-in Selection and Execution

Dynamic Behavior : Plug-in Un-registration

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

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.

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.)

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

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.

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

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"); } …

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(); } }

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