spring学习-第二讲-BeanFactory和ApplicationContext的实现

最新推荐文章于 2024-03-15 08:45:00 发布

前进人生

最新推荐文章于 2024-03-15 08:45:00 发布

阅读量350

点赞数

文章标签： spring 学习 java

本文链接：https://blog.csdn.net/key_wu/article/details/128718794

版权

前期回顾

之前，我从满老师那里学到的一些东西，BeanFactory与ApplicationContext之间的联系。以及在源码中它们是如何关联起来的，比如defaultListableBeanFactory，以及其父类上方的defaultSingleonBeanRegister，还有内部依赖的singleonObjects类之类的。还有ApplicationContext的四个接口所实现的扩展功能。

BeanFactory实现

我们了解过，beanFactory底层都是依赖于各种所配置的注解来实现的，比如@Componment，@Configuration,@Bean等等。那么这些注解是怎么在系统上应用上的，是通过什么来处理的。这个就需要好好的看看了。

代码编写

1月学的，3月才补博客，最近堕落的有点离谱了，好好梳理一下吧。

就当我自己在复习吧。从我上一小节写的博客，其实可以看出来，BeanFactory，功能较为简单，只实现了一个容器功能，就像内部的一些getBean方法。而ApplicationContext则是在内部对其进行了扩展，将BeanFactory类对象作为行为对象，来实现对应容器的功能。

那么既然BeanFactory只是一个基础容器，那么我们该怎么才能让其完成的实现一个容器功能呢？我这面用defaultListableBeanFactory来尝试一下。

package com.bo.beanfactoryapplicationcontextstudy.two;

import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.beans.factory.support.BeanDefinitionBuilder;
import org.springframework.beans.factory.support.DefaultListableBeanFactory;
import org.springframework.context.annotation.AnnotationConfigUtils;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;

/**
 * @Auther: zeroB
 * @Date: 2023/3/27 14:56
 * @Description:
 */
public class MyListableBeanFactoryTest {
    /**
     * 重新编写一下beanFactory的执行流程吧
     * @param args
     */
    public static void main(String[] args) {
        //创建一个容器，该容器是最基本的容器
        DefaultListableBeanFactory defaultListableBeanFactory = new DefaultListableBeanFactory();
        //创建bean的定义对象，这种链路方式不太明白
        BeanDefinition beanDefinition = BeanDefinitionBuilder.genericBeanDefinition(Config.class).setScope("singleton").getBeanDefinition();
        //将bean的定义对象注册至默认的bean容器中
        defaultListableBeanFactory.registerBeanDefinition("configBeaDefinition",beanDefinition);
        //为bean容器添加一些默认的处理器
        AnnotationConfigUtils.registerAnnotationConfigProcessors(defaultListableBeanFactory);
for (String beanDefinitionName : defaultListableBeanFactory.getBeanDefinitionNames()) {
            //这里我想看一下添加的beanFactory后置处理器有哪些，在这打印一下
            System.out.println("初步层面的beanDefinintionName为"+beanDefinitionName);
        }

        //添加一些后置处理器，对beanFactory名下的对象与时间进行扫描
        defaultListableBeanFactory.getBeansOfType(BeanFactoryPostProcessor.class).values().stream()
                .forEach(beanFactoryPostProcessor -> beanFactoryPostProcessor.postProcessBeanFactory(defaultListableBeanFactory));

        for (String beanDefinitionName : defaultListableBeanFactory.getBeanDefinitionNames()) {
            //这里我想看一下添加的beanFactory后置处理器有哪些，在这打印一下
            System.out.println("BeanFactory层面的beanDefinintionName为"+beanDefinitionName);
        }

        //上面的是BeanFactoryPostProcessor，现在我计划看一下BeanPostProcessor对象
        defaultListableBeanFactory.getBeansOfType(BeanPostProcessor.class).values().stream().forEach(beanPostProcessor ->
                defaultListableBeanFactory.addBeanPostProcessor(beanPostProcessor));

        for (String beanDefinitionName : defaultListableBeanFactory.getBeanDefinitionNames()) {
            //这里我想看一下添加的bean后置处理器有哪些，在这打印一下
            System.out.println("Bean层面的beanDefinintionName为"+beanDefinitionName);
        }
        //在构造前创建单例
        defaultListableBeanFactory.preInstantiateSingletons();

        //尝试获取一下各类元素(看看Bean2对象是否可以成功获取到)
        Bean2 bean2 = defaultListableBeanFactory.getBean(Bean1.class).getBean2();
        System.out.println(bean2);
        Bean3 bean3 = defaultListableBeanFactory.getBean(Bean1.class).getBean3();
        System.out.println(bean3);
    }


}


class Bean2{
    public Bean2(){
        System.out.println("对象2已经构建");
    }
}


class Bean3{
    public Bean3(){
        System.out.println("对象3已经构建");
    }
}

@Configuration
class Config{

    @Bean
    public Bean1 bean1(){
        return new Bean1();
    }

    @Bean
    public Bean2 bean2(){
        return new Bean2();
    }

    @Bean
    public Bean3 bean3(){
        return new Bean3();
    }

}

class Bean1{

    @Autowired
    private Bean2 bean2;
    @Resource
    private Bean3 bean3;

    public Bean1(){
        System.out.println("对象1发生构建");
    }

    public Bean2 getBean2() {
        return bean2;
    }

    public void setBean2(Bean2 bean2) {
        System.out.println("bean2对象填充至bean1");
        this.bean2 = bean2;
    }

    public Bean3 getBean3() {
        return bean3;
    }

    public void setBean3(Bean3 bean3) {
        System.out.println("bean3对象填充至bean1中");
        this.bean3 = bean3;
    }
}

结果分析

好久没有写这个了，写的时候竟然如何磕磕绊绊。@Compent注解没有识别（我不确定那五个bean后置处理器是否处理过这个注解），还有这段代码的流程，三类处理器，一种是默认的添加处理器，一种是BeanFactoryPostProcessor,还有一种BeanPostProcessor这种。先看看各类打印出来的结果，还是截图吧，日志过于不友好。

这里打印的，其实是beanFactory中所包含的类型定义，不是容器对象，切记。

正因为如此，所以在beanFactoryPostProcessor中加载完成后，才会开启注解扫描，并将bean1,bean2,bean3的类型定义给存放至容器中。

这里我其实没有明白，我在后续代码中加入了getBeanNamesIterator方式来将代码进行打印，发现了这些对象也被打印出来了，目前是一脸懵逼的情况，等后续好好看看吧。

源码分析

分析一下源码吧，就这几行代码，看看流程。

DefaultListableBeanFactory defaultListableBeanFactory = new DefaultListableBeanFactory();

这段代码只是创建一个基本容器，看看他上面的父类，有用的就这么一个，AbstractAutowireCapableBeanFactory。

	/**
	 * Create a new AbstractAutowireCapableBeanFactory.
	 */
	public AbstractAutowireCapableBeanFactory() {
		super();
		ignoreDependencyInterface(BeanNameAware.class);
		ignoreDependencyInterface(BeanFactoryAware.class);
		ignoreDependencyInterface(BeanClassLoaderAware.class);
		if (NativeDetector.inNativeImage()) {
			this.instantiationStrategy = new SimpleInstantiationStrategy();
		}
		else {
			this.instantiationStrategy = new CglibSubclassingInstantiationStrategy();
		}
	}

源码中这里的super()为空构造，ignoreDependencyInterface方法，则是忽略掉某个类底层的依赖注入，就像这里，是将Aware所对应的对象，在依赖注入的时候全部都过滤掉不注入。根据是否是本地文件，来创建不同的实例化策略。很明显一个是本地，另一个远程代理。

BeanDefinition beanDefinition = BeanDefinitionBuilder.genericBeanDefinition(Config.class).setScope("singleton").getBeanDefinition();

创建bean底层的类型定义，源码解析如下。

这个就是创建BeanDefinition的源码，具体流程也看不出来什么，不是核心代码，只需要知道创建了BeanDefinition就够了。

defaultListableBeanFactory.registerBeanDefinition("configBeaDefinition",beanDefinition);

将beanDefinition注册到BeanFactory的内容如下，这块其实就是在内部维护了一个BeanDefinitionMap,来存放对应的bean类定义，其它的一些判定操作不需要考虑，直接过。

@Override
	public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
			throws BeanDefinitionStoreException {

		Assert.hasText(beanName, "Bean name must not be empty");
		Assert.notNull(beanDefinition, "BeanDefinition must not be null");

		if (beanDefinition instanceof AbstractBeanDefinition) {
			try {
				((AbstractBeanDefinition) beanDefinition).validate();
			}
			catch (BeanDefinitionValidationException ex) {
				throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
						"Validation of bean definition failed", ex);
			}
		}

		BeanDefinition existingDefinition = this.beanDefinitionMap.get(beanName);
		if (existingDefinition != null) {
			if (!isAllowBeanDefinitionOverriding()) {
				throw new BeanDefinitionOverrideException(beanName, beanDefinition, existingDefinition);
			}
			else if (existingDefinition.getRole() < beanDefinition.getRole()) {
				// e.g. was ROLE_APPLICATION, now overriding with ROLE_SUPPORT or ROLE_INFRASTRUCTURE
				if (logger.isInfoEnabled()) {
					logger.info("Overriding user-defined bean definition for bean '" + beanName +
							"' with a framework-generated bean definition: replacing [" +
							existingDefinition + "] with [" + beanDefinition + "]");
				}
			}
			else if (!beanDefinition.equals(existingDefinition)) {
				if (logger.isDebugEnabled()) {
					logger.debug("Overriding bean definition for bean '" + beanName +
							"' with a different definition: replacing [" + existingDefinition +
							"] with [" + beanDefinition + "]");
				}
			}
			else {
				if (logger.isTraceEnabled()) {
					logger.trace("Overriding bean definition for bean '" + beanName +
							"' with an equivalent definition: replacing [" + existingDefinition +
							"] with [" + beanDefinition + "]");
				}
			}
			this.beanDefinitionMap.put(beanName, beanDefinition);
		}
		else {
			if (hasBeanCreationStarted()) {
				// Cannot modify startup-time collection elements anymore (for stable iteration)
				synchronized (this.beanDefinitionMap) {
					this.beanDefinitionMap.put(beanName, beanDefinition);
					List<String> updatedDefinitions = new ArrayList<>(this.beanDefinitionNames.size() + 1);
					updatedDefinitions.addAll(this.beanDefinitionNames);
					updatedDefinitions.add(beanName);
					this.beanDefinitionNames = updatedDefinitions;
					removeManualSingletonName(beanName);
				}
			}
			else {
				// Still in startup registration phase
				this.beanDefinitionMap.put(beanName, beanDefinition);
				this.beanDefinitionNames.add(beanName);
				removeManualSingletonName(beanName);
			}
			this.frozenBeanDefinitionNames = null;
		}

		if (existingDefinition != null || containsSingleton(beanName)) {
			resetBeanDefinition(beanName);
		}
		else if (isConfigurationFrozen()) {
			clearByTypeCache();
		}
	}

接下来这个就是我觉得相对比较重要的了。

AnnotationConfigUtils.registerAnnotationConfigProcessors(defaultListableBeanFactory);

添加一些默认的处理器，我们看看这些默认处理器是什么。

public static Set<BeanDefinitionHolder> registerAnnotationConfigProcessors(BeanDefinitionRegistry registry, @Nullable Object source) {
      
        DefaultListableBeanFactory beanFactory = unwrapDefaultListableBeanFactory(registry);
        //传入的beanfactory不为null的情况下，给添加一个依赖比较器，还有autowired解析器，我不太理解这个解析器含义
        if (beanFactory != null) {
            if (!(beanFactory.getDependencyComparator() instanceof AnnotationAwareOrderComparator)) {
                beanFactory.setDependencyComparator(AnnotationAwareOrderComparator.INSTANCE);
            }

            if (!(beanFactory.getAutowireCandidateResolver() instanceof ContextAnnotationAutowireCandidateResolver)) {
                beanFactory.setAutowireCandidateResolver(new ContextAnnotationAutowireCandidateResolver());
            }
        }

        Set<BeanDefinitionHolder> beanDefs = new LinkedHashSet(8);
        RootBeanDefinition def;
        //后面这里就好理解了，创建了后置处理器的类定义
        if (!registry.containsBeanDefinition("org.springframework.context.annotation.internalConfigurationAnnotationProcessor")) {
            def = new RootBeanDefinition(ConfigurationClassPostProcessor.class);
            def.setSource(source);
            beanDefs.add(registerPostProcessor(registry, def, "org.springframework.context.annotation.internalConfigurationAnnotationProcessor"));
        }

        if (!registry.containsBeanDefinition("org.springframework.context.annotation.internalAutowiredAnnotationProcessor")) {
            def = new RootBeanDefinition(AutowiredAnnotationBeanPostProcessor.class);
            def.setSource(source);
            beanDefs.add(registerPostProcessor(registry, def, "org.springframework.context.annotation.internalAutowiredAnnotationProcessor"));
        }

        if (jsr250Present && !registry.containsBeanDefinition("org.springframework.context.annotation.internalCommonAnnotationProcessor")) {
            def = new RootBeanDefinition(CommonAnnotationBeanPostProcessor.class);
            def.setSource(source);
            beanDefs.add(registerPostProcessor(registry, def, "org.springframework.context.annotation.internalCommonAnnotationProcessor"));
        }

        if (jpaPresent && !registry.containsBeanDefinition("org.springframework.context.annotation.internalPersistenceAnnotationProcessor")) {
            def = new RootBeanDefinition();

            try {
                def.setBeanClass(ClassUtils.forName("org.springframework.orm.jpa.support.PersistenceAnnotationBeanPostProcessor", AnnotationConfigUtils.class.getClassLoader()));
            } catch (ClassNotFoundException var6) {
                throw new IllegalStateException("Cannot load optional framework class: org.springframework.orm.jpa.support.PersistenceAnnotationBeanPostProcessor", var6);
            }

            def.setSource(source);
            beanDefs.add(registerPostProcessor(registry, def, "org.springframework.context.annotation.internalPersistenceAnnotationProcessor"));
        }

        if (!registry.containsBeanDefinition("org.springframework.context.event.internalEventListenerProcessor")) {
            def = new RootBeanDefinition(EventListenerMethodProcessor.class);
            def.setSource(source);
            beanDefs.add(registerPostProcessor(registry, def, "org.springframework.context.event.internalEventListenerProcessor"));
        }

        if (!registry.containsBeanDefinition("org.springframework.context.event.internalEventListenerFactory")) {
            def = new RootBeanDefinition(DefaultEventListenerFactory.class);
            def.setSource(source);
            beanDefs.add(registerPostProcessor(registry, def, "org.springframework.context.event.internalEventListenerFactory"));
        }

        return beanDefs;
    }

我第一批打印的处理器，可以看出来，就是下方这几个类。

ConfigurationClassPostProcessor

这个很明显了，就是扫描当前beanFactory容器中，自定义的BeanDefinition中的@Configuration注解，然后去看这些东西。

AutowiredAnnotationBeanPostProcessor

这个是扫描@Autowired注解的。

CommonAnnotationBeanPostProcessor

这个是扫描@Resource注解的

internalEventListenerProcessor，internalEventListenerFactory

这俩很明显可以看出来，与上一章所说的ApplicationEvent有一些关系，应该是来监听整体事件的。

defaultListableBeanFactory.getBeansOfType(BeanFactoryPostProcessor.class).values().stream()
        .forEach(beanFactoryPostProcessor -> beanFactoryPostProcessor.postProcessBeanFactory(defaultListableBeanFactory));

这一段是将beanFactory后置处理器与BeanFactory相关联，那么他与前面的处理器区别是什么，带着疑问看看源码。

看一下getBeansOfType源码的方法，跟着断点走了下，看到了在这里源码获取到的。

源码中涉及到的东西太多，主要在一个判定上，isTypeMatch(beanName, type, allowFactoryBeanInit);很明显就是判断当前容器中存放的beanName与这个type类型是否匹配。

在源码中，我们发现了beanName总共有六种结果，就是我之前AnnotationConfigUtils.registerAnnotationConfigProcessors(defaultListableBeanFactory);中获取到的6种beanDefinition。

BeanFactoryPostProcessor类型有两个结果，分别为internalConfigurationAnnotationProcessor以及internalEventListenerProcessor类型，那么根据isTypeMatch来确定，这俩是BeanFactoryPostProcessor，所以BeanFactoryPostProcessor是之前注册过的Porcessor的子集。

@Override
	@SuppressWarnings("unchecked")
	public <T> Map<String, T> getBeansOfType(
			@Nullable Class<T> type, boolean includeNonSingletons, boolean allowEagerInit) throws BeansException {

		String[] beanNames = getBeanNamesForType(type, includeNonSingletons, allowEagerInit);
		Map<String, T> result = CollectionUtils.newLinkedHashMap(beanNames.length);
		for (String beanName : beanNames) {
			try {
				Object beanInstance = getBean(beanName);
				if (!(beanInstance instanceof NullBean)) {
					result.put(beanName, (T) beanInstance);
				}
			}
			catch (BeanCreationException ex) {
				Throwable rootCause = ex.getMostSpecificCause();
				if (rootCause instanceof BeanCurrentlyInCreationException) {
					BeanCreationException bce = (BeanCreationException) rootCause;
					String exBeanName = bce.getBeanName();
					if (exBeanName != null && isCurrentlyInCreation(exBeanName)) {
						if (logger.isTraceEnabled()) {
							logger.trace("Ignoring match to currently created bean '" + exBeanName + "': " +
									ex.getMessage());
						}
						onSuppressedException(ex);
						// Ignore: indicates a circular reference when autowiring constructors.
						// We want to find matches other than the currently created bean itself.
						continue;
					}
				}
				throw ex;
			}
		}
		return result;
	}

inernalEventListenerProcessor以及internalConfigurationAnnotationProcessor作为后置处理器，肯定要与BeanFactory进行绑定，看一下绑定的源码。

beanFactoryPostProcessor.postProcessBeanFactory(defaultListableBeanFactory)

这块底层实现类有点多，不过我们只关注两个，这里我拿着ConfigurationClassPostProcessor这个后置处理器来看看。

 public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
        int factoryId = System.identityHashCode(beanFactory);
        if (this.factoriesPostProcessed.contains(factoryId)) {
            throw new IllegalStateException("postProcessBeanFactory already called on this post-processor against " + beanFactory);
        } else {
            this.factoriesPostProcessed.add(factoryId);
            if (!this.registriesPostProcessed.contains(factoryId)) {
                this.processConfigBeanDefinitions((BeanDefinitionRegistry)beanFactory);
            }

            this.enhanceConfigurationClasses(beanFactory);
            beanFactory.addBeanPostProcessor(new ConfigurationClassPostProcessor.ImportAwareBeanPostProcessor(beanFactory));
        }
    }

这里我们关注的方法是addBeanPostProcessor方法，其实真正的后置处理器对象是在这个地方进行创建的（在与beanFactory绑定时添加的），这个方法我们可以看到，addBeanPostProcessor是将对象存放至BeanFactory的BeanPostPorcessors属性中，这个属性对应的类继承了copyOnWriteArrayList集合保证线程安全。

接下来看一下BeanPostProcessor.

defaultListableBeanFactory.getBeansOfType(BeanPostProcessor.class).values().stream().forEach(beanPostProcessor ->
        defaultListableBeanFactory.addBeanPostProcessor(beanPostProcessor));

这个功能过程应该是与BeanFactoryPostProcessor类似，第一个方法getBeansOfType，看看与我的想法是否一致。

确实如此，在此处加载过程中，确定了BeanPostProcerssor是InternalAutowiredAnnotationProcessor以及InternalCommonAnnotationProcessor.

addBeanPostProcessor这个点进去一看，没什么意思，与BeanFactoryPostProcessor相比更加简化了。

//在构造前创建单例
defaultListableBeanFactory.preInstantiateSingletons();

这个没什么好说的，在实例化前创建单例bean。源码中getBean方法已说明一切。

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

		// Iterate over a copy to allow for init methods which in turn register new bean definitions.
		// While this may not be part of the regular factory bootstrap, it does otherwise work fine.
		List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);

		// Trigger initialization of all non-lazy singleton beans...
		for (String beanName : beanNames) {
			RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
			if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
				if (isFactoryBean(beanName)) {
					Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
					if (bean instanceof FactoryBean) {
						FactoryBean<?> factory = (FactoryBean<?>) bean;
						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());
						}
						if (isEagerInit) {
							getBean(beanName);
						}
					}
				}
				else {
					getBean(beanName);
				}
			}
		}

这还只是表层的源码，这里只是看到了后置处理器有哪些，具体是怎么工作的，一点不知，等后续吧。

beanFactory总结

beanFactory的工作流程：

创建一个原生的BeanFactory容器。

创建要创建的类型定义，BeanDefition类。

将BeanDefition注册至BeanFactory上，设置单例属性等等。

加载处理器至BeanFactory上。

将处理器中的BeanFactoryPostProcessor以及BeanPostProcessor区别，并注册至BeanFactory中。

最终调用实例化前单例对象方法，对其完成创建。

ApplicationContext应用

在BeanFactory我这面已经初步了解细节，ApplicationContext是在BeanFactory基础上做了封装。这个的话，简单写点样例代码就够了，后续再说。

package com.bo.beanfactoryapplicationcontextstudy.two;

import com.bo.beanfactoryapplicationcontextstudy.interview.Person;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.context.support.FileSystemXmlApplicationContext;

/**
 * @Auther: zeroB
 * @Date: 2023/3/28 11:13
 * @Description:
 */
public class MyApplicationContextTwoTest {

    public static void main(String[] args) {
//        fileSyatemXmlBean();
//        annotationConfigBean();
    }

  

    public static void annotationConfigBean(){
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(Person.class);
        Person person = (Person)context.getBean("person");
        System.out.println(person);
    }

    public static void fileSyatemXmlBean(){
        FileSystemXmlApplicationContext fileSystemXmlApplicationContext = new FileSystemXmlApplicationContext("D:\\sourcecode\\spring-study\\beanFactoryApplicationContextStudy\\src\\main\\resources\\testIoc.xml");
        Person person = (Person)fileSystemXmlApplicationContext.getBean("person");
        System.out.println(person);

    }

    public static void classPathXmlBean(){
        ClassPathXmlApplicationContext classPathXmlApplicationContext = new ClassPathXmlApplicationContext("testIoc.xml");
        Person person = (Person)classPathXmlApplicationContext.getBean("person");
        System.out.println(person);
    }


}

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

    <bean id="person" class="com.bo.beanfactoryapplicationcontextstudy.interview.Person" init-method="myInit"
          destroy-method="myDestory" scope="singleton">
           <property name="name" value="wuwenbo"></property>
            <property name="address" value="shanxi"></property>
            <property name="phone" value="188"></property>
    </bean>


</beans>

package com.bo.beanfactoryapplicationcontextstudy.interview;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.*;

/**
 * @Auther: zeroB
 * @Date: 2023/2/13 10:31
 * @Description: 实现了四个接口，aware类型，我暂时不是很了解，后面的俩，是实际初始化和销毁bean对象的流程
 */
public class Person implements BeanFactoryAware, BeanNameAware, InitializingBean, DisposableBean {

    private String name;

    private String address;

    private int phone;

    private BeanFactory beanFactory;

    private String beanName;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        System.out.println("set方法设置属性name"+name);
        this.name = name;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        System.out.println("set方法设置属性address"+address);
        this.address = address;
    }

    public int getPhone() {
        return phone;
    }

    public void setPhone(int phone) {
        System.out.println("set方法设置属性phone"+phone);
        this.phone = phone;
    }


    public Person() {
        System.out.println("调用Person对象的构造函数进行初始化");
    }

    @Override
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        System.out.println("BeanFactoryAware接口调用setBeanFactory方法");
        this.beanFactory = beanFactory;
    }

    @Override
    public void setBeanName(String name) {
        System.out.println("BeanNameAware接口调用setBeanName方法");
        this.beanName = beanName;
    }

    @Override
    public void destroy() throws Exception {
        System.out.println("调用了disposableBean接口的销毁方法");
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("调用了initializingBean的afterPropertiesSet方法");
    }

    //TODO 原先它这里用的xml解析方式，这里我觉得费事，直接用Bean注解的方式了

    public void myInit(){
        System.out.println("调用了我自身的初始化方法");
    }

    public void myDestory(){
        System.out.println("调用了我自身的销毁方法");
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", address='" + address + '\'' +
                ", phone=" + phone +
                ", beanFactory=" + beanFactory +
                ", beanName='" + beanName + '\'' +
                '}';
    }
}

其实他罗列了4种，第4种我这面不想整了，所以先这么着。

以AnnotationConfigApplicationContext源码构造函数来看，简单看一下这个refresh方法。