一文带你搞定JDBC

前言：“只有自己强大，才不会被别人践踏。”
你好，我是梦阳辰，让我们轻松玩编程，一起走进JDBC的世界吧！文章较长建议收藏再看！

1.JDBC概述

1.JDBC是什么？
Java DataBase connectivity(java数据库连接）

Java数据库连接是Java语言中用来规范客户端程序如何来访问数据库的应用程序接口，提供了诸如查询和更新数据库中数据的方法。

2.JDBC的本质是什么？
JDBC是sun公司制定的一套接口（interface)

• java.sql包下。

为什么java要制定一套JDBC接口？
因为每一个数据库的底层实现原理都不一样。
oracle数据库都有自己的原理。
MySQL数据库也有自己的原理。
MS Sqlserver数据库也有自己的原理。

这意味着如果没有JDBC接口的话，使用不同的数据库，就要编写一套代码，这样扩展性不强，增加了程序员的负担，为了解决这个问题，sun公司就编写了一套JDBC接口，不同的数据库厂家，对此编写了一套实现接口的类，也称为驱动。

接口都由调用者和实现者完成。
面向接口调用，面向接口写实现类，这都是属于面向接口编程。

1.调用者为程序员；不需要关心具体是哪个厂家的数据库，只需要面向JDBC接口写代码。

2.实现者为数据库厂家，也被称为驱动，对JDBC进行实现（为class文件）。

3.如果没有实现类驱动可以编译，但无法执行。

为什么要面向接口编程呢？
解耦合：降低程序的耦合度，提高程序的扩展力。
多态机制就是非常典型的：面向抽象编程。
即建议：
Animal a = new cat();
public void feed(Animal a) //面向父类型编程。

3.JDBC开发前的准备工作，先从官网下载对应的驱动jar包，然后将其配置到环境变量classpath当中。

如果是用IDEA开发，需要在IDEA中导入驱动jar包，步骤为：点击file–>Project Structure–>"+"–>java。然后选择你在数据库官网下载的驱动jar包，最后选择要导入的项目（module)即可。如果你还在用eclipse，建议换一下IDEA，哈哈。

classpath=.;+下载的驱动包的路径及文件名。
"."代表当前路径，加了这个，JVM会在当前路径下查找类，如果没找到再到指定位置查找。

注意：虽然在jdk5之后不用配置class环境变量，但是当我们用到JDBC,或者开发JavaEE应用时，则必须要设置classpath环境变量，JVM通过classpath查找类。JDK 1.5 版本以上的JDK，会自动搜索当前路径下的类文件，而且使用java的编译和运行工具时，系统可以自动加载dt.jar和tools.jar文件中的java类，因此不再需要设置classpath环境变量。

注意：用文本编辑器开发，需要配置环境变量到classpath中。
如果使用IDEA工具的时候，不需要配置classpath环境变量，按要求导入jar包到项目即可。

2.JDBC编程六步（重点）

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

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

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

第四步：执行SQL语句。（DQL,DML)

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

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

1.例如：(注意注解）

/*
JDBC编程六步
*/
import java.sql.Driver;//接口
import java.sql.DriverManager;//类
import java.sql.SQLException;//异常类
import java.sql.Connection;//接口
import java.sql.Statement;//类
public class JavaJDBC 
{
	public static void main(String[] args) 
	{
		Connection conn =null;
		Statement stat = null;
		
		try{
		//1.注册驱动
		Driver driver = new com.mysql.jdbc.Driver();//多态
		//Driver driver = new oracle.jdbc.driver.OracleDriver();//oracle的驱动
		//注意前面的Driver是接口，后面的Driver是其实现类，因为在不同的包中，故可以这样命名
		DriverManager.registerDriver(driver);//静态方法
		//2.获取连接(建立通道，数据库和java）
		/*
		url:统一资源定位符（网络中某个资源的绝对路径）
		如：https://www.baidu.com/ 这就是一个URL
		URL包括哪几个部分？
		协议，IP,PORT,资源名
		如：http://182.61.200.7:80/index.html
		http://通信协议
		182.61.200.7 服务器IP地址
		80 服务器上软件的端口
		index.html 是服务器上某个资源名
		*/
		String url="jdbc:mysql://127.0.0.1:3306/xingkong";//或者localhost
		/*
		jdbc:mysql:// 协议
		127.0.0.1 IP地址
		3306 mysql数据库端口号
		xingkong 具体的数据库实例名
		说明：localhost与129.0.0.1都是本机的IP地址。
		更改地址就可以访问其他服务器的内容。

		什么是通信协议，有什么用？
			通信协议是通信之前就提前定好的数据库传送格式。
			数据包具体怎么传数据，格式提前定好了。
		
		oracle的URL:
			jdbc:oracle:thin:@localhost:1521:xingkong
		*/
		String user="root";
		String password = "1234";
		conn =DriverManager.getConnection(url,user,password);//静态方法
		System.out.println("数据库连接对象="+conn);

		//3.获取数据库操作对象(Statement专门执行sql语句）
		 stat = conn.createStatement();
		//4.执行sql
		String sql = "insert into dept(deptno,dname,loc )values(50,'fgagad','sfd')";
		//专门执行DML语句的（insert ,delete,update)
		//返回值是“影响数据库的记录条数”
		int count = stat.executeUpdate(sql);
		System.out.println(count==1?"保存成功":"保存失败");
		//5.处理查询结果集（这里不是查询，所以不需要这一步）
		}catch(SQLException e){
		e.printStackTrace();
		}finally{
			//6.释放资源
			//要遵循从小大以此关闭
			//分别对其try...catch
			try{
			if(stat!=null){//不能一起try,如果一起try，假如一个出问题，其他也出问题
				stat.close();
			}
			}catch(SQLException e){
				e.printStackTrace();
			}
			try{
			if(conn!=null){//不能一起try,如果一起try，假如一个出问题，其他也出问题
				conn.close();
			}
			}catch(SQLException e){
				e.printStackTrace();
			}
	
		}
		
	}
}

url解释：
url:统一资源定位符（网络中某个资源的绝对路径）
如：https://www.baidu.com/ 这就是一个URL
URL包括哪几个部分？
协议，IP,PORT,资源名
如：http://182.61.200.7:80/index.html
http://通信协议
182.61.200.7 服务器IP地址
80 服务器上软件的端口
ndex.html 是服务器上某个资源名

因此：
jdbc:mysql:// 协议
127.0.0.1 IP地址
3306 mysql数据库端口号
xingkong 具体的数据库实例名

说明：localhost与129.0.0.1都是本机的IP地址。
更改地址就可以访问其他服务器的内容。

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

oracle的URL:
jdbc:oracle:thin:@localhost:1521:xingkong

2.简化代码并执行删除和更新操作：

import java.sql.*;
public class JDBCTest2{
	public static void main(String[] args){
	Connection conn = null;
	Statement stat = null;
	try{
	//1注册驱动
	DriverManager.registerDriver(new com.mysql.jdbc.Driver());
	//2获取连接
	conn= DriverManager.getConnection("jdbc:mysql://localhost:3306/xingkong","root","0910");
	//3获取数据库操作对象
	stat =conn.createStatement();
	//4执行SQL语句
	//String sql ="delete from dept where deptno = 40";
	String sql ="update dept set dname = 'xin',loc='beijin' where deptno =20";
	int count = stat.executeUpdate(sql);
	System.out.println(count==1?"修改成功":"修改失败");

	}catch(SQLException e){
		e.printStackTrace();
	}finally{
			try{
			if(stat!=null){//不能一起try,如果一起try，假如一个出问题，其他也出问题
				stat.close();
			}
			}catch(SQLException e){
				e.printStackTrace();
			}
			try{
			if(conn!=null){//不能一起try,如果一起try，假如一个出问题，其他也出问题
				conn.close();
			}
			}catch(SQLException e){
				e.printStackTrace();
			}
	}
	}
}

3.将连接数据库的所有信息配置到，配置文件中：（使用资源绑定器）
这里为重点，因为这种方式非常灵活，这很常用。注意用这种方式需要配置，jdbc.properties文件哦。

如果这里看不懂，这篇文章也许会帮到你：
java的反射机制，看完这篇轻松应对高级框架（超详细总结）

import java.sql.*;
import java.util.*;
public class  JDBCTest3
{
	public static void main(String[] args) 
	{
		//使用资源绑定器绑定属性配置文件
		ResourceBundle bundle  = ResourceBundle.getBundle("jdbc");
		String driver = bundle.getString("driver");//driver=com.mysql.jdbc.Driver
		String url = bundle.getString("url");
		String user = bundle.getString("user");
		String password= bundle.getString("password");
		Connection conn = null;
		Statement stat = null;
		try{
			//1.注册驱动，这里为注册驱动的另一种方式
			Class.forName(driver);//反射获取类，这是会在类加在之前执行静态代码块
			//2.获取连接
			conn = DriverManager.getConnection(url,user,password);
			//3.获取数据库操作对象
			stat=conn.createStatement();
			//4.执行SQL语句
			String sql="update dept set dname ='sfaf',loc ='shenzhen' where deptno =20";
			int count = stat.executeUpdate(sql);
			System.out.println(count==1?"更新成功":"更新失败");
			
		}catch(Exception e){
			e.printStackTrace();
		}finally{
			//6.释放资源
			//要遵循从小大以此关闭
			//分别对其try...catch
			try{
			if(stat!=null){//不能一起try,如果一起try，假如一个出问题，其他也出问题
				stat.close();
			}
			}catch(SQLException e){
				e.printStackTrace();
			}
			try{
			if(conn!=null){//不能一起try,如果一起try，假如一个出问题，其他也出问题
				conn.close();
			}
			}catch(SQLException e){
				e.printStackTrace();
			}
		}
	}
}

4.处理查询结果集
遍历结果集分析图：

import java.util.*;
import java.sql.*;
public class JDBCTest4 
{
	public static void main(String[] args) 
	{
		//使用资源绑定器绑定属性配置文件
		ResourceBundle bundle  = ResourceBundle.getBundle("jdbc");
		String driver = bundle.getString("driver");//driver=com.mysql.jdbc.Driver
		String url = bundle.getString("url");
		String user = bundle.getString("user");
		String password= bundle.getString("password");
		Connection conn = null;
		Statement stat =null;
		ResultSet rs =null;
		try{
		//1.注册驱动
		Class.forName(driver);

		//2.获取连接
		conn=DriverManager.getConnection(url,user,password);

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

		//4.执行sql语句
		String sql="select empno,ename,sal from emp";
		//int executeUpdate(insert/delete/update)
		//ResultSet executeQuery(select)
		rs= stat.executeQuery(sql);//专门执行DQL语句的方法

		//5.处理查询结果集
		//boolean flag = rs.next();
		/*if(rs.next()){
			//不管数据库中的数据类型是什么，都以String的形式取出。
			String ss = rs.getString(1);//JDBC中所有下标从1开始。不是从0开始。
			String ename = rs.getString(2);//第二列中的那个数据
			String sal = rs.getString(3);//第三列的那个数据
			System.out.println(ss+","+ename+","+sal);
		}*/
		while(rs.next()){
			//不管数据库中的数据类型是什么，都以String的形式取出，如果想以Int类型取出，改为getInt方法，其它类似。
			String ss = rs.getString("empno");
			String ename = rs.getString("ename");//如果重命名，这里写重命名后的名字
			String sal = rs.getString("sal");
			System.out.println(ss+","+ename+","+sal);
		}
		}catch(Exception e){
			
		}finally{
			//6.释放资源
			try{
			if(rs!=null){//不能一起try,如果一起try，假如一个出问题，其他也出问题
				rs.close();
			}
			}catch(SQLException e){
				e.printStackTrace();
			}
			try{
			if(stat!=null){//不能一起try,如果一起try，假如一个出问题，其他也出问题
				stat.close();
			}
			}catch(SQLException e){
				e.printStackTrace();
			}
			try{
			if(conn!=null){//不能一起try,如果一起try，假如一个出问题，其他也出问题
				conn.close();
			}
			}catch(SQLException e){
				e.printStackTrace();
			}
		}
	}
}

*不管数据库中的数据类型是什么，都以String的形式取出，如果想以Int类型取出，改为getInt方法，并且，用getInt取出的数据可以参加数学运算，其它类似。

3.用数据库实现用户登录功能

模拟用户登入：
1.程序运行时的时候，提供一个输入的入口，可以让用户输入用户名和密码。

2.用户输入用户名和密码之后，提交信息，java程序收集到用户信息

• java程序连接数据库验证用户名和密码是否合法
• 合法登陆成功，否则登入失败

3.数据的准备：

• 在实际开发中，表的设计会使用专业的建模工具，这里使用：PowerDesigner
• 使用PowerDesigner工具进行数据表的设计

4.存在的问题(表中并没有这个用户，但是显示登录成功）

• 用户：fdas
• 密码：fdas’ or ‘1’='1
• 登陆成功
• 这种现象被称为SQL注入(安全隐患).

5.导致sql注入的根本原因是什么？

• 用户输入的信息中含有sql语句的关键字，并且这些关键字参与sql语句的编译过程，
• 导致sql语句的原意被扭曲，进而达到sql注入。

6.详情请看源代码：

package Day1;
//模拟用户登入功能
import java.sql.*;
import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;

public class Test1 {
    public static void main(String[] args) {
        //初始化界面
        Map<String,String> userInfromation =initUi();
        //验证用户名和密码
       boolean loginSuccess= login(userInfromation);
       //输出结果
        System.out.println(loginSuccess?"登陆成功":"登录失败");
    }
/**
* 用户登录
 * 用户登录信息
 * false表示失败，true表示成功*/
    private static boolean login(Map<String, String> userInfromation) {
        boolean falg =false;
        String loginName= userInfromation.get("username");//用户名
        String passcode=userInfromation.get("passcode");//用户密码
        //JDBC代码
        Connection conn = null;
        Statement stat= null;
        ResultSet rs= null;
        try {
            //1.注册驱动
            Class.forName("com.mysql.jdbc.Driver");
            //2.获取连接
            conn= DriverManager.getConnection("jdbc:mysql://localhost:3306/newdata?useSSL=false","root","123456");
            //3.获取数据库操作对象
            stat = conn.createStatement();
            //4.执行sql
            String sql = "select * from t_users where loginName='"+loginName+"'and passcode='"+passcode+"'";
           //以上正好完成了sql语句的拼接，以下代码是，发送sql语句给DBMS进行编译。
            //正好将用户提供的”非法信息“编译进去。导致了原sql语句的含义被扭曲了。
            rs=stat.executeQuery(sql);
            //处理结果集
            if(rs.next()){
                falg =true;
            }
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        } finally {
            //6.释放资源
            if(rs!=null){
                try {
                    rs.close();
                } catch (SQLException throwables) {
                    throwables.printStackTrace();
                }
            }
            if(stat!=null){
                try {
                    stat.close();
                } catch (SQLException throwables) {
                    throwables.printStackTrace();
                }
            }
            if(conn!=null){
                try {
                    conn.close();
                } catch (SQLException throwables) {
                    throwables.printStackTrace();
                }
            }
        }


        return  falg;
    }

    /**
* 初始化用户界面
* 返回用户名和密码等信息*/
    private static Map<String, String> initUi() {
        Scanner sc = new Scanner(System.in);
        System.out.println("用户名：");
        String username=sc.nextLine();
        System.out.println("密码：");
        String passcode = sc.nextLine();
        Map<String,String>userInfromation= new HashMap<>();
        userInfromation.put("username",username);
        userInfromation.put("passcode",passcode);
        return userInfromation;
    }

}

*你会发现某些安全性不高的网站用这种SQL注入的方式可以成功登录，但是可能会显示封号或者报出警告等。

7.那么我们该怎么解决SQL注入的问题呢？（重点，安全性高常用）
问题关键在于我们提供的密码参加了编译。因此我们可以从这里下手。我们可以将提供的信息不参与SQL语句的编译，因此我们需要使用java.sql.PreparedStatement接口。

1.将Statement接口换成PrepareStatement。PrepareStatement是Statement子接口。
PrepareStatement属于预编译的数据库操作对象。
其原理是：预先对SQL语句的框架进行编译，然后再给SQL语句传“值”。

2.将createStatemet();方法，改为：prepareStatement(sql);sql语句提前。并将sql语句的值改为占位符。

3.给占位符“？”传值，（第一个问号下表是1，第二个问号下标是2，JDBC中所有下表从1开始。）

详细请看源代码：

package Day1;
//模拟用户登入功能
* */

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

public class Test1 {
    public static void main(String[] args) {
        //初始化界面
        Map<String,String> userInfromation =initUi();
        //验证用户名和密码
       boolean loginSuccess= login(userInfromation);
       //输出结果
        System.out.println(loginSuccess?"登陆成功":"登录失败");
    }
/**
* 用户登录
 * 用户登录信息
 * false表示失败，true表示成功*/
    private static boolean login(Map<String, String> userInfromation) {
        boolean falg =false;
        String loginName= userInfromation.get("username");//用户名
        String passcode=userInfromation.get("passcode");//用户密码
        //JDBC代码
        Connection conn = null;
        PreparedStatement prep= null;
        ResultSet rs= null;
        try {
            //1.注册驱动
            Class.forName("com.mysql.jdbc.Driver");
            //2.获取连接
            conn= DriverManager.getConnection("jdbc:mysql://localhost:3306/newdata?useSSL=false","root","0910");
            //3.获取预编译的数据库操作对象
            String sql = "select * from t_users where loginName=? and passcode=?";//?表示占位符，只能填充值，
            //程序执行到这，会发送sql语句框子给DBMS,然后DBMS进行sql语句的预先编译。
            prep = conn.prepareStatement(sql);
            //给占位符？传值，（第一个问号下表是1，第二个问号下标是2，JDBC中所有下表从1开始。
            prep.setString(1,loginName);//会自动加单引号，如果是数字用setInt()方法。
            prep.setString(2,passcode);
            //4.执行sql
           //以上正好完成了sql语句的拼接，以下代码是，发送sql语句给DBMS进行编译。
            //正好将用户提供的”非法信息“编译进去。导致了原sql语句的含义被扭曲了。
            rs=prep.executeQuery();
            //处理结果集
            if(rs.next()){
                falg =true;
            }
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        } finally {
            //6.释放资源
            if(rs!=null){
                try {
                    rs.close();
                } catch (SQLException throwables) {
                    throwables.printStackTrace();
                }
            }
            if(prep!=null){
                try {
                    prep.close();
                } catch (SQLException throwables) {
                    throwables.printStackTrace();
                }
            }
            if(conn!=null){
                try {
                    conn.close();
                } catch (SQLException throwables) {
                    throwables.printStackTrace();
                }
            }
        }


        return  falg;
    }

    /**
* 初始化用户界面
* 返回用户名和密码等信息*/
    private static Map<String, String> initUi() {
        Scanner sc = new Scanner(System.in);
        System.out.println("用户名：");
        String username=sc.nextLine();
        System.out.println("密码：");
        String passcode = sc.nextLine();
        Map<String,String>userInfromation= new HashMap<>();
        userInfromation.put("username",username);
        userInfromation.put("passcode",passcode);
        return userInfromation;
    }

}

运行结果可以看出解决了SQL语句的注入问题。
8.Statement和PrepareStatement接口对比：
1.PrepareStatement接口解决了SQL注入的问题。

2.Statement第一次已经编译的SQL语句，后面出现一模一样的不会再编译，直接执行，一但多了一个空格就会重新编译。而PrepareStatement没有这个问题只编译一次。因此后者效率较高。

3.PrepareStatement会在编译的时候进行安全检查。

9.因此可以看出PrepareSatement使用较多(单纯传值。当业务需要SQL注入的时候，使用Statement.
比如：在升序和降序的时候需要使用SQL注入。

因为setString(1,desc)会自动加单引号，但是我们不需要单引号。

4.用PreparedStatement完成增删改查

直接看代码：注意得配置jdbc.properties文件。

package Day1;
import java.util.*;
import java.sql.*;
public class PreparedStatementTest1 {
    public static void main(String[] args) {
        //使用资源绑定器绑定属性配置文件
        ResourceBundle bundle  = ResourceBundle.getBundle("jdbc");
        String driver = bundle.getString("driver");//driver=com.mysql.jdbc.Driver
        String url = bundle.getString("url");
        String user = bundle.getString("user");
        String password= bundle.getString("password");
        Connection conn = null;
        PreparedStatement prep =null;
        try{
            //1.注册驱动
            Class.forName(driver);

            //2.获取连接
            conn=DriverManager.getConnection(url,user,password);

            //3.获取预编译的数据库操作对象
            //增
            /*String sql = "insert  into dept(deptno,dname,loc)values(?,?,?)";
            prep=conn.prepareStatement(sql);
            prep.setInt(1,60);
            prep.setString(2,"xing");
            prep.setString(3,"shenzhen");*/
            //改
           /* String sql = "update dept set dname = ?,loc =? where deptno =?";
            prep=conn.prepareStatement(sql);
            prep.setString(1,"asdf");
            prep.setString(2,"ShangHai");
            prep.setInt(3,60);*/
            //删除
            String sql = "delete  from dept where deptno =?";
           prep=conn.prepareStatement(sql);
            prep.setInt(1,60);

            //4.执行sql语句
            //int executeUpdate(insert/delete/update)
            //ResultSet executeQuery(select)
            int count=prep.executeUpdate();
            System.out.println(count);
        }catch(Exception e){

        }finally{
            //6.释放资源
            try{
                if(prep!=null){//不能一起try,如果一起try，假如一个出问题，其他也出问题
                    prep.close();
                }
            }catch(SQLException e){
                e.printStackTrace();
            }
            try{
                if(conn!=null){//不能一起try,如果一起try，假如一个出问题，其他也出问题
                    conn.close();
                }
            }catch(SQLException e){
                e.printStackTrace();
            }
        }
    }
}

5.事务问题

JDBC中的事务是自动提交的：
1.只要执行任意一条DML语句，则自动提交一次。这是JDBC默认的事务行为。

• 但是在实际业务中，同常都是N条DML语句共同联合才能完成的，必须保证他们这些DML
• 在同一个事物中同时成功或者同时失败。

自动提交存在的问题：
账户转账演示：（单机事务）

package Day1;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.util.ResourceBundle;

//JDBC事务机制
public class JDBCTest2 {
    public static void main(String[] args) {
        //使用资源绑定器绑定属性配置文件
        ResourceBundle bundle  = ResourceBundle.getBundle("jdbc");
        String driver = bundle.getString("driver");//driver=com.mysql.jdbc.Driver
        String url = bundle.getString("url");
        String user = bundle.getString("user");
        String password= bundle.getString("password");
        Connection conn = null;
        PreparedStatement prep =null;
        try{
            //1.注册驱动
            Class.forName(driver);

            //2.获取连接
            conn= DriverManager.getConnection(url,user,password);
            //将自动提交改为手动提交
            conn.setAutoCommit(false);

            //3.获取预编译的数据库操作对象
            //账户向另一个账户转账
           String sql = "update t_acount set balance = ? where acount =?";
            prep=conn.prepareStatement(sql);
            prep.setDouble(1,333);//转333
            prep.setInt(2,123);
            int count = prep.executeUpdate();
            //假设遇到异常
            String s =null;
            s.toString();

            prep.setDouble(1,334);//收333
            prep.setInt(2,1234);

            //4.执行sql语句
            //int executeUpdate(insert/delete/update)
            //ResultSet executeQuery(select)
            count+=prep.executeUpdate();
            System.out.println(count==2?"转账成功":"转账失败");
            conn.commit();
        }catch(Exception e){
            if(conn!=null){
                try {
                    conn.rollback();
                } catch (SQLException throwables) {
                    throwables.printStackTrace();
                }
            }
            e.printStackTrace();
        }finally{
            //6.释放资源
            try{
                if(prep!=null){//不能一起try,如果一起try，假如一个出问题，其他也出问题
                    prep.close();
                }
            }catch(SQLException e){
                e.printStackTrace();
            }
            try{
                if(conn!=null){//不能一起try,如果一起try，假如一个出问题，其他也出问题
                    conn.close();
                }
            }catch(SQLException e){
                e.printStackTrace();
            }
        }
    }

}

重点代码：
conn.setAutoCommit(flase);
conn.commit();
conn.rollback();
分布式事务（目前了解即可）

6.JDBC工具类的封装

引出问题：你有木有发现前面写的JDBC的六步太繁琐了，代码太多了，那可不可以简化呢？

当然可以，我们可以将其封装解决这个问题。

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

自己封装的工具类：

package Day1;

import java.sql.*;

public class JDBCTest3 {
    private JDBCTest3(){
    }
    //静态代码块在类加载的时候只执行一次
    static {
        try {
            Class.forName("com.mysql.jdbc.Driver");//注册驱动
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
    //获取数据库连接
    public static Connection getConnection() throws SQLException{
            return DriverManager.getConnection("jdbc:mysql://localhost:3306/newdata?useSSL=false","root","123456");
        }

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

用自己封装的类实现模糊查询：

package Day1;

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

public class JDBCTest4 {
    public static void main(String[] args) {
        Connection conn =null;
        PreparedStatement prep =null;
        ResultSet rs = null;
        try {
            //获取连接
            conn=JDBCTest3.getConnection();
            //获取预编译的数据库操作对象
            String sql ="select name from t_student where name like ?";
            prep=conn.prepareStatement(sql);
            prep.setString(1,"_e%");
            rs=prep.executeQuery();
            while (rs.next()){
                System.out.println(rs.getString("name"));
            }

        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }finally {
            JDBCTest3.close(conn,prep,rs);
        }
    }
}

7.行级锁（悲观锁和乐观锁）

1.乐观锁：多线程并发，都可以对一行数据修改，只不过需要设置一个版本号。
版本号：比如事务1和事务2开始读到版本号为1.

其中事务1先对数据进行了修改，修改后查找版本号为1，于是提交修改的数据，将版本号改为2.

然后事务2后修改，修改之后查询版本号为2，和最初的版本号不相同，进行回滚操作。
思考：根据上述描述发现，如果两个事务对数据同时修改就会造成，前者数据更新的丢失。

*利用数据库中的数据和已经取出的数据的一致性做为“锁”，与for update相比，乐观锁机制是等到更改数据的时候才去校验，悲观锁是读取数据就开始做了校验，从这个角度来看，乐观锁是对数据库没有额外开销，那么效率相对是高的。

*需要更改的字段可以作为乐观锁的验证字段；或者表里建立version版本号，每更新一次数据版本号+1；或者加lastupdatedate（最后更新时间）

2.悲观锁（行级锁）：事务必须进行排队，数据被锁住了，不允许并发。
在select最后面加上 for update;

单表for update:

没有在for update 后加nowait时，事务需要等待其他事务执行。加上后就不用等待其他事务执行了，一判断有事务，立马抛出异常。

1.select * from table where name= ‘MengYangChen’ for update 锁住了这条数据，那么另一个事务对该数据进行DML操作或者也执行同样的for update操作时，会检测到这笔数据上有行级锁，那么就会等待着锁释放；

2.select * from table where name= ‘MengYangChen’ nowait，意思就是如果这笔数据上本身加了锁，另一个事务去执行这句SQL的时候，发现加了锁，就会直接抛出异常（ORA-00054:资源正忙），不会等待这笔数据的锁释放。

3.select * from table where name= ‘MengYangChen’ wait 5；意思就是如果这笔数据被锁住，另外一个人如果执行这句SQL后，会等待5秒，如果5秒后这句SQL还没有得到这笔数据的锁，就会抛出异常。

4.skip locked
例如： 我们如果先执行 A语句：select * from table where name=‘MengYangChen’ for update 这样就会把MengYangChen这行加上锁，然后再执行 B语句的时候：select * from table where name = ‘MengYangChen’ and name=‘XingKong’ for update;这时候肯定查不出来，因为A已经把B要加锁的数据锁了，这样B语句，连XingKong改行的数据都查不出来。

我们可以用skip locked解决该问题：
把B语句改为：select * from table where name = ‘MengYangChen’ and name=‘XingKong’ for update skip locked；意思就是执行的时候如果发现要查询的数据有锁，就把加了锁的数据跳过，把剩下未加锁的数据加锁，然后查询出来！

关联表for update:

现在大部分业务都是联表查询，如果用for update 的话，就会把所有关联表查询出来的列所在的行全部加锁。
例如： select * from t1,t2 where t1.id = t2.id and t1.age = ‘20’ for update；就会把t1和t2两个表中符合条件的行锁定。

那如果我只想锁住一个表该怎么办呢？
在for update后面添加 of column_name(你要加锁的字段名）。
例子： select * from t1,t2 where t1.id = t2.id and t1.age = ‘20’ for update of t1.id;这样只会对t1符合条件的行进行加锁。

关注公众号【轻松玩编程】后台回复“计算机资源”，即可获得学习资源。

“一朵花凋零荒芜不了整个春天，一次跌倒也荒废不了整段旅程。走下去，凭着耐心和拼搏，生活自会给予你全部答案。”
我是梦阳辰，期待与你相遇！看到这里素质三连一下呗！