Spring学习笔记

Posted 2020-09-18

关于Spring

---

 

Spring 框架是一个基于 Java 的开源框架平台，并且为实现 Java 应用程序提供了全面的基础架构支持。 你可以专注于你的应用，让 Spring 来帮助你处理基础架构的问题。

Java 应用程序小到 HelloWorld，大到N层的复杂架构的企业级应用，这些应用里面包含着各种的协作对象，程序里面的对象是相互之间依赖的。尽管Java平台提供的很多功能性的应用程序，但是它缺少将这些基础组件组织成一个整体的方法，最终把这些整合工作交给了架构师或是开发者。你可以使用设计模式，例如工厂，抽象工厂，建造者，装饰和服务定位来将这些不同的类和示例对象组合起来，从而构建一个应用。但是，这些模式仅仅只是：一个被给予名字的最佳实践，说明了该模式做什么，怎样应用，解决了什么问题等等。 模式是形式化的，你必须在你的应用中去实现它。

Spring中的IoC（控制反转）也称为DI（依赖注入），解决了这个问题，通过提供一种有效的方式将各个分开的组件组合成一个完全可供使用的应用。这些组件间的依赖，交由给Spring去管理，从而减少对象依赖间的麻烦。 IOC是Spring重要思想之一。

Spring的目标是致力于全方位的简化Java开发。为了降低Java开发复杂性，Spring采取了以下4种关键策略：

1、基于POJO的轻量级和最小侵入性编程

2、通过依赖注入和面向接口实现松耦合

3、基于切面和惯例进行声明式编程

4、通过切面和模板减少样板式代码

 

IOC和DI

---

 

Spring的核心是IOC容器和DI。

什么是IOC？什么又是DI？

控制反转（Inversion of Control）是一种是面向对象编程中的一种设计原则，用来减低计算机代码之间的耦合度。其基本思想是：借助于“第三方”实现具有依赖关系的对象之间的解耦。

这里，对象A、B、C分别都依赖对象1、2、3，这些对象相互协调工作但朴素耦合，一旦其中那一个对象出问题，整个系统就崩溃了。对象之间的耦合是避免不了的，这是协作的基础。但一旦系统做大了，对象之间的依赖关系也越来越复杂，经常会出现对象之间的多重依赖性关系，因此，架构师和设计师对于系统的分析和设计，将面临更大的挑战。对象之间耦合度过高的系统，必然会出现牵一发而动全身的情形。

由于有了第三方IOC的加入，对象间的耦合就降低了，但对象间的协作需要通过第三方IOC的协调和粘合，全部对象的控制权都得上交给IOC容器。

依赖注入（DI）就是将实例变量传入到一个对象中去(Dependency injection means giving an object its instance variables)。通过DI，对象的依赖关系将第系统中负责协调各对象的第三方组件在创建对象的时候进行设定，对象无需要自行创建或管理他们的依赖关系。

IOC和DI两者关系:

控制反转(IOC)是一种软件工程的解耦合的思想。

依赖注入(DI)是一种设计模式，可以作为控制反转的一种实现模式。

Spring IOC容器使用依赖注入作为实现控制反转的方式，但是控制反转还有其他的实现方式，例如说ServiceLocator，所以不能将控制反转和依赖注入等同。

 Spring各模块

---

Spring这个基于Java技术的平台可以理解为一个生态，在这个生态环境里面，有许多的模块组成，扩展到不同的领域。在官方文档上面写到，在Spring框架组织内大约有20个模块。这些模块组成了不同的功能:

1. Core Container(Spring 核心容器)
2. AOP(SpringAOP模块)
3. Data Access/Integration(数据访问与集成)
4. Web(Spring的Web支持)
5. Instrumentation
6. Messaging
7. Test

构建Spring应用

---

搭建基于Spring的Maven项目

1、Maven加入依赖

加入Spring核心依赖模块:

<!--Spring-->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>4.3.8.RELEASE</version>
    <exclusions>
        <exclusion>
            <groupId>commons-logging</groupId>
            <artifactId>commons-logging</artifactId>
        </exclusion>
    </exclusions>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-core</artifactId>
    <version>4.3.8.RELEASE</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-beans</artifactId>
    <version>4.3.8.RELEASE</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-test</artifactId>
    <version>4.3.8.RELEASE</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-expression</artifactId>
    <version>4.3.8.RELEASE</version>
</dependency>
<!--Spring-->

去除Spring依赖的commons-logging日志加入sl4j-log4j日志工具：

<!--Logging-->
<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>jcl-over-slf4j</artifactId>
    <version>1.5.8</version>
</dependency>
<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-api</artifactId>
    <version>1.5.8</version>
</dependency>
<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-log4j12</artifactId>
    <version>1.5.8</version>
</dependency>
<dependency>
    <groupId>log4j</groupId>
    <artifactId>log4j</artifactId>
    <version>1.2.14</version>
</dependency>
<!--logging-->

log4j.properties:

log4j.rootCategory=INFO, stdout
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d{ABSOLUTE} %5p %t %c{2}:%L - %m%n
log4j.category.org.springframework.beans.factory=DEBUG

2、以一个英勇的骑士执行的任务为例子，对比传统应用和Spring应用

一个Knight接口，代表骑士行为:

public interface Knight {
  void embarkOnQuest();
}

一个Quest接口，代表着探险任务行为:

public interface Quest {
  void embark();
}

一个拯救少女的探险任务:

public class RescueDamselQuest implements Quest {
  public void embark() {
    System.out.println("Embarking on a quest to rescue the damsel.");
  }
}

骑士的实现:

public class DamselRescuingKnight implements Knight {
  private RescueDamselQuest quest;
  public DamselRescuingKnight() {
    this.quest = new RescueDamselQuest();
  }
  public void embarkOnQuest() {
    quest.embark();
  }
}

骑士实现了Knight接口，有了embarkOnQuest功能，DamselRescuingKnight在构造函数中自行构建了RescueDamselQuest，这使得DamselRescuingKnight和RescueDamseQuest紧密地连接在一起，这极大限制了骑士执行的探险任务。如果有其他的Quest让骑士去embarkOnQuest，那骑士就无能为力了。

3、加入Spring支持

改造DamselRescuingKnight变成BraveKnight：

public class BraveKnight implements Knight {
  private Quest quest;
  public BraveKnight(Quest quest) {
    this.quest = quest;
  }
  public void embarkOnQuest() {
    quest.embark();
  }
}

BraveKnight没有自行创建探险任务，而是将探险任务当作构造参数传进来，属于构造函数注入。任何探险任务只实现了Ouest接口都可以被注入进来让BraveKnight响应。

新建一个SlayDragonQuest类:

public class SlayDragonQuest implements Quest {

    private PrintStream stream;

    public SlayDragonQuest(PrintStream stream) {
        this.stream = stream;
    }

    public void embark() {

        stream.println("Embarking on quest to slay the dragon!");
    }

}

这个实现Ouest的接口可以注入到时Knight之中，

项目中新建一个spring-context.xml文件，在源码的路径下。创建对象之间的协作行为称之为装配，Spring有许多装配Bean的方式，XML、JavaCode、基于注解的自动装配。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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    <!--声明一个Bean以及它的依赖关系-->
    <bean id="slayDragonQuest" class="com.test.bean.SlayDragonQuest">
        <constructor-arg value="#{T(java.lang.System).out}"></constructor-arg>
    </bean>
    <bean id="braveKnight" class="com.test.bean.BraveKnight">
        <constructor-arg ref="slayDragonQuest"/>
    </bean>

</beans>

顶级Beans声名这是一个Bean容器，Bean元素代表是一个Bean，可对这个Bean进行配置。

id标识这个Bean，class指定Bean的类路径。Constructor-arg用于构造注入，SlayDragonQuest的构造方法需要注入一个PrintStream对象，这里用Spel表达式，将java.lang.System.out这个PrintStream类型的常量注进去。

BraveKnight的构造方法需要注入一个Ouest类型，ref引用了id为slayDragonQuest的Bean。

新建一个Main方式使用:

//获取IOC容器
ApplicationContext context = new ClassPathXmlApplicationContext("spring-context.xml");
//获取一个Bean
Knight knight = context.getBean(Knight.class);
knight.embarkOnQuest();

Spring通过应用上下文（Application Context）来装配bean的定义把它们组装起来，Spring全权负责bean的创建和组装。Spring有多种上下文的实现，区别就是如何加载bean的配置。

4、应于切面编程

DI能够让相互协作的软件组件保持松散耦合，而面向切面编程AOP能让你把遍布在应用各地的组件分离出来形成可征用的组件。

面向切面编程(AOP)往往定义为促使软件系统实现关注点分离的一项技术。一个系统有许多不同组件组成，每一个组件都负责一项特定的功能，除了完成特定的核心功能，这些组件都承担额外的职责，诸如日志、事务、系统安全这些的系统服务经常融入到自身的核心业务之中，这些系统服务被称为横切关注点，它们横跨系统的各个组件。

AOP能将这些系统服务模块化，并将他们以声明的形式应用到它们需要影响的组件之中。所受影响的组件完全不用关注这些系统的服务，只需要关注自身核心的业务。

例子：

在骑士进行冒险之前用吟游诗人这个服务来记载骑士的所有事迹。

public class Minstrel {

    private PrintStream stream;

    public Minstrel(PrintStream stream) {
        this.stream = stream;
    }

    public void singBeforeQuest() {
        stream.println("Fa la la, the knight is so brave!");
    }

    public void singAfterQuest() {
        stream.println("Tee hee hee, the brave knight " +
                "did embark on a quest!");
    }

}

 

在骑士进行冒险之前，调用singBeforeQuest，冒险回来之后，会调用singAfterQuest方法。不使用AOP会这样做:

public class BraveKnight implements Knight {

    private Quest quest;
    private Minstrel minstrel;

    public BraveKnight(Quest quest, Minstrel minstrel) {
        this.quest = quest;
        this.minstrel = minstrel;

    }

    public void embarkOnQuest() {
        minstrel.singBeforeQuest();
        quest.embark();
        minstrel.singAfterQuest();
    }

}

 

但吟诗不是骑士的职责，骑士还要知道一位的吟诗诗人才行。这样简单的BraveKnight就变得复杂了。

可以利用AOP声明Minstrel必需要在骑士进行冒险任务之前进行吟诗，而骑士不必要知道诗人的存在。要将Minstrel变成一个切面，需要在配置文件里面声明它.

Maven依赖文件加入aspectj(一个强大的AOP框架，弥补Spring AOP框架不足):

<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.8.10</version>
</dependency>

sprng-context配置文件声明AOP:

   <bean id="minstrel" class="com.test.bean.Minstrel">
        <constructor-arg value="#{T(java.lang.System).out}"/>
    </bean>
    <aop:config>
        <aop:aspect ref="minstrel">
            <aop:pointcut id="embark" expression="execution(* *.embarkOnQuest(..))"/>
            <aop:before method="singBeforeQuest" pointcut-ref="embark"/>
            <aop:after method="singAfterQuest" pointcut-ref="embark"/>
        </aop:aspect>
    </aop:config>

使用SpringAOP命名空间将Minstrel声明为一个切面，首先得将Minstrel声明为一个Bean,然后在<aop:aspect>引用该Bean,

<aop:pointcut>定义一个切入点，并且用expression来应用通知，expression使用的是Aspect表达式。该表达式可灵活配置。

使用<aop:before>在embarkOnQuest方法执行之前调用Minstrel的singBeforeQuest方法。这叫前置通知。Method指定调用方法，pointcut-ref指定切入点。

使用<aop:after>在embarkOnQuest方法执行之后调用Minstrel的singAfterQuest方法，这叫后置通知。Method指定调用方法，pointcut-ref指定切入点。

使用AOP，Minstrel可以应用到Knight中，而且Knight不知道有Minstrel存在。