手撸一个JdbcTemplate，带你了解其原理

最新推荐文章于 2024-02-03 13:10:39 发布
最新推荐文章于 2024-02-03 13:10:39 发布
阅读量210 收藏 3
点赞数 1
分类专栏： java 文章标签： jdbc
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_37282062/article/details/115762635
版权

前提要求

  • 能够使用jdbc链接数据库
  • 能够利用jdbc完成数据库的增删改查等操作
  • 对泛型有一定的了解

基本原理

  • 通过jdbc链接数据库，查询数据库中内容
  • 利用反射对数据库中查询字段进行封装

步骤

1、创建项目

  • 创建Maven工程
    在这里插入图片描述
  • 输入项目名称
  • 创建resource文件目录：父目录为java文件夹
    在这里插入图片描述
  • 设置resource文件夹为resource文件夹：单击文件，项目结构
    在这里插入图片描述
    工程创建到此结束。

2、代码编写

2.1 maven导包，配置pom文件

  • 添加依赖
    mysql依赖、druid连接池依赖
 <!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>8.0.23</version>
    </dependency>

    <!-- https://mvnrepository.com/artifact/com.alibaba/druid -->
    <dependency>
      <groupId>com.alibaba</groupId>
      <artifactId>druid</artifactId>
      <version>1.2.5</version>
    </dependency>

2.2 druid配置

在resource文件夹下面创建文件并命名为：druid.properties 名称可以随便
并在文件中添加配置信息：

druid.url=jdbc:mysql://localhost:3306/demo?useUnicode=true&serverTimezone=Asia/Shanghai
druid.driverClassName=com.mysql.cj.jdbc.Driver
druid.username=root
druid.password=123456

根据自己的不同，自行修改

2.3 创建数据库以及表

CREATE DATABASE /*!32312 IF NOT EXISTS*/`demo` /*!40100 DEFAULT CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci */ /*!80016 DEFAULT ENCRYPTION='N' */;

USE `demo`;

/*Table structure for table `user` */

DROP TABLE IF EXISTS `user`;

CREATE TABLE `user` (
  `id` bigint NOT NULL AUTO_INCREMENT,
  `username` varchar(30) COLLATE utf8mb4_general_ci NOT NULL,
  `age` int NOT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=5 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci;

/*Data for the table `user` */

insert  into `user`(`id`,`username`,`age`) values 
(1,'张三',20),
(2,'李四',21),
(3,'王五',33),
(4,'陈六',25);

创建之后的数据展示：
在这里插入图片描述

2.4 创建数据库对应的Java实体类

import java.util.Objects;

public class User {

    private Long id;

    private String username;

    private Integer age;

    public User() {
    }

    public User(Long id, String username, Integer age) {
        this.id = id;
        this.username = username;
        this.age = age;
    }

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        User user = (User) o;
        return Objects.equals(id, user.id) && Objects.equals(username, user.username) && Objects.equals(age, user.age);
    }

    @Override
    public int hashCode() {
        return Objects.hash(id, username, age);
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", username='" + username + '\'' +
                ", age=" + age +
                '}';
    }
}

2.5 创建DBUtils类


public class DBUtils {

    private static DataSource dataSource;

    static {
        // 配置文件
        try {
            InputStream is = App.class.getClassLoader().getResourceAsStream("druid.properties");
            Properties properties = new Properties();
            properties.load(is);
            dataSource = DruidDataSourceFactory.createDataSource(properties);
        } catch (IllegalArgumentException e) {
            System.out.println("文件有误");
        } catch (IOException e) {
            System.out.println("打开配置文件失败");
        } catch (Exception e) {
            System.out.println("德鲁伊数据源创建失败");
        }
    }

    /**
     * 获取链接
     *
     * @return 数据库链接
     */
    public static Connection getConnection() {
        Connection connection = null;
        try {
            connection = dataSource.getConnection();
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return connection;
    }

    /**
     * 资源释放
     */
    public static void release(Connection connection, Statement statement, RowSet rowSet) {
        try {
            release(connection, statement, null, rowSet);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    public static void release(Connection connection, Statement statement, ResultSet resultSet) {
        try {
            release(connection, statement, resultSet, null);
        } catch (SQLException e) {
            e.printStackTrace();
        }

    }

    public static void release(Connection connection, Statement statement, ResultSet resultSet, RowSet rowSet) throws SQLException {
        if (rowSet != null) {
            rowSet.close();
        }
        if (resultSet != null) {
            resultSet.close();
        }
        if (statement != null) {
            statement.close();
        }
        if (connection != null) {
            connection.close();
        }
    }

}

2.6 创建JDBCTemplate抽象类

import java.util.List;

public abstract class JdbcTemplate<T> {

    protected Class<T> entityClass;

    protected JdbcTemplate(Class<T> entityClass) {
        this.entityClass = entityClass;
    }

    public abstract List<T> query(String sql, Object... args);

}

2.7 创建QueryTemplate查询模板

import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.sql.*;
import java.util.*;

public class QueryTemplate<T> extends JdbcTemplate<T> {

    public QueryTemplate(Class<T> entityClass) {
        super(entityClass);
    }

    @Override
    public List<T> query(String sql, Object... args) {
        Connection connection = null;
        PreparedStatement preparedStatement = null;
        ResultSet resultSet = null;
        List<T> result = new ArrayList<>();
        try {
            connection = DBUtils.getConnection();
            preparedStatement = connection.prepareStatement(sql);

            // 设置参数
            for (int i = 1; i <= args.length; i++) {
                setValue(i, args[i - 1], preparedStatement);
            }

            resultSet = preparedStatement.executeQuery();
            Map<String, String> metaMap = getMetaMap(preparedStatement);

            while (resultSet.next()) {
                T entity = getEntity(preparedStatement, resultSet);
                result.add(entity);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            DBUtils.release(connection, preparedStatement, resultSet);
        }
        return result;
    }

    /**
     * 获得具体的对象，并赋值
     */
    private T getEntity(PreparedStatement preparedStatement, ResultSet resultSet) {
        Map<String, String> metaMap = getMetaMap(preparedStatement);
        try {
            T object = entityClass.newInstance();
            Set<String> keySet = metaMap.keySet();
            for (String key : keySet) {
                Object value = getValue(key, metaMap.get(key), resultSet);
                // 获取属性
                Field field = entityClass.getDeclaredField(key);
                Method declaredMethod = entityClass.getMethod(constructSetMethod(key), field.getType());
                declaredMethod.invoke(object, value);
            }
            return object;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 获得数据库中 字段名称与数据类型的映射
     * @return Map
     */
    private static Map<String, String> getMetaMap(PreparedStatement preparedStatement) {
        Map<String, String> metaMap = new HashMap<>();
        try {
            ResultSetMetaData metaData = preparedStatement.getMetaData();
            // 遍历元素
            for (int i = 1; i <= metaData.getColumnCount(); i++) {
                String columnName = metaData.getColumnName(i);
                String columnTypeName = metaData.getColumnTypeName(i);
                metaMap.put(columnName, columnTypeName);
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return metaMap;
    }

    /**
     * 根据具体字段获得其属性赋值方法
     * @param key 成员名称
     * @return 方法名称
     */
    private static String constructSetMethod(String key) {
        String substring = key.substring(0, 1).toUpperCase() + key.substring(1);
        return "set" + substring;
    }

    /**
     * 预编译statement赋值
     * @param index 参数占位符 索引
     * @param value 具体值
     */
    private static void setValue(int index, Object value, PreparedStatement preparedStatement) {
        // 获得类型
        String typeName = value.getClass().getTypeName();
        try {
            switch (typeName) {
                case "java.lang.Long":
                    preparedStatement.setLong(index, Long.parseLong(value.toString()));
                    break;
                case "java.lang.String":
                    preparedStatement.setString(index, value.toString());
                    break;
                case "java.lang.Integer":
                    preparedStatement.setInt(index, Integer.parseInt(value.toString()));
                    break;
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }

    }

    /**
     * 从ResultSet中获取对应的值
     * @param key 字段
     * @param typeName 返回数据类型
     * @param resultSet 结果集
     * @return 值
     */
    private static Object getValue(String key, String typeName, ResultSet resultSet) {
        Object value = null;
        try {
            switch (typeName) {
                case "BIGINT":
                    value = resultSet.getLong(key);
                    break;
                case "INT":
                    value = resultSet.getInt(key);
                    break;
                case "VARCHAR":
                    value = resultSet.getString(key);
                    break;
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return value;
    }


}

创建程序入口类App

public class App {

    public static void main(String[] args) {
        JdbcTemplate<User> jdbcTemplate= new QueryTemplate<>(User.class);
        // 定义sql语句
        String sql = "select * from user where age > 20";
        // 执行
        List<User> users = jdbcTemplate.query(sql);
        for (User user : users) {
            System.out.println(user);
        }
    }
}

运行结果：
在这里插入图片描述
总结： 通过这段代码，基本上就能够知道如何去封装一个数据集，这也是ORM框架的基本封装思路，主要是数据查询比较麻烦，数据封装较为繁琐，其他的方法可以入法炮制，这里不再演示。读者也可以自行测试其他类，或者完成其他操作的封装。

项目Gitee地址

暮歌半生情朽
关注
专栏目录
Java学习（下）
Lzdnydppx的博客
08-16 486
web开发、spring开发、spring boot开发、spring cloud开发
面渣逆袭：Spring三十五问，四万字+五十图详解
www_xuhss_com的博客
04-20 366
Python微信订餐小程序课程视频 https://blog.csdn.net/m0_56069948/article/details/122285951 Python实战量化交易理财系统 https://blog.csdn.net/m0_56069948/article/details/122285941 大家好，我是老三啊，面渣逆袭 继续，这节我们来搞定另一个面试必问知识点——Spring。 有人说，“Java程序员都是Spring程序员”，老三不太赞成这个观点，但是这也可以看出Spring在Java世
Spring JDBCTemplate原理及使用实例
08-19
主要介绍了Spring JDBCTemplate原理及使用实例,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
Spring JdbcTemplate框架（一）——基本原理
信息技术提高班第九期
05-25 7934
JDBC已经能够满足大部分用户擦欧洲哦数据库的需求，但是在使用JDBC时，应用必须自己来管理数据库资源。spring对数据库操作需求提供了很好的支持，并在原始JDBC基础上，构建了一个抽象层，提供了许多使用JDBC的模板和驱动模块，为Spring应用操作关系数据库提供了更大的便利。 Spring封装好的模板，封装了数据库存取的基本过程，方便用户。   一、模板方法
JdbcTemplate原理
Artisan_w
06-20 272
JdbcTemplate源码原理与问题
spring jdbcTemplate
weixin_34220623的博客
08-29 290
一、JdbcTemplate主要提供以下五类方法： execute方法：可以用于执行任何SQL语句，一般用于执行DDL语句； update方法及batchUpdate方法：update方法用于执行新增、修改、删除等语句；batchUpdate方法用于执行批处理相关语句； query方法及queryForXXX方法：用于执行查询相关语句； call方法：用于执行存储过程、函数相关语句。 ...
JdbcTemplate原理分析
进击的博客
04-13 3170
1.类继承结构其中JdbcAccessor是抽象类，为子类提供公用属性，主要包括DataSource、SQLExceptionTranslator(提供get、set方法)JdbcOperations接口定义了需要JdbcTemplate可以使用的一些操作，如增删改查之类的具体来说JdbcTemplate为我们提供了如下方法：2.JdbcTemplate所提供的方法execute方法：可以用于执行...
芋道 Spring Boot Redis 入门
芋艿V
01-21 731
点击上方“芋道源码”，选择“设为星标”做积极的人，而不是积极废人！源码精品专栏原创 | Java 2019 超神之路，很肝~中文详细注释的开源项目RPC 框架 Dubbo 源码解析网络...
MyBatis学习笔记
jacksonary的博客
04-25 1222
 先做个科普吧，MyBatis是其3.0以后的叫法，之前的版本都叫iBatis，这个名字肯定听过吧，也是大名鼎鼎的Apache旗下的产品，后来易主谷歌，正式改名为MyBatis，代码迁到github上。它是一种持久化框架，和Hibernate一样都是ORM(Object Relation Mapping，对象关系映射)框架，他们需要完成的任务都是将JavaBean映射成数据库中的一条记录。  不...
JDBCTemplate框架的底层原理概述
учёба
09-09 578
自定义JDBC框架 背景： ​ 定义必要的信息、获取数据库的连接、释放资源都是重复的代码,而我们最终的核心功能仅仅只是执行条sql语询,所以我们可以抽取出一个JDBC模板类，来封装一些方法(update、 query) ,专门帮我们执行增删改查的sql语句。将之前那些重复的操作,都抽取到模板类中的方法里,就能大大简化我们的使用步骤! 框架的编写 update方法的实现(删除、添加、修改功能) package JDBCT; import Case.utils.DataSourceUtils;
数据访问：如何剖析 JdbcTemplate 数据访问实现原理？
最新发布
我乐了的博客
02-03 946
首先，CallbackJdbcTemplate 不是一个抽象类。其次，execute 方法签名上传入的是一个 StatementCallback 对象，而具体的定制化处理是通过 Statement 传入到 Callback 对象中完成的，我们也可以认为是把原有需要子类抽象方法实现的功能转嫁到了 StatementCallback 对象上。
JdbcTemplate的简单介绍和基本操作
LrvingTc的博客
01-20 531
什么JDBCTemplate？ Spring框架对JDBC的简单封装。提供了一个JDBCTemplate对象简化JDBC的开发 JDBCTemplate的基本使用 导入几个jar包 创建JdbcTemplate对象。需要传入数据源DataSource。 JdbcTemplate template = new JdbcTemplate(DataSource ds)； 进行增删改查操作 ...
SpringBoot 中 JdbcTemplate 数据访问的实现原理
姜皓的博客
12-22 678
SpringBoot 中 JdbcTemplate 数据访问的实现原理1）从模板方法模式和回调机制说起1.1 模板方法设计模式1.2 回调机制1.3 JDBC API 到 JdbcTemplate 的演变在 JDBC API 中添加模板方法模式2）在 JDBC API 中添加回调机制3）JdbcTemplate 源码解析4）小结 通过 JdbcTemplate 不仅简化了数据库操作，还避免了使用原生 JDBC 带来的代码复杂度和冗余性问题。 那么，JdbcTemplate 在 JDBC 基础上如何实现封装的
Spring JDBC原理与应用实例讲解
Evankaka的专栏
05-04 6509
使用Spring进行基本的JDBC访问数据库有多种选择。Spring至少提供了三种不同的工作模式：Spring JDBC抽象框架core包提供了JDBC模板类，其中JdbcTemplate是core包的核心类，所以其他模板类都是基于它封装完成的，JDBC模板类是第一种工作模式。
Spring学习（3）：jdbcTemplate详解
欢迎来到Jimmy的博客
04-19 1025
前言spring同样提供了一套对jdbc的封装代码，并且可以配置数据源（DataSource，数据库连接池）。这样一来，写程序的时候就可以专注于业务逻辑（增删改查等），而不用去管数据库的连接和关闭等琐事。这套代码封装就是JdbcTemplate模板，该模板已经封装进了Spring框架，为了使用它，我们要在配置文件中配置bean。正文一，生成jdbcTemplate并测试1，首先编写数据库连接的db.
JdbcTemplate源码解析
程序员小董的专栏
09-11 2426
先写一个测试代码 package jdbc; import java.sql.ResultSet; import java.sql.SQLException; import java.util.ArrayList; import java.util.HashMap; import java.util.List; import java.util.Map; import org.sprin
从JDBC到手撸极简版Mybaties（4）连接池加动态代理
qq_44886056的博客
01-17 676
简介 好了，其实就目前来说，我们的JDBC类已经封装的差不多了。但是！别忘了我们最初的目的！手写极简版的小框架！！ 所以对于目前来说，我们的数据库连接的管理（即：啥时候连接，啥时候断开，连接时长等）在我们的工具类中还是很混乱的，而站在巨人的肩膀上才能看的更远！ SO，我们选择使用连接池进行自动管理。当然，市面上连接池有不少，我们选用来自阿里的德鲁伊（druid）来进行管理。别问为啥，我就是觉得这个名字挺不错的，想用别的也行，没啥大区别。 之后，我们还需要加入动态代理，来让我们的项目更偏向于一个”框架“。 配
JDBCTemplate与模板设计方法(二)
weixin_30423977的博客
09-17 197
前言：上一篇博客介绍了模板方法模式，并且给出了一个小demo，简单对模板方法进行了实现，接下来我们把目光转向spring的源码JDBCTemplate，看一看spring是如何对jdbc进行高度封装的。 本篇博客的目录： 一：传统的jdbc存在的缺陷和不足 二：JDBCTemplate的实现原理 三：JDBCTemplate的使用方法 五：总结 正文: 一：传统的jdbc存在的缺陷和...
Spring JdbcTemplate执行过程分析
SAN_YUN的专栏
07-08 309
调用入口 调用JdbcTemplate提供的API都会委托给execute()，代码如下： public &lt;T&gt; T execute(PreparedStatementCreator psc, PreparedStatementCallback&lt;T&gt; action) throws DataAccessException { Assert.notNull...
jdbctemplate执行一个不带参数的存储过程
05-19
使用 JdbcTemplate 执行不带参数的存储过程可以按照以下步骤进行： 1. 创建 JdbcTemplate 对象，需要注入 DataSource 对象。 ``` @Autowired private JdbcTemplate jdbcTemplate; ``` 2. 编写 SQL 语句，调用存储过程。 ``` String sql = "{call stored_procedure_name()}"; ``` 3. 调用 JdbcTemplate 的 execute 方法执行存储过程。 ``` jdbcTemplate.execute(sql); ``` 完整的示例代码如下： ``` @Autowired private JdbcTemplate jdbcTemplate; public void callStoredProcedure() { String sql = "{call stored_procedure_name()}"; jdbcTemplate.execute(sql); } ``` 注意：该方式适用于不带参数的存储过程，如果需要传递参数，需要使用另外的方法。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值