Spring Data JPA之多表关系与多表查询（四）

最新推荐文章于 2024-07-29 11:02:40 发布

CodeDevMaster

最新推荐文章于 2024-07-29 11:02:40 发布

阅读量239

点赞数

分类专栏： # Spring Data JPA 文章标签： jpa

本文链接：https://blog.csdn.net/qq_38628046/article/details/108692635

版权

Spring Data JPA 专栏收录该内容

4 篇文章 1 订阅

订阅专栏

一、添加依赖

 <properties>
        <spring.version>5.2.8.RELEASE</spring.version>
        <hibernate.version>5.4.3.Final</hibernate.version>
        <slf4j.version>1.7.30</slf4j.version>
        <log4j.version>1.2.17</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>


        <!-- hibernate核心包 -->
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-core</artifactId>
            <version>${hibernate.version}</version>
        </dependency>
        <!--hibernate对jpa实现包-->
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-entitymanager</artifactId>
            <version>${hibernate.version}</version>
        </dependency>
        <!--hibernate的校验包-->
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-validator</artifactId>
            <version>${hibernate.version}</version>
        </dependency>


        <!-- c3p0连接池-->
        <dependency>
            <groupId>c3p0</groupId>
            <artifactId>c3p0</artifactId>
            <version>${c3p0.version}</version>
        </dependency>

        <!-- log相关 -->
        <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>


        <!--MYsql驱动-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>${mysql.version}</version>
        </dependency>

        <!-- spring data jpa-->
        <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>

        <!-- 使用spring data jpa 必须引入 -->
        <dependency>
            <groupId>javax.el</groupId>
            <artifactId>javax.el-api</artifactId>
            <version>3.0.0</version>
        </dependency>

        <dependency>
            <groupId>org.glassfish.web</groupId>
            <artifactId>javax.el</artifactId>
            <version>2.2.4</version>
        </dependency>
    </dependencies>

二、Spring Data JPA与Spring整合

<?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的配置-->

    <!-- 创建entityManagerFactory对象交给spring容器管理-->
    <bean id="entityManagerFactoty" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
        <property name="dataSource" ref="dataSource" />
        <!--配置扫描的包（实体类所在的包） -->
        <property name="packagesToScan" value="cn.ybzy.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" >
            <bean class="org.springframework.orm.jpa.vendor.HibernateJpaDialect" />
        </property>

	     <!--注入jpa的配置信息
            加载jpa的基本配置信息和jpa实现方式（hibernate）的配置信息
            hibernate.hbm2ddl.auto : 自动创建数据库表
                create ： 每次都会重新创建数据库表
                update：有表不会重新创建，没有表会重新创建表
        -->
        <property name="jpaProperties" >
            <props>
                <prop key="hibernate.hbm2ddl.auto">create</prop>
            </props>
        </property>

    </bean>

    <!--创建数据库连接池 -->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="user" value="root"></property>
        <property name="password" value="123456"></property>
        <property name="jdbcUrl" value="jdbc:mysql:///jpa" ></property>
        <property name="driverClass" value="com.mysql.jdbc.Driver"></property>
    </bean>

    <!--整合spring dataJpa-->
    <jpa:repositories base-package="cn.ybzy.dao" transaction-manager-ref="transactionManager"
                   entity-manager-factory-ref="entityManagerFactoty" ></jpa:repositories>

    <!--配置JPA事务管理器 -->
    <bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
        <property name="entityManagerFactory" ref="entityManagerFactoty"></property>
    </bean>

    <!-- txAdvice-->
    <tx:advice id="txAdvice" transaction-manager="transactionManager">
        <tx:attributes>
            <tx:method name="save*" propagation="REQUIRED"/>
            <tx:method name="insert*" propagation="REQUIRED"/>
            <tx:method name="update*" propagation="REQUIRED"/>
            <tx:method name="delete*" propagation="REQUIRED"/>
            <tx:method name="get*" read-only="true"/>
            <tx:method name="find*" read-only="true"/>
            <tx:method name="*" propagation="REQUIRED"/>
        </tx:attributes>
    </tx:advice>

    <!-- aop-->
    <aop:config>
        <aop:pointcut id="pointcut" expression="execution(* cn.itcast.service.*.*(..))" />
        <aop:advisor advice-ref="txAdvice" pointcut-ref="pointcut" />
    </aop:config>

    <!-- 配置包扫描-->
    <context:component-scan base-package="cn.ybzy" ></context:component-scan>
</beans>

```# 一、添加依赖

```java
在这里插入代码片

三、JPA中的一对多

确定两张表，客户Customer表与LinkMan联系人表。

一个Customer 客户有多个LinkMan联系人，表间关系为一对多。

习惯把一的一方称之为主表，把多的一方称之为从表。

在数据库中建立一对多关系时，需要使用数据库的外键约束，在从表中添加一列外键，取值参照主表的主键。

1.创建实体类以及映射配置

Customer实体类

@Entity
@Table(name="tb_customer")
public class Customer {

   @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name="cust_id")
    private Long custId;
    @Column(name="cust_name")
    private String custName;
    @Column(name="cust_phone")
    private String custPhone;
    @Column(name="cust_address")
    private String custAddress;

    /**
     * 配置客户和联系人之间的关系（一对多关系）
     * 
     * 使用注解的形式配置多表关系
     * 
     * @OneToMany: 申明表间关系（配置一对多关系）
     * 		targetEntity ： 对方对象的字节码
	 * 
	 * @JoinColumn：配置外键
	 * 		name：外键字段名称
	 *		referencedColumnName：参照的主表的主键字段名称
	 *	
	 *	在主表（一的一方）添加了外键了配置，所以对于从表（多的一方）而言，也具备了维护外键的作用
     */

    @OneToMany(targetEntity = LinkMan.class)
    @JoinColumn(name = "lkm_cust_id",referencedColumnName = "cust_id")
}

LinkMan实体类

@Entity
@Table(name = "tb_linkman")
public class LinkMan {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "lkm_id")
    private Long lkmId;
    @Column(name = "lkm_name")
    private String lkmName;
    @Column(name = "lkm_gender")
    private String lkmGender;
    @Column(name = "lkm_phone")
    private String lkmPhone;
    @Column(name = "lkm_email")
    private String lkmEmail;

    /**
     * 配置联系人到客户的多对一关系
     *    
     * @ManyToOne : 配置表间关系（多对一关系）
     *              targetEntity：对方的实体类字节码
     * 
     * @JoinColumn：配置外键
	 * 		name：外键字段名称
	 *		referencedColumnName：参照的主表的主键字段名称
     *
     *  外键配置到多的一方，就会在多的一方维护外键
     *
     */
    @ManyToOne(targetEntity = Customer.class,fetch = FetchType.LAZY)
    @JoinColumn(name = "lkm_cust_id",referencedColumnName = "cust_id")
    private Customer customer;
 }

3.映射的注解说明

@OneToMany:
作用：建立一对多的关系映射
属性：
	targetEntityClass：指定多的多方的类的字节码
	mappedBy：指定从表实体类中引用主表对象的名称。
	cascade：指定要使用的级联操作
	fetch：指定是否采用延迟加载
	orphanRemoval：是否使用孤儿删除

@ManyToOne
作用：建立多对一的关系
属性：
	targetEntityClass：指定一的一方实体类字节码
	cascade：指定要使用的级联操作
	fetch：指定是否采用延迟加载
	optional：关联是否可选。如果设置为false，则必须始终存在非空关系。

@JoinColumn
 作用：用于定义主键字段和外键字段的对应关系。
 属性：
	name：指定外键字段的名称
	referencedColumnName：指定引用主表的主键字段名称
	unique：是否唯一。默认值不唯一
	nullable：是否允许为空。默认值允许。
	insertable：是否允许插入。默认值允许。
	updatable：是否允许更新。默认值允许。
	columnDefinition：列的定义信息。

3.执行测试

1.单向一对多

    @Test
    @Transactional //配置事务
    @Rollback(false) //不自动回滚
    public void testAdd() {
        //创建一个客户，创建一个联系人
        Customer customer = new Customer();
        customer.setCustName("客户1");

        LinkMan linkMan = new LinkMan();
        linkMan.setLkmName("联系人1");

        /**
         * 配置客户到联系人的关系(单向一对多)
         * 
         * 会发送两条insert语句，发送一条更新语句更新数据库（更新外键）
         * 
         * 由于配置了客户到联系人的单向一对多关系：客户可以对外键进行维护
         */
        customer.getLinkMans().add(linkMan);

        customerDao.save(customer);
        linkManDao.save(linkMan);
    }

在这里插入图片描述

2.单向多对一

    @Test
    @Transactional //配置事务
    @Rollback(false) //不自动回滚
    public void testAdd1() {
        //创建一个客户，创建一个联系人
        Customer customer = new Customer();
        customer.setCustName("客户1");

        LinkMan linkMan = new LinkMan();
        linkMan.setLkmName("联系人1");

        /**
         * 配置联系人到客户的关系（单向多对一）
         * 
         * 只发送两条insert语句
         * 
         * 由于配置了联系人到客户的映射关系（多对一）,所以联系人也可以对外键进行维护
         *
         */
        linkMan.setCustomer(customer);

        customerDao.save(customer);
        linkManDao.save(linkMan);
    }

在这里插入图片描述

3.双向关系

    @Test
    @Transactional //配置事务
    @Rollback(false) //不自动回滚
    public void testAdd2() {
        //创建一个客户，创建一个联系人
        Customer customer = new Customer();
        customer.setCustName("客户1");

        LinkMan linkMan = new LinkMan();
        linkMan.setLkmName("联系人1");

		//由于配置了多的一方到一的一方的关联关系（当保存的时候，就已经对外键赋值）
        linkMan.setCustomer(customer);
        //由于配置了一的一方到多的一方的关联关系（发送一条update语句,此时该update语句是不需要的）
        customer.getLinkMans().add(linkMan);

        customerDao.save(customer);
        linkManDao.save(linkMan);
    }

在这里插入图片描述

设置双向关系之后，会发送两条insert语句，一条多余的update语句，解决方式:对一的一方放弃维护权。

4.放弃主表方的主键维护权

修改Customer实体类

 /**
     * 放弃外键维护权
     *      mappedBy：对方配置关系的属性名称
     * cascade : 配置级联（可以配置到设置多表的映射关系的注解上）
     *      CascadeType.all         : 所有
     *                  MERGE       ：更新
     *                  PERSIST     ：保存
     *                  REMOVE      ：删除
     *
     * fetch : 配置关联对象的加载方式
     *          EAGER   ：立即加载
     *          LAZY    ：延迟加载
     */
    @OneToMany(mappedBy = "customer",cascade = CascadeType.ALL)
    private Set<LinkMan> linkMans = new HashSet<>();

再次执行测试，发现放弃主键维护成功。

在这里插入图片描述

5.删除

@Test
	@Transactional
	@Rollback(false)
	public void testDelete() {
		customerDao.delete(1l);
	}

删除从表数据：可以随时任意删除。

删除主表数据：
		1.没有从表数据引用 ： 可以随时任意删除。
		
		2.有从表数据：
			1.在默认情况下，它会把外键字段置为null，然后删除主表数据。如果在数据库的表结构上，外键字段有非空约束，默认情况就会报错。
			
			2.如果配置了放弃维护关联关系的权利，则不能删除（与外键字段是否允许为null，没有关系）因为在删除时，它根本不会去更新从表的外键字段了。
			
			3.如果还想删除，需要使用级联删除引用

6.级联操作

修改User实体类映射关系，添加级联操作配置：

	 @OneToMany(mappedBy = "customer",cascade = CascadeType.ALL)

1.级联保存

级联添加：保存一个客户的同时，保存客户的所有联系人，需要在操作主体的实体类上，配置casacde属性。

    @Test
    @Transactional 
    @Rollback(false)
    public void testCascadeAdd() {
        Customer customer = new Customer();
        customer.setCustName("客户1");

        LinkMan linkMan = new LinkMan();
        linkMan.setLkmName("联系人1");

        linkMan.setCustomer(customer);
        customer.getLinkMans().add(linkMan);

        customerDao.save(customer);
    }

2.级联删除

级联删除：删除客户的同时，也会删除客户的所有联系人

    @Test
    @Transactional
    @Rollback(false) 
    public void testCascadeRemove() {
        Customer customer = customerDao.findOne(1l);
        customerDao.delete(customer);
    }

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:applicationContext.xml")
public class OneToManyTest {

    @Autowired
    private CustomerDao customerDao;

    @Autowired
    private LinkManDao linkManDao;
    
}

四、JPA中的多对多

确定两张表，用户User表与角色Role表。

一个用户User有多个角色Role，一个角色Role又对应多个User，所以表间关系为多对多。

多对多的表关系建立靠的是中间表，其中用户表和中间表的关系是一对多，角色表和中间表的关系也是一对多。

在数据库中建立一对多关系时，需要使用数据库的外键约束，在从表中（多的一方）添加一列外键，取值参照主表的主键。

1.创建实体类以及映射配置

Customer实体类

@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="age")
    private Integer age;

    /**
     * 配置用户到角色的多对多关系
     *      配置多对多的映射关系
     *          1.声明表关系的配置
     *              @ManyToMany(targetEntity = Role.class)  //多对多
     *                  targetEntity：代表对方的实体类字节码
     *          2.配置中间表（包含两个外键）
     *                @JoinTable
     *                  name : 中间表的名称
     *                  joinColumns：配置当前对象在中间表的外键
     *                      @JoinColumn的数组
     *                          name：外键名
     *                          referencedColumnName：参照的主表的主键名
     *                  inverseJoinColumns：配置对方对象在中间表的外键
     */
    @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<>();
}

LinkMan实体类

@Entity
@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(mappedBy = "roles")  //配置多表关系
    @ManyToMany(targetEntity = User.class,cascade = CascadeType.ALL)
    @JoinTable(name = "sys_user_role",
            //joinColumns,当前对象在中间表中的外键
            joinColumns = {@JoinColumn(name = "sys_role_id",referencedColumnName = "role_id")},
            //inverseJoinColumns，对方对象在中间表的外键
            inverseJoinColumns = {@JoinColumn(name = "sys_user_id",referencedColumnName = "user_id")}
    )
    private Set<User> users = new HashSet<User>();
}

2.映射的注解说明

@ManyToMany
作用：用于映射多对多关系
属性：
	cascade：配置级联操作。
	fetch：配置是否采用延迟加载。
	targetEntity：配置目标的实体类。映射多对多的时候不用写。

@JoinTable
作用：针对中间表的配置
属性：
	nam：配置中间表的名称
	joinColumns：中间表的外键字段关联当前实体类所对应表的主键字段			  			
	inverseJoinColumn：中间表的外键字段关联对方表的主键字段
	
@JoinColumn
作用：用于定义主键字段和外键字段的对应关系。
属性：
	name：指定外键字段的名称
	referencedColumnName：指定引用主表的主键字段名称
	unique：是否唯一。默认值不唯一
	nullable：是否允许为空。默认值允许。
	insertable：是否允许插入。默认值允许。
	updatable：是否允许更新。默认值允许。
	columnDefinition：列的定义信息。

3.执行测试

1.单项多对多

@Test
    @Transactional
    @Rollback(false)
    public void  testAdd() {
        User user = new User();
        user.setUserName("用户1");

        Role role = new Role();
        role.setRoleName("角色1");

        //配置用户到角色关系，可以对中间表中的数据进行维护 
        user.getRoles().add(role);

        userDao.save(user);
        roleDao.save(role);
    }

在这里插入图片描述

2.双向多对多

在多对多（保存）中，如果双向都设置关系，意味着双方都维护中间表，都会往中间表插入数据，中间表的2个字段又作为联合主键，所以会报错，主键重复。

@Test
    @Transactional
    @Rollback(false)
    public void  testAdd() {
        User user = new User();
        user.setUserName("用户 ");

        Role role = new Role();
        role.setRoleName("角色1");

        //配置用户到角色关系，可以对中间表中的数据进行维护
        user.getRoles().add(role);

        //配置角色到用户的关系，可以对中间表的数据进行维护 
        role.getUsers().add(user);

        userDao.save(user);
        roleDao.save(role);
    }

Caused by: 	com.mysql.jdbc.exceptions.jdbc4.MySQLIntegrityConstraintViolationException: Duplicate entry '1-1' for key 'PRIMARY'

在这里插入图片描述

3.放弃维护权

让任意一方放弃对中间表的维护权，推荐在被动的一方放弃。

修改Role实体类重新映射配置

//放弃对中间表的维护权，解决保存中主键冲突的问题
@ManyToMany(mappedBy="roles")
private Set<User> users = new HashSet<User>();

4.级联操作

修改User实体映射关系，添加级联操作配置：

	 @ManyToMany(targetEntity = Role.class,cascade = CascadeType.ALL)

1.级联保存

保存一个用户的同时保存用户的关联角色

    @Test
    @Transactional
    @Rollback(false)
    public void  testCasCadeAdd() {
        User user = new User();
        user.setUserName("用户1");

        Role role = new Role();
        role.setRoleName("角色1");

        //配置用户到角色关系，可以对中间表中的数据进行维护
        user.getRoles().add(role);

        //配置角色到用户的关系，可以对中间表的数据进行维护
        role.getUsers().add(user);
        userDao.save(user);
    }

2.级联删除

删除用户，同时删除用户的关联对象

    @Test
    @Transactional
    @Rollback(false)
    public void  testCasCadeRemove() {
        User user = userDao.findOne(1l);
        userDao.delete(user);

    }

五、JPA中的多表查询

1.对象导航查询

对象图导航检索方式是根据已经加载的对象，导航到它所关联的对象。

它利用类与类之间的关系来检索对象。例如：通过ID查询方式查出一个客户，可以调用Customer类中的getLinkMans()方法来获取该客户的所有联系人。

对象导航查询的使用要求是：两个对象之间必须存在关联关系。

1.从一的一方查询

1.对象导航查询：默认使用的是延迟加载
 	
2.调用get方法并不会立即发送查询，而是在使用关联对象的时候才会发送查询
	
3.延迟加载策略：
	  fetch : 配置关联对象的加载方式
          	EAGER   ：立即加载
         	LAZY    ：延迟加载
         	
4.修改配置，将延迟加载改为立即加载
		 fetch，需要配置到多表映射关系的注解上 
		  @ManyToOne(targetEntity = Customer.class, fetch = FetchType.EAGER)

    @Test
  	//由于是在java代码中测试，为了解决no session问题，将操作配置到同一个事务中	
    @Transactional 
    public void  testQuery1() {
        //查询id为1的客户
        Customer customer = customerDao.getOne(1l);
        //对象导航查询，此客户下的所有联系人
        Set<LinkMan> linkMans = customer.getLinkMans();

        for (LinkMan linkMan : linkMans) {
            System.out.println(linkMan);
        }
    }

2.从多的一方查询

1.对象导航查询：默认使用的是立即加载
 	
2.延迟加载策略：
	 	 fetch : 配置关联对象的加载方式
          	EAGER   ：立即加载
         	LAZY    ：延迟加载
         	
3.修改配置，将立即加载改为延迟加载
		 fetch，需要配置到多表映射关系的注解上 
		  @ManyToOne(targetEntity = Customer.class, fetch = FetchType.LAZY)

    @Test
    @Transactional
    public void  testQuery3() {
        LinkMan linkMan = linkManDao.findOne(2l);
        //对象导航查询所属的客户
        Customer customer = linkMan.getCustomer();
        System.out.println(customer);
    }

2.使用Specification查询

  @Test
    public void testFind() {
        Specification<LinkMan> spec = new Specification<LinkMan>() {
            public Predicate toPredicate(Root<LinkMan> root, CriteriaQuery<?> query, CriteriaBuilder cb) {
                //Join代表链接查询，通过root对象获取
                //创建的过程中，第一个参数为关联对象的属性名称，第二个参数为连接查询的方式（left，inner，right）
                //JoinType.LEFT : 左外连接,JoinType.INNER：内连接,JoinType.RIGHT：右外连接
                Join<LinkMan, Customer> join = root.join("customer", JoinType.INNER);
                Predicate predicate = cb.like(join.get("custName").as(String.class), "大白");
                return predicate;
            }
        };
        List<LinkMan> list = linkManDao.findAll(spec);
        for (LinkMan linkMan : list) {
            System.out.println(linkMan);
        }
    }