J2EE-BaseDaoImpl.java

最新推荐文章于 2021-02-13 09:10:29 发布
最新推荐文章于 2021-02-13 09:10:29 发布
阅读量543 收藏
点赞数
分类专栏： j2ee 文章标签： 基本dao实现
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/maxu12345/article/details/48050249
版权 
import java.io.Serializable;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.List;

import javax.persistence.EntityManager;
import javax.persistence.FlushModeType;
import javax.persistence.LockModeType;
import javax.persistence.PersistenceContext;
import javax.persistence.TypedQuery;
import javax.persistence.criteria.CriteriaBuilder;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Fetch;
import javax.persistence.criteria.From;
import javax.persistence.criteria.Join;
import javax.persistence.criteria.Predicate;
import javax.persistence.criteria.Root;
import javax.persistence.criteria.Selection;

import org.apache.commons.lang.StringUtils;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.Assert;

import Filter;
import Filter.Mold;
import Filter.Operator;
import Order;
import Order.Direction;
import Page;
import Pageable;
import BaseDao;
import OrderEntity;
import DateUtil;

/**
 * Dao - 基类
 */
public abstract class BaseDaoImpl<T, ID extends Serializable> implements BaseDao<T, ID>
{

    /** 实体类类型 */
    private Class<T> entityClass;

    /** 别名数 */
    private static volatile long aliasCount = 0;

    @PersistenceContext
    protected EntityManager entityManager;

    @SuppressWarnings("unchecked")
    public BaseDaoImpl()
    {
        Type type = getClass().getGenericSuperclass();
        Type[] parameterizedType = ((ParameterizedType) type).getActualTypeArguments();
        entityClass = (Class<T>) parameterizedType[0];
    }

    public T find(ID id)
    {
        if (id != null)
        {
            return entityManager.find(entityClass, id);
        }
        return null;
    }

    public T find(ID id, LockModeType lockModeType)
    {
        if (id != null)
        {
            if (lockModeType != null)
            {
                return entityManager.find(entityClass, id, lockModeType);
            }
            else
            {
                return entityManager.find(entityClass, id);
            }
        }
        return null;
    }

    public List<T> findList(Integer first, Integer count, List<Filter> filters, List<Order> orders)
    {
        CriteriaBuilder criteriaBuilder = entityManager.getCriteriaBuilder();
        CriteriaQuery<T> criteriaQuery = criteriaBuilder.createQuery(entityClass);
        criteriaQuery.select(criteriaQuery.from(entityClass));
        return findList(criteriaQuery, first, count, filters, orders);
    }

    public Page<T> findPage(Pageable pageable)
    {
        CriteriaBuilder criteriaBuilder = entityManager.getCriteriaBuilder();
        CriteriaQuery<T> criteriaQuery = criteriaBuilder.createQuery(entityClass);
        criteriaQuery.select(criteriaQuery.from(entityClass));
        return findPage(criteriaQuery, pageable);
    }

    public long count(Filter... filters)
    {
        CriteriaBuilder criteriaBuilder = entityManager.getCriteriaBuilder();
        CriteriaQuery<T> criteriaQuery = criteriaBuilder.createQuery(entityClass);
        criteriaQuery.select(criteriaQuery.from(entityClass));
        return count(criteriaQuery, filters != null ? Arrays.asList(filters) : null);
    }

    public void persist(T entity)
    {
        Assert.notNull(entity);
        entityManager.persist(entity);
    }

    public T merge(T entity)
    {
        Assert.notNull(entity);
        return entityManager.merge(entity);
    }

    public T saveOrUpdate(T entity)
    {
        Assert.notNull(entity);
        return null;// entityManager.save
    }

    public void remove(T entity)
    {
        if (entity != null)
        {
            entityManager.remove(entity);
        }
    }

    public void refresh(T entity)
    {
        if (entity != null)
        {
            entityManager.refresh(entity);
        }
    }

    public void refresh(T entity, LockModeType lockModeType)
    {
        if (entity != null)
        {
            if (lockModeType != null)
            {
                entityManager.refresh(entity, lockModeType);
            }
            else
            {
                entityManager.refresh(entity);
            }
        }
    }

    @SuppressWarnings("unchecked")
    public ID getIdentifier(T entity)
    {
        Assert.notNull(entity);
        return (ID) entityManager.getEntityManagerFactory().getPersistenceUnitUtil().getIdentifier(entity);
    }

    public boolean isManaged(T entity)
    {
        return entityManager.contains(entity);
    }

    public void detach(T entity)
    {
        entityManager.detach(entity);
    }

    public void lock(T entity, LockModeType lockModeType)
    {
        if (entity != null && lockModeType != null)
        {
            entityManager.lock(entity, lockModeType);
        }
    }

    public void clear()
    {
        entityManager.clear();
    }

    public void flush()
    {
        entityManager.flush();
    }

    protected List<T> findList(CriteriaQuery<T> criteriaQuery, Integer first, Integer count, List<Filter> filters,
            List<Order> orders)
    {
        Assert.notNull(criteriaQuery);
        Assert.notNull(criteriaQuery.getSelection());
        Assert.notEmpty(criteriaQuery.getRoots());

        CriteriaBuilder criteriaBuilder = entityManager.getCriteriaBuilder();
        Root<T> root = getRoot(criteriaQuery);
        addRestrictions(criteriaQuery, filters);
        addOrders(criteriaQuery, orders);
        if (criteriaQuery.getOrderList().isEmpty())
        {
            if (OrderEntity.class.isAssignableFrom(entityClass))
            {
                criteriaQuery.orderBy(criteriaBuilder.asc(root.get(OrderEntity.ORDER_PROPERTY_NAME)));
            }
            else
            {
                criteriaQuery.orderBy(criteriaBuilder.desc(root.get(OrderEntity.CREATE_DATE_PROPERTY_NAME)));
            }
        }
        TypedQuery<T> query = entityManager.createQuery(criteriaQuery).setFlushMode(FlushModeType.COMMIT);
        if (first != null)
        {
            query.setFirstResult(first);
        }
        if (count != null)
        {
            query.setMaxResults(count);
        }
        return query.getResultList();
    }

    protected Page<T> findPage(CriteriaQuery<T> criteriaQuery, Pageable pageable)
    {
        Assert.notNull(criteriaQuery);
        Assert.notNull(criteriaQuery.getSelection());
        Assert.notEmpty(criteriaQuery.getRoots());

        if (pageable == null)
        {
            pageable = new Pageable();
        }
        CriteriaBuilder criteriaBuilder = entityManager.getCriteriaBuilder();
        Root<T> root = getRoot(criteriaQuery);
        addRestrictions(criteriaQuery, pageable);
        addOrders(criteriaQuery, pageable);
        if (criteriaQuery.getOrderList().isEmpty())
        {
            if (OrderEntity.class.isAssignableFrom(entityClass))
            {
                criteriaQuery.orderBy(criteriaBuilder.asc(root.get(OrderEntity.ORDER_PROPERTY_NAME)));
            }
            else
            {
                criteriaQuery.orderBy(criteriaBuilder.desc(root.get(OrderEntity.CREATE_DATE_PROPERTY_NAME)));
            }
        }
        long total = count(criteriaQuery, null);
        int totalPages = (int) Math.ceil((double) total / (double) pageable.getPageSize());
        if (totalPages < pageable.getPageNumber())
        {
            pageable.setPageNumber(totalPages);
        }
        TypedQuery<T> query = entityManager.createQuery(criteriaQuery).setFlushMode(FlushModeType.COMMIT);
        query.setFirstResult((pageable.getPageNumber() - 1) * pageable.getPageSize());
        query.setMaxResults(pageable.getPageSize());
        return new Page<T>(query.getResultList(), total, pageable);
    }

    protected Long count(CriteriaQuery<T> criteriaQuery, List<Filter> filters)
    {
        Assert.notNull(criteriaQuery);
        Assert.notNull(criteriaQuery.getSelection());
        Assert.notEmpty(criteriaQuery.getRoots());

        CriteriaBuilder criteriaBuilder = entityManager.getCriteriaBuilder();
        addRestrictions(criteriaQuery, filters);

        CriteriaQuery<Long> countCriteriaQuery = criteriaBuilder.createQuery(Long.class);
        for (Root<?> root : criteriaQuery.getRoots())
        {
            Root<?> dest = countCriteriaQuery.from(root.getJavaType());
            dest.alias(getAlias(root));
            copyJoins(root, dest);
        }

        Root<?> countRoot = getRoot(countCriteriaQuery, criteriaQuery.getResultType());
        countCriteriaQuery.select(criteriaBuilder.count(countRoot));

        if (criteriaQuery.getGroupList() != null)
        {
            countCriteriaQuery.groupBy(criteriaQuery.getGroupList());
        }
        if (criteriaQuery.getGroupRestriction() != null)
        {
            countCriteriaQuery.having(criteriaQuery.getGroupRestriction());
        }
        if (criteriaQuery.getRestriction() != null)
        {
            countCriteriaQuery.where(criteriaQuery.getRestriction());
        }
        return entityManager.createQuery(countCriteriaQuery).setFlushMode(FlushModeType.COMMIT).getSingleResult();
    }

    private synchronized String getAlias(Selection<?> selection)
    {
        if (selection != null)
        {
            String alias = selection.getAlias();
            if (alias == null)
            {
                if (aliasCount >= 1000)
                {
                    aliasCount = 0;
                }
                alias = "preschoolEduGeneratedAlias" + aliasCount++;
                selection.alias(alias);
            }
            return alias;
        }
        return null;
    }

    private Root<T> getRoot(CriteriaQuery<T> criteriaQuery)
    {
        if (criteriaQuery != null)
        {
            return getRoot(criteriaQuery, criteriaQuery.getResultType());
        }
        return null;
    }

    private Root<T> getRoot(CriteriaQuery<?> criteriaQuery, Class<T> clazz)
    {
        if (criteriaQuery != null && criteriaQuery.getRoots() != null && clazz != null)
        {
            for (Root<?> root : criteriaQuery.getRoots())
            {
                if (clazz.equals(root.getJavaType()))
                {
                    return (Root<T>) root.as(clazz);
                }
            }
        }
        return null;
    }

    private void copyJoins(From<?, ?> from, From<?, ?> to)
    {
        for (Join<?, ?> join : from.getJoins())
        {
            Join<?, ?> toJoin = to.join(join.getAttribute().getName(), join.getJoinType());
            toJoin.alias(getAlias(join));
            copyJoins(join, toJoin);
        }
        for (Fetch<?, ?> fetch : from.getFetches())
        {
            Fetch<?, ?> toFetch = to.fetch(fetch.getAttribute().getName());
            copyFetches(fetch, toFetch);
        }
    }

    private void copyFetches(Fetch<?, ?> from, Fetch<?, ?> to)
    {
        for (Fetch<?, ?> fetch : from.getFetches())
        {
            Fetch<?, ?> toFetch = to.fetch(fetch.getAttribute().getName());
            copyFetches(fetch, toFetch);
        }
    }

    private void addRestrictions(CriteriaQuery<T> criteriaQuery, List<Filter> filters)
    {
        if (criteriaQuery == null || filters == null || filters.isEmpty())
        {
            return;
        }
        Root<T> root = getRoot(criteriaQuery);
        if (root == null)
        {
            return;
        }
        CriteriaBuilder criteriaBuilder = entityManager.getCriteriaBuilder();

        Predicate restrictions = criteriaQuery.getRestriction() != null ? criteriaQuery.getRestriction()
                : criteriaBuilder.conjunction();
        for (Filter filter : filters)
        {
            if (filter == null || StringUtils.isEmpty(filter.getProperty()))
            {
                continue;
            }

            /** 针对时间类型 */
            if (filter.getMold() == Mold.dl || filter.getMold() == Mold.dg)
            {
                if (filter.getOperator() == Operator.lt && filter.getValue() != null)
                {
                    restrictions = criteriaBuilder.and(
                            restrictions,
                            criteriaBuilder.lessThan(root.<Date> get(filter.getProperty()),
                                    DateUtil.parseDate(filter.getValue().toString())));
                }
                else if (filter.getOperator() == Operator.gt && filter.getValue() != null)
                {
                    restrictions = criteriaBuilder.and(
                            restrictions,
                            criteriaBuilder.greaterThan(root.<Date> get(filter.getProperty()),
                                    DateUtil.parseDate(filter.getValue().toString())));
                }
                else if (filter.getOperator() == Operator.le && filter.getValue() != null)
                {
                    restrictions = criteriaBuilder.and(
                            restrictions,
                            criteriaBuilder.lessThanOrEqualTo(root.<Date> get(filter.getProperty()),
                                    DateUtil.parseDate(filter.getValue().toString())));
                }
                else if (filter.getOperator() == Operator.ge && filter.getValue() != null)
                {
                    restrictions = criteriaBuilder.and(
                            restrictions,
                            criteriaBuilder.greaterThanOrEqualTo(root.<Date> get(filter.getProperty()),
                                    DateUtil.parseDate(filter.getValue().toString())));
                }

            }
            else
            {

                if (filter.getOperator() == Operator.eq && filter.getValue() != null)
                {
                    if (filter.getIgnoreCase() != null && filter.getIgnoreCase() && filter.getValue() instanceof String)
                    {
                        restrictions = criteriaBuilder.and(restrictions, criteriaBuilder.equal(
                                criteriaBuilder.lower(root.<String> get(filter.getProperty())),
                                ((String) filter.getValue()).toLowerCase()));
                    }
                    else
                    {
                        restrictions = criteriaBuilder.and(restrictions,
                                criteriaBuilder.equal(root.get(filter.getProperty()), filter.getValue()));
                    }
                }
                else if (filter.getOperator() == Operator.ne && filter.getValue() != null)
                {
                    if (filter.getIgnoreCase() != null && filter.getIgnoreCase() && filter.getValue() instanceof String)
                    {
                        restrictions = criteriaBuilder.and(restrictions, criteriaBuilder.notEqual(
                                criteriaBuilder.lower(root.<String> get(filter.getProperty())),
                                ((String) filter.getValue()).toLowerCase()));
                    }
                    else
                    {
                        restrictions = criteriaBuilder.and(restrictions,
                                criteriaBuilder.notEqual(root.get(filter.getProperty()), filter.getValue()));
                    }
                }
                else if (filter.getOperator() == Operator.gt && filter.getValue() != null)
                {
                    restrictions = criteriaBuilder.and(restrictions,
                            criteriaBuilder.gt(root.<Number> get(filter.getProperty()), (Number) filter.getValue()));

                }
                else if (filter.getOperator() == Operator.lt && filter.getValue() != null)
                {
                    restrictions = criteriaBuilder.and(restrictions,
                            criteriaBuilder.lt(root.<Number> get(filter.getProperty()), (Number) filter.getValue()));
                }
                else if (filter.getOperator() == Operator.ge && filter.getValue() != null)
                {
                    restrictions = criteriaBuilder.and(restrictions,
                            criteriaBuilder.ge(root.<Number> get(filter.getProperty()), (Number) filter.getValue()));
                }
                else if (filter.getOperator() == Operator.le && filter.getValue() != null)
                {
                    restrictions = criteriaBuilder.and(restrictions,
                            criteriaBuilder.le(root.<Number> get(filter.getProperty()), (Number) filter.getValue()));
                }
                else if (filter.getOperator() == Operator.like && filter.getValue() != null
                        && filter.getValue() instanceof String)
                {
                    restrictions = criteriaBuilder.and(restrictions,
                            criteriaBuilder.like(root.<String> get(filter.getProperty()), (String) filter.getValue()));
                }
                else if (filter.getOperator() == Operator.in && filter.getValue() != null)
                {
                    restrictions = criteriaBuilder.and(restrictions,
                            root.get(filter.getProperty()).in(filter.getValue()));
                }
                else if (filter.getOperator() == Operator.isNull)
                {
                    restrictions = criteriaBuilder.and(restrictions, root.get(filter.getProperty()).isNull());
                }
                else if (filter.getOperator() == Operator.isNotNull)
                {
                    restrictions = criteriaBuilder.and(restrictions, root.get(filter.getProperty()).isNotNull());
                }
            }
        }
        criteriaQuery.where(restrictions);
    }

    private void addRestrictions(CriteriaQuery<T> criteriaQuery, Pageable pageable)
    {
        if (criteriaQuery == null || pageable == null)
        {
            return;
        }
        Root<T> root = getRoot(criteriaQuery);
        if (root == null)
        {
            return;
        }
        CriteriaBuilder criteriaBuilder = entityManager.getCriteriaBuilder();
        Predicate restrictions = criteriaQuery.getRestriction() != null ? criteriaQuery.getRestriction()
                : criteriaBuilder.conjunction();
        if (StringUtils.isNotEmpty(pageable.getSearchProperty()) && StringUtils.isNotEmpty(pageable.getSearchValue()))
        {
            restrictions = criteriaBuilder.and(
                    restrictions,
                    criteriaBuilder.like(root.<String> get(pageable.getSearchProperty()),
                            "%" + pageable.getSearchValue() + "%"));
        }
        if (pageable.getFilters() != null)
        {
            for (Filter filter : pageable.getFilters())
            {
                if (filter == null || StringUtils.isEmpty(filter.getProperty()))
                {
                    continue;
                }
                /** 针对时间类型 */
                if (filter.getMold() == Mold.dl || filter.getMold() == Mold.dg)
                {
                    if (filter.getOperator() == Operator.lt && filter.getValue() != null)
                    {
                        restrictions = criteriaBuilder.and(
                                restrictions,
                                criteriaBuilder.lessThan(root.<Date> get(filter.getProperty()),
                                        DateUtil.parseDate(filter.getValue().toString())));
                    }
                    else if (filter.getOperator() == Operator.gt && filter.getValue() != null)
                    {
                        restrictions = criteriaBuilder.and(
                                restrictions,
                                criteriaBuilder.greaterThan(root.<Date> get(filter.getProperty()),
                                        DateUtil.parseDate(filter.getValue().toString())));
                    }
                    else if (filter.getOperator() == Operator.le && filter.getValue() != null)
                    {
                        restrictions = criteriaBuilder.and(
                                restrictions,
                                criteriaBuilder.lessThanOrEqualTo(root.<Date> get(filter.getProperty()),
                                        DateUtil.parseDate(filter.getValue().toString())));
                    }
                    else if (filter.getOperator() == Operator.ge && filter.getValue() != null)
                    {
                        restrictions = criteriaBuilder.and(
                                restrictions,
                                criteriaBuilder.greaterThanOrEqualTo(root.<Date> get(filter.getProperty()),
                                        DateUtil.parseDate(filter.getValue().toString())));
                    }
                }
                else
                {

                    if (filter.getOperator() == Operator.eq && filter.getValue() != null)
                    {
                        if (filter.getIgnoreCase() != null && filter.getIgnoreCase()
                                && filter.getValue() instanceof String)
                        {
                            restrictions = criteriaBuilder.and(restrictions, criteriaBuilder.equal(
                                    criteriaBuilder.lower(root.<String> get(filter.getProperty())),
                                    ((String) filter.getValue()).toLowerCase()));
                        }
                        else
                        {
                            restrictions = criteriaBuilder.and(restrictions,
                                    criteriaBuilder.equal(root.get(filter.getProperty()), filter.getValue()));
                        }
                    }
                    else if (filter.getOperator() == Operator.ne && filter.getValue() != null)
                    {
                        if (filter.getIgnoreCase() != null && filter.getIgnoreCase()
                                && filter.getValue() instanceof String)
                        {
                            restrictions = criteriaBuilder.and(restrictions, criteriaBuilder.notEqual(
                                    criteriaBuilder.lower(root.<String> get(filter.getProperty())),
                                    ((String) filter.getValue()).toLowerCase()));
                        }
                        else
                        {
                            restrictions = criteriaBuilder.and(restrictions,
                                    criteriaBuilder.notEqual(root.get(filter.getProperty()), filter.getValue()));
                        }
                    }
                    else if (filter.getOperator() == Operator.gt && filter.getValue() != null)
                    {
                        restrictions = criteriaBuilder.and(restrictions,
                                criteriaBuilder.gt(root.<Number> get(filter.getProperty()), (Number) filter.getValue()));
                    }
                    else if (filter.getOperator() == Operator.lt && filter.getValue() != null)
                    {
                        restrictions = criteriaBuilder.and(restrictions,
                                criteriaBuilder.lt(root.<Number> get(filter.getProperty()), (Number) filter.getValue()));
                    }
                    else if (filter.getOperator() == Operator.ge && filter.getValue() != null)
                    {
                        restrictions = criteriaBuilder.and(restrictions,
                                criteriaBuilder.ge(root.<Number> get(filter.getProperty()), (Number) filter.getValue()));
                    }
                    else if (filter.getOperator() == Operator.le && filter.getValue() != null)
                    {
                        restrictions = criteriaBuilder.and(restrictions,
                                criteriaBuilder.le(root.<Number> get(filter.getProperty()), (Number) filter.getValue()));
                    }
                    else if (filter.getOperator() == Operator.like && filter.getValue() != null
                            && filter.getValue() instanceof String)
                    {
                        restrictions = criteriaBuilder.and(
                                restrictions,
                                criteriaBuilder.like(root.<String> get(filter.getProperty()),
                                        (String) filter.getValue()));
                    }
                    else if (filter.getOperator() == Operator.in && filter.getValue() != null)
                    {
                        restrictions = criteriaBuilder.and(restrictions,
                                root.get(filter.getProperty()).in(filter.getValue()));
                    }
                    else if (filter.getOperator() == Operator.isNull)
                    {
                        restrictions = criteriaBuilder.and(restrictions, root.get(filter.getProperty()).isNull());
                    }
                    else if (filter.getOperator() == Operator.isNotNull)
                    {
                        restrictions = criteriaBuilder.and(restrictions, root.get(filter.getProperty()).isNotNull());
                    }
                }
            }
        }
        criteriaQuery.where(restrictions);
    }

    private void addOrders(CriteriaQuery<T> criteriaQuery, List<Order> orders)
    {
        if (criteriaQuery == null || orders == null || orders.isEmpty())
        {
            return;
        }
        Root<T> root = getRoot(criteriaQuery);
        if (root == null)
        {
            return;
        }
        CriteriaBuilder criteriaBuilder = entityManager.getCriteriaBuilder();
        List<javax.persistence.criteria.Order> orderList = new ArrayList<javax.persistence.criteria.Order>();
        if (!criteriaQuery.getOrderList().isEmpty())
        {
            orderList.addAll(criteriaQuery.getOrderList());
        }
        for (Order order : orders)
        {
            if (order.getDirection() == Direction.asc)
            {
                orderList.add(criteriaBuilder.asc(root.get(order.getProperty())));
            }
            else if (order.getDirection() == Direction.desc)
            {
                orderList.add(criteriaBuilder.desc(root.get(order.getProperty())));
            }
        }
        criteriaQuery.orderBy(orderList);
    }

    private void addOrders(CriteriaQuery<T> criteriaQuery, Pageable pageable)
    {
        if (criteriaQuery == null || pageable == null)
        {
            return;
        }
        Root<T> root = getRoot(criteriaQuery);
        if (root == null)
        {
            return;
        }
        CriteriaBuilder criteriaBuilder = entityManager.getCriteriaBuilder();
        List<javax.persistence.criteria.Order> orderList = new ArrayList<javax.persistence.criteria.Order>();
        if (!criteriaQuery.getOrderList().isEmpty())
        {
            orderList.addAll(criteriaQuery.getOrderList());
        }
        if (StringUtils.isNotEmpty(pageable.getOrderProperty()) && pageable.getOrderDirection() != null)
        {
            if (pageable.getOrderDirection() == Direction.asc)
            {
                orderList.add(criteriaBuilder.asc(root.get(pageable.getOrderProperty())));
            }
            else if (pageable.getOrderDirection() == Direction.desc)
            {
                orderList.add(criteriaBuilder.desc(root.get(pageable.getOrderProperty())));
            }
        }
        if (pageable.getOrders() != null)
        {
            for (Order order : pageable.getOrders())
            {
                if (order.getDirection() == Direction.asc)
                {
                    orderList.add(criteriaBuilder.asc(root.get(order.getProperty())));
                }
                else if (order.getDirection() == Direction.desc)
                {
                    orderList.add(criteriaBuilder.desc(root.get(order.getProperty())));
                }
            }
        }
        criteriaQuery.orderBy(orderList);
    }

    /**
     * 批量更新
     * 
     * @param list
     */
    @Transactional
    public void batchUpdate(List<T> list)
    {
        for (int i = 0, len = list.size(); i < len; i++)
        {
            entityManager.merge(list.get(i));
            if (i % 30 == 0)
            {
                entityManager.flush();
                entityManager.clear();
            }
        }
    }

}

melody-
关注
专栏目录
java basedaoimpl_java web项目DAO层通用接口BaseDao与实现类BaseDaoImpl
weixin_42542669的博客
02-13 385
在spring+hibernate的web项目中，处理数据层通常会使用Spring框架提供的HibernateTemplate类提供的方法。通常的用法是每一个实体类对应的去写DAO层的接口和实现类。每个实现类中都写hibernateTemp.save(entity)、hibernateTemp.update(entity)、hibernateTemp.get(id)...这样写固然没错，但存在着大...
Spring和Tomcat版本兼容问题
weixin_42500287的博客
04-02 3057
org.springframework.beans.factory.BeanCreationException: Error creating java.lang.ClassNotFoundException: Illegal access: this web application instance has been stopped already. java.lang.IllegalStateException: Illegal access: this web application instanc
java basedaoimpl_java实现人脸识别源码【含测试效果图】——DaoImpl层（BaseDaoUtilImpl）...
weixin_29359001的博客
02-13 88
/****/package org.dao.impl;import java.sql.ResultSet;import java.sql.SQLException;import java.util.ArrayList;import java.util.List;import org.dao.BaseDao;import org.entity.Users;import org.junit.Test;...
SSH整合的BaseDaoImpl.java
RichardGeek的博客
04-10 254
import java.io.Serializable; import java.lang.reflect.ParameterizedType; import java.lang.reflect.Type; import java.util.List; import org.hibernate.criterion.DetachedCriteria; import org.hibernate.c
J2EE-BaseDao.java
马旭的专栏
08-28 719
import java.io.Serializable; import java.util.List; import javax.persistence.LockModeType; import Filter; import Order; import Page; import Pageable; /** * Dao - 基类 * * @author Sencloud Team *
BaseDaoImpl
Dong
06-25 418
package com.base;import java.lang.reflect.Field; import java.lang.reflect.Method; import java.lang.reflect.ParameterizedType; import java.sql.Connection; import java.sql.PreparedStatement; import
BaseDAOImpl.java
07-08
java数据库基础操作类,hibernate框架基础
baseDaoUtil1.2-jar.zip
12-17
在使用这个jar包时，只需要在项目的类路径中引入它，并且在Dao层的实现类中继承提供的`BaseDaoImpl`，就可以便捷地进行数据的增删改查等操作，从而减少重复的代码编写。 首先，"baseDaoUtil" 是这个库的名称，它...
android持久化 ormlite-android-4.31.jar
12-14
- **定义DAO接口**：创建一个接口，继承自`BaseDaoImpl, ID>`，其中T代表实体类，ID代表主键类型。 - **创建数据库帮助器**：创建一个继承自`OrmLiteSqliteOpenHelper`的类，重写`onCreate()`和`onUpgrade()`方法...
java web项目基础步骤.docx
05-09
Java Web项目开发的基础步骤涉及多个环节，包括数据库连接、配置文件设置、模型对象定义、数据访问接口设计、抽象类实现以及前端页面创建等。以下是对这些步骤的详细说明： 1. **连接数据库**： 在Java Web项目中...
java basedao t_Java 最通用的BaseDao 和BaseDaoImpl
weixin_39791386的博客
02-13 187
1.BaseDao.javapackagecom.util;importjava.sql.Connection;importjava.sql.SQLException;importjava.util.*;importjava.io.Serializable;/**统一数据访问接口*/publicinterfaceBaseDAO{/**加载指定ID的持久化对象*/public...
java dao通用方法
xianrenyibu的专栏
08-28 496
public abstract class BaseDaoImpl implements BaseDao { /** 实体类类型 */ private Class entityClass; /** 别名数 */ private static volatile long aliasCount = 0; @PersistenceContext protected E
java servlet异常：weblogic.j2ee.dd.xml.AnnotationProcessException
java小记转一转（基础）
01-08 824
原因：就是因为web.xml的请求头部和要求的不一样，版本不匹配导致 如果是报错javaee.dd.xml,可以搜一个javaee的请求头，此处需要j2ee的，故改为上图所示： <?xml version="1.0" encoding="UTF-8"?> <web-app xmlns="http://java.sun.com/xml/ns/j2ee" ...
关于BaseDaoImpl的简单示例
jeas_rt 的博客
03-28 1987
示例：实现basedao package com.cn.base.dao.impl; import java.lang.reflect.ParameterizedType; import java.lang.reflect.Type; import java.util.ArrayList; import java.util.List; import org.apache.com
BaseDao即BaseDaoImpl的具体代码
qq_41009846的博客
09-26 1508
BaseDao package cn.crm.dao; import java.io.Serializable; import java.util.List; import org.hibernate.criterion.DetachedCriteria; /** * @author Administrator * 实现dao的功能的结构 这里我们需要dao.interface来实现我...
三层架构model与DAOImpl实现
javaproducts的专栏
11-15 1290
<br />今天写程序，老是出现“查询客户信息失败”，表名 is not mapping。很奇怪以前没出错，今天怎么错了！看来是数据库表名的原因，于是回头查找名字，这时才发现，DAOImpl中的查找方法<br />finds（）{<br /> String str="from system_setting";  //system_setting是数据库中的表名<br />……<br />}<br />而model层中的model和映射分别是：<br />model名字：SystemOption.java  
基于MNIST数据集的分类器设计_MNIST_Classifier.zip
10-01
基于MNIST数据集的分类器设计_MNIST_Classifier
基于springboot项目,集成常用第三方整合的一个框架,包含通用mapper实现百分之
最新发布
10-01
基于springboot项目,集成常用第三方整合的一个框架,包含通用mapper实现百分之八九十的s_myspringboot
分析dao包中各java文件的用途
06-11
- `BaseDaoImpl.java`：实现了 `BaseDao` 接口，提供了一组默认的 CRUD 操作和查询方法的实现。 - `UserDao.java`：定义了用户数据访问接口，包含了用户信息的增删改查等操作方法。 - `UserDaoImpl.java`：实现了 `...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值