AI 助理
文档备案控制台
开发者社区 数据库 文章 正文

深入拆解 MyBatis：Mapper 动态代理、一级与二级缓存的底层实现与实战

2026-03-05 353
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 本文深入解析MyBatis三大核心机制：1）Mapper接口通过动态代理实现SQL执行，核心类包括MapperProxy和MapperMethod；2）一级缓存是SqlSession级别的内存缓存，默认开启且基于HashMap实现；3）二级缓存是Mapper级别的可共享缓存，需手动开启且要求实体类实现Serializable。通过代码示例详细演示了缓存的生效条件和失效场景，并对比了一二级缓存的关键差异，帮助开发者深入理解MyBatis底层原理，在实际开发中合理运用缓存机制。

引言

MyBatis作为国内最流行的持久层框架之一，其核心设计精巧且实用。本文将从底层原理出发，结合实战代码，深入拆解MyBatis中最核心的三个机制：Mapper接口的动态代理实现、一级缓存的生效机制以及二级缓存的生效机制。通过本文，你将不仅知其然，更知其所以然，能够在实际开发中灵活运用这些机制解决问题。

一、Mapper接口的动态代理实现

1.1 动态代理的核心概念

在MyBatis中，我们只需要编写Mapper接口，不需要编写实现类，就能直接调用接口方法执行SQL。这背后的核心原理就是JDK动态代理。MyBatis会在运行时为Mapper接口生成一个动态代理对象，当我们调用接口方法时，实际上是调用代理对象的invoke方法，在该方法中完成SQL的解析、参数绑定、执行和结果映射。

1.2 MyBatis动态代理的执行流程

1.3 核心类解析

1.3.1 MapperProxy

MapperProxy是动态代理的核心类，实现了InvocationHandler接口。它持有SqlSession、Mapper接口和方法缓存三个核心对象。当调用代理对象的方法时，会进入invoke方法，该方法会判断是否为Object类的方法（如toString、hashCode），如果是则直接执行；否则会从缓存中获取MapperMethod对象并执行。

1.3.2 MapperMethod

MapperMethod封装了Mapper接口方法的完整信息，包括方法名、参数类型、返回值类型、SQL语句类型等。它的execute方法是SQL执行的入口，会根据SQL类型（SELECT/INSERT/UPDATE/DELETE）调用SqlSession的对应方法完成数据库操作。

1.3.3 MapperProxyFactory

MapperProxyFactory是Mapper代理对象的工厂类，负责创建MapperProxy实例并生成动态代理对象。每个Mapper接口对应一个MapperProxyFactory实例。

1.4 实战示例：从接口调用到SQL执行

1.4.1 项目环境搭建

首先创建一个Maven项目，pom.xml配置如下：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
   <modelVersion>4.0.0</modelVersion>
   <parent>
       <groupId>org.springframework.boot</groupId>
       <artifactId>spring-boot-starter-parent</artifactId>
       <version>3.2.3</version>
       <relativePath/>
   </parent>
   <groupId>com.jam</groupId>
   <artifactId>mybatis-demo</artifactId>
   <version>1.0.0</version>
   <name>mybatis-demo</name>
   <description>MyBatis核心机制实战演示</description>
   <properties>
       <java.version>17</java.version>
       <mybatis-plus.version>3.5.5</mybatis-plus.version>
       <fastjson2.version>2.0.43</fastjson2.version>
       <swagger.version>2.3.0</swagger.version>
       <guava.version>33.0.0-jre</guava.version>
   </properties>
   <dependencies>
       <dependency>
           <groupId>org.springframework.boot</groupId>
           <artifactId>spring-boot-starter-web</artifactId>
       </dependency>
       <dependency>
           <groupId>com.baomidou</groupId>
           <artifactId>mybatis-plus-boot-starter</artifactId>
           <version>${mybatis-plus.version}</version>
       </dependency>
       <dependency>
           <groupId>com.baomidou</groupId>
           <artifactId>mybatis-plus-generator</artifactId>
           <version>${mybatis-plus.version}</version>
       </dependency>
       <dependency>
           <groupId>mysql</groupId>
           <artifactId>mysql-connector-java</artifactId>
           <version>8.0.33</version>
       </dependency>
       <dependency>
           <groupId>org.projectlombok</groupId>
           <artifactId>lombok</artifactId>
           <version>1.18.30</version>
           <scope>provided</scope>
       </dependency>
       <dependency>
           <groupId>com.alibaba.fastjson2</groupId>
           <artifactId>fastjson2</artifactId>
           <version>${fastjson2.version}</version>
       </dependency>
       <dependency>
           <groupId>com.google.guava</groupId>
           <artifactId>guava</artifactId>
           <version>${guava.version}</version>
       </dependency>
       <dependency>
           <groupId>org.springdoc</groupId>
           <artifactId>springdoc-openapi-starter-webmvc-ui</artifactId>
           <version>${swagger.version}</version>
       </dependency>
       <dependency>
           <groupId>org.springframework.boot</groupId>
           <artifactId>spring-boot-starter-test</artifactId>
           <scope>test</scope>
       </dependency>
   </dependencies>
   <build>
       <plugins>
           <plugin>
               <groupId>org.springframework.boot</groupId>
               <artifactId>spring-boot-maven-plugin</artifactId>
               <configuration>
                   <excludes>
                       <exclude>
                           <groupId>org.projectlombok</groupId>
                           <artifactId>lombok</artifactId>
                       </exclude>
                   </excludes>
               </configuration>
           </plugin>
       </plugins>
   </build>
</project>

application.yml配置如下：

spring:
 datasource:
   driver-class-name: com.mysql.cj.jdbc.Driver
   url: jdbc:mysql://localhost:3306/mybatis_demo?useUnicode=true&characterEncoding=utf-8&serverTimezone=Asia/Shanghai&useSSL=false
   username: root
   password: root
mybatis-plus:
 configuration:
   log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
   cache-enabled: true
 global-config:
   db-config:
     id-type: auto

SQL脚本如下：

CREATE DATABASE IF NOT EXISTS mybatis_demo DEFAULT CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci;
USE mybatis_demo;
CREATE TABLE IF NOT EXISTS `user` (
   `id` BIGINT NOT NULL AUTO_INCREMENT COMMENT '主键ID',
   `username` VARCHAR(50) NOT NULL COMMENT '用户名',
   `password` VARCHAR(100) NOT NULL COMMENT '密码',
   `email` VARCHAR(100) DEFAULT NULL COMMENT '邮箱',
   `create_time` DATETIME DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
   `update_time` DATETIME DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
   PRIMARY KEY (`id`),
   UNIQUE KEY `uk_username` (`username`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='用户表';
INSERT INTO `user` (`username`, `password`, `email`) VALUES
('zhangsan', '123456', 'zhangsan@example.com'),
('lisi', '123456', 'lisi@example.com'),
('wangwu', '123456', 'wangwu@example.com');

1.4.2 核心代码实现

实体类User.java：

package com.jam.demo.entity;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
import java.io.Serializable;
import java.time.LocalDateTime;
/**
* 用户实体类
* @author ken
*/
@Data
@TableName("user")
@Schema(description = "用户实体")
public class User implements Serializable {
   private static final long serialVersionUID = 1L;
   /**
    * 主键ID
    */
   @TableId(type = IdType.AUTO)
   @Schema(description = "主键ID")
   private Long id;
   /**
    * 用户名
    */
   @Schema(description = "用户名")
   private String username;
   /**
    * 密码
    */
   @Schema(description = "密码")
   private String password;
   /**
    * 邮箱
    */
   @Schema(description = "邮箱")
   private String email;
   /**
    * 创建时间
    */
   @Schema(description = "创建时间")
   private LocalDateTime createTime;
   /**
    * 更新时间
    */
   @Schema(description = "更新时间")
   private LocalDateTime updateTime;
}

Mapper接口UserMapper.java：

package com.jam.demo.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.jam.demo.entity.User;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Select;
/**
* 用户Mapper接口
* @author ken
*/
@Mapper
public interface UserMapper extends BaseMapper<User> {
   /**
    * 根据用户名查询用户
    * @param username 用户名
    * @return 用户信息
    */
   @Select("SELECT * FROM user WHERE username = #{username}")
   User selectByUsername(@Param("username") String username);
}

测试类MybatisProxyTest.java：

package com.jam.demo;
import com.jam.demo.entity.User;
import com.jam.demo.mapper.UserMapper;
import lombok.extern.slf4j.Slf4j;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
/**
* MyBatis动态代理测试类
* @author ken
*/
@Slf4j
@SpringBootTest
public class MybatisProxyTest {
   @Autowired
   private SqlSessionFactory sqlSessionFactory;
   /**
    * 测试Mapper动态代理
    */
   @Test
   public void testMapperProxy() {
       try (SqlSession sqlSession = sqlSessionFactory.openSession()) {
           UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
           log.info("Mapper代理对象类型：{}", userMapper.getClass().getName());
           log.info("Mapper代理对象是否为Proxy：{}", java.lang.reflect.Proxy.isProxyClass(userMapper.getClass()));
           User user = userMapper.selectByUsername("zhangsan");
           log.info("查询结果：{}", user);
       }
   }
}

运行测试类，你会看到如下关键日志：

Mapper代理对象类型：com.sun.proxy.$Proxy87
Mapper代理对象是否为Proxy：true

这证明了UserMapper的实例确实是JDK动态代理生成的对象。

二、一级缓存的生效机制

2.1 一级缓存的定义与范围

一级缓存是SqlSession级别的缓存，默认开启且无法关闭（只能调整缓存范围）。它的作用范围是同一个SqlSession实例，当同一个SqlSession执行相同的SQL查询时，会直接从缓存中获取结果，而不会再次查询数据库。

2.2 一级缓存的执行流程

2.3 一级缓存的底层实现

一级缓存的底层实现类是PerpetualCache，它内部使用一个HashMap来存储缓存数据，key是CacheKey对象（由SQL语句、参数、分页信息等组成），value是查询结果。

2.4 实战示例：一级缓存的生效与失效场景

测试类FirstLevelCacheTest.java：

package com.jam.demo;
import com.jam.demo.entity.User;
import com.jam.demo.mapper.UserMapper;
import lombok.extern.slf4j.Slf4j;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.transaction.support.TransactionTemplate;
/**
* 一级缓存测试类
* @author ken
*/
@Slf4j
@SpringBootTest
public class FirstLevelCacheTest {
   @Autowired
   private SqlSessionFactory sqlSessionFactory;
   @Autowired
   private TransactionTemplate transactionTemplate;
   @Autowired
   private UserMapper userMapper;
   /**
    * 测试一级缓存生效：同一个SqlSession，相同查询
    */
   @Test
   public void testFirstLevelCacheHit() {
       try (SqlSession sqlSession = sqlSessionFactory.openSession()) {
           UserMapper mapper = sqlSession.getMapper(UserMapper.class);
           log.info("第一次查询...");
           User user1 = mapper.selectById(1L);
           log.info("第一次查询结果：{}", user1);
           log.info("第二次查询...");
           User user2 = mapper.selectById(1L);
           log.info("第二次查询结果：{}", user2);
           log.info("两次查询结果是否为同一对象：{}", user1 == user2);
       }
   }
   /**
    * 测试一级缓存失效：不同SqlSession
    */
   @Test
   public void testFirstLevelCacheMissDifferentSession() {
       try (SqlSession sqlSession1 = sqlSessionFactory.openSession();
            SqlSession sqlSession2 = sqlSessionFactory.openSession()) {
           UserMapper mapper1 = sqlSession1.getMapper(UserMapper.class);
           UserMapper mapper2 = sqlSession2.getMapper(UserMapper.class);
           log.info("SqlSession1查询...");
           User user1 = mapper1.selectById(1L);
           log.info("SqlSession1查询结果：{}", user1);
           log.info("SqlSession2查询...");
           User user2 = mapper2.selectById(1L);
           log.info("SqlSession2查询结果：{}", user2);
           log.info("两次查询结果是否为同一对象：{}", user1 == user2);
       }
   }
   /**
    * 测试一级缓存失效：执行增删改操作
    */
   @Test
   public void testFirstLevelCacheMissAfterUpdate() {
       try (SqlSession sqlSession = sqlSessionFactory.openSession()) {
           UserMapper mapper = sqlSession.getMapper(UserMapper.class);
           log.info("第一次查询...");
           User user1 = mapper.selectById(1L);
           log.info("第一次查询结果：{}", user1);
           log.info("执行更新操作...");
           User updateUser = new User();
           updateUser.setId(1L);
           updateUser.setEmail("new_email@example.com");
           mapper.updateById(updateUser);
           sqlSession.commit();
           log.info("第二次查询...");
           User user2 = mapper.selectById(1L);
           log.info("第二次查询结果：{}", user2);
           log.info("两次查询结果是否为同一对象：{}", user1 == user2);
       }
   }
   /**
    * 测试一级缓存失效：手动清空缓存
    */
   @Test
   public void testFirstLevelCacheMissAfterClear() {
       try (SqlSession sqlSession = sqlSessionFactory.openSession()) {
           UserMapper mapper = sqlSession.getMapper(UserMapper.class);
           log.info("第一次查询...");
           User user1 = mapper.selectById(1L);
           log.info("第一次查询结果：{}", user1);
           log.info("手动清空一级缓存...");
           sqlSession.clearCache();
           log.info("第二次查询...");
           User user2 = mapper.selectById(1L);
           log.info("第二次查询结果：{}", user2);
           log.info("两次查询结果是否为同一对象：{}", user1 == user2);
       }
   }
}

运行测试类，你会发现：

  1. 同一个SqlSession执行相同查询时，只执行一次SQL，第二次直接从缓存获取，且两次结果是同一对象。
  2. 不同SqlSession、执行增删改操作、手动清空缓存都会导致一级缓存失效。

三、二级缓存的生效机制

3.1 二级缓存的定义与范围

二级缓存是Mapper级别的缓存，默认关闭，需要手动开启。它的作用范围是同一个Mapper接口的namespace，不同的SqlSession可以共享二级缓存。

3.2 二级缓存的配置与开启

3.2.1 全局配置

在application.yml中开启二级缓存：

mybatis-plus:
 configuration:
   cache-enabled: true

3.2.2 Mapper配置

在Mapper接口上添加@CacheNamespace注解：

package com.jam.demo.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.jam.demo.entity.User;
import org.apache.ibatis.annotations.CacheNamespace;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Select;
/**
* 用户Mapper接口
* @author ken
*/
@Mapper
@CacheNamespace
public interface UserMapper extends BaseMapper<User> {
   /**
    * 根据用户名查询用户
    * @param username 用户名
    * @return 用户信息
    */
   @Select("SELECT * FROM user WHERE username = #{username}")
   User selectByUsername(@Param("username") String username);
}

注意：实体类必须实现Serializable接口，因为二级缓存可能会将数据序列化到磁盘或网络传输。

3.3 二级缓存的执行流程

3.4 二级缓存的事务管理

二级缓存的一个重要特点是：只有当SqlSession提交或关闭时，查询结果才会被写入二级缓存。这是为了避免脏读，确保只有提交后的数据才会被缓存。

3.5 实战示例：二级缓存的生效与失效场景

测试类SecondLevelCacheTest.java：

package com.jam.demo;
import com.jam.demo.entity.User;
import com.jam.demo.mapper.UserMapper;
import lombok.extern.slf4j.Slf4j;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
/**
* 二级缓存测试类
* @author ken
*/
@Slf4j
@SpringBootTest
public class SecondLevelCacheTest {
   @Autowired
   private SqlSessionFactory sqlSessionFactory;
   /**
    * 测试二级缓存生效：不同SqlSession，相同查询，SqlSession提交
    */
   @Test
   public void testSecondLevelCacheHit() {
       try (SqlSession sqlSession1 = sqlSessionFactory.openSession();
            SqlSession sqlSession2 = sqlSessionFactory.openSession()) {
           UserMapper mapper1 = sqlSession1.getMapper(UserMapper.class);
           UserMapper mapper2 = sqlSession2.getMapper(UserMapper.class);
           log.info("SqlSession1查询...");
           User user1 = mapper1.selectById(1L);
           log.info("SqlSession1查询结果：{}", user1);
           log.info("SqlSession1提交...");
           sqlSession1.commit();
           log.info("SqlSession2查询...");
           User user2 = mapper2.selectById(1L);
           log.info("SqlSession2查询结果：{}", user2);
           log.info("两次查询结果是否为同一对象：{}", user1 == user2);
           log.info("两次查询结果内容是否相同：{}", user1.equals(user2));
       }
   }
   /**
    * 测试二级缓存失效：SqlSession未提交
    */
   @Test
   public void testSecondLevelCacheMissWithoutCommit() {
       try (SqlSession sqlSession1 = sqlSessionFactory.openSession();
            SqlSession sqlSession2 = sqlSessionFactory.openSession()) {
           UserMapper mapper1 = sqlSession1.getMapper(UserMapper.class);
           UserMapper mapper2 = sqlSession2.getMapper(UserMapper.class);
           log.info("SqlSession1查询...");
           User user1 = mapper1.selectById(1L);
           log.info("SqlSession1查询结果：{}", user1);
           log.info("SqlSession2查询...");
           User user2 = mapper2.selectById(1L);
           log.info("SqlSession2查询结果：{}", user2);
           log.info("两次查询结果是否为同一对象：{}", user1 == user2);
       }
   }
   /**
    * 测试二级缓存失效：执行增删改操作
    */
   @Test
   public void testSecondLevelCacheMissAfterUpdate() {
       try (SqlSession sqlSession1 = sqlSessionFactory.openSession();
            SqlSession sqlSession2 = sqlSessionFactory.openSession();
            SqlSession sqlSession3 = sqlSessionFactory.openSession()) {
           UserMapper mapper1 = sqlSession1.getMapper(UserMapper.class);
           UserMapper mapper2 = sqlSession2.getMapper(UserMapper.class);
           UserMapper mapper3 = sqlSession3.getMapper(UserMapper.class);
           log.info("SqlSession1查询并提交...");
           User user1 = mapper1.selectById(1L);
           sqlSession1.commit();
           log.info("SqlSession1查询结果：{}", user1);
           log.info("SqlSession2执行更新操作并提交...");
           User updateUser = new User();
           updateUser.setId(1L);
           updateUser.setEmail("second_level_cache@example.com");
           mapper2.updateById(updateUser);
           sqlSession2.commit();
           log.info("SqlSession3查询...");
           User user3 = mapper3.selectById(1L);
           log.info("SqlSession3查询结果：{}", user3);
       }
   }
}

运行测试类，你会发现：

  1. 当第一个SqlSession提交后，第二个SqlSession执行相同查询时，会直接从二级缓存获取结果（注意：两次结果不是同一对象，因为二级缓存会反序列化对象）。
  2. SqlSession未提交、执行增删改操作都会导致二级缓存失效。

四、易混淆点深度对比

4.1 一级缓存vs二级缓存：核心差异一览

对比项 一级缓存 二级缓存
作用范围 SqlSession级别 Mapper namespace级别
默认状态 默认开启 默认关闭
开启方式 无需配置 全局配置+Mapper注解
存储介质 内存（HashMap） 内存（可扩展至磁盘）
失效场景 不同SqlSession、增删改、手动清空 增删改、缓存超时、内存不足
事务要求 无 需SqlSession提交/关闭才写入
序列化要求 无 实体类需实现Serializable

4.2 缓存失效的常见场景总结

  1. 一级缓存失效：
  • 使用不同的SqlSession
  • 执行增删改操作（即使操作的是不同表）
  • 手动调用sqlSession.clearCache()
  • 查询条件不同
  1. 二级缓存失效：
  • 执行增删改操作
  • SqlSession未提交或关闭
  • 缓存超时
  • 内存不足触发LRU策略
  • 查询条件不同

结语

本文深入拆解了MyBatis的三个核心机制：Mapper动态代理、一级缓存和二级缓存。通过底层原理分析、流程图展示和实战代码示例，我们不仅理解了这些机制的工作原理，更掌握了它们在实际开发中的使用方法和注意事项。在实际项目中，我们应该根据业务场景合理使用缓存，避免缓存带来的脏读问题，同时也要注意缓存的性能优化。希望本文能对你有所帮助，让你在MyBatis的使用上更加得心应手。

文章标签：
Java
缓存
数据库连接
mybatis
SQL
浅浅33
目录
相关文章
nick7259836553-25887
|
8月前
|
Java Shell 测试技术
Jmeter快速入门
本文介绍JMeter的安装与快速入门，包括下载、解压、运行步骤，以及中文语言设置和基本使用方法，帮助用户快速上手性能测试工具JMeter。
nick7259836553-25887
324 1
小鲸云
|
5月前
|
人工智能 自然语言处理 安全
“养龙虾玩Skill”指南！OpenClaw（Clawdbot）阿里云/本地部署+新手3种 Skill 挖掘AI工具核心价值
OpenClaw（昵称“龙虾”）的爆火，让“养龙虾玩Skill”成了2026年的新潮流——有人用它自动化处理工作，有人靠定制部署服务变现，甚至闲鱼上500元一次的上门部署生意都应运而生。但多数新手入手后，只停留在基础对话层面，殊不知OpenClaw的核心价值藏在Skill生态中——这些可执行的“能力单元”，就像一个个专属机器人，能将自然语言指令转化为实际操作，从文档处理到硬件控制，覆盖全场景需求。
小鲸云
3582 5
c的前世今生
|
5月前
|
网络协议 编译器 C语言
C语言深度解析：内存对齐与结构体填充的底层逻辑
C语言中，内存对齐是CPU硬件强制要求的底层规则，直接影响结构体大小、访问性能与硬件兼容性。合理排列成员可减少填充、节省内存；滥用`#pragma pack`则易致崩溃或性能暴跌。嵌入式、网络协议与跨平台开发必备核心知识。（239字）
c的前世今生
576 14
阿里云云原生
|
10月前
|
人工智能 监控 Java
零代码改造 + 全链路追踪！Spring AI 最新可观测性详细解读
Spring AI Alibaba 通过集成 OpenTelemetry 实现可观测性，支持框架原生和无侵入探针两种方式。原生方案依赖 Micrometer 自动埋点，适用于快速接入；无侵入探针基于 LoongSuite 商业版，无需修改代码即可采集标准 OTLP 数据，解决了原生方案扩展性差、调用链易断链等问题。未来将开源无侵入探针方案，整合至 AgentScope Studio，并进一步增强多 Agent 场景下的观测能力。
阿里云云原生
3297 101
Deephub
|
6月前
|
存储 安全 测试技术
并行多智能体系统的协调测试实战：从轨迹捕获到CI/CD的六个步骤
本文探讨并行多智能体系统的协调测试难题：当多个LLM驱动的智能体协同决策时，单个正确≠集体安全。传统单元测试失效，需构建以轨迹捕获、行为不变量、回放回归、黄金数据集和CI/CD集成为核心的新型测试框架，专治容量超限、状态陈旧、 reducer 冲突等典型协调故障。
Deephub
287 2
并行多智能体系统的协调测试实战：从轨迹捕获到CI/CD的六个步骤
游客xp6ru7c63sdiu
|
5月前
|
传感器 机器人 Linux
嵌入式开发新手入门教程（第一卷）
教程来源 https://app-a6nw7st4g741.appmiaoda.com/ 嵌入式系统是嵌入设备内部的专用计算机系统，广泛应用于智能手表、汽车电控、医疗设备乃至火星车等。其由硬件（MCU、存储器、外设）和软件（裸机/RTOS/嵌入式Linux）构成。新手可按电路与C语言→单片机开发→RTOS与ARM深入三阶段学习，推荐STM32平台入门。
游客xp6ru7c63sdiu
1105 1
霍格沃兹测试开发学社
|
5月前
|
人工智能 JSON 测试技术
还在手动造数据？Faker+LLM，模拟真实业务场景的N种姿势
本文分享团队用Faker+LLM组合生成真实测试数据的实战经验：Faker高效产出海量基础数据，LLM补足业务逻辑与语义真实性。覆盖单元测试、演示环境、全链路压测及AI训练等场景，兼顾效率、质量与合规性。
霍格沃兹测试开发学社
495 1
OpenClaw
|
5月前
|
人工智能 Linux API
两步搞定OpenClaw部署：阿里云7×24小时在线AI助手实操+API配置及常见问题解答
OpenClaw（曾用名Clawdbot）作为2026年开源AI智能助手领域的核心工具，凭借轻量化部署、高扩展性与多场景适配能力，成为个人与轻量团队实现任务自动化的首选。其核心优势在于可通过极简步骤完成阿里云云端部署，实现7×24小时不间断运行，同时支持本地MacOS、Linux、Windows11多系统部署，灵活对接阿里云千问大模型或市场免费大模型Coding Plan API，无需复杂编程基础，零基础用户也能快速搭建专属在线AI助手。
OpenClaw
1006 0
岁月如酒
|
10月前
|
移动开发 JavaScript API
如何保证 UniApp 插件接口与 UniApp 规范兼容？
如何保证 UniApp 插件接口与 UniApp 规范兼容？
岁月如酒
692 137

热门文章

最新文章

  • 1
    阿里云DTS踩坑经验分享系列｜如何使用DTS进行MySQL->ClickHouse同步
  • 2
    本地部署开源大模型的完整教程：LangChain + Streamlit+ Llama
  • 3
    Linux系统离线安装Docker完整指南
  • 4
    nodeJS 的 npm 设置国内高速镜像之淘宝镜像的方法
  • 5
    mybatis-plus小技能： 分表策略（按年分表和按月分表）
  • 6
    如何在SpringBoot中集成JWT(JSON Web Token)鉴权
  • 7
    AI加持的阿里云飞天大数据平台技术揭秘
  • 8
    如何精准清除特定类型或标签的缓存数据？
  • 9
    详解逗号表达式
  • 10
    OSCAR 分享之蚂蚁开源治理的方法和实践
  • 1
    阿里云 ESSD AutoPL 云盘完整指南：性能分层、计费规则与控制台操作
    81
  • 2
    同城O2O系统开发趋势分析：本地生活数字化下的新机会
    61
  • 3
    【AI】Agent 全栈进阶｜系统化学习路线专题
    569
  • 4
    创业团队开发聊天应用，需要解决哪些 IM 技术难题？
    86
  • 5
    互联网医院系统开发：HIS接口、电子病历与处方数据同步设计
    78
  • 6
    RAG系统测试实战：如何验证企业知识库AI助手是否可靠？
    87
  • 7
    风控系统如何从“管交易”延伸到“管IP”？IP风险画像落地指南
    94
  • 8
    LLM测试体系设计：从Prompt测试到模型质量评估的完整实践
    89
  • 9
    【AI时代软件项目管理系列】2. 从工具到数字员工：AI 在项目团队中的角色演进
    103
  • 10
    阿里云服务器弹性临时盘是什么？哪些ECS支持弹性临时盘？
    107

    • 相关电子书

    更多
  • 低代码开发师（初级）实战教程
  • 冬季实战营第三期：MySQL数据库进阶实战
  • 阿里巴巴DevOps 最佳实践手册
    • 下一篇
    一条命令迁移，帮你实现 OpenClaw 与 Hermes Agent 记忆互通！