Specifications动态查询
* 继承了JpaSpecificationExecutor<T>中的方法
//根据条件查询一个对象
T findOne(Specification<T> spec);
//根据条件查询集合
List<T> findAll(Specification<T> spec);
//根据条件分页查询
Page<T> findAll(Specification<T> spec, Pageable pageable);
//排序查询查询
List<T> findAll(Specification<T> spec, Sort sort);
//统计查询
long count(Specification<T> spec);
* Specification:查询条件
自定义我们自己的Specification实现类
实现
1. root:查询的根对象(查询的任何属性都可以从根对象中获取)
2. CriteriaQuery:顶层查询对象,自定义查询方式(了解即可,一般不使用)
3. CriteriaBuilder:查询构造器,封装了很多的查询条件
Predicate toPredicate(Root<T> root,CriteriaQuery<?> query,CriteriaBuilder cb);
* 代码
@Test
public void testEquals(){
Customer c = dao.findOne(new Specification<Customer>() {
public Predicate toPredicate(Root<Customer> root, CriteriaQuery<?> criteriaQuery, CriteriaBuilder criteriaBuilder) {
Path<Object> custId = root.get("custId");
Predicate predicate = criteriaBuilder.equal(custId, 1l);
return predicate;
}
});
System.out.println(c);
}
/**
* testNoAsString
* 在path写上String就不用再写as.(String.class)
*
*/
@Test
public void testNoAsString() throws Exception{
Customer customer = dao.findOne(new Specification<Customer>() {
public Predicate toPredicate(Root<Customer> root, CriteriaQuery<?> criteriaQuery, CriteriaBuilder criteriaBuilder) {
Path<String> custName = root.get("custName");
Predicate predicate = criteriaBuilder.like(custName, "ha%");
return predicate;
}
});
System.out.println(customer);
}
/**
* 测试分页查询
* Pageable
*/
@Test
public void testPageSelect()throws Exception{
Page<Customer> page = dao.findAll(new PageRequest(0, 5));
//返回的总页数
System.out.println(page.getTotalPages());
//返回的总记录数
System.out.println(page.getTotalElements());
//返回的内容集合
System.out.println(page.getContent());
}
/**
* 排序查询
*/
@Test
public void testSortSelect() throws Exception{
//倒序查询,根据custId属性倒序
List<Customer> list = dao.findAll(new Sort(Sort.Direction.DESC,"custId"));
for (Customer customer : list) {
System.out.println(customer);
}
}多表之间的关系和操作多表的操作步骤
表关系:
一对一
主键映射(两个表的主键相同),外键映射(在一个表中设置外键来对应另一张表的主键)
一对多
一的一方:主表
多的一方:从表
外键:需要在从表上新建一列作为外键,取值来源于主表的主键
多对多
中间表:至少有两个字段组成
实体类中的关系:
包含关系:可以通过实体类中的包含关系描述表关系
继承关系:
步骤:
1. 明确表关系
2. 确定表关系(描述:外键|中间表)
3. 编写实体类,在实体类中描述表关系(包含|继承)
4. 配置映射关系多表操作练习
* 一般我们不会进行双向关联,只会保存可以维护中间表/外键的一方
1. 一对多:
1. 建立表之间的关联关系(实体类之间的关系)
Customer(一的一方)
//配置一对多的关系
//@OneToMany(targetEntity = LinkMan.class)
//@JoinColumn(name = "lkm_cust_id",referencedColumnName = "cust_id")
//放弃维护外键(一般一的一方会放弃外键的维护)
@OneToMany(mappedBy = "customer")
private Set<LinkMan> linkmans = new HashSet<LinkMan>();
linkman(多的一方)
//配置一对多关系
/@ManyToOne(targetEntity = Customer.class)
//配置级联操作,一般级联不会配置到一的一方,太危险,会把所有对应的多都删除
@ManyToOne(targetEntity = Customer.class,cascade = CascadeType.ALL)
@JoinColumn(name = "lkm_cust_id",referencedColumnName = "cust_id")
private Customer customer;
2. 测试类
@Autowired
private ICustomerDao customerDao;
@Autowired
private ILinkmanDao linkmanDao;
//保存
@Test
public void testAdd() throws Exception{
Customer customer = new Customer();
customer.setCustName("test222");
LinkMan linkMan = new LinkMan();
linkMan.setLkmName("testl222");
linkMan.setCustomer(customer);
//只需要在维护外键的一方告诉关系即可保存维护外键
customerDao.save(customer);
linkmanDao.save(linkMan);
}
/**
* 级联删除
*/
@Test
@Transactional
@Rollback(value = false)
public void testCascadeDelete()throws Exception{
linkmanDao.delete(4l);
}
2. 多对多
1. 建立表之间的关联关系(实体类之间的关系)
SysUser
//配置多对多关系
@ManyToMany(targetEntity = SysRole.class,cascade = CascadeType.ALL)
@JoinTable(name = "user_role_rel",
joinColumns = {@JoinColumn(name = "user_id",referencedColumnName = "user_id")},
inverseJoinColumns = {@JoinColumn(name = "role_id",referencedColumnName = "role_id")}
)
private Set<SysRole> roles = new HashSet<>();
SysRole
//配置多对多关系,并放弃外键/表的维护
@ManyToMany(mappedBy = "roles")
private Set<SysUser> users = new HashSet<>();
2. 测试类
@Autowired
private ISysRoleDao roleDao;
@Autowired
private ISysUserDao userDao;
//保存
@Test
public void testAdd() throws Exception{
SysUser user = new SysUser();
user.setUserName("haha");
SysRole role = new SysRole();
role.setRoleName("hehe");
//在一方进行外键/表维护
user.getRoles().add(role);
userDao.save(user);
roleDao.save(role);
}
//删除,没有级联
@Test
@Transactional
@Rollback(value = false)
public void testDelete() throws Exception{
userDao.delete(2l);
}
3. 关于删除
* 有从表数据
1、在默认情况下，它会把外键字段置为null，然后删除主表数据。如果在数据库的表结构上，外键字段有非空约束，默认情况就会报错了。
2、如果配置了放弃维护关联关系的权利，则不能删除（与外键字段是否允许为null,没有关系）因为在删除时，它根本不会去更新从表的外键字段了。
3、如果还想删除，使用级联删除引用
* 没有从表数据引用：随便删
* 在多对多时候,级联删除最好不要配置,如果配了的话，如果数据之间有相互引用关系，可能会清空所有数据对象导航查询
对象图导航检索方式是根据已经加载的对象，导航到他的关联对象。它利用类与类之间的关系来检索对象。
例如：我们通过ID查询方式查出一个user，可以调用user类中的getroles()方法来获取该用户的角色。
对象导航查询的使用要求是：两个对象之间必须存在关联关系。
简单理解:就是查询对象后通过.getXxx来调用有关联关系的属性
//对象导航查询
@Test
@Transactional
public void testObjectmap() throws Exception{
SysUser user = userDao.findOne(5l);
Set<SysRole> roles = user.getRoles();
System.out.println(roles);
}Specification的多表查询
//创建的过程中，第一个参数为关联对象的属性名称，第二个参数为连接查询的方式（left，inner，right）
//JoinType.LEFT : 左外连接,JoinType.INNER：内连接,JoinType.RIGHT：右外连接
//使用Specification的多表查询
@Test
@Transactional
public void testSpec(){
SysUser user = userDao.findOne(new Specification<SysUser>() {
@Override
public Predicate toPredicate(Root<SysUser> root, CriteriaQuery<?> criteriaQuery, CriteriaBuilder criteriaBuilder) {
Join<SysUser, SysRole> join = root.join("roles", JoinType.LEFT);
return criteriaBuilder.like(join.get("roleName").as(String.class), "he%");
}
});
Set<SysRole> roles = user.getRoles();
System.out.println(roles);
}
* roles,表示查询中当前类中的外键属性,后面的条件是对外连接表中条件的查询
* 也可以继续写root.xx,并对root条件限制,root代表的是本类的查询条件,join是连接表的插叙条件
Jpql的多表查询
在接口中重写方法,并使用@query注解
如:
@Query("select c from Customer c left outer join c.linkMans m where m.lkmId = 3")
List<Customer> getCustomerByLink();本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
