springboot + JPA

import com.example.demo.domain.User;
import org.springframework.data.jpa.domain.Specification;
import org.springframework.data.jpa.repository.Modifying;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.query.Param;
import org.springframework.util.StringUtils;

import javax.persistence.criteria.Path;
import javax.persistence.criteria.Predicate;
import java.util.ArrayList;
import java.util.List;

public interface UserRepository extends baseRepository {

    default Specification getSpecification(User example) {
        return (root, criteriaQuery, criteriaBuilder) -> {
            Path id = root.get("id");
            Path account = root.get("account");
            Path delFlag = root.get("delFlag");

            List predicateList = new ArrayList<>();

            if (example.getId() != null && example.getId() > 0) {
                predicateList.add(criteriaBuilder.equal(id, example.getId()));
            }
            if (example.getDelFlag() != null) {
                predicateList.add(criteriaBuilder.equal(delFlag, example.getDelFlag()));
            }
            if (!StringUtils.isEmpty(example.getAccount())) {
                predicateList.add(criteriaBuilder.equal(account, example.getAccount()));
            }

            return criteriaBuilder.and(predicateList.toArray(new Predicate[predicateList.size()]));
        };
    }

    User findByAccount(String account);

    // native SQL
    @Query(value = "select u.* from user_user u where u.id = ?1 or u.account = ?2 ", nativeQuery = true)
    User queryUser(Integer id, String account);

    // JPQL
    @Modifying // 更新或删除时需要加此注解，查询时不需要
    @Query("update User set account = :account where id = :id ")
    User updateUserAccount(@Param("id") Integer id, @Param("account") String account);
}

3) service

baseService:

import com.example.demo.po.PagerRequest;
import org.springframework.data.domain.Page;

import java.util.List;

public interface baseService {

    
    T merge(T domain);

    
    List mergeAll(Iterable domains);

    
    void delete(T domain);

    
    void deleteAll(Iterable domains);

    
    T findById(Integer id);

    
    List findAllById(Iterable ids);

    
    List findByExample(T domain);

    
    long count(T domain);

    
    Page findByPage(PagerRequest pagerRequest);

}

import com.example.demo.domain.Domain;
import com.example.demo.po.PagerRequest;
import com.example.demo.repository.baseRepository;
import com.example.demo.service.baseService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Sort;
import org.springframework.transaction.annotation.Transactional;

import java.lang.reflect.ParameterizedType;
import java.util.Collections;
import java.util.List;

@Slf4j
public abstract class baseServiceImpl implements baseService {

    @Autowired
    private baseRepository baseRepository;

    private Class domain;

    public baseServiceImpl() {
        ParameterizedType parameterizedType = ((ParameterizedType) getClass().getGenericSuperclass());
        domain = (Class) parameterizedType.getActualTypeArguments()[0];
    }

    @Transactional(rollbackFor = Exception.class)
    @Override
    public T merge(T domain) {
        return baseRepository.save(domain);
    }

    @Transactional(rollbackFor = Exception.class)
    @Override
    public List mergeAll(Iterable domains) {
        return baseRepository.saveAll(domains);
    }

    @Transactional(rollbackFor = Exception.class)
    @Override
    public void delete(T domain) {
        baseRepository.delete(domain);
    }

    @Transactional(rollbackFor = Exception.class)
    @Override
    public void deleteAll(Iterable domains) {
        baseRepository.deleteAll(domains);
    }

    @Override
    public T findById(Integer id) {
        if(id != null && id > 0){
            return baseRepository.findById(id).orElse(null);
        }
        return null;
    }

    @Override
    public List findAllById(Iterable ids) {
        if(ids != null){
            return baseRepository.findAllById(ids);
        }
        return Collections.emptyList();
    }

    @Override
    public List findByExample(T domain) {
        return baseRepository.findAll(baseRepository.getSpecification(domain));
    }

    @Override
    public long count(T domain) {
        return baseRepository.count(baseRepository.getSpecification(domain));
    }

    @Override
    public Page findByPage(PagerRequest pagerRequest) {
        try {
            T t = domain.newInstance();

            // 查询参数封装转换 (如分页查询User, 创建UserRequest extends PagerRequest,
            BeanUtils.copyProperties(pagerRequest, t);

            // 排序处理
            Sort sort = pagerRequest.getSort();
            if (sort == null) {
                sort = new Sort(Sort.Direction.DESC, "id");
            }

            // JPA分页从0开始, mybatis pagerHelper从1开始
            PageRequest pageable = PageRequest.of((pagerRequest.getPageNum() - 1), pagerRequest.getPageSize(), sort);
            // 在对应的repository中覆写getSpecification方法
            return baseRepository.findAll(baseRepository.getSpecification(t), pageable);
        } catch (Exception e) {
            log.error("异常信息：{}", e.getMessage());
            throw new RuntimeException("查询参数异常");
        }
    }

}

UserService:

import com.example.demo.domain.User;

public interface UserService extends baseService {

    
    User findByAccount(String account);

    User queryUser(Integer id, String account);

    User updateUserAccount(Integer id, String account);
}

import com.example.demo.domain.User;
import com.example.demo.repository.UserRepository;
import com.example.demo.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class UserServiceImpl extends baseServiceImpl implements UserService {

    @Autowired
    private UserRepository userRepository;

    @Override
    public  User findByAccount(String account) {
        return userRepository.findByAccount(account);
    }
  
    @Override
    public User queryUser(Integer id, String account) {
        return userRepository.queryUser(id, account);
    }

    @Transactional(rollbackFor = Exception.class)
    @Override
    public User updateUserAccount(Integer id, String account) {
        return userRepository.updateUserAccount(id, account);
    }

}

写在最后：ORM一般作为关系型数据库的持久层处理解决方案，对于非关系型数据库（也就是我们常说的NoSQL）, 比如：redis, mongoDB, ES, solr等(虽然有些侧重搜索，但也都具有数据存储功能)，spring也可以无缝集成，下次聊聊springboot + springdata，其实JPA也是基于springdata。