EntityManager、EntityManagerFactory

1、EntityManager

An instance of the interface javax. persistence. Entity Manager is used to persist, retrieve, update and remove entities to/from the database. Depending on the environment, an EntityManager can be used in following two ways:

• 容器托管 - Container-managed entity manger: In this case, the instance of EntityManager is managed automatically by the container. We typically obtain the instance of EntityManager by injecting it with @PersistenceContext. This is only applicable to Java EE environment
• 应用托管 - Application-managed entity manager: In this case, we have to explicitly obtain and manage the instance(s) of EntityManager. This is applicable to both Java EE or stand-alone/Java SE applications.

EntityManager是JPA中用于增删改查的接口，它的作用相当于一座桥梁，连接内存中的java对象和数据库的数据存储。 

EntityManager托管方式由两种：容器托管（EntityManger && PersistenceContext）和 应用托管（EntityManagerFactory && PersistenceUnit），比较简单的方式是采用容器托管。

关于PersistenceUnit与PersistenceContext，请移步另一文章：https://blog.youkuaiyun.com/tfstone/article/details/119330721

1、容器托管（持久化上下文获取）

@PersistenceContext
private EntityManager em;

2、应用托管（从持久化单元获取）

#从EntityManagerFactory获取（EntityManagerFactory从容器获取）
@PersistenceUnit
private EntityManagerFactory emf;
EntityManager em = emf.createEntityManager();

Plus：SpingBoot启动时，默认PersistenceUnit

源码： 

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package javax.persistence;

import java.util.List;
import java.util.Map;
import javax.persistence.criteria.CriteriaBuilder;
import javax.persistence.criteria.CriteriaDelete;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.CriteriaUpdate;
import javax.persistence.metamodel.Metamodel;

public interface EntityManager {
    void persist(Object var1);

    <T> T merge(T var1);

    void remove(Object var1);

    <T> T find(Class<T> var1, Object var2);

    <T> T find(Class<T> var1, Object var2, Map<String, Object> var3);

    <T> T find(Class<T> var1, Object var2, LockModeType var3);

    <T> T find(Class<T> var1, Object var2, LockModeType var3, Map<String, Object> var4);

    <T> T getReference(Class<T> var1, Object var2);

    void flush();

    void setFlushMode(FlushModeType var1);

    FlushModeType getFlushMode();

    void lock(Object var1, LockModeType var2);

    void lock(Object var1, LockModeType var2, Map<String, Object> var3);

    void refresh(Object var1);

    void refresh(Object var1, Map<String, Object> var2);

    void refresh(Object var1, LockModeType var2);

    void refresh(Object var1, LockModeType var2, Map<String, Object> var3);

    void clear();

    void detach(Object var1);

    boolean contains(Object var1);

    LockModeType getLockMode(Object var1);

    void setProperty(String var1, Object var2);

    Map<String, Object> getProperties();

    Query createQuery(String var1);

    <T> TypedQuery<T> createQuery(CriteriaQuery<T> var1);

    Query createQuery(CriteriaUpdate var1);

    Query createQuery(CriteriaDelete var1);

    <T> TypedQuery<T> createQuery(String var1, Class<T> var2);

    Query createNamedQuery(String var1);

    <T> TypedQuery<T> createNamedQuery(String var1, Class<T> var2);

    Query createNativeQuery(String var1);

    Query createNativeQuery(String var1, Class var2);

    Query createNativeQuery(String var1, String var2);

    StoredProcedureQuery createNamedStoredProcedureQuery(String var1);

    StoredProcedureQuery createStoredProcedureQuery(String var1);

    StoredProcedureQuery createStoredProcedureQuery(String var1, Class... var2);

    StoredProcedureQuery createStoredProcedureQuery(String var1, String... var2);

    void joinTransaction();

    boolean isJoinedToTransaction();

    <T> T unwrap(Class<T> var1);

    Object getDelegate();

    void close();

    boolean isOpen();

    EntityTransaction getTransaction();

    EntityManagerFactory getEntityManagerFactory();

    CriteriaBuilder getCriteriaBuilder();

    Metamodel getMetamodel();

    <T> EntityGraph<T> createEntityGraph(Class<T> var1);

    EntityGraph<?> createEntityGraph(String var1);

    EntityGraph<?> getEntityGraph(String var1);

    <T> List<EntityGraph<? super T>> getEntityGraphs(Class<T> var1);
}

 2、EntityManagerFactory 持久化工厂，可以生成多个EntityManager

The main role of an EntityManagerFactory instance is to support instantiation of EntityManager instances. An EntityManagerFactory is constructed for a specific database, and by managing resources efficiently (e.g. a pool of sockets), it provides an efficient way to construct multiple EntityManager instances for that database. 

EntityManagerFactory 是线程安全的，因此单个实​​例可以被多个线程共享；

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package javax.persistence;

import java.util.Map;
import javax.persistence.criteria.CriteriaBuilder;
import javax.persistence.metamodel.Metamodel;

public interface EntityManagerFactory {
    EntityManager createEntityManager();

    EntityManager createEntityManager(Map var1);

    EntityManager createEntityManager(SynchronizationType var1);

    EntityManager createEntityManager(SynchronizationType var1, Map var2);

    CriteriaBuilder getCriteriaBuilder();

    Metamodel getMetamodel();

    boolean isOpen();

    void close();

    Map<String, Object> getProperties();

    Cache getCache();

    PersistenceUnitUtil getPersistenceUnitUtil();

    void addNamedQuery(String var1, Query var2);

    <T> T unwrap(Class<T> var1);

    <T> void addNamedEntityGraph(String var1, EntityGraph<T> var2);
}

参考：

https://www.jianshu.com/p/091360c47e6b

https://www.logicbig.com/tutorials/java-ee-tutorial/jpa/entity-context.html

https://dzone.com/articles/jpa-entitymanagerfactory-interface-with-example