Sugar-Electron

安装

npm i sugar-electron --save-dev

脚手架

npm i sugar-electron-cli -g

sugar-electron-cli init

前言

今天给大家带来一款基于Electron桌面开发平台的自研应用框架Sugar-Electron，期望能改善Electron应用稳定性和帮助开发团队降低开发和维护成本。

笔者使用Electron做桌面应用，已经有3年的时间，期间也遇到很多大大小小的坑。但总结起来，最大的问题还是应用稳定性和开发效率问题。我们期望通过这个框架，能让应用程序在这两个方面有所优化。

项目源码地址： https://github.com/SugarTurboS/Sugar-Electron

如有任何疑问，可以扫码加入微信群聊讨论

关于应用稳定性

我们知道Electron应用程序有三大基础模块。

主进程
渲染进程
进程间通信

由于我们属于多窗口（多渲染进程）的应用，所以我们会把窗口公共的服务模块都写到主进程模块，这为整个程序的稳定性埋下了隐患。

在Electron中，主进程控制了整个程序的生命周期，同时也负责管理它创建出来的各个渲染进程。一旦主进程的代码出现问题，那么会导致以下情况发生。

主进程出现未捕获的异常崩溃，直接导致应用退出。
主进程出现阻塞，直接导致全部渲染进程阻塞，UI处于阻塞无响应状态。

所以，在Sugar-Electron中，我们引入了Service进程的概念，期望将业务原来写在主进程的代码，迁移到Service进程中（本质上是渲染进程），使得这些代码导致的崩溃不会使得整个程序退出。而主进程的进程管理器可以在Service崩溃时，重启该进程并恢复崩溃前的状态，从而提高整个程序的稳定性和可用性。

关于开发效率低

Electron属于桌面开发平台提供桌面应用开发的能力框架，上手简单。但框架本身缺少约定，因此使用Electron做应用开发，系统模块会出现各种千奇百怪的划分，代码会出现多种多样的写法，这会显著的增加学习成本，降低开发人员的效率。sugar-electron按照约定进行开发，降低团队协作成本，以提升效率。

特性

内置进程间通信模块，支持请求响应、发布订阅的方式
内置进程间状态共享模块，支持状态同步变更、状态变更监听
内置进程管理模块，支持进程模块集中式管理
内置配置管理模块，支持开发、测试、生产环境配置切换
内置插件模块，支持高度可扩展的插件机制
框架侵入性低，项目接入改造成本低
渐进式开发

设计原则

一、sugar-electron一切围绕渲染进程为核心设计，主进程只是充当进程管理（创建、删除、异常监控）和调度（进程通信、状态功能桥梁）的守护进程的角色。

主进程不处理业务逻辑，这么设计的好处：

可以避免主进程出现未捕获异常崩溃，导致应用退出
避免主进程出现阻塞，引起全部渲染进程阻塞，导致UI阻塞无响应

二、sugar-electron所有的业务模块都是渲染进程。我们知道进程之间是不能直接访问的，为了让进程之间的调用就像同线程模块之间直接调用一样方便，sugar-electron提供了以下三个模块：

进程间通信模块
进程间状态共享模块
进程管理模块

三、为了保证框架核心的足够精简、稳定、高效，因此框架的扩展能力至关重要，为此sugar-electron提供自定义插件机制扩展框架能力，还可以促进业务逻辑复用，甚至于生态圈的形成。

如下是框架逻辑视图：

sugar-electron基于类微内核架构设计，如下图所示：

其框架核心有七大模块:

基础进程类BaseWindow
服务进程类Service
进程管理windowCenter
进程间通信ipc
进程间状态共享store
配置中心config
插件管理plugins

核心功能

基础进程类——BaseWindow

基础进程类BaseWindow基于BrowserWindow二次封装，sugar-electron以BaseWindow为载体，聚合了框架所有核心模块。

举个例子

使用BrowserWindow创建渲染进程

// 在主进程中.
const { BrowserWindow } = require('electron')
let win = new BrowserWindow({ width: 800, height: 600, show: false });
win.on('ready-to-show', () => {})
win.loadURL('https://github.com');

使用BaseWindow创建渲染进程

// 在主进程中.
const { BaseWindow } = require('sugar-electron');
let win = new BaseWindow('winA', {
  url: 'https://github.com' // BaseWindow 特有属性，默认打开的页面
  width: 800, ght: 600, show: false
});
win.on('ready-to-show', () => {})
const browserWindowInstance = winA.open();

服务进程类——Service

在实际业务开发中，我们需要有一个进程去承载业务进程通用模块的功能，Service为此而生。Service进程实例实际上也是渲染进程，只是开发者只需要传入启动入口js文件，即可创建一个渲染进程，且BaseWindow一样，聚合框架所有核心模块。

举个例子

// -----------------------主进程-----------------------
const service = new Service('service', path.join(__dirname, 'app.js'), true);
service.on('success', function () {
    console.log('service进程启动成功');
});
service.on('fail', function () {
    console.log('service进程启动异常');
});
service.on('crashed', function () {
    console.log('service进程崩溃'); // 对应webContents.on('crashed')
});
service.on('closed', function () {
    console.log('service进程关闭'); // 对应browserWindow.on('closed')
});

进程通信——ipc

ipc作为进程间通信核心模块，支持三种通信方式：

请求响应（渲染进程间）
发布订阅（渲染进程间）
主进程与渲染进程通信

请求响应

逻辑视图：

举个例子

// 服务进程service
const { ipc } = require('sugar-electron');  
// 注册响应服务A1
ipc.response('service-1', (json, cb) => {
    console.log(json); // { name: 'winA' }
    cb('service-1响应');
});

// 渲染进程winA
const { ipc, windowCenter } = require('sugar-electron');  

const r1 = await windowCenter.service.request('service-1', { name: 'winA' });
console.log(r1); // service-1响应
// 等同
const r2 = await ipc.request('service', 'service-1', { name: 'winA' });
console.log(r2); // service-1响应

异常

状态码 1	说明 2
1	找不到进程
2	找不到进程注册服务
3	超时

发布订阅

逻辑视图：

举个例子

// 服务进程service
const { ipc } = require('sugar-electron');
setInterval(() => {
    ipc.publisher('service-publisher', { name: '发布消息' });
}, 1000);

// winA
const { ipc, windowCenter } = require('sugar-electron');  

// 订阅
const unsubscribe = windowCenter.service.subscribe('service-publisher', (json) => {
    console.log(json); // { name: '发布消息' }
});
// 等同
const unsubscribe = ipc.subscribe('service', service-publisher', (json) => {
    console.log(json); // { name: '发布消息' }
});


// 取消订阅 
unsubscribe();
// 等同
windowCenter.service.unsubscribe('service-publisher', cb);

主进程与渲染进程间通信（进程名"main"，为主进程预留）

sugar-electron框架设计理念所有业务模块都有各个渲染进程完成，所以基本上不存在与主进程通信的功能，但不排除有主进程与渲染进程通信的场景。

所以sugar-electron进程通信模块支持与主进程通信接口，接口与渲染进程保持一致，只是主进程名占用==“main”==

举个例子

// 主进程
const { ipc } = require('sugar-electron');
ipc.response('test', (data, cb) => {
    console.log(data); // 我是渲染进程
    cb('我是主进程')
});
 
// winA
const res = ipc.request('main', 'test', '我是渲染进程');
console.log(res); // 我是主进程

进程管理——windowCenter

sugar-electron所有的业务模块都是渲染进程。我们知道进程之间是不能直接访问的，所有有了进程管理模块。

所有的渲染进程都能在windowCenter中根据进程名对应的唯一key找到对应的渲染进程，让进程之间的调用就像同线程模块之间直接调用一样方便。

举个例子

需求：winA内打开winB，并在winB webContents初始化完成后，设置窗口B setSize(400, 400)

// 主进程
const { BaseWindow, Service, windowCenter } = require('sugar-electron');
// 设置窗口默认设置，详情请参考Electron BrowserWindow文档
BaseWindow.setDefaultOption({
  show: false
});
 
// winA
const winA = new BaseWindow('winA', {
   url: `file://${__dirname}/indexA.html`
});
 
// winB
const winB = new BaseWindow('winB', {
   url: `file://${__dirname}/indexB.html`
});
 
// 创建winA窗口实例
windowCenter.winA.open(); // 等同于winA.open();

// winA
const { windowCenter } = require('sugar-electron');
const winB = windowCenter.winB;
// 创建winB窗口实例
await winB.open();
// 订阅窗口创建完成“ready-to-show”
const unsubscribe = winB.subscribe('ready-to-show', () => {
   // 解绑订阅
   unsubscribe();
  // 设置winB size[400, 400]
   const r1 = await winB.setSize(400, 400);
   // 获取winB size[400, 400]
   const r2 = await winB.getSize();
   console.log(r1, r2);
});

==备注：服务进程句柄通过windowCenter也可以获取==

进程间状态共享——store

sugar-electron是多进程架构设计，在业务系统中，避免不了多个业务进程共享状态。由于进程间内存相互独立，不互通，为此sugar-electron框架集成了进程状态共享模块。

进程状态共享模块分成两个部分：

主进程申明共享状态数据
渲染进程设置、获取共享状态数据，订阅状态变化

举个例子

// 主进程——初始化申明state
const { store } = require('sugar-electron');
store.createStore({
    state: {
        name: '我是store'
    },
    modules: {
        moduleA: {
            state: {
                name: '我是moduleA'
            }
        },
        moduleB: {
            state: {
                name: '我是moduleB'
            },
            modules: {
                moduleC: {
                    state: {
                        name: '我是moduleC'
                    }
                }
            }
        }
    }
});

// 渲染进程A，订阅state变化
const { store } = require('sugar-electron');
console.log(store.state.name); // 我是store
// 订阅更新消息
const unsubscribe = store.subscribe((data) => {
    console.log(store.state.name); // 改变state
    unsubscribe(); // 取消订阅
});
 
// moduleA
const moduleA = store.getModule('moduleA');
console.log(moduleA.state.name); // 我是moduleA
const unsubscribeA = moduleA.subscribe((data) => {
    console.log(moduleA.state.name); // 改变moduleA
    unsubscribeA(); // 取消订阅
});

// 渲染进程B，设置state
const { store } = require('sugar-electron');
await store.setState({
    'name': '改变state'
});
 
// moduleA
const moduleA = store.getModule('moduleA');
await moduleA.setState({
    'name': '改变moduleA'
});

配置——config

sugar-electron提供了多环境配置，可根据环境变量切换配置，默认加载生成环境配置。

config
|- config.base.js     // 基础配置
|- config.js          // 生产配置
|- config.test.js     // 测试配置——环境变量env=test
|- config.dev.js      // 开发配置——环境变量env=dev

流程图：

举个例子

// 主进程
const { config, start } = require('sugar-electron');
start().then(() => {
  console.log(config);
});

// 渲染进程
const { config } = require('sugar-electron');
console.log(config);

==备注：==

AppData/appName 配置文件config.json { "env": "环境变量", "config": "配置" }
sugar-electron默认根据根目录config自动初始化

插件——plugins

一个好用的框架离不开框架的可扩展性和业务复用。开发者通过plugins模块自定义插件和配置安装插件。

==使用一款插件，需要三个步骤：==

自定义封装
config目录配置问题plugins.js配置插件安装
使用插件

插件封装

// 1、自定义封装ajax插件adpter
const axios = require('axios');
const apis = {
    FETCH_DATA_1: {
        url: '/XXXXXXX1',
        method: 'POST'
    }
}
 
module.exports = {
    /**
     * 安装插件，自定义插件必备
     * @ctx [object] 框架上下文对象{ config, ipc, store, windowCenter, plugins }
     * @params [object] 配置参数
    */
    install(ctx, params = {}) {
        // 通过配置文件读取基础服务配置
        const baseServer = ctx.config.baseServer;
        return {
            async callAPI(action, option) {
                const { method, url } = apis[action];
                try {
                    // 通过进程状态共享SDK获取用户ID
                    const token = ctx.store.state.token;
                    const res = await axios({
                        method,
                        url: `${baseServer}${url}`,
                        data: option,
                        timeout: params.timeout // 通过插件配置超时时间
                    });
                    if (action === 'LOGOUT') {
                        // 通过进程间通信模块，告知主进程退出登录
                        ctx.ipc.sendToMain('LOGOUT');
                    }
                    return res;
                } catch (error) {
                    throw error;
                }
            }
        }
    }
}

插件安装

在配置中心目录plugins.js配置插件安装

config
|- config.base.js     // 基础配置
|- config.js          // 生产配置
|- config.test.js     // 测试配置——环境变量env=test
|- config.dev.js      // 开发配置——环境变量env=dev
|- plugins.js         // 插件配置文件

// 2、配置插件安装
const path = require('path');
exports.adpter = {
    // 如果根路径plugins目录有对应的插件名，则不需要配置path或package
    path: path.join(__dirname, '../plugins/adpter'),  // 插件绝对路径
    package: 'adpter',  // 插件包名，如果package与path同时存在，则package优先级更高
    enable: true, // 是否启动插件
    env: ['main', 'render'], // 插件运行环境，main在主进程安装，render在渲染进程安装
    include: ['winA'], // 插件使用范围，如果为空，则所有渲染进程安装
    params: { timeout: 20000 } // 传入插件参数
};

插件使用

// 3、使用插件——winA
const { plugins } = require('sugar-electron');
const res = await plugins.adpter.callAPI('FETCH_DATA_1', {});

启动框架

启动框架，初始化框架核心模块，且在app.isReady() === true，返回Promise.resolve();

举个例子

const { start } = require('sugar-electron');
start({
    useAppPathConfig: false, // 可选，是否从应用安装系统缓存目录%appData%/应用/config.json中读取配置合并
    basePath: '启动目录', // 可选，默认根目录
    configPath: '配置中心目录', // 可选，默认basePath/config
    storePath: '进程状态共享目录', // 可选，默认basePath/store
    windowCenterPath: '配置中心目录', // 可选，默认basePath/windowCenter
    pluginsPath: '插件目录', // 可选，默认basePath/plugins
}).then(() => console.log('app ready'));

注意事项

1、由于sugar-electron核心模块会自动判断主进程或者渲染进程环境，自动选择加载不同环境的模块，如果使用webpack打包会导致把两个环境的代码都打包进去，可能还会出现异常。

因此，如果使用webpack打包，引入sugar-electron采用如下方式：

// 主进程
const { ipc, store, ... } = require('sugar-electron/main')


// 渲染进程
const { ipc, store, ... } = require('sugar-electron/render')

API

start

启动框架，初始化框架核心模块，且在app.isReady() === true，返回Promise.resolve();

主进程API

/**
 * 自动判断app.whenReady启动框架初始化
 * @param {object} options 启动参数
 * @param {string} options.useAppPathConfig 是否从应用安装系统缓存目录%appData%/应用/config.json中读取配置合并，默认false
 * @param {string} options.basePath 启动目录，默认根目录
 * @param {string} options.configPath 配置目录，默认basePath/config
 * @param {string} options.storePath 进程状态共享目录，默认basePath/store
 * @param {string} options.windowCenterPath 窗口中心目录，默认basePath/windowCenter
 * @param {string} options.pluginsPath 插件目录，默认basePath/plugins
 * @return {Promise}
*/
start(opions)

使用举例

// -----------------------主进程-----------------------
start({
    useAppPathConfig: boolean,
    basePath: string,
    configPath: string,
    storePath: string,
    windowCenterPath: string,
    pluginsPath: string
});

BaseWindow

/**
 * 主进程调用
 * @param {string} name
 * @param {object} option
 */
new BaseWindow(name, option);

主进程API

setDefaultOptions [类方法]设置窗口默认配置

/**
 * @param {object} option 参考electron BrowserWindow
 */
setDefaultOptions(option)

open [实例方法]创建一个BrowserWindow实例

/**
 * @param {object} option 参考electron BrowserWindow
 * @return {browserWindow}
 */
open(option)

getInstance [实例方法]

/**
 * @return {browserWindow}
 */
getInstance()

isInstanceExist [实例方法]判断窗口实例是否存在

/**
 * @return {browserWindow}
 */
isInstanceExist()

publisher [实例方法]向当前窗口发布通知，可参考ipc模块

/**
 * @param {string} eventName 通知事件名
 * @param {object} param 参数
 * @return {promise}
 */
publisher(eventName, param)

subscribe [实例方法]向当前窗口订阅通知，可参考ipc模块

/**
 * @param {string} eventName 通知事件名
 * @param {function} callback 回调
 * @return {unsubscribe} 取消订阅函数
 */
subscribe(eventName, callback)

unsubscribe [实例方法]向当前窗口取消订阅通知，可参考ipc模块

/**
 * @param {string} eventName 通知事件名
 * @param {function} callback 回调
 */
unsubscribe(eventName, callback)

request [实例方法]向当前窗口发起请求，可参考ipc模块

/**
 * @param {string} eventName 请求事件名事件名
 * @param {object} param 参数
 * @param {number} timeout 超时时间
 * @return {promise}
 */
request(eventName, param, timeout)

使用举例

// -----------------------主进程-----------------------
const { BaseWindow } = require('sugar-electron');
BaseWindow.setDefaultOptions({
    width: 600,
    height: 800,
    show: false,
    ...
});
const winA = new BaseWindow('winA', { url: 'https://github.com' });
const instance = winA.open({...}); // 创建窗口
instance === winA.getInstance(); // true

Service

主进程API

/*
 * 创建服务进程
 * @param {string} name 服务进程名
 * @param {string} path 启动入口文件路径（绝对路径）
 * @param {boolean} devTool  是否打开调试工具，默认false
 */
new Service(name = '', path = '', openDevTool = false);

使用举例

// -----------------------主进程-----------------------
const service = new Service('service', path.join(__dirname, 'app.js'), true);
service.on('success', function () {
    console.log('service进程启动成功');
});
service.on('fail', function () {
    console.log('service进程启动异常');
});
service.on('crashed', function () {
    console.log('service进程崩溃'); // 对应webContents.on('crashed')
});
service.on('closed', function () {
    console.log('service进程关闭'); // 对应browserWindow.on('closed')
});

windowCenter

主进程、渲染进程API

windowCenter: object 进程集合key=进程名 value=进程实例，默认{}

使用举例

// -----------------------主进程-----------------------
const service = new Service('service', path.join(__dirname, 'app.js'), true);
const winA = new BaseWindow('winA', {});
const winB = new BaseWindow('winB', {});
windowCenter['service'] === service; // true
windowCenter['winA'] === winA; // true
windowCenter['winB'] === winB; // true
windowCenter['winA'].open(); // 创建winA窗口实例，同步调用
windowCenter['winA'].on('ready-to-show', () => {
    windowCenter['winA'].setFullscreen(true);
});
// -----------------------渲染进程-----------------------
// 渲染进程接口调用实际上是通过ipc通道通知主进程进程接口调用，所以接口异步而非同步
(async () => {
   await windowCenter['winA'].open(); // 创建winA窗口实例，异步Promise调用
   windowCenter['winA'].subscribe('ready-to-show', async () => {
       await windowCenter['winA'].setFullscreen(true);
   });
})()

ipc

主进程/渲染进程API

setDefaultRequestTimeout 设置响应超时时间

setDefaultRequestTimeout(timeout = 0);

request 请求

/**
 * @param {string} toId 进程ID（注册通信进程模块名） 
 * @param {string} eventName 事件名 
 * @param {any} data 请求参数 
 * @param {number} timeout 超时时间，默认20s * 
 * @return 返回Promise对象
 */
request(toId, eventName, data, timeout)

response 响应

/**
 * 注册响应服务
 * @param {string} eventName 事件名  
 * @param {function} callback 回调
 */
response(eventName, callback)

unresponse 注销响应服务

/**
 * @param {string} eventName 事件名  
 * @param {function} callback 回调
 */
unresponse(eventName, callback)

publisher 发布

/**
 * @param {string} eventName 事件名  
 * @param {any} param 参数
 */
publisher(eventName, param)

subscribe 订阅

/**
 * @param {string} toId BaseWindow窗口名，不传，则默认订阅所有窗口进程
 * @param {string | array} eventName 事件名 
 * @param {function} callback 回调
 * Auguments.length === 2，则表示订阅所有进程
 */
subscribe(toId, eventName, callback)

unsubscribe 取消订阅

/**
 * @param {string} toId BaseWindow窗口名，不传，则默认取消订阅所有窗口进程
 * @param {string} eventName 事件名 
 * @param {function} callback 回调
 * Auguments.length === 2，则表示取消订阅所有进程
 */
unsubscribe(toId, eventName, callback)

使用举例

// ---------------------winA---------------------
const { ipc } = require('sugar-electron');  
// 注册响应服务A1
ipc.response('get-data', (json, cb) => {
    console.log(json); // { name: 'winB' }
    cb('winA响应');
});


// ---------------------winB---------------------
const { ipc, windowCenter } = require('sugar-electron');  
const btn1 = document.querySelector('#btn1');
const { winA } = windowCenter;
btn1.onclick = () => {
    const r1 = await winA.request('get-data', { name: 'winB' });
    console.log(r1); // winA响应
    // 等同
    const r2 = await ipc.request('get-data', 'get-data', { name: 'winB' });
    console.log(r2); // winA响应
}

store

主进程API

createStore 初始化state

/**
 * @param {object} store
 */
createStore(store)

渲染进程/主进程API

setState 设置state

/**
 * 单个值设置
 * @param {string} key
 * @param {any} value
 * @return 返回Promise对象
 */
 setState(key, value)
 
 /**
 * 批量设置
 * @param {object} state
 * @return 返回Promise对象
 */
 setState(state)

subscribe 订阅当前module的值变化通知

/**
 * @param {function} cb 订阅回调
 * @return {function} 返回注销订阅function
 */
subscribe(cb)

unsubscribe 注销订阅

/**
 * @param {funtion} cb 订阅回调
 */
unsubscribe(cb)

getModule 获取module

/**
 * 获取module
 * @param {string} moduleName 模块名
 * @return {object} module
 * 返回：setState: 设置当前模块state;subscribe: 订阅;unsubscribe: 注销订阅;getModule: 获取当前模块的子模块;getModules
 */
getModule(moduleName)

getModules 获取所有modules

/**
 * @return {array} [module, module, module]
 */
getModules()

使用举例

// 主进程——初始化申明state
const { store } = require('sugar-electron');
store.createStore({
    state: {
        name: '我是store'
    },
    modules: {
        moduleA: {
            state: {
                name: '我是moduleA'
            }
        },
        moduleB: {
            state: {
                name: '我是moduleB'
            },
            modules: {
                moduleC: {
                    state: {
                        name: '我是moduleC'
                    }
                }
            }
        }
    }
});
 
// 渲染进程
const { store } = require('sugar-electron');
store.state.name; // 我是store

// 订阅更新消息
const unsubscribe = store.subscribe((data) => {
    console.log('更新：', data); // 更新：{ name: '我是store1' }
});
await store.setState({
    'name': '我是store1'
});
unsubscribe(); // 取消订阅
 
// moduleA
const moduleA = store.getModule('moduleA');
moduleA.state.name; // 我是moduleA
const unsubscribeA = moduleA.subscribe((data) => {
    console.log('更新：', data); // 更新：{ name: '我是moduleA1' }
});
await moduleA.setState({
    'name': '我是moduleA1'
});
moduleA.unsubscribe(cb); // 取消订阅

sugar-electron

Sugar-Electron

安装

脚手架

前言

关于应用稳定性

关于开发效率低

特性

设计原则

核心功能

基础进程类——BaseWindow

举个例子

服务进程类——Service

举个例子

进程通信——ipc

请求响应

举个例子

发布订阅

举个例子

主进程与渲染进程间通信（进程名"main"，为主进程预留）

举个例子

进程管理——windowCenter

举个例子

进程间状态共享——store

举个例子

配置——config

举个例子

插件——plugins

插件封装

插件安装

插件使用

启动框架

举个例子

注意事项

API

start

BaseWindow

Service

windowCenter

ipc

store

Readme

Keywords

Package Sidebar

Install

Repository

Homepage

DownloadsWeekly Downloads

Version

License

Unpacked Size

Total Files

Last publish

Collaborators

Weekly Downloads