public interface GrailsPluginManager extends ApplicationContextAware
Handles the loading and management of plug-ins in the Grails system. A plugin a just like a normal Grails application except that it contains a file ending in *Plugin.groovy in the root of the directory.
A Plugin class is a Groovy class that has a version and optionally closures called doWithSpring, doWithContext and doWithWebDescriptor
The doWithSpring closure uses the BeanBuilder syntax (
| Type Params | Return Type | Name and description | 
|---|---|---|
 | 
                            public void | 
                            doArtefactConfiguration()Called prior to the initialisation of the GrailsApplication object to allow registration of additional ArtefactHandler objects  | 
                        
 | 
                            public void | 
                            doDynamicMethods()Called on all plugins so that they can add new methods/properties/constructors etc.  | 
                        
 | 
                            public void | 
                            doPostProcessing(ApplicationContext applicationContext)Performs post initialization configuration for each plug-in, passing the built application context  | 
                        
 | 
                            public void | 
                            doRuntimeConfiguration(RuntimeSpringConfiguration springConfig)Executes the runtime configuration phase of plug-ins  | 
                        
 | 
                            public void | 
                            doRuntimeConfiguration(java.lang.String pluginName, RuntimeSpringConfiguration springConfig)Executes the runtime configuration for a specific plugin AND all its dependencies  | 
                        
 | 
                            public GrailsPlugin[] | 
                            getAllPlugins()Returns an array of all the loaded plug-ins  | 
                        
 | 
                            public GrailsPlugin[] | 
                            getFailedLoadPlugins()
  | 
                        
 | 
                            public GrailsPlugin | 
                            getFailedPlugin(java.lang.String name)Retrieves a plug-in that failed to load, or null if it doesn't exist  | 
                        
 | 
                            public GrailsPlugin | 
                            getGrailsPlugin(java.lang.String name)Retrieves a name Grails plugin instance  | 
                        
 | 
                            public GrailsPlugin | 
                            getGrailsPlugin(java.lang.String name, java.lang.Object version)Retrieves a plug-in for its name and version  | 
                        
 | 
                            public GrailsPlugin | 
                            getGrailsPluginForClassName(java.lang.String name)Obtains a GrailsPlugin for the given classname  | 
                        
 | 
                            public GrailsPlugin | 
                            getPluginForClass(java.lang.Class<?> theClass)Obtains the GrailsPlugin for the given class  | 
                        
 | 
                            public GrailsPlugin | 
                            getPluginForInstance(java.lang.Object instance)Looks up the plugin that defined the given instance.  | 
                        
 | 
                            public java.util.Collection | 
                            getPluginObservers(GrailsPlugin plugin)Retrieves a collection of plugins that are observing the specified plugin  | 
                        
 | 
                            public java.lang.String | 
                            getPluginPath(java.lang.String name)Returns the pluginContextPath for the given plugin  | 
                        
 | 
                            public java.lang.String | 
                            getPluginPath(java.lang.String name, boolean forceCamelCase)Returns the pluginContextPath for the given plugin and will force name to camel case instead of '-' lower case  | 
                        
 | 
                            public java.lang.String | 
                            getPluginPathForClass(java.lang.Class<? extends java.lang.Object> theClass)Returns the plugin path for the given class  | 
                        
 | 
                            public java.lang.String | 
                            getPluginPathForInstance(java.lang.Object instance)Returns the pluginContextPath for the given instance  | 
                        
 | 
                            public java.lang.String | 
                            getPluginViewsPathForClass(java.lang.Class<? extends java.lang.Object> theClass)Returns the plugin views directory path for the given class  | 
                        
 | 
                            public java.lang.String | 
                            getPluginViewsPathForInstance(java.lang.Object instance)Returns the plugin views directory for the given instance  | 
                        
 | 
                            public java.util.List<TypeFilter> | 
                            getTypeFilters()Get all of the TypeFilter definitions defined by the plugins  | 
                        
 | 
                            public GrailsPlugin[] | 
                            getUserPlugins()Gets plugin installed by the user and not provided by the framework  | 
                        
 | 
                            public boolean | 
                            hasGrailsPlugin(java.lang.String name)
  | 
                        
 | 
                            public void | 
                            informObservers(java.lang.String pluginName, java.util.Map event)inform the specified plugins observers of the event specified by the passed Map instance  | 
                        
 | 
                            public void | 
                            informOfClassChange(java.lang.Class<?> aClass)Method for handling changes to a class and triggering on change events etc.  | 
                        
 | 
                            public void | 
                            informOfClassChange(java.io.File file, java.lang.Class cls) | 
                        
 | 
                            public void | 
                            informOfFileChange(java.io.File file)Fire to inform the PluginManager that a particular file changes  | 
                        
 | 
                            public void | 
                            informPluginsOfConfigChange()Inform of a change in configuration  | 
                        
 | 
                            public boolean | 
                            isInitialised()
  | 
                        
 | 
                            public boolean | 
                            isShutdown()Indicates whether the manager has been shutdown or not  | 
                        
 | 
                            public void | 
                            loadPlugins()Performs the initial load of plug-ins throwing an exception if any dependencies don't resolve  | 
                        
 | 
                            public void | 
                            onStartup(java.util.Map<java.lang.String, java.lang.Object> event)Executes the Plugin.onStartup hook for all plugins  | 
                        
 | 
                            public void | 
                            refreshPlugin(java.lang.String name)Refreshes the specified plugin.  | 
                        
 | 
                            public void | 
                            registerProvidedArtefacts(GrailsApplication application)Registers pre-compiled artefacts with the GrailsApplication instance, only overriding if the application doesn't already provide an artefact of the same name.  | 
                        
 | 
                            public void | 
                            setApplication(GrailsApplication application)Sets the GrailsApplication used be this plugin manager  | 
                        
 | 
                            public void | 
                            setLoadCorePlugins(boolean shouldLoadCorePlugins)Set whether the core plugins should be loaded  | 
                        
 | 
                            public void | 
                            setPluginFilter(PluginFilter pluginFilter)Sets the filter to use to filter for plugins  | 
                        
 | 
                            public void | 
                            shutdown()Shuts down the PluginManager  | 
                        
Called prior to the initialisation of the GrailsApplication object to allow registration of additional ArtefactHandler objects
Called on all plugins so that they can add new methods/properties/constructors etc.
Performs post initialization configuration for each plug-in, passing the built application context
applicationContext -  The ApplicationContext instanceExecutes the runtime configuration phase of plug-ins
springConfig -  The RuntimeSpringConfiguration instanceExecutes the runtime configuration for a specific plugin AND all its dependencies
pluginName -  The name of he pluginspringConfig -  The runtime spring config instanceReturns an array of all the loaded plug-ins
Retrieves a plug-in that failed to load, or null if it doesn't exist
name -  The name of the pluginRetrieves a name Grails plugin instance
name -  The name of the pluginRetrieves a plug-in for its name and version
name -  The name of the pluginversion -  The version of the pluginObtains a GrailsPlugin for the given classname
name -  The name of the pluginObtains the GrailsPlugin for the given class
theClass -  The classLooks up the plugin that defined the given instance. If no plugin defined the instance then null is returned.
instance -  The instanceRetrieves a collection of plugins that are observing the specified plugin
plugin -  The plugin to retrieve observers forReturns the pluginContextPath for the given plugin
name -  The plugin nameReturns the pluginContextPath for the given plugin and will force name to camel case instead of '-' lower case my-plug-web would resolve to myPlugWeb if forceCamelCase is true.
name -  The plugin nameforceCamelCase -  Force camel case for nameReturns the plugin path for the given class
theClass -  The classReturns the pluginContextPath for the given instance
instance -  The instanceReturns the plugin views directory path for the given class
theClass -  The classReturns the plugin views directory for the given instance
instance -  The instanceGet all of the TypeFilter definitions defined by the plugins
Gets plugin installed by the user and not provided by the framework
name -  The name of the plugininform the specified plugins observers of the event specified by the passed Map instance
pluginName -  The name of the pluginevent -  The eventMethod for handling changes to a class and triggering on change events etc.
aClass -  The classFire to inform the PluginManager that a particular file changes
file -  The file that changedInform of a change in configuration
Indicates whether the manager has been shutdown or not
Performs the initial load of plug-ins throwing an exception if any dependencies don't resolve
Executes the Plugin.onStartup hook for all plugins
event -  the EventRefreshes the specified plugin. A refresh will force to plugin to "touch" each of its watched resources and fire modified events for each
name -  The name of the plugin to refreshRegisters pre-compiled artefacts with the GrailsApplication instance, only overriding if the application doesn't already provide an artefact of the same name.
application -  The GrailsApplication objectSets the GrailsApplication used be this plugin manager
application -  The GrailsApplication instanceSet whether the core plugins should be loaded
shouldLoadCorePlugins -  True if they shouldSets the filter to use to filter for plugins
pluginFilter -  The plugin filterShuts down the PluginManager