Merge pull request #62 from poutsma/SPR-9300

* SPR-9300:
  Add convenient WebAppInitializer base classes

Author: cbeams

spring-web/src/main/java/org/springframework/web/WebApplicationInitializer.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2011 the original author or authors.
+ * Copyright 2002-2012 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.
@@ -72,6 +72,9 @@
  *
  * }</pre>
  *
+ * As an alternative to the above, you can also extend from {@link
+ * org.springframework.web.servlet.support.AbstractDispatcherServletInitializer}.
+ *
  * As you can see, thanks to Servlet 3.0's new {@link ServletContext#addServlet} method
  * we're actually registering an <em>instance</em> of the {@code DispatcherServlet}, and
  * this means that the {@code DispatcherServlet} can now be treated like any other object
@@ -82,7 +85,7 @@
  * are free to create and work with your Spring application contexts as necessary before
  * injecting them into the {@code DispatcherServlet}.
  *
- * <p>Most major Spring Web componentry has been updated to support this style of
+ * <p>Most major Spring Web components have been updated to support this style of
  * registration.  You'll find that {@code DispatcherServlet}, {@code FrameworkServlet},
  * {@code ContextLoaderListener} and {@code DelegatingFilterProxy} all now support
  * constructor arguments. Even if a component (e.g. non-Spring, other third party) has not
@@ -131,6 +134,9 @@
  *
  * }</pre>
  *
+ * As an alternative to the above, you can also extend from {@link
+ * org.springframework.web.servlet.support.AbstractAnnotationConfigDispatcherServletInitializer}.
+ *
  * Remember that {@code WebApplicationInitializer} implementations are <em>detected
  * automatically</em> -- so you are free to package them within your application as you
  * see fit.
@@ -165,6 +171,9 @@
  * @author Chris Beams
  * @since 3.1
  * @see SpringServletContainerInitializer
+ * @see org.springframework.web.context.AbstractContextLoaderInitializer
+ * @see org.springframework.web.servlet.support.AbstractDispatcherServletInitializer
+ * @see org.springframework.web.servlet.support.AbstractAnnotationConfigDispatcherServletInitializer
  */
 public interface WebApplicationInitializer {
 

spring-web/src/main/java/org/springframework/web/context/AbstractContextLoaderInitializer.java

@@ -0,0 +1,78 @@
+/*
+ * Copyright 2002-2012 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.springframework.web.context;
+
+import javax.servlet.ServletContext;
+import javax.servlet.ServletException;
+
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+
+import org.springframework.web.WebApplicationInitializer;
+
+/**
+ * Convenient base class for {@link WebApplicationInitializer} implementations that
+ * register a {@link ContextLoaderListener} in the servlet context.
+ *
+ * <p>The only method required to be implemented by subclasses is {@link
+ * #createRootApplicationContext()}, which gets invoked from {@link
+ * #registerContextLoaderListener(javax.servlet.ServletContext)}.
+ *
+ * @author Arjen Poutsma
+ * @author Chris Beams
+ * @since 3.2
+ */
+public abstract class AbstractContextLoaderInitializer implements WebApplicationInitializer {
+
+	/** Logger available to subclasses. */
+	protected final Log logger = LogFactory.getLog(getClass());
+
+	public void onStartup(ServletContext servletContext) throws ServletException {
+		this.registerContextLoaderListener(servletContext);
+	}
+
+	/**
+	 * Register a {@link ContextLoaderListener} against the given servlet context. The
+	 * {@code ContextLoaderListener} is initialized with the application context returned
+	 * from the {@link #createRootApplicationContext()} template method.
+	 * @param servletContext the servlet context to register the listener against
+	 */
+	protected void registerContextLoaderListener(ServletContext servletContext) {
+		WebApplicationContext rootAppContext = this.createRootApplicationContext();
+		if (rootAppContext != null) {
+			servletContext.addListener(new ContextLoaderListener(rootAppContext));
+		}
+		else {
+			logger.debug("No ContextLoaderListener registered, as " +
+					"createRootApplicationContext() did not return an application context");
+		}
+	}
+
+	/**
+	 * Create the "root" application context to be provided to the
+	 * {@code ContextLoaderListener}.
+	 * <p>The returned context is delegated to
+	 * {@link ContextLoaderListener#ContextLoaderListener(WebApplicationContext)} and will
+	 * be established as the parent context for any {@code DispatcherServlet} application
+	 * contexts. As such, it typically contains middle-tier services, data sources, etc.
+	 * @return the root application context, or {@code null} if a root context is not
+	 * desired
+	 * @see org.springframework.web.servlet.support.AbstractDispatcherServletInitializer
+	 */
+	protected abstract WebApplicationContext createRootApplicationContext();
+
+}

spring-web/src/test/java/org/springframework/web/context/ContextLoaderInitializerTests.java

@@ -0,0 +1,93 @@
+/*
+ * Copyright 2002-2012 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.springframework.web.context;
+
+import java.util.EventListener;
+
+import javax.servlet.ServletContextEvent;
+import javax.servlet.ServletException;
+
+import org.junit.Before;
+import org.junit.Test;
+
+import org.springframework.mock.web.MockServletContext;
+import org.springframework.web.context.support.StaticWebApplicationContext;
+import org.springframework.web.context.support.WebApplicationContextUtils;
+
+import static org.junit.Assert.*;
+
+/**
+ * Test case for {@link AbstractContextLoaderInitializer}.
+ *
+ * @author Arjen Poutsma
+ */
+public class ContextLoaderInitializerTests {
+
+	private static final String BEAN_NAME = "myBean";
+
+	private AbstractContextLoaderInitializer initializer;
+
+	private MockServletContext servletContext;
+
+	private EventListener eventListener;
+
+	@Before
+	public void setUp() throws Exception {
+		servletContext = new MyMockServletContext();
+		initializer = new MyContextLoaderInitializer();
+		eventListener = null;
+	}
+
+	@Test
+	public void register() throws ServletException {
+		initializer.onStartup(servletContext);
+
+		assertTrue(eventListener instanceof ContextLoaderListener);
+		ContextLoaderListener cll = (ContextLoaderListener) eventListener;
+		cll.contextInitialized(new ServletContextEvent(servletContext));
+
+		WebApplicationContext applicationContext = WebApplicationContextUtils
+				.getRequiredWebApplicationContext(servletContext);
+
+		assertTrue(applicationContext.containsBean(BEAN_NAME));
+		assertTrue(applicationContext.getBean(BEAN_NAME) instanceof MyBean);
+	}
+
+	private class MyMockServletContext extends MockServletContext {
+
+		@Override
+		public <T extends EventListener> void addListener(T listener) {
+			eventListener = listener;
+		}
+
+	}
+
+	private static class MyContextLoaderInitializer
+			extends AbstractContextLoaderInitializer {
+
+		@Override
+		protected WebApplicationContext createRootApplicationContext() {
+			StaticWebApplicationContext rootContext = new StaticWebApplicationContext();
+			rootContext.registerSingleton(BEAN_NAME, MyBean.class);
+			return rootContext;
+		}
+	}
+
+	private static class MyBean {
+
+	}
+}

spring-webmvc/src/main/java/org/springframework/web/servlet/support/AbstractAnnotationConfigDispatcherServletInitializer.java

@@ -0,0 +1,101 @@
+/*
+ * Copyright 2002-2012 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.springframework.web.servlet.support;
+
+import org.springframework.util.Assert;
+import org.springframework.util.ObjectUtils;
+import org.springframework.web.context.WebApplicationContext;
+import org.springframework.web.context.support.AnnotationConfigWebApplicationContext;
+
+/**
+ * Base class for {@link org.springframework.web.WebApplicationInitializer
+ * WebApplicationInitializer} implementations that register a {@link
+ * org.springframework.web.servlet.DispatcherServlet DispatcherServlet}
+ * configured with annotated classes, e.g. Spring's {@link
+ * org.springframework.context.annotation.Configuration @Configuration} classes.
+ *
+ * <p>Concrete implementations are required to implement {@link #getRootConfigClasses()},
+ * {@link #getServletConfigClasses()}, as well as {@link #getServletMappings()}. Further
+ * template and customization methods are provided by {@link
+ * AbstractDispatcherServletInitializer}.
+ *
+ * @author Arjen Poutsma
+ * @author Chris Beams
+ * @since 3.2
+ */
+public abstract class AbstractAnnotationConfigDispatcherServletInitializer
+		extends AbstractDispatcherServletInitializer {
+
+	/**
+	 * {@inheritDoc}
+	 * <p>This implementation creates an {@link AnnotationConfigWebApplicationContext},
+	 * providing it the annotated classes returned by {@link #getRootConfigClasses()}.
+	 * Returns {@code null} if {@link #getRootConfigClasses()} returns {@code null}.
+	 */
+	@Override
+	protected WebApplicationContext createRootApplicationContext() {
+		Class<?>[] rootConfigClasses = this.getRootConfigClasses();
+		if (!ObjectUtils.isEmpty(rootConfigClasses)) {
+			AnnotationConfigWebApplicationContext rootAppContext =
+					new AnnotationConfigWebApplicationContext();
+			rootAppContext.register(rootConfigClasses);
+			return rootAppContext;
+		}
+		else {
+			return null;
+		}
+	}
+
+	/**
+	 * {@inheritDoc}
+	 * <p>This implementation creates an {@link AnnotationConfigWebApplicationContext},
+	 * providing it the annotated classes returned by {@link #getServletConfigClasses()}.
+	 * @throws IllegalArgumentException if {@link #getServletConfigClasses()} returns
+	 * empty or {@code null}
+	 */
+	@Override
+	protected WebApplicationContext createServletApplicationContext() {
+		AnnotationConfigWebApplicationContext servletAppContext =
+				new AnnotationConfigWebApplicationContext();
+		Class<?>[] servletConfigClasses = this.getServletConfigClasses();
+		Assert.notEmpty(servletConfigClasses,
+				"getServletConfigClasses() did not return any configuration classes");
+
+		servletAppContext.register(servletConfigClasses);
+		return servletAppContext;
+	}
+
+	/**
+	 * Specify {@link org.springframework.context.annotation.Configuration @Configuration}
+	 * and/or {@link org.springframework.stereotype.Component @Component} classes to be
+	 * provided to the {@linkplain #createRootApplicationContext() root application context}.
+	 * @return the configuration classes for the root application context, or {@code null}
+	 * if creation and registration of a root context is not desired
+	 */
+	protected abstract Class<?>[] getRootConfigClasses();
+
+	/**
+	 * Specify {@link org.springframework.context.annotation.Configuration @Configuration}
+	 * and/or {@link org.springframework.stereotype.Component @Component} classes to be
+	 * provided to the {@linkplain #createServletApplicationContext() dispatcher servlet
+	 * application context}.
+	 * @return the configuration classes for the dispatcher servlet application context
+	 * (may not be empty or {@code null}).
+	 */
+	protected abstract Class<?>[] getServletConfigClasses();
+
+}