BlogJava-szhswl-文章分类-HIBERNATEhttp://www.blogjava.net/szhswl/category/27818.html宋针还的个人空间zh-cnWed, 05 Dec 2007 14:52:17 GMTWed, 05 Dec 2007 14:52:17 GMT60使用模板模式简化DAO操作Hibernate http://www.blogjava.net/szhswl/articles/165620.html宋针还宋针还Wed, 05 Dec 2007 10:49:00 GMThttp://www.blogjava.net/szhswl/articles/165620.htmlhttp://www.blogjava.net/szhswl/comments/165620.htmlhttp://www.blogjava.net/szhswl/articles/165620.html#Feedback0http://www.blogjava.net/szhswl/comments/commentRss/165620.htmlhttp://www.blogjava.net/szhswl/services/trackbacks/165620.html 　　
　　getHibernateTemplate().save(user);
　　
　　这样一句话在我们没有Spring的时候就必须使用如下的代码才能完成：
　　
　　Session session = HibernateUtil.getSession();
　　Transaction tx = session.beginTransaction();
　　session.save(user);
　　tx.commit();
　　HibernateUtil.colseSession();
　　这里还省去了异常处理，同时使用了HibernateUtil类来简化从SessionFactory获取Session，以及关闭Session等处理。
　　
　　但是我们在使用Hibernate的时候不一定会使用Spring，所以我们可以模仿Spring的处理方式，做一个Hibernate的模板，使用模板模式来简化我们的开发，其主要的目的就是为了简化开发，使代码达到最大话的重用。
　　
　　1．我们现来实现一个Hibernate模板：
　　
 1　　package kick.hibernate;
 2　　
 3　　import net.sf.hibernate.HibernateException;
 4　　import net.sf.hibernate.Session;
 5　　import net.sf.hibernate.Transaction;
 6　　
 7　　public class HibernateTemplate{
 8　　public static Object run(HibernateCallback callback) throws HibernateException{
 9　　Session session = null;
10　　Transaction tx = null;
11　　try {
12　　session = HibernateSessionutil.currentSession();
13　　tx = session.beginTransaction();
14　　Object result = callback.execute(session);
15　　tx.commit();
16　　session.flush();
17　　return result;
18　　} catch (HibernateException e) {
19　　tx.rollback();
20　　return null;
21　　} finally {
22　　HibernateSessionutil.closeSession();
23　　}
24　　}
25
　　这里类很简单，就是使用一个实现HibernateCallBack接口的一个回掉类，在调用的时候根据具体的需求实现HibernateCallBack类。
　　
　　2．回掉接口HibernateCallBack：
1　　package kick.hibernate;
2　　
3　　import net.sf.hibernate.HibernateException;
4　　import net.sf.hibernate.Session;
5　　
6　　public interface HibernateCallBack {
7　　Object execute(Session session)throws HibernateException;
8　　}

　　
　　好了，到此为止我们就可以使用这个模板了，可以用如下的方式使用：
　　HibernateTemplate.run(new HibernateCallback() {
　　public Object execute(Session session) throws HibernateException {
　　session.save(user);
　　return null;
　　}
　　});
　　
　　看看，是不是省去了很多代码？^_^
　　
　　不过这还没有达到想Spring里面那样简单，不要着急，“面包会有的”呵呵，我们会达到的。
　　
　　3．实现我们自己的HibernateSupport类：
　　
　　从上面的代码可以看出，我们要自己实现HibernateCallback接口，而每次我们实现的时候又重复代码了。因此我们再抽象，讲这些实现放到我们的HibernateSupport类里面去。看看我们上面的代码就知道我们实现HibernateCallback接口的目的就是为了调用session.save()方法，即session的方法。代码如下：
　　
 1　　package kick.hibernate;
 2　　
 3　　import java.io.Serializable;
 4　　
 5　　import net.sf.hibernate.HibernateException;
 6　　import net.sf.hibernate.Session;
 7　　
 8　　public class HibernateSupport{
 9　　
10　　public Object save(final Object object) throws HibernateException{
11　　return HibernateTemplate.run(new HibernateCallBack(){
12　　
13　　public Object execute(Session session) throws HibernateException {
14　　session.save(object);
15　　return null;
16　　}
17　　
18　　});
19　　}
20　　public Object save(final Object object,final Serializable id) throws HibernateException{
21　　return HibernateTemplate.run(new HibernateCallBack(){
22　　
23　　public Object execute() throws HibernateException {
24　　session.save(object,id);
25　　return null;
26　　}
27　　
28　　});
29　　}
30　　
31　　public Object saveOrUpdate(final Object object) throws HibernateException{
32　　return HibernateTemplate.run(new HibernateCallBack(){
33　　
34　　public Object execute(Session session) throws HibernateException {
35　　session.saveOrUpdate(object);
36　　return null;
37　　}
38　　
39　　});
40　　}
41　　……………………………………………………………………………………
42　　……………………………………………………………………………………
43　　……………………………………………………………………………………
44　　

　　调用一些其他的session的方法。
　　
　　}
　　
　　4．抽象RootDao：
　　
　　该类为抽象类，在实现自己的DAO类的时候继承该类。该类的有一个HibernateSupport的对象，在子类中使用getHibernateTemplate()方法就可以得到该对象，然后调用它对应的方法。实现代码如下：
　　
 1　　package kick.hibernate.dao;
 2　　
 3　　import net.sf.hibernate.Session;
 4　　import kick.hibernate.HibernateTemplateImpl;
 5　　
 6　　public abstract class RootDao {
 7　　private HibernateSupport temp = null;
 8　　
 9　　/**
10　　* @return Returns the temp.
11　　*/
12　　public HibernateTemplateImpl getHibernateTemplate(Session session) {
13　　return new HibernateSupport();
14　　}
15　　}

　　
　　5．使用例子：
　　
　　定义一个自己的DAO类，实现代码如下：
　　
　　public class UserDaoImpl extends RootDao implements UserDaoInterface{
　　public void saveUser(User user) throws KickException {
　　getHibernateTemplate().saveOrUpdate(user);
　　}
　　……………………………………………………………………………………
　　实现其他的方法
　　……………………………………………………………………………………
　　}

宋针还 2007-12-05 18:49 发表评论
]]>优化hibernate性能的几点建议http://www.blogjava.net/szhswl/articles/165525.html宋针还宋针还Wed, 05 Dec 2007 07:30:00 GMThttp://www.blogjava.net/szhswl/articles/165525.htmlhttp://www.blogjava.net/szhswl/comments/165525.htmlhttp://www.blogjava.net/szhswl/articles/165525.html#Feedback0http://www.blogjava.net/szhswl/comments/commentRss/165525.htmlhttp://www.blogjava.net/szhswl/services/trackbacks/165525.html
　　即在hibernate配制文件中进行配制：

1 ＜property name="hibernateProperties"＞
2 ＜props＞
3 ＜prop key="hibernate.dialect"＞org.hibernate.dialect.Oracle9Dialect＜/prop＞
4 ＜prop key="hibernate.show_sql"＞false＜/prop＞
5 ＜!-- Create/update the database tables automatically when the JVM starts up
6 ＜prop key="hibernate.hbm2ddl.auto"＞update＜/prop＞ --＞
7 ＜!-- Turn batching off for better error messages under PostgreSQL
8 ＜prop key="hibernate.jdbc.batch_size"＞100＜/prop＞ --＞
9 ＜prop key="hibernate.jdbc.batch_size"＞50＜/prop＞
10 ＜/props＞
11 ＜/property＞Fetch Size设的越大，读数据库的次数越少，速度越快；Fetch Size越小，读数据库的次数越多，速度越慢。

　　2、如果是超大的系统，建议生成htm文件。加快页面提升速度。

　　3、不要把所有的责任推在hibernate上，对代码进行重构，减少对数据库的操作，尽量避免在数据库查询时使用in操作，以及避免递归查询操作，代码质量、系统设计的合理性决定系统性能的高低。

　　4、 对大数据量查询时，慎用list()或者iterator()返回查询结果，

　　（1）. 使用List()返回结果时，Hibernate会所有查询结果初始化为持久化对象，结果集较大时，会占用很多的处理时间。

　　（2）. 而使用iterator()返回结果时，在每次调用iterator.next()返回对象并使用对象时，Hibernate才调用查询将对应的对象初始化，对于大数据量时，每调用一次查询都会花费较多的时间。当结果集较大，但是含有较大量相同的数据，或者结果集不是全部都会使用时，使用iterator()才有优势。

　　5、在一对多、多对一的关系中，使用延迟加载机制，会使不少的对象在使用时方会初始化，这样可使得节省内存空间以及减少数据库的负荷，而且若PO中的集合没有被使用时，就可减少互数据库的交互从而减少处理时间。

　　6、对含有关联的PO（持久化对象）时，若default-cascade="all"或者 “save-update”，新增PO时，请注意对PO中的集合的赋值操作，因为有可能使得多执行一次update操作。

　　7、 对于大数据量新增、修改、删除操作或者是对大数据量的查询，与数据库的交互次数是决定处理时间的最重要因素，减少交互的次数是提升效率的最好途径，所以在开发过程中，请将show_sql设置为true，深入了解Hibernate的处理过程，尝试不同的方式，可以使得效率提升。尽可能对每个页面的显示，对数据库的操作减少到100----150条以内。越少越好。

宋针还 2007-12-05 15:30 发表评论
]]>