JPA - Persistence与EntityManagerFactory简解

//1. 创建 EntitymanagerFactory
String persistenceUnitName = "jpa-1";
Map<String, Object> properites = new HashMap<String, Object>();
properites.put("hibernate.show_sql", false);
EntityManagerFactory entityManagerFactory = 
//        Persistence.createEntityManagerFactory(persistenceUnitName);
    Persistence.createEntityManagerFactory(persistenceUnitName, properites);

// $Id: Persistence.java 20957 2011-06-13 09:58:51Z stliu $
package javax.persistence;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import javax.persistence.spi.LoadState;
import javax.persistence.spi.PersistenceProvider;
import javax.persistence.spi.PersistenceProviderResolverHolder;
/**
 * Bootstrap class that provides access to an EntityManagerFactory.
 */
public class Persistence {
  @Deprecated
  public static final String PERSISTENCE_PROVIDER = "javax.persistence.spi.PeristenceProvider";
  @Deprecated
  protected static final Set<PersistenceProvider> providers = new HashSet<PersistenceProvider>();
  /**
   * Create and return an EntityManagerFactory for the named persistence unit.
   *
   * @param persistenceUnitName The name of the persistence unit
   *
   * @return The factory that creates EntityManagers configured according to the specified persistence unit
   */
  public static EntityManagerFactory createEntityManagerFactory(String persistenceUnitName) {
    return createEntityManagerFactory( persistenceUnitName, null );
  }
  /**
   * Create and return an EntityManagerFactory for the named persistence unit using the given properties.
   *
   * @param persistenceUnitName The name of the persistence unit
   * @param properties Additional properties to use when creating the factory. The values of these properties override
   * any values that may have been configured elsewhere
   *
   * @return The factory that creates EntityManagers configured according to the specified persistence unit
   */
  public static EntityManagerFactory createEntityManagerFactory(String persistenceUnitName, Map properties) {
    EntityManagerFactory emf = null;
    List<PersistenceProvider> providers = getProviders();
    for ( PersistenceProvider provider : providers ) {
      emf = provider.createEntityManagerFactory( persistenceUnitName, properties );
      if ( emf != null ) {
        break;
      }
    }
    if ( emf == null ) {
      throw new PersistenceException( "No Persistence provider for EntityManager named " + persistenceUnitName );
    }
    return emf;
  }
  private static List<PersistenceProvider> getProviders() {
    return PersistenceProviderResolverHolder
        .getPersistenceProviderResolver()
        .getPersistenceProviders();
  }
  /**
   * @return Returns a <code>PersistenceUtil</code> instance.
   */
  public static PersistenceUtil getPersistenceUtil() {
    return util;
  }
  private static PersistenceUtil util =
      //TODO add an Hibernate specific optimization
    new PersistenceUtil() {
      public boolean isLoaded(Object entity, String attributeName) {
        List<PersistenceProvider> providers = Persistence.getProviders();
        for ( PersistenceProvider provider : providers ) {
          final LoadState state = provider.getProviderUtil().isLoadedWithoutReference( entity, attributeName );
          if ( state == LoadState.UNKNOWN ) continue;
          return state == LoadState.LOADED;
        }
        for ( PersistenceProvider provider : providers ) {
          final LoadState state = provider.getProviderUtil().isLoadedWithReference( entity, attributeName );
          if ( state == LoadState.UNKNOWN ) continue;
          return state == LoadState.LOADED;
        }
        return true;
      }
      public boolean isLoaded(Object object) {
        List<PersistenceProvider> providers = Persistence.getProviders();
        for ( PersistenceProvider provider : providers ) {
          final LoadState state = provider.getProviderUtil().isLoaded( object );
          if ( state == LoadState.UNKNOWN ) continue;
          return state == LoadState.LOADED;
        }
        return true;
      }
    };
}

// $Id: EntityManagerFactory.java 20957 2011-06-13 09:58:51Z stliu $
package javax.persistence;
import java.util.Map;
import javax.persistence.metamodel.Metamodel;
import javax.persistence.criteria.CriteriaBuilder;
/**
 * Interface used to interact with the entity manager factory
 * for the persistence unit.
 *
 * <p>When the application has finished using the entity manager
 * factory, and/or at application shutdown, the application should
 * close the entity manager factory.  Once an
 * <code>EntityManagerFactory</code> has been closed, all its entity managers
 * are considered to be in the closed state.
 *
 * @since Java Persistence 1.0
 */
public interface EntityManagerFactory {
    /**
     * Create a new application-managed <code>EntityManager</code>.
     * This method returns a new <code>EntityManager</code> instance each time
     * it is invoked.
     * The <code>isOpen</code> method will return true on the returned instance.
     * @return entity manager instance
     * @throws IllegalStateException if the entity manager factory
     * has been closed
     */
    public EntityManager createEntityManager();
    /**
     * Create a new application-managed <code>EntityManager</code> with the
     * specified Map of properties.
     * This method returns a new <code>EntityManager</code> instance each time
     * it is invoked.
     * The <code>isOpen</code> method will return true on the returned instance.
     * @param map properties for entity manager
     * @return entity manager instance
     * @throws IllegalStateException if the entity manager factory
     * has been closed
     */
    public EntityManager createEntityManager(Map map);
    /**
     * Return an instance of <code>CriteriaBuilder</code> for the creation of
     * <code>CriteriaQuery</code> objects.
     * @return CriteriaBuilder instance
     * @throws IllegalStateException if the entity manager factory
     * has been closed
     *
     * @since Java Persistence 2.0
     */
    public CriteriaBuilder getCriteriaBuilder();
    /**
     * Return an instance of <code>Metamodel</code> interface for access to the
     * metamodel of the persistence unit.
     * @return Metamodel instance
     * @throws IllegalStateException if the entity manager factory
     * has been closed
     *
     * @since Java Persistence 2.0
     */
    public Metamodel getMetamodel();
    /**
     * Indicates whether the factory is open. Returns true
     * until the factory has been closed.
     * @return boolean indicating whether the factory is open
     */
    public boolean isOpen();
    /**
     * Close the factory, releasing any resources that it holds.
     * After a factory instance has been closed, all methods invoked
     * on it will throw the <code>IllegalStateException</code>, except
     * for <code>isOpen</code>, which will return false. Once an
     * <code>EntityManagerFactory</code> has been closed, all its
     * entity managers are considered to be in the closed state.
     * @throws IllegalStateException if the entity manager factory
     * has been closed
     */
    public void close();
    /**
     * Get the properties and associated values that are in effect
     * for the entity manager factory. Changing the contents of the
     * map does not change the configuration in effect.
     * @return properties
     * @throws IllegalStateException if the entity manager factory
     * has been closed
     *
     * @since Java Persistence 2.0
     */
    public Map<String, Object> getProperties();
    /**
     * Access the cache that is associated with the entity manager
     * factory (the "second level cache").
     * @return instance of the <code>Cache</code> interface
     * @throws IllegalStateException if the entity manager factory
     * has been closed
     *
     * @since Java Persistence 2.0
     */
    public Cache getCache();
    /**
     * Return interface providing access to utility methods
     * for the persistence unit.
     * @return <code>PersistenceUnitUtil</code> interface
     * @throws IllegalStateException if the entity manager factory
     * has been closed
     *
     * @since Java Persistence 2.0
     */
    public PersistenceUnitUtil getPersistenceUnitUtil();
}