Day67-Spring-JDBCTemplate基本使用

最新推荐文章于 2022-10-05 17:04:59 发布

柳子陌

最新推荐文章于 2022-10-05 17:04:59 发布

阅读量78

点赞数 1

分类专栏： Spring Java 文章标签： spring JdbcTemplate spring事务控制 xml事务注解事务

本文链接：https://blog.csdn.net/qq_38205875/article/details/115768218

版权

Java 同时被 2 个专栏收录

64 篇文章 0 订阅

订阅专栏

Spring

4 篇文章 0 订阅

订阅专栏

title: Day67-Spring-JDBCTemplate基本使用
date: 2021-04-15 10:36:47
author: Liu_zimo

Spring JDBCTemplate基本使用

概述

它是spring框架中提供的一个对象，是对原始繁琐的JdbcAPI对象的简单封装。spring框架为我们提供了很多的操作模板类
- 操作关系型数据的JdbcTemplate和HibernateTemplate
- 操作nosql数据库的RedisTemplate
- 操作消息队列的JmsTemplate等

JdbcTemplate开发步骤

导入spring-jdbc和spring-tx坐标（spring-tx：事务操作）
创建数据库表和实体
创建JdbcTemplate对象
执行数据库操作

pom坐标

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

创建数据库表

CREATE TABLE `account` (
   `ID` int(11) NOT NULL COMMENT '编号',
   `UID` int(11) DEFAULT NULL COMMENT '用户编号',
   `MONEY` double DEFAULT NULL COMMENT '金额',
   PRIMARY KEY (`ID`),
   KEY `FK_Reference_8` (`UID`),
   CONSTRAINT `FK_Reference_8` FOREIGN KEY (`UID`) REFERENCES `user` (`id`)
 ) ENGINE=InnoDB DEFAULT CHARSET=utf8

实体类

package com.zimo.domain;
/**
 * @author Liu_zimo
 * @version v0.1 by 2021/4/15 13:52
 */
public class Account {
    private int id;
    private int uid;
    private int money;
    public int getId() { return id; }
    public void setId(int id) { this.id = id; }
    public int getUid() { return uid; }
    public void setUid(int uid) { this.uid = uid; }
    public int getMoney() { return money; }
    public void setMoney(int money) { this.money = money; }
    @Override
    public String toString() { return "Account{" + "id=" + id + ", uid=" + uid + ", money=" + money + '}'; }
}

执行数据库操作

package com.zimo.test;
import com.mchange.v2.c3p0.ComboPooledDataSource;
import org.junit.Test;
import org.springframework.jdbc.core.JdbcTemplate;
import java.beans.PropertyVetoException;
/**
 * @author Liu_zimo
 * @version v0.1 by 2021/4/15 13:57
 */
public class JDBCTemplateTest {
    @Test
    public void test1() throws PropertyVetoException {
        // 创建数据源对象
        ComboPooledDataSource dataSource = new ComboPooledDataSource();
        dataSource.setDriverClass("com.mysql.jdbc.Driver");
        dataSource.setJdbcUrl("jdbc:mysql://localhost:3306/test");
        dataSource.setUser("root");
        dataSource.setPassword("123456");
        JdbcTemplate template = new JdbcTemplate();
        // 设置数据源对象
        template.setDataSource(dataSource);
        // 执行操作
        template.update("insert into account values (?,?,?)", 11,"48",5001);
    }
}

Spring产生JDBCTemplate对象

我们可以将JdbcTemplate的创建权交给Spring，将数据源DataSource的创建权也交给Spring，在Spring容器内部将数据源DataSource注入到JdbcTemplate模版对象中，配置如下：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       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">
    <!--数据源对象-->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="com.mysql.jdbc.Driver"/>
        <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/test"/>
        <property name="user" value="root"/>
        <property name="password" value="123456"/>
    </bean>
    <!--jdbc模板对象-->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource"/>
    </bean>
</beans>

JDBCTemplate常用操作

package com.zimo.test;

import com.zimo.domain.Account;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import java.util.List;

/**
 * jdbcTemplate CRUD操作
 *
 * @author Liu_zimo
 * @version v0.1 by 2021/4/15 15:32
 */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class JDBCTemplateCRUD {
    @Autowired
    private JdbcTemplate jdbcTemplate;

    @Test   // 增
    public void insertTest(){
        jdbcTemplate.update("insert into account values (?,?,?)", 6,"48",5001);
    }
    @Test   // 改
    public void updateTest(){
        jdbcTemplate.update("update account set money = ? where id = ?", 10010,5);
    }
    @Test   // 删
    public void deleteTest(){
        jdbcTemplate.update("delete from account where id = ?", 6);
    }
    @Test   // 查：全部查询
    public void selectAllTest(){
        List<Account> list = jdbcTemplate.query("select * from account", new BeanPropertyRowMapper<Account>(Account.class));
        System.out.println(list.toString());
    }
    @Test   // 查：单个对象
    public void selectOneTest(){
        Account account = jdbcTemplate.queryForObject("select * from account where id = ?", new BeanPropertyRowMapper<Account>(Account.class),5);
        System.out.println(account.toString());
    }
    @Test   // 查：查询总数
    public void selectCountTest(){
        Integer count = jdbcTemplate.queryForObject("select count(*) from account", Integer.class);
        System.out.println(count);
    }
}

Spring事务控制

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

编程式：通过Java API自实现
声明式：通过配置实现

编程式事务控制相关对象

PlatformTransactionManager

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

方法	说明
`TransactionStatus getTransaction(TransactionDefination defination)`	获取事务的状态信息
`void commit(TransactionStatus status)`	提交事务
`void rollaback(TansactionStatus status)`	回滚事务

注意：PlatformTransactionManager是接口类型，不同的 Dao层技术则有不同的实现类
例如：
- Dao层技术是jdbc或mybatis时：org.springframework.jdbc.datasource.DataSourceTransactionManager
- Dao层技术是hibernate时：org.springframework.orm.hibernate5.HibernateTransactionManager

TransactionDefination

TransactionDefinition是事务的定义信息对象，里面有如下方法

方法	说明
`int getIsolationLevel()`	获得事务的隔离级别
`int getPropagationBehavior()`	获得事务的传播行为
`int getTimeout()`	获得超时时间
`boolean isReadonly()`	是否只读

事务隔离级别

设置隔离级别，可以解决事务并发产生的问题，如脏读、不可重复读和虚读
- ISOLATION_DEFAULT
- ISOLATION_READ_UNCOMMITTED（都不能解决）
- ISOLATION_READ_COMMITTED（能解决脏读）
- ISOLATION_REPEATABLE_READ（能解决不可重复读）
- ISOLATION_SERIALIZABLE（全能解决：性能低，相当于锁表）
事务传播行为
- REQUIRED：如果当前没有事务，就新建一个事务，如果已经存在一个事务中，加入到这个事务中。一般的选择（默认值)
- SUPPORTS：支持当前事务，如果当前没有事务，就以非事务方式执行(没有事务)
- MANDATORY：使用当前的事务，如果当前没有事务，就抛出异常
- REQUERS_NEW：新建事务，如果当前在事务中，把当前事务挂起
- NOT_SUPPORTED：以非事务方式执行操作，如果当前存在事务，就把当前事务挂起
- NEVER：以非事务方式运行，如果当前存在事务，抛出异常
- NESTED：如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则执行REQUIRED类似的操作
- 超时时间：默认值是-1，没有超时限制。如果有，以秒为单位进行设置
- 是否只读：建议查询时设置为只读

TansactionStatus

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

方法	说明
`boolean hassavepoint()`	是否存储回滚点
`boolean iscompleted()`	事务是否完成
`boolean isNewTransaction()`	是否是新事务
`boolean isRollbackonly()`	事务是否回滚

知识要点

编程式事务控制三大对象
- PlatformTransactionManager
- TransactionDefination
- TansactionStatus

基于XML的声明式事务控制

作用

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

实现

package com.zimo.domain;
public class Account {
    private int id;
    private int uid;
    private int money;
    public int getId() { return id; }
    public void setId(int id) { this.id = id; }
    public int getUid() { return uid; }
    public void setUid(int uid) { this.uid = uid; }
    public int getMoney() { return money; }
    public void setMoney(int money) { this.money = money; }
}

public interface AccountDao {
    public void out(String outMan, double money);
    public void in(String inMan, double money);
}

public class AccountDaoImpl implements AccountDao {
    private JdbcTemplate jdbcTemplate;
    public AccountDaoImpl(JdbcTemplate jdbcTemplate) { this.jdbcTemplate = jdbcTemplate; }
    public void out(String outMan, double money) { jdbcTemplate.update("update account set money=money-? where id = ?",money, outMan); }
    public void in(String inMan, double money) { jdbcTemplate.update("update account set money=money+? where id = ?",money, inMan); }
}

public interface AccountService {
    public void transfer(String outMan,String inMan,double money);
}

public class AccountServiceImpl implements AccountService {
    private AccountDao accountDao;
    public void setAccountDao(AccountDao accountDao) { this.accountDao = accountDao; }
    public void transfer(String outMan, String inMan, double money) {
        accountDao.out(outMan, money);
        // int i = 1 / 0;	// 存在事务问题
        accountDao.in(inMan, money);
    }
}

public static void main(String[] args) {
    ClassPathXmlApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");
    AccountService bean = app.getBean(AccountService.class);
    bean.transfer("1", "2", 50);
}

声明式事务控制
- 谁是切点：accountService.transfer()
- 谁是通知：事务增强通知
- 谁是切面：

<?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:tx="http://www.springframework.org/schema/tx"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.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">
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="com.mysql.jdbc.Driver"/>
        <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/test"/>
        <property name="user" value="root"/>
        <property name="password" value="123456"/>
    </bean>
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource"/>
    </bean>
    <bean id="accountDao" class="com.zimo.dao.impl.AccountDaoImpl">
        <constructor-arg ref="jdbcTemplate"/>
    </bean>

    <!--目标方法 内部方法就是切点-->
    <bean id="accountService" class="com.zimo.service.impl.AccountServiceImpl">
        <property name="accountDao" ref="accountDao"></property>
    </bean>

    <!--配置平台事务管理器-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"/>
    </bean>

    <!--通知 事务的增强-->
    <tx:advice id="txAdvice" transaction-manager="transactionManager">
        <!--设置事务的属性-->
        <tx:attributes>
            <tx:method name="*"/>
            <tx:method name="transfer" isolation="REPEATABLE_READ" propagation="REQUIRED" read-only="false"/>
        </tx:attributes>
    </tx:advice>

    <!--配置事务的aop织入-->
    <aop:config>
        <!--事务增强-->
        <aop:advisor advice-ref="txAdvice" pointcut="execution(* com.zimo.service.impl.*.*(..))"/>
    </aop:config>
</beans>

<tx:method>代表切点方法的事务参数的配置：
- name：切点方法名称
- isolation：事务的隔离级别
- propogation：事务的传播行为
- timeout：超时时间
- read-only：是否只读

知识要点

平台事务管理器配置
事务通知的配置
事务aop织入的配置

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

@Repository("accountDao")
public class AccountDaoImpl implements AccountDao {
    @Autowired
    private JdbcTemplate jdbcTemplate;

    public void out(String outMan, double money) { jdbcTemplate.update("update account set money=money-? where id = ?",money, outMan); }
    public void in(String inMan, double money) { jdbcTemplate.update("update account set money=money+? where id = ?",money, inMan); }
}

@Service("accountService")
// 若在此声明，下面的类都使用此事务控制，若方法上有指定，则就近使用方法上声明的事务
@Transactional(isolation = Isolation.READ_COMMITTED,propagation = Propagation.REQUIRED)
public class AccountServiceImpl implements AccountService {
    @Autowired
    private AccountDao accountDao;

    // 以此事务为主
    @Transactional(isolation = Isolation.READ_COMMITTED,propagation = Propagation.REQUIRED)
    public void transfer(String outMan, String inMan, double money) {
        accountDao.out(outMan, money);
        int i = 1 / 0;
        accountDao.in(inMan, money);
    }
}

<?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:tx="http://www.springframework.org/schema/tx"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
         http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd
         http://www.springframework.org/schema/context  http://www.springframework.org/schema/context/spring-context.xsd
         http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">

    <!-- 组件扫描 -->
    <context:component-scan base-package="com.zimo"/>
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="com.mysql.jdbc.Driver"/>
        <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/test"/>
        <property name="user" value="root"/>
        <property name="password" value="123456"/>
    </bean>
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource"/>
    </bean>

    <!--配置平台事务管理器-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"/>
    </bean>
    <!--事务的注解驱动-->
    <tx:annotation-driven transaction-manager="transactionManager"/>
</beans>

注解配置声明式事务控制解析

使用@Transactional在需要进行事务控制的类或是方法上修饰，注解可用的属性同xml配置方式，例如隔离级别、传播行为等
注解使用在类上，那么该类下的所有方法都使用同一套注解参数配置
使用在方法上，不同的方法可以采用不同的事务参数配置
Xml配置文件中要开启事务的注解驱动<tx:annotation-driven />

知识要点

平台事务管理器配置(xml方式)
事务通知的配置(@Transactional注解配置)
事务注解驱动的配置<tx:annotation-driven />

柳子陌

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
Day67-Spring-JDBCTemplate基本使用

title: Day67-Spring-JDBCTemplate基本使用date: 2021-04-15 10:36:47author: Liu_zimoSpring JDBCTemplate基本使用概述它是spring框架中提供的一个对象，是对原始繁琐的JdbcAPI对象的简单封装。spring框架为我们提供了很多的操作模板类操作关系型数据的JdbcTemplate和HibernateTemplate操作nosql数据库的RedisTemplate操作消息队列的JmsTemplat.
复制链接

扫一扫