markdown图片离线备份，批量替换url

之前在某站写了很多笔记，最近想着迁移备份下，找到了接口写了个脚本将文章爬取下来了。文章是基于 Markdown 格式的，在写作时粘贴图片，直接上传到他们图床服务器了。Markdown 文本里面是个<img src="https://aaa.com/bbb.jpg">标签。

虽然笔记下载来了，本地看也没啥问题，但是万一哪天网站作妖就凉凉了，网站关停跑路了，线上图片挂了，或者升级做了防盗链等措施，那就不能愉快的玩耍了。

从我上网冲浪经历来看，这些事情时有发生。曾经丢失过，当时欲哭无泪，以后就怕，笔记还是得放一份自己本地心里踏实。

我常用的 Markdown 编辑器是 Typora 和 Obsidian，两者存在兼容差异。需要注意：

1. 插入图片通用格式 ![描述](https://aaa.com/bbb.jpg)
2. typora: <img src="https://aaa.com/bbb.jpg" />，typora 和 obsidian 都支持绝对路径，但后者尚不支持相对路径。参考方法：Typora插入图片后在Obsidian中显示（相对路径）
3. obsidian: 用特有格式: ![[aaa/bbb.jpg]] ，调整图片宽度 ![[aaa/bbb.jpg|600]]。
   详见：Obsidian论坛-讨论区
4. 图片转为 Base64 放进<img>标签的src。虽然只有一个 md 文件 All in one 很好，但我觉得比较丑陋，文本字数变得很多，以后复制图片也不方便。

因为我是用来备份，所以方便起见选择第一种方式，相对位置也不担心移动了文件夹图片就显示不了。

提取图片src的正则表达式：src="(https?:\S+.(jpg|jpeg|png|gif|webp|bmp|tiff|svg))"
推荐一个很好用的在线测试正则网站：正则表达式在线测试

全部代码：

/**
 * Markdown 网络图片下载器
 */
public class MarkdownImgDownloader {

    // 源 markdown 仓库目录
    private static final Path SOURCE_VAULT_PATH = Paths.get("K:\\Download\\笔记\\md文档");

    // 目标 markdown 仓库目录
    private static final Path TARGET_VAULT_PATH = Paths.get("C:\\Users\\Administrator\\Desktop\\md备份");

    // 资源目录名称(与 md 目标文件同层级,存储离线图片)
    private static final String ASSETS_DIRECTORY_NAME = "assets";

    // 简单日志记录
    private static final String LOG_FILE = TARGET_VAULT_PATH + File.separator + "log_" + Instant.now().getEpochSecond() + ".txt";
    private static int MD_COUNT, IMG_COUNT, ERROR_COUNT;
    private static final ArrayList<String> ERROR_STR = new ArrayList<>();

    /**
     * 配置 markdown 仓库源和目标目录；
     * 遍历源仓库,复制目录结构和 md 文件到目标仓库;
     * 每个 md 文件同级新建 assets 文件夹,assets 下新建 md 文件同名的文件夹用以存放离线图片；
     */
    public static void main(String[] args) {
        long startTime = Instant.now().getEpochSecond();
        log(">>>>> ALL_START:" + startTime);
        try {
            Files.createDirectories(TARGET_VAULT_PATH); // 目标文件夹不存在则创建
            Files.walkFileTree(SOURCE_VAULT_PATH, new SimpleFileVisitor<Path>() {
                @Override
                public FileVisitResult preVisitDirectory(Path dir, BasicFileAttributes attrs) {
                    Path targetPath = TARGET_VAULT_PATH.resolve(SOURCE_VAULT_PATH.relativize(dir).toString()); // 复制目录结构
                    try {
                        Files.createDirectories(targetPath);
                    } catch (IOException e) {
                        e.printStackTrace();
                        return FileVisitResult.SKIP_SUBTREE;
                    }
                    return FileVisitResult.CONTINUE;
                }

                @Override
                public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) {
                    if (file.toString().endsWith(".md")) { // 判断 .md 文件
                        Path targetMdPath = TARGET_VAULT_PATH.resolve(SOURCE_VAULT_PATH.relativize(file).toString());
                        try {
                            Files.copy(file, targetMdPath, StandardCopyOption.REPLACE_EXISTING);
                            downloadAndTransImgUrlToLocal(targetMdPath.toFile()); // 复制到目标文件夹,并下载图片和替换 url
                            MD_COUNT += 1;
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                    }
                    return FileVisitResult.CONTINUE;
                }
            });
        } catch (IOException e) {
            e.printStackTrace();
        }

        // 输出错误统计
        log(">>>>> ALL FINISH! COST TIME:" + (Instant.now().getEpochSecond() - startTime));
        log(">>>>> MD_COUNT:" + MD_COUNT);
        log(">>>>> IMG_COUNT:" + IMG_COUNT);
        log(">>>>> ERROR_COUNT:" + ERROR_COUNT);
        ERROR_STR.stream().map(s -> ">>>>> ERROR_INFO:" + s).forEach(MarkdownImgDownloader::log);
    }

    /**
     * md 文件网络图片下载和替换为本地路径
     *
     * @param mdFile markdown文件
     */
    public static void downloadAndTransImgUrlToLocal(File mdFile) {
        try {
            Path asertsDir = Paths.get(mdFile.getParent() + File.separator + ASSETS_DIRECTORY_NAME + File.separator + mdFile.getName().substring(0, mdFile.getName().lastIndexOf(".")));
            Files.createDirectories(asertsDir);
            String mdContent = readMdContent(mdFile);
            ArrayList<String> imgUrls = extractUrls(mdContent);
            if (imgUrls.isEmpty()) {
                log(mdFile.getPath() + "\t #doesn't have image URL");
                return;
            }
            // 下载网络图片和替换网络 URL 为本地相对路径
            for (String imgUrl : imgUrls) {
                String imgName = imgUrl.substring(imgUrl.lastIndexOf("/") + 1);
                String imgLocalUrl = asertsDir + File.separator + imgName;
                getAndSaveImg(imgUrl, new File(imgLocalUrl));
                // 替换原文图片 URL 为本地相对位置路径
                Path imgLocalPath = Paths.get(imgLocalUrl);
                Path mdFilePath = Paths.get(mdFile.getPath());
                Path relativize = mdFilePath.getParent().relativize(imgLocalPath); // 转换相对位置 path 和 url 的路径分隔符
                mdContent = mdContent.replace(imgUrl, relativize.toString().replace("\\", "/"));
                log(imgUrl + "\t" + imgLocalPath + "\t" + relativize);
            }
            // 保存到新 md 文件,然后关闭文件输出
            FileWriter fileWriter = new FileWriter(mdFile);
            fileWriter.write(mdContent);
            fileWriter.close();
        } catch (Exception e) {
            ERROR_COUNT += 1;
            ERROR_STR.add(mdFile.getPath() + "\t" + e.getMessage());
            e.printStackTrace();
        }
    }

    /**
     * 读取 md文件内容
     *
     * @param mdFile markdown文件
     * @return md文件内容
     */
    public static String readMdContent(File mdFile) {
        StringBuilder sb = new StringBuilder();
        try (BufferedReader bf = new BufferedReader(new InputStreamReader(new FileInputStream(mdFile), StandardCharsets.UTF_8))) {
            String line;
            while ((line = bf.readLine()) != null) {
                sb.append(line).append(System.lineSeparator());
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        return sb.toString();
    }

    /**
     * 解析出图片 url
     *
     * @param content md文本(源 md 文本使用 html 的 <img> 标签 src 属性引用图片)
     * @return 提取 src 属性值
     */
    public static ArrayList<String> extractUrls(String content) {
        ArrayList<String> imgUrls = new ArrayList<>();
        String imgSrcEx = "src=\"(https?:\\S+.(jpg|jpeg|png|gif|webp|bmp|tiff|svg))\"";
        Pattern compile = Pattern.compile(imgSrcEx);
        Matcher matcher = compile.matcher(content);
        while (matcher.find()) {
            String group = matcher.group(1);
            String replace = group.replace("src=", "").replace("\"", "");
            imgUrls.add(replace);
        }
        return imgUrls;
    }

    /**
     * 下载网络图片保存到本地
     *
     * @param imgUrl        网络图片 url
     * @param targetImgFile 待保存为的图片文件
     * @throws IOException 请求失败,非正常200响应
     */
    public static void getAndSaveImg(String imgUrl, File targetImgFile) throws Exception {
        URL url = new URL(imgUrl);
        HttpURLConnection httpConn = (HttpURLConnection) url.openConnection();
        httpConn.setRequestProperty("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/125.0.0.0 Safari/537.36 Edg/125.0.0.0");
        // 设置为不自动跟随重定向
        httpConn.setInstanceFollowRedirects(false);
        // 发起请求并获取响应码
        int responseCode = httpConn.getResponseCode();
        // 如果遇到重定向（3xx状态码），则获取新的 URL 并重新发起请求
        if (responseCode >= 300 && responseCode < 400) {
            String redirectUrl = httpConn.getHeaderField("Location");
            if (redirectUrl != null) {
                getAndSaveImg(redirectUrl, targetImgFile); // 使用新 URL 递归调用 downloadImage 方法
                return;
            }
        }
        // 如果响应码是200，则下载图片
        if (responseCode == HttpURLConnection.HTTP_OK) {
            try (InputStream inputStream = httpConn.getInputStream();
                 FileOutputStream outputStream = new FileOutputStream(targetImgFile)) {
                byte[] buffer = new byte[4096];
                int bytesRead;
                while ((bytesRead = inputStream.read(buffer)) != -1) {
                    outputStream.write(buffer, 0, bytesRead);
                }
                outputStream.flush(); // 刷新输出流
            } finally {
                httpConn.disconnect(); // 关闭连接
            }
        } else {
            throw new Exception(targetImgFile.getPath() + "\t" + imgUrl + "Failed to download image. HTTP error code: " + responseCode);
        }
        IMG_COUNT += 1;
    }

    /**
     * 简单日志输出保存
     *
     * @param message 日志信息
     */
    public static void log(String message) {
        FileWriter writer = null;
        try {
            // 创建 FileWriter 对象，追加模式（true）
            writer = new FileWriter(LOG_FILE, true);
            writer.write(message);
            writer.write(System.lineSeparator());
            writer.flush();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (writer != null) {
                try {
                    writer.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

}