最原始的O/R Mapping,比hibernate轻的多

hibernate的O/R Mapping确实很强大，但是对于查询如果要使用hibernate的Query来实现，就必须先写好mapping，对于单个表还好办，但如果是复杂的多表连接查询的话就得写一大堆mapping和Entity，稍有疏漏就会出错，那hibernate有没有提供更简单的sql query接口呢？简单到仅仅需要写个sql，并提供一个Entity的包路径（当然这个Entity bean还是要程序员来实现的），执行.list()就能轻松将返回的每行记录注入Entity，最后结果集以list返回？从而解放了程序员繁重的劳动，使开发更加敏捷呢？

带着这个疑问我看了hibernate reference，看到hibernate提供session.createSQLQuery接口，似乎可以满足我的要求，好！让我来试试看，于是有了下面的代码：

	public List<Private> getPublicIndex(String startDate, String endDate) throws SQLException {
		StringBuffer sql = new StringBuffer();
		sql.append("select a.id as id, a.money as deposit, b.money as loan, c.money as loanleave, a.tdate as tdate")
			.append(" FROM publicindex a inner join publicindex b")
			.append(" on a.tdate = b.tdate and a.flag = '1' and b.flag = '2'")
			.append(" inner join publicindex c")
			.append(" on a.tdate = c.tdate and c.flag = '3'")
			.append(" where (a.tflag = 2 or a.tflag = 3 or a.tflag = 7) and")
			.append(" (b.tflag = 2 or b.tflag = 3 or b.tflag = 7) and")
			.append(" (c.tflag = 2 or c.tflag = 3 or c.tflag = 7) and")
			.append(" a.tdate >= to_date(?, 'yyyy-mm-dd') and")
			.append(" a.tdate <= to_date(?, 'yyyy-mm-dd')")
			.append(" order by a.tdate");
		Session session = dao.openSession();
		return session.createSQLQuery(sql.toString()).addEntity(Private.class).setParameter(0, startDate).setParameter(1, endDate).list();
	}

说明下：dao是公司前辈封装的一个简单框架，同时支持jdbc和hibernate，对于Private.class，仅仅是个bean，并没有写hibernate mapping，测试发现抛了下面的异常：

org.hibernate.MappingException: Unknown entity: com.cuishen.edwview.pojo.Private

于是我就mapping了一个简单的Entity，做了个简单的单表sql查询，如下：

	public List<TechnicApp> getTechnicApp(String date) throws SQLException {
		String sql = "select * from technicappindex t where t.tdate = to_date(?, 'yyyy-mm-dd')";
		Session session = dao.openSession();
		return session.createSQLQuery(sql).addEntity(TechnicApp.class).setParameter(0, date).list();
	}

说明下：将technicappindex表mapping为TechnicApp，测试通过了！看来hibernate的sql query还是不能完全脱离mapping

于是我修改了dao的代码，在jdbc返回结果集做封装的模块中加入了如下代码：

    /**
     * 反射POJO的setter方法，将记录中匹配的列值注入POJO，最后以List返回，
     * 在不区分大小写的情况下记录中的列名（加上'set'前缀）必须和POJO中的公有setter方法名一致，
     * 否则将不会被注入
     * @param list 要返回的list
     * @param pojoClassName String 要注入的POJO的包路径, e.g 'com.cuishen.pojo.Cat'
     * @param rs ResultSet 待封装的原始结果集
     */
    private static void setPOJO(List list, String pojoClassName, ResultSet rs) {
    	try {
			ResultSetMetaData metaData = rs.getMetaData();
			int columnCount = metaData.getColumnCount(); // 查询的列数
			Method [] methodsToInvoke = new Method[columnCount];
			Class pojo = Class.forName(pojoClassName);
			Method [] methods = pojo.getMethods();
			for(int i = 0; i < columnCount; i++) {
				for(int j = 0; j < methods.length; j++) {
					String methodName = methods[j].getName();
					if(methodName.equalsIgnoreCase("set" + metaData.getColumnName(i + 1))) {
						methodsToInvoke[i] = methods[j];
						log4j.debug(">>>>>> method name : " + methodsToInvoke[i].getName() + " para name : " + methodsToInvoke[i].getParameterTypes()[0].getName());
						log4j.debug("======= >>>>>>> column name : " + metaData.getColumnName(i + 1) + " column type : " + metaData.getColumnClassName(i + 1));
						break;
					}
				}
			}
			while(rs.next()) {
				Object obj = pojo.newInstance();
				for(int i = 0; i < columnCount; i++) {
					methodsToInvoke[i].invoke(obj, new Object[]{castValue(rs.getObject(i + 1), methodsToInvoke[i].getParameterTypes()[0])});
				}
				list.add(obj);
			}
		} catch (InstantiationException e) {
			e.printStackTrace();
			log4j.error(e.getMessage(), e);
		} catch (IllegalAccessException e) {
			e.printStackTrace();
			log4j.error(e.getMessage(), e);
		} catch (SQLException e) {
			e.printStackTrace();
			log4j.error(e.getMessage(), e);
		} catch (IllegalArgumentException e) {
			e.printStackTrace();
			log4j.error(e.getMessage(), e);
		} catch (InvocationTargetException e) {
			e.printStackTrace();
			log4j.error(e.getMessage(), e);
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
			log4j.error(e.getMessage(), e);
		}
    }
    /**
     * 类型强制转换
     * @param source
     * @param target
     * @return
     */
    private static Object castValue(Object source, Class target) {
    	if(source instanceof BigDecimal) {
    		if(target == Long.class) return new Long(((BigDecimal)source).longValue());
    		else if(target == Integer.class) return new Integer(((BigDecimal)source).intValue());
    		else if(target == Short.class) return new Short(((BigDecimal)source).shortValue());
    		else if(target == Double.class) return new Double(((BigDecimal)source).doubleValue());
    		else if(target == Float.class) return new Float(((BigDecimal)source).floatValue());
    	}
    	return source;
    }

然后在dao里实现了新的接口：

    /**
     * jdbc sql查询，将记录注入POJO，结果集最终以list返回
     * @param sql String sql语句
     * @param params sql中的参数
     * @param pojo String POJO的包路径
     */
    List sqlQueryAsPOJO(String sql, Object[] params, String pojo) throws SQLException;

哈哈，现在做多表连接查询简单多啦！

	public List<Private> getPublicIndex(String startDate, String endDate) throws SQLException {
		StringBuffer sql = new StringBuffer();
		sql.append("select a.id as id, a.money as deposit, b.money as loan, c.money as loanleave, a.tdate as tdate")
			.append(" FROM publicindex a inner join publicindex b")
			.append(" on a.tdate = b.tdate and a.flag = '1' and b.flag = '2'")
			.append(" inner join publicindex c")
			.append(" on a.tdate = c.tdate and c.flag = '3'")
			.append(" where (a.tflag = 2 or a.tflag = 3 or a.tflag = 7) and")
			.append(" (b.tflag = 2 or b.tflag = 3 or b.tflag = 7) and")
			.append(" (c.tflag = 2 or c.tflag = 3 or c.tflag = 7) and")
			.append(" a.tdate >= to_date(?, 'yyyy-mm-dd') and")
			.append(" a.tdate <= to_date(?, 'yyyy-mm-dd')")
			.append(" order by a.tdate");
		return dao.sqlQueryAsPOJO(sql.toString(), new String[]{startDate, endDate}, "com.cuishen.edwview.pojo.Private");
	}

新加的代码是对jdbc的简单封装，并没有用到hibernate，代码还不够通用，以后还要改进。

评论

23 楼 wuhoufeng 2009-12-14  

2楼正解，直接使用sql是不受hibernate管理的，享受不到原本的一些好处。

22 楼 ldinh 2009-12-14  

确实挺原始。感觉lz不应该拿出来和Hibernate一起说。

21 楼 cuishen 2009-12-14  

xzh_endless 写道

如果工作地项目是糊弄人骗钱的，尽量使用吧！
要是以后自己使用，修改，运营，还是踏踏实实的作技术吧。
开发速度快，等价于“质量”差。

你凭什么说敏捷开发等价于质量差？？
难道说一个项目拖的时间越长，质量就越好？？

20 楼 xzh_endless 2009-12-13  

如果工作地项目是糊弄人骗钱的，尽量使用吧！
要是以后自己使用，修改，运营，还是踏踏实实的作技术吧。
开发速度快，等价于“质量”差。

19 楼 cuishen 2009-12-10  

hudefeifei1 写道

兄弟。你肯定没读过H的源码吧，看以下然后比较下setPOJO这个类的效率

下面是hibernate3.2.1的源代码:

package org.hibernate.transform;
public class AliasToBeanResultTransformer implements ResultTransformer {
	public Object transformTuple(Object[] tuple, String[] aliases) {
		Object result;
		
		try {
			if(setters==null) {
				setters = new Setter[aliases.length];
				for (int i = 0; i < aliases.length; i++) {
					String alias = aliases[i];
					if(alias != null) {
						setters[i] = propertyAccessor.getSetter(resultClass, alias);
					}
				}
			}
			result = resultClass.newInstance();
			
			for (int i = 0; i < aliases.length; i++) {
				if(setters[i]!=null) {
					setters[i].set(result, tuple[i], null);
				}
			}
		} 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;
	}
}

package org.hibernate.property;
public class ChainedPropertyAccessor implements PropertyAccessor {
	public Getter getGetter(Class theClass, String propertyName)
			throws PropertyNotFoundException {
		Getter result = null;
		for (int i = 0; i < chain.length; i++) {
			PropertyAccessor candidate = chain[i];
			try {
				result = candidate.getGetter(theClass, propertyName);
				return result;
			} catch (PropertyNotFoundException pnfe) {
				// ignore
			}
		}
		throw new PropertyNotFoundException("Could not find getter for " + propertyName + " on " + theClass);
	}

	public Setter getSetter(Class theClass, String propertyName)
			throws PropertyNotFoundException {
		Setter result = null;
		for (int i = 0; i < chain.length; i++) {
			PropertyAccessor candidate = chain[i];
			try {
				result = candidate.getSetter(theClass, propertyName);
				return result;
			} catch (PropertyNotFoundException pnfe) {
				//
			}
		}
		throw new PropertyNotFoundException("Could not find setter for " + propertyName + " on " + theClass);
	}

}

package org.hibernate.property;
public class BasicPropertyAccessor implements PropertyAccessor {
	public static final class BasicSetter implements Setter {
		public void set(Object target, Object value, SessionFactoryImplementor factory) 
		throws HibernateException {
			try {
				method.invoke( target, new Object[] { value } );
			}
			catch (NullPointerException npe) {
			//...
			//catch
			//...
			}
		}
	public Setter getSetter(Class theClass, String propertyName) 
	throws PropertyNotFoundException {
		return createSetter(theClass, propertyName);
	}
	
	private static Setter createSetter(Class theClass, String propertyName) 
	throws PropertyNotFoundException {
		BasicSetter result = getSetterOrNull(theClass, propertyName);
		if (result==null) {
			throw new PropertyNotFoundException( 
					"Could not find a setter for property " + 
					propertyName + 
					" in class " + 
					theClass.getName() 
				);
		}
		return result;
	}

	private static BasicSetter getSetterOrNull(Class theClass, String propertyName) {

		if (theClass==Object.class || theClass==null) return null;

		Method method = setterMethod(theClass, propertyName);

		if (method!=null) {
			if ( !ReflectHelper.isPublic(theClass, method) ) method.setAccessible(true);
			return new BasicSetter(theClass, method, propertyName);
		}
		else {
			BasicSetter setter = getSetterOrNull( theClass.getSuperclass(), propertyName );
			if (setter==null) {
				Class[] interfaces = theClass.getInterfaces();
				for ( int i=0; setter==null && i<interfaces.length; i++ ) {
					setter=getSetterOrNull( interfaces[i], propertyName );
				}
			}
			return setter;
		}

	}

	private static Method setterMethod(Class theClass, String propertyName) {

		BasicGetter getter = getGetterOrNull(theClass, propertyName);
		Class returnType = (getter==null) ? null : getter.getReturnType();

		Method[] methods = theClass.getDeclaredMethods();
		Method potentialSetter = null;
		for (int i=0; i<methods.length; i++) {
			String methodName = methods[i].getName();

			if ( methods[i].getParameterTypes().length==1 && methodName.startsWith("set") ) {
				String testStdMethod = Introspector.decapitalize( methodName.substring(3) );
				String testOldMethod = methodName.substring(3);
				if ( testStdMethod.equals(propertyName) || testOldMethod.equals(propertyName) ) {
					potentialSetter = methods[i];
					if ( returnType==null || methods[i].getParameterTypes()[0].equals(returnType) ) {
						return potentialSetter;
					}
				}
			}
		}
		return potentialSetter;
	}

	public Getter getGetter(Class theClass, String propertyName) 
	throws PropertyNotFoundException {
		return createGetter(theClass, propertyName);
	}
	
	public static Getter createGetter(Class theClass, String propertyName) 
	throws PropertyNotFoundException {
		BasicGetter result = getGetterOrNull(theClass, propertyName);
		if (result==null) {
			throw new PropertyNotFoundException( 
					"Could not find a getter for " + 
					propertyName + 
					" in class " + 
					theClass.getName() 
			);
		}
		return result;

	}

	private static BasicGetter getGetterOrNull(Class theClass, String propertyName) {

		if (theClass==Object.class || theClass==null) return null;

		Method method = getterMethod(theClass, propertyName);

		if (method!=null) {
			if ( !ReflectHelper.isPublic(theClass, method) ) method.setAccessible(true);
			return new BasicGetter(theClass, method, propertyName);
		}
		else {
			BasicGetter getter = getGetterOrNull( theClass.getSuperclass(), propertyName );
			if (getter==null) {
				Class[] interfaces = theClass.getInterfaces();
				for ( int i=0; getter==null && i<interfaces.length; i++ ) {
					getter=getGetterOrNull( interfaces[i], propertyName );
				}
			}
			return getter;
		}
	}

	private static Method getterMethod(Class theClass, String propertyName) {

		Method[] methods = theClass.getDeclaredMethods();
		for (int i=0; i<methods.length; i++) {
			// only carry on if the method has no parameters
			if ( methods[i].getParameterTypes().length==0 ) {
				String methodName = methods[i].getName();

				// try "get"
				if ( methodName.startsWith("get") ) {
					String testStdMethod = Introspector.decapitalize( methodName.substring(3) );
					String testOldMethod = methodName.substring(3);
					if ( testStdMethod.equals(propertyName) || testOldMethod.equals(propertyName) ) {
						return methods[i];
					}

				}

				// if not "get" then try "is"
				/*boolean isBoolean = methods[i].getReturnType().equals(Boolean.class) ||
					methods[i].getReturnType().equals(boolean.class);*/
				if ( methodName.startsWith("is") ) {
					String testStdMethod = Introspector.decapitalize( methodName.substring(2) );
					String testOldMethod = methodName.substring(2);
					if ( testStdMethod.equals(propertyName) || testOldMethod.equals(propertyName) ) {
						return methods[i];
					}
				}
			}
		}
		return null;
	}

}

兄台说我的setPOJO()方法效率低下，依据何在？是因为hibernate少做了强制类型转换？？还是你经过了严格的性能测试得出的结论？？还是你在拍脑袋？？？

18 楼 mislay 2009-12-09  

说了半天，这和hibernate有啥关系？？  利用sql的columnName，反射想要的bean。

17 楼 hudefeifei1 2009-12-09  

兄弟。你肯定没读过H的源码吧，看以下然后比较下setPOJO这个类的效率

16 楼 BarryWei 2009-12-08  

如果hibernate可以不用mapping配置而且能够同时支持多表连接那就舒服啦
可惜哦 不知道这样的思路是不是正确

15 楼 skyuck 2009-12-08  

hibernate最主要的是解决阻抗不匹配的问题，Java是一个面向对象的语言，而我们平时用的数据库大多是关系型数据库，hibernate的O/R mapping就是从关系到对象的一种映射。

14 楼 wangdgsc 2009-12-07  

如果不够用，就自己扩展,

13 楼 cuishen 2009-12-07  

<div class="quote_title">mccxj 写道</div>
<div class="quote_div">
<p>可以对原生sql 查询使用ResultTransformer。这会返回不受Hibernate管理的实体。 </p>
<pre class="programlisting">sess.createSQLQuery("SELECT NAME, BIRTHDATE FROM CATS")
        .setResultTransformer(Transformers.aliasToBean(CatDTO.class))</pre>
<p>这个查询指定：</p>
<div class="itemizedlist">
<ul type="disc">
<li>
<p>SQL查询字符串</p>
</li>
<li>
<p>结果转换器(result transformer)</p>
</li>
</ul>
</div>
<p>上面的查询将会返回<tt class="literal">CatDTO</tt>的列表,它将被实例化并且将NAME和BIRTHDAY的值注射入对应的属性或者字段。 </p>
<p> </p>
<p>from hibernate3.2文档 16.1.5. 返回非受管实体(Returning non-managed entities)</p>
<p> </p>
<p>我没用过这个。。不过看上面的解释应该是可以的~~同样，命名sql(不是命名hql)也可以达到这个目的</p>
<p> </p>
<p>其他：</p>
<p>1.任何时候hibernate都可以得到原生connection~~你的dao背后直接jdbc了？</p>
<p>2.虽然楼主似乎没搞清楚hibernate~不过楼主还不错~加油~~</p>
</div>
<p><br>本着勤学好问的精神，我试了一把，不错，hibernate3.2版的</p>
<p> </p>
<pre name="code" class="java">sess.createSQLQuery("SELECT NAME, BIRTHDATE FROM CATS")
.setResultTransformer(Transformers.aliasToBean(CatDTO.class))</pre>
<p> </p>
<p>确实可以基本达到我的要求，但是非常不好用（至少hibernate3.2是这样，不知3.3版有没有改进）：</p>
<p> </p>
<p>1. 没有做到setter方法大小写不敏感，举例来说：比如bean里面有属性id，setter方法名是setId，sql语句是“select id from ...”，明显的ResultSetMetaData中取出的ColumnName应该是大写的“ID”，遗憾的是hibernate并没有做到大小写不敏感，也去反射了setID方法，后果可想而知</p>
<p> </p>
<p>2. 反射setter方法的参数没有做到强制类型转换，ResultSet拿到的值是怎样的对象，它就set怎样的对象</p>

12 楼 mccxj 2009-12-07  

<div class="quote_title">cuishen 写道</div>
<div class="quote_div">
<div class="quote_title">mccxj 写道</div>
<div class="quote_div">
<p>可以对原生sql 查询使用ResultTransformer。这会返回不受Hibernate管理的实体。 </p>
<pre class="programlisting">sess.createSQLQuery("SELECT NAME, BIRTHDATE FROM CATS")
        .setResultTransformer(Transformers.aliasToBean(CatDTO.class))</pre>
<p>这个查询指定：</p>
<div class="itemizedlist">
<ul type="disc">
<li>
<p>SQL查询字符串</p>
</li>
<li>
<p>结果转换器(result transformer)</p>
</li>
</ul>
</div>
<p>上面的查询将会返回<tt class="literal">CatDTO</tt>的列表,它将被实例化并且将NAME和BIRTHDAY的值注射入对应的属性或者字段。 </p>
<p> </p>
<p>from hibernate3.2文档 16.1.5. 返回非受管实体(Returning non-managed entities)</p>
<p> </p>
<p>我没用过这个。。不过看上面的解释应该是可以的~~同样，命名sql(不是命名hql)也可以达到这个目的</p>
<p> </p>
<p>其他：</p>
<p>1.任何时候hibernate都可以得到原生connection~~你的dao背后直接jdbc了？</p>
<p>2.虽然楼主似乎没搞清楚hibernate~不过楼主还不错~加油~~</p>
</div>
<p>首先谢谢热心的网友批评指正，我特意看了下我看的hibernate的版本是3.1.3的，属于比较老旧的版本了，所以没有提供这个功能，大家可以去翻hibernate reference3.1.3，我又下载了3.2版本的reference，确实有16.1.5这个章节，这应该是新加进去的</p>
</div>
<p>看来这个贴有给投成新手的趋势~~~楼主下次还是把版本也给注明的比较好~</p>

11 楼 cuishen 2009-12-07  

kjj 写道

大家这么一评论，我发现作者是不是说的是这个意思

"select new UnMappingEntiry() from User u join Department d where d.userid=u.id"

确实是这个意思，但遗憾的是，用hibernate3.1.3实现的话，还是脱离不了mapping啊！

10 楼 cuishen 2009-12-07  

<div class="quote_title">mccxj 写道</div>
<div class="quote_div">
<p>可以对原生sql 查询使用ResultTransformer。这会返回不受Hibernate管理的实体。 </p>
<pre class="programlisting">sess.createSQLQuery("SELECT NAME, BIRTHDATE FROM CATS")
        .setResultTransformer(Transformers.aliasToBean(CatDTO.class))</pre>
<p>这个查询指定：</p>
<div class="itemizedlist">
<ul type="disc">
<li>
<p>SQL查询字符串</p>
</li>
<li>
<p>结果转换器(result transformer)</p>
</li>
</ul>
</div>
<p>上面的查询将会返回<tt class="literal">CatDTO</tt>的列表,它将被实例化并且将NAME和BIRTHDAY的值注射入对应的属性或者字段。 </p>
<p> </p>
<p>from hibernate3.2文档 16.1.5. 返回非受管实体(Returning non-managed entities)</p>
<p> </p>
<p>我没用过这个。。不过看上面的解释应该是可以的~~同样，命名sql(不是命名hql)也可以达到这个目的</p>
<p> </p>
<p>其他：</p>
<p>1.任何时候hibernate都可以得到原生connection~~你的dao背后直接jdbc了？</p>
<p>2.虽然楼主似乎没搞清楚hibernate~不过楼主还不错~加油~~</p>
</div>
<p>首先谢谢热心的网友批评指正，我特意看了下我看的hibernate的版本是3.1.3的，属于比较老旧的版本了，所以没有提供这个功能，大家可以去翻hibernate reference3.1.3，我又下载了3.2版本的reference，确实有16.1.5这个章节，这应该是新加进去的</p>

9 楼 kjj 2009-12-07  

whaosoft 写道

hibernate就是jdbc的封装，处理负责的sql查询,效率就不高啦

人云亦云！！！！

8 楼 mycybyb 2009-12-07  

hibernate是不是有人工智能啊，效率比手工打造的SQL还高

7 楼 mccxj 2009-12-07  

whaosoft 写道

hibernate就是jdbc的封装，处理负责的sql查询,效率就不高啦

效率不高不知你是怎么推算出来的~~拍脑袋?

6 楼 rmn190 2009-12-07  

fuwang 写道

弄清楚hibernate的人极少，
hibernate本来就是民工用的，有能力弄清楚的人是不屑用的。
所以现状就是：使用hibernate的人都不懂hibernate

"hibernate本来就是民工用的"源于何处?
为什么说“有能力弄清楚的人是不屑用的”？

5 楼 whaosoft 2009-12-06  

hibernate就是jdbc的封装，处理负责的sql查询,效率就不高啦

4 楼 kjj 2009-12-06  

大家这么一评论，我发现作者是不是说的是这个意思

"select new UnMappingEntiry() from User u join Department d where d.userid=u.id"