接口代理实现dao层代码

目标

通过配置让mybatis帮我们创建dao接口的实现类对象。

介绍

采用 Mybatis 的代理开发方式实现 dao层的开发,这种方式是我们后面进入企业的主流。

接口代理方式只需要程序员编写dao 接口(后期叫做mapper接口),由Mybatis 框架根据接口定义创建接口的动态代理对象。

需要遵循以下规范:

    1. 映射文件中的namespace与dao接口的全类名相同
    1. 映射文件中的增删改查标签的id属性与dao接口的方法名相同
    1. 映射文件中的增删改查标签的parameterType属性与dao接口中方法的参数类型匹配
    1. 映射文件中的增删改查标签的resultType属性与dao接口中方法的返回值类型匹配

1589770204634

记忆方式:以后映射文件就是描述mapper/dao接口的文件

代码实现

第一步:创建数据库表

1
2
3
4
5
6
7
8
9
10
11
CREATE TABLE `user`(
uid INT PRIMARY KEY AUTO_INCREMENT,
NAME VARCHAR(100) NOT NULL,
PASSWORD VARCHAR(50) NOT NULL,
email VARCHAR(50),
birthday DATE
);
INSERT INTO `user` (NAME,PASSWORD,email,birthday) VALUES("尼古拉斯赵四",'123456','nglszs@qq.com','1888-09-02');
INSERT INTO `user` (NAME,PASSWORD,email,birthday) VALUES("尼古拉斯赵五",'123456','nglszw@qq.com','1889-09-03');
INSERT INTO `user` (NAME,PASSWORD,email,birthday) VALUES("尼古拉斯赵六",'123456','nglszl@qq.com','1890-09-04');
INSERT INTO `user` (NAME,PASSWORD,email,birthday) VALUES("尼古拉斯赵七",'123456','nglszq@qq.com','1891-09-05');

第二步:导入jar包

点击下载jar包

第三步:创建实体类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package cn.itcast.domain;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {
private Integer uid;
private String name;
private String password;
private String email;
private String birthday;//数据库中是Date类型,java中可以是Date,也可以是String类型
}

第四步:创建dao接口

1
2
3
4
5
6
7
package cn.itcast.dao;

import cn.itcast.domain.User;

public interface UserDao {
User findById(Integer id);
}

第四步:创建映射文件

在src或者resource目录创建映射文件,名字叫UserMapper.xml

1
2
3
4
5
6
7
8
9
10
11
12
13
<?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">
<!--namespace的值是UserDao的类全名-->
<mapper namespace="cn.itcast.dao.UserDao">
<!--
id的值和UserDao中的方法名保持一致
parameterType和UserDao中的方法参数类型保持一致
resultType和UserDao的方法返回值类型保持一致,这里用的是别名
-->
<select id="findById" parameterType="int" resultType="user">
select * from `user` where uid= #{uid}
</select>
</mapper>

第五步:创建主配置文件

在src或者resources目录创建主配置文件,名字叫mybatis-config.xml

settings、typeAliases、properties配置参考第一天的配置

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>

<properties resource="jdbc.properties"></properties>
<settings>
<setting name="logImpl" value="log4j"/>
</settings>
<typeAliases>
<!--如果类比较多,可以指定包,通过扫包的方式给包中的所有类起别名-->
<package name="cn.itcast.domain"/>
</typeAliases>
<!--数据源环境-->
<environments default="developement">
<environment id="developement">
<transactionManager type="JDBC"></transactionManager>
<dataSource type="POOLED">
<property name="driver" value="${jdbc.driver}"/>
<property name="url" value="${jdbc.url}"/>
<property name="username" value="${jdbc.username}"/>
<property name="password" value="${jdbc.password}"/>
</dataSource>
</environment>
</environments>


<!--加载映射文件-->
<mappers>
<mapper resource="UserMapper.xml"></mapper>
</mappers>
</configuration>

第五步:编写测试方法Xml

注意:

使用的是org.apache.ibatis包下的Resources类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
@Test
public void testFindById()throws Exception{
/*1.读取配置文件并创建SqlSessionFactory*/
InputStream is = Resources.getResourceAsStream("mybatis-config.xml");
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);

/*2.获取sqlSession[这是mybatis的重要API, 使用它可以操作数据库crud*/
SqlSession sqlSession = sqlSessionFactory.openSession();

/*3.由Mybatis框架创建UserDao的实现类对象,我们称为代理对象*/
UserDao userDao = sqlSession.getMapper(UserDao.class);

/*4.调用接口的方法*/
User u = userDao.findById(1);

/*5.释放资源*/
sqlSession.close();

//测试查询结果
System.out.println(u);

}

小结

接口代理方式让我们只编写接口即可,而实现类对象由MyBatis生成

实现规则

    1. 映射文件中的namespace与dao接口的全类名相同
    1. 映射文件中的增删改查标签的id属性与dao接口的方法名相同
    1. 映射文件中的增删改查标签的parameterType属性与dao接口中方法的参数类型匹配
    1. 映射文件中的增删改查标签的resultType属性与dao接口中方法的返回值类型匹配

动态SQL

介绍

Mybatis 的映射文件中,前面我们的 SQL 都是比较简单的,有些时候业务逻辑复杂时,我们的 SQL是动态变化的,此时在前面的学习中我们的 SQL 就不能满足要求了。比如以下需求

  • findbyCondition(User user):根据传入的user对象进行查询,将不为空的属性作为查询条件
  • update(User user):根据传入的user对象进行更新,将不为空的属性更新到数据库
  • insert(User user):根据传入的user对象进行新增,将不为空的属性插入到数据库

像上面的场景,程序运行时的不同条件产生不同的SQL,这就用到了动态SQL。 动态SQL是Mybatis的强大特性之一。它的主要作用是通过Mybatis提供的标签实现sql的动态拼装。

Mybatis3之后,需要了解的动态SQL标签仅仅只有下面几个:

  • if 用于条件判断
  • where
  • foreach 用于循环遍历
  • sql片段

where标签

作用:代替where关键字,生成SQL的时候会判断是否有查询条件,如果有就会拼接where关键字,没有则不会拼接

if标签

格式和注意事项

注意事项:if标签中的test中获取值时不能出现#{},逻辑判断用and 和or 不能用&& 和 ||

1
2
3
4
5
<where>
<if test='条件判断'>
查询条件拼接
</if>
</where>

需求

根据用户信息查询对应的数据

分析

用户信息有哪些不确定,所以方法的形参直接用实体类更方便,查询结果有多少不确定,所以返回值类型是集合。那么最终接口中需要定义的方法就是List<User> findByCondition(User condition);

实现步骤

第一步:映射文件中定义条件查询语句

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
<select id="findByCondition" parameterType="user" resultType="user">
select * from `user`
<where>
<if test="uid!=null and uid!=''">
and uid = #{uid}
</if>
<if test="name!=null and name!=''">
and name = #{name}
</if>
<if test="password!=null and password!=''">
and password = #{password}
</if>
<if test="email!=null and email!=''">
and email = #{email}
</if>
<if test="birthday!=null and birthday!=''">
and birthday = #{birthday}
</if>
</where>
</select>

第二步:定义测试方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
@Test
public void testFindByCondition()throws Exception{
/*1.读取配置文件并创建SqlSessionFactory*/
InputStream is = Resources.getResourceAsStream("mybatis-config.xml");
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);

/*2.获取sqlSession[这是mybatis的重要API, 使用它可以操作数据库crud*/
SqlSession sqlSession = sqlSessionFactory.openSession();

/*3.由Mybatis框架创建UserDao的实现类对象,我们称为代理对象*/
UserDao userDao = sqlSession.getMapper(UserDao.class);

/*4.创建查询条件并调用接口的条件查询方法*/
User condition = new User();
condition.setPassword("123456");
List<User> users = userDao.findByCondition(condition);

/*5.释放资源*/
sqlSession.close();

//测试查询结果
System.out.println(users);

}

生成的SQL语句

1
select * from `user` WHERE password = ?

foreach标签

作用

循环执行sql的拼接操作,例如:SELECT * FROM USER WHERE id IN (1,2,5)。

格式

1
2
3
4
5
<where>
<foreach collection="" item="" open="" close="" separator="">
..
</foreach>
</where>

collection:代表要遍历的集合元素,注意编写时不要写#{}

  • 如果传入的是单参数且参数类型是一个List的时候,collection属性值为list
  • 如果传入的是单参数且参数类型是一个array数组的时候,collection的属性值为array
  • 如果传入的参数是多个的时候,我们就需要把它们封装成一个Map了, map的key就是参数名

open:代表语句的开始部分

close:代表结束部分

item:代表遍历集合的每个元素,生成的变量名

sperator:代表分隔符

案例1:接口方法形参是List类型

第一步:UserDao中新增方法

1
List<User> findByEmail1(List<String> emails);

第二步:配置映射文件

1
2
3
4
5
6
7
8
<select id="findByEmail" resultType="user" >
select * from `user`
<where>
<foreach collection="list" open="email in (" close=")" item="email" separator="," >
#{email}
</foreach>
</where>
</select>

第三步:编写测试方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
@Test
public void testFindByEmail1()throws Exception{
/*1.读取配置文件并创建SqlSessionFactory*/
InputStream is = Resources.getResourceAsStream("mybatis-config.xml");
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);

/*2.获取sqlSession[这是mybatis的重要API, 使用它可以操作数据库crud*/
SqlSession sqlSession = sqlSessionFactory.openSession();

/*3.由Mybatis框架创建UserDao的实现类对象,我们称为代理对象*/
UserDao userDao = sqlSession.getMapper(UserDao.class);

/*4.创建查询条件并调用接口的条件查询方法*/
ArrayList<String> emails = new ArrayList<String>();
emails.add("110@qq.com");
emails.add("nglszs@qq.com");
emails.add("nglszw@qq.com");

List<User> users = userDao.findByEmail1(emails);

/*5.释放资源*/
sqlSession.close();

//测试查询结果
System.out.println(users);

}

如果emails集合中有数据,控制台输出的SQL语句

1
select * from `user` WHERE email in ( ? , ? , ? )

如果emails集合中没有数据,控制台输出的SQL语句

1
select * from `user`

案例2:接口方法形参是数组类型

第一步:UserDao中新增方法

1
List<User> findByEmail2(String... emails);

第二步:配置映射文件

1
2
3
4
5
6
7
8
<select id="findByEmail2" resultType="user" >
select * from `user`
<where>
<foreach collection="array" open="email in (" close=")" item="email" separator="," >
#{email}
</foreach>
</where>
</select>

第三步:编写测试方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
@Test
public void testFindByEmail2()throws Exception{
/*1.读取配置文件并创建SqlSessionFactory*/
InputStream is = Resources.getResourceAsStream("mybatis-config.xml");
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);

/*2.获取sqlSession[这是mybatis的重要API, 使用它可以操作数据库crud*/
SqlSession sqlSession = sqlSessionFactory.openSession();

/*3.由Mybatis框架创建UserDao的实现类对象,我们称为代理对象*/
UserDao userDao = sqlSession.getMapper(UserDao.class);

/*4.创建查询条件并调用接口的条件查询方法*/
List<User> users = userDao.findByEmail2("110@qq.com","nglszs@qq.com");

/*5.释放资源*/
sqlSession.close();

//测试查询结果
System.out.println(users);

}

SQL片段抽取

Sql 中可将重复的 sql 提取出来,使用时用 include 引用即可,最终达到 sql 重用的目的

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
<!--抽取sql片段简化编写-->
<sql id="selectUser" select * from User</sql>

<select id="findById" parameterType="int" resultType="user">
<include refid="selectUser"></include> where id=#{id}
</select>

<select id="findByIds" parameterType="list" resultType="user">
<include refid="selectUser"></include>
<where>
<foreach collection="array" open="id in(" close=")" item="id" separator=",">
#{id}
</foreach>
</where>
</select>

分页插件的使用

第一步:导分页jar包

点击下载

第二步: 集成分页助手插件

在主配置文件的typeAliases标签后添加如下代码

1
2
3
<plugins>
<plugin interceptor="com.github.pagehelper.PageInterceptor"></plugin>
</plugins>

第三步:添加查询全部功能

UserDao接口中新添加的方法

1
List<User> findAll();

UserMapper中添加以下配置

1
2
3
<select id="findAll" resultType="user">
select * from `user`
</select>

第四步:测试类中使用分页

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
@Test
public void testPage()throws Exception{
/*1.读取配置文件并创建SqlSessionFactory*/
InputStream is = Resources.getResourceAsStream("mybatis-config.xml");
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);

/*2.获取sqlSession[这是mybatis的重要API, 使用它可以操作数据库crud*/
SqlSession sqlSession = sqlSessionFactory.openSession();

/*3.查询第一页的数据,每页显示2条*/
PageHelper.startPage(1,2);

/*4.由Mybatis框架创建UserDao的实现类对象,我们称为代理对象*/
UserDao userDao = sqlSession.getMapper(UserDao.class);

/*5.创建查询条件并调用接口的条件查询方法*/

List<User> users = userDao.findAll();

/*6.释放资源*/
sqlSession.close();

//测试查询结果
PageInfo<User> pi = new PageInfo<>(users);
System.out.println("总页数:"+pi.getPages());
System.out.println("总记录数:"+pi.getTotal());
System.out.println("每页显示条数:"+pi.getPageSize());
System.out.println("当前第:"+pi.getPageNum()+"页");

}

查看结果

1
2
3
4
总页数:3
总记录数:5
每页显示条数:2
当前第:1页

分页的业务层代码

接口

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
package cn.itcast.service;

import cn.itcast.domain.User;
import com.github.pagehelper.PageInfo;

public interface UserService {

/**
* 分页的业务层代码
* @param pageNum 第几页
* @param pageSize 每页显示的记录数
* @return 分页相关的所有的数据,都封装到了PageInfo,PageInfo中有什么数据,不需要太过关注
* @throws Exception
*/
PageInfo<User> pageQuery(Integer pageNum, Integer pageSize)throws Exception;
}

实现类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
package cn.itcast.service.impl;

import cn.itcast.dao.UserDao;
import cn.itcast.domain.User;
import cn.itcast.service.UserService;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;

import java.util.List;

public class UserServiceImpl implements UserService {
@Override
public PageInfo<User> pageQuery(Integer pageNum, Integer pageSize)throws Exception {
SqlSession sqlSession = new SqlSessionFactoryBuilder().build(Resources.getResourceAsStream("mybatis-config.xml")).openSession();

UserDao userDao = sqlSession.getMapper(UserDao.class);

//分页的代码
//1.设置页码和每页显示的数据
PageHelper.startPage(pageNum,pageSize);
//2.调用查询所有的方法
List<User> list = userDao.findAll();
//3.把查询到的结果封装到PageInfo对象
PageInfo<User> pageInfo = new PageInfo<>(list);

sqlSession.close();
return pageInfo;
}
}

一对一查询

表关系

一对一关系中,表关系由任意一方维护,以人和身份证为例,一个人对应一个身份证,一个身份证对应一个人。本案例中由身份证表维护表关系

1589801843745

需求

查询所有的身份证,并且要将身份证对应的人也查询出来

实现步骤

第一步:建表

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
DROP TABLE IF EXISTS `person`;
CREATE TABLE `person` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`name` varchar(30) NOT NULL COMMENT '姓名',
`age` int(11) NOT NULL COMMENT '年龄',
PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=5 DEFAULT CHARSET=utf8 COMMENT='用户表';
insert into `person`(`id`,`name`,`age`) values (1,'陈乔恩',39),(2,'钟汉良',44),(3,'林志颖',44),(4,'吴奇隆',48);
DROP TABLE IF EXISTS `card`;
CREATE TABLE `card` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`number` varchar(30) NOT NULL COMMENT '身份证号',
`pid` int(11) NOT NULL COMMENT '所属用户',
PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=5 DEFAULT CHARSET=utf8 COMMENT='身份证表';
insert into `card`(`id`,`number`,`pid`) values (1,' 110101199003079008',1),(2,'110101199003079331',2),(3,' 11010119900307299X',3),(4,' 110101199003070791',4);

第二步:创建实体类

Person 人类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
package cn.itcast.domain;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Person {
private Integer id;
private String name;
private Integer age;
}

Card 身份证类,因为需求是查询身份证,并且查询对应的人,所以应该是Card实体类中存放Perosn属性

1
2
3
4
5
6
7
8
9
10
11
12
13
14
package cn.itcast.domain;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@NoArgsConstructor
@AllArgsConstructor
public class Card {
private Integer id;
private String number;
private Person person;
}

第三步:创建Dao接口

1
2
3
4
5
6
7
8
9
package cn.itcast.dao;

import cn.itcast.domain.Card;

import java.util.List;

public interface CardDao {
List<Card> findAll();
}

第四步:创建映射文件

resultMap的分析与编写

1589812615436

在src或resources目录创建CardMapper.xml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
<?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">
<!--namespace的值是UserDao的类全名-->
<mapper namespace="cn.itcast.dao.CardDao">
<resultMap id="cardMap" type="card">
<!--把结果集中cid这一列赋值给id属性-->
<id column="cid" property="id"></id>
<!--把结果集中cnumber这一列的值赋值给number属性-->
<result column="cnumber" property="number"></result>
<!--给person属性赋值-->
<association property="person" javaType="person">
<!--把结果集中的pid这一列的值赋值给id属性-->
<id column="pid" property="id"></id>
<!--把结果集中的pname这一列的值赋值给name属性-->
<result column="pname" property="name"></result>
<!--把结果集中的page这一列的值赋值给age属性-->
<result column="page" property="age"></result>
</association>
</resultMap>

<select id="findAll" resultMap="cardMap">
SELECT
c.id 'cid',
c.number 'cnumber',
p.id 'pid',
p.name 'pname',
p.age 'page'
FROM card c
LEFT JOIN person p ON p.id = c.pid
</select>
</mapper>

第五步:主配置导入映射文件

在mybatis-config.xml中的mappers标签中引入CardMapper.xml

1
2
3
<mappers>
<mapper resource="CardMapper.xml"></mapper>
</mappers>

第六步:编写测试方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
@Test
public void testFindAll()throws Exception{
/*1.读取配置文件并创建SqlSessionFactory*/
InputStream is = Resources.getResourceAsStream("mybatis-config.xml");
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);

/*2.获取sqlSession[这是mybatis的重要API, 使用它可以操作数据库crud*/
SqlSession sqlSession = sqlSessionFactory.openSession();

/*3.由Mybatis框架创建CardDao的实现类对象,我们称为代理对象*/
CardDao cardDao = sqlSession.getMapper(CardDao.class);

/*4.查询所有身份证*/
List<Card> cards = cardDao.findAll();

/*5.释放资源*/
sqlSession.close();

//测试查询结果
System.out.println(cards);
}

小结

一对一查询,使用resultMap+association标签

一对多查询

表关系

一对多关系中,表关系由多的一方维护,以班级和学生为例,一个班级可以有多个学生,学生表应该维护表关系。

1589806452924

需求

查询所有班级信息,并且要将班级对应的学生信息也同时查询出来

实现步骤

第一步:建表

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
DROP TABLE IF EXISTS `classes`;
CREATE TABLE `classes` (
`id` INT(11) NOT NULL AUTO_INCREMENT,
`name` VARCHAR(20) DEFAULT NULL COMMENT '班级名称',
PRIMARY KEY (`id`)
) ENGINE=INNODB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8 COMMENT='班级表';
INSERT INTO `classes`(`id`,`name`) VALUES (1,'黑马一班'),(2,'黑马二班');

DROP TABLE IF EXISTS `student`;
CREATE TABLE `student` (
`id` INT(11) NOT NULL AUTO_INCREMENT,
`name` VARCHAR(24) NOT NULL,
`age` INT(11) NOT NULL,
`cid` INT(11) NOT NULL COMMENT '所属班级',
PRIMARY KEY (`id`),
KEY `cid` (`cid`)
) ENGINE=INNODB AUTO_INCREMENT=15 DEFAULT CHARSET=utf8;

INSERT INTO `student`(`id`,`name`,`age`,`cid`) VALUES (8,'王力宏',23,1),(9,'张韶涵',22,1),(10,'张晋',24,1),(11,'罗晋',25,1),(12,'唐僧',12,2),(13,'孙悟空',22,2),(14,'猪八戒',21,2);

第二步:创建实体类

Student学生类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
package cn.itcast.domain;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Student {
private Integer id;
private String name;
private Integer age;
}

Classes班级类,因为需求是查询班级,以及对应的学生,所以应该是班级类中定义List表示一堆学生

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
package cn.itcast.domain;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.util.ArrayList;
import java.util.List;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Classes {
private Integer id;
private String name;
private List<Student> students;
}

第三步:创建Dao接口

1
2
3
4
5
6
7
8
9
package cn.itcast.dao;

import cn.itcast.domain.Classes;

import java.util.List;

public interface ClassesDao {
List<Classes> findAll();
}

第四步:创建映射文件

resultMap的分析与编写

1589807864329

在src或者resources目录下创建ClassesMapper.xml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
<?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="cn.itcast.dao.ClassesDao">
<resultMap id="classesMap" type="classes">
<id column="cid" property="id"></id>
<result column="cname" property="name"></result>
<collection property="students" ofType="student">
<id column="sid" property="id"></id>
<result column="sname" property="name"></result>
<result column="sage" property="age"></result>
</collection>
</resultMap>
<select id="findAll" resultMap="classesMap">
SELECT
c.id 'cid',
c.name 'cname',
s.id 'sid',
s.name 'sname',
s.age 'sage'
FROM classes c
LEFT JOIN student s ON s.`cid` = c.`id`
</select>
</mapper>

第五步:主配置导入映射文件

在mybatis-config.xml中的mappers标签中引入ClassesMapper.xml

1
2
3
<mappers>
<mapper resource="ClassesMapper.xml"></mapper>
</mappers>

第六步:编写测试方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
@Test
public void testFindAll()throws Exception{
/*1.读取配置文件并创建SqlSessionFactory*/
InputStream is = Resources.getResourceAsStream("mybatis-config.xml");
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);

/*2.获取sqlSession[这是mybatis的重要API, 使用它可以操作数据库crud*/
SqlSession sqlSession = sqlSessionFactory.openSession();

/*3.由Mybatis框架创建UserDao的实现类对象,我们称为代理对象*/
ClassesDao classesDao = sqlSession.getMapper(ClassesDao.class);

/*4.查询所有班级*/
List<Classes> classes = classesDao.findAll();

/*5.释放资源*/
sqlSession.close();

//测试结果
System.out.println(classes);
}

小结

一对多查询,使用resultMap+collection标签

多对多关系

表关系

多对多关系中表关系由中间表维护,以学生和课程为例,一个学生对应多们课程,一个课程同时对应多个学生

1589814558313

需求

查询所有的学生,并且要将学生对应的课程也查询出来

实现步骤

第一步: 建表

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
DROP TABLE IF EXISTS `classes`;
CREATE TABLE `classes` (
`id` INT(11) NOT NULL AUTO_INCREMENT,
`name` VARCHAR(20) DEFAULT NULL COMMENT '班级名称',
PRIMARY KEY (`id`)
) ENGINE=INNODB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8 COMMENT='班级表';
INSERT INTO `classes`(`id`,`name`) VALUES (1,'黑马一班'),(2,'黑马二班');

DROP TABLE IF EXISTS `student`;
CREATE TABLE `student` (
`id` INT(11) NOT NULL AUTO_INCREMENT,
`name` VARCHAR(24) NOT NULL,
`age` INT(11) NOT NULL,
`cid` INT(11) NOT NULL COMMENT '所属班级',
PRIMARY KEY (`id`),
KEY `cid` (`cid`)
) ENGINE=INNODB AUTO_INCREMENT=15 DEFAULT CHARSET=utf8;

INSERT INTO `student`(`id`,`name`,`age`,`cid`) VALUES (8,'王力宏',23,1),(9,'张韶涵',22,1),(10,'张晋',24,1),(11,'罗晋',25,1),(12,'唐僧',12,2),(13,'孙悟空',22,2),(14,'猪八戒',21,2);

DROP TABLE IF EXISTS `course`;
CREATE TABLE `course` (
`id` INT(11) NOT NULL AUTO_INCREMENT,
`name` VARCHAR(30) NOT NULL COMMENT '课程名',
PRIMARY KEY (`id`)
) ENGINE=INNODB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8 COMMENT='课程表';
INSERT INTO `course`(`id`,`name`) VALUES (1,'语文'),(2,'数学');

DROP TABLE IF EXISTS `stu_cr`;
CREATE TABLE `stu_cr` (
`id` INT(11) NOT NULL AUTO_INCREMENT,
`sid` INT(11) NOT NULL,
`cid` INT(11) NOT NULL,
PRIMARY KEY (`id`)
) ENGINE=INNODB AUTO_INCREMENT=11 DEFAULT CHARSET=utf8;
INSERT INTO `stu_cr`(`id`,`sid`,`cid`) VALUES (1,8,1),(2,8,2),(3,9,1),(4,10,2),(5,13,2),(6,13,1),(7,14,1),(8,11,2),(9,12,1),(10,12,2);

第二步:创建实体类

Course 课程类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
package cn.itcast.domain;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Course {
/**课程ID*/
private Integer id;
/**课程名*/
private String name;
}

Student 学生类,学生类之前已经定义过了,只需要添加新的course属性即可。因为需求是查询学生信息,以及对应的课程,所以应该在学生类中定义List,表示一堆课程

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package cn.itcast.domain;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.util.List;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Student {
private Integer id;
private String name;
private Integer age;
private List<Course> courses;
}

第三步:创建Dao接口

1
2
3
4
5
6
7
package cn.itcast.dao;
import cn.itcast.domain.Student;
import java.util.List;

public interface StudentDao {
List<Student> findAll();
}

第四步:创建映射文件

resultMap的分析与编写

1589815904713

在src或resources目录下创建StudentMapper.xml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
<?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">
<!--namespace的值是UserDao的类全名-->
<mapper namespace="cn.itcast.dao.StudentDao">
<resultMap id="studentMap" type="student">
<!--把结果集中sid这一列赋值给id属性-->
<id column="sid" property="id"></id>
<!--把结果集中sname这一列的值赋值给name属性-->
<result column="sname" property="name"></result>
<!--把结果集中sage这一列的值赋值给age属性-->
<result column="sage" property="age"></result>
<!--给courses属性赋值-->
<collection property="courses" ofType="course">
<!--把结果集中的cid这一列的值赋值给id属性-->
<id column="cid" property="id"></id>
<!--把结果集中的cname这一列的值赋值给name属性-->
<result column="cname" property="name"></result>
</collection>
</resultMap>

<select id="findAll" resultMap="studentMap">
SELECT
s.id 'sid',
s.name 'sname',
s.age 'sage',
c.id 'cid',
c.name 'cname'
FROM student s
LEFT JOIN stu_cr sc ON s.id = sc.`sid`
LEFT JOIN course c ON c.`id` = sc.`cid`
</select>

</mapper>

第五步:主配置导入映射文件

在mybatis-config.xml中的mappers标签中引入StudentMapper.xml

1
2
3
<mappers>
<mapper resource="StudentMapper.xml"></mapper>
</mappers>

第六步:编写测试方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
@Test
public void testFindAll()throws Exception{
/*1.读取配置文件并创建SqlSessionFactory*/
InputStream is = Resources.getResourceAsStream("mybatis-config.xml");
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);

/*2.获取sqlSession[这是mybatis的重要API, 使用它可以操作数据库crud*/
SqlSession sqlSession = sqlSessionFactory.openSession();

/*3.由Mybatis框架创建UserDao的实现类对象,我们称为代理对象*/
StudentDao studentDao = sqlSession.getMapper(StudentDao.class);

/*4.查询所有学生*/
List<Student> students = studentDao.findAll();

/*5.释放资源*/
sqlSession.close();

//测试结果
System.out.println(students);
}

小结

多对多查询,使用resultMap+collection标签

多表查询总结

什么情况使用resultMap标签

情况1:如果查询的结果集的列名和实体类的属性名不匹配,就需要使用resultMap建立匹配规则

情况2:如果涉及到多表查询也需要使用resultMap标签,一对一查询用resultMap+association,一对多和多对多 resultMap+collection

思维导图总结

跳转链接:http://www.xmind.net/m/Z3EF3f