Spring核心知识总结及底层源码分析

Spring核心知识总结及底层源码分析

本文对Spring框架的核心知识进行总结，并对Spring底层进行分析！
全部是个人对Spring知识的理解及整理，内容持续更新中… …
欢迎评论一起讨论！！！

Spring 基础阶段

一、初始Spring

1.1 spring 是什么

Spring 是分层的 Java SE/EE 应用 full-stack 轻量级开源框架，以 IoC（Inverse Of Control：反转控制）和 AOP（Aspect Oriented Programming：面向切面编程）为内核，提供了展现层 Spring MVC 和持久层 Spring JDBC 以及业务层事务管理等众多的企业级应用技术，还能整合开源世界众多著名的第三方框架和类库，逐渐成为使用最多的 Java EE 企业应用开源框架。

Spring 就是让我们在程序开发中进行解耦合，利用反射动态创建管理对象，更加方便开发。同时增加AOP切面编程功能，对程序拓展更加方便。

Spring 体系架构

1.2 spring 的优势

• 轻量级
  体积小，对代码没有侵入性

• 控制反转，方便解耦，简化开发
  通过 Spring 提供的 IoC 容器，可以将对象间的依赖关系交由 Spring 进行控制，避免硬编码所造成的过度程序耦合。用户也不必再为单例模式类、属性文件解析等这些很底层的需求编写代码，可以更专注于上层的应用。

• AOP 编程的支持
  通过 Spring 的 AOP 功能，方便进行面向切面的编程，许多不容易用传统 OOP 实现的功能可以通过 AOP 轻松应付。

• 声明式事务的支持
  可以将我们从单调烦闷的事务管理代码中解脱出来，通过声明式方式灵活的进行事务的管理，提高开发效率和质量。

• 方便程序的测试
  可以用非容器依赖的编程方式进行几乎所有的测试工作，测试不再是昂贵的操作，而是随手可做的事情。

• 方便集成各种优秀框架
  Spring 可以降低各种框架的使用难度，提供了对各种优秀框架（Struts、Hibernate、Hessian、Quartz等）的直接支持。

• 降低 JavaEE API 的使用难度
  Spring 对 JavaEE API（如 JDBC、JavaMail、远程调用等）进行了薄薄的封装层，使这些 API 的使用难度大为降低。

• Java源码是经典学习范例
  Spring 的源代码设计精妙、结构清晰、匠心独用，处处体现着大师对 Java 设计模式灵活运用以及对 Java 技术的高深造诣。它的源代码无意是 Java 技术的最佳实践的范例。

二、Spring IoC(控制反转)

2.1 什么是程序的耦合

耦合性(Coupling)，也叫耦合度，是对模块间关联程度的度量。耦合的强弱取决于模块间接口的复杂性、调用模块的方式以及通过界面传送数据的多少。模块间的耦合度是指模块之间的依赖关系，包括控制关系、调用关系、数据传递关系。模块间联系越多，其耦合性越强，同时表明其独立性越差( 降低耦合性，可以提高其独立性)。耦合性存在于各个领域，而非软件设计中独有的，但是我们只讨论软件工程中的耦合。在软件工程中，耦合指的就是就是对象之间的依赖性。对象之间的耦合越高，维护成本越高。因此对象的设计应使类和构件之间的耦合最小。软件设计中通常用耦合度和内聚度作为衡量模块独立程度的标准。

划分模块的一个准则就是高内聚低耦合。

它有如下分类：

（1）内容耦合： 当一个模块直接修改或操作另一个模块的数据时，或一个模块不通过正常入口而转入另一个模块时，这样的耦合被称为内容耦合。内容耦合是最高程度的耦合，应该避免使用之。

（2）公共耦合： 两个或两个以上的模块共同引用一个全局数据项，这种耦合被称为公共耦合。在具有大量公共耦合的结构中，确定究竟是哪个模块给全局变量赋了一个特定的值是十分困难的。

（3） 外部耦合 ： 一组模块都访问同一全局简单变量而不是同一全局数据结构，而且不是通过参数表传递该全局变量的信息，则称之为外部耦合。

（4） 控制耦合 ： 一个模块通过接口向另一个模块传递一个控制信号，接受信号的模块根据信号值而进行适当的动作，这种耦合被称为控制耦合。

（5）标记耦合 ： 若一个模块 A 通过接口向两个模块 B 和 C 传递一个公共参数，那么称模块 B 和 C 之间存在一个标记耦合。

（6） 数据耦合： 模块之间通过参数来传递数据，那么被称为数据耦合。数据耦合是最低的一种耦合形式，系统中一般都存在这种类型的耦合，因为为了完成一些有意义的功能，往往需要将某些模块的输出数据作为另一些模块的输入数据。

（7） 非直接耦合 ： 两个模块之间没有直接关系，它们之间的联系完全是通过主模块的控制和调用来实现的。

总结：

耦合是影响软件复杂程度和设计质量的一个重要因素，在设计上我们应采用以下原则：如果模块间必须存在耦合，就尽量使用数据耦合，少用控制耦合，限制公共耦合的范围，尽量避免使用内容耦合。

内聚与耦合

内聚标志一个模块内各个元素彼此结合的紧密程度，它是信息隐蔽和局部化概念的自然扩展。内聚是从功能角度来度量模块内的联系，一个好的内聚模块应当恰好做一件事。它描述的是模块内的功能联系。耦合是软件结构中各模块之间相互连接的一种度量，耦合强弱取决于模块间接口的复杂程度、进入或访问一个模块的点以及通过接口的数据。 程序讲究的是低耦合，高内聚。就是同一个模块内的各个元素之间要高度紧密，但是各个模块之间的相互依存度却要不那么紧密。内聚和耦合是密切相关的，同其他模块存在高耦合的模块意味着低内聚，而高内聚的模块意味着该模块同其他模块之间是低耦合。在进行软件设计时，应力争做到高内聚，低耦合。

2.3 IoC和DI

• IoC (Inverse of Control) 控制反转，通过Spring对象工厂完成对象的创建
• DI (Dependency Injection)依赖注入，在Spring完成对象创建的同时依赖Spring容器完成对象属性的赋值

总结：IoC就是通过Spring对象工程帮助我们完成对象创建，通过Bean标签配置，DI是实现对象中属性的依赖注入，例如在Bean的标签体内通过property标签进行属性的赋值。
因此： 我们可以理解为，Spring的IOC其实是包含DI的。

2.2 DI依赖注入的三种方式

Spring容器加载配置文件之后，通过反射创建类的对象，并给属性赋值；
Spring容器通过反射实现属性注入有三种方式：

• set方法注入
  在bean标签中通过配置property标签给属性属性赋值，实际上就是通过反射调用set方法完成属性的注入
• 构造器注入
  使用constructor-arg标签进行属性注入即可
• 接口注入（不常用）

2.3 Spring Bean标签

作用：

用于配置对象让 spring 来创建的。

默认情况下它调用的是类中的无参构造函数。如果没有无参构造函数则不能创建成功。

属性：

id：给对象在容器中提供一个唯一标识。用于获取对象。

class：指定类的全限定类名。用于反射创建对象。默认情况下调用无参构造函数。

scope：指定对象的作用范围。

• singleton :默认值，单例的.

• prototype :多例的.

  • request :WEB 项目中,Spring 创建一个 Bean 的对象,将对象存入到 request 域中.

  • session :WEB 项目中,Spring 创建一个 Bean 的对象,将对象存入到 session 域中.

  • global session :WEB 项目中,应用在 Portlet 环境.如果没有 Portlet 环境，那么globalSession 相当于 session.

• init-method：指定类中的初始化方法名称。

• destroy-method：指定类中销毁方法名称。

2.4 Spring Bean 的作用域

在bean标签可以通过scope属性指定对象的的作用域

• scope=“singleton” 表示当前bean是单例模式（默认饿汉模式，Spring容器初始化阶段就会完成此对象的创建；当在bean标签中设置 lazy-init="true"变为懒汉模式）
• scope=“prototype” 表示当前bean为非单例模式，每次通过Spring容器获取此bean的对象时都会创建一个新的对象

2.5 Spring Bean的生命周期

• 单例对象：scope=“singleton”

  一个应用只有一个对象的实例。它的作用范围就是整个引用。

  • 生命周期：

    对象出生：当应用加载，创建容器时，对象就被创建了。

    对象活着：只要容器在，对象一直活着。

    对象死亡：当应用卸载，销毁容器时，对象就被销毁了。

• 多例对象：scope=“prototype”

  每次访问对象时，都会重新创建对象实例。

  • 生命周期：

    对象出生：当使用对象时，创建新的对象实例。

    对象活着：只要对象在使用中，就一直活着。

    对象死亡：当对象长时间不用时，被 java 的垃圾回收器回收了

在bean标签中通过init-method属性指定当前bean的初始化方法，初始化方法在构造器执行之后执行，通过destroy-method属性指定当前bean的销毁方法，销毁方法在对象销毁之前执行

2.6 BeanFactory 和 ApplicationContext 的区别

• BeanFactory 是 Spring 容器中的顶层接口。

  ApplicationContext 是它的子接口。

• BeanFactory 和 ApplicationContext 的区别：

  创建对象的时间点不一样。

  ApplicationContext：只要一读取配置文件，默认情况下就会创建对象。

  BeanFactory：什么时候使用什么时候创建对象。

2.7 ApplicationContext 接口的实现类

ClassPathXmlApplicationContext：

它是从类的根路径下加载配置文件（推荐使用这种）

FileSystemXmlApplicationContext：

它是从磁盘路径上加载配置文件，配置文件可以在磁盘的任意位置。

AnnotationConfigApplicationContext:

当我们使用注解配置容器对象时，需要使用此类来创建 spring 容器。它用来读取注解。

2.8 Spring 自动装配

自动装配：Spring在实例化当前bean的时候从Spring容器中找到匹配的实例赋值给当前bean的属性
自动装配策略有两种：

autowire="byName"：byName就是通过名字去匹配，根据当前bean的属性名在spring容器中寻找匹配的对象, 但是：如果根据name找到了bean，但是类型不匹配，抛出异常。
autowire="byType": byType根据当前Bean的属性类型在spring容器中寻找匹配的对象。但是：如果根据类型找到了多个bean，也会抛出异常。

总结： 所有对象是都交给Spring进行管理的，我们在一个对象中使用另外一个对象的时候，可以使用自动装配，这样就不用显式的new一个对象。

2.9 SpringIoc工作原理

3.1 IoC常用注解

3.2.1 @Component

• 类注解，声明此类被Spring容器进行管理，相当于bean标签的作用
• @Component(value="stu") value属性用于指定当前bean的id，相当于bean标签的id属性；value属性也可以省略，如果省略当前类的id默认为类名首字母改小写
• 除了@Component之外 @Service、@Controller、@Repository这三个注解也可以将类声明给Spring管理，他们主要是语义上的区别
  • @Controller 注解主要声明将控制器类配置给Spring管理，例如Servlet
  • @Service 注解主要声明业务处理类配置Spring管理，Service接口的实现类
  • @Repository 直接主要声明持久化类配置给Spring管理，DAO接口
  • @Component 除了控制器、servcie和DAO之外的类一律使用此注解声明

3.2.2 @Scope

• 类注解，用于声明当前类单例模式还是 非单例模式，相当于bean标签的scope属性
• @Scope(“prototype”) 表示声明当前类为非单例模式（默认单例模式）

3.2.3 @Lazy

• 类注解，用于声明一个单例模式的Bean是否为懒汉模式
• @Lazy(true) 表示声明为懒汉模式，默认为饿汉模式

3.2.4 @PostConstruct

• 方法注解，声明一个方法为当前类的初始化方法（在构造器之后执行），相当于bean标签的init-method属性

3.2.5 @PreDestroy

• 方法注解，声明一个方法为当前类的销毁方法（在对象从容器中释放之前执行），相当于bean标签的destory-method属性

3.2.6 @Autowired

• 属性注解、方法注解（set方法），声明当前属性自动装配，默认byType

• @Autowired(required = false) 通过requried属性设置当前自动装配是否为必须（默认必须——如果没有找到类型与属性类型匹配的bean则抛出异常）

  • byType

  • ref引用

  @Autowired
  public void setClazz(@Qualifier("c2") Clazz clazz) {
      this.clazz = clazz;
  }
  

3.2.7 @Resource

• 属性注解，也用于声明属性自动装配
• 默认装配方式为byName，如果根据byName没有找到对应的bean，则继续根据byType寻找对应的bean，根据byType如果依然没有找到Bean或者找到不止一个类型匹配的bean,则抛出异常。

四、代理模式

基本介绍：

  1. 代理模式：为一个对象提供一个替身，以控制对这个对象的访问。即通过代理对象访问目标对象.这样做的好处是:可以在目标对象实现的基础上，增强额外的功能操作,即扩展目标对象的功能。
  2. 被代理的对象可以是远程对象、创建开销大的对象或需要安全控制的对象.
  3. 代理模式有不同的形式, 主要有三种 静态代理、动态代理 (JDK代理、接口代理)和Cglib代理 (可以在内存动态的创建对象，而不需要实现接口， 他是属于动态代理的范畴) 。

4.1 静态代理

静态代理在使用时,需要定义接口或者父类,被代理对象(即目标对象)与代理对象一起实现相同的接口或者是继承相同父类。

步骤：

1. 定义一个公共的接口。
2. 目标对象实现公共的接口。
3. 代理对象实现公共的接口，并且代理对象要聚合目标对象（实际上就是聚合的接口，多态的特性）。
4. 通过代理对象的方法调用目标对象的方法进行实现。

静态代理优缺点:

​ 1) 优点：在不修改目标对象的功能前提下, 能通过代理对象对目标功能扩展。

​ 2) 将通用的代码放到代理类中进行实现，提供了代码的复用性。

​ 3) 被代理类中只用关注核心业务的实现，将通用的管理型逻辑（事务管理、日志管理）和业务逻辑分离。

​ 1) 缺点：因为代理对象需要与目标对象实现一样的接口，所以会有很多代理类
​ 2) 一旦接口增加方法,目标对象与代理对象都要维护

4.2 JDK动态代理

使用步骤：

JDK动态代理：是通过被代理对象实现的接口产生其代理对象的（只能对实现了接口的对象进行代理）。
1、创建一个类，实现InvocationHandler接口，重写invoke方法。
2、在类中定义一个Object类的变量，并提供这个变量的有参构造器，用于将被代理对象传递进来。
3、定义getProxy方法，用于创建并返回代理对象。

/**
 * 产生代理对象，返回代理对象
 * @return
 */
public Object getProxy() {
    //1、获取被代理对象的类加载器
    ClassLoader classLoader = obj.getClass().getClassLoader();
    //2、获取被代理对象的实现的接口
    Class<?>[] interfaces = obj.getClass().getInterfaces();
    /*
    3、产生代理对象(通过被代理对象的类加载器及实现类的接口)
    第一个参数：被代理对象的类加载器
    第二个参数：被代理对象实现的接口
    第三个参数：使用产生代理对象调用方法时，用于拦截执行的处理器
     */
    Object o = Proxy.newProxyInstance(classLoader, interfaces, new InvocationHandler() {
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            begin();
            //执行method的方法
            Object returnValue = method.invoke(obj, args);
            commit();
            return returnValue;
        }
    });
    return o;
}

注意： JDK动态代理是通过被代理类实现的接口来创建代理对象的，因此JDK动态代理只能代理实现了接口的类的对象。代理对象会转化成接口类型对象。

4.3 CGLib动态代理

由于JDK动态代理是通过被代理类实现的接口来创建代理对象的，因此JDK动态代理只能代理实现了接口的类的对象。如果一个类没有实现任何接口，该如何产生代理对象呢？

CGLib动态代理，是通过创建被代理类的子类来创建代理对象的，因此即使没有实现任何接口的类也可以通过CGLib产生代理对象

CGLib动态代理不能为final类创建代理对象。

• 实现步骤：

  CGLib动态代理:
  1、添加CGLib依赖
  2、创建一个类，实现MethodInterceptor接口，同时实现接口中的intercept方法。
  3、在类中定义一个Object类型的变量，并提供这个变量的有参构造器，用于传递被代理对象。
  4、定义Proxy方法创建并返回代理对象（代理对象是通过创建被代理类的子类来创建的）
  

• 核心功能

  public Object getProxy() {
      Enhancer enhancer = new Enhancer();
      enhancer.setSuperclass(obj.getClass());
      //指定回调的方法
      enhancer.setCallback(new MethodInterceptor() {
          @Override
          public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
              begin();
              //通过反射调用被代理类的方法
              Object returnValue = method.invoke(obj, objects);
              commit();
              return returnValue;
          }
      });
  
      Object proxy = enhancer.create();
  
      return proxy;
  }
  

五、Spring AOP

Aspect Oriented Programming 面向切面编程，是一种利用“横切”的技术（底层实现就是动态代理），对原有的业务逻辑进行拦截，并且可以在这个拦截的横切面上添加特定的业务逻辑，对原有的业务进行增强。

基于动态代理实现在不改变原有业务的情况下对业务逻辑进行增强。

5.1 AOP 开发步骤

1.创建切面类，在切面类定义切点方法

2.将切面类配置给Spring容器

3.声明切入点

4.配置AOP的通知策略

5.2 AOP各种切入点声明

<aop:pointcut id="book_insert" expression="execution(* com.qfedu.dao.BookDAOImpl.insert())"/>


<aop:pointcut id="book_pc1" expression="execution(void com.qfedu.dao.BookDAOImpl.*())"/>


<aop:pointcut id="book_pc2" expression="execution(void com.qfedu.dao.BookDAOImpl.*(..))"/>


<aop:pointcut id="book_pc3" expression="execution(* com.qfedu.dao.BookDAOImpl.*())"/>


<aop:pointcut id="book_pc4" expression="execution(* com.qfedu.dao.BookDAOImpl.*(..))"/>


<aop:pointcut id="pc5" expression="execution(* com.qfedu.dao.*.*(..))"/>


<aop:pointcut id="pc6" expression="execution(* com.qfedu.dao.*.insert(..))"/>


<aop:pointcut id="pc7" expression="execution(* *(..))"/>

5.3 AOP的注意事项

//如果要使用Spring aop面向切面编程，调用切入点方法的对象必须通过Spring容器获取
//如果一个类中的方法被声明为切入点并且织入了切点之后，通过Spring容器获取该类对象，实则获取到的是一个代理对象
//如果一个类中的方法没有被声明为切入点，通过Spring容器获取的就是这个类真实创建的对象
//BookServiceImpl bookService = new BookServiceImpl();
BookServiceImpl bookService = (BookServiceImpl) 
context.getBean("bookServiceImpl");
bookService.addBook();

5.4 AOP的通知策略

AOP通知策略：就是声明将切面类中的切点方法如何织入到切入点

• before
• after
• after-throwing
• after-returning
• around

<aop:aspect ref="myAspect">
    
    <aop:before method="method1" pointcut-ref="book_insert" />
    
    <aop:after method="method2" pointcut-ref="book_insert" />

    
    <aop:after-throwing method="method3" pointcut-ref="book_insert" />

    
    <aop:after-returning method="method4" pointcut-ref="book_insert" />

    <aop:around method="method5" pointcut-ref="book_insert" />
aop:aspect>

//环绕通知的切点方法，必须准守如下的定义规则：
//1.必须带有一个ProceedingJoinPoint类型的参数
//2.必须有Object类型的返回值
//3.在前后增强的业务逻辑之间执行Object v = point.proceed();
//4.方法最后返回v
public Object method5(ProceedingJoinPoint point) throws Throwable {
    System.out.println("~~~~~~~method5---before");
    //此代码的执行，就表示切入点方法的执行
    Object v = point.proceed();
    System.out.println("~~~~~~~method5---after");
    return v;
}

5.5 Spring AOP 基于注解的使用

@Component
@Aspect
public class TransactionManager {

    @Pointcut("execution(* com.qfedu.dao.*.*(..))")
    public void pc1(){}


    @Before("pc1()")
    public void begin(){
        System.out.println("~~~~开启事务");
    }

    @After("pc1()")
    public void commit(){
        System.out.println("~~~~提交事务");
    }

    @Around("pc1()")
    public Object printExecuteTime(ProceedingJoinPoint point) throws Throwable {
        long time1 = System.currentTimeMillis();
        Object v = point.proceed();
        long time2 = System.currentTimeMillis();
        System.out.println("----time:"+(time2-time1));
        return v;
    }
}

注意：注解使用虽然方便，但是只能在源码上添加注解，因此我们的自定义类提倡使用注解配置；但如果如果使用到第三方提供的类则需要通过xml配置形式完成配置。

5.6 SpringAOP 事务管理

isolation 设置事务隔离级别：READ_UNCOMMITTED ,READ_COMMITTED , REPEATABLE_READ , SERIALIZABLE

5.7 事务的传播机制

propagation 设置事务的传播机制

• REQUIRED 如果上层方法没有事务，则创建一个新的事务；如果已经存在事务，则加入到事务中。

• SUPPORTS 如果上层方法没有事务，则以非事务方式执行；如果已经存在事务，则加入到事务中。

• REQUIRES_NEW 如果上层方法没有事务，则创建一个新的事务；如果已经存在事务，则将当前事务挂起。

• NOT_SUPPORTED 如果上层方法没有事务，则以非事务方式执行；如果已经存在事务，则将当前事务挂起。

• NEVER 如果上层方法没有事务，则以非事务方式执行；如果已经存在事务，则抛出异常。

• MANDATORY 如果上层方法已经存在事务，则加入到事务中执行；如果不存在事务则抛出异常。

• NESTED 如果上层方法没有事务，则创建一个新的事务；如果已经存在事务，则嵌套到当前事务中。

Spring高级核心知识总结

一、Spring如何解决循环依赖问题？

循环依赖：

• 相互依赖：A依赖B B依赖A
• 三者间依赖：A依赖B B依赖C C依赖A
• 自我依赖：自己依赖自己

Spring提供了三级缓存机制来解决循环依赖问题，当我们通过getBean()去获取一个对象实例的时候，会先去一级缓存中找，如果没有找到，再去二级缓存中找，如果没有找到，那说明该对Bean还没有实例化。Spring就会去实例化这个Bean，这就是早起的Bean，那么这个早期的Bean就会作为一个目标Bean被放入二级缓存，同时加入标记是否有循环依赖存在，如果不存在就放入二级缓存，否则就等待下一次循环，也就是会解析@Autowrid注解，待复制完成后，将目标Bean放入一级缓存。

因此，Spring一级缓存存放所有成熟的Bean（目标Bean），二级缓存存放早起Bean。

三级缓存存放代理Bean，也就是如果Spring发现某些Bean需要使用工厂来创建，那么就存入三级缓存，成熟的Bean都存入一级。

四种情况无法解决循环依赖：

1. 多实例Bean通过setter注入。
2. 构造器注入Bean的情况。
3. 单例的单例Bean通过setter注入。
4. 设置@Dependson注解的。