一、JDBC的用途

  1. 加载对应的数据库驱动（Load Driver）
  2. 与数据库建立连接（connection）
  3. 大宋操作数据库语句（createStatement）
  4. 执行并处理返回结果（executeQuery）

二、JDBC

2.1 什么是JDBC

  1. java语言连接数据库（mysql、DB2）
  2. 一套规范，所有数据库厂家都需要实现；

2.2 通过jdbc连接数据库

  1. 需要将mysql 数据库的驱动导入到工程；

    2.2.1 jdbc编程六步：

  • 注册驱动；
  • 获取数据库链接；
  • 获取数据库操作对象；
  • 编写sql，执行sql；
  • 根据返回值，如果是增删改查，返回影响记录条数，如果查询返回查询结果集；
  • 关闭资源；

2.2.2详细操作：

  1. 注册驱动：Driver
    1. //1、注册驱动
    2. Class.forName("com.mysql.cj.jdbc.Driver");
    3. /**
    4. * jdbc:mysql : jdbc协议，类似于http协议
    5. * localhost   本地的ip地址 127.0.0.1
    6. * 3306 ：mysql服务默认的端口号
    7. */
    8. //连接数据的地址
    9. String url = "jdbc:mysql://localhost:3306/eagls?characterEncoding=utf8&serverTimezone=GMT%2B8";
    10. //用户名
    11. String username = "root";
    12. //密码
    13. String password = "root";
    Driver驱动： ```java package com.mysql.cj.jdbc;

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

public class Driver extends NonRegisteringDriver implements java.sql.Driver { public Driver() throws SQLException { } //try catch 添加快捷键方式ctrl +alt+t static { try { DriverManager.registerDriver(new Driver()); } catch (SQLException var1) { throw new RuntimeException(“Can’t register driver!”); } } }

  1. > 创建Driver的实例对象，完成Driver中的static的类加载（类加载只加载一次不是很占用内存）；
  2. > class.forName（" com.mysql.cj.jdbc.Driver"）可以使得driver类加载。
  3. >      权限定类名 com.mysql.cj.jdbc.Driver     全类名   注意点上包结构。
  5. String url="jdbc:mysql://localhost:3306/eagls?characterEncoding=utf8&serverTimezone=GMT%2B8";
  6. > 字符集设置，防止字符乱码以及时区设置； 
  7. > characterEncoding=utf8&serverTimezone=GMT%2B8  
  10. 2. 获取数据库链接；
  11. ```java
  12.   //2、获取数据库连接对象
  13.  Connection connection = DriverManager.getConnection(url, username, password);

  1. 获取数据库操作对象；

    1. //3、获取数据库操作对象
    2. Statement statement = connection.createStatement();

  2. 编写sql，执行sql；

    1. //4、编写sql、执行sql
    2. String sql = "insert into user(username,password)values('jack','123456')";

  3. 根据返回值，如果是增删改查，返回影响记录条数，如果查询返回查询结果集；

    1. //执行sql
    2. int num = statement.executeUpdate(sql);
    3. System.out.println(num == 1 ? "添加成功" : "添加失败");

  4. 关闭资源；

    1. //关闭资源
    2. statement.close();
    3. connection.close();

    2.3 JDBC的完整写法；

1. 按照六部写法；
  1. import java.sql.Connection;
  2. import java.sql.DriverManager;
  3. import java.sql.SQLException;
  4. import java.sql.Statement;
  5. /**
  6.  * jdbc编程六步
  7.  */
  8. public class JDBCTest02 {
  9.     public static void main(String[] args) {
  10.         try {
  11.             //1、注册驱动
  12.             Class.forName("com.mysql.cj.jdbc.Driver");
  13.             /**
  14.              * jdbc:mysql : jdbc协议，类似于http协议
  15.              * localhost   本地的ip地址 127.0.0.1
  16.              * 3306 ：mysql服务默认的端口号
  17.              */
  18.             //连接数据的地址
  19.             String url = "jdbc:mysql://localhost:3306/eagls?characterEncoding=utf8&serverTimezone=GMT%2B8";
  20.             //用户名
  21.             String username = "root";
  22.             //密码
  23.             String password = "root";
  24.             //2、获取数据库连接对象
  25.             Connection connection = DriverManager.getConnection(url, username, password);
  26.             //3、获取数据库操作对象
  27.             Statement statement = connection.createStatement();
  28.             //4、编写sql、执行sql
  29.             String sql = "insert into user(username,password)values('jack','123456')";
  30.             //执行sql
  31.             int num = statement.executeUpdate(sql);
  32.             System.out.println(num == 1 ? "添加成功" : "添加失败");
  33.             //关闭资源
  34.             statement.close();
  35.             connection.close();
  36.         } catch (ClassNotFoundException e) {
  37.             e.printStackTrace();
  39.         } catch (SQLException throwables) {
  40.             throwables.printStackTrace();
  41.         }
  42.     }
  43. }

2. 改进写法

常用写法以及注意事项：

  1. 首先，数据库连接对象、数据库获取对象、以及用以存放数据库查询结果的对象需要在主函数内声明并赋初值为null。不放在try语句块的内部申明，这样方便后面再finally语句块内关闭资源；

  2. 关闭资源的时候需要做判空判断，并添加try-catch语句捕获异常；

  3. 注意sql语句的写法与执行； ```java import java.sql.*;

public interface JdbcTest2 { public static void main(String[] args) { //2、获取数据库连接对象 Connection connection = null;

  1.     //3，获取数据库操作对象
  2.     Statement statement = null;
  4.     //获取数据库对象，用以存放查询结果；
  5.     ResultSet resultSet = null;
  7.     try {
  8.         Class.forName("com.mysql.cj.jdbc.Driver");
  9.         //连接数据的地址
  10.        // String url = "jdbc:mysql://localhost:3306/test1?characterEncoding=utf8&serverTimezone=GMT%2B8";
  11.      /*   //用户名
  12.         String username = "root";
  13.         //密码
  14.         String password = "root";*/
  16.         //2、获取数据库连接对象
  17.         connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/test1?characterEncoding=utf8&serverTimezone=GMT%2B8", "root", "root");
  18.         //3，获取数据库操作对象
  19.         statement = connection.createStatement();
  20.         //4. 编写sql
  21.         //String sql = "insert into user(username,password)values('jack','123456')";
  22.         //String sql1 = "UPDATE user set username = 'jack12', password = '12345678' where id = 1";
  23.         String sql2 = "select * from user";
  24.         //5. 执行sql
  25.         //int num1 = statement.executeUpdate(sql1);
  26.         //int num = statement.executeUpdate(sql);
  27.         resultSet = statement.executeQuery(sql2);
  28.         //System.out.println(num == 1 ? "数据添加成功" : "数据添加失败失败");
  29.         //System.out.println(num1 == 1 ? "数据修改成功" : "数据修改失败失败");
  30.         while(resultSet.next()){
  31.             int id = resultSet.getInt("id");
  32.             String username = resultSet.getString("username");
  33.             String password = resultSet.getString("password");
  34.             System.out.println(id+ " "+username+" "+password);
  35.         }
  36.     } catch (ClassNotFoundException | SQLException e) {
  37.         e.printStackTrace();
  38.     }
  39.     finally {
  40.         if(statement != null){
  41.             try {
  42.                 statement.close();
  43.             } catch (SQLException throwables) {
  44.                 throwables.printStackTrace();
  45.             }
  46.         }
  47.         if(connection != null){
  48.             try {
  49.                 connection.close();
  50.             } catch (SQLException throwables) {
  51.                 throwables.printStackTrace();
  52.             }
  53.         }
  54.         if(resultSet != null){
  55.             try {
  56.                 resultSet.close();
  57.             } catch (SQLException throwables) {
  58.                 throwables.printStackTrace();
  59.             }
  60.         }
  61.     }
  62. }

}

  2. <a name="TnHwQ"></a>
  3. ##### 3. 几个案例：
  4. 将数据添加到数据库，并把数据库内的表创建对应的类，将每条数据创建对应实例对象并存入集合。
  5. ```java
  6. public class Student {
  7.     private Integer id;
  8.     private String name;
  9.     private String sex;
  10.     private String birth;
  11.     private String department;
  12.     private String Address;
  14.     public Student(Integer id, String name, String sex, String birth, String department, String address) {
  15.         this.id = id;
  16.         this.name = name;
  17.         this.sex = sex;
  18.         this.birth = birth;
  19.         this.department = department;
  20.         Address = address;
  21.     }
  22.     public Student() {
  23.     }
  24.     public Integer getId() {
  25.         return id;
  26.     }
  27.     public void setId(Integer id) {
  28.         this.id = id;
  29.     }
  30.     public String getName() {
  31.         return name;
  32.     }
  33.     public void setName(String name) {
  34.         this.name = name;
  35.     }
  36.     public String getSex() {
  37.         return sex;
  38.     }
  39.     public void setSex(String sex) {
  40.         this.sex = sex;
  41.     }
  42.     public String getBirth() {
  43.         return birth;
  44.     }
  46.     public void setBirth(String birth) {
  47.         this.birth = birth;
  48.     }
  50.     public String getDepartment() {
  51.         return department;
  52.     }
  54.     public void setDepartment(String department) {
  55.         this.department = department;
  56.     }
  57.     public String getAddress() {
  58.         return Address;
  59.     }
  60.     public void setAddress(String address) {
  61.         Address = address;
  62.     }
  63.     @Override
  64.     public String toString() {
  65.         return "Student{" +
  66.                 "id=" + id +
  67.                 ", name='" + name + '\'' +
  68.                 ", sex='" + sex + '\'' +
  69.                 ", birth='" + birth + '\'' +
  70.                 ", department='" + department + '\'' +
  71.                 ", Address='" + Address + '\'' +
  72.                 '}';
  73.     }
  74. }
  1. import javax.xml.crypto.Data;
  2. import java.sql.*;
  3. import java.util.ArrayList;
  4. public interface JdbcTest03 {
  5.     public static void main(String[] args) {
  6.         //定义数据库的几个操作对象；
  7.         //数据库连接对象
  8.         Connection connection = null;
  9.         //数据库操作对象
  10.         Statement statement = null;
  11.         //数据库的数据获取的集合对象
  12.         ResultSet resultSet =null;
  14.         try {
  15.             Class.forName("com.mysql.cj.jdbc.Driver");
  17.             connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/test1?characterEncoding=utf8&serverTimezone=GMT%2B8","root","root");
  19.             statement = connection.createStatement();
  21.             ArrayList<Student> students = new ArrayList<>();
  22.             String sql1 = "select * from student";
  23.             resultSet = statement.executeQuery(sql1);
  24.             while(resultSet.next()){
  25.                 int id = resultSet.getInt("id");
  26.                 String name =resultSet.getString("name");
  27.                 String sex = resultSet.getString("sex");
  28.                 String birth = resultSet.getString("birth");
  29.                 String department = resultSet.getString("department");
  30.                 String Address = resultSet.getString("Address");
  32.                 Student student = new Student();
  34.                 student.setId(id);
  35.                 student.setName(name);
  36.                 student.setSex(sex);
  37.                 student.setBirth(birth);
  38.                 student.setDepartment(department);
  39.                 student.setAddress(Address);
  40.                 students.add(student);
  41.             }
  42.             for (Student student : students) {
  43.                 System.out.println(student);
  44.             }
  46.         } catch (ClassNotFoundException e) {
  47.             e.printStackTrace();
  48.         } catch (SQLException throwables) {
  49.             throwables.printStackTrace();
  50.         }
  51.         finally {
  52.             if(statement != null){
  53.                 try {
  54.                     statement.close();
  55.                 } catch (SQLException throwables) {
  56.                     throwables.printStackTrace();
  57.                 }
  58.             }
  59.             if(connection != null){
  60.                 try {
  61.                     connection.close();
  62.                 } catch (SQLException throwables) {
  63.                     throwables.printStackTrace();
  64.                 }
  65.             }
  66.         }
  67.     }
  68. }

案例：写一个用户登陆部分：
注意sql语句中变量添加的位置：

String sql = “select * from user where username =’”+username+ “‘and password = ‘“+password+”‘“;

  1. import java.sql.*;
  2. import java.util.ArrayList;
  3. import java.util.Scanner;
  5. public interface JdbcTest04 {
  6.     public static void main(String[] args) {
  7.         //定义数据库的几个操作对象；
  8.         //数据库连接对象
  9.         Connection connection = null;
  10.         //数据库操作对象
  11.         Statement statement = null;
  12.         //数据库的数据获取的集合对象
  13.         ResultSet resultSet =null;
  15.         try {
  16.             Scanner scanner = new Scanner(System.in);
  17.             System.out.println("请输入登陆用户名：");
  18.             String username = scanner.next();
  19.             System.out.println("请输入登陆用户密码：");
  20.             String password = scanner.next();
  21.             //注册驱动
  22.             Class.forName("com.mysql.cj.jdbc.Driver");
  24.             //获取数据库连接对象
  25.             connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/test1?characterEncoding=utf8&serverTimezone=GMT%2B8","root","root");
  27.             //获取数据操作对象
  28.             statement = connection.createStatement();
  30.             //编写sql语句
  31.             String sql = "select * from user where username ='"+username+ "'and password = '"+password+"'";
  32.             resultSet = statement.executeQuery(sql);
  33.             if(resultSet.next()) {
  34.                 System.out.println("登陆成功");
  35.             }
  36.             else
  37.                 System.out.println("登陆失败");
  38.         } catch (ClassNotFoundException e) {
  39.             e.printStackTrace();
  40.         } catch (SQLException throwables) {
  41.             throwables.printStackTrace();
  42.         }
  43.         finally {
  44.             if(statement != null){
  45.                 try {
  46.                     statement.close();
  47.                 } catch (SQLException throwables) {
  48.                     throwables.printStackTrace();
  49.                 }
  50.             }
  51.             if(connection != null){
  52.                 try {
  53.                     connection.close();
  54.                 } catch (SQLException throwables) {
  55.                     throwables.printStackTrace();
  56.                 }
  57.             }
  58.         }
  59.     }
  60. }

三、preparedStatemen

1.Statement操作对象

  • 可能会出现sql注入，就是通过扭曲sql语句的本来意思来窃取数据库数据。
  • 但是preparedStatement操作对象就不会出现这种问题。
  1. preparedStatemen

需要先传入一个sql的’框架’语句，框架中变量用占位符，再传入变量。防止SQL注入。
注意占位符的使用以及赋值操作；

    1. 获取操作对象,预编译sql

      preparedStatement = connection.prepareStatement(“insert into user(username,password) values (?,?)”);

    1. 给占位符赋值

      preparedStatement.setString(1,”tom”); preparedStatement.setString(2,”112233”);

    1. 执行sql语句

      int num = preparedStatement.executeUpdate();

四、JDBC工具类

4.1 jdbc工具类的封装
  1. 由于jdbc的六部操作相对于复杂，可以把jdbc中相对固定的代码的组件封装成一个工具类；
  2. jdbc对应的都是对应的静态方法，没有普通方法，直接用类名点上就可以使用。
  3. 封装步骤：
    1. 先将当前类的构造方法私有化，把六步放在静态代码块中。
    1. 获取数据库连接对象 注意异常捕获或者异常抛出。
    1. 关闭数据库资源 ```java import java.sql.; /*
    • 封装jdbcUtils

    • 1、先将当前类构造方法私有化 */ public class JDBCUtils {

      private JDBCUtils(){ } /**

      • 将注册驱动的步骤放进代码块中，在类加载的时候就会加载，而且只执行一次，提高程序的执行效率 */ static {

        try {

        1.  //注册驱动
        2.  Class.forName("com.mysql.cj.jdbc.Driver");

        } catch (ClassNotFoundException e) {

        1.  e.printStackTrace();

        } }

      /**

      • 获取数据库连接对象
      • @return

      • @throws SQLException */ public static Connection getConnection() throws SQLException {

        return DriverManager.getConnection(“jdbc:mysql://localhost:3306/eagls?” +

        1.      "characterEncoding=utf8&serverTimezone=GMT%2B8","root","root");

        } /**

      • 关闭数据库资源
      • @param connection
      • @param statement

      • @param resultSet */ public static void close(Connection connection, Statement statement, ResultSet resultSet){

        if (resultSet != null){

        1.  try {
        2.      resultSet.close();
        4.  } catch (SQLException throwables) {
        6.      throwables.printStackTrace();
        7.  }

        }

        if (statement != null){

        1.  try {
        2.      statement.close();
        4.  } catch (SQLException throwables) {
        6.      throwables.printStackTrace();
        7.  }

        }

        if (connection != null){

        1.  try {
        2.      connection.close();
        4.  } catch (SQLException throwables) {
        6.      throwables.printStackTrace();
        7.  }

        } } } ```

五、事物处理

  1. java事物

    事物必须服从ACID原则；

    ACID原则：原子性、一致性、隔离性、持久性； 通常认为：事物仅于数据库相关

  2. 事物是一组原子操作单元，从数据库角度上来书哦就是一组sql语句，要么全部执行成功要么全部执行失败（撤销不执行）

  3. Jdbc事物是用Connection对象控制的； 

    1. jdbc Connection 接口：

  4. jdbc默认情况下是没有开启事物的，需要手动开启；

    jdbc默认情况下采用自动提交策略；（每次执行完sql之后，java只要
    一提交，那么会通知mysql修改数据）
    如果要开启事物：要自动提交改为手动提交；

  5. 开启事物： connection.setAutoCommit(false);

  6. 提交事物： connection.commit();
  7. 回滚事物：让事物回到执行之前的状态； connection.rollback();

事物案例：

  1. import com.eagleslab.utils.JDBCUtils;
  3. import java.sql.Connection;
  4. import java.sql.PreparedStatement;
  5. import java.sql.ResultSet;
  6. import java.sql.SQLException;
  7. /**
  8.  * 关于jdbc的事务操作:
  9.  *      -场景：模拟A账户给B账户转账，如果中途发生异常，我们希望事务能满足一致性
  10.  *      -jdbc默认情况下是没有开启事务的，事务需要我们手动开启
  11.  *          -jdbc默认情况下采用的是自动提交的策略(当每次执行完sql之后，jdbc会自动提交sql，sql只要一提交，那么就会通知mysql，修改对应的数据)
  12.  *          -如果要开启事务的话，要将自动提交改为手动提交
  13.  */
  14. public class JdbcTest03 {
  16.     public static void main(String[] args) {
  18.         Connection connection = null;
  19.         PreparedStatement preparedStatement = null;
  20.         ResultSet resultSet = null;
  22.         try {
  24.             //获取数据库连接对象
  25.             connection = JDBCUtils.getConnection();
  27.             //开启事务，将自动提交改为手动提交
  28.             connection.setAutoCommit(false);
  30.             //获取数据库操作对象
  31.             preparedStatement = connection.prepareStatement("update tb_account set account_A = account_A - ? where id = ?");//给A账户扣钱
  33.             //给占位符赋值
  34.             preparedStatement.setDouble(1,1000.0);
  35.             preparedStatement.setInt(2,1);
  37.             //执行sql语句
  38.             int num = preparedStatement.executeUpdate();
  40.             System.out.println(num == 1 ? "扣钱成功" : "扣钱失败");
  42.             //模拟异常
  43.             int i = 1 / 0;
  45.             preparedStatement = connection.prepareStatement("update tb_account set account_B = account_B + ? where id = ?");
  47.             //给占位符赋值
  48.             preparedStatement.setDouble(1,1000.0);
  49.             preparedStatement.setInt(2,1);
  51.             num = preparedStatement.executeUpdate();
  53.             System.out.println(num == 1 ? "转账成功" : "转账失败");
  55.             //提交事务
  56.             connection.commit();
  58.         } catch (Exception e) {
  60.             try {
  62.                 //回滚事务，让事务回到执行之前的状态
  63.                 connection.rollback();
  65.             } catch (SQLException throwables) {
  67.                 throwables.printStackTrace();
  68.             }
  70.             e.printStackTrace();
  72.         }finally {
  74.             //关闭资源
  75.            JDBCUtils.close(connection,preparedStatement,resultSet);
  76.         }
  77.     }
  78. }

结束