Spring JdbcTemplate&声明式事务

时间  2020-05-24
标签 spring jdbctemplate 声明 事务 栏目 Spring 繁體版
原文   原文链接

一、JdbcTemplate基本使用

1）、JdbcTemplate基本使用-概述(了解)

JdbcTemplate是spring框架中提供的一个对象，是对原始繁琐的Jdbc API对象的简单封装。spring框架为咱们提供了不少的操做模板类。例如：操做关系型数据的JdbcTemplate和HibernateTemplate，操做nosql数据库的RedisTemplate，操做消息队列的JmsTemplate等等。

2）、JdbcTemplate基本使用-开发步骤(理解)

①导入spring-jdbc和spring-tx（事务）坐标

②建立数据库表和实体  

③建立JdbcTemplate对象  设置链接池

④执行数据库操做

3）、JdbcTemplate基本使用-快速入门代码实现(应用)

①导入Spring-jdbc和Spring-tx坐标(依赖)php

<dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-jdbc</artifactId>
      <version>5.0.5.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-tx</artifactId>
      <version>5.0.5.RELEASE</version>
    </dependency>

<!--使用jdk1.8版本编译-->
<build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.1</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                </configuration>
            </plugin>
        </plugins>
    </build>

②建立数据库表和实体java

package com.ppvir.domain;

public class Account {

    private String name;
    private double money;

    public String getNa me() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getMoney() {
        return money;
    }

    public void setMoney(double money) {
        this.money = money;
    }

    @Override
    public String toString() {
        return "Account{" +
                "name='" + name + '\'' +
                ", money=" + money +
                '}';
    }
}

③建立JdbcTemplate对象 设置链接池 ④执行数据库操做mysql

@Test
    //测试JdbcTemplate开发步骤
    public void test1() throws PropertyVetoException {
        //2，建立数据源对象，c3p0链接池
        ComboPooledDataSource dataSource = new ComboPooledDataSource();
        //数据库参数设置
        dataSource.setDriverClass("com.mysql.jdbc.Driver");
        dataSource.setJdbcUrl("jdbc:mysql://localhost:3306/test");
        dataSource.setUser("root");
        dataSource.setPassword("root");

        JdbcTemplate jdbcTemplate = new JdbcTemplate();
        //1，设置数据源对象  知道数据库在哪
        jdbcTemplate.setDataSource(dataSource);
        //三、执行数据库操做
        int row = jdbcTemplate.update("insert into account values(?,?)", "java", 18000);
        System.out.println(row);

    }

4）、JdbcTemplate基本使用-spring产生模板对象分析(理解)

咱们能够将JdbcTemplate的建立权交给Spring， 将数据源DataSource的建立权也交给Spring， 在Spring容器内部将数据源DataSource注入到JdbcTemplate模版对象中, 而后经过Spring容器得到JdbcTemplate对象来执行操做。spring

注入与被注入对象都必须在spring容器中sql

5）、JdbcTemplate基本使用-spring产生模板对象代码实现(应用)

在上面例子的基础上，编写applicationContext.xml配置数据源对象 配置：数据库

applicationContext.xml
<!--数据源链接池对象-->
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPoolDataSource">
        <property name="driverClass" value="com.mysql.jdbc.Driver"></property>
        <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/aop"/>
        <property name="user" value="root"/>
        <property name="password" value="root"/>
 </bean>
<!--jdbc模版对象-->
<bean class="org.springframework.jdbc.core.JdbcTemplate" id="jdbcTemplate">
        <property name="dataSource" ref="dataSource"></property>
</bean>

测试代码：express

/**
     * 测试Spring产生jdbcTemplate对象
     */
    @Test
    public void testTemplate() throws Exception{
       //加载配置文件
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("classpath:applicationContext.xml");
        //获取spring容器中初始化的getBean
        JdbcTemplate jdbcTemplate = context.getBean(JdbcTemplate.class);
        //c操做数据库
        jdbcTemplate.update("insert into account(name,money) VALUES(?,?)","js",19990);
    }

6）、JdbcTemplate基本使用-spring产生模板对象代码实现（抽取jdbc.properties）(应用)

将数据库的链接信息抽取到外部配置文件中，和spring的配置文件分离开，有利于后期维护
jdbc.propreties

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/aop
jdbc.username=root
jdbc.password=root

修改配置文件：apache

<!--加载jdbc.properties-->
<context:property-placeholder location="classpath:jdbc,properties">
<!--数据源对象-->
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="${jdbc.driver}"/>
        <property name="jdbcUrl" value="${jdbc.url}"/>
        <property name="user" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
</bean>

7）、JdbcTemplate基本使用-经常使用操做-更新操做&查询操做(应用)

使用注解注入编程

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class JdbcTemplateAnnoTest {
    @Autowired
    private JdbcTemplate jdbcTemplate;

    /**
     * 更新操做
     */
    @Test
    public void updateTest(){
        jdbcTemplate.update("update account set money=? where name=?",10000,"java");
    }

    @Test
    /**
     * 删除操做
     */
    public void delTest(){
        jdbcTemplate.update("delete from account where name=?","php");
    }

    //查询全部
    @Test
    public void queryAllTest(){
        List<Account> accountList = jdbcTemplate.query("select * from account", new BeanPropertyRowMapper<>(Account.class));
        for (Account account : accountList) {
            System.out.println(account);
        }
    }
    //查询一个
    @Test
    public void queryOneTest(){
        Account name = jdbcTemplate.queryForObject("select * from account where name=?", new BeanPropertyRowMapper<>(Account.class), "java");
        System.out.println(name);
    }
    //聚合查询
    @Test
    public void queryCountTest(){
        Long aLong = jdbcTemplate.queryForObject("select count(*) from account", long.class);//requiedType
        System.out.println(aLong);
    }

}

###9）、JdbcTemplate基本使用-知识要点(理解，记忆)api

  • 导入spring-jdbc和spring-tx坐标依赖
  • 建立数据库表和实体
  • 建立jdbcTemplate对象
    • JdbcTemplate jdbcTemplate = newJdbcTemplate();
    • jdbcTemplate.setDataSource(dataSource);
  • 执行数据库CRUB操做
更新操做：

    jdbcTemplate.update (sql,params)

查询操做：

    jdbcTemplate.query (sql,Mapper,params)//多个对象

    jdbcTemplate.queryForObject(sql,Mapper,params)//单个对象

#二、声明式事务控制

***事务：***不可分割的操做要么同时成功要么同时失败 声明式事务控制=AOP+编程式事务控制，在xml配置文件中声明

###2.一、编程式事务控制相关的对象 概念：经过java代码手动开启事务，提交事务，回滚事务。 #####2.1.一、PlatformTransactionManager （平台事务管理器） PlatformTransactionManager 接口是 spring 的事务管理器，它里面提供了咱们经常使用的操做事务的方法 平台事务管理器

注意： PlatformTransactionManager 是接口类型，不一样的 Dao 层技术则有不一样的实现类，经过配置告诉spring，集成的哪一个框架，spring根据不一样的框架选择不一样的操做。

Dao层的技术 实现类
jdbc 或 mybatis org.springframework.jdbc.datasource.DataSourceTransactionManager
hibernate（架构） org.springframework.orm.hibernate5.HibernateTransactionManager

#####2.1.二、 TransactionDefinition(事务的详细配置信息存放) 封装事务的参数 TransactionDefinition 是事务的定义信息对象，里面有以下方法：

方法 说明
int getIsolationLevel() 得到事务的隔离级别
int getPropogationBehavior() 得到事务的传播行为
int getTimeout() 得到超时时间
boolean isReadOnly 是否只读
  • 1.事务的隔离级别 设置隔离级别，能够解决事务并发产生的问题，如脏读、不可重复读和虚读(幻读)。
    • ISOLATION_DEFAULT
    • ISOLATION_READ_UNCOMMITTED//读未提交的数据 脏读不可重复读
    • ISOLATION_READ-COMMITTED//读已提交数据，可是容许其余人修改
    • ISOLATION-REPEATABLE_READ//读到提交的数据，同时不容许别人修改，容许增删。
    • ISOLATION_SERIALIZEBLE//读到提交的数据，同时不容许别人任何操做。
  • 2.事务的传播行为 主要做用是 解决业务方法调用业务方法时统一
    • REQUIRED：required若是当前没有事务，就新建一个事务，若是已经存在一个事务中，加入到这个事务中。通常的选择（默认值）有就用，没有就建立
    • SUPPORTS：支持当前事务，若是当前没有事务，就以非事务方式执行（没有事务）有就用，没有就不用
    • MANDATORY：使用当前的事务，若是当前没有事务，就抛出异常
    • REQUERS_NEW：新建事务，若是当前在事务中，把当前事务挂起。
    • NOT_SUPPORTED：以非事务方式执行操做，若是当前存在事务，就把当前事务挂起 有没有都不用
    • NEVER：以非事务方式运行，若是当前存在事务，抛出异常
    • NESTED：若是当前存在事务，则在嵌套事务内执行。若是当前没有事务，则执行 REQUIRED 相似的操做
    • 超时时间：默认值是-1，没有超时限制。若是有，以秒为单位进行设置 timwout
    • 是否只读：建议查询时设置为只读 read-only #####2.1.三、 TransactionStatus（获取事务的状态信息） TransactionStatus 接口提供的是事务具体的运行状态，方法介绍以下。

状态是被动信息，不是主动设置的。

平台事务管理器（指定事务控制行为）+事务定义对象（封装事务的参数）=事务状态对象（被动的封装程序的动态信息）

方法 说明
boolean hasSavepoint() 是否存储滚回点
boolean isCompleted() 事务是否完成
boolean isNewTransaction() 是不是新事务
boolean isRollbackOnly() 事务是否滚回

###2.二、 基于xml的声明式事务控制（方便统一配置） #####2.2.1 什么是声明式事务控制

Spring 的声明式事务顾名思义就是采用声明的方式来处理事务。这里所说的声明，就是指在配置文件中声明，用在 Spring 配置文件中声明式的处理事务来代替代码式的处理事务。

声明式事务控制=AOP+编程式事务控制，在xml配置文件中声明

声明式事务处理的做用

  • 事务管理不侵入开发的组件（解耦性）。具体来讲，业务逻辑对象就不会意识到正在事务管理之中，事实上也应该如此，由于事务管理是属于系统层面的服务，而不是业务逻辑的一部分，若是想要改变事务管理策划的话，也只须要在定义文件中从新配置便可
  • 在不须要事务管理的时候，只要在设定文件上修改一下，便可移去事务管理服务，无需改变代码从新编译，这样维护起来极其方便

注意：Spring 声明式事务控制底层就是AOP。 #####2.2.二、声明式事务控制的体现

声明式事务控制 明确事项：

谁是切点，哪一个是将要被加强的方法 谁是通知，加强方法 配置切面 ①配置文件引入tx命名空间

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="
       http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
       http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd
       http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd
">

②配置事务加强 & 事务AOP织入

<!--在上面引入tx aop命名空间-->

    <!--
        配置事务加强:
            1.平台事务管理器
            2.事务加强配置
            3.配置事务AOP织入
    -->
    <!--1.告诉spring使用什么框架来操做数据库，不一样的框架，底层操做事务的方式是不一样的bean-->
    <bean class="org.springframework.jdbc.datasource.DataSourceTransactionManager" id="transactionManager">
        <property name="dataSource" ref="dataSource"/>
    </bean>

    <!--2.事务加强配置 tx-->
    <tx:advice id="txAdvice" transaction-manager="transactionManager">
        <tx:attributes><!--事务的属性-->
            <tx:method name="*"/><!--对切点（方法）进行加强 *：表明加强全部的切点（方法）-->
        </tx:attributes>
        <!--
        切点方法的事务参数配置
        <tx:method name="transfer" isolation="REPEATABLE_READ" propagation="REQUIRED" timeout="-1" read-only="false"/>
        - name：切点方法名称
        - isolation:事务的隔离级别
        - propogation：事务的传播行为
        - timeout：超时时间
        - read-only：是否只读

        -->
    </tx:advice>
    <!--3.配置事务AOP织入-->
    <aop:config>
        <!--抽取切点表达式-->
        <aop:pointcut id="myPointcut" expression="execution(* *cn.ppvir.service.impl.*.*(..))"/>
        <!--织入-->
        <aop:advisor advice-ref="txAdvice" pointcut-ref="myPointcut"></aop:advisor>
    </aop:config>

#####2.2.三、小结要点 声明式事务控制的配置要点

  • 平台事务管理器的配置，告诉spring将要使用哪套api进行配置
  • 事务通知的配置，事务加强
    • 参数配置，通配或者单独配置
  • 事务aop织入的配置
    • adviser表明只有一个通知
    • 切点表达式也能够对外进行抽取
      • <aop:pointcut id="myPointcut" expression="execution(* *cn.ppvir.service.impl.*.*(..))"/>

###2.三、基于注解的声明式事务控制 #####2.3.一、 使用注解配置声明式事务控制

使用注解在xml中配置组件扫描<context:componet-scan/>，建议使用场景：

注解使用通常是自定义的bean,由于能够拿到源码 *XML * 通常是非自定义的bean 注解@Transactional(事务参数)，能够在类上或方法上，或单独配置，如包含多层注解事务控制，就近原则执行。

  • 编写AccountDao，@Respostitory() 注解DAO配置bean、@Autowired自动注入
  • 编写AccountService, @Service()注解Service配置bean @Transactional()注解事务通知的配置
/**
1) AccountDao
 * 数据库操做的实现类
 * 注解方式@Respository("accountDao")
 */
@Repository("accountDao")
public class AccountDao implements IAccountDao {
    public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
        this.jdbcTemplate = jdbcTemplate;
    }
    @Autowired
    private JdbcTemplate jdbcTemplate;

    @Override
    public void out(String outMan, double money) {
        jdbcTemplate.update("update account set money=money-? where name=?",money,outMan);

    }
    @Override
    public void in(String inMan, double money) {
        jdbcTemplate.update("update account SET money=money+? where name=?",money,inMan);

    }
    @Override
    public void queryAll() {
        List<Account> accountList = jdbcTemplate.query("select * from account", new BeanPropertyRowMapper<>(Account.class));
        for (Account account : accountList) {
            System.out.println(account);
        }
    }
}

/**
2)AccountService
 * 具体的业务操做实现类
 */
@Service("accountService") 
@Transactional(isolation = Isolation.READ_COMMITTED)//注解事务通知配置
public class AccountServiceImpl implements IAccountService {
    @Autowired
    private IAccountDao accountDao;

    public void setAccountDao(IAccountDao accountDao) {
        this.accountDao = accountDao;
    }

    @Transactional(isolation = Isolation.REPEATABLE_READ,propagation = Propagation.REQUIRED)
    public void transfer(String outMan, String inMan, double money) {
        accountDao.out(outMan,money);
        //int m= 2/0;//java.lang.ArithmeticException: / by zero
        accountDao.in(inMan,money);
    }

    @Override
    public void findAll() {
        accountDao.queryAll();
    }
}
  • 编写applicationContext.xml配置文件
<!--只包含新添加的组件扫描 和 事务的注解驱动 配置-->
<!--组件扫描-->
    <context:component-scan base-package="cn.ppvir"></context:component-scan>
<!--事务注解驱动--><!--驱动是开关，加上之后注解才能启动-->
    <tx:annotation-driven transaction-manager="transactionManager"/>

#####2.3.二、注解配置声明式事务控制解析 ①使用 @Transactional 在须要进行事务控制的类或是方法上修饰，注解可用的属性同 xml 配置方式，例如隔离级别、传播行为等。

②注解使用在类上，那么该类下的全部方法都使用同一套注解参数配置。

③使用在方法上，不一样的方法能够采用不一样的事务参数配置。

④Xml配置文件中要开启事务的注解驱动<tx:annotation-driven />

#####2.3.三、小结要点 注解声明式事务控制的配置要点

  • 平台事务管理器配置（xml方式）
  • 事务通知的配置（@Transactional注解配置）
  • 事务注解驱动的配置<tx:annotation-driven transaction-manager="transactionManager"/>
相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程