Historically we have seen the success of plug-in based products like Mozilla Firefox and Eclipse IDE where new content can be plugged-in at runtime to augment software functionality.  In plug-in based architecture there is always a base container implementation where other components are added as plug-ins to extend its functionality; however, in these solutions there are no extension points exposed in added plug-in components to interact or bind them together. In this article I discuss the details of a pattern that is a hybrid of plug-in and event-driven architecture to integrate individual plug-ins together  to come up with a Plug-in Integrator Pattern. This pattern leverages the benefits of both of these well-known architectures to provide an optimal solution to build enterprise-ready rapid application development infrastructure, preferably in Flex but it could also be implemented in other programming languages such as Java and C#. I call it a pattern, not a framework, because it’s abstract and may be implemented in any software solutions.

The basic need to come up with such a pattern is to integrate already-released software components at runtime and use them to develop new applications with minimal testing and developmental effort and maximize the code reuse. Flex is already becoming the preferred choice while programming RIAs and with the adoption of Flex in the marketplace, many web applications are being written in Flex. It's time to think about how to provide a common platform where these disparate components written by various vendors can be integrated to build new applications during runtime. A good example is desktop widgets being developed by several vendors; if coded according to this pattern, these disparate widgets can interact with each other to provide more elegant solutions for the end user. This pattern makes a runtime plug-in such as embedding Flex content and hooking them up with messaging a reality, where each Flex component can interoperate with each other to make really extensible solutions with a versatile mix of plug-in and loosely coupled event-driven architecture.

I you really want to take your Flex applications to the next step and expose them to the world and also build robust Flex-based applications using components already released by others, read on…

Why the Plug-in Integrator Pattern?
The Plug-in Integrator Pattern is a hybrid of the plug-in pattern and event-driven architecture. This plug-in pattern refers to a mechanism for creating an object instance of a certain interface at runtime while the actual configuration and implementation of the instance is usually controlled by external configuration. The message-driven architecture refers to the design and implementation of applications and systems that transmit events among loosely coupled software components and services. The Plug-in Integrator Pattern is a mix of both of these concepts where the container implements a plug-in mechanism to load contained components, implementing the plug-in interface and hooking up these components to pass messages between themselves by reading configuration details from an externally maintained configurator. This mechanism of having the external configurator load and hook up content provides the best solution to reusing existing tested components to come up with functional applications in no time. Please refer to Figure 1 for more details.