JDBC
    1、JDBC是什么？
    Java DataBase Connectivity（Java语言连接数据库）
    2、JDBC的本质是什么？
    JDBC是SUN公司制定的一套接口（interface）
    java.sql.*; (这个软件包下有很多接口。)
    接口都有调用者和实现者。
    面向接口调用、面向接口写实现类，这都属于面向接口编程。
    为什么要面向接口编程？
    解耦合：降低程序的耦合度，提高程序的扩展力。
    多态机制就是非常典型的：面向抽象编程。（不要面向具体编程）
    建议：
    Animal a = new Cat();
    Animal a = new Dog();
    // 喂养的方法
    public void feed(Animal a){ // 面向父类型编程。

    }
    不建议：
    Dog d = new Dog();
    Cat c = new Cat();

    思考：为什么SUN制定一套JDBC接口呢？
    因为每一个数据库的底层实现原理都不一样。
    Oracle数据库有自己的原理。
    MySQL数据库也有自己的原理。
    MS SqlServer数据库也有自己的原理。
    ….
    每一个数据库产品都有自己独特的实现原理。

    JDBC的本质到底是什么？
    一套接口。
    3、JDBC开发前的准备工作，先从官网下载对应的驱动jar包，然后将其配置到环境变量classpath当中。
    classpath=.;D:\course\06-JDBC\resources\MySql Connector Java 5.1.23\mysql-connector-java-5.1.23-bin.jar
    以上的配置是针对于文本编辑器的方式开发，使用IDEA工具的时候，不需要配置以上的环境变量。
    IDEA有自己的配置方式。

    4、JDBC编程六步（需要背会）

    第一步：注册驱动（作用：告诉Java程序，即将要连接的是哪个品牌的数据库）
    第二步：获取连接（表示JVM的进程和数据库进程之间的通道打开了，这属于进程之间的通信，重量级的，使用完之后一定要关闭通道。）
    第三步：获取数据库操作对象（专门执行sql语句的对象）
    第四步：执行SQL语句（DQL DML….）
    第五步：处理查询结果集（只有当第四步执行的是select语句的时候，才有这第五步处理查询结果集。）
    第六步：释放资源（使用完资源之后一定要关闭资源。Java和数据库属于进程间的通信，开启之后一定要关闭。）

    1. import java.sql.*;
    3. public class JDBCTest01 {
    4.     public static void main(String[] args) {
    5.         Connection conn = null;
    6.         Statement stmt = null;
    8.         try{
    9.             //1. 注册驱动
    10.             Driver driver = new com.mysql.cj.jdbc.Driver();//多态，父类型引用指向子类型对象
    11.             DriverManager.registerDriver(driver);
    13.             //2. 获取连接
    14.             /*
    15.                 url:统一资源定位符（网络资源绝对路径）
    16.                 包括：
    17.                     http://36.152.44.95:80/index.html
    18.                     协议        IP      port   资源名
    20.              */
    21.             String url = "jdbc:mysql://127.0.0.1:3306/bjpowernode?serverTimezone=GMT";
    22.             //localhost和 127.0.0.1都是本机IP
    23.             String user = "root";
    24.             String password = "hqw3.1415926";
    25.             conn = DriverManager.getConnection(url,user,password);
    26.             System.out.println("数据库连接对象=" + conn);
    28.             //3. 获取数据库操作对象(Statement专门执行sql)
    29.             stmt = conn.createStatement();
    31.             //4. 执行sql
    32.             String sql = "insert into dept(deptno,dname,loc) values(50,'人事部','北京')";
    33.             //专门执行DML语句的(insert delete update)
    34.             //返回值时影响数据库的记录条数
    35.             int count = stmt.executeUpdate(sql);
    36.             System.out.println(count ==1 ? "保存成功":"保存失败");
    37.             //5. 处理查询结果集
    39.         }catch (SQLException e){
    40.             e.printStackTrace();
    42.         }finally{
    43.             //6. 释放资源
    44.             //未来保证资源释放，在语句块中关闭资源
    45.             //并且从小到大依次关闭
    46.             if(stmt!= null){
    47.                 try {
    48.                     stmt.close();
    49.                 } catch (SQLException t) {
    50.                     t.printStackTrace();
    51.                 }
    52.             }
    53.             if (conn != null){
    54.                 try {
    55.                     conn.close();
    56.                 } catch (SQLException t) {
    57.                     t.printStackTrace();
    58.                 }
    59.             }
    60.         }
    61.     }
    62. }
    1. import java.sql.Connection;
    2. import java.sql.DriverManager;
    3. import java.sql.SQLException;
    4. import java.sql.Statement;
    6. public class JDBCTest02 {
    7.     public static void main(String[] args) {
    8.         Connection conn = null;
    9.         Statement stat = null;
    10.         try{
    11.             //1.注册驱动
    12.             DriverManager.registerDriver(new com.mysql.cj.jdbc.Driver());
    13.             //2.获取连接
    14.             conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/bjpowernode?serverTimezone=GMT","root","hqw3.1415926");
    15.             //3.获取数据库操作对象
    16.             stat = conn.createStatement();
    17.             //4.执行SQL语句
    18.             //java中sql语句不写分号
    19.             String sql = "delete from dept where deptno = 50";
    20.             int count = stat.executeUpdate(sql);
    21.             System.out.println(count == 1 ? "删除成功" : "删除失败");
    23.         }catch (SQLException e){
    24.             e.printStackTrace();
    25.         }finally{
    26.             //5.释放连接
    27.             if (stat != null){
    28.                 try {
    29.                     stat.close();
    30.                 } catch (SQLException throwables) {
    31.                     throwables.printStackTrace();
    32.                 }
    33.             }
    34.             if (conn != null){
    35.                 try {
    36.                     conn.close();
    37.                 } catch (SQLException throwables) {
    38.                     throwables.printStackTrace();
    39.                 }
    40.             }
    41.         }
    42.     }
    43. }
    1. import java.sql.Connection;
    2. import java.sql.DriverManager;
    3. import java.sql.SQLException;
    4. import java.sql.Statement;
    5. import java.util.ResourceBundle;
    7. public class JDBCTest03 {
    8.     public static void main(String[] args) {
    9.         //使用资源绑定器绑定属性配置文件
    10.         ResourceBundle bundle = ResourceBundle.getBundle("jdbc");
    11.         String driver = bundle.getString("driver");
    12.         String url = bundle.getString("url");
    13.         String user = bundle.getString("user");
    14.         String password = bundle.getString("password");
    16.         Connection conn = null;
    17.         Statement stat = null;
    18.         try {
    19.             //1.注册驱动
    20.             //第一种方法：DriverManager.registerDriver(new com.mysql.cj.jdbc.Driver());
    21.             //第二种常用：
    22.             Class.forName(driver);
    23.             //2.获取连接
    24.             conn = DriverManager.getConnection(url,user,password);
    25.             //3.获取数据库操作对象
    26.             stat = conn.createStatement();
    27.             //4.执行SQL语句
    28.             String sql = "insert into dept(deptno,dname,loc) values(50,'人事部','北京')";
    29.             //专门执行DML语句的(insert delete update)
    30.             //返回值时影响数据库的记录条数
    31.             int count = stat.executeUpdate(sql);
    32.             System.out.println(count ==1 ? "保存成功":"保存失败");
    34.         } catch (SQLException e) {
    35.             e.printStackTrace();
    36.         } catch (ClassNotFoundException e) {
    37.             e.printStackTrace();
    38.         }
    39.     }
    40. }
    • 模拟用户登录功能 ```java import java.sql.*; import java.util.HashMap; import java.util.Map; import java.util.Scanner;

    public class JDBCTest06 { public static void main(String[] args) { //初始化一个界面 Map userLoginInfo = initUI(); //验证用户名和密码 boolean loginSuccess = login(userLoginInfo); //输出结果 System.out.println((loginSuccess ? “登录成功” : “登录失败”)); }

    1. /**
    2.  * 用户登录
    3.  * @param userLoginInfo 用户登录信息
    4.  * @return false表示失败 true成功
    5.  */
    6. private static boolean login(Map<String, String> userLoginInfo) {
    7.     //打标记
    8.     boolean loginSuccess = false;
    9.     //单独定义变量
    10.     String loginName = userLoginInfo.get("loginName");
    11.     String loginPwd = userLoginInfo.get("loginPwd");
    12.     //JDBC代码
    13.     Connection conn = null;
    14.     Statement stmt = null;
    15.     ResultSet rs = null;
    18.     try {
    19.         //1.注册驱动
    20.         Class.forName("com.mysql.cj.jdbc.Driver");
    22.         //2.获取连接
    23.         conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/bjpowernode?serverTimezone=GMT","root","hqw3.1415926");
    25.         //3.获取数据操作对象
    26.         stmt = conn.createStatement();
    28.         //4.执行sql
    29.         String sql = "select * from t_user where loginName = '"+loginName+"' and loginPwd = '"+loginPwd+"' ";
    30.         rs = stmt.executeQuery(sql);
    31.         //5.处理结果集
    32.         if (rs.next()){
    33.             //登录成功
    34.             loginSuccess = true;
    35.         }
    36.     } catch (ClassNotFoundException e) {
    37.         e.printStackTrace();
    38.     } catch (SQLException throwables) {
    39.         throwables.printStackTrace();
    40.     } finally {
    41.         //6.释放资源
    42.         if (rs != null){
    43.             try {
    44.                 rs.close();
    45.             } catch (SQLException throwables) {
    46.                 throwables.printStackTrace();
    47.             }
    48.         }
    49.         if (stmt != null){
    50.             try {
    51.                 stmt.close();
    52.             } catch (SQLException throwables) {
    53.                 throwables.printStackTrace();
    54.             }
    55.         }
    56.         if (conn != null){
    57.             try {
    58.                 conn.close();
    59.             } catch (SQLException throwables) {
    60.                 throwables.printStackTrace();
    61.             }
    62.         }
    63.     }
    64.     return loginSuccess;
    65. }
    67. /**
    68.  * 初始化用户信息
    69.  * @return 用户输入用户名和密码登录信息
    70.  */
    71. private static Map<String,String> initUI() {
    72.     Scanner s = new Scanner(System.in);
    73.     System.out.println("用户名：");
    74.     String loginName = s.nextLine();
    75.     System.out.println("密码：");
    76.     String loginPwd = s.nextLine();
    77.     Map<String,String> userLoginInfo = new HashMap<>();
    78.     userLoginInfo.put("loginName",loginName);
    79.     userLoginInfo.put("loginPwd",loginPwd);
    80.     return userLoginInfo;
    82. }

    }

    1. **上面案例存在sql注入**<br />用户输入信息含有sql关键字，并且这些关键字参与sql语句编译，导致sql语句的原意被扭曲，进而达到sql注入<br />解决sql注入：
    3. - PreparedStatement接口继承了java.sql.Statement，是属于预编译的数据库对象。原理是对sql框架预编译
    4. - PreparedStatement编译一次执行n次
    5. - PreparedStatement会在编译阶段做类型的安全检查
    6. ```java
    7. public class JDBCTest07 {
    8.     public static void main(String[] args) {
    9.         //初始化一个界面
    10.         Map<String,String> userLoginInfo = initUI();
    11.         //验证用户名和密码
    12.         boolean loginSuccess = login(userLoginInfo);
    13.         //输出结果
    14.         System.out.println((loginSuccess ? "登录成功" : "登录失败"));
    15.     }
    17.     /**
    18.      * 用户登录
    19.      * @param userLoginInfo 用户登录信息
    20.      * @return false表示失败 true成功
    21.      */
    22.     private static boolean login(Map<String, String> userLoginInfo) {
    23.         //打标记
    24.         boolean loginSuccess = false;
    25.         //单独定义变量
    26.         String loginName = userLoginInfo.get("loginName");
    27.         String loginPwd = userLoginInfo.get("loginPwd");
    28.         //JDBC代码
    29.         Connection conn = null;
    30.         PreparedStatement ps = null;
    31.         ResultSet rs = null;
    34.         try {
    35.             //1.注册驱动
    36.             Class.forName("com.mysql.cj.jdbc.Driver");
    38.             //2.获取连接
    39.             conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/bjpowernode?serverTimezone=GMT","root","hqw3.1415926");
    41.             //3.获取预编译的数据操作对象
    42.             //问号为占位符,?将来接收一个值
    43.             String sql = "select * from t_user where loginName = ? and loginPwd = ?";
    44.             //sql语句发给DBMS进行预编译
    45.             ps = conn.prepareStatement(sql);
    46.             //给占位符传值（第一个?下标为1，JDBC下标从1开始）
    47.             ps.setString(1,loginName);
    48.             ps.setString(2,loginPwd);
    50.             //4.执行sql
    51.             rs = ps.executeQuery();
    53.             //5.处理结果集
    54.             if (rs.next()){
    55.                 //登录成功
    56.                 loginSuccess = true;
    57.             }
    58.         } catch (ClassNotFoundException e) {
    59.             e.printStackTrace();
    60.         } catch (SQLException throwables) {
    61.             throwables.printStackTrace();
    62.         } finally {
    63.             //6.释放资源
    64.             if (rs != null){
    65.                 try {
    66.                     rs.close();
    67.                 } catch (SQLException throwables) {
    68.                     throwables.printStackTrace();
    69.                 }
    70.             }
    71.             if (ps != null){
    72.                 try {
    73.                     ps.close();
    74.                 } catch (SQLException throwables) {
    75.                     throwables.printStackTrace();
    76.                 }
    77.             }
    78.             if (conn != null){
    79.                 try {
    80.                     conn.close();
    81.                 } catch (SQLException throwables) {
    82.                     throwables.printStackTrace();
    83.                 }
    84.             }
    85.         }
    86.         return loginSuccess;
    87.     }
    89.     /**
    90.      * 初始化用户信息
    91.      * @return 用户输入用户名和密码登录信息
    92.      */
    93.     private static Map<String,String> initUI() {
    94.         Scanner s = new Scanner(System.in);
    95.         System.out.println("用户名：");
    96.         String loginName = s.nextLine();
    97.         System.out.println("密码：");
    98.         String loginPwd = s.nextLine();
    99.         Map<String,String> userLoginInfo = new HashMap<>();
    100.         userLoginInfo.put("loginName",loginName);
    101.         userLoginInfo.put("loginPwd",loginPwd);
    102.         return userLoginInfo;
    104.     }
    105. }
    1. import java.sql.Connection;
    2. import java.sql.DriverManager;
    3. import java.sql.PreparedStatement;
    4. import java.sql.SQLException;
    6. public class JDBCTest09 {
    7.     public static void main(String[] args) {
    8.         Connection conn = null;
    9.         PreparedStatement ps = null;
    12.         try {
    13.             //注册驱动
    14.             Class.forName("com.mysql.cj.jdbc.Driver");
    15.             //获取连接
    16.             conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/bjpowernode?serverTimezone=GMT","root","hqw3.1415926");
    17.             //获取预编译的数据库对象
    18.             String sql = "insert into dept(deptno,dname,loc) values (?,?,?)";
    19.             ps = conn.prepareStatement(sql);
    20.             ps.setInt(1,60);
    21.             ps.setString(2,"销售部");
    22.             ps.setString(3,"上海");
    24.             //执行sql
    25.             int count = ps.executeUpdate();
    26.             System.out.println(count);
    28.         } catch (ClassNotFoundException e) {
    29.             e.printStackTrace();
    30.         } catch (SQLException throwables) {
    31.             throwables.printStackTrace();
    32.         } finally {
    33.             if (ps != null){
    34.                 try {
    35.                     ps.close();
    36.                 } catch (SQLException throwables) {
    37.                     throwables.printStackTrace();
    38.                 }
    39.             }
    40.             if (conn != null){
    41.                 try {
    42.                     conn.close();
    43.                 } catch (SQLException throwables) {
    44.                     throwables.printStackTrace();
    45.                 }
    46.             }
    47.         }
    48.     }
    49. }
    • JDBC事务机制

    JDBC中只要完成一个DML语句就提交一次

    1. import java.sql.Connection;
    2. import java.sql.DriverManager;
    3. import java.sql.PreparedStatement;
    4. import java.sql.SQLException;
    6. /**
    7.  * sql脚本：
    8.  *      drop table if exists t_act;
    9.  *      create table t_act(
    10.  *              actno bigint,
    11.  *              balance double(7,2)
    12.  *      );
    13.  *      insert into t_act(actno,balance) values (111,20000);
    14.  *      insert into t_act(actno,balance) values (222,0);
    15.  *      commit;
    16.  *      select * from t_act;
    17.  */
    18. public class JDBCTest10 {
    19.     public static void main(String[] args) {
    20.         Connection conn = null;
    21.         PreparedStatement ps = null;
    23.         try {
    24.             Class.forName("com.mysql.cj.jdbc.Driver");
    25.             conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/bjpowernode","root","hqw3.1415926");
    27.             //将自动提交机制调整为手动提交,开启事务
    28.             conn.setAutoCommit(false);
    30.             String sql = "update t_act set balance = ? where actno = ?";
    31.             ps = conn.prepareStatement(sql);
    33.             ps.setDouble(1,10000);
    34.             ps.setDouble(2,111);
    35.             int count = ps.executeUpdate();
    36.             ps.setDouble(1,10000);
    37.             ps.setDouble(2,222);
    38.             count += ps.executeUpdate();
    40.             System.out.println(count ==2 ? "转账成功" : "转账失败");
    42.             //程序能走到这说明没有异常，事务结束，手动提交
    43.             conn.commit();
    45.         } catch (ClassNotFoundException e) {
    46.             //回滚事务
    47.             if (conn != null) {
    48.                 try {
    49.                     conn.rollback();
    50.                 } catch (SQLException throwables) {
    51.                     throwables.printStackTrace();
    52.                 }
    53.             }
    54.             e.printStackTrace();
    55.         } catch (SQLException throwables) {
    56.             throwables.printStackTrace();
    57.         } finally {
    58.             if (ps != null){
    59.                 try {
    60.                     ps.close();
    61.                 } catch (SQLException throwables) {
    62.                     throwables.printStackTrace();
    63.                 }
    64.             }
    65.             if (conn != null){
    66.                 try {
    67.                     conn.close();
    68.                 } catch (SQLException throwables) {
    69.                     throwables.printStackTrace();
    70.                 }
    71.             }
    72.         }
    73.     }
    74. }

    自建工具类并实现模糊查询

    1. import java.sql.*;
    3. public class DBUtil {
    4.     /**
    5.      * 工具类中的构造方法都是私有的
    6.      * 因为工具类中的方法是静态的，不需要new对象，直接采用类名调用
    7.      */
    8.     private DBUtil(){}
    10.     //静态代码块在类加载时只执行一次
    11.     static {
    12.         try {
    13.             Class.forName("com.mysql.cj.jdbc.Driver");
    14.         } catch (ClassNotFoundException e) {
    15.             e.printStackTrace();
    16.         }
    17.     }
    19.     /**
    20.      * 获取数据库连接对象
    21.      * @return 连接对象
    22.      * @throws SQLException
    23.      */
    24.     public static Connection getConnection() throws SQLException {
    25.         return DriverManager.getConnection("jdbc:mysql://localhost:3306/bjpowernode?serverTimezone=GMT","root","hqw3.1415926");
    26.     }
    28.     /**
    29.      * 关闭资源
    30.      * @param conn 连接对象
    31.      * @param ps 数据库操作对象
    32.      * @param rs 结果集
    33.      */
    34.     public static void close(Connection conn, Statement ps, ResultSet rs){
    35.         if (rs != null){
    36.             try {
    37.                 rs.close();
    38.             } catch (SQLException throwables) {
    39.                 throwables.printStackTrace();
    40.             }
    41.         }
    42.         if (ps != null){
    43.             try {
    44.                 ps.close();
    45.             } catch (SQLException throwables) {
    46.                 throwables.printStackTrace();
    47.             }
    48.         }
    49.         if (conn != null){
    50.             try {
    51.                 conn.close();
    52.             } catch (SQLException throwables) {
    53.                 throwables.printStackTrace();
    54.             }
    55.         }
    56.     }
    57. }
    1. import java.sql.Connection;
    2. import java.sql.PreparedStatement;
    3. import java.sql.ResultSet;
    4. import java.sql.SQLException;
    6. public class JDBCTest12 {
    7.     public static void main(String[] args) {
    8.         Connection conn = null;
    9.         PreparedStatement ps = null;
    10.         ResultSet rs = null;
    11.         try {
    12.             //获取连接
    13.             conn = DBUtil.getConnection();
    14.             //获取预编译的数据库操作对象
    15.             /*
    16.             String sql = "select ename from emp where ename like '_?%'";
    17.             ps = conn.prepareStatement(sql);
    18.             ps.setString(1,"A");
    19.             错误写法
    20.              */
    21.             String sql = "select ename from emp where ename like ?";
    22.             ps = conn.prepareStatement(sql);
    23.             ps.setString(1,"_A%");
    24.             rs = ps.executeQuery();
    26.             while (rs.next()){
    27.                 System.out.println(rs.getString("ename"));
    28.             }
    29.         } catch (SQLException throwables) {
    30.             throwables.printStackTrace();
    31.         } finally{
    32.             DBUtil.close(conn,ps,rs);
    33.         }
    34.     }
    35. }