（尚硅谷）JDBC总复习

最新推荐文章于 2024-07-30 19:26:47 发布

每天都要学习的阿荣

最新推荐文章于 2024-07-30 19:26:47 发布

阅读量1k

点赞数 1

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

本文链接：https://blog.csdn.net/qq_42148002/article/details/124723280

版权

JDBC 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

第一章 JDBC概述

1、数据的持久化

持久化(persistence)：把数据保存到可掉电式存储设备中以供之后使用。
持久化的媒介：硬盘，关系型数据库，XML文件

2、JDBC的理解

JDBC(Java Database Connectivity)是一个独立于特定数据库管理系统、通用的SQL数据库存取和操作的公共接口（一组API）

简单理解为：JDBC，是SUN提供的一套 API，使用这套API可以实现对具体数据库的操作（获取连接、关闭连接、DML、DDL、DCL)

3、Java 与 MySQL 连接图示

在这里插入图片描述

好处 — 面向接口编程：

从开发程序员的角度：不需要关注具体的数据库的细节
数据库厂商：只需要提供标准的具体实现。

4、数据库的驱动

数据库针对 JDBC 这套接口，提供的具体实现类的集合。（也就是一个 jar 包，导入之后 Add as Library 来使用里面提供的代码）

5、面向接口编程的思想

JDBC 是 sun 公司提供一套用于数据库操作的接口，java 程序员只需要面向这套接口编程即可。
不同的数据库厂商，需要针对这套接口，提供不同实现。不同的实现的集合，即为不同数据库的驱动。

第二章数据库的连接

1、数据库连接的一般步骤

配置连接的基本信息：url、user、password
加载驱动：其实分为新建驱动、注册驱动和加载驱动三步，但是一般直接加载驱动，java 会自动的新建驱动和注册驱动（见下方代码，其中提供了静态代码块，来实现这两部分操作）
获得连接

2、数据库连接代码示例（MySQL）

掌握方式五即可，即在配置文件中读取连接基本信息，而不是在代码中直接写出基本信息，代码如下：

    /**
     * @return
     * @throws Exception
     * @Description 获取数据库的连接
     * @author shkstart
     * @date 上午9:11:23
     */
    public static Connection getConnection() throws Exception {
        // 1.读取配置文件中的4个基本信息
        // 当前类.class.获取类加载器.获取输入流的文件名
		// 自定义类是由系统类加载器加载的
        InputStream is = ClassLoader.getSystemClassLoader().getResourceAsStream("jdbc.properties");

        Properties pros = new Properties();
        pros.load(is);

        String user = pros.getProperty("user");
        String password = pros.getProperty("password");
        String url = pros.getProperty("url");
        String driverClass = pros.getProperty("driverClass");

        // 2.加载驱动
        Class.forName(driverClass);

        // 3.获取连接
        Connection conn = DriverManager.getConnection(url, user, password);
        return conn;
    }

注意！！！：

用 I/O 流的方式来获取配置文件
用系统类加载器来加载自定义类

其中，配置文件【jdbc.properties】：此配置文件声明在工程的src下（下面为 MySQL 8.0 版本的配置信息）

url=jdbc:mysql://localhost:3306/test
user=root
password=abc123
driverClass=com.mysql.cj.jdbc.Driver

使用配置文件的好处：

实现了代码和数据的分离，如果需要修改配置信息，直接在配置文件中修改，不需要深入代码；
如果修改了配置信息，省去重新编译的过程，代码效率更高。

3、JDBCUtils（操作数据库的工具类）

每一次与数据库交互都要进行连接，关闭资源等，所以将其封装成工具类，使用时直接调用即可。

package com.atguigu3.util;
/**
 * @author shkstart Email:shkstart@126.com
 * @Description 操作数据库的工具类
 * @date 上午9:10:02
 */
public class JDBCUtils {
    /**
     * @return
     * @throws Exception
     * @Description 获取数据库的连接
     * @author shkstart
     * @date 上午9:11:23
     */
    public static Connection getConnection() throws Exception {
        // 1.读取配置文件中的4个基本信息
        InputStream is = ClassLoader.getSystemClassLoader().getResourceAsStream("jdbc.properties");

        Properties pros = new Properties();
        pros.load(is);

        String user = pros.getProperty("user");
        String password = pros.getProperty("password");
        String url = pros.getProperty("url");
        String driverClass = pros.getProperty("driverClass");

        // 2.加载驱动
        Class.forName(driverClass);

        // 3.获取连接
        Connection conn = DriverManager.getConnection(url, user, password);
        return conn;
    }

    /**
     * @param conn
     * @param ps
     * @Description 关闭连接和Statement的操作
     * @author shkstart
     * @date 上午9:12:40
     */
    public static void closeResource(Connection conn, Statement ps) {
        try {
            if (ps != null)
                ps.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
        try {
            if (conn != null)
                conn.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    /**
     * @param conn，与数据库的连接资源
     * @param ps，PreparedStatement资源
     * @param rs，ResultSet结果集
     * @Description 关闭资源操作，方法的重载
     * @author shkstart
     * @date 上午10:21:15
     */
    public static void closeResource(Connection conn, Statement ps, ResultSet rs) {
        try {
            if (ps != null)
                ps.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
        try {
            if (conn != null)
                conn.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
        try {
            if (rs != null)
                rs.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

第三章：使用 PreparedStatement 实现 CRUD 操作

1、Statement 使用的弊端

存在拼串操作，繁琐
存在 SQL 注入问题
没办法操作Blob类型变量
实现批量插入时，效率较低

问题一（拼串操作）：

		Scanner scan = new Scanner(System.in);

		System.out.print("用户名：");
		String userName = scan.next();
		System.out.print("密   码：");
		String password = scan.next();

		// SELECT user,password FROM user_table WHERE USER = '1' or ' AND PASSWORD = ' ='1' or '1' = '1';
		String sql = "SELECT user,password FROM user_table WHERE USER = '" + userName + "' AND PASSWORD = '" + password + "'";

问题二（SQL注入），加黄字体就是输入的用户名和密码：
在这里插入图片描述

2、PreparedStatement 替换 Statement 实现 CRUD 操作

PreparedStatement的理解：
① PreparedStatement 是 Statement 的子接口
② An object that represents a precompiled SQL statement. （预编译 SQL 语句，只需要填空即可）
③ 可以解决Statement的sql注入问题，拼串问题

3、使用 PreparedStatement 实现通用的增、删、改的方法：version 1.0

获取与数据库的连接 Connection
预编译 sql 语句，返回 PreparedStatement 的实例
填充占位符
执行此 PreparedStatement 对象中的SQL语句
关闭 Connection，PreparedStatement 资源

    /**
     * 通用的增删改操作，将会变化的东西放到形参里，会用到可变形参
     * @param sql
     * @param args
     * @return 返回 DML 操作执行完之后涉及到的数据库行数：>=0
     */
    public static int update(String sql, Object... args) {//sql中占位符的个数与可变形参的长度相同！
        Connection conn = null;
        PreparedStatement ps = null;
        try {
            //1.获取数据库的连接
            conn = JDBCUtils.getConnection();
            //2.预编译sql语句，返回PreparedStatement的实例
            ps = conn.prepareStatement(sql);
            //3.填充占位符
            for (int i = 0; i < args.length; i++) {
                //加入到sql中下标从1开始，但是用的是数组中第i个数据（java中数组下标从0开始）
                ps.setObject(i + 1, args[i]);//小心参数声明错误！！
            }
            //4.执行
            // true if the first result is a ResultSet object; 如果执行查询，有返回集，true
            // false if the first result is an update count or there is no result;执行增删改或没有结果集，false
//            ps.execute();
            
            return ps.executeUpdate();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //5.资源的关闭
            JDBCUtils.closeResource(conn, ps);
        }
        return 0;
    }

4、使用 PreparedStatement 实现通用的查询操作：version 1.0

获取与数据库的连接 Connection
预编译 sql 语句，返回 PreparedStatement 的实例
填充占位符
执行此 PreparedStatement 对象中的 SQL 查询语句，并返回一个结果集 ResultSet
通过 ResultSet 得到结果集的元数据：ResultSetMetaData
通过 ResultSetMetaData 得到数据集列数 columnCount，数据列别名 columnLabel；通过 ResultSet 得到列值；使用反射，给对象的相应属性赋值，给t对象指定的 columnLabel 属性，赋值为 columValue
关闭 Connection，PreparedStatement，ResultSet 资源

  /**
     * @param clazz
     * @param sql
     * @param args
     * @return
     * @Description 针对于不同的表的通用的查询操作，返回表中的一条记录
     * @author shkstart
     * @date 上午11:42:23
     */
    public static <T> T getInstance(Class<T> clazz, String sql, Object... args) {
        Connection conn = null;
        PreparedStatement ps = null;
        ResultSet rs = null;
        try {
            conn = JDBCUtils.getConnection();

            ps = conn.prepareStatement(sql);
            for (int i = 0; i < args.length; i++) {
                ps.setObject(i + 1, args[i]);
            }

            rs = ps.executeQuery();
            // 获取结果集的元数据 :ResultSetMetaData
            ResultSetMetaData rsmd = rs.getMetaData();
            // 通过ResultSetMetaData获取结果集中的列数
            int columnCount = rsmd.getColumnCount();

            if (rs.next()) {
                T t = clazz.newInstance();
                // 处理结果集一行数据中的每一个列
                for (int i = 0; i < columnCount; i++) {
                    // 获取列值
                    Object columValue = rs.getObject(i + 1);

                    // 获取每个列的列名
                    // String columnName = rsmd.getColumnName(i + 1);
                    String columnLabel = rsmd.getColumnLabel(i + 1);

                    // 给t对象指定的columnName属性，赋值为columValue：通过反射
                    Field field = clazz.getDeclaredField(columnLabel);
                    field.setAccessible(true);
                    field.set(t, columValue);
                }
                return t;
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            JDBCUtils.closeResource(conn, ps, rs);
        }
        return null;
    }

    /**
     * 针对不同表的查询操作，返回多条记录并处理
     * @param clazz
     * @param sql
     * @param args
     * @param <T>，运行时类是哪个类
     * @return
     */
    public static <T> List<T> getForList(Class<T> clazz, String sql, Object... args) {
        Connection conn = null;
        PreparedStatement ps = null;
        ResultSet rs = null;
        try {
            conn = JDBCUtils.getConnection();

            ps = conn.prepareStatement(sql);
            for (int i = 0; i < args.length; i++) {
                ps.setObject(i + 1, args[i]);
            }

            rs = ps.executeQuery();
            // 获取结果集的元数据 :ResultSetMetaData
            ResultSetMetaData rsmd = rs.getMetaData();
            // 通过ResultSetMetaData获取结果集中的列数
            int columnCount = rsmd.getColumnCount();
            //创建集合对象
            ArrayList<T> list = new ArrayList<T>();
            while (rs.next()) {
                T t = clazz.newInstance();
                // 处理结果集一行数据中的每一个列:给t对象指定的属性赋值
                for (int i = 0; i < columnCount; i++) {
                    // 获取列值
                    Object columValue = rs.getObject(i + 1);

                    // 获取每个列的列名
                    // String columnName = rsmd.getColumnName(i + 1);
                    String columnLabel = rsmd.getColumnLabel(i + 1);

                    // 给t对象指定的columnName属性，赋值为columValue：通过反射
                    Field field = clazz.getDeclaredField(columnLabel);
                    field.setAccessible(true);
                    field.set(t, columValue);
                }
                list.add(t);//对于查询到的多条数据来说，把每一个对象放进集合里
            }
            return list;
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            JDBCUtils.closeResource(conn, ps, rs);
        }
        return null;
    }

两种思想：
（1）面向接口编程的思想
（2）ORM 编程思想：（object relational mapping），有点万事万物皆对象那种意思

一个数据表对应一个java类
表中的一条记录对应java类的一个对象
表中的一个字段对应java类的一个属性

两种技术：

（1）使用结果集的元数据：ResultSetMetaData

getColumnCount()：获取列数
getColumnLabel()：获取列的别名
说明：如果 sql 中没给字段其别名，getColumnLabel()获取的就是列名

（2）反射的使用

创建对应的运行时类的对象
在运行时，动态的调用指定的运行时类的属性、方法

在这里插入图片描述
注意： Java与数据库交互涉及到的相关Java API中的索引都从 1 开始。

5、PreparedStatement 操作 Blob 类型的变量

写入操作的方法：
setBlob(InputStream is);

读取操作的方法：
Blob blob = getBlob(int index); 或者 Blob blob = getBlob(String columnLabel);
InputStream is = blob.getBinaryStream();

Blob 增删改代码示例：

	//向数据表customers中插入Blob类型的字段(增删改类似)
//com.mysql.cj.jdbc.exceptions.PacketTooBigException:MySQL中默认最大可以传输的包为4M
//	max_allowed_packet = 4M
	@Test
	public void testInsert() throws Exception{
		Connection conn = JDBCUtils.getConnection();
		String sql = "insert into customers(name,email,birth,photo)values(?,?,?,?)";
		
		PreparedStatement ps = conn.prepareStatement(sql);
		
		ps.setObject(1,"袁浩");
		ps.setObject(2, "yuan@qq.com");
		ps.setObject(3,"1992-09-08");
		FileInputStream is = new FileInputStream(new File("girl.jpg"));
		ps.setBlob(4, is);
		
		ps.execute();
		
		JDBCUtils.closeResource(conn, ps);
	}

Blob 查询代码示例：

	//查询数据表customers中Blob类型的字段
	@Test
	public void testQuery(){
		Connection conn = null;
		PreparedStatement ps = null;
		InputStream is = null;
		FileOutputStream fos = null;
		ResultSet rs = null;
		try {
			conn = JDBCUtils.getConnection();
			String sql = "select id,name,email,birth,photo from customers where id = ?";
			ps = conn.prepareStatement(sql);
			ps.setInt(1, 21);
			rs = ps.executeQuery();
			if(rs.next()){
	//			方式一：按照索引来找
	//			int id = rs.getInt(1);
	//			String name = rs.getString(2);
	//			String email = rs.getString(3);
	//			Date birth = rs.getDate(4);
				//方式二：按照列的别名来找
				int id = rs.getInt("id");
				String name = rs.getString("name");
				String email = rs.getString("email");
				Date birth = rs.getDate("birth");
				
				Customer cust = new Customer(id, name, email, birth);
				System.out.println(cust);
				
				//将Blob类型的字段下载下来，以文件的方式保存在本地
				Blob photo = rs.getBlob("photo");
				is = photo.getBinaryStream();
				fos = new FileOutputStream("zhangyuhao.jpg");
				byte[] buffer = new byte[1024];
				int len;
				while((len = is.read(buffer)) != -1){
					fos.write(buffer, 0, len);
				}
			}
		} catch (Exception e) {
			e.printStackTrace();
		}finally{
			try {
				if(is != null)
					is.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
			try {
				if(fos != null)
					fos.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
			JDBCUtils.closeResource(conn, ps, rs);
		}
	}

注意，在向数据库中插入图片的时候会报错，可能是由于图片过大，而 Java 对每次传输的最大包容量做了一个限制：
在这里插入图片描述

6、PreparedStatement 实现高效的批量插入

update、delete本身就具有批量操作的效果，此时的批量操作，主要指的是批量插入更高效。

题目：向goods表中插入20000条数据

CREATE TABLE goods(
	id INT PRIMARY KEY AUTO_INCREMENT,
	NAME VARCHAR(25)
   );

层次一：使用 Statement 实现（每一次都要执行一次 SQL 语句）

Connection conn = JDBCUtils.getConnection();
Statement st = conn.createStatement();
for(int i = 1;i <= 20000;i++){
	String sql = "insert into goods(name)values('name_" + i + "')";
	st.execute(sql);
}

层次二：使用 PreparedStatement 替换 Statement

Connection conn = null;
PreparedStatement ps = null;
try {
	long start = System.currentTimeMillis();

	conn = JDBCUtils.getConnection();
	String sql = "insert into goods(name)values(?)";
	ps = conn.prepareStatement(sql);
	for(int i = 1;i <= 20000;i++){
		ps.setObject(1, "name_" + i);
		ps.execute();//每次填充占位符之后要和数据库交互一次
	}

	long end = System.currentTimeMillis();
	System.out.println("花费的时间为：" + (end - start));//20000:10690ms
} catch (Exception e) {
	e.printStackTrace();
}finally{
	JDBCUtils.closeResource(conn, ps);
}

层次三：
（1）addBatch()、executeBatch()、clearBatch()
（2）mysql 服务器默认是关闭批处理的，我们需要通过一个参数，让 mysql开启批处理的支持。?rewriteBatchedStatements=true 写在配置文件的 url 后面
（3）使用更新的mysql 驱动：mysql-connector-java-5.1.37-bin.jar

Connection conn = null;
PreparedStatement ps = null;
try {
	long start = System.currentTimeMillis();
	
	conn = JDBCUtils.getConnection();
	String sql = "insert into goods(name)values(?)";
	ps = conn.prepareStatement(sql);
	for(int i = 1;i <= 20000;i++){
		ps.setObject(1, "name_" + i);
		
		//1."攒"sql
		ps.addBatch();
		
		if(i % 500 == 0){
			//2.执行batch
			ps.executeBatch();
			
			//3.清空batch
			ps.clearBatch();
		}
	}
	
	long end = System.currentTimeMillis();
	System.out.println("花费的时间为：" + (end - start));//20000:10690 --- 494
} catch (Exception e) {
	e.printStackTrace();
}finally{
	JDBCUtils.closeResource(conn, ps);
}

层次四：设置连接不允许自动提交数据

Connection conn = null;
PreparedStatement ps = null;
try {
	long start = System.currentTimeMillis();
	
	conn = JDBCUtils.getConnection();

	//设置不允许自动提交数据
	conn.setAutoCommit(false);
	String sql = "insert into goods(name)values(?)";
	ps = conn.prepareStatement(sql);
	for(int i = 1;i <= 20000;i++){
		ps.setObject(1, "name_" + i);
		
		//1."攒"sql
		ps.addBatch();
		if(i % 500 == 0){
		
			//2.执行batch
			ps.executeBatch();
	
			//3.清空batch
			ps.clearBatch();
		}
	}
	//提交数据
	conn.commit();
	
	long end = System.currentTimeMillis();
	System.out.println("花费的时间为：" + (end - start));//20000:83065 -- 494 --- 484
} catch (Exception e) {
	e.printStackTrace();
}finally{
	JDBCUtils.closeResource(conn, ps);
}

7、PreparedStatement 与 Statement 的异同

指出二者的关系？接口与子接口的关系
开发中，PreparedStatement 替换 Statement，
An object that represents a precompiled SQL statement. （所有优点都是基于这个 SQL 预编译语句）

第四章数据库事务

1、事务

一组逻辑操作单元,使数据从一种状态变换到另一种状态。
一组逻辑操作单元：一个或多个DML操作。

2、事务处理的原则（提交or回滚）

保证所事务都作为一个工作单元来执行，即使出现了故障，都不能改变这种执行方式。
当在一个事务中执行多个操作时，要么所有的事务都被提交(commit)，那么这些修改就永久地保存下来；要么数据库管理系统将放弃所作的所有修改，整个事务回滚(rollback)到最初状态。

说明：
1.数据一旦提交，就不可回滚
2.哪些操作会导致数据的自动提交？

DDL操作一旦执行，都会自动提交。
> set autocommit = false 对 DDL 操作失效
DML默认情况下，一旦执行，就会自动提交。
> 我们可以通过 set autocommit = false 的方式取消 DML 操作的自动提交。
默认在关闭连接时，会自动的提交数据

3、JDBC 实现事务的代码体现（以转账为例）

取消数据的自动提交
提交数据或者出现异常回滚数据
对于数据库连接池来说，最后连接会返回到数据库连接池，所以 conn.setAutoCommit(true); 要恢复为默认值

Connection conn = null;
try {
	conn = JDBCUtils.getConnection();//事务之前的建立连接
	System.out.println(conn.getAutoCommit());//true
	
	//1.取消数据的自动提交
	conn.setAutoCommit(false);
	String sql1 = "update user_table set balance = balance - 100 where user = ?";
	update(conn,sql1, "AA");
	
	//模拟网络异常
	System.out.println(10 / 0);
	String sql2 = "update user_table set balance = balance + 100 where user = ?";
	update(conn,sql2, "BB");

	System.out.println("转账成功");
	
	//2.提交数据
	conn.commit();
} catch (Exception e) {
	e.printStackTrace();
	
	//3.出现异常回滚数据
	try {
		conn.rollback();
	} catch (SQLException e1) {
		e1.printStackTrace();
	}
}finally{
	//对于数据库连接池来说，最后连接会返回到数据库连接池，所以这个状态要恢复为默认值
	try {
		conn.setAutoCommit(true);
	} catch (SQLException e) {
		e.printStackTrace();
	}
	JDBCUtils.closeResource(conn, null);//事务之后关闭连接
}

4、考虑到事务以后，实现的通用的增删改查操作： version 2.0

考虑事务之后的通用增删改代码：
注：从外面传一个连接进来，并且最后不要关闭连接，事务结束之后再关闭连接

// 通用的增删改操作---version 2.0 （考虑上事务）
// 从外面传一个连接进来，并且最后不要关闭连接，事务结束之后再关闭连接
public int update(Connection conn,String sql, Object... args) {// sql中占位符的个数与可变形参的长度相同！
	PreparedStatement ps = null;
	try {
		// 1.预编译sql语句，返回PreparedStatement的实例
		ps = conn.prepareStatement(sql);
		// 2.填充占位符
		for (int i = 0; i < args.length; i++) {
			ps.setObject(i + 1, args[i]);// 小心参数声明错误！！
		}
		// 3.执行
		return ps.executeUpdate();
	} catch (Exception e) {
		e.printStackTrace();
	} finally {
		// 4.资源的关闭
		JDBCUtils.closeResource(null, ps);
	}
	return 0;
}

考虑事务之后的通用查询代码：
注：从外面传一个连接进来，并且最后不要关闭连接，事务结束之后再关闭连接

//通用的查询操作，用于返回数据表中的一条记录（version 2.0：考虑上事务）
// 从外面传一个连接进来，并且最后不要关闭连接，事务结束之后再关闭连接
public <T> T getInstance(Connection conn,Class<T> clazz,String sql, Object... args) {
	PreparedStatement ps = null;
	ResultSet rs = null;
	try {
		ps = conn.prepareStatement(sql);
		for (int i = 0; i < args.length; i++) {
			ps.setObject(i + 1, args[i]);
		}

		rs = ps.executeQuery();
		// 获取结果集的元数据 :ResultSetMetaData
		ResultSetMetaData rsmd = rs.getMetaData();
		// 通过ResultSetMetaData获取结果集中的列数
		int columnCount = rsmd.getColumnCount();

		if (rs.next()) {
			T t = clazz.newInstance();
			// 处理结果集一行数据中的每一个列
			for (int i = 0; i < columnCount; i++) {
				// 获取列值
				Object columValue = rs.getObject(i + 1);

				// 获取每个列的列名
				// String columnName = rsmd.getColumnName(i + 1);
				String columnLabel = rsmd.getColumnLabel(i + 1);

				// 给t对象指定的columnName属性，赋值为columValue：通过反射
				Field field = clazz.getDeclaredField(columnLabel);
				field.setAccessible(true);
				field.set(t, columValue);
			}
			return t;
		}
	} catch (Exception e) {
		e.printStackTrace();
	} finally {
		JDBCUtils.closeResource(null, ps, rs);
	}
	return null;
}

5、事务的 ACID 属性

原子性（Atomicity）：原子性是指事务是一个不可分割的工作单位，事务中的操作要么都发生，要么都不发生。
一致性（Consistency） ：事务必须使数据库从一个一致性状态变换到另外一个一致性状态。
隔离性（Isolation） ：事务的隔离性是指一个事务的执行不能被其他事务干扰，即一个事务内部的操作及使用的数据对并发的其他事务是隔离的，并发执行的各个事务之间不能互相干扰。
持久性（Durability） ：持久性是指一个事务一旦被提交，它对数据库中数据的改变就是永久性的，接下来的其他操作和数据库故障不应该对其有任何影响。

5.1 数据库的并发问题

在这里插入图片描述

5.2 四种隔离级别（一致性和并发性：一致性越好，并发性越差）

在这里插入图片描述

5.3 MySQL 如何查看并设置隔离级别

select @@transaction_isolation;

第五章 DAO 及相关实现类

DAO: data(base) access object

通常来说，为了实现功能的模块化，要有

abstract class BaseDAO：封装了针对于数据表的通用的操作，声明为 abstract 的），
interface CustomerDAO：此接口用于规范针对于customers表的常用操作）
class CustomerDAOImpl extends BaseDAO implements CustomerDAO：针对 Customer 表的实现类
class CustomerDAOImplTest：通常还要设置一个测试类，来对 CustomerDAOImpl 表中的功能进行测试

1、BaseDAO 实现（升级版，使用反射获取当前对象的父类的泛型参数）

public abstract class BaseDAO<T> {
	//出现对象.方法 T t = clazz.newInstance(); 只需要在该方法之前赋值就可以了
	// 几种方法：构造器、代码块、静态代码块
	private Class<T> clazz = null;

//	public BaseDAO(){
//
//	}

	//使用代码块：在new一个子类对象的时候，先调用super();加载父类的结构，先后把代码块和构造器加载了
	// 使用反射获取当前对象的父类的泛型参数
	{
		//获取当前BaseDAO的子类继承的父类中的泛型
		// 这个this是谁来调用这个代码块，这个this指代的就是谁，所以这里代表子类对象
		Type genericSuperclass = this.getClass().getGenericSuperclass();
		ParameterizedType paramType = (ParameterizedType) genericSuperclass;

		Type[] typeArguments = paramType.getActualTypeArguments();//获取了父类的泛型参数
		clazz = (Class<T>) typeArguments[0];//泛型的第一个参数
	}
	/**
     * 通用的增删改操作---version 2.0 （考虑上事务）
	 * @param conn
     * @param sql
     * @param args
     * @return
     */
	public int update(Connection conn, String sql, Object... args) {// sql中占位符的个数与可变形参的长度相同！
		PreparedStatement ps = null;
		try {
			// 1.预编译sql语句，返回PreparedStatement的实例
			ps = conn.prepareStatement(sql);
			// 2.填充占位符
			for (int i = 0; i < args.length; i++) {
				ps.setObject(i + 1, args[i]);// 小心参数声明错误！！
			}
			// 3.执行
			return ps.executeUpdate();
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			// 4.资源的关闭
			JDBCUtils.closeResource(null, ps);
		}
		return 0;
	}
	/**
     * 通用的查询操作，用于返回数据表中的一条记录（version 2.0：考虑上事务）
	 * @param conn
     * @param sql
     * @param args
     * @return
     */
	public T getInstance(Connection conn, String sql, Object... args) {
		PreparedStatement ps = null;
		ResultSet rs = null;
		try {
			ps = conn.prepareStatement(sql);
			for (int i = 0; i < args.length; i++) {
				ps.setObject(i + 1, args[i]);
			}

			rs = ps.executeQuery();
			// 获取结果集的元数据 :ResultSetMetaData
			ResultSetMetaData rsmd = rs.getMetaData();
			// 通过ResultSetMetaData获取结果集中的列数
			int columnCount = rsmd.getColumnCount();

			if (rs.next()) {
				T t = clazz.newInstance();
				// 处理结果集一行数据中的每一个列
				for (int i = 0; i < columnCount; i++) {
					// 获取列值
					Object columValue = rs.getObject(i + 1);

					// 获取每个列的列名
					// String columnName = rsmd.getColumnName(i + 1);
					String columnLabel = rsmd.getColumnLabel(i + 1);

					// 给t对象指定的columnName属性，赋值为columValue：通过反射
					Field field = clazz.getDeclaredField(columnLabel);
					field.setAccessible(true);
					field.set(t, columValue);
				}
				return t;
			}
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			JDBCUtils.closeResource(null, ps, rs);
		}
		return null;
	}
	/**
     * 通用的查询操作，用于返回数据表中的多条记录构成的集合（version 2.0：考虑上事务）
	 * @param conn
     * @param sql
     * @param args
     * @return
     */
	public List<T> getForList(Connection conn, String sql, Object... args) {
		PreparedStatement ps = null;
		ResultSet rs = null;
		try {
			ps = conn.prepareStatement(sql);
			for (int i = 0; i < args.length; i++) {
				ps.setObject(i + 1, args[i]);
			}

			rs = ps.executeQuery();
			// 获取结果集的元数据 :ResultSetMetaData
			ResultSetMetaData rsmd = rs.getMetaData();
			// 通过ResultSetMetaData获取结果集中的列数
			int columnCount = rsmd.getColumnCount();
			// 创建集合对象
			ArrayList<T> list = new ArrayList<T>();
			while (rs.next()) {
				T t = clazz.newInstance();
				// 处理结果集一行数据中的每一个列:给t对象指定的属性赋值
				for (int i = 0; i < columnCount; i++) {
					// 获取列值
					Object columValue = rs.getObject(i + 1);

					// 获取每个列的列名
					// String columnName = rsmd.getColumnName(i + 1);
					String columnLabel = rsmd.getColumnLabel(i + 1);

					// 给t对象指定的columnName属性，赋值为columValue：通过反射
					Field field = clazz.getDeclaredField(columnLabel);
					field.setAccessible(true);
					field.set(t, columValue);
				}
				list.add(t);
			}
			return list;
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			JDBCUtils.closeResource(null, ps, rs);
		}
		return null;
	}
	/**
     * 用于查询特殊值的通用的方法
	 * @param conn
     * @param sql
     * @param args
     * @param <E>
     * @return
     */
	public <E> E getValue(Connection conn,String sql,Object...args){
		PreparedStatement ps = null;
		ResultSet rs = null;
		try {
			//预编译sql语句
			ps = conn.prepareStatement(sql);
			//填充占位符
			for(int i = 0;i < args.length;i++){
				ps.setObject(i + 1, args[i]);
			}
			//执行查询
			rs = ps.executeQuery();
			//返回查询到的一列数据
			if(rs.next()){
				return (E) rs.getObject(1);
			}
		} catch (SQLException e) {
			e.printStackTrace();
		}finally{
			JDBCUtils.closeResource(null, ps, rs);
		}
		return null;
	}	
}

2、CustomerDAO 实现（根据不同的需求指定不同的函数）

/*
 * 此接口用于规范针对于customers表的常用操作
 */
public interface CustomerDAO {
	/**
	 * 
	 * @Description 将cust对象添加到数据库中
	 * @author shkstart
	 * @date 上午11:00:27
	 * @param conn
	 * @param cust
	 */
	void insert(Connection conn,Customer cust);
	/**
	 * 
	 * @Description 针对指定的id，删除表中的一条记录
	 * @author shkstart
	 * @date 上午11:01:07
	 * @param conn
	 * @param id
	 */
	void deleteById(Connection conn,int id);
	/**
	 * 
	 * @Description 针对内存中的cust对象，去修改数据表中指定的记录
	 * @author shkstart
	 * @date 上午11:02:14
	 * @param conn
	 * @param cust
	 */
	void update(Connection conn,Customer cust);
	/**
	 * 
	 * @Description 针对指定的id查询得到对应的Customer对象
	 * @author shkstart
	 * @date 上午11:02:59
	 * @param conn
	 * @param id
	 */
	Customer getCustomerById(Connection conn,int id);
	/**
	 * 
	 * @Description 查询表中的所有记录构成的集合
	 * @author shkstart
	 * @date 上午11:03:50
	 * @param conn
	 * @return
	 */
	List<Customer> getAll(Connection conn);
	/**
	 * 
	 * @Description 返回数据表中的数据的条目数
	 * @author shkstart
	 * @date 上午11:04:44
	 * @param conn
	 * @return
	 */
	Long getCount(Connection conn);
	
	/**
	 * 
	 * @Description 返回数据表中最大的生日
	 * @author shkstart
	 * @date 上午11:05:33
	 * @param conn
	 * @return
	 */
	Date getMaxBirth(Connection conn);
}

3、CustomerDAOImpl 实现接口定义的各种方法

public class CustomerDAOImpl extends BaseDAO<Customer> implements CustomerDAO{

	@Override
	public void insert(Connection conn, Customer cust) {
		String sql = "insert into customers(name,email,birth)values(?,?,?)";
		update(conn, sql,cust.getName(),cust.getEmail(),cust.getBirth());
	}

	@Override
	public void deleteById(Connection conn, int id) {
		String sql = "delete from customers where id = ?";
		update(conn, sql, id);
	}

	@Override
	public void update(Connection conn, Customer cust) {
		String sql = "update customers set name = ?,email = ?,birth = ? where id = ?";
		update(conn, sql,cust.getName(),cust.getEmail(),cust.getBirth(),cust.getId());
	}

	@Override
	public Customer getCustomerById(Connection conn, int id) {
		String sql = "select id,name,email,birth from customers where id = ?";
		Customer customer = getInstance(conn, sql,id);
		return customer;
	}

	@Override
	public List<Customer> getAll(Connection conn) {
		String sql = "select id,name,email,birth from customers";
		List<Customer> list = getForList(conn, sql);
		return list;
	}

	@Override
	public Long getCount(Connection conn) {
		String sql = "select count(*) from customers";
		return getValue(conn, sql);
	}

	@Override
	public Date getMaxBirth(Connection conn) {
		String sql = "select max(birth) from customers";
		return getValue(conn, sql);
	}
}

4、CustomerDAOImplTest 实现测试功能

public class CustomerDAOImplTest {

	private CustomerDAOImpl dao = new CustomerDAOImpl();
	
	@Test
	public void testInsert() {
		Connection conn = null;
		try {
			conn = JDBCUtils.getConnection();
			Customer cust = new Customer(1, "于小飞", "xiaofei@126.com",new Date(43534646435L));
			dao.insert(conn, cust);
			System.out.println("添加成功");
		} catch (Exception e) {
			e.printStackTrace();
		}finally{
			JDBCUtils.closeResource(conn, null,null);
		}
	}

	@Test
	public void testDeleteById() {
		Connection conn = null;
		try {
			conn = JDBCUtils.getConnection();
			
			dao.deleteById(conn, 13);
			System.out.println("删除成功");
		} catch (Exception e) {
			e.printStackTrace();
		}finally{
			JDBCUtils.closeResource(conn, null);
			
		}
	}

	@Test
	public void testUpdateConnectionCustomer() {
		Connection conn = null;
		try {
			conn = JDBCUtils.getConnection();
			Customer cust = new Customer(18,"贝多芬","beiduofen@126.com",new Date(453465656L));
			dao.update(conn, cust);
			System.out.println("修改成功");
		} catch (Exception e) {
			e.printStackTrace();
		}finally{
			JDBCUtils.closeResource(conn, null);
			
		}
	}

	@Test
	public void testGetCustomerById() {
		Connection conn = null;
		try {
			conn = JDBCUtils.getConnection3();
			
			Customer cust = dao.getCustomerById(conn, 19);
			System.out.println(cust);
			
		} catch (Exception e) {
			e.printStackTrace();
		}finally{
			JDBCUtils.closeResource(conn, null);
		}
	}

	@Test
	public void testGetAll() {
		Connection conn = null;
		try {
			conn = JDBCUtils.getConnection();
			
			List<Customer> list = dao.getAll(conn);
			list.forEach(System.out::println);
		} catch (Exception e) {
			e.printStackTrace();
		}finally{
			JDBCUtils.closeResource(conn, null);
		}
	}

	@Test
	public void testGetCount() {
		Connection conn = null;
		try {
			conn = JDBCUtils.getConnection();
			
			Long count = dao.getCount(conn);
			
			System.out.println("表中的记录数为：" + count);
		} catch (Exception e) {
			e.printStackTrace();
		}finally{
			JDBCUtils.closeResource(conn, null);
		}
	}

	@Test
	public void testGetMaxBirth() {
		Connection conn = null;
		try {
			conn = JDBCUtils.getConnection();
			
			Date maxBirth = dao.getMaxBirth(conn);
			
			System.out.println("最大的生日为：" + maxBirth);
		} catch (Exception e) {
			e.printStackTrace();
		}finally{
			JDBCUtils.closeResource(conn, null);
		}
	}
}

总结：考虑到数据库事务以后的数据库操作（重点）

获取数据库的连接

//获得连接的两种方式：方式1：手动获取连接方式2:数据库连接池
Connection conn = JDBCUtils.getConnection();

conn.setAutoCommit(false); //体现事务

如下的多个DML操作，作为一个事务出现：

操作1：需要使用通用的增删改查操作
操作2：需要使用通用的增删改查操作
操作3：需要使用通用的增删改查操作

conn.commit(); //如果事务执行结束就进行提交

//通用的增删改查操作如何实现？
//方式1：手动使用 PreparedStatement 实现
//方式2：使用 dbutils.jar 中 QueryRunner 类

如果出现异常，则：
conn.rollback();
关闭资源

//关闭资源的两种方式：方式1：手动关闭资源方式2：DbUtils类的关闭方法
JDBCUtils.closeResource(…,…,…);

第六章数据库连接池

1、传统连接的问题

在这里插入图片描述

2、使用数据库连接池的好处

提高程序的响应速度(减少了创建连接相应的时间)
降低资源的消耗(可以重复使用已经提供好的连接)
便于连接的管理，可以设置最大数据库连接数量、最大连接活跃数等等

3、实现的方式（推荐使用Druid）

在这里插入图片描述

4、如何使用数据库连接池（以Druid为例）

导入jar包：
测试连接的代码：
（1）加载配置文件
（2）获取数据库连接池中的连接
（3）与数据库建立连接

	@Test
public void getConnection() throws Exception{
	Properties pros = new Properties();
	
	InputStream is = ClassLoader.getSystemClassLoader().getResourceAsStream("druid.properties");
	pros.load(is);
	
	DataSource source = DruidDataSourceFactory.createDataSource(pros);
	Connection conn = source.getConnection();
	System.out.println(conn);
}

封装成 JDBCUtils 代码：

/**
 * 使用Druid数据库连接池技术
 */
private static DataSource source1;
static{
	try {
		Properties pros = new Properties();
		InputStream is = ClassLoader.getSystemClassLoader().getResourceAsStream("druid.properties");
		pros.load(is);
		source1 = DruidDataSourceFactory.createDataSource(pros);
	} catch (Exception e) {
		e.printStackTrace();
	}
}
public static Connection getConnection3() throws SQLException{
	Connection conn = source1.getConnection();
	return conn;
}

注意： 每次加载类的收只用创建一个 Druid 数据库连接池，这里使用静态代码块来实现。

配置文件定义在 src 下：druid.properties

url=jdbc:mysql:///test
username=root
password=abc123
driverClassName=com.mysql.cj.jdbc.Driver

initialSize=10
maxActive=10

第七章 DBUtils 提供的 jar 包实现 CRUD 操作

commons-dbutils 是 Apache 组织提供的一个开源 JDBC工具类库,封装了针对于数据库的增删改查操作

1、导入jar包：
在这里插入图片描述
2、使用现成的 jar 中的 QueryRunner 测试增、删、改的操作:

//测试插入
@Test
public void testInsert() {
	Connection conn = null;
	try {
		QueryRunner runner = new QueryRunner();
		conn = JDBCUtils.getConnection3();
		String sql = "insert into customers(name,email,birth)values(?,?,?)";
		int insertCount = runner.update(conn, sql, "蔡徐坤","caixukun@126.com","1997-09-08");
		System.out.println("添加了" + insertCount + "条记录");
	} catch (SQLException e) {
		e.printStackTrace();
	}finally{
		JDBCUtils.closeResource(conn, null);
	}
}

3、使用现成的 jar 中的 QueryRunner 测试查询的操作:

//测试查询
/*
 * BeanHander:是ResultSetHandler接口的实现类，用于封装表中的一条记录，表中的记录封装完之后返回一个对象。
 */
@Test
public void testQuery1(){
	Connection conn = null;
	try {
		QueryRunner runner = new QueryRunner();
		conn = JDBCUtils.getConnection3();
		String sql = "select id,name,email,birth from customers where id = ?";

		BeanHandler<Customer> handler = new BeanHandler<>(Customer.class);
		//ResultSetHandler（接口）是结果集的一个处理器，有多种实现类，其中BeanHandler是通用的
		Customer customer = runner.query(conn, sql, handler, 26);
		System.out.println(customer);
	} catch (SQLException e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	}finally{
		JDBCUtils.closeResource(conn, null);
	}
}

/*
 * BeanListHandler:是ResultSetHandler接口的实现类，用于封装表中的多条记录构成的集合。
 */
@Test
public void testQuery2() {
	Connection conn = null;
	try {
		QueryRunner runner = new QueryRunner();
		conn = JDBCUtils.getConnection3();
		String sql = "select id,name,email,birth from customers where id < ?";
		
		BeanListHandler<Customer>  handler = new BeanListHandler<>(Customer.class);
		List<Customer> list = runner.query(conn, sql, handler, 23);
		list.forEach(System.out::println);
	} catch (SQLException e) {
		e.printStackTrace();
	}finally{
		JDBCUtils.closeResource(conn, null);
	}
}

/*
 * MapHander:是ResultSetHandler接口的实现类，对应表中的一条记录。
 * 将字段及相应字段的值作为map中的key和value
 */
@Test
public void testQuery3(){
	Connection conn = null;
	try {
		QueryRunner runner = new QueryRunner();
		conn = JDBCUtils.getConnection3();
		String sql = "select id,name,email,birth from customers where id = ?";
		MapHandler handler = new MapHandler();
		Map<String, Object> map = runner.query(conn, sql, handler, 26);
		System.out.println(map);
	} catch (SQLException e) {
		e.printStackTrace();
	}finally{
		JDBCUtils.closeResource(conn, null);
	}
}

/*
 * MapListHander:是ResultSetHandler接口的实现类，对应表中的多条记录。
 * 将字段及相应字段的值作为map中的key和value。将这些map添加到List中
 */
@Test
public void testQuery4(){
	Connection conn = null;
	try {
		QueryRunner runner = new QueryRunner();
		conn = JDBCUtils.getConnection3();
		String sql = "select id,name,email,birth from customers where id < ?";
	
		MapListHandler handler = new MapListHandler();
		List<Map<String, Object>> list = runner.query(conn, sql, handler, 23);
		list.forEach(System.out::println);
	} catch (SQLException e) {
		e.printStackTrace();
	}finally{
		JDBCUtils.closeResource(conn, null);
	}
}
/*
 * ScalarHandler:用于查询特殊值
 */
@Test
public void testQuery5(){
	Connection conn = null;
	try {
		QueryRunner runner = new QueryRunner();
		conn = JDBCUtils.getConnection3();
		String sql = "select count(*) from customers";
		
		ScalarHandler handler = new ScalarHandler();
		Long count = (Long) runner.query(conn, sql, handler);
		System.out.println(count);
	} catch (SQLException e) {
		e.printStackTrace();
	}finally{
		JDBCUtils.closeResource(conn, null);
	}
}
@Test
public void testQuery6(){
	Connection conn = null;
	try {
		QueryRunner runner = new QueryRunner();
		conn = JDBCUtils.getConnection3();
		String sql = "select max(birth) from customers";
		
		ScalarHandler handler = new ScalarHandler();
		Date maxBirth = (Date) runner.query(conn, sql, handler);
		System.out.println(maxBirth);
	} catch (SQLException e) {
		e.printStackTrace();
	}finally{
		JDBCUtils.closeResource(conn, null);
	}
}

/*
 * 自定义ResultSetHandler的实现类
 */
@Test
public void testQuery7(){
	Connection conn = null;
	try {
		QueryRunner runner = new QueryRunner();
		conn = JDBCUtils.getConnection3();
		
		String sql = "select id,name,email,birth from customers where id = ?";
		//提供一个handler的匿名实现类
		ResultSetHandler<Customer> handler = new ResultSetHandler<Customer>(){
			@Override
			public Customer handle(ResultSet rs) throws SQLException {
//					System.out.println("handle");
//					return null;
//					return new Customer(12, "成龙", "Jacky@126.com", new Date(234324234324L));
				
				if(rs.next()){
					int id = rs.getInt("id");
					String name = rs.getString("name");
					String email = rs.getString("email");
					Date birth = rs.getDate("birth");
					Customer customer = new Customer(id, name, email, birth);
					return customer;
				}
				return null;
			}
		};
		//handler中最后返回的对象就是这里query最终的返回对象
		Customer customer = runner.query(conn, sql, handler,26);
		System.out.println(customer);
	} catch (SQLException e) {
		e.printStackTrace();
	}finally{
		JDBCUtils.closeResource(conn, null);
	}
}

4、使用 dbutils.jar 包中的 DbUtils 工具类实现连接等资源的关闭：

	/**
	 * @Description 使用dbutils.jar中提供的DbUtils工具类，实现资源的关闭
	 * @author shkstart
	 * @date 下午4:53:09
	 * @param conn
	 * @param ps
	 * @param rs
	 */
public static void closeResource1(Connection conn,Statement ps,ResultSet rs){
//		try {
//			DbUtils.close(conn);
//		} catch (SQLException e) {
//			e.printStackTrace();
//		}
//		try {
//			DbUtils.close(ps);
//		} catch (SQLException e) {
//			e.printStackTrace();
//		}
//		try {
//			DbUtils.close(rs);
//		} catch (SQLException e) {
//			e.printStackTrace();
//		}

	DbUtils.closeQuietly(conn);
	DbUtils.closeQuietly(ps);
	DbUtils.closeQuietly(rs);
}

每天都要学习的阿荣

关注

1
点赞
踩
15

收藏

觉得还不错? 一键收藏
0
评论
（尚硅谷）JDBC总复习

第一章 JDBC概述1、数据的持久化持久化(persistence)：把数据保存到可掉电式存储设备中以供之后使用。持久化的媒介：硬盘，关系型数据库，XML文件2、JDBC的理解JDBC(Java Database Connectivity)是一个独立于特定数据库管理系统、通用的SQL数据库存取和操作的公共接口（一组API）简单理解为：JDBC，是SUN提供的一套 API，使用这套API可以实现对具体数据库的操作（获取连接、关闭连接、DML、DDL、DCL)3、Java 与 MySQL 连接图示
复制链接

扫一扫