Spring Boot 创建入门级 RESTful Web 项目简单到令人发指，下面就来看看怎么用吧(如果想知道 Spring Boot 是啥，搜索即可):

1. 创建项目的骨架
2. 添加 RestController
3. 启动项目: gradle bootRun
4. 打包项目: gradle build

创建项目的骨架

1. 访问 http://start.spring.io
2. 选择 Gradle 项目，Spring Boot 2.x
3. 填写 Group (项目的包名，例如 com.xtuer) 和 Artifact (可不填)
4. Search for dependencies 输入 web
5. 点击 Generate Project，会自动下载项目骨架 demo.zip
6. 解压，如果不需要里面的 gradlew，删除即可

在 Spring Security Session + Token 认证 中介绍了 Token 相关的身份验证，但是怎么验证 token 和使用 token 获取用户信息没有进行介绍，可以把 token 存储到 Redis、数据库等，下面介绍另一种 token 实现方法 JWT(Json Web Token)，这种 token 不需要存储到服务器，自身就能进行验证。

JWT 中存储了 token 的签名，用户信息，还可以存储 token 的签发时间用于服务器验证 token 的有效期，并且这些信息如果被篡改了的话就会导致 token 失效，JWT 的理论请参考 http://www.jianshu.com/p/576dbf44b2ae。

为了在 Spring Security 中使用 JWT，需要修改下面 3 个类:

• TokenAuthenticationFilter
• TokenService
• JwtUtils

如下面层级结构的权限:

1
2
3

ROLE_ADMIN > ROLE_STAFF
ROLE_STAFF > ROLE_USER
ROLE_USER  > ROLE_GUEST

A user who is authenticated with ROLE_ADMIN, will behave as if they have all four roles, as well the user will have the authorities ROLE_USER and ROLE_GUEST who is authenticated with ROLE_USER，请参考帮助文档。

Spring Security 里通过 RoleHierarchyVoter 实现权限继承(只需要配置，不需要写代码)。

注意:

<http> 需要设置 use-expressions 为 false，禁用 SpEL 表达式进行权限判断，因为它为 true 时 Spring Security 使用 WebExpressionConfigAttribute，它的 getAttribute() 总是返回 null，导致 RoleVoter.supports() 总是返回 false，于是权限校验失败，为 false 时使用的是 SecurityConfig，这时就没问题了，可以在 RoleVoter.vote() 中打断点进行验证。

坑爹的是，Spring Security 的帮助文档里没说这个，走了不少弯路。

微信企业号主要是为了链接组织和内部员工的，通过提供通讯录、组织新闻公告、活动、投票、调研、论坛 BBS、意见建议墙、招聘、考勤、流程审批、任务管理等一系列功能和服务，提高组织运作效率。微信企业号是微信为企业客户提供的移动服务，旨在提供企业移动应用入口。

微信企业号，有以下一些特点：

• 关注更安全

  只有企业通讯录的成员才能关注企业号，分级管理员、保密消息等各种特性确保企业内部信息的安全

• 应用可配置

  企业可自行在企业号中配置多个服务号，可以连接不同的企业应用系统，只有授权的企业成员才能使用相应的服务号

• 消息无限制

  发送消息无限制，并提供完善的管理接口及微信原生能力，以适应企业复杂、个性化的应用场景

• 使用更便捷

  企业号在微信中有统一的消息入口，用户可以更方便地管理企业号消息。微信通讯录也可以直接访问企业号中的应用

前面通过表单进行登陆，会为用户创建一个 session 保存在服务器端，session id 保存在 cookie 中，每次访问服务器的时候服务器端从 cookie 中读取 session id 然后找到用户的 session，就能知道当前用户的信息。但是对于移动端来说，传递 cookie 不是很方便，一般都会使用 token 来进行验证。

Token 就是一个字符串(可以使用 uuid)，验证时使用的 token 可以理解为和 session id 的功能差不多:

1. 用户申请 token 时，可以把 token 作为 key，用户信息的对象作为 value 保存到 Redis 中，把 token 返回给移动端
2. 移动端保存 token，有很多种方式，例如保存到文件中，sqlite 里都可以
3. 每次访问的时候把 token 放到请求的 header 中
4. 服务器端从 header 中读取 token，然后用 token 作为 key 去 Redis 中去读用户数据
5. 如果读取到的用户数据有效，则说明用户是合法的，认证通过，继续访问，否则返回错误，终止请求

使用纯 token 验证，不支持 session，这样的应用一般都是用来提供纯数据服务(应用中没有网页，很多微服务就是这样的)，以下叫 DSA(Data Service Application)，但是数据也是需要后台功能来管理的，大多都会使用 Web 应用，叫 DMA(Data Management Application)，Web 应用需要使用 session，也就是说 DSA 和 DMA 是独立的 2 个应用，不能共存，因为 DSA 中不支持 session，而 DMA 中需要 session。这种设计的好处是 DSA 很轻量级，只关心数据服务，能够降低开发的复杂度，还有其它比如每个服务都很简单，只关注于一个业务功能，每个微服务可以由不同的团队独立开发，微服务是松散耦合的等等。但是也有缺点，比如有可能对资源的访问需要重复实现，例如一个电子图书馆程序，读取图书信息的 API /api/books/{bookId} 在 DSA 中需要实现，在 DMA 中也要提供实现，因为 DMA 中也需要读取图书信息进行管理，就算用分布式服务使用 dubbo 负责服务治理，由 DMA 提供访问数据的逻辑，但是 DSA 和 DMA 里都至少也要各自有个 Controller 来处理这个 URL 吧。

本文的目的，是要实现一个 Web 应用即支持 session，同时又能支持使用 token 进行身份验证时不生成 session:

• 浏览器访问 /api/books/{bookId} 时，从 cookie 中读取 session id 找到对应的 session，获取当前用户，如果没有登陆则跳转到登陆页面进行登陆，登陆成功会创建 session
• 移动端访问 /api/books/{bookId} 时，从 header 中读取 token 找到对应的用户，如果没有 token 或者 token 过期、用户信息无效则返回错误提示未登陆认证(token 可以事先请求保存起来)，整个过程不会产生 session

程序在开发工具例如 Qt Creator 中运行没有问题，不少同学开发好后就直接把 xxx.exe 给用户使用，用户双击 xxx.exe 后提示错误，打开程序失败。很是奇怪: 程序在我的电脑里打开好好的，为什么到其他电脑上就不行了呢，是不是他的电脑有问题？不知道此同学有没有在自己电脑上双击过这个程序！

例如双击下面的 Gui.exe，提示找不到 libgcc_s_dw2-1.dll，那是因为 Qt 的程序运行的时候除了需要可执行程序本身外，还需要依赖一些其他的 dll，需要把这些 dll 一起打包给用户才行:

Qt 程序打包一般有 2 种方式，纯手动打包和半自动打包，下面以 Windows 中打包 Qt 程序 Gui.exe 为例进行介绍，环境如下:

• 安装 MinGW 的 Qt 5.9.1 到 F 盘
• DLL 目录: F:\Qt\Qt5.9.1\5.9.1\mingw53_32\bin
• Qt 的插件目录: F:\Qt\Qt5.9.1\5.9.1\mingw53_32\plugins

GitBook 是一个使用 Markdown 文件，用来写书、说明文档等的工具，它的官网已经有 5 万多本使用 GitBook 写的书了，现在不少公司都开始用 GitBook 来写项目文档、使用手册等。下面就简要的介绍怎么使用 GitBook，首先需要安装下面这些软件:

1. 安装 Git
2. 安装 Nodejs
3. 安装 GitBook: npm install gitbook -g
4. 安装 GitBook-Cli: npm install gitbook-cli -g

本地搭建 GitBook

本地搭建 GitBook 的好处是我们可以自己管理文件的存储，例如可以放到公司的 Git 私服上:

1. 创建目录例如 Pandora 用于存放书的文件，进入目录

2. 创建文件 README.md 和 SUMMARY.md，它们是 GitBook 最重要的 2 个文件，README.md 对书进行介绍，在 SUMMARY.md 中描述书的目录结构，其内容可参考如下:

   README.md:

   1	本书用于介绍 Pandora 项目的使用说明

   SUMMARY.md:

   1 2 3 4 5 6 7 8 9 10

   # Summary * [简介](README.md) * [第一章](chapter1/README.md) * [第一节](chapter1/section1.md) * [第二节](chapter1/section2.md) * [第二章](chapter2/README.md) * [第一节](chapter2/section1.md) * [第二节](chapter2/section2.md) * [结束](end/README.md)

3. 执行 gitbook init:

   会自动创建 SUMMARY.md 中描述的目录结构对应的文件夹和文件，每次执行这个命令都会创建还没有还不存在的文件和文件夹，但是不会影响已经创建的，所以不用担心多次执行 gitbook init 导致数据丢失

4. 编辑书的 Markdown 文件，例如 section1.md 等

5. 安装插件 gitbook install

6. 执行 gitbook serve，在浏览器里访问 http://localhost:4000 就可以看到上面写的书了，以后常用的也是这个命令，当文件变化后可以在网页中及时看到新的变化

   Bug: Windows 中 gitbook serve 运行后，当文件发生变化时不是自动更新网页而是退出，可以使用下面的脚本来运行 gitbook serve 解决这个问题：

   1 2 3 4

   @Echo off :Start call gitbook serve goto Start

   把上面的文件保存为 gs.bat 放到 GitBook 目录中，运行 gs.bat 就可以了。

Video.js 是一个简洁、漂亮的 HTML5 播放器，支持字幕，还可支持 Flash(不支持 HTML5 时自动切换到 Flash)，使用很简单，也能自定义插件:

Video.js is a JavaScript and CSS library that makes it easier to work with and build on HTML5 video. This is also known as an HTML5 Video Player. Video.js provides a common controls skin built in HTML/CSS, fixes cross-browser inconsistencies, adds additional features like fullscreen and subtitles, manages the fallback to Flash or other playback technologies when HTML5 video isn’t supported, and also provides a consistent JavaScript API for interacting with the video.

JS 的事件有几个重要的坐标:

• (offsetX, offsetY): 事件触发点在事件源元素的坐标系统中的坐标(相对于元素的左上角，左上角坐标为 (0, 0))
• (pageX, pageY): 事件触发点相对于整个页面左上角的坐标，包括了滚动条隐藏的部分
• (clientX, clientY): 事件触发点相对于页面可视部分(客户区)左上角的坐标，不包括滚动条隐藏的部分
• (screenX, screenY): 事件触发点相对于屏幕左上角的坐标

有时希望限制同一个账号同时只能有 1 个用户登陆，通常为后一次登录将使前一次登录失效。Spring Security 的 session-management为我们提供了这种限制:

1. 在 web.xml 中定义监听器 HttpSessionEventPublisher

   1 2 3

   <listener> <listener-class>org.springframework.security.web.session.HttpSessionEventPublisher</listener-class> </listener>

2. 通过 concurrency-control 来限制账号登陆数

   1 2 3 4 5 6

   <http auto-config="true"> ... <session-management> <concurrency-control max-sessions="1"/> </session-management> </http>

   ​

每个 Thread 都有一个 ThreadLocalMap 的对象，存储时以 ThreadLocal 变量为 key，set() 的参数作为 value，这样同一个 ThreadLocal 变量在不同的线程中就可以存储不同的数据。

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

public class ThreadLocalTest {
    private static ThreadLocal<String> foo = new ThreadLocal<>();

    public static void main(String[] args) throws Exception {
        new Thread(() -> {
            await(300);
            System.out.println(Thread.currentThread().getName() + ": " + foo.get()); // [2] 输出: Thread-1: null
            foo.set("1"); // [3]

            await(1000);
            System.out.println(Thread.currentThread().getName() + ": " + foo.get()); // [5] 输出: Thread-1: 1
        }, "Thread-1").start();

        new Thread(() -> {
            foo.set("2"); // [1]

            await(600);
            System.out.println(Thread.currentThread().getName() + ": " + foo.get()); //[4] 输出: Thread-2: 2
        }, "Thread-2").start();
    }

    public static void await(long timeout) {
        try { Thread.sleep(timeout); } catch (InterruptedException e) {}
    }
}

输出:

1
2
3

Thread-1: null
Thread-2: 2
Thread-1: 1

ThreadLocal 的变量一般定义为 private static 的。

使用 canvas 绘图时，很多时候在 canvas 上绘制的图像只占 canvas 的一部分，如果把整个 canvas 的图像发送到服务器就比较浪费空间和带宽，所以保存真正绘制的图像部分是有必要的。

下图的上部分为一个的 canvas，绘制的图像大概只占它的四分之一，我们的目的是把 canvas 中多余的部分去掉，得到真正绘制的图像，如下部分显示:

MyCLI 是一个 MySQL 的命令行客户端，可以实现自动补全（auto-completion）和语法高亮，具体特性如下:

• 智能补全
• SQL 语法高亮显示
• 自动完成输入 SQL关键字以及数据库列表
• SELECT * FROM <tab> 只显示表名
• SELECT * FROM users WHERE <tab> 只显示列名
• 支持 tab 自动补全
• MySQL 的输出会通过 less 命令进行格式化输出
• 支持 ssl 连接

可以使用 OpenCV 来操作摄像头，不过 Qt5 已经自带了调用系统摄像头的功能，在 .pro 文件中增加下面的模块:

1

QT += multimedia multimediawidgets

主要是使用下面 3 个类，使用起来很方便:

• QCamera
• QCameraViewfinder
• QCameraImageCapture

下面代码的效果为

Thymeleaf 使用 HTML 元素的属性获取 model 中的数据，属性的前缀是 th:，例如 th:text, th:src。

变量访问

1
2
3
4
5
6
7

<!-- 使用属性的方式访问变量 -->
<span th:text="${name}">Thymeleaf 解析后会被覆盖</span>
<span th:text="|Welcome ${name}|">Thymeleaf 解析后会被覆盖</span>
<span th:text="'Welcome ' + ${name}">Thymeleaf 解析后会被覆盖</span>

<!-- 非属性的方式访问变量 -->
<span>[[${name}]]</span>

字符串拼接时 |...| 的方式更简洁，但是里面不能包含表达式，第三种方式功能强大，可以包含表达式。

变量访问也可以使用级联的方式: ${user.name}。

null 处理

表达式 ${foo}? 当 foo 为 null 时返回 false；级联调用时变量访问前先用 ? 进行判断可以减少一个一个的条件判断

1
2

<div th:text="${foo}?'Alt'"></div>
<div th:text="${foo?.bar?.fix}"></div>

使用 URL

1

<a th:href="@{/login}" th:if="${session.user == null}">Login</a>

使用 th:href="@{/uri}" 引入 URL，/ 开头时会在 URI 前面加上项目的 context path。

有了 Freemarker，Velocity 等模版后，为什么要选择 Thymeleaf？

• Freemarker 的模版还是有一些非 HTML 的标签在里面，对于前端来说需要学习相关语法
• Velocity 虽然也很好，但是已经很久不更新了，Spring 5 已经官方宣布不支持 Velocity 了
• Thymeleaf 的语法就是 HTML 的语法，动态内容部分使用 HTML 的属性来实现，属性部分不会影响 HTML 的设计，前后端可以很好的分离

第一步: 我们要确定一个可行的设计方案:	第二步: 我们要开始把框架搭好	第三步: 我们开始一个模块一个模块的完成
第四步: 可以拿去给测试们看了(白盒黑盒都有)	第五步: 产品经过测试通过可以拿去给安全组检查了	最后: 我们的产品就可以上线了

I make things.

项目打包后一般可以按照以下几个步骤进行部署：

1. 选择正确的环境打包: 测试环境、线上环境等
2. 把 war 包上传到服务器（使用 FTP、scp 等）
3. 停止 tomcat: <tomcat>/bin/shutdown.sh
4. 删除服务器上的项目文件: rm -rf <project_path>
5. 解压 war 包到项目路径下: unzip project.war -d <project_path>
6. 启动 tomcat: <tomcat>/bin/startup.sh
7. 删除上传的 war 包
8. 如果有 N 个服务器，就需要重复 2 到 7 共 N 次

每次部署都要手动重复这么多步骤，效率很低不说，还容易疏忽出错，为了解决这些问题，借助 Gradle 的 deploy 插件，一条命令 gradle deploy 就完成上面的这些事了。

如下图使用多个 步骤 表示一个过程：

这样的组件 Qt 没有提供，需要我们自己实现，可以用下面几种方式实现:

• 使用 QPainter 绘图：计算每一个步骤的图形(可以使用 QPainterPath)和位置，然后在 QPainterPath 上填充背景和文字

• QPushButton + QSS Border-Image + 绝对坐标定位：因为 QPushButton 之间有重叠，而不是一个紧挨着一个的排列，所以需要计算每个步骤的坐标进行定位，使用 PS 设计步骤在不同状态时的背景图，需要 6 张图片：

  • 当前步骤：第一个位置的图、中间的图、最后一个位置的图

  • 非当前步骤：第一个位置的图、中间的图、最后一个位置的图

  • 每个图是步骤的完整背景图，例如

    

    优点：直观

    缺点：需要手动计算坐标

• QPushButton + QSS Border-Image + QHBoxLayout：使用 Layout 把 QPushButton 一个紧挨着一个的排列，使用 PS 设计步骤在不同状态时的背景图，需要 5 张图片：

  • 当前步骤：当前步骤前一个步骤的图、最后一个位置的图

  • 非当前步骤：第一个位置的图、中间的图、最后一个位置的图

  • 每个图都不是步骤的完整背景图，例如

    

    优点：能够使用 Layout 进行布局，不需要手动计算坐标

    缺点：不够直观，不过，在步骤之间加一点空隙，估计大家都明白怎么做了：每一个步骤的背景都有一部分在它的前一个步骤上：

    

Nginx 作为前端反向代理或者负载均衡，Tomcat 不需要自己处理 https，https 由 Nginx 处理:

• 用户首先和 Nginx 建立连接，完成 SSL 握手
• 而后 Nginx 作为代理以 http 协议将请求转发给 Tomcat 处理
• Nginx 再把 Tomcat 的输出通过 SSL 加密发回给用户

Tomcat 只是在处理 http 请求而已 (默认监听 8080 端口)。因此，这种情况下不需要配置 Tomcat 的 SSL，只需要配置 Nginx 的 SSL，Tomcat 和 Nginx 需要配置以下几项:

• Nginx 中启用 https:

  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

  http { include mime.types; default_type text/html; gzip on; gzip_types text/css text/x-component application/x-javascript application/javascript text/javascript text/x-js text/richtext image/svg+xml text/plain text/xsd text/xsl text/xml image/x-icon; sendfile on; # Tomcat 服务器集群 upstream app_server { server 127.0.0.1:8080 weight=4; server 127.0.0.1:8081 weight=2; server 127.0.0.1:8082 weight=1; } server { listen 443 ssl; # https 的默认端口是 443 charset utf-8; server_name www.xtuer.com; # host_name of URL # 启用 https # ssl on; # deprecated, use listen 443 ssl instead ssl_certificate /Users/Biao/Desktop/cert/server.crt; ssl_certificate_key /Users/Biao/Desktop/cert/server.key; location / { proxy_redirect off; proxy_set_header Host $host; proxy_set_header X-Real-IP $remote_addr; proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for; # 把 https 的协议告知 Tomcat，否则 Tomcat 可能认为是 http 的请求 proxy_set_header X-Forwarded-Proto $scheme; # 请求转发给 Tomcat 集群处理 proxy_pass http://app_server; } } }

  关键是以下几项:

  • listen port ssl
  • ssl_certificate
  • ssl_certificate_key
  • X-Forwarded-Proto

• Tomcat 的 server.xml 的 Host 中配置 Valve:

  1 2 3

  <Host name="localhost" appBase="webapps" unpackWARs="true" autoDeploy="true"> <Valve className="org.apache.catalina.valves.RemoteIpValve" remoteIpHeader="X-Forwarded-For" protocolHeader="X-Forwarded-Proto" protocolHeaderHttpsValue="https"/> </Host>

  • X-Forwarded-Proto 是为了正确地识别实际用户发出的协议是 http 还是 https
  • X-Forwarded-For 是为了获得实际用户的 IP
  • 如果不配置它们，则在 redirect 的时候仍然会使用 http 而不是 https

Vue 提供了自定义组件的功能，可以定义全局组件，也可以定义局部组件：

• 全局组件: 使用 Vue.component() 来注册
• 局部组件: 使用 Vue 对象的 components 属性来注册

下面先介绍全局组件的自定义，然后再简要的介绍局部组件的自定义。

QtCreator 中创建的 Qt Designer Form Class 包含三个文件: .h, .cpp, .ui，例如我们创建了一个 Form Class Widget，则包含下面三个文件：Widget.h, Widget.cpp, Widget.ui，其中的类名为 Widget，如果想要把其重命名为 MyWidget，则可以按照下面几步进行：

• 文件重命名：
  • Widget.h -> MyWidget.h
  • Widget.cpp -> MyWidget.cpp
  • Widget.ui -> MyWidget.ui
• 修改 MyWidget.ui 中的 objectName 为 MyWidget
• 重构 MyWidget.h 中的类名:
  • Ui::MyWidget -> Ui::Widget
  • MyWidget -> Widget
• 修改 MyWidget.h 中 #ifndef 的名字: WIDGET_H -> MYWIDGET_H
• 修改 MyWidget.cpp 中的 #include "ui_Widget.h" -> #include "ui_MyWidget.h"

签名验证

签名验证涉及到客户端（比如一个 Web 应用）和服务器端，每个客户端在服务器上有一个对应的 app_id 和 app_key，大致步骤如下：

1. 客户端使用 app_id + app_key + 其他参数 生成签名字符串 sign1

2. 把 app_id、其他参数 和 sign1 一起发送给服务器 (app_key 不发送)

3. 服务器接收到请求后，根据参数中的 app_id 查找到对应的 app_key，然后根据签名算法生成签名字符串 sign2

   客户端和服务器端使用同样的签名算法生成签名字符串: app_id + app_key + 其他参数

4. 服务器端比较参数中的 sign1 和服务器生成的 sign2，如果相等则签名没问题，放行访问，否则签名无效，拒绝访问

JavaScript 已经自带了随机数生成函数，为什么我们还需要弄一个随机数的生成工具呢？

例如 Web 的考试系统里，加载试卷后，需要把试卷的题目顺序打乱，如果用 JS 的随机数函数的话，每次打乱的顺序都是不一样的，因为每次生成的随机数序列都不一样。问题出现了，同一个学员刷新试卷后，题目的顺序和上一次的竟然不一样，这不符合实际要求，应该是不同学员的题目顺序不一样，但是同一个学员的题目顺序永远是一样的。这样就不能使用直接使用原生的随机函数了，下面定义一个随机数生成函数，随机数种子是一个字符串，这样就可以用学员的编码来作为随机数种子生成随机数打乱题目的顺序了，因为每次刷新时同一个学员的编码都是一样的，所以生成的随机数序列都相同，就保证了同一个学员的试卷题目顺序一直都是一样的。

Velocity 比较接近脚本语言，例如 JS

1
2
3
4
5
6
7
8
9

#if ($foo < 10)
    ...
#elseif ($foo == 10)
    ...
#elseif ($foo == 12)
    ...
#else
    ...
#end

比较一下 Freemarker

1
2
3
4
5
6
7
8
9

<#if foo < 10> 
    ... 
<#elseif foo == 10> 
    ... 
<#elseif foo == 12> 
    ... 
<#else>
    ...
</#if>

Velocity 可以作为 SpringMVC 的 View 使用，也可以用来生成邮件，静态页面等。

Velocity 模版中可以直接调用对象的方法，这点比 Freemarker 好用，if else foreach 等语句也更舒服。

Gradle 依赖

1
2

compile 'org.apache.velocity:velocity:1.7'
compile 'org.apache.velocity:velocity-tools:2.0'

JSP 和 Velocity 都用于显示层，但是都有自己的优缺点。

Velocity 比 Freemarker 快，而且语法也更舒服。

Velocity 的优点：

1. 不能编写 Java 代码，可以实现严格的 MVC 分离，可维护性好
2. 性能不错，比 JSP 快
3. 对 JSP 标签支持良好
4. 内置大量常用函数
5. 宏定义非常简单(类似 JSP 标签)
6. 使用表达式语言
7. 美工和技术的工作分离（例如命名为 .htm 的格式，不需要经过 Server 就能在浏览器里看到效果，JSP 这一点不太方便）

Velocity 的缺点：

1. 不是官方标准
2. 用户群体和第三方标签库没有 JSP 多

本文介绍在 Qt 中绘制平滑曲线的实现，调用下面的函数 SmoothCurveGenerator::generateSmoothCurve(points) 即可。默认曲线的 2 个顶点之间被分割为 16 个小线段来拟合曲线，下图展示了 tension 为 0.5（默认值） 的曲线效果，tension 并不是越大越好，默认的 0.5 大多数时候就不错。

算法来自于 How to draw smooth curve through N points using javascript HTML5 canvas?

Canvas 还没有提供直接绘制椭圆的功能，下面使用 bezierCurveTo() 来绘制椭圆。

圆也是使用 arc 来绘制的，在新版的 JS 中提供了 ellipse 来绘制椭圆，但是很多浏览器都还不支持

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

<!DOCTYPE html>
<html>

<head>
    <meta charset="utf-8">
    <script src="http://cdn.bootcss.com/jquery/3.2.1/jquery.min.js"></script>
    <style media="screen">
        canvas {
            border: 1px solid grey;
        }
    </style>
</head>

<body>
    <canvas id="canvas" width="500" height="300">Your browser does not support canvas.</canvas>

    <script>
        var canvas = $('#canvas').get(0);
        var ctx = canvas.getContext('2d');

        drawEllipse(ctx, 100, 100, 80, 120);
        drawEllipse(ctx, 200, 200, 200, 80);

        function drawEllipse(context, centerX, centerY, width, height) {
            context.beginPath();
            context.moveTo(centerX, centerY - height / 2);

            context.bezierCurveTo(
                centerX + width / 2, centerY - height / 2,
                centerX + width / 2, centerY + height / 2,
                centerX, centerY + height / 2
            );
            context.bezierCurveTo(
                centerX - width / 2, centerY + height / 2,
                centerX - width / 2, centerY - height / 2,
                centerX, centerY - height / 2
            );
            context.closePath();
            context.stroke();
        }
    </script>
</body>

</html>

本文介绍在 JS 中绘制平滑曲线的实现，调用下面的函数 drawSmoothCurve() 即可。默认曲线的 2 个顶点之间被分割为 16 个小线段来拟合曲线，下图展示了 tension 为 0.3，0.5，0.7 时的曲线效果，tension 并不是越大越好，默认的 0.5 大多数时候就不错。

算法来自于 How to draw smooth curve through N points using javascript HTML5 canvas?

Canvas 的 context 调用 getImageData() 获取 canvas 中图片的像素数据，处理好后再调用 putImageData() 设置回 canvas。

1
2
3
4
5
6
7
8

var canvas = $('#canvas').get(0);
canvas.width = 500; // canvas 的实际宽度，默认是 300
canvas.height = 300;
var ctx = canvas.getContext('2d');

var imageData = ctx.getImageData(0, 0, canvas.width, canvas.height); // 获取像素数据
grayscale(imageData); // 处理像素数据
ctx.putImageData(imageData, 0, 0); // 设置回 canvas

本文的目的是为了测试 Java 的 UUID.randomUUID() 生成 UUID 是否重复，使用了 2 种方式:

1. 多线程加 ConcurrentSkipListSet
2. 多线程加 MySQL
   1. 多线程生成 UUID
   2. 保存 UUID 到文件
   3. 导入文件中的 UUID 到 MySQL
   4. 使用 GROUP BY 和 HAVING 查找重复的 UUID

结果：尝试了多次，生成 1 万个，10 万，100 万个 UUID 都没有发现重复的情况。

在编写程序时，我们经常会遇到一些基于条件判断的逻辑，比如：判断该条数据是否已经在数据库中存在，如果不存在，则插入。

技巧一：使用 ignore 关键字

如果是用主键 primary 或者唯一索引 unique 区分了记录的唯一性，避免重复插入记录可以使用 insert ignore into。

当插入数据时，如出现错误时，如重复数据，将不返回错误，只以警告形式返回。所以使用 ignore 请确保语句本身没有问题，否则也会被忽略掉。

以下为 JDBC 和 MyBatis 的性能比较参考，MyBatis 的性能比 JDBC 大概慢三分之一，看上去相差挺大的，不过网络才是对效率影响最大的因素，局域网中有 200 多倍的影响，这么比较起来，MyBatis 和 JDBC 本身的效率差距可以忽略不计了。

测试 2 种情况 (每条记录有 7 个字段)

• 向本机的数据库插入 66720 条记录
• 向局域网中其他机器上的数据库插入 20000 条记录

在向局域网中其他机器上不停的插入数据时，2 台机器的 CPU 占用都很小，也就百分之几，因为大多数时候都在等待 IO。

Vue 后台管理简单框架（一） 中搭建出了后台管理的页面框架，但是还没有添加其他的功能，例如使用 Vuex 实现模块间数据共享、与服务器通讯、功能独立为模块、修改打包选项等，这一章主要的内容就是介绍这些功能的实现。

Vue 后台管理简单框架（一）中介绍了单页 SPA 的实现，但是实际系统中后台管理的功能很可能是需要多页的，例如要开发一个学习系统，学生和老师的管理功能完全不一样，如果非要把它们放在一起使用 SPA 的方式也可以，左边菜单栏根据角色是老师或则学生来动态显示也是可以的，但是这样会导致管理页的代码很多，功能都放在一起，开发的时候可能不够清晰，增加开发难度，如果把它们分开，使用多页的方式来实现，功能模块就很清晰了，不失为一个好办法。还有例如 PC 的网页和移动设备的网页实现不同，如果放在同一个页面就需要做各种判断来确定对应设备显示的内容也会把很简单的逻辑搞的很复杂，使用不同的页面的话就会很清晰了。

下面就来介绍把 vue-cli 创建的工程改造为支持多页：

• 不同页面的文件放在不同的文件夹下

  每个页面都有自己的 router.js, index.js, index.vue, index.html

• 修改 4 个配置文件：

  • webpack.base.conf.js: 修改入口文件 entry
  • webpack.dev.conf.js: 修改 HtmlWebpackPlugin
  • webpack.prod.conf.js: 修改 HtmlWebpackPlugin，删除 CommonsChunkPlugin
  • .eslintrc.js

vue-cli 简单搭建项目框架 后我们知道了怎么使用 vue-cli 创建一个项目，但是页面比较简单，一般后台管理功能的界面会像下面这样子:

下面介绍怎么实现一个这样的界面，UI 的框架使用 iView。

可以使用 Java 提供的线程池简单地实现一个任务队列:

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

package com.xtuer.util;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * 任务队列，同时执行任务的数量由构造函数的参数 concurrentTaskCount 指定。
 */
public class TaskQueue {
    private ExecutorService executor;

    /**
     * 创建任务队列，concurrentTaskCount 指定同时执行任务的数量。
     * 有些情况下任务需要排队一个执行完后再执行另一个，此时 concurrentTaskCount 传入 1。
     *
     * @param concurrentTaskCount 同时执行任务的数量
     */
    public TaskQueue(int concurrentTaskCount) {
        executor = Executors.newFixedThreadPool(concurrentTaskCount);
    }

    /**
     * 添加任务，根据不同的业务逻辑定义一个任务类，继承自 Runnable，
     * 可以在属性中存储任务相关的数据，在 run() 中实现任务逻辑。
     * 当然也可以重载 addTask() 函数实现添加不同的任务。
     *
     * @param task
     */
    public void addTask(Runnable task) {
        executor.submit(task);
    }

    /**
     * 下面的实现是为了测试使用
     *
     * @param n 任务内容
     * @param delay 任务消耗的时间，单位为秒，为了测试用的
     */
    public void addTask(int n, int delay) {
        addTask(() -> {
            // 模拟任务执行消耗时间
            try {
                Thread.sleep(delay * 1000);
            } catch (InterruptedException e) {
            }

            System.out.println(n + " started at " + System.currentTimeMillis() + " and elapsed " + delay * 1000);
        });
    }

    /**
     * 销毁任务队列，不再接受新的任务。
     * Spring bean 的 destroy-method 函数。
     */
    public void destroy() {
        executor.shutdown();
    }

    public static void main(String[] args) throws Exception {
        TaskQueue taskQueue = new TaskQueue(1);

        taskQueue.addTask(1, 1);
        taskQueue.addTask(2, 1);
        taskQueue.addTask(3, 1);
        taskQueue.addTask(4, 1);
        taskQueue.addTask(5, 1);

        taskQueue.destroy();
    }
}

可以如下使用 Spring bean 来生成任务队列的对象

1
2
3
4
5
6
7
8
9

<!--单任务队列-->
<bean id="singleTaskQueue" class="com.xtuer.util.TaskQueue" destroy-method="destroy">
    <constructor-arg value="1"/>
</bean>

<!--多任务队列-->
<bean id="multiTaskQueue" class="com.xtuer.util.TaskQueue" destroy-method="destroy">
    <constructor-arg value="222"/>
</bean>

然后在 Controller 中如下使用

1
2
3
4
5
6
7
8
9
10
11

@Resource(name="singleTaskQueue")
private TaskQueue singleTaskQueue;

@GetMapping("/tasks/{taskId}")
@ResponseBody
public Result task(@PathVariable int taskId) {
    Random rand = new Random();
    singleTaskQueue.addTask(taskId, rand.nextInt(4) + 1); // 任务执行时间为 1 到 4 秒

    return Result.ok("" + taskId);
}

完全自己实现的话，任务队列继承 Thread，用一个 list 存储任务，在 run() 函数中用循环查看是否有任务可执行，如果没有则调用 wait() 等待，当调用 addTask() 添加新的任务后调用 notify() 让 while 循环中可获取一个任务执行，获取和添加任务时还要锁住队列等，如果同时允许执行多个任务则还要用一个计数器记录正在执行的任务数，需要处理好各种细节。使用 Executors.newFixedThreadPool() 后，这些细节都不需要我们关心了。

下面介绍使用 JodConverter + LibreOffice 把 Windows Office 的 doc，docx，xls 等文档转换为 PDF 和 HTML:

• HTML:
  • 优点: 用浏览器打开方便，便于实现 doc 等在线预览
  • 缺点: 相对于 PDF 大不少，图片是独立文件，格式也没有 PDF 的漂亮
• PDF:
  • 优点: 比 HTML 格式小，格式比较接近于原文档
  • 缺点: 相对于 HTML 在线预览不够方便，也可以借助 pdf.js + HTML5 实现在线预览

实现点击按钮下载文件以及点击 a 标签下载文件，注意一下几个问题:

• 浏览器中点击链接下载文件没啥好说的，但是点击按钮怎么实现下载呢？

  1	调用 window.open(url) 就可以了

• 服务器端需要设置响应头表明是以流的形式下载文件

  1	response.setContentType("application/octet-stream");

• 文件名有中文时需要处理乱码问题

  1 2	String filename = new String(paper.getOriginalName().getBytes("UTF-8"), "ISO8859_1"); // 解决乱码问题 response.setHeader("Content-Disposition", "attachment;filename=" + filename);

创建数据库

1

CREATE DATABASE ebag DEFAULT CHARACTER SET utf8 COLLATE utf8_general_ci

增加新列

1

ALTER TABLE table_name ADD COLUMN column_name varchar(64)

分页查询

MySQL 中使用 LIMIT 进行分页，第一个参数是起始位置 offset，从 0 开始，第二个参数是要取多少条记录

1

SELECT * FROM question WHERE subject_code='XXX' LIMIT 0, 30

插入更新

查看 UNIQUE 索引或 PRIMARY KEY 对应的行是否存在，存在则更新 (执行 ON DUPLICATE KEY UPDATE 后面的语句)，不存在则插入新行

1
2
3

# id 是唯一主键
INSERT INTO question (id, type, content) VALUES (#{id}, #{type}, #{content})
ON DUPLICATE KEY UPDATE content=#{content}

插入时先使用条件查询，满足条件时才插入，不满足条件就不进行插入

1
2
3
4
5
6
7
8

# 根据条件查询，满足条件时才插入
INSERT INTO paper_knowledge_point_relation(paper_id, knowledge_point_id, tenant_code)
SELECT #{paperId}, #{knowledgePointId}, #{tenantCode}
FROM   dual
WHERE NOT EXISTS(
    SELECT 1 FROM paper_knowledge_point_relation
    WHERE paper_id=#{paperId} AND knowledge_point_id=#{knowledgePointId} AND tenant_code=#{tenantCode}
)

查询更新

查询的结果作为临时表，更新知识点下的题目数量

1
2
3

UPDATE question_knowledge_point qkp
JOIN   (SELECT knowledge_point_id AS id, COUNT(id) AS count FROM question GROUP BY knowledge_point_id) AS t ON qkp.id=t.id
SET    qkp.count=t.count

使用了子查询

左连接

查询所有题目及它的选项

1
2
3

SELECT q.id, q.content, qo.id, qo.content
FROM   question q
LEFT JOIN question_option qo ON q.id=qo.question_id

内连接

内连接 JOIN 和 WHERE 等价，查询所有有选项的题目

1
2
3
4
5
6
7

SELECT q.id, q.content, qo.id, qo.content
FROM   question q
JOIN   question_option qo ON q.id=qo.question_id

SELECT q.id, q.content, qo.id, qo.content
FROM   question q, question_option qo
WHERE  q.id=qo.question_id

可参考 https://www.cnblogs.com/eflylab/archive/2007/06/25/794278.html

分组

统计有选项的题目的选项个数

1
2
3
4

SELECT q.id, count(1), qo.id, qo.content
FROM   question q
JOIN   question_option qo ON q.id=qo.question_id
GROUP BY q.id

数据量大时 JOIN 比 LEFT JOIN 快很多

类型转换

使用 CAST 转换类型

1

SELECT CAST(id AS CHAR) AS id FROM question

切换 0 和 1

如果是 0 则设置为 1，否则设置为 0，对于切换 true 和 false 很有用，很像三元运算符

1

UPDATE demo SET is_marked=IF(is_marked=0, 1, 0)

字符串连接

使用 CONCAT(p1, p2, p3) 连接字符串

1

SELECT CONCAT(subject_code, '-', original_id) FROM question WHERE is_marked=1

返回布尔值

JDBC 标准中，0 表示 false，1 表示 true，大于 1 和小于 0 的数没有定义，MySQL 的 JDBC Driver 中 <=0 表示 false，>=1 表示 true，为了保险起见，使用 EXISTS 来查询返回布尔值

1
2
3

SELECT EXISTS (
    SELECT 1 FROM paper WHERE paper_id=#{paperId}
)

建表语句

建表语句中需要有足够的注释描述每一列的作用，便于维护

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

#-------------------------------------------
# 表名：question
# 作者：公孙二狗
# 日期：2018-04-01
# 版本：1.0
# 描述：保存题目
#------------------------------------------
DROP TABLE IF EXISTS question;

CREATE TABLE question (
    id bigint(20) unsigned NOT NULL COMMENT '题目 ID',
    type varchar(8) DEFAULT ''      COMMENT '题目类型',
    content mediumtext              COMMENT '题目内容：题干+选项',
    analysis mediumtext             COMMENT '题目解析',
    answer text                     COMMENT '题目答案',
    demand varchar(32) DEFAULT ''   COMMENT '教学要求',
    score int(11) DEFAULT 0         COMMENT '题目分值',
    difficulty int(11) DEFAULT 0    COMMENT '题目难度',
    original_id varchar(64) DEFAULT  ''        COMMENT '题目在乐教乐学数据库中的 ID',
    subject_code varchar(64) DEFAULT ''        COMMENT '题目的科目编码',
    knowledge_point_code varchar(8) DEFAULT '' COMMENT '题目的知识点编码',
    knowledge_point_id bigint(20) DEFAULT 0    COMMENT '题目的知识点 ID',
    is_marked tinyint(4) DEFAULT 0             COMMENT '是否被标记过，0 为未标记，1 为已标记',
    created_time datetime DEFAULT NULL         COMMENT '创建时间',
    updated_time timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
    PRIMARY KEY (id)
) ENGINE=InnoDB COMMENT '存储题目的表';

复合主键: PRIMARY KEY (code, type)，因为用 id 作为主键，所以不推荐使用复合主键，可以使用多列建立唯一约束。

唯一约束

UNIQUE 约束唯一标识数据库表中的每条记录。

UNIQUE 和 PRIMARY KEY 约束均为列或列集合提供了唯一性的保证。

PRIMARY KEY 拥有自动定义的 UNIQUE 约束。

每个表可以有多个 UNIQUE 约束，但是每个表只能有一个 PRIMARY KEY 约束。

• 唯一约束

  1	ALTER TABLE table_name ADD CONSTRAINT dict_identifier UNIQUE(code, type)

• 删除约束

  1	ALTER TABLE table_name DROP CONSTRAINT dict_identifier

添加索引

• 唯一索引

  1	ALTER TABLE table_name ADD UNIQUE (`column`)

• 普通索引

  1	ALTER TABLE table_name ADD INDEX index_name (`column`)

• 多列索引

  1	ALTER TABLE table_name ADD INDEX index_name (`column1`, `column2`, `column3`)

• 建表时用 KEY 创建索引

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

  #------------------------------------------- # 表名：dict # 作者：二狗 # 日期：2018-03-07 # 版本：1.0 # 描述：保存字典数据 #------------------------------------------ CREATE TABLE dict ( id bigint(20) unsigned NOT NULL COMMENT '字典的 ID', code varchar(128) NOT NULL COMMENT '字典的编码', value varchar(256) NOT NULL COMMENT '字典的值', type varchar(128) NOT NULL COMMENT '字典的类型', description text COMMENT '字典的描述', PRIMARY KEY (id), UNIQUE KEY dict_identifier (code, type) COMMENT 'code + type 唯一标记一个字典数据', KEY idx_type (type) COMMENT '类型建立索引' ) ENGINE=InnoDB DEFAULT CHARSET=utf8;

删除索引

1

ALTER TABLE table_name DROP INDEX index_name

创建视图

1
2
3
4
5
6
7
8
9
10
11

DROP VIEW IF EXISTS view_paper_knowledge_point;

CREATE VIEW view_paper_knowledge_point
AS SELECT
    pkpr.paper_id AS paper_id,
    kp.knowledge_point_id AS knowledge_point_id,
    kp.name AS name,
    kp.tenant_code AS tenant_code
FROM paper_knowledge_point_relation pkpr
LEFT JOIN knowledge_point kp ON pkpr.knowledge_point_id = kp.knowledge_point_id
WHERE kp.is_deleted=0;

使用 vue-cli 生成项目框架后，一般都会根据自己或则团队的风格微调一些参数。

具体步骤

1. 安装 node

2. 安装 vue-cli

   1	npm install -g vue-cli

3. 创建项目:

   1	vue init webpack projectname

A 机器上的 MySQL 默认只能 A 机器上的软件访问，即 localhost，如果 B 机器上的软件想访问 A 机器上的 MySQL，需要 MySQL 对 B 机器的 IP 进行授权。

方式一

• 任意主机以用户 root 和密码 root 连接到 MySQL 服务器

  1 2	GRANT ALL PRIVILEGES ON *.* TO 'root'@'%' IDENTIFIED BY 'root' WITH GRANT OPTION; FLUSH PRIVILEGES;

• 指定 IP 为（如192.168.10.186）的主机以用户 alice 和密码 Passw0rd 连接到 MySQL 服务器

  1 2	GRANT ALL PRIVILEGES ON *.* TO 'alice'@'192.168.10.186' IDENTIFIED BY 'Passw0rd' WITH GRANT OPTION; FLUSH PRIVILEGES;

方式二

网上还看到说直接修改 user 表中 User root 的 Host 为 %，最好别这么干，不小心会哭的:

1
2
3
4

USE mysql;
SELECT user, host FROM user;
UPDATE user SET host='%' WHERE user='root';
FLUSH PRIVILEGES;

按照上面的修改 host 为 % 后外网可以访问了，但是本地却访问出错:

1
2
3

mysql -uroot -p 
提示
Access denied for user 'root'@'localhost' (using password: YES) when trying

可用按下面的方式补救:

1
2
3
4
5
6
7
8
9
10

1. 启动 mysqld_safe
   mysqld_safe --user=mysql --skip-grant-tables --skip-networking &
2. 登陆修改
   mysql -u root mysql
   use mysql
   UPDATE user SET host='localhost' WHERE user='root';
   FLUSH PRIVILEGES;
   quit

这时可以看到 user 中关于 root 的记录会多一条

Semantic Ui 没有提供日期控件，在网上找到了一个基于它的实现，能够选择年、日期、时间、日期+时间，日期范围等，功能很齐全。

可以使用 npm 安装: npm install --save semantic-ui-calendar，也可以下载 semantic-ui-calendar.7z 直接使用，其外观如下:

从 GitHub 随机选择的 50,000 个开源 Java 项目中统计出最常用的 16 个 Java 实用工具类类及其最常用的方法，类列表和方法列表都按人气排序。

1. org.apache.commons.io.IOUtils
   • closeQuietly ( )
   • toString ( )
   • copy ( )
   • toByteArray ( )
   • write ( )
   • toInputStream ( )
   • readLines ( )
   • copyLarge ( )
   • lineIterator ( )
   • readFully ( )

zTree 不支持 jQuery ui 的拖拽操作，因为 drop 事件阻止了 mouse up 事件的冒泡以致 zTree 不能调用 onMouseUp 的回调函数。为了拖拽普通的 element 到 zTree 上，需要自己实现拖拽功能，Drag With Other DOMs 演示了具体的实现，但是代码太多，不易于理解，这里把拖拽相关的核心代码提取出来，就能快速的理解拖拽的实现。

Vue 的数据变化后会更新 DOM，但只能保证在当前 tick 里面的代码全部执行完毕后更新 (事件队列)，不能保证数据一变化后就能用 document.querySelector() 立即获取到最新的 DOM。要保证在 DOM 更新以后执行某一块代码，就必须把这块代码放到下一次事件循环里面，比如 setTimeout(fn, 0)，这样 DOM 更新后，就会立即执行这块代码。

有些时候 DOM 更新完成后执行某些操作是有必要的，这时就可以使用 Vue.nextTick() 注册一个函数放到 Vue 的事件队列里，使其在下一个 tick 被执行。

例如使用 Vue + Semantic Ui 创建 Popup，新创建的 Popup 需要执行 popup() 后才会生效，此时在 DOM 更新完成后需要执行一下 popup() 函数。

一般有 3 种方式调用 Vue.nextTick():

• 普通事件处理函数中，下面的 [[1]]，当有多个地方修改同一个变量时，每个地方都需要执行一次
• 监听指定的数据变化时，下面的 [[2]]，粒度细，只与数据是否变化有关，和修改数据的地方无关
• updated() 回调中，下面的 [[3]]，只要 DOM 变化了都会调用，无关的数据变化时都会调用，最省事，但是需要小心测试看看是否有副作用

JS and CSS

一下代码都是基于 jQuery、Semantic Ui、Layer、Vue 来写的:

1
2
3
4
5

<link rel="stylesheet" href="http://cdn.staticfile.org/semantic-ui/2.2.7/semantic.min.css">
<script src="http://cdn.bootcss.com/jquery/1.9.1/jquery.min.js"></script>
<script src="http://cdn.staticfile.org/semantic-ui/2.2.7/semantic.min.js"></script>
<script src="http://cdn.staticfile.org/vue/2.0.3/vue.js"></script>
<script src="http://cdn.staticfile.org/layer/2.3/layer.js"></script>

Semantic Ui 默认使用的是谷歌提供的字体，并且是直接使用了谷歌的官方链接。谷歌网站在国内访问速度很差，甚至根本无法访问，需要对 Semantic UI 的源文件进行一下手动修改:

1. 使用 Nodejs 下载 Semantic Ui 源码: http://www.semantic-ui.cn/introduction/getting-started.html

   • 安装 Nodejs
   • 安装 gulp: npm install -g gulp
   • 下载 Semantic Ui: npm install semantic-ui –save

2. 修改 src\themes\default\globals\site.variables

   • 修改文件中的 @fontName 的值来设置 Semantic UI 的默认字体，这里使用了微软雅黑: Microsoft YaHei
   • 修改文件中的 @importGoogleFonts 为 false 禁止使用 Google 的字体

3. 使用命令 gulp build 编译一下 Semantic UI

4. 复制生成的 dist 目录中的文件到项目里即可