Spring菜鸟教你看源码冲面试

Spring

类的初始化和实例化的不同

IOC

探究spring的IOC容器

DefaultListableBeanFactory是最终实现类，在代码中可以找到HashMap的影子；IOC容器就是用HashMap装的Bean;

1. public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFactory
2. implements ConfigurableListableBeanFactory, BeanDefinitionRegistry, Serializable {
3. @Nullable
4. private static Class<?> javaxInjectProviderClass;
5.  
6. static {
7. try {
8. javaxInjectProviderClass =
9. ClassUtils.forName("javax.inject.Provider", DefaultListableBeanFactory.class.getClassLoader());
10. }
11. catch (ClassNotFoundException ex) {
12. // JSR-330 API not available - Provider interface simply not supported then.
13. javaxInjectProviderClass = null;
14. }
15. }
16.  
17. /** Map from serialized id to factory instance. */
18. private static final Map<String, Reference<DefaultListableBeanFactory>> serializableFactories =
19. new ConcurrentHashMap<>(8);
20.  
21. /** Optional id for this factory, for serialization purposes. */
22. @Nullable
23. private String serializationId;
24.  
25. /** Whether to allow re-registration of a different definition with the same name. */
26. private boolean allowBeanDefinitionOverriding = true;
27.  
28. /** Whether to allow eager class loading even for lazy-init beans. */
29. private boolean allowEagerClassLoading = true;
30.  
31. /** Optional OrderComparator for dependency Lists and arrays. */
32. @Nullable
33. private Comparator<Object> dependencyComparator;
34.  
35. /** Resolver to use for checking if a bean definition is an autowire candidate. */
36. private AutowireCandidateResolver autowireCandidateResolver = SimpleAutowireCandidateResolver.INSTANCE;
37.  
38. /** Map from dependency type to corresponding autowired value. */
39. private final Map<Class<?>, Object> resolvableDependencies = new ConcurrentHashMap<>(16);
40.  
41. /** Map of bean definition objects, keyed by bean name. */
42. private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>(256);
43.  
44. /** Map from bean name to merged BeanDefinitionHolder. */
45. private final Map<String, BeanDefinitionHolder> mergedBeanDefinitionHolders = new ConcurrentHashMap<>(256);
46.  
47. /** Map of singleton and non-singleton bean names, keyed by dependency type. */
48. private final Map<Class<?>, String[]> allBeanNamesByType = new ConcurrentHashMap<>(64);
49.  
50. /** Map of singleton-only bean names, keyed by dependency type. */
51. private final Map<Class<?>, String[]> singletonBeanNamesByType = new ConcurrentHashMap<>(64);
52.  
53. /** List of bean definition names, in registration order. */
54. private volatile List<String> beanDefinitionNames = new ArrayList<>(256);
55.  
56. /** List of names of manually registered singletons, in registration order. */
57. private volatile Set<String> manualSingletonNames = new LinkedHashSet<>(16);
58.  
59. /** Cached array of bean definition names in case of frozen configuration. */
60. @Nullable
61. private volatile String[] frozenBeanDefinitionNames;
62. ................
63. ...........
64. }

BeanFactory：主要方法为getBean(String beanName)，该方法根据Bean名称从容器返回对应的Bean

BeanFactory是接口，提供了IOC容器最基本的形式，给具体的IOC容器的实现提供了规范，

发现BeanFactory是Spring的IOC容器核心接口，它的职责包括，实例化，有很多的实现类；

原始的BeanFactory无法支持spring的许多插件，如AOP功能、Web应用等

那么BeanFactroy是否有AOP的影子呢？

找到BeanFactroyAware接口看到很多关键字有proxy类似代理的接口

so 猜想是否跟AOP(面向切面，动态代理)有关

然后点进去其中一个方法(AbstractAutoProxyCreator)，发现引入很多跟AOP相关的包

1. import org.springframework.aop.Advisor;
2. import org.springframework.aop.Pointcut;
3. import org.springframework.aop.TargetSource;
4. import org.springframework.aop.framework.AopInfrastructureBean;
5. import org.springframework.aop.framework.ProxyFactory;
6. import org.springframework.aop.framework.ProxyProcessorSupport;
7. import org.springframework.aop.framework.adapter.AdvisorAdapterRegistry;
8. import org.springframework.aop.framework.adapter.GlobalAdvisorAdapterRegistry;
9. import org.springframework.aop.target.SingletonTargetSource;

往下看看这个类，做了什么？找几个方法出来；

看看类的注释

此类区分通用拦截器（由创建的所有代理共享）和特定拦截器：每个bean实例唯一。不需要任何通用拦截器。如果存在，则使用interceptorNames属性设置它们。
与{@link org.springframework.aop.framework.ProxyFactoryBean}一样，使用当前工厂中的拦截器名称而不是bean引用来正确处理原型顾问程序和拦截器例如，以支持有状态的混合。{@link #set InterceptorNames interceptorNames}条目支持任何建议类型。 如果有大量的豆需要用类似的代理包装，即委托给相同的拦截器，则这种自动代理特别有用。 代替x个目标bean的x个重复代理定义，您可以在bean工厂注册一个这样的后处理器，以达到相同的效果

1. public abstract class AbstractAutoProxyCreator extends ProxyProcessorSupport
2. implements SmartInstantiationAwareBeanPostProcessor, BeanFactoryAware {
3. /**
4. *设置公共拦截器。这些必须是当前工厂中的bean名称
5. */
6. public void setInterceptorNames(String... interceptorNames) {
7. this.interceptorNames = interceptorNames;
8. }
9. /**
10. 为给定的bean创建一个AOP代理
11. */
12. protected Object createProxy(Class<?> beanClass, @Nullable String beanName,
13. @Nullable Object[] specificInterceptors, TargetSource targetSource) {
14.  
15. if (this.beanFactory instanceof ConfigurableListableBeanFactory) {
16. AutoProxyUtils.exposeTargetClass((ConfigurableListableBeanFactory) this.beanFactory, beanName, beanClass);
17. }
18. ProxyFactory proxyFactory = new ProxyFactory();
19. proxyFactory.copyFrom(this);
20.  
21. if (!proxyFactory.isProxyTargetClass()) {
22. if (shouldProxyTargetClass(beanClass, beanName)) {
23. proxyFactory.setProxyTargetClass(true);
24. }
25. else {
26. evaluateProxyInterfaces(beanClass, proxyFactory);
27. }
28. }
29. Advisor[] advisors = buildAdvisors(beanName, specificInterceptors);
30. proxyFactory.addAdvisors(advisors);
31. proxyFactory.setTargetSource(targetSource);
32. customizeProxyFactory(proxyFactory);
33. proxyFactory.setFrozen(this.freezeProxy);
34.  
35. if (advisorsPreFiltered()) {
36. proxyFactory.setPreFiltered(true);
37. }
38. return proxyFactory.getProxy(getProxyClassLoader());
39. }
40.  
41. }

AbstractAutoProxyCreator类关系UML图

说明AOP横切在Bean的生命周期中

---

AOP

Spring 通过 AbstractAutoProxyCreator 来创建 AOP 代理，AbstractAutoProxyCreator 是一个抽象类，它实现了 BeanPostProcessor 接口，用于在 bean 初始化完成之后创建它的代理(从上面IOC容器创建Bean过程中有点体现)；

在AbstractAutoProxyCreator类关系UML图中找到一个特殊的接口—>BeanPostProcessor

划重点：

• 与工厂挂钩，允许自定义修改新bean实例，如检查标记接口或使用代理包装bean
• 普通的{@code BeanFactory}允许以编程方式注册后处理器，并将其应用于通过bean工厂创建的所有bean中；跟上面的AOP横切BeanFactroy联系上了；

1. /**
2. 工厂挂钩，允许自定义修改新bean实例-例如，检查标记接口或使用代理包装bean。 <p>通常，通过标记接口*或类似对象填充bean的后处理器将实现{@link #postProcessBeforeInitialization}，而使用代理包装bean的后处理器通常将实现{@link #postProcessAfterInitialization}。 <h3>注册</h3> <p> {@ code ApplicationContext}可以在其bean定义中自动检测{@code BeanPostProcessor} bean，并将这些后处理器应用于随后创建的任何bean。普通的{@code BeanFactory}允许以编程方式注册后处理器，并将其应用于通过bean工厂创建的所有bean
3. */
4. public interface BeanPostProcessor {
5.  
6. /**
7. 在任何bean 初始化回调（如InitializingBean的{@code afterPropertiesSet} 或自定义的init-method）之前，将此{@code BeanPostProcessor}应用于给定的新bean实例<i> </ i>。该bean将已经用属性值填充。 返回的bean实例也可能是原始实例的包装;
8. */
9. @Nullable
10. default Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
11. return bean;
12. }
13.  
14. /**
15. 在任何bean 初始化回调（例如InitializingBean的{@code afterPropertiesSet} 或自定义的初始化方法）之后，将此{@code BeanPostProcessor}应用于给定的新bean实例。该bean将已经用属性值填充。 返回的bean实例可能是原始实例的包装。 对于FactoryBean，将为FactoryBean 实例和由FactoryBean创建的对象（从Spring 2.0开始）调用此回调。后处理器可以通过相应的{@code bean instanceof FactoryBean}检查来决定是应用到FactoryBean还是创建的对象，还是两者都应用。
16. */
17. @Nullable
18. default Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
19. return bean;
20. }
21.  
22. }

在来看这张图(IOC容器工作过程) BeanPostProcessor就是AOP切入的位置，处在对象的生命周期中；

BeanFactoryPostProcessor(初始化Bean,如上图)

1. public interface BeanFactoryPostProcessor {
2. /**
3. 在标准初始化之后，修改应用程序上下文的内部bean工厂。所有bean定义都将被加载，但是还没有实例化bean *。这甚至可以覆盖或添加*属性，甚至可以用于初始化bean。
4. */
5. void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException;}

---

另外提点东西(来自面试) BeanFactory 简介以及它 和FactoryBean的区别(阿里面试)

 

FactoryBean接口是什么？

看看官方注释：

在BeanFactory中的对象实现的接口，这些对象本身是个单个对象的工厂，如果这些对象实现FactoryBean接口，它将用作对象公开的工厂，而不是直接将自身公开；

好像还是有点蒙吧看看其他解释

FactoryBean是个Bean。在Spring中，所有的Bean都是由BeanFactory(也就是IOC容器)来进行管理的。但对FactoryBean而言，这个Bean不是简单的Bean，而是一个能生产或者修饰对象生成的工厂Bean,它的实现与设计模式中的工厂模式和修饰器模式类似
FactoryBean接口用的是Class<?> getObjectType();可以理解为高级定制Bean；

看FactoryBean接口抽象类(AbstractFactoryBean)

1. public abstract class AbstractFactoryBean<T>
2. implements FactoryBean<T>, BeanClassLoaderAware, BeanFactoryAware, InitializingBean, DisposableBean {
3. /** Logger available to subclasses. */
4. protected final Log logger = LogFactory.getLog(getClass());
5. private boolean singleton = true;
6. @Nullable
7. private ClassLoader beanClassLoader = ClassUtils.getDefaultClassLoader();
8. @Nullable
9. private BeanFactory beanFactory;
10. private boolean initialized = false;
11. @Nullable
12. private T singletonInstance;
13. @Nullable
14. private T earlySingletonInstance;
15.  
16. /**
17. 设置是否应该创建一个单例，或者在每个请求上创建一个新对象*否则。默认值为{@code true}（单例）。
18. */
19. public void setSingleton(boolean singleton) {
20. this.singleton = singleton;
21. }
22. @Override
23. public boolean isSingleton() {
24. return this.singleton;
25. }
26. @Override
27. public void setBeanClassLoader(ClassLoader classLoader) {
28. this.beanClassLoader = classLoader;
29. }
30. @Override
31. public void setBeanFactory(@Nullable BeanFactory beanFactory) {
32. this.beanFactory = beanFactory;
33. }
34. /**
35. 返回运行该bean的BeanFactory
36. */
37. @Nullable
38. protected BeanFactory getBeanFactory() {
39. return this.beanFactory;
40. }
41.  
42. /**
43. 从运行该bean的BeanFactory获取一个bean类型转换器
44. */
45. protected TypeConverter getBeanTypeConverter() {
46. BeanFactory beanFactory = getBeanFactory();
47. if (beanFactory instanceof ConfigurableBeanFactory) {
48. return ((ConfigurableBeanFactory) beanFactory).getTypeConverter();
49. }
50. else {
51. return new SimpleTypeConverter();
52. }
53. }
54. /**
55. 公开单例实例（用于通过“早期单例”代理访问）。返回此FactoryBean持有的单例实例
56. */
57. @Nullable
58. private T getSingletonInstance() throws IllegalStateException {
59. Assert.state(this.initialized, "Singleton instance not initialized yet");
60. return this.singletonInstance;
61. }
62. }

看完FactoryBean接口抽象类(AbstractFactoryBean)基本的代码后，发现什么？

FactoryBean基于BeanFactory，FactoryBean是一个能生产或者修饰对象生成的工厂Bean；

FactoryBean中定义了一个Spring Bean的很重要的三个特性：是否单例、Bean类型、Bean实例

ApplicationContext接口,

由BeanFactory接口派生而来

看到ApplicationContext接口

提供应用程序配置的中央接口。在应用程序运行时为只读，但如果实现支持，则可以重新加载。
ApplicationContext提供：

• 用于访问应用程序组件的Bean工厂方法。继承自{@link org.springframework.beans.factory.ListableBeanFactory}。
• 以通用方式加载文件资源的能力。继承自{@link org.springframework.core.io.ResourceLoader}接口。
• 将事件发布到注册的侦听器的能力。继承自{@link ApplicationEventPublisher}接口。
• 解决消息的能力，支持国际化。继承自{@link MessageSource}接口。
• 从父上下文继承。在后代上下文中的定义将始终优先。例如，这意味着整个Web应用程序都可以使用单个父上下文，而每个servlet都有自己的子上下文，而该子上下文独立于任何其他servlet的子上下文。
• 除了标准的{@link org.springframework.beans.factory.BeanFactory}生命周期功能之外，ApplicationContext实现还检测并调用{@link ApplicationContextAware} Bean以及{@link ResourceLoaderAware }，{@link ApplicationEventPublisherAware}和{@link MessageSourceAware} bean。

1. public interface ApplicationContext extends EnvironmentCapable, ListableBeanFactory, HierarchicalBeanFactory,
2. MessageSource, ApplicationEventPublisher, ResourcePatternResolver {
3.  
4. /**
5. 返回此应用程序上下文的唯一ID
6. */
7. @Nullable
8. String getId();
9.  
10. /**
11. 返回此上下文所属的已部署应用程序的名称
12. */
13. String getApplicationName();
14.  
15. /**
16. 返回此上下文的显示名称
17. */
18. String getDisplayName();
19.  
20. /**
21. 返回首次加载此上下文时的时间戳
22. */
23. long getStartupDate();
24.  
25. /**
26. 返回父级上下文，如果没有父级，则返回{@code null}
27. */
28. @Nullable
29. ApplicationContext getParent();
30.  
31. /**
32. 针对此上下文公开AutowireCapableBeanFactory功能。 * <p>应用程序代码通常不使用此功能，除非是为了*初始化存在于应用程序上下文之外的bean实例，*将Spring bean生命周期（全部或部分）应用于它们。 * <p>或者，通过{@link ConfigurableApplicationContext}接口公开的内部BeanFactory也提供对{{link AutowireCapableBeanFactory}接口的访问。本方法主要*用作ApplicationContext接口上的便捷特定工具。 * <p> <b>注意：从4.2开始，在关闭应用程序上下文之后，此方法将始终抛出IllegalStateException *。</ b>在当前的Spring Framework *版本中，只有可刷新的应用程序上下文才具有这种行为；从4.2开始，*所有应用程序上下文实现都将必须遵守。 * @为此上下文返回AutowireCapableBeanFactory *如果上下文不支持{@link AutowireCapableBeanFactory}接口，或者尚不具有支持自动连线功能的bean工厂，则抛出IllegalStateException（例如，如果{@code refresh（）}具有*从未调用过），或者上下文已经关闭* @see ConfigurableApplicationContext＃refresh（）* @see ConfigurableApplicationContext＃getBeanFactory（）* /
33. */
34. AutowireCapableBeanFactory getAutowireCapableBeanFactory() throws IllegalStateException;

ApplicationContext接口UML类图

ApplicationContext有两个主要的实现类：ClassPathXmlApplicationContext：默认从类路径加载配置文件，还有FileSystemXmlApplicationContext：默认从文件系统中装载配置文件

WebApplicationContext

提供Web应用程序配置的界面。在应用程序运行时为只读，但是如果实现支持，则可以重新加载。此接口在通用ApplicationContext接口中添加了一个{@code getServletContext（）}方法，并定义了一个众所周知的应用程序属性名称，该名称必须在引导过程中绑定到根上下文。类似于通用应用程序上下文，Web应用程序上下文是分层的。 每个应用程序只有一个根上下文，而应用程序中的每个servlet（包括MVC框架中的调度程序servlet）都有自己的子上下文。除了标准的应用程序上下文生命周期功能外，WebApplicationContext实现还需要检测{@link ServletContextAware} bean，并相应地调用{@code setServletContext}方法

1. public interface WebApplicationContext extends ApplicationContext {
2.  
3. /**
4. Context属性，用于在成功启动时将根WebApplicationContext绑定到该属性。 * <p>注意：如果根上下文的启动失败，则此属性可以包含*异常或错误作为值。使用WebApplicationContextUtils方便*查找根WebApplicationContext。
5. */
6. String ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE = WebApplicationContext.class.getName() + ".ROOT";
7.  
8. /**
9. 请求范围的范围标识符：“ request”。 *除了标准范围“ singleton”和“ prototype”之外，还受支持。
10. */
11. String SCOPE_REQUEST = "request";
12.  
13. /**
14. 会话范围的范围标识符：“session”。 *除了标准范围“ singleton”和“ prototype”之外，还受支持。
15. */
16. String SCOPE_SESSION = "session";
17.  
18. /**
19. 全局Web应用程序范围的范围标识符：“application”。 *除了标准范围“ singleton”和“ prototype”之外，还受支持。
20. */
21. String SCOPE_APPLICATION = "application";
22.  
23. /**
24. 工厂中ServletContext环境Bean的名称
25. */
26. String SERVLET_CONTEXT_BEAN_NAME = "servletContext";
27.  
28. /**
29. 工厂中ServletContext init-params环境Bean的名称
30. */
31. String CONTEXT_PARAMETERS_BEAN_NAME = "contextParameters";
32.  
33. /**
34. 工厂中ServletContext属性环境bean的名称
35. */
36. String CONTEXT_ATTRIBUTES_BEAN_NAME = "contextAttributes";
37.  
38. /**
39. 返回此应用程序的标准Servlet API ServletContext
40. */
41. @Nullable
42. ServletContext getServletContext();
43. }

WebApplicationContext的UML类图(从图中可以发现WebApplicationContext扩展了ApplicationContext的功能，ApplicationContext扩展了BeanFactory的功能。)

这几个接口间的区别

BeanFactory和ApplicationContext， WebApplicationContext初始化区别：BeanFactory在初始化容器时并没有实例化Bean，而是在第一次访问到目标Bean时才实例化该Bean；而ApplicationContext会在初始化上下文时实例化所有的单例的Bean。WebApplicationContext的初始化需要servletContext实例(getServletContext();)，即初始化需要拥有web容器，我们需要在web.xml中配置自启动的servlet或web容器监听器（servletContextListener）

Bean的作用域

在BeanFactory和ApplicationContext中的Bean的作用域有两种：
singleton和prototype，
在WebApplicationContext中的Bean的作用域有三种：request，session和globalSession。
singleton：在IOC容器中仅存在一个Bean实例，Bean以单例方式存在，外部引用都指向这个Bean
prototype：每次调用Bean都返回一个新实例
request：在同一个Http请求的Bean相同，每个Http请求创建一个新的Bean。
session：在Http请求对应同一个session时对应同一个Bean。
globalSession：一般的web应用中globalSession等价于session，只有在portlet web应用中才存在globalSession概念。

到此这篇关于Spring菜鸟教你看源码冲面试的文章就介绍到这了,更多相关Spring源码内容请搜索服务器之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持服务器之家！

原文链接：https://blog.csdn.net/weixin_44313584/article/details/114785885