JDBC入门
DBUtils学习
第1章：DBUtils概述
1.1 数据的持久化
-
持久化(persistence)：把数据保存到可掉电式存储设备中以供之后使用。大多数情况下，特别是企业级应用，数据持久化意味着将内存中的数据保存到硬盘上加以”固化”，而持久化的实现过程大多通过各种关系数据库来完成。
-
持久化的主要应用是将内存中的数据存储在关系型数据库中，当然也可以存储在磁盘文件、XML数据文件中。
第2章：获取数据库连接
2.1 要素一：Driver接口实现类
2.1.1 Driver接口介绍
-
java.sql.Driver 接口是所有 DBUtils 驱动程序需要实现的接口。这个接口是提供给数据库厂商使用的，不同数据库厂商提供不同的实现。
-
在程序中不需要直接去访问实现了 Driver 接口的类，而是由驱动程序管理器类(java.sql.DriverManager)去调用这些Driver实现。
- Oracle的驱动：oracle.jdbc.driver.OracleDriver - mySql 的驱动：com.mysql.jdbc.Driver -
将上述jar包拷贝到Java工程的一个目录中，习惯上新建一个lib文件夹，不同的idea有不同的操作。
2.1.2 加载与注册DBUtils驱动
-
加载驱动：加载 DBUtils 驱动需调用 Class 类的静态方法 forName()，向其传递要加载的 DBUtils 驱动的类名
- Class.forName(“com.mysql.jdbc.Driver”);
-
注册驱动：DriverManager 类是驱动程序管理器类，负责管理驱动程序
-
使用DriverManager.registerDriver(com.mysql.jdbc.Driver)来注册驱动
-
通常不用显式调用 DriverManager 类的 registerDriver() 方法来注册驱动程序类的实例，因为 Driver 接口的驱动程序类都包含了静态代码块，在这个静态代码块中，会调用 DriverManager.registerDriver() 方法来注册自身的一个实例。
-
2.2 要素二：URL
-
DBUtils URL 用于标识一个被注册的驱动程序，驱动程序管理器通过这个 URL 选择正确的驱动程序，从而建立到数据库的连接。
-
DBUtils URL的标准由三部分组成，各部分间用冒号分隔。
- jdbc:子协议:子名称
- 协议：DBUtils URL中的协议总是jdbc
- 子协议：子协议用于标识一个数据库驱动程序
- 子名称：一种标识数据库的方法。子名称可以依不同的子协议而变化，用子名称的目的是为了定位数据库提供足够的信息。包含主机名(对应服务端的ip地址)，端口号，数据库名
-
几种常用数据库的 DBUtils URL
-
MySQL的连接URL编写方式：
- jdbc:mysql://主机名称:mysql服务端口号/数据库名称?参数=值&参数=值
- jdbc:mysql://localhost:3306/xinzhi
- jdbc:mysql://localhost:3306/xinzhi?useUnicode=true&characterEncoding=utf8（如果程序与服务器端的字符集不一致，会导致乱码，那么可以通过参数指定服务器端的字符集）
- jdbc:mysql://localhost:3306/atguigu?user=root&password=123456
-
Oracle 的连接URL编写方式：
- jdbc:oracle:thin:@主机名称:oracle服务端口号:数据库名称
- jdbc:oracle:thin:@localhost:1521:atguigu
-
SQLServer的连接URL编写方式：
-
jdbc:sqlserver://主机名称:sqlserver服务端口号:DatabaseName=数据库名称
-
jdbc:sqlserver://localhost:1433:DatabaseName=atguigu
-
-
2.3 要素三：用户名和密码
- user,password可以用“属性名=属性值”方式告诉数据库
- 可以调用 DriverManager 类的 getConnection() 方法建立到数据库的连接
2.4 数据库连接方式举例
package com.xinzhi;
import org.junit.Test;
import java.io.InputStream;
import java.sql.Connection;
import java.sql.Driver;
import java.sql.DriverManager;
import java.util.Properties;
/**
* @author zn
* @date 2020/4/3
**/
public class TestUser {
@Test
public void testConnection1() throws Exception{
//1.数据库连接的4个基本要素：
String url = "jdbc:mysql://101.200.48.99:3306/test?useUnicode=true&characterEncoding=utf8";
String user = "root";
String password = "root";
//8.0之后名字改了 com.mysql.cj.jdbc.Driver
String driverName = "com.mysql.jdbc.Driver";
//2.实例化Driver
Class clazz = Class.forName(driverName);
Driver driver = (Driver) clazz.newInstance();
//3.注册驱动
DriverManager.registerDriver(driver);
//4.获取连接
Connection conn = DriverManager.getConnection(url, user, password);
System.out.println(conn);
}
@Test
public void testConnection2() throws Exception{
//1.数据库连接的4个基本要素：
String url = "jdbc:mysql://101.200.48.99:3306/test?useUnicode=true&characterEncoding=utf8";
String user = "root";
String password = "root";
String driverName = "com.mysql.jdbc.Driver";
//2.加载驱动 （①实例化Driver ②注册驱动）
Class.forName(driverName);
//3.获取连接
Connection conn = DriverManager.getConnection(url, user, password);
System.out.println(conn);
}
@Test
public void testConnection3() throws Exception{
//1.数据库连接的4个基本要素：
String url = "jdbc:mysql://101.200.48.99:3306/test?useUnicode=true&characterEncoding=utf8";
String user = "root";
String password = "root";
String driverName = "com.mysql.jdbc.Driver";
//3.获取连接
Connection conn = DriverManager.getConnection(url, user, password);
System.out.println(conn);
}
@Test
public void testConnection4() throws Exception{
//1.数据库连接的4个基本要素：
InputStream in = TestUser.class.getClassLoader().getResourceAsStream("jdbc.config");
Properties properties = new Properties();
properties.load(in);
String url = properties.getProperty("url");
String user = properties.getProperty("user");
String password = properties.getProperty("password");
String driverName = properties.getProperty("driverName");
//2.加载驱动 （①实例化Driver ②注册驱动）
Class.forName(driverName);
//3.获取连接
Connection conn = DriverManager.getConnection(url, user, password);
System.out.println(conn);
}
}
说明：使用配置文件的方式保存配置信息，在代码中加载配置文件
使用配置文件的好处：
①实现了代码和数据的分离，如果需要修改配置信息，直接在配置文件中修改，不需要深入代码
②如果修改了配置信息，省去重新编译的过程。
第3章：使用PreparedStatement
3.1 操作和访问数据库
-
数据库连接被用于向数据库服务器发送命令和 SQL 语句，并接受数据库服务器返回的结果。其实一个数据库连接就是一个Socket连接。
-
在 java.sql 包中有 3 个接口分别定义了对数据库的调用的不同方式：
- Statement：用于执行静态 SQL 语句并返回它所生成结果的对象。
- PrepatedStatement：SQL 语句被预编译并存储在此对象中，可以使用此对象多次高效地执行该语句。
- CallableStatement：用于执行 SQL 存储过程（不学，有兴趣自己研究，但是得先学习存储过程）
3.2 使用Statement操作数据表的弊端
-
通过调用 Connection 对象的 createStatement() 方法创建该对象。该对象用于执行静态的 SQL 语句，并且返回执行结果。
-
Statement 接口中定义了下列方法用于执行 SQL 语句：
int excuteUpdate(String sql)：执行更新操作INSERT、UPDATE、DELETE ResultSet executeQuery(String sql)：执行查询操作SELECT -
但是使用Statement操作数据表存在弊端：
- 问题一：存在拼串操作，繁琐
- 问题二：存在SQL注入问题
-
SQL 注入是利用某些系统没有对用户输入的数据进行充分的检查，而在用户输入数据中注入非法的 SQL 语句段或命令(如：SELECT user, password FROM user_table WHERE user='a' OR 1 = ' AND password = ' OR '1' = '1') ，从而利用系统的 SQL 引擎完成恶意行为的做法。
-
对于 Java 而言，要防范 SQL 注入，只要用 PreparedStatement(从Statement扩展而来) 取代 Statement 就可以了。
3.2.1 体会增删改代码
public static void main(String[] args) throws Exception {
//1.数据库连接的4个基本要素：
String url = "jdbc:mysql://localhost:3306/test";
String user = "root";
String password = "root";
String driverName = "com.mysql.jdbc.Driver";
String sql = "insert into user values(1,'zn',12)";
//2.实例化Driver
Class clazz = Class.forName(driverName);
Driver driver = (Driver) clazz.newInstance();
//3.注册驱动
DriverManager.registerDriver(driver);
//4.获取连接
Connection conn = DriverManager.getConnection(url, user, password);
Statement statement = conn.createStatement();
statement.execute(sql);
}
3.2.2 体会查询代码
public static void main(String[] args) throws Exception {
//1.数据库连接的4个基本要素：
String url = "jdbc:mysql://localhost:3306/test";
String user = "root";
String password = "root";
String driverName = "com.mysql.jdbc.Driver";
String sql = "select id,name,age from user";
//2.实例化Driver
Class clazz = Class.forName(driverName);
Driver driver = (Driver) clazz.newInstance();
//3.注册驱动
DriverManager.registerDriver(driver);
//4.获取连接
Connection conn = DriverManager.getConnection(url, user, password);
Statement statement = conn.createStatement();
ResultSet resultSet = statement.executeQuery(sql);
resultSet.next();
int id = resultSet.getInt("id");
String name = resultSet.getString("name");
int age = resultSet.getInt("age");
System.out.println("id="+id);
System.out.println("name="+name);
System.out.println("age="+age);
resultSet.next();
int id2 = resultSet.getInt("id");
String name2 = resultSet.getString("name");
int age2 = resultSet.getInt("age");
System.out.println("id="+id2);
System.out.println("name="+name2);
System.out.println("age="+age2);
}
3.2.3 代码优化
资源的释放
- 释放ResultSet, Statement,Connection。
- 数据库连接（Connection）是非常稀有的资源，用完后必须马上释放，如果Connection不能及时正确的关闭将导致系统宕机。Connection的使用原则是尽量晚创建，尽量早的释放。
- 可以在finally中关闭，保证及时其他代码出现异常，资源也一定能被关闭。
1、手动处理异常
2、合理关系资源
3、遍历处理数据
public static void main(String[] args) {
//1.数据库连接的4个基本要素：
String url = "jdbc:mysql://localhost:3306/test";
String user = "root";
String password = "root";
String driverName = "com.mysql.jdbc.Driver";
String sql = "select id,name,age from user";
//2.实例化Driver
//抽离资源，方便合理关闭
Connection conn = null;
Statement statement = null;
ResultSet resultSet = null;
//手动处理异常
try {
Class clazz = Class.forName(driverName);
Driver driver = (Driver) clazz.newInstance();
//3.注册驱动
DriverManager.registerDriver(driver);
//4.获取连接
conn = DriverManager.getConnection(url, user, password);
statement = conn.createStatement();
resultSet = statement.executeQuery(sql);
//使用遍历获取数据
while (resultSet.next()){
int id = resultSet.getInt("id");
String name = resultSet.getString("name");
int age = resultSet.getInt("age");
System.out.println("id=" + id);
System.out.println("name=" + name);
System.out.println("age=" + age);
}
} catch (Exception exception) {
exception.printStackTrace();
}finally {
//关闭资源
if(conn != null){
try {
conn.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
if(statement != null){
try {
statement.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
if(resultSet != null){
try {
resultSet.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
}
3.2.4 公共提取
1、不管哪里要操作数据库都要获取连接，所以能不能提取
2、不管哪里都要关闭资源能不能提取
package com.xinzhi;
import java.sql.*;
/**
* @author zn
* @date 2020/4/1
**/
public class DBUtil {
public static Connection getConnection(){
String url = "jdbc:mysql://localhost:3306/test";
String user = "root";
String password = "root";
String driverName = "com.mysql.jdbc.Driver";
Connection conn = null;
try {
Class clazz = Class.forName(driverName);
Driver driver = (Driver) clazz.newInstance();
//3.注册驱动
DriverManager.registerDriver(driver);
//4.获取连接
conn = DriverManager.getConnection(url, user, password);
}catch (Exception e){
e.printStackTrace();
}
return conn;
}
public static void closeAll(Connection connection, Statement statement, ResultSet rs){
if(connection != null){
try {
connection.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
if(statement != null){
try {
statement.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
if( rs != null ){
try {
rs.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
}
public static void main(String[] args) {
String sql = "select id,name,age from user";
Connection conn = null;
Statement statement = null;
ResultSet resultSet = null;
//手动处理异常
try {
conn = DBUtil.getConnection();
statement = conn.createStatement();
resultSet = statement.executeQuery(sql);
//使用遍历获取数据
while (resultSet.next()){
int id = resultSet.getInt("id");
String name = resultSet.getString("name");
int age = resultSet.getInt("age");
System.out.println("id=" + id);
System.out.println("name=" + name);
System.out.println("age=" + age);
}
} catch (Exception exception) {
exception.printStackTrace();
}finally {
DBUtil.closeAll(conn,statement,resultSet);
}
}
3.2.5 sql注入问题
因为SQL是一个拼接字符串的问题，所以会有攻击者使用一些特殊技巧完成一些操作，从而绕开我们的逻辑。
getUserById
因为sql语句是预编译的，而且语句中使用了占位符，规定了sql语句的结构。用户可以设置"?"的值，但是不能改变sql语句的结构，因此想在sql语句后面加上如“or 1=1”实现sql注入是行不通的。
3.3 PreparedStatement的使用
3.3.1 PreparedStatement介绍
-
可以通过调用 Connection 对象的 preparedStatement(String sql) 方法获取 PreparedStatement 对象
-
PreparedStatement 接口是 Statement 的子接口，它表示一条预编译过的 SQL 语句
-
PreparedStatement 对象所代表的 SQL 语句中的参数用问号(?)来表示，调用 PreparedStatement 对象的 setXxx() 方法来设置这些参数. setXxx() 方法有两个参数，第一个参数是要设置的 SQL 语句中的参数的索引(从 1 开始)，第二个是设置的 SQL 语句中的参数的值
3.3.2 PreparedStatement vs Statement
-
代码的可读性和可维护性。
-
PreparedStatement 能最大可能提高性能：
- DBServer会对预编译语句提供性能优化。因为预编译语句有可能被重复调用，所以语句在被DBServer的编译器编译后的执行代码被缓存下来，那么下次调用时只要是相同的预编译语句就不需要编译，只要将参数直接传入编译过的语句执行代码中就会得到执行。
- 在statement语句中,即使是相同操作但因为数据内容不一样,所以整个语句本身不能匹配,没有缓存语句的意义.事实是没有数据库会对普通语句编译后的执行代码缓存。这样每执行一次都要对传入的语句编译一次。
- (语法检查，语义检查，翻译成二进制命令，缓存)
-
PreparedStatement 可以防止 SQL 注入
3.3.3 Java与SQL对应数据类型转换表
| Java类型 | SQL类型 |
|---|---|
| boolean | BIT |
| byte | TINYINT |
| short | SMALLINT |
| int | INTEGER |
| long | BIGINT |
| String | CHAR,VARCHAR,LONGVARCHAR |
| byte array | BINARY , VAR BINARY |
| java.sql.Date | DATE |
| java.sql.Time | TIME |
| java.sql.Timestamp | TIMESTAMP |
3.3.4 使用PreparedStatement实现增、删、改操作
//通用的增、删、改操作（体现一：增、删、改 ； 体现二：针对于不同的表）
public void update(String sql,Object ... args){
Connection conn = null;
PreparedStatement ps = null;
try {
//1.获取数据库的连接
conn = DBUtilsUtils.getConnection();
//2.获取PreparedStatement的实例 (或：预编译sql语句)
ps = conn.prepareStatement(sql);
//3.填充占位符
for(int i = 0;i < args.length;i++){
ps.setObject(i + 1, args[i]);
}
//4.执行sql语句
ps.execute();
} catch (Exception e) {
e.printStackTrace();
}finally{
//5.关闭资源
DBUtilsUtils.closeResource(conn, ps);
}
}
3.3.5 使用PreparedStatement实现查询操作
statement = conn.prepareStatement(sql);
statement.setInt(1,1);
resultSet = statement.executeQuery();
2、反射高级应用
// 通用的针对于不同表的查询:返回一个对象 (version 1.0)
public <T> T getInstance(Class<T> clazz, String sql, Object... args) {
Connection conn = null;
PreparedStatement ps = null;
ResultSet rs = null;
try {
// 1.获取数据库连接
conn = DBUtilsUtils.getConnection();
// 2.预编译sql语句，得到PreparedStatement对象
ps = conn.prepareStatement(sql);
// 3.填充占位符
for (int i = 0; i < args.length; i++) {
ps.setObject(i + 1, args[i]);
}
// 4.执行executeQuery(),得到结果集：ResultSet
rs = ps.executeQuery();
// 5.得到结果集的元数据：ResultSetMetaData
ResultSetMetaData rsmd = rs.getMetaData();
// 6.1通过ResultSetMetaData得到columnCount,columnLabel；通过ResultSet得到列值
int columnCount = rsmd.getColumnCount();
if (rs.next()) {
T t = clazz.newInstance();
for (int i = 0; i < columnCount; i++) {// 遍历每一个列
// 获取列值
Object columnVal = rs.getObject(i + 1);
// 获取列的别名:列的别名，使用类的属性名充当
String columnLabel = rsmd.getColumnLabel(i + 1);
// 6.2使用反射，给对象的相应属性赋值
Field field = clazz.getDeclaredField(columnLabel);
field.setAccessible(true);
field.set(t, columnVal);
}
return t;
}
} catch (Exception e) {
e.printStackTrace();
} finally {
// 7.关闭资源
DBUtilsUtils.closeResource(conn, ps, rs);
}
return null;
}
说明：使用PreparedStatement实现的查询操作可以替换Statement实现的查询操作，解决Statement拼串和SQL注入问题。
第6章： 数据库事务
6.1 DBUtils事务处理
-
数据一旦提交，就不可回滚。
-
数据什么时候意味着提交？
- 当一个连接对象被创建时，默认情况下是自动提交事务：每次执行一个 SQL 语句时，如果执行成功，就会向数据库自动提交，而不能回滚。
- 关闭数据库连接，数据就会自动的提交。如果多个操作，每个操作使用的是自己单独的连接，则无法保证事务。即同一个事务的多个操作必须在同一个连接下。
-
DBUtils程序中为了让多个 SQL 语句作为一个事务执行：
- 调用 Connection 对象的 setAutoCommit(false); 以取消自动提交事务
- 在所有的 SQL 语句都成功执行后，调用 commit(); 方法提交事务
- 在出现异常时，调用 rollback(); 方法回滚事务
若此时 Connection 没有被关闭，还可能被重复使用，则需要恢复其自动提交状态 setAutoCommit(true)。尤其是在使用数据库连接池技术时，执行close()方法前，建议恢复自动提交状态。
【案例：用户AA向用户BB转账100】
public void testDBUtilsTransaction() {
Connection conn = null;
try {
// 1.获取数据库连接
conn = DBUtilsUtils.getConnection();
// 2.开启事务
conn.setAutoCommit(false);
// 3.进行数据库操作
String sql1 = "update user_table set balance = balance - 100 where user = ?";
update(conn, sql1, "AA");
// 模拟网络异常
//System.out.println(10 / 0);
String sql2 = "update user_table set balance = balance + 100 where user = ?";
update(conn, sql2, "BB");
// 4.若没有异常，则提交事务
conn.commit();
} catch (Exception e) {
e.printStackTrace();
// 5.若有异常，则回滚事务
try {
conn.rollback();
} catch (SQLException e1) {
e1.printStackTrace();
}
} finally {
try {
//6.恢复每次DML操作的自动提交功能
conn.setAutoCommit(true);
} catch (SQLException e) {
e.printStackTrace();
}
//7.关闭连接
DBUtilsUtils.closeResource(conn, null, null);
}
}
浙公网安备 33010602011771号