一、JDBC的六步骤（背过）

第一步：注册驱动（作用：告诉Java程序，即将要连接的是哪个品牌的数据库）

第二步：获取连接（表示JVM的进程和数据库进程之间的通道打开了，这属于进程之间的通信，重量级的，使用完之后一定要关闭通道。）

第三步：获取数据库操作对象（专门执行sql语句的对象）

第四步：执行SQL语句（DQL DML….）

第五步：处理查询结果集（只有当第四步执行的是select语句的时候，才有这第五步处理查询结果集。）

第六步：释放资源（使用完资源之后一定要关闭资源。Java和数据库属于进程间的通信，开启之后一定要关闭。）

  1. import java.sql.*;
  2. public class JDBCTest01 {
  3.     public static void main(String[] args) {
  4.         Connection conn =null;
  5.         Statement stmt = null;
  6.         ResultSet rs =null;
  7.         try{
  8.             //1.注册驱动
  9.             Class.forName("com.mysql.jdbc.Driver");
  11.             //2.获取连接
  12.             conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/bjpowernode","root","333");
  14.             //3.获取数据库操作对象
  15.             stmt = conn.createStatement();
  17.             //4.执行sql
  18.             //int executeUpdate(insert/delete/update)
  19.             //ResultSet executeQuery(select)
  20.             String sql ="select empno as a,ename,sal from emp";
  21.             rs =stmt.executeQuery(sql);
  23.             //5.处理查询结果集
  24.             while(rs.next()){
  25.                 /*
  26.                 // 以指定的格式取出
  27.                 int empno = rs.getInt(1);
  28.                 String ename = rs.getString(2);
  29.                 double sal = rs.getDouble(3);
  30.                 System.out.println(empno + "," + ename + "," + (sal + 100));
  31.                 */
  32.                 // 按下标取出，程序不健壮
  33.                 int empno = rs.getInt("a");
  34.                 String ename = rs.getString("ename");
  35.                 double sal = rs.getDouble("sal");
  36.                 System.out.println(empno + "," + ename + "," + (sal + 200));
  37.             }
  41.         } catch (ClassNotFoundException e) {
  42.             e.printStackTrace();
  43.         } catch (SQLException throwables) {
  44.             throwables.printStackTrace();
  45.                 // 6、释放资源
  46.         }finally{
  47.             if(rs != null){
  48.                 try{
  49.                     rs.close();
  50.                 } catch (Exception e){
  51.                     e.printStackTrace();
  52.                 }
  53.             }
  54.             if(stmt != null){
  55.                 try{
  56.                     stmt.close();
  57.                 } catch (Exception e){
  58.                     e.printStackTrace();
  59.                 }
  60.             }
  61.             if(conn != null){
  62.                 try{
  63.                     conn.close();
  64.                 } catch (Exception e){
  65.                     e.printStackTrace();
  66.                 }
  67.             }
  68.         }
  70.     }
  71. }

二、SQL问题

该问题存在BUG
用户名:fdsa
密码:fdsa’ or ‘1’=’1登录成功
这种现象被称为SQL注入(安全隐患)。（黑客经常使用)5、导致SQL注入的根本原因是什么?
用户输入的信息中含有sql语句的关键字，并且这些关键字参与sql语句的编译过程，导致sql语句的原意被扭曲,进而达到SQL注入。

  1. package ustc.java.jdbc;
  2. import java.sql.*;
  3. import java.util.HashMap;
  4. import java.util.Map;
  5. import java.util.Scanner;
  7. /*
  8.     模拟实现用户登录功能
  9.  */
  10. public class JDBCTest06 {
  11.     public static void main(String[] args) {
  12.         // 初始化界面
  13.         Map<String,String> userLoginInfo = initUI();
  14.         // 验证用户名和密码
  15.         boolean loginSuccess = login(userLoginInfo);
  16.         // 输出最后结果
  17.         System.out.println(loginSuccess ? "登录成功" : "登录失败");
  18.     }
  20.     /**
  21.      * 用户登录
  22.      * @param userLoginInfo 用户登录信息
  23.      * @return true表示登录成功，false表示登录失败
  24.      */
  25.     private static boolean login(Map<String, String> userLoginInfo) {
  26.         //单独定义变量
  27.         String loginName = userLoginInfo.get("loginName");
  28.         String loginPwd = userLoginInfo.get("loginPwd");
  29.         boolean loginSuccess = false;
  30.         Connection conn = null;
  31.         Statement stmt = null;
  32.         ResultSet rs = null;
  33.         try {
  34.             // 1、注册驱动
  35.             Class.forName("com.mysql.jdbc.Driver");
  36.             // 2、获取连接
  37.             conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/bjpowernode","root","333");
  38.             // 3、获取数据库操作对象
  39.             stmt = conn.createStatement();
  40.             // 4、执行sql语句
  41.             String sql = "select * from t_user where loginName = '"+ loginName+ "' and loginPwd = '" + loginPwd+ "'";
  42.             rs = stmt.executeQuery(sql);
  43.             // 5、处理结果集
  44.             if(rs.next()) {
  45.                 loginSuccess = true;
  46.             }
  47.         } catch (ClassNotFoundException e) {
  48.             e.printStackTrace();
  49.         } catch (SQLException throwables) {
  50.             throwables.printStackTrace();
  51.         } finally {
  52.             // 6、释放资源
  53.             if (rs != null) {
  54.                 try {
  55.                     rs.close();
  56.                 } catch (SQLException throwables) {
  57.                     throwables.printStackTrace();
  58.                 }
  59.             }
  60.             if (stmt != null) {
  61.                 try {
  62.                     stmt.close();
  63.                 } catch (SQLException throwables) {
  64.                     throwables.printStackTrace();
  65.                 }
  66.             }
  67.             if (conn != null) {
  68.                 try {
  69.                     conn.close();
  70.                 } catch (SQLException throwables) {
  71.                     throwables.printStackTrace();
  72.                 }
  73.             }
  74.         }
  75.         return loginSuccess;
  76.     }
  79.     /**
  80.      * 初试化界面
  81.      * @return 用户输入的用户名和密码等登录信息
  82.      */
  83.     private static Map<String, String> initUI() {
  84.         Scanner s = new Scanner(System.in);
  86.         System.out.print("请输入用户:");
  87.         String loginName = s.nextLine();
  88.         System.out.print("请输入密码:");
  89.         String loginPwd= s.nextLine();
  91.         Map<String,String> userLoginInfo = new HashMap<>();
  92.         userLoginInfo.put("loginName",loginName);
  93.         userLoginInfo.put("loginPwd",loginPwd);
  95.         return userLoginInfo;
  96.     }
  97. }

解决SQL注入问题
3、解决SQL注入的关键是什么?
用户提供的信息中即使含有sql语句的关键字，但是这些关键字并没有参与编译。不起作用。4、对比一下statement和Preparedstatement?
Statement存在sql注入问题，Preparedstatement解决了SQL注入问题。
Statement是编译一次执行一次。PreparedStatement是编译一次，可执行多次。Preparedstatement效率较高一些。Preparedstatement会在编译阶段做类型的安全检查。

  1. package ustc.java.jdbc;
  2. import java.sql.*;
  3. import java.util.HashMap;
  4. import java.util.Map;
  5. import java.util.Scanner;
  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 true表示登录成功，false表示登录失败
  21.      */
  22.     private static boolean login(Map<String, String> userLoginInfo) {
  23.         boolean loginSuccess = false;
  24.         Connection conn = null;
  25.         PreparedStatement ps = null;
  26.         ResultSet rs = null;
  27.         try {
  28.             // 1、注册驱动
  29.             Class.forName("com.mysql.jdbc.Driver");
  30.             // 2、获取连接
  31.             conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/bjpowernode","root","333");
  32.             // 3、获取预编译的数据库操作对象
  33.             // sql语句的框架中，一个?，表示一个占位符，一个?将来接收一个值。注意：?不要用单引号括起来
  34.             String sql = "select * from t_user where loginName = ? and loginPwd = ?";
  35.             // 程序执行到此处，会发送sql语句框架给DBMS，DBMS对sql语句框架进行预编译。
  36.             ps = conn.prepareStatement(sql);
  37.             // 给占位符?传值，第一个?的下标是1，第二个?的下标是2（JDBC中下标都从1开始）
  38.             ps.setString(1,userLoginInfo.get("loginName"));
  39.             ps.setString(2,userLoginInfo.get("loginPwd"));
  40.             // 4、执行sql语句
  41.             rs = ps.executeQuery();
  42.             // 5、处理结果集
  43.             if(rs.next()) {
  44.                 loginSuccess = true;
  45.             }
  46.         } catch (ClassNotFoundException e) {
  47.             e.printStackTrace();
  48.         } catch (SQLException throwables) {
  49.             throwables.printStackTrace();
  50.         } finally {
  51.             // 6、释放资源
  52.             if (rs != null) {
  53.                 try {
  54.                     rs.close();
  55.                 } catch (SQLException throwables) {
  56.                     throwables.printStackTrace();
  57.                 }
  58.             }
  59.             if (ps != null) {
  60.                 try {
  61.                     ps.close();
  62.                 } catch (SQLException throwables) {
  63.                     throwables.printStackTrace();
  64.                 }
  65.             }
  66.             if (conn != null) {
  67.                 try {
  68.                     conn.close();
  69.                 } catch (SQLException throwables) {
  70.                     throwables.printStackTrace();
  71.                 }
  72.             }
  73.         }
  74.         return loginSuccess;
  75.     }
  78.     /**
  79.      * 初试化界面
  80.      * @return 用户输入的用户名和密码等登录信息
  81.      */
  82.     private static Map<String, String> initUI() {
  83.         Scanner s = new Scanner(System.in);
  85.         System.out.print("请输入用户:");
  86.         String loginName = s.nextLine();
  87.         System.out.print("请输入密码:");
  88.         String loginPwd = s.nextLine();
  90.         Map<String,String> userLoginInfo = new HashMap<>();
  91.         userLoginInfo.put("loginName",loginName);
  92.         userLoginInfo.put("loginPwd",loginPwd);
  94.         return userLoginInfo;
  95.     }
  96. }

演示statement的用途
即什么时候使用statement
综上所述: Preparedstatement使用较多。只有极少数的情况下需要使用statement5、什么情况下必须使用statement呢?
业务方面要求必须支持sql注入的时候。
statement支持sql注入，凡是业务方面要求是需要进行sql语句拼接的，必须使用statement。 

  1. package ustc.java.jdbc;
  3. import java.sql.*;
  4. import java.util.Scanner;
  6. public class JDBCTest08 {
  7.     public static void main(String[] args) {
  8.         //用户在控制台输入desc就是降序，输入asc就是升序
  9.         Scanner s = new Scanner(System.in);
  10.         System.out.println("请输入desc或者asc");
  11.         String keyWords = s.nextLine();
  12.         //执行SQL
  13.         Connection conn = null;
  14.         Statement stmt = null;
  15.         ResultSet rs = null;
  17.         try {
  18.             Class.forName("com.mysql.jdbc.Driver");
  20.             conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/bjpowernode","root","333");
  22.             stmt = conn.createStatement();
  24.             String sql = "select ename from emp order by ename " + keyWords;
  25.             rs = stmt.executeQuery(sql);
  26.             //遍历结果集
  27.             while(rs.next()){
  28.                 System.out.println(rs.getString("ename"));
  29.             }
  31.         } catch (ClassNotFoundException e) {
  32.             e.printStackTrace();
  33.         } catch (SQLException throwables) {
  34.             throwables.printStackTrace();
  35.         } finally {
  36.             if (rs != null) {
  37.                 try {
  38.                     rs.close();
  39.                 } catch (SQLException throwables) {
  40.                     throwables.printStackTrace();
  41.                 }
  42.             }
  43.             if (stmt != null) {
  44.                 try {
  45.                     rs.close();
  46.                 } catch (SQLException throwables) {
  47.                     throwables.printStackTrace();
  48.                 }
  49.             }
  50.             if (conn != null) {
  51.                 try {
  52.                     rs.close();
  53.                 } catch (SQLException throwables) {
  54.                     throwables.printStackTrace();
  55.                 }
  56.             }
  57.         }
  58.     }
  59. }

三、JDBC事务机制

JDBC事务机制:
1、JDBc中的事务是自动提交的，什么是自动提交?
只要执行任意一条DML语句，则自动提交—次。这是JDBC默认的事务行为。但是在实际的业务当中，通常都是N条DML语句共同联合才能完成的，必须保证他们这些DML语句在同一个事务中同时成功或者同时失败。

文件名：t_act.sql 用途：bjpowernode； source …

  1. drop table if exists t_act;
  2. create table t_act(
  3.     actno int,
  4.     balance double(7,2)//注意7表示有效数字的个数，2表示小数位的个数。
  5. );
  6. insert into t_act(actno,balance) values(111,20000);
  7. insert into t_act(actno,balance) values(222,0);
  8. commit;
  9. select * from t_act;
  1. /*重点三行代码：
  2.        conn.setAutoCommit(false);
  3.        conn.commit();
  4.        conn.rollback();
  5.  */
  6. package ustc.java.jdbc;
  7. import java.sql.Connection;
  8. import java.sql.DriverManager;
  9. import java.sql.PreparedStatement;
  10. import java.sql.SQLException;
  12. public class JDBCTest10 {
  13.     public static void main(String[] args) {
  14.         Connection conn = null;
  15.         PreparedStatement ps = null;
  16.         try {
  17.             // 注册驱动
  18.             Class.forName("com.mysql.jdbc.Driver");
  20.             // 获取连接
  21.             conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/bjpowernode","root","333");
  23.             // 将自动提交改为手动提交
  24.             conn.setAutoCommit(false);
  26.             // 获取预编译的数据库操作对象
  27.             String sql = "update t_act set balance = ? where actno = ? ";
  28.             ps = conn.prepareStatement(sql);
  29.             ps.setInt(1,10000);
  30.             ps.setDouble(2,111);
  32.             // 执行sql语句
  33.             int count = ps.executeUpdate();
  35.             /*String s = null;
  36.             s.toString();*/
  38.             ps.setInt(1,10000);
  39.             ps.setDouble(2,222);
  40.             count += ps.executeUpdate();
  42.             System.out.println(count == 2 ? "转账成功" : "转账失败");
  44.             // 程序能执行到此处，说明没有异常，事务结束，手动提交数据
  45.             conn.commit();
  46.         } catch (Exception e) {
  47.             // 遇到异常，回滚
  48.             if (conn != null) {
  49.                 try {
  50.                     conn.rollback();
  51.                 } catch (SQLException throwables) {
  52.                     throwables.printStackTrace();
  53.                 }
  54.             }
  55.             e.printStackTrace();
  56.         }  finally {
  57.             // 释放资源
  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. }

四、JDBC工具类的封装

  1. package ustc.java.jdbc;
  3. import java.sql.*;
  5. /*
  6.     JDBC工具类，简化JDBC编程
  7. */
  8. public class DBUtil {
  10.     /**
  11.      * 工具类中的构造方法是私有的
  12.      * 因为工具类中的方法都是静态的，不需要new对象，直接通过类名去调即可。
  13.      */
  14.     private DBUtil(){}
  16.     /**
  17.      * 静态代码块，类加载的时候执行
  18.      * 把注册驱动程序的代码放在静态代码块中，避免多次获取连接对象时重复调用
  19.      */
  20.     static {
  21.         try {
  22.             Class.forName("com.mysql.jdbc.Driver");
  23.         } catch (ClassNotFoundException e) {
  24.             e.printStackTrace();
  25.         }
  26.     }
  28.     public static Connection getConnection() throws SQLException {
  29.         return DriverManager.getConnection("jdbc:mysql://localhost:3306/bjpowernode","root","333");
  30.     }
  32.     /**
  33.      * 关闭资源
  34.      * @param conn   连接对象
  35.      * @param ps     数据库操作对象
  36.      * @param rs      结果集
  37.      */
  40.     public static void close(Connection conn, Statement ps, ResultSet rs){
  41.         if (rs != null) {
  42.             try {
  43.                 rs.close();
  44.             } catch (SQLException throwables) {
  45.                 throwables.printStackTrace();
  46.             }
  47.         }
  48.         if (ps != null) {
  49.             try {
  50.                 ps.close();
  51.             } catch (SQLException throwables) {
  52.                 throwables.printStackTrace();
  53.             }
  54.         }
  55.         if (conn != null) {
  56.             try {
  57.                 conn.close();
  58.             } catch (SQLException throwables) {
  59.                 throwables.printStackTrace();
  60.             }
  61.         }
  62.     }
  63. }

测试DBUtil工具类和模糊查询

  1. package ustc.java.jdbc;
  3. import java.sql.Connection;
  4. import java.sql.PreparedStatement;
  5. import java.sql.ResultSet;
  6. import java.sql.SQLException;
  8. /*
  9.     1、测试DBUtil工具类
  10.     2、模糊查询
  11.  */
  12. public class JDBCTest {
  13.     public static void main(String[] args) {
  14.         Connection conn = null;
  15.         PreparedStatement ps = null;
  16.         ResultSet rs = null;
  18.         try {
  19.             conn =  DBUtil.getConnection();
  21.             String sql = "select ename from emp where ename like ?";
  22.             ps = conn.prepareStatement(sql);
  23.             ps.setString(1,"_A%");
  25.             rs = ps.executeQuery();
  27.             while(rs.next()){
  28.                 System.out.println(rs.getString("ename"));
  29.             }
  30.         } catch (SQLException throwables) {
  31.             e.printStackTrace();
  32.         }finally{
  33.             DBUtil.close(conn,ps,rs);
  34.     }
  35. }