java实现的简单网页爬虫：Servlet + MySQL5.5

最新推荐文章于 2021-07-02 16:17:24 发布

春秋战国程序猿

最新推荐文章于 2021-07-02 16:17:24 发布

阅读量3.2k

点赞数

分类专栏： Java开发网络爬虫 HttpClient 文章标签： javaWeb开发 servlet mysql 网络爬虫

本文链接：https://blog.csdn.net/reggergdsg/article/details/50451247

版权

Java开发同时被 3 个专栏收录

49 篇文章 2 订阅

订阅专栏

网络爬虫

4 篇文章 0 订阅

订阅专栏

HttpClient

1 篇文章 0 订阅

订阅专栏

* * JavaSpier的目标：
*
* 1，我们要获取的是
* http://commons.apache.org/proper/commons-fileupload/apidocs/src-html/org/apache/commons/
* Apache org.apache.commons站点下的所有源代码文件，也就是最终的.html文件。
*,2，我们要对获取到的源代码网页，进行格式化处理，以java源代码的方式，保存到指定文件中。
* 3，每个.html页面保存到对应的.java文件中。这些文件都保存到电脑的指定目录下。
*
* JavaSpier 1.3版本我们实现了以下功能：
* 1，自动检索当前网址所在网页的HTML内容，并从中抽取所有的URL地址，然后保存到数据库中；
* 2，需要说明的是，这里保存的网址，有的是.html结尾的，有的是一个目录，比如.../fileupload/
* 3，在JavaSpier 1.3版本，我们并没有将网页内容保存到文件中，因为我们的目的是先获得所有的目标网址，然后统一处理；
*
*/

该系统，我们使用的servlet + MySQL5.5来实现的。

系统关键文件结构如下：

前台JSP页面：
/Spider/WebRoot/WEB-INF/spider/GetAllUrl_JavaSpider_1_3.jsp
/Spider/WebRoot/WEB-INF/spider/Error.jsp
/Spider/WebRoot/WEB-INF/spider/Success.jsp

后台java文件：
/Spider/src/com/spider/dao/JavaSpider_1_3_Dao.java                              Dao层接口
/Spider/src/com/spider/dao/impl/JavaSpider_1_3_DaoImpl.java             Dao层实现类

/Spider/src/com/spider/service/JavaSpider_1_3_Service.java                  Service层接口
/Spider/src/com/spider/service/impl/JavaSpider_1_3_ServiceImpl.java Service层实现类

/Spider/src/com/spider/servlet/GetAllUrl_JavaSpider_1_3_Servlet.java Servlet控制类

/Spider/src/com/spider/java/JavaSpiderBase_1_3.java                              爬虫核心接口
/Spider/src/com/spider/java/JavaSpider_1_3.java                            爬虫核心接口实现类
/Spider/src/com/spider/java/JavaSpider_1_3_URLParser.java             对网页中的链接进行处理的工具类，以行为单位，获取网页中的所有URL地址
/Spider/src/com/spider/java/JavaSpider_1_3_HTMLParser.java              对网页进行抽取的工具类，也就是去掉HTML标签，得到网页内容

配置文件：

/Spider/WebRoot/WEB-INF/web.xml

下面贴上所有文件的源代码，可能较多，大家耐心...

/Spider/WebRoot/WEB-INF/spider/GetAllUrl_JavaSpider_1_3.jsp

<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<%
String path = request.getContextPath();
String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";
%>

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
  <head>
    <base href="<%=basePath%>">
    <title>JavaSpider 抓取所有的目标网址，保存到数据库</title>
	<meta http-equiv="pragma" content="no-cache">
	<meta http-equiv="cache-control" content="no-cache">
	<meta http-equiv="expires" content="0">    
	<meta http-equiv="keywords" content="keyword1,keyword2,keyword3">
	<meta http-equiv="description" content="This is my page">
</head>
  
<body>
<div>
    <form class="STYLE-NAME" action="GetAllUrl_JavaSpider_1_3_Servlet" method="post">
    <label>
    <span>  JavaSpier 1.3版本</span>
    </label><br>
    <label>
    <span>  我们进行了以下改进：</span>
    </label><br>
    <label>
    <span>  1，从指定网页，抓取该网页中的所有的网址，保存到数据库</span>
    </label><br>
    <label>
    <span>  2，需要说明的是，这里保存的网址，有的是.html结尾的，有的是一个目录，比如.../fileupload/</span>
    </label><br>
    <label>
    <span>  3，比如下面这个网址，我们可以获取该网址下，所有的二级网址，并保存到数据库中...</span>
    </label><br>
    <label>
    <span>  http://commons.apache.org/proper/commons-fileupload/apidocs/src-html/org/apache/commons/fileupload/</span>
    </label><br>
    <label>
    <span>后缀级别level：</span>
    <input type="text" name="LEVEL">
    </label><br>
    <label>
    <span>请输入网址：</span>
    <input type="text" name="URL" id="">
    </label><br>
    <input type="submit" name="submit" id="" value="点击保存到数据库中">
    </form>
</div>
</body>
</html>

/Spider/WebRoot/WEB-INF/spider/Error.jsp

<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<%
String path = request.getContextPath();
String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";
%>

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
  <head>
    <base href="<%=basePath%>">
    
    <title>程序出现异常</title>
    
	<meta http-equiv="pragma" content="no-cache">
	<meta http-equiv="cache-control" content="no-cache">
	<meta http-equiv="expires" content="0">    
	<meta http-equiv="keywords" content="keyword1,keyword2,keyword3">
	<meta http-equiv="description" content="This is my page">
  </head>
<div>
    <form class="STYLE-NAME" action="">
    <label>
    <span>  程序出现异常</span>
    </label><br>
    <label>
    <span>  </span>
    </label><br>
    </form>
</div>
</html>

/Spider/WebRoot/WEB-INF/spider/Success.jsp

<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%
String path = request.getContextPath();
String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";
%>

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
  <head>
    <base href="<%=basePath%>">
    
    <title>文件保存成功</title>
    <meta http-equiv="pragma" content="no-cache">
    <meta http-equiv="cache-control" content="no-cache">
    <meta http-equiv="expires" content="0">    
    <meta http-equiv="keywords" content="keyword1,keyword2,keyword3">
    <meta http-equiv="description" content="This is my page">
  </head>
<div>
    <form class="STYLE-NAME" action="">
    <label>
    <span>  如果文件保存成功，则跳转到这个页面</span>
    </label><br>
    <label>
    <span>  </span>
    </label><br>
    </form>
</div>
<!-- 显示服务器端传递过来的提示信息message -->
<div>
<c:if test=""></c:if>
<c:out value="${request.message}"></c:out>
<label><span> A ${message}</span></label>

</div>
</html>

后台java文件：
/Spider/src/com/spider/dao/JavaSpider_1_3_Dao.java Dao层接口

package com.spider.dao;

import java.util.Map;
import com.spider.Model.Temp_url;
import com.spider.Model.Url;

public interface JavaSpider_1_3_Dao {
	//增
	public boolean saveToDatabase(Url url);
	//增
	public boolean saveToDatabase(Temp_url temp_url);
	//查
	public Map<Integer,String> getAllUrlsOfLevel(int level);
}

/Spider/src/com/spider/dao/impl/JavaSpider_1_3_DaoImpl.java Dao层实现类

ackage com.spider.dao.impl;

import java.sql.ResultSet;
import java.util.HashMap;
import java.util.Map;
import com.spider.Model.Temp_url;
import com.spider.Model.Url;
import com.spider.dao.JavaSpider_1_3_Dao;
import com.spider.util.JavaSpider_JDBC;

public class JavaSpider_1_3_DaoImpl implements JavaSpider_1_3_Dao {

    @Override
    public boolean saveToDatabase(Temp_url temp_url) {
        //创建数据库连接对象
        JavaSpider_JDBC JavaSpider_JDBC = new JavaSpider_JDBC();
        //定义一个Boolean类型的变量，用来表示数据库操作是否成功
        boolean flag = false;

        //用PreparedStatement
        String sql = "insert into temp_url(id,url,level) values(null,?,?)";

        try{

            //调用dao层增加方法，把数据插入到数据库
            JavaSpider_JDBC.javaSpider_JDBC(sql);
            //执行数据库操作，如何执行预处理的SQL语句，请参考PreparedStatement源码，如下
            JavaSpider_JDBC.pst.setString(1, temp_url.getTempurl());
            JavaSpider_JDBC.pst.setInt(2, temp_url.getLevel());
            JavaSpider_JDBC.pst.execute();
            //测试输出
            System.out.println("数据库插入成功...");
            flag = true;
        }
        catch(Exception e){
            //测试输出
            System.out.println("数据库插入异常...");
            e.printStackTrace();
        }
        return flag;
    }

    @Override
    public boolean saveToDatabase(Url url) {
        //创建数据库连接对象
        JavaSpider_JDBC JavaSpider_JDBC = new JavaSpider_JDBC();
        //定义一个Boolean类型的变量，用来表示数据库操作是否成功
        boolean flag = false;

        //用PreparedStatement
        String sql = "insert into url(id,url,date) values(null,?,?)";
        
        try{

            //调用dao层增加方法，把数据插入到数据库
            JavaSpider_JDBC.javaSpider_JDBC(sql);
            //执行数据库操作，如何执行预处理的SQL语句，请参考PreparedStatement源码，如下
            JavaSpider_JDBC.pst.setString(1, url.getUrl());
            JavaSpider_JDBC.pst.setString(2, url.getDate());
            JavaSpider_JDBC.pst.execute();
            //测试输出
            System.out.println("数据库插入成功...");
            flag = true;
        }
        catch(Exception e){
            //测试输出
            System.out.println("数据库插入异常...");
            e.printStackTrace();
        }
        return flag;
    }

    @Override
    public Map<Integer, String> getAllUrlsOfLevel(int level) {
        //创建数据库连接对象
        JavaSpider_JDBC JavaSpider_JDBC = new JavaSpider_JDBC();
        //查询结果集
        ResultSet resultSet;
        //Map<Integer, String>
        Map<Integer, String> urls = new HashMap<Integer, String>();

        //用PreparedStatement
        String sql = "select url from temp_url where level=?";
        
        try{

            //调用dao层增加方法，把数据插入到数据库
            JavaSpider_JDBC.javaSpider_JDBC(sql);
            //执行数据库操作，如何执行预处理的SQL语句，请参考PreparedStatement源码，如下
            JavaSpider_JDBC.pst.setInt(1, level);
            resultSet = JavaSpider_JDBC.pst.executeQuery();
            //把查询结果保存到Map中
            int i = 1;
            while(resultSet.next()){
                urls.put(i-1, resultSet.getString("url"));
                System.out.println("dao测试：" + urls.get(i-1));
                i++;
            }
            
            //测试输出
            System.out.println("数据库插入成功...");
        }
        catch(Exception e){
            //测试输出
            System.out.println("数据库插入异常...");
            e.printStackTrace();
        }
        return urls;
    }
    
}

/Spider/src/com/spider/service/JavaSpider_1_3_Service.java Service层接口

package com.spider.service;

import java.util.Map;

import com.spider.Model.Temp_url;
import com.spider.Model.Url;

public interface JavaSpider_1_3_Service {
	//增
	public boolean saveToDatabase(Url url);
	//增
	public boolean saveToDatabase(Temp_url temp_url);
	//查
	public Map<Integer,String> getAllUrlsOfLevel(int level);
}

/Spider/src/com/spider/service/impl/JavaSpider_1_3_ServiceImpl.java Service层实现类

package com.spider.service.impl;

import java.util.HashMap;
import java.util.Map;
import com.spider.Model.Temp_url;
import com.spider.Model.Url;
import com.spider.dao.JavaSpider_1_3_Dao;
import com.spider.dao.impl.JavaSpider_1_3_DaoImpl;
import com.spider.service.JavaSpider_1_3_Service;

public class JavaSpider_1_3_ServiceImpl implements JavaSpider_1_3_Service {
	
	//定义Dao层接口对象
	JavaSpider_1_3_Dao javaSpider_1_3_Dao = new JavaSpider_1_3_DaoImpl(); 

	public JavaSpider_1_3_Dao getJavaSpider_1_3_Dao() {
		return javaSpider_1_3_Dao;
	}

	public void setJavaSpider_1_3_Dao(JavaSpider_1_3_Dao javaSpider_1_3_Dao) {
		this.javaSpider_1_3_Dao = javaSpider_1_3_Dao;
	}

	@Override
	public boolean saveToDatabase(Temp_url temp_url) {
		//定义一个Boolean类型的变量，用来表示数据库操作是否成功
		boolean flag = false;
		//
		flag = javaSpider_1_3_Dao.saveToDatabase(temp_url);

		return flag;
	}

	@Override
	public boolean saveToDatabase(Url url) {
		//定义一个Boolean类型的变量，用来表示数据库操作是否成功
		boolean flag = false;
		//
		flag = javaSpider_1_3_Dao.saveToDatabase(url);

		return flag;
	}

	@Override
	public Map<Integer, String> getAllUrlsOfLevel(int level) {
		
		Map<Integer, String> urls = new HashMap<Integer, String>();
		
		urls = javaSpider_1_3_Dao.getAllUrlsOfLevel(level);
		
		return urls;
	}
}

/Spider/src/com/spider/servlet/GetAllUrl_JavaSpider_1_3_Servlet.java Servlet控制类

package com.spider.servlet;

import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import com.spider.Model.Temp_url;
import com.spider.java.JavaSpider_1_3;
import com.spider.service.JavaSpider_1_3_Service;
import com.spider.service.impl.JavaSpider_1_3_ServiceImpl;

@SuppressWarnings("serial")
public class GetAllUrl_JavaSpider_1_3_Servlet extends HttpServlet{
    
	//定义service层接口对象
	JavaSpider_1_3_Service javaSpider_1_3_Service = new JavaSpider_1_3_ServiceImpl();
	
	//setter、getter方法
	public JavaSpider_1_3_Service getJavaSpider_1_3_Service() {
		return javaSpider_1_3_Service;
	}
	public void setJavaSpider_1_3_Service(JavaSpider_1_3_Service javaSpider_1_3_Service) {
		this.javaSpider_1_3_Service = javaSpider_1_3_Service;
	}
	
	//实现doPost方法
	
	public void doPost(HttpServletRequest request,HttpServletResponse response) throws ServletException,IOException{
		
		//设置相应信息的编码方式
		response.setCharacterEncoding("UTF-8");
		//定义一个String类型的变量，用来表示用户输入的URL
		String URL = "";
		//定义一个String类型的变量，用来表示用户输入的URL
		int LEVEL = 0;
		//定义一个String类型的变量，用来表示返回客户端的提示信息
		String message = "";
		//生成url对象
		Temp_url url_temp = new Temp_url();
		//定义一个Map，用来封装所有的URL网址
		Map<Integer,String> urls = new HashMap<Integer,String>();
		//
		Map<Integer,String> urls_rs = new HashMap<Integer,String>();
		//定义一个Map，用来封装所有的url对象
		Map<Integer,Temp_url> url_entity = new HashMap<Integer,Temp_url>();
		//生成JavaSpider_1_3_URLParser对象
		JavaSpider_1_3 javaSpider_1_3 = new JavaSpider_1_3();
	        //生成日期对象
	        Date current_date = new Date();
	        //设置日期格式化样式为：yyyy-MM-dd
	        SimpleDateFormat  SimpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
	        //格式化当前日期
	        SimpleDateFormat.format(current_date.getTime());
		//url.setUrl(URL);
		//url.setDate(SimpleDateFormat.format(current_date.getTime()));
		//在request请求域中获取参数
	    LEVEL = Integer.parseInt(request.getParameter("LEVEL"));
		URL = request.getParameter("URL");
		//测试输出
		System.out.println("在servlet中接收到的用户输入的网址：" + URL);

		if(!"".equals(URL)){
			//测试输出
			System.out.println(" 在servlet中 ，!''.equals(URL)：如果URL不为空，进入if语句...");
		    //获取所有的URL网址
		    urls = javaSpider_1_3.getFormatCode_1_3(URL);
		    
		    //封装url实体
		    for(int i=0;i<urls.size();i++){
		    	url_temp.setTempurl(urls.get(i));
		    	url_temp.setLevel(LEVEL);
		    	url_entity.put(i, url_temp);
		    	//调用业务逻辑处理对象，完成数据保存到数据库的业务逻辑
		    	javaSpider_1_3_Service.saveToDatabase(url_entity.get(i));
		    }
				
			//调用业务逻辑处理对象，完成数据保存到数据库的业务逻辑
			//for(int j=0;j<url_entity.size();j++){
				//javaSpider_1_3_Service.saveToDatabase(url_entity.get(j));
			//}
				
			message = "文件保存完成...";
				
			//把信息保存到request请求域中，传递到客户端
			request.setAttribute("message", message);
				
			//跳转到SpiderIndex.jsp页面
			request.getRequestDispatcher("WEB-INF/spider/Success.jsp").forward(request, response);

		}
		
		else{
			urls_rs = javaSpider_1_3_Service.getAllUrlsOfLevel(LEVEL);
			
			
			
		    //封装url实体
		    for(int i=0;i<urls_rs.size();i++){
		    	//url_temp.setTempurl(urls_rs.get(i));
		    	//url_temp.setLevel(LEVEL);
		    	//url_entity.put(i, url_temp);
		    	
		    	urls = javaSpider_1_3.getFormatCode_1_3(urls_rs.get(i));
		    	//测试输出
		    	System.out.println("查询结果集中的网址 urls_rs.get(i) = " + urls_rs.get(i));
		    	System.out.println("新爬取的网址 urls.get(i) = " + urls.get(i));
		    	
		    	for(int j=0;j<urls.size();j++){
		    		url_temp.setTempurl(urls.get(j));
		    		url_temp.setLevel(LEVEL);
		    		url_entity.put(j, url_temp);
			    	//测试输出
			    	System.out.println("新抓取的网址 = " + urls.get(j));
		    		javaSpider_1_3_Service.saveToDatabase(url_entity.get(j));
		    	}
		    }
				
				message = "文件保存完成...";
				
				//把信息保存到request请求域中，传递到客户端
				request.setAttribute("message", message);
				
				//跳转到SpiderIndex.jsp页面
				request.getRequestDispatcher("WEB-INF/spider/Success.jsp").forward(request, response);
			
		}
	}
	

	//实现doGet方法
	public void doGet(HttpServletRequest request,HttpServletResponse response) throws ServletException,IOException{
		//设置相应信息的编码方式
		response.setCharacterEncoding("UTF-8");	
	}
	
}

/Spider/src/com/spider/java/JavaSpiderBase_1_3.java 爬虫核心接口

package com.spider.java;

import java.io.IOException;
import java.util.Map;
import org.apache.http.client.ClientProtocolException;

public interface JavaSpiderBase_1_3 {

    //带参数的方法 JavaSpider_1_3版本
    public Map<Integer,String> getFormatCode_1_3(String URL) throws ClientProtocolException, IOException;
}

/Spider/src/com/spider/java/JavaSpider_1_3.java 爬虫核心接口实现类

package com.spider.java;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.HashMap;
import java.util.Map;
import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.HttpStatus;
import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.HttpClient;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.impl.client.DefaultHttpClient;

/*
 * JavaSpier 1.3版本 之 网页内容处理类public class JavaSpider_1_3
 * 我们进行了以下改进：
 * 1，增加自动搜索目标网页的功能，先实现把一个站点下的网址都保存起来的功能。
 * 2，把一个站点下的网址，都保存到数据库中；
 * 
 * 在网页内容处理类public class JavaSpider_1_3，我们主要进行网页的爬取和文件IO的业务逻辑；
 * 网页抽取的操作从这个类中剥离；
 */
@SuppressWarnings("deprecation")
public class JavaSpider_1_3 implements JavaSpiderBase_1_3{
	
	//定义一个String变量，用来表示新生成的文件的存放路径
	public static final String FILE_PATH = "E:\\uploadFiles\\";

	@Override
	public Map<Integer,String> getFormatCode_1_3(String URL) throws ClientProtocolException, IOException {
		
		//创建HttpClient
		HttpClient httpClient = new DefaultHttpClient();
		//获取HttpGet对象
		HttpGet httpGet = new HttpGet(URL);
		//
		@SuppressWarnings("unused")
		StringBuffer stringBuffer = new StringBuffer();
		//
		HttpResponse httpResoponse = httpClient.execute(httpGet);
		//
		BufferedReader bufferedReader;
		//定义一个Map，用来封装所有的URL
		Map<Integer,String> urls = new HashMap<Integer,String>();

		//生成JavaSpider_1_3_URLParser对象
		JavaSpider_1_3_URLParser javaSpider_1_3_URLParser = new JavaSpider_1_3_URLParser();
		
		if(HttpStatus.SC_OK == httpResoponse.getStatusLine().getStatusCode()){
			//
			HttpEntity httpEntity = httpResoponse.getEntity();
			//
			if(httpEntity != null){
				
				bufferedReader = new BufferedReader(new InputStreamReader(httpEntity.getContent(),"UTF-8"));
				
				//bufferedReader按行读取
				String line = "";
				
				//if(httpEntity.getContentLength() > 0 ){
				if(httpEntity.getContent() != null && httpEntity.getContentLength() > 0){

					stringBuffer = new StringBuffer((int) httpEntity.getContentLength());
					
					int z = 0;

					while((line = bufferedReader.readLine()) != null){

						//判断得到的目标网址是否为空
						if(!"".equals(javaSpider_1_3_URLParser.parserURL_2(line, URL))){
							
							//封装到数组中
							
							urls.put(z, javaSpider_1_3_URLParser.parserURL_2(line, URL));
							
							z++;
						}
					
					}
				}
				
				//如果httpEntity.getContent() != null && httpEntity.getContentLength() == -1
				else{
					//测试输出
					System.out.println("进入if...进入条件：httpEntity.getContent() != null || httpEntity.getContentLength() == -1");

					//stringBuffer = new StringBuffer((int) httpEntity.getContentLength());
					//把长度写死
					stringBuffer = new StringBuffer(1024);
					
					int z = 0;

					while((line = bufferedReader.readLine()) != null){
						
						//判断得到的目标网址是否为空
						if(!"".equals(javaSpider_1_3_URLParser.parserURL_2(line, URL))){
							
							//封装到数组中
							
							urls.put(z, javaSpider_1_3_URLParser.parserURL_2(line, URL));
							
							//System.out.println("在JavaSpider中测试输出获取到的所有网址：" + urls.get(z));
							
							z++;
						}
					
					}
				}
			}
			if(httpEntity != null){
				//
				httpEntity.consumeContent();
			}
		}
		
		//返回Map
		return urls;
	}
}

/Spider/src/com/spider/java/JavaSpider_1_3_URLParser.java 对网页中的链接进行处理的工具类，以行为单位，获取网页中的所有URL地址

package com.spider.java;

/*
 *  * JavaSpier的目标：
 * 
 * 1，我们要获取的是http://commons.apache.org/proper/commons-fileupload/apidocs/src-html/org/apache/commons/
 * Apache org.apache.commons站点下的所有源代码文件，也就是最终的.html文件。
 *,2，我们要对获取到的源代码网页，进行格式化处理，以java源代码的方式，保存到指定文件中。
 * 3，每个.html页面保存到对应的.java文件中。这些文件都保存到电脑的指定目录下。
 * 
 * JavaSpier 1.3版本 之 网页内容处理类public class JavaSpider_1_3_URLParser
 * 我们进行了以下改进：
 * 1，自动检索当前网址所在网页的HTML内容，并从中抽取所有的URL地址，然后保存到数据库中；
 * 2，需要说明的是，这里保存的网址，有的是.html结尾的，有的是一个目录，比如.../fileupload/
 * 3，在JavaSpier 1.3版本，我们并没有将网页内容保存到文件中，因为我们的目的是先获得所有的目标网址，然后统一处理；
 * 
 * 在网页A标签处理类public class JavaSpider_1_3_URLParser，
 * 我们对网页中的链接进行处理，返回目标网址；
 */
public class JavaSpider_1_3_URLParser {

	/**
	 * 第二种实现方法：
	 * 
     * 1，直接获取第一个A标签的起始位置，然后截取想要的属性，或者A标签； 
     * 2，然后从剩下的二级子串中，重复进行第一步的操作；
     * 3，以此类推，我们就可以获取所有的A标签了...
     * 
	 * 此方法需要接收以下几个参数：
	 * 1，当前页面的网址current_url，String类型；
	 * 2，当前需要处理的行line，String类型；
	 */
	public String parserURL_2(String line,String current_url){

	    //目标网址前缀  target_url_prefix
	    String target_url_prefix = "";
	    //目标网址
	    String target_url = "";
	    //目标网址后缀
	    String target_url_suffix = "";
	    
		/*
		 * 第一次抽取
		 */
	    
	    //定义一个int变量，用来表示第一个 A 标签起始位置的索引
	    int a_start = -100;
	    //定义一个int变量，用来表示第一个 A 标签的 href 属性起始位置的索引
	    int href_start = -100;
	    //定义一个int变量，用来表示第一个 A 标签的  第一个双引号 起始位置的索引
	    int double_start = -100;
		
		//定义一个String类型的变量，用来表示截取的子串，我们称之为一级子串
		String sub_String = "";
		//定义一个String类型的变量，用来表示截取的子串的子串，我们称之为二级子串
		String sub_sub_String = "";
		
		/*
		 * 首先对当前网址current_url进行处理，获得目标网址前缀
		 */
		int current_url_index = current_url.lastIndexOf("/");
		target_url_prefix = current_url.substring(0, current_url_index+1);
		//测试输出
		System.out.println("当前输入的URL ==== " + current_url);
		System.out.println("目标网址前缀 target_url_prefix ==== " + target_url_prefix);
		
		//获取第一个A标签的索引
		if(line.contains("<a")){
			
			a_start = line.indexOf("<a");
			sub_String = line.substring(a_start);
			//测试输出
			//System.out.println("一级子串  sub_String = " + sub_String);
			
			href_start = sub_String.indexOf("href=");
			sub_sub_String = sub_String.substring(href_start+6);
			//测试输出
			//System.out.println("二级子串  sub_sub_String = " + sub_sub_String);
			
			//如果二级子串非法，也就是href的第一位不是字母
			if(sub_sub_String.startsWith("?") || sub_sub_String.startsWith("/")){
				//测试输出
				System.out.println("非法网址，不保存！");
			}
			else{
				
				double_start = sub_sub_String.indexOf("\"");
				target_url_suffix = sub_sub_String.substring(0, double_start);
				//测试输出
				//System.out.println("目标网址后缀  target_url_suffix = " + target_url_suffix);
			}
		}
		
		//如果目标网址后缀  target_url_suffix 不为空
		if(!"".equals(target_url_suffix)){
			
		    //目标网址为 
		    target_url = target_url_prefix + target_url_suffix;
		    //测试输出
		    System.out.println("当前获得的目标网址为 target_url:" + target_url);
		
		}
		
		//返回目标网址
		return target_url;
	}
}

/Spider/src/com/spider/java/JavaSpider_1_3_HTMLParser.java 对网页进行抽取的工具类，也就是去掉HTML标签，得到网页内容

package com.spider.java;

public class JavaSpider_1_3_HTMLParser {
	//
	public String parserHTML(String line){
		
		//定义一个String类型的变量parseredLine，用来表示处理以后的line
		String parseredLine = "";
		//第一次抽取后的子串
		String subString = "";
		//第二次抽取后的子串
		String sub_subString = "";
		//第三次抽取后的子串
		String sub_sub_subString = "";
		int i = line.indexOf('<'); 
		int j = line.lastIndexOf('<');
		int k = line.indexOf('>');
		//int m = line.lastIndexOf('>');
		//1，如果字符<第一次出现的索引和最后一次出现的索引值相等，说明这一行，只有一对<></> 这种闭合的HTML标签；
		//此时只需要把这个标签删除掉就行，我们可以使用String类的subString方法截取我们需要的信息；
		if(i == j && i != -1){
			//这种情况下， 我们还要再判断，这个标签是不是位于行首；
			if(i == 0 ){
				//System.out.println(""); //简化处理
			}
			else{
				//System.out.println("");  //简化处理，暂时不考虑<br>这种单独的标签
			}
				
		}
		//如果字符< 第一次出现的索引和最后一次出现的索引值不相同，说明这一行，有2对<></>或者多对， 这样的闭合的HTML标签；
		//2，如果有2对闭合的HTML标签；此时我们需要删除这2对HTML标签；这里简化步骤，只考虑闭合标签位于首尾的情况；
		else if(i != j){
			//第一次抽取
			subString = line.substring(k+1, j);
			//第二次抽取
			//第二次抽取的时候，需要考虑2个标签的特殊情况，也就是title、link这种标签，虽然符合条件，但是不抽取这种值。
			int y = subString.lastIndexOf('<');
			int z = subString.indexOf('>');
			if(y > -1){
				//此时还要考虑只有3个HTML标签的特殊情况
				if(subString.contains("<title") || subString.contains("<link" )){
					sub_subString = subString.substring(z+1, y);
				}
				else{
					sub_subString = subString.substring(z+1, y);
					if(sub_subString != null && (sub_subString.startsWith("0") || sub_subString.startsWith("1") 
							|| sub_subString.startsWith("2") 
							|| sub_subString.startsWith("3") || sub_subString.startsWith("4") || sub_subString.startsWith("5")
							|| sub_subString.startsWith("6") || sub_subString.startsWith("7") || sub_subString.startsWith("8")
							|| sub_subString.startsWith("9"))){
					}
					else{
						System.out.println(sub_subString);
						parseredLine = sub_subString;
					}
				}
			}
			//第三次抽取
			int A = sub_subString.indexOf('<');
			int B = sub_subString.indexOf('>');
			int C = sub_subString.lastIndexOf('<');
			//如果A<0，说明没有HTML标签了；
			if(A < 0){
				//System.out.println("");
			}
			//如果A>0,说明还有HTML标签，此时需要判断是只有一个，还是有多个；
			else{
				//如果A = C，说明，只有一个HTML标签，此时还有三种情况，HTML标签在首，HTML标签居中，HTML标签在尾；
				if(A == C && A == 0){
					sub_sub_subString = sub_subString.substring(B+1, sub_subString.length());
					System.out.println(sub_sub_subString);
					parseredLine = sub_sub_subString;
				}
				else if(A == C && (B == sub_subString.length() - 1)){
					sub_sub_subString = sub_subString.substring(0, A);
					System.out.println(sub_sub_subString);
					parseredLine = sub_sub_subString;
				}
				else if(A == C && A != 0 && (B != sub_subString.length() - 1 )){
					//如果HTML标签居中，我们这时需要根据java的语法来判断，
					//此时还需要判断，我们需要抽取的内容在哪边，这时我们根据HTML标签内，有没有/来判断
					//如果书写规范的话，没有/，则我们需要抽取的内容在后边；否则在前边；
					//这种情况下，还要进行第四次抽取的判断；
						
					//如果开头是数字，可以判断我们需要抽取的代码在尾部
					if(sub_subString.substring(0, 1).matches("^[0-9]")){
						sub_sub_subString = sub_subString.substring(B+1,sub_subString.length());
						System.out.println(sub_sub_subString);
						parseredLine = sub_sub_subString;
					}
					else{
						sub_sub_subString = sub_subString.substring(0, A);
						System.out.println(sub_sub_subString);
						parseredLine = sub_sub_subString;
					}
				}
			}
		}
		return parseredLine;
	}
}

/Spider/src/com/spider/Model/Temp_url.java 实体类

package com.spider.Model;

public class Temp_url {
	/*
	 * 数据库名称：test
	 * 
	 * 表名称：temp_url
	 * 字段1，id，主键，auto_increment；
	 * 字段2，url，varchar(200) not null
	 * 字段3，level，int(4)，not null
	 * 
	 * 建表语句：
       create table temp_url(
       id int auto_increment primary key,
       url varchar(200) not null,
       level int(4) not null
       );
       
     * 测试数据
     * insert into url(id,url,date) values(null,"http://commons.apache.org/proper/commons-fileupload/apidocs/src-

html/org/apache/commons/fileupload/portlet/PortletFileUpload.html#line.51",now());
     * 
     * url字段长度50不够用，我们把长度修改为100
     * alter table url modify url varchar(200) not null;
     */

	//id，主键，自增长
	int id;
	//临时URL，不是有效的URL
	String tempurl;
	//时间，date
	int level;
	
	//setter、getter方法
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getTempurl() {
		return tempurl;
	}
	public void setTempurl(String tempurl) {
		this.tempurl = tempurl;
	}
	public int getLevel() {
		return level;
	}
	public void setLevel(int level) {
		this.level = level;
	}
	
}

配置文件：web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="3.0" 
	xmlns="http://java.sun.com/xml/ns/javaee" 
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
	xsi:schemaLocation="http://java.sun.com/xml/ns/javaee 
	http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd">
  <display-name>JavaSpider</display-name>	

<!-- 配置servlet 用于设置Servlet的注册名称和Servlet的完整类名-->

<!-- 抓取所有的目标网址，保存到数据库 -->
<servlet>
    <servlet-name>GetAllUrl_JavaSpider_1_3_Servlet</servlet-name>
    <servlet-class>com.spider.servlet.GetAllUrl_JavaSpider_1_3_Servlet</servlet-class>
</servlet>

<!-- 配置servlet-mapping 用于映射一个已注册的Servlet的一个对外访问路径-->
<!-- 注意：-->
<!--     1，url-pattern是对外访问路径，对应JSP页面的action的值-->
<!--     2，客户端发送的action请求，对应url-pattern斜杠后面的参数；-->
<!--     3，action请求找到url-pattern以后，根据servlet-name去找对应的servlet类；-->
<!--     4，servlet类接收到客户端的请求以后，开始处理请求；-->

<!-- 抓取所有的目标网址，保存到数据库 -->
<servlet-mapping>
    <servlet-name>GetAllUrl_JavaSpider_1_3_Servlet</servlet-name>
    <url-pattern>/GetAllUrl_JavaSpider_1_3_Servlet</url-pattern>
</servlet-mapping>

</web-app>

这是一个没有经过优化的，简单的爬虫，可以爬取指定站点的网页，并将链接保存到数据库中。后续还会更新更高版本...

春秋战国程序猿

关注

0
点赞
踩
7

收藏

觉得还不错? 一键收藏
3
评论
java实现的简单网页爬虫：Servlet + MySQL5.5

/* * * JavaSpier的目标： * * 1，我们要获取的是 * http://commons.apache.org/proper/commons-fileupload/apidocs/src-html/org/apache/commons/ * Apache org.apache.commons站点下的所有源代码文件，也就是最终的.html文件。 *,2，我们
复制链接

扫一扫