JDBC——基本概念

概念

Java Database Connectivity
Java数据库连接
Java语言操作数据库

JDBC本质

官方定义的一套操作所有关系型数据库的规则，即接口。
各个数据库厂商去实现这套接口，提供数据库驱动jar包。
可以使用这套接口（JDBC）编程，真正执行的代码是驱动jar包中的实现类

快速入门

步骤

1. 导入驱动jar包 mysql-connector-java-5.0.8-bin.jar

• 复制mysql-connector-java-5.0.8-bin.jar到项目中
• 右键–>Add as Library

2. 注册驱动
3. 获取数据库连接对象Connection
4. 定义sql
5. 获取执行sql语句的对象 Statement
6. 执行sql，接受返回结果
7. 处理结果
8. 释放资源

代码实现

详解各个对象

DriverManager : 驱动管理对象

功能:注册驱动:告诉程序该使用哪一个数据库驱动jar

static void registerDriver(Driver driver) : 注册与给定的驱动程序 DriverManager。
写代码使用：Class.forName(“com.mysql.jdbc.Driver”);
查看源码发现：在com.mysql.jdbc.Driver类中存在静态代码块

	static{
		try{
			java.sql.DriverManager.registerDriver(new Driver());
		}catch(SQLException E){
			throw new RuntimeException("Can't register driver!")
		}
	}

注意：mysql 5 之后的驱动jar包可以省略注册驱动的步骤

获取数据库连接

1. 方法： static Connection getConnection(String url,String user,String password)
2. 参数：

• url : 指定连接的路径
• 语法：jdbc:mysql://IP地址(域名):端口号/数据库名称
  • 例如：jdbc:mysql://localhost:3306/db20210907
• 细节: 如果连接的是本机的mysql服务器，并且mysql服务器默认端口号为3306，则url可以简写为：jdbc:mysql:///数据库名称
• user : 用户名
• password : 密码

Connection : 数据库连接对象

功能：获取执行sql的对象

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

管理事务

• 开启事务: setAutoCommit(boolean autoCommit) : 调用该方法设置参数为false，即开启事务
• 提交事务: commit()
• 回滚事务: rollback()

Statement : 执行sql的对象

执行sql

1. boolean execute(String sql) : 可以执行任意的sql（了解）
2. int executeUpdate(String sql) : 执行DML(insert、update、delete)语句、DDL(create、alter、drop)语句–>没有返回值
3. 返回值：影响的行数，可以通过影响的行数判断DML语句是否执行成功，返回值>0的则成功，反之，则失败。
4. ResultSet executeQuery(String sql) : 执行（select）语句

ResultSet : 结果集对象，封装查询结果

1. next() : 游标向下移动一行，判断当前行是否是最后一行末尾（是否有数据），如果是，则返回false，如果不是则返回true
2. getXxx() : 获取数据类型

• Xxx : 代表数据类型 如： int getInt() , String getString()
• 参数：
  • int : 代表列的编号，从1开始 如：getInt(1)
  • String : 代表列的名称 如：getString(“name”)
• 注意：
  • 使用步骤：
    • 游标向下移动一行
    • 判断是否有数据
    • 获取数据

PreparedStatement : 执行sql的对象

1. SQL注入问题：在拼接sql 时，有一些sql的特殊关键字参与字符串的拼接，会造成安全性问题
   随机输入用户名，输入密码: a’ or ’ a ’ = 'a
2. 解决sql注入问题：使用PreparedStatement对象来解决
3. 预编译的sql：参数使用 ? 作为占位符
4. 步骤：

• 导入驱动jar包 mysql-connector-java-5.0.8-bin.jar
• 注册驱动
• 获取连接对象Connection
• 定义sql
  • 注意：sql的参数使用 ? 作为占位符
    如：select * from user where username = ? and password = ?;
• 获取执行sql语句的对象 PreparedStatement Connnection.prepareStatement(String sql)
• 给 ? 赋值
  • 方法：setXxx(参数1，参数2)
  • 参数1： ? 的位置编号 从1开始
  • 参数2： ? 的值
• 执行sql，接受返回结果
• 处理结果
• 释放资源

5. 注意：后期都会使用PreparedStatement来完成增删改查的所有操作
   可以防止SQL注入
   效率更高

package org.ccit.demo;

import java.sql.*;
import java.util.Scanner;

import org.ccit.utils.JDBCUtils;

/**
 * 	1. 通过键盘录入用户名和密码
 * 	2. 判断用户是否登录成功
 */
public class demo1 {

    public static void main(String[] args) {
        //1.键盘录入，接受用户名和密码
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入用户名：");
        String username = sc.nextLine();
        System.out.println("请输入密码：");
        String password = sc.nextLine();
        //2.调用方法
        boolean flag = new demo1().login(username, password);
        //3.判断结果，输出不同语句
        if(flag){
            //登录成功
            System.out.println("登录成功！");
        }else{
            System.out.println("用户名或密码错误！");
        }


    }

    /**
     * 登录方法,使用PreparedStatement实现
     */
    public boolean login(String username ,String password){
        if(username == null || password == null){
            return false;
        }
        //连接数据库判断是否登录成功
        Connection conn = null;
        PreparedStatement pstmt =  null;
        ResultSet rs = null;
        //1.获取连接
        try {
            conn =  JDBCUtils.getConnection();
            //2.定义sql
            String sql = "select * from user where username = ? and password = ?";
            //3.获取执行sql的对象
            pstmt = conn.prepareStatement(sql);
            //给?赋值
            pstmt.setString(1,username);
            pstmt.setString(2,password);
            //4.执行查询,不需要传递sql
            rs = pstmt.executeQuery();
           
            return rs.next();//如果有下一行，则返回true

        } catch (SQLException e) {
            e.printStackTrace();
        }finally {
            JDBCUtils.close(rs,pstmt,conn);
        }
        return false;
    }
}

JDBC工具类：JDBCUtils

1. 目的：简化书写
2. 分析：

• 注册驱动地抽取
• 抽取一个方法获取连接对象
  • 需求：不想传递参数（麻烦），还要保证工具类的通用性
  • 解决：配置文件
    jdbc.properties
    url=
    user=
    password=
• 抽取一个方法释放资源
  

3. 工具类

package org.ccit.utils;

import java.io.FileReader;
import java.io.IOException;
import java.net.URL;
import java.sql.*;
import java.util.Properties;

/**
 * JDBC工具类
 */
public class JDBCUtils {
    private static String url;
    private static String user;
    private static String password;
    private static String driver;
    /**
     * 文件的读取，只需要读取一次即可拿到这些值。使用静态代码块
     */
    static{
        //读取资源文件，获取值。

        try {
            //1. 创建Properties集合类。
            Properties pro = new Properties();

            //获取src路径下的文件的方式--->ClassLoader 类加载器
            ClassLoader classLoader = JDBCUtils.class.getClassLoader();
            URL res  = classLoader.getResource("jdbc.properties");
            String path = res.getPath();
            
            //2. 加载文件
            pro.load(new FileReader(path));

            //3. 获取数据，赋值
            url = pro.getProperty("url");
            user = pro.getProperty("user");
            password = pro.getProperty("password");
            driver = pro.getProperty("driver");
            //4. 注册驱动
            Class.forName(driver);
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }


    /**
     * 获取连接
     * @return 连接对象
     */
    public static Connection getConnection() throws SQLException {

        return DriverManager.getConnection(url, user, password);
    }

    /**
     * 释放资源
     * @param stmt
     * @param conn
     */
    public static void close(Statement stmt,Connection conn){
        if( stmt != null){
            try {
                stmt.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }

        if( conn != null){
            try {
                conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }


    /**
     * 释放资源
     * @param stmt
     * @param conn
     */
    public static void close(ResultSet rs,Statement stmt, Connection conn){
        if( rs != null){
            try {
                rs.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }

        if( stmt != null){
            try {
                stmt.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }

        if( conn != null){
            try {
                conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }

}

JDBC控制事务

事务

一个包含多个步骤的业务操作，如果这个业务操作被事务管理，则这多个步骤要么同时成功，要么同时失败。

操作

• 开启事务
• 提交事务
• 回滚事务

使用Connection对象来管理事务

1. 开启事务：setAutoCommit(boolean autoCommit) ： 调用该方法设置参数为false，即开启事务
   在执行sql之前开启事务
2. 提交事务：commit()
   当所有sql语句都执行完提交事务
3. 回滚事务：rollback()
   在catch中回滚事务

代码演示

package org.ccit.demo;

import java.sql.*;

import org.ccit.utils.JDBCUtils;

public class demo2 {

	public static void main(String[] args) {
		Connection conn = null;
		PreparedStatement pstmt1 = null;
		PreparedStatement pstmt2 = null;
		
		try {
			//获取连接
			conn = JDBCUtils.getConnection();
			//开启事务
			conn.setAutoCommit(false);
			
			//定义sql
			//面包 cnt -10
			String sql1 = "update goods set cnt = cnt -? where id = ?"; 
			//可乐 cnt +10
			String sql2 = "update goods set cnt = cnt +? where id = ?"; 
			//获取执行SQL对象
			pstmt1 = conn.prepareStatement(sql1);
			pstmt2 = conn.prepareStatement(sql2);
			
			//设置参数
			pstmt1.setDouble(1, 10);
			pstmt1.setDouble(2, 1);
			
			pstmt2.setDouble(1, 10);
			pstmt2.setDouble(2, 3);
			
			//执行sql
			pstmt1.execute();
			pstmt2.execute();
			//提交事务
			conn.commit();
			System.out.println("更改成功");
		} catch (Exception e) {
			e.printStackTrace();
			
			try {
				//事务回滚
				if(conn != null) {
					conn.rollback();
				}
			} catch (SQLException e1) {
				e1.printStackTrace();
			}
		}finally {
			JDBCUtils.close(pstmt1, conn);
			JDBCUtils.close(pstmt2, null);
		}
	}
}