java从零到变身爬虫大神,变身爬虫大神

java从零到变身爬虫大神,变身爬虫大神

刚初阶先从最简易的爬虫逻辑动手

爬虫最简便易行的剖判面真的是那般

import org.jsoup.Jsoup;
import org.jsoup.nodes.Document;
import java.io.IOException;

public class Test {
    public static void Get_Url(String url) {
        try {
         Document doc = Jsoup.connect(url) 
          //.data("query", "Java")
          //.userAgent("头部")
          //.cookie("auth", "token")
          //.timeout(3000)
          //.post()
          .get();
        } catch (IOException e) {
              e.printStackTrace();
        }
    }
}

这只是一个函数而已

那正是说在底下加上:

  //main函数
     public static void main(String[] args) {
         String url = "...";
        Get_Url(url);
     }

哈哈,搞定

正是这么二个爬虫了

太神奇

不过获得的只是网页的html页面的事物

再便是还没筛选

那正是说就筛选吧

public static void Get_Url(String url) {
        try {
         Document doc = Jsoup.connect(url) 
          //.data("query", "Java")
          //.userAgent("头部")
          //.cookie("auth", "token")
          //.timeout(3000)
          //.post()
          .get();

        //得到html的所有东西
        Element content = doc.getElementById("content");
        //分离出html下<a>...</a>之间的所有东西
        Elements links = content.getElementsByTag("a");
        //Elements links = doc.select("a[href]");
        // 扩展名为.png的图片
        Elements pngs = doc.select("img[src$=.png]");
        // class等于masthead的div标签
        Element masthead = doc.select("div.masthead").first();

        for (Element link : links) {
              //得到<a>...</a>里面的网址
              String linkHref = link.attr("href");
              //得到<a>...</a>里面的汉字
              String linkText = link.text();
              System.out.println(linkText);
            }
        } catch (IOException e) {
              e.printStackTrace();
        }
    }

那就用地点的来深入分析一下自己的今日头条

剖析的是<a>…</a>之间的东西

图片 1

看起来还不易啊

 

——————————-小编是一根牛逼的分水岭——————————-

 

实际还会有别的一种爬虫的法子越来越好

他能批量爬取网页保存到地头

先保存在地头再去正则什么的筛选本身想要的东西

那般效用比地方的要命高了十分的多

看代码!

//将抓取的网页变成html文件,保存在本地
    public static void Save_Html(String url) {
        try {
            File dest = new File("src/temp_html/" + "保存的html的名字.html");
            //接收字节输入流
            InputStream is;
            //字节输出流
            FileOutputStream fos = new FileOutputStream(dest);

            URL temp = new URL(url);
            is = temp.openStream();

            //为字节输入流加缓冲
            BufferedInputStream bis = new BufferedInputStream(is);
            //为字节输出流加缓冲
            BufferedOutputStream bos = new BufferedOutputStream(fos);

            int length;

            byte[] bytes = new byte[1024*20];
            while((length = bis.read(bytes, 0, bytes.length)) != -1){
                fos.write(bytes, 0, length);
            }

            bos.close();
            fos.close();
            bis.close();
            is.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

那个方法直接将html保存在了文本夹src/temp_html/里面

在批量抓取网页的时候

都以先抓下来,保存为html恐怕json

下一场在正则什么的进数据库

东西在本土了,本身想怎么搞就怎么搞

反爬虫关自家怎么着事

地点多少个章程都会变成二个问题

图片 2

其一荒西汉表

这种爬虫方法太low逼

大部网页都不准了

故此,要加个头

就是UA

主意一那边的尾部这里一贯

userAgent("Mozilla/5.0 (compatible; MSIE 9.0; Windows NT 6.1; Trident/5.0; MALC)")

方式二直接加:

 URL temp = new URL(url);
 URLConnection uc = temp.openConnection();
uc.addRequestProperty("User-Agent", "Mozilla/5.0 (iPad; U; CPU OS 4_3_3 like Mac OS X; en-us) AppleWebKit/533.17.9 (KHTML, like Gecko) Version/5.0.2 Mobile/8J2 Safari/6533.18.5");
  is = temp.openStream();

加了尾部,差非常的少能够应付当先四分之二网址了

 

——————————-作者是一根牛逼的分水线——————————-

 

将html下载到本地后须求解析啊

剖析啊看这里呀

//解析本地的html
    public static void Get_Localhtml(String path) {

        //读取本地html的路径
        File file = new File(path);
        //生成一个数组用来存储这些路径下的文件名
        File[] array = file.listFiles();
        //写个循环读取这些文件的名字

        for(int i=0;i<array.length;i++){
            try{
                if(array[i].isFile()){
                //文件名字
                System.out.println("正在解析网址:" + array[i].getName());

                //下面开始解析本地的html
                Document doc = Jsoup.parse(array[i], "UTF-8");
                //得到html的所有东西
                Element content = doc.getElementById("content");
                //分离出html下<a>...</a>之间的所有东西
                Elements links = content.getElementsByTag("a");
                //Elements links = doc.select("a[href]");
                // 扩展名为.png的图片
                Elements pngs = doc.select("img[src$=.png]");
                // class等于masthead的div标签
                Element masthead = doc.select("div.masthead").first();

                for (Element link : links) {
                      //得到<a>...</a>里面的网址
                      String linkHref = link.attr("href");
                      //得到<a>...</a>里面的汉字
                      String linkText = link.text();
                      System.out.println(linkText);
                        }
                    }
                }catch (Exception e) {
                    System.out.println("网址:" + array[i].getName() + "解析出错");
                    e.printStackTrace();
                    continue;
                }
        }
    }

文字配的很好看

就那样深入分析出来啊

主函数增进

//main函数
    public static void main(String[] args) {
        String url = "http://www.cnblogs.com/TTyb/";
        String path = "src/temp_html/";
        Get_Localhtml(path);
    }

那么那一个文件夹里面包车型大巴享有的html都要被笔者分析掉

好啦

3天java1天爬虫的结果就是那样子咯

——————————-小编是愉悦的分水岭——————————-

 

实际上对于那三种爬取html的方法来讲,最棒组合在协同

笔者测量试验过

情势二安宁不足

方法一进程不佳

于是自个儿校正

将艺术一放到方式二的catch里面去

当方法二出现谬误的时候就能够用到艺术一

可是当方法一也不对的时候就跳过呢

重组如下:

import org.jsoup.Jsoup;
import org.jsoup.nodes.Document;
import org.jsoup.nodes.Element;
import org.jsoup.select.Elements;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.net.HttpURLConnection;
import java.net.URL;
import java.net.URLConnection;
import java.util.Date;
import java.text.SimpleDateFormat;

public class JavaSpider {

    //将抓取的网页变成html文件,保存在本地
    public static void Save_Html(String url) {
        try {
            File dest = new File("src/temp_html/" + "我是名字.html");
            //接收字节输入流
            InputStream is;
            //字节输出流
            FileOutputStream fos = new FileOutputStream(dest);

            URL temp = new URL(url);
            URLConnection uc = temp.openConnection();
            uc.addRequestProperty("User-Agent", "Mozilla/5.0 (iPad; U; CPU OS 4_3_3 like Mac OS X; en-us) AppleWebKit/533.17.9 (KHTML, like Gecko) Version/5.0.2 Mobile/8J2 Safari/6533.18.5");
            is = temp.openStream();

            //为字节输入流加缓冲
            BufferedInputStream bis = new BufferedInputStream(is);
            //为字节输出流加缓冲
            BufferedOutputStream bos = new BufferedOutputStream(fos);

            int length;

            byte[] bytes = new byte[1024*20];
            while((length = bis.read(bytes, 0, bytes.length)) != -1){
                fos.write(bytes, 0, length);
            }

            bos.close();
            fos.close();
            bis.close();
            is.close();
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("openStream流错误,跳转get流");
            //如果上面的那种方法解析错误
            //那么就用下面这一种方法解析
            try{
                Document doc = Jsoup.connect(url)
                .userAgent("Mozilla/5.0 (compatible; MSIE 9.0; Windows NT 6.1; Trident/5.0; MALC)")
                .timeout(3000) 
                .get();

                File dest = new File("src/temp_html/" + "我是名字.html");
                if(!dest.exists())
                    dest.createNewFile();
                FileOutputStream out=new FileOutputStream(dest,false);
                out.write(doc.toString().getBytes("utf-8"));
                out.close();

            }catch (IOException E) {
                E.printStackTrace();
                System.out.println("get流错误,请检查网址是否正确");
            }

        }
    }

    //解析本地的html
    public static void Get_Localhtml(String path) {

        //读取本地html的路径
        File file = new File(path);
        //生成一个数组用来存储这些路径下的文件名
        File[] array = file.listFiles();
        //写个循环读取这些文件的名字

        for(int i=0;i<array.length;i++){
            try{
                if(array[i].isFile()){
                    //文件名字
                    System.out.println("正在解析网址:" + array[i].getName());
                    //文件地址加文件名字
                    //System.out.println("#####" + array[i]); 
                    //一样的文件地址加文件名字
                    //System.out.println("*****" + array[i].getPath()); 


                    //下面开始解析本地的html
                    Document doc = Jsoup.parse(array[i], "UTF-8");
                    //得到html的所有东西
                    Element content = doc.getElementById("content");
                    //分离出html下<a>...</a>之间的所有东西
                    Elements links = content.getElementsByTag("a");
                    //Elements links = doc.select("a[href]");
                    // 扩展名为.png的图片
                    Elements pngs = doc.select("img[src$=.png]");
                    // class等于masthead的div标签
                    Element masthead = doc.select("div.masthead").first();

                    for (Element link : links) {
                          //得到<a>...</a>里面的网址
                          String linkHref = link.attr("href");
                          //得到<a>...</a>里面的汉字
                          String linkText = link.text();
                          System.out.println(linkText);
                        }
                    }
                }catch (Exception e) {
                    System.out.println("网址:" + array[i].getName() + "解析出错");
                    e.printStackTrace();
                    continue;
                }
            }
        }
    //main函数
    public static void main(String[] args) {
        String url = "http://www.cnblogs.com/TTyb/";
        String path = "src/temp_html/";
        //保存到本地的网页地址
        Save_Html(url);
        //解析本地的网页地址
        Get_Localhtml(path);
    }
}

如上所述

java爬虫的格局比python的多大多

java的库真特么变态

http://www.bkjia.com/Javabc/1225895.htmlwww.bkjia.comtruehttp://www.bkjia.com/Javabc/1225895.htmlTechArticlejava从零到变身爬虫大神,变身爬虫大神
刚初阶先从最轻易易行的爬虫逻辑入手 爬虫最轻松易行的深入分析面真的是那样 import
org.jsoup.Jsoup; import org.jso…

刚最先先从最轻巧易行的爬虫逻辑入手

爬虫最简便的辨析面真的是这么

import org.jsoup.Jsoup;
import org.jsoup.nodes.Document;
import java.io.IOException;

public class Test {
    public static void Get_Url(String url) {
        try {
         Document doc = Jsoup.connect(url) 
          //.data("query", "Java")
          //.userAgent("头部")
          //.cookie("auth", "token")
          //.timeout(3000)
          //.post()
          .get();
        } catch (IOException e) {
              e.printStackTrace();
        }
    }
}

那只是三个函数而已

那就是说在底下加上:

  //main函数
     public static void main(String[] args) {
         String url = "...";
        Get_Url(url);
     }

哈哈,搞定

就是那般二个爬虫了

太神奇

不过获得的只是网页的html页面包车型地铁事物

还要还没筛选

那就是说就筛选吧

public static void Get_Url(String url) {
        try {
         Document doc = Jsoup.connect(url) 
          //.data("query", "Java")
          //.userAgent("头部")
          //.cookie("auth", "token")
          //.timeout(3000)
          //.post()
          .get();

        //得到html的所有东西
        Element content = doc.getElementById("content");
        //分离出html下<a>...</a>之间的所有东西
        Elements links = content.getElementsByTag("a");
        //Elements links = doc.select("a[href]");
        // 扩展名为.png的图片
        Elements pngs = doc.select("img[src$=.png]");
        // class等于masthead的div标签
        Element masthead = doc.select("div.masthead").first();

        for (Element link : links) {
              //得到<a>...</a>里面的网址
              String linkHref = link.attr("href");
              //得到<a>...</a>里面的汉字
              String linkText = link.text();
              System.out.println(linkText);
            }
        } catch (IOException e) {
              e.printStackTrace();
        }
    }

那就用地点的来解析一下本人的博客园

浅析的是<a>…</a>之间的东西

图片 3

看起来还不易啊

 

——————————-我是一根牛逼的分水线——————————-

 

骨子里还会有别的一种爬虫的点子非常好

他能批量爬取网页保存到本地

先保存在本土再去正则什么的筛选本人想要的事物

那样作用比地点的不胜高了广大

看代码!

//将抓取的网页变成html文件,保存在本地
    public static void Save_Html(String url) {
        try {
            File dest = new File("src/temp_html/" + "保存的html的名字.html");
            //接收字节输入流
            InputStream is;
            //字节输出流
            FileOutputStream fos = new FileOutputStream(dest);

            URL temp = new URL(url);
            is = temp.openStream();

            //为字节输入流加缓冲
            BufferedInputStream bis = new BufferedInputStream(is);
            //为字节输出流加缓冲
            BufferedOutputStream bos = new BufferedOutputStream(fos);

            int length;

            byte[] bytes = new byte[1024*20];
            while((length = bis.read(bytes, 0, bytes.length)) != -1){
                fos.write(bytes, 0, length);
            }

            bos.close();
            fos.close();
            bis.close();
            is.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

其一法子直接将html保存在了文件夹src/temp_html/里面

在批量抓取网页的时候

都是先抓下来,保存为html可能json

接下来在正则什么的进数据库

东西在该地了,自身想怎么搞就怎么搞

反爬虫关自家哪些事

上边五个方法都会招致贰个标题

图片 4

本条错误代表

这种爬虫方法太low逼

比很多网页都不准了

故此,要加个头

就是UA

艺术一那边的尾部这里平素

userAgent("Mozilla/5.0 (compatible; MSIE 9.0; Windows NT 6.1; Trident/5.0; MALC)")

办法二直接加:

 URL temp = new URL(url);
 URLConnection uc = temp.openConnection();
uc.addRequestProperty("User-Agent", "Mozilla/5.0 (iPad; U; CPU OS 4_3_3 like Mac OS X; en-us) AppleWebKit/533.17.9 (KHTML, like Gecko) Version/5.0.2 Mobile/8J2 Safari/6533.18.5");
  is = temp.openStream();

加了底部,大约能够应付超过十分二网站了

 

——————————-小编是一根牛逼的分水岭——————————-

 

将html下载到本地后须要深入分析啊

浅析啊看这里呀

//解析本地的html
    public static void Get_Localhtml(String path) {

        //读取本地html的路径
        File file = new File(path);
        //生成一个数组用来存储这些路径下的文件名
        File[] array = file.listFiles();
        //写个循环读取这些文件的名字

        for(int i=0;i<array.length;i++){
            try{
                if(array[i].isFile()){
                //文件名字
                System.out.println("正在解析网址:" + array[i].getName());

                //下面开始解析本地的html
                Document doc = Jsoup.parse(array[i], "UTF-8");
                //得到html的所有东西
                Element content = doc.getElementById("content");
                //分离出html下<a>...</a>之间的所有东西
                Elements links = content.getElementsByTag("a");
                //Elements links = doc.select("a[href]");
                // 扩展名为.png的图片
                Elements pngs = doc.select("img[src$=.png]");
                // class等于masthead的div标签
                Element masthead = doc.select("div.masthead").first();

                for (Element link : links) {
                      //得到<a>...</a>里面的网址
                      String linkHref = link.attr("href");
                      //得到<a>...</a>里面的汉字
                      String linkText = link.text();
                      System.out.println(linkText);
                        }
                    }
                }catch (Exception e) {
                    System.out.println("网址:" + array[i].getName() + "解析出错");
                    e.printStackTrace();
                    continue;
                }
        }
    }

文字配的绝对漂亮

就这么剖判出来呀

主函数拉长

//main函数
    public static void main(String[] args) {
        String url = "http://www.cnblogs.com/TTyb/";
        String path = "src/temp_html/";
        Get_Localhtml(path);
    }

那就是说那几个文件夹里面包车型大巴具有的html都要被笔者剖判掉

好啦

3天java1天爬虫的结果就是如此子咯

——————————-我是开心的分水线——————————-

 

骨子里对于这两种爬取html的法子来讲,最好组合在一起

小编测验过

办法二平稳不足

措施一进程倒霉

为此自身改良

将艺术一放到办法二的catch里面去

当方法第二行业出错误的时候就能够用到方法一

而是当方法一也不对的时候就跳过啊

构成如下:

import org.jsoup.Jsoup;
import org.jsoup.nodes.Document;
import org.jsoup.nodes.Element;
import org.jsoup.select.Elements;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.net.HttpURLConnection;
import java.net.URL;
import java.net.URLConnection;
import java.util.Date;
import java.text.SimpleDateFormat;

public class JavaSpider {

    //将抓取的网页变成html文件,保存在本地
    public static void Save_Html(String url) {
        try {
            File dest = new File("src/temp_html/" + "我是名字.html");
            //接收字节输入流
            InputStream is;
            //字节输出流
            FileOutputStream fos = new FileOutputStream(dest);

            URL temp = new URL(url);
            URLConnection uc = temp.openConnection();
            uc.addRequestProperty("User-Agent", "Mozilla/5.0 (iPad; U; CPU OS 4_3_3 like Mac OS X; en-us) AppleWebKit/533.17.9 (KHTML, like Gecko) Version/5.0.2 Mobile/8J2 Safari/6533.18.5");
            is = temp.openStream();

            //为字节输入流加缓冲
            BufferedInputStream bis = new BufferedInputStream(is);
            //为字节输出流加缓冲
            BufferedOutputStream bos = new BufferedOutputStream(fos);

            int length;

            byte[] bytes = new byte[1024*20];
            while((length = bis.read(bytes, 0, bytes.length)) != -1){
                fos.write(bytes, 0, length);
            }

            bos.close();
            fos.close();
            bis.close();
            is.close();
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("openStream流错误,跳转get流");
            //如果上面的那种方法解析错误
            //那么就用下面这一种方法解析
            try{
                Document doc = Jsoup.connect(url)
                .userAgent("Mozilla/5.0 (compatible; MSIE 9.0; Windows NT 6.1; Trident/5.0; MALC)")
                .timeout(3000) 
                .get();

                File dest = new File("src/temp_html/" + "我是名字.html");
                if(!dest.exists())
                    dest.createNewFile();
                FileOutputStream out=new FileOutputStream(dest,false);
                out.write(doc.toString().getBytes("utf-8"));
                out.close();

            }catch (IOException E) {
                E.printStackTrace();
                System.out.println("get流错误,请检查网址是否正确");
            }

        }
    }

    //解析本地的html
    public static void Get_Localhtml(String path) {

        //读取本地html的路径
        File file = new File(path);
        //生成一个数组用来存储这些路径下的文件名
        File[] array = file.listFiles();
        //写个循环读取这些文件的名字

        for(int i=0;i<array.length;i++){
            try{
                if(array[i].isFile()){
                    //文件名字
                    System.out.println("正在解析网址:" + array[i].getName());
                    //文件地址加文件名字
                    //System.out.println("#####" + array[i]); 
                    //一样的文件地址加文件名字
                    //System.out.println("*****" + array[i].getPath()); 


                    //下面开始解析本地的html
                    Document doc = Jsoup.parse(array[i], "UTF-8");
                    //得到html的所有东西
                    Element content = doc.getElementById("content");
                    //分离出html下<a>...</a>之间的所有东西
                    Elements links = content.getElementsByTag("a");
                    //Elements links = doc.select("a[href]");
                    // 扩展名为.png的图片
                    Elements pngs = doc.select("img[src$=.png]");
                    // class等于masthead的div标签
                    Element masthead = doc.select("div.masthead").first();

                    for (Element link : links) {
                          //得到<a>...</a>里面的网址
                          String linkHref = link.attr("href");
                          //得到<a>...</a>里面的汉字
                          String linkText = link.text();
                          System.out.println(linkText);
                        }
                    }
                }catch (Exception e) {
                    System.out.println("网址:" + array[i].getName() + "解析出错");
                    e.printStackTrace();
                    continue;
                }
            }
        }
    //main函数
    public static void main(String[] args) {
        String url = "http://www.cnblogs.com/TTyb/";
        String path = "src/temp_html/";
        //保存到本地的网页地址
        Save_Html(url);
        //解析本地的网页地址
        Get_Localhtml(path);
    }
}

总的看

java爬虫的方法比python的多好些个

java的库真特么变态

发表评论

电子邮件地址不会被公开。 必填项已用*标注

网站地图xml地图