学习笔记 | Spring中bean的生命周期

Spring中bean的生命周期

在Spring框架中，bean的生命周期包括了bean的实例化、属性注入、初始化、使用和销毁等多个阶段。这些阶段的顺序和方式都是由Spring容器控制的，而在这个过程中，我们可以通过实现一些特定的接口或者注解来对bean的生命周期进行干预和定制。

1、Bean的实例化

在Spring中，bean的实例化分为两种方式：一种是通过构造函数实例化，另一种是通过静态工厂方法或者实例工厂方法实例化。

1.1、构造函数实例化

在Spring中，bean的构造函数实例化是最常用的实例化方式。我们可以通过在bean的定义中指定构造函数的参数来实现bean的实例化。下面是一个例子：

<bean id="userDao" class="com.example.dao.UserDaoImpl">
    <constructor-arg index="0" value="jdbc:mysql://localhost:3306/test"/>
    <constructor-arg index="1" value="root"/>
    <constructor-arg index="2" value="123456"/>
bean>

在以上的例子中，我们指定了UserDaoImpl类的构造函数需要传入三个参数，分别是数据库连接地址、用户名和密码。当Spring容器启动时，它会自动根据bean的定义来实例化这个bean，并将参数传入构造函数中。

1.2、工厂方法实例化

除了构造函数实例化外，我们还可以通过工厂方法来实例化bean。工厂方法是一个静态方法或者实例方法，它返回一个bean的实例。下面是一个例子：

<bean id="userDao" class="com.example.dao.UserDaoFactory" factory-method="createUserDao">
    <constructor-arg index="0" value="jdbc:mysql://localhost:3306/test"/>
    <constructor-arg index="1" value="root"/>
    <constructor-arg index="2" value="123456"/>
bean>

在以上的例子中，我们指定了UserDaoFactory类的createUserDao方法来实例化bean。当Spring容器启动时，它会自动调用这个方法来实例化bean，并将参数传入方法中。

2、Bean的属性注入

在Spring中，bean的属性注入分为两种方式：一种是通过构造函数注入，另一种是通过Setter方法注入。

2.1、构造函数注入

在Spring中，我们可以通过在bean的定义中指定构造函数的参数来实现属性注入。下面是一个例子：

<bean id="userService" class="com.example.service.UserServiceImpl">
    <constructor-arg ref="userDao"/>
bean>

在以上的例子中，我们指定了UserServiceImpl类的构造函数需要传入一个UserDao类型的参数。当Spring容器启动时，它会自动根据bean的定义来实例化这个bean，并将userDao bean注入到UserServiceImpl中。

2.2、Setter方法注入

除了构造函数注入外，我们还可以通过Setter方法来实现属性注入。Setter方法是一个公共的、无参的方法，它用来设置bean的属性值。下面是一个例子：

<bean id="userService" class="com.example.service.UserServiceImpl">
    <property name="userDao" ref="userDao"/>
bean>

在以上的例子中，我们指定了UserServiceImpl类的userDao属性需要注入userDao bean。当Spring容器启动时，它会自动调用UserServiceImpl的setUserDao方法，并将userDao bean注入到UserServiceImpl中。

3、Bean的初始化

在Spring中，bean的初始化包括了两个阶段：一是bean的后置处理器，二是bean的初始化方法。

3.1、Bean后置处理器

在Spring中，我们可以通过实现BeanPostProcessor接口来定义一个bean的后置处理器。后置处理器可以在bean实例化、属性注入和初始化方法执行等多个阶段对bean进行干预和处理。下面是一个例子：

public class MyBeanPostProcessor implements BeanPostProcessor {

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("Before Initialization : " + beanName);
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("After Initialization : " + beanName);
        return bean;
    }
}

在以上的例子中，我们实现了BeanPostProcessor接口，并重写了postProcessBeforeInitialization和postProcessAfterInitialization方法。当Spring容器在bean实例化和初始化方法执行之前和之后，会自动调用这两个方法。

3.2、初始化方法

在Spring中，我们可以通过在bean的定义中指定初始化方法来定义bean的初始化逻辑。初始化方法是一个公共的、无参的方法，它用来初始化bean的状态。下面是一个例子：

<bean id="userService" class="com.example.service.UserServiceImpl" init-method="init">
    <property name="userDao" ref="userDao"/>
bean>

在以上的例子中，我们指定了UserServiceImpl类的init方法为初始化方法。当Spring容器启动时，它会自动调用这个方法来初始化bean的状态。

4、Bean的使用

在Spring中，bean的使用是最常见的操作之一。我们可以通过注入bean来使用它，也可以通过调用getBean方法来获取它。下面是一个例子：

public class UserServiceTest {

    @Autowired
    private UserService userService;

    @Test
    public void testAddUser() {
        User user = new User();
        user.setUsername("test");
        user.setPassword("123456");
        userService.addUser(user);
    }
}

在以上的例子中，我们使用了@Autowired注解来注入了一个UserService类型的bean，并调用了它的addUser方法来添加一个用户。

5、Bean的销毁

在Spring中，我们可以通过在bean的定义中指定销毁方法来定义bean的销毁逻辑。销毁方法是一个公共的、无参的方法，它用来销毁bean的状态。下面是一个例子：

<bean id="userService" class="com.example.service.UserServiceImpl" init-method="init" destroy-method="destroy">
    <property name="userDao" ref="userDao"/>
bean>

在以上的例子中，我们指定了UserServiceImpl类的destroy方法为销毁方法。当Spring容器关闭时，它会自动调用这个方法来销毁bean的状态。

好的，下面我来补充一下具体的实例。

6、实例介绍

我们假设有一个需求，需要实现一个简单的用户管理功能，包括添加用户、删除用户、查询用户等操作。为了实现这个功能，我们需要创建一个UserService接口和一个UserServiceImpl实现类，并在Spring配置文件中配置这个bean。

6.1创建包和接口

首先，我们需要创建一个com.example.service包，并在这个包下创建一个UserService接口，用来定义用户管理的方法。

package com.example.service;

import com.example.domain.User;

public interface UserService {
    void addUser(User user);
    void deleteUser(int id);
    User getUser(int id);
}

在以上的代码中，我们定义了三个方法，分别是添加用户、删除用户和查询用户。这些方法的具体实现会在UserServiceImpl类中实现。

6.2、创建实现类

接下来，我们需要创建一个UserServiceImpl实现类，并实现UserService接口中的方法。

package com.example.service;

import com.example.dao.UserDao;
import com.example.domain.User;

public class UserServiceImpl implements UserService {

    private UserDao userDao;

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

    @Override
    public void addUser(User user) {
        userDao.addUser(user);
    }

    @Override
    public void deleteUser(int id) {
        userDao.deleteUser(id);
    }

    @Override
    public User getUser(int id) {
        return userDao.getUser(id);
    }
}

在以上的代码中，我们实现了UserService接口中的三个方法，并注入了一个UserDao类型的bean，用来操作数据持久化层。

6.3、配置Spring

接下来，我们需要在Spring配置文件中配置UserService和UserDao的bean，并将它们注入到UserServiceImpl中。

<bean id="userDao" class="com.example.dao.UserDaoImpl">
    <constructor-arg index="0" value="jdbc:mysql://localhost:3306/test"/>
    <constructor-arg index="1" value="root"/>
    <constructor-arg index="2" value="123456"/>
bean>

<bean id="userService" class="com.example.service.UserServiceImpl">
    <property name="userDao" ref="userDao"/>
bean>

在以上的配置中，我们首先配置了UserDaoImpl的bean，并指定了它的构造函数需要传入三个参数。接着，我们配置了UserServiceImpl的bean，并将userDao bean注入到它的属性中。

6.4、输出测试

最后，我们可以使用JUnit进行测试，看看UserService和UserDao是否能够正常工作。

package com.example.service;

import com.example.domain.User;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = {"classpath:applicationContext.xml"})
public class UserServiceTest {

    @Autowired
    private UserService userService;

    @Test
    public void testAddUser() {
        User user = new User();
        user.setUsername("test");
        user.setPassword("123456");
        userService.addUser(user);
    }

    @Test
    public void testDeleteUser() {
        userService.deleteUser(1);
    }

    @Test
    public void testGetUser() {
        User user = userService.getUser(2);
        System.out.println(user.getUsername() + " : " + user.getPassword());
    }
}

在以上的代码中，我们使用了@Autowired注解来注入了一个UserService类型的bean，并调用了它的addUser、deleteUser和getUser方法来添加、删除和查询用户。

7总结

在Spring中，bean的生命周期包括了bean的实例化、属性注入、初始化、使用和销毁等多个阶段。我们可以通过实现一些特定的接口或者注解来对bean的生命周期进行干预和定制。在实际开发中，我们应该根据需求来选择合适的实例化、注入、初始化和销毁方式，并且注意bean的作用域和线程安全问题。

以上就是Spring中bean的生命周期的介绍，希望对大家有所帮助，如有错误还请大佬指出。