java爬虫抓取动态网页(
简单聊一聊如何用python爬取动态网站(一)_Python版本
)
　　Python爬虫爬取动态网站——爬取各大币种交易网站公告（二）
　　我们经常发现网页中的很多数据并不是用 HTML 编写的，而是通过 js 动态加载的。因此，引入了动态数据的概念。这里的动态数据是指网页中通过Javascript动态生成的页面内容，是页面加载到浏览器之后动态生成的，而不是之前动态生成的。
　　在编写爬虫爬取网页数据的时候，经常会遇到这种需要动态加载数据的HTML网页。如果还是直接从网页爬取，就无法获取任何数据。
　　今天就在这里简单的说一下如何使用python爬取动态网站。
　　Python版本：Python3.X
　　操作平台：Windows
　　IDE：PyCharm
　　浏览器：铬
　　网站: , CoinEx 等。这里以 , 为例。
　　(一）分析网站
　　查看网页源码，如下图，我们在HTML中找不到对应的公告信息：
　　
　　在Chrome浏览器中，点击F12打开网络中的XHR，我们抓取对应的js文件进行解析。如下所示：
　　
　　按F5刷新，我们看到如下界面：
　　
　　通知公告，明显和我们想要的有关，点击获取：
　　
　　显然，我们想要的只是在右侧，我们将在下面获得该信息。点击标题：
　　
　　我们得到了 Requests Header 和请求参数。
　　(二）通过requests模块发送POST请求
　　headers = {
'User - Agent': 'Mozilla / 5.0(Linux;Android6.0;Nexus5Build / MRA58N) AppleWebKit / 537.36(KHTML, likeGecko) Chrome / 67.0.3396.62MobileSafari / 537.36',
'Cookie': 'SESSION= 6b464d53 - 0609 - 4165 - 936a - a05755e6aa50;__jsluid = 2116ec5d7ed6479ffcc767fe36fcc671;Hm_lvt_0c4a3a6d4432aa88adff38d3193396ce = 1538189398;_uab_collina = 153818939825788460139305;__jsl_clearance = 1538189703.864 | 0 | UEnHiXDEq4kQ805BL4iBLIKbm % 2Fc % 3D;Hm_lpvt_0c4a3a6d4432aa88adff38d3193396ce = 1538189712',
'Referer': 'https: // www.cointiger.pro /'
}
data = {
'page': '1',
'pageSize': '20'
}
　　(三）提取信息
　　点击预览，我们得到：
　　
　　我们在其中找到了我们正在寻找的信息——时间、标题和 ID。
　　看到id，你可能会有疑问，为什么需要id？
　　让我们来看看其中的几个文章。
　　
　　
　　对比id，我们会发现每条公告的链接其实都是'
　　提取方法说明如下：
　　title = html_doc.get('data').get('noticeInfoList')[n].get('title')
　　其他两种提取方法相同。
　　除此之外，这里的时间是一个时间戳，我们需要将其转换为本地时间。
　　timestamp = html_doc.get('data').get('noticeInfoList')[n].get('ctime') / 1000 #/1000是因为时间戳一般为10位
timeArray = time.localtime(timestamp)
now_time = time.strftime("%Y-%m-%d-%H:%M:%S", timeArray)
　　(四）获取当地时间前一天的公告
　　同静态，我们先获取当地时间的前一天：
　　now_time = datetime.datetime.now()
yes_time = now_time + datetime.timedelta(days=-1)
yes_time_nyr = yes_time.strftime('%Y-%m-%d')
　　然后通过if语句来判断。
　　(五）总码
　　import requests
import json
import time
import datetime
if __name__=='__main__':
now_time = datetime.datetime.now()
yes_time = now_time + datetime.timedelta(days=-1)
yes_time_nyr = yes_time.strftime('%Y-%m-%d')
headers = {
'User - Agent': 'Mozilla / 5.0(Linux;Android6.0;Nexus5Build / MRA58N) AppleWebKit / 537.36(KHTML, likeGecko) Chrome / 67.0.3396.62MobileSafari / 537.36',
'Cookie': 'SESSION= 6b464d53 - 0609 - 4165 - 936a - a05755e6aa50;__jsluid = 2116ec5d7ed6479ffcc767fe36fcc671;Hm_lvt_0c4a3a6d4432aa88adff38d3193396ce = 1538189398;_uab_collina = 153818939825788460139305;__jsl_clearance = 1538189703.864 | 0 | UEnHiXDEq4kQ805BL4iBLIKbm % 2Fc % 3D;Hm_lpvt_0c4a3a6d4432aa88adff38d3193396ce = 1538189712',
'Referer': 'https: // www.cointiger.pro /'
}
data = {
'page': '1',
'pageSize': '20'
}
target = 'https://www.cointiger.pro/exchange/internal/sperate/public/notices?page=1&pageSize=20' #此为Request URL
req = requests.get(url=target, headers=headers, data=data)
html = req.text
html_doc = json.loads(html) #json.loads()解码python json格式
num = len(html_doc.get('data').get('noticeInfoList'))
n = 0
judge = []
while (n < num):
title = html_doc.get('data').get('noticeInfoList')[n].get('title')
timestamp = html_doc.get('data').get('noticeInfoList')[n].get('ctime') / 1000
timeArray = time.localtime(timestamp)
now_time = time.strftime("%Y-%m-%d-%H:%M:%S", timeArray)
id = html_doc.get('data').get('noticeInfoList')[n].get('id')
href = 'https://www.cointiger.pro/#/notice_detail/%s' % id
all = now_time + '\t' + title + '\t' + href
n = n + 1
if yes_time_nyr in all:
print(all)
judge += all
if len(judge) == 0:
print('本日无公告')
　　（笔记）
　　通过requests.post()发出POST请求时，传入的消息有两个参数，一个是data，一个是json。
　　常见的表单表单可以直接使用data参数进行消息提交，data对象是python中的字典类型；而在最新爬虫的过程中，遇到了payload消息，是json格式的消息。所以传入的消息对象也应该被格式化。消息提交有两种方法：
　　import requests
import json
url = "http://example.com"
data = { 'a': 1,
'b': 2,
}
#1
requests.post(url, data=json.dumps(data))
#2，json参数会自动将字典类型的对象转换为json格式
requests.post(url, json=data) 查看全部

　　java爬虫抓取动态网页(
Java爬虫被屏蔽，不要慌，聊反爬虫策略和反反爬虫
)
　　
　　这是Java爬虫系列的第五篇。在上一篇文章中，Java爬虫服务器被阻塞了。不要惊慌。换个服务器吧。印章及其相应措施。之前的文章文章我们讲了爬虫的基础知识。在这篇文章中，我们来谈谈爬虫架构。
　　在前面的章节中，我们的爬虫程序都是单线程的。我们在调试爬虫程序的时候，单线程爬虫是没有问题的，但是当我们使用单线程爬虫程序去在线环境下的采集网页时，单线程的两个致命问题问题暴露：
　　线上的环境不能像我们本地的测试一样，不关心采集的效率，只要能正确提取结果即可。在这个时间就是金钱的时代，不可能给你时间慢慢来采集，所以单线程爬虫程序是行不通的，我们需要将单线程改为多线程模式来改进采集 效率和提高计算机利用率。
　　多线程爬虫的设计比单线程复杂很多，但不同于其他需要在高并发下保证数据安全的业务。被视为一个独立的实体。做多线程爬虫，必须做好两件事：第一点是维护统一的采集 URL，第二点是对URL进行去重。简单说一下这两点。
　　将 URL 维护为 采集
　　多线程爬虫不能像单线程一样，每个线程独立维护自己的采集 URL，如果是这样的话，那么每个线程的网页采集都是一样的，你会不是多线程采集，而是要多次采集 一个页面。为此，我们需要将 URL 统一维护为 采集。每个线程从统一的URL维护处接收到采集 URL，完成采集任务。如果在页面上找到新 URL 链接将添加到统一 URL 维护的容器中。这里有几个适合统一 URL 维护的容器：
　　URL重复数据删除
　　URL去重也是多线程采集中的一个关键步骤，因为如果我们不去重，那么我们会采集到大量重复的URL，这并不能改善我们的采集 效率，例如在一个分页的新闻列表中，我们可以在 采集 的第一页获取到 2、3、4、5 个页面的链接，并且在采集的第二个页面上，当得到1、3、4、5个页面链接时，URL队列中会有大量列表页面链接被采集，会重复采集甚至进入死循环，所以需要进行URL去重。有很多方法可以对 URL 进行重复数据删除。以下是几种常用的URL去重方法：
　　关于多线程爬虫的两个核心知识点大家都知道。下面我画一个简单的多线程爬虫架构图，如下图所示：
　　
　　以上，我们主要了解了多线程爬虫的架构设计。接下来，我们不妨试试Java多线程爬虫。我们以采集虎扑新闻为例，实战Java多线程爬虫，在Java多线程爬虫中设计的URL为采集和URL为去重，由于这里只是演示，所以我们将使用JDK内置的容器来完成它。我们使用 LinkedBlockingQueue 作为 URL 维护容器为 采集，HashSet 作为 URL 到 Heavy 容器。以下是Java多线程爬虫的核心代码。详细代码可以上传到GitHub，地址在文末：
　　
　　
　　
　　
　　
　　我们用5个线程去采集虎扑新闻列表页面看看效果？运行程序会产生以下结果：
　　
　　从结果可以看出，我们启动了 5 个线程 采集 到 61 个页面，总共耗时 2 秒。可以说效果还是不错的。我们用单线程对比一下，看看差距有多大？我们将线程数设置为1，再次启动程序，得到如下结果：
　　
　　可以看到，单线程采集Hupu 61消息耗时7秒，几乎是多线程的4倍。如果你仔细想想，这只有 61 页。如果有更多的页面，差距会增加。该值越大，多线程爬虫的效率越高。
　　分布式爬虫架构
　　分布式爬虫架构是只有大型采集程序才需要使用的架构。一般可以使用单机多线程来解决业务需求。反正我没有分布式爬虫项目的经验，所以和这个没什么关系。是的，但作为技术人员，我们需要保持技术的热度。虽然我们不需要它，但理解它是可以的。我查了很多资料，得出以下结论：
　　分布式爬虫架构在思路上和我们的多线程爬虫架构是一样的。我们只需要在多线程的基础上稍加改进，就可以成为一个简单的分布式爬虫架构。由于在分布式爬虫架构中爬虫程序部署在不同的机器上，我们等待的URL采集和已经是采集的URL不能存储在爬虫程序机器的内存中，我们需要存储在某台机器上统一维护，比如存储在Redis或者MongoDB中，每台机器都从这里获取采集链接，而不是从LinkedBlockingQueue等内存队列中获取链接，比如一个简单的分发爬虫架构出现了。当然会有很多细节，因为我没有分布式架构的经验，也谈不上。如果您有兴趣，欢迎交流。
　　源代码：
　　https://github.com/BinaryBall/ ... .java
　　文章希望大家多多指导，共同学习，共同进步。
　　作者：平头哥的技术博文
来源：掘金
商业用途请与原作者联系，本文只做展示分享，不妥侵删！ 查看全部

　　java爬虫抓取动态网页(Python爬虫、数据分析、网站开发等案例教程视频免费在线观看
)
　　Python爬虫、数据分析、网站开发等案例教程视频在线免费观看
　　https://space.bilibili.com/523606542
　　Python学习交流群：。抓住目标：
　　百度NBA图片
　　
　　2.获取结果
　　
　　3.详细步骤分析
　　（1）分析是否是动态加载的关键是在滚动鼠标滚轮时观察XHR中的包是否发生了变化。如果这里的面包数量已经更新，那么页面很可能是动态请求，分析的百度图片是动态加载的。
　　
　　(2）找到动态加载的包后，我们分析包的请求，难点在于查询参数的分析。这里建议大家至少找两组关键字对比，找出两者的区别不同包中的关键字，看它的变化规律（那棵树偷偷提醒大家找一个叫pn的查询参数）整个动态其实是他一个人控制的，找到包后发出request请求，进行数据分析提取图片url就可以了（图片一定要写二进制！）
　　
　　4.完整源代码
　　本次爬取所需的工具包请求和 json
　　import requests as rq
import json
import time
import os
count = 1
def crawl(page):
global count
if not os.path.exists('E://桌面/NBA'):
os.mkdir('E://桌面/NBA')
url = 'https://image.baidu.com/search/acjson?'
header = {
# 'Referer': 'https://image.baidu.com/search/index?ct=201326592&cl=2&st=-1&lm=-1&nc=1&ie=utf-8&tn=baiduimage&ipn=r&rps=1&pv=&fm=rs4&word',
'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/89.0.4389.82 Safari/537.36'
}
param = {
"tn": "resultjson_com",
"logid": "11007362803069082764",
"ipn": "rj",
"ct": "201326592",
"is": "",
"fp": "result",
"queryWord": "NBA",
"cl": "2",
"lm": "-1",
"ie": "utf-8",
"oe": "utf-8",
"adpicid": "",
"st": "-1",
"z": "",
"ic": "",
"hd": "",
"latest": "",
"copyright": "",
"word": "NBA",
"s": "",
"se": "",
"tab": "",
"width": "",
"height": "",
"face": "0",
"istype": "2",
"qc": "",
"nc": "1",
"fr": "",
"expermode": "",
"force": "",
"pn": page,
"rn": "30",
"gsm": "1e",
"1615565977798": "",
}
response = rq.get(url, headers=header, params=param)
result = response.text
# print(response.status_code)
j = json.loads(result)
# print(j)
img_list = []
for i in j['data']:
if 'thumbURL' in i:
# print(i['thumbURL'])
img_list.append(i['thumbURL'])
# print(len(img_list))
for n in img_list:
r = rq.get(n, headers=header)
with open(f'E://桌面/NBA/{count}.jpg', 'wb') as f:
f.write(r.content)
count += 1
if __name__ == '__main__':
for i in range(30, 601, 30):
t1 = time.time()
crawl(i)
t2 = time.time()
t = t2 - t1
print('page {0} is over!!! 耗时{1:.2f}秒！'.format(i//30, t)) 查看全部

　　java爬虫抓取动态网页(一种爬虫获取动态网页源码的方式你get到了吗？)
　　今天给大家普及下爬虫获取动态网页源码的方法。
　　众所周知，如果爬虫请求静态网页，它可以直接获取该网页的源代码。但是如果请求的是动态网页，比如js加载等，那么直接请求是无法获取网页源代码的。
　　那么在这种情况下该怎么办呢？有些学生可能已经考虑过使用硒。Selenium 是一个模拟人为操作网页的神器，可以达到可见、可爬的效果。唯一的缺点是速度慢，消耗大量资源。如果整个过程都用硒来操作，会费时费力，那么有没有更好的办法呢？
　　如果我只是使用 selenimu 加载网页，在加载完网页并获取网页的源代码后，我会关闭 selenium 并使用 BeautifulSoup 来解析网页的内容。这可能吗？答案是肯定的，这种方法完美的实现了既可以获取网页的源代码，又可以避免整个过程中使用selenium。
　　接下来，我以漫画网站为例。我们想在下一页上获得第一部漫画的名称和链接。
　　
　　如果我们使用普通请求请求网站，流程如下：
　　import time
import requests
from bs4 import BeautifulSoup
import hashlib
from selenium import webdriver
import os
headers = {&#39;X-Requested-With&#39;: &#39;XMLHttpRequest&#39;,&#39;User-Agent&#39;:&#39;Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_3) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/80.0.3987.149 Safari/537.36&#39;}
url = &#39;http://manhua.dmzj.com/tags/se ... 39%3B
res = requests.get(url, headers=headers)
res = res.text
soup = BeautifulSoup(res, "html.parser")
a = soup.select(&#39;div.tcaricature_block.tcaricature_block2 ul>li:first-child a&#39;)[0]
title = a[&#39;title&#39;]
url2 = &#39;http:&#39; + a[&#39;href&#39;]
print(url2)
print(title)
　　结果如下：
　　
　　可见，漫画的名字和链接根本不是我们想要的。其实是因为它的网页是动态加载的，而我们请求的网页源代码不是我们想要的，所以出现定位错误。
　　接下来，我们使用 selenium 获取源代码进行试用。程序如下：
　　import time
import requests
from bs4 import BeautifulSoup
import hashlib
from selenium import webdriver
import os
path = "/usr/local/chromedriver"
driver = webdriver.Chrome(path)
headers = {&#39;X-Requested-With&#39;: &#39;XMLHttpRequest&#39;,&#39;User-Agent&#39;:&#39;Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_3) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/80.0.3987.149 Safari/537.36&#39;}
url = &#39;http://manhua.dmzj.com/tags/se ... 39%3B
driver.get(url)
time.sleep(3) #这是为了让网页能够完全加载出来
res = driver.page_source
driver.close()
soup = BeautifulSoup(res, "html.parser")
a = soup.select(&#39;div.tcaricature_block.tcaricature_block2 ul>li:first-child a&#39;)[0]
title = a[&#39;title&#39;]
url2 = &#39;http:&#39; + a[&#39;href&#39;]
print(url2)
print(title)
　　结果如下：
　　
　　可以看出我们得到了我们想要的漫画名和链接，因为用selenium得到的源码和我们在网页上看到的一样。
　　你有这种获取网页源代码的方法吗？ 查看全部

　　java爬虫抓取动态网页(网络爬虫(又被称为网页蜘蛛，网络机器人)蜘蛛)
　　网络爬虫
　　网络爬虫（也称为网络蜘蛛、网络机器人，在 FOAF 社区中，更常称为网络追逐者）是根据一定规则自动爬取万维网上信息的程序或脚本。
　　其他不太常用的名称是 ant、autoindex、emulator 或 worm。网络蜘蛛通过网页的链接地址搜索网页，从网站的某个页面（通常是首页）开始，阅读
　　网页的内容，找到网页中的其他链接地址，然后通过这些链接地址找到下一个网页，以此类推，直到这个网站的所有网页都被爬取完毕。如果整个
　　互联网被视为一个网站，那么网络蜘蛛就可以利用这个原理爬取互联网上的所有网页。因此，为了抓取网络上的数据，不仅需要爬虫，还需要
　　接收“爬虫”发送的数据并进行处理和过滤的服务器。爬虫爬取的数据量越大，对服务器的性能要求就越高。
　　1 重点介绍爬虫的工作原理及关键技术概述
　　网络爬虫是一种自动提取网页的程序。它为搜索引擎从万维网上下载网页，是搜索引擎的重要组成部分。传统爬虫从一个或多个初始网页的URL开始，获取初始网页的信息。
　　在抓取网页的过程中，不断地从当前页面中提取新的 URL 并放入队列中，直到满足系统的某些停止条件。焦点爬虫的工作流程比较复杂，需要根据某个网页进行分析
　　算法过滤掉主题链接，保留有用的链接并将它们放入等待抓取的 URL 队列中。然后，它会根据一定的搜索策略从队列中选择下一个要爬取的网页URL，重复上述操作
　　停止上述过程，直到达到系统的某个条件。此外，所有被爬虫爬取的网页都会被系统存储，经过一定的分析、过滤、索引，以供后续查询和检索；
　　对于焦爬虫来说，这个过程中得到的分析结果也可能对后续的爬取过程起到反馈和指导作用。
　　与通用网络爬虫相比，聚焦爬虫还需要解决三个主要问题：
　　(1) 获取目标的描述或定义；
　　(2) 网页或数据的分析和过滤；
　　(3) URL 的搜索策略。
　　分类
　　根据系统结构和实现技术，网络爬虫大致可以分为以下几种：通用网络爬虫、重点网络爬虫、
　　增量网络爬虫，深度网络爬虫。实际的网络爬虫系统通常是通过结合几种爬虫技术来实现的。
　　网络爬虫实现原理
　　根据这个原理，编写一个简单的网络爬虫程序，这个程序的作用是获取网站发回的数据，并提取其中的URL。我们将获取的 URL 存储在一个文件夹中。刚从网上
　　网站获取的URL进一步循环获取数据，提取其他数据。我不会在这里写。只是模拟最简单的原理。实际的网站爬虫远比这个复杂，深入的讨论太多了。
　　. 除了提取URL之外，我们还可以提取我们想要的各种其他信息，只要我们修改过滤数据的表达式即可。下面是一个Java模拟的提取新浪网页链接并存储的程序
　　在一个文件中
　　源代码如下
　　包 com.cellstrain.icell.util;
　　导入java.io.*；
　　进口 。*;
　　导入 java.util.regex.Matcher；
　　导入 java.util.regex.Pattern；
　　/**
　　* java实现爬虫
　　*/
　　公共类机器人{
　　公共静态无效主要（字符串[]参数）{
　　网址网址 = 空；
　　URLConnection urlconn = null;
　　BufferedReader br = null;
　　PrintWriter pw = null;
　　// 字符串正则表达式 = "http://[\\w+\\.?/?]+\\.[A-Za-z]+";
　　String regex = "https://[\\w+\\.?/?]+\\.[A-Za-z]+";//url匹配规则
　　模式 p = pile(regex);
　　尝试 {
　　url = new URL("");//爬取的URL，这里是一个生物网站
　　urlconn = url.openConnection();
　　pw = new PrintWriter(new FileWriter("D:/SiteURL.txt"), true);//把爬取的链接放到D盘的SiteURL文件中
　　br = 新 BufferedReader（新 InputStreamReader（
　　urlconn.getInputStream()));
　　字符串 buf = null;
　　while ((buf = br.readLine()) != null) {
　　匹配器 buf_m = p.matcher(buf);
　　而（buf_m.find（））{
　　pw.println(buf_m.group());
　　}
　　}
　　System.out.println("爬取成功^_^");
　　} 捕捉（MalformedURLException e）{
　　e.printStackTrace();
　　} 捕捉（IOException e）{
　　e.printStackTrace();
　　} 最后 {
　　尝试 {
　　br.close();
　　} 捕捉（IOException e）{
　　e.printStackTrace();
　　}
　　pw.close();
　　}
　　}}
　　运行idea的结果如下：
　　检查D盘是否有SiteURL.txt文件
　　已经成功生成SiteURL文件，打开就可以看到所有抓到的url 查看全部

　　java爬虫抓取动态网页(java爬虫抓取动态网页常见问题解决方案(一)_)
　　java爬虫抓取动态网页，都是基于scrapy等python框架的。用scrapy在百度、快手等平台抓取中，常见的错误是scrapy抓取不到所要的数据，这是什么原因呢？我们针对这个问题分析一下，再给大家一些建议。
　　一、问题分析
　　1、爬取过程中发现某些页面不能获取数据，采用requests要么无法获取，要么请求超时，或者返回乱码。我们采用mongodb数据库存储这些数据，可问题是，
　　2、抓取到的数据，部分数据是乱码，我们分析数据库，发现数据并不在scrapy框架，
　　3、没办法写入到mongodb数据库里，
　　4、有的爬取网站，则是抓取后直接返回数据库，有的爬取网站，需要定时读取下一页的数据，然后还要手动写入mongodb，这个地方和数据库同步，一旦采用这个方式，
　　1）我们使用正则表达式抓取需要抓取的页面；
　　2）我们定时扫描服务器的url，然后对需要抓取的页面写入数据库；正则表达式如下：defselect(self,request):assert(request.url.split("/")[1])assert(request.url.split("/")[1].replace(".","."))assert(request.url.split("/")[1].replace("/","."))assert(request.url.split("/")[1].replace("/","."))assert(request.url.split("/")[1].replace("/","."))assert(request.url.split("/")[1].replace(".","."))参考：查正则表达式获取百度信息常见问题解决方案：深入解析正则表达式、pythonparse_requests源码剖析。
　　-jiehaoqian_博客园
　　2、爬取失败原因是json格式数据，提取过程，更多涉及了自己解析和传递json对象、拼接字符串、切割json字符串、正则表达式匹配。那么scrapy框架解析json数据，是怎么通过反向工程，从服务器获取数据文件？解决方案：解析json数据，接收源码，解析json文件；解析过程，接收源码，解析json文件；。
　　3、爬取app_timestamp、temp_timestamp、history_timestamp的中间值？前两者取值不同，为什么结果是不同的呢？因为temp_timestamp比history_timestamp大3.4m，网站服务器限制大小。
　　解决方案：
　　1、针对爬取过程，默认使用history_timestamp，当有大量json时，对存量数据也是一个巨大的浪费，可以封装一个循环存储，大存储数据时， 查看全部

　　java爬虫抓取动态网页(Java垂直爬虫框架（一）——webmagic)
　　webmagic 是一个开源的 Java 垂直爬虫框架。其目标是简化爬虫的开发过程，让开发者专注于逻辑功能的开发。webmagic的核心很简单，但是涵盖了爬虫的全过程，也是学习爬虫开发的好资料。
　　网络爬虫是一种技术，webmagic致力于降低这项技术的实现成本，但出于对资源提供者的尊重，webmagic不会做防阻塞的事情，包括：验证码破解、代理切换、自动登录等...
　　作者黄宜华（）曾在原公司从事垂直履带开发工作一年。Webmagic 是为解决爬虫开发的一些重复性工作而生成的框架。
　　webmagic的架构和设计参考了以下两个项目，感谢以下两个项目的作者：
　　python爬虫scrapy
　　Java爬虫蜘蛛侠
　　webmagic 遵循 Apache 2.0 协议，您可以自由使用和修改它。如果您有任何不便或问题，欢迎您在 github 上提交问题，或在 oschina 讨论模块中提问。
　　使用maven下载安装
　　webmagic 使用 maven 来管理依赖，你可以通过在项目中添加相应的依赖来使用 webmagic：
　　
us.codecraft
webmagic-core
0.4.2


us.codecraft
webmagic-extension
0.4.2

　　项目结构
　　webmagic主要包括两个包：
　　webmagic 还包括两个可用的扩展包。因为这两个包依赖于比较重量级的工具，所以是从主包中提取出来的。这些包需要在源码之后自行下载编译：
　　在您的项目中，您可以根据需要依赖不同的包。
　　不使用maven
　　不使用maven的用户可以下载带有二进制jar包的版本（感谢oschina）：
　　 git clone http://git.oschina.net/flashsword20/webmagic.git
　　在 bin/lib 目录下，可以在 IDE 中直接导入项目所依赖的所有 jar 包。
　　第一个爬虫自定义PageProcessor
　　PageProcessor 是 webmagic-core 的一部分，您可以通过自定义 PageProcessor 来实现自己的爬虫逻辑。下面是一段爬取 osc 博客的代码：
　　 public class OschinaBlogPageProcesser implements PageProcessor {
private Site site = Site.me().setDomain("my.oschina.net")
.addStartUrl("http://my.oschina.net/flashsword/blog");
@Override
public void process(Page page) {
List links = page.getHtml().links().regex("http://my\\.oschina\\.net/flashsword/blog/\\d+").all();
page.addTargetRequests(links);
page.putField("title", page.getHtml().xpath("//div[@class='BlogEntity']/div[@class='BlogTitle']/h1").toString());
page.putField("content", page.getHtml().$("div.content").toString());
page.putField("tags",page.getHtml().xpath("//div[@class='BlogTags']/a/text()").all());
}
@Override
public Site getSite() {
return site;
}
public static void main(String[] args) {
Spider.create(new OschinaBlogPageProcesser())
.pipeline(new ConsolePipeline()).run();
}
}
　　这里要爬取的URL是通过page.addTargetRequests()方法添加的，提取结果通过page.putField()保存。page.getHtml().xpath() 按照一定的规则提取结果，提取支持链式调用。调用后，toString() 表示转换为单个 String，all() 表示将其转换为 String 列表。
　　Spider 是爬虫的入口类。Pipeline 是结果输出和持久化的接口，其中 ConsolePipeline 表示将结果输出到控制台。
　　执行这个main方法，可以在控制台看到抓取结果。默认情况下，webmagic 的抓取间隔为 3 秒，请耐心等待。您可以使用 site.setSleepTime(int) 修改此值。该站点还具有一些用于修改爬网属性的方法。
　　使用注释
　　webmagic-extension 包括通过注解编写爬虫的方法。只需要基于POJO添加注解即可完成爬虫。下面依然是一段抓取oschina博客的代码，功能和OschinaBlogPageProcesser完全一样：
　　 @TargetUrl("http://my.oschina.net/flashsword/blog/\\d+")
public class OschinaBlog {
@ExtractBy("//title")
private String title;
@ExtractBy(value = "div.BlogContent",type = ExtractBy.Type.Css)
private String content;
@ExtractBy(value = "//div[@class='BlogTags']/a/text()", multi = true)
private List tags;
@Formatter("yyyy-MM-dd HH:mm")
@ExtractBy("//div[@class='BlogStat']/regex('\\d+-\\d+-\\d+\\s+\\d+:\\d+')")
private Date date;
public static void main(String[] args) {
OOSpider.create(
Site.me().addStartUrl("http://my.oschina.net/flashsword/blog"),
new ConsolePageModelPipeline(), OschinaBlog.class).run();
}
}
　　本例定义了一个Model类，Model类的“title”、“content”、“tags”字段都是要提取的属性。这个类在 Pipeline 中是可重用的。
　　有关如何使用注释的详细信息，请参阅下面的 webmagic-extension 注释模块。
　　模块详情 webmagic-core
　　webmagic-core是爬虫的核心框架，只收录了爬虫各个功能模块的核心功能。webmagic-core 的目标是成为网络爬虫的教科书实现。
　　本节部分内容摘自作者的博文 Webmagic Design Mechanism and Principle - How to Develop a Java Crawler。
　　webmagic-core的模块划分
　　webmagic-core指scrapy的模块划分，分为Spider（整个爬虫的调度框架）、Downloader（页面下载）、PageProcessor（链接提取和页面分析）、Scheduler（URL管理）、Pipeline（离线分析和持久化） ) 几个部分。只是scrapy是通过中间件扩展的，而webmagic是通过定义这些接口，将它们不同的实现注入到主框架类Spider中来扩展的。
　　
　　蜘蛛类（核心调度）
　　Spider是爬虫的入口类。爬虫的接口调用采用链式API设计，其他所有功能都通过接口注入到爬虫中。以下是启动更复杂爬虫的示例。
　　 Spider.create(sinaBlogProcessor)
.scheduler(new FileCacheQueueScheduler("/data/temp/webmagic/cache/"))
.pipeline(new FilePipeline())
.thread(10).run();
　　Spider的核心处理流程非常简单，代码如下：
　　 private void processRequest(Request request) {
Page page = downloader.download(request, this);
if (page == null) {
sleep(site.getSleepTime());
return;
}
pageProcessor.process(page);
addRequest(page);
for (Pipeline pipeline : pipelines) {
pipeline.process(page, this);
}
sleep(site.getSleepTime());
}
　　Spider还包括一个方法test(String url)，只爬取单个页面，用于测试提取效果。
　　PageProcessor（页面分析和链接提取）
　　页面分析是垂直爬虫中需要定制的部分。在 webmagic-core 中，通过实现 PageProcessor 接口来实现自定义爬虫。PageProcessor 有两个核心方法：public void process(Page page) 和 public Site getSite()。
　　Selector 是 webmagic 为简化页面提取和开发而开发的一个独立模块，是 webmagic-core 的主要关注点。它集成了 CSS Selector、XPath 和正则表达式，并且可以进行链式提取。
　　 //content是用别的爬虫工具抽取到的正文
List links = page.getHtml()
.$("div.title") //css 选择，Java里虽然很少有$符号出现，不过貌似$作为方法名是合法的
.xpath("//@href") //提取链接
.regex(".*blog.*") //正则匹配过滤
.all(); //转换为string列表
　　webmagic 收录一个 SmartContentSelector 类，它会自动提取页面的正文。相信 Evernote Clearly 会对它的自动文本提取技术印象深刻。这项技术也称为可读性。当然，webmagic 对 Readability 的实现还是比较粗糙的，但是还是有一些学习价值的。
　　webmagic的XPath解析使用了作者的另一个开源项目：Xsoup，一个基于Jsoup的XPath解析器。Xsoup 扩展了 XPath 的语法并支持一些自定义函数。这些函数通过在 XPath 末尾添加 /name-of-function() 来使用，例如："//div[@class='BlogStat']/regex('\\d+-\\d+-\\ d+ \\s+\\d+:\\d+')"。
　　功能
　　阐明
　　文本（n）
　　第 n 个文本节点（0 表示全取）
　　全部文本（）
　　所有文本，包括子节点
　　整洁的文本（）
　　使用智能换行收录子节点的所有文本
　　html()
　　内部 html（不包括当前标签本身）
　　外部HTML()
　　外部 html（包括当前标签本身）
　　正则表达式（@attr，expr，组）
　　正则表达式，@attr为提取属性（可省略），expr为表达式内容，group为捕获组（可省略，默认为0)
　　基于 Saxon，webmagic 提供对 XPath2.0 语法的支持。XPath2.0 语法支持内部函数、逻辑控制等，是一门完整的语言。如果你熟悉 XPath2.0 语法，不妨一试（需要引入 webmagic-saxon 包）。
　　webmagic-samples 包有一些为站点定制的 PageProcessor 用于学习目的。
　　下载器（页面下载）
　　Downloader 是 webmagic 中下载页面的接口。主要方法有：
　　Downloader 目前有几种实现方式：
　　调度程序（URL 管理）
　　调度器是webmagic的管理模块。您可以通过实施调度程序自定义您自己的 URL 管理器。调度器主要包括两个方法：
　　webmagic 目前有调度器的三种实现：
　　管道（后续处理和持久化）
　　Pipeline 是输出和持久化最终提取结果的接口。它只包括一种方法：
　　webmagic 收录以下 Pipeline 的实现：
　　webmagic 目前不支持持久化到数据库，但是结合其他工具，持久化到数据库很容易。这里，我们来看一段webmagic结合JFinal持久化到数据库的代码。因为 JFinal 目前不支持 maven，所以这段代码没有放在 webmagic-samples 中。
　　webmagic 扩展
　　webmagic-extension是为了方便开发爬虫而实现的一些功能模块。这些功能完全基于webmagic-core框架，包括编写爬虫、分页、以注解形式分发等功能。
　　注释模块
　　webmagic-extension 收录注释模块。为什么会有注释？
　　因为 PageProcessor 的方式灵活而强大，它并没有解决两个问题：
　　注解的核心是Model类，它本身就是一个POJO。这个 Model 类用于传递和保存页面，最后获取结果数据。注解方式直接将提取和数据绑定，方便编写和维护。
　　注解方法其实是通过一个PageProcessor--ModelPageProcessor的实现来完成的，所以对webmagic-core代码没有影响。还是以抓取OschinaBlog的程序为例：
　　 @TargetUrl("http://my.oschina.net/flashsword/blog/\\d+")
public class OschinaBlog {
@ExtractBy("//title")
private String title;
@ExtractBy(value = "div.BlogContent",type = ExtractBy.Type.Css)
private String content;
@ExtractBy(value = "//div[@class='BlogTags']/a/text()", multi = true)
private List tags;
@Formatter("yyyy-MM-dd HH:mm")
@ExtractBy("//div[@class='BlogStat']/regex('\\d+-\\d+-\\d+\\s+\\d+:\\d+')")
private Date date;
public static void main(String[] args) {
OOSpider.create(
Site.me().addStartUrl("http://my.oschina.net/flashsword/blog"),
new ConsolePageModelPipeline(), OschinaBlog.class).run();
}
}
　　注释部分包括以下内容：
　　类型转换
　　webmagic的注解方式支持提取结果的类型转换，使得提取结果不需要是String类型，可以是任意类型。webmagic 内置了对基本类型的支持（需要保证提取结果可以转换为对应的类型）。
　　 @ExtractBy("//ul[@class='pagehead-actions']/li[1]//a[@class='social-count js-social-count']/text()")
private int star;
　　提取结果也可以是 java.util.Date 类型，但您需要指定日期的格式：
　　 @Formatter("yyyy-MM-dd HH:mm")
@ExtractBy("//div[@class='BlogStat']/regex('\\d+-\\d+-\\d+\\s+\\d+:\\d+')")
private Date date;
　　您还可以编写一个实现 ObjectFormatter 接口的类来执行您自己的类型解析。要使用您自己的类，您需要调用 ObjectFormatters.put() 来注册该类。
　　 OOSpider.create(
Site.me().addStartUrl("http://www.oschina.net"),
new ConsolePageModelPipeline(),
OschinaBlog.clas,OschinaAnswer.class).run();
　　 OOSpider会根据TargetUrl调用不同的Model进行解析。
　　分散式
　　在 webmagic-extension 中，通过 redis 管理 URL 以达到分布式的效果。但是对于分布式爬虫来说，只有程序可以分布式运行，不能满足大规模爬取的需要。Webmagic 以后可能会添加一些任务管理和监控功能。也欢迎用户提交代码并为 webmagic 做出贡献。 查看全部

　　java爬虫抓取动态网页(一个完整的网络爬虫基础框架如下图所示：整个架构)
　　一个完整的网络爬虫基础框架如下图所示：
　　整个架构由以下过程组成：
　　1）需求方提供需要爬取的种子URL列表，根据提供的URL列表和对应的优先级（先到先得）建立待爬取URL队列；
　　2）根据要爬取的URL队列的排序，爬取网页；
　　3）将获取到的网页内容和信息下载到本地网络库，并构建爬取的URL列表（用于去重和判断爬取过程）；
　　4）将爬取的网页放入待爬取的URL队列中，进行循环爬取操作；
　　2. 网络爬虫爬取策略
　　在爬虫系统中，待爬取的 URL 队列是一个重要的部分。待爬取URL队列中的URL排列顺序也是一个很重要的问题，因为它涉及到先爬到哪个页面，再爬到哪个页面的问题。确定这些 URL 排列顺序的方法称为爬取策略。下面重点介绍几种常见的爬取策略：
　　1）深度优先遍历策略
　　深度优先遍历策略很好理解，和我们有向图中的深度优先遍历一样，因为网络本身就是一个图模型。深度优先遍历的思想是从一个起始网页开始爬取，然后根据链接一个接一个地爬取，直到不能再进一步爬取，然后返回上一页继续跟随关联。
　　有向图中的深度优先搜索示例如下所示：
　　上图左图是有向图的示意图，右图是深度优先遍历的搜索过程示意图。深度优先遍历的结果是：
　　2）广度优先搜索策略
　　广度优先搜索和深度优先搜索的工作方式完全相反。这个想法是将在新下载的网页中找到的链接直接插入到要抓取的 URL 队列的末尾。也就是说，网络爬虫会先爬取起始网页链接的所有网页，然后选择其中一个链接的网页，继续爬取该网页链接的所有网页。
　　上图是上例有向图的广度优先搜索流程图，其遍历结果为：
　　v1→v2→v3→v4→v5→v6→v7→v8
　　从树的结构来看，图的广度优先遍历就是树的层次遍历。
　　3）反向链接搜索策略
　　反向链接数是指从其他网页指向一个网页的链接数。反向链接的数量表示网页内容被他人推荐的程度。因此，在很多情况下，搜索引擎的爬取系统会使用这个指标来评估网页的重要性，从而确定不同网页的爬取顺序。
　　在真实的网络环境中，由于广告链接和作弊链接的存在，反向链接的数量并不能完全等同于他人的重要性。因此，搜索引擎倾向于考虑一些可靠的反向链接计数。
　　4）大网站优先策略
　　所有待爬取的URL队列中的网页都按照它们所属的网站进行分类。网站需要下载的页面较多，请先下载。这种策略也称为大站点优先策略。
　　5）其他搜索策略
　　一些比较常用的爬虫搜索侧率还包括Partial PageRank搜索策略（根据PageRank分数确定下一个抓取的URL），OPIC搜索策略（也是一种重要性）。最后必须指出的一点是，我们可以根据自己的需要来设置网页的抓取间隔，这样可以保证我们一些基本的大网站或者活跃的网站内容不会被漏掉。
　　3. 网络爬虫更新策略
　　互联网实时变化并且非常动态。网页更新策略主要决定何时更新之前已经下载的页面。常见的更新策略有以下三种：
　　1）历史参考政策
　　顾名思义，它根据页面过去的历史更新数据来预测未来页面何时会发生变化。通常，预测是通过泊松过程建模来进行的。
　　2）用户体验策略
　　尽管搜索引擎可以为某个查询返回大量结果，但用户通常只关注结果的前几页。因此，爬虫系统可以优先更新那些实际在查询结果前几页的页面，然后再更新后面的那些页面。这个更新策略也需要用到历史信息。UX 策略保留网页的多个历史版本，并根据每个过去内容更改对搜索质量的影响得出一个平均值，并以此值作为决定何时重新抓取的基础。
　　3）集群抽样策略
　　上面提到的两种更新策略都有一个前提：需要网页的历史信息。这种方式存在两个问题：第一，如果系统为每个系统保存多个版本的历史信息，无疑会增加很多系统负担；第二，如果新网页完全没有历史信息，就无法确定更新策略。
　　该策略认为网页具有许多属性，具有相似属性的网页可以认为具有相似的更新频率。计算某一类别网页的更新频率，只需对该类别的网页进行采样，并将其更新周期作为整个类别的更新周期。基本思路如下：
　　4. 分布式抓取系统结构
　　一般来说，爬虫系统需要处理整个互联网上数以亿计的网页。单个爬虫不可能完成这样的任务。通常需要多个爬虫程序一起处理它们。一般来说，爬虫系统往往是分布式的三层结构。如图所示：
　　最底层是分布在不同地理位置的数据中心。每个数据中心有多个爬虫服务器，每个爬虫服务器可能部署多套爬虫程序。这样就构成了一个基本的分布式爬虫系统。
　　对于数据中心中的不同服务器，有几种方法可以协同工作：
　　1）主从
　　主从基本结构如图：
　　对于主从类型，有一个专门的主服务器来维护要爬取的URL队列，负责每次将URL分发给不同的从服务器，从服务器负责实际的网页下载工作。Master服务器除了维护要爬取的URL队列和分发URL外，还负责调解每个Slave服务器的负载。为了避免一些从服务器过于空闲或过度工作。
　　在这种模式下，Master往往会成为系统的瓶颈。
　　2）点对点
　　等价的基本结构如图所示：
　　在这种模式下，所有爬虫服务器之间的分工没有区别。每个爬取服务器可以从待爬取的URL队列中获取URL，然后计算该URL主域名的哈希值H，进而计算H mod m（其中m为服务器数量，上图为例如，m 对于 3），计算出的数字是处理 URL 的主机号。
　　例子：假设对于URL，计算器hash值H=8，m=3，那么H mod m=2，那么编号为2的服务器会抓取该链接。假设此时服务器 0 获取了 URL，它会将 URL 传输到服务器 2，服务器 2 将获取它。
　　这种模式有一个问题，当一个服务器死掉或添加一个新服务器时，所有 URL 的哈希余数的结果都会改变。也就是说，这种方法不能很好地扩展。针对这种情况，提出了另一种改进方案。这种改进的方案是一致的散列以确定服务器划​​分。其基本结构如图所示：
　　一致散列对 URL 的主域名进行散列，并将其映射到 0-232 范围内的数字。这个范围平均分配给m台服务器，根据主URL域名的hash运算值的范围来确定要爬取哪个服务器。
　　如果某台服务器出现问题，本应负责该服务器的网页将由下一个服务器顺时针获取。在这种情况下，即使一台服务器出现问题，也不会影响其他工作。
　　5. 参考资料
　　[1] wawlian：网络爬虫基本原理(一)(二);
　　[2] guisu：搜索引擎——网络爬虫；
　　[3]《这就是搜索引擎：核心技术详解》。 查看全部

　　java爬虫抓取动态网页(爬虫原理就是向目标URL发送请求然后把响应解析成我们想要的)
　　说到爬虫，它并没有你想象的那么复杂。原理是向目标 URL 发送请求，然后将响应解析为我们想要的数据格式。如果涉及到Token认证，那就更复杂了。这次只讲解最简单的入门级静态爬虫。.
　　在node.js中实现爬虫推荐两个库request和cheerio
　　npm install request
npm install cheerio
　　request 用于发送请求；Cheerio 是对 jquery 核心功能的快速、简洁、灵活的实现，可以直接对请求请求返回的页面 html 进行 jquery 风格的 DOM 操作。
　　(一）dom 爬取
　　以下是爬虫的最简单示例。我们爬取了我在简书首页的用户名。
　　打开要爬取的页面，找到用户名的dom节点
　　
　　按照jquery选择器的写法，应该是$('.main-top&gt;.title&gt;a').text()
　　附代码
　　const request = require(&#39;request&#39;)
const cheerio = require(&#39;cheerio&#39;)
request(&#39;https://www.jianshu.com/u/5b23cf5114a1&#39;, (err, res) => {
if (err) {
console.log(err.code)
}
else {
let $ = cheerio.load(res.body)
console.log($(&#39;.main-top>.title>a&#39;).text())
}
})
　　
　　(二）列表爬取
　　如果要爬一个列表，比如我的短书Blog列表，怎么做？同理，使用jquery的each方法，会遍历选择器中匹配的dom。按照同样的步骤先找到dom节点，然后解析。
　　附上参考代码
　　const request = require(&#39;request&#39;)
const cheerio = require(&#39;cheerio&#39;)
request(&#39;https://www.jianshu.com/u/5b23cf5114a1&#39;, (err, res) => {
if (err) {
console.log(err.code)
}
else {
let $ = cheerio.load(res.body)
let data = []
$(&#39;.note-list>li&#39;).each(function (i) {
data.push($(this).find(&#39;.title&#39;).text());
});
console.log(data)
}
})
　　
　　静态爬虫到此结束，动态网页的爬取将在后面讲解。 查看全部

　　java爬虫抓取动态网页(不是学Python的人员才能做的么？我们Java能做呢？)
　　由于阿凡经历了上一次大数据杀戮事件，可见目前的平台对用户非常不友好。只要您经常搜索某些 关键词，它通常更具对比性。我在最高峰直接买，就像买股票一样，总觉得每次都能买到底部，却不知道是在天台买的。于是阿芬想了个办法，把所有的数据都拉下来，自己对比了一下，就停止了搜索。省级平台总是根据我的搜索内容推荐。
　　
　　如何用Java做爬虫
　　说到爬虫，大家肯定想说，爬虫，这难道不是只有学过Python的人才能做到的吗？我们可以在 Java 中做什么？阿凡想告诉大家的是，是的，Java语言已经存在这么多年了，怎么可能没有这样的内容，于是阿凡开始学习Java的爬虫之路。
　　汤
　　在介绍这门课之前，阿凡必须先说说我们平时看到的内容是由什么组成的。现在举个例子，我们都知道，我们在做开发的时候，至少我们在电脑上访问某东某某宝的数据时，他们给我们反馈的数据是通过HTML展示出来的，例如：
　　
　　参与开发的每个人都必须知道这些是什么意思。这里就不做详细介绍了，说一下这个HTML是什么。阿凡需要介绍的是Jsoup，然后告诉大家怎么用。Jsoup 这个类爬取京东的数据。
　　正如官方文档向我们建议的那样，如何解析一段 HTML 代码：
　　String html = "First parse"
+ "<p>Parsed HTML into a doc.";

Document doc = Jsoup.parse(html);
</p>
　　这个文件是什么？我们可以看看输出，看看源代码解释。毕竟，如果一个开发人员看不到这个类的用途，他就不是一个合格的程序员。
　　输出：
　　

First parse


<p>Parsed HTML into a doc.

</p>
　　其实这里可以看出，Document其实是为我们输出了一个新的文档，并且是排序好的，相当于为后续的HTML分析做专业的准备。
　　
　　当我们看源码的注释时，不难看出Jsoup不仅可以解析我们给的字符串，还可以解析URL或者文件。
　　它将我们给他的HTML字符串转换成一个对象，也就是我们上面看到的Document，然后我们就可以顺利的使用Document对象中的元素了。
　　上面是解析字符串，那我们看看是否存在下面的解析URL：
　　 public static void main(String[] args) {
try {
Document doc = Jsoup.connect("https://www.jd.com/%3Fcu%3Dtru ... 6quot;).get();
String title = doc.title();
System.out.println(title);
}catch (IOException e){
e.printStackTrace();
}
}

　　如果你执行以下，你就能看到标题是什么，结果是这样的：
　　
　　是不是和我们在百度上搜索的时候不一样，因为这是进入后的首页。
　　元素
　　我们看源码可以清楚的看到Document是继承了Element的类，所以一定可以调用Element中的方法，例如：
　　getElementById(String id); //是不是有点眼熟，像不像Js里面的ID选择器
getElementsByTag(String tagName)；// 通过标签来选择
getAllElements()；//获取所有的Element的元素
　　至于方法，阿凡就不一一描述了。有兴趣的可以去官方文档，或者去源码，把包名发到包org.jsoup.nodes
　　有些人一定是生气了。如果你说阿芬，就不要介绍了。那你废话太多了。快速介绍一下京东。好的，让我们开始吧。
　　爬取之前一定要分析一下京东的网站，比如我搜索硬盘：
　　
　　下面是一堆数据，我们需要解析的是HTML中最有用的部分，比如：
　　

￥879.00

　　这里我们写下价格，然后我们寻找我们想要的名字
　　
　　看，p-name就是我们需要的名字，然后我们就可以写代码了。
　　 //这是京东的搜索网址，我们把这个keyword关键词提取出来，注意中英文，中文要处理一下
String url = "https://search.jd.com/Search?keyword=" + keyword;
url = url + "&enc=utf-8";
Document document = Jsoup.parse(new URL(url), 40000);

//我们先找这个 List，然后一层一层的遍历
Element element = document.getElementById("J_goodsList");
Elements elements = element.getElementsByTag("li");
for (Element el : elements) {
String img = el.getElementsByTag("img").eq(0).attr("source-data-lazy-img");
String price = el.getElementsByClass("p-price").eq(0).text();
String title = el.getElementsByClass("p-name").eq(0).text();
String shop = el.getElementsByClass("p-shop").eq(0).text();
System.out.println("=========================");
System.out.println("标题:" + title);
System.out.println("图片url:" + img);
System.out.println("店铺:" + shop);
System.out.println("价格:" + price);
}
　　我们看一下实现的效果图：
　　
　　如果还有兴趣，可以直接在for循环中新建一个对象，得到一个List集合，然后在最后执行插入数据库的方法，这样数据就可以完整保存了。毛呢布？ 查看全部

　　java爬虫抓取动态网页(如何解析并抓取网页上的信息呢？-八维教育)
　　对于静态网页的解析，我们一般使用Jsoup。
　　但是对于动态加载的网页，Jsoup 就不行了！
　　那么我们如何解析和抓取网络上的信息呢？
　　看了网上朋友的讨论，打算模拟一个浏览器，然后通过操作浏览器获取新的网页信息。
　　最后我选择了 Selenium 来模拟浏览器。
　　事实上，Selenium 是一个测试浏览器性能的工具，这对于爬虫来说有点矫枉过正！
　　Selenium官网地址：
　　产科selenium的安装和使用可以去官网
　　我们一般使用 Selenium RC 工具包来操作浏览器。
　　安装完包后，我们举个小例子：
　　package com.example.tests;
// We specify the package of our tests
import com.thoughtworks.selenium.*;
// This is the driver&#39;s import. You&#39;ll use this for instantiating a
// browser and making it do what you need.
import java.util.regex.Pattern;
// Selenium-IDE add the Pattern module because it&#39;s sometimes used for
// regex validations. You can remove the module if it&#39;s not used in your
// script.
public class NewTest extends SeleneseTestCase {
// We create our Selenium test case
public void setUp() throws Exception {
setUp("http://www.google.com/", "*firefox");
// We instantiate and start the browser
}
public void testNew() throws Exception {
selenium.open("/");
selenium.type("q", "selenium rc");
selenium.click("btnG");
selenium.waitForPageToLoad("30000");
assertTrue(selenium.isTextPresent("Results * for selenium rc"));
// These are the real test steps
}
}
　　这是使用的类。
　　我们可以编写一个主程序如下：
　　package Test1;
import java.net.UnknownHostException;
import com.mongodb.BasicDBObject;
import com.thoughtworks.selenium.*;
//This is the driver&#39;s import. You&#39;ll use this for instantiating a
//browser and making it do what you need.
import org.jsoup.Jsoup;
import org.jsoup.helper.Validate;
import org.jsoup.nodes.Document;
import org.jsoup.nodes.Element;
import org.jsoup.select.Elements;
import java.util.LinkedList;
import java.util.Queue;
import java.util.regex.Pattern;
//Selenium-IDE add the Pattern module because it&#39;s sometimes used for
//regex validations. You can remove the module if it&#39;s not used in your
//script.
@SuppressWarnings("deprecation")
public class NewTest extends SeleneseTestCase {
//We create our Selenium test case
public String url;
public void setUp() throws Exception {
setUp("https://foursquare.com/v/singa ... ot%3B, "*chrome");
//selenium.waitForPageToLoad("30000");
// We instantiate and start the browser
}
public void testNew() throws Exception {

selenium.open("https://foursquare.com/v/singa ... 6quot;);
selenium.windowMaximize();
public static void print(String msg, Object... args) {
System.out.println(String.format(msg, args));
}
public static void gettips(Document doc){

Elements tips = doc.select(".tipText");
int count = 0;
//BasicDBObject document4 = new BasicDBObject();
for (Element link : tips){

String str2 = new String(link.text());
count++;
String tempint = String.valueOf(count);
//document4.put(tempint, str);
print("%s \r\n", str2);
}
}
}
　　运行后，程序会打开firefox浏览器，然后它会自动为他运行你的设计。 查看全部

　　java爬虫抓取动态网页(java爬虫抓取动态网页-java快速安装有一次我去的时候)
　　java爬虫抓取动态网页-java快速安装
　　有一次我去某地的时候，发现一个银行的网站可以爬。于是我下了一个特定版本的chrome和firefox。
　　谢邀！jsp是用不上了，本地的html页面可以尝试用xampp作ftp服务器。至于爬虫用java做爬虫太难了，还不如学c++。
　　对于我们这种闲人，比较好学的方法是买个linux发行版，安装jdk，然后就是刷题库做题，学学python。熟悉了解一下人家的网站运作方式，
　　这问题水平真是那啥，怎么能把语言换了个基础就叫水平好了。前端稍微看一下顶个半吊子没问题了，后端就把你的思路整理整理，看看人家的开发路线，
　　试试看写个会员中心系统，我们学校五年制在这边做过实验，
　　路还很长...虽然java很火，但基础上,ui技术还有其他组件和框架是必须掌握的。java能做的事也不少。
　　零基础学python，如果不喜欢，
　　目前做过一套网站，可以把楼主要的功能都考虑进去，和我零基础学python刚学差不多，但是比python大学生学习曲线还是低多了， 查看全部

　　java爬虫抓取动态网页(Python爬虫实战入门五：获取JS动态内容—爬取今日头条)
　　不管你是失业还是失业，在这个被互联网包围的时代，如果选择python动态爬虫，你就会多一技能，还怕找不到工作？，怕找不到工作？小编会告诉你这个专业的优势在哪里： Python爬虫实战入门五：获取JS动态内容——抓取今日头条，python爬虫入门实战（四)！爬取动态加载页面！，超棒！A Python爬虫学习的完整路线推荐？？
　　1.Python爬虫实战入门五：获取JS动态内容——抢今日头条
　　我们之前爬取的大部分网页都是从 HTML 静态生成的内容，而我们看到的数据和内容可以直接从 HTML 源代码中找到。然而，并不是所有的网页都是这样的。网站的部分内容是由前端JS动态生成的。由于网页上显示的内容是JS生成的，所以我们在浏览器上可以看到，但是在HTML源代码中是找不到的。比如今日头条：浏览器呈现的网页是这样的：查看源码，但是是这样的：在HTML源码中找不到网页的新闻，都是动态生成加载的由 JS。在这种情况下，我们应该如何抓取网页呢？有两种方法：1、从网页响应中查找JS脚本返回的JSON数据；2、 使用 Selenium 模拟对网页的访问。这里只介绍第一种方法。关于 Selenium 的使用，后面有一个专门的。一、从网页响应中找到JS脚本返回的JSON数据即使网页内容是JS动态生成加载的，JS也需要调用一个接口，然后根据返回的JSON数据加载渲染通过界面。所以我们可以找到JS调用的数据接口，从数据接口中找到网页中最后渲染的数据。以今日头条为例进行演示：1、打开网页调试工具，在找到JS请求的数据界面F12中选择“网络”选项卡，发现有很多响应。让我们过滤并仅查看 XHR 响应。
　　现在你大概明白如何找到 JS 请求的接口了吧？但是我们刚才没有找到我们想要的新闻，我们再找一下：有一个焦点，我们点一下看看：首页图片新闻呈现的数据是一样的，所以数据应该有. 查看其他链接：这应该是热搜关键词这是图片新闻下的新闻。我们打开一个接口链接看看：coding:utf-8import requestsimport jsonurl = 'wbdata = requests.get(url).textdata = json.loads(wbdata)news = data['data']['pc_feed_focus']for n in news:title = n['title']img_url = n['image_url']url = n['media_url']print(url,title,img_url) 返回结果如下： 按照惯例，稍微解释一下代码：代码分为四部分，第一部分：相关库的介绍# 编码：utf-8import requestsimport json 第二部分：http请求到数据接口 url = 'wbdata = requests.get(url).text 第三部分：HTTP响应的数据JSONize和index到新闻数据的位置 data = json.loads(wbdata)news = data['data']['pc_feed_focus']第四部分：遍历并提取news中n的索引JSON数据：title = n['title'] img_url = n['image_url']url = n['media_url']print(url,title, img_url) 完成从JS网页抓取数据。==============================微信公众号：周先生第一次个人发布网站：同步更新 get(url).text 第三部分：将HTTP响应的数据JSONize并索引到新闻数据的位置 data = json.loads(wbdata)news = data['data']['pc_feed_focus']第四部分：遍历并提取news中n的索引JSON数据： title = n['title']img_url = n['image_url']url = n['media_url']print(url,title, img_url) 完成数据的爬取JS 网页。==============================微信公众号：周先生第一次个人发布网站：同步更新 get(url).text 第三部分：将HTTP响应的数据JSONize并索引到新闻数据的位置 data = json.loads(wbdata)news = data['data']['pc_feed_focus']第四部分：遍历并提取news中n的索引JSON数据： title = n['title']img_url = n['image_url']url = n['media_url']print(url,title, img_url) 完成数据的爬取JS 网页。==============================微信公众号：周先生第一次个人发布网站：同步更新 media_url']print(url,title,img_url) 完成从JS网页抓取数据。==============================微信公众号：周先生第一次个人发布网站：同步更新 media_url']print(url,title,img_url) 完成从JS网页抓取数据。==============================微信公众号：周先生第一次个人发布网站：同步更新
　　2.python爬虫实战介绍（四)！爬取动态加载的页面！
　　今天的主题是分享爬取动态网页的经验，以cocos论坛为例进行分享。（官方不会打我）为什么配置环境选择cocos论坛？因为我在浏览论坛的时候发现标题内容会随着滚动条的位置动态添加。环境：python3 + 请求。还介绍了几个系统库。参考如下： import requests import json import csv from .dummy import Pool 分析网页以chrome浏览器为例，在空白处右键-&gt;勾选进入网页分析模式，在Network中选择XHR，滚动向下滚动条，观察右边加载了什么文件。在网页分享模式下，点击刚刚下载的文件即可查看内容，并发现GET方法是用于一个地址，传入页码的参数。看返回的内容是一个json字符串。这个 json 字符串有我们想要的内容。下面我们来看看如何使用requests发送参数并返回Json结果。headers = { 'Accept': '/json' } url=f' html=requests.get(url,headers=headers); 如果 html.status_code == 200:html_bytes = html.content;html_str = html_bytes.decode() ; 只是根据地址，传入一个header告诉网页我们要接收一个json字符串。headers = { 'Accept': '/json' } url=f' html=requests.get(url,headers=headers); 如果 html.status_code == 200:html_bytes = html.content;html_str = html_bytes.decode() ; 只是根据地址，传入一个header告诉网页我们要接收一个json字符串。headers = { 'Accept': '/json' } url=f' html=requests.get(url,headers=headers); 如果 html.status_code == 200:html_bytes = html.content;html_str = html_bytes.decode() ; 只是根据地址，传入一个header告诉网页我们要接收一个json字符串。
　　解析jsonjson是一种可以被多种语言解析的数据存储格式，一般用于数据传输。从上图可以看出，所有的文章列表都在topic_list的topic中，我们看看python3是如何解析的。数据 = json.loads(html_str); all_items=data['topic_list']['topics'] write_content=[]; 对于所有项目中的项目：slug = item['slug'];item_id = item['id']link = f'title = item['title'];like_count = item['like_count'];like_count = item['like_count '];posts_count = item['posts_count'];views = item['views'];created_at = item['created_at'];write_content.append({'title': 标题, 'link': 链接, 'like' :like_count, 'reply':posts_count, 'browse':views, '发帖时间': created_at} ）；打开几个论坛内容就可以找到链接地址，由slug和id这两个字段拼接而成。
　　最后使用多线程和 csv 来存储结果。（不确定可以看之前的文章。白鱼无冰：Python爬虫实战（三)！xpath和csv！白鱼无冰：Python爬虫实战（二)!) 多线程爬虫！) pool = Pool(3); orign_num=[x for x in range(0,10)]; result = pool.map(scrapy,orign_num); with open('ccc_title_link .csv', 'w', newline='') as csvfile:= ('title', 'link', 'like', 'reply', 'browse', 'post time')writer = csv .(csvfile , =)writer.()for write_content in result:for _content in write_content:writer.writerow(_content);最后我们来看看最终效果！总结 对于动态生成的内容，我们可以在网页分享中分析下载的文件, 并通过requests模块模拟headers和发送参数来获取数据。这是我学到的新技能！如果您有任何错误或其他想法，请留言！如果我学到了新东西，我会尽快与你分享。点击关注，不要迷路！以上内容仅供个人学习使用，请勿用于商业用途。我是白玉无冰，游戏开发小红人，也玩python和shell注意！Cocos中文论坛域名修改！动态爬取论坛列表！Python爬虫入门实战(四)! 我会尽快与您分享。点击关注，不要迷路！以上内容仅供个人学习使用，请勿用于商业用途。我是白玉无冰，游戏开发小红人，也玩python和shell注意！Cocos中文论坛域名修改！动态爬取论坛列表！Python爬虫入门实战(四)! 我会尽快与您分享。点击关注，不要迷路！以上内容仅供个人学习使用，请勿用于商业用途。我是白玉无冰，游戏开发小红人，也玩python和shell注意！Cocos中文论坛域名修改！动态爬取论坛列表！Python爬虫入门实战(四)!
　　3.太棒了！Python爬虫学习的完整路线推荐
　　数据是决策的原材料。高质量的数据很有价值。如何挖掘原材料成为互联网时代的先行者，掌握信息来源，可以比别人快一步。大数据时代，互联网成为海量信息的载体。机械复制和粘贴不再实用。它不仅费时费力，而且容易出错。这时，爬虫的出现解放了大家的双手，以其高速爬行和定向抓取资源的能力得到了大家的青睐。爬虫越来越流行，不仅因为它能够快速爬取海量数据，还因为python等易于使用的语言，使得爬虫可以快速上手。对于小白来说，爬取可能是一件很复杂的事情，技术门槛很高，但掌握正确的方法其实很容易，能够在短时间内爬取主流的网站数据。但建议你从一开始就有一个特定的目标。以目标为驱动，您的学习将更加准确和高效。所有你认为必要的必备知识，都可以在完成目标的过程中学习。基于python爬虫，我们组织了一个完整的学习框架：筛选和筛选要学什么知识，从哪里获取资源是很多初学者面临的常见问题。接下来，我们将拆解学习框架，详细介绍各个部分，并推荐一些相关资源，告诉大家该学什么，怎么学，在哪里学。爬虫简介 爬虫是一种程序或脚本，它按照一定的规则自动从万维网上爬取信息。这个定义看起来很生硬，我们改成更好理解的解释：我们作为用户获取网络数据的方式是向浏览器提交请求-&gt;下载网页代码-&gt;解析/渲染成页面；而爬虫的方式是模拟浏览服务器发送请求 -&gt; 下载网页代码 -&gt; 只提取有用的数据 -&gt; 将其存储在数据库或文件中。我们作为用户获取网络数据的方式是向浏览器提交请求-&gt;下载网页代码-&gt;解析/渲染成页面；而爬虫的方式是模拟浏览服务器发送请求 -&gt; 下载网页代码 -&gt; 只提取有用的数据 -&gt; 将其存储在数据库或文件中。我们作为用户获取网络数据的方式是向浏览器提交请求-&gt;下载网页代码-&gt;解析/渲染成页面；而爬虫的方式是模拟浏览服务器发送请求 -&gt; 下载网页代码 -&gt; 只提取有用的数据 -&gt; 将其存储在数据库或文件中。
　　爬虫和我们的区别在于，爬虫程序只提取网页代码中对我们有用的数据，爬虫爬取速度快，量级大。随着数据规模的扩大，爬虫获取数据的高效性能越来越突出，可以做的事情也越来越多： 市场分析：电商分析、商圈分析、一二级市场分析等。市场监控：电商、新闻、房产监控等商机发现：竞价情报发现、客户数据发现、企业客户发现等。爬虫学习首先要了解网页。那些我们肉眼能看到的亮丽漂亮的网页，都是由 HTML、css 等网页源代码组成的。支持的。这些源代码被浏览器识别并转换成我们看到的网页。这些源代码中肯定有很多规则，我们的爬虫可以根据这些规则抓取需要的信息。没有规则，也没有圈子。Robots 协议是爬虫中的规则。它告诉爬虫和搜索引擎哪些页面可以爬取，哪些页面不能爬取。通常在 网站 的根目录中有一个名为 robots.txt 的文本文件。轻量级爬虫“获取数据-解析数据-存储数据”是爬虫的三部曲。大多数爬虫都遵循这个过程，实际上是模拟了使用浏览器获取网页信息的过程。1、获取数据爬虫的第一步是模拟浏览器向服务器发送请求。基于python，
　　Python自带的标准库urllib2用的比较多。它是python内置的HTTP请求库。如果你只做基本的爬取网页，那么 urllib2 就足够了。Requests 的口号是“Requests 是唯一一个适用于 Python 的非转基因 HTTP 库，对它来说是安全的”。与 urllib2 相比，requests 使用起来确实简单得多，并且附带了一个 json 解析器。如果需要爬取异步加载的动态网站，可以学习浏览器抓包分析真实请求或学习Selenium自动化。当然对于爬虫来说，只要能爬取数据，越快越好。显然，传统的同步代码无法满足我们对速度的需求。（ps：据国外统计：正常情况下，如果我们请求同一个页面100次，至少需要30秒，但是如果我们对同一个页面使用异步请求100次，大约只需要3秒。）aiohttp是你值得拥有的一个库，aiohttp的异步操作在async的帮助下变得更加简洁，结构更加清晰/await 关键字。使用异步请求库进行数据抓取时，效率会大大提高。可以根据自己的需要选择合适的请求库，但建议从python自带的urllib入手。当然，您可以在学习的同时尝试所有方法以更好地了解这些库的使用。在 async/await 关键字的帮助下，aiohttp 的异步操作变得更加简洁，结构更加清晰。使用异步请求库进行数据抓取时，效率会大大提高。可以根据自己的需要选择合适的请求库，但建议从python自带的urllib入手。当然，您可以在学习的同时尝试所有方法以更好地了解这些库的使用。在 async/await 关键字的帮助下，aiohttp 的异步操作变得更加简洁，结构更加清晰。使用异步请求库进行数据抓取时，效率会大大提高。可以根据自己的需要选择合适的请求库，但建议从python自带的urllib入手。当然，您可以在学习的同时尝试所有方法以更好地了解这些库的使用。
　　推荐的请求库资源：urllib2 document::, JSON, XML 等格式。使用解析库相当于在HTML中查找需要的信息时使用正则表达式，可以更快速的定位到具体的元素，获取相应的信息。CSS 选择器是一种快速定位元素的方法。Pyqurrey 使用 lxml 解析器对 xml 和 html 文档进行快速操作。它提供了类似于 jQuery 的语法来解析 HTML 文档，支持 CSS 选择器，使用起来非常方便。Beautiful Soup 是一个借助网页结构和属性解析网页的工具，可以自动转换代码。它支持 Python 标准库中的 HTML 解析器，以及一些第三方解析器。Xpath 最初用于搜索 XML 文档，但它也适用于搜索 HTML 文档。它提供了 100 多个内置函数。这些函数用于字符串值、数值、日期和时间比较、节点和QName处理、序列处理、逻辑值等，XQuery和XPointer都是建立在XPath的基础上的。Re 正则表达式通常用于检索和替换匹配某个模式（规则）的文本。个人觉得前端基础比较扎实。使用 pyquery 是最方便最好的。re的速度比较快，但是写正则表达式比较麻烦。当然，既然用的是python，那最好还是自己用。逻辑值等，XQuery 和 XPointer 都是建立在 XPath 的基础上的。Re 正则表达式通常用于检索和替换匹配某个模式（规则）的文本。个人觉得前端基础比较扎实。使用 pyquery 是最方便最好的。re的速度比较快，但是写正则表达式比较麻烦。当然，既然用的是python，那最好还是自己用。逻辑值等，XQuery 和 XPointer 都是建立在 XPath 的基础上的。Re 正则表达式通常用于检索和替换匹配某个模式（规则）的文本。个人觉得前端基础比较扎实。使用 pyquery 是最方便最好的。re的速度比较快，但是写正则表达式比较麻烦。当然，既然用的是python，那最好还是自己用。
　　推荐解析器资源：pyquery作为关系型数据库的代表，系统比较成熟，成熟度很高，可以很好的存储一些数据，但是在处理海量数据时效率会明显变慢，已经不能令人满意了。某些大数据处理要求。MongoDB 已经流行了很长时间。与 MySQL 相比，MongoDB 可以方便你存储一些非结构化的数据，比如各种评论的文本、图片的链接等。你也可以使用 PyMongo 更方便地在 Python 中操作 MongoDB。因为这里用到的数据库知识其实很简单，主要是如何存储和提取数据，需要的时候学。Redis 是一个不折不扣的内存数据库。Redis支持丰富的数据结构，包括hash、set、list等。所有数据都存储在内存中，访问速度快，可以存储大量数据。一般用于分布式爬虫的数据存储。推荐的数据库资源：mysql文档和redis文档选择器可以轻松解析响应，但最让人惊喜的是它的超高性能，让你对爬虫进行工程化和模块化。学习scrapy，可以自己搭建一些爬虫框架，基本具备爬虫工程师的思维。最后，Pyspider作为国内大神们开发的框架，满足了大部分Python爬虫的需求——定向爬取和结构化分析。mysql 文档和redis 文档选择器可以轻松解析响应，但最让人惊喜的是它的超高性能，可以让你对爬虫进行工程化和模块化。学习scrapy，可以自己搭建一些爬虫框架，基本具备爬虫工程师的思维。最后，Pyspider作为国内大神们开发的框架，满足了大部分Python爬虫的需求——定向爬取和结构化分析。mysql 文档和redis 文档选择器可以轻松解析响应，但最让人惊喜的是它的超高性能，可以让你对爬虫进行工程化和模块化。学习scrapy，可以自己搭建一些爬虫框架，基本具备爬虫工程师的思维。最后，Pyspider作为国内大神们开发的框架，满足了大部分Python爬虫的需求——定向爬取和结构化分析。
　　可以在浏览器界面进行脚本编写、函数调度和爬取结果的实时查看，后端使用常用数据库存储爬取结果。它足够强大，更像是一个产品而不是一个框架。这是三个最具代表性的爬虫框架。它们都有远超其他的优势，比如Nutch的自然搜索引擎解决方案，Pyspider的产品级WebUI，以及Scrapy最灵活的定制化爬虫。推荐学习最接近爬虫本质的框架scarry，然后接触为搜索引擎而生的人性化Pyspider和Nutch。推荐爬虫框架资源：Nutch 文档 可怕文档 pyspider 文档爬取基础数据没问题，你也可以用框架来面对写更复杂的数据，这时候就算遇到反爬，你也已经掌握了一些反反爬的技巧。你的瓶颈将是爬取海量数据的效率。这个时候，相信大家自然会接触到一个很厉害的名字：分布式爬虫。分布式的东西听起来很吓人，但实际上它是利用多线程的原理，将多个主机组合起来，共同完成一个爬取任务。你需要掌握 Scrapy + Redis + MQ + Celery 的工具。之前我们说过，Scrapy是用来做基础页面爬取的，Redis是用来存放待爬取网页的队列，也就是任务队列。Scarpy-redis是scrapy中用来实现分布式组件的组件，
　　在高并发环境中，请求经常因为没有时间进行同步处理而被阻塞。通过使用消息队列MQ，我们可以异步处理请求，从而减轻系统压力。RabbitMQ 本身支持多种协议：AMQP、XMPP、SMTP、STOMP，使其非常重量级，更适合企业级开发。Scrapy-rabbitmq-link 是一个组件，它允许您从 RabbitMQ 消息队列中获取 URL 并将它们分发给 Scrapy 蜘蛛。Celery 是一个简单、灵活、可靠的分布式系统，用于处理大量消息。它支持RabbitMQ、Redis甚至其他数据库系统作为其消息代理中间件，在异步任务、任务调度、定时任务、分布式调度等场景中表现出色。所以分布式爬虫听起来很吓人，但就是这样。当你能写出分布式爬虫的时候，就可以尝试搭建一些基本的爬虫架构，实现一些更自动化的数据获取。推荐的分布式资源：scrapy-redis 文档
　　拿大数据说话，优势一目了然，从事IT行业，打开IT行业新大门，找到适合自己的培训机构，进行专业、系统的学习。 查看全部

　　java爬虫抓取动态网页(爬虫程序就是自动搜索获取内容的程序，我的需求
)
　　几年没写代码了，也不觉得以后会是码农，但是对编程的实用性还是挺感兴趣的。采集每次游泳的链接资源的想法，毕业后就没什么好担心的了。我开始思考了一两个小时，做了一个小爬虫来抓取这些超链接资源。当然，我的功能还是很简单的。这里不想写什么专业的东西，把自己写的原创源码贴出来分享给大家。
　　爬虫是一种自动搜索和获取内容的程序。我的需求是弄个采集网页内容的小爬虫，也叫网络爬虫，用来采集有用的超链接信息。
　　网络爬虫的简单原理（据我了解）是从给定的 URL 爬取相应网页的内容。给定的 URL 可以手动分配，也可以由爬虫自己自动解析。通过正则表达式判断需要爬取的网页内容，如何爬取是网页数据流的实现过程。所以小爬虫所涉及的技术非常基础，所以我就分类贴下下一个人的原代码。
　　一、通过 URL 获取网页内容
　　 public StringBuffer getContext(String URLPath)
{
StringBuffer buffer= new StringBuffer();
try {
URL url = new URL(URLPath);
URLConnection conn = url.openConnection();
BufferedReader reader = new BufferedReader(new InputStreamReader(conn.getInputStream()));
String line = null;
while((line = reader.readLine()) != null)
buffer.append(line + "\n");

} catch (MalformedURLException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
return buffer;
}
　　二、解析网页内容
　　 /**
* 解析网页内容，返回所需的信息，可以是String型，此处是因实际需要返回map
* @param htmlDoc 网页内容
*/
public LinkedHashMap urlDetector(String htmlDoc)
{
//key存放超链接显示名，value存放相对地址路径名
LinkedHashMap map = new LinkedHashMap();
final String patternString = "([^\\s]+)>>>");
buf1.append(keyName + "\n");
String BtStr = t.collectBTorOther(uPath, filePath + keyName + ".tmp");
buf1.append(BtStr);
buf1.append("-----------------------------------------------\n");
}
}
<p> /**
* 接上面，特殊处理
* @param uPath
* @param fPath
*/
public String collectBTorOther(String uPath, String fPath)
{
StringBuffer buf = this.getContext(uPath);
this.writeToFile(fPath, buf);
// 解析网页内容,返回需要收集的信息
final String patternBT = "http:[^>\"' 查看全部

　　java爬虫抓取动态网页(
如何使用Java编写知乎爬虫，小伙伴们可以对比这看下)
　　从零基础开始编写Java知乎爬虫的准备工作
　　更新时间：2014-11-07 09:48:35 发布者：hebedic
　　在上一个系列中，我们从易到难介绍了如何使用python编写爬虫。小伙伴们的反应还挺多的。在这个系列中，我们来学习使用Java编写知乎爬虫，小伙伴们可以对比一下。
　　一开始，我们还是和以前一样。下面说说做爬虫的思路和需要准备的知识。高手请无视。
　　首先，我们来想一想，想一想该怎么做，列出一个简单的需求。
　　要求如下：
　　1.模拟访问知乎官网()
　　2.下载指定页面内容，包括：今日热、本月热、编辑推荐
　　3.下载指定类别的所有问答，如：投资、编程、失败科目
　　4.下载给定受访者的所有回复
　　5.如果有一个变态的功能，一键点赞就好了（这样我就可以同时喜欢 Leylen 的所有答案。我太聪明了！）
　　那么需要解决的技术问题简单罗列如下：
　　1.模拟浏览器访问网页
　　2.捕获关键数据并保存在本地
　　3.解决网页浏览中的动态加载问题
　　4.使用树形结构海量抓取知乎的所有内容
　　好吧，这就是我目前所想的。
　　接下来是准备工作。
　　1.确定爬虫语言：由于之前写过一系列爬虫教程（点这里），百度贴吧、尴尬事百科、山东大学的成绩点查询等都是用python写的，所以这次决定用Java来写（哎，根本没有链接，好吧）。
　　2.科普爬虫知识：Web爬虫，或者Web Spider，是一个很形象的名字。互联网被比作蜘蛛网，那么蜘蛛就是在网上爬行的蜘蛛。网络蜘蛛通过它们的链接地址寻找网页。具体介绍请点击这里。
　　3.准备爬虫环境：关于Jdk和Eclipse的安装和配置就不多说了。在这里啰嗦一句，一个好的浏览器对于爬虫来说很重要，因为首先你需要自己浏览网页，知道你需要的东西在哪里，然后你才能告诉你的爬虫去哪里，怎么走爬行。个人推荐火狐，或者谷歌浏览器，它们的右键检查元素和查看源代码都很强大。
　　现在让我们开始正式的爬虫之旅吧！~具体说什么，嗯，这是个问题，让我想想，别着急^_^ 查看全部

　　java爬虫抓取动态网页(Python学习网页请求原理和技术方面的详细流程和方法
)
　　1、首先！你需要对爬虫有一个清晰的认识：
　　爬行动物的重要想法
　　1）理论上来说，只要网页上能看到的数据都能被爬取，而且网上的内容是人写的，第一页不是a，下一页是5，肯定有规律可寻，让人有爬行的可能。
　　（因为看到的网页上的所有数据都是由服务器发送到我们的电脑的，但有些数据是加密的，难以解密）
　　2）“框架不变”：网站不同，但原理相似。大部分爬虫都是从发送请求——获取页面——解析页面——下载内容——存储内容的过程开始做的，只是工具不同而已。
　　3）网页上看不到或者获取的数据也是爬虫无法获取的，比如一些付费数据。
　　4）分析页面数据的原则是由简单到复杂，由易到难。
　　现实中，爬虫面临很多问题，比如：
　　类似的问题还有很多。爬虫虽然简单，但学无止境（如搜索引擎等）。
　　
　　2、缺乏合理的学习路径，学完Python和HTML极易放弃
　　零基础学习Python爬虫路线
　　1）主要是学习Python的基础知识，从而能够掌握Python。
　　Python 很容易学习，但很难掌握。技术方面，首先基础知识要扎实，包括语言基础、计算机基础、算法和自己方向的编程。
　　2）了解爬虫的实现原理和技术，包括爬虫的实现原理、爬取网页的详细过程、通用爬虫中网页的分类、通用爬虫相关网站文件、反爬虫响应策略、Python爬虫的优势等。
　　在这个阶段，你需要了解爬虫是如何爬取网页的，并对爬取过程中出现的一些问题有一定的了解。
　　3）学习网页请求的原理，包括浏览网页的过程，HTTP网络请求的原理，HTTP抓包工具Fiddler。
　　浏览网页的过程：
　　在浏览网页的过程中，我们会看到一些图片和百度搜索框。这个过程其实就是用户输入URL后，经过DNS服务器，找到服务器主机，向服务器发送请求。服务器解析后，发送到用户的浏览器浏览器可以解析HTML、JS、CSS等文件，可以看到各种图片。
　　4）用作爬取web数据的两个库：urllib和requests。
　　学习 urllib 库的基本使用，包括使用 urllib 传输数据，添加具体的 headers，设置代理服务器，超时设置，常见的网络异常，然后学习一个更方便快捷的 requests 库。
　　最好结合一个简单的案例来学习如何使用 urllib 库来抓取网页数据。在这个阶段，熟练掌握这两个库的使用很重要。反复使用和练习非常重要。
　　5）主要是学习几种网页解析数据，包括正则表达式、XPath、Beautiful Soup和JSONPath，以及封装这些技术的Python模块或库的基本使用，包括re模块、lxml库, bs4 库, json 模块等。
　　大家可以结合大厂社招网站的案例来学习如何分别使用re模块、lxml库和bs4库来解析网页数据，知道什么情况下使用哪个库更有优势。
　　6）学习并发下载；包括多线程爬虫进程分析，使用queue模块实现多线程爬取，协程实现并发爬取。
　　本阶段实操推荐尴尬百科，使用单线程、多线程、协程获取网页数据，分析三者的表现。
　　7）练习如何抓取动态内容；动态网页介绍，selenium 和 PhantomJS 概述，selenium 和 PhantomJS 安装配置，selenium 和 PhantomJS 的基本使用。
　　模拟豆瓣网站登录是学习如何在项目中应用selenium和PhantomJS技术的一个很好的实践案例。
　　8）图像识别和文字处理的学习；包括下载安装Tesseract引擎、pytesseract和PIL库、处理标准格式文本、处理验证码等。
　　建议结合识别本地验证码图片的小程序学习如何使用pytesseract识别图片中的验证码。
　　9）数据库学习；包括数据存储介绍、MongoDB数据库介绍、使用PyMongo库存储到数据库等。
　　数据库的学习比较简单。逐步了解如何从 网站 获取、解析和存储电影信息。
　　10）爬虫框架Scrapy
　　Scrapy 自己的选择器、中间件、蜘蛛等会比较难理解。建议结合具体的例子，参考别人的代码来了解实现过程，以便更好的理解。
　　初步学习：包括常用爬虫框架介绍、Scrapy框架架构、操作流程、安装、基本操作等。
　　
　　3、知识储备不足
　　没有任何计算机网络和编程，基本的爬虫什么都做不了。
　　4、有效掌握请求和解析方法
　　爬虫的本质是网络请求和数据处理。网络请求没什么好说的，直接用requests框架就行了。
　　请求和响应
　　请求：浏览器向URL所在的服务器发送消息。这个过程称为 HTTP 请求。
　　响应：服务器收到浏览器发送的消息后，可以根据浏览器发送的消息内容进行处理，然后将消息发送回浏览器。此过程称为 HTTP 响应。
　　浏览器收到服务器的Response信息后，会对信息进行相应的处理，然后显示出来。
　　要求
　　请求方式：主要有GET和POST两种，另外还有HEAD、PUT、DELETE、OPTIONS等。
　　请求 URL：URL 的全称是统一资源定位器。例如，网页文档、图片、视频等都可以由URL唯一确定。
　　请求头：收录请求过程中的头信息，如User-Agent、Host、Cookies等信息。
　　请求体：请求过程中携带的附加数据，如表单提交时的表单数据。
　　回复
　　响应状态：有多种响应状态，如200成功，301重定向，404页面未找到，502服务器错误。
　　响应头：如内容类型、内容长度、服务器信息、设置cookies等。
　　响应体：最重要的部分，包括请求资源的内容，如网页HTML、图片二进制数据等。
　　解析出来的内容可以是HTML，可以用正则表达式和网页解析库来解析。可能是Json，可以直接转换成Json对象解析，也可能是二进制数据，可以保存或者进一步处理。
　　有以下分析方法：
　　数据处理基本上就是截取网页的HTML字符。建议新手先学会使用正则表达式匹配自己要提取的内容，再使用库。对于新手来说，常规规则会有些困难。.
　　
　　5、学会使用工具辅助
　　先了解这里，再到具体项目的时候再熟悉应用。
　　1）代码编辑器
　　IDE一般使用pycharm或者VSCode比较多，大家可以根据自己的习惯和喜好来使用，没有规定一定要使用。
　　2）F12 开发者工具
　　3）抓包工具
　　它是一个强大的 Web 调试工具，可以记录来自客户端和服务器的所有 HTTP 请求。作为代理网络服务器，它使用代理地址：127.0.0.1，端口：8888
　　火狐浏览器下的插件优于谷歌火狐自带的F12工具。
　　很不错的xpath测试工具，但是有几个坑：
　　xpath 检查器生成一个绝对路径。在遇到一些动态生成的图标（一般有列表翻页按钮等）时，绝对路径飘忽不定很可能会导致错误，所以建议在实际分析时作为参考。
　　请记住删除 xpath 框中的“x:”，如下所示。看来这是xpath早期版本的语法，目前与某些模块（如scrapy）不兼容，所以最好将其删除，以免出错。
　　
　　在线正则表达式测试可用于更多练习，有助于分析。有很多现成的正则表达式可以使用，也可以参考。
　　6、具备应对反爬的能力
　　爬上去怎么能行！
　　
　　常见的防爬虫措施：
　　应对反爬的手段有：
　　遇到反爬虫策略验证码怎么办？（不想直接折腾第四个）
　　处理反爬的部分，还是要自己动手尝试。实际爬取过程中遇到的问题肯定不会一样，多处理会有上手的体验。
　　先找一个简单的静态网站试试，先别急着爬动态网站，技巧还没到（动态网站爬比较复杂），比如一个简单小说网站：看好玩。
　　
　　7、很多新手说：网上很多爬虫代码卡死运行，得不到想要的结果
　　可能有以下三个原因：
　　①很久以前，爬的网站已经不能访问了。
　　②网站结构发生变化，原代码提取逻辑不适用。
　　③应该知道，互联网技术正在飞速发展。之前很多网站使用HTTP协议，但存在潜在的安全隐患。如今，它们中的大多数使用HTTPS协议。
　　对于爬虫来说，需要在请求链接的基础上添加headers参数：Cookie、User-Agent... 视实际情况而定（User-Agent头域的内容收录用户的信息谁提出了请求；浏览时cookie是在服务器中注册的一个小数据体，可以记录与服务器相关的用户信息）。
　　8、编写爬虫的一般步骤
　　1）目的
　　2）分析
　　-&gt; 分析页面加载过程
　　① 直接
　　② 动态加载
　　-&gt; 阿贾克斯
　　-&gt; Js生成：直接生成，jsonp方式
　　③ 工具
　　谷歌浏览器，f12 开发者工具
　　-&gt; 分发要爬取的页面结构 - 提取信息
　　3）实现
　　-&gt; 根据分析结果，代码实现
　　爬百度示例
　　爬虫示例,爬取百度页面
import requests #导入爬虫的库，不然调用不了爬虫的函数
​response = requests.get(“http://www.baidu.com”) #生成一个response对象
response.encoding = response.apparent_encoding #设置编码格式
print(“状态码:”+ str( response.status_code ) ) #打印状态码
print(response.text)#输出爬取的信息
　　爬虫就到此为止了，看完后你应该试一试。
　　互联网时代，爬虫技术的加持无疑是工作学习的锦上添花
　　Python学习路线
　　爬虫
　　
　　Linux基础
　　
　　面向对象
　　
　　项目实战
　　
　　学好 Python 是赚钱的好方法，不管是工作还是副业，但要学好 Python，还是要有学习计划的。免费分享全套Python学习资料，帮助想学Python的人！
　　本完整版Python全套学习资料已上传至CSDN。需要的可以微信扫描下方CSDN官方认证二维码免费获取【保证100%免费】。
　　 查看全部

　　java爬虫抓取动态网页(
知乎编辑推荐的爬虫、经验和见解，值得收藏！)
　　零基础写Java知乎爬虫获取知乎编者推荐
　　更新时间：2014-11-07 10:33:33 发布者：hebedic
　　在上一篇文章中，我们用百度首页做了一个小测试。今天我们来个复杂的，直接抓取知乎小编推荐的内容。小伙伴们松了口气，终于进入正题。哈哈。
　　知乎是一个真正的在线问答社区，社区氛围友好、理性、严肃，连接各行各业的精英。他们分享彼此的专业知识、经验和见解，为中国互联网提供源源不断的优质信息。
　　首先，花三五分钟设计一个 Logo=。= 作为程序员，我一直有一颗做艺术家的心！
　　
　　好吧，这有点临时，所以让我们先做一点。
　　接下来，我们开始制作知乎的爬虫。
　　首先，确定第一个目标：编辑建议。
　　网页链接：
　　我们对最后的代码稍作修改，首先实现可以获取到页面的内容：
　　import java.io.*;
import java.net.*;
import java.util.regex.*;
public class Main {
 static String SendGet(String url) {
  // 定义一个字符串用来存储网页内容
  String result = "";
  // 定义一个缓冲字符输入流
  BufferedReader in = null;
  try {
   // 将string转成url对象
   URL realUrl = new URL(url);
   // 初始化一个链接到那个url的连接
   URLConnection connection = realUrl.openConnection();
   // 开始实际的连接
   connection.connect();
   // 初始化 BufferedReader输入流来读取URL的响应
   in = new BufferedReader(new InputStreamReader(
     connection.getInputStream()));
   // 用来临时存储抓取到的每一行的数据
   String line;
   while ((line = in.readLine()) != null) {
    // 遍历抓取到的每一行并将其存储到result里面
    result += line;
   }
  } catch (Exception e) {
   System.out.println("发送GET请求出现异常！" + e);
   e.printStackTrace();
  }
  // 使用finally来关闭输入流
  finally {
   try {
    if (in != null) {
     in.close();
    }
   } catch (Exception e2) {
    e2.printStackTrace();
   }
  }
  return result;
 }
 static String RegexString(String targetStr, String patternStr) {
  // 定义一个样式模板，此中使用正则表达式，括号中是要抓的内容
  // 相当于埋好了陷阱匹配的地方就会掉下去
  Pattern pattern = Pattern.compile(patternStr);
  // 定义一个matcher用来做匹配
  Matcher matcher = pattern.matcher(targetStr);
  // 如果找到了
  if (matcher.find()) {
   // 打印出结果
   return matcher.group(1);
  }
  return "Nothing";
 }
 public static void main(String[] args) {
  // 定义即将访问的链接
  String url = "http://www.zhihu.com/explore/recommendations";
  // 访问链接并获取页面内容
  String result = SendGet(url);
  // 使用正则匹配图片的src内容
  //String imgSrc = RegexString(result, "src=\"(.+?)\"");
  // 打印结果
  System.out.println(result);
 }
}
　　运行没有问题，然后就是正则匹配的问题。
　　首先让我们获取此页面上的所有问题。
　　右键单击标题并检查元素：
　　
　　啊哈，可以看到标题其实是一个a标签，是一个超链接，和其他超链接区别的应该是类，也就是类选择器。
　　于是我们的常规语句就出来了：question_link.+?href=\"(.+?)\"
　　调用 RegexString 函数并传递参数：
<p> public static void main(String[] args) {
  // 定义即将访问的链接
  String url = "http://www.zhihu.com/explore/recommendations";
  // 访问链接并获取页面内容
  String result = SendGet(url);
  // 使用正则匹配图片的src内容
  String imgSrc = RegexString(result, "question_link.+?>(.+?)(.+?)(.+?) 查看全部

　　java爬虫抓取动态网页(《》大文件下载)
　　一、概览
　　大文件的下载方式很多，idm、aria2、迅雷直接链接也可以从idm下载
　　但是我发现还是有一些东西需要爬虫+batch（batch注定不小，只好带上多线程），于是开始尝试。
　　二、爬虫部分
　　/**爬虫实体
* @author LW
* @2021/10/30 19:25
*/
@Data
@NoArgsConstructor
@AllArgsConstructor
public class Parse {
private String title;
private String img;
private String price;
}
　　/**爬虫服务
* @author LW
* @2021/10/31 14:35
*/
public class ParseService {
public static void main(String[] args) throws Exception {
//测试数据
new ParseService().parseTo945("https://www.945kmzh.com/pc").forEach(System.out::println);
}
public List parseTo945(String keywords) throws Exception{
String url = keywords;
//解析网页 (Jsoup返回Document 就是页面对象 )
Document document = Jsoup.parse(new URL(url),30000);
Elements elements = document.getElementsByClass("post-item-thumbnail");
ArrayList goodsList = new ArrayList();
for (Element el : elements) {
String img = el.getElementsByTag("img").eq(0).attr("src");
Parse content = new Parse();
content.setImg(img);
goodsList.add(content);
}
return goodsList;
}
}
　　三、多线程
<p>/**
* @Author LW
* @2022/2/11 14:16
*/
public class MyMultiThread extends Thread {
private List list;//集合
private int len;//集合长度
private int n;//线程数
private String pre;//路径前缀
private String dir;//目录
private int flag;// 线程号
public MyMultiThread(List list, int len, int n, String pre, String dir, int flag) {
super();
this.list = list;
this.len = len;
this.n = n;
this.pre = pre;
this.dir = dir;
this.flag = flag;
}
@Override
public void run() {
//n线程数
// 每个线程执行一部分 (len/n)*flag--->(len/n)*(flag+1)
for (int j = (len/n)*flag; j 查看全部

　　java爬虫抓取动态网页(Python爬虫实现Java爬虫的类这个过程(组图))
　　1.需要的jar包
　　如果要进行Java爬取，需要额外导入一些jar包，如下
　　
　　这些 jars 可以从这个 URL 下载：
　　当然，如果读者不想导入这些模块（只想实现Java爬虫），可以看看小编的这篇博文。博客文章的链接是：
　　下载后，把这些jar包放在这个文件夹下，
　　
　　当然导入前需要创建动态项目，
　　
　　导入后需要建路径，
　　
　　
　　只需导入该项目文件下的所有jar包，一个简单的Java爬虫所需的jar就完成了。
　　2.一个实现Java爬虫的类
　　一般来说，这个过程只是几行代码（代码在很多地方重复）。读者可以参考小编的这篇博文。博文的链接是：另外这里提到需要爬取音乐。读者可以参考编辑的博文。这个博客，博客链接是：虽然这是用Python爬虫写的，但实现过程还是和Java爬虫一样！
　　小编这里需要强调的是，爬虫获取的json数据需要在这里进行处理。
　　
　　3. 实现主index.jsp文件
　　这个文件的主要作用是提交用户输入的关键词，然后返回一个搜索结果。效果如下：
　　
　　这里需要用到提交表单，如下：
　　
　　小编这里已经把下载记录放到了数据库里，所​​以这里又增加了一个功能，就是除了下载音乐，还可以查看你之前的下载记录！当然，下载记录也可以通过刚才的操作批量删除，也可以单独删除。
　　
　　下载记录本身就是一个a标签，也可以直接点击进入下载界面！
　　
　　同时，小编也下载了歌词。
　　
　　
　　这是一个.md文件，读者可以下载Typora软件查看。
　　具体其他servlet文件和java bean文件不再赘述。如果读者需要小编的这个项目，可以在CSDN上下载，当然也可以在gitee上下载！gitee链接是：
　　看看完整的运行结果！这里的运行结果还没有实现下载记录的功能！
　　Java爬虫结合jsp实现音乐下载的URL 查看全部

　　java爬虫抓取动态网页(刚来老板（导师）公司实习，接到爬虫和Jsoup方法)
　　我刚来老板（导师）公司实习。接到了用java做爬虫的任务，在中关村搜索手机参数。功能是输入一个关键字，然后输出相关手机的CPU型号、操作系统、蓝牙版本。例如：输入s6，需要输出s6手机的相关参数。
　　好吧，我对Java语言了解不多，可以借此机会好好学习一下，仅此而已！让我们开始学习...
　　首先，您需要弄清楚需求是什么。先模拟这个过程，然后你就不会上图了。编造你自己的大脑。首先在百度主页输入关键字s6，然后需要有页面跳转到搜索结果，然后找到相关结果。手机的链接，然后跳转到相关手机的页面，然后需要跳转到参数的页面，然后将相关数据一一提取。
　　网上找了很多教程，但是好像没有页面跳转的学习方法。那我想说大家应该对html有一定的了解，如果没有，可以去w3c看看。我尝试使用 RULConnection 和 Jsoup 方法，但似乎都不适用。也许它不适用于这个网站。在中关村搜索的页面好像不能直接跳转。经过多次尝试和失败，终于找到了HTMLUnitDriver类库。这个类库很好用，网上也有对应的jar包。可以自己下载，也可以自己深入学习。让我们从编码开始。
　　首先，要在网页上模拟关键词的输入，首先要找到输入框，打开评论元素（每个浏览器的名称不同），找到输入框的位置。
　　
　　输入框的id是kw，然后百度点击按钮的id是su，那么我们可以模拟在输入框中输入关键词，然后点击百度点击按钮进行搜索。代码显示如下：
　　 WebDriver driver = new HtmlUnitDriver();
String url = "https://www.baidu.com/";
driver.get(url);
driver.findElement(By.id("kw")).sendKeys(keyword);
driver.findElement(By.id("su")).click();
　　这里的关键字是自己输入的参数。代码没有写完整。搜索到的页面应如下所示：
　　
　　接下来，您应该输入中关村在线的链接。在这里您可以找到链接并通过链接文本输入。代码如下：
　　WebElement href =driver.findElement(By.partialLinkText("中关村在线"));
String href_s = href.getAttribute("href");
driver.get(href_s);
　　partialLinkText() 函数用于匹配部分链接文本。这里司机已经到了中关村页面。图片如下：
　　
　　然后需要点击参数表，可以再次查看元素，找到参数的链接地址，如图：
　　
　　继续跳转到找到的链接页面，代码如下：
　　String href_can =driver.findElement(By.partialLinkText("参数")).getAttribute("href");
driver.get(href_can);
　　跳转到目标页面后，就该开始提取目标数据了。还是要看网页的源码，图片如下：
　　
　　可以看到参数数据放在了id叫newTb的div中，所以我们需要找到这个div元素。然后找具体资料，以操作系统为例，先看下操作系统的相关源码，图片如下：
　　
　　在源码中可以看到，参数中的每一行数据都放在一个li中。可恶的是，这个li没有id值，也没有class值。这可能是网站的反爬虫设计，然后下面的span有一个id值，但是获取不到这个值。百度说这个id是动态的，无法获取固定值。我该怎么办？我想了一个办法，先把这些 li 搞定。，然后找出每个li下的span中是否有操作系统相关的关键字可以匹配。如果是，则输出 li 中的所有文本。代码如下：
　　WebElement tb = driver.findElement(By.id("newTb"));
List list = tb.findElements(By.tagName("li"));
for(WebElement e : list) {
if(e.getText() == "") {
}else {
List spans = e.findElements(By.tagName("span"));
boolean tag = false;
for(WebElement span : spans) {
String str = span.getText();
Pattern pattern = Pattern.compile("([Ii][Oo][Ss][ ][0-9]+)|([A][n][d][r][o][i][d][ ][0-9]+)|([C][P][U])|([W][L][A][N])");
Matcher matcher = pattern.matcher(str);
if(matcher.find()) {
tag = true;break;
}
}
if(tag) {
for(WebElement span : spans) {
System.out.println(span.getText());
}
}
}
　　上面的代码中使用了简单的正则表达式。不懂童鞋的可以自己学，以后会很有用。最后别忘了拦住司机。代码是：
　　driver.quit();
　　爬升参数的数据到这里基本就完成了。代码的核心部分都写了，也有一些没写，比如输入或者异常处理。这个学习者自学，然后可以看到我的代码中基本没有注释。事实上，有。我已经全部删除了。我只是希望您可以自己检查和了解更多信息。我自己只是一个学习者。我希望这篇文章 文章 可以对你有所帮助。. 查看全部