spring和mybatis的结合

1 Spring与jdbc结合
jdbc编程不变，主要是Connection对象的维护，即配置并使用数据源
1)<!-- 基于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值了 -->
<!-- 这种方式是我们第一节学习的那种配置方式方式的简写 -->
<context:property-placeholder location="com/briup/db/jdbc/jdbc.properties"/>

2)<!-- dbcp数据源 -->
<bean id="dataSource2"
　　class="org.apache.commons.dbcp.BasicDataSource">
<property name="driverClassName">
　　<value>${jdbc.driverClassName}</value>
</property>
<property name="url">
　　<value>${jdbc.url}</value>
</property>
<property name="username">
　　<value>${jdbc.username}</value>
</property>
<property name="password">
　　<value>${jdbc.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>

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

4)c3p0数据源
<!-- c3p0数据源 -->
<bean id="dataSource4" class="com.mchange.v2.c3p0.ComboPooledDataSource"
destroy-method="close">
<property name="driverClass">
<value>${jdbc.driverClassName}</value>
</property>
<property name="jdbcUrl">
<value>${jdbc.url}</value>
</property>
<property name="user">
<value>${jdbc.username}</value>
</property>
<property name="password">
<value>${jdbc.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>

扫描二维码关注公众号，回复： 10063260 查看本文章

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

数据源datasource，优点是包含数据库连接信息，可以帮我们获取数据库连对接象，
而且可以提供数据库连接池（pool）的功能，帮我们管理、分配、释放数据库连接
各个数据源连接池都有一些公有的属性，因为他们都是从javax.sql.datasource继承
而来，而且都有最大连接数，初始化连接数等概念。同时，他们又分别有各自不同的属性，做了扩展。
-------------------

spring在jdbc的使用中还给我们提供了一个模板类:JdbcTemplate
用以简化我们的jdbc操作[获取数据源,conn,statement,执行sqld,处理结果,关闭资源]
例如:
//java类中的写法:
public class JdbcTemplateDao implements AccountDao{
private JdbcTemplate jdbcTemplate;

public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
this.jdbcTemplate = jdbcTemplate;
}
...
}
//xml中进行配置
<bean name="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
<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>

注意1:JdbcTemplate模板类如何使用:在htmlsingle中搜索即可,其中包含有大量的使用实例
注意2:spring结合jdbc的时候,不论是否使用这个模板,jdbc操作的事务默认是自动提交的(和之前学习jdbc的时候是一致的)

2 Spring与mybatis结合
注意导入相关jar包:mybatis-spring-1.2.2.jar

使用Spring整合mybatis时,可以使用mybatis-config.xml文件,也可以不使用

<!-- 配置sqlSessionFactory 不使用mybatis-config.xml-->
<bean id="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文件 *.xml-->
<property name="mapperLocations" value="classpath:com/briup/db/mybatis/AccountMapper.xml" />
</bean>

或者:

<!-- 配置sqlSessionFactory 使用mybatis-config.xml-->
<!-- 直接读取mybatis-config.xml文件,里面和之前配置的一样 -->
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
<property name="dataSource" ref="dataSource" />
<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>

3 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配置文件主要内容:
<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">
<!-- 注入数据源,spring的jdbc事务管理器在管理事务时,依赖于JDBC的事务管理机制 -->
<property name="dataSource" ref="dataSource"></property>
</bean>

<!-- 配置事务拦截器 ,transaction-manager:表示通知织入哪个切面-->
<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>
<!-- *代表所有的方法
表示与事务属性关联的方法业务（方法名),对切入点进行细化。通配符（*）可以用来指定一批关联到相同的事务属性的方法。
如：'get*'、'find*'、'on*Event'等等-->
<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。

name 是必须的,表示与事务属性关联的方法名(业务方法名),对切入点进行细化。通配符（*）可以用来指定一批关联到相同的事务属性的方法。
如：'get*'、'handle*'、'on*Event'等等

2)事务隔离级别
定义了一个事务可能受其他并发事务影响的程度。
隔离级别是指若干个并发的事务之间的隔离程度。TransactionDefinition 接口中定义了五个表示隔离级别的常量：
脏读（没提交的数据），不可重复读（读到了提交的(update,d)），幻读(读到了提交的，insert)

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

TransactionDefinition.ISOLATION_READ_UNCOMMITTED：该隔离级别表示一个事务可以读取另一个事务修改但还没有提交的数据。该级别不能防止脏读和不可重复读，因此很少使用该隔离级别。
TransactionDefinition.ISOLATION_READ_COMMITTED：该隔离级别表示一个事务只能读取另一个事务已经提交的数据。该级别可以防止脏读，这也是大多数情况下的推荐值。
TransactionDefinition.ISOLATION_REPEATABLE_READ：该隔离级别表示在同一事务中，同一查询多次进行时候，由于其他插入操作（insert）的事务提交，导致每次返回不同的结果集。该级别可以防止脏读和不可重复读。
TransactionDefinition.ISOLATION_SERIALIZABLE：所有的事务依次逐个执行，这样事务之间就完全不可能产生干扰，也就是说，该级别可以防止脏读、不可重复读以及幻读。但是这将严重影响程序的性能。通常情况下也不会用到该级别。

注意:不同的数据库所能支持的事务隔离级别以及默认的事务隔离级别有可能是不同的,不同的隔离级别有不同的现象，并有不同的并发机制，隔离级别越高，数据库的并发性就越差。

3)事务的只读属性
定义了一个事务中是否是只读操作,如果设置只读那么数据库内部就可以对该操作进行合适的优化措施,只有传播行为是PROPAGATION_REQUIRED PROPAGATION_REQUIRES_NEW PROPAGATION_NESTED的时候只读设置才有意义,因为只读优化是在事务开始的时候由数据库实施的,而在这三个传播行为下才有可能启动一个新事务
find*,get*[优化]:开启*提交,不写
“只读事务”并不是一个强制选项，它只是一个“暗示”，提示数据库驱动程序和数据库系统，这个事务并不包含更改数据的操作，那么JDBC驱动程序和数据库就有可能根据这种情况对该事务进行一些特定的优化，比方说不安排相应的数据库锁，以减轻事务对数据库的压力，毕竟事务也是要消耗数据库的资源的。

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

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

<!-- tx:method的属性:
* name 是必须的,表示与事务属性关联的方法名(业务方法名),对切入点进行细化。通配符（*）可以用来指定一批关联到相同的事务属性的方法。
如：'get*'、'handle*'、'on*Event'等等.
* propagation 不是必须的 ，默认值是REQUIRED
表示事务传播行为, 包括REQUIRED,SUPPORTS,MANDATORY,REQUIRES_NEW,NOT_SUPPORTED,NEVER,NESTED
* isolation 不是必须的 默认值DEFAULT
表示事务隔离级别(数据库的隔离级别)
* timeout 不是必须的 默认值-1(永不超时)
表示事务超时的时间（以秒为单位）
* read-only 不是必须的 默认值false不是只读的
表示事务是否只读？
* rollback-for 不是必须的
表示将被触发进行回滚的 Exception(s)；以逗号分开。
* no-rollback-for 不是必须的
表示不被触发进行回滚的 Exception(s)；以逗号分开。

-->

//测试默认情况下
// throw new Exception("默认配置下，发生checkException异常是否回滚,不回滚");
// throw new SQLException("默认配置下，发生checkException异常是否回滚,不回滚");
// throw new Error("默认配置下，发生uncheckException异常是否回滚,回滚");
// throw new RuntimeException("默认配置下，发生uncheckException异常是否回滚,回滚");

/*try {
// throw new SQLException("默认配置下，捕获checkException异常是否回滚,不回滚");
// throw new Exception("默认配置下，捕获checkException异常是否回滚,不回滚");
// throw new Error("默认配置下，捕获uncheckException异常是否回滚,不回滚");
// throw new RuntimeException("默认配置下，捕获uncheckException异常是否回滚,不回滚");
} catch (Exception e) {
e.printStackTrace();
}*/

//检测配置rollback-for="Throwable"下
// throw new Exception("配置Throwable下，发生checkException异常是否回滚,回滚");
// throw new SQLException("配置Throwable下，发生checkException异常是否回滚,回滚");
// throw new Error("配置Throwable下，发生uncheckException异常是否回滚,回滚");
// throw new RuntimeException("配置Throwable下，发生uncheckException异常是否回滚,回滚");
/*try {
// throw new Exception("配置Throwable下，发生checkException异常是否回滚,不回滚");
// throw new SQLException("配置Throwable下，发生checkException异常是否回滚,不回滚");
// throw new Error("配置Throwable下，发生uncheckException异常是否回滚,不回滚");
// throw new RuntimeException("配置Throwable下，发生uncheckException异常是否回滚,不回滚");
} catch (Exception e) {
e.printStackTrace();
}*/
//结论：抛异常的情况下，默认只回滚uncheck异常（runtime和error）,经过配置Throwable后，子类异常和错误都回滚
// 但是try/catch后，全部不回滚