作者： 清朝云

共计 1031 个字符，预计需要花费 3 分钟才能阅读完成。

本文可能持续更新，主要记录一些在编译自己的特殊固件可能用到的东西。

1. 如何指定默认root密码

openwrt 默认编译出来是没有密码的，如果想指定，需要修改 package/base-files/files/etc/shadow 文件。

root:$1$ngCOq4Vk$mk9N2.RpBj58LWiMarHtu0::0:99999:7:::

比如想设置密码为 root，指定 root 后面的字符串即可，上面的字符串是 root 加密后的字符。

想要获取特定密码，需要在一台其他的 linux 机器上执行相关代码获取，比如：

# 修改root密码
passwd root
# 查看root加密后的字符串
cat /etc/shadow

2. 指定默认lan口ip

openwrt 默认 ip 是 192.168.1.1，想修改的话需要修改 package/base-files/files/bin/config_generate 文件。

搜索文件 192.168.1.1，修改成想要的 ip 即可。

此外，想要指定 ip 还可以添加一块新的网卡。在 generate_static_network 函数下，添加网卡信息：

generate_static_network() {
    uci -q batch <<-EOF
        delete network.lan1
        set network.lan1='interface'
        set network.lan1.device='br-lan'
        set network.lan1.proto='static'
        set network.lan1.ipaddr='172.21.9.11'
        set network.lan1.gateway='172.21.9.254'
        set network.lan1.dns='114.114.114.114'
        set network.lan1.netmask='255.255.255.0'
        set network.lan1.ip6assign='60'
    EOF

    # 下面是默认的内容
    uci -q batch <<-EOF
        delete network.loopback
        set network.loopback='interface'
        set network.loopback.device='lo'
        set network.loopback.proto='static'
        set network.loopback.ipaddr='127.0.0.1'
        set network.loopback.netmask='255.0.0.0'
    EOF
    ...
}

提醒：本文发布于255天前，文中所关联的信息可能已发生改变，请知悉！

共计 307 个字符，预计需要花费 1 分钟才能阅读完成。

顾名思义，短链服务是一种将长网址转换为较短、更易分享的链接的服务。清朝云在 github 上发现了一款不错的开源程序，它可以自定义拦截器和跳转方式，属实是对于有特别需求的来说很方便。遗憾的是，该程序并没有后台管理系统。

搭建方式：

docker run -d --name shorturl -p 80:80 hausen1012/shorturl

效果如下：

/>

方便的是，还可以使用 api 生成短链接。

curl -s http://ip/api/link?url=https://www.baidu.com/

开源项目地址：https://github.com/ellermister/shorturl

项目演示网站：https://x007.in/

提醒：本文发布于250天前，文中所关联的信息可能已发生改变，请知悉！

共计 388 个字符，预计需要花费 1 分钟才能阅读完成。

文件重命名对于清朝云来说不是很常用，但是想用的时候找不到好用的工具的一个功能。所以，一经发现这个浏览器可以批量重命名的开源项目，觉得很是惊喜。并且原来的功能只有修改比如删除或者替换，不能进行全新命名，清朝云提过 issue 以后，这个也加上了。

需要注意的是，这个项目由于浏览器 api 的缘故，只支持 https 访问。如果使用 nginx 反代，那么可以反代到 http 端口，但同时清朝云制作的镜像本身包含 https 端口。

废话不多说，搭建命令如下：

docker run -d --name rename -p 80:80 -p 443:443 hausen1012/rename

效果如下图，支持各种操作比如新增、插入删除等基本操作，还有正则替换和自定义 js。

/>

开源项目地址：https://github.com/JasonGrass/rename

项目演示网站：https://rename.jgrass.xyz/

提醒：本文发布于249天前，文中所关联的信息可能已发生改变，请知悉！

共计 472 个字符，预计需要花费 2 分钟才能阅读完成。

PicX 是一款基于 GitHub API 开发的图床工具，提供图片上传托管、生成图片链接和常用图片工具箱服务。

可以说虽然是图床工具，但是图片占用的不是自己服务器的空间，感觉这点还是挺好的。只需要使用 github 进行授权即可，上传的图片自动存储在仓库中。

其实好像没有自建的太大必要，因为数据并不存服务器上，而且如果使用 OAuth 授权登录，那么会跳转到官方地址。但是，已经构建了，想自建还是可以自建吧，只需要设置一下 github 的 token 就行。

搭建方式如下：

docker run -d --name picx -p 80:80 hausen1012/picx

如果是第一次使用，那么需要参考文档：https://picx-docs.xpoet.cn/docs/usage-guide/get-start.html 。

其实非常简单，只需要按提示傻瓜式操作即可，简单点来说就是让 picx 帮忙创建一个仓库，这个仓库用来存放图片文件。

上传效果如图：

/>

开源项目地址：https://github.com/XPoet/picx

项目演示网站：https://picx.xpoet.cn/

提醒：本文发布于246天前，文中所关联的信息可能已发生改变，请知悉！

共计 1895 个字符，预计需要花费 5 分钟才能阅读完成。

前言

由于 nginx 带不带/老是会混乱，并且确实在使用中出现过问题，比如使用不当导致代理后的 url 带有//，或者说配置很久也不能达到自己想要代理的效果。于是想着还是好好研究一下，并在以后规范自己 nginx 的使用。

如果代理后的地址带有 //，spring security 中可能报错：The request was rejected because the URL contained a potentially malicious String “//”

测试

准备工作

为了测试以下内容，专门做了一个镜像，不然看不见 nginx 代理后的完整请求，如果有需要的话可以搭建一下。

docker run -d --name full-path -p 5000:5000 hausen1012/full-path

然后可以根据 快速搭建 nginx 的脚本 这篇文章进行搭建 nginx。

1. location不带，proxy_pass带：

location /api {
    proxy_pass http://127.0.0.1:5000/;
}

• 当请为/api/时，Nginx 会 308 重定向到/api。

• 当请求匹配到/api时，Nginx会将请求转发给http://127.0.0.1:5000/。

• 如果请求是 /api/path1/path2，则会转发到 http://127.0.0.1:5000//path1/path2。

需要注意的是，这里如果后面不带 /，可能会导致双斜杠问题。(一般来说不会出问题，除非不允许使用双斜杠)

2. location带，proxy_pass带：

location /api/ {
    proxy_pass http://127.0.0.1:5000/;
}

• 当请求匹配到/api时，Nginx 会 301 重定向到/api/。

• 当请求匹配到/api时，Nginx会将请求转发给http://127.0.0.1:5000/。

• 如果请求是 /api/path1/path2，则会转发到 http://127.0.0.1:5000/path1/path2。

由上面两点得知，当proxy_pass带斜杠时，location部分是要被切割的部分，切割的内容具体取决于location的内容是否带斜杠，所以这就有可能导致双斜杠的问题。

3. location不带，proxy_pass不带：

location /api {
    proxy_pass http://127.0.0.1:5000;
}

• 当请求匹配到/api时，Nginx会将请求转发给http://127.0.0.1:5000/api。

• 如果请求是 /api/path1/path2，则会转发到 http://127.0.0.1:5000/api/path1/path2。

4. location带，proxy_pass不带：

location /api/ {
    proxy_pass http://127.0.0.1:5000;
}

• 当请求匹配到/api时，Nginx 会 301 重定向到/api/。

• 当请求匹配到/api/时，Nginx会将请求转发给http://127.0.0.1:5000/api/。

• 如果请求是 /api/path1/path2，则会转发到 http://127.0.0.1:5000/api/path1/path2。

结论

先说结论，proxy_pass路径带不带斜杠影响是否进行拼接location匹配的路径，如果带斜杠则不拼接，不带则拼接。而location带不带斜杠影响不是很大，带斜杠一定没问题，不带斜杠可能导致双斜杠问题。

那么这样的话可以规范一下配置文件的配置方式。

1. 所有的请求都转发到一个后端

location / {
    proxy_pass http://127.0.0.1:5000/;
}

这个是怎么配置都不会出问题的。

2. 需要截掉location部分

location /gateway/ {
    proxy_pass http://127.0.0.1:5000/;
}

都以斜杠结尾，不会有双斜杠问题。如果location是截取部分，那么可以这样操作。

location /gateway/api/ {
    proxy_pass http://127.0.0.1:5000/api/;
}

3. 代理后地址需要包含location部分

location /nacos/ {
    proxy_pass http://127.0.0.1:5000/nacos/;
}

比如 nacos 这种本来就有基础路径，那么还是在 proxy_pass 后面加上路径并带上斜杠即可。如果是多级路径，那么可以这样操作。

location /nacos/v1/ {
    proxy_pass http://127.0.0.1:5000/nacos/v1/;
}

提醒：本文发布于241天前，文中所关联的信息可能已发生改变，请知悉！

共计 3147 个字符，预计需要花费 8 分钟才能阅读完成。

概念

• 线程池是一组预先创建的线程，用于执行任务。

• 线程池可以重用线程，避免频繁地创建和销毁线程，提高性能和资源利用率。

• 线程池可以根据需要调整线程数量，并提供任务调度和管理的功能。

四种线程池

1. 固定大小线程池

创建方式：Executors.newFixedThreadPool()

线程池中的线程数量是固定的，任务会被放入任务队列等待执行。当有新任务提交时，如果有空闲线程可用，立即执行任务；否则，任务会等待直到有空闲线程为止。

2. 缓存线程池

创建方式：Executors.newCachedThreadPool()

缓存线程池中的线程数量是动态变化的，根据任务的数量自动调整。如果有空闲线程可用，任务会立即分配给空闲线程执行；否则，会创建新的线程来执行任务。

3. 单线程线程池

创建方式：Executors.newSingleThreadExecutor()

单线程线程池中只有一个线程在执行任务，保证任务的顺序性。所有提交的任务按顺序执行，适用于需要顺序执行任务的场景。

4. 定时任务线程池

创建方式：Executors.newScheduledThreadPool()

定时任务线程池可以执行定时任务和周期性任务。除了执行普通任务外，还可以执行延迟任务和周期性任务。

测试方法

以下是几种线程池的测试方法。

public class ThreadPoolTest {

    /**
     * 当有新任务提交时，如果线程池中有空闲线程，则立即执行；如果没有空闲线程，则任务会被放入任务队列等待执行，直到有空闲线程为止。
     * 结果：线程基本是2个2个一起执行的，打印基本是两行一起
     */
    @Test
    public void test1() throws InterruptedException {
        // 固定大小线程池
        ExecutorService fixedThreadPool = Executors.newFixedThreadPool(2);
        System.out.println("实际创建的线程池对象:" + fixedThreadPool);
        submitTasks(fixedThreadPool, "固定大小线程池");
        Thread.sleep(6000);
        fixedThreadPool.shutdown();
    }

    /**
     * 有任务提交给缓存线程池时，如果有空闲线程可用，那么任务将被立即分配给一个空闲线程执行。如果没有空闲线程可用，缓存线程池会创建一个新的线程来执行任务。
     * 结果：基本是一次性执行完毕
     */
    @Test
    public void test2() throws InterruptedException {
        // 缓存线程池
        ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
        submitTasks(cachedThreadPool, "缓存线程池");
        Thread.sleep(3000);
        cachedThreadPool.shutdown();
    }

    /**
     * 创建一个单线程的线程池，该线程池中只有一个线程在执行任务。所有提交的任务按顺序执行，保证任务的顺序性。
     * 结果：线程一个个执行，控制台一行行打印
     */
    @Test
    public void test3() throws InterruptedException {
        // 单线程线程池
        ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
        submitTasks(singleThreadExecutor, "单线程线程池");
        Thread.sleep(12000);
        singleThreadExecutor.shutdown();
    }

    /**
     * 创建一个定时任务线程池，可以用于执行定时任务和周期性任务。除了可以执行普通任务外，该线程池还可以执行延迟任务和周期性任务。
     * 结果：每2秒打印一次
     */
    @Test
    public void test4() throws InterruptedException {
        // 创建定时任务线程池
        ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(2);
        System.out.println("实际创建的线程池对象:" + scheduledThreadPool);
        scheduleTasks(scheduledThreadPool, "定时任务线程池");
        Thread.sleep(10000);
        scheduledThreadPool.shutdown();
    }

    /**
     *  execute 用于执行没有返回的线程 - 参数为 Runnable 对象，返回值为 void
     *  submit 用于执行有返回结果的线程 - 参数为 Runnable 对象，返回值 Future 对象
     */
    @Test
    public void test5() throws ExecutionException, InterruptedException {
        // 创建 ExecutorService
        ExecutorService executorService = Executors.newFixedThreadPool(2);
        // 线程1，仅打印，无返回值
        executorService.execute(() -> {
            for(int i=0; i<5; i++){
                System.out.println("无返回值线程第" + (i+1) + "次执行....");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        });
        Future<Integer> future = executorService.submit(() -> {
            // 任务的执行逻辑
            Thread.sleep(3000);
            System.out.println("有返回值线程执行完成...");
            return 42;
        });
        System.out.println(future.get());
        Thread.sleep(12000);
    }

    private static void submitTasks(ExecutorService executor, String poolName) {
        System.out.println("===========" + poolName + "开始执行任务==========");
        for (int i = 1; i <= 10; i++) {
            final int taskId = i;
            executor.submit(() -> {
                System.out.println(poolName + "执行任务" + taskId);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
        }
    }

    private static void scheduleTasks(ScheduledExecutorService executor, String poolName) {
        System.out.println("===========" + poolName + "开始执行定时任务==========");
        ScheduledFuture<?> scheduledFuture = executor.scheduleAtFixedRate(() -> {
            System.out.println(poolName + "执行定时任务，时间：" + new Date());
        }, 0, 2, TimeUnit.SECONDS);
        System.out.println(scheduledFuture);
    }
}

提醒：本文发布于238天前，文中所关联的信息可能已发生改变，请知悉！

共计 570 个字符，预计需要花费 2 分钟才能阅读完成。

现在很多浏览器的 api 都需要在 https 协议下才能访问，比如之前写过的 Docker 搭建批量文件重命名工具 还有 Docker 搭建 web 思维导图 等等。

想要搭建一个测试或者开发环境的话，如果直接搭建 nginx，还需要修改配置文件和制作证书，于是想着直接做一个带有证书的 nginx 镜像算了，目前的话是制作了一个 100 年有效期的自签名证书。

使用方式如下：

docker run -d --name nginx -p 80:80 -p 443:443 hausen1012/nginxssl

如果你想自定义证书，那么此时你需要将你的证书文件夹映射到 /etc/nginx/conf/cert 目录，如果你不想修改 nginx 默认配置文件的话，请将你的证书名修改为 localhost.crt，密钥文件修改为 localhost.key。

docker run -d \
--name nginx \
-p 80:80 \
-p 443:443 \
-v /home/docker/mindmap/cert:/etc/nginx/conf/cert \
hausen1012/nginxssl

当然也提供了 alpine 镜像，这个适合用来当作 docker 镜像的基础镜像，比如现在 hausen1012/rename 和 hausen1012/mindmap 镜像都是以 hausen1012/nginxssl:alpine 为基础镜像的。

提醒：本文发布于238天前，文中所关联的信息可能已发生改变，请知悉！