Ioc容器中的依赖注入-分析 createBeanInstance源码

createBeanInstance方法的作用就是：生成Bean所包含的对象
生成的方式主常见的两种：通过工厂方法生成 第二种：也可以通过ioc容器中autowire特性注入bean对象
决定bean生成的方式是由BeanDefinitiion来指定的
下面分析createBeanInstance方法源码解析
createBeanInstance:

//下面是详细介绍了生成bean对象的源码分析，BeanWrapper是封装Bean对象的类
protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
       //校验创建的Bean实例是否可以实例化
        Class<?> beanClass = this.resolveBeanClass(mbd, beanName, new Class[0]);
        if (beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) && !mbd.isNonPublicAccessAllowed()) {
            throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Bean class isn't public, and non-public access not allowed: " + beanClass.getName());
        } else {
            //默认是使用cglib代理模式来生成BeanWrapper对象
            Supplier<?> instanceSupplier = mbd.getInstanceSupplier();
            if (instanceSupplier != null) {
                return this.obtainFromSupplier(instanceSupplier, beanName);
                //痛过工厂生成Bean
            } else if (mbd.getFactoryMethodName() != null) {
                return this.instantiateUsingFactoryMethod(beanName, mbd, args);
            } else {
                boolean resolved = false;
                boolean autowireNecessary = false;
                if (args == null) {
                    synchronized(mbd.constructorArgumentLock) {
                        if (mbd.resolvedConstructorOrFactoryMethod != null) {
                            resolved = true;
                            //这里是通过构造器来生成bean
                            autowireNecessary = mbd.constructorArgumentsResolved;
                        }
                    }
                }

                if (resolved) {
                    //通过ioc容器中autowire属性来注入
                    return autowireNecessary ? this.autowireConstructor(beanName, mbd, (Constructor[])null, (Object[])null) : this.instantiateBean(beanName, mbd);
                } else {
                    Constructor<?>[] ctors = this.determineConstructorsFromBeanPostProcessors(beanClass, beanName);
                    if (ctors == null && mbd.getResolvedAutowireMode() != 3 && !mbd.hasConstructorArgumentValues() && ObjectUtils.isEmpty(args)) {
                        ctors = mbd.getPreferredConstructors();
                        return ctors != null ? this.autowireConstructor(beanName, mbd, ctors, (Object[])null) : this.instantiateBean(beanName, mbd);
                    } else {
                        return this.autowireConstructor(beanName, mbd, ctors, args);
                    }
                }
            }
        }
    }

//生成Bean对象的方法总结：
  工厂生成   ioc容器中的Autowire属性注入     构造器方法生成  cglib代理模式生成bean对象  这四种方式

下面主要是分析cglib生成bean对象的方法解析，在这里同时需要说明的一点就是Cglib技术的功能是
cglib技术是指代一个常用的字节码生成器的类库，提供一系列的Api生成或者是转换字节码

//这个方法是默认创建BeanWrapper对象的方法，是采用Cglib的代理模式生成
protected BeanWrapper obtainFromSupplier(Supplier<?> instanceSupplier, String beanName) {
        String outerBean = (String)this.currentlyCreatedBean.get();
        this.currentlyCreatedBean.set(beanName);

        Object instance;
        try {
            instance = instanceSupplier.get();
        } finally {
            if (outerBean != null) {
                this.currentlyCreatedBean.set(outerBean);
            } else {
                this.currentlyCreatedBean.remove();
            }

        }

        if (instance == null) {
            instance = new NullBean();
        }
        
    //在这里主要是进行代理模式的生成BeanWrapper封装对象
        BeanWrapper bw = new BeanWrapperImpl(instance);
        this.initBeanWrapper(bw);
        return bw;
    }

其中使用Cglib来生成bean对象的一个默认类
SimpleinstantiationStrategy类 作用：spring生成Bean对象的默认类 生成的两种方式 一种是利用jvm中反射 一种是CGLIB来生成

//关键的方法就是instantiate来生成对象
public Object instantiate(RootBeanDefinition bd, @Nullable String beanName, BeanFactory owner) {
        if (!bd.hasMethodOverrides()) {
            Constructor constructorToUse;
            //加锁的操作
            synchronized(bd.constructorArgumentLock) {
                //使用工厂方法或者是构造器方法来生成构造器
                constructorToUse = (Constructor)bd.resolvedConstructorOrFactoryMethod;
                if (constructorToUse == null) {
                    Class<?> clazz = bd.getBeanClass();
                    //判断是否是接口，如果是就抛错异常
                    if (clazz.isInterface()) {
                        throw new BeanInstantiationException(clazz, "Specified class is an interface");
                    }

                    try {
                        if (System.getSecurityManager() != null) {
                            clazz.getClass();
                            //通过特别的构造器方法生成Object
                            constructorToUse = (Constructor)AccessController.doPrivileged(() -> {
                                return clazz.getDeclaredConstructor();
                            });
                        } else {
                            constructorToUse = clazz.getDeclaredConstructor();
                        }

                        bd.resolvedConstructorOrFactoryMethod = constructorToUse;
                    } catch (Throwable var9) {
                        throw new BeanInstantiationException(clazz, "No default constructor found", var9);
                    }
                }
            }
            
            
            //这里是通过BeanUtils类生成对象
            return BeanUtils.instantiateClass(constructorToUse, new Object[0]);
        } else {
            //通过CGLIB来生成Object对象
            return this.instantiateWithMethodInjection(bd, beanName, owner);
        }
    }

具体的CGLIB技术的具体实现与代码展示的源码分析：

public Object instantiate(@Nullable Constructor<?> ctor, Object... args) {
            Class<?> subclass = this.createEnhancedSubclass(this.beanDefinition);
            Object instance;
            if (ctor == null) {
                instance = BeanUtils.instantiateClass(subclass);
            } else {
                try {
                    Constructor<?> enhancedSubclassConstructor = subclass.getConstructor(ctor.getParameterTypes());
                    instance = enhancedSubclassConstructor.newInstance(args);
                } catch (Exception var6) {
                    throw new BeanInstantiationException(this.beanDefinition.getBeanClass(), "Failed to invoke constructor for CGLIB enhanced subclass [" + subclass.getName() + "]", var6);
                }
            }
            
            //工厂的方法的实例化的对象
            Factory factory = (Factory)instance;
           //cGlilb技术的正确使用                                                                 
            factory.setCallbacks(new Callback[]{NoOp.INSTANCE, new CglibSubclassingInstantiationStrategy.LookupOverrideMethodInterceptor(this.beanDefinition, this.owner), new CglibSubclassingInstantiationStrategy.ReplaceOverrideMethodInterceptor(this.beanDefinition, this.owner)});
            return instance;
        }