欢迎加入开源鸿蒙PC社区：https://harmonypc.csdn.net/

atomgit仓库地址：https://atomgit.com/feng8403000/cms

---

进程间通信效果

一、引言

1.1 Electron进程模型概述

Electron采用主进程（Main Process）和渲染进程（Renderer Process）的架构模式：

主进程：

• 管理应用生命周期
• 创建和管理浏览器窗口
• 处理系统级操作（菜单、对话框、文件系统访问等）
• 作为渲染进程的父进程

渲染进程：

• 运行在Chromium引擎中
• 负责UI渲染和用户交互
• 每个窗口拥有独立的渲染进程
• 通过IPC与主进程通信

1.2 IPC通信的重要性

进程间通信（IPC）是Electron应用的核心机制，用于：

• 在主进程和渲染进程之间传递数据
• 调用系统级API
• 实现跨窗口通信
• 处理异步操作

1.3 本章概述

本章将详细介绍Electron中的进程间通信机制和主进程管理，包括：

• IPC基础概念
• 主进程架构设计
• IPC通信模式
• 异步通信最佳实践
• 进程管理策略

二、IPC基础概念

2.1 IPC机制原理

Electron提供了两种主要的IPC模块：

// 主进程中的IPC模块
const { ipcMain } = require('electron');

// 渲染进程中的IPC模块
const { ipcRenderer } = require('electron');

2.2 IPC通信模式

2.2.1 单向通信

// 主进程 - 监听渲染进程消息
ipcMain.on('renderer-message', (event, arg) => {
    console.log('收到渲染进程消息:', arg);
    
    // 获取发送消息的渲染进程
    const sender = event.sender;
    
    // 获取WebContents
    const webContents = event.sender;
});

// 渲染进程 - 发送消息到主进程
ipcRenderer.send('renderer-message', { 
    type: 'user-action',
    payload: { id: 1, data: 'hello' }
});

2.2.2 双向通信（同步）

// 主进程 - 处理同步消息
ipcMain.on('sync-request', (event, arg) => {
    console.log('收到同步请求:', arg);
    
    // 同步返回结果
    event.returnValue = { 
        success: true, 
        data: '处理完成' 
    };
});

// 渲染进程 - 发送同步请求
const result = ipcRenderer.sendSync('sync-request', { 
    action: 'get-data',
    params: { id: 1 }
});

console.log('同步响应:', result);

2.2.3 双向通信（异步）

// 主进程 - 处理异步消息
ipcMain.handle('async-request', async (event, arg) => {
    console.log('收到异步请求:', arg);
    
    // 模拟异步操作
    const result = await new Promise(resolve => {
        setTimeout(() => {
            resolve({ 
                success: true, 
                data: '异步处理完成' 
            });
        }, 1000);
    });
    
    return result;
});

// 渲染进程 - 发送异步请求
ipcRenderer.invoke('async-request', { 
    action: 'fetch-data',
    params: { id: 1 }
}).then(result => {
    console.log('异步响应:', result);
}).catch(error => {
    console.error('请求失败:', error);
});

2.3 IPC事件对象

IPC事件对象提供了丰富的信息和方法：

ipcMain.on('message', (event, arg) => {
    // event对象属性
    console.log('事件类型:', event.type);
    console.log('发送者WebContents:', event.sender);
    console.log('发送者ID:', event.sender.id);
    
    // event对象方法
    event.reply('reply-channel', '回复消息'); // 回复发送者
    event.sender.send('direct-message', '直接发送'); // 直接发送给发送者
    
    // event.returnValue - 同步消息返回值
    // event.preventDefault() - 阻止默认行为
});

三、主进程架构设计

3.1 主进程模块结构

main/
├── main.js                 # 主进程入口
├── window-manager.js       # 窗口管理模块
├── menu-manager.js         # 菜单管理模块
├── ipc-handler.js          # IPC处理器
├── file-system.js          # 文件系统操作
├── dialog-manager.js       # 对话框管理
└── app-lifecycle.js        # 应用生命周期管理

3.2 窗口管理模块

class WindowManager {
    constructor() {
        this.windows = new Map();
        this.windowConfigs = {
            main: {
                width: 1200,
                height: 800,
                minWidth: 800,
                minHeight: 600,
                title: '智能文章管理系统',
                webPreferences: {
                    nodeIntegration: true,
                    contextIsolation: false,
                    enableRemoteModule: true
                }
            },
            about: {
                width: 400,
                height: 280,
                title: '关于',
                resizable: false,
                webPreferences: {
                    nodeIntegration: true,
                    contextIsolation: false
                }
            },
            settings: {
                width: 600,
                height: 500,
                title: '设置',
                webPreferences: {
                    nodeIntegration: true,
                    contextIsolation: false
                }
            }
        };
    }

    createWindow(windowType, config = {}) {
        const baseConfig = this.windowConfigs[windowType];
        
        if (!baseConfig) {
            throw new Error(`未知窗口类型: ${windowType}`);
        }
        
        const mergedConfig = { ...baseConfig, ...config };
        const window = new BrowserWindow(mergedConfig);
        
        // 加载对应的HTML文件
        window.loadFile(`${windowType}.html`);
        
        // 存储窗口引用
        this.windows.set(windowType, window);
        
        // 设置窗口关闭事件
        window.on('closed', () => {
            this.windows.delete(windowType);
        });
        
        return window;
    }

    getWindow(windowType) {
        return this.windows.get(windowType);
    }

    getAllWindows() {
        return Array.from(this.windows.values());
    }

    closeWindow(windowType) {
        const window = this.windows.get(windowType);
        if (window) {
            window.close();
        }
    }

    closeAllWindows() {
        this.windows.forEach(window => {
            window.close();
        });
    }

    minimizeWindow(windowType) {
        const window = this.windows.get(windowType);
        if (window) {
            window.minimize();
        }
    }

    maximizeWindow(windowType) {
        const window = this.windows.get(windowType);
        if (window) {
            if (window.isMaximized()) {
                window.unmaximize();
            } else {
                window.maximize();
            }
        }
    }

    setWindowTitle(windowType, title) {
        const window = this.windows.get(windowType);
        if (window) {
            window.setTitle(title);
        }
    }

    showWindow(windowType) {
        const window = this.windows.get(windowType);
        if (window) {
            window.show();
            window.focus();
        }
    }

    hideWindow(windowType) {
        const window = this.windows.get(windowType);
        if (window) {
            window.hide();
        }
    }

    toggleDevTools(windowType) {
        const window = this.windows.get(windowType);
        if (window) {
            if (window.webContents.isDevToolsOpened()) {
                window.webContents.closeDevTools();
            } else {
                window.webContents.openDevTools();
            }
        }
    }
}

3.3 菜单管理模块

class MenuManager {
    constructor(app, windowManager) {
        this.app = app;
        this.windowManager = windowManager;
        this.menu = null;
    }

    buildMenu() {
        const template = [
            {
                label: '文件',
                submenu: [
                    {
                        label: '新建文章',
                        accelerator: 'CmdOrCtrl+N',
                        click: () => {
                            this.createNewArticle();
                        }
                    },
                    {
                        label: '打开文件',
                        accelerator: 'CmdOrCtrl+O',
                        click: () => {
                            this.openFile();
                        }
                    },
                    { type: 'separator' },
                    {
                        label: '保存',
                        accelerator: 'CmdOrCtrl+S',
                        click: () => {
                            this.saveFile();
                        }
                    },
                    {
                        label: '另存为',
                        accelerator: 'CmdOrCtrl+Shift+S',
                        click: () => {
                            this.saveFileAs();
                        }
                    },
                    { type: 'separator' },
                    {
                        label: '退出',
                        accelerator: 'CmdOrCtrl+Q',
                        click: () => {
                            this.app.quit();
                        }
                    }
                ]
            },
            {
                label: '编辑',
                submenu: [
                    { role: 'undo' },
                    { role: 'redo' },
                    { type: 'separator' },
                    { role: 'cut' },
                    { role: 'copy' },
                    { role: 'paste' },
                    { role: 'delete' },
                    { role: 'selectAll' }
                ]
            },
            {
                label: '视图',
                submenu: [
                    {
                        label: '刷新',
                        accelerator: 'CmdOrCtrl+R',
                        click: (item, focusedWindow) => {
                            if (focusedWindow) {
                                focusedWindow.reload();
                            }
                        }
                    },
                    { type: 'separator' },
                    { role: 'togglefullscreen' },
                    {
                        label: '开发者工具',
                        accelerator: 'CmdOrCtrl+Shift+I',
                        click: (item, focusedWindow) => {
                            if (focusedWindow) {
                                focusedWindow.webContents.toggleDevTools();
                            }
                        }
                    }
                ]
            },
            {
                label: '窗口',
                submenu: [
                    { role: 'minimize' },
                    { role: 'zoom' },
                    { type: 'separator' },
                    { role: 'front' },
                    {
                        label: '关于',
                        click: () => {
                            this.windowManager.createWindow('about');
                        }
                    }
                ]
            },
            {
                label: '帮助',
                submenu: [
                    {
                        label: '在线帮助',
                        click: () => {
                            require('electron').shell.openExternal('https://example.com/help');
                        }
                    },
                    {
                        label: '检查更新',
                        click: () => {
                            this.checkForUpdates();
                        }
                    }
                ]
            }
        ];

        this.menu = Menu.buildFromTemplate(template);
        Menu.setApplicationMenu(this.menu);
    }

    createNewArticle() {
        const mainWindow = this.windowManager.getWindow('main');
        if (mainWindow) {
            mainWindow.webContents.executeJavaScript('AppController.openEditor()');
        }
    }

    openFile() {
        // 文件打开逻辑
    }

    saveFile() {
        // 文件保存逻辑
    }

    saveFileAs() {
        // 文件另存为逻辑
    }

    checkForUpdates() {
        // 更新检查逻辑
    }
}

3.4 IPC处理器模块

class IpcHandler {
    constructor(ipcMain, windowManager, dataStorage) {
        this.ipcMain = ipcMain;
        this.windowManager = windowManager;
        this.dataStorage = dataStorage;
        this.setupHandlers();
    }

    setupHandlers() {
        // 文章相关IPC处理
        this.setupArticleHandlers();
        
        // 分类相关IPC处理
        this.setupCategoryHandlers();
        
        // 标签相关IPC处理
        this.setupTagHandlers();
        
        // 设置相关IPC处理
        this.setupSettingsHandlers();
        
        // 窗口相关IPC处理
        this.setupWindowHandlers();
    }

    setupArticleHandlers() {
        // 创建文章
        this.ipcMain.handle('article:create', async (event, articleData) => {
            try {
                const article = await this.dataStorage.createArticle(articleData);
                return { success: true, data: article.toJSON() };
            } catch (error) {
                return { success: false, error: error.message };
            }
        });

        // 更新文章
        this.ipcMain.handle('article:update', async (event, id, articleData) => {
            try {
                const article = await this.dataStorage.updateArticle(id, articleData);
                return { success: true, data: article.toJSON() };
            } catch (error) {
                return { success: false, error: error.message };
            }
        });

        // 获取文章
        this.ipcMain.handle('article:get', async (event, id) => {
            try {
                const article = await this.dataStorage.getArticle(id);
                return { success: true, data: article.toJSON() };
            } catch (error) {
                return { success: false, error: error.message };
            }
        });

        // 获取所有文章
        this.ipcMain.handle('article:list', async (event, filters) => {
            try {
                const articles = await this.dataStorage.getAllArticles(filters);
                return { 
                    success: true, 
                    data: articles.map(a => a.toJSON()) 
                };
            } catch (error) {
                return { success: false, error: error.message };
            }
        });

        // 删除文章
        this.ipcMain.handle('article:delete', async (event, id) => {
            try {
                await this.dataStorage.deleteArticle(id);
                return { success: true };
            } catch (error) {
                return { success: false, error: error.message };
            }
        });
    }

    setupCategoryHandlers() {
        // 创建分类
        this.ipcMain.handle('category:create', async (event, categoryData) => {
            try {
                const category = await this.dataStorage.createCategory(categoryData);
                return { success: true, data: category.toJSON() };
            } catch (error) {
                return { success: false, error: error.message };
            }
        });

        // 更新分类
        this.ipcMain.handle('category:update', async (event, id, categoryData) => {
            try {
                const category = await this.dataStorage.updateCategory(id, categoryData);
                return { success: true, data: category.toJSON() };
            } catch (error) {
                return { success: false, error: error.message };
            }
        });

        // 获取分类
        this.ipcMain.handle('category:get', async (event, id) => {
            try {
                const category = await this.dataStorage.getCategory(id);
                return { success: true, data: category.toJSON() };
            } catch (error) {
                return { success: false, error: error.message };
            }
        });

        // 获取所有分类
        this.ipcMain.handle('category:list', async () => {
            try {
                const categories = await this.dataStorage.getAllCategories();
                return { 
                    success: true, 
                    data: categories.map(c => c.toJSON()) 
                };
            } catch (error) {
                return { success: false, error: error.message };
            }
        });

        // 删除分类
        this.ipcMain.handle('category:delete', async (event, id) => {
            try {
                await this.dataStorage.deleteCategory(id);
                return { success: true };
            } catch (error) {
                return { success: false, error: error.message };
            }
        });
    }

    setupTagHandlers() {
        // 创建标签
        this.ipcMain.handle('tag:create', async (event, tagData) => {
            try {
                const tag = await this.dataStorage.createTag(tagData);
                return { success: true, data: tag.toJSON() };
            } catch (error) {
                return { success: false, error: error.message };
            }
        });

        // 更新标签
        this.ipcMain.handle('tag:update', async (event, id, tagData) => {
            try {
                const tag = await this.dataStorage.updateTag(id, tagData);
                return { success: true, data: tag.toJSON() };
            } catch (error) {
                return { success: false, error: error.message };
            }
        });

        // 获取标签
        this.ipcMain.handle('tag:get', async (event, id) => {
            try {
                const tag = await this.dataStorage.getTag(id);
                return { success: true, data: tag.toJSON() };
            } catch (error) {
                return { success: false, error: error.message };
            }
        });

        // 获取所有标签
        this.ipcMain.handle('tag:list', async () => {
            try {
                const tags = await this.dataStorage.getAllTags();
                return { 
                    success: true, 
                    data: tags.map(t => t.toJSON()) 
                };
            } catch (error) {
                return { success: false, error: error.message };
            }
        });

        // 删除标签
        this.ipcMain.handle('tag:delete', async (event, id) => {
            try {
                await this.dataStorage.deleteTag(id);
                return { success: true };
            } catch (error) {
                return { success: false, error: error.message };
            }
        });
    }

    setupSettingsHandlers() {
        // 获取用户设置
        this.ipcMain.handle('settings:get', async () => {
            try {
                const settings = await this.dataStorage.getUserSettings();
                return { success: true, data: settings.toJSON() };
            } catch (error) {
                return { success: false, error: error.message };
            }
        });

        // 更新用户设置
        this.ipcMain.handle('settings:update', async (event, settingsData) => {
            try {
                const settings = await this.dataStorage.updateUserSettings(settingsData);
                return { success: true, data: settings.toJSON() };
            } catch (error) {
                return { success: false, error: error.message };
            }
        });

        // 获取统计信息
        this.ipcMain.handle('stats:get', async () => {
            try {
                const stats = await this.dataStorage.getStats();
                return { success: true, data: stats };
            } catch (error) {
                return { success: false, error: error.message };
            }
        });
    }

    setupWindowHandlers() {
        // 创建窗口
        this.ipcMain.handle('window:create', async (event, windowType, config) => {
            try {
                this.windowManager.createWindow(windowType, config);
                return { success: true };
            } catch (error) {
                return { success: false, error: error.message };
            }
        });

        // 关闭窗口
        this.ipcMain.handle('window:close', async (event, windowType) => {
            try {
                this.windowManager.closeWindow(windowType);
                return { success: true };
            } catch (error) {
                return { success: false, error: error.message };
            }
        });

        // 最小化窗口
        this.ipcMain.handle('window:minimize', async (event, windowType) => {
            try {
                this.windowManager.minimizeWindow(windowType);
                return { success: true };
            } catch (error) {
                return { success: false, error: error.message };
            }
        });

        // 最大化窗口
        this.ipcMain.handle('window:maximize', async (event, windowType) => {
            try {
                this.windowManager.maximizeWindow(windowType);
                return { success: true };
            } catch (error) {
                return { success: false, error: error.message };
            }
        });
    }
}

四、IPC通信最佳实践

4.1 错误处理模式

// 统一错误处理中间件
class IpcErrorHandler {
    static async handle(promise) {
        try {
            const result = await promise;
            return { success: true, data: result };
        } catch (error) {
            console.error('IPC处理错误:', error);
            return { 
                success: false, 
                error: error.message,
                stack: process.env.NODE_ENV === 'development' ? error.stack : undefined
            };
        }
    }

    static handleSync(callback) {
        try {
            const result = callback();
            return { success: true, data: result };
        } catch (error) {
            console.error('IPC同步处理错误:', error);
            return { 
                success: false, 
                error: error.message 
            };
        }
    }
}

// 使用错误处理器
ipcMain.handle('safe-operation', async (event, arg) => {
    return IpcErrorHandler.handle(async () => {
        // 业务逻辑
        const result = await someAsyncOperation(arg);
        return result;
    });
});

4.2 消息序列化与反序列化

class MessageSerializer {
    static serialize(message) {
        try {
            return JSON.stringify(message);
        } catch (error) {
            console.error('消息序列化失败:', error);
            return null;
        }
    }

    static deserialize(data) {
        try {
            return JSON.parse(data);
        } catch (error) {
            console.error('消息反序列化失败:', error);
            return null;
        }
    }

    static validate(message, schema) {
        // 使用JSON Schema验证消息格式
        const Ajv = require('ajv');
        const ajv = new Ajv();
        const validate = ajv.compile(schema);
        
        if (!validate(message)) {
            console.error('消息验证失败:', validate.errors);
            return false;
        }
        
        return true;
    }
}

// 消息格式定义
const MessageSchemas = {
    articleCreate: {
        type: 'object',
        properties: {
            title: { type: 'string', minLength: 1 },
            content: { type: 'string', minLength: 1 },
            categoryId: { type: ['string', 'null'] },
            tagIds: { type: 'array', items: { type: 'string' } }
        },
        required: ['title', 'content']
    },
    articleUpdate: {
        type: 'object',
        properties: {
            id: { type: 'string', minLength: 1 },
            title: { type: 'string' },
            content: { type: 'string' },
            categoryId: { type: ['string', 'null'] },
            tagIds: { type: 'array', items: { type: 'string' } }
        },
        required: ['id']
    }
};

4.3 限流与熔断

class IpcRateLimiter {
    constructor(options = {}) {
        this.rateLimit = options.rateLimit || 100; // 每分钟最大请求数
        this.windowMs = options.windowMs || 60000; // 时间窗口（毫秒）
        this.clients = new Map();
    }

    check(clientId) {
        const now = Date.now();
        const client = this.clients.get(clientId);
        
        if (!client) {
            this.clients.set(clientId, {
                requests: 1,
                startTime: now
            });
            return true;
        }
        
        // 检查时间窗口是否过期
        if (now - client.startTime > this.windowMs) {
            this.clients.set(clientId, {
                requests: 1,
                startTime: now
            });
            return true;
        }
        
        // 检查请求数是否超限
        if (client.requests >= this.rateLimit) {
            return false;
        }
        
        client.requests++;
        return true;
    }

    getClientStats(clientId) {
        return this.clients.get(clientId);
    }

    resetClient(clientId) {
        this.clients.delete(clientId);
    }
}

// 使用限流器
const limiter = new IpcRateLimiter();

ipcMain.handle('rate-limited-operation', (event, arg) => {
    const clientId = event.sender.id.toString();
    
    if (!limiter.check(clientId)) {
        return { 
            success: false, 
            error: '请求过于频繁，请稍后再试' 
        };
    }
    
    // 处理请求
    return handleOperation(arg);
});

五、进程管理策略

5.1 应用生命周期管理

class AppLifecycleManager {
    constructor(app, windowManager) {
        this.app = app;
        this.windowManager = windowManager;
        this.isQuitting = false;
        
        this.setupEventListeners();
    }

    setupEventListeners() {
        // 应用就绪
        this.app.on('ready', () => {
            this.onAppReady();
        });

        // 所有窗口关闭
        this.app.on('window-all-closed', () => {
            this.onAllWindowsClosed();
        });

        // 应用激活（macOS）
        this.app.on('activate', () => {
            this.onAppActivate();
        });

        // 应用即将退出
        this.app.on('before-quit', (event) => {
            this.onBeforeQuit(event);
        });

        // 应用退出
        this.app.on('will-quit', () => {
            this.onWillQuit();
        });
    }

    onAppReady() {
        console.log('应用就绪');
        
        // 创建主窗口
        this.windowManager.createWindow('main');
        
        // 初始化其他服务
        this.initializeServices();
    }

    onAllWindowsClosed() {
        console.log('所有窗口已关闭');
        
        // 在macOS上，应用不会自动退出
        if (process.platform !== 'darwin') {
            this.app.quit();
        }
    }

    onAppActivate() {
        console.log('应用已激活');
        
        // 如果没有打开的窗口，创建主窗口
        if (this.windowManager.getAllWindows().length === 0) {
            this.windowManager.createWindow('main');
        }
    }

    async onBeforeQuit(event) {
        console.log('应用即将退出');
        
        if (this.isQuitting) {
            return;
        }
        
        // 取消默认退出行为
        event.preventDefault();
        
        // 执行清理操作
        try {
            await this.performCleanup();
            this.isQuitting = true;
            this.app.quit();
        } catch (error) {
            console.error('清理操作失败:', error);
            // 如果清理失败，仍然退出应用
            this.app.quit();
        }
    }

    onWillQuit() {
        console.log('应用正在退出');
        // 执行最终清理
        this.finalCleanup();
    }

    async performCleanup() {
        // 保存未保存的数据
        await this.saveUnsavedData();
        
        // 关闭所有窗口
        this.windowManager.closeAllWindows();
        
        // 停止后台服务
        this.stopBackgroundServices();
    }

    finalCleanup() {
        // 释放资源
        // 关闭数据库连接等
    }

    async saveUnsavedData() {
        // 保存草稿等未保存的数据
        console.log('保存未保存的数据');
    }

    initializeServices() {
        // 初始化后台服务
        console.log('初始化服务');
    }

    stopBackgroundServices() {
        // 停止后台服务
        console.log('停止后台服务');
    }
}

5.2 进程间通信安全

class IpcSecurityManager {
    constructor() {
        this.allowedChannels = [
            // 文章相关
            'article:create',
            'article:update',
            'article:get',
            'article:list',
            'article:delete',
            
            // 分类相关
            'category:create',
            'category:update',
            'category:get',
            'category:list',
            'category:delete',
            
            // 标签相关
            'tag:create',
            'tag:update',
            'tag:get',
            'tag:list',
            'tag:delete',
            
            // 设置相关
            'settings:get',
            'settings:update',
            'stats:get',
            
            // 窗口相关
            'window:create',
            'window:close',
            'window:minimize',
            'window:maximize'
        ];

        this.channelPermissions = {
            'article:delete': ['admin'],
            'category:delete': ['admin'],
            'tag:delete': ['admin']
        };
    }

    isChannelAllowed(channel) {
        return this.allowedChannels.includes(channel);
    }

    checkPermission(channel, userRole = 'user') {
        const requiredRoles = this.channelPermissions[channel];
        
        if (!requiredRoles) {
            return true; // 不需要权限
        }
        
        return requiredRoles.includes(userRole);
    }

    validateMessage(channel, data) {
        // 验证消息格式和内容
        switch (channel) {
            case 'article:create':
                return this.validateArticleCreate(data);
            case 'article:update':
                return this.validateArticleUpdate(data);
            // 更多验证...
            default:
                return true;
        }
    }

    validateArticleCreate(data) {
        if (!data || typeof data !== 'object') {
            return false;
        }
        
        if (!data.title || typeof data.title !== 'string') {
            return false;
        }
        
        if (!data.content || typeof data.content !== 'string') {
            return false;
        }
        
        return true;
    }

    validateArticleUpdate(data) {
        if (!data || typeof data !== 'object') {
            return false;
        }
        
        if (!data.id || typeof data.id !== 'string') {
            return false;
        }
        
        return true;
    }
}

// 使用安全管理器
const securityManager = new IpcSecurityManager();

ipcMain.handle('protected-operation', (event, channel, data) => {
    // 检查通道是否允许
    if (!securityManager.isChannelAllowed(channel)) {
        throw new Error('不允许的通道');
    }
    
    // 检查权限
    if (!securityManager.checkPermission(channel, 'user')) {
        throw new Error('权限不足');
    }
    
    // 验证消息
    if (!securityManager.validateMessage(channel, data)) {
        throw new Error('消息格式无效');
    }
    
    // 处理请求
    return handleRequest(channel, data);
});

六、性能优化与监控

6.1 IPC性能监控

class IpcPerformanceMonitor {
    constructor() {
        this.stats = {
            totalCalls: 0,
            successfulCalls: 0,
            failedCalls: 0,
            avgResponseTime: 0,
            maxResponseTime: 0,
            minResponseTime: Infinity,
            callsByChannel: new Map(),
            responseTimes: []
        };
        
        this.startTimes = new Map();
    }

    start(channel, requestId) {
        this.startTimes.set(requestId, {
            channel,
            startTime: Date.now()
        });
    }

    end(requestId, success) {
        const record = this.startTimes.get(requestId);
        
        if (!record) {
            return;
        }
        
        const responseTime = Date.now() - record.startTime;
        this.startTimes.delete(requestId);
        
        // 更新统计
        this.stats.totalCalls++;
        
        if (success) {
            this.stats.successfulCalls++;
        } else {
            this.stats.failedCalls++;
        }
        
        // 更新响应时间统计
        this.stats.responseTimes.push(responseTime);
        if (this.stats.responseTimes.length > 1000) {
            this.stats.responseTimes.shift();
        }
        
        this.stats.avgResponseTime = this.stats.responseTimes.reduce((a, b) => a + b, 0) / this.stats.responseTimes.length;
        this.stats.maxResponseTime = Math.max(this.stats.maxResponseTime, responseTime);
        this.stats.minResponseTime = Math.min(this.stats.minResponseTime, responseTime);
        
        // 更新通道统计
        if (!this.stats.callsByChannel.has(record.channel)) {
            this.stats.callsByChannel.set(record.channel, {
                calls: 0,
                totalTime: 0,
                avgTime: 0
            });
        }
        
        const channelStats = this.stats.callsByChannel.get(record.channel);
        channelStats.calls++;
        channelStats.totalTime += responseTime;
        channelStats.avgTime = channelStats.totalTime / channelStats.calls;
    }

    getStats() {
        return {
            ...this.stats,
            callsByChannel: Object.fromEntries(this.stats.callsByChannel)
        };
    }

    reset() {
        this.stats = {
            totalCalls: 0,
            successfulCalls: 0,
            failedCalls: 0,
            avgResponseTime: 0,
            maxResponseTime: 0,
            minResponseTime: Infinity,
            callsByChannel: new Map(),
            responseTimes: []
        };
        this.startTimes.clear();
    }
}

// 使用性能监控器
const monitor = new IpcPerformanceMonitor();

ipcMain.handle('monitored-operation', async (event, arg) => {
    const requestId = `req-${Date.now()}`;
    monitor.start('monitored-operation', requestId);
    
    try {
        const result = await handleOperation(arg);
        monitor.end(requestId, true);
        return result;
    } catch (error) {
        monitor.end(requestId, false);
        throw error;
    }
});

6.2 批量IPC优化

class BatchIpcHandler {
    constructor(ipcMain) {
        this.ipcMain = ipcMain;
        this.setupHandler();
    }

    setupHandler() {
        this.ipcMain.handle('batch', async (event, operations) => {
            const results = [];
            
            for (const operation of operations) {
                try {
                    const result = await this.executeOperation(operation);
                    results.push({
                        success: true,
                        id: operation.id,
                        data: result
                    });
                } catch (error) {
                    results.push({
                        success: false,
                        id: operation.id,
                        error: error.message
                    });
                }
            }
            
            return results;
        });
    }

    async executeOperation(operation) {
        const { type, payload } = operation;
        
        switch (type) {
            case 'article:create':
                return await createArticle(payload);
            case 'article:update':
                return await updateArticle(payload.id, payload.data);
            case 'article:get':
                return await getArticle(payload.id);
            case 'category:create':
                return await createCategory(payload);
            case 'tag:create':
                return await createTag(payload);
            default:
                throw new Error(`未知操作类型: ${type}`);
        }
    }
}

// 使用批量处理器
const batchHandler = new BatchIpcHandler(ipcMain);

// 渲染进程中发送批量请求
const operations = [
    { id: '1', type: 'article:create', payload: { title: '文章1', content: '内容1' } },
    { id: '2', type: 'category:create', payload: { name: '分类1' } },
    { id: '3', type: 'tag:create', payload: { name: '标签1', color: '#ff0000' } }
];

ipcRenderer.invoke('batch', operations).then(results => {
    results.forEach(result => {
        if (result.success) {
            console.log(`操作 ${result.id} 成功:`, result.data);
        } else {
            console.error(`操作 ${result.id} 失败:`, result.error);
        }
    });
});

七、总结与展望

7.1 功能回顾

本章详细介绍了进程间通信与主进程管理的设计与实现，包括：

1. IPC基础概念：单向通信、同步通信、异步通信
2. 主进程架构：窗口管理、菜单管理、IPC处理器
3. 通信最佳实践：错误处理、消息序列化、限流熔断
4. 进程管理策略：生命周期管理、安全控制
5. 性能优化：性能监控、批量操作优化

7.2 技术亮点

• 模块化设计：各个功能模块职责清晰
• 统一错误处理：提供一致的错误响应格式
• 安全控制：权限验证和消息验证
• 性能监控：实时监控IPC调用性能
• 批量操作：减少IPC调用次数，提高效率

7.3 未来扩展

未来可以考虑添加以下功能：

• 进程间共享内存：提高大数据传输效率
• IPC消息队列：支持消息持久化和重试
• 进程池管理：支持多进程并行处理
• 远程调试支持：支持远程调试主进程
• 热更新：支持应用热更新

---