bean的配置和实例化以及生命周期

1.bean的配置

1.1基础配置

<beans>
    <bean id="bookDao" class="com.my.dao.impl.BookDaoImpl"/>

    <bean id="bookService" class="com.my.service.impl.BookServiceImpl">
        <property name="bookDao" ref="bookDao"/>
    bean>
beans>
1
2
3
4
5
6
7

1.2别名配置

    <bean id="bookDao"  name="bookDao bookDao1" class="com.my.dao.impl.BookDaoImpl"/>
1

1.3作用范围配置

<bean id="userDao" class="com.my.factory.UserDaoFactoryBean" scope="prototype"/>
1

2.bean的实例化

2.1构造方法实例化（默认）

在实现类中添加无参构造方法（将类配置到Spring容器（xml配置文件））

public class BookDaoImpl implements BookDao {

    public BookDaoImpl(){
        System.out.println("book constructor is running");
    }
    
    @Override
    public void save() {
        System.out.println("book dao save......");
    }
}
1
2
3
4
5
6
7
8
9
10
11

配置文件

<bean id="bookDao" class="com.my.dao.impl.BookDaoImpl"/>
1

测试运行结果

    public static void main(String[] args) {

        ApplicationContext context=new ClassPathXmlApplicationContext("applicationConfig.xml");

        BookDao bookDao = (BookDao) context.getBean("bookDao");
        bookDao.save();
        //运行结果为：book constructor is running
        //book dao save......

    }
1
2
3
4
5
6
7
8
9
10

2.2静态工厂实例化

准备实现类

public class OrderDaoImpl implements OrderDao {
    @Override
    public void save() {
        System.out.println("order dao save ......");
    }
}
1
2
3
4
5
6

创建工厂类，添加一个静态方法

public class OrderDaoFactory {
    public static OrderDao getOrderDaoImpl(){
        System.out.println("order dao factory start......");
        return new OrderDaoImpl();
    }
}
1
2
3
4
5
6

配置文件

    <bean id="orderDao" class="com.my.factory.OrderDaoFactory" factory-method="getOrderDaoImpl"/>
1
2

测试运行结果

public static void main(String[] args) {

    ApplicationContext context=new ClassPathXmlApplicationContext("applicationConfig.xml");
    OrderDao orderDao = (OrderDao) context.getBean("orderDao");

    orderDao.save();
    //输出结果为：book constructor is running
    //order dao factory start......
    //order dao save ......
}
1
2
3
4
5
6
7
8
9
10

2.3实例工厂实例化

实现类

public class UserDaoImpl implements UserDao {
    @Override
    public void save() {
        System.out.println("user dao save ......");
    }
}
1
2
3
4
5
6

创建工厂类，添加方法（非静态方法）

public class UserDaoFactory {

    public UserDao getUserDaoImpl(){
        return new UserDaoImpl();
    }
}
1
2
3
4
5
6

配置文件

    <bean id="userDaoFactory" class="com.my.factory.UserDaoFactory"/>
    <bean id="userDao"  factory-method="getUserDaoImpl" factory-bean="userDaoFactory"/>
1
2
3

测试运行结果

    public static void main(String[] args) {

        ApplicationContext context=new ClassPathXmlApplicationContext("applicationConfig.xml");
        UserDao userDao = (UserDao) context.getBean("userDao");

        userDao.save();
        //输出结果为：user dao save ......
    }
1
2
3
4
5
6
7
8

2.4FactoryBean的使用（简化）

实现类（同2.3）

创建一个类实现 FactoryBean 接口

public class UserDaoFactoryBean implements FactoryBean<UserDao> {
    //创建对象
    @Override
    public UserDao getObject() throws Exception {
        return new UserDaoImpl();
    }
    //对象类型
    @Override
    public Class<?> getObjectType() {
        return UserDao.class;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

配置文件

<bean id="userDao" class="com.my.factory.UserDaoFactoryBean"/>
1

测试运行结果（同2.3）

3.bean的生命周期

• 初始化容器

  1. 创建对象
  2. 执行构造方法
  3. 执行属性注入（setter方法）
  4. 执行bean初始化方法

• 使用bean

  1. 执行业务操作

• 关闭、销毁容器

  1. 执行bean销毁方法

3.1控制生命周期方法

• void init(); bean初始化
• void destroy(); bean销毁

例如：

准备接口和实现类，添加 init 和 destroy 两个方法

public class BookDaoImpl implements BookDao {

    @Override
    public void save() {
        System.out.println("book dao save......");
    }

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

    public void destroy(){
        System.out.println("destroy ......");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

配置文件

<bean id="bookDao" class="com.my.dao.impl.BookDaoImpl" init-method="init" destroy-method="destroy"/>
1

测试运行结果

• Spring 的 IoC 容器是运行在 JVM 中的，main 方法执行完后，JVM

  退出，但 IoC 容器中的 bean 并没有来得及销毁

所以要在 JVM 退出前关闭容器

    public static void main(String[] args) {

        ClassPathXmlApplicationContext context=new ClassPathXmlApplicationContext("applicationConfig.xml");

        //虚拟机关闭前，将容器关闭
        context.registerShutdownHook();

        BookDao bookDao = (BookDao) context.getBean("bookDao");
        bookDao.save();
        //context.close();
        //输出结果：init ......
        //book dao save......
        //destroy ......
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14

3.2关闭容器的方式

• close() 方法 （调用的时候关闭容器）
• registerShutdownHook() 方法 （JVM退出前调用关闭 （钩子函数/回调函数））

ApplicationContext 没有 close 方法， ConfigurableApplicationContext 接口有 close 方法，所以使用实现类 ClassPathXmlApplicationContext

3.3生命周期控制接口实现（Spring提供的两个接口 InitializingBean，DisposableBean）

实现类可以改为

public class BookDaoImpl implements BookDao, InitializingBean, DisposableBean {

    @Override
    public void save() {
        System.out.println("book dao save......");
    }
    
    @Override
    public void destroy() throws Exception {
        System.out.println("destroy ......");
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("init ......");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

配置文件

<bean id="bookDao" class="com.my.dao.impl.BookDaoImpl"/>
1

测试运行结果（同3.1）