JDBCTemplate使用步骤

文章目录

Spring JDBC

  • Spring 框架对 JDBC 进行了简单的封装,提供了一个 JDBCTemplate 对象简化 JDBC 的开发

使用步骤

  1. 使用 maven 创建一个Java项目,导入所需要的依赖。

    复制代码
       <dependencies>
            <!-- JDBCTemplate所需依赖-->
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-jdbc</artifactId>
                <version>5.3.14</version> <!-- 替换为你需要的版本号 -->
            </dependency>
            <!-- MySQL数据库连接驱动 -->
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <version>8.0.27</version> <!-- 替换为你需要的版本号 -->
            </dependency>
            <!-- Druid 数据库连接池 -->
            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>druid</artifactId>
                <version>1.2.6</version> <!-- 替换为你需要的版本号 -->
            </dependency>
            <!-- 测试依赖-->
            <dependency>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
                <version>4.13.2</version> <!-- 替换为你需要的版本号 -->
                <scope>compile</scope>
            </dependency>
        </dependencies>
  2. 创建工具类,使用 Druid 连接池。

    java 复制代码
    import com.alibaba.druid.pool.DruidDataSourceFactory;
    
    import javax.sql.DataSource;
    import java.io.InputStream;
    import java.sql.Connection;
    import java.sql.SQLException;
    import java.util.Properties;
    // 工具类
    public class JdbcUtils {
        private static DataSource dataSource;
    
        static {
            try {
                // 加载配置文件
                Properties properties = new Properties();
                InputStream inputStream = JdbcUtils.class.getClassLoader().getResourceAsStream("druid.properties");
                properties.load(inputStream);
                // 创建数据源
                dataSource = DruidDataSourceFactory.createDataSource(properties);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    
        // 获取数据库连接
        public static Connection getConnection() throws SQLException {
            System.out.println(dataSource);
            return dataSource.getConnection();
        }
    
        // 释放资源
        public static void close(Connection conn) {
            if (conn != null) {
                try {
                    conn.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
        }
    
        // 获取数据库连接池对象
        public static DataSource getDataSource(){
            return dataSource;
        }
    }
  3. 在【src-main-resources】下边创建文件 【druid.properties】(更换自己的数据库用户名和密码)

    properties 复制代码
    url = jdbc:mysql://localhost:3306/test
    username = root
    password = root
  4. 创建实体类,封装由数据库查询到的数据

    java 复制代码
    public class Account {
        private int id;
        private String name;
        private double balance;
    
        public Account() {
        }
    
        public Account(int id, String name, double balance) {
            this.id = id;
            this.name = name;
            this.balance = balance;
        }
    
        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;
        }
    
        public double getBalance() {
            return balance;
        }
    
        public void setBalance(double balance) {
            this.balance = balance;
        }
    
        @Override
        public String toString() {
            return "Account{" +
                    "id=" + id +
                    ", name='" + name + '\'' +
                    ", balance=" + balance +
                    '}';
        }
    }
  5. 在【src-main-java】下边创建类 Test,几种使用方法(可以看的时候参考下下边的方法介绍)

    java 复制代码
    import org.springframework.jdbc.core.BeanPropertyRowMapper;
    import org.springframework.jdbc.core.JdbcTemplate;
    import java.util.List;
    import java.util.Map;
    import java.util.Set;
    
    
    public class Test {
    
        private JdbcTemplate template;
    
        {
            // 创建 JdbcTemplate 对象,依赖于数据源
            template = new JdbcTemplate(JdbcUtils.getDataSource());
        }
    
        @org.junit.Test
        public void test1(){
            // 调用 JdbcTemplate 完成 增删改操作
            String sql = "UPDATE account SET balance = 1000 WHERE id = ?";
            int i = template.update(sql,2);
            System.out.println(i);
        }
    
        /*查询的结果集只能有一行,多行报错,可删除条件试试*/
        @org.junit.Test
        public void test2(){
            // 定义查询语句
            String sql = "SELECT * FROM account WHERE id = ?";
            // 将结果封装为 Map 集合
            Map<String, Object> map = template.queryForMap(sql , 2);
            // 遍历集合
            Set<String> keySet = map.keySet();
            for (String key : keySet) {
                Object obj = map.get(key);
                System.out.println(key + "--" + obj);
            }
        }
    
        /*查询的结果可以多行,将每一行封装成一个 map 集合,再将多行 map 封装成一个 list 集合*/
        @org.junit.Test
        public void test3(){
            // 定义查询语句
            String sql = "SELECT * FROM account";
            // 将结果封装成 List 集合
            List<Map<String, Object>> maps = template.queryForList(sql);
            // 遍历集合
            for (Map<String, Object> map : maps) {
                System.out.println(map);
            }
        }
    
        /*查询的结果,由数据库封装到实体类中,然后 从实体类中遍历得到所有结果*/
        @org.junit.Test
        public void test4(){
            // 定义查询语句
            String sql = "SELECT * FROM account";
            // 完成数据到 JavaBean 的自动封装
            BeanPropertyRowMapper<Account> bean = new BeanPropertyRowMapper<>(Account.class);
            List<Account> list = template.query(sql, bean);
            for (Account l : list) {
                System.out.println(l);
            }
        }
    }

JDBCTemplate方法介绍

方法 作用 注意事项
update() 执行DML语句,增删改
queryForMap() 查询结果封装为map集合 查询的结果长度只能是1,只能查1行数据
queryForList() 查询结果封装为list集合 将每一行记录封装成一个 map 集合,再将 map 集合封装到 list 集合中
queryForObject() 查询结果封装为对象 一般用于聚合函数的查询
query() 查询结果封装为 Javabean 对象 使用 BeanPropertyRowMapper 实现类,完成数据到JavaBean 的自动分装 格式:new BeanPropertyRowMapper<类型>(类型.class)

注意:类型指的是,Java中的实体类,依照表格字段我们创建的类

相关推荐
我叫汪枫12 小时前
《Java餐厅的待客之道:BIO, NIO, AIO三种服务模式的进化》
java·开发语言·nio
yaoxtao12 小时前
java.nio.file.InvalidPathException异常
java·linux·ubuntu
Swift社区14 小时前
从 JDK 1.8 切换到 JDK 21 时遇到 NoProviderFoundException 该如何解决?
java·开发语言
DKPT14 小时前
JVM中如何调优新生代和老生代?
java·jvm·笔记·学习·spring
phltxy14 小时前
JVM——Java虚拟机学习
java·jvm·学习
seabirdssss16 小时前
使用Spring Boot DevTools快速重启功能
java·spring boot·后端
喂完待续16 小时前
【序列晋升】29 Spring Cloud Task 微服务架构下的轻量级任务调度框架
java·spring·spring cloud·云原生·架构·big data·序列晋升
benben04416 小时前
ReAct模式解读
java·ai
轮到我狗叫了17 小时前
牛客.小红的子串牛客.kotori和抽卡牛客.循环汉诺塔牛客.ruby和薯条
java·开发语言·算法