数据库连接神器：JDBC的基本概述、组成及工作原理全解析！

云端源想
更新于 2023-12-22 11:16
阅读 1667

JDBC（JavaDataBaseConnectivity）是一种用于执行SQL语句的JavaAPI，是Java和数据库之间的一个桥梁，是一个规范而不是一个实现，能够交给数据库执行SQL语句。在信息化时代，数据库已经成为了存储和管理数据的重要工具。而Java作为一种广泛使用的编程语言，

> JDBC（Java DataBase Connectivity）是一种用于执行SQL语句的 Java API，是Java和数据库之间的一个桥梁，是一个规范而不是一个实现，能够交给数据库执行SQL语句。

在信息化时代，数据库已经成为了存储和管理数据的重要工具。而Java作为一种广泛使用的编程语言，其与数据库的交互就显得尤为重要。JDBC就是为了解决这个问题而生的。通过JDBC，我们可以在Java程序中轻松地执行SQL语句，实现对数据库的增删改查操作。今天我们就来聊一聊JDBC的相关概念。

## 一、JDBC简介

**概念：**

JDBC(Java DataBase Connectivity) ：Java数据库连接技术。\
具体讲就是通过Java连接广泛的数据库，并对表中数据执行增、删、改、查等操作的技术。如图所示：

![Description](https://ydcqoss.ydcode.cn/ydyx/bbs/1703045854-iPHvql.png)

本质上，JDBC的作用和图形化客户端的作用相同，都是发送SQL操作数据库。差别在图形化界面的操作是图形化、傻瓜化的，而JDBC则需要通过编码（这时候不要思考JDBC代码怎么写，也不要觉得它有多难）完成图形操作时的效果。

也就是说，JDBC本质上也是一种发送SQL操作数据库的client技术，只不过需要通过Java编码完成。

**作用：**

* 通过JDBC技术与数据库进行交互，使用Java语言发送SQL语句到数据库中，可以实现对数据的增、删、改、查等功能，可以更高效、安全的管理数据。
* JDBC是数据库与Java代码的桥梁（链接）。

## 二、JDBC的组成

JDBC是由一组用Java语言编写的类和接口组成，主要有驱动管理、Connection接口、Statement接口、ResultSet接口这几个部分。

![Description](https://ydcqoss.ydcode.cn/ydyx/bbs/1703045946-P7sJ73.png)

### Connection 接口

定义：在 JDBC 程序中用于代表数据库的连接，是数据库编程中最重要的一个对象，客户端与数据库所有的交互都是通过connection 对象完成的。

```
Connection conn = DriverManager.getConnection(url,user,password);
```

**常见方法：**

* createStatement() ：创建向数据库发送的sql的statement对象。
* prepareStatement(sql) ：创建向数据库发送预编译sql的PrepareSatement对象。
* prepareCall(sql) ：创建执行存储过程的callableStatement对象。（常用）
* setAutoCommit(boolean autoCommit)：设置事务是否自动提交。

```
//关闭自动提交事务  
setAutoCommit(false);  
//关闭后需要手动打开提交事务
```

* commit() : 在链接上提交事务。
* rollback() : 在此链接上回滚事务。

### Statement 接口

* statement：由createStatement创建，用于发送简单的SQL语句（不带参数）。

```
Statement st = conn.createStatement();
```

* PreparedStatement ：继承自Statement接口，是Statement的子类,可发送含有参数的SQL语句。效率更高，并且可以防止SQL注入，建议使用。
```
PreparedStatement ps = conn.prepareStatement(sql语句);
```
>**PreparedStatement 的优势：**
> Statement会使数据库频繁编译SQL，可能造成数据库缓冲区溢出。PreparedStatement 可对SQL进行预编译，从而提高数据库的执行效率。
> 并且PreperedStatement对于sql中的参数，允许使用占位符的形式进行替换，简化sql语句的编写，可以避免SQL注入的问题。

* CallableStatement：继承自PreparedStatement接口，由方法 prepareCall创建，用于调用存储过程。

**常见方法：**

* executeQuery(String sql) ：用于向数据发送查询语句。
* executeUpdate(String sql) ：用于向数据库发送insert、update或delete语句。
* execute(String sql)：用于向数据库发送任意sql语句。
* addBatch(String sql)：把多条sql语句放到一个批处理中。
* executeBatch()：向数据库发送一批sql语句执行。

### ResultSet 接口

ResultSet：用于代表Sql语句的执行结果。

Resultset封装执行结果时，采用的类似于表格的方式，ResultSet 对象维护了一个指向表格数据行的游标，初始的时候，游标在第一行之前，调用ResultSet.next() 方法，可以使游标指向具体的数据行，进行调用方法获取该行的数据。

常用方法：

* ResultSet.next() :移动到下一行;
* ResultSet.Previous() :移动到前一行
* ResultSet.absolute(int row):移动到指定行
* ResultSet.beforeFirst():移动resultSet的最前面
* ResultSet.afterLast():移动resultSet的最后面

>你还在苦恼找不到真正免费的编程学习平台吗?可以试试云端源想！课程视频、在线书籍、在线编程、实验场景模拟、一对一咨询……你想要的全部学习资源这里都有，重点是统统免费！[点这里即可查看](https://www.ydcode.cn/?sourceId=510)

## 三、JDBC的工作原理

JDBC的工作原理可以分为以下几个步骤：

![Description](https://ydcqoss.ydcode.cn/ydyx/bbs/1703046175-PK992F.png)

**1、加载并注册JDBC驱动：**\
这是建立数据库连接的第一步，我们需要先加载JDBC驱动，然后通过DriverManager的registerDriver方法进行注册。

**2、建立数据库连接：**\
通过DriverManager的getConnection方法，我们可以建立与数据库的连接。

**3、创建Statement对象：**\
通过Connection对象的createStatement方法，我们可以创建一个Statement对象，用于执行SQL语句。

**4、执行SQL语句：**\
通过Statement对象的executeQuery或executeUpdate方法，我们可以执行SQL语句，获取结果或者更新数据库。

**5、处理结果：**\
对于查询操作，我们需要处理ResultSet结果集；对于更新操作，我们不需要处理结果。

**6、关闭资源：**\
最后，我们需要关闭打开的资源，包括ResultSet、Statement和Connection。

下面，我们来看一个简单的JDBC使用示例。假设我们要查询为"students"的表中的所有数据：

![Description](https://ydcqoss.ydcode.cn/ydyx/bbs/1703046252-P6jo13.png)

## 四、面向过程的实现过程

1.在pom.xml中引入mysql的驱动文件

```
<dependency>
   <groupId>mysql</groupId>
   <artifactId>mysql-connector-java</artifactId>
   <version>8.0.32</version>
```

2. 加载驱动类

```
Class.forName("com.mysql.cj.jdbc.Driver");
```

3. 建立Java同数据库中间的连接通道

```
String url = "jdbc:mydql://locallhost:3306/test";//test是数据库名称
String user  = "root";
String password = "root";
Connection conn = DriverManager.getConnection(url,user,password);
```

4. 产生负责’传递命令’的‘传令官’对象

```
String sql ="insert into emp values(null,"苏醒","歌手",7956,now(),79429,6799,30,1)";
PrepareStement ps = conn.prepareStement(sql);
```

5. 接收结果集(只有查询有结果集)

```
int row = ps.excuteUpdate();//交由MySQL执行命令
System.out.println(row + "行受到影响!");
```

6. 关闭连接通道

```
ps.close();
conn.close();
```

**参数的传递方式**

```
//键盘赋值
private static Scanner scan;
static{
        scan = new Scanner(System.in);
    }
```

**拼接字符串方式**

![Description](https://ydcqoss.ydcode.cn/ydyx/bbs/1703046692-1H67OB.png)

**占位符方式 ‘?’**

![Description](https://ydcqoss.ydcode.cn/ydyx/bbs/1703046656-2208Vy.png)

**使用占位符的好处：**

* 可以有效避免SQL注入问题
* 可以自动根据复制时的数据类型来决定是否引入"

**删除**

* 物理删除

![Description](https://ydcqoss.ydcode.cn/ydyx/bbs/1703052727-R2P4sm.png)

* 逻辑删除

![Description](https://ydcqoss.ydcode.cn/ydyx/bbs/1703052757-JC3N9P.png)

**查询操作**

* 全查询

![Description](https://ydcqoss.ydcode.cn/ydyx/bbs/1703052790-ots8Bh.png)

* 按ID查询

![Description](https://ydcqoss.ydcode.cn/ydyx/bbs/1703052819-1X4Fbf.png)

## 五、面向对象(JDBC)的实现方式

面向对象是指将多个功能查分成多个包进行对数据库的增删改查（CRUD）操作。

**db包作用**

db包中只需要一个类–>DBManager类，这个类的主要作用就是负责管理数据的的连接。

![Description](https://ydcqoss.ydcode.cn/ydyx/bbs/1703052892-nIXcxG.png)

**bean包作用**

一般和数据库中的表对应，bean包中的类一般都和表名相同，首字母大写，驼峰命名。

![Description](https://ydcqoss.ydcode.cn/ydyx/bbs/1703052914-hGo7y8.png)

**dao包作用**

DAO是Data Access Object数据访问接口，一般以bean包的类名为前缀，以DAO结尾，负责执行CRUD操作，一个dao类负责一个表的CRUD，也可以说成是对一个bean类的CRUD（增删改查）。

```
public class EmpDAO(){
    
    
    // 一般对于删除操作，都是进行更新状态将之隐藏
    public void delete(int id){
        try{
         conn = DBManager.getConnection();
          String sql = "update  emp set state = 0 where empNo = "+ id;
         ps = conn.prepareStatement(sql);  
         ps.executeUpdate();
        }catch(ClassNotFoundException e){
            e.printStackTrace();
        }catch(SQLException e){
            e.printStackTrace();
        }finally{
           DBManager.closeConn(conn, ps);
        }                
    }
    
    //存储
    public void save(Emp emp) {

try {
            conn = DBManager.getConnection();
            String sql = "insert into emp values(null,?,?,?,now(),?,?,?,1)";
            ps = conn.prepareStatement(sql);

ps.setString(1, emp.getEname());
            ps.setString(2, emp.getJob());
            ps.setInt(3, emp.getMgr());
            ps.setDouble(4, emp.getSal());
            ps.setDouble(5, emp.getComm());
            ps.setInt(6, emp.getDeptNo());
            ps.executeUpdate();
        } catch (ClassNotFoundException e) {
            throw new RuntimeException(e);
        } catch (SQLException e) {
            throw new RuntimeException(e);
        } finally {

DBManager.closeConn(conn, ps);
        }
    }
    
     //更新--修改
    public void update(Emp emp) {
        try {
            conn = DBManager.getConnection();
            String sql = "update emp set ename=?,job=?,mgr=?,sal=?,comm=?,deptNo=? where empNo=?";
            ps = conn.prepareStatement(sql);
            ps.setString(1, emp.getEname());
            ps.setString(2, emp.getJob());
            ps.setInt(3, emp.getMgr());
            ps.setDouble(4, emp.getSal());
            ps.setDouble(5, emp.getComm());
            ps.setInt(6, emp.getDeptNo());
            ps.setInt(7, emp.getEmpNo());
            ps.executeUpdate();
        } catch (ClassNotFoundException e) {
            throw new RuntimeException(e);
        } catch (SQLException e) {
            throw new RuntimeException(e);
        } finally {
            DBManager.closeConn(conn, ps);
        }
    }
  //单条信息查询--按ID查询--将填写的信息填写在emp属性里中，然后将emp
    public Emp findEmpByNo(int id) {
        Emp emp = new Emp();

try {
            conn = DBManager.getConnection();
            String sql = "select * from emp where empno=? and state = 1";
            ps = conn.prepareStatement(sql);
            ps.setInt(1, id);
            rs = ps.executeQuery();
            if (rs.next()) {
                //取出第一列的值赋给empNO
                emp.setEmpNo(rs.getInt(1));
                emp.setEname(rs.getString(2));
                emp.setJob(rs.getString(3));
                emp.setMgr(rs.getInt(4));
                emp.setHireDate(rs.getString(5));
                emp.setSal(rs.getDouble(6));
                emp.setComm(rs.getDouble(7));
                emp.setDeptNo(rs.getInt(8));
                emp.setState(1);
            }
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {

DBManager.closeConn(conn, ps);
        }
        return emp;
    }

//全表查询--集合
    public List<Emp> findAllEmp() {
        List<Emp> list = new ArrayList<>();

try {
            conn = DBManager.getConnection();
            String sql = "select * from emp where state  = 1";
            ps = conn.prepareStatement(sql);
            rs = ps.executeQuery();
            while (rs.next()) {
                Emp emp = new Emp();//每循环一次new一个新对象，给对象付一次值
                emp.setEmpNo(rs.getInt(1));
                emp.setEname(rs.getString(2));
                emp.setJob(rs.getString(3));
                emp.setMgr(rs.getInt(4));
                emp.setHireDate(rs.getString(5));
                emp.setSal(rs.getDouble(6));
                emp.setComm(rs.getDouble(7));
                emp.setDeptNo(rs.getInt(8));
                emp.setState(1);
                list.add(emp);//循环一次在集合中增加一条数据
            }
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            DBManager.closeConn(conn, ps);
        }

return list;

}
}
```

**多表联查**

```

//多表联查
    //方法一：
    public List<Emp> findAllEmp2(){
        List<Emp> list = new ArrayList<>();
        try {
            conn = DBManager.getConnection();
            String sql = "select * from emp e left join Dept d on e.deptNo = d.deptNo where state =1";
            ps = conn.prepareStatement(sql);
            rs = ps.executeQuery();
            while (rs.next()){
                Emp emp = new Emp();
                emp.setEmpNo(rs.getInt(1));
                emp.setEname(rs.getString(2));
                emp.setJob(rs.getString(3));
                emp.setMgr(rs.getInt(4));
                emp.setHireDate(rs.getString(5));
                emp.setSal(rs.getDouble(6));
                emp.setComm(rs.getDouble(7));
                emp.setDeptNo(rs.getInt(8));
                emp.setState(1);
                emp.setDname(rs.getString(11));
                emp.setLoc(rs.getString(12));
                list.add(emp);
            }
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            DBManager.closeConn(conn, ps,rs);
        }
        return list;
    }

//方法二：
    public List<Emp> findAllEmp3(){
        List<Emp> list = new ArrayList<>();

try {
            conn = DBManager.getConnection();
            String sql = "select * from emp e left join Dept d on e.deptNo = d.deptNo where state =1";
            ps = conn.prepareStatement(sql);
            rs = ps.executeQuery();
            while (rs.next()){
                Emp emp = new Emp();
                emp.setEmpNo(rs.getInt(1));
                emp.setEname(rs.getString(2));
                emp.setJob(rs.getString(3));
                emp.setMgr(rs.getInt(4));
                emp.setHireDate(rs.getString(5));
                emp.setSal(rs.getDouble(6));
                emp.setComm(rs.getDouble(7));
                emp.setDeptNo(rs.getInt(8));
                emp.setState(1);
                Dept dept = new Dept();
                dept.setDeptNo(rs.getInt(10));
                dept.setDname(rs.getString(11));
                dept.setLoc(rs.getString(12));
                emp.setDept(dept);//引入dept表
                list.add(emp);
            }
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            DBManager.closeConn(conn, ps,rs);
        }

return list;
    }
}
```

以上就是JDBC的基本概述了，JDBC这个看似复杂的技术，其实是一个非常实用的工具。

只要你掌握了它，就可以轻松地处理和管理你的数据。无论你是一位经验丰富的程序员，还是一位刚刚入门的新手，我都强烈推荐你学习和使用JDBC。相信我，当你掌握了JDBC，你会发现它为你的工作和学习带来了极大的便利。

JDBC（Java DataBase Connectivity）是一种用于执行SQL语句的 Java API，是Java和数据库之间的一个桥梁，是一个规范而不是一个实现，能够交给数据库执行SQL语句。

一、JDBC简介

概念：

JDBC(Java DataBase Connectivity) ：Java数据库连接技术。\ 具体讲就是通过Java连接广泛的数据库，并对表中数据执行增、删、改、查等操作的技术。如图所示：

也就是说，JDBC本质上也是一种发送SQL操作数据库的client技术，只不过需要通过Java编码完成。

作用：

通过JDBC技术与数据库进行交互，使用Java语言发送SQL语句到数据库中，可以实现对数据的增、删、改、查等功能，可以更高效、安全的管理数据。
JDBC是数据库与Java代码的桥梁（链接）。

二、JDBC的组成

JDBC是由一组用Java语言编写的类和接口组成，主要有驱动管理、Connection接口、Statement接口、ResultSet接口这几个部分。

Connection 接口

定义：在 JDBC 程序中用于代表数据库的连接，是数据库编程中最重要的一个对象，客户端与数据库所有的交互都是通过connection 对象完成的。

Connection conn = DriverManager.getConnection(url,user,password);

常见方法：

createStatement() ：创建向数据库发送的sql的statement对象。
prepareStatement(sql) ：创建向数据库发送预编译sql的PrepareSatement对象。
prepareCall(sql) ：创建执行存储过程的callableStatement对象。（常用）
setAutoCommit(boolean autoCommit)：设置事务是否自动提交。

//关闭自动提交事务  
setAutoCommit(false);  
//关闭后需要手动打开提交事务

commit() : 在链接上提交事务。
rollback() : 在此链接上回滚事务。

Statement 接口

statement：由createStatement创建，用于发送简单的SQL语句（不带参数）。

Statement st = conn.createStatement();

PreparedStatement ：继承自Statement接口，是Statement的子类,可发送含有参数的SQL语句。效率更高，并且可以防止SQL注入，建议使用。
```
PreparedStatement ps = conn.prepareStatement(sql语句);
```
PreparedStatement 的优势： Statement会使数据库频繁编译SQL，可能造成数据库缓冲区溢出。PreparedStatement 可对SQL进行预编译，从而提高数据库的执行效率。并且PreperedStatement对于sql中的参数，允许使用占位符的形式进行替换，简化sql语句的编写，可以避免SQL注入的问题。
CallableStatement：继承自PreparedStatement接口，由方法 prepareCall创建，用于调用存储过程。

常见方法：

executeQuery(String sql) ：用于向数据发送查询语句。
executeUpdate(String sql) ：用于向数据库发送insert、update或delete语句。
execute(String sql)：用于向数据库发送任意sql语句。
addBatch(String sql)：把多条sql语句放到一个批处理中。
executeBatch()：向数据库发送一批sql语句执行。

ResultSet 接口

ResultSet：用于代表Sql语句的执行结果。

常用方法：

ResultSet.next() :移动到下一行;
ResultSet.Previous() :移动到前一行
ResultSet.absolute(int row):移动到指定行
ResultSet.beforeFirst():移动resultSet的最前面
ResultSet.afterLast():移动resultSet的最后面

你还在苦恼找不到真正免费的编程学习平台吗?可以试试云端源想！课程视频、在线书籍、在线编程、实验场景模拟、一对一咨询……你想要的全部学习资源这里都有，重点是统统免费！点这里即可查看

三、JDBC的工作原理

JDBC的工作原理可以分为以下几个步骤：

1、加载并注册JDBC驱动：\ 这是建立数据库连接的第一步，我们需要先加载JDBC驱动，然后通过DriverManager的registerDriver方法进行注册。

2、建立数据库连接：\ 通过DriverManager的getConnection方法，我们可以建立与数据库的连接。

3、创建Statement对象：\ 通过Connection对象的createStatement方法，我们可以创建一个Statement对象，用于执行SQL语句。

4、执行SQL语句：\ 通过Statement对象的executeQuery或executeUpdate方法，我们可以执行SQL语句，获取结果或者更新数据库。

5、处理结果：\ 对于查询操作，我们需要处理ResultSet结果集；对于更新操作，我们不需要处理结果。

6、关闭资源：\ 最后，我们需要关闭打开的资源，包括ResultSet、Statement和Connection。

下面，我们来看一个简单的JDBC使用示例。假设我们要查询为"students"的表中的所有数据：

四、面向过程的实现过程

1.在pom.xml中引入mysql的驱动文件

&lt;dependency>
   &lt;groupId>mysql&lt;/groupId>
   &lt;artifactId>mysql-connector-java&lt;/artifactId>
   &lt;version>8.0.32&lt;/version>

加载驱动类

Class.forName("com.mysql.cj.jdbc.Driver");

建立Java同数据库中间的连接通道

String url = "jdbc:mydql://locallhost:3306/test";//test是数据库名称
String user  = "root";
String password = "root";
Connection conn = DriverManager.getConnection(url,user,password);

产生负责’传递命令’的‘传令官’对象

String sql ="insert into emp values(null,"苏醒","歌手",7956,now(),79429,6799,30,1)";
PrepareStement ps = conn.prepareStement(sql);

接收结果集(只有查询有结果集)

int row = ps.excuteUpdate();//交由MySQL执行命令
System.out.println(row + "行受到影响!");

关闭连接通道

ps.close();
conn.close();

参数的传递方式

//键盘赋值
private static Scanner scan;
static{
        scan = new Scanner(System.in);
    }

拼接字符串方式

占位符方式 ‘?’

使用占位符的好处：

可以有效避免SQL注入问题
可以自动根据复制时的数据类型来决定是否引入"

删除

物理删除

逻辑删除

查询操作

全查询

按ID查询

五、面向对象(JDBC)的实现方式

面向对象是指将多个功能查分成多个包进行对数据库的增删改查（CRUD）操作。

db包作用

db包中只需要一个类–>DBManager类，这个类的主要作用就是负责管理数据的的连接。

bean包作用

一般和数据库中的表对应，bean包中的类一般都和表名相同，首字母大写，驼峰命名。

dao包作用

public class EmpDAO(){

    // 一般对于删除操作，都是进行更新状态将之隐藏
    public void delete(int id){
        try{
         conn = DBManager.getConnection();
          String sql = "update  emp set state = 0 where empNo = "+ id;
         ps = conn.prepareStatement(sql);  
         ps.executeUpdate();
        }catch(ClassNotFoundException e){
            e.printStackTrace();
        }catch(SQLException e){
            e.printStackTrace();
        }finally{
           DBManager.closeConn(conn, ps);
        }                
    }

    //存储
    public void save(Emp emp) {

        try {
            conn = DBManager.getConnection();
            String sql = "insert into emp values(null,?,?,?,now(),?,?,?,1)";
            ps = conn.prepareStatement(sql);

            ps.setString(1, emp.getEname());
            ps.setString(2, emp.getJob());
            ps.setInt(3, emp.getMgr());
            ps.setDouble(4, emp.getSal());
            ps.setDouble(5, emp.getComm());
            ps.setInt(6, emp.getDeptNo());
            ps.executeUpdate();
        } catch (ClassNotFoundException e) {
            throw new RuntimeException(e);
        } catch (SQLException e) {
            throw new RuntimeException(e);
        } finally {

            DBManager.closeConn(conn, ps);
        }
    }

     //更新--修改
    public void update(Emp emp) {
        try {
            conn = DBManager.getConnection();
            String sql = "update emp set ename=?,job=?,mgr=?,sal=?,comm=?,deptNo=? where empNo=?";
            ps = conn.prepareStatement(sql);
            ps.setString(1, emp.getEname());
            ps.setString(2, emp.getJob());
            ps.setInt(3, emp.getMgr());
            ps.setDouble(4, emp.getSal());
            ps.setDouble(5, emp.getComm());
            ps.setInt(6, emp.getDeptNo());
            ps.setInt(7, emp.getEmpNo());
            ps.executeUpdate();
        } catch (ClassNotFoundException e) {
            throw new RuntimeException(e);
        } catch (SQLException e) {
            throw new RuntimeException(e);
        } finally {
            DBManager.closeConn(conn, ps);
        }
    }
  //单条信息查询--按ID查询--将填写的信息填写在emp属性里中，然后将emp
    public Emp findEmpByNo(int id) {
        Emp emp = new Emp();

        try {
            conn = DBManager.getConnection();
            String sql = "select * from emp where empno=? and state = 1";
            ps = conn.prepareStatement(sql);
            ps.setInt(1, id);
            rs = ps.executeQuery();
            if (rs.next()) {
                //取出第一列的值赋给empNO
                emp.setEmpNo(rs.getInt(1));
                emp.setEname(rs.getString(2));
                emp.setJob(rs.getString(3));
                emp.setMgr(rs.getInt(4));
                emp.setHireDate(rs.getString(5));
                emp.setSal(rs.getDouble(6));
                emp.setComm(rs.getDouble(7));
                emp.setDeptNo(rs.getInt(8));
                emp.setState(1);
            }
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {

            DBManager.closeConn(conn, ps);
        }
        return emp;
    }

    //全表查询--集合
    public List&lt;Emp> findAllEmp() {
        List&lt;Emp> list = new ArrayList&lt;>();

        try {
            conn = DBManager.getConnection();
            String sql = "select * from emp where state  = 1";
            ps = conn.prepareStatement(sql);
            rs = ps.executeQuery();
            while (rs.next()) {
                Emp emp = new Emp();//每循环一次new一个新对象，给对象付一次值
                emp.setEmpNo(rs.getInt(1));
                emp.setEname(rs.getString(2));
                emp.setJob(rs.getString(3));
                emp.setMgr(rs.getInt(4));
                emp.setHireDate(rs.getString(5));
                emp.setSal(rs.getDouble(6));
                emp.setComm(rs.getDouble(7));
                emp.setDeptNo(rs.getInt(8));
                emp.setState(1);
                list.add(emp);//循环一次在集合中增加一条数据
            }
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            DBManager.closeConn(conn, ps);
        }

        return list;

    }
}

多表联查


//多表联查
    //方法一：
    public List&lt;Emp> findAllEmp2(){
        List&lt;Emp> list = new ArrayList&lt;>();
        try {
            conn = DBManager.getConnection();
            String sql = "select * from emp e left join Dept d on e.deptNo = d.deptNo where state =1";
            ps = conn.prepareStatement(sql);
            rs = ps.executeQuery();
            while (rs.next()){
                Emp emp = new Emp();
                emp.setEmpNo(rs.getInt(1));
                emp.setEname(rs.getString(2));
                emp.setJob(rs.getString(3));
                emp.setMgr(rs.getInt(4));
                emp.setHireDate(rs.getString(5));
                emp.setSal(rs.getDouble(6));
                emp.setComm(rs.getDouble(7));
                emp.setDeptNo(rs.getInt(8));
                emp.setState(1);
                emp.setDname(rs.getString(11));
                emp.setLoc(rs.getString(12));
                list.add(emp);
            }
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            DBManager.closeConn(conn, ps,rs);
        }
        return list;
    }

    //方法二：
    public List&lt;Emp> findAllEmp3(){
        List&lt;Emp> list = new ArrayList&lt;>();

        try {
            conn = DBManager.getConnection();
            String sql = "select * from emp e left join Dept d on e.deptNo = d.deptNo where state =1";
            ps = conn.prepareStatement(sql);
            rs = ps.executeQuery();
            while (rs.next()){
                Emp emp = new Emp();
                emp.setEmpNo(rs.getInt(1));
                emp.setEname(rs.getString(2));
                emp.setJob(rs.getString(3));
                emp.setMgr(rs.getInt(4));
                emp.setHireDate(rs.getString(5));
                emp.setSal(rs.getDouble(6));
                emp.setComm(rs.getDouble(7));
                emp.setDeptNo(rs.getInt(8));
                emp.setState(1);
                Dept dept = new Dept();
                dept.setDeptNo(rs.getInt(10));
                dept.setDname(rs.getString(11));
                dept.setLoc(rs.getString(12));
                emp.setDept(dept);//引入dept表
                list.add(emp);
            }
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            DBManager.closeConn(conn, ps,rs);
        }

        return list;
    }
}

以上就是JDBC的基本概述了，JDBC这个看似复杂的技术，其实是一个非常实用的工具。