乐趣区

关于java:JAVA基础JDBC编程基于JAVA访问数据库

jiezi

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…

退出移动版