HttpClient和Jsoup爬虫实例

最新推荐文章于 2024-05-25 11:24:08 发布
最新推荐文章于 2024-05-25 11:24:08 发布
阅读量1.8k 收藏 15
点赞数 2
分类专栏： Java 文章标签： HttpClient、Jsoup
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42969074/article/details/85702541
版权

最近学习了一个爬虫项目，用到的是HttpClient+Jsoup实现，然后我就学习了一下HttpClient和Jsoup的内容，代码在最下面有地址：

HttpClient学习：https://blog.csdn.net/qq_42969074/article/details/85618628

Jsoup学习：https://blog.csdn.net/qq_42969074/article/details/85562751

我的项目目录如下：

1.首先创建一个数据库：

/*
Navicat MySQL Data Transfer

Source Server         : localhost_3306
Source Server Version : 50720
Source Host           : localhost:3306
Source Database       : db_blogcrawler

Target Server Type    : MYSQL
Target Server Version : 50720
File Encoding         : 65001

Date: 2019-01-03 17:21:21
*/

SET FOREIGN_KEY_CHECKS=0;

-- ----------------------------
-- Table structure for `t_blog`
-- ----------------------------
DROP TABLE IF EXISTS `t_blog`;
CREATE TABLE `t_blog` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `title` varchar(100) DEFAULT NULL,
  `content` text,
  `crawlerDate` datetime DEFAULT NULL,
  `oldUrl` varchar(100) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=20 DEFAULT CHARSET=utf8;

-- ----------------------------
-- Records of t_blog
-- ----------------------------

2. 然后在C盘创建一个ehcache.xml，内容如下：

<?xml version="1.0" encoding="UTF-8"?>

<ehcache>
   <!-- 
         磁盘存储:将缓存中暂时不使用的对象,转移到硬盘,类似于Windows系统的虚拟内存
          path:指定在硬盘上存储对象的路径
   -->
   <diskStore path="C:\blogehcache" />
   
   <!-- 
        defaultCache:默认的缓存配置信息,如果不加特殊说明,则所有对象按照此配置项处理
        maxElementsInMemory:设置了缓存的上限,最多存储多少个记录对象
        eternal:代表对象是否永不过期
        overflowToDisk:当内存中Element数量达到maxElementsInMemory时，Ehcache将会Element写到磁盘中
   -->
   <defaultCache
      maxElementsInMemory="1"
      eternal="true"
      overflowToDisk="true"/>

    <cache 
      name="cnblog"
      maxElementsInMemory="1"
      diskPersistent="true"
      eternal="true"
      overflowToDisk="true"/>
      
  

</ehcache>

 3.主要代码如下：

package com.thr.crawler;

import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.UUID;

import org.apache.commons.io.FileUtils;
import org.apache.http.HttpEntity;
import org.apache.http.ParseException;
import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.util.EntityUtils;
import org.apache.log4j.Logger;
import org.jsoup.Jsoup;
import org.jsoup.nodes.Document;
import org.jsoup.nodes.Element;
import org.jsoup.select.Elements;

import com.thr.util.DateUtil;
import com.thr.util.DbUtil;
import com.thr.util.PropertiesUtil;

import net.sf.ehcache.Cache;
import net.sf.ehcache.CacheManager;
import net.sf.ehcache.Status;

/**
 * @author Tang Haorong
 * @description 主体类
 */
public class CnBlogCrawler {

    private static Logger logger=Logger.getLogger(CnBlogCrawler.class);

    private static final String URL="http://www.cnblogs.com/";

    private static Connection con=null;

    private static CacheManager manager=null; // cache管理器

    private static Cache cache=null; // cache缓存对象

    /**
     * 解析主页
     */
    private static void parseHomePage(){
        while(true){
            logger.info("开始爬取"+URL+"网页");
            manager= CacheManager.create(PropertiesUtil.getValue("cacheFilePath"));
            cache=manager.getCache("cnblog");
            CloseableHttpClient httpClient= HttpClients.createDefault(); // 获取HttpClient实例
            HttpGet httpget=new HttpGet(URL); // 创建httpget实例
            RequestConfig config=RequestConfig.custom().setSocketTimeout(100000) // 设置读取超时时间
                    .setConnectTimeout(5000)  // 设置连接超时时间
                    .build();
            httpget.setConfig(config);
            CloseableHttpResponse response=null;
            try {
                response=httpClient.execute(httpget);
            } catch (ClientProtocolException e) {
                logger.error(URL+"-ClientProtocolException",e);
            } catch (IOException e) {
                logger.error(URL+"-IOException",e);
            }
            if(response!=null){
                HttpEntity entity=response.getEntity(); // 获取返回实体
                // 判断返回状态是否为200
                if(response.getStatusLine().getStatusCode()==200){
                    String webPageContent=null;
                    try {
                        webPageContent= EntityUtils.toString(entity, "utf-8");
                        parseHomeWebPage(webPageContent);
                    } catch (ParseException e) {
                        logger.error(URL+"-ParseException",e);
                    } catch (IOException e) {
                        logger.error(URL+"-IOException",e);
                    }
                }else{
                    logger.error(URL+"-返回状态非200");
                }
            }else{
                logger.error(URL+"-连接超时");
            }
            try{
                if(response!=null){
                    response.close();
                }
                if(httpClient!=null){
                    httpClient.close();
                }
            }catch(Exception e){
                logger.error(URL+"Exception", e);
            }
            if(cache.getStatus()== Status.STATUS_ALIVE){
                cache.flush(); // 把缓存写入文件
            }
            manager.shutdown();
            try {
                Thread.sleep(1*60*1000); // 每隔10分钟抓取一次网页数据
            } catch (InterruptedException e) {
                logger.error("InterruptedException", e);
            }
            logger.info("结束爬取"+URL+"网页");
        }
    }

    /**
     * 解析首页内容 提取博客link
     * @param webPageContent
     */
    private static void parseHomeWebPage(String webPageContent){
        if("".equals(webPageContent)){
            return;
        }
        Document doc= Jsoup.parse(webPageContent);
        Elements links=doc.select("#post_list .post_item .post_item_body h3 a");
        for(int i=0;i<links.size();i++){
            Element link=links.get(i);
            String url=link.attr("href");
            System.out.println(url);
            if(cache.get(url)!=null){ // 如果缓存中存在就不插入
                logger.info(url+"-缓存中存在");
                continue;
            }
            parseBlogLink(url);
        }

    }

    /**
     * 解析博客链接地址 获取博客内容
     * @param link
     */
    private static void parseBlogLink(String link){
        logger.info("开始爬取"+link+"网页");
        CloseableHttpClient httpClient=HttpClients.createDefault(); // 获取HttpClient实例
        HttpGet httpget=new HttpGet(link); // 创建httpget实例
        RequestConfig config=RequestConfig.custom().setSocketTimeout(100000) // 设置读取超时时间
                .setConnectTimeout(5000)  // 设置连接超时时间
                .build();
        httpget.setConfig(config);
        CloseableHttpResponse response=null;
        try {
            response=httpClient.execute(httpget);
        } catch (ClientProtocolException e) {
            logger.error(URL+"-ClientProtocolException",e);
        } catch (IOException e) {
            logger.error(URL+"-IOException",e);
        }
        if(response!=null){
            HttpEntity entity=response.getEntity(); // 获取返回实体
            // 判断返回状态是否为200
            if(response.getStatusLine().getStatusCode()==200){
                String blogContent=null;
                try {
                    blogContent=EntityUtils.toString(entity, "utf-8");
                    parseBlogPage(blogContent,link);
                } catch (ParseException e) {
                    logger.error(URL+"-ParseException",e);
                } catch (IOException e) {
                    logger.error(URL+"-IOException",e);
                }
            }else{
                logger.error(URL+"-返回状态非200");
            }
        }else{
            logger.error(URL+"-连接超时");
        }
        try{
            if(response!=null){
                response.close();
            }
            if(httpClient!=null){
                httpClient.close();
            }
        }catch(Exception e){
            logger.error(URL+"Exception", e);
        }
        logger.info("结束爬取"+link+"网页");
    }

    /**
     * 解析博客内容，提取有效信息
     * @param blogContent
     * @param link
     */
    private static void parseBlogPage(String blogContent,String link){
        if("".equals(blogContent)){
            return;
        }
        Document doc=Jsoup.parse(blogContent);
        Elements titleElements=doc.select("#cb_post_title_url"); // 获取博客标题
        if(titleElements.size()==0){
            logger.error(link+"-未获取到博客标题");
            return;
        }
        String title=titleElements.get(0).text();
        System.out.println("博客标题："+title);

        Elements contentElements=doc.select("#cnblogs_post_body"); // 获取博客内容
        Elements imgElements=contentElements.select("img"); // 获取所有图片元素
        if(contentElements.size()==0){
            logger.error(link+"-未获取到博客内容");
            return;
        }
        String content=contentElements.get(0).html();
        System.out.println("博客内容："+content);

        List<String> imgUrlList=new LinkedList<String>();
        for(int i=0;i<imgElements.size();i++){
            Element imgEle=imgElements.get(i);
            String url=imgEle.attr("src");
            imgUrlList.add(url);
            System.out.println(url);
        }

        if(imgUrlList.size()>0){
            Map<String,String> replaceImgMap=downLoadImages(imgUrlList);
            String newContent=replaceWebPageImages(content,replaceImgMap);
            content=newContent;
        }

        // 插入数据库
        String sql="insert into t_blog values(null,?,?,now(),?)";
        try {
            PreparedStatement pstmt=con.prepareStatement(sql);
            pstmt.setString(1, title);
            pstmt.setString(2, content);
            pstmt.setString(3, link);
            if(pstmt.executeUpdate()==1){
                logger.info(link+"-成功插入数据库");
                cache.put(new net.sf.ehcache.Element(link, link));
                logger.info(link+"-已加入缓存");
            }else{
                logger.info(link+"-插入数据库失败");
            }
        } catch (SQLException e) {
            logger.error("SQLException",e);
        }
    }

    /**
     * 把原来的网页图片地址换成本地新的
     * @param content
     * @param replaceImgMap
     * @return
     */
    private static String replaceWebPageImages(String content, Map<String, String> replaceImgMap) {
        for(String url:replaceImgMap.keySet()){
            String newPath=replaceImgMap.get(url);
            content=content.replace(url, newPath);
        }
        return content;
    }

    /**
     * 下载图片到本地
     * @param imgUrlList
     * @return
     */
    private static Map<String,String> downLoadImages(List<String> imgUrlList) {
        Map<String,String> replaceImgMap=new HashMap<String,String>();

        RequestConfig config=RequestConfig.custom().setSocketTimeout(10000) // 设置读取超时时间
                .setConnectTimeout(5000)  // 设置连接超时时间
                .build();
        CloseableHttpClient httpClient=HttpClients.createDefault(); // 获取HttpClient实例
        for(int i=0;i<imgUrlList.size();i++){
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }

            String url=imgUrlList.get(i);
            logger.info("开始爬取"+url+"图片");

            CloseableHttpResponse response=null;

            try {
                HttpGet httpget=new HttpGet(url); // 创建httpget实例
                httpget.setConfig(config);
                response=httpClient.execute(httpget);
            } catch (ClientProtocolException e) {
                logger.error(url+"-ClientProtocolException");
            } catch (IOException e) {
                logger.error(url+"-IOException");
            }
            if(response!=null){
                HttpEntity entity=response.getEntity(); // 获取返回实体
                // 判断返回状态是否为200
                if(response.getStatusLine().getStatusCode()==200){
                    try {
                        InputStream inputStream=entity.getContent();
                        String imageType=entity.getContentType().getValue();
                        String urlB=imageType.split("/")[1];
                        String uuid= UUID.randomUUID().toString();
                        String currentDatePath= DateUtil.getCurrentDatePath();
                        String newPath=PropertiesUtil.getValue("imagePath")+currentDatePath+"/"+uuid+"."+urlB;
                        FileUtils.copyToFile(inputStream, new File(PropertiesUtil.getValue("imageFilePath")+currentDatePath+"/"+uuid+"."+urlB));
                        replaceImgMap.put(url, newPath);
                    } catch (UnsupportedOperationException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    } catch (IOException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    } catch (Exception e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }else{
                    logger.error("返回状态非200");
                }
            }else{
                logger.error("连接超时");
            }
            try{
                if(response!=null){
                    response.close();
                }
            }catch(Exception e){
                logger.error("Exception", e);
            }
            logger.info("结束爬取"+url+"图片");
        }

        return replaceImgMap;
    }

    public static void start(){
        DbUtil dbUtil=new DbUtil();
        try {
            con=dbUtil.getCon();
        } catch (Exception e) {
            logger.error("创建数据库连接失败", e);
        }
        parseHomePage();
    }

    public static void main(String[] args) {
        start();
    }

}

还有一些工具类没有写出来，可以下面的地址下载。 

4.运行后的效果；

数据库里面数据：

然后图片也有：

GitHub地址：https://github.com/tanghaorong/Crawler 

我不想再熬夜了
关注
  • 2
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
爬虫 httpClient
qq_43621053的博客
12-12 82
public class CrawerFirst { public static void main(String[] args) throws IOException { //打开浏览器 创建一个HttpClient 对象 CloseableHttpClient httpClient = HttpClients.createDefault(); ...
爬虫：httpclient+jsoup
11-19
本文将详细探讨使用Java中的两种库——HttpClient和Jsoup，以及它们结合使用来构建网页爬虫的方法。 HttpClient是Apache软件基金会的一个项目，提供了对HTTP协议的全面支持，包括请求/响应模型、连接管理、重定向...
使用HttpClient和Jsoup实现一个简单爬虫
diannao5430的博客
05-19 134
一直很想了解一下爬虫这个东西的，完全是出于兴趣，其实刚开始是准备用python的，但是由于种种原因选择了java,此处省略很多字... 总之，如果你想做一件事情的话就尽快去做吧，千万不要把战线拉得太长了，否则时间一长其实发现自己什么都没做... 拖延症就是这样慢慢形成了。 在写一个爬虫以前需要了解一下HTTP协议的，通常的B/S程序都是客户端请求、服务端响应这种模式，通过一个URL就能...
Java基础
最新发布
05-25 465
抽象的，不是真实存在的第一次使用类内容时，通过CLASSPATH类路径找到字节码文件，将字节码文件中的内容加载到虚拟机中的过程，称之为类加载，通常情况下，类加载只会发生一次运行时异常：继承RuntimeException构造：无参构造+有参构造有参构造目的为给父类中声明的详细信息属性赋值非运行时异常：继承Exception内容：构造要求与运行时一致自定义类型必须实现java.io.Serializable接口，意为该类允许被序列化序列化：拆分对象信息的过程。
基于HttpClient实现网络爬虫~以百度新闻为例
jingqiang521的专栏
01-14 1061
时间 2014-11-07 13:48:55  CSDN博客 原文  http://blog.csdn.net/xiaojimanman/article/details/40891791 主题 HttpComponents 网络爬虫 转载请注明出处： http://blog.csdn.net/xiaojimanman/article/details/40891791 在
采用HttpClient和Jsoup实现简单的网页爬虫
Bobo‘s Home
10-01 554
在我们的学习过程中，有些时候难免可能需要在网上爬一些数据之类的，没有学过Python爬虫可能让你有些手足无措，这里我们就用Java程序实现一个简单的的网页爬虫程序。 jar包 HttpClient的使用 package tqb.test.httpclient; import java.io.IOException; import javax.swing.text.html.parser.En...
网络爬虫之httpclient的使用
qy20115549的博客
08-13 8569
HttpClient 是 Apache Jakarta Common 下的子项目，可以用来提供高效的、最新的、功能丰富的支持 HTTP 协议的客户端编程工具包，并且它支持 HTTP 协议最新的版本和建议。 如下面程序，为我写的一个简单的httpclient的测试程序：package crawlerTest;import java.io.IOException; import org.apache.
httpClient+jsoup抓取网页数据实例和jar包
04-18
在IT领域，网络爬虫是获取网页数据的重要手段，而HttpClient和Jsoup是两种常用的Java库，用于实现这一目的。HttpClient提供了低级别的HTTP通信能力，而Jsoup则是一个解析和操作HTML文档的强大工具。本教程将详细介绍...
jsoup+httpclient j简单爬虫
07-05
**JSoup + HttpClient 简单爬虫** 在信息技术领域，数据抓取，或称“爬虫”，是一种自动化获取网页信息的技术。JavaScript Object Notation (JSON) Soup 和 HttpClient 是两个在Java开发中常用于实现爬虫功能的库。...
httpClient+jsoup 抓取网页数据
04-18
实际操作时，可能还需要考虑登录、分页、动态加载等问题，这些可以通过HttpClient设置cookie和处理重定向，或者使用Jsoup的Jsoup.connect模拟JavaScript执行来解决。 总之，HttpClient和Jsoup是Java开发者进行网页...
基于Socket和HttpURLConnection的爬虫实例
11-01
在实际的爬虫项目中，我们通常会使用更高级的库，如Jsoup或Apache HttpClient，它们提供了更多的功能和便利性，但理解Socket和HttpURLConnection的基础对于任何网络编程和爬虫开发都是至关重要的。 总的来说，学习...
Java爬虫（一）-- HttpClient，HttpClient连接池，Jsoup的使用
stalin_的博客
11-16 1609
网络爬虫就是用程序帮助我们访问网络上的资源，我们一直以来都是使用HTTP协议访问互联网的网页，网络爬虫需要编写程序，在这里使用同样的HTTP协议访问网页。 在Java中模拟HTTP协议客户端一般使用 HttpClient这个技术，来实现抓取网页数据。而由于爬虫会发送很多请求，频繁创建销毁HttpClient会大量消耗服务的资源，所以我们会使用连接池来获取HttpClient。 而Jsoup则用来解析抓取到的网页数据中的内容。下面我就为大家逐一介绍这三个爬虫的基础工具的使用。 一、 HttpClient 1、
java爬虫-0020，httpclient获取源码
登峰小蚁
10-05 3306
项目地址：https://github.com/wenrongyao/java_crawler 1、导入httpclient依赖 &lt;dependency&gt; &lt;groupId&gt;org.apache.httpcomponents&lt;/groupId&gt; &lt;artifactId&gt;httpclient&lt;...
HttpClient和jsoup基础API使用
hikktn的博客
05-03 200
准备配置 pom <dependencies> <!-- https://mvnrepository.com/artifact/org.apache.httpcomponents/httpclient --> <dependency> <groupId>org.apache.httpcomponents</groupId> <artifactId&g
Jsoup和httpClient的对比
cyberpunk_Isme的博客
09-04 741
HttpClient爬虫
祈雨v的博客
10-01 374
1、模拟Get请求爬取HtmlCloseableHttpClient httpClient =HttpClients.createDefault(); HttpGet get = new HttpGet("http://192.168.100.2:8080"); CloseableHttpResponse response = httpclient.execute(get); HttpEntity
java爬虫（一） - HttpClient
qq_45752401的博客
06-24 924
爬虫入门网络爬虫简介为什么要学习爬虫下面演示httpClient方式普通 get 方式带参 get 方式普通 post 方式带参 post 方式创建连接池管理httpClient 网络爬虫简介 网络爬虫也叫网络机器人, 是一种可以按照一定规则自动采集互联网信息的程序或脚本, 爬虫一般分为数据采集, 处理, 储存三个部分, 从若干初始网页的URL开始抓取网页, 不断获取页面上的URL放入队列直到满足系统的一定条件停止 为什么要学习爬虫 可以实现私人的搜索引擎 大数据时代获取数据源, 作数据分析 可
五种实现网络爬虫的方法（三，基于httpclient编写爬虫）
AaronLin的博客
09-02 2598
咕咕咕~ 总所周知httpclient是java爬虫的利器， 一般我个人开发，都是用httpclient来编写抓取登陆代理等，用jsoup，xpath，正则来处理解析。 废话不多说直接上代码。 public static String getPageContent(String url) { // 创建一个客户端，类似于打开一个浏览器 DefaultHttpClient http...
网络爬虫小白教程 (HttpClient)
qq_22075913的博客
07-11 619
1.学习计划 入门程序 网络爬虫介绍 HttpClient抓取数据 Jsoup解析数据 爬虫案例 2.网络爬虫 网络爬虫（Web crawler），是一种按照一定的规则，自动地抓取万维网信息的程序或者脚本 2.1 爬虫入门程序 2.1.1 环境准备 JDK1.8 IntelliJ IDEA IDEA自带的Maven 2.1.2 环境准备 创建Maven工程itcast-crawler-first并给pom.xml加入依赖 <dependencies> <!--.
基于HttpClient、Jsoup的爬虫获取指定网页内容
06-09
要使用Java编写基于HttpClient和Jsoup的爬虫，需要进行以下步骤： 1. 首先，导入HttpClient和Jsoup的依赖包。可以使用maven或gradle进行依赖管理。 2. 创建一个HttpClient实例，用于发送HTTP请求和接收响应。可以...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值