BeanFactory和ApplicationContext

来源：互联网发布：水弹的数据编辑：程序博客网时间：2024/05/16 09:48

BeanFactory 和 ApplicationContext介绍：

Spring通过一个配置文件瞄上了Bean及Bean之间的依赖关系，利用java语言的反射功能实例化Bean并建立Bean之间的依赖关系。

Bean工厂（com.springframework.beans.factory.Beanfactory）是Spring框架最核心的接口，它提供了高级Ioc的配置机制。

BeanFactory为IOC容器，而称ApplicationContext为应用上下文。ApplicationContext是建立在BeanFactory基础之上的。

对于BeanFactroy和ApplicationContext用途的简单划分：

BeanFactroy是Spring框架的基础设施，面向Spring本身。、

ApplicationContext面向使用Spring框架的开发者，几乎所有的应用场合都直接使用ApplicationContext而非底层的BeanFactory.

BeanFactory介绍

BeanFactory是类的通用工厂,它可以创建并管理各种类对象。

初始化BeanFactory

第一步，首先在pom.xml中添加Spirng包的依赖

<dependencies>
   
       <dependency>
           <groupId>junit</groupId>
           <artifactId>junit</artifactId>
           <version>4.10</version>
           <scope>test</scope>
       </dependency>
   
    <dependency>
           <groupId>org.springframework</groupId>
           <artifactId>spring-core</artifactId>
           <version>3.1.2.RELEASE</version>
       </dependency>
       <dependency>
           <groupId>org.springframework</groupId>
           <artifactId>spring-context</artifactId>
           <version>3.1.2.RELEASE</version>
       </dependency>
       <dependency>
           <groupId>org.springframework</groupId>
           <artifactId>spring-jdbc</artifactId>
           <version>3.1.2.RELEASE</version>
       </dependency>
       <dependency>
           <groupId>org.springframework</groupId>
           <artifactId>spring-beans</artifactId>
           <version>3.1.2.RELEASE</version>
       </dependency>
       <dependency>
           <groupId>org.springframework</groupId>
           <artifactId>spring-web</artifactId>
           <version>3.1.2.RELEASE</version>
       </dependency>
       <dependency>
           <groupId>org.springframework</groupId>
           <artifactId>spring-expression</artifactId>
           <version>3.1.2.RELEASE</version>
       </dependency>
       <dependency>
           <groupId>org.springframework</groupId>
           <artifactId>spring-orm</artifactId>
           <version>3.1.2.RELEASE</version>
       </dependency>
</dependencies>

第二步：建立Car类

package com.spring.test;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.BeanFactoryAware;
import org.springframework.beans.factory.BeanNameAware;
import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.InitializingBean;

public class Car implements BeanFactoryAware, BeanNameAware, InitializingBean,
       DisposableBean
{
   private String brand;
    private String color;
    private int maxSpeed;
    private String name;
    private BeanFactory beanFactory;
    private String beanName;

    /**
     * 无参数构造函数
     */
    public Car()
    {
       System.out.println("调用Car()构造函数。");
    }

   public String getBrand()
   {
       return brand;
   }

   public void setBrand(String brand)
   {
       System.out.println("调用setBrand()设置属性。");
         this.brand = brand;
   }

   public String getColor()
   {
       return color;
   }

   public void setColor(String color)
   {
       this.color = color;
   }

   public int getMaxSpeed()
   {
       return maxSpeed;
   }

   public void setMaxSpeed(int maxSpeed)
   {
       this.maxSpeed = maxSpeed;
   }

   public String getName()
   {
       return name;
   }

   public void setName(String name)
   {
       this.name = name;
   }

   public BeanFactory getBeanFactory()
   {
       return beanFactory;
   }

   public String getBeanName()
   {
       return beanName;
   }

   public String toString()
   {
        return "brand:" + brand + "/color:" + color + "/maxSpeed:" + maxSpeed;
    }

   public void introduce()
   {
        System.out.println("introduce:" + this.toString());
   }

   // DisposableBean接口方法
   @Override
   public void destroy() throws Exception
   {
       System.out.println("调用DisposableBean.destory()。");
   }

   // InitializingBean接口方法
   @Override
   public void afterPropertiesSet() throws Exception
   {
       System.out.println("调用InitializingBean.afterPropertiesSet()。");
   }

   // BeanNameAware接口方法
   @Override
   public void setBeanName(String arg0)
   {
       System.out.println("调用BeanNameAware.setBeanName()。");
        this.beanName = beanName;
   }

   // BeanFactoryAware接口方法
   @Override
   public void setBeanFactory(BeanFactory arg0) throws BeansException
   {
       System.out.println("调用BeanFactoryAware.setBeanFactory()。");
         this.beanFactory = beanFactory;
   }

   public void myInit()
   {
        System.out.println("调用myInit()，将maxSpeed设置为240。");
        this.maxSpeed = 240;
   }

   public void myDestory()
   {
        System.out.println("调用myDestroy()。");
   }
}

第三部：建立beans.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:context="http://www.springframework.org/schema/context"
   xsi:schemaLocation="http://www.springframework.org/schema/beans
         http://www.springframework.org/schema/beans/spring-beans-3.1.xsd
         http://www.springframework.org/schema/context
         http://www.springframework.org/schema/context/spring-context-3.1.xsd"
         >

       <bean id="car" class="com.spring.test.Car">
           <property name="brand">
               <value>红旗CA72</value>
           </property>
           <property name="color">
               <value>黑色</value>
           </property>
           <property name="maxSpeed">
               <value>200</value>
           </property>
       </bean>
</beans>

第四步：建立测试类

package com.spring.test;

import org.junit.Test;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.core.io.Resource;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import org.springframework.core.io.support.ResourcePatternResolver;

public class TestBeanFactory
{
   @Test
   public void test()
   {
       ResourcePatternResolver resolver = new PathMatchingResourcePatternResolver();
       Resource res = resolver.getResource("classpath:beans.xml");
       BeanFactory bf = new XmlBeanFactory(res);
       System.out.println("init BeanFactory");
       Car car = bf.getBean("car",Car.class);
       car.introduce();
   }
}

运行结果：

2013-5-4 14:28:46 org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions
信息: Loading XML bean definitions from class path resource [beans.xml]
init BeanFactory
调用Car()构造函数。
调用setBrand()设置属性。
调用BeanNameAware.setBeanName()。
调用BeanFactoryAware.setBeanFactory()。
调用InitializingBean.afterPropertiesSet()。
introduce:brand:红旗CA72/color:黑色/maxSpeed:200

运行结果分析：

XmlBeanFactory通过Resource装载Spring配置信息并启动IOC容器，然后就可以通过BeanFactory#getBean(beanName)方法从IOC容器中获取Bean了。

ApplicationContext介绍

如果说BeanFactory是Spring的心脏，那么ApplicationContext就是完整的身躯了。ApplicationContext由BeanFactory派生而来，提供了更多面向实际应用的功能。

ApplicationContext的初始化也很简单，

如果配置文件放置在类路径下，则可以使用ClassPathXmlApplicationContext实现类

ApplicationContext ctx = new ClassPathXmlApplicationContext("com/spring/test/beans.xml")

如果配置文件放置在文件系统路径下，则可以使用FileSystemXmlApplicationContext实现类

ApplicationContext ctx = new FileSystemXmlApplicationContext("com/spring/test/bean.xml");

需要注意的是：ApplicationContext的初始化和BeanFactory初始化有一个重大的区别:BeanFactory在初始化容器时，并未实例化Bean,直到第一次访问某个Bean时才实例化目标Bean；而ApplicationContext在初始化应用上下文时就实例化所有单实例的Bean.