Spring初理解

一、Spring简介

1.什么是框架及作用

• 源自于建筑学，隶属土木工程，后发展到软件工程领域

• 软件工程框架

  • 经过验证

  • 具有一定功能

  • 半成品
    

2.Spring是什么

Spring框架一个分层架构的JavaSE/EE应用full-stack轻量级开源框架。

分层：针对三层架构设计

full-stack：Spring功能非常强大，能够服务于Java开发过程中的各个层面

轻量级：资源消耗较低，运行速度较快

最终目的：简化企业级应用程序的开发

3.Spring的体系结构

4.Spring的发展历史

作者：Rod Johnson 罗宾·约翰逊

5.Spring优势

Spring的优势
方便解耦，简化开发
方便集成各种优秀框架
方便程序的测试
AOP编程的支持
声明式事务的支持
降低JavaEE API的使用难度
Java源码是经典学习范例

6.Spring官网文档（学习）

要学好一门框架技术，那么相应的官网文档自然必不可少。

Spring官网：https://spring.io/

这个是主要使用的官方文档，研究一门语言，必不可少的就是研究其官方文档。

7.Spring两大核心

spring框架的两大核心：IOC与AOP。必须掌握内容，以下是详细介绍：

二、IOC

1. IOC简介

• IoC（Inversion Of Control）控制反转，Spring反向控制应用程序所需要使用的外部资源
• Spring控制的资源全部放置在Spring容器中，该容器称为IoC容器
• IoC是面向对象编程的一种设计原则，可以用来降低代码之间的耦合度

2. 对IOC的理解

2.1 首先IOC到底是什么？

Ioc—Inversion of Control，即“控制反转”，不是什么技术，而是一种设计思想。

2.2 IOC中“谁控制谁，控制什么，为何是反转（有反转就应该有正转了），哪些方面反转了”？

• 谁控制了谁，控制什么：传统Java程序需要我们在对象内部进行new才可以进行创建对象，是程序直接取创建依赖对象；而IOC是有一个专门的容器来创建这些对象，即是IOC；所以这里就知道了–是IOC控制了对象，控制了外部资源的获取（不只是对象，包括文件等）。

//例如一般Java程序引用对象
private UserService userService = new UserServiceImpl();

• 为何事反转，哪些方面反转了：将主动变为被动就是反转，由容器帮我们查找和注入依赖对象，对象只是被动的接收依赖对象，所以是反转；是依赖对象被反转了。

2.3 IOC和DI

DI—Dependency Injection，即“依赖注入”：组件之间依赖关系由容器在运行期决定，形象的说，即由容器动态的将某个依赖关系注入到组件之中。**依赖注入的目的并非为软件系统带来更多功能，而是为了提升组件重用的频率，并为系统搭建一个灵活、可扩展的平台。**通过依赖注入机制，我们只需要通过简单的配置，而无需任何代码就可指定目标需要的资源，完成自身的业务逻辑，而不需要关心具体的资源来自何处，由谁实现。

• 谁依赖于谁：应用程序依赖于IOC容器；
• 为什么需要依赖：应用程序需要IOC容器来提供对象所需要的资源；
• 谁注入谁：显然是IOC容器注入应用程序某个对象，应用程序依赖的对象；
• 注入了什么：注入了某个对象所需要的外部资源（包括对象、资源、常量数据）。

IOC和DI的关系：它们是同一个概念的不同角度描述。

3. 耦合和内聚

• 耦合（Coupling）：用于衡量软件中各个模块之间的互联程度
  

• 内聚（Cohesion）：代码书写过程中单个模块内部各组成部分间的联系，用于衡量软件中各个功能模块内部的功能联系

• 优质程序代码书写的目标：高内聚，低耦合

  就是同一个模块内的各个元素之间要高度紧密，但是尽量降低多个模块之间的相互依存度

4. 工厂模式

工厂模式+xml配置文件 就是Spring的雏形！

工厂模式（Factory Pattern）是 Java 中最常用的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。

想要熟练掌握Spring知识，工厂模式学习了解必不可少。

5. IOC配置实现

//首先需要创建一个maven项目
1.在pom.xml文件中导入spring坐标
2.编写业务层与表现层（模拟）接口与实现类
3.建立spring配置文件：resources\applicationContext.xml
4.配置所需资源（Service）为spring控制的资源
5.表现层（App）通过spring获取资源（Service实例）

5.1xml文件格式

1.bean标签

• 名称：bean

• 类型：标签

• 归属：beans标签

• 作用：定义spring中的资源，受此标签定义的资源将受到spring控制

• 格式：

  <beans>
  	<bean />
  </beans>
  

• 基本属性：

  <bean id="beanId" name="beanName1,beanName2" class="ClassName"></bean>
  

  ​ id：bean的名称，通过id值获取bean

  ​ class：bean的类型

  ​ name：bean的名称，可以通过name值获取bean，用于多人配合时给bean起别名

2. bean属性scope

• 名称：scope

• 类型：属性

• 归属：bean标签

• 作用：定义bean的作用范围

• 格式：

  <bean scope="singleton" />
  

• 取值：

  • singleton：设定创建出的对象保存在spring容器中，是一个单例的对象
  • prototype：设定创建出的对象保存在spring容器中，是一个非单例的对象
  • request、session、application、 websocket ：设定创建出的对象放置在web容器对应的位置

3.声明周期

• 名称：init-method，destroy-method

• 类型：属性

• 归属：bean标签

• 作用：定义bean对象在初始化或销毁时完成的工作

• 格式：

  <bean init-method="init" destroy-method="destroy></bean>
  

• 取值：bean对应的类中对应的具体方法名

• 注意事项：

  • 当scope=“singleton”时，spring容器中有且仅有一个对象，init方法在创建容器时仅执行一次

• 当scope=“prototype”时，spring容器要创建同一类型的多个对象，init方法在每个对象创建时均执行一次

  • 当scope=“singleton”时，关闭容器会导致bean实例的销毁，调用destroy方法一次

• 当scope=“prototype”时，对象的销毁由垃圾回收机制gc()控制，destroy方法将不会被执行

小结：

bean标签的几个属性：id, class, name, scope, init-method, destroy-method

4.bean对象创建方式

(1)使用静态工厂：factory-method

• 名称：factory-method

• 类型：属性

• 归属：bean标签

• 作用：定义bean对象创建方式，使用静态工厂的形式创建bean，兼容早期遗留系统的升级工作

• 格式：

• 注意事项：class属性必须配置成静态工厂的类名

  <bean id="factoryBeanId" class="FactoryClassName" factory-method="factoryMethodName" />
  

• 取值：工厂bean中用于获取对象的静态方法名

  public class UserServiceFactory {
  
      public static UserService getService(){
          System.out.println("factory create object...");
          return new UserServiceImpl();
      }
  }
  

(2)使用实例工厂：factory-bean，factory-method

• 名称：factory-bean，factory-method

• 类型：属性

• 归属：bean标签

• 作用：定义bean对象创建方式，使用实例工厂的形式创建bean，兼容早期遗留系统的升级工作

• 格式：

  <!--定义工厂类Bean-->
  <bean id="factoryId" class="FactoryClassName" />
  
  <bean id="factoryBeanId" factory-bean="factoryBeanId" factory-method="factoryMethodName" />
  

• 取值：工厂bean中用于获取对象的实例方法名

• 注意事项：

  • 使用实例工厂创建bean首先需要将实例工厂配置bean，交由spring进行管理

• factory-bean是实例工厂的beanId

  public class UserServiceFactory2 {
  
      public UserService getService(){
          System.out.println(" instance factory create object...");
          return new UserServiceImpl();
      }
  }
  

5.2 注解驱动

1. 什么是注解驱动

使用注解的形式替代xml配置，将繁杂的配置文件从工程中彻底消除掉，简化书写，提高开发效率。

弊端：

• 为了达成注解驱动的目的，可能会将原先很简单的书写，变的更加复杂
  

• XML中配置第三方开发的资源是很方便的，但使用注解驱动无法在第三方开发的资源中进行编辑，因此会增加一部分的代码量

2. 常用注解

启动注解扫描，加载类中配置的注解项。

<context:component-scan base-package="packageName"/>

• 说明：

  • 在进行包所扫描时，会对配置的包及其子包中所有文件进行扫描

  • 扫描过程是以文件夹递归迭代的形式进行的

  • 扫描过程仅读取合法的java文件

  • 扫描时仅读取spring可识别的注解

  • 扫描结束后会将可识别的有效注解转化为spring对应的资源加入IoC容器

• 注意：

  • 无论是注解格式还是XML配置格式，最终都是将资源加载到IoC容器中，差别仅仅是数据读取方式不同

  • 从开发效率上来说注解优于XML配置文件

3. bean的定义

• 名称：@Component

• 类型：类注解

• 位置：类定义上方

• 作用：设置该类为spring管理的bean

• 范例：

  @Component("userService")
  public class UserServiceImpl implements UserService {}
  

• 说明：

  • @Controller(表现层) 、 @Service(业务层) 、 @Repository(数据层)是@Component的衍生注解，功能同@Component

• 相关属性

  • value（默认）：定义bean的访问id

    @Component(value="beanId")
    public class ClassName{}

4. bean的作用域

• 名称：@Scope

• 类型：类注解

• 位置：类定义上方

• 作用：设置该类作为bean对应的scope属性

• 范例：

  @Scope("singleton")
  public class ClassName{}
  

• 相关属性

  • value（默认）：定义bean的作用域singleton、prototype，默认为singleton

    @Scope(value="prototype")
    public class ClassName{}

5. bean的生命周期

• 名称：@PostConstruct、@PreDestroy

• 类型：方法注解

• 位置：方法定义上方

• 作用：设置该类作为bean对应的生命周期方法

• 范例：

  @PostConstruct
  public void init() { System.out.println("init..."); }
  
  @PreDestroy
  public void destroy() {}
  

6. 加载第三方资源

• 名称：@Bean

• 类型：方法注解

• 位置：方法定义上方

• 作用：设置该方法的返回值作为spring管理的bean

• 范例：

  @Bean("dataSource")
  public DruidDataSource createDataSource() {    return ……;    }
  

• 说明：

  • 因为第三方bean无法在其源码上进行修改，使用@Bean解决第三方bean的引入问题

  • 该注解用于替代XML配置中的静态工厂与实例工厂创建bean，不区分方法是否为静态或非静态

  • @Bean所在的类必须被spring扫描加载，否则该注解无法生效

• 相关属性

  • value（默认）：定义bean的访问id

7. bean的非引用类型属性注入

• 名称：@Value

• 类型：属性注解、方法注解

• 位置：属性定义上方，set方法定义上方

• 作用：设置对应属性的值或对方法进行传参

• 范例：

  @Value("zhangsan")
  private String username;
  

• 说明：

  • value值仅支持非引用类型数据
  • value值支持SpEL：@Value("#{'zhangsan'}")
  • @value注解如果添加在属性上方，可以省略set方法
  • value值支持读取properties文件中的属性值，通过类属性将properties中数据传入类中

• 相关属性

  • value（默认）：定义对应的属性值或参数值

8. bean的引用类型属性注入

• 名称：@Autowired、@Qualifier

• 类型：属性注解、方法注解

• 位置：属性定义上方，方法定义上方

• 作用：设置对应属性的对象或对方法进行引用类型传参

• 范例：

  @Autowired(required = false)
  private UserDao userDao;
  

• 说明：

  • @Autowired默认按类型装配

  • 指定@Qualifier后可以指定自动装配的bean的id

    @Autowired
    @Qualifier("userDao")
    private UserDao userDao;
    

• 相关属性

  • required：定义该属性是否允许为null

9. bean装配优先级配置

• 名称：@Primary

• 类型：类注解

• 位置：类定义上方

• 作用：设置类对应的bean按类型装配时优先装配

• 范例：

  @Primary
  public class ClassName{}
  

• 说明：

  • @Autowired默认按类型装配，当出现相同类型的bean，使用@Primary提高按类型自动装配的优先级，多个@Primary会导致优先级设置无效

10. 加载properties文件

• 名称：@PropertySource

• 类型：类注解

• 位置：类定义上方

• 作用：加载properties文件中的属性值

• 范例：

  @PropertySource(value={"classpath:jdbc.properties","classpath:abc.properties"},ignoreResourceNotFound = true)
  public class ClassName {
      @Value("${propertiesAttributeName}")
      private String attributeName;
  }
  

• 说明：

  • 不支持*通配格式
  • 一旦加载，所有spring控制的bean中均可使用对应属性值

• 相关属性

  • value（默认）：设置加载的properties文件名

  • ignoreResourceNotFound：如果资源未找到，是否忽略，默认为false

11. 纯注解格式

• 名称：@Configuration、@ComponentScan

• 类型：类注解

• 位置：类定义上方

• 作用：设置当前类为spring核心配置加载类

• 范例：

  @Configuration
  @ComponentScan("scanPackageName")
  public class SpringConfigClassName{
  }
  

• 说明：

  • 核心配合类用于替换spring核心配置文件，此类可以设置空的，不设置变量与属性

  • bean扫描工作使用注解@ComponentScan替代

AnnotationConfigApplicationContext

• 加载纯注解格式上下文对象，需要使用AnnotationConfigApplicationContext

• 当配置类作为 AnnotationConfigApplicationContext 对象创建的参数时，@Configuration注解可以不写

  AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);
  

12. 第三方bean配置与管理

• 名称：@Import

• 类型：类注解

• 位置：类定义上方

• 作用：导入第三方bean作为spring控制的资源

• 范例：

  @Configuration
  @Import(OtherClassName.class)
  public class ClassName {
  }
  

• 说明：

  • @Import注解在同一个类上，仅允许添加一次，如果需要导入多个，使用数组的形式进行设定

    @Import({JDBCConfig.class, Abc.class})
    

  • @Bean所在的类可以使用导入的形式进入spring容器，无需使用@Component声明

  • 在被导入的类中可以继续使用@Import导入其他资源（了解）

小结

1. 开启注解驱动：<context:component-scan base-package="packageName"/>
2. bean的四种注解定义格式：Component, Controller, Service, Repository
3. bean相关属性注解格式：Scope, Postconstruct, PreDestroy

属性注入

1. 非引用类型注入：@Value

2. 引用类型注入

   • @Autowired = @Inject
   • @Qualifier = @Named
   • @Primary
   • @Resource: name, type

3. 加载properties文件：PropertySource -> Value("${}")

4. 纯注解：Configuration, ComponenScan

5. 第三方导入：Import

13. bean加载控制

(1)@DependsOn

• 名称：@DependsOn

• 类型：类注解、方法注解

• 位置：bean定义的位置（类上或方法上）

• 作用：控制bean的加载顺序，使其在指定bean加载完毕后再加载

• 范例：

  @DependsOn("beanId")
  public class ClassName {
  }
  

• 说明：

  • 配置在方法上，使@DependsOn指定的bean优先于@Bean注解配置的bean进行加载

  • 配置在类上，使@DependsOn指定的bean优先于当前类中所有@Bean配置的bean进行加载

  • 配置在类上，使@DependsOn指定的bean优先于@Component等配置的bean进行加载

• 相关属性

  • value（默认）：设置当前bean所依赖的bean的id

(2)@Order

• 名称：@Order

• 类型：配置类注解

• 位置：配置类定义的位置（类上）

• 作用：控制配置类的加载顺序，其中值越小优先级越高

• 范例：

  @Order(1)
  public class SpringConfigClassName {
  }
  

(3)@Lazy

• 名称：@Lazy

• 类型：类注解、方法注解

• 位置：bean定义的位置（类上或方法上）

• 作用：控制bean的加载时机，使其延迟加载

• 范例：

  @Lazy
  public class ClassName {
  }
  

注意：依赖加载应用场景

@DependsOn

• 微信订阅号，发布消息和订阅消息的bean的加载顺序控制

@Lazy

• 某个业务灾难出现后对应的应急预案处理bean可以延迟加载

@Order

• 多个种类的配置出现后，优先加载系统级的，然后加载业务级的

6. DI（依赖注入）

6.1 set注入（主流）

• 名称：property

• 类型：标签

• 归属：bean标签

• 作用：使用set方法的形式为bean提供资源

• 格式：

  <bean>
  	<property />
  </bean>
  

• 基本属性：

  <!--基本数据类型注入-->
  <property name="propertyName" value="propertyValue" />
  
  <!--引用类型注入-->
  <property name="propertyName" ref="beanId"/>
  

​ name：对应bean中的属性名，要求该属性必须提供可访问的set方法（严格规范：此名称是set方法对应名称）

​ value：设定非引用类型属性对应的值，不能与ref同时使用

​ ref：设定引用类型属性对应bean的id ，不能与value同时使用

• 注意：一个bean可以有多个property标签

小结：

1. 类中写set方法
2. bean中使用property标签注入属性
3. name表示注入的属性名
4. 对象：使用ref进行注入
5. 其他：使用value进行赋值注入

6.2构造方法注入（了解）

• 名称：constructor-arg

• 类型：标签

• 归属：bean标签

• 作用：使用构造方法的形式为bean提供资源，兼容早期遗留系统的升级工作

• 格式：

  <bean>
  	<constructor-arg />
  </bean>
  

• 基本属性：

  <constructor-arg name="argsName" value="argsValue />
  

​ name：对应bean中的构造方法所携带的参数名

​ value：设定非引用类型构造方法参数对应的值，不能与ref同时使用

其他属性：

<constructor-arg index="arg-index" type="arg-type" ref="beanId"/>

​ ref：设定引用类型构造方法参数对应bean的id ，不能与value同时使用

​ type ：设定构造方法参数的类型，用于按类型匹配参数或进行类型校验

​ index ：设定构造方法参数的位置，用于按位置匹配参数，参数index值从0开始计数

• 注意：一个bean可以有多个constructor-arg标签

6.3 集合类型数据注入

• 名称：array，list，set，map，props

• 类型：标签

• 归属：property标签 或 constructor-arg标签

• 作用：注入集合数据类型属性

• 格式：

(1)集合类型数据注入——list

<property name="al">
    <list>
        <value>itheima</value>
        <value>66666</value>
    </list>
</property>

(2)集合类型数据注入——props

<property name="properties">
    <props>
        <prop key="name">itheima666</prop>
        <prop key="value">666666</prop>
    </props>
</property>

(3)集合类型数据注入——array （了解）

<property name="arr">
    <array>
        <value>123456</value>
        <value>66666</value>
    </array>
</property>

(4)集合类型数据注入——set（了解）

 <property name="hs">
     <set>
         <value>itheima</value>
         <value>66666</value>
     </set>
</property>

(5)集合类型数据注入——map（了解）

<property name="hm">
    <map>
        <entry key="name" value="itheima66666"/>
        <entry key="value" value="6666666666"/>
    </map>
</property>

扩展知识

将引用类型注入到map当中，使用value-ref属性

<map>
    <entry key="name" value="itheima66666"/>
    <entry key="value" value="6666666666"/>

    <entry key="userDao" value-ref="userDao" />
</map>

6.4 SpEl（了解）

• Spring提供了对EL表达式的支持，统一属性注入格式

• 类型：属性值

• 归属：value属性值

• 作用：为bean注入属性值

• 格式：

  <property name="name" value="#{value}"/>
  

• 注意：所有属性值不区分是否引用类型，统一使用value赋值

• 所有格式统一使用 value=“#{}”

  • 常量 #{10} #{3.14} #{2e5} #{‘itcast’}

  • 引用bean #{beanId}

  • 引用bean属性 #{beanId.propertyName}

  • 引用bean方法 beanId.methodName().method2()

  • 引用静态方法 T(java.lang.Math).PI

  • 运算符支持 #{3 lt 4 == 4 ge 3}

  • 正则表达式支持 #{user.name matches‘[a-z]{6,}’}

  • 集合支持 #{likes[3]}

• 案例：

   <bean id="userService" class="com.itheima.service.impl.UserServiceImpl">
       <property name="userDao" value="#{userDao}"/>
       <property name="bookDao" value="#{bookDao}"/>
       <property name="num" value="#{666666666}"/>
       <property name="version" value="#{'itcast'}"/>
  </bean>
  

6.5 properties文件

• Spring提供了读取外部properties文件的机制，使用读取到的数据为bean的属性赋值

• 操作步骤

  1.准备外部properties文件

  2.开启context命名空间支持

  <?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"
  xmlns:context="http://www.springframework.org/schema/context"
  xsi:schemaLocation="http://www.springframework.org/schema/beans
  https://www.springframework.org/schema/beans/spring-beans.xsd
  http://www.springframework.org/schema/context
  https://www.springframework.org/schema/context/spring-context.xsd">
  

​ 3.加载指定的properties文件

<context:property-placeholder location="classpath:filename.properties">

​ 4.使用加载的数据

<property name="propertyName" value="${propertiesName}"/>

• 注意：如果需要加载所有的properties文件，可以使用*.properties表示加载所有的properties文件

• 注意：读取数据使用**${propertiesName}格式进行，其中propertiesName**指properties文件中的属性名

• 注意和系统环境变量的冲突

  cmd 
  echo %path%
  //例如
  jdbc.properties文件中的username属性
  

6.6 团队开发-import标签

• 名称：import

• 类型：标签

• 归属：beans标签

• 作用：在当前配置文件中导入其他配置文件中的项

• 格式：

  <beans>
      <import />
  </beans>
  

• 基本属性：

  <import resource=“config.xml"/>
  

​ resource：加载的配置文件名

• Spring容器加载多个配置文件

  new ClassPathXmlApplicationContext("config1.xml","config2.xml");
  

• Spring容器中的bean定义冲突问题

  • 同id的bean，后定义的覆盖先定义的

  • 导入配置文件可以理解为将导入的配置文件复制粘贴到对应位置

  • 导入配置文件的顺序与位置不同可能会导致最终程序运行结果不同

6.7 ApplicationContext

一般测试类中使用，解析applicationContext.xml文件,然后调用getBean方法获取对象，再进行调用CRUD方法。

ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
接口名 对象 = ctx.getBean("接口名");//getBean有很对重载方法可用

6.8 第三方资源配置

• 回顾之前Druid使用方式

  //2.通过Druid连接池工厂类获取数据库连接池对象
  //driverClassName=com.mysql.jdbc.Driver
  //url=jdbc:mysql://192.168.59.129:3306/db14
  //username=root
  //password=itheima
  DataSource dataSource = DruidDataSourceFactory.createDataSource(prop);
  

• 阿里数据源方案Druid

  <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
      <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
      <property name="url" value="jdbc:mysql://localhost:3306/spring_ioc"></property>
      <property name="username" value="root"></property>
      <property name="password" value="root"></property>
  </bean>
  

7. 整合MyBatis和Junit

1. 注解整合MyBatis

1.修改mybatis外部配置文件格式为注解格式

2.业务类使用@Component声明bean，使用@Autowired注入对象

3.编写Spring配置类：SpringConfig，并加载properties文件

4.建立配置文件JDBCConfig与MyBatisConfig类，并将其导入到核心配置类SpringConfig

5.开启注解扫描

6.使用AnnotationConfigApplicationContext对象加载配置项

• 业务类使用注解形式声明bean，属性采用注解注入

• 建立独立的配置管理类，分类管理外部资源，根据功能进行分类，并提供对应的方法获取bean

• 使用注解形式启动bean扫描，加载所有注解配置的资源（bean）

• 使用AnnotationConfigApplicationContext对象加载所有的启动配置类，内部使用导入方式进行关联

2. 注解整合Junit

1.导入Spring整合Junit坐标

• 从Spring5.0以后，要求Junit的版本必须是4.12及以上

<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.12</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-test</artifactId>
    <version>5.1.9.RELEASE</version>
</dependency>

2.Spring接管Junit的运行权，使用Spring专用的Junit类加载器

@RunWith(SpringJUnit4ClassRunner.class)

3.加载Spring配置类

@ContextConfiguration(classes = SpringConfig.class)

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = SpringConfig.class)
public class UserServiceTest {
}

8. IOC底层核心原理

1. IoC核心接口

查看类结构：Ctrl+h

查看内部结构：Alt+7

1. BeanFactory接口
   

2. HierarchicalBeanFactory接口
   

3. AutowireCapableBeanFactory接口
   

4. ListableBeanFactory
   

2. 组件扫描器

• 开发过程中，需要根据需求加载必要的bean，排除指定bean

3. 设定组件扫描加载过滤器

• 名称：@ComponentScan

• 类型：类注解

• 位置：类定义上方

• 作用：设置spring配置加载类扫描规则

• 范例：

  @ComponentScan(
      value="com.qiankun",	           //设置基础扫描路径
      excludeFilters =                   //设置过滤规则，当前为排除过滤
  	@ComponentScan.Filter(            //设置过滤器
  	    type= FilterType.ANNOTATION,  //设置过滤方式为按照注解进行过滤
  	    classes=Service.class)     //设置具体的过滤项，过滤所有@Service修饰的bean
      )
  

​ includeFilters：设置包含性过滤器

​ excludeFilters：设置排除性过滤器

​ type：设置过滤器类型：ANNOTATION, CUSTOM

4. 自定义组件过滤器

• 名称：TypeFilter

• 类型：接口

• 作用：自定义类型过滤器

• 编写自定义过滤器

  public class MyTypeFilter implements TypeFilter {
      
      @Override
      public boolean match(MetadataReader metadataReader, MetadataReaderFactory metadataReaderFactory) throws IOException {
          //通过参数获取加载的类的元数据
          ClassMetadata classMetadata = metadataReader.getClassMetadata();
          //通过类的元数据获取类的名称
          String className = classMetadata.getClassName();
          if(className.equals("com.qiankun.dao.impl.BookDaoImpl")){
              return true;
          }
          return false;
      }
  }
  

• 使用自定义过滤器：设置排除bean，排除的规则是自定义规则（FilterType.CUSTOM），具体的规则定义为（MyTypeFilter.class）

  @ComponentScan(
          value = "com.qiankun",
          excludeFilters = @ComponentScan.Filter(
                  type= FilterType.CUSTOM,
                  classes = MyTypeFilter.class
          )
  )
  

5. 自定义导入器

1.回顾如何让Spring管理bean

• bean只有通过配置才可以进入spring容器，被spring加载并控制

• 配置bean的方式如下：

  • XML文件中使用标签配置

• 使用@Component及衍生注解配置

2.为什么需要使用自定义导入器

• 企业开发过程中，通常需要配置大量的bean，需要一种快速高效配置大量bean的方式

  实现接口ImportSelector

  • 名称： ImportSelector

  • 类型：接口

  • 作用：自定义bean导入器

  • 范例：

  public class MyImportSelector implements ImportSelector {
      public String[] selectImports(AnnotationMetadata icm) {
          return new String[]{"com.qiankun.dao.impl.AccountDaoImpl"};
      }
  }
  

  @Configuration
  @ComponentScan("com.qiankun")
  @Import(MyImportSelector.class)
  public class SpringConfig {
  }
  

6. 自定义注册器

• 名称：ImportBeanDefinitionRegistrar

• 类型：接口

• 作用：自定义bean定义注册器

• 范例：

  public class MyImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {
      public void registerBeanDefinitions(AnnotationMetadata icm, BeanDefinitionRegistry r) {
          ClassPathBeanDefinitionScanner scanner = new ClassPathBeanDefinitionScanner(r, false);
          TypeFilter tf = new TypeFilter() {
              public boolean match(MetadataReader mr, MetadataReaderFactory mrf) throws IOException {
                  return true;
              }
          };
          scanner.addIncludeFilter(tf);
          //scanner.addExcludeFilter(tf);
          scanner.scan("com.qiankun");
      }
  }
  

7. bean初始化过程解析

• BeanFactoryPostProcessor

  • 作用：定义了在bean工厂对象创建后，bean对象创建前执行的动作，用于对工厂进行创建后业务处理

  • 运行时机：当前操作用于对工厂进行处理，仅运行一次

    public class MyBeanFactory implements BeanFactoryPostProcessor {
        @Override
        //工厂后处理bean接口核心操作
        public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
            System.out.println("bean工厂制作好了，还有什么事情需要处理");
        }
    }
    

  • 注意：导入自定义的MyBeanFactory

    @Import(MyBeanFactory.class)
    public class SpringConfig {...}
    

• BeanPostProcessor

  • 作用：定义了所有bean初始化前后进行的统一动作，用于对bean进行创建前业务处理与创建后业务处理

  • 运行时机：当前操作伴随着每个bean的创建过程，每次创建bean均运行该操作

    public class MyBean implements BeanPostProcessor {
        @Override
        //所有bean初始化前置操作
        public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
            System.out.println("bean之前巴拉巴拉");
            System.out.println(beanName);
            return bean;
        }
    
        @Override
        //所有bean初始化后置操作
        public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
            System.out.println("bean之后巴拉巴拉");
            return bean;
        }
    }
    

• InitializingBean

  • 作用：定义了每个bean的初始化前进行的动作，属于非统一性动作，用于对bean进行创建前业务处理

  • 运行时机：当前操作伴随着任意一个bean的创建过程，保障其个性化业务处理

    public class EquipmentDaoImpl implements EquipmentDao,InitializingBean {
    
        public void save() {
            System.out.println("equipment dao running...");
        }
        
        @PostConstruct
        public void init() {
            System.out.println("EquipmentDaoImpl......bean ...init......");
        }
    
        @Override
        //定义当前bean初始化操作，功效等同于init-method属性配置
        public void afterPropertiesSet() throws Exception {
            System.out.println("EquipmentDaoImpl......bean ...InitializingBean");
        }
    }
    

8. 繁琐的bean初始化过程处理

• 举例实现FactoryBean接口：MyBatis中的SqlSessionFactoryBean实现

对单一的bean的初始化过程进行封装，达到简化配置的目的：

public class EquipmentDaoImplFactoryBean implements FactoryBean {

    @Override
    public Object getObject() throws Exception {
        return new EquipmentDaoImpl();
    }

    @Override
    public Class<?> getObjectType() {
        return null;
    }

    @Override
    public boolean isSingleton() {
        return false;
    }
}

配置FactoryBean：

@Configuration
public class SpringConfig {

    @Bean("equipmentDaoImplBean")
    public EquipmentDaoImplFactoryBean equipmentDaoImplBean() {
        return new EquipmentDaoImplFactoryBean();
    }
}

获取方式：

public class App {
      public static void main(String[] args) {
          ApplicationContext ctx =
                  new AnnotationConfigApplicationContext(SpringConfig.class);
          EquipmentDao equipmentDao = (EquipmentDao)ctx.getBean("equipmentDaoImplBean");
          equipmentDao.save();
}

拓展：

FactoryBean与BeanFactory区别

• FactoryBean：

  FactoryBean是个bean，在IOC容器的基础上给Bean的实现加上了一个简单工厂模式和装饰模式，是一个可以生产对象和装饰对象的工厂bean，由spring管理后，生产的对象是由getObject()方法决定的（从容器中获取到的对象不是“ FactoryBeanTest ” 对象）。

• BeanFactory：

  是个bean 工厂，是一个工厂类(接口)， 它负责生产和管理bean的一个工厂；是ioc 容器最底层的接口，是个ioc容器，是spring用来管理和装配普通bean的ioc容器（这些bean成为普通bean）。

三、AOP

1. AOP简介

在软件业，AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

AOP不是由Spring提出的，最佳开源实现是：AspectJ 。Spring集成了AspectJ 实现AOP。

AOP代表的是一个横向的关系，如果说“对象”是一个空心的圆柱体，其中封装的是对象的属性和行为；那么面向方面编程的方法，就仿佛一把利刃，将这些空心圆柱体剖开，以获得其内部的消息。而剖开的切面，也就是所谓的“方面”了。然后它又以巧夺天功的妙手将这些剖开的切面复原，不留痕迹。

2. AOP的基本概念

• Joinpoint(连接点)：程序执行过程中明确的点，一般是方法的调用，就是方法；

• Pointcut(切入点)：就是带有通知的连接点，在程序中主要体现为书写切入点表达式，就是挖掉共性功能的方法；

• Advice(通知)：AOP在特定的切入点上执行的增强处理，有before,after,afterReturning,afterThrowing,around，就是共性功能，最终以一个方法的形式呈现；

• Aspect(切面)：通常是一个类，里面可以定义切入点和通知，就是共性功能与挖的位置的对应关系；

• Target(目标对象)：就是挖掉功能的方法对应的类产生的对象，这种对象是无法直接完成最终工作的

• Weaving(织入)：就是将挖掉的功能回填的动态过程

• Proxy(代理)：AOP框架创建的对象，代理就是目标对象的加强。Spring中的AOP代理可以使JDK动态代理，也可以是CGLIB代理，前者基于接口，后者基于子类

3. AOP配置（XML）

• Aspect（切面）用于描述切入点与通知间的关系，是AOP编程中的一个重要概念
• AspectJ基于java语言实现AOP

1. aop:config

• 名称：aop:config

• 类型：标签

• 归属：beans子标签

• 作用：设置AOP

• 格式：

  <beans>
      <aop:config>……</aop:config>
      <aop:config>……</aop:config>
  </beans>
  

• 说明：一个beans标签中可以配置多个aop:config标签

2. aop:aspect

• 名称：aop:aspect

• 类型：标签

• 归属：aop:config标签

• 作用：设置具体的AOP通知对应的切入点

• 格式：

  <bean id="myAdvice" class="com.qiankun.aop.AOPAdvice"/>
  
  <aop:config>
      <aop:aspect ref="myAdvice">
          <aop:before method="before" pointcut-ref="pt"/>
      </aop:aspect>
  </aop:config>
  

• 说明：

  一个aop:config标签中可以配置多个aop:aspect标签

• 基本属性：

  • ref ：通知类的beanId

3. aop:pointcut

• 名称：aop:pointcut

• 类型：标签

• 归属：aop:config标签、aop:aspect标签

• 作用：设置切入点

• 格式：

  <aop:config>
      <aop:pointcut id="pt" expression="execution(* *..*(..))"/>
      <aop:pointcut id="pt2" expression="execution(* *..*(..))"/>
      <aop:aspect ref="myAdvice">
          <aop:before method="before" pointcut-ref="pt"/>
      </aop:aspect>
  </aop:config>
  

• 说明：

  一个aop:config标签中可以配置多个aop:pointcut标签，且该标签可以配置在aop:aspect标签内

• 基本属性：

  • id ：识别切入点的名称
  • expression ：切入点表达式

小结

1. AspectJ是基于java语言实现AOP
2. aop:config aop配置入口
3. aop:aspect 设置具体的通知对应的切入点
4. aop:pointcut 配置切入点

4. 切入点

• 切入点描述的是某个方法

• 切入点表达式是一个快速匹配方法描述的通配格式，类似于正则表达式

1. 切入点表达式的组成

• 切入点表达式是一个快速匹配方法描述的通配格式，类似于正则表达式

  关键字（访问修饰符 返回值 包名.类名.方法名（参数）异常名）
  

​ 关键字：描述表达式的匹配模式（参看关键字列表） execution

​ 访问修饰符：方法的访问控制权限修饰符，public、 protected、private

​ 类名：方法所在的类（此处可以配置接口名称）

​ 异常：方法定义中指定抛出的异常

• 范例：

  execution（public User com.qiankun.service.UserService.findById（int））
  

2. 切入点表达式——关键字

• execution ：匹配执行指定方法

• args ：匹配带有指定参数类型的方法

• within ：……

• this ：……

• target ：……

• @within ：……

• @target ：……

• @args ：……

• @annotation ：……

• bean ：……

• reference pointcut ：……

3. 切入点表达式——通配符

• *：单个独立的任意符号，可以独立出现，也可以作为前缀或者后缀的匹配符出现

  execution（public * com.qiankun.*.UserService.find*（*））
  

​ 匹配com.itheima包下的任意包中的UserService类或接口中所有find开头的带有一个参数的方法

• … ：多个连续的任意符号，可以独立出现，常用于简化包名与参数的书写

  execution（public User com..UserService.findById（..））
  

​ 匹配com包下的任意包中的UserService类或接口中所有名称为findById的方法

• +：专用于匹配子类类型

  execution(* *..*Service+.*(..))
  

4. 切入点表达式——逻辑运算符

• && ：连接两个切入点表达式，表示两个切入点表达式同时成立的匹配

• || ：连接两个切入点表达式，表示两个切入点表达式成立任意一个的匹配

• ! ：连接单个切入点表达式，表示该切入点表达式不成立的匹配

5. 切入点表达式——范例

execution(* *(..))
execution(* *..*(..))
execution(* *..*.*(..))
execution(public * *..*.*(..))
execution(public int *..*.*(..))
execution(public void *..*.*(..))
execution(public void com..*.*(..)) 
execution(public void com..service.*.*(..))
execution(public void com.qiankun.service.*.*(..))
execution(public void com.qiankun.service.User*.*(..))
execution(public void com.qiankun.service.*Service.*(..))
execution(public void com.qiankun.service.UserService.*(..))
execution(public User com.qiankun.service.UserService.find*(..))
execution(public User com.qiankun.service.UserService.*Id(..))
execution(public User com.qiankun.service.UserService.findById(..))
execution(public User com.qiankun.service.UserService.findById(int))
execution(public User com.qiankun.service.UserService.findById(int,int))
execution(public User com.qiankun.service.UserService.findById(int,*))
execution(public User com.qiankun.service.UserService.findById(*,int))
execution(public User com.qiankun.service.UserService.findById())
execution(List com.qiankun.service.*Service+.findAll(..))

小结

1. 切入点表达式是一个快速匹配方法描述的通配格式，类似于正则表达式
2. 切入点表达式的关键字execution
3. 切入点表达式的通配符
   • *: 单个独立的任意符号，可以独立出现，也可以作为前缀或者后缀的匹配符出现
   • … : 多个连续的任意符号，可以独立出现，常用于简化包名与参数的书写
   • +: 专用于匹配子类类型
4. 切入点表达式的逻辑运算符: &&, ||, !

5. 切入点的三种配置方式(了解)

<aop:config>
    <!--配置公共切入点-->
    <aop:pointcut id="pt1" expression="execution(* *(..))"/>
    <aop:aspect ref="myAdvice">
        <!--配置局部切入点-->
        <aop:pointcut id="pt2" expression="execution(* *(..))"/>
        <!--引用公共切入点-->
        <aop:before method="logAdvice" pointcut-ref="pt1"/>
        <!--引用局部切入点-->
        <aop:before method="logAdvice" pointcut-ref="pt2"/>
        <!--直接配置切入点-->
        <aop:before method="logAdvice" pointcut="execution(* *(..))"/>
    </aop:aspect>
</aop:config>

6. 切入点配置经验

• 企业开发命名规范严格遵循规范文档进行

• 先为方法配置局部切入点

• 再抽取类中公共切入点

• 最后抽取全局切入点

• 代码走查过程中检测切入点是否存在越界性包含

• 代码走查过程中检测切入点是否存在非包含性进驻

• 设定AOP执行检测程序，在单元测试中监控通知被执行次数与预计次数是否匹配

• 设定完毕的切入点如果发生调整务必进行回归测试

7. 通知类型

AOP的通知类型共5种：

• 前置通知：原始方法执行前执行，如果通知中抛出异常，阻止原始方法运行

  应用：数据校验

• 后置通知：原始方法执行后执行，无论原始方法中是否出现异常，都将执行通知

  应用：现场清理，资源释放

• 返回后通知：原始方法正常执行完毕并返回结果后执行，如果原始方法中抛出异常，无法执行

  应用：返回值相关数据处理，java对象-> json格式数据

• 抛出异常后通知：原始方法抛出异常后执行，如果原始方法没有抛出异常，无法执行

  应用：对原始方法中出现的异常信息进行处理

• 环绕通知：在原始方法执行前后均有对应操作执行，还可以阻止原始方法的执行

  应用：十分强大，可以做任何事情

1. aop:before

• 名称：aop:before

• 类型：标签

• 归属：aop:aspect标签

• 作用：设置前置通知

• 格式：

  <aop:aspect ref="adviceId">
      <aop:before method="methodName" pointcut="……"/>
  </aop:aspect>
  

• 说明：一个aop:aspect标签中可以配置多个aop:before标签

• 基本属性：

  • method ：在通知类中设置当前通知类别对应的方法

  • pointcut ：设置当前通知对应的切入点表达式，与pointcut-ref属性冲突

  • pointcut-ref ：设置当前通知对应的切入点id，与pointcut属性冲突

2. aop:after

• 名称：aop:after

• 类型：标签

• 归属：aop:aspect标签

• 作用：设置后置通知

• 格式：

  <aop:aspect ref="adviceId">
      <aop:after method="methodName" pointcut="……"/>
  </aop:aspect>
  

• 说明：一个aop:aspect标签中可以配置多个aop:after标签

• 基本属性：

  • method ：在通知类中设置当前通知类别对应的方法

  • pointcut ：设置当前通知对应的切入点表达式，与pointcut-ref属性冲突

  • pointcut-ref ：设置当前通知对应的切入点id，与pointcut属性冲突

3. aop:after-returning

• 名称：aop:after-returning

• 类型：标签

• 归属：aop:aspect标签

• 作用：设置返回后通知

• 格式：

  <aop:aspect ref="adviceId">
      <aop:after-returning method="methodName" pointcut="……"/>
  </aop:aspect>
  

• 说明：一个aop:aspect标签中可以配置多个aop:after-returning标签

• 基本属性：

  • method ：在通知类中设置当前通知类别对应的方法

  • pointcut ：设置当前通知对应的切入点表达式，与pointcut-ref属性冲突

  • pointcut-ref ：设置当前通知对应的切入点id，与pointcut属性冲突

4. aop:after-throwing

• 名称：aop:after-throwing

• 类型：标签

• 归属：aop:aspect标签

• 作用：设置抛出异常后通知

• 格式：

  <aop:aspect ref="adviceId">
      <aop:after-throwing method="methodName" pointcut="……"/>
  </aop:aspect>
  

• 说明：一个aop:aspect标签中可以配置多个aop:after-throwing标签

• 基本属性：

  • method ：在通知类中设置当前通知类别对应的方法

  • pointcut ：设置当前通知对应的切入点表达式，与pointcut-ref属性冲突

  • pointcut-ref ：设置当前通知对应的切入点id，与pointcut属性冲突

5. aop:around

• 名称：aop:around

• 类型：标签

• 归属：aop:aspect标签

• 作用：设置环绕通知

• 格式：

  <aop:aspect ref="adviceId">
      <aop:around method="methodName" pointcut="……"/>
  </aop:aspect>
  

• 说明：一个aop:aspect标签中可以配置多个aop:around标签

• 基本属性：

  • method ：在通知类中设置当前通知类别对应的方法

  • pointcut ：设置当前通知对应的切入点表达式，与pointcut-ref属性冲突

  • pointcut-ref ：设置当前通知对应的切入点id，与pointcut属性冲突

环绕通知的开发方式

• 环绕通知可以在原始方法的前后分别添加功能，因此必须在在环绕通知中对原始方法进行显式调用

  public Object around(ProceedingJoinPoint pjp) throws Throwable {
      Object ret = pjp.proceed();
      return ret;
  }
  

• 环绕通知方法相关说明：

  • 方法须设定Object类型的返回值，否则会拦截原始方法的返回。如果原始方法返回值类型为void，通知方 也可以设定返回值类型为void，最终返回null

  • 方法需在第一个参数位置设定ProceedingJoinPoint对象，通过该对象调用proceed()方法，实现对原始方法的调用。如省略该参数，原始方法将无法执行

  • 使用proceed()方法调用原始方法时，因无法预知原始方法运行过程中是否会出现异常，强制抛出Throwable对象，封装原始方法中可能出现的异常信息

8. 通知顺序(了解)

当同一个切入点配置了多个通知时，通知会存在运行的先后顺序，该顺序以通知配置的先后顺序为准

• 不同的通知类型：after, around, before
• 多个相同通知类型

1. 通知获取数据

• 参数

• 返回值

• 异常

2. 获取参数数据

第一种情况：

• 设定通知方法第一个参数为JoinPoint，通过该对象调用getArgs()方法，获取原始方法运行的参数数组

  public void before(JoinPoint jp) throws Throwable {
      Object[] args = jp.getArgs();
  }
  

• 所有的通知均可以获取参数

第二种情况：

• 设定切入点表达式为通知方法传递参数（锁定通知变量名）

• 原始方法

第三种情况

• 设定切入点表达式为通知方法传递参数（改变通知变量名的定义顺序）

• 原始方法
  

3. 获取返回值数据

第一种：返回值变量名

• 设定返回值变量名

• 原始方法

  public int save() {
  	System.out.println("user service running...");
      return 100;
  }
  

• AOP配置

  <aop:aspect ref="myAdvice">
      <aop:pointcut id="pt3" expression="execution(* *(..))  "/>
      <aop:after-returning method="afterReturning" pointcut-ref="pt3" returning="ret"/>
  </aop:aspect>
  

• 通知类

  public void afterReturning(Object ret) {
      System.out.println(ret);
  }
  

• 适用于返回后通知（after-returning）

第二种：

• 在通知类的方法中调用原始方法获取返回值

• 原始方法

  public int save() {
      System.out.println("user service running...");
      return 100;
  }
  

• AOP配置

  <aop:aspect ref="myAdvice">
      <aop:pointcut id="pt2" expression="execution(* *(..))  "/>
      <aop:around method="around" pointcut-ref="pt2" />
  </aop:aspect>
  

• 通知类

  public Object around(ProceedingJoinPoint pjp) throws Throwable {
      Object ret = pjp.proceed();
      return ret;
  }
  

• 适用于环绕通知（around）

4. 通知获取异常数据

第一种：通知类的方法中调用原始方法捕获异常

• 在通知类的方法中调用原始方法捕获异常

• 原始方法

  public void save() {
      System.out.println("user service running...");
      int i = 1/0;
  }
  

• AOP配置

  <aop:aspect ref="myAdvice">
      <aop:pointcut id="pt4" expression="execution(* *(..))  "/>
      <aop:around method="around" pointcut-ref="pt4" />
  </aop:aspect>
  

• 通知类

  public Object around(ProceedingJoinPoint pjp) throws Throwable {
      Object ret = pjp.proceed();	//对此处调用进行try……catch……捕获异常，或抛出异常
      return ret;
  }
  

• 适用于环绕通知（around）

第二种：

• 设定异常对象变量名

• 原始方法

  public void save() {
      System.out.println("user service running...");
      int i = 1/0;
  }
  

• AOP配置

  <aop:aspect ref="myAdvice">
  	<aop:pointcut id="pt4" expression="execution(* *(..))  "/>
      <aop:after-throwing method="afterThrowing" pointcut-ref="pt4" throwing="t"/>
  </aop:aspect>
  

• 通知类

  public void afterThrowing(Throwable t){
      System.out.println(t.getMessage());
  }
  

• 适用于返回后通知（after-throwing）

小结

通知中获取原始操作数据

1. 参数（5种通知）
2. 返回值（2种通知）：after-returning, after-returning
3. 异常对象（2种通知）：around, after-throwing

4. AOP配置（注解）

1. 注解开发AOP步骤

在XML格式基础上

• 导入aspectj坐标

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

• AOP注解是由Spring提供的，所以需要引入spring-aop(spring-context已将aop的坐标引入)

• 开启AOP注解支持

  <aop:aspectj-autoproxy/>
  

• 配置切面@Aspect

• 定义专用的切入点方法，并配置切入点@Pointcut

• 为通知方法配置通知类型及对应切入点@Before

2. 注意事项

1.切入点最终体现为一个方法，无参无返回值，无实际方法体内容，但不能是抽象方法

@Pointcut("execution(* *..*(..))")
public void pt(){
}

2.引用切入点时必须使用方法调用名称，方法后面的括号不能省略

@Before("pt()")

3.切面类中定义的切入点只能在当前类中使用，如果想引用其他类中定义的切入点使用“类名.方法名()”引用

@Before("AOPPointcut.pt1()")

4.可以在通知类型注解后添加参数，实现XML配置中的属性，例如after-returning后的returning属性

3. AOP注解详解

1. @Aspect

• 名称：@Aspect

• 类型：注解

• 位置：类定义上方

• 作用：设置当前类为切面类

• 格式：

  @Aspect
  public class AopAdvice {
  }
  

• 说明：一个beans标签中可以配置多个aop:config标签

2. @Pointcut

• 名称：@Pointcut

• 类型：注解

• 位置：方法定义上方

• 作用：使用当前方法名作为切入点引用名称

• 格式：

  @Pointcut("execution(* *(..))")
  public void pt() {
  }
  

• 说明：被修饰的方法忽略其业务功能，格式设定为无参无返回值的方法，方法体内空实现（非抽象）

3. @Before

• 名称：@Before

• 类型：注解

• 位置：方法定义上方

• 作用：标注当前方法作为前置通知

• 格式：

  @Before("pt()")
  public void before(){
  }
  

• 特殊参数：

  • 无

4. @After

• 名称：@After

• 类型：注解

• 位置：方法定义上方

• 作用：标注当前方法作为后置通知

• 格式：

  @After("pt()")
  public void after(){
  }
  

• 特殊参数：

  • 无

5. @AfterReturning

• 名称：@AfterReturning

• 类型：注解

• 位置：方法定义上方

• 作用：标注当前方法作为返回后通知

• 格式：

  @AfterReturning(value="pt()",returning = "ret")
  public void afterReturning(Object ret) {
  }
  

• 特殊参数：

  • returning ：设定使用通知方法参数接收返回值的变量名

6. @AfterThrowing

• 名称：@AfterThrowing

• 类型：注解

• 位置：方法定义上方

• 作用：标注当前方法作为异常后通知

• 格式：

  @AfterThrowing(value="pt()",throwing = "t")
  public void afterThrowing(Throwable t){
  }
  

• 特殊参数：

  • throwing ：设定使用通知方法参数接收原始方法中抛出的异常对象名

7. @Around

• 名称：@Around

• 类型：注解

• 位置：方法定义上方

• 作用：标注当前方法作为环绕通知

• 格式：

  @Around("pt()")
  public Object around(ProceedingJoinPoint pjp) throws Throwable {
      Object ret = pjp.proceed();
      return ret;
  }
  

4.AOP注解开发通知执行顺序控制

<aop:config>
    <aop:pointcut id="pt" expression="execution(* *..*(..))"/>
    <aop:aspect ref="myAdvice">
        <aop:before method="before" pointcut-ref="pt"/>
        <aop:after method="after" pointcut-ref="pt"/>
        <aop:after-returning method="afterReturing" pointcut-ref="pt" returning="ret"/>
        <aop:after-throwing method="afterThrowing" pointcut-ref="pt" throwing="t"/>
        <aop:around method="around" pointcut-ref="pt"/>
    </aop:aspect>
</aop:config>

1.AOP使用XML配置情况下，通知的执行顺序由配置顺序决定，在注解情况下类中方法由于不存在配置顺序的概念，参照通知所配置的方法名字符串对应的编码值顺序，可以简单理解为字母排序

• 同一个通知类中，相同通知类型以方法名字母排序为准

• 不同通知类中，以类名字母排序为准

• 使用@Order注解通过变更bean的加载顺序改变通知的加载顺序

2.企业开发经验

• 通知方法名由3部分组成，分别是前缀、顺序编码、功能描述

• 前缀为固定字符串，例如baidu、itheima等，无实际意义

• 顺序编码为6位以内的整数，通常3位即可，不足位补0

• 功能描述为该方法对应的实际通知功能，例如exception、strLenCheck

  • 制通知执行顺序使用顺序编码控制，使用时做一定空间预留

  • 003使用，006使用，预留001、002、004、005、007、008

  • 使用时从中段开始使用，方便后期做前置追加或后置追加

  • 最终顺序以运行顺序为准，以测试结果为准，不以设定规则为准

5. AOP注解驱动

• 名称：@EnableAspectJAutoProxy

• 类型：注解

• 位置：Spring注解配置类定义上方

• 作用：设置当前类开启AOP注解驱动的支持，加载AOP注解

• 格式：

  @Configuration
  @ComponentScan("com.qiankun")
  @EnableAspectJAutoProxy
  public class SpringConfig {
  }
  

6. 代理模式的选择

Spirng可以通过配置的形式控制使用的代理形式：默认使用jdk-proxy，通过配置proxy-target-class为true可以修改为使用cglib

• XML配置

  <!--XMP配置AOP-->
  <aop:config proxy-target-class="true"></aop:config>
  

• XML注解支持

  <!--注解配置AOP-->
  <aop:aspectj-autoproxy proxy-target-class="true"/>
  

• 注解驱动

  //注解驱动
  @EnableAspectJAutoProxy(proxyTargetClass = true)
  

扩展知识

AOP和继承实现的区别

• 灵活性
• 耦合度
• 侵入

四、事务

1. 事务简介

1. 什么是事务

事务可以看做是一次大的活动，它由不同的小活动组成，这些活动要么全部成功，要么全部失败。

1.当数据库操作序列中个别操作失败时，提供一种方式使数据库状态恢复到正常状态（A），保障数据库即使在异常状态下仍能保持数据一致性（C）（要么操作前状态，要么操作后状态）。

2.当出现并发访问数据库时，在多个访问间进行相互隔离，防止并发访问操作结果互相干扰（I）。

• 事务特征（ACID）

  • 原子性（Atomicity）指事务是一个不可分割的整体，其中的操作要么全执行或全不执行

• 一致性（Consistency）事务前后数据的完整性必须保持一致。比如：张三向李四转100元，
  转账前和转账后的数据是正确状态这叫一致性，如果出现张三转出100元，李四账户没有增加100元这就出现了数据错误，就没有达到一致性。

• 隔离性（Isolation）事务的隔离性是多个用户并发访问数据库时，数据库为每一个用户开启的事务，不能被其他事务的操作数据所干扰，多个并发事务之间要相互隔离

  • 持久性（Durability）持久性是指一个事务一旦被提交，它对数据库中数据的改变就是永久性的，接下来即使数据库发生故障也不应该对其有任何影响

2. 事务的隔离级

并发事务时可能会出现的几种问题：

• 脏读：允许读取未提交的信息

  • 原因：Read uncommitted
  • 解决方案：Read committed（表级读锁）

• 不可重复读：读取过程中单个数据发生了变化
  • 解决方案： Repeatable read （行级写锁）

• 幻读：读取过程中数据条目发生了变化
  • 解决方案： Serializable（表级写锁）

为了有效保证并发读取数据的正确性，提出了4种事务隔离级别来解决脏读、不可重复读、幻读等问题：

• 未提交读(Read Uncommitted)：允许脏读，也就是可能读取到其他会话中未提交事务修改的数据
• 提交读(Read Committed)：只能读取到已经提交的数据，解决了脏读的问题
• 可重复读(Repeated Read)：可重复读。MySQL InnoDB默认级别。在SQL标准中，该隔离级别消除了不可重复读，但是还存在幻读
• 串行读(Serializable)：完全串行化的读，每次读都需要获得表级共享锁，读写相互都会阻塞，解决了幻读

注意：

Read Uncommitted这种级别，数据库一般都不会用，而且任何操作都不会加锁。

Serializable是最严格的隔离级别。在Serializable隔离级别下，所有事务按照次序依次执行，因此，脏读、不可重复读、幻读都不会出现。虽然Serializable隔离级别下的事务具有最高的安全性，但是由于事务是串行执行，所以效率会大大下降，应用程序的性能会急剧降低。如果没有特别重要的情景，一般都不会使用Serializable隔离级别。

3. 事务的传播机制（了解）

事务的传播性一般用在事务嵌套的场景，比如一个事务方法里面调用了另外一个事务方法，那么两个方法是各自作为独立的方法提交还是内层的事务合并到外层的事务一起提交，这就是需要事务传播机制的配置来确定怎么样执行。
常用的事务传播机制如下：

• PROPAGATION_REQUIRED
  Spring默认的传播机制，能满足绝大部分业务需求，如果外层有事务，则当前事务加入到外层事务，一块提交，一块回滚。如果外层没有事务，新建一个事务执行
• PROPAGATION_REQUES_NEW
  该事务传播机制是每次都会新开启一个事务，同时把外层事务挂起，当当前事务执行完毕，恢复上层事务的执行。如果外层没有事务，执行当前新开启的事务即可
• PROPAGATION_SUPPORT
  如果外层有事务，则加入外层事务，如果外层没有事务，则直接使用非事务方式执行。完全依赖外层的事务
• PROPAGATION_NOT_SUPPORT
  该传播机制不支持事务，如果外层存在事务则挂起，执行完当前代码，则恢复外层事务，无论是否异常都不会回滚当前的代码
• PROPAGATION_NEVER
  该传播机制不支持外层事务，即如果外层有事务就抛出异常
• PROPAGATION_MANDATORY
  与NEVER相反，如果外层没有事务，则抛出异常
• PROPAGATION_NESTED
  该传播机制的特点是可以保存状态保存点，当前事务回滚到某一个点，从而避免所有的嵌套事务都回滚，即各自回滚各自的，如果子事务没有把异常吃掉，基本还是会引起全部回滚的。

传播规则回答了这样一个问题：一个新的事务应该被启动还是被挂起，或者是一个方法是否应该在事务性上下文中运行。

4. 事务管理

1. Spring事务核心对象

• J2EE开发使用分层设计的思想进行，对于简单的业务层转调数据层的单一操作，事务开启在业务层或者数据层并无太大差别；当业务中包含多个数据层的调用时，需要在业务层开启事务，对数据层中多个操作进行组合并归属于同一个事务进行处理
• Spring提供如下三个接口为业务层提供了整套的事务解决方案
  • 平台事务管理器：PlatformTransactionManager
  • 事务定义对象：TransactionDefinition
  • 事务状态：TransactionStatus

2. PlatformTransactionManager

• 平台事务管理器实现类

  • DataSourceTransactionManager 适用于Spring JDBC或MyBatis

  • HibernateTransactionManager 适用于Hibernate3.0及以上版本

  • JpaTransactionManager 适用于JPA

  • JdoTransactionManager 适用于JDO

  • JtaTransactionManager 适用于JTA

• JPA（Java Persistence API）Java EE 标准之一，为POJO提供持久化标准规范，并规范了持久化开发的统一API，符合JPA规范的开发可以在不同的JPA框架下运行

• JDO(Java Data Object )是Java对象持久化规范，用于存取某种数据库中的对象，并提供标准化API。与JDBC相比，JDBC仅针对关系数据库进行操作，JDO可以扩展到关系数据库、文件、XML、对象数据库（ODBMS）等，可移植性更强

• JTA（Java Transaction API）Java EE 标准之一，允许应用程序执行分布式事务处理。与JDBC相比，JDBC事务则被限定在一个单一的数据库连接，而一个JTA事务可以有多个参与者，比如JDBC连接、JDO 都可以参与到一个JTA事务中

此接口定义了事务的基本操作

• 获取事务 ：

  TransactionStatus getTransaction(TransactionDefinition definition)
  

• 提交事务 ：

  void commit(TransactionStatus status) 
  

• 回滚事务 ：

  void rollback(TransactionStatus status)
  

3. TransactionDefinition

此接口定义了事务的基本信息

• 获取事务定义名称

  String getName()
  

• 获取事务的读写属性

  boolean isReadOnly()
  

• 获取事务隔离级别

  int getIsolationLevel()
  

• 获事务超时时间

  int getTimeout()
  

• 获取事务传播行为特征

  int getPropagationBehavior()
  

4. TransactionStatus

此接口定义了事务在执行过程中某个时间点上的状态信息及对应的状态操作

5. 事务控制方式

• 编程式

• 声明式（XML）

• 声明式（注解）

1. 声明式事务（XML）

AOP配置事务是否具有特例性

public Object tx(ProceedingJoinPoint pjp) throws Throwable {
    DataSourceTransactionManager dstm = new DataSourceTransactionManager();
    dstm.setDataSource(dataSource);
    TransactionDefinition td = new DefaultTransactionDefinition();
    TransactionStatus ts = dstm.getTransaction(td);
    Object ret = pjp.proceed(pjp.getArgs());
    dstm.commit(ts);

    return ret;
}

<bean id="txAdvice" class="com.qiankun.aop.TxAdvice">
	<property name="dataSource" ref="dataSource"/>
</bean>

tx命名空间：

<?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"
xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="http://www.springframework.org/schema/beans
https://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/tx
https://www.springframework.org/schema/tx/spring-tx.xsd
http://www.springframework.org/schema/aop
https://www.springframework.org/schema/aop/spring-aop.xsd">

1. aop:advisor

使用aop:advisor在AOP配置中引用事务专属通知类

<aop:config>
    <aop:pointcut id="pt" expression="execution(* com.qiankun.service.*Service.*(..))"/>
    <aop:advisor advice-ref="txAdvice" pointcut-ref="pt"/>
</aop:config>

aop:aspect与aop:advisor区别

• aop:aspect配置的通知类可以是普通java对象，不实现接口，也不使用继承关系

• aop:advisor配置的通知类TransactionInterceptor必须实现通知接口
  

2. tx配置----tx:advice

• 名称：tx:advice

• 类型：标签

• 归属：beans标签

• 作用：配置事务专属通知类

• 格式：

  <beans>
      <tx:advice id="txAdvice" transaction-manager="txManager">
          <tx:attributes>
              <tx:method name="*" read-only="false" />
              <tx:method name="get*" read-only="true" />
              <tx:method name="find*" read-only="true" />
          </tx:attributes>
      </tx:advice>
  </beans>
  

• 基本属性：

  • id ：用于配置aop时指定通知类的id

  • transaction-manager ：指定事务管理器bean

3. tx配置----tx:attributes

• 名称：tx:attributes

• 类型：标签

• 归属：tx:advice标签

• 作用：定义通知属性

• 格式：

  <tx:advice id="txAdvice" transaction-manager="txManager">
      <tx:attributes>
      </tx:attributes>
  </tx:advice>
  

• 基本属性：

  • 无

4. tx配置----tx:method

• 名称：tx:method

• 类型：标签

• 归属：tx:attribute标签

• 作用：设置具体的事务属性

• 格式：

  <tx:attributes>
      <tx:method name="*" read-only="false" />
      <tx:method name="get*" read-only="true" />
  </tx:attributes>
  

• 说明：

  通常事务属性会配置多个，包含1个读写的全事务属性，1个只读的查询类事务属性

tx:method属性

小结

声明式事务配置方式

1. 设置事务管理器

   <bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
       <property name="dataSource" ref="dataSource"/>
   </bean>
   

2. 专用事务通知器

   <!--定义事务管理的通知类-->
   <tx:advice id="txAdvice" transaction-manager="txManager">
       <!--定义控制的事务-->
       <tx:attributes>
           <tx:method name="*" read-only="false"/>
           <tx:method name="get*" read-only="true"/>
           <tx:method name="find*" read-only="true"/>
       </tx:attributes>
   </tx:advice>
   

3. AOP配置切面，使用通知器绑定切入点

   <aop:config>
       <aop:pointcut id="pt" expression="execution(* com.itheima.service.*Service.*(..))"/>
       <aop:advisor advice-ref="txAdvice" pointcut-ref="pt"/>
   </aop:config>
   

2. 声明式事务（注解）

1. @Transactional

• 名称：@Transactional

• 类型：方法注解，类注解，接口注解

• 位置：方法定义上方，类定义上方，接口定义上方

• 作用：设置当前类/接口中所有方法或具体方法开启事务，并指定相关事务属性

• 范例：

  @Transactional(
      readOnly = false,
      timeout = -1,
      isolation = Isolation.DEFAULT,
      rollbackFor = {ArithmeticException.class, IOException.class},
      noRollbackFor = {},
      propagation = Propagation.REQUIRES_NEW
  )
  

• 注意事项

  • 只能应用到 public 方法上，如果你在 protected、private或者默认可见性的方法上使用事务控制将被忽略，也不会抛出任何异常。
  • 如果类级别配置了注解，方法级别也配置了，应用程序会以方法上配置的事务属性信息来管理事务，换言之，方法级别的事务属性信息会覆盖类级别的相关配置。

2. tx:annotation-driven

• 名称：tx:annotation-driven

• 类型：标签

• 归属：beans标签

• 作用：开启事务注解驱动，并指定对应的事务管理器

• 范例：

  <tx:annotation-driven transaction-manager="txManager"/>
  

小结

声明式事务注解配置方式

1. 开启注解驱动
2. 配置事务属性
   • 接口
   • 类
   • 方法

3. 声明式事务（纯注解驱动）

• 名称：@EnableTransactionManagement

• 类型：类注解

• 位置：Spring注解配置类上方

• 作用：开启注解驱动，等同XML格式中的注解驱动

• 范例：

  @Configuration
  @ComponentScan("com.itheima")
  @PropertySource("classpath:jdbc.properties")
  @Import({JDBCConfig.class,MyBatisConfig.class,TransactionManagerConfig.class})
  @EnableTransactionManagement
  public class SpringConfig {
  }
  

  public class TransactionManagerConfig {
      @Bean
      public PlatformTransactionManager getTransactionManager(@Autowired DataSource dataSource){
          return new DataSourceTransactionManager(dataSource);
      }
  }
  

6. 模板对象

1. Spring模块对象

• TransactionTemplate

• JdbcTemplate

• RedisTemplate

• RabbitTemplate

• JmsTemplate

• HibernateTemplate

• RestTemplate

2. JdbcTemplate（了解）

JdbcTemplate是Spring对JDBC的封装，提供标准的sql语句操作API，目的是使JDBC更加易于使用。

1. update：用于执行INSERT、UPDATE、DELETE等语句。

   public void save(Account account) {
       String sql = "insert into account(name,money)values(?,?)";
       jdbcTemplate.update(sql,account.getName(),account.getMoney());
   }
   

2. queryXxx：用于执行SELECT数据查询语句。

   public String findNameById(Integer id) {
       String sql = "select name from account where id = ? ";
       //单字段查询可以使用专用的查询方法，必须制定查询出的数据类型，例如name为String类型
       return jdbcTemplate.queryForObject(sql,String.class,id );
   }
   

3. NamedParameterJdbcTemplate(了解）

提供标准的具名sql语句操作API

public void save(Account account) {
    String sql = "insert into account(name,money)values(:name,:money)";
    Map pm = new HashMap();
    pm.put("name",account.getName());
    pm.put("money",account.getMoney());
    jdbcTemplate.update(sql,pm);
}

4. RedisTemplate

1. 环境准备

1. Linux：配置redis.conf

   bind 127.0.0.1
   port 6379
   protected-mode no
   

   启动Redis：redis-server redis.conf

2. Windows：打开Redis安装目录，使用cmd切换到当前目录

   #切换到安装目录
   cd C:\Program Files\Redis
   
   #启动Redis
   redis-server --service-start
   
   #打开Redis控制台
   redis-cli
   
   #关闭Redis
   redis-server --service-stop
   

2. 对象结构

RedisTemplate提供的方法主要分为如下4类：

1. 客户端基本操作
   

2. Operations具体数据类型操作

public void changeMoney(Integer id, Double money) {
    redisTemplate.opsForValue().set("account:id:"+id,money);
}
public Double findMondyById(Integer id) {
    Object money = redisTemplate.opsForValue().get("account:id:" + id);
    return new Double(money.toString());
}

3. Bound Operations阻塞式数据类型操作
   

4. 其他操作