爬取网络视频和小说资源

一、视频部分的爬取

   1.如果对视频有关注的同学就会发现网络上的视频一般有第三方小站的视频，采集站现成的资源，一些解析接口（解析官网的链接，包括免费和收费的接口），还有就是大站的官网视频。所以我们有几个思路

（1）我们直接爬取采集网站的现成视频资源，然后放到播放器里播放，这种方式最简单也最省事，但问题是，资源站不好找，有的资源站过一段时间就会被封掉，资源链接一旦被封掉采集失效。

（2）采集资源站的官方链接，这些链接都是采集站从各大视频网站采集的官方链接，相对来说存活的时间久一些，但也是会失效的，拿到官方链接后我们再用免费公开的解析接口进行解析播放。

（3）对于第三方小站，我们利用嗅探等技术手段，拿到播放链接，再进行播放，也可以直接进行播放，但第三方小站的广告让你有点心烦，有的都是色情广告，没法再公共场合看。

（4）对于官网的视频，我们可以爬取该视频的链接，只要拿到该视频的链接（在浏览器中打开的链接）就行了，不需要拿到视频播放链接，然后再利用解析接口进行播放

 

这几种方式都要用到页面爬取的方法，所以我们先来看页面爬取的方法，这里用的jsoup，这里就不在过多赘述jsoup的用法了，直接上解析的代码

  /**
     * 获取Elements
     */
    private Elements getElements(Element temp, String rule) {
        Elements elements = new Elements();
        if (temp == null || isEmpty(rule)) {
            return elements;
        }
        SourceRule sourceRule = new SourceRule(rule);
        String elementsType;
        String[] ruleStrS;
        if (sourceRule.elementsRule.contains("&")) {
            elementsType = "&";
            ruleStrS = sourceRule.elementsRule.split("&+");
        } else if (sourceRule.elementsRule.contains("%")) {
            elementsType = "%";
            ruleStrS = sourceRule.elementsRule.split("%+");
        } else {
            elementsType = "|";
            if (sourceRule.isCss) {
                ruleStrS = sourceRule.elementsRule.split("\\|\\|");
            } else {
                ruleStrS = sourceRule.elementsRule.split("\\|+");
            }
        }
        List<Elements> elementsList = new ArrayList<>();
        if (sourceRule.isCss) {
            for (String ruleStr : ruleStrS) {
                Elements tempS = temp.select(ruleStr);
                elementsList.add(tempS);
                if (tempS.size() > 0 && elementsType.equals("|")) {
                    break;
                }
            }
        } else {
            for (String ruleStr : ruleStrS) {
                Elements tempS = getElementsSingle(temp, ruleStr);
                elementsList.add(tempS);
                if (tempS.size() > 0 && elementsType.equals("|")) {
                    break;
                }
            }
        }
        if (elementsList.size() > 0) {
            if ("%".equals(elementsType)) {
                for (int i = 0; i < elementsList.get(0).size(); i++) {
                    for (Elements es : elementsList) {
                        if (i < es.size()) {
                            elements.add(es.get(i));
                        }
                    }
                }
            } else {
                for (Elements es : elementsList) {
                    elements.addAll(es);
                }
            }
        }
        return elements;
    }

 /**
     * 获取Elements按照一个规则
     */
    private Elements getElementsSingle(Element temp, String rule) {
        Elements elements = new Elements();
        try {
            String[] rs = rule.trim().split("@");
            if (rs.length > 1) {
                elements.add(temp);
                for (String rl : rs) {
                    Elements es = new Elements();
                    for (Element et : elements) {
                        es.addAll(getElements(et, rl));
                    }
                    elements.clear();
                    elements.addAll(es);
                }
            } else {
                String[] rulePcx = rule.split("!");
                String[] rulePc = rulePcx[0].trim().split(">");
                String[] rules = rulePc[0].trim().split("\\.");
                String[] filterRules = null;
                boolean needFilterElements = rulePc.length > 1 && !isEmpty(rulePc[1].trim());
                if (needFilterElements) {
                    filterRules = rulePc[1].trim().split("\\.");
                    filterRules[0] = filterRules[0].trim();
                    List<String> validKeys = Arrays.asList("class", "id", "tag", "text");
                    if (filterRules.length < 2 || !validKeys.contains(filterRules[0]) || isEmpty(filterRules[1].trim())) {
                        needFilterElements = false;
                    }
                    filterRules[1] = filterRules[1].trim();
                }
                switch (rules[0]) {
                    case "children":
                        Elements children = temp.children();
                        if (needFilterElements)
                            children = filterElements(children, filterRules);
                        elements.addAll(children);
                        break;
                    case "class":
                        Elements elementsByClass = temp.getElementsByClass(rules[1]);
                        if (rules.length == 3) {
                            int index = Integer.parseInt(rules[2]);
                            if (index < 0) {
                                elements.add(elementsByClass.get(elementsByClass.size() + index));
                            } else {
                                elements.add(elementsByClass.get(index));
                            }
                        } else {
                            if (needFilterElements)
                                elementsByClass = filterElements(elementsByClass, filterRules);
                            elements.addAll(elementsByClass);
                        }
                        break;
                    case "tag":
                        Elements elementsByTag = temp.getElementsByTag(rules[1]);
                        if (rules.length == 3) {
                            int index = Integer.parseInt(rules[2]);
                            if (index < 0) {
                                elements.add(elementsByTag.get(elementsByTag.size() + index));
                            } else {
                                elements.add(elementsByTag.get(index));
                            }
                        } else {
                            if (needFilterElements)
                                elementsByTag = filterElements(elementsByTag, filterRules);
                            elements.addAll(elementsByTag);
                        }
                        break;
                    case "id":
                        Elements elementsById = Collector.collect(new Evaluator.Id(rules[1]), temp);
                        if (rules.length == 3) {
                            int index = Integer.parseInt(rules[2]);
                            if (index < 0) {
                                elements.add(elementsById.get(elementsById.size() + index));
                            } else {
                                elements.add(elementsById.get(index));
                            }
                        } else {
                            if (needFilterElements)
                                elementsById = filterElements(elementsById, filterRules);
                            elements.addAll(elementsById);
                        }
                        break;
                    case "text":
                        Elements elementsByText = temp.getElementsContainingOwnText(rules[1]);
                        if (needFilterElements)
                            elementsByText = filterElements(elementsByText, filterRules);
                        elements.addAll(elementsByText);
                        break;
                    default:
                        elements.addAll(temp.select(rulePcx[0]));
                }
                if (rulePcx.length > 1) {
                    String[] rulePcs = rulePcx[1].split(":");
                    for (String pc : rulePcs) {
                        int pcInt = Integer.parseInt(pc);
                        if (pcInt < 0 && elements.size() + pcInt >= 0) {
                            elements.set(elements.size() + pcInt, null);
                        } else if (Integer.parseInt(pc) < elements.size()) {
                            elements.set(Integer.parseInt(pc), null);
                        }
                    }
                    Elements es = new Elements();
                    es.add(null);
                    elements.removeAll(es);
                }
            }
        } catch (Exception ignore) {
        }
        return elements;
    }

这样网页html的class,tag,等都能更具id或class name获取到。

接下来就是写各个网页的规则就行了，规则可以具体到某个标签或class 例如

 "\"ruleBookAuthor\":\"id.info@tag.p.0@text\"," +

 id后面就是该class或tag的id,tag是对应的标签，text是表示标签的文本

再说一下嗅探技术，第三方小站的视频播放链接是需要通过嗅探技术拿到的。我们可以通过webview监听页面的所有链接然后分析链接就行了。具体的代码就不贴了，感兴趣的可以私信。

二 小说的爬取

 这个就简单很多了我们只需要爬取第三小站的资源就行了比如笔趣阁，顶点等，爬取的方法如上

只要写一下页面的解析规则就行。

想看demo的直接再googleplay上搜索阅影就可以看到

也可以搜索阅影微信公众号

欢迎各位指教。