Java学习记录 Spring-JDBC_getjdbctemplate-优快云博客

本文链接：https://blog.youkuaiyun.com/weixin_45963193/article/details/118531367

本文介绍了如何使用Spring的JdbcTemplate类来简化JDBC操作，包括数据源配置、基本的增删改查方法以及聚合函数的应用。示例中展示了如何在Spring XML配置文件中配置数据源和JdbcTemplate，以及如何在 Dao 类中使用 JdbcTemplate 进行数据库操作。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Spring-JDBC实现

Spring 针对数据库开发提供了 JdbcTemplate 类，它封装了 JDBC，支持对数据库的所有操作

JDBC以往的说明：Java学习记录 JDBC篇

Class JdbcTemplate

org.springframework.jdbc.core.JdbcTemplate

方法

修饰符	返回	方法	说明
public	int	update(String sql)	用于执行新增、修改、删除等语句
public	int	update(String sql,Object… args)	用于执行新增、修改、删除等语句 args 表示需要传入的参数
public	void	execute(String sql)	可以执行任意 SQL，一般用于执行 DDL 语句 action 表示执行完 SQL 语句后，要调用的函数
public	T	query(String sql, ResultSetExtractor rse)	用于执行查询语句以 ResultSetExtractor 作为参数的 query 方法返回值为 Object
public	List	query(String sql, RowMapper rse)	使用查询结果需要对其进行强制转型以 RowMapper 作为参数的 query 方法返回值为 List
public	Map<String, Object>	queryForMap(String sql)	SQL查询多个聚合函数结果值，查询出的结果值形式：key-value

JDBC应用

导入包 spring-jdbc-x.x.x.jar 、spring-tx-x.x.x.jar 以下为个人用Maven配置

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

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

<!--    XML 配置数据源-->
    <bean id="dateSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <!--驱动加载-->
        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
        <!--连接数据库的url  . 本次连接 test库-->
     	<!--指定IP地址 、 库（个人应用的 test库）-->   
        <property name="url" value="jdbc:mysql://192.168.74.131/test"/>
        <property name="username" value="root"/>
        <property name="password" value="root"/>
    </bean>

<!--    配置jdbc模板-->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <!--必须使用数据源-->
        <property name="dataSource" ref="dateSource"/>
    </bean>

<!--    配置注入类使用-->
    <bean id="xxx" class="xxx">
        <property name="jdbcTemplate" ref="jdbcTemplate"/>
    </bean>
<!--	例如：-->
<!--    <bean id="studentDao" class="com.StudentDao">-->
<!--        <property name="jdbcTemplate" ref="jdbcTemplate"/>-->
<!--    </bean>-->
	...
</beans>

配置注入类需要自己指定类进行配置

创建实体类 Student

package com;

public class Student {
    int id ;
    String name;
    int age;
    
    public Student() {
    }
    
    public Student(int id , String name , int age) {
        this.id = id;
        this.name = name;
        this.age = age;
    }
    
    public Student(String name , int age) {
        this.name = name;
        this.age = age;
    }
    
    public int getAge() {
        return age;
    }
    
    public void setAge(int age) {
        this.age = age;
    }
    
    public int getId() {
        return id;
    }
    
    public void setId(int id) {
        this.id = id;
    }
    
    public String getName() {
        return name;
    }
    
    public void setName(String name) {
        this.name = name;
    }
    
    @Override
    public String toString() {
        return "Student{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

数据库 test库引入库

id	name	age

DROP TABLE IF EXISTS `student`;
CREATE TABLE `student`  (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `name` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
  `age` int(11) NULL DEFAULT 16,
  PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 16 CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Compact;

指定类注入使用 JdbcTemplate类 （应用指定实例 StudentDao；实现一个操作业务即可）

package com;

import org.springframework.dao.DataAccessException;
import org.springframework.jdbc.core.ResultSetExtractor;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.jdbc.core.support.JdbcDaoSupport;

import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.List;
import java.util.Map;

public class StudentDao extends JdbcDaoSupport {
    
    //方法封装
    public Student turnEncapsulation(ResultSet resultSet) throws SQLException {
        Student student = new Student();
        student.setId(resultSet.getInt("id"));
        student.setName(resultSet.getString("name"));
        student.setAge(resultSet.getInt("age"));
        return student;
    }
    
    /**
     * 添加数据
     * @param student 学生类封装
     * @return 更变条数
     */
    public int insert(Student student) {
        if (student == null) {
            return 0;
        } 
        String sql = "INSERT INTO student(name,age) VALUE(?,?)";
        return this.getJdbcTemplate().update(sql,student.getName(),student.getAge());
    }
    
    /**
     * 删除数据
     * @param id 删除指定id
     * @return 更变条数
     */
    public int delete(int id) {
        String sql = "DELETE FROM student WHERE id = ?";
        return this.getJdbcTemplate().update(sql,id);
    }
    
    /**
     * 更变数据
     * @param id 指定学生id
     * @param student 更变指定 学生类
     * @return 更变条数
     */
    public int update(int id , Student student) {
        String sql = "UPDATE student set name=?,age=? WHERE id=?";
        return this.getJdbcTemplate().update(sql,student.getName(),student.getAge(),id);
    }
    
    /**
     * 查询所有条数
     * @return 学生队列
     */
    public List<Student> queryAll(){
        String sql = "SELECT * FROM student";
        return this.getJdbcTemplate().query(sql , new RowMapper<Student>() {
            @Override
            public Student mapRow(ResultSet resultSet , int i) throws SQLException {
                System.out.println("\ti : " + i);
                return turnEncapsulation(resultSet);
            }
        });
    }
    
    /**
     * 查询指定学生
     * @param id 指定学生id
     * @return 学生队列
     */
    public List<Student> queryFindById(int id) {
        String sql = "SELECT * FROM student WHERE id = ?";
        return this.getJdbcTemplate().query(sql,new Object[]{id}, new RowMapper<Student>() {
            @Override
            public Student mapRow(ResultSet resultSet , int i) throws SQLException {
                System.out.println("\ti : " + i);
                return turnEncapsulation(resultSet);
            }
        });
    }
    
    /**
     * 查询指定学生名称
     * @param name 名称
     * @return 学生队列
     */
    public List<Student> queryFindByName(String name) {
        String sql = "SELECT * FROM student WHERE name = ?";
        //匿名 new RowMapper<Student>() 替换为 lambda
        return this.getJdbcTemplate().query(sql,new Object[]{name}, (resultSet , i) -> {
            System.out.println("\ti : " + i);
            return turnEncapsulation(resultSet);
        });
    }
    
    /**
     * 聚合函数应用
     */
    /**
     * 获取学生总数
     * @return 学生总数
     */
    public int tableSize(){
        String sql = "SELECT count(id) FROM student";
        return this.getJdbcTemplate().queryForObject(sql,Integer.class);
    }
    
    /**
     * 学生首尾id
     * @return MAP形式返回id首尾
     */
    public Map<String , Object> tableMaxMin(){
        String sql = "SELECT max(id),min(id) FROM student";
        return this.getJdbcTemplate().queryForMap(sql);
    }
    
}

测试类（测试业务）

package com;

import com.mchange.v2.c3p0.ComboPooledDataSource;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.jdbc.core.JdbcTemplate;

import java.beans.PropertyVetoException;
import java.util.List;
import java.util.Map;

//连接测试
public class connectionMySQL {

    ApplicationContext ac = new ClassPathXmlApplicationContext("springJDBC.xml");
    StudentDao dao = (StudentDao) ac.getBean("studentDao");
    
    /**
     * xml应用
     */
    @Test
    public void test01_Insert(){
        int insert = dao.insert(new Student("老哥" , 23));
        System.out.println("insert : " + insert);
    }
    @Test
    public void test02_Delete() {
        int delete = dao.delete(19);
        System.out.println("delete : " + delete);
        
    }
    @Test
    public void test03_Update() {
        int update = dao.update(16,new Student("黑马",32));
        System.out.println("update : " + update);
    }
    @Test
    public void test04_Query() {
        List<Student> student = dao.queryFindById(17);
        System.out.println("student : " + student);
    }
    @Test
    public void test04_Querys() {
        List<Student> students = dao.queryAll();
        // List<Student> students = dao.queryFindByName("李四");
        for (Student student : students) {
            System.out.println(student.toString());
        }
    }
    @Test
    public void test05_group(){
        int i = dao.tableSize();
        System.out.println("i : " + i);
        System.out.println("==============");
        Map<String, Object> stringObjectMap = dao.tableMaxMin();
        System.out.println("stringObjectMap : " + stringObjectMap);
    }
    
}