构建一个给爬虫使用的代理IP池

时间 2019-11-24

标签构建一个爬虫使用代理栏目网络爬虫繁體版

原文原文链接

作网络爬虫时，通常对代理IP的需求量比较大。由于在爬取网站信息的过程当中，不少网站作了反爬虫策略，可能会对每一个IP作频次控制。这样咱们在爬取网站时就须要不少代理IP。前端

代理IP的获取，能够从如下几个途径获得：java

从免费的网站上获取，质量很低，能用的IP极少
购买收费的代理服务，质量高不少
本身搭建代理服务器，稳定，但须要大量的服务器资源。

本文的代理IP池是经过爬虫事先从多个免费网站上获取代理IP以后，再作检查判断IP是否可用，可用的话就存放到MongoDB中，最后展现到前端的页面上。react

获取可用Proxy

获取代理的核心代码是ProxyManager，它采用RxJava2来实现，主要作了如下几件事：git

建立ParallelFlowable，针对每个提供免费代理IP的页面并行地抓取。对于不了解ParallelFlowable的同窗，能够看我以前的文章RxJava 之 ParallelFlowable

Flowable.fromIterable(ProxyPool.proxyMap.keySet())
                .parallel()复制代码

针对每个页面进行抓取，返回Listgithub

map(new Function<String, List<Proxy>>() {
                 @Override
                 public List<Proxy> apply(String s) throws Exception {

                     try {
                         return new ProxyPageCallable(s).call();
                     } catch (Exception e) {
                         e.printStackTrace();
                     }

                     return null;
                 }
             })复制代码

对每个页面获取的代理IP列表进行校验，判断是否可用spring

flatMap(new Function<List<Proxy>, Publisher<Proxy>>() {
                 @Override
                 public Publisher<Proxy> apply(List<Proxy> proxies) throws Exception {

                     if (proxies == null) return null;

                     List<Proxy> result = proxies
                             .stream()
                             .parallel()
                             .filter(new Predicate<Proxy>() {
                         @Override
                         public boolean test(Proxy proxy) {

                             HttpHost httpHost = new HttpHost(proxy.getIp(), proxy.getPort(), proxy.getType());
                             return HttpManager.get().checkProxy(httpHost);
                         }
                     }).collect(Collectors.toList());

                     return Flowable.fromIterable(result);
                 }
             })复制代码

依次保存到proxyListapache

subscribe(new Consumer<Proxy>() {
                 @Override
                 public void accept(Proxy proxy) throws Exception {
                     log.debug("Result Proxy = "+proxy.getType()+"://"+proxy.getIp()+":"+proxy.getPort());
                     proxy.setLastSuccessfulTime(new Date().getTime());
                     ProxyPool.proxyList.add(proxy);
                 }
             });复制代码

附上完整的流程图
服务器

再附上完整的ProxyManager代码：网络

import com.cv4j.proxy.domain.Proxy;
import com.cv4j.proxy.http.HttpManager;
import com.cv4j.proxy.task.ProxyPageCallable;
import io.reactivex.Flowable;
import io.reactivex.functions.Consumer;
import io.reactivex.functions.Function;
import lombok.extern.slf4j.Slf4j;
import org.apache.http.HttpHost;
import org.reactivestreams.Publisher;
import org.springframework.stereotype.Component;

import java.util.Date;
import java.util.List;
import java.util.function.Predicate;
import java.util.stream.Collectors;

/** * Created by tony on 2017/10/25. */
@Slf4j
@Component
public class ProxyManager {

    /** * 抓取代理，成功的代理存放到ProxyPool中 */
    public void start() {

        Flowable.fromIterable(ProxyPool.proxyMap.keySet())
                .parallel()
                .map(new Function<String, List<Proxy>>() {
                    @Override
                    public List<Proxy> apply(String s) throws Exception {

                        try {
                            return new ProxyPageCallable(s).call();
                        } catch (Exception e) {
                            e.printStackTrace();
                        }

                        return null;
                    }
                })
                .flatMap(new Function<List<Proxy>, Publisher<Proxy>>() {
                    @Override
                    public Publisher<Proxy> apply(List<Proxy> proxies) throws Exception {

                        if (proxies == null) return null;

                        List<Proxy> result = proxies
                                .stream()
                                .parallel()
                                .filter(new Predicate<Proxy>() {
                            @Override
                            public boolean test(Proxy proxy) {

                                HttpHost httpHost = new HttpHost(proxy.getIp(), proxy.getPort(), proxy.getType());
                                return HttpManager.get().checkProxy(httpHost);
                            }
                        }).collect(Collectors.toList());

                        return Flowable.fromIterable(result);
                    }
                })
                .sequential()
                .subscribe(new Consumer<Proxy>() {
                    @Override
                    public void accept(Proxy proxy) throws Exception {
                        log.debug("Result Proxy = "+proxy.getType()+"://"+proxy.getIp()+":"+proxy.getPort());
                        proxy.setLastSuccessfulTime(new Date().getTime());
                        ProxyPool.proxyList.add(proxy);
                    }
                });
    }
}复制代码

定时任务

每隔几个小时跑一次定时任务，在抓取完任务以后先删除旧的数据，而后再把新的数据插入到MongoDB中。app

import com.cv4j.proxy.ProxyManager;
import com.cv4j.proxy.ProxyPool;
import com.cv4j.proxy.dao.ProxyDao;
import com.cv4j.proxy.domain.Proxy;
import com.safframework.tony.common.utils.Preconditions;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

import java.util.concurrent.CopyOnWriteArrayList;

/** * Created by tony on 2017/11/22. */
@Component
public class ScheduleJobs {

    @Autowired
    ProxyDao proxyDao;

    @Autowired
    ProxyManager proxyManager;

    /** * 每六个小时跑一次任务 */
    @Scheduled(cron = "0 0 */6 * * ?")
    public void cronJob() {
        System.out.println("Job Start...");

        proxyManager.start();

        CopyOnWriteArrayList<Proxy> list = ProxyPool.proxyList;

        // 先删除旧的数据
        proxyDao.deleteAll();

        // 而后再进行插入新的proxy
        if (Preconditions.isNotBlank(list)) {

            for (Proxy p:list) {

                proxyDao.saveProxy(p);
            }
        }

        System.out.println("Job End...");
    }
}复制代码

展现到前端

整个项目使用Spring Boot搭建，运行起来以后本地访问地址：
http://localhost:8080/load?pagename=proxy_list

预览效果以下：

在使用前，还能够再作一次检测，只要双击某个代理IP便可。

在第二次检测时，对于已经失效的IP会被ProxyPool删除。

总结

在作爬虫时，本身维护一个可用的代理IP池是颇有必要的事情，固然想要追求更高稳定性的代理IP仍是考虑购买比较好。

最后，附上github地址：
github.com/fengzhizi71…