【JDBC】自学JDBC笔记经常回顾加深印象点赞收藏

最新推荐文章于 2023-12-21 19:20:03 发布

23.

最新推荐文章于 2023-12-21 19:20:03 发布

阅读量189

点赞数 1

分类专栏： Java 文章标签： java 数据库

本文链接：https://blog.csdn.net/weixin_42383981/article/details/124598625

版权

Java 专栏收录该内容

7 篇文章 0 订阅

订阅专栏

1、JDBC是什么？
Java DataBase Connectivity（Java数据库连接）。

2、JDBC的本质是什么？
JDBC是SUN公司制定的一套接口（interface）
java.sql.*; （在这个软件包下有很多接口）

接口都有调用者和实现者。
面向接口调用、面向接口写实现类，这都属于面向接口编程。

为什么要面向接口编程？
解耦合：降低程序的耦合度，提高程序的扩展性。（降低Java程序员和数据库厂家的耦合）
多态机制就是非常典型的：面向抽象编程。（不要面向具体编程）

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

JDBC的本质到底是什么？
一套接口。

驱动：
所有的数据库驱动都是以jar包的形式存在，jar包当中有很多.class文件，这些class文件都是对JDBC接口的实现。
驱动不是SUN公司提供的，是各大数据库厂家负责提供，下载驱动jar包需要去数据库官网下载。

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和数据库属于进程间的通信，开启之后一定要关闭。）

URL：统一资源定位符（网络中某个资源的绝对路径）
https://www.baidu.com/ 这就是URL。
URL包括哪几部分？
协议
IP
端口
资源名

http://182.61.200.7:80/index.html
http:// 通信协议
182.61.200.7 服务器IP地址
80 服务器上软件的端口
index.html 是服务器上某个资源名

jdbc:mysql://127.0.0.1:3306/bjpowernode
jdbc:mysql:// 协议
127.0.0.1 IP协议
3306 mysql数据库端口号
bjpowernode 具体的数据库实例名

说明：localhost和127.0.0.1都是本机IP地址。

什么是通信协议，有什么用？
通信协议是通信之前就提前定好的数据传送格式。
数据包具体怎么传数据，格式提前定好的。

JDBC中的sql语句不需要提供分号结尾。

import java.sql.Driver;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Connection;
import java.sql.Statement;


public class JDBCTest01{
	public static void main(String[] args){
		Connection conn = null;
		Statement stmt = null;
		try{
			//1、注册驱动
			Driver driver = new com.mysql.jdbc.Driver(); //多态，父类型引用指向子类型对象。
			// Driver driver = new oracle.jdbc.driver.OracleDriver(); //Oracle的驱动
			DriverManager.registerDriver(driver);
			//2、获取连接
			String url = "jdbc:mysql://127.0.0.1:3306/bjpowernode";
			String user = "root";
			String password = "123456";
			conn = DriverManager.getConnection(url,user,password);
			System.out.println("数据库连接对象 = " + conn);

			//3、获取数据库操作对象
			stmt = conn.createStatement();

			//4、执行sql
			String sql = "insert into dept(deptno,dname,loc) values(50,'人事部','北京')";
			// 专门执行DML语句的(insert delete update)
			// 返回值是“影响数据库中的记录条数”
			int count = stmt.executeUpdate(sql);
			System.out.println(count == 1 ? "保存成功" : "保存失败");
			//5、处理查询结果集
		}catch(SQLException e){
			e.printStackTrace();
		}finally{
			//6、释放资源
			// 为了保证资源一定释放，在finally语句块中关闭资源
			// 并且要遵循从小到大依次关闭
			// 分别对其try...catch
			try{
				if(stmt != null){
					stmt.close();
				}
			}catch(SQLException e){
				e.printStackTrace();
			}
			try{
				if(conn != null){
					conn.close();
				}
			}catch(SQLException e){
				e.printStackTrace();
			}
		}
	}
}

注册驱动的第二种方式

类加载的方式注册驱动（常用的）
为什么这种方式常用？
因为参数是一个字符串，字符串可以写到xxx.properties文件中。以下方法不需要接收返回值，因为我们只想用它的类加载动作。

import java.sql.*;

public class JDBCTest03
{
	public static void main(String[] args){
		try{
			//注册驱动的第二种方式：常用的
			Class.forName("com.mysql.jdbc.Driver");
			//获取连接
			Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/bjpowernode","root","123456");
			System.out.println(conn);
		}catch(SQLException e){
			e.printStackTrace();
		}catch(ClassNotFoundException e){
			e.printStackTrace();
		}
	}
}

处理查询结果集(遍历结果集)

import java.sql.*;

public class JDBCTest05
{
	public static void main(String[] args){
		Connection conn = null;
		Statement stmt = null;
		ResultSet rs = null;
		try{
			//1、注册驱动
			Class.forName("com.mysql.jdbc.Driver");
			//2、获取连接
			conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/bjpowernode","root","123456");
			//3、获取数据库操作对象
			stmt = conn.createStatement();
			//4、执行sql
			String sql = "select empno,ename,sal from emp";
			rs = stmt.executeQuery(sql);
			//5、处理查询结果集
			while(rs.next()){
				String empno = rs.getString("empno");
				String ename = rs.getString("ename");
				double sal = rs.getDouble("sal");
				System.out.println(empno +","+ ename +","+ sal);
			}
		}catch(SQLException|ClassNotFoundException e){
			e.printStackTrace();
		}finally{
			//6、释放资源
			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();
				}
			}
		}
	}
}

使用IDEA配置驱动

用户登录业务

实现功能：
1、需求：
模拟用户登录功能的实现。
2、业务描述：
程序运行的时候，提供一个输入的入口，可以让用户输入用户名和密码，用户输入用户名和密码之后，
提交信息，java程序收集到用户信息。Java程序连接数据库验证用户名和密码是否合法。
合法：显示登录成功。
不合法：显示登录失败。
3、数据的准备：
在实际开发中，表的设计会使用专业的建模工具，PowerDesigner。
使用PD工具来进行数据库表的设计。（参见user-login.sql脚本）

package com.bjpowernode.jdbc;

import java.sql.*;
import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;
import java.util.Set;

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

    /**
     * 用户登录
     * @param userLoginInfo 用户登录信息
     * @return false表示失败，true表示成功
     */
    private static boolean login(Map<String, String> userLoginInfo) {
        //打标记的意识
        boolean loginSuccess = false;
        //获取登录的用户名和密码
        Set<Map.Entry<String, String>> entrySet = userLoginInfo.entrySet();
        String loginName = null;
        String loginPwd = null;
        for (Map.Entry<String, String> entry : entrySet){
            loginName = entry.getKey();
            loginPwd = entry.getValue();
        }
        //JDBC代码
        Connection conn = null;
        Statement stmt = null;
        ResultSet rs = null;

        try {
            //1、注册驱动
            Class.forName("com.mysql.cj.jdbc.Driver");
            //2、获取连接
            conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/bjpowernode?serverTimezone=Asia/Shanghai&useSSL=false&characterEncoding=UTF-8&useUnicode=true", "root", "123456");
            //3、获取数据库操作对象
            stmt = conn.createStatement();
            //4、执行sql

            String sql = "select * from t_user where loginName = '" + loginName + "' and loginPwd = '" + loginPwd + "'";
            rs = stmt.executeQuery(sql);
            //5、处理查询结果集
            if (rs.next()){
                //登录成功
                loginSuccess = true;
            }
        }catch (SQLException | ClassNotFoundException e){
            e.printStackTrace();
        }finally {
            //6、释放资源
            if (rs != null) {
                try {
                    rs.close();
                } catch (SQLException throwables) {
                    throwables.printStackTrace();
                }
            }
            if (stmt != null) {
                try {
                    stmt.close();
                } catch (SQLException throwables) {
                    throwables.printStackTrace();
                }
            }
            if (conn != null) {
                try {
                    conn.close();
                } catch (SQLException throwables) {
                    throwables.printStackTrace();
                }
            }
        }

        return loginSuccess;
    }

    /**
     * 初始化用户界面
     * @return 用户输入的用户名和密码等登录信息
     */
    private static Map<String, String> initUI() {
        Scanner in = new Scanner(System.in);

        System.out.print("用户名：");
        String loginName = in.nextLine();

        System.out.print("密码：");
        String loginPwd = in.nextLine();

        Map<String,String> map = new HashMap<>();
        map.put(loginName,loginPwd);

        return map;
    }
}

SQL注入

4、当前程序存在的问题：
用户名：fdsa
密码：fdsa’ or ‘1’='1
登录成功
这种现象被称为SQL注入。
5、导致sql注入的根本原因是什么？
用户输入的信息中含有sql语句的关键字，并且这些关键字参与sql语句的编译过程，导致sql语句的原意被扭曲，进而达到sql注入。

//1、注册驱动
Class.forName("com.mysql.cj.jdbc.Driver");
//2、获取连接
conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/bjpowernode?serverTimezone=Asia/Shanghai&useSSL=false&characterEncoding=UTF-8&useUnicode=true", "root", "123456");
//3、获取数据库操作对象
stmt = conn.createStatement();
//4、执行sql
String sql = "select * from t_user where loginName = '" + loginName + "' and loginPwd = '" + loginPwd + "'";
//以上正好完成了sql语句的拼接，以下代码的含义是：发送sql语句给DBMS，DBMS进行sql编译。
//正好将用户提供的“非法信息”编译进去，导致了原sql语句的含义被扭曲了。
rs = stmt.executeQuery(sql);
//5、处理查询结果集
if (rs.next()){
    //登录成功
    loginSuccess = true;
}

解决SQL注入问题

1、解决SQL注入问题？
只要用户提供的信息不参与SQL语句的编译过程，问题就解决了。
即使用户提供的信息中含有SQL语句的关键字，但是没有参与编译，不起作用。
要想用户信息不参与SQL语句的编译，那么必须使用java.sql.PreparedStatement。
PreparedStatement接口继承了java.sql.Statement。
PreparedStatement是属于预编译的数据库操作对象。
PreparedStatement的原理是：预先对SQL语句的框架进行编译，然后再给出SQL语句传‘值’。
2、解决SQL注入的关键是什么？
用户提供的信息中即使含有sql语句的关键字，但是这些关键字并没有参与编译，不起作用。

//1、注册驱动
Class.forName("com.mysql.cj.jdbc.Driver");
//2、获取连接
conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/bjpowernode?serverTimezone=Asia/Shanghai&useSSL=false&characterEncoding=UTF-8&useUnicode=true", "root", "123456");
//3、获取数据库操作对象
// SQL语句的框子。其中1个?表示一个占位符，将来接收一个“值”，注意：占位符不能使用单引号括起来。
String sql = "select * from t_user where loginName = ? and loginPwd = ?";
// 程序执行到此处，会发送sql语句框子给DBMS，然后DBMS进行sql语句的预先编译。
ps = conn.prepareStatement(sql);
// 给占位符?传值（第一个问号下标是1，第2个问号下标是2，JDBC中所有下标从1开始。）
ps.setString(1,loginName);
ps.setString(2,loginPwd);
//4、执行sql
rs = ps.executeQuery();
//5、处理查询结果集
if (rs.next()){
    //登录成功
    loginSuccess = true;
}

编写sql语句的框架
编译sql语句（获取预编译的数据库操作对象）
给占位符传值
执行sql

Statement和PreparedStatement的区别

Statement存在sql注入的问题。PreparedStatement解决了SQL注入问题。
Statement是编译一次执行一次。PreparedStatement是编译一次，可执行N次。PreparedStatement效率较高一些。
PreparedStatement会在编译阶段做类型的安全检查。

综上所述：PreparedStatement使用较多，只有极少数的情况下需要使用Statement。

什么情况下必须使用Statement呢？
业务方面要求必须支持SQL注入的时候。
Statement支持SQL注入，凡是业务方面要求是需要进行sql语句拼接的，必须使用Statement。

演示Statement的用途

// 用户在控制台输入desc就是降序，输入asc就是升序
Scanner in = new Scanner(System.in);
System.out.println("输入desc或asc，desc表示降序，asc表示升序");
System.out.print("请输入：");
String keyWords = in.nextLine();

Connection conn = null;
Statement stmt = null;
ResultSet rs = null;
try{
    // 注册驱动
    Class.forName("com.mysql.cj.jdbc.Driver");
    // 获取连接
    conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/bjpowernode?serverTimezone=Asia/Shanghai&useSSL=false&characterEncoding=UTF-8&useUnicode=true","root","123456");
    // 获取数据库操作对象
    stmt = conn.createStatement();
    // 执行sql
    String sql = "select ename from emp order by ename " + keyWords;
    rs = stmt.executeQuery(sql);
    // 遍历结果集
    while (rs.next()){
        System.out.println(rs.getString("ename"));
    }

PreparedStatement完成增删改

// 注册驱动
Class.forName("com.mysql.cj.jdbc.Driver");
// 获取连接
conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/bjpowernode?serverTimezone=Asia/Shanghai&useSSL=false&characterEncoding=UTF-8&useUnicode=true","root","123456");
// 获取预编译的数据库操作对象
/*            String sql = "insert into dept(deptno, dname, loc) values(?,?,?)";
ps = conn.prepareStatement(sql);
ps.setInt(1,60);
ps.setString(2,"销售部");
ps.setString(3,"上海");*/
/*            String sql = "update dept set dname=?, loc=? where deptno=?";
ps = conn.prepareStatement(sql);
ps.setString(1,"研发一部");
ps.setString(2,"北京");
ps.setInt(3,60);           */
String sql = "delete from dept where deptno=?";
ps = conn.prepareStatement(sql);
ps.setInt(1,60);
// 执行SQL
int count = ps.executeUpdate();
System.out.println(count);

JDBC的事务自动提交机制

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

重点三行代码：
conn.setAutoCommit(false);
conn.commit();
conn.rollback();

JDBC工具类的封装

技巧经验：
工具类中的构造方法都是私有的。
因为工具类当中的方法都是静态的，不需要new对象，直接采用类名调用。

package com.bjpowernode.jdbc.utils;

import java.sql.*;

/**
 * JDBC工具类，简化JDBC编程
 */
public class DBUtil {
    /**
     * 工具类中的构造方法都是私有的。
     * 因为工具类当中的方法都是静态的，不需要new对象，直接采用类名调用。
     */
    private DBUtil() {
    }

    // 静态代码块在类加载时执行，并且只执行一次。
    static {
        try {
            Class.forName("com.mysql.cj.jdbc.Driver");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }

    /**
     * 获取数据库连接对象
     * @return 连接对象
     * @throws SQLException
     */
    public static Connection getConnection() throws SQLException {
        return DriverManager.getConnection("jdbc:mysql://localhost:3306/bjpowernode?serverTimezone=Asia/Shanghai&useSSL=false&characterEncoding=UTF-8&useUnicode=true","root","123456");
    }

    /**
     * 关闭资源
     * @param conn 连接对象
     * @param ps 数据库操作对象
     * @param rs 结果集
     */
    public static void close(Connection conn, Statement ps, ResultSet rs){
        if (rs != null) {
            try {
                rs.close();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }
        if (ps != null) {
            try {
                ps.close();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }
        if (conn != null) {
            try {
                conn.close();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }
    }
}

JDBC实现模糊查询

package com.bjpowernode.jdbc;

import com.bjpowernode.jdbc.utils.DBUtil;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

/**
 * 这个程序两个任务：
 * 第一：测试DBUtil是否好用
 * 第二：模糊查询怎么写？
 */
public class JDBCTest12 {
    public static void main(String[] args) {
        Connection conn = null;
        PreparedStatement ps = null;
        ResultSet rs = null;
        try {
            // 获取连接
            conn = DBUtil.getConnection();
            // 编写sql语句框架
            String sql = "select ename from emp where ename like ?";
            // 获取预编译的数据库对象
            ps = conn.prepareStatement(sql);
            // 给占位符传值
            ps.setString(1,"_A%");
            // 执行SQL
            rs = ps.executeQuery();
            // 遍历结果集
            while (rs.next()){
                System.out.println(rs.getString("ename"));
            }
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        } finally {
            // 释放资源
            DBUtil.close(conn,ps,rs);
        }
    }
}

乐观锁和悲观锁的概念

悲观锁（或行级锁）：DQL语句后面添加for update。

案例：

package com.bjpowernode.jdbc;

import com.bjpowernode.jdbc.utils.DBUtil;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

/**
 * 这个程序开启一个事务，这个事务专门进行查询，并且使用行级锁/悲观锁，锁住相关的记录。
 */
public class JDBCTest13 {
    public static void main(String[] args) {
        Connection conn = null;
        PreparedStatement ps = null;
        ResultSet rs = null;
        try {
            conn = DBUtil.getConnection();
            // 开启事务
            conn.setAutoCommit(false);

            String sql = "select ename,job,sal from emp where job = ? for update";
            ps = conn.prepareStatement(sql);
            ps.setString(1,"MANAGER");

            rs = ps.executeQuery();
            while(rs.next()){
                System.out.println(rs.getString("ename") + "," + rs.getString("job") + "," + rs.getDouble("sal"));
            }

            // 提交事务
            conn.commit(); //在此处打断点，然后执行JDBCTest14，发现14执行一直没结束
        } catch (SQLException throwables) {
            // 回滚事务
            if (conn != null) {
                try {
                    conn.rollback();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
            throwables.printStackTrace();
        } finally {
            DBUtil.close(conn,ps,rs);
        }
    }
}

package com.bjpowernode.jdbc;

import com.bjpowernode.jdbc.utils.DBUtil;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;

public class JDBCTest14 {
    public static void main(String[] args) {
        Connection conn = null;
        PreparedStatement ps = null;

        try {
            conn = DBUtil.getConnection();
            // 开启事务
            conn.setAutoCommit(false);

            String sql = "update emp set sal = sal * 1.1 where job = ?";
            ps = conn.prepareStatement(sql);
            ps.setString(1,"MANAGER");
            int count = ps.executeUpdate();
            System.out.println(count);
            // 提交事务
            conn.commit();
        } catch (SQLException throwables) {
            // 回滚事务
            if (conn != null) {
                try {
                    conn.rollback();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
            throwables.printStackTrace();
        } finally {
            DBUtil.close(conn,ps,null);
        }
    }
}

23.

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
【JDBC】自学JDBC笔记经常回顾加深印象点赞收藏

1、JDBC是什么？Java DataBase Connectivity（Java数据库连接）。2、JDBC的本质是什么？JDBC是SUN公司制定的一套接口（interface）java.sql.*; （在这个软件包下有很多接口）接口都有调用者和实现者。面向接口调用、面向接口写实现类，这都属于面向接口编程。为什么要面向接口编程？解耦合：降低程序的耦合度，提高程序的扩展性。（降低Java程序员和数据库厂家的耦合）多态机制就是非常典型的：面向抽象编程。（不要面向具体编程）思考：为什么SUN制定一套JDB
复制链接

扫一扫