① java爬虫抓取指定数据
根据java网络编程相关的内容，使用jdk提供的相关类可以得到url对应网页的html页面代码。
针对得到的html代码，通过使用正则表达式即可得到我们想要的内容。
比如，我们如果想得到一个网页上所有包括“java”关键字的文本内容，就可以逐行对网页代码进行正则表达式的匹配。最后达到去除html标签和不相关的内容，只得到包括“java”这个关键字的内容的效果。
从网页上爬取图片的流程和爬取内容的流程基本相同，但是爬取图片的步骤会多一步。
需要先用img标签的正则表达式匹配获取到img标签，再用src属性的正则表达式获取这个img标签中的src属性的图片url，然后再通过缓冲输入流对象读取到这个图片url的图片信息，配合文件输出流将读到的图片信息写入到本地即可。
② java相关。爬虫问题，关于新浪微博。谢谢！
开门见山，说两个工具可以实现你的要求，分笔试selenium和htmlunit。当然还有其他工具，就不一一列举了。
首先你用jsoup或者apache的httpclient爬到你能够爬到的那一层，即可以通过response传回的html静态页面可以知道下一步爬哪个连接的那一层。
然后到爬不动的那一层，比如你说图片动态加载，抓回的html上找不到图片的链接了，那么你在使用上述两个工具其中一个。
大致思路我絮叨的如上。然后说一下二者的异同。
————————————————————————————————
这两个你选用一个就好，不过爬虫用htmlunit就可以了。这俩都是做页面测试方面很好用的工具，不同于其它的工具是他们可以模拟一个浏览器引擎，通过这句话我想你就应该知道你给他一个地址他就可以像浏览器那样解析，既然如此浏览器本身应该知道解析后的html啊，所以就可以拿到了。不同点是selenuim会弹出一个框，后者后台静默的为你奉献。当然，出发点不同，前者更善于肉眼可见的模拟，都很好用，简单爬虫推荐用后者。又絮叨了一堆，好了，你对这两个工具有个了解了。下面附上一个htmlunit的demo，你就可以用了。
————————————————————————————————
新浪微博需要登录，所以你需要模拟登录过程，并保持一个登录后的WebClient对象，然后用它来访问那些动态生成的网页。
WebClient webClient = new WebClient();
HtmlPage page1 = webClient.getPage(登录的url);
HtmlForm form = page1.getFormByName("myform");
HtmlSubmitInput button = form.getInputByName("submitbutton");
HtmlTextInput textField = form.getInputByName("userid");
textField.setValueAttribute("root");
HtmlPage page2 = button.click();
好了，你已经可以做了。这个工具一定可以帮你完成你的功能需求。htmlunit的例子也很多，网络一下试试。
③ JAVA开发新浪微博，怎样获取所有粉丝的ID，next_cursor一直出现问题
1、基于API的数据获取，本身就要依赖于服务提供方，也就是新浪的请求设置，这是程序设计中经常有的手段，现在服务方最多只能提供5000条，也就是最多可以取到5000条，至于为何会有curosr，应该是在一次请求小于5000的时候才会有实际意义。
2、现在的新浪微博开发越来越多，通过API只是其中的一种，像以前的网络爬虫方式获取数据也是可以的，
再查下资料吧~
④ 如何用Java写一个爬虫
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
import java.io.File;
import java.net.URL;
import java.net.URLConnection;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.Scanner;
import java.util.UUID;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class DownMM {
public static void main(String[] args) throws Exception {
//out为输出的路径,注意要以\\结尾
String out = "D:\\JSP\\pic\\java\\";
try{
File f = new File(out);
if(! f.exists()) {
f.mkdirs();
}
}catch(Exception e){
System.out.println("no");
}
String url = "http://www.mzitu.com/share/comment-page-";
Pattern reg = Pattern.compile("<img src=\"(.*?)\"");
for(int j=0, i=1; i<=10; i++){
URL uu = new URL(url+i);
URLConnection conn = uu.openConnection();
conn.setRequestProperty("User-Agent", "Mozilla/5.0 (Windows NT 6.3; WOW64; Trident/7.0; rv:11.0) like Gecko");
Scanner sc = new Scanner(conn.getInputStream());
Matcher m = reg.matcher(sc.useDelimiter("\\A").next());
while(m.find()){
Files.(new URL(m.group(1)).openStream(), Paths.get(out + UUID.randomUUID() + ".jpg"));
System.out.println("已下载:"+j++);
}
}
}
⑤ 新浪微博数据抓取方法有哪些
新浪微博数据抓取方法：
插入热门话题，会有相对应的热门关键词能够体提升阅读数；
发布的内容带有用户可以直观搜索的关键词；
图片最好采用九图模式；
发布头条文章；
申请话题主持人等。
⑥ Java网络爬虫怎么实现
网络爬虫是一个自动提取网页的程序，它为搜索引擎从万维网上下载网页，是搜索引擎的重要组成。
传统爬虫从一个或若干初始网页的URL开始，获得初始网页上的URL，在抓取网页的过程中，不断从当前页面上抽取新的URL放入队列，直到满足系统的一定停止条件。对于垂直搜索来说，聚焦爬虫，即有针对性地爬取特定主题网页的爬虫，更为适合。
以下是一个使用java实现的简单爬虫核心代码：
public void crawl() throws Throwable {
while (continueCrawling()) {
CrawlerUrl url = getNextUrl(); //获取待爬取队列中的下一个URL
if (url != null) {
printCrawlInfo();
String content = getContent(url); //获取URL的文本信息
//聚焦爬虫只爬取与主题内容相关的网页，这里采用正则匹配简单处理
if (isContentRelevant(content, this.regexpSearchPattern)) {
saveContent(url, content); //保存网页至本地
//获取网页内容中的链接，并放入待爬取队列中
Collection urlStrings = extractUrls(content, url);
addUrlsToUrlQueue(url, urlStrings);
} else {
System.out.println(url + " is not relevant ignoring ...");
}
//延时防止被对方屏蔽
Thread.sleep(this.delayBetweenUrls);
}
}
closeOutputStream();
}
private CrawlerUrl getNextUrl() throws Throwable {
CrawlerUrl nextUrl = null;
while ((nextUrl == null) && (!urlQueue.isEmpty())) {
CrawlerUrl crawlerUrl = this.urlQueue.remove();
//doWeHavePermissionToVisit：是否有权限访问该URL，友好的爬虫会根据网站提供的"Robot.txt"中配置的规则进行爬取
//isUrlAlreadyVisited：URL是否访问过，大型的搜索引擎往往采用BloomFilter进行排重，这里简单使用HashMap
//isDepthAcceptable：是否达到指定的深度上限。爬虫一般采取广度优先的方式。一些网站会构建爬虫陷阱（自动生成一些无效链接使爬虫陷入死循环），采用深度限制加以避免
if (doWeHavePermissionToVisit(crawlerUrl)
&& (!isUrlAlreadyVisited(crawlerUrl))
&& isDepthAcceptable(crawlerUrl)) {
nextUrl = crawlerUrl;
// System.out.println("Next url to be visited is " + nextUrl);
}
}
return nextUrl;
}
private String getContent(CrawlerUrl url) throws Throwable {
//HttpClient4.1的调用与之前的方式不同
HttpClient client = new DefaultHttpClient();
HttpGet httpGet = new HttpGet(url.getUrlString());
StringBuffer strBuf = new StringBuffer();
HttpResponse response = client.execute(httpGet);
if (HttpStatus.SC_OK == response.getStatusLine().getStatusCode()) {
HttpEntity entity = response.getEntity();
if (entity != null) {
BufferedReader reader = new BufferedReader(
new InputStreamReader(entity.getContent(), "UTF-8"));
String line = null;
if (entity.getContentLength() > 0) {
strBuf = new StringBuffer((int) entity.getContentLength());
while ((line = reader.readLine()) != null) {
strBuf.append(line);
}
}
}
if (entity != null) {
nsumeContent();
}
}
//将url标记为已访问
markUrlAsVisited(url);
return strBuf.toString();
}
public static boolean isContentRelevant(String content,
Pattern regexpPattern) {
boolean retValue = false;
if (content != null) {
//是否符合正则表达式的条件
Matcher m = regexpPattern.matcher(content.toLowerCase());
retValue = m.find();
}
return retValue;
}
public List extractUrls(String text, CrawlerUrl crawlerUrl) {
Map urlMap = new HashMap();
extractHttpUrls(urlMap, text);
extractRelativeUrls(urlMap, text, crawlerUrl);
return new ArrayList(urlMap.keySet());
}
private void extractHttpUrls(Map urlMap, String text) {
Matcher m = (text);
while (m.find()) {
String url = m.group();
String[] terms = url.split("a href=\"");
for (String term : terms) {
// System.out.println("Term = " + term);
if (term.startsWith("http")) {
int index = term.indexOf("\"");
if (index > 0) {
term = term.substring(0, index);
}
urlMap.put(term, term);
System.out.println("Hyperlink: " + term);
}
}
}
}
private void extractRelativeUrls(Map urlMap, String text,
CrawlerUrl crawlerUrl) {
Matcher m = relativeRegexp.matcher(text);
URL textURL = crawlerUrl.getURL();
String host = textURL.getHost();
while (m.find()) {
String url = m.group();
String[] terms = url.split("a href=\"");
for (String term : terms) {
if (term.startsWith("/")) {
int index = term.indexOf("\"");
if (index > 0) {
term = term.substring(0, index);
}
String s = //" + host + term;
urlMap.put(s, s);
System.out.println("Relative url: " + s);
}
}
}
}
public static void main(String[] args) {
try {
String url = "";
Queue urlQueue = new LinkedList();
String regexp = "java";
urlQueue.add(new CrawlerUrl(url, 0));
NaiveCrawler crawler = new NaiveCrawler(urlQueue, 100, 5, 1000L,
regexp);
// boolean allowCrawl = crawler.areWeAllowedToVisit(url);
// System.out.println("Allowed to crawl: " + url + " " +
// allowCrawl);
crawler.crawl();
} catch (Throwable t) {
System.out.println(t.toString());
t.printStackTrace();
}
}
⑦ python 新浪微博爬虫，求助
0x00. 起因
因为参加学校大学生创新竞赛，研究有关微博博文表达的情绪，需要大量微博博文，而网上无论是国内的某度、csdn，还是国外谷歌、gayhub、codeproject等都找不到想要的程序，没办法只能自己写一个程序了。
ps.在爬盟找到类似的程序，但是是windows下的，并且闭源，而且最终爬取保存的文件用notepad++打开有很多奇怪的问题，所以放弃了。
0x01. 基础知识
本程序由Python写成，所以基本的python知识是必须的。另外，如果你有一定的计算机网络基础，在前期准备时会有少走很多弯路。
对于爬虫，需要明确几点：
1. 对爬取对象分类，可以分为以下几种：第一种是不需要登录的，比如博主以前练手时爬的中国天气网，这种网页爬取难度较低，建议爬虫新手爬这类网页；第二种是需要登录的，如豆瓣、新浪微博，这些网页爬取难度较高；第三种独立于前两种，你想要的信息一般是动态刷新的，如AJAX或内嵌资源，这种爬虫难度最大，博主也没研究过，在此不细举（据同学说淘宝的商品评论就属于这类）。
2. 如果同一个数据源有多种形式（比如电脑版、手机版、客户端等），优先选取较为“纯净的”展现。比如新浪微博，有网页版，也有手机版，而且手机版可以用电脑浏览器访问，这时我优先选手机版新浪微博。
3. 爬虫一般是将网页下载到本地，再通过某些方式提取出感兴趣的信息。也就是说，爬取网页只完成了一半，你还要将你感兴趣的信息从下载下来的html文件中提取出来。这时就需要一些xml的知识了，在这个项目中，博主用的是XPath提取信息，另外可以使用XQuery等等其他技术，详情请访问w3cschool。
4. 爬虫应该尽量模仿人类，现在网站反爬机制已经比较发达，从验证码到禁IP，爬虫技术和反爬技术可谓不断博弈。
0x02. 开始
决定了爬虫的目标之后，首先应该访问目标网页，明确目标网页属于上述几种爬虫的哪种，另外，记录为了得到感兴趣的信息你需要进行的步骤，如是否需要登录，如果需要登录，是否需要验证码；你要进行哪些操作才能获得希望得到的信息，是否需要提交某些表单；你希望得到的信息所在页面的url有什么规律等等。
以下博文以博主项目为例，该项目爬取特定新浪微博用户从注册至今的所有微博博文和根据关键词爬取100页微博博文（大约1000条）。
0x03. 收集必要信息
首先访问目标网页，发现需要登录，进入登录页面如下新浪微博手机版登录页面
注意url后半段有很多形如”%xx”的转义字符，本文后面将会讲到。
从这个页面可以看到，登录新浪微博手机版需要填写账号、密码和验证码。
这个验证码是近期（本文创作于2016.3.11）才需要提供的，如果不需要提供验证码的话，将有两种方法进行登录。
第一种是填写账号密码之后执行js模拟点击“登录”按钮，博主之前写过一个Java爬虫就是利用这个方法，但是现在找不到工程了，在此不再赘述。
第二种需要一定HTTP基础，提交包含所需信息的HTTP POST请求。我们需要Wireshark 工具来抓取登录微博时我们发出和接收的数据包。如下图我抓取了在登录时发出和接收的数据包Wireshark抓取结果1
在搜索栏提供搜索条件”http”可得到所有http协议数据包，右侧info显示该数据包的缩略信息。图中蓝色一行是POST请求，并且info中有”login”，可以初步判断这个请求是登录时发出的第一个数据包，并且这个180.149.153.4应该是新浪微博手机版登录认证的服务器IP地址，此时我们并没有任何的cookie。
在序号为30是数据包中有一个从该IP发出的HTTP数据包，里面有四个Set-Cookie字段，这些cookie将是我们爬虫的基础。
Wireshark抓取结果2
早在新浪微博服务器反爬机制升级之前，登录是不需要验证码的，通过提交POST请求，可以拿到这些cookie，在项目源码中的TestCookie.py中有示例代码。
ps.如果没有wireshark或者不想这么麻烦的话，可以用浏览器的开发者工具，以chrome为例，在登录前打开开发者工具，转到Network，登录，可以看到发出和接收的数据，登录完成后可以看到cookies，如下图chrome开发者工具
接下来访问所需页面，查看页面url是否有某种规律。由于本项目目标之一是获取某用户的全部微博，所以直接访问该用户的微博页面，以央视新闻 为例。
央视新闻1
图为央视新闻微博第一页，观察该页面的url可以发现，新浪微博手机版的微博页面url组成是 “weibo.cn/(displayID)?page=(pagenum)” 。这将成为我们爬虫拼接url的依据。
接下来查看网页源码，找到我们希望得到的信息的位置。打开浏览器开发者工具，直接定位某条微博，可以发现它的位置，如下所示。
xpath
观察html代码发现，所有的微博都在<div>标签里，并且这个标签里有两个属性，其中class属性为”c”，和一个唯一的id属性值。得到这个信息有助于将所需信息提取出来。
另外，还有一些需要特别注意的因素
* 微博分为原创微博和转发微博
* 按照发布时间至当前时间的差距，在页面上有”MM分钟前”、”今天HH:MM”、”mm月dd日 HH:MM”、”yyyy-mm-dd HH:MM:SS”等多种显示时间的方式* 手机版新浪微博一个页面大约显示10条微博，所以要注意对总共页数进行记录以上几点都是细节，在爬虫和提取的时候需要仔细考虑。
0x04. 编码
1.爬取用户微博
本项目开发语言是Python 2.7，项目中用了一些第三方库，第三方库可以用pip的方法添加。
既然程序自动登录的想法被验证码挡住了，想要访问特定用户微博页面，只能使用者提供cookies了。
首先用到的是Python的request模块，它提供了带cookies的url请求。
import request
print request.get(url, cookies=cookies).content使用这段代码就可以打印带cookies的url请求页面结果。
首先取得该用户微博页面数，通过检查网页源码，查找到表示页数的元素，通过XPath等技术提取出页数。
页数
项目使用lxml模块对html进行XPath提取。
首先导入lxml模块，在项目里只用到了etree，所以from lxml import etree
然后利用下面的方法返回页数
def getpagenum(self):
url = self.geturl(pagenum=1)
html = requests.get(url, cookies=self.cook).content # Visit the first page to get the page number.
selector = etree.HTML(html)
pagenum = selector.xpath('//input[@name="mp"]/@value')[0]
return int(pagenum)
接下来就是不断地拼接url->访问url->下载网页。
需要注意的是，由于新浪反爬机制的存在，同一cookies访问页面过于“频繁”的话会进入类似于“冷却期”，即返回一个无用页面，通过分析该无用页面发现，这个页面在特定的地方会出现特定的信息，通过XPath技术来检查这个特定地方是否出现了特定信息即可判断该页面是否对我们有用。
def ispageneeded(html):
selector = etree.HTML(html)
try:
title = selector.xpath('//title')[0]
except:
return False
return title.text != '微博广场' and title.text != '微博'
如果出现了无用页面，只需简单地重新访问即可，但是通过后期的实验发现，如果长期处于过频访问，返回的页面将全是无用页面，程序也将陷入死循环。为了避免程序陷入死循环，博主设置了尝试次数阈值trycount，超过这个阈值之后方法自动返回。
下面代码片展示了单线程爬虫的方法。
def startcrawling(self, startpage=1, trycount=20):
attempt = 0
try:
os.mkdir(sys.path[0] + '/Weibo_raw/' + self.wanted)except Exception, e:
print str(e)
isdone = False
while not isdone and attempt < trycount:
try:
pagenum = self.getpagenum()
isdone = True
except Exception, e:
attempt += 1
if attempt == trycount:
return False
i = startpage
while i <= pagenum:
attempt = 0
isneeded = False
html = ''
while not isneeded and attempt < trycount:
html = self.getpage(self.geturl(i))
isneeded = self.ispageneeded(html)
if not isneeded:
attempt += 1
if attempt == trycount:
return False
self.savehtml(sys.path[0] + '/Weibo_raw/' + self.wanted + '/' + str(i) + '.txt', html)print str(i) + '/' + str(pagenum - 1)
i += 1
return True
考虑到程序的时间效率，在写好单线程爬虫之后，博主也写了多线程爬虫版本，基本思想是将微博页数除以线程数，如一个微博用户有100页微博，程序开10个线程，那么每个线程只负责10个页面的爬取，其他基本思想跟单线程类似，只需仔细处理边界值即可，在此不再赘述，感兴趣的同学可以直接看代码。另外，由于多线程的效率比较高，并发量特别大，所以服务器很容易就返回无效页面，此时trycount的设置就显得更重要了。博主在写这篇微博的时候，用一个新的cookies，多线程爬取现场测试了一下爬取北京邮电大学的微博，3976条微博全部爬取成功并提取博文，用时仅15s，实际可能跟cookies的新旧程度和网络环境有关，命令行设置如下，命令行意义在项目网址里有说明python main.py _T_WM=xxx; SUHB=xxx; SUB=xxx; gsid_CTandWM=xxx u bupt m 20 20爬取的工作以上基本介绍结束，接下来就是爬虫的第二部分，解析了。由于项目中提供了多线程爬取方法，而多线程一般是无序的，但微博博文是依靠时间排序的，所以项目采用了一种折衷的办法，将下载完成的页面保存在本地文件系统，每个页面以其页号为文件名，待爬取的工作结束后，再遍历文件夹内所有文件并解析。
通过前面的观察，我们已经了解到微博博文存在的标签有什么特点了，利用XPath技术，将这个页面里所有有这个特点的标签全部提取出来已经不是难事了。
在这再次提醒，微博分为转发微博和原创微博、时间表示方式。另外，由于我们的研究课题仅对微博文本感兴趣，所以配图不考虑。
def startparsing(self, parsingtime=datetime.datetime.now()):
basepath = sys.path[0] + '/Weibo_raw/' + self.uidfor filename in os.listdir(basepath):
if filename.startswith('.'):
continue
path = basepath + '/' + filename
f = open(path, 'r')
html = f.read()
selector = etree.HTML(html)
weiboitems = selector.xpath('//div[@class="c"][@id]')for item in weiboitems:
weibo = Weibo()
weibo.id = item.xpath('./@id')[0]
cmt = item.xpath('./div/span[@class="cmt"]')if len(cmt) != 0:
weibo.isrepost = True
weibo.content = cmt[0].text
else:
weibo.isrepost = False
ctt = item.xpath('./div/span[@class="ctt"]')[0]
if ctt.text is not None:
weibo.content += ctt.text
for a in ctt.xpath('./a'):
if a.text is not None:
weibo.content += a.text
if a.tail is not None:
weibo.content += a.tail
if len(cmt) != 0:
reason = cmt[1].text.split(u'\xa0')
if len(reason) != 1:
weibo.repostreason = reason[0]
ct = item.xpath('./div/span[@class="ct"]')[0]
time = ct.text.split(u'\xa0')[0]
weibo.time = self.gettime(self, time, parsingtime)self.weibos.append(weibo.__dict__)
f.close()
方法传递的参数parsingtime的设置初衷是，开发前期爬取和解析可能不是同时进行的（并不是严格的“同时”），微博时间显示是基于访问时间的，比如爬取时间是10:00，这时爬取到一条微博显示是5分钟前发布的，但如果解析时间是10:30，那么解析时间将错误，所以应该讲解析时间设置为10:00。到后期爬虫基本开发完毕，爬取工作和解析工作开始时间差距降低，时间差将是爬取过程时长，基本可以忽略。
解析结果保存在一个列表里，最后将这个列表以json格式保存到文件系统里，删除过渡文件夹，完成。
def save(self):
f = open(sys.path[0] + '/Weibo_parsed/' + self.uid + '.txt', 'w')jsonstr = json.mps(self.weibos, indent=4, ensure_ascii=False)f.write(jsonstr)
f.close()
2.爬取关键词
同样的，收集必要的信息。在微博手机版搜索页面敲入”python”，观察url，研究其规律。虽然第一页并无规律，但是第二页我们发现了规律，而且这个规律可以返回应用于第一页第一页
第二页
应用后第一页
观察url可以发现，对于关键词的搜索，url中的变量只有keyword和page（事实上，hideSearchFrame对我们的搜索结果和爬虫都没有影响），所以在代码中我们就可以对这两个变量进行控制。
另外，如果关键词是中文，那么url就需要对中文字符进行转换，如我们在搜索框敲入”开心”并搜索，发现url如下显示搜索开心
但复制出来却为
http://weibo.cn/search/mblog?hideSearchFrame=&keyword=%E5%BC%80%E5%BF%83&page=1幸好，python的urllib库有qoute方法处理中文转换的功能（如果是英文则不做转换），所以在拼接url前使用这个方法处理一下参数。
另外，考虑到关键词搜索属于数据收集阶段使用的方法，所以在此只提供单线程下载网页，如有多线程需要，大家可以按照多线程爬取用户微博的方法自己改写。最后，对下载下来的网页进行提取并保存（我知道这样的模块设计有点奇怪，打算重(xin)构(qing)时(hao)时再改，就先这样吧）。
def keywordcrawling(self, keyword):
realkeyword = urllib.quote(keyword) # Handle the keyword in Chinese.
try:
os.mkdir(sys.path[0] + '/keywords')
except Exception, e:
print str(e)
weibos = []
try:
highpoints = re.compile(u'[\U00010000-\U0010ffff]') # Handle emoji, but it seems doesn't work.
except re.error:
highpoints = re.compile(u'[\uD800-\uDBFF][\uDC00-\uDFFF]')pagenum = 0
isneeded = False
while not isneeded:
html = self.getpage('http://weibo.cn/search/mblog?keyword=%s&page=1' % realkeyword)isneeded = self.ispageneeded(html)
if isneeded:
selector = etree.HTML(html)
try:
pagenum = int(selector.xpath('//input[@name="mp"]/@value')[0])except:
pagenum = 1
for i in range(1, pagenum + 1):
try:
isneeded = False
while not isneeded:
html = self.getpage('http://weibo.cn/search/mblog?keyword=%s&page=%s' % (realkeyword, str(i)))isneeded = self.ispageneeded(html)
selector = etree.HTML(html)
weiboitems = selector.xpath('//div[@class="c"][@id]')for item in weiboitems:
cmt = item.xpath('./div/span[@class="cmt"]')if (len(cmt)) == 0:
ctt = item.xpath('./div/span[@class="ctt"]')[0]
if ctt.text is not None:
text = etree.tostring(ctt, method='text', encoding="unicode")tail = ctt.tail
if text.endswith(tail):
index = -len(tail)
text = text[1:index]
text = highpoints.sub(u'\u25FD', text) # Emoji handling, seems doesn't work.
weibotext = text
weibos.append(weibotext)
print str(i) + '/' + str(pagenum)
except Exception, e:
print str(e)
f = open(sys.path[0] + '/keywords/' + keyword + '.txt', 'w')try:
f.write(json.mps(weibos,indent=4,ensure_ascii=False))except Exception,ex:
print str(ex)
finally:
f.close()
博主之前从未写过任何爬虫程序，为了获取新浪微博博文，博主先后写了3个不同的爬虫程序，有Python，有Java，爬虫不能用了是很正常的，不要气馁，爬虫程序和反爬机制一直都在不断博弈中，道高一尺魔高一丈。
另. 转载请告知博主，如果觉得博主帅的话就可以不用告知了
⑧ Java网络爬虫怎么实现
网络爬虫是一个自动提取网页的程序，它为搜索引擎从万维网上下载网页，是搜索引擎的重要组成。x0dx0a传统爬虫从一个或若干初始网页的URL开始，获得初始网页上的URL，在抓取网页的过程中，不断从当前页面上抽取新的URL放入队列，直到满足系统的一定停止条件。对于垂直搜索来说，聚焦爬虫，即有针对性地爬取特定主题网页的爬虫，更为适合。x0dx0ax0dx0a以下是一个使用java实现的简单爬虫核心代码：x0dx0apublic void crawl() throws Throwable { x0dx0a while (continueCrawling()) { x0dx0a CrawlerUrl url = getNextUrl(); //获取待爬取队列中的下一个URL x0dx0a if (url != null) { x0dx0a printCrawlInfo(); x0dx0a String content = getContent(url); //获取URL的文本信息 x0dx0a x0dx0a //聚焦爬虫只爬取与主题内容相关的网页，这里采用正则匹配简单处理 x0dx0a if (isContentRelevant(content, this.regexpSearchPattern)) { x0dx0a saveContent(url, content); //保存网页至本地 x0dx0a x0dx0a //获取网页内容中的链接，并放入待爬取队列中 x0dx0a Collection urlStrings = extractUrls(content, url); x0dx0a addUrlsToUrlQueue(url, urlStrings); x0dx0a } else { x0dx0a System.out.println(url + " is not relevant ignoring ..."); x0dx0a } x0dx0a x0dx0a //延时防止被对方屏蔽 x0dx0a Thread.sleep(this.delayBetweenUrls); x0dx0a } x0dx0a } x0dx0a closeOutputStream(); x0dx0a}x0dx0aprivate CrawlerUrl getNextUrl() throws Throwable { x0dx0a CrawlerUrl nextUrl = null; x0dx0a while ((nextUrl == null) && (!urlQueue.isEmpty())) { x0dx0a CrawlerUrl crawlerUrl = this.urlQueue.remove(); x0dx0a //doWeHavePermissionToVisit：是否有权限访问该URL，友好的爬虫会根据网站提供的"Robot.txt"中配置的规则进行爬取 x0dx0a //isUrlAlreadyVisited：URL是否访问过，大型的搜索引擎往往采用BloomFilter进行排重，这里简单使用HashMap x0dx0a //isDepthAcceptable：是否达到指定的深度上限。爬虫一般采取广度优先的方式。一些网站会构建爬虫陷阱（自动生成一些无效链接使爬虫陷入死循环），采用深度限制加以避免 x0dx0a if (doWeHavePermissionToVisit(crawlerUrl) x0dx0a && (!isUrlAlreadyVisited(crawlerUrl)) x0dx0a && isDepthAcceptable(crawlerUrl)) { x0dx0a nextUrl = crawlerUrl; x0dx0a // System.out.println("Next url to be visited is " + nextUrl); x0dx0a } x0dx0a } x0dx0a return nextUrl; x0dx0a}x0dx0aprivate String getContent(CrawlerUrl url) throws Throwable { x0dx0a //HttpClient4.1的调用与之前的方式不同 x0dx0a HttpClient client = new DefaultHttpClient(); x0dx0a HttpGet httpGet = new HttpGet(url.getUrlString()); x0dx0a StringBuffer strBuf = new StringBuffer(); x0dx0a HttpResponse response = client.execute(httpGet); x0dx0a if (HttpStatus.SC_OK == response.getStatusLine().getStatusCode()) { x0dx0a HttpEntity entity = response.getEntity(); x0dx0a if (entity != null) { x0dx0a BufferedReader reader = new BufferedReader( x0dx0a new InputStreamReader(entity.getContent(), "UTF-8")); x0dx0a String line = null; x0dx0a if (entity.getContentLength() > 0) { x0dx0a strBuf = new StringBuffer((int) entity.getContentLength()); x0dx0a while ((line = reader.readLine()) != null) { x0dx0a strBuf.append(line); x0dx0a } x0dx0a } x0dx0a } x0dx0a if (entity != null) { x0dx0a nsumeContent(); x0dx0a } x0dx0a } x0dx0a //将url标记为已访问 x0dx0a markUrlAsVisited(url); x0dx0a return strBuf.toString(); x0dx0a}x0dx0apublic static boolean isContentRelevant(String content, x0dx0aPattern regexpPattern) { x0dx0a boolean retValue = false; x0dx0a if (content != null) { x0dx0a //是否符合正则表达式的条件 x0dx0a Matcher m = regexpPattern.matcher(content.toLowerCase()); x0dx0a retValue = m.find(); x0dx0a } x0dx0a return retValue; x0dx0a}x0dx0apublic List extractUrls(String text, CrawlerUrl crawlerUrl) { x0dx0a Map urlMap = new HashMap(); x0dx0a extractHttpUrls(urlMap, text); x0dx0a extractRelativeUrls(urlMap, text, crawlerUrl); x0dx0a return new ArrayList(urlMap.keySet()); x0dx0a} x0dx0aprivate void extractHttpUrls(Map urlMap, String text) { x0dx0a Matcher m = (text); x0dx0a while (m.find()) { x0dx0a String url = m.group(); x0dx0a String[] terms = url.split("a href=\""); x0dx0a for (String term : terms) { x0dx0a // System.out.println("Term = " + term); x0dx0a if (term.startsWith("http")) { x0dx0a int index = term.indexOf("\""); x0dx0a if (index > 0) { x0dx0a term = term.substring(0, index); x0dx0a } x0dx0a urlMap.put(term, term); x0dx0a System.out.println("Hyperlink: " + term); x0dx0a } x0dx0a } x0dx0a } x0dx0a} x0dx0aprivate void extractRelativeUrls(Map urlMap, String text, x0dx0a CrawlerUrl crawlerUrl) { x0dx0a Matcher m = relativeRegexp.matcher(text); x0dx0a URL textURL = crawlerUrl.getURL(); x0dx0a String host = textURL.getHost(); x0dx0a while (m.find()) { x0dx0a String url = m.group(); x0dx0a String[] terms = url.split("a href=\""); x0dx0a for (String term : terms) { x0dx0a if (term.startsWith("/")) { x0dx0a int index = term.indexOf("\""); x0dx0a if (index > 0) { x0dx0a term = term.substring(0, index); x0dx0a } x0dx0a String s = //" + host + term; x0dx0a urlMap.put(s, s); x0dx0a System.out.println("Relative url: " + s); x0dx0a } x0dx0a } x0dx0a } x0dx0a x0dx0a}x0dx0apublic static void main(String[] args) { x0dx0a try { x0dx0a String url = ""; x0dx0a Queue urlQueue = new LinkedList(); x0dx0a String regexp = "java"; x0dx0a urlQueue.add(new CrawlerUrl(url, 0)); x0dx0a NaiveCrawler crawler = new NaiveCrawler(urlQueue, 100, 5, 1000L, x0dx0a regexp); x0dx0a // boolean allowCrawl = crawler.areWeAllowedToVisit(url); x0dx0a // System.out.println("Allowed to crawl: " + url + " " + x0dx0a // allowCrawl); x0dx0a crawler.crawl(); x0dx0a } catch (Throwable t) { x0dx0a System.out.println(t.toString()); x0dx0a t.printStackTrace(); x0dx0a } x0dx0a}
⑨ 如何写爬虫程序爬取豆瓣网或者新浪微博里的内容
抓包，这个你搜一下网络很多博客有写
⑩ 如何写爬虫程序爬取豆瓣网或者新浪微博里的内容
在面向对象的高级语言中，早已有人将http请求封装成了类库，你只需要调下接口，就能获得目标网页的源码。所以程序需要做的就是请求目标url，获取页面的源码，解析html。基本流程是：
获取目标页面源码，方法：调用对应的类库。
解析html文件，提取出自己想要的信息。方法：正则表达式或者解析html的库。
按照上述步骤，C++（Qt）涉及的类是：
WebView，它的内核其实就是webkit，所以它就是一个功能原始的浏览器，他内置能够返回页面源码的函数，接受一个url的string类型参数，返回一个QString对象。
WebView类有方法能够处理DOM。
C#（.net）涉及的类是：
WebClient，WebRequest，HttpWebRequest等类，第一个封装得比较高级，写法简单，后面两个封装得低级，写起来麻烦但是用起来灵活，HttpWebRequest是WebRequest的一个子类。
Html Agility Pack。
Python涉及的包是：
urllib，urllib2，前者仅可以接受URL，不能伪装Header，但是需要用它的一个函数对post数据进行编码。类似于浏览器的有Selenium。
BeautifulSoup。
上面三种相比，python写法最简单，操作也灵活，要获取源码只要写一句话就行。字符串处理python也毫不逊色于C#和C++。