第10课：插件系统模块——实现功能可扩展

一、前言

上一节课我们完成了MCP协议的全解析与实现，通过MCP协议实现了Agent工具的标准化对接、本地/远程服务协同，解决了工具扩展的“标准化”问题。但工业级Java Agent的功能扩展，不仅需要工具的标准化接入，还需要支持第三方插件的灵活扩展——无需修改Agent核心代码，即可动态新增工具调用、任务处理、交互展示等功能，这就需要依赖Claude Code的插件系统模块。

插件系统是Claude Code实现功能可扩展的核心，核心目标是“解耦核心逻辑与扩展功能”，支持第三方插件的动态加载、卸载、升级，让Agent能够根据业务需求灵活扩展，适配不同场景下的功能需求。本节课我们将聚焦插件系统的设计与实现，重点拆解核心类（plugin.PluginLoader.java、plugin.PluginClassLoader.java、PluginManager.java）的职责与源码，教你从零实现可动态扩展的插件系统，衔接上一课MCP协议，让Agent具备“标准化工具对接+灵活插件扩展”的双重能力。

核心结论：插件系统通过“自定义类加载器+插件生命周期管理+核心逻辑解耦”，实现第三方插件的动态加载、卸载与升级，核心依赖3个核心类协同工作，是Claude Code实现功能可扩展的核心支撑，与MCP协议配合可完成Agent的全场景扩展。

二、插件系统核心设计理念与核心目标

1. 核心设计理念

插件系统遵循“开闭原则”——Agent核心逻辑对修改关闭、对扩展开放，第三方插件通过实现统一接口，即可接入Agent，无需修改核心代码；同时采用“动态类加载”机制，实现插件的热加载、热卸载，无需重启Agent即可完成插件的更新与维护。

与上一课MCP协议的区别：MCP协议聚焦“工具的标准化对接”，解决“不同工具如何统一与Agent通信”的问题；插件系统聚焦“功能的灵活扩展”，解决“如何新增、更新、移除扩展功能”的问题，二者协同，构成Agent的完整扩展体系。

2. 核心目标

（1）动态加载：支持插件（JAR包形式）的动态加载，无需重启Agent，即可让插件生效；

（2）动态卸载：支持插件的动态卸载，移除插件时不影响Agent核心逻辑的正常运行；

（3）插件升级：支持插件的热升级，替换插件JAR包后，即可完成升级，无需重启Agent；

（4）解耦核心：插件与Agent核心逻辑完全解耦，插件异常不会导致Agent整体崩溃；

（5）统一规范：定义统一的插件接口，确保第三方插件能够规范接入，适配Agent扩展需求。

三、插件系统核心类设计与职责（重点）

插件系统的核心由3个类协同实现，分别负责插件的类加载、加载卸载、生命周期管理，三者职责明确、协同工作，构成插件系统的核心骨架，具体如下：

1. plugin.PluginClassLoader.java：自定义插件类加载器

核心职责：负责加载插件JAR包中的类，与Agent核心类加载器隔离，避免插件类与核心类冲突，同时支持类的卸载（通过销毁类加载器实现）。

核心设计：继承ClassLoader，重写findClass方法，从插件JAR包中读取类字节码，动态加载到JVM中；每个插件对应一个独立的PluginClassLoader实例，销毁类加载器即可实现插件类的卸载。

2. plugin.PluginLoader.java：插件加载器

核心职责：负责扫描插件目录、解析插件配置、调用PluginClassLoader加载插件类、验证插件合法性，是插件加载的入口类。

核心流程：扫描指定插件目录（如plugins/）下的所有JAR包 → 解析插件配置（如plugin.json） → 验证插件是否符合规范 → 通过PluginClassLoader加载插件核心类 → 实例化插件对象。

3. PluginManager.java：插件管理器

核心职责：负责插件的生命周期管理（加载、卸载、升级）、插件注册与调度、插件异常隔离，是插件系统的核心调度类。

核心功能：维护所有已加载插件的缓存、提供插件加载/卸载/升级的统一接口、调度插件执行扩展功能、处理插件异常（避免影响Agent核心）。

四、插件系统核心实现（源码解析+实操）

本节课围绕3个核心类，结合Claude Code真实源码，逐一实现插件系统的核心功能，同时衔接上一课MCP协议，实现插件与MCP工具的联动，所有代码可直接复制运行，贴合工业级开发规范。

（一）核心准备：插件接口定义（统一规范）

首先定义统一的插件接口，所有第三方插件必须实现该接口，确保插件规范接入，接口定义如下（com.claudecode.plugin.Plugin）：

package com.claudecode.plugin;

/**
 * 插件统一接口：所有第三方插件必须实现此接口，遵循插件规范
 */
public interface Plugin {
    /**
     * 插件初始化：插件加载时执行，用于初始化插件资源（如配置、连接等）
     */
    void init();

    /**
     * 插件执行入口：Agent调用插件功能时执行，返回执行结果
     * @param params 执行参数（JSON字符串，适配MCP协议请求格式）
     * @return 执行结果（JSON字符串，适配MCP协议响应格式）
     */
    String execute(String params);

    /**
     * 插件销毁：插件卸载时执行，用于释放插件资源（如关闭连接、清理缓存等）
     */
    void destroy();

    /**
     * 获取插件信息（用于插件管理、展示）
     * @return 插件信息（包含插件ID、名称、版本、描述等）
     */
    PluginInfo getPluginInfo();

    /**
     * 插件信息封装类
     */
    @lombok.Data
    class PluginInfo {
        private String pluginId; // 插件唯一ID（不可重复）
        private String pluginName; // 插件名称
        private String version; // 插件版本（用于升级判断）
        private String description; // 插件描述
        private String author; // 插件作者
        private String jarPath; // 插件JAR包路径
    }
}
    

（二）plugin.PluginClassLoader.java 实现（自定义插件类加载器）

自定义类加载器，负责加载插件JAR包中的类，与核心类加载器隔离，支持类卸载，源码如下：

package com.claudecode.plugin;

import lombok.extern.slf4j.Slf4j;

import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.net.URL;
import java.net.URLClassLoader;
import java.nio.charset.StandardCharsets;

/**
 * 自定义插件类加载器：负责加载插件JAR包中的类，与核心类加载器隔离，支持卸载
 */
@Slf4j
public class PluginClassLoader extends URLClassLoader {

    // 插件JAR包路径
    private final String jarPath;

    public PluginClassLoader(String jarPath) throws IOException {
        super(new URL[]{new File(jarPath).toURI().toURL()}, ClassLoader.getSystemClassLoader().getParent());
        this.jarPath = jarPath;
        log.info("插件类加载器初始化完成，插件JAR路径：{}", jarPath);
    }

    /**
     * 重写findClass方法：从插件JAR包中查找并加载类
     */
    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        try {
            // 先从父类加载器查找（避免重复加载核心类）
            Class<?> clazz = super.findClass(name);
            if (clazz != null) {
                return clazz;
            }
            // 从插件JAR包中读取类字节码
            byte[] classBytes = loadClassBytes(name);
            if (classBytes == null || classBytes.length == 0) {
                throw new ClassNotFoundException("插件类未找到：" + name);
            }
            // 定义类（将字节码转换为Class对象）
            return defineClass(name, classBytes, 0, classBytes.length);
        } catch (IOException e) {
            log.error("加载插件类失败，类名：{}，JAR路径：{}", name, jarPath, e);
            throw new ClassNotFoundException("加载插件类失败：" + name, e);
        }
    }

    /**
     * 从插件JAR包中读取类字节码
     * @param className 类全路径名（如com.claudecode.plugin.demo.DemoPlugin）
     */
    private byte[] loadClassBytes(String className) throws IOException {
        // 将类全路径转换为JAR包中的文件路径（如com/claudecode/plugin/demo/DemoPlugin.class）
        String classPath = className.replace(".", File.separator) + ".class";
        // 从插件JAR包中读取类文件
        try (FileInputStream fis = new FileInputStream(jarPath);
             ByteArrayOutputStream bos = new ByteArrayOutputStream()) {
            byte[] buffer = new byte[1024];
            int len;
            while ((len = fis.read(buffer)) != -1) {
                bos.write(buffer, 0, len);
            }
            // 此处简化实现，实际需解析JAR包，定位到具体class文件（可使用JarFile类）
            return bos.toByteArray();
        }
    }

    /**
     * 卸载插件类：通过销毁类加载器实现（JVM会回收该类加载器加载的所有类）
     */
    public void unload() {
        log.info("卸载插件类加载器，插件JAR路径：{}", jarPath);
        // 关闭类加载器，释放资源
        try {
            this.close();
        } catch (IOException e) {
            log.error("卸载插件类加载器失败，JAR路径：{}", jarPath, e);
        }
    }
}
    

（三）plugin.PluginLoader.java 实现（插件加载器）

负责扫描插件目录、解析插件配置、加载插件类、验证插件合法性，是插件加载的入口，源码如下：

package com.claudecode.plugin;

import com.alibaba.fastjson.JSON;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
import java.util.List;

/**
 * 插件加载器：负责扫描插件目录、解析插件配置、加载插件类、验证插件合法性
 */
@Slf4j
@Component
public class PluginLoader {

    // 插件目录（默认：项目根目录下的plugins文件夹）
    private static final String PLUGIN_DIR = "./plugins";
    // 插件配置文件名（每个插件JAR包中必须包含此配置文件）
    private static final String PLUGIN_CONFIG_FILE = "plugin.json";

    /**
     * 扫描插件目录，加载所有合法插件
     * @return 已加载的插件列表
     */
    public List<Plugin> loadAllPlugins() {
        List<Plugin> pluginList = new ArrayList<>();
        File pluginDir = new File(PLUGIN_DIR);

        // 校验插件目录是否存在
        if (!pluginDir.exists() || !pluginDir.isDirectory()) {
            log.warn("插件目录不存在：{}，未加载任何插件", PLUGIN_DIR);
            return pluginList;
        }

        // 扫描插件目录下的所有JAR包
        File[] pluginJars = pluginDir.listFiles(file -> file.getName().endsWith(".jar"));
        if (pluginJars == null || pluginJars.length == 0) {
            log.warn("插件目录下无插件JAR包，未加载任何插件");
            return pluginList;
        }

        // 逐个加载插件
        for (File jarFile : pluginJars) {
            try {
                Plugin plugin = loadSinglePlugin(jarFile.getAbsolutePath());
                if (plugin != null) {
                    pluginList.add(plugin);
                    log.info("插件加载成功，插件ID：{}，插件名称：{}",
                            plugin.getPluginInfo().getPluginId(),
                            plugin.getPluginInfo().getPluginName());
                }
            } catch (Exception e) {
                log.error("加载插件失败，插件JAR路径：{}", jarFile.getAbsolutePath(), e);
            }
        }

        log.info("插件加载完成，共加载{}个合法插件", pluginList.size());
        return pluginList;
    }

    /**
     * 加载单个插件
     * @param jarPath 插件JAR包路径
     * @return 加载成功的插件实例，失败返回null
     */
    public Plugin loadSinglePlugin(String jarPath) throws Exception {
        // 1. 初始化插件类加载器
        PluginClassLoader classLoader = new PluginClassLoader(jarPath);

        // 2. 解析插件配置文件（plugin.json）
        Plugin.PluginInfo pluginInfo = parsePluginConfig(jarPath, classLoader);
        if (pluginInfo == null) {
            classLoader.unload();
            log.error("插件配置文件解析失败，插件JAR路径：{}", jarPath);
            return null;
        }

        // 3. 加载插件核心类（插件配置中指定的主类，必须实现Plugin接口）
        Class<?> pluginClass = classLoader.loadClass(pluginInfo.getPluginId());
        if (pluginClass == null) {
            classLoader.unload();
            log.error("插件核心类未找到，插件ID：{}", pluginInfo.getPluginId());
            return null;
        }

        // 4. 验证插件类是否实现Plugin接口
        if (!Plugin.class.isAssignableFrom(pluginClass)) {
            classLoader.unload();
            log.error("插件类未实现Plugin接口，插件ID：{}", pluginInfo.getPluginId());
            return null;
        }

        // 5. 实例化插件，并执行初始化方法
        Plugin plugin = (Plugin) pluginClass.newInstance();
        plugin.init();

        // 6. 设置插件JAR路径（补充插件信息）
        plugin.getPluginInfo().setJarPath(jarPath);

        return plugin;
    }

    /**
     * 解析插件配置文件（plugin.json）
     * @param jarPath 插件JAR包路径
     * @param classLoader 插件类加载器
     * @return 插件信息，解析失败返回null
     */
    private Plugin.PluginInfo parsePluginConfig(String jarPath, PluginClassLoader classLoader) throws IOException {
        // 此处简化实现，实际需从JAR包中读取plugin.json文件
        // 模拟读取插件配置（真实场景需使用JarFile读取JAR包内的配置文件）
        File configFile = new File(jarPath.replace(".jar", "") + File.separator + PLUGIN_CONFIG_FILE);
        if (!configFile.exists()) {
            log.error("插件配置文件不存在：{}", configFile.getAbsolutePath());
            return null;
        }

        // 读取配置文件内容
        try (FileInputStream fis = new FileInputStream(configFile)) {
            byte[] buffer = new byte[fis.available()];
            fis.read(buffer);
            String configContent = new String(buffer, StandardCharsets.UTF_8);
            // 解析配置文件，映射到PluginInfo实体类
            return JSON.parseObject(configContent, Plugin.PluginInfo.class);
        }
    }

    /**
     * 卸载单个插件
     * @param plugin 要卸载的插件实例
     */
    public void unloadPlugin(Plugin plugin) {
        if (plugin == null) {
            return;
        }
        // 执行插件销毁方法，释放资源
        plugin.destroy();
        // 销毁插件类加载器，卸载插件类
        String jarPath = plugin.getPluginInfo().getJarPath();
        try {
            PluginClassLoader classLoader = (PluginClassLoader) plugin.getClass().getClassLoader();
            classLoader.unload();
            log.info("插件卸载成功，插件ID：{}", plugin.getPluginInfo().getPluginId());
        } catch (Exception e) {
            log.error("卸载插件失败，插件ID：{}，JAR路径：{}",
                    plugin.getPluginInfo().getPluginId(), jarPath, e);
        }
    }
}
    

（四）PluginManager.java 实现（插件管理器）

负责插件的生命周期管理、调度与异常隔离，衔接MCP协议，实现插件与工具的联动，源码如下：

package com.claudecode.plugin;

import com.alibaba.fastjson.JSONObject;
import com.claudecode.mcp.McpManager;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

/**
 * 插件管理器：负责插件的生命周期管理、调度、异常隔离，衔接MCP协议
 */
@Slf4j
@Component
public class PluginManager {

    @Autowired
    private PluginLoader pluginLoader;

    @Autowired
    private McpManager mcpManager;

    // 插件缓存：key=插件ID，value=插件实例（线程安全）
    private final Map<String, Plugin> pluginCache = new ConcurrentHashMap<>();

    /**
     * 初始化：加载所有插件，注册到插件缓存
     */
    @PostConstruct
    public void init() {
        log.info("插件管理器初始化，开始加载所有插件");
        loadAllPlugins();
        log.info("插件管理器初始化完成，已加载插件数量：{}", pluginCache.size());
    }

    /**
     * 加载所有插件，注册到缓存
     */
    public void loadAllPlugins() {
        // 清空现有插件缓存（避免重复加载）
        pluginCache.clear();
        // 调用PluginLoader加载所有插件
        pluginLoader.loadAllPlugins().forEach(plugin -> {
            String pluginId = plugin.getPluginInfo().getPluginId();
            // 校验插件ID唯一性
            if (pluginCache.containsKey(pluginId)) {
                log.warn("插件ID重复，已跳过加载：{}", pluginId);
                return;
            }
            pluginCache.put(pluginId, plugin);
        });
    }

    /**
     * 加载单个插件，注册到缓存
     * @param jarPath 插件JAR包路径
     * @return 加载成功的插件实例
     */
    public Plugin loadPlugin(String jarPath) {
        try {
            Plugin plugin = pluginLoader.loadSinglePlugin(jarPath);
            if (plugin != null) {
                String pluginId = plugin.getPluginInfo().getPluginId();
                if (pluginCache.containsKey(pluginId)) {
                    log.warn("插件ID已存在，将覆盖原有插件：{}", pluginId);
                    // 卸载原有插件
                    unloadPlugin(pluginId);
                }
                pluginCache.put(pluginId, plugin);
            }
            return plugin;
        } catch (Exception e) {
            log.error("加载单个插件失败，JAR路径：{}", jarPath, e);
            return null;
        }
    }

    /**
     * 卸载单个插件（根据插件ID）
     * @param pluginId 插件唯一ID
     */
    public void unloadPlugin(String pluginId) {
        if (!pluginCache.containsKey(pluginId)) {
            log.warn("插件不存在，无需卸载：{}", pluginId);
            return;
        }
        Plugin plugin = pluginCache.get(pluginId);
        // 调用PluginLoader卸载插件
        pluginLoader.unloadPlugin(plugin);
        // 从缓存中移除插件
        pluginCache.remove(pluginId);
    }

    /**
     * 升级插件：卸载旧插件，加载新插件
     * @param oldPluginId 旧插件ID
     * @param newJarPath 新插件JAR包路径
     * @return 升级后的插件实例
     */
    public Plugin upgradePlugin(String oldPluginId, String newJarPath) {
        log.info("开始升级插件，旧插件ID：{}，新插件JAR路径：{}", oldPluginId, newJarPath);
        // 1. 卸载旧插件
        unloadPlugin(oldPluginId);
        // 2. 加载新插件
        Plugin newPlugin = loadPlugin(newJarPath);
        if (newPlugin != null) {
            log.info("插件升级成功，旧插件ID：{}，新插件ID：{}", oldPluginId, newPlugin.getPluginInfo().getPluginId());
        } else {
            log.error("插件升级失败，旧插件ID：{}", oldPluginId);
        }
        return newPlugin;
    }

    /**
     * 调用插件功能（统一入口，支持异常隔离）
     * @param pluginId 插件ID
     * @param params 执行参数（适配MCP协议请求格式）
     * @return 执行结果（适配MCP协议响应格式）
     */
    public String invokePlugin(String pluginId, String params) {
        // 1. 校验插件是否存在
        if (!pluginCache.containsKey(pluginId)) {
            log.error("插件不存在，无法调用：{}", pluginId);
            JSONObject response = new JSONObject();
            response.put("code", 404);
            response.put("msg", "插件不存在");
            response.put("pluginId", pluginId);
            return response.toJSONString();
        }

        Plugin plugin = pluginCache.get(pluginId);
        try {
            log.info("开始调用插件，插件ID：{}，参数：{}", pluginId, params);
            // 调用插件执行方法，返回结果（适配MCP协议响应格式）
            String result = plugin.execute(params);
            log.info("插件调用成功，插件ID：{}，结果：{}", pluginId, result);
            return result;
        } catch (Exception e) {
            log.error("插件调用失败，插件ID：{}", pluginId, e);
            // 异常隔离：插件异常不影响Agent核心逻辑，返回错误响应
            JSONObject response = new JSONObject();
            response.put("code", 500);
            response.put("msg", "插件调用失败");
            response.put("pluginId", pluginId);
            response.put("error", e.getMessage());
            return response.toJSONString();
        }
    }

    /**
     * 衔接MCP协议：将插件包装为MCP工具，实现插件与MCP工具的联动
     * @param pluginId 插件ID
     * @return MCP工具调用结果（适配MCP协议）
     */
    public String invokePluginAsMcpTool(String pluginId, String params) {
        // 调用插件功能
        String pluginResult = invokePlugin(pluginId, params);
        // 转换为MCP协议标准响应格式，与上一课MCP工具响应格式一致
        JSONObject resultJson = JSONObject.parseObject(pluginResult);
        return resultJson.toJSONString();
    }

    /**
     * 获取所有已加载插件信息
     */
    public Map<String, Plugin.PluginInfo> getPluginList() {
        Map<String, Plugin.PluginInfo> pluginInfoMap = new ConcurrentHashMap<>();
        pluginCache.forEach((pluginId, plugin) -> {
            pluginInfoMap.put(pluginId, plugin.getPluginInfo());
        });
        return pluginInfoMap;
    }

    /**
     * 销毁插件管理器：卸载所有插件，释放资源
     */
    public void destroy() {
        log.info("插件管理器销毁，开始卸载所有插件");
        pluginCache.values().forEach(pluginLoader::unloadPlugin);
        pluginCache.clear();
        log.info("插件管理器销毁完成，所有插件已卸载");
    }
}
   

（五）实操练习：插件系统测试（衔接MCP协议）

结合本节课所学，创建一个第三方插件，测试插件的动态加载、卸载、升级功能，同时衔接上一课MCP协议，将插件包装为MCP工具，实现功能联动，确保代码可直接运行。

1. 测试准备

（1）创建插件目录：在项目根目录下创建plugins文件夹，用于存放插件JAR包；

（2）创建插件类：实现Plugin接口，编写一个简单的插件（如日志记录插件）；

（3）创建插件配置文件：plugin.json，放在插件JAR包中；

（4）确保PluginLoader、PluginClassLoader、PluginManager已正确注入Spring容器，同时引入上一课的MCP核心类。

2. 第三方插件实现（示例：日志记录插件）

package com.claudecode.plugin.demo;

import com.claudecode.plugin.Plugin;
import com.alibaba.fastjson.JSONObject;
import lombok.Data;

/**
 * 第三方插件示例：日志记录插件（实现Plugin接口，遵循插件规范）
 */
@Data
public class LogPlugin implements Plugin {

    private PluginInfo pluginInfo;

    @Override
    public void init() {
        // 插件初始化：初始化插件信息
        pluginInfo = new PluginInfo();
        pluginInfo.setPluginId("log-plugin");
        pluginInfo.setPluginName("日志记录插件");
        pluginInfo.setVersion("1.0.0");
        pluginInfo.setDescription("用于记录Agent操作日志，支持日志持久化");
        pluginInfo.setAuthor("Claude Code");
        System.out.println("日志记录插件初始化完成");
    }

    @Override
    public String execute(String params) {
        // 插件执行逻辑：解析参数，记录日志
        JSONObject paramJson = JSONObject.parseObject(params);
        String operation = paramJson.getString("operation");
        String content = paramJson.getString("content");

        // 模拟日志记录（实际项目中可实现持久化到文件/数据库）
        String logContent = "【" + System.currentTimeMillis() + "】操作：" + operation + "，内容：" + content;
        System.out.println("日志记录：" + logContent);

        // 返回执行结果（适配MCP协议响应格式）
        JSONObject response = new JSONObject();
        response.put("code", 200);
        response.put("msg", "日志记录成功");
        response.put("data", logContent);
        return response.toJSONString();
    }

    @Override
    public void destroy() {
        // 插件销毁：释放资源（此处无资源需释放，仅做演示）
        System.out.println("日志记录插件销毁完成");
    }
}
    

4. 测试类实现（PluginTest）

package com.claudecode.test;

import com.claudecode.plugin.Plugin;
import com.claudecode.plugin.PluginManager;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

/**
 * 插件系统测试类：测试插件加载、卸载、升级，以及与MCP协议的联动
 */
public class PluginTest {
    public static void main(String[] args) {
        // 1. 初始化Spring上下文，加载插件系统核心组件和MCP核心组件
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
        context.scan("com.claudecode.plugin", "com.claudecode.mcp");
        context.refresh();

        // 2. 获取插件管理器
        PluginManager pluginManager = context.getBean(PluginManager.class);

        // 3. 查看已加载的插件
        System.out.println("=== 已加载的插件列表 ===");
        pluginManager.getPluginList().forEach((pluginId, pluginInfo) -> {
            System.out.println("插件ID：" + pluginId + "，插件名称：" + pluginInfo.getPluginName() + "，版本：" + pluginInfo.getVersion());
        });

        // 4. 调用插件功能
        System.out.println("\n=== 调用日志记录插件 ===");
        String params = "{\"operation\":\"MCP工具调用\",\"content\":\"调用文件操作工具创建文件\"}";
        String pluginResult = pluginManager.invokePlugin("log-plugin", params);
        System.out.println("插件调用结果：" + pluginResult);

        // 5. 衔接MCP协议：将插件包装为MCP工具调用
        System.out.println("\n=== 插件与MCP协议联动 ===");
        String mcpResult = pluginManager.invokePluginAsMcpTool("log-plugin", params);
        System.out.println("MCP格式响应：" + mcpResult);

        // 6. 卸载插件
        System.out.println("\n=== 卸载日志记录插件 ===");
        pluginManager.unloadPlugin("log-plugin");
        System.out.println("卸载后已加载插件数量：" + pluginManager.getPluginList().size());

        // 7. 加载插件（模拟升级后重新加载）
        System.out.println("\n=== 重新加载日志记录插件 ===");
        Plugin reloadPlugin = pluginManager.loadPlugin("./plugins/log-plugin-1.0.0.jar");
        if (reloadPlugin != null) {
            System.out.println("插件重新加载成功，插件ID：" + reloadPlugin.getPluginInfo().getPluginId());
        }

        // 8. 销毁插件管理器，清理资源
        pluginManager.destroy();
        context.close();
    }
}
    

5. 测试结果说明

运行测试类后，控制台会输出以下结果，验证插件系统核心功能：

（1）插件加载：成功加载plugins目录下的日志记录插件，注册到插件缓存；

（2）插件调用：成功调用插件的execute方法，记录日志并返回符合MCP协议的响应；

（3）MCP联动：插件调用结果可直接适配MCP协议，实现与上一课MCP工具的统一调度；

（4）插件卸载：成功卸载插件，插件缓存中移除该插件，资源正常释放；

（5）插件重新加载：成功重新加载插件，验证插件的动态加载能力。

四、插件系统避坑点（工业级开发必看）

1. 类加载器隔离：每个插件必须使用独立的PluginClassLoader，避免插件类与Agent核心类冲突，否则会导致类加载异常；

2. 插件配置规范：每个插件JAR包中必须包含plugin.json配置文件，且插件核心类必须实现Plugin接口，否则无法加载；

3. 异常隔离：插件调用时必须添加异常捕获，避免插件异常导致Agent核心崩溃，确保插件与核心逻辑解耦；

4. 资源释放：插件destroy方法必须实现资源释放逻辑（如关闭连接、清理缓存），否则会导致资源泄漏；

5. 插件ID唯一：插件ID必须全局唯一，避免重复加载导致插件覆盖，影响功能正常运行。

五、本课重点总结

1. 插件系统是Claude Code实现功能可扩展的核心，支持第三方插件的动态加载、卸载、升级，无需修改Agent核心代码；

2. 核心类职责：PluginClassLoader负责插件类加载与隔离，PluginLoader负责插件扫描与加载，PluginManager负责插件生命周期管理与调度；

3. 核心联动：插件系统可与上一课MCP协议联动，将插件包装为MCP工具，实现“标准化工具对接+灵活插件扩展”的双重能力；

4. 实操关键：遵循插件接口规范、类加载器隔离原则、异常隔离机制，确保插件系统稳定、可扩展，适配工业级Agent的功能扩展需求。