使用数据库别名

7. Mybatis是怎么将mapper与xml联系起来的

MyBatis 将 Mapper 接口与 XML 映射文件联系起来的原理主要依赖于 JDK 动态代理技术和 MyBatis 的内部实现机制。以下是具体的过程：

1. Mapper 接口定义：首先，你需要定义一个 Mapper 接口，这个接口中包含了与数据库操作相关的方法。
2. XML 映射文件：然后，你需要编写一个与 Mapper 接口对应的 XML 映射文件（通常以 .xml 为后缀）。这个文件包含了具体的 SQL 语句、参数类型、结果映射等信息。在 XML 文件中，<mapper> 标签的 namespace 属性通常设置为 Mapper 接口的全限定名，这样 MyBatis 就能知道这个 XML 文件是为哪个 Mapper 接口服务的。
3. Mapper 代理类的生成：当 MyBatis 启动或 Mapper 接口被加载时，MyBatis 会使用 JDK 动态代理技术为这个 Mapper 接口生成一个代理类（通常是 MapperProxy）。这个代理类实现了 Mapper 接口，并拦截了接口中所有方法的调用。
4. 方法调用与 SQL 执行：当应用程序调用 Mapper 接口中的方法时，实际上是在调用 Mapper 代理类的方法。Mapper 代理类会拦截这个方法的调用，并根据方法的名称和参数信息，在 XML 映射文件中找到对应的 SQL 语句。然后，MyBatis 会创建一个 SqlSession 对象，并将方法名和参数传递给 SqlSession 对象。SqlSession 对象会根据 XML 映射文件中的配置，解析 SQL 语句，设置参数，并执行 SQL 语句。
5. 结果处理：执行完 SQL 语句后，SqlSession 对象会将查询结果返回给 Mapper 代理类。Mapper 代理类会根据 XML 映射文件中的结果映射规则（如 <resultMap> 标签），将查询结果转换成 Java 对象，并返回给应用程序。

8. 如何执行批量插入（SqlSessionFactory）

在 MyBatis 中执行批量插入通常涉及到 SqlSession 的使用，而不是直接使用 SqlSessionFactory。SqlSessionFactory 是用于创建 SqlSession 的工厂类，而 SqlSession 是执行 SQL 语句的接口。

以下是如何使用 MyBatis 执行批量插入的步骤：

1. 配置 MyBatis：确保你的 MyBatis 配置文件（如 mybatis-config.xml）和 Mapper XML 文件已经正确配置。
2. 获取 SqlSessionFactory：从 MyBatis 配置文件中获取 SqlSessionFactory。
3. 打开 SqlSession：使用 SqlSessionFactory 打开一个新的 SqlSession。
4. 执行批量插入：
   • 使用 Mapper 接口中的方法执行多次插入（如果 Mapper 方法支持批量插入）。
   • 或者，手动构建批量插入的 SQL 语句，并使用 SqlSession 的 insert() 方法执行。
5. 提交事务：确保在批量插入后提交事务。
6. 关闭 SqlSession：在完成所有操作后关闭 SqlSession。

示例代码：

使用 MyBatis 执行批量插入的示例：

UserMapper.java

public interface UserMapper {  
    // 通常 Mapper 接口中不会有直接的批量插入方法，但你可以定义一个方法来执行自定义的 SQL  
    int batchInsertUsers(List<User> users);  
}

UserMapper.xml 

<mapper namespace="com.example.mapper.UserMapper">  
    <!-- 假设你有一个批量插入的 SQL 语句 -->  
    <insert id="batchInsertUsers" parameterType="list">  
        INSERT INTO users (column1, column2, ...)  
        VALUES   
        <foreach collection="list" item="user" separator=",">  
            (#{user.property1}, #{user.property2}, ...)  
        </foreach>  
    </insert>  
</mapper>

执行批量插入

try (SqlSession sqlSession = sqlSessionFactory.openSession(ExecutorType.BATCH)) {  
    UserMapper userMapper = sqlSession.getMapper(UserMapper.class);  
    List<User> users = ... // 填充用户列表  
  
    // 假设 batchInsertUsers 是你的批量插入方法  
    userMapper.batchInsertUsers(users);  
  
    // 提交事务  
    sqlSession.commit();  
}

9. Mybatis通过jdk动态代理的原理

MyBatis 通过 JDK 动态代理实现 Mapper 接口与 SQL 语句之间的关联，其原理步骤：

1. Mapper 接口定义：
   • 开发者定义 Mapper 接口，该接口中包含了与数据库操作相关的方法。
2. XML 映射文件：
   • 开发者为每个 Mapper 接口编写对应的 XML 映射文件，文件中定义了 SQL 语句、参数类型、结果映射等信息。
   • XML 映射文件的 <mapper> 标签的 namespace 属性设置为 Mapper 接口的全限定名，这样 MyBatis 就知道这个 XML 文件是为哪个 Mapper 接口服务的。
3. SqlSessionFactory 与 SqlSession：
   • MyBatis 通过 SqlSessionFactoryBuilder 加载配置文件（如 mybatis-config.xml），然后创建 SqlSessionFactory。
   • SqlSessionFactory 负责创建 SqlSession，SqlSession 是执行 SQL 语句的接口。
4. JDK 动态代理：
   • 当应用程序通过 SqlSession 调用 Mapper 接口中的方法时，MyBatis 不会直接执行这些方法。
   • 相反，MyBatis 使用 JDK 动态代理为 Mapper 接口生成一个代理对象（MapperProxy）。
   • 这个代理对象实现了 Mapper 接口，并拦截了接口中所有方法的调用。
5. 方法调用与 SQL 执行：
   • 当应用程序调用 Mapper 接口中的方法时，实际上是调用了 Mapper 代理对象（MapperProxy）的方法。
   • Mapper 代理对象会根据方法的名称和参数信息，在 XML 映射文件中找到对应的 SQL 语句。
   • 然后，Mapper 代理对象会创建一个 SqlCommand 对象（包含 SQL 语句、参数等信息），并将其传递给 SqlSession 执行。
6. 结果处理：
   • SqlSession 执行 SQL 语句后，会将查询结果返回给 Mapper 代理对象。
   • Mapper 代理对象会根据 XML 映射文件中的结果映射规则（如 <resultMap>），将查询结果转换成 Java 对象，并返回给应用程序。
7. 事务管理：
   • MyBatis 支持事务管理，可以在 SqlSession 级别控制事务的提交和回滚。
   • 开发者可以通过 SqlSession 的 commit() 和 rollback() 方法来管理事务。

演示如何通过 JDK 动态代理实现 Mapper 接口与 SQL 语句之间的关联：

1. Mapper 接口定义

package com.example.mapper;  
  
import com.example.model.User;  
  
public interface UserMapper {  
    User selectUserById(int id);  
    void insertUser(User user);  
    // ... 其他方法 ...  
}

2. 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.mapper.UserMapper">  
    <select id="selectUserById" resultType="com.example.model.User">  
        SELECT * FROM users WHERE id = #{id}  
    </select>  
    <insert id="insertUser" parameterType="com.example.model.User">  
        INSERT INTO users (name, age) VALUES (#{name}, #{age})  
    </insert>  
    <!-- ... 其他 SQL 语句 ... -->  
</mapper>

3. MyBatis 配置文件 

<?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>  
    <environments default="development">  
        <environment id="development">  
            <transactionManager type="JDBC"/>  
            <dataSource type="POOLED">  
                <!-- 数据库连接信息 -->  
                <property name="driver" value="com.mysql.jdbc.Driver"/>  
                <property name="url" value="jdbc:mysql://localhost:3306/mydatabase"/>  
                <property name="username" value="root"/>  
                <property name="password" value="password"/>  
            </dataSource>  
        </environment>  
    </environments>  
    <mappers>  
        <mapper resource="com/example/mapper/UserMapper.xml"/>  
        <!-- ... 其他映射文件 ... -->  
    </mappers>  
</configuration>

4. SqlSessionFactory 与 SqlSession

import org.apache.ibatis.io.Resources;  
import org.apache.ibatis.session.SqlSession;  
import org.apache.ibatis.session.SqlSessionFactory;  
import org.apache.ibatis.session.SqlSessionFactoryBuilder;  
  
import java.io.IOException;  
import java.io.Reader;  
  
public class MyBatisDemo {  
    public static void main(String[] args) {  
        String resource = "mybatis-config.xml";  
        try (Reader reader = Resources.getResourceAsReader(resource)) {  
            SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(reader);  
              
            try (SqlSession sqlSession = sqlSessionFactory.openSession()) {  
                // ... 使用 sqlSession 调用 Mapper 接口的方法 ...  
            }  
        } catch (IOException e) {  
            e.printStackTrace();  
        }  
    }  
}

5. JDK 动态代理

在 MyBatis 的内部实现中，当通过 sqlSession.getMapper(UserMapper.class) 获取 Mapper 接口的实例时，MyBatis 会使用 JDK 动态代理为 UserMapper 接口生成一个代理对象。但是，这部分代码是 MyBatis 框架内部实现的，我们不需要直接编写。

6. 方法调用与 SQL 执行

通过 sqlSession.getMapper(UserMapper.class) 获得的代理对象，我们可以像调用普通 Java 方法一样调用 Mapper 接口中的方法，MyBatis 会根据 XML 映射文件中的配置执行相应的 SQL 语句：

try (SqlSession sqlSession = sqlSessionFactory.openSession()) {  
    UserMapper userMapper = sqlSession.getMapper(UserMapper.class);  
    User user = userMapper.selectUserById(1); // 执行 SQL 查询

10. Mybatis的工作原理（重要）

MyBatis 的工作原理可以概括为以下几个重要步骤：

1. mybatis应用程序通过SqlSessionFactoryBuilder从mybatis-config.xml配置文件（或者Java文件配置）来构建SqlSessionFactory（SqlSessionFactory是线程安全的）
2. SqlSessionFactory实例通过openSession方法开启一个SqlSession
3. 通过SqlSession实例的getMapper方法获得指定的Mapper对象并运行Mapper映射的SQL语句，完成对数据库的CRUD和事务提交，之后关闭SqlSession

11. Mybatis实现一对一、一对多有几种方式

1. 一对一
   1.  联合查询：联合查询是几个表联合查询,只查询一次,通过在 resultMap 里面配置 association 节点配置一对一的类就可以完成
   2.  嵌套查询：先查一个表,根据这个表里面的结果的外键id,去再另外一个表里面查询数据,也是
   3.  通过 association 配置,但另外一个表的查询通过 select 属性配置
2. 一对多
   1.  联合查询：联合查询是几个表联合查询,只查询一次,通过在 resultMap 里面配置 collection 节点配置一对一的类就可以完成
   2.  嵌套查询：先查一个表,根据这个表里面的结果的外键id,去再另外一个表里面查询数据,也是
   3.  通过 collection 配置,但另外一个表的查询通过 select 属性配置

12. Mybatis是否支持延迟加载？如果支持，它的实现原理是什么？

MyBatis支持延迟加载。

延迟加载（Lazy Loading）是一种加载数据的策略，它只在真正需要数据时才进行加载，从而有助于提高系统性能和减少资源消耗。在MyBatis中，延迟加载的实现原理如下：

1. 配置延迟加载：在MyBatis的配置文件或映射文件中，需要设置lazyLoadingEnabled=true来开启延迟加载功能。
2. 生成代理对象：当主对象（如一个实体对象）被查询时，MyBatis会生成一个代理对象。这个代理对象包含了对关联对象的引用，但并不会立即加载关联对象的数据。
3. 触发时机：当应用程序需要访问代理对象中的关联属性时，延迟加载机制会被触发。此时，MyBatis会创建一个新的SQL语句来查询关联对象的数据。
4. 填充数据：查询完成后，MyBatis会将查询到的数据填充到代理对象中，使得关联属性变得可用。

MyBatis的延迟加载主要有两种类型：

• 全局延迟加载（全局懒加载）：在MyBatis的配置文件中配置开启全局延迟加载。这样，对于所有的关联关系，都会按照配置进行延迟加载。
• 按需延迟加载（按需懒加载）：在映射文件中使用fetchType属性设置按需延迟加载。这样，只有在需要的时候才会进行延迟加载。

通过配置全局延迟加载或按需延迟加载，可以根据实际业务需求灵活地使用延迟加载功能，从而提高系统性能。

13. 说说Mybatis的缓存机制