MyBatis之代理开发模式

1 mybatis-Dao的代理开发模式

Dao:数据访问对象

原来：定义dao接口，在定义dao的实现类

dao的代理开发模式

只需要定义dao接口，由mybatis产生dao接口的实现类。

1.1定义Mapper接口

 package org.guangsoft.mapper;

 import java.util.List;

 import org.guangsoft.entity.Dept;
 import org.guangsoft.vo.DeptVo;

 public interface DeptMapper
 {
     public List<DeptVo> getDeptPost();
     public void saveDept(Dept dept);
 } 

1.2定义Mapper.xml文件

定义Mapper接口中方法对应的操作

 <?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE mapper PUBLIC "-//mybatis.org/DTD Mapper 3.0" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
 <mapper namespace="org.guangsoft.mapper.DeptMapper">
     <!-- 使用dao的代理开发模式的时候
         1，namespace必须和map接口的完全限定名完全一样
         2.对应的数据库库擦操作id必须和接口中抽象放安防名一致
         3,parameterType必须和抽闲接口的抽象方法参数类型一致
         4，resultType必须和接口抽象方法的返回类型一样
      -->
      <select id="getDeptPost" resultType="org.guangsoft.vo.DeptVo">
          select dept.did,dname,pname from dept inner join post on dept.did=post.did
      </select>
      <insert id="saveDept" parameterType="org.guangsoft.entity.Dept">
          insert into dept values(null,#{dname})
      </insert>
 </mapper>

1.3通过session产生Mapper接口的代理对象

 public class TestDeptMapper
 {
     SqlSessionFactory ssf = null;
     @Before
     public void before()
     {
         SqlSessionFactoryBuilder ssfb = new SqlSessionFactoryBuilder();
         ssf = ssfb.build(this.getClass().getClassLoader().getResourceAsStream("MyBatis.xml"));
     }

     @Test
     public void testGetDeptPost()
     {
         SqlSession sqlSession = ssf.openSession();
         DeptMapper deptMapper = sqlSession.getMapper(DeptMapper.class);
         List<DeptVo> deptVoList = deptMapper.getDeptPost();
         for(DeptVo deptVo : deptVoList)
         {
             System.out.println(deptVo);
         }
         sqlSession.close();
     }

     @Test
     public void testSaveDept()
     {
         SqlSession sqlSession = ssf.openSession();
         DeptMapper deptMapper = sqlSession.getMapper(DeptMapper.class);
         Dept dept = new Dept();
         dept.setDname("danme");
         deptMapper.saveDept(dept);
         sqlSession.commit();
         sqlSession.close();
     }
 } 

2 mybatis的关联查询

Mybatis多表查询。

2.1 one-to-one 查询

需求：查询某个订单和订单对应的用户信息

订单编号      用户名     时间     金额     描述

2.1.1建立数据库模型

用户表，订单表。

 /*
 Navicat MySQL Data Transfer

 Source Server         : MySQL
 Source Server Version : 50715
 Source Host           : localhost:3306
 Source Database       : test

 Target Server Type    : MYSQL
 Target Server Version : 50715
 File Encoding         : 65001

 Date: 2016-12-14 20:47:27
 */

 SET FOREIGN_KEY_CHECKS=0;

 -- ----------------------------
 -- Table structure for orders
 -- ----------------------------
 DROP TABLE IF EXISTS `orders`;
 CREATE TABLE `orders` (
   `oid` int(11) NOT NULL AUTO_INCREMENT,
   `odate` datetime DEFAULT NULL,
   `ototal` double DEFAULT NULL,
   `odesc` varchar(255) DEFAULT NULL,
   `uid` int(11) DEFAULT NULL,
   PRIMARY KEY (`oid`),
   KEY `fk_uid` (`uid`),
   CONSTRAINT `fk_uid` FOREIGN KEY (`uid`) REFERENCES `user` (`uid`)
 ) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8;

 -- ----------------------------
 -- Table structure for user
 -- ----------------------------
 DROP TABLE IF EXISTS `user`;
 CREATE TABLE `user` (
   `uid` int(11) NOT NULL AUTO_INCREMENT,
   `username` varchar(255) DEFAULT NULL,
   `password` varchar(255) DEFAULT NULL,
   PRIMARY KEY (`uid`)
 ) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8;

2.1.2产生java实体模型

 package org.guangsoft.entity;

 import java.util.Set;

 public class User
 {
     private Integer uid;
     private String username;
     private String password;
     private Set<Orders> orders;
     public Integer getUid()
     {
         return uid;
     }
     public void setUid(Integer uid)
     {
         this.uid = uid;
     }
     public String getUsername()
     {
         return username;
     }
     public void setUsername(String username)
     {
         this.username = username;
     }
     public String getPassword()
     {
         return password;
     }
     public void setPassword(String password)
     {
         this.password = password;
     }
     public Set<Orders> getOrders()
     {
         return orders;
     }
     public void setOrders(Set<Orders> orders)
     {
         this.orders = orders;
     }

 }

 package org.guangsoft.entity;

 import java.util.Date;
 import java.util.Set;

 public class Orders
 {
     private Integer oid;
     private Date odate;
     private Double ototal;
     private String odesc;
     private User user;
     //关联订单下的明细
     private Set<Detail> details;
     public Integer getOid()
     {
         return oid;
     }
     public void setOid(Integer oid)
     {
         this.oid = oid;
     }
     public Date getOdate()
     {
         return odate;
     }
     public void setOdate(Date odate)
     {
         this.odate = odate;
     }
     public Double getOtotal()
     {
         return ototal;
     }
     public void setOtotal(Double ototal)
     {
         this.ototal = ototal;
     }
     public String getOdesc()
     {
         return odesc;
     }
     public void setOdesc(String odesc)
     {
         this.odesc = odesc;
     }
     public User getUser()
     {
         return user;
     }
     public void setUser(User user)
     {
         this.user = user;
     }
     public Set<Detail> getDetails()
     {
         return details;
     }
     public void setDetails(Set<Detail> details)
     {
         this.details = details;
     }

 }

2.1.3定义Mapper接口

 package org.guangsoft.mapper;

 import org.guangsoft.entity.Orders;

 public interface OrdersMapper
 {
     public Orders loadOrdersUser(Integer oid);
 }

2.1.4定义Mapper.xml

描述接口中方法对应的操作。

 <?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE mapper PUBLIC "-//mybatis.org/DTD Mapper 3.0" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
 <mapper namespace="org.guangsoft.mapper.OrdersMapper">
      <resultMap type="org.guangsoft.entity.Orders" id="ordersUser">
          <id column="oid" property="oid" />
          <result column="odate" property="odate" />
          <result column="odesc" property="odesc" />
          <result column="ototal" property="ototal" />
          <association property="user" javaType="org.guangsoft.entity.User">
              <id column="uid" property="uid" />
              <result column="username" property="username" />
              <result column="password" property="password" />
          </association>
      </resultMap>
      <select id="loadOrdersUser" parameterType="java.lang.Integer" resultMap="ordersUser">
          select oid ,odate,ototal,odesc,username
          from orders inner join user
          on orders.uid = user.uid where orders.oid = #{oid}
      </select>
 </mapper>

2.1.5获得Mapper接口代理对象

 public class TestDeptMapper
 {
     SqlSessionFactory ssf = null;
     @Before
     public void before()
     {
         SqlSessionFactoryBuilder ssfb = new SqlSessionFactoryBuilder();
         ssf = ssfb.build(this.getClass().getClassLoader().getResourceAsStream("MyBatis.xml"));
     }

     @Test
     public void testGetDeptPost()
     {
         SqlSession sqlSession = ssf.openSession();
         DeptMapper deptMapper = sqlSession.getMapper(DeptMapper.class);
         List<DeptVo> deptVoList = deptMapper.getDeptPost();
         for(DeptVo deptVo : deptVoList)
         {
             System.out.println(deptVo);
         }
         sqlSession.close();
     }
 }

2.2one-to-many查询

对表关联查询

给Users加入orders的集合属性

2.2.1定义Mapper接口

 package org.guangsoft.mapper;

 import java.util.List;

 import org.guangsoft.entity.User;

 public interface UserMapper
 {
     public User loadUserOrders(Integer uid);
     public List<User> loadUserOrdersDetail();
     public List<User> loadUserOrdersDetail2();
 }

2.2.2定义Mapper文件

 <?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE mapper PUBLIC "-//mybatis.org/DTD Mapper 3.0" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
 <mapper namespace="org.guangsoft.mapper.UserMapper">
      <resultMap type="org.guangsoft.entity.User" id="userOrders">
          <id column="uid" property="uid" />
          <result column="username" property="username"></result>
          <collection property="orders" ofType="org.guangsoft.entity.Orders">
              <id column="oid" property="oid" />
              <result column="odate" property="odate" />
              <result column="odesc" property="odesc" />
              <result column="ototal" property="ototal" />
          </collection>
      </resultMap>
      <select id="loadUserOrders" parameterType="java.lang.Integer" resultMap="userOrders">
          select user.uid ,oid ,odate,ototal,odesc,username
          from orders inner join user
          on orders.uid = user.uid where user.uid = #{uid}
      </select>
      <resultMap type="org.guangsoft.entity.User" id="userOrdersDetail">
          <id column="uid" property="uid" />
          <result column="username" property="username" />
          <collection property="orders" ofType="org.guangsoft.entity.Orders">
              <id column="oid" property="oid" ></id>
              <result column="odate" property="odate" ></result>
              <collection property="details" ofType="org.guangsoft.entity.Detail">
                  <id column="did" property="did"></id>
                  <result column="price" property="price"></result>
                  <result column="pname" property="pname"></result>
                  <result column="cts" property="cts"></result>
              </collection>
          </collection>
      </resultMap>
      <select id="loadUserOrdersDetail" resultMap="userOrdersDetail">
          select user.uid,orders.oid,username,odate,pname,price,cts
          from user left join orders on user.uid=orders.uid
          left join detail on orders.oid = detail.oid
      </select>

      <select id="loadUserOrdersDetail2" resultMap="userOrdersDetail">
          select user.uid,username from user
      </select>
      <select id="loadOrders" parameterType="java.lang.Integer" resultType="org.guangsoft.entity.Orders">
          select oid,odate from orders where orders.uid=#{uid}
      </select>
      <select id="loadDetail" parameterType="java.lang.Integer" resultType="org.guangsoft.entity.Detail">
          select pname,price,cts,odid from detail where detail.oid=#{oid}
      </select>
 </mapper>

2.2.3获得Mapper接口的代理对象

代码见上

2.3many-to-many查询(代码见上)

查询所有用户的所有订单信息和订单明细

订单号   ，用户名，日期，商品名称，单价，数量，小计

2.3.1建立订单明细表

订单明细表和订单表之间存在者主外键.

多个用户对应者多个订单，多个订单对应多个明细

2.3.2定义Mapper接口

2.3.3定义Mapper.xml文件

2.3.4获得Mapper接口代理对象

3 mybatis的懒加载

将多表关联查询的sql语句，分开执行

3.1开启懒加载

  <!-- 开启mybatis的懒加载 -->
 <setting name="lazyLoadingEnabled" value="true"/>
 <setting name="aggressiveLazyLoading" value="false"/>

3.2Mapper接口中添加方法

3.3拆分sql语句

3.4获得Mapper代理对象

4 mybatis的动态sql

更具业务需要，可以对sql完成动态的构造。

4.1 if标签

需求：查询订单明细，可以根据订单的编号，商品的名称，商品数量，商品的单价查询。

问题：select * from ordersdetails where (?)

4.1.1定义Mapper接口

 package org.guangsoft.mapper;

 import java.util.List;

 import org.guangsoft.entity.Detail;

 public interface DetailMapper
 {
     /**
      * 按照订单的编号，商品的名称，商品的数量，商品单价查询订单信息
      * @return
      */
     public List<Detail> loadDetail(Detail detail);
     public void deleteDetails(Integer dids[]);
 }

4.1.2定义Mapper.xml文件

 <?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE mapper PUBLIC "-//mybatis.org/DTD Mapper 3.0" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
 <mapper namespace="org.guangsoft.mapper.DetailMapper">
     <sql id="cond">
          <where>
              <if test="pname != null"><!-- 商品名称 -->
                  and pname = #{pname}
              </if>
              <if test="price != null"><!-- 商品价格 -->
                  and price = #{price}
              </if>
              <if test="cts != null"><!-- 商品 -->
                  and cts = #{cts}
              </if>
          </where>
     </sql>
      <select id="loadDetail" resultType="org.guangsoft.entity.Detail">
          select * from detail
          <!-- 动态关联where关键字 -->
          <include refid="cond"></include>
      </select>
      <delete id="deleteDetails" parameterType="org.guangsoft.entity.Detail">
          delete from detail
          <!--
              collection需要遍历的集合
              item集合汇总的每个元素
              open第一次遍历
              close最后一次遍历
              separator将遍历的元素使用什么隔开
           -->
          <foreach collection="dids" item="did" open="where did in (" close=")"
          separator=","></foreach>
      </delete>
      <insert id="saveDept" parameterType="org.guangsoft.entity.Dept">
          insert into dept values(null,#{dname})
      </insert>
 </mapper> 

4.1.3获得Mapper代理对象

 package org.guangsoft.test;

 import java.util.List;
 import java.util.Set;

 import org.apache.ibatis.session.SqlSession;
 import org.apache.ibatis.session.SqlSessionFactory;
 import org.apache.ibatis.session.SqlSessionFactoryBuilder;
 import org.guangsoft.entity.Dept;
 import org.guangsoft.entity.Detail;
 import org.guangsoft.entity.Orders;
 import org.guangsoft.entity.User;
 import org.guangsoft.mapper.DeptMapper;
 import org.guangsoft.mapper.DetailMapper;
 import org.guangsoft.mapper.OrdersMapper;
 import org.guangsoft.mapper.UserMapper;
 import org.guangsoft.vo.DeptVo;
 import org.junit.Before;
 import org.junit.Test;

 public class TestDeptMapper
 {
     SqlSessionFactory ssf = null;
     @Before
     public void before()
     {
         SqlSessionFactoryBuilder ssfb = new SqlSessionFactoryBuilder();
         ssf = ssfb.build(this.getClass().getClassLoader().getResourceAsStream("MyBatis.xml"));
     }

     @Test
     public void testGetDeptPost()
     {
         SqlSession sqlSession = ssf.openSession();
         DeptMapper deptMapper = sqlSession.getMapper(DeptMapper.class);
         List<DeptVo> deptVoList = deptMapper.getDeptPost();
         for(DeptVo deptVo : deptVoList)
         {
             System.out.println(deptVo);
         }
         sqlSession.close();
     }

     @Test
     public void testSaveDept()
     {
         SqlSession sqlSession = ssf.openSession();
         DeptMapper deptMapper = sqlSession.getMapper(DeptMapper.class);
         Dept dept = new Dept();
         dept.setDname("danme");
         deptMapper.saveDept(dept);
         sqlSession.commit();
         sqlSession.close();
     }

     @Test
     public void testGetUserOrders()
     {
         SqlSession sqlSession = ssf.openSession();
         UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
         User user = userMapper.loadUserOrders(1);
         Set<Orders> ordersSet = user.getOrders();
         for(Orders orders : ordersSet)
         {
             System.out.println(orders);
         }
     }

     @Test
     public void testGetOrdersUser()
     {
         SqlSession sqlSession = ssf.openSession();
         OrdersMapper ordersMapper = sqlSession.getMapper(OrdersMapper.class);
         Orders orders = ordersMapper.loadOrdersUser(1);
         System.out.println(orders.getUser().getUsername());
         sqlSession.close();
     }

     @Test
     public void testDetail()
     {
         SqlSession sqlSession = ssf.openSession();
         UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
         List<User> ulist = userMapper.loadUserOrdersDetail();
         for(User user : ulist)
         {
             Set<Orders> orders = user.getOrders();
             if(orders != null)
             {
                 for(Orders o : orders)
                 {
                     Set<Detail> details = o.getDetails();
                     for(Detail d : details)
                     {
                         System.out.println(d.getPname());
                     }
                 }
             }
         }
     }

     @Test
     public void testDetail2()
     {
         SqlSession sqlSession = ssf.openSession();
         UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
         OrdersMapper ordersMapper = sqlSession.getMapper(OrdersMapper.class);
         List<User> userList = userMapper.loadUserOrdersDetail2();
         for(User user : userList)
         {
             System.out.println(user.getUsername());
             Set<Orders> orders = user.getOrders();
             if(orders != null)
             {
                 for(Orders o : orders)
                 {
                     Set<Detail> details = o.getDetails();
                     for(Detail d : details)
                     {
                         System.out.println(d.getPname());
                     }
                 }
             }
         }
     }
 }

4.2foreach标签

完成订单明细的批量删除

Delete from ordersdetails where odid in  (1,3,4,5)

4.2.1定义Mapper接口

4.2.2定义Mapper.xml

4.2.3获得Mapper代理对象

5定义sql片段

使用sql标签定义sql片段，

提高sql语句复用性.

使用include标签引用sql片段

6mybatis的缓存机制

查询缓存：只有在做查询操作的时候，将数据进行缓存

6.1 mybaits的一级缓存

Session级别的缓存，不同的客户端访问数据库，缓存是独立的。

在进行查询操作的时候，数据自动放入一级缓存。

缓存数据消失：

提交事务的时候。

关闭数据库会话。

数据进行缓存的key:namespace+id+params+limit（缓存的界定，通过namespace+id+查询参数+结果集的限定），产生本次查询缓存对应的key

6.2二级缓存

二级sessionFactory级别的缓存（共享缓存）

开启二级缓存

加入缓存插件包(二级缓存为外部缓存插件)

配置缓存策略，在需要进行缓存的Mapper.xml

 <cache readOnly="true" type="org.mybatis.caches.ehcache.EhcacheCache"></cache> 

提供ehcache的配置文件