httpclient 抓取网页
httpclient 抓取网页(2021-05-24欢迎访问我的个人网站-广州图书馆)
网站优化 • 优采云 发表了文章 • 0 个评论 • 57 次浏览 • 2022-04-19 19:18
httpclient 抓取网页(2021-05-24欢迎访问我的个人网站-广州图书馆)
2021-05-24
欢迎来到我的个人网站，如果能在GitHub上给网站的源码打个star就更好了。
在构建自己的网站时，我想记录我读过和借过的所有书。大学也爬过自己学校的借阅记录，但是数据库已经被删除了==，只有一张截图。所以你要珍惜你阅读的日子，记录你的借阅记录——广州图书馆，现在代码已经放到服务器上定期运行，结果查看我的网站（关于我）页面。整个代码使用HttpClient，存储在MySql中，定期使用Spring自带的Schedule。下面是爬取的过程。
1.页面跳转过程
一般是进入首页，点击进入登录页面，然后输入账号密码。从表面上看，它似乎并没有什么特别之处。事实上，在模拟登录的时候，并不仅仅是向链接发布请求那么简单。生成的响应将跳转回登录页面或无限制地重定向。
其实就是做单点登录的，如下图，广州图书馆的网址是：，登录的网址是：。网上很多人都很好的解释了原理。您可以阅读此 文章SSO 单点登录。
2.处理方式
解决方法不难，只要先模拟访问首页获取库的session，python获取代码如：session.get("")，打印cookie后如下：
[, , ]
整个登录和抓取过程如下：
这是：
（1）用户先点击广州图书馆首页，获取换站session，然后点击登录界面，解析html，获取lt（自定义参数，类似验证码），单点登录服务器会话。
(2）向目标服务器（单点登录服务器）提交post请求，请求参数包括username（用户名）、password（密码）、event（时间，默认为submit）、lt（自定义request parameters) ，服务器还需要对参数进行校验：refer（源页面）、host（主机信息）、Content-Type（类型）。
(3）打印响应，搜索自己的名字，如果有则表示成功，否则会跳转回登录页面。
(4）使用cookies访问其他页面，这里是借阅历史的爬取，所以访问的页面是：.
这是基本的模拟登录和获取，然后是对面的html的解析，得到书名、书索引等，然后封装成JavaBean，然后存入数据库。（没做过，不知道用什么方法比较好）
3.代码
3.1 在Java中，大部分的httpclients一般都是用来提交http请求的。一、需要导入的httpclient相关包：
org.apache.httpcomponents
httpclient
4.5.3
org.apache.httpcomponents
httpcore
4.4.7
3.2 构建和声明全局变量——上下文管理器，其中context是上下文管理器
public class LibraryUtil {
private static CloseableHttpClient httpClient = null;
private static HttpClientContext context = null;
private static CookieStore cookieStore = null;
static {
init();
}
private static void init() {
context = HttpClientContext.create();
cookieStore = new BasicCookieStore();
// 配置超时时间
RequestConfig requestConfig = RequestConfig.custom().setConnectTimeout(12000).setSocketTimeout(6000)
.setConnectionRequestTimeout(6000).build();
// 设置默认跳转以及存储cookie
httpClient = HttpClientBuilder.create()
.setKeepAliveStrategy(new DefaultConnectionKeepAliveStrategy())
.setRedirectStrategy(new DefaultRedirectStrategy()).setDefaultRequestConfig(requestConfig)
.setDefaultCookieStore(cookieStore).build();
}
...
3.3 声明一个get函数，其中header可以自定义，这里不需要，但保留它，使其成为通用的。
public static CloseableHttpResponse get(String url, Header[] header) throws IOException {
HttpGet httpget = new HttpGet(url);
if (header != null && header.length > 0) {
httpget.setHeaders(header);
}
CloseableHttpResponse response = httpClient.execute(httpget, context);//context用于存储上下文
return response;
}
3.4 访问主页获取会话。服务器上的session是按session存储的，本地浏览器使用cookies。只要本地不注销，也可以使用本地cookie访问，但是为了达到模拟登录的效果，这里不再赘述。
CloseableHttpResponse homeResponse = get("http://www.gzlib.gov.cn/", null);
homeResponse.close();
此时如果打印cookie，可以看到当前cookie如下：
3.5 访问登录页面，获取单点登录服务器后的cookie，解析网页，获取自定义参数lt。这里的解析网页使用的是Jsoup，语法类似于python中的BeautifulSoup。
String loginURL = "http://login.gzlib.gov.cn/sso- ... 3B%3B
CloseableHttpResponse loginGetResponse = get(loginURL, null);
String content = toString(loginGetResponse);
String lt = Jsoup.parse(content).select("form").select("input[name=lt]").attr("value");
loginGetResponse.close();
此时再看cookie，又多了一个（）：
3.6 声明一个post函数来提交一个post请求，这里提交的参数默认为
public static CloseableHttpResponse postParam(String url, String parameters, Header[] headers)
throws IOException {
System.out.println(parameters);
HttpPost httpPost = new HttpPost(url);
if (headers != null && headers.length > 0) {
for (Header header : headers) {
httpPost.addHeader(header);
}
}
List nvps = toNameValuePairList(parameters);
httpPost.setEntity(new UrlEncodedFormEntity(nvps, "UTF-8"));
CloseableHttpResponse response = httpClient.execute(httpPost, context);
return response;
}
3.7 登录成功后，如果没有声明returnurl，即登录链接为()，那么只会显示登录成功页面：
后台应该定义一个链接跳转的服务。如果想在登录成功后得到跳转页面，可以在服务后修改链接，这里会保持原来的状态。此时查看cookie的结果如下：
其中，CASTGC的出现说明登录成功，该cookie可用于访问广州图书馆的其他页面。在python中是直接跳转到其他页面，但是在java中使用httpclient的过程中，看到的并不是直接跳转。，但 302 重定向。打印Header后，结果如下：
如果你仔细研究一下链接，你会发现服务器相当于给了一张通用票，即：你可以用这张票访问任何页面，returnUrl 就是返回的页面。这里我们直接访问重定向的 url。
Header header = response.getHeaders("Location")[0];
CloseableHttpResponse home = get(header.getValue(), null);
然后打印页面得到登录后跳转回的首页。
3.8 解析html
获取session并跳转回首页后，访问借阅历史页面，然后将结果解析为html。在python中使用了BeautifulSoup，简单实用，java中的jsoup也是不错的选择。
String html = getHTML();
Element element = Jsoup.parse(html).select("table.jieyue-table").get(0).select("tbody").get(0);
Elements trs = element.select("tr");
for (int i = 0; i < trs.size(); i++) {
Elements tds = trs.get(i).select("td");
System.out.println(tds.get(1).text());
}
输出结果：
企业IT架构转型之道
大话Java性能优化
深入理解Hadoop
大话Java性能优化
Java EE开发的颠覆者：Spring Boot实战
大型网站技术架构：核心原理与案例分析
Java性能权威指南
Akka入门与实践
高性能网站建设进阶指南：Web开发者性能优化最佳实践：Performance best practices for Web developers
Java EE开发的颠覆者：Spring Boot实战
深入理解Hadoop
大话Java性能优化
点击查看源代码
总结
目前修改后的代码已经集成到个人网站中，每天定时抓取，但是还有很多事情没有做（比如分页、去重等），如果你有兴趣的可以研究下源码，如果能帮助改进就更好了。谢谢♪(･ω･)ﾉ。整个代码接近250行，当然……包括注释，但是使用python后，只有25行=w=，这里是python的源代码。同时也欢迎大家访问我的个人网站，也欢迎大家给个star。
import urllib.parse
import requests
from bs4 import BeautifulSoup
session = requests.session()
session.get("http://www.gzlib.gov.cn/")
session.headers.update(
{"Referer": "http://www.gzlib.gov.cn/member ... ot%3B,
"origin": "http://login.gzlib.gov.cn",
'Content-Type': 'application/x-www-form-urlencoded',
'host': 'www.gzlib.gov.cn',
'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/50.0.2661.102 Safari/537.36'
}
)
baseURL = "http://login.gzlib.gov.cn/sso-server/login"
soup = BeautifulSoup(session.get(baseURL).text, "html.parser")
lt = soup.select("form")[0].find(attrs={'name': 'lt'})['value']
postdict = {"username": "你的身份证",
"password": "密码（默认为身份证后6位）",
"_eventId": "submit",
"lt": lt
}
postdata = urllib.parse.urlencode(postdict)
session.post(baseURL, postdata)
print(session.get("http://www.gzlib.gov.cn/member ... 6quot;).text)
分类：
技术要点：
相关文章： 查看全部
2021-05-24
欢迎来到我的个人网站，如果能在GitHub上给网站的源码打个star就更好了。
在构建自己的网站时，我想记录我读过和借过的所有书。大学也爬过自己学校的借阅记录，但是数据库已经被删除了==，只有一张截图。所以你要珍惜你阅读的日子，记录你的借阅记录——广州图书馆，现在代码已经放到服务器上定期运行，结果查看我的网站（关于我）页面。整个代码使用HttpClient，存储在MySql中，定期使用Spring自带的Schedule。下面是爬取的过程。
1.页面跳转过程
一般是进入首页，点击进入登录页面，然后输入账号密码。从表面上看，它似乎并没有什么特别之处。事实上，在模拟登录的时候，并不仅仅是向链接发布请求那么简单。生成的响应将跳转回登录页面或无限制地重定向。
其实就是做单点登录的，如下图，广州图书馆的网址是：，登录的网址是：。网上很多人都很好的解释了原理。您可以阅读此 文章SSO 单点登录。
2.处理方式
解决方法不难，只要先模拟访问首页获取库的session，python获取代码如：session.get("")，打印cookie后如下：
[, , ]
整个登录和抓取过程如下：
这是：
（1）用户先点击广州图书馆首页，获取换站session，然后点击登录界面，解析html，获取lt（自定义参数，类似验证码），单点登录服务器会话。
(2）向目标服务器（单点登录服务器）提交post请求，请求参数包括username（用户名）、password（密码）、event（时间，默认为submit）、lt（自定义request parameters) ，服务器还需要对参数进行校验：refer（源页面）、host（主机信息）、Content-Type（类型）。
(3）打印响应，搜索自己的名字，如果有则表示成功，否则会跳转回登录页面。
(4）使用cookies访问其他页面，这里是借阅历史的爬取，所以访问的页面是：.
这是基本的模拟登录和获取，然后是对面的html的解析，得到书名、书索引等，然后封装成JavaBean，然后存入数据库。（没做过，不知道用什么方法比较好）
3.代码
3.1 在Java中，大部分的httpclients一般都是用来提交http请求的。一、需要导入的httpclient相关包：
org.apache.httpcomponents
httpclient
4.5.3
org.apache.httpcomponents
httpcore
4.4.7
3.2 构建和声明全局变量——上下文管理器，其中context是上下文管理器
public class LibraryUtil {
private static CloseableHttpClient httpClient = null;
private static HttpClientContext context = null;
private static CookieStore cookieStore = null;
static {
init();
}
private static void init() {
context = HttpClientContext.create();
cookieStore = new BasicCookieStore();
// 配置超时时间
RequestConfig requestConfig = RequestConfig.custom().setConnectTimeout(12000).setSocketTimeout(6000)
.setConnectionRequestTimeout(6000).build();
// 设置默认跳转以及存储cookie
httpClient = HttpClientBuilder.create()
.setKeepAliveStrategy(new DefaultConnectionKeepAliveStrategy())
.setRedirectStrategy(new DefaultRedirectStrategy()).setDefaultRequestConfig(requestConfig)
.setDefaultCookieStore(cookieStore).build();
}
...
3.3 声明一个get函数，其中header可以自定义，这里不需要，但保留它，使其成为通用的。
public static CloseableHttpResponse get(String url, Header[] header) throws IOException {
HttpGet httpget = new HttpGet(url);
if (header != null && header.length > 0) {
httpget.setHeaders(header);
}
CloseableHttpResponse response = httpClient.execute(httpget, context);//context用于存储上下文
return response;
}
3.4 访问主页获取会话。服务器上的session是按session存储的，本地浏览器使用cookies。只要本地不注销，也可以使用本地cookie访问，但是为了达到模拟登录的效果，这里不再赘述。
CloseableHttpResponse homeResponse = get("http://www.gzlib.gov.cn/", null);
homeResponse.close();
此时如果打印cookie，可以看到当前cookie如下：
3.5 访问登录页面，获取单点登录服务器后的cookie，解析网页，获取自定义参数lt。这里的解析网页使用的是Jsoup，语法类似于python中的BeautifulSoup。
String loginURL = "http://login.gzlib.gov.cn/sso- ... 3B%3B
CloseableHttpResponse loginGetResponse = get(loginURL, null);
String content = toString(loginGetResponse);
String lt = Jsoup.parse(content).select("form").select("input[name=lt]").attr("value");
loginGetResponse.close();
此时再看cookie，又多了一个（）：
3.6 声明一个post函数来提交一个post请求，这里提交的参数默认为
public static CloseableHttpResponse postParam(String url, String parameters, Header[] headers)
throws IOException {
System.out.println(parameters);
HttpPost httpPost = new HttpPost(url);
if (headers != null && headers.length > 0) {
for (Header header : headers) {
httpPost.addHeader(header);
}
}
List nvps = toNameValuePairList(parameters);
httpPost.setEntity(new UrlEncodedFormEntity(nvps, "UTF-8"));
CloseableHttpResponse response = httpClient.execute(httpPost, context);
return response;
}
3.7 登录成功后，如果没有声明returnurl，即登录链接为()，那么只会显示登录成功页面：
后台应该定义一个链接跳转的服务。如果想在登录成功后得到跳转页面，可以在服务后修改链接，这里会保持原来的状态。此时查看cookie的结果如下：
其中，CASTGC的出现说明登录成功，该cookie可用于访问广州图书馆的其他页面。在python中是直接跳转到其他页面，但是在java中使用httpclient的过程中，看到的并不是直接跳转。，但 302 重定向。打印Header后，结果如下：
如果你仔细研究一下链接，你会发现服务器相当于给了一张通用票，即：你可以用这张票访问任何页面，returnUrl 就是返回的页面。这里我们直接访问重定向的 url。
Header header = response.getHeaders("Location")[0];
CloseableHttpResponse home = get(header.getValue(), null);
然后打印页面得到登录后跳转回的首页。
3.8 解析html
获取session并跳转回首页后，访问借阅历史页面，然后将结果解析为html。在python中使用了BeautifulSoup，简单实用，java中的jsoup也是不错的选择。
String html = getHTML();
Element element = Jsoup.parse(html).select("table.jieyue-table").get(0).select("tbody").get(0);
Elements trs = element.select("tr");
for (int i = 0; i < trs.size(); i++) {
Elements tds = trs.get(i).select("td");
System.out.println(tds.get(1).text());
}
输出结果：
企业IT架构转型之道
大话Java性能优化
深入理解Hadoop
大话Java性能优化
Java EE开发的颠覆者：Spring Boot实战
大型网站技术架构：核心原理与案例分析
Java性能权威指南
Akka入门与实践
高性能网站建设进阶指南：Web开发者性能优化最佳实践：Performance best practices for Web developers
Java EE开发的颠覆者：Spring Boot实战
深入理解Hadoop
大话Java性能优化
点击查看源代码
总结
目前修改后的代码已经集成到个人网站中，每天定时抓取，但是还有很多事情没有做（比如分页、去重等），如果你有兴趣的可以研究下源码，如果能帮助改进就更好了。谢谢♪(･ω･)ﾉ。整个代码接近250行，当然……包括注释，但是使用python后，只有25行=w=，这里是python的源代码。同时也欢迎大家访问我的个人网站，也欢迎大家给个star。
import urllib.parse
import requests
from bs4 import BeautifulSoup
session = requests.session()
session.get("http://www.gzlib.gov.cn/")
session.headers.update(
{"Referer": "http://www.gzlib.gov.cn/member ... ot%3B,
"origin": "http://login.gzlib.gov.cn",
'Content-Type': 'application/x-www-form-urlencoded',
'host': 'www.gzlib.gov.cn',
'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/50.0.2661.102 Safari/537.36'
}
)
baseURL = "http://login.gzlib.gov.cn/sso-server/login"
soup = BeautifulSoup(session.get(baseURL).text, "html.parser")
lt = soup.select("form")[0].find(attrs={'name': 'lt'})['value']
postdict = {"username": "你的身份证",
"password": "密码（默认为身份证后6位）",
"_eventId": "submit",
"lt": lt
}
postdata = urllib.parse.urlencode(postdict)
session.post(baseURL, postdata)
print(session.get("http://www.gzlib.gov.cn/member ... 6quot;).text)
分类：
技术要点：
相关文章： 查看全部
httpclient 抓取网页(2021-05-24欢迎访问我的个人网站-广州图书馆)
2021-05-24
欢迎来到我的个人网站，如果能在GitHub上给网站的源码打个star就更好了。
在构建自己的网站时，我想记录我读过和借过的所有书。大学也爬过自己学校的借阅记录，但是数据库已经被删除了==，只有一张截图。所以你要珍惜你阅读的日子，记录你的借阅记录——广州图书馆，现在代码已经放到服务器上定期运行，结果查看我的网站（关于我）页面。整个代码使用HttpClient，存储在MySql中，定期使用Spring自带的Schedule。下面是爬取的过程。
1.页面跳转过程
一般是进入首页，点击进入登录页面，然后输入账号密码。从表面上看，它似乎并没有什么特别之处。事实上，在模拟登录的时候，并不仅仅是向链接发布请求那么简单。生成的响应将跳转回登录页面或无限制地重定向。
其实就是做单点登录的，如下图，广州图书馆的网址是：，登录的网址是：。网上很多人都很好的解释了原理。您可以阅读此 文章SSO 单点登录。
2.处理方式
解决方法不难，只要先模拟访问首页获取库的session，python获取代码如：session.get("")，打印cookie后如下：
[, , ]
整个登录和抓取过程如下：
这是：
（1）用户先点击广州图书馆首页，获取换站session，然后点击登录界面，解析html，获取lt（自定义参数，类似验证码），单点登录服务器会话。
(2）向目标服务器（单点登录服务器）提交post请求，请求参数包括username（用户名）、password（密码）、event（时间，默认为submit）、lt（自定义request parameters) ，服务器还需要对参数进行校验：refer（源页面）、host（主机信息）、Content-Type（类型）。
(3）打印响应，搜索自己的名字，如果有则表示成功，否则会跳转回登录页面。
(4）使用cookies访问其他页面，这里是借阅历史的爬取，所以访问的页面是：.
这是基本的模拟登录和获取，然后是对面的html的解析，得到书名、书索引等，然后封装成JavaBean，然后存入数据库。（没做过，不知道用什么方法比较好）
3.代码
3.1 在Java中，大部分的httpclients一般都是用来提交http请求的。一、需要导入的httpclient相关包：
org.apache.httpcomponents
httpclient
4.5.3
org.apache.httpcomponents
httpcore
4.4.7
3.2 构建和声明全局变量——上下文管理器，其中context是上下文管理器
public class LibraryUtil {
private static CloseableHttpClient httpClient = null;
private static HttpClientContext context = null;
private static CookieStore cookieStore = null;
static {
init();
}
private static void init() {
context = HttpClientContext.create();
cookieStore = new BasicCookieStore();
// 配置超时时间
RequestConfig requestConfig = RequestConfig.custom().setConnectTimeout(12000).setSocketTimeout(6000)
.setConnectionRequestTimeout(6000).build();
// 设置默认跳转以及存储cookie
httpClient = HttpClientBuilder.create()
.setKeepAliveStrategy(new DefaultConnectionKeepAliveStrategy())
.setRedirectStrategy(new DefaultRedirectStrategy()).setDefaultRequestConfig(requestConfig)
.setDefaultCookieStore(cookieStore).build();
}
...
3.3 声明一个get函数，其中header可以自定义，这里不需要，但保留它，使其成为通用的。
public static CloseableHttpResponse get(String url, Header[] header) throws IOException {
HttpGet httpget = new HttpGet(url);
if (header != null && header.length > 0) {
httpget.setHeaders(header);
}
CloseableHttpResponse response = httpClient.execute(httpget, context);//context用于存储上下文
return response;
}
3.4 访问主页获取会话。服务器上的session是按session存储的，本地浏览器使用cookies。只要本地不注销，也可以使用本地cookie访问，但是为了达到模拟登录的效果，这里不再赘述。
CloseableHttpResponse homeResponse = get("http://www.gzlib.gov.cn/", null);
homeResponse.close();
此时如果打印cookie，可以看到当前cookie如下：
3.5 访问登录页面，获取单点登录服务器后的cookie，解析网页，获取自定义参数lt。这里的解析网页使用的是Jsoup，语法类似于python中的BeautifulSoup。
String loginURL = "http://login.gzlib.gov.cn/sso- ... 3B%3B
CloseableHttpResponse loginGetResponse = get(loginURL, null);
String content = toString(loginGetResponse);
String lt = Jsoup.parse(content).select("form").select("input[name=lt]").attr("value");
loginGetResponse.close();
此时再看cookie，又多了一个（）：
3.6 声明一个post函数来提交一个post请求，这里提交的参数默认为
public static CloseableHttpResponse postParam(String url, String parameters, Header[] headers)
throws IOException {
System.out.println(parameters);
HttpPost httpPost = new HttpPost(url);
if (headers != null && headers.length > 0) {
for (Header header : headers) {
httpPost.addHeader(header);
}
}
List nvps = toNameValuePairList(parameters);
httpPost.setEntity(new UrlEncodedFormEntity(nvps, "UTF-8"));
CloseableHttpResponse response = httpClient.execute(httpPost, context);
return response;
}
3.7 登录成功后，如果没有声明returnurl，即登录链接为()，那么只会显示登录成功页面：
后台应该定义一个链接跳转的服务。如果想在登录成功后得到跳转页面，可以在服务后修改链接，这里会保持原来的状态。此时查看cookie的结果如下：
其中，CASTGC的出现说明登录成功，该cookie可用于访问广州图书馆的其他页面。在python中是直接跳转到其他页面，但是在java中使用httpclient的过程中，看到的并不是直接跳转。，但 302 重定向。打印Header后，结果如下：
如果你仔细研究一下链接，你会发现服务器相当于给了一张通用票，即：你可以用这张票访问任何页面，returnUrl 就是返回的页面。这里我们直接访问重定向的 url。
Header header = response.getHeaders("Location")[0];
CloseableHttpResponse home = get(header.getValue(), null);
然后打印页面得到登录后跳转回的首页。
3.8 解析html
获取session并跳转回首页后，访问借阅历史页面，然后将结果解析为html。在python中使用了BeautifulSoup，简单实用，java中的jsoup也是不错的选择。
String html = getHTML();
Element element = Jsoup.parse(html).select("table.jieyue-table").get(0).select("tbody").get(0);
Elements trs = element.select("tr");
for (int i = 0; i < trs.size(); i++) {
Elements tds = trs.get(i).select("td");
System.out.println(tds.get(1).text());
}
输出结果：
企业IT架构转型之道
大话Java性能优化
深入理解Hadoop
大话Java性能优化
Java EE开发的颠覆者：Spring Boot实战
大型网站技术架构：核心原理与案例分析
Java性能权威指南
Akka入门与实践
高性能网站建设进阶指南：Web开发者性能优化最佳实践：Performance best practices for Web developers
Java EE开发的颠覆者：Spring Boot实战
深入理解Hadoop
大话Java性能优化
点击查看源代码
总结
目前修改后的代码已经集成到个人网站中，每天定时抓取，但是还有很多事情没有做（比如分页、去重等），如果你有兴趣的可以研究下源码，如果能帮助改进就更好了。谢谢♪(･ω･)ﾉ。整个代码接近250行，当然……包括注释，但是使用python后，只有25行=w=，这里是python的源代码。同时也欢迎大家访问我的个人网站，也欢迎大家给个star。
import urllib.parse
import requests
from bs4 import BeautifulSoup
session = requests.session()
session.get("http://www.gzlib.gov.cn/";)
session.headers.update(
{"Referer": "http://www.gzlib.gov.cn/member ... ot%3B,
"origin": "http://login.gzlib.gov.cn",
'Content-Type': 'application/x-www-form-urlencoded',
'host': 'www.gzlib.gov.cn',
'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/50.0.2661.102 Safari/537.36'
}
)
baseURL = "http://login.gzlib.gov.cn/sso-server/login"
soup = BeautifulSoup(session.get(baseURL).text, "html.parser")
lt = soup.select("form")[0].find(attrs={'name': 'lt'})['value']
postdict = {"username": "你的身份证",
"password": "密码（默认为身份证后6位）",
"_eventId": "submit",
"lt": lt
}
postdata = urllib.parse.urlencode(postdict)
session.post(baseURL, postdata)
print(session.get("http://www.gzlib.gov.cn/member ... 6quot;).text)
分类：
技术要点：
相关文章：
httpclient 抓取网页(网页获取和解析速度和性能的应用场景详解！)
网站优化 • 优采云 发表了文章 • 0 个评论 • 71 次浏览 • 2022-04-13 00:10
httpclient 抓取网页(网页获取和解析速度和性能的应用场景详解！)
(4）支持代理服务器
(5）支持自动cookie管理等
Java爬虫开发是应用最广泛的网页获取技术。它具有一流的速度和性能。它在功能支持方面相对较低。不支持JS脚本执行、CSS解析渲染等准浏览器功能。推荐用于无需解析脚本和 CSS 即可获取网页的快速场景。
示例代码如下：
package cn.ysh.studio.crawler.httpclient;import org.apache.http.client.HttpClient;import org.apache.http.client.ResponseHandler;import org.apache.http.client.methods.HttpGet;import org.apache.http.impl.client.BasicResponseHandler;import org.apache.http.impl.client.DefaultHttpClient;/**
* 基于HtmlClient抓取网页内容
*
* @author www.yshjava.cn
*/publicclassHttpClientTest{publicstaticvoid main(String[] args)throwsException{//目标页面String url ="http://www.yshjava.cn";//创建一个默认的HttpClientHttpClient httpclient =newDefaultHttpClient();try{//以get方式请求网页http://www.yshjava.cnHttpGet httpget =newHttpGet(url);//打印请求地址System.out.println("executing request "+ httpget.getURI());//创建响应处理器处理服务器响应内容ResponseHandlerresponseHandler=newBasicResponseHandler();//执行请求并获取结果String responseBody = httpclient.execute(httpget, responseHandler);System.out.println("----------------------------------------");System.out.println(responseBody);System.out.println("----------------------------------------");}finally{//关闭连接管理器
httpclient.getConnectionManager().shutdown();}}}
汤
jsoup 是一个Java HTML 解析器，可以直接解析一个URL 地址和HTML 文本内容。它提供了一个非常省力的 API，用于通过 DOM、CSS 和类似 jQuery 的操作方法获取和操作数据。
网页获取解析速度快，推荐。
主要功能如下：
1. 从 URL、文件或字符串解析 HTML；
2. 使用 DOM 或 CSS 选择器来查找和检索数据；
3.可以操作HTML元素、属性、文本；
示例代码如下：
package cn.ysh.studio.crawler.jsoup;import java.io.IOException;import org.jsoup.Jsoup;/**
* 基于Jsoup抓取网页内容
* @author www.yshjava.cn
*/publicclassJsoupTest{publicstaticvoid main(String[] args)throwsIOException{//目标页面String url ="http://www.yshjava.cn";//使用Jsoup连接目标页面,并执行请求,获取服务器响应内容String html =Jsoup.connect(url).execute().body();//打印页面内容System.out.println(html);}}
HtmlUnit
htmlunit 是一个开源的java页面分析工具。阅读完页面后，可以有效地使用htmlunit分析页面上的内容。该项目可以模拟浏览器的操作，称为java浏览器的开源实现。这个没有界面的浏览器运行速度非常快。使用 Rhinojs 引擎。模拟js运行。
网页获取解析速度快，性能更好。推荐用于需要解析网页脚本的应用场景。
示例代码如下：
package cn.ysh.studio.crawler.htmlunit;import com.gargoylesoftware.htmlunit.BrowserVersion;import com.gargoylesoftware.htmlunit.Page;import com.gargoylesoftware.htmlunit.WebClient;/**
* 基于HtmlUnit抓取网页内容
*
* @author www.yshjava.cn
*/publicclassHtmlUnitSpider{publicstaticvoid main(String[] s)throwsException{//目标网页String url ="http://www.yshjava.cn";//模拟特定浏览器FIREFOX_3WebClient spider =newWebClient(BrowserVersion.FIREFOX_3);//获取目标网页Page page = spider.getPage(url);//打印网页内容System.out.println(page.getWebResponse().getContentAsString());//关闭所有窗口
spider.closeAllWindows();}}
瓦提
Watij（发音为 wattage）是一个用 Java 开发的 Web 应用程序测试工具。鉴于 Watij 的简单性和 Java 语言的强大功能，Watij 使您能够在真实浏览器中自动测试 Web 应用程序。因为调用本地浏览器，所以支持CSS渲染和JS执行。
网页获取速度一般，IE版本太低（6/7）可能会导致内存泄漏。
示例代码如下：
package cn.ysh.studio.crawler.ie;import watij.runtime.ie.IE;/**
* 基于Watij抓取网页内容,仅限Windows平台
*
* @author www.yshjava.cn
*/publicclassWatijTest{publicstaticvoid main(String[] s){//目标页面String url ="http://www.yshjava.cn";//实例化IE浏览器对象
IE ie =new IE();try{//启动浏览器
ie.start();//转到目标网页
ie.goTo(url);//等待网页加载就绪
ie.waitUntilReady();//打印页面内容System.out.println(ie.html());}catch(Exception e){
e.printStackTrace();}finally{try{//关闭IE浏览器
ie.close();}catch(Exception e){}}}}
硒
Selenium 也是一个用于 Web 应用程序测试的工具。 Selenium 测试直接在浏览器中运行，就像真正的用户一样。支持的浏览器包括 IE、Mozilla Firefox、Mozilla Suite 等。该工具的主要功能包括： 测试与浏览器的兼容性 - 测试您的应用程序是否在不同的浏览器和操作系统上运行良好。测试系统功能 - 创建回归测试以验证软件功能和用户需求。支持动作的自动记录和自动生成。 Net、Java、Perl 和其他不同语言的测试脚本。 Selenium 是 ThoughtWorks 专门为 Web 应用编写的验收测试工具。
网页抓取速度慢，对于爬虫来说不是一个好的选择。
示例代码如下：
package cn.ysh.studio.crawler.selenium;import org.openqa.selenium.htmlunit.HtmlUnitDriver;/**
* 基于HtmlDriver抓取网页内容
*
* @author www.yshjava.cn
*/publicclassHtmlDriverTest{publicstaticvoid main(String[] s){//目标网页String url ="http://www.yshjava.cn";HtmlUnitDriver driver =newHtmlUnitDriver();try{//禁用JS脚本功能
driver.setJavascriptEnabled(false);//打开目标网页
driver.get(url);//获取当前网页源码String html = driver.getPageSource();//打印网页源码System.out.println(html);}catch(Exception e){//打印堆栈信息
e.printStackTrace();}finally{try{//关闭并退出
driver.close();
driver.quit();}catch(Exception e){}}}}
网络规范
具有支持脚本执行和 CSS 呈现的界面的开源 Java 浏览器。平均速度。
示例代码如下：
package cn.ysh.studio.crawler.webspec;import org.watij.webspec.dsl.WebSpec;/**
* 基于WebSpec抓取网页内容
*
* @author www.yshjava.cn
*/publicclassWebspecTest{publicstaticvoid main(String[] s){//目标网页String url ="http://www.yshjava.cn";//实例化浏览器对象WebSpec spec =newWebSpec().mozilla();//隐藏浏览器窗体
spec.hide();//打开目标页面
spec.open(url);//打印网页源码System.out.println(spec.source());//关闭所有窗口
spec.closeAll();}}
源码下载：网络爬虫（网络蜘蛛）网络爬取示例源码
转载来源地址：
转载于： 查看全部
(4）支持代理服务器
(5）支持自动cookie管理等
Java爬虫开发是应用最广泛的网页获取技术。它具有一流的速度和性能。它在功能支持方面相对较低。不支持JS脚本执行、CSS解析渲染等准浏览器功能。推荐用于无需解析脚本和 CSS 即可获取网页的快速场景。
示例代码如下：
package cn.ysh.studio.crawler.httpclient;import org.apache.http.client.HttpClient;import org.apache.http.client.ResponseHandler;import org.apache.http.client.methods.HttpGet;import org.apache.http.impl.client.BasicResponseHandler;import org.apache.http.impl.client.DefaultHttpClient;/**
* 基于HtmlClient抓取网页内容
*
* @author www.yshjava.cn
*/publicclassHttpClientTest{publicstaticvoid main(String[] args)throwsException{//目标页面String url ="http://www.yshjava.cn";//创建一个默认的HttpClientHttpClient httpclient =newDefaultHttpClient();try{//以get方式请求网页http://www.yshjava.cnHttpGet httpget =newHttpGet(url);//打印请求地址System.out.println("executing request "+ httpget.getURI());//创建响应处理器处理服务器响应内容ResponseHandlerresponseHandler=newBasicResponseHandler();//执行请求并获取结果String responseBody = httpclient.execute(httpget, responseHandler);System.out.println("----------------------------------------");System.out.println(responseBody);System.out.println("----------------------------------------");}finally{//关闭连接管理器
httpclient.getConnectionManager().shutdown();}}}
汤
jsoup 是一个Java HTML 解析器，可以直接解析一个URL 地址和HTML 文本内容。它提供了一个非常省力的 API，用于通过 DOM、CSS 和类似 jQuery 的操作方法获取和操作数据。
网页获取解析速度快，推荐。
主要功能如下：
1. 从 URL、文件或字符串解析 HTML；
2. 使用 DOM 或 CSS 选择器来查找和检索数据；
3.可以操作HTML元素、属性、文本；
示例代码如下：
package cn.ysh.studio.crawler.jsoup;import java.io.IOException;import org.jsoup.Jsoup;/**
* 基于Jsoup抓取网页内容
* @author www.yshjava.cn
*/publicclassJsoupTest{publicstaticvoid main(String[] args)throwsIOException{//目标页面String url ="http://www.yshjava.cn";//使用Jsoup连接目标页面,并执行请求,获取服务器响应内容String html =Jsoup.connect(url).execute().body();//打印页面内容System.out.println(html);}}
HtmlUnit
htmlunit 是一个开源的java页面分析工具。阅读完页面后，可以有效地使用htmlunit分析页面上的内容。该项目可以模拟浏览器的操作，称为java浏览器的开源实现。这个没有界面的浏览器运行速度非常快。使用 Rhinojs 引擎。模拟js运行。
网页获取解析速度快，性能更好。推荐用于需要解析网页脚本的应用场景。
示例代码如下：
package cn.ysh.studio.crawler.htmlunit;import com.gargoylesoftware.htmlunit.BrowserVersion;import com.gargoylesoftware.htmlunit.Page;import com.gargoylesoftware.htmlunit.WebClient;/**
* 基于HtmlUnit抓取网页内容
*
* @author www.yshjava.cn
*/publicclassHtmlUnitSpider{publicstaticvoid main(String[] s)throwsException{//目标网页String url ="http://www.yshjava.cn";//模拟特定浏览器FIREFOX_3WebClient spider =newWebClient(BrowserVersion.FIREFOX_3);//获取目标网页Page page = spider.getPage(url);//打印网页内容System.out.println(page.getWebResponse().getContentAsString());//关闭所有窗口
spider.closeAllWindows();}}
瓦提
Watij（发音为 wattage）是一个用 Java 开发的 Web 应用程序测试工具。鉴于 Watij 的简单性和 Java 语言的强大功能，Watij 使您能够在真实浏览器中自动测试 Web 应用程序。因为调用本地浏览器，所以支持CSS渲染和JS执行。
网页获取速度一般，IE版本太低（6/7）可能会导致内存泄漏。
示例代码如下：
package cn.ysh.studio.crawler.ie;import watij.runtime.ie.IE;/**
* 基于Watij抓取网页内容,仅限Windows平台
*
* @author www.yshjava.cn
*/publicclassWatijTest{publicstaticvoid main(String[] s){//目标页面String url ="http://www.yshjava.cn";//实例化IE浏览器对象
IE ie =new IE();try{//启动浏览器
ie.start();//转到目标网页
ie.goTo(url);//等待网页加载就绪
ie.waitUntilReady();//打印页面内容System.out.println(ie.html());}catch(Exception e){
e.printStackTrace();}finally{try{//关闭IE浏览器
ie.close();}catch(Exception e){}}}}
硒
Selenium 也是一个用于 Web 应用程序测试的工具。 Selenium 测试直接在浏览器中运行，就像真正的用户一样。支持的浏览器包括 IE、Mozilla Firefox、Mozilla Suite 等。该工具的主要功能包括： 测试与浏览器的兼容性 - 测试您的应用程序是否在不同的浏览器和操作系统上运行良好。测试系统功能 - 创建回归测试以验证软件功能和用户需求。支持动作的自动记录和自动生成。 Net、Java、Perl 和其他不同语言的测试脚本。 Selenium 是 ThoughtWorks 专门为 Web 应用编写的验收测试工具。
网页抓取速度慢，对于爬虫来说不是一个好的选择。
示例代码如下：
package cn.ysh.studio.crawler.selenium;import org.openqa.selenium.htmlunit.HtmlUnitDriver;/**
* 基于HtmlDriver抓取网页内容
*
* @author www.yshjava.cn
*/publicclassHtmlDriverTest{publicstaticvoid main(String[] s){//目标网页String url ="http://www.yshjava.cn";HtmlUnitDriver driver =newHtmlUnitDriver();try{//禁用JS脚本功能
driver.setJavascriptEnabled(false);//打开目标网页
driver.get(url);//获取当前网页源码String html = driver.getPageSource();//打印网页源码System.out.println(html);}catch(Exception e){//打印堆栈信息
e.printStackTrace();}finally{try{//关闭并退出
driver.close();
driver.quit();}catch(Exception e){}}}}
网络规范
具有支持脚本执行和 CSS 呈现的界面的开源 Java 浏览器。平均速度。
示例代码如下：
package cn.ysh.studio.crawler.webspec;import org.watij.webspec.dsl.WebSpec;/**
* 基于WebSpec抓取网页内容
*
* @author www.yshjava.cn
*/publicclassWebspecTest{publicstaticvoid main(String[] s){//目标网页String url ="http://www.yshjava.cn";//实例化浏览器对象WebSpec spec =newWebSpec().mozilla();//隐藏浏览器窗体
spec.hide();//打开目标页面
spec.open(url);//打印网页源码System.out.println(spec.source());//关闭所有窗口
spec.closeAll();}}
源码下载：网络爬虫（网络蜘蛛）网络爬取示例源码
转载来源地址：
转载于： 查看全部
httpclient 抓取网页(网页获取和解析速度和性能的应用场景详解！)
(4）支持代理服务器
(5）支持自动cookie管理等
Java爬虫开发是应用最广泛的网页获取技术。它具有一流的速度和性能。它在功能支持方面相对较低。不支持JS脚本执行、CSS解析渲染等准浏览器功能。推荐用于无需解析脚本和 CSS 即可获取网页的快速场景。
示例代码如下：
package cn.ysh.studio.crawler.httpclient;import org.apache.http.client.HttpClient;import org.apache.http.client.ResponseHandler;import org.apache.http.client.methods.HttpGet;import org.apache.http.impl.client.BasicResponseHandler;import org.apache.http.impl.client.DefaultHttpClient;/**
* 基于HtmlClient抓取网页内容
*
* @author www.yshjava.cn
*/publicclassHttpClientTest{publicstaticvoid main(String[] args)throwsException{//目标页面String url ="http://www.yshjava.cn";//创建一个默认的HttpClientHttpClient httpclient =newDefaultHttpClient();try{//以get方式请求网页http://www.yshjava.cnHttpGet httpget =newHttpGet(url);//打印请求地址System.out.println("executing request "+ httpget.getURI());//创建响应处理器处理服务器响应内容ResponseHandlerresponseHandler=newBasicResponseHandler();//执行请求并获取结果String responseBody = httpclient.execute(httpget, responseHandler);System.out.println("----------------------------------------");System.out.println(responseBody);System.out.println("----------------------------------------");}finally{//关闭连接管理器
httpclient.getConnectionManager().shutdown();}}}
汤
jsoup 是一个Java HTML 解析器，可以直接解析一个URL 地址和HTML 文本内容。它提供了一个非常省力的 API，用于通过 DOM、CSS 和类似 jQuery 的操作方法获取和操作数据。
网页获取解析速度快，推荐。
主要功能如下：
1. 从 URL、文件或字符串解析 HTML；
2. 使用 DOM 或 CSS 选择器来查找和检索数据；
3.可以操作HTML元素、属性、文本；
示例代码如下：
package cn.ysh.studio.crawler.jsoup;import java.io.IOException;import org.jsoup.Jsoup;/**
* 基于Jsoup抓取网页内容
* @author www.yshjava.cn
*/publicclassJsoupTest{publicstaticvoid main(String[] args)throwsIOException{//目标页面String url ="http://www.yshjava.cn";//使用Jsoup连接目标页面,并执行请求,获取服务器响应内容String html =Jsoup.connect(url).execute().body();//打印页面内容System.out.println(html);}}
HtmlUnit
htmlunit 是一个开源的java页面分析工具。阅读完页面后，可以有效地使用htmlunit分析页面上的内容。该项目可以模拟浏览器的操作，称为java浏览器的开源实现。这个没有界面的浏览器运行速度非常快。使用 Rhinojs 引擎。模拟js运行。
网页获取解析速度快，性能更好。推荐用于需要解析网页脚本的应用场景。
示例代码如下：
package cn.ysh.studio.crawler.htmlunit;import com.gargoylesoftware.htmlunit.BrowserVersion;import com.gargoylesoftware.htmlunit.Page;import com.gargoylesoftware.htmlunit.WebClient;/**
* 基于HtmlUnit抓取网页内容
*
* @author www.yshjava.cn
*/publicclassHtmlUnitSpider{publicstaticvoid main(String[] s)throwsException{//目标网页String url ="http://www.yshjava.cn";//模拟特定浏览器FIREFOX_3WebClient spider =newWebClient(BrowserVersion.FIREFOX_3);//获取目标网页Page page = spider.getPage(url);//打印网页内容System.out.println(page.getWebResponse().getContentAsString());//关闭所有窗口
spider.closeAllWindows();}}
瓦提
Watij（发音为 wattage）是一个用 Java 开发的 Web 应用程序测试工具。鉴于 Watij 的简单性和 Java 语言的强大功能，Watij 使您能够在真实浏览器中自动测试 Web 应用程序。因为调用本地浏览器，所以支持CSS渲染和JS执行。
网页获取速度一般，IE版本太低（6/7）可能会导致内存泄漏。
示例代码如下：
package cn.ysh.studio.crawler.ie;import watij.runtime.ie.IE;/**
* 基于Watij抓取网页内容,仅限Windows平台
*
* @author www.yshjava.cn
*/publicclassWatijTest{publicstaticvoid main(String[] s){//目标页面String url ="http://www.yshjava.cn";//实例化IE浏览器对象
IE ie =new IE();try{//启动浏览器
ie.start();//转到目标网页
ie.goTo(url);//等待网页加载就绪
ie.waitUntilReady();//打印页面内容System.out.println(ie.html());}catch(Exception e){
e.printStackTrace();}finally{try{//关闭IE浏览器
ie.close();}catch(Exception e){}}}}
硒
Selenium 也是一个用于 Web 应用程序测试的工具。 Selenium 测试直接在浏览器中运行，就像真正的用户一样。支持的浏览器包括 IE、Mozilla Firefox、Mozilla Suite 等。该工具的主要功能包括： 测试与浏览器的兼容性 - 测试您的应用程序是否在不同的浏览器和操作系统上运行良好。测试系统功能 - 创建回归测试以验证软件功能和用户需求。支持动作的自动记录和自动生成。 Net、Java、Perl 和其他不同语言的测试脚本。 Selenium 是 ThoughtWorks 专门为 Web 应用编写的验收测试工具。
网页抓取速度慢，对于爬虫来说不是一个好的选择。
示例代码如下：
package cn.ysh.studio.crawler.selenium;import org.openqa.selenium.htmlunit.HtmlUnitDriver;/**
* 基于HtmlDriver抓取网页内容
*
* @author www.yshjava.cn
*/publicclassHtmlDriverTest{publicstaticvoid main(String[] s){//目标网页String url ="http://www.yshjava.cn";HtmlUnitDriver driver =newHtmlUnitDriver();try{//禁用JS脚本功能
driver.setJavascriptEnabled(false);//打开目标网页
driver.get(url);//获取当前网页源码String html = driver.getPageSource();//打印网页源码System.out.println(html);}catch(Exception e){//打印堆栈信息
e.printStackTrace();}finally{try{//关闭并退出
driver.close();
driver.quit();}catch(Exception e){}}}}
网络规范
具有支持脚本执行和 CSS 呈现的界面的开源 Java 浏览器。平均速度。
示例代码如下：
package cn.ysh.studio.crawler.webspec;import org.watij.webspec.dsl.WebSpec;/**
* 基于WebSpec抓取网页内容
*
* @author www.yshjava.cn
*/publicclassWebspecTest{publicstaticvoid main(String[] s){//目标网页String url ="http://www.yshjava.cn";//实例化浏览器对象WebSpec spec =newWebSpec().mozilla();//隐藏浏览器窗体
spec.hide();//打开目标页面
spec.open(url);//打印网页源码System.out.println(spec.source());//关闭所有窗口
spec.closeAll();}}
源码下载：网络爬虫（网络蜘蛛）网络爬取示例源码
转载来源地址：
转载于：
httpclient 抓取网页(HtmlUnit使用场景对于使用java实现的网页爬虫程序呢？ )
网站优化 • 优采云 发表了文章 • 0 个评论 • 62 次浏览 • 2022-04-10 08:30
httpclient 抓取网页(HtmlUnit使用场景对于使用java实现的网页爬虫程序呢？
)
HtmlUnit简介
HtmlUnit is a "GUI-Less browser for Java programs". It models HTML documents and provides an API that allows you to invoke pages, fill out forms, click links, etc... just like you do in your "normal" browser.
It has fairly good JavaScript support (which is constantly improving) and is able to work even with quite complex AJAX libraries, simulating Chrome, Firefox or Internet Explorer depending on the configuration used.
It is typically used for testing purposes or to retrieve information from web sites.
HtmlUnit is not a generic unit testing framework. It is specifically a way to simulate a browser for testing purposes and is intended to be used within another testing framework such as JUnit or TestNG. Refer to the document "Getting Started with HtmlUnit" for an introduction.
HtmlUnit is used as the underlying "browser" by different Open Source tools like Canoo WebTest, JWebUnit, WebDriver, JSFUnit, WETATOR, Celerity, Spring MVC Test HtmlUnit, ...
HtmlUnit was originally written by Mike Bowler of Gargoyle Software and is released under the Apache 2 license. Since then, it has received many contributions from other developers, and would not be where it is today without their assistance.
HtmlUnit是一个无界面浏览器Java程序。它为HTML文档建模，提供了调用页面、填写表单、单击链接等操作的API。就跟你在浏览器里做的操作一样。
HtmlUnit不错的JavaScript支持(不断改进)，甚至可以使用相当复杂的AJAX库，根据配置的不同模拟Chrome、Firefox或Internet Explorer等浏览器。
HtmlUnit通常用于测试或从web站点检索信息。
HtmlUnit 使用场景
对于java实现的网络爬虫程序，我们一般可以使用apache的HttpClient组件来获取HTML页面信息。HttpClient实现的http请求返回的响应一般是纯文本文档页面，也就是最原创的html页面。
对于一个静态的html页面，使用httpClient就足够爬出我们需要的信息了。但是对于越来越多的动态网页，更多的数据是通过异步的JS代码来获取和渲染的，而初始的html页面并没有收录这部分数据。
上图中我们看到的网页在初始文档加载后并没有看到红框中的数据列表。浏览器通过执行异步JS请求，将获取到的动态数据渲染到原创文档页面中，最终变成我们看到的网页。对于这部分需要JS代码执行的数据，httpClient是无能为力的。虽然我们可以通过研究得到JS执行的请求路径，然后用java代码来获取我们需要的部分数据，不说能不能从JS脚本中分析请求路径和请求参数，只分析这部分数据源码成本已经很高了。
通过上面的介绍，我们了解到现在很大一部分动态网页都是通过异步JS请求获取的数据，然后通过JS渲染页面。那么我们能不能做这样的假设，假设我们的爬虫程序模拟一个浏览器，拿到html页面后，像浏览器一样执行异步JS代码，JS渲染好html页面后，就可以愉快的获取到节点信息了这页纸。那么有没有这样的java程序呢？
答案是肯定的。
HtmlUnit就是这样一个库，用来做界面显示的所有异步工作。没有耗时的显示工作，HtmlUnit 加载的完整网页比实际的浏览器块更多。并且根据不同的配置，HtmlUnit可以模拟市面上常见的Chrome、Firefox、IE浏览器等浏览器。
通过HtmlUnit库，加载一个完整的Html页面（图片和视频除外），然后将其转换成我们常用的字符串格式，使用Jsoup等其他工具获取元素。当然，你也可以直接从HtmlUnit提供的对象中获取网页元素，甚至可以操作按钮、表单等控件。除了不能像可见浏览器那样用鼠标和键盘浏览网页之外，我们可以使用HtmlUnit来模拟所有其他的操作，比如登录网站、写博客等都可以完成。当然，网页内容抓取是最简单的应用。
HtmlUnit 使用方法 1. 创建一个新的 maven 项目并添加 HtmlUnit 依赖项：
net.sourceforge.htmlunit
htmlunit
2.27
2.新建一个Junit TestCase 试试这个库
程序代码注释如下：
package xuyihao.util.depend;
import com.gargoylesoftware.htmlunit.BrowserVersion;
import com.gargoylesoftware.htmlunit.NicelyResynchronizingAjaxController;
import com.gargoylesoftware.htmlunit.WebClient;
import com.gargoylesoftware.htmlunit.html.HtmlPage;
import org.jsoup.Jsoup;
import org.jsoup.nodes.Document;
import org.jsoup.nodes.Element;
import org.junit.Test;
import java.util.List;
/**
* Created by xuyh at 2017/11/6 14:03.
*/
public class HtmlUtilTest {
@Test
public void test() {
final WebClient webClient = new WebClient(BrowserVersion.CHROME);//新建一个模拟谷歌Chrome浏览器的浏览器客户端对象
webClient.getOptions().setThrowExceptionOnScriptError(false);//当JS执行出错的时候是否抛出异常, 这里选择不需要
webClient.getOptions().setThrowExceptionOnFailingStatusCode(false);//当HTTP的状态非200时是否抛出异常, 这里选择不需要
webClient.getOptions().setActiveXNative(false);
webClient.getOptions().setCssEnabled(false);//是否启用CSS, 因为不需要展现页面, 所以不需要启用
webClient.getOptions().setJavaScriptEnabled(true); //很重要，启用JS
webClient.setAjaxController(new NicelyResynchronizingAjaxController());//很重要，设置支持AJAX
HtmlPage page = null;
try {
page = webClient.getPage("http://ent.sina.com.cn/film/");//尝试加载上面图片例子给出的网页
} catch (Exception e) {
e.printStackTrace();
}finally {
webClient.close();
}
webClient.waitForBackgroundJavaScript(30000);//异步JS执行需要耗时,所以这里线程要阻塞30秒,等待异步JS执行结束
String pageXml = page.asXml();//直接将加载完成的页面转换成xml格式的字符串
//TODO 下面的代码就是对字符串的操作了,常规的爬虫操作,用到了比较好用的Jsoup库
Document document = Jsoup.parse(pageXml);//获取html文档
List infoListEle = document.getElementById("feedCardContent").getElementsByAttributeValue("class", "feed-card-item");//获取元素节点等
infoListEle.forEach(element -> {
System.out.println(element.getElementsByTag("h2").first().getElementsByTag("a").text());
System.out.println(element.getElementsByTag("h2").first().getElementsByTag("a").attr("href"));
});
}
}
上面的示例将获取到的页面中消息列表的标题和超链接 URL 打印到控制台。操作HTML文档的库是Jsoup，需要添加依赖：
org.jsoup
jsoup
1.8.3
等待三十秒后，控制台输出如下：
十一月 06, 2017 2:17:05 下午 com.gargoylesoftware.htmlunit.IncorrectnessListenerImpl notify
警告: Obsolete content type encountered: 'application/x-javascript'.
十一月 06, 2017 2:17:06 下午 com.gargoylesoftware.htmlunit.javascript.StrictErrorReporter runtimeError
严重: runtimeError: message=[An invalid or illegal selector was specified (selector: '*,:x' error: Invalid selector: :x).] sourceName=[http://n.sinaimg.cn/lib/core/core.js] line=[1] lineSource=[null] lineOffset=[0]
十一月 06, 2017 2:17:06 下午 com.gargoylesoftware.htmlunit.IncorrectnessListenerImpl notify
警告: Obsolete content type encountered: 'application/x-javascript'.
2017-11-06 14:17:11.003:INFO::JS executor for com.gargoylesoftware.htmlunit.WebClient@618c5d94: Logging initialized @7179ms to org.eclipse.jetty.util.log.StdErrLog
十一月 06, 2017 2:17:11 下午 com.gargoylesoftware.htmlunit.javascript.host.WebSocket run
严重: WS connect error
java.util.concurrent.ExecutionException: org.eclipse.jetty.websocket.api.UpgradeException: 0 null
at java.util.concurrent.CompletableFuture.reportGet(CompletableFuture.java:357)
at java.util.concurrent.CompletableFuture.get(CompletableFuture.java:1895)
at com.gargoylesoftware.htmlunit.javascript.host.WebSocket$1.run(WebSocket.java:151)
at org.eclipse.jetty.util.thread.QueuedThreadPool.runJob(QueuedThreadPool.java:672)
at org.eclipse.jetty.util.thread.QueuedThreadPool$2.run(QueuedThreadPool.java:590)
at java.lang.Thread.run(Thread.java:748)
Caused by: org.eclipse.jetty.websocket.api.UpgradeException: 0 null
at org.eclipse.jetty.websocket.client.WebSocketUpgradeRequest.onComplete(WebSocketUpgradeRequest.java:513)
at org.eclipse.jetty.client.ResponseNotifier.notifyComplete(ResponseNotifier.java:193)
at org.eclipse.jetty.client.ResponseNotifier.notifyComplete(ResponseNotifier.java:185)
at org.eclipse.jetty.client.HttpExchange.notifyFailureComplete(HttpExchange.java:269)
at org.eclipse.jetty.client.HttpExchange.abort(HttpExchange.java:240)
at org.eclipse.jetty.client.HttpConversation.abort(HttpConversation.java:141)
at org.eclipse.jetty.client.HttpRequest.abort(HttpRequest.java:748)
at org.eclipse.jetty.client.HttpDestination.abort(HttpDestination.java:444)
at org.eclipse.jetty.client.HttpDestination.failed(HttpDestination.java:224)
at org.eclipse.jetty.client.AbstractConnectionPool$1.failed(AbstractConnectionPool.java:122)
at org.eclipse.jetty.util.Promise$Wrapper.failed(Promise.java:136)
at org.eclipse.jetty.client.HttpClient$1$1.failed(HttpClient.java:588)
at org.eclipse.jetty.client.AbstractHttpClientTransport.connectFailed(AbstractHttpClientTransport.java:154)
at org.eclipse.jetty.client.AbstractHttpClientTransport$ClientSelectorManager.connectionFailed(AbstractHttpClientTransport.java:199)
at org.eclipse.jetty.io.ManagedSelector$Connect.failed(ManagedSelector.java:655)
at org.eclipse.jetty.io.ManagedSelector$Connect.access$1300(ManagedSelector.java:622)
at org.eclipse.jetty.io.ManagedSelector$1.failed(ManagedSelector.java:364)
at org.eclipse.jetty.io.ManagedSelector$CreateEndPoint.run(ManagedSelector.java:604)
... 3 more
Caused 查看全部
)
HtmlUnit简介
HtmlUnit is a "GUI-Less browser for Java programs". It models HTML documents and provides an API that allows you to invoke pages, fill out forms, click links, etc... just like you do in your "normal" browser.
It has fairly good JavaScript support (which is constantly improving) and is able to work even with quite complex AJAX libraries, simulating Chrome, Firefox or Internet Explorer depending on the configuration used.
It is typically used for testing purposes or to retrieve information from web sites.
HtmlUnit is not a generic unit testing framework. It is specifically a way to simulate a browser for testing purposes and is intended to be used within another testing framework such as JUnit or TestNG. Refer to the document "Getting Started with HtmlUnit" for an introduction.
HtmlUnit is used as the underlying "browser" by different Open Source tools like Canoo WebTest, JWebUnit, WebDriver, JSFUnit, WETATOR, Celerity, Spring MVC Test HtmlUnit, ...
HtmlUnit was originally written by Mike Bowler of Gargoyle Software and is released under the Apache 2 license. Since then, it has received many contributions from other developers, and would not be where it is today without their assistance.
HtmlUnit是一个无界面浏览器Java程序。它为HTML文档建模，提供了调用页面、填写表单、单击链接等操作的API。就跟你在浏览器里做的操作一样。
HtmlUnit不错的JavaScript支持(不断改进)，甚至可以使用相当复杂的AJAX库，根据配置的不同模拟Chrome、Firefox或Internet Explorer等浏览器。
HtmlUnit通常用于测试或从web站点检索信息。
HtmlUnit 使用场景
对于java实现的网络爬虫程序，我们一般可以使用apache的HttpClient组件来获取HTML页面信息。HttpClient实现的http请求返回的响应一般是纯文本文档页面，也就是最原创的html页面。
对于一个静态的html页面，使用httpClient就足够爬出我们需要的信息了。但是对于越来越多的动态网页，更多的数据是通过异步的JS代码来获取和渲染的，而初始的html页面并没有收录这部分数据。
上图中我们看到的网页在初始文档加载后并没有看到红框中的数据列表。浏览器通过执行异步JS请求，将获取到的动态数据渲染到原创文档页面中，最终变成我们看到的网页。对于这部分需要JS代码执行的数据，httpClient是无能为力的。虽然我们可以通过研究得到JS执行的请求路径，然后用java代码来获取我们需要的部分数据，不说能不能从JS脚本中分析请求路径和请求参数，只分析这部分数据源码成本已经很高了。
通过上面的介绍，我们了解到现在很大一部分动态网页都是通过异步JS请求获取的数据，然后通过JS渲染页面。那么我们能不能做这样的假设，假设我们的爬虫程序模拟一个浏览器，拿到html页面后，像浏览器一样执行异步JS代码，JS渲染好html页面后，就可以愉快的获取到节点信息了这页纸。那么有没有这样的java程序呢？
答案是肯定的。
HtmlUnit就是这样一个库，用来做界面显示的所有异步工作。没有耗时的显示工作，HtmlUnit 加载的完整网页比实际的浏览器块更多。并且根据不同的配置，HtmlUnit可以模拟市面上常见的Chrome、Firefox、IE浏览器等浏览器。
通过HtmlUnit库，加载一个完整的Html页面（图片和视频除外），然后将其转换成我们常用的字符串格式，使用Jsoup等其他工具获取元素。当然，你也可以直接从HtmlUnit提供的对象中获取网页元素，甚至可以操作按钮、表单等控件。除了不能像可见浏览器那样用鼠标和键盘浏览网页之外，我们可以使用HtmlUnit来模拟所有其他的操作，比如登录网站、写博客等都可以完成。当然，网页内容抓取是最简单的应用。
HtmlUnit 使用方法 1. 创建一个新的 maven 项目并添加 HtmlUnit 依赖项：
net.sourceforge.htmlunit
htmlunit
2.27
2.新建一个Junit TestCase 试试这个库
程序代码注释如下：
package xuyihao.util.depend;
import com.gargoylesoftware.htmlunit.BrowserVersion;
import com.gargoylesoftware.htmlunit.NicelyResynchronizingAjaxController;
import com.gargoylesoftware.htmlunit.WebClient;
import com.gargoylesoftware.htmlunit.html.HtmlPage;
import org.jsoup.Jsoup;
import org.jsoup.nodes.Document;
import org.jsoup.nodes.Element;
import org.junit.Test;
import java.util.List;
/**
* Created by xuyh at 2017/11/6 14:03.
*/
public class HtmlUtilTest {
@Test
public void test() {
final WebClient webClient = new WebClient(BrowserVersion.CHROME);//新建一个模拟谷歌Chrome浏览器的浏览器客户端对象
webClient.getOptions().setThrowExceptionOnScriptError(false);//当JS执行出错的时候是否抛出异常, 这里选择不需要
webClient.getOptions().setThrowExceptionOnFailingStatusCode(false);//当HTTP的状态非200时是否抛出异常, 这里选择不需要
webClient.getOptions().setActiveXNative(false);
webClient.getOptions().setCssEnabled(false);//是否启用CSS, 因为不需要展现页面, 所以不需要启用
webClient.getOptions().setJavaScriptEnabled(true); //很重要，启用JS
webClient.setAjaxController(new NicelyResynchronizingAjaxController());//很重要，设置支持AJAX
HtmlPage page = null;
try {
page = webClient.getPage("http://ent.sina.com.cn/film/");//尝试加载上面图片例子给出的网页
} catch (Exception e) {
e.printStackTrace();
}finally {
webClient.close();
}
webClient.waitForBackgroundJavaScript(30000);//异步JS执行需要耗时,所以这里线程要阻塞30秒,等待异步JS执行结束
String pageXml = page.asXml();//直接将加载完成的页面转换成xml格式的字符串
//TODO 下面的代码就是对字符串的操作了,常规的爬虫操作,用到了比较好用的Jsoup库
Document document = Jsoup.parse(pageXml);//获取html文档
List infoListEle = document.getElementById("feedCardContent").getElementsByAttributeValue("class", "feed-card-item");//获取元素节点等
infoListEle.forEach(element -> {
System.out.println(element.getElementsByTag("h2").first().getElementsByTag("a").text());
System.out.println(element.getElementsByTag("h2").first().getElementsByTag("a").attr("href"));
});
}
}
上面的示例将获取到的页面中消息列表的标题和超链接 URL 打印到控制台。操作HTML文档的库是Jsoup，需要添加依赖：
org.jsoup
jsoup
1.8.3
等待三十秒后，控制台输出如下：
十一月 06, 2017 2:17:05 下午 com.gargoylesoftware.htmlunit.IncorrectnessListenerImpl notify
警告: Obsolete content type encountered: 'application/x-javascript'.
十一月 06, 2017 2:17:06 下午 com.gargoylesoftware.htmlunit.javascript.StrictErrorReporter runtimeError
严重: runtimeError: message=[An invalid or illegal selector was specified (selector: '*,:x' error: Invalid selector: :x).] sourceName=[http://n.sinaimg.cn/lib/core/core.js] line=[1] lineSource=[null] lineOffset=[0]
十一月 06, 2017 2:17:06 下午 com.gargoylesoftware.htmlunit.IncorrectnessListenerImpl notify
警告: Obsolete content type encountered: 'application/x-javascript'.
2017-11-06 14:17:11.003:INFO::JS executor for com.gargoylesoftware.htmlunit.WebClient@618c5d94: Logging initialized @7179ms to org.eclipse.jetty.util.log.StdErrLog
十一月 06, 2017 2:17:11 下午 com.gargoylesoftware.htmlunit.javascript.host.WebSocket run
严重: WS connect error
java.util.concurrent.ExecutionException: org.eclipse.jetty.websocket.api.UpgradeException: 0 null
at java.util.concurrent.CompletableFuture.reportGet(CompletableFuture.java:357)
at java.util.concurrent.CompletableFuture.get(CompletableFuture.java:1895)
at com.gargoylesoftware.htmlunit.javascript.host.WebSocket$1.run(WebSocket.java:151)
at org.eclipse.jetty.util.thread.QueuedThreadPool.runJob(QueuedThreadPool.java:672)
at org.eclipse.jetty.util.thread.QueuedThreadPool$2.run(QueuedThreadPool.java:590)
at java.lang.Thread.run(Thread.java:748)
Caused by: org.eclipse.jetty.websocket.api.UpgradeException: 0 null
at org.eclipse.jetty.websocket.client.WebSocketUpgradeRequest.onComplete(WebSocketUpgradeRequest.java:513)
at org.eclipse.jetty.client.ResponseNotifier.notifyComplete(ResponseNotifier.java:193)
at org.eclipse.jetty.client.ResponseNotifier.notifyComplete(ResponseNotifier.java:185)
at org.eclipse.jetty.client.HttpExchange.notifyFailureComplete(HttpExchange.java:269)
at org.eclipse.jetty.client.HttpExchange.abort(HttpExchange.java:240)
at org.eclipse.jetty.client.HttpConversation.abort(HttpConversation.java:141)
at org.eclipse.jetty.client.HttpRequest.abort(HttpRequest.java:748)
at org.eclipse.jetty.client.HttpDestination.abort(HttpDestination.java:444)
at org.eclipse.jetty.client.HttpDestination.failed(HttpDestination.java:224)
at org.eclipse.jetty.client.AbstractConnectionPool$1.failed(AbstractConnectionPool.java:122)
at org.eclipse.jetty.util.Promise$Wrapper.failed(Promise.java:136)
at org.eclipse.jetty.client.HttpClient$1$1.failed(HttpClient.java:588)
at org.eclipse.jetty.client.AbstractHttpClientTransport.connectFailed(AbstractHttpClientTransport.java:154)
at org.eclipse.jetty.client.AbstractHttpClientTransport$ClientSelectorManager.connectionFailed(AbstractHttpClientTransport.java:199)
at org.eclipse.jetty.io.ManagedSelector$Connect.failed(ManagedSelector.java:655)
at org.eclipse.jetty.io.ManagedSelector$Connect.access$1300(ManagedSelector.java:622)
at org.eclipse.jetty.io.ManagedSelector$1.failed(ManagedSelector.java:364)
at org.eclipse.jetty.io.ManagedSelector$CreateEndPoint.run(ManagedSelector.java:604)
... 3 more
Caused 查看全部
httpclient 抓取网页(HtmlUnit使用场景对于使用java实现的网页爬虫程序呢？
)
HtmlUnit简介
HtmlUnit is a "GUI-Less browser for Java programs". It models HTML documents and provides an API that allows you to invoke pages, fill out forms, click links, etc... just like you do in your "normal" browser.
It has fairly good JavaScript support (which is constantly improving) and is able to work even with quite complex AJAX libraries, simulating Chrome, Firefox or Internet Explorer depending on the configuration used.
It is typically used for testing purposes or to retrieve information from web sites.
HtmlUnit is not a generic unit testing framework. It is specifically a way to simulate a browser for testing purposes and is intended to be used within another testing framework such as JUnit or TestNG. Refer to the document "Getting Started with HtmlUnit" for an introduction.
HtmlUnit is used as the underlying "browser" by different Open Source tools like Canoo WebTest, JWebUnit, WebDriver, JSFUnit, WETATOR, Celerity, Spring MVC Test HtmlUnit, ...
HtmlUnit was originally written by Mike Bowler of Gargoyle Software and is released under the Apache 2 license. Since then, it has received many contributions from other developers, and would not be where it is today without their assistance.
HtmlUnit是一个无界面浏览器Java程序。它为HTML文档建模，提供了调用页面、填写表单、单击链接等操作的API。就跟你在浏览器里做的操作一样。
HtmlUnit不错的JavaScript支持(不断改进)，甚至可以使用相当复杂的AJAX库，根据配置的不同模拟Chrome、Firefox或Internet Explorer等浏览器。
HtmlUnit通常用于测试或从web站点检索信息。
HtmlUnit 使用场景
对于java实现的网络爬虫程序，我们一般可以使用apache的HttpClient组件来获取HTML页面信息。HttpClient实现的http请求返回的响应一般是纯文本文档页面，也就是最原创的html页面。
对于一个静态的html页面，使用httpClient就足够爬出我们需要的信息了。但是对于越来越多的动态网页，更多的数据是通过异步的JS代码来获取和渲染的，而初始的html页面并没有收录这部分数据。
上图中我们看到的网页在初始文档加载后并没有看到红框中的数据列表。浏览器通过执行异步JS请求，将获取到的动态数据渲染到原创文档页面中，最终变成我们看到的网页。对于这部分需要JS代码执行的数据，httpClient是无能为力的。虽然我们可以通过研究得到JS执行的请求路径，然后用java代码来获取我们需要的部分数据，不说能不能从JS脚本中分析请求路径和请求参数，只分析这部分数据源码成本已经很高了。
通过上面的介绍，我们了解到现在很大一部分动态网页都是通过异步JS请求获取的数据，然后通过JS渲染页面。那么我们能不能做这样的假设，假设我们的爬虫程序模拟一个浏览器，拿到html页面后，像浏览器一样执行异步JS代码，JS渲染好html页面后，就可以愉快的获取到节点信息了这页纸。那么有没有这样的java程序呢？
答案是肯定的。
HtmlUnit就是这样一个库，用来做界面显示的所有异步工作。没有耗时的显示工作，HtmlUnit 加载的完整网页比实际的浏览器块更多。并且根据不同的配置，HtmlUnit可以模拟市面上常见的Chrome、Firefox、IE浏览器等浏览器。
通过HtmlUnit库，加载一个完整的Html页面（图片和视频除外），然后将其转换成我们常用的字符串格式，使用Jsoup等其他工具获取元素。当然，你也可以直接从HtmlUnit提供的对象中获取网页元素，甚至可以操作按钮、表单等控件。除了不能像可见浏览器那样用鼠标和键盘浏览网页之外，我们可以使用HtmlUnit来模拟所有其他的操作，比如登录网站、写博客等都可以完成。当然，网页内容抓取是最简单的应用。
HtmlUnit 使用方法 1. 创建一个新的 maven 项目并添加 HtmlUnit 依赖项：
net.sourceforge.htmlunit
htmlunit
2.27
2.新建一个Junit TestCase 试试这个库
程序代码注释如下：
package xuyihao.util.depend;
import com.gargoylesoftware.htmlunit.BrowserVersion;
import com.gargoylesoftware.htmlunit.NicelyResynchronizingAjaxController;
import com.gargoylesoftware.htmlunit.WebClient;
import com.gargoylesoftware.htmlunit.html.HtmlPage;
import org.jsoup.Jsoup;
import org.jsoup.nodes.Document;
import org.jsoup.nodes.Element;
import org.junit.Test;
import java.util.List;
/**
* Created by xuyh at 2017/11/6 14:03.
*/
public class HtmlUtilTest {
@Test
public void test() {
final WebClient webClient = new WebClient(BrowserVersion.CHROME);//新建一个模拟谷歌Chrome浏览器的浏览器客户端对象
webClient.getOptions().setThrowExceptionOnScriptError(false);//当JS执行出错的时候是否抛出异常, 这里选择不需要
webClient.getOptions().setThrowExceptionOnFailingStatusCode(false);//当HTTP的状态非200时是否抛出异常, 这里选择不需要
webClient.getOptions().setActiveXNative(false);
webClient.getOptions().setCssEnabled(false);//是否启用CSS, 因为不需要展现页面, 所以不需要启用
webClient.getOptions().setJavaScriptEnabled(true); //很重要，启用JS
webClient.setAjaxController(new NicelyResynchronizingAjaxController());//很重要，设置支持AJAX
HtmlPage page = null;
try {
page = webClient.getPage("http://ent.sina.com.cn/film/";);//尝试加载上面图片例子给出的网页
} catch (Exception e) {
e.printStackTrace();
}finally {
webClient.close();
}
webClient.waitForBackgroundJavaScript(30000);//异步JS执行需要耗时,所以这里线程要阻塞30秒,等待异步JS执行结束
String pageXml = page.asXml();//直接将加载完成的页面转换成xml格式的字符串
//TODO 下面的代码就是对字符串的操作了,常规的爬虫操作,用到了比较好用的Jsoup库
Document document = Jsoup.parse(pageXml);//获取html文档
List infoListEle = document.getElementById("feedCardContent").getElementsByAttributeValue("class", "feed-card-item");//获取元素节点等
infoListEle.forEach(element -> {
System.out.println(element.getElementsByTag("h2").first().getElementsByTag("a").text());
System.out.println(element.getElementsByTag("h2").first().getElementsByTag("a").attr("href"));
});
}
}
上面的示例将获取到的页面中消息列表的标题和超链接 URL 打印到控制台。操作HTML文档的库是Jsoup，需要添加依赖：
org.jsoup
jsoup
1.8.3
等待三十秒后，控制台输出如下：
十一月 06, 2017 2:17:05 下午 com.gargoylesoftware.htmlunit.IncorrectnessListenerImpl notify
警告: Obsolete content type encountered: 'application/x-javascript'.
十一月 06, 2017 2:17:06 下午 com.gargoylesoftware.htmlunit.javascript.StrictErrorReporter runtimeError
严重: runtimeError: message=[An invalid or illegal selector was specified (selector: '*,:x' error: Invalid selector: :x).] sourceName=[http://n.sinaimg.cn/lib/core/core.js] line=[1] lineSource=[null] lineOffset=[0]
十一月 06, 2017 2:17:06 下午 com.gargoylesoftware.htmlunit.IncorrectnessListenerImpl notify
警告: Obsolete content type encountered: 'application/x-javascript'.
2017-11-06 14:17:11.003:INFO::JS executor for com.gargoylesoftware.htmlunit.WebClient@618c5d94: Logging initialized @7179ms to org.eclipse.jetty.util.log.StdErrLog
十一月 06, 2017 2:17:11 下午 com.gargoylesoftware.htmlunit.javascript.host.WebSocket run
严重: WS connect error
java.util.concurrent.ExecutionException: org.eclipse.jetty.websocket.api.UpgradeException: 0 null
at java.util.concurrent.CompletableFuture.reportGet(CompletableFuture.java:357)
at java.util.concurrent.CompletableFuture.get(CompletableFuture.java:1895)
at com.gargoylesoftware.htmlunit.javascript.host.WebSocket$1.run(WebSocket.java:151)
at org.eclipse.jetty.util.thread.QueuedThreadPool.runJob(QueuedThreadPool.java:672)
at org.eclipse.jetty.util.thread.QueuedThreadPool$2.run(QueuedThreadPool.java:590)
at java.lang.Thread.run(Thread.java:748)
Caused by: org.eclipse.jetty.websocket.api.UpgradeException: 0 null
at org.eclipse.jetty.websocket.client.WebSocketUpgradeRequest.onComplete(WebSocketUpgradeRequest.java:513)
at org.eclipse.jetty.client.ResponseNotifier.notifyComplete(ResponseNotifier.java:193)
at org.eclipse.jetty.client.ResponseNotifier.notifyComplete(ResponseNotifier.java:185)
at org.eclipse.jetty.client.HttpExchange.notifyFailureComplete(HttpExchange.java:269)
at org.eclipse.jetty.client.HttpExchange.abort(HttpExchange.java:240)
at org.eclipse.jetty.client.HttpConversation.abort(HttpConversation.java:141)
at org.eclipse.jetty.client.HttpRequest.abort(HttpRequest.java:748)
at org.eclipse.jetty.client.HttpDestination.abort(HttpDestination.java:444)
at org.eclipse.jetty.client.HttpDestination.failed(HttpDestination.java:224)
at org.eclipse.jetty.client.AbstractConnectionPool$1.failed(AbstractConnectionPool.java:122)
at org.eclipse.jetty.util.Promise$Wrapper.failed(Promise.java:136)
at org.eclipse.jetty.client.HttpClient$1$1.failed(HttpClient.java:588)
at org.eclipse.jetty.client.AbstractHttpClientTransport.connectFailed(AbstractHttpClientTransport.java:154)
at org.eclipse.jetty.client.AbstractHttpClientTransport$ClientSelectorManager.connectionFailed(AbstractHttpClientTransport.java:199)
at org.eclipse.jetty.io.ManagedSelector$Connect.failed(ManagedSelector.java:655)
at org.eclipse.jetty.io.ManagedSelector$Connect.access$1300(ManagedSelector.java:622)
at org.eclipse.jetty.io.ManagedSelector$1.failed(ManagedSelector.java:364)
at org.eclipse.jetty.io.ManagedSelector$CreateEndPoint.run(ManagedSelector.java:604)
... 3 more
Caused
httpclient 抓取网页(如何开发一个Java爬虫(的设计机制及原理))
网站优化 • 优采云 发表了文章 • 0 个评论 • 167 次浏览 • 2022-04-07 09:29
httpclient 抓取网页(如何开发一个Java爬虫(的设计机制及原理))
最近在写一个小爬虫，准备爬取一部分网页数据进行模型训练。在考虑如何爬取和分析网页的时候，参考了OSC站的一些项目，特别是@黄一华写的webmagic的设计机制和原理——如何开发Java爬虫”文章给了很多启发，webmagic是一个垂直爬虫，而我想写的是一个比较通用的爬虫，主要是爬取中文网站对于HTTP协议和消息处理，没有比HttpClient组件更好的选择。对于HTML代码解析，后对比HTMLParser和Jsoup，后者在API的使用上优势明显，简洁易懂，在确定使用的开源组件后，
我的爬虫要爬取这部分功能，我只需要根据网页的URL爬取HTML代码，然后从HTML代码中解析出链接和HTML代码。
可以使用标签的文本，所以解析的结果可以用一个Page类来表示，纯粹是一个POJO，那么如何使用HttpClient和Jsoup直接解析成Page对象呢？
在HttpClient4.2中，提供了ResponseHandler接口，负责处理HttpResponse。因此，通过实现该接口，可以将返回的 HTML 代码解析为所需的 Page 对象。主要思路是先将HttpResponse中的数据读出来，转换成HTML代码，然后用jsoup解析
标签和标签。代码显示如下，
公共类 PageResponseHandler 实现 ResponseHandler
{
private Page page;
public PageResponseHandler(Page page) {
this.page = page;
}
public void setPage(Page page) {
this.page = page;
}
public Page getPage() {
return page;
}
@Override
public Page handleResponse(HttpResponse response) throws ClientProtocolException, IOException {
StatusLine statusLine = response.getStatusLine();
HttpEntity entity = response.getEntity();
if (statusLine.getStatusCode() >= 300) {
EntityUtils.consume(entity);
throw new HttpResponseException(statusLine.getStatusCode(), statusLine.getReasonPhrase());
}
if (entity == null)
return null;
// 利用HTTPClient自带的EntityUtils把当前HttpResponse中的HttpEntity转化成HTML代码
String html = EntityUtils.toString(entity);
Document document = Jsoup.parse(html);
Elements links = document.getElementsByTag("a");
for (int i = 0; i < links.size(); i++) {
Element link = links.get(i);
page.addAnchor(link.attr("href"), link.text());
}
// parse context of plain text from HTML code,
Elements paragraphs = document.getElementsByTag("p");
StringBuffer plainText = new StringBuffer(html.length() / 2);
for (int i = 0; i < paragraphs.size(); i++) {
Element paragraph = paragraphs.get(i);
plainText.append(paragraph.text()).append("\n");
}
page.setPlainText(plainText.toString());
return page;
}
}
代码不超过40行，非常简单。现在可以直接返回Page对象，编写一个测试类来测试这个PageResponseHandler。测试这个类的功能不需要复杂的代码。
公共类 PageResponseHandlerTest {
HttpClient httpclient;
PageResponseHandler pageResponseHandler;
final String url = "http://news.163.com/13/0903/11 ... 3B%3B
Page page = new Page(url);
@Before
public void setUp() throws Exception {
httpclient = new DefaultHttpClient();
HttpGet httpget = new HttpGet(url);
pageResponseHandler = new PageResponseHandler(page);
httpclient.execute(httpget, pageResponseHandler);
}
@After
public void tearDown() throws Exception {
httpclient.getConnectionManager().shutdown();
}
@Test
public void test() {
System.out.println(page.getPlainText());
assertTrue(page.getPlainText().length() > 0);
assertTrue(page.getAnchors().size() > 0);
}
}
到目前为止，该爬虫中的爬取和分析功能运行良好。对于中文，它们也可以很好地解析。比较细心的读者会看到，这些代码中并没有设置字符集，也没有对字符集进行转换，后面会讲到HttpClient4.2组件中的字符集处理。
让我们首先回顾一下 Content-Type 在 HTTP 协议的 RFC 规范中的作用。它指示发送给接收方 HttpEntity 的内容的媒体类型。对于text-type HttpEntity，通常采用如下形式，指定HttpEntity的媒体类型，使用另外，RFC规范还规定在Content-Type不指定字符集的情况下，ISO-8859-默认使用 1 个字符集来编码 Http Entity
1
内容类型：文本/html；字符集=UTF-8
说到这里，你应该可以猜到 HttpClient 4.2 是如何正确编码的——即使用 Content-Type 标头中收录的字符集作为输入源进行编码。具体代码见EntityUtils类第212行开始的代码。EntityUtils 首先从 HttpEntity 对象中获取 Content-Type。如果 Content-Type 的字符集不为空，则使用 Content-Type 对象中指定的字符集进行编码，否则使用开发者指定的字符集进行编码，如果开发者未指定字符集，默认字符集 iso-8859-1 用于编码。当然，编码实现是调用JDK的Reader类。
ContentType contentType = ContentType.getOrDefault(entity);
字符集 charset = contentType.getCharset();
if (charset == null) {
字符集 = 默认字符集；
}
if (charset == null) { 查看全部
最近在写一个小爬虫，准备爬取一部分网页数据进行模型训练。在考虑如何爬取和分析网页的时候，参考了OSC站的一些项目，特别是@黄一华写的webmagic的设计机制和原理——如何开发Java爬虫”文章给了很多启发，webmagic是一个垂直爬虫，而我想写的是一个比较通用的爬虫，主要是爬取中文网站对于HTTP协议和消息处理，没有比HttpClient组件更好的选择。对于HTML代码解析，后对比HTMLParser和Jsoup，后者在API的使用上优势明显，简洁易懂，在确定使用的开源组件后，
我的爬虫要爬取这部分功能，我只需要根据网页的URL爬取HTML代码，然后从HTML代码中解析出链接和HTML代码。
可以使用标签的文本，所以解析的结果可以用一个Page类来表示，纯粹是一个POJO，那么如何使用HttpClient和Jsoup直接解析成Page对象呢？
在HttpClient4.2中，提供了ResponseHandler接口，负责处理HttpResponse。因此，通过实现该接口，可以将返回的 HTML 代码解析为所需的 Page 对象。主要思路是先将HttpResponse中的数据读出来，转换成HTML代码，然后用jsoup解析
标签和标签。代码显示如下，
公共类 PageResponseHandler 实现 ResponseHandler
{
private Page page;
public PageResponseHandler(Page page) {
this.page = page;
}
public void setPage(Page page) {
this.page = page;
}
public Page getPage() {
return page;
}
@Override
public Page handleResponse(HttpResponse response) throws ClientProtocolException, IOException {
StatusLine statusLine = response.getStatusLine();
HttpEntity entity = response.getEntity();
if (statusLine.getStatusCode() >= 300) {
EntityUtils.consume(entity);
throw new HttpResponseException(statusLine.getStatusCode(), statusLine.getReasonPhrase());
}
if (entity == null)
return null;
// 利用HTTPClient自带的EntityUtils把当前HttpResponse中的HttpEntity转化成HTML代码
String html = EntityUtils.toString(entity);
Document document = Jsoup.parse(html);
Elements links = document.getElementsByTag("a");
for (int i = 0; i < links.size(); i++) {
Element link = links.get(i);
page.addAnchor(link.attr("href"), link.text());
}
// parse context of plain text from HTML code,
Elements paragraphs = document.getElementsByTag("p");
StringBuffer plainText = new StringBuffer(html.length() / 2);
for (int i = 0; i < paragraphs.size(); i++) {
Element paragraph = paragraphs.get(i);
plainText.append(paragraph.text()).append("\n");
}
page.setPlainText(plainText.toString());
return page;
}
}
代码不超过40行，非常简单。现在可以直接返回Page对象，编写一个测试类来测试这个PageResponseHandler。测试这个类的功能不需要复杂的代码。
公共类 PageResponseHandlerTest {
HttpClient httpclient;
PageResponseHandler pageResponseHandler;
final String url = "http://news.163.com/13/0903/11 ... 3B%3B
Page page = new Page(url);
@Before
public void setUp() throws Exception {
httpclient = new DefaultHttpClient();
HttpGet httpget = new HttpGet(url);
pageResponseHandler = new PageResponseHandler(page);
httpclient.execute(httpget, pageResponseHandler);
}
@After
public void tearDown() throws Exception {
httpclient.getConnectionManager().shutdown();
}
@Test
public void test() {
System.out.println(page.getPlainText());
assertTrue(page.getPlainText().length() > 0);
assertTrue(page.getAnchors().size() > 0);
}
}
到目前为止，该爬虫中的爬取和分析功能运行良好。对于中文，它们也可以很好地解析。比较细心的读者会看到，这些代码中并没有设置字符集，也没有对字符集进行转换，后面会讲到HttpClient4.2组件中的字符集处理。
让我们首先回顾一下 Content-Type 在 HTTP 协议的 RFC 规范中的作用。它指示发送给接收方 HttpEntity 的内容的媒体类型。对于text-type HttpEntity，通常采用如下形式，指定HttpEntity的媒体类型，使用另外，RFC规范还规定在Content-Type不指定字符集的情况下，ISO-8859-默认使用 1 个字符集来编码 Http Entity
1
内容类型：文本/html；字符集=UTF-8
说到这里，你应该可以猜到 HttpClient 4.2 是如何正确编码的——即使用 Content-Type 标头中收录的字符集作为输入源进行编码。具体代码见EntityUtils类第212行开始的代码。EntityUtils 首先从 HttpEntity 对象中获取 Content-Type。如果 Content-Type 的字符集不为空，则使用 Content-Type 对象中指定的字符集进行编码，否则使用开发者指定的字符集进行编码，如果开发者未指定字符集，默认字符集 iso-8859-1 用于编码。当然，编码实现是调用JDK的Reader类。
ContentType contentType = ContentType.getOrDefault(entity);
字符集 charset = contentType.getCharset();
if (charset == null) {
字符集 = 默认字符集；
}
if (charset == null) { 查看全部
httpclient 抓取网页(如何开发一个Java爬虫(的设计机制及原理))
最近在写一个小爬虫，准备爬取一部分网页数据进行模型训练。在考虑如何爬取和分析网页的时候，参考了OSC站的一些项目，特别是@黄一华写的webmagic的设计机制和原理——如何开发Java爬虫”文章给了很多启发，webmagic是一个垂直爬虫，而我想写的是一个比较通用的爬虫，主要是爬取中文网站对于HTTP协议和消息处理，没有比HttpClient组件更好的选择。对于HTML代码解析，后对比HTMLParser和Jsoup，后者在API的使用上优势明显，简洁易懂，在确定使用的开源组件后，
我的爬虫要爬取这部分功能，我只需要根据网页的URL爬取HTML代码，然后从HTML代码中解析出链接和HTML代码。
可以使用标签的文本，所以解析的结果可以用一个Page类来表示，纯粹是一个POJO，那么如何使用HttpClient和Jsoup直接解析成Page对象呢？
在HttpClient4.2中，提供了ResponseHandler接口，负责处理HttpResponse。因此，通过实现该接口，可以将返回的 HTML 代码解析为所需的 Page 对象。主要思路是先将HttpResponse中的数据读出来，转换成HTML代码，然后用jsoup解析
标签和标签。代码显示如下，
公共类 PageResponseHandler 实现 ResponseHandler
{
private Page page;
public PageResponseHandler(Page page) {
this.page = page;
}
public void setPage(Page page) {
this.page = page;
}
public Page getPage() {
return page;
}
@Override
public Page handleResponse(HttpResponse response) throws ClientProtocolException, IOException {
StatusLine statusLine = response.getStatusLine();
HttpEntity entity = response.getEntity();
if (statusLine.getStatusCode() >= 300) {
EntityUtils.consume(entity);
throw new HttpResponseException(statusLine.getStatusCode(), statusLine.getReasonPhrase());
}
if (entity == null)
return null;
// 利用HTTPClient自带的EntityUtils把当前HttpResponse中的HttpEntity转化成HTML代码
String html = EntityUtils.toString(entity);
Document document = Jsoup.parse(html);
Elements links = document.getElementsByTag("a");
for (int i = 0; i < links.size(); i++) {
Element link = links.get(i);
page.addAnchor(link.attr("href"), link.text());
}
// parse context of plain text from HTML code,
Elements paragraphs = document.getElementsByTag("p");
StringBuffer plainText = new StringBuffer(html.length() / 2);
for (int i = 0; i < paragraphs.size(); i++) {
Element paragraph = paragraphs.get(i);
plainText.append(paragraph.text()).append("\n");
}
page.setPlainText(plainText.toString());
return page;
}
}
代码不超过40行，非常简单。现在可以直接返回Page对象，编写一个测试类来测试这个PageResponseHandler。测试这个类的功能不需要复杂的代码。
公共类 PageResponseHandlerTest {
HttpClient httpclient;
PageResponseHandler pageResponseHandler;
final String url = "http://news.163.com/13/0903/11 ... 3B%3B
Page page = new Page(url);
@Before
public void setUp() throws Exception {
httpclient = new DefaultHttpClient();
HttpGet httpget = new HttpGet(url);
pageResponseHandler = new PageResponseHandler(page);
httpclient.execute(httpget, pageResponseHandler);
}
@After
public void tearDown() throws Exception {
httpclient.getConnectionManager().shutdown();
}
@Test
public void test() {
System.out.println(page.getPlainText());
assertTrue(page.getPlainText().length() > 0);
assertTrue(page.getAnchors().size() > 0);
}
}
到目前为止，该爬虫中的爬取和分析功能运行良好。对于中文，它们也可以很好地解析。比较细心的读者会看到，这些代码中并没有设置字符集，也没有对字符集进行转换，后面会讲到HttpClient4.2组件中的字符集处理。
让我们首先回顾一下 Content-Type 在 HTTP 协议的 RFC 规范中的作用。它指示发送给接收方 HttpEntity 的内容的媒体类型。对于text-type HttpEntity，通常采用如下形式，指定HttpEntity的媒体类型，使用另外，RFC规范还规定在Content-Type不指定字符集的情况下，ISO-8859-默认使用 1 个字符集来编码 Http Entity
1
内容类型：文本/html；字符集=UTF-8
说到这里，你应该可以猜到 HttpClient 4.2 是如何正确编码的——即使用 Content-Type 标头中收录的字符集作为输入源进行编码。具体代码见EntityUtils类第212行开始的代码。EntityUtils 首先从 HttpEntity 对象中获取 Content-Type。如果 Content-Type 的字符集不为空，则使用 Content-Type 对象中指定的字符集进行编码，否则使用开发者指定的字符集进行编码，如果开发者未指定字符集，默认字符集 iso-8859-1 用于编码。当然，编码实现是调用JDK的Reader类。
ContentType contentType = ContentType.getOrDefault(entity);
字符集 charset = contentType.getCharset();
if (charset == null) {
字符集 = 默认字符集；
}
if (charset == null) {
httpclient 抓取网页(想用的使用参考Java11新特性之HttpClient_java_之家之家)
网站优化 • 优采云 发表了文章 • 0 个评论 • 87 次浏览 • 2022-03-28 03:08
httpclient 抓取网页(想用的使用参考Java11新特性之HttpClient_java_之家之家)
从必应主页抓取他的日常照片
上学的时候用python写了一个小工具，每天抓一张bing的图片。
现在想用java来重构。
抓取图片的想法
首先获取网页的源代码
从网页源代码中，我们可以找到图片的下载链接和图片的描述信息。
使用下载链接获取对应图片。
使用 python 抓取
我们使用python中的requests库来获取网页的源代码，然后使用正则表达式从网页的源代码中搜索图片的下载链接。
res = requests.get(url) #获取网页源码，并利用正则表达式找到与bing每日一图有关的参数
pattern = re.compile(r"(\/th\?id=(.+?)\.jpg)")
# pattern = re.compile(r"\/th\?id=(.+)(\.jpg)")
result = pattern.search(res.text) #从源码中获取bing大图的图片链接
imgLinkParam = result.group(0).split("&")
imgDownloadUrl = url+"&".join(imgLinkParam)
得到图片的下载地址后，还需要从网页中找到图片的标题。
这里我们使用 BeautifulSoup 库来解析网页。
查找所有class="title"的a节点，取a的第一个节点，其内容为图片的标题。
soup = BeautifulSoup(res.text,'lxml') #使用bs4来解析对应的html文件
#print(soup)
# imageInfo = soup.find_all(name="a",attrs={"id":"sh_cp","class":"sc_light"})
imageInfo = soup.find_all(name="a", attrs={"class":"title"})
imageDescription=imageInfo[0].contents[0] #获取对图片的描述
最后我们根据图片链接下载图片到本地
pictureData = requests.get(imgDownloadUrl) #根据下载链接获取图片数据
with open(imgName,"wb") as f:
f.write(pictureData.content)
f.flush()
log_write(logName,"图片保存成功")
如何使用java重构代码
思路和之前python的实现大致相同，先获取bing首页的html内容，然后解析html得到需要的内容。然后下载图片
首先需要构造一个http请求，根据链接发送请求并下载图片文件。这里我们使用java 11自带的HttpClient来发送http请求。
HttpClient的使用参考Java11的新特性，HttpClient小测试knife_java_Script Home() 查看全部
从必应主页抓取他的日常照片
上学的时候用python写了一个小工具，每天抓一张bing的图片。
现在想用java来重构。
抓取图片的想法
首先获取网页的源代码
从网页源代码中，我们可以找到图片的下载链接和图片的描述信息。
使用下载链接获取对应图片。
使用 python 抓取
我们使用python中的requests库来获取网页的源代码，然后使用正则表达式从网页的源代码中搜索图片的下载链接。
res = requests.get(url) #获取网页源码，并利用正则表达式找到与bing每日一图有关的参数
pattern = re.compile(r"(\/th\?id=(.+?)\.jpg)")
# pattern = re.compile(r"\/th\?id=(.+)(\.jpg)")
result = pattern.search(res.text) #从源码中获取bing大图的图片链接
imgLinkParam = result.group(0).split("&")
imgDownloadUrl = url+"&".join(imgLinkParam)
得到图片的下载地址后，还需要从网页中找到图片的标题。
这里我们使用 BeautifulSoup 库来解析网页。
查找所有class="title"的a节点，取a的第一个节点，其内容为图片的标题。
soup = BeautifulSoup(res.text,'lxml') #使用bs4来解析对应的html文件
#print(soup)
# imageInfo = soup.find_all(name="a",attrs={"id":"sh_cp","class":"sc_light"})
imageInfo = soup.find_all(name="a", attrs={"class":"title"})
imageDescription=imageInfo[0].contents[0] #获取对图片的描述
最后我们根据图片链接下载图片到本地
pictureData = requests.get(imgDownloadUrl) #根据下载链接获取图片数据
with open(imgName,"wb") as f:
f.write(pictureData.content)
f.flush()
log_write(logName,"图片保存成功")
如何使用java重构代码
思路和之前python的实现大致相同，先获取bing首页的html内容，然后解析html得到需要的内容。然后下载图片
首先需要构造一个http请求，根据链接发送请求并下载图片文件。这里我们使用java 11自带的HttpClient来发送http请求。
HttpClient的使用参考Java11的新特性，HttpClient小测试knife_java_Script Home() 查看全部
httpclient 抓取网页(想用的使用参考Java11新特性之HttpClient_java_之家之家)
从必应主页抓取他的日常照片
上学的时候用python写了一个小工具，每天抓一张bing的图片。
现在想用java来重构。
抓取图片的想法
首先获取网页的源代码
从网页源代码中，我们可以找到图片的下载链接和图片的描述信息。
使用下载链接获取对应图片。
使用 python 抓取
我们使用python中的requests库来获取网页的源代码，然后使用正则表达式从网页的源代码中搜索图片的下载链接。
res = requests.get(url) #获取网页源码，并利用正则表达式找到与bing每日一图有关的参数
pattern = re.compile(r"(\/th\?id=(.+?)\.jpg)")
# pattern = re.compile(r"\/th\?id=(.+)(\.jpg)")
result = pattern.search(res.text) #从源码中获取bing大图的图片链接
imgLinkParam = result.group(0).split("&")
imgDownloadUrl = url+"&".join(imgLinkParam)
得到图片的下载地址后，还需要从网页中找到图片的标题。
这里我们使用 BeautifulSoup 库来解析网页。
查找所有class="title"的a节点，取a的第一个节点，其内容为图片的标题。
soup = BeautifulSoup(res.text,'lxml') #使用bs4来解析对应的html文件
#print(soup)
# imageInfo = soup.find_all(name="a",attrs={"id":"sh_cp","class":"sc_light"})
imageInfo = soup.find_all(name="a", attrs={"class":"title"})
imageDescription=imageInfo[0].contents[0] #获取对图片的描述
最后我们根据图片链接下载图片到本地
pictureData = requests.get(imgDownloadUrl) #根据下载链接获取图片数据
with open(imgName,"wb") as f:
f.write(pictureData.content)
f.flush()
log_write(logName,"图片保存成功")
如何使用java重构代码
思路和之前python的实现大致相同，先获取bing首页的html内容，然后解析html得到需要的内容。然后下载图片
首先需要构造一个http请求，根据链接发送请求并下载图片文件。这里我们使用java 11自带的HttpClient来发送http请求。
HttpClient的使用参考Java11的新特性，HttpClient小测试knife_java_Script Home()
httpclient 抓取网页(想用的使用参考Java11新特性之HttpClient_java_之家之家)
网站优化 • 优采云 发表了文章 • 0 个评论 • 75 次浏览 • 2022-03-23 00:28
httpclient 抓取网页(想用的使用参考Java11新特性之HttpClient_java_之家之家)
从必应主页抓取他的日常照片
上学的时候用python写了一个小工具，每天抓一张bing的图片。
现在想用java来重构。
抓取图片的想法
首先获取网页的源代码
从网页源代码中，我们可以找到图片的下载链接和图片的描述信息。
使用下载链接获取对应图片。
使用 python 抓取
我们使用python中的requests库来获取网页的源代码，然后使用正则表达式从网页的源代码中搜索图片的下载链接。
res = requests.get(url) #获取网页源码，并利用正则表达式找到与bing每日一图有关的参数
pattern = re.compile(r"(\/th\?id=(.+?)\.jpg)")
# pattern = re.compile(r"\/th\?id=(.+)(\.jpg)")
result = pattern.search(res.text) #从源码中获取bing大图的图片链接
imgLinkParam = result.group(0).split("&")
imgDownloadUrl = url+"&".join(imgLinkParam)
得到图片的下载地址后，还需要从网页中找到图片的标题。
这里我们使用 BeautifulSoup 库来解析网页。
查找所有class="title"的a节点，取a的第一个节点，其内容为图片的标题。
soup = BeautifulSoup(res.text,'lxml') #使用bs4来解析对应的html文件
#print(soup)
# imageInfo = soup.find_all(name="a",attrs={"id":"sh_cp","class":"sc_light"})
imageInfo = soup.find_all(name="a", attrs={"class":"title"})
imageDescription=imageInfo[0].contents[0] #获取对图片的描述
最后我们根据图片链接下载图片到本地
pictureData = requests.get(imgDownloadUrl) #根据下载链接获取图片数据
with open(imgName,"wb") as f:
f.write(pictureData.content)
f.flush()
log_write(logName,"图片保存成功")
如何使用java重构代码
思路和之前python的实现大致相同，先获取bing首页的html内容，然后解析html得到需要的内容。然后下载图片
首先，根据链接发送请求和下载图片文件需要构造http请求。这里我们使用java 11自带的HttpClient来发送http请求。
HttpClient的使用参考Java11的新特性，HttpClient小测试knife_java_Script Home() 查看全部
从必应主页抓取他的日常照片
上学的时候用python写了一个小工具，每天抓一张bing的图片。
现在想用java来重构。
抓取图片的想法
首先获取网页的源代码
从网页源代码中，我们可以找到图片的下载链接和图片的描述信息。
使用下载链接获取对应图片。
使用 python 抓取
我们使用python中的requests库来获取网页的源代码，然后使用正则表达式从网页的源代码中搜索图片的下载链接。
res = requests.get(url) #获取网页源码，并利用正则表达式找到与bing每日一图有关的参数
pattern = re.compile(r"(\/th\?id=(.+?)\.jpg)")
# pattern = re.compile(r"\/th\?id=(.+)(\.jpg)")
result = pattern.search(res.text) #从源码中获取bing大图的图片链接
imgLinkParam = result.group(0).split("&")
imgDownloadUrl = url+"&".join(imgLinkParam)
得到图片的下载地址后，还需要从网页中找到图片的标题。
这里我们使用 BeautifulSoup 库来解析网页。
查找所有class="title"的a节点，取a的第一个节点，其内容为图片的标题。
soup = BeautifulSoup(res.text,'lxml') #使用bs4来解析对应的html文件
#print(soup)
# imageInfo = soup.find_all(name="a",attrs={"id":"sh_cp","class":"sc_light"})
imageInfo = soup.find_all(name="a", attrs={"class":"title"})
imageDescription=imageInfo[0].contents[0] #获取对图片的描述
最后我们根据图片链接下载图片到本地
pictureData = requests.get(imgDownloadUrl) #根据下载链接获取图片数据
with open(imgName,"wb") as f:
f.write(pictureData.content)
f.flush()
log_write(logName,"图片保存成功")
如何使用java重构代码
思路和之前python的实现大致相同，先获取bing首页的html内容，然后解析html得到需要的内容。然后下载图片
首先，根据链接发送请求和下载图片文件需要构造http请求。这里我们使用java 11自带的HttpClient来发送http请求。
HttpClient的使用参考Java11的新特性，HttpClient小测试knife_java_Script Home() 查看全部
httpclient 抓取网页(想用的使用参考Java11新特性之HttpClient_java_之家之家)
从必应主页抓取他的日常照片
上学的时候用python写了一个小工具，每天抓一张bing的图片。
现在想用java来重构。
抓取图片的想法
首先获取网页的源代码
从网页源代码中，我们可以找到图片的下载链接和图片的描述信息。
使用下载链接获取对应图片。
使用 python 抓取
我们使用python中的requests库来获取网页的源代码，然后使用正则表达式从网页的源代码中搜索图片的下载链接。
res = requests.get(url) #获取网页源码，并利用正则表达式找到与bing每日一图有关的参数
pattern = re.compile(r"(\/th\?id=(.+?)\.jpg)")
# pattern = re.compile(r"\/th\?id=(.+)(\.jpg)")
result = pattern.search(res.text) #从源码中获取bing大图的图片链接
imgLinkParam = result.group(0).split("&")
imgDownloadUrl = url+"&".join(imgLinkParam)
得到图片的下载地址后，还需要从网页中找到图片的标题。
这里我们使用 BeautifulSoup 库来解析网页。
查找所有class="title"的a节点，取a的第一个节点，其内容为图片的标题。
soup = BeautifulSoup(res.text,'lxml') #使用bs4来解析对应的html文件
#print(soup)
# imageInfo = soup.find_all(name="a",attrs={"id":"sh_cp","class":"sc_light"})
imageInfo = soup.find_all(name="a", attrs={"class":"title"})
imageDescription=imageInfo[0].contents[0] #获取对图片的描述
最后我们根据图片链接下载图片到本地
pictureData = requests.get(imgDownloadUrl) #根据下载链接获取图片数据
with open(imgName,"wb") as f:
f.write(pictureData.content)
f.flush()
log_write(logName,"图片保存成功")
如何使用java重构代码
思路和之前python的实现大致相同，先获取bing首页的html内容，然后解析html得到需要的内容。然后下载图片
首先，根据链接发送请求和下载图片文件需要构造http请求。这里我们使用java 11自带的HttpClient来发送http请求。
HttpClient的使用参考Java11的新特性，HttpClient小测试knife_java_Script Home()
httpclient 抓取网页(STM32 )
网站优化 • 优采云 发表了文章 • 0 个评论 • 75 次浏览 • 2022-03-19 22:21
httpclient 抓取网页(STM32
)
1、GET 方法
第一步是创建一个客户端，类似于使用浏览器打开网页的方式
HttpClient httpClient = new HttpClient();
第二步，创建GET方法，获取需要抓取的网页的URL
GetMethod getMethod = new GetMethod("");
第三步，获取URL的响应状态码，200表示请求成功
int statusCode = httpClient.executeMethod(getMethod);
第四步，获取网页源代码
byte[] responseBody = getMethod.getResponseBody();
主要是这四个步骤，当然还有很多其他的，比如网页编码问题
[java] view plain copy print ?
HttpClient httpClient = new HttpClient(); GetMethod getMethod = new GetMethod("http://www.baidu.com/"); try { int statusCode = httpClient.executeMethod(getMethod); if (statusCode != HttpStatus.SC_OK) { System.err.println("Method failed: " + getMethod.getStatusLine()); } // 读取内容 byte[] responseBody = getMethod.getResponseBody(); // 处理内容 String html = new String(responseBody); System.out.println(html); } catch (Exception e) { System.err.println("页面无法访问"); }finally{ getMethod.releaseConnection(); }
2、发布方式
[java] view plain copy print ?
HttpClient httpClient = new HttpClient(); PostMethod postMethod = new PostMethod(UrlPath); postMethod.getParams().setParameter(HttpMethodParams.RETRY_HANDLER,new DefaultHttpMethodRetryHandler()); NameValuePair[] postData = new NameValuePair[2]; postData[0] = new NameValuePair("username", "xkey"); postData[1] = new NameValuePair("userpass", "********"); postMethod.setRequestBody(postData); try { int statusCode = httpClient.executeMethod(postMethod); if (statusCode == HttpStatus.SC_OK) { byte[] responseBody = postMethod.getResponseBody(); String html = new String(responseBody); System.out.println(html); } } catch (Exception e) { System.err.println("页面无法访问"); }finally{ postMethod.releaseConnection(); }
本例传递两个Post参数：username为xkey，userpass为********，传递给URL UrlPath
如果您需要更多关于获取 gzip 页面的信息，请参考
另外一种是获取非字符数据，所以可以使用下面的方法
[java] view plain copy print ?
HttpClient httpClient = new HttpClient(); GetMethod getMethod = new GetMethod("http://www.baidu.com"); try { InputStream inputStream = getMethod.getResponseBodyAsStream(); // 这里处理 inputStream } catch (Exception e) { System.err.println("页面无法访问"); }finally{ getMethod.releaseConnection(); } 查看全部
)
1、GET 方法
第一步是创建一个客户端，类似于使用浏览器打开网页的方式
HttpClient httpClient = new HttpClient();
第二步，创建GET方法，获取需要抓取的网页的URL
GetMethod getMethod = new GetMethod("");
第三步，获取URL的响应状态码，200表示请求成功
int statusCode = httpClient.executeMethod(getMethod);
第四步，获取网页源代码
byte[] responseBody = getMethod.getResponseBody();
主要是这四个步骤，当然还有很多其他的，比如网页编码问题
[java] view plain copy print ?
HttpClient httpClient = new HttpClient(); GetMethod getMethod = new GetMethod("http://www.baidu.com/"); try { int statusCode = httpClient.executeMethod(getMethod); if (statusCode != HttpStatus.SC_OK) { System.err.println("Method failed: " + getMethod.getStatusLine()); } // 读取内容 byte[] responseBody = getMethod.getResponseBody(); // 处理内容 String html = new String(responseBody); System.out.println(html); } catch (Exception e) { System.err.println("页面无法访问"); }finally{ getMethod.releaseConnection(); }
2、发布方式
[java] view plain copy print ?
HttpClient httpClient = new HttpClient(); PostMethod postMethod = new PostMethod(UrlPath); postMethod.getParams().setParameter(HttpMethodParams.RETRY_HANDLER,new DefaultHttpMethodRetryHandler()); NameValuePair[] postData = new NameValuePair[2]; postData[0] = new NameValuePair("username", "xkey"); postData[1] = new NameValuePair("userpass", "********"); postMethod.setRequestBody(postData); try { int statusCode = httpClient.executeMethod(postMethod); if (statusCode == HttpStatus.SC_OK) { byte[] responseBody = postMethod.getResponseBody(); String html = new String(responseBody); System.out.println(html); } } catch (Exception e) { System.err.println("页面无法访问"); }finally{ postMethod.releaseConnection(); }
本例传递两个Post参数：username为xkey，userpass为********，传递给URL UrlPath
如果您需要更多关于获取 gzip 页面的信息，请参考
另外一种是获取非字符数据，所以可以使用下面的方法
[java] view plain copy print ?
HttpClient httpClient = new HttpClient(); GetMethod getMethod = new GetMethod("http://www.baidu.com"); try { InputStream inputStream = getMethod.getResponseBodyAsStream(); // 这里处理 inputStream } catch (Exception e) { System.err.println("页面无法访问"); }finally{ getMethod.releaseConnection(); } 查看全部
httpclient 抓取网页(STM32
)
1、GET 方法
第一步是创建一个客户端，类似于使用浏览器打开网页的方式
HttpClient httpClient = new HttpClient();
第二步，创建GET方法，获取需要抓取的网页的URL
GetMethod getMethod = new GetMethod("");
第三步，获取URL的响应状态码，200表示请求成功
int statusCode = httpClient.executeMethod(getMethod);
第四步，获取网页源代码
byte[] responseBody = getMethod.getResponseBody();
主要是这四个步骤，当然还有很多其他的，比如网页编码问题
[java] view plain copy print ?
HttpClient httpClient = new HttpClient(); GetMethod getMethod = new GetMethod("http://www.baidu.com/";); try { int statusCode = httpClient.executeMethod(getMethod); if (statusCode != HttpStatus.SC_OK) { System.err.println("Method failed: " + getMethod.getStatusLine()); } // 读取内容 byte[] responseBody = getMethod.getResponseBody(); // 处理内容 String html = new String(responseBody); System.out.println(html); } catch (Exception e) { System.err.println("页面无法访问"); }finally{ getMethod.releaseConnection(); }
2、发布方式
[java] view plain copy print ?
HttpClient httpClient = new HttpClient(); PostMethod postMethod = new PostMethod(UrlPath); postMethod.getParams().setParameter(HttpMethodParams.RETRY_HANDLER,new DefaultHttpMethodRetryHandler()); NameValuePair[] postData = new NameValuePair[2]; postData[0] = new NameValuePair("username", "xkey"); postData[1] = new NameValuePair("userpass", "********"); postMethod.setRequestBody(postData); try { int statusCode = httpClient.executeMethod(postMethod); if (statusCode == HttpStatus.SC_OK) { byte[] responseBody = postMethod.getResponseBody(); String html = new String(responseBody); System.out.println(html); } } catch (Exception e) { System.err.println("页面无法访问"); }finally{ postMethod.releaseConnection(); }
本例传递两个Post参数：username为xkey，userpass为********，传递给URL UrlPath
如果您需要更多关于获取 gzip 页面的信息，请参考
另外一种是获取非字符数据，所以可以使用下面的方法
[java] view plain copy print ?
HttpClient httpClient = new HttpClient(); GetMethod getMethod = new GetMethod("http://www.baidu.com";); try { InputStream inputStream = getMethod.getResponseBodyAsStream(); // 这里处理 inputStream } catch (Exception e) { System.err.println("页面无法访问"); }finally{ getMethod.releaseConnection(); }
httpclient 抓取网页(缺点是需要人工寻找post请求的url和对应的参数 )
网站优化 • 优采云 发表了文章 • 0 个评论 • 60 次浏览 • 2022-03-07 18:19
httpclient 抓取网页(缺点是需要人工寻找post请求的url和对应的参数
)
缺点是需要手动查找post请求的url和对应的参数。
参考：
1.为 GET 和 POST 请求添加请求参数和标头（使用 HttpClient，Java）
2.关于爬取js加载的内容（参考本博客的流程，比如找到实际的请求url）
以一条新闻为例：
1.使用F12，先在网络中的文件列表中找到该网页，双击弹出详细信息。“文本”查看网页内容，发现该信息对应的信息没有显示在网页上，说明是稍后加载的。
2.尝试在文本中搜索关键字以查看正在请求哪些文件获取数据。例如，在文本中搜索第一个单词“海关总署”可能会找到多个文件，需要进行判断和选择。
对应的请求体为“id:98212”，即请求参数
3.查看标题
主要取决于请求的url和请求的方法，有时还需要设置user-agent。需要使用post方法
4.代码编写
创建一个 Java Maven 项目并添加依赖项：
org.apache.httpcomponents
httpclient
4.5.6
com.google.code.gson
gson
2.2.4
下载的jar包如下图所示：
代码如下，我只拿到了文章的body：
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import org.apache.http.HttpEntity;
import org.apache.http.NameValuePair;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.util.EntityUtils;
import com.google.gson.Gson;
/**
* http://news.cqcoal.com/blank/nc.jsp?mid=98212
* 该网页的新闻主题是动态生成的，希望获取内容
* @author yangc_cong
*
*/
public class TestNewContent {
/**
* 针对请求的链接，使用post方法获取返回的数据
* @param urlStr String类型
* @return 这里是Map类型
*/
private Map getPageContByHttpCl(String urlStr) {
CloseableHttpClient httpclient = HttpClients.createDefault();
HttpPost post = new HttpPost(urlStr);
String userAgent = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/70.0.3538.102 Safari/537.36 Edge/18.18362";
post.setHeader("User-Agent", userAgent);
CloseableHttpResponse response = null;
String result = null;
// 创建请求参数
List list = new LinkedList();
BasicNameValuePair param1 = new BasicNameValuePair("id", "98212");
list.add(param1);
// 使用URL实体转换工具
UrlEncodedFormEntity entityParam = null;
try {
entityParam = new UrlEncodedFormEntity(list, "UTF-8");
post.setEntity(entityParam);
} catch (UnsupportedEncodingException e1) {
e1.printStackTrace();
}
try {
response = httpclient.execute(post);
HttpEntity entity = response.getEntity();
result = EntityUtils.toString(entity, "UTF-8");
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
response.close();
httpclient.close();
} catch (IOException e) {
e.printStackTrace();
}
}
System.out.println(result);
Gson gson = new Gson();
Map map = gson.fromJson(result, Map.class);
return map;
}
private void parse_content(Map map) {
//java.lang.ClassCastException: java.util.ArrayList cannot be cast to java.util.Map
ArrayList arrayList = (ArrayList)(map.get("rows"));
Map innerMap = (Map) arrayList.get(0);
String source = (String) innerMap.get("source");
String bodyhtml = (String) innerMap.get("body");
System.out.println("source: "+source);
System.out.println("bodyhtml:"+'\n'+bodyhtml);
}
public static void main(String[] args) {
TestNewContent test1 = new TestNewContent();
String urlStr = "http://news.cqcoal.com/manage/ ... 3B%3B
Map map = test1.getPageContByHttpCl(urlStr);
test1.parse_content(map);
}
}
运行截图：
查看全部
)
缺点是需要手动查找post请求的url和对应的参数。
参考：
1.为 GET 和 POST 请求添加请求参数和标头（使用 HttpClient，Java）
2.关于爬取js加载的内容（参考本博客的流程，比如找到实际的请求url）
以一条新闻为例：
1.使用F12，先在网络中的文件列表中找到该网页，双击弹出详细信息。“文本”查看网页内容，发现该信息对应的信息没有显示在网页上，说明是稍后加载的。
2.尝试在文本中搜索关键字以查看正在请求哪些文件获取数据。例如，在文本中搜索第一个单词“海关总署”可能会找到多个文件，需要进行判断和选择。
对应的请求体为“id:98212”，即请求参数
3.查看标题
主要取决于请求的url和请求的方法，有时还需要设置user-agent。需要使用post方法
4.代码编写
创建一个 Java Maven 项目并添加依赖项：
org.apache.httpcomponents
httpclient
4.5.6
com.google.code.gson
gson
2.2.4
下载的jar包如下图所示：
代码如下，我只拿到了文章的body：
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import org.apache.http.HttpEntity;
import org.apache.http.NameValuePair;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.util.EntityUtils;
import com.google.gson.Gson;
/**
* http://news.cqcoal.com/blank/nc.jsp?mid=98212
* 该网页的新闻主题是动态生成的，希望获取内容
* @author yangc_cong
*
*/
public class TestNewContent {
/**
* 针对请求的链接，使用post方法获取返回的数据
* @param urlStr String类型
* @return 这里是Map类型
*/
private Map getPageContByHttpCl(String urlStr) {
CloseableHttpClient httpclient = HttpClients.createDefault();
HttpPost post = new HttpPost(urlStr);
String userAgent = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/70.0.3538.102 Safari/537.36 Edge/18.18362";
post.setHeader("User-Agent", userAgent);
CloseableHttpResponse response = null;
String result = null;
// 创建请求参数
List list = new LinkedList();
BasicNameValuePair param1 = new BasicNameValuePair("id", "98212");
list.add(param1);
// 使用URL实体转换工具
UrlEncodedFormEntity entityParam = null;
try {
entityParam = new UrlEncodedFormEntity(list, "UTF-8");
post.setEntity(entityParam);
} catch (UnsupportedEncodingException e1) {
e1.printStackTrace();
}
try {
response = httpclient.execute(post);
HttpEntity entity = response.getEntity();
result = EntityUtils.toString(entity, "UTF-8");
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
response.close();
httpclient.close();
} catch (IOException e) {
e.printStackTrace();
}
}
System.out.println(result);
Gson gson = new Gson();
Map map = gson.fromJson(result, Map.class);
return map;
}
private void parse_content(Map map) {
//java.lang.ClassCastException: java.util.ArrayList cannot be cast to java.util.Map
ArrayList arrayList = (ArrayList)(map.get("rows"));
Map innerMap = (Map) arrayList.get(0);
String source = (String) innerMap.get("source");
String bodyhtml = (String) innerMap.get("body");
System.out.println("source: "+source);
System.out.println("bodyhtml:"+'\n'+bodyhtml);
}
public static void main(String[] args) {
TestNewContent test1 = new TestNewContent();
String urlStr = "http://news.cqcoal.com/manage/ ... 3B%3B
Map map = test1.getPageContByHttpCl(urlStr);
test1.parse_content(map);
}
}
运行截图：
查看全部
httpclient 抓取网页(缺点是需要人工寻找post请求的url和对应的参数
)
缺点是需要手动查找post请求的url和对应的参数。
参考：
1.为 GET 和 POST 请求添加请求参数和标头（使用 HttpClient，Java）
2.关于爬取js加载的内容（参考本博客的流程，比如找到实际的请求url）
以一条新闻为例：
1.使用F12，先在网络中的文件列表中找到该网页，双击弹出详细信息。“文本”查看网页内容，发现该信息对应的信息没有显示在网页上，说明是稍后加载的。
2.尝试在文本中搜索关键字以查看正在请求哪些文件获取数据。例如，在文本中搜索第一个单词“海关总署”可能会找到多个文件，需要进行判断和选择。
对应的请求体为“id:98212”，即请求参数
3.查看标题
主要取决于请求的url和请求的方法，有时还需要设置user-agent。需要使用post方法
4.代码编写
创建一个 Java Maven 项目并添加依赖项：
org.apache.httpcomponents
httpclient
4.5.6
com.google.code.gson
gson
2.2.4
下载的jar包如下图所示：
代码如下，我只拿到了文章的body：
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import org.apache.http.HttpEntity;
import org.apache.http.NameValuePair;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.util.EntityUtils;
import com.google.gson.Gson;
/**
* http://news.cqcoal.com/blank/nc.jsp?mid=98212
* 该网页的新闻主题是动态生成的，希望获取内容
* @author yangc_cong
*
*/
public class TestNewContent {
/**
* 针对请求的链接，使用post方法获取返回的数据
* @param urlStr String类型
* @return 这里是Map类型
*/
private Map getPageContByHttpCl(String urlStr) {
CloseableHttpClient httpclient = HttpClients.createDefault();
HttpPost post = new HttpPost(urlStr);
String userAgent = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/70.0.3538.102 Safari/537.36 Edge/18.18362";
post.setHeader("User-Agent", userAgent);
CloseableHttpResponse response = null;
String result = null;
// 创建请求参数
List list = new LinkedList();
BasicNameValuePair param1 = new BasicNameValuePair("id", "98212");
list.add(param1);
// 使用URL实体转换工具
UrlEncodedFormEntity entityParam = null;
try {
entityParam = new UrlEncodedFormEntity(list, "UTF-8");
post.setEntity(entityParam);
} catch (UnsupportedEncodingException e1) {
e1.printStackTrace();
}
try {
response = httpclient.execute(post);
HttpEntity entity = response.getEntity();
result = EntityUtils.toString(entity, "UTF-8");
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
response.close();
httpclient.close();
} catch (IOException e) {
e.printStackTrace();
}
}
System.out.println(result);
Gson gson = new Gson();
Map map = gson.fromJson(result, Map.class);
return map;
}
private void parse_content(Map map) {
//java.lang.ClassCastException: java.util.ArrayList cannot be cast to java.util.Map
ArrayList arrayList = (ArrayList)(map.get("rows"));
Map innerMap = (Map) arrayList.get(0);
String source = (String) innerMap.get("source");
String bodyhtml = (String) innerMap.get("body");
System.out.println("source: "+source);
System.out.println("bodyhtml:"+'\n'+bodyhtml);
}
public static void main(String[] args) {
TestNewContent test1 = new TestNewContent();
String urlStr = "http://news.cqcoal.com/manage/ ... 3B%3B
Map map = test1.getPageContByHttpCl(urlStr);
test1.parse_content(map);
}
}
运行截图：
httpclient 抓取网页(Java的Http协议客户端HttpClient来实现抓取网页数据(组图))
网站优化 • 优采云 发表了文章 • 0 个评论 • 89 次浏览 • 2022-02-28 21:08
httpclient 抓取网页(Java的Http协议客户端HttpClient来实现抓取网页数据(组图))
爬虫爬取网页上的数据和我们点击链接单独访问网页数据是一样的。就是使用Http协议访问网页。这里我们使用Java Http协议客户端HttpClient来实现网页数据的抓取。
你好世界
获取带参数的请求
使用参数发布请求
帖子也很简单，和上面差不多，只是改变发起请求的方式，如下：
当然，如果没有参数，就不需要创建表单对象，只要有一个HttpPost对象即可。
代码中的对象说明：
代码优化：连接池
在爬取数据的过程中，连接对象HttpClient的创建和销毁非常频繁，这里我们使用连接池对其进行优化
public class poolTest {
public static void main(String[] args) {
//创建连接池管理器
PoolingHttpClientConnectionManager pcm = new PoolingHttpClientConnectionManager();
pcm.setMaxTotal(100); //设置池内最大连接数
pcm.setDefaultMaxPerRoute(10); //设置每个坠机的最大连接数
//从连接池中获取连接对象，而不是单独创建连接对象
CloseableHttpClient httpClient = HttpClients.custom().setConnectionManager(pcm).build();
HttpGet httpGet = new HttpGet("https://www.cnblogs.com/msi-chen");
System.out.println(httpGet);
//使用httpClient发起请求，获得响应
CloseableHttpResponse response = null;
try {
response = httpClient.execute(httpGet);
//解析响应，获取到数据
if (response.getStatusLine().getStatusCode() == 200){
HttpEntity entity = response.getEntity();
String content = EntityUtils.toString(entity,"utf8");
System.out.println(content.length());
}
} catch (IOException e) {
e.printStackTrace();
}finally {
if (response != null){
try {
response.close();
} catch (IOException e) {
e.printStackTrace();
}
//因为我们是连接池中获取到的连接，所以这里不能再给他关闭了
//httpClient.close();
}
}
}
}
获取资源的相关时间配置
Jsoup 不是 Jsonp
经过我们上面的学习，我们已经可以通过HttpClient抓取页面了。抓取页面后，我们就可以解析了。我们可以使用字符串解析工具来解析页面，也可以使用正则表达式。解析，但是这两种方案的开发成本很高，不推荐使用。这里我们学习了一个解析html页面的技术，Jsonp
Jsoup简介
jsonp是一个Java Html解析器，可以自己解析一个url地址和html文本内容。它有一组现成的 API 来删除和操作数据。
jsonp的特点：
Jsoup解析网址
添加Jsoup的依赖以使用Jsoup
注意：Jsoup只限于使用Html解析工具，不能代替HttpClient发起请求，因为HttpClient支持多线程、连接池、代理等技术，而Jsoup对此的支持并不理想，专业的事情交给专业的人，HttpClient发送请求抓取数据，Jsoup做解析
Jsoup解析字符串
Jsoup解析文件
还是上面的静态页面，除了转成String后面再解析，我们也可以直接解析文件
使用 Dom 方法遍历文档
记得还有一个sax解析，比较麻烦，现在差点忘了；
dom解析，不知道大家有没有听说过或者用过。反正我以前用过，但是解析的确实是XML。让我简单介绍一个Dmo方法。
Dmo 解析会将目标文档视为对象。首先，将整个文档加载到内存中。如果文档太大，内存可能会溢出（一般不会）。加载到内存后，会构建一个Dom树，然后进行访问和修改操作
没学过的，我们通过一个小demo来了解一下。如果您使用过它，我们应该对其进行审查：
Java代码如下： 我已经演示了几个常用的获取页面数据的API
从元素中获取属性
选择器选择器
下面是上述always选择器的使用演示
选择器选择器组合使用
Hello World 级爬虫小箱子
在上面的学习中，我们已经知道HttpClient的作用是爬取数据，而Jsoup是解析HttpClient爬取的数据。让我们练习一下这两个工具的使用。
搁浅了一阵子，暂时……以后更新 查看全部
爬虫爬取网页上的数据和我们点击链接单独访问网页数据是一样的。就是使用Http协议访问网页。这里我们使用Java Http协议客户端HttpClient来实现网页数据的抓取。
你好世界
获取带参数的请求
使用参数发布请求
帖子也很简单，和上面差不多，只是改变发起请求的方式，如下：
当然，如果没有参数，就不需要创建表单对象，只要有一个HttpPost对象即可。
代码中的对象说明：
代码优化：连接池
在爬取数据的过程中，连接对象HttpClient的创建和销毁非常频繁，这里我们使用连接池对其进行优化
public class poolTest {
public static void main(String[] args) {
//创建连接池管理器
PoolingHttpClientConnectionManager pcm = new PoolingHttpClientConnectionManager();
pcm.setMaxTotal(100); //设置池内最大连接数
pcm.setDefaultMaxPerRoute(10); //设置每个坠机的最大连接数
//从连接池中获取连接对象，而不是单独创建连接对象
CloseableHttpClient httpClient = HttpClients.custom().setConnectionManager(pcm).build();
HttpGet httpGet = new HttpGet("https://www.cnblogs.com/msi-chen");
System.out.println(httpGet);
//使用httpClient发起请求，获得响应
CloseableHttpResponse response = null;
try {
response = httpClient.execute(httpGet);
//解析响应，获取到数据
if (response.getStatusLine().getStatusCode() == 200){
HttpEntity entity = response.getEntity();
String content = EntityUtils.toString(entity,"utf8");
System.out.println(content.length());
}
} catch (IOException e) {
e.printStackTrace();
}finally {
if (response != null){
try {
response.close();
} catch (IOException e) {
e.printStackTrace();
}
//因为我们是连接池中获取到的连接，所以这里不能再给他关闭了
//httpClient.close();
}
}
}
}
获取资源的相关时间配置
Jsoup 不是 Jsonp
经过我们上面的学习，我们已经可以通过HttpClient抓取页面了。抓取页面后，我们就可以解析了。我们可以使用字符串解析工具来解析页面，也可以使用正则表达式。解析，但是这两种方案的开发成本很高，不推荐使用。这里我们学习了一个解析html页面的技术，Jsonp
Jsoup简介
jsonp是一个Java Html解析器，可以自己解析一个url地址和html文本内容。它有一组现成的 API 来删除和操作数据。
jsonp的特点：
Jsoup解析网址
添加Jsoup的依赖以使用Jsoup
注意：Jsoup只限于使用Html解析工具，不能代替HttpClient发起请求，因为HttpClient支持多线程、连接池、代理等技术，而Jsoup对此的支持并不理想，专业的事情交给专业的人，HttpClient发送请求抓取数据，Jsoup做解析
Jsoup解析字符串
Jsoup解析文件
还是上面的静态页面，除了转成String后面再解析，我们也可以直接解析文件
使用 Dom 方法遍历文档
记得还有一个sax解析，比较麻烦，现在差点忘了；
dom解析，不知道大家有没有听说过或者用过。反正我以前用过，但是解析的确实是XML。让我简单介绍一个Dmo方法。
Dmo 解析会将目标文档视为对象。首先，将整个文档加载到内存中。如果文档太大，内存可能会溢出（一般不会）。加载到内存后，会构建一个Dom树，然后进行访问和修改操作
没学过的，我们通过一个小demo来了解一下。如果您使用过它，我们应该对其进行审查：
Java代码如下： 我已经演示了几个常用的获取页面数据的API
从元素中获取属性
选择器选择器
下面是上述always选择器的使用演示
选择器选择器组合使用
Hello World 级爬虫小箱子
在上面的学习中，我们已经知道HttpClient的作用是爬取数据，而Jsoup是解析HttpClient爬取的数据。让我们练习一下这两个工具的使用。
搁浅了一阵子，暂时……以后更新 查看全部
httpclient 抓取网页(Java的Http协议客户端HttpClient来实现抓取网页数据(组图))
爬虫爬取网页上的数据和我们点击链接单独访问网页数据是一样的。就是使用Http协议访问网页。这里我们使用Java Http协议客户端HttpClient来实现网页数据的抓取。
你好世界
获取带参数的请求
使用参数发布请求
帖子也很简单，和上面差不多，只是改变发起请求的方式，如下：
当然，如果没有参数，就不需要创建表单对象，只要有一个HttpPost对象即可。
代码中的对象说明：
代码优化：连接池
在爬取数据的过程中，连接对象HttpClient的创建和销毁非常频繁，这里我们使用连接池对其进行优化
public class poolTest {
public static void main(String[] args) {
//创建连接池管理器
PoolingHttpClientConnectionManager pcm = new PoolingHttpClientConnectionManager();
pcm.setMaxTotal(100); //设置池内最大连接数
pcm.setDefaultMaxPerRoute(10); //设置每个坠机的最大连接数
//从连接池中获取连接对象，而不是单独创建连接对象
CloseableHttpClient httpClient = HttpClients.custom().setConnectionManager(pcm).build();
HttpGet httpGet = new HttpGet("https://www.cnblogs.com/msi-chen";);
System.out.println(httpGet);
//使用httpClient发起请求，获得响应
CloseableHttpResponse response = null;
try {
response = httpClient.execute(httpGet);
//解析响应，获取到数据
if (response.getStatusLine().getStatusCode() == 200){
HttpEntity entity = response.getEntity();
String content = EntityUtils.toString(entity,"utf8");
System.out.println(content.length());
}
} catch (IOException e) {
e.printStackTrace();
}finally {
if (response != null){
try {
response.close();
} catch (IOException e) {
e.printStackTrace();
}
//因为我们是连接池中获取到的连接，所以这里不能再给他关闭了
//httpClient.close();
}
}
}
}
获取资源的相关时间配置
Jsoup 不是 Jsonp
经过我们上面的学习，我们已经可以通过HttpClient抓取页面了。抓取页面后，我们就可以解析了。我们可以使用字符串解析工具来解析页面，也可以使用正则表达式。解析，但是这两种方案的开发成本很高，不推荐使用。这里我们学习了一个解析html页面的技术，Jsonp
Jsoup简介
jsonp是一个Java Html解析器，可以自己解析一个url地址和html文本内容。它有一组现成的 API 来删除和操作数据。
jsonp的特点：
Jsoup解析网址
添加Jsoup的依赖以使用Jsoup
注意：Jsoup只限于使用Html解析工具，不能代替HttpClient发起请求，因为HttpClient支持多线程、连接池、代理等技术，而Jsoup对此的支持并不理想，专业的事情交给专业的人，HttpClient发送请求抓取数据，Jsoup做解析
Jsoup解析字符串
Jsoup解析文件
还是上面的静态页面，除了转成String后面再解析，我们也可以直接解析文件
使用 Dom 方法遍历文档
记得还有一个sax解析，比较麻烦，现在差点忘了；
dom解析，不知道大家有没有听说过或者用过。反正我以前用过，但是解析的确实是XML。让我简单介绍一个Dmo方法。
Dmo 解析会将目标文档视为对象。首先，将整个文档加载到内存中。如果文档太大，内存可能会溢出（一般不会）。加载到内存后，会构建一个Dom树，然后进行访问和修改操作
没学过的，我们通过一个小demo来了解一下。如果您使用过它，我们应该对其进行审查：
Java代码如下： 我已经演示了几个常用的获取页面数据的API
从元素中获取属性
选择器选择器
下面是上述always选择器的使用演示
选择器选择器组合使用
Hello World 级爬虫小箱子
在上面的学习中，我们已经知道HttpClient的作用是爬取数据，而Jsoup是解析HttpClient爬取的数据。让我们练习一下这两个工具的使用。
搁浅了一阵子，暂时……以后更新
httpclient 抓取网页(如何编写爬虫程序爬取网络上有价值的数据信息？)
网站优化 • 优采云 发表了文章 • 0 个评论 • 61 次浏览 • 2022-02-25 11:24
httpclient 抓取网页(如何编写爬虫程序爬取网络上有价值的数据信息？)
随着互联网+时代的到来，越来越多的互联网公司层出不穷，涉及游戏、视频、新闻、社交、电商、房地产、旅游等诸多行业。在互联网成为海量信息载体的今天，如何有效地从中提取有价值的信息并加以利用，成为了巨大的挑战。
爬虫这个可怕的怪物，从百度、谷歌等搜索引擎公司诞生以来就一直存在，如今在移动互联网时代，爬虫更是猖獗。每一个网站似乎都被它光顾过，但你看No，但你可以放心，它不会做坏事。您可以快速搜索在 Internet 上找到的信息。这应该是由于它的信用。每一天，都会不为人知采集网上丰富的资讯，供大家查询和分享。Java作为互联网开发的主流语言，在互联网领域得到了广泛的应用。本课程使用java技术讲解如何编写爬虫程序来爬取互联网上有价值的数据信息。
知识点1.爬虫介绍
当我们访问某个网页时，在地址栏中输入网址并回车，网站的服务器会返回一个HTML文件给我们，浏览器会解析返回的数据并显示在UI上。同样，爬虫程序也模仿人的操作。向网站发送请求，网站会返回一个HTML文件给爬虫程序，爬虫程序会对返回的数据进行爬取和分析。
1.1 爬虫简介
网络爬虫，也称为网络蜘蛛，是一种自动索引器，一种“自动浏览网页”的程序，或者是网络机器人。
爬虫广泛用于互联网搜索引擎或其他类似的网站s，以获取或更新这些网站s的内容和检索方式。他们可以自动采集他们可以访问的所有页面内容以供搜索引擎进一步处理（对下载的页面进行排序和排序），从而使用户可以更快地检索到他们需要的信息。
通俗的说，就是你手动打开窗口，输入数据等，换成程序。使用程序为你获取你想要的信息，这就是网络爬虫
1.2 爬虫应用1.2.1 搜索引擎
爬虫程序可以为搜索引擎系统抓取网络资源，用户可以通过搜索引擎搜索到网络上所有需要的资源。搜索引擎是一个非常庞大和复杂的算法系统，搜索的准确性和效率都对搜索系统提出了很高的要求。
1.2.2 数据挖掘
除了搜索，爬虫还可以做很多工作。可以说，爬虫现在广泛应用于互联网项目中。
互联网项目主要通过爬取相关数据进行数据分析，获取有价值的数据。那么爬虫就可以做那个分析了，下面可以简单的理解：
App下载量分析1.3爬虫原理1.3.1爬虫目的
一般来说，我们需要捕获的是一个网站或者一个应用程序的内容，提取有用的价值，进行数据分析。
1.3.2 爬虫框架设计
为了开发方便，项目中也可以使用爬虫框架来开发爬虫；一个通用网络爬虫的框架如图所示：
网络爬虫的基本工作流程如下：
首先选择一部分精心挑选的种子URL，将这些URL放入待爬取的URL队列中，从待爬取的URL队列中取出待爬取的URL，解析DNS，得到主机的ip，下载URL对应的网页，存储在下载的网页库中。另外，将这些URL放入已爬取URL队列，分析已爬取URL队列中的URL，分析其中的其他URL，将这些URL放入待爬取URL队列，从而进入下一个循环2. Java 爬虫框架2.1 Nutch
Nutch 是一个分布式爬虫。爬虫使用分布式，主要解决两个问题：1)海量URL管理；2) 网速。如果你想做一个搜索引擎，Nutch1.x 是一个非常不错的选择。Nutch1.x 和 solr 或 es 可以组成一个非常强大的搜索引擎，否则尽量不要选择 Nutch 作为爬虫。使用 Nutch 进行爬虫的二次开发，爬虫的编写和调试所需的时间往往是单机爬虫所需时间的十倍以上。
2.2 赫里特里克斯
Heritrix 是一个“档案爬虫”——获取您网站内容的完整、准确、深层副本。这包括获取图像和其他非文本内容。抓取并存储相关内容。内容不会被拒绝，页面内容也不会被修改。重新抓取相同的 URL 不会替换前一个。爬虫主要通过 Web 用户界面启动、监控和调整，允许灵活定义要获取的 url。
2.3 crawler4j
crawler4j 是一个用 Java 实现的开源网络爬虫。提供易于使用的界面，可在几分钟内创建多线程网络爬虫。
2.4 网络采集器
WebCollector 使用 Nutch 的爬虫逻辑（层次广度遍历），Crawler4j 的用户界面（重写访问方法，定义用户操作），以及一套自己的插件机制，设计了一套爬虫核心。
2.5 网络魔术
WebMagic 项目代码分为核心和扩展两部分。核心部分（webmagic-core）是一个精简的、模块化的爬虫实现，而扩展部分包括一些便利和实用的功能。WebMagic的架构设计参考了Scrapy，目标是尽可能模块化，并体现爬虫的功能特点。 查看全部
随着互联网+时代的到来，越来越多的互联网公司层出不穷，涉及游戏、视频、新闻、社交、电商、房地产、旅游等诸多行业。在互联网成为海量信息载体的今天，如何有效地从中提取有价值的信息并加以利用，成为了巨大的挑战。
爬虫这个可怕的怪物，从百度、谷歌等搜索引擎公司诞生以来就一直存在，如今在移动互联网时代，爬虫更是猖獗。每一个网站似乎都被它光顾过，但你看No，但你可以放心，它不会做坏事。您可以快速搜索在 Internet 上找到的信息。这应该是由于它的信用。每一天，都会不为人知采集网上丰富的资讯，供大家查询和分享。Java作为互联网开发的主流语言，在互联网领域得到了广泛的应用。本课程使用java技术讲解如何编写爬虫程序来爬取互联网上有价值的数据信息。
知识点1.爬虫介绍
当我们访问某个网页时，在地址栏中输入网址并回车，网站的服务器会返回一个HTML文件给我们，浏览器会解析返回的数据并显示在UI上。同样，爬虫程序也模仿人的操作。向网站发送请求，网站会返回一个HTML文件给爬虫程序，爬虫程序会对返回的数据进行爬取和分析。
1.1 爬虫简介
网络爬虫，也称为网络蜘蛛，是一种自动索引器，一种“自动浏览网页”的程序，或者是网络机器人。
爬虫广泛用于互联网搜索引擎或其他类似的网站s，以获取或更新这些网站s的内容和检索方式。他们可以自动采集他们可以访问的所有页面内容以供搜索引擎进一步处理（对下载的页面进行排序和排序），从而使用户可以更快地检索到他们需要的信息。
通俗的说，就是你手动打开窗口，输入数据等，换成程序。使用程序为你获取你想要的信息，这就是网络爬虫
1.2 爬虫应用1.2.1 搜索引擎
爬虫程序可以为搜索引擎系统抓取网络资源，用户可以通过搜索引擎搜索到网络上所有需要的资源。搜索引擎是一个非常庞大和复杂的算法系统，搜索的准确性和效率都对搜索系统提出了很高的要求。
1.2.2 数据挖掘
除了搜索，爬虫还可以做很多工作。可以说，爬虫现在广泛应用于互联网项目中。
互联网项目主要通过爬取相关数据进行数据分析，获取有价值的数据。那么爬虫就可以做那个分析了，下面可以简单的理解：
App下载量分析1.3爬虫原理1.3.1爬虫目的
一般来说，我们需要捕获的是一个网站或者一个应用程序的内容，提取有用的价值，进行数据分析。
1.3.2 爬虫框架设计
为了开发方便，项目中也可以使用爬虫框架来开发爬虫；一个通用网络爬虫的框架如图所示：
网络爬虫的基本工作流程如下：
首先选择一部分精心挑选的种子URL，将这些URL放入待爬取的URL队列中，从待爬取的URL队列中取出待爬取的URL，解析DNS，得到主机的ip，下载URL对应的网页，存储在下载的网页库中。另外，将这些URL放入已爬取URL队列，分析已爬取URL队列中的URL，分析其中的其他URL，将这些URL放入待爬取URL队列，从而进入下一个循环2. Java 爬虫框架2.1 Nutch
Nutch 是一个分布式爬虫。爬虫使用分布式，主要解决两个问题：1)海量URL管理；2) 网速。如果你想做一个搜索引擎，Nutch1.x 是一个非常不错的选择。Nutch1.x 和 solr 或 es 可以组成一个非常强大的搜索引擎，否则尽量不要选择 Nutch 作为爬虫。使用 Nutch 进行爬虫的二次开发，爬虫的编写和调试所需的时间往往是单机爬虫所需时间的十倍以上。
2.2 赫里特里克斯
Heritrix 是一个“档案爬虫”——获取您网站内容的完整、准确、深层副本。这包括获取图像和其他非文本内容。抓取并存储相关内容。内容不会被拒绝，页面内容也不会被修改。重新抓取相同的 URL 不会替换前一个。爬虫主要通过 Web 用户界面启动、监控和调整，允许灵活定义要获取的 url。
2.3 crawler4j
crawler4j 是一个用 Java 实现的开源网络爬虫。提供易于使用的界面，可在几分钟内创建多线程网络爬虫。
2.4 网络采集器
WebCollector 使用 Nutch 的爬虫逻辑（层次广度遍历），Crawler4j 的用户界面（重写访问方法，定义用户操作），以及一套自己的插件机制，设计了一套爬虫核心。
2.5 网络魔术
WebMagic 项目代码分为核心和扩展两部分。核心部分（webmagic-core）是一个精简的、模块化的爬虫实现，而扩展部分包括一些便利和实用的功能。WebMagic的架构设计参考了Scrapy，目标是尽可能模块化，并体现爬虫的功能特点。 查看全部
httpclient 抓取网页(如何编写爬虫程序爬取网络上有价值的数据信息？)
随着互联网+时代的到来，越来越多的互联网公司层出不穷，涉及游戏、视频、新闻、社交、电商、房地产、旅游等诸多行业。在互联网成为海量信息载体的今天，如何有效地从中提取有价值的信息并加以利用，成为了巨大的挑战。
爬虫这个可怕的怪物，从百度、谷歌等搜索引擎公司诞生以来就一直存在，如今在移动互联网时代，爬虫更是猖獗。每一个网站似乎都被它光顾过，但你看No，但你可以放心，它不会做坏事。您可以快速搜索在 Internet 上找到的信息。这应该是由于它的信用。每一天，都会不为人知采集网上丰富的资讯，供大家查询和分享。Java作为互联网开发的主流语言，在互联网领域得到了广泛的应用。本课程使用java技术讲解如何编写爬虫程序来爬取互联网上有价值的数据信息。
知识点1.爬虫介绍
当我们访问某个网页时，在地址栏中输入网址并回车，网站的服务器会返回一个HTML文件给我们，浏览器会解析返回的数据并显示在UI上。同样，爬虫程序也模仿人的操作。向网站发送请求，网站会返回一个HTML文件给爬虫程序，爬虫程序会对返回的数据进行爬取和分析。
1.1 爬虫简介
网络爬虫，也称为网络蜘蛛，是一种自动索引器，一种“自动浏览网页”的程序，或者是网络机器人。
爬虫广泛用于互联网搜索引擎或其他类似的网站s，以获取或更新这些网站s的内容和检索方式。他们可以自动采集他们可以访问的所有页面内容以供搜索引擎进一步处理（对下载的页面进行排序和排序），从而使用户可以更快地检索到他们需要的信息。
通俗的说，就是你手动打开窗口，输入数据等，换成程序。使用程序为你获取你想要的信息，这就是网络爬虫
1.2 爬虫应用1.2.1 搜索引擎
爬虫程序可以为搜索引擎系统抓取网络资源，用户可以通过搜索引擎搜索到网络上所有需要的资源。搜索引擎是一个非常庞大和复杂的算法系统，搜索的准确性和效率都对搜索系统提出了很高的要求。
1.2.2 数据挖掘
除了搜索，爬虫还可以做很多工作。可以说，爬虫现在广泛应用于互联网项目中。
互联网项目主要通过爬取相关数据进行数据分析，获取有价值的数据。那么爬虫就可以做那个分析了，下面可以简单的理解：
App下载量分析1.3爬虫原理1.3.1爬虫目的
一般来说，我们需要捕获的是一个网站或者一个应用程序的内容，提取有用的价值，进行数据分析。
1.3.2 爬虫框架设计
为了开发方便，项目中也可以使用爬虫框架来开发爬虫；一个通用网络爬虫的框架如图所示：
网络爬虫的基本工作流程如下：
首先选择一部分精心挑选的种子URL，将这些URL放入待爬取的URL队列中，从待爬取的URL队列中取出待爬取的URL，解析DNS，得到主机的ip，下载URL对应的网页，存储在下载的网页库中。另外，将这些URL放入已爬取URL队列，分析已爬取URL队列中的URL，分析其中的其他URL，将这些URL放入待爬取URL队列，从而进入下一个循环2. Java 爬虫框架2.1 Nutch
Nutch 是一个分布式爬虫。爬虫使用分布式，主要解决两个问题：1)海量URL管理；2) 网速。如果你想做一个搜索引擎，Nutch1.x 是一个非常不错的选择。Nutch1.x 和 solr 或 es 可以组成一个非常强大的搜索引擎，否则尽量不要选择 Nutch 作为爬虫。使用 Nutch 进行爬虫的二次开发，爬虫的编写和调试所需的时间往往是单机爬虫所需时间的十倍以上。
2.2 赫里特里克斯
Heritrix 是一个“档案爬虫”——获取您网站内容的完整、准确、深层副本。这包括获取图像和其他非文本内容。抓取并存储相关内容。内容不会被拒绝，页面内容也不会被修改。重新抓取相同的 URL 不会替换前一个。爬虫主要通过 Web 用户界面启动、监控和调整，允许灵活定义要获取的 url。
2.3 crawler4j
crawler4j 是一个用 Java 实现的开源网络爬虫。提供易于使用的界面，可在几分钟内创建多线程网络爬虫。
2.4 网络采集器
WebCollector 使用 Nutch 的爬虫逻辑（层次广度遍历），Crawler4j 的用户界面（重写访问方法，定义用户操作），以及一套自己的插件机制，设计了一套爬虫核心。
2.5 网络魔术
WebMagic 项目代码分为核心和扩展两部分。核心部分（webmagic-core）是一个精简的、模块化的爬虫实现，而扩展部分包括一些便利和实用的功能。WebMagic的架构设计参考了Scrapy，目标是尽可能模块化，并体现爬虫的功能特点。
httpclient 抓取网页(Python爬虫系列三“模拟登录”的方法需要抓取数据包分析)
网站优化 • 优采云 发表了文章 • 0 个评论 • 64 次浏览 • 2022-02-19 18:13
httpclient 抓取网页(Python爬虫系列三“模拟登录”的方法需要抓取数据包分析)
3.对http协议有基本的了解，比如http 200、301、302、400、404、500的返回码是什么意思（这个是最基本的），还有cookie和session机制（这个会在后续的Python爬虫系列三“模拟登录”中介绍“方法需要抓包分析，主要看cookies这些东西，学习分析数据包）
4.httpclient的重定向状态默认是自动的，这在很大程度上对开发者来说是非常方便的（比如一些授权的cookies），但是有时候需要手动设置。对于 CircularRedictException 异常，这是因为返回的头文件中的位置值指向了之前的重复地址（端口号可以不同），这可能会导致无限循环递归重定向。这时候可以手动关闭：method.setFollowRedirects(false)。
5.模拟浏览器登录，对于爬虫来说非常重要。有的网站会先判断用户的请求是否来自浏览器。如果不是直接拒绝访问，这是直接伪装成浏览器访问嘛，很容易用httpclient在header中添加一些信息： header.put("User-Agent", "Mozilla/5.0 (Windows NT 6.1)AppleWebKit /537.36 (KHTML, 像 Gecko) Chrome/37.0.2062.124 Safari/ 537.36)”);
6.post请求提交数据时，要更改默认编码，否则提交的数据会乱码。只需重写 postMethod 的 setContentCharSet() 方法即可。
事实上，任何网页的数据都是由请求-响应组成的。谷歌或者火狐打开F12选择网络，点击更多按钮，就可以得到他访问的连接，后面可以通过普通的httpclient或者jsoup获取。响应的内容就是现在，我个人感觉很有可能是这样返回json的
您可以使用 document.getElementById 函数，例如： var obj = document.getElementById("text1")
js一般使用ajax获取列表，可以在ajax中找到GET地址或者POST地址来获取分页内容。
如何抓取HTML页面数据-：使用ForeSpider数据采集系统。ForeSpider数据采集系统具有全面的采集范围，数据准确，抓取性能优秀，可视化操作简单，智能自动化采集，让企业以极少的人力成本，快速获取互联网上的结构化或非结构化数据。软件...
如何抓取获取到的html网页内容：在ie或者chrome浏览器中，f12可以打开开发者工具，找到网络，启动网络请求抓取，触发post请求，然后就可以看到发送和返回的内容了
如何抓取网页文字 - 如何使用网页文字刮板抓取文字：网页文字刮板是一款小型网页文字抓取工具，可让您轻松抓取和复制网页上禁止选择和复制的文字。对于页面上的内容，被大面积看不见的广告所覆盖。抓取网页文本抓取器并查看它也是一个很好的解决方案。此外，网页文本抓取器还可以抓取页面中 HTML 标签的路径，帮助理解 HTML 文档的结构。注册后即可轻松使用，功能非常简单方便。
如何将html代码粘贴到html页面？：复制到记事本，保存为.html，用浏览器打开。
如何抓取HTML页面中的一条数据，具体html如下-：直接使用爬虫即可，如优采云采集器或优采云浏览器
获取html标签h1的内容：我都是用JQuery写的1)如何获取值：$("#hn").text();2)如何获取值：$(".hn ").text();3)你好，如果只有一个标签，还需要获取第一个标签的内容，取值方式： $("h1")[0] 。文本（）;
如何抓取网页结构的html代码——：先知道html的网址，在浏览器中打开，保存为网页，保存类型，全部，或者使用html扒手工具，或者如果知道回来-end编程，可以自己写一个将html代码保存到本地文件的方法
如何抓取html页面并使用httpclient——：其实任何网页的数据都是由request-response组成的，谷歌或者火狐打开F12选择网络，点击更多按钮，就可以得到他访问的连接，和那么不管是普通的httpclient还是jsoup都能拿到响应内容，个人感觉这样返回json是很有可能的
C语言提取html标签内容-: #include #include void fetch_str(char *str_in, char *str_out);int main(){char test[] = "This is the string";char result[256];fetch_str( test , result);printf("\ntest\t=%s\n", test);printf("\nresult\t=%s\n",result);return 1;}void ...
如何抓取网页的 html 和 css - : 将网页另存为
相关视频：Python-MongoDB数据库-MongoDB数据库操作(上) Python-MongoDB数据库-MongoDB数据库操作(下) Python-爬虫进阶-Scrapy-Redis分布式-scrapy-redis简介 Python-爬虫进阶-Scrapy框架进阶-豆瓣阅读-Selenium中间件 Python-爬虫进阶-Scrapy框架初一-毒网（上） Python-多线程爬虫-多线程创建的两种方式 Python-爬虫与数据-为什么要爬虫 Python-爬虫进阶-Scrapy框架初级-虎扑新闻-scrapyPython-爬虫进阶-Scrapy-Redis分布式-Redis配置Python-爬虫进阶-Scrapy框架进阶-百度翻译 查看全部
3.对http协议有基本的了解，比如http 200、301、302、400、404、500的返回码是什么意思（这个是最基本的），还有cookie和session机制（这个会在后续的Python爬虫系列三“模拟登录”中介绍“方法需要抓包分析，主要看cookies这些东西，学习分析数据包）
4.httpclient的重定向状态默认是自动的，这在很大程度上对开发者来说是非常方便的（比如一些授权的cookies），但是有时候需要手动设置。对于 CircularRedictException 异常，这是因为返回的头文件中的位置值指向了之前的重复地址（端口号可以不同），这可能会导致无限循环递归重定向。这时候可以手动关闭：method.setFollowRedirects(false)。
5.模拟浏览器登录，对于爬虫来说非常重要。有的网站会先判断用户的请求是否来自浏览器。如果不是直接拒绝访问，这是直接伪装成浏览器访问嘛，很容易用httpclient在header中添加一些信息： header.put("User-Agent", "Mozilla/5.0 (Windows NT 6.1)AppleWebKit /537.36 (KHTML, 像 Gecko) Chrome/37.0.2062.124 Safari/ 537.36)”);
6.post请求提交数据时，要更改默认编码，否则提交的数据会乱码。只需重写 postMethod 的 setContentCharSet() 方法即可。
事实上，任何网页的数据都是由请求-响应组成的。谷歌或者火狐打开F12选择网络，点击更多按钮，就可以得到他访问的连接，后面可以通过普通的httpclient或者jsoup获取。响应的内容就是现在，我个人感觉很有可能是这样返回json的
您可以使用 document.getElementById 函数，例如： var obj = document.getElementById("text1")
js一般使用ajax获取列表，可以在ajax中找到GET地址或者POST地址来获取分页内容。
如何抓取HTML页面数据-：使用ForeSpider数据采集系统。ForeSpider数据采集系统具有全面的采集范围，数据准确，抓取性能优秀，可视化操作简单，智能自动化采集，让企业以极少的人力成本，快速获取互联网上的结构化或非结构化数据。软件...
如何抓取获取到的html网页内容：在ie或者chrome浏览器中，f12可以打开开发者工具，找到网络，启动网络请求抓取，触发post请求，然后就可以看到发送和返回的内容了
如何抓取网页文字 - 如何使用网页文字刮板抓取文字：网页文字刮板是一款小型网页文字抓取工具，可让您轻松抓取和复制网页上禁止选择和复制的文字。对于页面上的内容，被大面积看不见的广告所覆盖。抓取网页文本抓取器并查看它也是一个很好的解决方案。此外，网页文本抓取器还可以抓取页面中 HTML 标签的路径，帮助理解 HTML 文档的结构。注册后即可轻松使用，功能非常简单方便。
如何将html代码粘贴到html页面？：复制到记事本，保存为.html，用浏览器打开。
如何抓取HTML页面中的一条数据，具体html如下-：直接使用爬虫即可，如优采云采集器或优采云浏览器
获取html标签h1的内容：我都是用JQuery写的1)如何获取值：$("#hn").text();2)如何获取值：$(".hn ").text();3)你好，如果只有一个标签，还需要获取第一个标签的内容，取值方式： $("h1")[0] 。文本（）;
如何抓取网页结构的html代码——：先知道html的网址，在浏览器中打开，保存为网页，保存类型，全部，或者使用html扒手工具，或者如果知道回来-end编程，可以自己写一个将html代码保存到本地文件的方法
如何抓取html页面并使用httpclient——：其实任何网页的数据都是由request-response组成的，谷歌或者火狐打开F12选择网络，点击更多按钮，就可以得到他访问的连接，和那么不管是普通的httpclient还是jsoup都能拿到响应内容，个人感觉这样返回json是很有可能的
C语言提取html标签内容-: #include #include void fetch_str(char *str_in, char *str_out);int main(){char test[] = "This is the string";char result[256];fetch_str( test , result);printf("\ntest\t=%s\n", test);printf("\nresult\t=%s\n",result);return 1;}void ...
如何抓取网页的 html 和 css - : 将网页另存为
相关视频：Python-MongoDB数据库-MongoDB数据库操作(上) Python-MongoDB数据库-MongoDB数据库操作(下) Python-爬虫进阶-Scrapy-Redis分布式-scrapy-redis简介 Python-爬虫进阶-Scrapy框架进阶-豆瓣阅读-Selenium中间件 Python-爬虫进阶-Scrapy框架初一-毒网（上） Python-多线程爬虫-多线程创建的两种方式 Python-爬虫与数据-为什么要爬虫 Python-爬虫进阶-Scrapy框架初级-虎扑新闻-scrapyPython-爬虫进阶-Scrapy-Redis分布式-Redis配置Python-爬虫进阶-Scrapy框架进阶-百度翻译 查看全部
httpclient 抓取网页(Python爬虫系列三“模拟登录”的方法需要抓取数据包分析)
3.对http协议有基本的了解，比如http 200、301、302、400、404、500的返回码是什么意思（这个是最基本的），还有cookie和session机制（这个会在后续的Python爬虫系列三“模拟登录”中介绍“方法需要抓包分析，主要看cookies这些东西，学习分析数据包）
4.httpclient的重定向状态默认是自动的，这在很大程度上对开发者来说是非常方便的（比如一些授权的cookies），但是有时候需要手动设置。对于 CircularRedictException 异常，这是因为返回的头文件中的位置值指向了之前的重复地址（端口号可以不同），这可能会导致无限循环递归重定向。这时候可以手动关闭：method.setFollowRedirects(false)。
5.模拟浏览器登录，对于爬虫来说非常重要。有的网站会先判断用户的请求是否来自浏览器。如果不是直接拒绝访问，这是直接伪装成浏览器访问嘛，很容易用httpclient在header中添加一些信息： header.put("User-Agent", "Mozilla/5.0 (Windows NT 6.1)AppleWebKit /537.36 (KHTML, 像 Gecko) Chrome/37.0.2062.124 Safari/ 537.36)”);
6.post请求提交数据时，要更改默认编码，否则提交的数据会乱码。只需重写 postMethod 的 setContentCharSet() 方法即可。
事实上，任何网页的数据都是由请求-响应组成的。谷歌或者火狐打开F12选择网络，点击更多按钮，就可以得到他访问的连接，后面可以通过普通的httpclient或者jsoup获取。响应的内容就是现在，我个人感觉很有可能是这样返回json的
您可以使用 document.getElementById 函数，例如： var obj = document.getElementById("text1")
js一般使用ajax获取列表，可以在ajax中找到GET地址或者POST地址来获取分页内容。
如何抓取HTML页面数据-：使用ForeSpider数据采集系统。ForeSpider数据采集系统具有全面的采集范围，数据准确，抓取性能优秀，可视化操作简单，智能自动化采集，让企业以极少的人力成本，快速获取互联网上的结构化或非结构化数据。软件...
如何抓取获取到的html网页内容：在ie或者chrome浏览器中，f12可以打开开发者工具，找到网络，启动网络请求抓取，触发post请求，然后就可以看到发送和返回的内容了
如何抓取网页文字 - 如何使用网页文字刮板抓取文字：网页文字刮板是一款小型网页文字抓取工具，可让您轻松抓取和复制网页上禁止选择和复制的文字。对于页面上的内容，被大面积看不见的广告所覆盖。抓取网页文本抓取器并查看它也是一个很好的解决方案。此外，网页文本抓取器还可以抓取页面中 HTML 标签的路径，帮助理解 HTML 文档的结构。注册后即可轻松使用，功能非常简单方便。
如何将html代码粘贴到html页面？：复制到记事本，保存为.html，用浏览器打开。
如何抓取HTML页面中的一条数据，具体html如下-：直接使用爬虫即可，如优采云采集器或优采云浏览器
获取html标签h1的内容：我都是用JQuery写的1)如何获取值：$("#hn").text();2)如何获取值：$(".hn ").text();3)你好，如果只有一个标签，还需要获取第一个标签的内容，取值方式： $("h1")[0] 。文本（）;
如何抓取网页结构的html代码——：先知道html的网址，在浏览器中打开，保存为网页，保存类型，全部，或者使用html扒手工具，或者如果知道回来-end编程，可以自己写一个将html代码保存到本地文件的方法
如何抓取html页面并使用httpclient——：其实任何网页的数据都是由request-response组成的，谷歌或者火狐打开F12选择网络，点击更多按钮，就可以得到他访问的连接，和那么不管是普通的httpclient还是jsoup都能拿到响应内容，个人感觉这样返回json是很有可能的
C语言提取html标签内容-: #include #include void fetch_str(char *str_in, char *str_out);int main(){char test[] = "This is the string";char result[256];fetch_str( test , result);printf("\ntest\t=%s\n", test);printf("\nresult\t=%s\n",result);return 1;}void ...
如何抓取网页的 html 和 css - : 将网页另存为
相关视频：Python-MongoDB数据库-MongoDB数据库操作(上) Python-MongoDB数据库-MongoDB数据库操作(下) Python-爬虫进阶-Scrapy-Redis分布式-scrapy-redis简介 Python-爬虫进阶-Scrapy框架进阶-豆瓣阅读-Selenium中间件 Python-爬虫进阶-Scrapy框架初一-毒网（上） Python-多线程爬虫-多线程创建的两种方式 Python-爬虫与数据-为什么要爬虫 Python-爬虫进阶-Scrapy框架初级-虎扑新闻-scrapyPython-爬虫进阶-Scrapy-Redis分布式-Redis配置Python-爬虫进阶-Scrapy框架进阶-百度翻译
httpclient 抓取网页(() )
网站优化 • 优采云 发表了文章 • 0 个评论 • 85 次浏览 • 2022-02-08 18:14
httpclient 抓取网页(()
)
1、GET 方法
第一步是创建一个客户端，类似于使用浏览器打开网页的方式
HttpClient httpClient = new HttpClient();
第二步，创建GET方法，获取需要抓取的网页的URL
GetMethod getMethod = new GetMethod("");
第三步，获取URL的响应状态码，200表示请求成功
int statusCode = httpClient.executeMethod(getMethod);
第四步，获取网页源代码
byte[] responseBody = getMethod.getResponseBody();
主要是这四个步骤，当然还有很多其他的，比如网页编码问题
2、Post方式
1 HttpClient httpClient = new HttpClient();
2 PostMethod postMethod = new PostMethod(UrlPath);
3 postMethod.getParams().setParameter(HttpMethodParams.RETRY_HANDLER,new DefaultHttpMethodRetryHandler());
4 NameValuePair[] postData = new NameValuePair[2];
5 postData[0] = new NameValuePair("username", "xkey");
6 postData[1] = new NameValuePair("userpass", "********");
7 postMethod.setRequestBody(postData);
8 try {
9 int statusCode = httpClient.executeMethod(postMethod);
10 if (statusCode == HttpStatus.SC_OK) {
11 byte[] responseBody = postMethod.getResponseBody();
12 String html = new String(responseBody);
13 System.out.println(html);
14 }
15 } catch (Exception e) {
16 System.err.println("页面无法访问");
17 }finally{
18 postMethod.releaseConnection();
19 }
相关链接：http://blog.csdn.net/acceptedx ... 30700
http://www.cnblogs.com/modou/articles/1325569.html
查看全部
)
1、GET 方法
第一步是创建一个客户端，类似于使用浏览器打开网页的方式
HttpClient httpClient = new HttpClient();
第二步，创建GET方法，获取需要抓取的网页的URL
GetMethod getMethod = new GetMethod("");
第三步，获取URL的响应状态码，200表示请求成功
int statusCode = httpClient.executeMethod(getMethod);
第四步，获取网页源代码
byte[] responseBody = getMethod.getResponseBody();
主要是这四个步骤，当然还有很多其他的，比如网页编码问题
2、Post方式
1 HttpClient httpClient = new HttpClient();
2 PostMethod postMethod = new PostMethod(UrlPath);
3 postMethod.getParams().setParameter(HttpMethodParams.RETRY_HANDLER,new DefaultHttpMethodRetryHandler());
4 NameValuePair[] postData = new NameValuePair[2];
5 postData[0] = new NameValuePair("username", "xkey");
6 postData[1] = new NameValuePair("userpass", "********");
7 postMethod.setRequestBody(postData);
8 try {
9 int statusCode = httpClient.executeMethod(postMethod);
10 if (statusCode == HttpStatus.SC_OK) {
11 byte[] responseBody = postMethod.getResponseBody();
12 String html = new String(responseBody);
13 System.out.println(html);
14 }
15 } catch (Exception e) {
16 System.err.println("页面无法访问");
17 }finally{
18 postMethod.releaseConnection();
19 }
相关链接：http://blog.csdn.net/acceptedx ... 30700
http://www.cnblogs.com/modou/articles/1325569.html
查看全部
httpclient 抓取网页(()
)
1、GET 方法
第一步是创建一个客户端，类似于使用浏览器打开网页的方式
HttpClient httpClient = new HttpClient();
第二步，创建GET方法，获取需要抓取的网页的URL
GetMethod getMethod = new GetMethod("");
第三步，获取URL的响应状态码，200表示请求成功
int statusCode = httpClient.executeMethod(getMethod);
第四步，获取网页源代码
byte[] responseBody = getMethod.getResponseBody();
主要是这四个步骤，当然还有很多其他的，比如网页编码问题
2、Post方式
1 HttpClient httpClient = new HttpClient();
2 PostMethod postMethod = new PostMethod(UrlPath);
3 postMethod.getParams().setParameter(HttpMethodParams.RETRY_HANDLER,new DefaultHttpMethodRetryHandler());
4 NameValuePair[] postData = new NameValuePair[2];
5 postData[0] = new NameValuePair("username", "xkey");
6 postData[1] = new NameValuePair("userpass", "********");
7 postMethod.setRequestBody(postData);
8 try {
9 int statusCode = httpClient.executeMethod(postMethod);
10 if (statusCode == HttpStatus.SC_OK) {
11 byte[] responseBody = postMethod.getResponseBody();
12 String html = new String(responseBody);
13 System.out.println(html);
14 }
15 } catch (Exception e) {
16 System.err.println("页面无法访问");
17 }finally{
18 postMethod.releaseConnection();
19 }
相关链接：http://blog.csdn.net/acceptedx ... 30700
http://www.cnblogs.com/modou/articles/1325569.html
httpclient 抓取网页(一个基于JAVA的知乎爬虫抓取90W+用户信息（基本上4.5） )
网站优化 • 优采云 发表了文章 • 0 个评论 • 73 次浏览 • 2021-12-31 17:28
httpclient 抓取网页(一个基于JAVA的知乎爬虫抓取90W+用户信息（基本上4.5）
)
本文示例分享了一个基于JAVA的知乎爬虫，抓取知乎基本用户信息，基于HttpClient4.5，供大家参考，具体内容如下
详情：
抓取90W+用户信息（基本上活跃用户都在里面）
总体思路：
1.先模拟登录知乎，登录成功后cookie会序列化到磁盘，不需要每次都登录（如果不模拟登录，您可以直接从浏览器插入cookie。).
2. 创建两个线程池和一个 Storage。一个网页爬取线程池负责执行请求请求，返回网页内容，并存储在Storage中。另一种是解析网页线程池，负责从Storage中取出网页内容并分析，分析用户信息并存入数据库，解析用户关注的人的主页，并添加地址请求到网页抓取线程池。继续循环。
3. 关于url去重，我直接对访问过的链接进行md5保存到数据库中。每次访问前，检查数据库中是否存在该链接。
目前已抓到100W用户，访问220W+链接。现在爬取的用户是一些不太活跃的用户。比较活跃的用户应该基本完成了。
项目地址：
实现代码：
作者：卧颜沉默
链接：https://www.zhihu.com/question ... 43000
来源：知乎
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
/**
*
* @param httpClient Http客户端
* @param context Http上下文
* @return
*/
public boolean login(CloseableHttpClient httpClient, HttpClientContext context){
String yzm = null;
String loginState = null;
HttpGet getRequest = new HttpGet("https://www.zhihu.com/#signin");
HttpClientUtil.getWebPage(httpClient,context, getRequest, "utf-8", false);
HttpPost request = new HttpPost("https://www.zhihu.com/login/email");
List formParams = new ArrayList();
yzm = yzm(httpClient, context,"https://www.zhihu.com/captcha.gif?type=login");//肉眼识别验证码
formParams.add(new BasicNameValuePair("captcha", yzm));
formParams.add(new BasicNameValuePair("_xsrf", ""));//这个参数可以不用
formParams.add(new BasicNameValuePair("email", "邮箱"));
formParams.add(new BasicNameValuePair("password", "密码"));
formParams.add(new BasicNameValuePair("remember_me", "true"));
UrlEncodedFormEntity entity = null;
try {
entity = new UrlEncodedFormEntity(formParams, "utf-8");
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
}
request.setEntity(entity);
loginState = HttpClientUtil.getWebPage(httpClient,context, request, "utf-8", false);//登录
JSONObject jo = new JSONObject(loginState);
if(jo.get("r").toString().equals("0")){
System.out.println("登录成功");
getRequest = new HttpGet("https://www.zhihu.com");
HttpClientUtil.getWebPage(httpClient,context ,getRequest, "utf-8", false);//访问首页
HttpClientUtil.serializeObject(context.getCookieStore(),"resources/zhihucookies");//序列化知乎Cookies，下次登录直接通过该cookies登录
return true;
}else{
System.out.println("登录失败" + loginState);
return false;
}
}
/**
* 肉眼识别验证码
* @param httpClient Http客户端
* @param context Http上下文
* @param url 验证码地址
* @return
*/
public String yzm(CloseableHttpClient httpClient,HttpClientContext context, String url){
HttpClientUtil.downloadFile(httpClient, context, url, "d:/test/", "1.gif",true);
Scanner sc = new Scanner(System.in);
String yzm = sc.nextLine();
return yzm;
}
效果图：
查看全部
)
本文示例分享了一个基于JAVA的知乎爬虫，抓取知乎基本用户信息，基于HttpClient4.5，供大家参考，具体内容如下
详情：
抓取90W+用户信息（基本上活跃用户都在里面）
总体思路：
1.先模拟登录知乎，登录成功后cookie会序列化到磁盘，不需要每次都登录（如果不模拟登录，您可以直接从浏览器插入cookie。).
2. 创建两个线程池和一个 Storage。一个网页爬取线程池负责执行请求请求，返回网页内容，并存储在Storage中。另一种是解析网页线程池，负责从Storage中取出网页内容并分析，分析用户信息并存入数据库，解析用户关注的人的主页，并添加地址请求到网页抓取线程池。继续循环。
3. 关于url去重，我直接对访问过的链接进行md5保存到数据库中。每次访问前，检查数据库中是否存在该链接。
目前已抓到100W用户，访问220W+链接。现在爬取的用户是一些不太活跃的用户。比较活跃的用户应该基本完成了。
项目地址：
实现代码：
作者：卧颜沉默
链接：https://www.zhihu.com/question ... 43000
来源：知乎
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
/**
*
* @param httpClient Http客户端
* @param context Http上下文
* @return
*/
public boolean login(CloseableHttpClient httpClient, HttpClientContext context){
String yzm = null;
String loginState = null;
HttpGet getRequest = new HttpGet("https://www.zhihu.com/#signin");
HttpClientUtil.getWebPage(httpClient,context, getRequest, "utf-8", false);
HttpPost request = new HttpPost("https://www.zhihu.com/login/email");
List formParams = new ArrayList();
yzm = yzm(httpClient, context,"https://www.zhihu.com/captcha.gif?type=login");//肉眼识别验证码
formParams.add(new BasicNameValuePair("captcha", yzm));
formParams.add(new BasicNameValuePair("_xsrf", ""));//这个参数可以不用
formParams.add(new BasicNameValuePair("email", "邮箱"));
formParams.add(new BasicNameValuePair("password", "密码"));
formParams.add(new BasicNameValuePair("remember_me", "true"));
UrlEncodedFormEntity entity = null;
try {
entity = new UrlEncodedFormEntity(formParams, "utf-8");
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
}
request.setEntity(entity);
loginState = HttpClientUtil.getWebPage(httpClient,context, request, "utf-8", false);//登录
JSONObject jo = new JSONObject(loginState);
if(jo.get("r").toString().equals("0")){
System.out.println("登录成功");
getRequest = new HttpGet("https://www.zhihu.com");
HttpClientUtil.getWebPage(httpClient,context ,getRequest, "utf-8", false);//访问首页
HttpClientUtil.serializeObject(context.getCookieStore(),"resources/zhihucookies");//序列化知乎Cookies，下次登录直接通过该cookies登录
return true;
}else{
System.out.println("登录失败" + loginState);
return false;
}
}
/**
* 肉眼识别验证码
* @param httpClient Http客户端
* @param context Http上下文
* @param url 验证码地址
* @return
*/
public String yzm(CloseableHttpClient httpClient,HttpClientContext context, String url){
HttpClientUtil.downloadFile(httpClient, context, url, "d:/test/", "1.gif",true);
Scanner sc = new Scanner(System.in);
String yzm = sc.nextLine();
return yzm;
}
效果图：
查看全部
httpclient 抓取网页(一个基于JAVA的知乎爬虫抓取90W+用户信息（基本上4.5）
)
本文示例分享了一个基于JAVA的知乎爬虫，抓取知乎基本用户信息，基于HttpClient4.5，供大家参考，具体内容如下
详情：
抓取90W+用户信息（基本上活跃用户都在里面）
总体思路：
1.先模拟登录知乎，登录成功后cookie会序列化到磁盘，不需要每次都登录（如果不模拟登录，您可以直接从浏览器插入cookie。).
2. 创建两个线程池和一个 Storage。一个网页爬取线程池负责执行请求请求，返回网页内容，并存储在Storage中。另一种是解析网页线程池，负责从Storage中取出网页内容并分析，分析用户信息并存入数据库，解析用户关注的人的主页，并添加地址请求到网页抓取线程池。继续循环。
3. 关于url去重，我直接对访问过的链接进行md5保存到数据库中。每次访问前，检查数据库中是否存在该链接。
目前已抓到100W用户，访问220W+链接。现在爬取的用户是一些不太活跃的用户。比较活跃的用户应该基本完成了。
项目地址：
实现代码：
作者：卧颜沉默
链接：https://www.zhihu.com/question ... 43000
来源：知乎
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
/**
*
* @param httpClient Http客户端
* @param context Http上下文
* @return
*/
public boolean login(CloseableHttpClient httpClient, HttpClientContext context){
String yzm = null;
String loginState = null;
HttpGet getRequest = new HttpGet("https://www.zhihu.com/#signin";);
HttpClientUtil.getWebPage(httpClient,context, getRequest, "utf-8", false);
HttpPost request = new HttpPost("https://www.zhihu.com/login/email";);
List formParams = new ArrayList();
yzm = yzm(httpClient, context,"https://www.zhihu.com/captcha.gif?type=login";);//肉眼识别验证码
formParams.add(new BasicNameValuePair("captcha", yzm));
formParams.add(new BasicNameValuePair("_xsrf", ""));//这个参数可以不用
formParams.add(new BasicNameValuePair("email", "邮箱"));
formParams.add(new BasicNameValuePair("password", "密码"));
formParams.add(new BasicNameValuePair("remember_me", "true"));
UrlEncodedFormEntity entity = null;
try {
entity = new UrlEncodedFormEntity(formParams, "utf-8");
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
}
request.setEntity(entity);
loginState = HttpClientUtil.getWebPage(httpClient,context, request, "utf-8", false);//登录
JSONObject jo = new JSONObject(loginState);
if(jo.get("r").toString().equals("0")){
System.out.println("登录成功");
getRequest = new HttpGet("https://www.zhihu.com";);
HttpClientUtil.getWebPage(httpClient,context ,getRequest, "utf-8", false);//访问首页
HttpClientUtil.serializeObject(context.getCookieStore(),"resources/zhihucookies");//序列化知乎Cookies，下次登录直接通过该cookies登录
return true;
}else{
System.out.println("登录失败" + loginState);
return false;
}
}
/**
* 肉眼识别验证码
* @param httpClient Http客户端
* @param context Http上下文
* @param url 验证码地址
* @return
*/
public String yzm(CloseableHttpClient httpClient,HttpClientContext context, String url){
HttpClientUtil.downloadFile(httpClient, context, url, "d:/test/", "1.gif",true);
Scanner sc = new Scanner(System.in);
String yzm = sc.nextLine();
return yzm;
}
效果图：
httpclient 抓取网页(STM32 )
网站优化 • 优采云 发表了文章 • 0 个评论 • 60 次浏览 • 2021-12-23 12:04
httpclient 抓取网页(STM32
)
1、GET 方法
第一步是创建一个客户端，类似于用浏览器打开一个网页
HttpClient httpClient = new HttpClient();
第二步是创建一个GET方法来获取你需要爬取的网页的网址
GetMethod getMethod = new GetMethod("");
第三步，获取URL的响应状态码，200表示请求成功
int statusCode = httpClient.executeMethod(getMethod);
第四步，获取网页源代码
byte[] responseBody = getMethod.getResponseBody();
主要是这四个步骤，当然还有很多其他的，比如网页编码问题
HttpClient httpClient = new HttpClient();
GetMethod getMethod = new GetMethod("http://www.baidu.com/");
try {
int statusCode = httpClient.executeMethod(getMethod);
if (statusCode != HttpStatus.SC_OK) {
System.err.println("Method failed: "
+ getMethod.getStatusLine());
}
// 读取内容
byte[] responseBody = getMethod.getResponseBody();
// 处理内容
String html = new String(responseBody);
System.out.println(html);
} catch (Exception e) {
System.err.println("页面无法访问");
}finally{
getMethod.releaseConnection();
}
2、发布方式
HttpClient httpClient = new HttpClient();
PostMethod postMethod = new PostMethod(UrlPath);
postMethod.getParams().setParameter(HttpMethodParams.RETRY_HANDLER,new DefaultHttpMethodRetryHandler());
NameValuePair[] postData = new NameValuePair[2];
postData[0] = new NameValuePair("username", "xkey");
postData[1] = new NameValuePair("userpass", "********");
postMethod.setRequestBody(postData);
try {
int statusCode = httpClient.executeMethod(postMethod);
if (statusCode == HttpStatus.SC_OK) {
byte[] responseBody = postMethod.getResponseBody();
String html = new String(responseBody);
System.out.println(html);
}
} catch (Exception e) {
System.err.println("页面无法访问");
}finally{
postMethod.releaseConnection();
}
本例传递两个Post参数：username为xkey，userpass为*******，传递给URL UrlPath
如需了解获取gzip网页的信息，请参考
另一种是获取非字符数据，所以可以使用下面的方法
HttpClient httpClient = new HttpClient();
GetMethod getMethod = new GetMethod("http://www.baidu.com");
try {
InputStream inputStream = getMethod.getResponseBodyAsStream();
// 这里处理 inputStream
} catch (Exception e) {
System.err.println("页面无法访问");
}finally{
getMethod.releaseConnection();
} 查看全部
)
1、GET 方法
第一步是创建一个客户端，类似于用浏览器打开一个网页
HttpClient httpClient = new HttpClient();
第二步是创建一个GET方法来获取你需要爬取的网页的网址
GetMethod getMethod = new GetMethod("");
第三步，获取URL的响应状态码，200表示请求成功
int statusCode = httpClient.executeMethod(getMethod);
第四步，获取网页源代码
byte[] responseBody = getMethod.getResponseBody();
主要是这四个步骤，当然还有很多其他的，比如网页编码问题
HttpClient httpClient = new HttpClient();
GetMethod getMethod = new GetMethod("http://www.baidu.com/");
try {
int statusCode = httpClient.executeMethod(getMethod);
if (statusCode != HttpStatus.SC_OK) {
System.err.println("Method failed: "
+ getMethod.getStatusLine());
}
// 读取内容
byte[] responseBody = getMethod.getResponseBody();
// 处理内容
String html = new String(responseBody);
System.out.println(html);
} catch (Exception e) {
System.err.println("页面无法访问");
}finally{
getMethod.releaseConnection();
}
2、发布方式
HttpClient httpClient = new HttpClient();
PostMethod postMethod = new PostMethod(UrlPath);
postMethod.getParams().setParameter(HttpMethodParams.RETRY_HANDLER,new DefaultHttpMethodRetryHandler());
NameValuePair[] postData = new NameValuePair[2];
postData[0] = new NameValuePair("username", "xkey");
postData[1] = new NameValuePair("userpass", "********");
postMethod.setRequestBody(postData);
try {
int statusCode = httpClient.executeMethod(postMethod);
if (statusCode == HttpStatus.SC_OK) {
byte[] responseBody = postMethod.getResponseBody();
String html = new String(responseBody);
System.out.println(html);
}
} catch (Exception e) {
System.err.println("页面无法访问");
}finally{
postMethod.releaseConnection();
}
本例传递两个Post参数：username为xkey，userpass为*******，传递给URL UrlPath
如需了解获取gzip网页的信息，请参考
另一种是获取非字符数据，所以可以使用下面的方法
HttpClient httpClient = new HttpClient();
GetMethod getMethod = new GetMethod("http://www.baidu.com");
try {
InputStream inputStream = getMethod.getResponseBodyAsStream();
// 这里处理 inputStream
} catch (Exception e) {
System.err.println("页面无法访问");
}finally{
getMethod.releaseConnection();
} 查看全部
httpclient 抓取网页(STM32
)
1、GET 方法
第一步是创建一个客户端，类似于用浏览器打开一个网页
HttpClient httpClient = new HttpClient();
第二步是创建一个GET方法来获取你需要爬取的网页的网址
GetMethod getMethod = new GetMethod("");
第三步，获取URL的响应状态码，200表示请求成功
int statusCode = httpClient.executeMethod(getMethod);
第四步，获取网页源代码
byte[] responseBody = getMethod.getResponseBody();
主要是这四个步骤，当然还有很多其他的，比如网页编码问题
HttpClient httpClient = new HttpClient();
GetMethod getMethod = new GetMethod("http://www.baidu.com/";);
try {
int statusCode = httpClient.executeMethod(getMethod);
if (statusCode != HttpStatus.SC_OK) {
System.err.println("Method failed: "
+ getMethod.getStatusLine());
}
// 读取内容
byte[] responseBody = getMethod.getResponseBody();
// 处理内容
String html = new String(responseBody);
System.out.println(html);
} catch (Exception e) {
System.err.println("页面无法访问");
}finally{
getMethod.releaseConnection();
}
2、发布方式
HttpClient httpClient = new HttpClient();
PostMethod postMethod = new PostMethod(UrlPath);
postMethod.getParams().setParameter(HttpMethodParams.RETRY_HANDLER,new DefaultHttpMethodRetryHandler());
NameValuePair[] postData = new NameValuePair[2];
postData[0] = new NameValuePair("username", "xkey");
postData[1] = new NameValuePair("userpass", "********");
postMethod.setRequestBody(postData);
try {
int statusCode = httpClient.executeMethod(postMethod);
if (statusCode == HttpStatus.SC_OK) {
byte[] responseBody = postMethod.getResponseBody();
String html = new String(responseBody);
System.out.println(html);
}
} catch (Exception e) {
System.err.println("页面无法访问");
}finally{
postMethod.releaseConnection();
}
本例传递两个Post参数：username为xkey，userpass为*******，传递给URL UrlPath
如需了解获取gzip网页的信息，请参考
另一种是获取非字符数据，所以可以使用下面的方法
HttpClient httpClient = new HttpClient();
GetMethod getMethod = new GetMethod("http://www.baidu.com";);
try {
InputStream inputStream = getMethod.getResponseBodyAsStream();
// 这里处理 inputStream
} catch (Exception e) {
System.err.println("页面无法访问");
}finally{
getMethod.releaseConnection();
}
httpclient 抓取网页(HttpClient抓取网页js生成内容的问题-HttpClient的侠客们)
网站优化 • 优采云 发表了文章 • 0 个评论 • 59 次浏览 • 2021-11-28 19:13
httpclient 抓取网页(HttpClient抓取网页js生成内容的问题-HttpClient的侠客们)
HttpClient抓取网页js生成内容。曾经的骑士。来看看吧。非常感谢您来看我的问题。我要去抢京东产品的产品标题。红色部分的title后面是通过js加载的。这是不可用的。有什么办法可以好起来吗？有类似经历的同胞能指点一下吗？ - - - 解决方案 - - - - - - - - - - - - - - - - - - - - - - ------------- 需要抓取ajax的内容，这个是js动态加载的httpclient，但是获取不到，那么就需要直接模拟ajax了。根据你的需求，我阅读了，需要访问 获取其页面后在产品地址中添加标题红色部分，搜索skuidkey，获取其值，然后访问String skuidkey Stringurl +skuidkey+ callback= 使用Get访问这个url \u76F4\u964D900\u5143\uFF0C\u4EC5\u9650\ u4ECA\u592914:00-18:00\u9650\u62A2D\ECA\u500D \u6B64\u4E00\u6279\uFF01 结果已经得到了标题的红色部分。当然需要把unicode编码的文本转成中文，不知道怎么转百度 查看全部
HttpClient抓取网页js生成内容。曾经的骑士。来看看吧。非常感谢您来看我的问题。我要去抢京东产品的产品标题。红色部分的title后面是通过js加载的。这是不可用的。有什么办法可以好起来吗？有类似经历的同胞能指点一下吗？ - - - 解决方案 - - - - - - - - - - - - - - - - - - - - - - ------------- 需要抓取ajax的内容，这个是js动态加载的httpclient，但是获取不到，那么就需要直接模拟ajax了。根据你的需求，我阅读了，需要访问 获取其页面后在产品地址中添加标题红色部分，搜索skuidkey，获取其值，然后访问String skuidkey Stringurl +skuidkey+ callback= 使用Get访问这个url \u76F4\u964D900\u5143\uFF0C\u4EC5\u9650\ u4ECA\u592914:00-18:00\u9650\u62A2D\ECA\u500D \u6B64\u4E00\u6279\uFF01 结果已经得到了标题的红色部分。当然需要把unicode编码的文本转成中文，不知道怎么转百度 查看全部
httpclient 抓取网页(HttpClient抓取网页js生成内容的问题-HttpClient的侠客们)
HttpClient抓取网页js生成内容。曾经的骑士。来看看吧。非常感谢您来看我的问题。我要去抢京东产品的产品标题。红色部分的title后面是通过js加载的。这是不可用的。有什么办法可以好起来吗？有类似经历的同胞能指点一下吗？ - - - 解决方案 - - - - - - - - - - - - - - - - - - - - - - ------------- 需要抓取ajax的内容，这个是js动态加载的httpclient，但是获取不到，那么就需要直接模拟ajax了。根据你的需求，我阅读了，需要访问 获取其页面后在产品地址中添加标题红色部分，搜索skuidkey，获取其值，然后访问String skuidkey Stringurl +skuidkey+ callback= 使用Get访问这个url \u76F4\u964D900\u5143\uFF0C\u4EC5\u9650\ u4ECA\u592914:00-18:00\u9650\u62A2D\ECA\u500D \u6B64\u4E00\u6279\uFF01 结果已经得到了标题的红色部分。当然需要把unicode编码的文本转成中文，不知道怎么转百度
httpclient 抓取网页(如何使用Java/Python访问网页和使用Python进行数据解析)
网站优化 • 优采云 发表了文章 • 0 个评论 • 63 次浏览 • 2021-11-26 19:03
httpclient 抓取网页(如何使用Java/Python访问网页和使用Python进行数据解析)
前言：
网络爬虫看起来仍然很棒。但是，如果您考虑一下或进行一些研究，您就会知道爬虫并没有那么复杂。最深的就是当我们的数据量非常大的时候，也就是我们的网络“图”的循环越来越多的时候怎么解决。
这篇文章文章只是在这里作为一个介绍。本文主要讲解如何使用Java/Python访问网页和获取网页代码，Python模仿浏览器访问网页，使用Python进行数据分析。希望我们从这篇文章开始，一步步揭开网络蜘蛛的神秘面纱。
参考：
1. "做你自己的手写网络爬虫"
2. 用python写爬虫，爬取csdn的内容，完美解决403 Forbidden
运行效果图：
内容有点多，我只挑了一部分展示。
作者的环境：
系统：Windows 7
CentOS 6.5
运行环境：JDK1.7
Python 2.6.6
IDE：EclipseRelease 4.2.0
PyCharm 4.5.1
数据库：MySQLVer 14.14 Distrib 5.1.73
开发过程：1. 使用Java抓取页面
对于页面抓取，我们使用Java来实现，当然你也可以使用其他语言来开发。但
我们以“博客园”的主页为例，展示使用Java抓取网页的过程：
public class RetrivePageSimple {
private static HttpClient httpClient = new HttpClient();
// 设置代理服务器
static {
httpClient.getHostConfiguration().setProxy("58.220.2.132", 80);
}
public static boolean downloadPage(String path) throws HttpException,
IOException {
PostMethod postMethod = new PostMethod(path);
// 执行，返回状态码
int statusCode = httpClient.executeMethod(postMethod);
System.out.println(statusCode);
// 针对状态码进行处理 (简单起见，只处理返回值为200的状态码)
if (statusCode == HttpStatus.SC_OK) {
String a = postMethod.getResponseBodyAsString();
System.out.println(a);
return true;
}
return false;
}
public static void main(String[] args) {
try {
RetrivePageSimple.downloadPage("http://www.cnblogs.com/");
} catch (HttpException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
}
结果信息这里不再显示了，太多了。. . ——！
2.使用Python爬取页面
你可能会问，为什么写成Java版本是用来爬网页的，而这里又是一个Python呢？这是必要的。因为作者在开发这个demo之前没有考虑一个问题。当我们使用Java抓取一个网页并将其发送到Python时，网页字符串太长而无法作为参数传递。你可能认为保存文件是一个不错的选择，但是如果html文件太多怎么办？是的，在这里我们必须放弃这种累人的方法。
考虑到参数长度的限制，这里只给出Java端的页面地址，使用Python爬取网页。
以最简单的方式，我们通常使用 Python 网页是这样的：
import urllib2
result = urllib2.urlopen(\'http://blog.csdn.net/mobile/index.html\')
html = result.read()
print html
不过作者在代码中使用了CSDN的博客频道的url。CSDN 对爬虫的访问进行过滤。如下，我们会得到如下错误信息：
403，我被拒绝了。
3.使用仿浏览器登录网站
如前所述，当我们访问带有保护措施的网页时，我们会被拒绝。但是我们可以尝试使用我们的浏览器来访问它，它是可以访问的。
换句话说，如果我们可以在 Python 中将自己模仿为浏览器，我们就可以访问这个网页。下面是Python模仿浏览器的代码：
import random
import socket
import urllib2
import cookielib
ERROR = {
\'0\':\'Can not open the url,checck you net\',
\'1\':\'Creat download dir error\',
\'2\':\'The image links is empty\',
\'3\':\'Download faild\',
\'4\':\'Build soup error,the html is empty\',
\'5\':\'Can not save the image to your disk\',
}
class BrowserBase(object):
def __init__(self):
socket.setdefaulttimeout(20)
self._content = None
def speak(self, name, content):
print \'[%s]%s\' % (name, content)
def open_url(self, url):
"""
打开网页
"""
cookie_support= urllib2.HTTPCookieProcessor(cookielib.CookieJar())
self.opener = urllib2.build_opener(cookie_support,urllib2.HTTPHandler)
urllib2.install_opener(self.opener)
user_agents = [
\'Mozilla/5.0 (Windows; U; Windows NT 5.1; it; rv:1.8.1.11) Gecko/20071127 Firefox/2.0.0.11\',
\'Opera/9.25 (Windows NT 5.1; U; en)\',
\'Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; SV1; .NET CLR 1.1.4322; .NET CLR 2.0.50727)\',
\'Mozilla/5.0 (compatible; Konqueror/3.5; Linux) KHTML/3.5.5 (like Gecko) (Kubuntu)\',
\'Mozilla/5.0 (X11; U; Linux i686; en-US; rv:1.8.0.12) Gecko/20070731 Ubuntu/dapper-security Firefox/1.5.0.12\',
\'Lynx/2.8.5rel.1 libwww-FM/2.14 SSL-MM/1.4.1 GNUTLS/1.2.9\',
"Mozilla/5.0 (X11; Linux i686) AppleWebKit/535.7 (KHTML, like Gecko) Ubuntu/11.04 Chromium/16.0.912.77 Chrome/16.0.912.77 Safari/535.7",
"Mozilla/5.0 (X11; Ubuntu; Linux i686; rv:10.0) Gecko/20100101 Firefox/10.0 ",
]
agent = random.choice(user_agents)
self.opener.addheaders = [("User-agent", agent), ("Accept", "*/*"), (\'Referer\', \'http://www.google.com\')]
try:
res = self.opener.open(url)
self._content = res.read()
# print self._content
except Exception, e:
self.speak(str(e)+url)
raise Exception
else:
return res
def get_html_content(self):
return self._content
def get_html_response(html):
spider = BrowserBase()
spider.open_url(html)
return spider.get_html_content()
以上代码可以正常获取返回值。下面我们来看看返回结果的解析过程。
4.数据分析
使用 Python 解析 Html 异常简单：
import HTMLParser
class ListWebParser(HTMLParser.HTMLParser):
def __init__(self):
HTMLParser.HTMLParser.__init__(self)
self.tagDIVFlag = False
self.tagDIVAFlag = False
self.tagH1Flag = False
self.tagSecondHrefFlag = False
self._name = None
self._address = None
def handle_starttag(self, tag, attrs):
if tag == \'div\':
for name, value in attrs:
if name == \'class\' and value == \'blog_list\':
self.tagDIVFlag = True
if tag == \'h1\':
if self.tagDIVFlag:
self.tagH1Flag = True
# print \'h1->\', self.tagH1Flag
if tag == \'a\':
#if self.tagDIVAFlag:
#print \'h1: \', self.tagH1Flag
if self.tagH1Flag:
for name, value in attrs:
if name == \'target\' and value == \'_blank\':
self.tagDIVAFlag = True
if name == \'href\':
if self.tagSecondHrefFlag:
print \'网址：\', value
self._address = value
self.tagSecondHrefFlag = True
# if name == \'href\' and self.tagDIVAFlag:
# print \'网址：\', value
# self._address = value
def handle_endtag(self, tag):
if tag == \'div\':
self.tagDIVFlag = False
if tag == \'h1\':
self.tagH1Flag = False
# print \'false h1.\'
if tag == \'a\':
self.tagDIVAFlag = False
def handle_data(self, data):
if self.tagDIVAFlag:
print u"名称：", data.decode("utf-8")
如果你说你在网上找到的Html文件就没有这个烦恼。我承认这一点，因为在正常情况下，我们解析一些简单的数据确实很简单。上面代码中的复杂逻辑是处理过滤。
说到筛选，这里我使用了一个小技巧（当然，当人多的时候，这不再只是一个技巧。但是这个方法可以在以后的编码过程中参考）。我们使用一些特殊的标签属性（比如 id、class 等）来锁定块。当我们启动block时，我们对应的flag会被标记为True，当我们退出block时，我们对应的flag会被标记为False。也许你觉得这太麻烦了。事实上，如果你仔细想想，你就会知道这是有道理的。
预防措施：
1.在使用Java进行页面爬取时，我们使用了代理服务器。这个代理服务器的主机和端口可以直接在网上免费查到。
2.您需要准备以下jar包并导入到您的Eclipse项目中：
3.修改MySQL默认编码为UTF-8
因为这里会有一些中文信息，所以我们需要转换一下MySQL的编码格式。
如果你是在Linux下编码，那么你可以参考： 查看全部
前言：
网络爬虫看起来仍然很棒。但是，如果您考虑一下或进行一些研究，您就会知道爬虫并没有那么复杂。最深的就是当我们的数据量非常大的时候，也就是我们的网络“图”的循环越来越多的时候怎么解决。
这篇文章文章只是在这里作为一个介绍。本文主要讲解如何使用Java/Python访问网页和获取网页代码，Python模仿浏览器访问网页，使用Python进行数据分析。希望我们从这篇文章开始，一步步揭开网络蜘蛛的神秘面纱。
参考：
1. "做你自己的手写网络爬虫"
2. 用python写爬虫，爬取csdn的内容，完美解决403 Forbidden
运行效果图：
内容有点多，我只挑了一部分展示。
作者的环境：
系统：Windows 7
CentOS 6.5
运行环境：JDK1.7
Python 2.6.6
IDE：EclipseRelease 4.2.0
PyCharm 4.5.1
数据库：MySQLVer 14.14 Distrib 5.1.73
开发过程：1. 使用Java抓取页面
对于页面抓取，我们使用Java来实现，当然你也可以使用其他语言来开发。但
我们以“博客园”的主页为例，展示使用Java抓取网页的过程：
public class RetrivePageSimple {
private static HttpClient httpClient = new HttpClient();
// 设置代理服务器
static {
httpClient.getHostConfiguration().setProxy("58.220.2.132", 80);
}
public static boolean downloadPage(String path) throws HttpException,
IOException {
PostMethod postMethod = new PostMethod(path);
// 执行，返回状态码
int statusCode = httpClient.executeMethod(postMethod);
System.out.println(statusCode);
// 针对状态码进行处理 (简单起见，只处理返回值为200的状态码)
if (statusCode == HttpStatus.SC_OK) {
String a = postMethod.getResponseBodyAsString();
System.out.println(a);
return true;
}
return false;
}
public static void main(String[] args) {
try {
RetrivePageSimple.downloadPage("http://www.cnblogs.com/");
} catch (HttpException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
}
结果信息这里不再显示了，太多了。. . ——！
2.使用Python爬取页面
你可能会问，为什么写成Java版本是用来爬网页的，而这里又是一个Python呢？这是必要的。因为作者在开发这个demo之前没有考虑一个问题。当我们使用Java抓取一个网页并将其发送到Python时，网页字符串太长而无法作为参数传递。你可能认为保存文件是一个不错的选择，但是如果html文件太多怎么办？是的，在这里我们必须放弃这种累人的方法。
考虑到参数长度的限制，这里只给出Java端的页面地址，使用Python爬取网页。
以最简单的方式，我们通常使用 Python 网页是这样的：
import urllib2
result = urllib2.urlopen(\'http://blog.csdn.net/mobile/index.html\')
html = result.read()
print html
不过作者在代码中使用了CSDN的博客频道的url。CSDN 对爬虫的访问进行过滤。如下，我们会得到如下错误信息：
403，我被拒绝了。
3.使用仿浏览器登录网站
如前所述，当我们访问带有保护措施的网页时，我们会被拒绝。但是我们可以尝试使用我们的浏览器来访问它，它是可以访问的。
换句话说，如果我们可以在 Python 中将自己模仿为浏览器，我们就可以访问这个网页。下面是Python模仿浏览器的代码：
import random
import socket
import urllib2
import cookielib
ERROR = {
\'0\':\'Can not open the url,checck you net\',
\'1\':\'Creat download dir error\',
\'2\':\'The image links is empty\',
\'3\':\'Download faild\',
\'4\':\'Build soup error,the html is empty\',
\'5\':\'Can not save the image to your disk\',
}
class BrowserBase(object):
def __init__(self):
socket.setdefaulttimeout(20)
self._content = None
def speak(self, name, content):
print \'[%s]%s\' % (name, content)
def open_url(self, url):
"""
打开网页
"""
cookie_support= urllib2.HTTPCookieProcessor(cookielib.CookieJar())
self.opener = urllib2.build_opener(cookie_support,urllib2.HTTPHandler)
urllib2.install_opener(self.opener)
user_agents = [
\'Mozilla/5.0 (Windows; U; Windows NT 5.1; it; rv:1.8.1.11) Gecko/20071127 Firefox/2.0.0.11\',
\'Opera/9.25 (Windows NT 5.1; U; en)\',
\'Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; SV1; .NET CLR 1.1.4322; .NET CLR 2.0.50727)\',
\'Mozilla/5.0 (compatible; Konqueror/3.5; Linux) KHTML/3.5.5 (like Gecko) (Kubuntu)\',
\'Mozilla/5.0 (X11; U; Linux i686; en-US; rv:1.8.0.12) Gecko/20070731 Ubuntu/dapper-security Firefox/1.5.0.12\',
\'Lynx/2.8.5rel.1 libwww-FM/2.14 SSL-MM/1.4.1 GNUTLS/1.2.9\',
"Mozilla/5.0 (X11; Linux i686) AppleWebKit/535.7 (KHTML, like Gecko) Ubuntu/11.04 Chromium/16.0.912.77 Chrome/16.0.912.77 Safari/535.7",
"Mozilla/5.0 (X11; Ubuntu; Linux i686; rv:10.0) Gecko/20100101 Firefox/10.0 ",
]
agent = random.choice(user_agents)
self.opener.addheaders = [("User-agent", agent), ("Accept", "*/*"), (\'Referer\', \'http://www.google.com\')]
try:
res = self.opener.open(url)
self._content = res.read()
# print self._content
except Exception, e:
self.speak(str(e)+url)
raise Exception
else:
return res
def get_html_content(self):
return self._content
def get_html_response(html):
spider = BrowserBase()
spider.open_url(html)
return spider.get_html_content()
以上代码可以正常获取返回值。下面我们来看看返回结果的解析过程。
4.数据分析
使用 Python 解析 Html 异常简单：
import HTMLParser
class ListWebParser(HTMLParser.HTMLParser):
def __init__(self):
HTMLParser.HTMLParser.__init__(self)
self.tagDIVFlag = False
self.tagDIVAFlag = False
self.tagH1Flag = False
self.tagSecondHrefFlag = False
self._name = None
self._address = None
def handle_starttag(self, tag, attrs):
if tag == \'div\':
for name, value in attrs:
if name == \'class\' and value == \'blog_list\':
self.tagDIVFlag = True
if tag == \'h1\':
if self.tagDIVFlag:
self.tagH1Flag = True
# print \'h1->\', self.tagH1Flag
if tag == \'a\':
#if self.tagDIVAFlag:
#print \'h1: \', self.tagH1Flag
if self.tagH1Flag:
for name, value in attrs:
if name == \'target\' and value == \'_blank\':
self.tagDIVAFlag = True
if name == \'href\':
if self.tagSecondHrefFlag:
print \'网址：\', value
self._address = value
self.tagSecondHrefFlag = True
# if name == \'href\' and self.tagDIVAFlag:
# print \'网址：\', value
# self._address = value
def handle_endtag(self, tag):
if tag == \'div\':
self.tagDIVFlag = False
if tag == \'h1\':
self.tagH1Flag = False
# print \'false h1.\'
if tag == \'a\':
self.tagDIVAFlag = False
def handle_data(self, data):
if self.tagDIVAFlag:
print u"名称：", data.decode("utf-8")
如果你说你在网上找到的Html文件就没有这个烦恼。我承认这一点，因为在正常情况下，我们解析一些简单的数据确实很简单。上面代码中的复杂逻辑是处理过滤。
说到筛选，这里我使用了一个小技巧（当然，当人多的时候，这不再只是一个技巧。但是这个方法可以在以后的编码过程中参考）。我们使用一些特殊的标签属性（比如 id、class 等）来锁定块。当我们启动block时，我们对应的flag会被标记为True，当我们退出block时，我们对应的flag会被标记为False。也许你觉得这太麻烦了。事实上，如果你仔细想想，你就会知道这是有道理的。
预防措施：
1.在使用Java进行页面爬取时，我们使用了代理服务器。这个代理服务器的主机和端口可以直接在网上免费查到。
2.您需要准备以下jar包并导入到您的Eclipse项目中：
3.修改MySQL默认编码为UTF-8
因为这里会有一些中文信息，所以我们需要转换一下MySQL的编码格式。
如果你是在Linux下编码，那么你可以参考： 查看全部
httpclient 抓取网页(如何使用Java/Python访问网页和使用Python进行数据解析)
前言：
网络爬虫看起来仍然很棒。但是，如果您考虑一下或进行一些研究，您就会知道爬虫并没有那么复杂。最深的就是当我们的数据量非常大的时候，也就是我们的网络“图”的循环越来越多的时候怎么解决。
这篇文章文章只是在这里作为一个介绍。本文主要讲解如何使用Java/Python访问网页和获取网页代码，Python模仿浏览器访问网页，使用Python进行数据分析。希望我们从这篇文章开始，一步步揭开网络蜘蛛的神秘面纱。
参考：
1. "做你自己的手写网络爬虫"
2. 用python写爬虫，爬取csdn的内容，完美解决403 Forbidden
运行效果图：
内容有点多，我只挑了一部分展示。
作者的环境：
系统：Windows 7
CentOS 6.5
运行环境：JDK1.7
Python 2.6.6
IDE：EclipseRelease 4.2.0
PyCharm 4.5.1
数据库：MySQLVer 14.14 Distrib 5.1.73
开发过程：1. 使用Java抓取页面
对于页面抓取，我们使用Java来实现，当然你也可以使用其他语言来开发。但
我们以“博客园”的主页为例，展示使用Java抓取网页的过程：
public class RetrivePageSimple {
private static HttpClient httpClient = new HttpClient();
// 设置代理服务器
static {
httpClient.getHostConfiguration().setProxy("58.220.2.132", 80);
}
public static boolean downloadPage(String path) throws HttpException,
IOException {
PostMethod postMethod = new PostMethod(path);
// 执行，返回状态码
int statusCode = httpClient.executeMethod(postMethod);
System.out.println(statusCode);
// 针对状态码进行处理 (简单起见，只处理返回值为200的状态码)
if (statusCode == HttpStatus.SC_OK) {
String a = postMethod.getResponseBodyAsString();
System.out.println(a);
return true;
}
return false;
}
public static void main(String[] args) {
try {
RetrivePageSimple.downloadPage("http://www.cnblogs.com/";);
} catch (HttpException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
}
结果信息这里不再显示了，太多了。. . ——！
2.使用Python爬取页面
你可能会问，为什么写成Java版本是用来爬网页的，而这里又是一个Python呢？这是必要的。因为作者在开发这个demo之前没有考虑一个问题。当我们使用Java抓取一个网页并将其发送到Python时，网页字符串太长而无法作为参数传递。你可能认为保存文件是一个不错的选择，但是如果html文件太多怎么办？是的，在这里我们必须放弃这种累人的方法。
考虑到参数长度的限制，这里只给出Java端的页面地址，使用Python爬取网页。
以最简单的方式，我们通常使用 Python 网页是这样的：
import urllib2
result = urllib2.urlopen(\'http://blog.csdn.net/mobile/index.html\')
html = result.read()
print html
不过作者在代码中使用了CSDN的博客频道的url。CSDN 对爬虫的访问进行过滤。如下，我们会得到如下错误信息：
403，我被拒绝了。
3.使用仿浏览器登录网站
如前所述，当我们访问带有保护措施的网页时，我们会被拒绝。但是我们可以尝试使用我们的浏览器来访问它，它是可以访问的。
换句话说，如果我们可以在 Python 中将自己模仿为浏览器，我们就可以访问这个网页。下面是Python模仿浏览器的代码：
import random
import socket
import urllib2
import cookielib
ERROR = {
\'0\':\'Can not open the url,checck you net\',
\'1\':\'Creat download dir error\',
\'2\':\'The image links is empty\',
\'3\':\'Download faild\',
\'4\':\'Build soup error,the html is empty\',
\'5\':\'Can not save the image to your disk\',
}
class BrowserBase(object):
def __init__(self):
socket.setdefaulttimeout(20)
self._content = None
def speak(self, name, content):
print \'[%s]%s\' % (name, content)
def open_url(self, url):
"""
打开网页
"""
cookie_support= urllib2.HTTPCookieProcessor(cookielib.CookieJar())
self.opener = urllib2.build_opener(cookie_support,urllib2.HTTPHandler)
urllib2.install_opener(self.opener)
user_agents = [
\'Mozilla/5.0 (Windows; U; Windows NT 5.1; it; rv:1.8.1.11) Gecko/20071127 Firefox/2.0.0.11\',
\'Opera/9.25 (Windows NT 5.1; U; en)\',
\'Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; SV1; .NET CLR 1.1.4322; .NET CLR 2.0.50727)\',
\'Mozilla/5.0 (compatible; Konqueror/3.5; Linux) KHTML/3.5.5 (like Gecko) (Kubuntu)\',
\'Mozilla/5.0 (X11; U; Linux i686; en-US; rv:1.8.0.12) Gecko/20070731 Ubuntu/dapper-security Firefox/1.5.0.12\',
\'Lynx/2.8.5rel.1 libwww-FM/2.14 SSL-MM/1.4.1 GNUTLS/1.2.9\',
"Mozilla/5.0 (X11; Linux i686) AppleWebKit/535.7 (KHTML, like Gecko) Ubuntu/11.04 Chromium/16.0.912.77 Chrome/16.0.912.77 Safari/535.7",
"Mozilla/5.0 (X11; Ubuntu; Linux i686; rv:10.0) Gecko/20100101 Firefox/10.0 ",
]
agent = random.choice(user_agents)
self.opener.addheaders = [("User-agent", agent), ("Accept", "*/*"), (\'Referer\', \'http://www.google.com\')]
try:
res = self.opener.open(url)
self._content = res.read()
# print self._content
except Exception, e:
self.speak(str(e)+url)
raise Exception
else:
return res
def get_html_content(self):
return self._content
def get_html_response(html):
spider = BrowserBase()
spider.open_url(html)
return spider.get_html_content()
以上代码可以正常获取返回值。下面我们来看看返回结果的解析过程。
4.数据分析
使用 Python 解析 Html 异常简单：
import HTMLParser
class ListWebParser(HTMLParser.HTMLParser):
def __init__(self):
HTMLParser.HTMLParser.__init__(self)
self.tagDIVFlag = False
self.tagDIVAFlag = False
self.tagH1Flag = False
self.tagSecondHrefFlag = False
self._name = None
self._address = None
def handle_starttag(self, tag, attrs):
if tag == \'div\':
for name, value in attrs:
if name == \'class\' and value == \'blog_list\':
self.tagDIVFlag = True
if tag == \'h1\':
if self.tagDIVFlag:
self.tagH1Flag = True
# print \'h1->\', self.tagH1Flag
if tag == \'a\':
#if self.tagDIVAFlag:
#print \'h1: \', self.tagH1Flag
if self.tagH1Flag:
for name, value in attrs:
if name == \'target\' and value == \'_blank\':
self.tagDIVAFlag = True
if name == \'href\':
if self.tagSecondHrefFlag:
print \'网址：\', value
self._address = value
self.tagSecondHrefFlag = True
# if name == \'href\' and self.tagDIVAFlag:
# print \'网址：\', value
# self._address = value
def handle_endtag(self, tag):
if tag == \'div\':
self.tagDIVFlag = False
if tag == \'h1\':
self.tagH1Flag = False
# print \'false h1.\'
if tag == \'a\':
self.tagDIVAFlag = False
def handle_data(self, data):
if self.tagDIVAFlag:
print u"名称：", data.decode("utf-8")
如果你说你在网上找到的Html文件就没有这个烦恼。我承认这一点，因为在正常情况下，我们解析一些简单的数据确实很简单。上面代码中的复杂逻辑是处理过滤。
说到筛选，这里我使用了一个小技巧（当然，当人多的时候，这不再只是一个技巧。但是这个方法可以在以后的编码过程中参考）。我们使用一些特殊的标签属性（比如 id、class 等）来锁定块。当我们启动block时，我们对应的flag会被标记为True，当我们退出block时，我们对应的flag会被标记为False。也许你觉得这太麻烦了。事实上，如果你仔细想想，你就会知道这是有道理的。
预防措施：
1.在使用Java进行页面爬取时，我们使用了代理服务器。这个代理服务器的主机和端口可以直接在网上免费查到。
2.您需要准备以下jar包并导入到您的Eclipse项目中：
3.修改MySQL默认编码为UTF-8
因为这里会有一些中文信息，所以我们需要转换一下MySQL的编码格式。
如果你是在Linux下编码，那么你可以参考：
httpclient 抓取网页(,实例分析了java爬虫的两种实现技巧具有一定参考借鉴价值)
网站优化 • 优采云 发表了文章 • 0 个评论 • 65 次浏览 • 2021-11-15 10:09
httpclient 抓取网页(,实例分析了java爬虫的两种实现技巧具有一定参考借鉴价值)
本文文章主要介绍JAVA利用爬虫抓取网站网页内容的方法。实例分析了java爬虫的两种实现技术。有一定的参考价值，有需要的朋友可以参考。下
本文以JAVA如何使用爬虫抓取网站网页内容为例。分享给大家，供大家参考。详情如下：
最近在用JAVA学习爬虫技术。哈哈，我进了门，和大家分享我的经历。
下面提供了两种方法，一种是使用apache提供的包。另一种是JAVA自带的。
代码如下：
<p> // 第一种方法 //这种方法是用apache提供的包,简单方便 //但是要用到以下包:commons-codec-1.4.jar // commons-httpclient-3.1.jar // commons-logging-1.0.4.jar public static String createhttpClient(String url, String param) { HttpClient client = new HttpClient(); String response = null; String keyword = null; PostMethod postMethod = new PostMethod(url); // try { // if (param != null) // keyword = new String(param.getBytes("gb2312"), "ISO-8859-1"); // } catch (UnsupportedEncodingException e1) { // // TODO Auto-generated catch block // e1.printStackTrace(); // } // NameValuePair[] data = { new NameValuePair("keyword", keyword) }; // // 将表单的值放入postMethod中 // postMethod.setRequestBody(data); // 以上部分是带参数抓取,我自己把它注销了．大家可以把注销消掉研究下 try { int statusCode = client.executeMethod(postMethod); response = new String(postMethod.getResponseBodyAsString() .getBytes("ISO-8859-1"), "gb2312"); //这里要注意下 gb2312要和你抓取网页的编码要一样 String p = response.replaceAll("//&[a-zA-Z]{1,10};", "") .replaceAll("]*>", "");//去掉网页中带有html语言的标签 System.out.println(p); } catch (Exception e) { e.printStackTrace(); } return response; } // 第二种方法 // 这种方法是JAVA自带的URL来抓取网站内容 public String getPageContent(String strUrl, String strPostRequest, int maxLength) { // 读取结果网页 StringBuffer buffer = new StringBuffer(); System.setProperty("sun.net.client.defaultConnectTimeout", "5000"); System.setProperty("sun.net.client.defaultReadTimeout", "5000"); try { URL newUrl = new URL(strUrl); HttpURLConnection hConnect = (HttpURLConnection) newUrl .openConnection(); // POST方式的额外数据 if (strPostRequest.length() > 0) { hConnect.setDoOutput(true); OutputStreamWriter out = new OutputStreamWriter(hConnect .getOutputStream()); out.write(strPostRequest); out.flush(); out.close(); } // 读取内容 BufferedReader rd = new BufferedReader(new InputStreamReader( hConnect.getInputStream())); int ch; for (int length = 0; (ch = rd.read()) > -1 && (maxLength 查看全部
本文文章主要介绍JAVA利用爬虫抓取网站网页内容的方法。实例分析了java爬虫的两种实现技术。有一定的参考价值，有需要的朋友可以参考。下
本文以JAVA如何使用爬虫抓取网站网页内容为例。分享给大家，供大家参考。详情如下：
最近在用JAVA学习爬虫技术。哈哈，我进了门，和大家分享我的经历。
下面提供了两种方法，一种是使用apache提供的包。另一种是JAVA自带的。
代码如下：
<p> // 第一种方法 //这种方法是用apache提供的包,简单方便 //但是要用到以下包:commons-codec-1.4.jar // commons-httpclient-3.1.jar // commons-logging-1.0.4.jar public static String createhttpClient(String url, String param) { HttpClient client = new HttpClient(); String response = null; String keyword = null; PostMethod postMethod = new PostMethod(url); // try { // if (param != null) // keyword = new String(param.getBytes("gb2312"), "ISO-8859-1"); // } catch (UnsupportedEncodingException e1) { // // TODO Auto-generated catch block // e1.printStackTrace(); // } // NameValuePair[] data = { new NameValuePair("keyword", keyword) }; // // 将表单的值放入postMethod中 // postMethod.setRequestBody(data); // 以上部分是带参数抓取,我自己把它注销了．大家可以把注销消掉研究下 try { int statusCode = client.executeMethod(postMethod); response = new String(postMethod.getResponseBodyAsString() .getBytes("ISO-8859-1"), "gb2312"); //这里要注意下 gb2312要和你抓取网页的编码要一样 String p = response.replaceAll("//&[a-zA-Z]{1,10};", "") .replaceAll("]*>", "");//去掉网页中带有html语言的标签 System.out.println(p); } catch (Exception e) { e.printStackTrace(); } return response; } // 第二种方法 // 这种方法是JAVA自带的URL来抓取网站内容 public String getPageContent(String strUrl, String strPostRequest, int maxLength) { // 读取结果网页 StringBuffer buffer = new StringBuffer(); System.setProperty("sun.net.client.defaultConnectTimeout", "5000"); System.setProperty("sun.net.client.defaultReadTimeout", "5000"); try { URL newUrl = new URL(strUrl); HttpURLConnection hConnect = (HttpURLConnection) newUrl .openConnection(); // POST方式的额外数据 if (strPostRequest.length() > 0) { hConnect.setDoOutput(true); OutputStreamWriter out = new OutputStreamWriter(hConnect .getOutputStream()); out.write(strPostRequest); out.flush(); out.close(); } // 读取内容 BufferedReader rd = new BufferedReader(new InputStreamReader( hConnect.getInputStream())); int ch; for (int length = 0; (ch = rd.read()) > -1 && (maxLength 查看全部
httpclient 抓取网页(,实例分析了java爬虫的两种实现技巧具有一定参考借鉴价值)
本文文章主要介绍JAVA利用爬虫抓取网站网页内容的方法。实例分析了java爬虫的两种实现技术。有一定的参考价值，有需要的朋友可以参考。下
本文以JAVA如何使用爬虫抓取网站网页内容为例。分享给大家，供大家参考。详情如下：
最近在用JAVA学习爬虫技术。哈哈，我进了门，和大家分享我的经历。
下面提供了两种方法，一种是使用apache提供的包。另一种是JAVA自带的。
代码如下：
<p> // 第一种方法 //这种方法是用apache提供的包,简单方便 //但是要用到以下包:commons-codec-1.4.jar // commons-httpclient-3.1.jar // commons-logging-1.0.4.jar public static String createhttpClient(String url, String param) { HttpClient client = new HttpClient(); String response = null; String keyword = null; PostMethod postMethod = new PostMethod(url); // try { // if (param != null) // keyword = new String(param.getBytes("gb2312"), "ISO-8859-1"); // } catch (UnsupportedEncodingException e1) { // // TODO Auto-generated catch block // e1.printStackTrace(); // } // NameValuePair[] data = { new NameValuePair("keyword", keyword) }; // // 将表单的值放入postMethod中 // postMethod.setRequestBody(data); // 以上部分是带参数抓取,我自己把它注销了．大家可以把注销消掉研究下 try { int statusCode = client.executeMethod(postMethod); response = new String(postMethod.getResponseBodyAsString() .getBytes("ISO-8859-1"), "gb2312"); //这里要注意下 gb2312要和你抓取网页的编码要一样 String p = response.replaceAll("//&[a-zA-Z]{1,10};", "") .replaceAll("]*>", "");//去掉网页中带有html语言的标签 System.out.println(p); } catch (Exception e) { e.printStackTrace(); } return response; } // 第二种方法 // 这种方法是JAVA自带的URL来抓取网站内容 public String getPageContent(String strUrl, String strPostRequest, int maxLength) { // 读取结果网页 StringBuffer buffer = new StringBuffer(); System.setProperty("sun.net.client.defaultConnectTimeout", "5000"); System.setProperty("sun.net.client.defaultReadTimeout", "5000"); try { URL newUrl = new URL(strUrl); HttpURLConnection hConnect = (HttpURLConnection) newUrl .openConnection(); // POST方式的额外数据 if (strPostRequest.length() > 0) { hConnect.setDoOutput(true); OutputStreamWriter out = new OutputStreamWriter(hConnect .getOutputStream()); out.write(strPostRequest); out.flush(); out.close(); } // 读取内容 BufferedReader rd = new BufferedReader(new InputStreamReader( hConnect.getInputStream())); int ch; for (int length = 0; (ch = rd.read()) > -1 && (maxLength
httpclient 抓取网页(GET方法模拟抓取网页使用org.apache.HttpClient )
网站优化 • 优采云 发表了文章 • 0 个评论 • 64 次浏览 • 2021-11-01 15:05
httpclient 抓取网页(GET方法模拟抓取网页使用org.apache.HttpClient
)
我目前正在学习Android并开发了一个类似于Super Course Schedule和Campus Today的APP。然而，我一直卡在抢课表这一步。遍历了很多数据，还是解决不了。我下定决心要系统信息HttpClient。写一个helloWord，继续记录和学习！
一、GET 方法模拟爬取网页
使用org.apache.HttpClient GET方法模拟登录网页并抓取数据，需要使用HttpClient包
import org.apache.http.HttpEntity;
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 java.io.IOException;
public class HellWord {
//直接模拟
public static void main(String[] a){
//生成一个可关闭的HTTP浏览器（相当于）
CloseableHttpClient httpClient=HttpClients.createDefault();
CloseableHttpResponse response=null;
//创建http Get请求
HttpGet httpGet=new HttpGet("http://hll520.cn");
try {
response=httpClient.execute(httpGet);//执行
} catch (IOException e) {
e.printStackTrace();
}
//获取网页源码
HttpEntity httpEntity=response.getEntity();//获取网页源码
try {
String h=EntityUtils.toString(httpEntity,"UTF-8");//指定编码避免乱码
System.out.printf(h);
} catch (IOException e) {
//io异常（网络问题）
e.printStackTrace();
}
//关闭HTTp
try {
response.close();
httpClient.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
运行结果，模拟打开网页，使用getEntity显示网页的HTML源代码
二、模拟浏览器UA并返回状态
有些网页会给不同的浏览器提供不同的页面，或者限制机器抓取。这时候需要设置UA模拟浏览器登录页面，可以使用getStatusLine返回状态。
1、设置请求头的UA模拟火狐浏览器
httpGet.setHeader("User-Agent","Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:74.0) Gecko/20100101 Firefox/74.0");
2、返回状态
response.getStatusLine();//获取当前状态
如果只返回状态码(200）
response.getStatusLine().getStatusCode()
3、返回类型
确定链接的目标类型
entity.getContentType().getValue()
三、带参数的GET
使用URIBuilder构造一个URI，并设置参数，多个参数就是多个setParameters
URIBuilder uriBuilder=new URIBuilder("http://baidu.com");
//写入参数 (可以设置多参数）
uriBuilder.setParameter("key","JAVA");
uriBuilder.setParameter("keys","c#");
使用build()方法转换为URI
httpGet=new HttpGet(uriBuilder.build());//使用builder写入URI
带参数的完整代码
import org.apache.http.HttpEntity;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.utils.URIBuilder;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.util.EntityUtils;
import java.io.IOException;
import java.net.URISyntaxException;
//带参数的get
public class HelloWordUA {
public static void main(String[] ars){
//生成一个可关闭的HTTP浏览器（相当于）
CloseableHttpClient httpClient= HttpClients.createDefault();
CloseableHttpResponse response=null;
HttpGet httpGet=null;
try {
URIBuilder uriBuilder=new URIBuilder("http://baidu.com");
//写入参数 (可以设置多参数）
uriBuilder.setParameter("key","JAVA");
uriBuilder.setParameter("keys","c#");
System.out.println(uriBuilder.build());
//创建http Get请求
httpGet=new HttpGet(uriBuilder.build());//使用builder写入URI
} catch (URISyntaxException e) {
e.printStackTrace();
}
//设置请求头，UA浏览器型号，模拟火狐浏览器
httpGet.setHeader("User-Agent","Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:74.0) Gecko/20100101 Firefox/74.0");
try {
response=httpClient.execute(httpGet);//执行
//获取当响应状态
// response.getStatusLine();//获取当前状态
//response.getStatusLine().getStatusCode() 获取当前状态码
System.out.println("Status:"+response.getStatusLine().getStatusCode());
//获取网页源码
HttpEntity entity=response.getEntity();//获取网页实体
//获取目标类型
System.out.println("ContentType："+entity.getContentType().getValue());
System.out.println(EntityUtils.toString(entity,"UTF-8"));
} catch (IOException e) {
e.printStackTrace();
}
//关闭HTTp
try {
response.close();
httpClient.close();
} catch (IOException e) {
e.printStackTrace();
}
}
} 查看全部
)
我目前正在学习Android并开发了一个类似于Super Course Schedule和Campus Today的APP。然而，我一直卡在抢课表这一步。遍历了很多数据，还是解决不了。我下定决心要系统信息HttpClient。写一个helloWord，继续记录和学习！
一、GET 方法模拟爬取网页
使用org.apache.HttpClient GET方法模拟登录网页并抓取数据，需要使用HttpClient包
import org.apache.http.HttpEntity;
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 java.io.IOException;
public class HellWord {
//直接模拟
public static void main(String[] a){
//生成一个可关闭的HTTP浏览器（相当于）
CloseableHttpClient httpClient=HttpClients.createDefault();
CloseableHttpResponse response=null;
//创建http Get请求
HttpGet httpGet=new HttpGet("http://hll520.cn");
try {
response=httpClient.execute(httpGet);//执行
} catch (IOException e) {
e.printStackTrace();
}
//获取网页源码
HttpEntity httpEntity=response.getEntity();//获取网页源码
try {
String h=EntityUtils.toString(httpEntity,"UTF-8");//指定编码避免乱码
System.out.printf(h);
} catch (IOException e) {
//io异常（网络问题）
e.printStackTrace();
}
//关闭HTTp
try {
response.close();
httpClient.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
运行结果，模拟打开网页，使用getEntity显示网页的HTML源代码
二、模拟浏览器UA并返回状态
有些网页会给不同的浏览器提供不同的页面，或者限制机器抓取。这时候需要设置UA模拟浏览器登录页面，可以使用getStatusLine返回状态。
1、设置请求头的UA模拟火狐浏览器
httpGet.setHeader("User-Agent","Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:74.0) Gecko/20100101 Firefox/74.0");
2、返回状态
response.getStatusLine();//获取当前状态
如果只返回状态码(200）
response.getStatusLine().getStatusCode()
3、返回类型
确定链接的目标类型
entity.getContentType().getValue()
三、带参数的GET
使用URIBuilder构造一个URI，并设置参数，多个参数就是多个setParameters
URIBuilder uriBuilder=new URIBuilder("http://baidu.com");
//写入参数 (可以设置多参数）
uriBuilder.setParameter("key","JAVA");
uriBuilder.setParameter("keys","c#");
使用build()方法转换为URI
httpGet=new HttpGet(uriBuilder.build());//使用builder写入URI
带参数的完整代码
import org.apache.http.HttpEntity;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.utils.URIBuilder;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.util.EntityUtils;
import java.io.IOException;
import java.net.URISyntaxException;
//带参数的get
public class HelloWordUA {
public static void main(String[] ars){
//生成一个可关闭的HTTP浏览器（相当于）
CloseableHttpClient httpClient= HttpClients.createDefault();
CloseableHttpResponse response=null;
HttpGet httpGet=null;
try {
URIBuilder uriBuilder=new URIBuilder("http://baidu.com");
//写入参数 (可以设置多参数）
uriBuilder.setParameter("key","JAVA");
uriBuilder.setParameter("keys","c#");
System.out.println(uriBuilder.build());
//创建http Get请求
httpGet=new HttpGet(uriBuilder.build());//使用builder写入URI
} catch (URISyntaxException e) {
e.printStackTrace();
}
//设置请求头，UA浏览器型号，模拟火狐浏览器
httpGet.setHeader("User-Agent","Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:74.0) Gecko/20100101 Firefox/74.0");
try {
response=httpClient.execute(httpGet);//执行
//获取当响应状态
// response.getStatusLine();//获取当前状态
//response.getStatusLine().getStatusCode() 获取当前状态码
System.out.println("Status:"+response.getStatusLine().getStatusCode());
//获取网页源码
HttpEntity entity=response.getEntity();//获取网页实体
//获取目标类型
System.out.println("ContentType："+entity.getContentType().getValue());
System.out.println(EntityUtils.toString(entity,"UTF-8"));
} catch (IOException e) {
e.printStackTrace();
}
//关闭HTTp
try {
response.close();
httpClient.close();
} catch (IOException e) {
e.printStackTrace();
}
}
} 查看全部
httpclient 抓取网页(GET方法模拟抓取网页使用org.apache.HttpClient
)
我目前正在学习Android并开发了一个类似于Super Course Schedule和Campus Today的APP。然而，我一直卡在抢课表这一步。遍历了很多数据，还是解决不了。我下定决心要系统信息HttpClient。写一个helloWord，继续记录和学习！
一、GET 方法模拟爬取网页
使用org.apache.HttpClient GET方法模拟登录网页并抓取数据，需要使用HttpClient包
import org.apache.http.HttpEntity;
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 java.io.IOException;
public class HellWord {
//直接模拟
public static void main(String[] a){
//生成一个可关闭的HTTP浏览器（相当于）
CloseableHttpClient httpClient=HttpClients.createDefault();
CloseableHttpResponse response=null;
//创建http Get请求
HttpGet httpGet=new HttpGet("http://hll520.cn";);
try {
response=httpClient.execute(httpGet);//执行
} catch (IOException e) {
e.printStackTrace();
}
//获取网页源码
HttpEntity httpEntity=response.getEntity();//获取网页源码
try {
String h=EntityUtils.toString(httpEntity,"UTF-8");//指定编码避免乱码
System.out.printf(h);
} catch (IOException e) {
//io异常（网络问题）
e.printStackTrace();
}
//关闭HTTp
try {
response.close();
httpClient.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
运行结果，模拟打开网页，使用getEntity显示网页的HTML源代码
二、模拟浏览器UA并返回状态
有些网页会给不同的浏览器提供不同的页面，或者限制机器抓取。这时候需要设置UA模拟浏览器登录页面，可以使用getStatusLine返回状态。
1、设置请求头的UA模拟火狐浏览器
httpGet.setHeader("User-Agent","Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:74.0) Gecko/20100101 Firefox/74.0");
2、返回状态
response.getStatusLine();//获取当前状态
如果只返回状态码(200）
response.getStatusLine().getStatusCode()
3、返回类型
确定链接的目标类型
entity.getContentType().getValue()
三、带参数的GET
使用URIBuilder构造一个URI，并设置参数，多个参数就是多个setParameters
URIBuilder uriBuilder=new URIBuilder("http://baidu.com";);
//写入参数 (可以设置多参数）
uriBuilder.setParameter("key","JAVA");
uriBuilder.setParameter("keys","c#");
使用build()方法转换为URI
httpGet=new HttpGet(uriBuilder.build());//使用builder写入URI
带参数的完整代码
import org.apache.http.HttpEntity;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.utils.URIBuilder;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.util.EntityUtils;
import java.io.IOException;
import java.net.URISyntaxException;
//带参数的get
public class HelloWordUA {
public static void main(String[] ars){
//生成一个可关闭的HTTP浏览器（相当于）
CloseableHttpClient httpClient= HttpClients.createDefault();
CloseableHttpResponse response=null;
HttpGet httpGet=null;
try {
URIBuilder uriBuilder=new URIBuilder("http://baidu.com";);
//写入参数 (可以设置多参数）
uriBuilder.setParameter("key","JAVA");
uriBuilder.setParameter("keys","c#");
System.out.println(uriBuilder.build());
//创建http Get请求
httpGet=new HttpGet(uriBuilder.build());//使用builder写入URI
} catch (URISyntaxException e) {
e.printStackTrace();
}
//设置请求头，UA浏览器型号，模拟火狐浏览器
httpGet.setHeader("User-Agent","Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:74.0) Gecko/20100101 Firefox/74.0");
try {
response=httpClient.execute(httpGet);//执行
//获取当响应状态
// response.getStatusLine();//获取当前状态
//response.getStatusLine().getStatusCode() 获取当前状态码
System.out.println("Status:"+response.getStatusLine().getStatusCode());
//获取网页源码
HttpEntity entity=response.getEntity();//获取网页实体
//获取目标类型
System.out.println("ContentType："+entity.getContentType().getValue());
System.out.println(EntityUtils.toString(entity,"UTF-8"));
} catch (IOException e) {
e.printStackTrace();
}
//关闭HTTp
try {
response.close();
httpClient.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
httpclient 抓取网页(java是一种可以撰写跨平台应用软件的程序设计语言和Java平台 )
网站优化 • 优采云 发表了文章 • 0 个评论 • 85 次浏览 • 2021-10-27 00:15
httpclient 抓取网页(java是一种可以撰写跨平台应用软件的程序设计语言和Java平台
)
Java 是一种面向对象的编程语言，可以编写跨平台的应用软件。是1995年5月推出的Java编程语言和Java平台（即JavaEE、JavaME、JavaSE）的总称。 本站提供基于Java框架struts、spring、hibernate的桌面应用、Web交互和移动端开发技巧和资料等
保持永久学习的心态，你会成为一个优秀的自己，继续从事java知识。
直接上代码，代码中有详细注释
1import org.apache.commons.httpclient.Cookie;
import org.apache.commons.httpclient.Header;
import org.apache.commons.httpclient.HttpClient;
import org.apache.commons.httpclient.NameValuePair;
import org.apache.commons.httpclient.methods.GetMethod;
import org.apache.commons.httpclient.methods.PostMethod;
import org.apache.commons.httpclient.params.HttpMethodParams;
public class test {
public static void main(String[] args) {
try {
// 先访问首页，得到cookie
// cookie信息自动保存在HttpClient中
HttpClient httpClient = new HttpClient();
PostMethod postMethod = new PostMethod("http://1.lexury2016.sinaapp.com/login");
httpClient.executeMethod(postMethod);
// 携带cookie访问登录网面
postMethod = new PostMethod("http://1.lexury2016.sinaapp.com/login");
// 设置登录的账号与密码
NameValuePair[] nameValuePairs = { new NameValuePair("stucid", "2013150091"),
new NameValuePair("stupassword", "ab1234") };
postMethod.setRequestBody(nameValuePairs);
// 设置请求编码为UTF-8
postMethod.getParams().setParameter(HttpMethodParams.HTTP_CONTENT_CHARSET, "UTF-8");
// httpclient访问登录网页
httpClient.executeMethod(postMethod);
// 得到响应文本
byte[] bytes = postMethod.getResponseBody();
String html = new String(bytes);
System.out.println(postMethod.getStatusCode());
// 输出为302，也就是说网页发生了重定向
// 得到重定向后的网页
Header redirect = postMethod.getResponseHeader("location");
String url = redirect.getValue();
// 使用get请求，访问登陆后的页面
GetMethod getMethod = new GetMethod(url);
httpClient.executeMethod(getMethod);
// 得到返回文本
bytes = getMethod.getResponseBody();
html = new String(bytes);
System.out.println(html);
} catch (Exception e) {
e.printStackTrace();
}
}
} 查看全部
)
Java 是一种面向对象的编程语言，可以编写跨平台的应用软件。是1995年5月推出的Java编程语言和Java平台（即JavaEE、JavaME、JavaSE）的总称。 本站提供基于Java框架struts、spring、hibernate的桌面应用、Web交互和移动端开发技巧和资料等
保持永久学习的心态，你会成为一个优秀的自己，继续从事java知识。
直接上代码，代码中有详细注释
1import org.apache.commons.httpclient.Cookie;
import org.apache.commons.httpclient.Header;
import org.apache.commons.httpclient.HttpClient;
import org.apache.commons.httpclient.NameValuePair;
import org.apache.commons.httpclient.methods.GetMethod;
import org.apache.commons.httpclient.methods.PostMethod;
import org.apache.commons.httpclient.params.HttpMethodParams;
public class test {
public static void main(String[] args) {
try {
// 先访问首页，得到cookie
// cookie信息自动保存在HttpClient中
HttpClient httpClient = new HttpClient();
PostMethod postMethod = new PostMethod("http://1.lexury2016.sinaapp.com/login");
httpClient.executeMethod(postMethod);
// 携带cookie访问登录网面
postMethod = new PostMethod("http://1.lexury2016.sinaapp.com/login");
// 设置登录的账号与密码
NameValuePair[] nameValuePairs = { new NameValuePair("stucid", "2013150091"),
new NameValuePair("stupassword", "ab1234") };
postMethod.setRequestBody(nameValuePairs);
// 设置请求编码为UTF-8
postMethod.getParams().setParameter(HttpMethodParams.HTTP_CONTENT_CHARSET, "UTF-8");
// httpclient访问登录网页
httpClient.executeMethod(postMethod);
// 得到响应文本
byte[] bytes = postMethod.getResponseBody();
String html = new String(bytes);
System.out.println(postMethod.getStatusCode());
// 输出为302，也就是说网页发生了重定向
// 得到重定向后的网页
Header redirect = postMethod.getResponseHeader("location");
String url = redirect.getValue();
// 使用get请求，访问登陆后的页面
GetMethod getMethod = new GetMethod(url);
httpClient.executeMethod(getMethod);
// 得到返回文本
bytes = getMethod.getResponseBody();
html = new String(bytes);
System.out.println(html);
} catch (Exception e) {
e.printStackTrace();
}
}
} 查看全部
httpclient 抓取网页(java是一种可以撰写跨平台应用软件的程序设计语言和Java平台
)
Java 是一种面向对象的编程语言，可以编写跨平台的应用软件。是1995年5月推出的Java编程语言和Java平台（即JavaEE、JavaME、JavaSE）的总称。 本站提供基于Java框架struts、spring、hibernate的桌面应用、Web交互和移动端开发技巧和资料等
保持永久学习的心态，你会成为一个优秀的自己，继续从事java知识。
直接上代码，代码中有详细注释
1import org.apache.commons.httpclient.Cookie;
import org.apache.commons.httpclient.Header;
import org.apache.commons.httpclient.HttpClient;
import org.apache.commons.httpclient.NameValuePair;
import org.apache.commons.httpclient.methods.GetMethod;
import org.apache.commons.httpclient.methods.PostMethod;
import org.apache.commons.httpclient.params.HttpMethodParams;
public class test {
public static void main(String[] args) {
try {
// 先访问首页，得到cookie
// cookie信息自动保存在HttpClient中
HttpClient httpClient = new HttpClient();
PostMethod postMethod = new PostMethod("http://1.lexury2016.sinaapp.com/login";);
httpClient.executeMethod(postMethod);
// 携带cookie访问登录网面
postMethod = new PostMethod("http://1.lexury2016.sinaapp.com/login";);
// 设置登录的账号与密码
NameValuePair[] nameValuePairs = { new NameValuePair("stucid", "2013150091"),
new NameValuePair("stupassword", "ab1234") };
postMethod.setRequestBody(nameValuePairs);
// 设置请求编码为UTF-8
postMethod.getParams().setParameter(HttpMethodParams.HTTP_CONTENT_CHARSET, "UTF-8");
// httpclient访问登录网页
httpClient.executeMethod(postMethod);
// 得到响应文本
byte[] bytes = postMethod.getResponseBody();
String html = new String(bytes);
System.out.println(postMethod.getStatusCode());
// 输出为302，也就是说网页发生了重定向
// 得到重定向后的网页
Header redirect = postMethod.getResponseHeader("location");
String url = redirect.getValue();
// 使用get请求，访问登陆后的页面
GetMethod getMethod = new GetMethod(url);
httpClient.executeMethod(getMethod);
// 得到返回文本
bytes = getMethod.getResponseBody();
html = new String(bytes);
System.out.println(html);
} catch (Exception e) {
e.printStackTrace();
}
}
}
httpclient 抓取网页(STM32 )
网站优化 • 优采云 发表了文章 • 0 个评论 • 75 次浏览 • 2021-10-15 08:19
httpclient 抓取网页(STM32
)
1、GET 方法
第一步是创建一个客户端，类似于用浏览器打开一个网页
HttpClient httpClient = new HttpClient();
第二步是创建一个GET方法来获取你需要爬取的网页的网址
GetMethod getMethod = new GetMethod("");
第三步，获取URL的响应状态码，200表示请求成功
int statusCode = httpClient.executeMethod(getMethod);
第四步，获取网页源代码
byte[] responseBody = getMethod.getResponseBody();
主要就是这四个步骤，当然还有很多其他的，比如网页编码的问题
HttpClient httpClient = new HttpClient();
GetMethod getMethod = new GetMethod("http://www.baidu.com/");
try {
int statusCode = httpClient.executeMethod(getMethod);
if (statusCode != HttpStatus.SC_OK) {
System.err.println("Method failed: "
+ getMethod.getStatusLine());
}
// 读取内容
byte[] responseBody = getMethod.getResponseBody();
// 处理内容
String html = new String(responseBody);
System.out.println(html);
} catch (Exception e) {
System.err.println("页面无法访问");
}finally{
getMethod.releaseConnection();
}
2、发布方式
HttpClient httpClient = new HttpClient();
PostMethod postMethod = new PostMethod(UrlPath);
postMethod.getParams().setParameter(HttpMethodParams.RETRY_HANDLER,new DefaultHttpMethodRetryHandler());
NameValuePair[] postData = new NameValuePair[2];
postData[0] = new NameValuePair("username", "xkey");
postData[1] = new NameValuePair("userpass", "********");
postMethod.setRequestBody(postData);
try {
int statusCode = httpClient.executeMethod(postMethod);
if (statusCode == HttpStatus.SC_OK) {
byte[] responseBody = postMethod.getResponseBody();
String html = new String(responseBody);
System.out.println(html);
}
} catch (Exception e) {
System.err.println("页面无法访问");
}finally{
postMethod.releaseConnection();
}
本例传递两个Post参数：username为xkey，userpass为*******，并传递给URL UrlPath
如需了解获取gzip网页的信息，请参考
另一种是获取非字符数据，所以可以使用下面的方法
HttpClient httpClient = new HttpClient();
GetMethod getMethod = new GetMethod("http://www.baidu.com");
try {
InputStream inputStream = getMethod.getResponseBodyAsStream();
// 这里处理 inputStream
} catch (Exception e) {
System.err.println("页面无法访问");
}finally{
getMethod.releaseConnection();
} 查看全部
)
1、GET 方法
第一步是创建一个客户端，类似于用浏览器打开一个网页
HttpClient httpClient = new HttpClient();
第二步是创建一个GET方法来获取你需要爬取的网页的网址
GetMethod getMethod = new GetMethod("");
第三步，获取URL的响应状态码，200表示请求成功
int statusCode = httpClient.executeMethod(getMethod);
第四步，获取网页源代码
byte[] responseBody = getMethod.getResponseBody();
主要就是这四个步骤，当然还有很多其他的，比如网页编码的问题
HttpClient httpClient = new HttpClient();
GetMethod getMethod = new GetMethod("http://www.baidu.com/");
try {
int statusCode = httpClient.executeMethod(getMethod);
if (statusCode != HttpStatus.SC_OK) {
System.err.println("Method failed: "
+ getMethod.getStatusLine());
}
// 读取内容
byte[] responseBody = getMethod.getResponseBody();
// 处理内容
String html = new String(responseBody);
System.out.println(html);
} catch (Exception e) {
System.err.println("页面无法访问");
}finally{
getMethod.releaseConnection();
}
2、发布方式
HttpClient httpClient = new HttpClient();
PostMethod postMethod = new PostMethod(UrlPath);
postMethod.getParams().setParameter(HttpMethodParams.RETRY_HANDLER,new DefaultHttpMethodRetryHandler());
NameValuePair[] postData = new NameValuePair[2];
postData[0] = new NameValuePair("username", "xkey");
postData[1] = new NameValuePair("userpass", "********");
postMethod.setRequestBody(postData);
try {
int statusCode = httpClient.executeMethod(postMethod);
if (statusCode == HttpStatus.SC_OK) {
byte[] responseBody = postMethod.getResponseBody();
String html = new String(responseBody);
System.out.println(html);
}
} catch (Exception e) {
System.err.println("页面无法访问");
}finally{
postMethod.releaseConnection();
}
本例传递两个Post参数：username为xkey，userpass为*******，并传递给URL UrlPath
如需了解获取gzip网页的信息，请参考
另一种是获取非字符数据，所以可以使用下面的方法
HttpClient httpClient = new HttpClient();
GetMethod getMethod = new GetMethod("http://www.baidu.com");
try {
InputStream inputStream = getMethod.getResponseBodyAsStream();
// 这里处理 inputStream
} catch (Exception e) {
System.err.println("页面无法访问");
}finally{
getMethod.releaseConnection();
} 查看全部
httpclient 抓取网页(STM32
)
1、GET 方法
第一步是创建一个客户端，类似于用浏览器打开一个网页
HttpClient httpClient = new HttpClient();
第二步是创建一个GET方法来获取你需要爬取的网页的网址
GetMethod getMethod = new GetMethod("");
第三步，获取URL的响应状态码，200表示请求成功
int statusCode = httpClient.executeMethod(getMethod);
第四步，获取网页源代码
byte[] responseBody = getMethod.getResponseBody();
主要就是这四个步骤，当然还有很多其他的，比如网页编码的问题
HttpClient httpClient = new HttpClient();
GetMethod getMethod = new GetMethod("http://www.baidu.com/";);
try {
int statusCode = httpClient.executeMethod(getMethod);
if (statusCode != HttpStatus.SC_OK) {
System.err.println("Method failed: "
+ getMethod.getStatusLine());
}
// 读取内容
byte[] responseBody = getMethod.getResponseBody();
// 处理内容
String html = new String(responseBody);
System.out.println(html);
} catch (Exception e) {
System.err.println("页面无法访问");
}finally{
getMethod.releaseConnection();
}
2、发布方式
HttpClient httpClient = new HttpClient();
PostMethod postMethod = new PostMethod(UrlPath);
postMethod.getParams().setParameter(HttpMethodParams.RETRY_HANDLER,new DefaultHttpMethodRetryHandler());
NameValuePair[] postData = new NameValuePair[2];
postData[0] = new NameValuePair("username", "xkey");
postData[1] = new NameValuePair("userpass", "********");
postMethod.setRequestBody(postData);
try {
int statusCode = httpClient.executeMethod(postMethod);
if (statusCode == HttpStatus.SC_OK) {
byte[] responseBody = postMethod.getResponseBody();
String html = new String(responseBody);
System.out.println(html);
}
} catch (Exception e) {
System.err.println("页面无法访问");
}finally{
postMethod.releaseConnection();
}
本例传递两个Post参数：username为xkey，userpass为*******，并传递给URL UrlPath
如需了解获取gzip网页的信息，请参考
另一种是获取非字符数据，所以可以使用下面的方法
HttpClient httpClient = new HttpClient();
GetMethod getMethod = new GetMethod("http://www.baidu.com";);
try {
InputStream inputStream = getMethod.getResponseBodyAsStream();
// 这里处理 inputStream
} catch (Exception e) {
System.err.println("页面无法访问");
}finally{
getMethod.releaseConnection();
}
httpclient 抓取网页(2021-05-24欢迎访问我的个人网站-广州图书馆)
网站优化 • 优采云 发表了文章 • 0 个评论 • 57 次浏览 • 2022-04-19 19:18
httpclient 抓取网页(2021-05-24欢迎访问我的个人网站-广州图书馆)
2021-05-24
欢迎来到我的个人网站，如果能在GitHub上给网站的源码打个star就更好了。
在构建自己的网站时，我想记录我读过和借过的所有书。大学也爬过自己学校的借阅记录，但是数据库已经被删除了==，只有一张截图。所以你要珍惜你阅读的日子，记录你的借阅记录——广州图书馆，现在代码已经放到服务器上定期运行，结果查看我的网站（关于我）页面。整个代码使用HttpClient，存储在MySql中，定期使用Spring自带的Schedule。下面是爬取的过程。
1.页面跳转过程
一般是进入首页，点击进入登录页面，然后输入账号密码。从表面上看，它似乎并没有什么特别之处。事实上，在模拟登录的时候，并不仅仅是向链接发布请求那么简单。生成的响应将跳转回登录页面或无限制地重定向。
其实就是做单点登录的，如下图，广州图书馆的网址是：，登录的网址是：。网上很多人都很好的解释了原理。您可以阅读此 文章SSO 单点登录。
2.处理方式
解决方法不难，只要先模拟访问首页获取库的session，python获取代码如：session.get("")，打印cookie后如下：
[, , ]
整个登录和抓取过程如下：
这是：
（1）用户先点击广州图书馆首页，获取换站session，然后点击登录界面，解析html，获取lt（自定义参数，类似验证码），单点登录服务器会话。
(2）向目标服务器（单点登录服务器）提交post请求，请求参数包括username（用户名）、password（密码）、event（时间，默认为submit）、lt（自定义request parameters) ，服务器还需要对参数进行校验：refer（源页面）、host（主机信息）、Content-Type（类型）。
(3）打印响应，搜索自己的名字，如果有则表示成功，否则会跳转回登录页面。
(4）使用cookies访问其他页面，这里是借阅历史的爬取，所以访问的页面是：.
这是基本的模拟登录和获取，然后是对面的html的解析，得到书名、书索引等，然后封装成JavaBean，然后存入数据库。（没做过，不知道用什么方法比较好）
3.代码
3.1 在Java中，大部分的httpclients一般都是用来提交http请求的。一、需要导入的httpclient相关包：
org.apache.httpcomponents
httpclient
4.5.3
org.apache.httpcomponents
httpcore
4.4.7
3.2 构建和声明全局变量——上下文管理器，其中context是上下文管理器
public class LibraryUtil {
private static CloseableHttpClient httpClient = null;
private static HttpClientContext context = null;
private static CookieStore cookieStore = null;
static {
init();
}
private static void init() {
context = HttpClientContext.create();
cookieStore = new BasicCookieStore();
// 配置超时时间
RequestConfig requestConfig = RequestConfig.custom().setConnectTimeout(12000).setSocketTimeout(6000)
.setConnectionRequestTimeout(6000).build();
// 设置默认跳转以及存储cookie
httpClient = HttpClientBuilder.create()
.setKeepAliveStrategy(new DefaultConnectionKeepAliveStrategy())
.setRedirectStrategy(new DefaultRedirectStrategy()).setDefaultRequestConfig(requestConfig)
.setDefaultCookieStore(cookieStore).build();
}
...
3.3 声明一个get函数，其中header可以自定义，这里不需要，但保留它，使其成为通用的。
public static CloseableHttpResponse get(String url, Header[] header) throws IOException {
HttpGet httpget = new HttpGet(url);
if (header != null && header.length > 0) {
httpget.setHeaders(header);
}
CloseableHttpResponse response = httpClient.execute(httpget, context);//context用于存储上下文
return response;
}
3.4 访问主页获取会话。服务器上的session是按session存储的，本地浏览器使用cookies。只要本地不注销，也可以使用本地cookie访问，但是为了达到模拟登录的效果，这里不再赘述。
CloseableHttpResponse homeResponse = get("http://www.gzlib.gov.cn/", null);
homeResponse.close();
此时如果打印cookie，可以看到当前cookie如下：
3.5 访问登录页面，获取单点登录服务器后的cookie，解析网页，获取自定义参数lt。这里的解析网页使用的是Jsoup，语法类似于python中的BeautifulSoup。
String loginURL = "http://login.gzlib.gov.cn/sso- ... 3B%3B
CloseableHttpResponse loginGetResponse = get(loginURL, null);
String content = toString(loginGetResponse);
String lt = Jsoup.parse(content).select("form").select("input[name=lt]").attr("value");
loginGetResponse.close();
此时再看cookie，又多了一个（）：
3.6 声明一个post函数来提交一个post请求，这里提交的参数默认为
public static CloseableHttpResponse postParam(String url, String parameters, Header[] headers)
throws IOException {
System.out.println(parameters);
HttpPost httpPost = new HttpPost(url);
if (headers != null && headers.length > 0) {
for (Header header : headers) {
httpPost.addHeader(header);
}
}
List nvps = toNameValuePairList(parameters);
httpPost.setEntity(new UrlEncodedFormEntity(nvps, "UTF-8"));
CloseableHttpResponse response = httpClient.execute(httpPost, context);
return response;
}
3.7 登录成功后，如果没有声明returnurl，即登录链接为()，那么只会显示登录成功页面：
后台应该定义一个链接跳转的服务。如果想在登录成功后得到跳转页面，可以在服务后修改链接，这里会保持原来的状态。此时查看cookie的结果如下：
其中，CASTGC的出现说明登录成功，该cookie可用于访问广州图书馆的其他页面。在python中是直接跳转到其他页面，但是在java中使用httpclient的过程中，看到的并不是直接跳转。，但 302 重定向。打印Header后，结果如下：
如果你仔细研究一下链接，你会发现服务器相当于给了一张通用票，即：你可以用这张票访问任何页面，returnUrl 就是返回的页面。这里我们直接访问重定向的 url。
Header header = response.getHeaders("Location")[0];
CloseableHttpResponse home = get(header.getValue(), null);
然后打印页面得到登录后跳转回的首页。
3.8 解析html
获取session并跳转回首页后，访问借阅历史页面，然后将结果解析为html。在python中使用了BeautifulSoup，简单实用，java中的jsoup也是不错的选择。
String html = getHTML();
Element element = Jsoup.parse(html).select("table.jieyue-table").get(0).select("tbody").get(0);
Elements trs = element.select("tr");
for (int i = 0; i < trs.size(); i++) {
Elements tds = trs.get(i).select("td");
System.out.println(tds.get(1).text());
}
输出结果：
企业IT架构转型之道
大话Java性能优化
深入理解Hadoop
大话Java性能优化
Java EE开发的颠覆者：Spring Boot实战
大型网站技术架构：核心原理与案例分析
Java性能权威指南
Akka入门与实践
高性能网站建设进阶指南：Web开发者性能优化最佳实践：Performance best practices for Web developers
Java EE开发的颠覆者：Spring Boot实战
深入理解Hadoop
大话Java性能优化
点击查看源代码
总结
目前修改后的代码已经集成到个人网站中，每天定时抓取，但是还有很多事情没有做（比如分页、去重等），如果你有兴趣的可以研究下源码，如果能帮助改进就更好了。谢谢♪(･ω･)ﾉ。整个代码接近250行，当然……包括注释，但是使用python后，只有25行=w=，这里是python的源代码。同时也欢迎大家访问我的个人网站，也欢迎大家给个star。
import urllib.parse
import requests
from bs4 import BeautifulSoup
session = requests.session()
session.get("http://www.gzlib.gov.cn/")
session.headers.update(
{"Referer": "http://www.gzlib.gov.cn/member ... ot%3B,
"origin": "http://login.gzlib.gov.cn",
'Content-Type': 'application/x-www-form-urlencoded',
'host': 'www.gzlib.gov.cn',
'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/50.0.2661.102 Safari/537.36'
}
)
baseURL = "http://login.gzlib.gov.cn/sso-server/login"
soup = BeautifulSoup(session.get(baseURL).text, "html.parser")
lt = soup.select("form")[0].find(attrs={'name': 'lt'})['value']
postdict = {"username": "你的身份证",
"password": "密码（默认为身份证后6位）",
"_eventId": "submit",
"lt": lt
}
postdata = urllib.parse.urlencode(postdict)
session.post(baseURL, postdata)
print(session.get("http://www.gzlib.gov.cn/member ... 6quot;).text)
分类：
技术要点：
相关文章： 查看全部
2021-05-24
欢迎来到我的个人网站，如果能在GitHub上给网站的源码打个star就更好了。
在构建自己的网站时，我想记录我读过和借过的所有书。大学也爬过自己学校的借阅记录，但是数据库已经被删除了==，只有一张截图。所以你要珍惜你阅读的日子，记录你的借阅记录——广州图书馆，现在代码已经放到服务器上定期运行，结果查看我的网站（关于我）页面。整个代码使用HttpClient，存储在MySql中，定期使用Spring自带的Schedule。下面是爬取的过程。
1.页面跳转过程
一般是进入首页，点击进入登录页面，然后输入账号密码。从表面上看，它似乎并没有什么特别之处。事实上，在模拟登录的时候，并不仅仅是向链接发布请求那么简单。生成的响应将跳转回登录页面或无限制地重定向。
其实就是做单点登录的，如下图，广州图书馆的网址是：，登录的网址是：。网上很多人都很好的解释了原理。您可以阅读此 文章SSO 单点登录。
2.处理方式
解决方法不难，只要先模拟访问首页获取库的session，python获取代码如：session.get("")，打印cookie后如下：
[, , ]
整个登录和抓取过程如下：
这是：
（1）用户先点击广州图书馆首页，获取换站session，然后点击登录界面，解析html，获取lt（自定义参数，类似验证码），单点登录服务器会话。
(2）向目标服务器（单点登录服务器）提交post请求，请求参数包括username（用户名）、password（密码）、event（时间，默认为submit）、lt（自定义request parameters) ，服务器还需要对参数进行校验：refer（源页面）、host（主机信息）、Content-Type（类型）。
(3）打印响应，搜索自己的名字，如果有则表示成功，否则会跳转回登录页面。
(4）使用cookies访问其他页面，这里是借阅历史的爬取，所以访问的页面是：.
这是基本的模拟登录和获取，然后是对面的html的解析，得到书名、书索引等，然后封装成JavaBean，然后存入数据库。（没做过，不知道用什么方法比较好）
3.代码
3.1 在Java中，大部分的httpclients一般都是用来提交http请求的。一、需要导入的httpclient相关包：
org.apache.httpcomponents
httpclient
4.5.3
org.apache.httpcomponents
httpcore
4.4.7
3.2 构建和声明全局变量——上下文管理器，其中context是上下文管理器
public class LibraryUtil {
private static CloseableHttpClient httpClient = null;
private static HttpClientContext context = null;
private static CookieStore cookieStore = null;
static {
init();
}
private static void init() {
context = HttpClientContext.create();
cookieStore = new BasicCookieStore();
// 配置超时时间
RequestConfig requestConfig = RequestConfig.custom().setConnectTimeout(12000).setSocketTimeout(6000)
.setConnectionRequestTimeout(6000).build();
// 设置默认跳转以及存储cookie
httpClient = HttpClientBuilder.create()
.setKeepAliveStrategy(new DefaultConnectionKeepAliveStrategy())
.setRedirectStrategy(new DefaultRedirectStrategy()).setDefaultRequestConfig(requestConfig)
.setDefaultCookieStore(cookieStore).build();
}
...
3.3 声明一个get函数，其中header可以自定义，这里不需要，但保留它，使其成为通用的。
public static CloseableHttpResponse get(String url, Header[] header) throws IOException {
HttpGet httpget = new HttpGet(url);
if (header != null && header.length > 0) {
httpget.setHeaders(header);
}
CloseableHttpResponse response = httpClient.execute(httpget, context);//context用于存储上下文
return response;
}
3.4 访问主页获取会话。服务器上的session是按session存储的，本地浏览器使用cookies。只要本地不注销，也可以使用本地cookie访问，但是为了达到模拟登录的效果，这里不再赘述。
CloseableHttpResponse homeResponse = get("http://www.gzlib.gov.cn/", null);
homeResponse.close();
此时如果打印cookie，可以看到当前cookie如下：
3.5 访问登录页面，获取单点登录服务器后的cookie，解析网页，获取自定义参数lt。这里的解析网页使用的是Jsoup，语法类似于python中的BeautifulSoup。
String loginURL = "http://login.gzlib.gov.cn/sso- ... 3B%3B
CloseableHttpResponse loginGetResponse = get(loginURL, null);
String content = toString(loginGetResponse);
String lt = Jsoup.parse(content).select("form").select("input[name=lt]").attr("value");
loginGetResponse.close();
此时再看cookie，又多了一个（）：
3.6 声明一个post函数来提交一个post请求，这里提交的参数默认为
public static CloseableHttpResponse postParam(String url, String parameters, Header[] headers)
throws IOException {
System.out.println(parameters);
HttpPost httpPost = new HttpPost(url);
if (headers != null && headers.length > 0) {
for (Header header : headers) {
httpPost.addHeader(header);
}
}
List nvps = toNameValuePairList(parameters);
httpPost.setEntity(new UrlEncodedFormEntity(nvps, "UTF-8"));
CloseableHttpResponse response = httpClient.execute(httpPost, context);
return response;
}
3.7 登录成功后，如果没有声明returnurl，即登录链接为()，那么只会显示登录成功页面：
后台应该定义一个链接跳转的服务。如果想在登录成功后得到跳转页面，可以在服务后修改链接，这里会保持原来的状态。此时查看cookie的结果如下：
其中，CASTGC的出现说明登录成功，该cookie可用于访问广州图书馆的其他页面。在python中是直接跳转到其他页面，但是在java中使用httpclient的过程中，看到的并不是直接跳转。，但 302 重定向。打印Header后，结果如下：
如果你仔细研究一下链接，你会发现服务器相当于给了一张通用票，即：你可以用这张票访问任何页面，returnUrl 就是返回的页面。这里我们直接访问重定向的 url。
Header header = response.getHeaders("Location")[0];
CloseableHttpResponse home = get(header.getValue(), null);
然后打印页面得到登录后跳转回的首页。
3.8 解析html
获取session并跳转回首页后，访问借阅历史页面，然后将结果解析为html。在python中使用了BeautifulSoup，简单实用，java中的jsoup也是不错的选择。
String html = getHTML();
Element element = Jsoup.parse(html).select("table.jieyue-table").get(0).select("tbody").get(0);
Elements trs = element.select("tr");
for (int i = 0; i < trs.size(); i++) {
Elements tds = trs.get(i).select("td");
System.out.println(tds.get(1).text());
}
输出结果：
企业IT架构转型之道
大话Java性能优化
深入理解Hadoop
大话Java性能优化
Java EE开发的颠覆者：Spring Boot实战
大型网站技术架构：核心原理与案例分析
Java性能权威指南
Akka入门与实践
高性能网站建设进阶指南：Web开发者性能优化最佳实践：Performance best practices for Web developers
Java EE开发的颠覆者：Spring Boot实战
深入理解Hadoop
大话Java性能优化
点击查看源代码
总结
目前修改后的代码已经集成到个人网站中，每天定时抓取，但是还有很多事情没有做（比如分页、去重等），如果你有兴趣的可以研究下源码，如果能帮助改进就更好了。谢谢♪(･ω･)ﾉ。整个代码接近250行，当然……包括注释，但是使用python后，只有25行=w=，这里是python的源代码。同时也欢迎大家访问我的个人网站，也欢迎大家给个star。
import urllib.parse
import requests
from bs4 import BeautifulSoup
session = requests.session()
session.get("http://www.gzlib.gov.cn/")
session.headers.update(
{"Referer": "http://www.gzlib.gov.cn/member ... ot%3B,
"origin": "http://login.gzlib.gov.cn",
'Content-Type': 'application/x-www-form-urlencoded',
'host': 'www.gzlib.gov.cn',
'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/50.0.2661.102 Safari/537.36'
}
)
baseURL = "http://login.gzlib.gov.cn/sso-server/login"
soup = BeautifulSoup(session.get(baseURL).text, "html.parser")
lt = soup.select("form")[0].find(attrs={'name': 'lt'})['value']
postdict = {"username": "你的身份证",
"password": "密码（默认为身份证后6位）",
"_eventId": "submit",
"lt": lt
}
postdata = urllib.parse.urlencode(postdict)
session.post(baseURL, postdata)
print(session.get("http://www.gzlib.gov.cn/member ... 6quot;).text)
分类：
技术要点：
相关文章： 查看全部
httpclient 抓取网页(2021-05-24欢迎访问我的个人网站-广州图书馆)
2021-05-24
欢迎来到我的个人网站，如果能在GitHub上给网站的源码打个star就更好了。
在构建自己的网站时，我想记录我读过和借过的所有书。大学也爬过自己学校的借阅记录，但是数据库已经被删除了==，只有一张截图。所以你要珍惜你阅读的日子，记录你的借阅记录——广州图书馆，现在代码已经放到服务器上定期运行，结果查看我的网站（关于我）页面。整个代码使用HttpClient，存储在MySql中，定期使用Spring自带的Schedule。下面是爬取的过程。
1.页面跳转过程
一般是进入首页，点击进入登录页面，然后输入账号密码。从表面上看，它似乎并没有什么特别之处。事实上，在模拟登录的时候，并不仅仅是向链接发布请求那么简单。生成的响应将跳转回登录页面或无限制地重定向。
其实就是做单点登录的，如下图，广州图书馆的网址是：，登录的网址是：。网上很多人都很好的解释了原理。您可以阅读此 文章SSO 单点登录。
2.处理方式
解决方法不难，只要先模拟访问首页获取库的session，python获取代码如：session.get("")，打印cookie后如下：
[, , ]
整个登录和抓取过程如下：
这是：
（1）用户先点击广州图书馆首页，获取换站session，然后点击登录界面，解析html，获取lt（自定义参数，类似验证码），单点登录服务器会话。
(2）向目标服务器（单点登录服务器）提交post请求，请求参数包括username（用户名）、password（密码）、event（时间，默认为submit）、lt（自定义request parameters) ，服务器还需要对参数进行校验：refer（源页面）、host（主机信息）、Content-Type（类型）。
(3）打印响应，搜索自己的名字，如果有则表示成功，否则会跳转回登录页面。
(4）使用cookies访问其他页面，这里是借阅历史的爬取，所以访问的页面是：.
这是基本的模拟登录和获取，然后是对面的html的解析，得到书名、书索引等，然后封装成JavaBean，然后存入数据库。（没做过，不知道用什么方法比较好）
3.代码
3.1 在Java中，大部分的httpclients一般都是用来提交http请求的。一、需要导入的httpclient相关包：
org.apache.httpcomponents
httpclient
4.5.3
org.apache.httpcomponents
httpcore
4.4.7
3.2 构建和声明全局变量——上下文管理器，其中context是上下文管理器
public class LibraryUtil {
private static CloseableHttpClient httpClient = null;
private static HttpClientContext context = null;
private static CookieStore cookieStore = null;
static {
init();
}
private static void init() {
context = HttpClientContext.create();
cookieStore = new BasicCookieStore();
// 配置超时时间
RequestConfig requestConfig = RequestConfig.custom().setConnectTimeout(12000).setSocketTimeout(6000)
.setConnectionRequestTimeout(6000).build();
// 设置默认跳转以及存储cookie
httpClient = HttpClientBuilder.create()
.setKeepAliveStrategy(new DefaultConnectionKeepAliveStrategy())
.setRedirectStrategy(new DefaultRedirectStrategy()).setDefaultRequestConfig(requestConfig)
.setDefaultCookieStore(cookieStore).build();
}
...
3.3 声明一个get函数，其中header可以自定义，这里不需要，但保留它，使其成为通用的。
public static CloseableHttpResponse get(String url, Header[] header) throws IOException {
HttpGet httpget = new HttpGet(url);
if (header != null && header.length > 0) {
httpget.setHeaders(header);
}
CloseableHttpResponse response = httpClient.execute(httpget, context);//context用于存储上下文
return response;
}
3.4 访问主页获取会话。服务器上的session是按session存储的，本地浏览器使用cookies。只要本地不注销，也可以使用本地cookie访问，但是为了达到模拟登录的效果，这里不再赘述。
CloseableHttpResponse homeResponse = get("http://www.gzlib.gov.cn/", null);
homeResponse.close();
此时如果打印cookie，可以看到当前cookie如下：
3.5 访问登录页面，获取单点登录服务器后的cookie，解析网页，获取自定义参数lt。这里的解析网页使用的是Jsoup，语法类似于python中的BeautifulSoup。
String loginURL = "http://login.gzlib.gov.cn/sso- ... 3B%3B
CloseableHttpResponse loginGetResponse = get(loginURL, null);
String content = toString(loginGetResponse);
String lt = Jsoup.parse(content).select("form").select("input[name=lt]").attr("value");
loginGetResponse.close();
此时再看cookie，又多了一个（）：
3.6 声明一个post函数来提交一个post请求，这里提交的参数默认为
public static CloseableHttpResponse postParam(String url, String parameters, Header[] headers)
throws IOException {
System.out.println(parameters);
HttpPost httpPost = new HttpPost(url);
if (headers != null && headers.length > 0) {
for (Header header : headers) {
httpPost.addHeader(header);
}
}
List nvps = toNameValuePairList(parameters);
httpPost.setEntity(new UrlEncodedFormEntity(nvps, "UTF-8"));
CloseableHttpResponse response = httpClient.execute(httpPost, context);
return response;
}
3.7 登录成功后，如果没有声明returnurl，即登录链接为()，那么只会显示登录成功页面：
后台应该定义一个链接跳转的服务。如果想在登录成功后得到跳转页面，可以在服务后修改链接，这里会保持原来的状态。此时查看cookie的结果如下：
其中，CASTGC的出现说明登录成功，该cookie可用于访问广州图书馆的其他页面。在python中是直接跳转到其他页面，但是在java中使用httpclient的过程中，看到的并不是直接跳转。，但 302 重定向。打印Header后，结果如下：
如果你仔细研究一下链接，你会发现服务器相当于给了一张通用票，即：你可以用这张票访问任何页面，returnUrl 就是返回的页面。这里我们直接访问重定向的 url。
Header header = response.getHeaders("Location")[0];
CloseableHttpResponse home = get(header.getValue(), null);
然后打印页面得到登录后跳转回的首页。
3.8 解析html
获取session并跳转回首页后，访问借阅历史页面，然后将结果解析为html。在python中使用了BeautifulSoup，简单实用，java中的jsoup也是不错的选择。
String html = getHTML();
Element element = Jsoup.parse(html).select("table.jieyue-table").get(0).select("tbody").get(0);
Elements trs = element.select("tr");
for (int i = 0; i < trs.size(); i++) {
Elements tds = trs.get(i).select("td");
System.out.println(tds.get(1).text());
}
输出结果：
企业IT架构转型之道
大话Java性能优化
深入理解Hadoop
大话Java性能优化
Java EE开发的颠覆者：Spring Boot实战
大型网站技术架构：核心原理与案例分析
Java性能权威指南
Akka入门与实践
高性能网站建设进阶指南：Web开发者性能优化最佳实践：Performance best practices for Web developers
Java EE开发的颠覆者：Spring Boot实战
深入理解Hadoop
大话Java性能优化
点击查看源代码
总结
目前修改后的代码已经集成到个人网站中，每天定时抓取，但是还有很多事情没有做（比如分页、去重等），如果你有兴趣的可以研究下源码，如果能帮助改进就更好了。谢谢♪(･ω･)ﾉ。整个代码接近250行，当然……包括注释，但是使用python后，只有25行=w=，这里是python的源代码。同时也欢迎大家访问我的个人网站，也欢迎大家给个star。
import urllib.parse
import requests
from bs4 import BeautifulSoup
session = requests.session()
session.get("http://www.gzlib.gov.cn/";)
session.headers.update(
{"Referer": "http://www.gzlib.gov.cn/member ... ot%3B,
"origin": "http://login.gzlib.gov.cn",
'Content-Type': 'application/x-www-form-urlencoded',
'host': 'www.gzlib.gov.cn',
'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/50.0.2661.102 Safari/537.36'
}
)
baseURL = "http://login.gzlib.gov.cn/sso-server/login"
soup = BeautifulSoup(session.get(baseURL).text, "html.parser")
lt = soup.select("form")[0].find(attrs={'name': 'lt'})['value']
postdict = {"username": "你的身份证",
"password": "密码（默认为身份证后6位）",
"_eventId": "submit",
"lt": lt
}
postdata = urllib.parse.urlencode(postdict)
session.post(baseURL, postdata)
print(session.get("http://www.gzlib.gov.cn/member ... 6quot;).text)
分类：
技术要点：
相关文章：
httpclient 抓取网页(网页获取和解析速度和性能的应用场景详解！)
网站优化 • 优采云 发表了文章 • 0 个评论 • 71 次浏览 • 2022-04-13 00:10
httpclient 抓取网页(网页获取和解析速度和性能的应用场景详解！)
(4）支持代理服务器
(5）支持自动cookie管理等
Java爬虫开发是应用最广泛的网页获取技术。它具有一流的速度和性能。它在功能支持方面相对较低。不支持JS脚本执行、CSS解析渲染等准浏览器功能。推荐用于无需解析脚本和 CSS 即可获取网页的快速场景。
示例代码如下：
package cn.ysh.studio.crawler.httpclient;import org.apache.http.client.HttpClient;import org.apache.http.client.ResponseHandler;import org.apache.http.client.methods.HttpGet;import org.apache.http.impl.client.BasicResponseHandler;import org.apache.http.impl.client.DefaultHttpClient;/**
* 基于HtmlClient抓取网页内容
*
* @author www.yshjava.cn
*/publicclassHttpClientTest{publicstaticvoid main(String[] args)throwsException{//目标页面String url ="http://www.yshjava.cn";//创建一个默认的HttpClientHttpClient httpclient =newDefaultHttpClient();try{//以get方式请求网页http://www.yshjava.cnHttpGet httpget =newHttpGet(url);//打印请求地址System.out.println("executing request "+ httpget.getURI());//创建响应处理器处理服务器响应内容ResponseHandlerresponseHandler=newBasicResponseHandler();//执行请求并获取结果String responseBody = httpclient.execute(httpget, responseHandler);System.out.println("----------------------------------------");System.out.println(responseBody);System.out.println("----------------------------------------");}finally{//关闭连接管理器
httpclient.getConnectionManager().shutdown();}}}
汤
jsoup 是一个Java HTML 解析器，可以直接解析一个URL 地址和HTML 文本内容。它提供了一个非常省力的 API，用于通过 DOM、CSS 和类似 jQuery 的操作方法获取和操作数据。
网页获取解析速度快，推荐。
主要功能如下：
1. 从 URL、文件或字符串解析 HTML；
2. 使用 DOM 或 CSS 选择器来查找和检索数据；
3.可以操作HTML元素、属性、文本；
示例代码如下：
package cn.ysh.studio.crawler.jsoup;import java.io.IOException;import org.jsoup.Jsoup;/**
* 基于Jsoup抓取网页内容
* @author www.yshjava.cn
*/publicclassJsoupTest{publicstaticvoid main(String[] args)throwsIOException{//目标页面String url ="http://www.yshjava.cn";//使用Jsoup连接目标页面,并执行请求,获取服务器响应内容String html =Jsoup.connect(url).execute().body();//打印页面内容System.out.println(html);}}
HtmlUnit
htmlunit 是一个开源的java页面分析工具。阅读完页面后，可以有效地使用htmlunit分析页面上的内容。该项目可以模拟浏览器的操作，称为java浏览器的开源实现。这个没有界面的浏览器运行速度非常快。使用 Rhinojs 引擎。模拟js运行。
网页获取解析速度快，性能更好。推荐用于需要解析网页脚本的应用场景。
示例代码如下：
package cn.ysh.studio.crawler.htmlunit;import com.gargoylesoftware.htmlunit.BrowserVersion;import com.gargoylesoftware.htmlunit.Page;import com.gargoylesoftware.htmlunit.WebClient;/**
* 基于HtmlUnit抓取网页内容
*
* @author www.yshjava.cn
*/publicclassHtmlUnitSpider{publicstaticvoid main(String[] s)throwsException{//目标网页String url ="http://www.yshjava.cn";//模拟特定浏览器FIREFOX_3WebClient spider =newWebClient(BrowserVersion.FIREFOX_3);//获取目标网页Page page = spider.getPage(url);//打印网页内容System.out.println(page.getWebResponse().getContentAsString());//关闭所有窗口
spider.closeAllWindows();}}
瓦提
Watij（发音为 wattage）是一个用 Java 开发的 Web 应用程序测试工具。鉴于 Watij 的简单性和 Java 语言的强大功能，Watij 使您能够在真实浏览器中自动测试 Web 应用程序。因为调用本地浏览器，所以支持CSS渲染和JS执行。
网页获取速度一般，IE版本太低（6/7）可能会导致内存泄漏。
示例代码如下：
package cn.ysh.studio.crawler.ie;import watij.runtime.ie.IE;/**
* 基于Watij抓取网页内容,仅限Windows平台
*
* @author www.yshjava.cn
*/publicclassWatijTest{publicstaticvoid main(String[] s){//目标页面String url ="http://www.yshjava.cn";//实例化IE浏览器对象
IE ie =new IE();try{//启动浏览器
ie.start();//转到目标网页
ie.goTo(url);//等待网页加载就绪
ie.waitUntilReady();//打印页面内容System.out.println(ie.html());}catch(Exception e){
e.printStackTrace();}finally{try{//关闭IE浏览器
ie.close();}catch(Exception e){}}}}
硒
Selenium 也是一个用于 Web 应用程序测试的工具。 Selenium 测试直接在浏览器中运行，就像真正的用户一样。支持的浏览器包括 IE、Mozilla Firefox、Mozilla Suite 等。该工具的主要功能包括： 测试与浏览器的兼容性 - 测试您的应用程序是否在不同的浏览器和操作系统上运行良好。测试系统功能 - 创建回归测试以验证软件功能和用户需求。支持动作的自动记录和自动生成。 Net、Java、Perl 和其他不同语言的测试脚本。 Selenium 是 ThoughtWorks 专门为 Web 应用编写的验收测试工具。
网页抓取速度慢，对于爬虫来说不是一个好的选择。
示例代码如下：
package cn.ysh.studio.crawler.selenium;import org.openqa.selenium.htmlunit.HtmlUnitDriver;/**
* 基于HtmlDriver抓取网页内容
*
* @author www.yshjava.cn
*/publicclassHtmlDriverTest{publicstaticvoid main(String[] s){//目标网页String url ="http://www.yshjava.cn";HtmlUnitDriver driver =newHtmlUnitDriver();try{//禁用JS脚本功能
driver.setJavascriptEnabled(false);//打开目标网页
driver.get(url);//获取当前网页源码String html = driver.getPageSource();//打印网页源码System.out.println(html);}catch(Exception e){//打印堆栈信息
e.printStackTrace();}finally{try{//关闭并退出
driver.close();
driver.quit();}catch(Exception e){}}}}
网络规范
具有支持脚本执行和 CSS 呈现的界面的开源 Java 浏览器。平均速度。
示例代码如下：
package cn.ysh.studio.crawler.webspec;import org.watij.webspec.dsl.WebSpec;/**
* 基于WebSpec抓取网页内容
*
* @author www.yshjava.cn
*/publicclassWebspecTest{publicstaticvoid main(String[] s){//目标网页String url ="http://www.yshjava.cn";//实例化浏览器对象WebSpec spec =newWebSpec().mozilla();//隐藏浏览器窗体
spec.hide();//打开目标页面
spec.open(url);//打印网页源码System.out.println(spec.source());//关闭所有窗口
spec.closeAll();}}
源码下载：网络爬虫（网络蜘蛛）网络爬取示例源码
转载来源地址：
转载于： 查看全部
(4）支持代理服务器
(5）支持自动cookie管理等
Java爬虫开发是应用最广泛的网页获取技术。它具有一流的速度和性能。它在功能支持方面相对较低。不支持JS脚本执行、CSS解析渲染等准浏览器功能。推荐用于无需解析脚本和 CSS 即可获取网页的快速场景。
示例代码如下：
package cn.ysh.studio.crawler.httpclient;import org.apache.http.client.HttpClient;import org.apache.http.client.ResponseHandler;import org.apache.http.client.methods.HttpGet;import org.apache.http.impl.client.BasicResponseHandler;import org.apache.http.impl.client.DefaultHttpClient;/**
* 基于HtmlClient抓取网页内容
*
* @author www.yshjava.cn
*/publicclassHttpClientTest{publicstaticvoid main(String[] args)throwsException{//目标页面String url ="http://www.yshjava.cn";//创建一个默认的HttpClientHttpClient httpclient =newDefaultHttpClient();try{//以get方式请求网页http://www.yshjava.cnHttpGet httpget =newHttpGet(url);//打印请求地址System.out.println("executing request "+ httpget.getURI());//创建响应处理器处理服务器响应内容ResponseHandlerresponseHandler=newBasicResponseHandler();//执行请求并获取结果String responseBody = httpclient.execute(httpget, responseHandler);System.out.println("----------------------------------------");System.out.println(responseBody);System.out.println("----------------------------------------");}finally{//关闭连接管理器
httpclient.getConnectionManager().shutdown();}}}
汤
jsoup 是一个Java HTML 解析器，可以直接解析一个URL 地址和HTML 文本内容。它提供了一个非常省力的 API，用于通过 DOM、CSS 和类似 jQuery 的操作方法获取和操作数据。
网页获取解析速度快，推荐。
主要功能如下：
1. 从 URL、文件或字符串解析 HTML；
2. 使用 DOM 或 CSS 选择器来查找和检索数据；
3.可以操作HTML元素、属性、文本；
示例代码如下：
package cn.ysh.studio.crawler.jsoup;import java.io.IOException;import org.jsoup.Jsoup;/**
* 基于Jsoup抓取网页内容
* @author www.yshjava.cn
*/publicclassJsoupTest{publicstaticvoid main(String[] args)throwsIOException{//目标页面String url ="http://www.yshjava.cn";//使用Jsoup连接目标页面,并执行请求,获取服务器响应内容String html =Jsoup.connect(url).execute().body();//打印页面内容System.out.println(html);}}
HtmlUnit
htmlunit 是一个开源的java页面分析工具。阅读完页面后，可以有效地使用htmlunit分析页面上的内容。该项目可以模拟浏览器的操作，称为java浏览器的开源实现。这个没有界面的浏览器运行速度非常快。使用 Rhinojs 引擎。模拟js运行。
网页获取解析速度快，性能更好。推荐用于需要解析网页脚本的应用场景。
示例代码如下：
package cn.ysh.studio.crawler.htmlunit;import com.gargoylesoftware.htmlunit.BrowserVersion;import com.gargoylesoftware.htmlunit.Page;import com.gargoylesoftware.htmlunit.WebClient;/**
* 基于HtmlUnit抓取网页内容
*
* @author www.yshjava.cn
*/publicclassHtmlUnitSpider{publicstaticvoid main(String[] s)throwsException{//目标网页String url ="http://www.yshjava.cn";//模拟特定浏览器FIREFOX_3WebClient spider =newWebClient(BrowserVersion.FIREFOX_3);//获取目标网页Page page = spider.getPage(url);//打印网页内容System.out.println(page.getWebResponse().getContentAsString());//关闭所有窗口
spider.closeAllWindows();}}
瓦提
Watij（发音为 wattage）是一个用 Java 开发的 Web 应用程序测试工具。鉴于 Watij 的简单性和 Java 语言的强大功能，Watij 使您能够在真实浏览器中自动测试 Web 应用程序。因为调用本地浏览器，所以支持CSS渲染和JS执行。
网页获取速度一般，IE版本太低（6/7）可能会导致内存泄漏。
示例代码如下：
package cn.ysh.studio.crawler.ie;import watij.runtime.ie.IE;/**
* 基于Watij抓取网页内容,仅限Windows平台
*
* @author www.yshjava.cn
*/publicclassWatijTest{publicstaticvoid main(String[] s){//目标页面String url ="http://www.yshjava.cn";//实例化IE浏览器对象
IE ie =new IE();try{//启动浏览器
ie.start();//转到目标网页
ie.goTo(url);//等待网页加载就绪
ie.waitUntilReady();//打印页面内容System.out.println(ie.html());}catch(Exception e){
e.printStackTrace();}finally{try{//关闭IE浏览器
ie.close();}catch(Exception e){}}}}
硒
Selenium 也是一个用于 Web 应用程序测试的工具。 Selenium 测试直接在浏览器中运行，就像真正的用户一样。支持的浏览器包括 IE、Mozilla Firefox、Mozilla Suite 等。该工具的主要功能包括： 测试与浏览器的兼容性 - 测试您的应用程序是否在不同的浏览器和操作系统上运行良好。测试系统功能 - 创建回归测试以验证软件功能和用户需求。支持动作的自动记录和自动生成。 Net、Java、Perl 和其他不同语言的测试脚本。 Selenium 是 ThoughtWorks 专门为 Web 应用编写的验收测试工具。
网页抓取速度慢，对于爬虫来说不是一个好的选择。
示例代码如下：
package cn.ysh.studio.crawler.selenium;import org.openqa.selenium.htmlunit.HtmlUnitDriver;/**
* 基于HtmlDriver抓取网页内容
*
* @author www.yshjava.cn
*/publicclassHtmlDriverTest{publicstaticvoid main(String[] s){//目标网页String url ="http://www.yshjava.cn";HtmlUnitDriver driver =newHtmlUnitDriver();try{//禁用JS脚本功能
driver.setJavascriptEnabled(false);//打开目标网页
driver.get(url);//获取当前网页源码String html = driver.getPageSource();//打印网页源码System.out.println(html);}catch(Exception e){//打印堆栈信息
e.printStackTrace();}finally{try{//关闭并退出
driver.close();
driver.quit();}catch(Exception e){}}}}
网络规范
具有支持脚本执行和 CSS 呈现的界面的开源 Java 浏览器。平均速度。
示例代码如下：
package cn.ysh.studio.crawler.webspec;import org.watij.webspec.dsl.WebSpec;/**
* 基于WebSpec抓取网页内容
*
* @author www.yshjava.cn
*/publicclassWebspecTest{publicstaticvoid main(String[] s){//目标网页String url ="http://www.yshjava.cn";//实例化浏览器对象WebSpec spec =newWebSpec().mozilla();//隐藏浏览器窗体
spec.hide();//打开目标页面
spec.open(url);//打印网页源码System.out.println(spec.source());//关闭所有窗口
spec.closeAll();}}
源码下载：网络爬虫（网络蜘蛛）网络爬取示例源码
转载来源地址：
转载于： 查看全部
httpclient 抓取网页(网页获取和解析速度和性能的应用场景详解！)
(4）支持代理服务器
(5）支持自动cookie管理等
Java爬虫开发是应用最广泛的网页获取技术。它具有一流的速度和性能。它在功能支持方面相对较低。不支持JS脚本执行、CSS解析渲染等准浏览器功能。推荐用于无需解析脚本和 CSS 即可获取网页的快速场景。
示例代码如下：
package cn.ysh.studio.crawler.httpclient;import org.apache.http.client.HttpClient;import org.apache.http.client.ResponseHandler;import org.apache.http.client.methods.HttpGet;import org.apache.http.impl.client.BasicResponseHandler;import org.apache.http.impl.client.DefaultHttpClient;/**
* 基于HtmlClient抓取网页内容
*
* @author www.yshjava.cn
*/publicclassHttpClientTest{publicstaticvoid main(String[] args)throwsException{//目标页面String url ="http://www.yshjava.cn";//创建一个默认的HttpClientHttpClient httpclient =newDefaultHttpClient();try{//以get方式请求网页http://www.yshjava.cnHttpGet httpget =newHttpGet(url);//打印请求地址System.out.println("executing request "+ httpget.getURI());//创建响应处理器处理服务器响应内容ResponseHandlerresponseHandler=newBasicResponseHandler();//执行请求并获取结果String responseBody = httpclient.execute(httpget, responseHandler);System.out.println("----------------------------------------");System.out.println(responseBody);System.out.println("----------------------------------------");}finally{//关闭连接管理器
httpclient.getConnectionManager().shutdown();}}}
汤
jsoup 是一个Java HTML 解析器，可以直接解析一个URL 地址和HTML 文本内容。它提供了一个非常省力的 API，用于通过 DOM、CSS 和类似 jQuery 的操作方法获取和操作数据。
网页获取解析速度快，推荐。
主要功能如下：
1. 从 URL、文件或字符串解析 HTML；
2. 使用 DOM 或 CSS 选择器来查找和检索数据；
3.可以操作HTML元素、属性、文本；
示例代码如下：
package cn.ysh.studio.crawler.jsoup;import java.io.IOException;import org.jsoup.Jsoup;/**
* 基于Jsoup抓取网页内容
* @author www.yshjava.cn
*/publicclassJsoupTest{publicstaticvoid main(String[] args)throwsIOException{//目标页面String url ="http://www.yshjava.cn";//使用Jsoup连接目标页面,并执行请求,获取服务器响应内容String html =Jsoup.connect(url).execute().body();//打印页面内容System.out.println(html);}}
HtmlUnit
htmlunit 是一个开源的java页面分析工具。阅读完页面后，可以有效地使用htmlunit分析页面上的内容。该项目可以模拟浏览器的操作，称为java浏览器的开源实现。这个没有界面的浏览器运行速度非常快。使用 Rhinojs 引擎。模拟js运行。
网页获取解析速度快，性能更好。推荐用于需要解析网页脚本的应用场景。
示例代码如下：
package cn.ysh.studio.crawler.htmlunit;import com.gargoylesoftware.htmlunit.BrowserVersion;import com.gargoylesoftware.htmlunit.Page;import com.gargoylesoftware.htmlunit.WebClient;/**
* 基于HtmlUnit抓取网页内容
*
* @author www.yshjava.cn
*/publicclassHtmlUnitSpider{publicstaticvoid main(String[] s)throwsException{//目标网页String url ="http://www.yshjava.cn";//模拟特定浏览器FIREFOX_3WebClient spider =newWebClient(BrowserVersion.FIREFOX_3);//获取目标网页Page page = spider.getPage(url);//打印网页内容System.out.println(page.getWebResponse().getContentAsString());//关闭所有窗口
spider.closeAllWindows();}}
瓦提
Watij（发音为 wattage）是一个用 Java 开发的 Web 应用程序测试工具。鉴于 Watij 的简单性和 Java 语言的强大功能，Watij 使您能够在真实浏览器中自动测试 Web 应用程序。因为调用本地浏览器，所以支持CSS渲染和JS执行。
网页获取速度一般，IE版本太低（6/7）可能会导致内存泄漏。
示例代码如下：
package cn.ysh.studio.crawler.ie;import watij.runtime.ie.IE;/**
* 基于Watij抓取网页内容,仅限Windows平台
*
* @author www.yshjava.cn
*/publicclassWatijTest{publicstaticvoid main(String[] s){//目标页面String url ="http://www.yshjava.cn";//实例化IE浏览器对象
IE ie =new IE();try{//启动浏览器
ie.start();//转到目标网页
ie.goTo(url);//等待网页加载就绪
ie.waitUntilReady();//打印页面内容System.out.println(ie.html());}catch(Exception e){
e.printStackTrace();}finally{try{//关闭IE浏览器
ie.close();}catch(Exception e){}}}}
硒
Selenium 也是一个用于 Web 应用程序测试的工具。 Selenium 测试直接在浏览器中运行，就像真正的用户一样。支持的浏览器包括 IE、Mozilla Firefox、Mozilla Suite 等。该工具的主要功能包括： 测试与浏览器的兼容性 - 测试您的应用程序是否在不同的浏览器和操作系统上运行良好。测试系统功能 - 创建回归测试以验证软件功能和用户需求。支持动作的自动记录和自动生成。 Net、Java、Perl 和其他不同语言的测试脚本。 Selenium 是 ThoughtWorks 专门为 Web 应用编写的验收测试工具。
网页抓取速度慢，对于爬虫来说不是一个好的选择。
示例代码如下：
package cn.ysh.studio.crawler.selenium;import org.openqa.selenium.htmlunit.HtmlUnitDriver;/**
* 基于HtmlDriver抓取网页内容
*
* @author www.yshjava.cn
*/publicclassHtmlDriverTest{publicstaticvoid main(String[] s){//目标网页String url ="http://www.yshjava.cn";HtmlUnitDriver driver =newHtmlUnitDriver();try{//禁用JS脚本功能
driver.setJavascriptEnabled(false);//打开目标网页
driver.get(url);//获取当前网页源码String html = driver.getPageSource();//打印网页源码System.out.println(html);}catch(Exception e){//打印堆栈信息
e.printStackTrace();}finally{try{//关闭并退出
driver.close();
driver.quit();}catch(Exception e){}}}}
网络规范
具有支持脚本执行和 CSS 呈现的界面的开源 Java 浏览器。平均速度。
示例代码如下：
package cn.ysh.studio.crawler.webspec;import org.watij.webspec.dsl.WebSpec;/**
* 基于WebSpec抓取网页内容
*
* @author www.yshjava.cn
*/publicclassWebspecTest{publicstaticvoid main(String[] s){//目标网页String url ="http://www.yshjava.cn";//实例化浏览器对象WebSpec spec =newWebSpec().mozilla();//隐藏浏览器窗体
spec.hide();//打开目标页面
spec.open(url);//打印网页源码System.out.println(spec.source());//关闭所有窗口
spec.closeAll();}}
源码下载：网络爬虫（网络蜘蛛）网络爬取示例源码
转载来源地址：
转载于：
httpclient 抓取网页(HtmlUnit使用场景对于使用java实现的网页爬虫程序呢？ )
网站优化 • 优采云 发表了文章 • 0 个评论 • 62 次浏览 • 2022-04-10 08:30
httpclient 抓取网页(HtmlUnit使用场景对于使用java实现的网页爬虫程序呢？
)
HtmlUnit简介
HtmlUnit is a "GUI-Less browser for Java programs". It models HTML documents and provides an API that allows you to invoke pages, fill out forms, click links, etc... just like you do in your "normal" browser.
It has fairly good JavaScript support (which is constantly improving) and is able to work even with quite complex AJAX libraries, simulating Chrome, Firefox or Internet Explorer depending on the configuration used.
It is typically used for testing purposes or to retrieve information from web sites.
HtmlUnit is not a generic unit testing framework. It is specifically a way to simulate a browser for testing purposes and is intended to be used within another testing framework such as JUnit or TestNG. Refer to the document "Getting Started with HtmlUnit" for an introduction.
HtmlUnit is used as the underlying "browser" by different Open Source tools like Canoo WebTest, JWebUnit, WebDriver, JSFUnit, WETATOR, Celerity, Spring MVC Test HtmlUnit, ...
HtmlUnit was originally written by Mike Bowler of Gargoyle Software and is released under the Apache 2 license. Since then, it has received many contributions from other developers, and would not be where it is today without their assistance.
HtmlUnit是一个无界面浏览器Java程序。它为HTML文档建模，提供了调用页面、填写表单、单击链接等操作的API。就跟你在浏览器里做的操作一样。
HtmlUnit不错的JavaScript支持(不断改进)，甚至可以使用相当复杂的AJAX库，根据配置的不同模拟Chrome、Firefox或Internet Explorer等浏览器。
HtmlUnit通常用于测试或从web站点检索信息。
HtmlUnit 使用场景
对于java实现的网络爬虫程序，我们一般可以使用apache的HttpClient组件来获取HTML页面信息。HttpClient实现的http请求返回的响应一般是纯文本文档页面，也就是最原创的html页面。
对于一个静态的html页面，使用httpClient就足够爬出我们需要的信息了。但是对于越来越多的动态网页，更多的数据是通过异步的JS代码来获取和渲染的，而初始的html页面并没有收录这部分数据。
上图中我们看到的网页在初始文档加载后并没有看到红框中的数据列表。浏览器通过执行异步JS请求，将获取到的动态数据渲染到原创文档页面中，最终变成我们看到的网页。对于这部分需要JS代码执行的数据，httpClient是无能为力的。虽然我们可以通过研究得到JS执行的请求路径，然后用java代码来获取我们需要的部分数据，不说能不能从JS脚本中分析请求路径和请求参数，只分析这部分数据源码成本已经很高了。
通过上面的介绍，我们了解到现在很大一部分动态网页都是通过异步JS请求获取的数据，然后通过JS渲染页面。那么我们能不能做这样的假设，假设我们的爬虫程序模拟一个浏览器，拿到html页面后，像浏览器一样执行异步JS代码，JS渲染好html页面后，就可以愉快的获取到节点信息了这页纸。那么有没有这样的java程序呢？
答案是肯定的。
HtmlUnit就是这样一个库，用来做界面显示的所有异步工作。没有耗时的显示工作，HtmlUnit 加载的完整网页比实际的浏览器块更多。并且根据不同的配置，HtmlUnit可以模拟市面上常见的Chrome、Firefox、IE浏览器等浏览器。
通过HtmlUnit库，加载一个完整的Html页面（图片和视频除外），然后将其转换成我们常用的字符串格式，使用Jsoup等其他工具获取元素。当然，你也可以直接从HtmlUnit提供的对象中获取网页元素，甚至可以操作按钮、表单等控件。除了不能像可见浏览器那样用鼠标和键盘浏览网页之外，我们可以使用HtmlUnit来模拟所有其他的操作，比如登录网站、写博客等都可以完成。当然，网页内容抓取是最简单的应用。
HtmlUnit 使用方法 1. 创建一个新的 maven 项目并添加 HtmlUnit 依赖项：
net.sourceforge.htmlunit
htmlunit
2.27
2.新建一个Junit TestCase 试试这个库
程序代码注释如下：
package xuyihao.util.depend;
import com.gargoylesoftware.htmlunit.BrowserVersion;
import com.gargoylesoftware.htmlunit.NicelyResynchronizingAjaxController;
import com.gargoylesoftware.htmlunit.WebClient;
import com.gargoylesoftware.htmlunit.html.HtmlPage;
import org.jsoup.Jsoup;
import org.jsoup.nodes.Document;
import org.jsoup.nodes.Element;
import org.junit.Test;
import java.util.List;
/**
* Created by xuyh at 2017/11/6 14:03.
*/
public class HtmlUtilTest {
@Test
public void test() {
final WebClient webClient = new WebClient(BrowserVersion.CHROME);//新建一个模拟谷歌Chrome浏览器的浏览器客户端对象
webClient.getOptions().setThrowExceptionOnScriptError(false);//当JS执行出错的时候是否抛出异常, 这里选择不需要
webClient.getOptions().setThrowExceptionOnFailingStatusCode(false);//当HTTP的状态非200时是否抛出异常, 这里选择不需要
webClient.getOptions().setActiveXNative(false);
webClient.getOptions().setCssEnabled(false);//是否启用CSS, 因为不需要展现页面, 所以不需要启用
webClient.getOptions().setJavaScriptEnabled(true); //很重要，启用JS
webClient.setAjaxController(new NicelyResynchronizingAjaxController());//很重要，设置支持AJAX
HtmlPage page = null;
try {
page = webClient.getPage("http://ent.sina.com.cn/film/");//尝试加载上面图片例子给出的网页
} catch (Exception e) {
e.printStackTrace();
}finally {
webClient.close();
}
webClient.waitForBackgroundJavaScript(30000);//异步JS执行需要耗时,所以这里线程要阻塞30秒,等待异步JS执行结束
String pageXml = page.asXml();//直接将加载完成的页面转换成xml格式的字符串
//TODO 下面的代码就是对字符串的操作了,常规的爬虫操作,用到了比较好用的Jsoup库
Document document = Jsoup.parse(pageXml);//获取html文档
List infoListEle = document.getElementById("feedCardContent").getElementsByAttributeValue("class", "feed-card-item");//获取元素节点等
infoListEle.forEach(element -> {
System.out.println(element.getElementsByTag("h2").first().getElementsByTag("a").text());
System.out.println(element.getElementsByTag("h2").first().getElementsByTag("a").attr("href"));
});
}
}
上面的示例将获取到的页面中消息列表的标题和超链接 URL 打印到控制台。操作HTML文档的库是Jsoup，需要添加依赖：
org.jsoup
jsoup
1.8.3
等待三十秒后，控制台输出如下：
十一月 06, 2017 2:17:05 下午 com.gargoylesoftware.htmlunit.IncorrectnessListenerImpl notify
警告: Obsolete content type encountered: 'application/x-javascript'.
十一月 06, 2017 2:17:06 下午 com.gargoylesoftware.htmlunit.javascript.StrictErrorReporter runtimeError
严重: runtimeError: message=[An invalid or illegal selector was specified (selector: '*,:x' error: Invalid selector: :x).] sourceName=[http://n.sinaimg.cn/lib/core/core.js] line=[1] lineSource=[null] lineOffset=[0]
十一月 06, 2017 2:17:06 下午 com.gargoylesoftware.htmlunit.IncorrectnessListenerImpl notify
警告: Obsolete content type encountered: 'application/x-javascript'.
2017-11-06 14:17:11.003:INFO::JS executor for com.gargoylesoftware.htmlunit.WebClient@618c5d94: Logging initialized @7179ms to org.eclipse.jetty.util.log.StdErrLog
十一月 06, 2017 2:17:11 下午 com.gargoylesoftware.htmlunit.javascript.host.WebSocket run
严重: WS connect error
java.util.concurrent.ExecutionException: org.eclipse.jetty.websocket.api.UpgradeException: 0 null
at java.util.concurrent.CompletableFuture.reportGet(CompletableFuture.java:357)
at java.util.concurrent.CompletableFuture.get(CompletableFuture.java:1895)
at com.gargoylesoftware.htmlunit.javascript.host.WebSocket$1.run(WebSocket.java:151)
at org.eclipse.jetty.util.thread.QueuedThreadPool.runJob(QueuedThreadPool.java:672)
at org.eclipse.jetty.util.thread.QueuedThreadPool$2.run(QueuedThreadPool.java:590)
at java.lang.Thread.run(Thread.java:748)
Caused by: org.eclipse.jetty.websocket.api.UpgradeException: 0 null
at org.eclipse.jetty.websocket.client.WebSocketUpgradeRequest.onComplete(WebSocketUpgradeRequest.java:513)
at org.eclipse.jetty.client.ResponseNotifier.notifyComplete(ResponseNotifier.java:193)
at org.eclipse.jetty.client.ResponseNotifier.notifyComplete(ResponseNotifier.java:185)
at org.eclipse.jetty.client.HttpExchange.notifyFailureComplete(HttpExchange.java:269)
at org.eclipse.jetty.client.HttpExchange.abort(HttpExchange.java:240)
at org.eclipse.jetty.client.HttpConversation.abort(HttpConversation.java:141)
at org.eclipse.jetty.client.HttpRequest.abort(HttpRequest.java:748)
at org.eclipse.jetty.client.HttpDestination.abort(HttpDestination.java:444)
at org.eclipse.jetty.client.HttpDestination.failed(HttpDestination.java:224)
at org.eclipse.jetty.client.AbstractConnectionPool$1.failed(AbstractConnectionPool.java:122)
at org.eclipse.jetty.util.Promise$Wrapper.failed(Promise.java:136)
at org.eclipse.jetty.client.HttpClient$1$1.failed(HttpClient.java:588)
at org.eclipse.jetty.client.AbstractHttpClientTransport.connectFailed(AbstractHttpClientTransport.java:154)
at org.eclipse.jetty.client.AbstractHttpClientTransport$ClientSelectorManager.connectionFailed(AbstractHttpClientTransport.java:199)
at org.eclipse.jetty.io.ManagedSelector$Connect.failed(ManagedSelector.java:655)
at org.eclipse.jetty.io.ManagedSelector$Connect.access$1300(ManagedSelector.java:622)
at org.eclipse.jetty.io.ManagedSelector$1.failed(ManagedSelector.java:364)
at org.eclipse.jetty.io.ManagedSelector$CreateEndPoint.run(ManagedSelector.java:604)
... 3 more
Caused 查看全部
)
HtmlUnit简介
HtmlUnit is a "GUI-Less browser for Java programs". It models HTML documents and provides an API that allows you to invoke pages, fill out forms, click links, etc... just like you do in your "normal" browser.
It has fairly good JavaScript support (which is constantly improving) and is able to work even with quite complex AJAX libraries, simulating Chrome, Firefox or Internet Explorer depending on the configuration used.
It is typically used for testing purposes or to retrieve information from web sites.
HtmlUnit is not a generic unit testing framework. It is specifically a way to simulate a browser for testing purposes and is intended to be used within another testing framework such as JUnit or TestNG. Refer to the document "Getting Started with HtmlUnit" for an introduction.
HtmlUnit is used as the underlying "browser" by different Open Source tools like Canoo WebTest, JWebUnit, WebDriver, JSFUnit, WETATOR, Celerity, Spring MVC Test HtmlUnit, ...
HtmlUnit was originally written by Mike Bowler of Gargoyle Software and is released under the Apache 2 license. Since then, it has received many contributions from other developers, and would not be where it is today without their assistance.
HtmlUnit是一个无界面浏览器Java程序。它为HTML文档建模，提供了调用页面、填写表单、单击链接等操作的API。就跟你在浏览器里做的操作一样。
HtmlUnit不错的JavaScript支持(不断改进)，甚至可以使用相当复杂的AJAX库，根据配置的不同模拟Chrome、Firefox或Internet Explorer等浏览器。
HtmlUnit通常用于测试或从web站点检索信息。
HtmlUnit 使用场景
对于java实现的网络爬虫程序，我们一般可以使用apache的HttpClient组件来获取HTML页面信息。HttpClient实现的http请求返回的响应一般是纯文本文档页面，也就是最原创的html页面。
对于一个静态的html页面，使用httpClient就足够爬出我们需要的信息了。但是对于越来越多的动态网页，更多的数据是通过异步的JS代码来获取和渲染的，而初始的html页面并没有收录这部分数据。
上图中我们看到的网页在初始文档加载后并没有看到红框中的数据列表。浏览器通过执行异步JS请求，将获取到的动态数据渲染到原创文档页面中，最终变成我们看到的网页。对于这部分需要JS代码执行的数据，httpClient是无能为力的。虽然我们可以通过研究得到JS执行的请求路径，然后用java代码来获取我们需要的部分数据，不说能不能从JS脚本中分析请求路径和请求参数，只分析这部分数据源码成本已经很高了。
通过上面的介绍，我们了解到现在很大一部分动态网页都是通过异步JS请求获取的数据，然后通过JS渲染页面。那么我们能不能做这样的假设，假设我们的爬虫程序模拟一个浏览器，拿到html页面后，像浏览器一样执行异步JS代码，JS渲染好html页面后，就可以愉快的获取到节点信息了这页纸。那么有没有这样的java程序呢？
答案是肯定的。
HtmlUnit就是这样一个库，用来做界面显示的所有异步工作。没有耗时的显示工作，HtmlUnit 加载的完整网页比实际的浏览器块更多。并且根据不同的配置，HtmlUnit可以模拟市面上常见的Chrome、Firefox、IE浏览器等浏览器。
通过HtmlUnit库，加载一个完整的Html页面（图片和视频除外），然后将其转换成我们常用的字符串格式，使用Jsoup等其他工具获取元素。当然，你也可以直接从HtmlUnit提供的对象中获取网页元素，甚至可以操作按钮、表单等控件。除了不能像可见浏览器那样用鼠标和键盘浏览网页之外，我们可以使用HtmlUnit来模拟所有其他的操作，比如登录网站、写博客等都可以完成。当然，网页内容抓取是最简单的应用。
HtmlUnit 使用方法 1. 创建一个新的 maven 项目并添加 HtmlUnit 依赖项：
net.sourceforge.htmlunit
htmlunit
2.27
2.新建一个Junit TestCase 试试这个库
程序代码注释如下：
package xuyihao.util.depend;
import com.gargoylesoftware.htmlunit.BrowserVersion;
import com.gargoylesoftware.htmlunit.NicelyResynchronizingAjaxController;
import com.gargoylesoftware.htmlunit.WebClient;
import com.gargoylesoftware.htmlunit.html.HtmlPage;
import org.jsoup.Jsoup;
import org.jsoup.nodes.Document;
import org.jsoup.nodes.Element;
import org.junit.Test;
import java.util.List;
/**
* Created by xuyh at 2017/11/6 14:03.
*/
public class HtmlUtilTest {
@Test
public void test() {
final WebClient webClient = new WebClient(BrowserVersion.CHROME);//新建一个模拟谷歌Chrome浏览器的浏览器客户端对象
webClient.getOptions().setThrowExceptionOnScriptError(false);//当JS执行出错的时候是否抛出异常, 这里选择不需要
webClient.getOptions().setThrowExceptionOnFailingStatusCode(false);//当HTTP的状态非200时是否抛出异常, 这里选择不需要
webClient.getOptions().setActiveXNative(false);
webClient.getOptions().setCssEnabled(false);//是否启用CSS, 因为不需要展现页面, 所以不需要启用
webClient.getOptions().setJavaScriptEnabled(true); //很重要，启用JS
webClient.setAjaxController(new NicelyResynchronizingAjaxController());//很重要，设置支持AJAX
HtmlPage page = null;
try {
page = webClient.getPage("http://ent.sina.com.cn/film/");//尝试加载上面图片例子给出的网页
} catch (Exception e) {
e.printStackTrace();
}finally {
webClient.close();
}
webClient.waitForBackgroundJavaScript(30000);//异步JS执行需要耗时,所以这里线程要阻塞30秒,等待异步JS执行结束
String pageXml = page.asXml();//直接将加载完成的页面转换成xml格式的字符串
//TODO 下面的代码就是对字符串的操作了,常规的爬虫操作,用到了比较好用的Jsoup库
Document document = Jsoup.parse(pageXml);//获取html文档
List infoListEle = document.getElementById("feedCardContent").getElementsByAttributeValue("class", "feed-card-item");//获取元素节点等
infoListEle.forEach(element -> {
System.out.println(element.getElementsByTag("h2").first().getElementsByTag("a").text());
System.out.println(element.getElementsByTag("h2").first().getElementsByTag("a").attr("href"));
});
}
}
上面的示例将获取到的页面中消息列表的标题和超链接 URL 打印到控制台。操作HTML文档的库是Jsoup，需要添加依赖：
org.jsoup
jsoup
1.8.3
等待三十秒后，控制台输出如下：
十一月 06, 2017 2:17:05 下午 com.gargoylesoftware.htmlunit.IncorrectnessListenerImpl notify
警告: Obsolete content type encountered: 'application/x-javascript'.
十一月 06, 2017 2:17:06 下午 com.gargoylesoftware.htmlunit.javascript.StrictErrorReporter runtimeError
严重: runtimeError: message=[An invalid or illegal selector was specified (selector: '*,:x' error: Invalid selector: :x).] sourceName=[http://n.sinaimg.cn/lib/core/core.js] line=[1] lineSource=[null] lineOffset=[0]
十一月 06, 2017 2:17:06 下午 com.gargoylesoftware.htmlunit.IncorrectnessListenerImpl notify
警告: Obsolete content type encountered: 'application/x-javascript'.
2017-11-06 14:17:11.003:INFO::JS executor for com.gargoylesoftware.htmlunit.WebClient@618c5d94: Logging initialized @7179ms to org.eclipse.jetty.util.log.StdErrLog
十一月 06, 2017 2:17:11 下午 com.gargoylesoftware.htmlunit.javascript.host.WebSocket run
严重: WS connect error
java.util.concurrent.ExecutionException: org.eclipse.jetty.websocket.api.UpgradeException: 0 null
at java.util.concurrent.CompletableFuture.reportGet(CompletableFuture.java:357)
at java.util.concurrent.CompletableFuture.get(CompletableFuture.java:1895)
at com.gargoylesoftware.htmlunit.javascript.host.WebSocket$1.run(WebSocket.java:151)
at org.eclipse.jetty.util.thread.QueuedThreadPool.runJob(QueuedThreadPool.java:672)
at org.eclipse.jetty.util.thread.QueuedThreadPool$2.run(QueuedThreadPool.java:590)
at java.lang.Thread.run(Thread.java:748)
Caused by: org.eclipse.jetty.websocket.api.UpgradeException: 0 null
at org.eclipse.jetty.websocket.client.WebSocketUpgradeRequest.onComplete(WebSocketUpgradeRequest.java:513)
at org.eclipse.jetty.client.ResponseNotifier.notifyComplete(ResponseNotifier.java:193)
at org.eclipse.jetty.client.ResponseNotifier.notifyComplete(ResponseNotifier.java:185)
at org.eclipse.jetty.client.HttpExchange.notifyFailureComplete(HttpExchange.java:269)
at org.eclipse.jetty.client.HttpExchange.abort(HttpExchange.java:240)
at org.eclipse.jetty.client.HttpConversation.abort(HttpConversation.java:141)
at org.eclipse.jetty.client.HttpRequest.abort(HttpRequest.java:748)
at org.eclipse.jetty.client.HttpDestination.abort(HttpDestination.java:444)
at org.eclipse.jetty.client.HttpDestination.failed(HttpDestination.java:224)
at org.eclipse.jetty.client.AbstractConnectionPool$1.failed(AbstractConnectionPool.java:122)
at org.eclipse.jetty.util.Promise$Wrapper.failed(Promise.java:136)
at org.eclipse.jetty.client.HttpClient$1$1.failed(HttpClient.java:588)
at org.eclipse.jetty.client.AbstractHttpClientTransport.connectFailed(AbstractHttpClientTransport.java:154)
at org.eclipse.jetty.client.AbstractHttpClientTransport$ClientSelectorManager.connectionFailed(AbstractHttpClientTransport.java:199)
at org.eclipse.jetty.io.ManagedSelector$Connect.failed(ManagedSelector.java:655)
at org.eclipse.jetty.io.ManagedSelector$Connect.access$1300(ManagedSelector.java:622)
at org.eclipse.jetty.io.ManagedSelector$1.failed(ManagedSelector.java:364)
at org.eclipse.jetty.io.ManagedSelector$CreateEndPoint.run(ManagedSelector.java:604)
... 3 more
Caused 查看全部
httpclient 抓取网页(HtmlUnit使用场景对于使用java实现的网页爬虫程序呢？
)
HtmlUnit简介
HtmlUnit is a "GUI-Less browser for Java programs". It models HTML documents and provides an API that allows you to invoke pages, fill out forms, click links, etc... just like you do in your "normal" browser.
It has fairly good JavaScript support (which is constantly improving) and is able to work even with quite complex AJAX libraries, simulating Chrome, Firefox or Internet Explorer depending on the configuration used.
It is typically used for testing purposes or to retrieve information from web sites.
HtmlUnit is not a generic unit testing framework. It is specifically a way to simulate a browser for testing purposes and is intended to be used within another testing framework such as JUnit or TestNG. Refer to the document "Getting Started with HtmlUnit" for an introduction.
HtmlUnit is used as the underlying "browser" by different Open Source tools like Canoo WebTest, JWebUnit, WebDriver, JSFUnit, WETATOR, Celerity, Spring MVC Test HtmlUnit, ...
HtmlUnit was originally written by Mike Bowler of Gargoyle Software and is released under the Apache 2 license. Since then, it has received many contributions from other developers, and would not be where it is today without their assistance.
HtmlUnit是一个无界面浏览器Java程序。它为HTML文档建模，提供了调用页面、填写表单、单击链接等操作的API。就跟你在浏览器里做的操作一样。
HtmlUnit不错的JavaScript支持(不断改进)，甚至可以使用相当复杂的AJAX库，根据配置的不同模拟Chrome、Firefox或Internet Explorer等浏览器。
HtmlUnit通常用于测试或从web站点检索信息。
HtmlUnit 使用场景
对于java实现的网络爬虫程序，我们一般可以使用apache的HttpClient组件来获取HTML页面信息。HttpClient实现的http请求返回的响应一般是纯文本文档页面，也就是最原创的html页面。
对于一个静态的html页面，使用httpClient就足够爬出我们需要的信息了。但是对于越来越多的动态网页，更多的数据是通过异步的JS代码来获取和渲染的，而初始的html页面并没有收录这部分数据。
上图中我们看到的网页在初始文档加载后并没有看到红框中的数据列表。浏览器通过执行异步JS请求，将获取到的动态数据渲染到原创文档页面中，最终变成我们看到的网页。对于这部分需要JS代码执行的数据，httpClient是无能为力的。虽然我们可以通过研究得到JS执行的请求路径，然后用java代码来获取我们需要的部分数据，不说能不能从JS脚本中分析请求路径和请求参数，只分析这部分数据源码成本已经很高了。
通过上面的介绍，我们了解到现在很大一部分动态网页都是通过异步JS请求获取的数据，然后通过JS渲染页面。那么我们能不能做这样的假设，假设我们的爬虫程序模拟一个浏览器，拿到html页面后，像浏览器一样执行异步JS代码，JS渲染好html页面后，就可以愉快的获取到节点信息了这页纸。那么有没有这样的java程序呢？
答案是肯定的。
HtmlUnit就是这样一个库，用来做界面显示的所有异步工作。没有耗时的显示工作，HtmlUnit 加载的完整网页比实际的浏览器块更多。并且根据不同的配置，HtmlUnit可以模拟市面上常见的Chrome、Firefox、IE浏览器等浏览器。
通过HtmlUnit库，加载一个完整的Html页面（图片和视频除外），然后将其转换成我们常用的字符串格式，使用Jsoup等其他工具获取元素。当然，你也可以直接从HtmlUnit提供的对象中获取网页元素，甚至可以操作按钮、表单等控件。除了不能像可见浏览器那样用鼠标和键盘浏览网页之外，我们可以使用HtmlUnit来模拟所有其他的操作，比如登录网站、写博客等都可以完成。当然，网页内容抓取是最简单的应用。
HtmlUnit 使用方法 1. 创建一个新的 maven 项目并添加 HtmlUnit 依赖项：
net.sourceforge.htmlunit
htmlunit
2.27
2.新建一个Junit TestCase 试试这个库
程序代码注释如下：
package xuyihao.util.depend;
import com.gargoylesoftware.htmlunit.BrowserVersion;
import com.gargoylesoftware.htmlunit.NicelyResynchronizingAjaxController;
import com.gargoylesoftware.htmlunit.WebClient;
import com.gargoylesoftware.htmlunit.html.HtmlPage;
import org.jsoup.Jsoup;
import org.jsoup.nodes.Document;
import org.jsoup.nodes.Element;
import org.junit.Test;
import java.util.List;
/**
* Created by xuyh at 2017/11/6 14:03.
*/
public class HtmlUtilTest {
@Test
public void test() {
final WebClient webClient = new WebClient(BrowserVersion.CHROME);//新建一个模拟谷歌Chrome浏览器的浏览器客户端对象
webClient.getOptions().setThrowExceptionOnScriptError(false);//当JS执行出错的时候是否抛出异常, 这里选择不需要
webClient.getOptions().setThrowExceptionOnFailingStatusCode(false);//当HTTP的状态非200时是否抛出异常, 这里选择不需要
webClient.getOptions().setActiveXNative(false);
webClient.getOptions().setCssEnabled(false);//是否启用CSS, 因为不需要展现页面, 所以不需要启用
webClient.getOptions().setJavaScriptEnabled(true); //很重要，启用JS
webClient.setAjaxController(new NicelyResynchronizingAjaxController());//很重要，设置支持AJAX
HtmlPage page = null;
try {
page = webClient.getPage("http://ent.sina.com.cn/film/";);//尝试加载上面图片例子给出的网页
} catch (Exception e) {
e.printStackTrace();
}finally {
webClient.close();
}
webClient.waitForBackgroundJavaScript(30000);//异步JS执行需要耗时,所以这里线程要阻塞30秒,等待异步JS执行结束
String pageXml = page.asXml();//直接将加载完成的页面转换成xml格式的字符串
//TODO 下面的代码就是对字符串的操作了,常规的爬虫操作,用到了比较好用的Jsoup库
Document document = Jsoup.parse(pageXml);//获取html文档
List infoListEle = document.getElementById("feedCardContent").getElementsByAttributeValue("class", "feed-card-item");//获取元素节点等
infoListEle.forEach(element -> {
System.out.println(element.getElementsByTag("h2").first().getElementsByTag("a").text());
System.out.println(element.getElementsByTag("h2").first().getElementsByTag("a").attr("href"));
});
}
}
上面的示例将获取到的页面中消息列表的标题和超链接 URL 打印到控制台。操作HTML文档的库是Jsoup，需要添加依赖：
org.jsoup
jsoup
1.8.3
等待三十秒后，控制台输出如下：
十一月 06, 2017 2:17:05 下午 com.gargoylesoftware.htmlunit.IncorrectnessListenerImpl notify
警告: Obsolete content type encountered: 'application/x-javascript'.
十一月 06, 2017 2:17:06 下午 com.gargoylesoftware.htmlunit.javascript.StrictErrorReporter runtimeError
严重: runtimeError: message=[An invalid or illegal selector was specified (selector: '*,:x' error: Invalid selector: :x).] sourceName=[http://n.sinaimg.cn/lib/core/core.js] line=[1] lineSource=[null] lineOffset=[0]
十一月 06, 2017 2:17:06 下午 com.gargoylesoftware.htmlunit.IncorrectnessListenerImpl notify
警告: Obsolete content type encountered: 'application/x-javascript'.
2017-11-06 14:17:11.003:INFO::JS executor for com.gargoylesoftware.htmlunit.WebClient@618c5d94: Logging initialized @7179ms to org.eclipse.jetty.util.log.StdErrLog
十一月 06, 2017 2:17:11 下午 com.gargoylesoftware.htmlunit.javascript.host.WebSocket run
严重: WS connect error
java.util.concurrent.ExecutionException: org.eclipse.jetty.websocket.api.UpgradeException: 0 null
at java.util.concurrent.CompletableFuture.reportGet(CompletableFuture.java:357)
at java.util.concurrent.CompletableFuture.get(CompletableFuture.java:1895)
at com.gargoylesoftware.htmlunit.javascript.host.WebSocket$1.run(WebSocket.java:151)
at org.eclipse.jetty.util.thread.QueuedThreadPool.runJob(QueuedThreadPool.java:672)
at org.eclipse.jetty.util.thread.QueuedThreadPool$2.run(QueuedThreadPool.java:590)
at java.lang.Thread.run(Thread.java:748)
Caused by: org.eclipse.jetty.websocket.api.UpgradeException: 0 null
at org.eclipse.jetty.websocket.client.WebSocketUpgradeRequest.onComplete(WebSocketUpgradeRequest.java:513)
at org.eclipse.jetty.client.ResponseNotifier.notifyComplete(ResponseNotifier.java:193)
at org.eclipse.jetty.client.ResponseNotifier.notifyComplete(ResponseNotifier.java:185)
at org.eclipse.jetty.client.HttpExchange.notifyFailureComplete(HttpExchange.java:269)
at org.eclipse.jetty.client.HttpExchange.abort(HttpExchange.java:240)
at org.eclipse.jetty.client.HttpConversation.abort(HttpConversation.java:141)
at org.eclipse.jetty.client.HttpRequest.abort(HttpRequest.java:748)
at org.eclipse.jetty.client.HttpDestination.abort(HttpDestination.java:444)
at org.eclipse.jetty.client.HttpDestination.failed(HttpDestination.java:224)
at org.eclipse.jetty.client.AbstractConnectionPool$1.failed(AbstractConnectionPool.java:122)
at org.eclipse.jetty.util.Promise$Wrapper.failed(Promise.java:136)
at org.eclipse.jetty.client.HttpClient$1$1.failed(HttpClient.java:588)
at org.eclipse.jetty.client.AbstractHttpClientTransport.connectFailed(AbstractHttpClientTransport.java:154)
at org.eclipse.jetty.client.AbstractHttpClientTransport$ClientSelectorManager.connectionFailed(AbstractHttpClientTransport.java:199)
at org.eclipse.jetty.io.ManagedSelector$Connect.failed(ManagedSelector.java:655)
at org.eclipse.jetty.io.ManagedSelector$Connect.access$1300(ManagedSelector.java:622)
at org.eclipse.jetty.io.ManagedSelector$1.failed(ManagedSelector.java:364)
at org.eclipse.jetty.io.ManagedSelector$CreateEndPoint.run(ManagedSelector.java:604)
... 3 more
Caused
httpclient 抓取网页(如何开发一个Java爬虫(的设计机制及原理))
网站优化 • 优采云 发表了文章 • 0 个评论 • 167 次浏览 • 2022-04-07 09:29
httpclient 抓取网页(如何开发一个Java爬虫(的设计机制及原理))
最近在写一个小爬虫，准备爬取一部分网页数据进行模型训练。在考虑如何爬取和分析网页的时候，参考了OSC站的一些项目，特别是@黄一华写的webmagic的设计机制和原理——如何开发Java爬虫”文章给了很多启发，webmagic是一个垂直爬虫，而我想写的是一个比较通用的爬虫，主要是爬取中文网站对于HTTP协议和消息处理，没有比HttpClient组件更好的选择。对于HTML代码解析，后对比HTMLParser和Jsoup，后者在API的使用上优势明显，简洁易懂，在确定使用的开源组件后，
我的爬虫要爬取这部分功能，我只需要根据网页的URL爬取HTML代码，然后从HTML代码中解析出链接和HTML代码。
可以使用标签的文本，所以解析的结果可以用一个Page类来表示，纯粹是一个POJO，那么如何使用HttpClient和Jsoup直接解析成Page对象呢？
在HttpClient4.2中，提供了ResponseHandler接口，负责处理HttpResponse。因此，通过实现该接口，可以将返回的 HTML 代码解析为所需的 Page 对象。主要思路是先将HttpResponse中的数据读出来，转换成HTML代码，然后用jsoup解析
标签和标签。代码显示如下，
公共类 PageResponseHandler 实现 ResponseHandler
{
private Page page;
public PageResponseHandler(Page page) {
this.page = page;
}
public void setPage(Page page) {
this.page = page;
}
public Page getPage() {
return page;
}
@Override
public Page handleResponse(HttpResponse response) throws ClientProtocolException, IOException {
StatusLine statusLine = response.getStatusLine();
HttpEntity entity = response.getEntity();
if (statusLine.getStatusCode() >= 300) {
EntityUtils.consume(entity);
throw new HttpResponseException(statusLine.getStatusCode(), statusLine.getReasonPhrase());
}
if (entity == null)
return null;
// 利用HTTPClient自带的EntityUtils把当前HttpResponse中的HttpEntity转化成HTML代码
String html = EntityUtils.toString(entity);
Document document = Jsoup.parse(html);
Elements links = document.getElementsByTag("a");
for (int i = 0; i < links.size(); i++) {
Element link = links.get(i);
page.addAnchor(link.attr("href"), link.text());
}
// parse context of plain text from HTML code,
Elements paragraphs = document.getElementsByTag("p");
StringBuffer plainText = new StringBuffer(html.length() / 2);
for (int i = 0; i < paragraphs.size(); i++) {
Element paragraph = paragraphs.get(i);
plainText.append(paragraph.text()).append("\n");
}
page.setPlainText(plainText.toString());
return page;
}
}
代码不超过40行，非常简单。现在可以直接返回Page对象，编写一个测试类来测试这个PageResponseHandler。测试这个类的功能不需要复杂的代码。
公共类 PageResponseHandlerTest {
HttpClient httpclient;
PageResponseHandler pageResponseHandler;
final String url = "http://news.163.com/13/0903/11 ... 3B%3B
Page page = new Page(url);
@Before
public void setUp() throws Exception {
httpclient = new DefaultHttpClient();
HttpGet httpget = new HttpGet(url);
pageResponseHandler = new PageResponseHandler(page);
httpclient.execute(httpget, pageResponseHandler);
}
@After
public void tearDown() throws Exception {
httpclient.getConnectionManager().shutdown();
}
@Test
public void test() {
System.out.println(page.getPlainText());
assertTrue(page.getPlainText().length() > 0);
assertTrue(page.getAnchors().size() > 0);
}
}
到目前为止，该爬虫中的爬取和分析功能运行良好。对于中文，它们也可以很好地解析。比较细心的读者会看到，这些代码中并没有设置字符集，也没有对字符集进行转换，后面会讲到HttpClient4.2组件中的字符集处理。
让我们首先回顾一下 Content-Type 在 HTTP 协议的 RFC 规范中的作用。它指示发送给接收方 HttpEntity 的内容的媒体类型。对于text-type HttpEntity，通常采用如下形式，指定HttpEntity的媒体类型，使用另外，RFC规范还规定在Content-Type不指定字符集的情况下，ISO-8859-默认使用 1 个字符集来编码 Http Entity
1
内容类型：文本/html；字符集=UTF-8
说到这里，你应该可以猜到 HttpClient 4.2 是如何正确编码的——即使用 Content-Type 标头中收录的字符集作为输入源进行编码。具体代码见EntityUtils类第212行开始的代码。EntityUtils 首先从 HttpEntity 对象中获取 Content-Type。如果 Content-Type 的字符集不为空，则使用 Content-Type 对象中指定的字符集进行编码，否则使用开发者指定的字符集进行编码，如果开发者未指定字符集，默认字符集 iso-8859-1 用于编码。当然，编码实现是调用JDK的Reader类。
ContentType contentType = ContentType.getOrDefault(entity);
字符集 charset = contentType.getCharset();
if (charset == null) {
字符集 = 默认字符集；
}
if (charset == null) { 查看全部
最近在写一个小爬虫，准备爬取一部分网页数据进行模型训练。在考虑如何爬取和分析网页的时候，参考了OSC站的一些项目，特别是@黄一华写的webmagic的设计机制和原理——如何开发Java爬虫”文章给了很多启发，webmagic是一个垂直爬虫，而我想写的是一个比较通用的爬虫，主要是爬取中文网站对于HTTP协议和消息处理，没有比HttpClient组件更好的选择。对于HTML代码解析，后对比HTMLParser和Jsoup，后者在API的使用上优势明显，简洁易懂，在确定使用的开源组件后，
我的爬虫要爬取这部分功能，我只需要根据网页的URL爬取HTML代码，然后从HTML代码中解析出链接和HTML代码。
可以使用标签的文本，所以解析的结果可以用一个Page类来表示，纯粹是一个POJO，那么如何使用HttpClient和Jsoup直接解析成Page对象呢？
在HttpClient4.2中，提供了ResponseHandler接口，负责处理HttpResponse。因此，通过实现该接口，可以将返回的 HTML 代码解析为所需的 Page 对象。主要思路是先将HttpResponse中的数据读出来，转换成HTML代码，然后用jsoup解析
标签和标签。代码显示如下，
公共类 PageResponseHandler 实现 ResponseHandler
{
private Page page;
public PageResponseHandler(Page page) {
this.page = page;
}
public void setPage(Page page) {
this.page = page;
}
public Page getPage() {
return page;
}
@Override
public Page handleResponse(HttpResponse response) throws ClientProtocolException, IOException {
StatusLine statusLine = response.getStatusLine();
HttpEntity entity = response.getEntity();
if (statusLine.getStatusCode() >= 300) {
EntityUtils.consume(entity);
throw new HttpResponseException(statusLine.getStatusCode(), statusLine.getReasonPhrase());
}
if (entity == null)
return null;
// 利用HTTPClient自带的EntityUtils把当前HttpResponse中的HttpEntity转化成HTML代码
String html = EntityUtils.toString(entity);
Document document = Jsoup.parse(html);
Elements links = document.getElementsByTag("a");
for (int i = 0; i < links.size(); i++) {
Element link = links.get(i);
page.addAnchor(link.attr("href"), link.text());
}
// parse context of plain text from HTML code,
Elements paragraphs = document.getElementsByTag("p");
StringBuffer plainText = new StringBuffer(html.length() / 2);
for (int i = 0; i < paragraphs.size(); i++) {
Element paragraph = paragraphs.get(i);
plainText.append(paragraph.text()).append("\n");
}
page.setPlainText(plainText.toString());
return page;
}
}
代码不超过40行，非常简单。现在可以直接返回Page对象，编写一个测试类来测试这个PageResponseHandler。测试这个类的功能不需要复杂的代码。
公共类 PageResponseHandlerTest {
HttpClient httpclient;
PageResponseHandler pageResponseHandler;
final String url = "http://news.163.com/13/0903/11 ... 3B%3B
Page page = new Page(url);
@Before
public void setUp() throws Exception {
httpclient = new DefaultHttpClient();
HttpGet httpget = new HttpGet(url);
pageResponseHandler = new PageResponseHandler(page);
httpclient.execute(httpget, pageResponseHandler);
}
@After
public void tearDown() throws Exception {
httpclient.getConnectionManager().shutdown();
}
@Test
public void test() {
System.out.println(page.getPlainText());
assertTrue(page.getPlainText().length() > 0);
assertTrue(page.getAnchors().size() > 0);
}
}
到目前为止，该爬虫中的爬取和分析功能运行良好。对于中文，它们也可以很好地解析。比较细心的读者会看到，这些代码中并没有设置字符集，也没有对字符集进行转换，后面会讲到HttpClient4.2组件中的字符集处理。
让我们首先回顾一下 Content-Type 在 HTTP 协议的 RFC 规范中的作用。它指示发送给接收方 HttpEntity 的内容的媒体类型。对于text-type HttpEntity，通常采用如下形式，指定HttpEntity的媒体类型，使用另外，RFC规范还规定在Content-Type不指定字符集的情况下，ISO-8859-默认使用 1 个字符集来编码 Http Entity
1
内容类型：文本/html；字符集=UTF-8
说到这里，你应该可以猜到 HttpClient 4.2 是如何正确编码的——即使用 Content-Type 标头中收录的字符集作为输入源进行编码。具体代码见EntityUtils类第212行开始的代码。EntityUtils 首先从 HttpEntity 对象中获取 Content-Type。如果 Content-Type 的字符集不为空，则使用 Content-Type 对象中指定的字符集进行编码，否则使用开发者指定的字符集进行编码，如果开发者未指定字符集，默认字符集 iso-8859-1 用于编码。当然，编码实现是调用JDK的Reader类。
ContentType contentType = ContentType.getOrDefault(entity);
字符集 charset = contentType.getCharset();
if (charset == null) {
字符集 = 默认字符集；
}
if (charset == null) { 查看全部
httpclient 抓取网页(如何开发一个Java爬虫(的设计机制及原理))
最近在写一个小爬虫，准备爬取一部分网页数据进行模型训练。在考虑如何爬取和分析网页的时候，参考了OSC站的一些项目，特别是@黄一华写的webmagic的设计机制和原理——如何开发Java爬虫”文章给了很多启发，webmagic是一个垂直爬虫，而我想写的是一个比较通用的爬虫，主要是爬取中文网站对于HTTP协议和消息处理，没有比HttpClient组件更好的选择。对于HTML代码解析，后对比HTMLParser和Jsoup，后者在API的使用上优势明显，简洁易懂，在确定使用的开源组件后，
我的爬虫要爬取这部分功能，我只需要根据网页的URL爬取HTML代码，然后从HTML代码中解析出链接和HTML代码。
可以使用标签的文本，所以解析的结果可以用一个Page类来表示，纯粹是一个POJO，那么如何使用HttpClient和Jsoup直接解析成Page对象呢？
在HttpClient4.2中，提供了ResponseHandler接口，负责处理HttpResponse。因此，通过实现该接口，可以将返回的 HTML 代码解析为所需的 Page 对象。主要思路是先将HttpResponse中的数据读出来，转换成HTML代码，然后用jsoup解析
标签和标签。代码显示如下，
公共类 PageResponseHandler 实现 ResponseHandler
{
private Page page;
public PageResponseHandler(Page page) {
this.page = page;
}
public void setPage(Page page) {
this.page = page;
}
public Page getPage() {
return page;
}
@Override
public Page handleResponse(HttpResponse response) throws ClientProtocolException, IOException {
StatusLine statusLine = response.getStatusLine();
HttpEntity entity = response.getEntity();
if (statusLine.getStatusCode() >= 300) {
EntityUtils.consume(entity);
throw new HttpResponseException(statusLine.getStatusCode(), statusLine.getReasonPhrase());
}
if (entity == null)
return null;
// 利用HTTPClient自带的EntityUtils把当前HttpResponse中的HttpEntity转化成HTML代码
String html = EntityUtils.toString(entity);
Document document = Jsoup.parse(html);
Elements links = document.getElementsByTag("a");
for (int i = 0; i < links.size(); i++) {
Element link = links.get(i);
page.addAnchor(link.attr("href"), link.text());
}
// parse context of plain text from HTML code,
Elements paragraphs = document.getElementsByTag("p");
StringBuffer plainText = new StringBuffer(html.length() / 2);
for (int i = 0; i < paragraphs.size(); i++) {
Element paragraph = paragraphs.get(i);
plainText.append(paragraph.text()).append("\n");
}
page.setPlainText(plainText.toString());
return page;
}
}
代码不超过40行，非常简单。现在可以直接返回Page对象，编写一个测试类来测试这个PageResponseHandler。测试这个类的功能不需要复杂的代码。
公共类 PageResponseHandlerTest {
HttpClient httpclient;
PageResponseHandler pageResponseHandler;
final String url = "http://news.163.com/13/0903/11 ... 3B%3B
Page page = new Page(url);
@Before
public void setUp() throws Exception {
httpclient = new DefaultHttpClient();
HttpGet httpget = new HttpGet(url);
pageResponseHandler = new PageResponseHandler(page);
httpclient.execute(httpget, pageResponseHandler);
}
@After
public void tearDown() throws Exception {
httpclient.getConnectionManager().shutdown();
}
@Test
public void test() {
System.out.println(page.getPlainText());
assertTrue(page.getPlainText().length() > 0);
assertTrue(page.getAnchors().size() > 0);
}
}
到目前为止，该爬虫中的爬取和分析功能运行良好。对于中文，它们也可以很好地解析。比较细心的读者会看到，这些代码中并没有设置字符集，也没有对字符集进行转换，后面会讲到HttpClient4.2组件中的字符集处理。
让我们首先回顾一下 Content-Type 在 HTTP 协议的 RFC 规范中的作用。它指示发送给接收方 HttpEntity 的内容的媒体类型。对于text-type HttpEntity，通常采用如下形式，指定HttpEntity的媒体类型，使用另外，RFC规范还规定在Content-Type不指定字符集的情况下，ISO-8859-默认使用 1 个字符集来编码 Http Entity
1
内容类型：文本/html；字符集=UTF-8
说到这里，你应该可以猜到 HttpClient 4.2 是如何正确编码的——即使用 Content-Type 标头中收录的字符集作为输入源进行编码。具体代码见EntityUtils类第212行开始的代码。EntityUtils 首先从 HttpEntity 对象中获取 Content-Type。如果 Content-Type 的字符集不为空，则使用 Content-Type 对象中指定的字符集进行编码，否则使用开发者指定的字符集进行编码，如果开发者未指定字符集，默认字符集 iso-8859-1 用于编码。当然，编码实现是调用JDK的Reader类。
ContentType contentType = ContentType.getOrDefault(entity);
字符集 charset = contentType.getCharset();
if (charset == null) {
字符集 = 默认字符集；
}
if (charset == null) {
httpclient 抓取网页(想用的使用参考Java11新特性之HttpClient_java_之家之家)
网站优化 • 优采云 发表了文章 • 0 个评论 • 87 次浏览 • 2022-03-28 03:08
httpclient 抓取网页(想用的使用参考Java11新特性之HttpClient_java_之家之家)
从必应主页抓取他的日常照片
上学的时候用python写了一个小工具，每天抓一张bing的图片。
现在想用java来重构。
抓取图片的想法
首先获取网页的源代码
从网页源代码中，我们可以找到图片的下载链接和图片的描述信息。
使用下载链接获取对应图片。
使用 python 抓取
我们使用python中的requests库来获取网页的源代码，然后使用正则表达式从网页的源代码中搜索图片的下载链接。
res = requests.get(url) #获取网页源码，并利用正则表达式找到与bing每日一图有关的参数
pattern = re.compile(r"(\/th\?id=(.+?)\.jpg)")
# pattern = re.compile(r"\/th\?id=(.+)(\.jpg)")
result = pattern.search(res.text) #从源码中获取bing大图的图片链接
imgLinkParam = result.group(0).split("&")
imgDownloadUrl = url+"&".join(imgLinkParam)
得到图片的下载地址后，还需要从网页中找到图片的标题。
这里我们使用 BeautifulSoup 库来解析网页。
查找所有class="title"的a节点，取a的第一个节点，其内容为图片的标题。
soup = BeautifulSoup(res.text,'lxml') #使用bs4来解析对应的html文件
#print(soup)
# imageInfo = soup.find_all(name="a",attrs={"id":"sh_cp","class":"sc_light"})
imageInfo = soup.find_all(name="a", attrs={"class":"title"})
imageDescription=imageInfo[0].contents[0] #获取对图片的描述
最后我们根据图片链接下载图片到本地
pictureData = requests.get(imgDownloadUrl) #根据下载链接获取图片数据
with open(imgName,"wb") as f:
f.write(pictureData.content)
f.flush()
log_write(logName,"图片保存成功")
如何使用java重构代码
思路和之前python的实现大致相同，先获取bing首页的html内容，然后解析html得到需要的内容。然后下载图片
首先需要构造一个http请求，根据链接发送请求并下载图片文件。这里我们使用java 11自带的HttpClient来发送http请求。
HttpClient的使用参考Java11的新特性，HttpClient小测试knife_java_Script Home() 查看全部
从必应主页抓取他的日常照片
上学的时候用python写了一个小工具，每天抓一张bing的图片。
现在想用java来重构。
抓取图片的想法
首先获取网页的源代码
从网页源代码中，我们可以找到图片的下载链接和图片的描述信息。
使用下载链接获取对应图片。
使用 python 抓取
我们使用python中的requests库来获取网页的源代码，然后使用正则表达式从网页的源代码中搜索图片的下载链接。
res = requests.get(url) #获取网页源码，并利用正则表达式找到与bing每日一图有关的参数
pattern = re.compile(r"(\/th\?id=(.+?)\.jpg)")
# pattern = re.compile(r"\/th\?id=(.+)(\.jpg)")
result = pattern.search(res.text) #从源码中获取bing大图的图片链接
imgLinkParam = result.group(0).split("&")
imgDownloadUrl = url+"&".join(imgLinkParam)
得到图片的下载地址后，还需要从网页中找到图片的标题。
这里我们使用 BeautifulSoup 库来解析网页。
查找所有class="title"的a节点，取a的第一个节点，其内容为图片的标题。
soup = BeautifulSoup(res.text,'lxml') #使用bs4来解析对应的html文件
#print(soup)
# imageInfo = soup.find_all(name="a",attrs={"id":"sh_cp","class":"sc_light"})
imageInfo = soup.find_all(name="a", attrs={"class":"title"})
imageDescription=imageInfo[0].contents[0] #获取对图片的描述
最后我们根据图片链接下载图片到本地
pictureData = requests.get(imgDownloadUrl) #根据下载链接获取图片数据
with open(imgName,"wb") as f:
f.write(pictureData.content)
f.flush()
log_write(logName,"图片保存成功")
如何使用java重构代码
思路和之前python的实现大致相同，先获取bing首页的html内容，然后解析html得到需要的内容。然后下载图片
首先需要构造一个http请求，根据链接发送请求并下载图片文件。这里我们使用java 11自带的HttpClient来发送http请求。
HttpClient的使用参考Java11的新特性，HttpClient小测试knife_java_Script Home() 查看全部
httpclient 抓取网页(想用的使用参考Java11新特性之HttpClient_java_之家之家)
从必应主页抓取他的日常照片
上学的时候用python写了一个小工具，每天抓一张bing的图片。
现在想用java来重构。
抓取图片的想法
首先获取网页的源代码
从网页源代码中，我们可以找到图片的下载链接和图片的描述信息。
使用下载链接获取对应图片。
使用 python 抓取
我们使用python中的requests库来获取网页的源代码，然后使用正则表达式从网页的源代码中搜索图片的下载链接。
res = requests.get(url) #获取网页源码，并利用正则表达式找到与bing每日一图有关的参数
pattern = re.compile(r"(\/th\?id=(.+?)\.jpg)")
# pattern = re.compile(r"\/th\?id=(.+)(\.jpg)")
result = pattern.search(res.text) #从源码中获取bing大图的图片链接
imgLinkParam = result.group(0).split("&")
imgDownloadUrl = url+"&".join(imgLinkParam)
得到图片的下载地址后，还需要从网页中找到图片的标题。
这里我们使用 BeautifulSoup 库来解析网页。
查找所有class="title"的a节点，取a的第一个节点，其内容为图片的标题。
soup = BeautifulSoup(res.text,'lxml') #使用bs4来解析对应的html文件
#print(soup)
# imageInfo = soup.find_all(name="a",attrs={"id":"sh_cp","class":"sc_light"})
imageInfo = soup.find_all(name="a", attrs={"class":"title"})
imageDescription=imageInfo[0].contents[0] #获取对图片的描述
最后我们根据图片链接下载图片到本地
pictureData = requests.get(imgDownloadUrl) #根据下载链接获取图片数据
with open(imgName,"wb") as f:
f.write(pictureData.content)
f.flush()
log_write(logName,"图片保存成功")
如何使用java重构代码
思路和之前python的实现大致相同，先获取bing首页的html内容，然后解析html得到需要的内容。然后下载图片
首先需要构造一个http请求，根据链接发送请求并下载图片文件。这里我们使用java 11自带的HttpClient来发送http请求。
HttpClient的使用参考Java11的新特性，HttpClient小测试knife_java_Script Home()
httpclient 抓取网页(想用的使用参考Java11新特性之HttpClient_java_之家之家)
网站优化 • 优采云 发表了文章 • 0 个评论 • 75 次浏览 • 2022-03-23 00:28
httpclient 抓取网页(想用的使用参考Java11新特性之HttpClient_java_之家之家)
从必应主页抓取他的日常照片
上学的时候用python写了一个小工具，每天抓一张bing的图片。
现在想用java来重构。
抓取图片的想法
首先获取网页的源代码
从网页源代码中，我们可以找到图片的下载链接和图片的描述信息。
使用下载链接获取对应图片。
使用 python 抓取
我们使用python中的requests库来获取网页的源代码，然后使用正则表达式从网页的源代码中搜索图片的下载链接。
res = requests.get(url) #获取网页源码，并利用正则表达式找到与bing每日一图有关的参数
pattern = re.compile(r"(\/th\?id=(.+?)\.jpg)")
# pattern = re.compile(r"\/th\?id=(.+)(\.jpg)")
result = pattern.search(res.text) #从源码中获取bing大图的图片链接
imgLinkParam = result.group(0).split("&")
imgDownloadUrl = url+"&".join(imgLinkParam)
得到图片的下载地址后，还需要从网页中找到图片的标题。
这里我们使用 BeautifulSoup 库来解析网页。
查找所有class="title"的a节点，取a的第一个节点，其内容为图片的标题。
soup = BeautifulSoup(res.text,'lxml') #使用bs4来解析对应的html文件
#print(soup)
# imageInfo = soup.find_all(name="a",attrs={"id":"sh_cp","class":"sc_light"})
imageInfo = soup.find_all(name="a", attrs={"class":"title"})
imageDescription=imageInfo[0].contents[0] #获取对图片的描述
最后我们根据图片链接下载图片到本地
pictureData = requests.get(imgDownloadUrl) #根据下载链接获取图片数据
with open(imgName,"wb") as f:
f.write(pictureData.content)
f.flush()
log_write(logName,"图片保存成功")
如何使用java重构代码
思路和之前python的实现大致相同，先获取bing首页的html内容，然后解析html得到需要的内容。然后下载图片
首先，根据链接发送请求和下载图片文件需要构造http请求。这里我们使用java 11自带的HttpClient来发送http请求。
HttpClient的使用参考Java11的新特性，HttpClient小测试knife_java_Script Home() 查看全部
从必应主页抓取他的日常照片
上学的时候用python写了一个小工具，每天抓一张bing的图片。
现在想用java来重构。
抓取图片的想法
首先获取网页的源代码
从网页源代码中，我们可以找到图片的下载链接和图片的描述信息。
使用下载链接获取对应图片。
使用 python 抓取
我们使用python中的requests库来获取网页的源代码，然后使用正则表达式从网页的源代码中搜索图片的下载链接。
res = requests.get(url) #获取网页源码，并利用正则表达式找到与bing每日一图有关的参数
pattern = re.compile(r"(\/th\?id=(.+?)\.jpg)")
# pattern = re.compile(r"\/th\?id=(.+)(\.jpg)")
result = pattern.search(res.text) #从源码中获取bing大图的图片链接
imgLinkParam = result.group(0).split("&")
imgDownloadUrl = url+"&".join(imgLinkParam)
得到图片的下载地址后，还需要从网页中找到图片的标题。
这里我们使用 BeautifulSoup 库来解析网页。
查找所有class="title"的a节点，取a的第一个节点，其内容为图片的标题。
soup = BeautifulSoup(res.text,'lxml') #使用bs4来解析对应的html文件
#print(soup)
# imageInfo = soup.find_all(name="a",attrs={"id":"sh_cp","class":"sc_light"})
imageInfo = soup.find_all(name="a", attrs={"class":"title"})
imageDescription=imageInfo[0].contents[0] #获取对图片的描述
最后我们根据图片链接下载图片到本地
pictureData = requests.get(imgDownloadUrl) #根据下载链接获取图片数据
with open(imgName,"wb") as f:
f.write(pictureData.content)
f.flush()
log_write(logName,"图片保存成功")
如何使用java重构代码
思路和之前python的实现大致相同，先获取bing首页的html内容，然后解析html得到需要的内容。然后下载图片
首先，根据链接发送请求和下载图片文件需要构造http请求。这里我们使用java 11自带的HttpClient来发送http请求。
HttpClient的使用参考Java11的新特性，HttpClient小测试knife_java_Script Home() 查看全部
httpclient 抓取网页(想用的使用参考Java11新特性之HttpClient_java_之家之家)
从必应主页抓取他的日常照片
上学的时候用python写了一个小工具，每天抓一张bing的图片。
现在想用java来重构。
抓取图片的想法
首先获取网页的源代码
从网页源代码中，我们可以找到图片的下载链接和图片的描述信息。
使用下载链接获取对应图片。
使用 python 抓取
我们使用python中的requests库来获取网页的源代码，然后使用正则表达式从网页的源代码中搜索图片的下载链接。
res = requests.get(url) #获取网页源码，并利用正则表达式找到与bing每日一图有关的参数
pattern = re.compile(r"(\/th\?id=(.+?)\.jpg)")
# pattern = re.compile(r"\/th\?id=(.+)(\.jpg)")
result = pattern.search(res.text) #从源码中获取bing大图的图片链接
imgLinkParam = result.group(0).split("&")
imgDownloadUrl = url+"&".join(imgLinkParam)
得到图片的下载地址后，还需要从网页中找到图片的标题。
这里我们使用 BeautifulSoup 库来解析网页。
查找所有class="title"的a节点，取a的第一个节点，其内容为图片的标题。
soup = BeautifulSoup(res.text,'lxml') #使用bs4来解析对应的html文件
#print(soup)
# imageInfo = soup.find_all(name="a",attrs={"id":"sh_cp","class":"sc_light"})
imageInfo = soup.find_all(name="a", attrs={"class":"title"})
imageDescription=imageInfo[0].contents[0] #获取对图片的描述
最后我们根据图片链接下载图片到本地
pictureData = requests.get(imgDownloadUrl) #根据下载链接获取图片数据
with open(imgName,"wb") as f:
f.write(pictureData.content)
f.flush()
log_write(logName,"图片保存成功")
如何使用java重构代码
思路和之前python的实现大致相同，先获取bing首页的html内容，然后解析html得到需要的内容。然后下载图片
首先，根据链接发送请求和下载图片文件需要构造http请求。这里我们使用java 11自带的HttpClient来发送http请求。
HttpClient的使用参考Java11的新特性，HttpClient小测试knife_java_Script Home()
httpclient 抓取网页(STM32 )
网站优化 • 优采云 发表了文章 • 0 个评论 • 75 次浏览 • 2022-03-19 22:21
httpclient 抓取网页(STM32
)
1、GET 方法
第一步是创建一个客户端，类似于使用浏览器打开网页的方式
HttpClient httpClient = new HttpClient();
第二步，创建GET方法，获取需要抓取的网页的URL
GetMethod getMethod = new GetMethod("");
第三步，获取URL的响应状态码，200表示请求成功
int statusCode = httpClient.executeMethod(getMethod);
第四步，获取网页源代码
byte[] responseBody = getMethod.getResponseBody();
主要是这四个步骤，当然还有很多其他的，比如网页编码问题
[java] view plain copy print ?
HttpClient httpClient = new HttpClient(); GetMethod getMethod = new GetMethod("http://www.baidu.com/"); try { int statusCode = httpClient.executeMethod(getMethod); if (statusCode != HttpStatus.SC_OK) { System.err.println("Method failed: " + getMethod.getStatusLine()); } // 读取内容 byte[] responseBody = getMethod.getResponseBody(); // 处理内容 String html = new String(responseBody); System.out.println(html); } catch (Exception e) { System.err.println("页面无法访问"); }finally{ getMethod.releaseConnection(); }
2、发布方式
[java] view plain copy print ?
HttpClient httpClient = new HttpClient(); PostMethod postMethod = new PostMethod(UrlPath); postMethod.getParams().setParameter(HttpMethodParams.RETRY_HANDLER,new DefaultHttpMethodRetryHandler()); NameValuePair[] postData = new NameValuePair[2]; postData[0] = new NameValuePair("username", "xkey"); postData[1] = new NameValuePair("userpass", "********"); postMethod.setRequestBody(postData); try { int statusCode = httpClient.executeMethod(postMethod); if (statusCode == HttpStatus.SC_OK) { byte[] responseBody = postMethod.getResponseBody(); String html = new String(responseBody); System.out.println(html); } } catch (Exception e) { System.err.println("页面无法访问"); }finally{ postMethod.releaseConnection(); }
本例传递两个Post参数：username为xkey，userpass为********，传递给URL UrlPath
如果您需要更多关于获取 gzip 页面的信息，请参考
另外一种是获取非字符数据，所以可以使用下面的方法
[java] view plain copy print ?
HttpClient httpClient = new HttpClient(); GetMethod getMethod = new GetMethod("http://www.baidu.com"); try { InputStream inputStream = getMethod.getResponseBodyAsStream(); // 这里处理 inputStream } catch (Exception e) { System.err.println("页面无法访问"); }finally{ getMethod.releaseConnection(); } 查看全部
)
1、GET 方法
第一步是创建一个客户端，类似于使用浏览器打开网页的方式
HttpClient httpClient = new HttpClient();
第二步，创建GET方法，获取需要抓取的网页的URL
GetMethod getMethod = new GetMethod("");
第三步，获取URL的响应状态码，200表示请求成功
int statusCode = httpClient.executeMethod(getMethod);
第四步，获取网页源代码
byte[] responseBody = getMethod.getResponseBody();
主要是这四个步骤，当然还有很多其他的，比如网页编码问题
[java] view plain copy print ?
HttpClient httpClient = new HttpClient(); GetMethod getMethod = new GetMethod("http://www.baidu.com/"); try { int statusCode = httpClient.executeMethod(getMethod); if (statusCode != HttpStatus.SC_OK) { System.err.println("Method failed: " + getMethod.getStatusLine()); } // 读取内容 byte[] responseBody = getMethod.getResponseBody(); // 处理内容 String html = new String(responseBody); System.out.println(html); } catch (Exception e) { System.err.println("页面无法访问"); }finally{ getMethod.releaseConnection(); }
2、发布方式
[java] view plain copy print ?
HttpClient httpClient = new HttpClient(); PostMethod postMethod = new PostMethod(UrlPath); postMethod.getParams().setParameter(HttpMethodParams.RETRY_HANDLER,new DefaultHttpMethodRetryHandler()); NameValuePair[] postData = new NameValuePair[2]; postData[0] = new NameValuePair("username", "xkey"); postData[1] = new NameValuePair("userpass", "********"); postMethod.setRequestBody(postData); try { int statusCode = httpClient.executeMethod(postMethod); if (statusCode == HttpStatus.SC_OK) { byte[] responseBody = postMethod.getResponseBody(); String html = new String(responseBody); System.out.println(html); } } catch (Exception e) { System.err.println("页面无法访问"); }finally{ postMethod.releaseConnection(); }
本例传递两个Post参数：username为xkey，userpass为********，传递给URL UrlPath
如果您需要更多关于获取 gzip 页面的信息，请参考
另外一种是获取非字符数据，所以可以使用下面的方法
[java] view plain copy print ?
HttpClient httpClient = new HttpClient(); GetMethod getMethod = new GetMethod("http://www.baidu.com"); try { InputStream inputStream = getMethod.getResponseBodyAsStream(); // 这里处理 inputStream } catch (Exception e) { System.err.println("页面无法访问"); }finally{ getMethod.releaseConnection(); } 查看全部
httpclient 抓取网页(STM32
)
1、GET 方法
第一步是创建一个客户端，类似于使用浏览器打开网页的方式
HttpClient httpClient = new HttpClient();
第二步，创建GET方法，获取需要抓取的网页的URL
GetMethod getMethod = new GetMethod("");
第三步，获取URL的响应状态码，200表示请求成功
int statusCode = httpClient.executeMethod(getMethod);
第四步，获取网页源代码
byte[] responseBody = getMethod.getResponseBody();
主要是这四个步骤，当然还有很多其他的，比如网页编码问题
[java] view plain copy print ?
HttpClient httpClient = new HttpClient(); GetMethod getMethod = new GetMethod("http://www.baidu.com/";); try { int statusCode = httpClient.executeMethod(getMethod); if (statusCode != HttpStatus.SC_OK) { System.err.println("Method failed: " + getMethod.getStatusLine()); } // 读取内容 byte[] responseBody = getMethod.getResponseBody(); // 处理内容 String html = new String(responseBody); System.out.println(html); } catch (Exception e) { System.err.println("页面无法访问"); }finally{ getMethod.releaseConnection(); }
2、发布方式
[java] view plain copy print ?
HttpClient httpClient = new HttpClient(); PostMethod postMethod = new PostMethod(UrlPath); postMethod.getParams().setParameter(HttpMethodParams.RETRY_HANDLER,new DefaultHttpMethodRetryHandler()); NameValuePair[] postData = new NameValuePair[2]; postData[0] = new NameValuePair("username", "xkey"); postData[1] = new NameValuePair("userpass", "********"); postMethod.setRequestBody(postData); try { int statusCode = httpClient.executeMethod(postMethod); if (statusCode == HttpStatus.SC_OK) { byte[] responseBody = postMethod.getResponseBody(); String html = new String(responseBody); System.out.println(html); } } catch (Exception e) { System.err.println("页面无法访问"); }finally{ postMethod.releaseConnection(); }
本例传递两个Post参数：username为xkey，userpass为********，传递给URL UrlPath
如果您需要更多关于获取 gzip 页面的信息，请参考
另外一种是获取非字符数据，所以可以使用下面的方法
[java] view plain copy print ?
HttpClient httpClient = new HttpClient(); GetMethod getMethod = new GetMethod("http://www.baidu.com";); try { InputStream inputStream = getMethod.getResponseBodyAsStream(); // 这里处理 inputStream } catch (Exception e) { System.err.println("页面无法访问"); }finally{ getMethod.releaseConnection(); }
httpclient 抓取网页(缺点是需要人工寻找post请求的url和对应的参数 )
网站优化 • 优采云 发表了文章 • 0 个评论 • 60 次浏览 • 2022-03-07 18:19
httpclient 抓取网页(缺点是需要人工寻找post请求的url和对应的参数
)
缺点是需要手动查找post请求的url和对应的参数。
参考：
1.为 GET 和 POST 请求添加请求参数和标头（使用 HttpClient，Java）
2.关于爬取js加载的内容（参考本博客的流程，比如找到实际的请求url）
以一条新闻为例：
1.使用F12，先在网络中的文件列表中找到该网页，双击弹出详细信息。“文本”查看网页内容，发现该信息对应的信息没有显示在网页上，说明是稍后加载的。
2.尝试在文本中搜索关键字以查看正在请求哪些文件获取数据。例如，在文本中搜索第一个单词“海关总署”可能会找到多个文件，需要进行判断和选择。
对应的请求体为“id:98212”，即请求参数
3.查看标题
主要取决于请求的url和请求的方法，有时还需要设置user-agent。需要使用post方法
4.代码编写
创建一个 Java Maven 项目并添加依赖项：
org.apache.httpcomponents
httpclient
4.5.6
com.google.code.gson
gson
2.2.4
下载的jar包如下图所示：
代码如下，我只拿到了文章的body：
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import org.apache.http.HttpEntity;
import org.apache.http.NameValuePair;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.util.EntityUtils;
import com.google.gson.Gson;
/**
* http://news.cqcoal.com/blank/nc.jsp?mid=98212
* 该网页的新闻主题是动态生成的，希望获取内容
* @author yangc_cong
*
*/
public class TestNewContent {
/**
* 针对请求的链接，使用post方法获取返回的数据
* @param urlStr String类型
* @return 这里是Map类型
*/
private Map getPageContByHttpCl(String urlStr) {
CloseableHttpClient httpclient = HttpClients.createDefault();
HttpPost post = new HttpPost(urlStr);
String userAgent = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/70.0.3538.102 Safari/537.36 Edge/18.18362";
post.setHeader("User-Agent", userAgent);
CloseableHttpResponse response = null;
String result = null;
// 创建请求参数
List list = new LinkedList();
BasicNameValuePair param1 = new BasicNameValuePair("id", "98212");
list.add(param1);
// 使用URL实体转换工具
UrlEncodedFormEntity entityParam = null;
try {
entityParam = new UrlEncodedFormEntity(list, "UTF-8");
post.setEntity(entityParam);
} catch (UnsupportedEncodingException e1) {
e1.printStackTrace();
}
try {
response = httpclient.execute(post);
HttpEntity entity = response.getEntity();
result = EntityUtils.toString(entity, "UTF-8");
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
response.close();
httpclient.close();
} catch (IOException e) {
e.printStackTrace();
}
}
System.out.println(result);
Gson gson = new Gson();
Map map = gson.fromJson(result, Map.class);
return map;
}
private void parse_content(Map map) {
//java.lang.ClassCastException: java.util.ArrayList cannot be cast to java.util.Map
ArrayList arrayList = (ArrayList)(map.get("rows"));
Map innerMap = (Map) arrayList.get(0);
String source = (String) innerMap.get("source");
String bodyhtml = (String) innerMap.get("body");
System.out.println("source: "+source);
System.out.println("bodyhtml:"+'\n'+bodyhtml);
}
public static void main(String[] args) {
TestNewContent test1 = new TestNewContent();
String urlStr = "http://news.cqcoal.com/manage/ ... 3B%3B
Map map = test1.getPageContByHttpCl(urlStr);
test1.parse_content(map);
}
}
运行截图：
查看全部
)
缺点是需要手动查找post请求的url和对应的参数。
参考：
1.为 GET 和 POST 请求添加请求参数和标头（使用 HttpClient，Java）
2.关于爬取js加载的内容（参考本博客的流程，比如找到实际的请求url）
以一条新闻为例：
1.使用F12，先在网络中的文件列表中找到该网页，双击弹出详细信息。“文本”查看网页内容，发现该信息对应的信息没有显示在网页上，说明是稍后加载的。
2.尝试在文本中搜索关键字以查看正在请求哪些文件获取数据。例如，在文本中搜索第一个单词“海关总署”可能会找到多个文件，需要进行判断和选择。
对应的请求体为“id:98212”，即请求参数
3.查看标题
主要取决于请求的url和请求的方法，有时还需要设置user-agent。需要使用post方法
4.代码编写
创建一个 Java Maven 项目并添加依赖项：
org.apache.httpcomponents
httpclient
4.5.6
com.google.code.gson
gson
2.2.4
下载的jar包如下图所示：
代码如下，我只拿到了文章的body：
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import org.apache.http.HttpEntity;
import org.apache.http.NameValuePair;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.util.EntityUtils;
import com.google.gson.Gson;
/**
* http://news.cqcoal.com/blank/nc.jsp?mid=98212
* 该网页的新闻主题是动态生成的，希望获取内容
* @author yangc_cong
*
*/
public class TestNewContent {
/**
* 针对请求的链接，使用post方法获取返回的数据
* @param urlStr String类型
* @return 这里是Map类型
*/
private Map getPageContByHttpCl(String urlStr) {
CloseableHttpClient httpclient = HttpClients.createDefault();
HttpPost post = new HttpPost(urlStr);
String userAgent = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/70.0.3538.102 Safari/537.36 Edge/18.18362";
post.setHeader("User-Agent", userAgent);
CloseableHttpResponse response = null;
String result = null;
// 创建请求参数
List list = new LinkedList();
BasicNameValuePair param1 = new BasicNameValuePair("id", "98212");
list.add(param1);
// 使用URL实体转换工具
UrlEncodedFormEntity entityParam = null;
try {
entityParam = new UrlEncodedFormEntity(list, "UTF-8");
post.setEntity(entityParam);
} catch (UnsupportedEncodingException e1) {
e1.printStackTrace();
}
try {
response = httpclient.execute(post);
HttpEntity entity = response.getEntity();
result = EntityUtils.toString(entity, "UTF-8");
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
response.close();
httpclient.close();
} catch (IOException e) {
e.printStackTrace();
}
}
System.out.println(result);
Gson gson = new Gson();
Map map = gson.fromJson(result, Map.class);
return map;
}
private void parse_content(Map map) {
//java.lang.ClassCastException: java.util.ArrayList cannot be cast to java.util.Map
ArrayList arrayList = (ArrayList)(map.get("rows"));
Map innerMap = (Map) arrayList.get(0);
String source = (String) innerMap.get("source");
String bodyhtml = (String) innerMap.get("body");
System.out.println("source: "+source);
System.out.println("bodyhtml:"+'\n'+bodyhtml);
}
public static void main(String[] args) {
TestNewContent test1 = new TestNewContent();
String urlStr = "http://news.cqcoal.com/manage/ ... 3B%3B
Map map = test1.getPageContByHttpCl(urlStr);
test1.parse_content(map);
}
}
运行截图：
查看全部
httpclient 抓取网页(缺点是需要人工寻找post请求的url和对应的参数
)
缺点是需要手动查找post请求的url和对应的参数。
参考：
1.为 GET 和 POST 请求添加请求参数和标头（使用 HttpClient，Java）
2.关于爬取js加载的内容（参考本博客的流程，比如找到实际的请求url）
以一条新闻为例：
1.使用F12，先在网络中的文件列表中找到该网页，双击弹出详细信息。“文本”查看网页内容，发现该信息对应的信息没有显示在网页上，说明是稍后加载的。
2.尝试在文本中搜索关键字以查看正在请求哪些文件获取数据。例如，在文本中搜索第一个单词“海关总署”可能会找到多个文件，需要进行判断和选择。
对应的请求体为“id:98212”，即请求参数
3.查看标题
主要取决于请求的url和请求的方法，有时还需要设置user-agent。需要使用post方法
4.代码编写
创建一个 Java Maven 项目并添加依赖项：
org.apache.httpcomponents
httpclient
4.5.6
com.google.code.gson
gson
2.2.4
下载的jar包如下图所示：
代码如下，我只拿到了文章的body：
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import org.apache.http.HttpEntity;
import org.apache.http.NameValuePair;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.util.EntityUtils;
import com.google.gson.Gson;
/**
* http://news.cqcoal.com/blank/nc.jsp?mid=98212
* 该网页的新闻主题是动态生成的，希望获取内容
* @author yangc_cong
*
*/
public class TestNewContent {
/**
* 针对请求的链接，使用post方法获取返回的数据
* @param urlStr String类型
* @return 这里是Map类型
*/
private Map getPageContByHttpCl(String urlStr) {
CloseableHttpClient httpclient = HttpClients.createDefault();
HttpPost post = new HttpPost(urlStr);
String userAgent = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/70.0.3538.102 Safari/537.36 Edge/18.18362";
post.setHeader("User-Agent", userAgent);
CloseableHttpResponse response = null;
String result = null;
// 创建请求参数
List list = new LinkedList();
BasicNameValuePair param1 = new BasicNameValuePair("id", "98212");
list.add(param1);
// 使用URL实体转换工具
UrlEncodedFormEntity entityParam = null;
try {
entityParam = new UrlEncodedFormEntity(list, "UTF-8");
post.setEntity(entityParam);
} catch (UnsupportedEncodingException e1) {
e1.printStackTrace();
}
try {
response = httpclient.execute(post);
HttpEntity entity = response.getEntity();
result = EntityUtils.toString(entity, "UTF-8");
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
response.close();
httpclient.close();
} catch (IOException e) {
e.printStackTrace();
}
}
System.out.println(result);
Gson gson = new Gson();
Map map = gson.fromJson(result, Map.class);
return map;
}
private void parse_content(Map map) {
//java.lang.ClassCastException: java.util.ArrayList cannot be cast to java.util.Map
ArrayList arrayList = (ArrayList)(map.get("rows"));
Map innerMap = (Map) arrayList.get(0);
String source = (String) innerMap.get("source");
String bodyhtml = (String) innerMap.get("body");
System.out.println("source: "+source);
System.out.println("bodyhtml:"+'\n'+bodyhtml);
}
public static void main(String[] args) {
TestNewContent test1 = new TestNewContent();
String urlStr = "http://news.cqcoal.com/manage/ ... 3B%3B
Map map = test1.getPageContByHttpCl(urlStr);
test1.parse_content(map);
}
}
运行截图：
httpclient 抓取网页(Java的Http协议客户端HttpClient来实现抓取网页数据(组图))
网站优化 • 优采云 发表了文章 • 0 个评论 • 89 次浏览 • 2022-02-28 21:08
httpclient 抓取网页(Java的Http协议客户端HttpClient来实现抓取网页数据(组图))
爬虫爬取网页上的数据和我们点击链接单独访问网页数据是一样的。就是使用Http协议访问网页。这里我们使用Java Http协议客户端HttpClient来实现网页数据的抓取。
你好世界
获取带参数的请求
使用参数发布请求
帖子也很简单，和上面差不多，只是改变发起请求的方式，如下：
当然，如果没有参数，就不需要创建表单对象，只要有一个HttpPost对象即可。
代码中的对象说明：
代码优化：连接池
在爬取数据的过程中，连接对象HttpClient的创建和销毁非常频繁，这里我们使用连接池对其进行优化
public class poolTest {
public static void main(String[] args) {
//创建连接池管理器
PoolingHttpClientConnectionManager pcm = new PoolingHttpClientConnectionManager();
pcm.setMaxTotal(100); //设置池内最大连接数
pcm.setDefaultMaxPerRoute(10); //设置每个坠机的最大连接数
//从连接池中获取连接对象，而不是单独创建连接对象
CloseableHttpClient httpClient = HttpClients.custom().setConnectionManager(pcm).build();
HttpGet httpGet = new HttpGet("https://www.cnblogs.com/msi-chen");
System.out.println(httpGet);
//使用httpClient发起请求，获得响应
CloseableHttpResponse response = null;
try {
response = httpClient.execute(httpGet);
//解析响应，获取到数据
if (response.getStatusLine().getStatusCode() == 200){
HttpEntity entity = response.getEntity();
String content = EntityUtils.toString(entity,"utf8");
System.out.println(content.length());
}
} catch (IOException e) {
e.printStackTrace();
}finally {
if (response != null){
try {
response.close();
} catch (IOException e) {
e.printStackTrace();
}
//因为我们是连接池中获取到的连接，所以这里不能再给他关闭了
//httpClient.close();
}
}
}
}
获取资源的相关时间配置
Jsoup 不是 Jsonp
经过我们上面的学习，我们已经可以通过HttpClient抓取页面了。抓取页面后，我们就可以解析了。我们可以使用字符串解析工具来解析页面，也可以使用正则表达式。解析，但是这两种方案的开发成本很高，不推荐使用。这里我们学习了一个解析html页面的技术，Jsonp
Jsoup简介
jsonp是一个Java Html解析器，可以自己解析一个url地址和html文本内容。它有一组现成的 API 来删除和操作数据。
jsonp的特点：
Jsoup解析网址
添加Jsoup的依赖以使用Jsoup
注意：Jsoup只限于使用Html解析工具，不能代替HttpClient发起请求，因为HttpClient支持多线程、连接池、代理等技术，而Jsoup对此的支持并不理想，专业的事情交给专业的人，HttpClient发送请求抓取数据，Jsoup做解析
Jsoup解析字符串
Jsoup解析文件
还是上面的静态页面，除了转成String后面再解析，我们也可以直接解析文件
使用 Dom 方法遍历文档
记得还有一个sax解析，比较麻烦，现在差点忘了；
dom解析，不知道大家有没有听说过或者用过。反正我以前用过，但是解析的确实是XML。让我简单介绍一个Dmo方法。
Dmo 解析会将目标文档视为对象。首先，将整个文档加载到内存中。如果文档太大，内存可能会溢出（一般不会）。加载到内存后，会构建一个Dom树，然后进行访问和修改操作
没学过的，我们通过一个小demo来了解一下。如果您使用过它，我们应该对其进行审查：
Java代码如下： 我已经演示了几个常用的获取页面数据的API
从元素中获取属性
选择器选择器
下面是上述always选择器的使用演示
选择器选择器组合使用
Hello World 级爬虫小箱子
在上面的学习中，我们已经知道HttpClient的作用是爬取数据，而Jsoup是解析HttpClient爬取的数据。让我们练习一下这两个工具的使用。
搁浅了一阵子，暂时……以后更新 查看全部
爬虫爬取网页上的数据和我们点击链接单独访问网页数据是一样的。就是使用Http协议访问网页。这里我们使用Java Http协议客户端HttpClient来实现网页数据的抓取。
你好世界
获取带参数的请求
使用参数发布请求
帖子也很简单，和上面差不多，只是改变发起请求的方式，如下：
当然，如果没有参数，就不需要创建表单对象，只要有一个HttpPost对象即可。
代码中的对象说明：
代码优化：连接池
在爬取数据的过程中，连接对象HttpClient的创建和销毁非常频繁，这里我们使用连接池对其进行优化
public class poolTest {
public static void main(String[] args) {
//创建连接池管理器
PoolingHttpClientConnectionManager pcm = new PoolingHttpClientConnectionManager();
pcm.setMaxTotal(100); //设置池内最大连接数
pcm.setDefaultMaxPerRoute(10); //设置每个坠机的最大连接数
//从连接池中获取连接对象，而不是单独创建连接对象
CloseableHttpClient httpClient = HttpClients.custom().setConnectionManager(pcm).build();
HttpGet httpGet = new HttpGet("https://www.cnblogs.com/msi-chen");
System.out.println(httpGet);
//使用httpClient发起请求，获得响应
CloseableHttpResponse response = null;
try {
response = httpClient.execute(httpGet);
//解析响应，获取到数据
if (response.getStatusLine().getStatusCode() == 200){
HttpEntity entity = response.getEntity();
String content = EntityUtils.toString(entity,"utf8");
System.out.println(content.length());
}
} catch (IOException e) {
e.printStackTrace();
}finally {
if (response != null){
try {
response.close();
} catch (IOException e) {
e.printStackTrace();
}
//因为我们是连接池中获取到的连接，所以这里不能再给他关闭了
//httpClient.close();
}
}
}
}
获取资源的相关时间配置
Jsoup 不是 Jsonp
经过我们上面的学习，我们已经可以通过HttpClient抓取页面了。抓取页面后，我们就可以解析了。我们可以使用字符串解析工具来解析页面，也可以使用正则表达式。解析，但是这两种方案的开发成本很高，不推荐使用。这里我们学习了一个解析html页面的技术，Jsonp
Jsoup简介
jsonp是一个Java Html解析器，可以自己解析一个url地址和html文本内容。它有一组现成的 API 来删除和操作数据。
jsonp的特点：
Jsoup解析网址
添加Jsoup的依赖以使用Jsoup
注意：Jsoup只限于使用Html解析工具，不能代替HttpClient发起请求，因为HttpClient支持多线程、连接池、代理等技术，而Jsoup对此的支持并不理想，专业的事情交给专业的人，HttpClient发送请求抓取数据，Jsoup做解析
Jsoup解析字符串
Jsoup解析文件
还是上面的静态页面，除了转成String后面再解析，我们也可以直接解析文件
使用 Dom 方法遍历文档
记得还有一个sax解析，比较麻烦，现在差点忘了；
dom解析，不知道大家有没有听说过或者用过。反正我以前用过，但是解析的确实是XML。让我简单介绍一个Dmo方法。
Dmo 解析会将目标文档视为对象。首先，将整个文档加载到内存中。如果文档太大，内存可能会溢出（一般不会）。加载到内存后，会构建一个Dom树，然后进行访问和修改操作
没学过的，我们通过一个小demo来了解一下。如果您使用过它，我们应该对其进行审查：
Java代码如下： 我已经演示了几个常用的获取页面数据的API
从元素中获取属性
选择器选择器
下面是上述always选择器的使用演示
选择器选择器组合使用
Hello World 级爬虫小箱子
在上面的学习中，我们已经知道HttpClient的作用是爬取数据，而Jsoup是解析HttpClient爬取的数据。让我们练习一下这两个工具的使用。
搁浅了一阵子，暂时……以后更新 查看全部
httpclient 抓取网页(Java的Http协议客户端HttpClient来实现抓取网页数据(组图))
爬虫爬取网页上的数据和我们点击链接单独访问网页数据是一样的。就是使用Http协议访问网页。这里我们使用Java Http协议客户端HttpClient来实现网页数据的抓取。
你好世界
获取带参数的请求
使用参数发布请求
帖子也很简单，和上面差不多，只是改变发起请求的方式，如下：
当然，如果没有参数，就不需要创建表单对象，只要有一个HttpPost对象即可。
代码中的对象说明：
代码优化：连接池
在爬取数据的过程中，连接对象HttpClient的创建和销毁非常频繁，这里我们使用连接池对其进行优化
public class poolTest {
public static void main(String[] args) {
//创建连接池管理器
PoolingHttpClientConnectionManager pcm = new PoolingHttpClientConnectionManager();
pcm.setMaxTotal(100); //设置池内最大连接数
pcm.setDefaultMaxPerRoute(10); //设置每个坠机的最大连接数
//从连接池中获取连接对象，而不是单独创建连接对象
CloseableHttpClient httpClient = HttpClients.custom().setConnectionManager(pcm).build();
HttpGet httpGet = new HttpGet("https://www.cnblogs.com/msi-chen";);
System.out.println(httpGet);
//使用httpClient发起请求，获得响应
CloseableHttpResponse response = null;
try {
response = httpClient.execute(httpGet);
//解析响应，获取到数据
if (response.getStatusLine().getStatusCode() == 200){
HttpEntity entity = response.getEntity();
String content = EntityUtils.toString(entity,"utf8");
System.out.println(content.length());
}
} catch (IOException e) {
e.printStackTrace();
}finally {
if (response != null){
try {
response.close();
} catch (IOException e) {
e.printStackTrace();
}
//因为我们是连接池中获取到的连接，所以这里不能再给他关闭了
//httpClient.close();
}
}
}
}
获取资源的相关时间配置
Jsoup 不是 Jsonp
经过我们上面的学习，我们已经可以通过HttpClient抓取页面了。抓取页面后，我们就可以解析了。我们可以使用字符串解析工具来解析页面，也可以使用正则表达式。解析，但是这两种方案的开发成本很高，不推荐使用。这里我们学习了一个解析html页面的技术，Jsonp
Jsoup简介
jsonp是一个Java Html解析器，可以自己解析一个url地址和html文本内容。它有一组现成的 API 来删除和操作数据。
jsonp的特点：
Jsoup解析网址
添加Jsoup的依赖以使用Jsoup
注意：Jsoup只限于使用Html解析工具，不能代替HttpClient发起请求，因为HttpClient支持多线程、连接池、代理等技术，而Jsoup对此的支持并不理想，专业的事情交给专业的人，HttpClient发送请求抓取数据，Jsoup做解析
Jsoup解析字符串
Jsoup解析文件
还是上面的静态页面，除了转成String后面再解析，我们也可以直接解析文件
使用 Dom 方法遍历文档
记得还有一个sax解析，比较麻烦，现在差点忘了；
dom解析，不知道大家有没有听说过或者用过。反正我以前用过，但是解析的确实是XML。让我简单介绍一个Dmo方法。
Dmo 解析会将目标文档视为对象。首先，将整个文档加载到内存中。如果文档太大，内存可能会溢出（一般不会）。加载到内存后，会构建一个Dom树，然后进行访问和修改操作
没学过的，我们通过一个小demo来了解一下。如果您使用过它，我们应该对其进行审查：
Java代码如下： 我已经演示了几个常用的获取页面数据的API
从元素中获取属性
选择器选择器
下面是上述always选择器的使用演示
选择器选择器组合使用
Hello World 级爬虫小箱子
在上面的学习中，我们已经知道HttpClient的作用是爬取数据，而Jsoup是解析HttpClient爬取的数据。让我们练习一下这两个工具的使用。
搁浅了一阵子，暂时……以后更新
httpclient 抓取网页(如何编写爬虫程序爬取网络上有价值的数据信息？)
网站优化 • 优采云 发表了文章 • 0 个评论 • 61 次浏览 • 2022-02-25 11:24
httpclient 抓取网页(如何编写爬虫程序爬取网络上有价值的数据信息？)
随着互联网+时代的到来，越来越多的互联网公司层出不穷，涉及游戏、视频、新闻、社交、电商、房地产、旅游等诸多行业。在互联网成为海量信息载体的今天，如何有效地从中提取有价值的信息并加以利用，成为了巨大的挑战。
爬虫这个可怕的怪物，从百度、谷歌等搜索引擎公司诞生以来就一直存在，如今在移动互联网时代，爬虫更是猖獗。每一个网站似乎都被它光顾过，但你看No，但你可以放心，它不会做坏事。您可以快速搜索在 Internet 上找到的信息。这应该是由于它的信用。每一天，都会不为人知采集网上丰富的资讯，供大家查询和分享。Java作为互联网开发的主流语言，在互联网领域得到了广泛的应用。本课程使用java技术讲解如何编写爬虫程序来爬取互联网上有价值的数据信息。
知识点1.爬虫介绍
当我们访问某个网页时，在地址栏中输入网址并回车，网站的服务器会返回一个HTML文件给我们，浏览器会解析返回的数据并显示在UI上。同样，爬虫程序也模仿人的操作。向网站发送请求，网站会返回一个HTML文件给爬虫程序，爬虫程序会对返回的数据进行爬取和分析。
1.1 爬虫简介
网络爬虫，也称为网络蜘蛛，是一种自动索引器，一种“自动浏览网页”的程序，或者是网络机器人。
爬虫广泛用于互联网搜索引擎或其他类似的网站s，以获取或更新这些网站s的内容和检索方式。他们可以自动采集他们可以访问的所有页面内容以供搜索引擎进一步处理（对下载的页面进行排序和排序），从而使用户可以更快地检索到他们需要的信息。
通俗的说，就是你手动打开窗口，输入数据等，换成程序。使用程序为你获取你想要的信息，这就是网络爬虫
1.2 爬虫应用1.2.1 搜索引擎
爬虫程序可以为搜索引擎系统抓取网络资源，用户可以通过搜索引擎搜索到网络上所有需要的资源。搜索引擎是一个非常庞大和复杂的算法系统，搜索的准确性和效率都对搜索系统提出了很高的要求。
1.2.2 数据挖掘
除了搜索，爬虫还可以做很多工作。可以说，爬虫现在广泛应用于互联网项目中。
互联网项目主要通过爬取相关数据进行数据分析，获取有价值的数据。那么爬虫就可以做那个分析了，下面可以简单的理解：
App下载量分析1.3爬虫原理1.3.1爬虫目的
一般来说，我们需要捕获的是一个网站或者一个应用程序的内容，提取有用的价值，进行数据分析。
1.3.2 爬虫框架设计
为了开发方便，项目中也可以使用爬虫框架来开发爬虫；一个通用网络爬虫的框架如图所示：
网络爬虫的基本工作流程如下：
首先选择一部分精心挑选的种子URL，将这些URL放入待爬取的URL队列中，从待爬取的URL队列中取出待爬取的URL，解析DNS，得到主机的ip，下载URL对应的网页，存储在下载的网页库中。另外，将这些URL放入已爬取URL队列，分析已爬取URL队列中的URL，分析其中的其他URL，将这些URL放入待爬取URL队列，从而进入下一个循环2. Java 爬虫框架2.1 Nutch
Nutch 是一个分布式爬虫。爬虫使用分布式，主要解决两个问题：1)海量URL管理；2) 网速。如果你想做一个搜索引擎，Nutch1.x 是一个非常不错的选择。Nutch1.x 和 solr 或 es 可以组成一个非常强大的搜索引擎，否则尽量不要选择 Nutch 作为爬虫。使用 Nutch 进行爬虫的二次开发，爬虫的编写和调试所需的时间往往是单机爬虫所需时间的十倍以上。
2.2 赫里特里克斯
Heritrix 是一个“档案爬虫”——获取您网站内容的完整、准确、深层副本。这包括获取图像和其他非文本内容。抓取并存储相关内容。内容不会被拒绝，页面内容也不会被修改。重新抓取相同的 URL 不会替换前一个。爬虫主要通过 Web 用户界面启动、监控和调整，允许灵活定义要获取的 url。
2.3 crawler4j
crawler4j 是一个用 Java 实现的开源网络爬虫。提供易于使用的界面，可在几分钟内创建多线程网络爬虫。
2.4 网络采集器
WebCollector 使用 Nutch 的爬虫逻辑（层次广度遍历），Crawler4j 的用户界面（重写访问方法，定义用户操作），以及一套自己的插件机制，设计了一套爬虫核心。
2.5 网络魔术
WebMagic 项目代码分为核心和扩展两部分。核心部分（webmagic-core）是一个精简的、模块化的爬虫实现，而扩展部分包括一些便利和实用的功能。WebMagic的架构设计参考了Scrapy，目标是尽可能模块化，并体现爬虫的功能特点。 查看全部
随着互联网+时代的到来，越来越多的互联网公司层出不穷，涉及游戏、视频、新闻、社交、电商、房地产、旅游等诸多行业。在互联网成为海量信息载体的今天，如何有效地从中提取有价值的信息并加以利用，成为了巨大的挑战。
爬虫这个可怕的怪物，从百度、谷歌等搜索引擎公司诞生以来就一直存在，如今在移动互联网时代，爬虫更是猖獗。每一个网站似乎都被它光顾过，但你看No，但你可以放心，它不会做坏事。您可以快速搜索在 Internet 上找到的信息。这应该是由于它的信用。每一天，都会不为人知采集网上丰富的资讯，供大家查询和分享。Java作为互联网开发的主流语言，在互联网领域得到了广泛的应用。本课程使用java技术讲解如何编写爬虫程序来爬取互联网上有价值的数据信息。
知识点1.爬虫介绍
当我们访问某个网页时，在地址栏中输入网址并回车，网站的服务器会返回一个HTML文件给我们，浏览器会解析返回的数据并显示在UI上。同样，爬虫程序也模仿人的操作。向网站发送请求，网站会返回一个HTML文件给爬虫程序，爬虫程序会对返回的数据进行爬取和分析。
1.1 爬虫简介
网络爬虫，也称为网络蜘蛛，是一种自动索引器，一种“自动浏览网页”的程序，或者是网络机器人。
爬虫广泛用于互联网搜索引擎或其他类似的网站s，以获取或更新这些网站s的内容和检索方式。他们可以自动采集他们可以访问的所有页面内容以供搜索引擎进一步处理（对下载的页面进行排序和排序），从而使用户可以更快地检索到他们需要的信息。
通俗的说，就是你手动打开窗口，输入数据等，换成程序。使用程序为你获取你想要的信息，这就是网络爬虫
1.2 爬虫应用1.2.1 搜索引擎
爬虫程序可以为搜索引擎系统抓取网络资源，用户可以通过搜索引擎搜索到网络上所有需要的资源。搜索引擎是一个非常庞大和复杂的算法系统，搜索的准确性和效率都对搜索系统提出了很高的要求。
1.2.2 数据挖掘
除了搜索，爬虫还可以做很多工作。可以说，爬虫现在广泛应用于互联网项目中。
互联网项目主要通过爬取相关数据进行数据分析，获取有价值的数据。那么爬虫就可以做那个分析了，下面可以简单的理解：
App下载量分析1.3爬虫原理1.3.1爬虫目的
一般来说，我们需要捕获的是一个网站或者一个应用程序的内容，提取有用的价值，进行数据分析。
1.3.2 爬虫框架设计
为了开发方便，项目中也可以使用爬虫框架来开发爬虫；一个通用网络爬虫的框架如图所示：
网络爬虫的基本工作流程如下：
首先选择一部分精心挑选的种子URL，将这些URL放入待爬取的URL队列中，从待爬取的URL队列中取出待爬取的URL，解析DNS，得到主机的ip，下载URL对应的网页，存储在下载的网页库中。另外，将这些URL放入已爬取URL队列，分析已爬取URL队列中的URL，分析其中的其他URL，将这些URL放入待爬取URL队列，从而进入下一个循环2. Java 爬虫框架2.1 Nutch
Nutch 是一个分布式爬虫。爬虫使用分布式，主要解决两个问题：1)海量URL管理；2) 网速。如果你想做一个搜索引擎，Nutch1.x 是一个非常不错的选择。Nutch1.x 和 solr 或 es 可以组成一个非常强大的搜索引擎，否则尽量不要选择 Nutch 作为爬虫。使用 Nutch 进行爬虫的二次开发，爬虫的编写和调试所需的时间往往是单机爬虫所需时间的十倍以上。
2.2 赫里特里克斯
Heritrix 是一个“档案爬虫”——获取您网站内容的完整、准确、深层副本。这包括获取图像和其他非文本内容。抓取并存储相关内容。内容不会被拒绝，页面内容也不会被修改。重新抓取相同的 URL 不会替换前一个。爬虫主要通过 Web 用户界面启动、监控和调整，允许灵活定义要获取的 url。
2.3 crawler4j
crawler4j 是一个用 Java 实现的开源网络爬虫。提供易于使用的界面，可在几分钟内创建多线程网络爬虫。
2.4 网络采集器
WebCollector 使用 Nutch 的爬虫逻辑（层次广度遍历），Crawler4j 的用户界面（重写访问方法，定义用户操作），以及一套自己的插件机制，设计了一套爬虫核心。
2.5 网络魔术
WebMagic 项目代码分为核心和扩展两部分。核心部分（webmagic-core）是一个精简的、模块化的爬虫实现，而扩展部分包括一些便利和实用的功能。WebMagic的架构设计参考了Scrapy，目标是尽可能模块化，并体现爬虫的功能特点。 查看全部
httpclient 抓取网页(如何编写爬虫程序爬取网络上有价值的数据信息？)
随着互联网+时代的到来，越来越多的互联网公司层出不穷，涉及游戏、视频、新闻、社交、电商、房地产、旅游等诸多行业。在互联网成为海量信息载体的今天，如何有效地从中提取有价值的信息并加以利用，成为了巨大的挑战。
爬虫这个可怕的怪物，从百度、谷歌等搜索引擎公司诞生以来就一直存在，如今在移动互联网时代，爬虫更是猖獗。每一个网站似乎都被它光顾过，但你看No，但你可以放心，它不会做坏事。您可以快速搜索在 Internet 上找到的信息。这应该是由于它的信用。每一天，都会不为人知采集网上丰富的资讯，供大家查询和分享。Java作为互联网开发的主流语言，在互联网领域得到了广泛的应用。本课程使用java技术讲解如何编写爬虫程序来爬取互联网上有价值的数据信息。
知识点1.爬虫介绍
当我们访问某个网页时，在地址栏中输入网址并回车，网站的服务器会返回一个HTML文件给我们，浏览器会解析返回的数据并显示在UI上。同样，爬虫程序也模仿人的操作。向网站发送请求，网站会返回一个HTML文件给爬虫程序，爬虫程序会对返回的数据进行爬取和分析。
1.1 爬虫简介
网络爬虫，也称为网络蜘蛛，是一种自动索引器，一种“自动浏览网页”的程序，或者是网络机器人。
爬虫广泛用于互联网搜索引擎或其他类似的网站s，以获取或更新这些网站s的内容和检索方式。他们可以自动采集他们可以访问的所有页面内容以供搜索引擎进一步处理（对下载的页面进行排序和排序），从而使用户可以更快地检索到他们需要的信息。
通俗的说，就是你手动打开窗口，输入数据等，换成程序。使用程序为你获取你想要的信息，这就是网络爬虫
1.2 爬虫应用1.2.1 搜索引擎
爬虫程序可以为搜索引擎系统抓取网络资源，用户可以通过搜索引擎搜索到网络上所有需要的资源。搜索引擎是一个非常庞大和复杂的算法系统，搜索的准确性和效率都对搜索系统提出了很高的要求。
1.2.2 数据挖掘
除了搜索，爬虫还可以做很多工作。可以说，爬虫现在广泛应用于互联网项目中。
互联网项目主要通过爬取相关数据进行数据分析，获取有价值的数据。那么爬虫就可以做那个分析了，下面可以简单的理解：
App下载量分析1.3爬虫原理1.3.1爬虫目的
一般来说，我们需要捕获的是一个网站或者一个应用程序的内容，提取有用的价值，进行数据分析。
1.3.2 爬虫框架设计
为了开发方便，项目中也可以使用爬虫框架来开发爬虫；一个通用网络爬虫的框架如图所示：
网络爬虫的基本工作流程如下：
首先选择一部分精心挑选的种子URL，将这些URL放入待爬取的URL队列中，从待爬取的URL队列中取出待爬取的URL，解析DNS，得到主机的ip，下载URL对应的网页，存储在下载的网页库中。另外，将这些URL放入已爬取URL队列，分析已爬取URL队列中的URL，分析其中的其他URL，将这些URL放入待爬取URL队列，从而进入下一个循环2. Java 爬虫框架2.1 Nutch
Nutch 是一个分布式爬虫。爬虫使用分布式，主要解决两个问题：1)海量URL管理；2) 网速。如果你想做一个搜索引擎，Nutch1.x 是一个非常不错的选择。Nutch1.x 和 solr 或 es 可以组成一个非常强大的搜索引擎，否则尽量不要选择 Nutch 作为爬虫。使用 Nutch 进行爬虫的二次开发，爬虫的编写和调试所需的时间往往是单机爬虫所需时间的十倍以上。
2.2 赫里特里克斯
Heritrix 是一个“档案爬虫”——获取您网站内容的完整、准确、深层副本。这包括获取图像和其他非文本内容。抓取并存储相关内容。内容不会被拒绝，页面内容也不会被修改。重新抓取相同的 URL 不会替换前一个。爬虫主要通过 Web 用户界面启动、监控和调整，允许灵活定义要获取的 url。
2.3 crawler4j
crawler4j 是一个用 Java 实现的开源网络爬虫。提供易于使用的界面，可在几分钟内创建多线程网络爬虫。
2.4 网络采集器
WebCollector 使用 Nutch 的爬虫逻辑（层次广度遍历），Crawler4j 的用户界面（重写访问方法，定义用户操作），以及一套自己的插件机制，设计了一套爬虫核心。
2.5 网络魔术
WebMagic 项目代码分为核心和扩展两部分。核心部分（webmagic-core）是一个精简的、模块化的爬虫实现，而扩展部分包括一些便利和实用的功能。WebMagic的架构设计参考了Scrapy，目标是尽可能模块化，并体现爬虫的功能特点。
httpclient 抓取网页(Python爬虫系列三“模拟登录”的方法需要抓取数据包分析)
网站优化 • 优采云 发表了文章 • 0 个评论 • 64 次浏览 • 2022-02-19 18:13
httpclient 抓取网页(Python爬虫系列三“模拟登录”的方法需要抓取数据包分析)
3.对http协议有基本的了解，比如http 200、301、302、400、404、500的返回码是什么意思（这个是最基本的），还有cookie和session机制（这个会在后续的Python爬虫系列三“模拟登录”中介绍“方法需要抓包分析，主要看cookies这些东西，学习分析数据包）
4.httpclient的重定向状态默认是自动的，这在很大程度上对开发者来说是非常方便的（比如一些授权的cookies），但是有时候需要手动设置。对于 CircularRedictException 异常，这是因为返回的头文件中的位置值指向了之前的重复地址（端口号可以不同），这可能会导致无限循环递归重定向。这时候可以手动关闭：method.setFollowRedirects(false)。
5.模拟浏览器登录，对于爬虫来说非常重要。有的网站会先判断用户的请求是否来自浏览器。如果不是直接拒绝访问，这是直接伪装成浏览器访问嘛，很容易用httpclient在header中添加一些信息： header.put("User-Agent", "Mozilla/5.0 (Windows NT 6.1)AppleWebKit /537.36 (KHTML, 像 Gecko) Chrome/37.0.2062.124 Safari/ 537.36)”);
6.post请求提交数据时，要更改默认编码，否则提交的数据会乱码。只需重写 postMethod 的 setContentCharSet() 方法即可。
事实上，任何网页的数据都是由请求-响应组成的。谷歌或者火狐打开F12选择网络，点击更多按钮，就可以得到他访问的连接，后面可以通过普通的httpclient或者jsoup获取。响应的内容就是现在，我个人感觉很有可能是这样返回json的
您可以使用 document.getElementById 函数，例如： var obj = document.getElementById("text1")
js一般使用ajax获取列表，可以在ajax中找到GET地址或者POST地址来获取分页内容。
如何抓取HTML页面数据-：使用ForeSpider数据采集系统。ForeSpider数据采集系统具有全面的采集范围，数据准确，抓取性能优秀，可视化操作简单，智能自动化采集，让企业以极少的人力成本，快速获取互联网上的结构化或非结构化数据。软件...
如何抓取获取到的html网页内容：在ie或者chrome浏览器中，f12可以打开开发者工具，找到网络，启动网络请求抓取，触发post请求，然后就可以看到发送和返回的内容了
如何抓取网页文字 - 如何使用网页文字刮板抓取文字：网页文字刮板是一款小型网页文字抓取工具，可让您轻松抓取和复制网页上禁止选择和复制的文字。对于页面上的内容，被大面积看不见的广告所覆盖。抓取网页文本抓取器并查看它也是一个很好的解决方案。此外，网页文本抓取器还可以抓取页面中 HTML 标签的路径，帮助理解 HTML 文档的结构。注册后即可轻松使用，功能非常简单方便。
如何将html代码粘贴到html页面？：复制到记事本，保存为.html，用浏览器打开。
如何抓取HTML页面中的一条数据，具体html如下-：直接使用爬虫即可，如优采云采集器或优采云浏览器
获取html标签h1的内容：我都是用JQuery写的1)如何获取值：$("#hn").text();2)如何获取值：$(".hn ").text();3)你好，如果只有一个标签，还需要获取第一个标签的内容，取值方式： $("h1")[0] 。文本（）;
如何抓取网页结构的html代码——：先知道html的网址，在浏览器中打开，保存为网页，保存类型，全部，或者使用html扒手工具，或者如果知道回来-end编程，可以自己写一个将html代码保存到本地文件的方法
如何抓取html页面并使用httpclient——：其实任何网页的数据都是由request-response组成的，谷歌或者火狐打开F12选择网络，点击更多按钮，就可以得到他访问的连接，和那么不管是普通的httpclient还是jsoup都能拿到响应内容，个人感觉这样返回json是很有可能的
C语言提取html标签内容-: #include #include void fetch_str(char *str_in, char *str_out);int main(){char test[] = "This is the string";char result[256];fetch_str( test , result);printf("\ntest\t=%s\n", test);printf("\nresult\t=%s\n",result);return 1;}void ...
如何抓取网页的 html 和 css - : 将网页另存为
相关视频：Python-MongoDB数据库-MongoDB数据库操作(上) Python-MongoDB数据库-MongoDB数据库操作(下) Python-爬虫进阶-Scrapy-Redis分布式-scrapy-redis简介 Python-爬虫进阶-Scrapy框架进阶-豆瓣阅读-Selenium中间件 Python-爬虫进阶-Scrapy框架初一-毒网（上） Python-多线程爬虫-多线程创建的两种方式 Python-爬虫与数据-为什么要爬虫 Python-爬虫进阶-Scrapy框架初级-虎扑新闻-scrapyPython-爬虫进阶-Scrapy-Redis分布式-Redis配置Python-爬虫进阶-Scrapy框架进阶-百度翻译 查看全部
3.对http协议有基本的了解，比如http 200、301、302、400、404、500的返回码是什么意思（这个是最基本的），还有cookie和session机制（这个会在后续的Python爬虫系列三“模拟登录”中介绍“方法需要抓包分析，主要看cookies这些东西，学习分析数据包）
4.httpclient的重定向状态默认是自动的，这在很大程度上对开发者来说是非常方便的（比如一些授权的cookies），但是有时候需要手动设置。对于 CircularRedictException 异常，这是因为返回的头文件中的位置值指向了之前的重复地址（端口号可以不同），这可能会导致无限循环递归重定向。这时候可以手动关闭：method.setFollowRedirects(false)。
5.模拟浏览器登录，对于爬虫来说非常重要。有的网站会先判断用户的请求是否来自浏览器。如果不是直接拒绝访问，这是直接伪装成浏览器访问嘛，很容易用httpclient在header中添加一些信息： header.put("User-Agent", "Mozilla/5.0 (Windows NT 6.1)AppleWebKit /537.36 (KHTML, 像 Gecko) Chrome/37.0.2062.124 Safari/ 537.36)”);
6.post请求提交数据时，要更改默认编码，否则提交的数据会乱码。只需重写 postMethod 的 setContentCharSet() 方法即可。
事实上，任何网页的数据都是由请求-响应组成的。谷歌或者火狐打开F12选择网络，点击更多按钮，就可以得到他访问的连接，后面可以通过普通的httpclient或者jsoup获取。响应的内容就是现在，我个人感觉很有可能是这样返回json的
您可以使用 document.getElementById 函数，例如： var obj = document.getElementById("text1")
js一般使用ajax获取列表，可以在ajax中找到GET地址或者POST地址来获取分页内容。
如何抓取HTML页面数据-：使用ForeSpider数据采集系统。ForeSpider数据采集系统具有全面的采集范围，数据准确，抓取性能优秀，可视化操作简单，智能自动化采集，让企业以极少的人力成本，快速获取互联网上的结构化或非结构化数据。软件...
如何抓取获取到的html网页内容：在ie或者chrome浏览器中，f12可以打开开发者工具，找到网络，启动网络请求抓取，触发post请求，然后就可以看到发送和返回的内容了
如何抓取网页文字 - 如何使用网页文字刮板抓取文字：网页文字刮板是一款小型网页文字抓取工具，可让您轻松抓取和复制网页上禁止选择和复制的文字。对于页面上的内容，被大面积看不见的广告所覆盖。抓取网页文本抓取器并查看它也是一个很好的解决方案。此外，网页文本抓取器还可以抓取页面中 HTML 标签的路径，帮助理解 HTML 文档的结构。注册后即可轻松使用，功能非常简单方便。
如何将html代码粘贴到html页面？：复制到记事本，保存为.html，用浏览器打开。
如何抓取HTML页面中的一条数据，具体html如下-：直接使用爬虫即可，如优采云采集器或优采云浏览器
获取html标签h1的内容：我都是用JQuery写的1)如何获取值：$("#hn").text();2)如何获取值：$(".hn ").text();3)你好，如果只有一个标签，还需要获取第一个标签的内容，取值方式： $("h1")[0] 。文本（）;
如何抓取网页结构的html代码——：先知道html的网址，在浏览器中打开，保存为网页，保存类型，全部，或者使用html扒手工具，或者如果知道回来-end编程，可以自己写一个将html代码保存到本地文件的方法
如何抓取html页面并使用httpclient——：其实任何网页的数据都是由request-response组成的，谷歌或者火狐打开F12选择网络，点击更多按钮，就可以得到他访问的连接，和那么不管是普通的httpclient还是jsoup都能拿到响应内容，个人感觉这样返回json是很有可能的
C语言提取html标签内容-: #include #include void fetch_str(char *str_in, char *str_out);int main(){char test[] = "This is the string";char result[256];fetch_str( test , result);printf("\ntest\t=%s\n", test);printf("\nresult\t=%s\n",result);return 1;}void ...
如何抓取网页的 html 和 css - : 将网页另存为
相关视频：Python-MongoDB数据库-MongoDB数据库操作(上) Python-MongoDB数据库-MongoDB数据库操作(下) Python-爬虫进阶-Scrapy-Redis分布式-scrapy-redis简介 Python-爬虫进阶-Scrapy框架进阶-豆瓣阅读-Selenium中间件 Python-爬虫进阶-Scrapy框架初一-毒网（上） Python-多线程爬虫-多线程创建的两种方式 Python-爬虫与数据-为什么要爬虫 Python-爬虫进阶-Scrapy框架初级-虎扑新闻-scrapyPython-爬虫进阶-Scrapy-Redis分布式-Redis配置Python-爬虫进阶-Scrapy框架进阶-百度翻译 查看全部
httpclient 抓取网页(Python爬虫系列三“模拟登录”的方法需要抓取数据包分析)
3.对http协议有基本的了解，比如http 200、301、302、400、404、500的返回码是什么意思（这个是最基本的），还有cookie和session机制（这个会在后续的Python爬虫系列三“模拟登录”中介绍“方法需要抓包分析，主要看cookies这些东西，学习分析数据包）
4.httpclient的重定向状态默认是自动的，这在很大程度上对开发者来说是非常方便的（比如一些授权的cookies），但是有时候需要手动设置。对于 CircularRedictException 异常，这是因为返回的头文件中的位置值指向了之前的重复地址（端口号可以不同），这可能会导致无限循环递归重定向。这时候可以手动关闭：method.setFollowRedirects(false)。
5.模拟浏览器登录，对于爬虫来说非常重要。有的网站会先判断用户的请求是否来自浏览器。如果不是直接拒绝访问，这是直接伪装成浏览器访问嘛，很容易用httpclient在header中添加一些信息： header.put("User-Agent", "Mozilla/5.0 (Windows NT 6.1)AppleWebKit /537.36 (KHTML, 像 Gecko) Chrome/37.0.2062.124 Safari/ 537.36)”);
6.post请求提交数据时，要更改默认编码，否则提交的数据会乱码。只需重写 postMethod 的 setContentCharSet() 方法即可。
事实上，任何网页的数据都是由请求-响应组成的。谷歌或者火狐打开F12选择网络，点击更多按钮，就可以得到他访问的连接，后面可以通过普通的httpclient或者jsoup获取。响应的内容就是现在，我个人感觉很有可能是这样返回json的
您可以使用 document.getElementById 函数，例如： var obj = document.getElementById("text1")
js一般使用ajax获取列表，可以在ajax中找到GET地址或者POST地址来获取分页内容。
如何抓取HTML页面数据-：使用ForeSpider数据采集系统。ForeSpider数据采集系统具有全面的采集范围，数据准确，抓取性能优秀，可视化操作简单，智能自动化采集，让企业以极少的人力成本，快速获取互联网上的结构化或非结构化数据。软件...
如何抓取获取到的html网页内容：在ie或者chrome浏览器中，f12可以打开开发者工具，找到网络，启动网络请求抓取，触发post请求，然后就可以看到发送和返回的内容了
如何抓取网页文字 - 如何使用网页文字刮板抓取文字：网页文字刮板是一款小型网页文字抓取工具，可让您轻松抓取和复制网页上禁止选择和复制的文字。对于页面上的内容，被大面积看不见的广告所覆盖。抓取网页文本抓取器并查看它也是一个很好的解决方案。此外，网页文本抓取器还可以抓取页面中 HTML 标签的路径，帮助理解 HTML 文档的结构。注册后即可轻松使用，功能非常简单方便。
如何将html代码粘贴到html页面？：复制到记事本，保存为.html，用浏览器打开。
如何抓取HTML页面中的一条数据，具体html如下-：直接使用爬虫即可，如优采云采集器或优采云浏览器
获取html标签h1的内容：我都是用JQuery写的1)如何获取值：$("#hn").text();2)如何获取值：$(".hn ").text();3)你好，如果只有一个标签，还需要获取第一个标签的内容，取值方式： $("h1")[0] 。文本（）;
如何抓取网页结构的html代码——：先知道html的网址，在浏览器中打开，保存为网页，保存类型，全部，或者使用html扒手工具，或者如果知道回来-end编程，可以自己写一个将html代码保存到本地文件的方法
如何抓取html页面并使用httpclient——：其实任何网页的数据都是由request-response组成的，谷歌或者火狐打开F12选择网络，点击更多按钮，就可以得到他访问的连接，和那么不管是普通的httpclient还是jsoup都能拿到响应内容，个人感觉这样返回json是很有可能的
C语言提取html标签内容-: #include #include void fetch_str(char *str_in, char *str_out);int main(){char test[] = "This is the string";char result[256];fetch_str( test , result);printf("\ntest\t=%s\n", test);printf("\nresult\t=%s\n",result);return 1;}void ...
如何抓取网页的 html 和 css - : 将网页另存为
相关视频：Python-MongoDB数据库-MongoDB数据库操作(上) Python-MongoDB数据库-MongoDB数据库操作(下) Python-爬虫进阶-Scrapy-Redis分布式-scrapy-redis简介 Python-爬虫进阶-Scrapy框架进阶-豆瓣阅读-Selenium中间件 Python-爬虫进阶-Scrapy框架初一-毒网（上） Python-多线程爬虫-多线程创建的两种方式 Python-爬虫与数据-为什么要爬虫 Python-爬虫进阶-Scrapy框架初级-虎扑新闻-scrapyPython-爬虫进阶-Scrapy-Redis分布式-Redis配置Python-爬虫进阶-Scrapy框架进阶-百度翻译
httpclient 抓取网页(() )
网站优化 • 优采云 发表了文章 • 0 个评论 • 85 次浏览 • 2022-02-08 18:14
httpclient 抓取网页(()
)
1、GET 方法
第一步是创建一个客户端，类似于使用浏览器打开网页的方式
HttpClient httpClient = new HttpClient();
第二步，创建GET方法，获取需要抓取的网页的URL
GetMethod getMethod = new GetMethod("");
第三步，获取URL的响应状态码，200表示请求成功
int statusCode = httpClient.executeMethod(getMethod);
第四步，获取网页源代码
byte[] responseBody = getMethod.getResponseBody();
主要是这四个步骤，当然还有很多其他的，比如网页编码问题
2、Post方式
1 HttpClient httpClient = new HttpClient();
2 PostMethod postMethod = new PostMethod(UrlPath);
3 postMethod.getParams().setParameter(HttpMethodParams.RETRY_HANDLER,new DefaultHttpMethodRetryHandler());
4 NameValuePair[] postData = new NameValuePair[2];
5 postData[0] = new NameValuePair("username", "xkey");
6 postData[1] = new NameValuePair("userpass", "********");
7 postMethod.setRequestBody(postData);
8 try {
9 int statusCode = httpClient.executeMethod(postMethod);
10 if (statusCode == HttpStatus.SC_OK) {
11 byte[] responseBody = postMethod.getResponseBody();
12 String html = new String(responseBody);
13 System.out.println(html);
14 }
15 } catch (Exception e) {
16 System.err.println("页面无法访问");
17 }finally{
18 postMethod.releaseConnection();
19 }
相关链接：http://blog.csdn.net/acceptedx ... 30700
http://www.cnblogs.com/modou/articles/1325569.html
查看全部
)
1、GET 方法
第一步是创建一个客户端，类似于使用浏览器打开网页的方式
HttpClient httpClient = new HttpClient();
第二步，创建GET方法，获取需要抓取的网页的URL
GetMethod getMethod = new GetMethod("");
第三步，获取URL的响应状态码，200表示请求成功
int statusCode = httpClient.executeMethod(getMethod);
第四步，获取网页源代码
byte[] responseBody = getMethod.getResponseBody();
主要是这四个步骤，当然还有很多其他的，比如网页编码问题
2、Post方式
1 HttpClient httpClient = new HttpClient();
2 PostMethod postMethod = new PostMethod(UrlPath);
3 postMethod.getParams().setParameter(HttpMethodParams.RETRY_HANDLER,new DefaultHttpMethodRetryHandler());
4 NameValuePair[] postData = new NameValuePair[2];
5 postData[0] = new NameValuePair("username", "xkey");
6 postData[1] = new NameValuePair("userpass", "********");
7 postMethod.setRequestBody(postData);
8 try {
9 int statusCode = httpClient.executeMethod(postMethod);
10 if (statusCode == HttpStatus.SC_OK) {
11 byte[] responseBody = postMethod.getResponseBody();
12 String html = new String(responseBody);
13 System.out.println(html);
14 }
15 } catch (Exception e) {
16 System.err.println("页面无法访问");
17 }finally{
18 postMethod.releaseConnection();
19 }
相关链接：http://blog.csdn.net/acceptedx ... 30700
http://www.cnblogs.com/modou/articles/1325569.html
查看全部
httpclient 抓取网页(()
)
1、GET 方法
第一步是创建一个客户端，类似于使用浏览器打开网页的方式
HttpClient httpClient = new HttpClient();
第二步，创建GET方法，获取需要抓取的网页的URL
GetMethod getMethod = new GetMethod("");
第三步，获取URL的响应状态码，200表示请求成功
int statusCode = httpClient.executeMethod(getMethod);
第四步，获取网页源代码
byte[] responseBody = getMethod.getResponseBody();
主要是这四个步骤，当然还有很多其他的，比如网页编码问题
2、Post方式
1 HttpClient httpClient = new HttpClient();
2 PostMethod postMethod = new PostMethod(UrlPath);
3 postMethod.getParams().setParameter(HttpMethodParams.RETRY_HANDLER,new DefaultHttpMethodRetryHandler());
4 NameValuePair[] postData = new NameValuePair[2];
5 postData[0] = new NameValuePair("username", "xkey");
6 postData[1] = new NameValuePair("userpass", "********");
7 postMethod.setRequestBody(postData);
8 try {
9 int statusCode = httpClient.executeMethod(postMethod);
10 if (statusCode == HttpStatus.SC_OK) {
11 byte[] responseBody = postMethod.getResponseBody();
12 String html = new String(responseBody);
13 System.out.println(html);
14 }
15 } catch (Exception e) {
16 System.err.println("页面无法访问");
17 }finally{
18 postMethod.releaseConnection();
19 }
相关链接：http://blog.csdn.net/acceptedx ... 30700
http://www.cnblogs.com/modou/articles/1325569.html
httpclient 抓取网页(一个基于JAVA的知乎爬虫抓取90W+用户信息（基本上4.5） )
网站优化 • 优采云 发表了文章 • 0 个评论 • 73 次浏览 • 2021-12-31 17:28
httpclient 抓取网页(一个基于JAVA的知乎爬虫抓取90W+用户信息（基本上4.5）
)
本文示例分享了一个基于JAVA的知乎爬虫，抓取知乎基本用户信息，基于HttpClient4.5，供大家参考，具体内容如下
详情：
抓取90W+用户信息（基本上活跃用户都在里面）
总体思路：
1.先模拟登录知乎，登录成功后cookie会序列化到磁盘，不需要每次都登录（如果不模拟登录，您可以直接从浏览器插入cookie。).
2. 创建两个线程池和一个 Storage。一个网页爬取线程池负责执行请求请求，返回网页内容，并存储在Storage中。另一种是解析网页线程池，负责从Storage中取出网页内容并分析，分析用户信息并存入数据库，解析用户关注的人的主页，并添加地址请求到网页抓取线程池。继续循环。
3. 关于url去重，我直接对访问过的链接进行md5保存到数据库中。每次访问前，检查数据库中是否存在该链接。
目前已抓到100W用户，访问220W+链接。现在爬取的用户是一些不太活跃的用户。比较活跃的用户应该基本完成了。
项目地址：
实现代码：
作者：卧颜沉默
链接：https://www.zhihu.com/question ... 43000
来源：知乎
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
/**
*
* @param httpClient Http客户端
* @param context Http上下文
* @return
*/
public boolean login(CloseableHttpClient httpClient, HttpClientContext context){
String yzm = null;
String loginState = null;
HttpGet getRequest = new HttpGet("https://www.zhihu.com/#signin");
HttpClientUtil.getWebPage(httpClient,context, getRequest, "utf-8", false);
HttpPost request = new HttpPost("https://www.zhihu.com/login/email");
List formParams = new ArrayList();
yzm = yzm(httpClient, context,"https://www.zhihu.com/captcha.gif?type=login");//肉眼识别验证码
formParams.add(new BasicNameValuePair("captcha", yzm));
formParams.add(new BasicNameValuePair("_xsrf", ""));//这个参数可以不用
formParams.add(new BasicNameValuePair("email", "邮箱"));
formParams.add(new BasicNameValuePair("password", "密码"));
formParams.add(new BasicNameValuePair("remember_me", "true"));
UrlEncodedFormEntity entity = null;
try {
entity = new UrlEncodedFormEntity(formParams, "utf-8");
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
}
request.setEntity(entity);
loginState = HttpClientUtil.getWebPage(httpClient,context, request, "utf-8", false);//登录
JSONObject jo = new JSONObject(loginState);
if(jo.get("r").toString().equals("0")){
System.out.println("登录成功");
getRequest = new HttpGet("https://www.zhihu.com");
HttpClientUtil.getWebPage(httpClient,context ,getRequest, "utf-8", false);//访问首页
HttpClientUtil.serializeObject(context.getCookieStore(),"resources/zhihucookies");//序列化知乎Cookies，下次登录直接通过该cookies登录
return true;
}else{
System.out.println("登录失败" + loginState);
return false;
}
}
/**
* 肉眼识别验证码
* @param httpClient Http客户端
* @param context Http上下文
* @param url 验证码地址
* @return
*/
public String yzm(CloseableHttpClient httpClient,HttpClientContext context, String url){
HttpClientUtil.downloadFile(httpClient, context, url, "d:/test/", "1.gif",true);
Scanner sc = new Scanner(System.in);
String yzm = sc.nextLine();
return yzm;
}
效果图：
查看全部
)
本文示例分享了一个基于JAVA的知乎爬虫，抓取知乎基本用户信息，基于HttpClient4.5，供大家参考，具体内容如下
详情：
抓取90W+用户信息（基本上活跃用户都在里面）
总体思路：
1.先模拟登录知乎，登录成功后cookie会序列化到磁盘，不需要每次都登录（如果不模拟登录，您可以直接从浏览器插入cookie。).
2. 创建两个线程池和一个 Storage。一个网页爬取线程池负责执行请求请求，返回网页内容，并存储在Storage中。另一种是解析网页线程池，负责从Storage中取出网页内容并分析，分析用户信息并存入数据库，解析用户关注的人的主页，并添加地址请求到网页抓取线程池。继续循环。
3. 关于url去重，我直接对访问过的链接进行md5保存到数据库中。每次访问前，检查数据库中是否存在该链接。
目前已抓到100W用户，访问220W+链接。现在爬取的用户是一些不太活跃的用户。比较活跃的用户应该基本完成了。
项目地址：
实现代码：
作者：卧颜沉默
链接：https://www.zhihu.com/question ... 43000
来源：知乎
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
/**
*
* @param httpClient Http客户端
* @param context Http上下文
* @return
*/
public boolean login(CloseableHttpClient httpClient, HttpClientContext context){
String yzm = null;
String loginState = null;
HttpGet getRequest = new HttpGet("https://www.zhihu.com/#signin");
HttpClientUtil.getWebPage(httpClient,context, getRequest, "utf-8", false);
HttpPost request = new HttpPost("https://www.zhihu.com/login/email");
List formParams = new ArrayList();
yzm = yzm(httpClient, context,"https://www.zhihu.com/captcha.gif?type=login");//肉眼识别验证码
formParams.add(new BasicNameValuePair("captcha", yzm));
formParams.add(new BasicNameValuePair("_xsrf", ""));//这个参数可以不用
formParams.add(new BasicNameValuePair("email", "邮箱"));
formParams.add(new BasicNameValuePair("password", "密码"));
formParams.add(new BasicNameValuePair("remember_me", "true"));
UrlEncodedFormEntity entity = null;
try {
entity = new UrlEncodedFormEntity(formParams, "utf-8");
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
}
request.setEntity(entity);
loginState = HttpClientUtil.getWebPage(httpClient,context, request, "utf-8", false);//登录
JSONObject jo = new JSONObject(loginState);
if(jo.get("r").toString().equals("0")){
System.out.println("登录成功");
getRequest = new HttpGet("https://www.zhihu.com");
HttpClientUtil.getWebPage(httpClient,context ,getRequest, "utf-8", false);//访问首页
HttpClientUtil.serializeObject(context.getCookieStore(),"resources/zhihucookies");//序列化知乎Cookies，下次登录直接通过该cookies登录
return true;
}else{
System.out.println("登录失败" + loginState);
return false;
}
}
/**
* 肉眼识别验证码
* @param httpClient Http客户端
* @param context Http上下文
* @param url 验证码地址
* @return
*/
public String yzm(CloseableHttpClient httpClient,HttpClientContext context, String url){
HttpClientUtil.downloadFile(httpClient, context, url, "d:/test/", "1.gif",true);
Scanner sc = new Scanner(System.in);
String yzm = sc.nextLine();
return yzm;
}
效果图：
查看全部
httpclient 抓取网页(一个基于JAVA的知乎爬虫抓取90W+用户信息（基本上4.5）
)
本文示例分享了一个基于JAVA的知乎爬虫，抓取知乎基本用户信息，基于HttpClient4.5，供大家参考，具体内容如下
详情：
抓取90W+用户信息（基本上活跃用户都在里面）
总体思路：
1.先模拟登录知乎，登录成功后cookie会序列化到磁盘，不需要每次都登录（如果不模拟登录，您可以直接从浏览器插入cookie。).
2. 创建两个线程池和一个 Storage。一个网页爬取线程池负责执行请求请求，返回网页内容，并存储在Storage中。另一种是解析网页线程池，负责从Storage中取出网页内容并分析，分析用户信息并存入数据库，解析用户关注的人的主页，并添加地址请求到网页抓取线程池。继续循环。
3. 关于url去重，我直接对访问过的链接进行md5保存到数据库中。每次访问前，检查数据库中是否存在该链接。
目前已抓到100W用户，访问220W+链接。现在爬取的用户是一些不太活跃的用户。比较活跃的用户应该基本完成了。
项目地址：
实现代码：
作者：卧颜沉默
链接：https://www.zhihu.com/question ... 43000
来源：知乎
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
/**
*
* @param httpClient Http客户端
* @param context Http上下文
* @return
*/
public boolean login(CloseableHttpClient httpClient, HttpClientContext context){
String yzm = null;
String loginState = null;
HttpGet getRequest = new HttpGet("https://www.zhihu.com/#signin";);
HttpClientUtil.getWebPage(httpClient,context, getRequest, "utf-8", false);
HttpPost request = new HttpPost("https://www.zhihu.com/login/email";);
List formParams = new ArrayList();
yzm = yzm(httpClient, context,"https://www.zhihu.com/captcha.gif?type=login";);//肉眼识别验证码
formParams.add(new BasicNameValuePair("captcha", yzm));
formParams.add(new BasicNameValuePair("_xsrf", ""));//这个参数可以不用
formParams.add(new BasicNameValuePair("email", "邮箱"));
formParams.add(new BasicNameValuePair("password", "密码"));
formParams.add(new BasicNameValuePair("remember_me", "true"));
UrlEncodedFormEntity entity = null;
try {
entity = new UrlEncodedFormEntity(formParams, "utf-8");
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
}
request.setEntity(entity);
loginState = HttpClientUtil.getWebPage(httpClient,context, request, "utf-8", false);//登录
JSONObject jo = new JSONObject(loginState);
if(jo.get("r").toString().equals("0")){
System.out.println("登录成功");
getRequest = new HttpGet("https://www.zhihu.com";);
HttpClientUtil.getWebPage(httpClient,context ,getRequest, "utf-8", false);//访问首页
HttpClientUtil.serializeObject(context.getCookieStore(),"resources/zhihucookies");//序列化知乎Cookies，下次登录直接通过该cookies登录
return true;
}else{
System.out.println("登录失败" + loginState);
return false;
}
}
/**
* 肉眼识别验证码
* @param httpClient Http客户端
* @param context Http上下文
* @param url 验证码地址
* @return
*/
public String yzm(CloseableHttpClient httpClient,HttpClientContext context, String url){
HttpClientUtil.downloadFile(httpClient, context, url, "d:/test/", "1.gif",true);
Scanner sc = new Scanner(System.in);
String yzm = sc.nextLine();
return yzm;
}
效果图：
httpclient 抓取网页(STM32 )
网站优化 • 优采云 发表了文章 • 0 个评论 • 60 次浏览 • 2021-12-23 12:04
httpclient 抓取网页(STM32
)
1、GET 方法
第一步是创建一个客户端，类似于用浏览器打开一个网页
HttpClient httpClient = new HttpClient();
第二步是创建一个GET方法来获取你需要爬取的网页的网址
GetMethod getMethod = new GetMethod("");
第三步，获取URL的响应状态码，200表示请求成功
int statusCode = httpClient.executeMethod(getMethod);
第四步，获取网页源代码
byte[] responseBody = getMethod.getResponseBody();
主要是这四个步骤，当然还有很多其他的，比如网页编码问题
HttpClient httpClient = new HttpClient();
GetMethod getMethod = new GetMethod("http://www.baidu.com/");
try {
int statusCode = httpClient.executeMethod(getMethod);
if (statusCode != HttpStatus.SC_OK) {
System.err.println("Method failed: "
+ getMethod.getStatusLine());
}
// 读取内容
byte[] responseBody = getMethod.getResponseBody();
// 处理内容
String html = new String(responseBody);
System.out.println(html);
} catch (Exception e) {
System.err.println("页面无法访问");
}finally{
getMethod.releaseConnection();
}
2、发布方式
HttpClient httpClient = new HttpClient();
PostMethod postMethod = new PostMethod(UrlPath);
postMethod.getParams().setParameter(HttpMethodParams.RETRY_HANDLER,new DefaultHttpMethodRetryHandler());
NameValuePair[] postData = new NameValuePair[2];
postData[0] = new NameValuePair("username", "xkey");
postData[1] = new NameValuePair("userpass", "********");
postMethod.setRequestBody(postData);
try {
int statusCode = httpClient.executeMethod(postMethod);
if (statusCode == HttpStatus.SC_OK) {
byte[] responseBody = postMethod.getResponseBody();
String html = new String(responseBody);
System.out.println(html);
}
} catch (Exception e) {
System.err.println("页面无法访问");
}finally{
postMethod.releaseConnection();
}
本例传递两个Post参数：username为xkey，userpass为*******，传递给URL UrlPath
如需了解获取gzip网页的信息，请参考
另一种是获取非字符数据，所以可以使用下面的方法
HttpClient httpClient = new HttpClient();
GetMethod getMethod = new GetMethod("http://www.baidu.com");
try {
InputStream inputStream = getMethod.getResponseBodyAsStream();
// 这里处理 inputStream
} catch (Exception e) {
System.err.println("页面无法访问");
}finally{
getMethod.releaseConnection();
} 查看全部
)
1、GET 方法
第一步是创建一个客户端，类似于用浏览器打开一个网页
HttpClient httpClient = new HttpClient();
第二步是创建一个GET方法来获取你需要爬取的网页的网址
GetMethod getMethod = new GetMethod("");
第三步，获取URL的响应状态码，200表示请求成功
int statusCode = httpClient.executeMethod(getMethod);
第四步，获取网页源代码
byte[] responseBody = getMethod.getResponseBody();
主要是这四个步骤，当然还有很多其他的，比如网页编码问题
HttpClient httpClient = new HttpClient();
GetMethod getMethod = new GetMethod("http://www.baidu.com/");
try {
int statusCode = httpClient.executeMethod(getMethod);
if (statusCode != HttpStatus.SC_OK) {
System.err.println("Method failed: "
+ getMethod.getStatusLine());
}
// 读取内容
byte[] responseBody = getMethod.getResponseBody();
// 处理内容
String html = new String(responseBody);
System.out.println(html);
} catch (Exception e) {
System.err.println("页面无法访问");
}finally{
getMethod.releaseConnection();
}
2、发布方式
HttpClient httpClient = new HttpClient();
PostMethod postMethod = new PostMethod(UrlPath);
postMethod.getParams().setParameter(HttpMethodParams.RETRY_HANDLER,new DefaultHttpMethodRetryHandler());
NameValuePair[] postData = new NameValuePair[2];
postData[0] = new NameValuePair("username", "xkey");
postData[1] = new NameValuePair("userpass", "********");
postMethod.setRequestBody(postData);
try {
int statusCode = httpClient.executeMethod(postMethod);
if (statusCode == HttpStatus.SC_OK) {
byte[] responseBody = postMethod.getResponseBody();
String html = new String(responseBody);
System.out.println(html);
}
} catch (Exception e) {
System.err.println("页面无法访问");
}finally{
postMethod.releaseConnection();
}
本例传递两个Post参数：username为xkey，userpass为*******，传递给URL UrlPath
如需了解获取gzip网页的信息，请参考
另一种是获取非字符数据，所以可以使用下面的方法
HttpClient httpClient = new HttpClient();
GetMethod getMethod = new GetMethod("http://www.baidu.com");
try {
InputStream inputStream = getMethod.getResponseBodyAsStream();
// 这里处理 inputStream
} catch (Exception e) {
System.err.println("页面无法访问");
}finally{
getMethod.releaseConnection();
} 查看全部
httpclient 抓取网页(STM32
)
1、GET 方法
第一步是创建一个客户端，类似于用浏览器打开一个网页
HttpClient httpClient = new HttpClient();
第二步是创建一个GET方法来获取你需要爬取的网页的网址
GetMethod getMethod = new GetMethod("");
第三步，获取URL的响应状态码，200表示请求成功
int statusCode = httpClient.executeMethod(getMethod);
第四步，获取网页源代码
byte[] responseBody = getMethod.getResponseBody();
主要是这四个步骤，当然还有很多其他的，比如网页编码问题
HttpClient httpClient = new HttpClient();
GetMethod getMethod = new GetMethod("http://www.baidu.com/";);
try {
int statusCode = httpClient.executeMethod(getMethod);
if (statusCode != HttpStatus.SC_OK) {
System.err.println("Method failed: "
+ getMethod.getStatusLine());
}
// 读取内容
byte[] responseBody = getMethod.getResponseBody();
// 处理内容
String html = new String(responseBody);
System.out.println(html);
} catch (Exception e) {
System.err.println("页面无法访问");
}finally{
getMethod.releaseConnection();
}
2、发布方式
HttpClient httpClient = new HttpClient();
PostMethod postMethod = new PostMethod(UrlPath);
postMethod.getParams().setParameter(HttpMethodParams.RETRY_HANDLER,new DefaultHttpMethodRetryHandler());
NameValuePair[] postData = new NameValuePair[2];
postData[0] = new NameValuePair("username", "xkey");
postData[1] = new NameValuePair("userpass", "********");
postMethod.setRequestBody(postData);
try {
int statusCode = httpClient.executeMethod(postMethod);
if (statusCode == HttpStatus.SC_OK) {
byte[] responseBody = postMethod.getResponseBody();
String html = new String(responseBody);
System.out.println(html);
}
} catch (Exception e) {
System.err.println("页面无法访问");
}finally{
postMethod.releaseConnection();
}
本例传递两个Post参数：username为xkey，userpass为*******，传递给URL UrlPath
如需了解获取gzip网页的信息，请参考
另一种是获取非字符数据，所以可以使用下面的方法
HttpClient httpClient = new HttpClient();
GetMethod getMethod = new GetMethod("http://www.baidu.com";);
try {
InputStream inputStream = getMethod.getResponseBodyAsStream();
// 这里处理 inputStream
} catch (Exception e) {
System.err.println("页面无法访问");
}finally{
getMethod.releaseConnection();
}
httpclient 抓取网页(HttpClient抓取网页js生成内容的问题-HttpClient的侠客们)
网站优化 • 优采云 发表了文章 • 0 个评论 • 59 次浏览 • 2021-11-28 19:13
httpclient 抓取网页(HttpClient抓取网页js生成内容的问题-HttpClient的侠客们)
HttpClient抓取网页js生成内容。曾经的骑士。来看看吧。非常感谢您来看我的问题。我要去抢京东产品的产品标题。红色部分的title后面是通过js加载的。这是不可用的。有什么办法可以好起来吗？有类似经历的同胞能指点一下吗？ - - - 解决方案 - - - - - - - - - - - - - - - - - - - - - - ------------- 需要抓取ajax的内容，这个是js动态加载的httpclient，但是获取不到，那么就需要直接模拟ajax了。根据你的需求，我阅读了，需要访问 获取其页面后在产品地址中添加标题红色部分，搜索skuidkey，获取其值，然后访问String skuidkey Stringurl +skuidkey+ callback= 使用Get访问这个url \u76F4\u964D900\u5143\uFF0C\u4EC5\u9650\ u4ECA\u592914:00-18:00\u9650\u62A2D\ECA\u500D \u6B64\u4E00\u6279\uFF01 结果已经得到了标题的红色部分。当然需要把unicode编码的文本转成中文，不知道怎么转百度 查看全部
HttpClient抓取网页js生成内容。曾经的骑士。来看看吧。非常感谢您来看我的问题。我要去抢京东产品的产品标题。红色部分的title后面是通过js加载的。这是不可用的。有什么办法可以好起来吗？有类似经历的同胞能指点一下吗？ - - - 解决方案 - - - - - - - - - - - - - - - - - - - - - - ------------- 需要抓取ajax的内容，这个是js动态加载的httpclient，但是获取不到，那么就需要直接模拟ajax了。根据你的需求，我阅读了，需要访问 获取其页面后在产品地址中添加标题红色部分，搜索skuidkey，获取其值，然后访问String skuidkey Stringurl +skuidkey+ callback= 使用Get访问这个url \u76F4\u964D900\u5143\uFF0C\u4EC5\u9650\ u4ECA\u592914:00-18:00\u9650\u62A2D\ECA\u500D \u6B64\u4E00\u6279\uFF01 结果已经得到了标题的红色部分。当然需要把unicode编码的文本转成中文，不知道怎么转百度 查看全部
httpclient 抓取网页(HttpClient抓取网页js生成内容的问题-HttpClient的侠客们)
HttpClient抓取网页js生成内容。曾经的骑士。来看看吧。非常感谢您来看我的问题。我要去抢京东产品的产品标题。红色部分的title后面是通过js加载的。这是不可用的。有什么办法可以好起来吗？有类似经历的同胞能指点一下吗？ - - - 解决方案 - - - - - - - - - - - - - - - - - - - - - - ------------- 需要抓取ajax的内容，这个是js动态加载的httpclient，但是获取不到，那么就需要直接模拟ajax了。根据你的需求，我阅读了，需要访问 获取其页面后在产品地址中添加标题红色部分，搜索skuidkey，获取其值，然后访问String skuidkey Stringurl +skuidkey+ callback= 使用Get访问这个url \u76F4\u964D900\u5143\uFF0C\u4EC5\u9650\ u4ECA\u592914:00-18:00\u9650\u62A2D\ECA\u500D \u6B64\u4E00\u6279\uFF01 结果已经得到了标题的红色部分。当然需要把unicode编码的文本转成中文，不知道怎么转百度
httpclient 抓取网页(如何使用Java/Python访问网页和使用Python进行数据解析)
网站优化 • 优采云 发表了文章 • 0 个评论 • 63 次浏览 • 2021-11-26 19:03
httpclient 抓取网页(如何使用Java/Python访问网页和使用Python进行数据解析)
前言：
网络爬虫看起来仍然很棒。但是，如果您考虑一下或进行一些研究，您就会知道爬虫并没有那么复杂。最深的就是当我们的数据量非常大的时候，也就是我们的网络“图”的循环越来越多的时候怎么解决。
这篇文章文章只是在这里作为一个介绍。本文主要讲解如何使用Java/Python访问网页和获取网页代码，Python模仿浏览器访问网页，使用Python进行数据分析。希望我们从这篇文章开始，一步步揭开网络蜘蛛的神秘面纱。
参考：
1. "做你自己的手写网络爬虫"
2. 用python写爬虫，爬取csdn的内容，完美解决403 Forbidden
运行效果图：
内容有点多，我只挑了一部分展示。
作者的环境：
系统：Windows 7
CentOS 6.5
运行环境：JDK1.7
Python 2.6.6
IDE：EclipseRelease 4.2.0
PyCharm 4.5.1
数据库：MySQLVer 14.14 Distrib 5.1.73
开发过程：1. 使用Java抓取页面
对于页面抓取，我们使用Java来实现，当然你也可以使用其他语言来开发。但
我们以“博客园”的主页为例，展示使用Java抓取网页的过程：
public class RetrivePageSimple {
private static HttpClient httpClient = new HttpClient();
// 设置代理服务器
static {
httpClient.getHostConfiguration().setProxy("58.220.2.132", 80);
}
public static boolean downloadPage(String path) throws HttpException,
IOException {
PostMethod postMethod = new PostMethod(path);
// 执行，返回状态码
int statusCode = httpClient.executeMethod(postMethod);
System.out.println(statusCode);
// 针对状态码进行处理 (简单起见，只处理返回值为200的状态码)
if (statusCode == HttpStatus.SC_OK) {
String a = postMethod.getResponseBodyAsString();
System.out.println(a);
return true;
}
return false;
}
public static void main(String[] args) {
try {
RetrivePageSimple.downloadPage("http://www.cnblogs.com/");
} catch (HttpException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
}
结果信息这里不再显示了，太多了。. . ——！
2.使用Python爬取页面
你可能会问，为什么写成Java版本是用来爬网页的，而这里又是一个Python呢？这是必要的。因为作者在开发这个demo之前没有考虑一个问题。当我们使用Java抓取一个网页并将其发送到Python时，网页字符串太长而无法作为参数传递。你可能认为保存文件是一个不错的选择，但是如果html文件太多怎么办？是的，在这里我们必须放弃这种累人的方法。
考虑到参数长度的限制，这里只给出Java端的页面地址，使用Python爬取网页。
以最简单的方式，我们通常使用 Python 网页是这样的：
import urllib2
result = urllib2.urlopen(\'http://blog.csdn.net/mobile/index.html\')
html = result.read()
print html
不过作者在代码中使用了CSDN的博客频道的url。CSDN 对爬虫的访问进行过滤。如下，我们会得到如下错误信息：
403，我被拒绝了。
3.使用仿浏览器登录网站
如前所述，当我们访问带有保护措施的网页时，我们会被拒绝。但是我们可以尝试使用我们的浏览器来访问它，它是可以访问的。
换句话说，如果我们可以在 Python 中将自己模仿为浏览器，我们就可以访问这个网页。下面是Python模仿浏览器的代码：
import random
import socket
import urllib2
import cookielib
ERROR = {
\'0\':\'Can not open the url,checck you net\',
\'1\':\'Creat download dir error\',
\'2\':\'The image links is empty\',
\'3\':\'Download faild\',
\'4\':\'Build soup error,the html is empty\',
\'5\':\'Can not save the image to your disk\',
}
class BrowserBase(object):
def __init__(self):
socket.setdefaulttimeout(20)
self._content = None
def speak(self, name, content):
print \'[%s]%s\' % (name, content)
def open_url(self, url):
"""
打开网页
"""
cookie_support= urllib2.HTTPCookieProcessor(cookielib.CookieJar())
self.opener = urllib2.build_opener(cookie_support,urllib2.HTTPHandler)
urllib2.install_opener(self.opener)
user_agents = [
\'Mozilla/5.0 (Windows; U; Windows NT 5.1; it; rv:1.8.1.11) Gecko/20071127 Firefox/2.0.0.11\',
\'Opera/9.25 (Windows NT 5.1; U; en)\',
\'Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; SV1; .NET CLR 1.1.4322; .NET CLR 2.0.50727)\',
\'Mozilla/5.0 (compatible; Konqueror/3.5; Linux) KHTML/3.5.5 (like Gecko) (Kubuntu)\',
\'Mozilla/5.0 (X11; U; Linux i686; en-US; rv:1.8.0.12) Gecko/20070731 Ubuntu/dapper-security Firefox/1.5.0.12\',
\'Lynx/2.8.5rel.1 libwww-FM/2.14 SSL-MM/1.4.1 GNUTLS/1.2.9\',
"Mozilla/5.0 (X11; Linux i686) AppleWebKit/535.7 (KHTML, like Gecko) Ubuntu/11.04 Chromium/16.0.912.77 Chrome/16.0.912.77 Safari/535.7",
"Mozilla/5.0 (X11; Ubuntu; Linux i686; rv:10.0) Gecko/20100101 Firefox/10.0 ",
]
agent = random.choice(user_agents)
self.opener.addheaders = [("User-agent", agent), ("Accept", "*/*"), (\'Referer\', \'http://www.google.com\')]
try:
res = self.opener.open(url)
self._content = res.read()
# print self._content
except Exception, e:
self.speak(str(e)+url)
raise Exception
else:
return res
def get_html_content(self):
return self._content
def get_html_response(html):
spider = BrowserBase()
spider.open_url(html)
return spider.get_html_content()
以上代码可以正常获取返回值。下面我们来看看返回结果的解析过程。
4.数据分析
使用 Python 解析 Html 异常简单：
import HTMLParser
class ListWebParser(HTMLParser.HTMLParser):
def __init__(self):
HTMLParser.HTMLParser.__init__(self)
self.tagDIVFlag = False
self.tagDIVAFlag = False
self.tagH1Flag = False
self.tagSecondHrefFlag = False
self._name = None
self._address = None
def handle_starttag(self, tag, attrs):
if tag == \'div\':
for name, value in attrs:
if name == \'class\' and value == \'blog_list\':
self.tagDIVFlag = True
if tag == \'h1\':
if self.tagDIVFlag:
self.tagH1Flag = True
# print \'h1->\', self.tagH1Flag
if tag == \'a\':
#if self.tagDIVAFlag:
#print \'h1: \', self.tagH1Flag
if self.tagH1Flag:
for name, value in attrs:
if name == \'target\' and value == \'_blank\':
self.tagDIVAFlag = True
if name == \'href\':
if self.tagSecondHrefFlag:
print \'网址：\', value
self._address = value
self.tagSecondHrefFlag = True
# if name == \'href\' and self.tagDIVAFlag:
# print \'网址：\', value
# self._address = value
def handle_endtag(self, tag):
if tag == \'div\':
self.tagDIVFlag = False
if tag == \'h1\':
self.tagH1Flag = False
# print \'false h1.\'
if tag == \'a\':
self.tagDIVAFlag = False
def handle_data(self, data):
if self.tagDIVAFlag:
print u"名称：", data.decode("utf-8")
如果你说你在网上找到的Html文件就没有这个烦恼。我承认这一点，因为在正常情况下，我们解析一些简单的数据确实很简单。上面代码中的复杂逻辑是处理过滤。
说到筛选，这里我使用了一个小技巧（当然，当人多的时候，这不再只是一个技巧。但是这个方法可以在以后的编码过程中参考）。我们使用一些特殊的标签属性（比如 id、class 等）来锁定块。当我们启动block时，我们对应的flag会被标记为True，当我们退出block时，我们对应的flag会被标记为False。也许你觉得这太麻烦了。事实上，如果你仔细想想，你就会知道这是有道理的。
预防措施：
1.在使用Java进行页面爬取时，我们使用了代理服务器。这个代理服务器的主机和端口可以直接在网上免费查到。
2.您需要准备以下jar包并导入到您的Eclipse项目中：
3.修改MySQL默认编码为UTF-8
因为这里会有一些中文信息，所以我们需要转换一下MySQL的编码格式。
如果你是在Linux下编码，那么你可以参考： 查看全部
前言：
网络爬虫看起来仍然很棒。但是，如果您考虑一下或进行一些研究，您就会知道爬虫并没有那么复杂。最深的就是当我们的数据量非常大的时候，也就是我们的网络“图”的循环越来越多的时候怎么解决。
这篇文章文章只是在这里作为一个介绍。本文主要讲解如何使用Java/Python访问网页和获取网页代码，Python模仿浏览器访问网页，使用Python进行数据分析。希望我们从这篇文章开始，一步步揭开网络蜘蛛的神秘面纱。
参考：
1. "做你自己的手写网络爬虫"
2. 用python写爬虫，爬取csdn的内容，完美解决403 Forbidden
运行效果图：
内容有点多，我只挑了一部分展示。
作者的环境：
系统：Windows 7
CentOS 6.5
运行环境：JDK1.7
Python 2.6.6
IDE：EclipseRelease 4.2.0
PyCharm 4.5.1
数据库：MySQLVer 14.14 Distrib 5.1.73
开发过程：1. 使用Java抓取页面
对于页面抓取，我们使用Java来实现，当然你也可以使用其他语言来开发。但
我们以“博客园”的主页为例，展示使用Java抓取网页的过程：
public class RetrivePageSimple {
private static HttpClient httpClient = new HttpClient();
// 设置代理服务器
static {
httpClient.getHostConfiguration().setProxy("58.220.2.132", 80);
}
public static boolean downloadPage(String path) throws HttpException,
IOException {
PostMethod postMethod = new PostMethod(path);
// 执行，返回状态码
int statusCode = httpClient.executeMethod(postMethod);
System.out.println(statusCode);
// 针对状态码进行处理 (简单起见，只处理返回值为200的状态码)
if (statusCode == HttpStatus.SC_OK) {
String a = postMethod.getResponseBodyAsString();
System.out.println(a);
return true;
}
return false;
}
public static void main(String[] args) {
try {
RetrivePageSimple.downloadPage("http://www.cnblogs.com/");
} catch (HttpException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
}
结果信息这里不再显示了，太多了。. . ——！
2.使用Python爬取页面
你可能会问，为什么写成Java版本是用来爬网页的，而这里又是一个Python呢？这是必要的。因为作者在开发这个demo之前没有考虑一个问题。当我们使用Java抓取一个网页并将其发送到Python时，网页字符串太长而无法作为参数传递。你可能认为保存文件是一个不错的选择，但是如果html文件太多怎么办？是的，在这里我们必须放弃这种累人的方法。
考虑到参数长度的限制，这里只给出Java端的页面地址，使用Python爬取网页。
以最简单的方式，我们通常使用 Python 网页是这样的：
import urllib2
result = urllib2.urlopen(\'http://blog.csdn.net/mobile/index.html\')
html = result.read()
print html
不过作者在代码中使用了CSDN的博客频道的url。CSDN 对爬虫的访问进行过滤。如下，我们会得到如下错误信息：
403，我被拒绝了。
3.使用仿浏览器登录网站
如前所述，当我们访问带有保护措施的网页时，我们会被拒绝。但是我们可以尝试使用我们的浏览器来访问它，它是可以访问的。
换句话说，如果我们可以在 Python 中将自己模仿为浏览器，我们就可以访问这个网页。下面是Python模仿浏览器的代码：
import random
import socket
import urllib2
import cookielib
ERROR = {
\'0\':\'Can not open the url,checck you net\',
\'1\':\'Creat download dir error\',
\'2\':\'The image links is empty\',
\'3\':\'Download faild\',
\'4\':\'Build soup error,the html is empty\',
\'5\':\'Can not save the image to your disk\',
}
class BrowserBase(object):
def __init__(self):
socket.setdefaulttimeout(20)
self._content = None
def speak(self, name, content):
print \'[%s]%s\' % (name, content)
def open_url(self, url):
"""
打开网页
"""
cookie_support= urllib2.HTTPCookieProcessor(cookielib.CookieJar())
self.opener = urllib2.build_opener(cookie_support,urllib2.HTTPHandler)
urllib2.install_opener(self.opener)
user_agents = [
\'Mozilla/5.0 (Windows; U; Windows NT 5.1; it; rv:1.8.1.11) Gecko/20071127 Firefox/2.0.0.11\',
\'Opera/9.25 (Windows NT 5.1; U; en)\',
\'Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; SV1; .NET CLR 1.1.4322; .NET CLR 2.0.50727)\',
\'Mozilla/5.0 (compatible; Konqueror/3.5; Linux) KHTML/3.5.5 (like Gecko) (Kubuntu)\',
\'Mozilla/5.0 (X11; U; Linux i686; en-US; rv:1.8.0.12) Gecko/20070731 Ubuntu/dapper-security Firefox/1.5.0.12\',
\'Lynx/2.8.5rel.1 libwww-FM/2.14 SSL-MM/1.4.1 GNUTLS/1.2.9\',
"Mozilla/5.0 (X11; Linux i686) AppleWebKit/535.7 (KHTML, like Gecko) Ubuntu/11.04 Chromium/16.0.912.77 Chrome/16.0.912.77 Safari/535.7",
"Mozilla/5.0 (X11; Ubuntu; Linux i686; rv:10.0) Gecko/20100101 Firefox/10.0 ",
]
agent = random.choice(user_agents)
self.opener.addheaders = [("User-agent", agent), ("Accept", "*/*"), (\'Referer\', \'http://www.google.com\')]
try:
res = self.opener.open(url)
self._content = res.read()
# print self._content
except Exception, e:
self.speak(str(e)+url)
raise Exception
else:
return res
def get_html_content(self):
return self._content
def get_html_response(html):
spider = BrowserBase()
spider.open_url(html)
return spider.get_html_content()
以上代码可以正常获取返回值。下面我们来看看返回结果的解析过程。
4.数据分析
使用 Python 解析 Html 异常简单：
import HTMLParser
class ListWebParser(HTMLParser.HTMLParser):
def __init__(self):
HTMLParser.HTMLParser.__init__(self)
self.tagDIVFlag = False
self.tagDIVAFlag = False
self.tagH1Flag = False
self.tagSecondHrefFlag = False
self._name = None
self._address = None
def handle_starttag(self, tag, attrs):
if tag == \'div\':
for name, value in attrs:
if name == \'class\' and value == \'blog_list\':
self.tagDIVFlag = True
if tag == \'h1\':
if self.tagDIVFlag:
self.tagH1Flag = True
# print \'h1->\', self.tagH1Flag
if tag == \'a\':
#if self.tagDIVAFlag:
#print \'h1: \', self.tagH1Flag
if self.tagH1Flag:
for name, value in attrs:
if name == \'target\' and value == \'_blank\':
self.tagDIVAFlag = True
if name == \'href\':
if self.tagSecondHrefFlag:
print \'网址：\', value
self._address = value
self.tagSecondHrefFlag = True
# if name == \'href\' and self.tagDIVAFlag:
# print \'网址：\', value
# self._address = value
def handle_endtag(self, tag):
if tag == \'div\':
self.tagDIVFlag = False
if tag == \'h1\':
self.tagH1Flag = False
# print \'false h1.\'
if tag == \'a\':
self.tagDIVAFlag = False
def handle_data(self, data):
if self.tagDIVAFlag:
print u"名称：", data.decode("utf-8")
如果你说你在网上找到的Html文件就没有这个烦恼。我承认这一点，因为在正常情况下，我们解析一些简单的数据确实很简单。上面代码中的复杂逻辑是处理过滤。
说到筛选，这里我使用了一个小技巧（当然，当人多的时候，这不再只是一个技巧。但是这个方法可以在以后的编码过程中参考）。我们使用一些特殊的标签属性（比如 id、class 等）来锁定块。当我们启动block时，我们对应的flag会被标记为True，当我们退出block时，我们对应的flag会被标记为False。也许你觉得这太麻烦了。事实上，如果你仔细想想，你就会知道这是有道理的。
预防措施：
1.在使用Java进行页面爬取时，我们使用了代理服务器。这个代理服务器的主机和端口可以直接在网上免费查到。
2.您需要准备以下jar包并导入到您的Eclipse项目中：
3.修改MySQL默认编码为UTF-8
因为这里会有一些中文信息，所以我们需要转换一下MySQL的编码格式。
如果你是在Linux下编码，那么你可以参考： 查看全部
httpclient 抓取网页(如何使用Java/Python访问网页和使用Python进行数据解析)
前言：
网络爬虫看起来仍然很棒。但是，如果您考虑一下或进行一些研究，您就会知道爬虫并没有那么复杂。最深的就是当我们的数据量非常大的时候，也就是我们的网络“图”的循环越来越多的时候怎么解决。
这篇文章文章只是在这里作为一个介绍。本文主要讲解如何使用Java/Python访问网页和获取网页代码，Python模仿浏览器访问网页，使用Python进行数据分析。希望我们从这篇文章开始，一步步揭开网络蜘蛛的神秘面纱。
参考：
1. "做你自己的手写网络爬虫"
2. 用python写爬虫，爬取csdn的内容，完美解决403 Forbidden
运行效果图：
内容有点多，我只挑了一部分展示。
作者的环境：
系统：Windows 7
CentOS 6.5
运行环境：JDK1.7
Python 2.6.6
IDE：EclipseRelease 4.2.0
PyCharm 4.5.1
数据库：MySQLVer 14.14 Distrib 5.1.73
开发过程：1. 使用Java抓取页面
对于页面抓取，我们使用Java来实现，当然你也可以使用其他语言来开发。但
我们以“博客园”的主页为例，展示使用Java抓取网页的过程：
public class RetrivePageSimple {
private static HttpClient httpClient = new HttpClient();
// 设置代理服务器
static {
httpClient.getHostConfiguration().setProxy("58.220.2.132", 80);
}
public static boolean downloadPage(String path) throws HttpException,
IOException {
PostMethod postMethod = new PostMethod(path);
// 执行，返回状态码
int statusCode = httpClient.executeMethod(postMethod);
System.out.println(statusCode);
// 针对状态码进行处理 (简单起见，只处理返回值为200的状态码)
if (statusCode == HttpStatus.SC_OK) {
String a = postMethod.getResponseBodyAsString();
System.out.println(a);
return true;
}
return false;
}
public static void main(String[] args) {
try {
RetrivePageSimple.downloadPage("http://www.cnblogs.com/";);
} catch (HttpException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
}
结果信息这里不再显示了，太多了。. . ——！
2.使用Python爬取页面
你可能会问，为什么写成Java版本是用来爬网页的，而这里又是一个Python呢？这是必要的。因为作者在开发这个demo之前没有考虑一个问题。当我们使用Java抓取一个网页并将其发送到Python时，网页字符串太长而无法作为参数传递。你可能认为保存文件是一个不错的选择，但是如果html文件太多怎么办？是的，在这里我们必须放弃这种累人的方法。
考虑到参数长度的限制，这里只给出Java端的页面地址，使用Python爬取网页。
以最简单的方式，我们通常使用 Python 网页是这样的：
import urllib2
result = urllib2.urlopen(\'http://blog.csdn.net/mobile/index.html\')
html = result.read()
print html
不过作者在代码中使用了CSDN的博客频道的url。CSDN 对爬虫的访问进行过滤。如下，我们会得到如下错误信息：
403，我被拒绝了。
3.使用仿浏览器登录网站
如前所述，当我们访问带有保护措施的网页时，我们会被拒绝。但是我们可以尝试使用我们的浏览器来访问它，它是可以访问的。
换句话说，如果我们可以在 Python 中将自己模仿为浏览器，我们就可以访问这个网页。下面是Python模仿浏览器的代码：
import random
import socket
import urllib2
import cookielib
ERROR = {
\'0\':\'Can not open the url,checck you net\',
\'1\':\'Creat download dir error\',
\'2\':\'The image links is empty\',
\'3\':\'Download faild\',
\'4\':\'Build soup error,the html is empty\',
\'5\':\'Can not save the image to your disk\',
}
class BrowserBase(object):
def __init__(self):
socket.setdefaulttimeout(20)
self._content = None
def speak(self, name, content):
print \'[%s]%s\' % (name, content)
def open_url(self, url):
"""
打开网页
"""
cookie_support= urllib2.HTTPCookieProcessor(cookielib.CookieJar())
self.opener = urllib2.build_opener(cookie_support,urllib2.HTTPHandler)
urllib2.install_opener(self.opener)
user_agents = [
\'Mozilla/5.0 (Windows; U; Windows NT 5.1; it; rv:1.8.1.11) Gecko/20071127 Firefox/2.0.0.11\',
\'Opera/9.25 (Windows NT 5.1; U; en)\',
\'Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; SV1; .NET CLR 1.1.4322; .NET CLR 2.0.50727)\',
\'Mozilla/5.0 (compatible; Konqueror/3.5; Linux) KHTML/3.5.5 (like Gecko) (Kubuntu)\',
\'Mozilla/5.0 (X11; U; Linux i686; en-US; rv:1.8.0.12) Gecko/20070731 Ubuntu/dapper-security Firefox/1.5.0.12\',
\'Lynx/2.8.5rel.1 libwww-FM/2.14 SSL-MM/1.4.1 GNUTLS/1.2.9\',
"Mozilla/5.0 (X11; Linux i686) AppleWebKit/535.7 (KHTML, like Gecko) Ubuntu/11.04 Chromium/16.0.912.77 Chrome/16.0.912.77 Safari/535.7",
"Mozilla/5.0 (X11; Ubuntu; Linux i686; rv:10.0) Gecko/20100101 Firefox/10.0 ",
]
agent = random.choice(user_agents)
self.opener.addheaders = [("User-agent", agent), ("Accept", "*/*"), (\'Referer\', \'http://www.google.com\')]
try:
res = self.opener.open(url)
self._content = res.read()
# print self._content
except Exception, e:
self.speak(str(e)+url)
raise Exception
else:
return res
def get_html_content(self):
return self._content
def get_html_response(html):
spider = BrowserBase()
spider.open_url(html)
return spider.get_html_content()
以上代码可以正常获取返回值。下面我们来看看返回结果的解析过程。
4.数据分析
使用 Python 解析 Html 异常简单：
import HTMLParser
class ListWebParser(HTMLParser.HTMLParser):
def __init__(self):
HTMLParser.HTMLParser.__init__(self)
self.tagDIVFlag = False
self.tagDIVAFlag = False
self.tagH1Flag = False
self.tagSecondHrefFlag = False
self._name = None
self._address = None
def handle_starttag(self, tag, attrs):
if tag == \'div\':
for name, value in attrs:
if name == \'class\' and value == \'blog_list\':
self.tagDIVFlag = True
if tag == \'h1\':
if self.tagDIVFlag:
self.tagH1Flag = True
# print \'h1->\', self.tagH1Flag
if tag == \'a\':
#if self.tagDIVAFlag:
#print \'h1: \', self.tagH1Flag
if self.tagH1Flag:
for name, value in attrs:
if name == \'target\' and value == \'_blank\':
self.tagDIVAFlag = True
if name == \'href\':
if self.tagSecondHrefFlag:
print \'网址：\', value
self._address = value
self.tagSecondHrefFlag = True
# if name == \'href\' and self.tagDIVAFlag:
# print \'网址：\', value
# self._address = value
def handle_endtag(self, tag):
if tag == \'div\':
self.tagDIVFlag = False
if tag == \'h1\':
self.tagH1Flag = False
# print \'false h1.\'
if tag == \'a\':
self.tagDIVAFlag = False
def handle_data(self, data):
if self.tagDIVAFlag:
print u"名称：", data.decode("utf-8")
如果你说你在网上找到的Html文件就没有这个烦恼。我承认这一点，因为在正常情况下，我们解析一些简单的数据确实很简单。上面代码中的复杂逻辑是处理过滤。
说到筛选，这里我使用了一个小技巧（当然，当人多的时候，这不再只是一个技巧。但是这个方法可以在以后的编码过程中参考）。我们使用一些特殊的标签属性（比如 id、class 等）来锁定块。当我们启动block时，我们对应的flag会被标记为True，当我们退出block时，我们对应的flag会被标记为False。也许你觉得这太麻烦了。事实上，如果你仔细想想，你就会知道这是有道理的。
预防措施：
1.在使用Java进行页面爬取时，我们使用了代理服务器。这个代理服务器的主机和端口可以直接在网上免费查到。
2.您需要准备以下jar包并导入到您的Eclipse项目中：
3.修改MySQL默认编码为UTF-8
因为这里会有一些中文信息，所以我们需要转换一下MySQL的编码格式。
如果你是在Linux下编码，那么你可以参考：
httpclient 抓取网页(,实例分析了java爬虫的两种实现技巧具有一定参考借鉴价值)
网站优化 • 优采云 发表了文章 • 0 个评论 • 65 次浏览 • 2021-11-15 10:09
httpclient 抓取网页(,实例分析了java爬虫的两种实现技巧具有一定参考借鉴价值)
本文文章主要介绍JAVA利用爬虫抓取网站网页内容的方法。实例分析了java爬虫的两种实现技术。有一定的参考价值，有需要的朋友可以参考。下
本文以JAVA如何使用爬虫抓取网站网页内容为例。分享给大家，供大家参考。详情如下：
最近在用JAVA学习爬虫技术。哈哈，我进了门，和大家分享我的经历。
下面提供了两种方法，一种是使用apache提供的包。另一种是JAVA自带的。
代码如下：
<p> // 第一种方法 //这种方法是用apache提供的包,简单方便 //但是要用到以下包:commons-codec-1.4.jar // commons-httpclient-3.1.jar // commons-logging-1.0.4.jar public static String createhttpClient(String url, String param) { HttpClient client = new HttpClient(); String response = null; String keyword = null; PostMethod postMethod = new PostMethod(url); // try { // if (param != null) // keyword = new String(param.getBytes("gb2312"), "ISO-8859-1"); // } catch (UnsupportedEncodingException e1) { // // TODO Auto-generated catch block // e1.printStackTrace(); // } // NameValuePair[] data = { new NameValuePair("keyword", keyword) }; // // 将表单的值放入postMethod中 // postMethod.setRequestBody(data); // 以上部分是带参数抓取,我自己把它注销了．大家可以把注销消掉研究下 try { int statusCode = client.executeMethod(postMethod); response = new String(postMethod.getResponseBodyAsString() .getBytes("ISO-8859-1"), "gb2312"); //这里要注意下 gb2312要和你抓取网页的编码要一样 String p = response.replaceAll("//&[a-zA-Z]{1,10};", "") .replaceAll("]*>", "");//去掉网页中带有html语言的标签 System.out.println(p); } catch (Exception e) { e.printStackTrace(); } return response; } // 第二种方法 // 这种方法是JAVA自带的URL来抓取网站内容 public String getPageContent(String strUrl, String strPostRequest, int maxLength) { // 读取结果网页 StringBuffer buffer = new StringBuffer(); System.setProperty("sun.net.client.defaultConnectTimeout", "5000"); System.setProperty("sun.net.client.defaultReadTimeout", "5000"); try { URL newUrl = new URL(strUrl); HttpURLConnection hConnect = (HttpURLConnection) newUrl .openConnection(); // POST方式的额外数据 if (strPostRequest.length() > 0) { hConnect.setDoOutput(true); OutputStreamWriter out = new OutputStreamWriter(hConnect .getOutputStream()); out.write(strPostRequest); out.flush(); out.close(); } // 读取内容 BufferedReader rd = new BufferedReader(new InputStreamReader( hConnect.getInputStream())); int ch; for (int length = 0; (ch = rd.read()) > -1 && (maxLength 查看全部
本文文章主要介绍JAVA利用爬虫抓取网站网页内容的方法。实例分析了java爬虫的两种实现技术。有一定的参考价值，有需要的朋友可以参考。下
本文以JAVA如何使用爬虫抓取网站网页内容为例。分享给大家，供大家参考。详情如下：
最近在用JAVA学习爬虫技术。哈哈，我进了门，和大家分享我的经历。
下面提供了两种方法，一种是使用apache提供的包。另一种是JAVA自带的。
代码如下：
<p> // 第一种方法 //这种方法是用apache提供的包,简单方便 //但是要用到以下包:commons-codec-1.4.jar // commons-httpclient-3.1.jar // commons-logging-1.0.4.jar public static String createhttpClient(String url, String param) { HttpClient client = new HttpClient(); String response = null; String keyword = null; PostMethod postMethod = new PostMethod(url); // try { // if (param != null) // keyword = new String(param.getBytes("gb2312"), "ISO-8859-1"); // } catch (UnsupportedEncodingException e1) { // // TODO Auto-generated catch block // e1.printStackTrace(); // } // NameValuePair[] data = { new NameValuePair("keyword", keyword) }; // // 将表单的值放入postMethod中 // postMethod.setRequestBody(data); // 以上部分是带参数抓取,我自己把它注销了．大家可以把注销消掉研究下 try { int statusCode = client.executeMethod(postMethod); response = new String(postMethod.getResponseBodyAsString() .getBytes("ISO-8859-1"), "gb2312"); //这里要注意下 gb2312要和你抓取网页的编码要一样 String p = response.replaceAll("//&[a-zA-Z]{1,10};", "") .replaceAll("]*>", "");//去掉网页中带有html语言的标签 System.out.println(p); } catch (Exception e) { e.printStackTrace(); } return response; } // 第二种方法 // 这种方法是JAVA自带的URL来抓取网站内容 public String getPageContent(String strUrl, String strPostRequest, int maxLength) { // 读取结果网页 StringBuffer buffer = new StringBuffer(); System.setProperty("sun.net.client.defaultConnectTimeout", "5000"); System.setProperty("sun.net.client.defaultReadTimeout", "5000"); try { URL newUrl = new URL(strUrl); HttpURLConnection hConnect = (HttpURLConnection) newUrl .openConnection(); // POST方式的额外数据 if (strPostRequest.length() > 0) { hConnect.setDoOutput(true); OutputStreamWriter out = new OutputStreamWriter(hConnect .getOutputStream()); out.write(strPostRequest); out.flush(); out.close(); } // 读取内容 BufferedReader rd = new BufferedReader(new InputStreamReader( hConnect.getInputStream())); int ch; for (int length = 0; (ch = rd.read()) > -1 && (maxLength 查看全部
httpclient 抓取网页(,实例分析了java爬虫的两种实现技巧具有一定参考借鉴价值)
本文文章主要介绍JAVA利用爬虫抓取网站网页内容的方法。实例分析了java爬虫的两种实现技术。有一定的参考价值，有需要的朋友可以参考。下
本文以JAVA如何使用爬虫抓取网站网页内容为例。分享给大家，供大家参考。详情如下：
最近在用JAVA学习爬虫技术。哈哈，我进了门，和大家分享我的经历。
下面提供了两种方法，一种是使用apache提供的包。另一种是JAVA自带的。
代码如下：
<p> // 第一种方法 //这种方法是用apache提供的包,简单方便 //但是要用到以下包:commons-codec-1.4.jar // commons-httpclient-3.1.jar // commons-logging-1.0.4.jar public static String createhttpClient(String url, String param) { HttpClient client = new HttpClient(); String response = null; String keyword = null; PostMethod postMethod = new PostMethod(url); // try { // if (param != null) // keyword = new String(param.getBytes("gb2312"), "ISO-8859-1"); // } catch (UnsupportedEncodingException e1) { // // TODO Auto-generated catch block // e1.printStackTrace(); // } // NameValuePair[] data = { new NameValuePair("keyword", keyword) }; // // 将表单的值放入postMethod中 // postMethod.setRequestBody(data); // 以上部分是带参数抓取,我自己把它注销了．大家可以把注销消掉研究下 try { int statusCode = client.executeMethod(postMethod); response = new String(postMethod.getResponseBodyAsString() .getBytes("ISO-8859-1"), "gb2312"); //这里要注意下 gb2312要和你抓取网页的编码要一样 String p = response.replaceAll("//&[a-zA-Z]{1,10};", "") .replaceAll("]*>", "");//去掉网页中带有html语言的标签 System.out.println(p); } catch (Exception e) { e.printStackTrace(); } return response; } // 第二种方法 // 这种方法是JAVA自带的URL来抓取网站内容 public String getPageContent(String strUrl, String strPostRequest, int maxLength) { // 读取结果网页 StringBuffer buffer = new StringBuffer(); System.setProperty("sun.net.client.defaultConnectTimeout", "5000"); System.setProperty("sun.net.client.defaultReadTimeout", "5000"); try { URL newUrl = new URL(strUrl); HttpURLConnection hConnect = (HttpURLConnection) newUrl .openConnection(); // POST方式的额外数据 if (strPostRequest.length() > 0) { hConnect.setDoOutput(true); OutputStreamWriter out = new OutputStreamWriter(hConnect .getOutputStream()); out.write(strPostRequest); out.flush(); out.close(); } // 读取内容 BufferedReader rd = new BufferedReader(new InputStreamReader( hConnect.getInputStream())); int ch; for (int length = 0; (ch = rd.read()) > -1 && (maxLength
httpclient 抓取网页(GET方法模拟抓取网页使用org.apache.HttpClient )
网站优化 • 优采云 发表了文章 • 0 个评论 • 64 次浏览 • 2021-11-01 15:05
httpclient 抓取网页(GET方法模拟抓取网页使用org.apache.HttpClient
)
我目前正在学习Android并开发了一个类似于Super Course Schedule和Campus Today的APP。然而，我一直卡在抢课表这一步。遍历了很多数据，还是解决不了。我下定决心要系统信息HttpClient。写一个helloWord，继续记录和学习！
一、GET 方法模拟爬取网页
使用org.apache.HttpClient GET方法模拟登录网页并抓取数据，需要使用HttpClient包
import org.apache.http.HttpEntity;
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 java.io.IOException;
public class HellWord {
//直接模拟
public static void main(String[] a){
//生成一个可关闭的HTTP浏览器（相当于）
CloseableHttpClient httpClient=HttpClients.createDefault();
CloseableHttpResponse response=null;
//创建http Get请求
HttpGet httpGet=new HttpGet("http://hll520.cn");
try {
response=httpClient.execute(httpGet);//执行
} catch (IOException e) {
e.printStackTrace();
}
//获取网页源码
HttpEntity httpEntity=response.getEntity();//获取网页源码
try {
String h=EntityUtils.toString(httpEntity,"UTF-8");//指定编码避免乱码
System.out.printf(h);
} catch (IOException e) {
//io异常（网络问题）
e.printStackTrace();
}
//关闭HTTp
try {
response.close();
httpClient.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
运行结果，模拟打开网页，使用getEntity显示网页的HTML源代码
二、模拟浏览器UA并返回状态
有些网页会给不同的浏览器提供不同的页面，或者限制机器抓取。这时候需要设置UA模拟浏览器登录页面，可以使用getStatusLine返回状态。
1、设置请求头的UA模拟火狐浏览器
httpGet.setHeader("User-Agent","Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:74.0) Gecko/20100101 Firefox/74.0");
2、返回状态
response.getStatusLine();//获取当前状态
如果只返回状态码(200）
response.getStatusLine().getStatusCode()
3、返回类型
确定链接的目标类型
entity.getContentType().getValue()
三、带参数的GET
使用URIBuilder构造一个URI，并设置参数，多个参数就是多个setParameters
URIBuilder uriBuilder=new URIBuilder("http://baidu.com");
//写入参数 (可以设置多参数）
uriBuilder.setParameter("key","JAVA");
uriBuilder.setParameter("keys","c#");
使用build()方法转换为URI
httpGet=new HttpGet(uriBuilder.build());//使用builder写入URI
带参数的完整代码
import org.apache.http.HttpEntity;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.utils.URIBuilder;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.util.EntityUtils;
import java.io.IOException;
import java.net.URISyntaxException;
//带参数的get
public class HelloWordUA {
public static void main(String[] ars){
//生成一个可关闭的HTTP浏览器（相当于）
CloseableHttpClient httpClient= HttpClients.createDefault();
CloseableHttpResponse response=null;
HttpGet httpGet=null;
try {
URIBuilder uriBuilder=new URIBuilder("http://baidu.com");
//写入参数 (可以设置多参数）
uriBuilder.setParameter("key","JAVA");
uriBuilder.setParameter("keys","c#");
System.out.println(uriBuilder.build());
//创建http Get请求
httpGet=new HttpGet(uriBuilder.build());//使用builder写入URI
} catch (URISyntaxException e) {
e.printStackTrace();
}
//设置请求头，UA浏览器型号，模拟火狐浏览器
httpGet.setHeader("User-Agent","Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:74.0) Gecko/20100101 Firefox/74.0");
try {
response=httpClient.execute(httpGet);//执行
//获取当响应状态
// response.getStatusLine();//获取当前状态
//response.getStatusLine().getStatusCode() 获取当前状态码
System.out.println("Status:"+response.getStatusLine().getStatusCode());
//获取网页源码
HttpEntity entity=response.getEntity();//获取网页实体
//获取目标类型
System.out.println("ContentType："+entity.getContentType().getValue());
System.out.println(EntityUtils.toString(entity,"UTF-8"));
} catch (IOException e) {
e.printStackTrace();
}
//关闭HTTp
try {
response.close();
httpClient.close();
} catch (IOException e) {
e.printStackTrace();
}
}
} 查看全部
)
我目前正在学习Android并开发了一个类似于Super Course Schedule和Campus Today的APP。然而，我一直卡在抢课表这一步。遍历了很多数据，还是解决不了。我下定决心要系统信息HttpClient。写一个helloWord，继续记录和学习！
一、GET 方法模拟爬取网页
使用org.apache.HttpClient GET方法模拟登录网页并抓取数据，需要使用HttpClient包
import org.apache.http.HttpEntity;
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 java.io.IOException;
public class HellWord {
//直接模拟
public static void main(String[] a){
//生成一个可关闭的HTTP浏览器（相当于）
CloseableHttpClient httpClient=HttpClients.createDefault();
CloseableHttpResponse response=null;
//创建http Get请求
HttpGet httpGet=new HttpGet("http://hll520.cn");
try {
response=httpClient.execute(httpGet);//执行
} catch (IOException e) {
e.printStackTrace();
}
//获取网页源码
HttpEntity httpEntity=response.getEntity();//获取网页源码
try {
String h=EntityUtils.toString(httpEntity,"UTF-8");//指定编码避免乱码
System.out.printf(h);
} catch (IOException e) {
//io异常（网络问题）
e.printStackTrace();
}
//关闭HTTp
try {
response.close();
httpClient.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
运行结果，模拟打开网页，使用getEntity显示网页的HTML源代码
二、模拟浏览器UA并返回状态
有些网页会给不同的浏览器提供不同的页面，或者限制机器抓取。这时候需要设置UA模拟浏览器登录页面，可以使用getStatusLine返回状态。
1、设置请求头的UA模拟火狐浏览器
httpGet.setHeader("User-Agent","Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:74.0) Gecko/20100101 Firefox/74.0");
2、返回状态
response.getStatusLine();//获取当前状态
如果只返回状态码(200）
response.getStatusLine().getStatusCode()
3、返回类型
确定链接的目标类型
entity.getContentType().getValue()
三、带参数的GET
使用URIBuilder构造一个URI，并设置参数，多个参数就是多个setParameters
URIBuilder uriBuilder=new URIBuilder("http://baidu.com");
//写入参数 (可以设置多参数）
uriBuilder.setParameter("key","JAVA");
uriBuilder.setParameter("keys","c#");
使用build()方法转换为URI
httpGet=new HttpGet(uriBuilder.build());//使用builder写入URI
带参数的完整代码
import org.apache.http.HttpEntity;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.utils.URIBuilder;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.util.EntityUtils;
import java.io.IOException;
import java.net.URISyntaxException;
//带参数的get
public class HelloWordUA {
public static void main(String[] ars){
//生成一个可关闭的HTTP浏览器（相当于）
CloseableHttpClient httpClient= HttpClients.createDefault();
CloseableHttpResponse response=null;
HttpGet httpGet=null;
try {
URIBuilder uriBuilder=new URIBuilder("http://baidu.com");
//写入参数 (可以设置多参数）
uriBuilder.setParameter("key","JAVA");
uriBuilder.setParameter("keys","c#");
System.out.println(uriBuilder.build());
//创建http Get请求
httpGet=new HttpGet(uriBuilder.build());//使用builder写入URI
} catch (URISyntaxException e) {
e.printStackTrace();
}
//设置请求头，UA浏览器型号，模拟火狐浏览器
httpGet.setHeader("User-Agent","Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:74.0) Gecko/20100101 Firefox/74.0");
try {
response=httpClient.execute(httpGet);//执行
//获取当响应状态
// response.getStatusLine();//获取当前状态
//response.getStatusLine().getStatusCode() 获取当前状态码
System.out.println("Status:"+response.getStatusLine().getStatusCode());
//获取网页源码
HttpEntity entity=response.getEntity();//获取网页实体
//获取目标类型
System.out.println("ContentType："+entity.getContentType().getValue());
System.out.println(EntityUtils.toString(entity,"UTF-8"));
} catch (IOException e) {
e.printStackTrace();
}
//关闭HTTp
try {
response.close();
httpClient.close();
} catch (IOException e) {
e.printStackTrace();
}
}
} 查看全部
httpclient 抓取网页(GET方法模拟抓取网页使用org.apache.HttpClient
)
我目前正在学习Android并开发了一个类似于Super Course Schedule和Campus Today的APP。然而，我一直卡在抢课表这一步。遍历了很多数据，还是解决不了。我下定决心要系统信息HttpClient。写一个helloWord，继续记录和学习！
一、GET 方法模拟爬取网页
使用org.apache.HttpClient GET方法模拟登录网页并抓取数据，需要使用HttpClient包
import org.apache.http.HttpEntity;
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 java.io.IOException;
public class HellWord {
//直接模拟
public static void main(String[] a){
//生成一个可关闭的HTTP浏览器（相当于）
CloseableHttpClient httpClient=HttpClients.createDefault();
CloseableHttpResponse response=null;
//创建http Get请求
HttpGet httpGet=new HttpGet("http://hll520.cn";);
try {
response=httpClient.execute(httpGet);//执行
} catch (IOException e) {
e.printStackTrace();
}
//获取网页源码
HttpEntity httpEntity=response.getEntity();//获取网页源码
try {
String h=EntityUtils.toString(httpEntity,"UTF-8");//指定编码避免乱码
System.out.printf(h);
} catch (IOException e) {
//io异常（网络问题）
e.printStackTrace();
}
//关闭HTTp
try {
response.close();
httpClient.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
运行结果，模拟打开网页，使用getEntity显示网页的HTML源代码
二、模拟浏览器UA并返回状态
有些网页会给不同的浏览器提供不同的页面，或者限制机器抓取。这时候需要设置UA模拟浏览器登录页面，可以使用getStatusLine返回状态。
1、设置请求头的UA模拟火狐浏览器
httpGet.setHeader("User-Agent","Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:74.0) Gecko/20100101 Firefox/74.0");
2、返回状态
response.getStatusLine();//获取当前状态
如果只返回状态码(200）
response.getStatusLine().getStatusCode()
3、返回类型
确定链接的目标类型
entity.getContentType().getValue()
三、带参数的GET
使用URIBuilder构造一个URI，并设置参数，多个参数就是多个setParameters
URIBuilder uriBuilder=new URIBuilder("http://baidu.com";);
//写入参数 (可以设置多参数）
uriBuilder.setParameter("key","JAVA");
uriBuilder.setParameter("keys","c#");
使用build()方法转换为URI
httpGet=new HttpGet(uriBuilder.build());//使用builder写入URI
带参数的完整代码
import org.apache.http.HttpEntity;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.utils.URIBuilder;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.util.EntityUtils;
import java.io.IOException;
import java.net.URISyntaxException;
//带参数的get
public class HelloWordUA {
public static void main(String[] ars){
//生成一个可关闭的HTTP浏览器（相当于）
CloseableHttpClient httpClient= HttpClients.createDefault();
CloseableHttpResponse response=null;
HttpGet httpGet=null;
try {
URIBuilder uriBuilder=new URIBuilder("http://baidu.com";);
//写入参数 (可以设置多参数）
uriBuilder.setParameter("key","JAVA");
uriBuilder.setParameter("keys","c#");
System.out.println(uriBuilder.build());
//创建http Get请求
httpGet=new HttpGet(uriBuilder.build());//使用builder写入URI
} catch (URISyntaxException e) {
e.printStackTrace();
}
//设置请求头，UA浏览器型号，模拟火狐浏览器
httpGet.setHeader("User-Agent","Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:74.0) Gecko/20100101 Firefox/74.0");
try {
response=httpClient.execute(httpGet);//执行
//获取当响应状态
// response.getStatusLine();//获取当前状态
//response.getStatusLine().getStatusCode() 获取当前状态码
System.out.println("Status:"+response.getStatusLine().getStatusCode());
//获取网页源码
HttpEntity entity=response.getEntity();//获取网页实体
//获取目标类型
System.out.println("ContentType："+entity.getContentType().getValue());
System.out.println(EntityUtils.toString(entity,"UTF-8"));
} catch (IOException e) {
e.printStackTrace();
}
//关闭HTTp
try {
response.close();
httpClient.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
httpclient 抓取网页(java是一种可以撰写跨平台应用软件的程序设计语言和Java平台 )
网站优化 • 优采云 发表了文章 • 0 个评论 • 85 次浏览 • 2021-10-27 00:15
httpclient 抓取网页(java是一种可以撰写跨平台应用软件的程序设计语言和Java平台
)
Java 是一种面向对象的编程语言，可以编写跨平台的应用软件。是1995年5月推出的Java编程语言和Java平台（即JavaEE、JavaME、JavaSE）的总称。 本站提供基于Java框架struts、spring、hibernate的桌面应用、Web交互和移动端开发技巧和资料等
保持永久学习的心态，你会成为一个优秀的自己，继续从事java知识。
直接上代码，代码中有详细注释
1import org.apache.commons.httpclient.Cookie;
import org.apache.commons.httpclient.Header;
import org.apache.commons.httpclient.HttpClient;
import org.apache.commons.httpclient.NameValuePair;
import org.apache.commons.httpclient.methods.GetMethod;
import org.apache.commons.httpclient.methods.PostMethod;
import org.apache.commons.httpclient.params.HttpMethodParams;
public class test {
public static void main(String[] args) {
try {
// 先访问首页，得到cookie
// cookie信息自动保存在HttpClient中
HttpClient httpClient = new HttpClient();
PostMethod postMethod = new PostMethod("http://1.lexury2016.sinaapp.com/login");
httpClient.executeMethod(postMethod);
// 携带cookie访问登录网面
postMethod = new PostMethod("http://1.lexury2016.sinaapp.com/login");
// 设置登录的账号与密码
NameValuePair[] nameValuePairs = { new NameValuePair("stucid", "2013150091"),
new NameValuePair("stupassword", "ab1234") };
postMethod.setRequestBody(nameValuePairs);
// 设置请求编码为UTF-8
postMethod.getParams().setParameter(HttpMethodParams.HTTP_CONTENT_CHARSET, "UTF-8");
// httpclient访问登录网页
httpClient.executeMethod(postMethod);
// 得到响应文本
byte[] bytes = postMethod.getResponseBody();
String html = new String(bytes);
System.out.println(postMethod.getStatusCode());
// 输出为302，也就是说网页发生了重定向
// 得到重定向后的网页
Header redirect = postMethod.getResponseHeader("location");
String url = redirect.getValue();
// 使用get请求，访问登陆后的页面
GetMethod getMethod = new GetMethod(url);
httpClient.executeMethod(getMethod);
// 得到返回文本
bytes = getMethod.getResponseBody();
html = new String(bytes);
System.out.println(html);
} catch (Exception e) {
e.printStackTrace();
}
}
} 查看全部
)
Java 是一种面向对象的编程语言，可以编写跨平台的应用软件。是1995年5月推出的Java编程语言和Java平台（即JavaEE、JavaME、JavaSE）的总称。 本站提供基于Java框架struts、spring、hibernate的桌面应用、Web交互和移动端开发技巧和资料等
保持永久学习的心态，你会成为一个优秀的自己，继续从事java知识。
直接上代码，代码中有详细注释
1import org.apache.commons.httpclient.Cookie;
import org.apache.commons.httpclient.Header;
import org.apache.commons.httpclient.HttpClient;
import org.apache.commons.httpclient.NameValuePair;
import org.apache.commons.httpclient.methods.GetMethod;
import org.apache.commons.httpclient.methods.PostMethod;
import org.apache.commons.httpclient.params.HttpMethodParams;
public class test {
public static void main(String[] args) {
try {
// 先访问首页，得到cookie
// cookie信息自动保存在HttpClient中
HttpClient httpClient = new HttpClient();
PostMethod postMethod = new PostMethod("http://1.lexury2016.sinaapp.com/login");
httpClient.executeMethod(postMethod);
// 携带cookie访问登录网面
postMethod = new PostMethod("http://1.lexury2016.sinaapp.com/login");
// 设置登录的账号与密码
NameValuePair[] nameValuePairs = { new NameValuePair("stucid", "2013150091"),
new NameValuePair("stupassword", "ab1234") };
postMethod.setRequestBody(nameValuePairs);
// 设置请求编码为UTF-8
postMethod.getParams().setParameter(HttpMethodParams.HTTP_CONTENT_CHARSET, "UTF-8");
// httpclient访问登录网页
httpClient.executeMethod(postMethod);
// 得到响应文本
byte[] bytes = postMethod.getResponseBody();
String html = new String(bytes);
System.out.println(postMethod.getStatusCode());
// 输出为302，也就是说网页发生了重定向
// 得到重定向后的网页
Header redirect = postMethod.getResponseHeader("location");
String url = redirect.getValue();
// 使用get请求，访问登陆后的页面
GetMethod getMethod = new GetMethod(url);
httpClient.executeMethod(getMethod);
// 得到返回文本
bytes = getMethod.getResponseBody();
html = new String(bytes);
System.out.println(html);
} catch (Exception e) {
e.printStackTrace();
}
}
} 查看全部
httpclient 抓取网页(java是一种可以撰写跨平台应用软件的程序设计语言和Java平台
)
Java 是一种面向对象的编程语言，可以编写跨平台的应用软件。是1995年5月推出的Java编程语言和Java平台（即JavaEE、JavaME、JavaSE）的总称。 本站提供基于Java框架struts、spring、hibernate的桌面应用、Web交互和移动端开发技巧和资料等
保持永久学习的心态，你会成为一个优秀的自己，继续从事java知识。
直接上代码，代码中有详细注释
1import org.apache.commons.httpclient.Cookie;
import org.apache.commons.httpclient.Header;
import org.apache.commons.httpclient.HttpClient;
import org.apache.commons.httpclient.NameValuePair;
import org.apache.commons.httpclient.methods.GetMethod;
import org.apache.commons.httpclient.methods.PostMethod;
import org.apache.commons.httpclient.params.HttpMethodParams;
public class test {
public static void main(String[] args) {
try {
// 先访问首页，得到cookie
// cookie信息自动保存在HttpClient中
HttpClient httpClient = new HttpClient();
PostMethod postMethod = new PostMethod("http://1.lexury2016.sinaapp.com/login";);
httpClient.executeMethod(postMethod);
// 携带cookie访问登录网面
postMethod = new PostMethod("http://1.lexury2016.sinaapp.com/login";);
// 设置登录的账号与密码
NameValuePair[] nameValuePairs = { new NameValuePair("stucid", "2013150091"),
new NameValuePair("stupassword", "ab1234") };
postMethod.setRequestBody(nameValuePairs);
// 设置请求编码为UTF-8
postMethod.getParams().setParameter(HttpMethodParams.HTTP_CONTENT_CHARSET, "UTF-8");
// httpclient访问登录网页
httpClient.executeMethod(postMethod);
// 得到响应文本
byte[] bytes = postMethod.getResponseBody();
String html = new String(bytes);
System.out.println(postMethod.getStatusCode());
// 输出为302，也就是说网页发生了重定向
// 得到重定向后的网页
Header redirect = postMethod.getResponseHeader("location");
String url = redirect.getValue();
// 使用get请求，访问登陆后的页面
GetMethod getMethod = new GetMethod(url);
httpClient.executeMethod(getMethod);
// 得到返回文本
bytes = getMethod.getResponseBody();
html = new String(bytes);
System.out.println(html);
} catch (Exception e) {
e.printStackTrace();
}
}
}
httpclient 抓取网页(STM32 )
网站优化 • 优采云 发表了文章 • 0 个评论 • 75 次浏览 • 2021-10-15 08:19
httpclient 抓取网页(STM32
)
1、GET 方法
第一步是创建一个客户端，类似于用浏览器打开一个网页
HttpClient httpClient = new HttpClient();
第二步是创建一个GET方法来获取你需要爬取的网页的网址
GetMethod getMethod = new GetMethod("");
第三步，获取URL的响应状态码，200表示请求成功
int statusCode = httpClient.executeMethod(getMethod);
第四步，获取网页源代码
byte[] responseBody = getMethod.getResponseBody();
主要就是这四个步骤，当然还有很多其他的，比如网页编码的问题
HttpClient httpClient = new HttpClient();
GetMethod getMethod = new GetMethod("http://www.baidu.com/");
try {
int statusCode = httpClient.executeMethod(getMethod);
if (statusCode != HttpStatus.SC_OK) {
System.err.println("Method failed: "
+ getMethod.getStatusLine());
}
// 读取内容
byte[] responseBody = getMethod.getResponseBody();
// 处理内容
String html = new String(responseBody);
System.out.println(html);
} catch (Exception e) {
System.err.println("页面无法访问");
}finally{
getMethod.releaseConnection();
}
2、发布方式
HttpClient httpClient = new HttpClient();
PostMethod postMethod = new PostMethod(UrlPath);
postMethod.getParams().setParameter(HttpMethodParams.RETRY_HANDLER,new DefaultHttpMethodRetryHandler());
NameValuePair[] postData = new NameValuePair[2];
postData[0] = new NameValuePair("username", "xkey");
postData[1] = new NameValuePair("userpass", "********");
postMethod.setRequestBody(postData);
try {
int statusCode = httpClient.executeMethod(postMethod);
if (statusCode == HttpStatus.SC_OK) {
byte[] responseBody = postMethod.getResponseBody();
String html = new String(responseBody);
System.out.println(html);
}
} catch (Exception e) {
System.err.println("页面无法访问");
}finally{
postMethod.releaseConnection();
}
本例传递两个Post参数：username为xkey，userpass为*******，并传递给URL UrlPath
如需了解获取gzip网页的信息，请参考
另一种是获取非字符数据，所以可以使用下面的方法
HttpClient httpClient = new HttpClient();
GetMethod getMethod = new GetMethod("http://www.baidu.com");
try {
InputStream inputStream = getMethod.getResponseBodyAsStream();
// 这里处理 inputStream
} catch (Exception e) {
System.err.println("页面无法访问");
}finally{
getMethod.releaseConnection();
} 查看全部
)
1、GET 方法
第一步是创建一个客户端，类似于用浏览器打开一个网页
HttpClient httpClient = new HttpClient();
第二步是创建一个GET方法来获取你需要爬取的网页的网址
GetMethod getMethod = new GetMethod("");
第三步，获取URL的响应状态码，200表示请求成功
int statusCode = httpClient.executeMethod(getMethod);
第四步，获取网页源代码
byte[] responseBody = getMethod.getResponseBody();
主要就是这四个步骤，当然还有很多其他的，比如网页编码的问题
HttpClient httpClient = new HttpClient();
GetMethod getMethod = new GetMethod("http://www.baidu.com/");
try {
int statusCode = httpClient.executeMethod(getMethod);
if (statusCode != HttpStatus.SC_OK) {
System.err.println("Method failed: "
+ getMethod.getStatusLine());
}
// 读取内容
byte[] responseBody = getMethod.getResponseBody();
// 处理内容
String html = new String(responseBody);
System.out.println(html);
} catch (Exception e) {
System.err.println("页面无法访问");
}finally{
getMethod.releaseConnection();
}
2、发布方式
HttpClient httpClient = new HttpClient();
PostMethod postMethod = new PostMethod(UrlPath);
postMethod.getParams().setParameter(HttpMethodParams.RETRY_HANDLER,new DefaultHttpMethodRetryHandler());
NameValuePair[] postData = new NameValuePair[2];
postData[0] = new NameValuePair("username", "xkey");
postData[1] = new NameValuePair("userpass", "********");
postMethod.setRequestBody(postData);
try {
int statusCode = httpClient.executeMethod(postMethod);
if (statusCode == HttpStatus.SC_OK) {
byte[] responseBody = postMethod.getResponseBody();
String html = new String(responseBody);
System.out.println(html);
}
} catch (Exception e) {
System.err.println("页面无法访问");
}finally{
postMethod.releaseConnection();
}
本例传递两个Post参数：username为xkey，userpass为*******，并传递给URL UrlPath
如需了解获取gzip网页的信息，请参考
另一种是获取非字符数据，所以可以使用下面的方法
HttpClient httpClient = new HttpClient();
GetMethod getMethod = new GetMethod("http://www.baidu.com");
try {
InputStream inputStream = getMethod.getResponseBodyAsStream();
// 这里处理 inputStream
} catch (Exception e) {
System.err.println("页面无法访问");
}finally{
getMethod.releaseConnection();
} 查看全部
httpclient 抓取网页(STM32
)
1、GET 方法
第一步是创建一个客户端，类似于用浏览器打开一个网页
HttpClient httpClient = new HttpClient();
第二步是创建一个GET方法来获取你需要爬取的网页的网址
GetMethod getMethod = new GetMethod("");
第三步，获取URL的响应状态码，200表示请求成功
int statusCode = httpClient.executeMethod(getMethod);
第四步，获取网页源代码
byte[] responseBody = getMethod.getResponseBody();
主要就是这四个步骤，当然还有很多其他的，比如网页编码的问题
HttpClient httpClient = new HttpClient();
GetMethod getMethod = new GetMethod("http://www.baidu.com/";);
try {
int statusCode = httpClient.executeMethod(getMethod);
if (statusCode != HttpStatus.SC_OK) {
System.err.println("Method failed: "
+ getMethod.getStatusLine());
}
// 读取内容
byte[] responseBody = getMethod.getResponseBody();
// 处理内容
String html = new String(responseBody);
System.out.println(html);
} catch (Exception e) {
System.err.println("页面无法访问");
}finally{
getMethod.releaseConnection();
}
2、发布方式
HttpClient httpClient = new HttpClient();
PostMethod postMethod = new PostMethod(UrlPath);
postMethod.getParams().setParameter(HttpMethodParams.RETRY_HANDLER,new DefaultHttpMethodRetryHandler());
NameValuePair[] postData = new NameValuePair[2];
postData[0] = new NameValuePair("username", "xkey");
postData[1] = new NameValuePair("userpass", "********");
postMethod.setRequestBody(postData);
try {
int statusCode = httpClient.executeMethod(postMethod);
if (statusCode == HttpStatus.SC_OK) {
byte[] responseBody = postMethod.getResponseBody();
String html = new String(responseBody);
System.out.println(html);
}
} catch (Exception e) {
System.err.println("页面无法访问");
}finally{
postMethod.releaseConnection();
}
本例传递两个Post参数：username为xkey，userpass为*******，并传递给URL UrlPath
如需了解获取gzip网页的信息，请参考
另一种是获取非字符数据，所以可以使用下面的方法
HttpClient httpClient = new HttpClient();
GetMethod getMethod = new GetMethod("http://www.baidu.com";);
try {
InputStream inputStream = getMethod.getResponseBodyAsStream();
// 这里处理 inputStream
} catch (Exception e) {
System.err.println("页面无法访问");
}finally{
getMethod.releaseConnection();
}
