MyBatis：简化Java数据库操作的利器

ღ᭄ꦿ࿐Never say never꧂

于 2024-08-27 10:22:15 发布

阅读量404

点赞数 11

文章标签： mybatis java 数据库

本文链接：https://blog.csdn.net/weixin_52007179/article/details/141596038

版权

大家好！今天我们来聊聊MyBatis，这个Java世界中备受欢迎的持久层框架。详情参考👉深入浅出MyBatis

1. 什么是MyBatis？

MyBatis是一个半自动化的ORM（对象关系映射）框架。它的特别之处在于，它让你能够直接控制SQL，同时又能享受到ORM框架带来的便利。

想象一下，你有一个简单的User类：

public class User {
    private int id;
    private String username;
    private String email;
    // getters and setters
}

使用MyBatis，你可以轻松地将这个类映射到数据库：

<mapper namespace="com.example.UserMapper">
  <select id="getUser" resultType="com.example.User">
    SELECT id, username, email FROM users WHERE id = #{id}
  </select>
</mapper>

是不是很直观？这就是MyBatis的魅力所在！

2. 为什么选择MyBatis？

既然有了JDBC，为什么还需要MyBatis呢？

2.1 JDBC连接流程

JDBC（Java Database Connectivity）是Java语言中用于执行SQL语句的标准API。以下是JDBC的典型连接和使用流程：

加载驱动程序：
```
Class.forName("com.mysql.jdbc.Driver");
```

建立数据库连接：

String url = "jdbc:mysql://localhost:3306/mydb";
String user = "username";
String password = "password";
Connection conn = DriverManager.getConnection(url, user, password);

创建Statement对象：

Statement stmt = conn.createStatement();

执行SQL语句：

ResultSet rs = stmt.executeQuery("SELECT * FROM users");

处理结果集：

while (rs.next()) {
    String name = rs.getString("name");
    System.out.println(name);
}

关闭连接：
```
rs.close();
stmt.close();
conn.close();
```

MyBatis在内部仍然使用JDBC来与数据库交互，但它通过抽象和封装，极大地简化了这个过程。例如，MyBatis自动处理了连接的创建和关闭，参数的设置，结果集的处理等，使得开发者可以专注于SQL的编写和业务逻辑的实现。

2.2 MyBatis VS JDBC

使用JDBC查询用户：

try (Connection conn = DriverManager.getConnection(url, user, password);
     PreparedStatement ps = conn.prepareStatement("SELECT * FROM users WHERE id = ?")) {
  ps.setInt(1, 1);
  try (ResultSet rs = ps.executeQuery()) {
    if (rs.next()) {
      System.out.println(rs.getString("username"));
    }
  }
}

使用MyBatis实现同样的功能：

try (SqlSession session = sqlSessionFactory.openSession()) {
  UserMapper mapper = session.getMapper(UserMapper.class);
  User user = mapper.getUser(1);
  System.out.println(user.getUsername());
}

sqlSessionFactory.openSession() 创建并返回一个新的 SqlSession 对象。SqlSession 是MyBatis工作的核心接口，用于执行SQL命令。
session.getMapper(UserMapper.class) 告诉MyBatis为UserMapper接口创建一个代理对象。这个代理对象会将接口方法调用转换为相应的SQL操作。
调用UserMapper接口的getUser方法，传入参数1（可能是用户ID）。

虽然我们没有实现这个方法，但MyBatis会根据配置文件中的SQL映射来执行相应的数据库查询。

查询结果会被自动映射成User对象。

3. MyBatis的亮点特性

动态SQL：再也不用手动拼接SQL字符串了！

<select id="findUsers" resultType="com.example.User">
  SELECT * FROM users
  <where>
    <if test="username != null">
      AND username LIKE #{username}
    </if>
    <if test="email != null">
      AND email = #{email}
    </if>
  </where>
</select>

强大的结果映射
缓存支持：一级缓存、二级缓存，性能优化不用愁。
插件机制：想要更多功能？自己动手，丰衣足食！

3.1 MyBatis的缓存机制

MyBatis提供了强大的缓存特性，主要分为一级缓存和二级缓存。

3.1.1 一级缓存

一级缓存是SqlSession级别的缓存，也称为本地缓存。

工作原理：

当我们使用SqlSession第一次查询数据时，MyBatis会将其放入到SqlSession的一级缓存中。
如果后续有相同的查询，MyBatis会直接从缓存中返回结果，而不再执行SQL。
如果SqlSession执行了insert、update、delete操作，或者调用了clearCache()、commit()、close()方法，一级缓存将被清空。

示例代码：

try (SqlSession session = sqlSessionFactory.openSession()) {
  UserMapper mapper = session.getMapper(UserMapper.class);
  User user1 = mapper.getUser(1);  // 执行SQL查询
  User user2 = mapper.getUser(1);  // 直接从一级缓存获取，不执行SQL
  assert user1 == user2;  // true，返回的是同一个对象
}

3.1.2 二级缓存

二级缓存是mapper级别的缓存，可以被多个SqlSession共享。

工作原理：

二级缓存需要在配置文件中显式开启。
当一个SqlSession关闭时，其一级缓存中的数据会被保存到二级缓存中。
新的SqlSession查询数据时，会先从二级缓存中查找。

配置示例：

<cache
  eviction="LRU"
  flushInterval="60000"
  size="512"
  readOnly="true"/>

这里的配置参数解释如下：

eviction：缓存的淘汰算法，LRU表示最近最少使用。
flushInterval：刷新间隔，单位为毫秒。
size：缓存存储上限。
readOnly：是否只读，如果为false，则会返回缓存对象的拷贝。

3.2 MyBatis插件机制详解

想象MyBatis是一个复杂的机器，而插件就像是可以安装在这个机器上的额外部件，用来增强或改变机器的某些功能。

3.2.1 插件的工作原理

动态代理：MyBatis使用Java的动态代理技术。可以把它想象成一个"替身演员"，这个"替身"可以在原本的方法执行前后做一些额外的事情。
拦截调用：插件就像是在方法执行路径上设置的"检查站"。每当有方法被调用时，都会经过这些"检查站"。
插件链：可以设置多个插件，它们会像流水线一样依次处理。

3.2.2 插件的实现步骤

实现Interceptor接口：这就像是定义了一个标准的插件模板。
使用@Intercepts注解：这相当于告诉MyBatis，"嘿，我要监视这个特定的方法"。
在配置文件中注册：让MyBatis知道要使用这个插件。

3.2.3 示例解析

@Intercepts({@Signature(
  type= Executor.class,
  method = "update",
  args = {MappedStatement.class,Object.class})})
public class ExamplePlugin implements Interceptor {
  public Object intercept(Invocation invocation) throws Throwable {
    // 在这里实现你的拦截逻辑
    return invocation.proceed();
  }
  public Object plugin(Object target) {
    return Plugin.wrap(target, this);
  }
  public void setProperties(Properties properties) {
  }
}

@Intercepts注解：指定要拦截的方法。这里拦截的是Executor接口的update方法。
intercept方法：这里是插件的主要逻辑。你可以在这里添加、修改或记录一些信息。
plugin方法：将目标对象包装成代理对象。
setProperties方法：可以在这里设置插件的属性。

3.2.4 使用场景

3.2.4.1 性能监控：

例如，你可以创建一个插件来记录每个SQL语句的执行时间。

public Object intercept(Invocation invocation) throws Throwable {
  long start = System.currentTimeMillis();
  Object result = invocation.proceed();
  long end = System.currentTimeMillis();
  System.out.println("SQL执行时间：" + (end - start) + "ms");
  return result;
}

3.2.4.2 审计日志：

记录谁在什么时候执行了什么操作。

public Object intercept(Invocation invocation) throws Throwable {
  String methodName = invocation.getMethod().getName();
  String userName = getCurrentUser(); // 假设有这么一个方法
  System.out.println(userName + " 执行了 " + methodName + " 操作");
  return invocation.proceed();
}

3.2.4.3 动态改变SQL：

根据某些条件动态修改SQL语句。

public Object intercept(Invocation invocation) throws Throwable {
  if (invocation.getTarget() instanceof StatementHandler) {
    StatementHandler statementHandler = (StatementHandler) invocation.getTarget();
    MetaObject metaObject = SystemMetaObject.forObject(statementHandler);
    String sql = (String) metaObject.getValue("delegate.boundSql.sql");
    sql = sql + " LIMIT 100"; // 为所有查询添加限制
    metaObject.setValue("delegate.boundSql.sql", sql);
  }
  return invocation.proceed();
}

3.2.4.4 数据加密解密：

在插入数据前加密，查询数据后解密。

3.2.4.5 分页：

许多MyBatis的分页插件就是通过拦截器实现的。

MyBatis的插件机制提供了一种强大的方式来扩展和定制MyBatis的行为。通过插件，你可以在不修改MyBatis核心代码的情况下，增加新的功能或修改现有的行为。这对于实现一些横切关注点（如日志、性能监控、安全控制等）特别有用。

4. MyBatis工作原理深入解析

想象MyBatis是一个精心设计的工厂，专门负责处理我们的数据库操作请求。让我们来看看这个"工厂"是如何运作的：

4.1 蓝图设计（配置阶段）

首先，我们需要为这个工厂制定一份详细的蓝图。这份蓝图就是MyBatis的配置文件，里面包含了数据库连接信息、SQL映射文件位置等重要信息。

<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/mydb"/>
        <property name="username" value="root"/>
        <property name="password" value="password"/>
      </dataSource>
    </environment>
  </environments>
  <mappers>
    <mapper resource="*.xml"/>
  </mappers>
</configuration>

4.2 工厂建设（SqlSessionFactory创建）

根据蓝图，我们建立了一个SqlSessionFactory。这就像是我们的主工厂，负责生产能够执行SQL的SqlSession。

String resource = "mybatis-config.xml";
InputStream inputStream = Resources.getResourceAsStream(resource);
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);

4.3 工人报到（SqlSession创建）

当我们需要执行数据库操作时，就从工厂里叫一个"工人"出来。这个工人就是SqlSession，它知道如何执行SQL语句。

SqlSession session = sqlSessionFactory.openSession();

4.4 接受订单（SQL语句准备）

工人（SqlSession）接收到我们的"订单"（SQL操作请求）。这个订单可能是查询、更新、插入或删除操作。

User user = session.selectOne("com.example.UserMapper.getUser", 1);

4.5 订单处理（SQL执行）

工人不是单打独斗，而是有一系列的"专家"来协助处理订单：

Executor：总指挥，负责整个SQL执行过程
StatementHandler：负责准备和执行SQL语句
ParameterHandler：负责设置参数
ResultSetHandler：负责处理结果集

这些"专家"协同工作，确保SQL被正确执行，结果被正确处理。

4.6 订单完成（结果返回）

处理完成后，工人（SqlSession）将结果返回给我们。如果是查询操作，结果会被自动映射成Java对象。

4.7 工作结束（关闭SqlSession）

当所有工作完成后，我们需要让工人（SqlSession）回到工厂休息。

session.close();

整个过程中，MyBatis为我们处理了很多复杂的细节：

自动开启和关闭数据库连接
将参数转换成SQL语句中的参数
处理结果集，将数据库返回的结果转换成Java对象
处理事务

这就是为什么使用MyBatis能让我们的代码变得更加简洁和易于维护。我们只需要关注业务逻辑，而不用处理繁琐的JDBC细节。

通过这种方式，MyBatis在幕后为我们完成了从Java对象到数据库操作的全过程，大大简化了我们的开发工作。

MyBatis面试常见问题

1. MyBatis中#{}和${}的区别是什么？

答：这是一个非常常见的问题！

#{} 是预编译处理，MyBatis会将SQL中的#{}替换为?号，调用PreparedStatement的set方法来赋值。
${} 是字符串替换，MyBatis直接将{}替换成变量的值。
使用#{}可以有效的防止SQL注入，提高系统安全性。

2. MyBatis的一级缓存和二级缓存的区别？

答：缓存是性能优化的重要手段，MyBatis提供了两级缓存：

一级缓存：SqlSession级别的缓存，默认开启。
二级缓存：Mapper级别的缓存，需要手动配置。主要区别在于作用域和生命周期。一级缓存随SqlSession的创建和关闭而生存，二级缓存可以跨SqlSession存在。

3. MyBatis如何实现延迟加载？

答：MyBatis通过动态代理机制实现延迟加载。当启用延迟加载时，MyBatis并不会立即加载关联对象，而是创建一个代理对象。只有当真正使用到该对象时，才会触发SQL查询。这可以通过配置lazyLoadingEnabled和aggressiveLazyLoading来控制。

4. MyBatis如何进行分页？

答：MyBatis提供了几种分页方式：

使用RowBounds对象进行内存分页
在SQL语句中使用LIMIT进行物理分页
使用分页插件，如PageHelper

在实际项目中，我们通常会选择使用分页插件或在SQL中直接使用LIMIT，因为它们的性能更好。

5. 什么是MyBatis的动态SQL？能举个例子吗？

答：动态SQL是MyBatis的强大特性之一，它允许我们根据不同条件生成不同的SQL语句。例如：

<select id="findActiveBlogWithTitleLike" resultType="Blog">
  SELECT * FROM BLOG 
  WHERE state = 'ACTIVE' 
  <if test="title != null">
    AND title like #{title}
  </if>
</select>

这个例子中，只有当title不为null时，才会添加title的查询条件。

ღ᭄ꦿ࿐Never say never꧂

关注

11
点赞
踩
12

收藏

觉得还不错? 一键收藏
0
评论
MyBatis：简化Java数据库操作的利器

MyBatis是一个半自动化的ORM（对象关系映射）框架。它的特别之处在于，它让你能够直接控制SQL，同时又能享受到ORM框架带来的便利。想象一下，你有一个简单的User类：使用MyBatis，你可以轻松地将这个类映射到数据库：</select></mapper>是不是很直观？这就是MyBatis的魅力所在！
复制链接

扫一扫