Spring Data JPA 封装API

jpa-service-spring-boot-starter 

---

已封装参考GitHub 中文教程

参考  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);
    }
}