private Object handleTypeMismatchException(
String beanName, RootBeanDefinition mbd, Object[] args) {
// type mismatch probably occured because another class was reloaded
final Class<?> beanClass = mbd.getBeanClass();
if (!GroovyObject.class.isAssignableFrom(beanClass)) {
return null;
}
GrailsApplication application = (GrailsApplication) getBean(GrailsApplication.APPLICATION_ID);
ClassLoader classLoader = application.getClassLoader();
if (!(classLoader instanceof GrailsClassLoader)) {
return null;
}
GrailsClassLoader gcl = (GrailsClassLoader) classLoader;
gcl.reloadClass(beanClass.getName());
Class<?> newBeanClass;
try {
newBeanClass = gcl.loadClass(beanClass.getName());
} catch (ClassNotFoundException e) {
return null;
}
mbd.setBeanClass(newBeanClass);
if (newBeanClass.equals(beanClass)) {
return null;
}
GrailsPluginManager pluginManager =
(GrailsPluginManager) getBean(GrailsPluginManager.BEAN_NAME);
pluginManager.informOfClassChange(newBeanClass);
return super.doCreateBean(beanName, mbd, args);
}
private String getContextPath(GrailsWebRequest webRequest, Map argMap) {
Object cp = argMap.get(ARGUMENT_CONTEXTPATH);
String contextPath = (cp != null ? cp.toString() : "");
Object pluginName = argMap.get(ARGUMENT_PLUGIN);
if (pluginName != null) {
ApplicationContext applicationContext = webRequest.getApplicationContext();
GrailsPluginManager pluginManager =
(GrailsPluginManager) applicationContext.getBean(GrailsPluginManager.BEAN_NAME);
GrailsPlugin plugin = pluginManager.getGrailsPlugin(pluginName.toString());
if (plugin != null && !plugin.isBasePlugin()) contextPath = plugin.getPluginPath();
}
return contextPath;
}
private View lookupBinaryPluginView(
GrailsWebRequest webRequest, GroovyObject controller, String gspView) {
View v = null;
if (pluginManager != null && pluginManager.getPluginForInstance(controller) != null) {
final GrailsPlugin plugin = pluginManager.getPluginForInstance(controller);
if (plugin instanceof BinaryGrailsPlugin) {
BinaryGrailsPlugin binaryGrailsPlugin = (BinaryGrailsPlugin) plugin;
Class<?> viewClass = binaryGrailsPlugin.resolveView(gspView);
if (viewClass != null) {
v = createGroovyPageView(webRequest, gspView, viewClass);
}
}
}
return v;
}
/**
* Attempts to resolve a view relative to a controller.
*
* @param controller The controller to resolve the view relative to
* @param application The GrailsApplication instance
* @param viewName The views name
* @param loader The ResourceLoader to use
* @return The URI of the view
*/
protected String resolveViewForController(
GroovyObject controller,
GrailsApplication application,
String viewName,
ResourceLoader loader) {
String
gspView; // try to resolve the view relative to the controller first, this allows us to
// support views provided by plugins
if (controller != null && application != null) {
String pathToView =
pluginManager != null ? pluginManager.getPluginViewsPathForInstance(controller) : null;
if (pathToView != null) {
gspView = GrailsResourceUtils.WEB_INF + pathToView + viewName + GSP_SUFFIX;
} else {
gspView = localPrefix + viewName + GSP_SUFFIX;
}
} else {
gspView = localPrefix + viewName + GSP_SUFFIX;
}
if (LOG.isDebugEnabled()) {
LOG.debug(
"Attempting to resolve view for URI ["
+ gspView
+ "] using ResourceLoader ["
+ loader.getClass().getName()
+ "]");
}
return gspView;
}
@SuppressWarnings("deprecation")
protected Map<String, Object> createGlobalBinding(List<GrailsDomainClass> domainClass) {
boolean hasHibernate =
pluginManager.hasGrailsPlugin("hibernate") || pluginManager.hasGrailsPlugin("hibernate4");
Map<String, Object> binding = new HashMap<String, Object>();
binding.put("pluginManager", pluginManager);
binding.put("domainClassList", domainClass);
binding.put("renderEditor", getRenderEditor());
binding.put("applicationName", grailsApplication.getMetadata().get("app.name"));
binding.put(
"comparator",
hasHibernate
? DomainClassPropertyComparator.class
: SimpleDomainClassPropertyComparator.class);
return binding;
}
public static WebApplicationContext configureWebApplicationContext(
ServletContext servletContext, WebApplicationContext parent) {
ServletContextHolder.setServletContext(servletContext);
GrailsApplication application =
(GrailsApplication) parent.getBean(GrailsApplication.APPLICATION_ID);
if (LOG.isDebugEnabled()) {
LOG.debug("[GrailsContextLoader] Configuring Grails Application");
}
if (application.getParentContext() == null) {
application.setApplicationContext(parent);
}
GrailsRuntimeConfigurator configurator = null;
if (parent.containsBean(GrailsRuntimeConfigurator.BEAN_ID)) {
// get configurator from parent application context
configurator = (GrailsRuntimeConfigurator) parent.getBean(GrailsRuntimeConfigurator.BEAN_ID);
} else {
// get configurator from servlet context
configurator =
determineGrailsRuntimeConfiguratorFromServletContext(application, servletContext, parent);
}
if (configurator == null) {
// no configurator, use default
configurator = new GrailsRuntimeConfigurator(application, parent);
if (parent.containsBean(GrailsPluginManager.BEAN_NAME)) {
GrailsPluginManager pluginManager =
(GrailsPluginManager) parent.getBean(GrailsPluginManager.BEAN_NAME);
configurator.setPluginManager(pluginManager);
}
}
final GrailsPluginManager pluginManager = configurator.getPluginManager();
// return a context that obeys grails' settings
WebApplicationContext webContext = configurator.configure(servletContext);
pluginManager.setApplicationContext(webContext);
configureServletContextAttributes(servletContext, application, pluginManager, webContext);
LOG.info("[GrailsContextLoader] Grails application loaded.");
return webContext;
}
public void initRun(Writer target, GrailsWebRequest webRequest) {
this.outputStack = GroovyPageOutputStack.currentStack(true, target, false, true);
this.out = outputStack.getProxyWriter();
this.webRequest = webRequest;
final Map map = getBinding().getVariables();
if (map.containsKey(APPLICATION_CONTEXT)) {
final ApplicationContext applicationContext =
(ApplicationContext) map.get(APPLICATION_CONTEXT);
if (applicationContext != null
&& applicationContext.containsBean(GrailsPluginManager.BEAN_NAME)) {
final GrailsPluginManager pluginManager =
applicationContext.getBean(GrailsPluginManager.BEAN_NAME, GrailsPluginManager.class);
this.pluginContextPath = pluginManager.getPluginPathForInstance(this);
}
}
if (webRequest != null) {
this.webRequest.setOut(this.out);
}
getBinding().setVariable(OUT, this.out);
}
public void afterPropertiesSet() throws Exception {
if (pluginManager != null && localResourceLoader != null) {
GrailsPlugin[] plugins = pluginManager.getAllPlugins();
for (GrailsPlugin plugin : plugins) {
Resource[] pluginBundles;
final String pluginName = plugin.getFileSystemName();
pluginBundles = getPluginBundles(pluginName);
for (Resource pluginBundle : pluginBundles) {
String baseName = FilenameUtils.getBaseName(pluginBundle.getFilename());
baseName = StringUtils.substringBefore(baseName, "_");
pluginBaseNames.add(
WEB_INF_PLUGINS_PATH.substring(1) + pluginName + "/grails-app/i18n/" + baseName);
}
}
}
}
@SuppressWarnings("rawtypes")
@Override
public GrailsClass getArtefactForFeature(Object featureId) {
if (artefactInfo == null) {
return null;
}
String uri;
String pluginName = null;
if (featureId instanceof Map) {
Map featureIdMap = (Map) featureId;
uri = (String) featureIdMap.get("uri");
pluginName = (String) featureIdMap.get("pluginName");
} else {
uri = featureId.toString();
}
GrailsClass controllerClass = uriToControllerClassCache.get(uri);
if (controllerClass == null) {
final ApplicationContext mainContext = grailsApplication.getMainContext();
GrailsPluginManager grailsPluginManager = null;
if (mainContext.containsBean(GrailsPluginManager.BEAN_NAME)) {
final Object pluginManagerBean = mainContext.getBean(GrailsPluginManager.BEAN_NAME);
if (pluginManagerBean instanceof GrailsPluginManager) {
grailsPluginManager = (GrailsPluginManager) pluginManagerBean;
}
}
final GrailsClass[] controllerClasses = artefactInfo.getGrailsClasses();
// iterate in reverse in order to pick up application classes first
for (int i = (controllerClasses.length - 1); i >= 0; i--) {
GrailsClass c = controllerClasses[i];
if (((GrailsControllerClass) c).mapsToURI(uri)) {
boolean foundController = false;
if (pluginName != null && grailsPluginManager != null) {
final GrailsPlugin pluginForClass = grailsPluginManager.getPluginForClass(c.getClazz());
if (pluginForClass != null && pluginName.equals(pluginForClass.getName())) {
foundController = true;
}
} else {
foundController = true;
}
if (foundController) {
controllerClass = c;
break;
}
}
}
if (controllerClass == null) {
controllerClass = NO_CONTROLLER;
}
// don't cache for dev environment
if (Environment.getCurrent() != Environment.DEVELOPMENT) {
uriToControllerClassCache.put(uri, controllerClass);
}
}
if (controllerClass == NO_CONTROLLER) {
controllerClass = null;
}
return controllerClass;
}
