Java-JDBC_java jdbc 持久化-CSDN博客

本文链接：https://blog.csdn.net/qq_48114126/article/details/132502894

1 JDBC概述

1.1 数据持久化

持久化(persistence)：把数据保存到可掉电式存储设备中以供之后使用。大多数情况下，特别是企业级应用，数据持久化意味着将内存中的数据保存到硬盘上加以”固化”，而持久化的实现过程大多通过各种关系数据库来完成。
持久化的主要应用是将内存中的数据存储在关系型数据库中，当然也可以存储在磁盘文件、XML数据文件中。

1.2 Java中的数据存储技术

在Java中，数据库存取技术可分为如下几类：
- JDBC直接访问数据库
- JDO (Java Data Object )技术
- 第三方O/R工具，如Hibernate, Mybatis 等
JDBC是java访问数据库的基石，JDO、Hibernate、MyBatis等只是更好的封装了JDBC。

1.3 JDBC介绍

JDBC(Java Database Connectivity)是一个独立于特定数据库管理系统、通用的SQL数据库存取和操作的公共接口（一组API），定义了用来访问数据库的标准Java类库，（java.sql,javax.sql）使用这些类库可以以一种标准的方法、方便地访问数据库资源。
JDBC为访问不同的数据库提供了一种统一的途径，为开发者屏蔽了一些细节问题。
JDBC的目标是使Java程序员使用JDBC可以连接任何提供了JDBC驱动程序的数据库系统，这样就使得程序员无需对特定的数据库系统的特点有过多的了解，从而大大简化和加快了开发过程。
如果没有JDBC，那么Java程序访问数据库时是这样的：

有了JDBC，Java程序访问数据库时是这样的：

1.4 JDBC体系结构

JDBC接口（API）包括两个层次：
- 面向应用的API：Java API，抽象接口，供应用程序开发人员使用（连接数据库，执行SQL语句，获得结果）。
- 面向数据库的API：Java Driver API，供开发商开发数据库驱动程序用。

JDBC是sun公司提供一套用于数据库操作的接口，java程序员只需要面向这套接口编程即可。不同的数据库厂商，需要针对这套接口，提供不同实现。不同的实现的集合，即为不同数据库的驱动。 ————面向接口编程

2 JDBC详解

2.1 JDBC入门案例

导入.sql数据
创建maven项目，引入依赖

pom.xml中引入MySQL数据库的java连接器

    <dependencies>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.31</version>
        </dependency>
    </dependencies>

练习

    public static void main(String[] args) throws Exception {
        Class.forName("com.mysql.cj.jdbc.Driver");
        //Connection
        Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/test", "root", "123456");
        //Statement，PrepareStatement
        PreparedStatement ps = conn.prepareStatement("SELECT name FROM customers");
        //ResultSet
        ResultSet rs = ps.executeQuery();
        while (rs.next()) {
            System.out.println(rs.getString("name"));
        }
        //必须关闭连接
        rs.close();
        ps.close();
        conn.close();
    }

package com.gk.demo;

import java.io.*;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;

public class Main {
    public static void main(String[] args) throws Exception{
        Class.forName("com.mysql.cj.jdbc.Driver");
        //Connection
        Connection con = DriverManager.getConnection("jdbc:mysql://localhost:3306/test","root","123456");
        //PrepareStatement
        PreparedStatement ps = con.prepareStatement("SELECT * FROM customers where id=16");
        //ResultSet
        ResultSet rs = ps.executeQuery();
        InputStream in = null;
        String name = null;
        while (rs.next()){
            /*System.out.print(rs.getInt("id"));
            System.out.print(rs.getString("name"));
            System.out.println(rs.getDate("birth"));*/
            in =  rs.getBinaryStream("photo");
            name = rs.getString("name");
        }

        FileOutputStream out = new FileOutputStream(name + ".jpg");
        int len = -1;
        byte[] buffer = new byte[1024];
        while ((len = in.read(buffer)) != -1){
            out.write(buffer,0,len);
            out.flush();
        }

        //Close
        out.close();
        in.close();
        rs.close();
        ps.close();
        con.close();
    }
}

2.2 Class.forName() 与 Connection

Class.forName() 是 Java 中的一个方法，用于加载并初始化指定的类。它可以通过提供类的全限定名作为参数来加载类。

在旧版本的 Java 中，通过调用 Class.forName(className) 加载类会触发该类的静态初始化块，进而执行一些静态操作。这通常用于加载和注册 JDBC 驱动程序、加载特定的类库或执行其他需要在运行时进行类加载的操作。

然而，从 Java 9 开始，在大多数情况下，不再需要显式调用 Class.forName() 来加载类。JVM 在需要使用类时会自动进行类加载，并且可以通过模块系统、服务提供者接口（SPI）等机制更方便地指定要加载的类。因此，在较新的 Java 版本中，很少需要使用 Class.forName()。

需要注意的是，如果你在使用某些需要旧版兼容性的代码或框架，可能仍然需要使用 Class.forName()。但在大多数情况下，可以通过让 JVM 自动加载类来简化代码并提高可读性。
Connection 是 Java 中表示与数据库建立的连接的接口，位于 java.sql.Connection 包中。它是使用 JDBC（Java Database Connectivity）进行数据库操作的关键组件之一。

通过创建 Connection 对象，可以与数据库建立连接，并执行各种操作，如执行 SQL 语句、事务管理、设置连接属性等。

2.3 PreparedStatement 和 Statement

数据库连接被用于向数据库服务器发送命令和SQL语句，并接受数据库服务器返回的结果。其实一个数据库连接就是一个Socket连接
在java.sql包中有三个接口分别定义了对数据库的调用的不同方式：
- Statement：用于执行静态SQL语句并返回它所生成结果的对象
- PrepareStatement：SQL语句被预编译并存储在此对象中，可以使用此对象多次高效地执行该语句
- CallableStatement：用于执行SQL存储过程

2.2.1 PreparedStatement

可以通过调用Connection对象的prepareStatement(String sql)方法获取PrepareStatement对象
PrepareStatement接口是Statement的子接口，表示一条预编译过的SQL语句
PreparedStatement 对象所代表的 SQL 语句中的参数用问号(?)来表示，调用 PreparedStatement 对象的 setXxx() 方法来设置这些参数. setXxx() 方法有两个参数，第一个参数是要设置的 SQL 语句中的参数的索引(从 1 开始)，第二个是设置的 SQL 语句中的参数的值

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

public class Main {
    public static void main(String[] args) {
        String url = "jdbc:mysql://localhost:3306/mydatabase";
        String username = "your-username";
        String password = "your-password";

        try (Connection connection = DriverManager.getConnection(url, username, password)) {
            // 创建 PreparedStatement 对象
            String sql = "SELECT * FROM mytable WHERE id = ?";
            PreparedStatement statement = connection.prepareStatement(sql);

            // 设置参数的值
            int idParam = 1;
            statement.setInt(1, idParam);//第一个1代表第一个问号

            // 执行查询
            ResultSet resultSet = statement.executeQuery();

            // 处理查询结果
            while (resultSet.next()) {
                // 通过列名或索引获取数据
                int id = resultSet.getInt("id");
                String name = resultSet.getString("name");

                // 打印结果
                System.out.println("ID: " + id + ", Name: " + name);
            }

            // 关闭连接
            connection.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

在上述代码中，我们创建了一个带有参数的 SQL 查询语句，并将参数索引设置为 1（即第一个问号）。然后，使用 setInt() 方法将参数的值设置为 idParam 变量的值。最后，调用 executeQuery() 方法执行查询。

注意，在设置参数索引时，从 1 开始计数。具体使用哪个 setXxx() 方法取决于参数的类型（如 setInt()、setString() 等）。

通过使用 PreparedStatement 对象可以安全地处理带有参数的 SQL 语句，避免了 SQL 注入攻击，并提高了性能和可读性。

2.2.2 PreparedStatement 与 Statement

PreparedStatement 能最大可能提高性能：
- DBServer会对预编译语句提供性能优化。因为预编译语句有可能被重复调用，所以语句在被DBServer的编译器编译后的执行代码被缓存下来，那么下次调用时只要是相同的预编译语句就不需要编译，只要将参数直接传入编译过的语句执行代码中就会得到执行。
- 在statement语句中,即使是相同操作但因为数据内容不一样,所以整个语句本身不能匹配,没有缓存语句的意义.事实是没有数据库会对普通语句编译后的执行代码缓存。这样每执行一次都要对传入的语句编译一次。
- (语法检查，语义检查，翻译成二进制命令，缓存)
PreparedStatement 可以防止 SQL 注入
Statement需要拼接SQL语句代码繁琐，存在SQL注入问题

1. 登录Statement实现案例

public class StatementTest {

    /**
     * Statement
     *   - 不能预编译语句，性能差
     *   - sql语句，拼接字符串，繁琐
     *   - sql注入问题
     *      - 用户名输入：”1' or “
     *      - 密码输入：“=1 or '1' = '1”
     */
    public static void main(String[] args) throws Exception {
        Scanner sc = new Scanner(System.in);
        System.out.println("输入用户名");
        String username = sc.nextLine();
        System.out.println("输入密码");
        String password = sc.nextLine();

        String sql = "SELECT * FROM user_table WHERE USER = '" + username +  "' AND PASSWORD = '" + password +"'";
        Class.forName("com.mysql.cj.jdbc.Driver");
        //Connection
        Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/test", "root", "123456");
        //Statement，PrepareStatement
        Statement st = conn.createStatement();
        //ResultSet
        ResultSet rs = st.executeQuery(sql);
        if (rs.next()) {
            System.out.println("登录成功");
        } else {
            System.out.println("登录失败");
        }
        //必须关闭连接
        rs.close();
        st.close();
        conn.close();
    }

}

2. 登录PreparedStatement

public class PrepareStatementTest {

    /**
     * PrepareStatement
     *   性能好
     *   使用?代替参数，避免字符串拼接，避免SQL注入	
     */
    public static void main(String[] args) throws Exception {
        Scanner sc = new Scanner(System.in);
        System.out.println("输入用户名");
        String username = sc.nextLine();
        System.out.println("输入密码");
        String password = sc.nextLine();

        String sql = "SELECT * FROM user_table WHERE USER = ? AND PASSWORD = ?";
        Class.forName("com.mysql.cj.jdbc.Driver");
        //Connection
        Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/test", "root", "123456");
        //Statement，PrepareStatement
        PreparedStatement ps = conn.prepareStatement(sql);
        ps.setString(1, username);
        ps.setString(2, password);
        //ResultSet
        ResultSet rs = ps.executeQuery();
        if (rs.next()) {
            System.out.println("登录成功");
        } else {
            System.out.println("登录失败");
        }
        //必须关闭连接
        rs.close();
        ps.close();
        conn.close();
    }

}

2.2.3 SQL注入

SQL 注入是一种常见的安全漏洞，它发生在应用程序未正确验证用户输入数据，并将其直接插入到构成 SQL 查询的字符串中。攻击者可以通过恶意构造的输入数据修改原始 SQL 查询的含义，以执行未授权的操作或暴露敏感信息。

下面是一个示例，展示了 SQL 注入攻击的可能性：

假设有一个登录页面，用户可以输入用户名和密码进行身份验证。后台使用用户输入直接拼接 SQL 查询语句，例如：

String username = request.getParameter("username");
String password = request.getParameter("password");

String sql = "SELECT * FROM users WHERE username = '" + username + "' AND password = '" + password + "'";

如果不对用户输入进行验证和转义，而是直接将其插入到 SQL 查询字符串中，攻击者可以通过输入特殊字符来修改查询的含义。

举例1，如果用户输入的用户名为 admin' --，则构成的 SQL 查询变为：

SELECT * FROM users WHERE username = 'admin' --' AND password = 'xxxx'

这个查询通过注释符 -- 将原始密码条件注释掉，因此无需提供正确的密码即可绕过身份验证。

举例2，用户名输入：1' or，密码输入：=1 or '1' = '1

SELECT * FROM user_table WHERE USER = '1' or' and password='=1 or '1' = '1'

这个查询只执行最后一个or后的语句

使用参数化查询或预编译语句：使用 PreparedStatement 接口或其他支持参数化查询的机制。通过将用户输入作为参数传递给查询，而不是直接拼接到查询字符串中，可以防止注入攻击。
输入验证和过滤：对用户的输入进行验证和过滤，确保只接受预期的数据格式和字符。可以使用正则表达式、白名单或黑名单等方法对输入进行验证。
参数化存储过程：如果使用存储过程，确保正确使用参数化语句和绑定输入参数，以防止注入。
最小权限原则：数据库用户应该具有最少的权限来执行所需的操作，以限制攻击者对数据库的影响范围。

通过采取这些防御措施，可以有效地预防 SQL 注入攻击，并提高应用程序的安全性。记住，永远不要相信用户输入，始终进行适当的验证和转义。

3 JDBC的CRUD实现

3.1 程序的分层

java开发手册推荐的工程的分层

Dao(data access object)：数据访问层
Service：业务逻辑层
Controller：控制层
domain：实体类·，领域模型（persistence object）

3.2 领域模型（实体类）

创建表对应的实体类：表->类，字段->属性

Java与SQL对应数据类型转换表

Java类型	SQL类型
boolean	BIN
byte	TINYINT
short	SMALLINT
int	INTEGER
long	BIGINT
String	CHAR,VARCHAR,LONGVARCHAR
byte array	BINARY,VAR BINARY
java.sql.Date	DATE
java.sql.Time	TIME
java.sql.Timestamp	TIMESTAMP

domain

User

package com.gk.c_crud.domain;

public class User {
    //实体类不要使用基本数据类型，使用包装类，原始基本数据类型不能接受null
    private Integer id;
    private String name;
    private String password;
    private String address;
    private String phone;

    public User() {
    }

    public User(Integer 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 Integer getId() {
        return id;
    }

    public void setId(Integer 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 + '\'' +
                '}';
    }
}

Order

public class Order {

    private Integer orderId;
    private String orderName;
    private Date orderDate;

    public Integer getOrderId() {
        return orderId;
    }

    public void setOrderId(Integer orderId) {
        this.orderId = orderId;
    }

    public String getOrderName() {
        return orderName;
    }

    public void setOrderName(String orderName) {
        this.orderName = orderName;
    }

    public Date getOrderDate() {
        return orderDate;
    }

    public void setOrderDate(Date orderDate) {
        this.orderDate = orderDate;
    }
}

3.3 Dao层

UserDao

package com.gk.c_crud.dao;

import com.gk.c_crud.domain.User;

import java.sql.*;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class UserDao {
    /**
     * 查询所有
     * */
    public List<User> find(){
        List<User> list = new ArrayList<>(10);
        String sql = "select `id`,`name`,`password`,`address`,`phone` from user";
        Connection con = null;
        PreparedStatement ps = null;
        ResultSet rs = null;

        try {
            con = DriverManager.getConnection("jdbc:mysql://localhost:3306/test","root","123456");
            ps = con.prepareStatement(sql);
            rs = ps.executeQuery();
            while (rs.next()){
                User user = new User();
                user.setId(rs.getInt(1));
                user.setName(rs.getString(2));
                user.setPassword(rs.getString(3));
                user.setAddress(rs.getString("address"));
                user.setPhone(rs.getString("phone"));
                list.add(user);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (rs != null && !rs.isClosed()) {
                    rs.close();
                }
            } catch (SQLException e) {
                e.printStackTrace();
            }
            try {
                if (ps != null && !ps.isClosed()) {
                    ps.close();
                }
            } catch (SQLException e) {
                e.printStackTrace();
            }
            try {
                if (con != null && !con.isClosed()) {
                    con.close();
                }
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        return list;
    }

    /**
    * 查询单个id
    */
    public User findSingle(){
        User user = new User();
        Scanner sc = new Scanner(System.in);
        System.out.println("输入要查询的人物的id：");
        int id = sc.nextInt();
        String sql = "SELECT `id`,`name`,`password`,`address`,`phone` FROM user where id = ?";

        Connection con = null;
        PreparedStatement ps = null;
        ResultSet rs = null;

        try {
            con = DriverManager.getConnection("jdbc:mysql://localhost:3306/test","root","123456");
            ps = con.prepareStatement(sql);
            ps.setInt(1,id);
            rs = ps.executeQuery();

            if(rs.next()){
                user.setId(rs.getInt("id"));
                user.setName(rs.getString("name"));
                user.setPassword(rs.getString("password"));
                user.setAddress(rs.getString("address"));
                user.setPhone(rs.getString("phone"));
            }

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (rs != null && !rs.isClosed()) {
                    rs.close();
                }
            } catch (SQLException e) {
                e.printStackTrace();
            }
            try {
                if (ps != null && !ps.isClosed()) {
                    ps.close();
                }
            } catch (SQLException e) {
                e.printStackTrace();
            }
            try {
                if (con != null && !con.isClosed()) {
                    con.close();
                }
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }

        return user;
    }

    /**
    *  插入数据
    */
    public int insert(){
        int rows = 0;
        Scanner src = new Scanner(System.in);
        System.out.println("输入名字");
        String name = src.next();
        System.out.println("输入密码");
        String password = src.next();
        System.out.println("输入地址");
        String address = src.next();
        System.out.println("输入电话");
        String phone = src.next();

        Connection con = null;
        String sql = "insert into user(`name`, `password`, `address`, `phone`) values(?,?,?,?)";
        PreparedStatement ps = null;
        //ResultSet rs = null;

        try {
            con = DriverManager.getConnection("jdbc:mysql://localhost:3306/test","root","123456");
            ps = con.prepareStatement(sql);
            ps.setString(1,name);
            ps.setString(2,password);
            ps.setString(3,address);
            ps.setString(4,phone);
            //rs = ps.executeQuery();
            rows = ps.executeUpdate();
        } catch (SQLException e) {
            throw new RuntimeException(e);
        } finally {

            try {
                if (ps != null && !ps.isClosed()) {
                    ps.close();
                }
            } catch (SQLException e) {
                e.printStackTrace();
            }
            try {
                if (con != null && !con.isClosed()) {
                    con.close();
                }
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        return rows;
    }

    /**
    *  输入id,删除数据
    */
    public int delete(){
        int rows = 0;
        Scanner src = new Scanner(System.in);
        System.out.println("输入要删除的人的id:");
        Integer id = src.nextInt();
        String sql = "delete from `user` where id = ?";
        Connection con = null;
        PreparedStatement ps = null;

        try {
            con = DriverManager.getConnection("jdbc:mysql://localhost:3306/test","root","123456");
            ps = con.prepareStatement(sql);
            ps.setInt(1,id);
            rows = ps.executeUpdate();
        } catch (SQLException e) {
            throw new RuntimeException(e);
        } finally {
            try {
                if (ps != null && !ps.isClosed()) {
                    ps.close();
                }
            } catch (SQLException e) {
                e.printStackTrace();
            }
            try {
                if (con != null && !con.isClosed()) {
                    con.close();
                }
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }

        return rows;
    }

    /**
    *  输入id，更改数据
    */
    public int update(){
        User user = new User();
        int rows = 0;
        Scanner src = new Scanner(System.in);
        System.out.println("输入要修改的人的id:");
        Integer id = src.nextInt();
        System.out.println("输入改后的id");
        Integer ids = src.nextInt();
        System.out.println("输入改后的名字");
        String name = src.next();
        System.out.println("输入改后的密码");
        String password = src.next();
        System.out.println("输入改后的地址");
        String address = src.next();
        System.out.println("输入改后的手机号");
        String phone = src.next();

        String sql = "update `user` set `id` = ?, `name` = ?, `password` = ?, `address` = ?, `phone` = ? where id = ?";
        Connection con = null;
        PreparedStatement ps = null;

        try {
            con = DriverManager.getConnection("jdbc:mysql://localhost:3306/test","root","123456");
            ps = con.prepareStatement(sql);
            ps.setInt(1,ids);
            ps.setString(2,name);
            ps.setString(3,password);
            ps.setString(4,address);
            ps.setString(5,phone);
            ps.setInt(6,id);
            rows = ps.executeUpdate();
        } catch (SQLException e) {
            throw new RuntimeException(e);
        } finally {
            try {
                if (ps != null && !ps.isClosed()) {
                    ps.close();
                }
            } catch (SQLException e) {
                e.printStackTrace();
            }
            try {
                if (con != null && !con.isClosed()) {
                    con.close();
                }
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }

        return rows;
    }
    
     /**
     * 添加
     * @param user
     * @return 返回语句影响的函数
     */
    public int update1(User user) {
        int rows = 0;
        String sql = "update user set `name`=?, `password`=?,  `address`=?,  `phone`=? WHERE `id` = ?";

        Connection conn = null;
        PreparedStatement ps = null;
        ResultSet rs = null;
        try {
            conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/test", "root", "123456");
            ps = conn.prepareStatement(sql);
            ps.setString(1, user.getName());
            ps.setString(2, user.getPassword());
            ps.setString(3, user.getAddress());
            ps.setString(4, user.getPhone());
            ps.setInt(5, user.getId());

            rows = ps.executeUpdate(); //执行修改,返回语句影响的行数

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (rs != null && !rs.isClosed()) {
                    rs.close();
                }
            } catch (SQLException e) {
                e.printStackTrace();
            }
            try {
                if (ps != null && !ps.isClosed()) {
                    ps.close();
                }
            } catch (SQLException e) {
                e.printStackTrace();
            }
            try {
                if (conn != null && !conn.isClosed()) {
                    conn.close();
                }
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        return rows;
    }

}

OrderDao

public class OrderDao {

    /**
     * `order_id`,  `order_name`,  `order_date`
     */

    /**
     * 查询所有
     * @return
     */
    public List<Order> find() {
        List<Order> list = new ArrayList<>(10);
        String sql = "SELECT `order_id`,  `order_name`,  `order_date` from `order`";

        Connection conn = null;
        PreparedStatement ps = null;
        ResultSet rs = null;
        try {
            conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/test", "root", "123456");
            ps = conn.prepareStatement(sql);
            rs = ps.executeQuery();
            while (rs.next()) {
                Order order = new Order();
                order.setOrderId(rs.getInt(1));
                order.setOrderName(rs.getString(2));
                order.setOrderDate(rs.getDate(3));
                list.add(order);
            }

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (rs != null && !rs.isClosed()) {
                    rs.close();
                }
            } catch (SQLException e) {
                e.printStackTrace();
            }
            try {
                if (ps != null && !ps.isClosed()) {
                    ps.close();
                }
            } catch (SQLException e) {
                e.printStackTrace();
            }
            try {
                if (conn != null && !conn.isClosed()) {
                    conn.close();
                }
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        return list;
    }

    /**
     * 查询主键对应的记录
     * @param id
     * @return
     */
    public Order get(Integer id) {
        Order order = new Order();
        String sql = "SELECT `order_id`,  `order_name`,  `order_date` from `order` where `order_id` = ?";

        Connection conn = null;
        PreparedStatement ps = null;
        ResultSet rs = null;
        try {
            conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/test", "root", "123456");
            ps = conn.prepareStatement(sql);
            ps.setInt(1, id);
            rs = ps.executeQuery();
            while (rs.next()) {
                order.setOrderId(rs.getInt(1));
                order.setOrderName(rs.getString(2));
                order.setOrderDate(rs.getDate(3));
            }

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (rs != null && !rs.isClosed()) {
                    rs.close();
                }
            } catch (SQLException e) {
                e.printStackTrace();
            }
            try {
                if (ps != null && !ps.isClosed()) {
                    ps.close();
                }
            } catch (SQLException e) {
                e.printStackTrace();
            }
            try {
                if (conn != null && !conn.isClosed()) {
                    conn.close();
                }
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        return order;
    }

    /**
     * 添加
     * @param order
     * @return 返回语句影响的函数
     */
    public int insert(Order order) {
        int rows = 0;
        String sql = "insert into `order`( `order_name`,  `order_date`) values(?,?)";

        Connection conn = null;
        PreparedStatement ps = null;
        ResultSet rs = null;
        try {
            conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/test", "root", "123456");
            ps = conn.prepareStatement(sql);
            ps.setString(1, order.getOrderName());
            ps.setDate(2, new Date(order.getOrderDate().getTime()) );

            rows = ps.executeUpdate(); //执行修改,返回语句影响的行数

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (rs != null && !rs.isClosed()) {
                    rs.close();
                }
            } catch (SQLException e) {
                e.printStackTrace();
            }
            try {
                if (ps != null && !ps.isClosed()) {
                    ps.close();
                }
            } catch (SQLException e) {
                e.printStackTrace();
            }
            try {
                if (conn != null && !conn.isClosed()) {
                    conn.close();
                }
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        return rows;
    }

    /**
     * 删除
     * @param id
     * @return 返回语句影响的函数
     */
    public int delete(Integer id) {
        int rows = 0;
        String sql = "delete from `order` where order_id = ?";

        Connection conn = null;
        PreparedStatement ps = null;
        ResultSet rs = null;
        try {
            conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/test", "root", "123456");
            ps = conn.prepareStatement(sql);
            ps.setInt(1, id);

            rows = ps.executeUpdate(); //执行修改,返回语句影响的行数

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (rs != null && !rs.isClosed()) {
                    rs.close();
                }
            } catch (SQLException e) {
                e.printStackTrace();
            }
            try {
                if (ps != null && !ps.isClosed()) {
                    ps.close();
                }
            } catch (SQLException e) {
                e.printStackTrace();
            }
            try {
                if (conn != null && !conn.isClosed()) {
                    conn.close();
                }
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        return rows;
    }

    /**
     * 添加
     * @param order
     * @return 返回语句影响的函数
     */
    public int update(Order order) {
        int rows = 0;
        String sql = "update `order` set `order_name`=?, `order_date`=? WHERE `order_id` = ?";

        Connection conn = null;
        PreparedStatement ps = null;
        ResultSet rs = null;
        try {
            conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/test", "root", "123456");
            ps = conn.prepareStatement(sql);
            ps.setString(1, order.getOrderName());
            ps.setDate(2, new Date(order.getOrderDate().getTime()));
            ps.setInt(3, order.getOrderId());

            rows = ps.executeUpdate(); //执行修改,返回语句影响的行数

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (rs != null && !rs.isClosed()) {
                    rs.close();
                }
            } catch (SQLException e) {
                e.printStackTrace();
            }
            try {
                if (ps != null && !ps.isClosed()) {
                    ps.close();
                }
            } catch (SQLException e) {
                e.printStackTrace();
            }
            try {
                if (conn != null && !conn.isClosed()) {
                    conn.close();
                }
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        return rows;
    }
}

3.4 测试

ctrl+shift+t

UserDaoTest

package com.gk.c_crud.dao;

import com.gk.c_crud.domain.User;
import org.junit.Test;



public class UserDaoTest {
    UserDao userDao = new UserDao();

    @Test
    public void find() {
        for (User user : userDao.find()) {
            System.out.println(user);
        }
    }
    @Test
    public void findSingle(){
        System.out.println(userDao.findSingle());
    }
    @Test
    public void insert(){
        System.out.println(userDao.insert());
    }
    @Test
    public void delete(){
        System.out.println(userDao.delete());
    }
    @Test
    public void update(){
        System.out.println(userDao.update());
    }
     @Test
    public void update() {
        User user = new User(1, "张学友", "123", "香港", "110");
        userDao.update(user);
    }
}

OrderDaoTest

public class OrderDaoTest {

    OrderDao dao = new OrderDao();

    @Test
    public void find() {
        dao.find().forEach(o -> System.out.println(o));
    }

    @Test
    public void get() {
        System.out.println(dao.get(1));
    }

    @Test
    public void insert() {
        Order o = new Order(null, "华为", new Date());
        dao.insert(o);
    }

    @Test
    public void delete() {
    }

    @Test
    public void update() {
    }
}

3.5 JdbcUtil

创建属性文件jdbc.properties,配置连接字符串，驱动，用户，密码

user=root
password=123456
url=jdbc:mysql://localhost:3306/test
driverClass=com.mysql.cj.jdbc.Driver

JdbcUtil工具类，处理重复使用的方法

public class JdbcUtil {

    static String driver;
    static String url;
    static String user;
    static String password;

    static {
//        InputStream in = JdbcUtil.class.getResourceAsStream("/jdbc.properties");
        InputStream in = ClassLoader.getSystemClassLoader().getResourceAsStream("jdbc.properties");
        Properties pro = new Properties();
        try {
            pro.load(in);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
        driver = pro.getProperty("driverClass");
        url = pro.getProperty("url");
        user = pro.getProperty("user");
        password = pro.getProperty("password");

    }

    public static Connection getConnection() throws Exception {
        Class.forName(driver);
        return DriverManager.getConnection(url, user, password);
    }

    public static void closeResource(Connection conn, PreparedStatement ps, ResultSet rs) {
        try {
            if (rs != null && !rs.isClosed()) {
                rs.close();
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
        try {
            if (ps != null && !ps.isClosed()) {
                ps.close();
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
        try {
            if (conn != null && !conn.isClosed()) {
                conn.close();
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

使用

    /**
     * 查询所有
     * @return
     */
    public List<User> find() {
        List<User> list = new ArrayList<>(10);
        String sql = "SELECT `id`,  `name`,  `password`,  `address`,  `phone` from user";

        Connection conn = null;
        PreparedStatement ps = null;
        ResultSet rs = null;
        try {
            conn = JdbcUtil.getConnection();
            ps = conn.prepareStatement(sql);
            rs = ps.executeQuery();
            while (rs.next()) {
                User user = new User();
                user.setId(rs.getInt(1));
                user.setName(rs.getString(2));
                user.setPassword(rs.getString(3));
                user.setAddress(rs.getString("address"));
                user.setPhone("phone");
                list.add(user);
            }

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            JdbcUtil.closeResource(conn, ps, rs);
        }
        return list;
    }

3.6 ResultSet和ResultSetMetaData

3.6.1 ResultSet

查询需要调用PreparedStatement 的 executeQuery() 方法，查询结果是一个ResultSet 对象
ResultSet 对象以逻辑表格的形式封装了执行数据库操作的结果集，ResultSet 接口由数据库厂商提供实现
ResultSet 返回的实际上就是一张数据表。有一个指针指向数据表的第一条记录的前面。
ResultSet 对象维护了一个指向当前数据行的游标，初始的时候，游标在第一行之前，可以通过 ResultSet 对象的 next() 方法移动到下一行。调用 next()方法检测下一行是否有效。若有效，该方法返回 true，且指针下移。相当于Iterator对象的 hasNext() 和 next() 方法的结合体。
当指针指向一行时, 可以通过调用 getXxx(int index) 或 getXxx(int columnName) 获取每一列的值。
- 例如: getInt(1), getString(“name”)
- 注意：Java与数据库交互涉及到的相关Java API中的索引都从1开始。
ResultSet 接口的常用方法：
- boolean next()
- getString()
- …

3.6.2 ResultSetMetaData

可用于获取关于 ResultSet 对象中列的类型和属性信息的对象
ResultSetMetaData meta = rs.getMetaData();
- getColumnName(int column)：获取指定列的名称
- getColumnLabel(int column)：获取指定列的别名
- getColumnCount()：返回当前 ResultSet 对象中的列数。
- getColumnTypeName(int column)：检索指定列的数据库特定的类型名称。
- getColumnDisplaySize(int column)：指示指定列的最大标准宽度，以字符为单位。
- isNullable(int column)：指示指定列中的值是否可以为 null。
- isAutoIncrement(int column)：指示是否自动为指定列进行编号，这样这些列仍然是只读的。

问题1：得到结果集后, 如何知道该结果集中有哪些列？列名是什么？

需要使用一个描述 ResultSet 的对象，即 ResultSetMetaData

问题2：关于ResultSetMetaData

如何获取 ResultSetMetaData：调用 ResultSet 的 getMetaData() 方法即可
获取 ResultSet 中有多少列：调用 ResultSetMetaData 的 getColumnCount() 方法
获取 ResultSet 每一列的列的别名是什么：调用 ResultSetMetaData 的getColumnLabel() 方法

3.7 BaseDao

Dao层的基类，把Dao层重复的代码逻辑放到BaseDado中，减少开发

BaseDao

public class BaseDao<T> {

    Class<T> clazz;

    //得到当前对象，父类声明的返回类型

    {
        //获取当前BaseDAO的子类继承的父类中的第一个泛型
        //    - this = UserDao extends BaseDao<User>
        //    - this = OrderDao extends BaseDao<Order>
        Type genericSuperclass = this.getClass().getGenericSuperclass();
        ParameterizedType paramType = (ParameterizedType) genericSuperclass;

        Type[] typeArguments = paramType.getActualTypeArguments();//获取了父类的泛型参数
        clazz = (Class<T>) typeArguments[0];//泛型的第一个参数

    }

    /**
     * 查询List
     * @return
     */
    public List<T> findList(String sql, Object... params) {
        List<T> list = new ArrayList<>(10);

        Connection conn = null;
        PreparedStatement ps = null;
        ResultSet rs = null;
        try {
            conn = JdbcUtil.getConnection();
            ps = conn.prepareStatement(sql);

            //处理查询条件
            for (int i = 0; i < params.length; i++) {
                ps.setObject(i + 1, params[i]);
            }

            rs = ps.executeQuery();

            //查询结果的元数据（列名，类类型，类数量...)
            ResultSetMetaData metaData =  rs.getMetaData();
            int columnCount = metaData.getColumnCount(); //多少列

            while (rs.next()) {
                T instance = clazz.newInstance();
                for (int i = 0; i < columnCount; i++) {
                    //列的值
                    Object value = rs.getObject(i + 1);

                    //列名（约定：列名等于属性名）
                    String name = metaData.getColumnLabel(i + 1);

                    Field field = clazz.getDeclaredField(name);
                    field.setAccessible(true);
                    field.set(instance, value);
                }
                list.add(instance);
            }

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            JdbcUtil.closeResource(conn, ps, rs);
        }
        return list;
    }

    /**
     * 查询List
     * @return
     */
    public T findOne(String sql, Object... params) {
        T instance  = null;

        Connection conn = null;
        PreparedStatement ps = null;
        ResultSet rs = null;
        try {
            conn = JdbcUtil.getConnection();
            ps = conn.prepareStatement(sql);
            //处理查询条件
            for (int i = 0; i < params.length; i++) {
                ps.setObject(i + 1, params[i]);
            }
            rs = ps.executeQuery();

            //查询结果的元数据（列名，类类型，类数量...)
            ResultSetMetaData metaData =  rs.getMetaData();
            int columnCount = metaData.getColumnCount(); //多少列

            while (rs.next()) {
                instance = clazz.newInstance();

                for (int i = 0; i < columnCount; i++) {
                    //列的值
                    Object value = rs.getObject(i + 1);

                    //列名（约定：列名等于属性名）
                    String name = metaData.getColumnLabel(i + 1);

                    Field field = clazz.getDeclaredField(name);
                    field.setAccessible(true);
                    field.set(instance, value);
                }
            }

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            JdbcUtil.closeResource(conn, ps, rs);
        }
        return instance;
    }

    /**
     *
     * @param sql：语句
     * @param params：?参数
     * @return
     */
    public int update(String sql, Object... params) {
        int rows = 0;

        Connection conn = null;
        PreparedStatement ps = null;
        ResultSet rs = null;
        try {
            conn = JdbcUtil.getConnection();
            ps = conn.prepareStatement(sql);
            for (int i = 0; i < params.length; i++) {
                ps.setObject(i + 1, params[i]);
            }

            rows = ps.executeUpdate(); //执行修改,返回语句影响的行数

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            JdbcUtil.closeResource(conn, ps, rs);
        }
        return rows;
    }
}

public class UserDao extends BaseDao<User> {

    /**
     * 查询所有
     * @return
     */
    public List<User> find() {
        String sql = "SELECT `id`,  `name`,  `password`,  `address`,  `phone` from user";
        return super.findList(sql);
    }

    /**
     * 查询主键对应的记录
     * @param id
     * @return
     */
    public User get(Integer id) {
        String sql = "SELECT `id`,  `name`,  `password`,  `address`,  `phone` from user where id = ?";
        return super.findOne(sql, id);
    }

    /**
     * 添加
     * @param user
     * @return 返回语句影响的函数
     */
    public int insert(User user) {
        String sql = "insert into user(`name`, `password`, `address`, `phone`) values(?,?,?,?)";
        return super.update(sql, user.getName(), user.getPassword(), user.getAddress(), user.getPhone());
    }

    /**
     * 删除
     * @param id
     * @return 返回语句影响的函数
     */
    public int delete(Integer id) {
        String sql = "delete from user where id = ?";
        return super.update(sql, id);
    }

    /**
     * 添加
     * @param user
     * @return 返回语句影响的函数
     */
    public int update(User user) {
        String sql = "update user set `name`=?, `password`=?,  `address`=?,  `phone`=? WHERE `id` = ?";
        return super.update(sql, user.getName(), user.getPassword(), user.getAddress(), user.getPhone(), user.getId());

    }
}