前言：
当前同学们对“oracle connector java”大体比较注意，小伙伴们都需要分析一些“oracle connector java”的相关内容。那么小编也在网上搜集了一些关于“oracle connector java””的相关资讯，希望朋友们能喜欢，看官们一起来学习一下吧！学习目标
本次目标
第一章 JDBC概述
之前我们学习了JavaSE，编写了Java程序，数据保存在变量、数组、集合等中，无法持久化，后来学习了IO流可以将数据写入文件，但不方便管理数据以及维护数据的关系；
后来我们学习了数据库管理软件MySQL，可以方便的管理数据。
那么如何将它俩结合起来呢？即Java程序<==>MySQL，实现数据的存储和处理。
答案：使用JDBC技术，后期可以使用MyBatis等持久层框架（底层仍然使用了JDBC）。
1.1 JDBC概述
JDBC：Java Database Connectivity，它是代表一组独立于任何数据库管理系统（DBMS）的API，声明在java.sql与javax.sql包中，是SUN(现在Oracle)提供的一组接口规范。由各个数据库厂商来提供实现类，这些实现类的集合构成了数据库驱动jar。
即JDBC技术包含两个部分：
（1）java.sql包和javax.sql包中的API
因为为了项目代码的可移植性，可维护性，SUN公司从最初就制定了Java程序连接各种数据库的统一接口规范。这样的话，不管是连接哪一种DBMS软件，Java代码可以保持一致性。
（2）各个数据库厂商提供的jar
因为各个数据库厂商的DBMS软件各有不同，那么内部如何通过sql实现增、删、改、查等管理数据，只有这个数据库厂商自己更清楚，因此把接口规范的实现交给各个数据库厂商自己实现。
package com.atguigu.jdbc;
/*
一、JDBC的概述
1、之前学习了Java，又学习了MySQL数据库
JDBC 把 Java程序 和 MySQL数据库连起来，Java程序是负责数据的输入，业务的处理，数据的显示，MySQL负责数据的存储和管理。
2、JDBC：Java Database Connectivity
JDBC = JDK核心类库中的一套API（接口+部分工具类） + 数据库厂商提供的驱动jar
Java程序不仅仅能够连接MySQL数据库，可以连接很多数据库（Oracle，SQL Server，DB2，...）。
这就有一个问题？
数据库不同，它们的操作方式会有所不同，因为它们的底层实现方式，实现的语言等都是不同的。
那么Java去连接不同的数据库时，就会有不同的API。这样的话，就会导致：
（1）程序员的学习成本增加
（2）如果发生数据库迁移，Java代码就需要“重写”
如果是这样的话，就非常麻烦，可移植性、可维护性等非常差。
SUN公司（现在Oracle）就说，必须统一一套API，可以操作各种数据库。但是SUN公司又不同知道所有数据库内部是如何实现的，
也无法要求所有的数据库厂商按照统一的标准来开发他们的数据库软件。
SUN公司（现在Oracle）就设计了一套接口 + 部分类。然后各个数据库厂商，来提供这些接口的实现类。
==>Java程序中面向接口编程，在程序运行时，又需要引入这些接口的实现类，这些实现类就是数据库驱动jar。
*/
public class TestJDBC {
}
1.2 Java程序连接MySQL数据库
1.2.1 引入mysql驱动jar
方式一：单独某个模块使用mysql驱动
（1）在模块路径下建一个文件夹“jdbclibs”，把mysql的驱动jar放到里面
MySQL5.7：mysql-connector-java-5.1.36-bin.jar
MySQL8.0：mysql-connector-java-8.0.19.jar
（2）在jdbclibs文件夹上右键-->Add as Library...
（3）填写库名称、选择这个库应用范围（模块）-->选择使用的具体模块
方式二：项目下多个模块使用mysql驱动
（1）在项目路径下建一个文件夹“jdbclibrary”，把mysql的驱动jar放到里面
mysql-connector-java-5.1.36-bin.jar
MySQL8.0：mysql-connector-java-8.0.19.jar
（2）项目设置-->libraries--> + ->java-->文件夹“jdbclibs”
（3）选择需要这个jar的模块
项目设置-->modules-->模块名-->dependencies--> + - >library->Java -> 库
后期其他模块也要使用mysql驱动，可以直接添加项目的jdbclibrary库即可：
方式三：使用Maven仓库（后期大家学习）
12.2.2 Java代码连接MySQL数据库
/*步骤：
1、模块添加了依赖的mysql驱动相关库
2、在内存中加载驱动类（可选）
更早版本mysql驱动类：org.gjt.mm.mysql.Driver
最近版本：com.mysql.jdbc.Driver
MySQL8.0版本：com.mysql.cj.jdbc.Driver
//新版的mysql驱动jar可以省略这步，旧版的mysql驱动jar必须加这一步。
// 因为新版mysql驱动jar包下有一个META-INF/services/java.sql.Driver文件
//里面有填写mysql驱动类的全名称，DriverManager会自动读取这个文件，并加载对应的驱动类
//后期使用数据库连接池，或者MyBatis等框架时，在配置文件中加这个驱动类的配置即可
Class.forName("com.mysql.cj.jdbc.Driver");
3、连接数据库：通过DriverManager工具类获取数据库连接Connection的对象。
此时的Java程序是MySQL的一个客户端
连接数据库：
MySQL服务器主机的IP地址：
端口号
用户名
密码
网址：
String url = "jdbc:mysql://localhost:3306/test?serverTimezone=UTC";
Connection conn = DriverManager.getConnection(url, "root", "123456");
MySQL8使用时，url需要加参数：serverTimezone=UTC，否则会报错：
Exception in thread "main" java.sql.SQLException: The server time zone value '�й���ʱ��' is unrecognized or represents more than one time zone. You must configure either the server or JDBC driver (via the 'serverTimezone' configuration property) to use a more specifc time zone value if you want to utilize time zone support.
4、断开连接：使用close方法。
*/
package com.atguigu.jdbc;
import java.sql.Connection;
import java.sql.DriverManager;
public class TestJDBC {
public static void main(String[] args)throws Exception {
Class.forName("com.mysql.cj.jdbc.Driver");
Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/atguigu?serverTimezone=UTC","root","123456");
System.out.println("conn = " + conn);
conn.close();
}
}
1.3 实现增删改查
/*步骤：
1、模块添加了依赖的mysql驱动相关库
2、在内存中加载驱动类（可选）
Class.forName("com.mysql.cj.jdbc.Driver");
3、连接数据库
通过DriverManager工具类获取数据库连接Connection的对象。
String url = "jdbc:mysql://localhost:3306/test?serverTimezone=UTC";
Connection conn = DriverManager.getConnection(url, "root", "123456");
4、操作数据库
（1）通过Connection对象获取Statement或PreparedStatement对象
（2）通过Statement或PreparedStatement对象执行sql
执行增、删、改：int executeUpate()
执行查询：ResultSet executeQuery()
（3）如果服务器有查询结果返回，需要用ResultSet接收
遍历结果集的方法：
boolean next()：判断是否还有下一行
getString(字段名或序号),getInt(字段名或序号),getObject(字段名或序号)
5、释放资源（close）
*/
1.3.1 添加数据
package com.atguigu.crud;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
/*
用JDBC实现添加一条记录到atguigu数据库的t_department表中。
mysql> desc t_department;
+-------------+--------------+------+-----+---------+----------------+
| Field | Type | Null | Key | Default | Extra |
+-------------+--------------+------+-----+---------+----------------+
| did | int | NO | PRI | NULL | auto_increment |
| dname | varchar(20) | NO | UNI | NULL | |
| description | varchar(200) | YES | | NULL | |
+-------------+--------------+------+-----+---------+----------------+
3 rows in set (0.01 sec)
mysql> select * from t_department;
+-----+--------+------------------+
| did | dname | description |
+-----+--------+------------------+
| 1 | 研发部 | 负责研发工作 |
| 2 | 人事部 | 负责人事管理工作 |
| 3 | 市场部 | 负责市场推广工作 |
| 4 | 财务部 | 负责财务管理工作 |
| 5 | 后勤部 | 负责后勤保障工作 |
| 6 | 测试部 | 负责测试工作 |
+-----+--------+------------------+
6 rows in set (0.00 sec)
步骤：
1、一个项目引入一次数据库驱动jar就可以
2、建立数据库连接
（1）加载驱动类：通过Class类的forName方法注册驱动
（2）获取数据库连接
通过DriverManager类的静态方法获取数据库连接对象
3、通过数据库连接对象获取Statement或PreparedStatement对象，用来执行sql
4、通过Statement或PreparedStatement对象调用
（1）int executeUpdate()：执行insert,update,delete等更新数据库数据的sql
5、关闭，释放各种资源
*/
public class TestInsert {
public static void main(String[] args)throws Exception {
//把驱动类加载到内存中
Class.forName("com.mysql.cj.jdbc.Driver");
//B：获取数据库连接对象
String url = "jdbc:mysql://localhost:3306/atguigu?serverTimezone=UTC";
Connection connection = DriverManager.getConnection(url,"root","123456");
//Connection ==> 网络编程的Socket
String sql = "insert into t_department values(null,'测试数据部门','测试数据部门简介')";//发给服务器的sql
PreparedStatement pst = connection.prepareStatement(sql);
//PreparedStatement ==> IO流 网络编程的socket.getOutputStream()发生数据用的
int len = pst.executeUpdate();
//返回sql影响的记录数
System.out.println(len>0 ? "添加成功" : "添加失败");
pst.close();
connection.close();
/*
mysql> select * from t_department;
+-----+--------------+------------------+
| did | dname | description |
+-----+--------------+------------------+
| 1 | 研发部 | 负责研发工作 |
| 2 | 人事部 | 负责人事管理工作 |
| 3 | 市场部 | 负责市场推广工作 |
| 4 | 财务部 | 负责财务管理工作 |
| 5 | 后勤部 | 负责后勤保障工作 |
| 6 | 测试部 | 负责测试工作 |
| 7 | 测试数据部门 | 测试数据部门简介 |
+-----+--------------+------------------+
7 rows in set (0.00 sec)
*/
}
}
1.3.2 修改数据
package com.atguigu.crud;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
public class TestUpdate {
public static void main(String[] args)throws Exception {
//把驱动类加载到内存中
Class.forName("com.mysql.cj.jdbc.Driver");
//B：获取数据库连接对象
String url = "jdbc:mysql://localhost:3306/atguigu?serverTimezone=UTC";
Connection connection = DriverManager.getConnection(url, "root", "123456");
//Connection ==> 网络编程的Socket
String sql = "update t_department set description = 'xx' where did = 7";//发给服务器的sql
PreparedStatement pst = connection.prepareStatement(sql);
//PreparedStatement ==> IO流 网络编程的socket.getOutputStream()发生数据用的
int len = pst.executeUpdate();
//返回sql影响的记录数
System.out.println(len > 0 ? "修改成功" : "修改失败");
pst.close();
connection.close();
}
}
/*
mysql> select * from t_department;
+-----+--------------+------------------+
| did | dname | description |
+-----+--------------+------------------+
| 1 | 研发部 | 负责研发工作 |
| 2 | 人事部 | 负责人事管理工作 |
| 3 | 市场部 | 负责市场推广工作 |
| 4 | 财务部 | 负责财务管理工作 |
| 5 | 后勤部 | 负责后勤保障工作 |
| 6 | 测试部 | 负责测试工作 |
| 7 | 测试数据部门 | xx |
+-----+--------------+------------------+
7 rows in set (0.00 sec)
*/
1.3.3 删除数据
package com.atguigu.crud;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
public class TestDelete {
public static void main(String[] args)throws Exception {
//把驱动类加载到内存中
Class.forName("com.mysql.cj.jdbc.Driver");
//B：获取数据库连接对象
String url = "jdbc:mysql://localhost:3306/atguigu?serverTimezone=UTC";
Connection connection = DriverManager.getConnection(url, "root", "123456");
//Connection ==> 网络编程的Socket
String sql = "delete from t_department where did = 7";//发给服务器的sql
PreparedStatement pst = connection.prepareStatement(sql);
//PreparedStatement ==> IO流 网络编程的socket.getOutputStream()发生数据用的
int len = pst.executeUpdate();
//返回sql影响的记录数
System.out.println(len > 0 ? "删除成功" : "删除失败");
pst.close();
connection.close();
}
}
/*
mysql> select * from t_department;
+-----+--------+------------------+
| did | dname | description |
+-----+--------+------------------+
| 1 | 研发部 | 负责研发工作 |
| 2 | 人事部 | 负责人事管理工作 |
| 3 | 市场部 | 负责市场推广工作 |
| 4 | 财务部 | 负责财务管理工作 |
| 5 | 后勤部 | 负责后勤保障工作 |
| 6 | 测试部 | 负责测试工作 |
+-----+--------+------------------+
6 rows in set (0.00 sec)
*/
1.3.4 查询数据
package com.atguigu.crud;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
/*
步骤：
1、一个项目引入一次数据库驱动jar就可以
2、建立数据库连接
（1）加载驱动类：通过Class类的forName方法注册驱动
（2）获取数据库连接
通过DriverManager类的静态方法获取数据库连接对象
3、通过数据库连接对象获取Statement或PreparedStatement对象，用来执行sql
4、通过Statement或PreparedStatement对象调用
（1）int executeUpdate()：执行insert,update,delete等更新数据库数据的sql
（2）ResultSet executeQuery()：执行select查询的sql，返回一个结果集
（3）boolean execute()：可以用来执行DDL语句
遍历结果集ResultSet的方法：
boolean next()：判断是否还有下一行
getString(字段名或序号),getInt(字段名或序号),getObject(字段名或序号)
5、关闭，释放各种资源
*/
public class TestSelect {
public static void main(String[] args)throws Exception {
//把驱动类加载到内存中
Class.forName("com.mysql.cj.jdbc.Driver");
//B：获取数据库连接对象
String url = "jdbc:mysql://localhost:3306/atguigu?serverTimezone=UTC";
Connection connection = DriverManager.getConnection(url, "root", "123456");
//Connection ==> 网络编程的Socket
String sql = "select * from t_department";//发给服务器的sql
PreparedStatement pst = connection.prepareStatement(sql);
//PreparedStatement ==> IO流 网络编程的socket.getOutputStream()发生数据用的
ResultSet resultSet = pst.executeQuery();//==>IO流 输入流，又像是集合和迭代器的集成
while(resultSet.next()){ //while循环一次，迭代一行，遍历一行
int did = resultSet.getInt("did");//get一次得到一个单元格的数据
String dname = resultSet.getString("dname");
String decription = resultSet.getString("description");
System.out.println(did +"\t" + dname +"\t" + decription);
}
resultSet.close();
pst.close();
connection.close();
}
}
第二章 轻松处理各种问题
2.1 避免sql拼接问题
准备代码和sql
Scanner input = new Scanner(System.in);
System.out.print("请输入姓名：");
String ename = input.next();//李四
System.out.print("请输入薪资：");
double salary = input.nextDouble();//15000
System.out.print("请输入出生日期：");
String birthday = input.next();//1990-1-1
System.out.print("请输入性别：");
char gender = input.next().charAt(0);//男
System.out.print("请输入手机号码：");
String tel = input.next();//13578595685
System.out.print("请输入邮箱：");
String email = input.next();//zhangsan@atguigu.com
input.close();
INSERT INTO t_employee(ename,salary,birthday,gender,tel,email,hiredate)VALUES(值列表);
问题演示代码
package com.atguigu.problem;
import org.junit.Test;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.util.Date;
import java.util.Scanner;
/*
避免sql拼接问题
演示：从键盘输入数据，存储到atguigu数据库的t_employee表中。
mysql> desc t_employee;
+----------------+----------------------------------+------+-----+---------+----------------+
| Field | Type | Null | Key | Default | Extra |
+----------------+----------------------------------+------+-----+---------+----------------+
| eid | int | NO | PRI | NULL | auto_increment |
| ename | varchar(20) | NO | | NULL | |
| salary | double | NO | | NULL | |
| commission_pct | decimal(3,2) | YES | | NULL | |
| birthday | date | NO | | NULL | |
| gender | enum('男','女') | NO | | 男 | |
| tel | char(11) | NO | | NULL | |
| email | varchar(32) | NO | | NULL | |
| address | varchar(150) | YES | | NULL | |
| work_place | set('北京','深圳','上海','武汉') | NO | | 北京 | |
| hiredate | date | NO | | NULL | |
| job_id | int | YES | MUL | NULL | |
| mid | int | YES | MUL | NULL | |
| did | int | YES | MUL | NULL | |
+----------------+----------------------------------+------+-----+---------+----------------+
14 rows in set (0.00 sec)
PreparedStatement接口是Statement接口的子接口的。
Statement接口是不支持 ？ 形式的sql，只能拼接。
*/
public class TestSQLConcat {
@Test
public void test01()throws Exception{
Scanner input = new Scanner(System.in);
System.out.print("请输入姓名：");
String ename = input.next();//李四
System.out.print("请输入薪资：");
double salary = input.nextDouble();//15000
System.out.print("请输入出生日期：");
String birthday = input.next();//1990-1-1
System.out.print("请输入性别：");
char gender = input.next().charAt(0);//男
System.out.print("请输入手机号码：");
String tel = input.next();//13578595685
System.out.print("请输入邮箱：");
String email = input.next();//zhangsan@atguigu.com
//A:把驱动类加载到内存中
Class.forName("com.mysql.cj.jdbc.Driver");
//B：获取数据库连接对象
String url = "jdbc:mysql://localhost:3306/atguigu?serverTimezone=UTC";
Connection connection = DriverManager.getConnection(url,"root","123456");
//Connection ==> 网络编程的Socket
//给t_employee表中的有非空约束的字段赋值，因为work_place有默认值，这里就没有管它
String sql = "INSERT INTO t_employee(ename,salary,birthday,gender,tel,email,hiredate)VALUES(" +
"'" + ename +"'," + //这里的'，是mysql中表示字符串和日期的单引号
salary + "," +
"'" + birthday +"'," +
"'" + gender +"'," +
"'" + tel +"'," +
"'" + email +"'," +
"curdate()" + //mysql中日期函数，获取当前系统时间
")";
//C：通过连接对象，获取PreparedStatement对象
PreparedStatement pst = connection.prepareStatement(sql);
//D：执行sql
int len = pst.executeUpdate();
System.out.println(len>0 ? "添加成功" : "添加失败");
//E：释放连接等资源
pst.close();
connection.close();
input.close();
}
@Test
public void test02()throws Exception{
Scanner input = new Scanner(System.in);
System.out.print("请输入姓名：");
String ename = input.next();//李四
System.out.print("请输入薪资：");
double salary = input.nextDouble();//15000
System.out.print("请输入出生日期：");
String birthday = input.next();//1990-1-1
System.out.print("请输入性别：");
char gender = input.next().charAt(0);//男
System.out.print("请输入手机号码：");
String tel = input.next();//13578595685
System.out.print("请输入邮箱：");
String email = input.next();//zhangsan@atguigu.com
//A:把驱动类加载到内存中
Class.forName("com.mysql.cj.jdbc.Driver");
//B：获取数据库连接对象
String url = "jdbc:mysql://localhost:3306/atguigu?serverTimezone=UTC";
Connection connection = DriverManager.getConnection(url,"root","123456");
//Connection ==> 网络编程的Socket
//给t_employee表中的有非空约束的字段赋值，因为work_place有默认值，这里就没有管它
String sql = "INSERT INTO t_employee(ename,salary,birthday,gender,tel,email,hiredate)VALUES(?,?,?,?,?,?,?)";
//这里的？就像占位符，表示要给几个字段赋值
//C：通过连接对象，获取PreparedStatement对象
PreparedStatement pst = connection.prepareStatement(sql);//此时对sql进行预编译，里面是带？的
//要给每一个？指定具体的值
/*
PreparedStatement支持给每一个字段指定值时，确定数据类型，例如：
pst.setString(1,ename);
pst.setDouble(2,salary);
...
但是这样有点麻烦，还要一一去确定数据类型
PreparedStatement支持用Object统一处理
pst.setObject(1,ename);
pst.setObject(2,salary);
*/
pst.setObject(1,ename); //这里的1，表示第1个？
pst.setObject(2,salary); //这里的2，表示第2个？
pst.setObject(3,birthday); //这里的3，表示第3个？
pst.setObject(4,gender); //这里的4，表示第4个？
pst.setObject(5,tel); //这里的5，表示第5个？
pst.setObject(6,email); //这里的6，表示第6个？
pst.setObject(7,"curdate()"); //这里的7，表示第7个？
//每一个？与你要赋值的字段对应，不能对错了
//D：执行sql
int len = pst.executeUpdate();
System.out.println(len>0 ? "添加成功" : "添加失败");
/*
(1)上面的代码执行出错了：java.sql.SQLException: Data truncated for column 'gender' at row 1
原因： pst.setObject(4,gender); 把gender自动包装为Character对象
解决方案：把char类型用String类型表示。
(2)com.mysql.cj.jdbc.exceptions.MysqlDataTruncation: Data truncation: Incorrect date value: 'curdate()' for column 'hiredate' at row 1
pst.setObject(7,"curdate()"); "curdate()"代表字符串，setObject把curdate()识别为一个字符串，而不是mysql函数， 这句代码给hiredate字段赋值的是一个String
hiredate需要的是一个日期。
解决方案：pst.setObject(7, new Date());
*/
//E：释放连接等资源
pst.close();
connection.close();
input.close();
}
@Test
public void test03()throws Exception{
Scanner input = new Scanner(System.in);
System.out.print("请输入姓名：");
String ename = input.next();//李四
System.out.print("请输入薪资：");
double salary = input.nextDouble();//15000
System.out.print("请输入出生日期：");
String birthday = input.next();//1990-1-1
System.out.print("请输入性别：");
// char gender = input.next().charAt(0);//男
String gender = input.next();//男
System.out.print("请输入手机号码：");
String tel = input.next();//13578595685
System.out.print("请输入邮箱：");
String email = input.next();//zhangsan@atguigu.com
//A:把驱动类加载到内存中
Class.forName("com.mysql.cj.jdbc.Driver");
//B：获取数据库连接对象
String url = "jdbc:mysql://localhost:3306/atguigu?serverTimezone=UTC";
Connection connection = DriverManager.getConnection(url,"root","123456");
//Connection ==> 网络编程的Socket
//给t_employee表中的有非空约束的字段赋值，因为work_place有默认值，这里就没有管它
String sql = "INSERT INTO t_employee(ename,salary,birthday,gender,tel,email,hiredate)VALUES(?,?,?,?,?,?,?)";
//这里的？就像占位符，表示要给几个字段赋值
//C：通过连接对象，获取PreparedStatement对象
PreparedStatement pst = connection.prepareStatement(sql);//此时对sql进行预编译，里面是带？的
//要给每一个？指定具体的值
/*
PreparedStatement支持给每一个字段指定值时，确定数据类型，例如：
pst.setString(1,ename);
pst.setDouble(2,salary);
...
但是这样有点麻烦，还要一一去确定数据类型
PreparedStatement支持用Object统一处理
pst.setObject(1,ename);
pst.setObject(2,salary);
*/
pst.setObject(1,ename); //这里的1，表示第1个？
pst.setObject(2,salary); //这里的2，表示第2个？
pst.setObject(3,birthday); //这里的3，表示第3个？
pst.setObject(4,gender); //这里的4，表示第4个？
pst.setObject(5,tel); //这里的5，表示第5个？
pst.setObject(6,email); //这里的6，表示第6个？
pst.setObject(7, new Date()); //这里的7，表示第7个？
//每一个？与你要赋值的字段对应，不能对错了
//D：执行sql
int len = pst.executeUpdate();
System.out.println(len>0 ? "添加成功" : "添加失败");
/*
上面的代码执行出错了：java.sql.SQLException: Data truncated for column 'gender' at row 1
原因： pst.setObject(4,gender); 把gender自动包装为Character对象
解决方案：把char类型用String类型表示。
*/
//E：释放连接等资源
pst.close();
connection.close();
input.close();
}
}
2.2 避免sql注入问题
准备代码和sql
Scanner input = new Scanner(System.in);
System.out.print("请输入你要查询的员工的编号：");
String id = input.nextLine();
input.close();
select * from t_employee where eid = 值;
问题演示代码
package com.atguigu.problem;
import org.junit.Test;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.Scanner;
/*
避免sql注入问题
演示：从键盘输入员工编号，查询员工信息。每一个员工都可以输入自己的编号，查看自己的信息。
*/
public class TestSQLInject {
@Test
public void test01()throws Exception{
Scanner input = new Scanner(System.in);
System.out.print("请输入你要查询的员工的编号：");
String id = input.nextLine();
// 第一种正常输入：1
// 第二种恶意输入：1 or 1=1 第一个1表示员工编号， 后面 or 1= 1表示条件，而1=1是永远成立，其他条件全部失效
//把驱动类加载到内存中
Class.forName("com.mysql.cj.jdbc.Driver");
//B：获取数据库连接对象
String url = "jdbc:mysql://localhost:3306/atguigu?serverTimezone=UTC";
Connection connection = DriverManager.getConnection(url, "root", "123456");
//Connection ==> 网络编程的Socket
String sql = "select * from t_employee where eid = " + id;
System.out.println("sql = " + sql);//select * from t_employee where eid = 1 or 1=1
PreparedStatement pst = connection.prepareStatement(sql);
//执行查询
ResultSet rs = pst.executeQuery();
/*
ResultSet接口提供了
(1)boolean next()：判断是否有下一条记录
(2)获取某个单元格的数据
String getString(字段名)
int getInt(字段名)
double getDouble(字段名)
...
有点麻烦，需要一一去对应字段名
Object getObject(字段名)
Object getObject(字段的序号) 从1开始。
*/
while(rs.next()){//while循环一次，代表一行
//t_employee有14个字段
for(int i=1; i<=14; i++){//for循环一次，代表一行中的一个单元格
System.out.print(rs.getObject(i)+"\t");
}
System.out.println();
}
rs.close();
pst.close();
connection.close();
input.close();
/*
用户输入 1 or 1=1，盗取了表中的所有数据。
1 孙洪亮 28000.0 0.65 1980-10-08 男 13789098765 shl@atguigu.com 白庙村西街 北京,深圳 2011-07-28 1 1 1
2 何进 7001.0 0.10 1984-08-03 男 13456732145 hj@atguigu.com 半截塔存 深圳,上海 2015-07-03 2 1 1
3 邓超远 8000.0 null 1985-04-09 男 18678973456 dcy666@atguigu.com 宏福苑 北京,深圳,上海,武汉 2014-07-01 3 7 1
4 黄熙萌 9456.0 null 1986-09-07 女 13609876789 hxm@atguigu.com 白庙村东街 深圳,上海,武汉 2015-08-08 8 22 3
5 陈浩 8567.0 null 1978-08-02 男 13409876545 ch888@atguigu.com 回龙观 北京,深圳,上海 2015-01-01 3 7 1
6 韩庚年 12000.0 null 1985-04-03 男 18945678986 hgn@atguigu.com 龙泽 深圳,上海 2015-02-02 3 2 1
7 贾宝玉 15700.0 0.24 1982-08-02 男 15490876789 jby@atguigu.com 霍营 北京,武汉 2015-03-03 2 1 1
8 李晨熙 9000.0 0.40 1983-03-02 女 13587689098 lc@atguigu.com 东三旗 深圳,上海,武汉 2015-01-06 4 1 1
9 李易峰 7897.0 null 1984-09-01 男 13467676789 lyf@atguigu.com 西山旗 武汉 2015-04-01 3 7 1
10 陆风 8789.0 null 1989-04-02 男 13689876789 lf@atguigu.com 天通苑一区 北京 2014-09-03 2 1 1
11 黄冰茹 15678.0 null 1983-05-07 女 13787876565 hbr@atguigu.com 立水桥 深圳 2014-04-04 4 1 1
12 孙红梅 9000.0 null 1986-04-02 女 13576234554 shm@atguigu.com 立城苑 上海 2014-02-08 3 7 1
13 李冰冰 18760.0 null 1987-04-09 女 13790909887 lbb@atguigu.com 王府温馨公寓 北京 2015-06-07 3 2 1
14 谢吉娜 18978.0 0.25 1990-01-01 女 13234543245 xjn@atguigu.com 园中园 上海,武汉 2015-09-05 5 14 2
15 董吉祥 8978.0 null 1987-05-05 男 13876544333 djx@atguigu.com 小辛庄 北京,上海 2015-08-04 6 14 2
16 彭超越 9878.0 null 1988-03-06 男 18264578930 pcy@atguigu.com 西二旗 深圳,武汉 2015-03-06 8 22 3
17 李诗雨 9000.0 null 1990-08-09 女 18567899098 lsy@atguigu.com 清河 北京,深圳,武汉 2013-06-09 8 22 3
18 舒淇格 16788.0 0.10 1978-09-04 女 18654565634 sqg@atguigu.com 名流花园 北京,深圳,武汉 2013-04-05 9 18 4
19 周旭飞 7876.0 null 1988-06-13 女 13589893434 sxf@atguigu.com 小汤山 北京,深圳 2014-04-07 10 18 4
20 章嘉怡 15099.0 0.10 1989-12-11 女 15634238979 zjy@atguigu.com 望都家园 北京 2015-08-04 11 20 5
21 白露 9787.0 null 1989-09-04 女 18909876789 bl@atguigu.com 西湖新村 上海 2014-06-05 12 20 5
22 刘烨 13099.0 0.32 1990-11-09 男 18890980989 ly@atguigu.com 多彩公寓 北京,上海 2016-08-09 7 22 3
23 陈纲 13090.0 null 1990-02-04 男 18712345632 cg@atguigu.com 天通苑二区 深圳 2016-05-09 3 2 1
24 吉日格勒 10289.0 null 1990-04-01 男 17290876543 jrgl@163.com 北苑 北京 2017-02-06 12 20 5
25 额日古那 9087.0 null 1989-08-01 女 18709675645 ergn@atguigu.com 望京 北京,上海 2017-09-01 3 2 1
26 李红 5000.0 null 1995-02-15 女 15985759663 lihong@atguigu.com 冠雅苑 北京 2021-09-01 null null null
27 周洲 8000.0 null 1990-01-01 男 13574528569 zhouzhou@atguigu.com 冠华苑 北京,深圳 2020-08-15 3 2 null
28 张三 15000.0 null 1999-05-05 男 10086 zhangsan@atguigu.com null 北京 2021-12-03 null null null
29 李四 14000.0 null 2000-09-09 女 10010 lisi@atguigu.com null 北京 2021-12-03 null null null
*/
}
@Test
public void test02()throws Exception {
Scanner input = new Scanner(System.in);
System.out.print("请输入你要查询的员工的编号：");
String id = input.nextLine();
// 第一种正常输入：1
// 第二种恶意输入：1 or 1=1 第一个1表示员工编号， 后面 or 1= 1表示条件，而1=1是永远成立，其他条件全部失效
//把驱动类加载到内存中
Class.forName("com.mysql.cj.jdbc.Driver");
//B：获取数据库连接对象
String url = "jdbc:mysql://localhost:3306/atguigu?serverTimezone=UTC";
Connection connection = DriverManager.getConnection(url, "root", "123456");
//Connection ==> 网络编程的Socket
String sql = "select * from t_employee where eid = ? ";//不用拼接了
PreparedStatement pst = connection.prepareStatement(sql);
//给？指定值
pst.setObject(1, id);
//因为这里把 "2 or 1=1"当成一个整体赋值给eid
//select * from t_employee where eid = '2 or 1=1';
/*
eid字段是int类型，mysql在解析时，发现给eid赋值了字符串，会把字符串尽量转为int类型的值。
SELECT '2 or 1=1'+0; 得到结果是2。
select * from t_employee where eid = '2 or 1=1';
等价于
select * from t_employee where eid = 2;
*/
//执行查询
ResultSet rs = pst.executeQuery();
/*
ResultSet接口提供了
(1)boolean next()：判断是否有下一条记录
(2)获取某个单元格的数据
String getString(字段名)
int getInt(字段名)
double getDouble(字段名)
...
有点麻烦，需要一一去对应字段名
Object getObject(字段名)
Object getObject(字段的序号) 从1开始。
*/
while (rs.next()) {//while循环一次，代表一行
//t_employee有14个字段
for (int i = 1; i <= 14; i++) {//for循环一次，代表一行中的一个单元格
System.out.print(rs.getObject(i) + "\t");
}
System.out.println();
}
rs.close();
pst.close();
connection.close();
input.close();
}
}
2.3 使用字节IO流读取图片等给blob等二进制类型数据赋值
准备代码和sql
Scanner input = new Scanner(System.in);
System.out.print("请输入用户名：");
String username = input.next();
System.out.print("请输入密码：");
String password = input.next();
System.out.print("请选择照片：");
String path = input.next();//这里没有图形化界面，只能输入路径，通过IO流读取图片的内容
input.close();
CREATE TABLE `t_user` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`username` varchar(20) NOT NULL,
`password` varchar(50) NOT NULL,
`photo` blob,
PRIMARY KEY (`id`)
);
添加记录：insert into t_user values(null,?,?,?);
修改表结构：ALTER TABLE t_user MODIFY photo MEDIUMBLOB;
问题演示代码
package com.atguigu.problem;
import org.junit.Test;
import java.io.FileInputStream;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.util.Scanner;
/*
CREATE TABLE `t_user` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`username` varchar(20) NOT NULL,
`password` varchar(50) NOT NULL,
`photo` blob,
PRIMARY KEY (`id`)
);
mysql> desc t_user;
+----------+-------------+------+-----+---------+----------------+
| Field | Type | Null | Key | Default | Extra |
+----------+-------------+------+-----+---------+----------------+
| id | int | NO | PRI | NULL | auto_increment |
| username | varchar(20) | NO | | NULL | |
| password | varchar(50) | NO | | NULL | |
| photo | blob | YES | | NULL | |
+----------+-------------+------+-----+---------+----------------+
4 rows in set (0.00 sec)
*/
public class TestBlob {
@Test
public void test01()throws Exception{
Scanner input = new Scanner(System.in);
System.out.print("请输入用户名：");
String username = input.next();
System.out.print("请输入密码：");
String password = input.next();
System.out.print("请选择照片：");
String path = input.next();//这里没有图形化界面，只能输入路径，通过IO流读取图片的内容
//把驱动类加载到内存中
Class.forName("com.mysql.cj.jdbc.Driver");
//B：获取数据库连接对象
String url = "jdbc:mysql://localhost:3306/atguigu?serverTimezone=UTC";
Connection connection = DriverManager.getConnection(url, "root", "123456");
//Connection ==> 网络编程的Socket
String sql = "insert into t_user values(null,?,?,?)";
PreparedStatement pst = connection.prepareStatement(sql);
//设置？的值
pst.setObject(1, username);
pst.setObject(2, password);
// pst.setObject(3, path);//不对，因为path是一个路径
pst.setObject(3, new FileInputStream(path)); //用字节IO流来表示二进制数据
//执行sql
int len = pst.executeUpdate();
System.out.println(len >0 ? "添加成功" : "添加失败");
pst.close();
connection.close();
input.close();
/*
当存储的图片特别大时：
（1）com.mysql.cj.jdbc.exceptions.PacketTooBigException: Packet for query is too large (6,638,795 > 4,194,304).
You can change this value on the server by setting the 'max_allowed_packet' variable.
解决方案：修改my.ini配置文件 max_allowed_packet变量的值
先停止服务，然后修改my.ini文件，再重启服务
（2）com.mysql.cj.jdbc.exceptions.MysqlDataTruncation: Data truncation: Data too long for column 'photo' at row 1
问题是：blob类型的数据，存不下这么大的图片
解决方案：修改字段的数据类型
alter table t_user modify photo mediumblob;
mysql> alter table t_user modify photo mediumblob;
ERROR 2013 (HY000): Lost connection to MySQL server during query
No connection. Trying to reconnect...
Connection id: 9
Current database: atguigu
Query OK, 1 row affected (0.08 sec)
Records: 1 Duplicates: 0 Warnings: 0
mysql> desc t_user;
+----------+-------------+------+-----+---------+----------------+
| Field | Type | Null | Key | Default | Extra |
+----------+-------------+------+-----+---------+----------------+
| id | int | NO | PRI | NULL | auto_increment |
| username | varchar(20) | NO | | NULL | |
| password | varchar(50) | NO | | NULL | |
| photo | mediumblob | YES | | NULL | |
+----------+-------------+------+-----+---------+----------------+
4 rows in set (0.01 sec)
*/
}
}
2.4 获取自增长键值
准备代码和sql
INSERT INTO t_employee(ename,salary,birthday,gender,tel,email,hiredate)VALUES(?,?,?,?,?,?,?)
Scanner input = new Scanner(System.in);
System.out.print("请输入姓名：");
String ename = input.next();//李四
System.out.print("请输入薪资：");
double salary = input.nextDouble();//15000
System.out.print("请输入出生日期：");
String birthday = input.next();//1990-1-1
System.out.print("请输入性别：");
String gender = input.next();//男 mysql的gender是枚举类型，这里用String处理
System.out.print("请输入手机号码：");
String tel = input.next();//13578595685
System.out.print("请输入邮箱：");
String email = input.next();//zhangsan@atguigu.com
input.close();
问题演示代码
package com.atguigu.problem;
import org.junit.Test;
import java.sql.*;
import java.util.Date;
import java.util.Scanner;
/*
获取自增长键值：
mysql中很多表都是有自增长字段，特别是id。
当我们添加了一个员工、部门，添加成功后，需要立刻返回该员工、部门的自增长的id值。
（1）在用Connection数据库连接对象获取PreparedStatement对象时，要加一个参数
PreparedStatement pst = connection.prepareStatement(sql, Statement.RETURN_GENERATED_KEYS);
这里Statement.RETURN_GENERATED_KEYS表示，执行sql后，返回自增长键值
（2）执行完成之后，需要从PreparedStatement对象中获取自增长键值
ResultSet rs = pst.getGeneratedKeys(); //方法别调错
if(rs.next()){ //因为只有一条记录，所以只有一个自增长键值，用if即可
System.out.println("新员工编号是：" + rs.getObject(1));//因为自增长键值只有一个，所以这里直接getObject(1)即可
}
*/
public class TestGenerateKey {
@Test
public void test03()throws Exception{
Scanner input = new Scanner(System.in);
System.out.print("请输入姓名：");
String ename = input.next();//李四
System.out.print("请输入薪资：");
double salary = input.nextDouble();//15000
System.out.print("请输入出生日期：");
String birthday = input.next();//1990-1-1
System.out.print("请输入性别：");
String gender = input.next();//男 mysql的gender是枚举类型，这里用String处理
System.out.print("请输入手机号码：");
String tel = input.next();//13578595685
System.out.print("请输入邮箱：");
String email = input.next();//zhangsan@atguigu.com
//A:把驱动类加载到内存中
Class.forName("com.mysql.cj.jdbc.Driver");
//B：获取数据库连接对象
String url = "jdbc:mysql://localhost:3306/atguigu?serverTimezone=UTC";
Connection connection = DriverManager.getConnection(url,"root","123456");
//Connection ==> 网络编程的Socket
//给t_employee表中的有非空约束的字段赋值，因为work_place有默认值，这里就没有管它
String sql = "INSERT INTO t_employee(ename,salary,birthday,gender,tel,email,hiredate)VALUES(?,?,?,?,?,?,?)";
//这里的？就像占位符，表示要给几个字段赋值
//C：通过连接对象，获取PreparedStatement对象
PreparedStatement pst = connection.prepareStatement(sql, Statement.RETURN_GENERATED_KEYS);//此时对sql进行预编译，里面是带？的
//Statement.RETURN_GENERATED_KEYS表示，执行sql后，返回自增长键值
//要给每一个？指定具体的值
/*
PreparedStatement支持给每一个字段指定值时，确定数据类型，例如：
pst.setString(1,ename);
pst.setDouble(2,salary);
...
但是这样有点麻烦，还要一一去确定数据类型
PreparedStatement支持用Object统一处理
pst.setObject(1,ename);
pst.setObject(2,salary);
*/
pst.setObject(1,ename); //这里的1，表示第1个？
pst.setObject(2,salary); //这里的2，表示第2个？
pst.setObject(3,birthday); //这里的3，表示第3个？
pst.setObject(4,gender); //这里的4，表示第4个？
pst.setObject(5,tel); //这里的5，表示第5个？
pst.setObject(6,email); //这里的6，表示第6个？
pst.setObject(7, new Date()); //这里的7，表示第7个？
//每一个？与你要赋值的字段对应，不能对错了
//D：执行sql
int len = pst.executeUpdate();
System.out.println(len>0 ? "添加成功" : "添加失败");
ResultSet rs = pst.getGeneratedKeys();
if(rs.next()){
System.out.println("新员工编号是：" + rs.getObject(1));//因为自增长键值只有一个，所以这里直接getObject(1)即可
}
//E：释放连接等资源
rs.close();
pst.close();
connection.close();
input.close();
}
}
2.5 批处理
准备代码和sql
insert into t_department values(null,?,?)
问题演示代码
package com.atguigu.problem;
import org.junit.Test;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
/*
批处理：
批量执行一组sql。大多数情况下都是批量执行insert语句。
演示：给部门表批量添加1000条部门测试信息。
MySQL服务器端，默认批处理功能没有开启。需要通过参数告知mysql服务器，开启批处理功能。
在url后面再加一个参数 rewriteBatchedStatements=true
url的格式：
jdbc:mysql://localhost:3306/atguigu
如果要加参数，需要用一个?，表示后面是参数
jdbc:mysql://localhost:3306/atguigu?serverTimezone=UTC
如果有多个参数，参数之间使用&连接，
每一个参数都是key=value的格式。
jdbc:mysql://localhost:3306/atguigu?serverTimezone=UTC&rewriteBatchedStatements=true
如何实现批处理？
（1）url中加rewriteBatchedStatements=true
jdbc:mysql://localhost:3306/atguigu?serverTimezone=UTC&rewriteBatchedStatements=true
（2）PreparedStatement对象调用
A：addBatch()
B：executeBatch()
（3）不要把values写错value（学生问题）
*/
public class TestBatch {
@Test
public void test01()throws Exception{
long start = System.currentTimeMillis();
//把驱动类加载到内存中
Class.forName("com.mysql.cj.jdbc.Driver");
//B：获取数据库连接对象
String url = "jdbc:mysql://localhost:3306/atguigu?serverTimezone=UTC";
Connection connection = DriverManager.getConnection(url, "root", "123456");
//Connection ==> 网络编程的Socket
String sql = "insert into t_department values(null,?,?)";
PreparedStatement pst = connection.prepareStatement(sql);
//上面的sql是重复使用的，PreparedStatement对象也重复使用，不用new1000个对象。
//mysql服务器端也可以优化，提高性能
for(int i=1; i<=1000; i++){
//设置1000次？的值
pst.setObject(1,"测试"+i);
pst.setObject(2,"测试简介"+i);
pst.executeUpdate();//这里就不接收返回值了
//逐条添加，每设置一次？，就立刻添加一条
//设置完？是在内存中，添加到表中，是要用IO流写到文件中，
// 添加1000条意味着要用IO流与文件通信1000次
}
pst.close();
connection.close();
long end = System.currentTimeMillis();
System.out.println("耗时：" + (end-start));//耗时：4700
}
@Test
public void test02()throws Exception{
long start = System.currentTimeMillis();
//把驱动类加载到内存中
Class.forName("com.mysql.cj.jdbc.Driver");
//B：获取数据库连接对象
String url = "jdbc:mysql://localhost:3306/atguigu?serverTimezone=UTC";
Connection connection = DriverManager.getConnection(url, "root", "123456");
//Connection ==> 网络编程的Socket
String sql = "insert into t_department values(null,?,?)";
PreparedStatement pst = connection.prepareStatement(sql);
//上面的sql是重复使用的，PreparedStatement对象也重复使用，不用new1000个对象。
//mysql服务器端也可以优化，提高性能
for(int i=1001; i<=2000; i++){
//设置1000次？的值
pst.setObject(1,"测试"+i);
pst.setObject(2,"测试简介"+i);
// pst.executeUpdate();//不用设置一次？，就执行一次
pst.addBatch();//先攒着这些数据，设置完？，sql会重新编译一下，生成一条新的完整的sql
}
pst.executeBatch();//最后一口气执行
// 这里虽然调用了批处理执行sql的方法，但是url中没有告诉mysql开启批处理的功能，仍然是一条一条添加的
pst.close();
connection.close();
long end = System.currentTimeMillis();
System.out.println("耗时：" + (end-start));//耗时：4714
}
@Test
public void test03()throws Exception{
long start = System.currentTimeMillis();
//把驱动类加载到内存中
Class.forName("com.mysql.cj.jdbc.Driver");
//B：获取数据库连接对象
String url = "jdbc:mysql://localhost:3306/atguigu?serverTimezone=UTC&rewriteBatchedStatements=true";
Connection connection = DriverManager.getConnection(url, "root", "123456");
//Connection ==> 网络编程的Socket
String sql = "insert into t_department values(null,?,?)";
PreparedStatement pst = connection.prepareStatement(sql);
//上面的sql是重复使用的，PreparedStatement对象也重复使用，不用new1000个对象。
//mysql服务器端也可以优化，提高性能
for(int i=2001; i<=3000; i++){
//设置1000次？的值
pst.setObject(1,"测试"+i);
pst.setObject(2,"测试简介"+i);
// pst.executeUpdate();//不用设置一次？，就执行一次
pst.addBatch();//先攒着这些数据，设置完？，sql会重新编译一下，生成一条新的完整的sql
}
pst.executeBatch();//最后一口气执行
pst.close();
connection.close();
long end = System.currentTimeMillis();
System.out.println("耗时：" + (end-start));//耗时：1625
}
@Test
public void test04()throws Exception{
long start = System.currentTimeMillis();
//把驱动类加载到内存中
Class.forName("com.mysql.cj.jdbc.Driver");
//B：获取数据库连接对象
String url = "jdbc:mysql://localhost:3306/atguigu?serverTimezone=UTC&rewriteBatchedStatements=true";
Connection connection = DriverManager.getConnection(url, "root", "123456");
//Connection ==> 网络编程的Socket
String sql = "insert into t_department values(null,?,?)";//如果把values写错value，批处理不起作用
PreparedStatement pst = connection.prepareStatement(sql);
//上面的sql是重复使用的，PreparedStatement对象也重复使用，不用new1000个对象。
//mysql服务器端也可以优化，提高性能
for(int i=2001; i<=3000; i++){
//设置1000次？的值
pst.setObject(1,"测试"+i);
pst.setObject(2,"测试简介"+i);
// pst.executeUpdate();//不用设置一次？，就执行一次
pst.addBatch();//先攒着这些数据，设置完？，sql会重新编译一下，生成一条新的完整的sql
}
pst.executeBatch();//最后一口气执行
pst.close();
connection.close();
long end = System.currentTimeMillis();
System.out.println("耗时：" + (end-start));//耗时：4625
}
}
2.6 事务处理
准备代码和sql
演示：
update t_department set description = 'xx' where did = 2;
update t_department set description = 'yy' where did = 3;
故意把其中一条sql语句写错。
update t_department set description = 'xx' where did = 2;
update t_department set description = 'yy' what did = 3; #what是错误的
问题演示代码
package com.atguigu.problem;
import org.junit.Test;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.SQLException;
/*
如果多条sql要组成一个事务，要么一起成功，要么一起失败。
例如：订单
（1）修改商品表的商品库存和销量
（2）订单表新建订单数据
（3）订单明细表新建订单明细记录（多条）
....
这些sql要么一起成功，要么都还原到最初。
演示：
update t_department set description = 'xx' where did = 2;
update t_department set description = 'yy' where did = 3;
故意把其中一条sql语句写错。
update t_department set description = 'xx' where did = 2;
update t_department set description = 'yy' what did = 3; #what是错误的，故意制造错误
JDBC如何管理事务？
（1）mysql默认是自动提交事务，每执行一条语句成功后，自动提交。
需要开启手动提交模式。
Connection连接对象.setAutoCommit(false);//取消自动提交模式，开始手动提交模式
(2)sql执行成功，别忘了提交事务
Connection连接对象.commit();
（3）sql执行失败，回滚事务
Connection连接对象.rollback();
*/
public class TestTransaction {
@Test
public void test01()throws Exception{
//把驱动类加载到内存中
Class.forName("com.mysql.cj.jdbc.Driver");
//B：获取数据库连接对象
String url = "jdbc:mysql://localhost:3306/atguigu?serverTimezone=UTC";
Connection connection = DriverManager.getConnection(url, "root", "123456");
//Connection ==> 网络编程的Socket
connection.setAutoCommit(false);//取消自动提交模式，开始手动提交模式
String s1 = "update t_department set description = 'xx' where did = 2";
String s2 = "update t_department set description = 'yy' what did = 3";
try(PreparedStatement p1 = connection.prepareStatement(s1);
PreparedStatement p2 = connection.prepareStatement(s2);) {
p1.executeUpdate();
p2.executeUpdate();
System.out.println("两条更新成功");
connection.commit();//提交事务
}catch(SQLException e){
e.printStackTrace();
System.out.println("失败");
connection.rollback();//回滚事务
}finally {
connection.close();
}
}
}
