spring底层原理

bean的生命周期

UserService.class —> 无参构造 —> 对象 —> 依赖注入 —> Bean对象

依赖注入底层原理

1. 找到对象中添加了@Autowired的属性
2. 给属性设置值

单例bean

Map<beanName,Bean对象> 单例池
getbean首先会去单例池中找，如果找不到创建并放入单例池

UserService.class —> 无参构造 —> 对象 —> 依赖注入 —> 放入Map(单例池) —> Bean对象

初始化前

UserService.class —> 无参构造 —> 对象 —> 依赖注入 —> 初始化前（a() ）—> 放入Map(单例池) —> Bean对象

class UserService{
	private Usre admin;

	@PostConstruct
	public void a(){
		//MySQL --> 管理员信息 --> User对象 ---> admin
	}
}

初始化

UserService.class —> 无参构造 —> 对象 —> 依赖注入 —> 初始化前（@PostConstruct）—> 初始化 （InitializingBean）—> 放入Map(单例池) —> Bean对象

public class UserServiceImpl  implements UserService, InitializingBean {
	private Usre admin;

    @Override
    public void afterPropertiesSet() throws Exception {
		//MySQL --> 管理员信息 --> User对象 ---> admin
    }

	protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
			throws BeanCreationException {
		......
		if (instanceWrapper == null) {
			instanceWrapper = createBeanInstance(beanName, mbd, args);
		}
		final Object bean = instanceWrapper.getWrappedInstance();

		......

		// Initialize the bean instance.
		Object exposedObject = bean;
		try {
			//填充bean，处理Autowired注解
			populateBean(beanName, mbd, instanceWrapper);
			//初始化bean
			exposedObject = initializeBean(beanName, exposedObject, mbd);
		}
		......
		return exposedObject;
	}




	protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) {
		......
		else {
			//aware回调
			invokeAwareMethods(beanName, bean);
		}
		//初始化前
		Object wrappedBean = bean;
		if (mbd == null || !mbd.isSynthetic()) {
			wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
		}

		//初始化
		try {
			invokeInitMethods(beanName, wrappedBean, mbd);
		}
		catch (Throwable ex) {
			throw new BeanCreationException(
					(mbd != null ? mbd.getResourceDescription() : null),
					beanName, "Invocation of init method failed", ex);
		}
		//初始化后
		if (mbd == null || !mbd.isSynthetic()) {
			wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
		}

		return wrappedBean;
	}




protected void invokeInitMethods(String beanName, final Object bean, @Nullable RootBeanDefinition mbd)
			throws Throwable {

		//判断是否实现 InitializingBean 接口
		boolean isInitializingBean = (bean instanceof InitializingBean);
		if (isInitializingBean && (mbd == null || !mbd.isExternallyManagedInitMethod("afterPropertiesSet"))) {
			if (logger.isTraceEnabled()) {
				logger.trace("Invoking afterPropertiesSet() on bean with name '" + beanName + "'");
			}
			//判断安全管理器是否打开
			if (System.getSecurityManager() != null) {
				try {
					AccessController.doPrivileged((PrivilegedExceptionAction<Object>) () -> {					//多态调用实现类方法
						((InitializingBean) bean).afterPropertiesSet();
						return null;
					}, getAccessControlContext());
				}
				catch (PrivilegedActionException pae) {
					throw pae.getException();
				}
			}
			else {
				//多态调用实现类方法
				((InitializingBean) bean).afterPropertiesSet();
			}
		}
		......
	}

初始化后

UserService.class —> 无参构造 —> 对象 —> 依赖注入 —> 初始化前（@PostConstruct）—> 初始化 （InitializingBean）—> 【初始化后（AOP）–>代理对象】—> 放入Map(单例池) —> Bean对象

此时代理对象会被放入到单例池中去

推断构造方法

UserService.class —> 【推断构造方法】 —> 对象 —> 依赖注入 —> 初始化前（@PostConstruct）—> 初始化 （InitializingBean）—> 初始化后（AOP）–>代理对象—> 放入Map(单例池) —> Bean对象

只有一个有参构造，spring会去找一个对象构造对象

AOP

UserService.class —> 推断构造方法 —> 普通对象 —> 依赖注入 —> 初始化前（@PostConstruct）—> 初始化 （InitializingBean）—> 初始化后（AOP）–>【代理对象—> 放入Map(单例池) 】—> Bean对象

事务原理

由于声明式事务使用的是AOP

事务失效原理

当有事务的传播行为时

解决方法一：拆类法

解决方法二：自己注入自己（spring已解决循环依赖问题）

方法三：获取当前代理对象

@configuration