JDBC核心技术学习笔记
JDBC核心技术
- 1、JDBC概述
- 1.1 数据的持久化
- 1.2Java中的数据存储技术
- 1.3JDBC介绍
- 1.4 JDBC体系结构
- 1.5JDBC程序编写步骤
- 2、快速入门
- 3、详解各个对象
- 抽取JDBC工具类：JDBCUtils
- 4、JDBC控制事务
- 5、数据库连接池
- 1、概念：
- 2、好处：
- 3、实现：
- 4、C3P0：数据库连接池技术
- 5、Druid：数据库连接池技术，阿里巴巴提供
- 6、Spring JDBC: JDBC Template
1、JDBC概述
- 技术体系：
1.1 数据的持久化
- 持久化：把数据保存到可掉电式存储设备中以供之后使用。
- 持久化的实现过程大多通过各种关系数据库来完成
- 持久化的主要应用是将内存中的数据存储在关系型数据库中，当然也可以存储在磁盘文件，XML数据文件中。
1.2Java中的数据存储技术
- Java数据库存储技术：
- JDBC直接访问数据库。
- JDO（Java Data Object）技术
- 第三方工具，Mybatis
1.3JDBC介绍
JDBC是一个独立于特定数据库管理系统，通用的sql数据库存储和操作的公共接口（API）。
有了JDBC：
1.4 JDBC体系结构
1.5JDBC程序编写步骤
- 开始
- 导入java.sql包
1、复制jar包到libs目录下
2、右键，Add As Library - 建立数据源，附加驱动
- 加载并注册驱动程序
- 创建connection对象
- 创建Statement对象
- 执行SQL语句
- 使用ResultSet对象
- 关闭ResultSet对象
- 关闭Statement对象
- 关闭connection对象
- 结束
2、快速入门
package com.atguigu.connection;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.Statement;
/*
* Jdbc快速入门
* */
public class JdbcDemo1 {
public static void main(String[] args) throws Exception {
//1、导入驱动jar包
//2、注册驱动
Class.forName("com.mysql.cj.jdbc.Driver");
//3、湖区数据库连接对象
Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/db3?serverTimezone=GMT%2B8","root","123456");
//4、定义sql语句
String sql = "update account set balance = 500 where id = 1";
//5、获取数据库对象Statement
Statement stmt = conn.createStatement();
//6、执行sql
int count = stmt.executeUpdate(sql);
//7、处理结果
System.out.println(count);
//8、释放资源
stmt.close();
conn.close();
}
}
3、详解各个对象
-
1、DriverManager：驱动管理对象
- 功能：
- 1、注册驱动：告诉程序使用哪个数据库驱动jar
static void registerDriver(Driver driver) ：注册与给定的驱动程序 DriveManager
写代码使用： Class.forName(“com.mysql.cj.jdbc.Driver”);
查看源码发现：com.mysql.cj.jdbc.Driver类中存在静态代码块
注意：mysql5之后的驱动jar包可以省略注册驱动的步骤 - 2、获取数据库连接：
- 方法： static Connection getConnection(String url, String user, String password)
- 参数：
- url：指定连接的路径
- 语法：jdbc:mysql://ip地址（域名）：端口号/数据库名称
- 例子：jdbc:mysql://localhost:3306/db3
- 细节：如果连接的是本机的mysql服务器，并且mysql服务器默认端口号为3306.则url可以简写为：jdbc:mysql://数据库名称
- user：用户名
- password ：密码
- url：指定连接的路径
- 1、注册驱动：告诉程序使用哪个数据库驱动jar
- 功能：
-
2、Connection：数据库连接对象
- 1、功能：
- 1、获取数据库对象：
- Statement createStatement()
- PreparedStatement prepareStatement(String sql)
- 2、管理事务：
- 开启事务:setAutoCommit(boolean autoCommit)
- 提交事务:commit()
- 回滚事务:rollback()
- 1、获取数据库对象：
- 1、功能：
-
3、Statement： 执行sql的对象
- 1、执行sql
- 1、boolean execute（String sql）：可以执行任意的sql
- 2、int executeUpdate(Stirng) : 执行DML（insert、update、delete）语句、DDL（create、alter、drop）语句
- 返回值：影响的行数，可以通过这个影响的行数判断DML语句是否执行成功 返回值>0的则执行成功，反之，则失败。
- 3、ResultSet execute(String sql) : 执行DQL（select）语句
- 1、执行sql
-
4、ResultSet： 结果集对象，封装查询结果
- next(): 游标向下移动一行，判断当前行是否是最后一行（是否有数据），如果是，则返回false，如果不是则返回true。
- getXxx(): 获取数据
- Xxx表示数据类型 如： int getInt(), String getString()
- 参数：
- int: 代表列的编号，从1开始 如：getString(1)
- String：代表列名称。如：getDouble(“balance”)
- 注意：
- 使用步骤：
- 1、游标向下移动一行
- 2、判断是否有数据
- 3、获取数据
while (rs.next()){ //循环判断结果是否有下一行 //循环数据 int id = rs.getInt(1); String name = rs.getString("ac_name"); double balance = rs.getDouble(3); System.out.println(id + "---" + name + "---" + balance); }
- 使用步骤：
- 练习：
- 定义一个方法，查询表中的数据并将其封装为对象，然后装载集合，返回。
- 1、定义类
- 2、定义方法：public list findAll(){ }
- 3、实现方法：select * from xxxl;
package com.atguigu.connection; import com.atguigu.exe.Account; import java.sql.*; import java.util.ArrayList; import java.util.List; /* * 定义一个方法，查询Account表的数据并将其封装为对象，然后装载集合，返回 * */ public class JDBCDemo8 { public static void main(String[] args) { List<Account> list = new JDBCDemo8().findAll(); System.out.println(list); System.out.println(list.size()); } /* * 查询所有Account对象 * */ public List<Account> findAll() { Connection conn = null; Statement stmt = null; ResultSet rs = null; List<Account> list = null; try { //1、注册驱动 Class.forName("com.mysql.cj.jdbc.Driver"); //2、获取连接 conn = DriverManager.getConnection("jdbc:mysql:///db3?serverTimezone=GMT%2B8", "root", "123456"); //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 ac_name = rs.getString("ac_name"); int balance = rs.getInt("balance"); //创建account对象，并赋值 account = new Account(); account.setId(id); account.setAc_name(ac_name); account.setBalance(balance); //装载集合 list.add(account); } } 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; } } - 定义一个方法，查询表中的数据并将其封装为对象，然后装载集合，返回。
-
5、PreparedStatement：执行sql的对象
- 1、SQL注入问题：在拼接sql时，有一些sql的特殊关键字与字符串的拼接。会造成安全性问题
- 1、输入用户随便，输入密码：a’ or ‘a’ = ’ a
- 2、sql: select * from user where username = ‘fhiasdh’ and password =a’ or ‘a’ = ’ a
- 2、 解决sql注入问题：使用PreparedStatement对象来解决
- 3、预编译的SQL：参数使用？作为占位符
- 4、步骤：
- 1、 导入驱动jar包
- 2、注册驱动
- 3、获取数据库连接对象 Connection
- 4、定义sql
- 注意： sql的参数使用？作为占位符。如：select * from user where username = ? and password = ?;
- 5、获取执行sql语句的对象 PreoareStatement Connection.prepareStatement(String sql)
- 6、给？赋值：
- 方法：setXxx（参数1，参数2）
- 参数1：？的位置编号（从1开始）
- 参数2：？的值
- 方法：setXxx（参数1，参数2）
- 6、执行sql，接收返回结果，不需要传递sql 语句
- 7、处理结果
- 8、释放资源
- 5、注意：后期都会使用PreparedStatement来完成增删改查的所有操作
- 1、可以防止sql注入
- 2、效率更高
- 1、SQL注入问题：在拼接sql时，有一些sql的特殊关键字与字符串的拼接。会造成安全性问题
抽取JDBC工具类：JDBCUtils
-
目的：简化书写
-
分析：
- 1、注册驱动也抽取
- 2、抽取一个方法获取连接对象
- 需求：不想传递参数（麻烦），还得保证工具类的通用性。
- 解决：配置文件
- jdbc.properties
url =
user =
password =
- jdbc.properties
- 3、 抽取一个方法释放对象
-
代码实现1：
package com.atguigu.util;
import javax.annotation.processing.Filer;
import java.awt.*;
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 res = classLoader.getResource("jdbc.properties");
String path = res.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();
}
}
/**
* 获取连接
*
* @return 连接对象
*/
public Connection getConnection() throws SQLException {
return DriverManager.getConnection(url, user, password);
}
/**
* 释放资源
*
* @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();
}
}
}
}
- 练习：
-
需求：
- 1、键盘录入用户名密码
- 2、判断用户是否登录成功
-
步骤：
- 1、创建数据库表 user
-
CREATE TABLE USER(
id INT NOT NULL AUTO_INCREMENT PRIMARY KEY,
username VARCHAR(32),
PASSWORD VARCHAR(32)
);
INSERT INTO USER VALUES(NULL,'zhangsan','123');
INSERT INTO USER VALUES(NULL,'lisi','234');
SELECT * from USER;
- 代码实现2：
package com.atguigu.connection;
/*
* * 练习：
* 需求：
* 1、键盘录入用户名密码
* 2、判断用户是否登录成功
* */
import com.atguigu.util.JDBCUtils;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Scanner;
public class JDBCDemo9 {
public static void main(String[] args) {
//1、键盘录入，接收用户名密码
Scanner sc = new Scanner(System.in);
System.out.println("请输入用户名：");
String username = sc.nextLine();
System.out.println("请输入密码：");
String password = sc.nextLine();
//2、调用方法
boolean flag = new JDBCDemo9().login(username, password);
//3、判断结果，输出不同语句
if (flag) {
//登陆成功
System.out.println("success!");
//登录失败
} else {
System.out.println("fail!");
}
}
/**
* 登录方法
*/
public boolean login(String username, String password) {
if (username == null || password == null) {
return false;
}
//连接数据库判断是否登录成功
Connection conn = null;
Statement stmt = null;
ResultSet rs = null;
//1、获取连接
try {
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;
}
}
4、JDBC控制事务
- 1、事务：一个包含多个步骤的业务操作。如果这个业务操作被事务管理，则这多个步骤要么同时成功，要么同时失败。
- 2、操作：
- 1、开启事务
- 2、提交事务
- 3、回滚事务
- 3、使用Connection对象来管理事务
- 开启事务：setAutoCommit(boolean autoCommit)：调用该方法设置参数为false，即开启事务
- 在执行sql之前开启事务
- 提交事务：commit()
- 当所有sql都执行完提交事务
- 回滚事务：rollback()
- 在catch中回滚事务
- 开启事务：setAutoCommit(boolean autoCommit)：调用该方法设置参数为false，即开启事务
5、数据库连接池
1、概念：
是一个集合，存放数据库连接的容器。当系统初始化好后，容器被创建，容器中会申请一些连接对象，当用户来访问数据库时，从容器中获取连接对象，用户访问完后，会将连接对象归还给容器
2、好处：
- 节约资源
- 用户访问高效
3、实现：
- 1、标准接口：DataSource javax.sql包下的
- 1、方法：
- 获取连接：getConnection()
- 归还连接：如果连接对象Connection是从连接池中获取的，那么调用Connection.close()方法，则不会再关闭连接了。而是归还连接
- 2、一般我们不去实现它，有数据库厂商来实现
- 1、C3P0:数据库连接池技术
- 2、Druid：数据库连接池实现技术，由阿里巴巴提供
- 1、方法：
4、C3P0：数据库连接池技术
- 步骤：
1、导入jar包两个,还要导入数据库驱动包
2、定义xml配置文件：- 名称：c3p0.properties 或者 c3p0-config.xml
- 路径：直接将文件放在src目录下即可
3、创建核心对象 数据库连接池对象 ComboPooledDataSource
4、获取连接：getConnection
5、Druid：数据库连接池技术，阿里巴巴提供
-
步骤：
1、导入jar包
2、定义properties配置文件：- 1、是properties形式的
- 2、可以叫做任何名称，可放在任意目录下，手动加载
3、加载配置文件：properties
4、获取数据库连接池对象：通过工厂来获取：DruidDataSourceFactory
5、获取连接：getConnection
-
定义工具类：
1、定义一个类 JDBCUtils
2、提供静态代码块加载配置文件，初始化连接池对象
3、提供方法- 1、 获取连接方法：通过数据库连接池获取连接
- 2、释放资源
- 3、获取连接池的方法
6、Spring JDBC: JDBC Template
-
Spring的框架对JDBC的简单封装。提供了JDBCTemplate对象简化JDBC的开发
-
步骤：
- 1、导入jar包
- 2、 创建JDBCTemplate对象。依赖于数据源DataSource
- 3、调用JDBCTemplate方法来完成crud操作：
- update()：执行DML语句。增删改
- queryForMap()：查询结果，将结果封装成Map集合
- 注意：这个方法查询的结果集长度只能是1
- queryForList()：查询结果，将结果封装成list集合
- 注意：将每一个结果封装成Map集合，再讲Map集合装载到list对象中
- query():查询结果，将结果封装成JavaBean对象
- query的参数：RowMapper
- 一般我们使用BeanPropertyRowMapper实现类。可以完成数据到JavaBean的自动封装
- new BeanPropertyRowMapper<类型>(类型.class)
- queryforObject：查询结果，将结果封装为对象
- 一般用于聚合函数的查询
- query的参数：RowMapper
-
基本入门程序：
package cn.itcust.datasource.jdbctemplate;
import cn.itcust.datasource.utils.JDBCUtils;
import org.springframework.jdbc.core.JdbcTemplate;
/*
* JdbcTemplate入门
*/
public class JdbcTemplateDemo1 {
public static void main(String[] args) {
//1、导入jar包
//2、创建template对象
JdbcTemplate template = new JdbcTemplate(JDBCUtils.getDataSource());
//3、调用方法
String sql = "update account set balance = 5000 where id = ?";
int count = template.update(sql,3);
System.out.println(count);
}
}
-
练习：
- 需求：
- 修改1号数据的balance为10000；
- 添加一条记录
- 删除刚刚添加的记录
- 查询id为1的记录，将其封装为map集合
- 查询所有记录，将其封装为list
- 查询所有记录，将其封装为Emp对象的list集合
- 查询总记录数。
- 需求：
-
演示代码：
package cn.itcust.datasource.jdbctemplate;
import cn.itcust.datasource.domain.Emp;
import cn.itcust.datasource.utils.JDBCUtils;
import org.junit.Test;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.List;
import java.util.Map;
public class JdbcTemplateDemo2 {
//1、获取JdbcTemplate对象
private JdbcTemplate template = new JdbcTemplate(JDBCUtils.getDataSource());
/**
* 修改一号数据的balance为10000
*/
@Test
public void test1() {
//2、定义sql
String sql = "update account set balance = 10000 where id = 1";
//3、执行sql
int count = template.update(sql);
System.out.println(count);
}
/**
* 添加已一条记录
*/
@Test
public void test2() {
String sql = "insert into account(id,ac_name,balance) value(?,?,?)";
int count = template.update(sql, 8, "老八", 5000);
System.out.println(count);
}
/**
* 删除刚刚添加的记录
*/
@Test
public void test3() {
String sql = "delete from account where id = ?";
int count = template.update(sql, 8);
System.out.println(count);
}
/**
* 查询id为1的记录，将其封装成集合map
* 注意：这个方法查询的结果集长度只能是1
*/
@Test
public void test4() {
String sql = "select * from account where id = ?";
Map<String, Object> map = template.queryForMap(sql, 1);
System.out.println(map);
//结果：{id=1, ac_name=zhangsan, balance=10000}
}
/**
* 查询所有记录，将其封装为Emp对象的list集合
*/
@Test
public void test5() {
String sql = "select * from account";
List<Map<String, Object>> list = template.queryForList(sql);
for (Map<String, Object> stringObjectMap : list) {
System.out.println(stringObjectMap);
}
}
/**
* 查询所有记录，将其封装为Emp对象的list集合
*/
@Test
public void test6() {
String sql = "select * from account";
List<Emp> list = template.query(sql, new RowMapper<Emp>() {
@Override
public Emp mapRow(ResultSet rs, int i) throws SQLException {
Emp emp = new Emp();
int id = rs.getInt("id");
String ac_name = rs.getString("ac_name");
int balance = rs.getInt("balance");
emp.setId(id);
emp.setAc_name(ac_name);
emp.setBalance(balance);
return emp;
}
});
for (Emp emp : list) {
System.out.println(emp);
}
}
/**
* 查询所有记录，将其封装为Emp对象的list集合
*/
@Test
public void test6_2() {
String sql = "select * from account";
List<Emp> list = template.query(sql, new BeanPropertyRowMapper<Emp>(Emp.class));
for (Emp emp : list) {
System.out.println(emp);
}
}
/**
* 查询所有记录数
*/
@Test
public void test7(){
String sql = "select count(id) from account";
Long total = template.queryForObject(sql,long.class);
System.out.println(total);
}
}