Spring--bean生命周期

bean生命周期

文件结构：

方法1自定义初始化方法和销毁方法：

第一步：
编写BookDao

package com.dao;

public interface BookDao {
    void save();
}
1
2
3
4
5

编写BookDaoImpl实现类

package com.dao.Impl;

import com.dao.BookDao;

public class BookDaoImpl implements BookDao {
    @Override
    public void save() {
        System.out.println("bookDao save ...");
    }

    public void init(){
        System.out.println("初始化BookDaoImpl对象");
    }

    public void destroy(){
        System.out.println("BookDaoImpl对象已销毁");
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

第二步 ：
Spring容器的配置

        <bean id="bookDaoImpl" class="com.dao.Impl.BookDaoImpl" init-method="init" destroy-method="destroy"/>
1

第三步：
编写main方法

import com.dao.BookDao;
import com.dao.Impl.BookDaoImpl;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MainApp{
    public static void main(String[] args) {
        ApplicationContext appCon=new ClassPathXmlApplicationContext("ApplicationContext.xml");
        BookDao bookDao=(BookDaoImpl)appCon.getBean("bookDaoImpl");
        bookDao.save();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13

结果：

发现销毁方法并没有执行！！！
这是因为当程序执行完，jvm虚拟机并没有关闭Spring容器。对象没有被销毁，所以销毁方法并没有被调用需要手动关闭容器。然而在ApplicationContext类中并没有close方法

但在其子类中有，所以我们应该创建子类对象而非ApplicationContext对象。

import com.dao.BookDao;
import com.dao.Impl.BookDaoImpl;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MainApp{
    public static void main(String[] args) {
        ConfigurableApplicationContext appCon=new ClassPathXmlApplicationContext("ApplicationContext.xml");
        BookDao bookDao=(BookDaoImpl)appCon.getBean("bookDaoImpl");
        bookDao.save();
        appCon.close();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14

这样对象在容器关闭的时候就销毁了。
这里的close()方法可以替换成registerShutdownHook()方法，该方法可以放在程序的任意位置。
作用是提醒jvm在程序结束时关闭容器。

方法二要创建bean的类，实现 InitializingBean, DisposableBean这两接口重写destroy()方法和afterPropertiesSet()方法。

步骤1
BookService接口:

package com.service;

public interface BookService {
    void save();
}
1
2
3
4
5

BookServiceImpl实现类实现 InitializingBean, DisposableBean这两接口重写destroy()方法和afterPropertiesSet()方法。

package com.service.Impl;

import com.dao.BookDao;
import com.service.BookService;
import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.InitializingBean;

public class BookServiceImpl implements BookService, InitializingBean, DisposableBean {
    BookDao bookDao;

    public void setBookDao(BookDao bookDao) {
        bookDao.save();
        this.bookDao = bookDao;
    }

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

    @Override
    public void destroy() throws Exception {
        System.out.println("BookServiceImpl对象被销毁");
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("初始化BookServiceImpl对象");
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

注意afterPropertiesSet()方法是在属性设置之后执行，及在对成员赋值之后才被执行。
步骤2
Spring容器的配置

  <bean id="bookServiceImpl" class="com.service.Impl.BookServiceImpl">
                <property name="bookDao" ref="bookDaoImpl"/>
        </bean>
1
2
3

步骤3
编写main函数

import com.service.BookService;
import com.service.Impl.BookServiceImpl;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MainApp{
    public static void main(String[] args) {
        ConfigurableApplicationContext appCon=new ClassPathXmlApplicationContext("ApplicationContext.xml");
        BookService bookService=(BookServiceImpl) appCon.getBean("bookServiceImpl");
        bookService.save();
        appCon.close();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

总结:
1.通过实现InitializingBean, DisposableBean接口。可以减少我们的Spring容器的配置。
2.在销毁方法调用前应该关闭容器
3.afterPropertiesSet()方法是在属性设置之后执行，及在对成员赋值之后才被执行。