MyBatis详细讲解

最新推荐文章于 2024-05-26 16:37:28 发布
最新推荐文章于 2024-05-26 16:37:28 发布
阅读量372 收藏 1
点赞数 1
文章标签： mybatis java 数据库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_53743471/article/details/126152462
版权

layout: post
#标题配置
title: MyBatis框架
#时间配置
date: 2022-01-25 20:46:00 +0800
#目录配置
categories: 框架
#标签配置
tag: 学习笔记

  • content
    {:toc}

MyBatis

一.框架介绍

  • 框架是一款半成品软件，我们可以基于这个半成品软件继续开发，来完成我们个性化的需求!

二.ORM介绍

  • ORM(Object Relational Mapping):对象关系映射

  • 指的是持久化数据和实体对象的映射模式，为了解决面向对象与关系型数据库存在的互不匹配的现象的技术。

  • 映射规则

    • 数据表->类
    • 表字段->类属性
    • 表数据->对象

三.MyBatis介绍

  • 原始JDBC的操作问题分析

    • 1.频繁创建和销毁数据库的连接会造成系统资源浪费从而影响系统性能。

    • 2.sql语句在代码中硬编码，如果要修改sql语句，就需要修改java代码，造成代码不易维护。

    • 3.查询操作时，需要手动将结果集中的数据封装到实体对象中。

    • 4.增删改查操作需要参数时，需要手动将实体对象的数据设置到sql语句的占位符。

  • 原始JDBC的操作问题解决方案

    • 1.使用数据库连接池初始化连接资源。
    • 2.将sql语句抽取到配置文件中。
    • 3.使用反射、内省等底层技术，将实体与表进行属性与字段的自动映射。

  • MyBatis介绍

    • MyBatis是一个优秀的基于Java的持久层框架，它内部封装了JDBC，使开发者只需要关注SQL语句本身，而不需要花费精力去处理加载驱动、创建连接、创建执行者等复杂的操作。
    • MyBatis通过xml或注解的方式将要执行的各种Statement配置起来，并通过Java对象和Statement中SQL的动态参数进行映射生成最终要执行的SQL语句。
    • 最后MyBatis框架执行完SQL并将结果映射为Java对象并返回。采用ORM思想解决了实体和数据库映射的问题，对JDBC进行了封装，屏蔽了JDBC API底层访问细节，使我们不用与JDBC API打交道，就可以完成对数据库的持久化操作。

四.MyBatis入门程序

  • 1.数据准备。
  • 2.导入jar包。
  • 3.在src下创建映射配置文件。
  • 4.在src下创建核心配置文件。
  • 5.编写测试类完成相关API的使用。

五.相关API

1.Resources介绍

  • org.apache.ibatis.io.Resources :加载资源的工具类。
  • 核心方法
返回值方法名说明
lnputStreamgetResourceAsStream(String fileName)通过类加载器返回指定资源的字节输入流

2.SqlSessionFactoryBuilder

  • org.apache.ibatis.session.SqlSessionFactoryBuilder:获取SqlSessionFactory工厂对象的功能类。

  • 核心方法

返回值方法名说明
SqlSessionFactorybuild(InputStream is)通过指定资源字节输入流获取SqlSession工厂对象

3.SqlSessionFactory

  • org.apache.ibatis.session.SqlSessionFactory:获取SqlSession构建者对象的工厂接口。
  • 核心方法
返回值方法名说明
SqlSessionopenSession()获取SqlSession构建者对象，并开启手动提交事务获取
SqlSessionopenSession(boolean autoCommit)SqlSession构建者对象，如果参数为true，则开启自动提交事务

4.SqlSession

  • org.apache.ibatis.session.SqlSession：构建者对象接口。用于执行 SQL、管理事务、接口代理。+
  • 核心方法
返回值方法名说明
ListselectList(String statement,Object paramter)执行查询语句，返回List集合
TselectOne(String statement,Object paramter)执行查询语句，返回一个结果对象
intinsert(String statement,Object paramter)执行新增语句，返回影响行数
intupdate(String statement,Object paramter)执行修改语句，返回影响行数
intdelete(String statement,Object paramter)执行删除语句，返回影响行数
voidcommit()提交事务
voidrollback()回滚事务
TgetMapper(Class cls)获取指定接口的代理实现类对象
voidclose()释放资源

六.映射配置文件

1.映射配置文件介绍

  • 映射配置文件包含了数据和对象之间的映射关系以及要执行的 SQL 语句
<?xml version="1.0" encoding="UTF-8" ?>
<!--MyBatis的DTD约束-->
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<!--
    mapper：核心根标签
    namespace属性：名称空间
-->
<mapper namespace="StudentMapper">
    <!--
       select：查询功能的标签
       id属性：代表唯一标识
       resultType属性：指定结果映射对象类型
       parameterType属性：指定参数映射对象类型（SQL语句有参数才需要）
     -->
    <select id="selectAll" resultType="com.wzk.bean.Student">
        SELECT * FROM student
    </select>
</mapper>

2.查询功能

  • ：查询功能标签。

  • 属性

    id：唯一标识， 配合名称空间使用。

    parameterType：指定参数映射的对象类型。

    resultType：指定结果映射的对象类型。

  • SQL 获取参数: #{属性名}

  • 例子

<select id="selectById" resultType="com.wzk.bean.Student" parameterType="java.lang.Integer">
    SELECT * FROM student WHERE id = #{id}
</select>

3.新增功能

  • ：新增功能标签。

  • 属性

    id：唯一标识， 配合名称空间使用。

    parameterType：指定参数映射的对象类型。

    resultType：指定结果映射的对象类型。

  • SQL 获取参数: #{属性名}

  • 例子
<insert id="insert" parameterType="com.wzk.bean.Student">
    INSERT INTO student VALUES (#{id},#{name},#{age})
</insert>

4.修改功能

  • ：修改功能标签。

  • 属性

    id：唯一标识， 配合名称空间使用。

    parameterType：指定参数映射的对象类型。

    resultType：指定结果映射的对象类型。

  • SQL 获取参数: #{属性名}

  • 例子
<update id="update" parameterType="com.wzk.bean.Student">
    UPDATE student SET name = #{name},age = #{age} WHERE id = #{id}
</update>

5.删除功能

  • ：查询功能标签。

  • 属性

    id：唯一标识， 配合名称空间使用。

    parameterType：指定参数映射的对象类型。

    resultType：指定结果映射的对象类型。

  • SQL 获取参数: #{属性名}

  • 例子

<delete id="delete" parameterType="java.lang.Integer">
    DELETE FROM student WHERE id = #{id}
</delete>

七.核心配置文件

1.核心配置文件介绍

核心配置文件包含了 MyBatis 最核心的设置和属性信息。如数据库的连接、事务、连接池信息等。

如下图:

<?xml version="1.0" encoding="UTF-8" ?>
<!--MyBatis的DTD约束-->
<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd">

<!--configuration 核心根标签-->
<configuration>

    <!--environments配置数据库环境，环境可以有多个。default属性指定使用的是哪个-->
    <environments default="mysql">
        <!--environment配置数据库环境  id属性唯一标识-->
        <environment id="mysql">
            <!-- transactionManager事务管理。  type属性，采用JDBC默认的事务-->
            <transactionManager type="JDBC"></transactionManager>
            <!-- dataSource数据源信息   type属性 连接池-->
            <dataSource type="POOLED">
                <!-- property获取数据库连接的配置信息 -->
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://127.0.0.1:3306/mybatis"/>
                <property name="username" value="root"/>
                <property name="password" value="root"/>
            </dataSource>
        </environment>
    </environments>

    <!-- mappers引入映射配置文件 -->
    <mappers>
        <!-- mapper 引入指定的映射配置文件   resource属性指定映射配置文件的名称 -->
        <mapper resource="StudentMapper.xml"/>
    </mappers>
</configuration>

2.数据库连接配置文件引入

  • properties标签引入外部文件

        <!--引入数据库连接的配置文件-->
    <properties resource="jdbc.properties"/>

  • 具体使用，如下配置

      <!-- property获取数据库连接的配置信息 -->
    <property name="driver" value="${driver}" />
    <property name="url" value="${url}" />
    <property name="username" value="${username}" />
    <property name="password" value="${password}" />

3.起别名

  • ：为全类名起别名的父标签。

  • ：为全类名起别名的子标签。

  • 属性

    type：指定全类名

    alias：指定别名

  • ：为指定包下所有类起别名的子标签。(别名就是类名)

  • 如下图

别名数据类型
stringjava.lang.String
longjava.lang.Long
intjava.lang.Integer
doublejava.lang.Double
booleanjava.lang.Boolean
……

  • 具体如下配置

        <!--起别名-->
    <typeAliases>
        <typeAlias type="com.itheima.bean.Student" alias="student"/>
        <!--<package name="com.itheima.bean"/>-->
    </typeAliase

4.核心配置文件小结

  • 核心配置文件包含了MyBatis最核心的设置和属性信息。如数据库的连接、事务
    连接池信息等。
  • ︰核心根标签。
  • :引入数据库连接信息配置文件标签。
  • :起别名标签。
  • :配置数据库环境标签。
  • :配置数据库信息标签。
  • :事务管理标签。
  • ∶数据源标签。
  • :数据库连接信息标签。
  • :引入映射配置文件标签。

八.Mybatis传统方式开发

1.Dao 层传统实现方式

  • 分层思想：控制层(controller)、业务层(service)、持久层(dao)。
  • 调用流程

​ 控制层—>业务层—>持久层—>DB

2.LOG4J的配置和使用

  • 在日常开发过程中，排查问题时难免需要输出 MyBatis 真正执行的 SQL 语句、参数、结果等信息，我们就可以借助 LOG4J 的功能来实现执行信息的输出。

  • 使用步骤：

    • 1.导入jar包
    • 2.修改核心配置文件
    <!--配置LOG4J-->
    <settings>
        <setting name="logImpl" value="log4j"/>
    </settings>
    • 3.在src下编写LOG4J配置文件
    # Global logging configuration
# ERROR WARN INFO DEBUG
log4j.rootLogger=DEBUG, stdout
# Console output...
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%5p [%t] - %m%n

九.MyBatis接口代理方式实现dao层

1.接口代理方式-实现规则

  • 传统方式实现Dao层，我们既要写接口，还要写实现类。而MyBatis框架可以帮助我们省略编写Dao层接口实现类的步骤。程序员只需要编写接口，由MyBatis框架根据接口的定义来创建该接口的动态代理对象。

  • 实现规则

    • 1.映射配置文件中的名称空间必须和Dao层接口的全类名（包括路径）相同。如：com.wzk.mapper.StudentMapper
    • 2.映射配置文件中的增删改查标签的id属性必须和Dao层接口的方法名相同。
    • 3.映射配置文件中的增删改查标签的parameterType属性必须和Dao层接口方法的参数相同。
    • 4.映射配置文件中的增删改查标签的resultType属性必须和Dao层接口方法的返回值相同。

2.接口代理方式-代码实现

  • 1.删除 mapper层接口的实现类。
  • 2.修改映射配置文件。
  • 3.修改service层接口的实现类，采用接口代理方式实现功能。

3.测试代理方式

 public Student selectById(Integer id) {
        Student stu = null;
        SqlSession sqlSession = null;
        InputStream is = null;
        try{
            //1.加载核心配置文件
            is = Resources.getResourceAsStream("MyBatisConfig.xml");

            //2.获取SqlSession工厂对象
            SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);

            //3.通过工厂对象获取SqlSession对象
            sqlSession = sqlSessionFactory.openSession(true);

            //4.获取StudentMapper接口的实现类对象
            StudentMapper mapper = sqlSession.getMapper(StudentMapper.class); // StudentMapper mapper = new StudentMapperImpl();

            //5.通过实现类对象调用方法，接收结果
            stu = mapper.selectById(id);

        } catch (Exception e) {

        } finally {
            //6.释放资源
            if(sqlSession != null) {
                sqlSession.close();
            }
            if(is != null) {
                try {
                    is.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

        //7.返回结果
        return stu;
    }

4.源码分析

  • 分析动态代理对象如何生成的？

    通过动态代理开发模式，我们只编写一个接口，不写实现类，我们通过 getMapper() 方法最终获取到 org.apache.ibatis.binding.MapperProxy 代理对象，然后执行功能，而这个代理对象正是 MyBatis 使用了 JDK 的动态代理技术，帮助我们生成了代理实现类对象。从而可以进行相关持久化操作。

  • 分析方法是如何执行的？

    动态代理实现类对象在执行方法的时候最终调用了 mapperMethod.execute() 方法，这个方法中通过 switch 语句根据操作类型来判断是新增、修改、删除、查询操作，最后一步回到了 MyBatis 最原生的 SqlSession 方式来执行增删改查。

5.知识小结

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

  • 实现规则 ：

    • 1.映射配置文件中的名称空间必须和 Dao 层接口的全类名相同。
    • 2.映射配置文件中的增删改查标签的 id 属性必须和 Dao 层接口的方法名相同。
    • 3.映射配置文件中的增删改查标签的 parameterType 属性必须和 Dao 层接口方法的参数相同。
    • 4.映射配置文件中的增删改查标签的 resultType 属性必须和 Dao 层接口方法的返回值相同。

  • 获取动态代理对象

    • SqlSession 功能类中的 getMapper() 方法。

十.MyBatis映射配置文件-动态SQL

1.动态SQL介绍

  • Mybatis 的映射文件中，前面我们的 SQL 都是比较简单的，有些时候业务逻辑复杂时，我们的 SQL是动态变化的，此时在前面的学习中我们的 SQL 就不能满足要求了。
  • 多条件查询
  • 动态SQL标签
    • ：条件判断标签
    • ：循环遍历标签

2.标签（if）

  • ：条件标签。如果有动态条件，则使用该标签代替where关键字
  • ：条件判断标签
<if test="条件判断">
	查询条件拼接
</if>

3.标签（foreach）

  • ：循环遍历标签。适用于多个参数或者的关系
<foreach collection="" open="" close="" item="" separator="">
	获取参数
</foreach>
  • 属性
    • collection：参数容器类型， (list-集合， array-数组)。
    • open：开始的 SQL 语句。
    • close：结束的 SQL 语句。
    • item：参数变量名。
    • separator：分隔符。

4.SQL片段抽取

  • 我们可以将一些重复性的 SQL 语句进行抽取，以达到复用的效果。
  • ：抽取 SQL 语句标签。
<sql id="片段唯一标识">抽取的 SQL 语句</sql>
  • ：引入 SQL 片段标签。
<include refid=“片段唯一标识”/>
  • Sql 中可将重复的 sql 提取出来，使用时用 include 引用即可，最终达到 sql 重用的目的
<!--抽取sql片段简化编写-->
<sql id="select" SELECT * FROM student</sql>
<select id="findById" parameterType="int" resultType="student">
    <include refid="selectStudent"></include> where id=#{id}
</select>
<select id="findByIds" parameterType="list" resultType="student">
    <include refid="select"></include>
    <where>
        <foreach collection="array" open="id in(" close=")" item="id" separator=",">
            #{id}
        </foreach>
    </where>
</select>

5.知识小结

MyBatis映射文件配置：

<select>：查询

<insert>：插入

<update>：修改

<delete>：删除

<where>：where条件

<if>：if判断

<foreach>：循环

<sql>：sql片段抽取

十一.MyBatis核心配置文件-分页插件

1.分页插件介绍

  • 在企业级开发中，分页也是一种常见的技术。而目前使用的 MyBatis 是不带分页功能的，如果想实现分页的 功能，需要我们手动编写 LIMIT 语句。但是不同的数据库实现分页的 SQL 语句也是不同的，所以手写分页 成本较高。这个时候就可以借助分页插件来帮助我们实现分页功能。
  • PageHelper：第三方分页助手。将复杂的分页操作进行封装，从而让分页功能变得非常简单。

2.分页插件的使用

  • ①导入PageHelper的jar包

  • ②在mybatis核心配置文件中配置PageHelper插件

    <!-- 注意：分页助手的插件  配置在通用mapper之前 -->
<plugin interceptor="com.github.pagehelper.PageHelper">
    <!-- 指定方言 -->
    <property name="dialect" value="mysql"/>
</plugin>

    ③测试分页数据获取

    @Test
public void testPageHelper(){
    //设置分页参数
    PageHelper.startPage(1,2);

    List<User> select = userMapper2.select(null);
    for(User user : select){
        System.out.println(user);
    }
}

3.分页插件相关参数

  • Pagelnfo :封装分页相关参数的功能类。
  • 核心方法
返回值方法名说明
longgetTotal()获取总条数
intgetPages()获取总页数
intgetPageNum()获取当前页
intgetPageSize()获取每页显示条数
intgetPrePage()获取上一页
intgetNextPage()获取下一页
booleanislsFirstPage()获取是否是第一页
booleanislsLastPage()获取是否是最后一页

4.分页插件知识小结

​ 分页：可以将很多条结果进行分页显示。

  • 分页插件 jar 包： pagehelper-5.1.10.jar jsqlparser-3.1.jar

  • ：集成插件标签。

  • 分页助手相关 API

    ​ 1.PageHelper：分页助手功能类。

    1. startPage()：设置分页参数
    2. PageInfo：分页相关参数功能类。
    3. getTotal()：获取总条数
    4. getPages()：获取总页数
    5. getPageNum()：获取当前页
    6. getPageSize()：获取每页显示条数
    7. getPrePage()：获取上一页
    8. getNextPage()：获取下一页
    9. isIsFirstPage()：获取是否是第一页
    10. isIsLastPage()：获取是否是最后一页

十二.MyBatis多表操作

1.多表模型

  • 我们之前学习的都是基于单表操作的，而实际开发中，随着业务难度的加深，肯定需要多表操作的。
  • 多表模型分类
    • 一对一：在任意一方建立外键，关联对方的主键。
    • 一对多：在多的一方建立外键，关联一的一方的主键。
    • 多对多：借助中间表，中间表至少两个字段，分别关联两张表的主键。

2.多表模型一对一操作

  • 1.一对一模型： 人和身份证，一个人只有一个身份证

  • 2.代码实现

    • 步骤一: sql语句准备

      CREATE TABLE person(
	id INT PRIMARY KEY AUTO_INCREMENT,
	NAME VARCHAR(20),
	age INT
);
INSERT INTO person VALUES (NULL,'张三',23);
INSERT INTO person VALUES (NULL,'李四',24);
INSERT INTO person VALUES (NULL,'王五',25);

CREATE TABLE card(
	id INT PRIMARY KEY AUTO_INCREMENT,
	number VARCHAR(30),
	pid INT,
	CONSTRAINT cp_fk FOREIGN KEY (pid) REFERENCES person(id)
);
INSERT INTO card VALUES (NULL,'12345',1);
INSERT INTO card VALUES (NULL,'23456',2);
INSERT INTO card VALUES (NULL,'34567',3);

    • 步骤二:配置文件

      <?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.wzk.table01.OneToOneMapper">
    <!--配置字段和实体对象属性的映射关系-->
    <resultMap id="oneToOne" type="card">
        <!--id标签是为主键属性配置，其余属性用result标签-->
        <id column="cid" property="id" />
        <result column="number" property="number" />
        <!--
            association：配置被包含对象的映射关系
            property：被包含对象的变量名
            javaType：被包含对象的数据类型
        -->
        <association property="p" javaType="person">
            <id column="pid" property="id" />
            <result column="name" property="name" />
            <result column="age" property="age" />
        </association>
    </resultMap>

    <select id="selectAll" resultMap="oneToOne">
        SELECT c.id cid,number,pid,NAME,age FROM card c,person p WHERE c.pid=p.id
    </select>
</mapper>

    • 步骤三：测试类

      @Test
    public void selectAll() throws IOException {
        InputStream is = Resources.getResourceAsStream("MyBatisConfig.xml");

        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);

        SqlSession sqlSession = sqlSessionFactory.openSession(true);

        OneToOneMapper mapper = sqlSession.getMapper(OneToOneMapper.class);


        List<Card> list = mapper.selectAll();

        for (Card c : list) {
            System.out.println(c);
        }

        sqlSession.close();
        is.close();
    }

    3.一对一配置总结:

    <resultMap>：配置字段和对象属性的映射关系标签。
    id 属性：唯一标识
    type 属性：实体对象类型
<id>：配置主键映射关系标签。
<result>：配置非主键映射关系标签。
    column 属性：表中字段名称
    property 属性： 实体对象变量名称
<association>：配置被包含对象的映射关系标签。
    property 属性：被包含对象的变量名
    javaType 属性：被包含对象的数据类型

3.多表模型一对多操作

  1. 一对多模型： 一对多模型：班级和学生，一个班级可以有多个学生。

  2. 代码实现

    • 步骤一: sql语句准备

      CREATE TABLE classes(
	id INT PRIMARY KEY AUTO_INCREMENT,
	NAME VARCHAR(20)
);
INSERT INTO classes VALUES (NULL,'一班');
INSERT INTO classes VALUES (NULL,'二班');


CREATE TABLE student(
	id INT PRIMARY KEY AUTO_INCREMENT,
	NAME VARCHAR(30),
	age INT,
	cid INT,
	CONSTRAINT cs_fk FOREIGN KEY (cid) REFERENCES classes(id)
);
INSERT INTO student VALUES (NULL,'张三',23,1);
INSERT INTO student VALUES (NULL,'李四',24,1);
INSERT INTO student VALUES (NULL,'王五',25,2);
INSERT INTO student VALUES (NULL,'赵六',26,2);

    • 步骤二:配置文件

      <mapper namespace="com.itheima.table02.OneToManyMapper">
    <resultMap id="oneToMany" type="classes">
        <id column="cid" property="id"/>
        <result column="cname" property="name"/>

        <!--
            collection：配置被包含的集合对象映射关系
            property：被包含对象的变量名
            ofType：被包含对象的实际数据类型
        -->
        <collection property="students" ofType="student">
            <id column="sid" property="id"/>
            <result column="sname" property="name"/>
            <result column="sage" property="age"/>
        </collection>
    </resultMap>
    <select id="selectAll" resultMap="oneToMany">
        SELECT c.id cid,c.name cname,s.id sid,s.name sname,s.age sage FROM classes c,student s WHERE c.id=s.cid
    </select>
</mapper>

    • 步骤三：测试类

          @Test
    public void selectAll() throws Exception{
        //1.加载核心配置文件
        InputStream is = Resources.getResourceAsStream("MyBatisConfig.xml");

        //2.获取SqlSession工厂对象
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);

        //3.通过工厂对象获取SqlSession对象
        SqlSession sqlSession = sqlSessionFactory.openSession(true);

        //4.获取OneToManyMapper接口的实现类对象
        OneToManyMapper mapper = sqlSession.getMapper(OneToManyMapper.class);

        //5.调用实现类的方法，接收结果
        List<Classes> classes = mapper.selectAll();

        //6.处理结果
        for (Classes cls : classes) {
            System.out.println(cls.getId() + "," + cls.getName());
            List<Student> students = cls.getStudents();
            for (Student student : students) {
                System.out.println("\t" + student);
            }
        }

        //7.释放资源
        sqlSession.close();
        is.close();
    }

    3.一对多配置文件总结：

    <resultMap>：配置字段和对象属性的映射关系标签。
    id 属性：唯一标识
    type 属性：实体对象类型
<id>：配置主键映射关系标签。
<result>：配置非主键映射关系标签。
    column 属性：表中字段名称
    property 属性： 实体对象变量名称
<collection>：配置被包含集合对象的映射关系标签。
    property 属性：被包含集合对象的变量名
    ofType 属性：集合中保存的对象数据类型

4.多表模型多对多操作

  1. 多对多模型：学生和课程，一个学生可以选择多门课程、一个课程也可以被多个学生所选择。

  2. 代码实现

    • 步骤一: sql语句准备

      CREATE TABLE course(
	id INT PRIMARY KEY AUTO_INCREMENT,
	NAME VARCHAR(20)
);
INSERT INTO course VALUES (NULL,'语文');
INSERT INTO course VALUES (NULL,'数学');


CREATE TABLE stu_cr(
	id INT PRIMARY KEY AUTO_INCREMENT,
	sid INT,
	cid INT,
	CONSTRAINT sc_fk1 FOREIGN KEY (sid) REFERENCES student(id),
	CONSTRAINT sc_fk2 FOREIGN KEY (cid) REFERENCES course(id)
);
INSERT INTO stu_cr VALUES (NULL,1,1);
INSERT INTO stu_cr VALUES (NULL,1,2);
INSERT INTO stu_cr VALUES (NULL,2,1);
INSERT INTO stu_cr VALUES (NULL,2,2);

    • 步骤二:配置文件

      <?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.itheima.table03.ManyToManyMapper">
    <resultMap id="manyToMany" type="student">
        <id column="sid" property="id"/>
        <result column="sname" property="name"/>
        <result column="sage" property="age"/>

        <collection property="courses" ofType="course">
            <id column="cid" property="id"/>
            <result column="cname" property="name"/>
        </collection>
    </resultMap>
    <select id="selectAll" resultMap="manyToMany">
        SELECT sc.sid,s.name sname,s.age sage,sc.cid,c.name cname FROM student s,course c,stu_cr sc WHERE sc.sid=s.id AND sc.cid=c.id
    </select>
</mapper>

    • 步骤三：测试类

       @Test
    public void selectAll() throws Exception{
        //1.加载核心配置文件
        InputStream is = Resources.getResourceAsStream("MyBatisConfig.xml");

        //2.获取SqlSession工厂对象
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);

        //3.通过工厂对象获取SqlSession对象
        SqlSession sqlSession = sqlSessionFactory.openSession(true);

        //4.获取ManyToManyMapper接口的实现类对象
        ManyToManyMapper mapper = sqlSession.getMapper(ManyToManyMapper.class);

        //5.调用实现类的方法，接收结果
        List<Student> students = mapper.selectAll();

        //6.处理结果
        for (Student student : students) {
            System.out.println(student.getId() + "," + student.getName() + "," + student.getAge());
            List<Course> courses = student.getCourses();
            for (Course cours : courses) {
                System.out.println("\t" + cours);
            }
        }

        //7.释放资源
        sqlSession.close();
        is.close();
    }

    3.多对多配置文件总结：

    <resultMap>：配置字段和对象属性的映射关系标签。
	id 属性：唯一标识
	type 属性：实体对象类型
 <id>：配置主键映射关系标签。
 <result>：配置非主键映射关系标签。
	column 属性：表中字段名称
	property 属性： 实体对象变量名称
<collection>：配置被包含集合对象的映射关系标签。
	property 属性：被包含集合对象的变量名
	ofType 属性：集合中保存的对象数据类型

5.多表模型操作总结

<resultMap>：配置字段和对象属性的映射关系标签。
    id 属性：唯一标识
    type 属性：实体对象类型
<id>：配置主键映射关系标签。
<result>：配置非主键映射关系标签。
	column 属性：表中字段名称
	property 属性： 实体对象变量名称
<association>：配置被包含对象的映射关系标签。
	property 属性：被包含对象的变量名
	javaType 属性：被包含对象的数据类型
<collection>：配置被包含集合对象的映射关系标签。
	property 属性：被包含集合对象的变量名
	ofType 属性：集合中保存的对象数据类型

十三.MyBatis注解开发

1.常用注解介绍

  • 我们除了可以使用映射配置文件来操作以外，还可以使用注解形式来操作。
  • 常用注解
  • @Select(“查询的 SQL 语句”)：执行查询操作注解
  • @Insert(“新增的 SQL 语句”)：执行新增操作注解
  • @Update(“修改的 SQL 语句”)：执行修改操作注解
  • @Delete(“删除的 SQL 语句”)：执行删除操作注解

2.注解实现查询操作

  • 创建接口和查询方法
  • 在核心配置文件中配置映射关系
  • 编写测试类

3.注解实现新增操作

  • 创建新增方法
  • 编写测试类

4.注解实现修改操作

  • 创建修改方法
  • 编写测试类

5.注解实现删除操作

  • 创建删除方法
  • 编写测试类

6.注解开发总结

注解可以简化开发操作，省略映射配置文件的编写。

  • 常用注解

    @Select(“查询的 SQL 语句”)：执行查询操作注解

@Insert(“查询的 SQL 语句”)：执行新增操作注解

@Update(“查询的 SQL 语句”)：执行修改操作注解

@Delete(“查询的 SQL 语句”)：执行删除操作注解

  • 配置映射关系

    <mappers>
    <package name="接口所在包"/>
</mappers>

十四.注解多表操作

1.一对一查询

  • 一对一查询的需求：查询一个用户信息，与此同时查询出该用户对应的身份证信息

  • 对应的sql语句：

SELECT * FROM card；

SELECT * FROM person WHERE id=#{id};
1.1创建PersonMapper接口
public interface PersonMapper {
    //根据id查询
    @Select("SELECT * FROM person WHERE id=#{id}")
    public abstract Person selectById(Integer id);
}
1.2使用注解配置Mapper
public interface CardMapper {
    //查询全部
    @Select("SELECT * FROM card")
    @Results({
            @Result(column = "id",property = "id"),
            @Result(column = "number",property = "number"),
            @Result(
                    property = "p",             // 被包含对象的变量名
                    javaType = Person.class,    // 被包含对象的实际数据类型
                    column = "pid",             // 根据查询出的card表中的pid字段来查询person表
                    /*
                        one、@One 一对一固定写法
                        select属性：指定调用哪个接口中的哪个方法
                     */
                    one = @One(select = "com.wzk.one_to_one.PersonMapper.selectById")
            )
    })
    public abstract List<Card> selectAll();
}
1.3核心配置文件
	<!--配置映射关系-->
	<mappers>
        <package name="com.wzk.one_to_one"/>
    </mappers>
1.4测试类
public class Test01 {
    @Test
    public void selectAll() throws Exception{
        //1.加载核心配置文件
        InputStream is = Resources.getResourceAsStream("MyBatisConfig.xml");

        //2.获取SqlSession工厂对象
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);

        //3.通过工厂对象获取SqlSession对象
        SqlSession sqlSession = sqlSessionFactory.openSession(true);

        //4.获取CardMapper接口的实现类对象
        CardMapper mapper = sqlSession.getMapper(CardMapper.class);

        //5.调用实现类对象中的方法，接收结果
        List<Card> list = mapper.selectAll();

        //6.处理结果
        for (Card card : list) {
            System.out.println(card);
        }

        //7.释放资源
        sqlSession.close();
        is.close();
    }

}
1.5一对一配置总结
@Results：封装映射关系的父注解。
	Result[] value()：定义了 Result 数组
@Result：封装映射关系的子注解。
	column 属性：查询出的表中字段名称
	property 属性：实体对象中的属性名称
	javaType 属性：被包含对象的数据类型
	one 属性：一对一查询固定属性
@One：一对一查询的注解。
	select 属性：指定调用某个接口中的方法

2.一对多查询

  • 一对多查询的需求：查询一个课程，与此同时查询出该该课程对应的学生信息

  • 对应的sql语句：

SELECT * FROM classes

SELECT * FROM student WHERE cid=#{cid}
2.1创建StudentMapper接口
public interface StudentMapper {
    //根据cid查询student表
    @Select("SELECT * FROM student WHERE cid=#{cid}")
    public abstract List<Student> selectByCid(Integer cid);
}
2.2使用注解配置Mapper
public interface ClassesMapper {
    //查询全部
    @Select("SELECT * FROM classes")
    @Results({
            @Result(column = "id",property = "id"),
            @Result(column = "name",property = "name"),
            @Result(
                    property = "students",  // 被包含对象的变量名
                    javaType = List.class,  // 被包含对象的实际数据类型
                    column = "id",          // 根据查询出的classes表的id字段来查询student表
                    /*
                        many、@Many 一对多查询的固定写法
                        select属性：指定调用哪个接口中的哪个查询方法
                     */
                    many = @Many(select = "com.itheima.one_to_many.StudentMapper.selectByCid")
            )
    })
    public abstract List<Classes> selectAll();
}
2.3核心配置文件
	<!--配置映射关系-->
    <mappers>
        <package name="com.wzk"/>
    </mappers>
2.4测试类
public class Test01 {
    @Test
    public void selectAll() throws Exception{
        //1.加载核心配置文件
        InputStream is = Resources.getResourceAsStream("MyBatisConfig.xml");

        //2.获取SqlSession工厂对象
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);

        //3.通过工厂对象获取SqlSession对象
        SqlSession sqlSession = sqlSessionFactory.openSession(true);

        //4.获取ClassesMapper接口的实现类对象
        ClassesMapper mapper = sqlSession.getMapper(ClassesMapper.class);

        //5.调用实现类对象中的方法，接收结果
        List<Classes> list = mapper.selectAll();

        //6.处理结果
        for (Classes cls : list) {
            System.out.println(cls.getId() + "," + cls.getName());
            List<Student> students = cls.getStudents();
            for (Student student : students) {
                System.out.println("\t" + student);
            }
        }

        //7.释放资源
        sqlSession.close();
        is.close();
    }

}
2.5一对多配置总结
@Results：封装映射关系的父注解。
	Result[] value()：定义了 Result 数组
@Result：封装映射关系的子注解。
	column 属性：查询出的表中字段名称
	property 属性：实体对象中的属性名称
	javaType 属性：被包含对象的数据类型
	many 属性：一对多查询固定属性
@Many：一对多查询的注解。
	select 属性：指定调用某个接口中的方法

3.多对多查询

  • 多对多查询的需求：查询学生以及所对应的课程信息

  • 对应的sql语句：

SELECT DISTINCT s.id,s.name,s.age FROM student s,stu_cr sc WHERE sc.sid=s.id
SELECT c.id,c.name FROM stu_cr sc,course c WHERE sc.cid=c.id AND sc.sid=#{id}
3.1添加CourseMapper 接口方法
public interface CourseMapper {
    //根据学生id查询所选课程
    @Select("SELECT c.id,c.name FROM stu_cr sc,course c WHERE sc.cid=c.id AND sc.sid=#{id}")
    public abstract List<Course> selectBySid(Integer id);
}
3.2使用注解配置Mapper
public interface StudentMapper {
    //查询全部
    @Select("SELECT DISTINCT s.id,s.name,s.age FROM student s,stu_cr sc WHERE sc.sid=s.id")
    @Results({
            @Result(column = "id",property = "id"),
            @Result(column = "name",property = "name"),
            @Result(column = "age",property = "age"),
            @Result(
                    property = "courses",   // 被包含对象的变量名
                    javaType = List.class,  // 被包含对象的实际数据类型
                    column = "id",          // 根据查询出student表的id来作为关联条件，去查询中间表和课程表
                    /*
                        many、@Many 一对多查询的固定写法
                        select属性：指定调用哪个接口中的哪个查询方法
                     */
                    many = @Many(select = "com.itheima.many_to_many.CourseMapper.selectBySid")
            )
    })
    public abstract List<Student> selectAll();
}
3.3核心配置文件
	<!--配置映射关系-->
    <mappers>
        <package name="com.wzk"/>
    </mappers>
3.4测试类
public class Test01 {
    @Test
    public void selectAll() throws Exception{
        //1.加载核心配置文件
        InputStream is = Resources.getResourceAsStream("MyBatisConfig.xml");

        //2.获取SqlSession工厂对象
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);

        //3.通过工厂对象获取SqlSession对象
        SqlSession sqlSession = sqlSessionFactory.openSession(true);

        //4.获取StudentMapper接口的实现类对象
        StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);

        //5.调用实现类对象中的方法，接收结果
        List<Student> list = mapper.selectAll();

        //6.处理结果
        for (Student student : list) {
            System.out.println(student.getId() + "," + student.getName() + "," + student.getAge());
            List<Course> courses = student.getCourses();
            for (Course cours : courses) {
                System.out.println("\t" + cours);
            }
        }

        //7.释放资源
        sqlSession.close();
        is.close();
    }

}
3.5多对多配置总结
@Results：封装映射关系的父注解。
	Result[] value()：定义了 Result 数组
@Result：封装映射关系的子注解。
	column 属性：查询出的表中字段名称
	property 属性：实体对象中的属性名称
	javaType 属性：被包含对象的数据类型
	many 属性：一对多查询固定属性
@Many：一对多查询的注解。
	select 属性：指定调用某个接口中的方法

十五.构建SQL语句

1.SQL构建对象介绍

  • 我们之前通过注解开发时，相关 SQL 语句都是自己直接拼写的。一些关键字写起来比较麻烦、而且容易出错。
  • MyBatis 给我们提供了 org.apache.ibatis.jdbc.SQL 功能类，专门用于构建 SQL 语句
方法名说明
SELECT(String…column)根据字段拼接查询语句
FROM(String…table)根据表名拼接语句
WHERE(String…condition)根据条件拼接语句
INSERT_INTO(String table)根据表名拼接新增语句
VALUES(String column,String values)根据字段和值拼接插入数据语句
UPDATE(String table)根据表名拼接修改语句
DELETE_FROM(String table)根据表名拼接删除语句
……

2.查询功能的实现

  • 定义功能类并提供获取查询的 SQL 语句的方法。 

  • @SelectProvider：生成查询用的 SQL 语句注解。

    type 属性：生成 SQL 语句功能类对象

    method 属性：指定调用方法

3.新增功能的实现

  • 定义功能类并提供获取新增的 SQL 语句的方法。

  • @InsertProvider：生成新增用的 SQL 语句注解。

    type 属性：生成 SQL 语句功能类对象

    method 属性：指定调用方法

4.修改功能的实现

  • 定义功能类并提供获取修改的 SQL 语句的方法。

  • @UpdateProvider：生成修改用的 SQL 语句注解。

    type 属性：生成 SQL 语句功能类对象

    method 属性：指定调用方法

5.删除功能的实现

  • 定义功能类并提供获取删除的 SQL 语句的方法。

  • @DeleteProvider：生成删除用的 SQL 语句注解。

    type 属性：生成 SQL 语句功能类对象

    method 属性：指定调用方法

拾光1024
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
Mybatis动态sql及分页
weixin_44557427的博客
10-18 182
一、 1.mybatis动态sql 1.1 if 1.2 trim 1.3 foreach 遍历集合，批量查询、通常用于in关键字 1.4 其他 choose/set/where 2.模糊查询（3种方式） 2.1 参数中直接加入%% 2.2 使用${...}代替#{...}（不建议使用该方式，有...
mybatis详细使用讲解
08-14
mybatis详细讲解，适合初级开发者使用
mybatis-page
chengzhahui1998的博客
12-11 451
#mybatis-page mybais-page 是自定义的一个mybatis分页插件，方便系统集成，用户只需要集成到自己的系统中就可以实现自动分页功能。目前只支持mysql和oracle，当然用户也可以自己扩展自己需要的数据库分页。为方便系统开发，支持mybatis的XML动态刷新功能。 ...
MyBatis详细教程！！（入门版）
最新发布
ii804070359的博客
05-26 718
MyBatis是一款持久层框架，用于简化JDBC开发持久层：持久化操作的层，通常指数据访问层（DAO），是用来操作数据库的。
mybatis-page最简单分页插件
Q_zx1bydcom的专栏
12-07 1024
地址：https://coding.net/u/medusa/p/mybatis-page/git?ref=myread 说明 无需count，自动实现分页并返回分页信息，使用方法简单可能是使用起来最方便的分页插件包含了mybatis-3.4.1 mybatis-spring-1.3.0不需要重复引入 插件目前支持以下数据库 MysqlOracle 配置方法 Maven依赖
mybaties的分页查询问题记录
毅香雪海的博客
09-07 176
mybaties的分页查询
详细分析MybatisPlus中的Page类（附实战）
码农研究僧的博客
01-25 1万+
Page 类是用于封装分页信息的 Java 类，它主要用于在数据库查询时支持分页查询操作。
mybatis 教程讲解
03-03
mybatis 教程
尚硅谷mybatis高深讲解
06-22
"尚硅谷mybatis高深讲解"是一套全面深入的教程，旨在帮助开发者深入理解并熟练运用MyBatis框架。 首先，MyBatis的核心理念是动态SQL，这使得我们可以根据业务需求自由编写SQL语句，而无需硬编码到Java代码中。通过...
Mybatis源码讲解，面向秋招
10-09
Mybatis 是一个流行的 Java 持久层框架，它简化了数据库操作，通过 XML 或注解方式将 SQL 语句与 Java 代码分离。在面试中，了解 Mybatis 的核心概念和执行流程对于应聘者来说至关重要。下面我们将深入探讨 Mybatis ...
mybatis详细示例操作
09-06
学习mybatis的资料，附有详细示例讲解
MySQL 之mybatis分页使用多个Page
vihem的博客
12-13 819
单个查询会查询多个不同的sql，此时用一个Page已经不合适了，所以需要使用多个Page进行。
MyBatis-Plus分页查询IPage的使用方法，如何自定义分页查询功能？
m0_70325779的博客
04-19 5992
介绍 MyBatisPlus 分页插件IPage的使用和条件构造器 LambdQueryWrapper 的使用
Mybatis中简单语法总结
小小小怪兽_
09-05 671
一、分页插件（PageHelper） 需要注意的点： （1）只有紧跟在PageHelper.startPage(int page,int pageSize)方法后的第一个Mybatis的查询方法会被分页； （2）不要在系统中使用多个分页插件； （3）分页插件不支持带有for、update语句的分页，对于带有 for、update 的sql会抛出运行时异常； （4）分页查询不支持嵌套结果映射（由于...
详解Mybatis之分页插件【PageHelper】
siaok的博客
07-30 7285
以百度搜索为例，如下所示。
mybatis实现分页的几种方式
热门推荐
Jay的博客
08-14 1万+
一.借助数组进行分页 原理：进行数据库查询操作时，获取到数据库中所有满足条件的记录，保存在应用的临时数组中，再通过List的subList方法，获取到满足条件的所有记录。 实现： 首先在dao层，创建StudentMapper接口，用于对数据库的操作。在接口中定义通过数组分页的查询方法，如下所示： List<Student> queryStudentsByArray(); 方法很简单，就是获取所有的数据，通过list接收后进行分页操作。 创建StudentMapper.xml文件，编写查询的
MyBatis或MyBatis-plus中分页查询同时查询数据和总数量
weixin_43165220的博客
04-22 1万+
前言 1、做分页查询的时候，如果是单表还好，可以用mybatis-plus自带的分页，我们可以不用额外的去查询总数。 但如果是多表关联查询，就每次要写两个一样的sql，一个查询数据，一个查询总数，然后我就在想能不能在分页查询数据的时候，同时把总数量也查询出来。于是我在网上找了下，还真有，不过大多都是复制粘贴的，很多都有一样的问题。 问题 就比如： <resultMap type="java.lang.Integer" id="count"> <result column="total"/
mybits拦截器实现分页
su717854075的博客
11-18 1000
mybits拦截器实现分页 page pageplugin dialect pageSqlId
【Web开发实战】Mybatis-plus的使用
守夜人
05-19 363
最近正好在整合以前的知识，同时又接到一个关于苍穹外卖的后端代码填充的事情，里面没有用到，我就使用这个技术来补全这个项目代码的缺失，记录一下这个技术的使用。
mybatis框架讲解
05-29
2. 易学易用：相对于其他ORM框架，MyBatis学习曲线相对来说更加平滑，它提供了大量的示例代码和详细的文档，使得开发人员可以快速上手。 3. 可扩展性：MyBatis的架构设计非常灵活，可以很容易地扩展和定制，满足...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

拾光1024

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值