1、JDBC
1.1、数据的持久化
持久化(persistence)：把数据保存到可掉电式存储设备中以供之后使用。大多数情况下，特别是企业级应用， 数据持久化意味着将内存中的数据保存到硬盘上加以”固化”，而持久化的实现过程大多通过各种关系数据库来完成
持久化的主要应用是将内存中的数据存储在关系型数据库中，当然也可以存储在磁盘文件、XML数据文件中
1.2、 Java中的数据操作技术
在Java中，数据库存取数据的技术可分为如下几类：
- JDBC直接访问数据库
- 第三方O/RM框架，如Hibernate，Mybatis，Spring Data JPA等
JDBC是Java访问数据库的基石，Hibernate、MyBatis、Spring Data JPA等只是更好的封装了JDBC
1.3、JDBC介绍
-
全称：(Java DataBase Connectivity）Java数据库连接
-
JDBC就是使用Java语言操作关系型数据库的一套API
JDBC本质
- 官方(sun公司)定义的一套操作所有关系型数据库的规则，即接口
- 各个数据库厂商去实现这套接口，提供数据库驱动jar包
- 面向接口编程，真正执行的代码是驱动jar包中的实现类
同一套Java代码，操作不同的关系型数据库
JDBC的好处
- 各数据库厂商使用相同的接口，Java代码不需要针对不同数据库分别开发
- 可随时替换底层数据库，访问数据库的Java代码基本不变
1.4、JDBC程序编写步骤
- 导入数据库驱动包
mysql-connector-java-8.0.28.jar - 加载驱动
- 获取连接
- 定义SQL
- 执行SQL语句
- 处理返回结果
- 释放资源
public static void main(String[] args) throws ClassNotFoundException, SQLException {
// 1.注册驱动
Class.forName("com.mysql.cj.jdbc.Driver");
// 2.获取数据库连接对象
String url = "jdbc:mysql://localhost:3306/front_db?useSSL=true&useUnicode=true&characterEncoding=utf-8&serverTimezone=Asia/Shanghai";
String username = "root";
String password = "root";
Connection conn = DriverManager.getConnection(url, username, password);
// 3.定义sql
String sql = "insert front_db.users values (1005,'小黑','1314',19,1)";
// 4.获取执行sql的对象 Statement
Statement stmt = conn.createStatement();
// 5.执行sql
int affectRow = stmt.executeUpdate(sql);
// 6.处理结果
System.out.println("affectRow = " + affectRow);
// 7.释放资源
if (stmt != null) {
stmt.close();
}
if (conn != null) {
conn.close();
}
}
连接四要素
- 加载与注册JDBC驱动
- URL
- 用户名
- 密码
编写jdbc.properties配置文件
# 驱动包路径
driver=com.mysql.cj.jdbc.Driver
# 协议://主机地址:端口号/数据库名?参数1&参数2&参数3&参数n
url=jdbc:mysql://localhost:3306/test?useSSL=true&useUnicode=true&characterEncoding=utf-8&serverTimezone=Asia/Shanghai
# 用户名
username=root
# 密码
password=root
获取连接
使用配置文件的方式保存配置信息，在代码中加载配置文件
public static void main(String[] args) throws Exception {
// 获取连接
Connection conn = getConnection();
// 获取执行SQL对象
Statement stmt = conn.createStatement();
// 定义SQL
String sql = "select id, username, password, age, status from front_db.users";
// 执行SQL
ResultSet rs = stmt.executeQuery(sql);
List<User> userList = new ArrayList<>();
// 处理结果
while (rs.next()) {
int id = rs.getInt("id");
String username = rs.getString("username");
String password = rs.getString("password");
int age = rs.getInt("age");
int status = rs.getInt("status");
userList.add(new User(id, username, password, age, status));
}
System.out.println(userList);
if (rs != null) rs.close();
if (stmt != null) stmt.close();
if (conn != null) conn.close();
}
public static Connection getConnection() throws Exception {
// 1.读取配置文件中4个连接数据库的基本信息
InputStream is = ClassLoader.getSystemClassLoader().getResourceAsStream("jdbc.properties");
Properties prop = new Properties();
prop.load(is);
String driver = prop.getProperty("driver");
String url = prop.getProperty("url");
String username = prop.getProperty("username");
String password = prop.getProperty("password");
System.out.println(driver + "\n" + url + "\n" + username + "\n" + password);
// 2.加载驱动
Class.forName(driver);
// 3.获取连接
return DriverManager.getConnection(url, username, password);
}
使用配置文件的好处：
①实现了代码和数据的分离，如果需要修改配置信息，直接在配置文件中修改，无需深入代码
②如果修改了配置信息，省去重新编译的过程
1.5、JDBC API作用
- DriverManager（驱动管理类）：注册驱动，获取数据库连接
- Connection（数据库连接对象）
- 获取执行 SQL 的对象
- 普通执行SQL对象：createStatement()
- 预编译SQL的执行SQL对象：prepareStatement(sql)
- 执行存储过程的对象：prepareCall(sql)
- 管理事务
- 开启事务：setAutoCommit(boolean autoCommit)；true为自动提交事务，false为手动提交事务（即开启事务）
- 提交事务：commit()
- 回滚事务：rollback()
- 获取执行 SQL 的对象
- Statement：用来执行SQL语句
- 执行DDL、DML语句：excuteUpdate
- 执行DQL语句：executeQuery
- ResultSet（结果集对象）：封装了SQL查询语句的结果
- next()：将光标从当前位置向后移动一行，判断当前行是否有数据
- getXxx(参数)：获取数据
- PreparedStatement：预编译SQL语句并执行（性能更好），预防SQL注入问题（将敏感字符进行转义）
1.6、SQL注入
SQL注入是通过操作输入来修改事先定义好的SQL语句，用以达到执行代码对服务器进行攻击的方法
使用Statement操作数据库表存在弊端：
- 问题一：存在拼串操作，较为繁琐
- 问题二：存在SQL注入问题
public static void main(String[] args) throws Exception {
Scanner input = new Scanner(System.in);
Class.forName("com.mysql.cj.jdbc.Driver");
String url = "jdbc:mysql://localhost:3306/front_db?useSSL=true&useUnicode=true&characterEncoding=utf-8&serverTimezone=Asia/Shanghai";
String username = "root";
String password = "root";
Connection conn = DriverManager.getConnection(url, username, password);
System.out.print("请输入用户名：");
String uName = input.nextLine();
System.out.print("请输入密码：");
String uPwd = input.nextLine(); // ' or '1' = '1
String sql = "select * from front_db.users where username = '" + uName + "' and password = '" + uPwd + "'";
Statement stmt = conn.createStatement();
ResultSet rs = stmt.executeQuery(sql);
if (rs.next()) {
System.out.println("登录成功");
} else {
System.out.println("登录失败");
}
if (rs != null) rs.close();
if (stmt != null) stmt.close();
if (conn != null) conn.close();
}
对于 Java 而言，要防止 SQL 注入，只要用 PreparedStatement(从Statement扩展而来) 取代 Statement 就可以了
public static void main(String[] args) throws Exception {
Scanner input = new Scanner(System.in);
// MySQL5之后的驱动包，可以省略注册驱动的步骤
// Class.forName("com.mysql.cj.jdbc.Driver");
// useServerPrepStmts=true 参数开启预编译功能
String url = "jdbc:mysql://localhost:3306/front_db?useSSL=true&useUnicode=true&characterEncoding=utf-8&serverTimezone=Asia/Shanghai&useServerPrepStmts=true";
String username = "root";
String password = "root";
Connection conn = DriverManager.getConnection(url, username, password);
// 预编译SQL
String sql = "select * from front_db.users where username = ? and password = ?";
PreparedStatement ps = conn.prepareStatement(sql);
System.out.print("请输入用户名：");
String uName = input.nextLine();
System.out.print("请输入密码：");
String uPwd = input.nextLine(); // ' or '1' = '1
// 填充占位符
ps.setString(1, uName);
ps.setString(2, uPwd);
ResultSet rs = ps.executeQuery();
if (rs.next()) {
System.out.println("登录成功");
} else {
System.out.println("登录失败");
}
if (rs != null) rs.close();
if (ps != null) ps.close();
if (conn != null) conn.close();
}
使用PreparedStatement实现CRUD操作
可以通过调用 Connection 对象的 preparedStatement(String sql) 方法获取 PreparedStatement 对象，PreparedStatement接口是Statement的子接口，它表示一条预编译过的SQL语句
PreparedStatement 对象所代表的 SQL 语句中的参数用问号(?)来表示，调用PreparedStatement 对象的setXxx() 方法来设置这些参数，setXxx() 方法有两个参数，第一个参数是要设置的 SQL 语句中的参数的索引(从1开始)，第二个是设置的 SQL语句中参数的值
Query
public static void main(String[] args) throws Exception {
Class.forName("com.mysql.cj.jdbc.Driver");
String url = "jdbc:mysql://localhost:3306/front_db?useSSL=true&useUnicode=true&characterEncoding=utf-8&serverTimezone=Asia/Shanghai";
String username = "root";
String password = "root";
Connection conn = DriverManager.getConnection(url, username, password);
String sql = "select * from front_db.users";
PreparedStatement ps = conn.prepareStatement(sql);
ResultSet rs = ps.executeQuery();
List<User> userList = new ArrayList<>();
while (rs.next()) {
int id = rs.getInt("id");
String uName = rs.getString("username");
String uPwd = rs.getString("password");
int age = rs.getInt("age");
int status = rs.getInt("status");
User user = new User(id, uName, uPwd, age, status);
userList.add(user);
}
System.out.println(userList);
if (rs != null) rs.close();
if (ps != null) ps.close();
if (conn != null) conn.close();
}
Insert、Update、Delete 只需修改对应的SQL语句，以及填充对应占位符
public static void main(String[] args) throws Exception {
Class.forName("com.mysql.cj.jdbc.Driver");
String url = "jdbc:mysql://localhost:3306/front_db?useSSL=true&useUnicode=true&characterEncoding=utf-8&serverTimezone=Asia/Shanghai";
String username = "root";
String password = "root";
Connection conn = DriverManager.getConnection(url, username, password);
// 预编译SQL
String sql = "update front_db.users set username = ? ,password = ?,age = ?,status = ? where id = ?";
PreparedStatement ps = conn.prepareStatement(sql);
// 填充占位符
ps.setString(1, "小萌");
ps.setString(2, "meng@.");
ps.setInt(3, 18);
ps.setInt(4, 1);
ps.setInt(5, 1001);
int affectRow = ps.executeUpdate();
if (affectRow == 0) System.out.println("修改失败");
if (ps != null) ps.close();
if (conn != null) conn.close();
}
1.7、使用IDEA连接数据库
连接成功后，选择数据库
双击数据库，查看相应的表
修改表中数据
打开编写代码控制台
连接失败，检查原因
1.8、数据库连接池
数据库连接—>执行完毕—>释放
连接、释放十分浪费系统资源
- 数据库连接池是个容器，负责分配、管理数据库连接 (Connection)
- 它允许应用程序重复使用一个现有的数据库连接，而不是再重新建立一个
- 超过最大空闲时间的数据库连接会自动归还到连接池中，来避免因为没有释放数据库连接而引起的数据库连接遗漏
好处
- 资源重用
- 提升系统响应速度
- 避免数据库连接遗漏
池化技术：准备一些预先的资源，过来就连接预先准备好的
标准接口：DataSource
- 官方(SUN) 提供的数据库连接池标准接口，由第三方组织实现此接口。该接口提供了获取连接的功能
- 那么以后就不需要通过 DriverManager 对象获取 Connection 对象，而是通过连接池（DataSource）获取 Connection 对象
常见的数据库连接池
- C3P0
- DBCP
- Druid
C3P0
C3P0是一个开源组织提供的一个数据库连接池，**速度相对较慢，稳定性还可以。**hibernate官方推荐使用
需要用到的jar包：c3p0-0.9.5.5.jar
-
编写
c3p0-config.xml文件<?xml version="1.0" encoding="UTF-8" ?> <c3p0-config> <named-config name="helloC3P0"> <!--提供获取连接的四个基本信息--> <property name="driverClass">com.mysql.cj.jdbc.Driver</property> <!--注：在xml中 & 符号 需要使用 &特殊转义--> <property name="jdbcUrl">jdbc:mysql://localhost:3306/front_db?useSSL=true&useUnicode=true&characterEncoding=utf-8&serverTimezone=Asia/Shanghai</property> <property name="user">root</property> <property name="password">root</property> <!--进行数据库连接池管理的基本信息--> <!--当数据库连接池中的连接数不够时，c3p0一次性向数据库服务器申请的连接数--> <property name="acquireIncrement">5</property> <!--c3p0数据库连接池中初始化时的连接数--> <property name="initialPoolSize">10</property> <!--c3p0数据库连接池维护的最少连接数--> <property name="minPoolSize">10</property> <!--c3p0数据连接池维护的最多连接数--> <property name="maxPoolSize">100</property> <!--c3p0数据连接池最多维护的Statement的个数--> <property name="maxStatements">50</property> <!--每个连接中可以最多使用的Statement的个数--> <property name="maxStatementsPerConnection">2</property> </named-config> </c3p0-config> -
获取连接
@Test public void testC3p0Connection() throws SQLException { ComboPooledDataSource cpds = new ComboPooledDataSource("helloC3P0"); Connection conn = cpds.getConnection(); System.out.println(conn); }
DBCP
DBCP是Apache软件基金组织下的开源连接池实现，tomcat 服务器自带dbcp数据库连接池。速度相对c3p0较快，但因自身存在BUG，Hibernate3已不再提供支持
需要用到的jar包
- commons-dbcp-1.4.jar：连接池的实现
- commons-pool-1.6.jar：连接池实现的依赖库
-
编写
dbcp.properties配置文件# 连接四要素 driverClassName=com.mysql.cj.jdbc.Driver url=jdbc:mysql://localhost:3306/front_db?useSSL=true&useUnicode=true&characterEncoding=utf-8&serverTimezone=Asia/Shanghai username=root password=root # 其他设置 initialSize=10 maxActive=20 # ... -
获取连接
@Test public void testDBCPConnection() throws Exception { Properties pros = new Properties(); InputStream is = ClassLoader.getSystemClassLoader().getResourceAsStream("dbcp.properties"); pros.load(is); DataSource ds = BasicDataSourceFactory.createDataSource(pros); Connection conn = ds.getConnection(); System.out.println(conn); }
Druid（德鲁伊）
Druid是阿里巴巴开源平台上一个数据库连接池实现，它结合了C3P0、DBCP、Proxool等DB池的优点，同时加入了日志监控，可以很好的监控DB池连接和SQL的执行情况，可以说是针对监控而生的DB连接池，且功能强大，性能优秀，是Java语言最好的数据库连接池之一
需要用到的jar包：druid-1.2.8.jar
-
编写
druid.properties配置文件# 连接四要素 driverClassName=com.mysql.cj.jdbc.Driver url=jdbc:mysql://localhost:3306/front_db?useSSL=true&useUnicode=true&characterEncoding=utf-8&serverTimezone=Asia/Shanghai username=root password=root # 其他设置 # 初始化连接数量 initialSize=10 # 最大连接数 maxActive=15 # 最大等待时长 maxWait=3000 -
获取连接
@Test public void testDruidConnection() throws Exception { Properties prop = new Properties(); InputStream is = ClassLoader.getSystemClassLoader().getResourceAsStream("druid.properties"); prop.load(is); DataSource ds = DruidDataSourceFactory.createDataSource(prop); Connection conn = ds.getConnection(); System.out.println(conn); }
结论：无论使用什么数据源，本质还是一样的，DataSource接口不会变，方法就不会变！
1.9、DAO模式
为什么进行JDBC封装?
业务代码和数据访问代码耦合
- 可读性差
- 不利于后期修改和维护
- 不利于代码复用
什么是DAO？
非常流行的数据访问模式——DAO模式
- Data Access Object（数据访问对象）
- 位于业务逻辑层和持久化数据层之间
- 实现对持久化数据的访问
DAO模式的组成部分
- 实体类
- DAO接口
- DAO实现类
- 数据库连接和关闭工具类
DAO的优势
- 隔离业务逻辑代码和数据访问代码
- 隔离不同数据库的实现
为解决业务代码和数据访问代码的紧耦合，给修改和维护代码带来的不便，推荐使用DAO模式封装JDBC
// DAO：Data Access Object(数据访问对象)
public abstract class BaseDao<T> {
private Class<T> clazz;
{
// 获取当前BaseDao的子类继承父类中的泛型
Type genericSuperclass = this.getClass().getGenericSuperclass();
ParameterizedType paramType = (ParameterizedType) genericSuperclass;
Type[] typeArguments = paramType.getActualTypeArguments(); // 获取父类的泛型参数
clazz = (Class<T>) typeArguments[0]; // 泛型的第一个参数
}
/**
* 获取连接
*/
public Connection getConnection() {
DataSource dataSource = null;
try {
// 1.读取配置文件中连接数据库的基本信息
InputStream is = ClassLoader.getSystemClassLoader().getResourceAsStream("druid.properties");
Properties prop = new Properties();
prop.load(is);
// 获取数据库连接池
dataSource = DruidDataSourceFactory.createDataSource(prop);
return dataSource.getConnection();
} catch (Exception e) {
throw new RuntimeException(e);
}
}
/**
* 关闭资源 查询
*/
public void closeResource(Connection conn, PreparedStatement ps, ResultSet rs) {
try {
if (rs != null) rs.close();
if (ps != null) ps.close();
if (conn != null) conn.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
/**
* 关闭资源 增、删、改
*
* @param conn 连接对象
* @param ps 执行SQL语句对象
*/
public void closeResource(Connection conn, PreparedStatement ps) {
try {
if (ps != null) ps.close();
if (conn != null) conn.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
/**
* 通用增、删、改 version 2.0(考虑到事务)
*
* @param sql
* @param args
* @return
*/
public int modifyTbTx(Connection conn, String sql, Object... args) {
PreparedStatement ps = null;
try {
// 1.预编译sql 返回prepareStatement对象
ps = conn.prepareStatement(sql);
// 2.填充占位符
for (int i = 0; i < args.length; i++) {
// 从1开始
ps.setObject(i + 1, args[i]);
}
// 3.执行操作
return ps.executeUpdate();
} catch (Exception e) {
e.printStackTrace();
} finally {
// 4.关闭资源
closeResource(null, ps);
}
return 0;
}
/**
* 通用的查询操作，返回数据表的一条记录 version 2.0(考虑到事务)
*
* @param conn 连接对象
* @param sql sql语句
* @param args 执行sql所需的填充参数
* @return 单条记录
*/
public T getDataOneWithTx(Connection conn, String sql, Object... args) {
PreparedStatement ps = null;
ResultSet rs = null;
try {
// 预编译sql
ps = conn.prepareStatement(sql);
// 填充占位符
for (int i = 0; i < args.length; i++) {
ps.setObject(i + 1, args[i]);
}
// 执行操作
rs = ps.executeQuery();
// 获取结果集元数据
ResultSetMetaData rsmd = rs.getMetaData();
// 获取列数
int columnCount = rsmd.getColumnCount();
if (rs.next()) {
T t = clazz.newInstance();
for (int i = 0; i < columnCount; i++) {
// 获取每一个列的列值：通过ResultSet
Object columnValue = rs.getObject(i + 1);
// 获取每一个列的列名：通过ResultSetMetaData
// getColumnLabel:获取列的别名 推荐使用
String columnLabel = rsmd.getColumnLabel(i + 1);
// 通过反射，将对象的指定columnLabel属性名的属性赋值为指定值columnValue
Field field = clazz.getDeclaredField(columnLabel);
field.setAccessible(true);
field.set(t, columnValue);
}
return t;
}
} catch (Exception e) {
e.printStackTrace();
} finally {
closeResource(null, ps, rs);
}
return null;
}
/**
* 通用查询方法 返回多条记录的查询操作 version 2.0(考虑到事务)
*
* @param sql sql语句
* @param args 执行sql所需的填充参数
* @return 多条记录
*/
public List<T> getDataListWithTx(Connection conn, String sql, Object... args) {
PreparedStatement ps = null;
ResultSet rs = null;
try {
ps = conn.prepareStatement(sql);
for (int i = 0; i < args.length; i++) {
ps.setObject(i + 1, args[i]);
}
rs = ps.executeQuery();
ResultSetMetaData rsmd = rs.getMetaData();
int columnCount = rsmd.getColumnCount();
// 创建集合对象
ArrayList<T> list = new ArrayList<>();
while (rs.next()) {
T t = clazz.newInstance();
for (int i = 0; i < columnCount; i++) {
Object columnValue = rs.getObject(i + 1);
String columnLabel = rsmd.getColumnLabel(i + 1);
// 通过反射，将对象的指定columnLabel属性名的属性赋值为指定值columnValue
Field field = clazz.getDeclaredField(columnLabel);
field.setAccessible(true);
field.set(t, columnValue);
}
list.add(t);
}
return list;
} catch (Exception e) {
e.printStackTrace();
} finally {
closeResource(null, ps, rs);
}
return null;
}
/**
* 用于查询特殊值的通用方法
*
* @param conn 连接对象
* @param sql sql语句
* @param args 执行sql所需的填充参数
*/
public <E> E getValue(Connection conn, String sql, Object... args) {
PreparedStatement ps = null;
ResultSet rs = null;
try {
ps = conn.prepareStatement(sql);
for (int i = 0; i < args.length; i++) {
ps.setObject(i + 1, args[i]);
}
rs = ps.executeQuery();
if (rs.next()) {
return (E) rs.getObject(1);
}
} catch (SQLException e) {
e.printStackTrace();
} finally {
closeResource(null, ps, rs);
}
return null;
}
}
