Spring Data JPA 封装API

深碍√TFBOYSˉ_ 2022-04-04 03:05 290阅读 0赞

### **jpa-service-spring-boot-starter ** ###

--------------------

已封装参考GitHub 中文教程

参考  [https://github.com/uinio/jpa-querydsl-spring-boot-starter][https_github.com_uinio_jpa-querydsl-spring-boot-starter]

**☆** 支持 querydsl 开箱即用

**☆** 兼容 spring boot 2.1.x 以上（包含2.1）

--------------------

注意：以下内容为很早之前的编写，不再进行优化，仅供参考。

建议使用 jpa-service-spring-boot-starter ，支持querydsl 开箱即用。

--------------------

**使用很简单直接继承接口和实现类即可 **

T :实体类类型

ID：主键类型

--------------------

使用示例

public interface UserService extends BaseService<User, String> {
    
    }

@Service
    public class UserServiceImpl extends BaseServiceImpl<User, String> implements UserService {
    
    }

--------------------

**封装API**

import java.util.List;
    import java.util.Map;
    import java.util.Optional;
    
    public interface BaseService<T, ID> {
        /**
         * 分页查询
         *
         * @param pageNum  当前页
         * @param pageSize 每页的数据条数
         * @param entity   可根对象信息进行精确查找
         * @return Map
         */
    
        Map<String, Object> page(int pageNum, int pageSize, T entity);
    
        /**
         * 分页查询
         *
         * @param pageNum  当前页
         * @param pageSize 每页的数据条数
         * @return Map
         */
        Map<String, Object> page(int pageNum, int pageSize);
    
        /**
         * 查询所有
         *
         * @return
         */
        List<T> selectAll();
    
        /**
         * 根据主键查询，未查找到会抛出异常
         *
         * @param key
         * @return
         */
        T selectByKey(ID key);
    
        /**
         * 根据主键查询，未查找到不会抛出异常
         *
         * @param id
         * @return
         */
        Optional<T> selectById(ID id);
    
        /**
         * 保存实体
         *
         * @param entity
         * @return
         */
        T save(T entity);
    
        /**
         * 批量新增
         *
         * @param entity
         * @return
         */
        List<T> saveBatch(List<T> entity);
    
        /**
         * 删除对象
         *
         * @param entity
         */
        void delete(T entity);
    
        /**
         * 批量删除对象
         *
         * @param entities entities
         */
        void deleteBatch(List<T> entities);
    
        /**
         * 批量删除根据id
         *
         * @param ids ids
         */
        void deleteBatch(ID[] ids);
    
        /**
         * 根据主键删除
         *
         * @param key
         */
        void deleteById(ID key);
    
        /**
         * 更新实体（实体成员变量为null的不会更新）
         *
         * @param entity
         * @return
         */
        T update(T entity, ID id);
    
        /**
         * 批量更新对象
         *
         * @param entities entities
         */
        void updateBatch(List<T> entities, ID[] ids);
    
    
    }

import org.springframework.beans.BeanUtils;
    import org.springframework.beans.BeanWrapper;
    import org.springframework.beans.BeanWrapperImpl;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.data.domain.Example;
    import org.springframework.data.domain.Page;
    import org.springframework.data.domain.PageRequest;
    import org.springframework.data.domain.Pageable;
    import org.springframework.data.jpa.repository.JpaRepository;
    import org.springframework.transaction.annotation.Propagation;
    import org.springframework.transaction.annotation.Transactional;
    
    import java.beans.PropertyDescriptor;
    import java.util.*;
    
    @Transactional(propagation = Propagation.REQUIRED, readOnly = true, rollbackFor = Exception.class)
    public abstract class BaseServiceImpl<T, ID> implements BaseService<T, ID> {
    
        //总记录数
        protected final String PAGE_TOTAL = "total";
        //查询集合信息
        protected final String PAGE_ROWS = "rows";
        //验证
        protected final String PAGE_VALID = "valid";
    
        //完成JpaRepository注入
        private JpaRepository<T, ID> repository;
    
        @Autowired
        //警告可忽略是正确的
        public void setRepository(JpaRepository<T, ID> repository) {
            this.repository = repository;
        }
    
        /**
         * 条件分页查询
         *
         * @param pageNum  当前页
         * @param pageSize 每页的数据条数
         * @param entity   可根对象信息进行精确查找
         * @return map集合
         */
        @Override
        public Map<String, Object> page(int pageNum, int pageSize, T entity) {
            Map<String, Object> map = new HashMap<>();
            Pageable pageable = PageRequest.of(pageNum - 1, pageSize);
            //查询的实例（条件）
            Example<T> example = Example.of(entity);
            Page<T> page = repository.findAll(example, pageable);
            map.put(PAGE_TOTAL, page.getTotalElements());
            map.put(PAGE_ROWS, page.getContent());
            return map;
        }
    
        /**
         * 分页查询全部
         *
         * @param pageNum  当前页
         * @param pageSize 每页的数据条数
         * @return map集合
         */
        @Override
        public Map<String, Object> page(int pageNum, int pageSize) {
            Map<String, Object> map = new HashMap<>();
            Pageable pageable = PageRequest.of(pageNum - 1, pageSize);
            //查询的实例（条件）
            Page<T> page = repository.findAll(pageable);
            map.put(PAGE_TOTAL, page.getTotalElements());
            map.put(PAGE_ROWS, page.getContent());
            return map;
        }
    
        /**
         * 查询全部
         *
         * @return list集合
         */
        @Override
        public List<T> selectAll() {
            return repository.findAll();
        }
    
        /**
         * 单条件根据主键查询，未查找到会抛出异常
         *
         * @param key id
         * @return domain
         */
        @Override
        public T selectByKey(ID key) {
            return repository.getOne(key);
        }
    
        /**
         * 单条件根据主键查询，未查找到不会抛出异常
         *
         * @param id id
         * @return Optional
         */
        @Override
        public Optional<T> selectById(ID id) {
            return repository.findById(id);
        }
    
        /**
         * 保存
         *
         * @param entity 对象
         * @return domain
         */
        @Override
        @Transactional(propagation = Propagation.REQUIRED)
        public T save(T entity) {
            return repository.save(entity);
        }
    
        /**
         * 批量新增
         *
         * @param entity
         * @return
         */
        @Override
        public List<T> saveBatch(List<T> entity) {
            return repository.saveAll(entity);
        }
    
        /**
         * 删除对象
         *
         * @param entity 对象
         */
        @Override
        @Transactional(propagation = Propagation.REQUIRED)
        public void delete(T entity) {
            repository.delete(entity);
        }
    
        /**
         * 根据id删除
         *
         * @param key id
         */
        @Override
        @Transactional(propagation = Propagation.REQUIRED)
        public void deleteById(ID key) {
            repository.deleteById(key);
        }
    
        /**
         * 批量删除根据id
         *
         * @param ids ids
         */
        @Override
        @Transactional(propagation = Propagation.REQUIRED)
        public void deleteBatch(ID[] ids) {
            List<T> list = new ArrayList<>();
            for (ID id : ids) {
                T entity = repository.getOne(id);
                list.add(entity);
            }
            repository.deleteInBatch(list);
        }
    
        /**
         * 批量删除对象
         *
         * @param entities entities
         */
        @Override
        @Transactional(propagation = Propagation.REQUIRED)
        public void deleteBatch(List<T> entities) {
            repository.deleteInBatch(entities);
        }
    
        /**
         * 更新
         *
         * @param entity 更新参数
         * @param id     需要根据id过滤null值
         * @return 更新的结果
         */
        @Override
        @Transactional(propagation = Propagation.REQUIRED)
        public T update(T entity, ID id) {
            T object = repository.getOne(id);
            //将object复制给entity 忽略的属性是有值的属性（将object复制到entity属性为null）
            BeanUtils.copyProperties(object, entity, getNoNullProperties(entity));
            repository.save(entity);
            return entity;
        }
    
        /**
         * 批量更新
         *
         * @param entities entities
         * @param ids
         */
        @Override
        @Transactional(propagation = Propagation.REQUIRED)
        public void updateBatch(List<T> entities, ID[] ids) {
            List<T> list = new ArrayList<>();
            for (T entity : entities) {
                for (ID id : ids) {
                    T object = repository.getOne(id);
                    //注意不要导错包
                    BeanUtils.copyProperties(object, entity, getNoNullProperties(entity));
                    list.add(entity);
                }
            }
            repository.saveAll(list);
        }
    
        /**
         * 获取对象不为空的属性
         *
         * @param o 参数
         * @return 将目标源中不为空的字段取出
         */
        protected static String[] getNoNullProperties(Object o) {
            //获取对象的bean的包装类
            BeanWrapper bean = new BeanWrapperImpl(o);
            //获取属性（字段）的描述
            PropertyDescriptor[] descriptors = bean.getPropertyDescriptors();
            Set<String> set = new HashSet<>();
            for (PropertyDescriptor descriptor : descriptors) {
                Object value = bean.getPropertyValue(descriptor.getName());
                if (!Objects.equals(value, null)) set.add(descriptor.getName());
            }
            String[] result = new String[set.size()];
            return set.toArray(result);
        }
    }

[https_github.com_uinio_jpa-querydsl-spring-boot-starter]: https://github.com/uinio/jpa-service-spring-boot-starter