今日知识
1. 关联查询
2. 延时加载
3. 查询缓存关联查询
1.一对一 resultType实现
1. 写个定单的扩展类
public class OrdersExt extends Orders {
private String username;
private String address;
2. 声明定单接口
public interface OrdersMapper {
//根据订单id查询订单信息
public OrdersExt findOrdersUser(int id);
}
3. 声明定单配置文件
<mapper namespace="com.rqy.mapper.OrdersMapper">
<sql id="select_orders"> orders.id, orders.number, orders.createtime, orders.note, </sql> <sql id="select_user"> user.username, user.address </sql> <select id="findOrdersUser" parameterType="int" resultType="ordersExt"> SELECT <include refid="select_orders"/> <include refid="select_user"/> FROM orders,user WHERE orders.user_id=user.id and orders.id=#{?}; </select> </mapper> 4. 加载映射文件 <mappers> <package name="com.rqy.mapper"/> </mappers> 5. 测试 @Test public void test(){ OrdersMapper ordersMapper = sqlSession.getMapper(OrdersMapper.class); OrdersExt ordersExt = ordersMapper.findOrdersUser(3); System.out.println(ordersExt); sqlSession.commit(); } 6. 一对一 resultMap实现 <!--一对一 resultMap实现--> <resultMap id="ordersRsMap" type="orders"> <id column="id" property="id"/> <result column="number" property="number"/> <result column="createtime" property="createtime"/> <result column="note" property="note"/> <!--关联内部对象,Orders类有User user--> <association property="user" javaType="com.rqy.model.User"> <id property="id" column="id"/> <result column="username" property="username"/> <result column="address" property="address"/> </association> </resultMap> <select id="findOrdersByRsMap" parameterType="int" resultMap="ordersRsMap"> SELECT <include refid="select_orders"/> <include refid="select_user"/> FROM orders,user WHERE orders.user_id=user.id and orders.id=#{?}; </select>2.一对多 resultType实现
1. 在Orders中添加定单明细
private List<Orderdetail> orderdetails;
public List<Orderdetail> getOrderdetails() {
return orderdetails;
}
public void setOrderdetails(List<Orderdetail> orderdetails) { this.orderdetails = orderdetails; } 2. Mapper接口 //根据订单id查询订单信息，包括订单项 public Orders findOrdersByRsMap2(int ordersId); 3. OrderMapper.xml <!--一对多resultMap实现--> <resultMap id="ordersRsMap2" type="orders"> <id column="id" property="id"/> <result column="number" property="number"/> <result column="createtime" property="createtime"/> <result column="note" property="note"/> <!--关联内部对象--> <association property="user" javaType="com.rqy.model.User"> <id column="user_id" property="id"/> <result column="username" property="username"/> <result column="address" property="address"/> </association> <!--集合映射--> <collection property="orderdetails" ofType="orderdetail"> <id column="detail_id" property="id"/> <result column="items_id" property="itemsId"/> <result column="items_num" property="itmesNum"/> </collection> </resultMap> <select id="findOrdersByRsMap2" parameterType="int" resultMap="ordersRsMap2"> SELECT <include refid="select_orders"/> <include refid="select_user"/>, orderdetail.id detail_id, orderdetail.items_id, orderdetail.items_num FROM orders,user,orderdetail WHERE orders.user_id=user.id and orders.id=orderdetail.orders_id and orders.id=#{?}; </select> 4. 测试 //一对一多resultMap实现 @Test public void test2(){ OrdersMapper ordersMapper = sqlSession.getMapper(OrdersMapper.class); Orders order = ordersMapper.findOrdersByRsMap2(3); System.out.println(order); } 5. 总结：mybatis使用resultMap的collection对关联查询的多条记录映射到一个list集合属性 中。3.多对多 resultType实现
1. 将用户信息映射到user中。
* 在user类中添加订单列表属性List<Orders> orderslist，将用户创建的订单映射到orderslist
* 在Orders中添加订单明细列表属性List<Orderdetail> detailList，将订单的明细映射到detailList
* 在Orderdetail中添加Items属性，将订单明细所对应的商品映射到Items2. Mapper.xml
//查询用户信息及用户购买的商品信息
public List<User> findUserAndItemsRslMap();3. UserMapper.xml
<!--查询用户购买的商品信息，多对多-->
<resultMap id="userAndItemsRslMap" type="user"> <id column="id" property="id"/> <result column="username" property="username"/> <result column="address" property="address"/> <!--1.User里面的orderlist属性--> <collection property="orderslist" ofType="orders"> <id column="orders_id" property="id"/> <result column="number" property="number"/> <result column="createtime" property="createtime"/> <result column="note" property="note"/> <!--2.Order里面的orderdetail属性--> <collection property="orderdetails" ofType="orderdetail"> <id column="detail_id" property="id"/> <result column="items_id" property="itemsId"/> <result column="items_num" property="itmesNum"/> <!--orderdetail里面的items属性--> <association property="items" javaType="items"> <id column="items_id" property="id"/> <result column="items_name" property="name"/> <result column="items_detail" property="detail"/> <result column="items_price" property="price"/> </association> </collection> </collection> </resultMap> <select id="findUserAndItemsRslMap" resultMap="userAndItemsRslMap"> SELECT user.id, user.username, user.address, orders.id orders_id, orders.number, orders.createtime, orders.note, orderdetail.id detail_id, orderdetail.items_id, orderdetail.items_num, items.name items_name, items.detail items_detail, items.price items_price FROM orders,user,orderdetail,items WHERE orders.user_id=user.id and orders.id=orderdetail.orders_id and orderdetail.items_id=items.id; </select>4. 测试
//多对多resultMap实现
@Test
public void test3(){
UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
List<User> userAndItemsRslMap = userMapper.findUserAndItemsRslMap();
for (User user : userAndItemsRslMap) { System.out.println("用户名："+user.getUsername()+"-地址："+user.getAddress()); for (Orders order : user.getOrderslist()){ System.out.println("订单id:"+order.getId()); System.out.println("订单number:"+order.getNumber()); System.out.println("订单时间:"+order.getCreatetime()); System.out.println("----------------------------------------"); for (Orderdetail orderdetail : order.getOrderdetails()) { System.out.println(); System.out.println("商品数量："+orderdetail.getItmesNum()); System.out.println("商品名称："+orderdetail.getItems().getName()); System.out.println("商品详情："+orderdetail.getItems().getDetail()); } } } }延时加载
* 分次查询：支持懒加载
* 连接查询：不支持懒加载
1. 概念:延迟加载又叫懒加载，也叫按需加载。
也就是说先加载主信息，在需要的时候，再去加载从信息。
2. 在mybatis中，resultMap标签的association标签和
collection标签具有延迟加载的功能。
3. 案例
1. OrdersMapper.java
//懒加载订单和用户信息
public List<Orders> findOrderAndUserByLazyLoading(); 2. OrderMapper.xml配置 <!--==============懒加载==================--> <resultMap id="LazyLoadingordersRsMap" type="orders"> <id 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" select="com.rqy.mapper.UserMapper.findUserById" column="user_id"> </association> </resultMap> <select id="findOrderAndUserByLazyLoading" resultMap="LazyLoadingordersRsMap"> SELECT * FROM orders </select> 3. SqlMapConfig.xml !--配置懒加载--> <settings> <setting name="lazyLoadingEnabled" value="true"/> </settings> 4. 测试 //懒加载 @Test public void test4(){ OrdersMapper ordersMapper = sqlSession.getMapper(OrdersMapper.class); List<Orders> ordersList = ordersMapper.findOrderAndUserByLazyLoading(); for (Orders order : ordersList) { System.out.println("订单号："+order.getNumber()); System.out.println("订单所属人："+order.getUser().getUsername()); System.out.println("========================"); } } 5. 注意:association和collection:添加一个标签：当配置了lazyLoadingEnabled=true后，所有的分次查询都是懒加载，使用fetchType="eager",可以修改懒加载为立即加载查询缓存
1. 概念：Mybatis的缓存，包括一级缓存和二级缓存，一级缓存是默认使用的。二级缓存需要手动开启。
2. 一级缓存
* 概念：一级缓存指的就是sqlsession，在sqlsession中有一个数据区域，是map结构，这个区域就是一级缓存区域。一级缓存中的key是由sql语句、条件、statement等信息组成一个唯一值。一级缓存中的value，就是查询出的结果对象。 * 案例： 1. @Test public void test(){ UserMapper mapper = sqlSession.getMapper(UserMapper.class); User user = mapper.findUserById(35); System.out.println(user); System.out.println("======================"); //查询两次该用户信息，第二次不会执行sql语句 User user2 = mapper.findUserById(35); System.out.println(user2); } 2. 如果一旦执行完修改，添加，删除用户执行完commit,就会清空一级缓存。 @Test public void test2(){ UserMapper mapper = sqlSession.getMapper(UserMapper.class); User user = mapper.findUserById(35); System.out.println(user); //保存，删除，更新会消除一级缓存 User u=new User("123","男",new Date(),"河南"); mapper.insertUser(u); //第二次不会执行sql语句 User user2 = mapper.findUserById(35); System.out.println(user2); } 3. 二级缓存 * 概念：二级缓存指的就是同一个namespace下的mapper，二级缓存中，也有一个map结构，这个区域就是一级缓存区域。一级缓存中的key是由sql语句、条件、statement等信息组成一个唯一值。一级缓存中的value，就是查询出的结果对象。 1. 步骤一：User序列化public class User implements Serializable { 2. <settings> <!--二级缓存开关--> <setting name="cacheEnabled" value="true"/> </settings> 3. UserMapper中配置 二级缓存 <!--默认使用perpetualCache--> <cache></cache> 4. 测试 //二级缓存 //查询 @Test public void test3(){ SqlSession sqlSession1=ssf.openSession(); SqlSession sqlSession2=ssf.openSession(); SqlSession sqlSession3=ssf.openSession(); UserMapper mapper1 = sqlSession1.getMapper(UserMapper.class); UserMapper mapper2= sqlSession2.getMapper(UserMapper.class); UserMapper mapper3 = sqlSession3.getMapper(UserMapper.class); User user = mapper1.findUserById(35); System.out.println(user); sqlSession1.close(); //添加，删除，修改提交后，会清空二级缓存 mapper3.insertUser(user); sqlSession3.commit(); //第二次不会执行sql语句 User user2 = mapper2.findUserById(35); System.out.println(user2); } 5. 禁用指定方法二级缓存 select标签中加入：useCache="false" 6. 刷新缓存 select,insert,update,加入flushCache="false",此时添加，删除，修改提交后，不会清空二级缓存，默认情况下：flushCache="true".