1.与JDBC集成的配置步骤:
①配置数据源,如:
第一种方式:直接在XML中配置数据源:
<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
<property name="driverClassName" value="org.gjt.mm.mysql.Driver"/>
<property name="url" value="jdbc:mysql://localhost:3306/itcast?useUnicode=true&characterEncoding=UTF-8"/>
<property name="username" value="root"/>
<property name="password" value="123456"/>
<!-- 连接池启动时的初始值 -->
<property name="initialSize" value="1"/>
<!-- 连接池的最大值 -->
<property name="maxActive" value="500"/>
<!-- 最大空闲值.当经过一个高峰时间后,连接池可以慢慢将已经用不到的连接慢慢释放一部分,一直减少到maxIdle为止 -->
<property name="maxIdle" value="2"/>
<!-- 最小空闲值.当空闲的连接数少于阀值时,连接池就会预申请去一些连接,以免洪峰来时来不及申请 -->
<property name="minIdle" value="1"/>
</bean>
第二种方式:使用属性占位符方式配置数据源
<context:property-placeholder location=“jdbc.properties”/>
<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
<property name="driverClassName" value="${driverClassName}"/>
<property name="url" value="${url}"/>
<property name="username" value="${username}"/>
<property name="password" value="${password}"/>
<!-- 连接池启动时的初始值 -->
<property name="initialSize" value="${initialSize}"/>
<!-- 连接池的最大值 -->
<property name="maxActive" value="${maxActive}"/>
<!-- 最大空闲值.当经过一个高峰时间后,连接池可以慢慢将已经用不到的连接慢慢释放一部分,一直减少到maxIdle为止 -->
<property name="maxIdle" value="${maxIdle}"/>
<!-- 最小空闲值.当空闲的连接数少于阀值时,连接池就会预申请去一些连接,以免洪峰来时来不及申请 -->
<property name="minIdle" value="${minIdle}"/>
</bean>
其中,jdbc.properties 文件放在类路径下,内容如下:
driverClassName=org.gjt.mm.mysql.Driver
url=jdbc\:mysql\://localhost\:3306/itcast?useUnicode\=true&characterEncoding\=UTF-8
username=root
password=123456
initialSize=1
maxActive=500
maxIdle=2
minIdle=1
两种方式各有优缺点,个人感觉第二种方式更好些,把jdbc的配置提出来,这样直接修改属性文件就可以更改jdbc的配置,
在XML中引用这些配置就像是使用EL表达式一样
initialSize:连接池启动时的初始值,一般2-3就足够了
maxActive:连接池最大的连接数,这个要根据应用的大小来定
maxIdle:最大空闲值.当经过一个高峰时间后,连接池可以慢慢将已经用不到的连接慢慢释放一部分,一直减少到maxIdle为止
minIdle:最小空闲值.当空闲的连接数少于阀值时,连接池就会预申请去一些连接,以免洪峰来时来不及申请
②配置事务。配置事务时,需要在xml配置文件中引入用于声明事务的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"
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-2.5.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd">
</beans>
注意要添加 tx 命名空间 以及 相应的 schemaLocation
事务的配置方式有两种:注解方式和基于XML配置方式。
①注解方式:
采用注解方式
<bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource"/>
</bean>
<!– 采用@Transactional注解方式使用事务 -->
<tx:annotation-driven transaction-manager="txManager"/>
@Service
public class PersonServiceBean implements PersonService {
}
[注意] 注解的使用建议:
②XML方式:
<bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource"/>
</bean>
<aop:config>
<aop:pointcut id="transactionPointcut" expression="execution(* cn.itcast.service..*.*(..))"/>
<aop:advisor advice-ref="txAdvice" pointcut-ref="transactionPointcut"/>
</aop:config>
<tx:advice id="txAdvice" transaction-manager="txManager">
<tx:attributes>
<tx:method name="get*" read-only="true" propagation="NOT_SUPPORTED"/>
<tx:method name="*"/>
</tx:attributes>
</tx:advice>
配置中 <aop:config/>
的定义, 它确保由 'txAdvice'
bean定义的事务通知在应用中合适的点被执行。 首先我们定义了 一个切面,
它匹配 Service
接口定义的所有操作, 我们把该切面叫做 'ServiceOperation'
。然后我们用一个通知器(advisor)把这个切面与
'txAdvice'
绑定在一起, 表示当 'ServiceOperation'
执行时,'txAdvice'
定义的通知逻辑将被执行。
为不同的bean配置事务:
<tx:advice> 有关的设置:
2.使用Spring注解方式管理事务与传播行为
参考文档:
在理解Spring的声明式事务管理方面最重要的概念是:Spring的事务管理是通过AOP代理实现的。 其中的事务通知由元数据(目前基于XML或注解)驱动。
代理对象与事务元数据结合产生了一个AOP代理,它使用一个PlatformTransactionManager
实现品配合TransactionInterceptor
,在方法调用前后实施事务。
事务传播属性:
REQUIRED:业务方法需要在一个事务中运行。如果方法运行时,已经处在一个事务中,那么加入到该事务,否则为自己创建一个新的事务。
NOT_SUPPORTED:声明方法不需要事务。如果方法没有关联到一个事务,容器不会为它开启事务。
如果方法在一个事务中被调用,该事务会被挂起,在方法调用结束后,原先的事务便会恢复执行。
REQUIRESNEW:属性表明不管是否存在事务,业务方法总会为自己发起一个新的事务。如果方法已经运行在一个事务中,则原有事务会被挂起,
新的事务会被创建,直到方法执行结束,新事务才算结束,原先的事务才会恢复执行。
MANDATORY:该属性指定业务方法只能在一个已经存在的事务中执行,业务方法不能发起自己的事务。
如果业务方法在没有事务的环境下调用,容器就会抛出例外。
SUPPORTS:这一事务属性表明,如果业务方法在某个事务范围内被调用,则方法成为该事务的一部分。
如果业务方法在事务范围外被调用,则方法在没有事务的环境下执行。
Never:指定业务方法绝对不能在事务范围内执行。如果业务方法在某个事务中执行,容器会抛出例外,只有业务方法没有关联到任何事务,才能正常执行。
NESTED:如果一个活动的事务存在,则运行在一个嵌套的事务中. 如果没有活动事务, 则按REQUIRED属性执行.
它使用了一个单独的事务,这个事务拥有多个可以回滚的保存点。内部事务的回滚不会对外部事务造成影响。
它只对DataSourceTransactionManager事务管理器起效
图解:
nested 介绍
Connection conn = null;
try {
conn.setAutoCommit(false);
Statement stmt = conn.createStatement();
stmt.executeUpdate("update person set name='888' where id=1");
try{
conn.createStatement().executeUpdate("update person set name='222' where sid=2");
}catch(Exception ex){
}
stmt.executeUpdate("delete from person where id=9");
conn.commit();
stmt.close();
} catch (Exception e) {
conn.rollback();
}finally{
try {
if(null!=conn && !conn.isClosed()) conn.close();
} catch (SQLException e) { e.printStackTrace(); }
}
}
上面的代码中间部分是由spring可我们创建的,它共有三条sql更新语句,中间的那个方法在外围是声明为nested!
中间的方法的事务对上下两个方法是不会有影响的
注意:默认情况下,遇到了运行期异常(unchecked异常的一种),事务会回滚;
遇到了checked异常,事务不会回滚。但是也可以用注解方式改变
参考文档:我们推荐做法是在Spring框架的事务架构里指出当context的事务里的代码抛出 Exception
时事务进行回滚。
Spring框架的事务基础架构代码将从调用的堆栈里捕获到任何未处理的 Exception
,并将标识事务将回滚。
然而,请注意Spring框架的事务基础架构代码将默认地 只 在抛出运行时和unchecked exceptions时才标识事务回滚。
也就是说,当抛出一个 RuntimeException
或其子类例的实例时,(Errors
也一样 - 默认地 - 标识事务回滚。)从事务方法中
抛出的Checked exceptions将 不 被标识进行事务回滚。
可以通过设置 rollback-for 和 no-rollback-for 来修改默认的设置,决定事务是否回滚
指定回滚事务的方法:
3.数据库提供了四种事务隔离级别
数据库系统提供了四种事务隔离级别供用户选择。不同的隔离级别采用不同的锁类型来实现,在四种隔离级别中,
Serializable的隔离级别最高,Read Uncommited的隔离级别最低。大多数据库默认的隔离级别为Read Commited,如SqlServer
当然也有少部分数据库默认的隔离级别为Repeatable Read ,如Mysql
Read Uncommited:读未提交数据(会出现脏读,不可重复读和幻读)。
Read Commited:读已提交数据(会出现不可重复读和幻读)
Repeatable Read:可重复读(会出现幻读)
Serializable:串行化
脏读:一个事务读取到另一事务未提交的更新新据。
不可重复读:在同一事务中,多次读取同一数据返回的结果有所不同。换句话说就是,后续读取可以读到另一事务已提交的更新数据。
相反,“可重复读”在同一事务中多次读取数据时,能够保证所读数据一样,也就是,后续读取不能读到另一事务已提交的更新数据。
幻读:一个事务读取到另一事务已提交的insert数据。
本节测试代码:
首先,假设不使用事务!
新建一个接口:
package com.yinger.service;
import java.util.List;
import com.yinger.domain.Person;
public interface PersonService3 {
public void save(Person p);
public void update(Person p);
public void delete(int personid);
public Person getPerson(int personid);
public List<Person> getPersons();
}
新建实现类:
package com.yinger.service.impl;
import java.util.List;
import javax.annotation.Resource;
import javax.sql.DataSource;
import org.springframework.jdbc.core.JdbcTemplate;
import com.yinger.domain.Person;
import com.yinger.service.PersonService3;
public class PersonServiceBean5 implements PersonService3{
private JdbcTemplate jdbcTemplate;
//默认的构造器
public PersonServiceBean5(){}
@Resource
public void setDataSource(DataSource dataSource){
jdbcTemplate = new JdbcTemplate(dataSource); // 用dataSource构造一个JdbcTemplate
}
//save方法
public void save(Person p) {
jdbcTemplate.update("insert into person(name) values(?)", new Object[]{p.getName()},
new int[]{java.sql.Types.VARCHAR});
}
//update方法
public void update(Person p) {
jdbcTemplate.update("update person set name=? where id=?", new Object[]{p.getName(),p.getId()},
new int[]{java.sql.Types.VARCHAR,java.sql.Types.INTEGER});
}
//delete方法
public void delete(int personid) {
jdbcTemplate.update("delete from person where id=?", new Object[]{personid},
new int[]{java.sql.Types.INTEGER});
}
//根据id得到person方法
public Person getPerson(int personid) {
return (Person)jdbcTemplate.queryForObject("select * from person where id=?", new Object[]{personid}, new PersonRowMapper());
}
//得到所有的person的方法
@SuppressWarnings("unchecked")
public List<Person> getPersons() {
return (List<Person>)jdbcTemplate.query("select * from person", new Object[]{}, new PersonRowMapper());
}
}
在 Mysql 数据库中新建一个数据库 hibernate,新建一张表 person,里面有两个字段 id(int)[设置为主键,自增长],name(varchar)
数据库连接的属性文件:
driverClassName=org.gjt.mm.mysql.Driver
url=jdbc\:mysql\://localhost/hibernate
username=root
password=yinger
initialSize=1
maxActive=500
maxIdle=2
minIdle=1
beans.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:context="http://www.springframework.org/schema/context"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">
<context:annotation-config/>
<context:property-placeholder location="jdbc.properties" />
<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource"
destroy-method="close">
<property name="driverClassName" value="${driverClassName}" />
<property name="url" value="${url}" />
<property name="username" value="${username}" />
<property name="password" value="${password}" />
<!-- 连接池启动时的初始值 -->
<property name="initialSize" value="${initialSize}" />
<!-- 连接池的最大值 -->
<property name="maxActive" value="${maxActive}" />
<!-- 最大空闲值.当经过一个高峰时间后,连接池可以慢慢将已经用不到的连接慢慢释放一部分,一直减少到maxIdle为止 -->
<property name="maxIdle" value="${maxIdle}" />
<!-- 最小空闲值.当空闲的连接数少于阀值时,连接池就会预申请去一些连接,以免洪峰来时来不及申请 -->
<property name="minIdle" value="${minIdle}" />
</bean>
<bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource" />
</bean>
<!-- 采用@Transactional注解方式使用事务 -->
<tx:annotation-driven transaction-manager="txManager" />
<bean id="personService5" class="com.yinger.service.impl.PersonServiceBean5"></bean>
</beans>
测试代码:
@Test //用于测试事务管理的方法
public void testTrancation() throws Exception {
AbstractApplicationContext ctx = new ClassPathXmlApplicationContext("beans.xml");
System.out.println("--------");
PersonService3 ps3 = (PersonService3)ctx.getBean("personService5");
//save
for(int i=0;i<5;i++){
Person person = new Person("personname"+(i+1));
ps3.save(person);
}
//delete
ps3.delete(3);
//getPerson
Person p = ps3.getPerson(2);
p.setName("new name");
//update
ps3.update(p);
//getPersons
List<Person> persons = ps3.getPersons();
for(int i=0,size=persons.size();i<size;i++){
System.out.println(persons.get(i).getName());
}
ctx.close();
}
测试结果:
log4j:WARN No appenders could be found for logger (org.springframework.context.support.ClassPathXmlApplicationContext).
log4j:WARN Please initialize the log4j system properly.
--------
查看数据库也是如此,说明这个测试时可以的!
但是,想想,没有事务真的可以吗? 不可以的!
假设,如果在 delete 方法中在添加一句 insert 语句
//delete方法
public void delete(int personid) {
jdbcTemplate.update("delete from person where id=?", new Object[]{personid},
new int[]{java.sql.Types.INTEGER});
jdbcTemplate.update("delete from person where id=?", new Object[]{personid},
new int[]{java.sql.Types.INTEGER});
}
如果是这种方法,那么两次插入操作是在不同的事务中的,很显然这样就会造成一些问题!
如果希望两个操作要么都成功,要么都失败,那么就不可以了!
为了解决这些麻烦,Spring提供了事务管理器,通过一些配置就可以将方法设置成我们想要的事务类型
package com.yinger.service.impl;
import java.util.List;
import javax.annotation.Resource;
import javax.sql.DataSource;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import com.yinger.domain.Person;
import com.yinger.service.PersonService3;
public class PersonServiceBean5 implements PersonService3{
private JdbcTemplate jdbcTemplate;
//默认的构造器
public PersonServiceBean5(){}
@Resource
public void setDataSource(DataSource dataSource){
jdbcTemplate = new JdbcTemplate(dataSource); // 用dataSource构造一个JdbcTemplate
}
//save方法
public void save(Person p) {
jdbcTemplate.update("insert into person(name) values(?)", new Object[]{p.getName()},
new int[]{java.sql.Types.VARCHAR});
}
//update方法
public void update(Person p) {
jdbcTemplate.update("update person set name=? where id=?", new Object[]{p.getName(),p.getId()},
new int[]{java.sql.Types.VARCHAR,java.sql.Types.INTEGER});
}
//delete方法
public void delete(int personid) {
jdbcTemplate.update("delete from person where id=?", new Object[]{personid},
new int[]{java.sql.Types.INTEGER});
}
//根据id得到person方法 get*方法是不用使用事务的
public Person getPerson(int personid) {
return (Person)jdbcTemplate.queryForObject("select * from person where id=?", new Object[]{personid}, new PersonRowMapper());
}
//得到所有的person的方法
@SuppressWarnings("unchecked")
public List<Person> getPersons() {
return (List<Person>)jdbcTemplate.query("select * from person", new Object[]{}, new PersonRowMapper());
}
}
OK 了!以上就是使用注解方式实现事务管理