小组分享内容第一部分：总览+HttpClients

<dependency>
    <groupId>org.apache.httpcomponents.client5</groupId>
    <artifactId>httpclient5</artifactId>
    <version>5.4-alpha2</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.slf4j/slf4j-log4j12 -->
<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-log4j12</artifactId>
    <version>1.7.5</version>
</dependency>

引入进来日志之后还需要进行修改，否则会报错，不引入slf4j-log4j12这个玩意来搞日志也会报错，需要maven工程的resouces目录中新建一个名为log4j.properties的文件，并且复制进去下方的配置信息

log4j.rootLogger = DEBUG, console
log4j.appender.console=org.apache.log4j.ConsoleAppender
log4j.appender.console.target=System.out
log4j.appender.console.layout=org.apache.log4j.PatternLayout
log4j.appender.console.layout.ConversionPattern=%d{yy/MM/dd HH:mm:ss} %p %c{2}: %m%n

2.使用java的HttpClient来进行网页数据的抓取

3.使用jsoup来分析抓取到的网络数据

3.1使用jsoup分析的时候要引入进来四个包，因为有很多操作需要别的类

3.2：这四个包坐标如下，把这个坐标直接添加到maven工程的pom.xml文件中就可以了

<dependency>
            <groupId>org.jsoup</groupId>
            <artifactId>jsoup</artifactId>
            <version>1.15.3</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/junit/junit -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
        <!-- https://mvnrepository.com/artifact/commons-io/commons-io -->
<!--        这个里面有与文件操作相关的类，例如FileUtils-->
        <dependency>
            <groupId>commons-io</groupId>
            <artifactId>commons-io</artifactId>
            <version>2.11.0</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.apache.commons/commons-lang3 -->
<!--        这个里面有与字符串相关的类，例如StringUtils-->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
            <version>3.12.0</version>
        </dependency>

3.不使用程序进行网页信息的获取的操作步骤

3.1：打开浏览器

3.2：输入网址

3.3：按下回车（发出请求）

3.4：获取响应

3.5：解析响应成为人可以看懂的东西

4.如何使用程序来进行上述操作

1.打开浏览器

使用CloseableHttpClient来表示一个可以关闭的浏览器，所以首先创建一个浏览器对象

CloseableHttpClient closeableHttpClient = HttpClients.createDefault();

2.输入网址

使用HttpGet来向浏览器发送一个请求，请求的时候需要在创建对象的时候给这个对象一个形参，意思是要访问形参里的地址，在这里我选择了使用学校的雪梨官网，我怕别的网址违法

HttpGet url = new HttpGet("https://www.iqiyi.com/?vfm=f_809_lxm&fv=94f9f9e5a81b83a5");

3.发送请求

使用CloseableHttpClient对象的excute(网址)方法来模拟人按下回车的行为，这个方法会返回一个服务器方对我们的一个响应

closeableHttpClient.execute(url);

4.获取响应

通过CloseableRespnose来接受服务器返回的响应

CloseableHttpResponse response = closeableHttpClient.execute(url);

5.判断响应是否成功

为了成功获得响应不获取乱七八糟的东西就要想办法判断一下是否是正确的反馈，所以使用CloseableClient对象的getCode方法来获取服务器提供的状态码（正常获取到信息时的状态码是200），只有当我获取到了正确的状态码我才进行下一步的处理

if(response.getCode()==200)

6.获取响应里需要的内容

获取到了响应还不够，咱需要获取到响应里的信息，可以通过CloseableResponse对象的getEntity方法获取到响应体（响应头响应体响应行这些知识点可以参考下面这个帖子，我觉得这个解释的挺好理解的：HTTP响应是什么？_3、http响应的内容是什么-CSDN博客 HTTP响应是什么？_3、http响应的内容是什么-CSDN博客 HTTP响应是什么？_3、http响应的内容是什么-CSDN博客）可以通过EntityUtils类的静态方法toString来把响应体按照所需要的编码格式转化成字符串，访问雪梨获取到的就是他的html代码

if(response.getCode()==200)
    EntityUtils.toString(response.getEntity(),"utf8");

7.记得最后关闭浏览器和response

8.完整的简单示例

package org.example;
import org.apache.hc.client5.http.classic.methods.HttpGet;
import org.apache.hc.client5.http.impl.classic.CloseableHttpClient;
import org.apache.hc.client5.http.impl.classic.CloseableHttpResponse;
import org.apache.hc.client5.http.impl.classic.HttpClients;
import org.apache.hc.core5.http.ParseException;
import org.apache.hc.core5.http.io.entity.EntityUtils;
import java.io.IOException;
public class CanNumGet {
    public static void main(String[] args) {
        //人工获取页面信息操作流程：
        //打开浏览器
        CloseableHttpClient closeableHttpClient = HttpClients.createDefault();
        //输入网址
        HttpGet url = new HttpGet("http://www.edu2act.cn/votes/");
        CloseableHttpResponse response =null;
        //回车打开网址并且获取响应
        try {
            response= closeableHttpClient.execute(url);
            if(response.getCode()==200)
                System.out.println(EntityUtils.toString(response.getEntity(),"utf8"));
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ParseException e) {
            throw new RuntimeException(e);
        } finally {
            try {
                response.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                closeableHttpClient.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

5.带参数的get请求

之前的内容都是最基础的get请求，现在开始带参数的请求，在servlet的那节课的时候曾经提到过get请求可以有参数

例如在进行搜索的时候会进行一个参数的传递，传递给后台

1.如何使用发送带参数的get请求

在之前的内容中只提到了如何发送get请求，当时使用的是new一个HttpGet请求，参数是个String类型的网址，其实他的构造方法还可以不传递网址，而是传递一个URI，这个URI对我来讲可以简单理解为一个URL带参数的查询方式，但这只是一种记忆方式，建议按照正规方式慢慢理解，可以参考下面两篇帖子

今天，彻底弄懂什么是URI-CSDN博客

URI是什么?-CSDN博客

第二篇建议从第三部分开始看，算是入正题了

2.如何创建这个URI呢

需要使用URIBulider类来创建，你可以把这玩意当作一个构造URI的构造器

1.首先创建一个URIBulider对象，构造方法形参就是个URL

URIBuilder uriBuilder = new URIBuilder("http://www.edu2act.cn/votes/");

2.创建好URIBulider对象之后需要给这个URI设置参数

使用URIBulider对象的addparametter("参数名（key）","参数值（value）")，这个方法的返回值就是调用该方法的对象，所以可以反复调用这个方法从而设置更多参数

eg：uriBuilder.addParameter("key1","a").addParameter("key2","2").addParameter("key3","3");

这样子就相当于设置了三组参数

uriBuilder.addParameter("q","操作系统");

3.仅仅设置参数还不够，还需要创建出来URI对象呢

HttpGet url = new HttpGet(uriBuilder.build());

4.后续操作就和之前的一样了

package org.example;
import org.apache.hc.client5.http.classic.methods.HttpGet;
import org.apache.hc.client5.http.impl.classic.CloseableHttpClient;
import org.apache.hc.client5.http.impl.classic.CloseableHttpResponse;
import org.apache.hc.client5.http.impl.classic.HttpClients;
import org.apache.hc.core5.http.ParseException;
import org.apache.hc.core5.http.io.entity.EntityUtils;
import org.apache.hc.core5.net.URIBuilder;
import java.io.IOException;
import java.net.URISyntaxException;

public class CanNumGet {
    public static void main(String[] args) {
        //人工获取页面信息操作流程：
        //打开浏览器
        CloseableHttpClient closeableHttpClient = HttpClients.createDefault();
        URIBuilder uriBuilder = null;
        try {
            uriBuilder = new URIBuilder("http://www.edu2act.cn/votes/");
            uriBuilder.addParameter("q","操作系统");
        } catch (URISyntaxException e) {
            e.printStackTrace();
        }
        //输入网址
        HttpGet url = null;
        try {
            url = new HttpGet(uriBuilder.build());
        } catch (URISyntaxException e) {
            e.printStackTrace();
        }
        CloseableHttpResponse response =null;
        //回车打开网址并且获取响应
        try {
            response= closeableHttpClient.execute(url);
            if(response.getCode()==200)
                System.out.println(EntityUtils.toString(response.getEntity(),"utf8"));
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ParseException e) {
            throw new RuntimeException(e);
        } finally {
            try {
                response.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                closeableHttpClient.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

6.无参Post请求如何处理

只需要把无参get请求中的HttpGet换成HttpPost就可以了

7.有参Post请求如何处理

整体上有参Post也是在无参post的基础上添加上一些参数，

Get请求是传递给HttpGet一个uri，需要给用uri构造器送入参数然后创建出来uri再把uri当作参数传递给httpget的构造方法

1.如何创建有参的Post请求

而有参post请求其实就是先构造出来一个url实体，new的时候使用的构造方法有两个参数第一个参数是一个web页面的参数集合，第二个参数是编码方式，创建出来这个实体之后使用HttpGet对象的setEntity方法传递进去刚才创建出来的url实体就好

2.如何为原有的HttpGet请求添加参数

1.创建出来一个参数集合来存放参数，这些参数以NameValuePair对象(其实是BasicNameValuePair)的形式存在

List<NameValuePair> paramList = new ArrayList<>();

2.把BasicNameValuePair对象传入进参数集合当中

 paramList.add(new BasicNameValuePair("username","1123019893@qq.com"));
 paramList.add(new BasicNameValuePair("password","......"));
 paramList.add(new BasicNameValuePair("csrfmiddlewaretoken","kVkh9YxBwvs3V8FU8ADrsI1D04MuQSb5xFsOI8ZJ3GPyamLFHNloTNwcJHvpe7e3"));

3.创建UrlEncodingFormEntity对象

这个对象在我看来其实可以理解为是可以拼接在url后面的参数实体，每一组参数在list里面是一个元素，然后这个对象感觉起来就象是把元素与元素用&连接在一起。

UrlEncodedFormEntity postParamEntity = new UrlEncodedFormEntity(paramList,Charset.forName("utf-8"));

4.使用HttpPost对象的setEntity方法把刚才创建的UrlEncodingFormEntity对象添加给HttpPost对象

这个方法我觉得可以理解为把传递进来的UrlEncodingFormEntity所代表的参数串拼接到原有的URL的后面

url.setEntity(postParamEntity);

5.完整有参Post的代码

package org.example;


import org.apache.hc.client5.http.classic.methods.HttpPost;
import org.apache.hc.client5.http.entity.UrlEncodedFormEntity;
import org.apache.hc.client5.http.impl.classic.CloseableHttpClient;
import org.apache.hc.client5.http.impl.classic.CloseableHttpResponse;
import org.apache.hc.client5.http.impl.classic.HttpClients;
import org.apache.hc.core5.http.NameValuePair;
import org.apache.hc.core5.http.ParseException;
import org.apache.hc.core5.http.io.entity.EntityUtils;
import org.apache.hc.core5.http.message.BasicNameValuePair;

import java.io.IOException;
import java.nio.charset.Charset;
import java.util.ArrayList;
import java.util.List;

public class CanNumPost{
    public static void main(String[] args) throws Exception{
        //人工获取页面信息操作流程：
        //打开浏览器
        CloseableHttpClient closeableHttpClient = HttpClients.createDefault();
        //输入网址
        HttpPost url = new HttpPost("http://www.edu2act.cn/login/");
        //为了添加参数，可以需要在这里存储下来参数
        List<NameValuePair> paramList = new ArrayList<>();
        paramList.add(new BasicNameValuePair("username","1123019893@qq.com"));
        paramList.add(new BasicNameValuePair("password","......."));
        paramList.add(new BasicNameValuePair("csrfmiddlewaretoken","kVkh9YxBwvs3V8FU8ADrsI1D04MuQSb5xFsOI8ZJ3GPyamLFHNloTNwcJHvpe7e3"));
        //刚才是创建了参数，还需要给一个实体来把参数设置给承载参数的url实体，使用UrlEncodedFormEntity来记录
        UrlEncodedFormEntity postParamEntity = new UrlEncodedFormEntity(paramList,Charset.forName("utf-8"));
        url.setEntity(postParamEntity);
        CloseableHttpResponse response =null;
        //回车打开网址
        try {
            response= closeableHttpClient.execute(url);
//            if(response.getCode()==200)
                System.out.println(EntityUtils.toString(response.getEntity(),"utf8"));
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ParseException e) {
            throw new RuntimeException(e);
        } finally {
            try {
                response.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                closeableHttpClient.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

这里我个人在刚刚访问的时候遇到了一些问题，接收到的状态码是403，也就是雪梨官网有个csrf验证，我查了查在后面的jsoup可以解决这个问题所以访问失败别心慌

8.使用连接池来管理HttpClient

1.为什么使用这玩意来管理？

在爬取网络资源的过程中需要发出很多的HttpClient请求，频繁的创建与销毁HttpClient，这件事过于消耗资源，且频繁的建立销毁，会反复进行三次握手（HTTP是TCP的，所以就很费事），所以选择连接池来管理，让她在适当的时机释放和创建，咱用HttpClient的时候就只是用它创建的对象就可以了

2.如何操作

1.操作的时候第一步肯定是先把这个池子（）创建出来

PoolingHttpClientConnectionManager cm = new PoolingHttpClientConnectionManager();

2.创建一个HttpClientBuilder对象

根据使用的原因，可以确定我需要有一个可以生成CloseableHttpClient对象的构造器，这个构造器是由PoolHttpClientConnectionManager对象来进行管理的

1.首先先创建出来builder对象：使用HttpClients.custom()

HttpClientBuilder builder= HttpClients.custom();

2.为这个builder设定上管理器：使用builder.setConnectionManager(连接池对象)

该方法的返回值就是调用方法的这个对象

builder = builder.setConnectionManager(cm);

3.创建CloseableHttpClient对象

每次想要创建请求的时候就只需要进行HttpClientBuilder对象调用他的.build()方法就可以由被连接池管理的构造器生成一个被连接池管理的CloseableHttpClient对象了

CloseableHttpClient httpClient = builder.build();

4.为了方便，可以把发请求拿响应包裹成一个方法

public static void doIn(PoolingHttpClientConnectionManager cm,String url){
    //这次是在连接池当中创建出来一个可关闭的HttpClient对象
        //第三步的.build是利用刚才那个分配了连接池管理器的HttpClientBuilder对象来创建出一个CloseableHttpClient对象，这样每次创建出来的HttpClient就会由连接池来管理了
    CloseableHttpClient httpClient = builder.build();
    HttpGet hg = new HttpGet(url);
    CloseableHttpResponse response=null;
    try {
        response = httpClient.execute(hg);
        if(response.getCode()==200){
            System.out.println("OK\nOK\nOK\nOK\nOK\nOK\nOK\nOK\nOK\nOK\nOK\nOK\nOK\nOK\nOK\nOK");
        }
    } catch (IOException e) {
        e.printStackTrace();
    }
}

5.设置连接数

1.最大连接数

总不能无限的使用资源吧

//设置最大连接数：意思是我最多可以发出多少个连接请求
cm.setMaxTotal(100);//cm是一个PoolHttpClientConnectionManager对象

2.设置单个主机的最大连接数

在爬取数据的时候不一定只访问一台服务器（主机）的数据，有可能正在访问一个主机的时候也访问了其他主机，假如我的最大连接数是100，现在如果我不设置单个主机的最大连接数，就有可能会导致我所有的连接都在和第一台主机进行连接，导致无法和第二台主机连接获取数据

//设置主机最大连接数：也就是最多可以和某个服务器建立多少个连接
cm.setDefaultMaxPerRoute(10);//在这里cm就是上面那个PoolHttpClientConnectionManager对象

6.完整的操作代码

package org.example;

import org.apache.hc.client5.http.classic.methods.HttpGet;
import org.apache.hc.client5.http.impl.classic.CloseableHttpClient;
import org.apache.hc.client5.http.impl.classic.CloseableHttpResponse;
import org.apache.hc.client5.http.impl.classic.HttpClientBuilder;
import org.apache.hc.client5.http.impl.classic.HttpClients;
import org.apache.hc.client5.http.impl.io.PoolingHttpClientConnectionManager;

import java.io.IOException;

public class PoolHttpClient {
    //第一个.custom是创建出来一个HttpClientBuilder对象
    HttpClientBuilder builder= HttpClients.custom();
    public void manager(){
        //首先创建出来连接池管理这些HttpClient对象
        PoolingHttpClientConnectionManager cm = new PoolingHttpClientConnectionManager();
        //设置最大连接数：意思是我最多可以发出多少个连接请求
        cm.setMaxTotal(100);
        //设置主机最大连接数：也就是最多可以和某个web服务器建立多少个连接
        cm.setDefaultMaxPerRoute(10);
        //.set是给这个builder对象绑定管理器用的，返回值是他本身，可以没东西接收这个返回值，但是绑定是已经绑定成功了的
        builder.setConnectionManager(cm);
        doIn(cm,"https://www.loyo.cc/");//我在这个方法里让这个操作循环了三次，意思是让你能够看到对于同一个主机他每次访问都只是占用了一个连接，就算是我访问了多次，他也是只是在连接池里找寻连接，然后通过这个连接进行爬取，而不会新建连接
    }
    public static void main(String[] args) {
        //首先创建出来连接池管理这些HttpClient对象
        new PoolHttpClient().manager();
    }
    public void doIn(PoolingHttpClientConnectionManager cm, String url){
        //这次是在连接池当中创建出来一个可关闭的HttpClient对象
        //第三步的.build是利用刚才那个分配了连接池管理器的HttpClientBuilder对象来创建出一个CloseableHttpClient对象，这样每次创建出来的HttpClient就会由连接池来管理了
        for(int i = 0;i<3;i++) {
            CloseableHttpClient httpClient = builder.build();
            HttpGet hg = new HttpGet(url);
            CloseableHttpResponse response = null;
            try {
                response = httpClient.execute(hg);
                if (response.getCode() == 200) {
                    System.out.println("OK\nOK\nOK\nOK\nOK\nOK\nOK\nOK\nOK\nOK\nOK\nOK\nOK\nOK\nOK\nOK");
                }
                System.out.println("最大可连接数:"+cm.getTotalStats().getMax());
                System.out.println("当前连接数:"+cm.getTotalStats().getLeased());
            } catch (IOException e) {
                e.printStackTrace();
            }finally {
                try {
                    response.close();//如果这里我把close注释掉，相当于我循环的这一次会一直占用着一个连接，那么我下一次循环就会开辟新的，所以我需要在这里关闭掉我的链接
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

如果还有问题的话，可以参考下面这篇帖子

HttpClient4.5.2 HttpClientBuilder配置使用连接池-CSDN博客

9.对请求添加配置

这里说的配置，其实就是要求，在整个爬取资源的过程中提出的一些要求限制

像是get，post之类的请求，咱也是需要要求一些事情的（后面这个例子可能不咋有道德，但是这也就是个例子，用来理解一下就行，别当真），就假如你是个盲人，进入到了一家虽然有很多人非常安静的没有扫码点单的饭店，这家店只有一个服务员，1.你叫他之后他来到你面前的时间（建立连接的时间）你可以规定，他来晚了你一生气直接不吃了，2.除此之外当你点菜过程中(你跟他获取连接的时间)你跟他说一句话他想半天才能想出来你要的什么菜这样也不行，你也可以拍屁股走人，再者，他上菜慢了(数据传递的时间)，咱一样可以走人

像上面这样，其实咱再发出请求之后其实还可以提一些要求的（以下这些时间的单位都是毫秒）

配置信息也是个类：RequesetConfig

1.首先创建出配置信息构造器

RequestConfig rc = RequestConfig.custom();

2.开始进行配置

1.这里面使用刚才创建出来的Builder对象进行配置

RequestConfig cr = RequestConfig.custom().setConnectionRequestTimeout(Timeout.ofMilliseconds(1000)).setConnectionKeepAlive(Timeout.ofMilliseconds(1000)).build();

2.最后记得给请求绑定上这个配置（这里以get请求为例）

url.setConfig(cr);

3.“配置”信息的这些方法的特征：

这些方法以set开头，具体什么意思网上搜搜吧，实在懒得写了，但是他们有个共同点：返回值是调用他们的Builder

4.配置时间的方法的注意事项

像是setConnectionRequestTimeout，这类方法已经没法用纯数字作为构造参数了，我也不知道为啥，所以需要用Timeout.ofMilliseconds(数字)来包裹上你想设定的毫秒数然后放到形参里面

5.完整代码

package org.example;

import org.apache.hc.client5.http.classic.methods.HttpGet;
import org.apache.hc.client5.http.config.RequestConfig;
import org.apache.hc.client5.http.impl.classic.CloseableHttpClient;
import org.apache.hc.client5.http.impl.classic.CloseableHttpResponse;
import org.apache.hc.client5.http.impl.classic.HttpClients;
import org.apache.hc.client5.http.impl.classic.RequestAbortedException;
import org.apache.hc.core5.http.ParseException;
import org.apache.hc.core5.http.io.entity.EntityUtils;
import org.apache.hc.core5.util.Timeout;

import java.io.IOException;

public class GetHttpConfig {
    public static void main(String[] args) {
        //人工获取页面信息操作流程：
            //打开浏览器
        CloseableHttpClient closeableHttpClient = HttpClients.createDefault();
            //输入网址
        HttpGet url = new HttpGet("https://www.loyo.cc/");
        RequestConfig cr = RequestConfig.custom().setConnectionRequestTimeout(Timeout.ofMilliseconds(1000)).setConnectionKeepAlive(Timeout.ofMilliseconds(1000)).build();
        url.setConfig(cr);
        CloseableHttpResponse response =null;
        //回车打开网址
        try {
            response= closeableHttpClient.execute(url);
            if(response.getCode()==200)
                System.out.println(EntityUtils.toString(response.getEntity(),"utf8"));
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ParseException e) {
            throw new RuntimeException(e);
        } finally {
            try {
                response.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                closeableHttpClient.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}