/*** Simple extension of {@link javax.servlet.http.HttpServlet} which treats* its config parameters ({@code init-param} entries within the* {@code servlet} tag in {@code web.xml}) as bean properties.** <p>A handy superclass for any type of servlet. Type conversion of config* parameters is automatic, with the corresponding setter method getting* invoked with the converted value. It is also possible for subclasses to* specify required properties. Parameters without matching bean property* setter will simply be ignored.** <p>This servlet leaves request handling to subclasses, inheriting the default* behavior of HttpServlet ({@code doGet}, {@code doPost}, etc).** <p>This generic servlet base class has no dependency on the Spring* {@link org.springframework.context.ApplicationContext} concept. Simple* servlets usually don't load their own context but rather access service* beans from the Spring root application context, accessible via the* filter's {@link #getServletContext() ServletContext} (see* {@link org.springframework.web.context.support.WebApplicationContextUtils}).** <p>The {@link FrameworkServlet} class is a more specific servlet base* class which loads its own application context. FrameworkServlet serves* as direct base class of Spring's full-fledged {@link DispatcherServlet}.*/

    <!-- This servlet must be loaded first to configure the log4jsystem and create the WebApplicationContext--><servlet><servlet-name>config</servlet-name><servlet-class>org.springframework.framework.web.context.ContextLoaderServlet</servlet-class><init-param><param-name>contextClass</param-name><param-value>org.springframework.framework.web.context.XMLWebApplicationContext</param-value>           </init-param>    <init-param><param-name>log4jPropertiesUrl</param-name><param-value>/WEB-INF/log4j_PRODUCTION.properties</param-value>           </init-param>    <!-- This is essential --><load-on-startup>1</load-on-startup></servlet>

/*** Marker superinterface indicating that a bean is eligible to be* notified by the Spring container of a particular framework object* through a callback-style method. Actual method signature is* determined by individual subinterfaces, but should typically* consist of just one void-returning method that accepts a single* argument.** <p>Note that merely implementing {@link Aware} provides no default* functionality. Rather, processing must be done explicitly, for example* in a {@link org.springframework.beans.factory.config.BeanPostProcessor BeanPostProcessor}.* Refer to {@link org.springframework.context.support.ApplicationContextAwareProcessor}* and {@link org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory}* for examples of processing {@code *Aware} interface callbacks.** @author Chris Beams* @since 3.1*/
public interface Aware {}

public interface BeanNameAware extends Aware {void setBeanName(String name);
}
public interface BeanFactoryAware extends Aware {void setBeanFactory(BeanFactory beanFactory) throws BeansException;
}
public interface BeanClassLoaderAware extends Aware {void setBeanClassLoader(ClassLoader classLoader);
}

/*** Interface to be implemented by any bean that wishes to be notified* of the {@link Environment} that it runs in.** @author Chris Beams* @since 3.1*/
public interface EnvironmentAware extends Aware {/*** Set the {@code Environment} that this object runs in.*/void setEnvironment(Environment environment);}

    /*** {@inheritDoc}* @throws IllegalArgumentException if environment is not assignable to* {@code ConfigurableEnvironment}.*/@Overridepublic void setEnvironment(Environment environment) {Assert.isInstanceOf(ConfigurableEnvironment.class, environment);this.environment = (ConfigurableEnvironment) environment;}/*** {@inheritDoc}* <p>If {@code null}, a new environment will be initialized via* {@link #createEnvironment()}.*/@Overridepublic ConfigurableEnvironment getEnvironment() {if (this.environment == null) {this.environment = this.createEnvironment();}return this.environment;}/*** Create and return a new {@link StandardServletEnvironment}. Subclasses may override* in order to configure the environment or specialize the environment type returned.*/protected ConfigurableEnvironment createEnvironment() {return new StandardServletEnvironment();}

/*** Interface indicating a component that contains and exposes an {@link Environment} reference.** <p>All Spring application contexts are EnvironmentCapable, and the interface is used primarily* for performing {@code instanceof} checks in framework methods that accept BeanFactory* instances that may or may not actually be ApplicationContext instances in order to interact* with the environment if indeed it is available.** <p>As mentioned, {@link org.springframework.context.ApplicationContext ApplicationContext}* extends EnvironmentCapable, and thus exposes a {@link #getEnvironment()} method; however,* {@link org.springframework.context.ConfigurableApplicationContext ConfigurableApplicationContext}* redefines {@link org.springframework.context.ConfigurableApplicationContext#getEnvironment* getEnvironment()} and narrows the signature to return a {@link ConfigurableEnvironment}.* The effect is that an Environment object is 'read-only' until it is being accessed from* a ConfigurableApplicationContext, at which point it too may be configured.** @author Chris Beams* @since 3.1* @see Environment* @see ConfigurableEnvironment* @see org.springframework.context.ConfigurableApplicationContext#getEnvironment()*/
public interface EnvironmentCapable {/*** Return the {@link Environment} associated with this component.*/Environment getEnvironment();}

public class StandardEnvironment extends AbstractEnvironment {/** System environment property source name: {@value} */public static final String SYSTEM_ENVIRONMENT_PROPERTY_SOURCE_NAME = "systemEnvironment";/** JVM system properties property source name: {@value} */public static final String SYSTEM_PROPERTIES_PROPERTY_SOURCE_NAME = "systemProperties";@Overrideprotected void customizePropertySources(MutablePropertySources propertySources) {propertySources.addLast(new MapPropertySource(SYSTEM_PROPERTIES_PROPERTY_SOURCE_NAME, getSystemProperties())); //System.getProperties();propertySources.addLast(new SystemEnvironmentPropertySource(SYSTEM_ENVIRONMENT_PROPERTY_SOURCE_NAME, getSystemEnvironment()));//System.getenv()}}

public class StandardServletEnvironment extends StandardEnvironment implements ConfigurableWebEnvironment {/** Servlet context init parameters property source name: {@value} */public static final String SERVLET_CONTEXT_PROPERTY_SOURCE_NAME = "servletContextInitParams";/** Servlet config init parameters property source name: {@value} */public static final String SERVLET_CONFIG_PROPERTY_SOURCE_NAME = "servletConfigInitParams";/** JNDI property source name: {@value} */public static final String JNDI_PROPERTY_SOURCE_NAME = "jndiProperties";@Overrideprotected void customizePropertySources(MutablePropertySources propertySources) {propertySources.addLast(new StubPropertySource(SERVLET_CONFIG_PROPERTY_SOURCE_NAME));propertySources.addLast(new StubPropertySource(SERVLET_CONTEXT_PROPERTY_SOURCE_NAME));if (JndiLocatorDelegate.isDefaultJndiEnvironmentAvailable()) {propertySources.addLast(new JndiPropertySource(JNDI_PROPERTY_SOURCE_NAME));}super.customizePropertySources(propertySources);}@Overridepublic void initPropertySources(ServletContext servletContext, ServletConfig servletConfig) {WebApplicationContextUtils.initServletPropertySources(getPropertySources(), servletContext, servletConfig);}}