使用WebMagic爬取51job上的招聘信息

1. 开发分析

使用WebMagic实现爬取数据的功能，在这里我们实现的是聚焦网络爬虫，爬取https://www.51job.com/上的招聘信息，只爬取“计算机软件”和“互联网电子商务”两个行业的信息。
首先访问页面并搜索两个行业。结果如下
点击职位详情页，我们分析发现详情页还有一些数据需要抓取：
职位、公司名称、工作地点、薪资、发布时间、职位信息、公司联系方式、公司信息

数据库表
根据以上信息，设计数据库表

use crawler;
DROP database IF EXISTS `job_info`;
CREATE TABLE `job_info` (
  `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '主键id',
  `company_name` varchar(100) DEFAULT NULL COMMENT '公司名称',
  `company_addr` varchar(200) DEFAULT NULL COMMENT '公司联系方式',
  `company_info` text COMMENT '公司信息',
  `job_name` varchar(100) DEFAULT NULL COMMENT '职位名称',
  `job_addr` varchar(50) DEFAULT NULL COMMENT '工作地点',
  `job_info` text COMMENT '职位信息',
  `salary_min` int(10) DEFAULT NULL COMMENT '薪资范围，最小',
  `salary_max` int(10) DEFAULT NULL COMMENT '薪资范围，最大',
  `url` varchar(150) DEFAULT NULL COMMENT '招聘信息详情页',
  `time` varchar(10) DEFAULT NULL COMMENT '职位最近发布时间',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8 COMMENT='招聘信息';

在解析页面的时候，很可能会解析出相同的url地址(例如商品标题和商品图片超链接，而且url一样)，如果不进行处理，同样的url会解析处理多次，浪费资源。所以我们需要有一个url去重的功能：

Scheduler组件
WebMagic提供了Scheduler可以帮助我们解决以上问题。
Scheduler是WebMagic中进行URL管理的组件。一般来说，Scheduler包括两个作用：(1) 对待抓取的URL队列进行管理 (2) 对已抓取的URL进行去重。
WebMagic内置了几个常用的Scheduler，如果只是在本地执行规模比较小的爬虫，那么基本无需定制Scheduler，但是了解一下已经提供的几个Scheduler还是有意义的。

说明	备注
plicateRemovedScheduler	抽象基类，提供一些模板方法
eueScheduler	使用内存队列保存待抓取URL
iorityScheduler	使用带有优先级的内存队列保存待抓取URL
leCacheQueueScheduler	使用文件保存抓取URL，可以在关闭程序并下次启动时，从之前抓取到的URL继续抓取
disScheduler	使用Redis保存抓取队列，可进行多台机器同时合作抓取

去重部分被单独抽象成了一个接口：DuplicateRemover，从而可以为同一个Scheduler选择不同的去重方式，以适应不同的需要，目前提供了两种去重方式。

类	说明
HashSetDuplicateRemover	使用HashSet来进行去重，占用内存较大
BloomFilterDuplicateRemover	使用BloomFilter来进行去重，占用内存较小，但是可能漏抓页面

RedisScheduler是使用Redis的set进行去重，其他的Scheduler默认都使用HashSetDuplicateRemover来进行去重。
如果要使用BloomFilter，必须要加入以下依赖：

<!--WebMagic对布隆过滤器的支持-->
<dependency>
    <groupId>com.google.guava</groupId>
    <artifactId>guava</artifactId>
    <version>16.0</version>
</dependency>

修改代码，添加布隆过滤器

public static void main(String[] args) {
      
      
    Spider.create(new JobProcessor())
            //初始访问url地址
            .addUrl("https://www.jd.com/")
            .addPipeline(new FilePipeline("D:/webmagic/"))
            .setScheduler(new QueueScheduler()
                    .setDuplicateRemover(new BloomFilterDuplicateRemover(10000000))) //参数设置需要对多少条数据去重
            .thread(1)//设置线程数
            .run();
}

修改public void process(Page page)方法，添加一下代码

//每次加入相同的url，测试去重
page.addTargetRequest("https://www.jd.com/");

三种去重方式

HashSet
使用java中的HashSet不能重复的特点去重。优点是容易理解。使用方便。
缺点：占用内存大，性能较低。
Redis去重
使用Redis的set进行去重。优点是速度快（Redis本身速度就很快），而且去重不会占用爬虫服务器的资源，可以处理更大数据量的数据爬取。
缺点：需要准备Redis服务器，增加开发和使用成本。
布隆过滤器（BloomFilter）
使用布隆过滤器也可以实现去重。优点是占用的内存要比使用HashSet要小的多，也适合大量数据的去重操作。
缺点：有误判的可能。没有重复可能会判定重复，但是重复数据一定会判定重复。
布隆过滤器 (Bloom Filter)是由Burton Howard Bloom于1970年提出，它是一种space efficient的概率型数据结构，用于判断一个元素是否在集合中。在垃圾邮件过滤的黑白名单方法、爬虫(Crawler)的网址判重模块中等等经常被用到。
哈希表也能用于判断元素是否在集合中，但是布隆过滤器只需要哈希表的1/8或1/4的空间复杂度就能完成同样的问题。布隆过滤器可以插入元素，但不可以删除已有元素。其中的元素越多，误报率越大，但是漏报是不可能的。
原理：
布隆过滤器需要的是一个位数组(和位图类似)和K个映射函数(和Hash表类似)，在初始状态时，对于长度为m的位数组array，它的所有位被置0。
对于有n个元素的集合S={S1,S2…Sn},通过k个映射函数{f1,f2,…fk}，将集合S中的每个元素Sj(1<=j<=n)映射为K个值{g1,g2…gk}，然后再将位数组array中相对应的array[g1],array[g2]…array[gk]置为1：
如果要查找某个元素item是否在S中，则通过映射函数{f1,f2,…fk}得到k个值{g1,g2…gk}，然后再判断array[g1],array[g2]…array[gk]是否都为1，若全为1，则item在S中，否则item不在S中。
布隆过滤器会造成一定的误判，因为集合中的若干个元素通过映射之后得到的数值恰巧包括g1,g2,…gk，在这种情况下可能会造成误判，但是概率很小。

布隆过滤器实现（了解）

//布隆过滤器
public class BloomFilter {
      
      

   /* BitSet初始分配2^24个bit */
   private static final int DEFAULT_SIZE = 1 << 24;

   /* 不同哈希函数的种子，一般应取质数 */
   private static final int[] seeds = new int[] {
      
       5, 7, 11, 13, 31, 37 };

   private BitSet bits = new BitSet(DEFAULT_SIZE);

   /* 哈希函数对象 */
   private SimpleHash[] func = new SimpleHash[seeds.length];

   public BloomFilter() {
      
      
      for (int i = 0; i < seeds.length; i++) {
      
      
         func[i] = new SimpleHash(DEFAULT_SIZE, seeds[i]);
      }
   }

   // 将url标记到bits中
   public void add(String str) {
      
      
      for (SimpleHash f : func) {
      
      
         bits.set(f.hash(str), true);
      }
   }

   // 判断是否已经被bits标记
   public boolean contains(String str) {
      
      
      if (StringUtils.isBlank(str)) {
      
      
         return false;
      }

      boolean ret = true;
      for (SimpleHash f : func) {
      
      
         ret = ret && bits.get(f.hash(str));
      }

      return ret;
   }

2. 开发准备

2.1 创建工程
创建Maven工程，并在pom.xml中加入依赖：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.3.0.RELEASE</version>
    </parent>

    <groupId>cn.itcast</groupId>
    <artifactId>itcast-crawler-job</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <!--SpringMVC-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <!--SpringData Jpa-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>

        <!--MySQL连接包-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>

        <!--WebMagic核心包-->
        <dependency>
            <groupId>us.codecraft</groupId>
            <artifactId>webmagic-core</artifactId>
            <version>0.7.3</version>
            <exclusions>
                <exclusion>
                    <groupId>org.slf4j</groupId>
                    <artifactId>slf4j-log4j12</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <!--WebMagic扩展-->
        <dependency>
            <groupId>us.codecraft</groupId>
            <artifactId>webmagic-extension</artifactId>
            <version>0.7.3</version>
        </dependency>

        <!--WebMagic对布隆过滤器的支持-->
        <dependency>
            <groupId>com.google.guava</groupId>
            <artifactId>guava</artifactId>
            <version>16.0</version>
        </dependency>

        <!--工具包-->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
        </dependency>

        <!--单元测试-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
        </dependency>
    </dependencies>
</project>

2.2 加入配置文件
添加application.properties配置文件

#DB Configuration:
spring.datasource.driverClassName=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://127.0.0.1:3306/crawler?useUnicode=true&useJDBCCompliantTimezoneShift=true&useLegacyDatetimeCode=false&serverTimezone=UTC
spring.datasource.username=root
spring.datasource.password=root

#JPA Configuration:
spring.jpa.database=MySQL
spring.jpa.show-sql=true

server.port=80

2.3 编写Pojo

package cn.itcast.job.pojo;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@Entity
public class JobInfo {
    
    
	@Id
	@GeneratedValue(strategy = GenerationType.IDENTITY)
	private Long id;
	private String companyName;
	private String companyAddr;
	private String companyInfo;
	private String jobName;
	private String jobAddr;
	private String jobInfo;
	private Integer salaryMin;
	private Integer salaryMax;
	private String url;
	private String time;

	public Long getId() {
    
    
		return id;
	}

	public void setId(Long id) {
    
    
		this.id = id;
	}

	public String getCompanyName() {
    
    
		return companyName;
	}

	public void setCompanyName(String companyName) {
    
    
		this.companyName = companyName;
	}

	public String getCompanyAddr() {
    
    
		return companyAddr;
	}

	public void setCompanyAddr(String companyAddr) {
    
    
		this.companyAddr = companyAddr;
	}

	public String getCompanyInfo() {
    
    
		return companyInfo;
	}

	public void setCompanyInfo(String companyInfo) {
    
    
		this.companyInfo = companyInfo;
	}

	public String getJobName() {
    
    
		return jobName;
	}

	public void setJobName(String jobName) {
    
    
		this.jobName = jobName;
	}

	public String getJobAddr() {
    
    
		return jobAddr;
	}

	public void setJobAddr(String jobAddr) {
    
    
		this.jobAddr = jobAddr;
	}

	public String getJobInfo() {
    
    
		return jobInfo;
	}

	public void setJobInfo(String jobInfo) {
    
    
		this.jobInfo = jobInfo;
	}

	public Integer getSalaryMin() {
    
    
		return salaryMin;
	}

	public void setSalaryMin(Integer salaryMin) {
    
    
		this.salaryMin = salaryMin;
	}

	public Integer getSalaryMax() {
    
    
		return salaryMax;
	}

	public void setSalaryMax(Integer salaryMax) {
    
    
		this.salaryMax = salaryMax;
	}

	public String getUrl() {
    
    
		return url;
	}

	public void setUrl(String url) {
    
    
		this.url = url;
	}

	public String getTime() {
    
    
		return time;
	}

	public void setTime(String time) {
    
    
		this.time = time;
	}

	@Override
	public String toString() {
    
    
		return "JobInfo{" +
				"id=" + id +
				", companyName='" + companyName + '\'' +
				", companyAddr='" + companyAddr + '\'' +
				", companyInfo='" + companyInfo + '\'' +
				", jobName='" + jobName + '\'' +
				", jobAddr='" + jobAddr + '\'' +
				", jobInfo='" + jobInfo + '\'' +
				", salaryMin=" + salaryMin +
				", salaryMax=" + salaryMax +
				", url='" + url + '\'' +
				", time='" + time + '\'' +
				'}';
	}
}

2.4 编写Dao

package cn.itcast.job.dao;

import cn.itcast.job.pojo.JobInfo;
import org.springframework.data.jpa.repository.JpaRepository;

public interface JobInfoDao extends JpaRepository<JobInfo,Long> {
    
    
}

2.5 编写Service
Service接口

package cn.itcast.job.service;

import cn.itcast.job.pojo.JobInfo;
import org.springframework.stereotype.Service;

import java.util.List;

public interface JobInfoService {
    
    
	/**
	 * 保存数据
	 * @param jobInfo
	 */
	public void save(JobInfo jobInfo);

	/**
	 * 根据条件查询数据
	 * @param jobInfo
	 * @return
	 */
	public List<JobInfo> findJobInfo(JobInfo jobInfo);

}

Service实现类

package cn.itcast.job.service.impl;

import cn.itcast.job.dao.JobInfoDao;
import cn.itcast.job.pojo.JobInfo;
import cn.itcast.job.service.JobInfoService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Example;
import org.springframework.stereotype.Service;

import javax.transaction.Transactional;
import java.util.List;

@Service
public class JobInfoServiceImpl implements JobInfoService {
    
    

	@Autowired
	private JobInfoDao jobInfoDao;

	@Override
	@Transactional
	public void save(JobInfo jobInfo) {
    
    
		//先从数据库查询信息，根据发布日期查询和url查询
		JobInfo param = new JobInfo();
		param.setUrl(jobInfo.getUrl());
		param.setTime(jobInfo.getTime());
		List<JobInfo> list = this.findJobInfo(param);

		if (list.size()==0){
    
    
			//没有查询到数据则新增或者修改数据
			this.jobInfoDao.saveAndFlush(jobInfo);
		}
	}

	@Override
	public List<JobInfo> findJobInfo(JobInfo jobInfo) {
    
    
		Example example = Example.of(jobInfo);
		List<JobInfo> list = this.jobInfoDao.findAll(example);
		return list;
	}
}

2.6 编写引导类

package cn.itcast.job;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.scheduling.annotation.EnableScheduling;

@SpringBootApplication
@EnableScheduling//设置开启定时任务
public class Application {
    
    

    public static void main(String[] args) {
    
    
        SpringApplication.run(Application.class,args);
    }
}

3. 功能实现

3.1 编写url解析功能：public void process(Page page) {}
3.2 编写页面解析功能：private void saveJobInfo(Page page) {}

package cn.itcast.job.task;

import cn.itcast.job.pojo.JobInfo;
import org.apache.commons.lang3.StringUtils;
import org.jsoup.Jsoup;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
import us.codecraft.webmagic.Page;
import us.codecraft.webmagic.Site;
import us.codecraft.webmagic.Spider;
import us.codecraft.webmagic.processor.PageProcessor;
import us.codecraft.webmagic.scheduler.BloomFilterDuplicateRemover;
import us.codecraft.webmagic.scheduler.QueueScheduler;
import us.codecraft.webmagic.selector.Html;
import us.codecraft.webmagic.selector.Selectable;

import java.util.List;

@Component
public class JobProcessor implements PageProcessor {
    
    

	// 访问入口url地址
	private String url = "https://search.51job.com/list/000000,000000,0000,32%252C01,9,99,java,2,1.html?lang=c&stype=&postchannel=0000&workyear=99&cotype=99&degreefrom=99&jobterm=99&companysize=99&providesalary=99&lonlat=0%2C0&radius=-1&ord_field=0&confirmdate=9&fromType=&dibiaoid=0&address=&line=&specialarea=00&from=&welfare=";

	@Override
	public void process(Page page) {
    
    
		// 解析页面，获取招聘信息详情的url地址
		List<Selectable> list = page.getHtml().css("div#resultList div.el").nodes();
		// 判断获取到的集合是否为空
		if (list.size() == 0) {
    
    
			try {
    
    
				//如果为空，表示这是招聘信息详情页，保存数据
				this.saveJobInfo(page);
			} catch (Exception e) {
    
    
				e.printStackTrace();
			}
		} else {
    
    
			// 如果不为空，表示这是招聘信息列表页,解析出详情页的url地址，放到任务队列中
			for (Selectable selectable : list) {
    
    
				// 获取招聘信息详情页url
				String jobInfoUrl = selectable.links().toString();
				// System.out.println(jobInfoUrl);
				// 添加到url任务列表，等待下载
				page.addTargetRequest(jobInfoUrl);
				// 获取下一页的url
				String bkUrl = page.getHtml().css("div.p_in li.bk").nodes().get(1).links().toString();
				System.out.println(bkUrl);
				// 添加到任务列表中
				page.addTargetRequest(bkUrl);
			}
		}
		// String html = page.getHtml().toString();

	}

	// 解析页面，获取招聘信息详情的url地址，保存数据
	private void saveJobInfo(Page page) {
    
    
		//  创建招聘详情对象
		JobInfo jobInfo = new JobInfo();
		//  解析页面
		Html html = page.getHtml();

		//  获取数据，封装到对象中
		//公司名称a.catn
		jobInfo.setCompanyName(html.css("div.cn p.cname a.catn", "text").toString());
		//公司地址
		String cAddr = Jsoup.parse(html.css("div.cn p.ltype", "text").toString()).text().replace("-","");
		cAddr = cAddr.substring(0,6);
		jobInfo.setCompanyAddr(cAddr);

		//公司信息
		jobInfo.setCompanyInfo(html.css("div.tmsg", "text").toString());
		// 工作名字
		jobInfo.setJobName(html.css("div.cn h1", "text").toString());

		//  工作地址
        String jobAddr = Jsoup.parse(html.css("div.bmsg").nodes().get(1).toString()).text();
        //	部分公司暂没有填写公司详细地址，得非空判断
        if (StringUtils.isBlank(jobAddr)){
    
    
            jobInfo.setJobAddr(jobInfo.getCompanyAddr());
        }else {
    
    
	        jobAddr = jobAddr.replace("地图","");
            jobInfo.setJobAddr(jobAddr);
        }

		//  工作信息
        jobInfo.setJobInfo(Jsoup.parse(html.css("div.job_msg").toString()).text());
		// 个人薪水
		Integer[] salary = MathSalary.getSalary(html.css("div.cn strong", "text").toString());
		jobInfo.setSalaryMin(salary[0]);
		jobInfo.setSalaryMax(salary[1]);
		// 发布时间
		String time = html.css("div.cn p.msg", "text").toString();
		int length = time.lastIndexOf("发布");
		jobInfo.setTime(time.substring(length-5, length));

		// url地址
		jobInfo.setUrl(page.getUrl().toString());
		// 把结果保存起来，等待 ResultItem获取 获取
		page.putField("jobInfo",jobInfo);

	}

	private Site site = Site.me()
			.setCharset("gbk")//设置编码,根据网页编码设置
			.setTimeOut(1000 * 10)//设置超时时间
			.setRetrySleepTime(3000)//设置重试的间隔时间
			.setRetryTimes(3);//设置重试的次数

	@Override
	public Site getSite() {
    
    
		return site;
	}

	@Autowired
	private SpringDataPipeline springDataPipeline;

	// initialDelay当任务启动，等多久执行方法
	// fixedDelay每隔多久执行方法
	@Scheduled(initialDelay = 1000, fixedDelay = 1000 * 100)
	public void process() {
    
    

		Spider.create(new JobProcessor())
				.addUrl(url)
				.setScheduler(new QueueScheduler().setDuplicateRemover(new BloomFilterDuplicateRemover(10000000)))
				.thread(5)
				.run();
	}

}

3.3 其中的工资转换需用另外的工具类：MathSalary

package cn.itcast.job.task;

public class MathSalary {
    
    

    /**
     * 获取薪水范围
     * @param salaryStr
     * @return
     */
    public static Integer[] getSalary(String salaryStr) {
    
    
        //声明存放薪水范围的数组
        Integer[] salary = new Integer[2];

        //"500/天"
        //0.8-1.2万/月
        //5-8千/月
        //5-6万/年
        String date = salaryStr.substring(salaryStr.length() - 1, salaryStr.length());
        //如果是按天，则直接乘以240进行计算
        if (!"月".equals(date) && !"年".equals(date)) {
    
    
            salaryStr = salaryStr.substring(0, salaryStr.length() - 2);
            salary[0] = salary[1] = str2Num(salaryStr, 240);
            return salary;
        }

        String unit = salaryStr.substring(salaryStr.length() - 3, salaryStr.length() - 2);
        String[] salarys = salaryStr.substring(0, salaryStr.length() - 3).split("-");

        salary[0] = mathSalary(date, unit, salarys[0]);
        salary[1] = mathSalary(date, unit, salarys[1]);

        return salary;
    }

    //根据条件计算薪水
    private static Integer mathSalary(String date, String unit, String salaryStr) {
    
    
        Integer salary = 0;

        //判断单位是否是万
        if ("万".equals(unit)) {
    
    
            //如果是万，薪水乘以10000
            salary = str2Num(salaryStr, 10000);
        } else {
    
    
            //否则乘以1000
            salary = str2Num(salaryStr, 1000);
        }

        //判断时间是否是月
        if ("月".equals(date)) {
    
    
            //如果是月，薪水乘以12
            salary = str2Num(salary.toString(), 12);
        }

        return salary;
    }

    private static int str2Num(String salaryStr, int num) {
    
    
        try {
    
    
            // 把字符串转为小数，必须用Number接受，否则会有精度丢失的问题
            Number result = Float.parseFloat(salaryStr) * num;
            return result.intValue();
        } catch (Exception e) {
    
    
        }
        return 0;
    }
}

4. 使用和定制Pipeline

在WebMagic中，Pileline是抽取结束后，进行处理的部分，它主要用于抽取结果的保存，也可以定制Pileline可以实现一些通用的功能。在这里我们会定制Pipeline实现数据导入到数据库中
4.1 Pipeline输出
Pipeline的接口定义如下：

public interface Pipeline {
    
    

    // ResultItems保存了抽取结果，它是一个Map结构，
    // 在page.putField(key,value)中保存的数据，
    //可以通过ResultItems.get(key)获取
    public void process(ResultItems resultItems, Task task);
}

可以看到，Pipeline其实就是将PageProcessor抽取的结果，继续进行了处理的，其实在Pipeline中完成的功能，你基本上也可以直接在PageProcessor实现，那么为什么会有Pipeline？有几个原因：

为了模块分离
“页面抽取”和“后处理、持久化”是爬虫的两个阶段，将其分离开来，一个是代码结构比较清晰，另一个是以后也可能将其处理过程分开，分开在独立的线程以至于不同的机器执行。
Pipeline的功能比较固定，更容易做成通用组件
每个页面的抽取方式千变万化，但是后续处理方式则比较固定，例如保存到文件、保存到数据库这种操作，这些对所有页面都是通用的。

在WebMagic里，一个Spider可以有多个Pipeline，使用Spider.addPipeline()即可增加一个Pipeline。这些Pipeline都会得到处理，例如可以使用
spider.addPipeline(new ConsolePipeline()).addPipeline(new FilePipeline())
实现输出结果到控制台，并且保存到文件的目标。

4.2 已有的Pipeline
WebMagic中就已经提供了控制台输出、保存到文件、保存为JSON格式的文件几种通用的Pipeline。

类	说明	备注
ConsolePipeline	输出结果到控制台	抽取结果需要实现toString方法
FilePipeline	保存结果到文件	抽取结果需要实现toString方法
JsonFilePipeline	JSON格式保存结果到文件
ConsolePageModelPipeline	(注解模式)输出结果到控制台
FilePageModelPipeline	(注解模式)保存结果到文件
JsonFilePageModelPipeline	(注解模式)JSON格式保存结果到文件	想持久化的字段需要有getter方法

4.3 案例自定义Pipeline导入数据

package cn.itcast.job.task;

import cn.itcast.job.pojo.JobInfo;
import cn.itcast.job.service.JobInfoService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import us.codecraft.webmagic.ResultItems;
import us.codecraft.webmagic.Task;
import us.codecraft.webmagic.pipeline.Pipeline;

@Component
public class SpringDataPipeline implements Pipeline {
    
    

	@Autowired
	private JobInfoService jobInfoService;

	@Override
	public void process(ResultItems resultItems, Task task) {
    
    
		// 获取封装好的招聘详情对象
		JobInfo jobInfo = resultItems.get("jobInfo");

		// 判断数据是否不为空
		if(jobInfo!=null){
    
    
			//如果不为空把数据保存到数据库
			this.jobInfoService.save(jobInfo);
		}
	}
}

4.4 在JobProcessor中修改process()启动的逻辑，添加代码

@Scheduled(initialDelay = 1000, fixedDelay = 1000 * 100)
	public void process() {
    
    
		Spider.create(new JobProcessor())
				.addUrl(url)
				.setScheduler(new QueueScheduler().setDuplicateRemover(new BloomFilterDuplicateRemover(10000000)))
				.thread(5)
				.addPipeline(this.springDataPipeline)
				.run();
	}

爬取成功
在这里插入图片描述

5. bug分析

页面解析功能saveJobInfo(Page page)，编写注意：html页面标签分析，这是存在变数的，也就可能造成代码今天能爬取，但明天就失效。
报错：java.sql.SQLException:The server time zone value xxx is unrecognized，是因为mysql驱动依赖包的问题，简单的在配置文件application.properties中配置以下即可
```
spring.datasource.driverClassName=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://127.0.0.1:3306/crawler?useUnicode=true&useJDBCCompliantTimezoneShift=true&useLegacyDatetimeCode=false&serverTimezone=UTC
```
具体说明，请看这篇文章java.sql.SQLException：mysql版本依赖的问题
端口占用问题：当8080端口被占用时，我们可以通过配置文件application.properties中配置端口
```
 server.port=80
```

从网页爬取的数据是乱码：是因为51job网页编码为gbk，而我们时常用的是utf8,所以我们需要重新设置编码方式，在以上的代码中我已经使用gbk了，所以应该不会出现这个问题。
在这里插入图片描述

private Site site = Site.me()
		.setCharset("gbk")//设置编码,根据网页编码设置
		.setTimeOut(1000 * 10)//设置超时时间
		.setRetrySleepTime(3000)//设置重试的间隔时间
		.setRetryTimes(3);//设置重试的次数

idea从数据库导出数据到Excel的步骤和出现乱码怎么办，具体问题具体分析，请看这里：IDEA导出mysql数据库中的数据，并解决文本乱码问题