使用springboot构建rest api远程提交spark任务

最新推荐文章于 2023-02-24 20:40:07 发布
最新推荐文章于 2023-02-24 20:40:07 发布
阅读量1w 收藏 67
点赞数 15
分类专栏： spring boot spark 文章标签： spark springboot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hlp4207/article/details/100831384
版权

github代码链接：github地址

1. spark集群及版本信息

  • 服务器版本：centos7
  • hadoop版本：2.8.3
  • spark版本：2.3.3

使用springboot构建rest api远程提交spark任务，将数据库中的表数据存储到hdfs上，任务单独起一个项目，解除与springboot项目的耦合

2. 构建springboot项目

1. pom配置

	<properties>
        <java.version>1.8</java.version>
        <spark.version>2.3.3</spark.version>
        <scala.version>2.11</scala.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</artifactId>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.46</version>
        </dependency>
        <dependency>
            <groupId>org.apache.spark</groupId>
            <artifactId>spark-launcher_${scala.version}</artifactId>
            <version>${spark.version}</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.49</version>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <finalName>spark</finalName>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <mainClass>com.hrong.springbootspark.SpringbootSparkApplication</mainClass>
                </configuration>
                <executions>
                    <execution>
                        <goals>
                            <goal>repackage</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>

2. 项目结构

在这里插入图片描述

3. 编写代码

1. 创建spark任务实体
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.springframework.beans.factory.annotation.Value;

import java.util.Map;

/**
 * @Author hrong
 **/
@Data
@NoArgsConstructor
@AllArgsConstructor
public class SparkApplicationParam {
	/**
	 * 任务的主类
	 */
	private String mainClass;
	/**
	 * jar包路径
	 */
	private String jarPath;
	@Value("${spark.master:yarn}")
	private String master;
	@Value("${spark.deploy.mode:cluster}")
	private String deployMode;
	@Value("${spark.driver.memory:1g}")
	private String driverMemory;
	@Value("${spark.executor.memory:1g}")
	private String executorMemory;
	@Value("${spark.executor.cores:1}")
	private String executorCores;
	/**
	 * 其他配置：传递给spark job的参数
	 */
	private Map<String, String> otherConfParams;

	/**
	 * 调用该方法可获取spark任务的设置参数
	 * @return SparkApplicationParam
	 */
	public SparkApplicationParam getSparkApplicationParam(){
		return new SparkApplicationParam(mainClass, jarPath, master, deployMode, driverMemory, executorMemory, executorCores, otherConfParams);
	}
}
2. 任务参数对象

每个任务执行的时候都必须指定运行参数，所以要继承SparkApplicationParam对象

import com.hrong.springbootspark.entity.SparkApplicationParam;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

/**
 * @Author hrong
 **/
@Data
@NoArgsConstructor
@AllArgsConstructor
public class DataBaseExtractorVo extends SparkApplicationParam {
	/**
	 * 数据库连接地址
	 */
	private String url;
	/**
	 * 数据库连接账号
	 */
	private String userName;
	/**
	 * 数据库密码
	 */
	private String password;
	/**
	 * 指定的表名
	 */
	private String table;
	/**
	 * 目标文件类型
	 */
	private String targetFileType;
	/**
	 * 目标文件保存路径
	 */
	private String targetFilePath;
}
3. 定义spark提交方法
1. 定义interface

每个spark任务运行时都需要指定运行参数，但是任务内部所需的参数不一样，所以第一个参数为通用的参数对象，第二个参数为可变参数，根据不同的任务来进行传值

import com.hrong.springbootspark.entity.SparkApplicationParam;

import java.io.IOException;

/**
 * @Author hrong
 * @description spark任务提交service
 **/
public interface ISparkSubmitService {
	/**
	 * 提交spark任务入口
	 * @param sparkAppParams spark任务运行所需参数
	 * @param otherParams 单独的job所需参数
	 * @return 结果
	 * @throws IOException          io
	 * @throws InterruptedException 线程等待中断异常
	 */
	String submitApplication(SparkApplicationParam sparkAppParams, String... otherParams) throws IOException, InterruptedException;
}
2. 具体实现
import com.alibaba.fastjson.JSONObject;
import com.hrong.springbootspark.entity.SparkApplicationParam;
import com.hrong.springbootspark.service.ISparkSubmitService;
import com.hrong.springbootspark.util.HttpUtil;
import org.apache.spark.launcher.SparkAppHandle;
import org.apache.spark.launcher.SparkLauncher;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;

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

/**
 * @Author hrong
 **/
@Service
public class SparkSubmitServiceImpl implements ISparkSubmitService {

	private static Logger log = LoggerFactory.getLogger(SparkSubmitServiceImpl.class);

	@Value("${driver.name:n151}")
	private String driverName;


	@Override
	public String submitApplication(SparkApplicationParam sparkAppParams, String... otherParams) throws IOException, InterruptedException {
		log.info("spark任务传入参数：{}", sparkAppParams.toString());
		CountDownLatch countDownLatch = new CountDownLatch(1);
		Map<String, String> confParams = sparkAppParams.getOtherConfParams();
		SparkLauncher launcher = new SparkLauncher()
				.setAppResource(sparkAppParams.getJarPath())
				.setMainClass(sparkAppParams.getMainClass())
				.setMaster(sparkAppParams.getMaster())
				.setDeployMode(sparkAppParams.getDeployMode())
				.setConf("spark.driver.memory", sparkAppParams.getDriverMemory())
				.setConf("spark.executor.memory", sparkAppParams.getExecutorMemory())
				.setConf("spark.executor.cores", sparkAppParams.getExecutorCores());
		if (confParams != null && confParams.size() != 0) {
			log.info("开始设置spark job运行参数:{}", JSONObject.toJSONString(confParams));
			for (Map.Entry<String, String> conf : confParams.entrySet()) {
				log.info("{}:{}", conf.getKey(), conf.getValue());
				launcher.setConf(conf.getKey(), conf.getValue());
			}
		}
		if (otherParams.length != 0) {
			log.info("开始设置spark job参数:{}", otherParams);
			launcher.addAppArgs(otherParams);
		}
		log.info("参数设置完成，开始提交spark任务");
		SparkAppHandle handle = launcher.setVerbose(true).startApplication(new SparkAppHandle.Listener() {
					@Override
					public void stateChanged(SparkAppHandle sparkAppHandle) {
						if (sparkAppHandle.getState().isFinal()) {
							countDownLatch.countDown();
						}
						log.info("stateChanged:{}", sparkAppHandle.getState().toString());
					}

					@Override
					public void infoChanged(SparkAppHandle sparkAppHandle) {
						log.info("infoChanged:{}", sparkAppHandle.getState().toString());
					}
				});
		log.info("The task is executing, please wait ....");
		//线程等待任务结束
		countDownLatch.await();
		log.info("The task is finished!");
		//通过Spark原生的监测api获取执行结果信息，需要在spark-default.xml、spark-env.sh、yarn-site.xml进行相应的配置
		String estUrl = "http://"+driverName+":18080/api/v1/applications/" + handle.getAppId();
		return HttpUtil.httpGet(restUrl, null);
	}
}
4. Controller写法

controller主要的职责就是接受页面的参数，将参数传递到service层

import com.hrong.springbootspark.service.ISparkSubmitService;
import com.hrong.springbootspark.vo.DataBaseExtractorVo;
import com.hrong.springbootspark.vo.Result;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.ResponseBody;

import javax.annotation.Resource;
import java.io.IOException;

/**
 * @Author hrong
 **/
@Slf4j
@Controller
public class SparkController {
	@Resource
	private ISparkSubmitService iSparkSubmitService;
	/**
	 * 调用service进行远程提交spark任务
	 * @param vo 页面参数
	 * @return 执行结果
	 */
	@ResponseBody
	@PostMapping("/extract/database")
	public Object dbExtractAndLoad2Hdfs(@RequestBody DataBaseExtractorVo vo){
		try {
			return iSparkSubmitService.submitApplication(vo.getSparkApplicationParam(),
					vo.getUrl(),
					vo.getTable(),
					vo.getUserName(),
					vo.getPassword(),
					vo.getTargetFileType(),
					vo.getTargetFilePath());
		} catch (IOException | InterruptedException e) {
			e.printStackTrace();
			log.error("执行出错：{}", e.getMessage());
			return Result.err(500, e.getMessage());
		}
	}
}

3. 构建Spark任务项目(Maven项目)

1. pom配置

<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.8.3</hadoop.version>
        <spark.version>2.3.3</spark.version>
        <scala.version>2.11</scala.version>
        <scala-library.version>2.11.8</scala-library.version>
        <mysql.version>5.1.46</mysql.version>
        <oracle.version>11g</oracle.version>
        <codehaus.version>3.0.10</codehaus.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>${mysql.version}</version>
        </dependency>
        <!-- 下载好了jar包install到本地的，无法使用maven下载 -->
        <dependency>
            <groupId>com.oracle.driver</groupId>
            <artifactId>jdbc-driver</artifactId>
            <version>${oracle.version}</version>
        </dependency>
        <!--spark相关开始-->
        <dependency>
            <groupId>org.apache.spark</groupId>
            <artifactId>spark-core_${scala.version}</artifactId>
            <version>${spark.version}</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>org.apache.spark</groupId>
            <artifactId>spark-sql_${scala.version}</artifactId>
            <version>${spark.version}</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>org.codehaus.janino</groupId>
            <artifactId>commons-compiler</artifactId>
            <version>${codehaus.version}</version>
        </dependency>
        <dependency>
            <groupId>org.scala-lang</groupId>
            <artifactId>scala-library</artifactId>
            <version>${scala-library.version}</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>org.apache.hadoop</groupId>
            <artifactId>hadoop-common</artifactId>
            <version>${hadoop.version}</version>
            <scope>provided</scope>
        </dependency>
    </dependencies>
    <build>
        <finalName>spark-job</finalName>
        <pluginManagement>
            <plugins>
                <plugin>
                    <groupId>net.alchim31.maven</groupId>
                    <artifactId>scala-maven-plugin</artifactId>
                    <version>3.2.2</version>
                </plugin>
            </plugins>
        </pluginManagement>
        <plugins>
            <plugin>
                <groupId>net.alchim31.maven</groupId>
                <artifactId>scala-maven-plugin</artifactId>
                <executions>
                    <execution>
                        <id>scala-compile-first</id>
                        <phase>process-resources</phase>
                        <goals>
                            <goal>add-source</goal>
                            <goal>compile</goal>
                        </goals>
                    </execution>
                    <execution>
                        <id>scala-test-compile</id>
                        <phase>process-test-resources</phase>
                        <goals>
                            <goal>testCompile</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <executions>
                    <execution>
                        <phase>compile</phase>
                        <goals>
                            <goal>compile</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-shade-plugin</artifactId>
                <version>2.4.3</version>
                <executions>
                    <execution>
                        <phase>package</phase>
                        <goals>
                            <goal>shade</goal>
                        </goals>
                        <configuration>
                            <filters>
                                <filter>
                                    <artifact>*:*</artifact>
                                    <excludes>
                                        <exclude>META-INF/*.SF</exclude>
                                        <exclude>META-INF/*.DSA</exclude>
                                        <exclude>META-INF/*.RSA</exclude>
                                    </excludes>
                                </filter>
                            </filters>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
2. 项目结构

在这里插入图片描述

3. spark job代码

获取外部参数，连接数据库，并将指定表中的数据根据指定的格式、目录转存到hdfs上

import org.apache.spark.sql.Dataset;
import org.apache.spark.sql.Row;
import org.apache.spark.sql.SparkSession;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * @Author hrong
 * @Description 将数据库中的表数据保存到hdfs上
 **/
public class DbTableEtl {
	private static Logger log = LoggerFactory.getLogger(DbTableEtl.class);

	public static void main(String[] args) {
		SparkSession spark = SparkSession.builder()
				.appName(DbTableEtl.class.getSimpleName())
				.getOrCreate();
		String url = args[0];
		String dbtable = args[1];
		String user = args[2];
		String password = args[3];
		String targetFileType = args[4];
		String targetFilePath = args[5];
		Dataset<Row> dbData = spark.read()
				.format("jdbc")
				.option("url", url)
				.option("dbtable", dbtable)
				.option("user", user)
				.option("password", password)
				.load();
		log.info("展示部分样例数据，即将开始导入到hdfs");
		dbData.show(20, false);
		dbData.write().mode("overwrite").format(targetFileType).save(targetFilePath);
	}
}

3. 项目打包

直接使用IDEA自带打包功能

1. springboot项目

在这里插入图片描述

2. Spark job项目

在这里插入图片描述

4. 上传至服务器

在这里插入图片描述

5. 将spark-job上传至hdfs

在这里插入图片描述

6. 启动springboot项目

在这里插入图片描述

7. 使用postman调用接口

指定jarPath、mainClass、deployMode以及任务所需参数
在这里插入图片描述

8. 调用结果

  • 程序开始提交任务
    在这里插入图片描述
  • 程序执行结束
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    代码放在了github上面，链接：github地址
hlp4207
关注
  • 15
    点赞
  • 踩
  • 67
    收藏
    觉得还不错? 一键收藏
  • 21
    评论
专栏目录
基于SpringBoot+Spark搭建本地计算引擎服务
jy739761380的专栏
06-16 505
本文只是描述搭建的主要流程，也为大家提供一个思路。如果想要了解详细的搭建留存请联系我哦。
springboot-rest-api-design:使用SpringBoot的REST API设计
05-02
该应用程序是一个示例项目，演示了如何使用SpringBoot，SpringSecurity，Spring Data JPA构建REST API。 怎么跑？ 将BlogApplication.java作为Java应用程序运行。 要探索和调用REST端点，请访问 一些端点需要身份...
SpringBoot项目通过httpClient调用SparkRestfulAPI提交spark作业到spark集群运行
无恋-zx的博客
09-13 3720
package com.rlt.services.impl; import com.alibaba.fastjson.JSON; import com.rlt.entity.SparkConfEntity; import com.rlt.entity.SparkResultEntity; import com.rlt.services.DictService; import com.rlt.u...
spring boot整合spark，基于yarn运行提交spark任务 spark on yarn
qq_41587243的博客
12-31 9723
springboot整理spark，基于yarn提交job任务
【收藏】使用springboot构建rest api远程提交spark任务
学亮编程手记
08-18 538
使用springboot构建rest api远程提交spark任务 https://blog.csdn.net/hlp4207/article/details/100831384
SpringBoot 快速入门，创建收个RestAPI
zjl523357813的专栏
02-24 292
1.座靠Spring （颠覆传统）2.内嵌Tomcat（无需外部署）3.提供各种Starter （开箱即用 +简化依赖 ）4.提供自动配置 （ 妈妈再也不用担我写错配置了）5.告别XML　（实现约定大于配置 ）
spring boot 内部执行 spark submit
骑着蜗牛向前跑的博客
07-08 1130
etrying connect to server: 0.0.0.0/0.0.0.0:8032. Already tried 0 time(s); retry policy is RetryUpToMaximumCountWithFixedSleep(maxRetries=10, sleepTime=1000 MILLISECONDS)
springboot项目在spark yarn 集群上部署运行
manbufenglin的专栏
05-20 2598
需求： 项目采用springboot开发，用于实现历史数据的统计分析及算法计算，通过spark-yarn运行跑出结果。 环境： JDK：1.8 操作系统：centos 7.6 大数据架构：Hadoop -Yarn-HA；spark 、hive 集群模型 项目预期效果： ./spark-submit --master yarn-client --class org.apache.spark.examples.SparkPi ../examples/jars/spark-examples_..
springboot-restapi：初始提交
02-14
【标题】"SpringBoot-RestAPI：初识与构建" 在现代Web开发中，Spring Boot框架因其简洁、高效和易用性而广受欢迎，尤其在构建RESTful API方面更是得心应手。"springboot-restapi：初始提交"这个项目，显然是一个...
REST_API:使用Springboot教程学习和构建REST API
03-29
在IT行业中，REST（Representational State Transfer）API已经成为构建现代Web服务的标准方法。Spring Boot是Java生态中的一个流行框架，它极大地简化了开发过程，包括创建RESTful API。本教程将深入探讨如何使用...
springboot-restapi
03-17
SpringBoot RESTAPI 是一个基于Java开发的轻量级框架，用于快速构建RESTful风格的Web服务。REST（Representational State Transfer）是一种网络应用程序的设计风格和开发方式，它基于HTTP协议，充分利用了HTTP协议的...
kafka-springboot-rest:使用springboot和rest的简单示例Apache Kafka
05-08
使用springboot和rest的简单示例Apache Kafka 下载并安装Kafka，请参阅的官方指南。 使用maven运行该应用程序。 从终端转到应用程序根目录，即“ mykafka-simple-rest”，然后使用mvn spring-boot：运行 正在从...
SpringBoot下YarnClient使用
仙道Bob的专栏
10-26 3443
1.pom.xml <properties> <!-- hadoop client --> <hadoop.client.version>2.6.0</hadoop.client.version> <!-- hadoop yarn api --> <hadoop.yarn.api.version>2.6.0</hadoop.yarn.api.version>
SpringBoot 使用 Spark
weixin_42555971的博客
02-13 4216
SpringBoot 使用 Spark
图解yarn的作业提交流程
weixin_46429290的博客
11-19 3056
YARN的作业提交机制 作业提交全过程详解 （1）作业提交 第 1 步：Client 调用 job.waitForCompletion 方法，向整个集群提交 MapReduce 作业。 第 2 步：Client 向 RM 申请一个作业 id。 第 3 步：RM 给 Client 返回该 job 资源的提交路径和作业 id。 第 4 步：Client 提交 jar 包、切片信息和配置文件到指定的资源提交路径。 第 5 步：Client 提交完资源后，向 RM 申请运行 MrAppMaster。 （2）作业初始
YARN提交任务的两种方式
我是一名程序猿
08-12 9778
第一种方式：yarn-client提交任务方式 Yarn-client模式提交命令写法1： ./spark-submit --master yarn --class org.apache.spark.examples.SparkPi ../lib/spark-examples-1.6.0-hadoop2.6.0.jar 100 Yarn-client模式提交命令写法2： ./spark...
SpringBoot 接入 Spark
weixin_42555971的博客
02-13 3705
SpringBoot 接入 Spark
通过springboot获取sparksql在yarn上执行的结果
shaozhiliang的博客
04-16 966
通过springboot获取sparksql在yarn上执行的结果 springboot + springcloud+nacos+spark on yarn 通过springboot获取sparksql在yarn上执行的结果 springboot项目的构建 主要的内容： 1.controller层：执行sql并获取结果的rest接口 2. service层：通过sparkSession，执行sql...
springboot Rest API
最新发布
08-24
这篇文章介绍了使用SpringBoot构建RESTful API的关键技术点，如果你已经具备相关经验，可以忽略这部分内容。 这篇文章还演示了使用SpringBoot构建RESTful API应用的完整过程，并提供了核心的配置和注解的说明。它...
评论 21
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值