JDBC的Jar包下载

image.pngimage.png

JDBC基本连接步骤：

**

步骤：

  1. 导入驱动jar包 mysql-connector-java-5.1.37-bin.jar 1.复制mysql-connector-java-5.1.37-bin.jar到项目的libs目录下 2.右键—>Add As Library
    1. 注册驱动
    2. 获取数据库连接对象 Connection
    3. 定义sql
    4. 获取执行sql语句的对象 Statement
    5. 执行sql，接受返回结果
    6. 处理结果
    7. 释放资源
  1. //代码实现：
  2.     //1. 导入驱动jar包
  3.     //2.注册驱动
  4.     Class.forName("com.mysql.jdbc.Driver");
  5.     //3.获取数据库连接对象
  6.     Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/db3", "root", "root");
  7.     //4.定义sql语句
  8.     String sql = "update account set balance = 500 where id = 1";
  9.     //5.获取执行sql的对象 Statement
  10.     Statement stmt = conn.createStatement();
  11.     //6.执行sql
  12.     int count = stmt.executeUpdate(sql);
  13.     //7.处理结果
  14.     System.out.println(count);
  15.     //8.释放资源
  16.     stmt.close();
  17.     conn.close();

JDBC异常捕捉版本：

  2. //代码：
  3.     Statement stmt = null;
  4.     Connection conn = null;
  5.     try {
  6.         //1. 注册驱动
  7.         Class.forName("com.mysql.jdbc.Driver");
  8.         //2. 定义sql
  9.         String sql = "insert into account values(null,'王五',3000)";
  10.         //3.获取Connection对象
  11.         conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/db3", "root", "root");
  12.         //4.获取执行sql的对象 Statement
  13.         stmt = conn.createStatement();
  14.         //5.执行sql
  15.         int count = stmt.executeUpdate(sql);//影响的行数
  16.         //6.处理结果
  17.         System.out.println(count);
  18.         if(count > 0){
  19.             System.out.println("添加成功！");
  20.         }else{
  21.             System.out.println("添加失败！");
  22.         }
  24.     } catch (ClassNotFoundException e) {
  25.         e.printStackTrace();
  26.     } catch (SQLException e) {
  27.         e.printStackTrace();
  28.     }finally {
  29.         //stmt.close();
  30.         //7. 释放资源
  31.         //避免空指针异常
  32.         if(stmt != null){
  33.             try {
  34.                 stmt.close();
  35.             } catch (SQLException e) {
  36.                 e.printStackTrace();
  37.             }
  38.         }
  40.         if(conn != null){
  41.             try {
  42.                 conn.close();
  43.             } catch (SQLException e) {
  44.                 e.printStackTrace();
  45.             }
  46.         }
  47.     }

通过上列代码可以发现，每当我们需要对DB进行操作时都要经过DB的连接与释放，代码重复率过高。

抽取JDBC工具类 ： JDBCUtils

目的：简化书写

分析：

  1. 注册驱动也抽取
  2. 抽取一个方法获取连接对象
    • 需求：不想传递参数（麻烦），还得保证工具类的通用性。
    • 解决：配置文件

jdbc.properties 内部配置： url=jdbc:mysql://localhost:3306/db3 user=root password=root driver=com.mysql.jdbc.Driver

  1. /**
  2.  * JDBC工具类
  3.  */
  4. public class JDBCUtils {
  5.     private static String url;
  6.     private static String user;
  7.     private static String password;
  8.     private static String driver;
  9.     /**
  10.      * 文件的读取，只需要读取一次即可拿到这些值。使用静态代码块
  11.      */
  12.     static{
  13.         //读取资源文件，获取值。
  14.         try {
  15.             //1. 创建Properties集合类。
  16.             Properties pro = new Properties();
  17.             //获取src路径下的文件的方式--->ClassLoader 类加载器
  18.             ClassLoader classLoader = JDBCUtils.class.getClassLoader();
  19.             URL res  = classLoader.getResource("jdbc.properties");
  20.             String path = res.getPath();
  22.             //2. 加载文件
  23.             pro.load(new FileReader(path));
  25.             //3. 获取数据，赋值
  26.             url = pro.getProperty("url");
  27.             user = pro.getProperty("user");
  28.             password = pro.getProperty("password");
  29.             driver = pro.getProperty("driver");
  31.             //4. 注册驱动
  32.             Class.forName(driver);
  33.         } catch (IOException e) {
  34.             e.printStackTrace();
  35.         } catch (ClassNotFoundException e) {
  36.             e.printStackTrace();
  37.         }
  38.     }
  40.     /**
  41.      * 获取连接
  42.      * @return 连接对象
  43.      */
  44.     public static Connection getConnection() throws SQLException {
  46.         return DriverManager.getConnection(url, user, password);
  47.     }
  49.     /**
  50.      * 释放资源
  51.      * @param stmt
  52.      * @param conn
  53.      */
  54.     public static void close(Statement stmt,Connection conn){
  55.         if( stmt != null){
  56.             try {
  57.                 stmt.close();
  58.             } catch (SQLException e) {
  59.                 e.printStackTrace();
  60.             }
  61.         }
  63.         if( conn != null){
  64.             try {
  65.                 conn.close();
  66.             } catch (SQLException e) {
  67.                 e.printStackTrace();
  68.             }
  69.         }
  70.     }
  73.     /**
  74.      * 释放资源
  75.      * @param stmt
  76.      * @param conn
  77.      */
  78.     public static void close(ResultSet rs,Statement stmt, Connection conn){
  79.         if( rs != null){
  80.             try {
  81.                 rs.close();
  82.             } catch (SQLException e) {
  83.                 e.printStackTrace();
  84.             }
  85.         }
  87.         if( stmt != null){
  88.             try {
  89.                 stmt.close();
  90.             } catch (SQLException e) {
  91.                 e.printStackTrace();
  92.             }
  93.         }
  95.         if( conn != null){
  96.             try {
  97.                 conn.close();
  98.             } catch (SQLException e) {
  99.                 e.printStackTrace();
  100.             }
  101.         }
  102.     }
  104. }

PreparedStatement 介绍

目的：

  • 可以防止SQL注入
  • 效率更高

详解各个对象： **

  1. DriverManager：驱动管理对象

    • 注册驱动：告诉程序该使用哪一个数据库驱动jar
      • 代码使用：Class.forName(“com.mysql.jdbc.Driver”);
      • 注意：mysql5 之后的驱动 jar 包可以省略注册驱动的步骤

    • 获取数据库连接：

      • 方法：

        • static Connection getConnection(String url, String user, String password)

      • 参数：

        1. url：指定连接的路径

          • 语法：jdbc:mysql://ip地址(域名):端口号/数据库名称
          • 例子：jdbc:mysql://localhost:3306/db3 ** ** (db3为数据库名)
          • 细节：本机mysql服务器，且默认端口3306，则url可简写：jdbc:mysql:///db3

        2. user：用户名

        3. password：密码

  1. Connection：数据库连接对象

    • 功能：

      • 获取执行sql 的对象

        • Statement createStatement()
        • PreparedStatement prepareStatement(String sql)

    • 管理事务：

      • 开启事务：setAutoCommit(boolean autoCommit) 设置参数为false，即开启事务
      • 提交事务：commit()
      • 回滚事务：rollback()

  1. Statement：执行 sql 的对象

    • boolean execute (String sql) 

      1. - 可以执行任意的sql 了解

    • int executeUpdate(String sql) 

      1. - 执行**DML**（insert、update、delete）语句、**DDL**(create，alter、drop)语句
      2. - 返回值：影响的行数，可以通过这个影响的行数判断DML语句是否执行成功 
      4.    - 返回值>0的则执行成功，反之，则失败。

    • ResultSet executeQuery(String sql) 

      1. - 执行**DQL**（select) 语句

  1. ResultSet：结果集对象，封装查询结果

    • 方法：

      • boolean next()

        • 游标向下移动一行，判断当前行是否是最后一行末尾 ( 是否有数据 )

          • 如果是，则返回false，如果不是则返回true

      • getXxx ( 参数 )

        • 获取数据
        • Xxx：代表数据类型 如： int getInt( ) , String getString( )

        • 参数：

          • int： 代表列的编号，从1开始 如： getString(1)
          • String：代表列名称。 如： getDouble(“balance”)

**

  1. PreparedStatement：执行sql的对象

原因：SQL注入问题：在拼接sql时，有一些sql的特殊关键字参与字符串的拼接。会造成安全性问题

  1.      1. 输入用户随便，输入密码：a' or 'a' = 'a
  2.      1. sql：select * from user where username = 'fhdsjkf' and password = 'a' **or 'a' = 'a' **

**

为解决sql注入问题：使用PreparedStatement对象来解决

预编译的SQL：参数使用 ? 作为占位符

  • 步骤：

    1. 1. 导入驱动jar包 mysql-connector-java-5.1.37-bin.jar
    2. 1. 注册驱动
    3. 1. 获取数据库连接对象 Connection
    4. 1.  定义sql
    6.    - 注意：sql 的参数**使用 ？作为占位符**。 
    7.    -  如：**select * from user where username = ? and password = ?;**
    9. 5. 获取执行sql语句的对象 PreparedStatement  Connection.prepareStatement(String sql)  
    10. 5. 给？赋值：
    12.    - 方法： setXxx(参数1,参数2)
    14.       - 参数1：？的位置编号 从1 开始
    15.       - 参数2：？的值
    17. 7. 执行sql，接受返回结果，不需要传递sql语句
    18. 7. 处理结果
    19. 7. 释放资源

  • 注意：后期都会使用PreparedStatement来完成增删改查的所有操作

    1. - 可以防止SQL注入
    2. - 效率更高



**

JDBCUtils配合PreparedStatement 的使用

利用 JDBCUtils 工具类极大的简化了代码的重复使用量，以及提高了代码的复用性

  1. public class JDBCDemo {
  3.     /**
  4.      * 登录方法,使用PreparedStatement实现
  5.      */
  6.     public boolean login(String username ,String password){
  7.         if(username == null || password == null){
  8.             return false;
  9.         }
  10.         //连接数据库判断是否登录成功
  11.         Connection conn = null;
  12.         PreparedStatement pstmt =  null;
  13.         ResultSet rs = null;
  14.         //1.获取连接
  15.         try {
  16.             conn =  JDBCUtils.getConnection();
  17.             //2.定义sql
  18.             String sql = "select * from user where username = ? and password = ?";
  19.             //3.获取执行sql的对象
  20.             pstmt = conn.prepareStatement(sql);
  21.             //给?赋值
  22.             pstmt.setString(1,username);
  23.             pstmt.setString(2,password);
  24.             //4.执行查询,不需要传递sql
  25.             rs = pstmt.executeQuery();
  26.             //5.判断
  27.             return rs.next();//如果有下一行，则返回true
  29.         } catch (SQLException e) {
  30.             e.printStackTrace();
  31.         }finally {
  32.             JDBCUtils.close(rs,pstmt,conn);
  33.         }
  34.         return false;
  35.     }
  36. }