项目中，jpa对于简单的数据库操作很方便，但如果多表关联动态查询时，需要自己去写SQL语句拼接查询条件，以下为本人学习的例子。
 
类似于这种多条件动态查询：
 
 
 
项目用的是springboot 2.1.0.RELEASE版本以及spring-boot-starter-data-jpa,其中spring-boot-starter-data-jpa底层已经依赖了hibernate-core5.3.7.Final，数据库用的是postgresql。
 
这里pom.xml和properties配置文件省略。
 
由于不能直接spring-data-jpa的Repository调用接口，所以得获取操作数据层的入口，详情请查看springBoot获取jpa的sessionFactory。
 
一.实体类(直接从工程复制粘贴过来的，有错可以自己解决，@Data为lombok工具的注解，自动生成getter/setter以及构造方法等)
 
**
 
* 商品表
 
*/
 
@Entity
 
@Table(name = "t_goods ")//heibernate自动生成数据库表
 
@Data
 
public class TGoods implements Serializable {
 
//这里关联两张表
 
@Id
 
@GeneratedValue(strategy=GenerationType.IDENTITY)
 
@ApiParam("自增列")
 
private int id;
 
private String goodsId;//商品id
 
private String goodsName；//商品名称
 
}
 
**
 
* 商品规格表
 
*/
 
@Entity
 
@Table(name = "t_goods_spec ")
 
@Data
 
public class TGoodsSpec implements Serializable {
 
//这里关联两张表
 
@Id
 
@GeneratedValue(strategy=GenerationType.IDENTITY)
 
@ApiParam("自增列")
 
private int id;
 
private String goodsSpecId;//商品规格Id
 
private String goodsName；//商品规格名称
 
private String goodsId;//商品id
 
}
 
**
 
* 库存表
 
*/
 
@Entity
 
@Table(name = "t_stock_statistics ")
 
@Data
 
public class TStockStatistics implements Serializable {
 
//这里关联两张表
 
@Id
 
@GeneratedValue(strategy=GenerationType.IDENTITY)
 
@ApiParam("自增列")
 
private int id;
 
private String goodsId;//商品id
 
private String goodsSpecId;//商品规格Id
 
private long totalAmount;//现有库存
 
}
 
二.测试JUnit代码
 
@RunWith(SpringRunner.class)
 
@SpringBootTest(classes = 对应的启动类.class)
 
public class ProviderApplicationTests {
 
@PersistenceContext//jpa的数据库操作类
 
private EntityManager entityManger;
 
@Test
 
public void test() throws Exception{
 
String ids = "2,3";
 
String supplier = "美的";
 
String goodsName = "空调";
 
String goodsSpecName = "1匹";
 
String sql = "select t1.goods_id goodsId,t1.id id,t2.goods_name goodsName,t1.goods_spec_id goodsSpecId,t3.goods_spec_name goodsSpecName from t_stock_statistics t1 join t_goods t2 on t1.goods_id = t2.goods_id join t_goods_spec t3 on t3.spec_id = t1.goods_spec_id where 1=1";
 
// 拼接动态查询条件的sql语句
 
// 中的:supplier表示传进来的参数的名称
 
// 另外一种传参方式是其中1代表的是参数传进来的顺序号，比如 nativeQuery.setParameter(1, “美的”);
 
Mapmap = new HashMap<>();
 
if(StringUtil.isNullOrEmpty(ids)){// 这里不把id作为查询条件
 
sql += " and t1.id in (:ids)";
 
map.put("ids",ids);
 
}
 
if(!StringUtil.isNullOrEmpty(supplier)){
 
sql += " and t1.supplier = :supplier";
 
map.put("supplier",supplier);
 
}
 
if(!StringUtil.isNullOrEmpty(goodsName)){
 
sql += " and t2.goods_name = :goodsName";
 
map.put("goodsName",goodsName);
 
}
 
if(!StringUtil.isNullOrEmpty(goodsSpecName)){
 
sql += " and t3.goods_spec_name = :goodsSpecName";
 
map.put("goodsSpecName",goodsSpecName);
 
}
 
sql += " order by id DESC";
 
Query nativeQuery = entityManger.createNativeQuery(sql);
 
// 把参数传进去
 
for (String key:map.keySet()
 
) {
 
if(key.equals("ids")){
 
ListidList = new ArrayList<>();
 
String[] split = map.get(key).toString().split(",");
 
for (String value:split
 
) {
 
idList.add(Integer.valueOf(value));
 
}
 
nativeQuery.setParameter("ids", idList);
 
} else {
 
nativeQuery.setParameter(key, map.get(key));
 
}
 
}
 
// 对查询出来的结果进行处理
 
// 有三种处理方式，Transformers.ALIAS_TO_ENTITY_MAP为其中一种，另一个相似的是Transformers.TO_LIST
 
nativeQuery.unwrap(SQLQuery.class).setResultTransformer(Transformers.ALIAS_TO_ENTITY_MAP);
 
List> resultList = nativeQuery.getResultList();
 
for (Mapmap1 :resultList
 
) {
 
System.out.println(map1);
 
}
 
// 这是第三种，Transformers.aliasToBean(StockStatisticsVO.class)意思为把查出来的结果转换成一个StockStatisticsVO实体类
 
/*nativeQuery.unwrap(SQLQuery.class).setResultTransformer(Transformers.aliasToBean(StockStatisticsVO.class));
 
ListresultList = nativeQuery.getResultList();
 
for (StockStatisticsVO svo:resultList
 
) {
 
System.out.println(svo.toString());
 
}*/
 
}
 
}
 
附StockStatisticsVO实体类
 
/**
 
* 仓库出入库VO
 
*/
 
@Data
 
public class StockStatisticsVO implements Serializable {
 
//构造方法(无参)必须
 
//VO类有的属性,sql查询语句必须有对应的返回字段值,顺序不分
 
//postgresql返回字段名不分大小写,统一小写
 
private int id;
 
private String goodsid;//商品id
 
private String goodsname;//商品名称
 
private String goodsspecid;//商品规格Id
 
private String goodsspecname;//商品规格名称
 
public StockStatisticsVO() {
 
}
 
}
 
测试结果：
 
 

 
展开全部
 
SQL中多表查询可以使用链接查询
 
1、union
 
union [all]
 
all：表示将查询的所e68a843231313335323631343130323136353331333337623431有结果都合并到结果集中，若不加all会将重复的行只保留一行--示例：
 
select * from a union select * from b
 
2、join
 
连接分为内连接、外连接、交叉连接
 
2.1、内连接 inner join (默认的连接方式)
 
只有至少有(指定的字段)一行的记录在两个查询表中都有记录，此时才有结果集。即        返回两个表之间的交集(相同字段的记录)--示例：
 
SELECT * FROM  `a` INNER JOIN b ON a.aaa = b.aaa
 
2.2、外连接
 
a、left join 左连接
 
返回查询表的记录，包含左边表的所有记录，如果左边表中的记录在右边表中没有对        应的记录，则所返回右边表的字段结果为空(差集)--示例：
 
SELECT * FROM  `a` LEFT JOIN `b` ON a.aaa = b.aaa
 
b、right join 右连接
 
与left join相反，查询的记录包含右边表的所有记录，如果右边表中的记录在左边表        中没有对应的记录，则返回左边表的字段值为空(差集)--示例：
 
SELECT * FROM `b` LEFT JOIN `a` ON a.aaa = b.aaa
 
c、full join 全连接
 
返回左表和右表中的所有记录，即两表的数据全部显示--示例：
 
select * from a full join b
 
3、cross in 交叉连接
 
不带where子句，返回两个表中所有笛卡尔积，记录数为a表和b表记录数的积--示例：
 
SELECT * FROM  `b` CROSS JOIN `a`

                       **sql语句多表关联查询语法**
 
一、外连接
 
1.左连接 left join 或 left outer join
 
SQL语句：select * from student left join score on student.Num=score.Stu_id;
 
2.右连接 right join 或 right outer join
 
SQL语句：select * from student right join score on student.Num=score.Stu_id;
 
3.完全外连接 full join 或 full outer join
 
SQL语句：select * from student full join score on student.Num=score.Stu_id;
 
通过上面这三种方法就可以把不同的表连接到一起，变成一张大表，之后的查询操作就简单一些了。
 
而对于select * from student,score;则尽量不使用此语句，产生的结果过于繁琐。
 
二、内连接
 
join 或 inner join
 
SQL语句：select * from student inner join score on student.Num=score.Stu_id;
 
此时的语句就相当于：select * from student,score where student.ID=course.ID;
 
三、交叉连接
 
cross join，没有where指定查询条件的子句的交叉联接将产生两表的笛卡尔积。
 
SQL语句：select * from student cross join score;
 
四、结构不同的表连接
 
当两表为多对多关系的时候，我们需要建立一个中间表student_score，中间表至少要有两表的主键。
 
SQL语句：select s.Name,C.Cname from student_score as sc left join student as s on s.Sno=sc.Sno left join score as c on c.Cno=sc.Cno
 
select C_name,grade from student left join score on student.Num=score.Stu_id where name=‘李五一’;
 红色部分即中间表，是集合两表所有内容的一张总表。
 
五、UNION操作符用于合并两个或多个select语句的结果集。
 
UNION内部的SELECT语句必须拥有相同数量的列，每个列也必须拥有相似的数据类型，每条SELECT语句中的列的顺序必须相同。
 
select Num from student union select Stu_id from score;
 union操作符是默认查重的，如果允许重复的值，就可以使用union all 。对于两张结构相同的表，union也可以把他们合并成一张表：
 
select * from student1 union select *from student2;
 六、子查询
 
有时候，查询时需要的条件是另外一个select语句的结果，就会使用到子查询。
 
1.带IN关键字的子查询
 
SQL语句：select * from student where Num IN(select Stu_id from score);
 
2.带EXISTS关键字的子查询
 
exists内查询返回一个真价值，若返回true时，外查询进行查询，否则外查询不进行查询。
 
SQL语句：select * from student where exists(select * from score where C_name=‘计算机’);
 
3.带ANY关键字的子查询
 
使用ANY关键字只要有一个满足，就通过该条件来执行外查询。
 
SQL语句：select sname,(date_format(from_days(now())-to_days(birthday)),’%Y’)+0) as ‘年龄’ from student where birthday>ANY(select birthday from student where bumen=‘计算机系’);
 
4.带ALL关键字的子查询
 
使用ALL关键字必须满足所有的内层查询语句返回的所有结果，才执行外查询
 
SQL语句：select sname,(date_format(from_days(now())-to_days(birthday)),’%Y’)+0) as ‘年龄’ from student where birthday>ALL(select birthday from student where bumen=‘计算机系’);

           多表查询就是在一条查询语句中，从多张表里一起取出所需的数据，如果要想进行多表查询，直接在FROM子句之后跟上多个表即可，此时的语法如下：
 
select [DISTINCT]*|列名称[AS][列别名]，列名称[AS][列别名],...FROM 表名称1[表别名]，表名称2[表别名2]...
 
[WHERE 条件（S）]
 
[ORDER BY 排序的字段1 ASC|DESC,排序的字段1 ASC|DESC...];
 
例：查询emp,dept两张表的数据
 
select * from emp,dept
 
 
 
 
从上表中可以看到，一共返回了39条数据，而且可以看到，有很多数据重复的。这些数据就是笛卡尔积造成的。在进行多表连接查询的时候，由于数据库内部的处理机制，会产生一些“无用”的数据，而这些数据就称为笛卡尔积。
 
 
 
--消除笛卡尔积
 
select *
 
from emp,dept
 
where emp.deptno = dept.deptno;
 
 
 
 
一般而言，如果要想进行笛卡尔积的消除，往往会使用关联字段。由于多张表之间可能会有重名的字段，所以在进行重名字段访问的时候，前面需要加上表名称。采用“表名称.字段”的方式来进行访问。
 
--多表查询范例：
 
--查询每个雇员编号、姓名、职位、基本工资、部门名称、部门位置信息
 
select emp.empno,emp.ename,emp.job,emp.sal,dept.dname,dept.loc
 
from emp,dept
 
where emp.deptno = dept.deptno;
 
 
 
 
步骤：
 
确定所需要的数据表：
 
emp:查询每个雇员的编号，姓名，职位，基本工资
 
dept表：部门名称，部门位置。
 
确定一致的关联字段：
 
部门与雇员关联：emp.deptno = dept.deptno
 
随后还需要按照一个SQL语法编写
 
 
 
多表查询别名定义：
 
--查询出每个雇员的编号、姓名、基本工资、工资等级
 
select e.empno,e.ename,e.sal,s.grade
 
from emp e,salgrade s
 
where e.sal BETWEEN s.losal AND s.hisal;
 
 
 
 
--为了更加清楚的显示处工资等级的信息，现在希望可以按如下格式进行替换显示：
 
--grade = 1:显示为“E等工资”
 
--grade = 2:显示为“D等工资”
 
--grade = 3:显示为“C等工资”
 
--grade = 4:显示为“B等工资”
 
--grade = 5:显示为“A等工资”
 
 
 
select e.empno,e.ename,e.sal,
 
DECODE(s.grade,1,'E等工资',2,'D等工资',3,'C等工资',4,'B等工资',5,'A等工资') grade
 
from emp e,salgrade s
 
where e.sal BETWEEN s.losal AND s.hisal;
 
 
 
 
--查询两张以上的表
 
--例：查询每个雇员的姓名，职位，基本工资，部门名称，工资等级
 
确定所需的数据表：
 
--emp表：每个雇员的姓名、职位、基本工资；
 
--dept表：部门名称
 
--salgrade:工资等级：
 
--确定一致的关联字段：
 
--雇员和部门：emp.deptno = dept.deptno
 
--雇员和工资等级：emp.sal BETWEEN salgrade.losal AND salgrade.hisal
 
 
 
select e.ename,e.job,e.sal,d.dname,
 
DECODE(s.grade,1,'E等工资',2,'D等工资',3,'C等工资',4,'B等工资',5,'A等工资') grade
 
from emp e,dept d,salgrade s
 
where e.deptno = d.deptno AND e.sal BETWEEN s.losal AND s.hisal;
 
 
 
 
注：多表查询之中，每当增加一个关联表都需要设置消除笛卡尔积的条件。