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<=#{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"