MyBatis接口代理实现dao层

最新推荐文章于 2022-02-27 02:23:14 发布

Z_海瑞_Z

最新推荐文章于 2022-02-27 02:23:14 发布

阅读量1.2k

点赞数 1

分类专栏： MyBatis 文章标签： mybatis java

ZHRZ

本文链接：https://blog.csdn.net/qq_20286065/article/details/107093215

版权

MyBatis 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

介绍

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

接口代理方式只需要程序员编写dao 接口（后期叫做mapper接口），由Mybatis 框架根据接口定义创建接口的动态代理对象。
需要遵循以下规范：

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

在这里插入图片描述
记忆方式：以后映射文件就是描述mapper/dao接口的文件

代码实现

创建数据库表

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');

创建实体类

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接口

package cn.itcast.dao;

import cn.itcast.domain.User;

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

创建映射文件

在src或者resource目录创建映射文件，名字叫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">
<!--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-conﬁg.xml
settings、typeAliases、properties配置参考第一天的配置

<?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>

编写测试方法

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

@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生成

实现规则

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

动态SQL

介绍

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

ﬁndbyCondition(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 不能用&& 和 ||

<where>
    <if test='条件判断'>
        查询条件拼接
    </if>
</where>

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

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

实现步骤

映射文件中定义条件查询语句

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

定义测试方法

@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语句

select * from `user` WHERE password = ?

foreach标签

作用
循环执行sql的拼接操作，例如：SELECT * FROM USER WHERE id IN (1,2,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中新增方法

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

第二步：配置映射文件

<select id="findByEmail" resultType="user" >
    select * from `user`
    <where>
        <foreach collection="list" open="email in (" close=")" item="email" separator="," >
            #{email}
        </foreach>
    </where>
</select>

第三步：编写测试方法

@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语句

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

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

select * from `user`

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

第一步：UserDao中新增方法

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

第二步：配置映射文件

<select id="findByEmail2" resultType="user" >
    select * from `user`
    <where>
        <foreach collection="array" open="email in (" close=")" item="email" separator="," >
            #{email}
        </foreach>
    </where>
</select>

第三步：编写测试方法

@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 重用的目的

<!--抽取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>

分页插件的使用

集成分页助手插件

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

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

添加查询全部功能

UserDao接口中新添加的方法

List<User> findAll();

UserMapper中添加以下配置

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

测试类中使用分页

@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()+"页");

}

查看结果

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

一对一查询

表关系

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

在这里插入图片描述

需求

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

实现步骤

第一步:建表

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 人类

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属性

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接口

package cn.itcast.dao;

import cn.itcast.domain.Card;

import java.util.List;

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

第四步:创建映射文件
resultMap的分析与编写

在这里插入图片描述

在src或resources目录创建CardMapper.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">
<!--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

<mappers>
    <mapper resource="CardMapper.xml"></mapper>
</mappers>

第六步:编写测试方法

@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标签

一对多查询

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

在这里插入图片描述
需求
查询所有班级信息，并且要将班级对应的学生信息也同时查询出来

实现步骤

第一步:建表

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学生类

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表示一堆学生

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接口

package cn.itcast.dao;

import cn.itcast.domain.Classes;

import java.util.List;

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

第四步:创建映射文件
resultMap的分析与编写

在这里插入图片描述

在src或者resources目录下创建ClassesMapper.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="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

<mappers>
    <mapper resource="ClassesMapper.xml"></mapper>
</mappers>

第六步:编写测试方法

@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标签

多对多关系

表关系

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

在这里插入图片描述

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

实现步骤

第一步: 建表

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 课程类

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，表示一堆课程

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接口

package cn.itcast.dao;
import cn.itcast.domain.Student;
import java.util.List;

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

第四步:创建映射文件
resultMap的分析与编写

在这里插入图片描述

在src或resources目录下创建StudentMapper.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">
<!--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

<mappers>
    <mapper resource="StudentMapper.xml"></mapper>
</mappers>

第六步:编写测试方法

@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标签

Z_海瑞_Z

关注

1
点赞
踩
7

收藏

觉得还不错? 一键收藏
0
评论
MyBatis接口代理实现dao层

介绍采用 Mybatis 的代理开发方式实现 dao层的开发，这种方式是我们后面进入企业的主流。接口代理方式只需要程序员编写dao 接口（后期叫做mapper接口），由Mybatis 框架根据接口定义创建接口的动态代理对象。需要遵循以下规范：映射文件中的namespace与dao接口的全类名相同映射文件中的增删改查标签的id属性与dao接口的方法名相同映射文件中的增删改查标签的parameterType属性与dao接口中方法的参数类型匹配映射文件中的增删改查标签的resultType属性与d
复制链接

扫一扫

专栏目录