MyBatis知识总结

已于 2023-09-21 22:41:55 修改
阅读量72 收藏 1
点赞数 1
分类专栏： 企业级开发框架 文章标签： mybatis java 笔记
于 2023-09-21 22:38:42 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/JavaBsj/article/details/133150885
版权

ORMapping：Object Relationship Mapping 对象关映射

对象指面向对象

关系指关系型数据库

Java 到 MySQL 的映射，开发者可以以面向对象的思想来管理数据库。

如何使用

  • 新建 Maven 工程，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.11</version>
    </dependency>
​
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <version>1.18.6</version>
        <scope>provided</scope>
    </dependency>
</dependencies>

  • 新建数据库表

use mybatis;
create table t_account(
    id int primary key auto_increment,
    username varchar(11),
    password varchar(11),
    age int
)character set = utf8;

  • 新建数据表对应的实体类 Account

package com.bsj.entity;
​
import lombok.Data;
​
@Data
public class Account {
    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 Config 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.cj.jdbc"/>
                <property name="url" value="jdbc:mysql://localhost:3306//mybatis?useUnicode=true&amp;characterEncoding=UTF-8"/>
                <property name="username" value="root"/>
                <property name="password" value="bsj20021220"/>
            </dataSource>
        </environment>
    </environments>
</configuration>

使用原生接口

1、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.bsj.mapper.AccountMapper">
​
    <insert id="save" parameterType="com.bsj.entity.Account">
        insert into t_account(username,password,age) values(#{username},#{password},#{age})
    </insert>
​
</mapper>

  • namespace 通常设置为文件所在包+文件名的形式。

  • insert 标签表示执行添加操作。

  • select 标签表示执行查询操作。

  • update 标签表示执行更新操作。

  • delete 标签表示执行删除操作。

  • id 是实际调用 MyBatis 方法时需要用到的参数。

  • parameterType 是调用对应方法时参数的数据类型。

2、在全局配置文件 config.xml 中注册 AccountMapper.xml。

<?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>
    <!-- 配置MyBatis运行环境-->
    <environments default="development">
        <environment id="development">
            <!-- 配置JDBC事务管理 -->
            <transactionManager type="JDBC"></transactionManager>
            <!-- POOLED配置JDBC数据源连接池-->
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.cj.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/mybatis?useUnicode=true&amp;useSSL=false&amp;characterEncoding=UTF-8&amp;serverTimezone=UTC"/>
                <property name="username" value="root"/>
                <property name="password" value="bsj20021220"/>
            </dataSource>
        </environment>
    </environments>
​
    <!-- 注册AccountMapper.xml -->
    <mappers>
        <mapper resource="com/bsj/mapper/AccountMapper.xml"></mapper>
    </mappers>
</configuration>

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

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

通过 Mapper 代理实现自定义接口

  • 自定义接口，定义相关业务方法。

  • 编写与方法相对应得 Mapper.xml。

1、自定义接口

package com.bsj.repository;
​
import com.bsj.entity.Account;
​
import java.util.List;
​
public interface AccountRepository {
    public int save(Account account);
    public int update(Account account);
    public int delete(long id);
    public List<Account> findAll();
    public Account findById(long id);
}

2、创建接口对应的 Mapper.xml，定义接口方法对应的 SQL 语句。

statement 标签可根据 SQL 执行的业务选中 insert、delete、update、select。

MyBatis 框架会根据规则自动创建接口实现类的代理对象。

规则：

  • Mapper.xml 中 namespace 为接口的全类名。

  • Mapper.xml 中 statement 的 id 为接口中对应的方法名。

  • Mapper.xml 中 statement 的 paremeterType 和接口中对应方法的参数类型一致。

  • Mapper.xml 中 statement 的 resultType 和接口中对应方法的返回值类型一致。

<?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.bsj.repository.AccountRepository">
    <insert id="save" parameterType="com.bsj.entity.Account">
        insert into t_account(username,password,age) values(#{username},#{password},#{age})
    </insert>
    <update id="update" parameterType="com.bsj.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="findAll" resultType="com.bsj.entity.Account">
        select * from t_account
    </select>
    <select id="findById" parameterType="long" resultType="com.bsj.entity.Account">
        select * from t_account where id = #{id}
    </select>
</mapper>

3、在config.xml 中注册 AccountRepository.xml

<!-- 注册AccountMapper.xml -->
<mappers>
    <mapper resource="com/bsj/mapper/AccountMapper.xml"></mapper>
    <mapper resource="com/bsj/repository/AccountRepository.xml"></mapper>
</mappers>

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

package com.bsj.test;
​
import com.bsj.entity.Account;
import com.bsj.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(3L,"王五","111111",24);
//        int result = accountRepository.save(account);
//        sqlSession.commit();
//        List<Account> list = accountRepository.findAll();
//        for (Account account:list){
//            System.out.println(account);
//        }
//        sqlSession.close();
        //通过id查询对象
//        Account account = accountRepository.findById(3L);
//        System.out.println(account);
//        sqlSession.close();
        //修改对象
//        Account account = accountRepository.findById(3L);
//        account.setUsername("小明");
//        account.setPassword("000");
//        account.setAge(18);
//        int result = accountRepository.update(account);
//        sqlSession.commit();
//        System.out.println(result);
//        sqlSession.close();
        //通过id删除对象
        int result = accountRepository.deleteById(3L);
        System.out.println(result);
        sqlSession.commit();
        sqlSession.close();
    }
}

Mapper.xml

  • statement 标签：select、update、delete、insert 分别对应查询、修改、删除、添加操作。

  • parameterType：参数数据类型

    1、基本数据类型，通过 id 来查询 Account

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

    2、String 类型，通过 name 来查询 Account

    <select id="findByName" parameterType="java.lang.String" resultType="com.bsj.entity.Account">
    select * from t_account where username = #{username}
</select>

    3、包装类，通过 id 查询 Account

    <select id="findById2" parameterType="java.lang.Long" resultType="com.bsj.entity.Account">
    select * from t_account where id = #{id}
</select>

    4、多个参数，通过 username 和 age 来查询 Account

    <select id="findByNameAndAge" resultType="com.bsj.entity.Account">
    select * from t_account where username = #{param1} and age = #{param2}
</select>
<select id="findByNameAndAge" resultType="com.bsj.entity.Account">
    select * from t_account where username = #{arg0} and age = #{arg1}
</select>

    5、Java Bean

    <update id="update" parameterType="com.bsj.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="count2" 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.bsj.entity.Account">
    select * from t_account where id = #{id}
</select>

及联查询

  • 一对多

Student

package com.bsj.entity;
​
import lombok.Data;
​
@Data
public class Student {
    private long id;
    private String name;
    private Classes classes;
}

Classes

package com.bsj.entity;
​
import lombok.Data;
​
import java.util.List;
​
@Data
public class Classes {
    private long id;
    private String name;
    private List<Student> students;
}

StudentRepository

package com.bsj.repository;
​
import com.bsj.entity.Student;
​
public interface StudentRepository {
    public Student findById(long id);
}

StudentRepository.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.bsj.repository.StudentRepository">
​
    <resultMap id="studentMap" type="com.bsj.entity.Student">
        <id column="id" property="id"></id>
        <result column="name" property="name"></result>
        <association property="classes" javaType="com.bsj.entity.Classes">
            <id column="cid" property="id"></id>
            <result column="cname" property="name"></result>
        </association>
    </resultMap>
​
    <select id="findById" parameterType="long" resultMap="studentMap">
        select s.id,s.name,c.id as cid,c.name as cname from student s ,classes c where s.id = #{id} and s.cid = c.id;
    </select>
</mapper>

ClassesRepository

package com.bsj.repository;
​
import com.bsj.entity.Classes;
​
public interface ClassesRepository {
    public Classes findById(long id);
}

ClassRepository.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.bsj.repository.ClassesRepository">
​
    <resultMap id="classesMap" type="com.bsj.entity.Classes">
        <id column="cid" property="id"></id>
        <result column="cname" property="name"></result>
        <collection property="students" ofType="com.bsj.entity.Student">
            <id column="id" property="id"/>
            <result column="name" property="name"/>
        </collection>
    </resultMap>
​
    <select id="findById" parameterType="long" resultMap="classesMap">
        select s.id,s.name,c.id as cid,c.name as cname from student s ,classes c where c.id = #{id} and s.cid = c.id;
    </select>
</mapper>

  • 多对多

Customer

package com.bsj.entity;
​
import lombok.Data;
​
import java.util.List;
​
@Data
public class Customer {
    private long id;
    private String name;
    private List<Goods> goods;
}

Goods

package com.bsj.entity;
​
import lombok.Data;
​
import java.util.List;
​
@Data
public class Goods {
    private long id;
    private String name;
    private List<Customer> customers;
}

CustomerRepository

package com.bsj.repository;
​
import com.bsj.entity.Customer;
​
public interface CustomerRepository {
    public Customer findById(long id);
}

CustomerRepository.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.bsj.repository.CustomerRepository">
​
    <resultMap id="customerMap" type="com.bsj.entity.Customer">
        <id column="cid" property="id"></id>
        <result column="cname" property="name"></result>
        <collection property="goods" ofType="com.bsj.entity.Goods">
            <id column="gid" property="id"/>
            <result column="gname" property="name"/>
        </collection>
    </resultMap>
​
    <select id="findById" parameterType="long" resultMap="customerMap">
        select c.id cid,c.name cname,g.id gid,g.name gname from customer c,goods g,customer_goods cg where c.id  = #{id} and cg.cid = c.id and cg.gid = g.id;
    </select>
</mapper>

GoodsRepository

package com.bsj.repository;
​
import com.bsj.entity.Goods;
​
public interface GoodsRepository {
    public Goods findById(long id);
}

GoodsRepository.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.bsj.repository.GoodsRepository">
​
    <resultMap id="goodsMap" type="com.bsj.entity.Goods">
        <id column="gid" property="id"></id>
        <result column="gname" property="name"></result>
        <collection property="customers" ofType="com.bsj.entity.Customer">
            <id column="cid" property="id"/>
            <result column="cname" property="name"/>
        </collection>
    </resultMap>
​
    <select id="findById" parameterType="long" resultMap="goodsMap">
        select c.id cid,c.name cname,g.id gid,g.name gname from customer c,goods g,customer_goods cg where g.id  = #{id} and cg.cid = c.id and cg.gid = g.id;
    </select>
</mapper>

逆向工程

MyBatis 框架需要：实体类、自定义 Mapper 接口、Mapper.xml

传统的开发中上诉的三个组件需要开发者手动创建，逆向工程可以帮助开发者来自动创建三个组件，减轻开发者的工作量，提高工作效率。

如何使用

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

  • 新建 Maven 工程，pomxml

<dependencies>
    
    <!-- 延迟加载配置时，3.4.5版本的mybatis会报空指针异常，3.5.1完美解决-->
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis</artifactId>
        <version>3.5.1</version>
    </dependency>
​
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.0.11</version>
    </dependency>
​
    <dependency>
        <groupId>org.mybatis.generator</groupId>
        <artifactId>mybatis-generator-core</artifactId>
        <version>1.3.2</version>
    </dependency>
</dependencies>

  • 创建 MBG 配置文件 generratorConfig.xml

1、jdbcConnection 配置数据库连接信息。

2、javaModelGenerator 配置 JavaBean 的生成策略。

3、sqlMapGenerator 配置 SQL 映射文件生成策略。

4、javaClientGenerator 配置 Mapper 接口的生成策略。

5、table 配置目标数据表（tableName：表名，domainObejctName：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>
    <context id="testTables" targetRuntime="MyBatis3">
        <jdbcConnection
                driverClass="com.mysql.cj.jdbc.Driver"
                connectionURL="jdbc:mysql://localhost:3306/mybatis?useUnicode=true&amp;useSSL=false&amp;characterEncoding=UTF-8&amp;serverTimezone=UTC"
                userId="root"
                password="bsj20021220"
        ></jdbcConnection>
        <javaModelGenerator targetPackage="com.bsj.entity" targetProject="./src/main/java"></javaModelGenerator>
        <sqlMapGenerator targetPackage="com.bsj.repository" targetProject="./src/main/java"></sqlMapGenerator>
        <javaClientGenerator type="XMLMAPPER" targetPackage="com.bsj.repository" targetProject="./src/main/java"></javaClientGenerator>
        <table tableName="t_user" domainObjectName="User"></table>
    </context>
</generatorConfiguration>

  • 创建 Generator 执行类。

package com.bsj.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 configFile = new File(Main.class.getResource(genCig).getFile());
        ConfigurationParser configurationParser = new ConfigurationParser(warings);
        Configuration configuration = null;
        try {
            configuration = configurationParser.parseConfiguration(configFile);
        } catch (IOException e) {
            throw new RuntimeException(e);
        } catch (XMLParserException e) {
            throw new RuntimeException(e);
        }
        DefaultShellCallback callback = new DefaultShellCallback(overwrite);
        MyBatisGenerator myBatisGenerator = null;
        try {
            myBatisGenerator = new MyBatisGenerator(configuration,callback,warings);
        } catch (InvalidConfigurationException e) {
            throw new RuntimeException(e);
        }
        try {
            myBatisGenerator.generate(null);
        } catch (SQLException e) {
            throw new RuntimeException(e);
        } catch (IOException e) {
            throw new RuntimeException(e);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
    }
}

MyBatis 延迟加载

  • 什么是延迟加载？

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

查询学生和班级时，学生和班级是两张不同的表，如果当前需求只需要获取学生的信息，那么查询学生单表即可，如果需要通过学生获取对应的班级信息，则必须查询两张表。

不同的业务需求，需要查询不同的表，根据具体的业务需求来动态减少数据表查询的工作就是延迟加载。

  • 在 config.xml 中开启延迟加载

<settings>
    <!-- 打印SQL -->
    <setting name="logImpl" value="STDOUT_LOGGING"/>
    <!-- 开启延迟加载 -->
    <!-- mybatis-3.4.5 会报空指针异常，mybatis-3.5.1异常解决-->
    <setting name="lazyLoadingEnabled" value="true"/>
</settings>

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

StudentRepository

public Student findByIdLazy(long id);

StudentRepository.xml

<resultMap id="studentMapLazy" type="com.bsj.entity.Student">
    <id column="id" property="id"></id>
    <result column="name" property="name"></result>
    <association property="classes" javaType="com.bsj.entity.Classes" select="com.bsj.repository.ClassesRepository.findByIdLazy" column="cid"></association>
</resultMap>
​
<select id="findByIdLazy" parameterType="long" resultMap="studentMapLazy">
    select * from student where id = #{id}
</select>

ClassesRepository

public Classes findByIdLazy(long id);

ClassesRepository.xml

<select id="findByIdLazy" parameterType="long" resultType="com.bsj.entity.Classes">
    select * from classes where id = #{id}
</select>

MyBatis 缓存

  • 什么是 MyBatis 缓存

使用缓存可以减少 Java 应用与数据库的交换次数，从而提升程序的运行效率，比如查询出 id = 1 的对象，第一次查询出之后会自动将该对象保存到缓存中，当下一次查询时，直接从缓存中取出对象即可，无序再次访问数据库。

  • MyBatis 缓存分类

1、一级缓存：SqlSession 级别，默认开启，并且不能关闭。

操作数据库时需要创建 SqlSession 对象，在对象中有一个 HashMap 用于存储缓存数据，不同的 SqlSession 之间缓存数据区域是互不影响的。

一级缓存的作用域是 SqlSession 范围的，当在同一个 SqlSession 中执行两次相同的 SQL 语句时，第一次执行完毕会将结果保存到缓存中，第二次查询时直接从缓存中获取。

需要注意的是，如果 SqlSession 执行了 DML 操作（insert、update、delete），MyBatis 必须将缓存清空以保证数据的准确性。

2、二级缓存：Mapper 级别，默认关闭，可以开启。

使用二级缓存时，多个 SqlSession 使用同一个 Mapper 的 SQL 语句操作数据库，得到的数据会存在二级缓存区，同样是使用 HashMap 进行数据存储，相比较于一级缓存，二级缓存的范围更大，多个 SqlSession 可以共用二级缓存，二级缓存是跨 SqlSession 的。

二级缓存是多个 SqlSession 共享的，其作用域是 Mapper 的同一个 namespace，不同的 SqlSession 两次执行相同的 namespace 下的 SQL 语句，参数也相等，则第一次执行成功之后会将数据保存到二级缓存中，第二次可直接从二级缓存中取出数据。

代码

  • 一级缓存

package com.bsj.test;
​
import com.bsj.entity.Account;
import com.bsj.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);
    }
}

  • 二级缓存

1、MyBatis 自带的二级缓存

  • config.xml 中配置开启二级缓存

<settings>
    <!-- 打印SQL -->
    <setting name="logImpl" value="STDOUT_LOGGING"/>
    <!-- 开启延迟加载 -->
    <!-- mybatis-3.4.5 会报空指针异常，mybatis-3.5.1异常解决-->
    <setting name="lazyLoadingEnabled" value="true"/>
    <!-- 开启二级缓存 -->
    <setting name="cacheEnabled" value="true"/>
</settings>

  • Mapper.xml 中配置二级缓存

<cache></cache>

  • 实体类实现序列化接口

package com.bsj.entity;
​
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
​
import java.io.Serializable;
​
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Account implements Serializable {
    private long id;
    private String username;
    private String password;
    private int age;
}

2、ehcache 二级缓存

  • pom.xml 添加相关依赖

<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis-ehcache</artifactId>
    <version>1.0.0</version>
</dependency>
<dependency>
    <groupId>net.sf.ehcache</groupId>
    <artifactId>ehcache-core</artifactId>
    <version>2.4.3</version>
</dependency>

  • 添加 ehcache.xml

<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:noNamespaceSchemaLoaction="../config/ehcache.xsd">
    <diskStore/>
    <defaultCache
            maxElementsInMemory="1000"
            maxElementsOnDisk="10000000"
            eternal="false"
            overflowToDisk="false"
            timeToIdleSeconds="120"
            timeToLiveSeconds="120"
            diskExpiryThreadIntervalSeconds="120"
            memoryStoreEvictionPolicy="LRU">
    </defaultCache>
</ehcache>

  • config.xml 中配置开启二级缓存

<settings>
    <!-- 打印SQL -->
    <setting name="logImpl" value="STDOUT_LOGGING"/>
    <!-- 开启延迟加载 -->
    <!-- mybatis-3.4.5 会报空指针异常，mybatis-3.5.1异常解决-->
    <setting name="lazyLoadingEnabled" value="true"/>
    <!-- 开启二级缓存 -->
    <setting name="cacheEnabled" value="true"/>
</settings>

  • Mapper.xml 中配置二级缓存

<cache type="org.mybatis.caches.ehcache.EhcacheCache">
    <!-- 缓存创建之后，最后一次访问缓存的世间至缓存失效的时间间隔 -->
    <property name="timeToIdleSeconds" value="3600"/>
    <!-- 缓存自创建时间起至失效的时间间隔 -->
    <property name="timeToLiveSeconds" value="3600"/>
    <!-- 缓存回收测率，LRU表示移除近期使用最少的对象 -->
    <property name="memmoryStoreEvictionPolicy" value="LRU"/>
</cache>

  • 实体类不需要实现序列化接口

package com.bsj.entity;
​
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
​
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Account{
    private long id;
    private String username;
    private String password;
    private int age;
}

MyBatis 动态 SQL

使用动态 SQL 可简化代码的开发，减少开发者的工作量，程序可以自动根据业务参数来决定 SQL 的组成。

  • if 标签

<select id="findByAccount" parameterType="com.bsj.entity.Account" resultType="com.bsj.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>

if 标签可以自动根据表达式的结果来决定是否将对应的语句添加到 SQL 中，如果条件不成立则不添加，如果条件成立则添加。

  • where 标签

<select id="findByAccount" parameterType="com.bsj.entity.Account" resultType="com.bsj.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>

where 标签可以自动判断是否要删除语句块中的 and 关键字，如果检测到 where 直接跟 and 拼接，则自动删除 and，通常情况下 if 和 where 结合起来使用。

  • choose、when 标签

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

  • trim 标签

trim 标签中的 prefix 和 suffix 属性会被用于生成实际的 SQL 语句，会和标签内部的语句进行拼接，如果语句前后出现了 prefixOverrides 或者 suffixOverrides 属性中指定的值，MyBatis 框架会自动将其删除。

<select id="findByAccount" parameterType="com.bsj.entity.Account" resultType="com.bsj.entity.Account">
    select * from t_account
    <trim prefix="where" prefixOverrides="and">
        <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>
    </trim>
</select>

  • set 标签

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

<update id="update" parameterType="com.bsj.entity.Account">
    update t_account
    <set>
        <if test="username!=null">
            username = #{username}
        </if>
        <if test="password!=null">
            password = #{password}
        </if>
        <if test="age!=0">
            age = #{age}
        </if>
        <where>id = #{id}</where>
    </set>
</update>

  • foreach 标签

foreach 标签可以迭代生成一系列值，这个标签主要用于 SQL 的 in 语句。

<select id="findByIds" parameterType="com.bsj.entity.Account" resultType="com.bsj.entity.Account">
    select * from t_account
    <where>
        <foreach collection="ids" open="id in(" close=")" item="id" separator=",">
            #{id}
        </foreach>
    </where>
 </select>

总结

MyBatis是一个开源的持久层框架，它简化了与数据库的交互，同时提供了高度灵活性和高效性。以下是对MyBatis的总结：

  1. 灵活性：MyBatis允许开发人员使用SQL语句直接操作数据库，并且不需要遵循任何特定的编程模型。这样，开发人员可以完全控制所有的SQL语句，并能够对它们进行优化。

  2. 易于使用：MyBatis允许使用注解或XML文件来配置和映射SQL语句。这些文件都具有良好的结构和易于理解的格式，使得开发人员可以轻松地创建和编辑它们。

  3. 易于维护：MyBatis的配置文件和SQL映射文件都很容易维护。这些文件中不仅包含SQL语句，还包含了与数据库相关的其他信息，如数据库连接等。这使得开发人员可以轻松地维护和更新这些文件，而不会影响代码的其他部分。

  4. 易于扩展：MyBatis提供了插件机制，可以轻松地扩展功能，例如在SQL执行时添加日志记录或缓存功能。

  5. 高效性：MyBatis使用了缓存机制和预编译语句等技术，从而能够提高SQL执行的效率和性能。

总而言之，MyBatis是一个非常优秀的持久层框架，它提供了灵活性、易于使用、易于维护、易于扩展和高效性等优点。同时，MyBatis还具有与Spring等其他框架的良好集成性，能够更好地满足开发人员的需求。

JavaBsj
关注
专栏目录
Mybatis知识点总结
weixin_49013768的博客
06-28 271
mybatis知识点总结 复习用
mybatis知识总结.zip
08-19
在学习MyBatis的过程中，你需要掌握以下几个关键知识点： 1. **配置文件**：MyBatis的配置文件包含了数据源、事务管理器、SqlSessionFactory等信息。SqlSessionFactory是MyBatis的核心，用于创建SqlSession对象，它...
Mybatis知识总结
Zhanhxinjie的博客
11-03 924
对象关系映射（Object Relational Mapping，简称ORM）模式是一种为了解决面向对象与关系数据库存在的互不匹配的现象的技术。ORM框架是连接数据库的桥梁，只要提供了持久化类与表的映射关系，ORM框架在运行时就能参照映射文件的信息，把对象持久化到数据库中。ORM框架：为了解决面型对象与关系数据库存在的互不匹配的现象的框架。#{变量名}可以进行预编译、类型匹配等操作。#{变量名}会转化为jdbc的类型。${变量名}不进行数据类型匹配，直接替换。#方式能够很大程度防止sql注入。
Mybatis 知识总结1（入门、JDBC、数据库连接池、lombok介绍）
ItDaChuang的博客
04-26 613
mybatis 基础知识入门，包含概念介绍、JDBC、数据库连接池、lombok等介绍
Mybatis知识总结及具体应用
A0123abc_的博客
08-25 977
1.MyBatis是一个优秀的持久层框架，它对jdbc的操作数据库的过程进行封装，使开发者只需要关注 SQL 本身，而不需要花费精力去处理例如注册驱动、创建connection、创建statement、手动设置参数、结果集检索等jdbc繁杂的过程代码。2.Mybatis通过xml或注解。
Mybatis知识总结归纳
weixin_44536951的博客
02-25 247
文章目录Mybatis什么是框架?mybatis概述mybatis快速入门 Mybatis 什么是框架? 框架一整套解决问题的方案，里面并没有具体的业务逻辑，框架是一个半成品的软件 mybatis概述 MyBatis 是一款优秀的持久层框架，它支持自定义 SQL、存储过程以及高级映射。MyBatis 免除了几乎所有的 JDBC 代码以及设置参数和获取结果集的工作。MyBatis 可以通过简单的 XML 或注解来配置和映射原始类型、接口和 Java POJO（Plain Old Java Objects
Mybatis知识总结（超详细、超全面）
靖妖傩舞
04-11 6328
mybatis重点详细整理
总结MyBatis知识点
初尘屿风的博客
04-06 2493
MyBatis 是一款优秀的持久层框架，它支持自定义 SQL、存储过程以及高级映射。MyBatis 免除了几乎所有的 JDBC 代码以及设置参数和获取结果集的工作。
MyBatis基础知识总结
zhaolk的博客
06-03 868
本文对于Mybatis的来源及优势做了阐述，重点对于Mybatis的实例做了大量的演示操作
mybatis框架知识总结
小棟的博客
09-26 661
了解mybatis框架 框架（Framework）是一种提供了科重用的公共结构的半成品。简单来说框架也是一种快速开发的模板。 框架的优势如下: 1.不用再考虑公共问题，框架已经帮我们做好了。 2.可以专心于业务逻辑，保证核心业务逻辑的开发质量。 3.结构统一，便于学习和维护。 4.框架中集成了前人的经验，可以帮助新手写出稳定、性能优良而且结构优美的高质量程序。 ORM即对象关系映射，是一种数据化...
Mybatis知识总结脑图.jpg
04-08
知识图示
MyBatis知识点总结.ppt
06-08
在Mybatis中，每一个、、、标签，都会被解析为一个MappedStatement对象。 Dao接口里的方法，是不能重载的，因为Mybatis是全限名+方法名的保存和寻找策略。 Dao接口的工作原理是JDK动态代理，Mybatis运行时会使用...
Mybatis基础知识思维导图
04-04
基于动力节点所做Mybatis基础知识思维导图
mybatis知识点总结.docx
08-21
以下是对MyBatis核心知识点的详细解释： 1. **MyBatis基础**：MyBatis的核心功能在于它能将Java对象与数据库SQL语句进行映射，通过XML或注解方式实现。它可以支持自定义SQL、存储过程，以及高级的映射机制，使得...
MybatisPlus的LambdaQueryWrapper用法
2301_79693537的博客
08-21 5415
【代码】MybatisPlus的LambdaQueryWrapper用法。
【C++刷题】力扣-#121-买卖股票的最佳时机
最新发布
会写代码的饭桶
10-16 319
给定一个数组 prices，其中 prices[i] 表示第 i 天的股票价格。假设你可以在第 i 天买入并在第 j 天卖出股票（i ≤ j），设计一个算法来计算你所能获取的最大利润。注意你只能持有一股股票，并且你不能同时参与多笔交易（即在再次买入前必须卖出股票）。
基于SSM班级事务管理系统的设计
2401_87849773的博客
10-15 386
管理员账户功能包括：系统首页，个人中心，学生管理，班委管理，班会组织管理，健康档案管理，党员发展管理，党员培训管理，学生成绩管理。主要技术：Java,Spring,mybatis,mysql,jquery,html。班委账号功能包括：系统首页，学生管理，学生成绩管理，活动信息管理，班费通知管理。服务器：SpringBoot自带 apache tomcat。JDK版本：Java JDK1.8。数据库可视化工具： navicat。数据库版本： mysql5.7。开发系统：Windows。
Java安卓开发之Fragment开发（通俗易懂版）——第8章
一个脚本小子的博客
10-13 686
FragmentManager中的getSupportFragmentManager()方法不支持Activity，不论是旧版的FragmentManager还是新版的，因此我们要把继承Activity类改成继承AppCompatActivity类。
MyBatis核心技术与实战总结
"MyBatis学习总结，涵盖了MyBatis的基础知识、常用特性、高级应用及扩展点，包括XML和注解方式的开发，主键返回，批量查询，动态传参，缓存机制，延迟加载，关联查询，逆向工程，PageHelper分页，以及注解开发等内容...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

JavaBsj

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

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

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

打赏作者

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

抵扣说明：

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

余额充值