JDBC基本使用

最新推荐文章于 2023-06-02 19:10:32 发布

嘻嘻你好呀

最新推荐文章于 2023-06-02 19:10:32 发布

阅读量1.2k

点赞数

分类专栏： java 文章标签：数据库 sql mysql

本文链接：https://blog.csdn.net/weixin_46049759/article/details/121915740

版权

java 专栏收录该内容

63 篇文章 5 订阅

订阅专栏

JDBC

https://github.com/sanshisi/JDBC_Study.git

MySql – 8.0.20

Java – 11.0.11

2021.12.12

=====emp表的结构=====
+---------+-------------+------+-----+---------+----------------+
| Field   | Type        | Null | Key | Default | Extra          |
+---------+-------------+------+-----+---------+----------------+
| id      | int         | NO   | PRI | NULL    | auto_increment |
| name    | varchar(10) | YES  |     | NULL    |                |
| dept_id | int         | YES  |     | NULL    |                |
+---------+-------------+------+-----+---------+----------------+

=====dept表的结构=====
+-------+-------------+------+-----+---------+-------+
| Field | Type        | Null | Key | Default | Extra |
+-------+-------------+------+-----+---------+-------+
| id    | int         | YES  |     | NULL    |       |
| name  | varchar(10) | YES  |     | NULL    |       |
| intro | varchar(10) | YES  |     | NULL    |       |
+-------+-------------+------+-----+---------+-------+

1.JDBC介绍

JDBC(Java DataBase Connectivity)是Java和数据库之间的一个桥梁，是一个规范而不是一个实现，能够执行SQL语句。

JDBC(Java Database Connectivity)是一个独立于特定数据库管理系统、通用的 SQL 数据库存取和操作的公共接口（一组 API)，定义了用来访问数据库的标准Java 类库,(java.sql,javax.sql)使用这个类库可以以一种标准的方法、方便地访问数据库资源

JDBC 为访问不同的数据库提供了一种统一的途径，为开发者屏蔽了一些细节问题JDBC 的目标是使 Java 程序员使用 JDBC 可以连接任何提供了 JDBC 驱动程序的数据库系统，这样就使得程序员无需对特定的数据库系统的特点有过多的了解，从而大大简化和加快了开发过程

2.链接数据库

package com.blog;

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

public class TestConnection {
    public static void main(String[] args) {
        try {
            // 1.加载驱动 [可以不写]
            Class.forName("com.mysql.cj.jdbc.Driver");

            // 2.通过DriverManager类来获取驱动
            // 2.1 提供Properties的对象，指明用户名和密码
            // 因为是本地链接,所以jdbc:mysql://localhost:3306/db_web...可以简写
            DriverManager.getConnection("jdbc:mysql:///db_web?user=root&password=root&serverTimezome=Asia/Shanghai");
            //Properties 该类主要用于读取Java的配置文件
//            Properties info = new Properties();
//            info.setProperty("user", "root");
//            info.setProperty("password", "root");
//            info.setProperty("serverTimezone", "Asia/Shanghai"); // 设置时区
//            DriverManager.getConnection("jdbc:mysql:///db_web", info);

            // 2.2 直接在获取驱动时传入
            Connection connection = DriverManager.getConnection("jdbc:mysql:///db_web?serverTimezone=Asia/Shanghai",
                    "root", "root");

            System.out.println(connection); // 输出获取的connection
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }
    }
}

通过配置文件链接数据库

@Test
public void testFile() {
    try {

        // 最终解决 硬编码问题
        // Properties 主要用于读取Java配置文件信息
        Properties properties = new Properties();
        properties.load(this.getClass().getClassLoader().getResourceAsStream("jdbc.properties"));

        String classDriver = properties.getProperty("jdbc.classDriver");
        String url = properties.getProperty("jdbc.url");
        String user = properties.getProperty("jdbc.user");
        String password = properties.getProperty("jdbc.password");

        // 加载驱动
        Class.forName(classDriver);
        Connection connection = null;
        // 传入参数
        connection = DriverManager.getConnection(url, user, password);
        System.out.println(connection);
    } catch (IOException e) {
        e.printStackTrace();
    } catch (ClassNotFoundException e) {
        e.printStackTrace();
    } catch (SQLException throwables) {
        throwables.printStackTrace();
    }
}

配置文件声明在工程的 src 目录下：【jdbc.properties】

jdbc.classDriver=com.mysql.cj.jdbc.Driver
jdbc.url=jdbc:mysql:///db_web?serverTimezone=Asia/Shanghai
jdbc.user=root
jdbc.password=root

3.PreparedStatement 实现 CRUD 操作

**CRUD：**增加(Create)、检索(Retrieve)、更新(Update)和删除(Delete)

🍕Statement：用于执行静态 SQL 语句并返回它所生成结果的对象

🍕PrepatedStatement：SQL 语句被预编译并存储在此对象中，可以使用此对象多次高效地执行该语句

🍕CallableStatement：用于执行 SQL 存储过程

3.1 Statement操作数据表

在 Java 早期使用的是Statement 接口来操作 SQL，但是因为这用字符串拼接 SQL 的方式完成 SQL 语句的，容易引发 SQL 注入漏洞问题，所以现在几乎都不再是用来，取而代之的则是使用 PreparedStatement 接口

通过调用Connection对象的 createStatement()方法创建该对象。该对象用于执行静态的 SQL 语句，并且返回执行结果

execute(sql)   		执行SQL，返回值是个boolean值，表示是否成功，主要用来执行 create drop等等语句（主要用于初始化）
executeBatch() 				   用于执行批量SQL
statement.executeQuery(sql)    用于查询语句（DQL）
statement.executeUpdate(sql)   主要用于DML语句 返回的是

Statement做插入和查询

package com.blog;

import com.study001.Emp;
import org.junit.Test;

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

public class TestStatement {
    @Test
    public void InnerTest() {
        try {
            // 1.加载驱动
            Class.forName("com.mysql.cj.jdbc.Driver");
            // 2.通过DriverManager类获取数据库链接
            Connection connection = DriverManager.getConnection("jdbc:mysql:///db_web?serverTimezone=Asia/Shanghai",
                    "root", "root");
            // 3.获取Statement对象
            Statement statement = connection.createStatement();

            String sql = "insert emp(id,name,dept_id) values(10,'小鱼二',3)";
            int count = statement.executeUpdate(sql);
            System.out.println(sql);
            if (count > 0) {
                System.out.println("count=" + count + ",插入成功");
            } else {
                System.out.println("count=" + count + ",插入失败");
            }

        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }
    }

    @Test
    public void QueryAllTest() {
        Connection connection = null; // 获取数据库链接
        Statement statement = null; // 获取Statement对象进行CRUD操作
        ResultSet resultSet = null; // 接受 statement.executeQuery(sql) 查询对象

        List<com.study001.Emp> emps = new ArrayList<>();
        Emp emp = null;
        try {
            // 1.加载驱动
            Class.forName("com.mysql.cj.jdbc.Driver");
            // 2.通过DriverManager类获取数据库链接
            connection = DriverManager.getConnection("jdbc:mysql:///db_web?serverTimezone=Asia/Shanghai",
                    "root", "root");
            // 3.获取Statement对象
            statement = connection.createStatement();

            String sql = "select id,name,dept_id from emp"; // 在真正开发时不能使用 select *
            resultSet = statement.executeQuery(sql);
            // 因为可能存在多条数据，所以使用循环不断的取值，直到没有值为止
            while (resultSet.next()) {
                // 进入循环，意味着开始读取一行数据2211
                // sql中的顺序都是从1开始的
//                int id = resultSet.getInt(1);
//                String name = resultSet.getString(2);
//                int deptId = resultSet.getInt(3);
                int id = resultSet.getInt("id");
                String name = resultSet.getString("name");
                int deptId = resultSet.getInt("dept_Id");
//                System.out.println("id=" + id + ", name=" + name + ", dept_id=" + deptId); 
                emp = new Emp(id,name,deptId);
                emps.add(emp);
            }
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        } finally {
            // 释放资源
            this.closeResource(connection, statement, resultSet);
        }
        // 使用方法引用对emps进行遍历
        emps.forEach(System.out::println);
    }

    // 做一个公共的关闭资源的工具
    public static void closeResource(Connection connection, Statement statement, ResultSet resultSet) {
        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();
            }
        }
    }
}

✨emp.java

package com.blog;

public class Emp {
    private Integer id;
    private String name;
    private Integer deptId;

    public Emp(Integer id, String name, Integer dept_id) {
        this.id = id;
        this.name = name;
        this.deptId = dept_id;
    }

    @Override
    public String toString() {
        return "Emp{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", dept_id=" + deptId +
                '}';
    }
}

释放资源

释放 ResultSet, Statement,Connection

数据库连接（Connection）是非常稀有的资源，用完后必须马上释放，如果 Connection不能及时正确的关闭将导致系统宕机。Connection的使用原则是尽量晚创建，尽量早的释放

可以在 finally中关闭，保证及时其他代码出现异常，资源也一定能被关闭

SQL 注入

SQL 注入是利用某些系统没有对用户输入的数据进行充分的检查，而在用户输入数据中注入非法的 SQL 语句段或命令(如：SELECT user, password FROM user_table WHEREuser='a' OR 1 = ' AND password = ' b'1' ='1') ，从而利用系统的 SQL 引擎完成恶意行为的做法。对于 Java 而言，要防范 SQL 注入，只要用 PreparedStatement(从 Statement 扩展而来) 取代 Statement 就可以了

3.2 PreparedStatement操作数据表

可以通过调用 Connection 对象的 preparedStatement(String sql) 方法获取PreparedStatement对象

PreparedStatement 接口是 Statement 的子接口，它表示一条预编译过的 SQL 语句PreparedStatement 对象所代表的 SQL 语句中的参数用问号 (?) 来表示，调用PreparedStatement对象的setXxx()方法来设置这些参数.

setXxx()方法有两个参数，第一个参数是要设置的 SQL语句中的参数的索引(从 1 开始)，第二个是设置的 SQL 语句中的参数的值

PrepareStatement 做插入

其它操作会在工具类中统一给出

@Test
public void testPs() {
    Connection connection = null;
    PreparedStatement ps = null;
    ResultSet rs = null;
    Scanner sc = new Scanner(System.in);
    try {
        connection = DriverManager
            .getConnection("jdbc:mysql:///db_web?serverTimezone=Asia/Shanghai",
                           "root", "root");
        System.out.print("请输入用户名:");
        String name = sc.nextLine().trim(); // 去除空格
        System.out.print("请输入密码:");
        String password = sc.nextLine().trim(); // 去除空格

        String sql = "select * from t_user where name = ? and password = ?";
        System.out.println(sql);
        ps = connection.prepareStatement(sql);

        ps.setString(1,name);
        ps.setString(2,password);

        rs = ps.executeQuery();
        if (rs.next()) {
            System.out.println("登录成功");
        } else {
            System.out.println("登录失败");
        }
    } catch (SQLException throwables) {
        throwables.printStackTrace();
    } finally {
        sc.close();
        closeResource(connection, ps, rs);
    }
}

3.3 ResultSet 与 ResultSetMetaData

3.3.1 ResultSet

查询需要调用PreparedStatement 的 executeQuery()方法，查询结果是一个ResultSet对象

ResultSet 对象以逻辑表格的形式封装了执行数据库操作的结果集，ResultSet 接口由数据库厂商提供实现’

ResultSet 返回的实际上就是一张数据表。有一个指针指向数据表的第一条记录的前面。

ResultSet 对象维护了一个指向当前数据行的游标，初始的时候，游标在第一行之前，可以通过 ResultSet 对象的 next() 方法移动到下一行。调用 next()方法检测下一行是否有效。若有效，该方法返回 true，且指针下移。相当于Iterator 对象的 hasNext()和 next()方法的结合体。当指针指向一行时 , 可以通过调用 getXxx(int index)或 getXxx(intcolumnName) 获取每一列的值。

例如: getInt(1), getString("name")

注意：Java 与数据库交互涉及到的相关 Java API 中的索引都从 1 开始。

✨ResultSet 接口的常用方法：

boolean next()

getString()

3.3.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):指示是否自动为指定列进行编号，这样这些列仍然是只读的

@Test
void testResultSetMetaData() {
    Connection connection = null;
    PreparedStatement ps = null;
    try {
        connection = DriverManager
            .getConnection("jdbc:mysql:///db_web?serverTimezone=Asia/Shanghai", 
                           "root", "root");
		// 获取PrepareStatement对象
        ps = connection.prepareStatement("select id, name userName, age, intros from t_user");

        // 获取ResultSetMetaData对象
        ResultSetMetaData metaData = ps.getMetaData();

        System.out.println("查询的字段的数量:"+ metaData.getColumnCount());
        System.out.println("查询的结果的列的名称:"+ metaData.getColumnName(2));
        System.out.println("查询的结果的字段的名称(别名):"+ metaData.getColumnLabel(2));

    } catch (SQLException e) {
        e.printStackTrace();
    } finally {
        TestConnection.closeResource(connection, ps, null);
    }
}

4.JDBC通用工具类的实现

一般在开发中，我们会封装数据，实现一些好用的工具类

`PropertieUtil.java`

通过传入配置文件的名称获取 Properties 对象

package com.util;

import java.io.IOException;
import java.util.Properties;

public class PropertieUtil {
    private static Properties properties;

    public static Properties getProperties(String name) {
        if (properties == null) {
            properties = new Properties();
        }
        try {
            // 获取配置文件 properties
            properties.load(PropertieUtil.class.getClassLoader().getResourceAsStream(name));
        } catch (IOException e) {
            e.printStackTrace();
        }
        return properties;
    }
}

`DbUtil.java`

进一步获取 Connection 对象

package com.util;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.Properties;

public class DbUtil {
    public static Connection getConnectionByJdbc() {
        Properties prop = PropertieUtil.getProperties("jdbc.properties"); // 通过配置文件获取 properties
        String CalssDrive = prop.getProperty("jdbc.classDriver");
        String url = prop.getProperty("jdbc.url");
        String user = prop.getProperty("jdbc.user");
        String password = prop.getProperty("jdbc.password");

        // 加载驱动
        try {
            Class.forName(CalssDrive);
            Connection conn = DriverManager.getConnection(url,user,password);
            return conn;
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }
        return null;
    }
}

`DBHepler.java`

执行 DML 操作

package com.util;

import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.sql.*;
import java.util.ArrayList;
import java.util.List;


public class DBHepler {
    /**
     * 功能:更新工具方法DML语句 (增删改查操作)
     *
     * @param sql  DML SQL
     * @param args 问号的参数
     * @return 影响的行数
     */
    public static int update(String sql, Object... args) {
        Connection connection = null;
        PreparedStatement ps = null;
        try {
            connection = DbUtil.getConnectionByJdbc();
            ps = connection.prepareStatement(sql);
            for (int i = 0; i < args.length; i++) {
                ps.setObject(i + 1, args[i]);
            }
            int count = ps.executeUpdate();
            return count;
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        } finally {
            closeResource(connection, ps, null);
        }
        return 0;
    }

    /***
     * 封装查询所有对象的结果集,返回的泛型对象的List
     *
     * @param <T>  对象类型
     * @param clzz 对象的字节码文件
     * @param sql  查询SQL
     * @param args 问号的参数
     * @return 泛型对象的List, 表示符合条件的所有数据库记录(对象)
     */
    public static <T> T queryOne(Class<T> clzz, String sql, Object... args) {
        Connection connection = null;
        PreparedStatement ps = null;
        ResultSet rs = null;
        T t = null;
        connection = DbUtil.getConnectionByJdbc();
        try {
            ps = connection.prepareStatement(sql);
            // 为?赋值
            for (int i = 0; i < args.length; i++) {
                ps.setObject(i + 1, args[i]);
            }
            rs = ps.executeQuery();
            ResultSetMetaData metaData = ps.getMetaData();
            if (rs.next()) {
                // 通过反射获取对象
                t = clzz.getConstructor().newInstance();
                int columCount = metaData.getColumnCount();
                for (int i = 1; i <= columCount; i++) {
                    // 通过下标获取列的别名
                    // 此处应当注意 获取的是别名 而别名应当是 Emp类 中的属性
                    String columnLabel = metaData.getColumnLabel(i);
                    Object columValue = rs.getObject(columnLabel);

                    // 通过反射获取属性
                    Field field = clzz.getDeclaredField(columnLabel);
                    field.setAccessible(true); // 解除属性私有性的影响
                    field.set(t, columValue);
                }
            }
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (NoSuchFieldException e) {
            e.printStackTrace();
        }
        return t;
    }

    /***
     * 封装查询所有对象的结果集,返回的泛型对象的List
     *
     * @param <T>  对象类型
     * @param clzz 对象的字节码文件
     * @param sql  查询SQL
     * @param args 问号的参数
     * @return 泛型对象的List, 表示符合条件的所有数据库记录(对象)
     */
    public static <T> List<T> queryAll(Class<T> clzz, String sql, Object... args) {
        Connection connection = null;
        PreparedStatement ps = null;
        ResultSet rs = null;
        List<T> list = new ArrayList<>();
        T t = null;
        try {
            connection = DbUtil.getConnectionByJdbc();
            ps = connection.prepareStatement(sql);

            for (int i = 0; i < args.length; i++) {
                ps.setObject(i + 1, args[i]);
            }

            rs = ps.executeQuery();
            ResultSetMetaData metaData = ps.getMetaData();

            while (rs.next()) {
                t = clzz.getConstructor().newInstance();
                int columnCount = metaData.getColumnCount();
                for (int i = 1; i <= columnCount; i++) {
                    String columnLabel = metaData.getColumnLabel(i);
                    Object columnValue = rs.getObject(columnLabel);
                    Field field = clzz.getDeclaredField(columnLabel);
                    field.setAccessible(true);
                    field.set(t, columnValue);
                }
                list.add(t);
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } catch (NoSuchFieldException e) {
            e.printStackTrace();
        } catch (SecurityException e) {
            e.printStackTrace();
        } catch (IllegalArgumentException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } finally {
            closeResource(connection, ps, rs);
        }
        return list;
    }

    // 公共的关闭资源的工具
    private static void closeResource(Connection connection, PreparedStatement ps, ResultSet resultSet) {
        if (resultSet != null) {
            try {
                resultSet.close();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }

        if (connection != null) {
            try {
                connection.close();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }
        if (ps != null) {
            try {
                ps.close();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }
    }
}

`TestUtil.java`

package com.util;

import com.study001.Emp;
import org.junit.Test;

import java.util.List;

public class TestUtil {
    @Test
    public void test00() {
        String sql = "insert emp(id,name,dept_id) values(?,?,?)";
        int count = DBHepler.update(sql, 21, "小小鱼", 3);
        if (count>0) {
            System.out.println("插入成功");
        } else {
            System.out.println("插入失败");
        }
    }

    @Test
    public void test01() {
        String sql = "select id,name,dept_id deptId from emp";
        Emp emp = DBHepler.queryOne(Emp.class, sql);
        System.out.println(emp);
    }

    @Test
    public void test02() {
        String sql = "select id,name,dept_id deptId from emp";
        List<Emp> emps = DBHepler.queryAll(Emp.class, sql);
        emps.forEach(System.out::println);
    }
}

工具类小结

✨解释一下关于别名的问题

……
rs = ps.executeQuery();// 获取了 ResultSet 对象
ResultSetMetaData metaData = ps.getMetaData();// 获取了 ResultSetMetaData 对象
if (rs.next()) {
    // 通过反射获取对象
    // getConstructor() 获取构造方法  newInstance() 实例化改对象[该类必须已经加载过]
    t = clzz.getConstructor().newInstance(); // 最终获得的是 Emp 对象
    int columCount = metaData.getColumnCount(); // 获取列数
    for (int i = 1; i <= columCount; i++) {
        // 通过下标获取列的别名
        // 此处是为了保证后面通过反射获取属性能获取成功,即保证 获取到的别名和Emp对象中对应的属性名相同
        String columnLabel = metaData.getColumnLabel(i);
        Object columValue = rs.getObject(columnLabel); // 通过别名获取对应的值 [通过下标也可以]
        //                    Object columValue = rs.getObject(i);

        // 通过反射获取属性
        // 如果传入的别名与Emp中对应的属性名不同,该处就会获取不到属性
        Field field = clzz.getDeclaredField(columnLabel);
        field.setAccessible(true); // 解除属性私有性的影响
        field.set(t, columValue); // 将对应的值传入Emp对象中
    }
}
……

5.JDBC API小结

两种思想：

面向接口编程的思想
ORM 思想(object relational mapping)

ORM思想:

这就是为什么要查询语句中字段对应的别名要与其对应的对象的属性一样

一个数据表对应一个 java 类

表中的一条记录对应 java 类的一个对象

表中的一个字段对应 java 类的一个属性

**注意:**sql 是需要结合列名和表的属性名来写。注意起别名。

两种技术

JDBC 结果集的元数据：ResultSetMetaData

DatabaseMetaData 类中提供了许多方法用于获得数据源的各种信息，通过这些方法可以非常详细的了解数据库的信息

获取列数：getColumnCount()

获取列的别名：getColumnLabel()

通过反射，创建指定类的对象，获取指定的属性并赋值

6.DAO

DAO：Data Access Object 访问数据信息的类和接口，包括了对数据的 CRUD（Create、Retrival、Update、Delete），而不包含任何业务相关的信息。作用：为了实现功能的模块化，更有利于代码的维护和升级。

首先看一下项目结构

📒dao
	📒impl
		[接口实现类]
        BaseDaoImpl.java
        DeptDaoImpl.java
        EmpDaoImpl.java
	[接口]
	BaseDao.java
	DeptDao.java
	EmpDao.java
📒daoTest
	dao测试类
📒entity
	[实体类]
	Dept.java
	Emp.java

1.📒entity

📒entity
[实体类]
Dept.java
Emp.java

2.📒dao

📒dao
📒impl
[接口实现类]
BaseDaoImpl.java
DeptDaoImpl.java
EmpDaoImpl.java
[接口]
BaseDao.java
DeptDao.java
EmpDao.java

2.1接口

BaseDao.java

package com.dao;

import java.util.List;

public interface BaseDao<T> {
    /**
     * 增删改操作
     * @param sql
     * @param args
     * @return
     */
    int update(String sql, Object... args);

    /**
     * 封装查询一个对象
     *
     * @param sql  查询SQL
     * @param args 问号的参数
     * @return 一个clzz对应的对象T
     */
    T queryOne(String sql, Object... args);

    /***
     * 	封装查询所有对象的结果集,返回的泛型对象的List
     * @param sql 查询SQL
     * @param args 问号的参数
     * @return 泛型对象的List, 表示符合条件的所有数据库记录(对象)
     */
    List<T> queryAll(String sql, Object... args);
    
}

2.2接口实现类

2.2.1 BaseDaoImpl.java

package com.dao.Impl;

import com.dao.BaseDao;
import com.study002.DbUtil;

import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.sql.*;
import java.util.ArrayList;
import java.util.List;

@SuppressWarnings("unchecked")
public class BaseDaoImpl<T> implements BaseDao<T> {

    // 定义一个变量来接收泛型的类型
    private Class<T> clzz;

    {
        //获取当前BaseDAO的子类继承的父类中的泛型
        Type genericSuperclass = this.getClass().getGenericSuperclass();
        ParameterizedType paramType = (ParameterizedType) genericSuperclass;
        //获取了父类的泛型参数
        Type[] typeArguments = paramType.getActualTypeArguments();
        //泛型的第一个参数
        clzz = (Class<T>) typeArguments[0];
    }

    @Override
    public int update(String sql, Object... args) {
        Connection connection = null;
        PreparedStatement ps = null;
        try {
            connection = DbUtil.getConnectionByJdbc();
            ps = connection.prepareStatement(sql);
            for (int i = 0; i < args.length; i++) {
                ps.setObject(i + 1, args[i]);
            }
            int count = ps.executeUpdate();
            return count;
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            closeResource(connection, ps, null);
        }
        return 0;
    }

    @Override
    /**
     * 	封装查询一个对象
     * @param <T> 对象类型
     * @param clzz 对象的字节码文件
     * @param sql 查询SQL
     * @param args 问号的参数
     * @return 一个clzz对应的对象T
     */
    public T queryOne(String sql, Object...args) {
        Connection connection = null;
        PreparedStatement ps = null;
        ResultSet rs = null;
        T t = null;
        try {
            connection = DbUtil.getConnectionByJdbc();
            ps = connection.prepareStatement(sql);
            // 为?赋值
            for (int i = 0; i < args.length; i++) {
                ps.setObject(i + 1, args[i]);
            }
            rs = ps.executeQuery();
            ResultSetMetaData metaData = ps.getMetaData();
            if (rs.next()) {
                // 通过反射获取对象
                t = (T) clzz.getConstructor().newInstance();
                int columnCount = metaData.getColumnCount();
                for (int i = 1; i <= columnCount; i++) {
                    // 通过下标获取列的名称
                    // String colunmName = metaData.getColumnName(i);
                    // 通4RFC 4RC过下标获取列的别名(就是对象的属性的名称)
                    String columnLabel = metaData.getColumnLabel(i);
                    Object columnValue = rs.getObject(columnLabel);

                    // 通过反射获取属性
                    Field field = clzz.getDeclaredField(columnLabel);
                    field.setAccessible(true);
                    field.set(t, columnValue);
                }
            }

        } catch (SQLException e) {
            e.printStackTrace();
        } catch (NoSuchFieldException e) {
            e.printStackTrace();
        } catch (SecurityException e) {
            e.printStackTrace();
        } catch (IllegalArgumentException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } finally {
            closeResource(connection, ps, rs);
        }
        return t;
    }

    @Override
    /***
     * 	封装查询所有对象的结果集,返回的泛型对象的List
     * @param <T> 对象类型
     * @param clzz 对象的字节码文件
     * @param sql 查询SQL
     * @param args 问号的参数
     * @return 泛型对象的List,表示符合条件的所有数据库记录(对象)
     */
    public List<T> queryAll(String sql, Object...args) {
        Connection connection = null;
        PreparedStatement ps = null;
        ResultSet rs = null;
        List<T> list = new ArrayList<>();
        T t = null;
        try {
            connection = DbUtil.getConnectionByJdbc();
            ps = connection.prepareStatement(sql);

            for (int i = 0; i < args.length; i++) {
                ps.setObject(i + 1, args[i]);
            }

            rs = ps.executeQuery();
            ResultSetMetaData metaData = ps.getMetaData();

            while (rs.next()) {
                t = clzz.getConstructor().newInstance();
                int columnCount = metaData.getColumnCount();
                for (int i = 1; i <= columnCount; i++) {
                    // 通过下标获取列的名称
                    // String colunmName = metaData.getColumnName(i);
                    // 通过下标获取列的别名(就是对象的属性的名称)
                    String columnLabel = metaData.getColumnLabel(i);
                    Object columnValue = rs.getObject(columnLabel);
                    Field field = clzz.getDeclaredField(columnLabel);

                    // 通过反射获取属性
                    field.setAccessible(true);
                    field.set(t, columnValue);
                }
                list.add(t);
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } catch (NoSuchFieldException e) {
            e.printStackTrace();
        } catch (SecurityException e) {
            e.printStackTrace();
        } catch (IllegalArgumentException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } finally {
            closeResource(connection, ps, rs);
        }
        return list;
    }

    // 做一个公共的关闭资源的工具
    public void closeResource(Connection connection, PreparedStatement ps, ResultSet resultSet) {
        if (resultSet != null) {
            try {
                resultSet.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if (ps != null) {
            try {
                ps.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if (connection != null) {
            try {
                connection.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
}

2.2.2 DeptDaoImpl.java

package com.dao.Impl;

import com.dao.DeptDao;
import com.entity.Dept;

import java.util.List;

public class DeptDaoImpl extends BaseDaoImpl<Dept> implements DeptDao {
    @Override
    public void update(Dept dept) {
        super.update("update dept set name=?,intro=? where id = ? ",dept.getName(),dept.getName(),dept.getInfo());
    }

    @Override
    public void delete(int id) {
        super.update("delete from dept where id = ? ",id);
    }

    @Override
    public void delete(Dept dept) {
        // 必须要所有属性全对上才能删除
        super.update("delete from dept  where  id = ? and name = ? and intro = ?",dept.getId(),dept.getName(),dept.getInfo());
    }

    @Override
    public void add(Dept dept) {
        super.update("insert into dept(id,name,intro) values(?,?,?)",dept.getId(),dept.getName(),dept.getInfo());
    }

    @Override
    public Dept findById(int id) {
        Dept dept = super.queryOne("select id,name,intro from dept where id = ?", id);
        return dept;
    }

    @Override
    public List<Dept> findAll() {
        List<Dept> depts = super.queryAll("select id,name,intro from dept ");
        return depts;
    }
}

2.2.3 EmpDaoImpl.java

package com.dao.Impl;

import com.dao.EmpDao;
import com.entity.Emp;

import java.util.List;

public class EmpDaoImpl extends BaseDaoImpl<Emp> implements EmpDao {
    @Override
    public void update(Emp emp) {
        super.update("update emp set name=?,dept_id=? where id = ? ",emp.getName(),emp.getDeptId(),emp.getId());
    }

    @Override
    public void delete(int id) {
        super.update("delete from emp  where id = ? ",id);
    }

    @Override
    public void delete(Emp emp) {
        // 必须要所有属性全对上才能删除
        super.update("delete from emp  where  id = ? and name = ? and dept_id = ?",emp.getId(),emp.getName(),emp.getDeptId());
    }

    @Override
    public void add(Emp emp) {
        super.update("insert into emp(id,name,dept_id) values(?,?,?)",emp.getId(),emp.getName(),emp.getDeptId());
    }

    @Override
    public Emp findById(int id) {
        Emp emp = super.queryOne("select id,name,dept_id deptId from emp where id = ?", id);
        return emp;
    }

    @Override
    public List<Emp> findAll() {
//        List<Emp> emps = super.queryAll("select id,name,dept_id from emp");
        List<Emp> emps = super.queryAll("select id,name,dept_id deptId from emp where dept_id = ?",2);
        return emps;
    }
}

2.2测试类

package com.daoTest;

import com.dao.Impl.EmpDaoImpl;
import com.entity.Emp;
import org.junit.Test;

import java.util.List;

public class DaoTest {
    @Test
    public void test01() {
        // 测试插入
        Emp e1 = new Emp(8, "小周", 3);
//        Emp e2 = new Emp(9, "小黄", 4);

        EmpDaoImpl daoEmp = new EmpDaoImpl();
        daoEmp.add(e1);
//        daoEmp.add(e2);
    }

    @Test
    public void test02() {
        // 测试更新
//        Emp e = new Emp(8, "小周", 3);
        Emp e = new Emp(8, "小周来啦", 2);

        EmpDaoImpl daoEmp = new EmpDaoImpl();
        daoEmp.update(e);
    }

    @Test
    public void test03() {
        // 测试删除
        Emp e = new Emp(8, "小周", 3);

        EmpDaoImpl daoEmp = new EmpDaoImpl();
        daoEmp.delete(e);
//        daoEmp.delete(1);
    }

    @Test
    public void test04() {
        // 测试查询
        Emp e = new Emp(8, "小周", 3);


        EmpDaoImpl daoEmp = new EmpDaoImpl();
//        Emp byId = daoEmp.findById(e.getId());
//        System.out.println(byId);

        List<Emp> emps = daoEmp.findAll();
        emps.forEach(System.out::println);
    }

    public static void main(String[] args) {
        // 测试查询
        Emp e = new Emp(8, "小周", 3);


        EmpDaoImpl daoEmp = new EmpDaoImpl();
//        Emp byId = daoEmp.findById(e.getId());
//        System.out.println(byId);

        List<Emp> emps = daoEmp.findAll();
        emps.forEach(System.out::println);
    }
}