_baserootdao.java

iReport 和 Jasperreport整合开发web报表1

package net.ensode.jasperbook.dbaccess.base;

import java.io.Serializable;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import org.hibernate.Criteria;
import org.hibernate.HibernateException;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.Transaction;
import org.hibernate.SessionFactory;

import org.hibernate.cfg.Configuration;
import org.hibernate.criterion.Expression;
import org.hibernate.criterion.Order;

public abstract class _BaseRootDAO
{

  protected static Map<String, SessionFactory> sessionFactoryMap;
  protected static SessionFactory sessionFactory;
  protected static ThreadLocal<Map> mappedSessions;
  protected static ThreadLocal<Session> sessions;

  /**
   * Configure the session factory by reading hibernate config file
   */
  public static void initialize()
  {
    net.ensode.jasperbook.dbaccess.dao._RootDAO.initialize((String) null);
  }

  /**
   * Configure the session factory by reading hibernate config file
   * 
   * @param configFileName
   *          the name of the configuration file
   */
  public static void initialize(String configFileName)
  {
    net.ensode.jasperbook.dbaccess.dao._RootDAO.initialize(configFileName,
        net.ensode.jasperbook.dbaccess.dao._RootDAO.getNewConfiguration(null));
  }

  public static void initialize(String configFileName,
      Configuration configuration)
  {
    if (null == configFileName && null != sessionFactory)
      return;
    else if (null != sessionFactoryMap
        && null != sessionFactoryMap.get(configFileName))
      return;
    else
    {
      if (null == configFileName)
      {
        configuration.configure();
        net.ensode.jasperbook.dbaccess.dao._RootDAO
            .setSessionFactory(configuration.buildSessionFactory());
      }
      else
      {
        configuration.configure(configFileName);
        net.ensode.jasperbook.dbaccess.dao._RootDAO.setSessionFactory(
            configFileName, configuration.buildSessionFactory());
      }
    }
  }

  /**
   * Set the session factory
   */
  protected static void setSessionFactory(SessionFactory sessionFactory)
  {
    setSessionFactory((String) null, sessionFactory);
  }

  /**
   * Set the session factory
   */
  protected static void setSessionFactory(String configFileName,
      SessionFactory sf)
  {
    if (null == configFileName)
    {
      sessionFactory = sf;
    }
    else
    {
      if (null == sessionFactoryMap)
        sessionFactoryMap = new HashMap<String, SessionFactory>();
      sessionFactoryMap.put(configFileName, sessionFactory);
    }
  }

  /**
   * Return the SessionFactory that is to be used by these DAOs. Change this and
   * implement your own strategy if you, for example, want to pull the
   * SessionFactory from the JNDI tree.
   */
  protected SessionFactory getSessionFactory()
  {
    return getSessionFactory(getConfigurationFileName());
  }

  protected SessionFactory getSessionFactory(String configFile)
  {
    if (null == configFile)
    {
      if (null == sessionFactory)
        throw new RuntimeException(
            "The session factory has not been initialized (or an error occured during initialization)");
      else
        return sessionFactory;
    }
    else
    {
      if (null == sessionFactoryMap)
        throw new RuntimeException(
            "The session factory for '"
                + configFile
                + "' has not been initialized (or an error occured during initialization)");
      else
      {
        SessionFactory sf = (SessionFactory) sessionFactoryMap.get(configFile);
        if (null == sf)
          throw new RuntimeException(
              "The session factory for '"
                  + configFile
                  + "' has not been initialized (or an error occured during initialization)");
        else
          return sf;
      }
    }
  }

  /**
   * Return a new Session object that must be closed when the work has been
   * completed.
   * 
   * @return the active Session
   */
  public Session getSession()
  {
    return getSession(getConfigurationFileName(), false);
  }

  /**
   * Return a new Session object that must be closed when the work has been
   * completed.
   * 
   * @return the active Session
   */
  public Session createNewSession()
  {
    return getSession(getConfigurationFileName(), true);
  }

  /**
   * Return a new Session object that must be closed when the work has been
   * completed.
   * 
   * @param configFile
   *          the config file must match the meta attribute "config-file" in the
   *          hibernate mapping file
   * @return the active Session
   */
  protected Session getSession(String configFile, boolean createNew)
  {
    if (createNew)
    {
      return getSessionFactory(configFile).openSession();
    }
    else
    {
      if (null == configFile)
      {
        if (null == sessions)
          sessions = new ThreadLocal<Session>();
        Session session = sessions.get();
        if (null == session || !session.isOpen())
        {
          session = getSessionFactory(null).openSession();
          sessions.set(session);
        }
        return session;
      }
      else
      {
        if (null == mappedSessions)
          mappedSessions = new ThreadLocal<Map>();
        Map<String, Session> map = mappedSessions.get();
        if (null == map)
        {
          map = new HashMap<String, Session>(1);
          mappedSessions.set(map);
        }
        Session session = map.get(configFile);
        if (null == session || !session.isOpen())
        {
          session = getSessionFactory(configFile).openSession();
          map.put(configFile, session);
        }
        return session;
      }
    }
  }

  /**
   * Close all sessions for the current thread
   */
  public static void closeCurrentThreadSessions()
  {
    if (null != sessions)
    {
      Session session = (Session) sessions.get();
      if (null != session && session.isOpen())
      {
        session.close();
        sessions.set(null);
      }
    }
    if (null != mappedSessions)
    {
      Map<String, Session> map = mappedSessions.get();
      if (null != map)
      {
        HibernateException thrownException = null;
        for (Session session : map.values())
        {
          try
          {
            if (null != session && session.isOpen())
            {
              session.close();
            }
          }
          catch (HibernateException e)
          {
            thrownException = e;
          }
        }
        map.clear();
        if (null != thrownException)
          throw thrownException;
      }
    }
  }

  /**
   * Close the session
   */
  public void closeSession(Session session)
  {
    if (null != session)
      session.close();
  }

  /**
   * Begin the transaction related to the session
   */
  public Transaction beginTransaction(Session s)
  {
    return s.beginTransaction();
  }

  /**
   * Commit the given transaction
   */
  public void commitTransaction(Transaction t)
  {
    t.commit();
  }

  /**
   * Return a new Configuration to use. This is not a mistake and is meant to be
   * overridden in the RootDAO if you want to do something different. The file
   * name is passed in so you have that to access. The config file is read in
   * the initialize method.
   */
  public static Configuration getNewConfiguration(String configFileName)
  {
    return new Configuration();
  }

  /**
   * Return the name of the configuration file to be used with this DAO or null
   * if default
   */
  public String getConfigurationFileName()
  {
    return null;
  }

  /**
   * Return the specific Object class that will be used for class-specific
   * implementation of this DAO.
   * 
   * @return the reference Class
   */
  protected abstract Class getReferenceClass();

  /**
   * Used by the base DAO classes but here for your modification Get object
   * matching the given key and return it.
   */
  protected Object get(Class refClass, Serializable key)
  {
    Session s = null;
    try
    {
      s = getSession();
      return get(refClass, key, s);
    }
    finally
    {
      closeSession(s);
    }
  }

  /**
   * Used by the base DAO classes but here for your modification Get object
   * matching the given key and return it.
   */
  protected Object get(Class refClass, Serializable key, Session s)
  {
    return s.get(refClass, key);
  }

  /**
   * Used by the base DAO classes but here for your modification Load object
   * matching the given key and return it.
   */
  protected Object load(Class refClass, Serializable key)
  {
    Session s = null;
    try
    {
      s = getSession();
      return load(refClass, key, s);
    }
    finally
    {
      closeSession(s);
    }
  }

  /**
   * Used by the base DAO classes but here for your modification Load object
   * matching the given key and return it.
   */
  protected Object load(Class refClass, Serializable key, Session s)
  {
    return s.load(refClass, key);
  }

  /**
   * Return all objects related to the implementation of this DAO with no
   * filter.
   */
  public java.util.List findAll()
  {
    Session s = null;
    try
    {
      s = getSession();
      return findAll(s);
    }
    finally
    {
      closeSession(s);
    }
  }

  /**
   * Return all objects related to the implementation of this DAO with no
   * filter. Use the session given.
   * 
   * @param s
   *          the Session
   */
  public java.util.List findAll(Session s)
  {
    return findAll(s, getDefaultOrder());
  }

  /**
   * Return all objects related to the implementation of this DAO with no
   * filter.
   */
  public java.util.List findAll(Order defaultOrder)
  {
    Session s = null;
    try
    {
      s = getSession();
      return findAll(s, defaultOrder);
    }
    finally
    {
      closeSession(s);
    }
  }

  /**
   * Return all objects related to the implementation of this DAO with no
   * filter. Use the session given.
   * 
   * @param s
   *          the Session
   */
  public java.util.List findAll(Session s, Order defaultOrder)
  {
    Criteria crit = s.createCriteria(getReferenceClass());