数据库连接池&DBUtils

一、数据库连接池

1、连接池介绍

（1）什么是连接池

实际开发中“获得连接”或“释放资源”是非常消耗系统资源的两个过程，为了解决此类性能问题，通常情况我们采用连接池技术，来共享连接Connection。这样我们就不需要每次都创建连接、释放连接了，这些操作都交给了连接池.

（2）连接池的好处

用池来管理Connection，这样可以重复使用Connection。当使用完Connection后，调用Connection的close()方法也不会真的关闭Connection，而是把Connection“归还”给池。

2、JDBC方式与连接池方式

普通JDBC方式

连接池方式

3、如何使用数据库连接池

Java为数据库连接池提供了公共的接口：javax.sql.DataSource，各个厂商需要让自己的连接池实现这个接口。这样应用程序可以方便的切换不同厂商的连接池！
常见的连接池有 DBCP连接池, C3P0连接池, Druid连接池, 接下里我们就详细学习一下

4、数据准备

#创建数据库
CREATE DATABASE db5 CHARACTER SET utf8;
 
#使用数据库
USE db5;
 
#创建员工表
CREATE TABLE employee (
    eid INT PRIMARY KEY AUTO_INCREMENT ,
    ename VARCHAR (20),     -- 员工姓名
    age INT ,               -- 员工年龄
    sex VARCHAR (6),        -- 员工性别
    salary DOUBLE ,         -- 薪水
    empdate DATE            -- 入职日期
); 
 
#插入数据
INSERT INTO employee (eid, ename, age, sex, salary, empdate) VALUES(NULL,'李清照',22,'女',4000,'2018-11-12');
INSERT INTO employee (eid, ename, age, sex, salary, empdate) VALUES(NULL,'林黛玉',20,'女',5000,'2019-03-14');
INSERT INTO employee (eid, ename, age, sex, salary, empdate) VALUES(NULL,'杜甫',40,'男',6000,'2020-01-01');
INSERT INTO employee (eid, ename, age, sex, salary, empdate) VALUES(NULL,'李白',25,'男',3000,'2017-10-01');

5、DBCP连接池

DBCP也是一个开源的连接池，是Apache成员之一，在企业开发中也比较常见，tomcat内置的连接池。

1.创建项目导入jar包

（1）将这两个 jar包添加到 myJar文件夹中

（2）添加myJar库到项目的依赖中

2.编写工具类

连接数据库表的工具类, 采用DBCP连接池的方式来完成
- Java中提供了一个连接池的规则接口： DataSource , 它是java中提供的连接池
- 在DBCP包中提供了DataSource接口的实现类，我们要用的具体的连接池 BasicDataSource 类

package com.soldier.utils;

import org.apache.commons.dbcp.BasicDataSource;

import javax.sql.DataSource;
import java.sql.*;

public class DBCPUtils {

    // 1.定义常量
    public static final String DRIVERNAME = "com.mysql.jdbc.Driver";
    public static final String URL = "jdbc:mysql://localhost:3306/db5?characterEncoding=UTF8";
    //public static final String URL = "jdbc:mysql://localhost:3306/db5?characterEncoding=UTF-8";
    public static final String USER = "root";
    public static final String PASSWORD = "123456";

    // 2.创建连接池对象（有DBCP提供的实现类）
    public static BasicDataSource dataSource = new BasicDataSource();

    // 3.使用静态代码块进行配置
    static {

        dataSource.setDriverClassName(DRIVERNAME);
        dataSource.setUrl(URL);
        dataSource.setUsername(USER);
        dataSource.setPassword(PASSWORD);
    }

    // 4.获取连接的方法
    public static Connection getConnection() {

        // 从连接池获取连接
        try {
            Connection connection = dataSource.getConnection();
            return connection;
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return null;
    }

    // 5.释放资源
    public static void close(Connection con, Statement statement) {

        if (null != con && null != statement) {

            try {
                statement.close();
                // 归还连接
                con.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }

    public static void close(Connection con, Statement statement, ResultSet resultSet) {

        if (null != con && null != statement && null != resultSet) {

            try {
                resultSet.close();
                statement.close();
                con.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
}

3、测试工具类

需求：查询所有员工的姓名

package pooltest;

import com.soldier.utils.DBCPUtils;

import javax.print.attribute.standard.MediaName;
import java.sql.*;
import java.util.Scanner;

public class DBCPTest {

    /**
     * 测试DBCP连接池
     * @param args
     */
    public static void main(String[] args) {

        // 1.获取连接
        Connection con = null;
        PreparedStatement preparedStatement = null;
        //Statement statement = null;
        ResultSet resultSet = null;
        try {
            con = DBCPUtils.getConnection();

            // 2.获取PreparedStatement对象
            //String sql = "select ? from employee;";
            String sql = "select ename from employee;";
            preparedStatement = con.prepareStatement(sql);
            //statement = con.createStatement();
           /* Scanner sc = new Scanner(System.in);
            System.out.println("输入查询依据：");
            String s = sc.next();
            preparedStatement.setString(1, s);*/
            // 3.执行查询操作
            resultSet = preparedStatement.executeQuery();
            //resultSet = statement.executeQuery(sql);
            // 4.处理结果集
            while (resultSet.next()) {

                String ename = resultSet.getString("ename");
                System.out.println(ename);
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            // 5.释放资源
            DBCPUtils.close(con,preparedStatement,resultSet);
            //DBCPUtils.close(con,statement,resultSet);
        }
       
    }
}

4、常见配置项

6、C3P0连接池

C3P0是一个开源的JDBC连接池,支持JDBC3规范和JDBC2的标准扩展。目前使用它的开源项目有Hibernate、Spring等。

1.导入jar包及配置文件

（1）将jar包复制到myJar文件夹即可,IDEA会自动导入

（2）导入配置文件 c3p0-config.xml

c3p0-config.xml 文件名不可更改
直接放到src下,也可以放到到资源文件夹中

<c3p0-config>
 
  <!--默认配置-->
  <default-config>
    <property name="driverClass">com.mysql.jdbc.Driver</property>
    <property name="jdbcUrl">jdbc:mysql://localhost:3306/db5?characterEncoding=UTF-8</property>
    <property name="user">root</property>
    <property name="password">123456</property>
 
    <!-- initialPoolSize：初始化时获取三个连接，
          取值应在minPoolSize与maxPoolSize之间。 -->
    <property name="initialPoolSize">3</property>
 
    <!-- maxIdleTime：最大空闲时间,60秒内未使用则连接被丢弃。若为0则永不丢弃。-->
    <property name="maxIdleTime">60</property>
 
    <!-- maxPoolSize：连接池中保留的最大连接数 -->
    <property name="maxPoolSize">100</property>
    <!-- minPoolSize: 连接池中保留的最小连接数 -->
    <property name="minPoolSize">10</property>
  </default-config>
 
  <!--配置连接池mysql-->
  <named-config name="mysql">
 
    <property name="driverClass">com.mysql.jdbc.Driver</property>
    <property name="jdbcUrl">jdbc:mysql://localhost:3306/db5</property>
    <property name="user">root</property>
    <property name="password">123456</property>
 
    <property name="initialPoolSize">10</property>
    <property name="maxIdleTime">30</property>
    <property name="maxPoolSize">100</property>
    <property name="minPoolSize">10</property>
  </named-config>
 
  <!--配置连接池2,可以配置多个-->
 
</c3p0-config>

（3）在项目下创建一个resource文件夹(专门存放资源文件)

（4）选择文件夹,右键将resource文件夹指定为资源文件夹

（5）将文件放在resource目录下即可,创建连接池对象的时候会去加载这个配置文件

2.编写C3P0工具类

C3P0提供的核心工具类, ComboPooledDataSource , 如果想使用连接池,就必须创建该类的对象
- new ComboPooledDataSource(); 使用默认配置
- new ComboPooledDataSource("mysql"); 使用命名配置

package com.soldier.utils;

import com.mchange.v2.c3p0.ComboPooledDataSource;

import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

public class C3P0Utils {

    // 1.创建连接池对象 C3P0对DataSource接口的实现类
    // 使用的配置是 配置文件中的默认配置
    //public static ComboPooledDataSource dataSource = new ComboPooledDataSource();

    // 使用配置文件中配置名为mysql的指定配置
    public static ComboPooledDataSource dataSource = new ComboPooledDataSource("mysql");

    // 获取连接的方法
    public static Connection getConnection() {

        Connection connection = null;
        try {
            connection = dataSource.getConnection();
            return connection;
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return null;
    }

    // 释放资源
    public static void close(Connection con, Statement statement) {

        if (null != con && null != statement) {

            try {
                statement.close();
                con.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }

    public static void close(Connection con, Statement statement, ResultSet resultSet) {

        if (null != con && null != statement) {

            try {
                resultSet.close();
                statement.close();
                con.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
}

3.测试工具类

需求：查询名为李白的员工信息

package com.soldier.pooltest;

import com.soldier.utils.C3P0Utils;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Date;
import java.util.Scanner;

public class C3P0Test {

    /**
     * 查询姓名为李白的记录
     * @param args
     */
    public static void main(String[] args) {

        Connection con = null;
        PreparedStatement preparedStatement = null;
        ResultSet resultSet = null;
        try {
            // 1.获取连接
            con = C3P0Utils.getConnection();

            // 2.获取PreparedStatement对象
            String sql = "select * from employee where ename = ?;";
            preparedStatement = con.prepareStatement(sql);
            // 提示用户输入要查询的人名
            Scanner sc = new Scanner(System.in);
            System.out.println("请输入要查询的人名：");
            String name = sc.next();
            preparedStatement.setString(1,name);
            resultSet = preparedStatement.executeQuery();
            while (resultSet.next()) {

                int id = resultSet.getInt("eid");
                String ename = resultSet.getString("ename");
                int age = resultSet.getInt("age");
                String sex = resultSet.getString("sex");
                Double salary = resultSet.getDouble("salary");
                Date empDate = resultSet.getDate("empdate");
                System.out.println(id + " : " + ename + " : " + age + " : " + sex + " : " + salary + " : " + empDate);
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {

            C3P0Utils.close(con, preparedStatement,resultSet);
        }

    }
}

4、常见配置

7、Druid连接池

Druid（德鲁伊）是阿里巴巴开发的号称为监控而生的数据库连接池，Druid是目前最好的数据库连接池。在功能、性能、扩展性方面，都超过其他数据库连接池，同时加入了日志监控，可以很好的监控DB池连接和SQL的执行情况。

1.导入jar包及配置文件

（1）导入jar包

（2）导入配置文件

是properties形式的
可以叫任意名称，可以放在任意目录下,我们统一放到 resources资源目录

driverClassName=com.mysql.jdbc.Driver
url=jdbc:mysql://127.0.0.1:3306/db5?characterEncoding=UTF-8
username=root
password=123456
initialSize=5
maxActive=10
maxWait=3000

2.编写Druid工具类

获取数据库连接池对象
- 通过工厂来来获取 DruidDataSourceFactory类的createDataSource方法
- createDataSource(Properties p) 方法参数可以是一个属性集对象

3.测试工具类

需求: 查询薪资在3000 - 5000元之间的员工姓名

二、DBUtils工具类

1、 DBUtils简介

使用JDBC我们发现冗余的代码太多了,为了简化开发我们选择使用 DbUtils
Commons DbUtils是Apache组织提供的一个对JDBC进行简单封装的开源工具类库，使用它能够简化JDBC应用程序的开发，同时也不会影响程序的性能。

使用方式:
- DBUtils就是JDBC的简化开发工具包。需要项目导入 commons-dbutils-1.6.jar。

1.DBUtils核心功能介绍

QueryRunner 中提供对sql语句操作的API.
ResultSetHandler接口，用于定义select操作后，怎样封装结果集.
DbUtils类,他就是一个工具类,定义了关闭资源与事务处理相关方法.

2、案例相关知识

1.表与类之间的关系

整个表可以看做是一个类
表中的一行记录,对应一个类的实例(对象)
表中的一列,对应类中的一个成员属性

2.JavaBean组件

（1）JavaBean 就是一个类, 开发中通常用于封装数据,有一下特点

需要实现序列化接口, Serializable (暂时可以省略)
提供私有字段: private 类型变量名;
提供 getter 和 setter
提供空参构造

（2）创建Employee类和数据库的employee表对应

我们可以创建一个 entity包,专门用来存放 JavaBean类

public class Employee implements Serializable {
 
    private int eid;
 
    private String ename;
 
    private int age;
 
    private String  sex;
 
    private double salary;
 
    private Date empdate;
    
    //空参 getter setter省略
}

3、DBUtils完成CRUD

1.QueryRunner核心类

构造方法
- QueryRunner()
- QueryRunner(DataSource ds) ,提供数据源（连接池），DBUtils底层自动维护连接connection
常用方法
- update(Connection conn, String sql, Object... params) ，用来完成表数据的增加、删除、更新操作
- query(Connection conn, String sql, ResultSetHandler rsh, Object... params) ，用来完成表数据的查询操作

2.QueryRunner的创建

手动模式

//手动方式 创建QueryRunner对象
 QueryRunner qr = new QueryRunner();

自动模式

//自动创建 传入数据库连接池对象
QueryRunner qr2 = new QueryRunner(DruidUtils.getDataSource());

自动模式需要传入连接池对象

//获取连接池对象
public static DataSource getDataSource(){
    return dataSource;
}

3.QueryRunner实现增、删、改操作

核心方法：update(Connection conn, String sql, Object... params)

步骤
1.创建QueryRunner(手动或自动)
2.占位符方式编写SQL
3.设置占位符参数
4.执行

package com.soldier.DBUtilstest;

import com.soldier.utils.DruidUtils;
import org.apache.commons.dbutils.DbUtils;
import org.apache.commons.dbutils.QueryRunner;
import org.junit.Test;

import java.sql.Connection;
import java.sql.SQLException;

/**
 * 使用QueryRunner对象完成增删改的操作
 *     update（Connection con,String sql, Object ... param）方法
 */
public class DBUtilsDemo02 {

    @Test
    public void testInsert() throws SQLException {

        // 1.创建QueryRunner 手动模式创建
        QueryRunner queryRunner = new QueryRunner();

        // 2.编写占位符方式的sql语句
        String sql = "insert into employee values (?, ?,?,?,?,?);";

        // 3.设置占位符的参数
        Object[] param = {null, "赵云", 20, "女", 10000, "1990-12-26"};

        // 4.执行update方法
        Connection con = DruidUtils.getConnection();
        int i = queryRunner.update(con, sql, param);

        // 5.释放资源
        //con.close();
        DbUtils.closeQuietly(con);
    }

    // 修改姓名为赵云的员工的性别
    @Test
    public void testUpdate() throws SQLException {

        // 1.创建核心类
        QueryRunner queryRunner = new QueryRunner(DruidUtils.getDataSource());

        // 2.编写带占位符sql语句
        String sql = "update employee set sex = ? where ename = ?;";

        // 3.设置占位符的值
        Object[] param = {"男", "赵云"};

        // 4.执行update方法
        Connection con = DruidUtils.getConnection();
        int i = queryRunner.update(sql, param);

        // 5.释放资源
        DbUtils.closeQuietly(con);
    }

    // 把姓名为赵云的员工删除
    @Test
    public void testDelete() throws SQLException {

        // 1.创建核心类 自动模式
        QueryRunner queryRunner = new QueryRunner(DruidUtils.getDataSource());

        // 2.编写SQL语句
        String sql = "delete from employee where ename = ?";

        // 3.设置占位符的值
        Object[] param = {"赵云"};

        // 4.指向update方法
        int i = queryRunner.update(sql, param);

        // 5.释放资源
        DbUtils.closeQuietly(DruidUtils.getConnection());
    }
}

4.QueryRunner实现查询操作

（1）ResultSetHandler接口简介

ResultSetHandler可以对查询出来的ResultSet结果集进行处理，达到一些业务上的需求。

（2）ResultSetHandler 结果集处理类

本例展示的是使用ResultSetHandler接口的几个常见实现类实现数据库的增删改查，可以大大减少代码量，优化程序。
每一种实现类都代表了对查询结果集的一种处理方式

（3） ResultSetHandler 常用实现类测试

QueryRunner的查询方法
query方法的返回值都是泛型,具体的返回值类型,会根据结果集的处理方式,发生变化

创建一个测试类, 对ResultSetHandler接口的几个常见实现类进行测试
- 查询id为5的记录,封装到数组中
- 查询所有数据,封装到List集合中
- 查询id为5的记录,封装到指定JavaBean中
- 查询薪资大于 3000 的所员工信息,封装到JavaBean中再封装到List集合中
- 查询姓名是张百万的员工信息,将结果封装到Map集合中
- 查询所有员工的薪资总额

package com.soldier.DBUtilstest;

import com.soldier.entity.Employee;
import com.soldier.utils.DruidUtils;
import com.sun.java.accessibility.util.EventID;
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.*;
import org.junit.Test;

import java.sql.SQLException;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Set;

/**
 * - 查询id为5的记录,封装到数组中
 * - 查询所有数据,封装到List集合中
 * - 查询id为5的记录,封装到指定JavaBean中
 * - 查询薪资大于 3000 的所员工信息,封装到JavaBean中再封装到List集合中
 * - 查询姓名是 张百万的员工信息,将结果封装到Map集合中
 * - 查询所有员工的薪资总额
 */
public class DBUtilsDemo03 {

    // 查询id为5的记录,封装到数组中
    // ArrayHandLer 将结果集的第一条数据封装到数组中
    @Test
    public void testFindById() throws SQLException {

        // 1.创建QueryRunner
        QueryRunner queryRunner = new QueryRunner(DruidUtils.getDataSource());

        // 2.编写sql
        String sql = "select * from employee where eid = ?;";

        // 3.执行查询操作
        Object[] query = queryRunner.query(sql, new ArrayHandler(), 6);

        // 获取数据
        System.out.println(Arrays.toString(query));
    }

    // 查询所有数据,封装到List集合中
    // ArrayListHandLer可以将每条数据封装到数组中，再将数据封装到集合中
    @Test
    public void testFindAll () throws SQLException {

        // 1.创建QueryRunner
        QueryRunner queryRunner = new QueryRunner(DruidUtils.getDataSource());

        // 2.编写sql语句
        String sql = "select * from employee;";

        // 3.执行查询操作
        List<Object[]> query = queryRunner.query(sql, new ArrayListHandler());

        // 4.获取数据
        for (Object[] obj : query) {

            System.out.println(Arrays.toString(obj));
        }
    }

    // 查询id为3的记录,封装到指定JavaBean中
    // BeanHandLer可以将结果集的第一条数据封装到JavaBean中
    @Test
    public void testFindByIdToBean() throws SQLException {

        // 1.创建QueryRunner
        QueryRunner queryRunner = new QueryRunner(DruidUtils.getDataSource());

        // 2.编写SQL语句
        String sql = "select * from employee where eid = ?";

        // 3.执行查询
        Employee query = queryRunner.query(sql, new BeanHandler<Employee>(Employee.class), 3);

        // 4.获取数据
        System.out.println(query);
    }

    // 查询薪资大于 3000 的所员工信息,封装到JavaBean中再封装到List集合中
    // BeanListHandLer 可以将结果集的每一条数据封装到JavaBean中在封装到List中
    @Test
    public void testFindBySalary() throws SQLException {

        // 1.创建QueryRunner
        QueryRunner queryRunner = new QueryRunner(DruidUtils.getDataSource());

        // 2.编写sql语句
        String sql = "select * from employee where salary > ?;";

        // 3.执行查询
        List<Employee> query = queryRunner.query(sql, new BeanListHandler<Employee>(Employee.class), 3000);

        // 4.获取数据
        for (Employee employee : query) {

            System.out.println(employee);
        }
    }

    // 查询姓名是 张百万的员工信息,将结果封装到Map集合中
    // MapHandLer可以将结果集的第一条封装到Map<String,Object>集合中 key对应列名，value对应的是列的值
    @Test
    public void testFindByName() throws SQLException {

        // 1.创建QueryRunner
        QueryRunner queryRunner = new QueryRunner(DruidUtils.getDataSource());

        // 2.编写sql语句
        String sql = "select * from employee where ename = ?;";

        // 3.执行查询
        Map<String, Object> query = queryRunner.query(sql, new MapHandler(), "赵云");

        Set<Map.Entry<String,Object>> entries = query.entrySet();

        // 4.获取数据
        for (Map.Entry<String,Object> entry : entries) {

            System.out.println(entry.getKey() + " = " + entry.getValue());
        }
    }

    // 查询所有员工的薪资总额
    // ScalarHandLer可以封装单个数据
    @Test
    public void testFindSum() throws SQLException {

        // 1.创建QueryRunner
        QueryRunner queryRunner = new QueryRunner(DruidUtils.getDataSource());

        // 2.编写sql语句
        String sql = "select sum(salary) from employee;";

        // 3.执行查询
        Double query = queryRunner.query(sql, new ScalarHandler<Double>());

        // 4.获取数据
        System.out.println("员工薪资总额：" + query);
    }
}

三、数据库批处理

1、什么是批处理

批处理(batch) 操作数据库
- 批处理指的是一次操作中执行多条SQL语句，批处理相比于一次一次执行效率会提高很多。
- 当向数据库中添加大量的数据时，需要用到批处理。
举例: 送货员的工作：
- 未使用批处理的时候，送货员每次只能运送一件货物给商家；
- 使用批处理，则是送货员将所有要运送的货物, 都用车带到发放处派给客户。

2、实现批处理

Statement和PreparedStatement都支持批处理操作，这里我们介绍一下PreparedStatement的批处理方式：

（1）使用的方法：

（2）mysql 批处理是默认关闭的，所以需要加一个参数才打开mysql 数据库批处理，在url中添加

rewriteBatchedStatements=true
例如: url=jdbc:mysql://127.0.0.1:3306/db5?characterEncoding=UTF-8&rewriteBatchedStatements=true

（3）创建一张表

CREATE TABLE testBatch (
    id INT PRIMARY KEY AUTO_INCREMENT,
    uname VARCHAR(50)
)

（4）测试向表中插入 1万条数据

package com.soldier.testbatch;

import com.soldier.utils.DruidUtils;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;

public class BatchInsert {

    // 使用批处理向表中添加10000条数据
    public static void main(String[] args) throws SQLException {

        // 1.获取连接
        Connection con = DruidUtils.getConnection();

        // 2.获取预处理对象
        //String sql = "insert into testBatch(uname) values(?);";
        String sql ="insert into testBatch(uname) values(?)";
        PreparedStatement preparedStatement = con.prepareStatement(sql);

        // 3.执行批量插入操作
        for (int i = 0; i < 10000; i++) {

            preparedStatement.setString(1,"韩信" + i);

            // 将SQL添加到批处理列表中
            preparedStatement.addBatch();
        }
        // 添加时间戳测试执行效率
        long start = System.currentTimeMillis();

        // 统一执行批量插入操作
        preparedStatement.executeBatch();

        long end = System.currentTimeMillis();

        long time = end - start;
        System.out.println("执行时间是：" + time);

        // 5.关闭连接
        DruidUtils.close(con,preparedStatement);
    }
}

四、Mysql元数据

1、什么是元数据

除了表之外的数据都是元数据,可以分为三类
- 查询结果信息： UPDATE 或 DELETE语句受影响的记录数。
- 数据库和数据表的信息：包含了数据库及数据表的结构信息。
- MySQL服务器信息：包含了数据库服务器的当前状态，版本号等。

2、常用的命令

-- 元数据相关的命令介绍
 
-- 1.查看服务器当前状态
SHOW STATUS;
 
-- 2.查看MySQl的版本信息
SELECT VERSION();
 
-- 3.查询表中的详细信息
SHOW COLUMNS FROM employee;
 
-- 4.显示数据表的详细索引信息
SHOW INDEX FROM testBatch;
 
-- 5.列出所有数据库
SHOW DATABASES;
 
-- 6.显示当前数据库的所有表
SHOW TABLES;
 
-- 7.获取当前的数据库名
SELECT DATABASE();

select version(); 获取mysql服务器的版本信息

show status; 查看服务器的状态信息

show columns from table_name; 显示表的字段信息等，和desc table_name一样

show index from table_name; 显示数据表的详细索引信息，包括PRIMARY KEY（主键）

show databases:列出所有数据库
show tables : 显示当前数据库的所有表
select database(): 获取当前的数据库名

3、使用JDBC获取元数据

通过JDBC 也可以获取到元数据,比如数据库的相关信息,或者当我们使用程序查询一个不熟悉的表时, 我们可以通过获取元素据信息,了解表中有多少个字段,字段的名称和字段的类型.

1.常用类介绍

JDBC中描述元数据的类

获取元数据对象的方法 : getMetaData ()
- connection 连接对象, 调用 getMetaData () 方法,获取的是DatabaseMetaData 数据库元数据对象
- PrepareStatement 预处理对象调用 getMetaData () , 获取的是ResultSetMetaData , 结果集元数据对象
DatabaseMetaData的常用方法

ResultSetMetaData的常用方法

 public class TestMetaData {
 
    //1.获取数据库相关的元数据信息 使用DatabaseMetaData
    @Test
    public void testDataBaseMetaData() throws SQLException {
 
        //1.获取数据库连接对象 connection
        Connection connection = DruidUtils.getConnection();
 
        //2.获取代表数据库的 元数据对象 DatabaseMetaData
        DatabaseMetaData metaData = connection.getMetaData();
 
        //3.获取数据库相关的元数据信息
        String url = metaData.getURL();
        System.out.println("数据库URL: " + url);
 
        String userName = metaData.getUserName();
        System.out.println("当前用户: " + userName );
 
        String productName = metaData.getDatabaseProductName();
        System.out.println("数据库产品名: " + productName);
 
        String version = metaData.getDatabaseProductVersion();
        System.out.println("数据库版本: " + version);
        String driverName = metaData.getDriverName();
        System.out.println("驱动名称: " + driverName);
 
        //判断当前数据库是否只允许只读
        boolean b = metaData.isReadOnly();  //如果是 true 就表示 只读
        if(b){
            System.out.println("当前数据库只允许读操作!");
        }else{
            System.out.println("不是只读数据库");
        }
 
        connection.close();
    }
 
   //获取结果集中的元数据信息
    @Test
    public void testResultSetMetaData() throws SQLException {
 
        //1.获取连接
        Connection con = DruidUtils.getConnection();
 
        //2.获取预处理对象
        PreparedStatement ps = con.prepareStatement("select * from employee");
        ResultSet resultSet = ps.executeQuery();
 
        //3.获取结果集元素据对象
        ResultSetMetaData metaData = ps.getMetaData();
 
        //1.获取当前结果集 共有多少列
        int count = metaData.getColumnCount();
        System.out.println("当前结果集中共有: " + count + " 列");
 
        //2.获结果集中 列的名称 和 类型
        for (int i = 1; i <=  count; i++) {
            String columnName = metaData.getColumnName(i);
            System.out.println("列名: "+ columnName);
 
            String columnTypeName = metaData.getColumnTypeName(i);
            System.out.println("类型: " +columnTypeName);
        }
 
        //释放资源
        DruidUtils.close(con,ps,resultSet);
    }
}

本文来自博客园，作者：寒露凝珠，转载请注明原文链接：https://www.cnblogs.com/china-soldier/p/15068116.html