Framework---Spring

一、重点知识

ioc的实现原理
1、创建一个工厂类
2、用xml解析得到xml文件中的全路径名
3、通过反射的方式创建对象，掉用的是默认对象的无参构造

用applicationContext的方法实现优势在于在tomcat启动时就把对象创建好，在web工程中这样实现有优势

BeanFactory加载时候才去创建对象

两个重要的实现类
ClassPathXmlApplicationContext
后面的参数写在src下的路径
FileSystemXmlApplicationContext
后面的路径为在盘符下的全路径

DI是ioc中的一种具体实现，需要在创建对象的基础之上完成

有参函数注入属性，可以通过属性名或者下标进行注入，下标从0开始

bean创建的实例可以是一个单例的，也可以是多例的，默认情况下是单例得

bean作用域就是创建得对象是单例还是多例

Spring Bean是被实例的，组装的及被Spring 容器管理的Java对象。

xml文件中添加了后置处理器后，他会为所有的bean添加后置处理器

在实现自动注入属性用bytype时不能存在相同类型得类

p空间用的也是set方法赋值

类型的首字母小写—>简单类名

注解的功能都一样，划分的目的是为了区分三层架构

spring扫描只扫描父包也可以

注解的父类如果在context:exclude-filter标签中被去除了，则所有的子注解都会失效

添加注解一定要放在排除注解的上面

注解实现属性的注入，记得@autowrite要和@Qualifier搭配使用

springxml文件格式是由xsd约束决定的

classPath类路径

classPath*表示去当前父工程去找文件

在xml文件中对象的初始化按照从上到下的顺序

基于xml自动装配默认调用的时set方法

不改变源代码，就可以添加新功能就是AOP

aop的底层为动态代理分为有接口和没有接口两种

execution(* com.sc.service.AccountService+.*(..))" id="mypointcut"
+表示其下所有实现类

Spring的测试框架要基于junit4.12及其以上

二、知识框架

第一章 Spring简介

第1节 Spring的介绍

Spring官网地址

https://spring.io

Spring的介绍

Spring是一个开放源代码的设计层面框架，他解决的是业务逻辑层和其他各层的松耦合问题，因此它将面向接口的编程思想贯穿整个系统应用。Spring是于2003年兴起的一个轻量级的Java 开发框架，由Rod Johnson创建。简单来说，Spring是一个分层的JavaSE/EE full-stack(一站式) 轻量级开源框架。

第2节 Spring的架构

image

第3节 Spring的核心依赖介绍

image

Spring框架由约20个模块组成,这些模块分为核心容器,数据库操作,web,AOP,设置,消息处理,测试等。

Core Container

核心容器涉及到的模块
spring-core
spring-beans
spring-context
spring-context-support
spring-expression

AOP and Instrumentation

AOP(Aspect Oriented Programming)和设备

AOP涉及到的模块:
spring-aop
spring-aspects

设备涉及到的模块:
spring-instrument
spring-instrument-tomcat

Messaging

消息涉及到的模块:
spring-messaging

Data Access/Integration

数据库操作涉及到的模块:
spring-jdbc
spring-tx（事务管理）
spring-orm
spring-oxm
spring-jms

web涉及到的模块:
spring-web
spring-webmvc
spring-websocket
spring-webmvc-portlet

Test

Test 涉及到的模块:
spring-test

第二章 Spring的Core Container(核心容器)

第1节核心容器(IOC)介绍

IOC的概念

控制反转(Inversion of Control，缩写为IoC),又称为依赖注入,是面向对象编程中的一种设计思想，可以用来降低计算机代码之间的耦合度

依赖注入和控制反转的理解

依赖注入: 在应用程序中的组件需要获取资源时,传统的方式是组件主动去创建需要的资源;反转控制的思想完全颠覆了应用程序组件获取资源的方式,反转了资源的获取方向,改由容器创建,并主动的将资源推送给需要的组件，开发人员不需要知道容器是如何创建资源对象的,只需要提供接收资源的方式即可.

控制反转：IOC的另一种表述方式：即组件以一些预先定义好的方式(例如：setter方法)接受来自于容器的资源注入.

IOC容器创建

Spring提供了创建IOC容器的接口(ApplicationContext),要想创建一个IOC容器只需要实例化此接口的实现类即可

ApplicationContext接口的主要实现如下:

ClassPathXmlApplicationContext：创建IOC容器的典型实现类之一,基于对应类路径下的XML格式的配置文件进行IOC容器的初始化
ConfigurableApplicationContext:是ApplicationContext的子接口，里面包含了一些扩展方法,比如添加了启动,刷新,关闭IOC容器的能力

创建IOC实例的方式:
ApplicationContext ioc = new ClassPathXmlApplicationContext("bean.xml");
bean.xml：类路径下的xml配置文件，里面是一些需要IOC容器进行初始化的类的配置

第2节使用IOC容器进行对象实例化

我们有了IOC容器,IOC容器到底是干什么的,我们为什么要学习IOC容器,它能帮我们解决哪些问题?

我们下面会进行IOC容器的使用,你会发现IOC容器其实就是帮助我们创建对象和管理对象的.具体是怎么创建,怎么管理的,下面我们一个个说。

2.1 bean标签方式

bean的初始化(setter/getter)

bean的初始化(构造器方式)

bean的初始化(p标签赋值)
首先要在标签头上加入P标签标识
bean的初始化(给属性赋null值)

不设置值或者是设置标签

bean的初始化(对象引用ref赋值)

bean的初始化(内部bean赋值)

bean的初始化(list赋值)

bean的初始化(set赋值)

bean的初始化(map赋值)

util名称创建对象list(了解)

23123

bean的初始化(Properties赋值)

root
root
jdbc:mysql://localhost:3306/spring_repository
com.mysql/jdbc.Driver

级联属性赋值
- Java类

public class UserDao {

private String daoMsg;
}

public class UserService {

private UserDao userDao;

}

- XML配置

2.2 注解的方式

相对于XML方式而言，通过注解的方式配置bean更加简洁和优雅，而且和MVC组件化开发的理念十分契合，是开发中常用的使用方式.
@Component
public class User{

}

使用注解标识要加入到IOC管理的类

①普通组件：@Component
标识一个受Spring IOC容器管理的组件
②持久化层组件：@Repository（dao层）
标识一个受Spring IOC容器管理的持久化层组件
③业务逻辑层组件：@Service
标识一个受Spring IOC容器管理的业务逻辑层组件
④表述层控制器组件：@Controller（servlet层）
标识一个受Spring IOC容器管理的表述层控制器组件
⑤组件命名规则
[1]默认情况：使用组件的简单类名首字母小写后得到的字符串作为bean的id
[2]使用组件注解的value属性指定bean的id

组件扫描

组件被上述注解标识后还需要通过Spring进行扫描才能够侦测到

指定被扫描的package:

包含和排除

第3节静态工厂类/实例工厂类

3.1 静态工厂

Java代码

/**

静态工厂类
*/
public class StaticFactory {
private static Map map;
static {
map = new HashMap<>();
map.put("key01", new User(100, "user1"));
map.put("key02", new User(102, "user2"));
map.put("key03", new User(103, "user3"));
}
public static User getUser(String key){
return map.get(key);
}
}
xml配置

3.2 实例工厂

Java代码

/**

实例工厂类
*/
public class InstanceFactory {

private Map map;
{
map = new HashMap<>();
map.put("key01", new User(100, "user1"));
map.put("key02", new User(102, "user2"));
map.put("key03", new User(103, "user3"));
}
public User getUser(String key){
return map.get(key);
}
}
xml配置

第4节 factoryBean接口

Spring中有两种类型的bean，一种是普通bean，另一种是工厂bean，即FactoryBean。工厂bean跟普通bean不同，其返回的对象不是指定类的一个实例，其返回的是该工厂bean的getObject方法所返回的对象

Java代码

public class FactoryUser implements FactoryBean{
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public User getObject() throws Exception {
return new User(1001,name);
}
@Override
public Class getObjectType() {
return User.class;
}
@Override
public boolean isSingleton() {
return true;
}
}

XML配置

第5节 bean配置的继承

Spring允许继承bean的配置，被继承的bean称为父bean。继承这个父bean的bean称为子bean。子bean从父bean中继承配置，包括bean的属性配置.子bean也可以覆盖从父bean继承过来的配置

Java代码

public class User {
private Integer id;
private String name;

}

public class Student extends User {
private String gender;
}

XML配置

第6节 bean之间的依赖

有的时候创建一个bean的时候需要保证另外一个bean也被创建，这时我们称前面的bean对后面的bean有依赖。例如：要求创建Employee对象的时候必须创建Department。这里需要注意的是依赖关系不等于引用关系，Employee即使依赖Department也可以不引用它

第7节 bean的作用域

在Spring中，可以在bean元素的scope属性里设置bean的作用域，以决定这个bean是单实例的还是多实例的。默认情况下，Spring只为每个在IOC容器里声明的bean创建唯一一个实例，整个IOC容器范围内都能共享该实例：所有后续的getBean()调用和bean引用都将返回这个唯一的bean实例。该作用域被称为 singleton，它是所有bean的默认作用域

类别	说明
singleton	在IOC容器中仅存在一个bean实例，bean以单实例的方式存在
prototype	每次调用getBean()时都会返回新的实例

xml配置

注解配置

@Scope(value="prototype")
@Component
public class User{

}

测试代码

ApplicationContext ioc = new ClassPathXmlApplicationContext("bean.xml");
User bean = (User) ioc.getBean("user");
User bean2 = (User) ioc.getBean("user");
System.out.println(bean.hashCode());
System.out.println(bean2.hashCode());

第8节 bean的生命周期

Spring IOC容器可以管理bean的生命周期，Spring允许在bean生命周期内特定的时间点执行指定的任务

在配置bean时，通过init-method和destroy-method属性为bean指定初始化和销毁方法

Java代码

public class User {
public void init() {
System.out.println("user被初始化了");
}
public void destroy() {
System.out.println("user被销毁了");
}

}

XML配置

测试代码

@Test
public void test01() {
//ConfigurableApplicationContext: 带有关闭IOC容器的方法,如果不关闭IOC容器不会调用销毁方法
ConfigurableApplicationContext ioc = new ClassPathXmlApplicationContext("bean.xml");
User bean = (User) ioc.getBean("user");
System.out.println(bean);
ioc.close();
}

第9节 bean的后置处理器

后置处理器介绍

bean后置处理器允许在调用初始化方法前后对bean进行额外的处理;bean后置处理器对IOC容器里的所有bean实例逐一处理，而非单一实例。其典型应用是：检查bean属性的正确性或根据特定的标准更改bean的属性;bean后置处理器需要实现接口：org.springframework.beans.factory.config.BeanPostProcessor

在初始化方法被调用前后，Spring将把每个bean实例分别传递给上述接口的以下两个方法：

postProcessBeforeInitialization(Object, String)
postProcessAfterInitialization(Object, String)

Java代码

public class ABeanPostProcessor implements BeanPostProcessor {

public ABeanPostProcessor() {
}

@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
System.out.println("postProcessBeforeInitialization="+bean+"beanName:"+beanName);
return bean;
}

@Override
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
System.out.println("postProcessBeforeInitialization="+bean+"beanName:"+beanName);
return bean;
}

}

XML配置

第10节外部资源导入配置

直接配置

外部资源配置方式

直接配置方式是将配置信息直接写在XML配置文件中,这样不好管理,所以我们将配置信息抽出放在一个properties文件中: db.properties

user=root
password=root
url=jdbc:mysql://localhost:3306/hello
driver=com.mysql.jdbc.Driver

第11节自动装配

11.1 基于xml的自动装配

通过设置 autowire 属性来进行自动装配

1. byType : 通过类型进行匹配
2. byName : 通过bean的id进行匹配

Java代码

public class UserDao {

private String msg="我是userDao";
}

public class UserService {

private UserDao userDao;
}

public class UserController {

private UserService userService;
}

XML配置

11.2 基于注解的自动装配

通过以下注解进行自动装配

1. @Autowired 注解 : 根据类型装配
2. @Resource 注解 : 根据名称装配

第三章 SpEL表达式

第1节 SpEL表达式简介

Spring Expression Language,Spring表达式语言,简称SpEL.和JSP页面上的EL表达式一样,SpEL根据JavaBean风格的getXxx()、setXxx()方法定义的属性访问对象图,完全符合我们熟悉的操作习惯

第2节 SpEL基本语法

SpEL语法格式#{…}，所有在大框号中的字符都将被认为是SpEL表达式

第3节 SpEL的使用

3.1 基本数据类型

整数:
小数:
科学计数法:

3.2 String数据类型

String类型的字面量可以使用单引号或者双引号作为字符串的定界符号

或

3.3 引用其他bean

Java代码

public class Department {

private Integer deptId;
private String deptName;

public String getDeptName(){
return deptName;
}

public static String getInfo(){
return deptName;
}
}

public class Employee {

private Integer empId;
private String empName;

private Department department;

private String deptName;

}

XML配置

bean id="dept" class="com.sc.entity.Department">

3.4 引用其他bean的属性

3.5 调用非静态方法

bean id="dept" class="com.sc.entity.Department">

3.6 调用静态方法

3.7 运算符

① 算术运算符：+、-、*、/、%、^
② 字符串连接：+
③ 比较运算符：<、>、==、<=、>=、lt、gt、eq、le、ge
④ 逻辑运算符：and, or, not, |
⑤ 三目运算符：判断条件?判断结果为true时的取值:判断结果为false时的取值

第四章 Spring的AOP

第1节 AOP简介

AOP的概念

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

AOP的本质

代码重用的一种解决方案

传统的解决代码重用的方式：

1. 将重复的代码抽取成一个方法
2. 将重复的代码抽取到一个基类中
3. 动态代理的方式

第2节动态代理

public class ProxyMathUtil {
//目标代理对象
private Object target;

public ProxyMathUtil(Object target) {
this.target = target;
}

public Object getProxy() {
return Proxy.newProxyInstance(this.target.getClass().getClassLoader(),this.target.getClass().getInterfaces(),new InvocationHandler() {
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
Object object = method.invoke(target, args);
return object;
}
});
}
}

第3节 AOP术语介绍

1. 横切关注点: 从每个方法中抽取出来的同一类非核心业务
2. 切面 Aspect: 封装横切关注点信息的类
3. 通知 Advice: 切面要完成的具体工作
4. 目标 Target: 被通知的对象
5. 代理 Proxy: 向目标对象应用通知之后创建的代理对象
6. 连接点 Joinpoint: 横切关注点在程序代码中的具体体现对应程序执行的某个特定位置
7. 切入点 pointcut：查询具体连接点的表达式
8. 切入点的格式: execution([权限修饰符][返回值类型][简单类名/全类名]方法名)

切入点格式举例
精确匹配: execution(public int com.sc.aop.MathCaculator.add(int,int))
通配符匹配： execution(* .(..))

第4节 AOP实现方式

4.1 注解方式

注解方式实现步骤

1. 创建被代理的目标类,并加入到IOC容器中
2. 创建切面类,并加入到IOC容器中，同时给切面类添加@Aspect注解，表明当前类是一个切面类
3. 在切面类中声明通知方法

前置通知: @Before
返回通知: @AfterReturning
后置通知: @After
异常通知: @AfterThrowing
环绕通知: @Around

代码实现
- 创建目标接口

public interface MathCalculator {

int add(int x,int y);

int sub(int x,int y);

int mul(int x,int y);

int div(int x,int y);
}

- 创建目标接口实现类

@Service
public class MathCalculatorImpl implements MathCalculator {

@Override
public int add(int x, int y) {
return x+y;
}

@Override
public int sub(int x, int y) {

return x-y;
}

@Override
public int mul(int x, int y) {

return x*y;
}

@Override
public int div(int x, int y) {

return x/y;
}

}

- 创建切面类/在切面类中定义通知方法

@Aspect
@Component
public class AopAspect {

//前置通知
@Before("execution(public int com.sc.aop.MathCaculator.*(..))")
public void methodStart(JoinPoint joinPoint) {
System.out.println("前置通知");
}

//返回通知
@AfterReturning(pointcut="execution(public int com.sc.aop.MathCaculator.*(..))",returning="abc")
public void methodReturn(Object abc) {
System.out.println("返回通知");
}

//异常通知
@AfterThrowing(pointcut="execution(public int com.sc.aop.MathCaculator.*(..))",throwing="e")
public void methodThrow(Exception e) {
System.out.println("异常通知");
}

//后置通知
@After("execution(public int com.sc.aop.MathCaculator.*(..))")
public void methodAfter() {
System.out.println("后置通知");
}

//环绕通知
@Around("execution(public int com.sc.aop.MathCaculator.*(..))")
public Object methodAround(ProceedingJoinPoint joinPoint) {
Object r=0;
System.out.println("环绕-->前置通知");
try {
r = joinPoint.proceed();
System.out.println("环绕-->返回通知");
} catch (Throwable e) {
System.out.println("环绕-->异常通知");
}finally {
System.out.println("环绕-->后置通知");
}
return r;
}
}

- xml中开启AOP的注解功能

- JoinPoint 方法入参获取方法信息

//获取方法名
String methodName = joinPoint.getSignature().getName();

- 方法返回值获取

//returning：设置返回值参数名
@AfterReturning(pointcut="execution(public int com.sc.aop.MathCaculator.*(..))",returning="abc")
public void methodReturn(Object abc) {
System.out.println("返回通知");
}

- 接收捕获到的异常对象

//throwing：设置异常参数名
@AfterThrowing(pointcut="execution(public int com.sc.aop.MathCaculator.*(..))",throwing="e")
public void methodThrow(Exception e) {
System.out.println("异常通知");
}

- 统一声明切入点

@Pointcut("execution(public int com.sc.aop.MathCaculator.*(..))")
public void log(){

}

//前置通知
@Before("log()")
public void methodStart(JoinPoint joinPoint) {
System.out.println("前置通知");
}

- 优先级

给切面类设置优先级,当一个方法被多个切面切的时候，判断先走哪个切面。设置order注解。
@Order(10)
越小优先级越高

4.2 XML配置方式

第五章 Spring的事务管理

第1节事物介绍

什么是事务

事务是逻辑上的一组操作,这组操作要么全部成功，有一个失败就全部失败

事务的特性

1. 原子性
2. 一致性
3. 隔离性
4. 永久性

事务的隔离级别

1. 读已提交-> READ_COMMITTED -> 可避免脏读的发生
2. 读未提交-> READ_UNCOMMITTED -> 最低级别，任何情况都无法保证
3. 可重复读-> REPEATABLE_READ -> 可避免脏读、不可重复读的发生
4. 串行化-> SERIALIZABLE -> 可避免脏读、不可重复读、幻读的发生

没有隔离级别产生的问题
- 脏读

一个事物读取的数据是另一个事物还没有来得及提交的数据，会造成脏读的问题

- 幻读

幻读是指，如果我正在对一个数据库表进行全部的修改某几个属性的值，同时还有其他事物向数据库表中添加数据，当修改完查询的时候发现出现了有的字段属性值没有修改成功，这时候就产生幻读问题.

- 不可重复读

不可重复读是指在一个事务当中通过相同条件多次查询相同的数据，返回的结果集不相同。造成的原因是有其他事物正在不断的修改这些数据.

MYSQL的事务操作

1. mysql默认的隔离级别 : REPEATABLE_READ
2. oracle默认的隔离级别 : READ_COMMITTED
3. 查询当前mysql事务 : select @@tx_isolation;
4. 修改当前mysql事务 : set tx_isolation='REPEATABLE-READ';

第2节 Spring的事务API介绍

PlatformTransactionManager : 平台事务管理器

对ORM框架的事物进行管理
1. JDBC/Mybatis : DataSourceTransactionManager
2. hibernate ：Hibernate3TransactionManager/Hibernate4TransactionManager/Hibernate5TransactionManager

TransactionDefinition: 事务定义信息(隔离级别,传播行为,超时,只读)
- 隔离级别

ISOLATION_DEFAULT -> 使用数据库的隔离级别
ISOLATION_READ_COMMITTED
ISOLATION_READ_UNCOMMITTED
ISOLATION_REPEATABLE_READ
ISOLATION_SERIALIZABLE

- 传播行为

PROPAGATION_REQUIRED -> 支持当前事务如果不存在就重新创建一个
PROPAGATION_SUPPORTS -> 支持当前事务，如果不存在就不使用事务
PROPAGATION_MANDATORY -> 支持当前事务,如果不存在就抛出异常
PROPAGATION_REQUIRES_NEW -> 如果有事务存在,就挂起当前事务，创建一个新事务
PROPAGATION_NOT_SUPPORTED -> 以非事务方式运行,如果有事务存在就挂起当前事务
PROPAGATION_NEVER -> 以非事务方式运行,如果有事务就抛出异常
PROPAGATION_NESTED -> 如果当前事务存在就嵌套事务运行

- 超时时间

TIMEOUT_DEFAULT

TransactionStatus：事务具体运行状态

第3节 Spring的事务实现

3.1 环境准备

创建数据库

create database spring default character set utf8;

创建数据库表

CREATE TABLE account(
id int not null primary key auto_increment,
name varchar(10) not null comment '账户',
money double default 0.0
)ENGINE=InnoDB AUTO_INCREMENT=1000 DEFAULT CHARSET=UTF8 COMMENT = '账户表';

INSERT INTO account(name,money) VALUES("li4",1000),("z3",1000);

创建Java工程添加jar包或者依赖

c3p0-0.9.1.2.jar
com.springsource.net.sf.cglib-2.2.0.jar
com.springsource.org.aopalliance-1.0.0.jar
com.springsource.org.aspectj.weaver-1.6.8.RELEASE.jar
commons-logging-1.2.jar
mysql-connector-java-5.1.44.jar
spring-aop-4.3.10.RELEASE.jar
spring-aspects-4.3.10.RELEASE.jar
spring-beans-4.3.10.RELEASE.jar
spring-context-4.3.10.RELEASE.jar
spring-context-support-4.3.10.RELEASE.jar
spring-core-4.3.10.RELEASE.jar
spring-expression-4.3.10.RELEASE.jar
spring-jdbc-4.3.10.RELEASE.jar
spring-orm-4.3.10.RELEASE.jar
spring-oxm-4.3.10.RELEASE.jar
spring-test-4.3.10.RELEASE.jar
spring-tx-4.3.10.RELEASE.jar

创建外部属性资源文件(数据库配置信息)

//db.properties

jdbc.username=root
jdbc.password=root
jdbc.url=jdbc:mysql://127.0.0.1:3306/spring?useUnicode=true&characterEncoding=utf-8
jdbc.driverClass=com.mysql.jdbc.Driver

创建Dao层接口

public interface AccountDao {

/**

转入金额
@param in
@param money
*/
void inMoney(String in,double money);

/**

转出金额
@param out
@param money
*/
void outMoney(String out,double money);
}
创建Dao层接口实现类

public class AccountDaoImpl extends JdbcDaoSupport implements AccountDao {

@Override
public void inMoney(String in, double money) {

String sql="UPDATE account set money=money-? WHERE name=?";

this.getJdbcTemplate().update(sql, money, in);
}

@Override
public void outMoney(String out, double money) {

String sql="UPDATE account set money=money+? WHERE name=?";

this.getJdbcTemplate().update(sql, money, out);
}

}

创建service层接口

public interface AccountService {
/转账/
void transfer(String in,String out,double money);
}

创建service层接口实现类

public class AccountServiceImpl implements AccountService{

private AccountDao accountDao;

public void setAccountDao(AccountDao accountDao) {
this.accountDao = accountDao;
}

@Override
public void transfer(String in, String out, double money) {
//转出
accountDao.outMoney(in, money);
//int i = 1/0;
//转入
accountDao.inMoney(out, money);

}

}

编写spring的核心配置文件applicationContext.xml

测试环境是否搭建成功

@Test
public void test() {

ApplicationContext ioc = new ClassPathXmlApplicationContext("applicationContext.xml");
AccountService accountService = (AccountService) ioc.getBean("accountService");
//李四转账给张三500元
accountService.transfer("zs", "ls", 500);
}

3.2 编程式事务实现

1. Spring为了简化我们的开发,提供了TransactionTemplate这样的一个事务管理模板，所以编程式事务管理采用此模板进行管理。
2. 在AccountService中使用TransactionTemplate
3. TransactionTemplate依赖DataSourceTransactionManager
4. DataSourceTransactionManager依赖DataSource

Java类

public class AccountServiceImpl implements AccountService{

private AccountDao accountDao;
public void setAccountDao(AccountDao accountDao) {
this.accountDao = accountDao;
}
private TransactionTemplate transactionTemplate;
public void setTransactionTemplate(TransactionTemplate transactionTemplate) {
this.transactionTemplate = transactionTemplate;
}
@Override
public void transfer(String in, String out, double money) {

transactionTemplate.execute(new TransactionCallbackWithoutResult() {

@Override
protected void doInTransactionWithoutResult(TransactionStatus status) {
//转出
accountDao.outMoney(in, money);
int i = 1/0;
//转入
accountDao.inMoney(out, money);
}
});
}
}

XML配置

3.3 声明式事物实现

方式一(AOP传统方式)

1. 配置平台事务管理器
2. 配置事务代理(代理service层)
① spring传统aop方式
② TransactionProxyFactoryBean

配置目标对象
注入事务管理器
配置事务的一些属性:transactionAttributes（配置方式见源码）

XML配置

PROPAGATION_REQUIRED

Test测试

@Test
public void test() {

ApplicationContext ioc = new ClassPathXmlApplicationContext("applicationContext.xml");
//获取IOC容器中的代理增强类,不需要再获取AccountService类,因为他已经被accountServiceProxy代理。
AccountService accountService = (AccountService) ioc.getBean("accountServiceProxy");
//李四转账给张三500元
accountService.transfer("zs", "ls", 500);
}

方式二(AspectJ)

1. 导入aspectj的包/以及spring整合aspectj的包
2. 配置平台事务管理器
3. 配置事务的通知 tx:advice
4. 配置AOP的切面
① 配置切入点
② 配置切面