hibernate 原生查询实现结果集 转换成实体类

最新推荐文章于 2024-04-23 18:52:22 发布
最新推荐文章于 2024-04-23 18:52:22 发布
阅读量980 收藏
点赞数
文章标签： java python
原文链接：https://my.oschina.net/u/3065626/blog/1813095
版权

2019独角兽企业重金招聘Python工程师标准>>> hot3.png

hibernate原生sql查询返回对应的实体类 调用有点麻烦 目前自己写了2中方法 可以记录一下 一种hibernate提供的  需要在sql里实现as 成实体类的类名  另一种不需要as  直接按照驼峰式命名法 转换。

直接上代码


hibernate的方法
Query nativeQuery = createNamedDynamicQuery(queryName, params);
		nativeQuery.unwrap(SQLQuery.class).setResultTransformer(Transformers.aliasToBean(c));
		List<?> objs = nativeQuery.getResultList();

 

自己实现的方法

Query nativeQuery = createNamedDynamicQuery(queryName, params);
		nativeQuery.unwrap(SQLQuery.class).setResultTransformer(new SqlResultToBeanTransformer(c));
		return nativeQuery.getResultList();



import java.lang.reflect.Method;
import java.math.BigDecimal;
import java.util.Date;
import java.util.List;
import java.util.StringTokenizer;

import org.hibernate.HibernateException;
import org.hibernate.property.access.spi.Setter;
import org.hibernate.transform.ResultTransformer;
import org.springframework.util.StringUtils;


/**
 * Convert query result to vo list util class.
 */
public class SqlResultToBeanTransformer implements ResultTransformer {
    private static final long serialVersionUID = -5199190581393587893L;
    private final Class resultClass;
    private Setter[] setters;
    public SqlResultToBeanTransformer(Class resultClass) {
        if (resultClass == null) throw new IllegalArgumentException("resultClass cannot be null");
        this.resultClass = resultClass;
        }
    public Object transformTuple(Object[] tuple, String[] aliases) {
        Object result = null;
        try {
        	result=resultClass.newInstance();
        	
        	for (int i = 0; i < aliases.length; i++) {
                 String alias = convertColumnToProperty(aliases[i]);
                                 
                 if (alias != null && tuple[i]!=null) {
                 	mappingFieldsToObject(result,alias,tuple[i]);
                 }
             }
               
        } catch (InstantiationException e) {
            throw new HibernateException("Could not instantiate resultclass: " + resultClass.getName());
        } catch (IllegalAccessException e) {
            throw new HibernateException("Could not instantiate resultclass: " + resultClass.getName());
        }
        return result;
    }
    /**
     * Converts the specified 'XXX_YYY_ZZZ'-like column name to its
     * 'xxxYyyZzz'-like Java property name.
     *
     *   columnName the column name
     *   the Java property name
     */
    public String convertColumnToProperty(String columnName) {
        columnName = columnName.toLowerCase();
        StringBuffer buff = new StringBuffer(columnName.length());
        StringTokenizer st = new StringTokenizer(columnName, "_");
        while (st.hasMoreTokens()) {
            buff.append(StringUtils.capitalize(st.nextToken()));
        }
        buff.setCharAt(0, Character.toLowerCase(buff.charAt(0)));
        return buff.toString();
    }
    @SuppressWarnings({ "rawtypes", "unchecked" })
	public List transformList(List collection) {
        return collection;
    }
    

	public void mappingFieldsToObject(Object o,String field,Object value){

        	// 从JavaBean中得到所有的方法   
        	Method[] methods = o.getClass().getDeclaredMethods();   
        	
        	Method[] superClassMethods=null;//父类方法
        	
        	//取得父类的方法
        	if(o.getClass().getGenericSuperclass()!=null){
        		Class superClass = o.getClass().getSuperclass();// 父类
        		superClassMethods=superClass.getDeclaredMethods();//父类方法
        	}
  
        	String tem1 = field;   
      
  
            if (tem1 != null && !"".equals(tem1)){   
                String methodName = "set" + tem1.substring(0, 1).toUpperCase();   
                if (tem1.length() > 1){   
                    methodName += tem1.substring(1);   
                }   
                
              //遍历方法名
                for (int i = 0; i < methods.length; i++){
                	
                    if (methodName.equals(methods[i].getName())){   
                        Method method = methods[i];   
                        
                      
                        if (method.getParameterTypes()[0] == String.class){
                        	
                        		
                            String param = null2String(value.toString());   
                            try  
                            {   
                                method.invoke(o, new Object[]{param});   
                            }   
                            catch (Exception e)   
                            {   
                                e.printStackTrace();   
                                System.out.println("注入值时出错");   
                            }   
  
                        }   
                        else if (method.getParameterTypes()[0] == int.class || method.getParameterTypes()[0]== Integer.class)   
                        {   
                            String param = null2Zero(value.toString());   
                            Integer intParam = null;   
                            try  
                            {   
                                intParam = Integer.valueOf(param);   
                            }   
                            catch (NumberFormatException e1)   
                            {   
                                intParam = new Integer(0);   
                            }   
                            try  
                            {   
                                method.invoke(o, new Object[]   
                                {   
                                    intParam   
                                });   
                            }   
                            catch (Exception e)   
                            {   
                                e.printStackTrace();   
                                System.out.println("注入值时出错");   
                            }   
  
                        } 
                        else if (method.getParameterTypes()[0] == long.class || method.getParameterTypes()[0]==Long.class)   
                        {   
                            String param = null2Zero(value.toString());   
                            Long intParam = null;   
                            try  
                            {   
                                intParam = Long.valueOf(param);   
                            }   
                            catch (NumberFormatException e1)   
                            {   
                                intParam = new Long(0);   
                            }   
                            try  
                            {   
                                method.invoke(o, new Object[]   
                                {   
                                    intParam   
                                });   
                            }   
                            catch (Exception e)   
                            {   
                                e.printStackTrace();   
                                System.out.println("注入值时出错");   
                            }   
  
                        } 
                        else if (method.getParameterTypes()[0] == float.class || method.getParameterTypes()[0]==Float.class)   
                        {   
                            String param = null2Zero(value.toString());   
                            Float floatParam = null;   
                            try  
                            {   
                                floatParam = Float.valueOf(param);   
                            }   
                            catch (NumberFormatException e1)   
                            {   
                                floatParam = new Float(0.0F);   
                            }   
                            try  
                            {   
                                method.invoke(o, new Object[]   
                                {   
                                    floatParam   
                                });   
                            }   
                            catch (Exception e)   
                            {   
                                e.printStackTrace();   
                                System.out.println("注入值时出错");   
                            }   
  
                        }   
                        else if (method.getParameterTypes()[0] == double.class || method.getParameterTypes()[0]==Double.class)   
                        {   
                            String param = null2Zero(value.toString());   
                            Double doubleParam = null;   
                            try  
                            {   
                                doubleParam = Double.valueOf(param);   
                            }   
                            catch (NumberFormatException e1)   
                            {   
                                doubleParam = new Double(0);   
                            }   
                            try  
                            {   
                                method.invoke(o, new Object[]   
                                {   
                                    doubleParam   
                                });   
                            }   
                            catch (Exception e)   
                            {   
                                e.printStackTrace();   
                                System.out.println("注入值时出错");   
                            }   
  
                        }   
                        else if (method.getParameterTypes()[0] == boolean.class || method.getParameterTypes()[0]==Boolean.class)   
                        {   
                            String param = null2String(value.toString());   
                            if (!"true".equals(param))   
                            {   
                                param = "false";   
                            }   
                            Boolean booleanParam = Boolean.valueOf(param);   
                            try  
                            {   
                                method.invoke(o, new Object[]   
                                {   
                                    booleanParam   
                                });   
                            }   
                            catch (Exception e)   
                            {   
                                e.printStackTrace();   
                                System.out.println("注入值时出错");   
                            }   
                        } else if (method.getParameterTypes()[0] == Date.class)   
                        {   
//                            String param = null2String(value.toString());   
//                            Date booleanParam = CommonUtil.convertDateTime(param);
                        	
                        	Date booleanParam = (Date) value;
                            try  
                            {   
                                method.invoke(o, new Object[]   
                                {   
                                    booleanParam   
                                });   
                            }   
                            catch (Exception e)   
                            {   
                                e.printStackTrace();   
                                System.out.println("注入值时出错");   
                            }   
                        } else if (method.getParameterTypes()[0] == BigDecimal.class)   
                        {   
                      	
                        	BigDecimal bigDecimalParam = (BigDecimal) value;
                          try  
                          {   
                              method.invoke(o, new Object[]   
                              {   
                            		  bigDecimalParam   
                              });   
                          }   
                          catch (Exception e)   
                          {   
                              e.printStackTrace();   
                              System.out.println("注入值时出错");   
                          }   
                      } else if (method.getParameterTypes()[0] == char.class || method.getParameterTypes()[0] == Character.class)   
                      {    
                    	  Character characterParam = (Character)value;     
                          try  
                          {   
                              method.invoke(o, new Object[]   
                              {   
                            		characterParam   
                              });   
                          }   
                          catch (Exception e)   
                          {   
                              e.printStackTrace();   
                              System.out.println("注入值时出错");   
                          }
                    }  
                        break;   
                    }   
  
                }
                
                
              //遍历父类方法名
                for (int i = 0; i < superClassMethods.length; i++){
                	
                    if (methodName.equals(superClassMethods[i].getName())){   
                        Method method = superClassMethods[i];   
                        
                    
                       
                        if (method.getParameterTypes()[0] == String.class){   
                            String param = null2String(value.toString());   
                            try  
                            {   
                                method.invoke(o, new Object[]{param});   
                            }   
                            catch (Exception e)   
                            {   
                                e.printStackTrace();   
                                System.out.println("注入值时出错");   
                            }   
  
                        }   
                        else if (method.getParameterTypes()[0] == int.class || method.getParameterTypes()[0]== Integer.class)   
                        {   
                            String param = null2Zero(value.toString());   
                            Integer intParam = null;   
                            try  
                            {   
                                intParam = Integer.valueOf(param);   
                            }   
                            catch (NumberFormatException e1)   
                            {   
                                intParam = new Integer(0);   
                            }   
                            try  
                            {   
                                method.invoke(o, new Object[]   
                                {   
                                    intParam   
                                });   
                            }   
                            catch (Exception e)   
                            {   
                                e.printStackTrace();   
                                System.out.println("注入值时出错");   
                            }   
  
                        } 
                        else if (method.getParameterTypes()[0] == long.class || method.getParameterTypes()[0]==Long.class)   
                        {   
                            String param = null2Zero(value.toString());   
                            Long intParam = null;   
                            try  
                            {   
                                intParam = Long.valueOf(param);   
                            }   
                            catch (NumberFormatException e1)   
                            {   
                                intParam = new Long(0);   
                            }   
                            try  
                            {   
                                method.invoke(o, new Object[]   
                                {   
                                    intParam   
                                });   
                            }   
                            catch (Exception e)   
                            {   
                                e.printStackTrace();   
                                System.out.println("注入值时出错");   
                            }   
  
                        } 
                        else if (method.getParameterTypes()[0] == float.class || method.getParameterTypes()[0]==Float.class)   
                        {   
                            String param = null2Zero(value.toString());   
                            Float floatParam = null;   
                            try  
                            {   
                                floatParam = Float.valueOf(param);   
                            }   
                            catch (NumberFormatException e1)   
                            {   
                                floatParam = new Float(0.0F);   
                            }   
                            try  
                            {   
                                method.invoke(o, new Object[]   
                                {   
                                    floatParam   
                                });   
                            }   
                            catch (Exception e)   
                            {   
                                e.printStackTrace();   
                                System.out.println("注入值时出错");   
                            }   
  
                        }   
                        else if (method.getParameterTypes()[0] == double.class || method.getParameterTypes()[0]==Double.class)   
                        {   
                            String param = null2Zero(value.toString());   
                            Double doubleParam = null;   
                            try  
                            {   
                                doubleParam = Double.valueOf(param);   
                            }   
                            catch (NumberFormatException e1)   
                            {   
                                doubleParam = new Double(0);   
                            }   
                            try  
                            {   
                                method.invoke(o, new Object[]   
                                {   
                                    doubleParam   
                                });   
                            }   
                            catch (Exception e)   
                            {   
                                e.printStackTrace();   
                                System.out.println("注入值时出错");   
                            }   
  
                        }   
                        else if (method.getParameterTypes()[0] == boolean.class || method.getParameterTypes()[0]==Boolean.class)   
                        {   
                            String param = null2String(value.toString());   
                            if (!"true".equals(param))   
                            {   
                                param = "false";   
                            }   
                            Boolean booleanParam = Boolean.valueOf(param);   
                            try  
                            {   
                                method.invoke(o, new Object[]   
                                {   
                                    booleanParam   
                                });   
                            }   
                            catch (Exception e)   
                            {   
                                e.printStackTrace();   
                                System.out.println("注入值时出错");   
                            }   
                        } else if (method.getParameterTypes()[0] == Date.class)   
                        {   
//                            String param = null2String(value);   
                           
//                            Date booleanParam = CommonUtil.convertDateTime(param);
                        	Date booleanParam = (Date) value;
                            try  
                            {   
                                method.invoke(o, new Object[]   
                                {   
                                    booleanParam   
                                });   
                            }   
                            catch (Exception e)   
                            {   
                                e.printStackTrace();   
                                System.out.println("注入值时出错");   
                            }   
                        } else if (method.getParameterTypes()[0] == BigDecimal.class)   
                        {   
                      	
                        	BigDecimal bigDecimalParam = (BigDecimal) value;
                          try  
                          {   
                              method.invoke(o, new Object[]   
                              {   
                            		  bigDecimalParam   
                              });   
                          }   
                          catch (Exception e)   
                          {   
                              e.printStackTrace();   
                              System.out.println("注入值时出错");   
                          }   
                      } else if (method.getParameterTypes()[0] == char.class || method.getParameterTypes()[0] == Character.class)   
                      {    
                    	  Character characterParam = (Character)value;     
                          try  
                          {   
                              method.invoke(o, new Object[]   
                              {   
                            		characterParam   
                              });   
                          }   
                          catch (Exception e)   
                          {   
                              e.printStackTrace();   
                              System.out.println("注入值时出错");   
                          }
                    }    
                        break;   
                    }   
  
                }
            }   
  
        
        
}
	
	

    private static String null2Zero(String str)   
    {   
        if (str == null || "".equals(str.trim()))   
        {   
            return "0";   
        }   
        return str.trim();   
    }   
  
    private static String null2String(String str)   
    {   
        if (str == null)   
        {   
            return "";   
        }   
        return str.trim();   
    }   
}

 

转载于:https://my.oschina.net/u/3065626/blog/1813095

weixin_34279579
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
idea hibernate jpa 生成实体类的实现
08-25
主要介绍了idea hibernate jpa 生成实体类的实现，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
Hibernate查询结果转换为实体类型 (HQL/SQL)
Hardy专栏
03-31 4470
在使用Hibernate时，大部分情况使用HQL直接得到的就是实体了，但有时你或许要用到自定义实体的转换，可以参考如下 1.POJO实体 session.createSQLQuery(queryString.toString()).addEntity(实体.class); 2.普通JavaBean(非HibernatePOJO实体) SQLQuery query
Hibernate新手常见问题org.hibernate.service.spi.ServiceException: Unable to create requested service
热门推荐
成君的博客
06-04 2万+
org.hibernate.service.spi.ServiceException: Unable to create requested service [org.hibernate.engine.jdbc.env.spi.JdbcEnvironment]首先看到jdbcEnvironment肯定得先考虑jdbc配置的问题，驱动？配置文件？第一步：    检查数据库的驱动，例如：mysql-c...
JPA自定义VO接受返回结果集（unwrap）
乐闻世界
08-01 1万+
JPA跟mybitis比较，简单的业务搜索是方便的，但是设计到复杂的SQL搜索时，我们需要自定义SQL。 1.@Query直接写SQL,缺点是无法动态的组装条件 2.JPA的Specification对象动态组装where搜索条件 3.entityManager执行CriteriaBuilder 4.entityManger直接使用createNativeQuery，执行原生SQL。这里设...
Hibernate属性映射（一）
weixin_46222571的博客
04-13 226
Hibernate属性映射（一） 普通属性 假设有A类属性有属性x,A类与数据表a形成orm映射，属性x与字段y相对应。 class A{ private int x; } 在.hbm.xml中配置(省去id,包名,xml schema的引入): <hibernate-mapping> <class name="A" table="a"> ...
Hibernate级联的异常
有 prepare , No out
09-27 774
object references an unsaved transient instance - save the transient instance before flushing: com.lyq.model.Category 在book 配置文件上加上  cascade="save-update" 异常就没有了，他的这个定义其实不是要做什么的，是必须的，不然会异常
Hibernate sql查询结果转换新建的实体方法
m0_60349254的博客
01-17 165
sql查询结果转换新建的实体方法
hibernate _HQL多表语法详解
weixin_33962621的博客
01-31 130
一：数据表||实体类1、数据库表数据1、Orders表 2、Customer表 2、实体类1、Orders实体类2、Customer实例类二：回顾原生SQL语句多表查询1、交叉连接-笛卡尔乘积SELECT * FROM 表名1,表名22、内连接(两表交集的部分)|—隐式内连接1、 SELECT * FROM 表名1,表名2 where 表名1.id=表名2.id|-显示内连接1、SELECT * ...
【Hibernate】Hibernate多表查询后，将查询结果转化为实体
编程记录，亲测有效
11-16 1万+
在《【Hibernate】Hibernate的多表查询》（点击打开链接）一文中，已经介绍过，如果利用HQL语句进行多表查询，摆脱查完一张表又取其中的结果再查另一张表的问题。然而，利用HQL语句查询出来的东西，是一个Object数组，我们要进一步对其处理，将其转化为表的实体的实例。 有如下的一个Java工程如《【Hibernate】Hibernate3.x独立运行时的Failed to load
关于hibernate从数据库中获得pojo值的一些小细节
zhou2003737的专栏
05-20 902
原生SQL查询执行的控制是通过SQLQuery接口进行的，通过执行Session.createSQLQuery()获取这个接口。下面来描述如何使用这个API进行查询。标量查询（Scalar queries）最基本的SQL查询就是获得一个标量（数值）的列表。sess.createSQLQuery("SELECT * FROM CATS").list();sess.createSQLQuery("SE
Hibernate 使用SQL查询生成Entity对象
起飞的老鸟
11-27 238
昨天项目中有几个比较复杂的查询 ，故使用了createSQLQuery方法。 以前用它调用SQL语句进行查询，返回List,然后我在Action里一个一个的set语句生成Entity对象,那个累就不用说了。昨天朋友告诉我，Hibernate可以给我生成Entity对象，试了下果然好用，故我也贴出来。万分感谢。 [b]一：直接使用SQLQuery的addEntity方法[/b][code=...
IntelliJ IDEA下自动生成Hibernate映射文件以及实体类
08-25
主要介绍了IntelliJ IDEA下自动生成Hibernate映射文件以及实体类，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
Hibernate_实体类_注解_说明
11-21
Hibernate 实体类 注解及功能说明。
java根据实体类生成Hibernate映射文件
03-30
根据实体类生成简单的Hibernate映射文件，对不用Myeclipse的童鞋还是有用
springmvc4+hibernate4分页查询功能实现
08-31
本篇文章主要介绍了springmvc4+hibernate4分页查询功能实现，Springmvc+hibernate成为现在很多人用的框架整合，有兴趣的可以了解一下。
mybatisPlus使用MetaObjectHandler对字段进行更新
最新发布
m0_56356631的博客
04-23 342
都是符合我们的预期的。
string模拟实现
m0_73969414的博客
04-23 1444
c++中string的模拟实现，面试必会知识点
实现自定义注解、实现自定义幂等性注解
qq_44721738的博客
04-23 613
添加 Spring AOP 依赖。创建自定义注解。创建一个新的 Java 注解类，通过@interface关键字来定义，并可以添加元注解以及属性。@Target(ElementType.METHOD) //表示作用于方法上@Retention(RetentionPolicy.RUNTIME) // 表示这个注解在运行时是可见的，这样 AOP 代理才能在运行时读取到这个注解编写 AOP 拦截（自定义注解）的逻辑代码。@Aspect@Component// 方法执行前的处理。
javaweb-SpringBoot基础
kussm_的博客
04-20 1342
Spring的官网(Spring的简介：Spring makes Java simple。Spring Boot 可以帮助我们非常快速的构建应用程序、简化开发、提高效率。创建一个子包controller。
hibernate映射实体类查询时数据库空字段赋值给实体类报错的问题
05-29
如果你在使用Hibernate框架查询数据库时，数据库中某些字段为空，但是在将查询结果映射到实体类时，由于空字段无法转换成实体类属性的默认值，导致程序报错，那么你可以通过以下两种方式解决这个问题： 1. 使用包装...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值