数据库连接池与DBUtils
实际开发中"获得连接"或"释放资源"是非常消耗系统资源的两个过程，为了解决此类性能问题
通常情况我们采用连接池技术，来共享连接Connection
这样我们就不需要每次都创建连接、释放连接了，这些操作都交给了连接池
用池来管理Connection，这样可以重复使用Connection
当使用完Connection后，调用Connection的close()方法也不会真的关闭Connection，而是把Connection"归还"给池
Java为数据库连接池提供了公共的接口：javax.sql.DataSource，各个厂商需要让自己的连接池实现这个接口
这样应用程序可以方便的切换不同厂商的连接池，常见的连接池有DBCP连接池，C3P0连接池，Druid连接池等等
DBCP也是一个开源的连接池，是Apache成员之一（一个组织，开源免费），在企业开发中也比较常见，tomcat内置的连接池
上面是需要的包（后面或者说这里，都可以在网上找这些包来使用，当然，具体如何给项目导入包，网上教程也一大堆，并且由于版本不同，可能方式不同，所以这里就不给出具体如何导入了，因为这些知识并没有什么很大作用，无非就是固定的规则而已）
在项目里iml文件是写的配置文件，即你设置的什么，如仓库jar包的地方
连接数据库表的工具类，采用DBCP连接池的方式来完成
Java中提供了一个连接池的规则接口：DataSource，它是java中提供的连接池
在DBCP包中提供了DataSource接口的实现类，我们要用的具体的连接池BasicDataSource类
package com.lagou.utils;
import org.apache.commons.dbcp.BasicDataSource;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
public class DBCPUtils {
public static final String DRIVERNAME = "com.mysql.jdbc.Driver";
public static final String URL = "jdbc:mysql://localhost:3306/db5?characterEncoding=UTF-8";
public static final String USERNAME = "root";
public static final String PASSWORD = "123456";
public static BasicDataSource dataSource = new BasicDataSource();
static{
dataSource.setDriverClassName(DRIVERNAME);
dataSource.setUrl(URL);
dataSource.setUsername(USERNAME);
dataSource.setPassword(PASSWORD);
dataSource.setMaxActive(20);
}
public static Connection getConnection() throws SQLException {
Connection connection = dataSource.getConnection();
return connection;
}
public static void close(Connection con, Statement statement){
if(con != null && statement != null){
try {
statement.close();
con.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
public static void close(Connection con, Statement statement, ResultSet resultSet){
if(con != null && statement != null && resultSet != null){
try {
resultSet.close();
statement.close();
con.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
}
package com.lagou.testpool;
import com.lagou.utils.DBCPUtils;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
public class TestDBCP {
public static void main(String[] args) throws SQLException {
Connection con = DBCPUtils.getConnection();
Statement statement = con.createStatement();
String sql = "select ename from employee";
ResultSet resultSet = statement.executeQuery(sql);
while(resultSet.next()){
String ename = resultSet.getString("ename");
System.out.println("员工姓名: " + ename);
}
DBCPUtils.close(con,statement,resultSet);
}
}
在迭代器中删除元素，实际上是删除当前所在位置的值，而不是下标所在位置
即next()方法在remove()方法前面时，不会删除他后移的值，而是当前位置的值（前提是得到过，否则报错），注意：好像类似的迭代器，一般并不会直接的指向真正的数据，实际上你也可以设置指向的，但他是比较安全的而已
DBCP的配置项
protected int maxActive = 8;
protected int maxIdle = 8;
protected int minIdle = 0;
protected int initialSize = 0;
C3P0是一个开源的JDBC连接池，支持JDBC3规范和JDBC2的标准扩展，目前使用它的开源项目有Hibernate、Spring等
上面是需要的包
导入配置文件c3p0-config.xml
c3p0-config.xml文件名不可更改，应为C3P0底层指定了该名字的配置文件
若改变名字，那么就找不到配置文件了，即有可能会报错，或者阻塞等等（具体看底层的操作，运行时看也可以）
直接放到src
必须在src下，不可以放到src下的目录里，底层有指定的路劲
即项目路径下，记住是class文件的项目路径（没有src和其他特定的文件夹），而不是java的项目路径下
也可以放到到资源文件夹（编译后路径与src一样）中
对于我们的代码，实际运行的是class文件之间的操作，那么配置文件也是class进行操作的
那么对于所有代码的编译或者配置文件，都是放在idea中的out文件夹下的production目录的，该目录就存放了你的项目
可以发现，在idea里面，class存放的路径里没有src和resources文件夹，因为他们是特定的文件夹，即他们的内容就放在项目下面
可以看到，resources的内容与src的内容在同一路径
所以C3P0可以找到资源文件下的配置文件，也就是可以找到src目录下的配置文件
c3p0-config.xml---------------------------------------
<c3p0-config>
<default-config>
<property name="initialPoolSize">3</property>
<property name="maxIdleTime">60</property>
<property name="maxPoolSize">100</property>
<property name="minPoolSize">10</property>
</default-config>
<named-config name="mysql">
<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>
<property name="initialPoolSize">10</property>
<property name="maxIdleTime">30</property>
<property name="maxPoolSize">100</property>
<property name="minPoolSize">10</property>
</named-config>
</c3p0-config>
Mark Directory as：将目录标记为
Sources Root：通过这个类指定一个文件夹，你告诉IntelliJ IDEA
这个文件夹及其子文件夹中包含的源代码，可以编译为构建过程的一部分
Test Sources Root：这些根类似于源根，但用于用于测试的代码（例如用于单元测试）
测试源文件夹允许您将与测试相关的代码与生产代码分开
通常，源和测试源的编译结果被放置在不同的文件夹中
Resources Root：用于应用程序中的资源文件（图像、各种配置XML和属性文件等），编译后路径与src实际一样
Test Resources Root：（或测试资源文件夹，只有在java模块）是资源文件与您的测试源有关
在所有其他方面，这些文件夹类似于资源文件夹，一般只给测试使用，而不是都使用（Resources Root）
Excluded：将文件标记为Excluded目录后，idea就不会为该文件创建索引，全局搜索也不会搜里面的内容
编辑代码不会智能提示，相当于代码废弃场
只所以有C3P0是因为DBCP在连接信息需要改变时，需要修改代码，但由于开闭设计原则，对扩展开放对修改关闭
基本上是不可以修改代码的，若当你写上多个DBCP连接池时，又要全部改变，非常麻烦（一个一个的改变）
但可以修改扩展的，如配置文件
所以就出现了C3P0，他的连接信息在配置文件里，所以只要改变配置文件，就可以了，若当你写上多个C3P0连接池时
又要全部改变，只要修改配置文件就可以了，而不用改变代码，这样就满足了所有的C3P0连接池（只针对配置文件，便于找到，如果存在动态加载配置文件的话，那么更加好了）
package com.lagou.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 {
public static ComboPooledDataSource dataSource = new ComboPooledDataSource("mysql");
public static Connection getConnection() throws SQLException {
return dataSource.getConnection();
}
public static void close(Connection con, Statement statement){
if(con != null && statement != null){
try {
statement.close();
con.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
public static void close(Connection con, Statement statement, ResultSet resultSet){
if(con != null && statement != null && resultSet != null){
try {
resultSet.close();
statement.close();
con.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
}
package com.lagou.testpool;
import com.lagou.utils.C3P0Utils;
import java.sql.*;
public class TestC3P0 {
public static void main(String[] args) throws SQLException {
Connection con = C3P0Utils.getConnection();
String sql = "select * from employee where ename = ?";
PreparedStatement ps = con.prepareStatement(sql);
ps.setString(1,"李白");
ResultSet resultSet = ps.executeQuery();
while(resultSet.next()){
int eid = resultSet.getInt("eid");
String ename = resultSet.getString("ename");
int age = resultSet.getInt("age");
String sex = resultSet.getString("sex");
double salary = resultSet.getDouble("salary");
Date date = resultSet.getDate("empdate");
System.out.println(eid +" " + ename + " " + age +" " + sex +" " + salary +" " +date);
}
C3P0Utils.close(con,ps,resultSet);
}
}
由于C3P0读取的是配置文件，那么在运行时，通常会有日志产生（读取配置文件的基本都有日志），将操作的信息打印出来
当你初始化的连接数小于最小连接数时，会给你个警告，然后可能会自动创建连接满足条件
最后出结果，由于默认的配置，没有配置连接信息（必须项没有），那么在使用默认配置时，连接信息记得写上，否则会没结果
数据库都找不到了
由于C3P0灵活性不高，即路径基本固定，所以我们就有一个灵活性高的连接池Druid
Druid（德鲁伊）是阿里巴巴开发的号称为监控而生的数据库连接池，Druid是目前最好的数据库连接池（随着时间的推移，并不一定）
在功能、性能、扩展性方面，都超过其他数据库连接池，同时加入了日志监控，可以很好的监控DB池连接和SQL的执行情况
上述是需要的包
配置文件通常是properties形式的
在druid里可以叫任意名称，可以放在任意目录下（因为不像C3P0一样，有内置的路径，且不可更改）
因为Druid是可以设置指定路径的，即不主动加载配置文件，没有内置路径
所以可以说是任意目录下，因为你不管放在那里，我都可以直接指定路径，来达到使用该配置文件
大多数的需要配置文件的代码都可以指定配置文件路径的（因为没有内置路径），但有些不可，如C3P0（有内置路径）等等
在这里，我们统一放到resources资源目录，即编译和路径与src一样，且更好的管理，虽然路径一样
但还是会优先使用资源文件的配置（即优先使用编译后的资源文件的内容），没有的话，就使用内置路径的配置
注意：对于复制的文件，他的路径其实不是你复制到的哪个路径，还是原来的路径（通常这就是找不到文件的原因）
因为项目配置文件可能还没有对其路径进行关联，即更新，因为文件是包含路径的，在没有进行更新的情况下
使用复制的文件，就会去他没更新的路径去，导致路径不对，从而发生错误
在idea的File（文件）里的Invalidate Caches / Restart…（使缓存无效重新启动），基本可以解决大部分问题
而在idea的最上方的Bulid（建造，在idea叫做构造）里的Rebuild Project（重建项目，可以说是对项目重新编译）
可以解决一些小问题，如复制后的路径关联不上的问题，使得路径更新
长按电源键5秒重新启动电脑，可以解决99%的问题
剩下的问题就需要自己去百度了
druid.properties----------------------------------
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
package com.lagou.utils;
import com.alibaba.druid.pool.DruidDataSourceFactory;
import javax.sql.DataSource;
import java.io.InputStream;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Properties;
public class DruidUtils {
public static DataSource dataSource;
static{
try {
Properties p = new Properties();
InputStream inputStream =
DruidUtils.class.getClassLoader().getResourceAsStream("druid.properties");
p.load(inputStream);
dataSource = DruidDataSourceFactory.createDataSource(p);
} catch (Exception e) {
e.printStackTrace();
}
}
public static Connection getConnection(){
try {
return dataSource.getConnection();
} catch (SQLException e) {
e.printStackTrace();
return null;
}
}
public static DataSource getDataSource(){
return dataSource;
}
public static void close(Connection con, Statement statement){
if(con != null && statement != null){
try {
statement.close();
con.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
public static void close(Connection con, Statement statement, ResultSet resultSet){
if(con != null && statement != null && resultSet != null){
try {
resultSet.close();
statement.close();
con.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
}
package com.lagou.testpool;
import com.lagou.utils.DruidUtils;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
public class TestDruid {
public static void main(String[] args) throws SQLException {
Connection con = DruidUtils.getConnection();
Statement statement = con.createStatement();
ResultSet resultSet = statement.executeQuery("select ename from employee where salary
between 3000 and 5000");
while(resultSet.next()){
String ename = resultSet.getString("ename");
System.out.println(ename);
}
DruidUtils.close(con,statement,resultSet);
}
}
DBUtils工具类-------------------------
使用JDBC我们发现冗余的代码太多了，为了简化开发 我们选择使用 DbUtils
Commons DbUtils是Apache组织提供的一个对JDBC进行简单封装的开源工具类库
使用它能够简化JDBC应用程序的开发，同时也不会影响程序的性能
DBUtils就是JDBC的简化开发工具包
需要项目导入 commons-dbutils-1.6.jar
上面是需要的包
Dbutils核心功能介绍------------------------
QueryRunner类中提供对sql语句操作的API
ResultSetHandler接口，用于定义select操作后，怎样封装结果集
DbUtils类，他就是一个工具类,定义了关闭资源与事务处理相关方法
注意：java中的jar文件 ，装的是 .class 文件，它是一种压缩，和zip兼容，被称为jar包
对于mysql大小写问题：在不同的操作系统中有不同差异
在windows系统下，mysql数据库不区分大小写，且实际上你用大写时，最后都会变成小写，如创建表
在linux系统下，mysql数据库区分大小写，只能用小写，大写会找不到表
而在java与mysql之间操作时，java虽然不受操作系统的限制，但语句大小写受mysql限制（除非会自动变成小写）
以上是可以通过修改文件（或者配置，或者你厉害一点，修改底层）来改变
因为再怎么说，他都是人为的，只要是人为的基本都可以修改
int id = resultSet.getInt("id");
复习：
项目名全部小写
包名全部小写
类名首字母大写,其余组成词首字母依次大写
变量名和方法名首字母小写,如果名称由多个单词组成,除首字母外的每个单词的首字母都要大写.
常量名全部大写
所有命名规则必须遵循以下规则 :
名称只能由字母、数字、下划线、$符号组成
不能以数字开头
名称不能使用Java中的关键字
坚决不允许出现中文及拼音命名（实在不写，拼音也可以凑合，但不能太长）
只所以要这样，是一种规范，很多年的java经验得到的，有助与代码的浏览，但不适用于所有人（即有些人除外）
package com.lagou.entity;
import java.io.Serializable;
import java.util.Date;
public class Employee implements Serializable {
private int eid;
private String ename;
private int age;
private String sex;
private double salary;
private Date empdate;
public Employee() {
}
public Employee(int eid, String ename, int age, String sex, double salary, Date empdate) {
this.eid = eid;
this.ename = ename;
this.age = age;
this.sex = sex;
this.salary = salary;
this.empdate = empdate;
}
public int getEid() {
return eid;
}
public void setEid(int eid) {
this.eid = eid;
}
public String getEname() {
return ename;
}
public void setEname(String ename) {
this.ename = ename;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public double getSalary() {
return salary;
}
public void setSalary(double salary) {
this.salary = salary;
}
public Date getEmpdate() {
return empdate;
}
public void setEmpdate(Date empdate) {
this.empdate = empdate;
}
@Override
public String toString() {
return "Employee{" +
"eid=" + eid +
", ename='" + ename + '\'' +
", age=" + age +
", sex='" + sex + '\'' +
", salary=" + salary +
", empdate=" + empdate +
'}';
}
}
QueryRunner核心类------------------------
package com.lagou.testDBUtils;
import com.lagou.utils.DruidUtils;
import org.apache.commons.dbutils.QueryRunner;
public class DBUtilsDemo01 {
public static void main(String[] args) {
QueryRunner qr = new QueryRunner();
QueryRunner qr2 = new QueryRunner(DruidUtils.getDataSource());
}
}
package com.lagou.testDBUtils;
import com.lagou.utils.DBCPUtils;
import com.lagou.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;
public class DBUtilsDemo02 {
@Test
public void testInsert() throws SQLException {
QueryRunner qr = new QueryRunner();
String sql = "insert into employee values(?,?,?,?,?,?)";
Object[] param = {null,"张百万",20,"女",10000,"1990-12-26"};
Connection con = DruidUtils.getConnection();
int i = qr.update(con, sql, param);
DbUtils.closeQuietly(con);
}
@Test
public void testUpdate() throws SQLException {
QueryRunner qr = new QueryRunner(DruidUtils.getDataSource());
String sql = "update employee set salary = ? where ename = ?";
Object[] param = {15000,"张百万"};
qr.update(sql,param);
}
@Test
public void testDelete() throws SQLException {
QueryRunner qr = new QueryRunner(DruidUtils.getDataSource());
String sql = "delete from employee where eid = ?";
qr.update(sql,1);
}
}
ResultSetHandler接口可以对查询出来的ResultSet结果集进行处理，达到一些业务上的需求
ResultSetHandler接口的实现类如下--------------------------
上述每一种实现类都代表了对查询结果集的一种处理方式
QueryRunner的查询方法---------------------------
query方法的返回值都是泛型，具体的返回值类型，会根据结果集的处理方式，发生变化
package com.lagou.testDBUtils;
import com.lagou.entity.Employee;
import com.lagou.utils.DruidUtils;
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;
public class DBUtilsDemo03 {
@Test
public void testFindById() throws SQLException {
QueryRunner qr = new QueryRunner(DruidUtils.getDataSource());
String sql = "select * from employee where eid = ?";
Object[] query = qr.query(sql, new ArrayHandler(), 5);
System.out.println(Arrays.toString(query));
}
@Test
public void testFindAll() throws SQLException {
QueryRunner qr = new QueryRunner(DruidUtils.getDataSource());
String sql = "select * from employee";
List<Object[]> query = qr.query(sql, new ArrayListHandler());
for (Object[] objects : query) {
System.out.println(Arrays.toString(objects));
}
}
@Test
public void testFindByIdJavaBean() throws SQLException {
QueryRunner qr = new QueryRunner(DruidUtils.getDataSource());
String sql = "select * from employee where eid = ?";
Employee employee = qr.query(sql, new BeanHandler<Employee>(Employee.class), 3);
System.out.println(employee);
}
@Test
public void testFindBySalary() throws SQLException {
QueryRunner qr = new QueryRunner(DruidUtils.getDataSource());
String sql = "select * from employee where salary > ?";
List<Employee> list = qr.query(sql, new BeanListHandler<Employee>(Employee.class), 3000);
for (Employee employee : list) {
System.out.println(employee);
}
}
@Test
public void testFindByName() throws SQLException {
QueryRunner qr = new QueryRunner(DruidUtils.getDataSource());
String sql = "select * from employee where ename = ?";
Map<String, Object> map = qr.query(sql, new MapHandler(), "张百万");
Set<Map.Entry<String, Object>> entries = map.entrySet();
for (Map.Entry<String, Object> entry : entries) {
System.out.println(entry.getKey() +" = " +entry.getValue());
}
}
@Test
public void testGetSum() throws SQLException {
QueryRunner qr = new QueryRunner(DruidUtils.getDataSource());
String sql = "select sum(salary) from employee";
Double sum = (Double)qr.query(sql, new ScalarHandler<>());
System.out.println("员工薪资总额: " + sum);
}
}
批处理(batch) 操作数据库批处理指的是一次操作中执行多条SQL语句
批处理相比于一次一次执行效率会提高很多
当向数据库中添加大量的数据时，需要用到批处理
举例：
送货员的工作：未使用批处理的时候，送货员每次只能运送 一件货物给商家
使用批处理，则是送货员将所有要运送的货物, 都用车带到发放处派给客户
Statement和PreparedStatement都支持批处理操作
mysql批处理是默认关闭的，所以需要加一个参数才打开mysql 数据库批处理，在url中添加
rewriteBatchedStatements=true
例如: url=jdbc:mysql://127.0.0.1:3306/db5?characterEncoding=UTF-8&rewriteBatchedStatements=true
package com.lagou.testbatch;
import com.lagou.utils.DruidUtils;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;
public class BatchInsert {
public static void main(String[] args) throws SQLException {
Connection connection = DruidUtils.getConnection();
PreparedStatement ps = connection.prepareStatement("insert into testBatch(uname) values(?)");
for (int i = 0; i < 10000 ; i++){
ps.setString(1,"小强" + i);
ps.addBatch();
}
long start = System.currentTimeMillis();
ps.executeBatch();
long end = System.currentTimeMillis();
System.out.println("插入10000条数据需要使用: " + (end - start) + " 毫秒!");
DruidUtils.close(connection,ps);
}
}
除了表之外的数据都是元数据,可以分为三类
查询结果信息： UPDATE 或 DELETE语句 受影响的记录数
数据库和数据表的信息： 包含了数据库及数据表的结构信息
MySQL服务器信息： 包含了数据库服务器的当前状态，版本号等
-- 查看服务器的状态信息
show status;
185是：表示非正常中断的连接数
2是：连接失败的连接数
13220是：从客户端接收的字节数
285596是：发送的字节数
-- 获取mysql服务器的版本信息
select version();
版本信息
-- 显示表的字段信息等，和desc 表名一样
SHOW COLUMNS FROM employee;
desc employee
-- 两者一样
-- 其中employee是表名，即可以是其他的表
-- 显示数据表的详细索引信息，包括PRIMARY KEY（主键）
SHOW INDEX FROM testbatch;
-- 其中testbatch是表名，即可以是其他的表
-- 列出所有数据库
show databases;
-- 显示当前数据库的所有表
show tables;
-- 获取当前的数据库名
select database();
通过JDBC 也可以获取到元数据，比如数据库的相关信息
或者当我们使用程序查询一个不熟悉的表时
我们可以通过获取元素据信息，了解表中有多少个字段，字段的名称和字段的类型
JDBC中描述元数据的类
DatabaseMetaData描述数据库的元数据对象
ResultSetMetaData描述结果集的元数据对象
connection连接对象，调用getMetaData()方法，获取的是DatabaseMetaData数据库元数据对象
PrepareStatement预处理对象调用 getMetaData()，获取的是ResultSetMetaData结果集元数据对象
DatabaseMetaData的常用方法
ResultSetMetaData的常用方法
package com.lagou.testmetadata;
import com.lagou.utils.DruidUtils;
import org.junit.Test;
import java.sql.*;
public class TestMetaData {
@Test
public void testDataBaseMetaData() throws SQLException {
Connection connection = DruidUtils.getConnection();
DatabaseMetaData metaData = connection.getMetaData();
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();
if(b){
System.out.println("当前数据库只允许读操作!");
}else{
System.out.println("不是只读数据库");
}
connection.close();
}
@Test
public void testResultSetMetaData() throws SQLException {
Connection con = DruidUtils.getConnection();
PreparedStatement ps = con.prepareStatement("select * from employee");
ResultSet resultSet = ps.executeQuery();
ResultSetMetaData metaData = ps.getMetaData();
int count = metaData.getColumnCount();
System.out.println("当前结果集中共有: " + count + " 列");
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);
}
}
m.out.println("不是只读数据库");
}
connection.close();
}
@Test
public void testResultSetMetaData() throws SQLException {
Connection con = DruidUtils.getConnection();
PreparedStatement ps = con.prepareStatement("select * from employee");
ResultSet resultSet = ps.executeQuery();
ResultSetMetaData metaData = ps.getMetaData();
int count = metaData.getColumnCount();
System.out.println("当前结果集中共有: " + count + " 列");
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);
}
}
可以发现，预处理类也是重要的
938
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
