关于spring的事务与异常处理
发布网友
共2个回答
懂视网
aspectJ的aop操作（基于注解，对比day02配置操作）（会用）
*jdbcTemplate操作（实现CRUD）
*spring配置连接池
*spring事务管理
一、AspectJ的基于注解的AOP操作
（day02的配置回顾，略显麻烦，配置稍多）
建立项目记得导入day02操作aop的那些包（如果是复制项目一定要修改项目的context name）
再把配置文件拿过来
<?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-4.3.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd"> <!-- 开启aop代理（开启aop操作） --> <aop:aspectj-autoproxy></aop:aspectj-autoproxy> <!-- 配置创建对象 --> <bean id="book" class="cn.aop.Book"></bean> <bean id="buyBook" class="cn.aop.BuyBook"></bean> </beans>
建立两个类：Book 和 BuyBook
依旧使用配置文件创建对象，开启aop操作
在增强的类上使用注解实现增强的操作
在增强的类上使用注解完成aop操作
在类上加@Aspect
在方法上加真正的注解
@Before 前置通知
@AfterReturning 后置通知
@Around 环绕通知
@AfterThrowing 抛出通知
@After 最终通知
value属性值为原来的表达式的值
(表达式写法需要注意)
其它项目不用时请将其关闭！
package cn.aop;
public class Book {
public void buy(){
System.out.println("Book.buy");
}
}
package cn.aop;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
@Aspect
public class BuyBook {
//方法上使用注解完成真正的增强操作
@Before(value="execution(* cn.aop.Book.*(..))")
public void before1(){
System.out.println("BuyBook.before");
}
}
二、jdbcTemplate操作
spring是一站式的框架，对应javaEE三层框架都有不同的解决方案，jdbcTemplate就是对应于DAO层的
spring对不同的持久化层技术都作了不同的支持
JDBC === jdbcTemplate
Hibernate === HibernateTemplate （少写很多的操作）
MyBatis JPA等都有不同的支持
jdbcTemplate使用(CRUD操作)和DBUtils比较类似（但是并没有DBUtils方便，只是jdbc模板是spring封装好的）
具体的使用：
准备工作：
导包：spring-jdbc spring-tx(事务)
说到数据库，当然少不了最最最基本驱动jar包
添加：
依赖连接池获得连接，创建对象，设置数据库信息
创建jdbcTemplate对象，设置数据源
建表
使用jdbcTemplate实现操作（和DBUtils是非常像的）
增加修改在类中，删除不再赘述，只是SQL语句的差异
当然，具体的信息可以通过log4j看到（待补充log4j的详细用法）
package cn.jdbc;
import org.junit.Test;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.datasource.DriverManagerDataSource;
public class JDBCDemo01 {
@Test
public void add(){
//创建对象，设置数据库信息
DriverManagerDataSource dataSource = new DriverManagerDataSource();
dataSource.setDriverClassName("com.mysql.jdbc.Driver");
//本机时可以写成jdbc:mysql:///mydb
dataSource.setUrl("jdbc:mysql://localhost:3306/mydb");
dataSource.setUsername("root");
dataSource.setPassword("root");
//创建jdbcTemplate对象，设置数据源
JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);
//使用jdbcTemplate实现操作(已经建表)
String sql = "insert into user values(?,?)";
//注意使用的方法,dbutils调的也是update方法，参数是SQL和可变参数
int i = jdbcTemplate.update(sql, "lulu","123");
System.out.println(i);
}
//测试模板的修改方法，这是SQL语句的方法
@Test
public void update(){
//创建对象，设置数据库信息
DriverManagerDataSource dataSource = new DriverManagerDataSource();
dataSource.setDriverClassName("com.mysql.jdbc.Driver");
//本机时可以写成jdbc:mysql:///mydb
dataSource.setUrl("jdbc:mysql://localhost:3306/mydb");
dataSource.setUsername("root");
dataSource.setPassword("root");
//创建jdbcTemplate对象，设置数据源
JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);
String sql = "update user set username=? where username=?";
int i = jdbcTemplate.update(sql, "lucy","lulu");
System.out.println(i);
}
}
*查询：查询是重点
（QueryRunner runner = new QueryRunner(dataSource);
runner.query(sql,new BeanHandler<User>(User.class));
具体的ResultSetHandler可参考DBUtils部分）
使用jdbcTemplate实现查询时，有接口RowMapper,但没有像dbutils一样提供实现类
需要自己提供实现类（学习这个的目的不是为了更加方便，而是一般的，如果允许，尽量使用少的技术）
回顾JDBC底层实现查询结果，将结果集封装到对象中
查询的具体实现：
1.返回某一个值
queryForObject(sql, requiredType) 返回类型，如Integer.class(统计记录数)
2.返回一个对象
jdbcTemplate.queryForObject(sql, rowMapper, args)
第二个是结果集的处理，第三个是可变参数
第二个接口可以写匿名内部类，当然也可以单独写个类（更直观）
RowMapper实现类
class MyRowMapper implements RowMapper<User>{
public User mapRow(ResultSet arg0, int arg1) throws SQLException {
第二个 int arg1 表示行号（结果集的行号）
return null;
3.返回一个集合
jdbcTemplate.query(sql, rowMapper, args)
第三个是可变参数(当然有可省略的重载方法)，返回的是集合
数据封装也要自己写
给出一个Demo如下(注意最后给出的实现类)：
package cn.jdbc;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.List;
import org.junit.Test;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.jdbc.datasource.DriverManagerDataSource;
public class JDBCDemo02 {
//演示查询返回某个值
@Test
public void count(){
//创建对象，设置数据库信息
DriverManagerDataSource dataSource = new DriverManagerDataSource();
dataSource.setDriverClassName("com.mysql.jdbc.Driver");
//本机时可以写成jdbc:mysql:///mydb
dataSource.setUrl("jdbc:mysql://localhost:3306/mydb");
dataSource.setUsername("root");
dataSource.setPassword("root");
//创建jdbcTemplate对象，设置数据源
JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);
String sql = "SELECT COUNT(*) FROM user";
Integer i = jdbcTemplate.queryForObject(sql, Integer.class);
System.out.println(i);
}
//演示返回对象
@Test
public void obj(){
//创建对象，设置数据库信息
DriverManagerDataSource dataSource = new DriverManagerDataSource();
dataSource.setDriverClassName("com.mysql.jdbc.Driver");
//本机时可以写成jdbc:mysql:///mydb
dataSource.setUrl("jdbc:mysql://localhost:3306/mydb");
dataSource.setUsername("root");
dataSource.setPassword("root");
//创建jdbcTemplate对象，设置数据源
JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);
String sql = "select * from user where username=?";
//和dbutils类似，也是new一个处理器，不过这里需要自己实现
User user = jdbcTemplate.queryForObject(sql, new MyRowMapper(), "mary");
System.out.println(user);
}
//返回对象集合
@Test
public void objlist(){
//创建对象，设置数据库信息
DriverManagerDataSource dataSource = new DriverManagerDataSource();
dataSource.setDriverClassName("com.mysql.jdbc.Driver");
//本机时可以写成jdbc:mysql:///mydb
dataSource.setUrl("jdbc:mysql://localhost:3306/mydb");
dataSource.setUsername("root");
dataSource.setPassword("root");
//创建jdbcTemplate对象，设置数据源
JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);
String sql = "select * from user";
List<User> list = jdbcTemplate.query(sql, new MyRowMapper());
for (User user : list) {
System.out.println(user.getUsername());
}
}
}
//属性封装需要自己实现
class MyRowMapper implements RowMapper<User>{
public User mapRow(ResultSet rs, int num) throws SQLException {
String username = rs.getString("username");//使用索引更高效
String password = rs.getString("password");
User user = new User();
user.setUsername(username);
user.setPassword(password);
return user;
}
}
三、spring配置连接池和dao使用jdbcTemplate:
导包：
c3p0的两个jar包 c3p0 和依赖包 mchange
在配置连接池（原始方式见数据库连接池部分）
ComboPooledDataSource这个类本身里面就有属性和相关的set()方法
可以使用之前学的属性注入！属性注入注入的属性就是参考set()方法命名规范
bean1.xml配置文件：
可以创建service dao 进行稍微正式的测试，顺便复习属性注入
给JdbcTemplate需要传入dataSource ,需要注意注意这个
service注入dao
dao注入jdbcTemplate
jdbcTemplate注入dataSource
<?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-4.3.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd"> <!-- 配置c3p0连接池 --> <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"> <!-- 进行属性注入 --> <property name="driverClass" value="com.mysql.jdbc.Driver"></property> <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/mydb"></property> <property name="user" value="root"></property> <property name="password" value="root"></property> </bean> <!-- 在配置中配置依赖注入 --> <bean id="userService" class="cn.c3p0.UserService"> <!-- service中注入dao --> <property name="dao" ref="dao"></property> </bean> <bean id="dao" class="cn.c3p0.UserDao"> <!-- dao中注入jdbcTemplate --> <property name="jdbcTemplate" ref="jdbcTemplate"></property> </bean> <!-- 创建模板对象 --> <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate"> <!-- 给模板注入dataSource，具体可以看源码了解（set()方法等） --> <property name="dataSource" ref="dataSource"></property> </bean> </beans>
UserDao:
package cn.c3p0;
import org.springframework.jdbc.core.JdbcTemplate;
public class UserDao {
private JdbcTemplate jdbcTemplate;
public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
this.jdbcTemplate = jdbcTemplate;
}
public void add() {
//在这里使用jdbcTemplate new模板对象的过程都交给spring
String sql = "insert into user values(?,?)";
int i = jdbcTemplate.update(sql, "lilei","112");
System.out.println(i);
}
}
UserService:
package cn.c3p0;
public class UserService {
private UserDao dao;
public void setDao(UserDao dao) {
this.dao = dao;
}
public void add(){
System.out.println("service.add");
dao.add();
}
}
四、spring的事务管理
（不用像之前Hibernate一样写大堆的事务的代码）
事务的回顾见JDBC部分
事务的概念
事务的特性
事务的隔离性产生的问题
spring的事务管理主要有两种方式：
1.编程式事务管理（自己写代码，用的少）
2.声明式事务管理（配置文件实现，注解方式实现(简单易用)）
相关的API：
PlatformTransactionManager :spring的事务管理器接口，为不同的持久化框架提供了不同的实现类
例如模板的实现类：dataSourceTransactionManager
Hibernate的实现类：HibernateTransactionManager
无论注解还是配置文件都要配置事务管理器
搭建转账的环境演示事务管理的操作：
建表，添加一些数据
创建service和dao以及注入关系的完成（区分业务层和持久层的区别，业务层只处理业务，持久层只和数据库打交道）
Service:
package cn.acount;
import org.springframework.transaction.annotation.Transactional;
@Transactional
public class AcountService {
private AcountDao dao;
public void setDao(AcountDao dao) {
this.dao = dao;
}
//service调dao的方法完成逻辑
public void acountMoney(){
dao.decrese();
//int i = 1/0;
dao.increse();
}
}
Dao:
package cn.acount;
import org.springframework.jdbc.core.JdbcTemplate;
public class AcountDao {
private JdbcTemplate jdbcTemplate;
public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
this.jdbcTemplate = jdbcTemplate;
}
//减少钱的方法
public void decrese(){
String sql = "update acount set money=money+? where name=?";
jdbcTemplate.update(sql, -1000,"小王");
}
//增加钱的方法
public void increse(){
String sql = "update acount set money=money+? where name=?";
jdbcTemplate.update(sql, 1000,"小李");
}
}
bean2.xml 要引入事务的操作的约束！
一般以后引入四个约束 beans context aop tx 示例见bean2.xml
可以测试无事务操作时可以正确执行
声明式的事务管理：
xml实现：
（使用的是aop的思想）（jdbc的源码查看dataSourceTransactionManager）
bean2.xml
<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop" xmlns:context="http://www.springframework.org/schema/context" xmlns:tx="http://www.springframework.org/schema/tx" xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.3.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd"> <!-- 配置c3p0连接池 --> <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"> <!-- 进行属性注入 --> <property name="driverClass" value="com.mysql.jdbc.Driver"></property> <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/mydb"></property> <property name="user" value="root"></property> <property name="password" value="root"></property> </bean> <!-- 配置service对象 --> <bean id="acountService" class="cn.acount.AcountService"> <!-- service中注入dao --> <property name="dao" ref="dao"></property> </bean> <!-- 配置dao对象 --> <bean id="dao" class="cn.acount.AcountDao"> <!-- dao中注入模板 --> <property name="jdbcTemplate" ref="jdbcTemplate"></property> </bean> <!-- 创建模板对象 --> <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate"> <!-- 模板中注入dataSource --> <property name="dataSource" ref="dataSource"></property> </bean> <!-- 事务的配置实现 --> <!-- 1.配置事务管理器 --> <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager"> <!-- 注入dataSource --> <property name="dataSource" ref="dataSource"></property> </bean> <!-- 2.配置事务增强 ，需要指定事务管理器--> <tx:advice id="txadvice" transaction-manager="transactionManager"> <!-- 做事务操作 --> <tx:attributes> <!-- 设置进行事务操作的方法匹配规则 --> <tx:method name="acount*" propagation="REQUIRED"/> </tx:attributes> </tx:advice> <!-- 3.配置切面 --> <aop:config> <!-- 3.1切入点 --> <aop:pointcut expression="execution(* cn.acount.AcountService.*(...))" id="pointcut1"/> <!-- 3.2切面 --> <aop:advisor advice-ref="txadvice" pointcut-ref="pointcut1"/> </aop:config> </beans>
进行一个简单的测试：
package cn.acount;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class Test01 {
@Test
public void test(){
ApplicationContext context =
new ClassPathXmlApplicationContext("bean2.xml");
AcountService service = (AcountService) context.getBean("acountService");
service.acountMoney();
}
}
注解实现：
配置事务管理器
配置开启注解的操作
在要使用事务的方法所在的类上添加注解@Transactional
会自动找到@注解后对类里的所有方法进行事务操作
此时的配置文件如下：
bean4.xml:
<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop" xmlns:context="http://www.springframework.org/schema/context" xmlns:tx="http://www.springframework.org/schema/tx" xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.3.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd"> <!-- 配置c3p0连接池 --> <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"> <!-- 进行属性注入 --> <property name="driverClass" value="com.mysql.jdbc.Driver"></property> <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/mydb"></property> <property name="user" value="root"></property> <property name="password" value="root"></property> </bean> <!-- 配置事务管理器--> <!-- 1.配置事务管理器 --> <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager"> <!-- 注入dataSource --> <property name="dataSource" ref="dataSource"></property> </bean> <!-- 开启事务的注解 ，指定事务管理器--> <tx:annotation-driven transaction-manager="transactionManager"/> <!-- 配置service对象 --> <bean id="acountService" class="cn.acount.AcountService"> <!-- service中注入dao --> <property name="dao" ref="dao"></property> </bean> <!-- 配置dao对象 --> <bean id="dao" class="cn.acount.AcountDao"> <!-- dao中注入模板 --> <property name="jdbcTemplate" ref="jdbcTemplate"></property> </bean> <!-- 创建模板对象 --> <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate"> <!-- 模板中注入dataSource --> <property name="dataSource" ref="dataSource"></property> </bean> </beans>
在类上加注解：完整的类信息见xml配置实现
@Transactional
public class AcountService {
Spring第三天——JdbcTemplate和spring事务管理
标签：classpath line source 环境 private 事务 管理 管理器 lap
热心网友
记录日志后再抛出异常
protected <T> int executeUpdate(String sql, Object[] params, Class<T> clazz) {Logger log = Logger.getLogger(clazz);
int result = 0；
try {
result = jdbc.update(sql, params);
} catch (DataAccessException e) {
log.error(clazz + e.getMessage(), e);
throw e;
}
return result；
}
把DAO的异常最后仍交由Spring-tx处理，这样跟是否catch过就没差了。
另外我还改了一下return的方式。
