JDBC的简单使用

最新推荐文章于 2022-10-25 20:21:33 发布
最新推荐文章于 2022-10-25 20:21:33 发布
阅读量152 收藏
点赞数
文章标签： java jdbc
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/rmy_20/article/details/106794564
版权

1、导入jar包

没有使用连接池的情况下，只需要导入对应数据库版本的mysql-connector包即可。
对应数据库5.7

2、jdbc的使用步骤及对应的接口

  1. 加载驱动：
    java.sql.Driver
  2. 获取数据库连接：
    java.sql.Connection
  3. 获取操作数据库的对象：
    java.sql.Statement – 静态处理块 java.sql.PreparedStatement – 预处理块
  4. 执行sql语句
    select语句：java.sql.ResultSet – 结果集
    java.sql.ResultSetMetaData – 结果集元数据
  5. 关闭连接

3、jdbc的相关使用

1、 对于数据库的相关操作

public void test() {
        /*
            提供服务器的相关信息
         */
        String driverClassName = "com.mysql.jdbc.Driver";
        String url = "jdbc:mysql://localhost:3306/jdbc_test";
        String username = "root";
        String password = "root";
        Connection connection = null;
        Statement statement = null;
        DatabaseMetaData metaData = null;
        ResultSet resultSet = null;
        try {
            // 1、加载驱动
            Class.forName(driverClassName);
            // 2、获取数据库连接
            connection = DriverManager.getConnection(url, username, password);
            // 3、获取statement对象
            statement = connection.createStatement();
            // 4、获取数据库的基本信息（元数据）
            metaData = connection.getMetaData();
            System.out.println(metaData);
            // 获取数据库的名字
            System.out.println(metaData.getDatabaseProductName());
            // 获取数据库的版本
            System.out.println(metaData.getDatabaseProductVersion());
            // 获取数据库中的表
            resultSet = metaData.getTables(null, "root", null, new String[]{"TABLE"});
            // ResultSet中的 next() 用于判断数据集是否有下一条数据，如果有，可以通过 resultSet.getXXX(字段名|索引)获取该行字段的值
            while (resultSet.next()) {
                // 通过行字段的名称获取数据
                System.out.println("通过行字段的名称获取：" + resultSet.getString("TABLE_Name"));
                // 通过行字段的索引来获取数据，索引从 1 开始（数据库从 1 开始）
                System.out.println(resultSet.getString(3));
            }
            // 获取数据库中特定表的列信息
            ResultSet columns = metaData.getColumns(null, "root", "s_student", null);
            while (columns.next()) {
                // 当前字段的名称
                System.out.print(columns.getString("COLUMN_NAME") + " -> ");
                // 当前字段的类型
                System.out.print(columns.getString("TYPE_NAME") + ":");
                // 当前字段的长度
                System.out.println(columns.getString("COLUMN_SIZE"));
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // 关闭连接
            if (resultSet != null) {
                try {
                    resultSet.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
            if (statement != null) {
                try {
                    statement.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
            if (connection != null) {
                try {
                    connection.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
        }
    }

2.select 查询

public void test() {
        String driverClassName = "com.mysql.jdbc.Driver";
        String url = "jdbc:mysql://localhost:3306/jdbc_test";
        String username = "root";
        String password = "root";
        Connection connection = null;
        Statement statement = null;
        try {
            // 1、加载驱动
            Class.forName(driverClassName);
            // 2、获取数据库连接
            connection = DriverManager.getConnection(url, username, password);
            String sql = "select * from s_student";
            // 3、获取statement对象
            statement = connection.createStatement();
            // 4、执行 SQL 语句
            ResultSet resultSet = statement.executeQuery(sql);
            while (resultSet.next()) {
                System.out.println(resultSet.getInt("id") + "_" + resultSet.getString("name") + "_" + resultSet.getInt("c_id"));
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // 关闭数据库连接
            if (statement != null) {
                try {
                    statement.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
            if (connection != null) {
                try {
                    connection.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
        }
    }

4、DbUtil的封装

因为重复代码的原因，因此先进行封装。
1、db.properties文件

driverClassName=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/jdbc_test?characterEncoding=utf8&useSSL=false&serverTimezone=Asia/Shanghai
username=root
password=root
# 初始化的时候，连接池中放多少个连接
initialSize=10
# 最大存活的连接数量
maxActive=50
# 最小空闲数量
minIdle=5
# 配置获取连接等待超时的时间
maxWait=20000
# 验证连接池中的连接是否有效的sql语句
validationQuery='select 1'
# 在获取连接的时候，验证拿到的连接是否是有效连接
testOnBorrow=false
# 在归还连接的时候，验证是否为有效连接
test-on-return=false
# 空闲的时候验证是否有效
test-while-idle=true

2、 没有用连接池

public class DbUtil {
    private static String className = null;
    private static String url = null;
    private static String username = null;
    private static String password = null;

    // 给静态成员变量赋值
    static {
         InputStream is = null;
         try {
        	// 读取文件
        	is = DbUtil.class.getClassLoader().getResourceAsStream("db.properties");
        	Properties properties = new Properties();
        	// 读取文件
            properties.load(is);
            className = properties.getProperty("driverClassName");
            url = properties.getProperty("url");
            username = properties.getProperty("username");
            password = properties.getProperty("password");
            // 加载驱动
            Class.forName(className);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
        	// 关流
            if (is != null) {
                try {
                    is.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    /**
     * @return 数据库连接
     */
    public static Connection getConnection() {
        try {
            return DriverManager.getConnection(url, username, password);
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 通用的设置 sql 参数的方法
     *
     * @param preparedStatement PreparedStatement 对象
     * @param params            sql 要注入的参数
     */
    public static void setParams(PreparedStatement preparedStatement, Object... params) {
        if (preparedStatement != null) {
            if (params != null) {
                for (int i = 0; i < params.length; i++) {
                    try {
                        preparedStatement.setObject(i + 1, params[i]);
                    } catch (SQLException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }

    /**
     * /**
     * 通用的关闭连接的方法，因为 Connection、Statement、PreparedStatement、ResultSet
     * 都间接或直接的与AutoCloseable有继承或实现关系
     *
     * @param closeables 连接
     */
     *
     * @param closeables 连接
     */
    public static void close(AutoCloseable... closeables) {
        // 非空判断
        if (closeables != null) {
            for (AutoCloseable closeable : closeables) {
                if (closeable != null) {
                    try {
                        closeable.close();
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }
}

3、使用Druid连接池
在这里插入图片描述

/**
 * 工具类，提供数据库连接，关闭数据库连接，设置 sql 语句的对象
 */
public class DbUtil {
    // 数据源
    private static DataSource dataSource = null;

    static {
        // 自动关流，获取资源文件
        try (InputStream resourceAsStream = DbUtil.class.getClassLoader().getResourceAsStream("db.properties")) {
            Properties properties = new Properties();
            properties.load(resourceAsStream);
            // 使用druid数据源工厂创建数据源
            dataSource = DruidDataSourceFactory.createDataSource(properties);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * @return 连接
     */
    public static Connection getConnection() {
        try {
            return dataSource.getConnection();
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 通用的设置 sql 参数的方法
     *
     * @param preparedStatement PreparedStatement 对象
     * @param params            sql 要注入的参数
     */
    public static void setParams(PreparedStatement preparedStatement, Object... params) {
        if (preparedStatement != null) {
            if (params != null) {
                for (int i = 0; i < params.length; i++) {
                    try {
                        preparedStatement.setObject(i + 1, params[i]);
                    } catch (SQLException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }

    /**
     * 通用的关闭连接的方法
     *
     * @param closeables 连接
     */
    public static void close(AutoCloseable... closeables) {
        // 非空判断，避免空指针异常
        if (closeables != null) {
            for (AutoCloseable closeable : closeables) {
                if (closeable != null) {
                    try {
                        closeable.close();
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }
}

5、jdbc的使用

1、insert

public void test() {
        Connection connection = DbUtil.getConnection();
        Statement statement = null;
        try {
            String sql = "insert into s_student(name, c_id) values('你好', 1)";
            statement = connection.createStatement();
            // 执行sql
            int rows = statement.executeUpdate(sql);
            System.out.println(rows);
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
        	// 关闭连接
            DbUtil.close(statement, connection);
        }
    }

2、update

public void test() {
        Connection connection = DbUtil.getConnection();
        String sql = "update s_student set name = 'hello' where id = 2";
        Statement statement = null;
        try {
            statement = connection.createStatement();
            int rows = statement.executeUpdate(sql);
            System.out.println(rows);
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            DbUtil.close(statement, connection);
        }
    }

3、delete

public void test() {
        Connection connection = DbUtil.getConnection();
        Statement statement = null;
        String sql = "delete from s_student where id = 3";
        try {
            // Connection 默认获取的连接是自动提交事务的，可以通过 setAutoCommit() 修改事务提交类型
            connection.setAutoCommit(false);
            System.out.println(connection.getAutoCommit());
            statement = connection.createStatement();
            int rows = statement.executeUpdate(sql);
            System.out.println(rows);
            // 手动提交事务
            connection.commit();
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            // 如果没有显式提交事务，关闭连接时，会自动提交未提交的事务
            DbUtil.close(statement, connection);
        }
    }

4、delete

public void test() {
        Connection connection = DbUtil.getConnection();
        Statement statement = null;
        String sql = "delete from s_student where id = 1";
        try {
            // Connection 默认获取的连接是自动提交事务的，可以通过 setAutoCommit() 修改事务提交类型
            connection.setAutoCommit(false);
            System.out.println(connection.getAutoCommit());
            statement = connection.createStatement();
            int rows = statement.executeUpdate(sql);
            System.out.println(rows);
//            System.out.println(1 / 0);
            // 手动提交事务
            connection.commit();
        } catch (SQLException e) {
//            e.printStackTrace();
            // 回滚事务
            try {
                connection.rollback();
            } catch (SQLException ex) {
                ex.printStackTrace();
            }
        } finally {
            // 如果没有显式提交事务，关闭连接时，会自动提交未提交的事务
            DbUtil.close(statement, connection);
        }
    }

6、预处理 PreparedStatement

1、栗子1

public void test() {
        Connection connection = null;
        String sql = "select * from s_student where id = ?";
        PreparedStatement preparedStatement = null;
        ResultSet resultSet = null;
        try {
            connection = DbUtil.getConnection();
            preparedStatement = connection.prepareStatement(sql);
            preparedStatement.setInt(1, 1);
            resultSet = preparedStatement.executeQuery();
            while (resultSet.next()) {
                System.out.println(resultSet.getInt("id") + " | " + resultSet.getString("name"));
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            DbUtil.close(resultSet, preparedStatement, connection);
        }
    }

2、

public void test() {
        Connection connection = null;
        PreparedStatement preparedStatement = null;
        String sql = "insert into s_student(name, c_id) values (?, ?)";
        try {
            connection = DbUtil.getConnection();
            connection.setAutoCommit(false);
            preparedStatement = connection.prepareStatement(sql);
            // 设置参数
            DbUtil.setParam(preparedStatement, "沐颜", 1);
            int rows = preparedStatement.executeUpdate();
            // 提交事务
            connection.commit();
            System.out.println(rows);
        } catch (Exception e) {
//            e.printStackTrace();
            try {
                // 回滚事务
                connection.rollback();
            } catch (SQLException ex) {
                ex.printStackTrace();
            }
        } finally {
            // 关闭连接
            DbUtil.close(preparedStatement, connection);
        }
    }

7、批处理

添加到批处理中的方法：addBatch();
执行sql的方法：executeBatch();

/**
 * 测试批处理
 */
public class Test {
    public static void main(String[] args) {
        long start = System.currentTimeMillis();
//        for (int i = 0; i < 100; i++) {
//            add01();
//        }
        add02();
        long end = System.currentTimeMillis();
        System.out.println(end - start);
    }

	// 测试批处理的方法
    private static void add02() {
        Connection connection = DbUtil.getConnection();
        PreparedStatement preparedStatement = null;
        String sql = "insert into s_student(name, c_id) values (?, ?)";
        try {
            connection.setAutoCommit(false);
            for (int i = 0; i < 100; i++) {
                preparedStatement = connection.prepareStatement(sql);
                // 设置参数
                DbHelper.setParam(preparedStatement, "沐颜", 1);
                // 添加到批处理中
                preparedStatement.addBatch();
            }
            int[] rows = preparedStatement.executeBatch();
            // 提交事务
            connection.commit();
        } catch (Exception e) {
            try {
                // 回滚事务
                connection.rollback();
            } catch (SQLException ex) {
                ex.printStackTrace();
            }
        } finally {
            // 关闭连接
            DbUtil.close(preparedStatement, connection);
        }
    }
	
    private static void add01() {
        Connection connection = DbUtil.getConnection();
        PreparedStatement preparedStatement = null;
        String sql = "insert into s_student(name, c_id) values (?, ?)";
        try {
            connection.setAutoCommit(false);
            preparedStatement = connection.prepareStatement(sql);
            // 设置参数
            DbUtil.setParam(preparedStatement, "沐颜", 1);
            int rows = preparedStatement.executeUpdate();
            // 提交事务
            connection.commit();
        } catch (Exception e) {
            try {
                // 回滚事务
                connection.rollback();
            } catch (SQLException ex) {
                ex.printStackTrace();
            }
        } finally {
            // 关闭连接
            DbUtil.close(preparedStatement, connection);
        }
    }
}
一妍为定
关注
超通俗易懂的JDBC之入门使用步骤+解析
javaKingofFuture的博客
04-16 683
JDBC之入门使用步骤 解析 第一步：导入jar包（没有jdbc的jar是无法使用jdbc的） 第二步：注册驱动(可省略) Class.forName("com.mysql.jdbc.Drive") 第三步:使用DriverManager 类的getConnection() 方法获取Connection 数据库连接对象 COnnection conn = DriverManager.getCon...
JDBC——用JDBC连接MySQL数据库并进行简单的增删改查操作
热门推荐
记录只为更好地前行
06-24 4万+
一、什么是JDBC Java 数据库连接，（Java Database Connectivity，简称JDBC）是Java语言中用来规范客户端程序如何来访问数据库的应用程序接口，提供了诸如查询和更新数据库中数据的方法。（摘自维基百科） 二、简单的JDBC实例 现在使用JDBC写一个简单的小程序，主要是使用JDBC连接MySQL数据库，然后对数据库进行一些基本的增删改查操作。 1、设计数
JDBC最简单的使用
最新发布
qq_55931044的博客
10-25 884
JDBC概述JDBC搭建PreparedStatement 和Statement结果处理
JDBC 的简单使用
W31003的博客
01-25 1101
JDBC是Java语言中用来规范客户端程序如何来访问数据库的应用程序接口，提供了诸如更新数据库中数据的方法。 本文开始之前先准备一个数据 test，新建一个 student 表并插入数据 CREATE TABLE `student` ( `id` int(5) NOT NULL AUTO_INCREMENT, `name` varchar(20) NOT NULL, `course` varchar(10) NOT NULL, `grade` int(11) NOT NULL, PRIM
jdbc的简单使用
weixin_43231756的博客
08-21 138
3.在主函数中进行增、删、改、查。2.创建表格所对应的类。
Android JDBC简单使用
Cricket_7的博客
11-05 1714
一，JDBC 简介 JDBC:java database connectivity java数据库连接 常用的数据库mysql oracle sqlserver sun公司提供了一套jdbc的接口，让数据库厂商实现。   二，JDBC使用： 1，JDBC简单使用     步骤：        1），导入jar包    public class JDBCTest {    ...
Spring JDBC的使用方法详解
08-25
Spring JDBC的使用方法详解 Spring JDBC是Spring框架中的一部分，提供了对数据库的访问和操作。它提供了一个简单、灵活、可扩展的方式来访问数据库。下面将详细介绍Spring JDBC的使用方法详解。 为什么使用Spring...
Java使用Jdbc连接Oracle执行简单查询操作示例
08-25
Java使用Jdbc连接Oracle执行简单查询操作示例 Java使用Jdbc连接Oracle执行简单查询操作，是指使用Java语言通过Jdbc（Java Database Connectivity）连接Oracle数据库并执行简单查询操作的过程。本文将通过实例形式...
在Spring中使用JDBC和JDBC模板的讲解
08-26
以下是一个简单的使用示例： ```java public class UserDao { @Autowired private JdbcTemplate jdbcTemplate; public List<User> queryUsers() { return jdbcTemplate.queryForList("SELECT * FROM users"); ...
jdbc:使用旧的Java东西的简单项目
05-24
这个“jdbc:使用旧的Java东西的简单项目”可能是一个教学或者实践项目，目标是通过使用传统的Java技术来演示如何操作数据库。在Java领域，JDBC是连接数据库的标准方式，它允许开发人员执行SQL语句、处理结果集以及...
JDBC简单使用
开心星人的博客
03-01 606
视频学习链接，我是跟着黑马程序员学的 JDBC概述： JDBC(Java DataBase Connectivity)就是使用java语言操作关系数据库的一套API 本质： 同一套java代码，操作不同的关系数据库（不同关系数据库的底层实现是有差别的） Sun公司定义了一套标准接口（JDBC），实现类由各个数据库厂商自行定义对于JDBC的实现类（驱动），提供数据库驱动jar包 我们使用JDBC编程，真正执行的代码是驱动jar包中的实现类 好处： 可随时替换底层数据库，访问数据库的java代码基本不变 简.
[学习笔记] JDBC的简单使用_04
FE_Fighter的博客
07-22 278
数据库连接池 之前存在的问题 其实之前的代码没有任何问题, 用来操作数据库足够了 但获取连接对象(driverManager.getConnection(String driverClassName, String url, String password);)这一步是很消耗资源的. 每次用的时候创建连接对象, 用完就关闭, 下一次需要使用时在创建, 这样非常消耗性能 设计这样一种方案, 我们每次...
JDBC总结系列：简单使用
youxia007ya的技术社区
07-03 359
JDBC（Java DataBase Connectivity,java数据库连接）是一种用于执行SQL语句的Java API，可以为多种关系数据库提供统一访问，它由一组用Java语言编写的类和接口组成。JDBC提供了一种基准，据此可以构建更高级的工具和接口，使数据库开发人员能够编写数据库应用程序，同时，JDBC也是个商标名。（取自：百度百科）简单地说就是为了统一化各个数据库操作而做的统一化接口。...
JDBC简单入门
weixin_55715292的博客
04-18 891
在工作中，程序员可能会需要用到很多数据库，若没有相应的工具，程序员每用到一个数据库就需要掌握一条与之对应的方法调用，当换数据库时，代码也需要做相应改动，这样极其不利于开发，效率很低，这时JDBC接口就应运而生。 JDBC(java Database Connectivity) java数据库连接，实际上JDBC是sun公司提供一套连接数据库的API sun公司提供JDBC接口，让各个数据库厂商根据此接口写实现类（驱动），这样java程序员只需要掌握JDBC接口中的方法的调用，就可以访问任何数据，而且换数据库
jdbc基础操作，简单易学上手快
weixin_59755109的博客
04-08 1029
一.jdbc简介 jdbc(java database connectivity): java数据库连接技术；java应用操作数据库技术的简称。 二.工作原理分析 jdbc api: java厂商(sun公司定义)规定数据库驱动的标准(接口)，数据库厂商(mysql,oracle,sqlserver)提供驱动的具体实现（数据库jar包）。 DriverManager:驱动管理类 jdbc驱动: mysql驱动,sqlserver驱动,oracle驱动。连接不同的数据库使用不同的驱动包(jar)
JDBC基本使用方式
shanfengshuiqing的博客
07-15 504
目录1.JDBC数据库驱动封装2.用户数据封装3.数据库的增删改查（部分关键代码） 1.JDBC数据库驱动封装 JDBC数据库使用的七个基本步骤： 获取驱动 创建连接 编写sql 获取prepareStatement 执行sql语句，并返回结果 处理结果集 关闭资源 下面是实现上述步骤的主要代码： private static String driver="com.mysql.jdbc.Dr.........
Java JDBC使用详解与JDBCUtils工具类
"这篇教程主要探讨了JDBC的使用方法，包括基本的使用步骤和如何构建JDBCUtils工具类，以提高代码的复用性和数据库操作的便捷性。" JDBC（Java Database Connectivity）是Java语言中用来规范客户端程序如何访问...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值