詳細介紹如何自研一款"博客搬家"功能

前言

　　現在的技術博客（社區）越來越多，比如：imooc、spring4All、csdn、cnblogs或者iteye等，有很多朋友可能在這些網站上都發表過博文，當有一天我們想自己搞一個博客網站時就會發現好多東西已經寫過了，我們不可能再重新寫一遍，況且多個平台上都有自己發表的文章，也不可能挨個去各個平台ctrl c + ctrl v。鑒於此， 我在我的開源博客里新開發了一個“博客遷移”的功能，目前支持imooc、csdn、iteye和cnblogs，后期會適配更多站點。

功能介紹

　　如下視頻所示：

　　抓取展示：

功能特點

　　使用方便，抓取規則已內置，只需修改很少的配置就可運行。支持同步抓取文章標簽、description和keywords，支持轉存圖片文件。使用開源的國產爬蟲框架webMagic，方便擴展爬蟲功能。

使用教程

　　目前，該功能已內置了以下幾個平台（imooc、csdn、cnblogs和iteye），根據不同的平台，程序已默認了一套抓取規則，如下圖系列

　　cnblogs抓取規則：

　　使用時，只需要手動指定以下幾項配置即可

　　其他信息在選擇完博文平台后，程序會自動補充完整。圈中必填的幾項配置如下：

選擇博文平台：選擇待操作的博文平台（程序會自動生成對應平台的抓取規則）

自動轉存圖片：勾選時默認將文章中的圖片轉存到七牛雲中（需提前配置七牛雲）

文章分類：是指抓取的文章保存到本地數據庫中的文章分類

用戶ID：是指各平台中，登陸完成后的用戶ID，程序中已給出了對應獲取的方法

文章總頁數：是指待抓取的用戶所有文章的頁數

Cookie（非必填）：只在必須需要登陸才能獲取數據時指定，獲取方式如程序中所示

　　在指定完博文平台、用戶ID和文章總頁數后，爬蟲的其他配置項就會自動補充完整，最后直接執行該程序即可。 注意：默認同步過來的文章為“草稿”狀態，主要是為了防止抓取的內容錯誤，而直接顯示到網站前台，造成不必要的麻煩。所以，需要手動確認無誤后修改發布狀態。另外，針對一些做了防盜鏈的網站，我們在使用“文章搬運工”時，還要勾選上“自動轉存圖片”，至於為何要這么做，在下面會有解釋。

關於“文章搬運工”功能的實現

　　 “文章搬運工”功能聽起來覺得高大上，類似的比如CSDN和cnblogs里的“博客搬家”功能，其實實現起來很簡單。下面聽我道一道，你也可以輕松做出一個“博客搬家”功能！

　　“博客搬家”首先需要克服的問題無非就是：怎么從別人的頁面中提取出相關的文章信息后保存到自己的服務器中。說到頁面提取，可能很多同學不約而同的就想到了：爬蟲！沒錯，就是通過最基礎的網絡爬蟲就可實現，而OneBlog的文章搬運工功能就是基於爬蟲實現的。

　　OneBlog中選用了國產的優秀的開源爬蟲框架：webMagic。

　　WebMagic是一個簡單靈活的Java爬蟲框架。之所以選擇該框架，完全依賴於它的優秀特性：

1. 完全模塊化的設計，強大的可擴展性。
2. 核心簡單但是涵蓋爬蟲的全部流程，靈活而強大，也是學習爬蟲入門的好材料。
3. 提供豐富的抽取頁面API。
4. 無配置，但是可通過POJO+注解形式實現一個爬蟲。
5. 支持多線程。
6. 支持分布式。
7. 支持爬取js動態渲染的頁面。
8. 無框架依賴，可以靈活的嵌入到項目中去

　　關於webMagic的其他詳細介紹，請去webMagic的官網查閱，本文不做贅述。

　　下面針對OneBlog中的“文章搬運工”功能做一下簡單的分析。

　　第一步，添加依賴包

<dependency>
    <groupId>us.codecraft</groupId>
    <artifactId>webmagic-core</artifactId>
    <version>0.7.3</version>
    <exclusions>
        <exclusion>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
        </exclusion>
    </exclusions>
</dependency>
<dependency>
    <groupId>us.codecraft</groupId>
    <artifactId>webmagic-extension</artifactId>
    <version>0.7.3</version>
    <exclusions>
        <exclusion>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
        </exclusion>
    </exclusions>
</dependency>

　　第二步，抽取爬蟲規則

為了方便擴展，我們要抽象出webMagic爬蟲運行時需要的基本屬性到BaseModel.java

/**
 * @author yadong.zhang (yadong.zhang0415(a)gmail.com)
 * @website https://www.zhyd.me
 * @version 1.0
 * @date 2018/7/23 13:33
 */
@Data
public class BaseModel {
    @NotEmpty(message = "必須指定標題抓取規則(xpath)")
    private String titleRegex;
    @NotEmpty(message = "必須指定內容抓取規則(xpath)")
    private String contentRegex;
    @NotEmpty(message = "必須指定發布日期抓取規則(xpath)")
    private String releaseDateRegex;
    @NotEmpty(message = "必須指定作者抓取規則(xpath)")
    private String authorRegex;
    @NotEmpty(message = "必須指定待抓取的url抓取規則(xpath)")
    private String targetLinksRegex;
    private String tagRegex;
    private String keywordsRegex = "//meta [@name=keywords]/@content";
    private String descriptionRegex = "//meta [@name=description]/@content";
    @NotEmpty(message = "必須指定網站根域名")
    private String domain;
    private String charset = "utf8";

    /**
     * 每次爬取頁面時的等待時間
     */
    @Max(value = 5000, message = "線程間隔時間最大只能指定為5000毫秒")
    @Min(value = 1000, message = "線程間隔時間最小只能指定為1000毫秒")
    private int sleepTime = 1000;

    /**
     * 抓取失敗時重試的次數
     */
    @Max(value = 5, message = "抓取失敗時最多只能重試5次")
    @Min(value = 1, message = "抓取失敗時最少只能重試1次")
    private int retryTimes = 2;

    /**
     * 線程個數
     */
    @Max(value = 5, message = "最多只能開啟5個線程（線程數量越多越耗性能）")
    @Min(value = 1, message = "至少要開啟1個線程")
    private int threadCount = 1;

    /**
     * 抓取入口地址
     */
//    @NotEmpty(message = "必須指定待抓取的網址")
    private String[] entryUrls;

    /**
     * 退出方式{1:等待時間(waitTime必填),2:抓取到的url數量(urlCount必填)}
     */
    private int exitWay = 1;
    /**
     * 單位：秒
     */
    private int waitTime = 60;
    private int urlCount = 100;

    private List<Cookie> cookies = new ArrayList<>();
    private Map<String, String> headers = new HashMap<>();
    private String ua = "Mozilla/5.0 (ozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/67.0.3396.99 Safari/537.36";

    private String uid;
    private Integer totalPage;

    /* 保留字段，針對ajax渲染的頁面 */
    private Boolean ajaxRequest = false;
    /* 是否轉存圖片 */
    private boolean convertImg = false;

    public String getUid() {
        return uid;
    }

    public BaseModel setUid(String uid) {
        this.uid = uid;
        return this;
    }

    public Integer getTotalPage() {
        return totalPage;
    }

    public BaseModel setTotalPage(Integer totalPage) {
        this.totalPage = totalPage;
        return this;
    }

    public BaseModel setTitleRegex(String titleRegex) {
        this.titleRegex = titleRegex;
        return this;
    }

    public BaseModel setContentRegex(String contentRegex) {
        this.contentRegex = contentRegex;
        return this;
    }

    public BaseModel setReleaseDateRegex(String releaseDateRegex) {
        this.releaseDateRegex = releaseDateRegex;
        return this;
    }

    public BaseModel setAuthorRegex(String authorRegex) {
        this.authorRegex = authorRegex;
        return this;
    }

    public BaseModel setTargetLinksRegex(String targetLinksRegex) {
        this.targetLinksRegex = targetLinksRegex;
        return this;
    }

    public BaseModel setTagRegex(String tagRegex) {
        this.tagRegex = tagRegex;
        return this;
    }

    public BaseModel setKeywordsRegex(String keywordsRegex) {
        this.keywordsRegex = keywordsRegex;
        return this;
    }

    public BaseModel setDescriptionRegex(String descriptionRegex) {
        this.descriptionRegex = descriptionRegex;
        return this;
    }

    public BaseModel setDomain(String domain) {
        this.domain = domain;
        return this;
    }

    public BaseModel setCharset(String charset) {
        this.charset = charset;
        return this;
    }

    public BaseModel setSleepTime(int sleepTime) {
        this.sleepTime = sleepTime;
        return this;
    }

    public BaseModel setRetryTimes(int retryTimes) {
        this.retryTimes = retryTimes;
        return this;
    }

    public BaseModel setThreadCount(int threadCount) {
        this.threadCount = threadCount;
        return this;
    }

    public BaseModel setEntryUrls(String[] entryUrls) {
        this.entryUrls = entryUrls;
        return this;
    }

    public BaseModel setEntryUrls(String entryUrls) {
        if (StringUtils.isNotEmpty(entryUrls)) {
            this.entryUrls = entryUrls.split("\r\n");
        }
        return this;
    }

    public BaseModel setExitWay(int exitWay) {
        this.exitWay = exitWay;
        return this;
    }

    public BaseModel setWaitTime(int waitTime) {
        this.waitTime = waitTime;
        return this;
    }

    public BaseModel setHeader(String key, String value) {
        Map<String, String> headers = this.getHeaders();
        headers.put(key, value);
        return this;
    }

    public BaseModel setHeader(String headersStr) {
        if (StringUtils.isNotEmpty(headersStr)) {
            String[] headerArr = headersStr.split("\r\n");
            for (String s : headerArr) {
                String[] header = s.split("=");
                setHeader(header[0], header[1]);
            }
        }
        return this;
    }

    public BaseModel setCookie(String domain, String key, String value) {
        List<Cookie> cookies = this.getCookies();
        cookies.add(new Cookie(domain, key, value));
        return this;
    }

    public BaseModel setCookie(String cookiesStr) {
        if (StringUtils.isNotEmpty(cookiesStr)) {
            List<Cookie> cookies = this.getCookies();
            String[] cookieArr = cookiesStr.split(";");
            for (String aCookieArr : cookieArr) {
                String[] cookieNode = aCookieArr.split("=");
                if (cookieNode.length <= 1) {
                    continue;
                }
                cookies.add(new Cookie(cookieNode[0].trim(), cookieNode[1].trim()));
            }
        }
        return this;
    }

    public BaseModel setAjaxRequest(boolean ajaxRequest) {
        this.ajaxRequest = ajaxRequest;
        return this;
    }
}

如上方代碼中所示，我們抽取出了基本的抓取規則和針對不同平台設置的網站屬性（domain、cookies和headers等）。

　　第三步，編寫解析器

因為“博客遷移功能”目前只涉及到頁面的解析、抽取，所以，我們只需要實現webMagic的PageProcessor接口即可。這里有個關鍵點需要注意：隨着網絡技術的發展，現在前后端分離的網站越來越多，而前后端分離的網站基本通過ajax渲染頁面。這種情況下，httpClient獲取到的頁面內容只是js渲染前的html，因此按照常規的解析方式，是解析不到這部分內容的，因此我們需要針對普通的html頁面和js渲染的頁面分別提供解析器。本文主要講解針對普通html的解析方式，至於針對js渲染的頁面的解析，以后會另行寫文介紹。

/**
 * 統一對頁面進行解析處理
 *
 * @author yadong.zhang (yadong.zhang0415(a)gmail.com)
 * @version 1.0
 * @website https://www.zhyd.me
 * @date 2018/7/31 17:37
 */
@Slf4j
public class BaseProcessor implements PageProcessor {
    private static BaseModel model;

    BaseProcessor() {
    }

    BaseProcessor(BaseModel m) {
        model = m;
    }

    @Override
    public void process(Page page) {
        Processor processor = new HtmlProcessor();
        if (model.getAjaxRequest()) {
            processor = new JsonProcessor();
        }
        processor.process(page, model);

    }

    @Override
    public Site getSite() {
        Site site = Site.me()
                .setCharset(model.getCharset())
                .setDomain(model.getDomain())
                .setSleepTime(model.getSleepTime())
                .setRetryTimes(model.getRetryTimes());

        //添加抓包獲取的cookie信息
        List<Cookie> cookies = model.getCookies();
        if (CollectionUtils.isNotEmpty(cookies)) {
            for (Cookie cookie : cookies) {
                if (StringUtils.isEmpty(cookie.getDomain())) {
                    site.addCookie(cookie.getName(), cookie.getValue());
                    continue;
                }
                site.addCookie(cookie.getDomain(), cookie.getName(), cookie.getValue());
            }
        }
        //添加請求頭，有些網站會根據請求頭判斷該請求是由瀏覽器發起還是由爬蟲發起的
        Map<String, String> headers = model.getHeaders();
        if (MapUtils.isNotEmpty(headers)) {
            Set<Map.Entry<String, String>> entrySet = headers.entrySet();
            for (Map.Entry<String, String> entry : entrySet) {
                site.addHeader(entry.getKey(), entry.getValue());
            }
        }
        return site;
    }
}

Processor.java接口，只提供一個process方法供實際的解析器實現

/**
 * 頁面解析接口
 *
 * @author yadong.zhang (yadong.zhang0415(a)gmail.com)
 * @version 1.0
 * @website https://www.zhyd.me
 * @date 2018/7/31 17:37
 */
public interface Processor {
    void process(Page page, BaseModel model);
}

HtmlProcessor.java

/**
 * 解析處理普通的Html網頁
 *
 * @author yadong.zhang (yadong.zhang0415(a)gmail.com)
 * @version 1.0
 * @website https://www.zhyd.me
 * @date 2018/7/31 17:37
 */
public class HtmlProcessor implements Processor {

    @Override
    public void process(Page page, BaseModel model) {
        Html pageHtml = page.getHtml();
        String title = pageHtml.xpath(model.getTitleRegex()).get();
        String source = page.getRequest().getUrl();
        if (!StringUtils.isEmpty(title) && !"null".equals(title) && !Arrays.asList(model.getEntryUrls()).contains(source)) {
            page.putField("title", title);
            page.putField("source", source);
            page.putField("releaseDate", pageHtml.xpath(model.getReleaseDateRegex()).get());
            page.putField("author", pageHtml.xpath(model.getAuthorRegex()).get());
            page.putField("content", pageHtml.xpath(model.getContentRegex()).get());
            page.putField("tags", pageHtml.xpath(model.getTagRegex()).all());
            page.putField("description", pageHtml.xpath(model.getDescriptionRegex()).get());
            page.putField("keywords", pageHtml.xpath(model.getKeywordsRegex()).get());
        }
        page.addTargetRequests(page.getHtml().links().regex(model.getTargetLinksRegex()).all());
    }
}

JsonProcessor.java

/**
 * 解析處理Ajax渲染的頁面(待完善)
 *
 * @author yadong.zhang (yadong.zhang0415(a)gmail.com)
 * @version 1.0
 * @website https://www.zhyd.me
 * @date 2018/7/31 17:37
 */
public class JsonProcessor implements Processor {
    @Override
    public void process(Page page, BaseModel model) {
        String rawText = page.getRawText();
        String title = new JsonPathSelector(model.getTitleRegex()).select(rawText);
        if (!StringUtils.isEmpty(title) && !"null".equals(title)) {
            page.putField("title", title);
            page.putField("releaseDate", new JsonPathSelector(model.getReleaseDateRegex()).select(rawText));
            page.putField("author", new JsonPathSelector(model.getAuthorRegex()).select(rawText));
            page.putField("content", new JsonPathSelector(model.getContentRegex()).select(rawText));
            page.putField("source", page.getRequest().getUrl());
        }
        page.addTargetRequests(page.getHtml().links().regex(model.getTargetLinksRegex()).all());
    }
}

　　第四步，定義爬蟲的入口類

此步不多做解釋，就是最基本啟動爬蟲，然后通過自定義Pipeline對數據進行組裝

/**
 * 爬蟲入口
 *
 * @author yadong.zhang (yadong.zhang0415(a)gmail.com)
 * @version 1.0
 * @website https://www.zhyd.me
 * @date 2018/7/23 10:38
 */
@Slf4j
public class ArticleSpiderProcessor extends BaseProcessor implements BaseSpider<Article> {

    private BaseModel model;
    private PrintWriter writer;
    private ValidatorFactory factory = Validation.buildDefaultValidatorFactory();

    private ArticleSpiderProcessor() {
    }

    public ArticleSpiderProcessor(BaseModel model, PrintWriter writer) {
        super(model);
        this.model = model;
        this.writer = writer;
    }

    public ArticleSpiderProcessor(BaseModel model) {
        super(model);
        this.model = model;
    }

    /**
     * 運行爬蟲並返回結果
     *
     * @return
     */
    @Override
    public List<Article> run() {
        List<String> errors = validateModel(model);
        if (CollectionUtils.isNotEmpty(errors)) {
            WriterUtil.writer2Html(writer, "校驗不通過！請依據下方提示，檢查輸入參數是否正確......");
            for (String error : errors) {
                WriterUtil.writer2Html(writer, ">> " + error);
            }
            return null;
        }

        List<Article> articles = new LinkedList<>();

        WriterUtil.writer2Html(writer, ">> 爬蟲初始化完成，共需抓取 " + model.getTotalPage() + " 頁數據...");

        Spider spider = Spider.create(new ArticleSpiderProcessor())
                .addUrl(model.getEntryUrls())
                .addPipeline((resultItems, task) -> {
                    Map<String, Object> map = resultItems.getAll();
                    String title = String.valueOf(map.get("title"));
                    if (StringUtils.isEmpty(title) || "null".equals(title)) {
                        return;
                    }
                    String content = String.valueOf(map.get("content"));
                    String source = String.valueOf(map.get("source"));
                    String releaseDate = String.valueOf(map.get("releaseDate"));
                    String author = String.valueOf(map.get("author"));
                    String description = String.valueOf(map.get("description"));
                    description = StringUtils.isNotEmpty(description) ? description.replaceAll("\r\n| ", "")
                            : content.length() > 100 ? content.substring(0, 100) : content;
                    String keywords = String.valueOf(map.get("keywords"));
                    keywords = StringUtils.isNotEmpty(keywords) && !"null".equals(keywords) ? keywords.replaceAll(" +|，", ",").replaceAll(",,", ",") : null;
                    List<String> tags = (List<String>) map.get("tags");
                    log.info(String.format(">> 正在抓取 -- %s -- %s -- %s -- %s", source, title, releaseDate, author));
                    WriterUtil.writer2Html(writer, String.format(">> 正在抓取 -- <a href=\"%s\" target=\"_blank\">%s</a> -- %s -- %s", source, title, releaseDate, author));
                    articles.add(new Article(title, content, author, releaseDate, source, description, keywords, tags));
                })
                .thread(model.getThreadCount());
        // 啟動爬蟲
        spider.run();
        return articles;
    }

    private <T> List<String> validateModel(T t) {
        Validator validator = factory.getValidator();
        Set<ConstraintViolation<T>> constraintViolations = validator.validate(t);

        List<String> messageList = new ArrayList<>();
        for (ConstraintViolation<T> constraintViolation : constraintViolations) {
            messageList.add(constraintViolation.getMessage());
        }
        return messageList;
    }
}

　　第五步，提取html規則，運行測試。

以我的博客園為例，爬蟲的一般以文章列表頁作為入口頁面，本文示例為：https://www.cnblogs.com/zhangyadong/，然后我們需要手動提取文章相關內容的抓取規則（OneBlog中主要使用Xsoup-XPath解析器，使用方式參考鏈接）。以推薦一款自研的Java版開源博客系統OneBlog一文為例

如圖所示，需要抽取的一共為六部分：

1. 文章標題
2. 文章正文內容
3. 文章標簽
4. 文章發布日期
5. 文章作者
6. 待抽取的其他文章列表

 通過f12查看頁面結構，如下

整理相關規則如下：

1. 標題："//a[@id=cb_post_title_url]/html()"
2. 文章正文："//div[@id=cnblogs_post_body]/html()"
3. 標簽："//div[@id=EntryTag]/a/html()"
4. 發布日期："//span[@id=post-date]/html()"
5. 作者："//div[@class=postDesc]/a[1]/html()"
6. 待抽取的其他文章鏈接：".*www\\.cnblogs\\.com/zhangyadong/p/[\\w\\d]+\\.html"

注：“待抽取的其他文章鏈接”就是根據這篇文章的鏈接抽取出的規則

到這一步為止，基本的文章信息抽取規則就以獲取完畢，接下來就跑一下測試

@Test
public void cnblogSpiderTest() {
    BaseSpider<Article> spider = new ArticleSpiderProcessor(new CnblogModel().setUid("zhangyadong")
            .setTotalPage(1)
            .setDomain("www.cnblogs.com")
            .setTitleRegex("//a[@id=cb_post_title_url]/html()")
            .setAuthorRegex("//div[@class=postDesc]/a[1]/html()")
            .setReleaseDateRegex("//span[@id=post-date]/html()")
            .setContentRegex("//div[@id=cnblogs_post_body]/html()")
            .setTagRegex("//div[@id=EntryTag]/a/html()")
            .setTargetLinksRegex(".*www\\.cnblogs\\.com/zhangyadong/p/[\\w\\d]+\\.html")
            .setHeader("Host", "www.cnblogs.com")
            .setHeader("Referer", "https://www.cnblogs.com/"));
    spider.run();
}

　　Console控制台打印數據

2018-09-12 11:50:49 [us.codecraft.webmagic.Spider:306] INFO  - Spider www.cnblogs.com started!
2018-09-12 11:50:51 [com.zyd.blog.spider.processor.ArticleSpiderProcessor:89] INFO  - >> 正在抓取 -- https://www.cnblogs.com/zhangyadong/p/oneblog.html -- 推薦一款自研的Java版開源博客系統OneBlog -- 2018-09-11 09:53 -- HandsomeBoy丶
2018-09-12 11:50:52 [us.codecraft.webmagic.Spider:338] INFO  - Spider www.cnblogs.com closed! 2 pages downloaded.

 如圖，文章已成功被抓取，剩下的，無非就是要么保存到文件中，要么持久化到數據庫里。OneBlog中是直接保存到了數據庫里。

關於文章圖片轉存

　　為什么要添加“文章轉存”功能？那是因為一些網站對本站內的靜態資源做了“防盜鏈”，而所謂的“防盜鏈”說簡單點就是：我的東西別人不能用，得需要我授權才可。這樣做的好處就是，不會讓自己的勞動成果白白給別人做了嫁衣。那么，針對這一特性，如果在“文章搬運”時，原文圖片未經處理就原封不動的保存下來，以開源博客這篇文章為例，可能就會碰到如下情況：

　　如上圖，有一些圖片無法顯示，在控制台中可以看到這些圖片全是報錯403，也就是未授權，也就是所謂的被原站做了“防盜鏈”！這個時候，我們在抓取文章時就需要將原文的圖片全部轉存到自己服務器上，如此一來就解決了“被防盜鏈”的問題。

　　針對這一問題，OneBlog中則是通過正則表達式，將所有img標簽的src里的網絡文件下載下來后轉存到七牛雲中。簡單代碼如下：

private static final Pattern PATTERN = Pattern.compile("<img[^>]+src\\s*=\\s*['\"]([^'\"]+)['\"][^>]*>");
private String parseImgForHtml(String html, String qiniuBasePath, PrintWriter writer) {
    if (StringUtils.isEmpty(html)) {
        return null;
    }
    Matcher m = PATTERN.matcher(html);
    Set<String> imgUrlSet = new HashSet<>();
    while (m.find()) {
        String imgUrl = m.group(1);
        imgUrlSet.add(imgUrl);
    }
    if (!CollectionUtils.isEmpty(imgUrlSet)) {
        WriterUtil.writer2Html(writer, "  > 開始轉存圖片到七牛雲...");
        for (String imgUrl : imgUrlSet) {
            String qiniuImgPath = ImageDownloadUtil.convertToQiniu(imgUrl);
            if (StringUtils.isEmpty(qiniuImgPath)) {
                WriterUtil.writer2Html(writer, "  >> 圖片轉存失敗，請確保七牛雲以配置完畢！請查看控制台詳細錯誤信息...");
                continue;
            }
            html = html.replaceAll(imgUrl, qiniuBasePath + qiniuImgPath);
            WriterUtil.writer2Html(writer, String.format("  >> <a href=\"%s\" target=\"_blank\">原圖片</a> convert to <a href=\"%s\" target=\"_blank\">七牛雲</a>...", imgUrl, qiniuImgPath));
        }
    }
    return html;
}

　　ImageDownloadUtil.convertToQiniu方法如下

/**
 * 將網絡圖片轉存到七牛雲
 *
 * @param imgUrl 網絡圖片地址
 */
public static String convertToQiniu(String imgUrl) {
    log.debug("download img >> %s", imgUrl);
    String qiniuImgPath = null;
    try (InputStream is = getInputStreamByUrl(checkUrl(imgUrl));
         ByteArrayOutputStream outStream = new ByteArrayOutputStream();) {
        byte[] buffer = new byte[1024];
        int len = 0;
        while ((len = is.read(buffer)) != -1) {
            outStream.write(buffer, 0, len);
        }
        qiniuImgPath = QiniuApi.getInstance()
                .withFileName("temp." + getSuffixByUrl(imgUrl), QiniuUploadType.SIMPLE)
                .upload(outStream.toByteArray());
    } catch (Exception e) {
        log.error("Error.", e);
    }
    return qiniuImgPath;
}

（注：以上代碼只是簡單示例了一下核心代碼，具體代碼請參考我的開源博客：OneBlog）

總結

　　看完了我上面的介紹，你應該可以發現，其實技術實現起來，並沒有太大的難點。主要重難點無非就一個：如何編寫提取html內容的規則。規則一旦確定了，剩下的無非就是粘貼復制就能完成的代碼而已。

最后聲明

• 本工具開發初衷只是用來遷移 自己的文章 所用，因此不可用該工具惡意竊取他人勞動成果！
• 因不聽勸阻，使用該工具惡意竊取他們勞動成果而造成的一切不良后果，本人表示：堅決不背鍋！
• 如果該工具不好用，你們絕對不能打我！
• 有問題、建議，請留言，或者去gitee上提Issues！

        最后打個廣告，如果你覺得這篇文章對你有用，可以關注我的技術公眾號：碼一碼，你的關注和轉發是對我最大的支持，O(∩_∩)O