Spring Bean详解

Spring Bean

在Spring的应用中，Spring IoC容器可以创建、装配和配置应用组件对象，这里的组件对象称为Bean。

Bean的配置

Spring可以看作一个大型工厂，用于生产和管理Spring容器中的Bean。如果要使用这个工厂生产和管理Bean，需要开发者将Bean配置在Spring的配置文件中，Spring框架支持XML和Properties两种格式的配置文件，在实际开发中常用XML格式的配置文件。

从前面的内容得知XML配置文件的根元素是<beans>，<beans>中包含了多个<bean>子元素，每个<bean>元素定义<bean>，并描述Bean如何被装配到Spring容器中，<bean>元素的常用属性及其子元素如下所示

属性或子元素名称	描述
id	Bean在BeanFactory中的唯一标识，在代码中通过BeanFactory获取Bean实例时使用的索引名称。
class	Bean的具体实现类，使用全类名描述。
scope	指定Bean实例的作用域。
<construct-arg>	<bean>元素的子元素，使用构造方法注入，指定构造方法的参数，该元素的index属性指定参数的序号，ref属性指定对BeanFactory中其他Bean的引用关系，type属性指定参数类型，vlaue属性指定参数的常量值。
<property>	<bean>元素的子元素，用于设置一个属性，该元素的name属性指定Bean实例中相应属性名称，value指定Bean的属性值，ref属性指定属性对BeanFactory中其他Bean的引用关系。
<list>	<property>元素的子元素，用于封装List或数组类型的依赖注入。
<map>	<property>元素的子元素，用于封装map类型的依赖注入。
<set>	<property>元素的子元素，用于封装set类型的依赖注入。
<entry>	<map>元素的子元素，用于设置一个键值对。

Bean的配置示例如下：

<?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.xsd">
    <!--将指定类TestDIDaoImpl配置给Spring，让Spring为其创建实例-->
    <bean id="myTestDIDao" class="dao.Impl.TestDIDaoImpl"/>
    <!--使用构造方法注入-->
    <bean id="testDIService" class="service.Impl.TestDIServiceImpl">
    <!--将myTestDIDao注入到TestDIServiceImpl类的属性的TestDIDao上-->
        <constructor-arg index="0" ref="myTestDIDao"/>
    </bean>
    <!--使用setter方法注入-->
    <bean id="testDIService_setter" class="service.Impl.TestDIServiceImpl_setter">
        <!--调用setter方法，将myTestDIDao注入到方法的属性中-->
        <property name="testDIDao" ref="myTestDIDao"/>
    </bean>
</beans>

Bean的实例化

在面向对象中，如果想要使用某个对象，需要事先实例化该对象，同样，在Spring框架中，如果想使用Spring容器中的Bean，也需要实例化Bean，Spring框架实例化Bean有3种方式，即构造方法实例化，静态工厂实例化和实例工厂实例化（最常用的是构造方法实例化）。

构造方法实例化

在Spring框架中，Spring容器可以调用Bean对应类中的无参构造方法来实例化Bean，这种方式称为构造方法实例化。

1. 创建BeanClass类

package instance;
public class BeanClass {
    public String message;
    public BeanClass(){
        message="构造方法实例化Bean";
    }
    public BeanClass(String s){
        message=s;
    }
}

1. 创建配置文件

<?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.xsd">
    <!--构造方法实例化Bean-->
    <bean id="constructorInstance" class="instance.BeanClass"/>
</beans>

1. 创建测试类

package Test;
import instance.BeanClass;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class TestInstance {
    public static void main(String[] args) {
        ApplicationContext appCo=new ClassPathXmlApplicationContext("applicationContext.xml");
        BeanClass beanClass = (BeanClass) appCo.getBean("constructorInstance");
        System.out.println(beanClass+beanClass.message);
    }
}

静态工厂实例化

在使用静态工厂实例化Bean时要求开发者在工厂类中创建一个静态方法来创建Bean的实例，在配置Bean时，class属性指定静态工厂类，同时还需要使用factory-method属性指定工厂类中的静态方法，下面通过实例测试静态工厂实例化

1. 创建工厂类BeanStaticFactory

package instance;
public class BeanStaticFactory {
    private static BeanClass beanInstanece=new BeanClass("调用静态工厂方法实例化");
    public static BeanClass createInstance(){
        return beanInstanece;
    }
}

1. 编辑配置文件

<?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.xsd">
        <!--静态工厂实例化-->
    <bean id="staticFactory" class="instance.BeanStaticFactory" factory-method="createInstance"/>
</beans>

1. 添加测试代码

package Test;
import instance.BeanClass;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class TestInstance {
    public static void main(String[] args) {
        ApplicationContext appCo=new ClassPathXmlApplicationContext("applicationContext.xml");
        BeanClass beanClass = (BeanClass) appCo.getBean("staticFactory");
        System.out.println(beanClass+beanClass.message);
    }
}

实例工厂实例化

在使用实例工厂实例化Bean时要求开发者在工厂类中创建一个实例方法来创建Bean的实例，在配置Bean时需要使用factory-bean属性指定配置的实例工厂，同时还需要使用factory-method属性指定实例工厂中的实例方法。下面通过代码测试实例工厂实例化。

1. 创建工厂类BeanInstanceFactory

package instance;
public class BeanInstanceFactory {
    public BeanClass createBeanClassInstance(){
        return new BeanClass("调用实例工厂实例化Bean");
    }
}

1. 编辑配置文件

<?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.xsd">
    <!--配置工厂-->
    <bean id="myFactory" class="instance.BeanInstanceFactory"/>
    <!--使用factory-bean属性指定配置工厂，使用factory-method属性指定使用哪个方法实例化-->
    <bean id="instanceFactoryInstance" factory-bean="myFactory" factory-method="createBeanClassInstance"/>
</beans>

1. 测试方法

package Test;
import instance.BeanClass;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class TestInstance {
    public static void main(String[] args) {
        ApplicationContext appCo=new ClassPathXmlApplicationContext("applicationContext.xml");
        BeanClass beanClass = (BeanClass) appCo.getBean("instanceFactoryInstance");
        System.out.println(beanClass+beanClass.message);
    }
}

Bean的作用域

在Spring中不但可以完成Bean的实例化，还可以指定Bean的作用域，在Spring中定义实例化Bean的作用域如下：

作用域名称	描述
singleton	默认的作用域，使用singleton定义的Bean在Spring容器中只有一个Bean实例。
prototype	Spring容器每次获取prototype定义的Bean，容器都将创建一个新的Bean实例。
requesrt	在一次HTTP请求中容器将返回一个Bean实例，不同的HTTP请求返回不同的Bean实例，仅在Web应用中使用。
session	在一个HTTPSession中，容器将返回一个Bean实例，仅在Web应用中使用。
application	为每个ServletContext对象创建一个实例，即同一个应用共享一个Bean实例，仅在Web应用使用。
websocket	为每个WebSocket对象创建一个实例，仅在Web应用使用。

在上表中，singleton和prototype是最常用的两种，后面4种仅在Web应用使用。

Singleton作用域

当将bean的scope设置为singleton时，Spring IoC容器仅生成和管理一个Bean对象，在使用id获取Bean实例时，IoC容器将返回共享的Bean实例。

由于singleton是scope的默认方式，因此可以不写。

测试singleton作用域，代码如下：

package Test;
import instance.BeanClass;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class TestInstance {
    public static void main(String[] args) {
        ApplicationContext appCo=new ClassPathXmlApplicationContext("applicationContext.xml");
        BeanClass beanClass1 = (BeanClass) appCo.getBean("instanceFactoryInstance");
        System.out.println(beanClass1+beanClass1.message);
        BeanClass beanClass2 = (BeanClass) appCo.getBean("instanceFactoryInstance");
        System.out.println(beanClass2+beanClass2.message);
    }
}

获取到两个对象的hash值相同，因此是同一个对象。

prototype作用域

当将bean的scope设置为prototype时，SpringIoC容器将为每次请求创建一个新实例。如果将bean的配置改为：

<bean id="instanceFactoryInstance" factory-bean="myFactory" factory-method="createBeanClassInstance" scope="prototype"/>

则可以每次请求时都会创建一个新的实例。

Bean的生命周期

一个对象的生命周期包括创建（实例化和初始化），使用以及销毁等阶段，在Spring中，Bean对象周期也遵循这一过程，但是Spring提供许多对外的接口，允许开发者对3个过程（实例化，初始化，销毁）的前后做一些操作。在SpringBean中，实例化是为对象开辟空间，初始化则是对属性的初始化。

Spring容器可以管理singleton作用域Bean的生命周期，在此作用域下，Spring能够精确地知道Bean何时被创建，何时初始化完成，以及何时被销毁，而对于prototype作用域的Bean，Spring只负责创建，当容器创建了Bean的实例后，Bean实例就交给了客户端的代码管理，Spring容器不再跟踪其生命周期，并且不会管理那些被配置成prototype作用域的Bean，Spring中的生命周期的执行是一个很复杂的过程，可借鉴Servlet的声明周期“实例化→初始化→接收请求→销毁”来理解Spring的声明周期。

Bean的生命周期整个过程如下：

1. 根据Bean的配置情况实例化一个Bean
2. 根据Spring上下文对实例化的Bean进行依赖注入，即对Bean的属性进行初始化。
3. 如果Bean实现了BeanNameAware接口，将调用它实现的setBeanName(String beanId)方法，此参数传递的是Spring配置文件中Bean的id。
4. 如果Bean实现了BeanFactoryAware接口，将调用它实现的setBeanFactory方法，此处传递的参数是当前Spring工厂实例的引用。
5. 如果Bean实现了ApplicationContextAware接口，将调用它实现的setApplicationContext(ApplicationContext)方法，此处参数传递的是Spring上下文实例的引用。
6. 如果Bean关联了BeanPostProcessor接口，将调用初始化方法postProcessBeforeInitialization(Object obj,String s)对Bean进行操作。
7. 如果Bean实现了InitalizingBean接口，将调用afterPropertiesSet方法。
8. 如果Bean在Spring配置文件中配置了init-method属性，将自动调用其配置的初始化方法。
9. 如果Bean关联了BeanPostProcessor接口，将调用postProcessAfterInitialzation(Object obj,String s)方法，由于是在Bean初始化结束后调用After方法，也可用于内存或缓存技术。

以上工作完成后就可以使用该Bean，由于该Bean的作用域是singleton，所以调用的是同一个Bean实例。

1. 当Bean不再需要时进入销毁阶段，如果Bean实现了DisposableBean接口，则调用其实现的destroy方法将Spring中的Bean销毁。
2. 如果在配置文件中通过destroy-method属性指定了Bean的销毁方法，将调用其配置的销毁方法进行销毁。

在Spring中，通过实现特定的接口或通过<bean>元素的属性设置可以对Bean的生命周期产生影响，开发者可以随意的配置属性，但是不建议过多的使用Bean实现接口，因为这样会使代码和Spring聚合较紧密。下面通过实例来演示Bean生命周期：

1. 创建Bean的实现类

package life;
public class BeanLife {
    public void initMyself(){
        System.out.println(this.getClass().getName()+"执行自定义的初始化方法");
    }
    public void destroyMyself(){
        System.out.println(this.getClass().getName()+"执行自定义的销毁方法");
    }
}

1. 在Spring的配置文件中创建一个Bean

<!--配置bean，使用init-method指定初始化方法，使用destroy-method指定销毁方法-->
<bean id="beanLife" class="life.BeanLife" init-method="initMyself" destroy-method="destroyMyself"/>

1. 测试生命周期

package Test;
import life.BeanLife;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class TestLife {
    public static void main(String[] args) {
        //为了方便演示销毁方法，使用ClassPathXmlApplicationContext实现类声明容器。
        ClassPathXmlApplicationContext ctx=new ClassPathXmlApplicationContext("applicationContext.xml");
        System.out.println("获取对象之前");
        BeanLife beanLife=(BeanLife)ctx.getBean("beanLife");
        System.out.println("获取对象之后"+beanLife);
        ctx.close();
    }
}

Bean的装配方式

Bean的装配可以理解为将Bean依赖注入到Spring容器中，Bean的装配方式即Bean依赖注入的方式。Spring容器支持基于XML的装配、基于注解的装配以及自动装配方式，其中最受青睐的装配方式是基于注解的装配。

基于XML的配置方式的装配

基于XML的装配方式提供了两种方式，即使用构造方法注入和使用属性的setter方法注入。

在使用构造方法注入方式装配Bean时，Bean的实现类需要提供带参数的构造方法，并在配置方式中使用<bean>的子元素<construct-arg>来定义构造方法的参数，在使用属性的setter方法注入方式装配Bean时，Bean的实现类需要提供一个默认无参数的构造方法，并为需要注入的属性提供对应的setter方法，另外还需要使用<bean>元素的子元素<property>为每个属性注入值。

下面通过实例来演示基于XML配置的装配方式。

1. 创建Bean的实现类ComplexUser

package assemble;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Set;
public class ComplexUser {
    private String uname;
    private List<String> hobbyList;
    private Map<String,String> residenceMap;
    private Set<String> aliasSet;
    private String[] array;
    /**
     * 使用构造方法注入，需要提供带参数的构造方法
     * @param uname
     * @param hobbyList
     * @param residenceMap
     * @param aliasSet
     * @param array
     */
    public ComplexUser(String uname, List<String> hobbyList, Map<String, String> residenceMap, Set<String> aliasSet, String[] array) {
        this.uname = uname;
        this.hobbyList = hobbyList;
        this.residenceMap = residenceMap;
        this.aliasSet = aliasSet;
        this.array = array;
    }
    /**
     * 使用属性的setter方法注入，提供默认无参构造方法，并为注入的属性提供setter方法
     */
    public ComplexUser() {
    }
    public void setUname(String uname) {
        this.uname = uname;
    }
    public void setHobbyList(List<String> hobbyList) {
        this.hobbyList = hobbyList;
    }
    public void setResidenceMap(Map<String, String> residenceMap) {
        this.residenceMap = residenceMap;
    }
    public void setAliasSet(Set<String> aliasSet) {
        this.aliasSet = aliasSet;
    }
    public void setArray(String[] array) {
        this.array = array;
    }
    @Override
    public String toString() {
        return "ComplexUser{" +
                "uname='" + uname + '\'' +
                ", hobbyList=" + hobbyList +
                ", residenceMap=" + residenceMap +
                ", aliasSet=" + aliasSet +
                ", array=" + Arrays.toString(array) +
                '}';
    }
}

1. 配置Bean，在Spring配置文件中使用ComplexUser配置Bean的两个实例

<!--使用构造方法注入方式装配ComplexUser实例user1-->
<bean id="user1" class="assemble.ComplexUser">
    <constructor-arg index="0" value="chenheng1"/>
    <constructor-arg index="1">
        <list>
            <value>唱歌</value>
            <value>跳舞</value>
            <value>爬山</value>
        </list>
    </constructor-arg>
    <constructor-arg index="2">
        <map>
            <entry key="dalian" value="大连"/>
            <entry key="beijing" value="北京"/>
            <entry key="shanghai" value="上海"/>
        </map>
    </constructor-arg>
    <constructor-arg index="3">
        <set>
            <value>chenheng100</value>
            <value>chenheng101</value>
            <value>chenheng102</value>
        </set>
    </constructor-arg>
    <constructor-arg index="4">
        <array>
            <value>aaa</value>
            <value>bbb</value>
        </array>
    </constructor-arg>
</bean>
<!--使用构造方法注入方式装配ComplexUser实例user2-->
<bean id="user2" class="assemble.ComplexUser">
    <constructor-arg index="0" value="chenheng2"/>
    <constructor-arg index="1">
        <list>
            <value>看书</value>
            <value>学习</value>
        </list>
    </constructor-arg>
    <constructor-arg index="2">
        <map>
            <entry key="shenzhen" value="深圳"/>
            <entry key="guanzhou" value="广州"/>
            <entry key="tianjin" value="天津"/>
        </map>
    </constructor-arg>
    <constructor-arg index="3">
        <set>
            <value>chenheng103</value>
            <value>chenheng104</value>
            <value>chenheng105</value>
        </set>
    </constructor-arg>
    <constructor-arg index="4">
        <array>
            <value>ccc</value>
            <value>ddd</value>
        </array>
    </constructor-arg>
</bean>

1. 测试基于XML的装配方式

package Test;
import assemble.ComplexUser;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class TestAssemble {
    public static void main(String[] args) {
        ApplicationContext appCon = new ClassPathXmlApplicationContext("applicationContext.xml");
        //使用构造方法装配测试
        ComplexUser u1=(ComplexUser)appCon.getBean("user1");
        System.out.println(u1);
        //使用setter方法装配测试
        ComplexUser u2=(ComplexUser)appCon.getBean("user2");
        System.out.println(u2);
    }
}

基于注解的装配

在Spring框架中，尽管使用XML配置文件可以简单地装配Bean，但如果应用中有大量的Bean需要装配，会导致XML配置文件过于庞大，不方便维护，因此更多时候我们建议使用注解配置。

在Spring框架中定义了一系列的注解，下面介绍几个常用的注解。

1. @Component：该注解是一个泛化的概念，仅仅表示一个组件对象（Bean）。可以作用在任何层次上，下面通过一个实例解释@Component。

   1. 创建一个Bean

   package annotation;
   import org.springframework.beans.factory.annotation.Value;
   import org.springframework.stereotype.Component;
   @Component()
   /** 相当于@Component(“annotationUser”)或@Component(value = “annotationUser”),
    * annotationUser为Bean的id，默认为首字母小写的类名 **/
   public class AnnotationUser {
       @Value("chenheng") //只注入了值，对于复杂的注入目前使用该方式无法解决。
       private String uname;
       public String getUname() {
           return uname;
       }
       public void setUname(String uname) {
           this.uname = uname;
       }
   }
   

   1. 配置注解：现在有了Bean的实现类，但还无法测试，因为Spring容器并不知道去哪里找Bean对象。需要在配置文件中配置注解，方式如下：<context:component-scan base-package="bean所在的包"/>，因此创建配置文件annotationContext.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.xsd
           http://www.springframework.org/schema/context
           http://www.springframework.org/schema/context/spring-context.xsd">
       <context:component-scan base-package="annotation"/>
   </beans>
   

   1. 测试Bean实例

   package Test;
   import annotation.AnnotationUser;
   import org.springframework.context.ApplicationContext;
   import org.springframework.context.support.ClassPathXmlApplicationContext;
   public class TestAnnotation {
       public static void main(String[] args) {
           ApplicationContext appCon = new ClassPathXmlApplicationContext("annotationContext.xml");
           AnnotationUser annotationUser = (AnnotationUser)appCon.getBean("annotationUser");
           System.out.println(annotationUser);
       }
   }
   

在Spring4.0以上，配置注解指定包中的注解进行扫描需要事先导入SpringAOP的jar包。

1. @Repository：该注解用于将数据访问层（DAO）的类标识为Bean，即注解数据访问层Bean，其功能与@Compoent相同。
2. @Service：该注解用于标注一个业务逻辑层组件，其功能与@Compoent相同。
3. @Autowired：该注解对类成员变量、方法及构造函数进行标注，完成自动装配的工作，通过使用@Autowired来消除setter和getter方法，默认按照Bean的类型进行装配。

默认按照bean类型注入，意思是不需要写property属性，直接按照名称向类成员变量、方法及构造函数注入。

1. @Controller：该注解用于标注一个控制器组件类，其功能与@Compoent相同。
2. @Resource：该注解与@Autowired的功能一样，区别在于该注解是按照名称来进行装配注入的，只有当找不到与名称匹配的Bean时才会按照类型来装配注入。而@Autowired默认是按照Bean的类型进行装配，如果想按照名称来装配，则需要与@Qualifier注解一起使用。

@Resource有两个属性——name和type，name属性指定的是Bean实例的名称，即按照名称注入，type指定的是Bean类型，即按照Bean的类型进行装配。

1. @Qualifier：该注解与@Autowired配合使用，当@Autowired注解需要按照名称来装配注入时需要和该注解一起使用，Bean的实例名称由@Qulifier注解的参数指定。

在上面的几个注解中，@Controller，@Repository，@Service的功能与@Compoent一样，但是为了让类的标注更加清晰，在开发中推荐使用@Repository标注数据访问层（DAO层），@Service标注业务逻辑层（Service层），@Controller标注控制器层（控制层）。

下面通过实例使用注解：

1. 创建Dao层接口TestDao

package annotation.dao;

public interface TestDao {
    public void save();
}

1. 实现TestDao接口TestDaoImpl

package annotation.dao.Impl;
import annotation.dao.TestDao;
import org.springframework.stereotype.Repository;
@Repository("testDao")
/**相当于@Repository，但如果在service中使用@Resource(name="testDao")时,不能省略testDao*/
public class TestDaoImpl implements TestDao {
    @Override
    public void save() {
        System.out.println("testDao save");
    }
}

1. 创建Service接口TestService

package annotation.Service;

public interface TestService {
    public void save();
}

1. 实现Service接口TestServiceImpl

package annotation.Service.Impl;

import annotation.Service.TestService;
import annotation.dao.TestDao;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;

@Service("testService") //相当于testService
public class TestServiceImpl implements TestService {
    @Resource(name = "testDao")//相当于使用@Autowired。按照类型装配
    private TestDao testDao;
    @Override
    public void save() {
        testDao.save();
        System.out.println("testService save");
    }
}

1. 创建Controller类

package annotation.Controller;
import annotation.Service.TestService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
@Controller
public class TestController {
    @Autowired
    private TestService testService;
    public void save(){
        testService.save();
        System.out.println("testController save");
    }
}

1. 配置注解

<?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.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd">
    <context:component-scan base-package="annotation"/>
</beans>

1. 创建测试类

package Test;

import annotation.Controller.TestController;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestMoreAnnoation {
    public static void main(String[] args) {
        ApplicationContext appCo=new ClassPathXmlApplicationContext("annotationContext.xml");
        TestController testController = (TestController)appCo.getBean("testController");
        testController.save();
    }
}