文章目录
一、多对一
实体类：
import lombok.Data;
@Data
public class Student {
private int id;
private String name;
private Teacher teacher;
}
import lombok.Data;
@Data
public class Teacher {
private int id;
private String name;
}
Studentmapper接口：
public interface Studentmapper {
public List<Student> getStudent();
}
Studentmapper.xml映射文件
按照查询嵌套查询
<select id="getStudent" resultMap="StudentTeacher">
select * from student
</select>
<resultMap id="StudentTeacher" type="entity.Student">
<result property="id" column="id"/>
<result property="name" column="name"/>
<association property="teacher" column="tid" javaType="Teacher" select="getTeacher"/>
</resultMap>
<select id="getTeacher" resultType="Teacher" >
select * from teacher where id=#{tid}
</select>
按照查询结果嵌套查询
<select id="getStudent" resultMap="Studentteacher">
select s.id sid,s.name sname,t.id tid,t.name tname
from student s,teacher t
where s.tid=t.id;
</select>
<resultMap id="Studentteacher" type="entity.Student">
<result property="id" column="sid"/>
<result property="name" column="sname"/>
<association property="teacher" javaType="entity.Teacher">
<result property="id" column="tid"/>
<result property="name" column="tname"/>
</association>
</resultMap>
Test测试类
public void getTeacher(){
SqlSession sqlSession = MybatisUtil.getSqlSession();
Studentmapper mapper = sqlSession.getMapper(Studentmapper.class);
List<Student> student = mapper.getStudent();
for (Student student1 : student) {
System.out.println(student1);
}
sqlSession.commit();
sqlSession.close();
查询结果：
Student(id=1, name=董xx, teacher=Teacher(id=1, name=老王))
Student(id=2, name=李沫x, teacher=Teacher(id=1, name=老王))
Student(id=3, name=马x林, teacher=Teacher(id=1, name=老王))
Student(id=4, name=马x狗, teacher=Teacher(id=2, name=老哥))
Student(id=5, name=李狗x, teacher=Teacher(id=2, name=老哥))
二、一对多
实体类
@Data
public class Student {
private int id;
private String name;
private int tid;
}
因为是多对一，一个老师下面有很多学生，所以属性有一个学生集合。
@Data
public class Teacher {
private int id;
private String name;
private List<Student> students;
}
Teachermapper接口：
public interface Teachermapper {
Teacher getTeacher(@Param("tid") int id);
}
Teachermapper.xml文件：
因为一个老师有多个学生，所以
<select id="getTeacher" resultMap="teacherStudent">
select s.id sid,s.name sname, t.id tid,t.name tname
from student s,teacher t
where s.tid=t.id and t.id=#{tid};
</select>
<resultMap id="teacherStudent" type="Teacher">
<result property="id" column="tid"/>
<result property="name" column="tname"/>
<collection property="students" ofType="Student">
<result property="id" column="sid"/>
<result property="name" column="sname"/>
<result property="tid" column="tid"/>
</collection>
</resultMap>
- 其中复杂的属性要单独处理，集合用collection，对象用association
- javaType="" 指定属性的类型
- ofType ="" 获取集合中的泛型
Test测试类
@Test
public void getTeacher(){
SqlSession sqlSession = MybatisUtil.getSqlSession();
Teachermapper mapper = sqlSession.getMapper(Teachermapper.class);
Teacher teacher = mapper.getTeacher(1);
System.out.println(teacher);
sqlSession.commit();
sqlSession.close();
}
}
查询结果
Teacher(id=1, name=老王, students=[Student(id=1, name=董瑞龙, tid=1), Student(id=2, name=李沫璇, tid=1), Student(id=3, name=马嘉林, tid=1)])
三、动态sql
3.1 什么是动态sql
- 动态sql就是根据不同的条件生成不同的sql语句。
- 本质还是一句sql，只不过我们可以再sql层面执行一个逻辑代码
3.2 if标签
作用：标签用if标签进行判断然后拼接，用if标签时，要给原本的SQL语句后加一个"where 1=1" 以便后面进行SQL拼接。
Bookmapper接口：
public interface Bookmapper {
List<Book> dongtaisqlIF(Map<String,String> map);
}
Bookmapper.xml文件：
<select id="dongtaisqlIF" parameterType="map" resultType="Book" >
select * from book where 1=1
<if test="title!=null">
and title =#{title}
</if>
<if test="author!=null">
and author =#{author}
</if>
</select>
Test测试类：
public void dongtaisqlIF()
{
SqlSession sqlSession = MybatisUtil.getSqlSession();
Bookmapper mapper = sqlSession.getMapper(Bookmapper.class);
Map<String,String> map=new HashMap<>();
map.put("title","语文书");
List<Book> books = mapper.dongtaisqlIF(map);
for (Book book : books) {
System.out.println(book);
}
sqlSession.commit();
sqlSession.close();
}
查询结果
ook(id=4558e13487194a4196e2876f3ea72097, title=语文书, author=董瓜皮, createTime=Thu Oct 21 16:31:40 CST 2021, views=123)
Book(id=624ba970bac949f3a257c83a3d54b3de, title=语文书, author=董瓜皮, createTime=Thu Oct 21 16:28:05 CST 2021, views=2000)
3.3 where标签
根据刚才的动态sql语句我们可以得知我们经常在动态构造sql时，为防止注入或防止语句不当时会使用where 1=1，但这并不合适。所以我们引入了where标签。
where标签会知道如果它包含的标签中有返回值的话，它就会插入一个‘where’。此外，如果标签返回的内容是以AND 或OR开头的，则会把它去除掉。
3.4 choose（when otherwise）标签
<select id="dongtaisqlIF" parameterType="map" resultType="Book" >
select * from book
<where>
<choose>
<when test="title!=null">
title =#{title}
</when>
<when test="author!=null">
and author =#{author}
</when>
<otherwise>
and views=#{views}
</otherwise>
</choose>
</where>
</select>
进入choose标签之后，按顺序只对一个标签中的sql语句进行查找，若都不满足则对中的语句进行查找。
例1:我传入三个数据，但是只对title进行了查询。
public void dongtaisqlIF()
{
SqlSession sqlSession = MybatisUtil.getSqlSession();
Bookmapper mapper = sqlSession.getMapper(Bookmapper.class);
Map<String,String> map=new HashMap<>();
map.put("title","语文书");
map.put("author","皮");
map.put("views","1000");
List<Book> books = mapper.dongtaisqlIF(map);
for (Book book : books) {
System.out.println(book);
}
sqlSession.commit();
sqlSession.close();
}
返回的结果是title为语文书的所有对象
Book(id=4558e13487194a4196e2876f3ea72097, title=语文书, author=董瓜皮, createTime=Thu Oct 21 16:31:40 CST 2021, views=123)
Book(id=624ba970bac949f3a257c83a3d54b3de, title=语文书, author=董瓜皮, createTime=Thu Oct 21 16:28:05 CST 2021, views=2000)
3.5 sql片段
sql片段可以用来解决重复造*的问题
<sql id="hhhhh" >
<if test="title!=null">
and title =#{title}
</if>
<if test="author!=null">
and author =#{author}
</if>
</sql>
使用标签将需要复用的sql片段插入。
<select id="dongtaisqlIF" parameterType="map" resultType="Book" >
select * from book
<where>
<include refid="hhhhh"></include>
</where>
</select>
3.6 Foreach
open：开始的标志
close：结束的标志
separator：用什么隔开
collection：
item：
<select id="FOReach" parameterType="map" resultType="book">
select * from book
<where>
<foreach collection="ids" item="id" open="(" close=")" separator="or">
id=#{id}
</foreach>
</where>
</select>
测试文件：
public void FOReach(){
SqlSession sqlSession = MybatisUtil.getSqlSession();
Bookmapper mapper = sqlSession.getMapper(Bookmapper.class);
HashMap map = new HashMap<>();
ArrayList<Integer> ids= new ArrayList<>();
ids.add(1);
map.put("ids",ids);
List<Book> books1 = mapper.FOReach(map);
for (Book book : books1) {
System.out.println(book);
}
开始
四、缓存
4.1什么是缓存？
- 存在内存中的临时数据
- 将用户经常查询的数据放在缓存中（内存），用户去查询数据就不用从磁盘上（关系型数据库数据文件）查询，转而从缓存中查询，从而提高查询效率，解决了高并发系统的性能问题。
4.2为什么使用缓存？**
- 减少和数据库的交互此数，减少系统开销，提高系统效率。
4.3什么样的数据能使用缓存？
- 经常查询且不经常改变的数据。
4.4.测试实现一级缓存
接口：
public interface Teachermapper {
Teacher getTeacher( int id);
}
映射文档：
<select id="getTeacher" parameterType="java.lang.Integer" resultType="entity.Teacher">
select * from teacher where id =#{tid}
</select>
测试类：
public void getTeacher(){
SqlSession sqlSession = MybatisUtil.getSqlSession();
Teachermapper mapper = sqlSession.getMapper(Teachermapper.class);
Teacher teacher = mapper.getTeacher(1);
Teacher teacher2 = mapper.getTeacher(1);
System.out.println(teacher);
System.out.println("=====================");
System.out.println(teacher2);
System.out.println(teacher==teacher2);
}
我们可以看到我们的sql只执行了一次，但是我们的两次查询结果是相同的，也就是说第二次的查询直接是在缓存中读取的。
4.5二级缓存
- 二级缓存也叫全局缓存，因为一级缓存的作用域太小了，所以单身了耳机缓存。
- 基于namespace级别的缓存，一个名称空间对应一个二级缓存。
- 工作机制
一个会话查询一条数据，这个数据就回被放在当前会话的一级缓存中；
如果当前会话关闭了，这个会话对应的一级缓存就没了，但是我们想要的是，会话关闭数据被保存到二级缓存中。
新的会话查询信息，就可以直接在二级缓存中查找
（1）开启全局缓存
<settings>
<setting name="cacheEnabled" value="true"/>
</settings>
（2）在要使用二级缓存的mapper中使用
（3）二级缓存工作原理用户先读取二级缓存再读取一级缓