0 前言
Java为关系数据库定义了一套规范的拜访接口:JDBC(Java Database Connectivity),使咱们能够基于JDBC拜访数据库,实现数据的增删改查。
本文将以PostgreSQL为例,展现JDBC的一些基本操作,其中以实操代码为主,对于基本概念的解说详见参考文献。
提醒:在开始学习JDBC编程之前,务必先学习下SQL根底。
1 配置MAVEN
<dependency>
<groupId>org.postgresql</groupId>
<artifactId>postgresql</artifactId>
<version>42.2.18</version>
<scope>runtime</scope>
</dependency>
<dependency>
<groupId>com.zaxxer</groupId>
<artifactId>HikariCP</artifactId>
<version>3.4.5</version>
</dependency>
配置项包含两个jar包:
1、postgresql:PostgreSQL的JDBC驱动
2、HikariCP:JDBC连接池(javax.sql.DataSource)的实现类
留神:
postgresql中的scope应该为runtime,因为只在运行期才应用。如果把runtime
改成compile
,尽管也能失常编译,然而在IDE里写程序的时候,会多进去一大堆相似com.mysql.jdbc.Connection
这样的类,非常容易与Java规范库的JDBC接口混同,所以坚定不要设置为compile
。
2 连贯数据库
import java.sql.*;
public class Test {
// JDBC连贯的URL, 不同数据库有不同的格局:
static final String URL = "jdbc:postgresql://localhost:3306/test";
static final String USER = "sde";
static final String PASSWORD = "123456";
public static void main(String[] args) {
// 获取连贯:
try (Connection conn = DriverManager.getConnection(URL, USER, PASSWORD)) {
System.out.println("数据库连贯胜利!");
}catch(SQLException e){
e.printStackTrace();
}
}
}
外围代码是DriverManager
提供的静态方法getConnection()
。DriverManager
会主动扫描classpath,找到所有的JDBC驱动,而后依据咱们传入的URL主动筛选一个适合的驱动。因为JDBC连贯是一种低廉的资源,所以应用后要及时开释(通过try-with-resources的形式)。
留神:代码中的URL
、USER
、PASSWORD
是数据库的信息,填写你本人的。
3 创立表
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement;
public class Test {
// 不同数据库有不同的格局
static final String URL = "jdbc:postgresql://localhost:3306/test";
static final String USER = "sde";
static final String PASSWORD = "123456";
public static void main(String[] args) {
// 获取连贯:
try (Connection conn = DriverManager.getConnection(URL, USER, PASSWORD)) {
// Statement对象用于执行SQL语句
try (Statement stmt = conn.createStatement()) {
String sql = "CREATE TABLE public.javaBuild" +
" (id serial PRIMARY KEY NOT NULL," +
" name text ," +
" age int," +
" gender char(1))";
stmt.executeUpdate(sql);
}
System.out.println("JAVA建表胜利!");
}catch(SQLException e){
e.printStackTrace();
}
}
}
Postgre 中主键设定为serial类型,在后续插入时,主键就会自增。
4 增删改查
import java.sql.*;
public class Test {
// 不同数据库有不同的格局
static final String URL = "jdbc:postgresql://localhost:3306/test";
static final String USER = "sde";
static final String PASSWORD = "123456";
public static void main(String[] args) {
// 获取连贯:
try (Connection conn = DriverManager.getConnection(URL, USER, PASSWORD)) {
// Statement对象用于执行SQL语句
try (Statement stmt = conn.createStatement()) {
// 插入
String sql = "INSERT INTO public.javaBuild (name,age,gender) VALUES ('Tom',12,'M'),('Ming',13,'W'),('Wang',12,'M')";
stmt.executeUpdate(sql);
// 删除
String delete = "DELETE FROM public.javaBuild WHERE name='Tom'";
stmt.executeUpdate(delete);
// 查问
String query= "SELECT * FROM public.javaBuild";
try (ResultSet rs = stmt.executeQuery(query)) {
while (rs.next()) {
System.out.println(rs.getInt("id") + rs.getString("name") + rs.getInt("age") + rs.getInt("gender"));
}
}
}
}catch(SQLException e){
e.printStackTrace();
}
}
}
留神:
Statment
和ResultSet
都是须要敞开的资源。- 数据库的索引是从1开始,而不是0。
应用Statement
拼字符串非常容易引发SQL注入的问题,这是因为SQL参数往往是从办法参数传入的(案例详见参考文献2)。因而,应用Java对数据库进行操作时,必须应用PreparedStatement,严禁任何通过参数拼字符串的代码!
具体代码如下:
import java.sql.*;
public class Test {
// JDBC连贯的URL, 不同数据库有不同的格局:
static final String URL = "jdbc:postgresql://localhost:3306/test";
static final String USER = "sde";
static final String PASSWORD = "123456";
public static void main(String[] args) {
// 初始化须要插入的数据
Student[] students=new Student[]{new Student("Tom",12,"M"),
new Student("Ming",13,"W"),new Student("Wang",12,"M")};
// 获取连贯:
try (Connection conn = DriverManager.getConnection(URL, USER, PASSWORD)) {
// 插入,其中?示意占位符
try (PreparedStatement ps = conn.prepareStatement("INSERT INTO public.javaBuild (name,age,gender) VALUES (?,?,?)")) {
// 对同一个PreparedStatement重复设置参数并调用addBatch():
for (Student student:students){
// 设置对应占位符的值
ps.setObject(1,student.getName());
ps.setObject(2,student.getAge());
ps.setObject(3,student.getGender());
// 将每个残缺的插入语句放进Batch
ps.addBatch();
}
// 执行batch:
int[] ns = ps.executeBatch();
for (int n : ns) {
// batch中每个SQL执行的后果数量
System.out.println(n + " has been inserted.");
}
}
// 删除
try (PreparedStatement ps = conn.prepareStatement("DELETE FROM public.javaBuild WHERE name='Tom'")) {
int n = ps.executeUpdate();
System.out.println(n + " has been deleted.");
}
// 查问
try (PreparedStatement ps = conn.prepareStatement("SELECT * FROM public.javaBuild")) {
try (ResultSet rs = ps.executeQuery()) {
while (rs.next()) {
System.out.println(rs.getInt("id") + rs.getString("name") + rs.getInt("age")+rs.getString("gender"));
}
}
}
}catch(SQLException e){
e.printStackTrace();
}
}
}
class Student{
private String name;
private int age;
private String gender;
public Student(String name, int age, String gender) {
this.name = name;
this.age = age;
this.gender = gender;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getGender() {
return gender;
}
public void setGender(String gender) {
this.gender = gender;
}
}
5 事务
在执行SQL语句的时候,某些业务要求,一系列操作必须全副执行,而不能仅执行一部分。
package com.navinfo.csu.domain.broker.htf.jdbcTest;
import scala.xml.Null;
import java.sql.*;
public class Test {
// JDBC连贯的URL, 不同数据库有不同的格局:
static final String URL = "jdbc:postgresql://localhost:3306/test";
static final String USER = "sde";
static final String PASSWORD = "123456";
public static void main(String[] args) throws SQLException {
Connection conn = null;
Savepoint savepoint =null;
try{
// 获取连贯
conn = DriverManager.getConnection(URL, USER, PASSWORD);
// 设定隔离级别
conn.setTransactionIsolation(Connection.TRANSACTION_READ_COMMITTED);
// 敞开主动提交,相当于SQL语句中的BEGAIN
conn.setAutoCommit(false);
// 插入操作1
try (PreparedStatement ps = conn.prepareStatement("INSERT INTO public.javaBuild (name,age,gender) VALUES ('Huang',12,'M')")) {
ps.executeUpdate();
}
// 设置保留点
savepoint = conn.setSavepoint("Savepoint");
// 插入操作2
try (PreparedStatement ps = conn.prepareStatement("INSERT INTO public.javaBuild (name,age,gender) VALUES ('Dong',12,11111)")) {
ps.executeUpdate();
}
// 提交事务
conn.commit();
// 查问
try (PreparedStatement ps = conn.prepareStatement("SELECT * FROM public.javaBuild")) {
try (ResultSet rs = ps.executeQuery()) {
while (rs.next()) {
System.out.println(rs.getInt("id") + rs.getString("name") + rs.getInt("age")+rs.getString("gender"));
}
}
}
}catch(SQLException e){
e.printStackTrace();
// 回滚事务
if (conn != null){
conn.rollback(savepoint);
}
}finally {
if (conn != null) {
conn.setAutoCommit(true);
conn.close();
}
}
}
}
默认状况下,咱们获取到Connection
连贯后,总是处于“主动提交”模式,也就是每执行一条SQL都是作为事务主动执行的,即默认为“隐式事务”。只有敞开了Connection
的autoCommit
,那么就能够在一个事务中执行多条语句,事务以commit()
办法完结。
MySQL的默认隔离级别是REPEATABLE READ
。
setSavepoint()
能够记录保留点,当出现异常时,能够回滚到指定的保留点。
6 连接池
在执行JDBC的增删改查的操作时,如果每一次操作都来一次关上连贯,操作,敞开连贯,那么创立和销毁JDBC连贯的开销就太大了。为了防止频繁地创立和销毁JDBC连贯,咱们能够通过连接池(Connection Pool)复用曾经创立好的连贯。
JDBC连接池有一个规范的接口javax.sql.DataSource
,留神这个类位于Java规范库中,但仅仅是接口。要应用JDBC连接池,咱们必须抉择一个JDBC连接池的实现。罕用的JDBC连接池有:
- HikariCP
- C3P0
- BoneCP
- Druid
目前应用最宽泛的是HikariCP,代码案例如下:
import com.zaxxer.hikari.HikariConfig;
import com.zaxxer.hikari.HikariDataSource;
import javax.sql.DataSource;
import java.sql.*;
public class Test {
// JDBC连贯的URL, 不同数据库有不同的格局:
static final String URL = "jdbc:postgresql://localhost:3306/test";
static final String USER = "sde";
static final String PASSWORD = "123456";
static public HikariConfig config = new HikariConfig();
public static void main(String[] args) {
// 初始化连接池
config.setJdbcUrl(URL);
config.setUsername(USER);
config.setPassword(PASSWORD);
config.addDataSourceProperty("connectionTimeout", "1000"); // 连贯超时:1秒
config.addDataSourceProperty("idleTimeout", "60000"); // 闲暇超时:60秒
config.addDataSourceProperty("maximumPoolSize", "10"); // 最大连接数:10
DataSource ds = new HikariDataSource(config);
// 获取连贯,把DriverManage.getConnection()改为ds.getConnection()
try (Connection conn = ds.getConnection()) {
// 查问
try (PreparedStatement ps = conn.prepareStatement("SELECT * FROM public.javaBuild")) {
try (ResultSet rs = ps.executeQuery()) {
while (rs.next()) {
System.out.println(rs.getInt("id") + rs.getString("name") + rs.getInt("age")+rs.getString("gender"));
}
}
}
}catch(SQLException e){
e.printStackTrace();
}
}
}
当咱们调用conn.close()
办法时(在try(resource){...}
完结处),不是真正“敞开”连贯,而是开释到连接池中,以便下次获取连贯时能间接返回。
因而,连接池外部保护了若干个Connection
实例,如果调用ds.getConnection()
,就抉择一个闲暇连贯,并标记它为“正在应用”而后返回,如果对Connection
调用close()
,那么就把连贯再次标记为“闲暇”从而期待下次调用。这样一来,咱们就通过连接池保护了大量连贯,但能够频繁地执行大量的SQL语句。
7 参考目录
【1】菜鸟教程:https://www.runoob.com/postgr…
【2】廖雪峰的官方网站:https://www.liaoxuefeng.com/w…