关于Mybatis的那点事

1.实现关联表查询

1.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：使用另一个查询封装的结果

1.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：指定集合元素对象的类型

2. 动态SQL与模糊查询

2.1. 提出需求:

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

2.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);

2.3. ConditionUser(查询条件实体类)

private String name;

private int minAge;

private int maxAge;

2.4. User(表实体类)

private int id;

private String name;

private int age;

2.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>

2.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

3. Mybatis缓存

3.1. 理解MyBatis缓存

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

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

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

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

3.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

<?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.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.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"/> //只读

4.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条，则分三次执行全部插入。所耗费的时间要比一次执行的时间要短。

5.Mybatis传多个参数

5.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是采用的短名字。

5.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层中第二参数，更多参数一致往后加即可。

5.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);
}

5.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.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')

5.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"