構建一個給爬蟲使用的代理IP池

做網絡爬蟲時，一般對代理IP的需求量比較大。因為在爬取網站信息的過程中，很多網站做了反爬蟲策略，可能會對每個IP做頻次控制。這樣我們在爬取網站時就需要很多代理IP。

代理IP的獲取，可以從以下幾個途徑得到：

• 從免費的網站上獲取，質量很低，能用的IP極少
• 購買收費的代理服務，質量高很多
• 自己搭建代理服務器，穩定，但需要大量的服務器資源。

本文的代理IP池是通過爬蟲事先從多個免費網站上獲取代理IP之后，再做檢查判斷IP是否可用，可用的話就存放到MongoDB中，最后展示到前端的頁面上。

獲取可用Proxy

獲取代理的核心代碼是ProxyManager，它采用RxJava2來實現，主要做了以下幾件事：

1. 創建ParallelFlowable，針對每一個提供免費代理IP的頁面並行地抓取。對於不了解ParallelFlowable的同學，可以看我之前的文章RxJava 之 ParallelFlowable

Flowable.fromIterable(ProxyPool.proxyMap.keySet())
                .parallel()

1. 針對每一個頁面進行抓取，返回List<Proxy>

   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;
                   }
               })

2. 對每一個頁面獲取的代理IP列表進行校驗，判斷是否可用

   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);
                   }
               })

3. 依次保存到proxyList

   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中。

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地址：
https://github.com/fengzhizi715/ProxyPool