Spring从认识到细化了解

目录

• Spring的介绍
• 基本运行环境搭建
• IoC
  • 介绍：
  • 示例使用：
  • 使用说明：
  • 使用注意：
  • Bean的实例化方式
  • Bean的作用范围的配置:
  • 补充：
• DI：
  • 属性注入：
  • 补充：
• IoC的注解方式：
  • 依赖包
  • 示例使用
  • bean配置注解介绍：
  • Bean的作用范围的配置
• DI的注解方式
  • 注解方式的属性注入：
• AOP
  • 动态代理技术简单演示
  • AOP相关术语:
  • 通知类型：
  • 使用示例：
  • 使用详解：
    • AOP配置结构
    • 切点：
    • 切面：
    • 切面类：
  • 补充
• AOP的注解方式：
  • 使用示例
    • 开启自动代理
    • 创建切面并定义通知
  • 使用详解：
    • 通知类型：
  • 补充：
• Spring与数据库：
  • JDBC模板使用示例
    • 1. 引入依赖包：
    • 2. 创建数据连接资源（这里以简单数据库连接池为例）
    • 3. 获取Jdbc模板
    • 4.使用jdbc模板操作数据库
  • 使用详解
    • jdbc模板的使用
    • 配置数据库资源
    • 引入外部配置文件：
• 事务管理
  • Spring用于管理事务的几个类
  • 声明式事务管理
    • xml方式【XML的方式有很多种，例如拦截器方式、通知方式，这里介绍通知方式】：
    • 注解式
  • 使用详解：
  • 补充：
• 分模块开发问题：
• 框架整合问题:
  • 解决方案1：
  • 标准解决方案：
• 写在最后

首发日期：2018-08-25

修改日期：

1. 2018-08-29：针对排版问题进行了修改。主要是最前面那部分排版出了问题--一些序号排序失效了。

---

Spring的介绍

• Spring框架是目前java应用最广的框架。
• Spring是一个分层的JavaSE/EE full-stack(一站式) 轻量级开源框架 ,它为每一个层次（表现层、业务层、持久层）都提供了解决方案
  • web层：springMVC【此文不涉及springMVC】
  • service层：IoC,DI,AOP
  • dao层：jdbc模板、Hibernate模板
• spring有几个特点功能【后面将讲这几个功能的好处】：
  • IoC控制反转：将对象的生成权限交给spring,当一个对象需要其他对象时，spring会帮你生成对应的对象。
  • DI：如果使用spring生成的类需要其他类或属性来协助运行，可以使用DI来进行注入。
  • AOP切面编程：通过代理模式，spring可以对某个业务进行强化，而不影响原有的运行。
  • spring提供了与其他框架整合的组件，比如支持Hibernate开发的HibernateTemplate、支持MyBatis开发的SqlSessionTemplate。

---

基本运行环境搭建

本次环境基于spring4.3.4

1.在官网下载：

下载地址：http://repo.spring.io/libs-release-local/org/springframework/spring/

2.解压压缩包：

• 重要文件夹：
  • docs：spring的开发规范文档和api文档
  • libs：spring的依赖包、文档（后缀javadoc）和源码(后缀source)
  • schema：spring的配置文件的约束(xsd)。

3.在libs中提取依赖包：【如果你会maven,那么你可以百度一下尝试使用maven来管理依赖】

• spring核心容器包（spring的所有模块都构建在核心容器之上，所以导入核心容器包构建的就是最基础的运行环境）
  • spring-beans-4.3.4.RELEASE.jar：
  • spring-context-4.3.4.RELEASE.jar：
  • spring-core-4.3.4.RELEASE.jar：
  • spring-expression-4.3.4.RELEASE.jar：
• 日志接口包：commons-logging-1.2.jar【apache提供的，需要自己下载】【必须的】
• 【如果需要扩展日志功能，才需要导入，这里使用log4j】日志包：log4j-1.2.16.jar【apache提供的，需要自己下载】

ps:上面所引入的依赖包仅能实现基本功能，但比如spring的事务管理、aop这些还需要引入其他的包，这些包将在下面的各个模块中讲。

---

由于spring很多时候都是提出解决方案，所以下面介绍spring将根据解决方案来讲。

1. IOC【解决了对象的创建问题】
2. DI 【解决了属性注入问题】
3. AOP【解决了业务对象解耦问题】
4. 模板代码【解决了jdbc代码太繁琐的问题】

---

IoC

介绍：

• IoC全称Inversion of Control(控制反转)。
• IoC就是把对象的生成权限交给spring(原本情况是对象需要我们手动去new，现在声明+配置，spring就可以帮我们把需要的对象自动生成)

示例使用：

1.导入依赖包，IoC只需要基础的依赖包。【这里省去扩展日志依赖包】

2.创建一个用于被spring管理的类（由于仅作演示，所以创建一个简单的实体类）：

package work.domain;
public class User {
	private String name;
	private int age;
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	@Override
	public String toString() {
		return "User [name=" + name + ", age=" + age + "]";
	}
}

3.在src目录下创建applicationContext.xml，在applicationContext.xml中把类配置给spring，让spring管理这个类的创建，：

• applicationContext.xml需要xsd约束，xsd在解压文件夹spring-framework-4.2.4.RELEASE\docs\spring-framework-reference\html\xsd-configuration.html的the beans schema中。【xsd-configuration.html是spring的配置文件的所有xsd配置的参考文件，可以根据不同配置来查找到不同的xsd配置】
• applicationContext.xml需要放置在classpath可搜索路径下，通常可以放在src目录下。

<?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,让spring管理这个类的创建，id用于标识这个类，class是类全限定名 -->
    <bean id="user" class="work.domain.User"></bean>
</beans>

4.创建测试类，获取spring创建的对象：

package work.test;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import work.domain.User;
public class Demo1 {
	@Test
	public void test1() {
		//读取上下文
		ApplicationContext context=new ClassPathXmlApplicationContext("applicationContext.xml");
		//根据id来获取spring实例化对象
		User user = (User) context.getBean("user");
		user.setName("李雷");
		user.setAge(9);
		//能够使用就说明已经被实例化了
		System.out.println(user);
	}
}

上面的示例使用可以说明spring帮我们创建了对象。

使用说明：

• 如何在applicationContext.xml中配置：

  • xsd约束：

    • xsd在解压文件夹spring-framework-4.2.4.RELEASE\docs\spring-framework-reference\html\xsd-configuration.html的the beans schema中。【xsd-configuration.html是spring的配置文件的所有xsd配置的参考文件，可以根据不同配置来查找到不同的xsd配置】

  • bean

    • 属性

      • id:唯一标志性属性，可以用于标识spring管理的类。【在代码中，我们可以根据这个属性来获取对象】
      • name:不是唯一标志性属性，可以用于标识spring管理的类。虽然可以重复，但为了不引起歧义，通常开发中也不能重复。
      • class:需要实例化的类的路径,指明根据id或name获取类对象的时候，获取的是哪个类的。

    • 示例：

      <bean id="user" name="name_user" class="work.domain.User"></bean>
      

• 如何在代码中获取spring创建的对象：

  • 先读取上下文，然后利用上下文的getBean方法获取实例化对象：

    • public void test1() {
      		//读取上下文
      		ApplicationContext context=new ClassPathXmlApplicationContext("applicationContext.xml");
      		//获取方法1：根据id来获取spring实例化对象
      		User user = (User) context.getBean("user");
      		//获取方法2：也可以根据name来获取spring对象
      		User user2 = (User) context.getBean("name_user");
      		user.setName("李雷");
      		user.setAge(9);
      		//能够使用就说明已经被实例化了
      		System.out.println(user);
      		System.out.println(user2);
      	}
      

使用注意：

• 默认情况下，生成的类是单例的，并且spring一开启就会实例化对象。也就是说，默认情况下，在不同代码中多次使用一个类的对象都是同一个对象。【可以通过配置来改变，bean的scope属性可以配置对象是单例的还是多例的】

• applicationContext.xml的文件名是可以改变的（但默认获取的时候文件名就是这个），如果你的文件名不是这个，创建工厂的时候需要传入其他的文件名：new ClassPathXmlApplicationContext("文件名");。

• spring创建类对象的本质是通过工厂来获取类对象。

  • 老版本的工厂类:BeanFactory
    • BeanFactory：调用getBean的时候，才会生成类的实例。
  • 新版本的工厂类:ApplicationContext【现在都用这个】
    • ApplicationContext：加载配置文件的时候，就会将Spring管理的类都实例化
    • ApplicationContext常见实现类主要有两个：
      • ClassPathXmlApplicationContext ：加载类路径下的配置文件
      • FileSystemXmlApplicationContext ：加载文件系统下的配置文件
      • 还有一些例如XmlWebApplicationContext,AnnotationConfigApplicationContext,AnnotationConfigWebApplicationContext这些虽然也有用，但这里不涉及，所以不讲。

• 由于本质是工厂模式，所以它是有利于进行接口化编程的，我们可以在配置文件中很方便地更改它的实现类。比如：

  • 修改前：（获取bean的时候通过id获取，存储的类型是接口，那么可以很方便地更改它的实现类）

    <bean id="calc" class="work.domain.Calc">
    

  • 修改后（只需要修改配置文件，就能给接口提供不同的实现类）：

    <!-- 假如功能升级了！给它一个新的实现类。 -->
    <bean id="calc" class="work.domain.SuperCalc">
    

Bean的实例化方式

• spring创建的对象也可以称为bean

• spring帮我们实例化的有几种方式，默认是调用无参构造方法来实例化。

  • 默认无参实例化（所以如果没有无参构造函数，将报错）：

    • <bean id="user" name="name_user" class="work.domain.User"></bean>
      

  • 注入构造方法参数，带参数实例化：（这个涉及DI内容，具体后面讲）

    •     <bean id="user" name="name_user" class="work.domain.User">
              <!-- 向 User(String name, int age)构造方法注入参数，然后实例化  -->
              <constructor-arg name="name" value="lilei" ></constructor-arg>
              <constructor-arg name="age" value="18" ></constructor-arg>
          </bean>
      

  • 调用静态实例工厂方法得到对象：

    • 静态工厂编写

      public class MyBeanFactory {
          	public static User createUser() {
          		return new User();
          	}
      }
      

    • applicationContext.xml编写

      <!-- class是工厂类路径，factory-method是静态获取对象的方法 -->
           <bean id="factory_user"  class="work.factory.MyBeanFactory" factory-method="createUser"></bean>
      

  • 调用非静态实例工厂方法得到对象：

    • 工厂编写

      public class MyBeanFactory {
          	public  User createU() {
          		return new User();
          	}
      }
      

    • applicationContext.xml编写

        <!-- 先实例化工厂 -->
         <bean id="myBeanFactory" class="work.factory.MyBeanFactory" ></bean>
         <!-- 利用工厂对象来获取对象,factory-bean是上面工厂bean的id，factory-method是获取对象的方法名  -->
         <bean id="user" factory-bean="myBeanFactory"  factory-method="createU"></bean>
      

Bean的作用范围的配置:

在上面说过了，默认情况下，Bean的创建是单例的，但是可以通过bean中的scope属性来配置Bean的创建方式（同时也有作用范围）。

• scope
  • 取值：
    • singleton：单例模式，只生成一个对象。
    • prototype：多例的，每次通过上下文获取都是获取一个新的对象。
    • request：一次请求创建一个实例。
    • session：一次会话创建一个实例。
  • 示例：

    • <bean id="userAction" class="work.action.UserAction" scope="prototype"></bean>
      

补充：

• 这里没有讲述基于p名称空间的属性注入和spEL的属性注入【其实挺重要的，但讲细的话太占空间】，有兴趣的可以自查。

---

DI：

• 依赖注入。依赖是指某些功能可能依赖某些属性，只有有了对应的属性才能执行功能。当使用了IOC之后，可能需要把某些属性（也包括对象）注入给生成的对象，那么可以使用DI。
  • 比如你利用spring帮你新建了一个类，但是这个类需要另一个类来协助运行（好比CD机需要CD，没有CD的CD机用起来没意思），那么这时候怎么把另一个类传给这个类呢？DI就是解决这类问题的。
• DI是spring的一个很好的属性注入解决方案，如果你不使用DI的话，你可能需要使用接口或者通过继承类来完成属性注入。
  • 其他方案探究：让这个类管理他的协助类，在构造函数中传参进来或者调用某些方法设置属性，但这会造成代码耦合性很高以及难以测试（因为要确保使用协助类之前，协助类要被初始化了）。
• 使用DI之后，当通过IoC来创建对象的时候(此时，依赖对象和被依赖对象都创建了)，IoC也会同时处理依赖管理，帮助我们把协助类注入到目标类中（有构造器注入、set注入等方法）。
• 像IoC一样，依赖注入也是有利于接口化编程的，当我们注入的属性是一个对象时，如果使用接口名来管理注入，那么我们可以很轻易地更改注入的接口实现类。

属性注入：

属性注入是创建对象的时候，为对象注入属性。

• 构造方法方式注入：要求类中必须要有与注入参数对应的构造方法

  • 类的编写：

    package work.domain;
    public class User {
    	private String name;
    	private int age;
    	private Account account;
    	public User() {
    		super();
    	}
    	public User(String name, int age) {
    		super();
    		this.name = name;
    		this.age = age;
    	}
    	public String getName() {
    		return name;
    	}
    	public void setName(String name) {
    		this.name = name;
    	}
    	public int getAge() {
    		return age;
    	}
    	public void setAge(int age) {
    		this.age = age;
    	}
    	public Account getAccount() {
    		return account;
    	}
    	public void setAccount(Account account) {
    		this.account = account;
    	}
    }
    

  • applicationContext.xml的编写：

    <bean id="account" class="work.domain.Account"></bean>
        <bean id="user"  class="work.domain.User">
        	 <!--  向 User(String name, int age)构造方法注入参数，然后实例化  -->
        	 <!-- name是属性名，value是属性值，如果属性需要一个类对象，使用ref来注入，值为bean中的id或name -->
        	<constructor-arg name="name" value="lilei" ></constructor-arg>
        	<constructor-arg name="age" value="18" ></constructor-arg>
        	<constructor-arg name="account" ref="account" ></constructor-arg>
     </bean>
    

• set方法方式,要求类中必须提供注入参数对应的setter方法

  • 类的编写：

    package work.domain;
    public class User {
    	private String name;
    	private int age;
    	private Account account;
    	public User() {
    		super();
    	}
    	public User(String name, int age) {
    		super();
    		this.name = name;
    		this.age = age;
    	}
    	public String getName() {
    		return name;
    	}
    	public void setName(String name) {
    		this.name = name;
    	}
    	public int getAge() {
    		return age;
    	}
    	public void setAge(int age) {
    		this.age = age;
    	}
    	public Account getAccount() {
    		return account;
    	}
    	public void setAccount(Account account) {
    		this.account = account;
    	}
    }
    

  • applicationContext.xml的编写：

    	<bean id="account" class="work.domain.Account"></bean>
        <bean id="user"  class="work.domain.User">
        	 <!--  使用setter来注入参数  -->
        	 <!-- name是属性名，value是属性值，如果属性需要一个类对象，使用ref来注入，值为bean中的id或name -->
        	<property name="name" value="织女"></property>
        	<property name="age" value="1000"></property>
        	<property name="account"  ref="account"></property>
        </bean>
    

• 上面提到了基本类型属性和对象类型属性的注入，由于集合类型多,所以留到这里再讲:

  • 类的编写(包含了数组,list,set,map):需要提供setter

    • package work.domain;
      
      import java.util.List;
      import java.util.Map;
      import java.util.Set;
      
      public class CollectionBean {
      	private String[] array;
      	private List list;
      	private Set set;
      	private Map map;
      	public void setArray(String[] array) {
      		this.array = array;
      	}
      	public void setList(List list) {
      		this.list = list;
      	}
      	public void setSet(Set set) {
      		this.set = set;
      	}
      	public void setMap(Map map) {
      		this.map = map;
      	}
      	public String[] getArray() {
      		return array;
      	}
      	public List getList() {
      		return list;
      	}
      	public Set getSet() {
      		return set;
      	}
      	public Map getMap() {
      		return map;
      	}
      }
      

  • applicationContext.xml编写

    • <bean id="collecionBean" class="work.domain.CollectionBean" >
         	<!--数组类型的属性注入，name是属性名，数组的元素使用list中的value包裹，也可以使用array中的value包裹;注入的是对象的时候，可以使用ref包裹 -->
         	<property name="array">
         		<list>
         			<value>牛郎</value>
         			<value>织女</value>
         		</list>
         	</property>
         	<!-- List类型的属性注入，name是属性名，数组的元素使用list中的value包裹 -->
         	<property name="list">
         		<list>
         			<value>二郎神</value>
         			<value>华山</value>
         		</list>
         	</property>
         	<!-- Set类型的属性注入，name是属性名，数组的元素使用set中的value包裹 -->
         	<property name="set">
         		<set>
         			<value>孙悟空</value>
         			<value>白骨精</value>
         		</set>
         	</property>
         	<!-- Map类型的属性注入，name是属性名，数组的元素使用entry包裹，如果注入的是对象，那么可以使用key-ref和value-ref来注入 -->
         	<property name="map">
         		<map>
         			<entry key="爱" value="520" ></entry>
         			<entry key="一生一世" value="1314" ></entry>
         		</map>
         	</property>
         </bean>
      

• 注入其他bean对象：上面的都是一个类对象中的普通属性，但没有说到注入一个其他bean对象时怎么注入。

  •   <bean id="productDao" class="cn.dao.ProductDao"></bean>
      <bean id="productService" class="cn.service.ProductService">
      	<!-- 注入其他bean对象，使用ref，ref是bean的id -->
      	<property name="productDao" ref="productDao"/>
      </bean>
    

• 属性注入方式还有一种接口注入，接口注入通常使用于资源来自于外界的情况，比如当数据库连接资源来自于外部的时候就可以使用接口注入。这个知识点这里不讲，有兴趣自查。

补充：

• 还可以从Properties中读取数据来进行注入 ，这里不讲，有兴趣的可以自查【在事务管理中讲述了可以利用一种方式来读取】。

        <context:property-placeholder location="classpath:jdbc.properties" />
        <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        	<!-- 引用properties文件中的数据 -->
            <property name="driverClass" value="${jdbc.driverClass}" ></property>
            <property name="jdbcUrl" value="${jdbc.url}" ></property>
            <property name="user" value="${jdbc.username}" ></property>
            <property name="password" value="${jdbc.password}" ></property>
        </bean>
  ```
  

---

IoC的注解方式：

• 现在已经更趋向于使用注解来配置IOC了。
• 注解可以减少XML配置。
• 但XML的配置方式也有好处：
  • 统一管理、方便维护
  • 可以配置第三方组件

依赖包

• 除了导入基础的核心容器包，还需要spring-aop-4.3.4.RELEASE.jar

示例使用

• applicationContext.xml配置

  • 导入xsd:

    • 在原来的xsd的基础上，加上context的，context在spring-framework-4.3.4.RELEASE/docs/spring-framework-reference/html/xsd-configuration.html的the context schema中

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

        </beans>

• applicationContext.xml中配置组件扫描：

  • 在xml配置context:component-scan这个标签后，spring可以自动去扫描base-pack下面或者子包下面的java文件，如果扫描到有@Component @Controller@Service等这些注解的类，则把这些类注册为bean 。如果有多个包，可以使用,分隔。

  	<!-- 配置组件扫描，base-package是扫描的包，扫描的包下类的相关注解会把类注册成bean -->
  	<context:component-scan base-package="work.domain"></context:component-scan>
  

• 给类加上注解@Component("person")：

package work.domain;

import org.springframework.stereotype.Component;
//添加注解
@Component("person")  //相当于在applicationContext.xml中配置<bean id="person" class="work.domain.Person" />
public class Person {
	private String name;
	private int age;
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
}

上面配置完毕，就可以像XML配置方式一样使用Context上下文获取对象了。

bean配置注解介绍：

• @Component：修饰一个类，代表这个类的对象交给spring去生成

  • @Component("person") //相当于在applicationContext.xml中配置<bean id="person" class="....." />
  • @Component的衍生注解,下面三个注解与@Component的功能一样，不过多了层次的意义，可以使用下面的来表明是什么层次的bean。【听说后面版本下面的三个注解加了一些功能，没去了解】
    • @Controller：web层
    • @Service：service层
    • @Responsitory:dao层

Bean的作用范围的配置

在类上使用@Scope注解指定Bean的作用范围。

• @Scope

  • 属性：

    • singleton：单例模式
    • prototype：多例
    • request：存入到request中
    • session：存入到session中

  • 示例：

    • @Component
      @Scope("prototype")
      

---

DI的注解方式

注解方式的属性注入：

对于类的注解，需要开启IoC上面的组件扫描【组件扫描的时候也会扫描到用于属性注入的注解】；如果仅仅使用注解来进行属性注入，则不需要组件扫描，直接使用下面的。【很多时候，我们可能会使用xml来配置bean,注解来配置属性注入】

<!--只会扫描属性上的注解-->
<context:annotation-config></context:annotation-config>

• 对于普通类型的属性：

  • @value("属性值")
  • 例如：

• 对于对象类型的属性：

  • @Autowired：根据类名去进行注入
    • 歧义性问题：部分时候都是采用接口化编程，使得一个接口可能有多个实现类，那么需要使用告诉spring使用哪个类。
      • @Primary用在接口的实现类中，表明使用@Autowired来进行注入的时候，如果有多个实现类，那么优先使用这个。
      • @Qualifier与@Autowired一起使用，@Qualifier("xxx")的时候，代表使用xxx实现类注入。
  • @Resource（name = "...."） ：根据id去进行注入（对于注解式的，@Component("xxx")中的xxx就是id）【由于@Autowired有歧义问题，所以通常使用@Resource】

• 对于集合类型的属性，我觉得使用注解就不太清晰了。有兴趣的可以自查，它通常使用@Resource来注入。

• DI注解的使用：如果有setter方法，就把注解添加到set方法上；如果没有，那么添加到属性上；两者都有的时候建议添加到set方法上。

---

AOP

• AOP全称Aspect Oriented Programming （面向切面编程）。
• AOP可以做到在不改变程序原代码的情况下对程序进行增强。
  • 诸如日志、事务管理和安全这种服务经常用来配合业务，如果把这些服务的代码写在各个业务中，当需要修改，你需要修改很多地方，除此还会可能造成业务逻辑混乱。（业务混乱是指影响了业务实体，增加了不必要的概念，好比某个业务的运行需要先初始化日志对象，这样就影响了本来业务的执行。）
  • AOP通过声明把这类服务应用到它们需要影响的业务中（不需要改变业务代码）。
• AOP有点类似于拦截器，拦截器是发起请求之后先到拦截器，再到业务逻辑，出去再经过拦截器，拦截器也是脱离了业务逻辑的。
• 在声明之后，AOP会对目标方法所在的类生成一个代理类对象，这个代理类对象中的目标方法是使用AOP加强过了的。
• 以事务的理念来谈一下AOP：通常来说，我们的增删改操作需要事务的帮助，我们可能需要在各处代码中都写下开启事务的代码。这样代码可能就很赘余了，而且事务的代码变成了必须品。如果使用了AOP，那么调用方法之前，AOP帮你开启事务，这样你就不必在代码里写下开启事务了。

动态代理技术简单演示

spring AOP的底层实现技术就是动态代理技术。为了帮助了解AOP底层原理，这里基于jdk动态代理对动态代理技术简单演示。【仅作理解，不写太严谨的代码】

1.创建一个接口

      public interface SchoolPerson {
      	public void read();
      	public void save();
      }

2.定义一个实现接口的类

     package work.domain;
     public class Student implements SchoolPerson {
     	public void read() {
     		System.out.println("read");
     	}
     	public void save() {
     		System.out.println("save");
     	}
     }

3.创建一个代理器，实现InvocationHandler接口，创建createProxy方法--负责获取代理对象，创建invoke方法--负责对方法进行增强。

      package work.utils;

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

      import work.domain.SchoolPerson;

      public class JDKProxy implements InvocationHandler {
      	//被代理的对象
      	private SchoolPerson sp;
      	//把对象传给代理器，让它生成一个代理对象
      	public JDKProxy(SchoolPerson sp) {
      		this.sp = sp;
      	}
      	//生成代理对象，并绑定代理方法
      	public SchoolPerson createProxy() {
      		SchoolPerson proxyStu = (SchoolPerson) Proxy.newProxyInstance(sp.getClass().getClassLoader(), sp.getClass().getInterfaces(), this);
      		return proxyStu;
      	}
      	@Override
      	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
      		if(method.getName().equals("save")) {
      			System.out.println("增强功能执行---。");
      			return  method.invoke(sp, args);
      		}
      		return method.invoke(sp, args);
      	}
      }

4.测试：

      package work.test;
      import org.junit.Test;
      import work.domain.SchoolPerson;
      import work.domain.Student;
      import work.utils.JDKProxy;

      public class Demo2 {
      	@Test
      	public void test1() {
      		SchoolPerson sp=new Student();
      		JDKProxy proxy = new JDKProxy(sp);
      		SchoolPerson createProxy = proxy.createProxy();
              //调用方法，测试是否被增强
      		createProxy.save();
      		/*测试结果：
      		 * 增强功能执行---。
      			save
      		 */
      	}
      }

上述例子可以看出，student对象原有的save方法被增强了，而且我们并没有修改过student的代码。

AOP相关术语:

• Aspect：切面,切面是指贯穿多个业务的环境。比如拦截器就贯穿了业务逻辑。

  • 

• Advice：通知、增强。是指增强的方法，根据逻辑和顺序可以区分成多个通知类型（下面讲）

• Joinpoint：连接点，可拦截点，判断一个点是否是切点。

• Pointcut：切点，被切面拦截的点就是一个拦截点。

• Target：目标，被增强的对象

• Weaving：织入，生成代理对象的过程

• Proxy：代理对象

通知类型：

• 前置通知before：在目标方法之前执行通知里面的操作

• 正常返回通知after-returning：目标方法正常执行完成之后，进行通知里面的操作

• 环绕通知around：目标方法执行之前和目标方法执行完成之后，进行通知里面的操作

• 异常抛出通知after-throw：发生异常时，进行通知里面的操作

• 后置（最终）通知after：运行完成时，无论是否发生异常，都进行通知里面的操作

• 五种通知的执行顺序为： 前置通知→环绕通知→后置通知→正常返回通知/异常抛出通知

使用示例：

• 导入依赖包：

  • 基本包:
  • AOP依赖包
    • 两个spring自带的：
      • spring-aop-4.3.4.RELEASE.jar
      • spring-aspects-4.3.4.RELEASE.jar
    • 三个需要下载的：
      • aopalliance-1.0.jar
      • aspectjrt-1.7.2.jar
      • aspectjweaver-1.7.2.jar

• 编写一个接口：

  • package work.dao;
    public interface StudentDao {
    	public void read();
    	public void save();
    }
    

• 编写一个接口的实现类：

  • package work.dao.impl;
    import work.dao.StudentDao;
    public class StudenDaoImpl implements StudentDao {
    	@Override
    	public void read() {
    		System.out.println("read");
    	}
    	@Override
    	public void save() {
    		System.out.println("save");
    	}
    }
    

• 编写一个切面类,用于调用切面类的方法对目标对象增强：

  • package work.utils;
    
    import org.aspectj.lang.ProceedingJoinPoint;
    
    public class MyAspect {
    	public void before() {
    		System.out.println("before。。。");
    	}
    	public void after() {
    		System.out.println("after。。。");
    	}
    	public void afterReturn() {
    		System.out.println("afterReturn。。。");
    	}
    	public void around(ProceedingJoinPoint pj) throws Throwable {
    		System.out.println("around in。。。");
    		pj.proceed();
    		System.out.println("around out。。。");
    	}
    	public void afterThrow() {
    		System.out.println("afterThrow。。。");
    	}
    }
    

• 配置applicationContext.xml文件

  • 导入xsd，他在xsd-configuration.html的the aop schema中（如果你有其他功能，注意进行保留，在原来的基础上增加aop的xsd）

    • <?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">
      </beans>
      

  • 把接口实现类交给Spring去管理

    • <!-- 把目标实现类交给spring管理 -->
         <bean id="studentDao" class="work.dao.impl.StudenDaoImpl"></bean>
      

• 把切面交给Spring去管理

  • <!-- 把切面类交给spring管理 -->
      <bean id="myAspect" class="work.utils.MyAspect"></bean>
    

• 配置AOP

  •     <!-- 配置AOP -->
        <aop:config>
            	<!-- 配置切点，配置哪些类的哪些方法需要增强 -->
            	<aop:pointcut expression="execution(* work.dao.impl.StudenDaoImpl.*(..))" id="pointcut1"/>
            	<!-- 配置切面，配置通知与切点的关系 -->
            	<aop:aspect ref="myAspect">
            		<aop:before method="before" pointcut-ref="pointcut1"/>
            		<aop:after method="after"  pointcut-ref="pointcut1" />
            		<aop:after-returning method="afterReturn"  pointcut-ref="pointcut1"  />
            		<aop:around method="around"  pointcut-ref="pointcut1" />
            	</aop:aspect>
        </aop:config>
    

• 编写测试方法：

  • //测试AOP
    	@Test
    	public void test2() {
    		ApplicationContext context=new ClassPathXmlApplicationContext("applicationContext.xml");
    		StudentDao studentDao = (StudentDao) context.getBean("studentDao");
    		studentDao.read();
    	}
    

使用详解：

AOP配置结构

•     <!-- aop:config是配置AOP的顶层标签 -->
      <aop:config>
          	<!-- aop:pointcut配置切点，配置哪些类的哪些方法需要增强 -->
          	<aop:pointcut expression="..." id="..."/>
          	<!-- aop:aspect配置切面 -->
          	<aop:aspect ref="myAspect"><!-- ref引用的是切面类的bean -->
                  <!--配置对于切点怎么增强 -->
          		<aop:before method="..." pointcut-ref="..."/>
          		<aop:after method="..."  pointcut-ref="..." />
          		<aop:after-returning method="..."  pointcut-ref="..."  />
          		<aop:around method="..."  pointcut-ref="..." />
          	</aop:aspect>
      </aop:config>
  

切点：

在xml中，用<aop:pointcut expression="..." id="..."/>来声明一个切点，使得增强可以针对一个切点来进行。其中id是用于标识一个切点的；expression是用来表示切点的位置的，表示增强用于哪个类的哪个方法上。

• expression的写法
  • 语法格式：expression="execution(访问修饰符 返回类型 包名.类名.方法名(参数) )"
  • execution()代表方法执行时触发
  • 访问修饰符（public之类的）是可选的。
  • 返回类型是必需的，可以使用*来代表任意返回值类型的
  • 包名.类名 ，可以使用*来代表任意包任意类,但注意要符合层次比如work.demo.dao可以用*.*.*代替
  • 方法名，可以使用*来代表任意方法
  • 参数中填写的是参数类型，（..）表示任意个数任意类型参数，（.）表示有一个参数 ，（*,String）表示第一个参数为任意，第二个为String类型
• expression的示例：
  • public void com.domain.Custom.save(..)、
  • * *.*.*.save(..)
• expression的语法类似于正则表达式，这里仅仅讲了一些基础的，足够你基本使用的。如果想了解更多，可以自查。

切面：

在xml中，用<aop:aspect ref="..."></aop:aspect>来声明一个切面，声明切面怎么对切点增强。

• aop:aspect 的属性：
  • ref用来引用spring管理的切面类的bean。
  • order:用与多个切面处理同一个切点的时候，决定它们之间的顺序。没有的时候，多个切面处理一个切点的时候，顺序是乱的，如果想有顺序的，需要使用order。
• 通知类型【aop:aspect 下使用各种通知类型来定义什么时候对切点进行增强】
  • 前置通知：<aop:before method="调用的方法" pointcut-ref="切点id"/>
  • 后置通知：<aop:after method="调用的方法" pointcut-ref="切点id" />
  • 环绕通知：<aop:around method="调用的方法" pointcut-ref="切点id" />
  • 返回通知：<aop:after-returning method="调用的方法" pointcut-ref="切点id" />
  • 异常抛出通知：<aop:after-throwing method="调用的方法" pointcut-ref="切点id" />

切面类：

切面类是用来对切点增强的，在xml中配置的通知类型的method就是切面类中的方法名。

通知类型有不同的作用，所以切面类也需要规范写法。

• 前置通知before可以用来获取切点信息，在方法中需要定义一个形参JoinPoint pj,这个形参会自动传入。

  • public void before(JoinPoint jp) {
    		System.out.println("before。。。"+jp);
    	}
    

• 正常通知after-returning既可以用来获取切点信息，也可以获取目标方法的返回值。如果在目标方法中进行了返回，可以在xml中使用returning属性来指明存储到哪个变量中。

  • xml中：<aop:after-returning method="afterReturn" pointcut-ref="pointcut1" returning="result" />【returning中的值是通知中的形参的名字。通知中通过形参来获取目标方法的返回值】
  • 
  • 当获取返回值的时候要注意环绕通知的使用，获取返回值需要在环绕通知中使用return pj.proceed();

• 环绕通知可以用来拦截方法，所以它需要“放行”才能正常环绕，在方法中需要定义一个形参ProceedingJoinPoint pj（会自动传入值）,然后pj.proceed()就可以放行了。

  • public void around(ProceedingJoinPoint pj) throws Throwable {
    		System.out.println("around in。。。");
    		Object obj=pj.proceed();
    		System.out.println("around out。。。");
            return obj;
    	}
    

• 异常抛出通知可以获取目标方法的异常信息

  • 

补充

• 还可以对通知类型传入参数，这样在切面的类的方法中可以根据参数来执行。这里不讲，有兴趣自查。

---

AOP的注解方式：

• AOP的注解方式不需要引入额外的其他依赖包，只需要引入前面的核心容器包和aop包即可。

使用示例

开启自动代理

• 在xml中开启AOP自动代理【其实也可以全注解配置--可以创建一个java类来进行配置，但这里不讲。】

  • <aop:aspectj-autoproxy></aop:aspectj-autoproxy><!-- 这个标签与bean同级，不要配错了。 -->
    

创建切面并定义通知

使用@Aspect来注解一个类，Spring就会认为这个类是一个切面类。使用@Before来注解一个方法，Spring就会把这个方法当成切面类的前置通知。

package work.utils;

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
//注解，标明这个是一个切面类
@Aspect
public class MyAspect {
	//前置通知
	@Before(value="execution(* work.dao.impl.StudenDaoImpl.*(..))")
	public void before() {
		System.out.println("before。。。");
	}
}

这样之后，获取的对象就是被AOP前置增强了的。

使用详解：

通知类型：

• 前置通知：@Before
• 正常返回通知：@AfterReturning
• 环绕通知：@Around
• 异常抛出通知：@AfterThrowing
• 后置通知：@After

### 切点：

• 当在通知中同时声明一个切点的时候，使用的是切点表达式，可以参考上面XML中的切点表达式的写法。

• 除了切点表达式，还可以使用注解声明切点，然后在通知是使用切点名即可。

  • 使用@Pointcut注解来声明切点，它使用在方法上，这个方法是没有意义的，可以为空方法，方法名相当于切点的ID。Pointcut的值为切点表达式。可以在通知中使用 类名.方法名() 来指向一个切点。

    • package work.utils;
      
      import org.aspectj.lang.annotation.Aspect;
      import org.aspectj.lang.annotation.Before;
      import org.aspectj.lang.annotation.Pointcut;
      //注解，标明这个是一个切面类
      @Aspect
      public class MyAspect {
      	@Pointcut(value="execution(* work.dao.impl.StudenDaoImpl.*(..))")
      	public void pointcut1() {}
      //	@Before(value="execution(* work.dao.impl.StudenDaoImpl.*(..))")
      	@Before(value="MyAspect.pointcut1()")
      	public void before() {
      		System.out.println("before。。。");
      	}
      }
      

补充：

• 多个切面对一个切点增强时，如果想要按顺序处理，可以在切面类上使用注解@Order,Order的值影响它们的顺序。

---

Spring与数据库：

• 对于非框架式的JDBC数据库编程，Spring提供jdbc模板来简化jdbc的使用
• 对于Hibernate框架，Spring提供了Hibernate模板来简化Spring整合Hibernate时对Hibernate的操作。
• 对于MyBatis框架，Spring没有提供很好的MyBatis模板，通常使用MyBatis社区开发了MyBatis-Spring整合包，其中SqlSessionTemplate就相当于MyBatis模板。
• 对于Hibernate和MyBatis框架，这里不涉及框架整合知识，所以这里只介绍一下jdbc模板。[整合框架的内容迟一点写]

JDBC模板使用示例

• JDBC模板可以说是Spring进行jdbc的封装，它的使用就像DbUtils。

1. 引入依赖包：

• spring核心容器基本包
• 数据库驱动包：mysql-connector-java-5.1.7-bin.jar
• Spring的JDBC包：spring-jdbc-4.3.4.RELEASE.jar
• Spring的事务包（需要事务时才导入）：spring-tx-4.3.4.RELEASE.jar

2. 创建数据连接资源（这里以简单数据库连接池为例）

		SimpleDriverDataSource dataSource = new SimpleDriverDataSource();
		dataSource.setDriverClass(com.mysql.jdbc.Driver.class);
		dataSource.setUrl("jdbc:mysql://localhost:3306/spring");
		dataSource.setUsername("root");
		dataSource.setPassword("123456");

3. 获取Jdbc模板

JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);

4.使用jdbc模板操作数据库

这里以保存数据为例：

@Test
	public void test3() {
		//创建简单连接池
		SimpleDriverDataSource dataSource = new SimpleDriverDataSource();
		dataSource.setDriverClass(com.mysql.jdbc.Driver.class);
		dataSource.setUrl("jdbc:mysql://localhost:3306/spring");
		dataSource.setUsername("root");
		dataSource.setPassword("123456");
		//获取jdbc模板
		JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);
		//操作数据库
		jdbcTemplate.update("insert into userinfo values(null,?,?) ","李雷",20);
	}

使用详解

jdbc模板的使用

• 新增、修改、删除：jdbc模板的的增删改主要是通过update方法来与数据库交互的。

  • public void test4() {
    		//获取jdbc模板
    		ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
    		JdbcTemplate jdbcTemplate = (JdbcTemplate) context.getBean("jdbcTempldate");
    		//操作数据库
    		jdbcTemplate.update("insert into userinfo values(null,?,?) ","韩雷",20);
    		jdbcTemplate.update("delete from userinfo where id=3");
    		jdbcTemplate.update("update userinfo set name='地雷' where id=?", 4);
    	}
    

• 查询：

  • 查询主要依靠query方法和queryForObject方法，他们的使用与DbUtils中的查询使用类似，都是需要传入一个结果集处理对象

  • 下面只给出一个小例子(这个例子是使用了spring注入生成template的结果，配置方法在下下份代码中)，基本跟DbUtils的用法没什么区别，所以你也可以自己把它封装到对象中

    	@Test
    	public void test5() {
    		//获取jdbc模板
    		ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
    		JdbcTemplate jdbcTemplate = (JdbcTemplate) context.getBean("jdbcTempldate");
    		//操作数据库
    		jdbcTemplate.query("select * from userinfo", new RowMapper() {
    			@Override
    			public Object mapRow(ResultSet rs, int rowNum) throws SQLException {
    				String name=rs.getString("name");
    				int age=rs.getInt("age");
    				System.out.println(name+":"+age);
    				return null;
    			}
    		});
    	}
    

  • queryForObject可以用来获取单个数据，也可以用来像query一样用结果集处理对象来处理数据

    @Test
    	public void test5() {
    		//获取jdbc模板
    		ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
    		JdbcTemplate jdbcTemplate = (JdbcTemplate) context.getBean("jdbcTempldate");
    
    		Long num = jdbcTemplate.queryForObject("select count(*) from userinfo",Long.class);
    		System.out.println(num);
    	}
    

• 上面讲了jdbc模板的使用涉及spring管理jdbc模板，了jdbc模板也可以交给spring去管理。

  • <!-- class里面写dbcp的类，使用dataSource获取的时候就是dbcp连接池对象 -->
    	<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">
    		<!-- 由于里面有很多setter，可以直接属性注入 -->
    		<property name="driverClassName" value="com.mysql.jdbc.Driver" ></property>
    		<property name="url" value="jdbc:mysql://localhost:3306/spring" ></property>
    		<property name="username" value="root" ></property>
    		<property name="password" value="123456" ></property>
    	</bean>
    
        <bean id="jdbcTempldate" class="org.springframework.jdbc.core.JdbcTemplate">
        	    <!-- jdbc模板需要数据库连接池，这里注入一个dbcp的连接池对象 -->
            	<property name="dataSource" ref="dataSource"></property>
        </bean>
    

配置数据库资源

如果你之前学过第三方数据库连接池的配置的话，你应该了解到他们都是DataSource接口的实现类，再想想上面的IoC，所以其实Spring中配置数据库资源就是将连接池类交给Spring去管理。（如果是在代码中创建数据库连接资源的话，像普通的编写即可，跟Spring没关系）

• 配置DBCP连接池：
  • 引入dbcp依赖包：
    • commons-dbcp-1.4.jar
    • commons-pool-1.5.6.jar
  • 配置DBCP：
    • 让spring管理dataSource对象。

<!-- class里面写dbcp的类，使用dataSource获取的时候就是dbcp连接池对象 -->
	<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">
		<!-- 由于里面有很多setter，可以直接属性注入 -->
		<property name="driverClassName" value="com.mysql.jdbc.Driver" ></property>
		<property name="url" value="jdbc:mysql://localhost:3306/spring" ></property>
		<property name="username" value="root" ></property>
		<property name="password" value="123456" ></property>
	</bean>

• 配置C3P0连接池：
  • 引入依赖包：
    • c3p0-0.9.1.2.jar
  • 配置连接池,把连接池交给spring管理：

<!-- class里面写c3p0的类，使用dataSource获取的时候就是c3p0连接池对象 -->
	<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
		<!-- 由于里面有很多setter，可以直接属性注入 -->
		<property name="driverClass" value="com.mysql.jdbc.Driver" ></property>
		<property name="jdbcUrl" value="jdbc:mysql://localhost:3306/spring" ></property>
		<property name="user" value="root" ></property>
		<property name="password" value="123456" ></property>
	</bean>

引入外部配置文件：

在上面的连接池配置过程中，你可能会发现一个问题，以往会使用配置文件来解决在代码中把参数写成固定值的问题，在上面中也是使用了固定值，那么怎么使用外部配置文件来解决这个问题呢？

1.引入Property配置文件：【注意一下下面标签是以context开头的，所以它需要什么xsd，你懂的】

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

2.根据配置文件中的key【要求key是点分的多单词，测试过单个单词无法获取】，引用配置文件中的参数：

      <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
      		<property name="driverClass" value="${jdbc.driverClass}" ></property>
      		<property name="jdbcUrl" value="${jdbc.url}" ></property>
      		<property name="user" value="${jdbc.username}" ></property>
      		<property name="password" value="${jdbc.password}" ></property>
      	</bean>

给一下配置文件的写法：

jdbc.driverClass=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/spring
jdbc.username=root
jdbc.password=123456

---

事务管理

• 在上面中讲述了Spring对数据库操作的支持，但没有涉及事务管理，并且实质上jdbc模板是没有自带事务管理的。
• Spring对事务的管理是通过PlatformTransactionManager管理的。

Spring用于管理事务的几个类

• PlatformTransactionManager：一个接口，spring用于管理事务

  • DataSourceTransactionManager：PlatformTransactionManager的实现类，可用于jdbc模板和MyBatis框架
  • HibernateTransactionManager：PlatformTransactionManager的实现类，主要针对Hibernate框架

• TransactionDefinition:事务定义信息,包含了一些关于事务管理的变量（隔离级别、传播行为等等），spring会把方法\类中配置的事务相关属性装载到TransactionDefinition中。

• TransactionStatus:事务的状态

• 平台事务管理器PlatformTransactionManager会根据事务定义信息TransactionDefinition的信息来进行事务管理。事务管理中产生的状态信息存储到TransactionStatus中。

声明式事务管理

xml方式【XML的方式有很多种，例如拦截器方式、通知方式，这里介绍通知方式】：

1.导入事务管理的xsd:

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

      </beans>

2.配置事务管理器

     <!--使用事务管理器，必须注入一个dataSource -->
     <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
     	<property name="dataSource" ref="dataSource" />
     </bean>

3.配置事务的增强，把事务管理器当成切面类来对方法增强，相当于给方法配置一个事务管理增强。

•  <!-- 把spring管理的transactionManager赋给transaction-manager属性 -->
       <tx:advice id="txAdvice" transaction-manager="transactionManager" >
  		<tx:attributes>
  			<!-- name写要进行事务管理的方法名 -->
  	        <tx:method name="transfer"  />
  	    </tx:attributes>
  	 </tx:advice>
  

4.AOP配置，把上面的事务增强配置给哪个切点，这些切点就是需要事务管理的地方：

	 <aop:config>
	 	<!-- 这里的切点注意要写把多个数据库操作集合起来的方法 -->
	 	<aop:pointcut expression="execution(* work.service.impl.AccountServiceImpl.*(..))" id="pointcut1"/>
	 	<aop:advisor advice-ref="txAdvice" pointcut-ref="pointcut1"/>
	 </aop:config>

5.测试类的编写：

注解式

1.导入事务管理tx和aop的xsd

2.配置事务管理器

• <!--使用事务管理器，必须注入一个dataSource -->
  <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
  	<property name="dataSource" ref="dataSource" />
  </bean>
  

3.开启注解式事务

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

4.在业务层增加@Transactional注解：

• 使用在类上，代表类的所有方法都使用事务管理
• 也可以仅使用在某个方法上。

使用详解：

• 事务管理器配置

  • spring管理事务依靠事务管理器，所以事务管理器是必须的，无论注解式还是XML式都需要。对于MyBatis和JDBC可以使用DataSourceTransactionManager作为实现类，对于Hibernate可以使用HibernateTransactionManager作为实现类

  • 事务管理器必须注入一个dataSource

  • <!--使用事务管理器，必须注入一个dataSource -->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    	<property name="dataSource" ref="dataSource" />
    </bean>
    

• XML式中事务增强的配置

  • method配置：

    • name属性是增强的方法名。另外，可以使用*作为后缀，代表匹配某一些特定前缀开头的方法，比如save*可以匹配saveCustomer,saveStudent;单写*的时候的，代表匹配所有方法。

  •  <!-- 把spring管理的transactionManager赋给transaction-manager属性 -->
         <tx:advice id="txAdvice" transaction-manager="transactionManager" >
    		<tx:attributes>
    			<!-- name写要进行事务管理的方法名 -->
    	        <tx:method name="transfer"  />
    	    </tx:attributes>
    	 </tx:advice>
    

• 注解式事务管理的开启,使用注解式事务管理，除了创建事务管理器，还需要开启事务管理的注解管理,<tx:annotation-driven transaction-manager="transactionManager"/>

• 注解式中@Transactional的位置

  • 当它使用在类上时，代表类中的所有方法都使用事务管理
  • 使用在方法上时，代表对某个方法使用事务管理。

• 隔离级别配置：【隔离级别分别解决了不同的读写问题，由于是SQL的内容，所以这里不介绍，只讲用法】

  • 隔离级别有：Read uncommitted、Read committed 、Repeatable read、Serializable
  • 对于注解方式，对注解@Transactional添加属性isolation即可，例如@Transactional(isolation=Isolation.DEFAULT)
  • 对于XML方式（这里指上面那种，XML有很多方式），在tx:method中增加isolation属性即可，例如<tx:method name="transfer" isolation="DEFAULT" />

• 传播行为配置：（传播行为用来处理多个事务时的叠加问题--当方法相互调用时可能会发生，某个方法有了事务，另一个方法也有事务，那么用哪个事务管理？）

  • 传播行为类型：【以A、B两个方法为例】
    • 保证方法都在一个事务中（A+B）
      • REQUIRED：A调用B时，如果A中已经有了事务，那么B使用A中的事务（A+B）；如果A中没有事务，那么A创建一个事务，然后包裹B（A+B）。【默认值】
      • SUPPORTS：A调用B时，如果A中已经有了事务，那么B使用A中的事务（A+B）；如果A中没有事务，那么B不使用事务。
      • MANDATORY：A调用B时，如果A中已经有了事务，那么B使用A中的事务（A+B）；如果A中没有事务，那么报错。
    • 保证方法都不在一个事务中
      • REQUIRES_NEW：A调用B时，无论A是否有事务（有事务则挂起事务），B都重新创建一个事务来包裹B。
      • NOT_SUPPORTED：A调用B时，无论A是否有事务（有事务则挂起事务），B都不使用事务。
      • NEVER：A调用B时，如果A中有事务，则报错。
    • 嵌套事务
      • NESTED：A调用B时，A事务中嵌套B事务，如果B事务报错，只回滚B事务，不回滚A事务。
  • 对于XML方式，在tx:method中增加propagation属性即可，例如<tx:method name="*" propagation="REQUIRED" />
  • 对于注解方式，对注解@Transactional添加属性propagation即可，例如@Transactional(propagation=Propagation.REQUIRED)

• jdbcTemplate注入问题：你可能会发现每一个Dao你都要注入一次jdbcTemplate,那样子貌似太麻烦了。spring提供了一个JdbcDaoSupport,我们的Dao可以继承这个类，这个类中已经包含了jdbcTemplate。除此之外，如果给这个类注入一个连接池，它会自动根据连接池来生成jdbcTemplate（这样我们就不需要把jdbcTemplate交给spring管理了，直接在dao中注入一个dataSource即可）。

  • 

补充：

• 其实处理事务，还可以使用编程式事务（就是利用事务模板transactionTemplate来手动写），但编程式事务没有声明式事务简单好用，而且声明式事务基于AOP特性，所以这里只讲声明式事务。
• 有时候使用@Transactional会失效，通常有几个情况
  • 1. 由于事务管理是基于AOP，所以不能用于静态和非public的方法。
    2. 自调用问题：调用自身类的方法，传播行为是不生效的，具体可以参考这个老哥的博文，讲的比较详细了，https://blog.csdn.net/jiesa/article/details/53438342

---

分模块开发问题：

有时候你可能不想在一个applicationContext.xml中配置所有的属性，你想建立多个applicationContext.xml来配置不同的属性。

• 配置文件名默认名字是applicationContext.xml，其实你可以改成别名字。你可能留意到new ClassPathXmlApplicationContext()时需要给一个名字，所以其实你可以改成其他的。

• 在new ClassPathXmlApplicationContext()中其实可以读取多个配置文件

  • ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml","applicationContext2.xml");
    

• 如果你不想在ew ClassPathXmlApplicationContext()时导入多个，也可以在一个配置文件中引入多个配置文件，例如在applicationContext.xml中使用import就可以引入别的配置文件

  • <import resource="applicationContext2.xml"/>
    

---

框架整合问题:

• 这里不讨论怎么与其他框架整合，只提一个常见的问题--这是与其他框架整合时都会遇到的问题。
• 问题：当你把spring使用到web中的时候，在没有提前创建的基础上，每次请求都需要创建一个Spring的工厂（每次都ApplicationContext context=new ClassPathXmlApplicationContext("applicationContext.xml");），工厂是很耗费资源的，一个项目只有一个Spring的工厂，下面讨论这个问题的解决方案。

解决方案其实我们都知道，重点是提前创建，然后存储起来，需要的时候再获取。

解决方案1：

使用ServletContextListener 监听ServletContext 对象的创建和销毁。

• 在ServletContextListener 的ContetInitialized中创建工程，并存储到ServletContext 中，每次获取工厂都从ServletContext中获取。【重点不是这个，所以不讲述那么多。】

标准解决方案：

配置spring核心监听器，让监听器提前创建工厂。监听器会帮我们把工厂存储到ServletContext 中。

• 引入jar包：spring-web.jar

• 在web.xml中配置监听器：

  •   <listener>
      		<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
      </listener>
      <!-- 配置参数，告诉核心过滤器读取哪个文件来创建工厂 -->
      <context-param>
    	  	<param-name>contextConfigLocation</param-name>
    	  	<param-value>classpath:applicationContext.xml</param-value>
      </context-param>
    

• 获取ServletContext ，然后利用WebApplicationContext context= WebApplicationContextUtils.getWebApplicationContext(sc);获取工厂 ：【这里为了帮助了解，使用基础的servlet，而不是框架】

  • public class HelloServelet extends HttpServlet {
    	@Override
    	protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    		//获取ServletContext
    		ServletContext sc=req.getServletContext();
    		//传入ServletContext，获取工厂
    		WebApplicationContext context= WebApplicationContextUtils.getWebApplicationContext(sc);
    		//通过工厂获取对象
    		Person person = (Person) context.getBean("person");
    		person.setName("丁典");
    		//能使用就说明获取成功
    		System.out.println(person);
    	}
    }
    

---

写在最后

1. 这个讲述顺序是我想了好久才琢磨出来的顺序，希望能帮助了解
2. spring框架也是个大块头，虽然这篇博文已经很长了，但还是不能涉及所有内容，而我是一个比较喜欢系统化的人，对于一些知识，我可能会整合到别的博文中去，但如果某天发现不适合整合到别的博文中去时，我可能会回来整合到这篇博文中。
3. 希望这篇博文能帮助到你。

---