JDBC编程基础
- JDBC是什么？
Java DateBase Connectivity（Java语言连接数据库） - JDBC的本质是什么？
JDBC 是SUN公司制定的一套接口（interface）。
面向接口调用、面向接口写实现类，这都属于面向接口编程。
为什么要面向接口编程？
解耦合，降低程序的耦合度，提高程序的扩展力。
多态机制就是非常典型的：面向抽象编程。 - JDBC编程六步？
1.注册驱动
2. 获取连接
3.获取数据库操作对象 /获取可编译的数据库操作对象
4.执行SQL语句（DQL语句或者DML语句）
5.查询结果集 （若第四步执行DML语句，则跳过本步骤）
6.释放资源 - 有关mysql-connector-java-x.x.xx-bin.jar的配置
1.当使用文本编辑器如Notepad++等编写简单程序时
要配置环境变量classpath具体如下图：
2. 使用编程工具则不用配置classpath路径直接引入jar包即可：
点击项目名（模块名）–>Open Modules Setting(或者快捷键F4）–>Libraries -->点➕---->选Java（后期可以使用Maven）再选路径—>点击Apply—>点击OK。
- 什么叫SQL注入？
程序发送sql语句给DBMS，DBMS进行sql编译。正好将用户提供的“非法信息”编译进去，导致了原sql语句的含义被扭曲。（用户的非法信息参与到SQL语句的编译中）。要知道SQL注入并不是因为用户提供的信息中含有SQL语句的关键字，而是其参与了原SQL语句的编译所导致的。参见我上传的TestJDBC包中的TestJDBC06（使用IDEA工具）。
package com.bjpowernode.jdbc;
import java.sql.*;
import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;
/*
1.需求：
模拟用户登录功能的实现
2.业务描述：
程序运行时，提供一个输入的入口，可以让用户输入用户名和密码
用户输入用户名和密码之后，提交信息，Java程序收集到用户信息
Java程序连接数据库验证用户名和密码是否合法
合法：显示登录成功
不合法：显示登录失败
3.数据的准备：
在实际开发中，表的设计会使用专业的建模工具，我们这里安装一个建模工具：PowerDesigner
使用PD工具进行数据库表的设计。（参见user_login.sql脚本）。
4. 当前程序存在的问题：
用户名:da
密码:da' or '1' ='1
da
da' or '1' ='1
登录成功
这种现象被称为SQL注入。（黑客经常使用）
5. 导致SQL注入的根本原因？
用户输入的信息中含有sql语句的关键字，并且这些关键字参与sql语句的编译过程。
导致sql语句的愿意被扭曲，进而达到sql注入的效果。
*/
public class TestJDBC06 {
public static void main(String[] args) {
//初始化一个界面
Map<String,String> userLoginInfo = initUI();
System.out.println(userLoginInfo.get("loginName"));
System.out.println(userLoginInfo.get("loginPwd"));
//验证用户名和密码
boolean loginSuccess = login(userLoginInfo);
//最后输出结果
System.out.println(loginSuccess ? "登录成功" : "登录失败");
}
/**
*
* @param userLoginInfo 用户登录信息
* @return false表示失败，true表示成功
*/
private static boolean login(Map<String,String> userLoginInfo) {
//打标记的意识
boolean loginSuccess = false;
//单独定义变量
String loginName = userLoginInfo.get("loginName");
String loginPwd = userLoginInfo.get("loginPwd");
//JDBC代码
Connection conn = null;
Statement stmt = null;
ResultSet rs = null;
try {
//1.注册驱动
Class.forName("com.mysql.jdbc.Driver");
//2.获取连接
conn = DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/bjpowernode","root","root");
//3.获取数据库操作对象
stmt = conn.createStatement();
//4.执行SQL语句
//String sql = "select * from t_user where loginName = '"+userLoginInfo.get("loginName")+" ' and loginPwd = '"+userLoginInfo.get("loginPwd")+" '"; //写法一
String sql = "select * from t_user where loginName = '"+loginName+"' and loginPwd ='"+loginPwd+"'"; //写法二
//以上语句正好完成sql语句的拼接，以下代码的含义是：发送sql语句给DBMS，DBMS进行sql编译。
//正好将用户提供的“非法信息”编译进去。导致了原sql语句的含义被扭曲。
rs = stmt.executeQuery(sql);
//5.查询结果集
if(rs.next()) {
loginSuccess = true;
}
} catch (Exception e) {
e.printStackTrace();
} finally {
//6.释放资源
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 loginSuccess;
}
/**
* 初始化用户界面
* @return 用户输入的用户名和密码等登录信息
*/
private static Map<String, String> initUI() {
Scanner s = new Scanner(System.in);
System.out.print("用户名:");
String loginName = s.nextLine();
System.out.print("密码:");
String loginPwd = s.nextLine();
Map<String,String> userLoginInfo = new HashMap<>();
userLoginInfo.put("loginName",loginName);
userLoginInfo.put("loginPwd",loginPwd);
return userLoginInfo;
}
}
6. 如何避免SQL注入？
减少动态SQL语句的使用，最好使用准备好的语句和参数化查询。参见我上传的TestJDBC包中的TestJDBC07（使用IDEA工具）。
学习占位符？的使用
package com.bjpowernode.jdbc;
import java.sql.*;
import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;
/**
* 1. 解决SQL注入问题
* 只要用户提供的信息不参与SQL语句的编译过程，问题就解决了。
* 即使用户提供的信息中含有SQL语句的关键字，但是没有参与编译，不起作用。
* 要想用户信息不参与SQL语句的编译，那么必须使用java.sql.PreparedStatement.
* PreparedStatement是属于预编译的数据库操作对象。
* PreparedStatement的原理是：预先对SQL语句的框架进行编译，然后再给SQL语句传“值”。
* 2. 测试结果：
* 用户名:da
* 密码:da' or '1'='1
* da
* da' or '1'='1
* 登录失败
* 3. 解决SQL注入的关键是什么？
* 用户提供的信息中即使含有SQL语句的关键字，但是这些关键字并没有参与编译，不起作用。
* 4. 对比一下Statement和PreparedStatement？
* - Statement存在SQL注入问题，PreparedStatement解决了SQL注入问题。
* - Statement是编译一次执行一次，PreparedStatement是编译一次，可执行N次，PreparedStatement的效率较高一些。
* - PreparedStatement会在编译阶段做类型的安全检查。
*
* 综上所述：PreparedStatement使用较多，只有极少数情况下需要使用Statement
* 5. 什么情况下必须使用Statement呢？
* 业务方面要求必须支持SQL注入的时候。
* Statement支持SQL注入，凡是业务方面需要进行SQL语句拼接的，必须使用Statement.
*
*
*/
public class TestJDBC07 {
public static void main(String[] args) {
//初始化一个界面
Map<String,String> userLoginInfo = initUI();
System.out.println(userLoginInfo.get("loginName"));
System.out.println(userLoginInfo.get("loginPwd"));
//验证用户名和密码
boolean loginSuccess = login(userLoginInfo);
//最后输出结果
System.out.println(loginSuccess ? "登录成功" : "登录失败");
}
/**
*
* @param userLoginInfo 用户登录信息
* @return false表示失败，true表示成功
*/
private static boolean login(Map<String,String> userLoginInfo) {
//打标记的意识
boolean loginSuccess = false;
//单独定义变量
String loginName = userLoginInfo.get("loginName");
String loginPwd = userLoginInfo.get("loginPwd");
//JDBC代码
Connection conn = null;
PreparedStatement ps = null; //这里使用预编译的数据库对象PreparedStatement
ResultSet rs = null;
try {
//1.注册驱动
Class.forName("com.mysql.jdbc.Driver");
//2.获取连接
conn = DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/bjpowernode","root","root");
//3.获取预编译的数据库操作对象
//SQL语句框架，其中一个？，表示一个占位符，一个？将来接受一个“值”，注意占位符不能使用单引号括起来。
String sql = "select * from t_user where loginName = ? and loginPwd = ? ";
//程序执行到此处，会发送SQL语句框架给DBMS，然后DBMS进行SQL语句的预先编译。
ps = conn.prepareStatement(sql);
//给占位符？传值（第1个问号的下标是1，第二个问号的下标是2，JDBC中所有的下标从1开始。
ps.setString(1,loginName);
ps.setString(2,loginPwd);
//4.执行SQL语句
rs = ps.executeQuery();
//5.查询结果集
if(rs.next()) {
loginSuccess = true;
}
} catch (Exception e) {
e.printStackTrace();
} finally {
//6.释放资源
if(rs != null) {
try {
rs.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
if(ps != null) {
try {
ps.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
if(conn != null) {
try {
conn.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
return loginSuccess;
}
/**
* 初始化用户界面
* @return 用户输入的用户名和密码等登录信息
*/
private static Map<String, String> initUI() {
Scanner s = new Scanner(System.in);
System.out.print("用户名:");
String loginName = s.nextLine();
System.out.print("密码:");
String loginPwd = s.nextLine();
Map<String,String> userLoginInfo = new HashMap<>();
userLoginInfo.put("loginName",loginName);
userLoginInfo.put("loginPwd",loginPwd);
return userLoginInfo;
}
}
- 这么说来，是不是以后都使用PreparedStatement而不使用Statement？
存在即合理，有些情况是需要SQL注入进行数据库的拼接如商品信息的升降序排列等，所以Statement并不是一无是处。参见我上传的TestJDBC包中的TestJDBC07（使用IDEA工具）。
package com.bjpowernode.jdbc;
import java.sql.*;
import java.util.Scanner;
/**
* @Author Hasee
* @Date 2020/4/29 23:06
* @Version 1.0
*/
public class TestJDBC08 {
//使用PreparedStatement进行演示，结果显示错误。
/*public static void main(String[] args) {
//用户在控制台输入desc就是降序，输入asc就是升序
Scanner s = new Scanner(System.in);
System.out.println("输入desc或者asc，desc表示降序，asc表示升序");
System.out.print("请输入：");
String keywords = s.nextLine();
//执行SQL
Connection conn = null;
PreparedStatement ps = null;
ResultSet rs = null;
try {
//1.注册驱动
Class.forName("com.mysql.jdbc.Driver");
//2.获取连接
conn = DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/bjpowernode","root","root");
//3.获取预编译的数据库操作对象
String sql = "select ename from emp order by ename ?";
ps = conn.prepareStatement(sql);
ps.setString(1,keywords);
//4.执行SQL语句
rs = ps.executeQuery();
//5.处理查询结果集
while(rs.next()) {
System.out.println(rs.getString("ename"));
}
} catch (Exception e) {
e.printStackTrace();
} finally {
//6.释放资源
if(rs != null) {
try {
rs.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
if(ps != null) {
try {
ps.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
if(conn != null) {
try {
conn.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
}*/
public static void main(String[] args) {
//用户在控制台输入desc就是降序，输入asc就是升序
Scanner s = new Scanner(System.in);
System.out.println("输入desc或者asc，desc表示降序，asc表示升序");
System.out.print("请输入：");
String keywords = s.nextLine();
//执行SQL
Connection conn = null;
Statement stmt = null;
ResultSet rs = null;
try {
//1.注册驱动
Class.forName("com.mysql.jdbc.Driver");
//2.获取连接
conn = DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/bjpowernode","root","root");
//3.获取数据库操作对象
stmt = conn.createStatement();
//4.执行SQL语句
String sql = "select ename from emp order by ename "+ keywords;
rs = stmt.executeQuery(sql);
//5.处理查询结果集
while(rs.next()) {
System.out.println(rs.getString("ename"));
}
} catch (Exception e) {
e.printStackTrace();
} finally {
//6.释放资源
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();
}
}
}
}
}
- JDBC中事务的重要性？
JDBC编程中事务具有重要意义，现实中的项目往往需要多条DML同时成功或失败，才算完成一个简单的功能。参见我上传的TestJDBC包中的TestJDBC11（使用IDEA工具）
实现事务的几条重要语句？
conn.setAutoCommit(false); //开启事务
conn.commit(); //提交事务
conn.rollback(); //回滚事务
package com.bjpowernode.jdbc;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.SQLException;
/**
* @Author Hasee
* @Date 2020/4/30 8:36
* @Version 1.0
*
* sql脚本：
* drop table if exists t_act;
* create table t_act(
* actno int,
* balance double(7,2) //注意：7表示有效数字的个数，2表示小数位的个数
* );
* insert into t_act(actno,balance) values(111,20000);
* insert into t_act(actno,balance) values(222,0);
* commit;
* select * from t_act;
*/
public class TestJDBC11 {
public static void main(String[] args) {
Connection conn = null;
PreparedStatement ps = null;
try {
//1.注册驱动
Class.forName("com.mysql.jdbc.Driver");
//2.获取连接
conn = DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/bjpowernode","root","root");
// 将自动提交机制修改为手动提交
conn.setAutoCommit(false); //开启事务
//3.获取预编译的数据库操作对象-----update
String sql = "update t_act set balance = ? where actno = ?";
ps = conn.prepareStatement(sql);
//第一次给占位符传值
ps.setDouble(1,10000);
ps.setInt(2,111);
int count = ps.executeUpdate();
//人为制造空指针异常，模拟银行转账被打断
/*String s = null;
s.toString();*/
//重新给占位符传值
ps.setDouble(1,10000);
ps.setInt(2,222);
count += ps.executeUpdate();
System.out.println(count == 2 ? "转账成功" :"转账失败");
//程序能够走到这里说明以上程序没有异常，事务结束，手动提交数据
conn.commit(); //提交事务
} catch (Exception e) {
//回滚事务
if(conn != null) {
try {
conn.rollback();
} catch (SQLException e1) {
e1.printStackTrace();
}
}
e.printStackTrace();
} finally {
//6.释放资源
if(ps != null) {
try {
ps.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
if(conn != null) {
try {
conn.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
}
}
-
JDBC工具类的封装？
将JDBC中常见的代码块封装成方法，方便编程使用。参见我上传的TestJDBC包中的utils工具包（使用IDEA工具）。方法参见动力节点杜老师 -
悲观锁（行级锁）和乐观锁
悲观锁：又叫行级锁。事务必须排队，数据被锁死，不允许并发（悲观锁/行级锁：select语句后添加 for update)
乐观锁：支持并发，事务不用排队，但是每个事务要检测版本号，不一致则该事务回滚。
悲观锁简单例子：参见我上传的TestJDBC包中的TestJDBC13和TestJDBC14一起执行（使用IDEA工具）。
乐观锁常见于分布式项目中，以后可能会补充，先有所了解即可。
- 上传资源的相关说明？
所有代码相关部分均是本人手敲，因工具版本或人为原因难免有所不足和缺失，请大家参考。
从TestJDBC01-TestJDBC05都是在Notepad++上编写程序。
在IDEA上编写TestJDBC06时，发现SQL注入问题，往后编写TestJDBC07-Test JDBC12均解决了SQL注入问题，TestJDBC13-Test JDBC14一起演示行级锁/悲观锁。
注：本文及上传的相关文件均是参考动力节点杜聚宾老师的视频，由本人亲自整理，供大家相互学习使用。
