Spring事务

一、Spring事务接口

spring事务提供了三个主要的接口PlatformTransactionManager、TransactionDefination定义事务隔离级别、TransactionDefination定义事务传播行为、TransactionStatus接口。

PlatformTransactionManager：事务管理器。

TransactionDefination：定义事务隔离级别：READ_UNCOMMITED、READ_COMMITTED、REPEATABLE_READ、SERIALIZABLE。mysql数据库默认的是REPEATABLE_READ级别4.

TransactionDefination：定义事务传播行为：PROPAGATION_REQUIRED、PROPAGATION_SUPPORTS、PROPAGATION_MANDATORY、PROPAGATION_REQUIRES_REW、PROPAGATION_NOT_SUPPORTED、PROPAGATION_NEVER、PROPAGATION_NESTED等

二、spring事务管理--转账案例

2.1、环境搭建

    引入相关jar包、jdbc.properties、log4j.properties等

    AccountService接口、AccountServiceImpl实现类

    AccountDao接口、AccountDaoImpl实现类

AccountService.java接口

  1: package com.spring.demo1;

  2: 

  3: public interface AccountService {

  4:   public void transfer(String OutName,String InName,Double money);

  5: }

  6: 

AccountDao.java接口：

  1: package com.spring.demo1;

  2: public interface AccountDao {

  3:   public void outMoney(String OutName,Double money);

  4:   public void inMoney(String InName,Double money);

  5: }

  6: 

AccountDaoImpl.java

  1: package com.spring.demo1;

  2: 

  3: import org.springframework.jdbc.core.support.JdbcDaoSupport;

  4: public class AccountDaoImpl extends JdbcDaoSupport implements AccountDao  {

  5: 

  6:   public void inMoney(String InName, Double money) {

  7:     // TODO Auto-generated method stub

  8:     String sql="update account set money=money + ? where name= ?";

  9:     this.getJdbcTemplate().update(sql,money,InName);

 10:   }

 11: 

 12:   public void outMoney(String OutName, Double money) {

 13:     // TODO Auto-generated method stub

 14:     String sql="update account set money=money - ? where name= ?";

 15:     this.getJdbcTemplate().update(sql,money,OutName);

 16:   }

 17: 

 18: }

 19: 

 

2.2、编程式事务管理

ApplicationContex.xml

  1: <?xml version="1.0" encoding="UTF-8" ?>

  2: <beans xmlns="http://www.springframework.org/schema/beans"

  3:   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"

  4:   xmlns:context="http://www.springframework.org/schema/context"

  5:   xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"

  6:   xsi:schemaLocation="http://www.springframework.org/schema/beans 

  7:        http://www.springframework.org/schema/beans/spring-beans-3.0.xsd

  8:        http://www.springframework.org/schema/context 

  9:        http://www.springframework.org/schema/context/spring-context-3.0.xsd

 10:        http://www.springframework.org/schema/tx 

 11:        http://www.springframework.org/schema/tx/spring-tx-3.0.xsd

 12:        http://www.springframework.org/schema/aop

 13:        http://www.springframework.org/schema/aop/spring-aop-3.0.xsd">

 14:     

 15:     

 16:    <!-- 引入外部的属性文件 -->

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

 18:      

 19:      <!-- 配置c3p0连接池 

 20:   <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"

 21:     p:driverClass="${jdbc.driverClass}"

 22:     p:jdbcUrl="${jdbc.url}"

 23:     p:user="${jdbc.username}"

 24:     p:password="${jdbc.password}" />-->

 25:   

 26:   <!-- 配置dbcp连接池 -->

 27:   <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource"

 28:     destroy-method="close" 

 29:     p:driverClassName="${jdbc.driverClass}"

 30:     p:url="${jdbc.url}"

 31:     p:username="${jdbc.username}"

 32:     p:password="${jdbc.password}" />

 33: 

 34:   <!-- 配置Jdbc模板  -->

 35:   <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate"

 36:     p:dataSource-ref="dataSource" />

 37:   

 38:   <!-- 业务层 -->

 39:   <bean id="accountService" class="com.spring.demo4.AccountServiceImpl" p:accountDao-ref="accountDao"/>

 40: 

 41:   <!-- Dao类 -->

 42:   <bean id="accountDao" class="com.spring.demo4.AccountDaoImpl" p:dataSource-ref="dataSource" />

 43:   

 44:   <!-- 配置事务管理器 -->

 45:   <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager" 

 46:     p:dataSource-ref="dataSource" />

 47:   

 48:   <!-- 定义一个事务管理模板 ：spring为了简化事务管理的代码而提供的类-->

 49:   <bean id="transactionTemplate" class="org.springframework.transaction.support.TransactionTemplate"

 50:     p:transactionManager-ref="transactionManager" />

 51:   

 52: </beans>

 53: 

AccountServiceImpl.java

  1: package com.spring.demo1;

  2: 

  3: import org.springframework.transaction.TransactionStatus;

  4: import org.springframework.transaction.support.TransactionCallback;

  5: import org.springframework.transaction.support.TransactionCallbackWithoutResult;

  6: import org.springframework.transaction.support.TransactionTemplate;

  7: import com.sun.istack.internal.FinalArrayList;

  8: public class AccountServiceImpl implements AccountService {

  9: 

 10:   //注入转账的DAO类

 11:   

 12:   private AccountDao accountDao;

 13:   public void setAccountDao(AccountDao accountDao) {

 14:     this.accountDao = accountDao;

 15:   }

 16:   

 17:   //注入事务管理的模板

 18:   private TransactionTemplate transactionTemplate;

 19:   public void setTransactionTemplate(TransactionTemplate transactionTemplate) {

 20:     this.transactionTemplate = transactionTemplate;

 21:   }

 22:   

 23:   public AccountDao getAccountDao() {

 24:     return accountDao;

 25:   }

 26: 

 27:   public TransactionTemplate getTransactionTemplate() {

 28:     return transactionTemplate;

 29:   }

 30: 

 31:   public void transfer(final String OutName,final String InName,final Double money) {

 32:     // TODO Auto-generated method stub

 33:     transactionTemplate.execute(new TransactionCallbackWithoutResult() {      

 34:       @Override

 35:       protected void doInTransactionWithoutResult(TransactionStatus transactionStatus) {

 36:         // TODO Auto-generated method stub

 37:         accountDao.outMoney(OutName, money);

 38:         accountDao.inMoney(InName, money);

 39:       }

 40:     });

 41:   

 42:   }

 43: 

 44: }

 45: 

测试类:springtestdemo1.java

  1: package com.spring.demo1;

  2: 

  3: import javax.annotation.Resource;

  4: import org.junit.Test;

  5: import org.junit.runner.RunWith;

  6: import org.springframework.test.context.ContextConfiguration;

  7: import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

  8: @RunWith(SpringJUnit4ClassRunner.class)

  9: @ContextConfiguration("classpath:applicationContext.xml")

 10: public class springtestdemo1 {

 11:   //测试业务层类：

 12:   @Resource(name="accountService")

 13:   private AccountService accountService;

 14:   @Test

 15:   public void demo1(){

 16:     accountService.transfer("aaa", "bbb", 200d);

 17:   }

 18: }

 19: 

运行结果：

当修改一下AccountServiceImpl.java的代码

  1: accountDao.outMoney(OutName, money);

  2: int i=1 / 0;

  3: accountDao.inMoney(InName, money);

当不引入事务管理的运行结果: 发现用户aaa已经少了300块,但是用户bbb却没有增加.

当引入事务管理的运行结果: 这时候,用户aaa和bbb不会出现不一致的情况

 

2.3、声明式事务管理方式一：TransactionProxyFactoryBean

ApplicationContext2.xml

  1: <?xml version="1.0" encoding="UTF-8" ?>

  2: <beans xmlns="http://www.springframework.org/schema/beans"

  3:   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"

  4:   xmlns:context="http://www.springframework.org/schema/context"

  5:   xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"

  6:   xsi:schemaLocation="http://www.springframework.org/schema/beans 

  7:        http://www.springframework.org/schema/beans/spring-beans-3.0.xsd

  8:        http://www.springframework.org/schema/context 

  9:        http://www.springframework.org/schema/context/spring-context-3.0.xsd

 10:        http://www.springframework.org/schema/tx 

 11:        http://www.springframework.org/schema/tx/spring-tx-3.0.xsd

 12:        http://www.springframework.org/schema/aop

 13:        http://www.springframework.org/schema/aop/spring-aop-3.0.xsd">

 14:     

 15:    <!-- 引入外部的属性文件 -->

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

 17:      

 18:      <!-- 配置c3p0连接池 

 19:   <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"

 20:     p:driverClass="${jdbc.driverClass}"

 21:     p:jdbcUrl="${jdbc.url}"

 22:     p:user="${jdbc.username}"

 23:     p:password="${jdbc.password}" />-->

 24:   

 25:   <!-- 配置dbcp连接池 -->

 26:   <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource"

 27:     destroy-method="close" 

 28:     p:driverClassName="${jdbc.driverClass}"

 29:     p:url="${jdbc.url}"

 30:     p:username="${jdbc.username}"

 31:     p:password="${jdbc.password}" />

 32: 

 33:   <!-- 配置Jdbc模板  -->

 34:   <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate"

 35:     p:dataSource-ref="dataSource" />

 36:   

 37:   <!-- 业务层 -->

 38:   <bean id="accountService" class="com.spring.demo4.AccountServiceImpl" p:accountDao-ref="accountDao"/>

 39: 

 40:   <!-- Dao类 -->

 41:   <bean id="accountDao" class="com.spring.demo4.AccountDaoImpl" p:dataSource-ref="dataSource" />

 42:   

 43:   <!-- 配置事务管理器 -->

 44:   <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager" 

 45:     p:dataSource-ref="dataSource" />

 46:   

 47:   <!-- 配置业务层的代理 -->

 48:         <!-- prop的格式：

 49:             PROPAGATION:事务的传播行为

 50:             ISOLATION : 事务的隔离级别

 51:             readOnly:   只读

 52:             -Exception :发生哪些异常，回滚事务

 53:             +Exception:发生哪些异常，事务不回滚

 54:          -->

 55:   <bean id="accountServiceProxy" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">

 56:     <!-- 配置目标对象 -->

 57:     <property name="target" ref="accountService" />

 58:     <!-- 事务事务管理器 -->

 59:     <property name="transactionManager" ref="transactionManager" />

 60:     <!-- 注入事务的一些属性 -->

 61:     <property name="transactionAttributes" >

 62:       <props>

 63:         <prop key="transfer">PROPAGATION_REQUIRED,+java.lang.ArithmeticException</prop>

 64:       </props>

 65:     </property>

 66:   </bean>  

 67: </beans>

AccountServiceImpl.java

  1: package com.spring.demo2;

  2: import org.springframework.transaction.TransactionStatus;

  3: import org.springframework.transaction.support.TransactionCallback;

  4: import org.springframework.transaction.support.TransactionCallbackWithoutResult;

  5: import org.springframework.transaction.support.TransactionTemplate;

  6: import com.sun.istack.internal.FinalArrayList;

  7: public class AccountServiceImpl implements AccountService {

  8:   //注入转账的DAO类  

  9:   private AccountDao accountDao;

 10:   public void setAccountDao(AccountDao accountDao) {

 11:     this.accountDao = accountDao;

 12:   }    

 13:   public void transfer(String OutName, String InName, Double money) {

 14:     // TODO Auto-generated method stub

 15:     accountDao.outMoney(OutName, money);

 16:     int i=1/0;

 17:     accountDao.inMoney(InName, money);  

 18:   }

 19: }

 20: 

测试类：springtestdemo2.java

  1: package com.spring.demo2;

  2: import javax.annotation.Resource;

  3: import org.junit.Test;

  4: import org.junit.runner.RunWith;

  5: import org.springframework.test.context.ContextConfiguration;

  6: import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

  7: /**

  8:  * 声明式

  9:  * 

 10:  * @author su

 11:  *

 12:  */

 13: @RunWith(SpringJUnit4ClassRunner.class)

 14: @ContextConfiguration("classpath:applicationContext2.xml")

 15: public class springtestdemo2 {

 16:   //测试业务层类：

 17:   /**

 18:    * 

 19:    * 注入代理类：因为代理类已经增强了

 20:    */

 21:   //@Resource(name="accountService")

 22:   @Resource(name="accountServiceProxy")

 23:   private AccountService accountService;

 24:   @Test

 25:   public void test(){

 26:     accountService.transfer("aaa", "bbb", 300d);

 27:   }

 28: }

运行结果图上。

2.4、声明式事务管理方式二：基于AspectJ的xml配置

ApplicationContex3.xml

  1: <?xml version="1.0" encoding="UTF-8" ?>

  2: <beans xmlns="http://www.springframework.org/schema/beans"

  3:   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"

  4:   xmlns:context="http://www.springframework.org/schema/context"

  5:   xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"

  6:   xsi:schemaLocation="http://www.springframework.org/schema/beans 

  7:        http://www.springframework.org/schema/beans/spring-beans-3.0.xsd

  8:        http://www.springframework.org/schema/context 

  9:        http://www.springframework.org/schema/context/spring-context-3.0.xsd

 10:        http://www.springframework.org/schema/tx 

 11:        http://www.springframework.org/schema/tx/spring-tx-3.0.xsd

 12:        http://www.springframework.org/schema/aop

 13:        http://www.springframework.org/schema/aop/spring-aop-3.0.xsd">

 14:     

 15:     <!-- 引入外部的属性文件 -->

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

 17:      

 18:      <!-- 配置c3p0连接池 

 19:   <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"

 20:     p:driverClass="${jdbc.driverClass}"

 21:     p:jdbcUrl="${jdbc.url}"

 22:     p:user="${jdbc.username}"

 23:     p:password="${jdbc.password}" />-->

 24:   

 25:   <!-- 配置dbcp连接池 -->

 26:   <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource"

 27:     destroy-method="close" 

 28:     p:driverClassName="${jdbc.driverClass}"

 29:     p:url="${jdbc.url}"

 30:     p:username="${jdbc.username}"

 31:     p:password="${jdbc.password}" />

 32: 

 33:   <!-- 配置Jdbc模板  -->

 34:   <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate"

 35:     p:dataSource-ref="dataSource" />

 36:   

 37:   <!-- 业务层 -->

 38:   <bean id="accountService" class="com.spring.demo4.AccountServiceImpl" p:accountDao-ref="accountDao"/>

 39: 

 40:   <!-- Dao类 -->

 41:   <bean id="accountDao" class="com.spring.demo4.AccountDaoImpl" p:dataSource-ref="dataSource" />

 42:   

 43:   <!-- 配置事务管理器 -->

 44:   <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager" 

 45:     p:dataSource-ref="dataSource" />

 46:   

 47:   <!-- 配置事务的通知：(事务的增强增强) -->

 48:   <tx:advice id="txAdvice" transaction-manager="transactionManager">

 49:     <tx:attributes>

 50:       <!-- propagation：事务的传播行为

 51:         isolation：  事务的隔离级别

 52:         read-only:只读

 53:         rollback-for:发生哪些异常回滚

 54:         no-rollback-for:发生哪些异常不回滚

 55:        -->

 56:       <tx:method name="transfer" propagation="REQUIRED"/>

 57:     </tx:attributes>

 58:   </tx:advice>

 59:   

 60:   <!-- 配置切面 -->

 61:   <aop:config>

 62:     <!-- 配置切入点 -->

 63:     <aop:pointcut expression="execution(* com.spring.demo3.AccountService+.*(..))" id="pointcut1" />

 64:     <!-- 配置切面 -->

 65:     <aop:advisor advice-ref="txAdvice" pointcut-ref="pointcut1" />

 66:   </aop:config>

 67: </beans>

AccountServiceImpl.java

  1: package com.spring.demo3;

  2: import org.springframework.transaction.TransactionStatus;

  3: import org.springframework.transaction.annotation.Transactional;

  4: import org.springframework.transaction.support.TransactionCallback;

  5: import org.springframework.transaction.support.TransactionCallbackWithoutResult;

  6: import org.springframework.transaction.support.TransactionTemplate;

  7: import com.sun.istack.internal.FinalArrayList;

  8: public class AccountServiceImpl implements AccountService {

  9:   //注入转账的DAO类  

 10:   private AccountDao accountDao;

 11:   public void setAccountDao(AccountDao accountDao) {

 12:     this.accountDao = accountDao;

 13:   }  

 14:   public void transfer(String OutName, String InName, Double money) {

 15:     // TODO Auto-generated method stub

 16:      accountDao.outMoney(OutName, money);

 17: //    int i=1/0;

 18:      accountDao.inMoney(InName, money);  

 19:   }

 20: }

测试类：springtestdemo3.java

  1: package com.spring.demo3;

  2: 

  3: import javax.annotation.Resource;

  4: import org.junit.Test;

  5: import org.junit.runner.RunWith;

  6: import org.springframework.test.context.ContextConfiguration;

  7: import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

  8: /**

  9:  * 声明式：基于AspectJ的XML的配置

 10:  * 

 11:  * @author su

 12:  *

 13:  */

 14: @RunWith(SpringJUnit4ClassRunner.class)

 15: @ContextConfiguration("classpath:applicationContext3.xml")

 16: public class springtestdemo3 {

 17:   //测试业务层类：

 18:   @Resource(name="accountService")

 19:   private AccountService accountService;

 20:   @Test

 21:   public void test(){

 22:     accountService.transfer("aaa", "bbb", 300d);

 23:   }

 24: }

 

2.5、声明式事务管理方式三：基于@Transactional注解

ApplicationContext4.xml

  1: <?xml version="1.0" encoding="UTF-8" ?>

  2: <beans xmlns="http://www.springframework.org/schema/beans"

  3:   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"

  4:   xmlns:context="http://www.springframework.org/schema/context"

  5:   xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"

  6:   xsi:schemaLocation="http://www.springframework.org/schema/beans 

  7:        http://www.springframework.org/schema/beans/spring-beans-3.0.xsd

  8:        http://www.springframework.org/schema/context 

  9:        http://www.springframework.org/schema/context/spring-context-3.0.xsd

 10:        http://www.springframework.org/schema/tx 

 11:        http://www.springframework.org/schema/tx/spring-tx-3.0.xsd

 12:        http://www.springframework.org/schema/aop

 13:        http://www.springframework.org/schema/aop/spring-aop-3.0.xsd">

 14:        

 15:     <!-- 引入外部的属性文件 -->

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

 17:      

 18:     <!-- 配置c3p0连接池 

 19:   <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"

 20:     p:driverClass="${jdbc.driverClass}"

 21:     p:jdbcUrl="${jdbc.url}"

 22:     p:user="${jdbc.username}"

 23:     p:password="${jdbc.password}" />-->

 24:   

 25:   <!-- 配置dbcp连接池 -->

 26:   <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource"

 27:     destroy-method="close" 

 28:     p:driverClassName="${jdbc.driverClass}"

 29:     p:url="${jdbc.url}"

 30:     p:username="${jdbc.username}"

 31:     p:password="${jdbc.password}" />  

 32: 

 33:   <!-- 配置Jdbc模板  -->

 34:   <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate"

 35:     p:dataSource-ref="dataSource" />

 36:   

 37:   <!-- 业务层 -->

 38:   <bean id="accountService" class="com.spring.demo4.AccountServiceImpl" p:accountDao-ref="accountDao"/>

 39: 

 40:   <!-- Dao类 -->

 41:   <bean id="accountDao" class="com.spring.demo4.AccountDaoImpl" p:dataSource-ref="dataSource" />

 42:   

 43:   <!-- 配置事务管理器 -->

 44:   <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager" 

 45:     p:dataSource-ref="dataSource" />

 46:   

 47:   <!-- 开启注解事务 -->

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

 49: </beans>

AccountServiceImpl.java

  1: package com.spring.demo4;

  2: import org.springframework.transaction.TransactionStatus;

  3: import org.springframework.transaction.annotation.Isolation;

  4: import org.springframework.transaction.annotation.Propagation;

  5: import org.springframework.transaction.annotation.Transactional;

  6: import org.springframework.transaction.support.TransactionCallback;

  7: import org.springframework.transaction.support.TransactionCallbackWithoutResult;

  8: import org.springframework.transaction.support.TransactionTemplate;

  9: import com.sun.istack.internal.FinalArrayList;

 10: /**

 11:  * @Transactional:注解中的属性

 12:  * propagation:事务的传播行为

 13:  * isolation:  事务的隔离级别

 14:  * readOnly:只读

 15:  * rollbackFor:发生哪些异常回滚

 16:  * noRollbackFor:发生哪些异常不回滚

 17:  * 

 18:  * @author su

 19:  *

 20:  */

 21: @Transactional(propagation=Propagation.REQUIRED,isolation=Isolation.DEFAULT,readOnly=false)

 22: public class AccountServiceImpl implements AccountService {

 23: 

 24:   //注入转账的DAO类

 25:   

 26:   private AccountDao accountDao;

 27:   public void setAccountDao(AccountDao accountDao) {

 28:     this.accountDao = accountDao;

 29:   }

 30:   

 31:   public void transfer(String OutName, String InName, Double money) {

 32:     // TODO Auto-generated method stub

 33:     accountDao.outMoney(OutName, money);

 34: //    int i=1/0;

 35:     accountDao.inMoney(InName, money);  

 36:   }

 37: }

测试类：springtestdemo4.java

  1: package com.spring.demo4;

  2: import javax.annotation.Resource;

  3: import org.junit.Test;

  4: import org.junit.runner.RunWith;

  5: import org.springframework.test.context.ContextConfiguration;

  6: import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

  7: /**

  8:  * 声明式：基于注解的事务管理方式

  9:  * 

 10:  * @author su

 11:  *

 12:  */

 13: @RunWith(SpringJUnit4ClassRunner.class)

 14: @ContextConfiguration("classpath:applicationContext4.xml")

 15: public class springtestdemo4 {

 16: 

 17:   //测试业务层类：

 18:   @Resource(name="accountService")

 19:   private AccountService accountService;

 20:   @Test

 21:   public void test(){

 22:     accountService.transfer("aaa", "bbb", 300d);

 23:   }

 24: }