Code666 (代码贴、代码片段)

[Java] 工具类（增删改查） →→→→→进入此内容的聊天室

来自 , 2019-05-30, 写在 Java, 查看 114 次.
URL http://www.code666.cn/view/53adaf49
  1. import java.io.Serializable;
  2. import java.sql.SQLException;
  3. import java.util.Collection;
  4. import java.util.Iterator;
  5. import java.util.List;
  6. import java.util.Map;
  7.  
  8. import org.apache.commons.lang.StringUtils;
  9. import org.hibernate.Criteria;
  10. import org.hibernate.HibernateException;
  11. import org.hibernate.LockMode;
  12. import org.hibernate.Query;
  13. import org.hibernate.SQLQuery;
  14. import org.hibernate.Session;
  15. import org.hibernate.SessionFactory;
  16. import org.hibernate.criterion.DetachedCriteria;
  17. import org.hibernate.criterion.Restrictions;
  18. import org.hibernate.persister.entity.AbstractEntityPersister;
  19. import org.hibernate.transform.Transformers;
  20. import org.springframework.beans.factory.annotation.Autowired;
  21. import org.springframework.orm.hibernate3.HibernateCallback;
  22. import org.springframework.orm.hibernate3.support.HibernateDaoSupport;
  23. import org.springframework.stereotype.Repository;
  24.  
  25. import com.eshore.edms.common.util.EntityUtil;
  26. import com.eshore.edms.common.util.StringHelper;
  27. import com.googlecode.ehcache.annotations.Cacheable;
  28.  
  29. /**
  30.  * 通用数据访问对象.
  31.  */
  32. @SuppressWarnings("unchecked")
  34. public class CommonDAO extends HibernateDaoSupport {
  35.  
  36.     /**
  37.      * 取当前管理的数据访问会话.
  38.      *
  39.      * @return hibernate会话对象
  40.      */
  41.     public Session currentSession() {
  42.         return this.getSession();
  43.     }
  44.    
  45.     /**
  46.      * 装载实体
  47.      *
  48.      * @param pClass
  49.      *            实体类
  50.      * @param primaryKey
  51.      *            实体主键
  52.      */
  53.    
  54.     public <T>T findById(Class<T> pClass, Serializable primaryKey) {
  55.         return this.getHibernateTemplate().get(pClass, primaryKey);
  56.     }
  57.    
  58.     /**
  59.      * 根据指定参数查找
  60.      * @param <T>
  61.      * @param cls
  62.      * @param name
  63.      * @param value
  64.      * @return
  65.      */
  66.     public <T> List<T> findAllByProperty(Class<T> cls, String name, Object value) {
  67.         List<T> lst=this.getHibernateTemplate().find(" from "+cls.getSimpleName()+" where "+name+"=?",new Object[]{value});
  68.         return lst;
  69.     }
  70.    
  71.     /**
  72.      * 根据指定参数查找
  73.      * @param cls
  74.      * @param name
  75.      * @param value
  76.      * @return
  77.      */
  78.         public <T> T findByProperty(Class<T> cls, String name, Object value) {
  79.                 List<?> lst = this.getHibernateTemplate().find(" from " + cls.getSimpleName() + " where " + name + "=?",
  80.                                 new Object[] { value });
  81.                 if (lst != null && !lst.isEmpty()) {
  82.                         return (T) lst.get(0);
  83.                 } else {
  84.                         return null;
  85.                 }
  86.         }
  87.    
  88.     /**
  89.      * 根据指定参数查找
  90.      * @param cls
  91.      * @param name
  92.      * @param value
  93.      * @return
  94.      */
  95.         public <T> List<T> findByProperty(Class<T> cls, Map<String, Object> param) {
  96.                 DetachedCriteria detachedCriteria = DetachedCriteria.forClass(cls, "entity");
  97.                 Criteria criteria = detachedCriteria.getExecutableCriteria(this.getSession());
  98.                 for (Iterator<String> it = param.keySet().iterator(); it.hasNext();) {
  99.                         String key = (String) it.next();
  100.                         Object value = param.get(key);
  101.                         if (value instanceof Collection) {
  102.                                 criteria.add(Restrictions.in(key, (Collection<?>) value));
  103.                         } else if (value instanceof Object[]) {
  104.                                 criteria.add(Restrictions.in(key, (Object[]) value));
  105.                         } else {
  106.                                 criteria.add(Restrictions.eq(key, value));
  107.                         }
  108.                 }
  109.                 return criteria.list();
  110.         }
  111.    
  112.     /**
  113.      * 保存实体.
  114.      *
  115.      * @param pObject
  116.      *            实体对象
  117.      * @return 实体主键
  118.      */
  119.     public void save(Object pObject) {
  120.         this.getHibernateTemplate().saveOrUpdate(pObject);
  121.     }
  122.    
  123.     /**
  124.      * 保存实体，利用主键自动除空
  125.      * @param pObject
  126.      * @throws IllegalAccessException
  127.      * @throws IllegalArgumentException
  128.      */
  129.         public void saveOrUpdate(Object pObject) {
  130.                 try {
  131.                         //如果主键为空，直接设置为null
  132.                         String primaryKeyValue = EntityUtil.getPrimaryKeyValue(
  133.                                         currentSession(), pObject.getClass(), pObject);
  134.                         if (StringUtils.isBlank(primaryKeyValue)) {
  135.                                 EntityUtil.setPrimaryKeyValue(currentSession(),
  136.                                                 pObject.getClass(), pObject, null);
  137.                         }
  138.                 } catch (Exception e) {
  139.                         e.printStackTrace();
  140.                 }
  141.                 this.getHibernateTemplate().saveOrUpdate(pObject);
  142.         }
  143.    
  144.     /**
  145.      * 批量保存
  146.      * @param entities
  147.      */
  148.     public void saveOrUpdateAll(Collection<?> entities){
  149.         this.getHibernateTemplate().saveOrUpdateAll(entities);
  150.     }
  151.  
  152.     /**
  153.      * 删除实体.
  154.      *
  155.      * @param pObject
  156.      *            实体对象
  157.      */
  158.     public void delete(Object pObject) {
  159.         this.getHibernateTemplate().delete(pObject);
  160.     }
  161.    
  162.     /**
  163.      * 批量删
  164.      * @param entities
  165.      */
  166.     public void deleteAll(Collection<?> entities){
  167.         this.getHibernateTemplate().deleteAll(entities);
  168.     }
  169.  
  170.  
  171.     /**
  172.      * 更新实体.
  173.      *
  174.      * @param pObject
  175.      *            实体对象
  176.      */
  177.     public void update(Object pObject) {
  178.         this.getHibernateTemplate().update(pObject);
  179.     }
  180.  
  181.     /**
  182.      *  比较变化保存
  183.      */
  184.     public Object merge(Object po) {
  185.         return this.getSession().merge(po);
  186.     }  
  187.    
  188.     /**
  189.      * 根据参数名称、参数值查询实体对象
  190.      *
  191.      * @param queryString
  192.      * @param paramNames
  193.      * @param values
  194.      * @return
  195.      */
  196.    
  197.     public <T>List<T> findByNamedParam(String queryString, String paramName,Object value) {
  198.         return this.getHibernateTemplate().findByNamedParam(queryString, paramName, value);
  199.     }
  200.  
  201.     /**
  202.      * 根据参数名称、参数值查询实体对象
  203.      *
  204.      * @param queryString
  205.      * @param paramNames
  206.      * @param values
  207.      * @return
  208.      */
  209.    
  210.     public <T>List<T> findByNamedParam(String queryString, String[] paramNames,
  211.             Object[] values) {
  212.         return this.getHibernateTemplate().findByNamedParam(queryString,
  213.                 paramNames, values);
  214.     }  
  215.    
  216.     /**
  217.      *
  218.      * @param queryString
  219.      * @return
  220.      */
  221.     public <T>List<T> find(String queryString){
  222.         return this.getHibernateTemplate().find(queryString);
  223.     }
  224.      
  225.  
  226.     public <T> List<T> find(String queryString,Object[] values){
  227.         return this.getHibernateTemplate().find(queryString,values);
  228.     }
  229.      
  230.     public <T> List<T> find(String queryString,Object values){
  231.         return this.getHibernateTemplate().find(queryString,values);
  232.     }
  233.    
  234.     public <T> List<T> findByHQL(String queryString, Map<String, Object> map) {
  235.         Query query = currentSession().createQuery(queryString);
  236.         if (map != null) {
  237.             query.setProperties(map);
  238.         }
  239.         return query.list();
  240.     }
  241.  
  242.     public <T> List<T> findBySQL(String queryString, Map<String, Object> map) {
  243.         SQLQuery query = currentSession().createSQLQuery(queryString);
  244.         if (map != null) {
  245.             query.setProperties(map);
  246.         }
  247.         return query.list();
  248.     }
  249.    
  250.     public <T> List<T> findBySQL(String queryString, Map<String, Object> map, Class<T> clazz) {
  251.         SQLQuery query = currentSession().createSQLQuery(queryString);
  252.         if (clazz != null) {
  253.             query.addEntity(clazz);
  254.         }
  255.         else {
  256.             query.setResultTransformer(Transformers.ALIAS_TO_ENTITY_MAP);
  257.         }
  258.         if (map != null) {
  259.             query.setProperties(map);
  260.         }
  261.         return query.list();
  262.     }
  263.    
  264.     /**
  265.      * 根据hql创建查询对象
  266.      * @param hql
  267.      * @param values 数量量可变的参数,按顺序绑定.
  268.      * @return
  269.      */
  270.     public Query createQuery(String hql, final Object... values) {
  271.         Query query = currentSession().createQuery(hql);
  272.         if(values != null){
  273.             for (int i = 0; i < values.length; i++) {
  274.                 query.setParameter(i, values[i]);
  275.             }
  276.         }
  277.         return query;
  278.     }
  279.    
  280.     /**
  281.      * 根据hql创建查询对象
  282.      * @param hql
  283.      * @param values 命名参数,按名称绑定.
  284.      * @return
  285.      */
  286.     public Query createQuery(String hql, final Map<String, Object> values) {
  287.         Query query = currentSession().createQuery(hql);
  288.         if(values != null){
  289.              query.setProperties(values);
  290.         }
  291.         return query;
  292.     }
  293.    
  294.    
  295.    
  296.     /**
  297.      * 执行HQL进行批量修改/删除操作.
  298.      *
  299.      * @param values 数量可变的参数,按顺序绑定.
  300.      * @return 更新记录数.
  301.      */
  302.     public int batchHQLExecute(final String hql, final Object... values) {
  303.         return createQuery(hql, values).executeUpdate();
  304.     }
  305.    
  306.     /**
  307.      * 执行SQL进行批量修改/删除操作.
  308.      *
  309.      * @param values 数量可变的参数,按顺序绑定.
  310.      * @return 更新记录数.
  311.      */
  312.     public int batchSQLExecute(final String sql, final Object... values) {
  313.         return createSQLQuery(sql, values).executeUpdate();
  314.     }
  315.  
  316.    
  317.     /**
  318.      * 根据sql创建查询对象
  319.      *
  320.      * @param queryString
  321.      * @return
  322.      */
  323.     public SQLQuery createSQLQuery(String queryString, final Object... values) {
  324.         SQLQuery query = currentSession().createSQLQuery(queryString);
  325.         if(values != null){
  326.             for (int i = 0; i < values.length; i++) {
  327.                 query.setParameter(i, values[i]);
  328.             }
  329.         }
  330.         return query;
  331.     }
  332.    
  333.    
  334.     /**
  335.      * 根据sql创建查询对象
  336.      *
  337.      * @param queryString
  338.      * @return
  339.      */
  340.     public SQLQuery createSQLQuery(String queryString, final Map<String, Object> values) {
  341.         SQLQuery query = currentSession().createSQLQuery(queryString);
  342.         if(values != null){
  343.             query.setProperties(values);
  344.        }
  345.         return query;
  346.     }
  347.    
  348.         /**
  349.          * 根据sql创建查询对象,并且返回指定的对象列表
  350.          *
  351.          * @param queryString
  352.          * @return
  353.          */
  354.         public SQLQuery createSQLQuery(String sql, final Map<String, Object> values, Class<?> clz) {
  355.                 SQLQuery query = this.getSession().createSQLQuery(sql);
  356.                 if (values != null) {
  357.                         query.setProperties(values);
  358.                 }
  359.                 if (clz != null) {
  360.                         query.addEntity(clz);
  361.                 } else {
  362.                         query.setResultTransformer(Transformers.ALIAS_TO_ENTITY_MAP);
  363.                 }
  364.                 return query;
  365.         }
  366.    
  367.  
  368.     /**
  369.      *
  370.      * @作者：庞健
  371.      * @类的说明：更新
  372.      * @MSN：
  373.      * @2012-7-30
  374.      */
  375.     public int updateSQLExecute(String sql,Object object){
  376.         Query query=this.getSession().createSQLQuery(sql);
  377.         if(object!=null){
  378.             query.setProperties(object);
  379.         }
  380.         return query.executeUpdate();
  381.     }
  382.     /**
  383.      * 锁定实体
  384.      *
  385.      * @param entity
  386.      * @param lockMode
  387.      */
  388.     public void refresh(Object entity, LockMode lockMode) {
  389.         this.getHibernateTemplate().refresh(entity, lockMode);
  390.     }
  391.    
  392.     /**
  393.      * 手动提交事务，提交前会自动调用一个flush（）函数，会把缓存中的数据全部输出去
  394.      * @author Liangr
  395.      * Jan 28, 2014
  396.      * void
  397.      */
  398.     public void commit() {
  399.         this.getSession().getTransaction().commit();
  400.     }
  401.  
  402.     /**
  403.      * 刷新一级缓存区的内容,使之与数据库数据保持同步
  404.      */
  405.     public void flush() {
  406.         this.getHibernateTemplate().flush();
  407.     }
  408.  
  409.     /**
  410.      * 将一级缓存中的所有持久化对象清除,释放其占用的内存资源
  411.      */
  412.     public void clear() {
  413.         this.getHibernateTemplate().clear();
  414.     }
  415.    
  416.     /**
  417.      * 将对象从二级缓存中删除,持久化对象未清除
  418.      */
  419.     @SuppressWarnings({ "deprecation"})
  420.     public void evict(Class<?> clazz,Serializable poId) {
  421.         this.getSession().getSessionFactory().evict(clazz, poId);
  422.     }
  423.    
  424.     /**
  425.      * 将对象从一级缓存中删除，持久化对象未清除
  426.      */
  427.     public void evict(Object po) {
  428.         this.getSession().evict(po);
  429.     }  
  430.  
  431.    
  432.  
  433.     /**
  434.      *
  435.      * @param sessionFactory
  436.      */
  437.     @Autowired
  438.     public void setSession$Factory(SessionFactory sessionFactory) {
  439.            super.setSessionFactory(sessionFactory);        
  440.     }
  441.    
  442.     public SessionFactory getSession$Factory() {
  443.         return super.getSessionFactory();
  444.     }
  445.    
  446.     /**
  447.      * 调用存储过程
  448.      *
  449.      * @param procedureSql example: "{call pro_ADD_PARTITION_wareid(?,?)}"
  450.      * @param values
  451.      * @return
  452.      */
  453.     public <T>int callProcedure(String procedureSql, final Object... values) {
  454.         SQLQuery query = currentSession().createSQLQuery(procedureSql);
  455.         if(values != null){
  456.             for (int i = 0; i < values.length; i++) {
  457.                 query.setParameter(i, values[i]);
  458.             }
  459.         }
  460.         int executeUpdate = query.executeUpdate();
  461.         return executeUpdate;
  462.     }
  463.    
  464.     /**
  465.      * 根据 序列 名称跟长度获取唯一编码
  466.      * @param sequenceName
  467.      * @param totalLen
  468.      * @return
  469.      */
  470.     public String getSequence(final String sequenceName, int totalLen) {
  471.                 Integer s = (Integer) getHibernateTemplate().execute(
  472.                                 new HibernateCallback<Object>() {
  473.                                         public Object doInHibernate(Session session)
  474.                                                         throws HibernateException, SQLException {
  475.                                                 SQLQuery query = session.createSQLQuery("select "
  476.                                                                 + sequenceName + ".nextval from dual");
  477.                                                 return new Integer(query.list().get(0).toString());
  478.                                         }
  479.                                 });
  480.  
  481.                 return StringHelper.lpad("" + s, totalLen, '0');
  482.         }
  483.    
  484.     @Cacheable(cacheName="system")
  485.         public String getTableName(Class<?> clazz) {
  486.                 AbstractEntityPersister meta = (AbstractEntityPersister) this.getSessionFactory().getClassMetadata(clazz);
  487.                 // 实体名称
  488.                 String entityName = meta.getTableName();
  489.                 return entityName;
  490.         }
  491.    
  492.     public Object execute(HibernateCallback<?> hibernateCallback) {
  493.                 return super.getHibernateTemplate().execute(hibernateCallback);
  494.         }
  495. }
  496.  

回复 "工具类（增删改查）"

这儿你可以回复上面这条便签

captcha

贴代码片段 - Code666