交叉编译一般是指在一个平台上生成另一个平台上的可执行代码，因为有一些目标平台性能很弱，编译需要花费很长的时间，所以需要在性能较高的平台上通过交叉编译来得到目标程序。
在golang和rust中交叉编译都是很容易实现的。

Golang

golang交叉编译一般不需要额外的工具，只需要在golang编译时指定GOOS（操作系统）和GOARCH（CPU架构）即可。
可以使用go tool dist list来查看所有支持的目标平台。
但是如果代码中使用了cgo，那么通常还需要指定一个CC（一般为gcc）来进行编译。
如果目标平台使用glibc库，可以快捷的使用xgo来进行交叉编译。
但是有些目标平台是使用的是musl库，或者是使用其他版本的C库，就需要手动安装交叉编译工具链了。

通过CC指定musl-gcc之后，编译出来的程序就可以在musl库的目标平台下运行了，但是其他版本的C库又不行了，这里要引入一个新的概念，叫做静态编译，即直接将用到的库链接到目标程序中，这样就不在依赖其他的库了。
二进制程序依赖的库可以通过ldd file查看。
在golang中，在ldflags中加入--extldflags '-static -fpic'参数即可开启静态编译，这时使用musl编译出来的二进制文件就可以在所有的目标平台运行了，无论使用的是什么C库。

为什么不直接使用glibc来进行静态编译呢？
直接使用glibc编译出来的二进制文件用ldd查看也是没有依赖的，但是在musl库系统下就是无法运行，我也不知道为什么。

Rust

rust有专门用于交叉编译的库：cross，使用cross build命令直接指定target他就可以工作了。

如果需要手动交叉编译，在rust中进行交叉编译通常比golang中多一步，需要使用rustup target add来添加目标target，同样的所有目标target都可以通过rustup target list来查看。
然后就是和golang一样需要一个gcc，但是有少数时候又不需要，例如在x86_64-unknown-linux-gnu上编译目标平台为x86_64-unknown-linux-musl的hello-world程序就不需要安装额外的musl-gcc，至于为什么这样，我也不知道。
另外Rust可能还需要在.cargo/config中添加一个[target.'x86_64-unknown-linux-gnu'.linker = "xxx"]来指定使用的gcc，编译时也需要加入--target host来指定目标平台。

网上很多文章说需要rustup toolchain install，其实是错误的（我认为）

交叉编译工具链下载

• musl: https://musl.cc/
• gnu: https://gnutoolchains.com/download/
• all: https://toolchains.bootlin.com/

参考

• https://github.com/japaric/rust-cross
• https://blog.hcl.moe/archives/2630

题目描述：

给定整数 n 和 k，返回 [1, n] 中字典序第 k 小的数字。

示例 1:

1
2
3

输入: n = 13, k = 2
输出: 10
解释: 字典序的排列是 [1, 10, 11, 12, 13, 2, 3, 4, 5, 6, 7, 8, 9]，所以第二小的数字是 10。

示例 2:

1
2

输入: n = 1, k = 1
输出: 1

提示:

• 1 <= k <= n <= 109

思路

通过观察字典序的排列可以发现以下规律：

• 以i+1开头的字典序肯定大于以i开头的
• i*10 => 字典序+1
• i+1 => 字典序+(i+1作为前缀的最小值 - i作为前缀的最小值)

要找到在[1,n]中第k小的数字，我们肯定需要从以i作为前缀的开始数，首先需要计算出以i为前缀的个数，以i为前缀的个数即：以i+1为前缀的最小值-以i为前缀的最小值，且这些值都必须小于n。

找到以i为前缀的个数count后，有两种情况：

• k>count，说明以i为前缀的个数不够，还需要继续去找i+1的，k-=count，将i+1；
• k<=count，则说明第k小的数字就是以i开头的，那么通过将i*10将字典序+1，然后重复上面的步骤就可以找出第k小字典序的数字了。

代码

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

impl Solution {
    pub fn find_kth_number(n: i32, k: i32) -> i32 {
        let (mut k, mut cur, n) = ((k - 1) as i64, 1 as i64, n as i64);
        while k > 0 {
            let (mut count, mut first, mut last) = (0, cur, cur + 1);
            while first <= n {
                count += last.min(n + 1) - first;
                first *= 10;
                last *= 10;
            }
            if count <= k {
                cur += 1;
                k -= count;
            } else {
                cur *= 10;
                k -= 1;
            }
        }
        cur as i32
    }
}

题目描述：

给你一个有 n 个服务器的计算机网络，服务器编号为 0 到 n - 1 。同时给你一个二维整数数组 edges ，其中 edges[i] = [ui, vi] 表示服务器 ui 和 vi 之间有一条信息线路，在 一秒 内它们之间可以传输 任意 数目的信息。再给你一个长度为 n 且下标从 0 开始的整数数组 patience 。

题目保证所有服务器都是 相通 的，也就是说一个信息从任意服务器出发，都可以通过这些信息线路直接或间接地到达任何其他服务器。

编号为 0 的服务器是 主 服务器，其他服务器为 数据 服务器。每个数据服务器都要向主服务器发送信息，并等待回复。信息在服务器之间按 最优 线路传输，也就是说每个信息都会以 最少时间 到达主服务器。主服务器会处理 所有 新到达的信息并 立即 按照每条信息来时的路线 反方向 发送回复信息。

在 0 秒的开始，所有数据服务器都会发送各自需要处理的信息。从第 1 秒开始，每 一秒最 开始 时，每个数据服务器都会检查它是否收到了主服务器的回复信息（包括新发出信息的回复信息）：

• 如果还没收到任何回复信息，那么该服务器会周期性 重发 信息。数据服务器 i 每 patience[i] 秒都会重发一条信息，也就是说，数据服务器 i 在上一次发送信息给主服务器后的 patience[i] 秒 后 会重发一条信息给主服务器。
• 否则，该数据服务器 不会重发 信息。

当没有任何信息在线路上传输或者到达某服务器时，该计算机网络变为 空闲 状态。

请返回计算机网络变为 空闲 状态的 最早秒数 。

示例 1：

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

输入：edges = [[0,1],[1,2]], patience = [0,2,1]
输出：8
解释：
0 秒最开始时，
- 数据服务器 1 给主服务器发出信息（用 1A 表示）。
- 数据服务器 2 给主服务器发出信息（用 2A 表示）。

1 秒时，
- 信息 1A 到达主服务器，主服务器立刻处理信息 1A 并发出 1A 的回复信息。
- 数据服务器 1 还没收到任何回复。距离上次发出信息过去了 1 秒（1 < patience[1] = 2），所以不会重发信息。
- 数据服务器 2 还没收到任何回复。距离上次发出信息过去了 1 秒（1 == patience[2] = 1），所以它重发一条信息（用 2B 表示）。

2 秒时，
- 回复信息 1A 到达服务器 1 ，服务器 1 不会再重发信息。
- 信息 2A 到达主服务器，主服务器立刻处理信息 2A 并发出 2A 的回复信息。
- 服务器 2 重发一条信息（用 2C 表示）。
...
4 秒时，
- 回复信息 2A 到达服务器 2 ，服务器 2 不会再重发信息。
...
7 秒时，回复信息 2D 到达服务器 2 。

从第 8 秒开始，不再有任何信息在服务器之间传输，也不再有信息到达服务器。
所以第 8 秒是网络变空闲的最早时刻。

示例 2：

1
2
3
4

输入：edges = [[0,1],[0,2],[1,2]], patience = [0,10,10]
输出：3
解释：数据服务器 1 和 2 第 2 秒初收到回复信息。
从第 3 秒开始，网络变空闲。

提示：

• n == patience.length
• 2 <= n <= 105
• patience[0] == 0
• 对于 1 <= i < n ，满足 1 <= patience[i] <= 105
• 1 <= edges.length <= min(105, n * (n - 1) / 2)
• edges[i].length == 2
• 0 <= ui, vi < n
• ui != vi
• 不会有重边。
• 每个服务器都直接或间接与别的服务器相连。

思路

这里每个服务器最后变的空闲的时间都是相互独立的，所以我们算出每一个服务器接收最后一条消息的时间然后取最大的那一个就行了。

要计算这个的时间，首先肯定是需要计算每个服务器到服务器0的最短距离，这里刚开始使用的是迪杰斯特拉，但是提交之后超时了，然后观察到所有服务器的距离都是1，所以直接BFS就可以得到距离。

然后考虑怎么计算每个服务器的接受到最后一条消息的时间，接受最后一条消息的时间=发出最后一条消息的时间+2*服务器距离+1，所以最后需要计算的是最后一条消息发出的时间，如果距离$距离×2<=发送的间隔时间$的话，那么最后一条消息就是第一条消息，否则：

在停止发消息前，经历了$2×距离-1$的时间，再此期间则会发送$\Big\lfloor\dfrac{2 \times 距离- 1}{\textit{patience}[i]}\Big\rfloor$条消息，那么最后一条消息的时间就是：

$\Big\lfloor\dfrac{2 \times 距离- 1}{patience[i]}\Big\rfloor \times patience[i]$

代码

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

use std::collections::VecDeque;
impl Solution {
    pub fn network_becomes_idle(edges: Vec<Vec<i32>>, patience: Vec<i32>) -> i32 {
        let num_point = patience.len();
        let mut graph = vec![vec![]; num_point];
        edges.iter().for_each(|x| {
            graph[x[0] as usize].push(x[1] as usize);
            graph[x[1] as usize].push(x[0] as usize);
        });
        let mut distance = vec![num_point as i32; num_point];
        let mut visited = vec![false; num_point];
        visited[0] = true;
        distance[0] = 0;
        let mut queue = VecDeque::new();
        queue.push_back(0);
        while !queue.is_empty() {
            let cur = queue.pop_front().unwrap();
            graph[cur].iter().for_each(|&x| {
                if !visited[x] {
                    distance[x] = distance[cur] + 1;
                    visited[x] = true;
                    queue.push_back(x);
                }
            })
        }
        let mut ans = 0;
        for i in 1..num_point {
            ans = ans.max(2 * distance[i] + 1 + if distance[i] * 2 <= patience[i] {
                0
            } else {
                // 计算最后一次消息是什么时候发的
                (2 * distance[i] - 1) / patience[i] * patience[i]
            })
        }
        ans
    }
}

大部分的hexo主题自带的数学公式支持都是使用mathjax，但是这个插件的支持不是很好，有很多的公式无法正常显示。在网上搜索一番后，似乎是因为和markdown语法的冲突，发现很多人都推荐使用hexo-renderer-markdown-it-plus，它使用katex来支持数学公式的渲染但是安装之后又发现另一个问题，公式无法换行，在摸索了很长时间之后，最终发现是katex的版本的问题，然后找到了另一个渲染的库：@upupming/hexo-renderer-markdown-it-plus。现将使用的过程记录如下：

解决方法

首先需要替换默认的markdown渲染器：

1
2

npm un hexo-renderer-marked --save
npm i @upupming/hexo-renderer-markdown-it-plus --save

然后需要引入katex的样式文件，这里要注意官方的文档里用的还是0.9.0的老版本同样不支持换行，所以需要改成0.10.2的版本，这里使用字节的cdn：

1

<link href="https://lf9-cdn-tos.bytecdntp.com/cdn/expire-1-M/KaTeX/0.10.2/katex.min.css" rel="stylesheet">

现在就可以随意的书写数学公式了，比如：

$S(x,y)=\left[l_N(x,y)\right]^{\alpha_N}\prod_{j=1}^{N}\left[c_j(x,y)\right]^{\beta_i}\left[l_N(x,y)\right]^{\gamma_j}$

拓展

这里可能还会有一个问题就是，如果公式很长但是屏幕又很窄，公式就有可能超出屏幕，让主题变得很难看，可以添加一个css来改进这个问题：

1
2
3
4

.katex-display {
  overflow-x: auto;
  overflow-y: clip;
}

题目描述：

给你一个数组 nums，我们可以将它按一个非负整数 k 进行轮调，这样可以使数组变为 [nums[k], nums[k + 1], ... nums[nums.length - 1], nums[0], nums[1], ..., nums[k-1]] 的形式。此后，任何值小于或等于其索引的项都可以记作一分。

• 例如，数组为 nums = [2,4,1,3,0]，我们按 k = 2 进行轮调后，它将变成 [1,3,0,2,4]。这将记为 3 分，因为 1 > 0 [不计分]、3 > 1 [不计分]、0 <= 2 [计 1 分]、2 <= 3 [计 1 分]，4 <= 4 [计 1 分]。

在所有可能的轮调中，返回我们所能得到的最高分数对应的轮调下标 k 。如果有多个答案，返回满足条件的最小的下标 k 。

示例 1：

1
2
3
4
5
6
7
8
9
10

输入：nums = [2,3,1,4,0]
输出：3
解释：
下面列出了每个 k 的得分：
k = 0,  nums = [2,3,1,4,0],    score 2
k = 1,  nums = [3,1,4,0,2],    score 3
k = 2,  nums = [1,4,0,2,3],    score 3
k = 3,  nums = [4,0,2,3,1],    score 4
k = 4,  nums = [0,2,3,1,4],    score 3
所以我们应当选择 k = 3，得分最高。

示例 2：

1
2
3
4
5

输入：nums = [1,3,0,2,4]
输出：0
解释：
nums 无论怎么变化总是有 3 分。
所以我们将选择最小的 k，即 0。

提示：

• 1 <= nums.length <= 10^5
• 0 <= nums[i] < nums.length

思路

首先的思路当然是暴力求解，直接遍历K在0到nums.length这个范围内的所有得分，然后取得分最高的k值（若有多个取较小的k）即可，这样写思路很清晰代码也是比较简单的，但是这道题目的数据量是$10^5$，这样做的时间复杂度是$O(N^2)$，肯定是会超时的，所以需要去优化。

首先我们将问题转化，先求出数组中每个值要取得得分时k的范围，假设下标为i，则需要：

$nums_i \leq (i-k+n)\%n \\0 \leq (i-k+n)\%n \leq n-1 \\\Downarrow \\k \leq (i-nums_i+n)\\%n \\k \leq (i+n)\%n \\k \geq (i+1)\%n$

最终得到k的范围为：

$k \in \left\{\begin{aligned}&\lbrack(i+1)\%n,(i-nums_i+n)\%n\rbrack && (i+1)\%n \leq (i-nums_i+n)\%n \\&\lbrack0,(i-nums_i+n)\%n\rbrack \cup \lbrack(i+1)\%n, n-1\rbrack && (i+1)\%n > (i-nums_i+n)\%n \\\end{aligned}\right.$

我们就可以在$O(n)$的时间内求得每项可以得分的k的区间，这样问题就转换为了求k取多少时落在这些区间里最多（k取较小值）？

然后我们可以这样来求解：先初始化一个长度为n，值为0的数组，然后对于上述的每个区间，将这个数组下标落在区间里的值加一，遍历完之后值最大的那个下标即为得分最高的k值。但是这样做的时间复杂度依然为$O(n^2)$，因为有n+个区间，每个区间的长度的数量级也为n，所以这里需要引入一个算法：差分数组

差分数组

差分数组就是专门对数组的某个区间进行相同的操作，且时间复杂度为$O(1)$的一个算法，他的本质其实是前缀和的逆操作。步骤如下：

首先求对应数组的差分数组：

$a_1,a_2,...a_{n-1},a_n \Rightarrow 0,a_2-a_1,a_3-a_2-a_1,...,a_n-a_{n-1}-a_{n-2}-...-a_1$

就本题来说初始的数组是$[0;n]$，那对应的差分数组仍为$[0;n]$；当我们需要对某个区间进行操作时只需要对端点处进行修改，如对$[a,b]$都+1则只需要

$nums_a+=1 \\ nums_{b+1}-=1$

即对左侧端点进行这个修改，对右侧的右边一个进行逆修改。

然后是差分数组如何还原，进行前缀和运算就行了，因为前缀和是对数组前i项的累加，对左侧端点的修改就影响了后面的所有值，而对右侧端点的右边一个逆修改相当于消除了对之后的影响，于是就变成了对$[a,b]$的操作，且这里所有的操作都是$O(1)$的。

然后使用这种算法再对上面的先初始化一个长度为n，值为0的数组，然后对于上述的每个区间，将这个数组下标落在区间里的值加一，遍历完之后值最大的那个下标即为得分最高的k值问题求解就很简单了。

代码

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

impl Solution {
    pub fn best_rotation(nums: Vec<i32>) -> i32 {
        let n = nums.len();
        let mut diff = vec![0; n+1];
        for i in 0..nums.len() {
            let left = (i+1)%n;
            let right = (i-(nums[i] as usize)+n)%n;
            diff[left]+=1;
            diff[right+1]-=1;
            if left > right {
                diff[0]+=1;
                diff[n]-=1;
            }
        }
        let mut ans = 0;
        let mut tmp = 0;
        let mut sum = 0;
        for k in 0..n {
            sum += diff[k];
            if sum > tmp {
                tmp = sum;
                ans = k;
            }
        }
        ans as i32
    }
}

先看看官方的定义：

A crate is a binary or library. The crate root is a source file that the Rust compiler starts from and makes up the root module of your crate (we’ll explain modules in depth in the “Defining Modules to Control Scope and Privacy” section). A package is one or more crates that provide a set of functionality. A package contains a Cargo.toml file that describes how to build those crates.

crate是rust中的最小编译单元，也就是说rust是按照一个一个的crate来编译的，每个crate都有一个入口文件，可以是下面三种情况：

• src下的main.rs文件
• src下的lib.rs文件（作为一个库）
• src/bin目录下的任意文件（包含main函数）

mod

而mod则更像是C++中的命名空间，以下几种情况都可以作为一个根mod：

• 一个单独的文件为一个mod
• 一个文件夹中包含mod.rs（其他的文件在mod.rs中被声明成子mod）
• 文件夹同级的同名rs文件

mod是可以嵌套的，它是一个树形结构，要想使用mod，则必须在某个入口文件中声明mod（其实rust就是以这个mod名称寻找文件进行了替换），而子mod则可以在它的父mod中进行声明，然后在要使用的地方有以下几种使用方式：

• 在本文件中声明了mod，则可以直接使用这个mod；
• 使用use关键字引入在其他文件中声明的mod；
• 在src/bin目录下要使用同crate下的mod，则需要：在lib.rs中进行声明，然后使用这个crate的名称作为路径来use；
• 在src/main.rs 可以使用上一种方式，但也可以去掉lib.rs而直接在本文件中来声明mod；
• 所有的声明mod在其他文件中被use的话都需要pub导出；
• use只是为了简化路径，也可以直接从根mod一直写下去而不使用use关键字。

示例

文件：

1
2
3
4
5
6
7
8
9
10

├─src
│  │  lib.rs
│  │  main.rs
│  │
│  ├─bin
│  │      test.rs
│  │
│  └─test_mod
│          child.rs
│          mod.rs

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

// test_mod/child.rs
pub fn test(){
    println!("hello,world")
}
// test_mod/mod.rs
pub mod child; // 导出子mod
// lib.rs
pub mod test_mod; // 将本crate声明为一个库
// main.rs
mod test_mod;
fn main() {
    test_mod::child::test();
}
// 或者直接：
fn main() {
    crate_mod::test_mod::child::test()
}
// bin/test.rs
use crate_mod::test_mod::child;
fn main() {
    child::test()
}

安装Alist

直接使用一键脚本就可以，先打开宝塔，然后点击左侧的终端，进入ssh终端，可能会让你输入密码，相信你应该知道自己的密码，然后复制下面的代码粘贴回车运行

1

curl -fsSL "https://nn.ci/alist.sh" | bash -s install

当看到提示关于YOUR_IP:5244消息之后就成功了，注意这里也会输出初始的密码，记得记录下来。

宝塔操作

点击宝塔左侧的网站，新建一个网站相信你已经很熟悉这个操作了，类型选择静态/PHP就可以了。填入你的域名，新建网站完成。

建议先申请一个ssl证书开启https，因为此程序的部分功能需要https支持。

点击设置-配置文件。将默认文件的以下内容删除：

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

#禁止访问的文件或目录
location ~ ^/(\.user.ini|\.htaccess|\.git|\.svn|\.project|LICENSE|README.md)
{
    return 404;
}
location ~ .*\.(gif|jpg|jpeg|png|bmp|swf)$
{
    expires      30d;
    error_log /dev/null;
    access_log /dev/null;
}

location ~ .*\.(js|css)?$
{
    expires      12h;
    error_log /dev/null;
    access_log /dev/null; 
}

然后在你删除的任意地方加入：

1
2
3
4
5
6
7
8
9
10
11

location / {
    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    proxy_set_header Host $http_host;
    proxy_set_header X-Real-IP $remote_addr;
    proxy_set_header Range $http_range;
proxy_set_header If-Range $http_if_range;
    proxy_redirect off;
    proxy_pass http://127.0.0.1:5244;
    # 上传的最大文件尺寸
    client_max_body_size 20000m;
}

保存即可。

完成！打开你新建网站时填入的域名就可以打开了。

本文后续将在https://alist-doc.nn.ci/更新。提问请到https://github.com/Xhofe/alist/discussions
AList是一款支持多种存储的目录文件列表程序，后端基于gin，前端使用react。

https://github.com/ryanhanwu/How-To-Ask-Questions-The-Smart-Way/blob/main/README-zh_CN.md

项目地址

• https://github.com/Xhofe/alist
• https://github.com/Xhofe/alist-web

预览

• https://alist.nn.ci (稳定版本,即Github Release的最新版本)
• https://alist.now.sh (开发版本,随着GitHub提交更新)
  

部署

先打开 https://github.com/Xhofe/alist 点个star😁

手动部署

运行起来

1. 打开AList Release下载要部署的系统对应的文件
2. 解压下载对文件得到可执行文件：tar -zxvf alist-xxxx.tar.gz（Linux）
3. 赋予程序执行权限：chmod +x alist-xxxx
4. 运行程序：./alist-xxxx
5. 完成，后台默认密码为alist

守护进程

vim /usr/lib/systemd/system/alist.service添加以下内容，其中path_alist为alist所在的路径

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

[Unit]
Description=alist
After=network.target

[Service]
Type=simple
WorkingDirectory=path_alist
ExecStart=path_alist/alist-xxxx -conf data/config.json
Restart=on-failure

[Install]
WantedBy=multi-user.target

然后systemctl daemon-reload重载配置，现在你就可以使用这些命令来管理程序了：

• 启动: systemctl start alist
• 关闭: systemctl stop alist
• 自启: systemctl enable alist
• 状态: systemctl status alist
• 重启: systemctl restart alist

使用Docker

• 开发版：docker run -d --restart=always -v /etc/alist:/opt/alist/data -p 5244:5244 --name="alist" xhofe/alist:v2
• 稳定版：docker run -d --restart=always -v /etc/alist:/opt/alist/data -p 5244:5244 --name="alist" xhofe/alist:latest
• 指定版本：具体见https://hub.docker.com/r/xhofe/alist

从源码运行

首先需要有nodejs、yarn、golang>1.17的环境

构建前端

clone https://github.com/Xhofe/alist-web 这个项目，执行yarn&& yarn build，得到dist目录下的目标文件

构建后端

将上一步dist目录下的文件全部拷贝至 https://github.com/Xhofe/alist 项目下的public目录，然后：

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

appName="alist"
builtAt="$(date +'%F %T %z')"
goVersion=$(go version | sed 's/go version //')
gitAuthor=$(git show -s --format='format:%aN <%ae>' HEAD)
gitCommit=$(git log --pretty=format:"%h" -1)
gitTag=$(git describe --long --tags --dirty --always)
ldflags="\
-w -s \
-X 'github.com/Xhofe/alist/conf.BuiltAt=$builtAt' \
-X 'github.com/Xhofe/alist/conf.GoVersion=$goVersion' \
-X 'github.com/Xhofe/alist/conf.GitAuthor=$gitAuthor' \
-X 'github.com/Xhofe/alist/conf.GitCommit=$gitCommit' \
-X 'github.com/Xhofe/alist/conf.GitTag=$gitTag' \
"
go build -ldflags="$ldflags" alist.go

反向代理

程序默认监听5244端口，要实现https访问，需要使用nginx反向代理，在配置文件中加入

1
2
3
4
5
6
7

location / {
    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    proxy_set_header Host $http_host;
    proxy_set_header X-Real-IP $remote_addr;
    proxy_redirect off;
    proxy_pass http://127.0.0.1:5244;
}

使用

后台默认密码为alist

添加账号

所有账号的必填项：

• name（名称）：唯一标识符，也是当有多个账号时展示的路径
• index（索引）：当有多个账号时，用于排序，越小越靠前
• proxy（带理）：是否允许服务器中转下载

本地存储

只需填写根目录路径即可，可以是绝对路径，也可以是程序所在的相对路径

阿里云盘

• refresh_token（刷新令盘）：如何获取参考这个issue通过手机端抓包/查找日志（/data/media/0/Android/data/com.alicloud.databox/files/logs/trace/）来获取,或使用https://media.cooluc.com/decode_token/
• 根目录file_id：打开阿里云盘官网，点进去你要设置的文件夹时url后面的一串，如https://www.aliyundrive.com/drive/folder/5fe01e1830601baf774e4827a9fb8fb2b5bf7940就是5fe01e1830601baf774e4827a9fb8fb2b5bf7940
• order_by（排序）：可选值为name，size，updated_at，created_at
• order_direction（排序方向）：可选ASC（正序），DESC（倒序）

Onedrive

打开https://tool.nn.ci/onedrive/request

创建应用

• 在打开的页面，选择所在区域，点击创建应用
• 登陆后选择「注册应用程序」，输入「名称」，选择「任何组织目录中的账户和个人」（注意这里不要看位置选择而是看文字，部分人可能是中间那个选项，不要选成单一租户或者其他选项，否则会导致登陆时出现问题），输入重定向 URL 为 https://tool.nn.ci/onedrive/callback，「注册」即可，然后可以得到client_id
• 注册好应用程序之后，选择「证书和密码」，点击「新客户端密码」，输入一串密码，选择时间为最长的那个，点击「添加」
  （注：在添加之后输入的密码之后会消失，请记录下来 client_secret 的值）

获取刷新令牌

将上一步骤中获得的client_id和client_secret填入https://tool.nn.ci/onedrive/request 这个页面，点击获取刷新令牌，就可以得到刷新令牌了

获取Sharepoint site_id（未测试）

如果需要挂载Sharepoint，完成上一步后，在显示刷新令牌的界面会出现一个输入站点地址，输入站点地址后点击获取site_id即可。

添加账号

将上述过程中获取得到的值依次填入即可。

天翼云盘

填写账号（手机号），密码即可。可能会触发验证码，可等一段时间再重试。
根目录ID：与阿里云盘类似，官网url最后面一串，如：

• https://cloud.189.cn/web/main/file/folder/-11 -> -11
• https://cloud.189.cn/web/main/file/folder/71398114617385472 -> 71398114617385472

GoogleDrive（支持团队盘）

参照https://install.kenci.workers.dev/ 获取client_id,client_secret,refresh_token；或：

1. Open Google Drive API
2. Create a OAuth client ID
3. Install rclone software locally
4. Get refresh_token with rclone

123Pan

填写账号密码即可。

元信息（meta）设置

此处的path（路径）是访问alist页面时的pathname，如要设置https://alist.nn.ci/本地存储则路径是/本地存储

设置密码

填写密码字段即可

隐藏文件/文件夹

填写hide字段，填写要隐藏的文件（夹）名称，以,分隔，比如要隐藏https://alist.nn.ci/本地存储下的README.md和index.tsx文件，则填写README.md,index.tsx即可。

常见问题

• 向前不兼容版本记录
  v2.0.0-beta5
• 阿里云盘视频无法播放，下载显示InvalidArgument？
  由于referrer的限制，必须使用移动端token
• 视频播放不了？
  然后检查一下是不是编码不支持，一般浏览器不支持h.265（hevc）等编码视频，ac3等编码音频，Safari不支持的更多，建议使用软件播放。
• 获取中转链接？
  允许中转之后，复制对应文件直链，将/d改成/p即可。
• 前端文件在哪里？
  为方便安装，前端文件与程序打包在一起了，如需修改，请按照从源码运行自行修改编译或填写自定义样式/脚本字段。
• 密码忘了怎么半？
  命令行 ./alist-xxxx -password查看。
• 自定义样式/脚本不生效？
  是否前后端分开了？自定义部分为后端处理，只有在不分开时才起作用。
• 上传的文件不显示/删除的文件还在？
  程序缓存一小时自动失效，后台右上角可手动清除缓存。

请我喝杯奶茶

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

#include"utils.h"
#include<iostream>
using namespace std;

void calMinDis()
{
    bool **_map = NULL;
    int **_min_dis;
    int _height = 100;
    int _width = 200;

    _map = new bool*[_height];
    for (size_t i = 0; i < _height; i++)
    {
        _map[i] = new bool[_width];
    }

    printf("cal min dis.\n");
    if (_map == NULL)
    {
        printf("map haven't init.\n");
        return;
    }

    _min_dis = new int *[_height];
    for (size_t i = 0; i < _height; i++)
    {
        _min_dis[i] = new int[_width];
    }
    int MAX_INT = 0xffffffff >> 1;
    for (size_t i = 0; i < _height; i++)
    {
        for (size_t j = 0; j < _width; j++)
        {
            if (_map[i][j])
            {
                _min_dis[i][j] = MAX_INT;
            }
            else
            {
                _min_dis[i][j] = 0;
            }
        }
    }
    for (size_t i = 0; i < _height; i++)
    {
        for (size_t j = 0; j < _width; j++)
        {
            if (!_map[i][j])
            {
                continue;
            }
            if (i > 0 && _min_dis[i - 1][j] < _min_dis[i][j])
            {
                _min_dis[i][j] = _min_dis[i - 1][j] + 1;
            }
            if (j > 0 && _min_dis[i][j - 1] < _min_dis[i][j])
            {
                _min_dis[i][j] = _min_dis[i][j - 1] + 1;
            }
        }
    }
    printf("1\n");
    for (size_t i = _height - 1; i >= 0; i--)
    {
        for (size_t j = _width - 1; j >= 0; j--)
        {
            printf("(%d,%d)\n",i,j);
            if (!_map[i][j])
            {
                continue;
            }
            if (i + 1 < _height && _min_dis[i + 1][j] < _min_dis[i][j])
            {
                _min_dis[i][j] = _min_dis[i + 1][j] + 1;
            }
            if (j + 1 < _width && _min_dis[i][j + 1] < _min_dis[i][j])
            {
                _min_dis[i][j] = _min_dis[i][j + 1] + 1;
            }
        }
    }
    printf("finished cal min dis.\n");
}

int main(int argc, char const *argv[])
{
    calMinDis();
    return 0;
}

这段代码看起来没什么问题，实则隐藏了很大的坑，因为for (size_t i = _height - 1; i >= 0; i--)这个循环中使用了size_t，加上输出之后会发现，循环停不下来，直至出现segmentation fault;
这是因为size_t是一种非负类型，它永远都不可能会小于0,所以循环停不下来。把size_t改成int就没问题了。

此版本不再维护，请使用新版：https://github.com/Xhofe/alist
AList是一款阿里云盘的目录文件列表程序，后端基于golang最好的http框架gin，前端使用vue和ant design。没有专门学过前端，大佬轻喷?

更新计划：https://www.notion.so/AList-993f3a1a43fc464588f018b46369672e，有好的建议可以评论或在issue中告诉我。

本程序仅供学习研究使用！！！发现任何bug请提issue，部署上遇到问题欢迎加群交流。
更新的时候后端和前端文件都需要替换！！！！以及补上配置文件新的配置项！！！！第一次启动需要网页底部rebuild！！！
更新的时候后端和前端文件都需要替换！！！！以及补上配置文件新的配置项！！！！第一次启动需要网页底部rebuild！！！
更新的时候后端和前端文件都需要替换！！！！以及补上配置文件新的配置项！！！！第一次启动需要网页底部rebuild！！！

项目地址：

• https://github.com/Xhofe/alist
• https://github.com/Xhofe/alist-web

快捷部署（by 大白一号）

• 脚本安装：bash -c "$(curl -sS https://www.cooluc.com/alist-install.sh)"
• refresh_token获取：https://media.cooluc.com/decode_token/
• Heroku部署： https://github.com/sbwml/alist-heroku

更新

2021.5.1

• 在线预览视频时间延长到4小时 (#96)
• 指定路径与深度rebuild
• 优化请求：分次请求
• 增加右键菜单
• 支持多选、导出直链/秒传（需要rebuild，借助https://bbs.tampermonkey.net.cn/thread-427-1-1.html）
• 直链编码

2021.3.31

• 优化路径栏
• 修复了因为Referer导致不能下载的问题（122cygf）
• 增加了视频转码选项
• 图片缩略图预览
• 修复了json文件无法预览的bug

2021.3.17

本次更新需要修改配置文件，更新之后/首次运行都需要手动rebuild一下。

• 支持多盘
• 直链url密码哈希
• 修复不需要密码的文件复制直链也会携带密码的bug
• 数据库支持mysql
• 修复从文件返回目录Readme不更新的bug
• 重建目录时遮罩，优化体验
• 支持flv视频（部分浏览器可能不支持，详见https://github.com/Bilibili/flv.js/）

2021.3.13

• 后端引入sqlite3，列表部分不再依赖api，提高响应速度

• 支持搜索功能

• 前端使用vue3+ts重构

• url支持按照目录结果展示

• 音乐播放支持列表

• 支持隐藏文件夹

• 更好的密码支持

• 更早的更新：https://www.nn.ci/archives/alist-v0.html

预览

• https://alist.nn.ci (稳定版本,即Github Release的最新版本)
• https://alist.now.sh (开发版本,随着GitHub提交更新)

如何部署

首先第一步，Star本项目AList(bushi

获取refresh_token

web端token加入了referrer限制，请参考这个issue通过手机端抓包/查找日志（/data/media/0/Android/data/com.alicloud.databox/files/logs/trace/）来获取refresh_token，或使用https://media.cooluc.com/decode_token/。
为什么不直接使用access_token，因为有效期只有两小时。经Syc大佬的提醒，获取refresh_token其实没这么麻烦，我们只需要登陆阿里云盘之后，打开开发者工具，切换到Application选项卡，点开Local storage,会有一个token项，点开就可以看到refresh_token了，此处感谢一下Syc大佬。

部署

使用gin作为静态资源服务器

• 前往AList Release下载对应系统的程序，解压得到一个示例配置文件和一个系统名称文件夹里面包含运行文件alist
• 前往AList-web下载打包好的前端，解压得到一个dist目录放到alist同级目录下
• 在同级目录下新建一个配置文件conf.yml，复制以下内容到该文件中，或直接使用示例配置文件进行修改

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

info:
  title: AList #标题
  logo: "" #网站logo 如果填写,则会替换掉默认的
  footer_text: Xhofe's Blog #网页底部文字
  footer_url: https://www.nn.ci #网页底部文字链接
  music_img: https://img.xhofe.top/2020/12/19/0f8b57866bdb5.gif #预览音乐文件时的图片
  check_update: true #前端是否显示更新
  script: #自定义脚本,可以是脚本的链接，也可以直接是脚本内容
  autoplay: true #视频是否自动播放
  preview:
    text: [txt,htm,html,xml,java,properties,sql,js,md,json,conf,ini,vue,php,py,bat,gitignore,yml,go,sh,c,cpp,h,hpp] #要预览的文本文件的后缀，可以自行添加
server:
  address: "0.0.0.0"
  port: "5244"
  search: true
  download: true
  static: dist
  site_url: '*'
  password: password #用于重建目录
ali_drive:
  api_url: https://api.aliyundrive.com/v2
  max_files_count: 3000
  drives:
  - refresh_token: xxx #refresh_token
    root_folder: root #根目录的file_id
    name: drive0 #盘名，多个盘不可重复，这里只是示例，不是一定要叫这个名字，可随意修改
    password: pass #该盘密码，空（''）则不设密码，修改需要重建生效
    hide: false #是否在主页隐藏该盘，不可全部隐藏，至少暴露一个
  - refresh_token: xxx #只有一个盘的话，该段完全可以删除，反之有更多可以继续添加
    root_folder: root
    name: drive1
    password: pass
    hide: false
database:
  type: sqlite3
  dBFile: alist.db

• 填入最开始获取到的refresh_token，然后自行修改配置文件中默认的值
• 现在的情况应该是，目录下有两个文件alist、conf.yml和一个文件夹dist:

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

$ tree
.
├── alist
├── conf.yml
└── dist
    ├── favicon.ico
    ├── index.html
    └── static
        ├── css
        │   ├── about.f0b54b1c.css
        │   ├── app.4f0c3e9a.css
        │   └── chunk-vendors.8f913079.css
        ├── img
        │   └── alist.bcb68ba0.png
        └── js
            ├── about.8108f65b.js
            ├── app.34cb39e5.js
            └── chunk-vendors.131f0f41.js

5 directories, 12 files

在该文件夹下面执行下面的命令（Linux）

1
2

chmod +x alist
nohup ./alist > log.log 2>&1 &

ok，程序已经跑起来了。你可以cat log.log看看有没有报错。或者访问http://ip:5244进行查看。

守护进程（可选）

vim /usr/lib/systemd/system/alist.service添加以下内容，其中path_alist为alist所在的路径

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

[Unit]
Description=alist
After=network.target

[Service]
Type=simple
WorkingDirectory=path_alist
ExecStart=path_alist/alist -conf conf.yml
Restart=on-failure

[Install]
WantedBy=multi-user.target

然后systemctl daemon-reload重载配置，现在你就可以使用这些命令来管理程序了：

• 启动: systemctl start alist
• 关闭: systemctl stop alist
• 自启: systemctl enable alist
• 状态: systemctl status alist

使用mysql（可选）

需要使用utf8mb4编码，修改database部分配置：

1
2
3
4
5
6
7

database:
  type: mysql
  user: 用户名
  password: 密码
  host: 127.0.0.1
  port: 3306
  name: 数据库名

自定义静态资源服务器

与使用gin作为静态资源服务器操作步骤差不多，不同的地方在于：

• 下载AList-web的源码，修改.env.production中的VUE_APP_API_URL为具体部署的后端地址，然后yarn && yarn build自行部署
• conf.yml中的server.site_url填写前端部署的域名或者默认为’*’，需要正确填写，否则会报错。
• 建议直接使用gin作为静态资源服务器，使用nginx的话因为路由使用了history模式（没有#号好看一点），所以还需要设置一下nginx：

1
2
3

location / {
  try_files $uri $uri/ /index.html;
}

参考：https://router.vuejs.org/zh/guide/essentials/history-mode.html

反向代理

程序默认监听5244端口，要实现https访问，需要使用nginx反向代理，在配置文件中加入

1
2
3
4
5
6
7

location / {
    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    proxy_set_header Host $http_host;
    proxy_set_header X-Real-IP $remote_addr;
    proxy_redirect off;
    proxy_pass http://127.0.0.1:5244;
}

常见问题解答

• 如何给文件夹设置密码？
  在要加密的目录名称后面加上.password-密码，列表中会自动消除后面的密码部分。
• 如何隐藏文件夹
  在要隐藏的文件夹名称后面加上.hide即可。
• 如何重建目录树
  点击网页底部的rebuild按钮，输入配置文件中设置的server.password确定即可。
• 如何设置根目录？
  修改配置文件中的ali_drive.root_folder 为想要设置的文件夹的file_id即可。文件夹的file_id是什么？根目录就是root，其他目录为点进文件夹之后的url中folder/后面那一串
• 如何自定义网页底部链接？
  修改配置文件中的footer_text和footer_url为要设置的内容，或者不填则不会显示。
• 怎么复制文件直链？
  点进文件，右上角有复制直链的按钮。
• 修改网站icon？
  替换掉dist目录下的favicon.ico即可。
• 为什么新上传的文件不显示/删除了的文件还在？
  列表展示的是本地数据库里的数据，更新文件之后需要重建。
• 如何更新？
  前端：下载新的打包好的文件，删掉原来的dist文件夹，解压新的dist放入原来的位置即可。后端：pkill alist 停掉老的进程，删除旧的alist，下载新的alist，查看配置文件，补上新的配置项，再次运行即可。
• 运行显示检查更新之后直接报错？
  可能是无法访问到GitHub的api，可以在命令行后面加上-skip-update跳过检查更新。
• 怎么指定路径重建？
  在哪个路径点rebuild就是在哪里重建。
• The input parameter limit is not valid. limit should be less than 200？
  Xhofe/alist-web#22

Buy me a coffee

If you are using this project and happy with it or just want to encourage me to continue creating stuff,buy me a coffee by click this 。Thanks：

• zsbai ：请一杯奶茶?
• 白鹭
• 不知名
• 永胜
• MFYDev
• HakimYu
• Moc̶k̶i̶n̶gbird

• MacWk：https://macwk.com/
• XClient：https://xclient.info/
• AppKed：https://www.macbed.com/

工具类

macOS小助手

• https://macwk.com/soft/macos-assistant-macwk
• macOS小助手 是 MacWk.com 编写的一个应用程序，可以帮您快速的进行一些操作，比如禁用macOS的 Gatekeeper（守门员）、修复macOS 10.15 应用已损坏问题、修改mac截图保存位置、修改截图名称前缀、修改截图默认保存格式、禁用窗口截图的阴影、开启单应用模式、查看SIP状态、禁用 macOS 更新提示（关闭macOS设置图标的小红点）。

Mos

• https://github.com/Caldis/Mos/
• 一个用于在 macOS 上平滑你的鼠标滚动效果或单独设置滚动方向的小工具, 让你的滚轮爽如触控板

Alfred4

• https://macwk.com/soft/alfred-4
• Alfred Powerpack 4 是一款本地搜索及快速启动工具，它可以帮你提高工作效率。alfred 4 可以快速的搜索本地应用、搜索本地文件、执行终端命令、翻译、文件管理、音乐控制等等！

Mounty

• https://mounty.app/
• NTFS盘挂载

Popclip

• https://macwk.com/soft/popclip
• PopClip 2020 破解版是一款划词工具。PopClip在Mac OS上对划词这个功能做了极大的增强，依附于各类小插件，我们能获得更多强大的功能来提升我们的操作效率。PopClip的核心其实在于扩展，上线快三年官方已经累计130多个常用的扩展。这还不包含Github上那些非官方的扩展们。

Dozer

• https://github.com/Mortennn/Dozer
• Dozer 是一款隐藏macOS菜单栏图标的应用，不同于 Bartender 和 Vanilla，Dozer 是免费、开源的。Dozer 操作方法也很简单，Dozer运行后在菜单栏会出现一个「‧」，点击它，然后会出现另外一个「‧」，按住 command 键拖曳「‧」调整到适当位置，然后点击一下「‧」就会隐藏第一个「‧」左边的图标，重新显示也只需要点击「‧」即可。具体的大家可以上手体验一下，很简单的。

CheatSheet

• https://macwk.com/soft/cheatsheet
• CheatSheet 是一款可以快速查看mac应用快捷键的工具，你只需按住⌘键（command）几秒的时间，即可获得当前使用的应用程序所有的快捷组合列表。快捷键组合 列表窗口的右下角有个齿轮图标，可以设置呼出延时以及退出 CheatSheet。应用快捷键窗口中的名称是英文还是中文完全根据你使用的应用的语言决定。

iTerm2

• https://iterm2.com/
• iTerm2是Terminal的替代品，是iTerm的后继产品。 它适用于MacOS 10.14或更高版本的Mac。 iTerm2凭借您从未想过的功能将终端带入了现代时代。

Fig

• https://fig.io/
• With Fig, you can add autocomplete to any CLI tool or script using a declarative TypeScript schema.
• 下载：https://fig.io/invite/?code=yuGMx8azXL

ClashX

• https://github.com/yichengchen/clashX/releases
• A rule based proxy For Mac base on Clash.

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

# 赋予程序执行权限
chmod +x satrt
# 查看日志(最后50行)
tail -n 50 log.log
# 后台运行进程
nohup ./start > log.log 2>&1 &
# 根据进程名称杀进程
pkill start
# 查看某个端口是否占用
lsof -i:port
# 查看网络信息
ip addr
ifconfig
# 重启网络接口
ifdown eth0 && ifup eth0
# 测试磁盘I/O
dd if=/dev/zero of=1GB.bin count=2048k conv=fsync
dd if=/dev/sda of=/dev/null bs=4k

脚本收集

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

# 宝塔企业版(centos)开心版
yum install -y wget && wget -O install.sh https://download.fenhao.me/ltd/install/install_6.0.sh && sh install.sh
# 宝塔专业版(centos)开心版
yum install -y wget && wget -O install.sh https://download.fenhao.me/install/install_6.0.sh && sh install.sh
# BBR加速四合一
wget -N --no-check-certificate "https://raw.githubusercontent.com/chiakge/Linux-NetSpeed/master/tcp.sh" && chmod +x tcp.sh && ./tcp.sh
# trojan多用户管理
source <(curl -sL https://git.io/trojan-install)
# bench.sh
wget -qO- bench.sh | bash
# 全国测速
bash <(curl -Lso- https://git.io/superspeed)

此版本不再维护，请使用新版：https://github.com/Xhofe/alist
AList是一款阿里云盘的目录文件列表程序，后端基于golang最好的http框架gin，前端使用vue和ant design。没有专门学过前端，大佬轻喷?

暂时不会有太大的更新了，等阿里云盘正式发布之后再进行相关优化。更新计划：https://www.notion.so/Todo-3fdc2b0deec340e9aa9d86e6f603df72，有好的建议可以评论或在issue中告诉我。

测试了一下，在html文件头中加入<meta name="referrer" content="never">，目前可以避开防盗链检测，后续未知。来自https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Referrer-Policy , 若要使用程序作为图床，需要在img标签中加入referrerPolicy="no-referrer"。
由于阿里云盘加入了防盗链机制，目前所有不走服务器的预览均已失效，正在寻求解决办法，参考：https://developer.aliyun.com/article/59499 可能的方案：禁止浏览器的referer头，参考https://browsernative.com/http-referer-control-chrome/

1
2
3
4
5
6
7
8

<?xml version="1.0" encoding="UTF-8"?>
<Error>
  <Code>AccessDenied</Code>
  <Message>You are denied by bucket referer policy.</Message>
  <RequestId>5FFE96B83760853537D449EB</RequestId>
  <HostId>bj29.cn-beijing.data.alicloudccp.com</HostId>
  <BucketName>ccp-bj29-bj-1592982087</BucketName>
</Error>

本程序仅供学习研究使用！！！发现任何bug请提issue，部署上遇到问题欢迎添加我的qqi@nn.ci。
更新的时候后端和前端文件都需要替换！！！！以及补上配置文件新的配置项！！！！
更新的时候后端和前端文件都需要替换！！！！以及补上配置文件新的配置项！！！！
更新的时候后端和前端文件都需要替换！！！！以及补上配置文件新的配置项！！！！

项目地址：

• https://github.com/Xhofe/alist
• https://github.com/Xhofe/alist-web

更新

2021.1.22

• 使用阿里云提供的文档预览服务
• 解决阿里云盘防盗链问题
• 修复观看视频时返回播放器不销毁的bug
• 优化了一些代码

2021.1.12

• 修复安卓微信端左侧被裁切的问题
• 更新dplayer至最新版本
• 优化跨域/信任域名，隐藏了一些配置信息
• 修改meta信息中的语言为中文（不会弹出翻译）
• 优化版本号比较

2021.1.6

• 前端了去除了map文件，减小了打包后的文件体积，仅有原来的1/3
• 增加了文档文件的预览，使用了kkFileView，部署在比较辣鸡的机器上，有能力可以自行搭建
• 增加了几乎所有文本文件的预览，可自行修改需要预览的后缀
• 可自定义视频自动播放
• 修改了移动端（宽度小于600px）时的视频高度
• 更换了二维码接口，原来的有时候特别慢

2020.12.31

• 自定义脚本
• 移动端文件列表优化
• 二维码分享(只在宽度小于600px的设备上显示)
• 去除对文件请求的缓存
• 更新提醒(可在配置文件中关闭)

2020.12.29

• 引入缓存，大幅优化了响应速度

2020.12.28

• 自定义页面底部链接
• 301跳转文件直链
• 体验优化
• 隐藏.password密码文件
• json绑定出错问题

预览

• https://alist.nn.ci (稳定版本,即Github Release的最新版本)
• https://alist.now.sh (开发版本,随着GitHub提交更新)

如何部署

首先第一步，Star本项目AList(bushi

获取refresh_token

为什么不直接使用access_token，因为有效期只有两小时。

经Syc大佬的提醒，获取refresh_token其实没这么麻烦，我们只需要登陆阿里云盘之后，打开开发者工具，切换到Application选项卡，点开Local storage,会有一个token项，点开就可以看到refresh_token了，此处感谢一下Syc大佬。

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

# 过时内容
> 刚想起来忘记去掉自己博客的链接了?，下个版本去掉，或者自定义
> 如果启动时遇到`json:cannot unmarshal number into Go...`的问题，请先尝试使用[开发版本][7]

首先第一步需要获取`refresh_token`，这也是部署过程中最麻烦的一步。我尝试过直接通过login_token去登陆获取，但是会得到这个错误：
> User not authorized to operate on the specified APIs you need access by oauth.
知道如何破解的大佬，欢迎发起pr?或者在issues中告诉我。所以，现在还是先获取`refresh_token`吧。
- 进入阿里云盘登录页，打开开发者工具，并开启Preserve log：
![打开控制台][8]
- 选择一种方式登录，我这里选择的是扫码其他的应该也差不多
- 找到`https://auth.aliyundrive.com/v2/oauth/token_login`这个请求并复制请求中的token
![获取login_token][9]
- 这是我们就需要一个模拟请求插件，这里我使用的是[Postwomen][10],用刚刚复制的数据再次请求这个接口
![token_login][11]
- 然后我们就会得到一个goto的链接（在控制台就是看不到，是真滴奇怪，如果可以看到就没这么麻烦了），链接中有个code参数，我们再次复制它，然后用这个code请求`https://websv.aliyundrive.com/token/get`这个接口，注意这个code只能使用一次，所以这里没有打码了?
![token_get][12]
- 大功告成，终于得到这个`refresh_token`了，保存好它，然后就可以开始接下来的步骤了。

部署

使用gin作为静态资源服务器

• 前往AList Release下载对应系统的程序，解压得到一个运行文件alist
• 前往AList-web下载打包好的前端，解压得到一个dist目录放到alist同级目录下
• 在同级目录下新建一个配置文件conf.yml，复制以下内容到该文件中：

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

info:
  title: AList #网站名称，如果填写，则会替换掉默认的
  logo: #网站logo，如果填写，则会替换掉默认的
  footer_text: "Xhofe's Blog" #网页底部文字
  footer_url: https://www.nn.ci #网页底部文字链接
  music_img: https://img.xhofe.top/2020/12/19/0f8b57866bdb5.gif #预览音乐文件时的图片
  check_update: true #前端是否显示更新
  script: #自定义js脚本,可以是脚本的链接，也可以直接是脚本内容,如document.querySelector('body').style="background-image:url('https://api.mtyqx.cn/api/random.php');background-attachment:fixed"
  autoplay: true #视频是否自动播放
  preview:
    url: https://view.alist.nn.ci/onlinePreview?url= #extensions中包含的后缀名预览的地址，默认使用了kkFileView，可以自行搭建
    pre_process: [base64,encodeURIComponent] #对地址的处理，支持base64,encodeURIComponent,encodeURI
    extensions: [] #使用上面的url预览的文件后缀
    text: [txt,htm,html,xml,java,properties,sql,js,md,json,conf,ini,vue,php,py,bat,gitignore,yml,go,sh,c,cpp,h,hpp] #要预览的文本文件的后缀，可以自行添加
    max_size: 5242880
server:
  port: "5244" #程序监听端口
  search: false
  static: dist
  site_url: '*' #建议直接填*,若有信任域名要求,可填写其他具体域名,逗号分割
cache:
  enable: true #是否开启缓存
  expiration: 60 #缓存失效时间(单位:分钟)
  cleanup_interval: 120 #清理失效缓存间隔
  refresh_password: password #手动清理缓存密码
ali_drive:
  api_url: https://api.aliyundrive.com/v2
  root_folder: root #根目录
  refresh_token: #必填！！！
  max_files_count: 3000 #一次性最大文件数量

• 填入最开始获取到的refresh_token，然后自行修改配置文件中默认的值
• 现在的情况应该是，目录下有两个文件alist、conf.yml和一个文件夹dist，在该文件夹下面执行下面的命令（Linux）

1
2

chmod +x alist
nohup ./alist > log.log 2>&1 &

ok，程序已经跑起来了。你可以cat log.log看看有没有报错。或者访问http://ip:5244进行查看。

自定义静态资源服务器

与使用gin作为静态资源服务器操作步骤差不多，不同的地方在于：

• 下载AList-web的源码，修改.env.production中的VUE_APP_API_URL为具体部署的后端地址，然后yarn && yarn build自行部署
• conf.yml中的server.site_url填写前端部署的域名或者默认为’*’，需要正确填写，否则会报错。
• 建议直接使用gin作为静态资源服务器，使用nginx的话因为路由使用了history模式（没有#号好看一点），所以还需要设置一下nginx：

1
2
3

location / {
  try_files $uri $uri/ /index.html;
}

参考：https://router.vuejs.org/zh/guide/essentials/history-mode.html

反向代理

程序默认监听5244端口，要实现https访问，需要使用nginx反向代理，在配置文件中加入

1
2
3
4
5
6
7

location / {
    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    proxy_set_header Host $http_host;
    proxy_set_header X-Real-IP $remote_addr;
    proxy_redirect off;
    proxy_pass http://127.0.0.1:5244;
}

常见问题解答

• 如何给文件夹设置密码？
  在要加密的目录下新建一个名称为.password-要设置的密码的文件或者文件夹就可以了。
• 如何设置根目录？
  修改配置文件中的ali_drive.root_folder 为想要设置的文件夹的file_id即可。
• 如何自定义网页底部链接？
  修改配置文件中的footer_text和footer_url为要设置的内容，或者不填则不会显示。
• 怎么复制文件直链？
  进入文件预览，可以预览的文件复制按钮在右上角，不可预览的复制按钮在正中间。
• 修改网站icon？
  替换掉dist目录下的favicon.ico即可。
• 为什么新上传的文件不显示/删除了的文件还在？
  为了提高响应速度，对文件的列表是有缓存的，默认开启。
• 如何开关缓存？
  配置文件中的cache.enable设置为true或false即可，打开会占用更多的内存，但会大幅优化使用体验，默认打开。经测试下载地址是会失效的，所以请自行设置缓存的时间。下个版本将给文件去掉缓存，只缓存文件夹。更新文件的时候可以手动刷新缓存。
• 如何刷新缓存？
  程序会自动按照配置文件中的cache.cleanup_interval自动清理过期缓存，如需手动刷新，手动访问后端地址/cache/配置文件中设置的刷新密码，如https://alist.nn.ci/cache/alist。
• 如何更新？
  前端：下载新的打包好的文件，删掉原来的dist文件夹，解压新的dist放入原来的位置即可。后端：pkill alist 停掉老的进程，删除旧的alist，下载新的alist，查看配置文件，补上新的配置项，再次运行即可。
• 要安装Windows版本？
  自行编译，或者在Github Actions可以找到每次提交的build。

Buy me a coffee

If you are using this project and happy with it or just want to encourage me to continue creating stuff,buy me a coffee by click this 。Thanks：

• zsbai ：请一杯奶茶?
• 白鹭
• 不知名
• 永胜

Apache JMeter是Apache组织开发的基于Java的压力测试工具。用于对软件做压力测试，它最初被设计用于Web应用测试，但后来扩展到其他测试领域。 它可以用于测试静态和动态资源，例如静态文件、Java 小服务程序、CGI 脚本、Java 对象、数据库、FTP 服务器， 等等。JMeter 可以用于对服务器、网络或对象模拟巨大的负载，来自不同压力类别下测试它们的强度和分析整体性能。另外，JMeter能够对应用程序做功能/回归测试，通过创建带有断言的脚本来验证你的程序返回了你期望的结果。为了最大限度的灵活性，JMeter允许使用正则表达式创建断言。

为什么要进行二次插件开发

因为有时候自带的取样器无法满足我们的需求，我们需要自己定义就需要进行二次插件开发了，其实这个开发的流程也非常的简单，只需要实现其中几个接口就可以了。
例如Jmeter自带的TCP取样器的行尾（EOL字节值）只能设置的范围只能是[-128,127]，判断行结束的byte值，如果你指定的值大于127或者小于-128，则会跳过EOL检测，这样TCP就无法自动断开连接直至超时判断失败。
所以我们需要进行自定义的TCP取样器。

二次开发的步骤

• 首先使用IDEA新建普通java项目
• 将jmeter的lib/ext目录下的ApacheJMeter_core.jar和ApacheJMeter_java.jar两个jar包引入
• 新建一个类实现JavaSamplerClient接口：
  • getDefaultParameters：设置默认参数
  • setupTest：测试前做的事
  • runTest：测试时主要做的事
  • teardownTest：测试后做的事，一般不做设置

runTest

runTest就是主要的测试逻辑部分，在这个函数中，我们需要记录开始于结束的时间，设置测试的标签和结果以及response等等。

code

我这里主要实现的就是一个发送自定义的16进制TCP报文并检测一次回复的报文尾部转换之后是否为指定字符串。

[tag type=“default”]SocketTest[/tag]类，主要的取样器类：

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

package top.xhofe;

import org.apache.jmeter.config.Arguments;
import org.apache.jmeter.protocol.java.sampler.JavaSamplerClient;
import org.apache.jmeter.protocol.java.sampler.JavaSamplerContext;
import org.apache.jmeter.samplers.SampleResult;

import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;

/**
 * @author Xhofe
 */
public class SocketTest implements JavaSamplerClient {
    private SampleResult result;
    private String host;
    private int port;
    private String content;
    private String end;
    @Override
    public void setupTest(JavaSamplerContext javaSamplerContext) {
        result=new SampleResult();
        host=javaSamplerContext.getParameter("host");
        port=Integer.parseInt(javaSamplerContext.getParameter("port"));
        content=javaSamplerContext.getParameter("content");
        end=javaSamplerContext.getParameter("end");
    }

    @Override
    public SampleResult runTest(JavaSamplerContext javaSamplerContext) {
        String threadName=Thread.currentThread().getName();
        result.setSampleLabel(threadName);
        result.setSamplerData("TCP发送:"+host+":"+port+"数据:"+content);
        result.sampleStart();
        try {
            Socket socket=new Socket(host,port);
            OutputStream out=socket.getOutputStream();
            byte[] hexStrToByteArr = Utils.hexStrToByteArr(content);
            if (hexStrToByteArr==null){
                throw new Exception("hexStrToByteArr error");
            }
            out.write(hexStrToByteArr);
            InputStream in=socket.getInputStream();
            byte[] buf=new byte[1024];
            int len=in.read(buf);
            String response=Utils.bytesToHexString(buf,len);
            result.setResponseData(response,"UTF-8");
            socket.close();
            if (!response.endsWith(end)){
                throw new Exception("response:"+response+"not ends with:"+end);
            }
            result.setSuccessful(true);
        }catch (Exception e){
            result.setSuccessful(false);
            e.printStackTrace();
        }finally {
            result.sampleEnd();
        }
        return result;
    }

    @Override
    public void teardownTest(JavaSamplerContext javaSamplerContext) {

    }

    @Override
    public Arguments getDefaultParameters() {
        Arguments params=new Arguments();
        params.addArgument("host","tcp.xhofe.top");
        params.addArgument("port","9999");
        params.addArgument("end","FB")  ;
        params.addArgument("content","fa120106009a6946401000010077036a65b4002202175e4c00002f5b00002f5b00002f5b09080908007d04dd0bc3000000000175d3f077ca01f9000c000f0055006401f9004d001907e707de04bc000007de04bc000050643201fb");
        return params;
    }
}

[tag type=“success”]Utils[/tag]工具类，用于转换字符串和十六进制的转换：

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

package top.xhofe;

/**
 * @author Xhofe
 */
public class Utils {
    public static byte[] hexStrToByteArr(String hexString) {
        if (hexString==null||hexString.isEmpty()) {
            return null;
        }

        hexString = hexString.replaceAll(" ", "");
        int len = hexString.length();
        int index = 0;

        byte[] bytes = new byte[len / 2];

        while (index < len) {
            String sub = hexString.substring(index, index + 2);
            bytes[index / 2] = (byte) Integer.parseInt(sub, 16);
            index += 2;
        }
        return bytes;
    }

    public static String bytesToHexString(byte[] bArray,int len) {
        StringBuilder sb = new StringBuilder(len);
        String sTemp;
        for (int i = 0; i < len; i++) {
            sTemp = Integer.toHexString(0xFF & bArray[i]);
            if (sTemp.length() < 2) {
                sb.append(0);
            }
            sb.append(sTemp.toUpperCase());
        }
        return sb.toString();
    }
}

• 将代码打包成Jar包（此处不赘述）
• 将打包好的Jar包放到jmeter根目录/lib/ext目录下
• Jmeter添加线程组->添加取样器-Java请求->选择自定义的类->设置参数/使用默认的参数
• OK，完成！

参考

五步教你如何去做jmeter接口java二次开发

短链接原理

原理其实很简单，前端给后端传一个字符串，然后根据这个字符串找到原网址，最后返回一个301即可。所以短网址算法主要就是研究如何根据原网址算出这个字符串以及如何根据字符串找到这个网址。

短链接算法

常用的短链接算法主要有两种：自增ID和哈希

哈希

顾名思义，哈希就是将原网址计算出一个哈希字符串，但是这种算法碰到哈希碰撞时，会存在重复的情况，这个时候就有可能需要再哈希或者进行其他的处理。

自增ID

所以这里我们选择使用自增ID的方法，我们先将原网址存入数据，然后使用数据库返回的id，将id换算成六十二进制的字符串（随机的大小写字母+数字），数据库也不需要存储这个字符串，直接返回给前端即可。当前端请求这个字符串时，再转成十进制的id即可找到原网址。go进制转换与随机62进制字符串代码：

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

import (
"io"
"log"
"math"
"math/rand"
"os"
"path/filepath"
"regexp"
"strings"
)

var CHARS = "InsV3Sf0obzp2i4gj1yYGqQv6wUtmBxlMAP7KHd8uTXFk9aRJWNC5EOhZDcLer"

const (
// 0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ
SCALE = 62
REGEX = "^[0-9a-zA-Z]+$"
NUM = 6
)

func RandomStr(str string) string {
chars := []rune(str)
for i := len(chars) - 1; i > 0; i-- {
num := rand.Intn(i + 1)
chars[i], chars[num] = chars[num], chars[i]
}
return string(chars)
}

func Encode10To62(val uint) string {
if val < 0 {
panic("val cannot be negative.")
}
str := ""
var remainder int
for math.Abs(float64(val)) > SCALE-1 {
remainder = int(val % SCALE)
str = string(CHARS[remainder]) + str
val = val / SCALE
}
str = string(CHARS[val]) + str
//for i := len(str); i < NUM; i++ {
//str = string(CHARS[0]) + str
//}
return str
}

func Decode62To10(val string) uint {
if match, _ := regexp.MatchString(REGEX, val); !match {
panic("input illegal.")
}
var result uint = 0
index, length := 0, len(val)
for i := 0; i < length; i++ {
index = strings.Index(CHARS, string(val[i]))
result += uint(index * int(math.Pow(float64(SCALE), float64(length-i-1))))
}
return result
}

Demo

Oh,easy!
支持API调用与添加书签栏快捷缩短。

最近在做C++的开发，其中很多地方需要使用到多线程，故记录在此。

头文件：#include <thread>，命名空间：std

std::thread是C++11之后的标准线程库，使用起来很方便。

主要有以下几种使用方式：

新线程执行一个函数

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

#include <iostream>
#include <thread>
 
using namespace std;
 
void t1() 
{
    for (int i = 0; i < 10; ++i)
    {
        cout << "thread-1\n";
    }
}
void t2(int n)
{
    for (int i = 0; i < n; ++i)
    {
        cout << "thread-2\n";
    }
}
int main()
{
    thread th1(t1);  //没有参数时
    thread th2(t2,10); //有参数时
 
    th1.join(); // 必须将线程join或者detach 等待子线程结束主进程才可以退出，detach是用来和线程对象分离的，这样线程会独立地执行
    th2.join(); 
 
    //or use detach
    //th1.detach();
    //th2.detach();
 
    cout << "main thread\n";
 
    return 0;
}

类外新线程执行一个成员函数

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

#include <iostream>
#include <thread>
 
using namespace std;
class Client{
    void recieve();
    void recieve(int conn);
}

int main()
{
 Client *client=new Client();//此处必须使用指针
    thread t1(&Client::recieve,client);//没有参数时
    thread t2(&Client::recieve,client,1);//有参数时
    t1.join();
    t2.join();
    return 0;
}

类中新线程执行成员函数

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

#include <iostream>
#include <thread>
 
using namespace std;
class Client{
    void recieve();
    void recieve(int conn);
    
    Client(){
        thread t1(&Client::recieve,this);//没有参数时
    thread t2(&Client::recieve,this,1);//有参数时
        t1.detach();
        t2.detach();
    }
}

int main()
{
    while(true){
        
    }
    return 0;
}

Jenkins 支持各种运行方式，可通过系统包、Docker 或者通过一个独立的 Java 程序。

Jenkins安装部署所需条件及作用

Jenkins安装部署所需条件

机器要求

• 最少256 MB 的内存，建议大于 512 MB
• 10 GB 的硬盘空间（用于 Jenkins 和 Docker 镜像）

环境要求

• Java 8 ( JRE 或者 JDK 都可以)
• Docker （如果需要使用docker来部署）
• Maven （如果需要使用Maven构建项目）
• Tomcat （如果基于Tomcat安装）

Jenkins的作用

Jenkins的主要作用是用来做CI&CD，在软件工程中，CI / CD或CICD通常是指持续集成以及持续交付或持续部署的组合实践(from wiki)。具体而言，CI/CD 可让持续自动化和持续监控贯穿于应用的整个生命周期（从集成和测试阶段，到交付和部署）。这些关联的事务通常被统称为“CI/CD 管道”，由开发和运维团队以敏捷方式协同支持。

所以在此处，Jenkins的主要作用是，我们将代码提交到SVN，Jenkins自动从SVN获取最新的代码，然后进行一系列自动的打包、测试、部署的工作，不需要我们手动去完成。

Jenkins安装部署

首先是JDK的安装 ：

1
2
3

cd /mnt/java
wget xxx.com/jdk-8u251-linux-x64.tar.gz
tar -zxvf jdk-8u251-linux-x64.tar.gz

因为环境变量中已经配置了Jdk1.7，所以不再配置环境变量。

然后是安装Maven ;

安装maven

1
2
3
4
5
6
7
8
9
10

mkdir /mnt/maven
cd /mnt/maven
wget xxx.com/apache-maven-3.6.3-bin.tar.gz
tar -zxvf apache-maven-3.6.3-bin.tar.gz
vim /etc/profile
# 添加
export M2_HOME=/mnt/maven/apache-maven-3.6.3
export PATH=${M2_HOME}/bin:$PATH
#使环境变量生效
source /etc/profile

更改默认的仓库位置与maven阿里云镜像：

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

# 新建仓库文件夹
mkdir /mnt/maven/repository
# 备份默认的配置文件
cd /mnt/maven/apache-maven-3.6.3/conf
cp settings.xml settings-backup.xml
vim settings.xml
# 在settings标签中添加
<localRepository>/mnt/maven/repository</localRepository>
# 添加mirrors子节点
<mirror>
  <id>aliyunmaven</id>
  <mirrorOf>*</mirrorOf>
  <name>阿里云公共仓库</name>
  <url>https://maven.aliyun.com/repository/public</url>
</mirror>

安装Jenkins

此处采用war包方式安装：

• 首先设置Jenkins_home

  1 2 3 4 5 6 7 8

  # 创建文件夹 mkdir /mnt/jenkins mkdir /mnt/jenkins/jenkins-home vim /etc/profile # 添加 export JENKINS_HOME=/mnt/jenkins/jenkins-home #使环境变量生效 source /etc/profile

• 拉取免安装war包(建议先在本地下载，然后在传上去)

  1 2	cd /mnt/jenkins wget http://mirrors.jenkins.io/war-stable/2.249.1/jenkins.war

• 添加Jenkins运行脚本

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

  cd /mnt/jenkins # 新建日志存放目录 mkdir jenkins-logs vim run.sh # 添加 #!/bin/bash pid=`ps -ef | grep jenkins.war | grep -v 'grep'| awk '{print $2}'| wc -l` if [ "$1" = "start" ];then if [ $pid -gt 0 ];then echo 'jenkins is running...' else /mnt/java/jdk1.8.0_251/bin/java -jar jenkins.war --httpPort=8080 >jenkins-logs/log1.log 2>&1 & echo 'jenkins is starting' fi elif [ "$1" = "stop" ];then exec ps -ef | grep jenkins | grep -v grep | awk '{print $2}'| xargs kill -9 echo 'jenkins is stop..' else echo "Please input like this:"./run.sh start" or "./jenkins stop"" fi # 赋予脚本执行权限 chmod +x run.sh

• 运行

  1	bash run.sh start

Jenkins的配置

系统配置

• 打开域名/ip:8080

• 获取初始密码，在/mnt/jenkins/jenkins-logs/log1.log日志文件中寻找，或者

  1	cat /mnt/jenkins/jenkins-home/secrets/initialAdminPassword

• 输入初始密码，继续

• 安装推荐的插件/选择插件安装，都不选，直接叉掉跳过，然后在用户名-configure-修改密码

• 汉化：System configuration–plugin manage–available plugin–search cn–选择Chinese simplified安装，然后重启Jenkins

• 设置jdk和maven

  • jdk：系统管理-全局工具配置-新增JDK-别名：JDK1.8；JAVA_HOME：/mnt/java/jdk1.8.0_251
  • maven：系统管理-全局工具配置-新增Maven-别名：MAVEN3.6.3；MAVEN_HOME：/mnt/maven/apache-maven-3.6.3

• 安装需要的插件：（勾选直接安装，视情况选择）

  • git
  • Subversion
  • Maven Integration

新建Job（此处以cloudweb为例）

• 新建任务

• 选择构建一个maven项目

• 勾选丢弃旧的构建，保持构建的天数与保持构建的最大个数都填10

• 源码管理选择git或者Subversion，填入URL

• Credentials-添加-Jenkins-username with password

• 构建触发器-去掉Build whenever a SNAPSHOT dependency is built勾选

• build：root pom：pom.xml Goals and options：package -Dmaven.test.skip=true

• 保存-立即构建

Sonarqube

SonarQube 是一个开源的代码分析平台，用来持续分析和评测代码的质量，支持检测 Java、JavaScript、C#、C、C++ 等二十几种编程语言。通过 SonarQube 可以检测出项目中潜在的Bug、漏洞、代码规范、重复代码、缺乏单元测试的代码等问题，并提供了 UI 界面进行查看和管理。

sonarqube安装

确定要使用的sonarqube版本

当前sonarqube最新版本为8.4，但是需要jdk版本至少为11，且不支持mysql5.7，最近的长期支持版本SonarQube 7.9.4 LTS也是。

所以我选择的是sonarqube 7.7，支持jdk8和MySQL 5.7.

首先下载sonarqube（建议手动下载上传）

1
2
3

mkdir /mnt/jenkins/sonarqube
cd /mnt/jenkins/sonarqube
wget https://binaries.sonarsource.com/Distribution/sonarqube/sonarqube-7.7.zip

安装sonarqube

1
2

# 直接解压即可
unzip sonarqube-7.7.zip

配置sonarqube

• 首先区mysql中新建一个数据库，名称为sonar

• 配置sonar.properties中的数据库(这里很坑，地址填localhost无法连接，找了很久)

  1 2 3 4 5

  vim /mnt/jenkins/sonarqube/sonarqube-7.7/conf/sonar.properties # 添加 sonar.jdbc.url=jdbc:mysql://xhofe.top:3306/sonar?useUnicode=true&characterEncoding=utf8&rewriteBatchedStatements=true&useConfigs=maxPerformance&useSSL=false&serverTimezone=Asia/Shanghai sonar.jdbc.username=test sonar.jdbc.password=test

启动Sonarqube

• 因为环境变量中的Java版本是1.7，而sonarqube需要的jdk是8，所以需要手动修改一下启动文件：

  1 2 3

  vim /mnt/jenkins/sonarqube/sonarqube-7.7/conf/wrapper.conf # 修改 wrapper.java.command wrapper.java.command=/mnt/java/jdk1.8.0_251/bin/java

• sonarqube不能以root用户运行，所以需要创建新用户

  1 2 3 4 5

  useradd sonar passwd sonar Enter new UNIX password: sonar Retype new UNIX password: sonar chown -R sonar:sonar /mnt/jenkins/sonarqube/sonarqube-7.7

• 修改vm.max_map_count 与max file descriptors

  1 2 3 4 5 6 7 8 9

  sudo vim /etc/sysctl.conf # 添加 vm.max_map_count=655360 # 执行 sudo sysctl -p vim /etc/security/limits.conf # 添加 sonar soft nofile 65536 sonar hard nofile 65536

• 启动

  1 2 3

  su sonar cd /mnt/jenkins/sonarqube/sonarqube-7.7/bin/linux-x86-64 ./sonar.sh start

• 汉化(或者手动上传)

  打开http://[url/ip]:9000/默认密码为admin/admin；

  1 2 3 4

  cd /mnt/jenkins/sonarqube/sonarqube-7.7/extensions/plugins wget https://github.com/SonarQubeCommunity/sonar-l10n-zh/releases/download/sonar-l10n-zh-plugin-1.27/sonar-l10n-zh-plugin-1.27.jar cd /mnt/jenkins/sonarqube/sonarqube-7.7/bin/linux-x86-64 ./sonar.sh restart

与Jenkins集成

Jenkins安装SonarQube Scanner

• Jenkins-系统管理-插件管理-可用插件-SonarQube Scanner-直接安装

• 重启Jenkins

配置Jenkins与sonarqube集成

• 首先，在SonarQube中生成一个Token：我的账号-安全-生成令牌-名称填Jenkins（token）

• 然后，在Jenkins中配置连接sonarqube服务器的地址，这里用到的token就是刚才在sonarqube中创建的那个token：Jenkins-系统管理-系统配置-SonarQube servers-add sonarqube：

保存应用

• 最后，配置全局工具配置：Jenkins-系统管理-全局工具配置-SonarQube Scanner-新增SonarQube Scanner-

  名称：sonarqube scanner，勾选自动安装，版本选择4.0.0.1744

  保存应用。

sonarqube中配置svn(选做，如果使用git则不需要)

sonar-runner发现了.svn文件，于是启动了自己的SVN插件，去访问SVN，所以需要配置svn，配置-scm-将Disabled the SCM Sensor设置为true，在svn页面，设置svn的用户名和密码。

如何使用

在Jenkins中创建job时，post-steps中添加excute sonarqube scanner；

Analysis properties：

1
2
3
4
5
6
7
8
9

sonar.projectKey=cloudweb
sonar.projectName=cloudweb
sonar.projectVersion=1.0

sonar.language=java
sonar.sourceEncoding=UTF-8

sonar.sources=$WORKSPACE/src
sonar.java.binaries=$WORKSPACE/target/classes

保存应用。

OK~现在就点击立即构建吧。

参考

• Jenkins使用教程

• Jenkins 集成 SonarQube Scanner

• Jenkins集成SonarQube进行代码质量扫描

• sonarqube

• sonar-scanner扫描代码出错 SonarQube svn: E170001

• max virtual memory areas vm.max_map_count [65530] is too low, increase to at least [262144]

• 解决：max file descriptors [65535] for elasticsearch process is too low

• sonar es can not run elasticsearch as root

• Linux下为Sonarqube安装中文插件

移除类dp问题和平常的dp问题不一样，因为平常的dp问题都是每次做出选择直接分解成子问题，但是移除类dp问题每次的选择会改变问题的状态，所以我们需要逆向思考，给状态的定义是每次最后的选择。

题目收集：

312. 戳气球

有 n 个气球，编号为0 到 n-1，每个气球上都标有一个数字，这些数字存在数组 nums 中。

现在要求你戳破所有的气球。如果你戳破气球 i ，就可以获得 nums[left] * nums[i] * nums[right] 个硬币。 这里的 left 和 right 代表和 i 相邻的两个气球的序号。注意当你戳破了气球 i 后，气球 left 和气球 right 就变成了相邻的气球。

求所能获得硬币的最大数量。

说明:

• 你可以假设 nums[-1] = nums[n] = 1，但注意它们不是真实存在的所以并不能被戳破。
• 0 ≤ n ≤ 500, 0 ≤ nums[i] ≤ 100

示例:

1
2
3
4

输入: [3,1,5,8]
输出: 167 
解释: nums = [3,1,5,8] --> [3,5,8] -->   [3,8]   -->  [8]  --> []
     coins =  3*1*5      +  3*5*8    +  1*3*8      + 1*8*1   = 167

code

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

class Solution {
    public int maxCoins(int[] nums) {
        int len=nums.length;
        if (len==0)return 0;
        int[][] dp=new int[len][len];
        for (int i = 0; i < len; i++) {
            dp[i][i]=nums[i]*(i>0?nums[i-1]:1)*(i+1<len?nums[i+1]:1);
        }
        for (int i = 1; i < len; i++) {
            for (int j = 0; j < len-i; j++) {
                for (int k = j; k <= j+i; k++) {
                    dp[j][j+i]=Math.max(dp[j][j+i],nums[k]*(j>0?nums[j-1]:1)*(j+i+1<len?nums[j+i+1]:1)+(j>k-1?0:dp[j][k-1])+(k+1>j+i?0:dp[k+1][j+i]));
                }
            }
        }
        return dp[0][len-1];
    }
}

546. 移除盒子

给出一些不同颜色的盒子，盒子的颜色由数字表示，即不同的数字表示不同的颜色。
你将经过若干轮操作去去掉盒子，直到所有的盒子都去掉为止。每一轮你可以移除具有相同颜色的连续 k 个盒子（k >= 1），这样一轮之后你将得到 k*k 个积分。
当你将所有盒子都去掉之后，求你能获得的最大积分和。

示例：

1
2
3
4
5
6
7
8

输入：boxes = [1,3,2,2,2,3,4,3,1]
输出：23
解释：
[1, 3, 2, 2, 2, 3, 4, 3, 1] 
----> [1, 3, 3, 4, 3, 1] (3*3=9 分) 
----> [1, 3, 3, 3, 1] (1*1=1 分) 
----> [1, 1] (3*3=9 分) 
----> [] (2*2=4 分)

提示：

• 1 <= boxes.length <= 100
• 1 <= boxes[i] <= 100

code

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

class Solution {
private:
    int dp[100][100][100];
public:
    int removeBoxes(vector<int>& boxes) {
        memset(dp,0,sizeof(dp));
        return calculatePoints(boxes,0,boxes.size()-1,0);
    }
    int calculatePoints(vector<int>& boxes,int l,int r,int k){
        if(l>r)return 0;
        if(dp[l][r][k]!=0)return dp[l][r][k];
        while(r>l&&boxes[r-1]==boxes[r]){
            r--;k++;
        }
        dp[l][r][k]=calculatePoints(boxes,l,r-1,0)+(k+1)*(k+1);
        for(int i=l;i<r;++i){
            if(boxes[i]==boxes[r]){
                dp[l][r][k]=max(dp[l][r][k],calculatePoints(boxes,l,i,k+1)+calculatePoints(boxes,i+1,r-1,0));
            }
        }
        return dp[l][r][k];
    }
};

17 210. 课程表 II

题目

现在你总共有 n 门课需要选，记为 0 到 n-1。

在选修某些课程之前需要一些先修课程。 例如，想要学习课程 0 ，你需要先完成课程 1 ，我们用一个匹配来表示他们: [0,1]

给定课程总量以及它们的先决条件，返回你为了学完所有课程所安排的学习顺序。

可能会有多个正确的顺序，你只要返回一种就可以了。如果不可能完成所有课程，返回一个空数组。

示例 1:

输入: 2, [[1,0]]
输出: [0,1]
解释: 总共有 2 门课程。要学习课程 1，你需要先完成课程 0。因此，正确的课程顺序为 [0,1] 。

示例 2:

输入: 4, [[1,0],[2,0],[3,1],[3,2]]
输出: [0,1,2,3] or [0,2,1,3]
解释: 总共有 4 门课程。要学习课程 3，你应该先完成课程 1 和课程 2。并且课程 1 和课程 2 都应该排在课程 0 之后。
因此，一个正确的课程顺序是 [0,1,2,3] 。另一个正确的排序是 [0,2,1,3] 。

说明:

• 输入的先决条件是由边缘列表表示的图形，而不是邻接矩阵。详情请参见图的表示法。
• 你可以假定输入的先决条件中没有重复的边。

提示:

• 这个问题相当于查找一个循环是否存在于有向图中。如果存在循环，则不存在拓扑排序，因此不可能选取所有课程进行学习。
• 通过 DFS 进行拓扑排序 - 一个关于Coursera的精彩视频教程（21分钟），介绍拓扑排序的基本概念。
• 拓扑排序也可以通过 BFS 完成。

思路

拓扑排序过程：

(1) 选择一个入度为0的顶点并输出之；

(2) 从网中删除此顶点及所有出边。

重复执行此过程，若无剩余点则删除的顺序即为一个答案，若有则无解。

ps：将给的参数转换成图会更快一些，懒得写了。

code

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

class Solution {
    public int[] findOrder(int numCourses, int[][] prerequisites) {
        int[] indegree=new int[numCourses];
        int[] res=new int[numCourses];
        for (int[] prerequisite : prerequisites) {
            indegree[prerequisite[0]]++;
        }
        boolean flag=true;
        int count=0;
        while (flag&&count<numCourses){
            flag=false;
            int i=0;
            while (i<numCourses){
                if (indegree[i]==0){
                    indegree[i]=-1;
                    res[count++]=i;
                    flag=true;
                    break;
                }
                ++i;
            }
            for (int[] prerequisite : prerequisites) {
                if (prerequisite[1]==i)indegree[prerequisite[0]]--;
            }
        }
        if (count==numCourses)return res;
        return new int[0];
    }
}

18 152. 乘积最大子数组

题目

给你一个整数数组 nums ，请你找出数组中乘积最大的连续子数组（该子数组中至少包含一个数字），并返回该子数组所对应的乘积。

示例 1:

1
2
3

输入: [2,3,-2,4]
输出: 6
解释: 子数组 [2,3] 有最大乘积 6。