Spring+SpringMVC+MyBatis-教程、笔记-5

夏天的冬雪

已于 2023-07-24 22:05:24 修改

阅读量43

点赞数

分类专栏： Spring+SpringMVC+MyBatis-教程-笔记文章标签： spring mybatis 笔记

于 2023-07-24 21:49:09 首次发布

本文链接：https://blog.csdn.net/qq_48269763/article/details/131905729

版权

Spring+SpringMVC+MyBatis-教程-笔记专栏收录该内容

11 篇文章 0 订阅

订阅专栏

base黑马，视频链接：https://www.bilibili.com/video/BV1WZ4y1P7Bp?t=94.4
此系列文章可以当做视频的配套笔记，也可以当做自学SSM框架的教程。

JdbcTemplate基本使用-概述

JdbcTemplate其实就是Spring提供的Jdbc操作的工具。

Spring的优点，Spring可以简化开发。
Spring封装后的工具只不过不叫 xxxUtils 叫 xxxTemplate

JdbcTemplate基本使用-开发步骤

spring-jdbc这个包内部封装着jdbc模板对象。
spring-tx是事务，因为jdbc模板操作底层默认用到事务了。

JdbcTemplate基本使用-快速入门代码实现

pom文件中的内容是接着之前的项目写的，是复制的之前的项目，在之前的项目上进行添加。
在pom.xm中导入相应的坐标：

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

创建相应的数据库和数据表

在com.lyh.domain包下面创建实体类Account

package com.lyh.domain;

public class Account {
    private String name;
    private double money;

    public String getName() {
        return name;
    }

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

    public double getMoney() {
        return money;
    }

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

    //创建 toString 方法


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

在com.lyh.test包下面创建JdbcTemplateTest类进行测试

package com.lyh.test;

import com.mchange.v2.c3p0.ComboPooledDataSource;
import org.junit.Test;
import org.springframework.jdbc.core.JdbcTemplate;
import java.beans.PropertyVetoException;

public class JdbcTemplateTest {

    @Test
    //测试JdbcTemplate开发步骤
    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("1234");
        //创建模板对象
        //底层在操作的时候是从数据源中拿到connection对象 帮你 进行相应的操作
        JdbcTemplate jdbcTemplate = new JdbcTemplate();
        //更新操作是：增、删、改
        //就用update方法
        //查询操作就用query方法

        //想执行 更新操作或者查询操作 得知道数据库在哪里
        //模板要想使用 也得知道 数据库 在哪里
        //设置数据源对象 是为了 知道数据库在哪里
        //换句话说得有connection对象，源于数据源
        //从数据源中 拿 connection进行操作
        jdbcTemplate.setDataSource(dataSource);

        //执行操作
        int row = jdbcTemplate.update("insert into account value(?,?)", "tom", 5000);
        System.out.println(row);


    }

}

测试效果：

JdbcTemplate基本使用-Spring产生模板对象分析

JdbcTemplate jdbcTemplate = new JdbcTemplate();
这个模板对象，不自己手动去new，而是交给Spring框架帮你产生。

jdbcTemplate.setDataSource(dataSource);
这里是 依赖注入
注入的方式，有两种，一种是set方法注入，一种是有参构造注入。
注入与 被注入 对象都必须存在IOC容器当中。

ComboPooledDataSource dataSource = new ComboPooledDataSource();
dataSource.setDriverClass("com.mysql.jdbc.Driver");
dataSource.setJdbcUrl("jdbc:mysql://localhost:3306/test");
dataSource.setUser("root");
dataSource.setPassword("1234");

JdbcTemplate基本使用-Spring产生模板对象代码实现

在resources下面创建Spring配置文件 applicationContext.xml

<?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="1234"/>
  </bean>
  <!--    Jdbc模板对象-->
  <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
    <property name="dataSource" ref="dataSource"/>
  </bean>
</beans>

在JdbcTemplateTest类中进行测试

	@Test
    //测试Spring产生jdbcTemplate对象
    public void test2() throws PropertyVetoException {
        ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");
        JdbcTemplate jdbcTemplate = app.getBean("jdbcTemplate",JdbcTemplate.class);
        int row = jdbcTemplate.update("insert into account value(?,?)", "Lisi", 6000);
        System.out.println(row);
	}

效果：

JdbcTemplate基本使用-Spring产生模板对象代码实现（抽取jdbc.properties）

在 resources 文件下面创建，jdbc.properties文件

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

applicationContext.xml 文件这里面的这段代码后期配置的时候一写就是一套。

<?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:context="http://www.springframework.org/schema/context"
  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">

  <!--    加载外部的jdbc.properties文件 需要context的命名空间，还是老方法-->
  <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>

  <!--    Jdbc模板对象-->
  <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
    <property name="dataSource" ref="dataSource"/>
  </bean>
</beans>

进行代码相应测试：

	@Test
    //测试JdbcTemplate开发步骤
    public void test2() throws PropertyVetoException {
        ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");
        JdbcTemplate jdbcTemplate = app.getBean("jdbcTemplate",JdbcTemplate.class);
        int row = jdbcTemplate.update("insert into account value(?,?)", "WangWu", 7000);
        System.out.println(row);
	}

效果：

JdbcTemplate基本使用-常用操作-更新操作

插入操作、修改操作、删除操作都是更新操作，用的方法都是update

在 com.lyh.test 包下面创建 JdbcTemplateCRUDTest类

package com.lyh.test;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

    //用Spring集成Junit的测试去完成
    //首先需要导入 spring-test 的包 和 junit的包（之前已经都导入了）
    //指定 让Spring作为驱动的内核，帮我进行测试
    //告诉其配置文件 让JdbcTemplateCRUDTest去完成对应的功能
    //得把配置文件 告诉JdbcTemplateCRUDTest 让其产生 应用上下文对象
    //测试谁 就把 那个对象 用 Autowired注入
    @RunWith(SpringJUnit4ClassRunner.class)
    @ContextConfiguration("classpath:applicationContext.xml")
    public class JdbcTemplateCRUDTest {

        //测试谁 注入谁
        @Autowired
        private JdbcTemplate jdbcTemplate;

        @Test
        public void testUpdate(){
            //将Lisi 的 钱 改成 10000块钱
            jdbcTemplate.update("update account set money=? where name=?",10000,"Lisi");
        }
    }

效果：
Lisi的钱修改成了 10000

删除操作的代码：

	@Test
    public void testDelete(){
        //将姓名 tom 删除掉
        jdbcTemplate.update("delete from account where name=?","tom");
    }

效果：
表中已经没有tom的相关信息了

JdbcTemplate基本使用-常用操作-查询操作

比较常用
RowMapper是一个接口。返回的是一个List集合，内部的参数是泛型。
RowMapper 翻译成中文是 行映射
原先在原始jdbc返回的数据ResultSet 结果集需要手动的去封装实体
现在不用手动封装，这个jdbcTemplate的query方法中的RowMapper类型的形参
就是具有封装数据功能的接口
可以用接口对应的实现类，看其内部有没有帮我进行一个实体属性封装的实现

RowMapper是一个接口，我们在这里是用这个接口对应的实现，
帮我完成一个数据实体的封装

在IDEA中按两下Shift，进行查询

找 spring 这个包，点进去

会看到 RowMapper 对应的实现

BeanPropertiesRowMapper 是对应的实体的属性封装。
实体属性行映射。

数据库中的3条数据

在 com.lyh.test 包中的 JdbcTemplateCRUDTest 类中
查询核心java代码：

	@Test
    public void testQueryAll(){
        //第二个参数是一个RowMapper接口，给它一个接口对应的实现就可以  这里的泛型是要封装的实体的泛型 参数的位置给Account的字节码类型对象
        List<Account> accountList = jdbcTemplate.query("select * from account", new BeanPropertyRowMapper<Account>(Account.class));
        //返回的是List集合 这个List集合的泛型是Account
        System.out.println(accountList);
        //Account对象的toString方法都已经写好了
    }

测试效果：

查询单个对象的核心java代码：

	@Test
    public void testQueryOne(){
        //返回的 就是 一个对象 Account
        Account account = jdbcTemplate.queryForObject("select * from account where name=?", new BeanPropertyRowMapper<Account>(Account.class), "tom");
        System.out.println(account);
    }

效果：

聚合查询：使用这个API

如果是简单类型，在这里就不用这个RowMapper去映射封装了，
直接需要把这个数据给你，进行一个强转就行。

聚合查询核心Java代码：

    //聚合查询
    //查询总数、查询加和、查询平均数
    @Test       //查询总条数
    public void testQueryCount(){
    //查询的总数，最终返回的也是一个结果，也可以用 queryForObject
    //最终返回的是一个数--总和  这个数就不是一个JavaBean了
    //不是一个实体了 就不需要进行封装了
    //这个的返回值是 Long型的
    //不需要映射封装，只有JavaBean才能进行一个属性的映射封装
    //直接转换成一个Long型 就可以
    Long count = jdbcTemplate.queryForObject("select count(*) from account", Long.class);
    System.out.println(count);
}