怎么利用爬虫编译出小程序的源码_求网络视频爬虫的程序源代码用java开发的

❶ 有一个任务，说是用java 编程，编一个类似网络爬虫的东西，可以将网页上的文字小说提取出来变为txt文档。

如果单线程来实现，就是一个主程序去爬，不断遍历。很简单的。
如果多线程，就主程序控制多线程去进行遍历。最好用一个线程池来进行管理，否则会随着遍历系统资源消耗过大的。

❷ ajax框架的原理，以及怎样用爬虫程序来进行框架识别，最好有ajax爬虫的源代码。

1、AJAX理解：
异步的javascript 与xml
包含的主要技术点：异步；javascript;xml
2、AJAX的技术组成：
AJAX不是一种技术，而是多种传统技术的组合
HTML 和 CSS
JavaScript
XML和XSLT
DOM
XMLHttpRequest对象
3、AJAX的工作原理：
传统的b/s操作，客户端执行的是与服务器端的同步操作，必须等待服务器有返回信息后才能在客户端显示出来，而是客户端有明确的刷新过程。
在AJAX的工作中，在传统的浏览器端，服务器端的基础上，添加了一个称为AJAX引擎的中间层，来实现异步的数据传输。
AJAX引擎，主要是通过一个XMLHttpRequest对象实现的。
4、XMLHttpRequest对象
通过XMLHttpRequest，AJAX可以像桌面应用程序一样，只同服务器进行数据层面的交互，而不用每次都刷新页面。这样，即减轻了服务器的负担，又加快了响应速度，缩短了用户等待的时间。
XMLHttpRequest是AJAX中最重要的一个对象。
XMLHttpRequest在IE5中，就已经实现了，而且在不同浏览器中是兼容的。所以，在开发中可以通过固定的方法来获得
5、AJAX的核心工作机制
（1）初始化XMLHttpRequest对象
（2）客户端发送请求
（3）服务器接收请求并进行处理
（4）服务器返回响应数据
（5）客户端接受响应数据
（6）根据响应数据在客户端进行显示
根据以上流程，可形成初步的AJAX的开发框架
<script language="javascript">
var XMLHttpReq;
//创建XMLHttpRequest对象
function createXMLHttpRequest() {
if(window.XMLHttpRequest) { //Mozilla 浏览器
XMLHttpReq = new XMLHttpRequest();
}
else if (window.ActiveXObject) { // IE浏览器
try {
XMLHttpReq = new ActiveXObject("Msxml2.XMLHTTP");
} catch (e) {
try {
XMLHttpReq = new ActiveXObject("Microsoft.XMLHTTP");
} catch (e) {}
}
}
}
或者是函数如下：
var XMLHttpReq;
function createXMLHttpRequest() {
if(window.ActiveXObject){
XMLHttpReq = new ActiveXObject("Microsoft.XMLHTTP");
}else{
XMLHttpReq = new XMLHttpRequest();
}
}
//发送请求函数
function sendRequest(url) {
createXMLHttpRequest();
XMLHttpReq.open("GET", url, true);
XMLHttpReq.onreadystatechange = processResponse;//指定响应函数
XMLHttpReq.send(null); // 发送请求
}
// 处理返回信息函数
function processResponse() {
if (XMLHttpReq.readyState == 4) { // 判断对象状态
if (XMLHttpReq.status == 200) { // 信息已经成功返回，开始处理信息
var res=XMLHttpReq.responseXML.getElementsByTagName("res")[0].firstChild.data;
window.alert(res);
} else { //页面不正常
window.alert("您所请求的页面有异常。");
}
}
}
//实现自己功能的函数，在此函数中根据需要调用请求发送的函数sendRequest

❸ 求网络视频爬虫的程序源代码，用java开发的

apache上有个Lucence项目，是开源的搜索引擎。
你可以下载一份源代码。
中国还有一个中文网站，还有像Lucence In Action 这本书到处都可以下载
估计www.xunlei.com上就有

❹ 如何使用python爬虫jfinal

一、gzip/deflate支持
现在的网页普遍支持gzip压缩，这往往可以解决大量传输时间，以VeryCD的主页为例，未压缩版本247K，压缩了以后45K，为原来的1/5。这就意味着抓取速度会快5倍。
然而python的urllib/urllib2默认都不支持压缩，要返回压缩格式，必须在request的header里面写明’accept-
encoding’，然后读取response后更要检查header查看是否有’content-encoding’一项来判断是否需要解码，很繁琐琐
碎。如何让urllib2自动支持gzip, defalte呢？
其实可以继承BaseHanlder类，然后build_opener的方式来处理：
import urllib2
from gzip import GzipFile
from StringIO import StringIO
class ContentEncodingProcessor(urllib2.BaseHandler):
"""A handler to add gzip capabilities to urllib2 requests """

# add headers to requests
def http_request(self, req):
req.add_header("Accept-Encoding", "gzip, deflate")
return req

# decode
def http_response(self, req, resp):
old_resp = resp
# gzip
if resp.headers.get("content-encoding") == "gzip":
gz = GzipFile(
fileobj=StringIO(resp.read()),
mode="r"
)
resp = urllib2.addinfourl(gz, old_resp.headers, old_resp.url, old_resp.code)
resp.msg = old_resp.msg
# deflate
if resp.headers.get("content-encoding") == "deflate":
gz = StringIO( deflate(resp.read()) )
resp = urllib2.addinfourl(gz, old_resp.headers, old_resp.url, old_resp.code) # 'class to add info() and
resp.msg = old_resp.msg
return resp

# deflate support
import zlib
def deflate(data): # zlib only provides the zlib compress format,not the deflate format;
try: # so on top of all there's this workaround:
return zlib.decompress(data, -zlib.MAX_WBITS)
except zlib.error:
return zlib.decompress(data)
然后就简单了，
encoding_support = ContentEncodingProcessor
opener = urllib2.build_opener( encoding_support, urllib2.HTTPHandler )

#直接用opener打开网页，如果服务器支持gzip/defalte则自动解压缩
content = opener.open(url).read()
二、更方便地多线程
总结一文的确提及了一个简单的多线程模板，但是那个东东真正应用到程序里面去只会让程序变得支离破碎，不堪入目。在怎么更方便地进行多线程方面我也动了一番脑筋。先想想怎么进行多线程调用最方便呢？
1、用twisted进行异步I/O抓取
事实上更高效的抓取并非一定要用多线程，也可以使用异步I/O法：直接用twisted的getPage方法，然后分别加上异步I/O结束时的callback和errback方法即可。例如可以这么干：
from twisted.web.client import getPage
from twisted.internet import reactor

links = [ 'http://www.verycd.com/topics/%d/'%i for i in range(5420,5430) ]

def parse_page(data,url):
print len(data),url

def fetch_error(error,url):
print error.getErrorMessage(),url

# 批量抓取链接
for url in links:
getPage(url,timeout=5)
.addCallback(parse_page,url) #成功则调用parse_page方法
.addErrback(fetch_error,url) #失败则调用fetch_error方法

reactor.callLater(5, reactor.stop) #5秒钟后通知reactor结束程序
reactor.run()
twisted人如其名，写的代码实在是太扭曲了，非正常人所能接受，虽然这个简单的例子看上去还好；每次写twisted的程序整个人都扭曲了，累得不得了，文档等于没有，必须得看源码才知道怎么整，唉不提了。
如果要支持gzip/deflate，甚至做一些登陆的扩展，就得为twisted写个新的HTTPClientFactory类诸如此类，我这眉头真是大皱，遂放弃。有毅力者请自行尝试。
这篇讲怎么用twisted来进行批量网址处理的文章不错，由浅入深，深入浅出，可以一看。
2、设计一个简单的多线程抓取类
还是觉得在urllib之类python“本土”的东东里面折腾起来更舒服。试想一下，如果有个Fetcher类，你可以这么调用
f = Fetcher(threads=10) #设定下载线程数为10
for url in urls:
f.push(url) #把所有url推入下载队列
while f.taskleft(): #若还有未完成下载的线程
content = f.pop() #从下载完成队列中取出结果
do_with(content) # 处理content内容
这么个多线程调用简单明了，那么就这么设计吧，首先要有两个队列，用Queue搞定，多线程的基本架构也和“技巧总结”一文类似，push方法和
pop方法都比较好处理，都是直接用Queue的方法，taskleft则是如果有“正在运行的任务”或者”队列中的任务”则为是，也好办，于是代码如
下：
import urllib2
from threading import Thread,Lock
from Queue import Queue
import time

class Fetcher:
def __init__(self,threads):
self.opener = urllib2.build_opener(urllib2.HTTPHandler)
self.lock = Lock() #线程锁
self.q_req = Queue() #任务队列
self.q_ans = Queue() #完成队列
self.threads = threads
for i in range(threads):
t = Thread(target=self.threadget)
t.setDaemon(True)
t.start()
self.running = 0

def __del__(self): #解构时需等待两个队列完成
time.sleep(0.5)
self.q_req.join()
self.q_ans.join()

def taskleft(self):
return self.q_req.qsize()+self.q_ans.qsize()+self.running

def push(self,req):
self.q_req.put(req)

def pop(self):
return self.q_ans.get()

def threadget(self):
while True:
req = self.q_req.get()
with self.lock: #要保证该操作的原子性，进入critical area
self.running += 1
try:
ans = self.opener.open(req).read()
except Exception, what:
ans = ''
print what
self.q_ans.put((req,ans))
with self.lock:
self.running -= 1
self.q_req.task_done()
time.sleep(0.1) # don't spam

if __name__ == "__main__":
links = [ 'http://www.verycd.com/topics/%d/'%i for i in range(5420,5430) ]
f = Fetcher(threads=10)
for url in links:
f.push(url)
while f.taskleft():
url,content = f.pop()
print url,len(content)

❺ 爬虫获取和DOM中类似的源码有什么方法

jslang
jslang
天际的海浪 T10
Blank Blank Blank

在控制台DOM中看到的代码是当前页面中正在显示的内容，这包含由js程序动态创建和修改的部分，并且会根据用户操作执行js程序修改页面而实时更新

❻ 如何利用python写爬虫程序

利用python写爬虫程序的方法：

1、先分析网站内容，红色部分即是网站文章内容div。

❼ 跪求一份java网络爬虫的源代码急用！！

希望能帮到你 . . . 这个可以解决你的问题但是没有样式的.只是爬了源代码

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileOutputStream;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.net.HttpURLConnection;
import java.net.URL;
public class WebPageSource {
public static void main(String args[]){
URL url;
int responsecode;
HttpURLConnection urlConnection;
BufferedReader reader;
BufferedWriter writer;
String line;
try{
//生成一个URL对象，要获取源代码的网页地址为：http://www.sina.com.cn
url=new URL("http://www.sina.com.cn");
//打开URL
urlConnection = (HttpURLConnection)url.openConnection();
//获取服务器响应代码
responsecode=urlConnection.getResponseCode();
if(responsecode==200){
//得到输入流，即获得了网页的内容
reader=new BufferedReader(new InputStreamReader(urlConnection.getInputStream(),"GBK"));
writer = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(new File("d://test.txt"))));
while((line=reader.readLine())!=null){
writer.write(line);
writer.newLine();
}
}
else{
System.out.println("获取不到网页的源码，服务器响应代码为："+responsecode);
}
}
catch(Exception e){
System.out.println("获取不到网页的源码,出现异常："+e);
}
}
}

❽ 求一个网络爬虫的完整代码，需要能自动递归爬取站内页面



importjava.net.*;
importjava.io.*;
importjava.util.regex.*;

//搜索Web爬行者
{

	/*
	*disallowListCache缓存robot不允许搜索的URL。Robot协议在Web站点的根目录下设置一个robots.txt文件,
	*规定站点上的哪些页面是限制搜索的。搜索程序应该在搜索过程中跳过这些区域,下面是robots.txt的一个例子:#robots.txtfor
	*http://somehost.com/User-agent:*Disallow:/cgi-bin/Disallow:
	*/registration#/:/login
	*/

	privateHashMap<String,ArrayList<String>>disallowListCache=newHashMap<String,ArrayList<String>>();
	ArrayList<String>errorList=newArrayList<String>();//错误信息
	ArrayList<String>result=newArrayList<String>();//搜索到的结果
	StringstartUrl;//开始搜索的起点
	intmaxUrl;//最大处理的url数
	StringsearchString;//要搜索的字符串(英文)
	booleancaseSensitive=false;//是否区分大小写
	booleanlimitHost=false;//是否在限制的主机内搜索

	publicSearchCrawler(StringstartUrl,intmaxUrl,StringsearchString){
		this.startUrl=startUrl;
		this.maxUrl=maxUrl;
		this.searchString=searchString;
	}

	publicArrayList<String>getResult(){
		returnresult;
	}

	publicvoidrun(){//启动搜索线程

		crawl(startUrl,maxUrl,searchString,limitHost,caseSensitive);
	}

	//检测URL格式
	privateURLverifyUrl(Stringurl){
		//只处理HTTPURLs.
		if(!url.toLowerCase().startsWith("http://"))
			returnnull;

		URLverifiedUrl=null;
		try{
			verifiedUrl=newURL(url);
		}catch(Exceptione){
			returnnull;
		}

		returnverifiedUrl;
	}

	//检测robot是否允许访问给出的URL.
	privatebooleanisRobotAllowed(URLurlToCheck){
		Stringhost=urlToCheck.getHost().toLowerCase();//获取给出url的主机
		//System.out.println("主机="+host);

		//获取主机不允许搜索的URL缓存
		ArrayList<String>disallowList=disallowListCache.get(host);

		//如果还没有缓存,下载并缓存。
		if(disallowList==null){
			disallowList=newArrayList<String>();
			try{
				URLrobotsFileUrl=newURL("http://"+host+"/robots.txt");
				BufferedReaderreader=newBufferedReader(
						newInputStreamReader(robotsFileUrl.openStream()));

				//读robot文件，创建不允许访问的路径列表。
				Stringline;
				while((line=reader.readLine())!=null){
					if(line.indexOf("Disallow:")==0){//是否包含"Disallow:"
						StringdisallowPath=line.substring("Disallow:"
								.length());//获取不允许访问路径

						//检查是否有注释。
						intcommentIndex=disallowPath.indexOf("#");
						if(commentIndex!=-1){
							disallowPath=disallowPath.substring(0,
									commentIndex);//去掉注释
						}

						disallowPath=disallowPath.trim();
						disallowList.add(disallowPath);
					}
				}

				//缓存此主机不允许访问的路径。
				disallowListCache.put(host,disallowList);
			}catch(Exceptione){
				returntrue;//web站点根目录下没有robots.txt文件,返回真
			}
		}

		Stringfile=urlToCheck.getFile();
		//System.out.println("文件getFile()="+file);
		for(inti=0;i<disallowList.size();i++){
			Stringdisallow=disallowList.get(i);
			if(file.startsWith(disallow)){
				returnfalse;
			}
		}

		returntrue;
	}

	privateStringdownloadPage(URLpageUrl){
		try{
			//OpenconnectiontoURLforreading.
			BufferedReaderreader=newBufferedReader(newInputStreamReader(
					pageUrl.openStream()));

			//Readpageintobuffer.
			Stringline;
			StringBufferpageBuffer=newStringBuffer();
			while((line=reader.readLine())!=null){
				pageBuffer.append(line);
			}

			returnpageBuffer.toString();
		}catch(Exceptione){
		}

		returnnull;
	}

	//从URL中去掉"www"
	privateStringremoveWwwFromUrl(Stringurl){
		intindex=url.indexOf("://www.");
		if(index!=-1){
			returnurl.substring(0,index+3)+url.substring(index+7);
		}

		return(url);
	}

	//解析页面并找出链接
	privateArrayList<String>retrieveLinks(URLpageUrl,StringpageContents,
			HashSetcrawledList,booleanlimitHost){
		//用正则表达式编译链接的匹配模式。
		Patternp=Pattern.compile("<a\s+href\s*=\s*"?(.*?)["|>]",
				Pattern.CASE_INSENSITIVE);
		Matcherm=p.matcher(pageContents);

		ArrayList<String>linkList=newArrayList<String>();
		while(m.find()){
			Stringlink=m.group(1).trim();

			if(link.length()<1){
				continue;
			}

			//跳过链到本页面内链接。
			if(link.charAt(0)=='#'){
				continue;
			}

			if(link.indexOf("mailto:")!=-1){
				continue;
			}

			if(link.toLowerCase().indexOf("javascript")!=-1){
				continue;
			}

			if(link.indexOf("://")==-1){
				if(link.charAt(0)=='/'){//处理绝对地
					link="http://"+pageUrl.getHost()+":"
							+pageUrl.getPort()+link;
				}else{
					Stringfile=pageUrl.getFile();
					if(file.indexOf('/')==-1){//处理相对地址
						link="http://"+pageUrl.getHost()+":"
								+pageUrl.getPort()+"/"+link;
					}else{
						Stringpath=file.substring(0,
								file.lastIndexOf('/')+1);
						link="http://"+pageUrl.getHost()+":"
								+pageUrl.getPort()+path+link;
					}
				}
			}

			intindex=link.indexOf('#');
			if(index!=-1){
				link=link.substring(0,index);
			}

			link=removeWwwFromUrl(link);

			URLverifiedLink=verifyUrl(link);
			if(verifiedLink==null){
				continue;
			}

			/*如果限定主机，排除那些不合条件的URL*/
			if(limitHost
					&&!pageUrl.getHost().toLowerCase()
							.equals(verifiedLink.getHost().toLowerCase())){
				continue;
			}

			//跳过那些已经处理的链接.
			if(crawledList.contains(link)){
				continue;
			}

			linkList.add(link);
		}

		return(linkList);
	}

	//搜索下载Web页面的内容，判断在该页面内有没有指定的搜索字符串

	(StringpageContents,
			StringsearchString,booleancaseSensitive){
		StringsearchContents=pageContents;
		if(!caseSensitive){//如果不区分大小写
			searchContents=pageContents.toLowerCase();
		}

		Patternp=Pattern.compile("[\s]+");
		String[]terms=p.split(searchString);
		for(inti=0;i<terms.length;i++){
			if(caseSensitive){
				if(searchContents.indexOf(terms[i])==-1){
					returnfalse;
				}
			}else{
				if(searchContents.indexOf(terms[i].toLowerCase())==-1){
					returnfalse;
				}
			}
		}

		returntrue;
	}

	//执行实际的搜索操作
	publicArrayList<String>crawl(StringstartUrl,intmaxUrls,
			StringsearchString,booleanlimithost,booleancaseSensitive){

		System.out.println("searchString="+searchString);
		HashSet<String>crawledList=newHashSet<String>();
		LinkedHashSet<String>toCrawlList=newLinkedHashSet<String>();

		if(maxUrls<1){
			errorList.add("InvalidMaxURLsvalue.");
			System.out.println("InvalidMaxURLsvalue.");
		}

		if(searchString.length()<1){
			errorList.add("MissingSearchString.");
			System.out.println("MissingsearchString");
		}

		if(errorList.size()>0){
			System.out.println("err!!!");
			returnerrorList;
		}

		//从开始URL中移出www
		startUrl=removeWwwFromUrl(startUrl);

		toCrawlList.add(startUrl);
		while(toCrawlList.size()>0){

			if(maxUrls!=-1){
				if(crawledList.size()==maxUrls){
					break;
				}
			}

			//GetURLatbottomofthelist.
			Stringurl=toCrawlList.iterator().next();

			//RemoveURLfromthetocrawllist.
			toCrawlList.remove(url);

			//ConvertstringurltoURLobject.
			URLverifiedUrl=verifyUrl(url);

			//.
			if(!isRobotAllowed(verifiedUrl)){
				continue;
			}

			//增加已处理的URL到crawledList
			crawledList.add(url);
			StringpageContents=downloadPage(verifiedUrl);

			if(pageContents!=null&&pageContents.length()>0){
				//从页面中获取有效的链接
				ArrayList<String>links=retrieveLinks(verifiedUrl,
						pageContents,crawledList,limitHost);

				toCrawlList.addAll(links);

				if(searchStringMatches(pageContents,searchString,
						caseSensitive)){
					result.add(url);
					System.out.println(url);
				}
			}

		}
		returnresult;
	}

	//主函数
	publicstaticvoidmain(String[]args){
		if(args.length!=3){
			System.out
					.println("Usage:");
			return;
		}
		intmax=Integer.parseInt(args[1]);
		SearchCrawlercrawler=newSearchCrawler(args[0],max,args[2]);
		Threadsearch=newThread(crawler);
		System.out.println("Startsearching...");
		System.out.println("result:");
		search.start();

	}
}

参考：http://www.cnblogs.com/tjsquall/archive/2007/12/22/1010831.html

❾ 你好，我有个JAVA的爬虫代码，txt的，但是不知道怎么使用它爬网络上的数据。可不可以指点下

你有的是代码（源码）？如果是源码，请把它另存为.java文件，然后使用jdk编译成class文件，然后用java命令执行试试。

导航:首页 > 源码编译 > 怎么利用爬虫编译出小程序的源码

怎么利用爬虫编译出小程序的源码

与怎么利用爬虫编译出小程序的源码相关的资料