对Springdata模块的简单理解

有关于Spring对数据库的操作属于为Spring中的Springdata模块，对数据库的操作。Spring对JDBC和Mybatis都有封装与简化

可以从以下角度学习研究

SpringData：
1.对jdbc的操作来说，jdbc编程不变，主要是Connection对象的维护，即配置并使用数据源
2.spring在jdbc的使用中还给我们提供了一个模板类:JdbcTemplate用以简化我们的jdbc操作
3.Spring与mybatis结合
4.Spring事务管理机制

第一部分 

对Connection对象的维护，即配置并使用数据源

1.基于jdk的规范数据源 --------jdk官方的数据源

<bean name="dataSource1" class="oracle.jdbc.pool.OracleConnectionPoolDataSource">
　　<property name="networkProtocol">
　　　　<value>tcp</value>
　　</property>
　　<property name="databaseName">
　　　　<value>XE</value>
　　</property>
　　<property name="driverType">
　　　　<value>thin</value>
　　</property>
　　<property name="portNumber">
　　　　<value>1521</value>
　　</property>
　　<property name="user">
　　　　<value>briup</value>
　　</property>
　　<property name="serverName">
　　　　<value>127.0.0.1</value>
　　</property>
　　<property name="password">
　　　　<value>briup</value>
　　</property>
</bean>

!!!注意:别忘了读取配置文件!!!

下面是配置文件的读取方式

读取这个资源文件 读完之后下面就可以用${key}来去文件中的value值了
这是第一种读取资源文件的方式

<bean
class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
<property name="locations" value="classpath:oracle.properties" >
</property>
</bean>

这种方式是我们第一种配置方式方式的简写

<context:property-placeholder location="classpath:oracle.perperties"/>

2.dbcp数据源---------第三方提供

<bean id="dataSource2"
class="org.apache.commons.dbcp.BasicDataSource">
<property name="driverClassName">
<value>${driver}</value>
</property>
<property name="url">
<value>${url}</value>
</property>
<property name="username">
<value>${user}</value>
</property>
<property name="password">
<value>${password}</value>
</property>
<!-- 最大连接数 -->
<property name="maxActive">
<value>80</value>
</property>
<!-- 最大空闲连接数 -->
<property name="maxIdle">
<value>20</value>
</property>
<!-- 最大等待时间:当没有可用连接时,连接池等待连接被归还的最大时间 单位:毫秒 -->
<!-- 超过时间则抛出异常,如果设置为-1表示无限等待 -->
<property name="maxWait">
<value>3000</value>
</property>
</bean>

连接池基本的思想，原理：

在系统初始化的时候，将数据库连接作为对象存储在内存中。
　　　　　　↓
当用户需要访问数据库时，并非建立一个新的连接，而是从连接池中取出一个已建立的空闲连接对象。
　　　　　　↓
数据库连接池负责分配,管理和释放数据库连接,它允许应用程序重复使用一个现有的数据库连接,而不是重新建立一个。

连接池通俗理解：　　

数据库连接池就是准备一个池子，里面放着好多好多生成好的Connection，用户请求获得连接。
就不需要getConnection,只要从池子里拿一个给他就行了，这样省掉了生成Connection的时间。
效率上会有很大提高，不过当然会占用一些内存~稍微大点网站都会用到数据库连接池的~

3.spring提供的一种数据源--------Spring提供

这种数据源的配置比较简单，一般也够用

<bean id="dataSource3"
class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="driverClassName">
<value>${driver}</value>
</property>
<property name="url">
<value>${url}</value>
</property>
<property name="username">
<value>${user}</value>
</property>
<property name="password">
<value>${password}</value>
</property>
</bean>

4.c3p0数据源----------连接池

<bean id="dataSource4" class="com.mchange.v2.c3p0.ComboPooledDataSource"
destroy-method="close">
<property name="driverClass">
<value>${driver}</value>
</property>
<property name="jdbcUrl">
<value>${url}</value>
</property>
<property name="user">
<value>${user}</value>
</property>
<property name="password">
<value>${password}</value>
</property>

<!--连接池中保留的最小连接数。 -->
<property name="minPoolSize">
<value>5</value>
</property>

<!--连接池中保留的最大连接数。Default: 15 -->
<property name="maxPoolSize">
<value>30</value>
</property>

<!--初始化时获取的连接数，取值应在minPoolSize与maxPoolSize之间。Default: 3 -->
<property name="initialPoolSize">
<value>10</value>
</property>

<!--最大空闲时间,60秒内未使用则连接被丢弃。若为0则永不丢弃。Default: 0 -->
<property name="maxIdleTime">
<value>60</value>
</property>

<!--当连接池中的连接耗尽的时候c3p0一次同时获取的连接数。Default: 3 -->
<property name="acquireIncrement">
<value>5</value>
</property>

<!--每60秒检查所有连接池中的空闲连接。Default: 0 -->
<property name="idleConnectionTestPeriod">
<value>60</value>
</property>

<!--定义在从数据库获取新连接失败后重复尝试的次数。Default: 30 -->
<property name="acquireRetryAttempts">
<value>30</value>
</property>
</bean>

可以看出，将这些数据源作为bean注入了框架中我们需要从这些数据源中拿到Connection对象

可以写一个类来从连接池中获得connection对象：

public class DBUtil{
//数据源
private DataSource dataSorce;

public DataSource getDataSorce() {
return dataSorce;
}

public void setDataSorce(DataSource dataSorce) {
this.dataSorce = dataSorce;
}
//获得Connection对象
public Connection getConn(){
Connection conn = dataSorce.getConnection();
return conn;
}
}

将这个类注入容器：

<bean name="dao" class="包名.DBUtil">
<property name="dataSorce" ref="dataSource4【数据源名】"></property>
</bean>

使用getConn()方法获得Connection对象

public void jdbc_dataSource(){
try {
String path = "xml文件地址";
ClassPathXmlApplicationContext container =
new ClassPathXmlApplicationContext(path);

DBUtil dao = (DBUtil)container.getBean("dao");
Connection conn = dao.getConn();

container.destroy();
}catch(Exception e) {
e.printStackTrace();
}
}

但是注意，一般来说，如果连接池设置了大小，这个连接拿到之后要注意归还 【方法conn.close()】

第二部分

JdbcTemplate用以简化我们的jdbc操作
例如:

//java类中的写法:
public class JdbcTemplateDao implements AccountDao{
private JdbcTemplate jdbcTemplate;

public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
this.jdbcTemplate = jdbcTemplate;
}
...
}

xml中进行配置

<!-- spring提供的一种数据源 -->
<bean name="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="driverClassName">
<value>${driver}</value>
</property>
<property name="url">
<value>${url}</value>
</property>
<property name="username">
<value>${user}</value>
</property>
<property name="password">
<value>${password}</value>
</property>
</bean>

<bean name="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
<!--很明显这里使用的是构造器注入，参数是一个数据源
也就是说，要使用这个类就先要在容器中注入一个Spring提供的数据源(这里注意不只是Spring提供的数据源有效)-->
<constructor-arg index="0" ref="dataSource"></constructor-arg>
</bean>

<bean name="dao" class="com.briup.db.jdbc.JdbcTemplateDao">
<property name="jdbcTemplate" ref="jdbcTemplate"></property>
</bean>

可以写个方法获得这个类对象：

public void jdbc_dataSource(){
try {
String path = "xml文件地址";
ClassPathXmlApplicationContext container =
new ClassPathXmlApplicationContext(path);

JdbcTemplateDao dao = (JdbcTemplateDao)container.getBean("dao");
JdbcTemplate jdbcTemplate = dao.getJdbcTemplate();

container.destroy();
}catch(Exception e) {
e.printStackTrace();
}
}

JdbcTemplate这个类对象有一些方法用来操作sql语句【详细方法可以看Spring4.3.7说明书】
注意1:JdbcTemplate模板类如何使用:在htmlsingle中搜索即可,其中包含有大量的使用实例
注意2:spring结合jdbc的时候,不论是否使用这个模板,jdbc操作的事务默认是自动提交的(和之前学习jdbc的时候是一致的)

JDBC虽然不如Mybatis方便，但是效率的确高，在一些小型项目，或者是追求效率的问题中，使用Spring中的JdbcTemplate这个类简化操作依旧是不错的选择。

第三部分

Spring与mybatis结合

首先我在classpath下建好一个配置文件【oracle.properties】内容如下

driver=oracle.jdbc.driver.OracleDriver
url=jdbc:oracle:thin:@127.0.0.1:1521:XE
user=briup
password=briup

读取这个资源文件 读完之后下面就可以用${key}来去文件中的value值了
这种方式是简写

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

构建dbcp数据源(这里注意不只是dbcp的数据源有效)

<bean name="dataSource" class="org.apache.commons.dbcp.BasicDataSource">
<property name="driverClassName">
<value>${driver}</value>
</property>
<property name="url">
<value>${url}</value>
</property>
<property name="username">
<value>${user}</value>
</property>
<property name="password">
<value>${password}</value>
</property>
<!-- 最大连接数 -->
<property name="maxActive">
<value>80</value>
</property>
<!-- 最大空闲连接数 -->
<property name="maxIdle">
<value>20</value>
</property>
<!-- 最大等待时间:当没有可用连接时,连接池等待连接被归还的最大时间 单位:毫秒 -->
<!-- 超过时间则抛出异常,如果设置为-1表示无限等待 -->
<property name="maxWait">
<value>3000</value>
</property>
</bean>

配置sqlSessionFactory

<bean name="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
　　<property name="dataSource" ref="dataSource" />
　　<property name="typeAliasesPackage" value="com.briup.db"></property>
　　<property name="configurationProperties">
　　<props>
　　　　<prop key="cacheEnabled">true</prop>
　　</props>
　　</property>
　　　　<!-- 自动扫描mapping.xml文件 -->
　　<property name="mapperLocations" value="classpath:com/briup/db/mybatis/AccountMapper.xml" />
</bean>

自动扫描映射接口所在的包
将来可以通过接口的名字首字母小写作为beanName,从spring容器中拿出自动生成的该接口的实现类

<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
　　<property name="basePackage" value="com.briup.db" />
</bean>

如果不加这个配置，一样可以通过前面的配置sqlSessionFactory拿到一个sqlSessionFactory对象，还是可以映射接口

当然也可以自己写一个mybatis-config.xml文件读入，方法如下：
配置sqlSessionFactory 时使用mybatis-config.xml
直接读取mybatis-config.xml文件,里面和之前配置的一样

<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
<property name="configLocation" value="classpath:mybatis-config.xml"/>
</bean>

最后还需要扫描mybatis中映射接口,以便spring为其生产对应的实现类(这一步同样可以自己选择的)

<!-- 自动扫描映射接口所在的包 -->
<!-- 将来可以通过接口的名字首字母小写作为beanName,从spring容器中拿出自动生成的该接口的实现类 -->
<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
<property name="basePackage" value="com.briup.db" />
</bean>

第四部分

Spring事务管理机制

1.编程式事务管理(不常用)

所谓编程式事务指的是通过编码方式实现事务。
记得在JDBC中可以使用手动提交事务的方法

2.声明式事务管理(常用)

在Spring配置文件中声明式的处理事务来代替代码式的处理事务.
在spring中,声明式事务主要是通过【事务属性】来定义的,事务属性描述了事务策略如何应用到方法上面

事务属性主要包含了以下5个方面:(文档的最后有统一的介绍)
传播行为 隔离级别 回滚规则 事务超时 是否只读

声明式事务管理的配置方式通常以下几种：
注意:配置事务的方式都需要用到事务管理器(切面)和事务拦截器(advice)
其实就是使用aop编程,把事务代码动态织入到需要使用的方法上

spring中实现aop的配置方式很多,在这里配置事务的时候推荐使用:

1.tx前缀的事务标签和aop前缀的标签结合,将切面(事务管理器)织入到切入点上

2.注解进行事务配置【在实际开发中更容易使用】

例如1:
spring结合jdbc,事务配置在service层指定方法上,使用tx标签结合aop标签

//使用jdbc实现dao层接口
public class JDBCAccountDaoImpl implements AccountDao{
private JdbcTemplate jdbcTemplate;
//get/set方法
//实现接口中的抽象方法
.....
}

spring_jdbc.xml配置文件主要内容:

<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="driverClassName">
<value>oracle.jdbc.driver.OracleDriver</value>
</property>
<property name="url">
<value>jdbc:oracle:thin:@localhost:1521:XE</value>
</property>
<property name="username">
<value>briup</value>
</property>
<property name="password">
<value>briup</value>
</property>
</bean>

jdbc_service1.xml配置文件主要内容:

<!-- 配置dao层对象 -->
<bean name="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
　　<constructor-arg index="0" ref="dataSource"></constructor-arg>
</bean>
<bean id="accountDao" class="com.briup.tran.jdbc.JDBCAccountDaoImpl">
　　<property name="jdbcTemplate" ref="jdbcTemplate"/>
</bean>
<!-- 配置service层对象 目标对象-->
<bean name="service" class="com.briup.tran.service.AccountServiceImpl">
　　<!-- 注入dao层对象 -->
　　<property name="accountDao" ref="accountDao"></property>
</bean>
<!-- 配置jdbc的事务管理器 (切面类)-->
<bean name="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
　　<!-- 注入数据源 -->
　　<property name="dataSource" ref="dataSource"></property>
</bean>
<!-- 配置事务拦截器 -->
<tx:advice id="transactionInterceptor" transaction-manager="transactionManager">
　　<tx:attributes>
　　　　<!-- *代表所有的方法 -->
　　　　<tx:method name="*" propagation="REQUIRED" rollback-for="Throwable"/>
　　</tx:attributes>
</tx:advice>
<!-- 配置aop -->
<aop:config>
　　<!-- 配置切入点 -->
　　<aop:pointcut expression="execution(public * com.briup.tran.service.*.*(..))" id="myPointCut"/>
　　<!-- 配置事务拦截器在哪一个切入点上起作用 -->
　　<aop:advisor advice-ref="transactionInterceptor" pointcut-ref="myPointCut"/>
</aop:config>

测试方法：

String path[] = {"com/briup/tran/jdbc/spring_jdbc.xml",
"com/briup/tran/service/jdbc_service1.xml"};
ApplicationContext container =
new ClassPathXmlApplicationContext(path);
AccountService service = (AccountService)container.getBean("service");
service.add(new Account(1,"zs1",1000));

例如2:
spring结合jdbc,事务配置在service层指定方法上,使用注解进行事务配置
和例子1中只有俩处不同
第一处:

service接口的实现类的上面使用@Transactional:这个注解加在目标类上

@Transactional(propagation=Propagation.REQUIRED,rollbackFor=Throwable.class)
public class AccountServiceImpl implements AccountService{
.....
}

第二处:
jdbc_service2.xml配置文件主要内容:

<!-- 配置service层对象 目标对象-->
<bean name="service" class="com.briup.tran.service.AccountServiceImpl">
<!-- 注入dao层对象 -->
<property name="accountDao" ref="accountDao"></property>
</bean>

<!-- 配置jdbc的事务管理器 (切面类)-->
<bean name="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<!-- 注入数据源 -->
<property name="dataSource" ref="dataSource"></property>
</bean>

<!-- 通知spring我们在目标对象中做了事务的注解,并指明使用哪一个事务管理器 -->
<!-- 加入上这个标签后 去目标对象去加入相应的注解就可以了 -->
<tx:annotation-driven transaction-manager="transactionManager"/>

例如3:
spring结合mybatis,事务配置在service层指定方法上,使用tx标签结合aop标签

AccountMapper.xml配置文件主要内容:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!-- com.briup.tran.dao.AccountDao是我们定义接口的全限定名字 这样就可以使用接口调用映射的SQL语句了 这个名字一定要和接口对应上-->
<mapper namespace="com.briup.tran.dao.AccountDao">

<insert id="save" parameterType="Account">
insert into
t_account(id,name,balance)
values(#{id},#{name},#{balance})
</insert>

<update id="update" parameterType="Account">
update t_account
set
name=#{name},
balance=#{balance}
where id=#{id}
</update>

<delete id="delete" parameterType="Account">
delete from t_account where id=#{id}
</delete>

</mapper>

spring_mybatis.xml配置文件主要内容:

<!-- 配置数据源 -->
<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="driverClassName">
<value>oracle.jdbc.driver.OracleDriver</value>
</property>
<property name="url">
<value>jdbc:oracle:thin:@localhost:1521:XE</value>
</property>
<property name="username">
<value>briup</value>
</property>
<property name="password">
<value>briup</value>
</property>
</bean>

<!-- 配置sqlSessionFactory -->
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
<property name="dataSource" ref="dataSource" />
<property name="typeAliasesPackage" value="com.briup.tran"></property>
<property name="configurationProperties">
<props>
<prop key="cacheEnabled">true</prop>
</props>
</property>
<!-- 自动扫描mapping.xml文件 -->
<property name="mapperLocations" value="classpath:com/briup/tran/mybatis/AccountMapper.xml" />
</bean>    

<!-- 自动扫描映射接口所在的包 -->
<!-- 将来可以通过接口的名字首字母小写作为beanName,从spring容器中拿出自动生成的该接口的实现类 -->
<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
<property name="basePackage" value="com.briup.tran.dao" />
</bean>

mybatis_service1.xml配置文件主要内容:

<!-- 配置service层对象 目标对象-->
<bean name="service" class="com.briup.tran.service.AccountServiceImpl">
<!-- 注入dao层对象 -->
<property name="accountDao" ref="accountDao"></property>
</bean>

<!-- 配置jdbc的事务管理器 (切面类) 适用于mybatis-->
<bean name="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<!-- 注入数据源 -->
<property name="dataSource" ref="dataSource"></property>
</bean>

<!-- 配置事务拦截器 -->
<tx:advice id="transactionInterceptor" transaction-manager="transactionManager">
<tx:attributes>
<!-- *代表所有的方法 -->
<tx:method name="*" propagation="REQUIRED" rollback-for="Throwable"/>
</tx:attributes>
</tx:advice>

<!-- 配置aop -->
<aop:config>
<!-- 配置切入点 -->
<aop:pointcut expression="execution(public * com.briup.tran.service.*.*(..))" id="myPointCut"/>
<!-- 配置事务拦截器在哪一个切入点上起作用 -->
<aop:advisor advice-ref="transactionInterceptor" pointcut-ref="myPointCut"/>
</aop:config>

测试方法:
.....

例如4:
spring结合mybatis,事务配置在service层指定方法上,使用注解进行事务配置

和例子3中只有俩处不同
第一处:
service接口的实现类的上面使用@Transactional:

@Transactional(propagation=Propagation.REQUIRED,rollbackFor=Throwable.class)
public class AccountServiceImpl implements AccountService{
.....
}

第二处:
mybatis_service2.xml配置文件主要内容:

<!-- 配置service层对象 目标对象-->
<bean name="service" class="com.briup.tran.service.AccountServiceImpl">
<!-- 注入dao层对象 -->
<property name="accountDao" ref="accountDao"></property>
</bean>

<!-- 配置jdbc的事务管理器 (切面类) 适用于mybatis-->
<bean name="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<!-- 注入数据源 -->
<property name="dataSource" ref="dataSource"></property>
</bean>

<!-- 通知spring我们在目标对象中做了事务的注解,并指明使用哪一个事务管理器 -->
<!-- 加入上这个标签后 去目标对象去加入相应的注解就可以了 -->
<tx:annotation-driven transaction-manager="transactionManager"/>

-----------------------------------------------------------
了解事务属性包含的五个方面分别是什么:

1)事务传播行为
规定了如果有新的事务应该被启动还是被挂起,或者方法是否需要在事务中运行。

TransactionDefinition.PROPAGATION_REQUIRED：如果当前存在事务，则加入该事务；如果当前没有事务，则创建一个新的事务。
TransactionDefinition.PROPAGATION_REQUIRES_NEW：创建一个新的事务，如果当前存在事务，则把当前事务挂起。
TransactionDefinition.PROPAGATION_SUPPORTS：如果当前存在事务，则加入该事务；如果当前没有事务，则以非事务的方式继续运行。
TransactionDefinition.PROPAGATION_NOT_SUPPORTED：以非事务方式运行，如果当前存在事务，则把当前事务挂起。
TransactionDefinition.PROPAGATION_NEVER：以非事务方式运行，如果当前存在事务，则抛出异常。
TransactionDefinition.PROPAGATION_MANDATORY：如果当前存在事务，则加入该事务；如果当前没有事务，则抛出异常。
TransactionDefinition.PROPAGATION_NESTED：如果当前存在事务，则创建一个事务作为当前事务的嵌套事务来运行；如果当前没有事务，则该取值等价于TransactionDefinition.PROPAGATION_REQUIRED。

2)事务隔离级别
定义了一个事务可能受其他并发事务影响的程度。
隔离级别是指若干个并发的事务之间的隔离程度。TransactionDefinition 接口中定义了五个表示隔离级别的常量：

TransactionDefinition.ISOLATION_DEFAULT：这是默认值，表示使用底层数据库的默认隔离级别。对大部分数据库而言，通常这值就是TransactionDefinition.ISOLATION_READ_COMMITTED。

TransactionDefinition.ISOLATION_READ_UNCOMMITTED：该隔离级别表示一个事务可以读取另一个事务修改但还没有提交的数据。该级别不能防止脏读和不可重复读，因此很少使用该隔离级别。
TransactionDefinition.ISOLATION_READ_COMMITTED：该隔离级别表示一个事务只能读取另一个事务已经提交的数据。该级别可以防止脏读，这也是大多数情况下的推荐值。
TransactionDefinition.ISOLATION_REPEATABLE_READ：该隔离级别表示一个事务在整个过程中可以多次重复执行某个查询，并且每次返回的记录都相同。即使在多次查询之间有新增的数据满足该查询，这些新增的记录也会被忽略。该级别可以防止脏读和不可重复读。
TransactionDefinition.ISOLATION_SERIALIZABLE：所有的事务依次逐个执行，这样事务之间就完全不可能产生干扰，也就是说，该级别可以防止脏读、不可重复读以及幻读。但是这将严重影响程序的性能。通常情况下也不会用到该级别。

注意:不同的数据库所能支持的事务隔离级别以及默认的事务隔离级别有可能是不同的

3)事务的只读属性
定义了一个事务中是否是只读操作,如果设置只读那么数据库内部就可以对该操作进行合适的优化措施,只有传播行为是PROPAGATION_REQUIRED PROPAGATION_REQUIRES_NEW PROPAGATION_NESTED的时候只读设置才有意义,因为只读优化是在事务开始的时候由数据库实施的,而在这三个传播行为下才有可能启动一个新事务

4)事务超时
为了使应用程序可以很好的运行,事务不能运行太长的时间,所以这个属性就控制着这个时间.只有传播行为是PROPAGATION_REQUIRED PROPAGATION_REQUIRES_NEW PROPAGATION_NESTED的时候超时设置才有意义,因为超时时钟会在事务开始的时候启动,而在这三个传播行为下才有可能启动一个新事务.注意事务超时后会自动回滚.(单位是 秒)

5)事务的回滚规则
定义了哪些异常会导致事务回滚而哪些不会。默认情况下,事务在遇到运行时异常的时候才会回滚,而遇到检查时异常时不会回滚
-Exception表示有Exception抛出时,事务回滚. -代表回滚+就代表提交