利用反射机制，将ResultSet处理为bean或list的方法

最新推荐文章于 2024-10-01 18:51:18 发布
最新推荐文章于 2024-10-01 18:51:18 发布
阅读量170 收藏
点赞数
文章标签： java

我自己的处理：写一个util类，然后封装方法

Java代码 复制代码 收藏代码 
@SuppressWarnings("unchecked")
	public static List resultSetToList(ResultSet rs, Class cls)throws Exception {
	

			//取得Method 
	        Method[] methods = cls.getDeclaredMethods(); 
	       System.out.println(methods[0].getName());
			List lst = new ArrayList();
			// 用于获取列数、或者列类型
			ResultSetMetaData meta = rs.getMetaData();
			Object obj = null;
			while (rs.next()) {
				// 获取formbean实例对象
				obj = cls.newInstance(); // 用Class.forName方法实例化对象和new创建实例化对象是有很大区别的，它要求JVM首先从类加载器中查找类，然后再实例化，并且能执行类中的静态方法。而new仅仅是新建一个对象实例
				// 循环获取指定行的每一列的信息
				for (int i = 1; i <= meta.getColumnCount(); i++) {
					// 当前列名
					String colName = meta.getColumnName(i);
					
					// 设置方法名
					String setMethodName = "set" + colName;
					  
					
					 //遍历Method 
	                for (int j = 0; j < methods.length; j++) { 
	                    if (methods[j].getName().equalsIgnoreCase(setMethodName)) { 
	                        setMethodName = methods[j].getName(); 
	                        
	                        System.out.println(setMethodName);
	                    	// 获取当前位置的值，返回Object类型
	                        Object value = rs.getObject(colName); 
	                        if(value == null){
	                        	continue;
	                        }

	                        //实行Set方法 
	                        try { 
	                        	 利用反射获取对象
	                            //JavaBean内部属性和ResultSet中一致时候 
	                            Method setMethod = obj.getClass().getMethod( 
	                                    setMethodName, value.getClass()); 
	                            setMethod.invoke(obj, value); 
	                        } catch (Exception e) { 
	                            //JavaBean内部属性和ResultSet中不一致时候，使用String来输入值。 
	                           e.printStackTrace();
	                        } 
	                    } 
	                } 
				}
				lst.add(obj);
			}

			return lst;
		
	}

相关参考：

原文地址 http://blog.csdn.net/redria/article/details/2988158

Java代码 复制代码 收藏代码
  1. 其实反射也不是什么高深莫测的东西。反射就是我们对一个未知对象进行操作，由于它是未知的，所以我们需要从类型等方面下手，使用该对象共有的方法和属性，引用自该对象，从而得到我们想要的结果。
  5. 本文简单列举了一个利用反射将ResultSet的值自动赋值到POJO(JavaBean)对象的一个实例，便于大家学习。
  9. packagedemo;
  11. importjava.lang.reflect.Array;
  12. importjava.lang.reflect.Method;
  13. importjava.sql.ResultSetMetaData;
  14. importjava.sql.ResultSet;
  16. /**
  17. *绑定数据处理
  18. *Wrotebyredria
  19. */
  20. publicclassBindData{
  21. /**
  22. *从ResultSet绑定到JavaBean
  23. *
  24. *@paramResultSet
  25. *@paramDTO（JavaBean）
  26. *@returnDTO
  27. */
  28. publicstaticDTObindDataToDTO(ResultSetrs,DTOdto)throwsException{
  30. //取得Method方法
  31. Method[]methods=dto.getClass().getMethods();
  33. //取得ResultSet的列名
  34. ResultSetMetaDatarsmd=rs.getMetaData();
  35. intcolumnsCount=rsmd.getColumnCount();
  36. String[]columnNames=newString[columnsCount];
  37. for(inti=0;i<columnsCount;i++){
  38. columnNames[i]=rsmd.getColumnLabel(i+1);
  39. }
  41. //遍历ResultSet
  42. while(rs.next()){
  43. //反射,从ResultSet绑定到JavaBean
  44. for(inti=0;i<columnNames.length;i++){
  45. //取得Set方法
  46. StringsetMethodName="set"+columnNames[i];
  47. //遍历Method
  48. for(intj=0;j<methods.length;j++){
  49. if(methods[j].getName().equalsIgnoreCase(setMethodName)){
  50. setMethodName=methods[j].getName();
  51. Objectvalue=rs.getObject(columnNames[i]);
  53. //实行Set方法
  54. try{
  55. //JavaBean内部属性和ResultSet中一致时候
  56. MethodsetMethod=dto.getClass().getMethod(
  57. setMethodName,value.getClass());
  58. setMethod.invoke(dto,value);
  59. }catch(Exceptione){
  60. //JavaBean内部属性和ResultSet中不一致时候，使用String来输入值。
  61. MethodsetMethod=dto.getClass().getMethod(
  62. setMethodName,String.class);
  63. setMethod.invoke(dto,value.toString());
  64. }
  65. }
  66. }
  67. }
  68. }
  70. //戻り値
  71. returndto;
  72. }
  74. /**
  75. *从ResultSet绑定到JavaBean数组
  76. *
  77. *@paramResultSet
  78. *@paramDTO（JavaBean）
  79. *@returnDTO数组
  80. */
  81. publicstaticDTO[]bindDataToDTOS(ResultSetrs,DTOdto)throwsException{
  83. //取得Method
  84. Method[]methods=dto.getClass().getMethods();
  86. //取得ResultSet的列名
  87. ResultSetMetaDatarsmd=rs.getMetaData();
  88. intcolumnsCount=rsmd.getColumnCount();
  89. String[]columnNames=newString[columnsCount];
  90. for(inti=0;i<columnsCount;i++){
  91. columnNames[i]=rsmd.getColumnLabel(i+1);
  92. }
  94. //取得Class
  95. Class<?extendsDTO>dtoClass=dto.getClass();
  97. //取得record数
  98. rs.last();
  99. intrsCnt=rs.getRow();
  100. rs.beforeFirst();
  102. //DTO[]初期化
  103. DTO[]dtos=(DTO[])Array.newInstance(dtoClass,rsCnt);
  105. intdtoNow=0;
  106. //遍历ResultSet
  107. while(rs.next()){
  108. //DTO[]中DTO初期化
  109. dtos[dtoNow]=(DTO)dtoClass.newInstance();
  110. //反射,从ResultSet绑定到JavaBean
  111. for(inti=0;i<columnNames.length;i++){
  112. //取得Set方法
  113. StringsetMethodName="set"+columnNames[i];
  114. //遍历Method
  115. for(intj=0;j<methods.length;j++){
  116. if(methods[j].getName().equalsIgnoreCase(setMethodName)){
  117. setMethodName=methods[j].getName();
  118. Objectvalue=rs.getObject(columnNames[i]);
  120. //实行Set方法
  121. try{
  122. //JavaBean内部属性和ResultSet中一致时候
  123. MethodsetMethod=dto.getClass().getMethod(
  124. setMethodName,value.getClass());
  125. setMethod.invoke(dtos[dtoNow],value);
  126. }catch(Exceptione){
  127. //JavaBean内部属性和ResultSet中不一致时候，使用String来输入值。
  128. MethodsetMethod=dto.getClass().getMethod(
  129. setMethodName,String.class);
  130. setMethod.invoke(dtos[dtoNow],value.toString());
  131. }
  132. }
  133. }
  134. }
  135. dtoNow++;
  136. }
  138. //返回值
  139. returndtos;
  140. }
  141. }
  142. 当然这里的DTO是一个普通的JavaBean类。我们可以建立一个基类，然后建立我们要的JavaBean子类来继承于该基类，将子类扔进来反射，我们就可以得到一个绑定好数据的子类。诚然，我这里对数据类型判别的也不多，不是和ResultSet中一直的，统统变成了String，这里可以根据需要自行修改。
  146. 注意：这里如果要绑定，则必须JavaBean中的属性名称和ResultSet中的列名一致，反射也需要有一个参照对象不是么，不然绑定到哪里去呢？呵呵……
  150. 原理么，就是拿ResultSet中的列名和JavaBean中的属性名配对，然后赋值。
其实反射也不是什么高深莫测的东西。反射就是我们对一个未知对象进行操作，由于它是未知的，所以我们需要从类型等方面下手，使用该对象共有的方法和属性，引用自该对象，从而得到我们想要的结果。

 

本文简单列举了一个利用反射将ResultSet的值自动赋值到POJO(JavaBean)对象的一个实例，便于大家学习。

 

package demo; 

import java.lang.reflect.Array; 
import java.lang.reflect.Method; 
import java.sql.ResultSetMetaData; 
import java.sql.ResultSet; 

/** 
 * 绑定数据处理 
 * Wrote by redria 
 */ 
public class BindData { 
    /** 
     * 从ResultSet绑定到JavaBean 
     *  
     * @param ResultSet 
     * @param DTO（JavaBean） 
     * @return DTO 
     */ 
    public static DTO bindDataToDTO(ResultSet rs, DTO dto) throws Exception { 

        //取得Method方法 
        Method[] methods = dto.getClass().getMethods(); 

        //取得ResultSet的列名 
        ResultSetMetaData rsmd = rs.getMetaData(); 
        int columnsCount = rsmd.getColumnCount(); 
        String[] columnNames = new String[columnsCount]; 
        for (int i = 0; i < columnsCount; i++) { 
            columnNames[i] = rsmd.getColumnLabel(i + 1); 
        } 

        //遍历ResultSet 
        while (rs.next()) { 
            //反射, 从ResultSet绑定到JavaBean 
            for (int i = 0; i < columnNames.length; i++) { 
                //取得Set方法 
                String setMethodName = "set" + columnNames[i]; 
                //遍历Method 
                for (int j = 0; j < methods.length; j++) { 
                    if (methods[j].getName().equalsIgnoreCase(setMethodName)) { 
                        setMethodName = methods[j].getName(); 
                        Object value = rs.getObject(columnNames[i]); 

                        //实行Set方法 
                        try { 
                            //JavaBean内部属性和ResultSet中一致时候 
                            Method setMethod = dto.getClass().getMethod( 
                                    setMethodName, value.getClass()); 
                            setMethod.invoke(dto, value); 
                        } catch (Exception e) { 
                            //JavaBean内部属性和ResultSet中不一致时候，使用String来输入值。 
                            Method setMethod = dto.getClass().getMethod( 
                                    setMethodName, String.class); 
                            setMethod.invoke(dto, value.toString()); 
                        } 
                    } 
                } 
            } 
        } 

        //戻り値 
        return dto; 
    } 

    /** 
     *从ResultSet绑定到JavaBean数组 
     *  
     * @param ResultSet 
     * @param DTO（JavaBean） 
     * @return DTO数组 
     */ 
    public static DTO[] bindDataToDTOS(ResultSet rs, DTO dto) throws Exception { 

        //取得Method 
        Method[] methods = dto.getClass().getMethods(); 

        //取得ResultSet的列名  
        ResultSetMetaData rsmd = rs.getMetaData(); 
        int columnsCount = rsmd.getColumnCount(); 
        String[] columnNames = new String[columnsCount]; 
        for (int i = 0; i < columnsCount; i++) { 
            columnNames[i] = rsmd.getColumnLabel(i + 1); 
        } 

        //取得Class 
        Class<? extends DTO> dtoClass = dto.getClass(); 

        //取得record数 
        rs.last(); 
        int rsCnt = rs.getRow(); 
        rs.beforeFirst(); 

        //DTO[]初期化 
        DTO[] dtos = (DTO[]) Array.newInstance(dtoClass, rsCnt); 

        int dtoNow = 0; 
        //遍历ResultSet 
        while (rs.next()) { 
            //DTO[]中DTO初期化 
            dtos[dtoNow] = (DTO) dtoClass.newInstance(); 
            //反射, 从ResultSet绑定到JavaBean 
            for (int i = 0; i < columnNames.length; i++) { 
                //取得Set方法 
                String setMethodName = "set" + columnNames[i]; 
                //遍历Method  
                for (int j = 0; j < methods.length; j++) { 
                    if (methods[j].getName().equalsIgnoreCase(setMethodName)) { 
                        setMethodName = methods[j].getName(); 
                        Object value = rs.getObject(columnNames[i]); 

                        //实行Set方法 
                        try { 
                            //JavaBean内部属性和ResultSet中一致时候 
                            Method setMethod = dto.getClass().getMethod( 
                                    setMethodName, value.getClass()); 
                            setMethod.invoke(dtos[dtoNow], value); 
                        } catch (Exception e) { 
                            //JavaBean内部属性和ResultSet中不一致时候，使用String来输入值。 
                            Method setMethod = dto.getClass().getMethod( 
                                    setMethodName, String.class); 
                            setMethod.invoke(dtos[dtoNow], value.toString()); 
                        } 
                    } 
                } 
            } 
            dtoNow++; 
        } 

        //返回值 
        return dtos; 
    } 
}
当然这里的DTO是一个普通的JavaBean类。我们可以建立一个基类，然后建立我们要的JavaBean子类来继承于该基类，将子类扔进来反射，我们就可以得到一个绑定好数据的子类。诚然，我这里对数据类型判别的也不多，不是和ResultSet中一直的，统统变成了String，这里可以根据需要自行修改。

 

注意：这里如果要绑定，则必须JavaBean中的属性名称和ResultSet中的列名一致，反射也需要有一个参照对象不是么，不然绑定到哪里去呢？呵呵……

 

原理么，就是拿ResultSet中的列名和JavaBean中的属性名配对，然后赋值。

http://www.blogjava.net/wanghl259748/articles/277261.html

Java代码 复制代码 收藏代码
  1. 一般做法是将ResultSet封装成一个个javabean然后将javabean放入list集合中返回。
  3. 类似于：
  4. publicclasstest{
  6. DBdbx=newDB();
  8. publicstaticListresultSetToList(Stringsql)throwsSQLException{
  9. DBdbx=newDB();
  10. ResultSetrs=dbx.executeQuery(sql);
  11. ResultSetMetaDatamd=rs.getMetaData();
  12. for(inti=0;i<md.getColumnCount();i++){
  13. System.out.println(md.getColumnName(i));
  14. System.out.println("-----------------");
  15. }
  16. Listlist=newArrayList();
  17. while(rs.next()){
  18. UserBeanbean=newUserBean();
  19. intuserid=rs.getInt("userid");
  20. Stringusername=rs.getString("username");
  21. bean.setUserid(userid+"");
  22. bean.setUsername(username);
  23. list.add(bean);
  24. System.out.println(userid+""+username);
  25. }
  26. returnlist;
  27. }
  28. }
一般做法是将ResultSet封装成一个个javabean然后将javabean放入list集合中返回。 

类似于： 
public   class   test   { 

DB   dbx   =   new   DB(); 

public   static   List   resultSetToList(String   sql)   throws   SQLException   { 
DB   dbx   =   new   DB(); 
ResultSet   rs   =   dbx.executeQuery(sql); 
ResultSetMetaData   md   =   rs.getMetaData(); 
for   (int   i   =   0;   i   <   md.getColumnCount();   i++)   { 
System.out.println(md.getColumnName(i)); 
System.out.println( "----------------- "); 
} 
List   list   =   new   ArrayList(); 
while   (rs.next())   { 
UserBean   bean   =   new   UserBean(); 
int   userid   =   rs.getInt( "userid "); 
String   username   =   rs.getString( "username "); 
bean.setUserid(userid   +   " "); 
bean.setUsername(username); 
list.add(bean); 
System.out.println(userid   +   "   "+username); 
} 
return   list; 
} 
}

另外一种方法

Java代码 复制代码 收藏代码
  1. packagecom.service;
  3. importjava.lang.reflect.Method;
  4. importjava.sql.ResultSet;
  5. importjava.sql.ResultSetMetaData;
  6. importjava.util.ArrayList;
  7. importjava.util.List;
  9. importcom.entity.Student;
  11. publicclassService{
  12. publicListtoList(ResultSetrs,Classcls)
  13. {
  14. try
  15. {
  17. Listlst=newArrayList();
  18. //用于获取列数、或者列类型
  19. ResultSetMetaDatameta=rs.getMetaData();
  20. Objectobj=null;
  21. while(rs.next())
  22. {
  23. //获取formbean实例对象
  24. obj=Class.forName(cls.getName()).newInstance();//用Class.forName方法实例化对象和new创建实例化对象是有很大区别的，它要求JVM首先从类加载器中查找类，然后再实例化，并且能执行类中的静态方法。而new仅仅是新建一个对象实例
  25. //循环获取指定行的每一列的信息
  26. for(inti=1;i<=meta.getColumnCount();i++)
  27. {
  28. //当前列名
  29. StringcolName=meta.getColumnName(i);
  30. //将列名第一个字母大写（为什么加+""ne?是大写字母比小写字母多个字节？）
  31. colName=colName.replace(colName.charAt(0)+"",newString(colName.charAt(0)+"").toUpperCase());
  32. //设置方法名
  33. StringmethodName="set"+colName;
  34. System.out.println(methodName);
  35. //获取当前位置的值，返回Object类型
  36. Objectvalue=rs.getObject(i);
  37. //利用反射获取对象（反射概念很模糊？不太懂）
  38. Methodmethod=obj.getClass().getMethod(methodName,value.getClass());
  39. method.invoke(obj,value);//感觉这段类似于obj.setMethodName(value)......对于静态方法的反射可以写成method.invoke(null,value),而不能把第一个参数省略，如果方法没有参数的话，第二个参数可以为空
  40. }
  41. lst.add(obj);
  42. }
  44. returnlst;
  45. }
  46. catch(Exceptionex)
  47. {
  48. ex.printStackTrace();
  49. returnnull;
  50. }
  52. }
  53. }
package com.service;

import java.lang.reflect.Method;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.util.ArrayList;
import java.util.List;

import com.entity.Student;

public class Service {
    public List toList(ResultSet rs,Class cls)
    {
        try
        {
            
            List lst=new ArrayList();
            //用于获取列数、或者列类型
            ResultSetMetaData meta=rs.getMetaData();
            Object obj=null;
            while(rs.next())
            {
                //获取formbean实例对象
                obj=Class.forName(cls.getName()).newInstance();              //用Class.forName方法实例化对象和new创建实例化对象是有很大区别的，它要求JVM首先从类加载器中查找类，然后再实例化，并且能执行类中的静态方法。而new仅仅是新建一个对象实例
                //循环获取指定行的每一列的信息
                for(int i=1;i<=meta.getColumnCount();i++)
                {
                    //当前列名
                    String colName=meta.getColumnName(i);
                    //将列名第一个字母大写（为什么加+""ne ?是大写字母比小写字母多个字节？）
                    colName=colName.replace(colName.charAt(0)+"", new String(colName.charAt(0)+"").toUpperCase());
                    //设置方法名
                    String methodName="set"+colName;
                    System.out.println(methodName);
                    //获取当前位置的值，返回Object类型
                    Object value=rs.getObject(i);
                    //利用反射获取对象（反射概念很模糊？不太懂）
                    Method method=obj.getClass().getMethod(methodName, value.getClass());
                    method.invoke(obj, value);                 //感觉这段类似于obj.setMethodName(value)......对于静态方法的反射可以写成method.invoke(null,value),而不能把第一个参数省略，如果方法没有参数的话，第二个参数可以为空
                }
                lst.add(obj);
            }
            
            return lst;
        }
        catch(Exception ex)
        {
            ex.printStackTrace();
            return null;
        }
        
    }
}

Java代码 复制代码 收藏代码
  1. 使用BeanUtils类简化request和resultset转换
  2. 2009年06月01日20:02
  3. 当提交表单时，如果没有使用Struts等框架的话，你的代码可能是这样
  5. Useruser=newUser();
  6. user.setUsername(request.getParameter("username"));
  7. user.setPassword(request.getParameter("password"));
  8. user.setEmail(request.getParameter("email"));
  10. 如果表单项比较多，每次都要这样写是不是很烦？
  12. OK，使用commons-beanutils吧。你只需要这样写
  14. try{
  15. Mapparams=request.getParameterMap();
  16. BeanUtils.populate(user,params);
  17. }catch(Exceptione){
  18. //TODOAuto-generatedcatchblock
  19. e.printStackTrace();
  20. }
  21. 那么处理ResultSet时，如果没有Hibernate等框架，你的代码可能是这样
  23. if(rs.next()){
  24. Useruser=newUser();
  25. user.setId(rs.getLong("id"));
  26. user.setUsercode(rs.getString("usercode"));
  27. user.setSex(rs.getString("sex"));
  28. user.setPassword(rs.getString("password"));
  29. user.setPhone(rs.getString("phone"));
  30. user.setEmail(rs.getString("email"));
  31. users.add(user);
  32. }
  34. 是不是也有点烦？OK，这样来写吧
  36. ResultSetDynaClassrsdc=newResultSetDynaClass(rs);
  37. Iteratorrows=rsdc.iterator();
  38. ArrayListlists=newArrayList();
  39. while(rows.hasNext()){
  40. Useruser=newUser();
  41. DynaBeanrow=(DynaBean)rows.next();
  42. BeanUtils.copyProperties(user,row);
  43. lists.add(user)
  44. }
  46. 如何，是否让你的工作更加有效率了呢？

iteye_12332
关注
DAO层通用实现，结果集ResultSet转化为javaBean的反射实现，自动生成javaBean
欧阳金城-武
08-03 3604
在学习持久层框架之前，反复编写dao层代码编烦了，就自己实现了一个能方便地根据数据库表创建javaBean,并实现其增删改查，结果集转化为List集合，sql编译语句里参数赋值的自动化的“框架”。本文所使用的数据库是mysql自带的simple data里的sakila数据库 先看一下使用效果 实现过程 核心代码如下 其余代码会在后面贴上 其余代码先看一下使用效果： 先编写并运行测试类创建jav
通过反射方式把ResultSet映射到实体Vo上
weixin_37541878的博客
12-16 825
由于在老项目中没有使用一些持久层的框架，每次查询数据时都是要通过手动的方式取一行一行的赋值，研究了一些持久层框架的代码后，我用了自己的方式去把ResultSet的结果集映射到对应的实体上，这样可以减少写业务是对查询结果处理的繁杂工作 在没写我自己的映射方式时每次查询都要一下的操作 String sql = "select t.DIM_VALUE_CODE, t.DIM_VALUE_NAME from SP_DIM_VALUE_INFO t where t.dim_code = '0E0001' and t.
【Java】将ResultSet封装为Bean对象
qq_46599129的博客
10-07 1753
和其他的文章一样，也是利用反射封装，最后返回list集合 public class jdbcUtils { /** * MySQL数据库将result set风筝为Bean对象，需要数据库字段名和兵对象属性名一致(不区分大小写) * @param resultSet * @param beanClass * @param <T> * @return 返回Bean对象数组 * @throws Exception */
Java通过反射根据结果集ResultSet生成对应的JavaBean对象
renhq
04-26 2732
在写读数据库时由于JavaBean的属性太多，依次调用setter方法比较麻烦，动手写了一个工具类，通过反射实现自动根据查询的结果集(ResultSet)的一行结果封装成相应的JavaBean对象。 当然，你的JavaBean需要与数据库中的表对应。代码如下： 码云：https://gitee.com/ren_hq/codes/p7wr2kin90hymd4casbv520 public ...
《Java实战开发》运用反射从bean对象中取出属性 页面显示list优化
crazy王的学习
10-26 496
最近有一个需求，优化页面list下拉列表显示和数据库的查询，在页面显示的对象list下拉框的值改为根据指定的字段查询，并且封装到一个统一的LabelVO类中。 如何把查询到的对象中需要的属性名和值取出来放到LabelVO中是个问题，然后想到了用反射能不能解决，于是在网上查了一下，发现可以实现。 后端部分： public class LabelVo { String...
java反射bean_java反射应用对BEAN的操作，写通用类、标签时有用
weixin_35903340的博客
02-28 115
packagecom.hunau.liuyong;importjava.lang.reflect.Field;importjava.lang.reflect.InvocationTargetException;importjava.lang.reflect.Method;importjava.util.ArrayList;importjava.util.List;//其中User就是一个bean，...
java反射bean的属性值_java反射取属性值
weixin_35831256的博客
02-25 270
//Bean.javapackagecom.sort;publicclassBean {privateString name;privateString sex;publicBean() {super();//TODO Auto-generated constructor stub}publicBean(String name, String sex) {super();this.name=nam...
JAVA 版本ResultSet 转换为JAVABEAN的工具类
11-06
在Java编程中，ResultSet是处理数据库查询结果的主要接口，它由Statement或PreparedStatement对象执行SQL查询后返回。而JavaBean是一种符合特定规范的Java类，通常用于封装数据，便于数据的传输和操作。当我们从...
使用java反射将结果集封装成为对象和对象集合操作
08-24
使用 Java 反射将结果集封装成为对象和对象集合操作 ...我们学习了 Java 反射机制的基本概念和使用反射机制将结果集封装成为对象或者集合的方法。这些技术可以帮助我们更好地处理数据和对象之间的转换。
使用反射机制创建万能的数据库的增删查改
混合动力火锅的博客
11-28 382
package com.huoguo.common; import java.lang.reflect.Field; import java.sql.Connection; import java.sql.DriverManager; import java.sql.ResultSet; import java.sql.SQLException; import java.util.ArrayLi
java fastjson 泛型_解决fastjson泛型转换报错的解决方法
weixin_39595621的博客
02-17 724
错误信息Exception in thread "main" java.lang.ClassCastException: com.alibaba.fastjson.JSONObject cannot be cast to com.xh.demo.UserDO泛性类@Datapublic class ResultSetDTO {private Integer totalSize;private In...
数据库基础复习（一）
差不多先生
08-29 417
数据库的三范式是什么？ 第一范式：强调的是列的原子性，即数据库表的每一列都是不可分割的原子数据项。 第二范式：要求实体的属性完全依赖于主关键字。所谓完全依赖是指不能存在仅依赖主关键字一部分的属性。 第三范式：任何非主属性不依赖于其它非主属性。 ACID 是什么？ Atomicity（原子性）：一个事务（transaction）中的所有操作，或者全部完成，或者全部不完成，不会结束在中间某个环节。事务...
JAVA反射的使用之ResultSet的自动转换
零学IT
05-24 3305
Hello,大家好,上篇教程我们说了下反射的基本情况和简单使用，那么本篇教程我们就使用反射写一个工具类。用来将数据库查询结果的ResultSet转换为指定类型的对象。 使用反射来实现ResultSet内容的转换： //将查询结果的第一条数据转换为指定类型的对象 public static <T> T parseResultSet(ResultSet rs,Class<T> cls)
DatabaseMetaData ResultSet ResultSetMetaData三种类型的区别
suwu150
10-05 6026
DatabaseMetaData，ResultSet，ResultSetMetaData三种类型的区别 1、DatabaseMetaData 有关整个数据库的信息：数据库产品的名称和版本,数据库中表和列等信息，关于数据库的整体综合信息。 2、ResultSet 关于某个表的信息或一个查询的结果。必须逐行访问数据行，但是可以任何顺序访问列。这个ResultSet中包含的列可能是一个表中的所有列或者某些列,也能是多张表中不同的列，表示数据库结果集的数据表，通常通过执行查询数据库的语句生成 3、ResultSe
IHS下webwork的Calendar无法正确显示的问题解决
网络芝麻的快乐生活
02-03 879
今天发现一个问题，通过IHS（和Websphere经过插件连接）无法显示webwork中的Calendar插件。在页面上显示红叉。如果通过WAS的9080端口则可以正常访问，问题一定出在IHS上。 首先，通过抓包工具Fiddler2发现，IHS下webwork的calendar.js文件返回长度为0，说明IHS没有获取到calendar.js。为什么呢？决定跟踪IHS的插件看看。 
No result defined for action
mmmzzc的专栏
11-25 109
大家用 Ext + struts2 提交表单数据时 不知道是否遇见过 No result defined for action 这个的错误 这个错误 正经的 折磨了我很久 现在总结下 问题所在 和 解决方法 至今 我只遇到过两种情况 会出现这个问题 1。大家 都知道 Ext 是靠 name 往后台传值的，如果前台传的 name 值 再后台没有相应的 set 和 get ，也就是说 前台属性多...
JavaScript ArrayBuffer的读写与类型转换
最新发布
白瑕 的博客
10-01 403
所有视图的基本单位是ArrayBuffer, ArrayBuffer中只存储二进制格式的数据.ArrayBuffer不可直接读写, 必须通过视图(比如DataView)暴露的API.
spring-boot 整合 mybatis
m0_72168501的博客
09-29 510
spring boot 整合 mybatis
Java内存布局
阿呆的专栏
10-01 781
64位 JVM 不启用指针压缩时：Object Header 大小是16字节。64位 JVM 启用指针压缩时（默认）：Object Header 大小是12字节。32位 JVM：Object Header 大小是8字节。JVM在默认情况下启用指针压缩，但如果堆内存超过32GB，就会禁用指针压缩。32GB是压缩指针的最大寻址范围。超过32GB的堆内存中，压缩指针带来的性能提升并不显著，而且需要解压指针反而可能增加开销。
Java反射：将ResultSet封装为对象与集合的操作指南
本文将详细介绍如何利用Java反射将数据库查询的结果集（通常作为`ResultSet`对象）有效地封装成对象实例，进而转化为对象集合。 首先，让我们了解一下Java反射的基础概念： 1. **反射API**: Java反射主要包括`java...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值