JavaEE开发之Spring框架整合2(完结撒花)
随着时代发展，软件规模与功能都呈几何式增长，开发难度也在不断递增，该如何解决?
Spring可以简化开发，降低企业级开发的复杂性，使开发变得更简单快捷随着项目规模与功能的增长,遇到的问题就会增多，为了解决问题会引入更多的框架，这些框架如何协调工作?Spring可以框架整合，高效整合其他技术，提高企业级应用开发与运行效率，综上所述，Spring是一款非常优秀而且功能强大的框架。
目录
一、IOC/DI注解开发
1.1、注解开发定义bean
1.2、纯注解开发模式
1.3、注解开发bean的作用范围与生命周期管理
1.4、注解开发的依赖注入
1.5、注解开发管理第三方的bean
1.6、XML配置和注解方式的对比
二、Spring整合
2.1、Spring整合MyBatis
2.2、Spring整合Junit
三、面向切面编程(AOP)
3.1、AOP的基本概念
3.2、AOP的入门案例
3.3、AOP工作流程
3.4、AOP配置管理
四、Spring事务管理
4.1、Spring事务简介
4.2、Spring事务属性
一、IOC/DI注解开发
1.1、注解开发定义bean
1、创建maven项目，在dao层和service分别定义一个接口和一个实现类，并使用注解标记bean。
public interface BookDao {
public void save() ;
}
import com.dao.BookDao;
import org.springframework.stereotype.Repository;
@Repository("bookDao")
public class BookDaoImpl implements BookDao {
public void save() {
System.out.println("book dao save ...");
}
}
public interface BookService {
public void save() ;
}
import com.dao.BookDao;
import com.service.BookService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
@Service
public class BookServiceImpl implements BookService {
@Autowired
BookDao bookDao ;
public void setBookDao(BookDao bookDao) {
this.bookDao = bookDao;
}
public void save() {
bookDao.save();
System.out.println("book service save...");
}
}
2）在sping的配置文件applicationContext.xml中对注解进行扫描，如下：
3）编写测试类，获取IOC容器，根据bean对象访问对应的方法，如下：
import com.dao.BookDao;
import com.service.BookService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class app {
public static void main(String[] args) {
//获取IOC容器
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml") ;
//获取bean对象,并执行相应的方法
BookDao bookDao = (BookDao) applicationContext.getBean("bookDao");
bookDao.save();
BookService bookService = applicationContext.getBean(BookService.class) ;
bookService.save();
}
}
1.2、纯注解开发模式
spring3.0之后升级了纯注解开发模式，不用写配置文件了，使用java类替代spring的核心配置文件。
1）将上述的spring配置文件applicationContext.xml替换为如下类：
@Configuration注解用于设定当前类为配置类
@ComponentScan注解用于设定扫描路径，此注解只能添加一次，多个数据请用数组格式
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
@Configuration
@ComponentScan("com")
public class SpringConfig {
}
2）编写测试类，加载IOC容器，进行测试即可，这次直接配置类。
import com.SpringConfig;
import com.dao.BookDao;
import com.service.BookService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class app1 {
public static void main(String[] args) {
//获取IOC容器
ApplicationContext applicationContext = new AnnotationConfigApplicationContext(SpringConfig.class) ;
//获取bean对象,并执行相应的方法
BookDao bookDao = (BookDao) applicationContext.getBean("bookDao");
bookDao.save();
BookService bookService = applicationContext.getBean(BookService.class) ;
bookService.save();
}
}
1.3、注解开发bean的作用范围与生命周期管理
对于bean的作用范围加@scope注解，对于生命周期的初始化和销毁分别加@PostConstruct和@PreDestroy注解。
import com.dao.BookDao;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Repository;
import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
@Repository("bookDao")
@Scope
public class BookDaoImpl implements BookDao {
public void save() {
System.out.println("book dao save ...");
}
@PostConstruct
public void init(){
System.out.println("init ...");
}
@PreDestroy
public void destroy(){
System.out.println("destroy ...");
}
}
1.4、注解开发的依赖注入
1）直接使用@Autowired进行自动装配，完成注入，setter方法可以省略，如下：
该注解和@Qualifier注解组合使用，开启指定名称装配bean。
import com.dao.BookDao;
import com.service.BookService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
@Service
public class BookServiceImpl implements BookService {
@Autowired
BookDao bookDao ;
public void save() {
bookDao.save();
System.out.println("book service save...");
}
}
2)上面是对引用类型的注入，下面使用@Value注解对简单类型进行注入，如下：
import com.dao.BookDao;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Repository;
@Repository("bookDao")
public class BookDaoImpl implements BookDao {
@Value("一起学习吧")
private String name ;
public void save() {
System.out.println("book dao save ..." + name);
}
}
3）读取外部的Properties文件，首先创建一个jdbc.properties文件，然后再配置类使用注解@PropertySource加载文件，然后使用@Value注解获取jdbc.properties文件的值。
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;
@Configuration
@ComponentScan("com")
@PropertySource("jdbc.properties")
public class SpringConfig {
}
import com.dao.BookDao;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Repository;
@Repository("bookDao")
public class BookDaoImpl implements BookDao {
@Value("${jdbc.username}")
private String name ;
public void save() {
System.out.println("book dao save ..." + name);
}
}
文件jdbc.properties如下：
jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://127.0.0.1:3306/spring_db
jdbc.username=root
jdbc.password=root1.5、注解开发管理第三方的bean
1）创建外部资源对象，使用@Bean注解标注为bean。
import com.alibaba.druid.pool.DruidDataSource;
import org.springframework.context.annotation.Bean;
import javax.sql.DataSource;
public class JdbcConfig {
@Bean
public DataSource dataSource(){
DruidDataSource dataSource = new DruidDataSource() ;
dataSource.setDriverClassName("com.mysql.jdbc.Driver");
dataSource.setUrl("jdbc:mysql://127.0.0.1:3306/spring_db");
dataSource.setUsername("root");
dataSource.setPassword("root");
return dataSource ;
}
}
2）在spring的配置类中直接扫描@ComponentScan或者导入@Import的形式加载外部资源，如下：
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
@Configuration
@ComponentScan("com")
@Import({JdbcConfig.class})
public class SpringConfig {
}
3）对应简单类型的注入，使用成员变量，对于引用类型的注入使用方法形参。
import com.alibaba.druid.pool.DruidDataSource;
import com.dao.BookDao;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import javax.sql.DataSource;
public class JdbcConfig {
@Value("com.mysql.jdbc.Driver")
private String driveClassName ;
@Value("jdbc:mysql://127.0.0.1:3306/spring_db")
private String url ;
@Value("root")
private String username ;
@Value("root")
private String password ;
@Bean
public DataSource dataSource(BookDao bookDao){
System.out.println(bookDao);
DruidDataSource dataSource = new DruidDataSource() ;
dataSource.setDriverClassName(driveClassName);
dataSource.setUrl(url);
dataSource.setUsername(username);
dataSource.setPassword(password);
return dataSource ;
}
}
1.6、XML配置和注解方式的对比
从如下5个角度进行对比，看图即可：
二、Spring整合
Spring有一个容器，叫做IoC容器，里面保存bean。在进行企业级开发的时候，其实除了将自己写的类让Spring管理之外，还有一部分重要的工作就是使用第三方的技术。前面已经讲了如何管理第三方bean了，下面结合IoC和DI，整合2个常用技术，进一步加深对Spring的使用理解。
2.1、Spring整合MyBatis
本次使用纯注解的方式在Spring中整合mybatis，把配置文件换成了java类+注解的方式，提高了开发效率，如果想看基于配置文件的方式整合mybatis，可以看我之前写的博客，地址如下：MyBatis与Spring的整合（Eclipse版本和IDEA版本）_nuist__NJUPT的博客-CSDN博客
1)创建一个数据库和表，如下：
create database if not exists spring_db character set utf8;
use spring_db;
create table if not exists tbl_account(
id int primary key auto_increment,
name varchar(35),
money double
);
insert into tbl_account VALUES(null,'张三',100.00);
insert into tbl_account VALUES(null,'李四',200.00);
insert into tbl_account VALUES(null,'王五',300.00);2）创建maven项目，并在pom.xml文件中添加相关依赖jar包，如下：
4.0.0
org.example
java02
1.0-SNAPSHOT
org.springframework
spring-context
5.2.10.RELEASE
com.alibaba
druid
1.1.16
org.mybatis
mybatis
3.5.6
mysql
mysql-connector-java
5.1.47
org.springframework
spring-jdbc
5.2.10.RELEASE
org.mybatis
mybatis-spring
1.3.0
3）创建数据源配置，mybatis配置，以及spring配置，不使用配置文件，这里直接使用注解的方式进行，如下：
数据源的配置：
jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/spring_db
jdbc.username=root
jdbc.password=123456import com.alibaba.druid.pool.DruidDataSource;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import javax.sql.DataSource;
public class JdbcConfig {
@Value("${jdbc.driver}")
private String driver;
@Value("${jdbc.url}")
private String url;
@Value("${jdbc.username}")
private String userName;
@Value("${jdbc.password}")
private String password;
@Bean
public DataSource dataSource() {
DruidDataSource ds = new DruidDataSource();
ds.setDriverClassName(driver);
ds.setUrl(url);
ds.setUsername(userName);
ds.setPassword(password);
return ds ;
}
}
mybatis配置：
import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.mapper.MapperScannerConfigurer;
import org.springframework.context.annotation.Bean;
import javax.sql.DataSource;
public class MybatisConfig {
//定义bean，SqlSessionFactoryBean，用于产生SqlSessionFactory对象
@Bean
public SqlSessionFactoryBean sqlSessionFactory(DataSource dataSource){
SqlSessionFactoryBean ssfb = new SqlSessionFactoryBean();
//设置模型类的别名扫描
ssfb.setTypeAliasesPackage("com.domain");
ssfb.setDataSource(dataSource);
return ssfb;
}
//定义bean，返回MapperScannerConfigurer对象
@Bean
public MapperScannerConfigurer mapperScannerConfigurer(){
MapperScannerConfigurer msc = new MapperScannerConfigurer();
msc.setBasePackage("com.dao");
return msc;
}
}
spring配置：
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
import org.springframework.context.annotation.PropertySource;
@Configuration
@ComponentScan("com")
@PropertySource("jdbc.properties")
@Import({JdbcConfig.class,MybatisConfig.class})
public class SpringConfig {
}
4）创建实体对象，要保证和数据库中一致，如下：
import java.io.Serializable;
public class Account implements Serializable {
private Integer id ;
private String name ;
private Double money ;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public double getMoney() {
return money;
}
public void setMoney(double money) {
this.money = money;
}
@Override
public String toString() {
return "Account{" +
"id=" + id +
", name='" + name + '\'' +
", money=" + money +
'}';
}
}
5）创建创建数据访问层，执行sql语句，如下：
import com.domain.Account;
import org.apache.ibatis.annotations.*;
import java.util.List;
public interface AccountDao {
@Insert("insert into tbl_account(name,money)values(#{name},#{money})")
void save(Account account) ;
@Delete("delete from tbl_account where id = #{id} ")
void delete(Integer id) ;
@Update("update tbl_account set name = #{name} , money = #{money} where id = #{id} ")
void update(Account account) ;
@Select("select * from tbl_account")
List findAll() ;
@Select("select * from tbl_account where id = #{id}")
Account findById(Integer id) ;
} 6）业务层，将数据访问层bean注入业务层，调用数据访问层的方法，执行业务操作：
import com.domain.Account;
import java.util.List;
public interface AccountService {
void save(Account account) ;
void delete(Integer id) ;
void update(Account account) ;
List findAll() ;
Account findById(Integer id) ;
}
import com.dao.AccountDao;
import com.domain.Account;
import com.service.AccountService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;
@Service
public class AccountServiceImpl implements AccountService {
@Autowired
private AccountDao accountDao ;
public void save(Account account) {
accountDao.save(account);
}
public void delete(Integer id) {
accountDao.delete(id);
}
public void update(Account account) {
accountDao.update(account);
}
public List findAll() {
return accountDao.findAll();
}
public Account findById(Integer id) {
return accountDao.findById(id);
}
}
7）编写测试类进行测试，如下：
import com.config.SpringConfig;
import com.domain.Account;
import com.service.AccountService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import java.util.List;
public class App {
public static void main(String[] args) {
ApplicationContext applicationContext = new AnnotationConfigApplicationContext(SpringConfig.class) ;
AccountService accountService = applicationContext.getBean(AccountService.class);
List list = accountService.findAll() ;
for(Account account : list){
System.out.println(account);
}
System.out.println(accountService.findById(1)) ;
accountService.delete(1);
}
}
2.2、Spring整合Junit
1）首先需要在pom.xml文件中田间test的相关jar包依赖，如下：
4.0.0
org.example
com.mybatis
1.0-SNAPSHOT
org.springframework
spring-context
5.2.10.RELEASE
com.alibaba
druid
1.1.16
org.mybatis
mybatis
3.5.6
mysql
mysql-connector-java
5.1.47
org.springframework
spring-jdbc
5.2.10.RELEASE
org.mybatis
mybatis-spring
1.3.0
junit
junit
4.12
test
org.springframework
spring-test
5.2.10.RELEASE
2）编写测试类进行测试，需要加载测试运行器，设置spring文件的位置，对需要的测试的bean进行自动装配，然后调用方法进行测试。
import com.config.SpringConfig;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
//设置运行器类
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = {SpringConfig.class})
public class AccountServiceTest {
@Autowired
private AccountService accountService ;
@Test
public void findAll(){
System.out.println(accountService.findAll());
}
}
三、面向切面编程(AOP)
3.1、AOP的基本概念
AOP(Aspect Oriented Programming)面向切面编程，一种编程范式，指导开发者如何组织程
序结构。
OOP(Object Oriented Programming)面向对象编程，我们都知道OOP是一种编程思想，那么AOP也是一种编程思想，编程思想主要的内容就是指导程序员该如何编写程序，所以它们两个是不同的 编程范式 。
作用:在不惊动原始设计的基础上为其进行功能增强，前面咱们有技术就可以实现这样的功能即代
理模式。
通过下图：我们可以形象的学习AOP中的一些名词的含义，通知类中定义的增强功能的方法叫做通知，连接点表示原始所有方法，切入点是进行增强的方法，切面是进行通知和切入点进行绑定的。
3.2、AOP的入门案例
1）创建maven项目，在pom.xml文件中添加相应的依赖jar包。
com.mybatis
org.example
1.0-SNAPSHOT
4.0.0
com.aop
org.springframework
spring-context
5.2.10.RELEASE
org.aspectj
aspectjweaver
1.9.4
2）在dao层编写接口和实现类，需要加相应的数据访问层注解，如下：
public interface BookDao {
public void save() ;
public void update() ;
}
import com.dao.BookDao;
import org.springframework.stereotype.Repository;
@Repository
public class BookDaoImpl implements BookDao {
public void save() {
System.out.println("bookDao save ...");
}
public void update() {
System.out.println("bookDao update ...");
}
}
3）编写通知类，通知类中编写通知，通过切面对切入点进行绑定。对update方法进行增强。
@Component
@Aspect
public class MyAdvice {
@Pointcut("execution(void com.dao.BookDao.update())")
private void pt(){}
@Before("pt()")
public void method(){
System.out.println(System.currentTimeMillis());
}
}
4）编写spring配置类，加上相应的注解。
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;
@Configuration
@ComponentScan("com")
@EnableAspectJAutoProxy
public class SpringConfig {
}
5）编写测试类进行测试。
import com.config.SpringConfig;
import com.dao.BookDao;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
public class App {
public static void main(String[] args) {
ApplicationContext applicationContext = new AnnotationConfigApplicationContext(SpringConfig.class) ;
BookDao bookDao = applicationContext.getBean(BookDao.class) ;
bookDao.update();
}
}
3.3、AOP工作流程
流程1:Spring容器启动，容器启动就需要去加载bean,哪些类需要被加载呢?
需要被增强的类，如:BookServiceImpl，通知类，如:MyAdvice。注意此时bean对象还没有创建成功。
流程2：读取所有切面配置中的切入点。
流程3：始化bean，判定bean对应的类中的方法是否匹配到任意切入点，注意第1步在容器启动的时候，bean对象还没有被创建成功。要被实例化bean对象的类中的方法和切入点进行匹配。匹配成功，创建原始对象（目标对象）的代理对象,如: BookDao匹配成功说明需要对其进行增强
对哪个类做增强，这个类对应的对象就叫做目标对象，因为要对目标对象进行功能增强，而采用的技术是动态代理，所以会为其创建一个代理对象最终运行的是代理对象的方法，在该方法中会对原始方法进行功能增强。
流程4：获取的bean是代理对象时，根据代理对象的运行模式运行原始方法与增强的内容，完成操作。
目标对象(Target)：原始功能去掉共性功能对应的类产生的对象，这种对象是无法直接完成最终
工作的
代理(Proxy)：目标对象无法直接完成工作，需要对其进行功能回填，通过原始对象的代理对象实
现
3.4、AOP配置管理
1）切入点表达式
对于切入点表达式可以采用通配符的方式书写，通过符的书写一般采用如下格式：
2）AOP通知类型
前置通知：@Before
后置通知：@After
环绕通知(重点)：@Around
返回后通知(了解)：@AfterReturning
抛出异常后通知(了解)：@AfterThrowing
前置通知案例：
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;
@Component
@Aspect
public class MyAdvice {
@Pointcut("execution(void com.dao.BookDao.update())")
private void pt(){}
@Before("pt()")
public void method(){
System.out.println(System.currentTimeMillis());
}
}
后置通知案例：
import com.config.SpringConfig;
import com.dao.BookDao;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
public class App {
public static void main(String[] args) {
ApplicationContext applicationContext = new AnnotationConfigApplicationContext(SpringConfig.class) ;
BookDao bookDao = applicationContext.getBean(BookDao.class) ;
bookDao.update();
}
}环绕通知案例：
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;
@Component
@Aspect
public class MyAdvice {
@Pointcut("execution(void com.dao.BookDao.update())")
private void pt(){}
@Around("pt()")
public Object method(ProceedingJoinPoint pjp) throws Throwable {
System.out.println(System.currentTimeMillis());
Object object = pjp.proceed() ;
System.out.println(System.currentTimeMillis());
return object ;
}
}
3）测量接口万次代码执行效率：用环绕通知实现
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.Signature;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;
@Component
@Aspect
public class MyAdvice {
@Pointcut("execution(void com.dao.BookDao.update())")
private void pt(){}
@Around("pt()")
public void method(ProceedingJoinPoint pjp) throws Throwable {
Signature signature = pjp.getSignature() ;
String className = signature.getDeclaringTypeName() ;
String methodName = signature.getName() ;
long start = System.currentTimeMillis() ;
for(int i=0; i<10000; i++) {
pjp.proceed();
}
long end = System.currentTimeMillis() ;
System.out.println("万次执行" + className + "." + methodName + "------->" + "时间为:" + (end-start) + "ms");
}
}
四、Spring事务管理
4.1、Spring事务简介
事务作用：在数据层保障一系列的数据库操作同成功同失败
Spring事务作用：在数据层或业务层保障一系列的数据库操作同成功同失败
数据层有事务我们可以理解，为什么业务层也需要处理事务呢?
举个简单的例子，
转账业务会有两次数据层的调用，一次是加钱一次是减钱
把事务放在数据层，加钱和减钱就有两个事务
没办法保证加钱和减钱同时成功或者同时失败
这个时候就需要将事务放在业务层进行处理。
Spring为了管理事务，提供了一个平台事务管理器 PlatformTransactionManager
下面看一个简单的转账案例
1）创建数据库的表，并添加两条记录用于模拟转账，如下：
create database if not exists spring_db character set utf8;
use spring_db;
create table if not exists tbl_account(
id int primary key auto_increment,
name varchar(35),
money double
);
insert into tbl_account values(1,'Tom',1000);
insert into tbl_account values(2,'Jerry',1000);2）创建maven项目，加载相关依赖jar包，如下：
com.mybatis
org.example
1.0-SNAPSHOT
4.0.0
com.transaction
org.springframework
spring-context
5.2.10.RELEASE
com.alibaba
druid
1.1.16
org.mybatis
mybatis
3.5.6
mysql
mysql-connector-java
5.1.47
org.springframework
spring-jdbc
5.2.10.RELEASE
org.mybatis
mybatis-spring
1.3.0
3）添加数据的配置文件jdbc.properties，如下：
jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://127.0.0.1:3306/spring_db?characterEncoding=utf-8
jdbc.username=root
jdbc.password=1234564）添加Account实体类。
import java.io.Serializable;
public class Account implements Serializable {
private Integer id ;
private String name ;
private Double money ;
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Double getMoney() {
return money;
}
public void setMoney(Double money) {
this.money = money;
}
@Override
public String toString() {
return "Account{" +
"id=" + id +
", name='" + name + '\'' +
", money=" + money +
'}';
}
}
5）创建数据层，执行操作数据库的操作。
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Update;
public interface AccountDao {
@Update("update tbl_account set money = money + #{money} where name = #{name}")
void inMoney(@Param("name") String name, @Param("money") Double money) ;
@Update("update tbl_account set money = money - #{money} where name = #{name}")
void outMoney(@Param("name") String name, @Param("money") Double money) ;
}
6）创建业务层的接口和实现类，实现数据层注入和调用数据层的方法等业务操作，需要在接口添加事务注解。
import org.springframework.transaction.annotation.Transactional;
@Transactional
public interface AccountService {
public void transfer(String out,String in ,Double money) ;
}
import com.dao.AccountDao;
import com.service.AccountService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
@Service
public class AccountServiceImpl implements AccountService {
@Autowired
private AccountDao accountDao ;
public void transfer(String out, String in, Double money) {
accountDao.outMoney(out,money);
// int a = 1 / 0 ;
accountDao.inMoney(in,money);
}
}
7）完成数据源，mybatis以及spring的配置，在mybatis配置中配置事务管理器，在spring配置中启动事务管理器。
数据源配置：
import com.alibaba.druid.pool.DruidDataSource;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.transaction.PlatformTransactionManager;
import javax.sql.DataSource;
public class JdbcConfig {
@Value("${jdbc.driver}")
private String driver;
@Value("${jdbc.url}")
private String url;
@Value("${jdbc.username}")
private String userName;
@Value("${jdbc.password}")
private String password;
@Bean
public DataSource dataSource() {
DruidDataSource ds = new DruidDataSource();
ds.setDriverClassName(driver);
ds.setUrl(url);
ds.setUsername(userName);
ds.setPassword(password);
return ds;
}
//配置事务管理器，mybatis使用的是jdbc事务
@Bean
public PlatformTransactionManager transactionManager(DataSource dataSource) {
DataSourceTransactionManager transactionManager = new DataSourceTransactionManager();
transactionManager.setDataSource(dataSource);
return transactionManager;
}
}
mybatis配置：
import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.mapper.MapperScannerConfigurer;
import org.springframework.context.annotation.Bean;
import javax.sql.DataSource;
public class MybatisConfig {
//定义bean，SqlSessionFactoryBean，用于产生SqlSessionFactory对象
@Bean
public SqlSessionFactoryBean sqlSessionFactory(DataSource dataSource){
SqlSessionFactoryBean ssfb = new SqlSessionFactoryBean();
//设置模型类的别名扫描
ssfb.setTypeAliasesPackage("com.domain");
ssfb.setDataSource(dataSource);
return ssfb;
}
//定义bean，返回MapperScannerConfigurer对象
@Bean
public MapperScannerConfigurer mapperScannerConfigurer(){
MapperScannerConfigurer msc = new MapperScannerConfigurer();
msc.setBasePackage("com.dao");
return msc;
}
}
spring配置：
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
import org.springframework.context.annotation.PropertySource;
import org.springframework.transaction.annotation.EnableTransactionManagement;
@Configuration
@ComponentScan("com")
@PropertySource("jdbc.properties")
@Import({JdbcConfig.class,MybatisConfig.class})
@EnableTransactionManagement
public class SpringConfig {
}
8）编写测试类，测试事务管理。
import com.config.SpringConfig;
import com.service.AccountService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
public class App {
public static void main(String[] args) {
ApplicationContext applicationContext = new AnnotationConfigApplicationContext(SpringConfig.class) ;
AccountService accountService = applicationContext.getBean(AccountService.class) ;
accountService.transfer("Tom","Jerry",100.00);
}
}
4.2、Spring事务属性
1）事务配置，我们可以对事务设置属性，特别是回滚属性，可以设置在什么异常下产生回滚。
2）事务的传播行为，如果事务管理员已经开启事务，事务协调员不想加入，就需要另外开辟一个事务，通过设置事务传播属性是实现。
3）事务传播属性设置案例
需求：在以上的基础上，无论转账是否成功，都记录转账日志信息。
第一步，在上述的数据库中创建一个表用于记录转账信息，如下：
create table tbl_log(
id int primary key auto_increment,
info varchar(255),
createDate datetime
)
然后，添加数据层接口，如下：
import org.apache.ibatis.annotations.Insert;
public interface LogDao {
@Insert("insert into tbl_log (info,createDate) values(#{info},now())")
void log(String info);
}然后添加业务层接口和实现类，需要设置事务为另外开启一个新的事务，即修改事务的传播行为：
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
@Transactional(propagation = Propagation.REQUIRES_NEW)
public interface LogService {
void log(String out, String in, Double money);
}
import com.dao.LogDao;
import com.service.LogService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
@Service
public class LogServiceImpl implements LogService {
@Autowired
private LogDao logDao;
public void log(String out, String in, Double money) {
logDao.log("转账操作由"+out+"到"+in+",金额："+money);
}
}
然后需要转账业务中添加日志记录业务，如下：
import com.dao.AccountDao;
import com.service.AccountService;
import com.service.LogService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
@Service
public class AccountServiceImpl implements AccountService {
@Autowired
private AccountDao accountDao ;
@Autowired
private LogService logService ;
public void transfer(String out, String in, Double money) {
try {
accountDao.outMoney(out, money);
int a = 1 / 0 ;
accountDao.inMoney(in, money);
}finally {
logService.log(out,in,money);
}
}
}