Spring

1、Spring概述

• Spring是什么？

  Spring框架是一个开放源代码的J2EE（现在更名JavaEE了）应用程序框架(准确来说是一个框架体系)，由Rod Johnson发起，是针对bean的生命周期进行管理的轻量级容器。

  Spring官网：Spring | Home

  ---

  外话：Spring在英文中是春天的意思，正如英文名一样，Spring开启了Java的春天，让Java成为现在很多企业开发的首选语言，成功稳固了Java的地位，它是目前最受欢迎的企业级 Java 应用程序开发框架，毫不夸张地说，想从事Java开发Spring是必学的（当然也就是就目前而言，说不定又出来了一个很牛的框架呢）

• Spring的特点：

  • 轻量。完整的Spring框架可以在一个大小只有1MB多的JAR文件里发布。并且Spring所需的处理开销也是微不足道的
  • 控制反转。Spring通过一种称作控制反转(IOC)）的技术促进了低耦合
  • 面向切面。Spring提供了面向切面编程(AOP)的丰富支持，允许通过分离应用的业务逻辑与系统级服务（例如审计（auditing）和事务（transaction）管理）进行内聚性的开发
  • 组件化。Spring 实现了使用简单的组件配置组合成一个复杂的应用。在 Spring 中可以使用 XML 和 Java 注解组合这些对象。这使得我们可以基于一个个功能明确、边界清晰的组件有条不紊的搭 建超大型复杂应用系统
  • 声明式。很多以前需要编写代码才能实现的功能，现在只需要声明需求即可由框架代为实现
  • 一站式。在 IOC 和 AOP 的基础上可以整合各种企业应用的开源框架和优秀的第三方类库。而且 Spring 旗下的项目已经覆盖了广泛领域，很多方面的功能性需求可以在 Spring Framework 的基 础上全部使用 Spring 来实现

• Spring的优点：

  • 提高Java开发的效率。主要体现在易于测试、易于开发这两点，易于测试是因为Spring为Junit提供了方便的测试环境，易于开发有三点体现：一是因为Spring本身是框架，符合框架一般性的特点（简化开发），二是有了Spring，用户不必再为单实例模式类、属性文件解析等这些很底层的需求编写代码，可以更专注于上层的应用，三是Spring提供的IoC容器，我们可以将对象之间的依赖关系交由Spring进行控制，避免硬编码¹所造成的过度程序耦合

  • 使用灵活轻巧。灵活体现：Spring并不强制应用完全依赖于Spring，开发者可自由选用Spring框架的部分或全部；轻巧体现：Spring最初版本只有2M！后来经过Spring设计师的精心设计，使用了大量设计模式，让Spring逐渐趋于完美

  • 低侵入式²设计，代码污染³极低。

  • 提高Java程序的性能。Spring框架的设计师在Spring中封装了大量的设计模式⁴，让开发的Java程序具有更优秀的性能

  ……

• Spring家族体系

  Spring是一个家族，常见的有：Spring Framework、Spring MVC、Spring Boot、Spring Cloud……

  • Spring Framwork：是Spring家族的基础，其他Spring框架都是在它的基础上诞生的，一般而言，我们通常说的Spring就是指Spring Framework，它与Spring MVC 和 MyBatis 三者的整合合称SSM
  • Spring MVC：是基于MVC模式，使用Java语言开发实现的一个轻量级 Web 框架，解决页面代码和后台代码的分离
  • Spring Boot：用来简化新Spring应用的初始搭建以及开发过程
  • Spring Cloud：是一系列框架的有序集合，它将各家公司开发的比较成熟、经得起实际考验的服务框架组合起来，最终给开发者留出了一套简单易懂、易部署和易维护的分布式系统开发工具包

  ……

  推荐阅读：

  • Spring发展史：Spring Boot/Cloud 背后豪华的研发团队了

2、IOC

IOC（Inversion Of Control，反转控制）：一种资源获取方式，以前获取某个资源需要主动（创建所需的对象，通过对象）获取，现在使用IOC思想就是被动接受（直接使用Spring框架为我们创建好的对象），同时是面向对象编程中的一种设计原则，可以用来减低计算机代码之间的耦合度

---

推荐阅读：浅析控制反转 - 知乎 (zhihu.com)

2.1 IOC概述

• 获取资源的传统方式

  自己做饭：买菜、洗菜、择菜、改刀、炒菜，全过程参与，费时费力，必须清楚了解资源创建整个过程 中的全部细节且熟练掌握。 在应用程序中的组件需要获取资源时，传统的方式是组件主动的从容器中获取所需要的资源，在这样的 模式下开发人员往往需要知道在具体容器中特定资源的获取方式，增加了学习成本，同时降低了开发效率

• 反转控制方式获取资源

  点外卖：下单、等、吃，省时省力，不必关心资源创建过程的所有细节。 反转控制的思想完全颠覆了应用程序组件获取资源的传统方式：反转了资源的获取方向——改由容器主 动的将资源推送给需要的组件，开发人员不需要知道容器是如何创建资源对象的，只需要提供接收资源 的方式即可，极大的降低了学习成本，提高了开发的效率。这种行为也称为查找的被动形式

• DI（Dependency Injection，依赖注入）

  DI 是 IOC 的另一种表述方式：即组件以一些预先定义好的方式（例如：set 方法）接受来自于容器 的资源注入。相对于IOC而言，这种表述更直接。 所以结论是：IOC 就是一种反转控制的思想， 而 DI 是对 IOC 的一种具体实现

• IOC的优点：

  • 提高开发效率。所有的资源类都是使用已经创建好的，不需要手动创建，同时不需要关注对象的创建过程
  • 便于与测试。借由IOC容器，我们的业务代码不需要为单元测试作出修改，只需要在测试的时候，把测试的实例注册到IOC的容器中就可以了
  • 提高程序的可维护性。IOC降低了类之间的耦合度，降低耦合度

• IOC容器的实现：

  Spring 的 IOC 容器就是 IOC 思想的一个落地的产品实现。IOC 容器中管理的组件也叫做 bean。在创建 bean 之前，首先需要创建 IOC 容器。Spring中提供了 IOC 容器的两种实现方式：BeanFactory和ApplicationContext

  • 方式一：BeanFactory

    这是 IOC 容器的基本实现，是 Spring 内部使用的接口。面向 Spring 本身，不提供给开发人员使用。

    双击Shift，搜索BeanFactory，然后Ctrl+H查看BeanFactory的类继承关系

    

    

  • 方式二：ApplicationContext

    BeanFactory的子接口，提供了更多高级特性。面向 Spring 的使用者，几乎所有场合都使用ApplicationContext而不是底层的 BeanFactory

2.2 基于XML管理Bean

使用注解管理Bean比使用XML要更加简便，但当我们在项目中使用第三方类库时，我们无法在别人写的jar包中使用注解管理Bean对象，所以XML管理也是必须要会的

2.2.1 快速入门

• Step1：创建Maven工程

  目录结构：

  

• Step2：导入依赖

  pom.xml：

  <?xml version="1.0" encoding="UTF-8"?>
  <project xmlns="http://maven.apache.org/POM/4.0.0"
           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
           xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
      <modelVersion>4.0.0</modelVersion>
  
      <groupId>org.example</groupId>
      <artifactId>day05_spring</artifactId>
      <version>1.0-SNAPSHOT</version>
  
      <properties>
          <maven.compiler.source>8</maven.compiler.source>
          <maven.compiler.target>8</maven.compiler.target>
          <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      </properties>
  
      <dependencies>
          <!--DI依赖的jar包-->
          <dependency>
              <!--spring（间接引入ioc容器依赖）-->
              <groupId>org.springframework</groupId>
              <artifactId>spring-context</artifactId>
              <version>5.3.22</version>
          </dependency>
          <!--junit-->
          <dependency>
              <groupId>junit</groupId>
              <artifactId>junit</artifactId>
              <version>4.13.2</version>
          </dependency>
      </dependencies>
      
  </project>
  

• Step3：编写spring配置文件

  

  applicationContext.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对象交给IOC容器进行管理-->
      <bean id="helloWord" class="com.hhxy.pojo.HelloWorld"></bean>
  </beans>
  

  备注：bean类的创建可以在实体类创建后进行创建，这样会有提示

• Step4：编写实体类

  HelloWord：

  package com.hhxy.pojo;
  
  /**
   * @author ghp
   * @date 2022/9/13
   */
  public class HelloWorld {
      public void sayHello(){
          System.out.println("Hello IOC!");
      }
  }
  

• Step5：测试

  测试类：

  import com.hhxy.pojo.HelloWorld;
  import org.junit.Test;
  import org.springframework.context.ApplicationContext;
  import org.springframework.context.support.ClassPathXmlApplicationContext;
  
  /**
   * XML配置IOC入门测试
   * @author ghp
   * @date 2022/9/13
   */
  public class HelloWordTest {
      @Test
      public void hellWorldTest(){
          //1、获取IOC容器
          ApplicationContext ioc = new ClassPathXmlApplicationContext("applicationContext.xml");
          //2、通过Bean的id获取IOC容器中的HelloWorld类的bean对象（强转是方便调用实体类的特有方法）
          HelloWorld helloWord = (HelloWorld) ioc.getBean("helloWord");
          //3、调用实体类方法
          helloWord.sayHello();
      }
  }
  

  测试结果：

拓展：

注意事项：Spring框架为实体类创建一个对象底层是使用反射进行实现的，而反射创建对象百分之99都是利用无参构造器来创建对象的，因为我们可以百分百肯定无参构造器长啥样，而无法确定一个类的有参构造器长啥样，所以为了提高容错率（当然这也是一种规范），当我们创建实体类时，如果实体类有有参构造方法，就必须手动创建一个无参构造方法，不然会报异常org.springframework.context.support.AbstractApplicationContext refresh

当然了，强大的IDEA会在编译时，就会给出警告~ o(*￣▽￣*)ブ

2.2.2 获取Bean三种方式

Spring配置文件 spring-ioc.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">
    <!--为Student实体类配置一个bean对象-->
    <bean id="studentOne" class="com.hhxy.pojo.Student"></bean>
    <bean id="studentTwo" class="com.hhxy.pojo.Student"></bean>
</beans>

• 方式一：根据id获取

  Spring配置文件：

  测试类：

          //1、获取IOC容器
          ApplicationContext ioc = new ClassPathXmlApplicationContext("spring-ioc.xml");
          //2、获取IOC容器中的Bean对象
          Student studentOne = (Student) ioc.getBean("studentOne");
  		//打印输出
  		System.out.println(studentOne);
  

• 方式二：根据类型获取

          //1、获取IOC容器
          ApplicationContext ioc = new ClassPathXmlApplicationContext("spring-ioc.xml");
          //2、获取IOC容器中的Bean对象
          Student student = ioc.getBean(Student.class);
          System.out.println(student);
  

  注意事项一：必须保障Spring配置文件中Bean对象的唯一性

  使用这种方式获取Bean对象，配置文件种必须有且只有一个该数据类型的Bean对象，否则会报org.springframework.beans.factory.NoUniqueBeanDefinitionException异常（另外两种方式不存在这个问题）

  举一个反例：

  

  注意事项二：可以通过Bean对象的接口类型获取该Bean对象，前提也需要该Bean对象必须唯一

  这是因为IOC容器对象的getBean方法是向上兼容⁵的，这样虽然可以获取，诞生获取的Bean对象无法使用实现类的的特有方法

       //1、获取IOC容器
       ApplicationContext ioc = new ClassPathXmlApplicationContext("spring-ioc.xml");
       //2、获取IOC容器中的Bean对象
       Person person = ioc.getBean(Person.class);
       System.out.println(person);
  

  

• 方式三：根据id和类型获取

          //1、获取IOC容器
          ApplicationContext ioc = new ClassPathXmlApplicationContext("spring-ioc.xml");
          //2、获取IOC容器中的Bean对象
          Student studentOne = ioc.getBean("studentOne", Student.class);
          System.out.println(studentOne);
  

2.2.3 依赖注入

依赖注入就是指为实体类的属性⁶进行赋值的这一过程，本质就是通过成员变量的Set方法给成员变量设置值，所以使用这种方式Set方法是必须要有的，否则报org.springframework.beans.NotWritablePropertyException异常

• spring-ioc.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">
      <!--为Student实体类配置一个bean对象-->
      <bean id="studentOne" class="com.hhxy.pojo.Student">
          <property name="id" value="1"></property>
          <property name="name" value="张三"></property>
          <property name="age" value="22"></property>
          <property name="gender" value="男"></property>
      </bean>
      <bean id="studentTwo" class="com.hhxy.pojo.Student"></bean>
  </beans>
  

• 测试类：

  import com.hhxy.pojo.Student;
  import org.junit.Test;
  import org.springframework.context.ApplicationContext;
  import org.springframework.context.support.ClassPathXmlApplicationContext;
  
  /**
   * @author ghp
   * @date 2022/9/14
   */
  public class IOCByXMLTest {
  
      @Test
      public void IOCTest(){
          //1、获取IOC容器
          ApplicationContext ioc = new ClassPathXmlApplicationContext("spring-ioc.xml");
          //2、获取IOC容器中的Bean对象
          Student studentOne = ioc.getBean("studentOne", Student.class);
          System.out.println(studentOne);
      }
  }
  

• 测试结果：

  

拓展：为特殊类型的属性赋值

前面我们是给普通属性（基本数据类型的属性）进行赋值，现在我们学习一下如何给特殊属性赋值，主要包括：给属性赋值为null、给属性赋值特殊符号、为对象类型的属性赋值、为数组类型的属性赋值、为集合类型的属性赋值

• 给属性赋值为null，由于value属性设置的是字面量⁷，所以无法直接使用，可以通过使用null标签进行赋值

  <property name="name">
      <null/>
      <!--
  	这里也可以使用双标签：<null></null>
  	name、value属性也可以这样写
  	-->
  </property>
  

• 给属性赋值特殊符号，需要进行转义，转义有两种方式

  • 方式一：使用转义符

    <property name="expression" value="a &lt; b"/>
    

  • 方式二：使用CDATA区

    <property name="expression">
        <value><![CDATA[a < b]]></value>
    </property>
    

• 为对象类型的属性赋值

  • 方式一：引用外部已声明的bean

        <bean id="studentOne" class="com.hhxy.pojo.Student">
            <property name="id" value="1"></property>
            <property name="name" value="张三"></property>
            <property name="age" value="22"></property>
            <property name="gender" value="男"></property>
            <property name="clazz" ref="clazzRef"></property>
        </bean>
        <bean id="clazzRef" class="com.hhxy.pojo.Clazz">
            <property name="id" value="1"></property>
            <property name="className" value="计科一班"></property>
        </bean>
    

    测试结果：

    

  • 方式二：使用级联方式

    注意事项：必须先给对象的属性进行实例化，否则会报错（这种方式其实就是起到一个修改的作用，还是推荐使用方式一）

    可以直接在Student类中将clazz字段直接使用new进行实例化，或者使用外部引入的方式也是对clazz字段进行了实例化

        <bean id="studentOne" class="com.hhxy.pojo.Student">
            <property name="id" value="1"></property>
            <property name="name" value="张三"></property>
            <property name="age" value="22"></property>
            <property name="gender" value="男"></property>
            <!--使用级联，先使用ref给对象的属性进行赋值，否则会报错-->
            <property name="clazz" ref="clazzRef"></property>
            <property name="clazz.id" value="2"></property>
            <property name="clazz.clazzName" value="计科二班"></property>
        </bean>
    
        <bean id="clazzRef" class="com.hhxy.pojo.Clazz">
            <property name="id" value="1"></property>
            <property name="clazzName" value="计科一班"></property>
        </bean>
    

  测试结果：

  

  • 方式三：内部bean

        <bean id="studentOne" class="com.hhxy.pojo.Student">
            <property name="id" value="1"></property>
            <property name="name" value="张三"></property>
            <property name="age" value="22"></property>
            <property name="gender" value="男"></property>
            <property name="clazz">
                <bean id="clazzInner" class="com.hhxy.pojo.Clazz">
                    <property name="id" value="2"></property>
                    <property name="clazzName" value="计科二班"></property>
                </bean>
            </property>
        </bean>
    

    注意：内部Bean对象只能在外部Bean的内部使用，无法在外部访问（即：无法直接通过IOC容器获取内部Bean对象），这一点类似于内部类

• 为数组类型的属性赋值：

      <bean id="studentOne" class="com.hhxy.pojo.Student">
          <property name="id" value="1"></property>
          <property name="name" value="赵六"></property>
          <property name="age" value="26"></property>
          <property name="gender" value="女"></property>
          <!--
          数组存储的是字面量类型的数据，使用value，直接进行赋值
          数组存储的是类对象类型的数据，使用ref，引用外部已申明的bean
          -->
          <property name="hobbies">
              <array>
                  <value>唱</value>
                  <value>跳</value>
                  <value>rap</value>
              </array>
          </property>
      </bean>
  

  测试成功：

  

• 为集合类型的属性赋值：

  • 为List集合类型的属性进行赋值

    • 方式一：使用list标签进行外部引入

          <bean id="clazzOne" class="com.hhxy.pojo.Clazz">
              <property name="id" value="1"></property>
              <property name="clazzName" value="计科一班"></property>
              <property name="students">
                  <!--
      				List集合中的元素是类对象类型的就用ref
      				如果是普通类型的就使用value
      			-->
                  <list>
                      <ref bean="student1"></ref>
                      <ref bean="student2"></ref>
                  </list>
              </property>
          </bean>
      
          <bean id="student1" class="com.hhxy.pojo.Student">
              <property name="id" value="1"></property>
              <property name="name" value="赵六"></property>
              <property name="age" value="26"></property>
              <property name="gender" value="女"></property>
          </bean>
      
          <bean id="student2" class="com.hhxy.pojo.Student">
              <property name="id" value="2"></property>
              <property name="name" value="张三"></property>
              <property name="age" value="25"></property>
              <property name="gender" value="女"></property>
          </bean>
      

    • 方式二：引入集合类型的bean

      	<bean id="clazzOne" class="com.hhxy.pojo.Clazz">
              <property name="id" value="1"></property>
              <property name="clazzName" value="计科一班"></property>
              <property name="students" ref="studentList"></property>
          </bean>
      
          <!--配置一个集合类型的bean，前提需要使用util的约束（IDEA会自动导入约束）-->
          <util:list id="studentList">
              <ref bean="student1"></ref>
              <ref bean="student2"></ref>
          </util:list>
      
          <bean id="student1" class="com.hhxy.pojo.Student">
              <property name="id" value="1"></property>
              <property name="name" value="赵六"></property>
              <property name="age" value="26"></property>
              <property name="gender" value="女"></property>
          </bean>
      
          <bean id="student2" class="com.hhxy.pojo.Student">
              <property name="id" value="2"></property>
              <property name="name" value="张三"></property>
              <property name="age" value="25"></property>
              <property name="gender" value="女"></property>
          </bean>
      

    测试结果：

    

  • 为Map集合类型的属性进行赋值

    • 方式一：使用map标签进行外部引入

          <bean id="student" class="com.hhxy.pojo.Student">
              <property name="id" value="1"></property>
              <property name="name" value="张三"></property>
              <property name="age" value="22"></property>
              <property name="gender" value="男"></property>
              <property name="teacherMap">
                  <map>
                      <!--
                      Map的键如果是字面量使用key，如果是类类型的值就用key-ref
                      Map的值如果是字面量使用value，如果是类类型的值就用value-ref
                      -->
                      <entry key="老师1" value-ref="teacherOne"></entry>
                      <entry key="老师2" value-ref="teacherTwo"></entry>
                  </map>
              </property>
          </bean>
      
          <bean id="teacherOne" class="com.hhxy.pojo.Teacher">
              <property name="id" value="1"></property>
              <property name="teacherName" value="张三"></property>
          </bean>
      
          <bean id="teacherTwo" class="com.hhxy.pojo.Teacher">
              <property name="id" value="2"></property>
              <property name="teacherName" value="李四"></property>
          </bean>
      

    • 方式二：引入集合类型的bean

          <bean id="student" class="com.hhxy.pojo.Student">
              <property name="id" value="1"></property>
              <property name="name" value="张三"></property>
              <property name="age" value="22"></property>
              <property name="gender" value="男"></property>
              <property name="teacherMap" ref="teacherMap"></property>
          </bean>
      
          <util:map id="teacherMap">
              <entry key="老师1" value-ref="teacherOne"></entry>
              <entry key="老师2" value-ref="teacherTwo"></entry>
          </util:map>
      
          <bean id="teacherOne" class="com.hhxy.pojo.Teacher">
              <property name="id" value="1"></property>
              <property name="teacherName" value="张三"></property>
          </bean>
      
          <bean id="teacherTwo" class="com.hhxy.pojo.Teacher">
              <property name="id" value="2"></property>
              <property name="teacherName" value="李四"></property>
          </bean>
      

    • 方式三：使用命名空间

      和前面配置集合类型bean时，也需要提前引入约束，不同的是前面引入util约束IDEA会自动导入，而引入命名空间的约束（P约束）却需要手动引入

      备注：这种方式用的很少，但是要看得懂。该方式不仅能用来为Map集合的属性来赋值，还能用来给其他所有类型的属性来赋值

      xmlns:p="http://www.springframework.org/schema/p"
      

      

          <!--
      	带ref的属性是用来给类类型的属性进行赋值的，不带是给普通属性进行赋值的，取值可以是id或类类型
      	-->
      	<bean id="studentSpace" class="com.hhxy.pojo.Student"
                p:id="666" p:name="小明" p:teacherMap-ref="teacherMap">
          </bean>
      
          <util:map id="teacherMap">
              <entry key="老师1" value-ref="teacherOne"></entry>
              <entry key="老师2" value-ref="teacherTwo"></entry>
          </util:map>
      
          <bean id="teacherOne" class="com.hhxy.pojo.Teacher">
              <property name="id" value="1"></property>
              <property name="teacherName" value="张三"></property>
          </bean>
      
          <bean id="teacherTwo" class="com.hhxy.pojo.Teacher">
              <property name="id" value="2"></property>
              <property name="teacherName" value="李四"></property>
          </bean>
      

  测试结果：

  

2.2.4 构造器注入

构造器注入就是指给实体类的构造器的参数进行赋值

• spring-ioc.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">
      <!--为Student实体类配置一个bean对象-->
      <bean id="studentOne" class="com.hhxy.pojo.Student">
          <constructor-arg value="1"></constructor-arg>
          <constructor-arg value="2"></constructor-arg>
          <constructor-arg value="3"></constructor-arg>
          <constructor-arg value="4"></constructor-arg>
      </bean>
      <bean id="studentTwo" class="com.hhxy.pojo.Student"></bean>
  </beans>
  

  注意事项：构造器注入先根据设置参数的个数匹配与之对应的构造器（这个类似于super，this方法寻找构造方法），如果没有匹配到与之对应的构造器会报org.springframework.beans.factory.BeanCreationException异常，然后再按照构造器中参数的顺序进行一次赋值

• 测试类：

  import com.hhxy.pojo.Student;
  import org.junit.Test;
  import org.springframework.context.ApplicationContext;
  import org.springframework.context.support.ClassPathXmlApplicationContext;
  
  /**
   * @author ghp
   * @date 2022/9/14
   */
  public class IOCByXMLTest {
  
      @Test
      public void IOCTest(){
          //1、获取IOC容器
          ApplicationContext ioc = new ClassPathXmlApplicationContext("spring-ioc.xml");
          //2、获取IOC容器中的Bean对象
          Student studentOne = ioc.getBean("studentOne", Student.class);
          System.out.println(studentOne);
      }
  }
  

• 测试结果：

  

拓展：

• 匹配优先级问题

  当我们的有两个有相同参数的构造器，这时候进行构造器注入会优先匹配精度高的（具体遇到再说吧，现在知道这么多也很快就忘记了，还不如不记😆）。如果想要设置给指定的属性，可以使用name属性指明要赋值的属性；

  示例：

使用name属性修改默认匹配的构造器：

2.3.5 数据源注入

数据源⁸注入就是指为数据源对象配置一个Bean对象，然后将该Bean对象将放到IOC容器中

• Step1：创建Mven工程

  项目目录：

  

• Step2：导入依赖

  pom.xml：

  <?xml version="1.0" encoding="UTF-8"?>
  <project xmlns="http://maven.apache.org/POM/4.0.0"
           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
           xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
      <modelVersion>4.0.0</modelVersion>
  
      <groupId>org.example</groupId>
      <artifactId>day06_spring</artifactId>
      <version>1.0-SNAPSHOT</version>
  
      <properties>
          <maven.compiler.source>8</maven.compiler.source>
          <maven.compiler.target>8</maven.compiler.target>
          <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      </properties>
  
      <dependencies>
          <!--mysql驱动-->
          <dependency>
              <groupId>mysql</groupId>
              <artifactId>mysql-connector-java</artifactId>
              <version>8.0.16</version>
          </dependency>
          <!--德鲁伊数据源（数据库连接池）-->
          <dependency>
              <groupId>com.alibaba</groupId>
              <artifactId>druid</artifactId>
              <version>1.2.12</version>
          </dependency>
  
          <!--spring（间接引入ioc容器依赖）-->
          <dependency>
              <groupId>org.springframework</groupId>
              <artifactId>spring-context</artifactId>
              <version>5.3.22</version>
          </dependency>
          <!--junit-->
          <dependency>
              <groupId>junit</groupId>
              <artifactId>junit</artifactId>
              <version>4.13.2</version>
          </dependency>
      </dependencies>
  </project>
  

• Step3：编写spring配置文件

  spring-ioc.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:context="http://www.springframework.org/schema/context"
         xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">
      <!--引入properties文件，前提是必须引入context约束(上下文约束)-->
      <context:property-placeholder location="classpath:jdbc.properties"/>
      <!--数据库链接池创建bean对象-->
      <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
          <property name="driverClassName" value="${jdbc.driver}"></property>
          <property name="url" value="${jdbc.url}"></property>
          <property name="username" value="${jdbc.username}"></property>
          <property name="password" value="${jdbc.password}"></property>
      </bean>
  </beans>
  

  jdbc.properties：

  jdbc.driver=com.mysql.cj.jdbc.Driver
  jdbc.url=jdbc:mysql:///ssm?useSSL=false&characterEncoding=utf8&useServerPrepStmts=true&serverTimezone=UTC
  jdbc.username=root
  jdbc.password=32345678
  

• Step4：

  import com.alibaba.druid.pool.DruidDataSource;
  import org.junit.Test;
  import org.springframework.context.support.ClassPathXmlApplicationContext;
  import java.sql.SQLException;
  
  /**
   * @author ghp
   * @date 2022/9/15
   */
  public class TestDataSource {
      @Test
      public void dataSourceTest() throws SQLException {
          //1、获取IOC对象
          ClassPathXmlApplicationContext ioc = new ClassPathXmlApplicationContext("spring-dataSource.xml");
          //2、获取IOC中的Bean对象
          DruidDataSource dataSource = ioc.getBean(DruidDataSource.class);
          //测试输出
          System.out.println(dataSource.getConnection());
      }
  }
  

  测试结果：

  

2.3.6 Bean的作用域和生命周期

Bean的作用域

在Spring中可以通过配置bean标签的scope属性来指定bean的作用域范围，各取值含义参加下表：

如果是在WebApplicationContext环境下还会有另外两个作用域（但不常用）：

• spring配置文件：

  <bean class="com.hhxy.User" scope="prototype"></bean>
  

• 测试类：

  @Test
  public void testBeanScope(){
  	ApplicationContext ac = new ClassPathXmlApplicationContext("springscope.xml");
  	User user1 = ac.getBean(User.class);
  	User user2 = ac.getBean(User.class);
  	System.out.println(user1==user2);
      //当scope取值prototype时，输出：false
      //当scope取值singleton时，输出：true
  }
  

Bean的生命周期

• bean对象创建（通过newInstance方法调用无参构造器）
• 给bean对象设置属性
• bean对象初始化之前操作（由bean的后置处理器负责）
• bean对象初始化（需在配置bean时指定初始化方法）
• bean对象初始化之后操作（由bean的后置处理器负责）
• bean对象就绪可以使用 bean对象销毁（需在配置bean时指定销毁方法）
• IOC容器关闭（或者Web服务器关闭）

备注：上述生命周期是针对单例bean对象而言的，对于多例bean对象，IOC容器无法管理多例bean对象的销毁

推荐阅读：面试官：请你说一下 Bean 的生命周期 - 知乎 (zhihu.com)

示例：

测试Bean对象的生命周期

• Step1：

  目录结构：

  

  备注：这里导入依赖的步骤就省略了，这里的依赖就是快速入门中的依赖

• Step2：编写spring配置文件

  spring-life.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:context="http://www.springframework.org/schema/context"
         xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">
  
      <!--引入properties文件-->
      <context:property-placeholder location="classpath:jdbc.properties"/>
  
      <!--为User类创建Bean对象-->
      <bean class="com.hhxy.pojo.User" init-method="initMethod" destroy-method="destroyMethod">
          <property name="id" value="1001"></property>
          <property name="username" value="admin"></property>
          <property name="password" value="123456"></property>
          <property name="age" value="23"></property>
      </bean>
      
      <!--为IOC容器配置一个自定义的后置处理器-->
      <bean class="com.hhxy.process.MyBeanProcessor"></bean>
  </beans>
  

  备注：自定义的后置处理器针对IOC容器中所有的Bean对象

• MyBeanProcessor：

  package com.hhxy.process;
  
  import org.springframework.beans.BeansException;
  import org.springframework.beans.factory.config.BeanPostProcessor;
  
  /**
   * 自定义一个bean的后置处理器
   * @author ghp
   * @date 2022/9/15
   */
  public class MyBeanProcessor implements BeanPostProcessor {
  
      /**
       * 该方法在bean对象的生命周期初始化之前执行
       * @param bean IOC创建的bean对象
       */
      @Override
      public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
          System.out.println("执行了后置处理器MyBeanProcessor的postProcessBeforeInitialization方法");
          return BeanPostProcessor.super.postProcessBeforeInitialization(bean, beanName);
      }
  
      /**
       * 该方法在bean对象的生命周期的初始化之后执行
       */
      @Override
      public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
          System.out.println("执行了后置处理器MyBeanProcessor的postProcessAfterInitialization方法");
          return BeanPostProcessor.super.postProcessAfterInitialization(bean, beanName);
      }
  }
  

• User：

  package com.hhxy.pojo;
  
  /**
   * @author ghp
   * @date 2022/9/15
   */
  public class User {
      private Integer id;
      private String username;
      private String password;
      private Integer age;
  
      public User() {
          System.out.println("生命周期：1、创建对象");
      }
  
      public User(Integer id, String username, String password, Integer age) {
          this.id = id;
          this.username = username;
          this.password = password;
          this.age = age;
      }
  
      public Integer getId() {
          return id;
      }
  
      public void setId(Integer id) {
          System.out.println("生命周期：2、依赖注入");
          this.id = id;
      }
  
      public String getUsername() {
          return username;
      }
  
      public void setUsername(String username) {
          this.username = username;
      }
  
      public String getPassword() {
          return password;
      }
  
      public void setPassword(String password) {
          this.password = password;
      }
  
      public Integer getAge() {
          return age;
      }
  
      public void setAge(Integer age) {
          this.age = age;
      }
  
      public void initMethod() {
          System.out.println("生命周期：3、初始化");
      }
  
      public void destroyMethod() {
          System.out.println("生命周期：4、销毁");
      }
  
      @Override
      public String toString() {
          return "User{" +
                  "id=" + id +
                  ", username='" + username + '\'' +
                  ", password='" + password + '\'' +
                  ", age=" + age +
                  '}';
      }
  }
  

• 测试类：

      /**
       * 测试Bean的生命周期
       */
      @Test
      public void beanLifeTest(){
          //1、获取IOC对象
  //        ClassPathXmlApplicationContext ioc = new ClassPathXmlApplicationContext("spring-dataSource.xml");
          //关闭IOC容器的方法在ConfigurableApplicationContext对象中，使用上面的对象无法关闭IOC容器
          ConfigurableApplicationContext ioc = new ClassPathXmlApplicationContext("spring-life.xml");
          //2、获取IOC中的Bean对象
          User user = ioc.getBean(User.class);
          //测试输出
          System.out.println(user);
          ioc.close();
      }
  

  注意：

  1. 销毁方法存在ConfigurableApplicationContext对象中的，使用ClassPathXmlApplicationContext无法执行close方法
  2. 使用多例模式（即scope="prototype"时），无法执行销毁方法，因为spring无法管理非单例bean的完整生命周期

  测试结果：

  

2.3.7 FactoryBean机制

FactoryBean是Spring提供的一种整合第三方框架的常用机制。和普通的bean不同，配置一个 FactoryBean类型的bean，在获取bean的时候得到的并不是class属性中配置的这个类的对象，而是getObject()方法的返回值。通过这种机制，Spring可以帮我们把复杂组件创建的详细过程和繁琐细节都屏蔽起来，只把最简洁的使用界面展示给我们

• 工厂类：

  package com.hhxy.factory;
  
  import com.hhxy.pojo.User;
  import org.springframework.beans.factory.FactoryBean;
  
  /**
   * @author ghp
   * @date 2022/9/15
   */
  public class UserFactoryBean implements FactoryBean<User> {
      /**
       * @return 创建的对象
       */
      @Override
      public User getObject() throws Exception {
          return new User();
      }
  
      /**
       * @return 工厂创建对象的类型
       */
      @Override
      public Class<?> getObjectType() {
          return User.class;
      }
  }
  
  

• spring配置文件：

  <?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是get方法返回的User对象，而不是工厂对象-->
      <bean class="com.hhxy.factory.UserFactoryBean"></bean>
  </beans>
  

• 测试类：

      /**
       * 测试FactoryBean机制
       */
      @Test
      public void factoryBeanTest(){
          //1、获取IOC对象
          ClassPathXmlApplicationContext ioc = new ClassPathXmlApplicationContext("spring-factory.xml");
          //2、获取IOC中的Bean对象
          User user = ioc.getBean(User.class);
          //测试输出
          System.out.println(user);
      }
  

2.3 基于注解管理Bean

和 XML 配置文件一样，注解本身并不能执行，注解本身仅仅只是做一个标记，具体的功能是框架检测 到注解标记的位置，然后针对这个位置按照注解标记的功能来执行具体操作。 本质上：所有一切的操作都是Java代码来完成的，XML和注解只是告诉框架中的Java代码如何执行。Spring 为了知道程序员在哪些地方标记了什么注解，就需要通过扫描的方式，来进行检测。然后根据注 解进行后续操作。

• 表示组件的常用注解：

  • Component：将类标识为普通组件
  • Controller：将类标识为控制层组件
  • Service：将类标识为业务层组件
  • Repository：将类标识为持久层组件

  备注：后三个注解都是由Component注解扩展出来的，需要注意的是注解不能加在接口上

示例：

• Step1：创建Mvaen工程

  目录结构：

  

• Step2：导入依赖

  和2.2.2的一样，略……

• Step3：编写spring配置文件

  spring-ani=notation.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:context="http://www.springframework.org/schema/context"
         xsi:schemaLocation="http://www.springframework.org/schema/beans
         http://www.springframework.org/schema/beans/spring-beans.xsd
         http://www.springframework.org/schema/context
         https://www.springframework.org/schema/context/spring-context.xsd">
      <!--扫描组件，需要先创建命名空间引入约束-->
      <!--方式一：指定包（效率更高）-->
      <context:component-scan base-package="com.hhxy.controller,com.hhxy.dao.imp,com.hhxy.service.imp"></context:component-scan>
      <!--方式二：使用包扫描（使用方便）-->
  <!--    <context:component-scan base-package="com.hhxy"></context:component-scan>-->
  </beans>
  

  拓展：

  • 排除扫描：（用的很多）

        <context:component-scan base-package="com.hhxy">
            <!--
            type的取值
            annotation:根据注解排除，expression中设置要排除的注解的全类名
            assignable:根据类型排除，expression中设置要排除的类型的全类名
    		还有其他的取值，以后在学，这两给最常用
            -->
            <!--排除@controller注解标记的所有类-->
            <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
        </context:component-scan>
    

  • 指定扫描：（几乎不用，了解即可）

        <context:component-scan base-package="com.hhxy" use-default-filters="false">
            <!--
            use-default-filters:是否扫描包下所有内容（默认是true），想要使用指定扫描需要设置称true
            type的取值
            annotation:根据注解指定，expression中设置要排除的注解的全类名
            assignable:根据类型指定，expression中设置要排除的类型的全类名
            -->
            <!--只扫描com.hhxy包下的@controller注解标记的类-->
            <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
        </context:component-scan>
    

• Step4：编写Java代码

  这里需要使用注解标记类，标记后再到spring配置文件中扫描组件

  

• Step5：测试

  import com.hhxy.controller.UserController;
  import com.hhxy.dao.UserDao;
  import com.hhxy.service.UserService;
  import org.junit.Test;
  import org.springframework.context.ApplicationContext;
  import org.springframework.context.support.ClassPathXmlApplicationContext;
  
  /**
   * 测试使用注解管理Bean
   * @author ghp
   * @date 2022/9/16
   */
  public class IOCByAnnotationTest {
      /**
       * 测试注解管理Bean
       */
      @Test
      public void annotationTest(){
          //1、获取IOC容器对象
          ApplicationContext ioc = new ClassPathXmlApplicationContext("spring-annotation.xml");
          //2、获取Bean对象
          //获取Controller层组件对象
          UserController userController = ioc.getBean(UserController.class);
          System.out.println(userController);
          //获取Service层组件
          UserService userService = ioc.getBean(UserService.class);
          System.out.println(userService);
          //获取Dao层组件
          UserDao userDao = ioc.getBean(UserDao.class);
          System.out.println(userDao);
      }
  }
  

  

拓展：使用注解管理的Bean对象的id

在我们使用XML方式管理Bean的时候，每个Bean都有一个唯一标识，便于在其他地方引用。现在使用 注解后，每个组件仍然应该有一个唯一标识：

• 默认情况类名首字母小写就是bean的id。例如：UserController类对应的Bean的id就是userController

• 自定义Bean的id：

  

2.4 自动装配

自动装配：根据指定的策略，在IOC容器中匹配某一个Bean，自动为指定的Bean中所依赖的类类型或接口类型属性进行赋值

2.4.1 基于XML实现自动装配

使用XML实现Bean对象的自动装配，需要使用使用autowire属性来指定自动装配的策略

自动装配匹配策略有：

• no：没有策略（默认），此时Bean对象的属性采用默认值

• default：采用默认策略（等价no）

• byType：根据要赋值属性的类型进行匹配，然后为属性赋值（用的很多）

  组要注意两种特殊情况：

  • 匹配不到一个Bean，要赋值的属性使用默认值（这种情况一般会报NullPointerException异常）
  • 匹配到多个Bean，IDEA直接在编译阶段报错，运行时会报NoUniqueBeanDefinitionException异常

• byName：根据要赋值的属性的名称进行匹配，然后为属性赋值（很少用，但byType不行时就用byName）

• constructor：根据赋值属性与构造器的参数个数和参数类型进行匹配，然后为属性赋值（几乎不用，前两个搭配就够了）

  使用构造器进行自动装配的例子

示例：

思路（使用三层架构进行模拟）：

目录结构：

<?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">

    <!--为UserDaoImp类配置Bean对象-->
    <bean id="userDao" class="com.hhxy.dao.imp.UserDaoImp"></bean>
    <!--手动为UserServiceImp类配置Bean对象-->
    <bean id="userService" class="com.hhxy.service.imp.UserServiceImp" autowire="byType">
        <!--手动为UserDao接口对象赋值一个实体类对象-->
<!--        <property name="userDao" ref="userDao"></property>-->
    </bean>
    <!--为UserController类配置Bean对象-->
    <bean id="userController" class="com.hhxy.controller.UserController" autowire="byType">
        <!--手动为UserService接口对象进行赋值一个实现类对象-->
<!--        <property name="userService" ref="userService"></property>-->
    </bean>
</beans>

测试：

    /**
     * 测试基于XML实现的自动装配
     */
    @Test
    public void autowireByXMLTest(){
        //1、获取IOC容器对象
        ApplicationContext ioc = new ClassPathXmlApplicationContext("spring-autowire-xml.xml");
        //2、获取Bean对象
        UserController userController = ioc.getBean(UserController.class);
        userController.saveUser();
    }

测试结果：

2.4.2 基于注解实现自动装配

• Step1：创建Maven工程

  目录结构：

  

• Step2：导入依赖

• Step3：编写spring配置文件

  <?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:context="http://www.springframework.org/schema/context"
         xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">
  
      <!--扫描组件-->
      <context:component-scan base-package="com.hhxy"></context:component-scan>
  </beans>
  

• Step4：编写Java代码

  

  备注：@Autowired标识在以下三个地方，都能实现Bean的自动装配

  1. 该注解标识成员变量，不需要设置成员变量set方法（官方不推荐）
  2. 该注解标识set方法（官方推荐）
  3. 该注解标识在为该成员变量的有参构造方法上

  @Autowired注解的匹配策略：

  1. 默认是使用byType策略进行匹配的；

  2. 当匹配到多个Bean时会自动转换成byName策略进行匹配；

  3. 当byType和byName策略都无法成功匹配到Bean，就直接报NoUniqueBeanDefinitionException异常。

     此时可以使用@Qualifier注解指定一个id所对应的Bean为属性赋值

     

  4. 当一个都没有匹配到时，会报NOSuchBeanDefinitionException异常，这和XML实现不同是因为@Autowire注解中有一个required属性，它默认取值为true，未完成自动装配就抛异常。当我们将其设置称false时：@Autowire(required=false)，此时就报空指针异常，和XML实现时一样了（这种情况几乎不会遇到，99%的自动装配使用byType和byName就够了）

  总结起来就是一张图：

  

  推荐阅读：为什么 Spring和IDEA 都不推荐使用 @Autowired 注解

• Step5：测试

      /**
       * 测试基于注解实现的自动装配
       */
      @Test
      public void autowireByAnnotationTest(){
          //1、获取IOC容器对象
          ApplicationContext ioc = new ClassPathXmlApplicationContext("spring-autowire-annotation.xml");
          //2、获取Bean对象
          UserController userController = ioc.getBean(UserController.class);
          userController.saveUser();
      }
  

  测试结果和基于XML实现的自动装配是一样的

3、AOP

3.1 代理模式

AOP的底层实现是离不开代理模式的，所以在了解AOP前需要先来了解代理模式。所谓的代理模式是23种设计模式种的一种，属于结构型模式，它的作用是：通过提供一个代理类，让我们在调用目标 方法的时候，不再是直接对目标方法进行调用，而是通过代理类间接调用，让不属于目标方法核心逻辑 的代码从目标方法中剥离出来——解耦。调用目标方法时先调用代理对象的方法，减少对目标方法的调用和打扰，同时让附加功能能够集中在一起也有利于统一维护。

推荐阅读：

• 每日一个设计模式之【代理模式】
• Spring AOP 和代理的关系？

3.1.1 静态代理

静态代理：代理类和委托类的关系在运行前就确定了

示例：

• Step1：创建Java工程

  目录结构：

  

• Step2：编写目标类

  1）编写目标类的接口

  package com.hhxy.proxy;
  
  /**
   * @author ghp
   * @date 2022/9/17
   */
  public interface Calculator {
      /**
       * 加法
       */
      int add(int i, int j);
  }
  

  2）编写目标类

  package com.hhxy.proxy;
  
  /**
   * 目标类（委托类）
   * @author ghp
   * @date 2022/9/17
   */
  public class CalculatorImp implements Calculator{
      /**
       * 加法
       */
      @Override
      public int add(int i, int j) {
          int result = i + j;
          System.out.println("方法内部: result = "+result);
          return result;
      }
  }
  

• Step3：编写代理类

  须知：如果目标类实现了接口，代理类也需要实现

  package com.hhxy.proxy;
  
  /**
   * 静态代理类
   * @author ghp
   * @date 2022/9/17
   */
  public class CalculatorStaticProxy implements Calculator {
      //1、获取目标类对象
      private CalculatorImp target;
      public CalculatorStaticProxy(CalculatorImp target) {
          this.target = target;
      }
  
      //2、给代理对象的方法添加附加代码
      /**
       * 加法
       */
      @Override
      public int add(int i, int j) {
          System.out.println("add方法运行前逻辑");
          int result = target.add(i, j);
          System.out.println("add方法运行后逻辑");
          return result;
      }
  }
  

  代理类可以给代理对象的方法添加附加代码的地方有四个，分别是：代理前，代理后，catch，finally

  

• Step4：测试

      @Test
      public void staticProxyTest(){
          //1、获取静态代理类对象
          CalculatorStaticProxy staticProxy = new CalculatorStaticProxy(new CalculatorImp());
          //2、通过代理对象调用目标类的方法
          staticProxy.add(1,2);
      }
  

  测试结果：

  

静态代理确实实现了解耦，但是由于代码都写死了（一个静态代理方法只能为一个目标类的方法进行代理），完全不具备任何的灵活性。就拿日志功能来 说，将来其他地方也需要附加日志，那还得再声明更多个静态代理类，那就产生了大量重复的代码，日志功能还是分散的，没有统一管理。 提出进一步的需求：将日志功能集中到一个代理类中，将来有任何日志需求，都通过这一个代理 类来实现。这就需要使用动态代理技术了！

3.1.2 动态代理

动态代理：代理类和委托类的关系在运行时确定，能够帮助任何类创建代理类（底层是使用反射实现的）。

动态代理分为两种：JDK动态代理、CGLIB动态代理

• JDK代理：基于接口进行动态代理，使用反射技术

  只能对该类所实现接口中定义的方法进行代理，同时代理类需要实现目标类的接口（基于这种特性，可以趣称JDK代理方式为 拜把子模式），否则报java.lang.ClassCastException: com.sun.proxy.$Proxy4 cannot be cast to com.hhxy.proxy.Calculator异常，这在实际编程中有一定的局限性，而且使用反射的效率也不高，生成的代理类在com.sun.proxy包下，类名为$proxy数字

• CGLIB代理：基于类进行动态代理，使用字节码技术

  比使用反射的效率要高，但CGBIL不能对final修饰的方法进行代理，因为CGBIL原理是动态生成委托类（目标类）的子类，生成的代理类和目标类在同一包下（基于这种特性，可以趣称CGLIB代理方式为 认干爹模式）

JDK代理

• Step1：创建Java工程

  目录结构：

• Step2：编写目标类

  和静态代理中的目标类一样，略……

• Step3：编写代理类

  package com.hhxy.proxy;
  
  import java.lang.reflect.InvocationHandler;
  import java.lang.reflect.Method;
  import java.lang.reflect.Proxy;
  
  /**
   * 动态生成代理类的工具类
   * @author ghp
   * @date 2022/9/17
   */
  public class ProxyFactory {
      private Object target;//目标类对象
      public ProxyFactory(Object target){
          this.target = target;
      }
  
      /**
       * 获取动态代理类对象
       * @return
       */
      public Object getProxy() {
          /**
           public static Object newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h)
           参数一: loader表示目标类的类加载器
           参数二: interfaces表示对象实现的所有接口对象的Class对象的数组
           参数三: h表示匿名内部类对象，它是JDK动态代理类实现的核心代码
           */
          return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(),
                  new InvocationHandler() {
                      /**
                       * 这是代理类执行 目标对象中的方法 的方法
                       * @param proxy 表示代理类的对象
                       * @param method 表示要执行的方法
                       * @param args 表示要执行方法的参数列表
                       */
              @Override
              public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                  System.out.println(method.getName()+"方法执行前逻辑");
                  Object result = method.invoke(target, args);
                  System.out.println(method.getName()+"方法执行后逻辑");
                  return result;
              }
          });
      }
  }
  

  知识拓展：

  类加载器有四种：

  • 根类加载器：也称启动类加载器(BootstrapClassLoader)，用于加载核心类库（底层用C实现的）
  • 扩展类加载器(ExtClassLoader)：用于加载阔赞类库
  • 应用类加载器(AppClassLoader）：用于加载开发者写的类或者第三方jar包中的类
  • 自定义类加载器(DefineClassLoader)：该种类加载器有开发者自己定义，作用是从实际场景出发，解决一些应用上的问题，例如：热部署、加密……

• Step4：测试

      /**
       * 测试JDK动态代理
       */
      @Test
      public void dynamicProxyTest(){
          //1、获取动态代理工厂类对象
          ProxyFactory proxyFactory = new ProxyFactory(new CalculatorImp());
          //2、获取静态代理类对象
          Calculator dynamicProxy = (Calculator) proxyFactory.getProxy();
          //3、通过代理类对象调用目标类的方法
          dynamicProxy.add(1,2);
      }
  

  测试结果和静态代理是一样的

CGLIB代理

这里只提供一个简单使用CGLIB进行动态代理的案例

详情见：CGLIB(Code Generation Library) 介绍与原理 | 菜鸟教程 (runoob.com)

• Step1：创建Java工程

  结构目录：

  

• Step2：导入依赖

  pom.xml：

  <?xml version="1.0" encoding="UTF-8"?>
  <project xmlns="http://maven.apache.org/POM/4.0.0"
           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
           xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
      <modelVersion>4.0.0</modelVersion>
  
      <groupId>org.example</groupId>
      <artifactId>day07_spring</artifactId>
      <version>1.0-SNAPSHOT</version>
  
      <properties>
          <maven.compiler.source>8</maven.compiler.source>
          <maven.compiler.target>8</maven.compiler.target>
          <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      </properties>
      <dependencies>
          <!--cglib依赖的jar包-->
          <dependency>
              <groupId>cglib</groupId>
              <artifactId>cglib-nodep</artifactId>
              <version>3.3.0</version>
          </dependency>
          <dependency>
              <groupId>cglib</groupId>
              <artifactId>cglib</artifactId>
              <version>3.3.0</version>
          </dependency>
      </dependencies>
  </project>
  

• Step3：编写目标代码

  和静态代理中的目标类一样，略……

• Step4：编写代理类

  package com.hhxy.proxy;
  
  import net.sf.cglib.proxy.MethodInterceptor;
  import net.sf.cglib.proxy.MethodProxy;
  
  import java.lang.reflect.Method;
  
  /**
   * 目标对象拦截器，作用类似于JDK动态代理中的InvocationHandler接口
   * @author ghp
   * @date 2022/9/17
   */
  public class TargetInterceptor implements MethodInterceptor {
      /**
       * 这是代理类执行 目标对象中的方法 的方法
       * @param o 表示目标对象
       * @param method 表示目标方法
       * @param objects 表示目标方法的参数列表
       * @param methodProxy 表示代理类的对象
       */
      @Override
      public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
          System.out.println(method.getName()+"方法执行前逻辑");
          Object result = methodProxy.invokeSuper(o, objects);
          System.out.println(method.getName()+"方法执行后逻辑");
          return result;
      }
  }
  

• Step5：测试

      /**
       * 测试CGLIB动态代理
       */
      @Test
      public void cglibTest(){
          //1、获取字节码增强器对象Enhancer
          Enhancer enhancer = new Enhancer();
          //2、将目标类设置成父类
          enhancer.setSuperclass(CalculatorImp.class);
          //3、设置拦截器TargetInterceptor
          enhancer.setCallback(new TargetInterceptor());
          //4、生成动态类对象
          Calculator dynamicProxy = (Calculator) enhancer.create();
          //5、通过代理类对象调用目标类的方法
          dynamicProxy.add(1,2);
      }
  

  测试结果和静态代理是一样的

3.2 AOP概述

• AOP是什么？

  AOP（Aspect Oriented Programming，面向切面编程）是一种设计思想，是OOP（Object Oriented Programming，面向对象编程）的一种补充和完善。AOP以通过 预编译方式 和 运行期动态代理方式 实现在不修改源代码的情况下给程序动态统一添加额外功能的一种技术。

• AOP和OOP的联系？

  OOP概念接触的算是比较早的，它的出现时间也是很早的，随着第一个面对对象语言的诞生而诞生，而AOP是后来随着OOP的发展而诞生的，AOP是OOP的补充，两者并不排斥，可以相辅相成。主要是OOP无法面对哪些分散的业务进行抽取，就拿最典型的日志来说，每一个方法都需要进行日志输出，但每一个方法的日志输出信息都不同，我们是无法使用OOP进行抽取的，OOP只适合那种连续性的业务抽取，不适合这种零散的业务抽取，于是AOP就随之诞生了，但总的来讲AOP和OOP的目的都是为了降低项目的耦合度。

  PS：以上纯属个人理解，持续更新纠正中(•̀ ω •́ )✧哈哈，如有错误，欢迎您的指正(●’◡’●)

• AOP的作用：

  • 提高程序的扩展性。AOP引用代理模式，可以很好地对代码进行扩展，增强代码的功能
  • 提高代码的可重用性。AOP抽取了重复的非核心业务代码，能够大大提高代码的可重用性
  • 降低各组件间的耦合度。AOP是面向切面编程，将非核心业务代码都抽取出来了，降低了非核心代码和核心代码的耦合度，提高了组件的内聚性
  • 提高开发效率。核心代码和非核心代码的分离，可以让开发者更关注于核心，并且非核心代码可以重用，从而大大提高开发效率

  ……

• AOP相关基础概念

  • 横切关注点

    横切关注点是一个方法中的非核心业务代码，从每个方法中抽取出来的同一类非核心业务（例如日志就是一个类的非核心业务）。在同一个项目中，我们可以使用多个横切关注点对相关方法进行多个不同方面的增强。 这个概念不是语法层面天然存在的，而是根据附加功能的逻辑上的需要：有十个附加功能，就有十个横切关注点。

  • 通知

    抽取并封装横切关注点而形成的方法称作通知，每一个横切关注点上要做的事情都需要写一个方法来实现，这样的方法就叫通知方法（其实本质就是将所有横切关注点进行封装的代码），简称通知（例如代理方法）。通知中有很多代码，根据代码的不同位置，可以分为：

    • 前置通知（Before Advice）：在目标方法执行前的代码
    • 异常通知（After Throwing Advice）：目标方法有异常后执行的代码
    • 返回通知（After Returning Advice）：目标方法正常执行后执行的代码
    • 后置通知（After Advice）：目标方法最终结束后执行的代码
    • 环绕通知（Around Advice）：除目标方法以外的所有代码（这个就相当于一个完整的代理方法）

    备注：异常通知和返回通知是互斥关系

    图示：

    

  • 切面

    封装了通知方法的类（例如代理类）

  • 目标

    是被代理类（即委托类）的目标对象

  • 代理

    是向目标对象应用通知之后创建的代理对象。需要注意的是代理对象一般是有AOP帮我们创建的，无需手动创建

  • 连接点

    指抽取横切关注点的位置，属于纯逻辑层面的概念。

    需要注意的是，并不是所有横切关注点的位置能被称为连接点，只有哪些被抽取成通知的横切关注点才能被称为连接点

    

  • 切入点

    定位连接点的方式，本质就是一个表达式，属于代码层面的概念。 我们需要使用切入点表达式将通知套到连接点上，从而实现功能的增强。每个类的方法中都包含多个连接点，所以连接点是类中客观存在的事物（从逻辑上来说）。 如果把连接点看作数据库中的记录，那么切入点就是查询记录的 SQL 语句。 Spring 的 AOP 技术可以通过切入点定位到特定的连接点。 切点通过 org.springframework.aop.Pointcut 接口进行描述，它使用类和方法作为连接点的查询条件。

    ---

    说了一大推，总结起来就是：可以把切入点看作一个方法的引用，它是在连接点上用来引用通知的。

  总结：AOP是对OOP的补充（弥补OOP无法抽取封装横切关注点的不足），AOP可以通过对多个横切关注点进行抽取封装成多个通知，这些通知又经过封装形成切面，期间被抽取的横切关注点的位置就称之为连接点，同时还需要使用切入点定位连接点然后引用通知，最终我们就能通过代理访问目标了

3.3 基于注解的AOP

3.3.1 前置知识

AOP主要使用代理模式，其中Spring中关于基于注解的AOP实现，如图所示：

• 动态代理（InvocationHandler）：JDK原生的实现方式，需要被代理的目标类必须实现接口。因为这个技术要求代理对象和目标对象实现同样的接口（兄弟两个拜把子模式）
• CGLIB：通过继承被代理的目标类（认干爹模式）实现代理，所以不需要目标类实现接口
• Aspectj⁹：本质上是静态代理，支持所有情况的代理，它是将代理逻辑“织入”被代理的目标类编译得到的字节码文件，所以最 终效果是动态的。Spring只是借用了AspectJ中的注解，但是并没有使用它的编译器和织入器。其实现原理是JDK动态代理和CGLIB，在运行时生成代理类

总结：Spring基于注解开发，就是使用JDK代理和CGLIB代理来实现动态代理，然后使用Aspectj的注解来进行调用的过程。这也是Spring框架的一大十分亮眼的特点：一站式，可以随意整合市面上几乎所有优秀的框架（就问你服不服，你的就是我的，而且我还是取其精华，去其糟泊，简直是虾仁猪心啊🤣）

3.3.2 快速入门

• Step1：创建Maven工程

  目录结构：

  

• Step2：导入依赖

  pom.xml：

  <?xml version="1.0" encoding="UTF-8"?>
  <project xmlns="http://maven.apache.org/POM/4.0.0"
           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
           xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
      <modelVersion>4.0.0</modelVersion>
  
      <groupId>org.example</groupId>
      <artifactId>day08_spring</artifactId>
      <version>1.0-SNAPSHOT</version>
      <packaging>jar</packaging>
  
      <properties>
          <maven.compiler.source>8</maven.compiler.source>
          <maven.compiler.target>8</maven.compiler.target>
          <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      </properties>
  
      <dependencies>
          <!--spring上下文-->
          <dependency>
              <groupId>org.springframework</groupId>
              <artifactId>spring-context</artifactId>
              <version>5.3.22</version>
          </dependency>
          <!--spring-aspects（由于依赖具有传递性，和spring-context一样会间接导入aspects所需依赖）-->
          <dependency>
              <groupId>org.springframework</groupId>
              <artifactId>spring-aspects</artifactId>
              <version>5.3.22</version>
          </dependency>
          <!--junit-->
          <dependency>
              <groupId>junit</groupId>
              <artifactId>junit</artifactId>
              <version>4.13.2</version>
              <scope>test</scope>
          </dependency>
      </dependencies>
  </project>
  

• Step3：编写目标类

  1）Calculator：

  package com.hhxy.target;
  
  /**
   * @author ghp
   * @date 2022/9/17
   */
  public interface Calculator {
      /**
       * 加法
       */
      int add(int i, int j);
  
      /**
       * 除法
       */
      int div(int i,int j);
  }
  

  2）CalculatorImp：

  package com.hhxy.target;
  
  import org.springframework.stereotype.Component;
  
  /**
   * @author ghp
   * @date 2022/9/17
   */
  @Component
  public class CalculatorImp implements Calculator { //
      /**
       * 加法
       */
      @Override
      public int add(int i, int j) {
          int result = i + j;
          System.out.println("目标方法内部: result = "+result);
          return result;
      }
  
     /**
       * 除法
       */
      //如果接口中没有这个方法，则代理对象中也没有这个方法
      public int div(int i,int j){
          int result = i / j;
          System.out.println("目标方法内部: result = "+result);
          return result;
      }
  }
  

• Step4：编写切面

  package com.hhxy.aop.annotation;
  
  import org.aspectj.lang.JoinPoint;
  import org.aspectj.lang.ProceedingJoinPoint;
  import org.aspectj.lang.Signature;
  import org.aspectj.lang.annotation.*;
  import org.springframework.stereotype.Component;
  
  import java.util.Arrays;
  
  /**
   * 抽取日志业务的切面类
   * @author ghp
   * @date 2022/9/18
   */
  @Component
  @Aspect
  public class LoggerAspect {
  
      /**
       * 在切面类中设置公共的切入表达式，方便切入表达式的重用
       */
      @Pointcut("execution(* com.hhxy.target.CalculatorImp.*(..))")
      public void pointCut(){}
  
      /**
       * 前置通知
       */
      //需要使用指定的注解将方法标识为通知方法，然后定位到连接点（注解所在这一行就是一个切入点）
  //    @Before("execution(public int com.hhxy.target.CalculatorImp.add(int,int))")
      //上面那种写法只能给一个方法加前置通知，我们现在给所有方法添加前置通知
  //    @Before("execution(* com.hhxy.target.CalculatorImp.*(..))")
      @Before("pointCut()")
      //使用JoinPoint获取定位方法的信息（会动态获取，底层使用了反射）
      public void beforeAdvice(JoinPoint joinPoint){
          //获取连接点所在方法的签名信息(签名信息就是方法的声明信息，需要使用getName方法获取方法名)
          Signature signature = joinPoint.getSignature();//int com.hhxy.target.Calculator.add(int,int)
          //获取连接点所在方法的参数列表
          Object[] args = joinPoint.getArgs();
          System.out.println("这是"+signature.getName()+"的前置通知"+",方法参数"+ Arrays.toString(args));
      }
  
      /**
       * 异常通知
       */
      //throwing属性用于指定exception来接收目标方法产生的异常(注意还要给通知添加一个异常类型的参数)
      @AfterThrowing(value = "pointCut()",throwing = "exception")
      public void exceptionAdvice(JoinPoint joinPoint,Throwable exception){
          //获取连接点所在方法的签名信息(签名信息就是方法的声明信息，需要使用getName方法获取方法名)
          Signature signature = joinPoint.getSignature();//int com.hhxy.target.Calculator.add(int,int)
          //获取连接点所在方法的参数列表
          Object[] args = joinPoint.getArgs();
          System.out.println("这是"+signature.getName()+"的异常通知"+",方法参数"+ Arrays.toString(args)+",异常"+ exception);
      }
  
      /**
       * 后置通知
       * @param joinPoint
       */
      @After("pointCut()")
      public void afterAdvice(JoinPoint joinPoint){
          //获取连接点所在方法的签名信息(签名信息就是方法的声明信息，需要使用getName方法获取方法名)
          Signature signature = joinPoint.getSignature();//int com.hhxy.target.Calculator.add(int,int)
          //获取连接点所在方法的参数列表
          Object[] args = joinPoint.getArgs();
          System.out.println("这是"+signature.getName()+"的后置通知"+",方法参数"+ Arrays.toString(args));
      }
  
      /**
       * 返回通知
       */
      //returning属性用于指定result来接收目标方法的返回值(注意还要给通知添加一个Object类型的参数)
      @AfterReturning(value = "pointCut()",returning = "result")
      public void afterReturningAdvice(JoinPoint joinPoint,Object result){
          //获取连接点所在方法的签名信息(签名信息就是方法的声明信息，需要使用getName方法获取方法名)
          Signature signature = joinPoint.getSignature();//int com.hhxy.target.Calculator.add(int,int)
          //获取连接点所在方法的参数列表
          Object[] args = joinPoint.getArgs();
          System.out.println("这是"+signature.getName()+"的返回通知"+",方法参数"+ Arrays.toString(args)+",方法返回值"+result);
      }
  
      /**
       * 环绕通知
       */
  //    @Around("pointCut()")//关闭环绕通知，因为使用了其他四个就没必要使用环绕通知了，想要测试就关闭其他四个再开启这个
      public Object aroundAdvice(ProceedingJoinPoint joinPoint){
          Object result = null;
          try {
              System.out.println("环绕通知-->前置通知");
              //执行目标方法
              result = joinPoint.proceed();
              System.out.println("环绕通知-->返回通知");
          } catch (Throwable e) {
              System.out.println("环绕通知-->异常通知");
              throw new RuntimeException(e);
          }finally {
              System.out.println("环绕通知-->后置通知");
          }
          return result;
      }
  }
  

• Step5：编写spring配置文件

  spring-aop-annotation.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:context="http://www.springframework.org/schema/context"
         xmlns:aop="http://www.springframework.org/schema/aop"
         xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop.xsd">
      <!--注意事项：
      - 切面类和目标类都需要交给IOC进行管理（IOC是AOP的基础）
      - 切面类需要使用@Aspect注解进行标识，告诉JVM这是一个切面类
      -->
  
      <!--扫描组件-->
      <context:component-scan base-package="com.hhxy"></context:component-scan>
  
      <!--想要基于注解实现注解，就必须写上这个标签-->
      <aop:aspectj-autoproxy/>
  
  </beans>
  

• Step6：测试

  import com.hhxy.target.Calculator;
  import org.junit.Test;
  import org.springframework.context.ApplicationContext;
  import org.springframework.context.support.ClassPathXmlApplicationContext;
  
  /**
   * 测试AOP
   * @author ghp
   * @date 2022/9/18
   */
  public class AOPTest {
  
      /**
       * 测试基于注解实现的AOP
       */
      @Test
      public void aopByAnnotationTest(){
          //1、获取IOC对象
          ApplicationContext ioc = new ClassPathXmlApplicationContext("spring-aop-annotation.xml");
          //2、获取代理对象（无法通过IOC获取目标对象）
          Calculator calculatorProxy = ioc.getBean(Calculator.class);
          //3、通过代理对象调用目标方法
          calculatorProxy.div(1,1);
      }
  }
  

  测试结果：

  

  通知的执行顺序于Spring的版本有关系：

  • Spring5.3.x以前的版本：$前置通知\to 执行目标方法\to 后置通知\to 返回通知或异常通知$
  • Spring5.3.x以后的版本：$前置通知\to 执行目标方法\to 返回通知或异常通知\to 后置通知$

3.3.3 切入点表达式语法

• 用*号代替“权限修饰符”和“返回值”部分表示“权限修饰符”和“返回值”不限
• 在包名的部分，一个*号只能代表包的层次结构中的一层，表示这一层是任意的。 例如：*.Hello匹配com.Hello，不匹配com.atguigu.Hello
• 在包名的部分，使用..表示包名任意、包的层次深度任意 在类名的部分，类名部分整体用号代替，表示类名任意 在类名的部分，可以使用号代替类名的一部分 例如：Service匹配所有名称以Service结尾的类或接口
• 在方法名部分，可以使用*号表示方法名任意
• 在方法名部分，可以使用*号代替方法名的一部分 例如：*Operation匹配所有方法名以Operation结尾的方法
• 在方法参数列表部分，使用(..)表示参数列表任意
• 在方法参数列表部分，使用(int,..)表示参数列表以一个int类型的参数开头
• 在方法参数列表部分，基本数据类型和对应的包装类型是不一样的，例如：切入点表达式中使用int和实际方法中Integer是不匹配的
• 在方法返回值部分，如果想要明确指定一个返回值类型，那么必须同时写明权限修饰符
  • 例如：execution(public int ..Service.(.., int)) 正确√
  • 例如：execution( int ..Service.*(.., int)) 错误×