MyBatis学习笔记

最新推荐文章于 2023-06-08 18:48:46 发布
最新推荐文章于 2023-06-08 18:48:46 发布
阅读量825 收藏 2
点赞数
分类专栏： 笔记 文章标签： java mysql mybatis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/makerjack001/article/details/113662945
版权

目录

什么是MyBatis

MyBatis是apache的一个开源项目iBatis，2010年由apache software foundation迁移到google code，并且改名为MyBatis，2013年11月迁移到Github
MyBatis是一个实现了数据持久化的开源项目框架，简单理解就是对JDBC进行封装。
ORMapping：Object Relationship Mapping 对象关系映射
对象：面向对象
关系：关系型数据库
例子：java到MySql的映射，开发者可以用面向对象的思想来管理数据库

MyBatis的优点

  • 与JDBC相比大大减少代码量
  • MyBatis是最简单的持久化框架啊，小巧并且简易
  • MyBatis是相当灵活，不会对应用程序或数据库设计强加影响，SQL写在XML中，从程序代码中彻底分离，降低耦合度，便于同意管理和优化，并且可以重用
  • 提供XML标签，支持编写动态SQL语句
  • 提供映射标签，支持对象与数据库的ORM字段关系映射

MyBatis的缺点

  • SQL语句的编写工作量较大，尤其是字段多，关联表多时，尤为严重
  • SQL语句依赖于数据库，导致数据库移植性差，不能随意更换数据库

MyBatis的使用

创造一个普通的maven工程

添加pom.xml依赖

<dependencies>
    <dependencies>
    	<dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.6</version>
        </dependency>
   
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.4.5</version>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.25</version>
        </dependency>
    </dependencies>
</dependencies>

建立数据库表

在这里插入图片描述

创建数据表对应的实体类

package com.makerjack.entity;

import lombok.Data;

@Data
public class User {
    private long id;
    private String username;
    private String password;
    private int age;
}

创建MyBatis配置文件config.xml

在这里插入图片描述
文件名可以自定义

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Cofig 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <!--配置mybatis运行环境-->
    <environments default="development"><!--设置默认环境（可以配置多个，但运行只有一个-->
        <environment id="development">
            <!--配置JDBC-->
            <transactionManager type="JDBC"></transactionManager>
            <!--POOLED配置JDBC数据库连接池-->
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/study?useUnicode=true&amp;characterEncoding=utf8&amp;useSSL=false"/>
                <property name="username" value="root"/>
                <property name="password" value="123456"/>
            </dataSource>
        </environment>
    </environments>
</configuration>

MyBatis的开发

分两种方式

  • 使用原生接口
  • 使用Mapper代理

使用原生接口

为对象创建Mapper.xml

MyBatis框架需要开发者自己定义SQL语句，写在Mapper.xml文件中，实际开发中会为每个实体类创建对应的Mapper.xml，定义该对象的SQL
以插入为例

<?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.makerjack.mapper.AccountMapper">
    <insert id="save" parameterType="com.makerjack.entity.Account">
        insert into t_account(username,password,age) values (#{username},#{passwprd},#{age})
    </insert>
</mapper>
字段说明
namespace通常设置为文件所在包+文件名（并不需要文件后缀）
insert标签表示执行添加操作
select标签表示执行查询操作
update标签表示执行更新操作
delete标签表示执行删除操作
id是实际调用MyBatis方法时需要用到的参数
resultType方法返回值的数据类型
parameterType是调用对应方法时参数的数据类型

在全局配置文件config.xml注册Mapper

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Cofig 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <!--配置mybatis运行环境-->
    <environments default="development"><!--设置默认环境（可以配置多个，但运行只有一个-->
        <environment id="development">
            <!--配置JDBC-->
            <transactionManager type="JDBC"></transactionManager>
            <!--POOLED配置JDBC数据库连接池-->
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/study?useUnicode=true&amp;characterEncoding=utf8&amp;useSSL=false"/>
                <property name="username" value="root"/>
                <property name="password" value="123456"/>
            </dataSource>
        </environment>
    </environments>

    <!--注册AccountMapper.xml  每次写完操作的xml，都需要到这里进行注册-->
    <mappers>
        <mapper resource="com/makerjack/mapper/AccountMapper.xml"></mapper>
    </mappers>
</configuration>

注意此处要用斜杠表示层级，因为最后需要加文件后缀

调用MyBatis的原生接口执行添加操作

import com.makerjack.entity.Account;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;

import java.io.InputStream;

public class Test {
    public static void main(String[] args) {
        //加载MyBatis配置文件
        InputStream inputStream = Test.class.getResourceAsStream("config.xml");
        SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
        SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(inputStream);
        SqlSession sqlSession = sqlSessionFactory.openSession();
        String statement = "com.makerjack.mapper.AccountMapper.save";
        Account account = new Account(1L,"张三","123456",20);
        sqlSession.insert(statement,account);
        sqlSession.commit();
    }
}

只写到这一步是会运行报错的，因为Maven只能读取到resource目录下的内容，java目录下 的内容无法读取，所以需要在pom.xml中添加
在这里插入图片描述

<build>
    <resources>
        <resource>
            <directory>src/main/java</directory>
            <includes>
                <include>**/*.xml</include>
            </includes>
        </resource>
    </resources>
</build>

使用Mapper代理实现自定义接口（推荐，因为更方便）

mapper会自动为接口动态生成一个实现类，同时获取实现类的对象

自定义接口

package com.makerjack.repository;

import com.makerjack.entity.Account;

import java.util.List;

public interface AccountRepository {
    public int save(Account account);
    public int deleteById(long id);
    public int update(Account account);
    public Account findById(long id);
    public List<Account> findAll();
}

编写与方法对应的Mapper.xml接口，定义接口方法对应的SQL语句

statement标签会根据SQL执行业务选择insert、delete、update、select方法
MyBatis框架会根据规则自动创建接口实现类的代理对象
规则：

  • Mapper.xml中namespace为接口的全类名
  • Mapper.xml中statement的 id 为接口中对应的方法名
  • Mapper.xml中statement的parameterType和接口中对应的方法的参数类型一致
  • Mapper.xml中statement的resultType和接口对应方法的返回值类型一致
    新建AccountRepository.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.makerjack.repository.AccountRepository">
    <insert id="save" parameterType="com.makerjack.entity.Account">
        insert into t_account(username,password,age) values (#{username},#{password},#{age})
    </insert>

    <update id="update" parameterType="com.makerjack.entity.Account">
        update t_account set username=#{username}, password=#{password}, age=#{age} where id=#{id}
    </update>

    <delete id="deleteById" parameterType="long">
        delete from t_account where id = #{id}
    </delete>

    <select id="findById" parameterType="long" resultType="com.makerjack.entity.Account">
        select * from t_account where id = #{id}
    </select>

    <select id="findAll" resultType="com.makerjack.entity.Account">
        select * from t_account
    </select>
</mapper>

此处若mapper标红，则说明语句中有不合法，比如//注释

在config.xml中注册AccountRepository.xml

在这里插入图片描述

<mapper resource="com/makerjack/repository/AccountRepository.xml"></mapper>

调用接口代理对象完成相关的业务

import com.makerjack.entity.Account;
import com.makerjack.repository.AccountRepository;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;

import java.io.InputStream;
import java.util.List;

public class Test2 {
    public static void main(String[] args) {
        InputStream inputStream = Test.class.getClassLoader().getResourceAsStream("config.xml");
        SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
        SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(inputStream);
        SqlSession sqlSession = sqlSessionFactory.openSession();
        //获取实现接口的代理对象
        AccountRepository accountRepository = sqlSession.getMapper(AccountRepository.class);
        //添加对象
        Account account = new Account(2L,"李四","123456",40);
        accountRepository.save(account);
        sqlSession.commit();//提交事务才能持久化到数据库中

        //修改对象
        Account account2 = accountRepository.findById(2);
        account2.setUsername("小明");
        account2.setPassword("123");
        account2.setAge(21);
        int result = accountRepository.update(account2);
        System.out.println(result);
        sqlSession.commit();

        //删除对象
        int res = accountRepository.deleteById(2);
        sqlSession.commit();
        System.out.println(res);

        //按id查对象
        Account account1 = accountRepository.findById(1L);
        System.out.println(account1);

        //查询全部对象
        List<Account> list = accountRepository.findAll();
        for(Account a:list){
            System.out.println(a);
        }
        sqlSession.close();
    }
}

Mapper.xml

  • statement 标签：select、update、delete、insert 分别对应查询、修改、删除、添加操作
  • parameterType：参数数据类型（可以不写）
    1、 基本数据类型，通过 id 查询Account
    <select id="findById" parameterType="long" resultType="com.makerjack.entity.Account">
    select * from t_account where id = #{id}
</select>
    2、 String类型，通过 name 查询Account
    <select id="findByName" parameterType="java.lang.String" resultType="com.makerjack.entity.Account">
    select * from t_account where username = #{name}
</select>
    3、 包装类型（可以接收null值），通过 id 查询Account
    <select id="findById2" resultType="com.makerjack.entity.Account">
    select * from t_account where id = #{id}
</select>
    4、 同时传递多个参数
    <select id="findByNameAndAge" resultType="com.makerjack.entity.Account">
    select * from t_account where username = #{param1} and age = #{param2}
</select>
    5、 传递java Bean对象
    <update id="update" parameterType="com.makerjack.entity.Account">
    update t_account set username=#{username}, password=#{password}, age=#{age} where id=#{id}
</update>
  • resultType 返回结果类型
    1、基本数据类型，统计 Account 总数
    <select id="count" resultType="int">
    select count(id) from t_account
</select>
    2、包装类型，统计 Account 总数
    <select id="count" resultType="java.lang.Integer">
    select count(id) from t_account
</select>
    3、String类型，通过 id 查询 Account 的 name
    <select id="findNameById" resultType="java.lang.String">
    select username from t_account where id = #{id}
</select>
    4、java Bean类型
    <select id="findById" parameterType="long" resultType="com.makerjack.entity.Account">
    select * from t_account where id = #{id}
</select>

级联查询

一对多

当数据库的表彼此间有级联查询时，比如商品 和 商品分类
在这里插入图片描述
在这里插入图片描述
查询想要知道特定商品全部信息，其sql语句为：

SELECT c.id,c.name,c.price,c.date,k.id as kid,k.name as kname FROM commodity c,kinds k where c.id = 1 and c.kid = k.id

结果：
在这里插入图片描述
你们mybatis应该怎么处理呢？
首先建立两个实体类
商品 Commodity

package com.makerjack.entity;

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

import java.util.Date;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Commodity {
    private long id;
    private String name;
    private double price;
    private Date date;
    private Kinds kinds;
}

分类 Kinds

package com.makerjack.entity;

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

import java.util.List;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Kinds {
    private long id;
    private String name;
    private List<Commodity> commodities;
}

以查询为例

package com.makerjack.repository;

import com.makerjack.entity.Commodity;
import org.apache.ibatis.annotations.Param;

import java.util.List;

public interface CommodityRepository {
    public Commodity findById(long id);
}

则CommodityRepository.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.makerjack.repository.CommodityRepository">

    <!--编辑映射关系-->
    <resultMap id="commodityMap" type="com.makerjack.entity.Commodity">
        <!-- 主键id标签只能有一个，其余用result，内部类用associaion标签新建映射关系
                其中property为java bean的成员变量，column为sql查询结果列名，javaType为内部类地址
        -->
        <id column="id" property="id"></id>
        <result column="name" property="name"></result>
        <result column="price" property="price"></result>
        <result column="date" property="date"></result>
        <association property="kinds" javaType="com.makerjack.entity.Kinds">
            <id column="kid" property="id"></id>
            <result column="kname" property="name"></result>
        </association>
    </resultMap>
    <!--使用映射关系，注意是resultMap-->
    <select id="findById" parameterType="long" resultMap="commodityMap">
        SELECT c.id,c.name,c.price,c.date,k.id as kid,k.name as kname FROM commodity c,kinds k where c.id = #{id} and c.kid = k.id
    </select>
</mapper>

别忘了在总的配置文件config.xml中添加路径
在这里插入图片描述
测试
在这里插入图片描述
结果
在这里插入图片描述

多对一

还是刚才示例，查询指定分类下的商品，则创建KindsRepository.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.makerjack.repository.KindsRepository">

    <!--编辑映射关系-->
    <resultMap id="kindsMap" type="com.makerjack.entity.Kinds">
        <id column="kid" property="id"></id>
        <result column="kname" property="name"></result>
        <!--使用collection映射集合 ofType是集合内部泛型地址-->
        <collection property="commodities" ofType="com.makerjack.entity.Commodity">
            <id column="id" property="id"></id>
            <result column="name" property="name"></result>
            <result column="price" property="price"></result>
            <result column="date" property="date"></result>
        </collection>
    </resultMap>
    <!--使用映射关系，注意是resultMap-->
    <select id="findById" parameterType="long" resultMap="kindsMap">
        SELECT c.id,c.name,c.price,c.date,k.id as kid,k.name as kname FROM commodity c,kinds k where k.id = #{id} and c.kid = k.id
    </select>
</mapper>

在这里插入图片描述

多对多

比如一个顾客考研购买多个商品，一个商品考研背多个顾客购买，这就是多对多的关系
新建两个对象（之前的对象太复杂了）
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
购买关系如下
在这里插入图片描述

通过顾客查其购买的商品

查询用户id=1的人购买物品情况

SELECT c.id as cid,c.name as cname,g.id as gid,g.name as gname FROM customer c,goods g,customer_goods cg where c.id=1 and c.id=cg.cid and g.id=cg.gid

查询结果如下
在这里插入图片描述
其mapper如下

<?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.makerjack.repository.CustomerRepository">

    <!--编辑映射关系-->
    <resultMap id="customerMap" type="com.makerjack.entity.Customer">
        <id column="cid" property="id"></id>
        <result column="cname" property="name"></result>
        <!--使用collection映射集合 ofType是集合内部泛型地址-->
        <collection property="goods" ofType="com.makerjack.entity.Goods">
            <id column="gid" property="id"></id>
            <result column="gname" property="name"></result>
        </collection>
    </resultMap>
    <!--使用映射关系，注意是resultMap-->
    <select id="findById" parameterType="long" resultMap="customerMap">
        SELECT c.id as cid,c.name as cname,g.id as gid,g.name as gname FROM customer c,goods g,customer_goods cg where c.id=#{id} and c.id=cg.cid and g.id=cg.gid
    </select>
</mapper>

测试结果如下
在这里插入图片描述

通过商品查购买它的顾客

sql语句不变，是需要把映射方法改变即可

<?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.makerjack.repository.GoodsRepository">

    <!--编辑映射关系-->
    <resultMap id="goodsMap" type="com.makerjack.entity.Goods">
        <id column="gid" property="id"></id>
        <result column="gname" property="name"></result>
        <!--使用collection映射集合 ofType是集合内部泛型地址-->
        <collection property="customers" ofType="com.makerjack.entity.Customer">
            <id column="cid" property="id"></id>
            <result column="cname" property="name"></result>
        </collection>
    </resultMap>
    <!--使用映射关系，注意是resultMap-->
    <select id="findById" parameterType="long" resultMap="goodsMap">
        SELECT c.id as cid,c.name as cname,g.id as gid,g.name as gname FROM customer c,goods g,customer_goods cg where g.id=#{id} and c.id=cg.cid and g.id=cg.gid
    </select>
</mapper>

在这里插入图片描述

MyBatis逆向工程

MyBatis 框架需要：实体类、自定义 Mapper 接口、Mapper.xml
传统的开发中，上述的三个组件需要开发者手动创建
逆向工程可以帮助开发者来创建这三个组件，减轻开发者的工作量，提高工作效率。

如何使用逆向工程

MyBatis Generator，简称MBG，是一个专门为 MyBatis 框架开发者定制的代码生成器，可自动生成 MyBatis 框架所需的实体类、Mapper 接口、Mapper.xml，支持基本的CRUD操作，但是一下相对复杂的SQL需要开发者自己来完成

1、 新建一个maven工程
在这里插入图片描述
2、 在pom.xml中添加依赖
在这里插入图片描述

<dependencies>
<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis</artifactId>
    <version>3.4.5</version>
</dependency>

<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>8.0.25</version>
</dependency>

<dependency>
    <groupId>org.mybatis.generator</groupId>
    <artifactId>mybatis-generator-core</artifactId>
    <version>1.3.2</version>
</dependency>
</dependencies>

3、 在resource 目录下，创建 MBG 配置文件 generatorConfig.xml 并写入以下内容

关键字含义
jdbcConnection配置数据库连接信息
javaModelGenerator配置 JavaBean 的生成策略
sqlMapGenerator配置 SQL 映射文件生成策略
javaClientGenerator配置Mapper接口的生成策略
table配置目标数据表（tableName：表名，domainObjectName：javaBean 类名）
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE generatorConfiguration
        PUBLIC "-//mybatis.org//DTD MyBatis Generator Configuration 1.0//EN"
        "http://mybatis.org/dtd/mybatis-generator-config_1_0.dtd">
<generatorConfiguration>
    <!--id可以自定义，targetRuntime必须为MyBatis-->
    <context id="testTables" targetRuntime="MyBatis3">
        <!--配置信息以属性的形式填写-->
        <jdbcConnection
                driverClass="com.mysql.jdbc.Driver"
                connectionURL="jdbc:mysql://localhost:3306/study?useUnicode=true&amp;characterEncoding=utf8&amp;useSSL=false"
                userId="root"
                password="123456"
        ></jdbcConnection>
        <javaModelGenerator targetPackage="com.makerjack.entity" targetProject="./src/main/java"></javaModelGenerator>
        <sqlMapGenerator targetPackage="com.makerjack.repository" targetProject="./src/main/java"></sqlMapGenerator>
        <javaClientGenerator type="XMLMAPPER" targetPackage="com.makerjack.repository" targetProject="./src/main/java"></javaClientGenerator>
        <table tableName="t_user" domainObjectName="User"></table>
    </context>
</generatorConfiguration>

4、 创建generator执行的类

在这里插入图片描述

package com.makerjack.test;

import org.mybatis.generator.api.MyBatisGenerator;
import org.mybatis.generator.config.Configuration;
import org.mybatis.generator.config.xml.ConfigurationParser;
import org.mybatis.generator.exception.InvalidConfigurationException;
import org.mybatis.generator.exception.XMLParserException;
import org.mybatis.generator.internal.DefaultShellCallback;

import java.io.File;
import java.io.IOException;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<String> warings = new ArrayList<String>();
        boolean overwrite = true;
        //定义配置文件路径
        String genCig = "/generatorConfig.xml";
        //根据配置文件创建对应的file文件
        File configFile = new File((Main.class.getResource(genCig).getFile()));
        ConfigurationParser configurationParser = new ConfigurationParser(warings);
        Configuration configuration = null;
        try {
            configuration = configurationParser.parseConfiguration(configFile);
        } catch (XMLParserException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        DefaultShellCallback callback = new DefaultShellCallback(overwrite);
        MyBatisGenerator myBatisGenerator = null;
        try {
            myBatisGenerator = new MyBatisGenerator(configuration,callback,warings);
        } catch (InvalidConfigurationException e) {
            e.printStackTrace();
        }
        try {
            myBatisGenerator.generate(null);
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

MyBatis的延迟加载

延迟加载也叫懒加载、惰性加载，使用延迟加载考研提高程序的运行效率，针对于数据持久层的操作，在某些特定的情况下去访问特定的数据库，在其他情况下考研不访问某些表，从一一定程度上减少了 java 程序与数据库的交互次数。

例如这张commodity表，其kid对应的是商品分类
在这里插入图片描述
而kinds表如下在这里插入图片描述
当我们只需要commodity信息时，我们就只查询一张表
如果还需要它的分类信息，则需要查询两张表
应对这两种情况我们以往的做法是写两条SQL语句来应对，并且每增加一种情况就要写一条sql语句
而延迟查询则可以这样做

  1. 开启延迟查询
  2. 在xml中编写相关延迟加载映射关系
    这样当你想要单个commodity信息时，系统自动只调用1条sql语句，当想要commodity及其kinds信息时，程序会调用两条sql语句

在 config.xml 中开启延迟加载

<settings>
    <!-- 打印sql语句 -->
    <setting name="logImpl" value="STDOUT_LOGGING"/>
    <!-- 开启延迟加载 -->
    <setting name="lazyLoadingEnabled" value="true"/>
</settings>

将多表关联查询拆分成成多个单表查询

commodityRepository 中添加如下方法（以此为例）

public Commodity lazyFindById(long id);

kindsRepository 中添加如下方法

public Kinds lazyFindById(long id);

CommodityRepository 中添加对应的sql语句

<!--编辑映射关系-->
<resultMap id="lazyCommodityMap" type="com.makerjack.entity.Commodity">
    <id column="id" property="id"></id>
    <result column="name" property="name"></result>
    <result column="price" property="price"></result>
    <result column="date" property="date"></result>
    <!--select指向的是懒惰查询下一步要执行的对象方法，column指明当前查询的哪一列需要传递的参数-->
    <association property="kinds" javaType="com.makerjack.entity.Kinds"
                 select="com.makerjack.repository.KindsRepository.lazyFindById"
                 column="kid"
    >
        <id column="kid" property="id"></id>
        <result column="kname" property="name"></result>
    </association>
</resultMap>
<!--使用映射关系，注意是resultMap-->
<select id="lazyFindById" parameterType="long" resultMap="lazyCommodityMap">
    SELECT * from commodity where id = #{id}
</select>

KindsRepository中添加对应的sql语句

<!--使用映射关系，注意是resultType-->
<select id="lazyFindById" resultType="com.makerjack.entity.Kinds">
    select * from kinds where id = #{id}
</select>

结果如下
当我们只需要商品的信息（不涉及kinds内容时）
在这里插入图片描述
程序只执行了1次sql语句查询
当涉及到kings信息，即涉及到两张表时
在这里插入图片描述
程序执行了2次sql语句查询
可以说很智能了

MyBatis缓存

使用缓存可以减少 java 应用和数据库的交互次数，从而提升程序的运行效率。比如查询出 id = 1 的对象，第一次查询出之后会自动将该对象保存到缓存当中，当下一次查询时，直接调取缓存内容，无需进行查询
缓存分类如下

一级缓存

一级缓存：SqlSession 级别，默认开启，并且不能关闭
操作数据库时需要创建SqlSession对象，在对象当中有一个HashMap 用于存储缓存数据，不同的 SqlSession 之间缓存数据是互不影响。
一级缓存的作用域是 SqlSession 范围的，当在同一个SqlSession 中执行两次相同的 SQL 语句时，第一次执行完毕会将结果保存到缓存中，第二次查询会直接从缓存当中获取。
如果SqlSession 执行力DML操作（insert、update、delete），MyBatis 必须将缓存清空，以保证数据的准确性

演示
普通的查询如下，执行sql语句并且输出
在这里插入图片描述
当两次执行相同sql语句时，仍然只查询一次，从内存中直接获取结果
在这里插入图片描述
当销毁当前SqlSession，新建一个时，即便执行相同的SQL语句，仍然需要重新查询
在这里插入图片描述

代码示例

import com.makerjack.entity.Account;
import com.makerjack.repository.AccountRepository;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;

import java.io.InputStream;

public class Test4 {
    public static void main(String[] args) {
        InputStream inputStream = Test.class.getClassLoader().getResourceAsStream("config.xml");
        SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
        SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(inputStream);
        SqlSession sqlSession = sqlSessionFactory.openSession();

        AccountRepository accountRepository = sqlSession.getMapper(AccountRepository.class);
        Account account = accountRepository.findById(1L);
        System.out.println(account);
        Account account1 = accountRepository.findById(1L);
        System.out.println(account1);
        sqlSession.close();
        System.out.println("=================以下为新的SqlSession===============");

        sqlSession = sqlSessionFactory.openSession();
        accountRepository = sqlSession.getMapper(AccountRepository.class);
        Account account2 = accountRepository.findById(1L);
        System.out.println(account2);
        sqlSession.close();
    }
}

二级缓存

二级缓存：Mapper 级别， 默认关闭，可以开启。
使用二级缓存时，多个 SqlSession 使用同一个 Mapper 的 SQL 语句操作数据库，得到的数据会存在二级缓存当中，同样是使用HashMap 进行数据存储，相比较于以及缓存，二级缓存的范围更大，多个 SqlSession 可以共用二级缓存，二级缓存是跨 SqlSession 的。
二级缓存是多个 SqlSession 共享的，其作用域是 Mapper 的同一个 namespace，不同的 SqlSession 两次执行相同的 namespce 下的 SQL 语句，参数也相等，则第一次执行成功后会将数据保存到二级缓存中，第二次可直接从二级缓存中取出数据。

以自带的二级缓存为例第三方的比较繁琐

步骤1：在 congfig.xml 中开启二级缓存

<settings>
    <!-- 打印sql语句 -->
    <setting name="logImpl" value="STDOUT_LOGGING"/>
    <!-- 开启延迟加载 -->
    <setting name="lazyLoadingEnabled" value="true"/>
    <!-- 开启二级缓存 -->
    <setting name="cacheEnabled" value="true"/>
</settings>

步骤2：在使用的mapper中开启二级缓存
在这里插入图片描述

<cache></cache>

步骤3：在实体类实现Serializable接口
在这里插入图片描述
还是运行刚才的测试代码

import com.makerjack.entity.Account;
import com.makerjack.repository.AccountRepository;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;

import java.io.InputStream;

public class Test4 {
    public static void main(String[] args) {
        InputStream inputStream = Test.class.getClassLoader().getResourceAsStream("config.xml");
        SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
        SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(inputStream);
        SqlSession sqlSession = sqlSessionFactory.openSession();

        AccountRepository accountRepository = sqlSession.getMapper(AccountRepository.class);
        Account account = accountRepository.findById(1L);
        System.out.println(account);
        Account account1 = accountRepository.findById(1L);
        System.out.println(account1);
        sqlSession.close();
        System.out.println("=================以下为新的SqlSession===============");

        sqlSession = sqlSessionFactory.openSession();
        accountRepository = sqlSession.getMapper(AccountRepository.class);
        Account account2 = accountRepository.findById(1L);
        System.out.println(account2);
        sqlSession.close();
    }
}

可以看到只执行了一次SQL查询语句（注意sqlSessionFactory不能变，否则还是会查两次）
在这里插入图片描述

MyBatis 动态SQL

使用动态 SQL 可以简化代码开发，减少开发者的工作量，程序自行决定SQL语句

动态SQL可以根据传递的参数，动态调整SQL语句
情景：当我们查询一个Account时，其有4个属性：id、username、password、age
如果需要完全匹配则是要4条数据，缺一不可，但实际使用时，可能没有完整的4条语句
可能缺少4个属性的一个或多个，那么就不能查询出来

比如Account有根据account查询的方法，其mapper如下

<select id="findByAccount" resultType="com.makerjack.entity.Account">
    select * from t_account where id=#{id} and username=#{username} and password=#{password} and age=#{age}
</select>

数据库中存在数据项
在这里插入图片描述

那么代码肯定是可以查询出来结果的，
在这里插入图片描述
但当我们缺少某个数据项，则无法查询出结果
在这里插入图片描述
但理论上只要不设置 password=#{} 肯定还是能查询出来，而且这只是一个参数的情况，如果是多个参数，则会有更多SQL语句要修改，此时就需要动态SQL
在 mapper.xml 中引入

if标签

其可以根据表达式（test）的结果，决定是否将语句添加到最终的SQL中
若test成立则添加，如果不成立则不添加

<select id="findByAccount" resultType="com.makerjack.entity.Account">
    select * from t_account where
    <if test="id != 0">
        id=#{id}
    </if>
    <if test="username != null">
        and username=#{username}
    </if>
    <if test="password != null">
        and password=#{password}
    </if>
    <if test="age != 0">
        and age=#{age}
    </if>
</select>

再次运行，可以看到password不存在后，sql语句就省略了password判断
在这里插入图片描述
当id也缺失后，程序会报错，这是因为此时SQL语句变成了
在这里插入图片描述
当无 id 属性后， where 和 and 直接拼接，当然会报错，此时就需要

where 标签

其可以自动判断是否要删除语句块中的 and 关键字，如果检测到 where 和 and 直接拼接，则会自动删除 and ，一般 where 和 if 一起使用

<select id="findByAccount" resultType="com.makerjack.entity.Account">
   select * from t_account 
   <where>
       <if test="id != 0">
           id=#{id}
       </if>
       <if test="username != null">
           and username=#{username}
       </if>
       <if test="password != null">
           and password=#{password}
       </if>
       <if test="age != 0">
           and age=#{age}
       </if>
   </where>
</select>

在这里插入图片描述
语句就又能执行了

choose、when标签

语法类似 swatch-case 语句

<select id="findByAccount" resultType="com.makerjack.entity.Account">
    select * from t_account
    <where>
        <choose>
            <when test="id != 0">
                id=#{id}
            </when>
            <when test="username != null">
                and username=#{username}
            </when>
            <when test="password != null">
                and password=#{password}
            </when>
            <when test="age != 0">
                and age=#{age}
            </when>
        </choose>
    </where>
</select>

在这里插入图片描述
一旦某一个 when 成立，下面的when都不再执行
在这里插入图片描述
所以当数据库中有字段部分内容重复时，会报错（我新加了一个22岁的张三）
在这里插入图片描述

set标签

其用于 update 操作，会自动根据参数选择生成SQL语句

<select id="findByAccount" resultType="com.makerjack.entity.Account">
    select * from t_account
    <where>
        <if test="id != 0">
            id=#{id}
        </if>
        <if test="username != null">
            and username=#{username}
        </if>
        <if test="password != null">
            and password=#{password}
        </if>
        <if test="age != 0">
            and age=#{age}
        </if>
    </where>
</select>

当调用时，如果需要更改，则更改，否则不进行更改
比如数据库中有表在这里插入图片描述
在这里插入图片描述
更改内容无age属性，SQL语句也没有age属性

makerjack001
关注
专栏目录
MyBatis-Plus自定义字符串分割格式化策略的深度解析与实践
奇妙的Bug之旅
01-09 427
在MyBatis-Plus中，我们可以使用注解来定义实体类的属性映射到数据库表的字段。其中，formatter属性可以用来指定一个自定义的格式化器，用于对字段值进行格式化。格式化器可以是一个实现了接口的类，或者是一个实现了接口的类。要实现自定义的字符串分割格式化策略，我们需要创建一个实现了接口的类。这个类的主要任务是接收一个对象作为参数，然后返回一个字符串作为结果。在这个类中，我们可以重写format方法来实现自定义的格式化逻辑。
【Mybatis】分割字符串
sayyy的专栏
09-04 9015
前言 springboot 2.1.1.RELEASE 分割字符串 <select id="selectXXXList" parameterType="XXX" resultMap="XXXResult"> select * from xxx <where> <if test="tagIds != null and tagIds != ''"> and <foreach item="tagId" collec
关于MyBatis动态＜if＞标签的使用介绍
最新发布
xiaoweids的博客
06-08 2256
MyBatis中的动态SQL标签，常用场景是根据条件添加WHERE子句。本篇文章将对动态SQL标签使用中的常见问题进行演示和总结。if判断字符串if判断数字。MyBatis3.5.6if>标签的test判断中，外层用双引号，内层用单引号时，有如下比较规则。允许数字与字符串做比较；允许数字与字符做比较，但不推荐。数字与字符做比较时，数字会与字符的ASCAII值做比较，容易出错；不允许包含字母的字符串与字符做比较。这种情况MyBatis会直接报错；允许全是数字。
Mybatis传参- 被逗号分割的字符串(“1,2,3“)
chancui9673的博客
06-06 872
service List<Position> pos = positionMapper.selectPositionStudentByPosId("1,2,3"); mybatis //注意得用@Param ,否则会在xml中会获取不到ids参数,导致出现问题 public List<Position> selectPositionStudentByPosId(@Param("ids") String ids); mybatis的xml中 .
mybatis xml 拆分
weixin_43973832的博客
07-15 807
mybatis 拆分
Mybatis学习笔记
07-22
本学习笔记是作者在大学期间深入学习Mybatis后的整理，旨在帮助初学者快速入门并掌握其核心概念与功能。 笔记共分为11个章节，涵盖Mybatis的基础到高级应用，以下是主要知识点的详细讲解： 1. **Mybatis简介**：...
MyBatis-Plus
qq_51234063的博客
10-28 5389
1、了解Mybatis-Plus 1.1Mybatis-Plus介绍 MyBatis-Plus（简称 MP）是一个 MyBatis 的增强工具，在 MyBatis 的基础上只做增强不做改 变，为简化开发、提高效率而生。 官网：https://mybatis.plus/ 或 https://mp.baomidou.com/ 愿景:我们的愿景是成为 MyBatis 最好的搭档，就像 魂斗罗 中的 1P、2P，基友搭配，效率翻倍。 1.2特性 无侵入：...
sql 拆分_mybatis之水平拆分
weixin_39540018的博客
12-05 559
数据库水平拆分将数据按某个字段，将数据存储到不同的表里，减少单张表的数据量，一般热点数据如：日志数据，用户订单等可以按数据创建时间occurTime,然后按年或月或日等策略，把表数据水平拆分。 可以通过mybatis自定义拦截器Interceptor拦截StatementHandler(封装了JDBC Statement操作，负责对JDBC statement 的操作，...
springboot 多模块将dao(mybatis)项目拆分出去
08-27
主要介绍了springboot 多模块将dao(mybatis)项目拆分出去，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
sql多表查询（单表查询略过）
weixin_30478757的博客
12-13 150
表library： 表borrow： 表reader： 1、等值连接：（常用） 　　原理：将多张表组合成一个逻辑大表，即字段相加记录...
Mybatis分解式查询
qq_53317005的博客
04-11 3786
Mybatis分解式查询，一对一，一对多查询
mybatis foreach标签的解释 与常用之处
热门推荐
bareheadzzq
09-21 18万+
情景：查询数据库中文章的相关文章   文章为一个表 字段tags为相关文章字符串中间用','逗号进行啦分割 查询完一个文章后可以把tags字段构造为一个List 然后利用这个集合作为条件来查询     select * from t_news n where        separator="," close=")">    #{tag} in n.tags      看
mybatis 字符串分割匹配
weixin_42188960的博客
05-25 1万+
&lt;if test="contractNo!=null and contractNo!=''"&gt; and d.CONTRACT_NO in  &lt;foreach item="item" index="index" collection="contractNo.split(',')" open="(" separator="," close=&a
采用shardbatis在springBoot中实现表的水平拆分,整合swagger,mybatis,shardbatis,pagehelper
水中加点糖
01-13 7059
在最近的一个小项目中，由于会用到一点关于分表的操作，数据库是mysql的，在那个mysql数据库中有一个函数，每天会创建一张数据表作为分表，创建出来的表和原始表的结构不变，只是表名有一点改变。 为此，为了解决这个问题，我在网上搜索了一些关于分表的解决办法，我这里用的是mybatis作为持久层框架，在网上找到了一个叫做shardbatis的开源插件，于是便用了起来，但在使用的过程中，发现这个sha
mybatis 批量的更新
彻底拆分，一切可控！
08-24 831
1.oracle 配置 &lt;update id="batchUpdate" parameterType="java.util.List"&gt; &lt;foreach collection="list" item="item" index="index" open="begin" close="end;" separ
mybatis 文档
彻底拆分，一切可控！
08-07 466
http://mybatis.github.io/mybatis-3/zh/configuration.html
MyBatis学习笔记与实战指南
"这是一份关于MyBatis的学习笔记，包含笔记整理和示例代码，旨在帮助学习者全面理解并掌握MyBatis框架。" 在Java开发领域，MyBatis是一个广泛使用的开源免费数据访问层框架，原名为iBatis，自2010年起在Google Code...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值