ResultSetMetaData元数据

最新推荐文章于 2021-03-13 12:17:50 发布
最新推荐文章于 2021-03-13 12:17:50 发布
阅读量642 收藏 1
点赞数
分类专栏： Javaee-jdbc
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013210620/article/details/52738749
版权

首先构建数据库表
这里写图片描述

插入2条数据
这里写图片描述

构建一个对应的Bean类，get/set/toString方法省略。。。
Customer

int idCard;
String nameStr;
String addressStr;
int phoneCard;

看操作数据库的方法
DAO

package com.godinsec;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public class DAO {
    //获取链接数据库的方法
    public Connection getConnection() throws Exception {
        //准备链接数据库的配置信息
        String user = "root";
        String password = "root";
        String url = "jdbc:mysql:///mydatabase";
        String driverClass = "com.mysql.jdbc.Driver";
        //加载驱动
        Class.forName(driverClass);
        //获取链接
        Connection connection = DriverManager.getConnection(url, user, password);
        //返回给函数调用者的connection
        return connection;
    }
    //关闭资源
    public void release(ResultSet resultSet,
            PreparedStatement preparedStatement, Statement statement,
            Connection connection) throws Exception {
        if (resultSet != null) {
            resultSet.close();
        }
        if (preparedStatement != null) {
            preparedStatement.close();
        }
        if (statement != null) {
            statement.close();
        }
        if (connection != null) {
            connection.close();
        }
    }


    // （一）插入、更新、删除都可以包含在其中
    public void update(String sql, Object... args) throws Exception {
        // 准备好2个初始化接口
        Connection connection = null;
        PreparedStatement preparedStatement = null;
        try {
            // 获取链接和PrepareStatement接口对象
            connection = getConnection();
            preparedStatement = connection.prepareStatement(sql);
            // 填充占位符
            for (int i = 0; i < args.length; i++) {
                preparedStatement.setObject(i + 1, args[i]);
            }
            // 执行更新操作
            preparedStatement.executeUpdate();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // 关闭资源
            release(null, preparedStatement, null, connection);
        }
    }


    // 查询一条语句，返回对应的对象
    public <T> T get(Class<T> clazz, String sql, Object... args)
            throws Exception {
        T entity = null;
        // 准备好4个初始化接口
        Connection connection = null;
        PreparedStatement preparedStatement = null;
        ResultSet resultSet = null;
        try {
            // 获取connection
            connection = getConnection();
            // 获取PrepareStatement
            preparedStatement = connection.prepareStatement(sql);
            // 填充占位符
            for (int i = 0; i < args.length; i++) {
                preparedStatement.setObject(i + 1, args[i]);
            }
            // 进行查询，得到ResultSet
            resultSet = preparedStatement.executeQuery();

            // 若ResultSet有记录，准备一个Map<String,Object>-->>键：是列别名 值：列值
            Map<String, Object> values = new HashMap<String, Object>();
            // 得到ResultSetMetaData对象
            ResultSetMetaData rsmd = resultSet.getMetaData();

            while (resultSet.next()) {
                // 有ResultSetMetaData对象得到结果集有多少列
                int columCount = rsmd.getColumnCount();
                // 有ResultSetMetaData对象得到结果集得到每列的列名
                for (int i = 0; i < columCount; i++) {
                    String columnLabel = rsmd.getColumnLabel(i + 1);
                    Object columnValue = resultSet.getObject(i + 1);
                    Object columnValue1 = resultSet.getObject(columnLabel);
                    System.out.println(columnLabel+"::"+columnValue+"::"+columnValue1);
                    // 填充Map对象
                    values.put(columnLabel, columnValue);
                }
                // 用反射创建Class对应的对象
                entity = clazz.newInstance();
                // 遍历Map对象，利用反射填充对象的属性值
                for (Map.Entry<String, Object> entry : values.entrySet()) {
                    // 属性名为Map中的key，属性值为Map中的value
                    String propertyName = entry.getKey();
                    Object value = entry.getValue();
                    System.out.println(propertyName+"-----"+value);
                    ReflectionUtils.setFieldValue(entity, propertyName, value);

                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // 关闭资源
            release(resultSet, preparedStatement, null, connection);
        }
        return entity;
    }

    // 查询多条记录，返回对应的对象集合
    public <T> List<T> getForList(Class<T> clazz, String sql, Object... args) {
        List<T> list = new ArrayList<>();
        Connection connection = null;
        PreparedStatement preparedStatement = null;
        ResultSet resultSet = null;

        try {
            // 获取链接
            connection = getConnection();
            // 获取PrepareStatement对象
            preparedStatement = connection.prepareStatement(sql);
            // 填占位符
            for (int i = 0; i < args.length; i++) {
                preparedStatement.setObject(i + 1, args[i]);
            }
            // 获取结果集
            resultSet = preparedStatement.executeQuery();
            // 若ResultSet有记录，准备一个List<Map<String , Object>>----键：是列别名 值：列值
            // 一条map就是一条记录
            List<Map<String, Object>> values = new ArrayList<>();
            // 得到ResultSetMetaData对象
            ResultSetMetaData rsmd = resultSet.getMetaData();
            Map<String, Object> map = null;
            // 判断并且处理结果集
            while (resultSet.next()) {
                map = new HashMap<>();
                // 将每条记录放到每条map里面
                for (int i = 0; i < rsmd.getColumnCount(); i++) {
                    String columnLable = rsmd.getColumnLabel(i + 1);
                    Object value = resultSet.getObject(i + 1);
                    map.put(columnLable, value);
                }
                // 将所有的map记录，放到values--list容器中
                values.add(map);
            }
            T bean = null;
            if (values.size() > 0) {
                // 遍历list集合中的每一条map记录
                for (Map<String, Object> m : values) {
                    bean = clazz.newInstance();
                    // 遍历没一条map记录的键、值
                    for (Map.Entry<String, Object> entry : m.entrySet()) {
                        String propertyName = entry.getKey();
                        Object value = entry.getValue();
                        // 通过反射进行赋值
                        ReflectionUtils
                                .setFieldValue(bean, propertyName, value);
                        // 或者通过BeanUtils工具类进行赋值
                        // BeanUtils.setProperty(bean,propertyName,value);
                    }
                    list.add(bean);
                }
            }
        } catch (Exception e) {

        } finally {

        }
        return list;
    }
    //获取某个字段，得到结果集: 该结果集应该只有一行, 且只有一列
    public <E> E getForValue(String sql, Object... args) throws Exception {
        //声明数据库需要的接口
        Connection connection = null;
        PreparedStatement preparedStatement = null;
        ResultSet resultSet = null;
        try {
            // 1. 得到结果集
            connection = getConnection();
            preparedStatement = connection.prepareStatement(sql);
            // 填充占位符
            for (int i = 0; i < args.length; i++) {
                preparedStatement.setObject(i + 1, args[i]);
            }
            resultSet = preparedStatement.executeQuery();
            if (resultSet.next()) {
                return (E) resultSet.getObject(1);
            }
        } catch (Exception ex) {
            ex.printStackTrace();
        } finally {
            release(resultSet, preparedStatement, null, connection);
        }
        return null;
    }
}

看看测试类
DAOTest

package com.godinsec;

import java.sql.Connection;
import java.util.List;

import org.junit.Test;

public class DAOTest {
    DAO dao = new DAO();

    // 测试链接数据库
    @Test
    public void testGetConnection() throws Exception {
        Connection connection = dao.getConnection();
        System.out.println(connection);
    }

    // 测试添加、删除、修改操作
    @Test
    public void testUpdate() throws Exception {
        String sql = "insert into stu(id,"
                + "name,address,phone)values(?,?,?,?)";
        dao.update(sql, 4, "he", "nanjing", 189);
    }

    // 测试查询单条语句
    @Test
    public void testGet() throws Exception {
        String sql = "select id idCard,name nameStr,address addressStr,phone phoneCard"
                + " from stu where id = ?";
        Customer customer = dao.get(Customer.class, sql, 2);
        System.out.println(customer);
    }

    // 测试查询多条语句
    @Test
    public void testGetForList() {

        String sql = "select id idCard,name nameStr,address addressStr,phone phoneCard from stu";
        List<Customer> customers = dao.getForList(Customer.class, sql);
        System.out.println(customers);

    }

    // 测试某个字段值
    @Test
    public void testGetForValue() throws Exception {
        String sql = "select name from stu where phone = ?";
        String id = dao.getForValue(sql, 111);
        System.out.println(id);
    }
}

在看一个反射的工具类
ReflectionUtils

package com.godinsec;

import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;

/**
 * 反射的 Utils 函数集合
 * 提供访问私有变量, 获取泛型类型 Class, 提取集合中元素属性等 Utils 函数
 * @author Administrator
 *
 */
public class ReflectionUtils {


    /**
     * 通过反射, 获得定义 Class 时声明的父类的泛型参数的类型
     * 如: public EmployeeDao extends BaseDao<Employee, String>
     * @param clazz
     * @param index
     * @return
     */
    @SuppressWarnings("unchecked")
    public static Class getSuperClassGenricType(Class clazz, int index){
        Type genType = clazz.getGenericSuperclass();

        if(!(genType instanceof ParameterizedType)){
            return Object.class;
        }

        Type [] params = ((ParameterizedType)genType).getActualTypeArguments();

        if(index >= params.length || index < 0){
            return Object.class;
        }

        if(!(params[index] instanceof Class)){
            return Object.class;
        }

        return (Class) params[index];
    }

    /**
     * 通过反射, 获得 Class 定义中声明的父类的泛型参数类型
     * 如: public EmployeeDao extends BaseDao<Employee, String>
     * @param <T>
     * @param clazz
     * @return
     */
    @SuppressWarnings("unchecked")
    public static<T> Class<T> getSuperGenericType(Class clazz){
        return getSuperClassGenricType(clazz, 0);
    }

    /**
     * 循环向上转型, 获取对象的 DeclaredMethod
     * @param object
     * @param methodName
     * @param parameterTypes
     * @return
     */
    public static Method getDeclaredMethod(Object object, String methodName, Class<?>[] parameterTypes){

        for(Class<?> superClass = object.getClass(); superClass != Object.class; superClass = superClass.getSuperclass()){
            try {
                //superClass.getMethod(methodName, parameterTypes);
                return superClass.getDeclaredMethod(methodName, parameterTypes);
            } catch (NoSuchMethodException e) {
                //Method 不在当前类定义, 继续向上转型
            }
            //..
        }

        return null;
    }

    /**
     * 使 filed 变为可访问
     * @param field
     */
    public static void makeAccessible(Field field){
        if(!Modifier.isPublic(field.getModifiers())){
            field.setAccessible(true);
        }
    }

    /**
     * 循环向上转型, 获取对象的 DeclaredField
     * @param object
     * @param filedName
     * @return
     */
    public static Field getDeclaredField(Object object, String filedName){

        for(Class<?> superClass = object.getClass(); superClass != Object.class; superClass = superClass.getSuperclass()){
            try {
                return superClass.getDeclaredField(filedName);
            } catch (NoSuchFieldException e) {
                //Field 不在当前类定义, 继续向上转型
            }
        }
        return null;
    }

    /**
     * 直接调用对象方法, 而忽略修饰符(private, protected)
     * @param object
     * @param methodName
     * @param parameterTypes
     * @param parameters
     * @return
     * @throws InvocationTargetException 
     * @throws IllegalArgumentException 
     */
    public static Object invokeMethod(Object object, String methodName, Class<?> [] parameterTypes,
            Object [] parameters) throws InvocationTargetException{

        Method method = getDeclaredMethod(object, methodName, parameterTypes);

        if(method == null){
            throw new IllegalArgumentException("Could not find method [" + methodName + "] on target [" + object + "]");
        }

        method.setAccessible(true);

        try {
            return method.invoke(object, parameters);
        } catch(IllegalAccessException e) {
            System.out.println("不可能抛出的异常");
        } 

        return null;
    }

    /**
     * 直接设置对象属性值, 忽略 private/protected 修饰符, 也不经过 setter
     * @param object
     * @param fieldName
     * @param value
     */
    public static void setFieldValue(Object object, String fieldName, Object value){
        Field field = getDeclaredField(object, fieldName);

        if (field == null)
            throw new IllegalArgumentException("Could not find field [" + fieldName + "] on target [" + object + "]");

        makeAccessible(field);

        try {
            field.set(object, value);
        } catch (IllegalAccessException e) {
            System.out.println("不可能抛出的异常");
        }
    }

    /**
     * 直接读取对象的属性值, 忽略 private/protected 修饰符, 也不经过 getter
     * @param object
     * @param fieldName
     * @return
     */
    public static Object getFieldValue(Object object, String fieldName){
        Field field = getDeclaredField(object, fieldName);

        if (field == null)
            throw new IllegalArgumentException("Could not find field [" + fieldName + "] on target [" + object + "]");

        makeAccessible(field);

        Object result = null;

        try {
            result = field.get(object);
        } catch (IllegalAccessException e) {
            System.out.println("不可能抛出的异常");
        }

        return result;
    }
}

先看testGet方法输出：

idCard::2::2
nameStr::bbb::bbb
addressStr::nanjing::nanjing
phoneCard::222::222
idCard-----2
phoneCard-----222
nameStr-----bbb
addressStr-----nanjing
Customer [idCard=2, nameStr=bbb, addressStr=nanjing, phoneCard=222]

然后看testGetForList

[Customer [idCard=1, nameStr=aaa, addressStr=beijing, phoneCard=111], Customer [idCard=2, nameStr=bbb, addressStr=nanjing, phoneCard=222]]

继而看testGetForValue输出

aaa

这里写图片描述

最后看插入数据库testUpdate
这里写图片描述

易辰_
关注
专栏目录
【JDBC使用】Java如何使用JDBC获取到数据库meta元数据
✅ Java 开发工程师，从事 Web 应用程序的研发，擅长 Spring、SpringBoot 等技术。 ✅ 热爱编程，业余时间学习新知识，通过 CSDN 记录学习心得和笔记内容。
07-17 2444
元数据（又称字典）是属于数据库本身的一些数据，包含数据库名、数据库字符集、表名、表的大小、表的记录行数、表的字符集、表的字段、表的索引、表的描述、字段的类型、字段的精度、字段的描述等。注意：JDBC的URL连接地址需要指定具体的数据库，不然报错：java.sql.SQLException: No database selected。到此，使用JDBC获取数据库的meta元数据就介绍完啦。
ResultSetMetaData
Context
05-01 222
ResultSetMetaData 标签： ResultSetMetaData 2013-09-21 19:54 1033人阅读 评论(0) 收藏 举报  分类： java 版权声明：本文为博主原创文章，未经博主允许不得转载。 [java] view plain copy package dao;  
ResultSetMetaData类
Java-Jinguo
12-23 171
ResultSetMetaData类的介绍 (2008-12-10 20:44:18) 标签：it 杂谈 分类：Java,Jsp 利用ResultSet的getMetaData的方法可以获得ResultSetMeta对象，而ResultSetMetaData存储了ResultSet的MetaData。所谓的MetaData在英文中的解释为“Data about Data”，直译成中...
ResultSetMetaData使用实例
kuang_wu的专栏
12-05 596
本例中使用ORACLE数据库，表CLASS结构如下： 例子代码如下： import java.sql.Connection;import java.sql.DriverManager;import java.sql.PreparedStatement;import java.sql.ResultSet;import java.sql.ResultSetMetaData;import
ResultSetMetaData和DatabaseMetaData
wqe198612的专栏
10-10 505
MetaData的意思是元数据，即描述其他数据的数据，因此ResultSetMetaData封装了描述ResultSet对象的数据，这些描述ResultSet对象的数据包括列名、列类型、列数、表名等信息；而DatabaseMetaData则封装了描述Database的数据，这些描述数据库的元数据包括表类型、数据库的全部数据表、表的主键、表的外键、数据库里的存储过程、某个表的全部数据列等待信息。
java jdbc元数据,JDBC 进阶——元数据
weixin_36296864的博客
03-13 506
本文包括：1、元数据－ DatabaseMetaData2、元数据－ ParameterMetaData3、元数据－ ResultSetMetaData4、使用元数据简化JDBC代码Paste_Image.png1、元数据－ DatabaseMetaData元数据：数据库、表、列的定义信息，关于数据库的整体综合信息。获得对象：Connection.getMetaData()DataBaseMeta...
Java_17_数据库元数据&Mybatis框架：数据库元数据、Mybatis框架入门
Jinniu00 的博客
04-30 1018
一、数据库元数据 元数据：是指数据库、表、列的定义信息。即用来定义数据表的数据 回顾元注解 元注解是用来定义注解的注解 元数据分类 数据库元数据：可以获得数据库的版本，驱动版本等信息(了解) 参数元数据：用来获得占位符?的个数以及数据类型，参数指的是SQL语句中占位符? 结果集元数据：用来获得结果集中的列的数量，列的名称，以及列的类型 二、参数元数据–ParameterMetaData Para...
ResultSetMetaData获取数据库字段数据
最新发布
05-19
ResultSetMetaData是Java中提供的一个接口，它可以用来获取数据库结果集中的元数据信息，包括列名称、列类型、列的大小、列是否可为空等。 下面是一个简单的示例代码，演示如何使用ResultSetMetaData获取数据库字段...
ResultSetMetaData类的介绍
weixin_30814223的博客
02-18 46
利用ResultSet的getMetaData的方法可以获得ResultSetMeta对象，而ResultSetMetaData存储了ResultSet的MetaData。所谓的MetaData在英文中的解释为“Data about Data”，直译成中文则为“有关数据的数据”或者“描述数据的数据”，实际上就是描述及解释含义的数据。以Result的MetaData为例，ResultSet是以表格的...
ResultSetMetaData 、DatabaseMetaData中的方法的介绍
weixin_34344677的博客
10-24 76
ResultSetMetaData 、DatabaseMetaData中的方法的介绍 如何获取数据库信息及表的信息，如：数据库中有多少表，表中的字段的含义等，这里用主要用到相关的两个类ResultSetMetaData和DataBaseMetaData： 首先是ResultSetMetaData： 使用DatabaseMetaData则是用...
JDBC中的元数据ResultSetMetadata
天使的翅膀
12-12 131
public interface ResultSetMetaData可用于获取关于 ResultSet  对象中列的类型和属性信息的对象。相当于反射Class： 代码示例如下： package com.ambow.day21.jdbc.NewFecture; import java.sql.Connection; import java.sql.PreparedStatement; im...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值