JMX（Java Management Extensions）是 Java 提供的一种用于管理和监控应用程序、系统对象及资源的技术框架。它通过 MBean（Managed Bean）实现对资源的动态管理，支持远程监控和配置调整，广泛应用于性能调优、故障排查和运维管理场景。

1.1 JMX 的核心价值

• 运行时管理：无需重启应用即可调整配置参数
• 性能监控：实时查看应用状态和性能指标
• 故障排查：通过JMX工具快速定位问题
• 运维自动化：支持脚本化管理和监控

2. 基本使用

结合 Spring 可以便捷使用：

相关注解：

• org.springframework.jmx.export.annotation.ManagedResource - 标记MBean类
• org.springframework.jmx.export.annotation.ManagedAttribute - 标记属性
• org.springframework.jmx.export.annotation.ManagedOperation - 标记操作
• org.springframework.jmx.export.annotation.ManagedOperationParameters - 标记操作参数
• org.springframework.jmx.export.annotation.ManagedOperationParameter - 标记单个参数

在Spring Boot应用中，需要启用JMX支持：

1
2
3
4
5
6
7
8
9

# application.yml
management:
  endpoints:
    web:
      exposure:
        include: "*"
  endpoint:
    jmx:
      enabled: true

或者通过JVM参数启动：

1
2
3
4

-Dcom.sun.management.jmxremote
-Dcom.sun.management.jmxremote.port=9999
-Dcom.sun.management.jmxremote.authenticate=false
-Dcom.sun.management.jmxremote.ssl=false

2.1 MBean

2.1.1 MBean 介绍

MBean（Managed Bean）是 Java 平台中用于管理应用程序组件的一种机制，属于 Java Management Extensions (JMX) 技术的核心部分。MBean 是一种标准的、可被管理的 Java 对象，
它通过暴露属性和操作来允许外部管理系统（如 JConsole 或其他监控工具）与其交互。

2.1.2 定义一个 MBean

在 Spring 框架中定义一个 MBean 非常方便，使用 ManagedResource 注解，并将目标类注册为 Bean 即可，例如：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

package com.mk.jmxdemo.jmxdemo.jmx;

import org.springframework.jmx.export.annotation.*;
import org.springframework.stereotype.Component;

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.atomic.AtomicLong;

/**
 * @author maphicalyng
 * @since 2025/10/9
 */
@ManagedResource(
        objectName = "com.mk.jmxdemo.jmxdemo.jmx:name=DataManager",
        description = "数据管理MBean，提供数据存储和统计功能"
)
@Component
public class DataManager {

    private final Map<String, String> data = new HashMap<>();
    private final AtomicLong accessCount = new AtomicLong(0);
    private boolean enabled = true;

    @ManagedAttribute(description = "获取访问次数")
    public long getAccessCount() {
        return accessCount.get();
    }

    @ManagedAttribute(description = "获取启用状态")
    public boolean isEnabled() {
        return enabled;
    }

    @ManagedAttribute(description = "设置启用状态")
    public void setEnabled(boolean enabled) {
        this.enabled = enabled;
    }

    @ManagedOperation(description = "重置访问计数器")
    public void resetAccessCount() {
        accessCount.set(0);
    }

    @ManagedOperation(description = "获取数据大小")
    public int getDataSize() {
        return data.size();
    }
}

Spring 会自动将其注册为 MBean，并暴露出去。

2.2 MBean Attribute

2.2.1 MBean 属性是什么

MBean 的属性是指该 MBean 中可以被外部访问或修改的状态信息。这些属性通常以 Java 类中的字段形式存在，并通过一组标准化的 getter 和 setter 方法对外暴露。MBean 属性的设计目的是让外部管理系统能够读取或更新 MBean 的状态，而无需直接访问其内部实现。

属性的特点

1. 命名规范：
   • 属性名称必须遵循 JavaBeans 命名规范。
   • 例如，如果属性名为 CacheSize，那么对应的 getter 方法应为 getCacheSize()，setter 方法应为 setCacheSize(int value)。
2. 只读或可写：
   • 如果只有 getter 方法，则该属性是只读的。
   • 如果同时有 getter 和 setter 方法，则该属性是可读写的。
3. 数据类型：
   • 属性的数据类型可以是基本类型（如 int、boolean）或复杂类型（如自定义类）。
   • 复杂类型的属性需要确保其类是可序列化的，以便在分布式环境中传递。
4. 元数据描述：
   • 每个属性可以通过 JMX 提供的元数据进行描述，例如属性的名称、类型、描述信息等。这些元数据可以帮助管理工具更好地理解和展示属性。

2.2.2 示例：定义一个简单的 MBean 及其属性

以下是一个简单的 MBean 示例，展示了如何定义和暴露属性：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58

package com.mk.jmxdemo.jmxdemo.jmx;

import org.springframework.jmx.export.annotation.*;
import org.springframework.stereotype.Component;

/**
 * @author maphicalyng
 * @since 2025/10/9
 */
@ManagedResource(
        objectName = "com.mk.jmxdemo.jmxdemo.jmx:name=ConfigManager",
        description = "配置管理MBean示例"
)
@Component
public class ConfigManager {

    private String appName = "JMX Demo App";
    private String version = "1.0.0";
    private boolean debugMode = false;
    private int maxConnections = 100;

    @ManagedAttribute(description = "获取应用名称")
    public String getAppName() {
        return appName;
    }

    @ManagedAttribute(description = "设置应用名称")
    public void setAppName(String appName) {
        this.appName = appName;
    }

    @ManagedAttribute(description = "获取应用版本（只读）")
    public String getVersion() {
        return version;
    }

    @ManagedAttribute(description = "获取调试模式状态")
    public boolean isDebugMode() {
        return debugMode;
    }

    @ManagedAttribute(description = "设置调试模式")
    public void setDebugMode(boolean debugMode) {
        this.debugMode = debugMode;
    }

    @ManagedAttribute(description = "获取最大连接数")
    public int getMaxConnections() {
        return maxConnections;
    }

    @ManagedAttribute(description = "设置最大连接数")
    public void setMaxConnections(int maxConnections) {
        if (maxConnections > 0) {
            this.maxConnections = maxConnections;
        }
    }
}

在这个示例中：

• version 是一个只读属性，因为只有 getVersion() 方法。
• appName、debugMode、maxConnections 是可读写属性，因为它们既有 getter 方法，也有 setter 方法。

2.3 MBean Operation

MBean 操作（MBean Operation）是 MBean 暴露给外部系统的可调用的方法。这些方法允许管理员或监控系统在应用运行时执行特定的管理性任务，比如清空缓存、重启服务、重新加载配置等。

在 Spring 中，使用 ManagedOperation 注解标注，使用 ManagedParameters 注解标记操作接收的参数，例如：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72

package com.mk.jmxdemo.jmxdemo.jmx;

import jakarta.annotation.PostConstruct;
import org.springframework.jmx.export.annotation.*;
import org.springframework.stereotype.Component;

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.atomic.AtomicLong;

/**
 * @author maphicalyng
 * @since 2025/10/9
 */
@ManagedResource(
        objectName = "com.mk.jmxdemo.jmxdemo.jmx:name=DataManager",
        description = "数据管理MBean，提供数据存储和统计功能"
)
@Component
public class DataManager {

    private final Map<String, String> data = new HashMap<>();
    private final AtomicLong accessCount = new AtomicLong(0);

    @PostConstruct
    public void init() {
        data.put("name", "maphicalyng");
        data.put("age", "18");
        data.put("gender", "male");
        data.put("email", "maphicalyng@example.com");
        data.put("phone", "1234567890");
    }

    @ManagedOperation(description = "获取指定数据")
    @ManagedOperationParameters(
            @ManagedOperationParameter(name = "key", description = "数据键")
    )
    public String getDataKey(String key) {
        accessCount.incrementAndGet();
        return data.get(key);
    }

    @ManagedOperation(description = "设置指定数据")
    @ManagedOperationParameters(
            value = {
                    @ManagedOperationParameter(name = "key", description = "数据键"),
                    @ManagedOperationParameter(name = "value", description = "数据值")
            }
    )
    public void setDataKey(String key, String value) {
        data.put(key, value);
    }

    @ManagedOperation(description = "清空所有数据")
    public void clearAllData() {
        data.clear();
    }

    @ManagedOperation(description = "获取所有数据键")
    public String[] getAllKeys() {
        return data.keySet().toArray(new String[0]);
    }

    @ManagedOperation(description = "批量设置数据")
    @ManagedOperationParameters(
            @ManagedOperationParameter(name = "dataMap", description = "数据映射（JSON格式）")
    )
    public void batchSetData(String dataMap) {
        // 这里可以解析JSON并批量设置数据
        // 实际实现需要JSON解析库
    }
}

其中：

• getDataKey 和 setDataKey 是两个 Operation，用于查看和设置 data 的特定 key 的值
• clearAllData 用于清空所有数据
• getAllKeys 用于获取所有数据键
• batchSetData 用于批量设置数据

在 jconsole 等外部工具中，会显示为一个按钮，并提供输入控件来输入调用参数，点击执行后，会执行对应 Operation 方法中的逻辑。

3. 相关工具

3.1 jconsole

JDK 自带的图形化工具，用于通过 JMX 管理 Java 系统。

上述 MBean 在 jconsole 中的操作界面为：

总览

Attributes

Operations

Notifications

3.2 jmxterm

开源的 JMX 命令行管理工具，当在无图形界面的环境中连接 JMX 时使用，项目地址：

CYCLOPSGROUP DOCS - Jmxterm

使用示例：

四条命令的说明：

1. 列出所有 MBeans 的 domain；
2. 获取 Attribute 的属性值；
3. 调用 Operation setDataKey，参数为 age、18；
4. 调用 Operation getData，参数为 age。

4. 最佳实践和注意事项

4.1 性能考虑

• 避免频繁调用：JMX 操作会消耗系统资源，避免在高频场景下使用
• 线程安全：确保 MBean 的属性和操作是线程安全的
• 异常处理：在操作中妥善处理异常，避免影响主业务逻辑

4.2 安全考虑

• 权限控制：生产环境中应该启用 JMX 认证和 SSL
• 敏感信息：避免在 JMX 中暴露敏感配置信息
• 网络隔离：限制 JMX 端口的网络访问

4.3 监控建议

• 关键指标：监控应用的核心业务指标
• 告警机制：结合监控系统设置合理的告警阈值
• 日志记录：记录重要的 JMX 操作日志

4.4 常见问题

1. 连接失败：检查 JMX 端口配置和防火墙设置
2. 权限不足：确认 JVM 参数中的认证配置
3. 性能影响：避免在性能关键路径上使用 JMX

以上。

1.AppImage 介绍

AppImage 是一种通用的 Linux 应用打包格式，旨在简化软件分发和安装过程。它允许开发者将应用程序及其所有依赖项打包成一个单独的文件，用户可以直接运行，无需复杂的安装步骤。AppImage 文件以.AppImage为后缀，支持大多数主流 Linux 发行版（如Ubuntu、Fedora、Arch Linux等），具有良好的兼容性和便携性。

1.1 AppImage 的优势

• 跨发行版兼容性：AppImage 可以在大多数 Linux 发行版上运行，无需针对不同发行版单独打包。
• 无需安装：用户可以直接运行 AppImage 文件，无需使用包管理器安装依赖项。
• 简化分发：开发者只需生成一个文件即可分发应用程序，极大简化了发布流程。

1.2 快速入门资源

• 官方网站：https://appimage.org/
• 文档：https://docs.appimage.org/
• 常见问题解答：https://discourse.appimage.org/
• 示例：https://github.com/AppImage/AppImageKit

通过 AppImage，开发者和用户都可以更轻松地管理和分发应用程序。接下来，我们将详细介绍如何将 Java 应用程序（Jar包）打包成 AppImage 格式。

2.编写应用并生成 Jar 包

Java 程序开发就按照一般方式进行，这里快速介绍一下。可以通过 maven 提供的快捷脚手架生成一个 Java 项目（目录名称为 artifactId）：

1

mvn archetype:generate -DgroupId=com.mk.tool -DartifactId=simple-tool -Dversion=1.0.0-SNAPSHOT -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false

正常编写代码，并生成一个带有全部依赖的 Jar 包，可以使用 maven-assembly-plugin 插件：

1
2
3
4
5
6
7
8
9
10
11
12
13
14

<plugin>
  <groupId>org.apache.maven.plugins</groupId>
  <artifactId>maven-assembly-plugin</artifactId>
  <configuration>
    <archive>
      <manifest>
        <mainClass>com.mk.tool.actionagent.Entry</mainClass>
      </manifest>
    </archive>
    <descriptorRefs>
      <descriptorRef>jar-with-dependencies</descriptorRef>
    </descriptorRefs>
  </configuration>
</plugin>

使用命令行生成 Jar：

1

mvn clean package assembly:single

假设输出的 Jar 包路径为：./target/simple-tool-1.0.0-SNAPSHOT-jar-with-dependencies.jar

3.使用 Jpackage 工具生成需要的资源

3.1 Jpackage 是什么

JPackage 是 Java Development Kit (JDK) 自 JDK 14 起引入的一个命令行工具，旨在简化将 Java 应用程序打包成平台特定格式的过程。这个工具允许开发者为 Windows、macOS 和 Linux 系统创建安装包或软件包，如 .msi 文件（Windows）、.dmg 文件（macOS）和 .deb 或 .rpm 文件（Linux）。使用 JPackage 可以让最终用户更方便地安装 Java 应用程序，并且可以更好地集成到操作系统的环境中，当然，JPackage 工具也支持打包 AppImage 格式。

3.1.1 主要功能

• 跨平台支持：支持生成适用于 Windows、macOS 和 Linux 的安装包。
• 自定义图标与描述：可以设置应用程序的图标以及描述信息等元数据。
• 模块化支持：不仅支持传统的 JAR 文件，还支持基于 Java 模块系统（JPMS）的应用程序。
• 依赖管理：能够处理应用程序及其运行时所需的依赖项。
• 启动器生成：自动创建启动脚本或快捷方式，使得应用更容易被启动。
• 更新机制：提供基础的支持来配置应用程序的自动更新。

3.1.2 示例用法

使用 JPackage 需要指定几个关键参数，包括输入文件的位置、输出格式、目标操作系统等。下面是一个简单的例子，展示如何使用 JPackage 来创建一个 macOS 的 .dmg 包：

1
2
3
4
5
6

jpackage --name MyApp \
         --input /path/to/myapp \
         --main-jar myapp.jar \
         --main-class com.example.MyApp \
         --type dmg \
         --icon /path/to/icon.icns

这里：

• --name 指定了应用程序的名字。
• --input 指向包含所有必要资源的目录。
• --main-jar 指出主 JAR 文件。
• --main-class 定义了程序的入口点。
• --type 设置了输出格式，在此例中为 macOS 的磁盘映像文件。
• --icon 用于指定应用图标。

3.2 创建 AppImage 需要的文件目录

执行 JPackage 命令：

1
2
3
4
5
6
7
8
9
10
11

jpackage \
    --input "./target" \
    --main-jar simple-tool-1.0.0-SNAPSHOT-jar-with-dependencies.jar \
    --main-class com.mk.tool.simpletool.Entry \
    --name simple-tool \
    --app-version "1.0.0-SNAPSHOT" \
    --vendor "MaphicalYng" \
    --description "Simple Tool，示例简单命令行工具。" \
    --copyright "Copyright $(date +%Y) MaphicalYng" \
    --type app-image \
    --dest "./packages"

命令中各个选项的作用：

• --input: 指定包含应用程序资源的目录。在这个例子中，./target是存放构建输出（如JAR文件）的目录。
• --main-jar: 指明作为主程序入口点的JAR文件名。这个JAR文件包含了应用及其所有依赖项。
• --main-class: 指定Java应用程序的主类。当启动应用时，会运行这个类中的public static void main(String[] args)方法。
• --name: 设置生成的应用程序包或可执行文件的名字。
• --app-version: 定义应用程序的版本号。
• --vendor: 应用程序供应商的信息。
• --description: 提供应用程序的简短描述。
• --copyright: 添加版权信息到应用程序元数据中。这里使用了shell命令$(date +%Y)来动态插入当前年份。
• --type: 指定要创建的打包类型。app-image表示将为Linux系统创建一个自包含的应用镜像，它可以在没有安装 Java 的情况下运行。
• --dest: 指定输出目录，即生成的软件包将被放置的位置。

执行完成之后，将会生成这样一个目录结构和文件：

这个目录就是生成 AppImage 的基础目录，但是还需要进行一些目录结构的调整，让它更匹配标准结构。

3.3 安装 AppImageTool 和 AppRun

3.3.1 简要介绍

AppImageTool 是一个用于创建 AppImage 的工具，它允许开发者将应用程序及其依赖项打包成一个可执行文件，从而在不同的 Linux 发行版上轻松分发和运行。AppRun 则是一个轻量级的运行时环境，它可以帮助用户直接从命令行启动 AppImage 文件，简化了 AppImage 的使用流程。

实际上执行 AppImage 文件就是执行了其中的 AppRun 文件，相当于是整个程序的入口。

3.3.2 下载安装

可以使用下面的脚本自动安装在项目目录中（默认下载 x86_64 架构的可执行文件，若你的环境不同可以修改其中的下载 URL），值得一提的是，这两个程序也是使用的 AppImage 格式，这何尝不是一种自举呢：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

#!/bin/sh

set -e

echo "Setting up AppImage tools..."

# 创建工具目录
TOOLS_DIR="./tools"
mkdir -p "$TOOLS_DIR"

# 从官方 Github 下载 appimagetool
if [ ! -f "$TOOLS_DIR/appimagetool" ]; then
    echo "Downloading appimagetool..."
    wget -O "$TOOLS_DIR/appimagetool" "https://github.com/AppImage/appimagetool/releases/download/continuous/appimagetool-x86_64.AppImage"
    chmod +x "$TOOLS_DIR/appimagetool"
fi

# 下载 AppRun
if [ ! -f "$TOOLS_DIR/AppRun" ]; then
    echo "Downloading AppRun..."
    wget -O "$TOOLS_DIR/AppRun" "https://github.com/AppImage/AppImageKit/releases/download/continuous/AppRun-x86_64"
    chmod +x "$TOOLS_DIR/AppRun"
fi

echo "AppImage tools setup completed!" 

3.3 调整目录结构

在正式创建 AppImage 程序包之前，还需要调整一下我们的目录结构以及生成 .desktop 文件，适配 AppRun 工具兼容的标准结构，可以直接执行脚本来生成一个符合条件的目录 appdir：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

#!/bin/sh

set -e

# 设置目录
APP_DIR="./packages/simple-tool"
APPDIR_DIR="./appdir"
TOOLS_DIR="./tools"

echo "Creating AppDir structure..."

# 清理并创建 AppDir
rm -rf "$APPDIR_DIR"
mkdir -p "$APPDIR_DIR"

# 创建标准的 usr 目录结构
mkdir -p "$APPDIR_DIR/usr/bin"
mkdir -p "$APPDIR_DIR/usr/lib"

# 复制应用文件到正确的位置
if [ -f "$APP_DIR/bin/simple-tool" ]; then
    cp "$APP_DIR/bin/simple-tool" "$APPDIR_DIR/usr/bin/"
fi

if [ -d "$APP_DIR/lib" ]; then
    cp -r "$APP_DIR/lib"/* "$APPDIR_DIR/usr/lib/"
fi

# 使用下载的 AppRun 文件
echo "Using downloaded AppRun..."
cp "$TOOLS_DIR/AppRun" "$APPDIR_DIR/AppRun"
chmod +x "$APPDIR_DIR/AppRun"

# 创建 .desktop 文件
cat > "$APPDIR_DIR/simple-tool.desktop" << EOF
[Desktop Entry]
Name=simple-tool
Comment=Simple Tool，简单的命令行工具。
Exec=simple-tool
Icon=simple-tool
Terminal=true
Type=Application
Categories=Utility;
EOF

# 复制图标
if [ -f "$APP_DIR/lib/simple-tool.png" ]; then
    cp "$APP_DIR/lib/simple-tool.png" "$APPDIR_DIR/simple-tool.png"
fi

执行成功后，生成的 appdir 目录结构如下：

现在就可以正式创建 AppImage 了。

3.4 创建 AppImage 可执行文件

执行命令：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

#!/bin/sh

set -e

# 设置目录
OUTPUT_DIR="./output"
APPDIR_DIR="./appdir"
TOOLS_DIR="./tools"
APP_VERSION="1.0.0"

echo "Building AppImage..."

# 创建输出目录
rm -rf "$OUTPUT_DIR"
mkdir -p "$OUTPUT_DIR"

# 使用 appimagetool 创建 AppImage
if [ -f "$TOOLS_DIR/appimagetool" ]; then
    "$TOOLS_DIR/appimagetool" "$APPDIR_DIR" "$OUTPUT_DIR/simple-tool-$APP_VERSION-x86_64.AppImage"
else
    echo "Error: appimagetool not found. Please setup first."
    exit 1
fi

echo "AppImage built successfully: $OUTPUT_DIR/simple-tool-$APP_VERSION-x86_64.AppImage" 

命令输出这样就是创建成功了：

同时，我们的 output 目录下多出一个可执行文件：

4.测试程序

现在，就可以像其他任何可执行文件一样，直接在命令行中执行这个文件了：

到此大功告成，可以把这个文件分发到 x84_64 架构的 Linux 机器上执行了！

以上。

在表格中，大量数据时需要进行分页显示，实现方法如下：

1.改造接口支持分页

将接口改造为支持分页的形式，一般是传入参数有current（当前页码）、pageSize（每页条目数），返回包括list（当页数据）和total（所有数据的总条目数）。

2.设置页面状态（state）

实现分页需要记录当前页码和总条目数，在跳转分页时，通知组件进行渲染。实现如下：

2.1 设置current、total、dataList和loading状态

可以将pageSize固定在项目配置中，不动态调整。

使用useState设置以上状态，current初始化为1，total初始化为0，dataList设置为空数组，loading设置为false.代码：

1
2
3
4

const [orderList, setOrderList] = useState<APP_API.Order[]>([])
const [current, setCurrent] = useState(1)
const [total, setTotal] = useState(0)
const [loading, setLoading] = useState(false)

2.2 设置searchWord和dateRange状态（可选）

其中searchWord是搜索关键词，dateRange是日期搜索范围，设置目的是，在表格进行分页跳转时，重新渲染时保留筛选条件（调用接口筛选）。

1
2

const [searchWord, setSearchWord] = useState('')
const [dateRange, setDateRange] = useState('')

3.编写加载数据的函数

编写根据当前页码和每页条目数加载更新数据的函数，用于分页跳转时的数据更新，以及首次加载时的数据加载。函数中需要包括更新状态的语句，用于更新页面的渲染，例：
​

1
2
3
4
5
6
7
8
9
10
11
12
13

const loadData = (current: number) => {
    model.setLoading(true)  // 显示加载中状态
    getOrderList(current, config.pageSize).then(response => {
      if (response.code === 200) { // 拉取数据成功，更新数据
        model.setOrderList(response.data.list)  // 更新数据列表
        model.setTotal(response.data.total)  // 更新数据总条目数
        model.setCurrent(current)  // 更新当前页码
      } else {
        message.error('拉取数据失败！')
      }
      model.setLoading(false)  // 取消加载中状态
    })
  }

4.设置表格分页

设置表格的：

• 数据源
• 加载中状态
• 分页设置
  • 默认页码
  • 默认每页条目数
  • 是否显示条目数修改器（当前逻辑中不显示）
  • 分页切换回调

代码示例：

1
2
3
4
5
6
7
8
9
10
11
12
13

<Table
      dataSource={model.driverList}  // 数据源
      pagination={{  // 分页设置
        defaultPageSize: config.pageSize,  // 默认条目数
        defaultCurrent: model.current,  // 当前页码
        showSizeChanger: false,  // 是否显示条目数修改器
        onChange: (current: number) => {  // 分页切换回调函数
          loadData(current)
        }
      }}
      loading={model.loading}  // 表格加载状态
    >
</Table>

5.设置页面数据首次初始化

进入页面时，根据当前状态刷新数据，进行数据的初始化。使用useEffect钩子进行loadData函数的调用：
​

1
2
3

useEffect(() => {
    loadData(model.current)
  }, [])  // 空数组表示只调用一次

6.测试

完成开发，进行测试。
​

• 越靠近函数越被先调用，先被调用的装饰器的返回函数，会作为参数传递给后面调用的装饰器，即此装饰器上面的装饰器。

实验代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

def need1(param: str):
    def decorate(func):
        def inner():
            return func(param)
        return inner
    return decorate


def need2(func):
    def inner(param):
        print(param + 'need2')
        return func()
    return inner


@need1('need1')
@need2
def fu():
    print('fu')


fu()

运行输出为：

1
2

need1need2
fu

其中need1装饰器需要一个具有一个参数的函数传入，need2装饰器需要一个无参函数，将两个装饰器按照上面顺序应用到一个无参函数上，可以被正确调用，说明need1正确接收到了具有一个参数的函数，即need2的返回值，证明首先调用了need2，得出越靠近函数的装饰器越被先调用。

若将两个装饰器位置调换，则输出为：

1
2
3
4

Traceback (most recent call last):
  File "test.py", line 21, in <module>
    fu()
TypeError: inner() missing 1 required positional argument: 'param'

inner被调用时缺少一个参数，即出错的位置在need2中，说明被传入need2的函数又一个参数，即need1的返回值被传入了need2中，首先调用了need1.

注意

这里的调用顺序是函数加载的时候的装饰器调用顺序，而不是这些装饰器生成函数后，各个装饰器的逻辑在生成的函数中被调用的顺序。

事实上各个装饰器的逻辑在被生成的函数中被调用的顺序是和这个顺序相反的，可以将目标函数想象成一个礼物，装饰器想象成一张张包装纸。在函数加载时最先被调用的装饰器，最为最内层包装被直接包装在礼物上，后面调用的装饰器按顺序被依次包装在上一层包装的外层，直到包装完毕。

而在装饰器生成的函数（包装好的礼物）被调用（拆开）的时候，是最外层的包装最先被撕掉，即最后被应用的装饰器中包含的逻辑最先被调用，再依次深入（拆开包装），直到目标函数（礼物）。

人工智能、机器学习和深度学习之间的关系，如下图：

人工智能有多种实现形式，机器学习只是其中的一种。在机器学习之外，早期实现方式主要是专家系统——某一领域内的专家将解决问题的方法编码进系统中，代替专家对问题进行决策。这一时期的AI也称为「符号人工智能」。

2.机器学习

通常的编程工作是，开发者将处理数据的逻辑写入程序，使程序可以按照此逻辑对输入的数据进行处理，并输出开发者所希望的答案。

机器学习所做的是，开发者提供原始数据和答案，由机器去从输入数据和答案之间学习处理逻辑，学习到输入数据和答案之间的联系。使用一张图来表示为：

我们使用输入数据和答案来训练计算机（模型），即下面的输入数据和期望输出数据。

说明

原始数据，可以理解为问题。

举个例子：我有华氏度和摄氏度的对应关系，但是我不知道他们的转换公式，我想通过机器学习的方式学习这个公式。那么，输入华氏度，计算机给出对应的摄氏度，则华氏度是输入数据，摄氏度是输出数据。

输出数据一般指计算机根据其学习情况，套用学习到的规律，依据输入数据得出的结果，即计算机计算得出的摄氏度。

期望的输出数据，是指正确答案，即正确的摄氏度。

3.深度学习

深度学习是一种从数据学习数据特征的数学框架，是机器学习的一种实现手段。深度学习的“深度”主要体现在框架的多层，每一层的输出作为下一层的输入。

4.神经网络

神经网络是深度学习的主要方式，神经网络的定义，来自维基百科：

人工神经网络（英语：Artificial Neural Network，ANN），简称神经网络（Neural Network，NN）或类神经网络，在机器学习和认知科学领域，是一种模仿生物神经网络（动物的中枢神经系统，特别是大脑）的结构和功能的数学模型或计算模型，用于对函数进行估计或近似。神经网络由大量的人工神经元联结进行计算。大多数情况下人工神经网络能在外界信息的基础上改变内部结构，是一种自适应系统，通俗地讲就是具备学习功能。现代神经网络是一种非线性统计性数据建模工具，神经网络通常是通过一个基于数学统计学类型的学习方法（Learning Method）得以优化，所以也是数学统计学方法的一种实际应用，通过统计学的标准数学方法我们能够得到大量的可以用函数来表达的局部结构空间，另一方面在人工智能学的人工感知领域，我们通过数学统计学的应用可以来做人工感知方面的决定问题（也就是说通过统计学的方法，人工神经网络能够类似人一样具有简单的决定能力和简单的判断能力），这种方法比起正式的逻辑学推理演算更具有优势。
和其他机器学习方法一样，神经网络已经被用于解决各种各样的问题，例如机器视觉和语音识别。这些问题都是很难被传统基于规则的编程所解决的。

神经网络由不同数量的层组成，层由不同数量的神经元组成，神经元是一个线性函数：

y=kx+b

其中 k 称为权重（weight），b 称为偏移（bias），这个函数构成一个神经元。

不同数量的神经元构成一个层（layer），而不同类型的神经元所组成的层，类型也不相同。如图。

图中每一列代表一个层，相邻的层之间的神经元进行连接，数据从上一层传递到下一层。每一个圆点表示一个神经元，即一个线性函数。

5.神经网络的学习过程

神经网络的学习过程就是：

通过不断地输入数据，并根据输出结果，对网络中神经元中地参数值进行自动调节，使得输入数据通过网络后的输出，可以与期望的输出尽可能地相似。调节参数的过程，称为神经网络的学习。

而这个学习过程是自动进行的，即，网络中参数的调节，是计算机自动完成的。大致基本过程为：

图中：

• 这是一个两层模型，输入层和输出层，没有中间层。
• Input X为输入数据，输入数据进入第一层（线性函数中的 x），经过计算后的输出，作为输入进入第二层，作为第二层的 x，经过计算后输出为 y’ ，作为整个模型的输出（预测结果）。
• y’ 与真实正确的数据 y 使用指定的损失函数进行比较，得出损失值（Loss score）。
  • 注：损失函数，用于衡量预测结果和真实结果之间差距的函数，不是某一个具体的函数，对于不同的问题，使用不同的损失函数。
• 优化器使用损失值来决定如何对模型中的参数进行更新，更新的目标是：使得损失值尽可能得小
  • 注：优化器，用于根据损失值来决定如何更新模型参数得算法。不是某一个具体的算法，对不不同问题，使用不同的优化器，一般在使用时，指定学习率（Learning rate），确定每一次优化中的优化幅度。
• 更新参数后，进行下一次循环，不断循环直到达到指定的循环次数，这个次数称作训练轮次（epoch）。

6.机器学习的常用工具

机器学习框架：

• Tensorflow（Google）
• PyTorch（Facebook）

编程工具：

• Anaconda（用于管理Python版本和工具包，数据科学的常用Python环境，集中管理虚拟环境）
• JupyterLab（可交互式编程环境，可以分段运行代码，在代码中嵌入Markdown，实时显示代码运行结果，数据科学常用的工具，目前也被广泛运用在教育行业中）

常见依赖库：

• CUDA（Nvidia提供的，让程序可以使用Nvidia显卡进行计算的库，AMD没有）
• CuDNN（用于深度神经网络的GPU加速库）
• NumPy（科学计算库，高性能矩阵运算）
• Pandas（处理表格数据的常用工具库）
• matplotlib（绘图工具库）

常见文件格式：

• HDF5（用于保存大型数据集）
• CSV
• Excel

前言：博主在刚接触Python的时候时常听到GIL这个词，并且发现这个词经常和Python无法高效的实现多线程划上等号。本着不光要知其然，还要知其所以然的研究态度，博主搜集了各方面的资料，花了一周内几个小时的闲暇时间深入理解了下GIL，并归纳成此文，也希望读者能通过次本文更好且客观的理解GIL。

文章欢迎转载，但转载时请保留本段文字，并置于文章的顶部 作者：卢钧轶(cenalulu) 本文原文地址：http://cenalulu.github.io/python/gil-in-python/

GIL是什么

首先需要明确的一点是 GIL并不是Python的特性，它是在实现Python解析器(CPython)时所引入的一个概念。就好比C++是一套语言（语法）标准，但是可以用不同的编译器来编译成可执行代码。有名的编译器例如GCC，INTEL C++，Visual C++等。Python也一样，同样一段代码可以通过CPython，PyPy，Psyco等不同的Python执行环境来执行。像其中的JPython就没有GIL。然而因为CPython是大部分环境下默认的Python执行环境。所以在很多人的概念里CPython就是Python，也就想当然的把 GIL归结为Python语言的缺陷。所以这里要先明确一点：GIL并不是Python的特性，Python完全可以不依赖于GIL

那么CPython实现中的GIL又是什么呢？GIL全称 Global Interpreter Lock为了避免误导，我们还是来看一下官方给出的解释：

In CPython, the global interpreter lock, or GIL, is a mutex that prevents multiple native threads from executing Python bytecodes at once. This lock is necessary mainly because CPython’s memory management is not thread-safe. (However, since the GIL exists, other features have grown to depend on the guarantees that it enforces.)

好吧，是不是看上去很糟糕？一个防止多线程并发执行机器码的一个Mutex，乍一看就是个BUG般存在的全局锁嘛！别急，我们下面慢慢的分析。

为什么会有GIL

由于物理上的限制，各CPU厂商在核心频率上的比赛已经被多核所取代。为了更有效的利用多核处理器的性能，就出现了多线程的编程方式，而随之带来的就是线程间数据一致性和状态同步的困难。即使在CPU内部的Cache也不例外，为了有效解决多份缓存之间的数据同步时各厂商花费了不少心思，也不可避免的带来了一定的性能损失。

Python当然也逃不开，为了利用多核，Python开始支持多线程。而解决多线程之间数据完整性和状态同步的最简单方法自然就是加锁。 于是有了GIL这把超级大锁，而当越来越多的代码库开发者接受了这种设定后，他们开始大量依赖这种特性（即默认python内部对象是thread-safe的，无需在实现时考虑额外的内存锁和同步操作）。

慢慢的这种实现方式被发现是蛋疼且低效的。但当大家试图去拆分和去除GIL的时候，发现大量库代码开发者已经重度依赖GIL而非常难以去除了。有多难？做个类比，像MySQL这样的“小项目”为了把Buffer Pool Mutex这把大锁拆分成各个小锁也花了从5.5到5.6再到5.7多个大版为期近5年的时间，并且仍在继续。MySQL这个背后有公司支持且有固定开发团队的产品走的如此艰难，那又更何况Python这样核心开发和代码贡献者高度社区化的团队呢？

所以简单的说GIL的存在更多的是历史原因。如果推到重来，多线程的问题依然还是要面对，但是至少会比目前GIL这种方式会更优雅。

GIL的影响

从上文的介绍和官方的定义来看，GIL无疑就是一把全局排他锁。毫无疑问全局锁的存在会对多线程的效率有不小影响。甚至就几乎等于Python是个单线程的程序。 那么读者就会说了，全局锁只要释放的勤快效率也不会差啊。只要在进行耗时的IO操作的时候，能释放GIL，这样也还是可以提升运行效率的嘛。或者说再差也不会比单线程的效率差吧。理论上是这样，而实际上呢？Python比你想的更糟。

下面我们就对比下Python在多线程和单线程下得的效率对比。测试方法很简单，一个循环1亿次的计数器函数。一个通过单线程执行两次，一个多线程执行。最后比较执行总时间。测试环境为双核的Mac pro。注：为了减少线程库本身性能损耗对测试结果带来的影响，这里单线程的代码同样使用了线程。只是顺序的执行两次，模拟单线程。

顺序执行的单线程(single_thread.py)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

#! /usr/bin/python

from threading import Thread
import time

def my_counter():
    i = 0
    for _ in range(100000000):
        i = i + 1
    return True

def main():
    thread_array = {}
    start_time = time.time()
    for tid in range(2):
        t = Thread(target=my_counter)
        t.start()
        t.join()
    end_time = time.time()
    print("Total time: {}".format(end_time - start_time))

if __name__ == '__main__':
    main()

同时执行的两个并发线程(multi_thread.py)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

#! /usr/bin/python

from threading import Thread
import time

def my_counter():
    i = 0
    for _ in range(100000000):
        i = i + 1
    return True

def main():
    thread_array = {}
    start_time = time.time()
    for tid in range(2):
        t = Thread(target=my_counter)
        t.start()
        thread_array[tid] = t
    for i in range(2):
        thread_array[i].join()
    end_time = time.time()
    print("Total time: {}".format(end_time - start_time))

if __name__ == '__main__':
    main()

下图就是测试结果

可以看到python在多线程的情况下居然比单线程整整慢了45%。按照之前的分析，即使是有GIL全局锁的存在，串行化的多线程也应该和单线程有一样的效率才对。那么怎么会有这么糟糕的结果呢？

让我们通过GIL的实现原理来分析这其中的原因。

当前GIL设计的缺陷

基于pcode数量的调度方式

按照Python社区的想法，操作系统本身的线程调度已经非常成熟稳定了，没有必要自己搞一套。所以Python的线程就是C语言的一个pthread，并通过操作系统调度算法进行调度（例如linux是CFS）。为了让各个线程能够平均利用CPU时间，python会计算当前已执行的微代码数量，达到一定阈值后就强制释放GIL。而这时也会触发一次操作系统的线程调度（当然是否真正进行上下文切换由操作系统自主决定）。

伪代码

1
2
3
4
5
6

while True:
    acquire GIL
    for i in 1000:
        do something
    release GIL
    /* Give Operating System a chance to do thread scheduling */

这种模式在只有一个CPU核心的情况下毫无问题。任何一个线程被唤起时都能成功获得到GIL（因为只有释放了GIL才会引发线程调度）。但当CPU有多个核心的时候，问题就来了。从伪代码可以看到，从 release GIL到 acquire GIL之间几乎是没有间隙的。所以当其他在其他核心上的线程被唤醒时，大部分情况下主线程已经又再一次获取到GIL了。这个时候被唤醒执行的线程只能白白的浪费CPU时间，看着另一个线程拿着GIL欢快的执行着。然后达到切换时间后进入待调度状态，再被唤醒，再等待，以此往复恶性循环。

PS：当然这种实现方式是原始而丑陋的，Python的每个版本中也在逐渐改进GIL和线程调度之间的互动关系。例如先尝试持有GIL在做线程上下文切换，在IO等待时释放GIL等尝试。但是无法改变的是GIL的存在使得操作系统线程调度的这个本来就昂贵的操作变得更奢侈了。 关于GIL影响的扩展阅读

为了直观的理解GIL对于多线程带来的性能影响，这里直接借用的一张测试结果图（见下图）。图中表示的是两个线程在双核CPU上得执行情况。两个线程均为CPU密集型运算线程。绿色部分表示该线程在运行，且在执行有用的计算，红色部分为线程被调度唤醒，但是无法获取GIL导致无法进行有效运算等待的时间。

由图可见，GIL的存在导致多线程无法很好的立即多核CPU的并发处理能力。

那么Python的IO密集型线程能否从多线程中受益呢？我们来看下面这张测试结果。颜色代表的含义和上图一致。白色部分表示IO线程处于等待。可见，当IO线程收到数据包引起终端切换后，仍然由于一个CPU密集型线程的存在，导致无法获取GIL锁，从而进行无尽的循环等待。

简单的总结下就是：Python的多线程在多核CPU上，只对于IO密集型计算产生正面效果；而当有至少有一个CPU密集型线程存在，那么多线程效率会由于GIL而大幅下降。

如何避免受到GIL的影响

说了那么多，如果不说解决方案就仅仅是个科普帖，然并卵。GIL这么烂，有没有办法绕过呢？我们来看看有哪些现成的方案。

用multiprocessing替代Thread

multiprocessing库的出现很大程度上是为了弥补thread库因为GIL而低效的缺陷。它完整的复制了一套thread所提供的接口方便迁移。唯一的不同就是它使用了多进程而不是多线程。每个进程有自己的独立的GIL，因此也不会出现进程之间的GIL争抢。

当然multiprocessing也不是万能良药。它的引入会增加程序实现时线程间数据通讯和同步的困难。就拿计数器来举例子，如果我们要多个线程累加同一个变量，对于thread来说，申明一个global变量，用thread.Lock的context包裹住三行就搞定了。而multiprocessing由于进程之间无法看到对方的数据，只能通过在主线程申明一个Queue，put再get或者用share memory的方法。这个额外的实现成本使得本来就非常痛苦的多线程程序编码，变得更加痛苦了。

用其他解析器

之前也提到了既然GIL只是CPython的产物，那么其他解析器是不是更好呢？没错，像JPython和IronPython这样的解析器由于实现语言的特性，他们不需要GIL的帮助。然而由于用了Java/C#用于解析器实现，他们也失去了利用社区众多C语言模块有用特性的机会。所以这些解析器也因此一直都比较小众。毕竟功能和性能大家在初期都会选择前者，Done is better than perfect。

所以没救了么？

当然Python社区也在非常努力的不断改进GIL，甚至是尝试去除GIL。并在各个小版本中有了不少的进步。有兴趣的读者可以扩展阅读这个Slide 另一个改进 Reworking the GIL

• 将切换颗粒度从基于opcode计数改成基于时间片计数
• 避免最近一次释放GIL锁的线程再次被立即调度
• 新增线程优先级功能（高优先级线程可以迫使其他线程释放所持有的GIL锁）

总结

Python GIL其实是功能和性能之间权衡后的产物，它尤其存在的合理性，也有较难改变的客观因素。从本分的分析中，我们可以做以下一些简单的总结：

• 因为GIL的存在，只有IO Bound场景下得多线程会得到较好的性能
• 如果对并行计算性能较高的程序可以考虑把核心部分也成C模块，或者索性用其他语言实现
• GIL在较长一段时间内将会继续存在，但是会不断对其进行改进

Reference

1. Python's hardest problem

2. Official documents about GIL

3. Revisiting thread priorities and the new GIL

只有你认为你正在做的事情是有意义的，你才会更加投入和具有热情，否则，我为什么要消耗我的生命去做一件无意义的事？有人会说，因为你需要生存，需要养家糊口。但是对于当前的选择，一定是有理由的，既然你可以从事计算机行业，那么你一定也可以从事其他能够“养家糊口”让自己不饿肚子的行业，这已经是工作的最低标准。

如今，计算机行业已经趋于成熟。并且经过21世纪以来的高速发展，计算机行业也在大多数人的认识里和高薪画上了等号，有越来越多的人转行进入计算机和互联网行业中，通过一段时间的培训，或者是自学，就可以有一份不错的薪资。当然，收入水平是衡量一个行业吸引力的重要指标，但并不是唯一指标。

计算机行业又分为两大领域：硬件和软件。但无论是哪个领域，或者大领域中的细分领域，都是未来数字世界的基础设施，而我们就像15年前的建筑工人一样，为了现在和将来的数字高楼大厦和繁华市景，进行着建筑工作。

但当我们每日进行着CRUD的时候，是否有想过我们所做的事情，到底有什么样的意义。肯定有人会说：“我才不会去思考这些虚无缥缈的东西，只需要有不错的薪资，让我过上满意的生活就可以了”。这种想法当然没错，人生在世，首先要解决的是衣食住行，对于「意义」什么的，这种哲学上的东西，一般也都是在解决了基本需求后才会思考的，仓廪实而知礼节。对于我来说，也是遵循同样的逻辑，但是一份有意义的工作，会让我更加充满动力。

对于我来说，从事计算机行业并不是一朝一夕就决定的事情，也并不完全因为相对于传统行业的高薪，我从高中就开始自学编程也许能说明这一点。从高一开始，我对计算机的兴趣渐渐浮上表面，如果说之前也对电脑感兴趣，那完全是因为想要玩游戏，大多数的男孩子都有的兴趣，而高一开始，我则对电脑的运行方式产生了兴趣，看着一行行在漆黑屏幕上的滚动的代码（当时大部分是科幻电影里出现的），就会想要去搞懂这些字符的意思。

由于这种想要在自己电脑上“滚屏”的冲动，让我开始接触到Linux——使用起来最像黑客的操作系统，并开始不停地往电脑上安装不同发行版的Linux，Ubuntu、CentOS、Kali Linux、Fedora等，在和这些发行版玩耍时，为了便于操作，我在网上买了一本Linux Shell脚本编程详解，把它带到学校，课间就会拿出来翻看并在笔记本上做笔记，搞得比上课还认真……

高一高二两年是我对编程浅尝辄止的两年，也算是野生入门了吧，现在想想如果你问我我学习的第一门编程语言是什么，我会说是Bash Shell，很奇怪吧，大部分人应该都是C语言或者Python啊……顺便一讲，我的语言学习路径是：Bash、Visual Basic、JavaScript、PHP、C、C++、Java、C#、Python、Scala，目前主力语言是Java、Python和Scala，分别对应三个用途：CRUD业务逻辑、AI（或OA）和大数据。

如果说高一高二是由于喜欢酷酷的感觉而接触计算机和编程，那么高三时我的理由变得更“宏大”了。

从小，看着美式科幻电影长大的我，对宇宙充满了兴趣，倒不是对外星人什么的兴趣（虽然也有一些），而是对于人类探索宇宙的期待。比如人类在外星球上的基地应该是什么样子的，有哪些功能，飞船使用什么动力，在宇宙里用什么武器比较有效等等。

而随着自然科学知识的增加（理科生），我渐渐认识到，宇宙这么大，地球这么小，人类这个物种最终一定会走出地球进入宇宙，而宇宙中空间大到难以想象，光是同一星系不同的星球之间就有着在地球上无法认识的距离，更不用说飞出太阳系之后了。而我们想要探索宇宙，到后来的定居其他星球，实现这些目标，就需要星际航行。鉴于外太空纷繁复杂的空间环境，例如引力影响、小行星撞击、射线危害，以及轨道的计算、应急情况的快速处理、行动的决策等，单凭人类大脑的认知能力和信息处理能力，完全没有可能达到要求的合理的速度和正确性，不说这些，单独使用大脑来进行工业生产，人类甚至无法制造出能够星际航行的宇宙飞船……（也许能否做到正确调度火车班次都是个问题，更不用说可控核聚变等能源要求了）

所以，对人类发展来说，我们需要一个智能——第二大脑，也就是计算机，来帮助我们在另一个数量级的速度上处理信息、做出决策以及精密控制，这不光是决定我们现在能否在家里不出门叫到外卖的问题，而是关乎人类未来的前途以及人类文明的能力问题。

举个例子，在不使用计算机的情况下，如何控制一座大型核电站的正常运转以及危机处理？可以让好多位操作员24小时轮流排班盯着数万个仪表板，将他们编为多个小组，当某些仪表出现异常读数时，最快速度通过小组通知所有操作员，需要进行处理操作的操作员们按照规程进行处理，处理结束后反馈给异常发出处的操作员小组，确认异常得到解除。若未解除，则需要所有操作员层层上报仪表数据，汇总到某个核电专家组处，专家组通过一本厚厚的仪表参数报表分析研判问题所在，将解决方法层层下放到各个操作小组，由操作员进行调整，问题得以解决。而这一决策过程可能需要半个小时，且不保证不会出现操作员误操作和数据误报的情况出现，专家组和操作员需要24小时轮班来确保核电站正常运行，哦对了，半小时后可能异常已经变化了，需要重新研判……或者，马上撤离……

毫无疑问，计算机的出现和大规模应用，使得人类在文明维度上，有了一个巨大的进步和更大的未来可能性。这只是在基于计算机没有智能的前提下得出的结论，而人工智能的出现，对于我们来说，意义和计算机被发明同样重大，甚至更加。

而这一切，包括AI出现后可能的其他相关跨越式发明和发现，都是以计算机的发展为基础的，那么计算机对于人类文明的重要性不言而喻。

甚至可以毫不夸张地说，在计算机出现之前和之后，人类文明是两个样貌截然不同的文明，它是文明发展的加速器和更高级文明的加载器，如果说文明在宇宙中是要被考验的话，计算机则大大增加了人类通过“大过滤器”的可能性（大过滤器理论：费米悖论的一种解释）。

科技是一把双刃剑，对于计算机这一工具的不同利用方式会造成截然不同的结果（有益或是有害），那么作为人类操控这一极具意义工具的操作员的我们（计算机行业从业者）来说，如何利用计算机为人类创造福祉、为文明开辟道路，这是值得我们每个人去思考的问题。

一、变量的定义

Scala变量使用两种方式定义：

• var

  • 使用var定义的变量的值可以被修改。

  1	var a: String = "MaphicalYng" // 格式：var <变量名>: <变量类型> = <变量值>

• val

  • 使用val定义的变量不能被修改。因为在日常对象使用中，我们很少去修改对象引用本身，而只是修改对象的属性。其次，val是线程安全的，Scala设计者推荐使用val。

  1	val a: String = "MaphicalYng" // 格式：val <变量名>: <变量类型> = <变量值>

二、数据类型

所有的类型都是对象，没有基本数据类型。

例如：

1

1.toString  // 等同于 1.toString()

这里toString是一个方法，在Scala中，没有形参的方法可以不加括号进行调用。可以对1进行方法调用，说明1在Scala中是一个对象。

注意点：

• 数据类型可以分为两大类，值类型和引用类型，分别是下面两个类的子类：
  • AnyVal：值类型的父类
  • AnyRef：引用类型的父类
• 有一个所有类的父类：根类——Any。

1.默认类型

整数类型默认为Int类型，浮点型默认为Double类型。Scala会自动将低精度转换为高精度，例如Float类型的值可以赋给Double类型的值，但不能相反。

2.浮点数精度

Float精度为点后6位，多位会丢失，一般使用Double因为精度高。

三、数据类型体系图

四、字符类型

1.Char类型

Char类型为一个Unicode字符，可以使用正数表示，范围在U+0000 - U+FFFF。可以当作整数进行运算。

2.赋值逻辑

将一个表达式和一个常量赋值给一个变量时，逻辑不同：

• 表达式：

  • 编译器在将表达式给变量赋值时，会先进行表达式的计算，此时会进行两个工作：（1）类型转换；（2）范围判断。所以当表达式的值为一个高精度类型时，就不能将此表达式的值赋值给一个低精度类型，典型例子：

  1	var a: Char = 97 + 1 // 报错

• 常量：

  • 编译器将常量给变量赋值时，只会进行范围的判断，即常量值在变量类型允许的范围中即可，而不会进行类型的判断，此时可以将高精度的常量赋值给低精度类型的变量，典型例子：

  1	var a: Char = 98 // 正常运行

五、Unit类型、Null类型和Nothing类型

• Unit类型相当于Java中的void，表示空值，此类型只有一个值：()

• Null类型是所有AnyRef类型的子类，只有一个值：null。可以赋值给任意引用类型（AnyRef），但不能赋值给值类型（AnyVal）。

• Nothing类型是所有类型的子类，可以赋值给所类型（Any），开发中可以将Nothing返回给任何函数调用或类型变量。

六、变量名称的格式

和Java的变量命名风格基本相同，其中不同的是：

• 首字符可以是操作符（+-*/），但若首字母是操作符，则后续必须也是操作符，且至少跟1个，操作符不能出现在变量名的中间或最后。
• 关键字也可以作为变量名，例如true，使用反引号（``）包括起来即可。

七、变量支持代码块赋值

在给变量赋值时，可以使用一个大括号将一些代码括住，这些代码的执行结果作为变量的值赋给变量，例：

1

var a1: Int = { 1 + 1 }

八、表达式的值

Scala中任意表达式都有返回值，表达式可以是一个代码块，使用大括号括住，具体的值取决于表达式代码块的最后一行内容。

九、for循环

Scala中的循环和Java中有较大差异，Scala中有3种for循环：前后范围闭合的循环、前闭合后开放的循环、对可遍历对象的循环。

（1）前后范围闭合的循环

1
2
3

for (i <- start to end) {
  println(i) 
}

此种方式会将start和end都包括进去，打印值为start到end。

（2）前闭合后开放的循环

1
2
3

for (i <- start until end) {
  println(i) 
}

此种方式会将start包括进去，而不会包括end，打印值为start到end-1。数据范围部分也可以使用Range(start, end)替换。

（3）对可遍历对象的循环

1
2
3
4

val list: List[Int] = List(1, 2, 3) 
for (i <- list) {
  println(i)
}

此种方式会将list的值遍历打印出来。

1.循环守卫

循环守卫是一句在for循环中的判断语句，当此语句判断为true时，会进入循环体中执行，若判断为false，会跳过这次循环，进入下一次循环。

1
2
3

for (i <- start to end if i != 2) {
  println(i)
}

此处打印的值为（start=1，end=3）：1，3，跳过了2.

2.引入变量

可以在循环头部语句中加入变量，例：

1
2
3

for (i <- start to end; j = 5 - i) {
  println(j)
}

次数会引入变量j，打印结果为（start=1，end=3）：4，3，2.

3.嵌套循环

在循环头部写入嵌套循环，例：

1
2
3
4

for (i <- start to end; j <- i to end) {
  println(i)
  println(j)
}

相当于等价代码：

1
2
3
4
5
6

for (i <- start to end) {
  for (j  <- i to end) {
    println(i)
    println(j)
  }
}

4.返回值

for循环可以有返回值，使用yield关键字可以将返回值存储到一个Vector集合中。一个常用应用方式是，将一堆数据经过业务逻辑处理之后形成新的数据集合，或者进行多次处理形成集合，示例代码：

1
2
3
4
5
6
7
8

val list1: List[Int] = List(1, 2, 3, 4, 5, 6, 7, 8, 9)
val res = for (i <- list1) yield {
  if (i % 2 == 0) {
    i * 2
  } else {
    i * 3
  }
}

上述代码功能为：将list1列表中的所有偶数扩大2倍，奇数扩大3倍，并存储在新的集合中。

注：for的小括号可以换为大括号并换行写条件。

十、break和continue

Scala中没有break和continue关键字，而是使用其他方式替代其功能。

1. break

使用函数util.control.Breaks.break以及高阶函数util.control.Breaks.breakable来实现break关键字的功能，示例代码：

1
2
3
4
5
6
7

breakable{
  for (i <- Range(1, 20)) {
    if (i == 6) {
      break()
    }
  }
}

break()函数会抛出一个breakException，而高阶函数breakable函数会catch这个异常，实现跳出循环的效果。

2. continue

使用循环守卫或者循环体内的if判断来实现continue的效果，示例代码：

1
2
3

for (i <- Range(1, 20) if i != 14) {
  println(i)
}

上述代码表示当i不等于14时进入循环体，实现了当i等于14时执行continue的效果。

第二种方式是使用循环体内部的if判断，实例代码为：

1
2
3
4
5

for (i <- Range(1, 20)) {
  if (i != 14) {
    println(i)
  }
}

十一、函数的定义

基本语法：

def 函数名([参数名: 参数类型, …])[[: 返回值类型] =] {  语句…  return 返回值}

关于返回值：

• : 返回值类型 =
  • 表示有返回值，且返回值类型确定
• =
  • 表示返回值类型不确定，需要使用类型推导
• （空）
  • 表示没有返回值，return无效

1.函数定义位置

函数定义位置不影响其作用域，在方法中定义方法，可以和其他方法同等使用。

2.函数参数的默认值

函数的参数可以有默认值，在调用函数时，可以不给实参，函数将使用默认值；若只想修改部分参数的值，可以使用带名参数，指定参数名称为参数赋值。代码示例：

1
2
3
4
5
6

def databaseConnect(ip: String = "127.0.0.1", port: Int = 3306,
                    user: String = "root", password: String = "root"): Unit = {
  println(ip + port + user + password)
}
// 调用，当需要不按顺序修改参数的值时，可以指定参数名称赋值
databaseConnect("192.168.1.2", password = "admin123")

注：Scala函数的形参默认是val类型，因此不能在函数中修改。

3.可变参数

Scala函数支持可变参数，使用星号表示，例：

1
2
3
4
5

def func1(args: Int*): Unit = {
  for (i <- args) {
    print(i)
  }
}

其中args可以接受多个参数，类型都为Int，args为一个序列，包含了多个参数的值。可以和普通参数一同使用，但使用时可变参数一定放在最后。调用方法：

1

func1(1, 2, 3, 4, 5, 6, 7, 8, 98)  

4.过程

返回值类型为Unit的函数称为过程。

十二、函数的递归

递归函数不能自动判断返回类型，必须指定返回的数据类型。

十三、惰性函数

一个有返回值的函数，当它被调用且返回值被赋值给一个被声明为lazy的val类型时，这个函数将的执行将被推迟，直到这个val类型被使用时，函数才会被执行。在此之前，即使存在赋值语句，函数仍不会被执行。代码示例：

1
2
3
4
5
6
7

def t2(n: Int): Int = {
  println("函数被执行")
  n * 2
}
lazy val result: Int = t2(200)
println("赋值语句结束")
println(result)

这段代码的执行结果为：

赋值语句结束函数被执行400

即result被赋值时，t2函数并不会立即执行，而是在使用result的值时才会被执行。

注：lazy关键字只能用于val类型的值，不能修饰var类型的变量。当lazy修饰一个变量时，该变量值的分配也会被推迟。

十四、异常的类型

Scala异常体系沿用了Java的异常体系，Java的各种异常类型被Scala使用。

十五、异常的处理

Scala中也使用try和catch来捕获和处理异常，但是用法和Java不尽相同，捕获和处理异常的代码示例如下：

1
2
3
4
5
6
7
8
9
10
11
12

def mayException(): Int = {
  5 / 0
}
try { 
  mayException()
} catch {
  case e: ArithmeticException => println(e.getMessage)
  case e: Exception => {
    println("捕获了一个异常")
    e.printStackTrace()
  }
}

上述代码使用try和catch捕获并处理了一个算数异常，在catch块中，Scala使用case关键字来捕获异常，使用=>关键字来声明处理异常的代码，这里可以是单行代码也可以是代码块。可以添加finally块，此块中的代码无论异常捕获发生与否都会执行。

1.声明某个方法可能抛出异常

使用throw注解标注方法来声明这个方法可能抛出异常：

1
2
3
4

@throws(classOf[ArithmeticException])
def mayException(): Int = {
  5 / 0
}

其中classOf[ArithmeticException]相当于Java中的ArithmeticException.class。

十六、面向对象编程

1.Scala类的属性和Java的关系

Scala中的类的属性默认都是private，而在底层Java字节码中，生成了对应的public的getter和setter方法。

Scala中的类默认权限修饰符是public，不能显式添加public修饰符，且一个类文件中可以包含多个类，且全部可以为public。

2.属性定义

Scala在类中定义属性时，需要显式初始化，而不能像Java中声明后不进行初始化，可以根据初始化的值进行自动类型判断。

如果初始化的值为null，则一定要加类型，否则属性的类型将被自动推断为Null。

若需要为各个类型的变量赋值默认值，使用下划线“_”进行赋值，下划线为各个类型赋值的默认值见表：

3.对象

Scala对象内存布局和Java相同，栈中的引用对象的变量保存指向堆中对象的内存地址。

使用new关键字进行对象的实例化，对于构造器没有形参的类，可以不加括号。

4.类

Scala中的类定义使用class关键字，构造器声明在class关键字类名后面，其成员变量使用var或者val在类的块中进行声明，声明为private的属性使用getter和setter进行外部访问，声明方法和Java不同，示例代码：

1
2
3
4
5
6
7
8
9
10

class TestClass(left: String, right: String) {
  private var _pp:  String =  _
  def pp = _pp
  def pp_=(newValue: String): Unit = {
    _pp = newValue
  }
  def greet(name:  String):  Unit = {
    println(left + name + right)
  }
}

注：

• 在TestClass后面的参数列表为默认构造器（主构造器）的形参列表，当参数名称前不加var或val时，其权限为private，添加var或val时，其权限为public。
• 权限为private的属性，getter方法名为属性名称；setter方法名为属性名_=。在调用时，可以直接使用等于号对属性值进行赋值，而不用显式调用函数名称。例：

1
2

val t = new TestClass(left = "left", right = "right")
t.pp = "?????"

• 写在类名后面的构造器称为主构造器，在类定义中的方法名为this的构造器为辅助构造器。
• 主构造器在执行时会调用类定义中的所有语句，所以可以在定义类时进行属性的处理或者其他工作。
• Scala通过构造器形参列表的不同来区分不同的构造器，辅助构造器在定义时必须显式调用主构造器（直接调用或调用其他调用了主构造器的构造器）。
• 为了和Java的可互操作性，属性可以使用@BeanProperty注解标注，用于生成和Java兼容的getXxx和setXxx方法，与原有的Scala的getter和setter方法可以共存。

5.类的继承

Scala和Java相同，都是只能单继承，使用extends关键字集成基类。

6.object

Scala中不仅有class关键字来声明一个类，还有object关键字来声明对象类型。对象类型指的是这个对象类型定义所代表的类的单例对象。

Objects are single instances of their own definitions. You can think of them as singletons of their own classes.

在编译后的Java字节码中，表现为一个伴生类，我们在程序中使用的是伴生类的实例化对象。

Scala程序的入口声明在一个object中，方法名为main，参数列表为字符串数组，例：

1
2
3
4

object Exec {
  def main(args:  Array[String]): Unit = {
  }
}

7.trait

trait中文名为特质，Scala中的trait相当于Java中的interface，用于在类之间共享接口和属性，但它不能被实例化。

十七、包机制

1.包的声明

Scala中的包比Java中更灵活，有三种声明包的方式：

第一种：

1
2

package cn.maphical.modules
class PackageImport {}

第二种：

1
2
3

package cn.maphical
package modules  
class PackageImport{}  

第三种：

1
2
3
4
5

package cn.maphical {
  package modules {
    class PackageImport {}
  }
}

因此可以在同一个文件中声明不同的包，更加灵活。

子包可以使用父包中的内容，而不用显式引入。

就近原则

如果有两个相同名称的类，不使用包路径直接引用，则会优先使用本包中的类，由近及远。

2.包对象

一个包对象（package object）是对包功能的补充。现有一个包cn.maphical.modules，定义这个包的包对象，在其父包cn.maphical中定义package object modules，具体代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

package cn.maphical
package object modules {
  val name = "Scala"
  def sayHi(): Unit = {
    println("HI  from package object")
  }
}
package modules {
  object Test {
    def main(args: Array[String]): Unit = {
      println("name="  + name)
      sayHi()
    }
  }
}

在cn.maphical包中定义了modules的包对象后，其内部的变量和方法都可以在modules包中使用了。

包对象的底层机制

使用反编译工具对上述代码进行反编译，可以得出：包对象在字节码中的存在形式为名为package和package$的两个类，package$中存在一个静态对象，此对象的方法被Test类中的main方法调用，反编译后的代码如下：

文件名：package$.class

1
2
3
4
5
6
7
8
9
10
11

package cn.maphical.modules;
public final class package$ {
  public static final package$ MODULE$ = new package$();
  private static final String name = "Scala";
  public  String name() {
    return name;
  }
  public void sayHi() {
    scala.Predef$.MODULE$.println("HI  from package object");
  }
}

文件名：package.class

1
2
3
4
5
6
7
8
9
10

package cn.maphical.modules;
import scala.reflect.ScalaSignature;
public final class  package {
  public static void sayHi() {
    package$.MODULE$.sayHi();
  }
  public static String name() {
    return package$.MODULE$.name();
  }
}

文件名：Test$.class

1
2
3
4
5
6
7
8
9
10
11

package cn.maphical.modules;
public final class Test$ {
  public static final Test$ MODULE$ = new Test$();
  public void main(String[] args) {
    scala.Predef$.MODULE$.println((newStringBuilder(5))
                                  .append("name=")
                                  .append(package$.MODULE$.name())
                                  .toString());
    package$.MODULE$.sayHi();
  }
}

Test$中的main方法调用了package$中静态对象的各种方法，这些方法都是在Scala包对象中定义的。

包对象中可以定义任何内容，而不仅仅是变量和方法。 例如，包对象经常用于保存包级作用域的类型别名和隐式转换。 包对象甚至可以继承 Scala 的类和特质。

按照惯例，包对象的代码通常放在名为 package.scala的源文件中。

3.伴生类和伴生对象

在一个文件中出现了同名的类（class）和对象（object）时，class称为伴生类，object称为伴生对象。由于Scala中没有static关键字，为了和Java兼容（Java有static关键字），需要将静态内容写在伴生对象中，非静态内容写在伴生类中。

1
2
3
4
5
6
7
8

class ClassAndObject {
  private val text = "Scala"
}
object ClassAndObject {
  def test(c: ClassAndObject): Unit = {
    println(c.text)
  }
}

伴生对象可以访问伴生类中的私有方法和属性。

4.包访问权限

Scala中的包访问权限与Java稍有不同，Scala中没有public关键字，其默认的方法和属性权限为public。

• private：私有权限，只在类的内部和伴生对象中可以使用。
• protected：受保护权限，只能子类访问，与Java不同，同包不能访问。

访问权限的扩大：

protected和private关键字可以手动扩大权限，指定能够访问此内容的包：

1

private[modules] val text = "Scala"

上述代码表示，text属性在private基础上，对modules包以及它的子包有可访问权限。

5.包的引入

与Java不同的点为：

• import语句可以不出现在文件头部，可以在需要时再引入，但其作用域为其被包含的大括号。
• 引入所有包，使用下划线（_）
• 使用选择器导入部分包部分类，例：import scala.collection.mutable.{HashMap, HashSet}，即导入了HashMap和HashSet这两个类
• 将导入的类重命名，例：import java.util.{HashMap => Map}，将HashMap重命名为Map

十八、柯里化

在计算机科学中，柯里化（Currying）是把接受多个参数的函数变换成接受一个单一参数（最初函数的第一个参数）的函数，并且返回接受余下的参数且返回结果的新函数的技术。这个技术由 Christopher Strachey 以逻辑学家 Haskell Curry 命名的，尽管它是 Moses Schnfinkel 和 Gottlob Frege 发明的。

——百度百科

Scala中的函数柯里化使用多个参数列表实现，一个函数可以有多个参数列表，而这些参数列表不需要必须同时提供。在只提供一个参数列表的实参时，函数返回带有这些参数的值的新函数，此新函数可以接受剩余的参数列表，此函数可以作为一个普通函数使用，并返回正确的值。

代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

object CurryingTest {
  def curringTest(seq: List[Int])(func: (Int, Int) => Int): Int = {
    var result = seq.head
    for (item <- seq; if item != seq.head) {
      result = func(result, item)
    }
    result
  }
  def main(args: Array[String]): Unit = {
    val cat = new Cat
    val list: List[Int] = List[Int](1, 2, 3, 4, 5, 6, 7)
    val result = curringTest(list) _    // 这里使用下划线代替没有提供实参的参数列表
    println(result(_ * _))
  }
}

上述代码中的result既是curryingTest函数在接受了一个List后形成的函数，此函数可以作为一个新的函数进行调用，并接受原有函数的未提供参数列表作为其参数列表。

十九、内部类

Scala的内部类和Java不同之处在于，Java中在某类的内部定义的类，是此类的成员变量，和外部类绑定。而Scala中在某类内部定义的类，和此类的对象绑定，即每个此类实例化产生的每个对象都有一个此内部类的定义，不同对象的此内部类是“不同的类型”。

例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

object InnerClass {
  def main(args: Array[String]): Unit = {
    val a = new InnerClassTest
    val b = new InnerClassTest
    val innerA = a.newInnerA
    val innerB = b.newInnerA
    a.setInnerInst(innerA)  // 正常赋值
    a.setInnerInst(innerB)  // 非法赋值
  }
}
class InnerClassTest {
  class InnerClassA {}
  var innerClassInst: InnerClassA = _
  def newInnerA = new InnerClassA
  def setInnerInst(inst: InnerClassA): Unit = this.innerClassInst = inst
}

上述中将innerB对象赋值给对象a的成员变量时出错，原因是innerA和innerB不是同一个类型，它们的类型分别是：a.InnerClassA和b.InnerClassA（和对象绑定）。

一、POM引入Activiti依赖

**文件名：**pom.xml

**类型：**Maven项目配置

**作用：**引入Activiti7库

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

<properties>
    <activiti.version>7.1.0.M6</activiti.version>
</properties>

<dependencies>
    <dependency>
        <groupId>org.activiti</groupId>
        <artifactId>activiti-engine</artifactId>
        <version>${activiti.version}</version>
    </dependency>

    <dependency>
        <groupId>org.activiti</groupId>
        <artifactId>activiti-spring</artifactId>
        <version>${activiti.version}</version>
    </dependency>

    <dependency>
        <groupId>org.activiti</groupId>
        <artifactId>activiti-bpmn-model</artifactId>
        <version>${activiti.version}</version>
    </dependency>

    <dependency>
        <groupId>org.activiti</groupId>
        <artifactId>activiti-bpmn-converter</artifactId>
        <version>${activiti.version}</version>
    </dependency>

    <dependency>
        <groupId>org.activiti</groupId>
        <artifactId>activiti-json-converter</artifactId>
        <version>${activiti.version}</version>
    </dependency>

    <dependency>
        <groupId>org.activiti</groupId>
        <artifactId>activiti-bpmn-layout</artifactId>
        <version>${activiti.version}</version>
    </dependency>
</dependencies>

二、注册Activiti相关的Bean

**文件名：**ApplicationConfiguration.java

**类型：**Spring配置注解

**作用：**注册ServiceBean需要使用的SpringProcessEngineConfiguration和ProcessEngineFactoryBean

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

import org.activiti.spring.ProcessEngineFactoryBean;
import org.activiti.spring.SpringProcessEngineConfiguration;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

import javax.sql.DataSource;

@Configuration
@Order(300)
public class ApplicationConfiguration {
    private Logger logger = LoggerFactory.getLogger(ApplicationConfiguration.class);
    private DataSource dataSource;
    private PlatformTransactionManager transactionManager;

    public ApplicationConfiguration(DataSource dataSource, PlatformTransactionManager transactionManager) {
        this.dataSource = dataSource;
        this.transactionManager = transactionManager;
    }

    @Bean
    public SpringProcessEngineConfiguration processEngineConfiguration() {
        logger.info("注册Activiti流程引擎配置……");
        SpringProcessEngineConfiguration springProcessEngineConfiguration = new SpringProcessEngineConfiguration();
        springProcessEngineConfiguration.setDataSource(dataSource);
        springProcessEngineConfiguration.setTransactionManager(transactionManager);
        springProcessEngineConfiguration.setDatabaseSchemaUpdate("true");
        return springProcessEngineConfiguration;
    }

    @Bean
    public ProcessEngineFactoryBean processEngine() {
        logger.info("注册Activiti流程引擎……");
        ProcessEngineFactoryBean processEngineFactoryBean = new ProcessEngineFactoryBean();
        processEngineFactoryBean.setProcessEngineConfiguration(processEngineConfiguration());
        return processEngineFactoryBean;
    }
}

**文件名：**ActivitiConfiguration.java

**类型：**Spring配置注解

**作用：**注册各个ServiceBean，其中的Order注解确保在ProcessEngineBean被创建之后再执行此配置中各种服务Bean的创建。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

import org.activiti.engine.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.annotation.Order;

@Configuration
@Order(301)
public class ActivitiConfiguration {
    private Logger logger = LoggerFactory.getLogger(ActivitiConfiguration.class);
    private ProcessEngine processEngine;

    public ActivitiConfiguration(ProcessEngine processEngine) {
        this.processEngine = processEngine;
    }

    @Bean
    public RepositoryService repositoryService() {
        logger.info("注册Activiti资源服务……");
        return processEngine.getRepositoryService();
    }

    @Bean
    public RuntimeService runtimeService() {
        logger.info("注册Activiti运行时服务……");
        return processEngine.getRuntimeService();
    }

    @Bean
    public TaskService taskService() {
        logger.info("注册Activiti任务服务……");
        return processEngine.getTaskService();
    }

    @Bean
    public HistoryService historyService() {
        logger.info("注册Activiti历史服务……");
        return processEngine.getHistoryService();
    }
}

以上。

通过Maven导入Kafka Client库：

在项目的POM中导入：

1
2
3
4
5
6
7
8
9
10

<dependency>
<groupId>org.apache.kafka</groupId>
<artifactId>kafka-clients</artifactId>
<version>2.5.0</version>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-simple</artifactId>
<version>1.7.9</version>
</dependency>

导入slf4j-simple用于解决org.slf4j.impl.StaticLoggerBinder无法加载的错误，也可以引入其他日志库。

二、发布消息

实例化一个java.util.Properties类，写入服务器地址和序列化反序列化的类配置：

1
2
3
4

Properties p = new Properties();  
p.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "192.168.1.228:9092");
p.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class);
p.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class);  

实例化一个KafkaProducer，Properties作为参数传入：

1

KafkaProducer<String,String> kafkaProducer = new KafkaProducer<>(p);

实例化一个ProducerRecord，第一个参数为Topic名称，第二个参数为消息体：

1

ProducerRecord<String,String> record = new ProducerRecord<>(topic, msg);

使用KafkaProducer发送这个Record：

1

kafkaProducer.send(record);

全部发送完成后调用close方法关闭这个Producer。

三、订阅消息

实例化Properties类，在上面代码片段基础上加一个消费者的分组名称：

1
2
3
4
5

Properties p = new Properties();
p.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, "192.168.1.228:9092");
p.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class);
p.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class);
p.put(ConsumerConfig.GROUP_ID_CONFIG, "MKMTest");    //消费者分组名称

实例化一个KafkaConsumer，Properties作为参数传入，并订阅Topic：

1
2

KafkaConsumer<String,String> kafkaConsumer = new KafkaConsumer<>(p);
kafkaConsumer.subscribe(Collections.singletonList(topic));    //订阅消息  

在循环中获取消息，使用kafkaConsumer.poll方法获取消息数组，并通过循环读取每个消息：

1
2
3
4
5
6
7

while (true) {
ConsumerRecords<String,String> records = kafkaConsumer.poll(Duration.ofMillis(500));
for (ConsumerRecord<String,String> record : records){
System.out.println(String.format("topic:%s, offset:%d, 消息:%s",
                                     record.topic(), record.offset(), record.value()));
}
}

其中，record的三个方法分别返回：

• topic：消息来源主题
• offset：消息在分区中的偏移
• value：消息的值

一、管理用户

在Identity Management应用中，用户管理分为3个部分（Administrator）：

• 用户的创建和修改
• 用户组的创建的管理
• 自己的资料管理

在创建流程之前首先进行人员用户的创建，然后在流程制作中即可将任务委托给各个用户。用户由管理员创建，管理员初始密码为：admin，test。普通用户在用户管理页面中只能管理自己的资料。

创建用户组之后可以将用户添加进入组中，在流程中可以使用组来进行任务的分配。

二、管理流程

在主页面的Kickstart App是用来制作流程和发布流程的应用。包括4各部分：Processes、Forms、Decision Tables和Apps。

1.Processes部分

这个部分用来创建流程，使用可视化编辑器来编辑BPM流程图，且包括查看和导出功能。

2.Forms部分

这个部分用来创建表单，表单是在流程中用来收集信息的，流程中的事件如果需要用户填写信息，可以在流程事件中的Referenced Form属性绑定一个创建好的表单，那么当流程被执行且执行人在查看此任务时，表格会显示出来供其填写。

关于表单和流程变量的结合使用

表格中填写的项可以在流程中被用作流程变量，在流程图制作中使用UEL表达式访问。在使用UEL表达式时，所使用的流程变量的名称就是表单中每一项的id。

表单中的各种组件

在创建表单时，有几种组件可以使用：

下面将这几种组件的用途分别描述一下：

3.Decision Tables部分

创建后在流程中使用，用来帮助流程根据一系列的变量的值进行决策的表格，用户通过设置此表格中的左边输入变量的状态来设置相应的右边一栏的输出变量的值，这些值可以在流程中的后续环节中被使用。

4.Apps部分

用来发布制作好的流程模型，创建一个App并选择与之绑定的流程模型后，填写一些基本信息即可发布，发布之后所有用户都可查看并在App中启动流程和完成任务。

流程模型更新之后，原有的App如果不重新发布就不会应用新的更改。

三、使用流程进行工作

发布了App后就可以使用流程了，包括发起新流程实例、查看当前用户的待办任务、处理待办任务等，这些操作都可以通过主页面的Task应用来实现。在Task中可以查看到所有App的待办任务和流程实例，也可以选择不同的App图标进入不同的App中查看特定App的任务和流程实例等。

Task应用中包括两个部分。

1.Tasks部分

在Tasks部分中，可以查看所有的待办任务，并且可以在其中完成任务（填表单等）。

可以脱离流程实例创建新任务，并将任务委托给不同的用户，包括自己。

2.Processes部分

Processes部分可以查看当前用户参与的所有流程实例，在流程实例中查看历史活动信息和每个参与者的操作详情、表单填写信息等。

在这里，用户可以发起新的流程实例，也可以将自己发起的流程实例进行删除操作。

• WordPress 是动态框架，每次运行都要动态生成内容（即使有缓存插件还是需要运行 PHP 脚本），不仅让网站访问的速度降低了，而且我觉得这种可以通过用户名和密码认证来直接在 Web 页面上获取网站管理权限的机制，不如直接部署 HTML 静态页面安全（毕竟静态页面不用运行 PHP 代码）；
• WordPress 在写文章的时候只能开着浏览器在线上写，文章数据也只能保存在服务器中，对于之前由于服务器无法登录而损失了宝贵数据的我来说，文章数据还是放在本地更加放心。另外，将文章从 WordPress 导出来比较困难，平时写的一些文章我也会将它们发布到简书、公众号上等，没有文章的 Markdown 文件是比较麻烦的一件事。

综上所述，既能使用静态文件生成网站，又能为我在本地保留 Markdown 文件的个人博客框架，那就首选 Hexo 了，至于为什么不选其他的静态框架，是因为我同学的博客也是用 Hexo 搭建的，所以我对这个比较熟悉。

下面就开始讲如何使用 Hexo 搭建个人博客。（Hexo 官方网站：https://hexo.io/zh-cn/）

一、架构概述

我在网上看到很多使用 Hexo 搭建个人博客的教程，使用的是 Github Pages 功能，将 Hexo 生成的 HTML 上传到 GitHub 的 Repo 里，开启 Pages 功能就可以通过 Github.com 的二级域名进行访问了。这种部署方式很方便，也不需要自己有服务器和域名，适合不想折腾太多的人。

这篇文章介绍的是使用自己的服务器来进行部署，以及使用 Github 的 Webhooks 自动更新服务器上的静态资源，Github 只是一个文件的中转站和备份，这么做的原因是我还有其他的服务挂在域名上，而那些服务需要 PHP 运行环境。

大概的架构图为：

在文章更新的时候，大概流程是：

• 本地计算机执行 git push
• Github 触发 push 事件，启动 Webhook，将事件信息通过 HTTP POST 发送给服务器上的特定路径的 PHP 脚本
• 脚本运行 git pull 命令，更新 Hexo 资源目录

二、安装 Hexo

使用 Hexo 搭建个人博客的第一步当然是安装 Hexo 了，在本地安装 Hexo 需要先安装 Node.js 运行环境，Hexo 使用 npm 包管理器进行安装。

1.安装 Node.js

Node.js 官网地址为：https://nodejs.org/zh-cn/，进入官网后建议选择【长期支持版】进行下载，下载后跟随安装界面一路下去即可。如果下载速度太慢，可以使用淘宝 npm 镜像下载，地址为：https://npm.taobao.org/mirrors/node

安装过程完成后，可以在命令行执行

1

node --version

查看是否可以显示 Node.js 的版本号，如果显示就说明安装成功了。

2.安装 Hexo

安装 Node.js 后，就是安装 Hexo 框架了。打开命令行（Cmd 或 PowerShell）执行命令：

1
2

# 安装Hexo-cli，Hexo本体
npm install hexo-cli -g

等待其运行成功后，执行

1

hexo -v

出现如下输出即为安装成功

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

hexo-cli: 3.1.0
os: Windows_NT 10.0.18363 win32 x64
node: 12.13.0
v8: 7.7.299.13-node.12
uv: 1.32.0
zlib: 1.2.11
brotli: 1.0.7
ares: 1.15.0
modules: 72
nghttp2: 1.39.2
napi: 5
llhttp: 1.1.4
http_parser: 2.8.0
openssl: 1.1.1d
cldr: 35.1
icu: 64.2
tz: 2019a
unicode: 12.1

3.安装 Git

现在来安装 Git，用于网站生成完成后的部署。

首先下载 Git 安装程序：https://git-scm.com/downloads，选择符合自己的平台下载即可，如果下载速度太慢可以使用淘宝镜像：https://npm.taobao.org/mirrors/git-for-windows/（或者复制链接使用迅雷下载，我试了一下还挺快）。

下载完成后运行程序，如果有 Add Git to Path 的选项请勾选。然后打开命令行（CMD 或者 PowerShell）输入：

1

git --version

显示版本即安装成功。

三、创建 Git Repository

我们使用 Github 来作为网站的备份和版本控制，这里我们将创建两个 Repository，一个用来放置网站的源代码，对于 Hexo 来说就是 Markdown 文件和各种配置文件。另一个用来放置 Hexo 生成的网页内容，并设置 Webhook 和我们的服务器保持同步。

ssh-keygen -t rsa

首先创建第一个用于托管源文件的 Repository。

登录 Github，创建一个新的 Repository，设置权限为 Private（仅自己可见），这里命名为“Hexo-Source”，并初始化一个 Readme.md 文件。如下图：

相似的，我们再创建一个新的 Repository 用来托管网站生成后的文件，这里命名为“Hexo-Website”，同样也设置为 Private。

现在我们就有了两个 Github Repository，接下来就是生成网站的步骤了。

四、创建 Hexo 项目

首先要把 Github 上的 Hexo-Source Repository 克隆下来。

然后我们打开 PowerShell，使用 CD 命令进入想要存储刚才克隆的 Repository 目录，执行下面的代码进行项目的初始化：

1
2
3

hexo init <folder>
cd <folder>
npm install

其中的 <folder> 替换为你的项目名称。

初始化完成以后的目录结构是这样的：

1
2
3
4
5
6
7
8

.
├── _config.yml
├── package.json
├── scaffolds
├── source
|   ├── _drafts
|   └── _posts
└── themes

• _config.yml - 项目的配置文件（主要需要修改的配置文件）
• package.json - 应用程序的信息（一般不用修改）
• scaffolds - 新建文章时程序使用的模板
• source - 存储文章 Markdown 源码的目录
  • _drafts - 文章草稿源码
  • _posts - 发布的文章源码
• themes - 主题目录（将自己想用的主题文件放在此文件夹中）

关于各种目录具体的用途，请参考官网文档：https://hexo.io/zh-cn/docs/setup

五、配置网站

创建项目后，这只是一个默认的模板，我们需要在网站中添加自己的信息，修改网站的主题等，使得它更像“自己的个人博客”。

首先需要修改的是 _config.yml 文件，关于这个文件的具体配置项，请参考文档：https://hexo.io/zh-cn/docs/configuration，下面简要介绍一下常用的配置。

下面我们进行主题的配置，我们可以先在 Hexo 的主题网站中寻找一个自己喜欢的主题：https://hexo.io/themes/。

找到之后，点击主题名称，进入主题代码托管的平台，然后将其下载下来，解压在 themes 目录中，主题文件的根目录必须在 themes/<theme-name> 中。

接下来就需要修改主题的配置文件，即主题目录中的 _config.yml 文件。不同主题提供的功能不同，所需要配置的选项也不同，所以请参考所选主题的文档进行操作（一般在主题代码托管的平台就可找到）。

六、如何写文章

Hexo 写作需要使用 Markdown，对 Markdown 不熟悉的读者可以参考：https://www.runoob.com/markdown/md-tutorial.html。

Hexo 的文章常用的类别为已发布的文章（Post）和草稿（Draft）。我们在创建文章的时候，两种不同的类别有不同的命令，这两种文章的区别是：

• 草稿（Draft）的 Markdown 文件存储在项目根目录的 source/_drafts 目录中，在生成网站时不会将草稿包括在内，即草稿不会出现在我们的网站中。
• 已发布的文章（Post）的 Markdown 文件存储在项目根目录的 source/_posts 目录中，在生成网站的时会将此目录中的所有文章包括在内，即我们可以在网站中看到我们发布的文章。

创建草稿的命令：

1

hexo new draft <title>

创建已发布文章的命令：

1

hexo new post <title>

将草稿发布的命令（将草稿转换为已发布的文章）：

1

hexo publish <title>

还有一种文章类型叫做“页面（Page）”，页面是网站中单独的网页，不属于博客文章列表中，不会在首页中显示出来。创建页面的命令为：

1

hexo new page <title>

和上面两种文章类型不同，页面生成后会在 source 目录中创建一个以页面标题命名的文件夹，文件夹里面自动生成一个名为 index.md 的文件，编辑这个文件即可编辑页面的内容。

还记得这个目录是我们克隆下来的吗？编辑好文章内容后，可以将此项目 Push 一下，托管到 Github（处于备份目的）。

七、预览网站效果

写好了自己的文章后，我们就可以在本地进行网站效果的预览了，通过启动本地 Hexo 服务器可以进行预览。

首先安装服务器模块（在 Hexo 项目根目录）：

1

npm install hexo-server --save

安装完成后，执行 generate 命令生成网站代码：

1

hexo generate

然后启动服务器：

1

hexo server

然后我们就可以在 http://localhost:4000 这个地址访问我们的网站了。

如果发现需要修改内容，直接修改文件即可，修改完成后不需要重启服务器，更改会自动应用。若启动服务器时发生了 EADDRINUSE（端口被占用）错误，可以使用 -p 参数指定启动端口。

八、部署网站

可以使用 Github Pages 托管自己的网站，如果使用这种方式，请参考文档：https://hexo.io/zh-cn/docs/github-pages。

下面要介绍的是通过服务器的部署方式。

首先，我们需要安装 Hexo 的 Git 部署模块，在 Hexo 项目根目录执行：

1

npm install hexo-deployer-git --save

安装完成后，打开项目根目录的 _config.yml 文件，找到 deploy 选项，按照下面的内容进行修改：

1
2
3
4
5
6
7

# Deployment
## Docs: https://hexo.io/docs/deployment.html
deploy:
  type: git
  repo: <你的github中用来托管网站的项目的ssh地址，即我们上文中创建的Hexo-Website Repository>
  branch: master
  message: '你想写的提交信息'

这一步告诉 Hexo 我们想要使用 Git 进行部署，且提供了 Git 项目的地址等信息。

然后就可以进行上传了，在根目录执行命令：

1

hexo deploy

等待执行完毕即可。

那么现在就要开始配置服务器了，登录自己的服务器，我以 CentOS 系统为例进行说明。

• 首先确保服务器中安装了 Git，然后创建一个新用户，这里且命名为 hexo，修改 /etc/passwd 文件授予此用户执行 Bash 脚本的权限。然后我们切换到这个用户：su hexo。
• 在 /var 目录下创建一个新目录，这里命名为 hexo_blog。进入此目录，使用 git 把 Hexo-Website Repository 克隆下来，那么克隆成功后的目录就是 Hexo-Website。
• 安装 Nginx，将 Nginx 的运行用户修改为 hexo（在 /etc/nginx/nginx.conf 中修改）。
• 配置 nginx.conf，将其 server 块中的内容替换为：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

listen       80 http2 default_server;
listen       [::]:80 http2 default_server;
server_name  你的域名;
root         /var/hexo_blog/Hexo-Website;
access_log /var/log/nginx/access-hexo.log;
error_log /var/log/nginx/error-hexo.log;

index index.html index.php;

location = /favicon.ico {
log_not_found off;
access_log off;
}

location = /robots.txt {
allow all;
log_not_found off;
access_log off;
}

location / {
}

location ~ \.php$ {
#NOTE: You should have "cgi.fix_pathinfo = 0;" in php.ini
include fastcgi.conf;
fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
fastcgi_intercept_errors on;
fastcgi_pass 127.0.0.1:9000;
}

location ~* \.(js|css|png|jpg|jpeg|gif|ico)$ {
expires max;
log_not_found off;
}

error_page 404 /404.html;

• 然后重启 Nginx 即可访问网站（这里我省略了申请域名和配置域名解析的内容）。

接下来，设置自动更新。

• 首先安装 PHP 运行环境：php-fpm，安装完成后启动，并设置监听端口为 9000.
• 在 /var/hexo_blog/Hexo-Website 中创建一个目录，命名为 api，创建一个名为 sync.php 的 PHP 文件，内容如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

<?php

// 认证字符串，需要填入Github Webhook Secret中
$code = 'xxxxxxxxxxxxxxxx';

// 测试认证
if (!isset($_GET['code']) || $_GET['code'] !== $code)
{
    exit('请提供正确的认证代码。');
}

// 计算Github HMAC认证
$data_body = file_get_contents('php://input');
$hash = hash_hmac('sha1', $data_body, $code);
$hash = 'sha1=' . $hash;
if (!function_exists('getallheaders')) {
    function getallheaders() {
        foreach ($_SERVER as $name => $value) {
            if (substr($name, 0, 5) == 'HTTP_') {
                $headers[str_replace(' ', '-', ucwords(strtolower(str_replace('_', ' ', substr($name, 5)))))] = $value;
            }
        }
        return $headers;
    }
}
if (!isset(getallheaders()['X-Hub-Signature']))
{
    exit('HMAC认证失败，无签名。');
}
$signature = getallheaders()['X-Hub-Signature'];
if ($hash !== $signature)
{
    exit('HMAC认证失败。');
}

$command = 'cd /var/hexo_blog/crontab && nohup ./personal_hexo_blog_hook_sync.sh &';

// 执行更新脚本
system($command, $status);
if ($status)
{
    echo '执行失败。';
}
else
{
    echo '执行成功。';
}

• 上面代码中的 xxxxxxxxxxxxxxxx 需要换成你自己指定的认证码（就是随意的一串字符串），这个认证码下面还会用到。
• 创建目录 /var/hexo_blog/crontab，在其中创建一个名为 personal_hexo_blog_hook_sync.sh 的文件，其内容为：

1
2
3
4
5
6
7
8
9
10
11

#!/bin/bash

# 用于响应Github hook拉取Github的更新

# 记录日志
echo $(date)": Git-Work(Hexo)" >> /var/hexo_blog/git_hook_sync.log

cd /var/hexo_blog/Hexo-Website
git pull >> /var/hexo_blog/git_hook_sync.log

echo "End=====================" >> /var/hexo_blog/git_hook_sync.log

• 给 personal_hexo_blog_hook_sync.sh 文件加上可执行权限。
• 编辑 php-fpm 的配置文件，让其以 hexo 用户运行。
• 重启 php-fpm 服务。

现在，我们的服务器已经配置完成。

我们进入 Github 刚才创建的 Hexo-Website Repository，进入项目的 Settings 选项，点击左侧的 Webhooks，再点击右侧的 Add Webhook 添加新的钩子：

图中，将 你的域名 换成你的域名地址，将 xxxxxxxxxxxxxxxx 换成上文中我们 PHP 代码中设置的认证码，Content type 设置为 application/json，Secret 中也填写相同的认证码，其他的按照图中设置即可。

然后点击 Add Webhook 即可成功添加钩子。

九、测试自动更新

现在我们就有了一个可以自动更新的 Hexo 个人网站了，是不是很简单（bushi）！

我们来测试一下自动更新功能：

• 修改或者增添一篇博客文章（在本地计算机）。
• 运行命令（在本地计算机）：

1

hexo clean && hexo generate && hexo deploy

• 等待运行完成，然后再等待大概 2-3 分钟时间让服务器完成更新。
• 访问你的域名，查看你刚才修改的博客文章是否已经更新了！

要查看 Github 的 Webhook 运行是否正常，进入 Repository 的 Webhook 界面，点击我们添加的 Webhook，往下翻就能看到最近进行过的 Hook 活动了，点击项目就能看到 Github 在执行 Hook 的时候服务器的返回状态码和返回内容，由此判断可能出现的问题。

如上，Body 里返回了 执行成功。 则表明更新成功了。

以上。

<span style="color:grey">注：本视频中的观点来自我们在作业中所查阅的相关论文资料，这里只是进行一个简单的概括和总结。我们并非对此领域有专业深入的研究和认识，只是提供一个了解碎片化阅读的角度。

B站视频链接：av50436230

以我在学校中做项目的经验来看（特别是与网络相关的项目），在整个开发流程中最关键的点之一就是系统的代码拆分，即将系统分解形成不同的模块分发给不同的团队成员去实现。系统拆分需要从系统功能性需求和非功能性需求两方面同时考虑，例如在工作量正常的情况下，与用户系统相关的功能设计最好放在同一个模块中实现，而不应该将用户注册和用户登录分为两个模块，甚至交给两组不同的团队去实现。

一、背景

在最近的软件工程课程设计中，我们组被分配到的任务是“校园二手书”平台网站的设计与实现，不要求特定语言与框架。在经过组员之间的讨论后，我和另外一个负责开发的组员决定使用 Python Django 框架开发后端，使用 Bootstrap 开发前端，前后端之间使用 Javascript jQuery 进行异步数据交互，并且前后端分离。

至于为什么只有两名开发组员，是因为这次的课设工作量并不大，且功能并没有很繁多，只是简单地实现一个较小规模的网站平台。另外，在一开始我们也曾考虑过使用 Java Web 技术进行开发，但由于想要尝试并学习一下新的框架（玩具），我们才放弃了最熟悉的 Java 技术栈转向并没有开发经验的 Python Django，同时，作为前端开发的我也并没有能拿得出手的前端开发项目经验。更加棘手的是，课设的那一个星期正赶上移动应用程序和云计算课程的结课，软工课设时间被挤压只能在三天内从零做完整个项目（原计划是两个星期）。

二、开发过程

在开发的前期，因为前后端分离的原因，我们两个人除了交流功能、讨论界面设计和确定数据格式以外，基本没有其他的合作，各自确定代码结构和实现。在开发了一段时间之后，对完成的首页进行测试，发现由于 JavaScript 进行了跨域访问，数据无法提交，只好将前端部署到服务器上进行访问，这样就造成了代码修改的不便，需要进行频繁的部署和访问。由于时间紧迫，没有使用 Webhook 等自动部署工具。

解决了跨域访问的问题后，由于使用网页端 JavaScript 异步登录，不知什么原因在进行登录后服务器端无法识别 Session（可能和 Cookie 相关），导致登录始终失败无法进行下一步的测试。

除了上述两个问题外，因为前后端分离，我们试图使用原生 JavaScript 通过异步数据交换，对 DOM 进行操作，更新网页内容。由于前端知识掌握不足，模板等技术不会使用，只好利用字符串拼接在 JavaScript 中形成 HTML 代码，从而更新内容。这种方法浪费了大量的时间（因为有大量的字符串和变量拼接，以及字符转义操作等），且效果非常不理想，JS 代码可读性较差，查找 Bug 困难，且不易修改。

终于，在积累了大量的 Bug 后，我们没能在规定时间内解决，无法完成一个功能正常的网站，作品存在的问题如下：

• 登录始终不成功
• 数据交换成功率不高
• 页面内容更新效果差，失败率高
• 页面美观性低

三、解决方案

经过和老师的沟通，老师同意让我们延后一周提交作品。我们决定放弃这种方案，放弃前后端分离的设计，使用 Django 的模板进行开发。这样一来有点如下：

• Session 问题自然解决，因为放弃异步登录，所有登录操作都在服务器完成
• 数据交换都在服务器完成
• 页面内容更新不需要 JS 对 DOM 进行操作，使用 HTML 模板生成
• 有更多精力和时间进行页面美化和功能完善
• 将所有业务逻辑代码放在框架中完成，提高了代码的可读性和可维护性

经过3天的重构和开发，我们最终完成了具有正常功能的网站……

四、总结

我认为，这次的课程设计失败的主要原因有两个：一是在时间紧迫的情况下使用自己不熟悉的技术栈；二是在进行网站架构设计时，对原本工作量不大的代码工作进行了过度拆分，平白增加了巨大的对接工作量，耽误了完成进度。

所以，在写代码之前，首先要进行合理的软件设计，否则可能会事倍功半。

以上。

一、JavaFX SDK 和 JDK 之间的关系

刚入门 JavaFX 的同学肯定对这个问题很头大（因为我就是这样的hhh），在 JDK 8 及之前版本，JavaFX 都是和 JDK 捆绑在一起的，下载安装 JDK 即可开发和使用 JavaFX 进行开发。而在 JDK 8 之后，Oracle 将 JavaFX 从 JDK 中分离了出去，作为 OpenJDK Project 的一个部分 OpenJFX Project 由社区进行运营，其官网在这里。关于 JavaFX 被移除的信息请见官网链接。

在搭建开发环境时，如果选用 JDK 8 / 7 的话，则不需要下载其他的 JavaFX SDK，可以直接使用 JDK 进行 JavaFX 开发；若使用 JDK 8 之后的版本，则需要安装 JDK 之外，再安装 JavaFX SDK，其下载地址见上文的官网地址。

二、使用 IDEA 开发 JavaFX 项目

接下来介绍使用 IDEA 进行 JFX 开发所需要的项目配置。

1.使用 JDK 8

使用 JDK 8 的情况下，首先下载安装 JDK。

安装完成后，打开 IDEA 并新建 JavaFX 项目：打开 File->Project Structure 窗口，选择 Project SDK->New… 选择你刚安装的 JDK 路径。

接下来配置 JFX 启动参数（如果不配置启动参数，编译后会出现“无法运行 JavaFX 程序，请安装 JavaFX 运行时来运行此程序”的错误提示）：

回到项目主界面，点击右上角的“播放”符号左侧的下拉菜单，选择“Edit Configurations…”选项，在跳出窗口的“VM options”项中填写下面的内容：

1

--module-path /path/to/javafx-sdk/lib --add-modules javafx.controls,javafx.fxml

其中“/path/to/javafx-sdk/lib”改成你安装 JavaFX SDK 的目录下 lib 目录的路径即可。

这样就配置完成了，可以使用 IDEA 开发和启动 JFX 应用程序了。

2.使用 JDK 8 以后的 JDK 版本

使用 JDK 8 以后的 JDK（例如 JDK 11 等）时，同样需要进行上述所有步骤，在完成上述步骤之后，还要下载 JavaFX SDK 并安装。

接着在“Project Structure”窗口选择左侧的“Libraries”分页，点击“+”号，点击“Java”，找到安装 JavaFX SDK 的目录，选择目录下的“lib”目录，点击打开即可。

添加完成后点击“OK”关闭页面，即可进行 JavaFX 开发。

以上信息可以在官方网站中找到，地址为：https://openjfx.io/openjfx-docs/#IDE-Intellij ，可以将这篇博客看作以上文档的翻译和扩充。

以上。

CAS 的具体操作是比较和替换，即第一步比较指定值和内存中的值是否一致，若一致则使用新值对内存值进行替换。

不一致问题的举例

假设有两个线程 A 和 B，它们分别对数据 V（值为100）执行加 10 和减 10 的操作，代码执行过程如下：

线程A对数据V的操作：

1. 从内存中读取数据 V（100）；
2. （在线程中）将数据 V加10；
3. 将加法的结果 V1（110）存入内存中原来的位置（替换掉旧的 V）。

线程 B 对数据 V 的操作：

1. 从内存中读取数据 V（100）；
2. （在线程中）将数据 V 减 10；
3. 将减法的结果 V2（90）存入内存中原来的位置（替换掉旧的 V）。

假设这两个线程并发执行，且 A 首先获得 CPU 时间片，在 A 的 CPU 时间内，它先读取数据 V 的值，并将其进行了加法操作，获得数据 V1（110）。此时，A 的 CPU 时间片结束，线程 B 开始执行。B 将数据 V 读入（此时数据V未被改动），并执行了减法操作，获得数据 V2（90）。此时，B 的 CPU 时间片结束，线程 A 继续执行，A 将 V1（110）存入内存，A 线程结束。B 继续执行，B 将 V2（90）存入内存，B 线程结束。

我们可以看到，此时内存中的数据 V 已经变成了 V2（90），与我们原先以为的100（加十减十）预期不同，造成了数据不一致的问题。

使用CAS解决数据不一致问题

CAS 可以用于解决上述数据不一致问题，假设线程 A 和 B 都使用了 CAS 方式，那么他们的执行步骤为：

线程 A 对数据 V 的操作：

1. 从内存中读取数据 V（100）；
2. （在线程中）将数据 V 加 10；
3. 执行 CAS 操作，比较第一步读取的 V 值（100）与现在内存中的 V 值是否相等，若相等则继续；否则返回执行第一步；
4. 将加法的结果 V1（110）存入内存中原来的位置（替换掉旧的 V）。

线程B对数据V的操作：

1. 从内存中读取数据 V（100）；
2. （在线程中）将数据 V 减 10；
3. 执行 CAS 操作，比较第一步读取的 V 值（100）与现在内存中的 V 值是否相等，若相等则继续；否则返回执行第一步；
4. 将减法的结果 V2（90）存入内存中原来的位置（替换掉旧的 V）。

流程修改后，在执行过程中，当 A 线程执行结束后，内存中的值已经变为 V1（110），线程B在存入新的值之前首先比较 V1 是否与 V 相同，因为内存中的值已经修改，所以线程B需要重新执行读取操作，从第一步重新执行，将 V1（110）减 10 在存入内存，得到 V（100）与预期一致，从而确保了数据的一致问题。

实现

CAS 操作基于 CPU 提供的原子操作指令实现。对于 Intel X86 处理器，可通过在汇编指令前增加 LOCK 前缀来锁定系统总线，使系统总线在汇编指令执行时无法访问相应的内存地址。而各个编译器根据这个特点实现了各自的原子操作函数。[1]

• C语言，C11 的头文件 stdatomic.h。由 GNU 提供了对应的 __sync 系列函数完成原子操作。
• C++11，STL 提供了 atomic 系列函数。
• JAVA，sun.misc.Unsafe 提供了 compareAndSwap 系列函数。
• C#，通过 Interlocked 方法实现。
• Go， 通过 import “sync/atomic” 包实现。
• Windows，通过 Windows API 实现了 InterlockedCompareExchangeXYZ 系列函数。

外部链接

[1] 引用自 Wikipedia CAS 词条:网页链接。

以上。

Unity 是一款优秀的2D/3D游戏引擎，使用 Unity 开发的游戏大作层出不穷。如今，Unity 已经不止用来开发游戏，其在电影、工业制造、教学、仿真实验和工程领域也有很多的应用。本文主要介绍使用 Unity 开发游戏时 Windows 平台的开发环境搭建。

Unity 开发环境主要组成部分是 Unity Editor 和脚本编辑器。Unity Editor 用于游戏中场景和对象的设计与制作，游戏中的对象称为 GameObject（游戏对象），每个游戏对象都可以添加若干 Component（组件），组件用于控制游戏对象的特征或行为，Script（脚本）就是其中一种组件，用于定义游戏对象的行为逻辑。脚本可以使用 C# 或者 Javascript 编写，我们可以使用任意的编辑器编写脚本，这里我们使用 Visual Studio 2017 为例，介绍如何安装开发环境和调试游戏对象的脚本。

此文参考了 Unity 官方的环境搭建指导视频，链接在此（Youtube-英文版）。

一、安装 Unity

安装 Unity 推荐使用 Unity Hub 管理程序。

第一步，下载 Unity Hub。这里使用 Personal（个人版）为例，下载地址为 https://store.unity.com/cn/download ，下载时需要满足网页中显示的几个条件。下载安装程序后点击运行，并注册账户，完成其中内置的几个小调查即安装完毕。

第二步，安装 Unity。安装 Unity Hub 完成之后打开，选择 Installs 标签页，选择 Official Releases 页面，选择一个想要安装的版本点击 Download 即可，等待其下载完毕。

二、安装 Visual Studio

接下来安装 Visual Studio，以 2017 社区版为例。

第一步，从微软官网下载 Visual Studio Installer，地址为：https://visualstudio.microsoft.com/zh-hans/downloads/ ，点击下方所有下载中的 Visual Studio 2017 开始下载。

第二步，运行安装程序，安装 Visual Studio Installer。安装完成后，从开始菜单中打开 Installer，在 Visual Studio Community 2017 下方点击安装按钮开始安装，进入“工作负载”页面。

如上图，勾选“使用 Unity 的游戏开发”即可，然后进行安装。Installer 会下载 Visual Studio 并安装在指定位置。

待安装好之后，我们打开 Unity Editor -> 编辑 -> Preferences -> 外部工具，可以查看到“外部脚本编辑器”这一项的值是 Visual Studio 2017 (Community)。此时双击 Editor 中的脚本文件，系统将会启动 Visual Studio 作为 IDE 进行编辑。

三、使用 Visual Studio 调试

在安装完开发环境之后，需要提及的是 Unity + Visual Studio 的代码调试功能。Visual Studio 可以启动 Unity 游戏进程来进行代码调试。我们要做的是，在 Visual Studio 中编辑完毕代码，在需要设置断点的代码行左侧单击设置断点（会出现一个红点）。之后选择“附加到 Unity 并播放”按钮开始调试，Visual Studio 会启动游戏进程并运行到断点处停止，显示各种代码状态。

点击调试按钮后，界面会跳回 Unity 并开始运行游戏进程，当运行到断点时，跳回 Visual Studio 显示调试界面。

到此，环境安装完成，可以开始开发了！

以上。

但在使用时，我发现 OKHttp 所提供的异步请求接口在执行回调函数时，不能更新 UI 组件，原因是框架执行回调，并不是在 UI 线程上执行的。这一点问题在开发时造成了一些不便。为了解决这个问题，我使用框架提供的同步请求接口封装了一个自己实现的异步接口，使得回调函数能够在 UI 线程上执行，也能够处理网络请求中出现的一些异常。实现如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155

import android.app.Activity;
import android.content.Context;
import android.util.Log;

import org.json.JSONException;

import java.io.IOException;
import java.util.concurrent.TimeUnit;

import okhttp3.Call;
import okhttp3.MediaType;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.RequestBody;

/**
 * 用于发起HTTP请求的协助类。
 */
public class HttpRequestHelper {

    /**
     * 请求的地址。
     */
    private String url;

    /**
     * 请求的消息体。
     */
    private String body;

    /**
     * 请求的方法。
     */
    private String method;

    private Call call;
    private Activity activity;

    private final Boolean[] ifSuccessfully = {true};

    /**
     * 构造方法。
     * @param c Context
     * @param u URL
     * @param m Method
     * @param b Body
     */
    public HttpRequestHelper(Context c, String u, String m, String b) {
        url = u;
        method = m;
        body = b;
        activity = (Activity) c;

        // 设置超时时间为10秒
        OkHttpClient client = new OkHttpClient.Builder()
                .readTimeout(30, TimeUnit.SECONDS)
                .writeTimeout(30, TimeUnit.SECONDS)
                .build();
        Request request;
        if (m.equals("get")) {
            request = new Request.Builder()
                    .url(u)
                    .get()
                    .build();
        } else {
            request = new Request.Builder()
                    .url(u)
                    .post(
                        RequestBody.create(
                            MediaType.parse("application/json"),b
                        )
                    )
                    .build();
        }
        call = client.newCall(request);
    }

    /**
     * 用于处理网络请求结果的方法。
     * @param rh 处理接口。
     * @param invoker 调用者Class
     * @param info 用于显示的Debug信息。
     */
    public void handleResponse(ResponseHandler rh, Class invoker,
                               String info) {
        Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
                String response = "";
                try {
                    Log.i(invoker.getName(),
                            "HTTP发送数据\""
                                    + info + "\"(方法"
                                    + method + ")：" + body
                                    + " 到 " + url);
                    response = call.execute().body().string();
                    Log.i(invoker.getName(),
                            "HTTP接收数据\""
                                    + info + "\"："
                                    + response);
                } catch (IOException e) {
                    Log.e(invoker.getName(),
                            "HTTP获取异常\""
                                    + info + "\"："
                                    + e.getMessage());
                    ifSuccessfully[0] = false;
                } finally {
                    String finalResponse = response;
                    activity.runOnUiThread(new Runnable() {
                        @Override
                        public void run() {
                            try {
                                rh.handle(finalResponse);
                            } catch (JSONException e) {
                                Log.e(invoker.getName(),
                                        "HTTP获取JSON解析异常\""
                                                + info + "\"："
                                                + e.getMessage());
                                ifSuccessfully[0] = false;
                            } finally {
                                rh.handleResult();
                            }
                        }
                    });
                }
            }
        });
        t.start();
    }

    /**
     * 返回网络请求是否成功。
     * @return 是否成功。
     */
    public Boolean ifSuccess() {
        return ifSuccessfully[0];
    }

    /**
     * 处理结果的接口。
     */
    public interface ResponseHandler {
        /**
         * 用于处理网络返回结果的回调方法。
         * @param response 网络返回的字符串结果。
         * @throws JSONException 可能的JSON异常。
         */
        void handle(String response) throws JSONException;

        /**
         * 用于判断请求是否成功，并对结果进行处理的回调方法。
         */
        void handleResult();
    }
}

这个 HTTP 协助类用于发起异步 HTTP 请求，并对结果调用传入的回调函数进行处理。回调函数一共有两个，即 ResponseHandler 接口中的两个方法。

handle 方法用于处理网络返回的数据（已转换为字符串，代码中默认返回的和发送的数据都为 JSON 格式），在此方法中可以进行对数据的解析提取等操作。

handleResult 方法用于处理整个网络请求的结果，例如请求成功和请求失败（需要调用协助类中的 ifSuccess 方法进行判断）。对不同的结果进行不同的处理，对于 UI 组件的更新也是在此方法中进行的，此方法会在 UI 线程调用。注意，此方法不抛出任何异常，需要在方法中对异常进行处理。

协助类中的 ifSuccess 返回的结果包含了请求中任意异常的发生，也就是说，无论是 handle 方法中的异常，还是在请求中出现的异常，都能在 ifSuccess 方法返回的结果中体现，可以认为只要发生了异常，ifSuccess 方法返回的就是 false，否则为 true。

下面是调用协助类的代码示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

HttpRequestHelper hrh = new HttpRequestHelper(
    this,
    authUrl,
    "post",
    loginData.toString()
);
hrh.handleResponse(new HttpRequestHelper.ResponseHandler() {
    @Override
    public void handle(String response) throws JSONException {
        // 解析自动登录JSON数据
        authData = new JSONObject(response);
        System.out.println("Auth接受数据："+ authData.toString());
        if (!authData.getString("username").equals(username)) {
            throw new JSONException("自动登录异常：用户名不对应");
        }
        ifLoginSuccessfully=
            Boolean.valueOf(authData.getString("auth_result"));
        if (ifStudent) {
            ifUploadStandardPhoto =
                authData.getBoolean("if_upload_standard_photo");
         }
    }

    @Override
    public void handleResult() {
        handleNetForAutoLogin(hrh, navigationView, ifLoginSuccessfully);
    }
}, this.getClass(), "自动登录");

调用的代码中，首先是实例化了一个 HttpRequestHelper hrh，确定了 URL、请求方法（“post”）和消息体数据（JSON对象字符串）。然后调用 hrh 对象的handleResponse 方法来启动请求，同时实例化回调方法的接口，将回调函数传入 handleResponse 方法。

可以看到，在 ResponseHandler 接口中，handle方法主要用来解析和提取网络返回的数据。在其他地方，我定义了一个 handleNetForAutoLogin 方法，用于对返回的网络数据的后续使用和处理。这里我把 handle 方法中解析出的数据（ifLoginSuccessfully）传入了 handleNetForAutoLogin 方法中进行处理，同时也传入了 hrh 和 一个 View 组件。传入 hrh 是为了检查网络请求是否出现了异常，若出现了异常，就不会使用解析出的数据，并通知用户发生了错误。若没有发生异常，则使用传入的数据进行下一步的操作。

需要注意的是，handleResult 方法在 HttpRequestHelper 类中是在 finally 块中执行的，也就是说，无论网络请求是否发生异常，handleResult 方法都一定会执行（所以就可以在此方法中判断网络请求是否发生异常）。

无论是 handle 还是 handleResult，在协助类中，他们都是被放在 activity.runOnUiThread 方法中执行，都可以直接操作和更新 UI 组件。

以上。

一、关于 Scrapy

Scrapy 是一个 Python 爬虫框架，可以很方便地使用此框架编写爬虫并爬取解析网络数据，Scrapy 官网在这里。

安装 Scrapy：

1.使用 Anaconda 进行安装

在 Windows 平台安装 Scrapy 需要使用 Anaconda Distribution，因为如果直接使用自己安装的 Python PIP 包管理器进行安装可能会导致依赖组件的编译问题（可能需要特定的C++运行库），使用 Anaconda 进行安装的步骤：

• 安装 Anaconda Distribution；
• 打开 Anaconda Prompt；
• 执行命令 conda install -c conda-forge scrapy；
• 等待安装完成即可。

2.使用 pip 包管理器进行安装

使用虚拟环境或者系统 Python 命令行安装 scrapy。

1

pip install scrapy

或

1

pip3 install scrapy

二、Scrapy 常用命令

startproject

在 Anaconda Prompt 中执行

1

scrapy startproject <PROJECT_NAME>

**用途：**创建项目（Project），即创建一个项目文件夹并生成项目中的文件架构。

crawl

在 Anaconda Prompt 中执行

1
2

cd <PROJECT_DIR>
scrapy crawl <SPIDER_NAME>

**用途：**启动一个编写好的爬虫，爬虫类中 name 属性的值为爬虫的名称（即以上）。

shell

在 Anaconda Prompt 中执行

1

scrapy shell "<TARGET_URL>"

**用途：**以交互模式启动，抓取 URL 中的网页后提供交互式命令行供用户手动分析，一般用于设计爬虫时的网页元素分析。

三、Scrapy 部分组件思维导图

Scrapy Spider

Scrapy Item

Scrapy ItemLoader

Scrapy ItemPipeline

Scrapy Request

Scrapy AutoThrottle Extension

以上。

我们都知道，目前的网络应用大部分是客户端/服务器（Client/Server，C/S）架构，客户端可以使用 HTTP 协议去获取服务器端的内容，使用 HTTP 协议一定是客户端主动地去向服务器发出请求，服务器根据客户端的请求来返回相应的内容。传统的网站以及对信息实时性要求不高的网络应用使用 HTTP 协议获取内容是很好的选择，但是对于具有实时通讯功能（用户彼此实时交流）的应用来说，更好的选择是 WebSocket 协议。WebSocket 协议可以使客户端与服务器保持连接，并打破了只能是客户端主动获取服务器内容的局限，服务器可以主动向客户端推送信息，形成双向的信息流。

在 Java 平台使用 WebSocket 也是非常方便的，Java Specification Requests（JSR）标准中的 JSR356（https://jcp.org/en/jsr/detail?id=356）叙述了 WebSocket 的 Java API 使用方式，遵循这套模型开发的 WebSocket 代码，可以在不同的应用容器中运行（例如 Tomcat），应用容器 WebSocket 部分的实现都遵循这套标准。

对 JSR356 的简介如下：

JSR 356, Java API for WebSocket, specifies the API that Java developers can use when they want to integrate WebSockets into their applications—both on the server side as well as on the Java client side. Every implementation of the WebSocket protocol that claims to be compliant with JSR 356 must implement this API. As a consequence, developers can write their WebSocket-based applications independent of the underlying WebSocket implementation. This is a huge benefit, because it prevents a vendor-lock and allows for more choices and freedom of libraries and application servers.

2018年11月22日摘自 Oracle，JSR 356, Java API for WebSocket，by Johan Vos，https://www.oracle.com/technetwork/articles/java/jsr356-1937161.html

一、编写 WebSocket 服务器

使用 Java 编写 WebSocket 服务器端不难，我们可以使用上述提到的 Java WebSocket API 来实现，这篇文章中的代码运行于 Tomcat。要让 Tomcat 识别代码中的 WebSocket Endpoint 类和各个用于处理事件的方法，我们需要用到注解。一个大概的 WebSocket Endpoint 类的结构是这样的（需要导入 javax.websocket.* 和 javax.websocket.server.ServerEndpoint）：

• @ServerEndpoint(value=”/path/to/endpoint”)注解（类）
• @OnOpen注解（方法）
• @OnMessage注解（方法）
• @OnClose注解（方法）
• @OnError注解（方法）

@ServerEndpoint(value=”/path/to/endpoint”)

1
2

@ServerEndpoint(value="/path/to/endpoint")
class WebsocketEndpoint {...}

此注解用于标记实现 WebSocket 端点的类，即用于处理 WebSocket 消息、WebSocket 连接、WebSocket 异常的类。被此注解标记的类，会被 Tomcat 用于处理由客户端发起的 WebSocket 连接，具体对于连接进行处理的方式被定义在此类的各个方法中。

注解中的 value 属性的值定义了 WebSocket 端点在服务器上的访问路径，例如若服务器的域名为 maphical.cn，且 value 的值为“/path/to/endpoint”，则访问 WebSocket 端点的链接为“wss://maphical.cn/path/to/endpoint”。

@OnOpen

1
2

@OnOpen
public static void onOpen(javax.websocket.Session sess)

此注解标记用于处理新 WebSocket 连接的方法，当 Tomcat 接收到新的连接请求并建立连接后，将会调用此方法。此注解标记的方法在 WebSocket 服务中一般被用来将新会话保存进类中维护的会话列表中，使得系统能够在后续发送消息是能够根据 Session ID 找到相应的会话对象。同时也可以在此方法中维护 WebSocket 客户端连接数量等附加信息。

@OnMessage

1
2

@OnMessage
public static void onMessage(String mess, javax.websocket.Session sess)

此注解标记的方法用于处理 WebSocket 会话发送到服务器的消息，消息内容将会被以字符串参数的形式传入方法（上述代码中的 mess 参数）。当 Tomcat 接收到一条来自某个会话的消息后，会调用此方法并将消息内容与发送消息的会话对象作为参数一同传入方法中，之后的处理是由程序员的代码来完成。对于实时通讯类应用服务器来说，这个方法的通常用途是作为消息中转站，将接收到的消息进行处理转发到目标客户端。

@OnClose

1
2

@OnClose
public static void onClose(javax.websocket.Session sess)

此注解标记的方法用于处理 WebSocket 连接的关闭，当 Tomcat 关闭或者客户端即将关闭某个链接时，将会调用此方法，并将即将被关闭的会话对象作为参数传入（上述代码中的 sess 参数）。此方法的一般用途为，进行连接被关闭时的清理工作，例如从会话列表中删除即将关闭的会话等。

@OnError

1
2

@OnError
public static void onError(javax.websocket.Session sess, Throwable e)

此注解标记的方法用于处理其它过程中产生的异常，当发生异常时 Tomcat 会调用此方法，并将发生异常的会话对象以及异常对象作为参数传入方法中（上述代码中的 sess 和 e 参数）。此方法的一般用途为，通知客户端服务器发生异常，并为异常进行清理工作和日志的记录等。

二、部署 WebSocket 服务器

将端点类编写完毕之后，不需要改动其他的配置文件等，直接将项目打包成 war 文件并上传到 Tomcat 即可自动部署，服务器会自动识别代码中的注解，部署完毕后即可使用 WebSocket 客户端（如小程序等）连接 WebSocket 端点进行测试。

需要说明的是，小程序不支持没有进行 SSL 加密的 WebSocket 连接，需要提前在服务器上部署并配置域名 SSL 证书，并使用 wss:// 进行访问（wss 意为经过 SSL 加密的 WebSocket 协议，ws 意为没有经过 SSL 加密的 WebSocket 协议）。

WebSocket 的连接建立使用 HTTP 头，在建立 TCP 连接之后，服务器根据 HTTP 头部中的信息切换到 WebSocket 协议，所以 ws 默认使用 80 端口，wss 默认使用 443 端口。若你的服务器已经为 HTTPS 配置好了 SSL 证书和端口，那就可以直接使用 wss 协议访问 WebSocket 端点。

以上。

其实，看一本书，或者一套小说，应该是要连续的读完的。这样才能将前后的情节连贯起来，更加准确地了解各个人物的特点和小说的主旨大意，也更能获得情感上的共鸣。但也正因为我断断续续地读了两年，每次都要回忆，所以我对这本小说的印象应该会比较深刻了。

整套小说描写了地球文明从现代开始，一直到宇宙即将坍缩的末日，时间跨度达到上百亿年，主题非常宏大，构思也是非常的精妙。这是一部硬科幻，小说中所描写的所有，似乎都和我们现在所生活的世界息息相关，都似乎是从现实世界衍生的，完全有可能发生的事件。同时也不得不叹服作者的知识渊博，身为工程师的刘慈欣，从计算机和物理学，到政治和美学艺术，都在作品中展示了他对这些领域的了解。在我看来，如果没有这些深入的积累，这部作品是写不出来的，十分佩服。

我从小就对天文和科幻十分感兴趣，小时候也是无数次“模拟”太空基地和飞船等太空科幻元素，也有过无数次的对星空的幻想。在《三体》中，我几乎享受了我所期望它有的所有科幻元素，不仅如此，这些科幻元素都基于现实的世界，这让这部作品看起来似乎是一部史书，是以几个地球生命的视角来记录整个宇宙的发展史，向读者一步一步地揭露了宇宙的险恶面目和文明发展的艰难。

但它又不仅仅是一部生硬的科幻，作者又将主人公的感情心理和成长历程，地球文明对道路的选择以及对道德的重新认识等等触人心弦的元素融入了其中。让我看完之后回味无穷，这其中既有对时间的无情的感慨，又有对太阳系人类道路选择的惋惜。这部作品似乎从哲学的高度重新让读者认识了一遍宇宙。我们生命的意义是什么？时间是无穷无尽的吗？文明的高度能有多高？在生存和道德面前我们应该如何选择？

可以看到，太阳系人类的文明无论如何挣扎，都逃脱不了毁灭的命运，这也是大多数人的命运，真正能够摆脱这种命运的人，都要先摆脱人类的道德约束，先认清现实的残酷。这里有一个争议很大的人物——程心。有很多人对她的评价不是很好，认为她在担负人类命运的时候总是会做出错误的决定，“短视”、“自私”、“妇人之仁”等不好的词语都被加在了她的身上。而我认为，这责任远远轮不到她来背负，就如“执剑人”那次转折说来，那种选择并不是程心做出的，而是所有赞成程心担任执剑人的选民所做出的选择，也就是，那是全体人类的选择。在我看来，即使没有程心这个人物的出现，地球人类也会选出第二个程心，这种结果并不是程心的错，而是人类的错误。是当时人类幼稚、天真的想法和社会文化所导致的必然产物，说白了，也就是人类种族的特性所致，这怪不了任何人，但与任何人都有关系。如果说程心有什么错的话，那就是她不能知错而改，在维德履行承诺的时候，她不能吸取教训相信维德一次，而是继续相信自己的判断。

有时我会想，如果维德能够代替程心的位置该多好，或者程心能够拥有像维德一样的果断和正确的思维判断，那样他或她都会引导太阳系文明走上正确的道路。

但是这是不可能的，如果程心像维德一样，在一开始云天明也不一定会喜欢上她，也就不一定能够送给她星星，她也就不一定能够获得启动星环集团资金，后来也就不一定能拥有研发光速飞船的资源了。

总之，即使太阳系文明能够一直发展下去，最终也是要面临毁灭的结局，到了时间的尽头，只有死神能够永生。

以上。

为了部署过程更加便捷，我将此文章中所述的环境搭建步骤写成了 Python 脚本，使用此脚本可以自动安装LAMPP（Apache、MySQL、PHP、PHPMyAdmin）环境，可以点击这里下载安装脚本。

LAMP环境

LAMP是Linux，Apache，MySQL，PHP的缩写。Linux为操作系统，Apache为web服务器另外还提供PHP模块，MySQL是数据库。MySQL一般会有两种版本的选择，一是MySQL5.6，二是比较新的版本。PHP也是这样，一般现在会选择PHP7.x。另外，一般我接触过的会使用LAMP环境作为运行环境的应用程序为——使用PHP CI框架开发的为微信公众号或小程序提供后端服务的应用程序。

部署步骤

一、获得Linux服务器

当然了，应用程序需要一个机器运行，可以从云平台上或者其他途径购买或获得一台Linux系统的服务器（一般使用CentOS或Ubuntu系统）。

二、安装所需软件（CentOS为例）

1.安装Apache服务器