JPA多表多条件查询解决思路

最新推荐文章于 2024-05-29 19:50:28 发布
最新推荐文章于 2024-05-29 19:50:28 发布
阅读量1.9k 收藏 4
点赞数 2
分类专栏： Mybatis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qixiang_chen/article/details/104465916
版权

JPA单表多条件查询

可以在Service层使用Predicate实现
ServiceImpl实现类，查询条件可以自定义

	@Override
	public Page<OrgInfo> findOrgByCondition(OrgParam orgParam, Pageable pageable)
	{
		return orgRepository.findAll((root, query, cb) -> {
			List<Predicate> predicates = new ArrayList<>();
            if (!StringUtils.isEmpty(orgParam.getFlag())){
                predicates.add(cb.equal(root.get("flag"),orgParam.getFlag()));
            }
            if (!StringUtils.isEmpty(orgParam.getParentId())){
                predicates.add(cb.equal(root.get("parentId"),orgParam.getParentId()));
            }
            if (!StringUtils.isEmpty(orgParam.getName())){
                predicates.add(cb.like(root.get("name"),orgParam.getName()+"%"));
            }
            if (orgParam.getMinSeqno()!=null && orgParam.getMaxSeqno()!=null) {
                Predicate agePredicate = cb.between(root.get("seqno"), orgParam.getMinSeqno(),
                		orgParam.getMaxSeqno());
                predicates.add(agePredicate);
            }
            return query.where(predicates.toArray(new Predicate[predicates.size()])).getRestriction();
		}, pageable);
	}

JPA多表多条件查询

如果针对多表多条件查询，可以使用原生SQL实现

package com.gf.erp.dao;


import java.sql.Date;
import java.util.List;
import java.util.Map;

import javax.persistence.NamedNativeQuery;
import javax.persistence.SqlResultSetMapping;
import javax.transaction.Transactional;

import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Modifying;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.query.Param;

import com.gf.erp.model.Account;
import com.gf.erp.model.FunctionInfo;
import com.gf.erp.model.InStoreInfo;
import com.gf.erp.model.OrderInfo;
import com.gf.erp.model.OutStoreInfo;
import com.gf.erp.model.StoreCheckInfo;
import com.gf.erp.model.StoreInfo;
import com.gf.erp.model.StoreNameInfo;
import com.gf.erp.model.UserInfo;

public interface StoreCheckDao extends JpaRepository<StoreCheckInfo,String> {

	@Query(value = "select s.* from gufang_storecheck s,gf_content2user cu where s.storeId=cu.entityId "+
		"and s.flag=:flag and cu.userId=:userId and cu.module='STORENAME' "+
		"and IF (:storeId is not null, s.storeId=:storeId,1 = 1) "+
		"and IF (:beginDt is not null, s.beginDt>=:beginDt,1 = 1) "+
		"and IF (:endDt is not null, s.endDt<=:endDt,1 = 1) ",
		countQuery = "select count(s.id) from gufang_storecheck s,gf_content2user cu where s.storeId=cu.entityId "+
		"and s.flag=:flag and cu.userId=:userId and cu.module='STORENAME' "+
		"and IF (:storeId is not null, s.storeId=:storeId,1 = 1) "+
		"and IF (:beginDt is not null, s.beginDt>=:beginDt,1 = 1) "+
		"and IF (:endDt is not null, s.endDt<=:endDt,1 = 1) ",
		nativeQuery = true
	)
	public Page<StoreCheckInfo> findStoreNameListByUserId(@Param("flag") String flag,
			@Param("userId") String userId,@Param("storeId") String storeId,
			@Param("beginDt") Date beginDt,@Param("endDt") Date endDt,
			Pageable pageable);

}

使用EntityManager定义多条件查询

在服务实现类中注入EntityManager，自定义HQL查询数据，并且可以通过多表数据组装对象

@PersistenceContext
private EntityManager entityManager;

在这里插入图片描述

package com.gf.erp.service.impl;

import java.sql.Date;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;

import javax.annotation.Resource;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import javax.persistence.Query;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Predicate;

import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Pageable;
import org.springframework.data.domain.Sort;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.StringUtils;

import com.gf.erp.dao.FuncDao;
import com.gf.erp.dao.InStoreDao;
import com.gf.erp.dao.InStoreDetailDao;
import com.gf.erp.dao.OrderDao;
import com.gf.erp.dao.OrderItemDao;
import com.gf.erp.dao.OutStoreDao;
import com.gf.erp.dao.OutStoreDetailDao;
import com.gf.erp.dao.PrdtDao;
import com.gf.erp.dao.PrdtTypeDao;
import com.gf.erp.dao.StoreCheckDao;
import com.gf.erp.dao.StoreDao;
import com.gf.erp.dao.StoreNameDao;
import com.gf.erp.dto.PageData;
import com.gf.erp.dto.ResultData;
import com.gf.erp.model.FunctionInfo;
import com.gf.erp.model.InStoreDetailInfo;
import com.gf.erp.model.InStoreInfo;
import com.gf.erp.model.OrderInfo;
import com.gf.erp.model.OutStoreDetailInfo;
import com.gf.erp.model.OutStoreInfo;
import com.gf.erp.model.ProductInfo;
import com.gf.erp.model.ProductTypeInfo;
import com.gf.erp.model.QueryParam;
import com.gf.erp.model.StoreCheckInfo;
import com.gf.erp.model.StoreInfo;
import com.gf.erp.model.StoreNameInfo;
import com.gf.erp.service.FuncService;
import com.gf.erp.service.PrdtService;
import com.gf.erp.service.StoreService;
import com.gf.erp.util.Util;

@Service
@Transactional(readOnly=false,rollbackFor = Exception.class, propagation = Propagation.REQUIRED)
public class StoreServiceImpl implements StoreService{
	@Resource
	private PrdtDao prdtRepo;
	@Resource
	private StoreDao storeRepo;
	@Resource
	private StoreNameDao storeNameDao;
	@Resource
	private StoreDao storeDao;
	@Resource
	private OutStoreDao osDao;
	@Resource
	private InStoreDao isDao;
	@Resource
	private OrderDao orderDao;
	@Resource
	private StoreCheckDao storeChkDao;
	
	@PersistenceContext
	private EntityManager entityManager;
	
	@Override
	public PageData<StoreNameInfo> findStoreNameList(String flag,Integer page,Integer size,String name) {
		PageData<StoreNameInfo> rtn = new PageData<StoreNameInfo>();
		Sort sort = new Sort(Sort.Direction.DESC,"seqNo");
        Pageable p = PageRequest.of(page,size,sort);
        Page<StoreNameInfo> list = storeNameDao.findStoreNameList(p,flag,name);
        rtn.setSize(size);
        rtn.setPage(page);
        rtn.setTotal(list.getTotalElements());
        rtn.setList(list.getContent());
		return rtn;
	}
	

	@Override
	public List<StoreNameInfo> findStoreNameListByUserId(String flag, String userId) {
		return storeNameDao.findStoreNameListByUserId(flag,userId);
	}

	@Override
	public Boolean saveStoreName(StoreNameInfo sni) {
		try
		{
			storeNameDao.save(sni);
			return true;
		}
		catch(Exception e)
		{
			throw new RuntimeException(e);
		}
	}

	@Override
	public ResultData checkDeleteStore(StoreNameInfo sni) {
		ResultData rtn = new ResultData(true);
		List<OrderInfo> list = orderDao.findByStoreId(sni.getId());
		if(list.size()>0)
		{
			rtn.setIsok(false);
			rtn.addMsg("仓库删除", "仓库:["+sni.getName()+"] 存在关联订单记录,禁止删除");
			return rtn;
		}
		List<StoreInfo> list2 = storeDao.findByStoreId(sni.getId());
		if(list2.size()>0)
		{
			rtn.setIsok(false);
			rtn.addMsg("仓库删除", "仓库:["+sni.getName()+"] 存在关联库存记录,禁止删除");
			return rtn;
		}
		List<OutStoreInfo> list3 = osDao.findByStoreIdOrToStoreId(sni.getId(), sni.getId());
		if(list3.size()>0)
		{
			rtn.setIsok(false);
			rtn.addMsg("仓库删除", "仓库:["+sni.getName()+"] 存在关联出库记录,禁止删除");
			return rtn;
		}
		List<InStoreInfo> list4 = isDao.findByStoreIdOrFromStoreId(sni.getId(), sni.getId());
		if(list4.size()>0)
		{
			rtn.setIsok(false);
			rtn.addMsg("仓库删除", "仓库:["+sni.getName()+"] 存在关联入库记录,禁止删除");
			return rtn;
		}
		return rtn;
	}

	@Override
	public Boolean deleteStoreName(String id) {
		try
		{
			storeNameDao.deleteById(id);
			return true;
		}
		catch(Exception e)
		{
			throw new RuntimeException(e);
		}
	}

	@Override
	public PageData<StoreInfo> findStoreList(String flag, Integer page, Integer size, String storeId,
			String prdtName) {
		PageData<StoreInfo> rtn = new PageData<StoreInfo>();
		Sort sort = new Sort(Sort.Direction.DESC,"count");
        Pageable p = PageRequest.of(page,size,sort);
        Page<StoreInfo> list = storeDao.findStoreList(p,flag,storeId,prdtName);
        rtn.setSize(size);
        rtn.setPage(page);
        rtn.setTotal(list.getTotalElements());
        rtn.setList(list.getContent());
		return rtn;
	}
	
	@Override
	public PageData<StoreCheckInfo> findStoreChkListByUserId(String flag,String userId,String storeId,
			Date beginDt,Date endDt,Integer page,Integer size) {
		PageData<StoreCheckInfo> rtn = new PageData<StoreCheckInfo>();
		Sort sort = new Sort(Sort.Direction.DESC,"endDt");
        Pageable p = PageRequest.of(page,size,sort);
        
        Page<StoreCheckInfo> list = storeChkDao.findStoreChkListByUserId(flag, userId, storeId, beginDt, endDt, p);
        rtn.setSize(size);
        rtn.setPage(page);
        rtn.setTotal(list.getTotalElements());
        rtn.setList(list.getContent());
		return rtn;
	}

	@Override
	public PageData<StoreCheckInfo> findStoreChkList(String flag,String storeId,
			Date beginDt,Date endDt,Integer page,Integer size) {
		PageData<StoreCheckInfo> rtn = new PageData<StoreCheckInfo>();
		Sort sort = new Sort(Sort.Direction.DESC,"endDt");
        Pageable p = PageRequest.of(page,size,sort);
        
        Page<StoreCheckInfo> list = storeChkDao.findStoreChkList(flag,storeId, beginDt, endDt, p);
        rtn.setSize(size);
        rtn.setPage(page);
        rtn.setTotal(list.getTotalElements());
        rtn.setList(list.getContent());
		return rtn;
	}
	
	@Override
	public PageData<StoreCheckInfo> findStoreChkList2(String flag,String storeId,
			Date beginDt,Date endDt,Integer page,Integer size) {
		PageData<StoreCheckInfo> rtn = new PageData<StoreCheckInfo>();
		Sort sort = new Sort(Sort.Direction.DESC,"endDt");
		Integer startPosition = (page-1)*size;
        
        String hql = "select new StoreCheckInfo(s.id,s.storeId,s.jbUserId,s.beginDt,"+
        		"s.endDt,s.status,s.isCurrent,s.flag,s.testMode,sn.name) from StoreCheckInfo s,"+
        		"StoreNameInfo sn where s.storeId=sn.id ";
        if(!Util.isNull(storeId))
        {
        	hql = hql + "and s.storeId=:storeId";
        }
        Query q = entityManager.createQuery(hql);
        if(!Util.isNull(storeId))
        {
        	q.setParameter("storeId", storeId);
        }
        Long total  = new Long(q.getResultList().size());
        q.setFirstResult(startPosition);
        q.setMaxResults(size);
        List<StoreCheckInfo> list = q.getResultList();
        rtn.setSize(size);
        rtn.setPage(page);
        rtn.setTotal(total);
        rtn.setList(list);
		return rtn;
	}
}

JPA多表数据组织实体对象

需要在JPQL中使用构造方法创建对象
在这里插入图片描述

package com.gf.erp.dao;


import java.util.List;
import java.util.Map;

import javax.persistence.NamedNativeQuery;
import javax.persistence.SqlResultSetMapping;
import javax.transaction.Transactional;

import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Modifying;
import org.springframework.data.jpa.repository.Query;

import com.gf.erp.model.UserInfo;

public interface UserDao extends JpaRepository<UserInfo,String> {

    @Query(value = "select * from orgmodel_user",nativeQuery = true)
    Page<UserInfo> findPageUser(Pageable pageable);
    
    @Query(value = "select u from UserInfo u where u.orgId=?1")
    List<UserInfo> getUserListByOrgId(String orgId);
    
    List<UserInfo> findByOrgPathLike(String path);
    
    UserInfo findByFlagAndLoginId(String flag,String loginId);
    
    @Query(value = "select new UserInfo(u.id,u.name,u.loginId,u.password,u.cardId,"+
			"u.birthday,u.address,u.companyMail,u.privateMail,"+
			"u.companyTeleNo,u.homeTeleNo,u.mobile,u.title,"+
			"u.orgId,u.orgPath,u.desc,u.enabled,u.locked,"+
			"u.managerId,u.shopId,u.failureDate,u.failureCount,"+
			"u.openid,u.securityLevel,u.seqno,u.flag,"+
			"o.name,o.name) from UserInfo u,OrgInfo o where u.orgId=o.id",
    		countQuery = "select count(u) from UserInfo u")
    Page<UserInfo> findPageFilledUser(Pageable pageable);
    
    @Query(value = "select o.name as department,u.* from orgmodel_user u,orgmodel_org o where u.orgid=o.id",
    		countQuery = "select count(*) from orgmodel_user",
    		nativeQuery = true)
    List<Map<String,Object>> findMapUser(Pageable pageable);
    
    @Modifying
    @Query("update UserInfo u set u.locked=?2 where u.id=?1")
    void updateUserLockById(String id,String locked);
}
华科易迅
关注
  • 2
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
spring data jpa 多表 分页 多条件 查询
laokaizzz的专栏
08-19 1万+
结论如下： 用querydsl的方式。 既然提供了这种方式就用吧。单实体，单表多条记录，动态条件直接写，不用写dao层。 多表的，大部分用querydsl都能实现。不能实现的，用sql实现。 返回值方面还是和以前一样，返回主实体类，附加的挂在对应的类属性上。需要很高效率的用dto返回。 代码如下： package com.xxx.xxxxx.service.impl; impo...
jpa实现多条件查询
IT界的一只菜鸟
08-06 566
@Override public DataResult<?> queryList(UserQuery query) { Specification<UserEntity> specification = ((root, criteriaQuery, criteriaBuilder) -> { List<Predicate> predicates = new ArrayList<>(16); .
Spring JPA实现多条件查询，全部条件查询
Li_Zhongxin的博客
07-31 2213
Spring JPA实现多条件查询，全部条件查询
【Java系列】JPA中实现NatveSql进行多表关联查询
最新发布
招财猫_Martin 的专栏
05-29 558
JPA 是一个基于O/R映射的标准规范，定义了标准接口和相关的注解。具体的实现由各厂家自己接接口规范来做，比如本示例中用到的是Hibernate。下面给出相关的配置。
JPA 多条件、多表查询
心有猛虎细嗅蔷薇
10-25 3777
JPA对于简单的查询操作确实很给力，但是涉及到多表、多条件、分页的场景就不是很好实现了。 可行的解决方案 1、多条件 public interface BaseRepository&lt;T,ID extends Serializable&gt; extends JpaRepository&lt;T,ID&gt;, JpaSpecificationExecutor&lt;T&gt; 使用...
SpringDataJpa -- 多条件查询
Crg的博客
03-31 1万+
前言：使用SpringDataJpa 进行多条件查询。 一、单表的多条件查询 @Override public Page&lt;Courier&gt; pageQuery(Courier model, Pageable pageable) { //封装查询对象Specification Specification&lt;Courier&gt; exam...
Spring Data JPA--多表关联查询--实例
IT利刃出鞘的博客
10-07 3048
原文网址： 简介 多表联查有以下方案 原生SQL JHQL Specification 实体关联（不推荐） 见：JPA--注解--实体关联_IT利刃出鞘的博客-CSDN博客 不推荐的原因：增删改查时强关联，操作不便捷 手动查一个表之后，在查另一个。 对于以上四种方案，第三四种不再介绍，本文只介绍原生SQL、JHQL和Specification这三种方案。 公共代码 配置文件及依赖 application.yml spring: datasource: drive
jpa多个条件查询
yuanbo_520的博客
06-18 498
jpa实体仓库 public interface StudentRepository extends JpaRepository<Student, String>, JpaSpecificationExecutor<Student>{ } jpa查询条件封装 /** *查询条件拼装 */ private Specification<student> query(String id, String name) {
分布式应用层中间件的设计
10-22
垂直分片是根据属性集将数据分割，而水平分片则是依据特定条件将记录划分为多个不相交的子集。当垂直分片无法满足扩展需求时，水平分片就显得尤为重要。水平分片允许数据分散在多个数据库中，以减轻单个数据库的压力...
基于Springboot+Vue的医护人员排班系统源码案例设计带文档说明.zip
04-20
2. 排班管理：医护人员可以根据部门、职务、技能等因素进行排班，系统需支持多条件查询、编辑和删除排班计划。 3. 时间表展示：以直观的日历形式展示排班情况，方便医护人员查看自己的工作时间。 4. 提醒功能：当...
学生课程管理系统, 期末课设, 使用Vue.js + SpringBoot.zip
12-26
系统设计上，课程管理模块包括课程创建、编辑、删除功能，支持课程信息的多条件查询。学生管理模块则涉及学生注册、登录、个人信息管理等。此外，还包含选课系统，允许学生根据自己的需求选择或退选课程，同时管理员...
基于Springboot的大学生平时成绩量化管理系统（有报告） Javaee项目，springboot项目
05-13
5. 成绩查询模块：支持按学生、课程等多种条件查询成绩，展示成绩排名和平均分等统计信息。 6. 成绩分析模块：根据录入的平时成绩，进行量化分析，如计算出学生的出勤率、作业完成情况等指标。 7. 报告生成模块：...
java web 图书管理系统，课程设计
03-05
- **图书查询**：用户可以按书名、作者、类别等条件搜索图书，系统返回符合条件的结果。 - **图书添加与修改**：管理员可以在后台添加新的图书或修改已有图书的信息，如更新库存、修改描述等。 - **图书借阅与...
JPA多条件查询
weixin_45739766的博客
11-26 269
@Service public class StudentService implements IStudentService { @Autowired private IStudentRepository repository; //无关代码略 @Override public List<Student> getStudent(String studentNumber,Strin...
SpringBoot JPA使用Specification多条件查询
小石潭记丶
02-28 1244
public Specification<SwindleAccountEntity> exportSwindleAccountSpecification(ExportSwindleAccountRequest request) { return (root, criteriaQuery, criteriaBuilder) -> { List<Predicate> predicateList = new ArrayList<>.
使用jpa进行多表联查、分页
weixin_69411453的博客
11-14 946
首先dao层mapper继承。
springboot+thymeleaf实现多条件查询分页以及CRUD操作
weixin_53949546的博客
05-24 1359
1.技术栈 前端使用thymeleaf模板引擎+bootstrap组件+jquery，后端使用springboot+mybatis+redis+pageHelper分页插件
SpringData jpa 实现多条件动态查询，分页功能
热门推荐
billluffy的博客
10-18 4万+
问题由来： 刚开始使用springdata的时候，只会用findByName这样的简单查询，这样写dao层确实非常的快，但是在我们做筛选功能的时候，这样的查询似乎很难满足我们的需求，但是都已经用上的springdata又不想再去写mybatis这样在xml里面判断是否为Null。 解决方案： 1. Example,用example可以最快速的完成支持所有参数的筛选功能,像这样的代码: @Test ...
关于使用JPA2.0时，执行多条件UPDATE语句时更新失败的问题
03-22 807
问题描述 第一次使用JPA，工作中有类似这样的需求： 把购物车表中的数量+1，SQL如下： updatet_basketsetbuy_count=6,real_pay=20300whereid=1822andbuy_count=5; Ja...
jpa多表关联分页条件查询
10-11
可以使用JPA的@ManyToOne或@OneToMany注解来实现多表关联，然后使用Spring Data JPA提供的PagingAndSortingRepository接口，结合自定义查询方法和分页参数，来实现多表关联分页条件查询。 例如，假设有两个实体类...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值