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.csdn.net/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