栏目分类:
子分类:
返回
名师互学网用户登录
快速导航关闭
当前搜索
当前分类
子分类
实用工具
热门搜索
名师互学网 > IT > 软件开发 > 后端开发 > Java

Spring-JdbcTemplate

Java 更新时间: 发布时间: IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

Spring-JdbcTemplate

Spring-JdbcTemplate 1.看一个实际需求

● 实际需求: 如果程序员就希望使用 spring 框架来做项目,spring 框架如何处理对数据库的 操作呢?

  1. 方案 1.自己开发 JdbcUtils 类
  2. 方案 2. 其实 spring 提供了一个操作数据库(表)功能强大的类 JdbcTemplate 。我们可以同 ioc 容器来配置一个 jdbcTemplate 对象,使用它来完成对数据库表的各种操作.
2.官方文档

JdbcTemplate APIs : /spring-framework-5.3.8/docs/javadoc-api/index.html

3.JdbcTemplate-基本介绍

● 基本介绍

  1. 通过 Spring 可以配置数据源,从而完成对数据表的操作

  2. JdbcTemplate 是 Spring 提供的访问数据库的技术。可以将 JDBC 的常用操作封装为模板方 法。[JdbcTemplate 类图]

4.JdbcTemplate 使用实例 1.需求说明

我们使用 spring 的方式来完成 JdbcTemplate 配置和使用

2.JdbcTemplate 使用
  1. 引入使用 JdbcTemplate 需要的 jar 包

2.创建数据库 spring 和表 monster

-- 创建数据库
CREATE DATABASE spring;
USE spring;
-- 创建表 monster
CREATE TABLE monster ( id INT PRIMARY KEY, `name` VARCHAr ( 64 ) NOT NULL DEFAULT '', skill VARCHAr ( 64 ) NOT NULL DEFAULT '' ) CHARSET = utf8;

-- 插入数据
INSERT INTO monster
VALUES
	( 100, '青牛怪', '吐火' );
INSERT INTO monster
VALUES
	( 200, '黄袍怪', '吐烟' );
INSERT INTO monster
VALUES
	( 300, '蜘蛛怪', '吐丝' );

3.创建配置文件 src/jdbc.properties

jdbc.userName=root
jdbc.password=root
jdbc.driverClass=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3308/spring

4.创建配置文件 src/JdbcTemplate_ioc.xml




    
    
    
    
        
        
        
        
        
    


5.创建测试,看能否得到数据源

public class JdbcTemplateTest {
    @Test
    public void testDataSourceByJdbcTemplate() throws SQLException {
        ApplicationContext ioc = new ClassPathXmlApplicationContext("JdbcTemplate_ioc.xml");
        DataSource dataSource = ioc.getBean(DataSource.class);
        Connection connection = dataSource.getConnection();
        System.out.println(connection);
    }
}

6.配置 JdbcTemplate_ioc.xml,将数据源分配给 JdbcTemplate bean


    
    

7.修改 JdbcTemplateTest.java,添加一个新的 monster

    @Test public void addDataByJdbcTemplate() {
        ApplicationContext ioc = new ClassPathXmlApplicationContext("JdbcTemplate_ioc.xml");
        JdbcTemplate jdbcTemplate = ioc.getBean(JdbcTemplate.class);
        //1. 添加方式1
//        String sql = "INSERT INTO monster VALUES(400, '红孩儿', '枪法')";
//        jdbcTemplate.update(sql);
//        jdbcTemplate.execute(sql);

        //2.添加方式2
        String sql = "INSERT INTO monster VALUES(?,?,?)";
        int update = jdbcTemplate.update(sql, 500, "白骨精", "吸血");
        System.out.println(update);
    }

8.修改 JdbcTemplateTest.java,更新一个 monster 的 skill

@Test
public void updateDataByJdbcTemplate() {
    ApplicationContext ioc = new ClassPathXmlApplicationContext("JdbcTemplate_ioc.xml");
    //得到 JdbcTemplate bean
    JdbcTemplate jdbcTemplate = ioc.getBean(JdbcTemplate.class);
    String sql = "update monster set skill=? where id = ?";
    int affected = jdbcTemplate.update(sql, "美人计", 500);
    System.out.println(affected);
}

9.修改 JdbcTemplateTest.java,批量添加二个 monster 白蛇精和青蛇精

@Test
public void addBatchDataByJdbcTemplate() {
    ApplicationContext ioc = new ClassPathXmlApplicationContext("JdbcTemplate_ioc.xml");
    //得到JdbcTemplate bean
    JdbcTemplate jdbcTemplate = ioc.getBean(JdbcTemplate.class);//添加..

    //1. 先确定,猜测API名称 batchUpdate[如果出现问题,才重新玩]
    //public int[] batchUpdate(String sql, List batchArgs){}
    //2. 准备参数
    String sql = "INSERT INTO monster VALUES(?, ?, ?)";
    List batchArgs = new ArrayList<>();
    batchArgs.add(new Object[]{600, "老鼠精", "偷吃粮食"});
    batchArgs.add(new Object[]{700, "老猫精", "抓老鼠"});
    //3. 调用
    //说明:返回结果是一个数组,每个元素对应上面的sql语句对表的影响记录数
    int[] ints = jdbcTemplate.batchUpdate(sql, batchArgs);
    //输出
    for (int anInt : ints) {
        System.out.println("anInt=" + anInt);
    }
    System.out.println("batch add ok..");
}

10.查询 id=100 的 monster 并封装到 Monster 实体对象

@Test
public void selectDataByJdbcTemplate() {
    ApplicationContext ioc = new ClassPathXmlApplicationContext("JdbcTemplate_ioc.xml");
    //得到JdbcTemplate bean
    JdbcTemplate jdbcTemplate = ioc.getBean(JdbcTemplate.class);
    //组织SQL
    //通过BeanPropertyRowMapper获取rowmapper 是一个接口,可以将查询的结果,封装到你指定的Monster对象中.

    //1. 确定API : queryForObject()
    //public  T queryForObject(String sql, RowMapper rowMapper, @Nullable Object... args)
    //2.准备参数
    String sql = "SELECT id AS monsterId, NAME, skill FROM monster WHERe id = 100";
    //使用RowMapper 接口来对返回的数据,进行一个封装-》底层使用的反射->setter
    //这里有一个细节: 你查询的记录的表的字段需要和 Monster的对象字段名保持一致
    RowMapper rowMapper = new BeanPropertyRowMapper<>(Monster.class);
    //jdbcTemplate
    Monster monster = jdbcTemplate.queryForObject(sql, rowMapper);
    System.out.println("monster= " + monster);
    System.out.println("查询ok");
}

11.查询 id>=200 的 monster 并封装到 Monster 实体对象

@Test
public void selectMulDataByJdbcTemplate() {
    ApplicationContext ioc =
            new ClassPathXmlApplicationContext("JdbcTemplate_ioc.xml");
    //得到JdbcTemplate bean
    JdbcTemplate jdbcTemplate = ioc.getBean(JdbcTemplate.class);
    //组织SQL
    //通过BeanPropertyRowMapper获取rowmapper 是一个接口,可以将查询的结果,封装到你指定的Monster对象中.

    //1.    确定API
    //public  T query(String sql, RowMapper rowMapper, Object... args){}
    //2. 组织参数
    String sql = "SELECT id AS monsterId, NAME, skill FROM monster WHERe id >= ?";
    RowMapper rowMapper = new BeanPropertyRowMapper<>(Monster.class);
    //3. 调用
    List monsterList = jdbcTemplate.query(sql, rowMapper, 200);
    for (Monster monster : monsterList) {
        System.out.println("monster= " + monster);
    }
}

12.查询返回结果只有一行一列的值,比如查询 id=100 的怪物名

@Test
public void selectScalarByJdbcTemplate() {
    ApplicationContext ioc =
            new ClassPathXmlApplicationContext("JdbcTemplate_ioc.xml");
    //得到JdbcTemplate bean
    JdbcTemplate jdbcTemplate = ioc.getBean(JdbcTemplate.class);

    //1. 确定API
    //public  T queryForObject(String sql, Class requiredType)
    //2. 提供参数
    String sql = "SELECT NAME FROM monster WHERe id = 100";
    //Class requiredType 表示你返回的单行单列的数据类型

    String name =
            jdbcTemplate.queryForObject(sql, String.class);
    System.out.println("返回name= " + name);

}

13.使用 Map 传入具名参数完成操作,比如添加 螃蟹精.:name 就是具名参数形式需要使 用 NamedParameterJdbcTemplate 类

修改配置文件




    
    

    
    
    
    
        
        
        
        
        
    

    
    
        
        
    

    
    
        
        
    

@Test
public void testDataByNamedParameterJdbcTemplate() {
    ApplicationContext ioc =
            new ClassPathXmlApplicationContext("JdbcTemplate_ioc.xml");
    //得到NamedParameterJdbcTemplate bean
    NamedParameterJdbcTemplate namedParameterJdbcTemplate =
            ioc.getBean(NamedParameterJdbcTemplate.class);

    //1. 确定使用API
    //public int update(String sql, Map paramMap)
    //2. 准备参数 [:my_id, :name, :skill] 要求按照规定的名字来设置参数
    String sql = "INSERT INTO monster VALUES(:id, :name, :skill)";
    Map paramMap = new HashMap<>();
    //给paramMap填写数据
    paramMap.put("id", 800);
    paramMap.put("name", "蚂蚁精");
    paramMap.put("skill", "喜欢打洞");
    //3. 调用
    int affected = namedParameterJdbcTemplate.update(sql, paramMap);
    System.out.println("add ok affected=" + affected);


}

14.使用 sqlparametersoruce 来封装具名参数,还是添加一个 Monster 狐狸精

@Test
public void operDataBySqlparametersoruce() {
    ApplicationContext ioc =
            new ClassPathXmlApplicationContext("JdbcTemplate_ioc.xml");
    //得到NamedParameterJdbcTemplate bean
    NamedParameterJdbcTemplate namedParameterJdbcTemplate =
            ioc.getBean(NamedParameterJdbcTemplate.class);

    //确定API
    //public int update(String sql, SqlParameterSource paramSource)
    //public BeanPropertySqlParameterSource(Object object)
    //准备参数
    String sql = "INSERT INTO monster VALUES(:monsterId, :name, :skill)";
    Monster monster = new Monster(900, "大象精", "搬运木头");
    SqlParameterSource sqlParameterSource =
            new BeanPropertySqlParameterSource(monster);
    //调用
    int affected =
            namedParameterJdbcTemplate.update(sql, sqlParameterSource);

    System.out.println("add ok affected= " + affected);
}

15.Dao 对象中使用 JdbcTemplate 完成对数据的操作

@Repository //将MonsterDao 注入到spring容器
public class MonsterDao {
    //注入一个属性
    @Resource
    private JdbcTemplate jdbcTemplate;

    //完成保存任务
    public void save(Monster monster) {
        //组织sql
        String sql = "INSERT INTO monster VALUES(?,?,?)";
        int affected = jdbcTemplate.update
                (sql, monster.getMonsterId(), monster.getName(), monster.getSkill());
        System.out.println("affected= " + affected);
    }
}
@Test
public void monsterDaoSave() {
    ApplicationContext ioc =
            new ClassPathXmlApplicationContext("JdbcTemplate_ioc.xml");

    MonsterDao monsterDao = ioc.getBean(MonsterDao.class);
    Monster monster = new Monster(1000, "小鸭精", "吃鱼");
    monsterDao.save(monster);
    System.out.println("MonsterDAO保存 ok ..");
}
5.声明式事务 1.事务分类

● 分类:

  1. 编程式事务: 示意代码, 传统方式
Connection connection = JdbcUtils.getConnection();
try {
    //1. 先设置事务不要自动提交
    connection.setAutoCommint(false);
    //2. 进行各种 crud 
    //多个表的修改,添加 ,删除 
    //3. 提交
    connection.commit(); 
	} catch (Exception e) {
    //4. 回滚
    conection.rollback();
}
  1. 声明式事务
2.声明式事务-使用实例 1.需求说明-用户购买商品
  1. 通过商品 id 获取价格.
  2. 购买商品(某人购买商品,修改用户的余额.)
  3. 修改库存量
  4. 其实大家可以看到,这时,我们需要涉及到三张表商品表,用户表,商品存量表。 应该使用事务处理
2.解决方案分析
  1. 使用传统的编程事务来处理,将代码写到一起[缺点: 代码冗余,效率低,不利于扩展, 优 点是简单,好理解]
Connection connection = JdbcUtils.getConnection();
try {
    //1. 先设置事务不要自动提交 connection.setAutoCommit(false);
    //2. 进行各种 crud 
    //多个表的修改,添加 ,删除 select from 商品表 => 获取价格 修改用户余额 update ... 修改库存量 update 
    //3. 提交 
    connection.commit(); 
} catch (Exception e) { 
    //4. 回滚 
    conection.rollback();
}
  1. 使用 Spring 的声明式事务处理, 可以将上面三个子步骤分别写成一个方法,然后统一 管理

[这个是 Spring 很牛的地方,在开发中使用的很多,优点是无代码冗余,效率高,扩展方便, 缺点是理解较困难]==> 底层使用 AOP (动态代理+动态绑定+反射+注解)

3.声明式事务使用-代码实现
  1. 先创建商品系统的数据库和表
-- 演示声明式事务创建的表 
-- 用户账户表
CREATE TABLE `user_account`( 
user_id INT UNSIGNED PRIMARY KEY AUTO_INCREMENT, 
user_name VARCHAr(32) NOT NULL DEFAULT '', 
money DOUBLE NOT NULL DEFAULT 0.0 
)CHARSET=utf8; 
INSERT INTO `user_account` VALUES(NULL,'张三', 1000); 
INSERT INTO `user_account` VALUES(NULL,'李四', 2000); 

-- 商品表
CREATE TABLE `goods`(
goods_id INT UNSIGNED PRIMARY KEY AUTO_INCREMENT,
goods_name VARCHAr(32) NOT NULL DEFAULT '',
price DOUBLE NOT NULL DEFAULT 0.0
)CHARSET=utf8 ;
INSERT INTO `goods` VALUES(NULL,'小风扇', 10.00); 
INSERT INTO `goods` VALUES(NULL,'小台灯', 12.00); 
INSERT INTO `goods` VALUES(NULL,'可口可乐', 3.00);

-- 商品库存表
CREATE TABLE `goods_amount`(
goods_id INT UNSIGNED PRIMARY KEY AUTO_INCREMENT, 
goods_num INT UNSIGNED DEFAULT 0 
)CHARSET=utf8 ;
INSERT INTO `goods_amount` VALUES(1,200);
INSERT INTO `goods_amount` VALUES(2,20); 
INSERT INTO `goods_amount` VALUES(3,15);

GoodsDao

@Repository //将 GoodsDao-对象 注入到spring容器
public class GoodsDao {

    @Resource
    private JdbcTemplate jdbcTemplate;

    
    public Float queryPriceById(Integer id) {
        String sql = "SELECT price From goods Where goods_id=?";
        Float price = jdbcTemplate.queryForObject(sql, Float.class, id);
        return price;
    }

    
    public void updateBalance(Integer user_id, Float money) {
        String sql = "UPDATE user_account SET money=money-? Where user_id=?";
        jdbcTemplate.update(sql, money, user_id);
    }

    
    public void updateAmount(Integer goods_id, int amount){
        String sql = "UPDATE goods_amount SET goods_num=goods_num-? Where goods_id=?";
        jdbcTemplate.update(sql, amount , goods_id);
    }
}

GoodsService

@Service //将 GoodsService对象注入到spring容器
public class GoodsService {

    //定义属性GoodsDao
    @Resource
    private GoodsDao goodsDao;

    //编写一个方法,完成用户购买商品的业务, 这里主要是讲解事务管理

    
    public void buyGoods(int userId, int goodsId, int amount) {

        //输出购买的相关信息
        System.out.println("用户购买信息 userId=" + userId
                + " goodsId=" + goodsId + " 购买数量=" + amount);

        //1.得到商品的价格
        Float price = goodsDao.queryPriceById(goodsId);
        //2. 减少用户的余额
        goodsDao.updateBalance(userId, price * amount);
        //3. 减少库存量
        goodsDao.updateAmount(goodsId, amount);

        System.out.println("用户购买成功~");

    }

    
    @Transactional
    public void buyGoodsByTx(int userId, int goodsId, int amount) {
        //输出购买的相关信息
        System.out.println("用户购买信息 userId=" + userId
                + " goodsId=" + goodsId + " 购买数量=" + amount);
        //1.得到商品的价格
        Float price = goodsDao.queryPriceById(userId);
        //2. 减少用户的余额
        goodsDao.updateBalance(userId, price * amount);
        //3. 减少库存量
        goodsDao.updateAmount(goodsId, amount);
        System.out.println("用户购买成功~");

    }
}

tx_ioc.xml




    
    
    

    
    
    
    
        
        
        
        
        
    

    
    
        
        
    

    
    
        
    

    
    

测试

public class TxTest {

    @Test
    public void queryPriceByIdTest() {
        //获取到容器
        ApplicationContext ioc =
                new ClassPathXmlApplicationContext("tx_ioc.xml");
        GoodsDao goodsDao = ioc.getBean(GoodsDao.class);

        Float price = goodsDao.queryPriceById(1);
        System.out.println("id=100 的price=" + price);
    }

    @Test
    public void updateBalance() {

        //获取到容器
        ApplicationContext ioc =
                new ClassPathXmlApplicationContext("tx_ioc.xml");
        GoodsDao goodsDao = ioc.getBean(GoodsDao.class);
        goodsDao.updateBalance(1, 1.0F);
        System.out.println("减少用户余额成功~");

    }

    @Test
    public void updateAmount() {
        //获取到容器
        ApplicationContext ioc =
                new ClassPathXmlApplicationContext("tx_ioc.xml");
        GoodsDao goodsDao = ioc.getBean(GoodsDao.class);
        goodsDao.updateAmount(1, 1);
        System.out.println("减少库存成功...");
    }

    //测试用户购买商品业务
    @Test
    public void buyGoodsTest() {
        //获取到容器
        ApplicationContext ioc =
                new ClassPathXmlApplicationContext("tx_ioc.xml");
        GoodsService goodsService = ioc.getBean(GoodsService.class);
        goodsService.buyGoods(1, 1, 1);
    }

    //测试用户购买商品业务
    @Test
    public void buyGoodsByTxTest() {
        //获取到容器
        ApplicationContext ioc =
                new ClassPathXmlApplicationContext("tx_ioc.xml");
        GoodsService goodsService = ioc.getBean(GoodsService.class);
        goodsService.buyGoodsByTx(1, 1, 1);//这里我们调用的是进行了事务声明的方法
    }
}

4.声明式事务机制-Debug 3.事务的传播机制 1.事务的传播机制说明
  1. 当有多个事务处理并存时,如何控制?

  2. 比如用户去购买两次商品(使用不同的方法), 每个方法都是一个事务,那么如何控制呢?

  3. 这个就是事务的传播机制,看一个具体的案例(如图)

2.事务传播机制种类

● 事务传播的属性/种类一览图

● 事务传播的属性/种类机制分析,重点分析了 REQUIRED 和 REQUIRED_NEW 两种事务 传播属性, 其它知道即可(看上图)

● 事务的传播机制的设置方法

● REQUIRES_NEW 和 REQUIRED 在处理事务的策略

  1. 如果设置为 REQUIRES_NEW buyGoods2 如果错误,不会影响到 buyGoods()反之亦然,即它们的事务是独立的.
  2. 如果设置为 REQUIRED buyGoods2 和 buyGoods 是一个整体,只要有方法的事务错误,那么两个方法都不会执行成功.!
3.事务的传播机制-应用实例

GoodsDao新增第二套方法

    
    public Float queryPriceById2(Integer id) {
        String sql = "SELECT price From goods Where goods_id=?";
        Float price = jdbcTemplate.queryForObject(sql, Float.class, id);
        return price;
    }

    
    public void updateBalance2(Integer user_id, Float money) {
        String sql = "UPDATE user_account SET money=money-? Where user_id=?";
        jdbcTemplate.update(sql, money, user_id);
    }

    
    public void updateAmount2(Integer goods_id, int amount){
        String sql = "UPDATE goods_amount SET goods_num=goods_num-? Where goods_id=?";
        jdbcTemplate.update(sql, amount , goods_id);
    }

GoodsService

   @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void buyGoodsByTx(int userId, int goodsId, int amount) {


        //输出购买的相关信息
        System.out.println("用户购买信息 userId=" + userId
                + " goodsId=" + goodsId + " 购买数量=" + amount);

        //1.得到商品的价格
        Float price = goodsDao.queryPriceById(userId);
        //2. 减少用户的余额
        goodsDao.updateBalance(userId, price * amount);
        //3. 减少库存量
        goodsDao.updateAmount(goodsId, amount);

        System.out.println("用户购买成功~");

    }


    
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void buyGoodsByTx2(int userId, int goodsId, int amount) {


        //输出购买的相关信息
        System.out.println("用户购买信息 userId=" + userId
                + " goodsId=" + goodsId + " 购买数量=" + amount);

        //1.得到商品的价格
        Float price = goodsDao.queryPriceById2(userId);
        //2. 减少用户的余额
        goodsDao.updateBalance2(userId, price * amount);
        //3. 减少库存量
        goodsDao.updateAmount2(goodsId, amount);

        System.out.println("用户购买成功~");

    }

MultiplyService

@Service
public class MultiplyService {
    @Resource
    private GoodsService goodsService;


    
    @Transactional
    public void multiBuyGoodsByTx() {

        goodsService.buyGoodsByTx(1, 1, 1);
        goodsService.buyGoodsByTx2(1, 1, 1);
    }
}
4.事务的隔离级别 1.事务隔离级别说明

● 事务隔离级别说明

  1. 默认的隔离级别, 就是 mysql 数据库默认的隔离级别 一般为 REPEATABLE_READ
  2. 看源码可知 Isolation.DEFAULT 是 :Use the default isolation level of the underlying datastore
  3. 查看数据库默认的隔离级别 SELECT @@global.tx_isolation
2.事务隔离级别的设置和测试 3.事务的超时回滚 5.声明式事务-练习
转载请注明:文章转载自 www.mshxw.com
本文地址:https://www.mshxw.com/it/943702.html
我们一直用心在做
关于我们 文章归档 网站地图 联系我们

版权所有 (c)2021-2022 MSHXW.COM

ICP备案号:晋ICP备2021003244-6号