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的本质到底是什么？
    JDBC本质.jpg
    一套接口。
    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. package com.zxx.jdbc;
    3. import java.sql.Connection;
    4. import java.sql.DriverManager;
    5. import java.sql.SQLException;
    6. import java.sql.Statement;
    7. import java.util.ResourceBundle;
    9. public class JDBCTest01 {
    10.     public static void main(String[] args) {
    12.         Connection connection=null;
    13.         Statement statement= null;
    14.         //使用资源绑定器绑定属性配置文件
    15.         ResourceBundle bundle =ResourceBundle.getBundle("jdbc");
    17.         String url =bundle.getString("url");
    18.         String user=bundle.getString("user");
    20.         String password=bundle.getString("password");
    22.         try {
    23.             //1.类加载执行静态代码块，获取数据库驱动
    24.             Class.forName("com.mysql.jdbc.Driver");
    25.             //2.获取数据库连接
    26.             connection= DriverManager.getConnection(url,user,password);
    27.             //3.获取数据库操作对象
    28.              statement = connection.createStatement();
    29.             //4.执行sql
    30.             String sql="delete from emp where empno=7902 ";
    31.             int i = statement.executeUpdate(sql);
    32.             System.out.println(i);
    34.         } catch (ClassNotFoundException e) {
    35.             e.printStackTrace();
    36.         } catch (SQLException e) {
    37.             e.printStackTrace();
    38.         }
    40.         finally {
    41.             //5.关闭流
    42.             if (statement!=null){
    43.                 try {
    44.                     statement.close();
    45.                 } catch (SQLException e) {
    46.                     e.printStackTrace();
    47.                 }
    48.             }
    49.             if (connection!=null){
    50.                 try {
    51.                     connection.close();
    52.                 } catch (SQLException e) {
    53.                     e.printStackTrace();
    54.                 }
    55.             }
    56.         }
    57.     }
    58. }
    1. //jdbc.properties
    2. url=jdbc:mysql://localhost:3306/bjpowernode
    3. user=root
    4. password=root
    1. package com.zxx.jdbc;
    3. import java.sql.*;
    4. import java.util.ResourceBundle;
    6. public class JDBCTest01 {
    7.     public static void main(String[] args) {
    9.         Connection connection=null;
    10.         Statement statement= null;
    11.         //使用资源绑定器绑定属性配置文件
    12.         ResourceBundle bundle =ResourceBundle.getBundle("jdbc");
    14.         String url =bundle.getString("url");
    15.         String user=bundle.getString("user");
    17.         String password=bundle.getString("password");
    19.         try {
    20.             Class.forName("com.mysql.jdbc.Driver");
    21.             connection= DriverManager.getConnection(url,user,password);
    22.              statement = connection.createStatement();
    23.             String sql="select * from dept";
    24.             ResultSet resultSet = statement.executeQuery(sql);
    25.             //遍历结果集
    26.             while (resultSet.next()){
    27.                 //取第一个元素的数据
    28.               int deptno1=  resultSet.getInt(1);
    29.               //取列名为dept的元素，更加精准，推荐使用
    30.                int deptno2= resultSet.getInt("deptno");
    31.                 System.out.println(deptno1);
    32.                 System.out.println(deptno2);
    33.             }
    35.         } catch (ClassNotFoundException e) {
    36.             e.printStackTrace();
    37.         } catch (SQLException e) {
    38.             e.printStackTrace();
    39.         }
    41.         finally {
    42.             if (statement!=null){
    43.                 try {
    44.                     statement.close();
    45.                 } catch (SQLException e) {
    46.                     e.printStackTrace();
    47.                 }
    48.             }
    49.             if (connection!=null){
    50.                 try {
    51.                     connection.close();
    52.                 } catch (SQLException e) {
    53.                     e.printStackTrace();
    54.                 }
    55.             }
    56.         }
    57.     }
    58. }

    使用idea创建数据库驱动
    1.首先先创建一个空的project
    2020-11-27_174259.png

    2.创建一个空的java模块
    2020-11-27_174331.png
    3.选择以下选项
    2020-11-27_174451.png
    4.导入mysql驱动的jar包
    2020-11-27_174602.png

    用statement时会引发sql注入的问题

    1. package com.zxx.jdbc;
    3. import java.sql.*;
    4. import java.util.HashMap;
    5. import java.util.Map;
    6. import java.util.Scanner;
    8. public class JDBCTest02 {
    9.     public static void main(String[] args) {
    10.         //初始化界面
    11.         Map<String,String> userLoginInfo=initUI();
    12.         //验证用户名和密码
    13.        boolean loginSuccess= login(userLoginInfo);
    14.        //输出结果
    15.         System.out.println(loginSuccess ? "登录成功":"登录失败");
    16.     }
    18.     /**
    19.      *
    20.      * @param userLoginInfo 用户登录
    21.      * @return true 登录成功，false 登录失败
    22.      */
    23.     private static boolean login(Map<String, String> userLoginInfo) {
    24.         //JDBC代码
    25.         Connection connection=null;
    26.         Statement statement=null;
    27.         ResultSet resultSet=null;
    28.         boolean state=false;
    29.         //1.获取数据库驱动
    30.         try {
    31.             Class.forName("com.mysql.jdbc.Driver");
    32.             //2.获取数据库连接
    33.             connection= DriverManager.getConnection("jdbc:mysql://localhost:3306/bjpowernode","root","root");
    34.             //3.创建数据库操作对象
    35.             statement =connection.createStatement();
    36.             //4.执行sql
    38.             //在输入密码fs' or '1'='1会引发sql注入的问题
    39.             String sql ="select * from t_user where lgoinName='"+userLoginInfo.get("loginName")+"' and loginPassword='"+userLoginInfo.get("loginPassword")+"'";
    42.             resultSet = statement.executeQuery(sql);
    43.             //5.处理结果集
    44.             if (resultSet.next()){
    45.                 state=true;
    47.             }
    48.         } catch (ClassNotFoundException e) {
    49.             e.printStackTrace();
    50.         } catch (SQLException e) {
    51.             e.printStackTrace();
    52.         }
    53.         finally {
    54.             //6.关闭流
    55.             if (resultSet!=null){
    56.                 try {
    57.                     resultSet.close();
    58.                 } catch (SQLException e) {
    59.                     e.printStackTrace();
    60.                 }
    61.             }
    63.             if (statement!=null){
    64.                 try {
    65.                     statement.close();
    66.                 } catch (SQLException e) {
    67.                     e.printStackTrace();
    68.                 }
    69.             }
    71.             if (connection!=null){
    72.                 try {
    73.                     connection.close();
    74.                 } catch (SQLException e) {
    75.                     e.printStackTrace();
    76.                 }
    77.             }
    79.         }
    81.         return state;
    82.     }
    84.     /**
    85.      * 初始化用户界面
    86.      * @return 用户输入的用户名和密码等登录信息
    87.      */
    88.     private static Map<String, String> initUI() {
    89.         Scanner scanner=new Scanner(System.in);
    90.         System.out.println("用户名");
    91.         String loginName=scanner.nextLine();
    92.         System.out.println("密码");
    94.         String loginPassword=scanner.nextLine();
    95.         Map<String,String> userLoginInfo=new HashMap<>();
    96.         userLoginInfo.put("loginName",loginName);
    97.         userLoginInfo.put("loginPassword",loginPassword);
    98.         return userLoginInfo;
    99.     }
    100. }

    解决sql注入

    1. package com.zxx.jdbc;
    3. import java.sql.*;
    4. import java.util.HashMap;
    5. import java.util.Map;
    6. import java.util.Scanner;
    8. public class JDBCTest02 {
    9.     public static void main(String[] args) {
    10.         //初始化界面
    11.         Map<String,String> userLoginInfo=initUI();
    12.         //验证用户名和密码
    13.        boolean loginSuccess= login(userLoginInfo);
    14.        //输出结果
    15.         System.out.println(loginSuccess ? "登录成功":"登录失败");
    16.     }
    18.     /**
    19.      *
    20.      * @param userLoginInfo 用户登录
    21.      * @return true 登录成功，false 登录失败
    22.      */
    23.     private static boolean login(Map<String, String> userLoginInfo) {
    24.         //JDBC代码
    25.         Connection connection=null;
    26.         PreparedStatement statement=null;
    27.         ResultSet resultSet=null;
    28.         boolean state=false;
    29.         //1.获取数据库驱动
    30.         try {
    31.             Class.forName("com.mysql.jdbc.Driver");
    32.             //2.获取数据库连接
    33.             connection= DriverManager.getConnection("jdbc:mysql://localhost:3306/bjpowernode","root","root");
    34.             //3.创建预编译的数据库操作对象
    35.             //在编译前定好sql语句的格式
    36.             String sql ="select * from t_user where lgoinName=? and loginPassword=?";
    37.             //程序执行到此处，会发送sql语句框子给DBMS 然后DBMS进行sql语句的预先编译
    38.             statement=connection.prepareStatement(sql);
    39.             //给占位符?传值 第一个问号下标是1 第二个问号下标是2
    40.             statement.setString(1,userLoginInfo.get("loginName"));
    41.             statement.setString(2,userLoginInfo.get("loginPassword"));
    43.             //4.执行sql
    49.             resultSet = statement.executeQuery();
    50.             //5.处理结果集
    51.             if (resultSet.next()){
    52.                 state=true;
    54.             }
    55.         } catch (ClassNotFoundException e) {
    56.             e.printStackTrace();
    57.         } catch (SQLException e) {
    58.             e.printStackTrace();
    59.         }
    60.         finally {
    61.             //6.关闭流
    62.             if (resultSet!=null){
    63.                 try {
    64.                     resultSet.close();
    65.                 } catch (SQLException e) {
    66.                     e.printStackTrace();
    67.                 }
    68.             }
    70.             if (statement!=null){
    71.                 try {
    72.                     statement.close();
    73.                 } catch (SQLException e) {
    74.                     e.printStackTrace();
    75.                 }
    76.             }
    78.             if (connection!=null){
    79.                 try {
    80.                     connection.close();
    81.                 } catch (SQLException e) {
    82.                     e.printStackTrace();
    83.                 }
    84.             }
    86.         }
    88.         return state;
    89.     }
    91.     /**
    92.      * 初始化用户界面
    93.      * @return 用户输入的用户名和密码等登录信息
    94.      */
    95.     private static Map<String, String> initUI() {
    96.         Scanner scanner=new Scanner(System.in);
    97.         System.out.println("用户名");
    98.         String loginName=scanner.nextLine();
    99.         System.out.println("密码");
    101.         String loginPassword=scanner.nextLine();
    102.         Map<String,String> userLoginInfo=new HashMap<>();
    103.         userLoginInfo.put("loginName",loginName);
    104.         userLoginInfo.put("loginPassword",loginPassword);
    105.         return userLoginInfo;
    106.     }
    107. }

    解决sql注入的关键：用户提供的信息中含有sql关键字，但是这些关键字并没有参与编译 不起作用

    statement和preparestatement的区别
    前者存在sql注入
    前者编译一次执行一次 后者编译一次 可执行多次 效率更高
    后者会在编译阶段进行安全检查
    当业务要求sql注入时才会使用前者

    jdbc的事务是自动提交的 每执行一条sql语句 就会提交一次 而具体业务有多条sql
    重点三行代码

    conn.setAutoCommit(false) 关闭自动提交 改为手动
    conn.commit()提交
    conn.rollback()回滚
    悲观锁（行级锁for update）和乐观锁机制.jpg