您的位置：首页 > 其它

flea-frame-db使用之JPA封装介绍

2021-03-26 09:42 477 查看

JPA封装介绍

参考

依赖

mysql-connector-java-5.1.25.jar

<!-- 数据库JDBC连接相关 （MySQL的JDBC驱动）-->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.25</version>
</dependency>

eclipselink-2.5.0.jar

<!-- 数据库持久化相关 EclipseLink-->
<dependency>
<groupId>org.eclipse.persistence</groupId>
<artifactId>eclipselink</artifactId>
<version>2.5.0</version>
</dependency>

内容讲解

目前支持 JPA + MySQL模式，需要各位本地自行装下MySQL数据库。

1. Flea JPA查询对象

该类用于实现JPA 标准化方式的数据库查询操作，可以自行组装查询条件。相关代码详细可至该路径查看 FleaJPAQuery，下面对一些关键点进行讲解，且听我细细道来 (这一版并发环境下可能存在问题，后面我会专门写一篇博文讲解 Flea JPA查询对象的问题，其中引入了对象池的概念 )。

获取FleaJPAQuery实例，并初始化内部成员变量

private static volatile FleaJPAQuery query;

private EntityManager entityManager; // JPA中用于增删改查的持久化接口
private Class sourceClazz; // 实体类类对象
private Class resultClazz; // 操作结果类类对象
private Root root; // 根SQL表达式对象
private CriteriaBuilder criteriaBuilder; //标准化生成器
private CriteriaQuery criteriaQuery; // 标准化查询对象
private List<Predicate> predicates; // Where条件集合
private List<Order> orders; // 排序集合
private List<Expression> groups; // 分组集合

private FleaJPAQuery() {
}

/**
* <p> 获取Flea JPA查询对象 </p>
* （单例模式，本身没有问题，但是由于获取之后Flea JPA查询对象还要使用，
* 这在有点并发的环境下就存在问题了；后面我会单独写一篇博文讲解基于对象池
* 的多例模式，既保证并发下各个线程获取的Flea JPA查询对象之间互不影响，
* 同时也能保证尽可能少的新建Flea JPA查询对象）
*
* @return Flea JPA查询对象
* @since 1.0.0
*/
public static FleaJPAQuery getQuery() {
if (ObjectUtils.isEmpty(query)) {
synchronized (FleaJPAQuery.class) {
if (ObjectUtils.isEmpty(query)) {
query = new FleaJPAQuery();
}
}
}
return query;
}

/**
* <p> getQuery()之后，一定要调用该方法进行初始化 </p>
*
* @param entityManager JPA中用于增删改查的持久化接口
* @param sourceClazz   实体类类对象
* @param resultClazz   操作结果类类对象
* @since 1.0.0
*/
public void init(EntityManager entityManager, Class sourceClazz, Class resultClazz) {
this.entityManager = entityManager;
this.sourceClazz = sourceClazz;
this.resultClazz = resultClazz;
// 从持久化接口中获取标准化生成器
criteriaBuilder = entityManager.getCriteriaBuilder();
// 通过标准化生成器 获取 标准化查询对象
if (ObjectUtils.isEmpty(resultClazz)) {
// 行记录查询结果
criteriaQuery = criteriaBuilder.createQuery(sourceClazz);
} else {
// 单个查询结果
criteriaQuery = criteriaBuilder.createQuery(resultClazz);
}
// 通过标准化查询对象，获取根SQL表达式对象
root = criteriaQuery.from(sourceClazz);
predicates = new ArrayList<Predicate>();
}

拼接查询条件，添加排序和分组

// 等于条件 (单个属性列)
public void equal(String attrName, Object value) throws DaoException;
// 等于条件 (多个属性列)
public void equal(Map<String, Object> paramMap) throws DaoException;
// 不等于条件 (单个属性列)
public void notEqual(String attrName, Object value) throws DaoException;
// 等于条件 (多个属性列)
public void notEqual(Map<String, Object> paramMap) throws DaoException;
// is null 条件，某属性值为空
public void isNull(String attrName) throws DaoException;
// is not null 条件，某属性值为非空
public void isNotNull(String attrName) throws DaoException;
// in 条件， attrName属性的值在value集合中
public void in(String attrName, Collection value) throws DaoException;
//  not in 条件，attrName属性的值不在value集合中
public void notIn(String attrName, Collection value) throws DaoException;
// like 条件， 模糊匹配
public void like(String attrName, String value) throws DaoException;
// 小于等于条件
public void le(String attrName, Number value) throws DaoException;
// 小于条件
public void lt(String attrName, Number value) throws DaoException;
// 大于等于条件
public void ge(String attrName, Number value) throws DaoException;
// 大于条件
public void gt(String attrName, Number value) throws DaoException;
// between and 条件, 时间区间查询
public void between(String attrName, Date startTime, Date endTime) throws DaoException;
// 大于某个日期值条件
public void greaterThan(String attrName, Date value) throws DaoException;
// 大于等于某个日期值条件
public void greaterThanOrEqualTo(String attrName, Date value) throws DaoException;
// 小于某个日期值条件
public void lessThan(String attrName, Date value) throws DaoException;
// 小于等于某个日期值条件
public void lessThanOrEqualTo(String attrName, Date value) throws DaoException;
// 统计数目，在getSingleResult调用之前使用
public void count();
// 统计数目(带distinct参数)，在getSingleResult调用之前使用
public void countDistinct();
// 设置查询某属性的最大值，在getSingleResult调用之前使用
public void max(String attrName) throws DaoException;
// 设置查询某属性的最小值，在getSingleResult调用之前使用
public void min(String attrName) throws DaoException;
// 设置查询某属性的平均值，在getSingleResult调用之前使用
public void avg(String attrName) throws DaoException;
// 设置查询某属性的值的总和，在getSingleResult调用之前使用
public void sum(String attrName) throws DaoException;
// 设置查询某属性的值的总和(Long)，在getSingleResult调用之前使用
public void sumAsLong(String attrName) throws DaoException;
// 设置查询某属性的值的总和(Double)，在getSingleResult调用之前使用
public void sumAsDouble(String attrName) throws DaoException;
// 去重某一列
public void distinct(String attrName) throws DaoException;
// 添加order by子句
public void addOrderby(String attrName, String orderBy) throws DaoException;
// 添加group by子句
public void addGroupBy(String attrName) throws DaoException;

获取查询结果（记录行或单个结果）

// 获取查询的记录行结果集合
public List getResultList() throws DaoException;
// 获取查询的记录行结果集合（设置查询范围）
public List getResultList(int start, int max) throws DaoException;
// 获取查询的单个属性列结果集合
// 需要先调用 distinct，否则默认返回行记录结果集合
public List getSingleResultList() throws DaoException;
// 获取查询的单个属性列结果集合（设置查询范围，可用于分页）
// 需要先调用 distinct，否则默认返回行记录结果集合
public List getSingleResultList(int start, int max) throws DaoException;
// 获取查询的单个结果
// 需要提前调用 (count, countDistinct, max, min, avg, sum, sumAsLong, sumAsDouble)
public Object getSingleResult() throws DaoException;

2. 数据处理的基本接口

基本的数据操作接口，其中包含了查询，（批量）添加，（批量）更新，删除等操作，详细可至GitHub查看 IFleaJPABaseDataHandler。

3. 抽象Flea JPA DAO层接口

/**
* <p> 抽象Flea JPA DAO层接口，实现基本的查询、（批量）添加、（批量）更新、删除接口 </p>
*
* @author huazie
* @version 1.0.0
* @since 1.0.0
*/
public interface IAbstractFleaJPADAO<T> extends IFleaJPABaseDataHandler<T> {

}

4. 抽象Flea JPA DAO层实现

本类中实现上述3中查询、（批量）添加、（批量）更新、删除的接口的具体逻辑，详细可至GitHub查看 AbstractFleaJPADAOImpl。

该类实现上述抽象Flea JPA DAO层接口，同样有类型T，由子类指定其操作的实体类。
```
public abstract class AbstractFleaJPADAOImpl<T> implements IAbstractFleaJPADAO<T>
```

无参构造方法，用于获取子类指定的实体类类对象。

/**
* <p> 获取T类型的Class对象 </p>
*
* @since 1.0.0
*/
public AbstractFleaJPADAOImpl() {
// 获取泛型类的子类对象的Class对象
Class<?> clz = getClass();
// 获取子类对象的泛型父类类型（也就是AbstractDaoImpl<T>）
ParameterizedType type = (ParameterizedType) clz.getGenericSuperclass();
if (LOGGER.isDebugEnabled()) {
LOGGER.debug("Type={}", type);
}
Type[] types = type.getActualTypeArguments();
clazz = (Class<T>) types[0];
if (LOGGER.isDebugEnabled()) {
LOGGER.debug("ClassName={}", clazz.getName());
}
}

实现接口方法，可参见上述类源码

持久化接口获取，由子类实现（可参考下面的持久化单元DAO层实现）

/**
* <p> 获取EntityManager对象 </p>
*
* @return EntityManager对象
* @since 1.0.0
*/
protected abstract EntityManager getEntityManager();

Flea JPA查询对象获取

/**
* <p> 获取指定的查询对象 </p>
* <p> 上一个版本如下调用，基于对象池的多例模式之后，获取Flea JPA查询对象有不同，可参考源码 </p>
*
* @return 自定义Flea JPA查询对象
* @since 1.0.0
*/
protected FleaJPAQuery getQuery(Class result) {
// 获取Flea JPA查询对象实例
FleaJPAQuery query = FleaJPAQuery.getQuery();
// 获取实例后必须调用该方法进行初始化
query.init(getEntityManager(), clazz, result);
return query;
}

5. 定义抽象Flea JPA SV层接口

/**
* <p> 抽象Flea JPA SV层接口 </p>
*
* @author huazie
* @version 1.0.0
* @since 1.0.0
*/
public interface IAbstractFleaJPASV<T> extends IFleaJPABaseDataHandler<T> {
}

6. 抽象Flea JPA SV层实现

该类实现上述抽象Flea JPA SV层接口，相关代码也比较简单，具体接口实现内部调用抽象Flea JPA DAO层实现，详细可至GitHub查看 AbstractFleaJPASVImpl，如下举例：

@Override
public T query(long entityId) throws Exception {
return getDAO().query(entityId);
}

// ... 其他接口实现已省略

/**
* <p> 获取Flea JPA DAO层实现 </p>
*
* @return 抽象Flea JPA DAO层实现
* @since 1.0.0
*/
protected abstract IAbstractFleaJPADAO<T> getDAO();

7. 持久化单元DAO层实现

该类与持久化单元一一对应，如果新增一个持久化配置，即需要新增一个持久化单元DAO层实现，同时Spring配置中，需要加入对应的持久化单元事物管理者配置。详细可至GitHub查看 FleaAuthDAOImpl

持久化单元名 ----- fleaauth
持久化事物管理者 ----- fleaauthTransactionManager
持久化接口对象 ----- entityManager （该类由注解定义，由Spring配置中的持久化接口工厂 fleaAuthEntityManagerFactory 初始化，详细可见下面持久化单元相关配置）

/**
* <p> FleaAuth数据源DAO层父类 </p>
*
* @author huazie
* @version 1.0.0
* @since 1.0.0
*/
public class FleaAuthDAOImpl<T> extends AbstractFleaJPADAOImpl<T> {

@PersistenceContext(unitName="fleaauth")
protected EntityManager entityManager;

@Override
@Transactional("fleaAuthTransactionManager")
public boolean remove(long entityId) throws Exception {
return super.remove(entityId);
}

// 其余代码省略。。。

@Override
protected EntityManager getEntityManager() {
return entityManager;
}

}

8. 配置介绍

持久化单元配置 fleaauth-persistence.xml

<?xml version="1.0" encoding="UTF-8"?>
<persistence version="2.0" xmlns="http://java.sun.com/xml/ns/persistence" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd">

<persistence-unit name="fleaauth" transaction-type="RESOURCE_LOCAL">
<!-- provider -->
<provider>org.eclipse.persistence.jpa.PersistenceProvider</provider>
<!-- Connection JDBC -->
<class>具体实体类全名</class>
<exclude-unlisted-classes>true</exclude-unlisted-classes>

<properties>
<property name="javax.persistence.jdbc.driver" value="com.mysql.jdbc.Driver" />
<property name="javax.persistence.jdbc.url" value="jdbc:mysql://localhost:3306/fleaauth?useUnicode=true&characterEncoding=UTF-8" />
<property name="javax.persistence.jdbc.user" value="root" />
<property name="javax.persistence.jdbc.password" value="root" />
</properties>
</persistence-unit>
</persistence>

Spring配置

<!-- 持久化单元管理器 -->
<bean id="defaultPersistenceManager" class="org.springframework.orm.jpa.persistenceunit.DefaultPersistenceUnitManager">
<property name="persistenceXmlLocations">
<!-- 可以配置多个持久单元 -->
<list>
<value>classpath:META-INF/fleaauth-persistence.xml</value>
</list>
</property>
</bean>
<!-- 持久化提供者 -->
<bean id="defaultPersistenceProvider" class="org.eclipse.persistence.jpa.PersistenceProvider"/>
<!-- 加载时织入器 -->
<bean id="defaultLoadTimeWeaver" class="org.springframework.instrument.classloading.InstrumentationLoadTimeWeaver"/>
<!-- JPA厂商适配器，对外公开EclipseLink的持久性提供程序和EntityManager扩展接口  -->
<bean id="defaultVendorAdapter" class="org.springframework.orm.jpa.vendor.EclipseLinkJpaVendorAdapter">
<!-- 是否在控制台显示sql -->
<property name="showSql" value="true"/>
</bean>
<!-- JpaDialect EclipseLink持久化服务的实现-->
<bean id="defaultJpaDialect" class="org.springframework.orm.jpa.vendor.EclipseLinkJpaDialect"/>

<!-- 以下部分 与指定持久化单元一一对应 -->
<!-- ################################## -->
<!-- FleaAuth TransAction Manager JPA -->
<!-- ################################## -->
<bean id="fleaAuthEntityManagerFactory" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
<property name="persistenceUnitManager" ref="defaultPersistenceManager"/>
<property name="persistenceUnitName" value="fleaauth"/>
<property name="persistenceProvider" ref="defaultPersistenceProvider"/>
<property name="jpaVendorAdapter" ref="defaultVendorAdapter"/>
<property name="jpaDialect" ref="defaultJpaDialect"/>
<property name="jpaPropertyMap">
<map>
<entry key="eclipselink.weaving" value="false"/>
</map>
</property>
</bean>

<bean id="fleaAuthTransactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
<property name="entityManagerFactory" ref="fleaAuthEntityManagerFactory"/>
</bean>

<tx:annotation-driven transaction-manager="fleaAuthTransactionManager"/>

至此，相关JPA使用已封装完毕，下一篇博文将介绍 JPA接入，敬请期待。

内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理

标签：

相关文章推荐

新的分享

章节导航