Spring 依赖注入后行为实现

主要有两种方式:

1.通过实现InitializingBean接口的afterPropertiesSet()方法,在方法中处理业务

2.在配置文件中配置init-method

实现方式1:InitializingBean

<strong>@Component
public class InitializingMyBean implements InitializingBean {
    @Autowired
	private UserRepository userRepository;
	
	@Override
	public void afterPropertiesSet() throws Exception {
		System.out.println("》》》新增用户《《《 ");
		User user =new User();
		user.setName("admin");
		user.setPassword("admin123");
		user.setAge("23");
		user.setSex("男");
		User add  = userRepository.save(user);
		if(!StringUtils.isEmpty(add)){
			System.out.println("新增用户成功！");
		}else{
			System.out.println("新增用户失败！");
		}
	}


}
</strong>

2.配置文件 ：init-method

xml version="1.0" encoding="UTF-8"?>DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN""http://www.springframework.org/dtd/spring-beans.dtd"><beans><bean name="lifeBean" class="research.spring.beanfactory.ch4.LifeCycleBean"
 init-method="init">bean>beans>
3.两种方式的区别:

实现InitializingBean接口是直接调用afterPropertiesSet方法，比通过反射调用init-method指定的方法效率相对来说要高点。但是init-method方式消除了对spring的依赖

4.注意:如果在spring初始化bean的时候，如果该bean是实现了InitializingBean接口，并且同时在配置文件中指定了init- method，

 * 系统则是先调用afterPropertiesSet方法，然后在调用init-method中指定的方法

5.InitializingBean和init-mthod同时执行的原理:

详见：org.springframework.beans.factory.support包下的抽象类AbstractAutowireCapableBeanFactory

主要处理代码如下:

		/**
		 * Give a bean a chance to react now all its properties are set,
		 * and a chance to know about its owning bean factory (this object).
		 * This means checking whether the bean implements InitializingBean or defines
		 * a custom init method, and invoking the necessary callback(s) if it does.
		 * @param beanName the bean name in the factory (for debugging purposes)
		 * @param bean the new bean instance we may need to initialize
		 * @param mbd the merged bean definition that the bean was created with
		 * (can also be {@code null}, if given an existing bean instance)
		 * @throws Throwable if thrown by init methods or by the invocation process
		 * @see #invokeCustomInitMethod
		 */
		protected void invokeInitMethods(String beanName, final Object bean, RootBeanDefinition mbd)
				throws Throwable {
            //获取当前bean是否实现了InitializingMyBean接口,如果实现了就执行afterPropertiesSet方法
			boolean isInitializingBean = (bean instanceof InitializingBean);
			if (isInitializingBean && (mbd == null || !mbd.isExternallyManagedInitMethod("afterPropertiesSet"))) {
				if (logger.isDebugEnabled()) {
					logger.debug("Invoking afterPropertiesSet() on bean with name '" + beanName + "'");
				}
				if (System.getSecurityManager() != null) {
					try {
						AccessController.doPrivileged(new PrivilegedExceptionAction<Object>() {
							@Override
							public Object run() throws Exception {
								//调用afterPropertiesSet()
								((InitializingBean) bean).afterPropertiesSet();
								return null;
							}
						}, getAccessControlContext());
					}
					catch (PrivilegedActionException pae) {
						throw pae.getException();
					}
				}
				else {
					//调用afterPropertiesSet()
					((InitializingBean) bean).afterPropertiesSet();
				}
			}
            //如果在配置文件中设置了init-mthod属性就通过反射调用init-method指定的方法
			if (mbd != null) {
				String initMethodName = mbd.getInitMethodName();
				if (initMethodName != null && !(isInitializingBean && "afterPropertiesSet".equals(initMethodName)) &&
						!mbd.isExternallyManagedInitMethod(initMethodName)) {
					invokeCustomInitMethod(beanName, bean, mbd);
				}
			}
		}

/**
		 * Invoke the specified custom init method on the given bean.
		 * Called by invokeInitMethods.
		 * <p>Can be overridden in subclasses for custom resolution of init
		 * methods with arguments.
		 * @see #invokeInitMethods
		 */
		protected void invokeCustomInitMethod(String beanName, final Object bean, RootBeanDefinition mbd) throws Throwable {
			String initMethodName = mbd.getInitMethodName();
			final Method initMethod = (mbd.isNonPublicAccessAllowed() ?
					BeanUtils.findMethod(bean.getClass(), initMethodName) :
					ClassUtils.getMethodIfAvailable(bean.getClass(), initMethodName));
			if (initMethod == null) {
				if (mbd.isEnforceInitMethod()) {
					throw new BeanDefinitionValidationException("Couldn't find an init method named '" +
							initMethodName + "' on bean with name '" + beanName + "'");
				}
				else {
					if (logger.isDebugEnabled()) {
						logger.debug("No default init method named '" + initMethodName +
								"' found on bean with name '" + beanName + "'");
					}
					// Ignore non-existent default lifecycle methods.
					return;
				}
			}

			if (logger.isDebugEnabled()) {
				logger.debug("Invoking init method  '" + initMethodName + "' on bean with name '" + beanName + "'");
			}

			if (System.getSecurityManager() != null) {
				AccessController.doPrivileged(new PrivilegedExceptionAction<Object>() {
					@Override
					public Object run() throws Exception {
						ReflectionUtils.makeAccessible(initMethod);
						return null;
					}
				});
				try {
					AccessController.doPrivileged(new PrivilegedExceptionAction<Object>() {
						@Override
						public Object run() throws Exception {
							initMethod.invoke(bean);
							return null;
						}
					}, getAccessControlContext());
				}
				catch (PrivilegedActionException pae) {
					InvocationTargetException ex = (InvocationTargetException) pae.getException();
					throw ex.getTargetException();
				}
			}
			else {
				try {
					ReflectionUtils.makeAccessible(initMethod);
					initMethod.invoke(bean);
				}
				catch (InvocationTargetException ex) {
					throw ex.getTargetException();
				}
			}
		}