mybatis3.2.7学习笔记2_一对一、一对多、多对多、延时加载、缓存-CSDN博客

本文链接：https://blog.csdn.net/undergrowth/article/details/46642469

参考源：

http://java.itcast.cn/news/20150512/13543033211.shtml 这是传智播客的燕青老师讲的讲的很好强烈推荐

hibernate 一对一一对多多对多 http://blog.csdn.net/undergrowth/article/details/12281771

我对比了一下mybatis和hibernate的一对一一对多多对多的概念

mybatis的要比hibernate简单的多更加突出了mybatis注重sql的概念

* resuType--将sql的列名和pojo的属性进行一一的映射
 *  resultMap--可以避免使用resultType方式的重复记录
 * association--将sql列映射到pojo对象中 collection--将关联信息映射到list列表中
 * association、collection都具备延时加载功能 mybatis具有二级缓存
 * SqlSession--一级缓存，当SqlSession未关闭时，使用key-value的形式存储对象，当进行增加、删除、修改时，都会清空一级缓存中的数据
 * Mapper命名空间--二级缓存，二级缓存的接口为Cache
 * ，mybatis提供的二级缓存默认实现为PerpetualCache，以Mapper的命名空间为单位进行缓存
 * ，可跨多个SqlSession，当SqlSession关闭时
 * ，将一级缓存的对象写入到二级缓存，要进行二级缓存的对象必须序列化，因为二级缓存不一定在内存中，可能在硬盘
 *  当进行增加、删除、修改时，都会清空二级缓存中的数据

*  useCache="true"  
 *  flushCache="true"

Mapper的配置文件

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
  PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
  "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!-- 使用Mapper代理开发 namespace的值与mapper的接口包 -->
<mapper namespace="com.undergrowth.mybatis.mapper.OrderUserMapper">
	<!-- 使用resultType进行一对一的映射 -->
	<select id="findOrdersUserByResultType" resultType="com.undergrowth.mybatis.po.OrdersUser">
		select
		orders.*,user.username,user.birthday from orders,user where
		orders.user_id=user.id
	</select>
	<!-- 使用resultMap进行一对一的映射 -->
	<resultMap type="com.undergrowth.mybatis.po.OrdersUserPojo"
		id="findOrdersUserByResultMapId">
		<result column="id" property="id" />
		<result column="user_id" property="user_id" />
		<result column="number" property="number" />
		<result column="createtime" property="createtime" />
		<result column="note" property="note" />

		<association property="user" javaType="com.undergrowth.mybatis.po.User">
			<result column="username" property="username" />
			<result column="birthday" property="birthday" />
		</association>
	</resultMap>

	<!-- 使用resultMap进行一对一的映射 -->
	<select id="findOrdersUserByResultMap" resultMap="findOrdersUserByResultMapId">
		select
		orders.*,user.username,user.birthday from orders,user where
		orders.user_id=user.id
	</select>

	<!-- 使用collection进行集合元素的映射 映射成一对多 避免记录的重复 -->
	<!-- 使用extends使orders与user不用进行映射 -->
	<resultMap type="com.undergrowth.mybatis.po.OrdersUserDetailPojo"
		id="findOrderUserDetailResultMapId" extends="findOrdersUserByResultMapId">
		<collection property="orderDetails"
			ofType="com.undergrowth.mybatis.po.OrderDetail">
			<result column="orders_id" property="orders_id" />
			<result column="items_id" property="items_id" />
			<result column="items_num" property="items_num" />
		</collection>
	</resultMap>

	<select id="findOrderUserDetailResultMap" resultMap="findOrderUserDetailResultMapId">
		SELECT
		orders.*,
		user.username,
		user.birthday,
		orderdetail.orders_id,
		orderdetail.items_id,
		orderdetail.items_num
		FROM
		orders,
		user,
		orderdetail
		WHERE
		orders.user_id = user.id
		AND orders.id = orderdetail.orders_id
	</select>

	<resultMap type="com.undergrowth.mybatis.po.UserToOrdersVo"
		id="findUserAndItemsResultMapId">
		<result column="user_id" property="id" />
		<result column="username" property="username" />
		<result column="birthday" property="birthday" />
		<result column="sex" property="sex" />
		<result column="user_address" property="address" />

		<!-- 关联订单列表 -->
		<collection property="orderList"
			ofType="com.undergrowth.mybatis.po.OrdersToOrderDetailVo">
			<result column="id" property="id" />
			<result column="user_id" property="user_id" />
			<result column="number" property="number" />
			<result column="createtime" property="createtime" />
			<result column="note" property="note" />
			<!-- 订单关联明细 -->
			<collection property="orderDetailList"
				ofType="com.undergrowth.mybatis.po.OrderDetailToItems">
				<result column="orders_id" property="orders_id" />
				<result column="items_id" property="items_id" />
				<result column="items_num" property="items_num" />
				<!-- 关联商品 -->
				<association property="items" javaType="com.undergrowth.mybatis.po.Items">
					<result column="name" property="name" />
					<result column="price" property="price" />
					<result column="detail" property="detail" />
				</association>
			</collection>
		</collection>
	</resultMap>

	<!-- 使用 collection和association进行用户和商品明细的多对多的映射 -->
	<select id="findUserAndItemsResultMap" resultMap="findUserAndItemsResultMapId">

		SELECT
		orders.*,
		user.username,
		user.birthday,
		user.sex,
		user.address
		user_address,
		orderdetail.orders_id,
		orderdetail.items_id,
		orderdetail.items_num,
		items.name,
		items.price,
		items.detail
		FROM
		orders,
		user,
		orderdetail,
		items
		WHERE
		orders.user_id =
		user.id
		AND orders.id =
		orderdetail.orders_id
		AND orderdetail.items_id =
		items.id
	</select>

	<select id="findUserById" resultType="com.undergrowth.mybatis.po.User">
		select * from user where id=#{value}
	</select>

	<!-- 延时加载 association -->
	<resultMap type="com.undergrowth.mybatis.po.OrdersUserPojo"
		id="findOrderUserLazyLoadingId">
		<result column="id" property="id" />
		<result column="user_id" property="user_id" />
		<result column="number" property="number" />
		<result column="createtime" property="createtime" />
		<result column="note" property="note" />
		<association property="user" javaType="com.undergrowth.mybatis.po.User"
			select="findUserById" column="user_id"></association>
	</resultMap>
	<select id="findOrderUserLazyLoading" resultMap="findOrderUserLazyLoadingId">
		select * from
		orders
	</select>
   <!-- 开启Mapper的二级缓存 默认实现为PerpetualCache -->
   <cache></cache>
</mapper>

接口文件

package com.undergrowth.mybatis.mapper;

import java.util.List;

import com.undergrowth.mybatis.po.OrdersUser;
import com.undergrowth.mybatis.po.OrdersUserDetailPojo;
import com.undergrowth.mybatis.po.OrdersUserPojo;
import com.undergrowth.mybatis.po.UserToOrdersVo;

/**
 * 通过
 * @author u1
 *
 */
public interface OrderUserMapper {

	public List<OrdersUser> findOrdersUserByResultType();
	public List<OrdersUserPojo> findOrdersUserByResultMap();
	public List<OrdersUserDetailPojo> findOrderUserDetailResultMap();
	public List<UserToOrdersVo> findUserAndItemsResultMap();
	public List<OrdersUserPojo> findOrderUserLazyLoading();
}

测试代码

package com.undergrowth.mybatis.dao;

import java.io.IOException;
import java.util.List;

import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.junit.Before;
import org.junit.Test;

import com.undergrowth.mybatis.mapper.OrderUserMapper;
import com.undergrowth.mybatis.po.OrdersUser;
import com.undergrowth.mybatis.po.OrdersUserDetailPojo;
import com.undergrowth.mybatis.po.OrdersUserPojo;
import com.undergrowth.mybatis.po.UserToOrdersVo;
import com.undergrowth.mybatis.util.SqlSessionUtil;

/**
 * 测试代码 
 * resuType--将sql的列名和pojo的属性进行一一的映射 
 * resultMap--可以避免使用resultType方式的重复记录
 * association--将sql列映射到pojo对象中 collection--将关联信息映射到list列表中
 * association、collection都具备延时加载功能
 *  mybatis具有二级缓存
 * SqlSession--一级缓存，当SqlSession未关闭时，使用key-value的形式存储对象
 * Mapper命名空间--二级缓存，二级缓存的接口为Cache
 * ，mybatis提供的二级缓存默认实现为PerpetualCache，以Mapper的命名空间为单位进行缓存，可跨多个SqlSession
 * 要进行二级缓存的对象必须序列化
 * @author u1
 * 
 */
public class OrderUserMapperDao {

	SqlSessionFactory sqlSessionFactory = null;

	@Before
	public void before() throws IOException {
		sqlSessionFactory = SqlSessionUtil
				.getSqlSessionFactory("mybatis-conf.xml");
	}

	/**
	 * 使用resultType进行一对一的映射
	 */
	@Test
	public void testOneToOne() {
		SqlSession sqlSession = sqlSessionFactory.openSession();
		try {
			OrderUserMapper orderUserMapper = sqlSession
					.getMapper(OrderUserMapper.class);
			List<OrdersUser> ordersUsers = orderUserMapper
					.findOrdersUserByResultType();
			for (OrdersUser ordersUser : ordersUsers) {
				System.out.println(ordersUser);
			}
		} catch (Exception e) {
			// TODO: handle exception
			e.printStackTrace();
		} finally {
			sqlSession.close();
		}
	}

	/**
	 * 使用resultMap进行一对一的映射
	 */
	@Test
	public void testOneToOneResultMap() {
		SqlSession sqlSession = sqlSessionFactory.openSession();
		try {
			OrderUserMapper orderUserMapper = sqlSession
					.getMapper(OrderUserMapper.class);
			List<OrdersUserPojo> ordersUsers = orderUserMapper
					.findOrdersUserByResultMap();
			for (OrdersUserPojo ordersUser : ordersUsers) {
				System.out.println(ordersUser);
			}
		} catch (Exception e) {
			// TODO: handle exception
			e.printStackTrace();
		} finally {
			sqlSession.close();
		}
	}

	/**
	 * 使用resultMap和collection进行一对多的映射
	 */
	@Test
	public void findOrderUserDetailResultMap() {
		SqlSession sqlSession = sqlSessionFactory.openSession();
		try {
			OrderUserMapper orderUserMapper = sqlSession
					.getMapper(OrderUserMapper.class);
			List<OrdersUserDetailPojo> ordersUsers = orderUserMapper
					.findOrderUserDetailResultMap();
			for (OrdersUserDetailPojo ordersUser : ordersUsers) {
				System.out.println(ordersUser);
			}
		} catch (Exception e) {
			// TODO: handle exception
			e.printStackTrace();
		} finally {
			sqlSession.close();
		}
	}

	/**
	 * 使用resultMap和collection association进行多对多的映射
	 */
	@Test
	public void findUserAndItemsResultMap() {
		SqlSession sqlSession = sqlSessionFactory.openSession();
		try {
			OrderUserMapper orderUserMapper = sqlSession
					.getMapper(OrderUserMapper.class);
			List<UserToOrdersVo> ordersUsers = orderUserMapper
					.findUserAndItemsResultMap();
			for (UserToOrdersVo ordersUser : ordersUsers) {
				System.out.println(ordersUser);
			}
		} catch (Exception e) {
			// TODO: handle exception
			e.printStackTrace();
		} finally {
			sqlSession.close();
		}
	}

	/**
	 * 延时加载
	 */
	@Test
	public void findOrderUserLazyLoading() {
		SqlSession sqlSession = sqlSessionFactory.openSession();
		try {
			OrderUserMapper orderUserMapper = sqlSession
					.getMapper(OrderUserMapper.class);
			List<OrdersUserPojo> ordersUsers = orderUserMapper
					.findOrderUserLazyLoading();
			for (OrdersUserPojo ordersUser : ordersUsers) {
				System.out.println(ordersUser);
			}
		} catch (Exception e) {
			// TODO: handle exception
			e.printStackTrace();
		} finally {
			sqlSession.close();
		}
	}
	
	/**
	 * 测试二级缓存
	 * @throws IOException 
	 */
	@Test
	public void testCache() throws IOException{
		SqlSession sqlSession=SqlSessionUtil.getSqlSessionFactory("mybatis-conf.xml").openSession();
		OrderUserMapper mapper=sqlSession.getMapper(OrderUserMapper.class);
		System.out.println("第一次查询订单用户");
		List<OrdersUser> ordersUsers=mapper.findOrdersUserByResultType();
		for (OrdersUser ordersUser : ordersUsers) {
			System.out.println(ordersUser);
		}
		//关闭一级缓存
		sqlSession.close();
		//如果未使用二级缓存 此时再次查询 会输出查询语句
		sqlSession=SqlSessionUtil.getSqlSessionFactory("mybatis-conf.xml").openSession();
		mapper=sqlSession.getMapper(OrderUserMapper.class);
		System.out.println("第二次查询");
		ordersUsers=mapper.findOrdersUserByResultType();
		for (OrdersUser ordersUser : ordersUsers) {
			System.out.println(ordersUser);
		}
		sqlSession.close();
	}
}

开缓存和延时加载配置

<!-- mybatis运行时全局参数配置 -->
	<settings>
		<setting name="cacheEnabled" value="true"></setting>
		<setting name="lazyLoadingEnabled" value="true" />
		<!-- 按需加载每个懒加载属性 -->
		<setting name="aggressiveLazyLoading" value="false" />
	</settings>

剩下的除了和前一篇博客一样外还有一些POJO

package com.undergrowth.mybatis.po;

import java.io.Serializable;
import java.util.Date;

public class OrdersUser extends Orders implements Serializable{
	/**
	 * 
	 */
	private static final long serialVersionUID = 1L;
	private String username;
	private Date birthday;

	public String getUsername() {
		return username;
	}

	public void setUsername(String username) {
		this.username = username;
	}

	public Date getBirthday() {
		return birthday;
	}

	public void setBirthday(Date birthday) {
		this.birthday = birthday;
	}

	@Override
	public String toString() {
		return super.toString() + "[username=" + username + ", birthday="
				+ birthday + "]";
	}
}

package com.undergrowth.mybatis.po;

public class OrdersUserPojo extends Orders {
	private User user;

	public User getUser() {
		return user;
	}

	public void setUser(User user) {
		this.user = user;
	}

	@Override
	public String toString() {
		return super.toString() + "OrdersUserPojo [user=" + user + "]";
	}

}

package com.undergrowth.mybatis.po;

import java.util.List;

public class UserToOrdersVo extends User {
	private List<OrdersToOrderDetailVo> orderList;

	public List<OrdersToOrderDetailVo> getOrderList() {
		return orderList;
	}

	public void setOrderList(List<OrdersToOrderDetailVo> orderList) {
		this.orderList = orderList;
	}

	@Override
	public String toString() {
		return super.toString()+"UserToOrdersVo [orderList=" + orderList + "]";
	}
	
}

package com.undergrowth.mybatis.po;

import java.util.List;

public class OrdersToOrderDetailVo extends Orders {
	private List<OrderDetailToItems> orderDetailList;

	public List<OrderDetailToItems> getOrderDetailList() {
		return orderDetailList;
	}

	public void setOrderDetailList(List<OrderDetailToItems> orderDetailList) {
		this.orderDetailList = orderDetailList;
	}

	@Override
	public String toString() {
		return super.toString() + "OrdersToOrderDetailVo [orderDetailList="
				+ orderDetailList + "]";
	}

}

package com.undergrowth.mybatis.po;

public class OrderDetailToItems extends OrderDetail {
	private Items items;

	public Items getItems() {
		return items;
	}

	public void setItems(Items items) {
		this.items = items;
	}

	@Override
	public String toString() {
		return super.toString() + "OrderDetailToItems [items=" + items + "]";
	}

}

代码在github上 https://github.com/undergrowthlinear/learn/tree/master/mybatis