JPA EntityManager详解

EntityManager是JPA中用于增删改查的接口，它的作用相当于一座桥梁，连接内存中的java对象和数据库的数据存储。其主要的方法定义如下：

既然EntityManager只是一个接口，那么谁来负责实现它呢？就是实现了JPA的厂商，例如EclipseLink，Hibernate等等。那么如何获得EntityManager对象呢？这取决于你的EntityManger对象的托管方式，主要有以下两种方式：

• 容器托管的EntityManager对象
• 应用托管的EntityManager对象

容器托管的EntityManager对象

容器托管的EntityManager对象最为简单，编程人员不需要考虑EntityManger的连接，释放以及复杂的事务问题等等，所有这些都交给容器来完成。

EntityManger && PersistenceContext

被EntityManager持久化到数据库中的对象，或者从数据库拉入内存中的对象，也会同时被一个持久化上下文（PersistenceContext）管理。这些被管理的对象统称为受管对象（Managed Object），每个受管对象都有一个唯一的id。EntityManager和PersistenceContext之间的关系，一般可以是多对一的，即多个EntityManager可以同时指向一个PersistenceContext。这其实很好理解，就是EntityManager虽然有多个实例，但是它们背后的持久化上下文却只有一个，这样就保证了多个EntityManager所管理的受管对象拥有的ID是唯一的。

受到容器托管的EntityManager可以直接通过注解@PersistenceContext注入的方式来获得：

@PersistenceContext
private EntityManager em;

应用托管的EntityManager对象

应用托管的EntityManager对象，程序员需要手动地控制它的释放和连接、手动地控制事务等。但这种获得应用托管的 EntityManager对象的方式，不仅可以在EJB容器中应用，也可以使 JPA脱离EJB容器，而与任何的Java环境集成，比如说Web容器、J2SE环境等。所以从某种角度上来说，这种方式是JPA能够独立于EJB环境运 行的基础。

理想状态下，最好是选用容器托管的EntityManager对象的方式，但在特殊的环境下，还是需要使用应用托管的EntityManager对象这种方式。

应用托管的EntityManger对象，通过EntityManagerFactory来获得。

EntityManagerFactory && PersistenceUnit

EntityManagerFactory接口中使用的最为频繁的就是第一个createEntityManager()，它能够创建并返回得到一个EntityManager接口的实现。既然是一个用于创建EntityManager接口的工厂接口，想必就会有一个用于控制如何生产的配置场所。这个配置场所就是上图中提到的持久化单元(Persistence Unit)。典型的比如在META-INF文件夹中创建的persistence.xml文件，其中就可以定义一个或者多个持久化单元。
一个典型的persistence.xml文件如下

 

那么EntityManagerFactory又是通过何种方法得到的呢？这得分两种环境来讨论：

• Java EE
• Java SE

Java EE环境获得EntityManagerFavctory

在JavaEE环境下，一般通过PersistenceUnit注入的方式引入：

@PersistenceUnit(unitName="jpa-1")
private EntityManagerFactory emf;

Java SE环境获得EntityManagerFavctory

在JavaSE环境下，可以通过Persistence类得到具体的EntityManagerFactory实现：

EntityManagerFactory emf = Persistence.createEntityManagerFactory("jpa-1");

entityManage使用：

package com.idea.repository.impl;

import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import javax.persistence.Query;
import org.apache.commons.collections.MapUtils;
import org.hibernate.transform.Transformers;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageImpl;
import org.springframework.data.domain.Pageable;
import org.springframework.util.Assert;

@SuppressWarnings({ "unchecked", "rawtypes" })
public class BaseRepositoryImpl {

    protected final Logger LOG = LoggerFactory.getLogger(getClass());

    @PersistenceContext
    private EntityManager entityManager;

    protected List getResultList(String sql, Map<String, Object> param) {
        Query nativeQuery = entityManager.createNativeQuery(sql);
        // 设置参数
        if (MapUtils.isNotEmpty(param)) {
            for (Map.Entry<String, Object> entry : param.entrySet()) {
                nativeQuery.setParameter(entry.getKey(), entry.getValue());
            }
        }
        nativeQuery.unwrap(org.hibernate.SQLQuery.class).setResultTransformer(Transformers.ALIAS_TO_ENTITY_MAP);
        List mapList = nativeQuery.getResultList();
        return mapList;
    }

    protected Object getSingleResult(String sql, Map<String, Object> param) {
        Query nativeQuery = entityManager.createNativeQuery(sql);
        if (MapUtils.isNotEmpty(param)) {
            for (Map.Entry<String, Object> entry : param.entrySet()) {
                nativeQuery.setParameter(entry.getKey(), entry.getValue());
            }
        }
        nativeQuery.unwrap(org.hibernate.SQLQuery.class).setResultTransformer(Transformers.ALIAS_TO_ENTITY_MAP);
        return nativeQuery.getSingleResult();
    }

    protected Page getPageResultList(String sql, Map<String, Object> param, Pageable pageRequest) {
        Query nativeQuery = entityManager.createNativeQuery(sql);
        // 设置参数
        if (MapUtils.isNotEmpty(param)) {
            for (Map.Entry<String, Object> entry : param.entrySet()) {
                nativeQuery.setParameter(entry.getKey(), entry.getValue());
            }
        }
        Assert.notNull(nativeQuery,"SQL执行");

        Long total = count(sql, param);

        if (total == null) {
            return null;
        }
        // 设置分页参数
        nativeQuery.setFirstResult(pageRequest.getOffset());
        nativeQuery.setMaxResults(pageRequest.getPageSize());

        nativeQuery.unwrap(org.hibernate.SQLQuery.class).setResultTransformer(Transformers.ALIAS_TO_ENTITY_MAP);
        List mapList = nativeQuery.getResultList();

        List<Map<String, Object>> content = total > pageRequest.getOffset() ? mapList : Collections.emptyList();

        return new PageImpl<>(content, pageRequest, total);
    }

    /**
     * 批量删除操作
     */
    public int excuteBatchDelete(String sql, Map<String, Object> param) {
        Query nativeQuery = entityManager.createNativeQuery(sql);
        /*
         * if (map != null && map.size() > 0) { for (Map.Entry<String, List<Object>>
         * entry : map.entrySet()) { nativeQuery.setParameter(entry.getKey(),
         * entry.getValue()); } }
         */
        if (MapUtils.isNotEmpty(param)) {
            for (Map.Entry<String, Object> entry : param.entrySet()) {
                nativeQuery.setParameter(entry.getKey(), entry.getValue());
            }
        }
        return nativeQuery.executeUpdate();
    }

    protected Long count(String sql, Map<String, Object> param) {
        String countSql = "select count(*) from (" + sql + ") a";
        Query countQuery = entityManager.createNativeQuery(countSql);

        // 设置参数
        if (MapUtils.isNotEmpty(param)) {
            for (Map.Entry<String, Object> entry : param.entrySet()) {
                countQuery.setParameter(entry.getKey(), entry.getValue());
            }
        }
        Assert.notNull(countQuery,"SQL执行");
        Long total = 0L;
        Object totalObj = countQuery.getSingleResult();
        try {
            if (totalObj != null) {
                if (totalObj instanceof BigDecimal) {
                    BigDecimal bd = (BigDecimal) totalObj;
                    total = bd.longValue();
                } else if (totalObj instanceof BigInteger) {
                    BigInteger bd = (BigInteger) totalObj;
                    total = bd.longValue();
                } else {
                    total = Long.parseLong(totalObj.toString());
                }
            }
        } catch (Exception e) {
            LOG.error("不支持该数据库count返回类型！！");
        }
        return total;
    }

}