監聽器如何獲取Spring配置文件（加載生成Spring容器）

 Spring容器是生成Bean的工廠，我們在做項目的時候，會用到監聽器去獲取spring的配置文件，然后從中拿出我們需要的bean出來，比如做網站首頁，假設商品的后台業務邏輯都做好了，我們需要創建一個監聽器，在項目啟動時將首頁的數據查詢出來放到application里，即在監聽器里調用后台商品業務邏輯的方法，也就是說我們需要在監聽器里獲取Spring中配置的相應的bean。先把監聽器創建出來：

1. 創建InitDataListener

        創建一個監聽器InitDataListener繼承ServletContextListener：

//@Component //監聽器是web層的組件，它是tomcat實例化的，不是Spring實例化的。不能放到Spring中  
public class InitDataListener implements ServletContextListener {  
      
    private ProductService productService = null;//productService中定義了跟商品相關的業務邏輯  
      
    @Override  
    public void contextDestroyed(ServletContextEvent event) {  
  
    }  
  
    @Override  
    public void contextInitialized(ServletContextEvent event) {  
  
    }  
  
}  

並在web.xml中配置該監聽器：

  如上，productService中定義了商品的一些業務邏輯，並且這個productService是交給Spring管理的，那么我們如何得到這個對象呢？首先肯定的一點是：我們不能自己new出來，因為new出來的話就跟Spring的IoC沒有關系了……主要有三種方式可以實現，我們先一個個分析，最后比較優劣。

2. 直接加載beans.xml文件

        這種方式比較簡單粗暴，不是要加載配置文件么？那好，我加載就是了，如下：

//@Component //監聽器是web層的組件，它是tomcat實例化的，不是Spring實例化的。不能放到Spring中  
public class InitDataListener implements ServletContextListener {  
  
      
    private ProductService productService = null; //productService中定義了跟商品相關的業務邏輯  
      
    @Override  
    public void contextDestroyed(ServletContextEvent event) {  
  
    }  
  
    @Override  
    public void contextInitialized(ServletContextEvent event) {  
        // 獲取業務邏輯類productService查詢商品信息        
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");  
        productService = (ProductService) context.getBean("productService");  
        System.out.println(productService); //輸出看看拿到了沒有       
  
                //下面是具體productService相關操作……  
    }  
  
}  

  這種方法完全沒問題，思路很清晰，先加載配置文件beans.xml，然后獲取bean，但是啟動tomcat后，我們看看控制台輸出的信息：

  到這里應該發現這種方式的弊端了，加載了兩次配置文件，也就是說那些bean被實例化了兩次，從打印的信息來看，是拿到我們自己加載配置文件是實例化的bean。這種方式明顯不可取。

3. 從ServletContext中獲取

        從上面的方法中，我們最起碼可以知道，Spring通過自己的監聽器已經加載過一次配置文件了，我們沒必要再加載一次，那么很容易想到，如果知道Spring加載后放到哪里了，那我們就可以從那地方獲取該配置文件，下面我們看下Spring加載配置文件的過程：

        上圖中(省略了無關的代碼)，ContextLoaderListener就是web.xml中我們配置的Spring監聽器，它也實現了ServletContextListener並繼承了ContextLoader。在監聽器中主要通過initWebApplicationContext方法來獲取配置文件，並創建WebApplicationContext對象，在initWebApplicationContext方法里主要做兩件事：一是拿到Spring的上下文，二是把Spring上下文放到ServletContext中，並且鍵為：WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE。那么如何拿到Spring的上下文呢？是通過獲取web.xml中配置的Spring的路徑，CONFIG_LOCATION_PARM其實是個字符串常量，就是上面web.xml中配置Spring監聽器下面的：

<context-param>  
<param-name>contextConfigLocation</param-name> <!--CONFIG_LOCATION_PARM就是contextConfigLocation-->  
<param-value>classpath:beans.xml</param-value>  
</context-param> 

　　   所以就很明顯了，通過web.xml中配置的路徑拿到beans.xml，然后加載這個配置文件，實例化bean。

        現在我們既然知道了Spring在加載配置文件后，把它放在了ServletContext中，那么我們就可以去這里面直接拿！

//@Component //監聽器是web層的組件，它是tomcat實例化的，不是Spring實例化的。不能放到Spring中  
public class InitDataListener implements ServletContextListener {  
  
      
    private ProductService productService = null;  
      
    @Override  
    public void contextDestroyed(ServletContextEvent event) {  
        // TODO Auto-generated method stub  
  
    }  
  
    @Override  
    public void contextInitialized(ServletContextEvent event) {  
        //  獲取業務邏輯類查詢商品信息  
          
        // 解決方案二，項目在啟動時，把Spring配置文件通過Spring的監聽器加載，存儲到ServletContext中，我們只要在ServletContext中獲取即可。  
        ApplicationContext context = (ApplicationContext) event.getServletContext()  
                                             .getAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE);  
        productService = (ProductService) context.getBean("productService");  
        System.out.println(productService);       
    }  
  
}  

    這樣我們就可以拿到produceService的實例化對象了，這種方法好是好，就是getAttribute中的參數太長，也不知道當時程序員的腦門子被夾了還是咋地，估計是想不到其他更合適的名字了吧~

 

4. 通過Spring提供的工具類加載

        也許開發Spring的大牛們也意識到了這個參數名字太長了，於是他們提供了一個方法類，可以加載配置文件：

public class InitDataListener implements ServletContextListener {  
  
      
    private ProductService productService = null;  
      
    @Override  
    public void contextDestroyed(ServletContextEvent event) {  
        // TODO Auto-generated method stub  
  
    }  
  
    @Override  
    public void contextInitialized(ServletContextEvent event) {  
        // 獲取業務邏輯類查詢商品信息  
  
        WebApplicationContext context = WebApplicationContextUtils.getWebApplicationContext(event.getServletContext());  
        productService = (ProductService) context.getBean("productService");  
        System.out.println(productService);  
    }  
  
} 

 其實，這里的getWebApplicationContext方法就是把上面的那個方法封裝了一下而已，我們看看這個方法的源碼就知道了：

public static WebApplicationContext getWebApplicationContext(ServletContext sc) {  
        return getWebApplicationContext(sc, WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE);  
    } 

這樣更加方便程序員調用，僅此而已……所以一般我們使用第三種方法來獲取Spring的配置文件，從而獲取相應的實例化bean。

參考文章：http://blog.csdn.net/eson_15/article/details/51373937

----更多文章請看：http://blog.csdn.net/eson_15

代碼實踐：

Spring整合web項目時的問題：
啟動服務器之后：
訪問action時，每次訪問都會重新加載spring配置文件，效率低下

解決方法：在服務器啟動的時候，利用監聽器只加載一次spring配置文件即可。

在spring里邊不需要自己寫代碼實現，框架已經做好了封裝
只需要配置即可：但是配置監聽器時，需要導入一個spring整合web項目的jar包

 

創建一個web項目，要求每次訪問action都無需加載新的xml文件，利用框架的監聽器實現只在服務器啟動時加載一次xml配置，用於提高性能

開發准備，導入struts相關jar和spring框架IOC相關jar以及spring整合web項目的jar包

第一種自己完成監聽器的代碼(不推薦，純屬娛樂)

package org.lister;

import javax.servlet.ServletContext;
import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Lis implements ServletContextListener {

    public void contextDestroyed(ServletContextEvent arg0) {
        // TODO Auto-generated method stub

    }
    public void contextInitialized(ServletContextEvent arg0) {
        // TODO Auto-generated method stub
        //服務器啟動的時候創建ApplicationContext對象
        ApplicationContext ac=new ClassPathXmlApplicationContext("applicationContext.xml");
        
        //得到ServletContext對象
        ServletContext sc=arg0.getServletContext();
        
        //保存創建的ApplicationContext對象,在action中調用
        sc.setAttribute("applicationcontext",ac);
    }
}

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.5" 
    xmlns="http://java.sun.com/xml/ns/javaee" 
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
    xsi:schemaLocation="http://java.sun.com/xml/ns/javaee 
    http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">
  <welcome-file-list>
    <welcome-file>index.jsp</welcome-file>
  </welcome-file-list>
  
  <!-- struts過濾器配置 -->
    <filter>
     <filter-name>struts2</filter-name>
     <filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>      
     <init-param>
          <param-name>actionPackages</param-name>
          <param-value>com.mycompany.myapp.actions</param-value>
     </init-param>    
  </filter>
  
  <filter-mapping>
      <filter-name>struts2</filter-name>
       <url-pattern>/*</url-pattern>
  </filter-mapping>
  
  <!-- 自己的監聽器配置 -->
27   <listener>
28       <listener-class>org.lister.Lis</listener-class>
29   </listener>
  
</web-app>

package org.model;

public class User {
    public void add(){
        System.out.println("add。。。。。。。。。。。。");
    }
}

package org.action;

import java.util.Map;

import javax.servlet.ServletContext;
import org.apache.struts2.ServletActionContext;
import org.model.User;
import org.springframework.context.ApplicationContext;

import com.opensymphony.xwork2.ActionContext;
import com.opensymphony.xwork2.ActionSupport;

public class UserAction extends ActionSupport {
    
    @Override
    public String execute() throws Exception {
        System.out.println("進入action");
//        ApplicationContext ac=new ClassPathXmlApplicationContext("applicationContext.xml");
//        User user=(User)ac.getBean("user");
//        user.add();
        
        //得到ServletContext(上下文對象，即application對象)對象 並且得到里邊保存的applicationContext對象；
        ServletContext servletContext = ServletActionContext.getServletContext(); 
        ApplicationContext ac=(ApplicationContext) servletContext.getAttribute("applicationcontext");
        if(ac!=null){
            User u=(User) ac.getBean("user");
            u.add();
        }
        
        /*
         //以下代碼也能實現
        ActionContext actioncontext=ActionContext.getContext();
        Map application=actioncontext.getApplication();
        ApplicationContext ac2=(ApplicationContext) application.get("applicationcontext");
        if(ac2!=null){
            User u2=(User) ac2.getBean("user");
            u2.add();
        }
        */    
        return NONE;
    }
}

<?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:p="http://www.springframework.org/schema/p"
    xmlns:aop="http://www.springframework.org/schema/aop" xsi:schemaLocation="
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
        <bean id="user" class="org.model.User"></bean>
</beans>

 在上邊的程序中沒有配置spring框架的監聽器，只配置了自己定義的，所以也實現了題目要求的功能：

服務器啟動的時候加載了配置文件：

然后訪問action截圖如下：

即使反復請求，只會輸出以上兩句，控制台並沒有打印其他內容，說明xml文件只加載了一次。

 

第二種：使用框架提供的監聽機制，我們只需要配置即可，不多說 直接上代碼

 

package org.dao;

public class UserDao {
    public void add(){
        System.out.println("UserDao.........");
    }
}

 

package org.service;

import org.dao.UserDao;

public class Service {
    private UserDao userdao;
    
    public void setUserdao(UserDao userdao) {//使用set注入
        this.userdao = userdao;
    }
    
    public void add(){
        System.out.println("Service.........");
        userdao.add();
    }
}

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.5" 
    xmlns="http://java.sun.com/xml/ns/javaee" 
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
    xsi:schemaLocation="http://java.sun.com/xml/ns/javaee 
    http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">
  <welcome-file-list>
    <welcome-file>index.jsp</welcome-file>
  </welcome-file-list>
        <filter>
      <filter-name>struts2</filter-name>
      <filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>      
      <init-param>
          <param-name>actionPackages</param-name>
          <param-value>com.mycompany.myapp.actions</param-value>
      </init-param>    
      </filter>
  <filter-mapping>
      <filter-name>struts2</filter-name>
      <url-pattern>/*</url-pattern>
  </filter-mapping>
  
  
24   <!-- 使用框架提供的監聽機制  需要配置下面代碼 -->
25   <listener>
26       <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
27   </listener>
28   
29   <context-param>
30       <param-name>contextConfigLocation</param-name>
31       <param-value>classpath:applicationContext.xml</param-value>
32   </context-param>
</web-app>

<?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:p="http://www.springframework.org/schema/p"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
    http://www.springframework.org/schema/aop 
    http://www.springframework.org/schema/aop/spring-aop-3.0.xsd">
    <bean id="ud" class="org.dao.UserDao"></bean>
    
    <bean id="us" class="org.service.Service">
        <property name="userdao" ref="ud"></property>
    </bean>
    
</beans>
    

package org.action;

import java.util.Map;

import javax.servlet.ServletContext;

import org.apache.struts2.ServletActionContext;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.web.context.WebApplicationContext;
import org.springframework.web.context.support.WebApplicationContextUtils;

import com.opensymphony.xwork2.ActionSupport;

import org.service.*;
public class UserAction extends ActionSupport {
    
    @Override
    public String execute() throws Exception {
        //ApplicationContext ac=new ClassPathXmlApplicationContext("applicationContext.xml");
        
        //得到servletContext對象(上下文application對象)
        ServletContext sc=ServletActionContext.getServletContext();    
        
        //從上下文對象中取得在服務器啟動時創建的ApplicationContext對象
        //因為在服務器啟動的時候就創建了一個applicationContext對象 並且保存在了ServletContext中(上下文application中)，
        //並且鍵為：WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE
        ApplicationContext ac=(ApplicationContext)sc.getAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE);
        if(ac!=null){
        Service s=(Service)ac.getBean("us");
        s.add();
        }else{
            System.out.println("沒有取得ApplicationContext對象");
        }
        /*
        WebApplicationContext context = WebApplicationContextUtils.getWebApplicationContext(ServletActionContext.getServletContext());  
        if(ac!=null){
        Service s=(Service)context.getBean("us");
        s.add(); 
        }else{
        System.out.println("沒有取得ApplicationContext對象");
        }
         */
        return NONE;//不做任何的返回
    }
}

啟動服務器：

 

 反復訪問action:

效果和上面的一樣，沒有反復加載xml生成Spring容器

-------------------------------

歡迎大家轉載，但請注明原創鏈接：http://www.cnblogs.com/Joke-Jay/p/6507171.html