Spring IOC

一、spring框架概念

　　spring是众多开源java项目中的一员，基于分层的javaEE应用一站式轻量级开源框架，主要核心是Ioc(控制反转/依赖注入) 与Aop(面向切面)两大技术，实现项目在开发过程中的轻松解耦，并极大的提高项目的开发效率。

　　　在项目中引入spring立即可以带来下面的好处 降低组件之间的耦合度,实现软件各层之间的解耦。可以使用容器提供的众多服务，如：事务管理服务、消息服务等等。当我们使用容器管理事务时，开发人员就不再需要手工控制事务.也不需处理复杂的事务传播。 容器提供单例模式支持，开发人员不再需要自己编写实现代码。 容器提供了AOP技术，利用它很容易实现如权限拦截、运行期监控等功能。

二、spring的七大模块

组成 Spring 框架的每个模块（或组件）都可以单独存在，或者与其他一个或多个模块联合实现。

1. 核心容器Spring Core: 核心容器提供 Spring 框架的基本功能。核心容器的主要组件是 BeanFactory，它是工厂模式的实现。BeanFactory 使用控制反转 （IOC） 思想将应用程序的配置和依赖性规范与实际的应用程序代码分开。
2. Spring 上下文Spring Context：Spring 上下文是一个配置文件，向 Spring 框架提供上下文信息。Spring 上下文包括企业服务，例如 JNDI、EJB、电子邮件、国际化、校验和调度功能。
3. Spring AOP：通过配置管理特性，Spring AOP 模块直接将面向切面的编程功能集成到了 Spring 框架中。所以，可以很容易地使 Spring 框架管理的任何对象支持 AOP。Spring AOP 模块为基于 Spring 的应用程序中的对象提供了事务管理服务。通过使用 Spring AOP，就可以将声明性事务管理集成到应用程序中。
4. Spring DAO：JDBC DAO  抽象层提供了有意义的异常层次结构，可用该结构来管理异常处理和不同数据库供应商抛出的错误消息。异常层次结构简化了错误处理，并且极大地降低了需要编写的异常代码数量（例如打开和关闭连接）。Spring DAO 的面向 JDBC 的异常遵从通用的 DAO 异常层次结构。
5. Spring ORM：Spring 框架插入了若干个 ORM 框架，从而提供了 ORM 的对象关系工具，其中包括 JDO、Hibernate 和 iBatis SQL Map。所有这些都遵从 Spring 的通用事务和 DAO 异常层次结构。
6. Spring Web 模块：Web 上下文模块建立在应用程序上下文模块之上，为基于 Web 的应用程序提供了上下文。所以，Spring 框架支持与 Jakarta Struts 的集成。Web 模块还简化了处理多部分请求以及将请求参数绑定到域对象的工作。
7. Spring MVC 框架：MVC 框架是一个全功能的构建 Web 应用程序的 MVC 实现。通过策略接口，MVC 框架变成为高度可配置的，MVC 容纳了大量视图技术，其中包括 JSP、Velocity、Tiles、iText 和 POI。

思考:Bean 是如何被实例化的？---工厂模式（简单模拟实现工厂模式）

简单工厂模式:抽象产品角色，具体产品角色，工厂角色

三、Spring  Ioc（控制反转/依赖注入）（Dependency Injection 即DI）

　　原先我们是通过手动的方式实例化new我们的对象，

　　现在将原先的过程交给我们web容器（spring）来进行创建，这个过程叫做控制反转、依赖注入。

　　目的：实现解耦

四、Spring  Ioc实例化bean对象的三种方式

　　　　1、构造器的方式实例化bean对象

　　　　

　　　　

　　　　2、静态工厂方法方式实例化bean（了解即可）

　　　　　　特点:

　　　　　　　　I.要有该工厂类及工厂方法 

　　　　　　　　II.工厂方法为静态的

　

　　　　

　　　　3、 实例化工厂方式创建bean（了解即可）　　　　　　

　　　　　　　　相比较静态工厂实现

　　　　　　　　I．工厂方法为非静态方法

　　　　　　　　II.需要配置工厂bean,并在业务bean中配置factory-bean，factory-method属性

　　　　　　

spring三种实例化bean的方式比较

　　　　方式一：通过bean的缺省构造函数创建，当各个bean的业务逻辑相互比较独立的时候或者和外界关联较少的时候可以使用。

　　　　方式二：利用静态factory方法创建，可以统一管理各个bean的创建，如各个bean在创建之前需要相同的初始化处理，则可用这个factory方法险进行统一的处理等等。

　　　　方式三：利用实例化factory方法创建，即将factory方法也作为了业务bean来控制，1可用于集成其他框架的bean创建管理方法，2能够使bean和factory的角色互换。

 　　　　开发中项目一般使用一种方式实例化bean，采用第一种方式最好，交给spring托管，使用时直接拿来使用即可。另外两种了解即可

 五、Spring  Ioc 4种注入方式

　　1）Set注入

　　　xml配置(同时 spring 也提供了对于基本数据类型的set注入方式)

　　

<!-- 
        id：名称唯一，一般是类名的全称，第一个首字母小写
        class：bean的全限命名 
     -->
     <!-- set注入 -->
    <bean id="userService" class="com.wisezone.service.UserService">
        <property name="userDao" ref="userDao"></property>
        <property name="age" value="23"></property>
        <property name="sex" value="1"></property>
        <property name="name" value="张三"></property>
    </bean>
    
    <bean id="userDao" class="com.wisezone.dao.UserDao"></bean>

　　　　java类

 　　　　

package com.wisezone.dao;

public class UserDao {
    
    public void save(){
        System.out.println("保存用户记录！");
    }
}

package com.wisezone.service;

import com.wisezone.dao.UserDao;

public class UserService {
    
    private UserDao userDao;
    
    private Integer age;//年龄
    
    private boolean sex;//性别
    
    private String name;//姓名
    
    
    public void setAge(Integer age) {
        this.age = age;
    }

    public void setSex(boolean sex) {
        this.sex = sex;
    }

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

    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

    public String save(){
        System.out.println("age:"+age+"--->sex:"+sex+"--->name:"+name);
        userDao.save();
        return "hello spring";
    }
}

package com.wisezone.test;

import static org.junit.Assert.*;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.context.support.FileSystemXmlApplicationContext;

import com.wisezone.service.UserService;

public class TestUserService {

    @Test
    public void test() {
        /**
         * 1、启动容器
         * 2、获取bean
         * 3、调用bean方法，打印信息
         */
        //1、传入xml  启动spring 容器
        ApplicationContext ac  = new ClassPathXmlApplicationContext("beans.xml");
        
        //2、获取bean 
        UserService userService = (UserService) ac.getBean("userService");
        
        //3、调用bean方法，打印信息
        System.out.println(userService.save());
    }

}

结果：

　　

　　2）构造器注入

　　xml配置（也提供对于基本数据类型的构造器注入值得方式）

　　　

<!-- 构造器注入 -->
    <!-- <bean id="userService2" class="com.wisezone.service.UserService2">
        <constructor-arg name="userDao" ref="userDao"></constructor-arg>
        <constructor-arg name="userName" value="admin"></constructor-arg>
        <constructor-arg name="addr" value="上海上海"></constructor-arg>
    </bean> -->
    
    <!-- 以index下标同样可以实现赋值 -->
    <bean id="userService2" class="com.wisezone.service.UserService2">
        <constructor-arg index="0" ref="userDao"></constructor-arg>
        <constructor-arg index="1" value="admin"></constructor-arg>
        <constructor-arg index="2" value="上海上海"></constructor-arg>
    </bean>
    
    <bean id="userDao" class="com.wisezone.dao.UserDao"></bean>

　　java类

　　

package com.wisezone.service;

import com.wisezone.dao.UserDao;

public class UserService2 {
    
    private UserDao userDao;
    
    private String userName;
    
    private String addr;
    
    
    //带参构造
    public UserService2(UserDao userDao,String userName,String addr) {
        super();
        this.userDao = userDao;
        this.userName = userName;
        this.addr = addr;
    }


    public String save(){
        System.out.println("userName:"+userName+"---->>>addr:"+addr);
        userDao.save();
        return "hello spring";
    }
}

package com.wisezone.test;

import static org.junit.Assert.*;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.context.support.FileSystemXmlApplicationContext;

import com.wisezone.service.UserService;
import com.wisezone.service.UserService2;

public class TestUserService2 {

    @Test
    public void test() {
        /**
         * 1、启动容器
         * 2、获取bean
         * 3、调用bean方法，打印信息
         */
        //1、传入xml  启动spring 容器
        ApplicationContext ac  = new ClassPathXmlApplicationContext("beans.xml");
        
        //2、获取bean 
        UserService2 userService2 = (UserService2) ac.getBean("userService2");
        
        //3、调用bean方法，打印信息
        System.out.println(userService2.save());
    }

}

结果：

 　　3）静态工厂注入

　　

<!-- 
        id：名称唯一，一般是类名的全称，第一个首字母小写
        class：bean的全限命名 
     -->
     <!-- set注入 -->
    <bean id="userService" class="com.wisezone.service.UserService">
        <property name="userDao" ref="staticFactory"></property>
    </bean>
    
    <!-- 静态工厂注入 -->
    <bean id="staticFactory" class="com.wisezone.factory.StaticFactory" factory-method="getUserDao">
    </bean>

　　java类

package com.wisezone.dao;

public class UserDao {
    
    public void save(){
        System.out.println("保存用户记录！");
    }
}

package com.wisezone.factory;

import com.wisezone.dao.UserDao;
import com.wisezone.service.UserService;

/**
 * 静态工厂实列化Bean
 * @author 王东海
 * @2017年4月27日
 */
public class StaticFactory {
    
    public static UserService getUserService(){
        
        return new UserService();
    }
    
    public static UserDao getUserDao(){
        
        return new UserDao();
    }
}    

package com.wisezone.service;

import com.wisezone.dao.UserDao;

public class UserService {
    
    private UserDao userDao;
    

    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

    public String save(){
        userDao.save();
        return "这是一个spring学习的开始。。。静态工厂注入";
    }
}

package com.wisezone.test;

import static org.junit.Assert.*;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.context.support.FileSystemXmlApplicationContext;

import com.wisezone.service.UserService;

public class TestUserService {

    @Test
    public void test() {
        /**
         * 1、启动容器
         * 2、获取bean
         * 3、调用bean方法，打印信息
         */
        //1、传入xml  启动spring 容器
        ApplicationContext ac  = new ClassPathXmlApplicationContext("beans.xml");
        
        //2、获取bean 
        UserService userService = (UserService) ac.getBean("userService");
        
        //3、调用bean方法，打印信息
        System.out.println(userService.save());
    }

}

结果：

 　　4）实例化工厂注入

<!-- 
        id：名称唯一，一般是类名的全称，第一个首字母小写
        class：bean的全限命名 
     -->
    <!-- 实例化工厂注入 -->
    <bean id="instanceFactory" class="com.wisezone.factory.InstanceFactory"></bean>
    
    <bean id="userDao" factory-bean="instanceFactory" factory-method="getUserDao"></bean>
     <!-- set注入 -->
    <bean id="userService" class="com.wisezone.service.UserService">
        <property name="userDao" ref="userDao"></property>
    </bean>

　　java类

package com.wisezone.dao;

public class UserDao {
    
    public void save(){
        System.out.println("保存用户记录！");
    }
}

package com.wisezone.factory;
import com.wisezone.dao.UserDao;
import com.wisezone.service.UserService;
/**
 * 实列化工厂
 * @author 王东海
 * @2017年4月27日
 */
public class InstanceFactory {
    
    public  UserService getUserService()
    {
        return new UserService();
    }
    
    public UserDao getUserDao(){
        
        return new UserDao();
    }

}

package com.wisezone.service;

import com.wisezone.dao.UserDao;

public class UserService {
    
    private UserDao userDao;
    

    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

    public String save(){
        userDao.save();
        return "spring实列化工厂注入测试。。。。";
    }
}

package com.wisezone.test;

import static org.junit.Assert.*;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.context.support.FileSystemXmlApplicationContext;

import com.wisezone.service.UserService;

public class TestUserService {

    @Test
    public void test() {
        /**
         * 1、启动容器
         * 2、获取bean
         * 3、调用bean方法，打印信息
         */
        //1、传入xml  启动spring 容器
        ApplicationContext ac  = new ClassPathXmlApplicationContext("beans.xml");
        
        //2、获取bean 
        UserService userService = (UserService) ac.getBean("userService");
        
        //3、调用bean方法，打印信息
        System.out.println(userService.save());
    }

}

结果：

　　

 六、Ioc集合类型属性注入（了解）

　　1）list集合注入

<property name="list">
            <list>
                <value>java01</value>
                <value>java02</value>
                <value>java03</value>
                <value>java04</value>
            </list>            
        </property>

结果：

　　　　2）set集合注入

<property name="set">
            <set>
                <value>10</value>
                <value>20</value>
                <value>30</value>
                <value>40</value>
                <value>50</value>
            </set>
        </property>

　　　　3）map类型属性注入

<property name="map">
            <map>
                <entry>
                    <key>
                        <value>a</value>    <!-- key值 -->
                    </key>
                    <value>hellojava</value>    <!-- key对应value值 -->
                </entry>
                <entry>
                    <key>
                        <value>b</value>    <!-- key值 -->
                    </key>
                    <value>helloworld</value>    <!-- key对应value值 -->
                </entry>
            </map>
        </property>

 　　　　4）properties属性注入

<property name="properties">
            <props>
                <prop key="a">test01</prop>
                <prop key="b">test02</prop>
                <prop key="c">test03</prop>
                <prop key="d">test04</prop>
            </props>
        </property>

 

-----------------------------------------总代码----------------------------------------------------------

package com.wisezone.service;

import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Properties;
import java.util.Set;


public class UserService2 {
    
    //1、list集合注入
    private List<String> list;
    
    //2、set集合注入
    private Set<Double> set;
    
    //3、map类型属性注入
    private Map<String, String> map;
    
    //4、Properties属性注入
    private Properties properties;


    public void setList(List<String> list) {
        this.list = list;
    }
    
    public void setSet(Set<Double> set) {
        this.set = set;
    }
    
    public void setMap(Map<String, String> map) {
        this.map = map;
    }

    public void setProperties(Properties properties) {
        this.properties = properties;
    }

    public void pointList(){
        for(String str:list){
            System.out.println(str);
        }
    }
    
    public void pointSet(){
        for(Double temp:set){
            System.out.println(temp);
        }
    }
    
    public void pointMap(){
        Set<Entry<String, String>> set = map.entrySet();
        for(Entry<String, String> entry:set){
            System.out.println(entry.getKey()+"----"+entry.getValue());
        }
    }
    
    
    public void pointProperties(){
        Set<Entry<Object, Object>> set = properties.entrySet();
        for(Entry<Object, Object> entry:set){
            System.out.println(entry.getKey()+"-----"+entry.getValue());
        }
    }
    
}

package com.wisezone.test;


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

import com.wisezone.service.UserService2;


public class TestUserService2 {

    @Test
    public void test() {
        /**
         * 1、启动容器
         * 2、获取bean
         * 3、调用bean方法，打印信息
         */
        //1、传入xml  启动spring 容器
        ApplicationContext ac  = new ClassPathXmlApplicationContext("beans.xml");
        
        //2、获取bean 
        UserService2 userService2 = (UserService2) ac.getBean("userService2");
        
        //list集合注入结果
//        userService2.pointList();
        
        //set集合注入结果
//        userService2.pointSet();
        
        //map类型属性注入结果
//        userService2.pointMap();
        
        //pointProperties属性注入结果
        userService2.pointProperties();
        
        
    }

}

<?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">

    <!-- 
        id：名称唯一，一般是类名的全称，第一个首字母小写
        class：bean的全限命名 
     -->
    <bean id="userService2" class="com.wisezone.service.UserService2">
        <property name="list">
            <list>
                <value>java01</value>
                <value>java02</value>
                <value>java03</value>
                <value>java04</value>
            </list>            
        </property>
        
        <property name="set">
            <set>
                <value>10</value>
                <value>20</value>
                <value>30</value>
                <value>40</value>
                <value>50</value>
            </set>
        </property>
        
        <property name="map">
            <map>
                <entry>
                    <key>
                        <value>a</value>    <!-- key值 -->
                    </key>
                    <value>hellojava</value>    <!-- key对应value值 -->
                </entry>
                <entry>
                    <key>
                        <value>b</value>    <!-- key值 -->
                    </key>
                    <value>helloworld</value>    <!-- key对应value值 -->
                </entry>
            </map>
        </property>
        
        <property name="properties">
            <props>
                <prop key="a">test01</prop>
                <prop key="b">test02</prop>
                <prop key="c">test03</prop>
                <prop key="d">test04</prop>
            </props>
        </property>
        
    </bean>
</beans>

 七、注解方式实现注入bean

　　　　对于bean的注入，除了使用xml 配置以外，注解的配置简化开发的速度，使程序看上去更简洁。对于注解的解释，spring对于注解有专门的解释器，对定义的注解进行解析，实现对应bean对象的注入，反射技术实现。

　　　　加入Aop  jar包 spring-aop-4.3.2.RELEASE.jar

　　　　Xml 配置:  加入context命名空间 和xsd地址 并添加

　　　　<context:annotation-config/> 配置

<?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:annotation-config/>
</beans>

　　　　对于bean的注入常用注解类型

　　　　@Autowired 属性字段或set方法上 

　　　　@Resource  属性字段上或set方法上

　　　　区别: 
　　　　　　@Autowired 默认按bean 的类型匹配 可以修改 按名称匹配 和@Qualifier配合使用
　　
　　　　　　　　@Resource  默认按名称进行装配，名称可以通过name属性进行指定，如果没有指定name属性，当注解写在字段上时，默认取字段名进行匹配注入，如果注解写在setter方法上默认取属性名进行装配。当找不到与名称匹配的bean时才按照类型进行装配。但是需要注意的是，如果name属性一旦指定，就只会按照名称进行装配。

　　　　推荐使用@Resource 注解是属于J2EE的，减少了与spring的耦合。

代码演示：

<?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:annotation-config />

    <bean id="userService" class="com.wisezone.service.UserService">
    </bean>
    
    <bean id="userDao" class="com.wisezone.dao.UserDao"></bean>
    
</beans>

package com.wisezone.service;

import javax.annotation.Resource;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;

import com.wisezone.dao.UserDao;

public class UserService {
    
    /**
     * 默认按照属性名称注入，如果没有找到对应名称，按照类型注入class
     * 反射 set
     */
    /*@Resource
    private UserDao userDao;*/
    
    /**
     *  默认按照类型 注入
     */
    @Autowired
    @Qualifier("userDao")
    private UserDao userDao;
    
    public String save(){
        userDao.save();
        return "hello spring";
    }
}

package com.wisezone.test;

import static org.junit.Assert.*;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.context.support.FileSystemXmlApplicationContext;

import com.wisezone.service.UserService;

public class TestUserService {

    @Test
    public void test() {
        /**
         * 1、启动容器
         * 2、获取bean
         * 3、调用bean方法，打印信息
         */
        //1、传入xml  启动spring 容器
        ApplicationContext ac  = new ClassPathXmlApplicationContext("beans.xml");
        
        //2、获取bean 
        UserService userService = (UserService) ac.getBean("userService");
        
        //3、调用bean方法，打印信息
        System.out.println(userService.save());
    }

}

结果：

 八、 Spring  Ioc容器自动扫描管理bean

　　　实际的开发中，bean的数量非常多，采用手动配置bean的方式已无法满足生产需要，spring这时候同样提供了扫描的方式，对扫描到的bean对象统一进行管理，简化开发配置，提高开发效率。

　　　　

　　　　　不需要再配置

 　　　　

　　　　同时对于被spring 管理的bean 类的定义上需要加入对应的注解定义

　　　　开发中建议(开发中的一种约定)

　　　　Dao 层:@Repository

　　　　Service层:@Service

　　　　视图控制层:@Controller

　　　　如果对于开发的类实在不明确到底属于哪个层，可以使用@Component注解定义。

 九、 Bean的作用域问题

　　默认情况下，我们从spring容器中拿到的对象均是单例的，对于bean的作用域类型如下：

　　

　　　　1、    singleton 作用域

 　　　　

　　　　

　　默认情况下，被管理的bean只会IOC容器中存在一个实例，对于所有获取该Bean的操作Spring容器将只返回同一个Bean。

　　

　　　　　　什么类型的对象适合作为单例对象来使用呢？ service,dao,action等

　　　　　　　　一般来说对于无状态或状态不可改变的 对象适合使用单例模式（什么是无状态或状态不可改变）

　　　　　　　　实际上对象状态的变化往往均是由于属性值得变化而引起的，比如user类  年龄属性会有变化  属性年龄的变化一般会引起user对象状态的变化。对于我们的程序来说，无状态对象 没有实例变量的存在，保证了线程的安全性，service 层业务对象即是无状态对象。线程安全的。

　　　　

　　　　prototype 作用域

　　　　

　　　　　　通过scope=” prototype” 设置bean的类型 ，每次向Spring容器请求获取Bean都返回一个全新的Bean，相对于“singleton”来说就是不缓存Bean，每次都是一个根据Bean定义创建的全新Bean。

　　　　　2、 Web应用中的作用域(request、session、globalsession)

　　　　　　

 十、Bean的生命周期

　　　1、Bean的定义

　　　　　　对比已经学过的servlet 生命周期（容器启动装载并实例化servlet类，初始化servlet，调用service方法，销毁servlet）。

　　　　　　　　同样对于spring容器管理的bean也存在生命周期的概念

　　　　　　　　在Spring中，Bean的生命周期包括Bean的定义、初始化、使用和销毁4个阶段

　　　　　　　　在Spring中，通常是通过配置文档的方式来定义Bean的。在一个配置文档中，可以定义多个Bean。

　　　　　2、Bean的初始化

　　　　　　Spring bean 初始化有两种方式：

　　　　　　　　I.在配置文档中通过指定 init-method 属性来完成。

　　　　　　　　II.实现org.springframework.beans.factory.InitializingBean接口。

　　　　　　　　Bean对象实例化过程是在spring容器初始化时被实例化的，但也不是不可改变的，可以通过  lazy-init=”true” 属性延迟bean对象的初始化操作，此时再调用getbean 方法时才会进行bean的初始化操作

　　　　　　　　

　　　　　3、Bean的使用

　　　　　　I.使用BeanFactory

　　　　　　　　II.使用ApplicationContext

 　　　　　4、Bean的销毁

 　　　　　　　　实现销毁方式(spring容器会维护bean对象的管理，可以指定bean对象的销毁所要执行的方法)

 　　　　　　　　

　　　　　　　　通过AbstractApplicationContext 对象，调用其close方法实现bean的销毁过程。

/**
     * 测试Bean的销毁过程
     * void
     */
    @Test
    public void test02() {
        /**
         * 1、启动容器
         * 2、获取bean
         * 3、调用bean方法，打印信息
         */
        //1、传入xml  启动spring 容器
        AbstractApplicationContext ac  = new ClassPathXmlApplicationContext("beans.xml");
        
        //2、获取bean 
        UserService userService = (UserService) ac.getBean("userService");
        
        //3、调用方法（怎么判断单例的两个结果是否一样，只要打印它的地址就可以了）
        System.out.println(userService);
        
        //关闭
        ac.close();
    }

结果：