zoukankan      html  css  js  c++  java

  • 打包JPA动态查询（CriteriaQuery） eq、ge、gt

    封装JPA动态查询（CriteriaQuery）

     

    JPA动态查询（CriteriaQuery）封装的一段代码:

    [java] view plain copy
    1. package com.platform.framework.dao.jpa;  
    2.   
    3. import java.io.Serializable;  
    4. import java.util.ArrayList;  
    5. import java.util.Collection;  
    6. import java.util.Date;  
    7. import java.util.HashMap;  
    8. import java.util.Iterator;  
    9. import java.util.List;  
    10. import java.util.Map;  
    11.   
    12. import javax.persistence.EntityManager;  
    13. import javax.persistence.criteria.CriteriaBuilder;  
    14. import javax.persistence.criteria.CriteriaBuilder.In;  
    15. import javax.persistence.criteria.CriteriaQuery;  
    16. import javax.persistence.criteria.Order;  
    17. import javax.persistence.criteria.Predicate;  
    18. import javax.persistence.criteria.Root;  
    19.   
    20. import org.apache.log4j.Logger;  
    21.   
    22. /** 
    23.  * Query基类<br> 
    24.  *  
    25.  * @describe：封装JPA CriteriaBuilder查询条件 
    26.  * @author：lry 
    27.  * @since：2014-05-23 
    28.  */  
    29. @SuppressWarnings({ "unused", "unchecked", "rawtypes", "null", "hiding" })  
    30. public class Query implements Serializable {  
    31.   
    32.     private static final long serialVersionUID = 5064932771068929342L;  
    33.   
    34.     private static Logger log = Logger.getLogger(Query.class);  
    35.   
    36.     private EntityManager entityManager;  
    37.   
    38.     /** 要查询的模型对象 */  
    39.     private Class clazz;  
    40.   
    41.     /** 查询条件列表 */  
    42.     private Root from;  
    43.   
    44.     private List<Predicate> predicates;  
    45.   
    46.     private CriteriaQuery criteriaQuery;  
    47.   
    48.     private CriteriaBuilder criteriaBuilder;  
    49.   
    50.     /** 排序方式列表 */  
    51.     private List<Order> orders;  
    52.   
    53.     /** 关联模式 */  
    54.     private Map<String, Query> subQuery;  
    55.   
    56.     private Map<String, Query> linkQuery;  
    57.   
    58.     private String projection;  
    59.   
    60.     /** 或条件 */  
    61.     private List<Query> orQuery;  
    62.   
    63.     private String groupBy;  
    64.   
    65.     private Query() {  
    66.     }  
    67.   
    68.     private Query(Class clazz, EntityManager entityManager) {  
    69.         this.clazz = clazz;  
    70.         this.entityManager = entityManager;  
    71.         this.criteriaBuilder = this.entityManager.getCriteriaBuilder();  
    72.         this.criteriaQuery = criteriaBuilder.createQuery(this.clazz);  
    73.         this.from = criteriaQuery.from(this.clazz);  
    74.         this.predicates = new ArrayList();  
    75.         this.orders = new ArrayList();  
    76.     }  
    77.   
    78.     /** 通过类创建查询条件 */  
    79.     public static Query forClass(Class clazz, EntityManager entityManager) {  
    80.         return new Query(clazz, entityManager);  
    81.     }  
    82.   
    83.     /** 增加子查询 */  
    84.     private void addSubQuery(String propertyName, Query query) {  
    85.         if (this.subQuery == null)  
    86.             this.subQuery = new HashMap();  
    87.   
    88.         if (query.projection == null)  
    89.             throw new RuntimeException("子查询字段未设置");  
    90.   
    91.         this.subQuery.put(propertyName, query);  
    92.     }  
    93.   
    94.     private void addSubQuery(Query query) {  
    95.         addSubQuery(query.projection, query);  
    96.     }  
    97.   
    98.     /** 增关联查询 */  
    99.     public void addLinkQuery(String propertyName, Query query) {  
    100.         if (this.linkQuery == null)  
    101.             this.linkQuery = new HashMap();  
    102.   
    103.         this.linkQuery.put(propertyName, query);  
    104.     }  
    105.   
    106.     /** 相等 */  
    107.     public void eq(String propertyName, Object value) {  
    108.         if (isNullOrEmpty(value))  
    109.             return;  
    110.         this.predicates.add(criteriaBuilder.equal(from.get(propertyName), value));  
    111.     }  
    112.   
    113.     private boolean isNullOrEmpty(Object value) {  
    114.         if (value instanceof String) {  
    115.             return value == null || "".equals(value);  
    116.         }  
    117.         return value == null;  
    118.     }  
    119.   
    120.     public void or(List<String> propertyName, Object value) {  
    121.         if (isNullOrEmpty(value))  
    122.             return;  
    123.         if ((propertyName == null) || (propertyName.size() == 0))  
    124.             return;  
    125.         Predicate predicate = criteriaBuilder.or(criteriaBuilder.equal(from.get(propertyName.get(0)), value));  
    126.         for (int i = 1; i < propertyName.size(); ++i)  
    127.             predicate = criteriaBuilder.or(predicate, criteriaBuilder.equal(from.get(propertyName.get(i)), value));  
    128.         this.predicates.add(predicate);  
    129.     }  
    130.   
    131.     public void orLike(List<String> propertyName, String value) {  
    132.         if (isNullOrEmpty(value) || (propertyName.size() == 0))  
    133.             return;  
    134.         if (value.indexOf("%") < 0)  
    135.             value = "%" + value + "%";  
    136.         Predicate predicate = criteriaBuilder.or(criteriaBuilder.like(from.get(propertyName.get(0)), value.toString()));  
    137.         for (int i = 1; i < propertyName.size(); ++i)  
    138.             predicate = criteriaBuilder.or(predicate, criteriaBuilder.like(from.get(propertyName.get(i)), value));  
    139.         this.predicates.add(predicate);  
    140.     }  
    141.   
    142.     /** 空 */  
    143.     public void isNull(String propertyName) {  
    144.         this.predicates.add(criteriaBuilder.isNull(from.get(propertyName)));  
    145.     }  
    146.   
    147.     /** 非空 */  
    148.     public void isNotNull(String propertyName) {  
    149.         this.predicates.add(criteriaBuilder.isNotNull(from.get(propertyName)));  
    150.     }  
    151.   
    152.     /** 不相等 */  
    153.     public void notEq(String propertyName, Object value) {  
    154.         if (isNullOrEmpty(value)) {  
    155.             return;  
    156.         }  
    157.         this.predicates.add(criteriaBuilder.notEqual(from.get(propertyName), value));  
    158.     }  
    159.   
    160.     /** 
    161.      * not in 
    162.      *  
    163.      * @param propertyName 
    164.      *            属性名称 
    165.      * @param value 
    166.      *            值集合 
    167.      */  
    168.     public void notIn(String propertyName, Collection value) {  
    169.         if ((value == null) || (value.size() == 0)) {  
    170.             return;  
    171.         }  
    172.         Iterator iterator = value.iterator();  
    173.         In in = criteriaBuilder.in(from.get(propertyName));  
    174.         while (iterator.hasNext()) {  
    175.             in.value(iterator.next());  
    176.         }  
    177.         this.predicates.add(criteriaBuilder.not(in));  
    178.     }  
    179.   
    180.     /** 
    181.      * 模糊匹配 
    182.      *  
    183.      * @param propertyName 
    184.      *            属性名称 
    185.      * @param value 
    186.      *            属性值 
    187.      */  
    188.     public void like(String propertyName, String value) {  
    189.         if (isNullOrEmpty(value))  
    190.             return;  
    191.         if (value.indexOf("%") < 0)  
    192.             value = "%" + value + "%";  
    193.         this.predicates.add(criteriaBuilder.like(from.get(propertyName), value));  
    194.     }  
    195.   
    196.     /** 
    197.      * 时间区间查询 
    198.      *  
    199.      * @param propertyName 
    200.      *            属性名称 
    201.      * @param lo 
    202.      *            属性起始值 
    203.      * @param go 
    204.      *            属性结束值 
    205.      */  
    206.     public void between(String propertyName, Date lo, Date go) {  
    207.         if (!isNullOrEmpty(lo) && !isNullOrEmpty(go)) {  
    208.             this.predicates.add(criteriaBuilder.between(from.get(propertyName), lo, go));  
    209.         }  
    210.   
    211.         // if (!isNullOrEmpty(lo) && !isNullOrEmpty(go)) {  
    212.         // this.predicates.add(criteriaBuilder.lessThan(from.get(propertyName),  
    213.         // new DateTime(lo).toString()));  
    214.         // }  
    215.         // if (!isNullOrEmpty(go)) {  
    216.         // this.predicates.add(criteriaBuilder.greaterThan(from.get(propertyName),  
    217.         // new DateTime(go).toString()));  
    218.         // }  
    219.   
    220.     }  
    221.   
    222.     public void between(String propertyName, Number lo, Number go) {  
    223.         if (!(isNullOrEmpty(lo)))  
    224.             ge(propertyName, lo);  
    225.   
    226.         if (!(isNullOrEmpty(go)))  
    227.             le(propertyName, go);  
    228.     }  
    229.   
    230.     /** 
    231.      * 小于等于 
    232.      *  
    233.      * @param propertyName 
    234.      *            属性名称 
    235.      * @param value 
    236.      *            属性值 
    237.      */  
    238.     public void le(String propertyName, Number value) {  
    239.         if (isNullOrEmpty(value)) {  
    240.             return;  
    241.         }  
    242.         this.predicates.add(criteriaBuilder.le(from.get(propertyName), value));  
    243.     }  
    244.   
    245.     /** 
    246.      * 小于 
    247.      *  
    248.      * @param propertyName 
    249.      *            属性名称 
    250.      * @param value 
    251.      *            属性值 
    252.      */  
    253.     public void lt(String propertyName, Number value) {  
    254.         if (isNullOrEmpty(value)) {  
    255.             return;  
    256.         }  
    257.         this.predicates.add(criteriaBuilder.lt(from.get(propertyName), value));  
    258.     }  
    259.   
    260.     /** 
    261.      * 大于等于 
    262.      *  
    263.      * @param propertyName 
    264.      *            属性名称 
    265.      * @param value 
    266.      *            属性值 
    267.      */  
    268.     public void ge(String propertyName, Number value) {  
    269.         if (isNullOrEmpty(value)) {  
    270.             return;  
    271.         }  
    272.         this.predicates.add(criteriaBuilder.ge(from.get(propertyName), value));  
    273.     }  
    274.   
    275.     /** 
    276.      * 大于 
    277.      *  
    278.      * @param propertyName 
    279.      *            属性名称 
    280.      * @param value 
    281.      *            属性值 
    282.      */  
    283.     public void gt(String propertyName, Number value) {  
    284.         if (isNullOrEmpty(value)) {  
    285.             return;  
    286.         }  
    287.         this.predicates.add(criteriaBuilder.gt(from.get(propertyName), value));  
    288.     }  
    289.   
    290.     /** 
    291.      * in 
    292.      *  
    293.      * @param propertyName 
    294.      *            属性名称 
    295.      * @param value 
    296.      *            值集合 
    297.      */  
    298.     public void in(String propertyName, Collection value) {  
    299.         if ((value == null) || (value.size() == 0)) {  
    300.             return;  
    301.         }  
    302.         Iterator iterator = value.iterator();  
    303.         In in = criteriaBuilder.in(from.get(propertyName));  
    304.         while (iterator.hasNext()) {  
    305.             in.value(iterator.next());  
    306.         }  
    307.         this.predicates.add(in);  
    308.     }  
    309.   
    310.     /** 直接添加JPA内部的查询条件,用于应付一些复杂查询的情况,例如或 */  
    311.     public void addCriterions(Predicate predicate) {  
    312.         this.predicates.add(predicate);  
    313.     }  
    314.   
    315.     /** 
    316.      * 创建查询条件 
    317.      *  
    318.      * @return JPA离线查询 
    319.      */  
    320.     public CriteriaQuery newCriteriaQuery() {  
    321.         criteriaQuery.where(predicates.toArray(new Predicate[0]));  
    322.         if (!isNullOrEmpty(groupBy)) {  
    323.             criteriaQuery.groupBy(from.get(groupBy));  
    324.         }  
    325.         if (this.orders != null) {  
    326.             criteriaQuery.orderBy(orders);  
    327.         }  
    328.         addLinkCondition(this);  
    329.         return criteriaQuery;  
    330.     }  
    331.   
    332.     private void addLinkCondition(Query query) {  
    333.   
    334.         Map subQuery = query.linkQuery;  
    335.         if (subQuery == null)  
    336.             return;  
    337.   
    338.         for (Iterator queryIterator = subQuery.keySet().iterator(); queryIterator.hasNext();) {  
    339.             String key = (String) queryIterator.next();  
    340.             Query sub = (Query) subQuery.get(key);  
    341.             from.join(key);  
    342.             criteriaQuery.where(sub.predicates.toArray(new Predicate[0]));  
    343.             addLinkCondition(sub);  
    344.         }  
    345.     }  
    346.   
    347.     public void addOrder(String propertyName, String order) {  
    348.         if (order == null || propertyName == null)  
    349.             return;  
    350.   
    351.         if (this.orders == null)  
    352.             this.orders = new ArrayList();  
    353.   
    354.         if (order.equalsIgnoreCase("asc"))  
    355.             this.orders.add(criteriaBuilder.asc(from.get(propertyName)));  
    356.         else if (order.equalsIgnoreCase("desc"))  
    357.             this.orders.add(criteriaBuilder.desc(from.get(propertyName)));  
    358.     }  
    359.   
    360.     public void setOrder(String propertyName, String order) {  
    361.         this.orders = null;  
    362.         addOrder(propertyName, order);  
    363.     }  
    364.   
    365.     public Class getModleClass() {  
    366.         return this.clazz;  
    367.     }  
    368.   
    369.     public String getProjection() {  
    370.         return this.projection;  
    371.     }  
    372.   
    373.     public void setProjection(String projection) {  
    374.         this.projection = projection;  
    375.     }  
    376.   
    377.     public Class getClazz() {  
    378.         return this.clazz;  
    379.     }  
    380.   
    381.     public List<Order> getOrders() {  
    382.         return orders;  
    383.     }  
    384.   
    385.     public void setOrders(List<Order> orders) {  
    386.         this.orders = orders;  
    387.     }  
    388.   
    389.     public EntityManager getEntityManager() {  
    390.         return this.entityManager;  
    391.     }  
    392.   
    393.     public void setEntityManager(EntityManager em) {  
    394.         this.entityManager = em;  
    395.     }  
    396.   
    397.     public Root getFrom() {  
    398.         return from;  
    399.     }  
    400.   
    401.     public List<Predicate> getPredicates() {  
    402.         return predicates;  
    403.     }  
    404.   
    405.     public void setPredicates(List<Predicate> predicates) {  
    406.         this.predicates = predicates;  
    407.     }  
    408.   
    409.     public CriteriaQuery getCriteriaQuery() {  
    410.         return criteriaQuery;  
    411.     }  
    412.   
    413.     public CriteriaBuilder getCriteriaBuilder() {  
    414.         return criteriaBuilder;  
    415.     }  
    416.   
    417.     public void setFetchModes(List<String> fetchField, List<String> fetchMode) {  
    418.   
    419.     }  
    420.   
    421.     public String getGroupBy() {  
    422.         return groupBy;  
    423.     }  
    424.   
    425.     public void setGroupBy(String groupBy) {  
    426.         this.groupBy = groupBy;  
    427.     }  
    428.   
    429. }  

     

    [java] view plain copy
    1. <?xml version="1.0" encoding="UTF-8"?>  
    2. <beans xmlns="http://www.springframework.org/schema/beans"  
    3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"  
    4.     xmlns:tx="http://www.springframework.org/schema/tx" xmlns:context="http://www.springframework.org/schema/context"  
    5.     xmlns:util="http://www.springframework.org/schema/util"  
    6.     xmlns:aop="http://www.springframework.org/schema/aop"  
    7.     xsi:schemaLocation="  
    8.             http://www.springframework.org/schema/beans   
    9.             http://www.springframework.org/schema/beans/spring-beans-3.1.xsd  
    10.             http://www.springframework.org/schema/tx   
    11.             http://www.springframework.org/schema/tx/spring-tx-3.1.xsd  
    12.             http://www.springframework.org/schema/context  
    13.             http://www.springframework.org/schema/context/spring-context-3.1.xsd  
    14.             http://www.springframework.org/schema/aop   
    15.             http://www.springframework.org/schema/aop/spring-aop.xsd  
    16.             http://www.springframework.org/schema/util   
    17.             http://www.springframework.org/schema/util/spring-util-3.1.xsd">   
    18.   
    19.     <!-- JPA Entity Manager Factory -->  
    20.     <bean id="entityManagerFactory"  
    21.         class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean"  
    22.         p:packagesToScan="com.**.model" p:dataSource-ref="dataSource"  
    23.         p:jpaVendorAdapter-ref="hibernateVendor" p:jpaPropertyMap-ref="jpaPropertyMap"/>  
    24.   
    25.     <util:map id="jpaPropertyMap">  
    26.         <entry key="hibernate.hbm2ddl.auto" value="update" /><!-- create,update,none -->  
    27.         <entry key="hibernate.format_sql" value="false" />  
    28.         <entry key="hibernate.show_sql" value="false" />  
    29.         <entry key="hibernate.current_session_context_class" value="org.hibernate.context.internal.ThreadLocalSessionContext"/>  
    30.         <entry key="hibernate.dialect" value="org.hibernate.dialect.MySQLDialect" />  
    31.   
    32.         <!-- To enable Hibernate's second level cache and query cache settings -->  
    33.         <entry key="hibernate.max_fetch_depth" value="4" />  
    34.         <entry key="hibernate.cache.use_second_level_cache" value="true" />  
    35.         <entry key="hibernate.cache.use_query_cache" value="true" />  
    36.         <!-- <entry key="hibernate.cache.region.factory_class" value="org.hibernate.cache.ehcache.EhCacheRegionFactory" /> -->  
    37.         <entry key="hibernate.cache.region.factory_class" value="org.hibernate.cache.SingletonEhCacheRegionFactory" />  
    38.     </util:map>  
    39.   
    40.     <bean id="hibernateVendor"  
    41.         class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter"  
    42.         p:database="MYSQL" p:showSql="true" p:generateDdl="true"  
    43.         p:databasePlatform="org.hibernate.dialect.MySQLDialect" />  
    44.           
    45.     <bean id="transactionHandler" class="com.platform.framework.dao.jpa.TransactionHandler" >  
    46.         <property name="txmethod">  
    47.             <list>  
    48.                 <value>insert</value>  
    49.                 <value>update</value>  
    50.                 <value>delete</value>  
    51.             </list>  
    52.         </property>  
    53.         <property name="entityManagerFactory" ref="entityManagerFactory"/>  
    54.     </bean>  
    55.     <aop:config>  
    56.         <aop:aspect id="tran" ref="transactionHandler">  
    57.             <aop:pointcut  id="tranMethod"  
    58.                 expression="  
    59.                     execution(* com.*.dao.*.*(..))||  
    60.                     execution(* com.*.service.impl.*.*(..))||  
    61.                       
    62.                     execution(* com.*.*.dao.*.*(..))||  
    63.                     execution(* com.*.*.service.impl.*.*(..))||  
    64.                       
    65.                     execution(* com.*.*.*.dao.*.*(..))||  
    66.                     execution(* com.*.*.*.service.impl.*.*(..))||  
    67.                       
    68.                     execution(* com.*.*.*.*.dao.*.*(..))||  
    69.                     execution(* com.*.*.*.*.service.impl.*.*(..))||  
    70.                       
    71.                     execution(* com.*.*.*.*.*.dao.*.*(..))||  
    72.                     execution(* com.*.*.*.*.*.service.impl.*.*(..))||  
    73.                       
    74.                     execution(* com.*.*.*.*.*.*.dao.*.*(..))||  
    75.                     execution(* com.*.*.*.*.*.*.service.impl.*.*(..))||  
    76.                       
    77.                     execution(* com.platform.framework.dao.jpa.BaseDaoImpl.*(..))"/>  
    78.             <aop:around method="exec"  pointcut-ref="tranMethod" />  
    79.         </aop:aspect>  
    80.     </aop:config>  
    81.       
    82.     <bean id="baseDao" class="com.platform.framework.dao.jpa.BaseDaoImpl">  
    83.         <property name="emf" ref="entityManagerFactory"/>  
    84.     </bean>  
    85. </beans>  

     

    [java] view plain copy
    1. package com.platform.framework.dao.jpa;  
    2.   
    3. import javax.persistence.EntityManager;  
    4. import javax.persistence.EntityManagerFactory;  
    5. import javax.persistence.EntityTransaction;  
    6.   
    7. import org.apache.log4j.Logger;  
    8. import org.aspectj.lang.ProceedingJoinPoint;  
    9. import org.aspectj.lang.Signature;  
    10.   
    11. /** 
    12.  * @describe JPA事务管理 
    13.  * @author lry 
    14.  * @since：2014-05-23 
    15.  *  
    16.  */  
    17. public class TransactionHandler {  
    18.   
    19.     private static final Logger log = Logger  
    20.             .getLogger(TransactionHandler.class);  
    21.   
    22.     private String[] txmethod;// 配置事务的传播特性方法  
    23.   
    24.     private EntityManagerFactory entityManagerFactory;// JPA工厂  
    25.   
    26.     public Object exec(ProceedingJoinPoint point) throws Throwable {  
    27.   
    28.         Signature signature = point.getSignature();  
    29.          log.debug(point.getTarget().getClass().getName() + "."  
    30.          + signature.getName() + "()");  
    31.         Boolean isTransaction = false;  
    32.         for (String method : txmethod) {  
    33.             if (signature.getName().startsWith(method)) {// 以method开头的方法打开事务  
    34.                 isTransaction = true;  
    35.                 break;  
    36.             }  
    37.         }  
    38.   
    39.         // JPA->Hibernate  
    40.         if (point.getTarget() instanceof EntityManagerFactoryProxy) {  
    41.   
    42.             // 获得被代理对象  
    43.             EntityManagerFactoryProxy emfp = (EntityManagerFactoryProxy) point  
    44.                     .getTarget();  
    45.             EntityManager em = emfp.getEntityManager();  
    46.             if (em != null) {// 如果对象已经有em了就不管  
    47.                 return point.proceed();  
    48.             } else {  
    49.                 em = entityManagerFactory.createEntityManager();  
    50.             }  
    51.              log.debug("JPA->Hibernate open connection...");  
    52.             if (isTransaction) {  
    53.                 EntityTransaction t = null;  
    54.                 try {  
    55.   
    56.                     // 打开连接并开启事务  
    57.                      log.debug("JPA->Hibernate begin transaction...");  
    58.                     t = em.getTransaction();  
    59.                     if (!t.isActive())  
    60.                         t.begin();  
    61.                     emfp.setEntityManager(em);  
    62.                     Object obj = point.proceed();  
    63.   
    64.                     // 提交事务  
    65.                     log.debug("JPA->Hibernate commit...");  
    66.                     t.commit();  
    67.                     return obj;  
    68.                 } catch (Exception e) {  
    69.                     if (t != null) {  
    70.                         log.debug("JPA->Hibernate error...,rollback..."  
    71.                                 + e.getMessage());  
    72.                         t.rollback();  
    73.                     }  
    74.                     e.printStackTrace();  
    75.                     throw e;  
    76.                 } finally {  
    77.                     if (em != null && em.isOpen()) {// 关闭连接  
    78.                         em.close();  
    79.                         log.debug("JPA->Hibernate close connection...");  
    80.                     }  
    81.                     emfp.setEntityManager(null);  
    82.                 }  
    83.             } else {  
    84.                 try {  
    85.                     emfp.setEntityManager(em);  
    86.                     return point.proceed();  
    87.                 } catch (Exception e) {  
    88.                     log.debug("JPA->Hibernate error..." + e.getMessage());  
    89.                     e.printStackTrace();  
    90.                     throw e;  
    91.                 } finally {  
    92.                     if (em != null && em.isOpen()) {// 关闭连接  
    93.                         em.close();  
    94.                         log.debug("JPA->Hibernate close connection...");  
    95.                     }  
    96.                     emfp.setEntityManager(null);  
    97.                 }  
    98.             }  
    99.         } else {  
    100.             return point.proceed();  
    101.         }  
    102.     }  
    103.   
    104.     public String[] getTxmethod() {  
    105.         return txmethod;  
    106.     }  
    107.   
    108.     public void setTxmethod(String[] txmethod) {  
    109.         this.txmethod = txmethod;  
    110.     }  
    111.   
    112.     public void setEntityManagerFactory(  
    113.             EntityManagerFactory entityManagerFactory) {  
    114.         this.entityManagerFactory = entityManagerFactory;  
    115.     }  
    116.   
    117. }  

     

    EntityManager管理器，通过spring管理

    [java] view plain copy
    1. package com.platform.framework.dao.jpa;  
    2.   
    3. import java.util.Collection;  
    4.   
    5. import javax.persistence.EntityManager;  
    6. import javax.persistence.EntityManagerFactory;  
    7.   
    8. /** 
    9.  * EntityManager管理器 
    10.  *  
    11.  * @author：yangjian1004 
    12.  * @since：2011-11-30 16:14:24 AM 
    13.  */  
    14. public class EntityManagerFactoryProxy {  
    15.   
    16.     private static ThreadLocal<EntityManager> emThreadLocal = new ThreadLocal<EntityManager>();  
    17.     private static EntityManagerFactory emf;  
    18.   
    19.     public void setEmf(EntityManagerFactory emf) {  
    20.         EntityManagerFactoryProxy.emf = emf;  
    21.     }  
    22.   
    23.     public static EntityManagerFactory getEmf() {  
    24.         return emf;  
    25.     }  
    26.   
    27.     public EntityManager getEntityManager() {  
    28.         return emThreadLocal.get();  
    29.     }  
    30.   
    31.     public void setEntityManager(EntityManager em) {  
    32.         emThreadLocal.set(em);  
    33.     }  
    34.   
    35.     /** 
    36.      * 创建查询条件 
    37.      *  
    38.      * @param name 
    39.      *            字段名称 
    40.      * @param values 
    41.      *            字段值 
    42.      */  
    43.     public String createInCondition(String name, Collection<String> values) {  
    44.         if (values == null || values.size() == 0) {  
    45.             return "1<>1";  
    46.         }  
    47.         StringBuffer sb = new StringBuffer();  
    48.         sb.append(name + " in(");  
    49.         for (String id : values) {  
    50.             sb.append("'" + id + "',");  
    51.         }  
    52.         String hsqlCondition = sb.substring(0, sb.length() - 1) + ")";  
    53.         return hsqlCondition;  
    54.     }  
    55. }  

     

    Page分页和结果封装类

    [java] view plain copy
    1. package com.platform.framework.dao.jpa;  
    2.   
    3. import java.io.Serializable;  
    4. import java.util.ArrayList;  
    5. import java.util.List;  
    6.   
    7. /** 
    8.  * Page基类<br> 
    9.  *  
    10.  * @describe：分页 
    11.  */  
    12. public class Page<T> implements Serializable {  
    13.   
    14.     private static final long serialVersionUID = 665620345605746930L;  
    15.     /** 总条数 */  
    16.     private int count;  
    17.     /** 页码 */  
    18.     private int pageNo;  
    19.     /** 每页显示多少条 */  
    20.     private int rowsPerPage;  
    21.     /** 总页数 */  
    22.     private int totalPageCount;  
    23.     /** 起始条数 */  
    24.     private int firstRow;  
    25.     /** 结束条数 */  
    26.     private int lastRow;  
    27.     /** 查询结果集合形式的结果 */  
    28.     private List<T> result;  
    29.     /** 查询结果对象形式的结果 */  
    30.     public Object obj;  
    31.   
    32.     public Integer code; // 返回码  
    33.     private boolean success = true;  
    34.     private String message;  
    35.   
    36.     public Page() {  
    37.     }  
    38.   
    39.     public Page(List<T> list) {  
    40.         this(list.size(), 1, list.size(), list);  
    41.     }  
    42.   
    43.     public Page(int count, int pageNo, int rowsPerPage, List<T> result) {  
    44.         if (rowsPerPage < 1) {  
    45.             rowsPerPage = 1;  
    46.         }  
    47.         this.count = count;  
    48.         this.pageNo = pageNo;  
    49.         this.result = result;  
    50.         this.rowsPerPage = rowsPerPage;  
    51.         if (this.result == null)  
    52.             this.result = new ArrayList<T>();  
    53.         totalPageCount = count / rowsPerPage;  
    54.         if (count - (count / rowsPerPage) * rowsPerPage > 0)  
    55.             totalPageCount++;  
    56.         if (count == 0) {  
    57.             totalPageCount = 0;  
    58.             pageNo = 0;  
    59.         }  
    60.   
    61.         firstRow = (pageNo - 1) * rowsPerPage + 1;  
    62.         if (count == 0) {  
    63.             firstRow = 0;  
    64.         }  
    65.         lastRow = (pageNo) * rowsPerPage;  
    66.         if (lastRow > count) {  
    67.             lastRow = count;  
    68.         }  
    69.     }  
    70.   
    71.     /** 返回每页的条数 */  
    72.     public int getCount() {  
    73.         return count;  
    74.     }  
    75.   
    76.     public List<T> getResult() {  
    77.         return result;  
    78.     }  
    79.   
    80.     public int getPageNo() {  
    81.         return pageNo;  
    82.     }  
    83.   
    84.     /** 返回每页的条数 */  
    85.     public int getRowsPerPage() {  
    86.         return rowsPerPage;  
    87.     }  
    88.   
    89.     /** 返回总的页数 */  
    90.     public int getTotalPageCount() {  
    91.         return totalPageCount;  
    92.     }  
    93.   
    94.     public void setPageNo(int pageNo) {  
    95.         this.pageNo = pageNo;  
    96.     }  
    97.   
    98.     public void setRowsPerPage(int rowsPerPage) {  
    99.         this.rowsPerPage = rowsPerPage;  
    100.     }  
    101.   
    102.     public int getFirstRow() {  
    103.         return firstRow;  
    104.     }  
    105.   
    106.     public int getLastRow() {  
    107.         return lastRow;  
    108.     }  
    109.   
    110.     public void setFirstRow(int firstRow) {  
    111.         this.firstRow = firstRow;  
    112.     }  
    113.   
    114.     public void setLastRow(int lastRow) {  
    115.         this.lastRow = lastRow;  
    116.     }  
    117.   
    118.     public void setCount(int count) {  
    119.         this.count = count;  
    120.     }  
    121.   
    122.     public void setTotalPageCount(int totalPageCount) {  
    123.         this.totalPageCount = totalPageCount;  
    124.     }  
    125.   
    126.     public void setResult(List<T> result) {  
    127.         this.result = result;  
    128.     }  
    129.   
    130.     public Object getObj() {  
    131.         return obj;  
    132.     }  
    133.   
    134.     public void setObj(Object obj) {  
    135.         this.obj = obj;  
    136.     }  
    137.   
    138.     public boolean isSuccess() {  
    139.         return success;  
    140.     }  
    141.   
    142.     public void setSuccess(boolean success) {  
    143.         this.success = success;  
    144.     }  
    145.   
    146.     public String getMessage() {  
    147.         return message;  
    148.     }  
    149.   
    150.     public void setMessage(String message) {  
    151.         this.message = message;  
    152.     }  
    153.   
    154.     /** 
    155.      * 计算起始条数 
    156.      */  
    157.     public static int calc(int pageNo, int rowsPerPage, int count) {  
    158.         if (pageNo <= 0)  
    159.             pageNo = 1;  
    160.         if (rowsPerPage <= 0)  
    161.             rowsPerPage = 10;  
    162.   
    163.         // 当把最后一页数据删除以后,页码会停留在最后一个上必须减一  
    164.         int totalPageCount = count / rowsPerPage;  
    165.         if (pageNo > totalPageCount && (count % rowsPerPage == 0)) {  
    166.             pageNo = totalPageCount;  
    167.         }  
    168.         if (pageNo - totalPageCount > 2) {  
    169.             pageNo = totalPageCount + 1;  
    170.         }  
    171.         int firstRow = (pageNo - 1) * rowsPerPage;  
    172.         if (firstRow < 0) {  
    173.             firstRow = 0;  
    174.         }  
    175.         return firstRow;  
    176.     }  
    177.   
    178. }  

     

    IBaseDao接口实现了BaseDaoImpl

    [java] view plain copy
    1. package com.platform.framework.dao.jpa;  
    2.   
    3. import java.io.Serializable;  
    4. import java.util.List;  
    5.   
    6. import javax.persistence.EntityManager;  
    7. import javax.persistence.criteria.CriteriaQuery;  
    8. import javax.persistence.criteria.Predicate;  
    9. import javax.persistence.criteria.Selection;  
    10. import javax.persistence.metamodel.EntityType;  
    11.   
    12. import org.apache.log4j.Logger;  
    13.   
    14. import com.google.common.base.Strings;  
    15. /** 
    16.  * IBaseDao接口实现了BaseDaoImpl类<br> 
    17.  */  
    18. @SuppressWarnings({ "unchecked", "rawtypes" })  
    19. public class BaseDaoImpl<T> extends EntityManagerFactoryProxy implements IBaseDao {  
    20.   
    21.     private static Logger log = Logger.getLogger(BaseDaoImpl.class);  
    22.   
    23.     /** 每次批量操作数 */  
    24.     private int batchSize = 50;  
    25.   
    26.     /** 设置每次操作数 */  
    27.     public void setBatchSize(int batchSize) {  
    28.         this.batchSize = batchSize;  
    29.     }  
    30.   
    31.     public <E> E get(Class clazz, Serializable id) {  
    32.         return (E) getEntityManager().find(clazz, id);  
    33.     }  
    34.   
    35.     /** 
    36.      * 插入记录 
    37.      *  
    38.      * @param entity 
    39.      *            要插入的记录 
    40.      */  
    41.     public void insert(Object entity) {  
    42.         if (entity instanceof List) {  
    43.             insertList((List) entity);  
    44.             return;  
    45.         } else if (entity instanceof Object[]) {  
    46.             return;  
    47.         }  
    48.         try {  
    49.             getEntityManager().persist(entity);  
    50.         } catch (Exception e) {  
    51.             e.printStackTrace();  
    52.         }  
    53.     }  
    54.   
    55.     /** 
    56.      * 批量增加 
    57.      *  
    58.      * @param list 
    59.      *            要新增的数据 
    60.      */  
    61.     public void insertList(List list) {  
    62.         EntityManager entityManager = getEntityManager();  
    63.         if (list == null || list.size() == 0) {  
    64.             return;  
    65.         }  
    66.         int i = 0;  
    67.         for (Object o : list) {  
    68.             insert(o);  
    69.             if (i % batchSize == 0) {  
    70.                 entityManager.flush();  
    71.             }  
    72.             i++;  
    73.         }  
    74.         log.debug(list.get(0).getClass() + "批量增加数据" + i + "条");  
    75.     }  
    76.   
    77.     /** 
    78.      * 更新记录 
    79.      *  
    80.      * @param entity 
    81.      *            要更新的记录 
    82.      */  
    83.     public void update(Object entity) {  
    84.         if (entity instanceof List) {  
    85.             this.updateList((List) entity);  
    86.             return;  
    87.         }  
    88.         getEntityManager().merge(entity);  
    89.     }  
    90.   
    91.     /** 更新list */  
    92.     public void updateList(List list) {  
    93.         for (Object entity : list) {  
    94.             this.update(entity);  
    95.         }  
    96.     }  
    97.   
    98.     /** 
    99.      * 删除记录 
    100.      *  
    101.      * @param entity 
    102.      *            要删除的记录 
    103.      */  
    104.     public void delete(Object entity) {  
    105.         if (entity instanceof List) {  
    106.             List list = (List) entity;  
    107.             for (Object o : list) {  
    108.                 getEntityManager().remove(o);  
    109.             }  
    110.         } else {  
    111.             getEntityManager().remove(entity);  
    112.         }  
    113.     }  
    114.   
    115.     public <E extends Serializable> List<E> query(String jpql) {  
    116.         return getEntityManager().createQuery(jpql).getResultList();  
    117.     }  
    118.   
    119.     public Integer updateJpql(String jpql) {  
    120.         return getEntityManager().createQuery(jpql).executeUpdate();  
    121.     }  
    122.   
    123.     public Integer updateSql(String sql) {  
    124.         return getEntityManager().createNativeQuery(sql).executeUpdate();  
    125.     }  
    126.   
    127.     public <E extends Serializable> List<E> queryBySql(String sql) {  
    128.         return getEntityManager().createNativeQuery(sql).getResultList();  
    129.     }  
    130.   
    131.     /** 
    132.      * 查询记录 
    133.      *  
    134.      * @param clazz 
    135.      *            要查询的实体类 
    136.      * @param hqlCondition 
    137.      *            查询条件 
    138.      */  
    139.     public <E extends Serializable> List<E> query(Class clazz, String hqlCondition) {  
    140.         return getEntityManager().createQuery("select t from " + clazz.getName() + " as t where " + hqlCondition)  
    141.                 .getResultList();  
    142.     }  
    143.   
    144.     public void delete(Class entity, String jpqlCondition) {  
    145.         if (Strings.isNullOrEmpty(jpqlCondition)) {  
    146.             jpqlCondition = "1=1";  
    147.         }  
    148.         int no = updateJpql("delete " + entity.getName() + " where " + jpqlCondition);  
    149.         log.debug(entity.getName() + "删除" + no + "条数据");  
    150.     }  
    151.   
    152.     /** 
    153.      * 根据ids删除数据 
    154.      *  
    155.      * @param entity 
    156.      *            删除实体类 
    157.      * @param ids 
    158.      *            删除条件 
    159.      */  
    160.     public void delete(Class entity, List ids) {  
    161.         String idName = getIdName(entity, getEntityManager());  
    162.         StringBuffer sb = new StringBuffer();  
    163.         sb.append(idName + " in(");  
    164.         for (int i = 0; i < ids.size(); i++) {  
    165.             sb.append("'" + ids.get(i) + "',");  
    166.         }  
    167.         String jpqlCondition = sb.substring(0, sb.length() - 1) + ")";  
    168.         delete(entity, jpqlCondition);  
    169.     }  
    170.   
    171.     public <E extends Serializable> List<E> query(String jpql, int firstResult, int maxResults) {  
    172.         List result = getEntityManager().createQuery(jpql).setFirstResult(firstResult).setMaxResults(maxResults)  
    173.                 .getResultList();  
    174.         return result;  
    175.     }  
    176.   
    177.     public <E extends Serializable> List<E> queryBySql(String sql, int firstResult, int maxResults) {  
    178.         return getEntityManager().createNativeQuery(sql).setFirstResult(firstResult).setMaxResults(maxResults)  
    179.                 .getResultList();  
    180.     }  
    181.   
    182.     public <E extends Serializable> List<E> queryAll(Class clazz) {  
    183.         CriteriaQuery criteriaQuery = getEntityManager().getCriteriaBuilder().createQuery(clazz);  
    184.         criteriaQuery.from(clazz);  
    185.         return getEntityManager().createQuery(criteriaQuery).getResultList();  
    186.     }  
    187.   
    188.     public Page queryPageByJpql(String jpql, int pageNo, int rowsPerPage) {  
    189.         if (pageNo <= 0)  
    190.             pageNo = 1;  
    191.         if (rowsPerPage <= 0)  
    192.             rowsPerPage = 7;  
    193.         log.debug("-----开始查询,页码:" + pageNo + ",每页显示:" + rowsPerPage + "----");  
    194.   
    195.         String countJpql = "select count(*) from (" + jpql + ")";  
    196.         int count = getCount(countJpql).intValue();  
    197.   
    198.         // 当把最后一页数据删除以后,页码会停留在最后一个上必须减一  
    199.         int totalPageCount = count / rowsPerPage;  
    200.         if (pageNo > totalPageCount && (count % rowsPerPage == 0)) {  
    201.             pageNo = totalPageCount;  
    202.         }  
    203.         if (pageNo - totalPageCount > 2) {  
    204.             pageNo = totalPageCount + 1;  
    205.         }  
    206.         int firstResult = (pageNo - 1) * rowsPerPage;  
    207.         if (firstResult < 0) {  
    208.             firstResult = 0;  
    209.         }  
    210.         List result = getEntityManager().createQuery(jpql).setFirstResult(firstResult).setMaxResults(rowsPerPage)  
    211.                 .getResultList();  
    212.         return new Page(count, pageNo, rowsPerPage, result);  
    213.     }  
    214.   
    215.     public Long getCount(String jpql) {  
    216.         return (Long) getEntityManager().createQuery(jpql).getResultList().get(0);  
    217.     }  
    218.   
    219.     /*** 
    220.      *  
    221.      * @Method updateJpql 
    222.      * @Description 根据传入的带有占位符的sql语句, 做增删改操作 例如 
    223.      *              updateJpql("update user t set t.name=? where t.id=?" 
    224.      *              ,{[zhongxiang],[23]}) 
    225.      * @Author 钟翔/zhongxiang 
    226.      * @Date 2012-8-9 下午3:38:35 
    227.      * @param jpql 
    228.      *            占位符式的sql 
    229.      * @param paramList 
    230.      *            list里面装有[zhongxiang , 23] 
    231.      */  
    232.     public void updateJpql(String jpql, List paramList) {  
    233.         javax.persistence.Query query = getEntityManager().createQuery(jpql);  
    234.         for (int i = 0; i < paramList.size(); i++) {  
    235.             query.setParameter(i + 1, paramList.get(i));  
    236.         }  
    237.         query.executeUpdate();  
    238.     }  
    239.   
    240.     /** 
    241.      * 统计记录 
    242.      *  
    243.      * @param query 
    244.      *            统计条件 
    245.      */  
    246.     public Long getCount(Query query) {  
    247.         Selection selection = query.getCriteriaQuery().getSelection();  
    248.         query.getCriteriaQuery().select(query.getCriteriaBuilder().count(query.getFrom()));  
    249.         Long count = (Long) getEntityManager().createQuery(query.newCriteriaQuery()).getResultList().get(0);  
    250.         query.getCriteriaQuery().select(selection);  
    251.         return count;  
    252.     }  
    253.   
    254.     /** 
    255.      * 分页查询 
    256.      *  
    257.      * @param query 
    258.      *            查询条件 
    259.      * @param pageNo 
    260.      *            页号 
    261.      * @param rowsPerPage 
    262.      *            每页显示条数 
    263.      */  
    264.     public Page queryPage(Query query, int pageNo, int rowsPerPage) {  
    265.         if (pageNo <= 0)  
    266.             pageNo = 1;  
    267.         if (rowsPerPage <= 0)  
    268.             rowsPerPage = 7;  
    269.         log.debug(query.getClazz() + "-----开始查询,页码:" + pageNo + ",每页显示:" + rowsPerPage + "----");  
    270.         log.debug("查询条件:");  
    271.         for (Predicate cri : query.getPredicates())  
    272.             log.debug(cri);  
    273.   
    274.         int count = getCount(query).intValue();  
    275.   
    276.         // 当把最后一页数据删除以后,页码会停留在最后一个上必须减一  
    277.         int totalPageCount = count / rowsPerPage;  
    278.         if (pageNo > totalPageCount && (count % rowsPerPage == 0)) {  
    279.             pageNo = totalPageCount;  
    280.         }  
    281.         if (pageNo - totalPageCount > 2) {  
    282.             pageNo = totalPageCount + 1;  
    283.         }  
    284.         int firstResult = (pageNo - 1) * rowsPerPage;  
    285.         if (firstResult < 0) {  
    286.             firstResult = 0;  
    287.         }  
    288.         List result = getEntityManager().createQuery(query.newCriteriaQuery()).setFirstResult(firstResult)  
    289.                 .setMaxResults(rowsPerPage).getResultList();  
    290.         return new Page(count, pageNo, rowsPerPage, result);  
    291.     }  
    292.   
    293.     /** 
    294.      * 根据query查找记录 
    295.      *  
    296.      * @param query 
    297.      *            查询条件 
    298.      * @param firstResult 
    299.      *            起始行 
    300.      * @param maxResults 
    301.      *            结束行 
    302.      */  
    303.     public <E extends Serializable> List<E> query(Query query, int firstResult, int maxResults) {  
    304.         List result = getEntityManager().createQuery(query.newCriteriaQuery()).setFirstResult(firstResult)  
    305.                 .setMaxResults(maxResults).getResultList();  
    306.         return result;  
    307.     }  
    308.   
    309.     /** 
    310.      * 根据query查找记录 
    311.      *  
    312.      * @param query 
    313.      *            查询条件 
    314.      */  
    315.     public <E extends Serializable> List<E> query(Query query) {  
    316.         return getEntityManager().createQuery(query.newCriteriaQuery()).getResultList();  
    317.     }  
    318.       
    319.     /** 
    320.      * 获得主键名称 
    321.      *  
    322.      * @param clazz 
    323.      *            操作是实体对象 
    324.      * @param EntityManager 
    325.      *            jpa的entityManager工厂 
    326.      * @return 初建名称 
    327.      * */  
    328.     public static String getIdName(Class clazz, EntityManager entityManager) {  
    329.         EntityType entityType = entityManager.getMetamodel().entity(clazz);  
    330.         return entityType.getId(entityType.getIdType().getJavaType()).getName();  
    331.     }  
    332. }  

     

    IBaseDao接口 

    [java] view plain copy
    1. package com.platform.framework.dao.jpa;  
    2.   
    3. import java.io.Serializable;  
    4. import java.util.List;  
    5.   
    6. import javax.persistence.EntityManager;  
    7.   
    8. /** 
    9.  * IBaseDao基类<br> 
    10.  *  
    11.  * @describe：系统基础JPA Dao接口 
    12.  */  
    13. @SuppressWarnings({ "rawtypes" })  
    14. public interface IBaseDao {  
    15.       
    16.     public EntityManager getEntityManager();  
    17.   
    18.     public <E> E get(Class clazz, Serializable id);  
    19.   
    20.     /** 
    21.      * 插入记录 
    22.      *  
    23.      * @param entity 
    24.      *            要插入的记录 
    25.      */  
    26.     public void insert(Object entity);  
    27.   
    28.     /** 
    29.      * 更新记录 
    30.      *  
    31.      * @param entity 
    32.      *            要更新的记录 
    33.      */  
    34.     public void update(Object entity);  
    35.   
    36.     /** 更新list */  
    37.     public void updateList(List list);  
    38.   
    39.     /** 
    40.      * 删除记录 
    41.      *  
    42.      * @param entity 
    43.      *            要删除的记录 
    44.      */  
    45.     public void delete(Object entity);  
    46.   
    47.     /** 
    48.      * 删除记录 
    49.      *  
    50.      * @param entity 
    51.      *            要删除的记录 
    52.      */  
    53.     public void delete(Class entity, List ids);  
    54.   
    55.     /** 
    56.      * 删除记录 
    57.      *  
    58.      * @param entity 
    59.      *            要删除的记录 
    60.      */  
    61.     public void delete(Class entity, String jpqlCondition);  
    62.   
    63.     /** 
    64.      * 统计记录 
    65.      *  
    66.      * @param query 
    67.      *            统计条件 
    68.      */  
    69.     public Long getCount(Query query);  
    70.   
    71.     public Long getCount(String jpql);  
    72.   
    73.     /** 
    74.      * 分页查询 
    75.      *  
    76.      * @param query 
    77.      *            查询条件 
    78.      * @param pageNo 
    79.      *            页号 
    80.      * @param rowsPerPage 
    81.      *            每页显示条数 
    82.      */  
    83.     public Page queryPage(Query query, int pageNo, int rowsPerPage);  
    84.   
    85.     /** 
    86.      * 根据query查找记录 
    87.      *  
    88.      * @param query 
    89.      *            查询条件 
    90.      * @param firstResult 
    91.      *            起始行 
    92.      * @param maxResults 
    93.      *            结束行 
    94.      */  
    95.     public <E extends Serializable> List<E> query(Query query, int firstResult, int maxResults);  
    96.   
    97.     /** 
    98.      * 根据query查找记录 
    99.      *  
    100.      * @param query 
    101.      *            查询条件 
    102.      */  
    103.     public <E extends Serializable> List<E> query(Query query);  
    104.   
    105.     /** 
    106.      * 执行更新操作的jpql语句 
    107.      *  
    108.      * @param jpql 
    109.      *            要执行的jpql语句 
    110.      */  
    111.     public <E extends Serializable> List<E> query(String jpql);  
    112.   
    113.     public <E extends Serializable> List<E> queryAll(Class clazz);  
    114.   
    115.     public <E extends Serializable> List<E> query(String jpql, int firstResult, int maxResults);  
    116.   
    117.     /** 
    118.      * 执行查询操作的sql语句 
    119.      *  
    120.      * @param sql 
    121.      *            要执行的sql语句 
    122.      */  
    123.     public <E extends Serializable> List<E> queryBySql(String sql);  
    124.   
    125.     public <E extends Serializable> List<E> queryBySql(String sql, int firstResult, int maxResults);  
    126.   
    127.     /** 
    128.      * 查询记录 
    129.      *  
    130.      * @param clazz 
    131.      *            要查询的实体类 
    132.      * @param hqlCondition 
    133.      *            查询条件 
    134.      */  
    135.     public <E extends Serializable> List<E> query(Class clazz, String hqlCondition);  
    136.   
    137.     /** 
    138.      * 执行更新操作的sql语句 
    139.      *  
    140.      * @param sql 
    141.      *            要执行的sql语句 
    142.      */  
    143.     public Integer updateSql(String sql);  
    144.   
    145.     public Integer updateJpql(String jpql);  
    146.   
    147.     public Page queryPageByJpql(String hql, int pageNo, int rowsPerPage);  
    148.   
    149.     public void updateJpql(String jpql, List paramList);  
    150.   
    151. } 
  • 相关阅读:
    laravel windows下安装 gulp 和 laravel-elixir
    php-新特性，生成器的创建和使用
    laravel 使用极验验证码
    laravel 发送邮件
    laravel安装 redis 并驱动 session
    理解HTTP协议（转载）
    iOS中Block的用法，举例，解析与底层原理
    iOS自定义结构体
    dyld环境变量
    iOS中的静态库与动态库，区别、制作和使用
  • 原文地址：https://www.cnblogs.com/hzcya1995/p/13300641.html
Copyright © 2011-2022 走看看