Java tutorial
/* * Copyright 2004-2005 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package org.grails.plugins; import grails.artefact.Enhanced; import grails.plugins.PluginFilter; import org.grails.config.NavigableMap; import grails.plugins.GrailsPlugin; import grails.plugins.GrailsPluginManager; import grails.plugins.GrailsVersionUtils; import grails.util.BuildScope; import grails.util.Environment; import grails.util.GrailsNameUtils; import grails.util.Metadata; import groovy.lang.ExpandoMetaClass; import groovy.lang.GroovySystem; import groovy.lang.MetaClassRegistry; import groovy.util.ConfigObject; import groovy.util.ConfigSlurper; import java.io.File; import java.util.ArrayList; import java.util.Collections; import java.util.HashMap; import java.util.List; import java.util.Map; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import grails.core.ArtefactHandler; import grails.core.GrailsApplication; import org.grails.core.legacy.LegacyGrailsApplication; import org.grails.spring.RuntimeSpringConfiguration; import org.grails.io.support.GrailsResourceUtils; import grails.plugins.exceptions.PluginException; import org.codehaus.groovy.runtime.DefaultGroovyMethods; import org.springframework.beans.BeansException; import org.springframework.beans.factory.config.AutowireCapableBeanFactory; import org.springframework.beans.factory.config.ConfigurableListableBeanFactory; import org.springframework.context.ApplicationContext; import org.springframework.core.annotation.AnnotationUtils; import org.springframework.core.convert.ConversionService; import org.springframework.core.convert.converter.Converter; import org.springframework.core.convert.converter.ConverterRegistry; import org.springframework.core.convert.support.GenericConversionService; import org.springframework.core.io.FileSystemResource; import org.springframework.core.io.Resource; import org.springframework.core.type.filter.TypeFilter; import org.springframework.util.Assert; import org.springframework.util.StringUtils; /** * Abstract implementation of the GrailsPluginManager interface * * @author Graeme Rocher * @since 0.4 */ public abstract class AbstractGrailsPluginManager implements GrailsPluginManager, org.codehaus.groovy.grails.plugins.GrailsPluginManager { private static final Log LOG = LogFactory.getLog(AbstractGrailsPluginManager.class); private static final String BLANK = ""; public static final String CONFIG_FILE = "application.groovy"; protected List<GrailsPlugin> pluginList = new ArrayList<GrailsPlugin>(); protected GrailsApplication application; protected Resource[] pluginResources = new Resource[0]; protected Map<String, GrailsPlugin> plugins = new HashMap<String, GrailsPlugin>(); protected Map<String, GrailsPlugin> classNameToPluginMap = new HashMap<String, GrailsPlugin>(); protected Class<?>[] pluginClasses = new Class[0]; protected boolean initialised = false; protected boolean shutdown = false; protected ApplicationContext applicationContext; protected Map<String, GrailsPlugin> failedPlugins = new HashMap<String, GrailsPlugin>(); protected boolean loadCorePlugins = true; private static final String CONFIG_BINDING_USER_HOME = "userHome"; private static final String CONFIG_BINDING_GRAILS_HOME = "grailsHome"; private static final String CONFIG_BINDING_APP_NAME = "appName"; private static final String CONFIG_BINDING_APP_VERSION = "appVersion"; public AbstractGrailsPluginManager(GrailsApplication application) { Assert.notNull(application, "Argument [application] cannot be null!"); this.application = application; } public List<TypeFilter> getTypeFilters() { List<TypeFilter> list = new ArrayList<TypeFilter>(); for (GrailsPlugin grailsPlugin : pluginList) { list.addAll(grailsPlugin.getTypeFilters()); } return Collections.unmodifiableList(list); } public GrailsPlugin[] getAllPlugins() { return pluginList.toArray(new GrailsPlugin[pluginList.size()]); } public GrailsPlugin[] getFailedLoadPlugins() { return failedPlugins.values().toArray(new GrailsPlugin[failedPlugins.size()]); } /** * @return the initialised */ public boolean isInitialised() { return initialised; } protected void checkInitialised() { Assert.state(initialised, "Must call loadPlugins() before invoking configurational methods on GrailsPluginManager"); } public GrailsPlugin getFailedPlugin(String name) { if (name.indexOf('-') > -1) { name = GrailsNameUtils.getPropertyNameForLowerCaseHyphenSeparatedName(name); } return failedPlugins.get(name); } /** * Base implementation that simply goes through the list of plugins and calls doWithRuntimeConfiguration on each * @param springConfig The RuntimeSpringConfiguration instance */ public void doRuntimeConfiguration(RuntimeSpringConfiguration springConfig) { ApplicationContext context = springConfig.getUnrefreshedApplicationContext(); AutowireCapableBeanFactory autowireCapableBeanFactory = context.getAutowireCapableBeanFactory(); if (autowireCapableBeanFactory instanceof ConfigurableListableBeanFactory) { ConfigurableListableBeanFactory beanFactory = (ConfigurableListableBeanFactory) autowireCapableBeanFactory; ConversionService existingConversionService = beanFactory.getConversionService(); ConverterRegistry converterRegistry; if (existingConversionService == null) { GenericConversionService conversionService = new GenericConversionService(); converterRegistry = conversionService; beanFactory.setConversionService(conversionService); } else { converterRegistry = (ConverterRegistry) existingConversionService; } converterRegistry.addConverter( new Converter<GrailsApplication, org.codehaus.groovy.grails.commons.GrailsApplication>() { @Override public org.codehaus.groovy.grails.commons.GrailsApplication convert( GrailsApplication source) { return new LegacyGrailsApplication(source); } }); converterRegistry.addConverter(new Converter<NavigableMap.NullSafeNavigator, Object>() { @Override public Object convert(NavigableMap.NullSafeNavigator source) { return null; } }); } checkInitialised(); for (GrailsPlugin plugin : pluginList) { if (plugin.supportsCurrentScopeAndEnvironment() && plugin.isEnabled(context.getEnvironment().getActiveProfiles())) { plugin.doWithRuntimeConfiguration(springConfig); } } } /** * Base implementation that will perform runtime configuration for the specified plugin name. */ public void doRuntimeConfiguration(String pluginName, RuntimeSpringConfiguration springConfig) { checkInitialised(); GrailsPlugin plugin = getGrailsPlugin(pluginName); if (plugin == null) { throw new PluginException("Plugin [" + pluginName + "] not found"); } if (!plugin.supportsCurrentScopeAndEnvironment()) { return; } if (!plugin.isEnabled(applicationContext.getEnvironment().getActiveProfiles())) return; String[] dependencyNames = plugin.getDependencyNames(); doRuntimeConfigurationForDependencies(dependencyNames, springConfig); String[] loadAfters = plugin.getLoadAfterNames(); for (String name : loadAfters) { GrailsPlugin current = getGrailsPlugin(name); if (current != null) { current.doWithRuntimeConfiguration(springConfig); } } plugin.doWithRuntimeConfiguration(springConfig); } private void doRuntimeConfigurationForDependencies(String[] dependencyNames, RuntimeSpringConfiguration springConfig) { for (String dn : dependencyNames) { GrailsPlugin current = getGrailsPlugin(dn); if (current == null) { throw new PluginException("Cannot load Plugin. Dependency [" + current + "] not found"); } String[] pluginDependencies = current.getDependencyNames(); if (pluginDependencies.length > 0) { doRuntimeConfigurationForDependencies(pluginDependencies, springConfig); } if (isPluginDisabledForProfile(current)) continue; current.doWithRuntimeConfiguration(springConfig); } } /** * Base implementation that will simply go through each plugin and call doWithApplicationContext on each. */ public void doPostProcessing(ApplicationContext ctx) { checkInitialised(); for (GrailsPlugin plugin : pluginList) { if (isPluginDisabledForProfile(plugin)) continue; if (plugin.supportsCurrentScopeAndEnvironment()) { plugin.doWithApplicationContext(ctx); } } } public Resource[] getPluginResources() { return pluginResources; } public GrailsPlugin getGrailsPlugin(String name) { if (name.indexOf('-') > -1) { name = GrailsNameUtils.getPropertyNameForLowerCaseHyphenSeparatedName(name); } return plugins.get(name); } public GrailsPlugin getGrailsPluginForClassName(String name) { return classNameToPluginMap.get(name); } public GrailsPlugin getGrailsPlugin(String name, Object version) { if (name.indexOf('-') > -1) { name = GrailsNameUtils.getPropertyNameForLowerCaseHyphenSeparatedName(name); } GrailsPlugin plugin = plugins.get(name); if (plugin != null && GrailsVersionUtils.isValidVersion(plugin.getVersion(), version.toString())) { return plugin; } return null; } public boolean hasGrailsPlugin(String name) { if (name.indexOf('-') > -1) { name = GrailsNameUtils.getPropertyNameForLowerCaseHyphenSeparatedName(name); } return plugins.containsKey(name); } public void doDynamicMethods() { checkInitialised(); Class<?>[] allClasses = application.getAllClasses(); if (allClasses != null) { for (Class<?> c : allClasses) { ExpandoMetaClass emc = new ExpandoMetaClass(c, true, true); emc.initialize(); } ApplicationContext ctx = applicationContext; for (GrailsPlugin plugin : pluginList) { if (!plugin.isEnabled(ctx.getEnvironment().getActiveProfiles())) continue; plugin.doWithDynamicMethods(ctx); } } } public void setApplicationContext(ApplicationContext applicationContext) throws BeansException { this.applicationContext = applicationContext; if (applicationContext != null) { for (GrailsPlugin plugin : pluginList) { plugin.setApplicationContext(applicationContext); } } } public void setApplication(GrailsApplication application) { Assert.notNull(application, "Argument [application] cannot be null"); this.application = application; for (GrailsPlugin plugin : pluginList) { plugin.setApplication(application); } } public void registerProvidedArtefacts(GrailsApplication app) { checkInitialised(); // since plugin classes are added as overridable artefacts, which are added as the first // item in the list of artefacts, we have to iterate in reverse order to ensure plugin // load sequence is maintained ArrayList<GrailsPlugin> plugins = new ArrayList<GrailsPlugin>(pluginList); Collections.reverse(plugins); for (GrailsPlugin plugin : plugins) { if (plugin.supportsCurrentScopeAndEnvironment()) { if (isPluginDisabledForProfile(plugin)) continue; for (Class<?> artefact : plugin.getProvidedArtefacts()) { String shortName = GrailsNameUtils.getShortName(artefact); if (!isAlreadyRegistered(app, artefact, shortName)) { app.addOverridableArtefact(artefact); } } } } } private boolean isAlreadyRegistered(GrailsApplication app, Class<?> artefact, String shortName) { return app.getClassForName(shortName) != null || app.getClassForName(artefact.getName()) != null; } public void doArtefactConfiguration() { checkInitialised(); for (GrailsPlugin plugin : pluginList) { if (isPluginDisabledForProfile(plugin)) continue; if (plugin.supportsCurrentScopeAndEnvironment()) { plugin.doArtefactConfiguration(); } } } protected boolean isPluginDisabledForProfile(GrailsPlugin plugin) { return applicationContext != null && !plugin.isEnabled(applicationContext.getEnvironment().getActiveProfiles()); } public void shutdown() { checkInitialised(); try { for (GrailsPlugin plugin : pluginList) { if (!plugin.isEnabled(applicationContext.getEnvironment().getActiveProfiles())) continue; if (plugin.supportsCurrentScopeAndEnvironment()) { plugin.notifyOfEvent(GrailsPlugin.EVENT_ON_SHUTDOWN, plugin); } } } finally { shutdown = true; } } public boolean isShutdown() { return shutdown; } @Override public void setPluginFilter(PluginFilter pluginFilter) { // no-op } public boolean supportsCurrentBuildScope(String pluginName) { GrailsPlugin plugin = getGrailsPlugin(pluginName); return plugin == null || plugin.supportsScope(BuildScope.getCurrent()); } public void setLoadCorePlugins(boolean shouldLoadCorePlugins) { loadCorePlugins = shouldLoadCorePlugins; } public void informOfClassChange(Class<?> aClass) { if (aClass == null || application == null) { return; } ArtefactHandler handler = application.getArtefactType(aClass); if (handler == null) { return; } String pluginName = handler.getPluginName(); if (pluginName == null) { return; } GrailsPlugin plugin = getGrailsPlugin(pluginName); if (plugin != null) { if (!plugin.isEnabled(applicationContext.getEnvironment().getActiveProfiles())) return; plugin.notifyOfEvent(GrailsPlugin.EVENT_ON_CHANGE, aClass); } } public String getPluginPath(String name) { return getPluginPath(name, false); } public String getPluginPath(String name, boolean forceCamelCase) { GrailsPlugin plugin = getGrailsPlugin(name); if (plugin != null && !plugin.isBasePlugin()) { if (forceCamelCase) { return plugin.getPluginPathCamelCase(); } else { return plugin.getPluginPath(); } } return BLANK; } public String getPluginPathForInstance(Object instance) { if (instance != null) { return getPluginPathForClass(instance.getClass()); } return null; } public GrailsPlugin getPluginForInstance(Object instance) { if (instance != null) { return getPluginForClass(instance.getClass()); } return null; } public GrailsPlugin getPluginForClass(Class<?> theClass) { if (theClass != null) { grails.plugins.metadata.GrailsPlugin ann = theClass .getAnnotation(grails.plugins.metadata.GrailsPlugin.class); if (ann != null) { return getGrailsPlugin(ann.name()); } } return null; } @Override public void informPluginsOfConfigChange() { for (GrailsPlugin plugin : pluginList) { plugin.notifyOfEvent(GrailsPlugin.EVENT_ON_CONFIG_CHANGE, application.getConfig()); } } public void informOfFileChange(File file) { String className = GrailsResourceUtils.getClassName(file.getAbsolutePath()); Class<?> cls = null; if (className != null) { cls = loadApplicationClass(className); } informOfClassChange(file, cls); } static ConfigSlurper getConfigSlurper(GrailsApplication application) { String environment = Environment.getCurrent().getName(); ConfigSlurper configSlurper = new ConfigSlurper(environment); Map binding = new HashMap(); // configure config slurper binding binding.put(CONFIG_BINDING_USER_HOME, System.getProperty("user.home")); binding.put(CONFIG_BINDING_GRAILS_HOME, System.getProperty("grails.home")); if (application != null) { binding.put(CONFIG_BINDING_APP_NAME, application.getMetadata().get(Metadata.APPLICATION_NAME)); binding.put(CONFIG_BINDING_APP_VERSION, application.getMetadata().get(Metadata.APPLICATION_VERSION)); binding.put(GrailsApplication.APPLICATION_ID, application); } configSlurper.setBinding(binding); return configSlurper; } public void informOfClassChange(File file, @SuppressWarnings("rawtypes") Class cls) { if (file.getName().equals(CONFIG_FILE)) { ConfigSlurper configSlurper = getConfigSlurper(application); ConfigObject c; try { c = configSlurper.parse(file.toURI().toURL()); application.getConfig().merge(c); final Map flat = c.flatten(); application.getConfig().merge(flat); application.configChanged(); informPluginsOfConfigChange(); } catch (Exception e) { // ignore LOG.debug("Error in changing Config", e); } } else { if (cls != null) { MetaClassRegistry registry = GroovySystem.getMetaClassRegistry(); registry.removeMetaClass(cls); ExpandoMetaClass newMc = new ExpandoMetaClass(cls, true, true); newMc.initialize(); registry.setMetaClass(cls, newMc); Enhanced en = AnnotationUtils.findAnnotation(cls, Enhanced.class); if (en != null) { Class<?>[] mixinClasses = en.mixins(); if (mixinClasses != null) { DefaultGroovyMethods.mixin(newMc, mixinClasses); } } } for (GrailsPlugin grailsPlugin : pluginList) { if (grailsPlugin.hasInterestInChange(file.getAbsolutePath())) { try { if (cls == null) { grailsPlugin.notifyOfEvent(GrailsPlugin.EVENT_ON_CHANGE, new FileSystemResource(file)); } else { grailsPlugin.notifyOfEvent(GrailsPlugin.EVENT_ON_CHANGE, cls); } Environment.setCurrentReloadError(null); } catch (Exception e) { LOG.error("Plugin " + grailsPlugin + " could not reload changes to file [" + file + "]: " + e.getMessage(), e); Environment.setCurrentReloadError(e); } } } } } private Class<?> loadApplicationClass(String className) { Class<?> cls = null; try { cls = application.getClassLoader().loadClass(className); } catch (ClassNotFoundException e) { // ignore } return cls; } public String getPluginPathForClass(Class<?> theClass) { if (theClass != null) { grails.plugins.metadata.GrailsPlugin ann = theClass .getAnnotation(grails.plugins.metadata.GrailsPlugin.class); if (ann != null) { return getPluginPath(ann.name()); } } return null; } public String getPluginViewsPathForInstance(Object instance) { if (instance != null) { return getPluginViewsPathForClass(instance.getClass()); } return null; } public String getPluginViewsPathForClass(Class<?> theClass) { if (theClass != null) { final String path = getPluginPathForClass(theClass); if (StringUtils.hasText(path)) { return path + '/' + GrailsResourceUtils.GRAILS_APP_DIR + "/views"; } } return null; } }