用Java爬取数据（url爬取文件）

最新推荐文章于 2024-05-14 19:21:39 发布
最新推荐文章于 2024-05-14 19:21:39 发布
阅读量2.9k 收藏 20
点赞数 6
分类专栏： spring boot 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43224797/article/details/108253803
版权

Java爬取接口的数据

首先让大家看看爬取的数据结果 46884 条数据

在这里插入图片描述

这是爬出文件ing
在这里插入图片描述
这是收获
在这里插入图片描述
废话不多说直接上代码

因为有数据才能爬文件所以来一段爬取数据的代码先

pom文件添加的依赖包
只添加一下关键的包

   <!--commons-->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
            <version>3.5</version>
        </dependency>
        <dependency>
            <groupId>commons-io</groupId>
            <artifactId>commons-io</artifactId>
            <version>2.5</version>
        </dependency>
        <!--commons-->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
            <version>3.5</version>
        </dependency>
        <!-- MybatisPlus -->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.1.1</version>
        </dependency>
        <!-- Gson -->
        <dependency>
            <groupId>com.google.code.gson</groupId>
            <artifactId>gson</artifactId>
            <version>2.8.5</version>
        </dependency>
        <!-- okhttp -->
        <dependency>
            <groupId>com.squareup.okhttp3</groupId>
            <artifactId>okhttp</artifactId>
            <version>3.14.2</version>
        </dependency>
        <dependency>
            <groupId>cn.hutool</groupId>
            <artifactId>hutool-all</artifactId>
            <version>4.5.16</version>
        </dependency>

关键代码

 /**
     * 
     * @param param1 参数1
     * @param param2 参数2
     * @param param3 参数3
     * 
     */
    private void getDataToLocalDataBase(String param1 , String param2 , String param3) {
        HttpParam httpParam = new HttpParam();
        httpParam.setApiUrl("爬取的网站");
        httpParam.setApiPath("接口地址");
        Map<String, String> parms = new HashMap<>();

        parms.put("param1 ", param1 );
        parms.put("param2 ", param2 );
        parms.put("param3 ", param3 );
        //....更多参数...
        /*     parms.put("strCustName","");*/
        //创建格式化参数
        Gson paramGson = new GsonBuilder().create();
        String requestParam = paramGson.toJson(parms);
        try {
        //post请求
            HttpResult postResult = HttpUtil.post(httpParam, requestParam);
            String result = postResult.getResult();

            int status = postResult.getStatus();
            Gson gson = new Gson();
            if (status == 200) {
                if (!StringUtils.isEmpty(result)) {
                    JsonObject jsonObject = (JsonObject) new JsonParser().parse(result);
                    JsonElement jsonElement = jsonObject.get("result");
                    String newResult = jsonElement.toString();
                    //xxData 与接口值返回相同的实体类  List<xxData>这里也可也是其他类型 按需去做
                    List<xxData> list = gson.fromJson(newResult, new TypeToken<List<xxData>>() {
                    }.getType());

                    log.info("数据有：{}",list.size());
                    if (list != null && list.size() > 0) {
                       //业务代码...把数据插入到本地数据库
                } else {
                    log.info("无数据");
                }
            } else {
               log.error("错误数据{}", result );
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

上面用的工具类

  • HttpParam
import okhttp3.MediaType;


public class HttpParam {
	//编码格式
    public static final MediaType MEDIA_TYPE_JSON = MediaType.parse("application/json; charset=utf-8");

    /**
     * 接口URL
     */
    private String apiUrl;

    /**
     * 接口路径
     */
    private String apiPath;

    /**
     * 读取超时时间
     */
    private int readTimeout = 30 * 1000;

    /**
     * 写入超时时间
     */
    private int writeTimeout = 30 * 1000;

    /**
     * 连接超时时间
     */
    private int connectTimeout = 2 * 1000;

    /**
     * 编码类型
     */
    private MediaType mediaType = MEDIA_TYPE_JSON;

    public String getApiUrl() {
        return apiUrl;
    }

    public void setApiUrl(String apiUrl) {
        this.apiUrl = apiUrl;
    }

    public String getApiPath() {
        return apiPath;
    }

    public void setApiPath(String apiPath) {
        this.apiPath = apiPath;
    }

    public int getReadTimeout() {
        return readTimeout;
    }

    public void setReadTimeout(int readTimeout) {
        this.readTimeout = readTimeout;
    }

    public int getWriteTimeout() {
        return writeTimeout;
    }

    public void setWriteTimeout(int writeTimeout) {
        this.writeTimeout = writeTimeout;
    }

    public int getConnectTimeout() {
        return connectTimeout;
    }

    public void setConnectTimeout(int connectTimeout) {
        this.connectTimeout = connectTimeout;
    }

    public MediaType getMediaType() {
        return mediaType;
    }

    public void setMediaType(MediaType mediaType) {
        this.mediaType = mediaType;
    }
}
  • HttpResult 这个大家接收的可根据需要自定义
public class HttpResult<T> {

    private int status;
    private String result;
    private T resultObject;

    public HttpResult() {
    }

    public HttpResult(int status, String result, T resultObject) {
        this.status = status;
        this.result = result;
        this.resultObject = resultObject;
    }

    public int getStatus() {
        return status;
    }

    public void setStatus(int status) {
        this.status = status;
    }

    public String getResult() {
        return result;
    }

    public void setResult(String result) {
        this.result = result;
    }

    public T getResultObject() {
        return resultObject;
    }

    public void setResultObject(T resultObject) {
        this.resultObject = resultObject;
    }
}

重点来了

  • HttpUtil
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import lombok.extern.slf4j.Slf4j;
import okhttp3.*;

import java.io.IOException;
import java.util.Map;
import java.util.concurrent.TimeUnit;


@Slf4j
public class HttpUtil {

    private static Gson gson = new GsonBuilder().serializeNulls().disableHtmlEscaping().create();

    /**
     * get请求
     */
    public static String get(HttpParam restParam) throws Exception {
        String url = restParam.getApiUrl();

        if (restParam.getApiPath() != null) {
            url = url+restParam.getApiPath();
        }
        Request request = new Request.Builder()
                .url(url)
                .get()
                .build();
        return exec(restParam, request).getResult();
    }

    /**
     * get请求
     */
    public static <T> HttpResult<T> get(HttpParam restParam, Class<T> tClass) throws Exception {
        String url = restParam.getApiUrl();

        if (restParam.getApiPath() != null) {
            url = url+restParam.getApiPath();
        }
        Request request = new Request.Builder()
                .url(url)
                .get()
                .build();
        return exec(restParam, request, tClass);
    }

    /**
     * POST请求json数据
     */
    public static <T> HttpResult<T> post(HttpParam restParam, Class<T> tClass) throws Exception {
        String url = restParam.getApiUrl();
        if (restParam.getApiPath() != null) {
            url = url + restParam.getApiPath();
        }
        Request request = new Request.Builder().url(url).build();
        return exec(restParam, request, tClass);
    }

    /**
     * POST请求json数据
     */
    public static <T> HttpResult<T> post(HttpParam restParam, String reqJsonData, Class<T> tClass) throws Exception {
        String url = restParam.getApiUrl();
        if (restParam.getApiPath() != null) {
            url = url+restParam.getApiPath();
        }
        RequestBody body = RequestBody.create(restParam.getMediaType(), reqJsonData);
        Request request = new Request.Builder()
                .url(url).post(body).build();
        return exec(restParam, request, tClass);
    }

    /**
     * POST请求map数据
     */
    public static <T> HttpResult<T> post(HttpParam restParam, Map<String, String> parms, Class<T> tClass) throws Exception {
        String url = restParam.getApiUrl();
        if (restParam.getApiPath() != null) {
            url = url+restParam.getApiPath();
        }
        FormBody.Builder builder = new FormBody.Builder();
        if (parms != null) {
            for (Map.Entry<String, String> entry : parms.entrySet()) {
                builder.add(entry.getKey(), entry.getValue());
            }
        }
        FormBody body = builder.build();
        Request request = new Request.Builder()
                .url(url)
                .post(body)
                .build();
        return exec(restParam, request, tClass);
    }

    /**
     * POST请求map数据 返回结果
     */
    public static <T> HttpResult<T> post(HttpParam restParam,  String reqJsonData) throws Exception {
        String url = restParam.getApiUrl();
        if (restParam.getApiPath() != null) {
            url = url+restParam.getApiPath();
        }
        RequestBody body = RequestBody.create(restParam.getMediaType(), reqJsonData);
        Request request = new Request.Builder()
                .url(url).post(body).build();
        return exec(restParam, request);
    }

    /**
     * 返回值封装成对象
     */
    private static <T> HttpResult<T> exec(
            HttpParam restParam,
            Request request,
            Class<T> tClass) throws Exception {

        HttpResult clientResult = exec(restParam, request);
        String result = clientResult.getResult();
        int status = clientResult.getStatus();

        T t = null;
        if (status == 200) {
            if (result != null && "".equalsIgnoreCase(result)) {
                t = gson.fromJson(result, tClass);
            }
        } else {
            try {
                result = gson.fromJson(result, String.class);
            } catch (Exception ex) {
                ex.printStackTrace();
            }
        }
        return new HttpResult<>(clientResult.getStatus(), result, t);
    }

    /**
     * 执行方法
     */
    private static HttpResult exec(
            HttpParam restParam,
            Request request) throws Exception {

        HttpResult result = null;

        okhttp3.OkHttpClient client = null;
        ResponseBody responseBody = null;
        try {
            client = new okhttp3.OkHttpClient();

            client.newBuilder()
                    .connectTimeout(restParam.getConnectTimeout(), TimeUnit.MILLISECONDS)
                    .readTimeout(restParam.getReadTimeout(), TimeUnit.MILLISECONDS)
                    .writeTimeout(restParam.getWriteTimeout(), TimeUnit.MILLISECONDS);

            Response response = client.newCall(request).execute();
            if (response.isSuccessful()) {
                responseBody = response.body();
                if (responseBody != null) {
                    String responseString = responseBody.string();

                    result = new HttpResult<>(response.code(), responseString, null);
                }
            } else {
                throw new Exception(response.message());
            }
        } catch (Exception ex) {
            throw new Exception(ex.getMessage());
        } finally {
            if (responseBody != null) {
                responseBody.close();
            }
            if (client != null) {
                client.dispatcher().executorService().shutdown();   //清除并关闭线程池
                client.connectionPool().evictAll();                 //清除并关闭连接池
                try {
                    if (client.cache() != null) {
                        client.cache().close();                         //清除cache
                    }
                } catch (IOException e) {
                    throw new Exception(e.getMessage());
                }
            }
        }
        return result;
    }
}

Java爬取文件

爬取数据的就告一段落了 接下来 就是拿这些数据去爬文件了 
其实网上找了很多很多的文章爬文件的都不靠谱，最后借到了协助三行代码搞定了
在这之前还是要导入关键的工具包滴，就是最上面的pom文件包

 URL url = new URL("文件地址");
 File folder = new File("本地存储文件地址");
 FileUtils.copyURLToFile(url , folder);

github地址
看完有用就点个赞吧

蝼蚁wllt
关注
  • 6
    点赞
  • 踩
  • 20
    收藏
    觉得还不错? 一键收藏
  • 7
    评论
专栏目录
java 爬取网页的数据_java爬取网页数据
weixin_42373103的博客
02-20 5240
最近使用java实现了一个简单的网页数据抓取，下面是实现原理及实现代码:原理：使用java.net下面的URL对象获取一个链接，下载目标网页的源代码，利用jsoup解析源代码中的数据，获取你想要的内容1.首先是根据网址下载源代码：/*** 根据网址和编码下载源代码*@paramurl 目标网址*@paramencoding 编码*@return*/public staticString getHt...
使用java实现数据爬取的功能（爬虫）
weixin_45460791的博客
06-29 971
在日常生活中，为了实现对数据的快速获取或者生成，可能没有那么大的数据，所以今天介绍一个小小的在网站爬取数据的案例。
Java 爬虫
chy1984的博客
09-29 881
Web Magic 封装了 SpiderMonitor、SpiderStatusMXBean 用于监控爬虫状态//爬虫名称，即爬虫的uuid，唯一标识一个爬虫//待爬取的url数量//启动爬虫，实质是调用 spider.start()//终止爬虫，实质是调用 spider.stop()SpiderMonitor 很多方法是 protected 的，不能直接调用，需要通过 jconsole 之类的 JMX 客户端来查看爬虫状态，使用不方便。
Java爬虫的几种方式
最新发布
weixin_42795092的博客
05-14 1069
最后，使用一个循环遍历每个链接，并通过link.text()获取链接的文本，通过link.attr(“href”)获取链接的URL。通过Selenium，您可以控制浏览器的行为，获取完整的页面内容。在上面的示例代码中，我们创建了一个WebClient对象，它代表了一个模拟的浏览器。当使用Java IO进行爬虫时，我们需要先获取网页的内容，然后可以使用Java IO类来处理和解析这些内容。请注意，HtmlUnit是一个强大的工具，可以模拟用户在浏览器中的操作，但它的运行需要一些依赖库。
java通过http url读取远程文件
liuhui12345的博客
09-16 9999
java通过http url读取远程文件 try { URL url = new URL("http://localhost:8080/VWdummy/VW/VW0001R/tgd/ja/test.txt"); InputStream is = url.openStream(); BufferedInputStream bis = new BufferedInputStream(is); ...
网页上爬取数据（Java版）通俗易懂
qq_42429369的博客
05-31 5057
java 网页爬虫，jsoup
java爬取京东数据
08-10
Java爬取京东数据是一项涉及网络爬虫技术和Java编程语言的任务，主要目的是从京东网站上抓取所需的数据。在这个过程中，我们需要了解几个关键知识点： 1. **网络爬虫基础**：网络爬虫是一种自动提取网页信息的程序...
用JavaURL编程爬取并分析网页敏感词
07-16
（3）建立敏感词库，用文本文件保存。 （4）将该网址所对应的文本中的敏感词提取并高亮显示。 （5）编写文本文件，可以存入多个网址；程序可爬取这些网址中的文本内容，将敏感词记录存入另一个文件，格式自定。 （6...
java爬虫，利用代理IP爬取大众点评网站内容.zip
03-08
数据存储： 爬虫将提取的数据存储到数据库、文件或其他存储介质中，以备后续分析或展示。常用的存储形式包括关系型数据库、NoSQL数据库、JSON文件等。 遵守规则： 为避免对网站造成过大负担或触发反爬虫机制，爬虫...
利用java定时爬取网页数据
11-11
3. 根据需求，可能需要修改爬虫的配置，如爬取间隔、目标URL或数据解析规则。 4. 如果使用Spring框架，需要了解如何配置和启动Spring容器。 总的来说，这个项目提供了一个基础的Java爬虫模板，可以帮助你学习如何...
SpringBoot中使用Jsoup爬取网站数据的方法
10-15
以下将详细介绍如何在SpringBoot应用中集成并使用Jsoup进行网站数据爬取。 首先，为了在SpringBoot项目中使用Jsoup，我们需要在`pom.xml`文件中添加对应的依赖。在给出的标签中，可以看到已经包含了Jsoup的依赖，...
网络爬虫demo
01-08
网络爬虫，采集数据，根据url采集数据，包括图片文本url等...
爬虫扩展——网站爬取 URL 去重方法
weixin_53919192的博客
04-28 1032
本文为大家介绍网站爬取 URL 去重方法，希望对大家有帮助~~
Java爬虫实战（一）：抓取一个网站上的全部链接
weixin_44195108的博客
03-22 5017
一 算法简介 程序在思路上采用了广度优先算法，对未遍历过的链接逐次发起GET请求，然后对返回来的页面用正则表达式进行解析，取出其中未被发现的新链接，加入集合中，待下一次循环时遍历。 具体实现上使用了Map<String, Boolean>，键值对分别是链接和是否被遍历标志。程序中使用了两个Map集合，分别是：oldMap和newMap，初始的链接在oldMap中，然后对o...
Java爬虫学习《一、爬取网页URL》
SELECT_BIN的博客
10-22 664
导包，如果是用的maven，添加依赖： <dependency> <groupId>commons-httpclient</groupId> <artifactId>commons-httpclient</artifactId> <versi...
python爬取全站链接_Python入门：全站url爬取
weixin_39897267的博客
12-15 1354
作为一个安全测试人员，面对一个大型网站的时候，手工测试很有可能测试不全，这时候就非常需要一个通用型的网站扫描器。当然能直接扫出漏洞的工具也有很多，但这样你只能算是一个工具使用者，对于安全测试你还远远不够。这时候应该怎么做呢？对于那些大量且重复性工作，尽量能用工具实现就用工具实现，然后打包成自己的工具包。如今天的这个url爬取工具。当我们把整站url都爬取出来之后，可以对url进行分析分类，然后有针...
使用Java-selenium获取网页数据
追风落叶乔木生
10-26 1112
本文数据库访问使用的是spring-boot-data-jpa,不懂得同学可以先了解spring-boot-data-jpa再来看本文章。 package com.frank.demo.etl.service.impl; import java.io.File; import java.util.Calendar; import java.util.Date; import java....
JAVA简易的爬取网页数据
weixin_45512495的博客
11-04 723
java简易的网页数据爬取，根据网站地址拉取网页，利用正则提取所需数据模块范围，利用截取标签获取具体数据 代码如下： package com.example.springbootdemo.test; import java.io.BufferedReader; import java.io.IOException; import java.io.InputStream; import java.io.InputStreamReader; import java.net.HttpURLConnecti
Java爬取数据
qq_43232973的博客
11-29 292
HttpUtils public class HttpUtils { //声明httpclient管理器对象（） private static PoolingHttpClientConnectionManager cm; private static List<String> userAgentlist = null; private static RequestConfig config =null; static { cm = new
java爬取网页数据代码
09-02
这里是一个简单的 Java 爬取网页数据的示例代码： ```java import java.io.BufferedReader; import java.io.InputStreamReader; import java.net.URL; public class WebPageScraper { public static void main...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 7
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值