作者： 清朝云

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

Java 枚举类（Enum）是一种特殊的数据类型，用于定义一组常量。

例如 web 请求状态码枚举类如下：

public enum ResultCode {

    /**
     * 请求成功状态码
     */
    SUCCESS(200, "成功"),

    /**
     * 请求失败状态码
     */
    FAIL(1000, "失败");

    private int code;
    private String msg;
    private static final Map<Integer, ResultCode> codeMsgMap = new HashMap<>();
    private static final Map<String, ResultCode> msgCodeMap = new HashMap<>();

    static {
        for (ResultCode resultCode : ResultCode.values()) {
            codeMsgMap.put(resultCode.getCode(), resultCode);
            msgCodeMap.put(resultCode.getMsg(), resultCode);
        }
    }

    ResultCode(int code, String msg){
        this.code = code;
        this.msg = msg;
    }
    public int getCode() {
        return code;
    }
    public String getMsg() {
        return msg;
    }

    public static Map<Integer, ResultCode> getCodeMsgMap() {
        return codeMsgMap;
    }
    public static Map<String, ResultCode> getMsgCodeMap() {
        return msgCodeMap;
    }

    public static ResultCode getMsgByCode(int code){
        for (ResultCode resultCode : ResultCode.values()) {
           if(resultCode.getCode() == code){
               return resultCode;
           }
        }
        return null;
    }
}

常见用法，一下列举出了枚举类的常见用法：

public class EmunTest {

    /**
     * 枚举类基本使用
     */
    @Test
    public void test1() {
        System.out.println(ResultCode.SUCCESS.getMsg() + ": " + ResultCode.SUCCESS.getCode());
    }

    /**
     * 枚举类遍历
     */
    @Test
    public void test2() {
        for (ResultCode resultCode : ResultCode.values()) {
            System.out.println("Code: " + resultCode.getCode());
            System.out.println("Message: " + resultCode.getMsg());
            System.out.println("--------------------------");
        }
    }

    /**
     * 测试自己写的 getByCode 方法获取枚举常量
     */
    @Test
    public void test3() {
        int code = 1000;
        ResultCode resultCode = ResultCode.getByCode(code);
        if (resultCode != null) {
            System.out.println(resultCode.getMsg() + ": " + resultCode.getCode());
        }
    }

    /**
     * 通过静态代码块，通过 map 获取枚举常量
     */
    @Test
    public void test4() {
        // 通过 code 获取枚举常量
        int code = 200;
        ResultCode resultCode = ResultCode.getCodeMsgMap().get(code);
        if (resultCode != null) {
            System.out.println(resultCode.getMsg() + ": " + resultCode.getCode());
        }

        // 通过 msg 获取枚举常量
        String msg = "失败";
        ResultCode resultCode2 = ResultCode.getMsgCodeMap().get(msg);
        if (resultCode2 != null) {
            System.out.println(resultCode2.getMsg() + ": " + resultCode2.getCode());
        }
    }
}

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

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

介绍

流是用了读取和写出数据的对象，下面是常见的一些对象即使用方法。

1. 字节流

• InputStream：用于从字节流中读取数据。

  InputStream 为抽象类，常见的继承类：FileInputStream、BufferedInputStream、DataInputStream、ObjectInputStream。

• OutputStream：用于向字节流中写入数据。

  OutputStream 同样为抽象类，常见继承类：FileOutputStream、BufferedOutputStream、DataOutputStream、ObjectOutputStream

2. 字符流

• Reader：用于从字符流中读取数据。

  Reader 也为抽象类，常见的继承类：FileReader、InputStreamReader、BufferedReader、StringReader。

• Writer：用于向字符流中写入数据。

  Writer 为抽象类，常见的继承类：FileWriter、OutputStreamWriter、BufferedWriter、StringWriter。

3. 缓冲流

缓冲流内置了缓冲区，将磁盘内容先读取到缓冲区即内存中，一般默认大小为 8K，获取字节或字符时直接从内存中取出，减少了和磁盘打交道的次数。

• BufferedInputStream：提供了缓冲功能的字节输入流。

• BufferedOutputStream：提供了缓冲功能的字节输出流。

• BufferedReader：提供了缓冲功能的字符输入流。

• BufferedWriter：提供了缓冲功能的字符输出流。

4. 文件流

• FileInputStream：用于从文件中读取数据的字节流。

• FileOutputStream：用于向文件中写入数据的字节流。

• FileReader：用于从文件中读取数据的字符流。

• FileWriter：用于向文件中写入数据的字符流。

5. 转换流

• InputStreamReader：将字节流转换为字符流的转换流。

• OutputStreamWriter：将字符流转换为字节流的转换流。

6. 数据流

支持读写基本数据类型和字符串，但是不支持读写对象类型。

• DataInputStream：用于读取基本数据类型和字符串的流。

• DataOutputStream：用于写入基本数据类型和字符串的流。

7. 对象流

支持基本类型和字符串的读写，同时也从支持对实现了Serializable 接口的对象进行序列化和反序列化。

• ObjectInputStream：用于读取对象的流。

• ObjectOutputStream：用于写入对象的流。

基本使用

以下内容是对上面各种输入输出流的一些测试方法：

public class IOTest {

    /**
     * 字节流 InputStream OutputStream
     * 1. 利用输入流，读取 file.txt, 将字符打印在控制台
     * 2. 利用输出流，复制 file.txt 里面的内容，追加到 file_copy.txt
     */
    @Test
    public void test1() throws IOException {
        String inputFile = "file/io/file.txt";
        String outPutFile = "file/io/file_copy.txt";
        initFileTxt(inputFile);  // 初始化文件内容为：你好啊amjun
        // try-with-resources 语句
        try (InputStream inputStream = new FileInputStream(inputFile);
             OutputStream outputStream = new FileOutputStream(outPutFile);) {
            int byteData;
            while ((byteData = inputStream.read()) != -1) {
                // byteData 是读取到的单个字节，因为这种读取方式是单个字符读取的
                // 打印中文时会乱码，因为中文在utf-8中是三个字节为一个字符
                System.out.println(byteData + "  " + (char)byteData);
                outputStream.write(byteData);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * 使用缓冲区进行数据读取
     * 1. 创建一个字节数组作为缓冲区
     * 2. 输入流读取字节时，将字节读入缓冲区
     * 3. 打印时，通过缓冲区的内容创建一个字符串
     * 4. 写入文件时，将缓冲区的内容一次性写入
     */
    @Test
    public void test2(){
        String inputFile = "file/io/file.txt";
        String outPutFile = "file/io/file_buffer_copy.txt";
        initFileTxt(inputFile); // 初始化文件内容为：你好啊amjun
        try (InputStream inputStream = new FileInputStream(inputFile);
             OutputStream outputStream = new FileOutputStream(outPutFile);) {
            // 创建临时字节数组缓冲区
            byte[] buffer = new byte[1024];
            int bytesRead;
            while ((bytesRead = inputStream.read(buffer)) != -1) {
                // bytesRead 是读取到的字节数，当字节少于1024时，一次性全部读取并打印，所以打印不会乱码
                System.out.print(new String(buffer, 0 , bytesRead));
                // 字节数为 14，因为3中文+5英文，中文3个字节1个字符，英文1个字节1个字符
                System.out.println("\n读取到的字节数：" + bytesRead);
                outputStream.write(buffer, 0, bytesRead);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * 字节缓冲流 BufferedInputStream BufferedOutputStream
     * 引入了缓冲区，缓冲区的存在可以减少和磁盘之间的交互次数，提高读写效率。有需要可以打印时间进行测试
     * 缓冲区会一次读取一定量的数据，然后在内存中进行操作，直到缓冲区被填满或者操作完成后再写回磁盘。
     */
    @Test
    public void test3(){
        String inputFile = "file/io/file.txt";
        String outPutFile = "file/io/file_buffer2_copy.txt";
        initFileTxt(inputFile); // 初始化文件内容为：你好啊amjun
        try (BufferedInputStream bufferedInputStream = new BufferedInputStream(new FileInputStream(inputFile));
             BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(new FileOutputStream(outPutFile))) {
            // 创建临时字节数组缓冲区
            int bytesRead;
            while ((bytesRead = bufferedInputStream.read()) != -1) {
                // 该乱码还是乱码，因为即使内部实现了缓冲区，但是读取的字节还是一个个读取出来的，但是字节的读取是在内存中读的，而不是在磁盘中
                System.out.println(bytesRead + "  " + (char)bytesRead);
                bufferedOutputStream.write(bytesRead);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * 字符流转换流 InputStreamReader OutputStreamWriter
     * 1. 先将文件读取为字节流，然后用字符流包装，输出流文件也是如此
     * 2. 创建一个字符数组作为缓冲区
     * 3. 将文件读取到字符缓冲区
     * 4. 将字符缓冲区的内容打印和写入
     */
    @Test
    public void test4(){
        String inputFile = "file/io/file.txt";
        String outPutFile = "file/io/file_buffer_copy.txt";
        initFileTxt(inputFile); // 初始化文件内容为：你好啊amjun
        try (InputStreamReader reader = new InputStreamReader(new FileInputStream(inputFile));
             OutputStreamWriter writer = new OutputStreamWriter(new FileOutputStream(outPutFile));) {
            // 创建临时字符数组缓冲区
            char[] buffer = new char[1024];
            int charsRead;
            while ((charsRead = reader.read(buffer)) != -1) {
                // 将读取到的字符写入控制台，由于字符数小于1024，会一次性全部输出
                System.out.print(new String(buffer, 0, charsRead));
                // 3中文字符+5英文字符
                System.out.println("\n读取到的字符数：" + charsRead);
                // 将读取的数据追加到目标文件中
                writer.write(buffer, 0, charsRead);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * 字符缓冲流 BufferedReader BufferedWriter
     */
    @Test
    public void test5(){
        String inputFile = "file/io/file.txt";
        String outPutFile = "file/io/file_buffer_copy.txt";
        initFileTxt(inputFile); // 初始化文件内容为：你好啊amjun
        // 装饰器模式
        try (BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(new FileInputStream(inputFile)));
             BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(outPutFile)))) {
            // 创建临时字符数组缓冲区
            char[] buffer = new char[1024];
            int charsRead;
            while ((charsRead = bufferedReader.read(buffer)) != -1) {
                // 将读取到的字符写入控制台，由于字符数小于1024，会一次性全部输出
                System.out.print(new String(buffer, 0, charsRead));
                // 3中文字符+5英文字符
                System.out.println("\n读取到的字符数：" + charsRead);
                // 将读取的数据追加到目标文件中
                bufferedWriter.write(buffer, 0, charsRead);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     *  字符流 FileReader FileWriter
     */
    @Test
    public void test6() throws IOException {
        String inputFile = "file/io/file.txt";
        String outPutFile = "file/io/file_buffer_copy.txt";
        initFileTxt(inputFile); // 初始化文件内容为：你好啊amjun
        try (Reader reader = new FileReader(inputFile);
            Writer writer = new FileWriter(outPutFile);) {
            // 创建临时字符数组缓冲区
            char[] buffer = new char[1024];
            int charsRead;
            while ((charsRead = reader.read(buffer)) != -1) {
                // 将读取到的字符写入控制台，由于字符数小于1024，会一次性全部输出
                System.out.print(new String(buffer, 0, charsRead));
                // 3中文字符+5英文字符
                System.out.println("\n读取到的字符数：" + charsRead);
                // 将读取的数据追加到目标文件中
                writer.write(buffer, 0, charsRead);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 数据流 DataInputStream DataOutputStream
     * 只支持读写基本数据类型和字符串
     */
    @Test
    public void test7() {
        String obgFile = "file/io/data.bin";
        try (DataOutputStream dataOutputStream = new DataOutputStream(new FileOutputStream(obgFile))) {
            dataOutputStream.writeInt(19);
            System.out.println("写入基本数据类型成功...");
        } catch (Exception e) {
            e.printStackTrace();
        }

        try (DataInputStream dataInputStream = new DataInputStream(new FileInputStream(obgFile));) {
            int i = dataInputStream.readInt();
            System.out.println("读取基本类型数据：" +  i);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 对象流 ObjectInputStream ObjectOutputStream
     * 对象流不能使用字符流进行包装，因为O对象流是基于字节流的，用于写入对象的二进制表示。而字符流主要用于处理字符数据。
     */
    @Test
    public void test8() {
        // 序列化对象
        String obgFile = "file/io/obj.bin";
        try (ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream(obgFile))) {
            User user = new User().setName("zhangsan").setAge(18);
            objectOutputStream.writeObject(user);
            System.out.println("写入对象成功...");
        } catch (Exception e) {
            e.printStackTrace();
        }

        // 反序列化对象
        try (ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream(obgFile));) {
            User user = (User)objectInputStream.readObject();
            System.out.println("读取的对象为：" + user);
        } catch (Exception e) {
            e.printStackTrace();
        }

    }

    /**
     * 初始化文件内容
     */
    public void initFileTxt(String outputFile){
        try(OutputStream outputStream = new FileOutputStream(outputFile);
        OutputStreamWriter writer = new OutputStreamWriter(outputStream)){
            String str = "你好啊amjun";
            // 将字符串以字节数组方式写入文件
            //byte[] byteArray = str.getBytes("UTF-8");
            //outputStream.write(byteArray);

            // 将文件以字符数组写入文件
            char[] charArray = str.toCharArray();
            writer.write(charArray);
        }catch (IOException e){

        }
    }
}

@Data
@Accessors(chain = true)
class User implements Serializable{

    public String name;

    public int age;
}

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

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

简介

线程是一种重要的概念，用于实现并发执行的多任务。

• 线程是程序执行的最小单元，它可以独立执行代码片段。

• 多线程允许在同一程序中同时执行多个任务，提高程序的并发性和响应能力。

• 线程可以共享内存空间，方便数据交换和通信。

三种方式创建线程

1. 继承Thread类

可以通过继承 Thread 类，并重写 run() 方法，在需要的地方调用 start 方法进行执行线程。

注意：需要调用 start 方法才能看见线程效果，调用 run 方法只是在当前线程同步执行 run 方法。

如果需要执行的逻辑代码只在一个地方出现，那么可以使用 Lambda 表达式的方式给

public class ThreadTest {

    /**
     * 继承自 Thread 的类
     * 1. 需要调用 start 方法才能看见线程效果，调用 run 方法只是在当前线程同步执行 run 方法
     */
    public static void main(String[] args) {
        new MyThread("线程1", 5).start();

        new MyThread("线程2", 2).start();
    }
}

class MyThread extends Thread {
    int count;

    MyThread(String name, int count){
        super(name);
        this.count = count;
    }

    @Override
    public void run() {
        System.out.println(getName() + "开始执行，时间：" + new Date());
        try {
            for (int i=0; i < count; i++){
                System.out.println(getName() + "第" + (i+1) + "次执行....");
                Thread.sleep(1000);
            }

        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        System.out.println(getName() + "执行完毕，时间：" + new Date());
    }
}

2. 实现Runnable接口

首先需要注意的是，实现 Runnable 接口的方式，其实还是要将实现类作为构造参数传递给 Thread 类，通过 Thread 的 start 方法开辟一个线程。

另外，Runnable 接口是一个函数式接口，可以通过 Lambda 表达式创建实现类。

public class RunnableTest {

    /**
     * 为什么需要通过Thread执行Runnable对象
     * 1. 线程管理：Thread类提供了对线程的管理和控制。它包含了一些方法，例如start()来启动线程，join()来等待线程完成，
     *      interrupt()来中断线程等。通过Thread类，可以更方便地控制线程的生命周期和执行。
     * 2. 线程调度：Thread类提供了线程调度的功能。线程调度是指决定线程执行顺序和时间片分配的过程。
     *      通过Thread类，可以设置线程的优先级、睡眠时间和调度策略等。
     * 3. 线程上下文：Thread类维护了线程的上下文信息，例如线程名称、线程状态、线程组等。
     *      通过Thread类，可以方便地获取和设置这些信息。
     */
    public static void main(String[] args) {
        MyRunnable runnable1 = new MyRunnable("线程1", 5);
        Thread thread1 = new Thread(runnable1);
        thread1.start();

        // Lambda 表达式创建线程
        new Thread(() -> {
            System.out.println( "线程2开始执行，时间：" + new Date());
            try {
                for (int i=0; i < 2; i++){
                    System.out.println("线程2第" + (i+1) + "次执行....");
                    Thread.sleep(1000);
                }

            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println("线程2执行完毕，时间：" + new Date());
        }).start();
    }
}

class MyRunnable implements Runnable {
    private String name;
    private int count;

    MyRunnable(String name, int count) {
        this.name = name;
        this.count = count;
    }

    @Override
    public void run() {
        System.out.println(name + "开始执行，时间：" + new Date());
        try {
            for (int i=0; i < count; i++){
                System.out.println(name + "第" + (i+1) + "次执行....");
                Thread.sleep(1000);
            }

        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        System.out.println(name + "执行完毕，时间：" + new Date());
    }
}

3. 实现Callable接口

前面两种方式都是通过重写 run 方法实现多线程，需要注意的是 run 方法返回值是 void，也就是说无法获取线程的执行结果，于是 Callable 出现了。

这种方式需要通过线程池的方式进行调用，首先需要创建一个线程池，然后创建一个 Callable 接口的实现类，使用线程池的 submit 或 execute 执行线程中的代码。

而这两个方法的区别是， execute 方法是无返回值的，效果和上面的方式一样。而 submit 是有返回值的，返回的是一个 Future<T> 接口类型的对象，通过该接口的 get 方法可以获取到返回值。

public class CallableTest {

    /**
     *
     * @param args
     */
    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(2);
        System.out.println("实际创建的线程池对象:" + executor);

        Callable<String> task1 = new MyCallable("线程1", 5);
        Future<String> future1 = executor.submit(task1);
        System.out.println("实际创建的Future对象:" + future1);

        Callable<String> task2 = new MyCallable("线程2", 2);
        Future<String> future2 = executor.submit(task2);

        executor.shutdown();

        try {
            // 这里是阻塞的，需要等待获取结果
            String result1 = future1.get();
            System.out.println(result1);

            // 虽然线程2比线程1早执行完，但是需要等待线程1执行完毕。如果放在线程1之前获取返回值，则先打印线程2执行完毕
            String result2 = future2.get();
            System.out.println(result2);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

class MyCallable implements Callable<String> {
    private String name;
    private int count;

    public MyCallable(String name, int count) {
        this.name = name;
        this.count = count;
    }

    @Override
    public String call() throws Exception {
        //System.out.println(name + "开始执行，时间：" + new Date());
        for (int i=0; i < count; i++){
            System.out.println(name + "第" + (i+1) + "次执行....");
            Thread.sleep(1000);
        }
        //System.out.println(name + "执行完毕，时间：" + new Date());
        return name + "执行完毕!!!!!!!";
    }
}

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

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

1. 简介及安装

云可云是一个支持照片管理、影音管理、文件浏览器和文件共享等功能的多功能管理软件，支持 window、mac、移动端甚至是 docker 进行安装，且界面非常美观，功能也非常全面。

以下就是 docker 的安装方式：

docker run -d \
--name nascab \
-p 8080:80 \
-p 8443:443 \
-p 8090:90 \
-p 8021:21 \
-v /home/docker/nascab/mydata:/mydata \
-v /home/docker/nascab/data:/root/.local/share/nascab \
ypptec/nascab

以上命令映射了两个端口，8080 是用于 web 访问的端口，,8443用于 https，8090 是用于 Webdav 服务端口，8021 是 ftp 端口。映射的文件夹 mydata 是用于存储自己的文件，如照片、视频等数据，data 数据是NasCab 的数据库和缓存目录。

首先就是设置管理员账号密码。

/>

2. 首页展示

接下来进入到首页，可以看见磁盘、CPU、内存等基本信息，因为现在还没添加照片视频等信息，所以还没有展示。

/>

3. 照片管理

进入照片管理，提示需要设置来源目录，因为 nascab 需要进行扫描，所以清朝云在 mydata 目录下新建 photo 照片目录作为示例。

/>

点击右上角进行图片上传，选择刚刚创建的 photo 目录，上传后点击刷新索引。

/>

接下来可以在时间轴看见上传的照片。

/>

4. 影视管理

接下来同样的操作，添加 video 文件夹，上传视频文件。

/>

点击播放是可以在线播放的。

/>

5. 文件浏览

点击首页的文件浏览，同样可以进入目录进行查看文件，这里进入刚刚创建的 photo 文件夹。

/>

6. 文件备份

此外，还支持备份，且支持单次、每天、每周、每月备份。

/>

7. 文件分享

支持 webdav、ftp 文件共享，此功能清朝云暂未测试。

/>

8. 安全中心

这里是为了保障系统的安全，防止暴露公网后被暴力破解等措施。

/>

9. 设置

这里是一些系统的设置，如用户管理、系统语言、端口等等。

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

/>

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

下载了一些视频，感觉默认有点大，于是准备使用 ffmpeg 进行压缩，用了如下命令感觉效果还不错。

ffmpeg -i input.mp4 -c:v libx264 -crf 23 -preset medium -c:a aac -b:a 128k output.mp4

但是需要压缩的视频有点多，并且我的视频是分类好的，不想压缩的时候整到一个文件夹去到时候又要分文件夹，所以借助 gpt 写出了此脚本，不得不说虽然有 gpt 还是踩坑不少的。

这个脚本能保证原来的目录结构，只需要指定输出目录即可。

@echo off
chcp 65001 > nul
setlocal enabledelayedexpansion

rem 设置 ffmpeg 路径、需要压缩的文件目录，输出文件目录
set "ffmpeg_path=D:\soft\ffmpeg\bin\ffmpeg.exe"
set "input_dir=E:\test3"
set "output_root_dir=E:\Compress"

for /r "%input_dir%" %%F in (*.mp4) do (
    set "input_file=%%F"
    echo 待压缩文件: !input_file!
    call set "output_file=!input_file:%input_dir%=%output_root_dir%!"
    rem echo 压缩后文件: !output_file!
    for %%I in ("!output_file!") do set "output_dir=%%~dpI"
    rem echo 输出目录: !output_dir!
    mkdir "!output_dir!" 2>nul

    rem 检查输入文件是否存在
    if exist "!output_file!" (
        rem 调用函数比较输入文件和输出文件的时长
    echo 输出文件已存在: !output_file!
    call :compare_durations "!input_file!" "!output_file!"
    )else (
    call :compress_file "!input_file!" "!output_file!"
    )

    echo "================================分隔符================================"
)

echo 脚本执行完成！！！！！按任意键退出.
pause

rem  方法===比较视频时长
:compare_durations
set "input_file=%~1"
set "output_file=%~2"

rem 获取输入文件、输出文件的时长
for /F "delims=" %%A in ('%ffmpeg_path% -i "!input_file!" 2^>^&1 ^| findstr /C:"Duration"') do (
    set "input_duration=%%A"
)
for /F "delims=" %%B in ('%ffmpeg_path% -i "!output_file!" 2^>^&1 ^| findstr /C:"Duration"') do (
    set "output_duration=%%B"
)

for /F "tokens=2 delims= " %%C in ("!input_duration!") do (
    set "input_duration=%%C" 
)
for /F "tokens=2 delims= " %%D in ("!output_duration!") do (
    set "output_duration=%%D"
)

rem 忽略毫秒级别比较
for /F "tokens=1 delims=." %%F in ("!input_duration!") do (
    set "input_duration=%%F"
)
for /F "tokens=1 delims=." %%G in ("!output_duration!") do (
    set "output_duration=%%G"
)

rem 比较输入文件和输出文件的时长
rem echo "%input_file%"  时长 ==== "!input_duration!"
rem echo "%output_file%" 时长 ==== "!output_duration!"
if "!input_duration!" neq "!output_duration!" (
    echo 时长不一致，重新压缩文件...
    call :compress_file "!input_file!" "!output_file!"
) else (
    echo 时长一致，无需重新压缩文件.
)

goto :eof

rem 方法===压缩文件
:compress_file
set "input_file=%~1"
set "output_file=%~2"
echo 正在压缩文件: !input_file! 请稍等...
"%ffmpeg_path%" -loglevel quiet -i "!input_file!" -c:v libx264 -crf 23 -preset medium -c:a aac -b:a 128k "!output_file!" -y -progress progress.txt 2>&1 | findstr "time=" > con
echo 压缩完成，输出文件为: !output_file! 请稍等...
call :compare_durations "!input_file!" "!output_file!"

goto :eof

执行效果：

/>

如图，已经压缩过的文件如果时长一致，则不进行再次压缩浪费时间；如果时长不一致，那么要进行压缩然后覆盖；如果没有压缩过的文件，直接进行压缩，压缩完再对比时长。

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

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

之前也写过 jenkins 微服务打包的教程，可以打包单个模块，但是如果需要一次性打包全部就实现不了了，这次优化了一下脚本。

如果有不了解的，可以先看看这两篇文章 Jenkins 打包微服务教程-一个配置文件即可打包所有模块，Jenkins 打包微服务流程优化。

不过这次需要用到 Extended Choice Parameter 插件，因为需要在构建时传参，但是 jenkins 默认不支持传多选，需要通过这个插件。

插件的使用也比较简单，在添加参数时选择 Extended Choice Parameter。

/>

然后按如下图填写即可。

/>

接下来就可以按住 ctrl 键配合鼠标进行多选了，也可以按住 shift 选择一个区间。

接下来就是配置源码地址，maven 的打包可以不需要，如果实在需要可以设置命令为 mvn dependency:tree，因为接下来会在脚本进行打包。

脚本如下，注意这里需要配置三个参数，分别是 all_module-候选打包模块，all_host-候选打包主机，branch-git分支，这个分支变量需要配置为 git 变量，其他两个使用上面的插件配置。

#!/bin/bash

# 0. 准备 1. 指定打包mvn路径 2. 获取打包的所有模块 3. 获取打包的所有主机
maven_command="/var/jenkins_home/tools/hudson.tasks.Maven_MavenInstallation/maven3.6/apache-maven-3.6.1/bin/mvn"
IFS=',' read -ra modules <<< "$all_module"
IFS=',' read -ra hosts <<< "$all_host"

echo "===============本次选择打包的模块 "$all_module"==============="
# 1. 打包
skip_tests="-Dmaven.test.skip=true"
for module in "${modules[@]}"
do
     echo "===============模块 "$module" 执行 mvn install==============="
     $maven_command clean install -pl ${module} -am $skip_tests
done

# 2. 构建镜像并保存
for module in "${modules[@]}"
do
    ## 构建镜像
    cd "${WORKSPACE}/${module}"
    serviceName="${module#*/}"
    current=$(date -d "8 hours" +"%Y%m%d-%H%M")
    branch_name=$(echo "${branch}" | sed 's/\//-/g')
    #imageName="${serviceName}-${branch_name}:${current}"
    imageName="${serviceName}:${branch_name}-${current}"
    tarName="${serviceName}-${current}.tar"
    jarFile=$(ls target/ | grep \.jar$)
    mv "target/${jarFile}" .
    docker build --build-arg JAR_FILE="${jarFile}" -t "${imageName}" .

    ## 保存镜像-保存在 jenkins 主目录下的 images 文件夹
    imagesDir="${JENKINS_HOME}/images/$JOB_NAME/${serviceName}"
    mkdir -p "${imagesDir}"
    docker save -o "${imagesDir}/${tarName}" "${imageName}"
    cp "${imagesDir}/${tarName}" target/

    ## 清理镜像
    docker rmi -f $(docker images | grep "${serviceName}" | awk 'NR>0 {print $3}')
    ## tar包保留指定数量
    cd "${imagesDir}"
    retainNumber=3
    rm -f $(ls -t | awk "NR>${retainNumber}")
done

# 3. 部署
# 准备工作 -> 1. 定义主机 2.获取工作目录 3. 连接新主机不询问是否添加到known_hosts
cd ${WORKSPACE}
cat > hosts.txt <<EOF
172.26.1.21 root xxx dev_test "-e ACTIVE=pro -e NACOS_URL=172.26.1.21"
EOF
grep -q 'StrictHostKeyChecking no' /etc/ssh/ssh_config || echo 'StrictHostKeyChecking no' >> /etc/ssh/ssh_config

#==========定义远程执行脚本文件开始==========
cd ${WORKSPACE}
cat << 'EOF' > script.sh
#!/bin/bash
cd /tmp/robot-patrol-platform
tarName=$(ls *.tar -1t | head -n 1)
imageName=$(docker load -i ${tarName} |  cut -d' ' -f3)
containerName=$(echo ${imageName} | cut -d: -f1)
# 删除原来的容器，并新建一个容器
if docker ps -a| grep "${containerName}" >/dev/null 2>&1; then docker rm -f ${containerName} ; fi
docker run -d --net host $1 --restart=unless-stopped --name ${containerName} ${imageName}
# 删除无用的镜像，只保留最新的镜像
serviceName=${containerName}
if docker images | grep "${serviceName}" >/dev/null 2>&1; then docker rmi -f $(docker images | grep ${serviceName} |awk 'NR>1 {print $3}'); fi
# 删除临时文件夹
rm -rf /tmp/robot-patrol-platform/${tarName}
rm -rf /tmp/robot-patrol-platform/script.sh
echo "The script has been executed successfully."
EOF
#==========定义远程执行脚本文件结束==========

#==========定义任务函数开始==========
dotask () {
    echo "===============远程主机 "$ip" 开始执行任务==============="
    for module in "${modules[@]}"
    do 
      echo "===============远程主机 "$ip" 正在部署 "$module" ==============="
      ip=$1; username=$2; password=$3; environment=$4; param=$5
      sshpass -p $password ssh $username@$ip "mkdir -p /tmp/robot-patrol-platform"
      sshpass -p $password scp ${WORKSPACE}/${module}/target/*.tar $username@$ip:/tmp/robot-patrol-platform
      sshpass -p $password scp ${WORKSPACE}/script.sh $username@$ip:/tmp/robot-patrol-platform
      sshpass -p $password ssh $username@$ip "chmod +x /tmp/robot-patrol-platform/script.sh && /tmp/robot-patrol-platform/script.sh $param"
   done
   echo "===============远程主机 "$ip" 脚本执行完成==============="
}
#==========定义任务函数结束==========

while read -r ip username password environment param; do
  for host in "${hosts[@]}"; do
    if [ "$host" = "$environment" ] || [ "$host" = "$ip" ]; then
      dotask "$ip" "$username" "$password" "$environment" "$param"
    fi
  done
done < hosts.txt
echo "===============所有任务已完成==============="

当然，这样的方式有个弊端，就是 idea 插件并不支持多选参数，

还有一种方式，需要配置 single_module、host 都为单选，并且提供 all 这个选项，意思是打包全部模块或发送到全部主机。然后配置一个 all_module 字符变量，这个变量是模块以逗号分隔，另外一个就是分支变量了。

脚本如下：

#!/bin/bash
modules=${single_module}
# 如果选择该项目，则全部进行打包
maven_command="/var/jenkins_home/tools/hudson.tasks.Maven_MavenInstallation/maven3.6/apache-maven-3.6.1/bin/mvn"
skip_tests="-Dmaven.test.skip=true"
if [ ${single_module} == "all" ]; then
     IFS=',' read -ra modules <<< "$all_module"
     echo "===============全部模块执行 mvn install==============="
     $maven_command clean install $skip_tests
else
     echo "===============${single_module}模块执行 mvn install==============="
     $maven_command clean install -pl ${single_module} -am $skip_tests
fi
for module in "${modules[@]}"
do
    echo $module
    ## 构建镜像
    cd "${WORKSPACE}/${module}"
    serviceName="${module#*/}"
    current=$(date -d "8 hours" +"%Y%m%d-%H%M")
    branch_name=$(echo "${branch}" | sed 's/\//-/g')
    #imageName="${serviceName}-${branch_name}:${current}"
    imageName="${serviceName}:${branch_name}-${current}"
    tarName="${serviceName}-${current}.tar"
    jarFile=$(ls target/ | grep \.jar$)
    mv "target/${jarFile}" .
    docker build --build-arg JAR_FILE="${jarFile}" -t "${imageName}" .

    ## 保存镜像-保存在 jenkins 主目录下的 images 文件夹
    imagesDir="${JENKINS_HOME}/images/$JOB_NAME/${serviceName}"
    mkdir -p "${imagesDir}"
    docker save -o "${imagesDir}/${tarName}" "${imageName}"
    cp "${imagesDir}/${tarName}" target/

    ## 清理镜像
    docker rmi -f $(docker images | grep "${serviceName}" | awk 'NR>0 {print $3}')
    ## tar包保留指定数量
    cd "${imagesDir}"
    retainNumber=3
    rm -f $(ls -t | awk "NR>${retainNumber}")
done

# 准备工作 -> 1. 定义主机 2.获取工作目录 3. 连接新主机不询问是否添加到known_hosts
cd ${WORKSPACE}
cat > hosts.txt <<EOF
172.26.1.21 root xxx dev_test "-e ACTIVE=pro -e NACOS_URL=172.26.1.21"
EOF
grep -q 'StrictHostKeyChecking no' /etc/ssh/ssh_config || echo 'StrictHostKeyChecking no' >> /etc/ssh/ssh_config

#==========定义远程执行脚本文件开始==========
cd ${WORKSPACE}
cat << 'EOF' > script.sh
#!/bin/bash
cd /tmp/robot-patrol-platform
tarName=$(ls *.tar -1t | head -n 1)
imageName=$(docker load -i ${tarName} |  cut -d' ' -f3)
containerName=$(echo ${imageName} | cut -d: -f1)
# 删除原来的容器，并新建一个容器
if docker ps -a| grep "${containerName}" >/dev/null 2>&1; then docker rm -f ${containerName} ; fi
docker run -d --net host $1 --restart=unless-stopped --name ${containerName} ${imageName}
# 删除无用的镜像，只保留最新的镜像
serviceName=${containerName}
if docker images | grep "${serviceName}" >/dev/null 2>&1; then docker rmi -f $(docker images | grep ${serviceName} |awk 'NR>1 {print $3}'); fi
# 删除临时文件夹
rm -rf /tmp/robot-patrol-platform/${tarName}
rm -rf /tmp/robot-patrol-platform/script.sh
echo "The script has been executed successfully."
EOF
#==========定义远程执行脚本文件结束==========

#==========定义任务函数开始==========
dotask () {
      echo "===============远程主机 "$ip" 开始执行任务==============="
    for module in "${modules[@]}"
    do 
      echo "===============远程主机 "$ip" 正在部署 "$module" ==============="
      ip=$1; username=$2; password=$3; environment=$4; param=$5
      sshpass -p $password ssh $username@$ip "mkdir -p /tmp/robot-patrol-platform"
      sshpass -p $password scp ${WORKSPACE}/${module}/target/*.tar $username@$ip:/tmp/robot-patrol-platform
      sshpass -p $password scp ${WORKSPACE}/script.sh $username@$ip:/tmp/robot-patrol-platform
      sshpass -p $password ssh $username@$ip "chmod +x /tmp/robot-patrol-platform/script.sh && /tmp/robot-patrol-platform/script.sh $param"
   done
   echo "===============远程主机 "$ip" 脚本执行完成==============="
}
#==========定义任务函数结束==========

while read -r ip username password environment param; do
  if [ "$host" = "all" ]; then
    dotask $ip $username $password $environment "$param"
  elif [ "$host" = "$environment" ]; then
    dotask $ip $username $password $environment "$param"
  fi
done < hosts.txt
echo "===============所有任务已完成==============="

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