Mybatis

已于 2024-11-04 13:43:17 修改
阅读量700 收藏 17
点赞数 13
文章标签： mybatis tomcat java
于 2024-10-31 17:33:47 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ITKidKid/article/details/143408708
版权

1、概述

  1. 什么是mybatis？

MyBatis是一个基于Java的持久层框架，它支持定制化SQL、存储过程以及高级映射。MyBatis消除了几乎所有的JDBC代码和参数的手动设置以及结果集的检索。MyBatis使用简单的XML或注解用于配置和原始映射，将接口和Java的POJOs（Plain Ordinary Java Objects，普通的Java对象）映射成数据库中的记录。

它是一款半自动的ORM持久层框架，具有较高的SQL灵活性，支持高级映射(一对一，一对多)，动态SQL，延迟加载和缓存等特性，但它的数据库无关性较低

  • 什么是ORM？

    Object Relation Mapping，对象关系映射。对象指的是Java对象，关系指的是数据库中的关系模型，对象关系映射，指的就是在Java对象和数据库的关系模型之间建立一种对应关系，比如用一个Java的Student类，去对应数据库中的一张student表，类中的属性和表中的列一一对应。Student类就对应student表，一个Student对象就对应student表中的一行数据

  • 为什么mybatis是半自动的ORM框架？

    用mybatis进行开发，需要手动编写SQL语句。而全自动的ORM框架，如hibernate，则不需要编写SQL语句。用hibernate开发，只需要定义好ORM映射关系，就可以直接进行CRUD操作了。由于mybatis需要手写SQL语句，所以它有较高的灵活性，可以根据需要，自由地对SQL进行定制，也因为要手写SQL，当要切换数据库时，SQL语句可能就要重写，因为不同的数据库有不同的方言(Dialect)，所以mybatis的数据库无关性低。虽然mybatis需要手写SQL，但相比JDBC，它提供了输入映射和输出映射，可以很方便地进行SQL参数设置，以及结果集封装。并且还提供了关联查询和动态SQL等功能，极大地提升了开发的效率。并且它的学习成本也比hibernate低很多

2、MyBatis的优缺点

  • 优点

    • 代码量减少：与JDBC相比，MyBatis能够显著减少代码量，减少了50%以上的代码量。

    • 简单易学：MyBatis是最简单的持久化框架之一，小巧并且简单易学，适合初学者快速上手。

    • 灵活性高：不会对应用程序或者数据库的现有设计强加任何影响，SQL写在XML里，从程序代码中彻底分离，降低耦合度，便于统一管理和优化，可重用。

    • 动态SQL：提供XML标签，支持编写动态SQL语句（如if、else等），增强了SQL的灵活性和可读性。

    • 映射标签：提供映射标签，支持对象与数据库的ORM字段关系映射，可以在XML中配置映射关系，也可以使用注解配置映射关系。

    • 兼容性好：由于MyBatis使用JDBC来连接数据库，所以只要JDBC支持的数据库MyBatis都支持，具有良好的兼容性。

    • 性能较高：MyBatis使用JDBC提供的原生SQL接口，没有封装过多的抽象层，运行效率相对较高。

    • 易于调试：提供了日志输出功能，可以详细记录SQL执行情况，便于开发者进行调试。

    • 集成方便：能够与Spring等主流框架很好地集成，提高了开发效率。

  • 缺点

    • SQL维护复杂：需要手动编写SQL语句，如果SQL语句写得不好，就会导致可读性差、难以维护。

    • 编程量较大：虽然MyBatis提供了很多插件和辅助工具，但是需要编写大量的XML文件，会导致编程量增大，不利于快速开发。

    • 集成困难：如果需要整合多个数据源，就需要编写较多的配置文件，集成起来比较麻烦。

    • 调试难度增加：与JDBC相比，增加了调试代码和查错的难度，因为使用了ORM需要额外花费时间学习ORM的框架，调试错误比JDBC难很多。

    • 单步调试限制：JDBC可以单步调试，但MyBatis不能单步调试，需要通过日志输出日志信息帮助调试。

    • 数据库移植性差：SQL语句依赖于数据库，导致数据库移植性差，不能随意更换数据库。

    • 学习成本较高：需要开发人员掌握XML文件编写和SQL语句的构建等技术，学习成本较高

3、快速入门

3.1 添加依赖

在pom.xml里面添加依赖

       <!-- MyBatis -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.11</version>
        </dependency>
        <!-- MySQL Connector/J -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.32</version>
        </dependency>
		<dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
3.2 配置数据源
  1. 在resouces文件创建数据源jdbc.properties文件
jdbc.driver=com.mysql.cj.jdbc.Driver
jdbc.url=jdbc:mysql://IP:端口/数据库名?serverTimezone=Asia/Shanghai&useSSL=true&useUnicode=true&characterEncoding=utf-8
jdbc.username=账号
jdbc.password=密码
  1. 在resouces文件下创建xml文件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>
    <!-- 引入了外部的属性文件jdbc.properties -->
    <properties resource="jdbc.properties"/>
    <!-- 定义环境集合，并指定了默认的环境为development -->
    <environments default="development">
        <!-- 定义了名为 development 的具体环境配置 -->
        <environment id="development">
            <!-- 指定了事务管理器类型为JDBC -->
            <transactionManager type="JDBC"/>
            <!-- 指定了数据源类型为POOLED -->
            <dataSource type="POOLED">
                <!-- 驱动名、URL、用户名和密码，使用 ${jdbc.driver} 等从 jdbc.properties 文件获取值 -->
                <property name="driver" value="${jdbc.driver}"/>
                <property name="url" value="${jdbc.url}"/>
                <property name="username" value="${jdbc.username}"/>
                <property name="password" value="${jdbc.password}"/>
            </dataSource>
        </environment>
    </environments>
    <!-- 定义了一组映射器（Mapper），用于将SQL语句与Java对象进行映射。 -->
    <mappers>
        <!-- 映射器文件UserMapper.xml -->
        <mapper resource="UserMapper.xml"/>
    </mappers>

</configuration>
3.3 数据准备
  1. 创建数据库表，与实体类对应，创建user表

在这里插入图片描述

  1. 在com.example.mybatis.model包下面创建User类
@Data
public class User {

    private int id;
    private String username;
    private String password;

}
3.4 创建映射文件UserMapper.xml

  1. 创建映射接口，在com.example.mybatis.dao下创建UserMapper接口

    需根据命名空间创建对应接口

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!-- namespace 命名空间 -->
<mapper namespace="com.example.mybatis.dao.UserMapper">
    <!-- 根据 id 查询用户 -->
    <select id="selectById" resultMap="UserResultMap">
        SELECT * FROM user WHERE id = #{id}
    </select>
    <!-- 插入用户 -->
    <insert id="insert" keyProperty="id" useGeneratedKeys="true">
        INSERT INTO user (username, password) VALUES (#{username}, #{password})
    </insert>
    <!-- 更新用户 -->
    <update id="update">
        UPDATE user SET username = #{username}, password = #{password} WHERE id = #{id}
    </update>
    <!-- 删除用户 -->
    <delete id="deleteById">
        DELETE FROM user WHERE id = #{id}
    </delete>
    <!-- 结果映射 -->
    <resultMap id="UserResultMap" type="com.example.mybatis.model.User">
        <id property="id" column="id"/>
        <result property="username" column="username"/>
        <result property="password" column="password"/>
    </resultMap>
</mapper>
3.5 测试

执行以下代码

public class Test {

    public static void main(String[] args) throws IOException {
        // 读取 MyBatis 配置文件
        Reader reader = Resources.getResourceAsReader("mybatis-config.xml");
        // 创建 SqlSessionFactory
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(reader);
        // 获取 SqlSession
        SqlSession sqlSession = sqlSessionFactory.openSession();

        try {
            // 插入用户
            User newUser = new User();
            newUser.setUsername("testuser");
            newUser.setPassword("testpassword");
            sqlSession.insert("com.example.mybatis.dao.UserMapper.insert", newUser);
            sqlSession.commit();

            // 根据 id 查询用户
            User user = sqlSession.selectOne("com.example.mybatis.dao.UserMapper.selectById", newUser.getId());
            System.out.println("查询到的用户: " + user.getUsername());

            // 更新用户
            user.setUsername("updateduser");
            sqlSession.update("com.example.mybatis.dao.UserMapper.update", user);
            sqlSession.commit();

            // 删除用户
            sqlSession.delete("com.example.mybatis.dao.UserMapper.deleteById", user.getId());
            sqlSession.commit();
        } finally {
            sqlSession.close();
        }
    }

}

差不多了

4、高级特性

4.1 一对一、一对多、多对多、多对一表述（关联查询）
关系类型描述示例数据库表Mapper XML配置MyBatis 映射
一对一（1:1）一个实体与另一个实体之间存在唯一的关联表A（主键ID），
表B（外键A_ID，且A_ID在表B中唯一）		 使用<association>元素在类A的结果映射中映射类B的属性
One-to-One例如：Person（ID, Name），Address（ID, Person_ID, Address_Details），其中Person_ID在Address表中唯一
一对多（1:N）一个实体与多个其他实体之间存在关联表A（主键ID），表B（外键A_ID） 使用<collection>元素在类A的结果映射中映射类B的集合
One-to-Many例如：Author（ID, Name），
Book（ID, Author_ID, Title）		 SELECT * FROM orders WHERE user_id = #{user_id};
多对多（M:N）多个实体之间存在关联，通常通过中间表实现表A（主键ID），表B（主键ID），
表C（外键A_ID，外键B_ID，组合主键）		 使用两个<collection>元素或嵌套查询，结合<association>元素（如果需要在一方中映射另一方的详细信息）
Many-to-Many例如：Student（ID, Name），Course（ID, Course_Name），Student_Course（Student_ID, Course_ID） SELECT * FROM courses INNER JOIN student_course ON courses.id = student_course.course_id WHERE student_course.student_id = #{student_id}; 通常通过辅助查询或中间表的结果映射来处理
多对一（N:1）多个实体对应一个实体，例如多个员工属于一个部门。表A（主键ID），表B（外键A_ID，指向表A的主键）在类B的结果映射中使用<association>元素映射类A的属性
Many-to-One例如：employee （e_id, employee_name），department（d_id , department_name），其中Order表中的Customer_ID外键指向Customer表的主键SELECT * FROM employee WHERE e_id = #{employeeId}SELECT * FROM department WHERE d_id = #{departmentId}在employee 的ResultMap中使用<association>来映射Customer的属性
4.2 缓存机制
1. 一级缓存

  1. 定义与范围

    • 一级缓存是SqlSession级别的缓存，其生命周期与SqlSession一致。
    • 每个SqlSession都有自己独立的缓存区域，缓存的数据仅对当前SqlSession有效。

  2. 工作机制

    • 当SqlSession执行查询时，查询结果会被存储在SqlSession的缓存中。
    • 如果在同一个SqlSession中再次执行相同的查询（即SQL语句和参数都相同），MyBatis会直接从缓存中获取结果，而不再访问数据库。

  3. 失效情况

    • SqlSession被关闭、提交或回滚后，一级缓存将失效。
    • 执行任何增删改操作（insert、update、delete）后，一级缓存会被清空，以确保缓存数据的一致性。

  4. 默认状态

    • 一级缓存默认是开启的，无需进行额外配置。

  5. 实现

	public static void main(String[] args) throws IOException {
        // 读取 MyBatis 配置文件
        Reader reader = Resources.getResourceAsReader("mybatis-config.xml");
        // 创建 SqlSessionFactory
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(reader);
        User user1 = null;
        // 第一次查询
        try (SqlSession sqlSession1 = sqlSessionFactory.openSession()) {
            UserMapper userMapper1 = sqlSession1.getMapper(UserMapper.class);
            user1 = userMapper1.selectById(1);
            System.out.println("第一次查询结果: " + user1);

            // 在同一个SqlSession中再次查询相同的数据，会从一级缓存中获取
            User user2 = userMapper1.selectById(1);
            System.out.println("第二次查询结果: " + user2);
            // 比较两个查询结果是否是同一个对象（一级缓存命中）
            System.out.println("两次查询结果是否相同: " + (user1 == user2));
        }

        // 新的 SqlSession 查询（不会使用上一个 SqlSession 的缓存）
        try (SqlSession sqlSession2 = sqlSessionFactory.openSession()) {
            UserMapper userMapper2 = sqlSession2.getMapper(UserMapper.class);
            User user3 = userMapper2.selectById(1);
            System.out.println("第三次查询结果: " + user3);
            // 比较与第一次查询结果是否是同一个对象（不是，因为是不同的 SqlSession）
            System.out.println("第一次和第三次查询结果是否相同: " + (user1 == user3));
        }
    }
2. 二级缓存

  1. 定义与范围

    • 二级缓存是Mapper级别的缓存，其生命周期相对较长，作用范围是整个应用程序中共享的。
    • 同一个Mapper对应的二级缓存数据可以在不同的SqlSession中共享。
    • 同一个namespace下的所有Mapper文件可以共享一个二级缓存区域。

  2. 工作机制

    • 当查询结果被存储在二级缓存中时，其他SqlSession可以直接从二级缓存中获取结果，而无需再次访问数据库。
    • 二级缓存的开启需要在Mapper XML文件中配置<cache/>标签或使用注解@CacheNamespace。

  3. 失效情况

    • 执行增删改操作后，相关的二级缓存会失效，以确保缓存数据的一致性。
    • 如果配置了全局性的缓存开关<setting name="cacheEnable" value="false"/>，则所有二级缓存都将被关闭。

  4. 默认状态

    • 二级缓存默认是关闭的，需要显式地在Mapper中配置才能启用。

  5. 使用条件

    • 要使用二级缓存，实体类对象必须是可序列化的，即必须实现Serializable接口。
    • SqlSession对象关闭或提交之后，一级缓存中的数据才会被写入二级缓存，此时二级缓存才可用。

  6. 开启二级缓存(UserMapper.xml)

<!-- 开启二级缓存 -->
<cache eviction="LRU" flushInterval="60000" size="512" readOnly="true"/>
  • eviction属性指定了缓存的淘汰策略，这里LRU（最近最少使用）表示当缓存达到容量上限时，会淘汰最近最少使用的数据。其他常见的淘汰策略还有FIFO（先进先出）、SOFT（软引用，基于垃圾回收器的策略）、WEAK（弱引用，基于垃圾回收器的策略）等。
  • flushInterval属性指定了缓存的刷新间隔时间（单位是毫秒），这里表示每60000毫秒（即60秒）刷新一次缓存。如果设置为0或不设置，则表示不自动刷新。
  • size属性指定了缓存的容量大小，这里最多可以缓存512个对象。
  • readOnly属性设置为true表示缓存数据是只读的，这可以提高性能。如果设置为false，则表示缓存数据可以被修改，MyBatis 会使用序列化等方式来处理缓存数据的更新，性能会稍低一些。
  1. 实现
	public static void main(String[] args) throws IOException {
        // 读取 MyBatis 配置文件
        Reader reader = Resources.getResourceAsReader("mybatis-config.xml");
        // 创建 SqlSessionFactory
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(reader);

        try (SqlSession sqlSession1 = sqlSessionFactory.openSession();
             SqlSession sqlSession2 = sqlSessionFactory.openSession()) {

            UserMapper userMapper1 = sqlSession1.getMapper(UserMapper.class);
            UserMapper userMapper2 = sqlSession2.getMapper(UserMapper.class);

            // 第一次查询，结果会从数据库中获取并存储到二级缓存中（在sqlSession1提交后）
            User user1 = userMapper1.selectById(1);
            sqlSession1.commit(); // 提交事务以将结果写入二级缓存

            // 第二次查询，在不同的SqlSession中，但因为开启了二级缓存，所以结果会从二级缓存中获取
            User user2 = userMapper2.selectById(1);
            sqlSession2.close(); // 注意：通常不需要显式关闭二级缓存，因为它是由MyBatis管理的

            // 输出user1和user2是否相同（注意：这里可能不是同一个实例，因为MyBatis可能会进行深拷贝或浅拷贝）
            // 但它们的内容应该是相同的
            System.out.println(user1.equals(user2)); // 输出 true，表示两个对象的内容相同
        }
    }
3. 缓存的优化与管理

  1. 选择合适的缓存类型

    • 根据业务需求和性能要求选择合适的缓存类型。一级缓存适用于短期的数据库操作，而二级缓存适用于更大范围的数据共享。

  2. 避免频繁更新数据

    • 更新操作会导致缓存失效，影响查询性能。因此，应尽量避免频繁的更新操作。

  3. 合理配置缓存大小和过期时间

    • 缓存数据过多或过期时间过长都可能导致性能问题。因此，应合理配置缓存大小和过期时间，以确保缓存的有效性和性能。

  4. 使用缓存注解或手动控制缓存

    • 在查询操作中使用缓存注解或手动控制缓存，可以提高缓存命中率，进一步提升性能。
4.3 插件机制
  1. 创建插件类ExecutionTimePlugin实现Interceptor接口
@Intercepts({
        @Signature(type = StatementHandler.class, method = "prepare", args = {Connection.class, Integer.class})
})
public class ExecutionTimePlugin implements Interceptor {

    @Override
    public Object intercept(Invocation invocation) throws Throwable {
        long startTime = System.currentTimeMillis();
        Object result = invocation.proceed();
        long endTime = System.currentTimeMillis();
        System.out.println("SQL Execution Time: " + (endTime - startTime) + " ms");
        return result;
    }

    @Override
    public Object plugin(Object target) {
        return Plugin.wrap(target, this);
    }

    @Override
    public void setProperties(Properties properties) {
        // 设置插件的属性，如果需要的话
    }
}
  1. 配置mybatis-config.xml文件

按照配置文件的顺序进行配置，不然会报错。

	<plugins>
        <plugin interceptor="com.example.mybatis.config.ExecutionTimePlugin"/>
    </plugins>
  1. 测试
	public static void main(String[] args) throws IOException {
        // 读取 MyBatis 配置文件
        Reader reader = Resources.getResourceAsReader("mybatis-config.xml");
        // 创建 SqlSessionFactory
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(reader);
        User user1 = null;
        // 查询
        try (SqlSession sqlSession1 = sqlSessionFactory.openSession()) {
            UserMapper userMapper1 = sqlSession1.getMapper(UserMapper.class);
            user1 = userMapper1.selectById(1);
            System.out.println("查询结果: " + user1);
        }
    }
  1. 测试结果
14:52:12.833 [main] DEBUG com.example.mybatis.dao.UserMapper.selectById - ==>  Preparing: SELECT * FROM user WHERE id = ?
SQL Execution Time: 15 ms
14:52:12.847 [main] DEBUG com.example.mybatis.dao.UserMapper.selectById - ==> Parameters: 1(Integer)
14:52:12.859 [main] DEBUG com.example.mybatis.dao.UserMapper.selectById - <==      Total: 1
查询结果: User(id=1, username=testuser, password=testpassword)
4.4 延迟加载
1. 延迟加载的概念

延迟加载（Lazy Loading），又称懒加载或按需加载，指的是在真正需要数据时才从数据库中加载数据，而不是在查询一开始就加载所有数据。这种机制可以减少不必要的数据库查询，提高系统性能。

2. MyBatis延迟加载的实现原理

MyBatis通过动态代理和AOP（面向切面编程）技术实现了延迟加载。当需要查询某个对象时，MyBatis不会立即执行完整的查询，而是返回一个代理对象。这个代理对象会在真正需要访问对象的属性时才去执行查询操作。

  1. 动态代理：MyBatis使用动态代理技术生成代理对象，该对象会拦截对实际数据对象的访问操作。当访问某个属性时，代理对象会判断该属性是否已经被加载。如果未被加载，则通过SQL语句查询出该属性并进行加载；如果已被加载，则直接返回该属性的值。
  2. AOP：MyBatis的延迟加载机制还利用了AOP技术。通过在Mapper接口的方法上应用特定的注解或配置，MyBatis可以在方法调用时插入延迟加载的逻辑。
3. MyBatis延迟加载的配置

在MyBatis中，可以通过配置文件或注解来配置延迟加载。

  1. 全局配置：在MyBatis的配置文件（如mybatis-config.xml）中，可以通过settings元素来配置全局的延迟加载行为。其中，lazyLoadingEnabled属性用于控制是否启用延迟加载，默认为false（不启用）。当设置为true时，MyBatis将启用延迟加载机制。
  2. 局部配置：在Mapper的XML文件中，可以通过resultMap元素中的association和collection子元素来配置具体属性的延迟加载行为。其中，fetchType属性可以设置为lazy（延迟加载）或eager（立即加载）。
4. 延迟加载的优点和注意事项

优点：

  1. 提高性能：延迟加载可以减少数据库的查询次数，从而减轻数据库的负担，提高系统的响应速度。
  2. 节约资源：对于不需要立即加载的数据，延迟加载可以避免不必要的内存占用，节约系统资源。

注意事项：

  1. N+1查询问题：在使用延迟加载时，如果循环访问每个对象的关联对象，可能会触发大量的单独查询，导致性能下降。这被称为N+1查询问题。为了避免这个问题，可以使用MyBatis提供的批量查询功能或优化查询逻辑。
  2. 并发问题：在多线程环境下，如果多个线程同时访问同一个对象的关联对象，可能会导致对象的多次加载和缓存问题。因此，在使用延迟加载时需要注意并发控制。
  3. 配置文件中的设置：在配置文件中启用或关闭延迟加载功能时，需要确保配置的正确性。同时，对于特定的属性或元素，也可以根据需要设置延迟加载属性。
5. 实战
  1. 创建类和数据库表记得创建，
@Data
public class Account {
    private Integer id;
    private Integer uid;
    private Double money;
    private User user;
}
  1. 配置mybatis-config.xml文件
    <settings>
        <!-- lazyLoadingEnabled 设置为 true：启用了延迟加载机制。这意味着当你查询一个对象时，其关联的对象不会立即加载。 -->
        <setting name="lazyLoadingEnabled" value="true"/>
        <!-- 当 lazyLoadingEnabled 为 true 时，这个设置项才有意义。如果 aggressiveLazyLoading 设置为 true，
        MyBatis 会在第一次访问延迟加载属性时立即加载所有关联对象。如果设置为 false，则只有在真正访问某个具体的关联对象时才会触发加载。 -->
        <setting name="aggressiveLazyLoading" value="false"/>
    </settings>
  1. 创建AccountMapper.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.example.mybatis.dao.AccountMapper">
    <resultMap id="AccountResultMap" type="com.example.mybatis.model.Account">
        <id column="id" property="id"/>
        <result column="uid" property="uid"/>
        <result column="money" property="money"/>
        <association property="user" javaType="com.example.mybatis.model.User" select="com.example.mybatis.dao.UserMapper.selectById" column="uid"/>
    </resultMap>
    <select id="findAccountById" resultMap="AccountResultMap">
        SELECT * FROM account WHERE id = #{id}
    </select>
</mapper>
  1. 测试
	public static void main(String[] args) throws IOException {
        // 读取 MyBatis 配置文件
        Reader reader = Resources.getResourceAsReader("mybatis-config.xml");
        // 创建 SqlSessionFactory
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(reader);
        try (SqlSession sqlSession = sqlSessionFactory.openSession()) {
            AccountMapper accountMapper = sqlSession.getMapper(AccountMapper.class);
            Account account = accountMapper.findAccountById(1);
            // 此时不会查询用户信息，直到访问account.getUser()时才会触发查询
            System.out.println(account.getUser().getUsername());
        }
    }
4.5 MyBatis Generator
1. 添加插件

在pom.xml添加以下插件

 			<plugin>
                <groupId>org.mybatis.generator</groupId>
                <artifactId>mybatis-generator-maven-plugin</artifactId>
                <version>1.3.7</version>
                <configuration>
                    <verbose>true</verbose>
                    <overwrite>true</overwrite>
                </configuration>
                <dependencies>
                    <dependency>
                        <groupId>mysql</groupId>
                        <artifactId>mysql-connector-java</artifactId>
                        <version>8.0.26</version>
                    </dependency>
                </dependencies>
            </plugin>

刷新依赖，就可以看到插件了

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

2. 创建 generatorConfig.xml 配置文件
<!DOCTYPE generatorConfiguration PUBLIC
        "-//mybatis.org//DTD MyBatis Generator Configuration 1.0//EN"
        "http://mybatis.org/dtd/mybatis-generator-config_1_0.dtd">
<generatorConfiguration>
    <!-- MyBatis3Simple风格 -->
    <context id="simple" targetRuntime="MyBatis3Simple">

        <property name="javaFileEncoding" value="UTF-8"/>
        <!--生成mapper.xml时覆盖原文件-->
        <plugin type="org.mybatis.generator.plugins.UnmergeableXmlMappersPlugin"/>

        <commentGenerator>
            <!-- 是否去除自动生成的注释 true：是 ： false:否。 自动生成注释太啰嗦，可以编码扩展CommentGenerator -->
            <property name="suppressAllComments" value="true"/>
        </commentGenerator>

        <!-- 数据库连接 -->
        <jdbcConnection driverClass="com.mysql.cj.jdbc.Driver"
                        connectionURL="jdbc:mysql://localhost:3306/test?useUnicode=true&amp;characterEncoding=utf8&amp;tinyInt1isBit=true&amp;serverTimezone=UTC"
                        userId="root" password="root">
            <!-- 设置为true就只读取test下的表, 否则会优先读取到mysql的user表  -->
            <property name="nullCatalogMeansCurrent" value="true"/>
        </jdbcConnection>

        <!-- 生成PO的包名和位置 -->
        <javaModelGenerator targetPackage="com.example.mybatis.model" targetProject="src/main/java"/>

        <!-- 生成XML映射文件的包名和位置 -->
        <sqlMapGenerator targetPackage="/" targetProject="src/main/resources"/>

        <!-- 生成Mapper接口的包名和位置 -->
        <javaClientGenerator type="XMLMAPPER" targetPackage="com.example.mybatis.dao" targetProject="src/main/java"/>

        <!-- 要生成对应表配置 -->
        <table tableName="sys_user" domainObjectName="User" >
            <!-- 自增主键列 -->
            <generatedKey column="id" sqlStatement="MYSQL" identity="true"/>
            <!-- varchar映射为String -->
            <columnOverride column="name" javaType="String" jdbcType="varchar"/>
        </table>
    </context>
</generatorConfiguration>

点击插件，进行代码生成。

微风粼粼
关注
MyBatis中使用POJO包装对象做映射(17)
BruceLeeNumberOne的博客
04-24 3115
开发中使用POJO传递查询条件，查询条件时综合的查询条件，不仅包括用户查询条件还包括其它的查询条件(是另外一个POJO)，这个时候就可以使用包装对象传递输入参数。定义包装对象将查询条件(pojo)以类组合的方式包装起来。一、需求完成用户信息的综合查询，需要传入的查询条件很复杂(可能包括用户信息、其他信息，比如商品、订单的信息)，针对这种需求，建议使用自定义的包装类型的pojo。二、编写代码进行测试...
myBatis高级映射（映射到pojo中的pojo）
Hao_JanYang的博客
06-12 1678
实体类 import java.math.BigDecimal; import java.util.List; public class Cartitem { private String cartItemId;// 主键 private Integer quantity;// 数量 private Book book;// 条目对应的图书 private Use...
MyBatis中配置POJO和数据库表字段映射
分享技术，分享经验
07-17 766
通过上述三种方法，可以灵活地在 MyBatis 中配置 POJO 类属性与数据库表字段的映射关系。标签提供了细粒度的控制，适合复杂映射。SQL 别名映射简单直接，适合简单映射。全局配置简洁高效，适合常规映射。
MyBatis(初阶）
最新发布
2301_80363309的博客
04-15 650
总结⽬标1.使⽤MyBatis完成库简单的增删改查操作, 参数传递.2.掌握MyBatis的两种写法: 注解 和 XML⽅式3.掌握MyBatis 相关的⽇志配置。
mybatis学习 (五) POJO的映射文件
bagonghui3635的博客
09-24 373
Mapper.xml映射文件中定义了操作数据库的sql，每个sql是一个statement，映射文件是mybatis的核心。 1、parameterType(输入类型) 通过parameterType指定输入参数的类型，类型可以是简单类型、hashmap、pojo的包装类型。#{}实现的是向prepareStatement中的预处理语句中设置参数值，sql语句中#{}表示一个占...
框架三：Mybatis sql语句与pojo之间的映射
失措*的博客
11-06 2535
MyBatis 是一款优秀的持久层框架，它支持定制化 SQL、存储过程以及高级映射。MyBatis 避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集。MyBatis 可以使用简单的 XML 或注解来配置和映射原生信息，将接口和 Java 的 POJOs(Plain Old Java Objects,普通的 Java对象)映射成数据库中的记录。 映射方式 数据表映射为类 表中行映射到对象...
Spring+SpringMVC+Mybatis框架整合例子(SSM) 下载
07-21
Spring、SpringMVC和Mybatis是Java开发中最常用的三大开源框架，它们的整合使用，通常被称为SSM框架。这个框架组合提供了完整的后端服务解决方案，包括依赖注入（DI）、面向切面编程（AOP）、模型-视图-控制器（MVC...
IDEA的MyBatis插件两个
03-07
本篇文章将详细介绍两个针对MyBatis框架的IntelliJ IDEA插件——MyBatisCodeHelper-Pro和MybatisX，它们都是为了提升MyBatis开发体验而设计的。 首先，我们来看MyBatisCodeHelper-Pro。这款插件是专为MyBatis开发者...
idea插件MybatisX-1.6.1
02-23
MybatisX是一款针对IntelliJ IDEA的高效MyBatis开发插件，版本为1.6.1。这个插件旨在简化MyBatis框架在IDEA中的使用，提高开发效率，帮助开发者快速完成与MyBatis相关的各种任务。下面将详细介绍这款插件的主要功能...
MyBatis-Flex： 一个优雅的 MyBatis 增强框架
08-04
MyBatis-Flex： 一个优雅的 MyBatis 增强框架。很轻量，MyBatis-Flex 整个框架只依赖 MyBatis，再无其他任何第三方依赖。只增强，MyBatis-Flex 支持 CRUD、分页查询、多表查询、批量操作，但不丢失 MyBatis 原有的...
# MybatisLog sql日志 Free-Mybatis 插件
06-01
MybatisLog是一款针对Mybatis框架的日志插件，Free-Mybatis则是它的扩展，两者结合为开发者提供了强大的SQL日志追踪功能。在开发过程中，理解并优化SQL查询是提升应用程序性能的关键步骤，而MybatisLog与Free-...
自动生成mybatis映射文件，mapper接口和pojo实体类
05-06
在generatorConfig.xml配置文件中修改自己的配置信息与数据库连接。确认一切无误之后运行项目src目录下GeneratorSqlmap.java。然后把生成的东西直接拷贝到你项目
JavaEE——MyBatis将查询结果集封装进POJO实体类
hssjsh的博客
02-17 1591
JavaEE——MyBatis将查询结果集封装进POJO实体类
mybatis高级映射总结
Molly
07-03 4731
一、一对一查询 二、一对多查询 三、多对多查询
【框架】mybatis---输入映射---定义pojo包装类型
sinat_38142087的博客
10-24 439
需求：完成用户的高级查询 或综合查询，需要传入复杂的查询条件，那么需要定义包装类型POJO和拓展类型来完成数据的传递 1、自定义包装类型 public class UserQueryVo { //引入拓展类并有setter和getter方法 //用户查询条件 private UserCustom userCustom; public UserCustom getUserCu...
Mybatis实现映射器的2种方式
unber的博客
08-12 493
映射器是 MyBatis 中最重要、最复杂的组件，它由一个接口和对应的 XML 文件（或注解）组成。本节阐述两种实现映射器的方式，XML 文件形式和注解形式。不过在此之前，先用以下 SQL 语句创建 role 表。并且定义一个 POJO，它十分简单，如下所示。映射器的主要作用就是将 SQL 查询到的结果映射为一个 POJO，或者将 POJO 的数据插入到数据库中，并定义一些关于缓存等的重要内容。注意，开发只是一个接口，而不是一个实现类。
MyBatis —— 多种查询及映射关系
荔枝当大佬的博客
08-30 1292
上一篇文章中荔枝梳理了有关MyBatis的相关环境配置和核心配置文件及其模板的设置和生成，而在这篇文章中荔枝会着重梳理MyBatis多种查询情况、特殊SQL执行以及两表联查时映射关系的处理。希望对需要的小伙伴有帮助~~~最近看了丙哥的文章，喜欢一句话分享给大家：你知道的越多，你不知道的越多。共勉共勉哈哈哈哈~~~
4.Mybatis映射文件（类名+Mapper.xml）
相互学习 共同进步
04-25 1397
除了上述自定义缓存的方式，也可以通过实现自己的缓存，或为其他第三方缓存方案创建适配器，来完全覆盖缓存行为例子：type属性指定的类必须实现org.mybatis.cache.Cache接口，且提供一个接受String参数作为id的构造器。这个接口是MyBatis框架中许多复杂的接口之一，但是行为却非常简单。
MyBatis高级映射——灵活地映射复杂的数据类型
AI天才研究院
07-28 2092
概述在实际项目中，经常会遇到需要从数据库查询出复杂的数据类型，例如pojo对象、map集合、json字符串等。如何将数据库查询出的复杂数据类型映射到pojo对象，或者如何自定义转换器实现映射呢？MyBatis 是一个优秀的ORM框架，它的提供的映射方式能够满足一般的需求。本文重点介绍 MyBatis 的高级映射功能。本文假设读者已经对 MyBatis 有一定了解。
SpringBoot与Mybatis整合完全指南
根据给定的文件信息，以下是关于Spring Boot整合MyBatis的知识点总结： ### Spring Boot整合MyBatis知识点总结 #### 1. Spring Boot简介 Spring Boot是由Pivotal团队提供的全新框架，其设计目的是用来简化新Spring...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值