JAVA JDBC 元数据分析小结

纯干货：

获取数据库名称：

     /**
      * 获取数据库的名称
      */
     public void getDataBaseName() throws Exception {
         Connection con = DSUtils.getConnection();
         // 获取DataBasematedata
         DatabaseMetaData db = con.getMetaData();
         System.err.println(db.getDatabaseProductName());// 数据库的名称
         System.err.println(db.getDatabaseMajorVersion());// 数据库的主版本
         System.err.println(db.getDatabaseMinorVersion());// 数据库的小版本
         System.err.println(db.getDriverName());// 驱动器的名称
     }

获取数据库表名：

这里有一个地方是要注意：查询mysql数据库的时候要在getTables的前两个参数里传入自己数据库名称，两个一样就行了

但是查询Oracle数据库的时候需要传入用户名但是必须大写！必须大写！必须大写！

    /**
     * 获取某个数据库中有多少表
     */public void testGetTable() throws Exception {
        Connection con = DSUtils.getConnection();
        DatabaseMetaData db = con.getMetaData();
        // 获取这个数据库中所有的表的结果集
        // 访问oracle时要大写！！！
        ResultSet rs = db.getTables("BAI", "BAI", null, new String[] { "TABLE" });
        while (rs.next()) {
            String tName = rs.getString("TABLE_NAME");
            System.err.println(tName);
        }
        con.close();
    }

分析一个表有多少列及列的类型：

     /**
      * 使用ResultSetMatedata分析一个表有多少列 及列的类型
      */
     public void testTableColumns() throws Exception {
         Connection con = DSUtils.getConnection();
         Statement st = con.createStatement();
         String sql = "select * from person";
         ResultSet rs = st.executeQuery(sql);
         // 获取结果集的元信息
         ResultSetMetaData rsmd = rs.getMetaData();
         // 获取列的数量
         int cols = rsmd.getColumnCount();
         // 遍历列的的数量获取列的名称
         for (int i = 1; i <= cols; i++) {
             String name = rsmd.getColumnName(i);
             String type = rsmd.getColumnTypeName(i);
             int size = rsmd.getColumnDisplaySize(i);
             System.err.println(name + " " + type + "(" + size + ")");
         }
     }

拐个弯先弄个表：

     /**
      * 创建一个新的Excel文件
      */
     public void createExcel() throws Exception {
         // 1:创建一个工作文件
         HSSFWorkbook book = new HSSFWorkbook();
         // 2:创建一个工作表
         HSSFSheet sheet = book.createSheet("Sheet1");
         // 3:创建一行
         HSSFRow row = sheet.createRow(0);
         // 创建一个单元格
         HSSFCell cel = row.createCell(0);
         // 保存数据
         cel.setCellValue("hello");
         // 保存这个文件
         book.write(new FileOutputStream("f:/a.xls"));
     }

好吧，元数据分析到底有啥用？我也没搞明白点啥，不过可以开发一个工具类玩玩：

 package cn.qlu.utils;

 import java.io.FileOutputStream;
 import java.sql.Connection;
 import java.sql.DatabaseMetaData;
 import java.sql.ResultSet;
 import java.sql.ResultSetMetaData;
 import java.sql.Statement;
 import java.util.ArrayList;
 import java.util.List;

 import org.apache.poi.hssf.usermodel.HSSFCell;
 import org.apache.poi.hssf.usermodel.HSSFRow;
 import org.apache.poi.hssf.usermodel.HSSFSheet;
 import org.apache.poi.hssf.usermodel.HSSFWorkbook;
 import org.junit.Test;

 public class XlsOutputUtils {
     String dbName;
     String file;
     public XlsOutputUtils(String dbmane,String file) {
         this.dbName=dbmane;
         this.file=file;//类似这玩意"f:/xls/"
     }
     /**
      * 导出指定的数据库中的所有表 – 表中的数据
      */
     public void exportTableDatas() throws Exception {

         HSSFWorkbook book = new HSSFWorkbook();

         Connection con = DSUtils.getConnection();
         DatabaseMetaData db = con.getMetaData();
         // 获取这个数据库中所有的表的结果集
         ResultSet rs = db.getTables(dbName, dbName, null, new String[] { "TABLE", "VIEW" });
         // 将所有表名先保存到一个集合中去
         List<String> tables = new ArrayList<String>();
         while (rs.next()) {
             String tName = rs.getString("TABLE_NAME");
             tables.add(tName);
         }
         System.err.println("tales:" + tables);
         Statement st = con.createStatement();
         // 遍历所有表
         for (String table : tables) {
             // 创建一个工作表
             HSSFSheet sheet = book.createSheet(table);

             // 每遍历 一个表，就查询这个表
             String sql = "select * from " + dbName + "." + table;
             rs = st.executeQuery(sql);// 执行查询
             // 获取结果集的元信息
             ResultSetMetaData rsmd = rs.getMetaData();
             int cols = rsmd.getColumnCount();
             // 创建第一行
             HSSFRow row = sheet.createRow(0);

             // 获取列名
             for (int i = 0; i < cols; i++) {
                 String colName = rsmd.getColumnName(i + 1);
                 // 创建一个单元格
                 HSSFCell cel = row.createCell(i);
                 // 设置值
                 cel.setCellValue(colName);
             }
             // 获取里面的数据
             int rowIndex = 1;
             while (rs.next()) {

                 // 行
                 row = sheet.createRow(rowIndex++);

                 // 再遍历列
                 for (int i = 0; i < cols; i++) {
                     // 直接获取这一列的数据
                     Object val = rs.getObject(i + 1);
                     //
                     HSSFCell cel = row.createCell(i);
                     cel.setCellValue("" + val);
                 }
             }
         }

         con.close();
         book.write(new FileOutputStream(file + dbName + ".xls"));
     }

 }

还可以搞个实用一点的：数据操作工具类，提供对任意表的查询， 对任意对象(Bean)的封装

 package cn.qlu.utils;

 import java.beans.PropertyDescriptor;
 import java.lang.reflect.Method;
 import java.sql.Connection;
 import java.sql.ParameterMetaData;
 import java.sql.PreparedStatement;
 import java.sql.ResultSet;
 import java.sql.ResultSetMetaData;
 import java.sql.SQLException;
 import java.sql.Statement;
 import java.util.ArrayList;
 import java.util.List;

 import javax.sql.DataSource;

 import org.apache.commons.beanutils.BeanUtils;

 /**
  * 数据操作工具类，提供对任意表的查询， 对任意对象(Bean)的封装
  * @author baix
  */
 @SuppressWarnings("unused")
 public class QueryUtils {
     /**
      * 获取连接可以通过接收DataSource
      */
     private DataSource dataSource;

     /**
      * 在实例化这个类时，接收数据源
      */
     public QueryUtils(DataSource ds) {
         this.dataSource = ds;
     }

     /**
      * 接收两个参数
      *
      * @param sql
      *            : 执行的SQL
      * @param Class
      *            ： 可以传递Person.class
      * @return
      */
     public <T> List<T> query(String sql, Class<T> cls, Object... params) {
         List<T> list = new ArrayList<T>();
         Connection con = null;
         PreparedStatement st = null;
         ResultSet rs = null;
         try {
             con = dataSource.getConnection();
             st = con.prepareStatement(sql);
             // 判断 参数的个数
             ParameterMetaData pmd = st.getParameterMetaData();
             if (pmd.getParameterCount() != params.length) {
                 throw new RuntimeException("何不自挂东南枝，参数个数不一样！");
             }
             // 设置参数
             for (int i = 0; i < params.length; i++) {
                 st.setObject(i + 1, params[i]);
             }

             rs = st.executeQuery();

             // 获取结果集的元数据
             ResultSetMetaData rsmd = rs.getMetaData();
             int cols = rsmd.getColumnCount();

             // 以下开始叫DAO数据封装
             while (rs.next()) {
                 T p = cls.newInstance();
                 // 获取列的名称 id - > p.setId
                 for (int i = 0; i < cols; i++) {
                     // 获取列名
                     String colName = rsmd.getColumnName(i + 1);// id - > p.setId
                     // 获取列值
                     Object obj = rs.getObject(i + 1);
                     // BeanButils
                     BeanUtils.setProperty(p, colName, obj);
                 }
                 list.add(p);
             }

         } catch (Exception e) {
             throw new RuntimeException(e);
         } finally {
             try {
                 if (rs != null) {
                     rs.close();
                 }
                 if (st != null) {
                     st.close();
                 }
                 con.close();
             } catch (SQLException e) {
                 throw new RuntimeException(e);
             }
         }
         return list;
     }
 }

好了先这样