spring bean的生命周期和事务

1.springbean的生命周期

从下图可以看到bean的生命周期大概的分成5部分，
1.先实例化bean，实例化前处理+无参构造方法+实例化后处理器+属性设置
2.如果实现了Aware接口，调用
3.调用初始化的方法，初始化前处理器+afterPropertiesSet+init-method+初始化后置处理器
4.bean的调用
5.bean的销毁

1.如果postProcessBeforeInstantiation方法返回了Object是null;那么就直接返回，调用doCreateBean方法();
2.如果postProcessBeforeInstantiation返回不为null;说明修改了bean对象;然后这个时候就立马执行postProcessAfterInitialization方法(注意这个是初始化之后的方法,也就是通过这个方法实例化了之后，直接执行初始化之后的方法;中间的实例化之后 和 初始化之前都不执行);
3.在调用postProcessAfterInitialization方法时候如果返回null;那么就直接返回，调用doCreateBean方法();(初始化之后的方法返回了null,那就需要调用doCreateBean生成对象了)
4.在调用postProcessAfterInitialization时返回不为null;那这个bean就直接返回给ioc容器了初始化之后的操作是这里面最后一个方法了；

完整的代码如下:

import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.*;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import javax.annotation.PostConstruct;

@Slf4j
public class UserInfo implements BeanNameAware, BeanFactoryAware, ApplicationContextAware, InitializingBean, DisposableBean {

    public UserInfo() {
       log.info("调用user的======>参数构造方法");
    }

    private String name;

    public String getName() {
        log.info("调用user的======>getName方法");
        return name;
    }

    public void setName(String name) {
        log.info("调用user的======>setName方法");
        this.name = name;
    }

    @PostConstruct
    public void postConstruct(){
        log.info("调用user的======>postConstruct方法");
    }

    @Override
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        log.info("调用BeanFactoryAware的======>setBeanFactory方法");
    }


    @Override
    public void setBeanName(String name) {
        log.info("调用BeanNameAware的=======>setBeanName方法");
    }

    @Override
    public void destroy() throws Exception {
        log.info("调用DisposableBean的=========>destroy方法");
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        log.info("调用InitializingBean的==========>afterPropertiesSet方法");
    }

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        log.info("调用ApplicationContextAware的============>setApplicationContext方法");
    }

    @Override
    public String toString() {
        log.info("使用User对象");
        return "User{" +
                " name='" + name + '\'' +
                '}';
    }

    private void initMethod() {
        log.info("调用user的======>initMethod方法");
    }


    private void destroyMethod() {
        log.info("调用user的======>destroyMethod方法");
    }
}

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;


@Configuration
public class UserConfig {
    
    @Bean(value = "userInfo", initMethod = "initMethod", destroyMethod = "destroyMethod")
    public UserInfo userInfo() {
        UserInfo u = new UserInfo();
        u.setName("张三");
        return u;
    }
}

import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeansException;
import org.springframework.beans.PropertyValues;
import org.springframework.beans.factory.config.InstantiationAwareBeanPostProcessor;
import org.springframework.stereotype.Component;


@Slf4j
@Component
public class TestBeanPostProcessor implements InstantiationAwareBeanPostProcessor {


    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        if ("userInfo".equals(beanName)) {
            log.info("调用BeanPostProcessor的=====>postProcessBeforeInitialization方法");
        }

        return null;
    }


    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        if ("userInfo".equals(beanName)) {
            log.info("调用BeanPostProcessor的=====>postProcessAfterInitialization方法");
        }
        return null;
    }


    @Override
    public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
        if ("userInfo".equals(beanName)) {
            log.info("调用InstantiationAwareBeanPostProcessor的=====>postProcessBeforeInstantiation方法");
        }
        return null;
    }

    @Override
    public boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {
        if ("userInfo".equals(beanName)) {
            log.info("调用InstantiationAwareBeanPostProcessor的=====>postProcessAfterInstantiation方法");
        }
        return false;
    }

    @Override
    public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) throws BeansException {
        if ("userInfo".equals(beanName)) {
            log.info("调用InstantiationAwareBeanPostProcessor的=====>postProcessProperties方法");
        }
        return null;
    }
}

import com.demo.spingdemo.UserInfo;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;

@SpringBootApplication
public class Application {

    public static void main(String[] args) {
        ConfigurableApplicationContext context = SpringApplication.run(Application.class, args);
        UserInfo user = (UserInfo) context.getBean("userInfo");
        user.toString();
        SpringApplication.exit(context);
    }
}

调用InstantiationAwareBeanPostProcessor的=====>postProcessBeforeInstantiation方法
调用user的======>参数构造方法
调用user的======>setName方法
调用InstantiationAwareBeanPostProcessor的=====>postProcessAfterInstantiation方法
调用BeanNameAware的=======>setBeanName方法
调用BeanFactoryAware的======>setBeanFactory方法
调用ApplicationContextAware的============>setApplicationContext方法
调用BeanPostProcessor的=====>postProcessBeforeInitialization方法
调用InitializingBean的==========>afterPropertiesSet方法
调用user的======>initMethod方法
调用BeanPostProcessor的=====>postProcessAfterInitialization方法
使用User对象
调用DisposableBean的=========>destroy方法
调用user的======>destroyMethod方法

spring事务

在初始化阶段org.springframework.aop.framework.autoproxy.AbstractAutoProxyCreator#postProcessAfterInitialization，对bean创建代理对象，然后返回代理对象,。默认用的JdkDynamicAopProxy

所以会调用JdkDynamicAopProxy的invoke方法，然后加载拦截器，执行事务的TransactionInterceptor的
invoke方法

开启事务（关闭自动提交）->执行目标方法->异常回滚->提交事务

参考:
https://blog.csdn.net/qq_38526573/article/details/88091702