Spring声明式事务（AOP的tx方式）

最新推荐文章于 2024-03-13 10:24:30 发布
最新推荐文章于 2024-03-13 10:24:30 发布
阅读量1.4k 收藏
点赞数
分类专栏： Spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Victor_Cindy1/article/details/51064677
版权

类似于上一篇，这里使用tx的方式来配置。

服务类StudentService.java代码如下：

package com.mysrc.service;

import java.sql.Date;
import java.util.List;

import com.mysrc.dao.StudentDao;
import com.mysrc.entity.Student;

public class StudentService {
	private StudentDao dao;

	public void setDao(StudentDao dao) {
		this.dao = dao;
	}

	public void doComplexLogic() {

		// select
		List<Student> list = dao.getAllStudent();
		for (Student student : list) {
			System.out.println(student);
		}

		// update
		Student student = list.get(0);
		student.setName("laohu..");
		dao.updateStudent(student);
		System.out.println("did update temporarily...");

		//int a = 9 / 0; // 遇到异常，整个事务回滚，也即上面的update不会成功
		// 如果try catch捕获这个异常，那整个事务会顺利执行，不会回滚
		
		int b = 2;
		if (b > 1) {
			throw new CustomRuntimeException();
			// 事务不会回滚，也就是上面的update操作会提交
		}

		// insert
		student = new Student();
		student.setName("hello");
		student.setBirth(new Date(354778));
		student.setScore(78.9f);
		dao.addStudent(student);
		System.out.println("did insert...");

		// delete
		dao.deleteStudent(3);
		System.out.println("did delete...");
	}

}

这里doComplexLogic()方法上不再有注解修饰了。
Spring的应用程序上下文配置文件applicationContext.xml的内容为： 

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:aop="http://www.springframework.org/schema/aop" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns:p="http://www.springframework.org/schema/p"
	xsi:schemaLocation="http://www.springframework.org/schema/aop   
    http://www.springframework.org/schema/aop/spring-aop-2.5.xsd 
    http://www.springframework.org/schema/beans 
    http://www.springframework.org/schema/beans/spring-beans-3.0.xsd 
    http://www.springframework.org/schema/tx 
    http://www.springframework.org/schema/tx/spring-tx.xsd"
	xmlns:tx="http://www.springframework.org/schema/tx">

	<bean id="basicDataSource" class="org.apache.commons.dbcp.BasicDataSource">
		<property name="url"
			value="jdbc:mysql://127.0.0.1:3306/mytestdb?characterEncoding=utf8" />
		<property name="driverClassName" value="com.mysql.jdbc.Driver" />
		<property name="username" value="root" />
		<property name="password" value="123456" />
		<property name="maxActive" value="100" />
		<property name="maxIdle" value="30" />
		<property name="maxWait" value="1000" />
		<property name="validationQuery" value="select 1" />
	</bean>
	<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
		<constructor-arg name="dataSource" ref="basicDataSource">
		</constructor-arg>
	</bean>
	<bean id="transactionManager"
		class="org.springframework.jdbc.datasource.DataSourceTransactionManager ">
		<property name="dataSource">
			<ref bean="basicDataSource" />
		</property>
	</bean>

	<bean id="studentDao" class="com.mysrc.dao.StudentDao">
		<property name="jdbcTemplate">
			<ref bean="jdbcTemplate" />
		</property>
	</bean>

	<bean id="studentService" class="com.mysrc.service.StudentService">
		<property name="dao">
			<ref bean="studentDao" />
		</property>
	</bean>

	<tx:advice id="txAdvice" transaction-manager="transactionManager">
		<tx:attributes>
			<tx:method name="add*" propagation="REQUIRED" />
			<tx:method name="del*" propagation="REQUIRED" />
			<tx:method name="update*" propagation="REQUIRED" />
			<tx:method name="get*" propagation="NOT_SUPPORTED"
				read-only="true" />
			<tx:method name="doComplexLogic" propagation="NESTED"
				isolation="REPEATABLE_READ" timeout="1000" rollback-for="java.lang.Exception"
				no-rollback-for="com.mysrc.service.CustomRuntimeException" />
		</tx:attributes>
	</tx:advice>

	<!-- Spring AOP config -->
	<aop:config>
		<!-- 切入点 -->
		<aop:pointcut id="studentServicesPointcut"
			expression="execution(* com.mysrc.service.StudentService.*(..))" />
		<!-- <aop:pointcut id="newServicesPointcut2" expression="execution(* com.model.*.*(..))" 
			/> -->
		<aop:advisor advice-ref="txAdvice" pointcut-ref="studentServicesPointcut" />
		<!-- <aop:advisor advice-ref="txAdvice" pointcut-ref="newServicesPointcut2" 
			/> -->
	</aop:config>

</beans>


顺便介绍一下Spring中jdbcTemplate的用法实例

要使用Jdbctemplate 对象来完成jdbc 操作。通常情况下，有三种种方式得到JdbcTemplate 对象。 
      第一种方式：我们可以在自己定义的DAO 实现类中注入一个DataSource 引用来完 成JdbcTemplate 的实例化。也就是它是从外部“注入” DataSource 到DAO 中，然后 自己实例化JdbcTemplate，然后将DataSource 设置到JdbcTemplate 对象中。 
      第二种方式： 在 Spring 的 IoC 容器中配置一个 JdbcTemplate 的 bean，将 DataSource 注入进来，然后再把JdbcTemplate 注入到自定义DAO 中。 
      第三种方式: Spring 提供了 org.springframework.jdbc.core.support.JdbcDaoSupport 类 ， 这 个 类 中 定 义 了 JdbcTemplate 属性，也定义了DataSource 属性，当设置DataSource 属性的时候，会创 建jdbcTemplate 的实例，所以我们自己编写的DAO 只需要继承JdbcDaoSupport 类， 然后注入DataSource 即可。

 /**   
     * 创建表  
     */   
    public void create(String tableName){ //tb_test1  
        jdbcTemplate.execute("create table "+tableName +" (id integer,user_name varchar2(40),password varchar2(40))");  
    }  
      
    //jdbcTemplate.update适合于insert 、update和delete操作；  
    /**   
     * 第一个参数为执行sql   
     * 第二个参数为参数数据   
     */   
    public void save3(User user) {  
        Assert.isNull(user, "user is not null");  
        jdbcTemplate.update("insert into tb_test1(name,password) values(?,?)",   
                new Object[]{user.getUsername(),user.getPassword()});  
    }  
      
    /**   
     * 第一个参数为执行sql   
     * 第二个参数为参数数据   
     * 第三个参数为参数类型   
     */   
    @Override  
    public void save(User user) {  
        Assert.isNull(user, "user is not null");  
        jdbcTemplate.update(  
                "insert into tb_test1(name,password) values(?,?)",   
                new Object[]{user.getUsername(),user.getPassword()},   
                new int[]{java.sql.Types.VARCHAR,java.sql.Types.VARCHAR}  
                );  
    }  
  
    //避免sql注入  
    public void save2(final User user) {  
        Assert.isNull(user, "user is not null");  
          
        jdbcTemplate.update("insert into tb_test1(name,password) values(?,?)",   
                new PreparedStatementSetter(){  
              
                    @Override  
                    public void setValues(PreparedStatement ps) throws SQLException {  
                        ps.setString(1, user.getUsername());  
                        ps.setString(2, user.getPassword());  
                    }  
        });  
          
    }  
      
    public void save4(User user) {  
        Assert.isNull(user, "user is not null");  
        jdbcTemplate.update("insert into tb_test1(name,password) values(?,?)",   
                             new Object[]{user.getUsername(),user.getPassword()});  
    }  
      
    //返回插入的主键  
    public List save5(final User user) {  
          
        KeyHolder keyHolder = new GeneratedKeyHolder();  
  
        jdbcTemplate.update(new PreparedStatementCreator() {  
                      
                                @Override  
                                public PreparedStatement createPreparedStatement(Connection connection) throws SQLException {  
                                    PreparedStatement ps = connection.prepareStatement("insert into tb_test1(name,password) values(?,?)", new String[] {"id"});  
                                    ps.setString(1, user.getUsername());  
                                    ps.setString(2, user.getPassword());  
                                    return ps;  
                                }  
                            },  
                keyHolder);  
          
        return keyHolder.getKeyList();  
    }  
      
    @Override  
    public void update(final User user) {  
        jdbcTemplate.update(  
                "update tb_test1 set name=？,password=？ where id = ?",   
                new PreparedStatementSetter(){  
                    @Override  
                    public void setValues(PreparedStatement ps) throws SQLException {  
                        ps.setString(1, user.getUsername());  
                        ps.setString(2, user.getPassword());  
                        ps.setInt(3, user.getId());  
                    }  
                }  
        );  
    }  
  
    @Override  
    public void delete(User user) {  
        Assert.isNull(user, "user is not null");  
        jdbcTemplate.update(  
                "delete from tb_test1 where id = ?",   
                new Object[]{user.getId()},   
                new int[]{java.sql.Types.INTEGER});  
    }  
  
    @Deprecated //因为没有查询条件，所以用处不大  
    public int queryForInt1(){  
        return jdbcTemplate.queryForInt("select count(0) from tb_test1");  
    }  
      
    public int queryForInt2(User user){  
        return jdbcTemplate.queryForInt("select count(0) from tb_test1 where username = ?" ,  
                new Object[]{user.getUsername()});  
    }  
      
    //最全的参数3个  
    public int queryForInt3(User user){  
        return jdbcTemplate.queryForInt("select count(0) from tb_test1 where username = ?" ,  
                new Object[]{user.getUsername()},  
                new int[]{java.sql.Types.VARCHAR});  
    }  
      
    //可以返回是一个基本类型的值  
    @Deprecated  //因为没有查询条件，所以用处不大  
    public String queryForObject1(User user) {  
        return (String) jdbcTemplate.queryForObject("select username from tb_test1 where id = 100",  
                                                    String.class);  
    }  
      
    //可以返回值是一个对象  
    @Deprecated //因为没有查询条件，所以用处不大  
    public User queryForObject2(User user) {  
        return (User) jdbcTemplate.queryForObject("select * from tb_test1 where id = 100", User.class); //class是结果数据的java类型  
    }  
      
    @Deprecated //因为没有查询条件，所以用处不大  
    public User queryForObject3(User user) {  
        return (User) jdbcTemplate.queryForObject("select * from tb_test1 where id = 100",   
                    new RowMapper(){  
      
                        @Override  
                        public Object mapRow(ResultSet rs, int rowNum)throws SQLException {  
                            User user  = new User();  
                            user.setId(rs.getInt("id"));  
                            user.setUsername(rs.getString("username"));  
                            user.setPassword(rs.getString("password"));  
                            return user;  
                        }  
                    }  
        );   
    }  
      
    public User queryForObject4(User user) {  
        return (User) jdbcTemplate.queryForObject("select * from tb_test1 where id = ?",   
                                                    new Object[]{user.getId()},  
                                                    User.class); //class是结果数据的java类型  实际上这里是做反射，将查询的结果和User进行对应复制  
    }  
      
    public User queryForObject5(User user) {  
        return (User) jdbcTemplate.queryForObject(  
                "select * from tb_test1 where id = ?",   
                new Object[]{user.getId()},  
                new RowMapper(){  
  
                    @Override  
                    public Object mapRow(ResultSet rs,int rowNum)throws SQLException {  
                        User user  = new User();  
                        user.setId(rs.getInt("id"));  
                        user.setUsername(rs.getString("username"));  
                        user.setPassword(rs.getString("password"));  
                        return user;  
                    }  
              
        }); //class是结果数据的java类型  
    }  
      
    @Override  
    public User queryForObject(User user) {  
        //方法有返回值  
        return (User) jdbcTemplate.queryForObject("select * from tb_test1 where id = ?",  
                new Object[]{user.getId()},  
                new int[]{java.sql.Types.INTEGER},   
                new RowMapper() {  
              
                    @Override  
                    public Object mapRow(ResultSet rs, int rowNum) throws SQLException {  
                        User user  = new User();  
                        user.setId(rs.getInt("id"));  
                        user.setUsername(rs.getString("username"));  
                        user.setPassword(rs.getString("password"));  
                        return user;  
                    }  
                }  
        );  
    }  
  
    @SuppressWarnings("unchecked")  
    public List<User> queryForList1(User user) {  
        return (List<User>) jdbcTemplate.queryForList("select * from tb_test1 where username = ?",   
                            new Object[]{user.getUsername()},  
                            User.class);  
    }  
  
    @SuppressWarnings("unchecked")  
    public List<String> queryForList2(User user) {  
        return (List<String>) jdbcTemplate.queryForList("select username from tb_test1 where sex = ?",   
                            new Object[]{user.getSex()},  
                            String.class);  
    }  
      
    @SuppressWarnings("unchecked")  
    //最全的参数查询  
    public List<User> queryForList3(User user) {  
        return (List<User>) jdbcTemplate.queryForList("select * from tb_test1 where username = ?",  
                            new Object[]{user.getUsername()},  
                            new int[]{java.sql.Types.VARCHAR},  
                            User.class);  
    }  
  
    //通过RowCallbackHandler对Select语句得到的每行记录进行解析，并为其创建一个User数据对象。实现了手动的OR映射。  
    public User queryUserById4(String id){  
        final User user  = new User();  
          
        //该方法返回值为void  
        this.jdbcTemplate.query("select * from tb_test1 where id = ?",   
                new Object[] { id },   
                new RowCallbackHandler() {     
              
                    @Override    
                    public void processRow(ResultSet rs) throws SQLException {     
                        User user  = new User();  
            user.setId(rs.getInt("id"));  
            user.setUsername(rs.getString("username"));  
            user.setPassword(rs.getString("password"));    
                    }     
        });   
          
        return user;     
    }  
      
    @SuppressWarnings("unchecked")  
    @Override  
    public List<User> list(User user) {  
        return jdbcTemplate.query("select * from tb_test1 where username like '%?%'",   
                new Object[]{user.getUsername()},   
                new int[]{java.sql.Types.VARCHAR},   
                new RowMapper(){  
              
                    @Override  
                    public Object mapRow(ResultSet rs, int rowNum) throws SQLException {  
                        User user  = new User();  
                        user.setId(rs.getInt("id"));  
                        user.setUsername(rs.getString("username"));  
                        user.setPassword(rs.getString("password"));  
                        return user;  
                    }  
        });  
    }  
  
    //批量操作    适合于增、删、改操作  
    public int[] batchUpdate(final List users) {  
          
        int[] updateCounts = jdbcTemplate.batchUpdate(  
                "update tb_test1 set username = ?, password = ? where id = ?",  
                new BatchPreparedStatementSetter() {  
                      
                        @Override  
                        public void setValues(PreparedStatement ps, int i) throws SQLException {  
                            ps.setString(1, ((User)users.get(i)).getUsername());  
                            ps.setString(2, ((User)users.get(i)).getPassword());  
                            ps.setLong(3, ((User)users.get(i)).getId());  
                        }  
                          
                        @Override  
                        public int getBatchSize() {  
                            return users.size();  
                        }  
                }   
        );  
          
        return updateCounts;  
    }  
      
    //调用存储过程  
    public void callProcedure(int id){  
        this.jdbcTemplate.update("call SUPPORT.REFRESH_USERS_SUMMARY(?)", new Object[]{Long.valueOf(id)});  
}

也可以参考这篇：http://blog.csdn.net/dyllove98/article/details/7772463

西楚小羽的窝窝
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
spring声明式事务.zip
08-19
本文将深入探讨Spring声明式事务的实现机制、优缺点以及如何在实际项目中进行配置和使用。 1. **声明式事务管理概述** 声明式事务管理与编程式事务管理相对，后者需要开发者在代码中显式调用开始、提交、回滚等...
Spring AOP中Pointcut,dvice 和 Advisor三个概念
03-28 228
（1）切入点 Pointcut 在介绍Pointcut之前，有必要先介绍 Join Point（连接点）概念。 连接点：程序运行中的某个阶段点，比如方法的调用、异常的抛出等。比如方法doSome(); 　　　　　　　　　Pointcut是JoinPoint的集合，它是程序中需要注入Advice 的位...
spring IPC, AOP,TX
qq_28772075的博客
08-15 268
tx:事务控制，哪些失效，哪些不失效 1 spring aop顺序 1.1 AOP常用注解 @Before：前置通知：目标方法之前执行 @After：后置通知：目标方法之后执行（始终执行） @AfterrReturning：返回后通知：执行方法结束前执行（异常不执行） @AfterThrowing：异常通知：出现异常时执行 @Around：环绕通知：环绕目标方法执行 1.2 面试题 1.3 业务类 1.3.1 接口CalcService 1.3.2 接口实现类CalcService
Spring -- spring结合aop 进行 tx&aspectj事务管理配置方法
kevin_xiang的专栏
03-14 1581
1. tx 配置方法， 代码示例 javabean及其映射文件省略，和上篇的一样 CustomerDao.java， dao层接口 public interface CustomerDao { public void insertCustomer(Customer c); public void updateCustomer(Customer c); public List fi
spring声明式事务管理方式( 基于tx和aop名字空间的xml配置+@Transactional注解)
niceyoo的博客
04-07 523
1. 声明式事务管理分类 声明式事务管理也有两种常用的方式， 一种是基于tx和aop名字空间的xml配置文件，另一种就是基于@Transactional注解。 显然基于注解的方式更简单易用，更清爽。 2. spring事务特性 spring所有的事务管理策略类都继承自org.springframework.transaction.PlatformTransactionMa...
AOP的详解
最新发布
一个想交朋友的陌生人
03-13 1288
aop
使用Spring的声明式事务----AOP方式
08-06
在Spring框架中，声明式事务管理是通过AOP（面向切面编程）实现的，它为开发者提供了方便、高效且灵活的事务管理机制。本文将深入探讨如何利用Spring的声明式事务来处理业务操作中的数据一致性问题，以及相关源码...
spring声明式事务管理配置方式
04-13
在"spring声明式事务管理配置方式"中，主要涉及到以下几个关键知识点： 1. **Spring事务管理器（Transaction Manager）**： - Spring支持多种事务管理器，如DataSourceTransactionManager（用于JDBC事务）和...
Spring编程式和声明式事务实例讲解小结
08-25
* 基于TransactionInterceptor的声明式事务：Spring声明式事务的基础，通常也不建议使用这种方式。 * 基于TransactionProxyFactoryBean的声明式事务：第一种方式的改进版本，简化了配置文件的书写。 * 基于<tx>和...
Spring aop、jdbc和事务tx练习
11-08
声明式事务管理允许开发者在配置文件中声明哪些方法需要在事务中运行，而无需在代码中显式管理开始和结束事务。这通常通过@Transactional注解实现，可以应用于类或方法级别。编程式事务管理则需要在代码中手动调用...
Spring4.x 笔记（14）：Spring 声明式 Aop
Sam Blog
05-17 405
文章目录声明式 Aop 实现基于AspectJ注解实现基于Schema标签实现基于注解的 Advice注解Advice详解说明前置- @Before后置- @AfterReturning环绕- @Around异常抛出- @AfterThrowingFinal- @After引介- @DeclareParentsAdvice 的顺序切点表达式函数详解常用函数以及用法@annotationexecut...
基于AOP/TX来实现事务操作
Jitwxs
07-19 494
使用XML配置事务 新建一个UserDao.java，如下： package com.cstor.dao; import org.springframework.jdbc.core.JdbcTemplate; public class AccountDao { private JdbcTemplate jdbcTemplate; static String sql; ...
spring--声明式事务（aop）
qq_42022411的博客
02-26 140
为了之后可以方便使用事务，将aop实现的事务，写于此处，避免日后出错！！ 修改的具体内容为： 在web.xml中配置: 添加和删除一组用户 完整代码： 依赖为 <dependencies> <dependency> <groupId>org.projectlombok</groupId> ...
[Spring]AOP应用及简单案例——声明式事务
言兼小师傅的博客
09-10 473
既然事务控制的代码有规律可循，代码的结构基本是确定的，所以框架就可以将固定模式的代码抽取出来，进行相关的封装。
Spring事务管理器配置两种配置方法，使用方法
Stardust_fantasy的博客
06-14 3733
事务管理器配置两种配置方法，使用方法
Spring 事务管理tx,aop
weixin_30786617的博客
05-29 167
spring tx:advice事务配置 2016年12月21日 17:27:22 阅读数：7629 http://www.cnblogs.com/rushoooooo/archive/2011/08/28/2155960.html 链接归纳的很详细。 首先在/WEB-INF/applicationContext.xml添加以下内容： &l...
基于tx/aop命名空间的spring声明式事务管理
Or1n_559的博客
10-24 1979
我们知道，spring声明式事务管理有两种方式：1、使用tx/aop命名空间XML配置文件式的方式 ；2、使用@Transactional注解的方式。 在本文中，我将会介绍第一种方式配置spring声明式事务管理。 首先，在我们使用spring声明式管理前，我们需要导入几个相关的jar包： 下面我们先编写我们的application.xml文件：<?xml vers
Spring基于tx/aop声明式事务配置
热门推荐
林荣章的博客
09-09 1万+
一、引入aop/tx命名空间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"
spring学习笔记(23)基于tx/aop配置切面增强事务
weixin_33782386的博客
03-26 191
在上一篇文章中，我们使用了声明式事务来配置事务，使事务配置从service逻辑处理中解耦出来。但它还存在一些缺点: 1. 我们只针对方法名的特定进行拦截，但无法利用方法签名的其它信息定位，如修饰符、返回值、方法入参、异常类型等。如果我们需要为同名不同参的同载方法配置不同事务就会出问题了。 2. 事务属性的配置串虽然能包含较多信息，但...
spring声明式事务配置方法.docx
04-16
Spring 声明式事务配置是指在 Spring 框架中通过配置文件或注解的方式来管理事务的提交和回滚。这种配置方法可以使得事务管理变得更加灵活和可靠。 TransactionProxyFactoryBean 方式是 Spring 中的一种声明式事务...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值