public class CustomerDAO {

   public CustomerDAO() {
      HibernateUtil.beginTransaction();
   }

   // ********************************************************** //

   public Customer getCustomerById(int customerId, boolean lock)
         throws InfrastructureException {

      Session session = HibernateUtil.getSession();
      Customer customer = null;
      try {
         if (lock) {
            customer = (Customer) session.load(Customer.class, customerId, LockMode.UPGRADE);
         } else {
            customer = (Customer) session.load(Customer.class, customerId);
         }
      }  catch (HibernateException ex) {
         throw new InfrastructureException(ex);
      }
      return customer;
   }

   // ********************************************************** //

   public Collection findAll()
         throws InfrastructureException {

      Collection customers;
      try {
         customers = HibernateUtil.getSession().createCriteria(Customer.class).list();
      } catch (HibernateException ex) {
         throw new InfrastructureException(ex);
      }
      return customers;
   }

   // ********************************************************** //

   public Collection findByExample(Customer exampleCustomer)
         throws InfrastructureException {

      Collection customers;
      try {
         Criteria crit = HibernateUtil.getSession().createCriteria(Customer.class);
         customers = crit.add(Example.create(exampleCustomer)).list();
      } catch (HibernateException ex) {
         throw new InfrastructureException(ex);
      }
      return customers;
   }

   // ********************************************************** //

   public void makePersistent(Customer customer)
         throws InfrastructureException {

      try {
         HibernateUtil.getSession().saveOrUpdate(customer);
         HibernateUtil.commitTransaction();
      } catch (HibernateException ex) {
         throw new InfrastructureException(ex);
      }
   }

   // ********************************************************** //

   public void update(Customer customer)
          throws InfrastructureException {

         try{
          HibernateUtil.getSession().update(customer);
          HibernateUtil.commitTransaction();
       }
       catch(HibernateException ex){
          throw new InfrastructureException(ex);
       }
   }

   // ********************************************************** //

   public void makeTransient(Customer customer)
         throws InfrastructureException {

      try {
         HibernateUtil.getSession().delete(customer);
         HibernateUtil.commitTransaction();
      } catch (HibernateException ex) {
         throw new InfrastructureException(ex);
      }
   }

    public Customer getCustomer(String phone)
           throws InfrastructureException {

      Session session = HibernateUtil.getSession();
       try{
            Iterator iter = session.iterate("from Customer customer order by customer");
            while(iter.hasNext()){
                Customer customer = (Customer)iter.next();
                 if(customer.getPhone().equals(phone)){
                  return customer;
               }
            }

        }
        catch (HibernateException ex) {
            throw new InfrastructureException(ex);
      }
       return null;
}
}

import net.sf.hibernate.*;
import net.sf.hibernate.cfg.Configuration;
import org.apache.commons.logging.*;


import javax.naming.*;

/**
* Basic Hibernate helper class, handles SessionFactory, Session and Transaction.
* <p>
* Uses a static initializer for the initial SessionFactory creation
* and holds Session and Transactions in thread local variables. All
* exceptions are wrapped in an unchecked InfrastructureException.
*
*
*/
public class HibernateUtil {

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

   private static Configuration configuration;
   private static SessionFactory sessionFactory;
   private static final ThreadLocal threadSession = new ThreadLocal();
   private static final ThreadLocal threadTransaction = new ThreadLocal();
   private static final ThreadLocal threadInterceptor = new ThreadLocal();

   // Create the initial SessionFactory from the default configuration files
   static {
      try {
         configuration = new Configuration();
         sessionFactory = configuration.configure().buildSessionFactory();
         // We could also let Hibernate bind it to JNDI:
         // configuration.configure().buildSessionFactory()
      } catch (Throwable ex) {
         // We have to catch Throwable, otherwise we will miss
         // NoClassDefFoundError and other subclasses of Error
         log.error("Building SessionFactory failed.", ex);
         throw new ExceptionInInitializerError(ex);
      }
   }

   /**
    * Returns the SessionFactory used for this static class.
    *
    * @return SessionFactory
    */
   public static SessionFactory getSessionFactory() {
      /* Instead of a static variable, use JNDI:
      SessionFactory sessions = null;
      try {
         Context ctx = new InitialContext();
         String jndiName = "java:hibernate/HibernateFactory";
         sessions = (SessionFactory)ctx.lookup(jndiName);
      } catch (NamingException ex) {
         throw new InfrastructureException(ex);
      }
      return sessions;
      */
      return sessionFactory;
   }

   /**
    * Returns the original Hibernate configuration.
    *
    * @return Configuration
    */
   public static Configuration getConfiguration() {
      return configuration;
   }

   /**
    * Rebuild the SessionFactory with the static Configuration.
    *
    */
    public static void rebuildSessionFactory()
      throws InfrastructureException {
      synchronized(sessionFactory) {
         try {
            sessionFactory = getConfiguration().buildSessionFactory();
         } catch (Exception ex) {
            throw new InfrastructureException(ex);
         }
      }
    }

   /**
    * Rebuild the SessionFactory with the given Hibernate Configuration.
    *
    * @param cfg
    */
    public static void rebuildSessionFactory(Configuration cfg)
      throws InfrastructureException {
      synchronized(sessionFactory) {
         try {
            sessionFactory = cfg.buildSessionFactory();
            configuration = cfg;
         } catch (Exception ex) {
            throw new InfrastructureException(ex);
         }
      }
    }

   /**
    * Retrieves the current Session local to the thread.
    * <p/>
    * If no Session is open, opens a new Session for the running thread.
    *
    * @return Session
    */
   public static Session getSession()
      throws InfrastructureException {
      Session s = (Session) threadSession.get();
      try {
         if (s == null) {
            log.debug("Opening new Session for this thread.");
            if (getInterceptor() != null) {
               log.debug("Using interceptor: " + getInterceptor().getClass());
               s = getSessionFactory().openSession(getInterceptor());
            } else {
               s = getSessionFactory().openSession();
            }
            threadSession.set(s);
         }
      } catch (HibernateException ex) {
         throw new InfrastructureException(ex);
      }
      return s;
   }

   /**
    * Closes the Session local to the thread.
    */
   public static void closeSession()
      throws InfrastructureException {
      try {
         Session s = (Session) threadSession.get();
         threadSession.set(null);
         if (s != null && s.isOpen()) {
            log.debug("Closing Session of this thread.");
            s.close();
         }
      } catch (HibernateException ex) {
         throw new InfrastructureException(ex);
      }
   }

   /**
    * Start a new database transaction.
    */
   public static void beginTransaction()
      throws InfrastructureException {
      Transaction tx = (Transaction) threadTransaction.get();
      try {
         if (tx == null) {
            log.debug("Starting new database transaction in this thread.");
            tx = getSession().beginTransaction();
            threadTransaction.set(tx);
         }
      } catch (HibernateException ex) {
         throw new InfrastructureException(ex);
      }
   }

   /**
    * Commit the database transaction.
    */
   public static void commitTransaction()
      throws InfrastructureException {
      Transaction tx = (Transaction) threadTransaction.get();
      try {
         if ( tx != null && !tx.wasCommitted()
                     && !tx.wasRolledBack() ) {
            log.debug("Committing database transaction of this thread.");
            tx.commit();
         }
         threadTransaction.set(null);
      } catch (HibernateException ex) {
         rollbackTransaction();
         throw new InfrastructureException(ex);
      }
   }

   /**
    * Commit the database transaction.
    */
   public static void rollbackTransaction()
      throws InfrastructureException {
      Transaction tx = (Transaction) threadTransaction.get();
      try {
         threadTransaction.set(null);
         if ( tx != null && !tx.wasCommitted() && !tx.wasRolledBack() ) {
            log.debug("Tyring to rollback database transaction of this thread.");
            tx.rollback();
         }
      } catch (HibernateException ex) {
         throw new InfrastructureException(ex);
      } finally {
         closeSession();
      }
   }

   /**
    * Reconnects a Hibernate Session to the current Thread.
    *
    * @param session The Hibernate Session to be reconnected.
    */
   public static void reconnect(Session session)
      throws InfrastructureException {
      try {
         session.reconnect();
         threadSession.set(session);
      } catch (HibernateException ex) {
         throw new InfrastructureException(ex);
      }
   }

   /**
    * Disconnect and return Session from current Thread.
    *
    * @return Session the disconnected Session
    */
   public static Session disconnectSession()
      throws InfrastructureException {

      Session session = getSession();
      try {
         threadSession.set(null);
         if (session.isConnected() && session.isOpen())
            session.disconnect();
      } catch (HibernateException ex) {
         throw new InfrastructureException(ex);
      }
      return session;
   }

   /**
    * Register a Hibernate interceptor with the current thread.
    * <p>
    * Every Session opened is opened with this interceptor after
    * registration. Has no effect if the current Session of the
    * thread is already open, effective on next close()/getSession().
    */
   public static void registerInterceptor(Interceptor interceptor) {
      threadInterceptor.set(interceptor);
   }

   private static Interceptor getInterceptor() {
      Interceptor interceptor =
         (Interceptor) threadInterceptor.get();
      return interceptor;
   }

}