关于Mybatis的那点事

一.实现关联表查询

1、一对一关联

（1）提出需求

根据班级id查询班级信息(带老师的信息)

（2）创建表和数据

CREATE TABLE teacher(
         t_id INT PRIMARY KEY AUTO_INCREMENT,
         t_name VARCHAR(20)
);

CREATE TABLE class(
         c_id INT PRIMARY KEY AUTO_INCREMENT,
         c_name VARCHAR(20),
         teacher_id INT
);

ALTER TABLE class ADD CONSTRAINT fk_teacher_id FOREIGN KEY (teacher_id) REFERENCES teacher(t_id); 

INSERT INTO teacher(t_name) VALUES('LS1');
INSERT INTO teacher(t_name) VALUES('LS2');

INSERT INTO class(c_name, teacher_id) VALUES('bj_a', 1);
INSERT INTO class(c_name, teacher_id) VALUES('bj_b', 2);

（3）定义实体类：

public class Teacher {
         private int id;
         private String name;

}

public class Classes {
         private int id;
         private String name;
         private Teacher teacher;

}

（4）定义sql映射文件ClassMapper.xml

<!--
方式一：嵌套结果：使用嵌套结果映射来处理重复的联合结果的子集封装联表查询的数据(去除重复的数据)
select * from class c, teacher t where c.teacher_id=t.t_id and  c.c_id=1
-->
<select id="getClass" parameterType="int" resultMap="ClassResultMap">
         select * from class c, teacher t where c.teacher_id=t.t_id and  c.c_id=#{id}
</select>

<resultMap type="_Classes" id="ClassResultMap">

         <id property="id" column="c_id"/>
         <result property="name" column="c_name"/>
         <association property="teacher" javaType="_Teacher">
                 <id property="id" column="t_id"/>
                 <result property="name" column="t_name"/>
         </association>
</resultMap>


<!--
方式二：嵌套查询：通过执行另外一个SQL映射语句来返回预期的复杂类型
         SELECT * FROM class WHERE c_id=1;
         SELECT * FROM teacher WHERE t_id=1   //1 是上一个查询得到的teacher_id的值
--> 
 <select id="getClass2" parameterType="int" resultMap="ClassResultMap2">
         select * from class where c_id=#{id}
 </select>

 <resultMap type="_Classes" id="ClassResultMap2">
         <id property="id" column="c_id"/>
         <result property="name" column="c_name"/>
         <association property="teacher" column="teacher_id" select="getTeacher"></association>
 </resultMap>


 <select id="getTeacher" parameterType="int" resultType="_Teacher">
         SELECT t_id id, t_name name FROM teacher WHERE t_id=#{id}
 </select>

（5）测试 

@Test

public void testOO() {
         SqlSession sqlSession = factory.openSession();
         Classes c = sqlSession.selectOne("com.atguigu.day03_mybatis.test5.OOMapper.getClass", 1);
         System.out.println(c);
}
 
@Test
public void testOO2() {
         SqlSession sqlSession = factory.openSession();
         Classes c = sqlSession.selectOne("com.atguigu.day03_mybatis.test5.OOMapper.getClass2", 1);
         System.out.println(c);
}

association：用于一对一的关联查询；

总结：

property：对象属性的名称；

javaType：对象属性的类型；

column：所对应的外键字段名称

select：使用另一个查询封装的结果

2、一对多关联

（1）提出需求

根据classId查询对应的班级信息,包括学生,老师

（2）创建表和数据：

CREATE TABLE student(
         s_id INT PRIMARY KEY AUTO_INCREMENT,
         s_name VARCHAR(20),
         class_id INT
);

INSERT INTO student(s_name, class_id) VALUES('xs_A', 1);
INSERT INTO student(s_name, class_id) VALUES('xs_B', 1);
INSERT INTO student(s_name, class_id) VALUES('xs_C', 1);
INSERT INTO student(s_name, class_id) VALUES('xs_D', 2);
INSERT INTO student(s_name, class_id) VALUES('xs_E', 2);
INSERT INTO student(s_name, class_id) VALUES('xs_F', 2);

（3）定义实体类： 

public class Student {
         private int id;
         private String name;
}

public class Classes {
         private int id;
         private String name;
         private Teacher teacher;
         private List<Student> students;
}

（4）定义sql映射文件ClassMapper.xml

<!--
方式一: 嵌套结果: 使用嵌套结果映射来处理重复的联合结果的子集
SELECT * FROM class c, teacher t,student s WHERE c.teacher_id=t.t_id AND c.C_id=s.class_id AND  c.c_id=1
 -->

<select id="getClass3" parameterType="int" resultMap="ClassResultMap3">
         select * from class c, teacher t,student s where c.teacher_id=t.t_id and c.C_id=s.class_id and  c.c_id=#{id}
</select>

<resultMap type="_Classes" id="ClassResultMap3">
         <id property="id" column="c_id"/>
         <result property="name" column="c_name"/>
         <association property="teacher" column="teacher_id" javaType="_Teacher">
                   <id property="id" column="t_id"/>
                   <result property="name" column="t_name"/>
         </association>

         <!-- ofType指定students集合中的对象类型 -->
         <collection property="students" ofType="_Student">
                   <id property="id" column="s_id"/>
                   <result property="name" column="s_name"/>
         </collection>
</resultMap>


<!--
         方式二：嵌套查询：通过执行另外一个SQL映射语句来返回预期的复杂类型
                   SELECT * FROM class WHERE c_id=1;
                   SELECT * FROM teacher WHERE t_id=1   //1 是上一个查询得到的teacher_id的值
                   SELECT * FROM student WHERE class_id=1  //1是第一个查询得到的c_id字段的值
 -->

 <select id="getClass4" parameterType="int" resultMap="ClassResultMap4">
         select * from class where c_id=#{id}
 </select>

 <resultMap type="_Classes" id="ClassResultMap4">
         <id property="id" column="c_id"/>
         <result property="name" column="c_name"/>
         <association property="teacher" column="teacher_id" javaType="_Teacher" select="getTeacher2"></association>
         <collection property="students" ofType="_Student" column="c_id" select="getStudent"></collection>
 </resultMap>


 <select id="getTeacher2" parameterType="int" resultType="_Teacher">
         SELECT t_id id, t_name name FROM teacher WHERE t_id=#{id}
 </select>


 <select id="getStudent" parameterType="int" resultType="_Student">
         SELECT s_id id, s_name name FROM student WHERE class_id=#{id}
 </select>

（5）测试：

@Test

public void testOM() {
         SqlSession sqlSession = factory.openSession();
         Classes c = sqlSession.selectOne("com.atguigu.day03_mybatis.test5.OOMapper.getClass3", 1);
         System.out.println(c);
}

@Test
public void testOM2() {
         SqlSession sqlSession = factory.openSession();
         Classes c = sqlSession.selectOne("com.atguigu.day03_mybatis.test5.OOMapper.getClass4", 1);
         System.out.println(c);
}

collection：做一对多关联查询的总结：

ofType：指定集合元素对象的类型

二.动态SQL与模糊查询

1、提出需求:

实现多条件查询用户(姓名模糊匹配, 年龄在指定的最小值到最大值之间)

2、准备数据表和数据:

create table d_user( 
         id int primary key auto_increment, 
         name varchar(10),
         age int(3)
);

insert into d_user(name,age) values('Tom',12); 
insert into d_user(name,age) values('Bob',13); 
insert into d_user(name,age) values('Jack',18);

3、ConditionUser(查询条件实体类)

private String name;
private int minAge;
private int maxAge;

4、User(表实体类)

private int id;
private String name;
private int age;

5、userMapper.xml(映射文件) 

<?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="com.atguigu.day03_mybatis.test6.userMapper">

<select id="getUser" parameterType="com.atguigu.day03_mybatis.test6.ConditionUser" resultType="com.atguigu.day03_mybatis.test6.User">
         select * from d_user where age>=#{minAge} and age&lt;=#{maxAge} <if test='name!="%null%"'>and name like #{name} </if>
</select>

</mapper>

6、UserTest(测试) 

public class UserTest {
         public static void main(String[] args) throws IOException {               
                   Reader reader = Resources.getResourceAsReader("conf.xml");
                   SqlSessionFactory sessionFactory = new SqlSessionFactoryBuilder().build(reader);                  
                   SqlSession sqlSession = sessionFactory.openSession();                
                   String statement = "com.atguigu.day03_mybatis.test6.userMapper.getUser";                 
                   List<User> list = sqlSession.selectList(statement, new ConditionUser("%a%", 1, 12));                 
                   System.out.println(list);
         }
}

总结：

MyBatis中可用的动态SQL标签： 

if
choose（when，otherwise）
trim（where，set）
foreach

三.Mybatis缓存

1、理解MyBatis缓存

正如大多数持久层框架一样，MyBatis 同样提供了一级缓存和二级缓存的支持。

（1）一级缓存

基于PerpetualCache 的 HashMap本地缓存，其存储作用域为 Session，当 Session flush 或 close 之后，该Session中的所有 Cache 就将清空。

Mybatis的一级缓存是指SQLSession，一级缓存的作用域是SQlSession, Mabits默认开启一级缓存。 

在同一个SqlSession中，执行相同的SQL查询时；第一次会去查询数据库，并写在缓存中，第二次会直接从缓存中取。 

当执行SQL时候两次查询中间发生了增删改的操作，则SQLSession的缓存会被清空。 每次查询会先去缓存中找，如果找不到，再去数据库查询，然后把结果写到缓存中。

Mybatis的内部缓存使用一个HashMap，key为hashcode+statementId+sql语句。Value为查询出来的结果集映射成的java对象。 

SqlSession执行insert、update、delete等操作commit后会清空该SQLSession缓存。

（2）二级缓存

与一级缓存其机制相同，默认也是采用 PerpetualCache，HashMap存储，不同在于其存储作用域为 Mapper(Namespace)，并且可自定义存储源，如 Ehcache。

二级缓存是mapper级别的，Mybatis默认是没有开启二级缓存的。 第一次调用mapper下的SQL去查询用户的信息，查询到的信息会存放代该mapper对应的二级缓存区域。 

第二次调用namespace下的mapper映射文件中，相同的sql去查询用户信息，会去对应的二级缓存内取结果。 

如果调用相同namespace下的mapepr映射文件中增删改sql，并执行了commit操作，此时会情况该。

（3）对于缓存数据更新机制，当某一个作用域(一级缓存Session/二级缓存Namespaces)的进行了 C/U/D 操作后，默认该作用域下所有 select 中的缓存将被clear。

2、Mybatis一级缓存 

（1）提出需求:

         根据id查询对应的用户记录对象

（2）准备数据库表和数据

CREATE TABLE c_user(
         id INT PRIMARY KEY AUTO_INCREMENT,
         NAME VARCHAR(20),
         age INT

);
INSERT INTO c_user(NAME, age) VALUES('Tom', 12);
INSERT INTO c_user(NAME, age) VALUES('Jack', 11);

（3）创建表的实体类

public class User implements Serializable{
         private int id;
         private String name;
         private int age;
}

（4）userMapper.xml

<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.atguigu.mybatis.test8.userMapper">

         <select id="getUser" parameterType="int" resultType="_CUser">
                   select * from c_user where id=#{id}
         </select>

         <update id="updateUser" parameterType="_CUser">
                   update c_user set
                   name=#{name}, age=#{age} where id=#{id}
         </update>
</mapper>

（5）测试:

 * 一级缓存: 也就Session级的缓存(默认开启)
 */
@Test
public void testCache1() {
         SqlSession session = MybatisUtils.getSession();
         String statement = "com.atguigu.mybatis.test8.userMapper.getUser";
         User user = session.selectOne(statement, 1);
         System.out.println(user);
        
         /*
          * 一级缓存默认就会被使用
          */

         user = session.selectOne(statement, 1);
         System.out.println(user);

         */        
         /*
          1. 必须是同一个Session,如果session对象已经close()过了就不可能用了
          */
         /*

         session = MybatisUtils.getSession();
         user = session.selectOne(statement, 1);
         System.out.println(user);

         */ 
         /*
          2. 查询条件是一样的
          */
         user = session.selectOne(statement, 2);
         System.out.println(user);

         */      
         /*
          3. 没有执行过session.clearCache()清理缓存
          */
         /*
         session.clearCache();
         user = session.selectOne(statement, 2);
         System.out.println(user);

         */        
         /*
          4. 没有执行过增删改的操作(这些操作都会清理缓存)
          */
         /*
         session.update("com.atguigu.mybatis.test8.userMapper.updateUser",new User(2, "user", 23));
         user = session.selectOne(statement, 2);
         System.out.println(user);

}

3、Mybatis二级缓存 

（1）添加一个<cache>在userMapper.xml中

<mapper namespace="com.atguigu.mybatis.test8.userMapper">
         <cache/>

（2）测试

/*
 * 测试二级缓存
 */
@Test
public void testCache2() {

         String statement = "com.atguigu.mybatis.test8.userMapper.getUser"; 
         SqlSession session = MybatisUtils.getSession();
         User user = session.selectOne(statement, 1);
         session.commit();
         System.out.println("user="+user);
        
         SqlSession session2 = MybatisUtils.getSession();
         user = session2.selectOne(statement, 1);
         session.commit();
         System.out.println("user2="+user);
}

（3）补充说明

1. 映射语句文件中的所有select语句将会被缓存。

2. 映射语句文件中的所有insert，update和delete语句会刷新缓存。

3. 缓存会使用Least Recently Used（LRU，最近最少使用的）算法来收回。

4. 缓存会根据指定的时间间隔来刷新。

5. 缓存会存储1024个对象

<cache
eviction="FIFO"  //回收策略为先进先出
flushInterval="60000" //自动刷新时间60s
size="512" //最多缓存512个引用对象
readOnly="true"/> //只读

四.Mybtis批量插入

问题存在：

在value值中，用到了mybatis的变量绑定。用的是#{}方式，还有一种方式${}。

默认情况下,使用#{}语法，MyBatis会用PreparedStatement语句当做占位符，并且安全的设置PreparedStatement参数，

可以避免SQL注入漏洞和钓鱼漏洞，这个过程中MyBatis会进行必要的安全检查和转义。

示例1：用#{}

执行SQL：Select * from emp where name = #{employeeName}

参数：employeeName=>Smith

解析后执行的SQL：Select * from emp where name = ？

示例2：用${}

执行SQL：Select * from emp where name = ${employeeName}

参数：employeeName传入值为：Smith

解析后执行的SQL：Select * from emp where name =Smith

可以看出，${}方式影响SQL语句的预编译，Oracle编译器解析时会进行硬解析，会造成很多临时游标变量的绑定，导致数据库性能下降。

所以从安全性和性能的角度出发，能使用#{}的情况下就不要使用${}。

SqlServer：对语句的条数和参数的数量都有限制，分别是 1000 和 2100。

Mysql：对语句的长度有限制，默认是 4M。

Mybatis：对动态语句没有数量上的限制。

将一批数据分多批插入，例如一批数据有220条，每次批量插入100条，则分三次执行全部插入。所耗费的时间要比一次执行的时间要短。

五.Mybatis传多个参数

1、第一种方案：单个参数

DAO层的函数方法 ：public List<XXBean> getXXBeanList(String xxCode);

对应的Mapper.xml文件：

<select id="getXXXBeanList" parameterType="java.lang.String" resultType="XXBean">
　　select t.* from tableName t where t.id= #{id} 
</select>

其中方法名和ID一致，#{}中的参数名与方法中的参数名一直， 这里采用的是XXXBean是采用的短名字。

2、第二种方案：多参数

DAO层的函数方法 ：public User selectUser(String name,String area);

对应的Mapper.xml文件：

<select id="selectUser" resultMap="BaseResultMap"或者resultType="XXBean">
select * from user_user_t where user_name = #{0} and user_area= #{1}
</select>

其中，#{0}代表接收的是dao层中的第一个参数，#{1}代表dao层中第二参数，更多参数一致往后加即可。

3、第三种方案：此方法采用Map传多参数.

Dao层的函数方法：Public User selectUser(Map paramMap);

对应的Mapper.xml文件：

<select id=" selectUser" parameterType="hashmap" resultMap="BaseResultMap"或者resultType="XXBean">
　　select * from user_user_t where user_name = #{userName，jdbcType=VARCHAR} and user_area= #{userArea,jdbcType=VARCHAR}
</select>

Service层调用：

Private User xxxSelectUser(){
Map paramMap=new hashMap();
paramMap.put(“userName”,”对应具体的参数值”);
paramMap.put(“userArea”,”对应具体的参数值”);
User user=xxx. selectUser(paramMap);
}

4、第四种方案：多参数传递之注解方式

Dao层的函数方法：Public User selectUser(@param(“userName”) String name, @param(“userArea”) String area);

对应的Mapper.xml

<select id=" selectUser" resultMap="BaseResultMap">
　　select * from user_user_t where user_name = #{userName，jdbcType=VARCHAR} and user_area = #{userArea,jdbcType=VARCHAR}
</select>

注解方法。

5、第五种方案：List封装in：

Dao层的函数方法：public List<XXXBean> getXXXBeanList(List<String> list);

对应的Mapper.xml

<select id="getXXXBeanList" resultType="XXBean">
　　select 字段... from XXX where id in
　　<foreach item="item" index="index" collection="list" open="(" separator="," close=")"> 
　　　　#{item} 
　　</foreach> 
</select>

foreach 最后的效果是select 字段... from XXX where id in ('1','2','3','4')

6、第六种方案：

selectList()只能传递一个参数，但实际所需参数既要包含String类型，又要包含List类型时的处理方法：

将参数放入Map，再取出Map中的List遍历。如下：

List<String> list_3 = new ArrayList<String>();
Map<String, Object> map2 = new HashMap<String, Object>();

list.add("1");
list.add("2");
map2.put("list", list); //网址id

map2.put("siteTag", "0");//网址类型

Dao层的函数方法：

public List<SysWeb> getSysInfo(Map<String, Object> map2) {
　　return getSqlSession().selectList("sysweb.getSysInfo", map2);
}

对应的Mapper.xml：

<select id="getSysInfo" parameterType="java.util.Map" resultType="SysWeb">
　　select t.sysSiteId, t.siteName, t1.mzNum as siteTagNum, t1.mzName as siteTag, t.url, t.iconPath
　　from TD_WEB_SYSSITE t
　　left join TD_MZ_MZDY t1 on t1.mzNum = t.siteTag and t1.mzType = 10
　　WHERE t.siteTag = #{siteTag } 
　　and t.sysSiteId not in 
　　<foreach collection="list" item="item" index="index" open="(" close=")" separator=",">
　　#{item}
　　</foreach>
</select>

resultclass属于隐身映射，在性能方面，resultMap要比resultClass高，所以建议尽量使用resultMap。

返回类型resultMap：resultType是直接表示返回类型的，而resultMap则是对外部ResultMap的引用，但是resultType跟resultMap不能同时存在。

传入参数parameterType：
parameterType="int" 
parameterType="User" 
parameterType="java.lang.Integer"
parameterType="string" 
parameterType="java.util.Map"
parameterType="java.util.ArrayList"

返回类型resultType：
resultType="java.lang.Integer"
resultType="实体类"
resultType="java.util.HashMap"
resultType="java.lang.String"