spring与jdbc整合

spring+jdbc开发，我使用的是c3p0连接池

1、数据库建表：

create table person(

       id int primary key auto_increment,

       name varchar()

)

2、配置数据源：

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

        <property name="driverClass" value="${jdbc.driverClassName}"/>

        <property name="jdbcUrl" value="${jdbc.url}"/>

        <property name="user" value="${jdbc.username}"/>

        <property name="password" value="${jdbc.password}"/>

        <property name="maxPoolSize" value="${jdbc.maxPoolSize}"/>

        <property name="minPoolSize" value="${jdbc.minPoolSize"/>

        <property name="initialPoolSize" value="${jdbc.initialPoolSize"/>

        <property name="maxIdleTime" value="${jdbc.maxIdleTime}"/>

        <property name="acquireIncrement" value="${jdbc.acquireIncrement}"/>

    </bean>

我这里使用的是c3p0连接池，不同连接池对应的数据源的class是不一样的。我的配置信息存放在属性文件中。这里使用类似el表达式读取的属性文件。

属性文件jdbc.properties:

jdbc.driverClassName=com.mysql.jdbc.Driver

jdbc.url=jdbc\:mysql\://localhost\:3306/customers?useUnicode\=true&characterEncoding\=UTF-8

jdbc.username=guodaxia

jdbc.password=961012gz

jdbc.maxPoolSize=

jdbc.minPoolSize=

jdbc.initialPoolSize=

jdbc.maxIdleTime=

jdbc.acquireIncrement=

如何让spring容器加载属性文件使得我们可以直接使用呢？

使用占位符指定属性文件：

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

这里用到了context，所以不要忘了加上context的namespace在声明中

spring中使用事务：

针对事务操作，我们需要引入事务有关的命名空间：

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

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

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

然后我们要在配置文件中装载spring提供的事务管理器：

<!-- 装载spring提供的针对数据源的事务管理器 -->

        <bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">

            <property name="dataSource" ref="dataSource"/>

        </bean>

1、使用注解方式使用事务

前提：
定义配置项（加入对应注解处理器）：

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

使用：

@Transactional 注解
放在类上，类中的所有方法都开始被spring声明式事务管理。

@Service("personService") @Transactional

public class PersonServiceBean implements PersonService {

只要该bean被spring容器管理，这样一声明该bean中的所有方法就会被spring事务管理器管理。

关于事务管理的细节：

默认的事务属性：
业务方法执行前，打开事务
业务方法结束前，结束事务
什么时候事务提交，什么时候事务回滚呢？
默认情况下对于业务方法出现运行期异常RuntimeException，也叫checked异常，会进行事务的回滚
如果业务方法出现Exception的话，默认的事务是不会滚的，Exception也叫checked异常

限定异常类型是否回滚的属性：
noRollbackFor 指定不会滚的对应的异常类型
rollbackFor 指定回滚对应的异常类型

@Transactional(noRollbackFor=RuntimeException.class,rollbackFor=Exception.class)

public void deletePerson(Integer personId) throws Exception{

noRollbackForClassName和rollbackForClassName我就不说了

事务传播属性（propagation）：
我们知道spring管理事务默认是方法开始前打开事务，结束后关闭事务。@Transactional注解放在类上，则该类的所有方法都具有事务特性。但我们有时候需要改变这种特性，
比如：我的查询方法不希望开启和打开事务，这时怎么办呢？
我们需要使用@Transactional注解的另一个属性propagation。

属性值以及对应的意义：
REQUIRED:
业务方法需要在一个事务中运行。如果方法运行时，已经处在一个事务中，那么加入到该事务，否则为自己创建一个新的事务。这是spring默认的事务传播属性
NOT_SUPPORT：
声明方法不需要事务。如果方法没有关联到一个事务，容器不会为它开启事务。如果方法在一个事务中被调用，该事务会被挂起，在方法调用结束后，原先的事务便
会恢复执行
MANDATORY:
该属性指定事务方法只能在一个已经存在的事务中执行，业务方法不能发起自己的事务，如果业务方法没有在事务的环境下调用，容器就会抛出异常。
SUPPORTS：
这一属性表明，如果业务方法在某个事务范围内被调用，则方法称为该事务的一部分，如果业务方法在事务范围外被调用，则方法在没有事务的环境下执行。
NEVER:
指定业务方法绝对不能在事务范围内执行。如果业务放大在某个事务中执行，则容器会抛出异常，只有业务方法没有关联到任何事务，才能正常执行。
NESTED:
如果一个活动的事务存在，则运行在一个嵌套的事务中，如果没有活动事务，则按REQUIRED属性执行，它使用了一个单独的事务，这个事务拥有多个可以回
滚的保存点。内部事务的回滚不会对外部事务造成影响。它只对DataSourceTransactionManager事务管理器起效果。外部事务的回滚会对内部事务造成影响，也要回滚。

@Transactional(propagation=Propagation.NEVER)

public void deletePerson(Integer personId){

设置事务的等待时间：timeout属性

设置事务的隔离级别（isolation）：
数据库系统提供了四种事务隔离级别
Read Uncommited：读未提交数据（会出现脏读，不可重复读和幻读）
Read Commited：读已提交数据（会出现不可重复读和幻读）
Repeatable Read：可重复读（会出现幻读，解决不可重复读的方式类似于镜像）
Serializable：串行化

脏读：
一个事务读取到另一事务未提交的更新数据
不可重读：
在同一事务中，多次读取同一数据返回的结果有所不同。换句话说，后续读取可以读取到另一事务的更新数据。相反，“不可重复读”在同一事务中多次读取
事务时，能够保证所读数据一样，也就是后续速去不能读取到另一事务已经提交的更新数据。
幻读：
一个事务读取到另一事务已经提交的insert数据

@Transactional(isolation=Isolation.READ_COMMITTED)

public void deletePerson(Integer personId){

基于xml方式配置事务

beans.xml中：

　　<aop:config>

        <aop:pointcut expression="execution(* cn.itcast.service..*.*(..))" id="mycut"/>

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

    </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>

检验事务是否成功管理：

public void deletePerson(Integer personId){

        jdbcTemplate.update("delete from person where id=?",

                new Object[]{personId},

                new int[]{java.sql.Types.INTEGER});

        jdbcTemplate.update("delete from personss where id=3");

    }

第二条删除语句中表名有误，测试的时候如果spring管理了事务则两条sql语句都会回滚，也就是同一个事务，如果没有管理事务则只有一条sql语句回滚，所有第一条还是会
删除数据库记录

完整代码（部分被后面覆盖）

package cn.itcast.service;

import java.util.List;

import cn.itcast.domain.Person;

public interface PersonService {

    /**

     * 保存person

     * @param person

     */

    public void save(Person person);

    /**

     * 更新person

     * @param person

     */

    public void update(Person person);

    /**

     * 根据id获取person

     * @param personId

     * @return

     */

    public Person getPerson(Integer personId);

    /**

     * 获取所有person

     * @return

     */

    public List<Person> getPersons();

    /**

     * 根据id删除person

     * @param personId

     */

    public void deletePerson(Integer personId);

}

PersonService.java

package cn.itcast.service.impl;

import java.util.List;

import javax.annotation.Resource;

import javax.sql.DataSource;

import org.springframework.jdbc.core.JdbcTemplate;

import org.springframework.stereotype.Service;

import org.springframework.transaction.annotation.Transactional;

import cn.itcast.domain.Person;

import cn.itcast.service.PersonService;

@Service("personService") @Transactional

public class PersonServiceBean implements PersonService {

    private JdbcTemplate jdbcTemplate;

    public void save(Person person) {

        jdbcTemplate.update("insert into person(name) values(?)",

                new Object[]{person.getName()},

                new int[]{java.sql.Types.VARCHAR});

    }

    public void update(Person person) {

        jdbcTemplate.update("update person set name=? where id=?",

                new Object[]{person.getName(),person.getId()},

                new int[]{java.sql.Types.VARCHAR,java.sql.Types.INTEGER});

    }

    public Person getPerson(Integer personId) {

        Person person = (Person) jdbcTemplate.queryForObject("select * from person where id=?",

                new Object[]{personId},

                new int[]{java.sql.Types.INTEGER},

                new PersonRowMapper());

        return person;

    }

    public List<Person> getPersons() {

        @SuppressWarnings("unchecked")

        List<Person> persons=jdbcTemplate.query("select * from person", new PersonRowMapper());

        return persons;

    }

    public void deletePerson(Integer personId){

        jdbcTemplate.update("delete from person where id=?",

                new Object[]{personId},

                new int[]{java.sql.Types.INTEGER});

        jdbcTemplate.update("delete from personss where id=3");

    }

    @Resource(name="dataSource")

    public void setDataSource(DataSource dataSource) {

        this.jdbcTemplate = new JdbcTemplate(dataSource);

    }

}

PersonServiceBean.java

package cn.itcast.service.impl;

import java.sql.ResultSet;

import java.sql.SQLException;

import org.springframework.jdbc.core.RowMapper;

import cn.itcast.domain.Person;

public class PersonRowMapper implements RowMapper{

    //外部调用我们方法的时候已经做了rs.next()操作

    public Object mapRow(ResultSet rs, int index) throws SQLException {

        Person person=new Person(rs.getInt("id"),rs.getString("name"));

        return person;

    }

}

PersonRowMapper.java

package junit.test;

import java.util.List;

import org.junit.BeforeClass;

import org.junit.Test;

import org.springframework.context.ApplicationContext;

import org.springframework.context.support.ClassPathXmlApplicationContext;

import cn.itcast.domain.Person;

import cn.itcast.service.PersonService;

public class PersonServiceBeanTest {

    private static PersonService personService;

    @BeforeClass

    public static void setUpBeforeClass() throws Exception {

        try{

            ApplicationContext ctx=new ClassPathXmlApplicationContext("beans.xml");

            personService=(PersonService) ctx.getBean("personService");

        }catch(RuntimeException e){

            e.printStackTrace();

        }

    }

    @Test public void testSave(){

        for(int i=;i<;i++)

            personService.save(new Person("传智播客"+""));

    }

    @Test public void testUpdate(){

        Person person=personService.getPerson();

        person.setName("张三");

        personService.update(person);

    }

    @Test public void testDetetePerson(){

            personService.deletePerson();

    }

    @Test public void testgetPerson(){

        Person person=personService.getPerson();

        System.out.println(person.getId()+" "+person.getName());

    }

    @Test public void testFindAll(){

        List<Person> persons=personService.getPersons();

        if(persons!=null){

            for(Person person:persons){

                System.out.println(person.getId()+" "+person.getName());

            }

        }

    }

}

PersonServiceBeanTest.java

<?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: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/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

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

           http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">

    <context:component-scan base-package="cn.itcast"/>

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

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

        <property name="driverClass" value="${jdbc.driverClassName}"/>

        <property name="jdbcUrl" value="${jdbc.url}"/>

        <property name="user" value="${jdbc.username}"/>

        <property name="password" value="${jdbc.password}"/>

        <property name="maxPoolSize" value="${jdbc.maxPoolSize}"/>

        <property name="minPoolSize" value="${jdbc.minPoolSize}"/>

        <property name="initialPoolSize" value="${jdbc.initialPoolSize}"/>

        <property name="maxIdleTime" value="${jdbc.maxIdleTime}"/>

        <property name="acquireIncrement" value="${jdbc.acquireIncrement}"/>

    </bean>   

    <!-- 装载spring提供的针对数据源的事务管理器 -->

    <bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">

        <property name="dataSource" ref="dataSource"/>

    </bean>

    <!-- 打开注解配置管理事务的处理器 -->

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

    <aop:config>

        <aop:pointcut expression="execution(* cn.itcast.service..*.*(..))" id="mycut"/>

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

    </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>

</beans>

beans.xml

巴特西

spring与jdbc整合

最新文章

热门文章