How to build Electron applications in Webpack

This article mainly introduces the actual construction of Electron applications with Webpack. Now I will share it with you and give you a reference.

Electron allows you to use Web development technology to develop cross-platform desktop applications. It is led by Github and open source. The familiar Atom and VSCode editors are developed using Electron.

Electron is a combination of Node.js and the Chromium browser. It uses the Web page displayed by the Chromium browser as the GUI of the application and interacts with the operating system through Node.js. When you operate on a window in an Electron application, you are actually operating on a web page. When your operation needs to be completed through the operating system, the web page will interact with the operating system through Node.js.

The advantages of developing desktop applications in this way are:

1. Lowers the development threshold. You only need to master web development technology and Node.js. A large number of Web Development technologies and ready-made libraries can be reused in Electron;

2. Since the Chromium browser and Node.js are both cross-platform, Electron can write the same code on different operating systems. run.

When running an Electron application, it starts by starting a main process. The startup of the main process is achieved by executing an entry JavaScript file through Node.js. The content of this entry file main.js is as follows:

const { app, BrowserWindow } = require('electron')
// 保持一个对于 window 对象的全局引用，如果你不这样做，
// 当 JavaScript 对象被垃圾回收， window 会被自动地关闭
let win
// 打开主窗口
function createWindow() {
 // 创建浏览器窗口
 win = new BrowserWindow({ width: 800, height: 600 })
 // 加载应用的 index.html
 const indexPageURL = `file://${__dirname}/dist/index.html`;
 win.loadURL(indexPageURL);
 // 当 window 被关闭，这个事件会被触发
 win.on('closed', () => {
  // 取消引用 window 对象
  win = null
 })
}

// Electron 会在创建浏览器窗口时调用这个函数。
app.on('ready', createWindow)

// 当全部窗口关闭时退出
app.on('window-all-closed', () => {
 // 在 macOS 上，除非用户用 Cmd + Q 确定地退出
 // 否则绝大部分应用会保持激活
 if (process.platform !== 'darwin') {
  app.quit()
 }
})

After the main process is started, it will always reside in the background and run, as you can see The window obtained and operated is not the main process, but a window sub-process newly started by the main process.

The application has a series of life cycle events from startup to exit. Use the electron.app.on() function to monitor life cycle events and react at specific moments. For example, use BrowserWindow to display the main window of the application in the app.on('ready') event.

The window that is started is actually a web page. When it is started, it will load the web page address passed in loadURL. Each window is a separate web page process, and communication between windows requires the use of the main process to pass messages.

Generally speaking, developing Electron applications is very similar to developing Web applications. The difference is that the Electron operating environment has built-in browsers and Node.js APIs. When developing web pages, In addition to using the API provided by the browser, you can also use the API provided by Node.js.

Connect to Webpack

Next, make a simple Electron application. It is required to display a main window after the application is started. There is a button in the main window. Click this A new window is displayed after the button, and the web page is developed using React.

Since each window in the Electron application corresponds to a web page, two web pages need to be developed, namely the index.html of the main window and the newly opened window login.html. In other words, the project consists of 2 single-page applications, which is very similar to the project in 3-10 Managing Multiple Single-page Applications. Let's transform it into an Electron application.

The places that need to be changed are as follows:

Create a new entry file main.js for the main process in the project root directory. The content is consistent with the above mentioned;

The main window web page The code is as follows:

import React, { Component } from 'react';
import { render } from 'react-dom';
import { remote } from 'electron';
import path from 'path';
import './index.css';
class App extends Component {
 // 在按钮被点击时
 handleBtnClick() {
  // 新窗口对应的页面的 URI 地址
  const modalPath = path.join('file://', remote.app.getAppPath(), 'dist/login.html');
  // 新窗口的大小
  let win = new remote.BrowserWindow({ width: 400, height: 320 })
  win.on('close', function () {
   // 窗口被关闭时清空资源
   win = null
  })
  // 加载网页
  win.loadURL(modalPath)
  // 显示窗口
  win.show()
 }
 render() {
  return (
   <p>
    <h1>Page Index</h1>
    <button onClick={this.handleBtnClick}>Open Page Login</button>
   </p>
  )
 }
}
render(<App/>, window.document.getElementById(&#39;app&#39;));

The most critical part is to use the API provided by the electron library to open a new window in the button click event and load the address of the web page file.

The code of the page part has been modified. Next, modify the construction code. The following points need to be done in the construction here:

Build two web pages that can be run in the browser, corresponding to the interfaces of the two windows;

1. Since in The JavaScript code of the web page may call the Node.js native module or electron module, that is, the output code depends on these modules. However, since these modules have built-in support, the built code cannot package these modules.

2. It is very simple to complete the above requirements because Webpack has built-in support for Electron. You only need to add a line of code to the Webpack configuration file, as follows:

target: 'electron-renderer',

This configuration was mentioned in 2-7 Other Configuration Items-Target, which means to let Webpack Construct the JavaScript code used for the Electron rendering process, which is the web page code required for these two windows.

After the above modifications are completed, re-execute the Webpack build, and the codes required for the corresponding web pages will be output to the dist directory under the project root directory.

In order to run as an Electron application, you need to install new dependencies:

# 安装 Electron 执行环境到项目中
npm i -D electron

After successful installation, execute electron in the project directory. You will be able to successfully see the launched desktop application. The effect As shown in the picture:

The above is what I compiled for everyone. I hope it will be helpful to everyone in the future.

Related articles:

How vue springboot implements single sign-on cross-domain issues (detailed tutorial)

How to implement scroller return to the page in vue and remember the scroll position

How to view deep copy in vue

How to implement reading and writing cookies in JavaScript

How to implement multiple file downloads in WeChat applet

The above is the detailed content of How to build Electron applications in Webpack. For more information, please follow other related articles on the PHP Chinese website!