回顾
-
springDataJpa ,Jpa规范,hibernate三者之间的关系
-
符合SpringDataJpa规范的dao层接口的编写规则
-
需要实现两个接口(JpaRepository,JapSpecificationExecutor)
-
提供相应的泛型
-
运行过程
- 动态代理的方式: 动态代理对象
-
查询
-
本篇内容
- Specification动态查询
- 多表之间的关系和操作多表的操作步骤
- 完成多表操作
- 一对多操作
- 多对多操作
Specifications 动态查询
1. 方法列表
-
查询条件
-
与JPQL相比的优势:
- 更加安全
- 更加面向对象
-
JpaSpecificationExecutor:
- 对于 JpaSpecificationExecutor,这个接口基本是围绕着 Specification 接口来定义的。我们可以简单的理解为,Specification 构造的就是查询条件。
-
方法对应关系图:
多表之前的关系和操作多表的操作步骤
-
表关系
-
一对一
-
一对多
- 一的一方: 主表
- 多的一方: 从表
- 外键: 需要再从表上新建一列作为外键,它的取值来源于主表的主键
-
多对多
- 中间表:中间表中最少应该由两个字段组成,这两个字段作为外键指向两张表的主键,又组成了联合主键;
-
-
关系图:
-
实体类中的关系
- 包含关系
- 可以通过实体类中的包含关系描述表述表关系
- 继承关系
- 包含关系
-
分析步骤:
- 明确表关系
- 如果关系确定错了,后面做的所有操作就都不可能正确。
- 确定表关系(描述 外键|中间表)
- 编写实体类,在实体类中描述表关系(包含关系)
- 配置映射关系
- 明确表关系
一对多操作
1. 一对多操作
* 案例: 客户和联系人的案例
1. 客户: 一家公司
2. 联系人: 这家公司的员工
* 分析:
1. 一个客户可以用具有多个联系人
2. 一个联系人从属于一家公司
2. 分析步骤:
1. 明确表关系
* 一对多关系
2. 确定表关系(描述 外键|中间表)
* 主表:客户表
* 从表: 联系人表
3. 编写实体类,在实体类中描述表关系(包含关系)
* 客户: 在客户的实体类中包含一个联系人的集合
* 联系人: 在联系人的实体类中包含一个客户的对象
4. 配置映射关系
* 使用jpa注解配置一对多映射关系;
5. 注意:
* 在表的关系中,客户表中包含了联系人表,所以在客户实体类中表也必须包含联系人实体类表,应该先建立两个类,并处理好两个类之间的关系;
* 在构建多对一的时候,需要配置两个实体类之间的关系,我们可以采取双向绑定的办法,
1. 主表类中包含从表类的集合(因为是一对多,所以从表数据肯定有很多个,所以需要用集合存储这些具体对象),还应该交代从表的外键id值和主表的id值的对应关系
2. 主表因为没有外键,从表是与主表通过从表的外键所关联的,所以从表如果想绑定主表,需要配置@ManyToOne注解,并且交代自己外键名称和主表的id值的对应关系,所以与上面的配置很多是一样的,但是一定要理解这个逻辑思维;
3. 级联:
1. 概念:
* 操作一个对象的同事操作他的关联对象
2. 级联操作:
1. 需要区分操作主体
2. 需要在操作主题的实体类上,添加级联属性(需要添加到多表映射关系的注解上)
3. 案例:
1. 级联添加:
* 当我保存一个客户的同时保存联系人
2. 级联删除:
* 当我删除一个客户的同时删除此客户的所有联系人
一对多种映射注解的说明
1. @OneToMany:
* 作用:建立一对多的关系映射
* 属性:
targetEntityClass:指定多的多方的类的字节码
mappedBy:指定从表实体类中引用主表对象的名称。
cascade:指定要使用的级联操作
fetch:指定是否采用延迟加载
orphanRemoval:是否使用孤儿删除
2. @ManyToOne
* 作用:建立多对一的关系
* 属性:
targetEntityClass:指定一的一方实体类字节码
cascade:指定要使用的级联操作
fetch:指定是否采用延迟加载
optional:关联是否可选。如果设置为 false,则必须始终存在非空关系
3. @JoinColumn
* 作用:用于定义主键字段和外键字段的对应关系。
* 属性:
name:指定外键字段的名称
referencedColumnName:指定引用主表的主键字段名称
unique:是否唯一。默认值不唯一
nullable:是否允许为空。默认值允许。
insertable:是否允许插入。默认值允许。
updatable:是否允许更新。默认值允许。
columnDefinition:列的定义信息。
一对多种的删除操作说明:
1. 删除从表数据:可以随时任意删除。
2. 删除主表数据:
1. 有从表数据
* 在默认情况下,它会把外键字段置为 null,然后删除主表数据。如果在数据库的表结构上,外键字段有非空约束,默认情况就会报错了。
* 如果配置了放弃维护关联关系的权利,则不能删除(与外键字段是否允许为 null, 没有关系)因为在删除时,它根本不会去更新从表的外键字段了。
* 如果还想删除,使用级联删除引用
2. 没有从表数据引用:随便删
3. 注意: 在实际开发中,级联删除请慎用!(在一对多的情况下)
多对多操作
1. 案例: 用户和角色(多对多关系)
1. 用户:用户是一个人
2. 角色:角色是对用户的一个程序
2. 分析步骤:
1. 明确表关系
* 多对多关系
2. 确定表关系(描述 外键|中间表)
* 中间间表
3. 编写实体类,在实体类中描述表关系(包含关系)
* 用户: 包含角色的集合
* 角色: 包含用户的集合
4. 配置映射关系
3. 图示多对多关系:
![](https://i.imgur.com/hdnHrAu.png)
多对多中注解映射的说明
1. @ManyToMany
* 作用:用于映射多对多关系
* 属性:
cascade:配置级联操作。
fetch:配置是否采用延迟加载。
targetEntity:配置目标的实体类。映射多对多的时候不用写。
2. @JoinTable
* 作用:针对中间表的配置
* 属性:
nam:配置中间表的名称
joinColumns:中间表的外键字段关联当前实体类所对应表的主键字段
inverseJoinColumn:中间表的外键字段关联对方表的主键字段
3. @JoinColumn
* 作用:用于定义主键字段和外键字段的对应关系。
* 属性:
name:指定外键字段的名称
referencedColumnName:指定引用主表的主键字段名称
unique:是否唯一。默认值不唯一
nullable:是否允许为空。默认值允许。
insertable:是否允许插入。默认值允许。
updatable:是否允许更新。默认值允许。
columnDefinition:列的定义信息。
4. 注意:
* 在多对多(保存)中,如果双向都设置关系,意味着双方都维护中间表,都会往中间表插入数据,中间表的 2 个字段又作为联合主键,所以报错,主键重复,解决保存失败的问题:只需要在任意一方放弃对中间表的维护权即可,推荐在被动的一方放弃,配置如下:
//放弃对中间表的维护权,解决保存中主键冲突的问题:
@ManyToMany(mappedBy="roles")
private Set<SysUser> users = new HashSet<SysUser>(0);
多表的查询--------对象导航查询
1. 概念:
* 对象图导航检索方式是根据已经加载的对象,导航到他的关联对象。它利用类与类之间的关系来检索对象。例如:我们通过 ID 查询方式查出一个客户,可以调用 Customer 类中的 getLinkMans()方法来获取该客户的所有联系人。对象导航查询的使用要求是:两个对象之间必须存在关联关系。
2. 案例:
* 客户和联系人(一对多,多对一,具有代表性)
3. 总结:
1. 一对多:
* 默认使用延迟加载
2. 多对一:
* 默认使用立即加载
实战代码:
pom.xml
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>cn.itcast</groupId>
<artifactId>jpa-day3-many-to-many</artifactId>
<version>1.0-SNAPSHOT</version>
<properties>
<spring.version>5.0.2.RELEASE</spring.version>
<hibernate.version>5.0.7.Final</hibernate.version>
<slf4j.version>1.6.6</slf4j.version>
<log4j.version>1.2.12</log4j.version>
<c3p0.version>0.9.1.2</c3p0.version>
<mysql.version>5.1.6</mysql.version>
</properties>
<dependencies>
<!-- junit单元测试 -->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<scope>test</scope>
</dependency>
<!-- spring beg -->
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.6.8</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-aop</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context-support</artifactId>
<version>${spring.version}</version>
</dependency>
<!--Spring 对orm 框架的支持包-->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-orm</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-beans</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-core</artifactId>
<version>${spring.version}</version>
</dependency>
<!-- spring end -->
<!-- hibernate beg -->
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-core</artifactId>
<version>${hibernate.version}</version>
</dependency>
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-entitymanager</artifactId>
<version>${hibernate.version}</version>
</dependency>
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-validator</artifactId>
<version>5.2.1.Final</version>
</dependency>
<!-- hibernate end -->
<!-- c3p0 beg -->
<dependency>
<groupId>c3p0</groupId>
<artifactId>c3p0</artifactId>
<version>${c3p0.version}</version>
</dependency>
<!-- c3p0 end -->
<!-- log end -->
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>${log4j.version}</version>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-api</artifactId>
<version>${slf4j.version}</version>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-log4j12</artifactId>
<version>${slf4j.version}</version>
</dependency>
<!-- log end -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>${mysql.version}</version>
</dependency>
<!--SpringDataJpa 的坐标-->
<dependency>
<groupId>org.springframework.data</groupId>
<artifactId>spring-data-jpa</artifactId>
<version>1.9.0.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-test</artifactId>
<version>${spring.version}</version>
</dependency>
<!-- el beg 使用spring data jpa 必须引入 -->
<dependency>
<groupId>javax.el</groupId>
<artifactId>javax.el-api</artifactId>
<version>2.2.4</version>
</dependency>
<dependency>
<groupId>org.glassfish.web</groupId>
<artifactId>javax.el</artifactId>
<version>2.2.4</version>
</dependency>
<!-- el end -->
</dependencies>
</project>
Role实体映射类:
package cn.itcast.domain;
import javax.persistence.*;
import java.util.HashSet;
import java.util.Set;
/**
* User
* hasee
* 2018/12/19
* 11:49
*
* @Version 1.0
**/
@Entity //@Entity说明这个class是实体类,并且使用默认的orm规则,即class名即数据库表中表名,class字段名即表中的字段名
@Table(name="sys_role") //建立映射关系
public class Role {
@Id
@GeneratedValue(strategy=GenerationType.IDENTITY)
@Column(name="role_id")
private Long roleId;
@Column(name="role_name")
private String roleName;
//配置多对多
// @ManyToMany(targetEntity=User.class) //配置多表关系,这里面要写另外一个的字节码文件
// @JoinTable(name="sys_user_role", //文件名
// //joinColumn:当前对象在中间表中的外键
// joinColumns={@JoinColumn(name="sys_role_id", referencedColumnName="role_id")},
// //inverseJoinColumns,对方对象在中间表的外键
// inverseJoinColumns={@JoinColumn(name="sys_user_id", referencedColumnName="user_id")}
// )
@ManyToMany(mappedBy = "roles") //配置多表关系
private Set<User> users=new HashSet<User>();
public Set<User> getUsers() {
return users;
}
public void setUsers(Set<User> users) {
this.users=users;
}
public Long getRoleId() {
return roleId;
}
public void setRoleId(Long releId) {
this.roleId=releId;
}
public String getRoleName() {
return roleName;
}
public void setRoleName(String roleName) {
this.roleName=roleName;
}
}
User实体映射类
package cn.itcast.domain;
import javax.persistence.*;
import java.util.HashSet;
import java.util.Set;
/**
* User
* hasee
* 2018/12/19
* 11:57
*
* @Version 1.0
**/
@Entity
@Table(name="sys_user")
public class User {
@Id
@GeneratedValue(strategy=GenerationType.IDENTITY)
@Column(name="user_id")
private Long userId;
@Column(name="user_name")
private String username;
@Column(name="user_age")
private Integer age;
/*
* 配置多对多的映射关系
* 1. 声明表关系的配置
* @ManyToMany(targetEntity=Role.class) //多对多
* targetEntity: 代表对方的实体类字节码
* 2. 配置中间表(包含两个外键)
* @JoinTable
* name:中间表的名称
* joinColumns:配置当前对象在中间表的外键
* @JoinColumn的数组
* name:外键名
* referencedColumnName: 参照的主表的主键名
* inverseJoinColumns: 配置对方对象在中间表的外键
* 3. 这里的@JoinTable相当于创建了一个中间表,它里面包含了两个类的外键,通过外键将两个实体类或者两个表关联起来,
* 形成了多对多的关系;
* */
@ManyToMany(targetEntity=Role.class,cascade = CascadeType.ALL)
@JoinTable(name="sys_user_role",
//joinColumns,当前对象在中间表中的外键
joinColumns={@JoinColumn(name="sys_user_id", referencedColumnName="user_id")},
//inverseJoinColumns,对方对象在中间表中的外键
inverseJoinColumns={@JoinColumn(name="sys_role_id", referencedColumnName="role_id")}
)
private Set<Role> roles=new HashSet<Role>();
public Set<Role> getRoles() {
return roles;
}
public void setRoles(Set<Role> roles) {
this.roles=roles;
}
public Long getUserId() {
return userId;
}
public void setUserId(Long userId) {
this.userId=userId;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username=username;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age=age;
}
}
RoleDao接口
package cn.itcast.dao;
import cn.itcast.domain.Role;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
public interface RoleDao extends JpaRepository<Role,Long> ,JpaSpecificationExecutor<Role>{
}
UserDao接口
package cn.itcast.dao;
import cn.itcast.domain.User;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
public interface UserDao extends JpaRepository<User,Long> ,JpaSpecificationExecutor<User> {
}
applicationContext.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:jdbc="http://www.springframework.org/schema/jdbc"
xmlns:tx="http://www.springframework.org/schema/tx"
xmlns:jpa="http://www.springframework.org/schema/data/jpa"
xmlns:task="http://www.springframework.org/schema/task"
xsi:schemaLocation="
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/jdbc
http://www.springframework.org/schema/jdbc/spring-jdbc.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx.xsd
http://www.springframework.org/schema/data/jpa
http://www.springframework.org/schema/data/jpa/spring-jpa.xsd">
<!--spring和Spring data jpa的配置-->
<!--1. 创建entityManagerFactory对象交给spring容器管理-->
<bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
<property name="dataSource" ref="dataSource"/>
<!--配置的扫描的包(实体类所在的包)-->
<property name="packagesToScan" value="cn.itcast.domain"/>
<!--jpa的实现厂家-->
<property name="persistenceProvider">
<bean class="org.hibernate.jpa.HibernatePersistenceProvider"/>
</property>
<!--jpa的供应商适配器-->
<property name="jpaVendorAdapter">
<bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter">
<!-- 配置是否自动创建数据库表-->
<property name="generateDdl" value="false"/>
<!--指定数据库类型-->
<property name="database" value="MYSQL"/>
<!--数据库特有方言:支持特有语法-->
<property name="databasePlatform" value="org.hibernate.dialect.MySQLDialect"/>
<!--是否显示sql-->
<property name="showSql" value="true"/>
</bean>
</property>
<!--jpa的方言:高级的特性-->
<property name="jpaDialect">
<!--这里是jpa实现了hibernate,所以SpringData jpa默认也继承了hibernate 的一些高级特性,如一级缓存二级缓存等..-->
<bean class="org.springframework.orm.jpa.vendor.HibernateJpaDialect"/>
</property>
<!--
注入jpa的配置信息
加载jpa的基本信息和Jpa的实现方式(hibernate)的配置信息
hibernate.hbm2ddl.auto:自动创建数据库表
1. create: 每次都会重新创建数据库表
2. update: 有表不会重新创建,没有表会重新创建表
-->
<property name="jpaProperties">
<props>
<!--这里值可以为create: 每次删除原表然后创建新表-->
<!--update: 可以使用这个进行删除数据等操作,就可以不用重新创建表了-->
<prop key="hibernate.hbm2ddl.auto">update</prop>
</props>
</property>
</bean>
<!--2. 创建数据库连接池-->
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
<property name="user" value="root"></property>
<property name="password" value="root"></property>
<property name="jdbcUrl" value="jdbc:mysql:///jpa"></property>
<property name="driverClass" value="com.mysql.jdbc.Driver"></property>
</bean>
<!--3. 整合spring data jpa-->
<jpa:repositories base-package="cn.itcast.dao" transaction-manager-ref="transactionManager"
entity-manager-factory-ref="entityManagerFactory"></jpa:repositories>
<!--4. 配置事务管理器-->
<bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
<property name="entityManagerFactory" ref="entityManagerFactory"></property>
</bean>
<!--5. 声明式事务-->
<!--6. 配置包扫描-->
<context:component-scan base-package="cn.itcast"></context:component-scan>
</beans>
ManyToManyTest
package cn.itcast.test;
import cn.itcast.dao.RoleDao;
import cn.itcast.dao.UserDao;
import cn.itcast.domain.Role;
import cn.itcast.domain.User;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.annotation.Rollback;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.transaction.annotation.Transactional;
/**
* ManyToManyTest
* hasee
* 2018/12/19
* 14:55
*
* @Version 1.0
**/
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:applicationContext.xml")
public class ManyToManyTest {
@Autowired
private UserDao userDao;
@Autowired
private RoleDao roleDao;
/*
* 保存一个用户,保存一个角色
*
* 多对多放弃维护权: 被动的一方放弃
* */
@Test
@Transactional
@Rollback(false)
public void testAdd(){
User user=new User();
user.setUsername("小李");
Role role=new Role();
role.setRoleName("java程序员");
/*
* 因为这两个都可以对外键进行维护,如果两个同时配置了维护,必须其中有一个放弃维护权
*
* */
//配置用户到角色关系,可以对中间表中数据进行维护
user.getRoles().add(role);
//配置角色到用户的关系,可以对中间表的数据进行维护
role.getUsers().add(user);
userDao.save(user);
roleDao.save(role);
}
/*
*
* 级联添加
*
* */
@Test
@Transactional
@Rollback(false)
public void testAdd2(){
User user=new User();
user.setUsername("叶修");
Role role=new Role();
role.setRoleName("大神");
//共同操作外键,但role已经放弃了维护权力
user.getRoles().add(role);
/*
* 下面这句是操作外键的,可以不用添加也可以完成保存操作
* 这个注解是放弃了维护外键,可以使用也可以不使用,当两个维护外键的代码同时存在的时候,就需要这个了;
* @ManyToMany(mappedBy = "roles") //配置多表关系
*
* cascade = CascadeType.ALL
* 这个注解里面加上了这句话代表了允许级联操作,就表示与他一起的从表将会一起添加数据;
*
* */
// role.getUsers().add(user);
userDao.save(user);
}
/*
* 级联删除
* 案例:删除id为1 的用户,同时也删除它的关联对象
*
* */
@Test
@Transactional
@Rollback(false)
public void testCasCadeRemove(){
//1. 查询1 号用户
User user=userDao.findOne(1l);
//2. 删除1号用户
userDao.delete(user);
}
}
对象查询代码
- 注意:
- 这里的对象查询代码是以一对多为原型的,这样具有代表性;
- 配置文件和dao层,domain文件请参照前两天的一对多相关文件,为避免本来就很臃肿的界面,这里仅提供测试类:
package cn.itcast.test;
import cn.itcast.dao.CustomerDao;
import cn.itcast.dao.LinkManDao;
import cn.itcast.domain.Customer;
import cn.itcast.domain.LinkMan;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.transaction.annotation.Transactional;
import java.util.Set;
/**
* ObjectQueryTest
* hasee
* 2018/12/19
* 15:54
*
* @Version 1.0
**/
/*
* 测试对象导航查询
*
*
* */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:applicationContext.xml")
public class ObjectQueryTest {
@Autowired
private CustomerDao customerDao;
@Autowired
private LinkManDao linkManDao;
//could no initialize proxy -no Session 没有添加事务--> 添加注解@Transactional
// 测试对象导航查询
@Test
@Transactional
public void testQuery1(){
//查询id为1的客户
Customer customer=customerDao.getOne(3l);
Set<LinkMan> list=customer.getLinkMans();
for (LinkMan linkMan : list) {
System.out.println(linkMan);
}
}
/*
* 立即加载的查询id值为1的公司的员工表长度
* 对象导航查询
* 默认使用的是延迟加载的形式查询的
* 调用get方法并不会立即发送查询,而是在使用关联对象的时候才会查询
*
* 延迟加载!
* 修改配置,将延迟加载改为立即加载
* fetch: 需要配置到多表映射关系的注解上;
* */
@Test
@Transactional
public void testQuery2(){
Customer customer=customerDao.findOne(3l);
Set<LinkMan> linkMans=customer.getLinkMans();
System.out.println(linkMans.size());
}
/*
* 从联系人对象导航查询他的所属客户
*
* 注意:如下方所示案例一样
* 1. 在查询所有多对一数据的时候,默认:立即加载
* 2. 在查询所有一对多数据的时候,默认: 延迟加载
* 3. 在查询的时候如果需要修改默认机制:在所在映射类上的相关地方添加注解fetch...设置加载机制
* 4. 一般情况下,一对多适合延迟加载,多对一适合立即加载!
*
*
*
* */
@Test
@Transactional
public void testQuery3(){
LinkMan linkMan=linkManDao.findOne(3l);
//对象导航查询所属的客户
Customer customer=linkMan.getCustomer();
System.out.println(customer);
}
}