入口-何时创建bean实例对象？

第一次用的时候创建bean的实例对象，具体是调用容器类的获取bean的方法。BeanDefinition只是xml bean的映射，但是还没有真正的创建bean对象实例。

调用容器类的获取bean方法

创建bean的实例对象

一般情况都是基于反射，可以在源码打断点验证，都是基于反射创建bean实例对象。 www.cnblogs.com/javastack/p…

blog.csdn.net/dhfzhishi/a…

创建bean实例对象和注入数据的源码实现具体是哪个方法？

---

具体是哪个方法？ 1.创建bean实例的方法是createBean() 2.注入数据的方法是populateBean()

核心类SimpleInstantiationStrategy

核心步骤是

1.入口是调用容器类的获取bean方法 2.但是最终具体的创建bean实例对象的方法在SimpleInstantiationStrategy类

源码

/**
 * Simple object instantiation strategy for use in a BeanFactory.
 *
 * <p>Does not support Method Injection, although it provides hooks for subclasses
 * to override to add Method Injection support, for example by overriding methods.
 *
 * @author Rod Johnson
 * @author Juergen Hoeller
 * @since 1.1
 */
public class SimpleInstantiationStrategy implements InstantiationStrategy {
@Override
	public Object instantiate(RootBeanDefinition bd //BeanDefinition接口的实现类, @Nullable String beanName //bean名字, BeanFactory owner) {
		// Don't override the class with CGLIB if no overrides.
		if (!bd.hasMethodOverrides()) {
			Constructor<?> constructorToUse;
			synchronized (bd.constructorArgumentLock) {
				constructorToUse = (Constructor<?>) bd.resolvedConstructorOrFactoryMethod;
				if (constructorToUse == null) {
					final Class<?> clazz = bd.getBeanClass();
					if (clazz.isInterface()) {
						throw new BeanInstantiationException(clazz, "Specified class is an interface");
					}
					try {
						if (System.getSecurityManager() != null) {
							constructorToUse = AccessController.doPrivileged(
									(PrivilegedExceptionAction<Constructor<?>>) clazz::getDeclaredConstructor);
						}
						else {
							constructorToUse = clazz.getDeclaredConstructor();
						}
						bd.resolvedConstructorOrFactoryMethod = constructorToUse;
					}
					catch (Throwable ex) {
						throw new BeanInstantiationException(clazz, "No default constructor found", ex);
					}
				}
			}
			return BeanUtils.instantiateClass(constructorToUse); //基于反射创建bean实例对象
		}
		else {
			// Must generate CGLIB subclass.
			return instantiateWithMethodInjection(bd, beanName, owner); //基于动态代理cglib创建bean对象
		}
	}

/**
 * Static convenience methods for JavaBeans: for instantiating beans,
 * checking bean property types, copying bean properties, etc.
 *
 * <p>Mainly for use within the framework, but to some degree also
 * useful for application classes.
 *
 * @author Rod Johnson
 * @author Juergen Hoeller
 * @author Rob Harrop
 * @author Sam Brannen
 * @author Sebastien Deleuze
 */
public abstract class BeanUtils {
/**
	 * Convenience method to instantiate a class using the given constructor.
	 * <p>Note that this method tries to set the constructor accessible if given a
	 * non-accessible (that is, non-public) constructor, and supports Kotlin classes
	 * with optional parameters and default values.
	 * @param ctor the constructor to instantiate
	 * @param args the constructor arguments to apply (use {@code null} for an unspecified
	 * parameter if needed for Kotlin classes with optional parameters and default values)
	 * @return the new instance
	 * @throws BeanInstantiationException if the bean cannot be instantiated
	 * @see Constructor#newInstance
	 */
	public static <T> T instantiateClass(Constructor<T> ctor, Object... args) throws BeanInstantiationException {
		Assert.notNull(ctor, "Constructor must not be null");
		try {
			ReflectionUtils.makeAccessible(ctor);
			return (KotlinDetector.isKotlinReflectPresent() && KotlinDetector.isKotlinType(ctor.getDeclaringClass()) ?
					KotlinDelegate.instantiateClass(ctor, args) : ctor.newInstance(args)); //ctor.newInstance(args)，用反射里的构造器类创建实例对象
		}
		catch (InstantiationException ex) {
			throw new BeanInstantiationException(ctor, "Is it an abstract class?", ex);
		}
		catch (IllegalAccessException ex) {
			throw new BeanInstantiationException(ctor, "Is the constructor accessible?", ex);
		}
		catch (IllegalArgumentException ex) {
			throw new BeanInstantiationException(ctor, "Illegal arguments for constructor", ex);
		}
		catch (InvocationTargetException ex) {
			throw new BeanInstantiationException(ctor, "Constructor threw exception", ex.getTargetException());
		}
	}

类继承图

容器的核心步骤之一就是创建bean

何时用cglib?

1.一般情况都是基于反射创建对象 即用反射的构造器类去创建实例对象。

2.特殊情况，比如拦截器才会基于动态代理cglib去创建实例对象 为什么？因为只有拦截器才需要对bean的功能进行增强，所谓增强就是在bean的之前和之后执行一些公共的非业务功能。而动态代理的作用刚好就是用来干这个的，即拦截业务方法，在业务方法的之前和之后执行一些公共的非业务功能。说白了就是，拦截器就是动态代理，动态代理就是拦截器，都是起拦截的作用。动态代理的代理两个字的作用其实和拦截这两个字的作用完全一样。

面试

面试的时候，经常会问一些理论 1.注入数据 基于反射

2.拦截器 基于动态代理cglib

本质原因就是因为今天讲的内容。