Spring系列开篇 — 核心功能 IoC, AOP (附事务管理，spring与mybatis整合等)

文章目录

概述
重要概念
快速入门
基本使用
- 纯XML
- - IoC配置
  - DI配置
  - - 构造函数注入
    - set方法注入
    - c命名空间和p命名空间
- XML+注解
- - IoC配置
  - DI配置
- 纯注解
- - IoC配置
- Spring整合JUnit4
SpringAop
- 术语介绍
- JDK动态代理示例
- CGLib动态代理示例
- 使用
- - 快速上手
  - 切入点指示器
  - AOP参数传递
  - AOP引介的使用
  - 基于XML的AOP使用
事务支持
- XML方式
- XML+注解
- 纯注解
- 小结
附录
- IoC
- AOP
- bean的其他实例化方式
- bean的生命周期

这篇文章是Spring系列笔记的开篇，介绍了Spring的两大核心功能：IoC和AOP。以及基于AOP的事务管理，Spring与mybatis的整合等内容。代码示例比较详细，所以篇幅较长，后续会更新一篇总结性质的篇幅较短的文章，敬请关注（已更新，传送门）。

（注：mybatis和spring整合的部分，在事务支持小节）

概述

Spring是什么？

广义上讲，Spring指的是Spring技术栈，或Spring生态。这些技术栈涵盖了web应用，大数据，云计算等各个方面。

狭义地讲，Spring指的就是Spring生态中的 Spring Framework。这也是我们常说的Spring。而Spring Framework中最核心的部分就是IoC（控制反转）与AOP（面向切面编程）。

如果你在百度上搜索"Spring 是什么"，得到的答案大概是：Spring是一个分层的JavaEE一站式轻量级开源框架。这是广义上的Spring，也是较为官方的定义。

根据官网（https://spring.io/projects）所述，从配置到安全，从web应用到大数据，Spring均有涉足。

Spring生态整体采用了模块化设计，针对不同的场景，可以选用Spring生态中的不同模块进行开发。如简单的Web应用我们可以用 Spring Framework ，微服务场景我们可以用SpringBoot，SpringCloud。

下图展示了Spring生态中所包含的各个模块。

Spring系列开篇 — 核心功能 IoC, AOP (附事务管理，spring与mybatis整合等)

而就算是Spring Framework 这个核心模块，它包含的内容也是非常丰富的。根据其官方文档，我们可以看到，Spring Framework 中包含了

IoC

容器，

AOP

等核心功能；测试相关内容；数据访问相关的事务，JDBC，ORM等；Web部分（基于

Servlet

）的

SpringMVC

，

WebSocket

，甚至还有支持响应式Web的

WebFlux

；以及JMS消息服务，邮件服务，任务调度等。

Spring Framework内部也采用了模块化设计，我们可以按需选择其中的模块进行使用。其结构如下图

其中最核心的部分，便是

Core Container

（Spring核心容器），可以看到，其他的如

Web

和

Data Access

都是以

Core Container

为基础的。

Core Container

又分为4个子模块：

Beans

，

Core

，

Context

，

SpEL

，这4个子模块对应了4个

jar

包，在

pom.xml

中就对应了4个

dependency

<dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>5.0.10.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>5.0.10.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.0.10.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-expression</artifactId>
            <version>5.0.10.RELEASE</version>
        </dependency>

Spring的简单介绍就到这里，下面对Spring中的一些重要概念进行说明。

重要概念

IoC ：控制反转。它不是一种具体技术，而是一种编程思想。详见附录IoC
DI ：依赖注入。是对 IoC 从不同角度的描述，详见附录IoC
AOP ：面向切面编程。能够在不修改源代码的情况下，对类做一些增强（添加一些额外功能），详见附录aop
Spring容器 ：指的就是 IoC 容器，在Spring的底层源码中对应了 BeanFactory 这个接口，负责创建和管理对象（ bean 实例）

快速入门

Spring最最核心的就是

IoC

容器（即Spring容器），Spring在启动时，会扫描相关配置，完成对象的创建和相关依赖的装配。Spring的快速入门demo如下

打开IDEA，创建一个maven项目，在 pom.xml
中添加spring的核心依赖包

<?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.demo</groupId> <artifactId>spring-demo</artifactId> <version>1.0-SNAPSHOT</version> <dependencies> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-core</artifactId> <version>5.0.10.RELEASE</version> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-beans</artifactId> <version>5.0.10.RELEASE</version> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-context</artifactId> <version>5.0.10.RELEASE</version> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-expression</artifactId> <version>5.0.10.RELEASE</version> </dependency> <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>4.12</version> <scope>test</scope> </dependency> </dependencies> </project>
创建几个类

package org.demo.dao; public class PetDao { public String getPetName(int id) { // 模拟访问数据库, 获取数据 return "dog00" + id; } } package org.demo.service; import org.demo.dao.PetDao; public class PetService { private PetDao dao; public void feedPet(int id) { // 先根据id从数据库查出宠物的名称 String petName = dao.getPetName(id); // 给宠物喂食 System.out.println("给宠物 [" + petName +"] 喂食"); } public void setDao(PetDao dao) { this.dao = dao; } }
创建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 id="petStore" class="org.demo.service.PetService"> <property name="dao" ref="petDao"/> </bean> <bean id="petDao" class="org.demo.dao.PetDao"/> </beans>
编写测试类

import org.demo.service.PetService; import org.junit.Test; import org.springframework.context.ApplicationContext; import org.springframework.context.support.ClassPathXmlApplicationContext; public class SpringTest { @Test public void test() { ApplicationContext context = new ClassPathXmlApplicationContext("spring-demo.xml"); PetService petService = context.getBean(PetService.class); petService.feedPet(7); } } 项目结构如下

Spring系列开篇 — 核心功能 IoC, AOP (附事务管理，spring与mybatis整合等)
运行测试

Spring系列开篇 — 核心功能 IoC, AOP (附事务管理，spring与mybatis整合等)

可以看到，Spring做的无非就是提供了一个容器，在这个容器里帮你创建所需要的各种类的对象，并解析各个类对象之间的依赖关系，自动完成依赖注入（上面的示例将PetDao对象注入到了PetService对象中）。随后可以调用Spring容器的

getBean

方法，取出所需要的对象来使用即可。

下面对Spring的核心功能

IoC

，进行一个较为详细的说明。

基本使用

Spring的基本配置可以通过XML或者注解的方式进行。

纯XML

IoC配置

通过配置，告诉Spring，需要创建哪些对象（对象，

bean

实例，

bean

，说的都是同一个东西）到Spring容器中。

通过

<bean>

标签，即可将一个对象注册到Spring容器中，如

<!-- 完整的xml配置模板见前文【快速入门】  -->
<bean id="petDao" class="org.litespring.pojo.PetDao"/>

默认情况下Spring会调用类的无参构造函数来实例化对象，若没有无参构造函数则会实例化失败。（若

<bean>

标签中，有通过

<constructor-arg>

子标签配置构造器参数时，则会调用带参数的构造函数进行实例化。其他的不常用的实例化方式参考这里）。

<bean>

标签的相关属性说明如下

id 对象在Spring容器中的唯一标识。也叫 bean 的 id ，或者 bean 的名称。当不指定 id 时，默认使用简单类名的小写作为 id 。
class 唯一一个必填属性。指定类的全限定名。Spring会通过反射来创建一个该类的对象，默认调用无参构造函数。
init-method 指定类中的初始化方法。在 bean 实例化完成（实例化指的是给这个对象分配内存空间，可以简单理解为，相当于代码中的 new
），依赖注入完成后，Spring会调用该属性指定的方法，进行一些自定义的初始化操作。可参见bean的生命周期。

注：通过注解配置
bean 时，可以通过 @PostConstruct （在类的某个方法上打上该注解）完成类似的功能。只是 @PostConstruct 的执行顺序要早于 init-method （若同时配置）
destroy-method
有自定义初始化方法，也就有自定义的销毁方法。该属性指定了，当对象在Spring容器中被销毁时（准确地说是被销毁之前），需要执行的方法（一般是用来做一些资源的释放和清理）。

对应注解中的
@PreDestroy ，只是 @PreDestroy 的执行顺序要早于 destroy-method （若同时配置）
scope 指定 bean 的作用范围。有如下几种取值
- singleton ：默认值，单例。 bean
  对象在整个Spring容器中只有1个。
  
  生命周期：当Spring容器初始化时，被创建，随后
  bean 一直存活，直到应用关闭，Spring容器销毁时， bean 才被销毁。
- prototype ：原型。每次从Spring容器中获取该 bean 时（每次调用 BeanFactory 中的 getBean 方法时），都会创建一个新的对象，也就是说 bean
  是多例的。
  
  生命周期：当获取该
  bean 时，创建一个新的对象实例，对象若被使用，就一直存活，当对象没有被任何地方引用，则会由垃圾回收器进行回收。
- request ：仅在 web 环境下有该配置。每次请求会创建一个新的 bean ， bean 的存活周期和一次请求的周期一致。请求到来时，新建一个 bean ，请求结束时， bean
  被销毁。
  
  需要结合
  <aop:scoped-proxy/> 标签使用，该值不常用。
- session ：仅在 web 环境下有该配置。每个会话（ HttpSession ）创建一个新的 bean ， bean 的存活周期和一次会话的周期一致。会话开启时，新建一个 bean ，会话结束时， bean
  被销毁。
  
  需要结合
  <aop:scoped-proxy/> 标签使用，该值也不常用。
对于Spring中 bean 的 request 和 session 作用域，想要进一步了解，可参考这篇文章

DI配置

依赖注入配置。通过配置，让Spring自动把一个类对象所需要的东西注入给它。

首先，什么是依赖？依赖是一个

bean

实例中的属性，比如下面这个类

package org.litespring.pojo;
public class PetStoreService {
    private PetDao dao;
    private String storeName;
    private List<String> customerNames;
}

这个类中的3个属性，都属于这个类的依赖。

依赖（或属性），根据其变量的类型，又可以分为3大类

简单类型：8大Java基本类型和 String
对象类型：自定义的Java类（POJO）
集合类型：jdk中自带的： List ， Set ， Map 等

依赖注入则是对这些属性，进行赋值，这也是交给Spring去完成的。

依赖注入有如下2种方式

构造函数注入

通过类的构造函数，来对类的属性进行赋值。示例如下

package org.litespring.pojo;
public class PetStoreService {
  private PetDao dao;
  private String storeName;
  public PetStoreService(PetDao dao, String storeName) {
    this.dao = dao;
    this.storeName = storeName;
  }
  // 省略了get方法
}

<!-- spring-demo.xml -->
    <bean id="petStore" class="org.litespring.pojo.PetStoreService">
        <constructor-arg index="0" ref="petDao"/>
        <constructor-arg index="1" value="大黄"/>
    </bean>

    <bean id="petDao" class="org.litespring.pojo.PetDao"/>

测试

@Test
  public void testConstruct() {
    ApplicationContext context = new ClassPathXmlApplicationContext("spring-demo.xml");
    PetStoreService petStore = (PetStoreService) context.getBean("petStore");
    System.out.println(petStore.getStoreName());
    System.out.println(petStore.getDao());
  }

主要是使用

<bean>

标签的子标签

<constructor-arg>

来进行的，

<constructor-arg>

标签有2个关键点：

指定要注入到构造函数中的哪个参数
要注入的值是什么

针对1，可以通过属性

index

指定构造函数中参数的位置下标，或通过

name

指定参数的名称，或通过

type

指定参数的类型。或者，当多个

<constructor-arg>

标签的顺序与构造函数的参数顺序一致，则可以不显式指定。

针对2，当注入的是简单类型变量，用

value

属性；当注入的是

POJO

类型（注入

bean

），用

ref

属性指定

bean

的

id

（这个

bean

也需要注册到了Spring容器中）；当注入的是集合类型，在下面的set方法注入部分再做说明

set方法注入

Spring会通过反射，调用类中的

setXxx

等方法，完成属性的注入。示例如下

首先，在类中，对需要注入的属性，需要有对应的

set

方法

package org.litespring.pojo;
public class PetStoreService {

    private PetDao dao;

    private String storeName;

    public void setDao(PetDao dao) {
        this.dao = dao;
    }

    public void setStoreName(String storeName) {
        this.storeName = storeName;
    }
    //省略get
}

<!-- spring-demo.xml -->
    <bean id="petStore" class="org.litespring.pojo.PetStoreService">
        <property name="dao" ref="petDao"/>
        <property name="storeName" value="大黄"/>
    </bean>

    <bean id="petDao" class="org.litespring.pojo.PetDao"/>

测试

@Test
  public void testProperty() {
    ApplicationContext context = new ClassPathXmlApplicationContext("spring-demo.xml");
    PetStoreService petStore = (PetStoreService) context.getBean("petStore");
    System.out.println(petStore.getStoreName());
    System.out.println(petStore.getDao());
  }

当需要注入的是集合类型时，采用如下方式，比如

PetStoreService

中有一个

List

类型的属性

package org.litespring.pojo;
import java.util.List;

public class PetStoreService {

    private List<String> customerNames;

    public void setCustomerNames(List<String> customerNames) {
        this.customerNames = customerNames;
    }
    // 省略get
}

则在XML文件中使用如下配置即可

<bean id="petStore" class="org.litespring.pojo.PetStoreService">
        <property name="customerNames">
            <list>
                <value>大黄</value>
                <value>王二狗</value>
                <value>王狗蛋</value>
            </list>
        </property>
    </bean>

测试

@Test
  public void testList() {
    ApplicationContext context = new ClassPathXmlApplicationContext("spring-demo.xml");
    PetStoreService petStore = (PetStoreService) context.getBean("petStore");
    petStore.getCustomerNames().forEach(System.out::println);
  }

其他的集合类型，如数组，

set

，

map

，

properties

等，分别按照如下标签进行配置即可

<!-- array -->
<bean id="b" class="B">
   <property name="arrs">
         <array>
            <value>数学</value>
           <value>英语</value>
         </array>
   </property>
</bean>
<!-- set -->
<bean id="b" class="B">
   <property name="arrs">
         <set>
            <value>数学</value>
           <value>英语</value>
         </set>
   </property>
</bean>
<!-- map -->
<bean id="b" class="B">
   <property name="arrs">
       <map>
           <entry key="age" value="18"/>
           <entry key="name" value="Bob"/>
       </map>
   </property>
</bean>
<!-- properties -->
<bean id="b" class="B">
   <property name="pro">
         <props>
              <prop key="id" value="root"/>
              <prop key="pw" value="root" />
         </props>
   </property>
</bean>

c命名空间和p命名空间

针对基于XML的构造器注入和set方法注入，可以使用简化版的c命名空间注入和p命名空间注入。（c代表constructor，即构造器注入；p代表property，即set方法注入）。

c命名空间注入的示例如下

假设有2个类

package com.food;
public class HotDog {
  public String getFoodName() {
    return "热狗";
  }
}

package com.food;
public class FoodStore {
    private HotDog food;
    private Integer price;
    public FoodStore(HotDog food, Integer price) {
        this.food = food;
        this.price = price;
    }
    //省略get
}

XML中进行如下配置（XML中记得先引入c命名空间，下面展示完整的XML文件）

<!--
c命名空间, 用于简化<constructor-arg>标签
格式： 
可以指定字段名，也可以用构造函数中形参的位置下标，分为引用注入和值注入,如
c:name-ref="anotherbean"
c:name="10"
c:_0-ref="anotherbean"
c:_0="10"
p命名空间, 用于简化<property>标签, 格式与上面类似
-->
<?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:c="http://www.springframework.org/schema/c"
       xmlns:p="http://www.springframework.org/schema/p"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
            http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="hotdog" class="com.food.HotDog"/>
    <bean id="store" class="com.food.FoodStore" c:food-ref="hotdog" c:price="10" />
</beans>

测试

@Test
  public void TestCNameSpace() {
    ApplicationContext context = new ClassPathXmlApplicationContext("spring-demo.xml");
    FoodStore foodStore = context.getBean(FoodStore.class);
    System.out.println(foodStore.getFood().getFoodName());
    System.out.println(foodStore.getPrice());
  }

XML中进行配置时，IDEA也会进行自动提示

p命名空间注入类似，在类中添加set方法，随后在XML中进行配置（记得XML中先引入p命名空间）

XML+注解

IoC配置

首先，在Spring的XML配置文件中，添加 <component-scan> 标签，指定需要扫描的包
然后，在类上打上注解 @Component ，表示需要创建一个该类的对象到Spring容器中。其中 @Component 注解还有3个衍生注解： @Controller ， @Service ， @Repository 。这3个注解提供了更强的语义，但效果和 @Component
是一样的。

@Controller
一般用于表现层

@Service
一般用于业务层

@Repository 一般用于持久层

示例如下

package org.pet;
import org.springframework.stereotype.Component;
@Component
public class PetDao { }

package org.pet;
import org.springframework.stereotype.Component;
@Component
public class PetStoreService { }

<!-- spring-demo.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
            http://www.springframework.org/schema/context/spring-context.xsd">

    <context:component-scan base-package="org.pet"/> <!-- 扫描 org.pet包下所有带@Component注解的类 -->
</beans>

测试

package spring.test;

import org.junit.Test;
import org.pet.PetDao;
import org.pet.PetStoreService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import static org.junit.Assert.*;
public class SpringTest {

  @Test
  public void test() {
    ApplicationContext context = new ClassPathXmlApplicationContext("spring-demo.xml");
    PetStoreService petStore = context.getBean(PetStoreService.class);
    PetDao petDao = context.getBean(PetDao.class);
    assertNotNull(petStore);
    assertNotNull(petDao);
  }
}

注：

@Component

注解中可以指定

bean

的

id

，跟XML配置时

<bean>

标签中的

id

是一样的，当不指定时，

bean

的

id

默认是当前类的简单类名（首字母小写）

DI配置

依赖注入有2步操作：1是从

IoC

容器中查找对象，2是将找到的对象进行注入

跟依赖注入相关的注解有如下几个

@Autowired
- 可以注解在类的字段（Field），方法（Method），构造器（Constructor）上。
  
  当注解在类的字段上时，Spring会先根据该字段的变量类型，在
  IoC 容器中查找对象，随后将找到的对象通过反射的方式，注入到这个字段上（这种方式不需要有 set
  方法）。
  
  当注解在方法或构造器上时，会根据方法的形参类型，在
  IoC
  容器中查找对象，随后通过反射的方式，调用这个方法，并把找到的对象传进去。示例如下
  
  package org.pet; import org.litespring.beans.factory.annotation.Autowired; import org.springframework.stereotype.Component; @Component public class PetStoreService { @Autowired private PetDao dao; // 会在Spring容器中查找类型为 PetDao 的对象, 并进行注入 } package org.pet; import org.litespring.beans.factory.annotation.Autowired; import org.springframework.stereotype.Component; @Component public class PetStoreService { private PetDao dao; @Autowired public PetStoreService(PetDao dao) { this.dao = dao; } }
- @Autowired 由Spring提供
- @Autowired 默认要求被注入的对象必须存在（不存在则报错），如果允许注入的值为 null ，则可以设置其 require 属性为 false ，如 @Autowired(required = false)
- @Autowired
  是按照类型进行装配的
  
  @Autowired private PetDao dao; /** 像这种, 是会去Spring容器中找到一个类型为 PetDao的对象，然后进行注入。而不是根据名称, 去Spring容器中找一个id为 dao 的 bean **/
- @Autowired 在Spring源码中是通过 AutowiredAnnotationBeanPostProcessor 这个类实现的
@Qualifier 由于 @Autowired 是按照类型进行装配，若Spring容器中该类型的 bean 有多个，则会报错。此时，可以结合 @Qualifier 注解（注意这里的 @Qualifier 是Spring中定义的 @Qualifier ），指定 bean 的 id
。示例如下

package org.pet.service; public interface IPetService { void doService(); } package org.pet.service; import org.springframework.stereotype.Service; @Service public class GoodPetService implements IPetService { @Override public void doService() { System.out.println("serve well"); } } package org.pet.service; import org.springframework.stereotype.Service; @Service public class BadPetService implements IPetService { @Override public void doService() { System.out.println("not serve well"); } } package org.pet.controller; import org.pet.service.IPetService; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Qualifier; import org.springframework.stereotype.Controller; @Controller public class PetController { @Autowired @Qualifier("goodPetService") private IPetService petService; public void servePet() { petService.doService(); } } 若在 PetController 中不加 @Qualifier 注解指定 bean 的 id ，则Spring框架会报错 NoUniqueBeanDefinitionException ，因为有多个类型为 IPetService 的对象，Spring不知道该注入哪一个，所以此时需要添加 @Qualifier 注解，指定 bean 的 id
@Resource 跟 @Autowired 类似。可以注解在类的字段上，方法上（构造方法不行）。当指定了 name 属性时，按照名称进行注入（按照 bean 的 id 进行查找），当不指定 name
属性时，按照类型进行注入。

@Resource 注解属于JavaEE规范（JSR250），不属于Spring。该注解的全限定名为 javax.annotation.Resource
。

使用
@Resource 而不是 @Autowired ，便可以和Spring解耦。这样，若以后使用了另外的 IoC
框架，则无需修改代码。

使用示例如下

package org.pet.controller; import org.pet.service.IPetService; import org.springframework.stereotype.Controller; import javax.annotation.Resource; @Controller public class PetController { @Resource(name = "goodPetService") private IPetService petService; public void servePet() { petService.doService(); } } package org.pet.service; import org.springframework.stereotype.Service; @Service public class GoodPetService implements IPetService { @Override public void doService() { System.out.println("serve well"); } }
@Inject 与 @Autowired ， @Resource
功能相同。它可以注解在类的字段，方法，构造器上。

按照类型进行注入。

@Inject
属于JavaEE规范（JSR330），需要导入jar包依赖

<dependency> <groupId>javax.inject</groupId> <artifactId>javax.inject</artifactId> <version>1</version> </dependency> 与 @Inject 属于同一规范的，还有个注解 @Named ，也在这个jar包中。由于 @Inject 是按照类型进行注入，当存在多个类型相同的 bean 时，需要使用 @Named 指定 bean 的 id 。这一点上， @Inject 与 @Named （2个注解都是 javax.inject 包里面的）的组合类似于 @Autowired 与 @Qualifier
（2个注解都是spring包里面的）。

特别的，用于将一个对象注册到Spring容器中的
@Component 注解，也可以用 @Named 注解替换，Spring框架同样会将对象注册到 IoC
容器中。

package org.pet.service; import javax.inject.Named; @Named public class BadPetService implements IPetService { @Override public void doService() { System.out.println("not serve well"); } }
@Value 前面的注解都是用于注入对象的。而 @Value 注解则是用来注入基本类型和 String
类型的。

它支持用
${}
占位符来获取属性文件中的值。

注意：当占位符中带有
$ ，表示取这个变量的值；不带 $
时，直接注入字面量，说明如下

// 带 $ 表示取 properties 文件中 key 为 user.name 的变量的值 @Value("${user.name}") private String name; // 不带$, 则直接将 "user.name" 作为一个字符串，注入给name字段 @Value("{user.name}") private String name; 比如，在 src/main/resources 下新建一个 db.properties db.user=eminem db.password=loseyourself db.age=20
新建一个配置类

package org.pet.properties; import org.springframework.beans.factory.annotation.Value; import org.springframework.context.annotation.PropertySource; import org.springframework.stereotype.Component; @Component @PropertySource("classpath:db.properties") // 使用该注解加载properties配置文件 public class DbConfig { @Value("${db.user}") private String user; @Value("${db.password}") private String password; @Value("${db.age}") private int age; //省略get方法 } XML中配置扫描 org.pet
包

 <context:component-scan base-package="org.pet"/>
测试代码

@Test public void test2() { ApplicationContext context = new ClassPathXmlApplicationContext("spring-demo.xml"); DbConfig dbConfig = context.getBean(DbConfig.class); System.out.println(dbConfig.getUser()); System.out.println(dbConfig.getPassword()); System.out.println(dbConfig.getAge()); }

Spring系列开篇 — 核心功能 IoC, AOP (附事务管理，spring与mybatis整合等)
上面演示的是通过 @PropertySource 注解和 @Value
注解完成属性的注入，若在XML中要如何使用呢

在XML中，通过配置一个
PropertyPlaceholderConfigurer 对象，即可在XML配置文件中使用 ${}
获取其中的属性了，示例如下

在项目的
src/main/resources
资源目录下，新建一个properties文件

# user.properties user=eminem password=loseyourself
新建一个类

package org.demo.pet.config; public class UserConfig { private String user; private String password; // 省略get/set方法 }
创建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:aop="http://www.springframework.org/schema/aop" xmlns:context="http://www.springframework.org/schema/context" xmlns:tx="http://www.springframework.org/schema/tx" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd"> <bean id="propertyConfigurer" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer"> <property name="locations"> <list> <value>user.properties</value> </list> </property> </bean> <bean id="userConfig" class="org.demo.pet.config.UserConfig"> <property name="user" value="${user}"/> <property name="password" value="${password}"/> </bean> </beans>
测试

package org.demo.test; import org.demo.pet.config.UserConfig; import org.junit.Test; import org.junit.runner.RunWith; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.test.context.ContextConfiguration; import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; @RunWith(SpringJUnit4ClassRunner.class) @ContextConfiguration(locations = "classpath:spring-demo2.xml") public class PropertiesTest { @Autowired private UserConfig userConfig; @Test public void test() { System.out.println(userConfig.getUser()); System.out.println(userConfig.getPassword()); } } 其中， PropertyPlaceholderConfigurer 对象，也可以用一个简化的注解 <<context:property-placeholder>
进行替换，效果相同，如下

<context:property-placeholder location="user.properties"/>

其他的一些注解：

@Scope ：注解在类上，与 @Component 配套使用，指定 bean 的作用范围，跟 <bean> 标签中的 scope 属性作用一致。可以设置为 singleton ， prototype 等
@PostConstruct ：注解在方法上，约等于 <bean> 标签中的 init-method ，用于在 bean 完成实例化和依赖注入后，进行自定义的初始化操作
@PreDestroy ：注解在方法上，约等于 <bean> 标签中的 destroy-method ，用于在 bean 销毁之前，进行一些资源释放和清理操作

纯注解

上面的XML+注解的方式，还是需要有一个XML配置文件，来配置要扫描的包。

其实，若看XML不顺眼，则可以完全干掉它，全部采用纯注解进行配置。（在使用SpringBoot进行开发时，几乎都是采用纯注解的方式，并且其约定优于配置的特点，大大降低了开发的成本）

IoC配置

@Configuration 在一个类上打上该注解，则该类就是一个Spring的配置类（相当于Spring的XML配置文件）
@Bean 在配置类中，使用 @Bean 注解一个方法，方法的返回值是一个对象，即可把方法返回值的对象注册到Spring容器。可以配合 @Scope 注解来指定 bean 的作用范围。这个注解主要用来创建一些第三方jar包中的对象到Spring容器。（因为第三方jar包中的代码我们无法修改，无法在其源码上添加 @Component 等注解）
@ComponentScan 通常和 @Configuration 一起使用，注解在类上，指定要扫描的包。可以通过 basePackages 属性，用字符串指定要扫描的包名（多个包直接用逗号分隔）；也可以使用 basePackageClasses 属性指定某个类，则会扫描该类所在的包。
@Import 用于组合多个配置类，比如在某个总配置类中，需要引入其他配置类

示例如下

package org.pet.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

import java.util.Arrays;
import java.util.List;

@Configuration
@ComponentScan(basePackages = {"org.pet.controller","org.pet.service"})
public class SpringConfig {

  @Bean
  public List<Integer> list() {
    return Arrays.asList(1,2,3);
  }
}

其中

package org.pet.controller;
import org.pet.service.IPetService;
import org.springframework.stereotype.Controller;
import javax.inject.Inject;

@Controller
public class PetController {

  @Inject
  private IPetService petService;

  public void servePet() {
    petService.doService();
  }
}

package org.pet.service;
import javax.inject.Named;

@Named
public class BadPetService implements IPetService {
  @Override
  public void doService() {
    System.out.println("not serve well");
  }
}

测试

@Test
  public void test3() {
        // 使用AnnotationConfigApplicationContext, 传入配置类的class
    ApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);
    PetController petController = context.getBean(PetController.class);
    petController.servePet();
    List list = context.getBean(List.class);
    list.forEach(System.out::println);
  }

我们上面的单元测试，都是采用

new

的方式，传入XML配置文件或者配置类的class信息，来创建一个Spring的上下文，那么其实还有一种方式更为方便，那就是与JUnit整合

Spring整合JUnit4

需要引入依赖

<dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>5.0.10.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>

在JUnit测试类上用

@RunWith

注解，传入

SpringJUnit4ClassRunner.class

，并用

@ContextConfiguration

注解申明要加载的Spring配置（可以指定加载XML文件或者配置类的class），随后就可以用

@Autowired

等DI相关的注解来注入需要测试的

bean

啦

package org.demo.test;

import org.demo.pet.service.PetService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:spring-demo.xml")
public class SpringTest {

  @Autowired
  private PetService petService;

  @Test
  public void testXmlAop() {
    petService.servePet();
  }
}

SpringAop

AOP的基本介绍参见附录aop部分

对于AOP的实现，最完备的有

AspectJ

框架，其功能非常强大，提供了完整的AOP实现；而Spring的AOP，旨在提供一个轻量级的实现，以便解决一些最常见的问题。

术语介绍

首先，对AOP相关的术语进行说明

JoinPoint 连接点。即系统中，可以应用通知（参见下文Advice）的时机。也就是可以被AOP拦截下来的地方。连接点可以分为3类
- 方法连接点：可以在方法执行时，进行拦截并添加一些功能
- 字段连接点：可以在字段发生变化时，进行拦截并添加一些功能
- 构造器连接点：可以在构造器执行时，进行拦截并添加一些功能
SpringAOP仅支持方法级别的连接点，而 AspectJ 则支持全部的3种。
PointCut
切入点。可以理解为连接点的匹配条件。满足这个匹配条件的一个或多个连接点，将会被应用通知。

即，通过
PointCut 指定一个规则，满足这个规则的地方，会被AOP拦截下来进行功能增强
Advice 通知，或者叫增强。AOP拦截下 JointPoint 之后要做的工作。比如我通过AOP拦截下一个方法，在这个方法执行前打印一下当前时间，那么打印时间这个动作，就是 Advice ，并且此时是前置通知，因为是在连接点执行之前做的增强。 Advice 描述了2个点
- 要做什么？
  
  即拦截下
  JointPoint 后要添加的额外功能
- 在何时做？在 JointPoint 之前，之后或者环绕。根据何时做，将通知分为了
- - 前置通知（Before）
  - 后置通知（After）：无论 JoinPoint 是否正常执行完毕。在 JoinPoint 执行后，执行增强。可以理解为Java中的 finally 块
  - 环绕通知（Around）
  - 返回通知（After-Returning）： JoinPoint 正常执行结束后，执行增强。
  - 异常通知（After-Throwing）： JoinPoint 抛出异常后，执行增强。
Aspect 切面。切面 = 切入点（PointCut） + 通知（Advice）
- 切入点定义了切面在何处（在哪些连接点）被应用
- 通知定义了切面需要做什么，以及何时做
总结起来就是，在何处，何时，做什么
Introduction
引介。

通过提供一个接口和接口的实现类，向目标对象中添加新的方法。使用示例见下文。
Target 目标对象。被AOP拦截下来的原对象。
Proxy
代理对象。AOP实际是通过对目标对象进行拦截，生成一个代理对象，在代理对象中执行额外操作（增强）。

代理对象中会持有目标对象，在代理对象完成增强后，会调用目标对象执行连接点的方法。
Weaving 织入。将切面应用到目标对象，并创建代理对象的过程。切面在指定的连接点，被织入到目标对象中。在目标对象的生命周期中有多个时间点可以进行织入：
- 编译期
  
  在目标类编译时织入。需要特殊的编译器，AspectJ的织入即是这种方式。
- 类加载期
  
  在目标类被加载到JVM时织入。需要特殊的类加载器，在目标类被加载时，增强该目标类的字节码
- 运行期
  
  切面在运行时被织入，通过动态代理的方式创建一个代理对象（动态代理，分为JDK原生动态代理和CGLib动态代理）。Spring AOP即是这种方式
根据织入时机进行分类，前两种的叫做静态织入，最后一种叫动态织入。AspectJ采用的是静态织入，且主要在编译期织入，而SpringAOP采用的是动态织入

两种动态代理的实现方式说明如下：

JDK原生动态代理。基于接口，和反射技术。涉及到JDK中的2个类：
java.lang.reflect.Proxy 和 java.lang.reflect.InvocationHandler
。被代理的目标对象，必须要实现某一接口，以这个接口为纽带，来完成AOP。

CGLib动态代理。基于继承，和字节码修改技术（asm），需要导入
cglib 依赖包，使用其中的 Enhancer 和 MethodInterceptor 。被代理的目标对象，不能是 final （那样会导致无法继承，无法创建子类），CGLib会创建一个目标对象的子类对象，来完成AOP。

JDK动态代理示例

package dynamic.proxy;

public interface IService {
  void doService();
}

package dynamic.proxy;

public class GoodService implements IService {
  @Override
  public void doService() {
    System.out.println("serve well");
  }
}

package dynamic.proxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class ProxyFactory implements InvocationHandler {

  private Object target;

  private ProxyFactory(Object target) {
    this.target = target;
  }

  @Override
  public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    System.out.println("这是前置通知");
    Object returnVal = method.invoke(target, args);
    System.out.println("这是后置通知");
    return returnVal;
  }

  public static <T> T getProxy(T target) {
    ProxyFactory proxyFactory = new ProxyFactory(target);
    return (T) Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), proxyFactory);
  }
}

测试

package dynamic.proxy;

public class Test {
  public static void main(String[] args) {
    IService service = new GoodService();
    IService proxy = ProxyFactory.getProxy(service);
    proxy.doService();
  }
}

CGLib动态代理示例

先导入依赖

<dependency>
            <groupId>cglib</groupId>
            <artifactId>cglib</artifactId>
            <version>3.3.0</version>
        </dependency>

package dynamic.proxy;

public class MyService {
  public void doService() {
    System.out.println("我的服务手法可好了！客官，试试？");
  }
}

package dynamic.proxy;

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
import java.lang.reflect.Method;

public class CgLibProxyFactory {

  public static <T> T getProxy(T target) {
    Enhancer enhancer = new Enhancer();
    enhancer.setSuperclass(target.getClass());
    enhancer.setCallback(new MethodInterceptor() {
      @Override
      public Object intercept(Object o, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
        System.out.println("前置通知");
        Object returnVal = methodProxy.invokeSuper(o, args);
        System.out.println("后置通知");
        return returnVal;
      }
    });
    return (T) enhancer.create();
  }
}

测试

package dynamic.proxy;

public class Test {

  public static void main(String[] args) {
    MyService service = new MyService();
    MyService proxy = CgLibProxyFactory.getProxy(service);
    proxy.doService();
  }
}

使用

因为现在基本都采用SpringBoot做快速开发了，所以这里先讲解纯注解的SpringAOP使用（这也是最简单的），至于XML的形式，会在本小节的最后部分略微提及。

快速上手

注意，除了有spring最基本的几个依赖，（

context

，

bean

，

core

），还需要有如下maven依赖

<dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aop</artifactId>
            <version>5.0.10.RELEASE</version>
        </dependency>

        <!-- aspectj -->
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.6</version>
        </dependency>

首先要有个目标类

package org.demo.pet.service;

import org.springframework.stereotype.Service;

@Service
public class PetService {
  public void servePet() {
    System.out.println("开始撸猫！");
  }
}

然后，进行切面配置

package org.demo.pet.aop;

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;

@Aspect
@Component
public class LogAop {

    // 切入点, 这里指定切入 PetService类中的任意方法, 方法参数为空
    @Pointcut("execution(* org.demo.pet.service.PetService.*())")
    private void pointcut() {}

    // 当然, 也可以不使用@Pointcut注解单独定义切入点
    // 可以直接将切入点表达式（@Pointcut后面那部分字符串），写到下面的@Before里
    @Before("pointcut()")
    public void before() {
        System.out.println("你好, 我是前置通知, 负责记录日志的~");
    }
}

最后，通过

@Configuration

进行Spring配置，记得加上

@EnableAspectJAutoProxy

package org.demo.pet;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;

@Configuration
@ComponentScan
@EnableAspectJAutoProxy
public class SpringConfig {
}

测试

package org.demo.test;

import org.demo.pet.SpringConfig;
import org.demo.pet.service.PetService;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class SpringTest {

  @Test
  public void testAop() {
    ApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);
    PetService petService = context.getBean(PetService.class);
    petService.servePet();
  }
}

使用AOP的核心内容，是AOP的配置类，下面进行详细说明。

首先，AOP配置类需要注册到Spring容器中，所以要打上

@Component

注解，并且要打上

@Aspect

注解，以表示这个类是切面配置类。

随后，就是配置AOP中最重要的切入点（PointCut）和通知（Advice）。

切入点+通知，构成了一个切面（Aspect）

定义切入点，用

@Pointcut

注解，注解中通过指示器（designators）来编写切入点的匹配条件。有如下的几种指示器

切入点指示器

execution() execution
指示器匹配的粒度最细，是方法级别

格式：[修饰符] 返回值类型包名.类名.方法名(方法参数) [异常声明]

其中修饰符和异常声明是可选的

示例

@Pointcut("execution(public * org.demo.pet.service.PetService.*())") private void pointcut() {} // 上面的指示器，public指的是匹配public方法，第一个*表示返回值是任意类型，中间表示匹配org.demo.pet.service.PetService这个类，后面的*表示PetSerivce中的任意方法，再后面的()是方法的形参列表，为空表示匹配参数为空的方法 @Pointcut("execution(* org.demo..*.*())") private void pointcut() {} // 上面省略了方法修饰符，第一个*表示返回值是任意类型，后面的是包名org.demo，在后面的2个点号..表示当前包及其下的所有子孙包（org.demo下面的全部） // 后面的*表示包下的任意类，再后面的*表示任意方法，最后的()表示参数为空 @Pointcut("execution(* org.demo.pet.service.PetService.*(String,Long))") private void pointcut() {} //上面的表示匹配org.demo.pet.service.PetService类的任意方法，且方法接收2个参数，第1个参数为String,第2个参数为Long @Pointcut("execution(* org.demo.pet.service.PetService.*(Integer,Long,..))") private void pointcut() {} //上面的表示匹配org.demo.pet.service.PetService类的任意方法，且方法接收至少2个参数，前2个参数分别为Integer和Long @Pointcut("execution(* *..*Service.*(..))") private void pointcut() {} //上面的表示匹配类名以Service结尾的类中的任意方法，方法的参数任意 @Pointcut("execution(* *..*Service.do*(..))") private void pointcut() {} //上面的表示匹配类名以Service结尾的类中的以do开头的方法，方法的参数任意
within()
匹配粒度是类级别，类中全部方法都会被匹配上。（注意，若指定匹配某一接口，则接口的实现类并不会被AOP拦截到）

格式跟
execution 略有不同，仅仅需要指定类的全限定名即可，当然，中间也可以使用通配符 * ，以及表示多级包的 ..
示例

//匹配com.service包下的所有类, 最后一个*表示这个包下的所有类 @Pointcut("within(com.service.*)") private void service(){} //匹配com.service包下所有类名以Service结尾的类 @Pointcut("within(com.service.*Service)") private void service(){} // 匹配com.service包及其子孙包下的全部类 @Pointcut("within(com.service..*)") private void service(){} //注意within用来匹配接口是无效的 //假设我们期望匹配com.service下所有实现了SomeService接口的类 //如下的写法并不能达成目标，将within换成this，target，或者使用更通用的execution即可 //或者在within里面的接口后面加上一个加号+ ，表示匹配类及其子类 @Pointcut("within(com.service.SomeService)") public void service(){}
this()
匹配目标对象的AOP代理对象，可以拦截到introduction中的方法

//拦截SomeService接口的所有实现类（就算实现类不在com.service包下） @Pointcut("this(com.service.SomeService)") public void service(){} @Before("service()") public void aop(){ System.out.println("aop take effect"); }
target 匹配目标对象，不能拦截introduction中的方法，在没有引入introductio时，和this是一样的
bean 匹配Spring IoC容器里的bean(通过 bean 的 id
)

//匹配bean名称为dinnerService的bean对象中只有一个参数且为Long的方法 // 表达式可以用 && || 等连接符来做运算 @Pointcut("bean(dinnerService) && args(Long)") public void service(){}
args()
匹配参数

//匹配SomeService接口的所有实现类中，只有一个参数，且参数类型为Long的方法 @Pointcut("this(service.SomeService) && args(Long)") public void service(){} //匹配SomeService接口的所有实现类中，只有一个参数且为Long，或者第一个参数为Long的方法 @Pointcut("this(service.SomeService) && args(Long,..)") public void service2(){} @Before("service()") public void aop(){ System.out.println("aop take effect"); }
@annotation()
匹配带有某一注解的方法。下面示例额外演示了AOP中的参数绑定

先定义一个注解

package org.demo.pet.annotations; import java.lang.annotation.ElementType; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; import java.lang.annotation.Target; @Target(ElementType.METHOD) @Retention(RetentionPolicy.RUNTIME) public @interface Secure { String apiName() default ""; }
再定义一个Service

package org.demo.pet.service; import org.demo.pet.annotations.Secure; import org.springframework.stereotype.Service; @Service public class ConfidentialService { @Secure(apiName = "withdraw") public void withdrawMoney(Long amount) { System.out.println("取了" + amount + "钱"); } }
定义一个AOP

package org.demo.pet.aop; import org.aspectj.lang.annotation.Aspect; import org.aspectj.lang.annotation.Before; import org.demo.pet.annotations.Secure; import org.springframework.stereotype.Component; @Aspect @Component public class SecureAop { @Before("@annotation(secure)") public void before(Secure secure) { System.out.println("我是Secure前置通知, 你所调用的api是" + secure.apiName()); } }
使用配置类进行配置

package org.demo.pet; import org.springframework.context.annotation.ComponentScan; import org.springframework.context.annotation.Configuration; import org.springframework.context.annotation.EnableAspectJAutoProxy; @Configuration @ComponentScan @EnableAspectJAutoProxy public class SpringConfig { }
测试

package org.demo.test; import org.demo.pet.SpringConfig; import org.demo.pet.service.ConfidentialService; import org.junit.Test; import org.junit.runner.RunWith; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.test.context.ContextConfiguration; import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; @RunWith(SpringJUnit4ClassRunner.class) @ContextConfiguration(classes = SpringConfig.class) public class SpringTest { @Autowired private ConfidentialService confidentialService; @Test public void testAnnotationAop() { confidentialService.withdrawMoney(1000L); } }

Spring系列开篇 — 核心功能 IoC, AOP (附事务管理，spring与mybatis整合等)
@within
匹配带有某一注解的类

@Pointcut("@within(anno.CheckThis)") public void check(){} @Component @CheckThis public class DinnerService implements SomeService { @Override public void doService() { System.out.println("Serve dinner"); } }
@target 匹配带有某一注解的类
@args()
匹配带某一注解的参数，示例如下

// 错误的使用如下 //如，有一个这样的方法 public void service(@CheckThis Args args){ } //下面的切入点，并不能拦截到上面的service方法 @Pointcut("@args(com.anno.CheckThis)") //正确的使用如下 //定义一个类, 类上带注解 @CheckThis public class Args{ } //某个方法的入参是这个类 public void service(Args args){ } //下面的切入点，能够拦截到service方法了 @Pointcut("@args(com.anno.CheckThis)")
切入点表达式中的通配符
- * 匹配任意数量字符
- + 匹配指定类及子类
- .. 匹配包及子包，或任意参数
切入点表达式中的逻辑运算符
- && ：逻辑与。在XML配置中，使用 and
- || ：逻辑或。在XML配置中，使用 or
- ! ：逻辑非。在XML配置中，使用 not

AOP参数传递

示例

先定义一个POJO

package org.demo.pet.po;

public class Pet {

    private Integer petNo;

    private String petName;

    private Integer petAge;

    private String masterName;
    // 省略构造函数, get/set函数

}

定义一个Service

package org.demo.pet.service;

import org.demo.pet.po.Pet;
import org.springframework.stereotype.Service;

@Service
public class PetService {
  public void introduce(Pet pet) {
    System.out.printf("我叫%s, 我%d岁了, 我的主人是%s\n", pet.getPetName(), pet.getPetAge(), pet.getMasterName());
  }
}

定义AOP

package org.demo.pet.aop;

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.demo.pet.po.Pet;
import org.springframework.stereotype.Component;

@Aspect
@Component
public class LogAop {

    // 匹配任意包下类名以Service结尾的类中的方法名以intro开头的方法, 且具有一个Pet类型的参数
    @Pointcut("execution(* *..*Service.intro*(..)) && args(pet)")
    private void pointcut(Pet pet) {}

    @Before("pointcut(pet)")
    public void before(Pet pet) {
        System.out.println("下面有请第" + pet.getPetNo() + "号选手进行自我介绍~~鼓掌~~");
    }
}

Spring配置类

package org.demo.pet;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;

@Configuration
@ComponentScan
@EnableAspectJAutoProxy  // 开启AOP自动代理
public class SpringConfig {
}

测试

package org.demo.test;

import org.demo.pet.SpringConfig;
import org.demo.pet.po.Pet;
import org.demo.pet.service.PetService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

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

  @Autowired
  private PetService petService;

  @Test
  public void  test() {
    Pet pet = new Pet(23, "小柴柴", 1, "大黄");
    petService.introduce(pet);
  }
}

AOP引介的使用

我们知道AOP实际是通过生成一个代理对象来完成的。引介可以为被代理的目标对象添加新的属性或新的方法。其原理大概是：将新的方法或属性，用一个新的bean去实现，然后代理对象同时包装了目标对象和这个新的bean。调用代理对象的方法时，会先判断方法是原始目标对象的，还是通过引介引入的新方法。代理对象再委托给其内部的不同bean去执行。

食用示例如下

定义一个接口以及实现类

package org.demo.pet.intro;

public interface IntroFunction {
  void fun();
}

package org.demo.pet.intro;

public class IntroFunctionImpl implements IntroFunction {
  @Override
  public void fun() {
    System.out.println("this is a new function added by introduction");
  }
}

配置AOP

package org.demo.pet.aop;

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.DeclareParents;
import org.demo.pet.intro.IntroFunction;
import org.demo.pet.intro.IntroFunctionImpl;
import org.springframework.stereotype.Component;

@Component
@Aspect
public class IntroAop {

  @DeclareParents(value = "org.demo.pet.service.PetService", defaultImpl = IntroFunctionImpl.class)
  public IntroFunction introFunction;

}

配置类

package org.demo.pet;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;

@Configuration
@ComponentScan(basePackages = {"org.demo.pet.aop", "org.demo.pet.service"})
@EnableAspectJAutoProxy
public class IntroConfig {
}

测试

package org.demo.test;

import org.demo.pet.IntroConfig;
import org.demo.pet.intro.IntroFunction;
import org.demo.pet.service.PetService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;


@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = IntroConfig.class)
public class IntroTest {

  @Autowired
  private PetService petService;

  @Test
  public void test() {
    IntroFunction introFunction = (IntroFunction) petService;
    introFunction.fun();
  }
}

基于XML的AOP使用

准备一个service

package org.demo.pet.service;

import org.demo.pet.po.Pet;

public class PetService {
  public void introduce(Pet pet) {
    System.out.printf("我叫%s, 我%d岁了, 我的主人是%s\n", pet.getPetName(), pet.getPetAge(), pet.getMasterName());
  }
}

准备一个切面类

package org.demo.pet.aop;

public class XmlAspect {

  public void log() {
    System.out.println("我是XML的AOP");
  }
}

配置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: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/aop
                           http://www.springframework.org/schema/aop/spring-aop.xsd">

    <bean id="petService" class="org.demo.pet.service.PetService"/>

    <bean id="xmlAspect" class="org.demo.pet.aop.XmlAspect"/>

    <aop:config>
        <aop:pointcut id="pointcut" expression="within(org..*.PetService)"/>
        <aop:aspect ref="xmlAspect"> <!-- 使用xmlAspect这个对象作为切面对象 -->
             <!-- 调用切面对象中的log方法, 对指定的切入点, 应用前置通知 -->
            <aop:before method="log" pointcut-ref="pointcut"/>
        </aop:aspect>
    </aop:config>

</beans>

测试

package org.demo.test;

import org.demo.pet.po.Pet;
import org.demo.pet.service.PetService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:spring-demo2.xml")
public class XmlAopTest {

  @Autowired
  private PetService petService;

  @Test
  public void test() {
    Pet pet = new Pet(1, "小柴", 2, "大黄");
    petService.introduce(pet);
  }
}

结果

事务支持

Spring并不直接管理事务，而是提供了一系列接口。

事务相关的核心接口有3个：

PlatformTransactionManager

，

TransactionDefinition

，

TransactionStatus

。

接口的具体实现类由各个平台自己去完成，如JDBC有

DataSourceTransactionManager

（spring-jdbc包下），Hibernate有

HibernateTransactionManager

等

PlatformTransactionManager 平台事务管理器。根据不同的持久层框架，选择不同的实现类。如使用的持久层框架是Mybatis或者Spring JDBC Template，需要选用 DataSourceTransactionManager 实现类（在spring-jdbc这个jar包中）；若使用的是Hibernate，需要选用 HibernateTransactionManager 实现类该接口提供了3个方法：
- getTransaction
- commit
- rollback
分别用来获取当前事务，提交事务，回滚事务
TransactionDefinition 事务的定义信息。如，事务的隔离级别，传播行为，超时，只读等。
TransactionStatus 事务的状态信息。如，是否是新事务，是否已提交，是否有保存点，是否回滚等。

XML方式

首先，事务管理是针对持久层数据库访问的，所以需要先配置一个数据源

DataSource

；随后，配置一个

PlatformTransactionManager

的对象，用来管理事务。接着，需要定义，哪些方法需要进行事务管理，以及具体的事务配置（隔离级别，传播行为等）。最后，配置aop，将

PlatformTransactionManager

对象切入目标类。

下面的演示需要持久层的参与，故通过spring整合mybatis，进行演示

数据库建表及初始化

CREATE TABLE `pet` ( `pet_no` int NOT NULL AUTO_INCREMENT, `pet_name` varchar(255) NOT NULL, `pet_age` int NOT NULL, `master_name` varchar(255) NOT NULL, PRIMARY KEY (`pet_no`) ); INSERT INTO pet (`pet_no`, `pet_name`, `pet_age`, `master_name`) VALUES (1, '小柴柴', 1, '大黄');

Spring系列开篇 — 核心功能 IoC, AOP (附事务管理，spring与mybatis整合等)
添加maven依赖

<dependency> <groupId>org.springframework</groupId> <artifactId>spring-core</artifactId> <version>5.0.10.RELEASE</version> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-beans</artifactId> <version>5.0.10.RELEASE</version> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-context</artifactId> <version>5.0.10.RELEASE</version> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-aop</artifactId> <version>5.0.10.RELEASE</version> </dependency>  <dependency> <groupId>org.aspectj</groupId> <artifactId>aspectjweaver</artifactId> <version>1.9.6</version> </dependency> <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>4.12</version> <scope>test</scope> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-test</artifactId> <version>5.0.10.RELEASE</version> </dependency>  <dependency> <groupId>org.springframework</groupId> <artifactId>spring-tx</artifactId> <version>5.0.10.RELEASE</version> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-jdbc</artifactId> <version>5.0.10.RELEASE</version> </dependency>  <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <version>8.0.21</version> <scope>runtime</scope> </dependency>  <dependency> <groupId>org.mybatis</groupId> <artifactId>mybatis</artifactId> <version>3.4.6</version> </dependency>  <dependency> <groupId>org.mybatis</groupId> <artifactId>mybatis-spring</artifactId> <version>2.0.1</version> </dependency>  <dependency> <groupId>com.alibaba</groupId> <artifactId>druid</artifactId> <version>1.1.10</version> </dependency>
创建PO类

package org.demo.pet.po; public class Pet { private Integer petNo; private String petName; private Integer petAge; private String masterName; //省略构造函数, get/set函数 }
创建mybatis的XML配置文件，创建包含SQL语句的mapper.xml文件（注意mybatis的XML配置文件中，不需要再配置数据源信息，数据源将交由Spring管理）

 <?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd"> <configuration> <settings> <setting name="mapUnderscoreToCamelCase" value="true"/>  </settings> <typeAliases> <package name="org.demo.pet.po"/> </typeAliases> <mappers> <mapper resource="PetMapper.xml"/> </mappers> </configuration>  <?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd"> <mapper namespace="org.demo.pet.mapper.PetMapper"> <insert id="insert" parameterType="pet"> insert into pet (pet_name, pet_age, master_name) VALUES (#{petName}, #{petAge}, #{masterName}) </insert> <select id="findAll" resultType="pet"> select * from pet; </select> <update id="changeMasterName" parameterType="pet"> update pet set master_name = #{masterName} where pet_no = #{petNo} </update> </mapper>
创建PetMapper.xml对应的mapper接口

package org.demo.pet.mapper; import org.demo.pet.po.Pet; import java.util.List; public interface PetMapper { int insert(Pet pet); List<Pet> findAll(); int changeMasterName(Pet pet); }
创建PetDao类

package org.demo.pet.dao; import org.demo.pet.mapper.PetMapper; import org.demo.pet.po.Pet; public class PetDao { private PetMapper mapper; public void setMapper(PetMapper mapper) { this.mapper = mapper; } public void changeMasterName(int petNo, String masterName) { Pet pet = new Pet(); pet.setPetNo(petNo); pet.setMasterName(masterName); mapper.changeMasterName(pet); // 先进行数据库更新 System.out.println(1/0); // 再抛出异常 } }
配置数据库信息

# db.properties db.url=jdbc:mysql://localhost:3306/yogurt?serverTimezone=Asia/Shanghai db.user=root db.password=root db.driver=com.mysql.cj.jdbc.Driver
配置Spring的XML文件（在这个XML文件里配置数据源, 以及mybatis的SqlSessionFactory等）

 <?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:aop="http://www.springframework.org/schema/aop" xmlns:context="http://www.springframework.org/schema/context" xmlns:tx="http://www.springframework.org/schema/tx" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd">  <context:property-placeholder location="db.properties"/>  <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"> <property name="driverClassName" value="${db.driver}"/> <property name="url" value="${db.url}"/> <property name="username" value="${db.user}"/> <property name="password" value="${db.password}"/> <property name="initialSize" value="5"/> <property name="maxActive" value="20"/> <property name="minIdle" value="5"/> </bean>  <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean"> <property name="dataSource" ref="dataSource"/>  <property name="configLocation" value="mybatis-config.xml"/>  </bean>  <bean id="petMapper" class="org.mybatis.spring.mapper.MapperFactoryBean"> <property name="mapperInterface" value="org.demo.pet.mapper.PetMapper"/> <property name="sqlSessionFactory" ref="sqlSessionFactory"/> </bean>  <bean id="petDao" class="org.demo.pet.dao.PetDao"> <property name="mapper" ref="petMapper"/> </bean>  <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager"> <property name="dataSource" ref="dataSource"/> </bean>  <tx:advice id="txAdvice" transaction-manager="transactionManager"> <tx:attributes> <tx:method name="change*"/>  </tx:attributes> </tx:advice>  <aop:config>  <aop:advisor advice-ref="txAdvice" pointcut="execution(* org.demo.pet.dao.PetDao.change*(..))"/> </aop:config> </beans>
测试 package org.demo.test; import org.demo.pet.dao.PetDao; import org.junit.Test; import org.junit.runner.RunWith; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.test.context.ContextConfiguration; import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; @RunWith(SpringJUnit4ClassRunner.class) @ContextConfiguration(locations = "classpath:spring-demo.xml") public class SpringMybatisXmlTest { @Autowired private PetDao petDao; @Test public void testTransactional() { int petNo = 1; String newMasterName = "小李"; petDao.changeMasterName(petNo, newMasterName); } } 在执行PetDao中的changeMasterName这个方法时，我们先进行了数据库更新，随后抛出了一个异常。我们希望把changeMasterName这整个方法作为一个事务，若这个方法执行过程中出现了异常，则应该进行事务回滚。为了更清晰地看到SQL执行情况，我们通过如下的配置打开mybatis的SQL语句打印功能
2. 添加log4j的maven依赖
  
   <dependency> <groupId>log4j</groupId> <artifactId>log4j</artifactId> <version>1.2.17</version> </dependency> <dependency> <groupId>org.slf4j</groupId> <artifactId>slf4j-log4j12</artifactId> <version>1.7.7</version> </dependency> <dependency> <groupId>org.slf4j</groupId> <artifactId>slf4j-api</artifactId> <version>1.7.30</version> </dependency>
3. mybatis的XML配置文件中开启日志打印
  
  <?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd"> <configuration> <settings> <setting name="mapUnderscoreToCamelCase" value="true"/> <setting name="logImpl" value="LOG4J"/>  </settings> <typeAliases> <package name="org.demo.pet.po"/> </typeAliases> <mappers> <mapper resource="PetMapper.xml"/> </mappers> </configuration>
4. 添加log4j.properties配置文件到 src/main/resources
  目录下
  
  # 开启DEBUG级别的日志, 才能看到SQL语句 log4j.rootLogger=DEBUG, CONSOLE ## for console log4j.appender.CONSOLE=org.apache.log4j.ConsoleAppender log4j.appender.CONSOLE.layout=org.apache.log4j.PatternLayout log4j.appender.CONSOLE.layout.ConversionPattern=%d %p %t %c - %m%n log4j.appender.CONSOLE.Encoding=UTF-8
此时运行测试代码，控制台的日志情况如下

根据日志，确实发生了事务回滚

我们观察数据库，这一行数据并没有发生修改，说明事务管理生效

若随便进行一下改动，比如在Spring的XML配置中，将AOP的相关配置去掉，即去掉下面的XML配置

<aop:config>  <aop:advisor advice-ref="txAdvice" pointcut="execution(* org.demo.pet.dao.PetDao.change*(..))"/> </aop:config>
再次执行，结果如下，没有发生事务回滚，数据更新成功

再查看数据库，发现信息已经被修改，说明事务管理未生效

XML+注解

该种方式与XML方式大同小异，唯一的区别是，Spring的XML文件中无需配置AOP了。在需要事务管理的方法上打上

@Transactional

注解即可，具体的事务隔离级别，传播行为，可以在

@Transactional

注解中进行配置，示例如下

Spring的XML配置文件，去掉 <tx:advice> 和 <aop-config> 标签，添加 <tx:annotation-driven>
标签

<?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:aop="http://www.springframework.org/schema/aop" xmlns:context="http://www.springframework.org/schema/context" xmlns:tx="http://www.springframework.org/schema/tx" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd"> <context:property-placeholder location="db.properties"/> <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"> <property name="driverClassName" value="${db.driver}"/> <property name="url" value="${db.url}"/> <property name="username" value="${db.user}"/> <property name="password" value="${db.password}"/> <property name="initialSize" value="5"/> <property name="maxActive" value="20"/> <property name="minIdle" value="5"/> </bean> <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean"> <property name="dataSource" ref="dataSource"/> <property name="configLocation" value="mybatis-config.xml"/> </bean> <bean id="petMapper" class="org.mybatis.spring.mapper.MapperFactoryBean"> <property name="mapperInterface" value="org.demo.pet.mapper.PetMapper"/> <property name="sqlSessionFactory" ref="sqlSessionFactory"/> </bean> <bean id="petDao" class="org.demo.pet.dao.PetDao"> <property name="mapper" ref="petMapper"/> </bean>  <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager"> <property name="dataSource" ref="dataSource"/> </bean>  <tx:annotation-driven transaction-manager="transactionManager"/> </beans>
PetDao

package org.demo.pet.dao; import org.demo.pet.mapper.PetMapper; import org.demo.pet.po.Pet; import org.springframework.transaction.annotation.Isolation; import org.springframework.transaction.annotation.Transactional; public class PetDao { private PetMapper mapper; public void setMapper(PetMapper mapper) { this.mapper = mapper; } @Transactional(isolation = Isolation.REPEATABLE_READ) // RR隔离级别 public void changeMasterName(int petNo, String masterName) { Pet pet = new Pet(); pet.setPetNo(petNo); pet.setMasterName(masterName); mapper.changeMasterName(pet); System.out.println(1/0); // 为了抛出异常 } }

测试代码和上面相同，测试结果如下

可见发生了事务回滚，数据库情况不再赘述

纯注解

若实在看XML不顺眼，那么也有纯注解的使用方式，如下

创建一个properties类，读取并加载 db.properties
中的数据库配置信息

package org.demo.pet.properties; import org.springframework.beans.factory.annotation.Value; import org.springframework.context.annotation.PropertySource; import org.springframework.stereotype.Component; @Component @PropertySource("classpath:db.properties") public class DbProperties { @Value("${db.url}") private String url; @Value("${db.driver}") private String driverClassName; @Value("${db.user}") private String user; @Value("${db.password}") private String password; // 省略get方法 }
用 @Component 系列的注解，将PetDao注册到Spring容器，并在方法上打上 @Transactional package org.demo.pet.dao; import org.demo.pet.mapper.PetMapper; import org.demo.pet.po.Pet; import org.springframework.stereotype.Repository; import org.springframework.transaction.annotation.Isolation; import org.springframework.transaction.annotation.Transactional; @Repository public class PetDao { @Autowired // 改用 @Autowired 自动注入 private PetMapper mapper; public void setMapper(PetMapper mapper) { this.mapper = mapper; } @Transactional(isolation = Isolation.REPEATABLE_READ) public void changeMasterName(int petNo, String masterName) { Pet pet = new Pet(); pet.setPetNo(petNo); pet.setMasterName(masterName); mapper.changeMasterName(pet); System.out.println(1/0); // 为了抛出异常 } }
创建Spring配置类

package org.demo.pet; import com.alibaba.druid.pool.DruidDataSource; import org.demo.pet.properties.DbProperties; import org.mybatis.spring.SqlSessionFactoryBean; import org.mybatis.spring.annotation.MapperScan; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.ComponentScan; import org.springframework.context.annotation.Configuration; import org.springframework.core.io.ClassPathResource; import org.springframework.jdbc.datasource.DataSourceTransactionManager; import org.springframework.transaction.annotation.EnableTransactionManagement; import javax.sql.DataSource; @Configuration @ComponentScan // 扫描当前包 @MapperScan(basePackages = "org.demo.pet.mapper") // 扫描mybatis的mapper接口, 生成代理对象 @EnableTransactionManagement // 开启事务管理 public class SpringMybatisConfig { /** * 创建DataSource，形参列表中的 DbProperties会自动注入, 因为DbProperties被@ComponentScan扫描到了Spring容器中 * **/ @Bean public DataSource dataSource(DbProperties dbProperties) { DruidDataSource dataSource = new DruidDataSource(); dataSource.setUrl(dbProperties.getUrl()); dataSource.setUsername(dbProperties.getUser()); dataSource.setPassword(dbProperties.getPassword()); dataSource.setDriverClassName(dbProperties.getDriverClassName()); return dataSource; } /** * mybatis 的 SqlSessionFactory, 形参中的 dataSource 也会自动注入, 因为上面的方法创建了 * **/ @Bean public SqlSessionFactoryBean sqlSessionFactoryBean(DataSource dataSource) { SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean(); sqlSessionFactoryBean.setDataSource(dataSource); // 这里传入mybatis的xml配置文件进行配置 // 当然，不想用XML的话，也可以创建 mybatis 中的 Configuration 对象, 在代码中对Configuration对象进行配置, sqlSessionFactoryBean.setConfigLocation(new ClassPathResource("mybatis-config.xml")); return sqlSessionFactoryBean; } /** * 事务管理器 transactionManager * **/ @Bean public DataSourceTransactionManager dataSourceTransactionManager(DataSource dataSource) { DataSourceTransactionManager transactionManager = new DataSourceTransactionManager(); transactionManager.setDataSource(dataSource); return transactionManager; } }
测试

这次，我们换一个宠物，先往数据库里插入一条数据

Spring系列开篇 — 核心功能 IoC, AOP (附事务管理，spring与mybatis整合等)
然后尝试将编号 2 的宠物的主人改为 小李 package org.demo.test; import org.demo.pet.SpringMybatisConfig; import org.demo.pet.dao.PetDao; import org.junit.Test; import org.junit.runner.RunWith; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.test.context.ContextConfiguration; import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; @RunWith(SpringJUnit4ClassRunner.class) @ContextConfiguration(classes = SpringMybatisConfig.class) public class SpringMybatisAnnoTest { @Autowired private PetDao petDao; @Test public void testTransaction() { petDao.changeMasterName(2, "小李"); } } 测试执行结果如下，可以看到事务成功回滚

Spring系列开篇 — 核心功能 IoC, AOP (附事务管理，spring与mybatis整合等)
数据库中的2号宠物 大橘 的主人仍然是 大黄

Spring系列开篇 — 核心功能 IoC, AOP (附事务管理，spring与mybatis整合等)

小结

使用Spring的事务控制功能，注意如下几点即可

最重要的。需要创建一个 TransactionManager 对象（即spring提供的接口 PlatformTransactionManager 的实现类对象），它负责事务管理（这个 TransactionManager 对象又需要一个 DataSource
数据源对象）。人如其名，Spring正是通过这个对象完成的事务管理功能。

所以这个对象必须有，无论是XML方式还是注解方式。
定义哪些方法需要进行事务管理，并对每个方法设置具体的事务配置（事务隔离级别，传播行为，是否只读等）
对这些方法应用AOP切面

无论是XML方式，还是注解方式，都需要创建一个

TransactionManager

对象到Spring容器中。

若是纯XML，配置

<tx:advice>

（对应上面的2）和

<aop-config>

（对应上面的3）。

若使用

@Transactional

注解。若采用XML+注解混合使用的方式，XML中，不需要

<tx:advice>

和

<aop-config>

，只需要加上

<tx:annotation-driven>

标签；若采用纯注解的方式，则要在Spring配置类上加上

@EnableTransactionManagement

注解

实际，上面的演示中，mybatis和spring的整合占了很大一部分内容。

附录

IoC

Inversion of Control，控制反转。

是面向对象编程的一个重要思想，能够指导我们设计出松散耦合的良好程序。

传统编程中，若我们在一个类

中需要使用另一个类

的方法，通常的做法是通过new关键字等手段，创建一个

的对象。这就导致了类与类之间的高度耦合，使得整个系统变得脆弱，对此简单的理解是：若类

发生了一些变化，很有可能需要修改类

。而当系统中类的规模较大时，类与类之间的依赖关系，将交织形成一张大网，网中任意一个类的修改，将引起连锁反应，使得多个类要进行同步修改，这无疑是一种灾难。

于是，

IoC

思想应运而生。有了

IoC

，当

中需要

时，

无需自己去寻找并创建

，而是告诉

IoC

容器：“我需要

”，

IoC

容器便会找到一个合适的

对象（有必要的话会进行创建），交给

使用。这样，即使

发生了变化，

也无需关心，

只需要问

IoC

容器要一个

对象即可。

如果没有

IoC

，当

想要

时，只能

自己主动去创建；而有了

IoC

，

只需要乖乖坐好等待（被动），

IoC

容器便会自动把

带过来给他。

这种【把对象的创建和管理的职责，由原先的类，转交给

IoC

容器】的思想，是为控制反转。

当没有

IoC

时，

需要自己去创建

，还需要管理

，并且

只在

的作用范围内，无法被其他的

，

复用，可谓金屋藏娇了。而有了

IoC

之后，所有对象的创建和管理都由

IoC

容器统一负责，大大减轻了类的负担，降低了类之间的耦合。需要什么，只要跟

IoC

说一声，就能得到，无需每个类自己去承担创建和管理对象的职责。（如果找对象也能这么方便那就好了）。并且，

IoC

容器就像一个公共资源池，同一个对象，我用完了你还能用，你用完了他还能用，对象变得可复用了，而不必每次使用都重新创建。

经常和

IoC

同时出现的，还有个兄弟，叫依赖注入（Dependency Injection，或简称DI）。

中需要用到

，则称

依赖于

，或者

是

的依赖。

IoC

容器找到

，并把

注入到

中，此过程便为依赖注入。

IoC

和

DI

在本质上是同一个东西，只是从不同的角度进行描述。

IoC

是从整体思想上的描述，而

DI

是从具体的操作细节上的描述。

AOP

Aspect Oriented Programming，面向切面编程。

一个系统中，有的【通用功能】需要被应用到各个业务模块当中，但是我们又不想在每个业务模块里明确地调用它们。比如日志，安全，事务管理，性能监控。它们都很重要，但不应该由各个业务模块来主动参与它们的行为。

这些【通用功能】，从概念上讲，应该是和【业务逻辑】相分离的，属于通用的【系统逻辑】。

要进行功能的重用，最常见的技术是继承，但是如果使所有负责业务逻辑的类继承一个相同的基类，会导致形成一个脆弱的对象体系。并且继承表达的是一种

is a

的关系，而这种场景下，【业务逻辑】和【系统逻辑】并不是

is a

的关系。

AOP

采取横向抽取机制，补充了传统的纵向继承体系无法解决的重复性代码优化的问题。将代码中的【业务逻辑】和【系统逻辑】解耦，提高了程序的维护性和健壮性。

假设有一个电商网站，其内部分为了【订单，物流，支付，用户】这4个模块，若我们想对这4个模块添加【性能监控】的功能。采用纵向继承机制，则图示如下

同一份【性能监控】代码重复的分布在了4个业务模块中，而当【性能监控】的代码需要改动时，则需要同步修改4个模块。这样的纵向继承形式的代码复用，将【系统逻辑】和【业务逻辑】紧紧地耦合在了一起，非常不便于系统的维护和扩展。（虽然可以将【性能监控】的代码写在一个父类中，然后让各个负责业务的类继承它，但是子类中还是需要显式地调用其中的方法以完成性能监控的功能，业务逻辑的代码还是会对系统逻辑的代码有所感知，并且此时的场景不满足

is a

的关系，不适合采用继承）

于是，

AOP

出现了，它采用横向抽取机制，将【系统逻辑】单独抽取出来，随后通过代码织入（静态织入，动态织入）的方式，对【业务逻辑】进行功能增强。图示如下

各个业务模块对【性能监控】一无所知。【性能监控】只需要编写一份代码，随后通过自动代码织入的方式神不知鬼不觉地将自己的代码逻辑添加到各个业务模块中，实现对业务模块的功能增强。

这样，【业务逻辑】和【系统逻辑】便可以独立开来，极大的降低了系统的耦合性。

bean的其他实例化方式

静态工厂

通过一个工厂类的静态方法来实例化，示例如下

package org.litespring.pojo; public class StaticFactory { public static PetStoreService createPetStore() { return new PetStoreService(); } }  <bean id="petStore2" class="org.litespring.pojo.StaticFactory" factory-method="createPetStore"/> 
实例工厂

通过一个工厂类的普通方法（非静态）来实例化，示例如下

package org.litespring.pojo; public class InstanceFactory { public PetStoreService createPetStore() { return new PetStoreService(); } }  <bean id="instanceFactory" class="org.litespring.pojo.InstanceFactory"/> <bean id="petStore2" factory-bean="instanceFactory" factory-method="createPetStore"/>

bean的生命周期

实例化
bean的依赖注入
BeanNameAware
BeanFactoryAware
ApplicationContextAware
BeanPostProcessor的postProcessBeforeInitialization

注意：若一个bean，实现了BeanPostProcessor接口，并且该bean被纳入spring容器，那么这个bean中的
postProcessBeforeInitialization 和 postProcessAfterInitialization 会对所有bean的创建进行拦截，统一进行前置后置处理
@PostConstruct 方法
InitializingBean 的 afterPropertiesSet 方法
<bean>标签中的init-method
BeanPostProcessor的postProcessAfterInitialization
（bean正常存活）
@PreDestroy 方法
<bean>标签中的destroy-method
DisposableBean 的 destroy 方法

Spring系列开篇 — 核心功能 IoC, AOP (附事务管理，spring与mybatis整合等)

文章目录

概述

重要概念

快速入门

基本使用

纯XML

IoC配置

DI配置

构造函数注入

set方法注入

c命名空间和p命名空间

XML+注解

IoC配置

DI配置

纯注解

IoC配置

Spring整合JUnit4

SpringAop

术语介绍

JDK动态代理示例

CGLib动态代理示例

使用

快速上手

切入点指示器

AOP参数传递

AOP引介的使用

基于XML的AOP使用

事务支持

XML方式

XML+注解

纯注解

小结

附录

IoC

AOP

bean的其他实例化方式

bean的生命周期

继续阅读