Jsoup学习总结

雨点打透心脏的1/2处 2021-11-11 08:22 426阅读 0赞

有两个推荐网址：

http://www.open-open.com/jsoup/

http://www.iteye.com/topic/1010581

这两个队jsoup简单使用做了很好的指导

我只提出比较实用的例子：

当我们读取某些网址被屏蔽返回505 时可以尝试用一下代码

  1. // 读取URL
  2.     public static Document readUrlFistT(String url) {
  3.         Document doc = null;
  4.         try {
  5.             doc = Jsoup.connect(url).timeout(60 * 1000).userAgent(
  6.                     "Mozilla/4.0 (compatible; MSIE 9.0; Windows NT 6.1)")
  7.                     .followRedirects(true).ignoreHttpErrors(true).post();
  8.         } catch (IOException e) {
  9.             e.printStackTrace();
  10.             if ((e instanceof UnknownHostException)
  11.                     || (e instanceof SocketTimeoutException)) {
  12.                 doc = readUrlFistT(url);
  13.             }
  15.         }
  16.         return doc;
  17.     }

　　也可以用下面的代码

  1. public static Document readUrlFist(String url) {
  2.         Document doc = null;
  3.         Connection conn = Jsoup.connect(url);
  4.         conn
  5.                 .header(
  6.                         "User-Agent",
  7.                         "Mozilla/5.0 (Macintosh; U; Intel Mac OS X 10.4; en-US; rv:1.9.2.2) Gecko/20100316 Firefox/3.6.2 Googlebot/2.1");
  8.         try {
  9.             doc = conn.timeout(200 * 1000).get();
  10.         } catch (IOException e) {
  11.             e.printStackTrace();
  12.             if ((e instanceof UnknownHostException)
  13.                     || (e instanceof SocketTimeoutException)) {
  14.                 doc = readUrlFist(url);
  15.             }
  17.         }
  18.         return doc;
  19.     }

　　个人推荐第二个，遇到解析不出来的两个换着用

还有一种情况想知道自己在的兄弟节点中的位置时候可以用siblingElements

这个比elementSiblingIndex()准确点，不过有的时候也不是很准确

下面贴一段我曾经做过的练习：如果你对某个网站做过详细的抓取后，jsoup对于你来说就是小菜了。

从不熟到应用灵活，个人喜好用select 语句，语句简单实用

  1. package com.xinsearch.test;
  3. import java.util.ArrayList;
  4. import java.util.HashMap;
  5. import java.util.Iterator;
  6. import java.util.List;
  7. import java.util.Map;
  8. import java.util.Set;
  10. import org.jsoup.nodes.Document;
  11. import org.jsoup.nodes.Element;
  12. import org.jsoup.select.Elements;
  14. import com.xinsearch.entity.Url;
  15. import com.xinsearch.util.TaoUtil;
  17. public class WedSeven extends TaoUtil {
  18.     public static String title = "";
  19.     public static Element bestFather = null;
  20.     public static List<Url> urls = new ArrayList<Url>();
  22.     public static void main(String[] args) {
  23.         String url = "http://www.qianzhihe.com.cn/allsort.html";
  24.         title = url.split("/")[2];
  25.         takeUrlFist(url);
  26.     }
  28.     // 得到最优节点
  29.     public static Element getFather(String url) {
  30.         Elements body = readBody(url);
  31.         Element bestElement = readChildByMaxNum(body.get(0));
  32.         return bestElement;
  33.     }
  35.     // 测试程序
  36.     public static String takeUrlFist(String url) {
  37.         bestFather = getFather(url);
  38.         // 得到该节点下a
  39.         Elements as = bestFather.select("a");
  40.         // 得到a 标签的父亲节点
  41.         List<Element> aParents = gerFaterPonit(as);
  42.         // 得到 a 父节点中tagName数量最多的那些节点
  43.         List<Element> aParentsTagNames = takeAparentByTagName(aParents,
  44.                 bestFather);
  45.         // 得到这些节点中className 最多的节点
  46.         List<Element> aParentsClassNames = getElementByMaxClassName(aParentsTagNames);
  47.         // 在这些节点中找出想要的信息
  48.         takeMessage(aParentsClassNames);
  49.         return "已经成功提取一个URL";
  50.     }
  52.     // 得到相同className的 节点的父节点
  53.     public static List<Element> gerFaterPonit(Elements elements) {
  54.         List<Element> bestElements = new ArrayList<Element>();
  55.         for (Element element : elements) {
  56.             Element elementFater = element.parent();
  57.             bestElements.add(elementFater);
  58.         }
  59.         return bestElements;
  60.     }
  62.     // 
  63.     public static List<Element> getElementByMaxClassName(
  64.             List<Element> bestElements) {
  65.         String index = takeIndexByClassName(bestElements);
  66.         List<Element> bestEList = getElementByClassName(bestElements, index);
  67.         return bestEList;
  68.     }
  70.     // 读取url得到一级节点，该节点含有url
  71.     public static Elements readBody(String url) {
  72.         Document doc = readUrlFist(url);
  73.         Elements body = doc.select("body");
  74.         return body;
  75.     }
  77.     // 得到该节点下的孩子最多的那个节点（这个节点就是含有Url的节点）
  78.     public static Element readChildByMaxNum(Element body) {
  79.         Elements divOne = body.children();
  80.         Element bestElement = divOne.get(0);
  81.         int best = divOne.get(0).children().size();
  82.         for (int i = 0; i < divOne.size(); i++) {
  83.             Elements divTwo = divOne.get(i).select("a");
  84.             int temp = divTwo.size();
  85.             if (temp > best) {
  86.                 best = temp;
  87.                 bestElement = divOne.get(i);
  88.             }
  89.         }
  90.         // System.out.println(bestElement.attr("id"));
  91.         return bestElement;
  92.     }
  94.     // 得到tagName最多的节点
  95.     public static List<Element> takeAparentByTagName(List<Element> as,
  96.             Element bestElement) {
  97.         List<Element> bestElements = new ArrayList<Element>();
  98.         Map<String, Integer> aparent = new HashMap<String, Integer>();
  99.         String index = "";
  100.         for (Element element : as) {
  101.             String tag = element.tagName();
  102.             if (aparent.containsKey(tag)) {
  103.                 aparent.put(tag, aparent.get(tag) + 1);
  104.             } else {
  105.                 aparent.put(tag, 1);
  106.             }
  107.         }
  108.         Set<String> keys = aparent.keySet();
  109.         Iterator<String> iterable = keys.iterator();
  110.         int max = 0;
  111.         String best = "";
  112.         while (iterable.hasNext()) {
  113.             String key = iterable.next();
  114.             if (max < aparent.get(key)) {
  115.                 max = aparent.get(key);
  116.                 best = key;
  117.             }
  118.         }
  119.         index = best;
  120.         bestElements = bestElement.select(index);
  122.         return bestElements;
  123.     }
  125.     // 得到className的名字和他的数量
  126.     public static Map<String, Integer> takeMapClass(List<Element> bestElements) {
  127.         Map<String, Integer> myClass = new HashMap<String, Integer>();
  128.         for (int i = 0; i < bestElements.size(); i++) {
  129.             Element element = bestElements.get(i);
  130.             String temp = element.className();
  131.             int sum = element.children().size();
  132.             if (sum == 0) {
  133.                 sum = 1;
  134.             }
  135.             if (temp == null || temp.equals("")) {
  136.                 temp = "iiiuuuzzz";
  137.             }
  138.             if (myClass.containsKey(temp)) {
  139.                 myClass.put(temp, myClass.get(temp) + sum);
  140.             } else {
  141.                 myClass.put(temp, sum);
  142.             }
  143.         }
  144.         // System.out.println("myClass.size() "+myClass.size());
  145.         return myClass;
  146.     }
  148.     // 得到className数量最多的节点的索引
  149.     public static String takeIndexByClassName(List<Element> bestElements) {
  150.         Map<String, Integer> myClass = takeMapClass(bestElements);
  151.         Set<String> keys = myClass.keySet();
  152.         Iterator<String> iterable = keys.iterator();
  153.         int max = 0;
  154.         String best = "";
  155.         while (iterable.hasNext()) {
  156.             String key = iterable.next();
  157.             // System.out.println(key+ myClass.get(key));
  158.             if (max < myClass.get(key)) {
  159.                 max = myClass.get(key);
  160.                 best = key;
  161.             }
  162.         }
  163.         String index = best;
  164.         // System.out.println("index :" +index);
  165.         return index;
  166.     }
  168.     // 和className数量次多的节点的索引
  169.     public static String takeBetterIndexByClassName(List<Element> bestElements) {
  170.         Map<String, Integer> myClass = takeMapClass(bestElements);
  171.         String index = takeIndexByClassName(bestElements);
  172.         String index2 = "";
  173.         Set<String> keys = myClass.keySet();
  174.         Iterator<String> iterable = keys.iterator();
  175.         int max = 0;
  176.         String best = "";
  177.         while (iterable.hasNext()) {
  178.             String key = iterable.next();
  179.             if (!key.equals(index)) {
  180.                 if (max < myClass.get(key)) {
  181.                     max = myClass.get(key);
  182.                     best = key;
  183.                 }
  184.             }
  185.         }
  186.         index2 = best;
  187.         // System.out.println("index2   :" +index2);
  188.         return index2;
  189.     }
  191.     // 根据索引得出所要的节点
  192.     public static List<Element> getElementByClassName(
  193.             List<Element> bestElements, String index) {
  194.         List<Element> elementList = new ArrayList<Element>();
  195.         for (Element element : bestElements) {
  196.             String temp = element.className();
  197.             if (temp == null || temp.equals("")) {
  198.                 temp = "iiiuuuzzz";
  199.             }
  200.             if (index.equals(temp)) {
  201.                 elementList.add(element);
  202.             }
  204.         }
  205.         return elementList;
  207.     }
  209.     // 得到孩子节点
  210.     public static List<Element> takeChildren(List<Element> bestElements) {
  211.         List<Element> children = new ArrayList<Element>();
  212.         for (Element element : bestElements) {
  213.             Elements childrens = element.children();
  214.             for (Element element2 : childrens) {
  215.                 children.add(element2);
  216.             }
  217.         }
  218.         return children;
  220.     }
  222.     // 得到和自己内容不同的父亲节点
  223.     public static Element getParent(Element element) {
  224.         Element parent = element.parent();
  225.         if (element.siblingElements().size() > 0) {
  226.             while (parent.text().equals(element.text())) {
  227.                 parent = parent.parent();
  228.             }
  229.         }
  230.         return parent;
  231.     }
  233.     // 得到最优父亲节点
  234.     public static void bestParent(List<Element> elements) {
  236.         for (int i = 0; i < elements.size(); i++) {
  237.             System.out.println(elements.get(i).tagName());
  238.             System.out.println(elements.get(i).className());
  239.             Element parent = getParent(elements.get(i));
  240.             System.out.println(parent.tagName());
  241.             System.out.println(parent.className());
  242.             //    
  243.             //            
  244.             Element parentTwo = getParent(parent);
  245.             System.out.println(parentTwo.tagName());
  246.             System.out.println(parentTwo.className());
  247.             //        
  248.             Element aparentTwo = parentTwo.parent();
  249.             System.out.println(aparentTwo.tagName());
  250.             System.out.println(aparentTwo.className());
  251.             //
  252.             System.out.println(elements.get(i).siblingElements().size());
  253.             System.out.println(parent.siblingElements().size());
  254.             System.out.println(parentTwo.siblingElements().size());
  255.             System.out.println(aparentTwo.siblingElements().size());
  257.             // 为什么要选择parent呢？
  258.             // 该节点是a 标签的父节点，parent里面可能含有第二级目录
  259.             // 如可选择第一级目录呢？这是个难点主要是各大网站的格式不一样
  260.             // （jsoup抓到的信息和审查元素看到的结果不一样）
  261.             // 
  262.             // 如果父节点兄弟有两个，可能一个是Title ，一个是want
  263.             // 如果是这样的话直接输出二级目录
  264.             // 还有一种可能：是这个区域中只有两个want(姑且放一边)
  265.             // 
  266.             // 否则
  267.             // 可能的第一种情况是，他的上一个兄弟就是第二级目录，
  268.             // （2）他兄弟中的老大是第二级目录，（这种情况不好处理，因为不确定）
  269.             //
  270.             //
  271.             //
  272.             // 如何在二级目录上找一级目录呢？
  273.             //   
  274.             //
  276.             if (parent.siblingElements().size() == 1) {
  278.                 if (parentTwo.siblingElements().size() == 1) {
  280.                 } else {
  282.                     if (parentTwo.siblingElements().size() + 1 == aparentTwo
  283.                             .children().size()) {
  285.                         Element apElementTwo = getParent(aparentTwo);
  287.                         System.out.println(apElementTwo.className());
  289.                         if (aparentTwo.siblingElements().size() == 1) {
  290.                             if (apElementTwo.siblingElements().size() == 1) {
  291.                                 System.out.println("fdsfdsfdsf");
  292.                                 System.out.print(apElementTwo.parent()
  293.                                         .children().first().text());
  294.                             } else {
  295.                                 System.out.println("ffffffffffffff");
  296.                                 System.out.print(apElementTwo.children()
  297.                                         .first().text());
  298.                             }
  300.                         } else {
  302.                             // System.out.println("dddddddddddddddddddddddd");
  303.                             if (apElementTwo.siblingElements().size() >= 1) {
  304.                                 // System.out.println("fdsfdsfdsf");
  306.                                 System.out.print(apElementTwo.parent()
  307.                                         .children().first().text());
  308.                             } else {
  309.                                 // System.out.println("ffffffffffffff");
  310.                                 // System.out.print(apElementTwo.children()
  311.                                 // .first().text());
  312.                                 // System.out.println("dsffffffffff");
  313.                             }
  315.                         }
  316.                     } else {
  318.                     }
  320.                 }
  322.                 System.out.print("     "
  323.                         + parent.parent().children().first().text());
  325.             } else {
  326.                 // 如果第二级目录在该元素的第一个节点
  327.                 // 如何找到第一级目录呢？
  328.                 // 苏宁：
  329.                 // 如果他的兄弟节点和他父节点的孩子数相同，说明他的父亲和他是亲父子，
  330.                 // 一级目录就可能是他的第一个兄弟 、
  331.                 // 判断一个父节点的兄弟，若有一个兄弟，可能是他的title
  332.                 // 
  333.                 // 也可能是 两个want
  334.                 // 
  335.                 if (parentTwo.children().size() == parent.siblingElements()
  336.                         .size() + 1) {
  337.                     System.out.println("dddddddddddddddddd");
  338.                     System.out.println(parentTwo.children().first().text());
  339.                 } else {
  340.                     if (parentTwo.elementSiblingIndex() - 1 >= 0) {
  341.                         System.out.print(aparentTwo.children().get(
  342.                                 parentTwo.elementSiblingIndex() - 1).children()
  343.                                 .first().text());
  344.                     }
  345.                 }
  347.                 System.out.print("              "
  348.                         + parent.children().first().text());
  350.             }
  352.             // /
  353.             System.out.print("            "
  354.                     + elements.get(i).select("a").text());
  355.             System.out.print("             "
  356.                     + addHttp(addTitle(
  357.                             elements.get(i).select("a").attr("href"), title)));
  358.             System.out.println();
  359.         }
  360.     }
  362.     // 提取需要的信息
  363.     public static void takeMessage(List<Element> bestElements) {
  364.         threadClass(bestElements);
  365.     }
  367.     //
  368.     public static void threadClass(List<Element> elements) {
  369.         for (int i = 0; i < elements.size(); i++) {
  370.             Element element = elements.get(i);
  371.             Elements elements2 = element.select("a");
  372.             for (Element element2 : elements2) {
  373.                 System.out.print(element2.text());
  374.                 System.out.println("             "
  375.                         + addHttp(addTitle(element2.attr("href"), title)));
  376.             }
  377.         }
  379.     }
  380. }

转载于:https://www.cnblogs.com/tomcattd/archive/2013/01/02/2842137.html

发表评论

表情：
评论列表 （有 0 条评论，426人围观）

还没有评论，来说两句吧...

相关阅读

    相关 Jsoup学习总结

    本文摘抄其他博客或者技术论坛，自己搜集整理如下： Jsoup学习总结 摘要 Jsoup是一款比较好的Java版HTML解析器。可直接解析某个URL地址、H

    向右看齐向右看齐/ 0 赞/ 178 阅读

    相关 jsoup总结

    本文摘抄其他博客或者技术论坛，自己搜集整理如下： Jsoup学习总结 摘要 Jsoup是一款比较好的[Java][]版HTML解析器。可直接解析某个U

    绝地灬酷狼绝地灬酷狼/ 0 赞/ 291 阅读

    相关 Jsoup学习总结

    Jsoup学习总结 摘要 Jsoup是一款比较好的Java版HTML解析器。可直接解析某个URL地址、HTML文本内容。它提供了一套非常省力的API，可通过DOM，

    港控/mmm°港控/mmm°/ 0 赞/ 272 阅读

    相关 jsoup

    一、Jsoup概述 1.1、简介     jsoup 是一款Java 的HTML解析器，可直接解析某个URL地址、HTML文本内容。它提供了一套非常省力的API，

    ゝ一纸荒年。ゝ一纸荒年。/ 0 赞/ 358 阅读