一阳Eayon

Spring：Bean生命周期、循环依赖、JDK动态代理源码分析

Spring 源码剖析

说在前面

本章相关代码及笔记地址：飞机票
Github：Java超神之路：【Java全生态技术学习笔记，一起超神吧】
CSDN：Java超神之路：【Java全生态技术学习笔记，一起超神吧】

Spring 源码剖析
说在前面
目录
一. Bean完整的生命周期
- 1.1 BeanDefinition（Bean定义信息）
- 1.2 BeanFactoryPostProcessor（BeanFactory的后置处理器）
- 1.3 Bean实例化、填充属性、Aware接口
- 1.4 BeanPostProcessor接口 / init-method
- 1.5 destory-method销毁方法-完整的Bean声明周期结束
二. Bean的生命周期源码解析
- 2.1 准备工作
- 2.2 ClassPathXmlApplicationContext方法
- 2.3 验证
  - 2.3.1 refresh()：方法
  - 2.3.2 freshBeanFactory()：创建bean工厂并加载xml文件到BeanDefinition
  - 2.3.3 finishBeanFactoryInitialization()：完成上下文bean工厂的初始化
  - 2.3.4 getBean()：获取bean
  - 2.3.5 createBean()：创建Bean
  - 2.3.6 popelateBean()：Bean的属性赋值
  - 2.3.7 invokeAwareMethods()：执行bean所实现Aware接口方法
  - 2.3.8 beanPostProcessors的before方法
  - 2.3.9 init-method：执行初始化方法
  - 2.3.10 beanPostProcessors的after方法
- 2.4 总结
三. 循环依赖
- 3.1 什么是循环依赖？
- 3.2 测试循环依赖
  - 3.2.1 准备实体
  - 3.2.2 XML文件创建Bean并属性注入
  - 3.2.3 测试及结果分析
- 3.2 循环依赖的几种场景
- 3.3 单例的setter注入如何解决循环依赖
  - 3.3.1 为什么正常情况下Spring不会出现循环依赖问题
  - 3.3.2 Spring默认针对单例setter注入是如何解决循环依赖的
  - 3.3.3 什么是三级缓存
  - 3.3.4 源码验证
- 3.4 为什么需要三级缓存，二级行不行?
四. JDK动态代理源码分析
- 4.1 JDK动态代理的实现
- 4.2 源码分析
- 4.3 总结

一. Bean完整的生命周期

1.1 BeanDefinition（Bean定义信息）

一般我们会通过XML配置文件、注解、配置类去定义bean。当我们去加载配置文件或者配置类的时候首先会去通过BeanDefinitionReader接口的实现类去读取bean的一些定义。比如我们通过XML配置文件去进行bean定义，则会通过XMLBeanDefinitionReader进行解析并将bean的定义信息、依赖关系等保存至BeanDefinition中。

1.2 BeanFactoryPostProcessor（BeanFactory的后置处理器）

为什么要有BeanFactoryPostProcessor？它的作用是什么？
一般情况我们将bean的一些定义信息保存至BeanDefinition中之后，就可以通过BeanFactory中的反射将bean进行实例化了。

但是根据我们开发经验，我们有时候会将数据源的一些配置信息（DataSource）通过XML或者配置类进行定义。并且会将属性值通过 ${} 占位符的方式去引入外部文件赋值，如下图：

但是我们通过BeanDefinitionReader解析配置文件保存至BeanDefinition这个过程中并没有去解析${} 占位符中的值，BeanDefinition中保存的还是${jdbc.url}这样的属性值。那么这个时候我们肯定是不能直接通过BeanFactory去实例化的，而是通过BeanFactoryPostProcessor去进行后置处理，解析占位符，再通过BeanFactory去实例化。

1.3 Bean实例化、填充属性、Aware接口

通过如上步骤我们将bean的定义信息全部解析完毕保存至BeanDefinition中并通过BeanFactoryPostProcessor进行增强后，就可以进行实例化和初始化。

实例化没啥好说就是通过反射去new对象，但是此时的bean中的属性值都是空的，赋值操作是由初始化来完成的。

初始化又分为两步：

属性赋值
执行bean所实现Aware接口的方法。

属性赋值很简单我们就不说了，主要看看什么叫执行bean所实现的Aware接口方法。

执行bean所实现的Aware接口方法：
Aware接口的意义在于方便通过Spring中的Bean对象来获取其在容器中对应的相关属性值

定义一个对象并实现Aware接口

public class Teacher implements EnvironmentAware , BeanNameAware {
    /**
     * bean的一些基础属性（业务层面的属性）
     */
    private String teacherName;
    private Integer age;

    /**
     * bean在容器中的属性
     */
    private Environment environment;
    private String beanName;

    /**
     * 通过EnvironmentAware设置该Bean在容器中的环境
     * @param environment
     */
    @Override
    public void setEnvironment(Environment environment) {
        this.environment = environment;
    }

    public Environment getEnvironment() {
        return environment;
    }

    /**
     * 设置该Bean再容器中的名称
     * @param s
     */
    @Override
    public void setBeanName(String s) {
        this.beanName = s;
    }

    public String getBeanName() {
        return beanName;
    }
}

获取bean在容器中的属性值

@Test
public void test_aware(){
    ApplicationContext ac = new AnnotationConfigApplicationContext(JdbcConfiguration.class);//加载配置类
    Teacher bean = ac.getBean("teacher", Teacher.class);
    //Aware接口的意义在于方便通过Spring中的Bean对象来获取其在容器中对应的相关属性值
    String beanName = bean.getBeanName();//bean的名称
    Environment environment = bean.getEnvironment();//环境
    System.out.println(beanName);
    System.out.println(environment);
}

1.4 BeanPostProcessor接口 / init-method

如果Bean实现了BeanPostProcess接口，Spring将调用它们的postProcessBeforeInitialization方法
- （作用是在Bean实例创建成功后对进行增强处理，如对Bean进行修改，增加某个功能）
如果Bean声明了init-method方法则会进行调用，完成初始化
如果Bean实现了BeanPostProcess接口，Spring将调用它们的postProcessAfterInitialization方法
- （和执行before方法一样都是进行增强，只不过一个在初始化之前，一个在初始化方法之后)

1.5 destory-method销毁方法-完整的Bean声明周期结束

如果该Bean声明了destory-method方法则会进行调用销毁。但是对于我们高级语言java来说，我们日常很少会声明销毁，都是通过垃圾回收进行解决。

二. Bean的生命周期源码解析

2.1 准备工作

定义一个对象

public class Teacher{

    private String teacherName;
    private Integer age;

    ...省略get/set方法.....
}

通过XML文件创建Bean及注入属性

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd
       http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd">

    <bean id="teacher" class="com.eayon.entity.Teacher">
        <property name="teacherName" value="张三"></property>
        <property name="age" value="24"></property>
    </bean>
    
</beans>

测试加载Bean

@Test
public void test_load_bean(){
    ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");//加载XML
    Teacher teacher = ac.getBean("teacher", Teacher.class);
    System.out.println(teacher.getTeacherName());
    System.out.println(teacher.getAge());
}

2.2 ClassPathXmlApplicationContext方法

public ClassPathXmlApplicationContext(String[] configLocations, boolean refresh, @Nullable ApplicationContext parent) throws BeansException {
    super(parent);
    //configLocations参数也就是1.6.1准备工作中的创建Bean的XML文件
    //将XML配置文件设置到类的成员属性中方便后面的读取和加载
    this.setConfigLocations(configLocations);
    if (refresh) {
        //refresh方法刷新Spring应用的上下文，这个方法里面包含了所有Bean生命周期的方法
        this.refresh();
    }
}

2.3 验证

本节refresh方法我们只去找创建bean的方法（createBean），其他的暂时我们不去研究

2.3.1 refresh()：方法

public void refresh() throws BeansException, IllegalStateException {
    synchronized(this.startupShutdownMonitor) {
        /**
        * （不重要 知道是准备工作即可）
        * prepareRefresh()方法 做容器刷新前的准备工作：
        * 1、设置容器的启动时间
        * 2、设置活跃状态为true
        * 3、设置关闭状态为false
        * 4、获取Environment对象，并加载当前系统的属性值到Environment对象中
        * 5、准备监听器和事件的集合对象，默认为空的集合
       */    
        this.prepareRefresh();
        
        //（重要）创建BeanFactory工厂，并加载XML配置文件中的属性到当前工厂中的BeanDefinition
        ConfigurableListableBeanFactory beanFactory = this.obtainFreshBeanFactory();
        
        //（不重要）对上一步创建的beanFactory做一些初始化属性填充的准备工作
        this.prepareBeanFactory(beanFactory);

        try {
            //（不重要）源码中该方法内部为空，是留给它子类做一些扩展用的。
            this.postProcessBeanFactory(beanFactory);
            
            //（重要）invoke是执行的意思 那该方法也就是执行beanFactoryPostProcessors（beanFactory的后置处理器）
            //我们之前所说的将xml文件的属性值的占位符解析成实际的值等扩展操作都是在这里执行。
            this.invokeBeanFactoryPostProcessors(beanFactory);
            
            //（有点重要）注册beanPostProcessors，这里只是注册（准备出来）
            //按之前的流程图来说本来应该实例化对象了，但是实例化之后的初始化操作中需要beanPostProcessors，所以我们在实例化之前先将他准备出来
            //注意：这里是beanPostProcessors和上面的beanFactoryPostProcessors不一样，所以这里只是注册，真正的调用是在getBean()的时候调用
            this.registerBeanPostProcessors(beanFactory);
            
            //（不重要）为上下文初始化message源，也就是不同语言的消息体，国际化处理
            this.initMessageSource();
            
            //(有点重要)初始化事件监听多路广播器
            //如果我们现在bean生命周期不同的阶段做不同的事情我们需要通过观察者模式：监听器、监听事件、多播器来实现，所以这里先进性初始化
            this.initApplicationEventMulticaster();
            
            //（不重要）一个空方法，留给子类来初始化其他bean的
            this.onRefresh();
            
            //（有点重要）注册监听器，也属于实例化bean的一些前期准备工作
            this.registerListeners();
            
            //（重要）实例化所有的单例bean（非懒加载的bean）
            this.finishBeanFactoryInitialization(beanFactory);
            
            //最后一步：发布相应的事件。
            this.finishRefresh();
        } catch (BeansException var9) {
            if (this.logger.isWarnEnabled()) {
                this.logger.warn("Exception encountered during context initialization - cancelling refresh attempt: " + var9);
            }

            this.destroyBeans();
            this.cancelRefresh(var9);
            throw var9;
        } finally {
            this.resetCommonCaches();
        }

    }
}

2.3.2 freshBeanFactory()：创建bean工厂并加载xml文件到BeanDefinition

ConfigurableListableBeanFactory beanFactory = this.obtainFreshBeanFactory();

创建BeanFactory工厂，并加载XML配置文件中的属性到当前工厂中的BeanDefinition

prepareBeanFactory()

进入到该prepareBeanFactory方法中可以找到下图的refreshBeanFactory方法，该方法中就是通过loadBeanDefinitions(beanFactory)方法去加载BeanDefinition。

loadBeanDefinitions()

那么就是通过XmlBeanDefinitionReader()方法解析xml文件中的定义并保存到BeanDefinition中

2.3.3 finishBeanFactoryInitialization()：完成上下文bean工厂的初始化

实例化所有非懒加载的单例bean

/**
* 完成此上下文的bean工厂的初始化，
* 初始化所有剩余的单例bean。
*/
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
   // （不用看）为此上下文初始化转换服务。
   if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) &&
         beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {
      beanFactory.setConversionService(
            beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));
   }

   //  （不用看）如果beanFactory之前没有注册嵌入值解析器，则注册默认的嵌入值解析器，主要用于注解属性值的解析
   if (!beanFactory.hasEmbeddedValueResolver()) {
      beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
   }

   // （不用看）尽早初始化loadTimeAware bean，以便尽早注册它们的转换器
   String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
   for (String weaverAwareName : weaverAwareNames) {
      getBean(weaverAwareName);
   }

   //（不用看）禁止使用临时类加载器进行类型匹配
   beanFactory.setTempClassLoader(null);

   //（不用看）冻结所有bean的定义，说明注册的bean定义将不被修改或任何进一步的处理。
   beanFactory.freezeConfiguration();

   //（重要）这一步开始去真正的去实例化剩下的所有非懒加载的单例对象
   beanFactory.preInstantiateSingletons();
}

preInstantiateSingletons()

实例化之前再做一些判断和前期准备工作

public void preInstantiateSingletons() throws BeansException {
   if (logger.isTraceEnabled()) {
      logger.trace("Pre-instantiating singletons in " + this);
   }

   //将所有beanDefinition的名字创建成一个集合，其实也就是bean的名称
   List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);

   //遍历该集合。初始化所有非懒加载的单例bean
   for (String beanName : beanNames) {
       //合并父类beanDefinition
      RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
      //条件判断：是否是抽象的、是否是单例、是否是懒加载
      if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
          //判断该bean是否实现了FactoryBean接口
         if (isFactoryBean(beanName)) {
             //FACTORY_BEAN_PREFIX 是定义的常量 & 
             //也就是根据 & + beanName来获取具体的bean
            Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
            // 判断bean是否等于 FactoryBean
            if (bean instanceof FactoryBean) {
               final FactoryBean<?> factory = (FactoryBean<?>) bean;
               //判断这个beanFactory是否急切的需要实例化的标识
               boolean isEagerInit;
               if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
                  isEagerInit = AccessController.doPrivileged((PrivilegedAction<Boolean>)
                              ((SmartFactoryBean<?>) factory)::isEagerInit,
                        getAccessControlContext());
               }
               else {
                  isEagerInit = (factory instanceof SmartFactoryBean &&
                        ((SmartFactoryBean<?>) factory).isEagerInit());
               }
               //如果急切实例化则通过beanName获取实例化bean
               if (isEagerInit) {
                  getBean(beanName);
               }
            }
         }
         else {
             //如果beanName对应的bean不是FactoryBean类型，或者说没有实现FactoryBean接口，只是一个普通bean，则执行getBean()
             //getBean()是去看容器中存不存在该beanName的bean实例，有直接获取，没有则创建
            getBean(beanName);
         }
      }
   }

   //遍历beanNames，触发所有SmartInitializingSingleton的后初始化回调
   for (String beanName : beanNames) {
       //获取beanName对应的bean实例
      Object singletonInstance = getSingleton(beanName);
      if (singletonInstance instanceof SmartInitializingSingleton) {
         final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
         if (System.getSecurityManager() != null) {
            AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
               smartSingleton.afterSingletonsInstantiated();
               return null;
            }, getAccessControlContext());
         }
         else {
            smartSingleton.afterSingletonsInstantiated();
         }
      }
   }
}

2.3.4 getBean()：获取bean

getBean()

public Object getBean(String name) throws BeansException {
    //此方法才是真正实例化bean的方法，前面都是前期准备工作，也是依赖注入的主要方法
    //Spring源码中，do开头的方法才是真正干活的方法
   return doGetBean(name, null, null, false);
}

doGetBean()

此方法才是真正去调用（仅仅是调用）实例化bean的方法，前面都是前期准备工作，同时该方法也是依赖注入的主要方法

ps：Spring源码中，do开头的方法才是真正干活的方法

此方法较长，包含需多循环依赖的东西，可以暂时不看，后面会单独将，只需要找到一个createBean()方法即可

protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
      @Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {
    //beanName转换
   final String beanName = transformedBeanName(name);
   Object bean;

   // 提前检查单例缓存中是否有手动注册的单例对象，此处跟循环依赖有关
   Object sharedInstance = getSingleton(beanName);
   if (sharedInstance != null && args == null) {
      if (logger.isTraceEnabled()) {
         if (isSingletonCurrentlyInCreation(beanName)) {
            logger.trace("Returning eagerly cached instance of singleton bean '" + beanName +
                  "' that is not fully initialized yet - a consequence of a circular reference");
         }
         else {
            logger.trace("Returning cached instance of singleton bean '" + beanName + "'");
         }
      }
      //返回对象的实例，当我们的bean实现了FactoryBean接口，需要获取具体的对象的时候就需要此方法来进行获取
      bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
   }

   else {
      // 当对象都是单例的时候会尝试解决循环依赖的问题，但是原型模式下如果存在循环依赖的情况，那么直接抛出异常
      if (isPrototypeCurrentlyInCreation(beanName)) {
         throw new BeanCurrentlyInCreationException(beanName);
      }

      // 获取父容器
      BeanFactory parentBeanFactory = getParentBeanFactory();
      //如果beanDefinitionMap中也就是在所有已经加载的类中不包含beanName，那么就尝试从父容器中获取
      if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
         // Not found -> check parent.
         String nameToLookup = originalBeanName(name);
         if (parentBeanFactory instanceof AbstractBeanFactory) {
            return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
                  nameToLookup, requiredType, args, typeCheckOnly);
         }
         else if (args != null) {
            return (T) parentBeanFactory.getBean(nameToLookup, args);
         }
         else if (requiredType != null) {
            return parentBeanFactory.getBean(nameToLookup, requiredType);
         }
         else {
            return (T) parentBeanFactory.getBean(nameToLookup);
         }
      }
        //如果不是做类型检查，那么表示要创建bean，此处在集合中做一个记录
      if (!typeCheckOnly) {
         markBeanAsCreated(beanName);
      }

      try {
          //此处做了BeanDefinition对象的转换，当我们从xml文件中加载beanDefinition对象的时候，封装的对象是GenericBeanDefinition
          //此处要做类型转换，如果是子类bean的话，会合并父类的相关属性
         final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
         checkMergedBeanDefinition(mbd, beanName, args);

         //如果存在依赖的bean的话，那么则优先实例化依赖的bean
         String[] dependsOn = mbd.getDependsOn();
         if (dependsOn != null) {
             //如果存在依赖，则需要递归实例化依赖的bean
            for (String dep : dependsOn) {
               if (isDependent(beanName, dep)) {
                  throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                        "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
               }
               //注册各个bean的依赖关系，以便进行销毁
               registerDependentBean(dep, beanName);
               try {
                  getBean(dep);
               }
               catch (NoSuchBeanDefinitionException ex) {
                  throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                        "'" + beanName + "' depends on missing bean '" + dep + "'", ex);
               }
            }
         }

         //（本小节重点，前面可以不看）创建单例模式bean的实例对象
         if (mbd.isSingleton()) {
            sharedInstance = getSingleton(beanName, () -> {
               try {
                   //这里去创建bean
                  return createBean(beanName, mbd, args);
               }
               catch (BeansException ex) {
                  destroySingleton(beanName);
                  throw ex;
               }
            });
            bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
         }
        //创建原型模式的bean实例对象
         else if (mbd.isPrototype()) {
            Object prototypeInstance = null;
            try {
               beforePrototypeCreation(beanName);
               prototypeInstance = createBean(beanName, mbd, args);
            }
            finally {
               afterPrototypeCreation(beanName);
            }
            bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
         }

//===============================省略一堆无用代码====================================

   return (T) bean;
}

2.3.5 createBean()：创建Bean

createBean()

之前我们说过，spring源码中真正干活的都是带do的方法，那么我们只需要在当前方法中找到doCreateBean即可。

protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
      throws BeanCreationException {

   if (logger.isTraceEnabled()) {
      logger.trace("Creating instance of bean '" + beanName + "'");
   }
   RootBeanDefinition mbdToUse = mbd;

   //锁定class，根据设置的class属性或者根据className来解析class
   Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
   if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
      mbdToUse = new RootBeanDefinition(mbd);
      mbdToUse.setBeanClass(resolvedClass);
   }

   //验证及准备覆盖的方法
   try {
      mbdToUse.prepareMethodOverrides();
   }
   catch (BeanDefinitionValidationException ex) {
      throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
            beanName, "Validation of method overrides failed", ex);
   }

   try {
      // 给BeanPostProcessors一个机会来返回代理来替代真正的实例
      Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
      if (bean != null) {
         return bean;
      }
   }
   catch (Throwable ex) {
      throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName,
            "BeanPostProcessor before instantiation of bean failed", ex);
   }

   try {
       //（此小节重点方法）真正实际创建bean的调用
      Object beanInstance = doCreateBean(beanName, mbdToUse, args);
      if (logger.isTraceEnabled()) {
         logger.trace("Finished creating instance of bean '" + beanName + "'");
      }
      return beanInstance;
   }
   catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {
      throw ex;
   }
   catch (Throwable ex) {
      throw new BeanCreationException(
            mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", ex);
   }
}

doCreateBean()

ok！见到亲人了，终于找到真正干活的人了

protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
      throws BeanCreationException {

   // 这个beanWrapper是用来持有创建出来的bean对象的
   BeanWrapper instanceWrapper = null;
   if (mbd.isSingleton()) {
       //如果是单例对象，从factoryBean实例缓存中移除当前bean定义信息
      instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
   }
   if (instanceWrapper == null) {
       //（重要，通过反射创建实例）根据执行bean使用对应的策略创建新的实例，如：工厂方法、构造函数主动注入、简单初始化
      instanceWrapper = createBeanInstance(beanName, mbd, args);
   }
   //创建完成后的实例
   final Object bean = instanceWrapper.getWrappedInstance();
   Class<?> beanType = instanceWrapper.getWrappedClass();
   if (beanType != NullBean.class) {
      mbd.resolvedTargetType = beanType;
   }

   // 允许后置处理器postPorcessor修改合并的bean定义
   synchronized (mbd.postProcessingLock) {
      if (!mbd.postProcessed) {
         try {
             //应用MergedBeanDefinitionPostProcessor
            applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
         }
         catch (Throwable ex) {
            throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                  "Post-processing of merged bean definition failed", ex);
         }
         mbd.postProcessed = true;
      }
   }

  //==========省略一堆无用代码===========================

   return exposedObject;
}

createBeanInstance(）

protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
   //确认需要创建的bean实例的类可以实例化
   Class<?> beanClass = resolveBeanClass(mbd, beanName);

   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());
   }

   Supplier<?> instanceSupplier = mbd.getInstanceSupplier();
   if (instanceSupplier != null) {
      return obtainFromSupplier(instanceSupplier, beanName);
   }

    //如果工厂方法不为空则使用工厂方法初始化策略
   if (mbd.getFactoryMethodName() != null) {
      return instantiateUsingFactoryMethod(beanName, mbd, args);
   }

   // Shortcut when re-creating the same bean...
   boolean resolved = false;
   boolean autowireNecessary = false;
   if (args == null) {
      synchronized (mbd.constructorArgumentLock) {
          //一个类中有多个构造函数，每个构造函数都有不同的参数，所以调用前需要现根据参数锁定构造函数或对应的工厂方法
         if (mbd.resolvedConstructorOrFactoryMethod != null) {
            resolved = true;
            autowireNecessary = mbd.constructorArgumentsResolved;
         }
      }
   }
   //如果已经解析过则使用解析好的构造函数方法，不需要再次锁定
   if (resolved) {
      if (autowireNecessary) {
          //（重要）构造函数自动注入
         return autowireConstructor(beanName, mbd, null, null);
      }
      else {
          //（重要）使用默认构造函数构造
         return instantiateBean(beanName, mbd);
      }
   }

   // 需要根据参数解析构造函数
   Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
   if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR ||
         mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
      return autowireConstructor(beanName, mbd, ctors, args);
   }

   // Preferred constructors for default construction?
   ctors = mbd.getPreferredConstructors();
   if (ctors != null) {
       //（重要）构造函数自动注入
      return autowireConstructor(beanName, mbd, ctors, null);
   }

   //（重要）使用默认构造函数构造
   return instantiateBean(beanName, mbd);
}

instantiateBean()

那我们主要来看这个使用默认构造函数构造的方法即可

protected BeanWrapper instantiateBean(final String beanName, final RootBeanDefinition mbd) {
   try {
      Object beanInstance;
      final BeanFactory parent = this;
      if (System.getSecurityManager() != null) {
         beanInstance = AccessController.doPrivileged((PrivilegedAction<Object>) () ->
               getInstantiationStrategy().instantiate(mbd, beanName, parent),
               getAccessControlContext());
      }
      else {
          //getInstantiationStrategy()：获取实例化的策略
          //instantiate()：进行实例化
          //得到实例化后的bean，所以我们再来看看这个instantiate()方法是如何进行实例化
         beanInstance = getInstantiationStrategy().instantiate(mbd, beanName, parent);
      }
      BeanWrapper bw = new BeanWrapperImpl(beanInstance);
      initBeanWrapper(bw);
      return bw;
   }
   catch (Throwable ex) {
      throw new BeanCreationException(
            mbd.getResourceDescription(), beanName, "Instantiation of bean failed", ex);
   }
}

instantiate()

public Object instantiate(RootBeanDefinition bd, @Nullable String beanName, BeanFactory owner) {
   //如果需要覆盖或者动态替换的方法则使用cglig进行动态代理，因为可以在创建代理的同时将动态方法织入类中，但是如果没有需要动态改变的方法，为了方便直接反射就可以了
   if (!bd.hasMethodOverrides()) {
       //此处获取到指定的构造器对bean进行实例化
      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 {
                   //根据beanClass获取到构造器
                  constructorToUse = clazz.getDeclaredConstructor();
               }
               bd.resolvedConstructorOrFactoryMethod = constructorToUse;
            }
            catch (Throwable ex) {
               throw new BeanInstantiationException(clazz, "No default constructor found", ex);
            }
         }
      }
      //（重要）使用BeanUtils工具类根据bean的构造器进行反射实例化并返回
      return BeanUtils.instantiateClass(constructorToUse);
   }
   else {
      // Must generate CGLIB subclass.
      return instantiateWithMethodInjection(bd, beanName, owner);
   }
}

BeanUtils.instantiateClass(constructorToUse)

public static <T> T instantiateClass(Constructor<T> ctor, Object... args) throws BeanInstantiationException {
   Assert.notNull(ctor, "Constructor must not be null");
   try {
      ReflectionUtils.makeAccessible(ctor);
      if (KotlinDetector.isKotlinReflectPresent() && KotlinDetector.isKotlinType(ctor.getDeclaringClass())) {
         return KotlinDelegate.instantiateClass(ctor, args);
      }
      else {
         Class<?>[] parameterTypes = ctor.getParameterTypes();
         Assert.isTrue(args.length <= parameterTypes.length, "Can't specify more arguments than constructor parameters");
         Object[] argsWithDefaultValues = new Object[args.length];
         for (int i = 0 ; i < args.length; i++) {
            if (args[i] == null) {
               Class<?> parameterType = parameterTypes[i];
               argsWithDefaultValues[i] = (parameterType.isPrimitive() ? DEFAULT_TYPE_VALUES.get(parameterType) : null);
            }
            else {
               argsWithDefaultValues[i] = args[i];
            }
         }
         //（重要）通过bean的构造器进行实例化，到这里实例化bean的操作就结束了
         return ctor.newInstance(argsWithDefaultValues);
      }
   }
   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回到doCreateBean()方法查看创建的bean可以发现，仅仅是进行了实例化，并没有进行属性赋值

2.3.6 popelateBean()：Bean的属性赋值

在刚刚的doCreateBean()方法中我们已经获取到了实例化的bean，并且发现是没有进行属性赋值的，所以我们还在当前doCreateBean()方法中找到popelateBean()属性赋值方法。

再来看看doCreateBean()方法

protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
      throws BeanCreationException {

   // 这个beanWrapper是用来持有创建出来的bean对象的
   BeanWrapper instanceWrapper = null;
   if (mbd.isSingleton()) {
       //如果是单例对象，从factoryBean实例缓存中移除当前bean定义信息
      instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
   }
   if (instanceWrapper == null) {
       //（重要，通过反射创建实例）根据执行bean使用对应的策略创建新的实例，如：工厂方法、构造函数主动注入、简单初始化
      instanceWrapper = createBeanInstance(beanName, mbd, args);
   }
   //创建完成后的实例bean
   final Object bean = instanceWrapper.getWrappedInstance();
   Class<?> beanType = instanceWrapper.getWrappedClass();
   if (beanType != NullBean.class) {
      mbd.resolvedTargetType = beanType;
   }

   // 允许后置处理器postPorcessor修改合并的bean定义
   synchronized (mbd.postProcessingLock) {
      if (!mbd.postProcessed) {
         try {
             //应用MergedBeanDefinitionPostProcessor
            applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
         }
         catch (Throwable ex) {
            throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                  "Post-processing of merged bean definition failed", ex);
         }
         mbd.postProcessed = true;
      }
   }

    //判断当前bean是否需要提前曝光：单例&允许循环依赖&当前bean正在创建中，检测循环依赖
  boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
          isSingletonCurrentlyInCreation(beanName));
    if (earlySingletonExposure) {
       if (logger.isTraceEnabled()) {
          logger.trace("Eagerly caching bean '" + beanName +
                "' to allow for resolving potential circular references");
       }
       //为避免后期循环依赖，可以在bean初始化完成前将创建实例的ObjectFactory加入工厂
       addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
    }
    
    // 初始化bean
    Object exposedObject = bean;
    try {
        //（重要）对bean的属性进行填充，将各个属性值注入，其中。可能存在依赖于其他bean的属性，则会递归初始化依赖的bean
        //只需要知道这里进行bean的一些普通属性填充即可
       populateBean(beanName, mbd, instanceWrapper);
       //（重要）执行初始化逻辑
       exposedObject = initializeBean(beanName, exposedObject, mbd);
    }
    
    //=====================省略一些无用代码=========================

   return exposedObject;
}

该bean只去填充了一些普通属性，对于实现的Aware接口的方法不在此处进行调用。

2.3.7 invokeAwareMethods()：执行bean所实现Aware接口方法

那么对于bean实现的Aware接口的方法在何处进行调用？其实就在populateBean()方法的下面，initializeBean()当中，我们可以来看一下

initializeBean()

protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) {
   if (System.getSecurityManager() != null) {
      AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
         invokeAwareMethods(beanName, bean);
         return null;
      }, getAccessControlContext());
   }
   else {
       //（重要）执行bean所实现Aware接口的方法
      invokeAwareMethods(beanName, bean);
   }

   Object wrappedBean = bean;
   if (mbd == null || !mbd.isSynthetic()) {
       //如果bean实现了BeanPostProcessors接口则调用该before方法进行一些额外的扩展增强操作
      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()) {
       //（重要）如果bean实现了BeanPostProcessors接口则调用该after方法进行一些额外的扩展增强操作
      wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
   }

   return wrappedBean;
}

执行完invokeAwareMethods()方法后我们发现，已经执行了bean所实现的Aware接口中的方法，并完成属性的赋值。

所以也证实了bean所实现的Aware接口中的方法的调用是在bean属性填充操作后去执行的。

PS：environmen为什么没有调用赋值？是因为spring源码在前期的准备工作者屏蔽了environment，他应该在beanPostProcessors的before方法中去调用。

2.3.8 beanPostProcessors的before方法

before方法的全称其实叫：applyBeanPostProcessorsBeforeInitialization（）

before方法也在initializeBean()方法中，就在invokeAwareMethods方法的下面

如果bean实现了beanPostProcessors接口则会执行before方法做一些扩展增强操作，另外environmentAware也会在此处进行调用赋值

initializeBean()

protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) {
   if (System.getSecurityManager() != null) {
      AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
         invokeAwareMethods(beanName, bean);
         return null;
      }, getAccessControlContext());
   }
   else {
       //（重要）执行bean所实现Aware接口的方法
      invokeAwareMethods(beanName, bean);
   }

   Object wrappedBean = bean;
   if (mbd == null || !mbd.isSynthetic()) {
       //（重要）如果bean实现了BeanPostProcessors接口则调用该before方法进行一些额外的扩展增强操作
      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()) {
       //（重要）如果bean实现了BeanPostProcessors接口则调用该after方法进行一些额外的扩展增强操作
      wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
   }

   return wrappedBean;
}

我们就不进before方法当中去看了，里面无非就是获取bean所实现的BeanPostProcessors接口方法然后去执行。

2.3.9 init-method：执行初始化方法

初始化方法的全称其实叫：invokeInitMethods()

init-method方法也在initializeBean()方法中，就在before方法的下面

initializeBean()

protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) {
   if (System.getSecurityManager() != null) {
      AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
         invokeAwareMethods(beanName, bean);
         return null;
      }, getAccessControlContext());
   }
   else {
       //（重要）执行bean所实现Aware接口的方法
      invokeAwareMethods(beanName, bean);
   }

   Object wrappedBean = bean;
   if (mbd == null || !mbd.isSynthetic()) {
       //（重要）如果bean实现了BeanPostProcessors接口则调用该before方法进行一些额外的扩展增强操作
      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()) {
       //（重要）如果bean实现了BeanPostProcessors接口则调用该after方法进行一些额外的扩展增强操作
      wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
   }

   return wrappedBean;
}

我们就不进init-method方法当中去看了，里面无非就是执行用户自定义的init-method方法并且执行

2.3.10 beanPostProcessors的after方法

after方法的全称其实叫：applyBeanPostProcessorsAfterInitialization（）

after方法也在initializeBean()方法中，就在invokeInitMethods方法的下面

如果bean实现了beanPostProcessors接口则会执行after方法做一些扩展增强操作

initializeBean()

protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) {
   if (System.getSecurityManager() != null) {
      AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
         invokeAwareMethods(beanName, bean);
         return null;
      }, getAccessControlContext());
   }
   else {
       //（重要）执行bean所实现Aware接口的方法
      invokeAwareMethods(beanName, bean);
   }

   Object wrappedBean = bean;
   if (mbd == null || !mbd.isSynthetic()) {
       //（重要）如果bean实现了BeanPostProcessors接口则调用该before方法进行一些额外的扩展增强操作
      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()) {
       //（重要）如果bean实现了BeanPostProcessors接口则调用该after方法进行一些额外的扩展增强操作
      wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
   }

   return wrappedBean;
}

我们就不进after方法当中去看了，里面无非就是获取bean所实现的BeanPostProcessors接口方法然后去执行。

至此我们获得一个完整的bean对象

2.4 总结

总结我们还是按照之前画的流程图来总结吧

我们首先都会在xml中定义bean，或者直接通过注解，这里我们之说xml的情况。
首先会通过BeanDefinitionReader（根据不同的bean定义方式来选择响应的实现类）来解析xml文件并保存至BeanDefinition中。
然后由于实际开发中我们经常会在xml配置文件定义bean时使用占位符的方式引入外部属性值，所以此时保存到BeanDefinition的属性值会存在为解析的占位符的情况。这种情况我们肯定不能将他直接通过BeanFactory去反射实例化。所以我们会通过BeanFactoryPostProcessor来对bean进行实例化前的扩展增强，这其中就包含了解析占位符的操作。
得到完整的一个BeanDefinition后我们就可以通过反射的方式实例化bean，注意：实例化的都是懒加载的bean。
接着进入初始化步骤：
1. bean的属性填充
2. 如果bean实现了Aware接口中的方法则在属性填充后进行方法调用并赋值
3. 如果bean实现了BeanPostProcessor接口的before方法则进行调用增强
4. 如果bean定义了init-method方法则进行调用此初始化方法
5. 如果bean实现了BeanPostProcessor接口的after方法则进行调用增强
获取到完整的bean实例
如果bean定义了destory-method销毁方法则还会进行销毁，但一般我们都通过java的垃圾回收解决此问题

三. 循环依赖

3.1 什么是循环依赖？

循环依赖分为三种：自身依赖于自身、互相循环依赖、多组循环依赖。

但无论循环依赖的数量有多少，循环依赖的本质是一样的。就是你的完整创建依赖于我，而我的完整创建也依赖于你，但我们互相没法解耦，最终导致依赖创建失败。

所以 Spring 提供了除了构造函数注入和原型注入外的，setter循环依赖注入解决方案。那么我们也可以先来尝试下这样的依赖，如果是我们自己处理的话该怎么解决。

3.2 测试循环依赖

3.2.1 准备实体

准备两个实体A和B，A中注入B实体属性，B中注入A实体属性

//实体A
public class A {
    private B b;
    
    public void setB(B b) {
        this.b = b;
    }
}

//实体B
public class B {
    private A a;
    
    public void setA(A a) {
        this.a = a;
    }
}

3.2.2 XML文件创建Bean并属性注入

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd
       http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd">

    <bean id="a" class="com.eayon.entity.A">
        <property name="b" ref="b"></property>
    </bean>

    <bean id="b" class="com.eayon.entity.B">
        <property name="a" ref="a"></property>
    </bean>
</beans>

3.2.3 测试及结果分析

按刚刚3.1章节我们分析什么是循坏依赖时的想法，这时候我们加载XML文件他会去实例化A和B，然后抛出循环依赖的异常，那我们来测试一下

我们发现，它最后正常的实例化出了A和B实例，并没有发生循环依赖。这是为什么呢？我们可以看下一节 3.3单例的setter注入如何解决循环依赖

3.2 循环依赖的几种场景

3.3 单例的setter注入如何解决循环依赖

3.3.1 为什么正常情况下Spring不会出现循环依赖问题

还记得我们在最开始跟踪Spring源码分析bean的生命周期时有一个preInstantiateSingletons()方法，该方法再去调用getBean()方法之前有一个判断，判断当前bean是否是抽象的、单例的、懒加载的。所以我们实例化的bean都是单例非懒加载的。

重要：

那么再回头看一下3.2.2小节我们给bean属性注入的方式是set方法。

那么其实在Spring中对于单例set注入的bean是默认解决了循环依赖问题的。解决方法是实例提前暴露+三层缓存

但是前提必须是单例的setter注入，如果是多例setter注入或者是单例/多例构造器注入都是无法解决的。

3.3.2 Spring默认针对单例setter注入是如何解决循环依赖的

针对于之前我们了解的bean生命周期得出。bean的实例化操作和属性赋值（初始化）操作是分开的。我们先实例化得到一个bean的半成品然后去属性赋值，或者说注入其他实体。

那么我们首先加载实体A，第一次肯定从缓存中获取不到，所以去创建实例，然后提前暴露添加到三级缓存，当我们去初始化A属性注入时，发现需要实例化B，然后我们再从缓存中获取不到B，则取创建B实例，然后将B暴露添加到三级缓存，当我们去初始化属性注入时发现是实体A，我们则从三级缓存中获取到了实体A，并添加到了二级缓存。至此实体B初始化完成，得到一个完整的bean，最后将B添加到一级缓存。紧接着回到实体A，成功完成实体A的属性注入，初始化完成得到一个完整的bean，并将A添加到一级缓存。至此bean加载结束。完美解决了循环依赖的问题。

3.3.3 什么是三级缓存

三级缓存的定义

为什么三级缓存保存的是ObjectFactory对象？直接保存实例对象不行？

ObjectFactory对象其实是getEarlyBeanReference函数表达式，执行该表达式可以获取到bean早期的bean引用，并判断该bean是否需要代理，简单地说就是，如果一个bean我们定义了他需要代理，那么通过三级缓存的函数表达式执行获取到的就是代理对象，如果不需要代理，获取到的就是普通对象。

一级缓存：存储的是完整实例

二级缓存：存储的是半成品实例，也就是还未属性赋值的实例

三级缓存：存储的是getEarlyBeanReference()函数表达式，该表达式可以获取到bean早期的bean引用，并判断该bean是否需要代理，最终返回代理对象或普通对象

为什么要三级缓存，二级行不行？

所以说我们只用二级缓存行不行其实取决你到底需不需要代理对象。

如果需要代理，我们则在创建过程中其实是创建了两个bean，一个是普通bean，一个是代理bean。所以他就会在通过调用getEarlyBeanReference()函数表达式想要用你这个bean的时候，将代理bean覆盖掉普通bean，保证你这个bean的全局唯一。如果说你不需要代理，那可以，你可以不需要三级缓存，二级缓存足以

3.3.4 源码验证

我们先把之前的流程图拿过来对照着看源码

首先第一步从一级缓存中获取实例

在doGetBean()方法中调用了getSingleton()方法从缓存中（这里单指一级缓存）获取bean。获取到bean就不去创建直接返回了。

getSingleton()方法
在方法中可看到他会根据beanName先从一级缓存中获取，如果一级缓存中不存在该bean并且该bean正在被创建的话才会去二级缓存中查找。

而此时我们的bean是首次创建，所以一级缓存里肯定没有，并且bean还没有进行创建，所以当从一级缓存中获取不到bean后直接返回一个空的object

创建实例 A

紧接着上面从一级缓存中未获取到bean返回空后，我们再来看看doGetBean() 方法的后半部分

经过一系列判断及准备操作之后通过mbd（beanDefinition）判断是否是单例的。

如果是单例的则调用getSingleton()去创建bean，其中该方法有两个参数，以格式beanName，另一个是函数表达式，我们就理解传递了**createBean()**方法过去。

该getSingletion()方法主要逻辑就是，再次从一级缓存查找，找不到则调用createBean()方法去创建bean。

getSingleton()
方法的上半部分如下图

doCeateBean()

好！现在我们知道了他要去创建bean了，那我们就来看看doCreateBean()方法怎么执行的，
我们发现实例化A成功并返回了。但是注意现在还没有进行初始化，所以还没有B的依赖注入

我们再来看看 doCreateBean() 方法的下半部分

我们之前提到过，创建完bean后会将这个半成品添加到三级缓存，那么就是通过 addSingletonFactory() 实现的

addSingletonFactory()
那么该方法其实就是去将创建出来的半成品bean添加到三级缓存

注意：存入三级缓存中的value就是singletonFactory这个函数表达式。也就是上一步doCreateBean()方法中的 getEarlyBeanReference()方法。

getEarlyBeanReference方法用于获取代理对象，其实底层是通过AbstractAutoProxyCreator类的getEarlyBeanReference生成代理对象。

为什么三级缓存保存的是ObjectFactory对象？直接保存实例对象不行？

首先通过上面我们知道了getEarlyBeanReference函数表达式就是传递到addSingletonFactory()中singletonFactory参数。该表达式作用是用于获取代理对象，那其实三级缓存存的是getEarlyBeanReference函数表达式 也可以理解为bean的代理对象。那为什么不能直接保存实例对象呢？因为假如你想对添加到三级缓存中的实例对象进行增强，直接用实例对象是行不通的。所以我们需要保存代理对象。

populateBean() 属性赋值-依赖注入

上面我们将半成品bean添加到三级缓存后，我们返回doCreateBean方法。将bean添加到三级缓存后，这时需要给bean进行初始化，也就是属性赋值依赖注入了。

关键的方法就在populateBean()。

那我们进入populateBean()方法看一下，由于该方法前面都是一些判断和预备操作，我们直接找到该方法最后面调用applyPropertyValues()方法查看如何进行属性注入

applyPropertyValues()

那么这时候我们其实是给A对象去进行属性赋值，那么需要注入的属性就是B，需要注入的属性值也就是B对象再运行时bean的引用

那么再次调用resolveValueIfNecessary()方法进行属性值处理

resolveValueIfNecessary()

resolveReference()
很明显，这个时候我们需要给A实体的属性b赋值，所以他这里调用了getBean()方法去容器中找B实例，我们知道getBean()方法会调用doGetBean()方法，doGetBean()方法中会去一级缓存中查找bean，找不到则去创建。那我们继续往下看看doGetBean()

doGetBean()

既然缓存没有那就实例化b呗，继续看该方法的后半段，他就去调用了getSingleton()方法再次从一级缓存中获取b实例，获取不到就去调用createBean()方法创建

getSingleton()

doCreateBean()
我们不看createBean()了直接看doCreateBean()

addSingletonFactory()

populateBean()
创建完b实例的半成品并添加到三级缓存之后，我们返回doCreateBean()方法找到给实例b进行属性赋值操作。

那进入方法看一下，找到applyPropertyValues()方法

applyPropertyValues()

resolveValueIfNecessary()

resolveReference()

doGetBean()

getSingleton()

该函数表达式其实就是getEarlyBeanReference()方法，然后获取到A实例，注意这个A实例此时是个半成品并没有给b属性赋值

doGetBean()
这时我们回到给B实例属性赋值的方法

getSingleton()
现在我们已经将B实例创建好也初始化好了，现在我们返回到了getSingleton()方法，现在需要将B这个完成的对象添加到一级缓存

添加到一级缓存

doCreateBean()
这时我们返回到创建A实例的doCreateBean()方法，此时实例A的属性赋值也全部完成

getSingleton()
现在我们已经将A实例创建好也初始化好了，现在我们返回到了getSingleton()方法，现在需要将A这个完成的对象添加到一级缓存


由于后面太乱了截图太多不方便，所以就不继续走源码了，但是大概的逻辑大家应该都清楚了。

我们将实例A的属性值b赋值完后添加到一级缓存之后，我们就可以从一级缓存获取到实例A，最后完成整个对象的创建。

3.4 为什么需要三级缓存，二级行不行?

一级缓存：存储的是完整实例

二级缓存：存储的是半成品实例，也就是还未属性赋值的实例

三级缓存：存储的是getEarlyBeanReference()函数表达式，该表达式可以获取到bean早期的bean引用，并判断该bean是否需要代理，最终返回代理对象或普通对象

getEarlyBeanReference函数表达式，执行该表达式可以获取到bean早期的bean引用，并判断该bean是否需要代理，简单地说就是，如果一个bean我们定义了他需要代理，那么通过三级缓存的函数表达式执行获取到的就是代理对象，如果不需要代理，获取到的就是普通对象。

所以说我们只用二级缓存行不行其实取决你到底需不需要代理对象。

四. JDK动态代理源码分析

4.1 JDK动态代理的实现

需要动态代理的接口

/**
 * 需要动态代理的接口
 */
public interface Movie {

    void player();

    void speak();
}

需要动态代理的接口的真实实现

/**
 * 需要动态代理接口的真实实现
 */
public class RealMovie implements Movie {

    @Override
    public void player() {
        System.out.println("看个电影");
    }

    @Override
    public void speak() {
        System.out.println("说句话");
    }
}

动态代理处理器

/**
 * 动态代理处理类
 */
public class MyInvocationHandler implements InvocationHandler {

    //需要动态代理接口的真实实现类
    private Object object;

    //通过构造方法去给需要动态代理接口的真实实现类赋值
    public MyInvocationHandler(Object object) {
        this.object = object;
    }


    /**
     * 对真实实现的目标方法进行增强
     * 当代理对象调用真实实现类的方法时，就会执行动态代理处理器中的该invoke方法
     *
     * @param proxy  生成的代理对象
     * @param method 代理对象调用的方法
     * @param args   调用的方法中的参数
     * @return
     * @throws Throwable
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //方法增强
        System.out.println("卖爆米花");

        //object是真实实现，args是调用方法的参数
        //当代理对象调用真实实现的方法，那么这里就会将真实实现和方法参数传递过去，去调用真实实现的方法
        method.invoke(object,args);

        //方法增强
        System.out.println("扫地");
        return null;
    }
}

创建代理对象

public class DynamicProxyTest {

    public static void main(String[] args) {
        // 保存生成的代理类的字节码文件
        //由于设置sun.misc.ProxyGenerator.saveGeneratedFiles 的值为true,所以代理类的字节码内容保存在了项目根目录下，文件名为$Proxy0.class
        System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");

        //需要动态代理接口的真实实现
        RealMovie realMovie = new RealMovie();
        //动态代理处理类
        MyInvocationHandler handler = new MyInvocationHandler(realMovie);
        //获取动态代理对象
        //第一个参数：真实实现的类加载器
        //第二个参数：真实实现类它所实现的所有接口的数组
        //第三个参数：动态代理处理器
        Movie movie = (Movie) Proxy.newProxyInstance(realMovie.getClass().getClassLoader(),
                realMovie.getClass().getInterfaces(),
                handler);
        movie.player();

    }

}

结果

由于设置 sun.misc.ProxyGenerator.saveGeneratedFiles 的值为true,所以代理类的字节码内容保存在了项目根目录下，文件名为$Proxy0.class

生成的代理对象字节码文件

public final class $Proxy0 extends Proxy implements Movie {
    private static Method m1;
    private static Method m3;
    private static Method m2;
    private static Method m4;
    private static Method m0;
    
    static {
        try {
            m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
            m3 = Class.forName("com.eayon.dynamic.Movie").getMethod("player");
            m2 = Class.forName("java.lang.Object").getMethod("toString");
            m4 = Class.forName("com.eayon.dynamic.Movie").getMethod("speak");
            m0 = Class.forName("java.lang.Object").getMethod("hashCode");
        } catch (NoSuchMethodException var2) {
            throw new NoSuchMethodError(var2.getMessage());
        } catch (ClassNotFoundException var3) {
            throw new NoClassDefFoundError(var3.getMessage());
        }
    }

    public $Proxy0(InvocationHandler var1) throws  {
        super(var1);
    }

    /**
     * 重写被代理接口的方法
     * 因为生成的代理对象会实现被代理接口，所以我们在外部可以直接通过代理对象嗲偶哦那个被代理接口中的方法
     */
    public final void speak() throws  {
        try {
            //当外部通过代理对象调用被代理接口的方法时，其实是通过invocationHandler中的invoke()方法去调用的。
            //这个h就是invocationHandler（我们之前创建的MyInvocationHandler代理处理器）
            //this就是当前这个Proxy0代理对象
            //m4则具体要调用的方法
            super.h.invoke(this, m4, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }
    
    //与上面的speak方法同理，都是重写的被代理接口中的方法
    public final void player() throws  {
        try {
            super.h.invoke(this, m3, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final String toString() throws  {
        try {
            return (String)super.h.invoke(this, m2, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final int hashCode() throws  {
        try {
            return (Integer)super.h.invoke(this, m0, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }
    
    public final boolean equals(Object var1) throws  {
        try {
            return (Boolean)super.h.invoke(this, m1, new Object[]{var1});
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }
}

代理对象的特点

1、代理类继承了Proxy类并且代理对象和真实实现一样都实现了要代理的接口

2、重写了equals、hashCode、toString

3、有一个静态代码块，通过反射或者代理类的所有方法

4、通过invoke执行代理类中的目标方法doSomething

4.2 源码分析

从上述代码中不难看出，创建代理对象的关键代码为：

//获取动态代理对象
//第一个参数：真实实现的类加载器
//第二个参数：真实实现类它所实现的所有接口的数组
//第三个参数：动态代理处理器
Movie movie = (Movie) Proxy.newProxyInstance(realMovie.getClass().getClassLoader(),
        realMovie.getClass().getInterfaces(),
        handler);

然后当执行如下代码的时候，也就是当代理对象调用真实实现的方法时，会自动跳转到动态代理处理器的invoke方法来进行调用。

movie.player();

这是为什么呢？

那其实归根结底都在Proxy.newProxyInstance()方法创建代理对象的源码中，我们一起来看看做了些什么

Proxy.newProxyInstance()

public static Object newProxyInstance(ClassLoader loader,
                                      Class<?>[] interfaces,
                                      InvocationHandler h)
    throws IllegalArgumentException
{
    //判断代理处理器是否为空，为空则抛出空指针异常
    Objects.requireNonNull(h);
    
    //将真实实现类它所实现的所有接口的数据进行拷贝
    final Class<?>[] intfs = interfaces.clone();
    final SecurityManager sm = System.getSecurityManager();
    if (sm != null) {
        checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
    }

    //生成接口的代理对象的字节码文件（主要方法）
    Class<?> cl = getProxyClass0(loader, intfs);

    /*
     * 使用自定义的InvocationHandler作为参数，调用构造函数获取代理对象示例
     */
    try {
        if (sm != null) {
            checkNewProxyPermission(Reflection.getCallerClass(), cl);
        }

        //通过代理对象的字节码文件获取代理对象的构造器
        final Constructor<?> cons = cl.getConstructor(constructorParams);
        final InvocationHandler ih = h;
        if (!Modifier.isPublic(cl.getModifiers())) {
            AccessController.doPrivileged(new PrivilegedAction<Void>() {
                public Void run() {
                    cons.setAccessible(true);
                    return null;
                }
            });
        }
        //通过代理对象的构造器调用newInstance()反射获取代理对象实例
        return cons.newInstance(new Object[]{h});
    } catch (IllegalAccessException|InstantiationException e) {
        throw new InternalError(e.toString(), e);
    } catch (InvocationTargetException e) {
        Throwable t = e.getCause();
        if (t instanceof RuntimeException) {
            throw (RuntimeException) t;
        } else {
            throw new InternalError(t.toString(), t);
        }
    } catch (NoSuchMethodException e) {
        throw new InternalError(e.toString(), e);
    }
}

由上述代码我们发现，主要是通过getProxyClass0()方法去获取或者创建代理对象的字节码文件，通过代理对象字节码文件获取其构造器并通过反射生成代理对象实例。

那现在的重点就是如何获取或者创建代理对象的字节码文件，我们继续往下。

getProxyClass0(loader, intfs)

那其实真正生成代理对象字节码文件的是这个方法，他会传入真实实现的类加载器和他所实现的接口数组。

private static Class<?> getProxyClass0(ClassLoader loader,
                                       Class<?>... interfaces) {
    //限制真实实现所实现的接口数量不能大于65535个
    if (interfaces.length > 65535) {
        throw new IllegalArgumentException("interface limit exceeded");
    }

    // 首先从缓存中获取该接口对于的代理对象，如果有则返回，没有则通过ProxyClassFactory创建
    return proxyClassCache.get(loader, interfaces);
}

ProxyClassFactory

缓存中获取我们比较好理解，但是我们并没有在上述方法中发现proxyClassFactory

我们可以点击进入proxyClassCache.get()方法看看是如何从缓存中获取的

public V get(K key, P parameter) {
    Objects.requireNonNull(parameter);

    expungeStaleEntries();
    
    // 这里我们就理解成将真实实现的类加载器作为缓存key即可
    Object cacheKey = CacheKey.valueOf(key, refQueue);

    // 从缓存中获取代理对象
    ConcurrentMap<Object, Supplier<V>> valuesMap = map.get(cacheKey);
    if (valuesMap == null) {
        ConcurrentMap<Object, Supplier<V>> oldValuesMap
            = map.putIfAbsent(cacheKey,
                              valuesMap = new ConcurrentHashMap<>());
        if (oldValuesMap != null) {
            valuesMap = oldValuesMap;
        }
    }

    // 缓存中不存在则根据subKeyFactory.apply(key, parameter)方法进行创建
    Object subKey = Objects.requireNonNull(subKeyFactory.apply(key, parameter));
    Supplier<V> supplier = valuesMap.get(subKey);

    .......省略无用代码........
}

subKeyFactory.apply(key, parameter)
我们点击进入apply方法发现其实是BiFunction接口，我们找到它的实现

此时我们发现，我们进入的这个apply方法所在的位置是Proxy类下ProxyClassFactory这个静态内部类中
所以当缓存中没有相应的代理对象，则会调用ProxyClassFactory类的apply方法来创建代理类。

ProxyClassFactory.apply()

private static final class ProxyClassFactory
    implements BiFunction<ClassLoader, Class<?>[], Class<?>>
{
    // 生成代理对象的字节码文件名的前缀，用于组装文件名
    private static final String proxyClassNamePrefix = "$Proxy";

    // 生成代理对象字节码文件名的计数器，用于组装文件名(计数器默认从0开始)
    private static final AtomicLong nextUniqueNumber = new AtomicLong();

    @Override
    public Class<?> apply(ClassLoader loader, Class<?>[] interfaces) {

        Map<Class<?>, Boolean> interfaceSet = new IdentityHashMap<>(interfaces.length);
        for (Class<?> intf : interfaces) {
            //校验类加载器是否能通过接口名称加载该类
            Class<?> interfaceClass = null;
            try {
                interfaceClass = Class.forName(intf.getName(), false, loader);
            } catch (ClassNotFoundException e) {
            }
            if (interfaceClass != intf) {
                throw new IllegalArgumentException(
                    intf + " is not visible from class loader");
            }
            
            //校验该类是否是接口类型
            if (!interfaceClass.isInterface()) {
                throw new IllegalArgumentException(
                    interfaceClass.getName() + " is not an interface");
            }
            
            //校验接口是否重复
            if (interfaceSet.put(interfaceClass, Boolean.TRUE) != null) {
                throw new IllegalArgumentException(
                    "repeated interface: " + interfaceClass.getName());
            }
        }

        String proxyPkg = null;     // 代理对象包名
        int accessFlags = Modifier.PUBLIC | Modifier.FINAL;

        /*
         * 用于生成代理对象需要使用的包名
         * 非public接口，代理类的包名与接口的包名相同
         */
        for (Class<?> intf : interfaces) {
            int flags = intf.getModifiers();
            if (!Modifier.isPublic(flags)) {
                accessFlags = Modifier.FINAL;
                String name = intf.getName();
                int n = name.lastIndexOf('.');
                String pkg = ((n == -1) ? "" : name.substring(0, n + 1));
                if (proxyPkg == null) {
                    proxyPkg = pkg;
                } else if (!pkg.equals(proxyPkg)) {
                    throw new IllegalArgumentException(
                        "non-public interfaces from different packages");
                }
            }
        }

        if (proxyPkg == null) {
            // 如果代理接口是public修饰的，则使用默认的com.sun.proxy package作为包名
            proxyPkg = ReflectUtil.PROXY_PACKAGE + ".";
        }

        /*
         * 为代理对象生成字节码文件名
         * 文件名格式：proxyName = 之前生成的包名 + $Proxy + 当前计数器的值(计数器默认从0开始)
         * 比如 proxyName = com.sun.proxy.$Proxy0
         */
        long num = nextUniqueNumber.getAndIncrement();
        String proxyName = proxyPkg + proxyClassNamePrefix + num;

        /*
         * 真正生成代理对象字节码文件的地方
         */
         //生成代理对象字节码数组
        byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
            proxyName, interfaces, accessFlags);
        try {
            // 将代理对象字节码数组生成字节码文件，并使用类加载器将代理对象的字节码文件加载到JVM内存中
            return defineClass0(loader, proxyName,
                                proxyClassFile, 0, proxyClassFile.length);
        } catch (ClassFormatError e) {
            throw new IllegalArgumentException(e.toString());
        }
    }
}

我们可以看出它是通过ProxyGenerator.generateProxyClass()先生成代理对象字节码数组，

然后通过defineClass0()方法将代理对象的字节码数组生成字节码文件，并将该字节码通过类加载器加载到JVM中。

但是defineClass0()方法底层是通过native调用的C++，我们看不了，知道有这个事就行

ProxyGenerator.generateProxyClass(proxyName, interfaces, accessFlags)

这个方法随便看看就行，不用过多理解

public static byte[] generateProxyClass(final String var0, Class<?>[] var1, int var2) {
    ProxyGenerator var3 = new ProxyGenerator(var0, var1, var2);
    final byte[] var4 = var3.generateClassFile();
    // 是否要将生成代理对象的字节码文件保存到磁盘中
    // 该步骤也就是为什么之前我们在测试生成代理对象的时候使用System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");来将代理对象字节码文件保存下来
    if (saveGeneratedFiles) {
        AccessController.doPrivileged(new PrivilegedAction<Void>() {
            public Void run() {
                try {
                    int var1 = var0.lastIndexOf(46);
                    Path var2;
                    if (var1 > 0) {
                        Path var3 = Paths.get(var0.substring(0, var1).replace('.', File.separatorChar));
                        Files.createDirectories(var3);
                        var2 = var3.resolve(var0.substring(var1 + 1, var0.length()) + ".class");
                    } else {
                        var2 = Paths.get(var0 + ".class");
                    }

                    Files.write(var2, var4, new OpenOption[0]);
                    return null;
                } catch (IOException var4x) {
                    throw new InternalError("I/O exception saving generated file: " + var4x);
                }
            }
        });
    }

    return var4;
}

4.3 总结

创建代理对象的核心方法就是Proxy.newProxyInstance()。该方法首先会调用getProxyClass0() 从缓存中获取或者创建代理对象字节码文件，拿到代理对象字节码文件后调用getConstructor()方法获取代理对象的构造器，最后通过cons.newInstance() 根据代理对象的构造器反射生成代理对象实例并返回。

我们回过头来看getProxyClass0()方法，该方法首先判断真实实现所实现的接口数量是否超限，没有超限则proxyClassCache.get()从缓存中获取代理实例。如果缓存中没有，则去创建代理对象。那么是如何创建的呢？首先会根据：包名 + $proxy0 + 当前计数器的值(默认从0开始) 生成代理对象的名称，其次根据名称和代理对象需要实现的被代理接口去生成代理对象字节码数组。拿到字节码数组之后，就可以通过调用的native方法去生成代理对象字节码文件，最后进行返回。

你可能感兴趣的:(JavaGod,循环依赖,bean生命周期,jdk动态代理,Spring5,源码)

店群合一模式下的社区团购新发展——结合链动 2+1 模式、AI 智能名片与 S2B2C 商城小程序源码说私域人工智能小程序
摘要：本文探讨了店群合一的社区团购平台在当今商业环境中的重要性和优势。通过分析店群合一模式如何将互联网社群与线下终端紧密结合，阐述了链动2+1模式、AI智能名片和S2B2C商城小程序源码在这一模式中的应用价值。这些创新元素的结合为社区团购带来了新的机遇，提升了用户信任感、拓展了营销渠道，并实现了线上线下的完美融合。一、引言随着互联网技术的不断发展，社区团购作为一种新兴的商业模式，在满足消费者日常需
四章-32-点要素的聚合彩云飘过
本文基于腾讯课堂老胡的课《跟我学Openlayers--基础实例详解》做的学习笔记，使用的openlayers5.3.xapi。源码见1032.html，对应的官网示例https://openlayers.org/en/latest/examples/cluster.htmlhttps://openlayers.org/en/latest/examples/earthquake-clusters.
DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理 STU学生网页设计网页设计期末网页作业 html静态网页 html5期末大作业网页设计 web大作业
️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
关于城市旅游的HTML网页设计——(旅游风景云南 5页)HTML+CSS+JavaScript 二挡起步 web前端期末大作业 javascript html css 旅游风景
⛵源码获取文末联系✈Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业|游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作|HTML期末大学生网页设计作业，Web大学生网页HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScrip
libyuv之linux编译 jaronho Linux linux 运维服务器
文章目录一、下载源码二、编译源码三、注意事项1、银河麒麟系统（aarch64）（1）解决armv8-a+dotprod+i8mm指令集支持问题（2）解决armv9-a+sve2指令集支持问题一、下载源码到GitHub网站下载https://github.com/lemenkov/libyuv源码，或者用直接用git克隆到本地，如：gitclonehttps://github.com/lemenko
ArrayList 源码解析程序猿进阶 Java基础 ArrayList List java 面试性能优化架构设计 idea
ArrayList是Java集合框架中的一个动态数组实现，提供了可变大小的数组功能。它继承自AbstractList并实现了List接口，是顺序容器，即元素存放的数据与放进去的顺序相同，允许放入null元素，底层通过数组实现。除该类未实现同步外，其余跟Vector大致相同。每个ArrayList都有一个容量capacity，表示底层数组的实际大小，容器内存储元素的个数不能多于当前容量。当向容器中添
Python神器！WEB自动化测试集成工具 DrissionPage 亚丁号 python 开发语言
一、前言用requests做数据采集面对要登录的网站时，要分析数据包、JS源码，构造复杂的请求，往往还要应付验证码、JS混淆、签名参数等反爬手段，门槛较高。若数据是由JS计算生成的，还须重现计算过程，体验不好，开发效率不高。使用浏览器，可以很大程度上绕过这些坑，但浏览器运行效率不高。因此，这个库设计初衷，是将它们合而为一，能够在不同须要时切换相应模式，并提供一种人性化的使用方法，提高开发和运行效率
笋丁网页自动回复机器人V3.0.0免授权版源码希希分享软希网58soho_cn 源码资源笋丁网页自动回复机器人
笋丁网页机器人一款可设置自动回复，默认消息，调用自定义api接口的网页机器人。此程序后端语言使用Golang，内存占用最高不超过30MB，1H1G服务器流畅运行。仅支持Linux服务器部署，不支持虚拟主机，请悉知！使用自定义api功能需要有一定的建站基础。源码下载：https://download.csdn.net/download/m0_66047725/89754250更多资源下载：关注我。安
ESP32-C3入门教程网络篇⑩——基于esp_https_ota和MQTT实现开机主动升级和被动触发升级的OTA功能小康师兄 ESP32-C3入门教程 https 服务器 esp32 OTA MQTT
文章目录一、前言二、软件流程三、部分源码四、运行演示一、前言本文基于VSCodeIDE进行编程、编译、下载、运行等操作基础入门章节请查阅：ESP32-C3入门教程基础篇①——基于VSCode构建HelloWorld教程目录大纲请查阅：ESP32-C3入门教程——导读ESP32-C3入门教程网络篇⑨——基于esp_https_ota实现史上最简单的ESP32OTA远程固件升级功能二、软件流程
2023-08-11 Tom梁
当下，文玩之风可谓风靡，喜欢星月菩提的玩友越来多。有许多玩友发私信来问小编“盘玩星月菩提有没有攻略？”。所以今天给大家分享实用的星月菩提盘玩攻略，希望对大家有所帮助。一、挑选方法大家都知道挑选星月菩提的唯一标准就是密度。密度越低，上色越快；密度越高，上色就越慢。但是小编觉得高密籽更适合盘玩，虽然上色慢，但耐盘，生命周期比低密度的要长很多。那么怎么去判断它的密度呢？其实很简单，看星眼的大小、疏密、颜
【Python搞定车载自动化测试】——Python实现车载以太网DoIP刷写（含Python源码）疯狂的机器人 Python搞定车载自动化 python DoIP UDS ISO 14229 1SO 13400 Bootloader tcp/ip
系列文章目录【Python搞定车载自动化测试】系列文章目录汇总文章目录系列文章目录前言一、环境搭建1.软件环境2.硬件环境二、目录结构三、源码展示1.DoIP诊断基础函数方法2.DoIP诊断业务函数方法3.27服务安全解锁4.DoIP自动化刷写四、测试日志1.测试日志五、完整源码链接前言随着智能电动汽车行业的发展，汽车=智能终端+四个轮子，各家车企都推出了各自的OTA升级方案，本章节主要介绍如何使
进销存小程序源码 PHP网络版ERP进销存管理系统全开源可二开摸鱼小号 php
可直接源码搭建部署发布后使用：一、功能模块介绍该系统模板主要有进，销，存三个主要模板功能组成，下面将介绍各模块所对应的功能；进：需要将产品采购入库，自动生成采购明细台账同时关联财务生成付款账单；销：是指对客户的销售订单记录，汇总生成产品销售明细及回款计划；存：库存的日常盘点与统计，库存下限预警、出入库台账、库存位置等。1.进购管理采购订单：采购下单审批→由上级审批通过采购入库；采购入库：货品到货>
iOS内存管理简单理解烧烤有点辣
什么是引用计数引用计数（ReferenceCount）是一个简单而有效的管理对象生命周期的方式。当我们创建一个新对象的时候，它的引用计数为1，当有一个新的指针指向这个对象时，我们将其引用计数加1，当某个指针不再指向这个对象是，我们将其引用计数减1，当对象的引用计数变为0时，说明这个对象不再被任何指针指向了，这个时候我们就可以将对象销毁，回收内存。由于引用计数简单有效，除了Objective-C和S
计算机毕业设计PHP仓储综合管理系统（源码+程序+VUE+lw+部署） java毕设程序源码王哥 php 课程设计 vue.js
该项目含有源码、文档、程序、数据库、配套开发软件、软件安装教程。欢迎交流项目运行环境配置：phpStudy+Vscode+Mysql5.7+HBuilderX+Navicat11+Vue+Express。项目技术：原生PHP++Vue等等组成，B/S模式+Vscode管理+前后端分离等等。环境需要1.运行环境：最好是小皮phpstudy最新版，我们在这个版本上开发的。其他版本理论上也可以。2.开发
JVM源码分析之堆外内存完全解读 HeapDump性能社区
概述广义的堆外内存说到堆外内存，那大家肯定想到堆内内存，这也是我们大家接触最多的，我们在jvm参数里通常设置-Xmx来指定我们的堆的最大值，不过这还不是我们理解的Java堆，-Xmx的值是新生代和老生代的和的最大值，我们在jvm参数里通常还会加一个参数-XX:MaxPermSize来指定持久代的最大值，那么我们认识的Java堆的最大值其实是-Xmx和-XX:MaxPermSize的总和，在分代算法
html+css网页设计旅游网站首页1个页面 html+css+js网页设计 html css 旅游
html+css网页设计旅游网站首页1个页面网页作品代码简单，可使用任意HTML辑软件（如：Dreamweaver、HBuilder、Vscode、Sublime、Webstorm、Text、Notepad++等任意html编辑软件进行运行及修改编辑等操作）。获取源码1，访问该网站https://download.csdn.net/download/qq_42431718/897527112，点击
Istio pilot-discovery服务发现源码解析（1.13版本） xidianjiapei001 #Istio istio 云原生服务发现
Istiopilot-discovery服务发现介绍工作机制初始化初始化Config控制器初始化Service控制器controller初始化NamespaceServiceNodePodPilotDiscovery各组件启动流程DiscoveryServer接收Envoy的gRPC连接请求流程Config变化后向Envoy推送更新的流程总结参考介绍IstioPilot的代码分为Pilot-Dis
Kubernetes数据持久化看清所苡看轻 kubernetes(k8s)emptyDir HostPath pv pvc kubernetes
在k8s中，Volume（数据卷）存在明确的生命周期（与包含该数据卷的容器组（pod）相同）。因此Volume的生命周期比同一容器组（pod）中任意容器的生命周期要更长，不管容器重启了多少次，数据都被保留下来。当然，如果pod不存在了，数据卷自然退出了。此时，根据pod所使用的数据卷类型不同，数据可能随着数据卷的退出而删除，也可能被真正持久化，并在下次容器组重启时仍然可以使用。从根本上来说，一个数
python中文版软件下载-Python中文版编程大乐趣
python中文版是一种面向对象的解释型计算机程序设计语言。python中文版官网面向对象编程，拥有高效的高级数据结构和简单而有效的方法，其优雅的语法、动态类型、以及天然的解释能力，让它成为理想的语言。软件功能强大，简单易学，可以帮助用户快速编写代码，而且代码运行速度非常快，几乎可以支持所有的操作系统，实用性真的超高的。python中文版软件介绍：python中文版的解释器及其扩展标准库的源码和编
Kubernetes的3种数据持久化方式 Seal^_^ 【云原生】容器化与编排技术持续集成 #Kubernetes kubernetes 容器云原生 EmptyDir 面试 HostPath
Kubernetes的3种数据持久化方式1.EmptyDir2.HostPath3.PersistentVolume(PV)TheBegin点点关注，收藏不迷路Kubernetes提供了几种数据持久化方式，以满足不同场景的需求：1.EmptyDir用途：临时数据存储，Pod内容器间共享。特点：生命周期与Pod相同，Pod删除时数据也删除。2.HostPath用途：访问宿主机特定文件或目录。特点：增
Scanpy源码浅析之pp.normalize_total 何物昂
版本导入Scanpy,其版本为'1.9.1'，如果你看到的源码和下文有差异，其可能是由于版本差异。importscanpyasscsc.__version__#'1.9.1'例子函数pp.normalize_total用于Normalizecountspercell，其源代码在scanpy/preprocessing/_normalization.py我们通过一个简单例子来了解该函数主要功能:将一
基于JavaWeb开发的Java+SpringMvc+vue+element实现上海汽车博物馆平台网顺技术团队成品程序项目 java vue.js 汽车课程设计 spring boot
基于JavaWeb开发的Java+SpringMvc+vue+element实现上海汽车博物馆平台作者主页网顺技术团队欢迎点赞收藏⭐留言文末获取源码联系方式查看下方微信号获取联系方式承接各种定制系统精彩系列推荐精彩专栏推荐订阅不然下次找不到哟Java毕设项目精品实战案例《1000套》感兴趣的可以先收藏起来，还有大家在毕设选题，项目以及论文编写等相关问题都可以给我留言咨询，希望帮助更多的人文章目录基
【K8s】专题十一：Kubernetes 集群证书过期处理方法行者Sun1989 Kubernetes kubernetes 云原生容器
本文内容均来自个人笔记并重新梳理，如有错误欢迎指正！如果对您有帮助，烦请点赞、关注、转发、订阅专栏！专栏订阅入口Linux专栏|Docker专栏|Kubernetes专栏往期精彩文章【Docker】（全网首发）KylinV10下MySQL容器内存占用异常的解决方法【Docker】（全网首发）KylinV10下MySQL容器内存占用异常的解决方法（续）【Docker】MySQL源码构建Docker镜
SAP自动化-ME12批量更新最后一行的价格小九不懂SAP 自动化 SAP python
Python源码#-Begin-----------------------------------------------------------------#-Includes--------------------------------------------------------------importsys,win32com.clientimportosimporttime#-Sub
linux gcc 格式,Linux下gcc与gdb简介神奇的战士 linux gcc 格式
gcc编译器可以将C、C++等语言源程序、汇编程序编译、链接成可执行程序。gdb是GNU开发的一个Unix/Linux下强大的程序调试工具。linux下没有后缀名的概念。但gcc根据文件的后缀来区别输入文件的类别：.cC语言源代码文件.a由目标文件构成的库文件.C、.cc、.cppC++源码文件.h头文件.i经过预处理之后的C语言文件.ii经过预处理之后的C++文件.o编译后的目标文件.s汇编源码
浅谈openresty 爱编码的钓鱼佬 nginx openresty 运维
熟悉了nginx后再来看openresty，不得不说openresty是比较优秀的。对nginx和openresty的历史等在这此就不介绍了。首先对标nginx，自然有优劣一、开发难度nginx：毫无疑问nginx的开发难度比较高，需要扎实的c/c++基础，而且还需要对nginx源码比较熟悉，开发效率慢，比如实现一个类似echo的功能，至少要上百行代码。而openresty只需要一句ngx.say
Java面试笔记记录6 今天背八股了吗 java 面试笔记
1.Spring是什么？特性？有哪些模块？Spring是一个轻量级、非入侵式的控制反转Ioc和面向切面AOP的框架。特性：1.Ioc和DISpring的核心就是一个大的工厂容器，可以维护所有对象的创建和依赖关系，Spring工厂用于生成Bean，并且管理Bean的生命周期，实现高内聚低耦合的设计理念。2.AOP编程Spring提供面向切面编程，可以方便实现对程序进行权限拦截、运行监控等切面功能。3
Golang Channel PandaSkr golang
Channel解析1.Channel源码分析1.1Channel数据结构typehchanstruct{qcountuint//channel的元素数量dataqsizuint//channel循环队列长度bufunsafe.Pointer//指向循环队列的指针elemsizeuint16//元素大小closeduint32//channel是否关闭0-未关闭elemtype*_type//元素类
分享一个基于python的电子书数据采集与可视化分析 hadoop电子书数据分析与推荐系统 spark大数据毕设项目（源码、调试、LW、开题、PPT) 计算机源码社 Python项目大数据大数据 python hadoop 计算机毕业设计选题计算机毕业设计源码数据分析 spark毕设
作者：计算机源码社个人简介：本人八年开发经验，擅长Java、Python、PHP、.NET、Node.js、Android、微信小程序、爬虫、大数据、机器学习等，大家有这一块的问题可以一起交流！学习资料、程序开发、技术解答、文档报告如需要源码，可以扫取文章下方二维码联系咨询Java项目微信小程序项目Android项目Python项目PHP项目ASP.NET项目Node.js项目选题推荐项目实战|p
使用FPGA接收MIPI CSI RX信号并进行去抖动、RGB转YUV处理：FX3014 USB3.0 UVC传输与帧率控制源代码，FPGA实现MIPI CSI RX接收，去Debayer， RGB转 kVfINoSzdrt fpga开发程序人生
fpgamipicsirx接收去debayer,rgb转yuv,fx3014usb3.0uvc传输与帧率控制源代码，具体架构看图，除dphy物理层外，mipi均为源码sensorimx219mipi源码mipi4lanecsirxraw10fpgamachXO3lf-690usb3.0fx301432bityuvdatawithframesync测试模式3280*246415fps1920*108
github中多个平台共存 jackyrong github
在个人电脑上，如何分别链接比如oschina,github等库呢，一般教程之列的，默认 ssh链接一个托管的而已，下面讲解如何放两个文件 1）设置用户名和邮件地址 $ git config --global user.name "xx" $ git config --global user.email "[email protected]"
ip地址与整数的相互转换(javascript) alxw4616 JavaScript
//IP转成整型 function ip2int(ip){ var num = 0; ip = ip.split("."); num = Number(ip[0]) * 256 * 256 * 256 + Number(ip[1]) * 256 * 256 + Number(ip[2]) * 256 + Number(ip[3]); n
读书笔记-jquey+数据库+css chengxuyuancsdn html jquery oracle
1、grouping ,group by rollup, GROUP BY GROUPING SETS区别 2、$("#totalTable tbody>tr td:nth-child(" + i + ")").css({"width":tdWidth, "margin":"0px", &q
javaSE javaEE javaME == API下载 Array_06 java
oracle下载各种API文档： http://www.oracle.com/technetwork/java/embedded/javame/embed-me/documentation/javame-embedded-apis-2181154.html JavaSE文档： http://docs.oracle.com/javase/8/docs/api/ JavaEE文档： ht
shiro入门学习 cugfy java Web 框架
声明本文只适合初学者，本人也是刚接触而已，经过一段时间的研究小有收获，特来分享下希望和大家互相交流学习。首先配置我们的web.xml代码如下，固定格式，记死就成 <filter> <filter-name>shiroFilter</filter-name> &nbs
Array添加删除方法 357029540 js
刚才做项目前台删除数组的固定下标值时，删除得不是很完整，所以在网上查了下，发现一个不错的方法，也提供给需要的同学。 //给数组添加删除 Array.prototype.del = function(n){
navigation bar 更改颜色张亚雄 IO
今天郁闷了一下午，就因为objective-c默认语言是英文，我写的中文全是一些乱七八糟的样子，到不是乱码，但是，前两个自字是粗体，后两个字正常体，这可郁闷死我了，问了问大牛，人家告诉我说更改一下字体就好啦，比如改成黑体，哇塞，茅塞顿开。翻书看，发现，书上有介绍怎么更改表格中文字字体的，代码如下
unicode转换成中文 adminjun unicode 编码转换
在Java程序中总会出现\u6b22\u8fce\u63d0\u4ea4\u5fae\u535a\u641c\u7d22\u4f7f\u7528\u53cd\u9988\uff0c\u8bf7\u76f4\u63a5这个的字符，这是unicode编码，使用时有时候不会自动转换成中文就需要自己转换了使用下面的方法转换一下即可。 /** * unicode 转换成中文
一站式 Java Web 框架 firefly aijuans Java Web
Firefly是一个高性能一站式Web框架。涵盖了web开发的主要技术栈。包含Template engine、IOC、MVC framework、HTTP Server、Common tools、Log、Json parser等模块。 firefly-2.0_07修复了模版压缩对javascript单行注释的影响，并新增了自定义错误页面功能。更新日志：增加自定义系统错误页面功能
设计模式——单例模式 ayaoxinchao 设计模式
定义 Java中单例模式定义：“一个类有且仅有一个实例，并且自行实例化向整个系统提供。” 分析从定义中可以看出单例的要点有三个：一是某个类只能有一个实例；二是必须自行创建这个实例；三是必须自行向系统提供这个实例。 &nb
Javascript 多浏览器兼容性问题及解决方案 BigBird2012 JavaScript
不论是网站应用还是学习js,大家很注重ie与firefox等浏览器的兼容性问题，毕竟这两中浏览器是占了绝大多数。一、document.formName.item(”itemName”) 问题问题说明：IE下，可以使用 document.formName.item(”itemName”) 或 document.formName.elements ["elementName&quo
JUnit-4.11使用报java.lang.NoClassDefFoundError: org/hamcrest/SelfDescribing错误 bijian1013 junit4.11 单元测试
下载了最新的JUnit版本，是4.11，结果尝试使用发现总是报java.lang.NoClassDefFoundError: org/hamcrest/SelfDescribing这样的错误，上网查了一下，一般的解决方案是，换一个低一点的版本就好了。还有人说，是缺少hamcrest的包。去官网看了一下，如下发现：
[Zookeeper学习笔记之二]Zookeeper部署脚本 bit1129 zookeeper
Zookeeper伪分布式安装脚本(此脚本在一台机器上创建Zookeeper三个进程，即创建具有三个节点的Zookeeper集群。这个脚本和zookeeper的tar包放在同一个目录下，脚本中指定的名字是zookeeper的3.4.6版本，需要根据实际情况修改)： #!/bin/bash #!!!Change the name!!! #The zookeepe
【Spark八十】Spark RDD API二 bit1129 spark
coGroup package spark.examples.rddapi import org.apache.spark.{SparkConf, SparkContext} import org.apache.spark.SparkContext._ object CoGroupTest_05 { def main(args: Array[String]) { v
Linux中编译apache服务器modules文件夹缺少模块(.so)的问题 ronin47 modules
在modules目录中只有httpd.exp，那些so文件呢？我尝试在fedora core 3中安装apache 2. 当我解压了apache 2.0.54后使用configure工具并且加入了 --enable-so 或者 --enable-modules=so (两个我都试过了) 去make并且make install了。我希望在/apache2/modules/目录里有各种模块，
Java基础-克隆 BrokenDreams java基础
Java中怎么拷贝一个对象呢？可以通过调用这个对象类型的构造器构造一个新对象，然后将要拷贝对象的属性设置到新对象里面。Java中也有另一种不通过构造器来拷贝对象的方式，这种方式称为克隆。 Java提供了java.lang.
读《研磨设计模式》-代码笔记-适配器模式-Adapter bylijinnan java 设计模式
声明：本文只为方便我个人查阅和理解，详细的分析以及源代码请移步原作者的博客http://chjavach.iteye.com/ package design.pattern; /* * 适配器模式解决的主要问题是，现有的方法接口与客户要求的方法接口不一致 * 可以这样想，我们要写这样一个类（Adapter）: * 1.这个类要符合客户的要求 ---> 那显然要
HDR图像PS教程集锦&心得 cherishLC PS
HDR是指高动态范围的图像，主要原理为提高图像的局部对比度。软件有photomatix和nik hdr efex。一、教程叶明在知乎上的回答： http://www.zhihu.com/question/27418267/answer/37317792 大意是修完后直方图最好是等值直方图，方法是HDR软件调一遍，再结合不透明度和蒙版细调。二、心得 1、去除阴影部分的
maven-3.3.3 mvn archetype 列表 crabdave ArcheType
maven-3.3.3 mvn archetype 列表可以参考最新的：http://repo1.maven.org/maven2/archetype-catalog.xml [INFO] Scanning for projects... [INFO]
linux shell 中文件编码查看及转换方法 daizj shell 中文乱码 vim 文件编码
一、查看文件编码。在打开文件的时候输入:set fileencoding 即可显示文件编码格式。二、文件编码转换 1、在Vim中直接进行转换文件编码,比如将一个文件转换成utf-8格式 &
MySQL--binlog日志恢复数据 dcj3sjt126com binlog
恢复数据的重要命令如下 mysql> flush logs; 默认的日志是mysql-bin.000001，现在刷新了重新开启一个就多了一个mysql-bin.000002
数据库中数据表数据迁移方法 dcj3sjt126com sql
刚开始想想好像挺麻烦的，后来找到一种方法了，就SQL中的 INSERT 语句，不过内容是现从另外的表中查出来的，其实就是 MySQL中INSERT INTO SELECT的使用下面看看如何使用语法：MySQL中INSERT INTO SELECT的使用 1. 语法介绍有三张表a、b、c，现在需要从表b
Java反转字符串 dyy_gusi java 反转字符串
前几天看见一篇文章，说使用Java能用几种方式反转一个字符串。首先要明白什么叫反转字符串，就是将一个字符串到过来啦，比如"倒过来念的是小狗"反转过来就是”狗小是的念来过倒“。接下来就把自己能想到的所有方式记录下来了。 1、第一个念头就是直接使用String类的反转方法，对不起，这样是不行的，因为Stri
UI设计中我们为什么需要设计动效 gcq511120594 UI linux
随着国际大品牌苹果和谷歌的引领，最近越来越多的国内公司开始关注动效设计了，越来越多的团队已经意识到动效在产品用户体验中的重要性了，更多的UI设计师们也开始投身动效设计领域。但是说到底，我们到底为什么需要动效设计？或者说我们到底需要什么样的动效？做动效设计也有段时间了，于是尝试用一些案例，从产品本身出发来说说我所思考的动效设计。一、加强体验舒适度嗯，就是让用户更加爽更加爽的用
JBOSS服务部署端口冲突问题 HogwartsRow java 应用服务器 jboss server EJB3
服务端口冲突问题的解决方法，一般修改如下三个文件中的部分端口就可以了。 1、jboss5/server/default/conf/bindingservice.beans/META-INF/bindings-jboss-beans.xml 2、./server/default/deploy/jbossweb.sar/server.xml 3、.
第三章 Redis/SSDB+Twemproxy安装与使用 jinnianshilongnian ssdb reids twemproxy
目前对于互联网公司不使用Redis的很少，Redis不仅仅可以作为key-value缓存，而且提供了丰富的数据结果如set、list、map等，可以实现很多复杂的功能；但是Redis本身主要用作内存缓存，不适合做持久化存储，因此目前有如SSDB、ARDB等，还有如京东的JIMDB，它们都支持Redis协议，可以支持Redis客户端直接访问；而这些持久化存储大多数使用了如LevelDB、RocksD
ZooKeeper原理及使用 liyonghui160com
ZooKeeper是Hadoop Ecosystem中非常重要的组件，它的主要功能是为分布式系统提供一致性协调(Coordination)服务，与之对应的Google的类似服务叫Chubby。今天这篇文章分为三个部分来介绍ZooKeeper，第一部分介绍ZooKeeper的基本原理，第二部分介绍ZooKeeper
程序员解决问题的60个策略 pda158 框架工作单元测试
根本的指导方针 1. 首先写代码的时候最好不要有缺陷。最好的修复方法就是让 bug 胎死腹中。良好的单元测试强制数据库约束使用输入验证框架避免未实现的“else”条件在应用到主程序之前知道如何在孤立的情况下使用日志 2. print 语句。往往额外输出个一两行将有助于隔离问题。 3. 切换至详细的日志记录。详细的日
Create the Google Play Account sillycat Google
Create the Google Play Account Having a Google account, pay 25$, then you get your google developer account. References: http://developer.android.com/distribute/googleplay/start.html https://p
JSP三大指令 vikingwei jsp
JSP三大指令一个jsp页面中，可以有0~N个指令的定义！ 1. page --> 最复杂：<%@page language="java" info="xxx"...%> * pageEncoding和contentType： > pageEncoding：它

Spring：Bean生命周期、循环依赖、JDK动态代理源码分析

Spring 源码剖析

说在前面

目录

一. Bean完整的生命周期

1.1 BeanDefinition（Bean定义信息）

1.2 BeanFactoryPostProcessor（BeanFactory的后置处理器）

1.3 Bean实例化、填充属性、Aware接口

1.4 BeanPostProcessor接口 / init-method

1.5 destory-method销毁方法-完整的Bean声明周期结束

二. Bean的生命周期 源码解析

2.1 准备工作

2.2 ClassPathXmlApplicationContext方法

2.3 验证

2.3.1 refresh()：方法

2.3.2 freshBeanFactory()：创建bean工厂并加载xml文件到BeanDefinition

2.3.3 finishBeanFactoryInitialization()：完成上下文bean工厂的初始化

2.3.4 getBean()：获取bean

2.3.5 createBean()：创建Bean

2.3.6 popelateBean()：Bean的属性赋值

2.3.7 invokeAwareMethods()：执行bean所实现Aware接口方法

2.3.8 beanPostProcessors的before方法

2.3.9 init-method：执行初始化方法

2.3.10 beanPostProcessors的after方法

2.4 总结

三. 循环依赖

3.1 什么是循环依赖？

3.2 测试循环依赖

3.2.1 准备实体

3.2.2 XML文件创建Bean并属性注入

3.2.3 测试及结果分析

3.2 循环依赖的几种场景

3.3 单例的setter注入如何解决循环依赖

3.3.1 为什么正常情况下Spring不会出现循环依赖问题

3.3.2 Spring默认针对单例setter注入是如何解决循环依赖的

3.3.3 什么是三级缓存

3.3.4 源码验证

3.4 为什么需要三级缓存，二级行不行?

四. JDK动态代理源码分析

4.1 JDK动态代理的实现

4.2 源码分析

4.3 总结

你可能感兴趣的:(JavaGod,循环依赖,bean生命周期,jdk动态代理,Spring5,源码)

二. Bean的生命周期源码解析