Java爬取CSDN博客

水深无声 2022-08-21 05:51 338阅读 0赞

最近由于要做一个关于技术博客搜索的搜索工具，我开始接触到了爬虫，因为Java学的比较精通（主要是有很多封装的工具包），写了一个小小的Demo，进入主题吧
参开博客链接

  1. 请求的规则，我用的是Jsoup请求网页，它可以在请求时，按照你设置的规则来进行请求，所有要有一个请求规则类，PS：但是后面好像并没有什么用到

规则的父类，一般请求都需要的

  1. package com.lg.po;
  3. import java.io.Serializable;
  5. /** * 规则的父类，一般请求都需要的 * @author LG * */
  6. public class SuperRule implements Serializable{ 
  7.     /** * 网页路径 */
  8.     private String url;
  9.     /** * GET/POST请求 */
  10.     private int requestType = GET;
  11.     /** * GET请求方式 */
  12.     public final static int GET = 0;
  13.     /** * POST请求方式 */
  14.     public final static int POST = 1;
  15.     /** * 参数集合 */
  16.     private String[] params;
  17.     /** * 参数对应的值 */
  18.     private String[] values;
  19.     /** * 对返回的HTML，第一次过滤所使用的标签， */
  20.     private String resultTagName;
  21.     /** * CLASS / ID / SELECTION * 设置resultTagName的类型，默认为ID */
  22.     private int type = ID;
  24.     public final static int ID = 0;
  25.     public final static int CLASS = 1;
  26.     public final static int SELECTION = 2;
  28.     public SuperRule(){}
  29.     public SuperRule(String url){
  30.    this.url = url;}
  31.     public SuperRule(String url, int requestType, String[] params, String[] values,
  32.             String resultTagName,int type) {
  33.         super();
  34.         this.url = url;
  35.         this.requestType = requestType;
  36.         this.params = params;
  37.         this.values = values;
  38.         this.resultTagName = resultTagName;
  39.         this.type = type;
  40.     }
  41.     //剩下的set，get方法自己脑补
  42.     }

解析CSDN博客的规则类

  1. package com.lg.po;
  2. /** * 博客规则类 * @author LG * */
  3. public class BlogRule extends SuperRule{ 
  6.     /** * 用于判断是否从博客空间到某一篇具体的博客,默认false */
  7.     private boolean isDirect = false;
  8.     /** * 该博客链接的类型,默认BLOG */
  9.     private int blogType = BLOG;
  10.     /** * HOME我的 SPACE博客空间 BLOG博客 */
  11.     public final static int HOME = 0;
  12.     public final static int SPACE = 1;
  13.     public final static int BLOG = 2;
  14.     public BlogRule(){}
  15.     public BlogRule(boolean isDirect, int blogType) {
  16.         super();
  17.         this.isDirect = isDirect;
  18.         this.blogType = blogType;
  19.     }

2.获取网页的类容，因为向服务器请求的过程中，如果请求的频率和次数都比较高的话，可能遭到别人反爬虫，网上有很多解决反爬的方法，如，降低请求次数，分时段爬取，我这里用的是换代理，一个IP不行了另一个赶紧顶上，免费IP代理地址

  1. package com.lg.utils;
  3. import java.io.IOException;
  4. import java.util.Map;
  5. import java.util.Queue;
  6. import java.util.concurrent.CountDownLatch;
  8. import org.apache.http.HttpEntity;
  9. import org.apache.http.HttpHost;
  10. import org.apache.http.HttpResponse;
  11. import org.apache.http.client.methods.HttpGet;
  12. import org.apache.http.impl.client.CloseableHttpClient;
  13. import org.apache.http.impl.client.HttpClients;
  14. import org.apache.http.util.EntityUtils;
  15. import org.jsoup.Connection;
  16. import org.jsoup.Jsoup;
  17. import org.jsoup.nodes.Document;
  19. import com.lg.filter.DatasBackUp;
  20. import com.lg.po.BlogRule;
  21. import com.lg.po.SuperRule;
  22. /** * 解析网页的工具类 * @author LG * */
  23. public class ParseCommenUtil { 
  24.     /** * 标识换IP是只能一个线程换 */
  25.     private static  boolean ischange = true;
  26.     /** * 代理IP */
  27.     private static String proxyHost = "218.106.96.196";
  28.     /** * 代理端口 */
  29.     private static int proxyPort = 80;
  31.     /** * 下载某个路径的网页 */
  32.     public static Document download(SuperRule rule,Queue<String> ipQueue){  
  33.         Document doc = downloadHttp(rule,ipQueue);  
  34.         try {
  35.             doc.setBaseUri("http://blog.csdn.net");//设置网页的基本路径，因为网页中有的用的是相对路径
  36.         } catch (Exception e) {
  37.             System.out.println("设置基础URL出错");        
  38.         }       
  39.         return doc;
  40.     }
  41.     /** * 通过HttpClient方式下载网页 * @param rule * @param ipQueue * @return */
  42.     public static  Document downloadHttp(SuperRule rule,Queue<String> ipQueue){
  43.    //通过HttpClient方式在网页
  45.         CloseableHttpClient httpClient = HttpClients.createDefault();  
  46.         HttpGet httpGet = new HttpGet(rule.getUrl());
  47.         //这里要设置模拟浏览器登录，要不然直接拒绝你
  48.         httpGet.setHeader("User-Agent", "Mozilla/5.0 (Windows; U; Windows NT 5.1; zh-CN; rv:1.9.1.2)");
  49.         httpGet.setHeader("Accept-Language", "zh-cn,zh;q=0.5");
  50.         httpGet.setHeader("Accept-Charset", "GB2312,utf-8;q=0.7,*;q=0.7");
  51.         HttpResponse response = null;       
  52.         while(true){
  53.             try {
  54.                 response = httpClient.execute(new HttpHost(proxyHost, proxyPort),httpGet);
  55.                 HttpEntity entity = response.getEntity();
  56.                 return Jsoup.parse(EntityUtils.toString(entity));
  57.             } catch (Exception e) { //发生异常换IP 
  58.                 ischange = true;//打开门
  59.                 chageIP(rule, ipQueue);
  60.             }
  61.         }
  62.     }
  63.     /** * 换IP的方法，这里要注意静态变量的线程安全，所有用到了Java中异步的方式 * @param r * @param ipQueue */
  64.     public static synchronized void chageIP(SuperRule r,Queue<String> ipQueue){
  65.         if(ischange){
  66.    //当可以换IP是，一个线程进来，其它线程等待
  67.             if (ipQueue.size()>0) {
  68.                 try {
  69.                     String ip_port = ipQueue.poll();
  70.                     String[] ips = ip_port.split(":");
  71.                     proxyHost = ips[0];
  72.                     proxyPort = Integer.parseInt(ips[1]);
  73.                     System.out.println("成功换IP---------------------"+proxyHost);
  74.                 } catch (Exception e2) {
  75.                     System.out.println("换IP发生错误");
  76.                 }           
  77.               }
  78.               ischange = false;//当一个线程换完IP后，其它的线程就不能换了，除非这个IP不能用,关上门
  79.         }
  81.     }
  82.       /** * 输出队列中元素 * @param q */
  83.     public static void sop(Queue<BlogRule> q){
  84.         BlogRule rule = null;
  85.         while((rule=q.poll())!=null){
  86.             System.out.println(rule.getUrl());
  87.         }
  88.     }
  90.     /** * 爬取是一个树状的方式，所以会有重复的，这里是通过一个Map来记录已经解析过得URL，用Map是因为HashMap * 是根据哈希表来进行存储数据的，查询的效率高 */
  91.     public static boolean isDownloaded(Map<String, Boolean> map,String url){
  92.         if(map.get(url)==null){
  93.    //如果不在Map中
  94.             return false;
  95.         }
  96.         else {
  97.             return true;
  98.         }
  99.     }
  100.     /** * 有时爬取的时候会出现一些错误，或者准备的IP用完了，不得不停止程序，但是存入数据库的解析过的网页数据又不能用，因为会重复， * 所以这里就写了一个把没有处理完的URL和已经处理过的URL写到本地去得方法 * @param queuespace */
  101.     public static void writeToLocal(Queue<BlogRule> queue,Queue<BlogRule> queuespace,Map<String, Boolean> map){
  102.         CountDownLatch countDownLatch = new CountDownLatch(3);//计数器，只有等这全部写完后，才能运行下面的程序
  103.         String basepath = "C:\\Users\\LG\\Desktop\\proxy\\";//存储路径自己定义
  104.         new Thread(new DatasBackUp(queue,basepath+"blogurl.txt",countDownLatch)).start();//存取博文的文件
  105.         new Thread(new DatasBackUp(queuespace,basepath+"blogspace.txt",countDownLatch)).start();//存取博客空间（这里可以查看博主所有博文）的路径，
  106.         new Thread(new DatasBackUp(map,basepath+"blogtemp.txt",countDownLatch)).start();//存取解析过的URL路径
  107.         try {
  108.             countDownLatch.await();
  109.             System.out.println("备份完成");
  110.         } catch (Exception e1) {
  111.             System.out.println("备份等待时错误");
  112.         }
  113.     }
  114. }

3.解析博客的主要实现类，包含一个抽象类

  1. package com.lg.parse;
  3. import java.util.Collections;
  4. import java.util.HashMap;
  5. import java.util.LinkedList;
  6. import java.util.Map;
  7. import java.util.Queue;
  8. import java.util.Set;
  9. import java.util.concurrent.ConcurrentLinkedQueue;
  10. import java.util.concurrent.CountDownLatch;
  11. import org.jsoup.nodes.Element;
  12. import org.jsoup.select.Elements;
  14. import com.lg.po.BlogDatas;
  15. import com.lg.po.BlogRule;
  16. import com.lg.utils.ParseCommenUtil;
  18. /** * 解析博客的抽象类 * @author LG * */
  19. public abstract class AbstractBlogParse implements BlogParseable<BlogDatas>{ 
  20.     /** * 检测是否重复的存储单位 */
  21.     public static Map<String, Boolean> map = Collections.synchronizedMap(new HashMap<String, Boolean>());
  22.     /** * 开启线程 的数量 */
  23.     protected int count = 0;
  24.     public void setCount(int count) {
  25.         this.count = count;
  26.     }
  27.     /** * 存放代理IP的队列 */
  28.     public static Queue<String> ipQueue = new LinkedList<String>();
  29.     /** * 待解析的博文链接队列,线程安全 */
  30.     public static Queue<BlogRule> queue = new ConcurrentLinkedQueue<BlogRule>();
  31.     /** * 带解析的博客空间队列,线程安全 */
  32.     public static Queue<BlogRule> queuespace = new ConcurrentLinkedQueue<BlogRule>();
  33.     /** * 解析的主要方法，该方法继承自BlogParseable接口，该接口中只有一个parseMain()方法 */
  34.     public Set<BlogDatas> parseMain() {
  35.         CountDownLatch countDownLatch = new CountDownLatch(count);
  36.         for (int i = 0; i < count; i++) {   //开启多线程爬取，--------这里是正式开始爬了 
  37.             new Thread(new MyRunnable(countDownLatch)).start();
  38.         }
  39.         try {
  40.             countDownLatch.await();
  41.         } catch (Exception e1) {
  42.             System.out.println("countDownLatch发成了异常---计数器");
  43.         }
  44.         return null;        
  45.     }
  47.     public abstract void parseSpace(BlogRule rule);
  49.     public abstract void parseBlog(BlogRule rule);
  51.     /** * 遍历博客空间 链接 得到如：http://blog.csdn.net/lmj623565791，存入队列 */
  52.     protected void getSpacesUrl(Elements links) {
  53.         if (links.size()>0) {
  54.             for(Element link:links){
  55.                 BlogRule br = new BlogRule(link.absUrl("href"),BlogRule.SPACE);
  56.                 if (!ParseCommenUtil.isDownloaded(map, br.getUrl())) {
  57.                     queuespace.offer(br);  
  58.                 }
  59.             }
  60.         }
  61.     }
  63.     /** * 遍历所有博客，得到如：http://blog.csdn.net/lmj623565791/article/details/50709663，存入队列 */
  64.     protected void getBlogsUrl(Elements links) {
  65.         if (links.size()>0) {
  66.             for(Element link:links){
  67.                 BlogRule br = new BlogRule();
  68.                 String url = link.absUrl("href");
  69.                 if (!ParseCommenUtil.isDownloaded(map, url)) {
  70.                     br.setUrl(url);
  71.                     br.setBlogType(BlogRule.BLOG);
  72.                     br.setIsDirect(true);
  73.                     queue.offer(br);
  74.                 }
  76.             }           
  77.         }
  78.     }
  80.     /** * 解析网页的多线程类 * @author LG * */
  81.     class MyRunnable implements Runnable{ 
  83.         private CountDownLatch countdown = null;
  84.         public MyRunnable(CountDownLatch countdown){
  85.             this.countdown = countdown;
  86.         }
  87.         public void run() { 
  88.             BlogRule rule = null;
  89.             while(((rule=queue.poll())!=null)||((rule=queuespace.poll())!=null)){
  90.    //当解析队列不为空时
  91.                 System.out.println(queue.size()+"--"+queuespace.size());
  92.                 //判断博客的类型
  93.                 switch (rule.getBlogType()){
  94.                     case BlogRule.BLOG:
  95.                         parseBlog(rule);
  96.                         break;
  97.                     case BlogRule.SPACE:
  98.                         parseSpace(rule);
  99.                         break;              
  100.                 }
  101.             }
  102.             countdown.countDown();
  103.         }       
  104.     }
  106. }
  109. //继承类
  110. package com.lg.parse;
  112. import java.util.regex.Matcher;
  113. import java.util.regex.Pattern;
  115. import org.jsoup.nodes.Document;
  116. import org.jsoup.nodes.Element;
  117. import org.jsoup.select.Elements;
  119. import com.lg.db.OperateDB;
  120. import com.lg.po.BlogRule;
  121. import com.lg.po.SuperRule;
  122. import com.lg.utils.ParseCommenUtil;
  123. import com.lg.utils.TextUtil;
  124. /** * 解析CSDN博客主要类 */
  125. public class CsdnBlogsParse extends AbstractBlogParse{ 
  126.     /** * 记录解析的网页的数量 */
  127.     public static int dataCount = 0;
  128.     /** * 多久向本地更新一次没有处理完的URL和已经处理完的URL，这里设置的值当存储到数 * 据库的超过500条时，更新一次 */
  129.     public static int backTime = 0;
  130.     /** * 暂存已经解析的网页数据,用于数据库的插入，可用于多线程 */
  131.     private static StringBuffer dataBuffer = new StringBuffer();
  133.     public static StringBuffer getDataBuffer() {
  134.         return dataBuffer;
  135.     }
  137.     public static void setDataBuffer(StringBuffer dataBuffer) {
  138.         CsdnBlogsParse.dataBuffer = dataBuffer;
  139.     }
  141.     /** * 解析的某一篇博客的方法 * @param url */
  142.     public void parseBlog(BlogRule rule){
  143.         if (!ParseCommenUtil.isDownloaded(map, rule.getUrl())) {
  144.    //如果url没被访问过
  145.             Document doc = ParseCommenUtil.download(rule,ipQueue);  
  146.             //缩小寻找的范围
  147.             Element ele = doc.getElementById("article_details");
  149.             if (ele!=null) {
  150.                 String blog_title = null;//标题
  151.                 String blog_url = null;//链接
  152.                 String labels = null;//标签
  153.                 String readDate = null,reads=null,comments = null;//发布时间
  154.                 int readTimes = 0;//阅读量
  155.                 int commentTimes = 0;//评论量
  156.                 String userClass = null;//分类
  158.                 Elements title = ele.select("div.article_title > h1 > span > a");
  159.                 if (title!=null&&title.size()>0) {
  160.                     blog_title = title.first().ownText();
  161.                     blog_title = blog_title.replaceAll("'", "\\\\'");
  162.                     blog_url = title.first().absUrl("href");
  163.                 }
  165.                 Elements cate = ele.select("span.link_categories");
  166.                 if (cate!=null&&cate.size()>0) {
  167.                     Elements categorys = cate.first().getElementsByTag("a");
  168.                     if (categorys!=null&&categorys.size()>0) {
  169.                         String temp = "";
  170.                         for(Element category:categorys)
  171.                             temp+= category.text()+",";
  172.                         labels = temp;
  173.                     }
  174.                 }
  176.                 Elements reads_before = ele.select("div.article_r");
  177.                 if (reads_before!=null&&reads_before.size()>0) {
  178.                     readDate = reads_before.first().child(0).text();
  179.                     reads = reads_before.first().child(1).text();
  180.                     readTimes = Integer.parseInt(reads.substring(0, reads.indexOf("人")));
  181.                     comments = reads_before.first().child(2).text();
  182.                 }
  183.                 commentTimes = Integer.parseInt(comments.substring(comments.indexOf("(")+1, comments.indexOf(")")));
  184.                 Elements c = ele.select("div.category_r > label > span");
  186.                 if (c!=null&&c.size()>0) {
  187.                     Element classes = c.first();
  188.                     userClass = classes.ownText();
  189.                 }   
  190.                 dataBuffer.append("('" +blog_title+"','" +blog_url+ "','" + labels+ "','" +readDate+ "',"+readTimes +","  +
  191.                         commentTimes +",'"  + userClass + "'" +"),");
  192.                 OperateDB.insert();//如果解析的网页数据已经达到50，开始向数据库存数据
  193.                 parseComment(doc);  
  194.                 if(!rule.getIsDirect()){
  195.                     //将该博客空间加入队列
  196.                     queuespace.offer(new BlogRule("http://blog.csdn.net/"+TextUtil.getUserName(rule.getUrl()),BlogRule.SPACE));
  197.                     parseHome(doc);
  198.                 }
  199.             }
  200.             map.put(rule.getUrl(), true);
  201.         }
  202.     }
  204.     /** * 获取博客空间中所有博客的URL */
  205.     public void parseSpace(BlogRule rule){
  206.         if (!ParseCommenUtil.isDownloaded(map, rule.getUrl())) {
  207.             Document doc = ParseCommenUtil.download(rule,ipQueue);
  208.             if (TextUtil.isOpenBlog(doc)&&doc.select("div.article_title")!=null) {
  209.    //如果开通了博客
  210.                 Elements links = doc.select("div.article_title > h1 > span > a");
  211.                 if (links!=null&&links.size()>0) {
  212.                     getBlogsUrl(links); 
  213.                 }
  214.                 parseNextPage(doc); 
  215.                 //左边相关链接
  216.                 //parseLeftLink(doc);
  217.                 //我的博客
  218.                 parseHome(doc);
  220.                 map.put(rule.getUrl(), true); //将解析过的URL放入Map中
  221.             }   
  222.         }
  224.     }
  226.     /** * 解析我的个人信息 */
  227.     protected void parseHome(Element ele){
  228.         String personHome = ele.getElementById("blog_userface").child(0).absUrl("href");
  229.         Document doc = ParseCommenUtil.download(new SuperRule(personHome),ipQueue);
  230.         Elements relations = doc.select("div.mod_relations");
  231.         if (relations!=null&&relations.size()>0) {
  232.             Elements persionlinks = relations.first().getElementsByTag("a");
  233.             getSpacesUrl(persionlinks);
  234.         }
  235.     }
  237.     /** * 解析左边栏 相关链接 */
  238.     protected void parseLeftLink(Element doc) {
  239.         Element links_before = doc.getElementById("side");
  240.         if (links_before!=null) {
  241.             Elements links = links_before.select("ul.panel_body > ul > li > a");
  242.             getSpacesUrl(links);
  243.         }
  244.     }
  246.     /** * 解析博客评论人的路径，有问题，有待改进 */
  247.     protected void parseComment(Element doc) {
  248.         Element links_before = doc.getElementById("comment_list");
  249.         if (links_before!=null) {
  250.             Elements links = links_before.select("dd.comment_userface > a");
  251.             getSpacesUrl(links);
  252.         }
  253.     }
  255.     /** * 解析博客空间中下一页博客URL */
  256.     public void parseNextPage(Element doc){
  257.         Element pagelists = doc.getElementById("papelist");
  258.         if (pagelists!=null) {
  259.             String firstUrl = pagelists.select("a").first().absUrl("href");
  260.             String nextUrl = firstUrl.split("article/list")[0] + "article/list/";//获取下一页的路径
  261.             String pagedesc = pagelists.select("span").first().text();
  262.             Pattern pattern = Pattern.compile("([0-9]+).*?([0-9]+)");
  263.             Matcher matcher = pattern.matcher(pagedesc.trim());
  264.             int pageCount = 0;
  265.             while(matcher.find()){
  266.                 pageCount = Integer.parseInt(matcher.group(2));
  267.             }
  268.             for (int i = 2; i <= pageCount; i++) {
  269.                 Document docpage = ParseCommenUtil.download(new SuperRule(nextUrl + i),ipQueue);
  270.                 getBlogsUrl(docpage.select("div.article_title > h1 > span > a"));
  271.             }
  272.         }
  273.     }
  274. }

4获取基础数据类，爬取数据都要有一个头，这个类就是头

  1. package com.lg.base;
  3. import java.util.Set;
  4. import java.util.concurrent.CountDownLatch;
  6. import org.jsoup.nodes.Document;
  7. import org.jsoup.nodes.Element;
  8. import org.jsoup.select.Elements;
  10. import com.lg.filter.DatasRecover;
  11. import com.lg.parse.AbstractBlogParse;
  12. import com.lg.parse.CsdnBlogsParse;
  13. import com.lg.po.BlogDatas;
  14. import com.lg.po.BlogRule;
  15. import com.lg.utils.ParseCommenUtil;
  17. /** * 获取基础数据的类,以http://blog.csdn.net/index.html为获取基础数据的接口 * @author LG * */
  18. public class CsdnParseIndex extends AbstractBlogParse{ 
  19.     /** * 解析博客空间和个人博客的对象 */
  20.     CsdnBlogsParse blogsParse = null;
  21.     Document doc = null;
  22.     /** * 用户自定义的开始路径，初始化的规则 */
  23.     private BlogRule blogrule = null;
  24.     public CsdnParseIndex(BlogRule blogrule){
  25.         this.blogrule = blogrule;
  26.     }
  27.     public CsdnParseIndex(){}
  28.     public Set<BlogDatas> parseMain() { 
  29.         //初始化
  30.         init();
  31.         if (queue.size()<=0||queuespace.size()>0) {
  32.    //如果备份中没有数据
  33.             if (blogrule==null) {
  34.    //按照默认来进行
  35.                 blogrule = new BlogRule("http://blog.csdn.net/index.html", 3);
  36.                 parseBlog(null);
  37.                 parseSpace(null);
  38.                 //取出下一页数据
  39.                 for (int count = 2; count < 23; count++) {
  40.                     String url = "http://blog.csdn.net/index.html?&page="+count;
  41.                     blogrule.setUrl(url);
  42.                     parseBlog(null);
  43.                 }
  44.             }
  45.             else {
  46.    //用户自定义
  47.                 queue.offer(blogrule);
  48.             }
  49.         }
  50.         blogsParse = new CsdnBlogsParse();
  51.         blogsParse.setCount(count);
  52.         blogsParse.parseMain();//开始解析
  53.         return null;
  54.     }
  56.     /** * 取出http://blog.csdn.net/index.html左边链接 */
  57.     @Override
  58.     public void parseSpace(BlogRule rule) {         
  59.         Element left = doc.select("div.main_left").first();
  60.         Elements alives = left.select("dl.alive_user > dt > a");
  61.         //取出左边推荐专家
  62.         getSpacesUrl(alives);       
  63.         Elements experts = left.select("dl.experts > dd > ul > li > a");
  64.         //取出左边博客专家
  65.         getSpacesUrl(experts);
  66.     }
  67.     /** * 取出http://blog.csdn.net/index.html中间元素 */
  68.     @Override
  69.     public void parseBlog(BlogRule rule) {
  70.         doc = ParseCommenUtil.download(blogrule,null);  
  71.         Element center = doc.select("div.main_center").first();     
  72.         Elements links = center.select("div.blog_list > h1");
  73.         if (links.size()>0) {
  74.             for(Element link:links){
  75.                 BlogRule br = new BlogRule();
  76.                 String url = null;
  77.                 if(link.select("a").size()>1)
  78.                    url = link.child(1).absUrl("href");
  79.                 else {
  80.                     url = link.child(0).absUrl("href");
  81.                 }
  82.                 if (!ParseCommenUtil.isDownloaded(map, url)) {
  83.                     br.setUrl(url);
  84.                     br.setBlogType(BlogRule.BLOG);
  85.                     br.setIsDirect(true);
  86.                     queue.offer(br);
  87.                 }
  89.             }           
  90.         }
  91.     }
  94.     /** * 判断是否有没有处理完的URL，如果有，从这里开始，还有就是读取IP地址 */
  95.     public void init(){
  96.         CountDownLatch countDownLatch = new CountDownLatch(4);
  97.         for (int i = 0; i < 4; i++) {
  98.             new Thread(new DatasRecover(i, countDownLatch)).start();
  99.         }
  100.         try {
  101.             countDownLatch.await();
  102.             System.out.println("数据恢复完成");
  103.         } catch (Exception e1) {
  104.             System.out.println("备份恢复时错误");
  105.         }
  106.     }
  108. }

5爬虫类，可以接受任意的基础数据类

  1. package com.lg.spider;
  3. import com.lg.parse.AbstractBlogParse;
  4. import com.lg.parse.BlogParseable;
  6. /** * 爬虫类 * @author LG * */
  7. public class Spider { 
  9.     /** * 爬虫的数量 */
  10.     public int count;
  11.     public Spider(int count){
  12.         this.count = count;
  13.     }
  14.     AbstractBlogParse BlogParse = null;
  16.     public AbstractBlogParse getBlogParseable() {
  17.         return BlogParse;
  18.     }
  19.     public void setBlogParseable(AbstractBlogParse BlogParse) {
  20.         this.BlogParse = BlogParse;
  21.     }
  22.     /** * 爬取的入口 * @return * @throws Exception */
  23.     public String process() throws Exception {
  24.         BlogParse.setCount(count);
  25.         BlogParse.parseMain();
  26.         return null;
  27.     }
  29. }

6测试类，

  1. public static void testParseIndex() throws Exception{
  2.         String url = "http://blog.csdn.net/sunny2038/article/details/6926079";
  3.         BlogRule rule = new BlogRule();
  4.         rule.setUrl(url);
  5.         rule.setBlogType(2); 
  6.         Spider spider = new Spider(10);
  7.         CsdnParseIndex ci = new CsdnParseIndex();
  8.         spider.setBlogParseable(ci);
  9.         spider.process();
  10.     }

代码有点多，还有其他的类在这里就不贴出来了，给个下载链接，
第一次写博客，排版不好，希望谅解，代码写的不是很好，各位技术大牛们多多指教。

发表评论

表情：
评论列表 （有 0 条评论，338人围观）

还没有评论，来说两句吧...

相关阅读

    相关 Java爬取CSDN博客

    最近由于要做一个关于技术博客搜索的搜索工具，我开始接触到了爬虫，因为Java学的比较精通（主要是有很多封装的工具包），写了一个小小的Demo，进入主题吧 [参开博客链接][

    水深无声水深无声/ 0 赞/ 339 阅读