Spring JdbcTemplate&声明式事务

1、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坐标(依赖)

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

②创建数据库表和实体

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对象 设置连接池
④执行数据库操作

@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);
        //3、执行数据库操作
        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容器中

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>

测试代码：

/**
     * 测试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

修改配置文件：

<!--加载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基本使用-知识要点(理解，记忆)

• 导入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)//单个对象

2、声明式事务控制

---

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

2.1、编程式事务控制相关的对象

概念：通过java代码手动开启事务，提交事务，回滚事务。

2.1.1、PlatformTransactionManager （平台事务管理器）

PlatformTransactionManager 接口是 spring 的事务管理器，它里面提供了我们常用的操作事务的方法

---

注意：
PlatformTransactionManager 是接口类型，不同的 Dao 层技术则有不同的实现类，通过配置告诉spring，集成的哪个框架，spring根据不同的框架选择不同的操作。
|Dao层的技术|实现类|
|----------------|--------------------|
|jdbc 或 mybatis |org.springframework.jdbc.datasource.DataSourceTransactionManager|
|hibernate（架构）|org.springframework.orm.hibernate5.HibernateTransactionManager|

2.1.2、 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.3、 TransactionStatus（获取事务的状态信息）

    TransactionStatus 接口提供的是事务具体的运行状态，方法介绍如下。

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

平台事务管理器（指定事务控制行为）+事务定义对象（封装事务的参数）=事务状态对象（被动的封装程序的动态信息）
|方法|说明|
|-------|-------|
|boolean hasSavepoint()|是否存储滚回点|
|boolean isCompleted()|事务是否完成|
|boolean isNewTransaction()|是否是新事务|
|boolean isRollbackOnly()|事务是否滚回|

2.2、 基于xml的声明式事务控制（方便统一配置）

2.2.1 什么是声明式事务控制

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

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

声明式事务处理的作用

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

注意：Spring 声明式事务控制底层就是AOP。

2.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.3、小结要点

声明式事务控制的配置要点

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

2.3、基于注解的声明式事务控制

2.3.1、 使用注解配置声明式事务控制

使用注解在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.2、注解配置声明式事务控制解析

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

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

③使用在方法上，不同的方法可以采用不同的事务参数配置。

④Xml配置文件中要开启事务的注解驱动

2.3.3、小结要点

注解声明式事务控制的配置要点

• 平台事务管理器配置（xml方式）
• 事务通知的配置（@Transactional注解配置）

• 事务注解驱动的配置<tx:annotation-driven transaction-manager="transactionManager"/>

来源：https://www.cnblogs.com/ppvir/p/11390564.html