Spring基础原理学习

---

前言

本次主要是针对于Spring的基础概念和原理进行学习

一、Spring是什么？

• Spring是一个轻量级的开源的JavaEE框架（轻量是指它所引入的jar包数量和体积都比较小，开源带来的好处就是社区活跃，集众人之思去解决问题），也是一个生态，比如说它有很多扩展，子项目，spingboot、springcloud，也是其它框架的基石
• Spring可以解决企业应用开发的复杂性
• Spring有两个核心部门：IOC和AOP
  （1）IOC：控制反转，把创建和管理对象的过程交给Spring去管理，降低各个模块之间的耦合度，也减少频繁创建对象带来的开销
  （2）AOP：面向切面编程的思想，Spring支持了AOP，在不改变源代码的基础上可以对功能进行增强，比如说对方法的执行时间进行统计，日志输出，权限鉴定等

二、Spring有什么特点

• 解耦，简化开发
• AOP编程的支持
• 声明式事务的支持
• 方便程序的测试Junit
• 方便整合其它框架Mybatis
• 对常用API进行封装JDBC

三、Spring的xml方式使用

1. 引入对应jar包
   

2. 配置bean.xml

<?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:p="http://www.springframework.org/schema/p"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
	 <bean id="user" class="com.mxf.spring5.User"></bean>
</beans>

@Test
public void testAdd() {
     //1 加载spring配置文件
     BeanFactory context = new ClassPathXmlApplicationContext("bean1.xml");
     //2 获取配置创建的对象
     User user = context.getBean("user", User.class);
     System.out.println(user);
     user.add();
 }

public class User {
   public void add() {
       System.out.println("add......");
   }
}

底层是：工厂模式+反射+xml解析

四、Spring实现IOC容器的两种方式

• BeanFactory: IOC容器的基础实现
• ApplicationContext：继承BeanFactory的同时还继承继承了一些其它的功能EnvironmentCapable, ListableBeanFactory, HierarchicalBeanFactory, MessageSource, ApplicationEventPublisher, ResourcePatternResolver，功能更强大
• BeanFactory在getBean()的时候才会创建对象，采用的是懒初始化
• ApplicationContext加载即创建,快捷键Ctrl+H
  

四、Spring实现DI

xml实现：

<!-- set方法注入属性-->
<bean id="book" class="com.mxf.spring5.Book">
	<property name="bname" value="易筋经"></property>
    <property name="bauthor" value="达摩老祖"></property>
</bean>

<!-- 有参数构造注入属性,要提供有参构造函数-->
<bean id="orders" class="com.mxf.spring5.Orders">
    <constructor-arg name="oname" value="电脑"></constructor-arg>
    <constructor-arg name="address" value="China"></constructor-arg>
</bean>

<!-- p命名空间注入 -->
<beans
xmlns:p="http://www.springframework.org/schema/p" 
....>

<bean id="book" class="com.mxf.spring5.Book" p:bname="九阳神功" p:bauthor="无名氏"></bean>

五、Spring原理概述

• 通过xml或者注解的方式定义了bean的描述信息
• 根据不同的实现定义抽象类/接口，BeanDefinitonRead接口用于解析
  
• 读取xml配置、注解的定义信息存储在BeanDefinition中
• beanfactory父接口，父容器，由它通过反射来创建实例对象，创建前一步由beanFactoryPostProccessor后置增强器转换beanDefinition里面的属性值如子类实现：PlaceholderConfigurerSupport
  
• 可以自定义bean的信息，实现这个BeanFactoryPostProcessor，获取beanDifinition信息，修改里面的值
  
  getBean()------>doGetBean()方法创建实例
  
• 实例化：相当于是在堆内存空间开辟了一块内存空间，属性附上默认值
• 填充属性—>populateBean
• 执行aware接口需要执行的方法，获取bean的相关属性信息，环境信息
• beanPostProcessor.before
• init-method
• beanPostProcessor.after（AOP的实现）
• 初始化：给对象赋值，主要包括两块：1.填充属性，通过set方法；2.执行初始化方法init-method
• 完整对象
• 销毁destory

六、debugSpring初始化过程

ApplicationContext context =
                new ClassPathXmlApplicationContext("bean1.xml");

public ClassPathXmlApplicationContext(String[] configLocations, boolean refresh, @Nullable ApplicationContext parent) throws BeansException {
    super(parent);
    this.setConfigLocations(configLocations);
    if (refresh) {
        this.refresh();
    }
}

public void refresh() throws BeansException, IllegalStateException {
        synchronized(this.startupShutdownMonitor) {
        // 刷新前的准备工作，设置环境值，方便后期操作bean
        this.prepareRefresh();
        // 创建工厂，装配beanDefinition,值为默认值
        ConfigurableListableBeanFactory beanFactory = this.obtainFreshBeanFactory();
        // 给属性赋值
        this.prepareBeanFactory(beanFactory);
		
        try {
        	//修改bean的定义信息
            this.postProcessBeanFactory(beanFactory);
            //待用各种beanFactory的处理器
            this.invokeBeanFactoryPostProcessors(beanFactory);
            // 注册bean的处理器，真正调用的是getBean()
            this.registerBeanPostProcessors(beanFactory);
            // 国际化
            this.initMessageSource();
            // 初始化事件的多播器
            this.initApplicationEventMulticaster();
            this.onRefresh();
            this.registerListeners();
            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();
        }

    }
}

七、Spring循环依赖

A 依赖b属性
B依赖a属性
彼此去容器里面找

//spring三级缓存
public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements SingletonBeanRegistry {
	// 一级缓存
    private final Map<String, Object> singletonObjects = new ConcurrentHashMap(256);
    // 三级缓存
    private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap(16);
    //二级缓存
    private final Map<String, Object> earlySingletonObjects = new HashMap(16);
}

在创建bean的实例化过程和初始化过程分开，在中间过程中给其它对象赋值的时候，并不是一个完整的对象，而是把实例化的对象赋值给了其他对象的属性，后续再对未初始化对象进行初始化。