一个简单的多线程爬虫

　

  　本文介绍一个简单的多线程并发爬虫，这里说的简单是指爬取的数据规模不大，单机运行，并且不使用数据库，但保证多线程下的数据的一致性，并且能让爬得正起劲的爬虫停下来，而且能保存爬取状态以备下次继续。

　　爬虫实现的步骤基本如下： 

• 分析网页结构，选取自己感兴趣的部分;
• 建立两个Buffer，一个用于保存已经访问的URL，一个用户保存带访问的URL;
• 从待访问的Buffer中取出一个URL来爬取，保存这个URL中感兴趣的信息；并将这个URL加入已经访问的Buffer中，然后将这个URL中的所有外链URLs中没有被访问过的URL加到待访问Buffer；
• 只要待访问的Buffer不为空，重复上一步。

　　这次是为了给博客园的用户进行一次pagerank排名，爬取了博客园各个用户的粉丝与关注者。博客园的用户用17万多个。爬取的页面是http://home.cnblogs.com/u/+userId，每个用户的url只需要用用户的id表示就可以了，用户id按平均10B来计算，保存所有用户也只需1.7Mb内存。因此我把两个Buffer都放在内存中。

　　这个项目的就四个java文件，结构如下：　　

　　下面对整个爬虫的实现过程进行详细的介绍。

一、登录

　　要获取用户的粉丝与关注，必须先登录，博客园的模拟登陆算是比较简单，找到登录时要上传的参数，然后Pos发送即登录成功，可以使用Chrome的工具，打开登录页面，调好账号和密码后，按F12弹出工具，按登录就能看到要传的参数了，再POST一个这些参数就好了。　　

　　我之前是使用这样的方式，后来用使用Jsoup解析的参数，代码实现如下：

　　/**
     * 使用Joup解析登录参数，然后POST发送参数实现登录
     * 
     * @throws UnsupportedEncodingException
     * @throws IOException
     */
    private static void login() throws UnsupportedEncodingException,
            IOException {
        CookieHandler.setDefault(new CookieManager());
        // 获取登录页面
        String page = getPage(LOGIN_URL);
        // 从登录去取出参数，并填充账号和密码
        Document doc = Jsoup.parse(page);
        // 取登录表格
        Element loginform = doc.getElementById("frmLogin");
        Elements inputElements = loginform.getElementsByTag("input");
        List<String> paramList = new ArrayList<String>();
        for (Element inputElement : inputElements) {
            String key = inputElement.attr("name");
            String value = inputElement.attr("value");
            if (key.equals("tbUserName"))
                value = Test.Name;
            else if (key.equals("tbPassword"))
                value = Test.passwd;
            paramList.add(key + "=" + URLEncoder.encode(value, "UTF-8"));
        }
        // 封装请求参数
        StringBuilder para = new StringBuilder();
        for (String param : paramList) {
            if (para.length() == 0) {
                para.append(param);
            } else {
                para.append("&" + param);
            }
        }
        // POST发送登录
        String result = sendPost(LOGIN_URL, para.toString());
        if (!result.contains("followees")) {
            cookies = null;
            System.out.println("登录失败");
        } else
            System.out.println("登录成功");
    }

二、获取粉丝与关注

　　登录成功就可以爬取粉丝和关注了，关注在http://home.cnblogs.com/u/userid/followees/链接中，而粉丝在http://home.cnblogs.com/u/userid/followers/，两个网页结构基本相同，只需要把选择一下followees（被关注者）和（followers）关注者，用Jsoup解析avatar_list中avatar_name就好了，代码如下：

　　/**
     * 获取一页中的关注or粉丝
     * 
     * @param pageHtml
     * @return
     */

    private List<String> getOnePageFriends(Document doc) {
        List<String> firends = new ArrayList<String>();
        Elements inputElements = doc.getElementsByClass("avatar_name");
        for (Element inputElement : inputElements) {
            Elements links = inputElement.getElementsByTag("a");
            for (Element link : links) {
                //从href中解析出用户id
                String href = link.attr("href");
                firends.add(href.substring(3, href.length() - 1));
            }
        }
        return firends;
    }

　　每一页显示50个粉丝or关注者，需要分页爬取，获取下一页跟获取用户粉丝差不多，找到元素就好。

三、爬取单个用户

　　爬取的一个用户的过程就是先分页爬取粉丝，再爬取关注者，然后把爬过的用户放入访问Buffer中，再把爬到的用户放到未访问队列中。

    @Override
    public void run() {        
        while (stop.get() == false) {
            // 取出一个待访问
            String userId = mUserBuffer.pickOne();            
            try {
                // 爬取粉丝
                List<String> fans = crawUser(userId, "/followers");
                // 爬取关注者
                List<String> heros = crawUser(userId, "/followees");
                // 只需要保持粉丝关系即可
                StringBuilder sb = new StringBuilder(userId).append("	");
                for (String friend : fans) {
                    sb.append(friend).append("	");
                }
                sb.deleteCharAt(sb.length() - 1).append("
");
                saver.save(sb.toString());
                // 被关注者应该放进队列里面，以供下次爬取他的粉丝
                fans.addAll(heros);
                mUserBuffer.addUnCrawedUsers(fans);
            } catch (Exception e) {
                saver.log(e.getMessage());
                // 访问错误时，放入访问出错的队列中，以备以后重新访问。
                mUserBuffer.addErrorUser(userId);
            }
        }    

　　一页一页爬取单个用户如下：

      /**
     * 爬取用户，根据tag来决定是爬该用户关注的人，还是该用户的粉丝
     * 
     * @param userId
     * @return
     * @throws IOException
     */
    private List<String> crawUser(String userId, String tag) throws IOException {
        //构造URL
        StringBuilder urlBuilder = new StringBuilder(USER_HOME);
        urlBuilder.append("/u/").append(userId).append(tag);
        //请求页面
        String page = getPage(urlBuilder.toString());
        Document doc = Jsoup.parse(page);
        List<String> friends = new ArrayList<String>();
        //爬取第一页
        friends.addAll(getOnePageFriends(doc));
        String nextUrl = null;
        //不断地爬取下一页
        while ((nextUrl = getNextUrl(doc)) != null) {
            page = getPage(nextUrl);
            doc = Jsoup.parse(page);
            friends.addAll(getOnePageFriends(doc));
        }
        return friends;
    }

　　 整个爬虫结构就是这样了:

public class UserCrawler implements Runnable {
    // 停止任务标志
    private static AtomicBoolean stop;
    // 当前爬虫的id
    private int id;
    // 用户缓存
    private UserBuffer mUserBuffer;
    // 日志与粉丝保存工具
    private Saver saver;

    static {
        stop = new AtomicBoolean(false);
        try {
            // 登录一次即可
            login();
            // 保存数据线程先启动
            Saver.getInstance().start();
        } catch (IOException e) {
            e.printStackTrace();
        }
        // new Thread(new CommandListener()).start();
    }

    public UserCrawler(UserBuffer userBuffer) {
        mUserBuffer = userBuffer;
        mUserBuffer.crawlerCountIncrease();
        id = c++;
        saver = Saver.getInstance();
    }

    @Override
    public void run() {
        if (id > 0) {
            // 等第一个线程启动一段时候再开始新的线程
            try {
                TimeUnit.SECONDS.sleep(20 + id);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("UserCrawler " + id + " start");
        int retry = 3;// 重置尝试次数
        while (stop.get() == false) {
            // 取出一个待访问
            String userId = mUserBuffer.pickOne();
            if (userId == null) {// 队列元素已经为空
                retry--;// 重试3次
                if (retry <= 0)
                    break;
                 continue;
            }
            ...//爬取用户
        }
        System.out.println("UserCrawler " + id + " stop");
        // 当前线程停止了
        mUserBuffer.crawlerCountDecrease();
    }
    
    private List<String> crawUser(String userId, String tag) throws IOException {
        
    }

    /**
     * 获取一页中的关注or粉丝
     * 
     * @param pageHtml
     * @return
     */

    private List<String> getOnePageFriends(Document doc) {
        ...
    }

    /**
     * 获取下一页的地址
     * 
     * @param doc
     * @return
     */
    private String getNextUrl(Document doc) {
        
    }

    private static String getPage(String pageUrl) throws IOException {
        
    }

    /***
     * 终止所有爬虫任务
     */
    public static void stop() {
        System.out.println("正在终止...");
        stop.compareAndSet(false, true);
        UserBuffer.getInstance().prepareForStop();
    }

    private static void login() throws UnsupportedEncodingException,
            IOException {
        ...
    }


    private static String sendPost(String url, String postParams)
            throws IOException {
        ...

}

四、Buffer并发控制

　　在用户Buffer设置一个已经访问的用户集合、一个访问出错的用户集合和一个待访问的队列。

    private UserBuffer() {
        crawedUsers = new HashSet<String>();// 已经访问的用户,包括访问成功和访问出错的用户
        errorUsers = new HashSet<String>();// 访问出错的用户
        unCrawedUsers = new LinkedList<String>();// 未访问的用户
    }

　　UserBuffer全局唯一，因此采用单例模式，使用的集合和队列都不是线程安全的数据结构，我认为没有必要使用线程安全的ConcurrentSkipListSet与ConcurrentLinkedQueue，因为将一个用户插入unCrawedUsers队列时需要先判断是否已经存在于crawedUsers用户集合中了，这需要用锁来同步访问，如果不使用锁来控制，单个线程安全的set和queque不能保证多个变量之间的test-try有效性。而使用了锁后，再使用线程安全的数据结构只会增加加锁和解锁的次数，反而降低了性能。

    /***
     * 添加未访问的用户 
     * 
     * @param users
     * @return
     */
    public synchronized void addUnCrawedUsers(List<String> users) {
        // 添加未访问的用户
        for (String user : users) {
            if (!crawedUsers.contains(user))
                unCrawedUsers.add(user);
        }
    }

    /**
     * 从队列中取一个元素,并把这个元素添加到已经访问的集合中，以免重复访问。
     * 
     * 
     * @return
     */
    public synchronized String pickOne() {
        String newId = unCrawedUsers.poll();
        // 队列中可能包含重复的id，因为插入队列时只检查是否在访问集合里，
        // 没有检查是否已经出现在队列里
        while (crawedUsers.contains(newId)) {
            newId = unCrawedUsers.poll();
        }
        //访问前先把添加到已经访问的集合中
        crawedUsers.add(newId);
        return newId;
    }

    /**
     * 添加访问出错的用户
     * 
     * @param userId
     */
    public synchronized void addErrorUser(String userId) {
        errorUsers.add(userId);
    }

 

五、安全地终止爬虫

　　大丈夫能伸能屈，能走能停，爬虫也当如此。爬博客园的用户时，我真是提心吊胆，担心管理员封我的账号，我尽量挑凌晨的时间爬数据，另外就是爬了一会后，我就停下来，过一段时间再爬。要让一个多线程的程序平稳的停下来还真不简单，最担心的就是死锁，发送停止命令后，线程不动却也没有终止，爬了好久的Buffer空间没有保存，那个恨啊。

　　我的思路:

　　1、爬虫启动时，向Buffer注册一下，buffer记录启动的爬虫数量；

　　2、对爬虫设置一个全局的标志，爬虫在每次爬取一个用户前检查终止标志是否被设置；

　　3、当发生停止命令时，爬虫检查到停止标志被设置，于是通知Buffer自己将要停止，通知完后就结束运行；

　　4、Buffer收到爬虫停止通知后，将爬虫计数器减1，当计数器为0时，保存工作空间，同时通知关闭日志；

　　5、为了避免有些爬虫在运行异常时推出而没有通知Buffer，在发出停止命令时，同时通知Buffer准备停止，Buffer设置一个计时器，2分钟后，强制保存爬虫状态和日志。

　　完整的代码还是放在Github上，有兴趣的同学可以看看。 

　　感谢阅读，转载请注明出处：http://www.cnblogs.com/fengfenggirl/