Java版Spark离线统计分析实战

写在前面

本文系统环境：在windows中安装VMware，VMware中装CentOS7.9.2009系统为。

本文中需要用到的大数据组件有Hadoop、Spark及MongoDB数据库。均在CentOS中安装。

本文中运行的程序是在windows中的Idea编辑器中进行编写，且为用Java编写，非Scala。

版本说明

• Hadoop 2.10.1
• Spark 3.1.1
• MongoDB 3.4.3
• JDK 1.8

功能概述

本文设计两类信息，一类是产品信息，另一类是评分信息。

• 产品
  • 产品id
  • 标签
  • 图片
  • 名称
  • 分类
• 评分
  • 产品id
  • 用户id
  • 分数
  • 评分时间

本分主要实现功能点：

• 历史热门商品统计
• 最近热门商品统计
• 商品平均得分统计

环境搭建

Hadoop

参考文章《分布式处理框架Hadoop的安装与使用》

Spark

参考文章《Spark3.1.1入门》

MongoDB

本例中使用wget命令进行包下载，所以需要使用wget命令。

检查系统中是否有wget命令：

rpm -qa|grep wget

如果搜出来内容，就不必再安装wget。

如果没有安装，需要先用yum安装wget。

yum install -y wget

安装成功之后，切换到hadoop用户（安装hadoop的时候创建的）

su hadoop

进入hadoop用户家目录

cd ~

使用wget下载MongoDB资源

wget https://fastdl.mongodb.org/linux/mongodb-linux-x86_64-rhel62-3.4.3.tgz

解压资源

tar -zxf mongodb-linux-x86_64-rhel62-3.4.3.tgz -C ./

重命名

mv mongodb-linux-x86_64-rhel62-3.4.3 ./mongodb

在mongodb目录中创建data文件夹存放日志与数据

mkdir ./mongodb/data

创建数据文件夹

mkdir ./mongodb/data/db

创建日志文件夹

mkdir ./mongodb/data/logs

在logs文件夹下创建log文件

touch ./mongodb/data/logs/mongodb.log

在data文件夹下创建mongodb.conf配置文件

touch ./mongodb/data/mongodb.conf

编辑mongodb.conf配置文件

vim ./mongodb/data/mongodb.conf

加入以下内容

#端口
port=27017
#数据库存文件存放目录
dbpath= /home/hadoop/mongodb/data/db
#日志文件存放路径
logpath= /home/hadoop/mongodb/data/logs/mongodb.log
#使用追加的方式写日志
logappend=true
#以守护进程的方式运行，创建服务器进程
fork=true
#最大同时连接数
maxConns=100
#不启用验证
noauth=true
#每次写入会记录一条操作日志（通过journal可以重新构造出写入的数据）。
#即使宕机，启动时wiredtiger会先将数据恢复到最近一次的checkpoint点，然后重放后续的journal日志来恢复。
journal=true
#存储引擎，有mmapv1、wiretiger、mongorocks
storageEngine=wiredTiger
#设置成全部ip可以访问，这样就可以在windows中去连虚拟机的MongoDB，也可以设置成某个网段或者某个ip1234567891011
bind_ip = 0.0.0.0

启动MongoDB服务器

./mongodb/bin/mongod -config ./mongodb/data/mongodb.conf

访问MongoDB服务器

./mongodb/bin/mongo

输入exit退出。

停止MongoDB服务器

./mongodb/bin/mongod -shutdown -config ./mongodb/data/mongodb.conf

如果系统开启了防火墙，则需要开启27017端口，详细操作可见《CentOS7 中端口命令》。

在windows中可以使用Navicat Premium连接MongoDB。

程序设计

项目结构设计

总体分为两个项目，一个用于数据加载，一个用于数据分析。项目使用maven结构。

- BigData #父项目
	- DataLoader #加载业务数据
	- StatisticsRecommender #数据分析

代码开发

BigData

作为一个父项目，我们需要在里面引入全局依赖与定义依赖版本。

<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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0modelVersion>

    <groupId>cn.javayuligroupId>
    <artifactId>BigDataartifactId>
    <version>1.0version>
    <modules>
        <module>DataLoadermodule>
        <module>StatisticsRecommendermodule>
    modules>
    <packaging>pompackaging>

    <properties>
        <log4j.version>1.2.17log4j.version>
        <slf4j.version>1.7.22slf4j.version>
        <mongodb-spark.version>3.0.1mongodb-spark.version>
        <spark.version>3.1.1spark.version>
        <hutool.version>5.6.3hutool.version>
        <mongo-java-driver.version>3.12.8mongo-java-driver.version>
    properties>
    <dependencies>
        
        <dependency>
            <groupId>org.slf4jgroupId>
            <artifactId>jcl-over-slf4jartifactId>
            <version>${slf4j.version}version>
        dependency>
        <dependency>
            <groupId>org.slf4jgroupId>
            <artifactId>slf4j-apiartifactId>
            <version>${slf4j.version}version>
        dependency>
        <dependency>
            <groupId>org.slf4jgroupId>
            <artifactId>slf4j-log4j12artifactId>
            <version>${slf4j.version}version>
        dependency>
        <dependency>
            <groupId>log4jgroupId>
            <artifactId>log4jartifactId>
            <version>${log4j.version}version>
        dependency>
        
        <dependency>
            <groupId>cn.hutoolgroupId>
            <artifactId>hutool-allartifactId>
            <version>${hutool.version}version>
        dependency>

    dependencies>

    <dependencyManagement>
        <dependencies>
            
            <dependency>
                <groupId>org.apache.sparkgroupId>
                <artifactId>spark-core_2.12artifactId>
                <version>${spark.version}version>
            dependency>
            <dependency>
                <groupId>org.apache.sparkgroupId>
                <artifactId>spark-sql_2.12artifactId>
                <version>${spark.version}version>
            dependency>
            <dependency>
                <groupId>org.apache.sparkgroupId>
                <artifactId>spark-streaming_2.12artifactId>
                <version>${spark.version}version>
            dependency>
            <dependency>
                <groupId>org.apache.sparkgroupId>
                <artifactId>spark-mllib_2.12artifactId>
                <version>${spark.version}version>
            dependency>
            <dependency>
                <groupId>org.apache.sparkgroupId>
                <artifactId>spark-graphx_2.12artifactId>
                <version>${spark.version}version>
            dependency>
        dependencies>
    dependencyManagement>

    <repositories>
        <repository>
            <id>nexus-aliyunid>
            <name>Nexus aliyunname>
            <layout>defaultlayout>
            <url>http://maven.aliyun.com/nexus/content/groups/publicurl>
            <snapshots>
                <enabled>falseenabled>
            snapshots>
            <releases>
                <enabled>trueenabled>
            releases>
        repository>
    repositories>
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.pluginsgroupId>
                <artifactId>maven-compiler-pluginartifactId>
                <version>3.6.1version>
                
                <configuration>
                    <source>1.8source>
                    <target>1.8target>
                configuration>
            plugin>
        plugins>
        <pluginManagement>
            <plugins>
                <plugin>
                    <groupId>org.apache.maven.pluginsgroupId>
                    <artifactId>maven-assembly-pluginartifactId>
                    <version>3.0.0version>
                    <configuration>
                        <descriptorRefs>
                            <descriptorRef>jar-with-dependenciesdescriptorRef>
                        descriptorRefs>
                    configuration>
                    <executions>
                        <execution>
                            <id>make-assemblyid>
                            <phase>packagephase>
                            <goals>
                                <goal>singlegoal>
                            goals>
                        execution>
                    executions>
                plugin>
            plugins>
        pluginManagement>
    build>
project>

DataLoader

此项目功能为从csv文件中加载数据，用spark按照具体规则处理后，将数据写入MongoDB数据库中。

在resources目录下新建log4j.properties，写入以下内容

log4j.rootLogger=info, stdout
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss,SSS}  %5p --- [%50t]  %-80c(line:%5L)  :  %m%n

项目pom.xml

<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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>BigDataartifactId>
        <groupId>cn.javayuligroupId>
        <version>1.0version>
    parent>
    <modelVersion>4.0.0modelVersion>

    <groupId>cn.javayuligroupId>
    <artifactId>DataLoaderartifactId>
    <version>1.0version>

    <properties>
        <maven.compiler.source>1.8maven.compiler.source>
        <maven.compiler.target>1.8maven.compiler.target>
    properties>

    <dependencies>
        
        <dependency>
            <groupId>org.apache.sparkgroupId>
            <artifactId>spark-core_2.12artifactId>
        dependency>
        <dependency>
            <groupId>org.apache.sparkgroupId>
            <artifactId>spark-sql_2.12artifactId>
        dependency>
        
        <dependency>
            <groupId>org.mongodbgroupId>
            <artifactId>mongo-java-driverartifactId>
            <version>${mongo-java-driver.version}version>
        dependency>
        <dependency>
            <groupId>org.mongodb.sparkgroupId>
            <artifactId>mongo-spark-connector_2.12artifactId>
            <version>${mongodb-spark.version}version>
        dependency>
    dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.pluginsgroupId>
                <artifactId>maven-assembly-pluginartifactId>
            plugin>
        plugins>
    build>
project>

Products数据集

Products数据集（products.csv）有7个字段，每个字段之间通过“^”符号进行分割。其中的categoryIds、amazonId对于内容特征没有实质帮助，我们只需要其它5个字段:

字段名	字段类型	字段描述	字段备注
productId	Integer	商品ID
name	String	商品名称
categories	String	商品分类	每一项用“|”分割
imageUrl	String	商品图片URL
tags	String	商品UGC标签	每一项用“|”分割

Ratings数据集

Ratings数据集（ratings.csv）有4个字段，每个字段之间通过“,”符号进行分割。

字段名	字段类型	字段描述	字段备注
userId	Integer	用户ID
productId	Integer	商品ID
score	Double	评分值
timestamp	Integer	评分时间

根据上述数据模型，我们建了Product，Rating两个实体

package cn.javayuli.entity;

/**
 * 产品实体
 *
 * @author hanguilin
 */
public class Product {

    /**
     * product集合名称
     */
    public static final String COLLECTION_PRODUCT = "Products";

    /**
     * 商品id
     */
    private Integer productId;

    /**
     * 商品名称
     */
    private String name;

    /**
     * 商品分类
     */
    private String categories;

    /**
     * 商品图片url
     */
    private String imageUrl;

    /**
     * 商品UGC标签
     */
    private String tags;

    public Product(Integer productId, String name, String categories, String imageUrl, String tags) {
        this.productId = productId;
        this.name = name;
        this.categories = categories;
        this.imageUrl = imageUrl;
        this.tags = tags;
    }

    public Integer getProductId() {
        return productId;
    }

    public void setProductId(Integer productId) {
        this.productId = productId;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getCategories() {
        return categories;
    }

    public void setCategories(String categories) {
        this.categories = categories;
    }

    public String getImageUrl() {
        return imageUrl;
    }

    public void setImageUrl(String imageUrl) {
        this.imageUrl = imageUrl;
    }

    public String getTags() {
        return tags;
    }

    public void setTags(String tags) {
        this.tags = tags;
    }
}

package cn.javayuli.entity;

/**
 * 评分实体
 *
 * @author hanguilin
 */
public class Rating {

    /**
     * rating集合名称
     */
    public static final String COLLECTION_RATING = "Ratings";

    /**
     * 用户id
     */
    private Integer userId;

    /**
     * 商品id
     */
    private Integer productId;

    /**
     * 评分值
     */
    private Double score;

    /**
     * 评分时间
     */
    private Integer timestamp;

    public Rating(Integer userId, Integer productId, Double score, Integer timestamp) {
        this.userId = userId;
        this.productId = productId;
        this.score = score;
        this.timestamp = timestamp;
    }

    public Integer getUserId() {
        return userId;
    }

    public void setUserId(Integer userId) {
        this.userId = userId;
    }

    public Integer getProductId() {
        return productId;
    }

    public void setProductId(Integer productId) {
        this.productId = productId;
    }

    public Double getScore() {
        return score;
    }

    public void setScore(Double score) {
        this.score = score;
    }

    public Integer getTimestamp() {
        return timestamp;
    }

    public void setTimestamp(Integer timestamp) {
        this.timestamp = timestamp;
    }
}

主程序

package cn.javayuli.processor;


import cn.hutool.json.JSONUtil;
import cn.javayuli.entity.Product;
import cn.javayuli.entity.Rating;
import com.google.common.collect.Maps;
import com.mongodb.spark.MongoSpark;
import com.mongodb.spark.config.WriteConfig;
import org.apache.spark.SparkConf;
import org.apache.spark.api.java.JavaRDD;
import org.apache.spark.api.java.JavaSparkContext;
import org.apache.spark.api.java.function.Function;
import org.bson.Document;

import java.util.HashMap;


/**
 * 加载数据类
 *
 * @author hanguilin
 */
public class Loader {

    /**
     * 创建SparkContext
     *
     * @return
     */
    private static JavaSparkContext createJavaSparkContext() {
        String uri = "mongodb://192.168.1.43:27017/bigData.coll";
        SparkConf sparkConf = new SparkConf()
                .setAppName("DataLoader")
                .setMaster("local[*]")
                .set("spark.app.id", "DataLoader")
                .set("spark.mongodb.input.uri", uri)
                .set("spark.mongodb.output.uri", uri);
        JavaSparkContext sparkContext = new JavaSparkContext(sparkConf);
        return sparkContext;
    }

    /**
     * 加载数据写入mongodb
     *
     * @param context spark context
     * @param filePath 文件路径
     * @param collection mongodb中集合名称
     * @param mapFunc String RDD转换为Entity RDD的转换函数
     * @param  泛型T
     */
    private static <T> void writeDataToMongo(JavaSparkContext context, String filePath, String collection, Function<String,T> mapFunc) {
        // 读取文件成RDD
        JavaRDD<String> stringRDD = context.textFile(filePath);
        // String类型RDD调用map函数转换成实体类的RDD
        JavaRDD<T> entityRDD = stringRDD.map(mapFunc);
        // 实体类的RDD调用map函数转换成MongoDB中Document的RDD
        JavaRDD<Document> documentRDD = entityRDD.map((Function<T, Document>) entityDocument -> Document.parse(JSONUtil.toJsonStr(entityDocument)));
        // 配置MongoDB写入参数
        HashMap<String, String> writeOverrides = Maps.newHashMap();
        writeOverrides.put("collection", collection);
        writeOverrides.put("writeConcern.w", "majority");
        WriteConfig writeConfig = WriteConfig.create(context).withOptions(writeOverrides);
        // 插入数据库
        MongoSpark.save(documentRDD, writeConfig);
    }

    public static void main(String[] args) {
        JavaSparkContext sparkContext = createJavaSparkContext();
        // Product转换函数
        Function<String, Product> productMapFunc = (item) -> {
            String[] split = item.split("\\^");
            return new Product(Integer.valueOf(split[0]), split[1].trim(), split[4].trim(), split[5].trim(), split[6].trim());
        };
        writeDataToMongo(sparkContext, "F:\\workspace\\BigData\\DataLoader\\src\\main\\resources\\products.csv", Product.COLLECTION_PRODUCT, productMapFunc);
        // Rating转换函数
        Function<String, Rating> ratingMapFunc = (item) -> {
            String[] split = item.split(",");
            return new Rating(Integer.valueOf(split[0]), Integer.valueOf(split[1]), Double.valueOf(split[2]), Integer.valueOf(split[3]));
        };
        writeDataToMongo(sparkContext, "F:\\workspace\\BigData\\DataLoader\\src\\main\\resources\\ratings.csv", Rating.COLLECTION_RATING, ratingMapFunc);
    }
}

运行main函数即可将csv数据导入到MongoDB数据库中。

StatisticsRecommender

此项目功能为从MongoDB数据库中读取数据，利用SparkSql进行数据分析，将分析结果写入MongoDB。

在resources目录下新建log4j.properties，写入以下内容

log4j.rootLogger=info, stdout
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss,SSS}  %5p --- [%50t]  %-80c(line:%5L)  :  %m%n

项目pom.xml

<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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>BigDataartifactId>
        <groupId>cn.javayuligroupId>
        <version>1.0version>
    parent>
    <modelVersion>4.0.0modelVersion>

    <artifactId>StatisticsRecommenderartifactId>

    <properties>
        <maven.compiler.source>1.8maven.compiler.source>
        <maven.compiler.target>1.8maven.compiler.target>
    properties>

    <dependencies>
        
        <dependency>
            <groupId>org.apache.sparkgroupId>
            <artifactId>spark-core_2.12artifactId>
        dependency>
        <dependency>
            <groupId>org.apache.sparkgroupId>
            <artifactId>spark-sql_2.12artifactId>
        dependency>
        
        <dependency>
            <groupId>org.mongodbgroupId>
            <artifactId>mongo-java-driverartifactId>
            <version>${mongo-java-driver.version}version>
        dependency>
        <dependency>
            <groupId>org.mongodb.sparkgroupId>
            <artifactId>mongo-spark-connector_2.12artifactId>
            <version>${mongodb-spark.version}version>
        dependency>
    dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.pluginsgroupId>
                <artifactId>maven-assembly-pluginartifactId>
            plugin>
        plugins>
    build>
project>

主程序

package cn.javayuli.processor;

import com.mongodb.spark.MongoSpark;
import org.apache.spark.api.java.JavaSparkContext;
import org.apache.spark.sql.Dataset;
import org.apache.spark.sql.Row;
import org.apache.spark.sql.SparkSession;
import org.apache.spark.sql.api.java.UDF1;
import org.apache.spark.sql.types.DataTypes;

import java.time.Instant;
import java.time.ZoneId;
import java.time.format.DateTimeFormatter;

/**
 * 统计类
 *
 * @author hanguilin
 */
public class Statistics {

    /**
     * 历史热门商品集合
     */
    private static final String COLLECTION_HOT = "RateHotProducts";

    /**
     * 历史热门商品集合
     */
    private static final String COLLECTION_HOT_RECENTLY = "RateHotRecentlyProducts";

    /**
     * 商品平均得分集合
     */
    private static final String COLLECTION_AVERAGE = "AverageProducts";

    /**
     * 时间序列化
     */
    private static DateTimeFormatter YEAR_MONTH = DateTimeFormatter.ofPattern("yyyyMM");

    /**
     * 创建SparkSession
     *
     * @return
     */
    private static SparkSession createSparkSession() {
        String uri = "mongodb://192.168.1.43:27017/bigData.Ratings";
        SparkSession sparkSession = SparkSession.builder()
                .appName("DataLoader")
                .master("local[*]")
                .config("spark.app.id", "DataLoader")
                .config("spark.mongodb.input.uri", uri)
                .config("spark.mongodb.output.uri", uri)
                .getOrCreate();
        return sparkSession;
    }

    public static void main(String[] args) {
        SparkSession sparkSession = createSparkSession();
        JavaSparkContext sparkContext = new JavaSparkContext(sparkSession.sparkContext());
        Dataset<Row> rowDataset = MongoSpark.load(sparkContext).toDF();
        // 打印schema
        rowDataset.printSchema();
        // 打印数据
        rowDataset.show();
        // 内存中创建一个临时表Ratings
        rowDataset.createOrReplaceTempView("Ratings");

        // *****************历史热门商品统计******************
        Dataset<Row> rateHotProducts = sparkSession.sql("select productId, count(productId) as count from Ratings group by productId");
        MongoSpark.write(rateHotProducts).option("collection", COLLECTION_HOT).mode("overwrite").format("com.mongodb.spark.sql").save();

        // *****************最近热门商品统计******************
        // 注册一个UDF函数，用于将timestamp转换成年月格式
        sparkSession.udf().register("changeDate", (UDF1<Integer, Integer>) (parameter) -> Integer.valueOf(Instant.ofEpochSecond(parameter).atZone(ZoneId.systemDefault()).toLocalDate().format(YEAR_MONTH)), DataTypes.IntegerType);
        // 将原来的Rating数据集中的时间转换成年月的格式
        Dataset<Row> ratingOfYearMonth = sparkSession.sql("select productId, score, changeDate(timestamp) as yearmonth from Ratings");
        // 将新的数据集注册成为一张表
        ratingOfYearMonth.createOrReplaceTempView("RatingOfMonth");
        // 根据月份和商品进行统计，并按年月与数量进行倒序排序
        Dataset<Row> rateHotRecentlyProducts = sparkSession.sql("select productId, count(productId) as count ,yearmonth from RatingOfMonth group by yearmonth,productId order by yearmonth desc, count desc");
        MongoSpark.write(rateHotRecentlyProducts).option("collection", COLLECTION_HOT_RECENTLY).mode("overwrite").format("com.mongodb.spark.sql").save();

        // *****************商品平均得分统计******************
        Dataset<Row> averageProducts = sparkSession.sql("select productId, avg(score) as avg from Ratings group by productId");
        MongoSpark.write(averageProducts).option("collection", COLLECTION_AVERAGE).mode("overwrite").format("com.mongodb.spark.sql").save();
    }
}

运行main函数，就可以将数据写入到各个MongoDB的集合中去

以上就是Spark程序在本地的开发与调试。现在需要打包到服务器中运行。

服务器运行

hadoop

启动hadoop:

# 启动hdfs
start-dfs.sh
# 启动yarn
start-yarn.sh
# 启动历史服务器
mr-jobhistory-daemon.sh start historyserver

查看是否启动成功：

jps

出现上述列表即为成功，其他情况请查看《分布式处理框架Hadoop的安装与使用》。

Jar

我们修改一下csv文件路径，使其从hdfs中读取数据。修改后的DataLoader项目中的Loader.java中的main函数：

public static void main(String[] args) {
        JavaSparkContext sparkContext = createJavaSparkContext();
        // Product转换函数
        Function<String, Product> productMapFunc = (item) -> {
            String[] split = item.split("\\^");
            return new Product(Integer.valueOf(split[0]), split[1].trim(), split[4].trim(), split[5].trim(), split[6].trim());
        };
        writeDataToMongo(sparkContext, "hdfs://localhost:9000/user/hadoop/input/products.csv", Product.COLLECTION_PRODUCT, productMapFunc);
        // Rating转换函数
        Function<String, Rating> ratingMapFunc = (item) -> {
            String[] split = item.split(",");
            return new Rating(Integer.valueOf(split[0]), Integer.valueOf(split[1]), Double.valueOf(split[2]), Integer.valueOf(split[3]));
        };
        writeDataToMongo(sparkContext, "hdfs://localhost:9000/user/hadoop/input/ratings.csv", Rating.COLLECTION_RATING, ratingMapFunc);
    }

只修改了两处文件路径。

通过idea的maven将DataLoader、StatisticsRecommender项目打包。

将两个包及products.csv、ratings.csv上传至服务器的/home/hadoop/sparkapp中。

将两个文件上传至hdfs文件系统中：

cd ~/sparkapp
hdfs dfs -put ./*.csv /user/hadoop/input

查看hdfs中的文件：

hdfs dfs -ls /user/hadoop/input

还原

为了测试程序运行结果，请先将MongoDB中本地测试数据清除。

提交任务

运行数据加载任务：

spark-submit --class "cn.javayuli.processor.Loader" DataLoader-1.0-jar-with-dependencies.jar

此时数据加载成功：

运行数据分析任务：

spark-submit --class "cn.javayuli.processor.Statistics" StatisticsRecommender-1.0-jar-with-dependencies.jar 

此时数据分析和写入成功：

资源链接

源代码git地址：https://github.com/hanguilin/BigData-demo/tree/main/Recommender
MongoSpark文档：https://docs.mongodb.com/spark-connector/current/java/datasets-and-sql/