Java tutorial
/* * Copyright 2002-2018 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 * * https://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.springframework.web.context.support; import java.io.IOException; import groovy.lang.GroovyObject; import groovy.lang.GroovySystem; import groovy.lang.MetaClass; import org.springframework.beans.BeanWrapper; import org.springframework.beans.BeanWrapperImpl; import org.springframework.beans.BeansException; import org.springframework.beans.factory.NoSuchBeanDefinitionException; import org.springframework.beans.factory.groovy.GroovyBeanDefinitionReader; import org.springframework.beans.factory.support.DefaultListableBeanFactory; import org.springframework.lang.Nullable; /** * {@link org.springframework.web.context.WebApplicationContext} implementation which takes * its configuration from Groovy bean definition scripts and/or XML files, as understood by * a {@link org.springframework.beans.factory.groovy.GroovyBeanDefinitionReader}. * This is essentially the equivalent of * {@link org.springframework.context.support.GenericGroovyApplicationContext} * for a web environment. * * <p>By default, the configuration will be taken from "/WEB-INF/applicationContext.groovy" * for the root context, and "/WEB-INF/test-servlet.groovy" for a context with the namespace * "test-servlet" (like for a DispatcherServlet instance with the servlet-name "test"). * * <p>The config location defaults can be overridden via the "contextConfigLocation" * context-param of {@link org.springframework.web.context.ContextLoader} and servlet * init-param of {@link org.springframework.web.servlet.FrameworkServlet}. Config locations * can either denote concrete files like "/WEB-INF/context.groovy" or Ant-style patterns * like "/WEB-INF/*-context.groovy" (see {@link org.springframework.util.PathMatcher} * javadoc for pattern details). Note that ".xml" files will be parsed as XML content; * all other kinds of resources will be parsed as Groovy scripts. * * <p>Note: In case of multiple config locations, later bean definitions will * override ones defined in earlier loaded files. This can be leveraged to * deliberately override certain bean definitions via an extra Groovy script. * * <p><b>For a WebApplicationContext that reads in a different bean definition format, * create an analogous subclass of {@link AbstractRefreshableWebApplicationContext}.</b> * Such a context implementation can be specified as "contextClass" context-param * for ContextLoader or "contextClass" init-param for FrameworkServlet. * * @author Juergen Hoeller * @since 4.1 * @see #setNamespace * @see #setConfigLocations * @see org.springframework.beans.factory.groovy.GroovyBeanDefinitionReader * @see org.springframework.web.context.ContextLoader#initWebApplicationContext * @see org.springframework.web.servlet.FrameworkServlet#initWebApplicationContext */ public class GroovyWebApplicationContext extends AbstractRefreshableWebApplicationContext implements GroovyObject { /** Default config location for the root context. */ public static final String DEFAULT_CONFIG_LOCATION = "/WEB-INF/applicationContext.groovy"; /** Default prefix for building a config location for a namespace. */ public static final String DEFAULT_CONFIG_LOCATION_PREFIX = "/WEB-INF/"; /** Default suffix for building a config location for a namespace. */ public static final String DEFAULT_CONFIG_LOCATION_SUFFIX = ".groovy"; private final BeanWrapper contextWrapper = new BeanWrapperImpl(this); private MetaClass metaClass = GroovySystem.getMetaClassRegistry().getMetaClass(getClass()); /** * Loads the bean definitions via an GroovyBeanDefinitionReader. * @see org.springframework.beans.factory.groovy.GroovyBeanDefinitionReader * @see #initBeanDefinitionReader * @see #loadBeanDefinitions */ @Override protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException { // Create a new XmlBeanDefinitionReader for the given BeanFactory. GroovyBeanDefinitionReader beanDefinitionReader = new GroovyBeanDefinitionReader(beanFactory); // Configure the bean definition reader with this context's // resource loading environment. beanDefinitionReader.setEnvironment(getEnvironment()); beanDefinitionReader.setResourceLoader(this); // Allow a subclass to provide custom initialization of the reader, // then proceed with actually loading the bean definitions. initBeanDefinitionReader(beanDefinitionReader); loadBeanDefinitions(beanDefinitionReader); } /** * Initialize the bean definition reader used for loading the bean * definitions of this context. Default implementation is empty. * <p>Can be overridden in subclasses. * @param beanDefinitionReader the bean definition reader used by this context */ protected void initBeanDefinitionReader(GroovyBeanDefinitionReader beanDefinitionReader) { } /** * Load the bean definitions with the given GroovyBeanDefinitionReader. * <p>The lifecycle of the bean factory is handled by the refreshBeanFactory method; * therefore this method is just supposed to load and/or register bean definitions. * <p>Delegates to a ResourcePatternResolver for resolving location patterns * into Resource instances. * @throws IOException if the required Groovy script or XML file isn't found * @see #refreshBeanFactory * @see #getConfigLocations * @see #getResources * @see #getResourcePatternResolver */ protected void loadBeanDefinitions(GroovyBeanDefinitionReader reader) throws IOException { String[] configLocations = getConfigLocations(); if (configLocations != null) { for (String configLocation : configLocations) { reader.loadBeanDefinitions(configLocation); } } } /** * The default location for the root context is "/WEB-INF/applicationContext.groovy", * and "/WEB-INF/test-servlet.groovy" for a context with the namespace "test-servlet" * (like for a DispatcherServlet instance with the servlet-name "test"). */ @Override protected String[] getDefaultConfigLocations() { if (getNamespace() != null) { return new String[] { DEFAULT_CONFIG_LOCATION_PREFIX + getNamespace() + DEFAULT_CONFIG_LOCATION_SUFFIX }; } else { return new String[] { DEFAULT_CONFIG_LOCATION }; } } // Implementation of the GroovyObject interface public void setMetaClass(MetaClass metaClass) { this.metaClass = metaClass; } public MetaClass getMetaClass() { return this.metaClass; } public Object invokeMethod(String name, Object args) { return this.metaClass.invokeMethod(this, name, args); } public void setProperty(String property, Object newValue) { this.metaClass.setProperty(this, property, newValue); } @Nullable public Object getProperty(String property) { if (containsBean(property)) { return getBean(property); } else if (this.contextWrapper.isReadableProperty(property)) { return this.contextWrapper.getPropertyValue(property); } throw new NoSuchBeanDefinitionException(property); } }