Jsoup入门学习一

1、Jsoup是一款Java 的HTML解析器，可直接解析某个URL地址、HTML文本内容。它提供了一套非常省力的API，可通过DOM，CSS以及类似于jQuery的操作方法来取出和操作数据。

2、Jsoup 的主要功能，如下所示：

　　1）、从一个URL，文件或字符串中解析HTML；
　　2）、使用DOM或CSS选择器来查找、取出数据；
　　3）、可操作HTML元素、属性、文本；
　　4）、Jsoup 是基于MIT协议发布的，可放心使用于商业项目。

3、httpClient 结合Jsoup 获取到网页内容进行解析，首先需要引入httpClient和Jsoup的依赖，如下所示：

<project xmlns="http://maven.apache.org/POM/4.0.0"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 
      http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.bie</groupId>
    <artifactId>jsoup</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>jar</packaging>

    <name>jsoup</name>
    <url>http://maven.apache.org</url>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <dependencies>
        <!-- 添加httpclient支持 -->
        <dependency>
            <groupId>org.apache.httpcomponents</groupId>
            <artifactId>httpclient</artifactId>
            <version>4.5.2</version>
        </dependency>
        <!-- jsoup版本依赖 -->
        <dependency>
            <groupId>org.jsoup</groupId>
            <artifactId>jsoup</artifactId>
            <version>1.8.3</version>
        </dependency>
    </dependencies>
</project>

虽然使用Jsoup可以替代HttpClient直接发起请求解析数据，但是往往不会这样用，因为实际的开发过程中，需要使用到多线程，连接池，代理等等技术，而jsoup对这些技术的支持并不是很好，所以jsoup一般仅仅作为Html解析工具使用。

package com.bie.spider.jsoup;

import java.io.File;
import java.io.IOException;
import java.net.MalformedURLException;
import java.net.URL;

import org.apache.commons.io.FileUtils;
import org.jsoup.Jsoup;
import org.jsoup.nodes.Document;
import org.jsoup.nodes.Element;

/**
 * 
 * @author
 *
 */
public class JsoupDocument {

    /**
     * 虽然使用Jsoup可以替代HttpClient直接发起请求解析数据，但是往往不会这样用，
     * 因为实际的开发过程中，需要使用到多线程，连接池，代理等等技术，
     * 而jsoup对这些技术的支持并不是很好， 所以jsoup一般仅仅作为Html解析工具使用
     * 
     * @throws MalformedURLException
     * @throws IOException
     */
    public static void inputUrl() throws MalformedURLException, IOException {
        // Jsoup可以直接输入url，它会发起请求并获取数据，封装为Document对象
        // 使用jsoup解析url
        Document doc = Jsoup.parse(new URL("https://www.autohome.com.cn/bestauto/"), 10000);

        // 把获取的内容输出为文件
        FileUtils.writeStringToFile(new File("D:/test.html"), doc.toString(), "UTF-8");

        // 获取title
        Element element = doc.getElementsByTag("title").first();

        // 打印title内容
        System.out.println(element.text());
    }

    /**
     * 输入字符串，Jsoup可以直接输入字符串，并封装为Document对象
     * 
     * @throws MalformedURLException
     * @throws IOException
     */
    public static void inputCharacter() throws MalformedURLException, IOException {
        // 读取文件，获取字符串
        String html = FileUtils.readFileToString(new File("D:/test.html"), "UTF-8");

        // 解析字符串
        Document doc = Jsoup.parse(html);

        // 获取title标签
        Element element = doc.getElementsByTag("title").first();

        // 打印title内容
        System.out.println(element.text());
    }

    /**
     * 输入文件，Jsoup可以直接输入文件，并封装为Document对象
     * 
     * @throws MalformedURLException
     * @throws IOException
     */
    public static void inputFile() throws MalformedURLException, IOException {
        // 使用jsoup解析文件
        Document doc = Jsoup.parse(new File("D:/test.html"), "UTF-8");

        // 获取title标签
        Element element = doc.getElementsByTag("title").first();

        // 打印title内容
        System.out.println(element.text());
    }

    public static void main(String[] args) throws MalformedURLException, IOException {
        // 输入url
        inputUrl();
        // 输入字符串
        inputCharacter();
        // 输入文件
        inputFile();
    }

}

httpClient 结合Jsoup 获取到网页内容进行解析，具体代码，如下所示：

package com.bie.jsoup;

import java.io.IOException;

import org.apache.http.Header;
import org.apache.http.HttpEntity;
import org.apache.http.ParseException;
import org.apache.http.StatusLine;
import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.util.EntityUtils;
import org.jsoup.Jsoup;
import org.jsoup.nodes.Document;
import org.jsoup.nodes.Element;
import org.jsoup.select.Elements;

public class HttpClientToJsoup {

    // 设置请求头消息 User-Agent 模拟浏览器
    private static String UserAgent = "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:83.0) Gecko/20100101 Firefox/83.0";

    /**
     * HttpGet请求操作
     */
    public static void httpGetRequest() {
        // 第一步，获取到httpClient客户端实例，获取到一个可关闭的httpClient客户端实例。
        CloseableHttpClient httpClient = HttpClients.createDefault();
        // 第二步，创建HttpGet或者HttpPost实例。
        String uri = "https://www.cnblogs.com/biehongli";
        HttpGet httpGet = new HttpGet(uri);
        // 设置请求头消息 User-Agent 模拟浏览器
        httpGet.setHeader("User-Agent", UserAgent);

        // 定义一个可响应的实例对象。
        CloseableHttpResponse response = null;
        try {
            // 第三步，发布一个请求，使用httpClient实例发送一个http协议的Get请求。
            response = httpClient.execute(httpGet);
            // 获取到响应的状态
            StatusLine statusLine = response.getStatusLine();
            System.out.println("响应状态： " + statusLine.toString() + ", 响应码： " + statusLine.getStatusCode());
        } catch (ClientProtocolException e) {
            // http协议异常
            e.printStackTrace();
        } catch (IOException e) {
            // io异常
            e.printStackTrace();
        }
        // 第四步，获取到返回的实体对象
        HttpEntity entity = response.getEntity();
        // 获取响应内容类型 Content-Type，获取到响应类型，从而过滤一些不想要的东西
        Header contentType = entity.getContentType();
        // 打印响应信息
        System.out.println("name : " + contentType.getName() + " , value: " + contentType.getValue());

        // 将返回结果转换为字符串进行查看（网页内容），参数一是请求返回的entity，参数二是字符集编码
        String result = null;
        try {
            result = EntityUtils.toString(entity, "UTF-8");
        } catch (ParseException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        // 打印请求返回的结果
        // System.out.println(result.toString());

        // 讲获取到网页转换成为jsoup进行处理，返回结果为Document文档
        Document document = Jsoup.parse(result);
        Elements elements = document.getElementsByTag("title");
        Element element = elements.get(0);
        System.out.println("获取到的标题內容： " + element.text().toString());

        // 获取到自己的博客题目名称内容
        Elements elementsByClass = document.getElementsByClass("postTitle2");
        for (Element e : elementsByClass) {
            System.out.println("获取到的标题内容是： " + e.text());
        }

        // 第五步，关闭流，释放资源
        try {
            response.close();
            httpClient.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        HttpClientToJsoup.httpGetRequest();
    }

}

4、Jsoup的主要作用是，用HttpClient获取到网页后，具体的网页提取需要的信息的时候 ，就用到Jsoup，Jsoup可以使用强大的类似Jquery，css选择器，来获取需要的数据；

Jsoup官方地址：https://jsoup.org/
Jsoup最新下载：https://jsoup.org/download
Jsoup学习文档：https://jsoup.org/cookbook/introduction/parsing-a-document

5、Jsoup查找DOM元素的主要方法，如下所示：

　　1）、getElementById(String id) 根据 id 来查询 DOM。
　　2）、getElementsByTag(String tagName) 根据 tag 名称来查询 DOM。
　　3）、getElementsByClass(String className) 根据样式名称来查询 DOM。
　　4）、getElementsByAttribute(String key) 根据属性名，标签的属性元素来查询 DOM。
　　5）、getElementsByAttributeValue(String key,String value) 根据属性名和属性值来查询 DOM。

如果满足不了自己的需求，可以使用Jsoup 的选择器语法查找 DOM 元素，如下所示：

package com.bie.jsoup;

import java.io.IOException;

import org.apache.http.Header;
import org.apache.http.HttpEntity;
import org.apache.http.ParseException;
import org.apache.http.StatusLine;
import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.util.EntityUtils;
import org.jsoup.Jsoup;
import org.jsoup.nodes.Document;
import org.jsoup.nodes.Element;
import org.jsoup.select.Elements;

public class HttpClientToJsoup {

    // 设置请求头消息 User-Agent 模拟浏览器
    private static String UserAgent = "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:83.0) Gecko/20100101 Firefox/83.0";

    /**
     * HttpGet请求操作
     */
    public static void httpGetRequest() {
        // 第一步，获取到httpClient客户端实例，获取到一个可关闭的httpClient客户端实例。
        CloseableHttpClient httpClient = HttpClients.createDefault();
        // 第二步，创建HttpGet或者HttpPost实例。
        String uri = "https://www.cnblogs.com/biehongli";
        HttpGet httpGet = new HttpGet(uri);
        // 设置请求头消息 User-Agent 模拟浏览器
        httpGet.setHeader("User-Agent", UserAgent);

        // 定义一个可响应的实例对象。
        CloseableHttpResponse response = null;
        try {
            // 第三步，发布一个请求，使用httpClient实例发送一个http协议的Get请求。
            response = httpClient.execute(httpGet);
            // 获取到响应的状态
            StatusLine statusLine = response.getStatusLine();
            System.out.println("响应状态： " + statusLine.toString() + ", 响应码： " + statusLine.getStatusCode());
        } catch (ClientProtocolException e) {
            // http协议异常
            e.printStackTrace();
        } catch (IOException e) {
            // io异常
            e.printStackTrace();
        }
        // 第四步，获取到返回的实体对象
        HttpEntity entity = response.getEntity();
        // 获取响应内容类型 Content-Type，获取到响应类型，从而过滤一些不想要的东西
        Header contentType = entity.getContentType();
        // 打印响应信息
        System.out.println("name : " + contentType.getName() + " , value: " + contentType.getValue());

        // 将返回结果转换为字符串进行查看（网页内容），参数一是请求返回的entity，参数二是字符集编码
        String result = null;
        try {
            result = EntityUtils.toString(entity, "UTF-8");
        } catch (ParseException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        // 打印请求返回的结果
        // System.out.println(result.toString());

        // 讲获取到网页转换成为jsoup进行处理，返回结果为Document文档
        Document document = Jsoup.parse(result);
        Elements elements = document.getElementsByTag("title");
        Element element = elements.get(0);
        System.out.println("获取到的标题內容： " + element.text().toString());

        // 通过选择器查找所有博客链接DOM,获取到自己的博客题目名称内容
        // 使用Jsoup的选择器
        Elements select = document.select("#centercontent .day .postTitle .postTitle2");
        for (Element e : select) {
            System.out.println("博客标题：" + e.text());
        }

        // 带有href属性的a元素
        Elements selectHref = document.select(".postTitle a[href]");
        for (Element e : selectHref) {
            System.out.println("博客标题：" + e.text());
        }

        // 查找扩展名为.png的图片DOM节点
        Elements imgElements = document.select("img[src$=.png]");
        for (Element e : imgElements) {
            System.out.println(e.toString());
        }

        // 获取tag是title的所有DOM元素
        Element first = document.getElementsByTag("title").first();
        String title = first.text(); // 返回元素的文本
        System.out.println("网页标题是：" + title);

        // 第五步，关闭流，释放资源
        try {
            response.close();
            httpClient.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        HttpClientToJsoup.httpGetRequest();
    }

}

6、使用选择器语法查找元素，Jsoup elements对象支持类似于CSS (或jquery)的选择器语法，来实现非常强大和灵活的查找功能。这个select 方法在Document, Element,或Elements对象中都可以使用。且是上下文相关的，因此可实现指定元素的过滤，或者链式选择访问。Select方法将返回一个Elements集合，并提供一组方法来抽取和处理结果。如下所示：

package com.bie.jsoup;

import java.io.IOException;

import org.apache.http.Header;
import org.apache.http.HttpEntity;
import org.apache.http.ParseException;
import org.apache.http.StatusLine;
import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.util.EntityUtils;
import org.jsoup.Jsoup;
import org.jsoup.nodes.Document;
import org.jsoup.nodes.Element;
import org.jsoup.select.Elements;

public class HttpClientToJsoup {

    // 设置请求头消息 User-Agent 模拟浏览器
    private static String UserAgent = "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:83.0) Gecko/20100101 Firefox/83.0";

    /**
     * HttpGet请求操作
     */
    public static void httpGetRequest() {
        // 第一步，获取到httpClient客户端实例，获取到一个可关闭的httpClient客户端实例。
        CloseableHttpClient httpClient = HttpClients.createDefault();
        // 第二步，创建HttpGet或者HttpPost实例。
        String uri = "https://www.cnblogs.com/biehongli";
        HttpGet httpGet = new HttpGet(uri);
        // 设置请求头消息 User-Agent 模拟浏览器
        httpGet.setHeader("User-Agent", UserAgent);

        // 定义一个可响应的实例对象。
        CloseableHttpResponse response = null;
        try {
            // 第三步，发布一个请求，使用httpClient实例发送一个http协议的Get请求。
            response = httpClient.execute(httpGet);
            // 获取到响应的状态
            StatusLine statusLine = response.getStatusLine();
            System.out.println("响应状态： " + statusLine.toString() + ", 响应码： " + statusLine.getStatusCode());
        } catch (ClientProtocolException e) {
            // http协议异常
            e.printStackTrace();
        } catch (IOException e) {
            // io异常
            e.printStackTrace();
        }
        // 第四步，获取到返回的实体对象
        HttpEntity entity = response.getEntity();
        // 获取响应内容类型 Content-Type，获取到响应类型，从而过滤一些不想要的东西
        Header contentType = entity.getContentType();
        // 打印响应信息
        System.out.println("name : " + contentType.getName() + " , value: " + contentType.getValue());

        // 将返回结果转换为字符串进行查看（网页内容），参数一是请求返回的entity，参数二是字符集编码
        String result = null;
        try {
            result = EntityUtils.toString(entity, "UTF-8");
        } catch (ParseException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        // 打印请求返回的结果
        // System.out.println(result.toString());

        // 讲获取到网页转换成为jsoup进行处理，返回结果为Document文档
        Document document = Jsoup.parse(result);

        // Jsoup 使用selector选择器
        Elements linkElements = document.select("#centercontent .day .postTitle .postTitle2"); // 通过选择器查找所有博客链接DOM
        for (Element e : linkElements) {
            System.out.println("博客标题：" + e.text());
            System.out.println("博客地址：" + e.attr("href"));
            // System.out.println("target：" + e.attr("target"));
        }

        // Jsoup 使用selector选择器
        Element linkElement = document.select(".postTitle2").first();
        System.out.println("纯文本内容：" + linkElement.text());
        System.out.println("Html内容：" + linkElement.html());

        // 第五步，关闭流，释放资源
        try {
            response.close();
            httpClient.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        HttpClientToJsoup.httpGetRequest();
    }

}

1、Selector选择器概述，如下所示：
1）、tagname: 通过标签查找元素，比如：a。
2）、ns|tag: 通过标签在命名空间查找元素，比如：可以用 fb|name 语法来查找 <fb:name> 元素。
3）、#id: 通过ID查找元素，比如：#logo。
4）、.class: 通过class名称查找元素，比如：.masthead。
5）、[attribute]: 利用属性查找元素，比如：[href]。
6）、[attr=value]: 利用属性值来查找元素，比如：[width=500]。


// 案例使用，使用选择器
// tagname: 通过标签查找元素，比如：a
str = doc.select("a").first().text();

// ns|tag: 通过标签在命名空间查找元素，比如：可以用 fb|name 语法来查找 <fb:name> 元素
str = doc.select("jsoup|li").first().text();

// #id: 通过ID查找元素，比如：#logo
str = doc.select("#auto-header-fenzhan").first().text();

// .class: 通过class名称查找元素，比如：.masthead
str = doc.select(".orangelink").first().text();

// [attribute]: 利用属性查找元素，比如：[href]
str = doc.select("[abc]").first().text();

// [attr=value]: 利用属性值来查找元素，比如：[width=500]
str = doc.select("[class=vlli]").first().text();


2、Selector选择器组合使用，如下所示：
1）、el#id: 元素+ID，比如： div#logo。
2）、el.class: 元素+class，比如： div.masthead。
3）、el[attr]: 元素+属性名，比如： a[href]。
4）、任意组合，比如：a[href].highlight。
5）、ancestor child: 查找某个元素下子元素，比如：.body p 查找"body"下的所有 p。
6）、parent > child: 查找某个父元素下的直接子元素，比如：div.content > p 查找 p。
7）、parent > * 查找某个父元素下所有直接子元素。


// 案例使用，组合选择器
// el#id: 元素+ID，比如： div#logo
str = doc.select("li#auto-header-fenzhan").first().text();

// el.class: 元素+class，比如： div.masthead
str = doc.select("a.greylink").first().text();

// el[attr]: 元素+属性，比如： a[href]
str = doc.select("a[href]").first().attr("href");

// 任意组合，比如：a[href].highlight
str = doc.select("a[href].greylink").first().attr("href");

// ancestor child: 查找某个元素下子元素，比如：可以用.body p 查找"body"下的所有 p
str = doc.select("div.mini-left a").text();

// parent > child: 查找某个父元素下的直接子元素，比如：div.content > p 查找 p
str = doc.select("div.mini-left ul > li").text();

// parent > * 查找某个父元素下所有直接子元素
Elements elements = doc.select("div.mini-left > *");
for (Element ele : elements) {
    System.out.println(ele.tagName());
}