在 Spring Data Jpa 中使用逻辑删除需做的工作

最新推荐文章于 2025-06-12 11:01:10 发布

gavid0124

最新推荐文章于 2025-06-12 11:01:10 发布

阅读量5.4k

点赞数

分类专栏： java技术

java技术专栏收录该内容

47 篇文章

订阅专栏

本文介绍如何在SpringData中实现逻辑删除，通过自定义SimpleJpaRepository以适应逻辑删除的需求，并调整了findByXXX方法以确保查询时能过滤掉已逻辑删除的数据。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Spring Data 是个好东西，极大简化了后端dao的操作，只需要在 dao 接口写个 findByXXX 的方法就能自动实现按条件查询这个简直太爽了。

不过问题也出现了，我的应用对于数据的操作没有物理删除，全是逻辑删除，也就是每个表都有个字段 deleted，1表示此记录已删除，默认值为 0 。这就与 spring data 提供的模式有冲突了，那剩下的就是：改之。

CRUD 操作

对于基础的CRUD 操作搞起来比较简单，按照其官方文档重新实现个 factory-class 就ok了，具体的 repository 类可以继承 org.springframework.data.jpa.repository.support.SimpleJpaRepository 进行修改，不过我为了省事，直接把这个类复制过来然后下手：

Java代码  

/* 

 * $Id$ 

 */  

package com.someok.common.base.spring.data;  

import static org.springframework.data.jpa.repository.query.QueryUtils.DELETE_ALL_QUERY_STRING;  

import static org.springframework.data.jpa.repository.query.QueryUtils.applyAndBind;  

import static org.springframework.data.jpa.repository.query.QueryUtils.getQueryString;  

import static org.springframework.data.jpa.repository.query.QueryUtils.toOrders;  

import java.io.Serializable;  

import java.util.ArrayList;  

import java.util.Collections;  

import java.util.List;  

import javax.persistence.EntityManager;  

import javax.persistence.LockModeType;  

import javax.persistence.NoResultException;  

import javax.persistence.TypedQuery;  

import javax.persistence.criteria.CriteriaBuilder;  

import javax.persistence.criteria.CriteriaQuery;  

import javax.persistence.criteria.Path;  

import javax.persistence.criteria.Predicate;  

import javax.persistence.criteria.Root;  

import org.springframework.dao.EmptyResultDataAccessException;  

import org.springframework.data.domain.Page;  

import org.springframework.data.domain.PageImpl;  

import org.springframework.data.domain.Pageable;  

import org.springframework.data.domain.Sort;  

import org.springframework.data.jpa.domain.Specification;  

import org.springframework.data.jpa.repository.support.JpaEntityInformation;  

import org.springframework.data.jpa.repository.support.JpaEntityInformationSupport;  

import org.springframework.data.jpa.repository.support.LockMetadataProvider;  

import org.springframework.data.jpa.repository.support.SimpleJpaRepository;  

import org.springframework.transaction.annotation.Transactional;  

import org.springframework.util.Assert;  

import com.someok.common.base.mvc.BaseDao;  

import com.someok.common.base.mvc.BaseDefaultModel;  

import com.someok.common.utils.StringUtil;  

/** 

 * 修改自 

 * {@link org.springframework.data.jpa.repository.support.SimpleJpaRepository}, 

 * 提供逻辑删除功能（logicDelete），为适应这个要求，相关的查询也都做了修改。 

 *  

 * 需要注意的是那些 delete 方法仍然是物理删除，而新增的那些 logic 开头的方法才是逻辑删除， 用时候需要注意这点. 

 *  

 * @author wangjxe 

 *  

 */  

@org.springframework.stereotype.Repository  

@Transactional(readOnly = true)  

public class CustomSimpleJpaRepository<T, ID extends Serializable> implements  

        BaseDao<T, ID> {  

    /** 

     * 逻辑删除字段名. 

     */  

    public final static String DELETEED_FIELD = "deleted";  

    public static final String COUNT_QUERY_STRING = "select count(%s) from %s x where x.deleted = false";  

    public static final String EXISTS_QUERY_STRING = "select count(%s) from %s x where x.%s = :id and x.deleted = false";  

    private final JpaEntityInformation<T, ?> entityInformation;  

    private final EntityManager em;  

    // private final PersistenceProvider provider;  

    private LockMetadataProvider lockMetadataProvider;  

    /** 

     * Creates a new {@link SimpleJpaRepository} to manage objects of the given 

     * {@link JpaEntityInformation}. 

     *  

     * @param entityInformation 

     *            must not be {@literal null}. 

     * @param entityManager 

     *            must not be {@literal null}. 

     */  

    public CustomSimpleJpaRepository(  

            JpaEntityInformation<T, ?> entityInformation,  

            EntityManager entityManager) {  

        Assert.notNull(entityInformation);  

        Assert.notNull(entityManager);  

        this.entityInformation = entityInformation;  

        this.em = entityManager;  

        // this.provider = PersistenceProvider.fromEntityManager(entityManager);  

    }  

    /** 

     * Creates a new {@link SimpleJpaRepository} to manage objects of the given 

     * domain type. 

     *  

     * @param domainClass 

     *            must not be {@literal null}. 

     * @param em 

     *            must not be {@literal null}. 

     */  

    public CustomSimpleJpaRepository(Class<T> domainClass, EntityManager em) {  

        this(JpaEntityInformationSupport.getMetadata(domainClass, em), em);  

    }  

    /** 

     * Configures a custom {@link LockMetadataProvider} to be used to detect 

     * {@link LockModeType}s to be applied to queries. 

     *  

     * @param lockMetadataProvider 

     */  

    public void setLockMetadataProvider(  

            LockMetadataProvider lockMetadataProvider) {  

        this.lockMetadataProvider = lockMetadataProvider;  

    }  

    private Class<T> getDomainClass() {  

        return entityInformation.getJavaType();  

    }  

    private String getDeleteAllQueryString() {  

        return getQueryString(DELETE_ALL_QUERY_STRING,  

                entityInformation.getEntityName());  

    }  

    private String getCountQueryString() {  

        String countQuery = String.format(COUNT_QUERY_STRING,  

                getCountQueryPlaceholder(), "%s");  

        return getQueryString(countQuery, entityInformation.getEntityName());  

    }  

    /* 

     * (non-Javadoc) 

     *  

     * @see org.springframework.data.repository.CrudRepository#delete(java.io. 

     * Serializable) 

     */  

    @Transactional  

    public void delete(ID id) {  

        Assert.notNull(id, "The given id must not be null!");  

        if (!exists(id)) {  

            throw new EmptyResultDataAccessException(String.format(  

                    "No %s entity with id %s exists!",  

                    entityInformation.getJavaType(), id), 1);  

        }  

        delete(findOne(id));  

    }  

    /* 

     * (non-Javadoc) 

     *  

     * @see 

     * org.springframework.data.repository.CrudRepository#delete(java.lang.Object 

     * ) 

     */  

    @Transactional  

    public void delete(T entity) {  

        Assert.notNull(entity, "The entity must not be null!");  

        em.remove(em.contains(entity) ? entity : em.merge(entity));  

    }  

    /* 

     * (non-Javadoc) 

     *  

     * @see 

     * org.springframework.data.repository.CrudRepository#delete(java.lang.Iterable 

     * ) 

     */  

    @Transactional  

    public void delete(Iterable<? extends T> entities) {  

        Assert.notNull(entities, "The given Iterable of entities not be null!");  

        for (T entity : entities) {  

            delete(entity);  

        }  

    }  

    /* 

     * (non-Javadoc) 

     *  

     * @see 

     * org.springframework.data.jpa.repository.JpaRepository#deleteInBatch(java 

     * .lang.Iterable) 

     */  

    @Transactional  

    public void deleteInBatch(Iterable<T> entities) {  

        Assert.notNull(entities, "The given Iterable of entities not be null!");  

        if (!entities.iterator().hasNext()) {  

            return;  

        }  

        applyAndBind(  

                getQueryString(DELETE_ALL_QUERY_STRING,  

                        entityInformation.getEntityName()), entities, em)  

                .executeUpdate();  

    }  

    /* 

     * (non-Javadoc) 

     *  

     * @see org.springframework.data.repository.Repository#deleteAll() 

     */  

    @Transactional  

    public void deleteAll() {  

        for (T element : findAll()) {  

            delete(element);  

        }  

    }  

    /* 

     * (non-Javadoc) 

     *  

     * @see 

     * org.springframework.data.jpa.repository.JpaRepository#deleteAllInBatch() 

     */  

    @Transactional  

    public void deleteAllInBatch() {  

        em.createQuery(getDeleteAllQueryString()).executeUpdate();  

    }  

    /* 

     * (non-Javadoc) 

     *  

     * @see 

     * org.springframework.data.repository.Repository#readById(java.io.Serializable 

     * ) 

     */  

    public T findOne(ID id) {  

        Assert.notNull(id, "The given id must not be null!");  

        return em.find(getDomainClass(), id);  

    }  

    /* 

     * (non-Javadoc) 

     *  

     * @see org.springframework.data.repository.CrudRepository#exists(java.io. 

     * Serializable) 

     */  

    public boolean exists(ID id) {  

        Assert.notNull(id, "The given id must not be null!");  

        if (entityInformation.getIdAttribute() != null) {  

            String placeholder = getCountQueryPlaceholder();  

            String entityName = entityInformation.getEntityName();  

            String idAttributeName = entityInformation.getIdAttribute()  

                    .getName();  

            String existsQuery = String.format(EXISTS_QUERY_STRING,  

                    placeholder, entityName, idAttributeName);  

            TypedQuery<Long> query = em.createQuery(existsQuery, Long.class);  

            query.setParameter("id", id);  

            return query.getSingleResult() == 1;  

        } else {  

            return findOne(id) != null;  

        }  

    }  

    /* 

     * (non-Javadoc) 

     *  

     * @see org.springframework.data.jpa.repository.JpaRepository#findAll() 

     */  

    public List<T> findAll() {  

        return getQuery(null, (Sort) null).getResultList();  

    }  

    /* 

     * (non-Javadoc) 

     *  

     * @see org.springframework.data.repository.CrudRepository#findAll(ID[]) 

     */  

    public List<T> findAll(Iterable<ID> ids) {  

        return getQuery(new Specification<T>() {  

            public Predicate toPredicate(Root<T> root, CriteriaQuery<?> query,  

                    CriteriaBuilder cb) {  

                Path<?> path = root.get(entityInformation.getIdAttribute());  

                return path.in(cb.parameter(List.class, "ids"));  

            }  

        }, (Sort) null).setParameter("ids", ids).getResultList();  

    }  

    /* 

     * (non-Javadoc) 

     *  

     * @see org.springframework.data.jpa.repository.JpaRepository#findAll(org. 

     * springframework.data.domain.Sort) 

     */  

    public List<T> findAll(Sort sort) {  

        return getQuery(null, sort).getResultList();  

    }  

    /* 

     * (non-Javadoc) 

     *  

     * @see 

     * org.springframework.data.repository.PagingAndSortingRepository#findAll 

     * (org.springframework.data.domain.Pageable) 

     */  

    public Page<T> findAll(Pageable pageable) {  

        if (null == pageable) {  

            return new PageImpl<T>(findAll());  

        }  

        return findAll(null, pageable);  

    }  

    /* 

     * (non-Javadoc) 

     *  

     * @see 

     * org.springframework.data.jpa.repository.JpaSpecificationExecutor#findOne 

     * (org.springframework.data.jpa.domain.Specification) 

     */  

    public T findOne(Specification<T> spec) {  

        try {  

            return getQuery(spec, (Sort) null).getSingleResult();  

        } catch (NoResultException e) {  

            return null;  

        }  

    }  

    /* 

     * (non-Javadoc) 

     *  

     * @see 

     * org.springframework.data.jpa.repository.JpaSpecificationExecutor#findAll 

     * (org.springframework.data.jpa.domain.Specification) 

     */  

    public List<T> findAll(Specification<T> spec) {  

        return getQuery(spec, (Sort) null).getResultList();  

    }  

    /* 

     * (non-Javadoc) 

     *  

     * @see 

     * org.springframework.data.jpa.repository.JpaSpecificationExecutor#findAll 

     * (org.springframework.data.jpa.domain.Specification, 

     * org.springframework.data.domain.Pageable) 

     */  

    public Page<T> findAll(Specification<T> spec, Pageable pageable) {  

        TypedQuery<T> query = getQuery(spec, pageable);  

        return pageable == null ? new PageImpl<T>(query.getResultList())  

                : readPage(query, pageable, spec);  

    }  

    /* 

     * (non-Javadoc) 

     *  

     * @see 

     * org.springframework.data.jpa.repository.JpaSpecificationExecutor#findAll 

     * (org.springframework.data.jpa.domain.Specification, 

     * org.springframework.data.domain.Sort) 

     */  

    public List<T> findAll(Specification<T> spec, Sort sort) {  

        return getQuery(spec, sort).getResultList();  

    }  

    /* 

     * (non-Javadoc) 

     *  

     * @see org.springframework.data.repository.CrudRepository#count() 

     */  

    public long count() {  

        return em.createQuery(getCountQueryString(), Long.class)  

                .getSingleResult();  

    }  

    /* 

     * (non-Javadoc) 

     *  

     * @see 

     * org.springframework.data.jpa.repository.JpaSpecificationExecutor#count 

     * (org.springframework.data.jpa.domain.Specification) 

     */  

    public long count(Specification<T> spec) {  

        return getCountQuery(spec).getSingleResult();  

    }  

    /* 

     * (non-Javadoc) 

     *  

     * @see 

     * org.springframework.data.repository.CrudRepository#save(java.lang.Object) 

     */  

    @Transactional  

    public <S extends T> S save(S entity) {  

        if (entityInformation.isNew(entity)) {  

            em.persist(entity);  

            return entity;  

        } else {  

            return em.merge(entity);  

        }  

    }  

    /* 

     * (non-Javadoc) 

     *  

     * @see 

     * org.springframework.data.jpa.repository.JpaRepository#saveAndFlush(java 

     * .lang.Object) 

     */  

    @Transactional  

    public T saveAndFlush(T entity) {  

        T result = save(entity);  

        flush();  

        return result;  

    }  

    /* 

     * (non-Javadoc) 

     *  

     * @see 

     * org.springframework.data.jpa.repository.JpaRepository#save(java.lang. 

     * Iterable) 

     */  

    @Transactional  

    public <S extends T> List<S> save(Iterable<S> entities) {  

        List<S> result = new ArrayList<S>();  

        if (entities == null) {  

            return result;  

        }  

        for (S entity : entities) {  

            result.add(save(entity));  

        }  

        return result;  

    }  

    /* 

     * (non-Javadoc) 

     *  

     * @see org.springframework.data.jpa.repository.JpaRepository#flush() 

     */  

    @Transactional  

    public void flush() {  

        em.flush();  

    }  

    /** 

     * Reads the given {@link TypedQuery} into a {@link Page} applying the given 

     * {@link Pageable} and {@link Specification}. 

     *  

     * @param query 

     *            must not be {@literal null}. 

     * @param spec 

     *            can be {@literal null}. 

     * @param pageable 

     *            can be {@literal null}. 

     * @return 

     */  

    private Page<T> readPage(TypedQuery<T> query, Pageable pageable,  

            Specification<T> spec) {  

        query.setFirstResult(pageable.getOffset());  

        query.setMaxResults(pageable.getPageSize());  

        Long total = getCountQuery(spec).getSingleResult();  

        List<T> content = total > pageable.getOffset() ? query.getResultList()  

                : Collections.<T> emptyList();  

        return new PageImpl<T>(content, pageable, total);  

    }  

    /** 

     * Creates a new {@link TypedQuery} from the given {@link Specification}. 

     *  

     * @param spec 

     *            can be {@literal null}. 

     * @param pageable 

     *            can be {@literal null}. 

     * @return 

     */  

    private TypedQuery<T> getQuery(Specification<T> spec, Pageable pageable) {  

        Sort sort = pageable == null ? null : pageable.getSort();  

        return getQuery(spec, sort);  

    }  

    /** 

     * Creates a {@link TypedQuery} for the given {@link Specification} and 

     * {@link Sort}. 

     *  

     * @param spec 

     *            can be {@literal null}. 

     * @param sort 

     *            can be {@literal null}. 

     * @return 

     */  

    private TypedQuery<T> getQuery(Specification<T> spec, Sort sort) {  

        CriteriaBuilder builder = em.getCriteriaBuilder();  

        CriteriaQuery<T> query = builder.createQuery(getDomainClass());  

        Root<T> root = applySpecificationToCriteria(spec, query);  

        query.select(root);  

        if (sort != null) {  

            query.orderBy(toOrders(sort, root, builder));  

        }  

        return applyLockMode(em.createQuery(query));  

    }  

    /** 

     * Creates a new count query for the given {@link Specification}. 

     *  

     * @param spec 

     *            can be {@literal null}. 

     * @return 

     */  

    private TypedQuery<Long> getCountQuery(Specification<T> spec) {  

        CriteriaBuilder builder = em.getCriteriaBuilder();  

        CriteriaQuery<Long> query = builder.createQuery(Long.class);  

        Root<T> root = applySpecificationToCriteria(spec, query);  

        query.select(builder.count(root));  

        return em.createQuery(query);  

    }  

    /** 

     * Applies the given {@link Specification} to the given 

     * {@link CriteriaQuery}. 

     *  

     * @param spec 

     *            can be {@literal null}. 

     * @param query 

     *            must not be {@literal null}. 

     * @return 

     */  

    private <S> Root<T> applySpecificationToCriteria(Specification<T> spec,  

            CriteriaQuery<S> query) {  

        Assert.notNull(query);  

        Root<T> root = query.from(getDomainClass());  

        CriteriaBuilder builder = em.getCriteriaBuilder();  

        // 增加了删除条件判断，从而将被逻辑删除的数据过滤掉  

        Predicate deletedPredicate = null;  

        if (BaseDefaultModel.class.isAssignableFrom(getDomainClass())) {  

            Path<Boolean> deletedPath = root.<Boolean> get(DELETEED_FIELD);  

            deletedPredicate = builder.isFalse(deletedPath);  

        }  

        if (spec == null) {  

            // 没有其它条件的时候只判断deleted字段  

            query.where(deletedPredicate);  

            return root;  

        }  

        Predicate predicate = spec.toPredicate(root, query, builder);  

        if (predicate != null) {  

            // 存在其它条件的时候还需要组合一下 deleted 条件  

            if (null != deletedPredicate) {  

                predicate = builder.and(predicate, deletedPredicate);  

            }  

            query.where(predicate);  

        }  

        return root;  

    }  

    private TypedQuery<T> applyLockMode(TypedQuery<T> query) {  

        LockModeType type = lockMetadataProvider == null ? null  

                : lockMetadataProvider.getLockModeType();  

        return type == null ? query : query.setLockMode(type);  

    }  

    /* 

     * (non-Javadoc) 

     *  

     * @see com.someok.common.base.mvc.BaseDao#logicDelete(java.io.Serializable) 

     */  

    @Override  

    public void logicDelete(ID id) {  

        T entity = findOne(id);  

        if (null == entity || !(entity instanceof BaseDefaultModel)) {  

            return;  

        }  

        BaseDefaultModel model = (BaseDefaultModel) entity;  

        model.setDeleted(true);  

        this.em.merge(model);  

    }  

    /* 

     * (non-Javadoc) 

     *  

     * @see com.someok.common.base.mvc.BaseDao#logicDelete(java.lang.Object) 

     */  

    @Override  

    public void logicDelete(T entity) {  

        if (null == entity || !(entity instanceof BaseDefaultModel)) {  

            return;  

        }  

        BaseDefaultModel model = (BaseDefaultModel) entity;  

        model.setDeleted(true);  

        if (StringUtil.isBlank(model.getId())) {  

            em.persist(model);  

        } else {  

            em.merge(model);  

        }  

    }  

    /* 

     * (non-Javadoc) 

     *  

     * @see com.someok.common.base.mvc.BaseDao#logicDelete(java.lang.Iterable) 

     */  

    @Override  

    public void logicDelete(Iterable<? extends T> entities) {  

        if (null == entities) {  

            return;  

        }  

        for (T entity : entities) {  

            logicDelete(entity);  

        }  

    }  

    protected String getCountQueryPlaceholder() {  

        return "x";  

    }  

}

主要的改动是 applySpecificationToCriteria 方法，与 SimpleJpaRepository 比对下就知道改了啥了。

findByXXX 操作

CURD 的修改还是比较简单的，不过那些根据接口方法自动实现查询修改起来就比较麻烦了。当然，不做任何修改也可以用，只需要在dao接口的方法上面加个 @Query 就行了，但是这样就需要写大量的jpql了，与采用 spring data的原意不符，咱用这玩意目的不就是为了个简单嘛。

本来的想法是继承某些类来对需要调整的方法重新实现就ok了，可惜spring data 这块的实现有点太封闭了，多个类没有 public，只能包内可见，更多的需要的方法只提供了 private 属性。没办法，只好把 org.springframework.data.jpa.repository.query 包内的代码都拷贝过来，其实真正需要改动的地方只有一处：

com.someok.common.base.spring.data.query.JpaQueryCreator.complete(Predicate, Sort, CriteriaQuery<Object>, CriteriaBuilder, Root<?>)

具体修改方法如下：

Java代码  

protected CriteriaQuery<Object> complete(Predicate predicate, Sort sort,  

        CriteriaQuery<Object> query, CriteriaBuilder builder, Root<?> root) {  

    // 增加了删除条件判断，从而将被逻辑删除的数据过滤掉  

    Predicate deletedPredicate = null;  

    if (BaseDefaultModel.class.isAssignableFrom(this.domainClass)) {  

        Path<Boolean> deletedPath = root.<Boolean> get(CustomSimpleJpaRepository.DELETEED_FIELD);  

        deletedPredicate = builder.isFalse(deletedPath);  

    }  

    // 在原有条件基础上组合 deleted 条件  

    if (null != deletedPredicate) {  

        predicate = builder.and(predicate, deletedPredicate);  

    }  

    return this.query.select(root).where(predicate)  

            .orderBy(QueryUtils.toOrders(sort, root, builder));  

}