JDBC操作数据库

已于 2022-12-19 10:02:21 修改
阅读量663 收藏 5
点赞数 1
分类专栏： # MySQL Java 文章标签： 数据库 mysql apache
于 2022-06-02 13:29:13 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_46283220/article/details/125098533
版权
Java 同时被 2 个专栏收录
31 篇文章 0 订阅
订阅专栏
MySQL
16 篇文章 1 订阅
订阅专栏

新建项目

首先，新建项目如下：

 

导入jar包

新建lib目录，导入jar包

  • mysql-connector-java-5.1.37-bin.jar 是mysql数据库驱动，用于操作mysql数据库
  • druid-1.1.10.jar 德鲁伊数据库连接池，用于连接数据库
  • commons-dbutils-1.3.jar commons-dbutils 是 Apache 组织提供的一个开源 JDBC工具类库，它是对JDBC的简单封装。
 

还需要添加到路径才能使用

 

添加路径完成

 

具体代码

分成3个包

  • util：JDBCUtils包含数据库的连接和关闭
  • bean：实体类
  • dao：数据库的操作
 

util包

 

JDBCUtils.java
可直接复用

package com.jdbcTest.util;

import com.alibaba.druid.pool.DruidDataSourceFactory;
import org.apache.commons.dbutils.DbUtils;

import javax.sql.DataSource;
import java.io.InputStream;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Properties;

/**
 * @author zj
 * @date 2022/6/2 12:51
 */
public class JBDCUtils {
    /**
     * 获取数据库的连接
     * 使用Druid数据库连接池技术
     */
    private static DataSource source;
    static{
        try {
            Properties pros = new Properties();

            InputStream is = ClassLoader.getSystemClassLoader().getResourceAsStream("druid.properties");

            pros.load(is);

            source = DruidDataSourceFactory.createDataSource(pros);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    public static Connection getConnection() throws SQLException {
        Connection conn = source.getConnection();
        return conn;
    }

    /**
     * 关闭数据库资源
     *使用dbutils.jar中提供的DbUtils工具类，实现资源的关闭
     */
    public static void closeResource(Connection conn, Statement ps, ResultSet rs){
        DbUtils.closeQuietly(conn);
        DbUtils.closeQuietly(ps);
        DbUtils.closeQuietly(rs);
    }

    public static void closeResource(Connection conn){
        DbUtils.closeQuietly(conn);
    }
}

数据库连接配置文件

 

druid.properties

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

bean包

以User表为例

 

项目结构

 

User.java

package com.jdbcTest.bean;

/**
 * @author zj
 * @date 2022/6/2 12:54
 */
public class User {
    int id;
    String name;
    String password;
    String address;
    String phone;

    public User() {
    }

    public User(int id, String name, String password, String address, String phone) {
        this.id = id;
        this.name = name;
        this.password = password;
        this.address = address;
        this.phone = phone;
    }

    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 String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    public String getPhone() {
        return phone;
    }

    public void setPhone(String phone) {
        this.phone = phone;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", password='" + password + '\'' +
                ", address='" + address + '\'' +
                ", phone='" + phone + '\'' +
                '}';
    }
}

dao包

项目结构

 

BaseDAO.java
可复用
定义一个用来被继承的对数据库进行基本操作的Dao

package com.jdbcTest.dao;

/**
 * @author zj
 * @date 2022/6/2 12:57
 */
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.List;

import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.BeanHandler;
import org.apache.commons.dbutils.handlers.BeanListHandler;
import org.apache.commons.dbutils.handlers.ScalarHandler;


/**
 * 定义一个用来被继承的对数据库进行基本操作的Dao
 *
 * @author HanYanBing
 *
 * @param <T>
 */
public abstract class BaseDAO<T> {
    private QueryRunner queryRunner = new QueryRunner();
    // 定义一个变量来接收泛型的类型
    private Class<T> type;

    // 获取T的Class对象，获取泛型的类型，泛型是在被子类继承时才确定
    public BaseDAO() {
        // 获取子类的类型
        Class clazz = this.getClass();
        // 获取父类的类型
        // getGenericSuperclass()用来获取当前类的父类的类型
        // ParameterizedType表示的是带泛型的类型
        ParameterizedType parameterizedType = (ParameterizedType) clazz.getGenericSuperclass();
        // 获取具体的泛型类型 getActualTypeArguments获取具体的泛型的类型
        // 这个方法会返回一个Type的数组
        Type[] types = parameterizedType.getActualTypeArguments();
        // 获取具体的泛型的类型·
        this.type = (Class<T>) types[0];
    }

    /**
     * 通用的增删改操作
     *
     * @param sql
     * @param params
     * @return
     */
    public int update(Connection conn, String sql, Object... params) {
        int count = 0;
        try {
            count = queryRunner.update(conn, sql, params);
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return count;
    }

    /**
     * 获取一个对象
     *
     * @param sql
     * @param params
     * @return
     */
    public T getBean(Connection conn,String sql, Object... params) {
        T t = null;
        try {
            t = queryRunner.query(conn, sql, new BeanHandler<T>(type), params);
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return t;
    }

    /**
     * 获取所有对象
     *
     * @param sql
     * @param params
     * @return
     */
    public List<T> getBeanList(Connection conn, String sql, Object... params) {
        List<T> list = null;
        try {
            list = queryRunner.query(conn, sql, new BeanListHandler<T>(type), params);
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return list;
    }

    /**
     * 获取一个值的方法，专门用来执行像 select count(*)...这样的sql语句
     *
     * @param sql
     * @param params
     * @return
     */
    public Object getValue(Connection conn,String sql, Object... params) {
        Object count = null;
        try {
            // 调用queryRunner的query方法获取一个单一的值
            count = queryRunner.query(conn, sql, new ScalarHandler(), params);
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return count;
    }
}

UserDAO和UserDAOImpl成对出现
UserDAO.java
接口

package com.jdbcTest.dao;

import com.jdbcTest.bean.User;

import java.sql.Connection;
import java.util.List;

/**
 * @author zj
 * @date 2022/6/2 12:59
 */
public interface UserDAO {
    /**
     * @param conn
     * @param user
     * @Description 将user对象添加到数据库中
     * @author shkstart
     * @date 上午11:00:27
     */
    void insert(Connection conn, User user);

    /**
     * @param conn
     * @param id
     * @Description 针对指定的id，删除表中的一条记录
     * @author shkstart
     * @date 上午11:01:07
     */
    void deleteById(Connection conn, int id);

    /**
     * @param conn
     * @param user
     * @Description 针对内存中的user对象，去修改数据表中指定的记录
     * @author shkstart
     * @date 上午11:02:14
     */
    void update(Connection conn, User user);

    /**
     * @param conn
     * @param id
     * @Description 针对指定的id查询得到对应的User对象
     * @author shkstart
     * @date 上午11:02:59
     */
    User getUserById(Connection conn, int id);

    /**
     * @param conn
     * @return
     * @Description 查询表中的所有记录构成的集合
     * @author shkstart
     * @date 上午11:03:50
     */
    List<User> getAll(Connection conn);

    /**
     * @param conn
     * @return
     * @Description 返回数据表中的数据的条目数
     * @author shkstart
     * @date 上午11:04:44
     */
    Long getCount(Connection conn);
}

UserDAOImpl.java
与数据库交互的具体实现，在这里写sql语句

package com.jdbcTest.dao;

import com.jdbcTest.bean.User;

import java.sql.Connection;
import java.util.List;

/**
 * @author zj
 * @date 2022/6/2 13:01
 */
public class UserDAOImpl extends BaseDAO<User> implements UserDAO {

    @Override
    public void insert(Connection conn, User user) {
        String sql = "insert into user(name,password,address,phone) values (?,?,?,?)";
        update(conn, sql, user.getName(), user.getPassword(), user.getAddress(), user.getPhone());
    }

    @Override
    public void deleteById(Connection conn, int id) {
        String sql = "delete from user where id = ?";
        update(conn, sql, id);
    }

    @Override
    public void update(Connection conn, User user) {
        String sql = "update user set name = ?, password = ?, address = ?, phone = ? where id = ?";
        update(conn, sql, user.getName(), user.getPassword(), user.getAddress(), user.getPhone(), user.getId());
    }

    @Override
    public User getUserById(Connection conn, int id) {
        String sql = "select id,name,password,address,phone from user where id = ?";
        User user = getBean(conn, sql, id);
        return user;
    }

    @Override
    public List<User> getAll(Connection conn) {
        String sql = "select id,name,password,address,phone from user";
        List<User> all = getBeanList(conn, sql);
        return all;
    }

    @Override
    public Long getCount(Connection conn) {
        String sql = "select count(*) from user";
        Long value = (Long) getValue(conn, sql);
        return value;
    }
}

测试

原User表数据

 

测试插入

	@Test
    public void testInsertUser() {
        Connection conn = null;
        try {
            conn = JDBCUtils.getConnection();
            userDAO.insert(conn, new User(0, "小红", "123456", "安徽", "13345672134"));
        } catch(SQLException e) {
            e.printStackTrace();
        } finally {
            JDBCUtils.closeResource(conn);
        }
    }
 

测试删除

	@Test
    public void testDeleteUser() {
        Connection conn = null;
        try {
            conn = JDBCUtils.getConnection();
            userDAO.deleteById(conn, 8);
        } catch(SQLException e) {
            e.printStackTrace();
        } finally {
            JDBCUtils.closeResource(conn);
        }
    }
 

测试修改

	@Test
    public void testUpdateUser() {
        Connection conn = null;
        try {
            conn = JDBCUtils.getConnection();
            userDAO.update(conn, new User(1, "小绿", "123456", "安徽", "13345672134"));
        } catch(SQLException e) {
            e.printStackTrace();
        } finally {
            JDBCUtils.closeResource(conn);
        }
    }
 

测试查询一条记录

	@Test
    public void testSelect() {
        Connection conn = null;
        try {
            conn = JDBCUtils.getConnection();
            User user = userDAO.getUserById(conn, 3);
            System.out.println("user = " + user);
        } catch(SQLException e) {
            e.printStackTrace();
        } finally {
            JDBCUtils.closeResource(conn);
        }
    }
 

测试查询多条记录

	@Test
    public void testSelectAll() {
        Connection conn = null;
        try {
            conn = JDBCUtils.getConnection();
            List<User> all = userDAO.getAll(conn);
            all.forEach(System.out::println);
        } catch(SQLException e) {
            e.printStackTrace();
        } finally {
            JDBCUtils.closeResource(conn);
        }
    }
 

测试查询特殊值

	@Test
    public void testCount() {
        Connection conn = null;
        try {
            conn = JDBCUtils.getConnection();
            Long count = userDAO.getCount(conn);
            System.out.println("count = " + count);
        } catch(SQLException e) {
            e.printStackTrace();
        } finally {
            JDBCUtils.closeResource(conn);
        }
    }
 

完整测试代码

MyTest.java

package com.jdbcTest;

import com.jdbcTest.bean.User;
import com.jdbcTest.dao.UserDAOImpl;
import com.jdbcTest.util.JDBCUtils;
import org.testng.annotations.Test;

import java.sql.Connection;
import java.sql.SQLException;
import java.util.List;

/**
 * @author zj
 * @date 2022/6/2 13:04
 */
public class MyTest {
    UserDAOImpl userDAO = new UserDAOImpl();

    @Test
    public void testInsertUser() {
        Connection conn = null;
        try {
            conn = JDBCUtils.getConnection();
            userDAO.insert(conn, new User(0, "小红", "123456", "安徽", "13345672134"));
        } catch(SQLException e) {
            e.printStackTrace();
        } finally {
            JDBCUtils.closeResource(conn);
        }
    }

    @Test
    public void testDeleteUser() {
        Connection conn = null;
        try {
            conn = JDBCUtils.getConnection();
            userDAO.deleteById(conn, 8);
        } catch(SQLException e) {
            e.printStackTrace();
        } finally {
            JDBCUtils.closeResource(conn);
        }
    }

    @Test
    public void testUpdateUser() {
        Connection conn = null;
        try {
            conn = JDBCUtils.getConnection();
            userDAO.update(conn, new User(1, "小绿", "123456", "安徽", "13345672134"));
        } catch(SQLException e) {
            e.printStackTrace();
        } finally {
            JDBCUtils.closeResource(conn);
        }
    }

    @Test
    public void testSelect() {
        Connection conn = null;
        try {
            conn = JDBCUtils.getConnection();
            User user = userDAO.getUserById(conn, 3);
            System.out.println("user = " + user);
        } catch(SQLException e) {
            e.printStackTrace();
        } finally {
            JDBCUtils.closeResource(conn);
        }
    }

    @Test
    public void testSelectAll() {
        Connection conn = null;
        try {
            conn = JDBCUtils.getConnection();
            List<User> all = userDAO.getAll(conn);
            all.forEach(System.out::println);
        } catch(SQLException e) {
            e.printStackTrace();
        } finally {
            JDBCUtils.closeResource(conn);
        }
    }

    @Test
    public void testCount() {
        Connection conn = null;
        try {
            conn = JDBCUtils.getConnection();
            Long count = userDAO.getCount(conn);
            System.out.println("count = " + count);
        } catch(SQLException e) {
            e.printStackTrace();
        } finally {
            JDBCUtils.closeResource(conn);
        }
    }
}

总结

完整项目结构

 

只需要按需要查询的表，增加以上圈出的3个java文件即可实现对数据库表的操作。

改进：实现多表连接查询和嵌套查询。

参考资料

尚硅谷JDBC核心技术视频教程（康师傅带你一站式搞定jdbc）
尚硅谷_宋红康_JDBC课件.md

dotJunz
关注
  • 1
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
实验3 JDBC操作数据库3
08-08
实验3 JDBC操作数据库3主要目的是通过Java的JDBC技术来熟悉和掌握数据库的连接与操作。这个实验涉及了以下几个核心知识点： 1. **MySQL数据库**：实验中提到了使用MySQL作为关系型数据库管理系统，它是开源且广泛...
如何使用JDBC操作数据库？一文带你吃透JDBC规范
zhangxia_的博客
02-06 9433
在 Java 开发中，使用 Java 语言操作数据库是非常重要的一部分，那么 Java 语言是如何操作数据库的呢？我们需要使用不同厂商的数据库时，例如 MySQL，Oracle 等，显然一套 Java 代码是不能同时操作不同的数据库的，那么怎样实现一套 Java 代码对不同的数据库的操作呢？JDBC 应运而生。
DBUtils中利用QueryRunner实现查询中resultSetHandler结果集处理类
weixin_44289282的博客
01-12 495
1.ArrayHandler 将结果集中的第一条记录封装到一个Object[]数组中，数组中的每一个元素就是这条记录中的每一个字段的值 2.ArrayListHandler 将结果集中的每一条记录都封装到一个Object[]数组中，将这些数组在封装到List集合中。 3.BeanHandler 将结果集中第一条记录封装到一个指定的javaBean中。 4.BeanListHandler 将结果集中...
如何使用JDBC操作数据库？一文带你吃透JDBC规范，2024年最新分享复习经验和后台开发面经
最新发布
2401_84181340的博客
04-18 790
首先 Java 代码将 sql 发送到 MySQL 服务端，MySQL 服务端接收到 sql 语句以后，会对 sql 语句进行检查（检查 sql 语句的语法），编译（编译 sql 语句，将 sql 语句编译成可执行的函数），执行的操作。例如，在程序的登录操作中，用户输入的用户名和密码会被发送到 Java 代码，然后用于 Java 操作数据库的sql 语句中，只有当用户输入的用户名和密码与数据库中的数据匹配时才能实现登录，但是，只要我们输入事先定义好的语句，便可以进行破解。
JDBC总结
qq_53723728的博客
07-20 213
1、数据持久化把数据保存到可掉电式存储设备中以供之后使用，jdbc中通过各种关系型数据库实现2、JDBC概念JDBC为一套接口，使用接口可实现对具体数据库的操作3、驱动针对接口提供具体实现类的集合4、JDBC体系面向应用的api供程序开发人员使用面向数据库的api供开发商开发数据库驱动使用。
JDBC——JDBC操作数据库步骤
shengshanlaolin_的博客
12-27 1285
JDBC
如何使用JDBC操作数据库
weixin_62394768的博客
07-27 5994
连接了数据库，就是要对数据库进行操作。所以要定义SQL语句，其实就是你要对数据库进行什么操作，放在SQL语句中（不完全正确的比喻，SQL语句就是对数据库的操作的容器）。就比如我想要查询user表中的所有数据。...
3.用JDBC操作数据库.zip
07-24
接下来，让我们逐步解析JDBC操作数据库的过程： 1. **建立连接**：使用`DriverManager.getConnection()`方法，传入数据库URL、用户名和密码，建立与数据库的连接。例如： ```java Connection conn = ...
简单的jdbc操作数据库项目
01-03
【简单的jdbc操作数据库项目】是一个基于Java编程语言的实战项目，主要目的是教授如何使用Java Database Connectivity（JDBC）API来与数据库进行交互。这个项目采用了Dao（Data Access Object）模式，这是一种常用的...
java使用jdbc操作数据库示例分享
09-04
主要介绍了java使用jdbc操作数据库示例,需要的朋友可以参考下
使用JDBC操作数据库
08-16
在Java编程领域，JDBC（Java Database Connectivity）是连接Java应用程序和各种数据库的...通过阅读“使用JDBC操作数据库下载资料”，你可以找到更多关于JDBC实战操作的示例和详细教程，进一步提升你的数据库操作技能。
JDBC操作数据库.md
03-23
JDBC操作数据库.md
jdbc操作数据库demon
10-09
jdbc操作数据库demon，包括增删改的封装，查询以集合返回，以jsonArray返回等，相关博文地址：http://blog.csdn.net/sapce_fish/article/details/52764678
jdbc操作数据库的基本流程详解
01-19
所有的JDBC应用程序都具有下面的基本流程：　1、加载数据库驱动并建立到数据库的连接。　2、执行SQL语句。　3、处理结果。　4、从数据库断开连接释放资源。下面我们就来仔细看一看每一个步骤：其实按照上面所说每个...
Java基础开发之JDBC操作数据库增删改查，分页查询实例详解
08-25
Java基础开发之JDBC操作数据库增删改查，分页查询实例详解 Java基础开发之JDBC操作数据库增删改查，分页查询实例详解是Java开发中最基本的操作之一，本文将详细介绍JDBC操作数据库增删改查，分页查询实例详解的知识...
六、JDBC操作数据库
耀耀zz的博客
03-15 782
JDBC( Java DataBase Connectivity )就是使用Java语言操作关系型数据库的一套API。我们开发的同一套Java代码是无法操作不同的关系型数据库，因为每一个关系型数据库的底层实现细节都不一样。如果这样，问题就很大了，在公司中可以在开发阶段使用的是MySQL数据库，而上线时公司最终选用oracle数据库，我们就需要对代码进行大批量修改，这显然并不是我们想看到的。
JDBC操作数据库详解
Zero摄氏度的博客
04-10 2426
十、JDBC 10.1、数据库驱动 驱动：声卡、显卡、数据库 我们的程序会通过数据库驱动，再和数据库连接 10.2、JDBC SUN公司为了简化开发人员的（对数据库的统一）操作，提供了一个java操作数据库的规范，俗称JDBC 这些规范的实现由具体的厂商去做，对于开发人员来说，我们只需要掌握JDBC接口的操作即可 jdbc需要的jar包 <!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java 数据库驱动包
jdbc实现数据库基本操作（增，删，改，查）
qq_75222206的博客
07-10 3097
【代码】jdbc实现数据库基本操作（增，删，改，查）
Jdbc操作数据库步骤
05-10
JDBC操作数据库的步骤如下： 1. 加载数据库驱动程序：首先需要加载特定数据库的驱动程序，例如MySQL、Oracle等。可以使用Class.forName()方法加载驱动程序。 2. 建立数据库连接：使用DriverManager.getConnection...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

dotJunz

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值