Hibernate 提供äº?/span> 3 ¿Uæ£€ç´¢ç­–略：

l        延迟‹‚€ç´¢ï¼›

l        立即‹‚€ç´¢ï¼›

l        ˜q«åˆ‡å·¦å¤–˜qžæŽ¥åQ?/span>

Hibernate 提供 2 ¿Uæ–¹å¼æ¥¼‹®å®š‹‚€ç´¢ç­–略，一中是在配¾|®æ–‡ä»¶å½“中，另外一¿Uæ˜¯åœ¨ç¨‹åºç§è®„¡½®ã€‚当ç„Óž¼Œå¦‚果你在½E‹åºä¸­è®¾¾|®äº†‹‚€ç´¢ç­–略，那么你在配置文äšg中的讄¡½®ä¹Ÿå°±æ— æ•ˆäº†ã€‚另外的一¿Uæƒ…冉|˜¯ HQL 会忽略配¾|®æ–‡ä»¶çš„讄¡½®åQŒè€Œæ€ÀL˜¯é‡‡ç”¨˜q«åˆ‡å·¦å¤–˜qžæŽ¥ã€?/span>

一ã€?¾cȝñ”别的‹‚€ç´?/span>

可以选择的检索策略是立即‹‚€ç´¢å’Œå»¶è¿Ÿ‹‚€ç´¢ï¼Œé»˜è®¤çš„是立即‹‚€ç´¢ã€‚用配置文äšg中的 <class> 节点çš?/span> lazy 来控制ã€?/span>

注意åQšä¸½Ž¡ä½ åœ¨é…¾|?/span> class çš?/span> lazy æ˜?/span> true ˜q˜æ˜¯ false åQŒå¯¹ get() å’?/span> create Criteria () æ–ÒŽ³•éƒ½ä¸èµ·ä½œç”¨ï¼Œåªæœ‰å¯?/span> load() æ–ÒŽ³•èµ·ä½œç”¨ã€?/span>

当你使用的检索策略是 lazy 的时候，当你执行

Customer customer = (Customer)session.load(Customer.class,new Long(1));

的时候， Hibernate 不从数据库检索数据，而只是äñ”生一个代理类åQŒåªæœ‰å½“你执è¡?/span>

Customer.getName();

的时候， Hibernate 才到数据库取数据。所以，如下的代码是会被抛出异常的：

Session session  =  sessionFactory.openSession();
transaction tx  =   null ;
tx  =  session.beginTransaction();
  Customer customer  =  (Customer)session.load(Customer. class , new  Long( 1 ));
tx.commit();
  session.close();
customer.getName();

import java.io.IOException;

import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.hibernate.SessionFactory;

import cn.hxex.blog.hibernate.HibernateUtil;

public class HibernateFilter implements Filter {

    private static Log log = LogFactory.getLog(HibernateFilter.class);

    /**
     * ˜q‡æ×o器的主要æ–ÒŽ³•
     * 用于实现Hibernate事务的开始和提交
     */
    public void doFilter(ServletRequest request,
                         ServletResponse response,
                         FilterChain chain)
            throws IOException, ServletException
    {
     // 得到SessionFactory对象的实ä¾?br>     SessionFactory sf = HibernateUtil.getSessionFactory();

        try
        {
         // 开始一个新的事åŠ?br>            log.debug("Starting a database transaction");
            sf.getCurrentSession().beginTransaction();

            log.debug( "Request Path:\t" + ((HttpServletRequest)request).getServletPath() );
            // Call the next filter (continue request processing)
            chain.doFilter(request, response);

            // 提交事务
            log.debug("Committing the database transaction");
            sf.getCurrentSession().getTransaction().commit();

        }
        catch (Throwable ex)
        {
         ex.printStackTrace();
            try
            {
             // 回滚事务
                log.debug("Trying to rollback database transaction after exception");
                sf.getCurrentSession().getTransaction().rollback();
            }
            catch (Throwable rbEx)
            {
                log.error("Could not rollback transaction after exception!", rbEx);
            }

            // 抛出异常
            throw new ServletException(ex);
        }
    }

    /**
     * Servlet˜q‡æ×o器的初始化方æ³?br>     * 可以è¯Õd–配置文äšg中设¾|®çš„配置参数
     */
    public void init(FilterConfig filterConfig) throws ServletException {}

    /**
     * Servlet的销毁方æ³?br>     * 用于释放˜q‡æ×o器所甌™¯·çš„资æº?br>     */
    public void destroy() {}

}

import java.io.Serializable;

import org.apache.commons.lang.builder.EqualsBuilder;
import org.apache.commons.lang.builder.HashCodeBuilder;
import org.apache.commons.lang.builder.ReflectionToStringBuilder;

public class BaseModel implements Serializable{

 /**
  * The Generated SerialVersionUID
  */
 private static final long serialVersionUID = 7766184319541530720L;
 
 /**
  * The identify of the object
  */
 private String id;

 public String getId() {
  return id;
 }

 public void setId(String id) {
  this.id = id;
 }
 
 /**
  * Common implement equals method
  */
 public boolean equals( Object obj )
 {
  if( this==obj ) return true;
  
  if( !( obj instanceof BaseModel ) )
   return false;
  
  BaseModel target = (BaseModel)obj;
  
  if( this.getId()!=null && this.getId().length()>0 )
  {
   return this.getId().equals( target.getId() );
  }
  
  if( target.getId()!=null && target.getId().length()>0 )
  {
   return false;
  }
  
  return EqualsBuilder.reflectionEquals(this, obj);
 }

 /**
  * Generate the hash code
  */
 public int hashCode()
 {
  if( this.getId()!=null && this.getId().length()>0 )
  {
   return this.getId().hashCode();
  }
   
  return HashCodeBuilder.reflectionHashCode(this);
 }

 /**
  * Common implement toString method
  */
 public String toString()
 {
  return ReflectionToStringBuilder.toString( this );
 }
}
         equals()æ–ÒŽ³•,用于判断两个对象是否相等,但åƈ不是在ä‹Éç”?=="˜q›è¡Œä¸¤ä¸ªå¯¹è±¡æ˜¯å¦ç›¸ç­‰çš„判断时调用.å› äؓ使用"=="所判断的是两个对象的引用是否相½{?也可以简单理解äؓ两个实例所引用的是否äؓ内存中的同一个对è±?equals()æ–ÒŽ³•å¯ä»¥ç†è§£ä¸ÞZ¸¤ä¸ªå¯¹è±¡åœ¨"含义"上是否相½{?也就是说˜q™ä¸¤ä¸ªå¯¹è±¡æ‰€è¡¨è¾¾çš„意思是否相å?equals()æ–ÒŽ³•åœ¨å¯¹è±¡ä¿å­˜åˆ°é›†åˆå®¹å™¨¾c?Collection)中时被调ç”?å› äؓ集合容器¾cÖM¸å…è®¸å…¶ä¸­å­˜åœ¨ä¸¤ä¸ªç›¸åŒå¯¹è±¡å®žä¾‹,其判断的依据ž®±æ˜¯é€šè¿‡è°ƒç”¨è¯¥å®žä½“对象的equals()æ–ÒŽ³•æ¥è¿›è¡Œåˆ¤æ–­çš„.
         å¦‚果修改了equals()æ–ÒŽ³•,ž®±å¿…™åÖM¿®æ”¹hashCode()æ–ÒŽ³•.如果不这æ ïLš„è¯?ž®Þp¿åjava.lang.Object的通用的hashCode的约å®?从而导致该¾cÀL— æ³•ä¸ŽåŸÞZºŽæ•£åˆ—值的集合¾cÖM¸€èµäh­£å¸¸å·¥ä½?
         toString()æ–ÒŽ³•,用于ž®†å½“前Java对象的实例è{换äؓ可以描述其内容的字符ä¸?˜q™ä¸ªæ–ÒŽ³•çš„作用是在程序调试的˜q‡ç¨‹å¯ä»¥æ–¹ä¾¿åœ°å¾—到实体对象中令ähæ„Ÿå…´­‘£çš„信息,有利于更准确及时地发现程序中的问é¢?

  å¯¹äºŽHibernate 3.1 以前的的版本在实现Hibernate工具¾cÀL—¶,需要通过两个¾U¿ç¨‹
局部变量来保存与当前进行相对应的Session和事务对象的实例.
  è€Œå¯¹äºŽHibernate 3.1 以后的版æœ?使用¾U¿ç¨‹å±€éƒ¨å˜é‡ä¿å­˜Session和事务对象的
工作ž®±å®Œå…¨ä¸éœ€è¦è‡ªå·±åŽ»å®žçŽ°äº?只需在Hibernate.cfg.xml配置文äšg中增加一个名ä¸?br>Current_session_context_class的属æ€?òq¶ä¸”讄¡½®è¯¥å±žæ€§çš„å€égØ“thread.˜q™æ ·Hibernate
ž®±å¯ä»¥è‡ªåŠ¨åœ°ä½¿ç”¨¾U¿ç¨‹å±€éƒ¨å˜é‡æ¥ä¿å­˜å½“前的进½E‹çš„Session和事务对象了.
  ç›¸åº”åœ?Hibernate也äØ“å…¶Session对象增加了getTransaction()æ–ÒŽ³•,以便可以随时
得到当前的事务åƈ˜q›è¡Œæäº¤æˆ–者回滚操ä½?˜q™ä¸ªæ–ÒŽ³•åœ¨ä»¥å‰ç‰ˆæœ¬çš„hibernate中是不存åœ?br>çš?
Hibernate工具¾cÖM¸»è¦åŒ…括以下功èƒ?
(1)Hibernate的初始化操作
  ˜q™ä¸ªåŠŸèƒ½ä¸æ”¾åœ¨ä“Q何方法中,采用静态编码的处理方式,在对象的初始化的时候被
  è°ƒç”¨ä¸€‹Æ¡å°±å¯ä»¥äº?
(2)得到当前的配¾|®ä¿¡æ?/em>
  ˜q™ä¸ªæ–ÒŽ³•å¯ä»¥å¾—到当前的配¾|®ä¿¡æ?以便于动态进行配¾|®å‚数的修改.hibernate
  çš„配¾|®ä¿¡æ¯åªåœ¨Hibernate初始化的时候ä‹É用一‹Æ?在完成初始化之后寚w…¾|®æ–‡ä»?br>  æˆ–者Configuration对象所做的修改ž®†ä¸ä¼šç”Ÿæ•?
(3)得到SessionFactory对象的实�/em>
  ˜q™ä¸ªæ–ÒŽ³•ç”¨äºŽå¾—到当前¾pȝ»Ÿ˜qè¡Œæ—¶çš„SessionFactory对象的实ä¾?˜q™ä¸ªå¯¹è±¡çš„实ä¾?br>  å¯¹äºŽæ•´ä¸ª¾pȝ»Ÿè€Œè¨€æ˜¯å…¨å±€å”¯ä¸€çš?
(4)释放各种资源
  ˜q™ä¸ªæ–ÒŽ³•ç”¨äºŽ¾lˆæ­¢Hibernate的报务后,释放各种Hibernate所使用的资æº?虽然˜q™ä¸ª
  æ–ÒŽ³•å‡ ä¹Žä¸ä¼šç”¨åˆ°,但对于申误‚µ„源的及时释放是每个程序应该掌握的基本原则.
(5)重徏SessionFactory
  ç”׃ºŽSessionFactory对于整个Hibernate应用是唯一çš?òq¶ä¸”是在Hibernate初始åŒ?br>  ä¹‹åŽå»ºç«‹å¥½çš„,而且对于配置文äšg的修改也不会影响到已¾låˆå§‹åŒ–çš„SessionFactory
  å¯¹è±¡.那么如何才能使修改的配置信息对Hibernate起作用呢.˜q™å°±éœ€è¦é‡å»ºSessionFactory
  å¯¹è±¡å®žä¾‹.
(6)拦截器注�/em>
  ç”¨äºŽæ³¨å†Œæ‹¦æˆªå™¨åƈ重徏SessionFactory.
HibenateUtil.java
import javax.naming.InitialContext;
import javax.naming.NamingException;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.hibernate.Interceptor;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
import org.hibernate.cfg.Environment;

/**
 * 基础的Hibernate辅助¾c»ï¼Œç”¨äºŽHibernate的配¾|®å’Œå¯åŠ¨ã€?br> * <p>
 * 通过静态的初始化代码来è¯Õd–Hibernate启动参数åQŒåƈ初始åŒ?br> * <tt>Configuration</tt>å’?lt;tt>SessionFactory</tt>对象ã€?br> * <p>
 *
 * @author galaxy
 */
public class HibernateUtil
{

    private static Log log = LogFactory.getLog(HibernateUtil.class);

    // 指定定义拦截器属性名
    private static final String INTERCEPTOR_CLASS = "hibernate.util.interceptor_class";

    // 静态Configurationå’ŒSessionFactory对象的实例（全局唯一的）
    private static Configuration configuration;
    private static SessionFactory sessionFactory;

    static
    {
        // 从缺省的配置文äšg创徏SessionFactory
        try
        {
         // 创徏默认的Configuration对象的实ä¾?br>         // 如果你不使用JDK 5.0或者注释请使用new Configuration()
         // 来创建Configuration()对象的实ä¾?br>            configuration = new Configuration();

            // è¯Õd–hibernate.properties或者hibernate.cfg.xmlæ–‡äšg
            configuration.configure();

            // 如果在配¾|®æ–‡ä»¶ä¸­é…ç½®äº†æ‹¦æˆªå™¨åQŒé‚£ä¹ˆå°†å…¶è®¾¾|®åˆ°configuration对象ä¸?br>            String interceptorName = configuration.getProperty(INTERCEPTOR_CLASS);
            if (interceptorName != null)
            {
                Class interceptorClass =
                        HibernateUtil.class.getClassLoader().loadClass(interceptorName);
                Interceptor interceptor = (Interceptor)interceptorClass.newInstance();
                configuration.setInterceptor(interceptor);
            }

            if (configuration.getProperty(Environment.SESSION_FACTORY_NAME) != null)
            {
                // 让Hibernatež®†SessionFacory¾l‘定到JNDI
                configuration.buildSessionFactory();
            }
            else
            {
                // 使用静态变量来保持SessioFactory对象的实ä¾?br>                sessionFactory = configuration.buildSessionFactory();
            }

        }
        catch (Throwable ex)
        {
            // 输出异常信息
            log.error("Building SessionFactory failed.", ex);
            ex.printStackTrace();
            throw new ExceptionInInitializerError(ex);
        }
    }

    /**
     * ˜q”回原始的Configuration对象的实ä¾?br>     *
     * @return Configuration
     */
    public static Configuration getConfiguration()
    {
        return configuration;
    }

    /**
     * ˜q”回全局的SessionFactory对象的实ä¾?br>     *
     * @return SessionFactory
     */
    public static SessionFactory getSessionFactory()
    {
        SessionFactory sf = null;
        String sfName = configuration.getProperty(Environment.SESSION_FACTORY_NAME);
        if ( sfName != null)
        {
            log.debug("Looking up SessionFactory in JNDI.");
            try
            {
                sf = (SessionFactory) new InitialContext().lookup(sfName);
            }
            catch (NamingException ex)
            {
                throw new RuntimeException(ex);
            }
        }
        else
        {
            sf = sessionFactory;
        }
        if (sf == null)
            throw new IllegalStateException( "SessionFactory not available." );
        return sf;
    }

    /**
     * 关闭当前的SessionFactoryòq¶ä¸”释放所有的资源
     */
    public static void shutdown()
    {
        log.debug("Shutting down Hibernate.");
        // Close caches and connection pools
        getSessionFactory().close();

        // Clear static variables
        configuration = null;
        sessionFactory = null;
    }

    /**
     * 使用静态的Configuration对象来重新构建SessionFactoryã€?br>     */
     public static void rebuildSessionFactory()
     {
        log.debug("Using current Configuration for rebuild.");
        rebuildSessionFactory(configuration);
     }

    /**
     * 使用指定的Configuration对象来重新构建SessionFactory对象ã€?br>     *
     * @param cfg
     */
     public static void rebuildSessionFactory(Configuration cfg)
     {
        log.debug("Rebuilding the SessionFactory from given Configuration.");
        synchronized(sessionFactory)
        {
            if (sessionFactory != null && !sessionFactory.isClosed())
                sessionFactory.close();
            if (cfg.getProperty(Environment.SESSION_FACTORY_NAME) != null)
                cfg.buildSessionFactory();
            else
                sessionFactory = cfg.buildSessionFactory();
            configuration = cfg;
        }
     }

    /**
     * 在当前SessionFactory中注册一个拦截器
     */
    public static SessionFactory registerInterceptorAndRebuild(Interceptor interceptor)
    {
        log.debug("Setting new global Hibernate interceptor and restarting.");
        configuration.setInterceptor(interceptor);
        rebuildSessionFactory();
        return getSessionFactory();
    }

    /**
     * 获得拦截器对è±?br>     *
     * @return Interceptor
     */
    public static Interceptor getInterceptor()
    {
        return configuration.getInterceptor();
    }

    /**
     * 提交当前事务åQŒåƈ开始一个新的事åŠ?br>     */
    public static void commitAndBeginTransaction()
    {
     sessionFactory.getCurrentSession().getTransaction().commit();
     sessionFactory.getCurrentSession().beginTransaction();
    }
}

 

Ke 2007-08-29 19:12 发表评论

]]>