JDBC相关知识

一、连接数据库

1. 步骤

//1.创建一个Driver实现类的对象
Driver driver = new com.mysql.jdbc.Driver();//注意抛异常

//2.准备 url 和 info
String url = "jdbc:mysql://localhost:3306/test";
//Oracle:"jdbc:oracle:thin:@localhost:1512:sid"
//SQLServer:"jdbc:microsoft:sqlserver//localhost:1433:DatabaseName=sid"
//MySql:"jdbc:mysql://localhost:3306/sid"

Properties info = new Properties();
info.put("user", "root");
info.put("password","1230");

//3.获取连接
Connection connection = driver.connect(url, info);//注意抛异常

2. 获取Driver的方式

• 通过new新建  ：Driver driver = new com.mysql.jdbc.Driver();
• 通过反射创建类的实例  ：Driver driver = (Driver)Class.forName(driverClass).newInstance();　　//driverClass为全类名，即 com.mysql.jdbc.Driver
• 通过DriverManager获取数据库连接（加载数据库驱动程序 即 注册驱动）  ：DriverManager.registerDriver(Class.forName(driverClass).newInstance());   可简化为 Class.forName(driverClass); 可加载多个驱动

  //加载数据库驱动程序 (可加载多个驱动程序)（注册驱动）
  //DriverManager.registerDriver(Class.forName(driverClass).newInstance());
  Class.forName(driverClass);
  Class.forName(driverClass2);
  
  //通过getConnection方法获得连接
  //getConnection(String url, String user, String password) throws SQLException
  Connection connection = DriverManager.getConnection(jdbcUrl, user, password);

3. 提取方法来获得Connection

实现方式：把URL、账号、密码等信息放入 jdbc.properties 文件，通过反射获取

public class Utils {
    public Connection getConnection() throws Exception {
        String driverClass = null;
        String jdbcUrl = null;
        String user = null;
        String password = null;

        // 读取类路径下的jdbc.properties文件
        InputStream in = getClass().getClassLoader().getResourceAsStream("jdbc.properties");
        Properties properties = new Properties();
        properties.load(in);
        driverClass = properties.getProperty("driver");
        jdbcUrl = properties.getProperty("jdbcUrl");
        user = properties.getProperty("user");
        password = properties.getProperty("password");

/*        // 通过反射创建类的实例
        Driver driver = (Driver) Class.forName(driverClass).newInstance();

        Properties info = new Properties();
        info.put("user", user);
        info.put("password", password);
        Connection connection = driver.connect(jdbcUrl, info);*/

        Class.forName(driverClass);
        Connection connection = DriverManager.getConnection(jdbcUrl, user, password);

        return connection;
    }

}

aaarticlea/png;base64,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" alt="" />

二、数据库操作

前提：连接数据库的前提下，才能进行操作

1. 执行更新操作 （插入、修改、删除 ）

//1.获得连接
Connection conn = driver.connect(url, info);
String sql="...";     //sql语句

//2.获取statement对象
Statement statement = conn.createStatement();

//3.执行
statement.executeUpdate(sql);

//4.关闭
statement.close();
conn.close();

2. 查询操作

//1.通过连接获得statement对象
Statement statement = conn.createStatement();
String sql = "...";

//2.执行
ResultSet rs = statement.executeQuery(sql);

//3.遍历输出
while(rs.next()){
     int id = rs.getInt(1);
     String name = rs.getString("name");
}

//4.关闭
rs.close();
statement.close();
conn.close();

3. 给SQL语句设置参数——PreparedStatement

父类：Statement

//1.通过连接获得preparedStatement对象
String sql = "insert into customers (name, email, birth) values(?,?,?)";
preparedStatement = conn.prepareStatement(sql);　　//与无参的Statement对象不同，获得对象时就得传入sql语句，执行语句时不用再传入sql语句

//2.设置参数
preparedStatement.setString(1, "zhangsan");
preparedStatement.setString(2, "77777@qq.com");
preparedStatement.setDate(3, new Date(new java.util.Date().getTime()));

//3.执行
preparedStatement.executeUpdate();

//4.获得ResultSet
ResultSet rs = preparedStatement.getResultSet();

获取插入记录的主键值

实现方式：使用重载的preparedStatement(sql, flag)来生成preparedStatement对象

preparedStatement = conn.preparedStatement(sql, Statement.RETURN_GENERATED_KEYS);

//生成的结果集里只有一列，即主键编号
ResultSet rs = preparedStatement.getGeneratedKeys();
if(rs.next()){

    //获得主键
    String generatedKey = rs.getObject(1);

}

4. 调用函数&存储过程——CallableStatement

父类：Statement

// 1. 通过 Connection 对象的 prepareCall()方法创建一个 CallableStatement 对象的实例。
//sql字符串指明如何调用存储过程：?=call name(param, ..., param) 或 callname(param, ..., param)
String sql = "{?= call sum_salary(?, ?)}";
CallableStatement callableStatement = connection.prepareCall(sql);

// 2. 通过 CallableStatement 对象的 reisterOutParameter() 方法注册 OUT 参数。
callableStatement.registerOutParameter(1, Types.NUMERIC);
callableStatement.registerOutParameter(3, Types.NUMERIC);

// 3. 通过 CallableStatement 对象的 setXxx() 方法设定 IN 或 IN OUT 参数。
//若想将参数默认值设为null, 可以使用 setNull() 方法。
callableStatement.setInt(2, 80);

// 4. 通过 CallableStatement 对象的 execute() 方法执行存储过程。
callableStatement.execute();

// 5. 如果所调用的是带返回参数的存储过程, 还需要通过 CallableStatement 对象的 getXxx() 方法获取其返回值。
double sumSalary = callableStatement.getDouble(1);
long empCount = callableStatement.getLong(3);

三、JDBC元数据

1. ResultSetMetaData

方法签名：ResultSetMetaData getMetaData()       //通过 resultSet.getMetaData() 方法获得 ResultSetMetaData 对象

int getColumnCount()                            //查询结果集中的列数

String getColumnName(int colum)        //获取查询结果集中指定的列别名，从1开始

String getColumnLabel(int colum)         //获取查询结果集中指定的列别名，从1开始

    //在数据库中查询记录，转换成与表相对应的实体类对象
    public <T> T get(Class<T> clazz, String sql, Object... args) throws Exception {
        T entity = null;

        Connection connection = null;
        PreparedStatement preparedStatement = null;
        ResultSet resultSet = null;

        //1.获得connection
        connection = getConnection();

        //2.设置参数
        preparedStatement = connection.prepareStatement(sql);
        for (int i = 0; i < args.length; i++) {
            preparedStatement.setObject(i + 1, args[i]);
        }

        //3.执行，并获得resultSet
        resultSet = preparedStatement.executeQuery();

        //4.通过resultSet获得resultSetMetaData
        ResultSetMetaData resultSetMetaData = resultSet.getMetaData();

        Map<String, Object> values = new HashMap<>();
        if (resultSet.next()) {
            //5.把结果放入哈希表中
            for (int i = 0; i < resultSetMetaData.getColumnCount(); i++) {
                String columnLabel = resultSetMetaData.getColumnLabel(i + 1);
                Object columnValue = resultSet.getObject(i + 1);

                values.put(columnLabel, columnValue);
            }
            
            //6.为相应实体类对象设置属性值
            if(values.size() > 0){
                entity = clazz.newInstance();
                for(Map.Entry<String, Object> entry: values.entrySet()){
                    String fieldName = entry.getKey();
                    Object value = entry.getValue();

                    BeanUtils.setProperty(entity, fieldName, value);//需要使用beanutils工具包
                }
            }
        }
        return entity;
    }

2. DatabaseMetaData

方法签名：DatabaseMetaData getMetaData()      //通过 connection.getMetaData() 方法获得

作用：可以得到数据库本身的一些信息

DatabaseMetaData data = connection.getMetaData();
            //1. 得到数据库的版本号
int version = data.getDatabaseMajorVersion();

//2. 得到连接到数据库的用户名
String user = data.getUserName();

//3. 得到 MySQL 中有哪些数据库
ResultSet resultSet = data.getCatalogs();

四、处理Blob大对象数据

LOB：大对象，存储大量数据的一种数据类型。

BLOB：二进制大对象。

1. 读取 Blob 数据

 实现方式：使用 getBlob 方法读取到 Blob 对象

调用 Blob 的 getBinaryStream() 方法得到输入流。再使用 IO 操作即可。

...
resultSet = preparedStatement.executeQuery();

if(resultSet.next()){
    int id = resultSet.getInt(1);
    String name = resultSet.getString(2);
    String email = resultSet.getString(3);

    //1.获得Blob对象
    Blob picture = resultSet.getBlob(5);

    //2.获得输入流
    InputStream in = picture.getBinaryStream();

    //3.输出到flower.jpg
    OutputStream out = new FileOutputStream("flower.jpg");
    byte [] buffer = new byte[1024];
    int len = 0;
    while((len = in.read(buffer)) != -1){
        out.write(buffer, 0, len);
    }

    in.close();
    out.close();
}

2. 写入Blob数据

作用：实现将本地图片写入数据库

String sql = "INSERT INTO customers(name, email, birth, picture) VALUES(?,?,?,?)";
//通过连接 获得preparedStatement对象
preparedStatement = connection.prepareStatement(sql);

//设置参数
preparedStatement.setString(1, "ABCDE");
preparedStatement.setString(2, "abcde@atguigu.com");
preparedStatement.setDate(3, new Date(new java.util.Date().getTime()));

//1.创建输入流
InputStream inputStream = new FileInputStream("Hydrangeas.jpg");
//2.设置Blob参数
preparedStatement.setBlob(4, inputStream);

preparedStatement.executeUpdate();

五、事务

1. 方法

//取消默认提交后才能进行事务

connection.setAutoCommit(false);　　//取消默认提交并开始事务

//提交事务

connection.commit();

//回滚

connection.rollback();

2. 数据库的隔离级别

• READ UNCOMMITTED　　：读未提交数据，允许事务读取未被其他事务提交的变更，脏读、不可重复读、幻读都会出现。
• READ COMMITTED　　     ：读已提交数据，只允许事务读取已经被其他事务提交的变更。可避免脏读，不可重复读和幻读仍然存在。
• REPEATABLE READ　　    ：可重复读，确保事务可以多次从一个字段中读取相同的值，在这个事务持续期间，禁止其他事务对这个字段进行更新。可避免脏读和不可重复读，幻读问题仍然存在。
• SERIALIZABLE　　　　      ：串行化，确保事务可以从一个表中读取相同的行，在这个事务持续期间，禁止其他事务对该表执行操作，所有并发问题都可避免，但性能低下。

通过Connection的setTransactionIsolation来设置事务的隔离级别。

例：connection.setTransactionIsolation(Connection.TRANSACTION_READ_UNCOMMITTED);

注：mysql的默认隔离级别是REPEATABLE READ。

六、批量处理

方法签名：preparedStatement.addBatch();　　       //加入Batch

preparedStatement.executeBatch();　　//批量处理

preparedStatement.clearBatch();　　    //清除当前的积累量

//批量插入十万条数据
sql = "INSERT INTO customers VALUES(?,?,?)";
preparedStatement = connection.prepareStatement(sql);
Date date = new Date(new java.util.Date().getTime());
for(int i = 0; i < 100000; i++){
    preparedStatement.setInt(1, i + 1);
    preparedStatement.setString(2, "name_" + i);
    preparedStatement.setDate(3, date);

    //"积攒" SQL
    preparedStatement.addBatch();　　//Statement写法：statement.addBatch(String sql);

    //当 "积攒" 到一定程度, 就统一的执行一次. 并且清空先前 "积攒" 的 SQL
    if((i + 1) % 300 == 0){
        preparedStatement.executeBatch();
        preparedStatement.clearBatch();
    }
}

//若总条数不是批量数值的整数倍, 则还需要再额外的执行一次.
if(100000 % 300 != 0){
    preparedStatement.executeBatch();
    preparedStatement.clearBatch();
}

七、数据库连接池

必要性

传统连接使用DriverManager获取，再验证用户名密码，执行完毕再断开连接。数据库的连接资源没有得到很好的重复利用。

数据库连接池负责分配、管理和释放数据库连接，它允许应用程序重复使用一个现有的数据库连接，而不是重新建立一个。

数据库连接池是通过实现DataSource接口来实现的。

1. DBCP

需要2 个jar 包：

• dbcp
• pool

注：dbcp依赖于 pool

final BasicDataSource dataSource = new BasicDataSource();

//1. 为数据源实例指定必须的属性
dataSource.setUsername("root");
dataSource.setPassword("1230");
dataSource.setUrl("jdbc:mysql://localhost:3306/test");
dataSource.setDriverClassName("com.mysql.jdbc.Driver");

//2. 指定数据源的一些可选的属性
//1). 指定数据库连接池中初始化连接数的个数
dataSource.setInitialSize(5);

//2). 指定最大的连接数: 同一时刻可以同时向数据库申请的连接数
dataSource.setMaxActive(5);

//3). 指定小连接数: 在数据库连接池中保存的最少的空闲连接的数量
dataSource.setMinIdle(2);

//4).等待数据库连接池分配连接的最长时间. 单位为毫秒. 超出该时间将抛出异常.
dataSource.setMaxWait(1000 * 5);

//3. 从数据源中获取数据库连接
Connection connection = dataSource.getConnection();

通过DataSourceFactory创建连接池（DataSource），这样可以直接从配置文件中获取信息

//从Properties文件里获得数据
Properties properties = new Properties();
InputStream inStream = DBCPTest.class.getClassLoader().getResourceAsStream("dbcp.properties");
properties.load(inStream);

//使用工厂创建连接池
DataSource dataSource = BasicDataSourceFactory.createDataSource(properties);

aaarticlea/png;base64,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" alt="" width="413" height="186" />

2. C3P0

@Test
public void testC3P0() throws Exception{
    ComboPooledDataSource cpds = new ComboPooledDataSource();
    cpds.setDriverClass( "com.mysql.jdbc.Driver" ); //loads the jdbc driver
    cpds.setJdbcUrl( "jdbc:mysql://localhost:3306/test" );
    cpds.setUser("root");
    cpds.setPassword("1230");

    System.out.println(cpds.getConnection());
}

通过加载配置文件来获得信息

DataSource dataSource = new ComboPooledDataSource("helloc3p0");

dataSource.getConnection();

<!-- 配置文件helloc3p0.xml -->
<?xml version="1.0" encoding="UTF-8"?>
<c3p0-config>
    <named-config name="helloc3p0">

        <!-- 指定连接数据源的基本属性 -->
        <property name="user">root</property>
        <property name="password">1230</property>
        <property name="driverClass">com.mysql.jdbc.Driver</property>
        <property name="jdbcUrl">jdbc:mysql:///atguigu</property>

        <!-- 若数据库中连接数不足时, 一次向数据库服务器申请多少个连接 -->
        <property name="acquireIncrement">5</property>
        <!-- 初始化数据库连接池时连接的数量 -->
        <property name="initialPoolSize">5</property>
        <!-- 数据库连接池中的最小的数据库连接数 -->
        <property name="minPoolSize">5</property>
        <!-- 数据库连接池中的最大的数据库连接数 -->
        <property name="maxPoolSize">10</property>

        <!-- C3P0 数据库连接池可以维护的 Statement 的个数 -->
        <property name="maxStatements">20</property>
        <!-- 每个连接同时可以使用的 Statement 对象的个数 -->
        <property name="maxStatementsPerConnection">5</property>
    </named-config>
</c3p0-config>

八、DBUtils

注：dbutils只是对底层的封装

QueryRunner可能会有线程安全问题，逐一不要创建多个实例

1. update方法

//1.创建QueryRunner实现类
QueryRunner queryRunner = new QueryRunner();
String sql = "DELETE FROM customers WHERE id IN (?,?)";

//2.使用update方法
queryRunner.update(connection, sql, 12, 13);

2. query方法

方法签名：queryRunner.query(Connection connection, String sql, ResultSetHandler rs);

使用：在实现ResultSetHandler接口的类的handle方法中编写对结果集的处理方法。

Object object = queryRunner.query(conn, sql, new ResultSetHandler() {
    @Override
    public Object handle(ResultSet rs) throws SQLException {
        List<Customer> customers = new ArrayList<>();

        while (rs.next()) {
            int id = rs.getInt(1);
            String name = rs.getString(2);
            String email = rs.getString(3);
            Date birth = rs.getDate(4);

            Customer customer = new Customer(id, name, email, birth);
            customers.add(customer);
        }
        //也是query方法的返回值
        return customers;
    }
});

以下Handler类实现了ResultSetHandler接口

1）BeanHandler

功能：返回查询的第一条记录对应的那个实体类对象

原理：BeanHandler类的handle方法中通过反射创建传入的Class类对应的类的对象，并用set方法为该对象设置属性，然后返回该对象。

注意：查询语句中的列名要和实体类的属性相对应，若不对应则需要使用别名   如下name：

String sql = "SELECT id, name customerName, email, birth FROM customers WHERE id >= ?";

// 1. 创建 QueryRunner 对象
QueryRunner queryRunner = new QueryRunner();

// 2. 调用query方法
Object object = queryRunner.query(conn, sql, new BeanHandler<>(Customer.class)，5);

2）BeanListHandler

作用：可以通过查询记录获得实体类对象集合

若可以查询到记录，则返回传入的Class对象对应的对象集合。

String sql = "SELECT id, name customerName, email, birth FROM customers";
QueryRunner queryRunner = new QueryRunner();

// 返回List<Customer> 对象
Object object = queryRunner.query(conn, sql, new BeanListHandler<>(Customer.class));

3）MapHandler

作用：返回查询的第一条记录对应的Map对象  键：列名（非别名）；值：列的值

QueryRunner queryRunner = new QueryRunner();
String sql = "SELECT id, name customerName, email, birth FROM customers WHERE id = ?";

Map<String, Object> map = queryRunner.query(connection, sql, new MapHandler(), 4);

4）MapListHandler

作用：返回查询的所有记录对应的Map对象的集合

QueryRunner queryRunner = new QueryRunner();
String sql = "SELECT id, name, email, birth FROM customers";

List<Map<String, Object>> mapList = queryRunner.query(connection, sql, new MapListHandler());

5）ScalarHandler

作用：返回结果集中的第一列对应的数据

QueryRunner queryRunner = new QueryRunner();
String sql = "SELECT name FROM customers WHERE id = ?";

Object count = queryRunner.query(connection, sql, new ScalarHandler(), 6);

3. QueryLoader

作用：可以用来加载存放着 SQL 语句的资源文件。

使用该类可以把 SQL 语句外置化到一个资源文件中. 以提供更好的解耦。

// / 代表类路径的根目录
Map<String, String> sqls = QueryLoader.instance().load("/sql.properties");

String updateSql = sqls.get("UPDATE_CUSTOMER");

aaarticlea/png;base64,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" alt="" width="659" height="61" />