第一节 概念
JDBC:Java DataBase Connectivity Java数据库连接,Java语言操作数据库
JDBC本质:官方定义了一套操作所有关系型数据库的规则(接口),各个数据库厂商去实现这套接口,提供数据库驱动jar包,我们可以使用这套接口(JDBC)编程,真正执行的代码是驱动jar包中的实现类
快速入门步骤:
1、导入驱动jar包
2、注册驱动
3、获取数据库连接对象Connection
4、定义sql
5、获取执行sql语句的对象Statement
6、执行sql,接收返回结果
7、处理结果
8、释放资源
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.Statement;
public class Demo01Jdbc {
public static void main(String[] args) throws Exception {
//1、导入驱动jar包
//2、注册驱动
Class.forName("com.mysql.jdbc.Driver");
//3、获取数据库连接对象
Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3305/db1", "root", "root");
//4、定义sql语句
String sql = "update account set balance = 500 where id = 1";
//5、获取执行sql的对象Statement
Statement statement = conn.createStatement();
//6、执行sql
int count = statement.executeUpdate(sql);
//7、处理结果
System.out.println(count);
//8、释放资源
statement.close();
conn.close();
}
}
第二节 各个对象
2.1 DriverManager
驱动管理对象
功能:
1、注册驱动 :告诉程序该使用哪一个数据库驱动jar
static void registerDriver(Driver driver):注册与给定的驱动 程序DriverManager
写代码使用:Class.forName(“com.mysql.jdbc.Driver”);
查看源码发现在com.mysql.jdbc.Driver类中存在静态代码块
注意:MySQL5之后的驱动jar包可以省略注册驱动的步骤
2、获取数据库连接
方法:static Connection getConnection(String url,String user, String password)
参数:
url:指定连接的路径
语法:jdbc:mysql://ip地址(域名):端口号/数据库名称
user:用户名
password:密码
2.2 Connection
数据库连接对象
功能:
1、获取执行sql的对象
Statement createStatement()
PreparedStatement prepareStatement(String sql)
2、管理事务
开启事务
set AutoCommit(boolean autoCommit):调用该方法设置参数为false,即开始事务
提交事务
commit()
回滚事务
rollback()
2.3 Statement
执行sql的对象
boolean execute(String sql):可以执行任意的sql
int executeUpdate(String sql):执行DML语句、DDL语句,返回值:影响的行数,通过影响的行数判断DML语句是否执行成功,返回值>0的则执行成功
ResultSet executeQuery(String sql):执行DQL语句
//account表 添加一条记录 insert语句
public class Demo02Jdbc {
public static void main(String[] args) {
Connection conn = null;
Statement stmt = 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:///db1", "root", "lb5214993");
//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 throwables) {
throwables.printStackTrace();
} finally {
//stmt.close();
//避免空指针异常
if (stmt != null){
try {
stmt.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
if (conn != null){
try {
conn.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
}
}
//account表 修改一条记录
//3、定义sql
String sql = "update account set balance = 1500 where id = 3";
//account表 删除一条记录
//3、定义sql
String sql = "delete from account where id = 3";
//创建student表
String sql = "create table student (id int, name varchar (20))";
2.4 ResultSet
结果集对象,封装查询结果
next():游标向下移动一行
getXxx(参数):获取数据,Xxx代表数据类型;参数:int代表列的编号,从1开始,String代表列名称
//基本使用,不推荐!
public class Demo06Jdbc {
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:///db1", "root", "lb5214993");
//3、定义sql
String sql = "select * from account";
//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("name");
double balance = rs.getDouble(3);
System.out.println(id + "---" + name + "---" + balance);
} 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();
}
}
}
}
}
注意:
使用步骤:
1、游标向下移动一行
2、判断是否有数据
boolean next():游标向下移动一行,判断当前行是否是最后一行末尾(是否有数据),如果是,则返回false,如果不是则返回true
3、获取数据
//6、处理结果
//6.1循环判断游标是否是最后一行末尾
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);
}
练习
//封装account表数据的JavaBean
public class Account {
private int id;
private String name;
private double balance;
public Account() {
}
public Account(int id, String name, double balance) {
this.id = id;
this.name = name;
this.balance = balance;
}
@Override
public String toString() {
return "Account{" +
"id=" + id +
", name='" + name + '\'' +
", balance=" + balance +
'}';
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public double getBalance() {
return balance;
}
public void setBalance(double balance) {
this.balance = balance;
}
}
/*
定义一个方法,查询Account表的数据将其封装为对象,然后装载集合,返回
1、定义Account类
2、定义方法public List<Account> findAll(){}
3、实现方法select * from account;
*/
public class TestJdbc {
public static void main(String[] args) {
List<Account> list = new TestJdbc().findAll();
System.out.println(list);
System.out.println(list.size());
}
//查询所有account对象
public List<Account> findAll(){
Statement stmt = null;
Connection conn = null;
ResultSet rs = null;
List<Account> list = null;
try {
//1、注册驱动
Class.forName("com.mysql.jdbc.Driver");
//2、获取连接
conn = DriverManager.getConnection("jdbc:mysql:///db1", "root", "lb5214993");
//3、定义sql
String sql = "select * from account";
//4、获取执行sql的对象
stmt = conn.createStatement();
//5、执行sql
rs = stmt.executeQuery(sql);
//6、遍历结果集,封装对象,装载集合
Account account = null;
list = new ArrayList<Account>();
while (rs.next()){
//获取数据
int id = rs.getInt("id");
String name = rs.getString("name");
double balance = rs.getDouble("balance");
//创建account对象
account = new Account();
account.setId(id);
account.setName(name);
account.setBalance(balance);
//装载集合
list.add(account);
}
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (SQLException throwables) {
throwables.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;
}
}
2.5 PrepareStatement
执行sql的对象
SQL注入问题:在拼接sql时,有一些sql的特殊关键字参与字符串的拼接,会造成安全性问题
1、输入用户随便,输入密码:a’ or ‘a’ = 'a,也能登录成功
2、sql:select * from user where username = ’ “+ username +” ’ and password = ’ “+ password +” ’
解决:使用PrepareStatement对象
预编译的SQL:参数使用?作为占位符
步骤:
1、导入驱动jar包
2、注册驱动
3、获取数据库连接对象Connection
4、定义sql
注意:sql的参数使用?作为占位符
如:select * from user where username = ? and password = ?
5、获取执行sql语句的对象PrepareStatement
6、给?赋值
方法:setXxx(参数1,参数2);参数1:?的位置编号,从1开始;参数2:?的值
6、执行sql,接收返回结果,不需要传递sql语句
7、处理结果
8、释放资源
注意:后期都会使用PrepareStatement对象来完成增删改查的所有操作
1、可以防止SQL注入
2、效率更高
public class Demo09JDBC {
public static void main(String[] args) {
//1、键盘录入,接收用户名和密码
Scanner sc = new Scanner(System.in);
System.out.println("请输入用户名:");
String username = sc.next();
System.out.println("请输入密码:");
String password = sc.next();
//2、调用方法
boolean flag = new Demo09JDBC().login(username, password);
//3、判断结果,输入不同语句
if (flag){
System.out.println("登录成功!");
} else {
System.out.println("用户名或密码错误!");
}
}
public boolean login(String username, String password){
if (username == null || password == null){
return false;
}
Connection conn = null;
Statement stmt = null;
ResultSet rs = null;
PreparedStatement pstmt = null;
//连接数据库判断是否登录成功
try {
//1、获取连接
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、执行查询
rs = pstmt.executeQuery();
//5、判断
return rs.next();//如果有下一行,则返回true
} catch (SQLException e) {
e.printStackTrace();
} finally {
JDBCUtils.close(rs, pstmt, conn);
}
return false;
}
}
第三节 JDBC工具类
JDBCUtils
目的:简化书写
分析:
1、注册驱动也抽取
2、抽取一个方法获取连接对象
需求:不想传递参数,还得保证工具类的通用性
解决:配置文件jdbc.properties
3、抽取一个方法释放资源
//jdbc.properties 配置文件
url=jdbc:mysql:///db1
user=root
password=xxxxxx
driver=com.mysql.jdbc.Driver
import java.io.FileReader;
import java.io.IOException;
import java.net.URL;
import java.sql.*;
import java.util.Properties;
//JDBC工具类
public class JDBCUtils {
private static String url;
private static String user;
private static String password;
private static String driver;
//文件的读取,只需要读取一次即可拿到这些值,使用静态代码块
static {
//读取资源文件,获取值
try {
//1、创建Properties集合类
Properties pro = new Properties();
//获取src路径下的文件的方式--->ClassLoader类加载器
ClassLoader classLoader = JDBCUtils.class.getClassLoader();
URL resource = classLoader.getResource("jdbc.properties");
String path = resource.getPath();
System.out.println(path);
//2、加载文件
//pro.load(new FileReader("src/jdbc.properties"));
pro.load(new FileReader(path));
//3、获取数据,赋值
url = pro.getProperty("url");
user = pro.getProperty("user");
password = pro.getProperty("password");
driver = pro.getProperty("driver");
Class.forName(driver);
} catch (IOException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
//获取连接
public static Connection getConnection() throws SQLException {
return DriverManager.getConnection(url, user, password);
}
//释放资源
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();
}
}
}
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();
}
}
}
}
public class Demo08Test {
public static void main(String[] args) {
List<Account> list = new Demo08Test().findAll();
System.out.println(list);
System.out.println(list.size());
}
//查询所有account对象
public List<Account> findAll(){
Statement stmt = null;
Connection conn = null;
ResultSet rs = null;
List<Account> list = null;
try {
conn = JDBCUtils.getConnection();
//3、定义sql
String sql = "select * from account";
//4、获取执行sql的对象
stmt = conn.createStatement();
//5、执行sql
rs = stmt.executeQuery(sql);
//6、遍历结果集,封装对象,装载集合
Account account = null;
list = new ArrayList<Account>();
while (rs.next()){
//获取数据
int id = rs.getInt("id");
String name = rs.getString("name");
double balance = rs.getDouble("balance");
//创建account对象
account = new Account();
account.setId(id);
account.setName(name);
account.setBalance(balance);
//装载集合
list.add(account);
}
} catch (SQLException throwables) {
throwables.printStackTrace();
} finally {
JDBCUtils.close(rs, stmt, conn);
}
return list;
}
}
3.1 练习
需求:
1、通过键盘录入用户名和密码
2、判断用户是否登录成功
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Scanner;
public class Demo09JDBC {
public static void main(String[] args) {
//1、键盘录入,接收用户名和密码
Scanner sc = new Scanner(System.in);
System.out.println("请输入用户名:");
String username = sc.next();
System.out.println("请输入密码:");
String password = sc.next();
//2、调用方法
boolean flag = new Demo09JDBC().login(username, password);
//3、判断结果,输入不同语句
if (flag){
System.out.println("登录成功!");
} else {
System.out.println("用户名或密码错误!");
}
}
public boolean login(String username, String password){
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、判断
return rs.next();//如果有下一行,则返回true
} catch (SQLException e) {
e.printStackTrace();
} finally {
JDBCUtils.close(rs, stmt, conn);
}
return false;
}
}
第四节 事务管理
事务:一个包含多个步骤的业务操作,如果这个业务操作被事务管理,则这多个步骤要么成功,要么同时失败
操作:使用Connection对象来管理事务
开启事务:在执行sql之前开启事务
set AutoCommit(boolean autoCommit):调用该方法设置参数为false,即开始事务
提交事务:当所有sql都执行完提交事务
commit()
回滚事务:在catch中回滚事务
rollback()
public class Demo10JDBC {
public static void main(String[] args) {
Connection conn = null;
PreparedStatement pstmt1 = null;
PreparedStatement pstmt2 = null;
try {
conn = JDBCUtils.getConnection();
//开启事务
conn.setAutoCommit(false);
String sql1 = "update account set balance = balance - ? where id = ? ";
String sql2 = "update account set balance = balance + ? where id = ? ";
pstmt1 = conn.prepareStatement(sql1);
pstmt2 = conn.prepareStatement(sql2);
pstmt1.setDouble(1,500);
pstmt1.setInt(2,1);
pstmt2.setDouble(1,500);
pstmt2.setInt(2,2);
pstmt1.executeUpdate();
//手动制造异常
int i = 3 / 0;
pstmt2.executeUpdate();
//提交事务
conn.commit();
} catch (Exception e) {
try {
//事务回滚
if (conn != null){
conn.rollback();
}
} catch (SQLException ex) {
ex.printStackTrace();
}
e.printStackTrace();
}finally {
JDBCUtils.close(pstmt1,conn);
JDBCUtils.close(pstmt2,null);
}
}
}
第五节 数据库连接池
概念:其实就是一个容器(集合),存放数据库连接的容器,当系统初始化好后,容器被创建,容器中会申请一些连接对象,当用户来访问数据库时,从容器中获取连接对象,用户访问完之后,会将连接对象归还给容器
好处:节约资源、用户访问高效
实现:
标准接口:DataSource java.sql包下
方法:获取连接getConnection()
归还连接:如果连接对象Connection是从连接池中获取的,那么调用Connection.close()方法,则不会再关闭连接了,而是归还连接
一般我们不去实现它,由数据库厂商来实现
1、C3P0:数据库连接池实现技术
2、Druid:数据库连接池实现技术,由阿里巴巴提供的
5.1 C3P0技术
步骤:
1、导入jar包(两个),不要忘记导入数据库驱动jar包
2、定义配置文件
名称:c3p0.properties或者c3p0-config.xml
路径:直接将文件放在src目录下即可
3、创建核心对象 数据库连接池对象ComboPooledDataSource
4、获取连接:getConnection
public class Demo01C3P0 {
public static void main(String[] args) {
//1、创建数据库连接池对象
DataSource ds = new ComboPooledDataSource();
//2、获取连接对象
Connection conn = ds.getConnection();
//3、打印
System.out.println(conn);
}
}
5.2 Druid技术
步骤:
1、导入jar包
2、定义配置文件:Properties形式,可以叫任意名称,可以放在任意目录下
3、加载配置文件Properties
4、获取数据库连接池对象:通过工厂类来获取DruidDataSourceFactory
5、获取连接:getConnection
public class DruidDemo {
public static void main(String[] args) throws Exception {
//1、导入jar包
//2、定义配置文件
//3、加载配置文件
Properties pro = new Properties();
InputStream is = DruidDemo.class.getClassLoader().getResourceAsStream("druid.properties");
pro.load(is);
//4、获取连接池对象
DataSource ds = DruidDataSourceFactory.createDataSource(pro);
//5、获取连接
Connection conn = ds.getConnection();
System.out.println(conn);
}
}
定义工具类
1、定义一个类JDBCUtils
2、提供静态代码块加载配置文件,初始化连接池对象
3、提供方法
3.1获取连接方法:通过数据库连接池获取连接
3.2释放资源
3.3获取连接池的方法
//Druid连接池的工具类
public class JDBCUtils {
//1、定义成员变量
private static DataSource ds;
static {
try {
//1、加载配置文件
Properties prop = new Properties();
prop.load(JDBCUtils.class.getClassLoader().getResourceAsStream("druid.properties"));
//2、获取DataSource
ds = DruidDataSourceFactory.createDataSource(prop);
} catch (IOException e) {
e.printStackTrace();
} catch (Exception e) {
e.printStackTrace();
}
}
//获取连接
public static Connection getConnection() throws SQLException {
return ds.getConnection();
}
//释放资源
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();
}
}*/
close(null,stmt,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();
}
}
}
//获取连接池的方法
public static DataSource getDataSource(){
return ds;
}
}
//使用新的工具类
public class DruidDemo2 {
public static void main(String[] args) {
//完成添加操作,给account表添加一条记录
Connection conn = null;
PreparedStatement pstmt = null;
//1、获取连接
try {
conn = JDBCUtils.getConnection();
//2、定义sql
String sql = "insert into account values(null,?,?)";
//3、获取pstmt对象
pstmt = conn.prepareStatement(sql);
//给?赋值
pstmt.setString(1,"哈哈");
pstmt.setDouble(2,2000);
//4、执行sql
int count = pstmt.executeUpdate();
System.out.println(count);
} catch (SQLException e) {
e.printStackTrace();
}finally {
JDBCUtils.close(pstmt,conn);
}
}
}