JDBC获得数据库连接及使用

1.Connection 

• Java.sql.Driver 接口是所有 JDBC 驱动程序需要实现的接口。这个接口是提供给数据库厂商使用的，不同数据库厂商提供不同的实现
• 在程序中不需要直接去访问实现了 Driver 接口的类，而是由驱动程序管理器类(java.sql.DriverManager)去调用这些Driver实现
• 通常不用显式调用 DriverManager 类的 registerDriver() 方法来注册驱动程序类的实例，因为 Driver 接口的驱动程序类都包含了静态代码块，在这个静态代码块中，会调用 DriverManager.registerDriver() 方法来注册自身的一个实例

@Test
    public void testDBDynamicDriver() throws Exception {
        // 1.读取配置文件
        Properties prop = new Properties();
        InputStream in = null;
        try {
            in = new FileInputStream(new File("jdbc.properties"));

            prop.load(in);
        } catch (Exception e1) {
            e1.printStackTrace();
        }
        String url = prop.getProperty("db.url");
        String user = prop.getProperty("db.user");
        String password = prop.getProperty("db.password");
        String driverPath = prop.getProperty("db.driver");

        // 2.配置properties，Normally at least "user" and "password" properties should be
        // included in the Properties object.

        Properties jdbcprop = new Properties();
        jdbcprop.put("user", user);
        jdbcprop.put("password", password);
        Class<?> driverClass = Class.forName(driverPath);
        Driver driver = (Driver) driverClass.newInstance();

        Connection conn = driver.connect(url, jdbcprop);
        in.close();
        System.out.println(conn);
    }

    @Test
    public void testDBDriverManager() throws Exception {
        // 1.读取配置文件
        Properties prop = new Properties();
        InputStream in = null;
        try {
            in = new FileInputStream(new File("jdbc.properties"));

            prop.load(in);
        } catch (Exception e1) {
            e1.printStackTrace();
        }
        String url = prop.getProperty("db.url");
        String user = prop.getProperty("db.user");
        String password = prop.getProperty("db.password");
        String driverPath = prop.getProperty("db.driver");

        // 2.加载数据库驱动程序
        //实际应该这样写,但是在mysql driver的静态代码块会被执行实例和注册
        DriverManager.registerDriver((java.sql.Driver) Class.forName(driverPath).newInstance());
        //Class.forName(driverPath);
        Connection conn = DriverManager.getConnection(url, user, password);
        in.close();
        System.out.println(conn);
    }

 2.Statement 

• 通过调用 Connection 对象的 createStatement 方法创建该对象
• 该对象用于执行静态的 SQL 语句，并且返回执行结果
• Statement 接口中定义了下列方法用于执行 SQL 语句：

　　–      ResultSet excuteQuery(String sql)

　　–      int excuteUpdate(String sql)

@Test
    public void testDBStatement() throws Exception {
        // 1.读取配置文件
        Properties prop = new Properties();
        InputStream in = null;
        try {
            in = new FileInputStream(new File("jdbc.properties"));
            prop.load(in);
        } catch (Exception e1) {
            e1.printStackTrace();
        }
        String url = prop.getProperty("db.url");
        String user = prop.getProperty("db.user");
        String password = prop.getProperty("db.password");
        String driverPath = prop.getProperty("db.driver");

        // 2.加载数据库驱动程序
        // 实际应该这样写,但是在mysql driver的静态代码块会被执行实例和注册
        DriverManager.registerDriver((java.sql.Driver) Class.forName(driverPath).newInstance());
        // Class.forName(driverPath);
        Connection conn = DriverManager.getConnection(url, user, password);
        in.close();
        System.out.println(conn);

        // 3.获得Statement
        Statement statement = conn.createStatement();
        ResultSet ret = statement.executeQuery("select * from teacher");
        while (ret.next()) {

            System.out.println(ret.getString("name"));
        }

        statement.executeUpdate("update teacher set name = 'Johnson李' where id = '1'");
        // 先关闭Statement
        statement.close();
        // 再关闭Connection
        conn.close();
    }

3.ResultSet

• 通过调用 Statement 对象的 excuteQuery() 方法创建该对象
• ResultSet 对象以逻辑表格的形式封装了执行数据库操作的结果集，ResultSet 接口由数据库厂商实现
• ResultSet 对象维护了一个指向当前数据行的游标，初始的时候，游标在第一行之前，可以通过 ResultSet 对象的 next() 方法移动到下一行
• ResultSet 接口的常用方法：

　　　　–      boolean next()

　　　　–      getString()

　　　　–      …

 4.PreparedStatement

• 可以通过调用 Connection 对象的 preparedStatement() 方法获取 PreparedStatement 对象
• PreparedStatement 接口是 Statement 的子接口，它表示一条预编译过的 SQL 语句
• PreparedStatement 对象所代表的 SQL 语句中的参数用问号(?)来表示，调用 PreparedStatement 对象的 setXXX() 方法来设置这些参数. setXXX() 方法有两个参数，第一个参数是要设置的 SQL 语句中的参数的索引(从 1 开始)，第二个是设置的 SQL 语句中的参数的值

public void testDBPreparedStatement() throws Exception {
        // 1.读取配置文件
        Properties prop = new Properties();
        InputStream in = null;
        try {
            in = new FileInputStream(new File("jdbc.properties"));
            prop.load(in);
        } catch (Exception e1) {
            e1.printStackTrace();
        }
        String url = prop.getProperty("db.url");
        String user = prop.getProperty("db.user");
        String password = prop.getProperty("db.password");
        String driverPath = prop.getProperty("db.driver");

        // 2.加载数据库驱动程序
        // 实际应该这样写,但是在mysql driver的静态代码块会被执行实例和注册
        DriverManager.registerDriver((java.sql.Driver) Class.forName(driverPath).newInstance());
        // Class.forName(driverPath);
        Connection conn = DriverManager.getConnection(url, user, password);
        in.close();
        System.out.println(conn);

        // 3.获得Statement
        PreparedStatement preparedStatement = conn
                .prepareStatement("insert into teacher (name,address,year) values(?,?,?)");
        preparedStatement.setString(1, "wiker");
        preparedStatement.setString(2, "海富大厦");
        preparedStatement.setDate(3, new Date(new java.util.Date().getTime()));
        int ret = preparedStatement.executeUpdate();

        System.out.println(ret);
        // 先关闭Statement
        preparedStatement.close();
        // 再关闭Connection
        conn.close();
    }

 

5.Oracle LOB 和 Mysql BLOB

Oracle LOB

• LOB，即Large Objects（大对象），是用来存储大量的二进制和文本数据的一种数据类型（一个LOB字段可存储可多达4GB的数据）。
• LOB 分为两种类型：内部LOB和外部LOB。

–      内部LOB将数据以字节流的形式存储在数据库的内部。因而，内部LOB的许多操作都可以参与事务，也可以像处理普通数据一样对其进行备份和恢复操作。Oracle支持三种类型的内部LOB：

• BLOB（二进制数据）
• CLOB（单字节字符数据）
• NCLOB（多字节字符数据）。

–      CLOB和NCLOB类型适用于存储超长的文本数据，BLOB字段适用于存储大量的二进制数据，如图像、视频、音频，文件等。

目前只支持一种外部LOB类型，即BFILE类型。在数据库内，该类型仅存储数据在操作系统中的位置信息，而数据的实体以外部文件的形式存在于操作系统的文件系统中。因而，该类型所表示的数据是只读的，不参与事务。该类型可帮助用户管理大量的由外部程序访问的文件。

Mysql BLOB

MySQL中，BLOB是一个二进制大型对象，是一个可以存储大量数据的容器，它能容纳不同大小的数据。

MySQL的四种BLOB类型(除了在存储的最大信息量上不同外，他们是等同的)

实际使用中根据需要存入的数据大小定义不同的BLOB类型。
需要注意的是：如果存储的文件过大，数据库的性能会下降。

@Test
    public void testDBBlob() throws Exception {
        // 1.读取配置文件
        Properties prop = new Properties();
        InputStream in = null;
        try {
            in = new FileInputStream(new File("jdbc.properties"));
            prop.load(in);
        } catch (Exception e1) {
            e1.printStackTrace();
        }
        String url = prop.getProperty("db.url");
        String user = prop.getProperty("db.user");
        String password = prop.getProperty("db.password");
        String driverPath = prop.getProperty("db.driver");

        // 2.加载数据库驱动程序
        // 实际应该这样写,但是在mysql driver的静态代码块会被执行实例和注册
        DriverManager.registerDriver((java.sql.Driver) Class.forName(driverPath).newInstance());
        // Class.forName(driverPath);
        Connection conn = DriverManager.getConnection(url, user, password);
        in.close();
        System.out.println(conn);

        // 3.获得Statement
        PreparedStatement preparedStatement = conn.prepareStatement("insert into picture (picture) values(?)");
        InputStream inputStream = new FileInputStream(new File("F:\\照片\\Camera\\IMG_20160719_103500.jpg"));
        preparedStatement.setBlob(1, inputStream);

        int ret = preparedStatement.executeUpdate();
        inputStream.close();
        System.out.println(ret);
        // 先关闭Statement
        preparedStatement.close();
        // 再关闭Connection
        conn.close();
    }

6.Apache—DBUtils简介

• commons-dbutils 是 Apache 组织提供的一个开源 JDBC工具类库，它是对JDBC的简单封装，学习成本极低，并且使用dbutils能极大简化jdbc编码的工作量，同时也不会影响程序的性能。
• API介绍：

　　–      org.apache.commons.dbutils.QueryRunner

　　–      org.apache.commons.dbutils.ResultSetHandler

• 工具类

　　–     org.apache.commons.dbutils.DbUtils、

package com.atguigu.jdbc;

import java.io.IOException;
import java.sql.Connection;
import java.sql.Date;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

import org.apache.commons.dbutils.QueryLoader;
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.ResultSetHandler;
import org.apache.commons.dbutils.handlers.BeanListHandler;
import org.apache.commons.dbutils.handlers.MapHandler;
import org.apache.commons.dbutils.handlers.MapListHandler;
import org.apache.commons.dbutils.handlers.ScalarHandler;
import org.junit.Test;

/**
 * 测试 DBUtils 工具类
 *
 */
public class DBUtilsTest {

    /**
     * QueryLoader: 可以用来加载存放着 SQL 语句的资源文件.
     * 使用该类可以把 SQL 语句外置化到一个资源文件中. 以提供更好的解耦
     * @throws IOException
     */
    @Test
    public void testQueryLoader() throws IOException{
        // / 代表类路径的根目录.
        Map<String, String> sqls =
                QueryLoader.instance().load("/sql.properties");

        String updateSql = sqls.get("UPDATE_CUSTOMER");
        System.out.println(updateSql);
    }

    /**
     * 1. ResultSetHandler 的作用: QueryRunner 的 query 方法的返回值最终取决于
     * query 方法的 ResultHandler 参数的 hanlde 方法的返回值.
     *
     * 2. BeanListHandler: 把结果集转为一个 Bean 的 List, 并返回. Bean 的类型在
     * 创建 BeanListHanlder 对象时以 Class 对象的方式传入. 可以适应列的别名来映射
     * JavaBean 的属性名:
     * String sql = "SELECT id, name customerName, email, birth " +
     *            "FROM customers WHERE id = ?";
     *
     * BeanListHandler(Class<T> type)
     *
     * 3. BeanHandler: 把结果集转为一个 Bean, 并返回. Bean 的类型在创建 BeanHandler
     * 对象时以 Class 对象的方式传入
     * BeanHandler(Class<T> type)
     *
     * 4. MapHandler: 把结果集转为一个 Map 对象, 并返回. 若结果集中有多条记录, 仅返回
     * 第一条记录对应的 Map 对象. Map 的键: 列名(而非列的别名), 值: 列的值
     *
     * 5. MapListHandler: 把结果集转为一个 Map 对象的集合, 并返回.
     * Map 的键: 列名(而非列的别名), 值: 列的值
     *
     * 6. ScalarHandler: 可以返回指定列的一个值或返回一个统计函数的值.
     */

    @Test
    public void testScalarHandler(){
        Connection connection = null;
        QueryRunner queryRunner = new QueryRunner();

        String sql = "SELECT name FROM customers " +
                "WHERE id = ?";

        try {
            connection = JDBCTools.getConnection();
            Object count = queryRunner.query(connection, sql,
                    new ScalarHandler(), 6);

            System.out.println(count);
        } catch (Exception e) {
            e.printStackTrace();
        } finally{
            JDBCTools.releaseDB(null, null, connection);
        }
    }

    @Test
    public void testMapListHandler(){
        Connection connection = null;
        QueryRunner queryRunner = new QueryRunner();

        String sql = "SELECT id, name, email, birth " +
                "FROM customers";

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

            System.out.println(mapList);
        } catch (Exception e) {
            e.printStackTrace();
        } finally{
            JDBCTools.releaseDB(null, null, connection);
        }
    }

    @Test
    public void testMapHandler(){
        Connection connection = null;
        QueryRunner queryRunner = new QueryRunner();

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

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

            System.out.println(map);
        } catch (Exception e) {
            e.printStackTrace();
        } finally{
            JDBCTools.releaseDB(null, null, connection);
        }
    }

    /**
     * 测试 ResultSetHandler 的 BeanListHandler 实现类
     * BeanListHandler: 把结果集转为一个 Bean 的 List. 该 Bean
     * 的类型在创建 BeanListHandler 对象时传入:
     *
     * new BeanListHandler<>(Customer.class)
     *
     */
    @Test
    public void testBeanListHandler(){
        String sql = "SELECT id, name customerName, email, birth " +
                "FROM customers";

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

        Connection conn = null;

        try {
            conn = JDBCTools.getConnection();

            Object object = queryRunner.query(conn, sql,
                    new BeanListHandler<>(Customer.class));             

            System.out.println(object);
        } catch (Exception e) {
            e.printStackTrace();
        } finally{
            JDBCTools.releaseDB(null, null, conn);
        }
    }

    /**
     * 测试 QueryRunner 的 query 方法
     */
    @SuppressWarnings({ "unchecked", "rawtypes" })
    @Test
    public void testResultSetHandler(){
        String sql = "SELECT id, name, email, birth " +
                "FROM customers";

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

        Connection conn = null;

        try {
            conn = JDBCTools.getConnection();
            /**
             * 2. 调用 query 方法:
             * ResultSetHandler 参数的作用: query 方法的返回值直接取决于
             * ResultSetHandler 的 hanlde(ResultSet rs) 是如何实现的. 实际上, 在
             * QueryRunner 类的 query 方法中也是调用了 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);
                            }

                            return customers;
                        }
                    }

                    );            

            System.out.println(object);
        } catch (Exception e) {
            e.printStackTrace();
        } finally{
            JDBCTools.releaseDB(null, null, conn);
        }

    }

    /**
     * 测试 QueryRunner 类的 update 方法
     * 该方法可用于 INSERT, UPDATE 和 DELETE
     */
    @Test
    public void testQueryRunnerUpdate() {
        //1. 创建 QueryRunner 的实现类
        QueryRunner queryRunner = new QueryRunner();

        String sql = "DELETE FROM customers " +
                "WHERE id IN (?,?)";

        Connection connection = null;

        try {
            connection = JDBCTools.getConnection();
            //2. 使用其 update 方法
            queryRunner.update(connection,
                    sql, 12, 13);
        } catch (Exception e) {
            e.printStackTrace();
        } finally{
            JDBCTools.releaseDB(null, null, connection);
        }

    }

}