1. 基本概念

1.1 优点

  • Spring是一个开源的免费的框架（容器）
  • Spring是一个轻量级的，非侵入式的框架
  • 控制反转（IOC Inversion of Control 和面向切面编程（AOP Aspect Oriented Programming）
  • 支持事务的处理，对框架整合的支持！

1.2 组成

Spring - 图1

  • Spring-Core：Core包是框架的最基础部分，并提供依赖注入（Dependency Injection）管理Bean容器功能。这里的基础概念是BeanFactory，它提供对Factory模式的经典实现来消除对程序性单例模式的需要，并真正地允许你从程序逻辑中分离出依赖关系和配置。

  • Spring-Context：核心模块的BeanFactory使Spring成为一个容器，而上下文模块使它成为一个框架。这个模块扩展了BeanFactory的概念，增加了消息、事件传播以及验证的支持。另外，这个模块提供了许多企业服务，例如电子邮件、JNDI访问、EJB集成、远程以及时序调度（scheduling）服务。也包括了对模版框架例如Velocity和FreeMarker集成的支持。

  • Spring-Aop：Spring在它的AOP模块中提供了对面向切面编程的丰富支持。例如方法拦截器（servletListener ,controller….）和切点，可以有效的防止代码上功能的耦合，这个模块是在Spring应用中实现切面编程的基础。Spring的AOP模块也将元数据编程引入了Spring。使用Spring的元数据支持，你可以为你的源代码增加注释，指示Spring在何处以及如何应用切面函数。

  • Spring-Dao：使用JDBC经常导致大量的重复代码，取得连接、创建语句、处理结果集，然后关闭连接、旧代码中迁移自定义工具类JDBCUtil 也让开发变得繁琐。Spring的Dao模块对传统的JDBC进行了抽象，还提供了一种比编程性更好的声明性事务管理方法。

  • Spring-Web：Web上下文模块建立于应用上下文模块之上，提供了WEB开发的基础集成特性，例如文件上传。另外，这个模块还提供了一些面向服务支持。利用Servlet listeners进行IOC容器初始化和针对Web的applicationcontext。

  • Spring Web MVC：(Model-View-Controller)Spring为构建Web应用提供了一个功能全面的MVC框架。它提供了一种清晰的分离模型，在领域模型代码和web form之间。并且，还可以借助Spring框架的其他特性。

  • Spring-ORM：关系映射模块，ORM包为流行的“关系/对象”映射APIs提供了集成层，包括JDO，Hibernate和iBatis（MyBatis）。通过ORM包，可以混合使用所有Spring提供的特性进行“对象/关系”映射，方便开发时小组内整合代码。

Spring - 图2

1.3 基本案例

创建UseDao接口

UseDaoImpl,UseDaoMysqlImpl,UseDaoOrcalImpl实现接口

UseService业务接口

UseServiceImpl业务实现接口

applicationContext.xmlSpring的配置文件

  1. public interface UseDao {
  2.     public void use();
  3. }
  5. public class UseDaoImpl implements UseDao {
  6.     public void use(){
  7.         System.out.println("use dao...");
  8.     }
  9. }
  11. public class UseDaoMysqlImpl implements UseDao{
  12.     public void use(){
  13.         System.out.println("use mysql...");
  14.     }
  15. }
  17. public class UseDaoOrcalImpl implements UseDao{
  18.     public void use(){
  19.         System.out.println("use Orcal...");
  20.     }
  21. }
  23. public interface UseService {
  24.     public void use();
  25. }
  27. public class UseServiceImpl implements UseService {
  28.     private UseDao useDao;
  30.     // 通过set注入，IOC实现反转
  31.     public void setUseDao(UseDao useDao){
  32.         this.useDao = useDao;
  33.     }
  35.     public void use(){
  36.         useDao.use();
  37.     }
  38. }
  40. // 测试结果，现在是由我们自行控制创建对象 , 把主动权交给了调用者
  41.     @Test
  42.     public void test1() {
  43.         UseService useService = new UseServiceImpl();
  44.         ((UseServiceImpl) useService).setUseDao(new UseDaoMysqlImpl());
  45.         useService.use();
  47.         ((UseServiceImpl) useService).setUseDao(new UseDaoOrcalImpl());
  48.         useService.use();
  49.     }

现在通过配置Spring的applicationContext.xml文件来控制反转

控制反转是一种通过描述（XML或注解）并通过第三方去生产或获取特定对象的方式。在Spring中实现控制反转的是IoC容器，其实现方法是依赖注入（Dependency Injection,DI）

  1. 在maven的pom.xml配置中添加依赖
  2. <dependency>
  3.    <groupId>org.springframework</groupId>
  4.    <artifactId>spring-webmvc</artifactId>
  5.    <version>5.1.10.RELEASE</version>
  6. </dependency>
  1. // 1. 在pojo中编写一个普通的类，无参构造类型
  2. public class Hello {
  3.    private String name;
  5.    public String getName() {
  6.        return name;
  7.   }
  8.    public void setName(String name) {
  9.        this.name = name;
  10.   }
  12.    public void show(){
  13.        System.out.println("Hello,"+ name );
  14.   }
  15. }
  1. 在applicationContext.xml中配置
  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
  6.     // id任意起的唯一标识名字，表示该类对象； class为调用类的全路径名；property属性中name为类中的变量名，value给该变量赋值
  7.     <bean id="hello" class="com.ahang.demo.pojoo.Hello">
  8.         <property name="str" value="nihao"></property>
  9.     </bean>
  10. </beans>
  1. 最后在测试类中测试
    1.  @Test
    2.  public void test1() {
    3.      // 找到配Spring的配置文件
    4.      ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
    5.      // 通过getBean(id)获取配置文件中的对应的类对象
    6.      Hello h = (Hello)context.getBean("hello");
    7.      System.out.println(h.toString());
    8.      System.out.println(h.getStr());
    9.  }
  • Hello 对象是谁创建的 ? hello 对象是由Spring创建的

  • Hello 对象的属性是怎么设置的 ? hello 对象的属性是由Spring容器设置的

  • 控制 : 谁来控制对象的创建 , 传统应用程序的对象是由程序本身控制创建的 , 使用Spring后 , 对象是由Spring来创建的

  • 反转 : 程序本身不创建对象 , 而变成被动的接收对象 .
  1. 通过在配置中添加来控制使用ServiceImpl
  1.     <bean id="useDaoMysql" class="com.ahang.demo.dao.UseDaoMysqlImpl"></bean>
  2.     <bean id="useDaoOrcal" class="com.ahang.demo.dao.UseDaoOrcalImpl"></bean>
  3.     <bean id="useServiceImpl" class="com.ahang.demo.service.UseServiceImpl">
  4.         <property name="useDao" ref="useDaoMysql"></property>
  5.     </bean>
  1.     @Test
  2.     public void test2(){
  3.         ApplicationContext con = new ClassPathXmlApplicationContext("applicationContext.xml");
  4.         UseServiceImpl useServiceImpl = (UseServiceImpl) con.getBean("useServiceImpl");
  5.         useServiceImpl.use();
  6.     }

1.4 基本配置

1.4.1 scope范围

1）当scope的取值为singleton时

  1.   `Bean`的实例化个数：1个
  3.   `Bean`的实例化时机：当`Spring`核心文件被加载时，实例化配置的`Bean`实例
  5.   `Bean`的生命周期：

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

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

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

2）当scope的取值为prototype时

  1.   `Bean`的实例化个数：多个
  3.   `Bean`的实例化时机：当调用`getBean()`方法时实例化`Bean`

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

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

对象销毁：当对象长时间不用时，被 Java 的垃圾回收器回收了

  1.     <bean id="hello" class="com.ahang.demo.pojo.Hello" scope="singleton"> </bean>
  1.     @Test
  2.     public void test5(){
  3.         ApplicationContext con = new ClassPathXmlApplicationContext("applicationContext.xml");
  4.         Hello hello =(Hello) con.getBean("hello");
  5.         Hello hello1 = (Hello) con.getBean("hello");
  6.         System.out.println(hello == hello1);  // true scope范围为单例时，声明了多个其实都是同一个对象同一个地址
  7.     }
  1.     <bean id="hello" class="com.ahang.demo.pojo.Hello" scope="prototype"> </bean>
  1.     @Test
  2.     public void test5(){
  3.         ApplicationContext con = new ClassPathXmlApplicationContext("applicationContext.xml");
  4.         Hello hello =(Hello) con.getBean("hello");
  5.         Hello hello1 = (Hello) con.getBean("hello");
  6.         System.out.println(hello == hello1);  // false, scope范围为多例时，声明了多个则有多个地址不同的对象
  7.     }

1.4.2 生命周期

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

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

hello类中声明init()和destory()方法：

  1.     <bean id="hello" class="com.ahang.demo.pojo.Hello" scope="singleton" init-method="init" destroy-method="destory"> </bean>

1.4.3 有参构造

  1. 通过指定参数名称配置
  1.     <bean id="hello" class="com.ahang.demo.pojo.Hello" scope="singleton" >
  2.         <constructor-arg name="str" value="haha" />
  3.     </bean>
  1. 通过指定参数位置
  1.     <bean id="hello" class="com.ahang.demo.pojoo.Hello">
  2.         <constructor-arg index="0" value="haha" />
  3.     </bean>

1.4.4 别名名称

  1.     <bean id="hello" class="com.ahang.demo.pojo.Hello" name="h1 h2,h3;h4"></bean>  <!--设置的name可以通过空格,;等隔开-->
  3.     <alias name="hello" alias="hello2"/>

1.4.5 import导入其他配置

对于团队开发多个合作，有多个xml的配置文件，最后需要汇总到一个中applicationContext.xml

  1. <import resource="beans1.xml"/>
  2. <import resource="beans2.xml"/>
  3. <import resource="beans3.xml"/>

1.6 依赖注入

Dependency Injection

依赖 : 指Bean对象的创建依赖于容器 . Bean对象的依赖资源 .

注入 : 指Bean对象所依赖的资源 , 由容器来设置和装配 .

1.6.1 构造器注入

通过构造函数录入参数

1.6.2 Set注入

在pojo中测试类1

  1. public class Address {
  2.     private String address;
  3.     public String getAddress(){ return address; }
  4.     public void setAddress(String address){ this.address = address; }
  5. }

对于多种类型的数据看如何注入

  1. public class InjectDemo {
  2.     private String name;
  3.     private Address address;
  4.     private String[] str;
  5.     private List<String> list;
  6.     private Map<Integer,String> map;
  7.     private Set<String> set;
  8.     private String kong;
  9.     private Properties info;
  11.     public String getName() { return name; }
  12.     public void setName(String name) { this.name = name; }
  13.     ...getXXX...setXXX

在applicationContext.xml中对于不同类型数据注入方式：

  1.     <bean id="addr" class="com.ahang.demo.pojo.Address">
  2.         <property name="address" value="China"></property>
  3.     </bean>
  5.     <bean id="inject" class="com.ahang.demo.pojo.InjectDemo">
  6.         <property name="name" value="ahang"></property>  // 常量
  7.         <property name="address" ref="addr"></property>  // 引用其他类
  8.         // 数组
  9.         <property name="str">
  10.             <array>
  11.                 <value>str1</value>
  12.                 <value>str2</value>
  13.                 <value>str3</value>
  14.             </array>
  15.         </property>
  17.         // 列表
  18.         <property name="list">
  19.             <list>
  20.                 <value>list1</value>
  21.                 <value>list2</value>
  22.                 <value>list3</value>
  23.             </list>
  24.         </property>
  26.         // map表
  27.         <property name="map">
  28.             <map>
  29.                 <entry key="1" value="123"/>
  30.                 <entry key="2" value="234"/>
  31.                 <entry key="3" value="345"/>
  32.             </map>
  33.         </property>
  35.         // set表
  36.         <property name="set">
  37.             <set>
  38.                 <value>set1</value>
  39.                 <value>set2</value>
  40.                 <value>set3</value>
  41.             </set>
  42.         </property>
  44.         // 空null类型数据
  45.         <property name="kong"><null></null></property>
  47.         // properties类型
  48.         <property name="info">
  49.             <props>
  50.                 <prop key="id">1234</prop>
  51.                 <prop key="name">haha</prop>
  52.                 <prop key="gender">man</prop>
  53.             </props>
  54.         </property>
  55.     </bean>

1.6.3 p命名和c命名注入

需要在配置文件中添加：

  1.        xmlns:p="http://www.springframework.org/schema/p"
  2.        xmlns:c="http://www.springframework.org/schema/c"
  1. public class User {
  2.     private String name;
  3.     private int age;
  5.     public User(){}
  7.     public User(String name, int age){
  8.         this.name = name;
  9.         this.age = age;
  10.     }
  11. }

具体使用：

  • p命名直接对变量注入
  • c命名需要注意添加有参构造方法才能使用
  1.     <bean id="user" class="com.ahang.demo.pojo.User" p:name="ahang" p:age="10"></bean>
  3.     <bean id="user1" class="com.ahang.demo.pojo.User" c:name="haha" c:age="20"></bean>

1.7 自动装配

环境满足Spring的bean依赖条件，会在上下文中寻找对应的bean

Spring中bean有三种装配机制，分别是：

  • 在xml中显式配置；
  • 在java中显式配置；
  • 隐式的bean发现机制和自动装配

推荐不使用自动装配xml配置, 而使用注解

  1. public class Cat {
  2.     public void bark(){
  3.         System.out.println("miao~");
  4.     }
  5. }
  7. public class Dog {
  8.     public void bark(){
  9.         System.out.println("wang~");
  10.     }
  11. }
  13. public class User {
  14.     private String name;
  15.     private int age;
  16.     private Cat cat;
  17.     private Dog dog;
  18.     public Cat getCat() {return cat;}
  19.     public void setCat(Cat cat) {this.cat = cat;}
  20.     ...getXXX...setXXX...

1.7.1 byType自动装配

只要上下文中存在User类中定义的bean类型：如User中存在Cat和Dog两个引用类，而上文中存在定义好的bean类型为Cat和Dog且唯一，bean的id可以随意命名。

如果存在两个Dog类型的bean则会报错，如

<bean id="dog1" class="com.ahang.demo.pojo.Dog"></bean>
<bean id="dog2" class="com.ahang.demo.pojo.Dog"></bean>

  1.     <bean id="cat1" class="com.ahang.demo.pojo.Cat" ></bean>
  2.     <bean id="dog" class="com.ahang.demo.pojo.Dog"></bean>
  3.     <bean id="user2" class="com.ahang.demo.pojo.User" autowire="byType">
  4.         <constructor-arg name="age" value="10"></constructor-arg>
  5.         <constructor-arg name="name" value="kaka"></constructor-arg>
  6.         <!--<property name="cat" ref="cat"></property>-->
  7.         <!--<property name="dog" ref="dog"></property>-->
  8.         <property name="age" value="30"></property>
  9.     </bean>

1.7.2 byName自动装配

上下文需要存在Bean的id等同于User中的方法setXXX中XXX才能自动装配

则可以存在多个相同类型的bean，但是id需要唯一对应相同，如：

<bean id="dog" class="com.ahang.demo.pojo.Dog"></bean>

<bean id="dog2" class="com.ahang.demo.pojo.Dog"></bean>

  1.     <bean id="cat" class="com.ahang.demo.pojo.Cat" ></bean>
  2.     <bean id="cat1" class="com.ahang.demo.pojo.Cat" ></bean> 
  3.     // 可以存在相同Cat，但是id不同，只要存在一个id和User类中setXXX相同即可
  4.     <bean id="dog" class="com.ahang.demo.pojo.Dog"></bean>
  5.     <bean id="dog2" class="com.ahang.demo.pojo.Dog"></bean>
  6.     <bean id="user2" class="com.ahang.demo.pojo.User" autowire="byName">
  7.         <constructor-arg name="age" value="10"></constructor-arg>
  8.         <constructor-arg name="name" value="kaka"></constructor-arg>
  9.         <!--<property name="cat" ref="cat"></property>-->
  10.         <!--<property name="dog" ref="dog"></property>-->
  11.         <property name="age" value="30"></property>
  12.     </bean>

1.8 使用注解装配注入

在配置文件中加入注解支持

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3.        xmlns:context="http://www.springframework.org/schema/context"
  4.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  5.        xsi:schemaLocation="http://www.springframework.org/schema/beans
  6.        http://www.springframework.org/schema/beans/spring-beans.xsd
  8.        http://www.springframework.org/schema/context
  9.        http://www.springframework.org/schema/context/spring-context.xsd ">
  11.     <context:annotation-config></context:annotation-config>
  12. </beans>

在配置中不用手动的添加装配

  1.     <bean id="cat1" class="com.ahang.demo.pojo.Cat"></bean>
  2.     <bean id="dog1" class="com.ahang.demo.pojo.Dog"></bean>
  3.     <bean id="dog2" class="com.ahang.demo.pojo.Dog"></bean>
  5.     <bean id="use" class="com.ahang.demo.pojo.Use">
  6.         <property name="str" value="haha"></property>
  7.     </bean>

在Java文件中,通过在对象上面添加注解或者在set方法上添加注解@Autowired，就可以根据类型自动装配，也可以通过添加@Qualifier("id")指定id名称装配

  1. public class Use {
  2.     @Autowired
  3.     private Cat cat;
  5.     @Autowired
  6.     @Qualifier("dog1")
  7.     private Dog dog;
  9.     private String str;
  10.     ...
  11. }

1.9 基于Java类配置

1.10 代理模式

10.1静态代理

静态代理角色分析

  • 抽象角色 : 一般使用接口或者抽象类来实现—-租房Rent
  • 真实角色 : 被代理的角色—-房主Host
  • 代理角色 : 代理真实角色 ; 代理真实角色后 , 一般会做一些附属的操作——代理中介Proxy
  • 客户 : 使用代理角色来进行一些操作 ——Client
  • 房主Host想出租房Rent,房主进行了出租
  • 但是房主又不想天天带人看房seeHouse，就把钥匙Proxy(Host host)给了中介Proxy
  • 然后中介Proxy就自己又发布了出租告示Rent
  • 这时候有客户Client想要租房，那么就得带着出租告示Rent去找中介Proxy来租房子
  • 中介在出租时就会同时看房seeHouse和出租Rent

Rent租房告示

  1. //抽象角色：租房
  2. public interface Rent {
  3.    public void rent();
  4. }

Host房主

  1. //真实角色: 房东，房东要出租房子
  2. public class Host implements Rent{
  3.    public void rent() {
  4.        System.out.println("房屋出租");
  5.   }
  6. }

中介Proxy

  1. //代理角色：中介
  2. public class Proxy implements Rent {
  4.    private Host host;
  5.    public Proxy() { }
  6.    public Proxy(Host host) {
  7.        this.host = host;
  8.   }
  10.    //租房
  11.    public void rent(){
  12.        seeHouse();
  13.        host.rent();
  14.   }
  15.    //看房
  16.    public void seeHouse(){
  17.        System.out.println("带房客看房");
  18.   }
  19. }

客户Client.java

  1. //客户类，一般客户都会去找代理！
  2. public class Client {
  3.    public static void main(String[] args) {
  4.        //房东要租房
  5.        Host host = new Host();
  6.        //中介帮助房东
  7.        Proxy proxy = new Proxy(host);
  9.        //你去找中介！
  10.        proxy.rent();
  11.   }
  12. }

静态代理的好处:

  • 可以使得我们的真实角色更加纯粹 . 不再去关注一些公共的事情 .
  • 公共的业务由代理来完成 . 实现了业务的分工 ,
  • 公共业务发生扩展时变得更加集中和方便 .

缺点 :

  • 类多了 , 多了代理类 , 工作量变大了 . 开发效率降低 .

我们想要静态代理的好处，又不想要静态代理的缺点，所以 , 就有了动态代理 !

10.2动态代理

  • 动态代理的角色和静态代理的一样 .
  • 动态代理的代理类是动态生成的 . 静态代理的代理类是我们提前写好的
  • 动态代理分为两类 : 一类是基于接口动态代理 , 一类是基于类的动态代理
    • 基于接口的动态代理——JDK动态代理
    • 基于类的动态代理–cglib
    • 现在用的比较多的是 javasist 来生成动态代理 . 百度一下javasist
    • 我们这里使用JDK的原生代码来实现，其余的道理都是一样的！、

JDK的动态代理需要了解两个类

核心 : InvocationHandler 和 Proxy

先定义一个接口Rent和一个实现该接口得Host类

  1. public interface Rent {
  2.     public void rent();
  3. }
  5. public class Host implements Rent {
  6.     @Override
  7.     public void rent() {
  8.         System.out.println("rental hosting");
  9.     }
  10. }

然后定义一个动态代理类ProxyInvocationHandler实现代理Rent

Object invoke(Object proxy, Method method, Object[] args)；
//参数
//proxy - 调用该方法的代理实例
//method -所述方法对应于调用代理实例上的接口方法的实例。方法对象的声明类将是该方法声明的接口，它可以是代理类继承该方法的代理接口的超级接口。
//args -包含的方法调用传递代理实例的参数值的对象的阵列，或null如果接口方法没有参数。原始类型的参数包含在适当的原始包装器类的实例中，例如java.lang.Integer或java.lang.Boolean。

  1. package com.ahang.pojo;
  3. import java.lang.reflect.InvocationHandler;
  4. import java.lang.reflect.Method;
  5. import java.lang.reflect.Proxy;
  7. public class ProxyInvocationHandler implements InvocationHandler {
  8.     private Rent rent;
  10.     public void setRent(Rent rent){
  11.         this.rent = rent;
  12.     }
  14.     public Object getProxy(){
  15.         return Proxy.newProxyInstance(this.getClass().getClassLoader(), rent.getClass().getInterfaces(), this);
  16.     }
  17.     // 处理代理实例，并返回结果
  18.     @Override
  19.     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
  20.         // 动态代理的本质：反射机制实现        
  21.         seeHouse();
  22.         Object invoke = method.invoke(rent, args);
  23.         return invoke;
  24.     }
  26.     public void seeHouse(){
  27.         System.out.println("see house");
  28.     }
  29. }

最后测试Client类

  1.         Host host = new Host();
  2.         ProxyInvocationHandler pih = new ProxyInvocationHandler();
  3.         pih.setRent(host);
  4.         Rent proxy =(Rent) pih.getProxy();
  5.         proxy.rent();

10.3 通用动态类

对于ProxyInvocationHandler

  1. public class ProxyInvocationHandler implements InvocationHandler {
  3.     private Object target;
  5.     public void setRent(Object target) {
  6.         this.target = target;
  7.     }
  9.     public Object getProxy() {
  10.         return Proxy.newProxyInstance(this.getClass().getClassLoader(), target.getClass().getInterfaces(), this);
  11.     }
  13.     // 处理代理实例，并返回结果
  14.     @Override
  15.     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
  16.         // 动态代理的本质：发射机制实现
  17.         log("调用了方法 " + method.getName());
  18.         Object result = method.invoke(target, args);
  19.         return result;
  20.     }
  22.     public void log(String msg) {
  23.         System.out.println(msg);
  24.     }
  25. }

在使用的时候对不同的接口和实现类替换即可

  1.         Host host = new Host();
  2.         ProxyInvocationHandler pih = new ProxyInvocationHandler();
  3.         pih.setTarget(host);
  4.         Rent proxy = (Rent) pih.getProxy();
  5.         proxy.rent();
  1.         UserServiceImpl userService = new UserServiceImpl();
  2.         ProxyInvocationHandler pih = new ProxyInvocationHandler();
  3.         pih.setRent(userService);
  4.         UserService proxy = (UserService) pih.getProxy();
  5.         proxy.add();
  6.         proxy.del();

1.11 AOP

1.11.1 什么是AOP

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

11.2.Aop在Spring中的作用

提供声明式事务；允许用户自定义切面

以下名词需要了解下：

  • 横切关注点：跨越应用程序多个模块的方法或功能。即是，与我们业务逻辑无关的，但是我们需要关注的部分，就是横切关注点。如日志 , 安全 , 缓存 , 事务等等 …
  • 切面（ASPECT）：横切关注点 被模块化 的特殊对象。即，它是一个类。
  • 通知（Advice）：切面必须要完成的工作。即，它是类中的一个方法。
  • 目标（Target）：被通知对象。
  • 代理（Proxy）：向目标对象应用通知之后创建的对象。
  • 切入点（PointCut）：切面通知 执行的 “地点”的定义。
  • 连接点（JointPoint）：与切入点匹配的执行点

Spring - 图3

SpringAOP中，通过Advice定义横切逻辑，Spring中支持5种类型的Advice:

Spring - 图4

即 Aop 在 不改变原有代码的情况下 , 去增加新的功能

1.11.3 具体实现

添加依赖

  1. <!-- https://mvnrepository.com/artifact/org.aspectj/aspectjweaver -->
  2. <dependency>
  3.    <groupId>org.aspectj</groupId>
  4.    <artifactId>aspectjweaver</artifactId>
  5.    <version>1.9.4</version>
  6. </dependency>

execution表达式的使用execution(访问修饰符（可省略） 返回值类型 包.包.类.方法名(参数) )如

<aop:before method="printLog" pointcut="execution(public void com.huge.service.impl.AccountServiceImpl.save())"></aop:before>

符号 类型匹配模式
* 匹配任何数量字符；比如模式 (*,String) 匹配了一个接受两个参数的方法，第一个可以是任意类型，第二个则必须是String类型
.. 匹配任何数量字符的重复，如在类型模式中匹配任何数量子包；而在方法参数模式中匹配任何数量参数，可以使零到多个。
+ 匹配指定类型的子类型；仅能作为后缀放在类型模式后边。
符号 参数匹配模式：
() 匹配了一个不接受任何参数的方法，
(..) 匹配了一个接受任意数量参数的方法（零或者更多）。
(*) 匹配了一个接受一个任何类型的参数的方法。
(*,String) 匹配了一个接受两个参数的方法，第一个可以是任意类型， 第二个则必须是String类型。

示例：

  1. // 省略访问修饰符
  2. void com.huge.service.impl.AccountServiceImpl.save()
  4. // 返回值使用通配符，表示可以返回任意值
  5. * com.huge.service.impl.AccountServiceImpl.save()
  7. // 包名可以使用通配符，表示任意包。但是有几级包，就需要写几个*.
  8. * *.*.*.*.AccountServiceImpl.save()
  10. // 包名可以使用..表示当前包及其子包
  11. * *..AccountServiceImpl.save()
  13. //定义在service 包里,及其子类的任意类的任意方法
  14. * com.huge.service.*.*()
  16. // 类名和方法名都可以使用*来实现通配
  17. * *..*.*()
  19. // 所有包下的service,及其子包
  20. * *.service..*()
  22. // IAccountService 若为接口，则为接口中的任意方法及其所有实现类中的任意,方法；若为类，则为该类及其子类中的任意方法
  23. * com.huge.service.IAccountService+.*()
  25. // 以s开头的任意方法
  26. * com.huge.service.*.s*()
  1. // 基本类型直接写名称 int
  2. * com.huge.service.*.*(int)
  4. // 方法不带参数的
  5. * com.huge.service.*.*()
  7. // 可以使用..表示有无参数均可，有参数可以是任意类型
  8. * com.huge.service.*.*(..)
  10. // 两个参数,第一个是String,第二个任意,三个参数不行
  11. execution(* joke(String,*)))
  13. // 两个参数,第一个String,第二个个数和类型不限
  14. execution(* joke(String,..)))
  16. // 全通配写法：
  17. * *..*.*(..)

1.11.3.1 方法一

首先编写我们的业务接口和实现类

  1. public interface UserService {
  3.    public void add();
  5.    public void delete();
  7.    public void update();
  9.    public void search();
  11. }
  12. public class UserServiceImpl implements UserService{
  14.    @Override
  15.    public void add() {
  16.        System.out.println("增加用户");
  17.   }
  19.    @Override
  20.    public void delete() {
  21.        System.out.println("删除用户");
  22.   }
  24.    @Override
  25.    public void update() {
  26.        System.out.println("更新用户");
  27.   }
  29.    @Override
  30.    public void search() {
  31.        System.out.println("查询用户");
  32.   }
  33. }

然后去写我们的增强类 , 我们编写两个 , 一个前置增强 一个后置增强

  1. public class Log implements MethodBeforeAdvice {
  3.    //method : 要执行的目标对象的方法
  4.    //objects : 被调用的方法的参数
  5.    //Object : 目标对象
  6.    @Override
  7.    public void before(Method method, Object[] objects, Object o) throws Throwable {
  8.        System.out.println( o.getClass().getName() + "的" + method.getName() + "方法被执行了");
  9.   }
  10. }
  11. public class AfterLog implements AfterReturningAdvice {
  12.    //returnValue 返回值
  13.    //method被调用的方法
  14.    //args 被调用的方法的对象的参数
  15.    //target 被调用的目标对象
  16.    @Override
  17.    public void afterReturning(Object returnValue, Method method, Object[] args,Object target) throws Throwable {
  18.        System.out.println("执行了" + target.getClass().getName()
  19.        +"的"+method.getName()+"方法,"
  20.        +"返回值："+returnValue);
  21.   }
  22. }

最后去spring的文件中注册 , 并实现aop切入实现 , 注意导入约束 .

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3.       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.       xmlns:aop="http://www.springframework.org/schema/aop"
  5.       xsi:schemaLocation="http://www.springframework.org/schema/beans
  6.        http://www.springframework.org/schema/beans/spring-beans.xsd
  7.        http://www.springframework.org/schema/aop
  8.        http://www.springframework.org/schema/aop/spring-aop.xsd">
  10.    <!--注册bean-->
  11.    <bean id="userService" class="com.kuang.service.UserServiceImpl"/>
  12.    <bean id="log" class="com.kuang.log.Log"/>
  13.    <bean id="afterLog" class="com.kuang.log.AfterLog"/>
  15.    <!--aop的配置-->
  16.    <aop:config>
  17.        <!--切入点 expression:表达式匹配要执行的方法-->
  18.        <aop:pointcut id="pointcut" expression="execution(* com.kuang.service.UserServiceImpl.*(..))"/>
  19.        <!--执行环绕; advice-ref执行方法 . pointcut-ref切入点-->
  20.        <aop:advisor advice-ref="log" pointcut-ref="pointcut"/>
  21.        <aop:advisor advice-ref="afterLog" pointcut-ref="pointcut"/>
  22.    </aop:config>
  24. </beans>

测试

  1. public class MyTest {
  2.    @Test
  3.    public void test(){
  4.        ApplicationContext context = newClassPathXmlApplicationContext("beans.xml");
  5.        UserService userService = (UserService) context.getBean("userService");
  6.        userService.search();
  7.   }
  8. }

1.11.3.2 第二种方式:自定义类来实现Aop

目标业务类不变依旧是userServiceImpl

第一步 : 写我们自己的一个切入类

  1. public class DiyPointcut {
  3.    public void before(){
  4.        System.out.println("---------方法执行前---------");
  5.   }
  6.    public void after(){
  7.        System.out.println("---------方法执行后---------");
  8.   }
  10. }
  11. 12345678910

去spring中配置

  1. <!--第二种方式自定义实现-->
  2. <!--注册bean-->
  3. <bean id="diy" class="com.kuang.config.DiyPointcut"/>
  5. <!--aop的配置-->
  6. <aop:config>
  7.    <!--第二种方式：使用AOP的标签实现-->
  8.    <aop:aspect ref="diy">
  9.        <aop:pointcut id="diyPonitcut" expression="execution(* com.kuang.service.UserServiceImpl.*(..))"/>
  10.        <aop:before pointcut-ref="diyPonitcut" method="before"/>
  11.        <aop:after pointcut-ref="diyPonitcut" method="after"/>
  12.    </aop:aspect>
  13. </aop:config>
  14. 12345678910111213

测试：

  1. public class MyTest {
  2.    @Test
  3.    public void test(){
  4.        ApplicationContext context = newClassPathXmlApplicationContext("beans.xml");
  5.        UserService userService = (UserService) context.getBean("userService");
  6.        userService.add();
  7.   }
  8. }

1.11.3.3第三种方式:使用注解实现

第一步：编写一个注解实现的增强类

  1. package com.kuang.config;
  3. import org.aspectj.lang.ProceedingJoinPoint;
  4. import org.aspectj.lang.annotation.After;
  5. import org.aspectj.lang.annotation.Around;
  6. import org.aspectj.lang.annotation.Aspect;
  7. import org.aspectj.lang.annotation.Before;
  9. @Aspect
  10. public class AnnotationPointcut {
  11.    @Before("execution(* com.kuang.service.UserServiceImpl.*(..))")
  12.    public void before(){
  13.        System.out.println("---------方法执行前---------");
  14.   }
  16.    @After("execution(* com.kuang.service.UserServiceImpl.*(..))")
  17.    public void after(){
  18.        System.out.println("---------方法执行后---------");
  19.   }
  21.    @Around("execution(* com.kuang.service.UserServiceImpl.*(..))")
  22.    public void around(ProceedingJoinPoint jp) throws Throwable {
  23.        System.out.println("环绕前");
  24.        System.out.println("签名:"+jp.getSignature());
  25.        //执行目标方法proceed
  26.        Object proceed = jp.proceed();
  27.        System.out.println("环绕后");
  28.        System.out.println(proceed);
  29.   }
  30. }

第二步：在Spring配置文件中，注册bean，并增加支持注解的配置

  1. <!--第三种方式:注解实现-->
  2. <bean id="annotationPointcut" class="com.kuang.config.AnnotationPointcut"/>
  3. <aop:aspectj-autoproxy/>

aop:aspectj-autoproxy：说明

通过aop命名空间的<aop:aspectj-autoproxy />声明自动为spring容器中那些配置@aspectJ切面的bean创建代理，织入切面。当然，spring 在内部依旧采用AnnotationAwareAspectJAutoProxyCreator进行自动代理的创建工作，但具体实现的细节已经被<aop:aspectj-autoproxy />隐藏起来了

<aop:aspectj-autoproxy />有一个proxy-target-class属性，默认为false，表示使用jdk动态代理织入增强，当配为<aop:aspectj-autoproxy poxy-target-class="true"/>时，表示使用CGLib动态代理技术织入增强。不过即使proxy-target-class设置为false，如果目标类没有声明接口，则spring将自动使用CGLib动态代理。

2. Spring-MyBatis

MyBatis-Spring 会帮助你将 MyBatis 代码无缝地整合到 Spring 中。

2.2 基本配置(方式一)

  1. 添加一个maven模块，在pom.xml中添加依赖包
  1.     <properties>
  2.         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  3.         <maven.compiler.source>1.7</maven.compiler.source>
  4.         <maven.compiler.target>1.7</maven.compiler.target>
  5.         <spring.version>5.0.5.RELEASE</spring.version>
  6.     </properties>
  8.     <dependency>
  9.         <groupId>org.springframework</groupId>
  10.         <artifactId>spring-jdbc</artifactId>
  11.         <version>${spring.version}</version>
  12.     </dependency>
  13.     <dependency>
  14.         <groupId>org.mybatis</groupId>
  15.         <artifactId>mybatis-spring</artifactId>
  16.         <version>2.0.6</version>
  17.     </dependency>
  18.     <!--添加Lombok来简化操作-->
  19.         <dependency>
  20.             <groupId>org.projectlombok</groupId>
  21.             <artifactId>lombok</artifactId>
  22.             <version>1.18.20</version>
  23.         </dependency>
  1. 在数据库中添加表user
  1. mysql> select * from user;
  2. +----+-------+
  3. | id | name  |
  4. +----+-------+
  5. | 10 | ahang |
  6. | 20 | gaga  |
  7. +----+-------+
  1. 在com.ahang.pojo包下添加User类
  1. package com.ahang.pojo;
  2. @Data
  3. @AllArgsConstructor
  4. @NoArgsConstructor
  5. public class User {
  6.     private int id;
  7.     private String name;
  8. }
  1. 在com.ahang.Dao包下添加三个文件UserDao接口，UserDaoImplJava类，UserDao.xml配置文件
  1. public interface UserDao {
  2.     List<User> getUser();
  3. }
  1. public class UserDaoImpl implements UserDao {
  2.     private SqlSessionTemplate sqlSessionTemplate;
  3.     // 代理模式：代理创建数据库的连接
  4.     public void setSqlSessionTemplate(SqlSessionTemplate sqlSessionTemplate){
  5.         this.sqlSessionTemplate = sqlSessionTemplate;
  6.     }
  8.     public List<User> getUser(){
  9.         UserDao mapper = sqlSessionTemplate.getMapper(UserDao.class);
  10.         return mapper.getUser();
  11.     }
  12. }

UserDao.xml配置文件写入对数据库的具体操作

注意事项：namespace中为接口的全类名

resultType:这里users时对User全类名的别名

  1. <?xml version="1.0" encoding="UTF-8" ?>
  2. <!DOCTYPE mapper
  3.         PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
  4.         "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
  6. <mapper namespace="com.ahang.Dao.UserDao">  
  7.     <select id="getUser" resultType="users">
  8.         select * from user;
  9.     </select>
  10. </mapper>
  1. 最后在resource中添加两个配置文件：mybatis.xml和applicationContext.xml

对于mybatis.xml

  1. <?xml version="1.0" encoding="UTF-8" ?>
  2. <!DOCTYPE configuration
  3.         PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
  4.         "http://mybatis.org/dtd/mybatis-3-config.dtd">
  5. <!--核心配置文件-->
  6. <configuration>
  7.     <!--给实体类起别名-->
  8.     <typeAliases>
  9.         <typeAlias type="com.ahang.pojo.User" alias="users"></typeAlias>
  10.     </typeAliases>
  11. </configuration>

对于Spring的appplicationContext.xml

对于数据库操作配置文件的绑定语句

可以使用具体的配置文件如下：<property name="mapperLocations" value="classpath:com/ahang/Dao/UserDao.xml"></property>

也可以修改为配置文件匹配:classpath*:com/ahang/Dao/*.xml

classpath：只会到你的class路径中查找找文件

classpath*不仅包含class路径，还包括jar文件中(class路径)进行查找，

否则会报错：‘mapperLocations’ was specified but matching resources are not found.

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.        xsi:schemaLocation="http://www.springframework.org/schema/beans
  5.        http://www.springframework.org/schema/beans/spring-beans.xsd">
  7.     <!--配置数据源：数据源有非常多，可以使用第三方的，也可使使用Spring的-->
  8.     <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
  9.         <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
  10.         <property name="url" value="jdbc:mysql://localhost:3306/mybatis"/>
  11.         <property name="username" value="root"/>
  12.         <property name="password" value="6666"/>
  13.     </bean>
  15.     <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
  16.         <property name="dataSource" ref="dataSource"></property>
  17.         <property name="configLocation" value="classpath:mybatis.xml"></property> //mybatis核心配置文件
  18.         <property name="mapperLocations" value="classpath:com/ahang/Dao/UserDao.xml"></property>  // 修改为对应的具体增删改查配置文件，也可以更改为`classpath*:com/ahang/Dao/*.xml`
  19.     </bean>
  21.     <bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
  22.         <constructor-arg index="0" ref="sqlSessionFactory"></constructor-arg>
  23.     </bean>
  25.     <bean id="userDao" class="com.ahang.Dao.UserDaoImpl">  // 修改为对应的实现类
  26.         <property name="sqlSessionTemplate" ref="sqlSession"></property>
  27.     </bean>
  28. </beans>
  1. 测试
    1.  @Test
    2.  public void test1(){
    3.      ClassPathXmlApplicationContext con = new ClassPathXmlApplicationContext("applicationContext.xml");
    4.      UserDao userDao = con.getBean("userDao", UserDao.class); 
    5.      // 这里的第一个参数对应applicationContext.xml配置中的bean的id,而第二个参数对应接口的类
    6.      List<User> user = userDao.getUser();
    7.      for (User e : user) {
    8.          System.out.println(e);
    9.      }
    10.  }

2.3 基本配置（方式二）

在原方式一的基础上修改两处，其余不变

  1. 修改UserDaoImpl,通过继承SqlSessionDaoSupport来简化数据库连接注入
  1. public class UserDaoImpl extends SqlSessionDaoSupport implements UserDao {
  3.     @Override
  4.     public List<User> getUser() {
  5.         return getSqlSession().getMapper(UserDao.class).getUser();
  6.     }
  8.     @Override
  9.     public int insertUser(User user) {
  10.         return getSqlSession().getMapper(UserDao.class).insertUser(user);
  11.     }
  13.     @Override
  14.     public int deleteUser(int id) {
  15.         return getSqlSession().getMapper(UserDao.class).deleteUser(id);
  16.     }
  17. }

  1. 修改applicationContext.xml

    1. <?xml version="1.0" encoding="UTF-8"?>
    2. <beans xmlns="http://www.springframework.org/schema/beans"
    3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    4.     xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    6.  <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
    7.      <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
    8.      <property name="url" value="jdbc:mysql://localhost:3306/mybatis"/>
    9.      <property name="username" value="root"/>
    10.      <property name="password" value="1598"/>
    11.  </bean>
    13.  <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
    14.      <property name="dataSource" ref="dataSource"></property>
    15.      <property name="configLocation" value="classpath:mybatis.xml"></property>
    16.      <property name="mapperLocations" value="classpath:com/ahang/Dao/UserDao.xml"></property>
    17.  </bean>
    19.  <!--将原来的数据库连接过程简化了-->
    20.      <!--<bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">-->
    21.      <!--<constructor-arg index="0" ref="sqlSessionFactory"></constructor-arg>-->
    22.  <!--</bean>-->
    24.  <!--<bean id="userDao" class="com.ahang.Dao.UserDaoImpl">-->
    25.      <!--<property name="sqlSessionTemplate" ref="sqlSession"></property>-->
    26.  <!--</bean>-->
    28.  <bean id="userDao" class="com.ahang.Dao.UserDaoImpl">
    29.      <property name="sqlSessionFactory" ref="sqlSessionFactory"></property>
    30.  </bean>
    31. </beans>

最后在测试

  1.     @Test
  2.     public void test1(){
  3.         ApplicationContext con = new ClassPathXmlApplicationContext("applicationContext.xml");
  4.         UserDao userDao = con.getBean("userDao", UserDao.class);
  5.         List<User> user = userDao.getUser();
  6.         for (User e : user) {
  7.             System.out.println(e);
  8.         }
  9.     }
  11.     @Test
  12.     public void test2(){
  13.         ApplicationContext con = new ClassPathXmlApplicationContext("applicationContext.xml");
  14.         UserDao userDao = con.getBean("userDao", UserDao.class);
  15.         User user = new User(30, "haha");
  16.         int i = userDao.insertUser(user);
  17.         if(i > 0) System.out.println("insert successed!!!");
  18.         else System.out.println("insert fail");
  19.     }
  21.     @Test
  22.     public void test3(){
  23.         ApplicationContext con = new ClassPathXmlApplicationContext("applicationContext.xml");
  24.         UserDao userDao = con.getBean("userDao", UserDao.class);
  25.         int i = userDao.deleteUser(30);
  26.         if(i > 0) System.out.println("delete successed!!!");
  27.         else System.out.println("delete fail");
  28.     }

2.3 配置事务

事务四个属性ACID

  1. 原子性（atomicity）
    事务是原子性操作，由一系列动作组成，事务的原子性确保动作要么全部完成，要么完全不起作用

  2. 一致性（consistency）
    一旦所有事务动作完成，事务就要被提交。数据和资源处于一种满足业务规则的一致性状态中

  3. 隔离性（isolation）
    可能多个事务会同时处理相同的数据，因此每个事务都应该与其他事务隔离开来，防止数据损坏

  4. 持久性（durability）
    事务一旦完成，无论系统发生什么错误，结果都不会受到影响。通常情况下，事务的结果被写到持久化存储器中

这里的事务配置针对的是在实现接口的一个方法中所有操作具有事务性，也就是UserDaoImpl中的一个方法如：public List<User> getUser(),而不是指在测试方法中调用多个方法多种操作的事务。

先对applicationContext.xml中配置

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.        xmlns:tx="http://www.springframework.org/schema/tx"
  5.        xmlns:aop="http://www.springframework.org/schema/aop"
  6.        xsi:schemaLocation="http://www.springframework.org/schema/beans
  7.        http://www.springframework.org/schema/beans/spring-beans.xsd
  8.         http://www.springframework.org/schema/tx
  9.        http://www.springframework.org/schema/tx/spring-tx.xsd
  10.        http://www.springframework.org/schema/aop
  11.        http://www.springframework.org/schema/aop/spring-aop.xsd">
  13.     <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
  14.         <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
  15.         <property name="url" value="jdbc:mysql://localhost:3306/mybatis"/>
  16.         <property name="username" value="root"/>
  17.         <property name="password" value="1598"/>
  18.     </bean>
  20.     <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
  21.         <property name="dataSource" ref="dataSource"></property>
  22.         <property name="configLocation" value="classpath:mybatis.xml"></property>
  23.         <property name="mapperLocations" value="classpath:com/ahang/Dao/UserDao.xml"></property>
  24.     </bean>
  26.     <bean id="userDao" class="com.ahang.Dao.UserDaoImpl">
  27.         <property name="sqlSessionFactory" ref="sqlSessionFactory"></property>
  28.     </bean>
  31.     <!-- 配置声明式事务 -->
  32.     <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
  33.         <property name="dataSource" ref="dataSource"/>
  34.     </bean>
  35.     <!-- 结合aop实现事务的植入-->
  36.     <!-- 配置事务通知 -->
  37.     <tx:advice id="txAdvice" transaction-manager="transactionManager">
  38.         <tx:attributes>
  39.             <!--这里的name就是指实现接口UserDaoImpl下的方法名称-->
  40.             <tx:method name="getUser" propagation="REQUIRED"/>
  41.             <tx:method name="delete" propagation="REQUIRED"/>
  42.             <tx:method name="update" propagation="REQUIRED"/>
  43.             <tx:method name="search" propagation="REQUIRED"/>
  44.             <tx:method name="get" read-only="true"/>
  45.             <tx:method name="*" propagation="REQUIRED"/>
  46.         </tx:attributes>
  47.     </tx:advice>
  48.     <!--配置事务切入，针对Dao包下的所有类的所有方法-->
  49.     <aop:config>
  50.         <aop:pointcut id="txPointCut" expression="execution(* com.ahang.Dao.*.*(..))"/>
  51.         <aop:advisor advice-ref="txAdvice" pointcut-ref="txPointCut"/>
  52.     </aop:config>
  54. </beans>

对接口实现类UserDaoImpl配置,针对第一个方法故意配置出错，在第一个方法中插入语句mapper.insertUser(user)正常，但是mapper.deleteUser(10)有问题

  • 如果测试时没有配置事务，那么执行了getUser()方法后会先插入数据，然后删除数据时出错，但是最后输入还是插入成功了
  • 如果配置了事务，那么会先插入数据，然后删除数据出错，但是由于事务的一致性，会回退至插入数据前，最后插入失败。
  1. public class UserDaoImpl extends SqlSessionDaoSupport implements UserDao {
  3.     @Override
  4.     public List<User> getUser() {
  5.         User user = new User(15, "kaka");
  6.         UserDao mapper = getSqlSession().getMapper(UserDao.class);
  7.         int i = mapper.insertUser(user);
  8.         if(i > 0) System.out.println("insert successed");
  9.         mapper.deleteUser(10);
  10.         return mapper.getUser();
  11.     }
  13.     @Override
  14.     public int insertUser(User user) {
  15.         return getSqlSession().getMapper(UserDao.class).insertUser(user);
  16.     }
  18.     @Override
  19.     public int deleteUser(int id) {
  20.         return getSqlSession().getMapper(UserDao.class).deleteUser(id);
  21.     }
  22. }

在配置UserDao.xml时第三条删除语句时，故意设置数据表user为users，那么在测试会出错

  1. <?xml version="1.0" encoding="UTF-8" ?>
  2. <!DOCTYPE mapper
  3.         PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
  4.         "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
  6. <mapper namespace="com.ahang.Dao.UserDao">
  7.     <select id="getUser" resultType="users">
  8.         select * from user;
  9.     </select>
  11.     <insert id="insertUser" parameterType="users">
  12.         insert into user values( #{id}, #{name} );
  13.     </insert>
  15.     <delete id="deleteUser" parameterType="int">
  16.         delete from users where id=#{id};
  17.     </delete>
  18. </mapper>

具体测试：

  1.     @Test
  2.     public void test1(){
  3.         ApplicationContext con = new ClassPathXmlApplicationContext("applicationContext.xml");
  4.         UserDao userDao = con.getBean("userDao", UserDao.class);
  5.         List<User> user = userDao.getUser();
  6.         for (User e : user) {
  7.             System.out.println(e);
  8.         }
  9.     }

spring事务传播特性：

事务传播行为就是多个事务方法相互调用时，事务如何在这些方法间传播。spring支持7种事务传播行为：

针对的是<tx:method name="*" propagation="REQUIRED"/>中的propagation

  • propagation_requierd：如果当前没有事务，就新建一个事务，如果已存在一个事务中，加入到这个事务中，这是最常见的选择。
  • propagation_supports：支持当前事务，如果没有当前事务，就以非事务方法执行。
  • propagation_mandatory：使用当前事务，如果没有当前事务，就抛出异常。
  • propagation_required_new：新建事务，如果当前存在事务，把当前事务挂起。
  • propagation_not_supported：以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。
  • propagation_never：以非事务方式执行操作，如果当前事务存在则抛出异常。
  • propagation_nested：如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则执行与propagation_required类似的操作

Spring 默认的事务传播行为是 PROPAGATION_REQUIRED，它适合于绝大多数的情况。

假设 ServiveX#methodX() 都工作在事务环境下（即都被 Spring 事务增强了），假设程序中存在如下的调用链：Service1#method1()->Service2#method2()->Service3#method3()，那么这 3 个服务类的 3 个方法通过 Spring 的事务传播机制都工作在同一个事务中。

就好比，我们刚才的几个方法存在调用，所以会被放在一组事务当中！