JavaGuide.net

切换主题

微信公众号

看不懂很正常 ​
让面试官仰望你。 ​
Spring 是围绕 Bean 来展开， BOP 的开发思想。 ​

Spring 的四个策略： ​

1. 基于 POJO 的轻量和最小侵入性编程 ​
2. 通过依赖注入和面向接口松耦合 ​
3. 基于切面和惯性进行声明式编程 ​
4. 通过切面和模板减少样板式代码。 ​

手段： ​

  • 面向 Bean
  • 依赖注入
  • 面向切面

思想 ​

  • AOP
  • OOP
  • BOP
  • IOC
  • DI

Spring 中什么时候用单例模式，什么时候用原型模式 ​

​ 对于 Spring 来说，他并不干预你对象本身的属性，他也不关心你这个对象是什么东西。他只关心它的管理方式。

Spring 中的生命周期？ ​

Spring 中的 Bean 是不是线程安全的呢？ ​

​ 在 Spring 中，Bean 是不是线程安全，也跟 Spring 无关，Spring 只是一个存放对象实例的容器，以及管理和维护对象与对象之间的关系。

​ 单例还是原型，线程安全不安全是由你本身的业务场景来决定的。

  • 全局唯一用单例，
  • 每次都会有一个新的对象，用原型模式

AOP ​

  • Authentication 权限认证
  • Logging 日志
  • Transctions Manager 事务
  • Lazy Loading 懒加载
  • Context Process上下文处理
  • Error Handler 错误跟踪（异常捕获机制）
  • Cache 缓存

Spring 5 架构 ​

Spring手画架构图 ​

Spring手画架构图

Spring官方架构图.jpg ​

Spring官方架构图

Spring各个Model的关系图.png ​

Spring各个Model的关系图.png

核心的四个模块 ​

Spring-beans ​

​ 定义，Bean，加载

Spring-core ​
Spring-context ​

​ ClassPathXmlApplicationContext

Spring-expression(Spring Expression Language, SpEL) ​

context 是入口

定位： 用的Reader结尾的

加载： BeanDefinition保存类信息，包括OOP关系

注册： Factroy、Context 就是把用户所定义的 Bean放到 IOC容器中（Map）

ClassPathXmlApplicationContext 通过 main 方法启动

DispatchServlet

FileSystem

Plugin

Lisenter

java
public class SpringTest{
    public static void main(string[] args){
        ClassPathXmlApplicationContext app = new ClassPathXmlApplicationContext("application-common.xml","application-beans.xml","application-jdbc.xml");
        Object obj = app.getBean("member");
    }
}
public class SpringTest{
    public static void main(string[] args){
        ClassPathXmlApplicationContext app = new ClassPathXmlApplicationContext("application-common.xml","application-beans.xml","application-jdbc.xml");
        Object obj = app.getBean("member");
    }
}
java
public ClassPathXmlApplicationContext(
    String[] configLocations, boolean refresh, @Nullable ApplicationContext parent)throws BeansException{
    
    super(parent);
    setconfigLocations(configLocations);
    if(refresh){
        
        // 初始化最核心的方法，就是refresh()
        // 把所有的Bean重新构造一遍
        // 七分猜测，三分验证
        refresh();
    }
}
public ClassPathXmlApplicationContext(
    String[] configLocations, boolean refresh, @Nullable ApplicationContext parent)throws BeansException{
    
    super(parent);
    setconfigLocations(configLocations);
    if(refresh){
        
        // 初始化最核心的方法，就是refresh()
        // 把所有的Bean重新构造一遍
        // 七分猜测，三分验证
        refresh();
    }
}

围绕Bean来展开

是由BeanFacoty来创建的

reader

load

do开头的都是具体干活的。

parseBeanDefinitions 方法实际上是解析xml，把xml解析成对象

java
@override
public void refresh()throws BeansException, illegalStateExcetion{
	prepareRegresh();
    congigurableListtableBeanfacotry beanFactory = obtainFreshBeanFacotry();
    prepareBeanFacotry(beanFacotry);
}
@override
public void refresh()throws BeansException, illegalStateExcetion{
	prepareRegresh();
    congigurableListtableBeanfacotry beanFactory = obtainFreshBeanFacotry();
    prepareBeanFacotry(beanFacotry);
}

Spring源码分析 ​

IOC 和 DI

一般采用 xml ，properties ，以及现在的 annotion 来表示。

这些资源通常会放到 classpath 上 ，

Spring 的核心容器体系结构 ​

（1） BeanFactory ​

就是用来生产 Bean 的。

有父子关系，有集合关系。还有我们的自动注入的关系。这些关系都需要通过 BeanFatory 来体现出来。

顶层一个接口，下面有子类，分别实现各个场景的一个实现。这种设计模式是什么模式？

委派。

BeaFactory 不干活的。

  • ListableBeanFacotry 处理集合之类的 Bean 的加载。
  • AutowireCapableBeanFactory 处理自动注入关系的 Bean 的加载。
  • HirearchicalBeanFactory 处理一些具有层次关系的 类的加载。

BeanFactory

最后都是由 DefaultListableBeanFactory 实现所有的功能。

ClassPathXmlApplicationContext 作为 Spring 唯一的入口，

ClassPathXmlApplicationContext

ClassPathXmlApplicationContext 就是 BeanFactory 的实现类。我们学习 Spring 必须先学习 Beanfactory 。

java
public interface BeanFactory {
	
	//对FactoryBean的转义定义，因为如果使用bean的名字检索FactoryBean得到的对象是工厂生成的对象
	//如果需要得到工厂本身，需要转义
	String FACTORY_BEAN_PREFIX = "&";

	//根据bean的名字，获取在IOC容器中得到bean实例
	Object getBean(String name) throws BeansException;
	
	//根据bean的名字和Class类型来得到bean实例，增加了类型安全验证机制。
	<T> T getBean(String name, @Nullable Class<T> requiredType) throws BeansException;

	Object getBean(String name, Object... args) throws BeansException;

	<T> T getBean(Class<T> requiredType) throws BeansException;

	<T> T getBean(Class<T> requiredType, Object... args) throws BeansException;

	//提供对bean的检索，看看是否在IOC容器有这个名字的bean
	boolean containsBean(String name);

	//根据bean名字得到bean实例，并同时判断这个bean是不是单例
	boolean isSingleton(String name) throws NoSuchBeanDefinitionException;

	boolean isPrototype(String name) throws NoSuchBeanDefinitionException;
    
	boolean isTypeMatch(String name, ResolvableType typeToMatch) throws NoSuchBeanDefinitionException;

	boolean isTypeMatch(String name, @Nullable Class<?> typeToMatch) throws NoSuchBeanDefinitionException;

	//得到bean实例的Class类型
	@Nullable
	Class<?> getType(String name) throws NoSuchBeanDefinitionException;

	//得到bean的别名，如果根据别名检索，那么其原名也会被检索出来
	String[] getAliases(String name);
}
public interface BeanFactory {
	
	//对FactoryBean的转义定义，因为如果使用bean的名字检索FactoryBean得到的对象是工厂生成的对象
	//如果需要得到工厂本身，需要转义
	String FACTORY_BEAN_PREFIX = "&";

	//根据bean的名字，获取在IOC容器中得到bean实例
	Object getBean(String name) throws BeansException;
	
	//根据bean的名字和Class类型来得到bean实例，增加了类型安全验证机制。
	<T> T getBean(String name, @Nullable Class<T> requiredType) throws BeansException;

	Object getBean(String name, Object... args) throws BeansException;

	<T> T getBean(Class<T> requiredType) throws BeansException;

	<T> T getBean(Class<T> requiredType, Object... args) throws BeansException;

	//提供对bean的检索，看看是否在IOC容器有这个名字的bean
	boolean containsBean(String name);

	//根据bean名字得到bean实例，并同时判断这个bean是不是单例
	boolean isSingleton(String name) throws NoSuchBeanDefinitionException;

	boolean isPrototype(String name) throws NoSuchBeanDefinitionException;
    
	boolean isTypeMatch(String name, ResolvableType typeToMatch) throws NoSuchBeanDefinitionException;

	boolean isTypeMatch(String name, @Nullable Class<?> typeToMatch) throws NoSuchBeanDefinitionException;

	//得到bean实例的Class类型
	@Nullable
	Class<?> getType(String name) throws NoSuchBeanDefinitionException;

	//得到bean的别名，如果根据别名检索，那么其原名也会被检索出来
	String[] getAliases(String name);
}

​ ApplicationContext 是 Spring 提供的一个高级的 IOC 容器， ApplicationContext 应该算是容器的高帅富。

spring Bean工厂的工作流程 ​

定位 ​
加载 ​
注册 ​

BeanDefinition 为什么会有一个 BeanDefinition 就是我们的 装饰器模式 。就是对原有对象的包装，就是一个 包装 。就是，保留原来的 OOP 的关系。

RootBeanDefinition

XmlBeanDefinitionReader 负责 XML 文件的读取和解析。转换成我们的 BeanDefinition 就是我们的 定位功能 。

XmlBeanDefinitionReader

4.3 IOC 容器的初始化 ​

​ IOC 容器的初始化包括 BeanDefinition 的 Resource 定位、载入和注册这三个基本的过程。

ClassPathXmlApplicationContext

Spring 中的技巧 ​

Context 是入口

定位 ： 用的 Reader 结尾的。

加载： BeanDefinition 保存类信息，包括 OOP 关系。

注册： Facotry 、 Context

注册就是：把用户所定义的 Bean 放到 IOC 容器中 （Map）

定位资源的位置，

加载资源的内容，

注册，把 Bean 写入到 Map 中。

Spring 启动方式 ​

  • ClassPathXmlApplicationContext 通过 main 方法启动
  • DispatchServlet
  • FileSystem
  • Plugin
  • Listener

reader

load

do 开头的都是具体干活的。

parseBeanDefinitions 的方法实际是解析 XML，把 XML 中的内容变成 BeanDefinition

java
	public ClassPathXmlApplicationContext(
			String[] configLocations, boolean refresh, @Nullable ApplicationContext parent)
			throws BeansException {

		super(parent);
		setConfigLocations(configLocations);
		if (refresh) {

			// 初始化最核心的方法，就是 refresh()
			// 把所有的 Bean 重新构造一遍
			// 七分猜测、三分验证
			refresh();
		}
	}
	public ClassPathXmlApplicationContext(
			String[] configLocations, boolean refresh, @Nullable ApplicationContext parent)
			throws BeansException {

		super(parent);
		setConfigLocations(configLocations);
		if (refresh) {

			// 初始化最核心的方法，就是 refresh()
			// 把所有的 Bean 重新构造一遍
			// 七分猜测、三分验证
			refresh();
		}
	}
java
@Override
	public void refresh() throws BeansException, IllegalStateException {
		synchronized (this.startupShutdownMonitor) {
			// Prepare this context for refreshing.
			//调用容器准备刷新的方法，获取容器的当时时间，同时给容器设置同步标识
			prepareRefresh();

			// Tell the subclass to refresh the internal bean factory.
			//告诉子类启动refreshBeanFactory()方法，Bean定义资源文件的载入
			//从子类的refreshBeanFactory()方法启动
			ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

			// Prepare the bean factory for use in this context.
			//为BeanFactory配置容器特性，例如类加载器、事件处理器等
			prepareBeanFactory(beanFactory);

			try {
				// Allows post-processing of the bean factory in context subclasses.
				//为容器的某些子类指定特殊的BeanPost事件处理器
				postProcessBeanFactory(beanFactory);

				// Invoke factory processors registered as beans in the context.
				//调用所有注册的BeanFactoryPostProcessor的Bean
				invokeBeanFactoryPostProcessors(beanFactory);

				// Register bean processors that intercept bean creation.
				//为BeanFactory注册BeanPost事件处理器.
				//BeanPostProcessor是Bean后置处理器，用于监听容器触发的事件
				registerBeanPostProcessors(beanFactory);

				// Initialize message source for this context.
				//初始化信息源，和国际化相关
				initMessageSource();

				// Initialize event multicaster for this context.
				//初始化容器事件传播器.
				initApplicationEventMulticaster();

				// Initialize other special beans in specific context subclasses.
				//调用子类的某些特殊Bean初始化方法
				onRefresh();

				// Check for listener beans and register them.
				//为事件传播器注册事件监听器.
				registerListeners();

				// Instantiate all remaining (non-lazy-init) singletons.
				//初始化所有剩余的单例Bean
				finishBeanFactoryInitialization(beanFactory);

				// Last step: publish corresponding event.
				//初始化容器的生命周期事件处理器，并发布容器的生命周期事件
				finishRefresh();
			}

			catch (BeansException ex) {
				if (logger.isWarnEnabled()) {
					logger.warn("Exception encountered during context initialization - " +
							"cancelling refresh attempt: " + ex);
				}

				// Destroy already created singletons to avoid dangling resources.
				//销毁已创建的Bean
				destroyBeans();

				// Reset 'active' flag.
				//消refresh操作，重置容器的同步标识
				cancelRefresh(ex);

				// Propagate exception to caller.
				throw ex;
			}

			finally {
				// Reset common introspection caches in Spring's core, since we
				// might not ever need metadata for singleton beans anymore...
				resetCommonCaches();
			}
		}
	}
@Override
	public void refresh() throws BeansException, IllegalStateException {
		synchronized (this.startupShutdownMonitor) {
			// Prepare this context for refreshing.
			//调用容器准备刷新的方法，获取容器的当时时间，同时给容器设置同步标识
			prepareRefresh();

			// Tell the subclass to refresh the internal bean factory.
			//告诉子类启动refreshBeanFactory()方法，Bean定义资源文件的载入
			//从子类的refreshBeanFactory()方法启动
			ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

			// Prepare the bean factory for use in this context.
			//为BeanFactory配置容器特性，例如类加载器、事件处理器等
			prepareBeanFactory(beanFactory);

			try {
				// Allows post-processing of the bean factory in context subclasses.
				//为容器的某些子类指定特殊的BeanPost事件处理器
				postProcessBeanFactory(beanFactory);

				// Invoke factory processors registered as beans in the context.
				//调用所有注册的BeanFactoryPostProcessor的Bean
				invokeBeanFactoryPostProcessors(beanFactory);

				// Register bean processors that intercept bean creation.
				//为BeanFactory注册BeanPost事件处理器.
				//BeanPostProcessor是Bean后置处理器，用于监听容器触发的事件
				registerBeanPostProcessors(beanFactory);

				// Initialize message source for this context.
				//初始化信息源，和国际化相关
				initMessageSource();

				// Initialize event multicaster for this context.
				//初始化容器事件传播器.
				initApplicationEventMulticaster();

				// Initialize other special beans in specific context subclasses.
				//调用子类的某些特殊Bean初始化方法
				onRefresh();

				// Check for listener beans and register them.
				//为事件传播器注册事件监听器.
				registerListeners();

				// Instantiate all remaining (non-lazy-init) singletons.
				//初始化所有剩余的单例Bean
				finishBeanFactoryInitialization(beanFactory);

				// Last step: publish corresponding event.
				//初始化容器的生命周期事件处理器，并发布容器的生命周期事件
				finishRefresh();
			}

			catch (BeansException ex) {
				if (logger.isWarnEnabled()) {
					logger.warn("Exception encountered during context initialization - " +
							"cancelling refresh attempt: " + ex);
				}

				// Destroy already created singletons to avoid dangling resources.
				//销毁已创建的Bean
				destroyBeans();

				// Reset 'active' flag.
				//消refresh操作，重置容器的同步标识
				cancelRefresh(ex);

				// Propagate exception to caller.
				throw ex;
			}

			finally {
				// Reset common introspection caches in Spring's core, since we
				// might not ever need metadata for singleton beans anymore...
				resetCommonCaches();
			}
		}
	}

friends