从ContextLoaderListener谈Spring父子容器

<!-- Spring -->
<!-- 配置Spring配置文件路径 -->
<context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>
        classpath*:spring/spring-config-*.xml
        classpath:other.xml
    </param-value>
</context-param>
<!-- 配置Spring上下文监听器 -->
<listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>

<!-- Spring MVC 核心控制器 DispatcherServlet 配置 -->
<servlet>
    <servlet-name>dispatcher</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <init-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath*:spring/spring-mvc.xml</param-value>
    </init-param>
    <load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
    <servlet-name>dispatcher</servlet-name>
    <!--不拦截jsp-->
    <url-pattern>/*</url-pattern>
    <!-- 拦截所有/* 的请求,交给DispatcherServlet处理,性能最好 -->
    <!-- <url-pattern>/*</url-pattern> -->
</servlet-mapping>

public interface TestInterface {
}

//ApplicationOne.java
public class ApplicationOne {
    public ApplicationOne() {
        System.out.println("ApplicationOne.init");
    }

    public void test(){
        System.out.println("ApplicationOne.test");
    }
}

//ApplicationAopTimeHandler.java
public class ApplicationAopTimeHandler {
    public void printTimeBefore() {
        System.out.println("\nCurrentTime = " + System.currentTimeMillis());
    }

    public void printTimeAfter() {
        System.out.println("CurrentTime = " + System.currentTimeMillis() + "\n");
    }
}

//TestInterfaceOne.java
public class TestInterfaceOne implements TestInterface {
}

//applicationContextOne.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans-4.3.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop-4.3.xsd">

    <bean id="app1" class="ApplicationOne" />
    <bean id="timeHandler" class="ApplicationAopTimeHandler" />

    <bean id="interface1" class="TestInterfaceOne" />

    <aop:config>
        <aop:aspect id="time" ref="timeHandler">
            <aop:pointcut id="addAllMethod" expression="execution(* *.*(..))" />
            <aop:before method="printTimeBefore" pointcut-ref="addAllMethod" />
            <aop:after method="printTimeAfter" pointcut-ref="addAllMethod" />
        </aop:aspect>
    </aop:config>
</beans>

//ApplicationTwo.java
public class ApplicationTwo {
    public ApplicationTwo() {
        System.out.println("ApplicationTwo.init");
    }

    public void test(){
        System.out.println("ApplicationTwo.test");
    }
}

//TestInterfaceTwo.java
public class TestInterfaceTwo implements TestInterface {
}

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans-4.3.xsd">

    <bean id="app2" class="ApplicationTwo" />
    
    <bean id="interface2" class="TestInterfaceTwo" />
</beans>

//ApplicationContextTest.java
public class ApplicationContextTest {
    public static void main(String[] args) {
        ApplicationContext ctx1 =
                new ClassPathXmlApplicationContext("applicationContextOne.xml");

        System.out.println("创建上下文1完成\n");

        String[] names = ctx1.getBeanNamesForType(TestInterface.class);
        System.out.println("类型实例数"+names.length);
        System.out.println("名称"+names[0]+"\n");


        ApplicationContext ctx2 = new ClassPathXmlApplicationContext(new String[]{"applicationContextTwo.xml"}, ctx1);

        System.out.println("创建上下文2完成\n");

        System.out.println("测试拦截器效果\n");
        ApplicationOne app1 = (ApplicationOne) ctx1.getBean("app1");
        app1.test();

        ApplicationTwo app2 = (ApplicationTwo) ctx2.getBean("app2");
        app2.test();



        names = ctx2.getBeanNamesForType(TestInterface.class);
        System.out.println("类型实例数"+names.length);
        System.out.println("名称"+names[0]);

    }
}

ApplicationOne.init
创建上下文1完成

类型实例数1
名称interface1

ApplicationTwo.init
创建上下文2完成

测试拦截器效果


CurrentTime = 1522921095986
ApplicationOne.test
CurrentTime = 1522921096200

ApplicationTwo.test
类型实例数1
名称interface2

In your case, no, there's no reason to keep the ContextLoaderListener and applicationContext.xml. If your app works fine with just the servlet's context, that stick with that, it's simpler.

Yes, the generally-encouraged pattern is to keep non-web stuff in the webapp-level context, but it's nothing more than a weak convention.

The only compelling reasons to use the webapp-level context are:

If you have multiple DispatcherServlet that need to share services
If you have legacy/non-Spring servlets that need access to Spring-wired services
If you have servlet filters that hook into the webapp-level context (e.g. Spring Security's DelegatingFilterProxy, OpenEntityManagerInViewFilter, etc)

None of these apply to you, so the extra complexity is unwarranted.

Just be careful when adding background tasks to the servlet's context, like scheduled tasks, JMS connections, etc. If you forget to add <load-on-startup> to your web.xml, then these tasks won't be started until the first access of the servlet.