SparkRESTApi使用JAVA封装

最新推荐文章于 2022-10-27 11:36:31 发布
最新推荐文章于 2022-10-27 11:36:31 发布
阅读量578 收藏 1
点赞数
分类专栏： Spark
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ciqingloveless/article/details/104297430
版权

项目功能就是封装SparkRestApi，用到了httpclient以及yarnclient，pom如下

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.2.2.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.wisetv</groupId>
    <artifactId>sparkprojectmanager</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>sparkprojectmanager</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
        <hadoop.version>2.9.0</hadoop.version>
        <org.apache.hive.version>1.2.1</org.apache.hive.version>
        <swagger.version>2.9.2</swagger.version>
        <ojdbc6.version>11.2.0.1.0</ojdbc6.version>
        <scala.version>2.11.12</scala.version>
        <spark.version>2.3.0</spark.version>
    </properties>

    <dependencies>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>


        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>

        <dependency>
            <groupId>com.google.code.gson</groupId>
            <artifactId>gson</artifactId>
            <version>2.8.2</version>
        </dependency>

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.47</version>
        </dependency>
        <!-- hadoop -->
        <dependency>
            <groupId>org.apache.hadoop</groupId>
            <artifactId>hadoop-client</artifactId>
            <version>${hadoop.version}</version>
            <exclusions>
                <exclusion>
                    <groupId>com.sun.jersey</groupId>
                    <artifactId>jersey-core</artifactId>
                </exclusion>
                <exclusion>
                    <groupId>com.sun.jersey</groupId>
                    <artifactId>jersey-client</artifactId>
                </exclusion>
                <exclusion>
                    <groupId>com.sun.jersey</groupId>
                    <artifactId>jersey-server</artifactId>
                </exclusion>
                <exclusion>
                    <groupId>com.sun.jersey</groupId>
                    <artifactId>jersey-json</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>org.apache.hadoop</groupId>
            <artifactId>hadoop-yarn-client</artifactId>
            <version>${hadoop.version}</version>
            <exclusions>
                <exclusion>
                    <groupId>com.google.guava</groupId>
                    <artifactId>guava</artifactId>
                </exclusion>
                <exclusion>
                    <groupId>com.sun.jersey</groupId>
                    <artifactId>jersey-core</artifactId>
                </exclusion>
                <exclusion>
                    <groupId>com.sun.jersey</groupId>
                    <artifactId>jersey-client</artifactId>
                </exclusion>
                <exclusion>
                    <groupId>com.sun.jersey</groupId>
                    <artifactId>jersey-server</artifactId>
                </exclusion>
                <exclusion>
                    <groupId>com.sun.jersey</groupId>
                    <artifactId>jersey-json</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <!-- spark -->
        <dependency>
            <groupId>org.apache.spark</groupId>
            <artifactId>spark-core_2.11</artifactId>
            <version>${spark.version}</version>
        </dependency>

        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger2</artifactId>
            <version>${swagger.version}</version>
            <exclusions>
                <exclusion>
                    <groupId>org.springframework</groupId>
                    <artifactId>spring-core</artifactId>
                </exclusion>
                <exclusion>
                    <groupId>org.springframework</groupId>
                    <artifactId>spring-beans</artifactId>
                </exclusion>
                <exclusion>
                    <groupId>org.springframework</groupId>
                    <artifactId>spring-context</artifactId>
                </exclusion>
                <exclusion>
                    <groupId>org.springframework</groupId>
                    <artifactId>spring-context-support</artifactId>
                </exclusion>
                <exclusion>
                    <groupId>org.springframework</groupId>
                    <artifactId>spring-aop</artifactId>
                </exclusion>
                <exclusion>
                    <groupId>org.springframework</groupId>
                    <artifactId>spring-tx</artifactId>
                </exclusion>
                <exclusion>
                    <groupId>org.springframework</groupId>
                    <artifactId>spring-orm</artifactId>
                </exclusion>
                <exclusion>
                    <groupId>org.springframework</groupId>
                    <artifactId>spring-jdbc</artifactId>
                </exclusion>
                <exclusion>
                    <groupId>org.springframework</groupId>
                    <artifactId>spring-web</artifactId>
                </exclusion>
                <exclusion>
                    <groupId>org.springframework</groupId>
                    <artifactId>spring-webmvc</artifactId>
                </exclusion>
                <exclusion>
                    <groupId>org.springframework</groupId>
                    <artifactId>spring-oxm</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger-ui</artifactId>
            <version>${swagger.version}</version>
        </dependency>
        <dependency>
            <groupId>org.apache.spark</groupId>
            <artifactId>spark-yarn_2.11</artifactId>
            <version>${spark.version}</version>
        </dependency>

        <dependency>
            <groupId>org.apache.spark</groupId>
            <artifactId>spark-sql_2.11</artifactId>
            <version>${spark.version}</version>
        </dependency>
        <dependency>
            <groupId>org.apache.spark</groupId>
            <artifactId>spark-hive_2.11</artifactId>
            <version>${spark.version}</version>
            <exclusions>
                <exclusion>
                    <groupId>com.twitter</groupId>
                    <artifactId>parquet-hadoop-bundle</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>org.glassfish.jersey.core</groupId>
            <artifactId>jersey-client</artifactId>
            <version>2.22.2</version>
        </dependency>
        <dependency>
            <groupId>org.glassfish.jersey.core</groupId>
            <artifactId>jersey-client</artifactId>
            <version>2.22.2</version>
        </dependency>
        <dependency>
            <groupId>org.glassfish.jersey.core</groupId>
            <artifactId>jersey-common</artifactId>
            <version>2.22.2</version>
        </dependency>
        <dependency>
            <groupId>org.glassfish.jersey.containers</groupId>
            <artifactId>jersey-container-servlet</artifactId>
            <version>2.22.2</version>
        </dependency>
        <dependency>
            <groupId>org.glassfish.jersey.containers</groupId>
            <artifactId>jersey-container-servlet-core</artifactId>
            <version>2.22.2</version>
        </dependency>
        <dependency>
            <groupId>org.glassfish.jersey.bundles.repackaged</groupId>
            <artifactId>jersey-guava</artifactId>
            <version>2.22.2</version>
        </dependency>
        <dependency>
            <groupId>org.glassfish.jersey.media</groupId>
            <artifactId>jersey-media-jaxb</artifactId>
            <version>2.22.2</version>
        </dependency>
        <dependency>
            <groupId>org.glassfish.jersey.core</groupId>
            <artifactId>jersey-server</artifactId>
            <version>2.22.2</version>
        </dependency>
        <dependency>
            <groupId>javax.ws.rs</groupId>
            <artifactId>javax.ws.rs-api</artifactId>
            <version>2.0.1</version>
        </dependency>
        <dependency>
            <groupId>com.sun.jersey</groupId>
            <artifactId>jersey-core</artifactId>
            <version>1.19.4</version>
        </dependency>
        <dependency>
            <groupId>com.sun.jersey</groupId>
            <artifactId>jersey-client</artifactId>
            <version>1.19.4</version>
        </dependency>
        <dependency>
            <groupId>com.sun.jersey</groupId>
            <artifactId>jersey-server</artifactId>
            <version>1.19.4</version>
        </dependency>
        <dependency>
            <groupId>com.sun.jersey</groupId>
            <artifactId>jersey-json</artifactId>
            <version>1.19.4</version>
        </dependency>
        <dependency>
            <groupId>org.apache.hive</groupId>
            <artifactId>hive-jdbc</artifactId>
            <version>${org.apache.hive.version}</version>
            <exclusions>
                <exclusion>
                    <groupId>org.eclipse.jetty.aggregate</groupId>
                    <artifactId>jetty-all</artifactId>
                </exclusion>
                <exclusion>
                    <groupId>org.apache.hive</groupId>
                    <artifactId>hive-shims</artifactId>
                </exclusion>
                <exclusion>
                    <groupId>org.apache.parquet</groupId>
                    <artifactId>parquet-hadoop-bundle</artifactId>
                </exclusion>
            </exclusions>
        </dependency>

    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

YarnClientTools

package com.wisetv.sparkprojectmanager.util;


import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.yarn.api.records.ApplicationId;
import org.apache.hadoop.yarn.api.records.ApplicationReport;
import org.apache.hadoop.yarn.client.api.YarnClient;
import org.apache.hadoop.yarn.exceptions.YarnException;
import org.apache.spark.sql.SparkSession;

import java.io.IOException;

/**
 * @ClassName YarnClientTools
 * @Description:
 * Yarn相关处理工具类
 * @Author 
 * @Date 20200213
 * @Version V1.0
 **/
public class YarnClientTools {


    /**
     * 通过SparkSession获取TrackingUrl，由于调用Spark REST Api需要这个URL作为地址，所以需要获取
     * @param sparkSession SparkSession
     * @param conf hadoop的配置参数，用于连接Yarn
     * @return TrackingUrl
     */
    public String getTrackingUrl(SparkSession sparkSession, Configuration conf){
        String s = sparkSession.sparkContext().applicationId();
        YarnClient yarnClient = YarnClient.createYarnClient();
        yarnClient.init(conf);
        yarnClient.start();
        ApplicationReport report = null;
        try {
            report = yarnClient.getApplicationReport(ApplicationId.fromString(s));
        } catch (YarnException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        yarnClient.stop();
        return report.getTrackingUrl();
    }
}

SparkRestApiTools.java

package com.wisetv.sparkprojectmanager.util;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * @ClassName SparkRestApiTools
 * @Description:
 * java调用Spark REST Api工具类
 * @Author 张年
 * @Date 2020/2/13
 * @Version V1.0
 **/
public class SparkRestApiTools {

    /**
     * A list of all applications.
     * ?status=[completed|running] list only applications in the chosen state.
     * ?minDate=[date] earliest start date/time to list.
     * ?maxDate=[date] latest start date/time to list.
     * ?minEndDate=[date] earliest end date/time to list.
     * ?maxEndDate=[date] latest end date/time to list.
     * ?limit=[limit] limits the number of applications listed.
     * Examples:
     * ?minDate=2015-02-10
     * ?minDate=2015-02-03T16:42:40.000GMT
     * ?maxDate=2015-02-11T20:41:30.000GMT
     * ?minEndDate=2015-02-12
     * ?minEndDate=2015-02-12T09:15:10.000GMT
     * ?maxEndDate=2015-02-14T16:30:45.000GMT
     * ?limit=10
     * @param trackingURL
     * 由于我是通过Yarn发布，所以需要此路径，假如是spark直接发布用 http://ip:4040/api/v1/applications
     * @param paramMap 所支持的参数根据官方api列举如上
     * @param time 超时时间，由于访问需要一定时间所以超时时间不宜设置过短
     * @return api返回的json信息
     */
    public String getApplications(String trackingURL, Map<String,String> paramMap,int time){
        HttpUtils httpUtils = new HttpUtils();
        String url = trackingURL+ "api/v1/applications";
        if(paramMap.size()>0){

            List<String> paramList = new ArrayList<>();
            for (Map.Entry entry:paramMap.entrySet()) {
                paramList.add(entry.getKey()+"="+entry.getValue());
            }
            url = url + "?"+String.join("&",paramList);
        }
        String json = httpUtils.doGet(url,time);
        return json;
    }

    /**
     * A list of all jobs for a given application.
     * ?status=[running|succeeded|failed|unknown] list only jobs in the specific state.
     * @param trackingURL
     * 由于我是通过Yarn发布，所以需要此路径，假如是spark直接发布用 http://ip:4040/api/v1/applications
     * @param appId
     * @param paramMap 所支持的参数根据官方api列举如上
     * @param time 超时时间
     * @return api返回的json信息
     */
    public String getApplicationJobs(String trackingURL,String appId, Map<String,String> paramMap,int time){
        HttpUtils httpUtils = new HttpUtils();
        String url = trackingURL+ "api/v1/applications/"+appId+"/jobs";
        if(paramMap.size()>0){

            List<String> paramList = new ArrayList<>();
            for (Map.Entry entry:paramMap.entrySet()) {
                paramList.add(entry.getKey()+"="+entry.getValue());
            }
            url = url + "?"+String.join("&",paramList);
        }
        String json = httpUtils.doGet(url,time);
        return json;
    }


    /**
     * A list of all stages for a given application.
     * ?status=[active|complete|pending|failed] list only stages in the state.
     * @param trackingURL
     * 由于我是通过Yarn发布，所以需要此路径，假如是spark直接发布用 http://ip:4040/api/v1/applications
     * @param appId
     * @param paramMap 所支持的参数根据官方api列举如上
     * @param time 超时时间
     * @return api返回的json信息
     */
    public String getApplicationStages(String trackingURL,String appId, Map<String,String> paramMap,int time){
        HttpUtils httpUtils = new HttpUtils();
        String url = trackingURL+ "api/v1/applications/"+appId+"/stages";
        if(paramMap.size()>0){

            List<String> paramList = new ArrayList<>();
            for (Map.Entry entry:paramMap.entrySet()) {
                paramList.add(entry.getKey()+"="+entry.getValue());
            }
            url = url + "?"+String.join("&",paramList);
        }
        String json = httpUtils.doGet(url,time);
        return json;
    }

    /**
     * A list of all attempts for the given stage.
     * @param trackingURL
     * 由于我是通过Yarn发布，所以需要此路径，假如是spark直接发布用 http://ip:4040/api/v1/applications
     * @param appId sparksession中的applicationId
     * @param time 超时时间
     * @return api返回的json信息
     */
    public String getApplicationStage(String trackingURL,String appId,String stageId,int time){
        HttpUtils httpUtils = new HttpUtils();
        String url = trackingURL+ "api/v1/applications/"+appId+"/stages/"+stageId;
        String json = httpUtils.doGet(url,time);
        return json;
    }

    /**
     * Details for the given stage attempt.
     * @param trackingURL
     * 由于我是通过Yarn发布，所以需要此路径，假如是spark直接发布用 http://ip:4040/api/v1/applications
     * @param appId sparksession中的applicationId
     * @param stageId appId中的stageId
     * @param stageAttemptId stageId中的stageAttemptId,是界面stage中Attempt列
     * @param time 超时时间
     * @return api返回的json信息
     */
    public String getApplicationStageAttempt(String trackingURL,String appId,String stageId,String stageAttemptId,int time){
        HttpUtils httpUtils = new HttpUtils();
        String url = trackingURL+ "api/v1/applications/"+appId+"/stages/"+stageId+"/"+stageAttemptId;
        String json = httpUtils.doGet(url,time);
        return json;
    }


    /**
     * Summary metrics of all tasks in the given stage attempt.
     * ?quantiles summarize the metrics with the given quantiles.
     * Example: ?quantiles=0.01,0.5,0.99
     * @param trackingURL
     * 由于我是通过Yarn发布，所以需要此路径，假如是spark直接发布用 http://ip:4040/api/v1/applications
     * @param appId sparksession中的applicationId
     * @param stageId appId中的stageId
     * @param stageAttemptId stageId中的stageAttemptId
     * @param paramMap 所支持的参数根据官方api列举如上
     * @param time 超时时间
     * @return api返回的json信息
     */
    public String getApplicationTaskSummary(String trackingURL,String appId,String stageId,String stageAttemptId, Map<String,String> paramMap,int time){
        HttpUtils httpUtils = new HttpUtils();
        String url = trackingURL+ "api/v1/applications/"+appId+"/stages/"+stageId+"/"+stageAttemptId+"/taskSummary";
        if(paramMap.size()>0){

            List<String> paramList = new ArrayList<>();
            for (Map.Entry entry:paramMap.entrySet()) {
                paramList.add(entry.getKey()+"="+entry.getValue());
            }
            url = url + "?"+String.join("&",paramList);
        }
        String json = httpUtils.doGet(url,time);
        return json;
    }


    /**
     * A list of all tasks for the given stage attempt.
     * ?offset=[offset]&length=[len] list tasks in the given range.
     * ?sortBy=[runtime|-runtime] sort the tasks.
     * Example: ?offset=10&length=50&sortBy=runtime
     * @param trackingURL
     * 由于我是通过Yarn发布，所以需要此路径，假如是spark直接发布用 http://ip:4040/api/v1/applications
     * @param appId sparksession中的applicationId
     * @param stageId appId中的stageId
     * @param stageAttemptId stageId中的stageAttemptId
     * @param paramMap 所支持的参数根据官方api列举如上
     * @param time 超时时间
     * @return api返回的json信息
     */
    public String getApplicationTaskList(String trackingURL,String appId,String stageId,String stageAttemptId, Map<String,String> paramMap,int time){
        HttpUtils httpUtils = new HttpUtils();
        String url = trackingURL+ "api/v1/applications/"+appId+"/stages/"+stageId+"/"+stageAttemptId+"/taskList";
        if(paramMap.size()>0){

            List<String> paramList = new ArrayList<>();
            for (Map.Entry entry:paramMap.entrySet()) {
                paramList.add(entry.getKey()+"="+entry.getValue());
            }
            url = url + "?"+String.join("&",paramList);
        }
        String json = httpUtils.doGet(url,time);
        return json;
    }

    /**
     * 	A list of all active executors for the given application.
     * @param trackingURL
     * 由于我是通过Yarn发布，所以需要此路径，假如是spark直接发布用 http://ip:4040/api/v1/applications
     * @param appId sparksession中的applicationId
     * @param time 超时时间
     * @return api返回的json信息
     */
    public String getApplicationExecutors(String trackingURL,String appId, int time){
        HttpUtils httpUtils = new HttpUtils();
        String url = trackingURL+ "api/v1/applications/"+appId+"/executors";
        System.out.println(url);
        String json = httpUtils.doGet(url,time);
        return json;
    }


    /**
     * Stack traces of all the threads running within the given active executor. Not available via the history server.
     * @param trackingURL
     * 由于我是通过Yarn发布，所以需要此路径，假如是spark直接发布用 http://ip:4040/api/v1/applications
     * @param appId sparksession中的applicationId
     * @param executorId 线程ID
     * @param time 超时时间
     * @return api返回的json信息
     */
    public String getApplicationExecutorThreads(String trackingURL,String appId,String executorId, int time){
        HttpUtils httpUtils = new HttpUtils();
        String url = trackingURL+ "api/v1/applications/"+appId+"/executors/"+executorId+"/threads";
        String json = httpUtils.doGet(url,time);
        return json;
    }

    /**
     * A list of all(active and dead) executors for the given application.
     * @param trackingURL
     * 由于我是通过Yarn发布，所以需要此路径，假如是spark直接发布用 http://ip:4040/api/v1/applications
     * @param appId sparksession中的applicationId
     * @param time 超时时间
     * @return api返回的json信息
     */
    public String getApplicationAllexecutors(String trackingURL,String appId, int time){
        HttpUtils httpUtils = new HttpUtils();
        String url = trackingURL+ "api/v1/applications/"+appId+"/allexecutors";
        String json = httpUtils.doGet(url,time);
        return json;
    }

    /**
     * 	A list of stored RDDs for the given application.
     * @param trackingURL
     * 由于我是通过Yarn发布，所以需要此路径，假如是spark直接发布用 http://ip:4040/api/v1/applications
     * @param appId sparksession中的applicationId
     * @param time 超时时间
     * @return api返回的json信息
     */
    public String getApplicationStorageRdds(String trackingURL,String appId, int time){
        HttpUtils httpUtils = new HttpUtils();
        String url = trackingURL+ "api/v1/applications/"+appId+"/storage/rdd";
        String json = httpUtils.doGet(url,time);
        return json;
    }

    /**
     * 	Details for the storage status of a given RDD.
     * @param trackingURL
     * 由于我是通过Yarn发布，所以需要此路径，假如是spark直接发布用 http://ip:4040/api/v1/applications
     * @param appId sparksession中的applicationId
     * @param rddId
     * @param time 超时时间
     * @return api返回的json信息
     */
    public String getApplicationStorageRdd(String trackingURL,String appId,String rddId, int time){
        HttpUtils httpUtils = new HttpUtils();
        String url = trackingURL+ "api/v1/applications/"+appId+"/storage/rdd/"+rddId;
        String json = httpUtils.doGet(url,time);
        return json;
    }

    public static void main(String[] args) {
        SparkRestApiTools sparkRestApiTools = new SparkRestApiTools();
        String trackingURL = "http://sparkdis1:8088/proxy/application_1579400438868_14544/";
        Map<String,String> map = new HashMap<>();
        String s = "";
//        s = sparkRestApiTools.getApplications(trackingURL, map, 5000);
//        System.out.println(s);

//        map.clear();
//        map.put("status","running");
//        s = sparkRestApiTools.getApplicationJobs(trackingURL, "application_1579400438868_14544", map, 5000);
//        System.out.println(s);

//        map.clear();
//        map.put("status","pending");
//        s = sparkRestApiTools.getApplicationStages(trackingURL, "application_1579400438868_14544", map, 5000);
//        System.out.println(s);

//        map.clear();
//        map.put("status","pending");
//        s = sparkRestApiTools.getApplicationStage(trackingURL, "application_1579400438868_14544", "3216", 5000);
//        System.out.println(s);

//        map.clear();
//        map.put("status","pending");
//        s = sparkRestApiTools.getApplicationStageAttempt(trackingURL, "application_1579400438868_14544", "3216","0", 5000);
//        System.out.println(s);

//        map.clear();
//        map.put("quantiles","0.5");
//        s = sparkRestApiTools.getApplicationTaskSummary(trackingURL, "application_1579400438868_14544", "3216","0",map, 5000);
//        System.out.println(s);

//        map.clear();
//        s = sparkRestApiTools.getApplicationTaskList(trackingURL, "application_1579400438868_14544", "3216","0",map, 5000);
//        System.out.println(s);

//        map.clear();
//        s = sparkRestApiTools.getApplicationExecutors(trackingURL, "application_1579400438868_14544", 5000);
//        System.out.println(s);

        /**
         * 不生效
         */
//        map.clear();
//        s = sparkRestApiTools.getApplicationExecutorThreads(trackingURL, "application_1579400438868_14544", "13",5000);
//        System.out.println(s);

//        map.clear();
//        s = sparkRestApiTools.getApplicationAllexecutors(trackingURL, "application_1579400438868_14544",5000);
//        System.out.println(s);

        map.clear();
        s = sparkRestApiTools.getApplicationStorageRdds(trackingURL, "application_1579400438868_14544",5000);
        System.out.println(s);
    }
}

HttpUtils.java

package com.wisetv.sparkprojectmanager.util;

import org.apache.http.HttpResponse;
import org.apache.http.NameValuePair;
import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.util.EntityUtils;

import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * @ClassName HttpUtils
 * @Description: http工具类
 * @Author 张年
 * @Date 2020/2/13
 * @Version V1.0
 **/
public class HttpUtils {

    /**
     * doget方法
     * @param url url
     * @param timeout 超时时长
     * @return 请求正常返回结果，异常返回空
     */
    public String doGet(String url, int timeout) {
        Map<String, Object> map = new HashMap<>();
        CloseableHttpClient httpClient = HttpClients.createDefault();
        //配置可有可无,根据个人情景
        RequestConfig requestConfig = RequestConfig.custom().setConnectionRequestTimeout(timeout) //设置连接超时时间
                .setConnectionRequestTimeout(timeout) //设置请求超时时间
                .setSocketTimeout(timeout)
                .setRedirectsEnabled(true) //设置允许自动重定向
                .build();
        HttpGet httpGet = new HttpGet(url);
        httpGet.setConfig(requestConfig);
        String result = "";
        try {
            HttpResponse httpResponse = httpClient.execute(httpGet);
            if (httpResponse.getStatusLine().getStatusCode() == 200) {
                result = EntityUtils.toString(httpResponse.getEntity());

            }

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                httpClient.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return result;
    }


    /**
     * doPost方法
     * @param url url
     * @param timeout 超时时长
     * @return 请求正常返回结果，异常返回空
     */
    public String doPost(String url, int timeout,Map<String,String>paramMap){
        CloseableHttpClient httpClient = HttpClients.custom()
                .build();
        //配置可有可无,根据个人情景
        RequestConfig requestConfig = RequestConfig.custom().setConnectionRequestTimeout(timeout) //设置连接超时时间
                .setConnectionRequestTimeout(timeout) //设置请求超时时间
                .setSocketTimeout(timeout)
                .setRedirectsEnabled(true) //设置允许自动重定向
                .build();
        HttpPost httpPost = new HttpPost(url);
        httpPost.setConfig(requestConfig);

        List<NameValuePair> formParams = new ArrayList<>();
        //表单参数
        for (Map.Entry<String, String> entry:paramMap.entrySet()) {
            formParams.add(new BasicNameValuePair(entry.getKey(), entry.getValue()));
        }


        UrlEncodedFormEntity entity = null;
        String result = "";
        try {
            entity = new UrlEncodedFormEntity(formParams, "utf-8");
            CloseableHttpResponse response = httpClient.execute(httpPost);
            result = EntityUtils.toString(response.getEntity());
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        } catch (ClientProtocolException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        httpPost.setEntity(entity);

        return result;
    }
}
ciqingloveless
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
spark restful_Spark入门：也可以用Java创建轻量级的RESTful应用程序
最佳 Java 编程
06-22 537
spark restful 最近，我一直在使用Spark （一种Java的Web框架，与Apache Spark 不相关）编写RESTful服务。 当我们计划写这篇文章时，我已经做好了不可避免的接口，样板代码和深层层次结构的Java风格的准备。 令我惊讶的是，对于局限于Java的开发人员来说，还有一个替代世界。 在本文中，我们将了解如何使用JSON传输数据来为博客构建RESTful应用程序...
Spark入门：也可以用Java创建轻量级的RESTful应用程序
最佳 Java 编程
05-29 292
最近，我一直在使用Spark （一种Java的Web框架，与Apache Spark 不相关）编写RESTful服务。 当我们计划写这篇文章时，我已经做好了不可避免的接口，样板代码和深层层次结构的Java风格的准备。 我很惊讶地发现，对于局限于Java的开发人员来说，还存在一个替代世界。 在本文中，我们将了解如何使用JSON传输数据来为博客构建RESTful应用程序。 我们会看到： ...
Spark常用封装类
吾常自闭的博客
05-31 362
创建Sparksession对象 // 创建sparksession对象 import org.apache.spark.sql.SparkSession import org.apache.spark.{SparkConf, SparkContext} object SparkUtils { /** * 获取到本地的SparkContext对象 */ def getLocalSparkContext() :SparkContext = getLocalSpar...
Spark多数据源封装
epitomizelu的专栏
08-06 471
官方数据源参考文档 一，HBase Spark没有直接提供HBase的数据源，读取需要通过HBaseConfiguration和SparkContext的API-newAPIHadoopRDD，写入需要通过HBaseConfiguration和SparkContext的API-saveAsNewAPIHadoopFile。 当然，也可以基于这些API封装后，安装下面这种方式读取和写入： val frame: DataFrame = spark.read .format("com.lcy.mode
spark Rest Api 使用
zhangxiping
03-24 1856
Rest API spark可以通过UI查看指标。这样可以让开发者很容易的创建一些可视化的工具。这些命令同时也只支持正在运行的应用。对于history server，访问的地址是http://:18080/api/v1,对于正在运行的任务，可以访问http://localhost:4040/api/v1 在这些api中，应用的标识为ID[app-id]。当通过YARN启动时，每个应用可能会有多次尝...
Java 封装基础知识
08-18
Java 封装基础知识 Java 封装是面向对象编程语言中的一种重要概念，它指的是将抽象性函式接口的实现细节部分包装、隐藏起来的方法。封装可以被认为是一个保护屏障，防止该类的代码和数据被外部类定义的代码随机访问...
浅谈java封装
09-03
封装封装就是将属性私有化，提供公有的方法访问私有的属性。*实现封装的步骤：（1）修改属性的可见性来限制对属性的访问。（2）为每个属性创建一对赋值方法和取值方法，用于对这些属性的访问。（3）在赋值和取值方法...
使用java数组 封装自己的数组操作示例
08-24
"使用Java数组封装自己的数组操作示例" 本文主要介绍了使用Java数组封装自己的数组操作，结合实例形式分析了Java数组索引、遍历等相关封装操作技巧与注意事项。 一、Java数组的基本概念 Java数组是一种基本的数据...
java线程池封装j
08-13
Java线程池封装是Java并发编程中重要的一环，合理的线程池配置和封装能显著提升程序的性能和稳定性。理解线程池的工作原理，根据业务需求选择合适的参数，以及正确处理拒绝策略，都是实现高效并发处理的关键。在实际...
Java封装统一的Result Model案例
08-24
Java 封装统一的 Result Model 案例 本文主要介绍了 Java 封装统一的 Result Model 案例，具有很好的参考价值，希望对大家有所帮助。在开发过程中，有时候会需要使用错误码+错误信息的形式，来返回某些业务操作的...
spark boot封装，多线程高效执行
lengyue2015的博客
10-27 987
众所周知，spark是一个分布式计算引擎，可以将计算数据分不到不同的节点进行计算，但是往往我们的业务都是比较复杂，每天定时跑的时候不只是一个job，可能是有很多的job，但是引擎本身是串行化的，而且对于经验不深的同学，一个业务可能在一个scala文件写上上前行代码，这样就很难维护，所以这里为大家提供一个简易的spark框架。框架同时采用多线程的方式，可以提高多个job的执行效率
spark 使用java如何定义返回类型_Spark中Java函数的使用方法笔记
weixin_35890416的博客
02-26 247
1:map函数map是对RDD中的每个元素都执行一个指定的函数来产生一个新的RDD。任何原RDD中的元素在新RDD中都有且只有一个元素与之对应。2:mapPartitions函数mapPartitions是map的一个变种。map的输入函数是应用于RDD中每个元素，而mapPartitions的输入函数是应用于每个分区，也就是把每个分区中的内容作为整体来处理的。3:mapValues函...
Spark 调优：Spark REST API
正趣果上果
04-22 313
Spark REST API Endpoint Meaning /applications 显示所有应用 /applications/[app-id]/jobs 获取给定应用的所有Jobs /applications/[app-id]/jobs/[job-id] 获取给定Job的信息 /applications/[app-id]/stages 获取给定应用的stages...
Spark中常用工具类Utils的简明介绍
beliefer的博客
03-16 9455
Utils是Spark中最常用的工具类之一，如果不关心其实现，也不会对理解Spark有太多影响。但是对于Scala或者Spark的初学者来说，通过了解Utils工具类的实现，也是个不错的入门途径。下面将逐个介绍Utils工具类提供的常用方法。
spark php接口,Spark 1.4中REST API介绍
weixin_29338295的博客
03-09 318
在https://issues.apache.org/jira/browse/SPARK-3644里面首先被提出，已经在/api/v1。比如，对于历史服务器来说，我们可以通过http://:18080/api/v1来获取一些信息；对于正在运行的Spark应用程序，我们可以通过:4040/api/v1来获取一些信息。如果想及时了解Spark、Hadoop或者Hbase相关的文章，欢迎关注微信公共帐号...
myecplise连接Spark集群接口封装
yanglx890826的博客
06-30 280
这是我的第一篇博文，从事IT人员这么多年得到了大家不少的帮助，以后也会向大家反馈。 废话不多说了，进入正题吧！ spark作为分布式计算框架，越来越受到企业的重视，对于从事java开发的人来说，虽然spark提供了java接口，但是基于脚本命令，如何融入自己的工程系统里，却是我们做产品人嘴关注的问题。‘  本文的主要目标是myecplise客户端通过java程序调用远程spark集群
spark java.utils.List 没有map方法的问题
lv_tianxiaomiao的博客
05-10 432
spark使用scala来编码的时候，有时候会使用java中的数据结构 在使用java中的list的时候，使用map方法会提示出错 这个问题倒是很简单，java的list确实没有map方法，不过转换成scala的list就可以解决了 scala中的list和java中的list是可以直接隐式转换的，不用在代码里面体现 只需要引入相应的包就可以
Spark REST Api的使用
我的笔记
10-13 2223
https://www.cnblogs.com/juncaoit/p/6379006.html
RDD封装成DataFrame的几种方式(SparkSQL模块)
weixin_37536020的博客
06-19 337
本文讲述了Spark中的集合、文件转化成DataFrame对象的方法。包括 RDD对象实例的toDF方法； JSON格式文件直接转化为DF对象； 数据库中二维表格直接转化为DF对象； 如何在Spark2版本转化DataFrame对象
使用java封装编写book类
最新发布
05-31
好的，下面是一个使用Java语言封装编写Book类的示例代码： ```java public class Book { private String title; private String author; private String publishDate; private double price; public Book...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值