朵朵的技术博客

SSE服务器推送：实时网络传输协议详解与实战

Mon, 03 Nov 2025 00:00:00 GMT

本文基于作者实际开发经验，已在项目中使用 SSE 实现实时数据推送，涵盖客户端监听与服务端事件流实现。

SSE（Server-Sent Events）是基于HTTP的一个轻量级单向传输协议，允许服务器主动向客户端推送实时数据，场景主要有：新闻推送、消息通知、股票行情、实时日志等。

核心特性如下：

单向通信
基于HTTP
长连接（替代轮询）
自动重连

1.客户端基本使用方法#

这里简单画了个流程图表示生命周期：

先是连接成功触发open事件；
然后接收message消息是要配置监听的，建议用addEventListener，因为如果使用onMessage无法接收指定消息类型；
网络中断，服务器出错都会触发error事件；
关闭连接的close方法，通常离开页面就要关闭

SSE生命周期

1
//url为后端sse服务器地址，根据地址创建连接
2
const eventSource = new EventSource(url);
3

4
// 建立连接触发open事件
5
eventSource.onopen = () => {
6
  console.log('✅ 触发open事件，SSE连接已建立');
7
};
8

9
// 方式1：使用onmessage属性
10
eventSource.onmessage = function (event) {
11
  var data = event.data;
12
  console.log('收到数据：', data);
13
};
14

15
// 方式2：使用addEventListener监听特定事件类型
16
eventSource.addEventListener('message', function (event) {
17
  var data = event.data;
18
  console.log('收到数据（监听方式）：', data);
19
}, false);
20

21
// 异常触发error事件
22
eventSource.onerror = (error) => {
23
  console.error('❌ 触发error事件，SSE连接错误:', error);
24
};
25

26
// 主动关闭SSE连接
27
eventSource.close();
28
console.log('SSE连接已手动关闭');

展开收起

2.服务器端使用方法#

先要了解服务端的实现规范，主要从三个方面入手：HTTP头信息要求、数据传输格式、核心字段。

2.1 HTTP头信息要求#

1
Content-Type: text/event-stream  // 必须，指定为事件流类型
2
Cache-Control: no-cache          // 必须，禁止缓存，确保数据实时性
3
Connection: keep-alive           // 必须，保持长连接

2.2 数据传输格式#

每行格式为字段: 值\n（字段名后必须跟冒号和空格，结尾用换行符\n）
多条消息之间用\n\n（两个换行符）分隔。
此外，以:开头的行是注释（服务器可定期发送注释保持连接）。

换行符必须是\n（Unix格式），\r\n可能导致客户端解析错误。

2.3 核心字段说明#

data字段：消息内容
event字段：指定事件类型
id字段：消息标识，发给谁
retry字段：重连间隔

3.服务端实现#

SSE在SpringBoot项目中，spring-boot-starter-web提供了SSE核心类SseEmitter。

3.1 简单实现#

下面是一个简单的实现方式，创建一个接口供前端访客建立SSE长连接，然后提供了广播接口和模拟进度通知接口。

1
import org.springframework.http.MediaType;
2
import org.springframework.web.bind.annotation.GetMapping;
3
import org.springframework.web.bind.annotation.RequestParam;
4
import org.springframework.web.bind.annotation.RestController;
5
import org.springframework.web.servlet.mvc.method.annotation.SseEmitter;
6
import java.io.IOException;
7
import java.util.concurrent.CopyOnWriteArrayList;
8
import java.util.concurrent.ExecutorService;
9
import java.util.concurrent.Executors;
10

11
@RestController
12
public class SseController {
13

14
    private final CopyOnWriteArrayList<SseEmitter> emitters = new CopyOnWriteArrayList<>();
15
    private final ExecutorService executor = Executors.newCachedThreadPool();
16

17
    @GetMapping(value = "/sse/subscribe", produces = MediaType.TEXT_EVENT_STREAM_VALUE)
18
    public SseEmitter subscribe() {
19
        SseEmitter emitter = new SseEmitter(Long.MAX_VALUE);
20
        emitters.add(emitter);
21

22
        emitter.onCompletion(() -> emitters.remove(emitter));
23
        emitter.onTimeout(() -> emitters.remove(emitter));
24
        emitter.onError((e) -> emitters.remove(emitter));
25

26
        try {
27
            emitter.send(SseEmitter.event()
28
                    .name("CONNECTED")
29
                    .data("You are successfully connected to SSE server!")
30
                    .reconnectTime(5000));
31
        } catch (IOException e) {
32
            emitter.completeWithError(e);
33
        }
34

35
        return emitter;
36
    }
37

38
    @GetMapping("/sse/broadcast")
39
    public String broadcastMessage(@RequestParam String message) {
40
        executor.execute(() -> {
41
            for (SseEmitter emitter : emitters) {
42
                try {
43
                    emitter.send(SseEmitter.event()
44
                            .name("BROADCAST")
45
                            .data(message)
46
                            .id(String.valueOf(System.currentTimeMillis())));
47
                } catch (IOException e) {
48
                    emitters.remove(emitter);
49
                    emitter.completeWithError(e);
50
                }
51
            }
52
        });
53
        return "Broadcast message: " + message;
54
    }
55

56
    @GetMapping("/sse/start-task")
57
    public String startTask() {
58
        executor.execute(() -> {
59
            try {
60
                for (int i = 0; i <= 100; i += 10) {
61
                    Thread.sleep(1000);
62
                    for (SseEmitter emitter : emitters) {
63
                        try {
64
                            emitter.send(SseEmitter.event()
65
                                    .name("PROGRESS")
66
                                    .data(i + "% completed")
67
                                    .id("task-progress"));
68
                        } catch (IOException e) {
69
                            emitters.remove(emitter);
70
                        }
71
                    }
72
                    if (i == 100) {
73
                        for (SseEmitter emitter : emitters) {
74
                            try {
75
                                emitter.send(SseEmitter.event()
76
                                        .name("COMPLETE")
77
                                        .data("Task completed successfully!"));
78
                            } catch (IOException e) {
79
                                emitters.remove(emitter);
80
                            }
81
                        }
82
                    }
83
                }
84
            } catch (InterruptedException e) {
85
                Thread.currentThread().interrupt();
86
            }
87
        });
88
        return "Task started!";
89
    }
90
}

展开收起

3.2 推荐实现#

推荐设计MessageEventType、MessageEvent、SseEmitterManager三层架构：消息的事件类型枚举类、消息事件封装对象、SSE管理工具类。

限于篇幅，推荐实现的核心代码请参考原文中的 MessageEventType 枚举、MessageEvent 事件类和 SseEmitterManager 管理类。

4.客户端实现#

客户端使用React + antd-mobile实现消息列表，通过SSE接收实时消息推送，分为已读和未读消息。

hook.js 核心逻辑#

1
const createSSEConnection = (url, messageHandlers, setLoading) => {
2
    const eventSource = new EventSource(url);
3

4
    eventSource.onopen = () => {
5
        console.log('✅ SSE连接已建立');
6
        setLoading?.(false);
7
    };
8

9
    eventSource.onmessage = (event) => handleSSEMessage(event, messageHandlers);
10

11
    Object.keys(messageHandlers).forEach(eventType => {
12
        eventSource.addEventListener(eventType, (event) => {
13
            try {
14
                const data = JSON.parse(event.data);
15
                messageHandlers[eventType](data);
16
            } catch (error) {
17
                console.error(`解析${eventType}失败:`, error);
18
            }
19
        });
20
    });
21

22
    eventSource.onerror = (error) => {
23
        console.error('❌ SSE连接错误:', error);
24
        setLoading?.(false);
25
    };
26

27
    return eventSource;
28
};

展开收起

踩坑#

一定要注意后端发送的事件类型，和客户端监听的要保持一致，要不然客户端收不到消息。

事件类型对比1

事件类型对比2

宝塔面板部署项目踩坑记录：PHP/Java/Node.js

Fri, 15 Nov 2024 00:00:00 GMT

📝 本文基于作者实际部署经验，已在宝塔面板上成功部署多个 PHP 和 Java 项目，记录踩坑过程。

最近在熟悉宝塔的部署，主要是各类php项目，目前大家有这个需求，我逐个框架进行一下整合

1.pbootcms#

PbootCMS是一个永久开源、免费的PHP企业网站开发建设管理系统，我的理解就是公司官网。源码托管地址：https://github.com/pbootcmspro/PbootCMS。系统后台默认访问路径：http://域名/admin.php 账号：admin 密码：123456。然后要去免费获取永久授权码的网站：https://www.pbootcms.com/freesn/获取一个授权码，访问后台在【全局配置】【配置参数】最下面【系统授权码】填入就可以开始用了。

1.1部署流程#

相对比较简单，其实就是添加，然后设置伪静态，因为这个开源模版没有route所以需要配置下，一般也都有模版，没有的我也列出了。

宝塔面板添加PbootCMS站点配置

设置伪静态规则

1
location / {
2
   if (!-e $request_filename){
3
        rewrite ^/index.php(.*)$ /index.php?p=$1 last;
4
            rewrite ^(.*)$ /index.php?s=$1 last;
5
   }
6
}

疑难杂症#

a.宝塔通过域名访问docker项目#

通过docker安装完，然后怎么配置都不行，后面修改了代理地址，一般代理地址都写127.0.0.1或者localhost，后面直接写了官网的地址就行了，ai说是docker部署的时候用的0.0.0.0导致的。

Kindle传书完全指南：Calibre管理任意格式电子书

Thu, 10 Oct 2024 00:00:00 GMT

📝 本文基于作者实际使用经验，已成功使用 Calibre 管理 Kindle 电子书库，支持多种格式转换和推送。

最近买了个泡面盖简单介绍下传书心得，kindle退出后，我感觉最简单的还是通过电脑的calibre进行整理然后传书。

Kindle泡面盖的日常使用场景

1.epub、mobi、azw3格式#

下载个calibre，这个软件主要做书库整理，使用上比较简单。只要你下载的书本格式和排版比较好，比如epub、mobi、azw3那直接照着下面操作就好。

zlibrary下载书籍，然后拖进去
下载douban插件，在首选项里导入zip，下载地址
右键书本，编辑元数据，填写书名和作者，然后点击下载元数据
数据线接入kindle，右键发送书籍到设备

Calibre书库管理界面截图

Calibre编辑元数据并下载豆瓣图书信息

通过USB数据线将书籍发送到Kindle设备

2.txt#

这个需求主要就是看小说使用的，会涉及到txt的格式转换，目前摸索出来比较好的一套模式如下：

VBook先转换一次
再导入calibre
同样的编辑源数据完善书籍信息
然后右键转换书籍（这一步要注意只要换字体就好，推荐霞鹜文楷。文本、布局、样式里一律不用勾选）
转换完就直接上传就好，样式非常漂亮

使用VBook将书籍转换为txt格式

Calibre转换书籍时设置字体参数

KODI打造家庭网络电视库：m3u直播源配置

Thu, 05 Sep 2024 00:00:00 GMT

📝 本文基于作者实际使用经验，已在 Windows 上成功配置 KODI 观看 m3u 电视直播源。

这个主要就是介绍下kodi的其中一个玩法，看m3u电视直播源。

1.安装软件和插件#

https://kodi.tv/download/windows/直接去官网下载对应的版本然后安装。接着就是跟着步骤做

1.改中文#

注意先改字符（Arial based），再改语言，要不然可能会乱码，全是正方形。

KODI设置字符集为Arial based

KODI中文语言设置界面

KODI选择中文语言包

KODI中文语言设置完成

KODI切换为中文界面

2.安装直播源插件#

插件-从库安装-PVR客户端-IPTV Simple Client，安装下，这个通常要等得比较久。

KODI从插件库安装

KODI PVR客户端选项

找到IPTV Simple Client插件

安装IPTV Simple Client插件

IPTV插件安装进度

IPTV插件安装完成

3.设置源#

找到这个插件然后点击设置，接下来去github上找找电视源

进入IPTV插件设置配置电视源

Jenkins流水线发布实战：React+SpringBoot全栈部署

Tue, 20 Aug 2024 00:00:00 GMT

📝 本文基于作者实际部署经验，已在生产环境成功搭建 Jenkins 流水线，实现 React+SpringBoot 项目自动化发布。

这次搭建的项目比较常规，前端是react写的，后端是springboot，并且由于是全栈开发，所以是在同一个项目中。接下来我演示下怎么用jenkins进行自动化发布。

1.jenkins必装插件#

这里用到的是jenkinsFile主要是基于Groovy这个沙盒，有些前置插件。这里使用maven进行打包，所以需要Maven Integration plugin和Pipeline Maven Integration Plugin。Pip这个是由于后面的语法withMaven要用。 NodeJs打包前端要用到NodeJS Plugin和Pipeline: Nodes and Processes。 jenkins是部署在运维机，所以要对远端的服务器进行发布，要用到SSH Agent Plugin。

所以总共要用到这些插件：Maven Integration plugin、Pipeline Maven Integration Plugin、NodeJS Plugin、Pipeline: Nodes and Processes、SSH Agent Plugin。

2.配置工具#

这里有两种方式，一种是自动安装，一种就是用你本地的配置，其实两种都没差。用本地的话，就是多配置一下目录。这里要注意的是，如果你是docker部署的jenkins并且需要给jenkins做读写权限，要给目录授权下，代码如下：

Terminal window

1
#jenkins默认就是1000:1000
2
chown -R 1000:1000 /opt/apache-maven-3.6.3/

其他的就简单截图。

Jenkins配置Maven工具路径

Jenkins配置NodeJS工具路径

Jenkins全局工具配置界面

Jenkins配置Git工具

Jenkins配置JDK工具

3.配置令牌#

你拉代码会涉及到git的账号密码，你发送远端服务器会涉及到服务器的密钥，这边点进去根据自己需要配置就好。

Jenkins添加GitLab访问令牌凭证

Jenkins配置SSH密钥凭证

4.创建项目#

创建很简单，主要就是看你jenkinsFile怎么写，我这里会提供简单参考。这里有个踩坑，EOF换行之后前面一定不能有空格。

Jenkins项目配置Jenkinsfile流水线脚本

1
//git仓库配置
2
def coding = [:]
3
coding.GIT_REPO_URL="xxx"
4
coding.CREDENTIALS_ID="xxx"
5
coding.GIT_BUILD_REF="xxx"
6

7
//远端服务器配置
8
def serverConfig = [:]
9
serverConfig.credentialsId="xxx"
10
serverConfig.ip = "xx"
11
serverConfig.username = "root"
12
serverConfig.port = 22
13

14
//项目名称
15
ADMIN_PROJECT_NAME="xxx-admin-server-0.0.1-SNAPSHOT"
16
MOBILE_PROJECT_NAME="xxx-weixin-server-0.0.1-SNAPSHOT"
17

18
pipeline {
19
    agent any
20

21
    tools {
22
        nodejs "NodeJS-20.15.0"
23
        maven "maven-3.6.3"
24
    }
25

26
    stages {
27
        stage('测试打包工具') {
28
            steps {
29
                sh 'node -v'
30
                withMaven(maven: 'maven-3.6.3') {
31
                    sh 'mvn -v'
32
                }
33
            }
34
        }
35

36
        stage("检出") {
37
            steps {
38
                checkout([
39
                    $class: 'GitSCM',
40
                    branches: [[name: coding.GIT_BUILD_REF]],
41
                    userRemoteConfigs: [[url: coding.GIT_REPO_URL, credentialsId: coding.CREDENTIALS_ID]]
42
                ])
43
            }
44
        }
45

46

47
        stage('common打包') {
48
            steps {
49
                dir('xxx-common-module') {
50
                    withMaven(maven: 'maven-3.6.3') {
51
                        sh 'mvn clean install'
52
                    }
53
                    sh 'cp target/xxx-common-module-1.0.jar /opt/apache-maven-3.6.3/lib'
54
                }
55
            }
56
        }
57

58
        stage('管理端打包') {
59
            steps {
60
                //编译前端
61
                dir('xxx-admin-server/front') {
62
                    sh 'npm install'
63
                    sh 'npm run build'
64
                }
65
                //移动dist
66
                sh 'rm -rf xxx-admin-server/src/main/resources/static/assets'
67
                sh 'mv xxx-admin-server/front/dist/assets xxx-admin-server/src/main/resources/static/assets'
68
                sh 'rm xxx-admin-server/src/main/resources/static/index.html'
69
                sh 'mv xxx-admin-server/front/dist/index.html xxx-admin-server/src/main/resources/static/index.html'
70
                //打包管理端项目
71
                dir('xxx-admin-server') {
72
                    withMaven(maven: 'maven-3.6.3') {
73
                        sh 'mvn clean package'
74
                    }
75
                }
76
            }
77
        }
78

79
        stage('手机端打包') {
80
            steps {
81
                //编译前端
82
                dir('xxx-weixin-server/front') {
83
                    sh 'npm install'
84
                    sh 'npm run build'
85
                }
86
                //移动dist
87
                sh 'rm -rf xxx-weixin-server/src/main/resources/static/assets'
88
                sh 'mv xxx-weixin-server/front/dist/assets xxx-weixin-server/src/main/resources/static/assets'
89
                sh 'rm xxx-weixin-server/src/main/resources/static/index.html'
90
                sh 'mv xxx-weixin-server/front/dist/index.html xxx-weixin-server/src/main/resources/static/index.html'
91
                //打包手机端项目
92
                dir('xxx-weixin-server') {
93
                    withMaven(maven: 'maven-3.6.3') {
94
                        sh 'mvn clean package'
95
                    }
96
                }
97
            }
98
        }
99

100
         stage('部署') {
101
            steps {
102
                echo '发布中...'
103
                sshagent([serverConfig.credentialsId]){
104
                  // 先使用scp命令将文件复制到远程服务器
105
                    sh """
106
                    scp -o StrictHostKeyChecking=no -P ${serverConfig.port} xxx-admin-server/target/${ADMIN_PROJECT_NAME}.jar ${serverConfig.username}@${serverConfig.ip}:/www/admin/
107
                    echo "管理端发送成功"
108
                    """
109
          // 然后使用ssh命令在远程服务器上执行脚本
110
                    sh """
111
                    ssh -o StrictHostKeyChecking=no ${serverConfig.username}@${serverConfig.ip} -p ${serverConfig.port} << 'EOF'
112
                        echo "测试服务器连接成功"
113
                        /www/restartAdminProject.sh
114
                        echo "管理端移动完成"
115
EOF
116
                    """
117
                }
118
                echo '发布完成.'
119
            }
120
        }
121
    }
122
}

展开收起

1
#!/bin/bash
2

3
# Admin 项目名称和路径
4
ADMIN_PROJECT_NAME="xxx-admin-server-0.0.1-SNAPSHOT"
5
ADMIN_PROJECT_PATH="/www/admin"
6

7
# Java 环境路径和启动参数
8
JAVA_HOME="/www/server/java/jdk1.8.0_371/bin/java"
9
JAVA_OPTIONS="-Xmx1024M -Xms256M"
10
JAVA_APP_OPTIONS="--server.port=9099 --spring.config.location=/www/admin/application-test.yml"
11

12
# 停止旧版本服务
13
pkill -f ${ADMIN_PROJECT_NAME}.jar || true
14

15
#备份旧版本
16
cp /www/admin/${ADMIN_PROJECT_NAME}.jar /www/admin/old-${ADMIN_PROJECT_NAME}.jar
17

18
# 移动 JAR 文件到 /www/SmartCommunity/admin，并替换旧版本
19
mv /www/adminxxx/${ADMIN_PROJECT_NAME}.jar /www/admin/${ADMIN_PROJECT_NAME}.jar
20

21
# 启动新版本服务
22
$JAVA_HOME $JAVA_OPTIONS -jar $ADMIN_PROJECT_PATH/${ADMIN_PROJECT_NAME}.jar $JAVA_APP_OPTIONS &

展开收起

群晖NAS入门教程：从零开始搭建家庭云盘和影视库

Thu, 15 Aug 2024 00:00:00 GMT

📝 本文基于作者实际部署经验，已在 ESXi 环境下成功部署群晖 DSM 7.0.1，并配置了 Jellyfin 影视库、NextCloud 云盘、DDNS 公网访问等功能。

很多人拿群晖做数据中心，我这里也安装记录下。我目前接触过的群晖安装是在ESXi的上进行安装，算是all in one的一种。主要步骤如下：

先到arpl，或者rr哪里下载img镜像然后通过StarWind进行打包拿到2个vmdk，推荐使用rr都直接装好了还有中文，如果是arpl就得自己折腾下
新建一个虚拟机，然后把2个vmdk上传
创建现有硬盘，然后启动系统
根据ip去访问或者用群晖的工具
正式安装群晖系统，直接用官网的pat或者本地上传

1.安装#

1.1 群晖DSM 7.0.1#

1.1.1 创建虚拟机#

自定义设置那边不存在的都删掉了：

创建一个新的虚拟机，Linux，其他4.X或更高…
移除无用自定义设置，硬盘、SCSI、usb、CD\DVD，记得依次向下

创建虚拟机1

创建虚拟机2

创建虚拟机3

1.1.2 修改虚拟交换机设置#

默认的安全系数较高，全部改成接受

虚拟交换机1

虚拟交换机2

1.1.3 上传群辉文件#

将用img转换的两个文件上传到刚刚创建的虚拟机目录，有一个会不显示属于正常现象。

上传文件

1.1.4 设置启动选项#

编辑刚刚的虚拟机添加现有硬盘，刚刚上传的文件目录选中后缀是.vmdk的，然后再添加新标准盘。

添加硬盘1

添加硬盘2

虚拟机选项改成bios引导，然后启动。

bios引导

启动后会给你个IP地址，访问之后照着步骤往下做。

启动IP

1.1.5 开始安装#

改语言
选版本（3622xs+）
选型号（7.2.2）
编译引导

这里踩了一个坑，用923+直接不识别硬盘。

网络卡顿加速办法：

Terminal window

1
sed -i 's/global.download.synology.com/cndl.synology.cn/g' /opt/rr/menu.sh
2
sed -i 's/global.download.synology.com/cndl.synology.cn/g' `find /opt/rr/model-configs/ -type f -name '*.yml'`
3
./menu.sh

不下载软件直接使用网页版查找：finds.synology.com

网页查找

1.2 群晖DSM 6.2.1#

准备必备文件后，在ESXi中创建虚拟机，增加两块新硬盘（后续做raid0），然后启动软件搜索，双击一直下一步安装即可。

1.3 物理机安装#

记录一次物理机安装，最简单的还是u盘引导，如果想把系统做在硬盘里就是用克隆分区，但是要记住克隆的选择按文件系统结构原样复制。

2.必备基础配置#

2.1 存储空间配置#

2.1.1 磁盘阵列#

这里直接做最快速的raid0，一般建议做raid5，我这里就是为了娱乐，不考虑数据安全。

磁盘阵列1

磁盘阵列2

2.1.2 建立存储空间#

依旧是根据提示下一步即可，描述建议使用raid级别加文件系统的方式。

存储空间1

存储空间2

2.2 修改IP#

默认动态获取，强烈建议改成静态ip，要不然网络环境出现问题，ip变了再去找很麻烦。

修改IP1

修改IP2

3.增加矿神组件#

这一步是为了让你可以下载更多群辉商店以外的大神的软件，免去你玩转docker的困惑。

矿神组件1

矿神组件2

矿神组件3

矿神组件4

4.局域网共享文件夹#

建议设置个配额，要不然内存爆了。给个用户可读写权限就好，然后在信息中心找到名字，比如admin，在windows电脑直接打开一个文件夹输入\\admin，输入账号密码即可登陆。

共享文件夹1

共享文件夹2

5.共享云盘NextCloud打造#

nextcloud是开源推荐最多的云盘，推荐是使用mysql进行部署。

Terminal window展开收起

1
#mysql命令
2
docker run -d \
3
--name=nextcloud_db \
4
-v /volume1/docker/mysql/nextcloud:/var/lib/mysql \
5
-e MYSQL_ROOT_PASSWORD=dkstFeb.1st \
6
--restart always \
7
mysql:latest
8

9
#进入容器
10
docker exec -it nextcloud_db mysql -u root -p
11

12
#创建新用户并授权
13
CREATE USER 'king' IDENTIFIED BY 'king.1st';
14
GRANT ALL ON *.* TO 'king'@'%';
15
flush privileges;
16
exit;
17

18
#创建数据库
19
docker exec -it nextcloud_db mysql -u king -p
20
CREATE DATABASE nextcloud;
21
exit;
22

23
#nextcloud命令
24
docker run -d \
25
-v /volume1/docker/nextcloud/config:/var/www/html/config \
26
-v /volume1/docker/nextcloud/data:/var/www/html/data \
27
-v /volume1/files:/files \
28
--restart always \
29
--link nextcloud_db:db \
30
-p 9000:80 \
31
--name nextcloud \
32
nextcloud

展开收起

6.私人影院打造#

6.1 视频文件夹授权#

先创建一个video文件夹，并且给所有人权限。

6.2 Jellyfin媒体服务器#

这是一个免费播放软件相当于迅雷影音，但是注意它本身并没有影视资源。

默认端口是8096，其他步骤比较简单，注意添加媒体库的时候要选中自己创建的视频文件夹。

6.2.1 配置刮削（修改hosts）#

直接用自带的刮削，因为找不到地址所以需要我们手动帮忙找，然后加进hosts里。

Terminal window

1
#切换管理员
2
sudo -i
3

4
#打开hosts
5
vim /etc/host
6

7
#添加ip地址
8
#jellyfin 刮削
9
52.84.18.58 api.themoviedb.org
10
52.84.18.75 api.themoviedb.org
11
52.84.18.78 api.themoviedb.org

6.2.2 配置刮削（豆瓣）#

主要是为了让你的视频有封面标题等，用的是豆瓣插件。

Terminal window

1
#豆瓣工具地址
2
https://raw.githubusercontent.com/Libitum/jellyfin-plugin-douban/master/manifest.json

媒体库设置上配置豆瓣工具，找到之前创建的电影媒体库设置【电影元数据下载器】和【Movie 图片获取程序】。

6.3 qBittorrent下载器#

这是一个下载工具相当于迅雷，默认账号：admin，密码：adminadmin。一般出问题的就是文件夹的目录，记得每一级文件夹都要给qb用户权限。

6.4 NASTool资源归集整理工具#

配置TMDB、下载器和播放器后，即可实现资源的自动搜索、下载和整理。

7.免费映射公网#

7.1 DDNS-GO（推荐）#

前置条件：你家的路由得支持ipv6。移动宽带光猫改桥接，路由器拨号上网开启ipv6一般就可以了。

矿神直接下载套件
域名服务商那里解析ipv4和ipv6记录（一个A和一个AAAA）
域名服务商生成密钥
配置ddns-go，保存
然后就可以正常访问了，想把其他映射出去就搞反向代理

7.2 cpolar#

cpolar群晖套件安装然后使用，下载地址

8.SynologyDrive同步家庭和公司电脑文件#

比较无脑就是安装下套件，然后电脑下载个客户端就好了。下载地址

9.群晖消息通过企业微信机器人通知#

企业微信的创建是不需要有公司的，自己创建一个就好，然后拉个自己小号，再创建一个群聊，点击设置可以直接添加一个企业微信机器人，然后复制他的webhook地址。

创建自定义webhook
输入webhook的地址
修改http方法为post，http主体为下面的代码

1
{
2
 "msgtype": "text",
3
 "text": {
4
   "content": "@@TEXT@@"
5
  }
6
}

NAS搭建家庭影视库：Jellyfin+Docker从零开始

Sun, 07 Jul 2024 00:00:00 GMT

家庭影视库

📝 本文基于作者实际部署经验，已在群晖 NAS 上成功部署 Transmission、Jellyfin、NASTool 等工具，实现自动下载、刮削、播放全流程。

在家准备搭建个影视库，之前都是七拼八凑，这次完整的做个教程。全部采用docker的方式部署，由于国内镜像源被封了，推荐使用轩辕镜像

我这里选用的工具如下，括号内的是平替：

下载工具——Transmission （qbittorrent）
视频播放器——emby （jellyfin）
媒体工具——nastool （moviepliot）
资源搜索工具——jacktt

我用的是黑群晖（新手建议先看玩转群晖——入门看这一篇足够了了解基础操作），共享目录主要就是video，用来存储影视资源。里面会进行电影和电视的分类，然后link文件夹是用来存储整理过后的媒体数据，和外层的目录一致即可。（ps：link文件夹主要是因为pt站，要进行保种不能变名称，所以整理后通过硬链接的方式放到link下，不影响原本的下载文件）

1
video文件夹的层级
2

3
video:.
4
├─movie #电影下载目录
5
├─tv    #电视剧下载目录
6
└─link
7
   ├─movie #电影资源访问目录
8
   └─tv    #电视剧资源访问目录

为了比较好的权限控制，我们先创建两个群组，一个是downloads，另一个是mediaSharers。然后再创建downloader和mediaShare用户，在两个群组下。他们的权限都是对video进行增加和删除。

1.下载器#

第一步是先下载资源，这里介绍两种下载器的docker安装。直接用downloader用户进行安装，接下来你要存放种子的文件夹都给他读写权限，包括docker底下安装软件的文件夹也给他读写权限。

1.1 Transmission#

这里我采用docker-compose安装，介绍下安装文件

1
version: "3.3"
2
services:
3
  transmission:
4
    image: docker.1panel.live/linuxserver/transmission #镜像版本
5
    container_name: transmission #容器名称
6
    environment:
7
      - PUID=1000 #downloader的用户id（ssh下使用命令'id downloader获取'）
8
      - PGID=1000 #downloader的群组id
9
      - TZ=Asia/Shanghai #时区
10
      - USER=admin #账号
11
      - PASS=****** #密码（请自行修改）
12
    volumes:
13
      - /docker/transmission/config:/config #配置文件夹
14
      - /video:/video #下载文件夹，建议统一使用video，避免后续媒体服务器访问异常
15
    ports:
16
      - 9091:9091
17
      - 51413:51413
18
      - 51413:51413/udp
19
    restart: unless-stopped

展开收起

启动完就安装完了，但是界面太丑了根本没法用，去github上下个皮肤，然后放到对应的目录即可。下载传送门

Transmission皮肤效果

我这里介绍命令行操作，先连接终端，然后输入下列命令。

Terminal window

1
#进入目录
2
cd /html
3

4
#下载皮肤文件
5
wget https://github.com/ronggang/transmission-web-control/archive/refs/tags/v1.6.1-update1.tar.gz
6

7
#解压
8
tar -zxvf v1.6.1-update1.tar.gz
9

10
#进入皮肤文件夹，复制src下的所有文件放到html下面
11
cd transmission-web-control-1.6.1-update1/src/
12
cp -rd * /html

安装完成，打开上方的设置齿轮图标，选中Base栏，下方的Language改成中文，然后save保存即可。

1.2 qBittorrent#

qb安装要注意以下几点：

WEBUI_PORT要和你映射的端口改成一致，要不然会访问出现“Unauthorized”。然后新版本容器改成了随机密码，账户是admin，密码要去看下日志。
TORRENTING_PORT端口不要用6881这类低端口，很多被封掉了。设置52000没有问题。记得要添加下tracker，网址：https://trackerslist.com/#/zh

1
---
2
services:
3
  qbittorrent:
4
    image: linuxserver/qbittorrent:latest
5
    container_name: qbittorrent
6
    environment:
7
      - PUID=1028
8
      - PGID=65536
9
      - TZ=Asi/Shanghai
10
      - WEBUI_PORT=8086
11
      - TORRENTING_PORT=52000
12
    volumes:
13
      - /volume1/docker/qbittorrent/config:/config
14
      - /volume1/video:/video
15
    ports:
16
      - 8086:8086
17
      - 52000:52000
18
      - 52000:52000/udp
19
    restart: unless-stopped

展开收起

2.iyuu#

实现qb下载，tr保种，然后绑定合作站点，后面moviesite就可以直接登录iyuu。

iyuu一定要注意把qb的种子下载路径映射进去，转种需要他。然后只要是你需要的下载路径也要一并映射进去，并且保持qb、tr、iyuu在容器内的路径名称一致，这样才不会出现找不到文件的情况。

转种：在计划任务里面，自己多设置几次测试下能不能成功，成功后再删除原来的种子。

1
---
2
services:
3
  iyuu:
4
    image: iyuucn/iyuuplus:latest #镜像版本
5
    container_name: iyuu #容器名称
6
    volumes:
7
      - /volume1/docker/iyuu/config:/config #配置文件夹
8
      - /volume1/docker/iyuu/data:/data
9
      - /volume1/Download:/Download
10
      - /volume1/video:/video
11
      - /volume1/docker/iyuu/logs:/var/log/nginx
12
      - /volume1/docker/qbittorrent/config/qBittorrent/BT_backup:/qb/BT_backup
13
    ports:
14
      - 8787:8787
15
      - 3131:3131
16
    restart: always

展开收起

3.媒体播放方案#

下载器安装好了，现在我们安装个播放器。emby个人感觉更好用，就是ios端收费，并且官方版硬解也是付费解锁。jellyfin是基于emby某个版本后的开源软件，所有都是免费，使用人群也比较多。接下来我会介绍两种安装方法。

3.1 Emby#

这里用docker-compose安装emby开心版，如果不采用这种安装方式就得用命令行先进行容器创建，因为要透传核显，界面化安装暂时不知道怎么设置，下面的jellyfin同理。

1
version: '3'
2
services:
3
  emby:
4
    image: docker.1panel.live/zishuo/embyserver:latest
5
    container_name: happy-emby
6
    environment: #这里就是id xxx之后照着写
7
      UID: 1035
8
      GID: 100
9
      GIDLIST: 100,65537
10
    volumes:
11
      - /volume1/docker/happy-emby/config:/config
12
      - /volume1/docker/happy-emby/mnt/share1:/mnt/share1
13
      - /volume1/docker/happy-emby/mnt/share2:/mnt/share2
14
      - /volume1/vide:/video #影视资源
15
    devices:
16
      - /dev/dri:/dev/dri #核显透传，为了硬解
17
    ports:
18
      - "8098:8096"
19
    restart: unless-stopped

展开收起

映射完直接访问端口地址，进行配置就好，切换成中文一步一步往下就行

3.2 Jellyfin#

docker下建议用nyanmisaka/jellyfin，免去使用官方版很多插件不足的情况，当然喜欢纯净版那就用官方的，安装没什么区别。

有个注意事项，如果你cpu比较旧，在镜像img那里换成latest-legacy的版本：即image: nyanmisaka/jellyfin

1
version: '3'
2
services:
3
  jellyfin:
4
    image: docker.1panel.live/nyanmisaka/jellyfin:latest-legacy
5
    container_name: jellyfin
6
    user: "1032:65537" #用户权限，前面是用户id，后面是组id
7
    volumes:
8
      - /volume1/docker/jellyfin/config:/config
9
      - /volume1/docker/jellyfin/cache:/cache
10
      - /volume1/video:/media #视频目录
11
    devices:
12
      - /dev/dri:/dev/dri #核显透传
13
    ports:
14
      - "8097:8096"
15
    restart: unless-stopped

展开收起

然后下一步直接运行，等待一下，然后访问即可，不行就多刷新两下，启动需要时间。然后正常按照提示进行设置，注意下媒体库路径选择link里面的即可。

设置硬件解码：播放-硬件加速-选VAAP（intel用这个，兼容性比较强，具体根据你cpu型号决定）后面保持默认即可，控制权限的话就是新建用户，给他不同的媒体库就好。

4.媒体工具 —— NASTool#

下载器、播放器都有了，最后介绍媒体管理工具Nastool。建议下载2.9.1的未阉割版。有几个坑：

官方的最新版本进去如果你没有pt站的用户，就用不了完整的功能。
官方的2.9.1下载部署完会自动升级，不提供别的内置索引器，对于想使用jackett，使用pt站搜资源就没法实现。

所以我这里最后选择下载了其他大神的2.9.1存档版本，19970688/nastools-bt。

1
version: '3.7'
2
services:
3
  nas-tools:
4
    container_name: nas-tools
5
    image: 19970688/nastools-bt:latest
6
    ports:
7
      - "3001:3000"
8
    volumes:
9
      - /volume1/docker/nastools/config:/config
10
      - /volume1/video:/video #视频资源目录
11
    environment:
12
      - PUID=1032
13
      - PGID=65537
14
      - UMASK=000
15
      - NASTOOL_AUTO_UPDATE=false #关闭自动更新
16
    restart: unless-stopped

展开收起

访问端口，默认账号密码：admin/password 接下来要开始配置NASTool，步骤比较多。

在基础设置里面，修改密码
增加TMDB密钥网址在这里，直接去注册个。themoviedb(https://www.themoviedb.org/login)在右上角我的-账户设置-API-请求API密钥。这里选择developer开发者申请，全部填满唯一要注意的就是简介里面加上一句话：

Terminal window

1
Application summary please elaborate on how you plan to use our API

BT保种,基础设置-默认文件转移方式-改成硬链接，实现BT保种
设置媒体库，都设置link文件夹底下的目录。
新增目录同步，跟上述的类似，就是把真实目录的资源改名后同步到目的目录，依次设置电影和电视剧。根目录用video/movie，目的目录video/link/movie
配置下载器，点击下载器输入网址，输入账号密码，测试成功后点击完成。
配置媒体服务器，先进入emby/jellyfin控制台，找到API密钥后添加一个，然后回到nastool进行设置。
配置消息通知，试了企业微信这种，门槛有点高得有固定的公网ip。我这里只是用云服务的公网进行测试，介绍下流程：
1. 先去企业微信注册一个账号，传送门
2. 通过企业微信创建一个应用
3. frp把你局域网里的nastool穿透出去
4. 在nastool里面创建一个应用
5. 企业微信进行回调配置
6. 企业微信开放白名单
7. nastool测试连接

企业微信端：我的企业，拉到最下面拿到企业id；
企业微信端：点击应用管理，创建一个应用；
Nastool端：新增一个消息通知，主要取个名字，不知道的可以先不填保存；
企业微信端：编辑api配置，主要是url，用你frp穿透出来的公网地址加上/你的消息通知的名称；
Nastool端：开始填写参数；
企业微信端：配置完成点击微信插件，扫描关注，然后点击nastool的测试成功就可以看到消息了。

然后在聊天框，随便输入一个电影名字，他会返回带序号的搜索结果，你输入序号，就可以开始自动下载。

5.jackett#

玩种子站会用到，内置索引器往往资源不够，所以用jackett来实现索引。

1
version: '3.7'
2
services:
3
jackett:
4
    container_name: jackett
5
    image: linuxserver/jackett:latest
6
    environment:
7
      - PUID=1000
8
      - PGID=100
9
      - TZ=Asia/shanghai
10
      - AUTO_UPDATE=true
11
    ports:
12
      - "9117:9117"
13
    volumes:
14
      - /volumn/docker/jackett/config:/config
15
      - /volumn/docker/jackett/downloads:/downloads
16
    restart: unless-stopped

展开收起

然后就是启动访问端口就好，然后都是中文界面自行操作。

6.metatube#

主要是用来给jellyfin刮削小姐姐

1
services:
2

3
  metatube:
4

5
    image: docker.unsee.tech/metatube/metatube-server:latest
6

7
    container_name: metatube
8

9
    volumes:
10

11
      - /volume1/metatube/data:/var/www/html/data
12

13
    ports:
14

15
      - 8089:80
16
    restart: unless-stopped

展开收起

ESXi虚拟化软路由：OpenWrt和爱快安装配置全攻略

Tue, 25 Jun 2024 00:00:00 GMT

本文基于作者实际部署经验，已在 ESXi 环境下成功部署 OpenWrt 和爱快双路由系统，涵盖镜像转换、网卡直通、旁路由配置等完整流程。

最近折腾下路由主要就是实现局域网内的上网。如果你是用群晖虚拟机部署OpenWRT，可以参考群辉虚拟机安装OpenWRT作旁路由。下面介绍ESXi环境下的OpenWrt和爱快。

OpenWrt#

1.StarWind V2V Converter下载#

先去下载个StarWind V2V Converter，这是官网地址。

双击之后无脑下一步即可。

2.OpenWrt镜像#

直接去官网下载，我这里的话是走了个野路子，有人有编译好的，我把连接也放在这里集成版。

3.镜像格式转换#

基本照着我的图片下一步就好，细心点

格式转换1

格式转换2

格式转换3

格式转换4

格式转换5

格式转换6

格式转换7

格式转换8

4.设置ESXi#

第四步操作为非必要操作，仅影响流量上限，一般家用场景不会跑满，所以可以不操作。这步没操作的情况下，5.3就不需要配置pci。这里注意如果你做了网卡直通并配置了pci估计得在实体机插个网线，要不然就访问不了openwrt管理端了，后面设置ip会无效。

4.1 添加虚拟交换机#

先查看网络-物理网卡有几张，就添加几个虚拟交换机。

虚拟交换机1

虚拟交换机2

虚拟交换机3

0默认就是esxi用的就把安全改成全部接受，别去改别的，要不然登陆不了后台。

安全设置1

安全设置2

4.2 添加端口组#

点进去可以看到，默认只有名为VM Network和Management Network两个端口，这两个端口都绑定了虚拟交换机vSwitch0。我们需要为剩下的虚拟交换机分别创建各自的端口。

就改标注的两个，其他别去动。

端口组1

端口组2

4.3 网卡直通#

网卡直通一般是指在虚拟平台下，把某个网卡独立出来指定某一个宿主机系统使用。

通过筛选器选择支持直通，然后找到Gigabit Ethernet字样的都是网卡（注意第一张别去直通），直接左上角切换直通即可，ESXi7.0及以上版本就不用重启了。

网卡直通

这里踩了一个坑，检查下高级设置里的ACScheck，如果是false所以改成true，每次设置完过一会又还原了。

ACScheck

5.创建OpenWrt虚拟机#

自定义设置里分4步走：

5.1 删除硬盘、CD/DVD两项#

删除硬盘

5.2 内存配置#

内存配置：2G，勾选【预留所有客户机内存（全部锁定）】

内存配置

5.3 添加PCI设备#

网口配置：【添加其他设备】-【PCI设备】，把刚刚直通的设备添加即可

添加PCI

5.4 硬盘配置#

硬盘配置：【添加硬盘】-【现有硬盘】，这个简单创建个目录，把刚刚那两个vmdk丢上去，这里注意上传了两个文件只会显示其中一个不用在意，选中它就好。

硬盘配置1

硬盘配置2

5.5 完成创建#

完成创建

6.启动并修改IP#

这个启动需要点时间，等他启动完配置下ip，毕竟每个人的网段不同。配置完成后直接reboot重启，至此就配置完成。直接访问即可，默认密码password

修改IP1

修改IP2

修改IP3

7.管理端配置#

7.1 配置LAN口#

网络 - 接口 - LAN - 修改，将网关、DNS服务器都指向主路由的地址

LAN口配置1

LAN口配置2

停用ipv6，最后点击右下角保存并应用

停用IPv6

7.2 检查网络#

检查网络

青龙面板使用教程：Docker部署定时任务全攻略

Mon, 10 Jun 2024 00:00:00 GMT

本文基于作者实际部署经验，已通过 Docker 成功部署青龙面板并配置定时任务，涵盖容器安装、面板设置及脚本管理。

玩nas除了看看电影，那肯定还得玩转docker，这期讲的就是青龙面板，一个跑脚本的神器。

GitHub地址：青龙面板

1.安装#

你安装完docker那就很简单了，不懂可以看看我这篇博客docker安装

镜像源一定要搞，要不然可能拉的是旧版本的青龙

Terminal window展开收起

1
#docker镜像加速
2
vim /etc/docker/daemon.json
3

4
#添加的源地址
5
{
6
    "registry-mirrors" : [
7
    "https://registry.docker-cn.com",
8
    "https://docker.mirrors.ustc.edu.cn",
9
    "http://hub-mirror.c163.com",
10
    "https://cr.console.aliyun.com/"
11
  ]
12
}
13
#添加后记得加载和重启下
14
systemctl daemon-reload
15
systemctl restart docker

展开收起

Terminal window

1
#先拉取镜像
2
docker pull whyour/qinglong:latest
3

4
#安装青龙镜像(我这里映射了宿主机所以要创建mnt底下的docker文件夹)
5
docker run -dit \
6
  -v /mnt/docker/ql/config:/ql/config \
7
  -v /mnt/docker/ql/log:/ql/log \
8
  -v /mnt/docker/ql/db:/ql/db \
9
  -p 5700:5700 \
10
  --name qinglong \
11
  --hostname qinglong \
12
  whyour/qinglong:latest

青龙面板安装1

青龙面板安装2

访客下宿主机的5700端口，就可以进去了，中文的界面无脑下一步跳过即可。不行，就把防火墙关了。

2.安装常用依赖#

这个依赖我感觉就是跑这些脚本会用到的，分为node.js，python3，linux。记得把自动拆分勾选上

Node.js

1
crypto-js
2
prettytable
3
dotenv
4
jsdom
5
date-fns
6
tough-cookie
7
tslib
8
ws@7.4.3
9
ts-md5
10
jsdom -g
11
jieba
12
fs
13
form-data
14
json5
15
global-agent
16
png-js
17
@types/node
18
require
19
typescript
20
js-base64
21
axios
22
moment

展开收起

python3

1
requests
2
canvas
3
ping3
4
jieba
5
PyExecJS
6
aiohttp

linux

Terminal window

1
bizCode
2
bizMsg
3
lxm

依赖安装1

依赖安装2

3.添加库#

我之前用的是这个集合库，后来找到一个订阅的网址也还不错最新青龙面板京东脚本库（持续更新中）

1
【faker】集合库
2
ql repo https://ghproxy.com/https://github.com/shufflewzc/faker2.git "jd_|jx_|getJDCookie" "activity|backUp" "^jd[^_]|USER|ZooFaker_Necklace"

添加库1

添加库2

4.配置环境变量#

这里我就测试了下jd的，所以名称是这个，值的话要去抓包，其实就是电脑登陆JD网址，用手机号登陆。右键检查，然后点网络里面会有pt_pin和pt_key。

配置环境变量

Terminal window

1
#这是值的格式，如果添加多个账号，加分号就好了。
2
pt_key=****;pt_pin=***;

环境变量配置1

环境变量配置2

群晖虚拟机安装OpenWRT作旁路由：完整教程+避坑指南

Mon, 20 May 2024 00:00:00 GMT

📝 本文基于作者实际部署经验，已在群晖虚拟机中成功部署 OpenWRT 旁路由，实现 AdGuard 去广告和网络加速功能。

最近在整活旁路由，基本就是要实现adguard和出国留学。openwrt这个的安装比较简单，就是先去找个镜像，然后导入即可。

我这里最后是去github上找了个大佬每天编译的地址链接。

OpenWRT版本

1.下载解压得到img#

下载完之后解压会得到一个img文件

下载解压

2.导入群辉安装#

下载映像（这类都是编译好的，后续只要导入）
上传映像到群辉
通过磁盘映像创建虚拟机
连接虚拟机修改ip地址重启
使用修改的ip进行访问，默认账号：root，默认密码：password

如果第一次玩先去套件中心安装下虚拟机。对群晖基础操作还不熟的话，可以先看玩转群晖——入门看这一篇足够了。

虚拟机套件

打开该软件，选择【映像】【磁盘映像】【新增】导入刚刚下载的镜像，稍等片刻，等到显示良好了再进行后面操作

导入映像1

导入映像2

开始导入映像完成虚拟机的创建

创建虚拟机1

创建虚拟机2

创建虚拟机3

创建虚拟机4

创建虚拟机5

创建虚拟机6

创建虚拟机7

创建虚拟机8

创建虚拟机9

3.连接OpenWRT操作#

连接openwrt虚拟机
修改ip地址
重启
网页访问openwrt

连接虚拟机

Terminal window

1
#修改网卡配置，直接复制吧
2
vi /etc/config/network

修改IP配置

进入配置文件后点击i，表示进入编辑模式。然后方向键移动到这里，把ip段改成你当前路由下的IP地址，家里一般是192.168.1.0网段的，这里是小米路由器所以是31网段。编写完成后，按esc，然后wq保存。

编辑IP

最后点击重启网络 /etc/init.d/network restart 或者 reboot 重启，等待重启完成，至此openwrt的安装完成了，接下来是一些配置。

重启网络

4.OpenWRT配置#

访问刚刚编写的ip地址，进入openwrt界面。

默认账号：root，默认密码：password

登录OpenWRT

点击网络，点击接口选择lan口，点击修改

LAN口配置1

然后把网关和dns改成你家里主路由的地址

LAN口配置2

最下面dhcp忽略掉，然后点击保存并应用

DHCP忽略

至此设置完成，有需要用到旁路由的只需要把终端设置静态ip，把dns和网关设置成你openwrt的地址。

HP Gen8 MicroServer服务器折腾记录：iLO设置与系统安装

Fri, 10 May 2024 00:00:00 GMT

📝 本文基于作者实际折腾经验，已在 HP Gen8 上成功搭建 NAS 和测试环境，实现 iLO 远程管理。

搭建一个测试服务器，这里是惠普的gen8，一些倒腾，以此文小记。

1.iLO设置#

iLO (Integrated Lights-Out) 是惠普公司开发的对服务器进行远程管理和维修的系统。简单来说就是网线插到iLO网口就可以远程操作，不用待在机房那么吵。

1.1禁用dhcp#

开机先按F8进入iLO设置界面，关闭dhcp，我们设置个固定ip进行操作（觉得麻烦这步可以不做）

iLO设置界面禁用DHCP选项

iLO网络设置界面

DHCP禁用后的确认界面

1.2配置iLO的ip#

iLO IP地址配置界面

iLO固定IP配置完成

1.3添加登陆用户#

添加iLO登录用户界面

用户创建成功确认

1.4远程访问#

https://ip直接登陆，然后输入上一步创建的账号密码

iLO远程登录页面

iLO远程访问登录后的管理界面

2.设置raid#

开机自检完按F10，然后按F5进入智能配置界面

按F10后按F5进入智能配置界面

2.1选择阵列卡#

选择阵列卡设备

2.2配置#

配置阵列设置

2.3创建阵列组#

创建阵列组

2.4选择硬盘开始创建#

选择硬盘开始创建阵列

2.5阵列配置#

因为我这里就一块所以只能做raid0，raid1是1:1备份，raid5是n-1块存储，一块是逻辑关系。

选择RAID级别配置

2.6阵列创建完成#

阵列创建完成确认

3.装系统#

3.1下载工具#

下载一个ilo管理工具

3.2连接ilo#

连接iLO管理工具

3.3加载镜像#

打开选中下载好的Esxi镜像

加载ESXi安装镜像

重启即可开始安装

重启服务器开始安装ESXi

3.4开始安装#

ESXi系统安装界面

后续就是一些基本设置，设置完成后直接就重启了

4.更新bios、ilo#

ilo升级就是靠访问ip地址，然后上传

上传iLO固件进行升级

版本下载地址

中文语言包安装 HP 360p Gen8 Chinese

HP 360p Gen8中文语言包文件

中文语言包安装过程

踩坑#

1.无法浏览器访问问题#

如果你的固件版本是1.05只能用老版本的ie访问

固件1.05版本只能用老版本IE访问

2.开启进入按F5进入阵列卡就重启#

F5进入Smart Storage后系统重启

F5进入HP Smart Storags使用界面化配置就一直重启，这里选择F8进入古早的阵列配置界面。

F8进入传统阵列配置界面

有旧的先Delete，然后再create

SoftEther使用教程：搭建私有VPN服务器完整指南

Wed, 10 Apr 2024 00:00:00 GMT

本文基于作者实际部署经验，已成功搭建 SoftEther VPN 服务器实现远程访问，涵盖 Linux 服务端安装、Windows 管理客户端配置及客户端连接。

SoftEther作为一款开源vpn软件，用起来还是不错的，我这里进行简单的分享。

官网地址

1.Linux服务端安装#

官网下载然后启动，配置调试是使用windows系统上的管理客户端来实现。

1.1 安装#

Terminal window展开收起

1
#前置必要组件
2
yum -y install wget gcc zlib-devel openssl-devel readline-devel ncurses-devel
3

4
#进入安装目录
5
cd /opt
6

7
#下载安装包
8
wget https://www.softether-download.com/files/softether/v4.42-9798-rtm-2023.06.30-tree/Linux/SoftEther_VPN_Server/64bit_-_Intel_x64_or_AMD64/softether-vpnserver-v4.42-9798-rtm-2023.06.30-linux-x64-64bit.tar.gz
9

10
#解压
11
tar -zxvf softether-vpnserver-v4.42-9798-rtm-2023.06.30-linux-x64-64bit.tar.gz
12

13
#编译二进制文件
14
cd vpnserver
15
make
16

17
#复制二进制文件到新目录
18
mkdir -p /usr/local/vpnserver
19
cd /opt/vpnserver
20
cp -p hamcore.se2 /usr/local/vpnserver/hamcore.se2
21
cp -p vpncmd /usr/local/vpnserver/vpncmd
22
cp -p vpnserver /usr/local/vpnserver/vpnserver
23

24
#运行和停止
25
/usr/local/vpnserver/vpnserver start
26
/usr/local/vpnserver/vpnserver stop
27

28
#使用systemd管理并开机启动
29
vim /etc/systemd/system/vpnserver.service

展开收起

新建vpnserver.service文件，粘贴下面的命令：

1
[Unit]
2
Description=SoftEther VPN Server
3
After=network.target
4

5
[Service]
6
Type=forking
7
ExecStart=/usr/local/vpnserver/vpnserver start
8
ExecStop=/usr/local/vpnserver/vpnserver stop
9
RestartSec=3
10

11
[Install]
12
WantedBy=multi-user.target

Terminal window

1
#开始运行
2
systemctl start vpnserver
3

4
#停止运行
5
systemctl stop vpnserver
6

7
#开机启动
8
systemctl enable vpnserver
9

10
#取消开机启动
11
systemctl disable vpnserver
12

13
#查看运行状态
14
systemctl status vpnserver

1.2 配置#

windows管理客户端下载地址，直接去官网自己选择也可以。

询问安装什么组件的时候，只需要选择【SoftEther VPN Server 管理工具（仅限管理工具）】即可，点击新设置。

设置名自定义，主机名填写云服务器ip地址，端口号（点击下拉框任意选择一个，要确保该端口没被占用，后续我们再进行端口修改，我这里用的是5555），选择服务端管理模式，默认没有密码，点击确定。然后双击连接。首次连接会让你设置新密码，然后会弹出【SoftEther VPN Server 简单安装】的窗口，关闭即可。接着会询问你是否需要设置 IPsec/L2TP，点击[否]。

基本配置：

【OpenVPN / MS-SSTP 设置】，取消选中[启用 OpenVPN 克隆 Server 功能]和[开启 MS-SSTP VPN 克隆 Server 功能]。
【加密与网络】，取消选中[使用并保持互联网的连接]。
【监听器列表】删除多余端口，只保留一个，如果想更改端口，先新建一个端口，然后使用新端口连接到服务器，再把旧端口删除。
【编辑设置】，点击[保存到文件]保存到本地，打开保存的文件。在前几行找到declare DDnsClient，然后把它下面的bool Disabled false改成bool Disabled true，再导入刚刚修改好的文件

创建虚拟局域网，删除默认的虚拟HUB，自己新建一个。创建好以后，点击[管理虚拟HUB]：

首先把DHCP服务器打开，点击[虚拟NAT和虚拟DHCP服务器] → [启用SecureNAT] → [SecureNAT配置] → 取消选中[使用虚拟NAT功能]。然后把[默认网关地址]和[DNS服务器地址]清空 → [确定]
最后一步，创建用户。点击[管理用户] → [新建] → 填写用户名和密码 → 完成创建

2.Linux客户端安装#

客户端先下载解压编译后运行，然后就是通过工具创建连接即可。

Terminal window展开收起

1
#下载
2
wget https://www.softether-download.com/files/softether/v4.42-9798-rtm-2023.06.30-tree/Linux/SoftEther_VPN_Client/64bit_-_Intel_x64_or_AMD64/softether-vpnclient-v4.42-9798-rtm-2023.06.30-linux-x64-64bit.tar.gz
3

4
#解压
5
tar zxvf softether-vpnclient-v4.42-9798-rtm-2023.06.30-linux-x64-64bit.tar.gz
6

7
#编译
8
cd vpnclient
9
make
10

11
#进入目录运行客户端
12
./vpnclient start
13

14
#配置(先把vpnclient目录下lang.config文件底部改成cn，中文模式)
15
./vpncmd

展开收起

输入完命令选择2

vpncmd

然后进行配置：

Terminal window

1
#创建连接
2
AccountCreate

这里要注意把主机名和端口号换成你自己的，连接用户就是你在服务端创建的，Hub名称可以随便写但是要记住，后面要用。

AccountCreate

Terminal window

1
#设置为tcp/ip直连方式
2
AccountProxyNone
3

4
#设置连接时的密码
5
AccountPasswordSet
6

7
#查看连接列表
8
AccountList
9

10
#连接
11
AccountConnect

然后就可以退出去获取局域网的地址了：

Terminal window

1
#获取地址
2
dhclient
3

4
#查看地址
5
ifconfig

获取IP1

获取IP2

获取IP3

3.其他#

重置管理员密码#

关闭server的softether服务（不关闭改完重启不会生效）
修改server安装目录下的vpn_server.config文件，找到里面的declare ServerConfiguration部分，里面有个byte HashedPassword xxxxxxx，将xxxxxxx改为+WzqGYrR3VYXrAhKPZLGEHcIwO8=（默认密码）
启动server的服务，用softether server管理工具再连接server的时候，就会让你设置新密码了

Frp内网穿透实战：从零开始搭建远程访问

Fri, 05 Apr 2024 00:00:00 GMT

📝 本文基于作者实际部署经验，已在云服务器和家庭网络间成功搭建 Frp 内网穿透，实现远程访问 NAS 和开发环境。

1.Frp安装服务端（买个云服务器装一下，或者有公网ip的）#

下载、上传、解压

Terminal window

1
 下载链接：https://github.com/fatedier/frp/releases/download/v0.41.0/frp_0.41.0_linux_amd64.tar.gz

文件介绍

Terminal window

1
## 文件涵义（C代表客户端，S代表服务端）
2
frpc      客户端
3
frpc_full.ini  客户端完整配置文件
4
frpc.ini    客户端简易配置文件
5
frps      服务端
6
frps_full.ini  服务端完整配置文件
7
frps.ini    服务端简易配置文件

配置服务端默认监听端口为7000，建议改成别的，这里我用7777。这里注意端口写哪个，相应的云服务器要开放端口。
frps.ini配置文件修改监听端口
dashboard_port相关的三个配置是仪表盘可装可不装
dashboard仪表盘相关配置

Terminal window展开收起

1
[common]
2
#frp服务器监听端口
3
bind_port = 7000
4

5
#开启token验证
6
authentication_method = token
7
token = xxxx
8

9
#frp的管理界面端口
10
dashboard_port = 7500
11
dashboard_user = xxxx
12
dashboard_pwd = xxxx
13

14
#通过http访问时使用该端口
15
vhost_http_port = 80
16
#通过https访问时使用该端口
17
vhost_https_port = 443
18
#公网域名
19
#subdomain_host = test.com

展开收起

这里我用的是腾讯云，如果是别的云服务器（阿里云）可能要填写来源：0.0.0.0/0

腾讯云安全组开放端口

安全组规则配置详情

启动服务（-c后面跟的是配置文件，意思就是以哪个配置文件启动服务）

Terminal window

1
#以简易配置启动服务
2
 ./frps -c ./frps.ini

启动frp服务端

frp服务端启动成功

2.Frp安装客户端（内网下的设备，这里用的是Centos7系统）#

操作和上述基本一致，只是修改的文件夹不一样

Terminal window

1
vim frpc.ini

Terminal window展开收起

1
[common]
2
server_addr = 114.132.199.13
3
server_port = 7000
4
token=yeapt
5

6

7
[http测试]
8
type = http
9
local_ip = 192.168.1.2
10
#内网服务端口，外网请求根据vhost_http_port配置为准
11
local_port = 80
12
#映射的公网ip的端口（记得云服务器要开放）
13
remote_port = 6006
14
#公网ip或域名
15
custom_domains=httpTest.test.com
16
#需要访问的前缀，如这里的httpTest,那么访问就是：httpTest.test.com:6006。这个要和服务端搞配对
17
#subdomain = httpTest
18

19
[https测试]
20
type = https
21
local_ip = 192.168.1.4
22
local_port = 8080
23
remote_port = 6006
24
custom_domains = httpsTest.test.com
25
# https追加内容
26
plugin = https2http
27
plugin_local_addr = 192.168.1.4:8080
28
plugin_crt_path = /opt/frp/lisence/httpsTest.test.com.pem
29
plugin_key_path = /opt/frp/lisence/httpsTest.test.com.key
30
plugin_host_header_rewrite = 192.168.1.4
31
plugin_header_X-From-Where = frp
32

33

34
[tcp测试--ssh就用这个]
35
type = tcp
36
local_ip = 192.168.1.3
37
#映射的frps端口
38
local_port = 8083
39
#本地端口
40
remote_port = 8083

展开收起

server_addr 就是服务端的公网ip，port就是端口。下面就代表每一台映射的内网电脑。

Terminal window

1
#以简易配置启动服务
2
 ./frpc -c ./frpc.ini

客户端frpc启动

大功告成#

启动完会发现，服务器弹日志了

服务器弹出连接日志表示穿透成功

后续#

1.设置服务端开机启动#

Terminal window

1
#编辑启动配置
2
vim /lib/systemd/system/frps.service

ExecStart代表你的frp路径，这个对其他照抄，然后保存

Terminal window

1
[Unit]
2
Description=Frps Service
3
After=network.target syslog.targer
4

5
[Service]
6
Type=simple
7
ExecStart=/opt/frp/frps -c /opt/frp/frps.ini
8

9
[Install]
10
WantedBy=multi-user.target

Terminal window

1
#启动服务
2
systemctl start frps
3

4
#设置自动启动（随系统）
5
systemctl enable frps

客户端的自启动同理，就是把frps都改成frpc

2.域名访问优化#

域名访问还要加上端口多少有点不爽，直接上个nginx，没安装可以来这里参考下：Nginx安装

Terminal window展开收起

1
server {
2
    listen 80;
3
    server_name aaa.test.com;  # 将泛解析的域名替换为你实际使用的域名
4

5
    location / {
6
        proxy_pass http://127.0.0.1:80;  # 这里需要绑定公网服务器的 frps 里面的 vhost_http_port
7
        proxy_set_header Host $host;
8
        proxy_set_header X-Real-IP $remote_addr;
9
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
10
    }
11
}
12

13

14
server {
15
    listen 80;
16
    server_name bbb.test.com;  # 将泛解析的域名替换为你实际使用的域名
17

18
    location / {
19
        proxy_pass http://127.0.0.1:80;
20
        proxy_set_header Host $host;
21
        proxy_set_header X-Real-IP $remote_addr;
22
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
23
    }
24
}

展开收起

踩坑#

1.看似简单，但是要注意在客户端配置的端口，在服务端的服务器也要打开限制，比如服务端frp的端口是7000，你客户端设置的端口是6000，那么腾讯云就要开6000和7000这个端口才能使用 2.后来使用中发现仪表盘无法访问，经过查证是防火墙没有开放相关端口，所以记录一下

Terminal window展开收起

1
#检测端口是否开启，返回yes代表开启，no代表未开启。（7500表示端口，下同）
2
firewall-cmd --query-port=7500/tcp --zone=public
3

4
#开启代码端口，success表示成功
5
firewall-cmd --zone=public --add-port=7500/tcp --permanent
6

7
#批量开
8
firewall-cmd --zone=public --add-port=7001-7010/tcp --permanent
9

10
#查看放行的端口
11
firewall-cmd --list-all
12

13
#重载规则
14
firewall-cmd --reload
15

16
#重启服务器
17
systemctl restart firewalld

展开收起

Metasploit渗透测试实战：白帽子从入门到精通

Fri, 15 Mar 2024 00:00:00 GMT

本文基于作者实际学习经验，基于实际安全测试环境进行渗透测试学习，总结 Metasploit 框架的核心使用方法。

根据pdf，总结自己认为比较重要的，欢迎大佬指错。

1.Metasploit基础#

1.1 专业术语#

1.1.1 渗透攻击（Exploit）#

由攻击者或渗透测试者利用一个系统、应用或服务中心的安全漏洞进行的攻击行为。往往会造成开发者所没有预期到的一种特殊结果。

1.1.2 攻击载荷（Payload）#

目标系统在被渗透攻击之后去执行的代码，在Metasploit框架中可以自由地选择、传送和植入。

1.1.3 Shellcode#

渗透攻击时作为攻击载荷运行的一组机器指令，通常用汇编语言编写。

1.1.4 模块（Module）#

Metasploit框架里面包含了许多软件组件，代表的就是模块，比如渗透攻击模块、辅助模块等。

1.1.5 监听器（Listener）#

Metasploit框架中用来等来接入网络连接的组件，比如目标主机被渗透攻击之后，通过互联网进行连接。

1.2 用户接口#

Metasploit为用户提供了多种接口，包含终端、命令行、图形化界面等。

1.2.1 MSF终端#

目前最流行的接口，灵活且功能丰富，后续的操作都基于此。启动命令：msfconsole

MSF终端

1.2.2 MSF命令行#

主要用于脚本和其他命令行工具的互操作性。在明确渗透工具和参数时，使用这个将会效率翻倍。（目前好像被废弃了emmm）

1.2.3 Armitage#

一个界面交互系统，不比命令那么酣畅淋漓，简单介绍下（以后补）。

Terminal window

1
#启动程序
2
armitage

1.3 功能程序#

1.3.1 MSF攻击载荷生成器#

简单就是把shellcode加入到各种文件中，js、html、py等等。

1.3.2 MSF编码器#

简单来说就是加壳，给shellcode加点料，让别人（杀毒软件）看不懂。

1.3.3 Nasm Shell#

目前的理解就是把指令操作转化成汇编的工具。

2.情报收集#

安全专家们都说是最重要的环节，用尽手段收集信息当然前提不能犯罪。比如渗透网站，就在网站的界面来回点，google该网站所属公司等碎片化信息，要想获取root权限，这些步骤必不可少。

2.1 被动信息收集#

不直接接触目标的情况下挖掘目标信息。比如接触运维人员，了解服务器的型号和系统等，也可以用whois工具在公开渠道获取情报。

2.1.1 whois查询#

简单查询了下某个域名，发现这些有用信息：①域名服务器：grs-whois.hichina.com（阿里云）②注册地址www.net.cn（阿里云）③更新时间，创建时间，创建者，注册商IANA编号④DNS服务器就是Name Server（ps：往往dns服务器部署在公司内部，解析域名和ip，所以看到很多对应关系）

whois查询

2.1.2 Netcraft#

这个网站是在线的直接搜索即可 https://sitereport.netcraft.com/

Netcraft

这里查到了ipv4的地址信息，我们直接whois查询ip地址，获取了一些信息（emmm好像没啥用）。

whois IP查询

2.1.3 NSLookup#

获取服务器附加信息的工具。有比较多的命令行，这里简单介绍几个。

1
A：指的是用来指定主机名或域名对应的IPv4记录
2
AAAA：指的是用来指定主机名或域名对应的IPv6记录
3
MX：邮件交换记录，它指向一个邮件服务器，用于电子邮件系统
4
NS：用来指定该域名由那个DNS服务器来进行解析
5
SOA：起始授权机构记录，SOA记录说明了在众多NS记录里那一台才是主要的服务器
6
CNAME：别名记录，也称为规范名字。这种记录允许将多个名字映射到同一台计算机
7
TXT：一般指为某个主机名或域名设置的说明

NSLookup查询1

NSLookup查询2

NSLookup查询3

Non-authoritative answer：表示未证实回答，说明是缓存读来的，不是向服务商请求获得的。

2.2 主动信息收集#

2.2.1 Nmap端口扫描#

Terminal window展开收起

1
#ping扫描，主机存活就扫描
2
nmap -sP <域名或ip>
3

4
#Tcp扫描，与扫描端口建立TCP连接（缺点会在目标主机留下日志溯源）
5
nmap -sT <域名或ip>
6

7
#半开扫描，SYN扫描需要root（只建立第一次握手，失败就放弃一般不会被留痕）
8
nmap -sS <ip地址>
9

10
#路由追踪扫描，了解网络通行情况，各个节点花费的时间
11
nmap -traceroute <域名或ip>
12

13
#扫描网段下的ip（会根据地址搜索当前网段）
14
nmap ip地址/24
15

16
#扫描一个目标列表
17
nmap -iL [ip地址列表文件]
18

19
#非ping扫描不执行主机发现，可以跳过防火墙（-PA：ACK方式，-PS：SYN方式，-PU：UDP方式，-PY：SCTP INIT）
20
nmap -Pn <域名或ip>
21

22
#脚本扫描
23
nmap --script=[指令] [ip]
24
auth：绕过鉴权扫描
25
broadcast：在局域网探查更多服务开启情况
26
brute：对常见http/smtp提供暴力破解
27
dos：用于拒绝服务攻击
28
vuln：用于检查目标主机是否有常见漏洞
29
version：负责增强服务与版本扫描的功能的脚本
30
malware：探测目标机是否感染了病毒，开启后门等信息
31
fuzzer：模糊测试脚本，发送异常的包到目标机，探测出潜在漏洞
32

33
#附加参数
34
-p：指定扫描端口
35
-A：全面系统检测，花费时间长
36
-vv：对扫描结果详细输出
37
-sV：探测打开对应的服务版本信息
38
-O：操作系统检测
39
-n：不进行域名解析

展开收起

2.2.2 使用数据库#

在实际的渗透场景中，可能需要多个主机，多个端口，所以比较好的方式就是将收集到的信息存入数据库统一管理。这里使用PostgreSQL，因为这个是Metasploit默认的。

2.2.2.1 连接数据库#

Terminal window展开收起

1
#启动数据库服务
2
service postgresql start
3

4
#初始化数据库
5
msfdb init
6

7
#启动msfconsole
8
msfconsole
9

10
#检测连接状态
11
db_status
12

13
#手动连接数据库
14
db_connect msf:admin@127.0.0.1/msf
15

16
#数据库配置文件
17
vi /usr/share/metasploit-framework/config/database.yml

展开收起

数据库连接1

数据库连接2

连接成功

2.2.2.2 将nmap输出结果导入Metasploit#

Terminal window

1
#扫描虚拟机网段（oX表示输出位xml格式，Subnet1就是文件名）
2
nmap -Pn -sS -A -oX Subnet1 192.168.48.0/24

nmap扫描1

nmap扫描2

Terminal window

1
#连接数据库
2
db_connect msf:admin@127.0.0.1/msf
3

4
#导入数据
5
db_import Subnet1
6

7
#显示数据库主机信息
8
db_hosts -C address

导入数据

2.2.2.3 TCP空闲扫描#

高级扫描，冒充内网中另一台电脑的ip地址对目标主机进行探测。递增ip帧标志理解成一个数值，如果局域网内的某台主机是空闲的，那么这个数值将可以预测，高级扫描就是找到这样一台主机来进行伪装扫描。

Terminal window

1
#使用scanner/ip/ipidseq框架
2
use auxiliary/scanner/ip/ipidseq
3
#参数说明
4
show options

空闲扫描参数

该列表展示了执行扫描所需要的参数：

RHOSTS：被扫描的目标，可以使用ip地址段（192.168.1.110-192.168.1.212）、CIDR地址块（192.168.1.48.0/24）、使用逗号分隔的多个CIDR地址块（192.168.1.0/24，192.168.5.0/24）、以及每行包含一个IP地址的IP列表文本文件

THREAD：所有扫描模块的默认线程数为1，增加参数可以提高扫描速度，一般windows平台不超过16，unix平台不超过128。

Terminal window

1
#指定cidr地址块
2
set RHOSTS 192.168.48.0/24
3
#线程数设置
4
set THREADS 50

空闲扫描结果1

空闲扫描结果2

这里捕获到两台空闲主机，133是我的xp，2就不知道是啥了，这里打算用空闲主机(192.168.1.2)对目标主机（192.168.1.133）进行扫描。这样我们就不需要通过自身ip发送任何数据包，就可以获取目标主机的端口信息。

Terminal window

1
nmap -PN -sI 192.168.1.2 192.168.1.133

空闲扫描攻击

2.2.2.4 在MSF客户端运行nmap#

连接数据库后采用db_nmap，不仅可以扫描，还能把扫描到的数据存库。

Terminal window

1
db_nmap -sS -A 192.168.48.133

db_nmap

2.2.3 Metasploit进行端口扫描#

metasploit不仅可以用第三方扫描器，还内建了一些扫描端口工具，搭配框架使用相得益彰。

SYN端口扫描器对单主机进行简单扫描：

Terminal window

1
#搜索端口扫描模块
2
search portscan
3

4
#使用syn扫描
5
use auxiliary/scanner/portscan/syn
6

7
#设置目标ip
8
set rhosts 192.168.48.133
9

10
#设置线程数
11
set threads 50
12

13
#启动攻击
14
run

这个扫描有点慢，这里可以看到目前135端口是开放的。

端口扫描

2.3 针对性扫描#

如果有捷径肯定是要走的，没什么要羞愧的，所以针对性扫描是很有必要的，假如市场告诉你大部分机子都存在一个漏洞，你肯定优先扫描，比如MS08-067（著名的远程溢出漏洞，影响范围是Windows 2000/XP/Server 2003/Vista/Server 2008的各个版本，甚至还包括测试阶段的Windows 7 Pro-Beta）

2.3.1 服务器消息块协议扫描#

SMB协议是微软和英特尔1987年制定的通信协议，大多运行在Windows系统上。Metasploit可以利用它的smb_version模块来遍历一个网络，并获取Windows系统的版本号。

Terminal window

1
#搜索端口扫描模块
2
search smb_version
3

4
#使用smb_version
5
use auxiliary/scanner/smb/smb_version
6

7
#设置目标ip
8
set rhosts 192.168.48.133
9

10
#启动
11
run

这里可以看到我靶机的版本xp sp3、中文、用户名等信息。

SMB扫描

2.3.2 搜寻配置不当的Microsoft SQL Server#

MS SQL安装后，默认监听在TCP端口1443或者使用随机的动态TCP端口。如果是随机的动态端口，只要简单的对1434这个udp端口进行查询，就能知道随机的tcp端口号，metasploit有一个mssql_ping模块可以帮我们完成。

Terminal window

1
#使用mssql_ping
2
use auxiliary/scanner/mssql/mssql_ping
3

4
#设置目标网段
5
set rhosts 192.168.48.0/24
6

7
#设置线程数（255提高扫描速度）
8
set threads 255
9

10
#启动
11
run

MSSQL扫描

2.3.3 SSH服务器扫描#

识别ssh安全协议的版本，ssh很多版本中被发现存在漏洞，这是一种安全协议，这里的安全仅代表数据安全。

Terminal window

1
#使用ssh_version
2
use scanner/ssh/ssh_version
3
#设置线程数
4
set threads 50
5
#设置目标
6
set rhosts 192.168.48.0/24
7
#查看配置
8
show options
9
#启动扫描
10
run

我的虚拟机中有一台windows，一台kali，一台centos7。这里132是kali自身（连自己都不放过），128是centos7。

SSH扫描

2.3.4 FTP扫描#

FTP是一个复制且缺乏安全性的应用侧协议，其实就是个文件传输协议。这里可以用ftp_version对xp虚拟机进行扫描。

Terminal window

1
use scanner/ftp/ftp_version
2
set threads 50
3
set rhosts 192.168.48.133
4
run

FTP扫描

成功识别到ftp服务器，接下来检查下是否允许匿名登陆。

Terminal window

1
use scanner/ftp/anonymous
2
set threads 50
3
set rhosts 192.168.48.133
4
run

结果可以看到允许匿名登陆，但是只有读的权限，没有写入权限。

FTP匿名扫描

2.3.5 简单网管协议扫描#

SNMP称为简单网管协议，设计之初是用来报告带宽利用率、冲突率以及其他一些信息。

Terminal window

1
use scanner/snmp/snmp_enum
2
set rhosts 192.168.48.133
3
set threads 50
4
run

扫描完之后获取了非常庞大的信息，主机名、描述、端口开放情况、服务情况等。

SNMP扫描

3.漏洞扫描#

这一章节主要就是介绍市面上常见的一些漏洞扫描工具。

3.1 NeXpose#

这个工具通过对网络进行扫描，然后找到正在运行的设备，最终识别操作系统和应用程序上的安全漏洞，生成各种类型的报告。

注意事项：

安装的时候要注意，记得输入的账号和密码，后续登陆软件要用。

需要有个企业邮箱，要不然官网密钥没地方发，去zoho注册一个就好

去官网登陆网站注册一步步往下

这软件扫描动静非常大，开启了目标就会警觉所以适合授权扫描，感觉适合做等保。

3.2 Nessus#

说是当前世界上使用最广泛的扫描漏洞工具，安装很简单就是直接下载无脑下一步就好了。

又踩坑了，没有科学上网插件会一直编译非常慢，记得科学上网开起来。

这软件相比于NeXpose感觉差不多，可能就是专业一点受众大一点，做安服的或许会用到这里就不深入研究了。

3.3 专用漏洞扫描器#

3.3.1 验证SMB登陆#

这就是个文件共享，比如windows系统是可以局域网共享文件的，还有nas系统群辉也有很多共享服务，我们可以针对进行扫描。

Terminal window

1
use auxiliary/scanner/smb/smb_login
2
set RHOSTS 192.168.48.133
3
set SMBUSER Administrator
4
set SMBPASS s3cr3t
5
run

SMB登陆验证

很多公司的系统都是镜像克隆安装的，所以拿到一个账号密码每个电脑都能smb访问了。

3.3.2 VNC空口令#

这是一个基于linux和unix的远程开源控制软件。

Terminal window

1
use auxiliary/scanner/vnc/vnc_none_auth
2
set RHOSTS 192.168.48.133
3
run

VNC空口令

3.3.3 开放的X11服务器#

一个用于在本地和远程计算机之间传输键盘和鼠标事件的协议，通过这个漏洞可以检测键盘的行为。

Terminal window

1
use auxiliary/scanner/x11/open_x11
2
set RHOSTS 192.168.48.133
3
run

X11扫描

番外#

Terminal window

1
#更新软件列表
2
apt-get update
3

4
#更新软件
5
apt-get upgrade
6

7
#更新内核
8
apt-get dist-upgrade

CentOS7 Docker安装使用指南：从零开始部署各种软件

Fri, 01 Mar 2024 00:00:00 GMT

📝 本文基于作者实际部署经验，已在 CentOS7 上成功部署 Docker 环境并运行多个容器化应用。

docker命令集合#

Terminal window

1
#启动docker所有容器
2
docker start $(docker ps -a | awk '{ print $1}' | tail -n +2)

1.安装docker#

官方建议内核为3.10及以上；在安装docker需要安装前置软件；

Terminal window展开收起

1
#查看当前内核版本号
2
uname -r
3

4
#前置软件安装
5
yum install -y yum-utils device-mapper-persistent-data lvm2
6

7
#设置中央仓库yum源
8
yum-config-manager --add-repo http://download.docker.com/linux/centos/docker-ce.repo
9
#上面不行就用阿里
10
yum-config-manager --add-repo https://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
11

12
#查看docker版本
13
yum list docker-ce --showduplicates | sort -r
14

15
#执行安装，结尾是版本号
16
yum -y install docker-ce-18.03.1.ce
17

18
#启动docker
19
systemctl start docker
20

21
#设置docker开机自启动
22
systemctl enable docker

展开收起

Docker安装完成后查看版本号

Docker服务启动成功

2.docker镜像加速#

docker拉取镜像太慢了，所以采用个镜像加速，简单修改配置文件实现。

Terminal window展开收起

1
#docker镜像加速
2
vim /etc/docker/daemon.json
3

4
#添加的源地址
5
{
6
    "registry-mirrors" : [
7
    "https://registry.docker-cn.com",
8
    "https://docker.mirrors.ustc.edu.cn",
9
    "http://hub-mirror.c.163.com",
10
    "https://cr.console.aliyun.com/"
11
  ]
12
}
13
#添加后记得加载和重启下
14
systemctl daemon-reload
15
systemctl restart docker

展开收起

3.Portainer安装#

一款开源的轻量级容器管理工具，谁用都舒服，而且很清凉。

Terminal window展开收起

1
docker volume create portainer_data
2

3
#下个中文包（这是我的路径：/home/docker/volume/portainer/pubilc）
4
wget https://github.com/eysp/public/archive/refs/tags/public.tar.gz
5

6
#拉镜像并安装
7
docker run -d --restart=always \
8
--name="portainerUI" \
9
-p 9000:9000 \
10
-v /var/run/docker.sock:/var/run/docker.sock \
11
-v /home/docker/volume/portainer/pubilc:/public \
12
-v portainer_data:/data \
13
portainer/portainer-ce:2.9.1
14

15
#直接访问9000端口设置完密码，会要求你重启容器
16
docker restart portainerUI
17

18
#开个防火墙
19
firewall-cmd --permanent --add-port=9000/tcp
20
firewall-cmd --reload
21
firewall-cmd --list-all

展开收起

4.docker部署oracle 11g#

拉取镜像，然后查看本地镜像，运行容器，查看容器状态，连接oracle进行操作。

Terminal window

1
#拉取阿里云 oracle 11g镜像及启动
2
docker pull registry.cn-hangzhou.aliyuncs.com/helowin/oracle_11g
3

4
#查看本地镜像
5
docker images
6

7
#运行容器
8
docker run -d -p 1521:1521 --name oracle-11g 3fa112fd3642
9

10
#查看容器状态
11
docker ps
12

13
#进入oracle容器（建议手打）
14
docker exec -it oracle-11g /bin/bash

Docker拉取Oracle 11g镜像

查看本地Oracle镜像列表

运行Oracle 11g容器

查看Oracle容器运行状态

4.1 导入数据#

先把主系统里的文件复制到容器，然后这里进入后su root可以进入管理员账户（密码：helowin），把文件夹的所有者改成oracle。后续就是【数据泵的操作】

Terminal window

1
#复制主系统里的文件到容器(cp后紧跟主系统的路径，然后是容器id，冒号后是容器的位置)
2
docker cp /home/test.sql 8cf9014a034a:/opt/sql
3

4
#修改文件夹所有者为oracle用户（xxx表示文件夹路径）
5
chown -R oracle:oinstall xxx

5.docker部署jenkins#

先部署java和maven，然后安装jenkins镜像。

5.1 java源码部署#

这里采用源码安装的方式，因为只需要供jenkins调用就好，没必要配置给宿主机。源码部署只需要解压即可，下面是配置给宿主机的方式。

Terminal window展开收起

1
#检测自带java版本（有的话就不需要部署，但是还是建议用自己公司的开发版本）
2
rpm -qa | grep java
3

4
#删除没用的版本（检测到自带的没用的就删了，避免冲突）
5
rpm -e --nodeps java-1.7.0-openjdk-1.7.0.191-2.6.15.5.el7.x86_64 java-1.7.0-openjdk-headless-1.7.0.191-2.6.15.5.el7.x86_64 java-1.8.0-openjdk-headless-1.8.0.181-7.b13.el7.x86_64 java-1.8.0-openjdk-1.8.0.181-7.b13.el7.x86_64
6

7
#rpm安装（这里的版本是我自己上传的，每个人不一样百度即可）
8
rpm -ivh /opt/jdk-8u11-linux-x64.rpm
9

10
#配置变量
11
vim /etc/profile
12
export JAVA_HOME=/usr/java/jdk1.8.0_11
13
export JRE_HOME=${JAVA_HOME}/jre
14
export CLASSPATH=.:${JAVA_HOME}/lib:${JRE_HOME}/lib
15
export PATH=${JAVA_HOME}/bin:$PATH
16

17
#加载变量
18
source /etc/profile
19
echo $JAVA_HOME
20

21
#检测安装结果
22
java -version

展开收起

5.2 maven部署#

Terminal window展开收起

1
#安装wget
2
yum -y install wget
3

4
#wget下载maven
5
wget https://mirrors.tuna.tsinghua.edu.cn/apache/maven/maven-3/3.6.3/binaries/apache-maven-3.6.3-bin.tar.gz
6

7
#解压
8
tar -zxvf apache-maven-3.6.3-bin.tar.gz
9

10
#配置环境变量（MAVEN_HOME后面表示maven路径，每个人不一样）
11
vi /etc/profile
12
MAVEN_HOME=/opt/maven/apache-maven-3.6.1
13
export PATH=${MAVEN_HOME}/bin:${PATH}
14

15
#加载环境变量
16
source /etc/profile
17

18
#查看mvn安装情况
19
mvn -version

展开收起

5.3 jenkins部署#

Terminal window展开收起

1
#下拉jenkins中文镜像
2
docker pull jenkins/jenkins:latest
3

4
#创建jenkins挂载目录并授权
5
mkdir -p /var/jenkins_mount
6
chmod 775 /var/jenkins_mount
7
chown -R 1000:1000 /var/jenkins_mount
8

9
#创建并启动Jenkins容器（这里启动我加了很多附加条件，根据自己需要进行调整）
10
#(这里映射端口、挂载maven、jdk、tomcat和时间目录,注意最后是镜像名字)
11
#-p：映射端口，前面是服务器端口，后面是镜像端口。
12
#-v：挂载目录，前面是服务器挂载目录，后面是容器的工作目录
13
docker run -d -p 8088:8080 \
14
-v /var/jenkins_mount:/var/jenkins_home \
15
-v /opt/apache-maven-3.6.3:/opt/apache-maven-3.6.3  \
16
-v /opt/jdk1.8.0_281:/opt/jdk1.8.0_281 \
17
-v /etc/localtime:/etc/localtime --name jenkins jenkins/jenkins:latest
18

19
#进入jenkins容器
20
docker exec -it 容器ID bash

展开收起

5.4参考#

jenkins部署后续的jenkins操作参考这两篇文章： 1.安装jenkins 2.部署gitLab项目

6.mySql部署#

Terminal window

1
#下载mysql镜像
2
docker pull mysql:5.7
3

4
#创建mysql挂载目录并授权
5
mkdir -p /opt
6
mkdir -p /opt/mysql
7
mkdir -p /opt/mysql/conf/
8
mkdir -p /opt/mysql/logs/
9
mkdir -p /opt/mysql/data/
10

11
#创建mysql配置文件
12
vim /opt/mysql/my.cnf

Terminal window

1
[mysqld]
2
user=mysql
3
character-set-server=utf8
4
default_authentication_plugin=mysql_native_password
5
secure_file_priv=/var/lib/mysql
6
expire_logs_days=7
7
sql_mode=STRICT_TRANS_TABLES,NO_ZERO_IN_DATE,NO_ZERO_DATE,ERROR_FOR_DIVISION_BY_ZERO,NO_ENGINE_SUBSTITUTION
8
max_connections=1000
9

10
[client]
11
default-character-set=utf8
12

13
[mysql]
14
default-character-set=utf8

这里我把映射端口改成3307避免本地的mysql冲突，云服务器记得开放端口

Terminal window

1
#创建容器，并后台启动
2
docker run --restart=always --privileged=true  \
3
-v /opt/mysql/my.cnf:/etc/mysql/my.cnf  \
4
-v /opt/mysql/logs:/logs \
5
-v /opt/mysql/data:/var/lib/mysql \
6
-v /opt/mysql/conf:/etc/mysql/conf.d \
7
-p 3307:3306 --name my-mysql \
8
-e MYSQL_ROOT_PASSWORD=123456 -d mysql:5.7
9

10
#本地进入mysql容器（两种方式均可）
11
docker exec -it 容器ID bash
12
docker exec -it 容器name /bin/bash

会碰到无法navicate无法连接问题，提示密码已经正常，这是由于5.7要专门开启ip登陆的权限，下面是命令。

Terminal window展开收起

1
#记得先登录mysql（回车输入密码）
2
mysql -u root -p
3

4
#使用数据库
5
use mysql;
6

7
#查询权限
8
select host, user from user;
9

10
#给root及其密码权限
11
GRANT ALL PRIVILEGES ON *.* TO 'root'@'%' IDENTIFIED BY '123456' WITH GRANT OPTION;
12

13
#关闭远程登陆权限
14
update user set host = "127.0.0.1" where user = "root" and host = "%";
15

16
#刷新
17
flush privileges;

展开收起

MySQL容器中授权root远程登录

测试navicate连接

Navicat成功连接MySQL数据库

题外#

docker降级#

Terminal window

1
yum remove docker-ce docker-ce-cli containerd.io
2
yum autoremove
3
yum install docker-ce-19.03.15 docker-ce-cli-19.03.* containerd.io
4
systemctl start docker
5
systemctl enable docker
6
docker --version

docker卸载容器#

1.查看正在运行的容器
2.先暂停启动的容器
3.卸载容器

Terminal window展开收起

1
#查看正在运行的容器
2
docker ps
3

4
#查看所有容器（-a: all）
5
docker ps -a
6

7
#启动暂停容器
8
docker start 容器id
9

10
#暂停指定容器
11
docker stop 容器id
12

13
#删除指定容器
14
docker rm 容器id
15

16
#删除指定镜像
17
docker rmi 镜像id
18

19
#容器启动失败查看日志
20
docker logs 镜像id

展开收起

CentOS7服务开机自启动配置：Nginx等常用服务

Thu, 15 Feb 2024 00:00:00 GMT

📝 本文基于作者实际运维经验，已在生产环境配置多个服务的开机自启动，解决断电后服务丢失问题。

centos7各种服务的开机自启动，偶尔会断电涉及到要开的服务就很多，所以这里统一写了一些，后续会不断更新。

1.nginx自启动#

进入centos的启动目录，编写启动脚本

Terminal window

1
vim /usr/lib/systemd/system/nginx.service

Terminal window

1
#nginx 启动脚本
2
[Unit]
3
Description=nginx
4
After=network.target
5

6
[Service]
7
Type=forking
8
ExecStart=/usr/local/nginx/sbin/nginx -c /usr/local/nginx/conf/nginx.conf
9
ExecReload=/usr/local/nginx/sbin/nginx -s reload
10
ExecStop=/usr/local/nginx/sbin/nginx -s quit
11
PrivateTmp=true
12

13
[Install]
14
WantedBy=multi-user.target

Terminal window

1
#设置开机自启动
2
systemctl enable nginx
3

4
#查看服务状态
5
systemctl status nginx

2.jenkins自启动#

直接输入命令即可

Terminal window

1
systemctl enable jenkins.service

3.tomcat自启动#

进入tomcat的bin目录编辑catalina.sh文件，在这个位置加入这个语句（搜索就是esc后，按/后面输入搜索的内容）

Terminal window

1
vim catalina.sh
2
CATALINA_PID="$CATALINA_BASE/tomcat.pid"

在catalina.sh中添加CATALINA_PID配置

编辑自启动脚本

Terminal window

1
vim /usr/lib/systemd/system/tomcat.service

注意environment的位置是电脑java环境的位置，tomcat的位置也要替换

Terminal window展开收起

1
#tomcat自启动脚本
2
[Unit]
3
Description=Tomcat
4
After=syslog.target network.target remote-fs.target nss-lookup.target
5

6
[Service]
7
Type=forking
8

9
Environment="JAVA_HOME=/usr/java/jdk1.8.0_11"
10

11
PIDFile=/opt/tomcat/apache-tomcat-8.5.69/tomcat.pid
12
ExecStart=/opt/tomcat/apache-tomcat-8.5.69/bin/startup.sh
13
ExecStop=/bin/kill -s QUIT $MAINPID
14
ExecReload=/bin/kill -s HUP $MAINPID
15
PrivateTmp=true
16

17
[Install]
18
WantedBy=multi-user.target

展开收起

Terminal window

1
#设置生效
2
systemctl daemon-reload
3
#开机自启
4
systemctl enable tomcat.service
5
#查看状态
6
systemctl status tomcat.service
7
#启动服务
8
systemctl start tomcat.service

4.oracle自启动#

找到这个路径/xxx/product/11.2.0/db_1/bin/，编写启动脚本（附在后面），然后修改为可执行，再创建软连接

Terminal window展开收起

1
#编写开机启动脚本（xxx表示自己的路径）
2
vim oracledb
3

4
#修改脚本为可执行
5
chmod a+x oracledb
6

7
#创建软链接（一定要用绝对路径）
8
ln -s xxx/oracledb /etc/rc.d/init.d/oracledb
9

10
#授权
11
chmod 755 /etc/rc.d/init.d/
12

13
#添加服务
14
chkconfig --add oracledb
15

16
#修改oracle启动配置（N改Y）
17
vim /etc/oratab
18
orcl:xxx/product/11.2.0/dbhome_1:Y
19

20
#开关
21
service oracledb stop
22
service oracledb start

展开收起

1
#!/bin/sh
2
# chkconfig: 35 80 10
3
# description: Oracle auto start-stop script.
4

5
#
6
# Set ORA_HOME to be equivalent to the $ORACLE_HOME
7
# from which you wish to execute dbstart and dbshut;
8
#
9
# Set ORA_OWNER to the user id of the owner of the
10
# Oracle database in ORA_HOME.
11
ORA_HOME=/data/oracle/product/11.2.0/db_1
12
ORA_OWNER=oracle
13
if [ ! -f $ORA_HOME/bin/dbstart ]
14
then
15
  echo "Oracle startup: cannot start"
16
  exit
17
fi
18
case "$1" in
19
'start')
20
# Start the Oracle databases:
21
echo "Starting Oracle Databases ... "
22
echo "-------------------------------------------------" >> /var/log/oracle
23
date +" %T %a %D : Starting Oracle Databases as part of system up." >> /var/log/oracle
24
echo "-------------------------------------------------" >> /var/log/oracle
25
su - $ORA_OWNER -c "$ORA_HOME/bin/dbstart" >>/var/log/oracle
26
echo "Done"
27

28
# Start the Listener:
29
echo "Starting Oracle Listeners ... "
30
echo "-------------------------------------------------" >> /var/log/oracle
31
date +" %T %a %D : Starting Oracle Listeners as part of system up." >> /var/log/oracle
32
echo "-------------------------------------------------" >> /var/log/oracle
33
su - $ORA_OWNER -c "$ORA_HOME/bin/lsnrctl start" >>/var/log/oracle
34
echo "Done."
35
echo "-------------------------------------------------" >> /var/log/oracle
36
date +" %T %a %D : Finished." >> /var/log/oracle
37
echo "-------------------------------------------------" >> /var/log/oracle
38
touch /var/lock/subsys/oracle
39
;;
40

41
'stop')
42
# Stop the Oracle Listener:
43
echo "Stoping Oracle Listeners ... "
44
echo "-------------------------------------------------" >> /var/log/oracle
45
date +" %T %a %D : Stoping Oracle Listener as part of system down." >> /var/log/oracle
46
echo "-------------------------------------------------" >> /var/log/oracle
47
su - $ORA_OWNER -c "$ORA_HOME/bin/lsnrctl stop" >>/var/log/oracle
48
echo "Done."
49
rm -f /var/lock/subsys/oracle
50

51
# Stop the Oracle Database:
52
echo "Stoping Oracle Databases ... "
53
echo "-------------------------------------------------" >> /var/log/oracle
54
date +" %T %a %D : Stoping Oracle Databases as part of system down." >> /var/log/oracle
55
echo "-------------------------------------------------" >> /var/log/oracle
56
su - $ORA_OWNER -c "$ORA_HOME/bin/dbshut" >>/var/log/oracle
57
echo "Done."
58
echo ""
59
echo "-------------------------------------------------" >> /var/log/oracle
60
date +" %T %a %D : Finished." >> /var/log/oracle
61
echo "-------------------------------------------------" >> /var/log/oracle
62
;;
63

64
'restart')
65
$0 stop
66
$0 start
67
;;
68
esac

展开收起

CentOS7安装Jenkins：从零开始搭建CI/CD环境

Sat, 20 Jan 2024 00:00:00 GMT

本文基于作者实际部署经验，已在 CentOS7 上成功安装 Jenkins 并配置 CI/CD 环境，涵盖 JDK 版本选择、插件源修改、中文插件安装等关键步骤。

1.安装对应版本的jdk#

Terminal window

1
#jenkins2.357之前不再支持java8，之后的版本使用java11或java17
2
yum install -y java

2.安装Jenkins#

清华大学镜像

把jenkins的网址导入yum安装里，然后用yum安装但是要注意跳过签名认证

Terminal window

1
wget https://mirrors.tuna.tsinghua.edu.cn/jenkins/redhat-stable/jenkins-2.346.3-1.1.noarch.rpm
2

3
#安装
4
yum install jenkins-2.346.3-1.1.noarch.rpm

2.1 修改配置#

修改端口号和用户（用户不改root，会有很多权限问题）。

旧版本配置文件：/etc/sysconfig/jenkins 新版本配置文件：/usr/lib/systemd/system/jenkins.service

目前我测试过的2.331和2.346是旧版配置文件，2.348为新版配置文件

Terminal window

1
#查看jenkins版本
2
cat /var/lib/jenkins/config.xml | grep version

2.1.1 旧版配置文件#

Terminal window

1
vim /etc/sysconfig/jenkins

旧版配置1

旧版配置2

2.1.2 新版配置文件#

Terminal window

1
vim /usr/lib/systemd/system/jenkins.service
2

3
#修改完，记得刷新配置
4
systemctl daemon-reload

新版配置

3.Jenkins基本操作#

Terminal window

1
启动：service jenkins start
2
停止：service jenkins stop
3
重启：service jenkins restart

4.访问Jenkins#

http://192.168.1.50:8088/ — ip地址改成自己的设备

访问Jenkins

Terminal window

1
cat /var/lib/jenkins/secrets/initialAdminPassword

初始密码

复制完密码粘贴后，点击继续即可。

5.Jenkins似乎离线，解决#

离线问题

修改/var/lib/jenkins/hudson.model.UpdateCenter.xml文件，记得要留一个备份。

也可以访问 http://ip:port/pluginManager/advanced 直接拉到最下面修改更新源进行提交后刷新界面。

Terminal window

1
#备份
2
cp hudson.model.UpdateCenter.xml hudson.model.UpdateCenter.xml.default
3
#修改
4
vim /var/lib/jenkins/hudson.model.UpdateCenter.xml
5

6
#下载源：
7
http://mirror.esuni.jp/jenkins/updates/update-center.json

修改更新源

然后重启jenkins，再登陆就不会显示离线了。

重启后正常

然后各种跳过进入jenkins首页。

Jenkins首页

6.配置插件源#

这时目录下才有updates文件夹，进去备份后修改

Terminal window

1
#备份
2
cp default.json default.json.def
3
cp hudson.tasks.Maven.MavenInstaller hudson.tasks.Maven.MavenInstaller.def
4

5
#修改
6
sed -i 's#https://updates.jenkins.io/download#https://mirrors.tuna.tsinghua.edu.cn/jenkins#g' default.json
7
sed -i 's#www.google.com#www.baidu.com#g' default.json

重启jenkins

7.下载中文插件#

中文插件1

中文插件2

中文插件3

中文插件4

至此jenkins完成。

8.设置开机自启动#

Terminal window

1
systemctl enable jenkins.service

9.卸载Jenkins#

Terminal window展开收起

1
#停止jenkins
2
service jenkins stop
3

4
#清理无用数据源
5
yum clean all
6

7
#卸载jenkins
8
yum -y remove jenkins
9

10
#rpm卸载jenkins
11
rpm -e jenkins
12

13
#检查是否卸载成功
14
rpm -ql jenkins
15

16
#删除jenkins相关文件
17
find / -iname jenkins | xargs -n 1000 rm -rf

展开收起

补充#

之前由于缺少证书，所以需要手动下载安装此插件。 https://updates.jenkins.io/download/plugins/skip-certificate-check/1.0/skip-certificate-check.hpi

踩坑#

1. Jenkins安装失败#

linux系统本身存在java8的版本，但是安装高版本jenkins需要java11或者java17，给linux安装多个java版本时，启动jenkins失败，修改启动依赖无效。

Terminal window

1
#修改启动依赖
2
vim /etc/init.d/jenkins
3

4
#java
5
/usr/lib/jvm/java-11-openjdk-11.0.16.1.1-1.el7_9.x86_64/bin/java
6
#jre
7
/usr/lib/jvm/jre-11-openjdk-11.0.16.1.1-1.el7_9.x86_64/bin/java

建议直接使用匹配java8的版本。

2. Jenkins端口更改失败#

有个兄弟说2.346这个版本，端口修改完直接启动不了，但是在8080端口启动没有问题。端口改不动的解决办法

PyCharm联合Anaconda：Python环境配置指南

Sun, 01 Oct 2023 00:00:00 GMT

📝 本文基于作者实际配置经验，已在 Windows 上成功配置 PyCharm + Anaconda Python 开发环境。

最近想试着用python做点小东西，先去git上down别人的代码，每个人环境都不一样，所以就用到了Anaconda，来进行环境控制。

1.安装#

直接去官方的网站里找，找不到直接用我这里的链接有各个版本，包括历史版本。基本都是下一步就可以，这里注意下直接打钩，要不然还要手动增加环境变量。 Anaconda官网

Anaconda安装时勾选添加环境变量选项

点开这个，输入命令看下，目前的环境，由图可见只有base，安装完成。

命令行查看Anaconda默认base环境

conda环境列表确认Anaconda安装完成

2.anaconda基本命令#

anaconda启动真的非常慢，反正我电脑是这样，所以我这里都用命令行来操作。

Terminal window

1
#修改国内镜像源
2
conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/free/
3
conda config --set show_channel_urls yes
4

5
#清除索引
6
conda clean -i

在用户目录下找到这个文件.condarc，修改里面内容保存完记得输入清除索引代码 conda clean -i，然后开始毫秒级体验。

用户目录下找到并编辑.condarc配置文件

清华镜像源配置完成后的.condarc文件内容

1
channels:
2
  - defaults
3
show_channel_urls: true
4
default_channels:
5
  - https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/main
6
  - https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/r
7
  - https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/msys2
8
  - http://mirrors.ustc.edu.cn/anaconda/pkgs/free/
9
custom_channels:
10
  conda-forge: https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud
11
  msys2: https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud
12
  bioconda: https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud
13
  menpo: https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud
14
  pytorch: https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud
15
  simpleitk: https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud
16
  ustc: http://mirrors.ustc.edu.cn/anaconda/pkgs/free/
17
  alibaba : https://mirrors.aliyun.com/pypi/simple/
18

19
ssl_verify: true

展开收起

Terminal window展开收起

1
#升级
2
conda update conda
3

4
#查看环境列表
5
conda env list
6

7
#创建虚拟环境（不指定路径）
8
conda create -n env_name（环境名称） python=3.8(对应的python版本号）
9

10
#创建虚拟环境（指定路径）
11
conda create --prefix=env_file（环境路径） python=3.8(对应的python版本号）
12
conda create -p env_file（环境路径） python=3.8(对应的python版本号）
13

14
#激活虚拟环境
15
conda activate env_name（环境名称）
16
#退出虚拟环境
17
conda deactivate env_name（环境名称）
18
#删除虚拟环境（删除前记得先退出环境）
19
conda remove -n env_name(环境名称) --all

展开收起

3.pycharm使用anaconda#

设置环境即可,File-setting

PyCharm中通过File-Settings进入项目设置

设置点一下，可以添加环境，选中自己anaconda的环境

在PyCharm中添加Anaconda解释器环境

选择Anaconda自带的Python解释器路径

4.GitHub项目run#

github上的项目都包含requirements.txt，用于记录所有依赖包及其精确的版本号，以便新环境部署。

Terminal window

1
#生成命令（借助pipreqs工具）
2
pip install pipreqs
3
pipreqs ./ --encoding=utf-8 --force
4

5
#安装命令
6
pip install -r requirements.txt
7

8
#指定源安装
9
pip install -r requirements.txt -i https://pypi.tuna.tsinghua.edu.cn/simple/

5.python使用小心得#

5.1生成的csv多了一列unamed#

CSV文件中多出一列unnamed索引列的问题

这是读取的时候多生成了一个索引列，实际我们是不需要的，只需增加index_col=0

1
data = pd.read_csv(csv_name, nrows=11, index_col=0)

添加index_col=0参数后CSV文件正常显示

Bootstrap响应式二级导航菜单：悬停展开实现

Tue, 05 Sep 2023 00:00:00 GMT

📝 本文基于作者实际开发经验，解决了 Bootstrap 导航菜单二级菜单无法悬停展开的问题。

这次碰到的需求是响应式二级导航窗格，默认的导航窗格只有点击下拉框的二级窗格，会有如下问题：一级菜单无法添加超链接，二级菜单展示要多点一下。

实现目标： 1.滑动到指定区域，展示二级菜单。 2.一级菜单和二级菜单都可以进行连接跳转。

1.核心代码CSS#

首先是css样式，其实就是让二级菜单在悬停（hover）的时候展示，这里我踩了个坑就是要指定到li样式，【.nav-list】中的【.】表示子类继承，而【>li】中的【>】表示指定子类样式，dropdown-menu就是我li的class名称。

1
.nav-list .navbar-nav>li:hover .dropdown-menu {
2
    display: block;
3
}

ps：浏览器的缓存会造成，建议开发者右键检查关闭浏览器缓存

Bootstrap二级导航菜单悬浮展开效果演示

2.核心代码js#

除了css实现悬停弹出二级菜单，还要让一级菜单可以点击，如果不加入js代码一级菜单将无法点击。

1
    let sUserAgent = navigator.userAgent.toLowerCase();
2
    let bIsIpad = sUserAgent.match(/ipad/i) == "ipad";
3
    let bIsIphoneOs = sUserAgent.match(/iphone os/i) == "iphone os";
4
    let bIsMidp = sUserAgent.match(/midp/i) == "midp";
5
    let bIsUc7 = sUserAgent.match(/rv:1.2.3.4/i) == "rv:1.2.3.4";
6
    let bIsUc = sUserAgent.match(/ucweb/i) == "ucweb";
7
    let bIsAndroid = sUserAgent.match(/android/i) == "android";
8
    let bIsCE = sUserAgent.match(/windows ce/i) == "windows ce";
9
    let bIsWM = sUserAgent.match(/windows mobile/i) == "windows mobile";
10

11
    if (!(bIsIpad || bIsIphoneOs || bIsMidp || bIsUc7 || bIsUc || bIsAndroid || bIsCE || bIsWM)) {
12
        // alert("当前是电脑打开");
13
        $(document).ready(function () {
14
            $(document).off('click.bs.dropdown.data-api');
15
        });
16
    }

展开收起

3.完整代码#

注释介绍了用到的class的用途，需要注意的就是css和js为核心，别指定错class否则无法使用

1
<!DOCTYPE html>
2
<html lang="en">
3
<head>
4
    <meta charset="UTF-8">
5
    <title>Title</title>
6
</head>
7
<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/bootstrap@3.3.7/dist/css/bootstrap.min.css">
8
<script type="text/javascript" src="http://code.jquery.com/jquery-1.10.0.js"></script>
9
<script type="text/javascript" src="https://cdn.jsdelivr.net/npm/bootstrap@3.3.7/dist/js/bootstrap.min.js"></script>
10
<style>
11
    .nav-list .navbar-nav > li:hover .response {
12
        display: block;
13
    }
14
</style>
15
<body>
16
<!--navbar-fixed-bottom设置导航条组件固定在底部，默认顶部navbar-fixed-top-->
17
<div class="collapse navbar-collapse nav-list" id="probootstrap-menu">
18
    <!--navbar-default默认主题，navbar-inverse黑色主题-->
19
    <nav class="navbar navbar-default">
20
        <!--container-fluid设置宽度充满父元素，即为100%-->
21
        <div class="container-fluid">
22
            <!-- navbar-header主要指定div元素为导航条组件包裹品牌图标及切换按钮 -->
23
            <div class="navbar-header">
24
                <!--navbar-toggle 设置button元素为导航条组件的切换钮-->
25
                <button type="button" class="navbar-toggle collapsed" data-toggle="collapse"
26
                        data-target="#bs-example-navbar-collapse-1" aria-expanded="false">
27
                </button>
28
                <!--class="navbar-brand" 一般放品牌logo-->
29
                <span class="navbar-brand glyphicon glyphicon-star " aria-hidden="true"/>
30
            </div>
31

32
            <!-- 导航条的body -->
33
            <!--collapse设置button元素为在视口小于768px时才显示-->
34
            <div class="collapse navbar-collapse" id="bs-example-navbar-collapse-1">
35
                <!--navbar-nav设置ul为导航条组件内的列表元素;-->
36
                <ul class="nav navbar-nav">
37
                    <!--第一个导航窗格-->
38
                    <!--active选中后的样式-->
39
                    <li class="active"><a href="#">激活 <span class="sr-only">(current)</span></a></li>
40
                    <!--第二个导航窗格-->
41
                    <!--dropdown表示下拉菜单-->
42
                    <li class="dropdown">
43
                        <a href="#" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true"
44
                           aria-expanded="false">下拉二级菜单 <span class="caret"></span></a>
45
                        <ul class="dropdown-menu">
46
                            <li><a href="#">下拉二级菜单1</a></li>
47
                            <!--role="separator"代表标签充当分隔角色无实际效果；divider分割线-->
48
                            <li role="separator" class="divider"></li>
49
                            <li><a href="#">下拉二级菜单2</a></li>
50
                            <li role="separator" class="divider"></li>
51
                            <li><a href="#">下拉二级菜单3</a></li>
52
                            <li role="separator" class="divider"></li>
53
                            <li><a href="#">下拉二级菜单4</a></li>
54
                        </ul>
55
                    </li>
56
                    <!--第三个导航窗格-->
57
                    <li class="dropdown">
58
                        <a href="#" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true"
59
                           aria-expanded="false">响应式二级菜单 <span class="caret"></span></a>
60
                        <ul class="dropdown-menu response">
61
                            <li><a href="#">响应二级菜单1</a></li>
62
                            <li><a href="#">响应二级菜单2</a></li>
63
                            <li><a href="#">响应二级菜单3</a></li>
64
                            <li><a href="#">响应二级菜单4</a></li>
65
                        </ul>
66
                    </li>
67
                </ul>
68

69

70
                <!--navbar-form表单；navbar-left左浮动-->
71
                <form class="navbar-form navbar-left">
72
                    <!--form-group调整间距，说白了就是个最佳间距样式-->
73
                    <div class="form-group">
74
                        <!--form-control特定效果：宽度变成了100%，浅灰色（#ccc）的边框，4px的圆角，
75
                        阴影效果，并且元素得到焦点之时，阴影和边框效果会有所变化
76
                        placeholder的颜色为#999-->
77
                        <input type="text" class="form-control" placeholder="Search">
78
                        <button type="submit" class="btn btn-default">Submit</button>
79
                    </div>
80
                </form>
81
                <ul class="nav navbar-nav navbar-right">
82
                    <li><a href="http://www.baidu.com">百度链接</a></li>
83
                    <li class="dropdown">
84
                        <a href="#" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true"
85
                           aria-expanded="false">下拉菜单 <span class="caret"></span></a>
86
                        <ul class="dropdown-menu">
87
                            <li><a href="#">1</a></li>
88
                            <li><a href="#">2</a></li>
89
                            <li><a href="#">3</a></li>
90
                            <li role="separator" class="divider"></li>
91
                            <li><a href="#">4</a></li>
92
                        </ul>
93
                    </li>
94
                </ul>
95
            </div><!-- /.navbar-collapse -->
96
        </div><!-- /.container-fluid -->
97
    </nav>
98
</div>
99
</body>
100
<script>
101
    //判断客户端
102
    let sUserAgent = navigator.userAgent.toLowerCase();
103
    console.log("客户端信息:" + "[" + sUserAgent + "]");
104
    //各种类型客户端枚举
105
    let bIsIpad = sUserAgent.match(/ipad/i) === "ipad";
106
    let bIsIphoneOs = sUserAgent.match(/iphone os/i) === "iphone os";
107
    let bIsMidp = sUserAgent.match(/midp/i) === "midp";
108
    let bIsUc7 = sUserAgent.match(/rv:1.2.3.4/i) === "rv:1.2.3.4";
109
    let bIsUc = sUserAgent.match(/ucweb/i) === "ucweb";
110
    let bIsAndroid = sUserAgent.match(/android/i) === "android";
111
    let bIsCE = sUserAgent.match(/windows ce/i) === "windows ce";
112
    let bIsWM = sUserAgent.match(/windows mobile/i) === "windows mobile";
113

114
    if (!(bIsIpad || bIsIphoneOs || bIsMidp || bIsUc7 || bIsUc || bIsAndroid || bIsCE || bIsWM)) {
115
        //不等于以上枚举判断是电脑
116
        console.log("当前是电脑打开");
117
        $(document).ready(function () {
118
            //取消绑定bootstrap导航窗体的下拉框点击事件
119
            // click.bs表示bootstrap的点击，response表示我要取消的class名称
120
            $(document).off('click.bs.response.data-api');
121
        });
122
    }
123
</script>
124
</html>

展开收起

RabbitMQ从入门到实战：消息队列核心用法详解

Fri, 18 Aug 2023 00:00:00 GMT

本文基于作者实际开发经验，已在项目中使用 RabbitMQ 实现异步消息处理，涵盖交换机配置、队列监听及消费者实践。

最近处理访客记录所以，来学习下RabbitMQ。之前同事已经写好了，这里只需要进行消费，后续会逐渐完善。

0.介绍#

0.1 交换机（Exchanges）#

RabbitMQ中生产者发送的消息都是发送到交换机，再由交换机推入队列。所以生产者不知道队列去了哪里，就靠Exchange来控制，交换机总共有以下几种类型。

0.1.1 广播模式（fanout）#

扇出所有消息进入队列，类似广播。

0.1.2 直接交换（direct）#

绑定相关的routerKey分发到不同的队列，简单说就是direct交换机接收了消息后，根据关键词分发队列。

0.1.3 主题模式（topic）#

direct路由比较单一，所以提升了routerKey的能力，在关键词标记下加上了通配符。

*（星号）可以代替一个单词
#（井号）可以替代零个或多个单词

1.公共配置类#

1
spring:
2
    rabbitmq:
3
        host: 127.0.0.1
4
        port: 5672
5
        username: guest
6
        password: guest

1
/**
2
 * RabbitMQ公共配置类
3
 */
4
public class RabbitMQConfig {
5
    /** RabbitMQ的队列主题名称 */
6
    public static final String RABBITMQ_TOPIC = "rabbitmqTopic";
7
    /** RabbitMQ的DIRECT交换机名称 */
8
    public static final String RABBITMQ_DIRECT_EXCHANGE = "rabbitmqDirectExchange";
9
    /** RabbitMQ的Direct交换机和队列绑定的匹配键 */
10
    public static final String RABBITMQ_DIRECT_ROUTING = "rabbitmqDirectRouting";
11
}

2.消费消息的两种方式#

把记录塞进队列里的时候，只是完成了第一步，那你肯定要对他进行消费。分为两种推模式和拉模式：推模式就是生产者发布消息时，主动推送给消费者；拉模式则是消费者发送请求后才会发送。

3.监听队列的两种方式#

一种是@RabbitListener注解的方式，一种是实现SpringBoot的ChannelAwareMessageListener接口的方式。

3.1 @RabbitListener#

如果demoData想不转换成String直接推，得在这个数据流实现序列化。

1
innerRabbitTemplate.convertAndSend(InnerMQConfig.TOPIC_EXCHANGE, msgKey, JSONObject.toJSONString(demoData));

1
@Component
2
public class DemoRabbitMQListener {
3
      @RabbitListener(queues = "demo_queue")
4
      @RabbitHandler
5
      public void demoQueue(Message message){
6
          System.out.println("message:"+message.getBody());
7
      }
8
}

3.2 实现ChannelAwareMessageListener接口#

听前辈说直接实现这个接口，就不用管底层是谁的消息队列了，因为是基于SpringBoot。这个实现起来有点麻烦，我总结了以下顺序：

3.2.1 创建连接工厂（ConnectionFactory）#

publisherConfirms：消息发送到exchange，返回成功或者失败。 publishReturns：消息从exchange到queue，发送成功或者失败。

1
    @Bean(name = "DemoConnectionFactory")
2
    @Primary
3
    public ConnectionFactory connectionFactory() {
4
        CachingConnectionFactory connectionFactory = new CachingConnectionFactory();
5
        connectionFactory.setHost(host);
6
        connectionFactory.setPort(port);
7
        connectionFactory.setUsername(username);
8
        connectionFactory.setPassword(password);
9
        connectionFactory.setVirtualHost(virtualHost);
10
        connectionFactory.setPublisherConfirms(true);
11
        connectionFactory.setPublisherReturns(true);
12
        return connectionFactory;
13
    }

3.2.2 初始化组件（RabbitAdmin）#

1
    @Bean(name = "DemoRabbitAdmin")
2
    @Primary
3
    public RabbitAdmin rabbitAdmin(@Qualifier("DemoConnectionFactory") ConnectionFactory connectionFactory) {
4
        RabbitAdmin rabbitAdmin = new RabbitAdmin(connectionFactory);
5
        rabbitAdmin.setAutoStartup(true);
6
        return rabbitAdmin;
7
    }

3.2.3 创建交换器（Exchange）#

durable：是否持久化，RabbitMQ关闭后，没有持久化的Exchange将被清除 autoDelete：是否自动删除，如果没有与之绑定的Queue，直接删除 internal：是否内置的，如果为true，只能通过Exchange到Exchange

1
    @Bean(DEMO_EXCHANGE)
2
    public TopicExchange exchange() {
3
        return new TopicExchange(DEMO_EXCHANGE, true, false);
4
    }

3.2.4 创建队列（Queue）#

创建队列主要掌握这几个参数：

name：队列名称
durable：队列是否持久化
exclusive：是否排他的队列
autoDelete：是否自动删除
arguments：队列中的消息什么时候会自动被删除

1
    @Bean(QUEUE_NAME)
2
    public Queue QUEUE_DEMO() {
3
        return new Queue(QUEUE_NAME, true, false, false);
4
    }

3.2.5 绑定队列到交换机（Binding）#

1
    @Bean
2
    public Binding BINGING_EXCHANGE_QUEUE(@Qualifier(QUEUE_NAME) Queue queue,
3
                                           @Qualifier(DEMO_EXCHANGE) Exchange exchange) {
4
        return BindingBuilder.bind(queue).to(exchange).with(ROUTING_KEY).noargs();
5
    }

3.2.6 创建监听容器（SimpleMessageListenerContainer）#

1
    @Bean
2
    public SimpleMessageListenerContainer simpleMessageListenerContainer(
3
            @Qualifier("DemoConnectionFactory") ConnectionFactory connectionFactory,
4
            DemoRabbitMQListener demoRabbitMQListener,
5
            @Qualifier(QUEUE_NAME) Queue queue
6
    ) throws AmqpException {
7
        SimpleMessageListenerContainer listenerContainer = new SimpleMessageListenerContainer(connectionFactory);
8
        listenerContainer.setConcurrentConsumers(listenerSize);
9
        listenerContainer.setQueues(queue);
10
        listenerContainer.setExposeListenerChannel(true);
11
        listenerContainer.setAcknowledgeMode(AcknowledgeMode.AUTO);
12
        listenerContainer.setMessageListener(demoRabbitMQListener);
13
        return listenerContainer;
14
    }

3.2.7 创建操作类（RabbitTemplate）#

setConfirmCallback的消息回调是在生产者端要把参数丢进去的。

1
    @Bean(name = "DemoRabbitTemplate")
2
    @Primary
3
    public RabbitTemplate rabbitTemplate(@Qualifier("DemoConnectionFactory") ConnectionFactory connectionFactory) {
4
        RabbitTemplate rabbitTemplate = new RabbitTemplate(connectionFactory);
5
        rabbitTemplate.setMandatory(true);
6
        rabbitTemplate.setConnectionFactory(connectionFactory);
7
        rabbitTemplate.setConfirmCallback(new RabbitTemplate.ConfirmCallback() {
8
            @Override
9
            public void confirm(CorrelationData correlationData, boolean ack, String cause) {
10
                if (ack) {
11
                    log.info("消息发送到交换机成功, 消息 = {}", correlationData.getId());
12
                } else {
13
                    log.error("消息发送到交换机失败! 消息: {}; 错误原因: cause: {}", correlationData.getId(), cause);
14
                }
15
            }
16
        });
17
        rabbitTemplate.setReturnCallback(new RabbitTemplate.ReturnCallback() {
18
            @Override
19
            public void returnedMessage(Message message, int replyCode, String replyText, String exchange, String routingKey) {
20
                String messageId = message.getMessageProperties().getMessageId();
21
                String result = null;
22
                try {
23
                    result = new String(message.getBody(), "UTF-8");
24
                } catch (Exception e) {
25
                    log.error("消息发送失败", e);
26
                }
27
                log.error("消息发送失败, 消息ID = {}; 消息内容 = {}", messageId, result);
28
            }
29
        });
30
        return rabbitTemplate;
31
    }

展开收起

3.2.8 监听消费（RabbitMQListener）#

这个类要注意用@Service或者@Component注解让他交给IOC

1
@Service
2
@Slf4j
3
public class DemoRabbitMQListener implements ChannelAwareMessageListener {
4

5
    @Override
6
    public void onMessage(Message message, Channel channel) throws Exception {
7
        log.info("message:{}", message.getBody());
8
        //todo: 接下来就是各自的业务逻辑，就是消费环节
9
    }
10
}

Bootstrap Table使用教程：数据表格实战

Thu, 10 Aug 2023 00:00:00 GMT

📝 本文基于作者实际开发经验，已在项目中成功使用 Bootstrap Table 实现数据表格展示。

最近项目中要展示一个表格，就使用了bootstrap的表格，听说巨好用，但是还是碰到了些坑。

1.html编写#

html比较简单，主要就是引入bootstrap的样式和jquery。jquery是为了表格加载直接请求后端接口。

1
<!DOCTYPE html>
2
<html lang="en">
3
<head>
4
    <!-- 引入bootstrap样式 -->
5
    <link href="https://cdn.bootcss.com/bootstrap/3.3.6/css/bootstrap.min.css" rel="stylesheet">
6
    <!-- 引入bootstrap-table样式 -->
7
    <link href="https://cdn.bootcss.com/bootstrap-table/1.11.1/bootstrap-table.min.css" rel="stylesheet">
8

9
    <!-- jquery -->
10
    <script src="https://cdn.bootcss.com/jquery/2.2.3/jquery.min.js"></script>
11
    <script src="https://cdn.bootcss.com/bootstrap/3.3.6/js/bootstrap.min.js"></script>
12

13
    <!-- bootstrap-table.min.js -->
14
    <script src="https://cdn.bootcss.com/bootstrap-table/1.11.1/bootstrap-table.min.js"></script>
15
    <!-- 引入中文语言包 -->
16
    <script src="https://cdn.bootcss.com/bootstrap-table/1.11.1/locale/bootstrap-table-zh-CN.min.js"></script>
17

18
    <meta charset="UTF-8">
19
    <title>测试</title>
20
</head>
21
<body>
22
<table id="myTable" class="table table-hover text-nowrap"></table>
23
</body>
24
</html>

展开收起

2.Js编写#

js的编写主要就是注意url表示你后端的请求额接口，method请求方法。

responseHandler：因为获取到的数据可能是json，包含记录和一些提示，所以这个函数可以对其进行处理，获得最终记录和列对应。

responseHandler处理JSON数据的函数

columns：里面包含的就是初始化表格的列，field对应的是你返回记录的属性，title就是初始化列你取的名字。

columns列配置中field和title对应关系

Bootstrap Table展示效果

1
$(function () {
2
        $('#myTable').bootstrapTable({
3
            method: 'get',  //以post的方式发送请求
4
            url: '/testList',    //url地址，可以是接口也可以是本地json文件
5
            striped: true, // 是否显示行间隔色
6
            pageNumber: 1, // 初始化加载第一页
7
            pagination: true, // 是否分页
8
            sortable: true,  //是否可排序
9
            search: true,    //是否可查询
10
            showColumns: true, //筛选要显示的列
11
            showSearchClearButton: true, //显示搜索清除按钮
12
            pageSize: 10, // 默认单页记录数
13
            pageList: [10, 15, 20],   //分页可选页数
14
            sidePagination: "client", //表示客户端请求
15
            clickToSelect: true,                //是否启用点击选中行
16
            //height: 500,                      //行高，如果没有设置height属性，表格自动根据记录条数觉得表格高度
17
            uniqueId: "id",                     //每一行的唯一标识，一般为主键列
18
            showToggle: true,                   //是否显示详细视图和列表视图的切换按钮
19
            cardView: false,                    //是否显示详细视图
20
            detailView: false,                  //是否显示父子表
21
            onLoadSuccess: function () { //加载成功时执行
22
                debugger;
23
                console.log("加载成功");
24
            },
25
            onLoadError: function () { //加载失败时执行
26
                debugger;
27
                console.error("加载数据失败");
28
            },
29
            responseHandler: function (res) {
30
                //在ajax获取到数据，渲染表格之前，修改数据源
31
                //该项返回的为数据源内的二级列表data
32
                if (res.code == "200") {
33
                    return res.rows;
34
                } else {
35
                    //显示报错信息
36
                    console.error(res);
37
                }
38
            },
39

40
            paginationLoop: true,   //换页按钮设置
41
            paginationHAlign: 'left',
42
            paginationDetailHAlign: 'right',
43
            paginationPreText: '上一页',
44
            paginationNextText: '下一页',
45
            columns: [{
46
                checkbox: true  //左侧复选框，用于多选操作
47
            }, {
48
                title: 'ID',
49
                field: 'id',
50
                visible: false,
51
                align: 'center',
52
                valign: 'middle',
53
                sortable: true
54
            },
55
                {
56
                    title: '序号',
57
                    visible: true,
58
                    align: 'center',
59
                    valign: 'middle',
60
                    width: '50px',
61
                    formatter: function (value, row, index) {
62
                        return index + 1;
63
                    }
64
                },
65
                {
66
                    title: '关键词',
67
                    field: 'keywords',
68
                    visible: true,
69
                    align: 'center',
70
                    valign: 'middle',
71
                    sortable: false,
72
                    width: '160px'
73
                },
74
                {
75
                    title: '新闻标题',
76
                    field: 'newsTitle',
77
                    visible: true,
78
                    align: 'center',
79
                    valign: 'middle',
80
                    sortable: false,
81
                    width: '160px'
82
                },
83
                {
84
                    title: '新闻作者',
85
                    field: 'author',
86
                    visible: true,
87
                    align: 'center',
88
                    valign: 'middle',
89
                    sortable: false,
90
                    width: '160px'
91
                },
92
                {
93
                    title: '创建时间',
94
                    field: 'createDatetime',
95
                    visible: true,
96
                    align: 'center',
97
                    valign: 'middle',
98
                    sortable: false,
99
                    width: '160px'
100
                }
101
            ]
102
        });
103
    });

展开收起

3.后端java的编写#

这里我是一个类型于新闻的类的列表返回，就是数据库查询多条记录，然后使用map返回数据。碰到了个坑，没有加@ResponseBody的时候显示加载失败。

PS:@ResponseBody是作用在方法上的，@ResponseBody 表示该方法的返回结果直接写入 HTTP response body 中，一般在异步获取数据时使用【也就是AJAX】，这里bootstrap用的就是ajax。

1
import com.website.company.entity.News;
2
import com.website.company.service.NewsService;
3
import org.springframework.beans.factory.annotation.Autowired;
4
import org.springframework.stereotype.Controller;
5
import org.springframework.web.bind.annotation.RequestMapping;
6
import org.springframework.web.bind.annotation.ResponseBody;
7

8
import java.util.HashMap;
9
import java.util.List;
10
import java.util.Map;
11

12
/**
13
 * 类描述：测试类
14
 *
15
 * @ClassName TestController
16
 * @Author ward
17
 * @Date 2022-06-27 10:49
18
 */
19
@Controller
20
public class TestController {
21
    @Autowired
22
    NewsService newsService;
23

24
    @RequestMapping("/testList")
25
    @ResponseBody
26
    public Object testList() {
27
        List<News> datalist = newsService.allNews();
28
        Map map = new HashMap();
29
        map.put("code", "200");
30
        map.put("total", datalist.size());
31
        map.put("rows", datalist);
32
        return map;
33

34
    }
35
}

展开收起

番外#

在把date格式传回前端给bootstrap的table时只剩下年月日了，前端暂时没有处理办法。所以就在后端进行了处理：增加属性把时间格式转为String，并表示当前属性不是数据库的字段。代码如下：

1
@TableField("CREATE_TIME")
2
private Date createTime;
3

4
@TableField(exist = false)
5
protected String createTimeStr;
6

7
public String getCreateTimeStr() {
8
  SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
9
  return sdf.format(createTime);
10
}
11

12
public void setCreateTimeStr(String createTimeStr) {
13
  this.createTimeStr = createTimeStr;
14
}

SpringBoot配置文件全局变量：多环境部署秘钥管理

Thu, 20 Jul 2023 00:00:00 GMT

📝 本文基于作者实际项目经验，已在多个客户部署场景中使用全局变量配置，实现一套代码多环境运行。

这篇文章介绍的是一个jar给不同的客户部署需要改变某些秘钥的值时，可以采用application的全局变量来配置，避免多次打包的繁琐。

第一种方式直接在application.yml里写

1
test:
2
  niuBi: 芦苇
3
  ceShi: 测试

使用的时候在类里面加上

1
@Value("${test.niuBi}")
2
    private String niuBi;
3
@Value("${test.ceShi}")
4
    private String ceShi;

然后就可以直接当做普通变量使用，配置文件里修改，相应也会进行更改。

第二种方式 ①跟第一种一样在application.yml写入

1
test:
2
  niuBi: 芦苇
3
  ceShi: 测试

②写一个类，加上注解。

1
@Component
2
@ConfigurationProperties(prefix = TestProperties.PREFIX)
3
public class TestProperties {
4
    public static final String PREFIX = "test";//这里注意前缀一律小写，这是规范
5
    private String niuBi;
6
    private String ceShi;
7

8
    public static String getPREFIX() {
9
        return PREFIX;
10
    }
11

12
    public String getNiuBi() {
13
        return niuBi;
14
    }
15

16
    public void setNiuBi(String niuBi) {
17
        this.niuBi = niuBi;
18
    }
19

20
    public String getCeShi() {
21
        return ceShi;
22
    }
23

24
    public void setCeShi(String ceShi) {
25
        this.ceShi = ceShi;
26
    }
27
}

展开收起

③使用：在要使用的接口里，注入配置类，然后通过get去调用

1
@Autowired
2
TestProperties test;
3

4
test.getNiuBi();
5
test.getCeShi();

第二种方式相较于第一种，不用每个属性写一个，直接注入类，一劳永逸，推荐使用！！！

React系统学习：从基础语法到虚拟DOM

Thu, 01 Jun 2023 00:00:00 GMT

📝 本文基于作者学习笔记，系统整理了 React 基础知识，适合前端开发者入门参考。

react是facebook开源的，为什么高效的原因，是因为使用了虚拟dom技术，可以很大程度的复用。

1.基本语法#

helloWorld，babel的引入是为了将jsx转换为js，使用jsx可以更快的创建虚拟dom。

1
<!DOCTYPE html>
2
<html lang="en">
3

4
<head>
5
    <meta charset="UTF-8">
6
    <title>hello_react</title>
7
</head>
8

9
<body>
10
    <div id="test"></div>
11
    <!-- 先引入核心库、扩展库、babel库 -->
12
    <script type="text/javascript" src="../js/react.development.js"></script>
13
    <script type="text/javascript" src="../js/react-dom.development.js"></script>
14
    <script type="text/javascript" src="../js/babel.min.js"></script>
15
    <script type="text/babel">
16
        const VDOM = <h1>hello,React</h1>
17
        ReactDOM.render(VDOM,document.getElementById('test')) /*此处不写引号，不是字符串*/
18
    </script>
19
</body>
20

21
</html>

展开收起

JSX的基本语法：

定义虚拟DOM时，不要写引号
标签中混入JS表达式要用{}，注意用const xxx=可以接收的才叫表达式
样式的类名指定不要用class，要用className
内联样式，要用style={{key}}形式
只有一个根标签
标签必须闭合
标签首字母：（1）若小写字母开头，则把标签转化为html同名元素，若没有对应同名元素则报错（2）若大写字母开头，react就去渲染对应的组件，若组件没有定义则报错。

1
<!DOCTYPE html>
2
<html lang="en">
3

4
<head>
5
    <meta charset="UTF-8">
6
    <title>hello_react</title>
7
</head>
8
<style>
9
    .title {
10
        font-size: large;
11
        color: blue;
12
    }
13
</style>
14

15
<body>
16
    <div id="test"></div>
17
    <!-- 先引入核心库、扩展库、babel库 -->
18
    <script type="text/javascript" src="../js/react.development.js"></script>
19
    <script type="text/javascript" src="../js/react-dom.development.js"></script>
20
    <script type="text/javascript" src="../js/babel.min.js"></script>
21
    <script type="text/babel">
22
        const title = 'title'
23
        const VDOM = (
24
            <div>
25
                <h1 className={title} style={{ color: 'red' }}>
26
                    <span>hello,React</span>
27
                </h1>
28
                <Good></Good>
29
            </div>
30

31
        )
32
        ReactDOM.render(VDOM, document.getElementById('test')) /*此处不写引号，不是字符串*/
33
    </script>
34
</body>
35

36
</html>

展开收起

2.面向组件编程#

js的模块化只是拆分html，而组件编程则是html、css、js、img、video等整合起来是一个组件，优点是复用编码，提高效率。

2.1函数式组件#

1
<!DOCTYPE html>
2
<html lang="en">
3
  <head>
4
    <meta charset="UTF-8" />
5
    <title>hello_react</title>
6
  </head>
7
  <style>
8
    .title {
9
      font-size: large;
10
      color: blue;
11
    }
12
  </style>
13

14
  <body>
15
    <div id="test"></div>
16
    <!-- 先引入核心库、扩展库、babel库 -->
17
    <script type="text/javascript" src="../js/react.development.js"></script>
18
    <script
19
      type="text/javascript"
20
      src="../js/react-dom.development.js"
21
    ></script>
22
    <script type="text/javascript" src="../js/babel.min.js"></script>
23
    <script type="text/babel">
24
      function Demo() {
25
        return <h1>我是一个函数式组件（适用于简单的自定义）</h1>;
26
      }
27
      ReactDOM.render(<Demo />, document.getElementById("test"));
28
    </script>
29
  </body>
30
</html>

展开收起

2.2类式组件#

2.2.1类的初识#

1
<!DOCTYPE html>
2
<html lang="en">
3
  <head>
4
    <meta charset="UTF-8" />
5
    <title>hello_react</title>
6
  </head>
7
  <style>
8
    .title {
9
      font-size: large;
10
      color: blue;
11
    }
12
  </style>
13

14
  <body>
15
    <div id="test"></div>
16
    <!-- 先引入核心库、扩展库、babel库 -->
17
    <script type="text/javascript" src="../js/react.development.js"></script>
18
    <script
19
      type="text/javascript"
20
      src="../js/react-dom.development.js"
21
    ></script>
22
    <script type="text/javascript" src="../js/babel.min.js"></script>
23
    <script type="text/babel">
24
      // 创建一个Person类
25
      class Perseon {
26
        // 构造器方法
27
        constructor(name, age) {
28
          this.name = name;
29
          this.age = age;
30
        }
31
        // 一般方法
32
        speak() {
33
          // speak方法在类的原型对象上，供实例使用
34
          // 通过Person实例调用speak时,speak中的this就是Person实例
35
          console.log(`我叫${this.name},我已经${this.age}了`);
36
        }
37
      }
38

39
      class Student extends Perseon {
40
        constructor(name, age, grade) {
41
          // 子类使用构造器一定要使用super且必须在前面
42
          super(name, age);
43
          this.grade = grade;
44
        }
45
        // 重写父类继承的方法
46
        speak(name,age,grade){
47
          console.log(`我叫${this.name},我已经${this.age}了,在读${this.grade}`);
48
        }
49
      }
50
      const mm = new Perseon("小满", 10);
51
      console.log(mm);
52
      mm.speak();
53
      //   call可以更改函数里的this指向
54
      mm.speak.call({ name: "didi", age: 8 });
55

56
      const ls = new Student("李四", "18", "大一");
57
      ls.speak();
58
    </script>
59
  </body>
60
</html>

展开收起

2.2.2使用#

React解析组件标签时，发现组件是使用类定义的，会new出该类实例，并通过该实例调用到原型上的render

1
<!DOCTYPE html>
2
<html lang="en">
3
  <head>
4
    <meta charset="UTF-8" />
5
    <title>hello_react</title>
6
  </head>
7
  <style>
8
    .title {
9
      font-size: large;
10
      color: blue;
11
    }
12
  </style>
13

14
  <body>
15
    <div id="test"></div>
16
    <!-- 先引入核心库、扩展库、babel库 -->
17
    <script type="text/javascript" src="../js/react.development.js"></script>
18
    <script
19
      type="text/javascript"
20
      src="../js/react-dom.development.js"
21
    ></script>
22
    <script type="text/javascript" src="../js/babel.min.js"></script>
23
    <script type="text/babel">
24
      class MyComponent extends React.Component{
25
        render(){
26
            return '我是一个类式组件'
27
        }
28
      }
29

30
      ReactDOM.render(<MyComponent/>,document.getElementById('test'))
31
    </script>
32
  </body>
33
</html>

展开收起

3.State状态#

借助构造器初始化状态并使用，通过点击事件修改状态。

3.1标准写法（强制绑定）#

下面是标准写法，借助构造器的this对state进行初始化

1
<!DOCTYPE html>
2
<html lang="en">
3
  <head>
4
    <meta charset="UTF-8" />
5
    <title>hello_react</title>
6
  </head>
7
  <style>
8
    .title {
9
      font-size: large;
10
      color: blue;
11
    }
12
  </style>
13

14
  <body>
15
    <div id="test"></div>
16
    <!-- 先引入核心库、扩展库、babel库 -->
17
    <script type="text/javascript" src="../js/react.development.js"></script>
18
    <script
19
      type="text/javascript"
20
      src="../js/react-dom.development.js"
21
    ></script>
22
    <script type="text/javascript" src="../js/babel.min.js"></script>
23
    <script type="text/babel">
24
      class Weather extends React.Component {
25
        constructor(props) {
26
          super(props);
27
          //   初始化状态
28
          this.state = { isHot: true, wind: "微风" };
29
          //   解决changeWeather中指向问题
30
          this.changeWeather = this.changeWeather.bind(this);
31
        }
32
        render() {
33
          const { isHot, wind } = this.state;
34
          return (
35
            <h1 onClick={this.changeWeather}>
36
              今天天气{isHot ? "炎热" : "凉爽"}，{wind}
37
            </h1>
38
          );
39
        }
40

41
        changeWeather() {
42
          const isHot = this.state.isHot;
43
          this.setState({ isHot: !isHot });
44
          console.log("修改天气：", this.state.isHot);
45
        }
46
      }
47

48
      ReactDOM.render(<Weather />, document.getElementById("test"));
49
    </script>
50
  </body>
51
</html>

展开收起

React State状态示例：天气炎热与凉爽切换

点击切换State状态后的效果

3.2简化写法（箭头函数）#

1
<!DOCTYPE html>
2
<html lang="en">
3
  <head>
4
    <meta charset="UTF-8" />
5
    <title>hello_react</title>
6
  </head>
7
  <style>
8
    .title {
9
      font-size: large;
10
      color: blue;
11
    }
12
  </style>
13

14
  <body>
15
    <div id="test"></div>
16
    <!-- 先引入核心库、扩展库、babel库 -->
17
    <script type="text/javascript" src="../js/react.development.js"></script>
18
    <script
19
      type="text/javascript"
20
      src="../js/react-dom.development.js"
21
    ></script>
22
    <script type="text/javascript" src="../js/babel.min.js"></script>
23
    <script type="text/babel">
24
      class Weather extends React.Component {
25
        // 自定义状态
26
        state = { isHot: true, wind: "微风" };
27
        render() {
28
          const { isHot, wind } = this.state;
29
          return (
30
            <h1 onClick={this.changeWeather}>
31
              今天天气{isHot ? "炎热" : "凉爽"}，{wind}
32
            </h1>
33
          );
34
        }
35

36
        // 自定义方法——用赋值语句+箭头函数的形式
37
        changeWeather = () => {
38
          console.log(this);
39
          const isHot = this.state.isHot;
40
          this.setState({ isHot: !isHot });
41
          console.log("修改天气：", this.state.isHot);
42
        };
43
      }
44

45
      ReactDOM.render(<Weather />, document.getElementById("test"));
46
    </script>
47
  </body>
48
</html>

展开收起

4.props多种属性#

三点运算符…表示展开，是对于一个数组。

4.1基本使用#

1
{...Person}在原生es6语法中，表示克隆一个对象
2
{...Person,name:'jack'}表示克隆一个对象并替换

1
<!DOCTYPE html>
2
<html lang="en">
3
  <head>
4
    <meta charset="UTF-8" />
5
    <title>hello_react</title>
6
  </head>
7
  <body>
8
    <div id="test1"></div>
9
    <div id="test2"></div>
10
    <div id="test3"></div>
11
    <!-- 先引入核心库、扩展库、babel库 -->
12
    <script type="text/javascript" src="../js/react.development.js"></script>
13
    <script
14
      type="text/javascript"
15
      src="../js/react-dom.development.js"
16
    ></script>
17
    <script type="text/javascript" src="../js/babel.min.js"></script>
18
    <script type="text/babel">
19
      class Weather extends React.Component {
20
        render() {
21
          const { area, day, weather } = this.props;
22
          return (
23
            <ul>
24
              <li>{area}</li>
25
              <li>{day}</li>
26
              <li>{weather}</li>
27
            </ul>
28
          );
29
        }
30
      }
31

32
      const p = { area: "福州", day: "11月25日", weather: "晴" };
33
    //这里不是表示克隆而是展开p，因为react+babel，原生会报错，而且只有标签属性可以
34
      ReactDOM.render(<Weather {...p} />, document.getElementById("test1"));
35

36
      ReactDOM.render(
37
        <Weather area="泉州" day="11月25日" weather="阴" />,
38
        document.getElementById("test2")
39
      );
40

41
      ReactDOM.render(
42
        <Weather area="厦门" day="11月25日" weather="大风" />,
43
        document.getElementById("test3")
44
      );
45
    </script>
46
  </body>
47
</html>

展开收起

4.2标签属性限制#

1
      Person.propTypes = {
2
        name: PropTypes.string.isRequired,//限制name必传，且为字符串
3
        sex: PropTypes.string,//限制sex为字符串
4
        age: PropTypes.number,//限制age为数值
5
        speak:PropTypes.func//限制speak为函数
6
      };
7

8
      Person.defaultProps = {
9
        sex: "保密",//sex默认值保密
10
      };

4.3简写#

1
      class Person extends React.Component {
2
        static propTypes = {
3
          name: PropTypes.string.isRequired, //限制name必传，且为字符串
4
          sex: PropTypes.string, //限制sex为字符串
5
          age: PropTypes.number, //限制age为数值
6
          speak: PropTypes.func, //限制speak为函数
7
        };
8

9
        static defaultProps = {
10
          sex: "保密", //sex默认值保密
11
        };
12
        render() {
13
          const { name, sex, age } = this.props;
14
          return (
15
            <ul>
16
              <li>{name}</li>
17
              <li>{sex}</li>
18
              <li>{age + 1}</li>
19
            </ul>
20
          );
21
        }
22
      }

展开收起

5.refs#

在 React 中，refs 是用来访问和操作 DOM 元素或组件实例的一种方式。通过 refs，开发者可以直接与 DOM 进行交互，而无需依赖 React 的状态管理和生命周期方法。

5.1字符串形式#

1
 class Demo extends React.Component {
2
        showData = () => {
3
          console.log(this);
4
          const {input1} = this.refs
5
          console.log(input1.value);
6
        };
7
        render() {
8
          return (
9
            <div>
10
              <input ref="input1" type="text" placeholder="点击按钮提示数据" />
11
              &nbsp;
12
              <button onClick={this.showData}>获取数据</button>&nbsp;
13
              <input id="input2" placeholder="失去焦点提示数据" />
14
            </div>
15
          );
16
        }
17
      }
18

19
      ReactDOM.render(<Demo />, document.getElementById("test1"));

展开收起

5.2回调函数形式#

1
<script type="text/babel">
2
      class Demo extends React.Component {
3
        showData = () => {
4
          const { input1 } = this.refs;
5
          console.log(this.input1.value);
6
        };
7
        render() {
8
          return (
9
            <div>
10
              <input
11
                ref={(c) => (this.input1 = c)}
12
                type="text"
13
                placeholder="点击按钮提示数据"
14
              />
15
              &nbsp;
16
              <button onClick={this.showData}>获取数据</button>&nbsp;
17
            </div>
18
          );
19
        }
20
      }
21
      ReactDOM.render(<Demo />, document.getElementById("test1"));
22
</script>

展开收起

5.3createRef形式#

1
 myRef1 = React.createRef();
2

3
<input
4
  ref={this.myRef1}
5
  type="text"
6
  placeholder="点击按钮提示数据"
7
/>

1
<script type="text/babel">
2
      class Demo extends React.Component {
3
        state = { isHot: true };
4
        myRef1 = React.createRef();
5
        myRef2 = React.createRef();
6

7
        showData = () => {
8
          console.log(this.myRef1.current.value);
9
        };
10

11
        showData2 = () => {
12
          alert(this.myRef2.current.value);
13
        };
14

15
        changeWeather = () => {
16
          const { isHot } = this.state;
17
          this.setState({ isHot: !isHot });
18
        };
19
        render() {
20
          const { isHot } = this.state;
21

22
          return (
23
            <div>
24
              <h1>今天天气很{isHot ? "炎热" : "凉爽"}</h1>
25
              <input
26
                ref={this.myRef1}
27
                type="text"
28
                placeholder="点击按钮提示数据"
29
              />
30
              &nbsp;
31
              <button onClick={this.showData}>获取数据</button>
32
              &nbsp;
33
              <button onClick={this.changeWeather}>点击切换天气</button>&nbsp;
34
              <input
35
                onBlur={this.showData2}
36
                ref={this.myRef2}
37
                type="text"
38
                placeholder="失去焦点提示数据"
39
              />
40
              &nbsp;
41
            </div>
42
          );
43
        }
44
      }
45
      ReactDOM.render(<Demo />, document.getElementById("test1"));
46
    </script>

展开收起

6.react中的事件处理#

不要过度使用ref，如果发生事件的元素就是你要操作的元素的时候就可以不适用ref。

1
//使用ref的版本
2
showData2 = () => {
3
  alert(this.myRef2.current.value);
4
};
5

6
<input nBlur={this.showData2}
7
       ref={this.myRef2}
8
       type="text"
9
       placeholder="失去焦点提示数据"
10
/>
11

12
//不使用ref的版本
13
showData2 = (event) => {
14
  alert(event.target.value);
15
};
16

17
<input nBlur={this.showData2}
18
       type="text"
19
       placeholder="失去焦点提示数据"
20
/>

展开收起

7.react中收集表单数据#

优先使用受控组件，因为使用非受控组件需要使用ref

7.1非受控组件#

现用现取属于非受控

1
<!DOCTYPE html>
2
<html lang="en">
3
  <head>
4
    <meta charset="UTF-8" />
5
    <title>hello_react</title>
6
  </head>
7
  <body>
8
    <div id="test1"></div>
9
    <div id="test2"></div>
10
    <div id="test3"></div>
11
    <!-- 先引入核心库、扩展库、babel库 -->
12
    <script type="text/javascript" src="../js/react.development.js"></script>
13
    <script
14
      type="text/javascript"
15
      src="../js/react-dom.development.js"
16
    ></script>
17
    <script type="text/javascript" src="../js/babel.min.js"></script>
18
    <script type="text/javascript" src="../js/prop-types.js"></script>
19
    <script type="text/babel">
20
      class Login extends React.Component {
21
        handleSubmit = (event) => {
22
          event.preventDefault();
23
          const { username, password } = this;
24
          alert(`你输入的用户名是${username.value}，密码是${password.value}`);
25
        };
26
        render() {
27
          return (
28
            <form action="http://www.baidu.com" onSubmit={this.handleSubmit}>
29
              用户名：
30
              <input
31
                type="text"
32
                ref={(c) => (this.username = c)}
33
                name="username"
34
              />
35
              密码：
36
              <input
37
                type="password"
38
                ref={(c) => (this.password = c)}
39
                name="password"
40
              />
41
              <button>登陆</button>
42
            </form>
43
          );
44
        }
45
      }
46
      ReactDOM.render(<Login />, document.getElementById("test1"));
47
    </script>
48
  </body>
49
</html>

展开收起

7.2受控组件#

页面中所有输入类的dom，随着输入可以维护到状态中，需要使用的时候通过状态中读取。

1
<!DOCTYPE html>
2
<html lang="en">
3
  <head>
4
    <meta charset="UTF-8" />
5
    <title>hello_react</title>
6
  </head>
7
  <body>
8
    <div id="test1"></div>
9
    <div id="test2"></div>
10
    <div id="test3"></div>
11
    <!-- 先引入核心库、扩展库、babel库 -->
12
    <script type="text/javascript" src="../js/react.development.js"></script>
13
    <script
14
      type="text/javascript"
15
      src="../js/react-dom.development.js"
16
    ></script>
17
    <script type="text/javascript" src="../js/babel.min.js"></script>
18
    <script type="text/javascript" src="../js/prop-types.js"></script>
19
    <script type="text/babel">
20
      class Login extends React.Component {
21
        // 初始化状态
22
        state = {
23
          username: "", //用户名
24
          password: "", //密码
25
        };
26
        handleSubmit = (event) => {
27
          event.preventDefault(); //阻止表单提交
28
          const { username, password } = this.state;
29
          alert(`你输入的用户名是${username}，密码是${password}`);
30
        };
31

32
        saveUsername = (event) => {
33
          this.setState({ username: event.target.value });
34
        };
35

36
        savePassword = (event) => {
37
          this.setState({ password: event.target.value });
38
        };
39

40
        render() {
41
          return (
42
            <form onSubmit={this.handleSubmit}>
43
              用户名：
44
              <input type="text" name="username" onChange={this.saveUsername} />
45
              密码：
46
              <input
47
                type="password"
48
                name="password"
49
                onChange={this.savePassword}
50
              />
51
              <button>登陆</button>
52
            </form>
53
          );
54
        }
55
      }
56
      ReactDOM.render(<Login />, document.getElementById("test1"));
57
    </script>
58
  </body>
59
</html>

展开收起

*8.生命周期#

下面是一副生命周期的流程，挂载比较简单就是一直往下走；setState就是先往左再往下；forceUpdate也是先往左再往下

React组件生命周期流程图

初始化阶段：由ReactDOM.render()触发---初次渲染

constructor()
componentWillMount()
render()
componentDidMount() ===> 常用，一般在钩子里做初始化操作，例如：开定时器，发网络请求，订阅消息

更新阶段：由组件内部this.setState()或父组件render触发

shouldComponentUpdate()
componentWillUpdate()
render() ==> 必须使用一个
componentDidUpdate()

卸载组件：由ReactDOM.unmountComponentAtNode()触发

componentWillUnmount ==>常用，一般做收尾动作，例如：关闭定时器取消订阅

1
<!DOCTYPE html>
2
<html lang="en">
3
  <head>
4
    <meta charset="UTF-8" />
5
    <title>生命周期</title>
6
  </head>
7
  <body>
8
    <div id="test"></div>
9
    <!-- 先引入核心库、扩展库、babel库 -->
10
    <script type="text/javascript" src="../js/react.development.js"></script>
11
    <script
12
      type="text/javascript"
13
      src="../js/react-dom.development.js"
14
    ></script>
15
    <script type="text/javascript" src="../js/babel.min.js"></script>
16
    <script type="text/javascript" src="../js/prop-types.js"></script>
17
    <script type="text/babel">
18
      // 创建组件
19
      // 生命周期回调函数<==>生命周期钩子函数<==>生命周期钩子<==>生命周期函数
20
      class Count extends React.Component {
21
        // 构造器
22
        constructor(props) {
23
          console.log("Count---constructor");
24
          super(props);
25
          this.state = { count: 0 };
26
        }
27

28
        add = () => {
29
          const { count } = this.state;
30
          this.setState({ count: count + 1 });
31
        };
32

33
        // 卸载组件按钮回调
34
        death = () => {
35
          ReactDOM.unmountComponentAtNode(document.getElementById("test"));
36
        };
37

38
        force = () => {
39
          this.forceUpdate();
40
        };
41
        // 组件将要挂载的钩子
42
        componentWillMount() {
43
          console.log("Count---componentWillMount");
44
        }
45

46
        // 组件挂载完毕的钩子
47
        componentDidMount() {
48
          console.log("Count---componentDidMount");
49
        }
50

51
        // 组件将要卸载的钩子
52
        componentWillUnmount() {
53
          console.log("Count---componentWillUnmount");
54
        }
55

56
        // 控制组件更新的“阀门”
57
        shouldComponentUpdate() {
58
          console.log("Count---shouldComponentUpdate");
59
          return true;
60
        }
61

62
        // 组件将要更新的钩子
63
        componentWillUpdate() {
64
          console.log("Count---componentWillUpdate");
65
        }
66

67
        // 组件更新完毕的钩子
68
        componentDidUpdate() {
69
          console.log("Count---componentDidUpdate");
70
        }
71

72
        render() {
73
          console.log("render");
74
          const { count } = this.state;
75
          return (
76
            <div>
77
              <h2>当前求和为:{count}</h2>
78
              <button onClick={this.add}>点我加1</button>
79
              <button onClick={this.death}>卸载组件</button>
80
              <button onClick={this.force}>不更改任何状态，强制更新</button>
81
            </div>
82
          );
83
        }
84
      }
85

86
      class A extends React.Component {
87
        state = { carName: "奔驰" };
88
        changeCar = () => {
89
          this.setState({ carName: "奥迪" });
90
        };
91
        render() {
92
          return (
93
            <div>
94
              <div>我是组件A</div>
95
              <button onClick={this.changeCar}>换车</button>
96
              <B carName={this.state.carName} />
97
            </div>
98
          );
99
        }
100
      }
101

102
      class B extends React.Component {
103
        componentWillReceiveProps(props) {
104
          // 这个函数有坑，非首次更新才执行
105
          console.log("B---componentWillReceiveProps");
106
        }
107
        render() {
108
          return (
109
            <div>
110
              <div>我是B组件，接收到的车是{this.props.carName}</div>
111
            </div>
112
          );
113
        }
114
      }
115
      ReactDOM.render(<A />, document.getElementById("test"));
116
    </script>
117
  </body>
118
</html>

展开收起

SSM框架访问静态资源：SpringMVC配置详解

Mon, 15 May 2023 00:00:00 GMT

📝 本文基于作者实际开发经验，解决了 SpringMVC 拦截静态资源导致 CSS/JS 无法加载的问题。

1.配置拦截器，拦截所有请求#

web.xml

1
  <!-- 配置Spring MVC前端核心控制器 -->
2
  <servlet>
3
    <servlet-name>crm</servlet-name>
4
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
5
    <!-- 加载springmvc核心配置文件 -->
6
    <init-param>
7
      <param-name>contextConfigLocation</param-name>
8
      <param-value>classpath:springmvc-config.xml</param-value>
9
    </init-param>
10
    <!-- 配置服务器启动后立即加载Spring MVC配置文件 -->
11
    <load-on-startup>1</load-on-startup>
12
  </servlet>
13

14
  <!-- 配置拦截路径 -->
15
  <servlet-mapping>
16
    <servlet-name>crm</servlet-name>
17
    <url-pattern>/</url-pattern>
18
  </servlet-mapping>

展开收起

2.配置静态资源的访问映射#

springmvc-config.xml

1
<!-- 配置静态文件放行 -->
2
  <mvc:default-servlet-handler />
3
  <!--配置静态资源的访问映射，此配置中的文件，将不被前端控制器拦截 -->
4
  <mvc:resources location="/WEB-INF/static/" mapping="/static/**" />
5
  <mvc:resources location="/WEB-INF/html/" mapping="/html/**" />

3.html访问图片、jq等资源#

HTML中访问图片和jQuery等静态资源的路径配置

Java实现文档视频缩略图：Spire插件实战

Sun, 15 Jan 2023 00:00:00 GMT

📝 本文基于作者实际开发经验，已在项目中成功使用 Spire 插件生成多种格式的缩略图。

背景#

很多业务系统需要展示文档和视频的缩略图——比如文件管理系统的列表预览、审批流程中的附件概览等。Java 生态里处理这个问题主要有两条路：

Apache POI + PDFBox：开源方案，但 Word/PPT 的渲染效果一般，样式兼容性差
Spire 系列：商业组件，API 简洁，渲染效果好，支持 doc/docx/ppt/pptx/pdf

本文使用 Spire 系列（spire.doc、spire.presentation、spire.pdf）来实现 Word、PPT、PDF 的缩略图生成，视频则使用 JavaCV（FFmpeg）截取第一帧。

依赖配置#

Spire 的免费版（Free Spire.Doc/Office/PDF）有页数限制，正式使用建议用商业版。

1
<!-- Spire.Doc -->
2
<dependency>
3
    <groupId>e-iceblue</groupId>
4
    <artifactId>spire.doc.free</artifactId>
5
    <version>5.4.2</version>
6
</dependency>
7

8
<!-- Spire.Presentation -->
9
<dependency>
10
    <groupId>e-iceblue</groupId>
11
    <artifactId>spire.presentation.free</artifactId>
12
    <version>5.4.0</version>
13
</dependency>
14

15
<!-- Spire.Pdf -->
16
<dependency>
17
    <groupId>e-iceblue</groupId>
18
    <artifactId>spire.pdf.free</artifactId>
19
    <version>8.6.0</version>
20
</dependency>
21

22
<!-- JavaCV（视频截帧） -->
23
<dependency>
24
    <groupId>org.bytedeco</groupId>
25
    <artifactId>javacv-platform</artifactId>
26
    <version>1.5.9</version>
27
</dependency>

展开收起

注意：Spire 的 jar 包可能无法通过 Maven 公共仓库直接下载，需要手动配置 e-iceblue 的私有仓库，或直接将 jar 包安装到本地 Maven 仓库。

1. Word 缩略图#

使用 Document.saveToImages() 将第一页渲染为图片，直接写入 PNG 文件。

1
private static String wordToImage(String wordFile, String outputImgPath) throws Exception {
2
    Document word = new Document();
3
    word.loadFromFile(wordFile);
4
    String fileName = getFileName(wordFile);
5
    BufferedImage image = word.saveToImages(0, ImageType.Bitmap);
6
    String imgUrl = outputImgPath + fileName + (0 + 1) + ".png";
7
    File file = new File(imgUrl);
8
    ImageIO.write(image, "PNG", file);
9
    log.info("word缩略图获取完成，图片目录：[{}]", imgUrl);
10
    return imgUrl;
11
}

2. PPT 缩略图#

PPT 取第一页幻灯片，用 saveAsImage() 渲染。注意用完后要调用 dispose() 释放资源。

1
private static String pptToImage(String pptFile, String outputImgPath) throws Exception {
2
    Presentation ppt = new Presentation();
3
    ppt.loadFromFile(pptFile);
4
    String fileName = getFileName(pptFile);
5
    BufferedImage image = ppt.getSlides().get(0).saveAsImage();
6
    String imgUrl = outputImgPath + fileName + (0 + 1) + ".png";
7
    ImageIO.write(image, "PNG", new File(imgUrl));
8
    ppt.dispose();
9
    log.info("ppt缩略图获取完成，图片目录：[{}]", imgUrl);
10
    return imgUrl;
11
}

3. PDF 缩略图#

PDF 同样取第一页，saveAsImage() 的第二个参数指定输出图片类型。

1
private static String pdfToImage(String pdfFile, String outputImgPath) throws Exception {
2
    PdfDocument pdf = new PdfDocument();
3
    pdf.loadFromFile(pdfFile);
4
    String fileName = getFileName(pdfFile);
5
    BufferedImage image = pdf.saveAsImage(0, PdfImageType.Bitmap);
6
    String imgUrl = outputImgPath + fileName + (0 + 1) + ".png";
7
    File file = new File(imgUrl);
8
    ImageIO.write(image, "PNG", file);
9
    log.info("pdf缩略图获取完成，图片目录：[{}]", imgUrl);
10
    return imgUrl;
11
}

4. 视频缩略图#

视频使用 JavaCV 的 FFmpegFrameGrabber 截取第一帧。如果第一帧为空（某些视频编码问题），会返回空字符串。

1
private static String videoImage(String videoFile, String outputImgPath) throws FrameGrabber.Exception {
2
    FFmpegFrameGrabber ff = FFmpegFrameGrabber.createDefault(videoFile);
3
    ff.start();
4
    Frame f = ff.grabImage();
5
    String pngPath = getFileName(videoFile) + ".png";
6
    String resPath = outputImgPath + pngPath;
7
    String imageMat = "PNG";
8
    if (null == f || null == f.image) {
9
        return "";
10
    }
11
    Java2DFrameConverter converter = new Java2DFrameConverter();
12
    BufferedImage bufferedImage = converter.getBufferedImage(f);
13
    File output = new File(resPath);
14
    try {
15
        ImageIO.write(bufferedImage, imageMat, output);
16
    } catch (IOException e) {
17
        e.printStackTrace();
18
    }
19
    log.info("video缩略图获取完成，图片目录：[{}]", resPath);
20
    ff.stop();
21
    return resPath;
22
}

展开收起

5. 通用入口方法#

根据文件后缀自动路由到对应的处理方法：

1
public static String generateThumbnail(String file, String outputImgPath) throws Exception {
2
    if (!outputImgPath.endsWith(File.separator)) {
3
        outputImgPath += File.separator;
4
    }
5
    String filePath = "";
6
    if (file.endsWith("doc") | file.endsWith("docx")) {
7
        filePath = wordToImage(file, outputImgPath);
8
    } else if (file.endsWith("ppt") | file.endsWith("pptx")) {
9
        filePath = pptToImage(file, outputImgPath);
10
    } else if (file.endsWith("pdf")) {
11
        filePath = pdfToImage(file, outputImgPath);
12
    } else if (file.endsWith("mp4")) {
13
        filePath = videoImage(file, outputImgPath);
14
    }
15
    return filePath;
16
}

展开收起

文件名使用时间戳 + 原始文件名的方式避免冲突：

1
private static String getFileName(String filePath) {
2
    String fileName = new File(filePath).getName();
3
    return System.currentTimeMillis() + "-" + fileName.substring(0, fileName.lastIndexOf("."));
4
}

6. Linux 部署踩坑：中文字体缺失#

项目部署到 Linux 后，生成的缩略图里中文字符全部显示为方框或空白。原因是 Linux 默认没有安装中文字体，Spire 渲染时找不到对应的字形。

解决方案：安装中文字体。

Terminal window展开收起

1
# 安装 fontconfig 和 mkfontscale
2
yum install -y fontconfig
3
yum install -y mkfontscale
4

5
# 创建字体目录
6
mkdir -p /usr/share/fonts/chinese/
7
chmod -R 775 /usr/share/fonts/chinese/
8

9
# 将 Windows 字体（C:\Windows\Fonts）打包上传到服务器，解压到上面的目录
10
# 然后执行以下命令刷新字体缓存
11
cd /usr/share/fonts
12
mkfontscale
13
mkfontdir
14
fc-cache -fv
15

16
# 验证中文字体是否生效
17
fc-list :lang=zh

展开收起

安装完成后重启应用，缩略图中的中文就能正常显示了。

完整工具类#

1
import com.spire.doc.Document;
2
import com.spire.doc.documents.ImageType;
3
import com.spire.pdf.PdfDocument;
4
import com.spire.pdf.graphics.PdfImageType;
5
import com.spire.presentation.Presentation;
6
import lombok.extern.slf4j.Slf4j;
7
import org.bytedeco.javacv.FFmpegFrameGrabber;
8
import org.bytedeco.javacv.Frame;
9
import org.bytedeco.javacv.FrameGrabber;
10
import org.bytedeco.javacv.Java2DFrameConverter;
11

12
import javax.imageio.ImageIO;
13
import java.awt.image.BufferedImage;
14
import java.io.File;
15
import java.io.IOException;
16

17
@Slf4j
18
public class ThumbnailUtil {
19

20
    private static String getFileName(String filePath) {
21
        String fileName = new File(filePath).getName();
22
        return System.currentTimeMillis() + "-" + fileName.substring(0, fileName.lastIndexOf("."));
23
    }
24

25
    private static String wordToImage(String wordFile, String outputImgPath) throws Exception {
26
        Document word = new Document();
27
        word.loadFromFile(wordFile);
28
        String fileName = getFileName(wordFile);
29
        BufferedImage image = word.saveToImages(0, ImageType.Bitmap);
30
        String imgUrl = outputImgPath + fileName + (0 + 1) + ".png";
31
        File file = new File(imgUrl);
32
        ImageIO.write(image, "PNG", file);
33
        log.info("word缩略图获取完成，图片目录：[{}]", imgUrl);
34
        return imgUrl;
35
    }
36

37
    private static String pptToImage(String pptFile, String outputImgPath) throws Exception {
38
        Presentation ppt = new Presentation();
39
        ppt.loadFromFile(pptFile);
40
        String fileName = getFileName(pptFile);
41
        BufferedImage image = ppt.getSlides().get(0).saveAsImage();
42
        String imgUrl = outputImgPath + fileName + (0 + 1) + ".png";
43
        ImageIO.write(image, "PNG", new File(imgUrl));
44
        ppt.dispose();
45
        log.info("ppt缩略图获取完成，图片目录：[{}]", imgUrl);
46
        return imgUrl;
47
    }
48

49
    private static String pdfToImage(String pdfFile, String outputImgPath) throws Exception {
50
        PdfDocument pdf = new PdfDocument();
51
        pdf.loadFromFile(pdfFile);
52
        String fileName = getFileName(pdfFile);
53
        BufferedImage image = pdf.saveAsImage(0, PdfImageType.Bitmap);
54
        String imgUrl = outputImgPath + fileName + (0 + 1) + ".png";
55
        File file = new File(imgUrl);
56
        ImageIO.write(image, "PNG", file);
57
        log.info("pdf缩略图获取完成，图片目录：[{}]", imgUrl);
58
        return imgUrl;
59
    }
60

61
    private static String videoImage(String videoFile, String outputImgPath) throws FrameGrabber.Exception {
62
        FFmpegFrameGrabber ff = FFmpegFrameGrabber.createDefault(videoFile);
63
        ff.start();
64
        Frame f = ff.grabImage();
65
        String pngPath = getFileName(videoFile) + ".png";
66
        String resPath = outputImgPath + pngPath;
67
        if (null == f || null == f.image) {
68
            return "";
69
        }
70
        Java2DFrameConverter converter = new Java2DFrameConverter();
71
        BufferedImage bufferedImage = converter.getBufferedImage(f);
72
        File output = new File(resPath);
73
        try {
74
            ImageIO.write(bufferedImage, "PNG", output);
75
        } catch (IOException e) {
76
            e.printStackTrace();
77
        }
78
        log.info("video缩略图获取完成，图片目录：[{}]", resPath);
79
        ff.stop();
80
        return resPath;
81
    }
82

83
    public static String generateThumbnail(String file, String outputImgPath) throws Exception {
84
        if (!outputImgPath.endsWith(File.separator)) {
85
            outputImgPath += File.separator;
86
        }
87
        String filePath = "";
88
        if (file.endsWith("doc") | file.endsWith("docx")) {
89
            filePath = wordToImage(file, outputImgPath);
90
        } else if (file.endsWith("ppt") | file.endsWith("pptx")) {
91
            filePath = pptToImage(file, outputImgPath);
92
        } else if (file.endsWith("pdf")) {
93
            filePath = pdfToImage(file, outputImgPath);
94
        } else if (file.endsWith("mp4")) {
95
            filePath = videoImage(file, outputImgPath);
96
        }
97
        return filePath;
98
    }
99

100
    public static void main(String[] args) throws Exception {
101
        String path = generateThumbnail("D:\\desktop\\test\\video.mp4",
102
                "D:\\desktop\\test\\img");
103
        System.out.println(path);
104
    }
105
}

展开收起

朵朵的技术博客

SSE服务器推送：实时网络传输协议详解与实战

1.客户端基本使用方法#

2.服务器端使用方法#

2.1 HTTP头信息要求#

2.2 数据传输格式#

2.3 核心字段说明#

3.服务端实现#

3.1 简单实现#

3.2 推荐实现#

4.客户端实现#

hook.js 核心逻辑#

踩坑#

相关推荐#

宝塔面板部署项目踩坑记录：PHP/Java/Node.js

1.pbootcms#

1.1部署流程#

疑难杂症#

a.宝塔通过域名访问docker项目#

相关推荐#

Kindle传书完全指南：Calibre管理任意格式电子书

1.epub、mobi、azw3格式#

2.txt#

相关推荐#

KODI打造家庭网络电视库：m3u直播源配置

1.安装软件和插件#

1.改中文#

2.安装直播源插件#

3.设置源#

相关推荐#

Jenkins流水线发布实战：React+SpringBoot全栈部署

1.jenkins必装插件#

2.配置工具#

3.配置令牌#

4.创建项目#

相关推荐#

群晖NAS入门教程：从零开始搭建家庭云盘和影视库

1.安装#

1.1 群晖DSM 7.0.1#

1.1.1 创建虚拟机#

1.1.2 修改虚拟交换机设置#

1.1.3 上传群辉文件#

1.1.4 设置启动选项#

1.1.5 开始安装#

1.2 群晖DSM 6.2.1#

1.3 物理机安装#

2.必备基础配置#

2.1 存储空间配置#

2.1.1 磁盘阵列#

2.1.2 建立存储空间#

2.2 修改IP#

3.增加矿神组件#

4.局域网共享文件夹#

5.共享云盘NextCloud打造#

6.私人影院打造#

6.1 视频文件夹授权#

6.2 Jellyfin媒体服务器#

6.2.1 配置刮削（修改hosts）#

6.2.2 配置刮削（豆瓣）#

6.3 qBittorrent下载器#

6.4 NASTool资源归集整理工具#

7.免费映射公网#

7.1 DDNS-GO（推荐）#

7.2 cpolar#

8.SynologyDrive同步家庭和公司电脑文件#

9.群晖消息通过企业微信机器人通知#

相关推荐#

NAS搭建家庭影视库：Jellyfin+Docker从零开始

1.下载器#

1.1 Transmission#

1.2 qBittorrent#

2.iyuu#

3.媒体播放方案#

3.1 Emby#

3.2 Jellyfin#

4.媒体工具 —— NASTool#

5.jackett#

6.metatube#

ESXi虚拟化软路由：OpenWrt和爱快安装配置全攻略

OpenWrt#