【JavaSE】JDBC(一):基础(本质，操作步骤，类对象详解，工具类，事务)

  JDBC第一部分基础，趁最近在回顾知识，趁热总结完。想想每次要用到数据库时，自己回来翻书、找文档的模样，就很真实。所以总结JDBC技术基础，连接数据库步骤，如何应用，以供快速回顾。连接MySQL数据库为例，后续会有进阶。进入正题

1.为什么需要JDBC

  做应用程序肯定会用到数据，用数据那必然涉及到操作某个数据库。作为一个Java程序员，写了一些代码想来操作数据库，但数据库有很多不同的产品(MySQL、Oracle、DB2等等)，那这个程序员写的同一套Java代码能不能操作MySQL、Oracle、DB2等关系型数据库呢？好像不太可能，一样的Java代码怎么可能操作不同的数据库呢，因为每一种数据库结构是不一样的。如果不能，那程序员就疯了，比如要用到以上三种数据库，程序员就要学习Java代码如何操作MySQL、Java代码如何操作Oracle、Java代码如何操作DB2，市面上这么多数据库，是不是就要学这么多套操作数据库的方式，那学着学着必然懵了。
  所以这个时候就有了需求，期望使用统一的一套Java代码可以操作所有的关系型数据库。如何实现这个期望呢，Sun公司程序员写了一套Java代码，并取名JDBC，它定义了一套操作所有关系型数据库的规则(接口)。
  这里可能会有个疑问，接口怎么操作数据库？当然是用接口的实现类来操作咯，Sun公司只定义了接口，而实现类是由不同的数据库厂商提供的，这些实现类就可以操作他们自己的数据库，每一个实现类都实现了相同的一套JDBC接口。这里就可以知道，后面不同的数据库驱动程序(Jar包)就是不同的厂商提供的JDBC实现类。
  小结一下，对于我们来说，操作数据库都是在JDBC API【接口】上，使用不同的数据库，只要用数据库厂商提供的数据库驱动程序即可。
  细品JDBC，把接口定义出来，给我实现就对了，无论数据库怎么变，用的时候是同一套API。

2.什么是JDBC

  JDBC（Java DataBase Connectivity）：Java数据库连接，通俗点就是Java语言操作数据库，是可以执行SQL语句的Java API。看了基本概念我还是不知道什么是JDBC，那JDBC本质到底是啥呢？在上面的也提到过，这里总结出来。
  JDBC本质：其实是官方（Sun公司）定义的一套操作所有关系型数据库的规则，即接口。各个数据库厂商去实现这套接口，提供数据库驱动jar包。我们可以使用这套接口（JDBC）编程，真正执行的代码是驱动jar包中的实现类。
  用一个例子理解JDBC本质：

/**
 * Person接口:好比一套JDBC接口中的一个
 * 接口中有一个eat()方法
 */
interface Person{
    void eat();
}

/**
 * Worker类，好比驱动jar包中的实现类
 * Person接口的一个实现类
 */
class Worker implements Person{

    @Override
    public void eat() {
        System.out.println("我喜欢吃牛肉！");
    }
}

/**
 - 例子
 - 我们JDBC编程都是用接口类型来调用方法，
 - 我们导入数据库驱动Jar包后，
 - 真正执行的代码是驱动Jar包中实现类里的方法；
 */
public class example {
    public static void main(String[] args) {
        Person p=new Worker();//父类引用指向子类对象的方式
        p.eat();//多态的调用
        //实际上调用的是Worker类中的eat()方法
    }
}

例子程序运行效果：

使用 JDBC 的好处

了解了JDBC，这里提一下使用JDBC的好处：

• 程序员如果要开发访问数据库的程序，只需要会调用 JDBC 接口中的方法即可，不用关注类是如何实现的。
• 使用同一套 Java 代码，进行少量的修改就可以访问其他 JDBC 支持的数据库

用图片更形象些：

3.如何使用JDBC

  通过前面的深入了解，实际使用JDBC，我们只需要会调用 JDBC 接口中的方法即可，数据库驱动由数据库厂商提供。随后我们简单学习一下这几个接口：Connection、Statement、ResultSet。使用JDBC的使用具体步骤如下：

具体步骤

1.导入驱动 Jar 包
2.加载和注册数据库驱动程序
3.获取数据库连接对象 Connection
4.定义SQL语句
5.获取执行SQL语句的对象 Statement
6.执行SQL语句，接受返回结果
7.处理结果
8.释放资源

1.导入驱动 Jar 包

笔者提供一个MySQL驱动Jar包:
链接: https://pan.baidu.com/s/1ZA43TxUXp49-MS_0KJvvbA.
提取码：7a5x
笔者用的IDEA，eclipse同理，导入方法：

2.其它步骤

  这里先用代码展示出来，后面再详解。

/**
 * JDBC步骤展示
 * 初级的代码，仅演示步骤用
 */
public class JDBCDemo1 {
    public static void main(String[] args) throws Exception {//异常都先抛出
        //1. 导入驱动jar包
        //2.注册驱动
        Class.forName("com.mysql.jdbc.Driver");
        //3.获取数据库连接对象
        Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/db1?useSSL=false", "root", "201703457");
        //4.定义sql语句
        String sql = "update user set password = 666666 where id = 1";
        //5.获取执行sql的对象 Statement
        Statement stmt = conn.createStatement();
        //6.执行sql
        int count = stmt.executeUpdate(sql);
        //7.处理结果
        System.out.println(count);
        //8.释放资源
        stmt.close();
        conn.close();
    }
}

  相信很多人最开始都写过这样的代码，高级的都在后面。相信我，高级的代码都是这么一步步走过来的，不一步一个脚丫子，很多时候就是知其然而不知其所以然。

3.DriverManage类

  DriverManage对象是驱动管理对象，我们只需要知道它这个对象有哪些功能和方法就可以了，功能：1.注册驱动；2.获取数据库连接。

注册驱动：告诉程序该使用哪一个数据库驱动jar
  注册驱动真正用到的方法是DriverManage类中的static void registerDriver(Driver driver)：注册与给定的驱动程序 DriverManager。
  那为什么写代码使用：Class.forName("com.mysql.jdbc.Driver");其实是这样写比较简单而已。这行代码的意思是将com.mysql.jdbc.Driver类加载到JVM中，而这个驱动类就在前面导入的驱动Jar包中，如果使用的不同数据库那么该驱动类将不同。
  我们通过查看源码发现：在com.mysql.jdbc.Driver类中存在静态代码块，Class.forName把这个类加载到JVM中的时候，就会执行其中的静态代码块，执行DriverManage类的registerDriver()方法，完成注册的相关工作。

/**
* com.mysql.jdbc.Driver类源码
*/
 static {
	        try {
	            java.sql.DriverManager.registerDriver(new Driver());
	        } catch (SQLException E) {
	            throw new RuntimeException("Can't register driver!");
	        }
		}

注意：mysql5之后的驱动jar包(自动注册了)可以省略注册驱动的步骤。但建议写上，规范。

获取数据库连接
  用到DriverManage类中的方法：static Connection getConnection(String url, String user, String password) ;返回一个Connection对象。

• 参数：
  url：指定连接的路径
    语法：jdbc:mysql://ip地址(域名):端口号/数据库名称
    例子：jdbc:mysql://localhost:3306/db1
    细节：如果连接的是本机mysql服务器，并且mysql服务默认端口是3306，则url可以简写为：jdbc:mysql:///数据库名称
  user：用户名
  password：密码

Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/db1?useSSL=false&characterEncoding=UTF-8", "root", "201703457");

useSSL=false：关闭SSL(Secure Sockets Layer)规范
characterEncoding=UTF-8：编码方式 UTF-8

4.Connection接口

  Connection对象是数据库连接对象，是当前代码和数据库之间的一个桥梁。对象的功能：1.获取执行sql 的对象；2.管理事务。

获取执行sql 的对象

  用到Connection中的方法：

• Statement createStatement();获得一个Statement对象
• PreparedStatement prepareStatement(String sql);获得一个PreparedStatement对象

//获取执行sql的对象 Statement
Statement stmt = conn.createStatement();
//获取执行sql的对象 PreparedStatement
PreparedStatement pstmt = conn.prepareStatement();

管理事务(写事务时详解)

• 开启事务：setAutoCommit(boolean autoCommit) ：调用该方法设置参数为false，关闭自动提交，即开启事务。
• 提交事务：commit()
• 回滚事务：rollback() ：撤销当前事务中所做的所有更改。

5.Statement接口

  Statement对象是执行静态SQL语句(参数都是给定值)，并返回生成的结果的对象。对象功能：执行SQL。

  用到Statement中的方法：

1. boolean execute(String sql) ：可以执行任意的sql 语句，用的非常少，了解一下。
2. int executeUpdate(String sql) ：执行DML（insert、update、delete）语句、DDL(create，alter、drop)语句
   返回值：影响的行数，可以通过这个影响的行数判断DML语句是否执行成功 [返回值>0的]则执行成功，反之，则失败。执行DDL语句，不返回任何内容。
3. ResultSet executeQuery(String sql) ：执行DQL（select)语句，返回一个ResultSet结果集对象。

        //4.定义sql语句
        String sql = "update user set password = 666666 where id = 1";
        //5.获取执行sql的对象 Statement
        Statement stmt = conn.createStatement();
        //6.执行sql
        int count = stmt.executeUpdate(sql);

6.ResultSet接口

  ResultSet对象是结果集对象,封装查询结果，即封装查询到的数据库的记录。

  用到ResultSet中的方法：

• boolean next(): 游标向下移动一行，判断当前行是否是最后一行末尾(是否有数据)，如果是，则返回false，如果不是则返回true
• getXxx(参数):获取数据
    Xxx：代表数据类型 如： int型数据对应getInt() , String型对应getString()
     括号里的参数有两种类型
      1. Int：代表列的编号,从1开始 如： getString(1)
      2. String：代表列名称。 如： getDouble("balance")

获取结果集中所有数据记录的代码：

//4.定义sql语句
String sql = "select * from user";
//执行查询语句，并把结果集返回给集合ResultSet
ResultSet rs = s.executeQuery(sql);
//循环判断游标是否是最后一行末尾。
while(rs.next()){
    //获取数据
    int id = rs.getInt(1);
    String name = rs.getString("name");
    double balance = rs.getDouble(3);

    System.out.println(id + "---" + name + "---" + balance);
}

  查询到的数据比较多的时候，就要用集合类来存放数据了，这里只做简单的示意。

7.PreparedStatement接口

  它是Statement的子接口，PreparedStatement对象是执行动态SQL语句(参数值未给定)的对象，对象的功能：1.解决SQL注入问题；2.预编译SQL。
先说下SQL注入问题，看一个用户登录例子:(用到了后面写好了的工具类JDBCUtils)

/**
 * 例子：
 * 需求：1.通过键盘录入用户名和密码
 *      2.判断用户是否登录成功
 */
public class JDBCDemo2 {

    public static void main(String[] args) {
        //1.键盘录入,用户名和密码
        Scanner sc=new Scanner(System.in);
        System.out.println("请输入用户名：");
        String username=sc.nextLine();
        System.out.println("请输入密码：");
        String password=sc.nextLine();
        //2.调用方法
        boolean flag=new JDBCDemo2().login(username,password);
        //3.判断方法,输出不同语句
        if (flag){
            //登录成功
            System.out.println("登录成功！");
        }else{
            System.out.println("用户名或密码错误!");
        }
    }

    /**
     * 登录方法
     */
    public boolean login(String username, String password) {
        if (username == null || password == null) {
            return false;
        }
        //连接数据库判断是否登录成功
        Connection conn = null;
        Statement stmt = null;
        ResultSet rs = null;
        try {
            //1.获取连接
            conn = JDBCUtils.getConnection();
            //2.定义SQL
            String sql = "select * from user where NAME='" + username + "' and password='" + password + "'";
            System.out.println(sql);
            //3.获取执行SQL的对象
            stmt = conn.createStatement();
            //4.执行查询
            rs = stmt.executeQuery(sql);
            //5.判断
            return rs.next();//如果有下一行,则返回true

        } catch (SQLException e) {
            e.printStackTrace();
        }finally {//释放资源
            JDBCUtils.close(rs,stmt,conn);
        }
        return false;
    }
}

正常登录：

看下面这种情况登录也可以成功，品一品打印出来的sql执行语句，永等式1=1，where条件始终是true。

  在使用Statement对象，执行SQL语句时，不可避免的要拼接像上面这样的SQL语句。就会有SQL注入问题：在拼接sql时，有一些sql的特殊关键字参与字符串的拼接。会造成安全性问题。

1.解决SQL注入问题：使用PreparedStatement对象来解决
  怎样解决的，是通过占位符?，来代替SQL语句中给定的参数值，然后再设置参数，指定相应的值，而不是Statement那样使用字符串拼接。修改上面的例子：

/**
     * 登录方法,使用PreparedStatement实现
     */
    public boolean login(String username, String password) {
        if (username == null || password == null) {
            return false;
        }
        //连接数据库判断是否登录成功
        Connection conn = null;
        PreparedStatement pstmt = null;
        ResultSet rs = null;
        try {
            //1.获取连接
            conn = JDBCUtils.getConnection();
            //2.定义SQL
            String sql = "select * from user where NAME=? and password=?";
            System.out.println(sql);
            //3.获取执行SQL的对象
            pstmt = conn.prepareStatement(sql);
            //4.给?赋值
            pstmt.setString(1,username);
            pstmt.setString(2,password);
            //5.执行查询,不需要传递sql
            rs = pstmt.executeQuery();
            //6.判断
            return rs.next();//如果有下一行,则返回true

        } catch (SQLException e) {
            e.printStackTrace();
        } finally {//释放资源
            JDBCUtils.close(rs, pstmt, conn);
        }
        return false;
    }

  修改后再试一下：随便输入用户，输入密码：a’ or 1 = '1，不会成功了，看一下打印的sql语句与Statement实现的情况比较，成功解决sql注入问题。

使用PreparedStatement对象时注意的几点：

• 定义sql语句时，sql的参数使用"?"作为占位符，简化sql的编写。 如：select * from user where username = ? and password = ?;
• 定义sql语句后，要记得给?赋值，方法： setXxx(参数1,参数2)，Xxx是"?"值对应的数据类型
  * 参数1：?的位置（位置索引从1 开始）
  * 参数2：?的值
• 执行sql，不需要传递sql语句。如：pstmt.executeQuery();

2.预编译SQL：提高性能。
  使用Statement会使数据库频繁编译SQL，可能造成数据库缓冲区溢出。
  使用PreparedStatement，Connection对象conn在调用prepareStatement(String sql)方法时，就对sql指定的SQL语句进行了预编译处理，后面PreparedStatement对象执行SQL语句时就不会再次编译了。提高访问数据库的效率。

后期都会使用PreparedStatement来完成数据库的增删改查的所有操作,优势：
1. 可以防止SQL注入
2. 效率更高

8.释放资源

  在JDBC编码的过程中我们创建了Connection、Statement、ResultSet等资源，这些资源在使用完毕之后是一定要进行关闭的。防止内存资源泄露，关闭的过程中遵循从里到外的原则,为确保资源释放代码能运行，资源释放代码一定要放在finally语句中。

		Connection conn=null;
        Statement stmt=null;
        ResultSet rs=null;
        try {
            //1. 导入驱动jar包
            //2.注册驱动
            //3.获取数据库连接对象
            //4.定义sql语句
            //5.获取执行sql的对象 Statement
            //6.执行sql
            //7.处理结果
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (SQLException e) {
            e.printStackTrace();
        }finally {
            //8.释放资源
            if (stmt!=null){//避免出现空指针异常,为了程序健壮
                try {
                    stmt.close();//释放资源
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
            if (conn!=null){
                try {
                    conn.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
            if (rs!=null){
                try {
                    rs.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
        }

JDBC工具类 ：JDBCUtils

• 目的：简化编写，尽量使代码简单，增加代码复用性
• 分析：
  1. 注册驱动也抽取
  2. 抽取一个方法获取连接对象
     * 需求：不想传递参数（麻烦），还得保证工具类的通用性。
     * 解决：配置文件,不同数据库修改配置文件中的值即可。
     jdbc.properties
url=指定连接路径
     user=用户名
     password=密码
     driver=使用的数据库驱动
  3. 抽取一个方法释放资源

代码实现:
1.JDBCUtils.java

import java.io.FileReader;
import java.io.IOException;
import java.net.URL;
import java.sql.*;
import java.util.Properties;

/**
 * JDBC工具类
 */
public class JDBCUtils {
    //声明用到参数对应的成员变量
    private static String url;
    private static String user;
    private static String password;
    private static String driver;

    /**
     * 配置文件的读取，只需要读取一次即可拿到这些值。使用静态代码块
     */
    static {
        //读取资源文件，获取值。
        try {
            //1.创建Properties集合类。
            Properties pro = new Properties();

            //2.动态获取src路径下的文件的方式--->使用ClassLoader类:类加载器
            ClassLoader classLoader = JDBCUtils.class.getClassLoader();//获取ClassLoader对象
            URL res = classLoader.getResource("jdbc.properties");//定位jdbc.properties绝对路径资源
            String path = res.getPath();//获取资源的字符串路径
            //System.out.println(path);//打印一下资源路径

            //3.加载路径对应的文件
            pro.load(new FileReader(path));

            //4.获取数据，传值
            url = pro.getProperty("url");
            user = pro.getProperty("user");
            password = pro.getProperty("password");
            driver = pro.getProperty("driver");

            //5.注册驱动
            Class.forName(driver);
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }


    /**
     * 获取连接
     * @return 连接对象
     */
    public static Connection getConnection() throws SQLException {
        return DriverManager.getConnection(url, user, password);
    }

    /**
     * 释放资源
     * @param stmt
     * @param conn
     */
    public static void close(Statement stmt, Connection conn) {
        close(null,stmt,conn);
    }


    /**
     * 释放资源
     * @param stmt
     * @param conn
     * @param rs
     */
    public static void close(ResultSet rs, Statement stmt, Connection conn) {
        if (rs != null) {//避免出现空指针异常,为了程序健壮
            try {
                rs.close();//释放资源
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }

        if (stmt != null) {
            try {
                stmt.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }

        if (conn != null) {
            try {
                conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }

}

2.资源配置文件(src目录下)：jdbc.properties

url=jdbc:mysql://localhost:3306/db1?useSSL=false&characterEncoding=UTF-8
user=root
password=201703457
driver=com.mysql.jdbc.Driver

注意：如果使用其它的类型数据库，更改这里driver的值为指定的数据库驱动类即可

  应用工具类举例见前面的用户登录例子。

JDBC控制事务

  终于写到事务了，JDBC第一部分最后一点内容，也很重要。
  什么是事务：一个包含多个步骤的业务操作。如果这个业务操作被事务管理，则这多个步骤要么同时成功，要么同时失败。
  事务处理的核心意义：将一系列操作放在一个事务下进行管理，正常情况全部执行，如果有异常出现，则回滚事务。
  前面提到JDBC是使用Connection对象来管理事务，事务步骤及用到的方法：

• 开启事务：setAutoCommit(boolean autoCommit) ：调用该方法设置参数为false，关闭自动提交，即开启事务。
• 提交事务：commit()
• 回滚事务：rollback() ：撤销当前事务中所做的所有更改。

事务例子，用户转账。张三转给李四500元，需要张三转出的同时，完成李四的转入。涉及两次数据库更新操作：
1.张三减500元。2.李四加500元。

• 未使用事务管理情况：如果1操作到2操作之间出现任何异常使程序运行出错，结果就只实现了张三减500，李四并没有任何转入。数据库只更新了张三的记录，没有更新李四的记录，不满足需要。(可以把下面代码中的事务操作删去，进行验证，这里不演示了)
• 使用事务管理情况：如果1操作到2操作之间出现任何异常，在异常处理catch中回滚事务，撤销1操作，数据库中张三和李四的记录都不会更新。没有异常，则张三和李四的记录同时更新。

这里就可以知道事务处理的位置了：
开启事务：在执行sql之前开启事务
提交事务：当所有sql都执行完提交事务
回滚事务：在catch中回滚事务

例子程序：
数据库中的account表

实现代码：

/**
 * 事务操作
 */
public class JDBCDemo4 {
    public static void main(String[] args) {
        Connection conn = null;
        PreparedStatement pstmt = null;
        String sql = null;

        try {
            //1.获取连接
            conn = JDBCUtils.getConnection();

            //开启事务
            conn.setAutoCommit(false);

            //2.定义sql
            sql = "update account set balance=balance-? where id=?";//张三减500
            //3.获取执行sql对象
            pstmt = conn.prepareStatement(sql);
            //4.设置?参数
            pstmt.setDouble(1, 500);
            pstmt.setInt(2, 1);
            //5.执行sql
            pstmt.executeUpdate();

            //人为异常
            //int i=3/0;
            
            sql = "update account set balance=balance+? where id=?";//李四加500
            pstmt = conn.prepareStatement(sql);
            pstmt.setDouble(1, 500);
            pstmt.setInt(2, 2);
            pstmt.executeUpdate();

            //提交事务
            conn.commit();
        } catch (Exception e) {
            e.printStackTrace();
            //事务回滚
            try {
                if (conn != null) {
                    conn.rollback();
                }
            } catch (SQLException ex) {
                ex.printStackTrace();
            }
        } finally {
            //释放资源
            JDBCUtils.close(pstmt, conn);
        }
    }
}

程序运行结果：

4.总结

补充
  小结一下PreparedStatement接口与Statement接口的区别，为什么要用PreparedStatement。

• Statement对象编译SQL语句时，如果SQL语句有变量，就需要使用分隔符来隔开，如果变量非常多，就会使SQL变得非常复杂。PreparedStatement可以使用占位符，简化sql的编写
• Statement会频繁编译SQL。PreparedStatement可对SQL进行预编译，提高效率，预编译的SQL存储在PreparedStatement对象中
• PreparedStatement防止SQL注入。(Statement通过分隔符’++’,编写永等式，可以不需要密码就进入数据库)

结语
  花了两天时间整理了这JDBC(一)基础部分，后面还会持续整理JDBC进阶数据库连接池、JDBCTemplate等知识。两天下来收获颇多，细化了很多点。希望仔细看完的小伙伴也能有收获，鼓掌~。
  这里贴张大佬总结JDBC的知识点思维导图，供学习参考

欢迎点赞评论，指出不足，笔者由衷感谢o！

---

推荐阅读：
 JDBC(一):基础(本质，操作步骤，类对象详解，工具类，事务)
 JDBC：API实战(CURD,封装结果集,批量处理sql,处理二进制大数据文件,获取主键列、元数据).
 JDBC(二):数据库连接池(C3P0、Druid)
 JDBC(三)：Spring的JDBCTemplate基本使用