day15--【Mybatis】--关联查询

day15–【Mybatis】–关联查询

关联查询
（1）项目不可能只有一个表，一般是多表
（2）多表关系为，一对一，一对多，多对多
（3）查询的数据来自多个表，要使用多表查询
笛卡尔集，显示内连接inner join，左外连接left outer join，右外连接right outer join，子查询select嵌套select
（4）查询的结果要封装成javaBean对象 ，在Mybatis中重点掌握resultType与resultMap

关联查询中只分为一对一和一对多查询

关联查询-一对一(1)
（1）关联查询的中的一对一是指，站在订单的角度看，一个订单有一个用户跟它对应
（2）数据来自两个表，使用连接查询，需要输出所有订单，使用左外连接
（3）查询结果可以有两种方式封装数据
》resultType 指定一个自定义javaBean类（通常要再编写一个新的javaBean类)
》resultMap 指定映射关系（不用编写新的javaBean类 推荐使用)
映射文件

一对一查询resultType实现

test

 @Test
    public void test01(){

        //ResultType=>类
        SqlSession session = MySessionUtils.getSession();
        //update  insert delete find
        OrderDao orderDao =  session.getMapper(OrderDao.class);
        List<OrderUer> list=orderDao.findAllOrderUser();
        System.out.println(list);
        //关闭资源
        session.commit();
        session.close();

    }

创建一个符合要求的新的类

public class OrderUer {
    //订单的属性
    private int oid;
    private Integer user_id;
    private String number;
    private Date createtime;
    private String note;
    //用户的属性
    private int uid;
    private String username;
    private Date birthday;
    private String sex;
    private String address;

接口方法

    /*
    select o.id as oid,
	o.user_id ,
	o.number,
	o.createtime,
	o.note,
	u.id as uid,
	u.username,
	u.birthday,
	u.sex,
	u.address
     from  `order` o left join `user` u
     on o.user_id=u.id;
     */
    List<OrderUer> findAllOrderUser();

resultType配置映射

<!--1:查询每个订单属于哪个用户  一对一 方式1-->
    <select id="findAllOrderAndUser" resultType="OrderUser">
    select o.id as id,
		o.user_id as userId,
		o.number,
		o.createtime,
		o.note,
		u.id as uid,
		u.username,
		u.birthday,
		u.sex,
		u.address
	 from  `order` o left join `user` u 
	 on o.user_id=u.id;
    </select>

重新定义javabeanlei类

public class OrderUser {
    // 订单id
    private int id;
    // 用户id
    private Integer userId;
    // 订单号
    private String number;
    // 订单创建时间
    private Date createtime;
    // 备注
    private String note;

    private int uid;
    private String username;
    private Date birthday;
    private String sex;
    private String address;

一对一查询resultMap实现

不用新创建一个javabean对象，直接在一个类里创建另一个类作为成员变量

（1）分析下属性
（2）association 标签 用于 成员变量的类型为自定义实体类型
（3）添加属性:autoMapping=“true”,自动映射

测试

    @Test
    public void test01(){

       //ResultMap=>原来的Order类
        SqlSession session = MySessionUtils.getSession();
        //update  insert delete find
        OrderDao orderDao =  session.getMapper(OrderDao.class);
        List<Order> list=orderDao.findAllOrder2();
        System.out.println(list);
        //关闭资源
        session.commit();
        session.close();

    }

改造order类

public class Order {
    // 订单id
    private int id;
    // 用户id
    private Integer userId;
    // 订单号
    private String number;
    // 订单创建时间
    private Date createtime;
    // 备注
    private String note;
    //增加User成员变量来接收一条记录的用户的查询字段。
    private User user;

定义接口

    /*

select o.id as id,
	o.user_id as userId,
	o.number,
	o.createtime,
	o.note,
	u.id as uid,
	u.username,
	u.birthday,
	u.sex,
	u.address
 from  `order` o left join `user` u
 on o.user_id=u.id;
     */
    List<Order> findAllOrder2();

resultMap与association 配置映射***
映射配置的重点是 Order类中的 User user 成员变量，它的类型User是自定义实现类的类型

autoMapping:表示如果字段名和属性名一致，则自动映射

   <!--2:查询每个订单属于哪个用户  一对一  方式2-->
    <!--
      如果是关联查询，则必须添加属性:autoMapping="true",自动映射
    -->
    <resultMap id="findAllOrder2Map" type="com.wzx.bean.Order" autoMapping="true">
        <!--先指定Order类属性和字段之间的映射关系-->
        <id column="id" property="id"></id>
        <result column="user_id" property="userId"></result>
        <!--先指定Order类中User类属性和字段之间的映射关系
        property:表示Order类中User类对象的名字
        javaType:表示Order类中包含的User类的全路径名
        autoMapping:表示如果字段名和属性名一致，则自动映射
          class Order{
            User user;
          }
        -->
        <association property="user" javaType="com.wzx.bean.User" autoMapping="true" >
            <id column="uid" property="id"></id>
        </association>
    </resultMap>

    <select id="findAllOrder2" resultMap="findAllOrder2Map">
   select o.id as id,
	    o.user_id as userId,
	    o.number,
	    o.createtime,
	    o.note,
	    u.id as uid,
	    u.username,
	    u.birthday,
	    u.sex,
	    u.address
    from  `order` o left join `user` u
    on o.user_id=u.id;
    </select>

体现了组合
两个标签都要开autoMapping=“true”，或者全部属性都写也行，不然只映射一些已写的属性

关联查询-一对多

（1）关联查询的中的一对多是指，站在用户的角度看，一个用户会存在多个订单跟他对应。

（2）数据来自两个表，使用连接查询，需要输出每一个用户有多少个订单

（3）查询结果使用collection标签 映射List<元素>

测试

 @Test
    public void test01(){

        //ResultMap=>原来的User类
        SqlSession session = MySessionUtils.getSession();

        UserDao userDao =  session.getMapper(UserDao.class);
        List<User> list=userDao.findAllUsers();
        //获取用户，然后调用用户的getOrders()
        System.out.println(list);

        session.commit();
        session.close();


    }

改造user

public class User {

    private int id;
    private String username;
    private Date birthday;
    private String sex;
    private String address;

    //变量类型是集合List
    private List<Order> orders;

定义接口方法

  /*
     select u.id as id,
		u.username,
		u.birthday,
		u.sex,
		u.address,
		o.id,
		o.user_id as userId,
		o.number,
		o.createtime,
		o.note
    from `user` u left join `order` o
    on u.id=o.user_id;

     */
    List<User> findAllUsers();

ResultMap与collection配置映射***

    <!-- autoMapping="true" 如果字段名与变量名一样，则不需要映射
    如果一个类成员变量出现集合类型，List，则需要使用collection标签了映射，字段与变量的关系
    ofType指定的集合List<元素> 元素的类型，不要写成javaType
    -->
    <resultMap id="findAllUsersMap" type="com.wzx.bean.User" autoMapping="true">
            <id property="id" column="uid"></id>
            <collection property="orders" ofType="com.wzx.bean.Order" autoMapping="true">
                <id property="id" column="oid"></id>
            </collection>
    </resultMap>


    <select id="findAllUsers" resultMap="findAllUsersMap">
	     select u.id as uid,
	        u.username,
	        u.birthday,
	        u.sex,
	        u.address,
	        o.id as oid,
	        o.user_id as userId,
	        o.number,
	        o.createtime,
	        o.note
	    from `user` u left join `order` o
	    on u.id=o.user_id;
    </select>