Spring中的实例生成方式及其生命周期

Posted 2020-06-28

三种实例化bean的方式
1.使用类构造器实例化

<!-- 使用类构造器实例化，class属性表示要使用的类的全限定名 -->
<bean id="userDao1" 
    class="com.tuniu.dao.daoImpl.UserDaoImpl">
</bean>

使用反射利用类的无参构造器生成实例。

2.使用静态工厂方法实例化
--配置文件：

<!-- 使用静态工厂方法实例化
    class属性表示工厂类的全限定名
    factory-method属性表示这个工厂类中用于创建实例的静态方法名（必须是static的）
-->
<bean id="userDao2" 
    class="com.tuniu.dao.StaticDaoFactory" 
    factory-method="createUserDaoInstance">
</bean>

--工厂类：

public class StaticDaoFactory {
// 方法必须声明为static的
    public static Object createUserDaoInstance() {
        System.out.println("StaticDaoFactory.createUserDaoInstance()");
        return new UserDaoImpl();
    }
}

3.使用实例化的工厂对象中的方法实例化,首先要构造出工厂实例，然后在生成实例
--配置文件：

<!-- 使用实例化工厂对象中的方法实例化
    一、定义工厂bean
    二、定义这个bean是由工厂方法创建的，其中：
        factory-bean属性表示工厂bean的名称（id或name）
        factory-method属性表示这个工厂类中用于创建实例的方法名（不能是static的）
-->
<bean id="simpleDaoFactory" 
class="com.tuniu.dao.SimpleDaoFactory"></bean>
<bean id="userDao3" 
    factory-bean="simpleDaoFactory"
    factory-method="createUserDaoInstance">
</bean>

 

--工厂类：

public class SimpleDaoFactory {
    // 方法不能声明为static的
    public static Object createUserDaoInstance() {
        System.out.println("SimpleDaoFactory.createUserDaoInstance()");
        return new UserDaoImpl();
    }
}

我们一般写代码的时候都会分层，显示层，业务层，数据访问层，显示层调用业务层，业务层调用数据访问层。

数据访问层Dao只需要一个实例，业务层Service只需要一个实例，但是action每一次访问都会生成一个实例。

------------

Bean的作用域
在Spring IoC容器中定义的bean默认只有一个实例（单例的），且默认情况下会在容器启动时初始化bean（饿汉式），但我们可以指定Bean节点的lazy-init="true"来延迟初始化bean（懒汉式），这时候，只有第一次获取bean会才初始化bean。如：
--创建类：
 

public class User {
    public User() {
        System.out.println("初始化了User...");
    }
}

--配置文件：

<!--
    scope属性：用于指定bean的生命周期 singleton：单例的，每次ac.getBean()返回的都是同一个实例.
    prototype：多例的，第次ac.getBean()返回的都是一个新的实例. 默认为singleton。
    lazy-init属性：用于指定在什么时候初始化单例的对象
    false：表示在创建ApplicationContext时就初始化本单例的对象。
    true：表示在第一次调用getBean()获取本对象时才初始化。 默认为default.
-->

<bean id="user1" class="com.tuniu.spring.User"/>

或是：

<bean id="user1" class="com.tuniu.spring.User" scope="singleton"/>

或是：

<bean id="user1" class="com.tuniu.spring.User" scope="singleton" lazy-init="default"/>

或是

<bean id="user1" class="com.tuniu.spring.User" scope="singleton" lazy-init="false"/>

以上几种配置，都是在ApplicationContext容器创建时就生成了User对象。

<bean id="user1" class="com.tuniu.spring.User" scope="singleton" lazy-init="true"/>

当lazy-init取值true时，容器创建不会创建User对象，只有在getBean()时才会创建对象，即延迟加载

对所有bean都应用延迟初始化：
方法是在根节点beans中设置属性default-lazy-init="true"，如下所示：

<beans default-lazy-init="true" ...>

 

prototype（原型，表示每次获取的都是新对象）

每次从容器获取bean都是新的对象。

<bean id="user1" class="com.tuniu.spring.User"  scope="prototype"/>

getBean()时生成实例。

 指定Bean的初始化方法和销毁方法
--创建类：

public class UserDao {
    private DataSource dataSource;

    public DataSource getDataSource() {
        return dataSource;
    }

    public void setDataSource(DataSource dataSource) {
        this.dataSource = dataSource;
    }
    /**
     * 初始化方法
     */
    public void init() {
        System.out.println("UserDao.init()  初始化方法");
    }

    /**
     * 销毁的方法
     */
    public void destroy() {
        System.out.println("UserDao.destroy()  销毁的方法");
    }
}

--配置：

<!-- 单例的对象，配置了初始化方法与销毁方法 -->
    <bean id="userDao" class="com.tuniu.spring.UserDao"
        init-method="init" destroy-method="destroy"
/>

--测试代码：

// 在ApplicationContext接口中没有定义close()方法，要想调用，就得先转为子类类型才行。
// 一定要关闭ApplicationContext，给bean配置的销毁方法才会被调用。
// 在单例时，配置的初始化与销毁方法都会被调用。
// 在多例时，只有配置的初始化才会被调用。
@Test
public void test() throws Exception {
    ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml", getClass());
    UserDao userDao = (UserDao) ac.getBean("userDao");
    System.out.println(userDao);
        
    ac.close();
}

--注意：
---如果scope属性为prototype则不受spring缓存的控制，destory方法也将不会执行（scope调为singleton时才会有效）。
---要调用ApplicationContext的close()方法才会执行destory方法（在ApplicationContext接口中没有close()方法，需要强转为具体的实现类才可以调用）