本文目录一览：

1. 如何用java爬虫爬取招聘信息
2. java网络爬虫爬取web视频资源,并下载怎么做
3. java如何做高级爬虫
4. java 网络爬虫怎么实现
5. java爬虫怎么抓取登陆后的网页数据
6. java爬虫抓取指定数据

如何用java爬虫爬取招聘信息

1. 思路：
   • 明确需要爬取的信息
   • 分析网页结构
   • 分析爬取流程
   • 优化
2. 明确需要爬取的信息
   • 职位名称
   • 工资
   • 职位描述
   • 公司名称
   • 公司主页
   • 详情网页
3. 分析网页结构
   • 目标网站-拉勾网
   • 网站使用json作为交互数据，分析json数据，需要的json关键数据
   • 查看需要的信息所在的位置，使用Jsoup来解析网页
4. 分析爬取流程
   1. 获取所有的positionId生成详情页，存放在一个存放网址列表中List<String> joburls
   2. 获取每个详情页并解析为Job类，得到一个存放Job类的列表List<Job> jobList
   3. 把List<Job> jobList存进Excel表格中
   • Java操作Excel需要用到jxl
5. 关键代码实现

public List<String> getJobUrls(String gj, String city, String kd) {
    String pre_url = "";
    String end_url = ".html";
    String url;
    if (gj.equals("")) {
        url = ";city=" + city + "needAddtionalResult=falsefirst=falsepn=" + pn + "kd=" + kd;
    } else {
        url = "" + gj + "px=defaultcity=" + city + "needAddtionalResult=falsefirst=falsepn=" + pn + "kd=" + kd;
    }
    String rs = getJson(url);
    System.out.println(rs);
    int total = JsonPath.read(rs, "$.content.positionResult.totalCount");// 获取总数
    int pagesize = total / 15;
    if (pagesize >= 30) {
        pagesize = 30;
    }
    System.out.println(total);
    // System.out.println(rs);
    List<Integer> posid = JsonPath.read(rs, "$.content.positionResult.result[*].positionId");// 获取网页id
    for (int j = 1; j <= pagesize; j++) { // 获取所有的网页id
        pn++; // 更新页数
        url = "" + gj + "px=defaultcity=" + city + "needAddtionalResult=falsefirst=falsepn=" + pn + "kd=" + kd;
        String rs2 = getJson(url);
        List<Integer> posid2 = JsonPath.read(rs2, "$.content.positionResult.result[*].positionId");
        posid.addAll(posid2); // 添加解析的id到第一个list
    }
    List<String> joburls = new ArrayList();
    // 生成网页列表
    for (int id : posid) {
        String url3 = pre_url + id + end_url;
        joburls.add(url3);
    }
    return joburls;
}
public Job getJob(String url) { // 获取工作信息
    Job job = new Job();
    Document document = null;
    document = Jsoup.parse(getJson(url));
    job.setJobname(document.select(".name").text());
    job.setSalary(document.select(".salary").text());
    String joball = HtmlTool.tag(document.select(".job_bt").select("div").html());// 清除html标签
    job.setJobdesc(joball);// 职位描述包含要求
    job.setCompany(document.select(".b2").attr("alt"));
    Elements elements = document.select(".c_feature");
    // System.out.println(document.select(".name").text());
    job.setCompanysite(elements.select("a").attr("href")); // 获取公司主页
    job.setJobdsite(url);
    return job;
}
void insertExcel(List<Job> jobList) throws IOException, BiffException, WriteException {
    int row = 1;
    Workbook wb = Workbook.getWorkbook(new File(JobCondition.filename));
    WritableWorkbook book = Workbook.createWorkbook(new File(JobCondition.filename), wb);
    WritableSheet sheet = book.getSheet(0);
    for (int i = 0; i < jobList.size(); i++) { // 遍历工作列表，一行行插入到表格中
        sheet.addCell(new Label(0, row, jobList.get(i).getJobname()));
        sheet.addCell(new Label(1, row, jobList.get(i).getSalary()));
        sheet.addCell(new Label(2, row, jobList.get(i).getJobdesc()));
        sheet.addCell(new Label(3, row, jobList.get(i).getCompany()));
        sheet.addCell(new Label(4, row, jobList.get(i).getCompanysite()));
        sheet.addCell(new Label(5, row, jobList.get(i).getJobdsite()));
        row++;
    }
    book.write();
    book.close();
}

java网络爬虫爬取web视频资源,并下载怎么做

import java.io.File;
import java.net.URL;
import java.net.URLConnection;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.Scanner;
import java.util.UUID;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class DownMM {
    public static void main(String[] args) throws Exception {
        // out为输出的路径,注意要以\\结尾
        String out = "D:\\JSP\\pic\\java\\";
        try {
            File f = new File(out);
            if (!f.exists()) {
                f.mkdirs();
            }
        } catch (Exception e) {
            System.out.println("no");
        }
        String url = "-";
        Pattern reg = Pattern.compile("img src=\"(.*?)\"");
        for (int j = 0, i = 1; i <= 10; i++) {
            URL uu = new URL(url + i);
            URLConnection conn = uu.openConnection();
            conn.setRequestProperty("User-Agent", "Mozilla/5.0 (Windows NT 6.3; WOW64; Trident/7.0; rv:11.0) like Gecko");
            Scanner sc = new Scanner(conn.getInputStream());
            Matcher m = reg.matcher(sc.useDelimiter("\\A").next());
            while (m.find()) {
                Files.copy(new URL(m.group(1)).openStream(), Paths.get(out + UUID.randomUUID() + ".jpg"));
                System.out.println("已下载:" + j++);
            }
        }
    }
}

java如何做高级爬虫

下面说明知乎爬虫的源码和涉及主要技术点：

1. 程序package组织
2. 模拟登录（爬虫主要技术点1）
   • 要爬去需要登录的网站数据，模拟登录是必要可少的一步，而且往往是难点。知乎爬虫的模拟登录可以做一个很好的案例。要实现一个网站的模拟登录，需要两大步骤是：
     1. 对登录的请求过程进行分析，找到登录的关键请求和步骤，分析工具可以有IE自带(快捷键F12)、Fiddler、HttpWatcher；
     2. 编写代码模拟登录的过程。
3. 网页下载（爬虫主要技术点2）
   • 模拟登录后，便可下载目标网页html了。知乎爬虫基于HttpClient写了一个网络连接线程池，并且封装了常用的get和post两种网页下载的方法。
4. 自动获取网页编码（爬虫主要技术点3）
   • 自动获取网页编码是确保下载网页html不出现乱码的前提。知乎爬虫中提供方法可以解决绝大部分乱码下载网页乱码问题。
5. 网页解析和提取（爬虫主要技术点4）
   • 使用Java写爬虫，常见的网页解析和提取方法有两种：利用开源Jar包Jsoup和正则。一般来说，Jsoup就可以解决问题，极少出现Jsoup不能解析和提取的情况。Jsoup强大功能，使得解析和提取异常简单。知乎爬虫采用的就是Jsoup。
6. 正则匹配与提取（爬虫主要技术点5）
   • 虽然知乎爬虫采用Jsoup来进行网页解析，但是仍然封装了正则匹配与提取数据的方法，因为正则还可以做其他的事情，如在知乎爬虫中使用正则来进行url地址的过滤和判断。
7. 数据去重（爬虫主要技术点6）
   • 对于爬虫，根据场景不同，可以有不同的去重方案：
     1. 少量数据，比如几万或者十几万条的情况，使用Map或Set便可；
     2. 中量数据，比如几百万或者上千万，使用BloomFilter（著名的布隆过滤器）可以解决；
     3. 大量数据，上亿或者几十亿，Redis可以解决。知乎爬虫给出了BloomFilter的实现，但是采用的Redis进行去重。
8. 设计模式等Java高级编程实践
   • 除了以上爬虫主要的技术点之外，知乎爬虫的实现还涉及多种设计模式，主要有链模式、单例模式、组合模式等，同时还使用了Java反射。除了学习爬虫技术，这对学习设计模式和Java反射机制也是一个不错的案例。
9. 一些抓取结果展示收起

java 网络爬虫怎么实现

网络爬虫是一个自动提取网页的程序，它为搜索引擎从万维网上下载网页，是搜索引擎的重要组成。 传统爬虫从一个或若干初始网页的URL开始，获得初始网页上的URL，在抓取网页的过程中，不断从当前页面上抽取新的URL放入队列，直到满足系统的一定停止条件。对于垂直搜索来说，聚焦爬虫，即有针对性地爬取特定主题网页的爬虫，更为适合。 以下是一个使用java实现的简单爬虫核心代码：

public void crawl() throws Throwable {
    while (continueCrawling()) {
        CrawlerUrl url = getNextUrl(); // 获取待爬取队列中的下一个URL
        if (url != null) {
            printCrawlInfo();
            String content = getContent(url); // 获取URL的文本信息
            // 聚焦爬虫只爬取与主题内容相关的网页，这里采用正则匹配简单处理
            if (isContentRelevant(content, this.regexpSearchPattern)) {
                saveContent(url, content); // 保存网页至本地
                // 获取网页内容中的链接，并放入待爬取队列中
                Collection urlStrings = extractUrls(content, url);
                addUrlsToUrlQueue(url, urlStrings);
            } else {
                System.out.println(url + " is not relevant ignoring ...");
            }
            // 延时防止被对方屏蔽
            Thread.sleep(this.delayBetweenUrls);
        }
    }
    closeOutputStream();
}
private CrawlerUrl getNextUrl() throws Throwable {
    CrawlerUrl nextUrl = null;
    while ((nextUrl == null) && (!urlQueue.isEmpty())) {
        CrawlerUrl crawlerUrl = this.urlQueue.remove();
        // doWeHavePermissionToVisit：是否有权限访问该URL，友好的爬虫会根据网站提供的"Robot.txt"中配置的规则进行爬取
        // isUrlAlreadyVisited：URL是否访问过，大型的搜索引擎往往采用BloomFilter进行排重，这里简单使用HashMap
        // isDepthAcceptable：是否达到指定的深度上限。爬虫一般采取广度优先的方式。一些网站会构建爬虫陷阱（自动生成一些无效链接使爬虫陷入死循环），采用深度限制加以避免
        if (doWeHavePermissionToVisit(crawlerUrl) && (!isUrlAlreadyVisited(crawlerUrl)) && isDepthAcceptable(crawlerUrl)) {
            nextUrl = crawlerUrl;
            // System.out.println("Next url to be visited is " + nextUrl);
        }
    }
    return nextUrl;
}
private String getContent(CrawlerUrl url) throws Throwable {
    // HttpClient4.1的调用与之前的方式不同
    HttpClient client = new DefaultHttpClient();
    HttpGet httpGet = new HttpGet(url.getUrlString());
    StringBuffer strBuf = new StringBuffer();
    HttpResponse response = client.execute(httpGet);
    if (HttpStatus.SC_OK == response.getStatusLine().getStatusCode()) {
        HttpEntity entity = response.getEntity();
        if (entity != null) {
            BufferedReader reader = new BufferedReader(new InputStreamReader(entity.getContent(), "UTF-8"));
            String line = null;
            if (entity.getContentLength() > 0) {
                strBuf = new StringBuffer((int) entity.getContentLength());
                while ((line = reader.readLine()) != null) {
                    strBuf.append(line);
                }
            }
        }
        if (entity != null) {
            entity.consumeContent();
        }
    }
    // 将url标记为已访问
    markUrlAsVisited(url);
    return strBuf.toString();
}
public static boolean isContentRelevant(String content, Pattern regexpPattern) {
    boolean retValue = false;
    if (content != null) {
        // 是否符合正则表达式的条件
        Matcher m = regexpPattern.matcher(content.toLowerCase());
        retValue = m.find();
    }
    return retValue;
}
public List extractUrls(String text, CrawlerUrl crawlerUrl) {
    Map urlMap = new HashMap();
    extractHttpUrls(urlMap, text);
    extractRelativeUrls(urlMap, text, crawlerUrl);
    return new ArrayList(urlMap.keySet());
}
private void extractHttpUrls(Map urlMap, String text) {
    Matcher m = (text);
    while (m.find()) {
        String url = m.group();
        String[] terms = url.split("a href=\"");
        for (String term : terms) {
            // System.out.println("Term = " + term);
            if (term.startsWith("http")) {
                int index = term.indexOf("\"");
                if (index > 0) {
                    term = term.substring(0, index);
                }
                urlMap.put(term, term);
                System.out.println("Hyperlink: " + term);
            }
        }
    }
}
private void extractRelativeUrls(Map urlMap, String text, CrawlerUrl crawlerUrl) {
    Matcher m = relativeRegexp.matcher(text);
    URL textURL = crawlerUrl.getURL();
    String host = textURL.getHost();
    while (m.find()) {
        String url = m.group();
        String[] terms = url.split("a href=\"");
        for (String term : terms) {
            if (term.startsWith("/")) {
                int index = term.indexOf("\"");
                if (index > 0) {
                    term = term.substring(0, index);
                }
                String s = "http://" + host + term;
                urlMap.put(s, s);
                System.out.println("Relative url: " + s);
            }
        }
    }
}
public static void main(String[] args) {
    try {
        String url = "";
        Queue urlQueue = new LinkedList();
        String regexp = "java";
        urlQueue.add(new CrawlerUrl(url, 0));
        NaiveCrawler crawler = new NaiveCrawler(urlQueue, 100, 5, 1000L, regexp);
        // boolean allowCrawl = crawler.areWeAllowedToVisit(url);
        // System.out.println("Allowed to crawl: " + url + " " +
        // allowCrawl);
        crawler.crawl();
    } catch (Throwable t) {
        System.out.println(t.toString());
        t.printStackTrace();
    }
}

java爬虫怎么抓取登陆后的网页数据

一般爬虫都不会抓登录以后的页面， 如果你只是临时抓某个站，可以模拟登录，然后拿到登录以后的Cookies，再去请求相关的页面。

java爬虫抓取指定数据

根据java网络编程相关的内容，使用jdk提供的相关类可以得到url对应网页的html页面代码。 针对得到的html代码，通过使用正则表达式即可得到我们想要的内容。 比如，我们如果想得到一个网页上所有包括“java”关键字的文本内容，就可以逐行对网页代码进行正则表达式的匹配。最后达到去除html标签和不相关的内容，只得到包括“java”这个关键字的内容的效果。 从网页上爬取图片的流程和爬取内容的流程基本相同，但是爬取图片的步骤会多一步。 需要先用img标签的正则表达式匹配获取到img标签，再用src属性的正则表达式获取这个img标签中的src属性的图片url，然后再通过缓冲输入流对象读取到这个图片url的图片信息，配合文件输出流将读到的图片信息写入到本地即可。