1. JDBC基本概念
2. 快速入门
3. 对JDBC中各个接口和类详解
-
JDBC基本概念
- 概念：Java DataBase Connectivity Java 数据库连接， Java语言操作数据库
- JDBC本质：其实是官方（sun公司）定义的一套操作所有关系型数据库的规则，即接口。 各个数据库厂商去实现这套接口，提供数据库驱动jar包。 我们可以使用这套接口（JDBC）编程， 真正执行的代码是驱动jar包中的实现类。
- 概念：Java DataBase Connectivity Java 数据库连接， Java语言操作数据库
-
快速入门
先创建一个用于测试的数据库
//创建数据库
create database web_test3;
//选择数据库
use web_test3;
//创建数据表
create table user(
id int primary key auto_increment,
username varchar(20),
password varchar(20),
nickname varchar(20),
age int
);
//导入数据
insert into user values (null,'aaa','123','aa',34);
insert into user values (null,'bbb','123','bb',32);
insert into user values (null,'ccc','123','cc',28);
insert into user values (null,'ddd','123','dd',21);
* 步骤：
1.环境准备.
导入驱动jar包 mysql-connector-java-5.1.37-bin.jar
ecilpse版本
1.新建一个项目
2.右键单击项目 创建 lib文件夹
3.复制mysql-connector-java-5.1.37-bin.jar 到lib文件
4.右键单击jar包
5.build Path —> Add to Build Path
6.添加成功 项目会多出 一个外部依赖目录
idea版本
1.复制mysql-connector-java-5.1.37-bin.jar到项目的libs目录下
2.右键–>Add As Library
2.代码实现
2.1. 注册驱动
2.2. 获取数据库连接对象 Connection
2.3. 定义sql
2.4. 获取执行sql语句的对象 Statement
2.5. 执行sql，接受返回结果
2.6. 处理结果
2.7. 释放资源
* 代码实现流程：
//2.注册驱动
Class.forName("com.mysql.jdbc.Driver");
//3.获取数据库连接对象
Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/db3", "root", "root");
//4.定义sql语句
/*
sql 写的是SQL语句 字符串的格式
*/
String sql = "update account set balance = 500 where id = 1";
//5.获取执行sql的对象 Statement
Statement stmt = conn.createStatement();
//6.执行sql
int count = stmt.executeUpdate(sql);
//7.处理结果
System.out.println(count);
//8.释放资源
stmt.close();
conn.close();
package cn.jdbc;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;
public class jdbc {
public static void main(String[] args) throws Exception {
//加载驱动
Class.forName("com.mysql.jdbc.Driver");
//获得连接
//DriverManager.getConnection(url, user, password);
Connection conn =DriverManager.getConnection("jdbc:mysql://localhost:3306/web_test3", "root", "root");
//用 Connection 对象接受
//基本操作执行 SQL
// 3.基本操作：执行SQL
// 3.1获得执行SQL语句的对象
//Statement对象 通过连接对象 Connection获得
Statement statement = conn.createStatement();
// 3.2编写SQL语句:
String sql = "select * from user";
// 3.3执行SQL:
ResultSet rs = statement.executeQuery(sql);
//遍历结果集
while(rs.next()) {
System.out.print(rs.getInt("id")+" ");
System.out.print(rs.getString("username")+" ");
System.out.print(rs.getString("password")+" ");
System.out.print(rs.getString("nickname")+" ");
System.out.print(rs.getInt("age"));
System.out.println();
}
//释放资源
rs.close();
statement.close();
conn.close();
}
}
在工程项目中一般不会在这里有main方法 这样也就无法启动这个类 无法测试
那就使用 junit 来启动 这是测试方法 要额外多导入一个包
import org.junit.Test;
package cn.jdbc;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;
import org.junit.Test;
public class jdbcDemo001 {
//测试方法
@Test
public void demo1() throws Exception {
//加载驱动
Class.forName("com.mysql.jdbc.Driver");
//获得连接
//DriverManager.getConnection(url, user, password);
Connection conn =DriverManager.getConnection("jdbc:mysql://localhost:3306/web_test3", "root", "root");
//用 Connection 对象接受
// 3.基本操作：执行SQL
// 3.1获得执行SQL语句的对象
//Statement对象 通过连接对象 Connection获得
Statement statement = conn.createStatement();
// 3.2编写SQL语句:
String sql = "select * from user";
// 3.3执行SQL:
ResultSet rs = statement.executeQuery(sql);
//遍历结果集
while(rs.next()) {
System.out.print(rs.getInt("id")+" ");
System.out.print(rs.getString("username")+" ");
System.out.print(rs.getString("password")+" ");
System.out.print(rs.getString("nickname")+" ");
System.out.print(rs.getInt("age"));
//换行的作用
System.out.println();
}
//释放资源
rs.close();
statement.close();
conn.close();
}
}
-
对JDBC中各个接口和类详解
-
DriverManager：驱动管理对象
-
Connection：数据库连接对象
-
Statement：执行sql的对象
-
ResultSet：结果集对象,封装查询结果
-
PreparedStatement：执行sql的对象
3.1 DriverManager：驱动管理对象
* 功能：
1. 注册驱动：告诉程序该使用哪一个数据库驱动jar
static void registerDriver(Driver driver) :注册与给定的驱动程序 DriverManager 。
写代码使用： Class.forName(“com.mysql.jdbc.Driver”);
通过查看源码发现：在com.mysql.jdbc.Driver类中存在静态代码块
static {
try {
java.sql.DriverManager.registerDriver(new Driver());
} catch (SQLException E) {
throw new RuntimeException(“Can’t register driver!”);
}
}
注意：mysql5之后的驱动jar包可以省略注册驱动的步骤。
2. 获取数据库连接：
* 方法：static Connection getConnection(String url, String user, String password)
* 参数：
* url：指定连接的路径
* 语法：jdbc:mysql://ip地址(域名):端口号/数据库名称
ip找到是哪个计算机
端口可以找到是哪个软件
* 例子：jdbc:mysql://localhost:3306/db3
* 细节：如果连接的是本机mysql服务器，
并且mysql服务默认端口是3306，
则url可以简写为：jdbc:mysql:///数据库名称
* user：用户名
* password：密码
3.2 Connection：数据库连接对象
当前代码与数据库的桥梁
1. 功能：
1. 获取执行sql 的对象
* Statement createStatement()
* PreparedStatement prepareStatement(String sql)
2. 管理事务：
* 开启事务：setAutoCommit(boolean autoCommit) ：
调用该方法设置参数为false，即开启事务
* 提交事务：commit()
* 回滚事务：rollback()
3.3 Statement：执行sql的对象 ！！！！！！！！！！！！！！！！
1. 执行sql
1. boolean execute(String sql) ：可以执行任意的sql 了解一下 不需要掌握
返回一个boolean类型对象
2. int executeUpdate(String sql) ：需要掌握
执行DML（insert、update、delete）语句、
DDL(create，alter、drop)语句 不常用
* 返回值：影响的行数，可以通过这个影响的行数判断DML语句是否执行成功
影响行数
操作成功的行数
对一个数据表进行操作
一共有50行数据
更改符合条件数的数据
返回的 int类型的的数据有多少 就代表 更改了多少行
返回一个 int类型的值 这个值代表 影响行数
判断 这个语句是否执行成功
返回值>0的则执行成功，
反之，则失败。
3. ResultSet executeQuery(String sql) ： 需要掌握
执行DQL（select)语句 他的返回值是一个结果集对象 下面再讲解
代码验证 影响行数
package cn.jdbc;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement;
public class jdbcDemo002 {
public static void main(String[] args) {
Statement stmt = null;
Connection conn = null;
try {
//1. 注册驱动
Class.forName("com.mysql.jdbc.Driver");
//2. 定义sql
String sql = "insert into student(id,name,age,score,birthday) values(1,'AA',45,89.1,'1998-1-1');";
//3.获取Connection对象
conn = DriverManager.getConnection("jdbc:mysql:///testa1", "root", "root");
//4.获取执行sql的对象 Statement
stmt = conn.createStatement();
//5.执行sql
int count = stmt.executeUpdate(sql);
//影响的行数
//6.处理结果
System.out.println(count);
if(count > 0){
System.out.println("添加成功！");
}else{
System.out.println("添加失败！");
}
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (SQLException e) {
e.printStackTrace();
}finally {
//stmt.close();
//7. 释放资源
//避免空指针异常
if(stmt != null){
try {
stmt.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
if(conn != null){
try {
conn.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
}
}
- 练习：
增删改 练习
1. account表 添加一条记录
2. account表 修改记录
3. account表 删除一条记录
注意！！！！！！！！
写代码要规范
避免内存泄漏问题
异常处理模块 这个异常应该进行处理 而不是抛出
与以前的直接抛出异常的代码不一样
抓取异常 finally 是 无论前面出不出意外 都会执行
如果在 程序的 第5 步发生错误 程序将不再继续执行
那么最下面的 资源关闭将不会被执行
就回造成资源泄露 引起内存出问题
所以 使用 这种结构
try{
容易出错的位置
} catch (SQLException e) {
}finally {
无论如何都会被执行
}
- account表 添加一条记录
package cn.itcast.jdbc;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement;
/**
* account表 添加一条记录 insert 语句
*/
public class JDBCDemo2 {
public static void main(String[] args) {
//如果在 try{ } 里面定义 这两个对象 在 finally { } 里面获取不到
所以在一开始 就定义好
Statement stmt = null;
Connection conn = null;
try {
//1. 注册驱动
Class.forName("com.mysql.jdbc.Driver");
//2. 定义sql
String sql = "insert into account values(null,'王五',3000)";
//3.获取Connection对象
conn = DriverManager.getConnection("jdbc:mysql:///db3", "root", "root");
//4.获取执行sql的对象 Statement
stmt = conn.createStatement();
//5.执行sql
int count = stmt.executeUpdate(sql);//影响的行数
//6.处理结果
System.out.println(count);
if(count > 0){
System.out.println("添加成功！");
}else{
System.out.println("添加失败！");
}
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (SQLException e) {
e.printStackTrace();
}finally {
//stmt.close();
//7. 释放资源
/*
在一些情况下 执行不到 stmt语句 前面也会有错误
这样的话 stmt就成了空指针 没有创建资源
所以 stmt 要注意 空指针异常
*/
//避免空指针异常
if(stmt != null){
try {
stmt.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
if(conn != null){
try {
conn.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
}
}
- account表 修改记录
package cn.itcast.jdbc;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement;
/**
* account表 修改记录
*/
public class JDBCDemo3 {
public static void main(String[] args) {
Connection conn = null;
Statement stmt = null;
try {
//1. 注册驱动
Class.forName("com.mysql.jdbc.Driver");
//2.获取连接对象
conn = DriverManager.getConnection("jdbc:mysql:///db3", "root", "root");
//3.定义sql
String sql = "update user set age = 999 where id = 1";
//4.获取执行sql对象
stmt = conn.createStatement();
//5.执行sql
int count = stmt.executeUpdate(sql);
//6.处理结果
System.out.println(count);
if(count > 0){
System.out.println("修改成功！");
}else{
System.out.println("修改失败");
}
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (SQLException e) {
e.printStackTrace();
} finally {
//7.释放资源
if(stmt != null){
try {
stmt.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
if(conn != null){
try {
conn.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
}
}
- account表 删除一条记录
package cn.itcast.jdbc;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement;
/**
* account表 修改记录
*/
public class JDBCDemo4 {
public static void main(String[] args) {
Connection conn = null;
Statement stmt = null;
try {
//1. 注册驱动
Class.forName("com.mysql.jdbc.Driver");
//2.获取连接对象
conn = DriverManager.getConnection("jdbc:mysql:///db3", "root", "root");
//3.定义sql
String sql = "delete from user where id = 999";
//4.获取执行sql对象
stmt = conn.createStatement();
//5.执行sql
int count = stmt.executeUpdate(sql);
//6.处理结果
System.out.println(count);
if(count > 0){
System.out.println("删除成功！");
}else{
System.out.println("删除失败");
}
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (SQLException e) {
e.printStackTrace();
} finally {
//7.释放资源
if(stmt != null){
try {
stmt.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
if(conn != null){
try {
conn.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
}
}
- 执行 DDL 语句 创建表 的语句
- 这样是没有返回结果的 只会返回一个 0
package cn.itcast.jdbc;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement;
/**
* 执行 DDL 语句
* 这样是没有返回结果的 只会返回一个 0
*/
public class JDBCDemo5 {
public static void main(String[] args) {
Connection conn = null;
Statement stmt = null;
try {
//1. 注册驱动
Class.forName("com.mysql.jdbc.Driver");
//2.获取连接对象
conn = DriverManager.getConnection("jdbc:mysql:///db3", "root", "root");
//3.定义sql
System.out.println("AA");
String sql = "create table DBaa(id int,age int)";
//4.获取执行sql对象
stmt = conn.createStatement();
System.out.println("BB");
//5.执行sql
int count = stmt.executeUpdate(sql);
//6.处理结果
System.out.println(count);
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (SQLException e) {
e.printStackTrace();
} finally {
//7.释放资源
if(stmt != null){
try {
stmt.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
if(conn != null){
try {
conn.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
}
}
返回结果只有一个 0
3.4 ResultSet：结果集对象,封装查询结果
while(rs.next()) {
System.out.print(rs.getInt(“id”)+" “);
System.out.print(rs.getString(“username”)+” “);
System.out.print(rs.getString(“password”)+” “);
System.out.print(rs.getString(“nickname”)+” ");
System.out.print(rs.getInt(“age”));
//换行的作用
System.out.println();
}
* boolean next(): 游标向下移动一行，
判断当前行是否是最后一行末尾(是否有数据)，
如果是，则返回false，如果不是则返回true
* getXxx(参数):获取数据
* Xxx：代表数据类型 如： int getInt() , String getString()
* 参数： 有两种 可以按顺序 int 类型 也可以直接指出 列名
1. int：代表列的编号,从1开始
如： getString(1) 代表第1列的数据
getString(5) 代表第5列的数据
2. String：代表列名称。
如： getDouble(“balance”)
代表 列名为 balance 的数据
* 注意：
* 使用步骤：
1. 游标向下移动一行
2. 判断是否有数据
3. 获取数据
//循环判断游标是否是最后一行末尾。
while(rs.next()){
//获取数据
//6.2 获取数据
int id = rs.getInt(1);
String name = rs.getString("name");
double balance = rs.getDouble(3);
System.out.println(id + "---" + name + "---" + balance);
}
package cn.itcast.jdbc;
import java.sql.*;
/**
* 执行DDL语句
*/
public class JDBCDemo6 {
public static void main(String[] args) {
Connection conn = null;
Statement stmt = null;
ResultSet rs = null;
try {
//1. 注册驱动
Class.forName("com.mysql.jdbc.Driver");
//2.获取连接对象
conn = DriverManager.getConnection("jdbc:mysql:///db3", "root", "root");
//3.定义sql
String sql = "select * from user";
//4.获取执行sql对象
stmt = conn.createStatement();
//5.执行sql
rs = stmt.executeQuery(sql);
//6.处理结果
//因为原来游标 是在标题行 标题行没数据
//6.1 让游标向下移动一行 移动到数据行
rs.next();
//6.2 获取数据
//获取第一行
int id = rs.getInt(1);
String name = rs.getString("username");
String password = rs.getString("password");
System.out.println(id + "---" + name + "---" + password);
//6.1 让游标向下移动一行
rs.next();
//6.2 获取数据
int id2 = rs.getInt(1);
String name2 = rs.getString("username");
String password2 = rs.getString("password");
System.out.println(id2 + "---" + name2 + "---" + password2);
//6.1 让游标向下移动一行
rs.next();
//6.2 获取数据
int id3 = rs.getInt(1);
String name3 = rs.getString("username");
String password3 = rs.getString("password");
System.out.println(id3 + "---" + name3 + "---" + password3);
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (SQLException e) {
e.printStackTrace();
} finally {
//7.释放资源
if(rs != null){
try {
rs.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
if(stmt != null){
try {
stmt.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
if(conn != null){
try {
conn.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
}
}
使用while循环的 结构 输出所有的数据
使用 next() 来判断是否到达 行和列的末尾 如果超了会报错
package cn.itcast.jdbc;
import java.sql.*;
/**
-
执行DDL语句
*/
public class JDBCDemo7 {
public static void main(String[] args) {
Connection conn = null;
Statement stmt = null;
ResultSet rs = null;
try {
//1. 注册驱动
Class.forName(“com.mysql.jdbc.Driver”);
//2.获取连接对象
conn = DriverManager.getConnection(“jdbc:mysql:///db3”, “root”, “root”);
//3.定义sql
String sql = “select * from account”;
//4.获取执行sql对象
stmt = conn.createStatement();
//5.执行sql
rs = stmt.executeQuery(sql);//6.处理结果 //循环判断游标是否是最后一行末尾。 while(rs.next()){ //获取数据 //6.2 获取数据 int id = rs.getInt(1); String name = rs.getString("name"); double balance = rs.getDouble(3); System.out.println(id + "---" + name + "---" + balance); } /* //6.1 让游标向下移动一行 //添加 if 判断 只能解决 超出次数后 不会报错 还是不能解决 ！！！！！！！！！！！！！！！！ //未知次数下 数据输出的问题 if(rs.next()){ //判断是否有数据 //6.2 获取数据 int id = rs.getInt(1); String name = rs.getString("name"); double balance = rs.getDouble(3); System.out.println(id + "---" + name + "---" + balance); } //6.1 让游标向下移动一行 if(rs.next()){ //判断是否有数据 //6.2 获取数据 int id = rs.getInt(1); String name = rs.getString("name"); double balance = rs.getDouble(3); System.out.println(id + "---" + name + "---" + balance); } //6.1 让游标向下移动一行 if(rs.next()){ //判断是否有数据 //6.2 获取数据 int id = rs.getInt(1); String name = rs.getString("name"); double balance = rs.getDouble(3); System.out.println(id + "---" + name + "---" + balance); } //6.1 让游标向下移动一行 if(rs.next()){ //判断是否有数据 //6.2 获取数据 int id = rs.getInt(1); String name = rs.getString("name"); double balance = rs.getDouble(3); System.out.println(id + "---" + name + "---" + balance); } */ /* //6.1 让游标向下移动一行 这种方法 游标下一次数多了 会报错！！！！！！！！！！！！！！！！！！！1 rs.next(); //6.2 获取数据 int id2 = rs.getInt(1); String name2 = rs.getString("name"); double balance2 = rs.getDouble(3); System.out.println(id2 + "---" + name2 + "---" + balance2); //6.1 让游标向下移动一行 rs.next(); //6.2 获取数据 int id3 = rs.getInt(1); String name3 = rs.getString("name"); double balance3 = rs.getDouble(3); System.out.println(id3 + "---" + name3 + "---" + balance3); */ } catch (ClassNotFoundException e) { e.printStackTrace(); } catch (SQLException e) { e.printStackTrace(); } finally { //7.释放资源 if(rs != null){ try { rs.close(); } catch (SQLException e) { e.printStackTrace(); } } if(stmt != null){ try { stmt.close(); } catch (SQLException e) { e.printStackTrace(); } } if(conn != null){ try { conn.close(); } catch (SQLException e) { e.printStackTrace(); } } }}
}
练习 查询
需求
定义一个方法 查询emp表的数据 将其封装成对象 然后装载集合 返回
1.定义一个类 Emp 类
2.定义一个方法 pubilc List findALL()
3.实现方法 select * from emp;
每查出来一条记录 就会new 一个emp对象
然后封装进 emp对象中
然后把emp对象添加到集合中
emp 类
package cn.itcast.domain;
import java.util.Date;
/*
实体类
用于封装 emp的javaBean
* */
public class Emp {
private int id;
private String ename;
private int job_id;
private int mgr;
private Date joindate;
private double salary;
private double bonus;
private int dept_id;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getEname() {
return ename;
}
public void setEname(String ename) {
this.ename = ename;
}
public int getJob_id() {
return job_id;
}
public void setJob_id(int job_id) {
this.job_id = job_id;
}
public int getMgr() {
return mgr;
}
public void setMgr(int mgr) {
this.mgr = mgr;
}
public Date getJoindate() {
return joindate;
}
public void setJoindate(Date joindate) {
this.joindate = joindate;
}
public double getSalary() {
return salary;
}
public void setSalary(double salary) {
this.salary = salary;
}
public double getBonus() {
return bonus;
}
public void setBonus(double bonus) {
this.bonus = bonus;
}
public int getDept_id() {
return dept_id;
}
public void setDept_id(int dept_id) {
this.dept_id = dept_id;
}
@Override
public String toString() {
return "\n "+
"Emp [" + "\n "
+ "id =" + id + "\n "
+ "ename =" + ename + "\n "
+ "job_id =" + job_id + "\n "
+ "mgr =" + mgr + "\n "
+ "joindate =" + joindate+ "\n "
+ "salary =" + salary + "\n "
+ "bonus =" + bonus + "\n "
+ "dept_id =" + dept_id + "\n "
+ "]"+"\n ";
}
}
JDBC实现类 对数据库进行操作
package cn.itcast.jdbc;
import cn.itcast.domain.Emp;
import cn.itcast.util.JDBCUtils;
import java.sql.*;
import java.util.ArrayList;
import java.util.List;
/**
* * 定义一个方法，查询emp表的数据将其封装为对象，然后装载集合，返回。
*/
public class JDBCDemo8 {
public static void main(String[] args) {
//创建一个集合 用来接收 findAll 方法 返回的数据
List<Emp> list = new JDBCDemo8().findAll();
//输出集合的所有数据
System.out.println(list);
System.out.println(list.size());
}
/**
* 查询所有emp对象
* @return
*/
public List<Emp> findAll(){
//变量抽取
Connection conn = null;
Statement stmt = null;
ResultSet rs = null;
List<Emp> list = null;
try {
//1.注册驱动
Class.forName("com.mysql.jdbc.Driver");
//2.获取连接
conn = DriverManager.getConnection("jdbc:mysql:///db3", "root", "root");
//3.定义sql
//查询所有 emp表的数据
String sql = "select * from emp";
//4.获取执行sql的对象
stmt = conn.createStatement();
//5.执行sql
rs = stmt.executeQuery(sql);
//6.遍历结果集，封装对象，装载集合
Emp emp = null;
list = new ArrayList<Emp>();
//遍历数据
while(rs.next()){
//获取数据
int id = rs.getInt("id");
String ename = rs.getString("ename");
int job_id = rs.getInt("job_id");
int mgr = rs.getInt("mgr");
Date joindate = rs.getDate("joindate");
double salary = rs.getDouble("salary");
double bonus = rs.getDouble("bonus");
int dept_id = rs.getInt("dept_id");
// 创建emp对象,并赋值
emp = new Emp();
emp.setId(id);
emp.setEname(ename);
emp.setJob_id(job_id);
emp.setMgr(mgr);
emp.setJoindate(joindate);
emp.setSalary(salary);
emp.setBonus(bonus);
emp.setDept_id(dept_id);
/*
把emp对象装载进集合中
*/
list.add(emp);
}
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (SQLException e) {
e.printStackTrace();
}finally {
if(rs != null){
try {
rs.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
if(stmt != null){
try {
stmt.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
if(conn != null){
try {
conn.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
return list;
}
}
在上面的代码中 有很多重复的操作
JDBC
每次都要
注册驱动
获取连接
释放 资源
抽取JDBC工具类 ： JDBCUtils
* 目的：简化书写
* 分析：
那一段代码 重复性高 就抽取哪一个
1. 注册驱动也抽取
注册驱动不会 写一个方法 写一个 类 这样也很麻烦 需要每次都写
所以
2. 抽取一个方法获取连接对象
* 需求：不想传递参数（麻烦），还得保证工具类的通用性。
* 解决：配置文件
jdbc.properties
url=
user=
password=
3. 抽取一个方法释放资源
抽取JDBC工具类 ： JDBCUtils 的方法 来简化代码
JDBCUtils 就是 JDBC的工具类
这个工具类里面至少要有两个方法
抽取 获取连接
释放资源
在这里插入代码片
package cn.itcast.util;
import java.io.FileReader;
import java.io.IOException;
import java.net.URL;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Properties;
/**
-
JDBC工具类
工具类都有一个特点
那就是 方法应该是静态的
方便我们去调用
返回类型前面 加一个
static
*/
public class JDBCUtils {
///*
- 获取连接
- 返回的是 连接对象
- */
/*
public static Connection getConnection() throws SQLException {//获取连接的方法 不管怎么获取 // 都是通过 Driver // 应该返回一个 DriverManager.getConnection return DriverManager.getConnection("jdbc:mysql:///db3", "root", "root"); //但是这样写 与 在 JDBCDemo8 里面直接写 没啥区别 //没必要在写这个工具类 //每次调用工具类的这个方法 都是返回 上面 这条语句 里面的 DB3 数据库的连接对象 //将来我们有很多的数据库 更换数据库 很麻烦 //需要更改这个 代码 //造成了 工具类不通用的情况 字符串不能写死}
*/
/*
//改进方法 将上面方法加入 传输参数public static Connection getConnection(String url,String user,String password) throws SQLException {
return DriverManager.getConnection(url,user,password);}
//在JDBCDemo8 这个实现类中 这样调用更麻烦
//conn = DriverManager.getConnection(“jdbc:mysql:///db3”, “root”, “root”);还不如不抽取
- */
/*
实现不传参
还能实现动态的效果以后很常用的一个方法
使用配置文件的方式定义一个jdbc.properties 的配置文件
里面写
url=
user=
password=将来只要 读取配置文件 就可以拿到这几个参数 将来参数发生变化 我们只要在配置文件中修改就行代码不用修改 位置放到 src目录下面就行 配置文件 url=jdbc:mysql:///db3 user=root password=root driver=com.mysql.jdbc.Driver Driver里面也写了 将来如果使用别的数据库 更改Driver就行 文件的读取 操作 干一次就行 拿到这些值 如何让文件读取只操作一次 如果放到 getConnection里面 getConnection每次调用都会 让文件读取 操作一遍特别麻烦 影响效率 使用静态代码块 来实现- */
private static String url;
private static String user;
private static String password;
private static String driver;/*
// 2.0 获取连接
这里定义的是 static定义的静态变量
因为 只有静态变量 才能被静态代码块访问
才能被静态方法 访问- */
static {
// 1.0 获取连接
//读取资源文件
//读取出来的三个变量需要能影想到 getConnection方法中
//那么 就应该把这三个变量 写到 这个类的开头
//声明三个成员变量try { //1. 创建Properties集合类。 Properties pro = new Properties(); //2.加载文件 //pro.load(new FileReader("src/jdbc.properties")); //这样写 会报错 路径不对 //解决方法 写绝对路径 //pro.load(new FileReader("E:\\About_Java\\EcilpseWordspace\\workspaceEcilpse001\\JDBCDemo001\\src\\src\\jdbc.properties")); //绝对路径 更不合理 不符合工具类要求 //获取src路径下文件的方式 有一个 类 // ClassLoader 类加载器 可以加载字节码文件 进入内存 //而且可以获取 src下的 资源文件的路径！！！！！！！！！！！！！！！ //要获取ClassLoader 首先要获取对应的字节码文件对象 //随便一个都可以 //比如说 JDBCUtils 这个 暂时 使用这个 当例子 //JDBCUtils.class 类名.class 获得类名对象 //类名对象 .getClassLoader(); 获得 classLoader 对象 ClassLoader classLoader = JDBCUtils.class.getClassLoader(); //classLoader对象有一个方法 getResource("jdbc.properties"); //传一个文件名 就可以 获取 这个文件的的绝对位置 URL res = classLoader.getResource("jdbc.properties"); //但是 返回的是一个 URL对象 //使用getPath();方法 转为 String类型 String path = res.getPath(); //加载文件 pro.load(new FileReader(path)); //3. 获取数据，赋值 url = pro.getProperty("url"); user = pro.getProperty("user"); password = pro.getProperty("password"); driver = pro.getProperty("driver"); //4. 注册驱动 Class.forName(driver); } catch (IOException e) { e.printStackTrace(); } catch (ClassNotFoundException e) { e.printStackTrace(); }}
/**
-
获取连接
-
@return 连接对象
*/
public static Connection getConnection() throws SQLException {return DriverManager.getConnection(url, user, password);
}
/*
- 释放资源的方法
- 不需要返回值
- 释放谁 就要告诉 释放资源这个方法 释放的是哪个
- 传什么参数 就释放谁
- 释放资源有两种情况
一种是 执行增删改的时候
需要释放
Statement stmt,Connection conn -
这两种情况 - 另一种是 执行查询的时候
-
需要释放 -
ResultSet rs,Statement stmt, Connection conn -
这三种 - 利用重载的机制
- 先写 释放两个的 再写释放三个的
- */
/**
-
释放资源
-
@param stmt
-
@param conn
*/
public static void close(Statement stmt,Connection conn){
if( stmt != null){
try {
stmt.close();
} catch (SQLException e) {
e.printStackTrace();
}
}if( conn != null){
try {
conn.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
/**
-
释放资源
-
@param stmt
-
@param conn
*/
public static void close(ResultSet rs,Statement stmt, Connection conn){
if( rs != null){
try {
rs.close();
} catch (SQLException e) {
e.printStackTrace();
}
}if( stmt != null){
try {
stmt.close();
} catch (SQLException e) {
e.printStackTrace();
}
}if( conn != null){
try {
conn.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
}
配置文件
url=jdbc:mysql:///db3
user=root
password=root
driver=com.mysql.jdbc.Driver
对数据处理的类
package cn.itcast.jdbc;
import cn.itcast.domain.Emp;
import cn.itcast.util.JDBCUtils;
import java.sql.*;
import java.util.ArrayList;
import java.util.List;
/**
-
-
定义一个方法，查询emp表的数据将其封装为对象，然后装载集合，返回。
*/
public class JDBCDemo8 {
public static void main(String[] args) throws Exception {List list = new JDBCDemo8().findAll2();
System.out.println(list);
System.out.println(list.size());
}
/**
-
演示JDBC工具类
-
@return
-
@throws ClassNotFoundException
*/
public List findAll2() throws ClassNotFoundException{Connection conn = null;
Statement stmt = null;
ResultSet rs = null;
List list = null;try {
//使用JDBCUtils工具类 conn = JDBCUtils.getConnection(); //3.定义sql String sql = "select * from emp"; //4.获取执行sql的对象 stmt = conn.createStatement(); //5.执行sql rs = stmt.executeQuery(sql); //6.遍历结果集，封装对象，装载集合 Emp emp = null; list = new ArrayList<Emp>(); while(rs.next()){ //获取数据 int id = rs.getInt("id"); String ename = rs.getString("ename"); int job_id = rs.getInt("job_id"); int mgr = rs.getInt("mgr"); Date joindate = rs.getDate("joindate"); double salary = rs.getDouble("salary"); double bonus = rs.getDouble("bonus"); int dept_id = rs.getInt("dept_id"); // 创建emp对象,并赋值 emp = new Emp(); emp.setId(id); emp.setEname(ename); emp.setJob_id(job_id); emp.setMgr(mgr); emp.setJoindate(joindate); emp.setSalary(salary); emp.setBonus(bonus); emp.setDept_id(dept_id); //装载集合 list.add(emp); }} catch (SQLException e) {
e.printStackTrace();
}finally {//释放资源被简化 /*if(rs != null){ try { rs.close(); } catch (SQLException e) { e.printStackTrace(); } } if(stmt != null){ try { stmt.close(); } catch (SQLException e) { e.printStackTrace(); } } if(conn != null){ try { conn.close(); } catch (SQLException e) { e.printStackTrace(); } }*/ JDBCUtils.close(rs,stmt,conn);}
return list;
}
}
-
练习 登录练习
* 需求：
1. 通过键盘录入用户名和密码
2. 判断用户是否登录成功
* select * from user where username = "" and password = "";
* 如果这个sql有查询结果，则成功，反之，则失败
* 步骤：
1. 创建数据库
创建数据表
添加数据
创建数据库
create database db4;
创建数据表
create table user( id int primary key auto_increment , username varchar(32), password varchar(32) );
查询所有数据
select * from user ;
插入数据
insert into user values(null,‘zhangsan’,‘123’);
insert into user values(null,‘xiaoming’,‘123’);
insert into user values(null,‘lisi’,‘123’);
insert into user values(null,‘aaaa’,‘123’);
JDBCDemo9来连接数据库 进行处理
package cn.itcast.jdbc;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Scanner;
import cn.itcast.util.JDBCUtils;
/**
练习：
需求：
1. 通过键盘录入用户名和密码
2. 判断用户是否登录成功
*/
public class JDBCDemo9 {
//主方法
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
System.out.println("请输入账号");
String username =sc.next();
System.out.println("请输入密码");
String password =sc.next();
//2.调用方法
boolean flag = new JDBCDemo9().login(username, password);
//3.判断结果，输出不同语句
if(flag){
//登录成功
System.out.println("登录成功！");
}else{
System.out.println("用户名或密码错误！");
}
}
/*
登录方法
要返回值
要参数值 键盘录入进来的
* */
public boolean login(String username,String password) {
//判断输入的是否为空 为空直接返回false 结束
if(username==null || password==null) {
return false;
}
//连接数据库判断是否登录成功
Connection conn = null;
Statement stmt = null;
ResultSet rs = null;
try {
//1.获取连接
conn=JDBCUtils.getConnection();
//2.定义 SQL
String sql="select * from user where username = '"+username+"' and password ='"+password+"'";
//3.获取执行sql的对象
stmt = conn.createStatement();
//4.执行查询
rs = stmt.executeQuery(sql);
//5.判断 这里只需要判断数据集有没有对象就可以了
/*
//如果有下一行，则返回true
if(rs.next()){
return true;
}else{
return false;
}
rs.next() 本来返回的就是 true false 值
*/
//如果有下一行，则返回true
return rs.next();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return false;
}
}
使用了 抽取工具类的方法 配置文件放在
url=jdbc:mysql:///db4
user=root
password=root
driver=com.mysql.jdbc.Driver
工具类 JDBCUtils 修改数据库 更换数据库 不需要改动 JDBCDemo9 还有 JDBCUtils 这两个地方
package cn.itcast.util;
import java.io.FileReader;
import java.io.IOException;
import java.net.URL;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Properties;
/**
-
JDBC工具类
工具类都有一个特点
那就是 方法应该是静态的
方便我们去调用
返回类型前面 加一个
static
*/
public class JDBCUtils {
///*
- 获取连接
- 返回的是 连接对象
- */
/*
public static Connection getConnection() throws SQLException {//获取连接的方法 不管怎么获取 // 都是通过 Driver // 应该返回一个 DriverManager.getConnection return DriverManager.getConnection("jdbc:mysql:///db3", "root", "root"); //但是这样写 与 在 JDBCDemo8 里面直接写 没啥区别 //没必要在写这个工具类 //每次调用工具类的这个方法 都是返回 上面 这条语句 里面的 DB3 数据库的连接对象 //将来我们有很多的数据库 更换数据库 很麻烦 //需要更改这个 代码 //造成了 工具类不通用的情况 字符串不能写死}
*/
/*
//改进方法 将上面方法加入 传输参数public static Connection getConnection(String url,String user,String password) throws SQLException {
return DriverManager.getConnection(url,user,password);}
//在JDBCDemo8 这个实现类中 这样调用更麻烦
//conn = DriverManager.getConnection(“jdbc:mysql:///db3”, “root”, “root”);还不如不抽取
- */
/*
实现不传参
还能实现动态的效果以后很常用的一个方法
使用配置文件的方式定义一个jdbc.properties 的配置文件
里面写
url=
user=
password=将来只要 读取配置文件 就可以拿到这几个参数 将来参数发生变化 我们只要在配置文件中修改就行代码不用修改 位置放到 src目录下面就行 配置文件 url=jdbc:mysql:///db3 user=root password=root driver=com.mysql.jdbc.Driver Driver里面也写了 将来如果使用别的数据库 更改Driver就行 文件的读取 操作 干一次就行 拿到这些值 如何让文件读取只操作一次 如果放到 getConnection里面 getConnection每次调用都会 让文件读取 操作一遍特别麻烦 影响效率 使用静态代码块 来实现- */
private static String url;
private static String user;
private static String password;
private static String driver;/*
// 2.0 获取连接
这里定义的是 static定义的静态变量
因为 只有静态变量 才能被静态代码块访问
才能被静态方法 访问- */
static {
// 1.0 获取连接
//读取资源文件
//读取出来的三个变量需要能影想到 getConnection方法中
//那么 就应该把这三个变量 写到 这个类的开头
//声明三个成员变量try { //1. 创建Properties集合类。 Properties pro = new Properties(); //2.加载文件 //pro.load(new FileReader("src/jdbc.properties")); //这样写 会报错 路径不对 //解决方法 写绝对路径 //pro.load(new FileReader("E:\\About_Java\\EcilpseWordspace\\workspaceEcilpse001\\JDBCDemo001\\src\\src\\jdbc.properties")); //绝对路径 更不合理 不符合工具类要求 //获取src路径下文件的方式 有一个 类 // ClassLoader 类加载器 可以加载字节码文件 进入内存 //而且可以获取 src下的 资源文件的路径！！！！！！！！！！！！！！！ //要获取ClassLoader 首先要获取对应的字节码文件对象 //随便一个都可以 //比如说 JDBCUtils 这个 暂时 使用这个 当例子 //JDBCUtils.class 类名.class 获得类名对象 //类名对象 .getClassLoader(); 获得 classLoader 对象 ClassLoader classLoader = JDBCUtils.class.getClassLoader(); //classLoader对象有一个方法 getResource("jdbc.properties"); //传一个文件名 就可以 获取 这个文件的的绝对位置 URL res = classLoader.getResource("jdbc.properties"); //但是 返回的是一个 URL对象 //使用getPath();方法 转为 String类型 String path = res.getPath(); //加载文件 pro.load(new FileReader(path)); //3. 获取数据，赋值 url = pro.getProperty("url"); user = pro.getProperty("user"); password = pro.getProperty("password"); driver = pro.getProperty("driver"); //4. 注册驱动 Class.forName(driver); } catch (IOException e) { e.printStackTrace(); } catch (ClassNotFoundException e) { e.printStackTrace(); }}
/**
-
获取连接
-
@return 连接对象
*/
public static Connection getConnection() throws SQLException {return DriverManager.getConnection(url, user, password);
}
/*
- 释放资源的方法
- 不需要返回值
- 释放谁 就要告诉 释放资源这个方法 释放的是哪个
- 传什么参数 就释放谁
- 释放资源有两种情况
一种是 执行增删改的时候
需要释放
Statement stmt,Connection conn -
这两种情况 - 另一种是 执行查询的时候
-
需要释放 -
ResultSet rs,Statement stmt, Connection conn -
这三种 - 利用重载的机制
- 先写 释放两个的 再写释放三个的
- */
/**
-
释放资源
-
@param stmt
-
@param conn
*/
public static void close(Statement stmt,Connection conn){
if( stmt != null){
try {
stmt.close();
} catch (SQLException e) {
e.printStackTrace();
}
}if( conn != null){
try {
conn.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
/**
-
释放资源
-
@param stmt
-
@param conn
*/
public static void close(ResultSet rs,Statement stmt, Connection conn){
if( rs != null){
try {
rs.close();
} catch (SQLException e) {
e.printStackTrace();
}
}if( stmt != null){
try {
stmt.close();
} catch (SQLException e) {
e.printStackTrace();
}
}if( conn != null){
try {
conn.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
}
3.5 PreparedStatement：执行sql的对象
1. SQL注入问题：在拼接sql时，有一些sql的特殊关键字参与字符串的拼接。会造成安全性问题
1. 输入用户名 随便 输入一个 数据库没有的，输入密码：a' or 'a' = 'a
2. sql：select * from user where username = 'fhdsjkf' and password = 'a' or 'a' = 'a'
打印出来实际使用的 SQL语句
and password = ‘a’ or ‘a’ = ‘a’
or ‘a’ = ‘a’ 这就是恒等式
2. 解决sql注入问题：使用PreparedStatement对象来解决
Statement 静态SQL 使用的是 拼接好的 字符串
预编译SQL不会产生这个问题
3. 预编译的SQL：参数使用?作为占位符
4. 步骤：
1. 导入驱动jar包 mysql-connector-java-5.1.37-bin.jar
2. 注册驱动
3. 获取数据库连接对象 Connection
4. 定义sql
* 注意：sql的参数使用 ？作为占位符。
如：select * from user where username = ? and password = ?;
5. 获取执行sql语句的对象 PreparedStatement Connection.prepareStatement(String sql)
6. 给？赋值：
* 方法： setXxx(参数1,参数2)
* 参数1：？的位置编号 从1 开始
* 参数2：？的值
7. 执行sql，接受返回结果，不需要传递sql语句
8. 处理结果
9. 释放资源
5. 注意：后期都会使用PreparedStatement来完成增删改查的所有操作
1. 可以防止SQL注入
2. 效率更高
使用PreparedStatement防止 SQL注入
package cn.itcast.jdbc;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Scanner;
import cn.itcast.util.JDBCUtils;
/**
练习：
需求：
1. 通过键盘录入用户名和密码
2. 判断用户是否登录成功
*/
public class JDBCDemo9_2 {
//主方法
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
System.out.println("请输入账号");
String username =sc.next();
System.out.println("请输入密码");
String password =sc.next();
//2.调用方法
boolean flag = new JDBCDemo9_2().login2(username, password);
//3.判断结果，输出不同语句
if(flag){
//登录成功
System.out.println("登录成功！");
}else{
System.out.println("用户名或密码错误！");
}
}
/*
登录方法
要返回值
要参数值 键盘录入进来的
* */
/**
* 登录方法,使用PreparedStatement实现
*/
public boolean login2(String username ,String password){
if(username == null || password == null){
return false;
}
//连接数据库判断是否登录成功
Connection conn = null;
PreparedStatement pstmt = null;
ResultSet rs = null;
//1.获取连接
try {
conn = JDBCUtils.getConnection();
//2.定义sql
String sql = "select * from user where username = ? and password = ?";
//3.获取执行sql的对象
pstmt = conn.prepareStatement(sql);
//给?赋值
pstmt.setString(1,username);
pstmt.setString(2,password);
//4.执行查询,不需要传递sql
rs = pstmt.executeQuery();
//5.判断
return rs.next();//如果有下一行，则返回true
} catch (SQLException e) {
e.printStackTrace();
}finally {
JDBCUtils.close(rs,pstmt,conn);
}
return false;
}
}
- JDBC控制事务：
数据库 db4
数据表 account
1. 事务：一个包含多个步骤的业务操作。
如果这个业务操作被事务管理，
则这多个步骤要么同时成功，要么同时失败。
2. 操作：
1. 开启事务
2. 提交事务
3. 回滚事务
3. 使用Connection对象来管理事务
* 开启事务：setAutoCommit(boolean autoCommit) ：调用该方法设置参数为false，即开启事务
* 在执行sql之前开启事务
* 提交事务：commit()
* 当所有sql都执行完提交事务
* 回滚事务：rollback()
* 在catch中回滚事务
需求建一个操作类 让 AA的钱转到 BB
转账的案例 不出错的情况下
执行完这个案例
数据库中 两个人的账户
A会减少 500
B会增加 500
package cn.itcast.jdbc;
import cn.itcast.util.JDBCUtils;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;
/**
事务操作
*/
public class JDBCDemo10 {
public static void main(String[] args) {
Connection conn = null;
PreparedStatement pstmt1 = null;
PreparedStatement pstmt2 = null;
try {
//1.获取连接
conn = JDBCUtils.getConnection();
//2.定义sql
//2.1 张三 - 500
String sql1 = "update account set balance = balance - ? where id = ?";
//2.2 李四 + 500
String sql2 = "update account set balance = balance + ? where id = ?";
/*
update 表名 set 列名1 = 值1, 列名2 = 值2,... [where 条件];
update account set balance = balance - ? where id = ?
update 更新数据
account 表名
balance = balance - ?
balance 列名
balance - ? 数值 其中 ?代表占位符
where id = ?
where 条件筛选
id = ? id代表 使用id这个列筛选
*/
//3.获取执行sql对象
pstmt1 = conn.prepareStatement(sql1);
pstmt2 = conn.prepareStatement(sql2);
//4. 设置参数
/*
pstmt1.setDouble(1,500);
1 是代表 pstmt1对象的 第一个参数 ?
500 是 传入的数据
setDouble 代表的是 传入数值的类型
*/
pstmt1.setDouble(1,500);
pstmt1.setInt(2,1);
pstmt2.setDouble(1,500);
pstmt2.setInt(2,2);
//5.执行sql
pstmt1.executeUpdate();
pstmt2.executeUpdate();
} catch (Exception e) {
//事务回滚
/*
只要出现任何异常
都会回到开始事务的状态
*/
e.printStackTrace();
}finally {
JDBCUtils.close(pstmt1,conn);
JDBCUtils.close(pstmt2,null);
}
}
}
我们在 执行 SQL过程中 添加一个异常
只有一个 SQL能顺利执行
异常下面的不再继续执行
那么 B的账户 不会增加 500
只有 A的账户 减少 500
这样总账对不上
所以需要添加事务管理
package cn.itcast.jdbc;
import cn.itcast.util.JDBCUtils;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;
/**
事务操作
*/
public class JDBCDemo10 {
public static void main(String[] args) {
Connection conn = null;
PreparedStatement pstmt1 = null;
PreparedStatement pstmt2 = null;
try {
//1.获取连接
conn = JDBCUtils.getConnection();
// //开启事务
conn.setAutoCommit(false);
//2.定义sql
//2.1 张三 - 500
String sql1 = "update account set balance = balance - ? where id = ?";
//2.2 李四 + 500
String sql2 = "update account set balance = balance + ? where id = ?";
/*
update 表名 set 列名1 = 值1, 列名2 = 值2,... [where 条件];
update account set balance = balance - ? where id = ?
update 更新数据
account 表名
balance = balance - ?
balance 列名
balance - ? 数值 其中 ?代表占位符
where id = ?
where 条件筛选
id = ? id代表 使用id这个列筛选
*/
//3.获取执行sql对象
pstmt1 = conn.prepareStatement(sql1);
pstmt2 = conn.prepareStatement(sql2);
//4. 设置参数
/*
pstmt1.setDouble(1,500);
1 是代表 pstmt1对象的 第一个参数 ?
500 是 传入的数据
setDouble 代表的是 传入数值的类型
*/
pstmt1.setDouble(1,500);
pstmt1.setInt(2,1);
pstmt2.setDouble(1,500);
pstmt2.setInt(2,2);
//5.执行sql
pstmt1.executeUpdate();
// 手动制造异常！！！！！！！！！！！！！！！！！
int i = 3/0;
pstmt2.executeUpdate();
// //提交事务
conn.commit();
} catch (Exception e) {
//事务回滚
/*
只要出现任何异常
都会回到开始事务的状态
*/
try {
if(conn != null) {
conn.rollback();
}
} catch (SQLException e1) {
e1.printStackTrace();
}
e.printStackTrace();
}finally {
JDBCUtils.close(pstmt1,conn);
JDBCUtils.close(pstmt2,null);
}
}
}
5535
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
