search

博客列表 >Java使用JDBC连接数据库的详细步骤

Java使用JDBC连接数据库的详细步骤

全
全原创
2022年01月04日 17:04:06600浏览

目录
一、JDBC是什么？
二、使用步骤
1.注册驱动
2.获取连接
3.获取数据库操作对象
4.执行sql语句
5.处理查询结果集
6.释放资源
上述六步连贯：
第一次优化：（比较两种注册驱动的方法）
第二次优化：（比较两种注册驱动的方法）
第三次优化：（最佳注册驱动获取连接）
第四次优化：（使用资源绑定器）
第五次优化：（对操作结果集的处理）
总结：

一、JDBC是什么？
JDBC 指 Java 数据库连接（Java Database Connectivity），是一种标准Java应用编程接口（ JAVA API），JDBC就是一套sun公司定义的接口，JDBC本质上就是Sun公司制定的一套接口（interface)！每个数据库厂商需要实现这套接口。我们只需要调用需要即可用来连接 Java 编程语言和广泛的数据库。

JDBC API 库包含下面提到的每个任务，都是与数据库相关的常用用法。

制作到数据库的连接。
创建 SQL 或 MySQL 语句。
执行 SQL 或 MySQL 查询数据库。
查看和修改所产生的记录。
从根本上来说，JDBC 是一种规范，它提供了一套完整的接口，允许便携式访问到底层数据库，因此可以用 Java 编写不同类型的可执行文件，例如：

Java 应用程序
Java Applets
Java Servlets
Java ServerPages (JSPs)
Enterprise JavaBeans (EJBs)
所有这些不同的可执行文件就可以使用 JDBC 驱动程序来访问数据库，这样可以方便的访问数据。

JDBC 具有 ODBC 一样的性能，允许 Java 程序包含与数据库无关的代码。

二、使用步骤

1.注册驱动
数据库厂商的Java程序员所写的实现类 叫做驱动 Driver

注册驱动

第一种注册方法代码如下：（不常用）
`public class 注册驱动 {
public static void main(String[] args) {
try {
DriverManager.registerDriver(new com.mysql.jdbc.Driver());
} catch (SQLException throwables) {
throwables.printStackTrace();
}
}

}`
第二种方利用反射的特性，加载过程中注册驱动的过程。

关于反射的补充： Java中的灵魂-反射机制

关于JDBC—MySQL中以类加载的方式注册驱动（反射）详解链接：

JDBC—MySQL以类加载的方式注册驱动（反射）
class.forName(com.mysql.jdbc.Driver);
上述一行代码就可以通过反射这个动作调用类，实现Driver类的加载 但是需要使用try和catch语句块环绕

2.获取连接
要连接数据库的url—— String url=”jdbc:mysql://localhost:3306/test?”+ “useUnicode=true&characterEncoding=UTF8”;//防止乱码
要连接数据库的用户名—— String user=”xxxx”;
要连接数据库的密码—— String pass=”xxxx”;

接下来我们分析下url：
“jdbc(这是协议以jdbc开头):mysql(这是子协议，数据库管理系统称)://localhost(数据库来源地址):3306(目标端口)/test(要查询的表的表名)?”
“useUnicode=true&characterEncoding=UTF8”;添加这个是为了防止乱码，指定使用Unicode字符集 ，且使用UTF-8来编辑。
`/*
url包括哪几部分:
协议
IP
Port
资源名

  1. eg：http://180.101.49.11:80/index.html
  2.     http:// 通信协议
  3.     180.101.49.11 IP地址
  4.     80 端口号
  5.     index.html 资源名

/ // 2、获取连接
/
url包括哪几部分:
协议
IP
Port
资源名
eg：http://180.101.49.11:80/index.html
http:// 通信协议
180.101.49.11 IP地址
80 端口号
index.html 资源名
*/
// static Connection getConnection(String url, String user, String password)
String url = “jdbc:mysql://127.0.0.1:3306/hello”;
String user = “root”;
System.out.println(“ “);
String password = “rota”;
conn = DriverManager.getConnection(url,user,password);
System.out.println(“数据库连接对象 ： “ + conn); //数据库连接对象com.mysql.jdbc.JDBC4Connection@1ae369b7
3.获取数据库操作对象// 3、获取数据库操作对象
// Statement 类中 createStatement() 创建一个 Statement 对象来将 SQL 语句发送到数据库。
stmt = conn.createStatement();

// 4、执行sql语句
// int executeUpdate(String sql)
// 专门执行DML语句
// 返回值是“影响数据库中的记录条数”
int count = stmt.executeUpdate(“update dept set dname = ‘销售部’,loc = ‘合肥’ where deptno = 20;”);
System.out.println(count == 1 ? “保存成功”:”保存失败”);4.执行sql语句// 4、执行sql语句
// int executeUpdate(String sql)
// 专门执行DML语句
// 返回值是“影响数据库中的记录条数”
int count = stmt.executeUpdate(“update dept set dname = ‘销售部’,loc = ‘合肥’ where deptno = 20;”);
System.out.println(count == 1 ? “保存成功”:”保存失败”);5.处理查询结果集rs = stmt.executeQuery(“select empno,ename,sal from emp”);

  1.         while(rs.next()){
  2.             /*
  3.             String empno = rs.getString(1);
  4.             String ename = rs.getString(2);
  5.             String sal = rs.getString(3);
  6.             System.out.println(empno + "," + ename + "," + sal);
  7.             */
  9.             /*
  10.             // 按下标取出，程序不健壮
  11.             String empno = rs.getString("empno");
  12.             String ename = rs.getString("ename");
  13.             String sal = rs.getString("sal");
  14.             System.out.println(empno + "," + ename + "," + sal);
  15.             */
  17.             /*
  18.             // 以指定的格式取出
  19.             int empno = rs.getInt(1);
  20.             String ename = rs.getString(2);
  21.             double sal = rs.getDouble(3);
  22.             System.out.println(empno + "," + ename + "," + (sal + 100));
  23.             */
  25.             int empno = rs.getInt("empno");
  26.             String ename = rs.getString("ename");
  27.             double sal = rs.getDouble("sal");
  28.             System.out.println(empno + "," + ename + "," + (sal + 200));
  29.         }`

其中执行增删改的方法返回值是int类型

执行查询的方法返回值是操作结果集对象，即使ResultSet的实例化对象！

6.释放资源
finally { // 6、释放资源 // 从小到大依次关闭 //finally语句块内的语句一定会执行！ if(stmt != null) { try { stmt.close(); } catch (SQLException e) { e.printStackTrace(); } } if(conn != null) { try { conn.close(); } catch (SQLException e) { e.printStackTrace(); } } } }
上述六步连贯：

第一次优化：（比较两种注册驱动的方法）
`import java.sql.*;

public class JDBCTest01 {
public static void main(String[] args) {
Connection conn = null;
Statement stmt = null;//先创建连接对象 和 操作对象 并且引用为空，是为了对象变量的生命周期不仅仅局限于try语句块内，而是在整个main方法内，方便后续finally语句块内释放资源
try{
// 1、注册驱动
Driver driver = new com.mysql.jdbc.Driver(); //多态，父类型引用指向子类型对象
DriverManager.registerDriver(driver);

  1.         // 2、获取连接
  2.         /*
  3.             url包括哪几部分:
  4.                 协议
  5.                 IP
  6.                 Port
  7.                 资源名
  8.             eg：http://180.101.49.11:80/index.html
  9.                 http:// 通信协议
  10.                 180.101.49.11 IP地址
  11.                 80 端口号
  12.                 index.html 资源名
  13.         */
  14.         // static Connection getConnection(String url, String user, String password)
  15.         String url = "jdbc:mysql://127.0.0.1:3306/hello";
  16.         String user = "root";
  17.         System.out.println(" ");
  18.         String password = "rota";
  19.         conn = DriverManager.getConnection(url,user,password);
  20.         System.out.println("数据库连接对象 ：     " + conn);    //数据库连接对象com.mysql.jdbc.JDBC4Connection@1ae369b7
  22.         // 3、获取数据库操作对象
  23.         // Statement 类中 createStatement() 创建一个 Statement 对象来将 SQL 语句发送到数据库。
  24.         stmt = conn.createStatement();
  26.         // 4、执行sql语句
  27.         // int executeUpdate(String sql)
  28.         // 专门执行DML语句
  29.         // 返回值是“影响数据库中的记录条数”
  30.         int count = stmt.executeUpdate("update dept set dname = '销售部',loc = '合肥' where deptno = 20;");
  31.         System.out.println(count == 1 ? "保存成功":"保存失败");
  33.         // 5、处理查询结果集
  35.     } catch(SQLException e) {
  36.         e.printStackTrace();
  37.     } finally {
  38.         // 6、释放资源
  39.         // 从小到大依次关闭
  40.         //finally语句块内的语句一定会执行！
  41.         if(stmt != null) {
  42.             try {
  43.                 stmt.close();
  44.             }
  45.             catch (SQLException e) {
  46.                 e.printStackTrace();
  47.             }
  48.         }
  49.         if(conn != null) {
  50.             try {
  51.                 conn.close();
  52.             }
  53.             catch (SQLException e) {
  54.                 e.printStackTrace();
  55.             }
  56.         }
  57.     }
  58. }

}第二次优化：（比较两种注册驱动的方法）package com.zdx.source.code.jdbc;

/
JDBC完成Delete /
import java.sql.*;

public class JDBCTest02 {
public static void main(String[] args) {
// 1、注册驱动
// 2、获取连接
// 3、获取数据库操作对象
// 4、执行sql语句
// 5、获取查询结果集
// 6、释放资源

  1.     Connection conn = null;
  2.     Statement stmt = null;
  3.     try {
  4.         Driver driver = new com.mysql.jdbc.Driver();
  5.         DriverManager.registerDriver(driver);
  7.         String url = "jdbc:mysql://127.0.0.1:3306/mydatabase";
  8.         String user = "root";
  9.         String password = "146";
  10.         conn = DriverManager.getConnection(url,user,password);
  12.         stmt = conn.createStatement();
  14.         int count = stmt.executeUpdate("delete from dept where deptno = 50");
  16.         System.out.println(count == 1? "删除成功":"删除失败");
  18.     } catch(SQLException e){
  19.         e.printStackTrace();
  20.     } finally {
  21.         if(conn != null) {
  22.             try {
  23.                 conn.close();
  24.             } catch(SQLException e){
  25.                 e.printStackTrace();
  26.             }
  27.         }
  28.         if(stmt != null) {
  29.             try {
  30.                 stmt.close();
  31.             } catch(SQLException e){
  32.                 e.printStackTrace();
  33.             }
  34.         }
  35.     }
  36. }

}第三次优化：（最佳注册驱动获取连接）package com.zdx.source.code.jdbc;

/
注册驱动的另一种方式 /

import java.sql.*;

public class JDBCTest03 {
public static void main(String[] args) {
try{
// 注册驱动
Class.forName(“com.mysql.jdbc.Driver”);

  1.         // 获取连接
  2.         Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/mydatabase","root","146");
  3.         System.out.println(conn);
  5.     } catch(SQLException e){
  6.         e.printStackTrace();
  7.     } catch(ClassNotFoundException e){
  8.         e.printStackTrace();
  9.     }
  10. }

}第四次优化：（使用资源绑定器）package com.zdx.source.code.jdbc;

/
使用资源绑定器 /

import java.sql.;
import java.util.;

public class JDBCTest04 {
public static void main(String[] args) {

  1.     ResourceBundle bundle = ResourceBundle.getBundle("jdbc");
  2.     String driver = bundle.getString("driver");
  3.     String url = bundle.getString("url");
  4.     String user = bundle.getString("user");
  5.     String password = bundle.getString("password");
  7.     Connection conn = null;
  8.     Statement stmt = null;
  9.     try {
  10.         Class.forName(driver);
  12.         conn = DriverManager.getConnection(url,user,password);
  14.         stmt = conn.createStatement();
  16.         int count = stmt.executeUpdate("insert into dept(deptno,dname,loc) values(50,'人事部','北京');");
  18.         System.out.println(count == 1? "保存成功":"保存失败");
  20.     } catch(SQLException e){
  21.         e.printStackTrace();
  22.     } catch(ClassNotFoundException e) {
  23.         e.printStackTrace();
  24.     } finally {
  25.         if(conn != null) {
  26.             try {
  27.                 conn.close();
  28.             } catch(SQLException e){
  29.                 e.printStackTrace();
  30.             }
  31.         }
  32.         if(stmt != null) {
  33.             try {
  34.                 stmt.close();
  35.             } catch(SQLException e){
  36.                 e.printStackTrace();
  37.             }
  38.         }
  39.     }
  40. }

}第五次优化：（对操作结果集的处理）package com.zdx.source.code.jdbc;

/
执行DQL语句 /

import java.sql.;
import java.util.;

public class JDBCTest05 {
public static void main(String[] args) {
// 1、注册驱动
// 2、建立连接
// 3、获取数据库操作对象
// 4、执行sql语句
// 5、获取查询结果集
// 6、释放资源
Connection conn = null;
Statement stmt = null;
ResultSet rs = null;

  1.     try{
  2.         ResourceBundle rb = ResourceBundle.getBundle("jdbc");
  3.         String driver = rb.getString("driver");
  4.         String url = rb.getString("url");
  5.         String user = rb.getString("user");
  6.         String password = rb.getString("password");
  8.         Class.forName(driver);
  10.         conn = DriverManager.getConnection(url,user,password);
  12.         stmt = conn.createStatement();
  14.         rs = stmt.executeQuery("select empno,ename,sal from emp");
  16.         while(rs.next()){
  17.             /*
  18.             String empno = rs.getString(1);
  19.             String ename = rs.getString(2);
  20.             String sal = rs.getString(3);
  21.             System.out.println(empno + "," + ename + "," + sal);
  22.             */
  24.             /*
  25.             // 按下标取出，程序不健壮
  26.             String empno = rs.getString("empno");
  27.             String ename = rs.getString("ename");
  28.             String sal = rs.getString("sal");
  29.             System.out.println(empno + "," + ename + "," + sal);
  30.             */
  32.             /*
  33.             // 以指定的格式取出
  34.             int empno = rs.getInt(1);
  35.             String ename = rs.getString(2);
  36.             double sal = rs.getDouble(3);
  37.             System.out.println(empno + "," + ename + "," + (sal + 100));
  38.             */
  40.             int empno = rs.getInt("empno");
  41.             String ename = rs.getString("ename");
  42.             double sal = rs.getDouble("sal");
  43.             System.out.println(empno + "," + ename + "," + (sal + 200));
  44.         }
  46.     } catch(Exception e){
  47.         e.printStackTrace();
  48.     }finally{
  49.         if(rs != null){
  50.             try{
  51.                 rs.close();
  52.             } catch (Exception e){
  53.                 e.printStackTrace();
  54.             }
  55.         }
  56.         if(stmt != null){
  57.             try{
  58.                 stmt.close();
  59.             } catch (Exception e){
  60.                 e.printStackTrace();
  61.             }
  62.         }
  63.         if(conn != null){
  64.             try{
  65.                 conn.close();
  66.             } catch (Exception e){
  67.                 e.printStackTrace();
  68.             }
  69.         }
  70.     }
  71. }

}总结： 在上述五次优化代码的过程中，针对这六步// 1、注册驱动
// 2、获取连接
// 3、获取数据库操作对象
// 4、执行sql语句
// 5、获取查询结果集
// 6、释放资源`
第一步的注册驱动最终使用了反射，已达最优

第二步的获取连接已达最优，已经有能力去完成JDBC连接数据库的工具类的封装了

看到这里可以移步去学习—————>工具类的封装啦！

注：

第三步的获取数据库操作对象中我们是使用Statement接口
public interface Statement extends Wrapper, AutoCloseable
还可以优化成为PreparedStatement
public interface PreparedStatement extends Statement
在实际开发过程中由于PreparedStatement能防止注入，且预先编译SQL语句的特性使得程序健壮性提高，所以实际开发中99.9％使用PreparedStatement。这是后话，由于封装工具类主要封装的是注册驱动，获取连接和释放资源，后续将专门写一篇博客讨论PreparedStatement

此外在实际开发中除了掌握上述六步还需要掌握事务提交回滚三部曲。

上一条：Rem+vw布局及Grid属性和应用下一条：rem+vw布局的原理与rem的设置技巧
声明：本文内容转载自脚本之家，由网友自发贡献，版权归原作者所有，如您发现涉嫌抄袭侵权，请联系admin@php.cn 核实处理。
全部评论
文明上网理性发言，请遵守新闻评论服务协议