cold start

.gitignore

@@ -0,0 +1,50 @@
+# ---> Java
+*.class
+
+# Mobile Tools for Java (J2ME)
+.mtj.tmp/
+
+# Package Files #
+*.jar
+*.war
+*.ear
+
+# virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml
+hs_err_pid*
+
+HELP.md
+target/
+!.mvn/wrapper/maven-wrapper.jar
+!**/src/main/**/target/
+!**/src/test/**/target/
+
+### STS ###
+.apt_generated
+.classpath
+.factorypath
+.project
+.settings
+.springBeans
+.sts4-cache
+
+### IntelliJ IDEA ###
+.idea
+*.iws
+*.iml
+*.ipr
+
+### NetBeans ###
+/nbproject/private/
+/nbbuild/
+/dist/
+/nbdist/
+/.nb-gradle/
+build/
+!**/src/main/**/build/
+!**/src/test/**/build/
+
+### VS Code ###
+.vscode/
+
+### log ###
+logs/*

pom.xml

@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<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.0</modelVersion>
+    <packaging>pom</packaging>
+    <parent>
+        <groupId>com.tzld.commons</groupId>
+        <artifactId>supom</artifactId>
+        <version>1.0.9</version>
+    </parent>
+    <groupId>com.tzld.piaoquan</groupId>
+    <artifactId>recommend-model</artifactId>
+    <version>1.0.0</version>
+    <name>recommend-model</name>
+    <description>recommend-model</description>
+
+    <modules>
+        <module>recommend-model-produce</module>
+    </modules>
+
+    <dependencies>
+    </dependencies>
+
+</project>

recommend-model-produce/pom.xml

@@ -0,0 +1,171 @@
+<?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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <parent>
+        <artifactId>recommend-model</artifactId>
+        <groupId>com.tzld.piaoquan</groupId>
+        <version>1.0.0</version>
+    </parent>
+    <modelVersion>4.0.0</modelVersion>
+
+    <artifactId>recommend-model-produce</artifactId>
+
+    <properties>
+        <!--        <spark.version>3.3.1</spark.version>-->
+        <!--        <scala.version>2.12.15</scala.version>-->
+        <spark.version>2.3.0</spark.version>
+        <scala.version>2.11.8</scala.version>
+        <emr.version>2.0.0</emr.version>
+        <java.version>1.8</java.version>
+        <odps.version>0.48.4-public</odps.version>
+        <fastjson.version>1.2.45</fastjson.version>
+
+        <maven.compiler.source>8</maven.compiler.source>
+        <maven.compiler.target>8</maven.compiler.target>
+    </properties>
+
+    <dependencies>
+        <dependency>
+            <groupId>org.apache.spark</groupId>
+            <artifactId>spark-core_2.11</artifactId>
+            <version>${spark.version}</version>
+            <exclusions>
+                <exclusion>
+                    <groupId>io.netty</groupId>
+                    <artifactId>netty-all</artifactId>
+                </exclusion>
+                <exclusion>
+                    <artifactId>slf4j-log4j12</artifactId>
+                    <groupId>org.slf4j</groupId>
+                </exclusion>
+                <exclusion>
+                    <artifactId>scala-library</artifactId>
+                    <groupId>org.scala-lang</groupId>
+                </exclusion>
+            </exclusions>
+        </dependency>
+        <dependency>
+            <groupId>org.apache.spark</groupId>
+            <artifactId>spark-mllib_2.11</artifactId>
+            <version>${spark.version}</version>
+            <exclusions>
+                <exclusion>
+                    <artifactId>scala-library</artifactId>
+                    <groupId>org.scala-lang</groupId>
+                </exclusion>
+            </exclusions>
+        </dependency>
+        <dependency>
+            <groupId>io.netty</groupId>
+            <artifactId>netty-all</artifactId>
+            <version>4.1.17.Final</version>
+        </dependency>
+        <dependency>
+            <groupId>com.aliyun.emr</groupId>
+            <artifactId>emr-maxcompute_2.11</artifactId>
+            <version>${emr.version}</version>
+            <exclusions>
+                <exclusion>
+                    <artifactId>spark-core_2.11</artifactId>
+                    <groupId>org.apache.spark</groupId>
+                </exclusion>
+                <exclusion>
+                    <artifactId>spark-catalyst_2.11</artifactId>
+                    <groupId>org.apache.spark</groupId>
+                </exclusion>
+            </exclusions>
+        </dependency>
+        <dependency>
+            <groupId>org.scala-lang</groupId>
+            <artifactId>scala-library</artifactId>
+            <version>${scala.version}</version>
+        </dependency>
+
+        <dependency>
+            <groupId>com.alibaba</groupId>
+            <artifactId>fastjson</artifactId>
+            <version>${fastjson.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>redis.clients</groupId>
+            <artifactId>jedis</artifactId>
+            <version>5.1.3</version>
+        </dependency>
+        <dependency>
+            <groupId>com.aliyun.odps</groupId>
+            <artifactId>odps-sdk-core</artifactId>
+            <version>${odps.version}</version>
+            <exclusions>
+                <exclusion>
+                    <groupId>org.codehaus.jackson</groupId>
+                    <artifactId>jackson-mapper-asl</artifactId>
+                </exclusion>
+                <exclusion>
+                    <groupId>org.codehaus.jackson</groupId>
+                    <artifactId>jackson-core-asl</artifactId>
+                </exclusion>
+            </exclusions>
+        </dependency>
+        <dependency>
+            <groupId>com.aliyun.odps</groupId>
+            <artifactId>odps-sdk-commons</artifactId>
+            <version>${odps.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.projectlombok</groupId>
+            <artifactId>lombok</artifactId>
+            <version>1.18.24</version>
+        </dependency>
+        <dependency>
+            <groupId>com.ctrip.framework.apollo</groupId>
+            <artifactId>apollo-client</artifactId>
+            <version>1.8.0</version>
+        </dependency>
+        <dependency>
+            <groupId>org.slf4j</groupId>
+            <artifactId>slf4j-simple</artifactId>
+            <version>1.7.28</version>
+        </dependency>
+        <dependency>
+            <groupId>com.aliyun.oss</groupId>
+            <artifactId>aliyun-sdk-oss</artifactId>
+            <version>3.17.4</version>
+        </dependency>
+        <dependency>
+            <groupId>ml.dmlc</groupId>
+            <artifactId>xgboost4j-spark</artifactId>
+            <version>0.90</version>
+            <exclusions>
+                <exclusion>
+                    <artifactId>scala-library</artifactId>
+                    <groupId>org.scala-lang</groupId>
+                </exclusion>
+            </exclusions>
+        </dependency>
+    </dependencies>
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-assembly-plugin</artifactId>
+                <version>2.5.5</version>
+                <configuration>
+                    <descriptorRefs>
+                        <descriptorRef>jar-with-dependencies</descriptorRef>
+                    </descriptorRefs>
+                    <finalName>${project.name}</finalName>
+                </configuration>
+                <executions>
+                    <execution>
+                        <id>make-assembly</id>
+                        <phase>package</phase>
+                        <goals>
+                            <goal>single</goal>
+                        </goals>
+                    </execution>
+                </executions>
+            </plugin>
+        </plugins>
+    </build>
+</project>

recommend-model-produce/src/main/java/com/tzld/piaoquan/recommend/model/produce/service/CMDService.java

@@ -0,0 +1,20 @@
+package com.tzld.piaoquan.recommend.model.produce.service;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * https://help.aliyun.com/zh/maxcompute/user-guide/java-sdk-1/?spm=a2c4g.11174283.0.0.6d0111c1E15lI3
+ *
+ * @author dyp
+ */
+public class CMDService {
+
+    public Map<String, String> parse(String[] args) {
+        Map<String, String> map = new HashMap<>();
+        for (int i = 0; i < args.length - 1; i++) {
+            map.put(args[i].substring(1), args[i + 1]);
+        }
+        return map;
+    }
+}

recommend-model-produce/src/main/java/com/tzld/piaoquan/recommend/model/produce/service/HDFSService.java

@@ -0,0 +1,34 @@
+package com.tzld.piaoquan.recommend.model.produce.service;
+
+import lombok.extern.slf4j.Slf4j;
+import org.apache.hadoop.conf.Configuration;
+import org.apache.hadoop.fs.FileSystem;
+import org.apache.hadoop.fs.Path;
+
+import java.io.IOException;
+import java.io.Serializable;
+
+/**
+ * @author dyp
+ */
+@Slf4j
+public class HDFSService implements Serializable {
+    private FileSystem fSystem;
+
+    public HDFSService() throws IOException {
+        fSystem = FileSystem.get(new Configuration());
+    }
+
+    public boolean createDir(String dir) throws IOException {
+        Path dirPath = new Path(dir);
+        if (!fSystem.exists(dirPath)) {
+            fSystem.mkdirs(dirPath);
+        }
+        return true;
+    }
+
+    public boolean delete(String path) throws IOException {
+        return fSystem.delete(new Path(path));
+    }
+
+}

recommend-model-produce/src/main/java/com/tzld/piaoquan/recommend/model/produce/service/ODPSService.java

@@ -0,0 +1,109 @@
+package com.tzld.piaoquan.recommend.model.produce.service;
+
+import com.aliyun.odps.Instance;
+import com.aliyun.odps.Odps;
+import com.aliyun.odps.OdpsException;
+import com.aliyun.odps.TableSchema;
+import com.aliyun.odps.account.Account;
+import com.aliyun.odps.account.AliyunAccount;
+import com.aliyun.odps.data.Record;
+import com.aliyun.odps.data.SimpleJsonValue;
+import com.aliyun.odps.task.SQLTask;
+import com.google.common.base.Joiner;
+import com.tzld.piaoquan.recommend.model.produce.util.CommonCollectionUtils;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.spark.aliyun.odps.OdpsOps;
+import org.apache.spark.api.java.JavaRDD;
+import org.apache.spark.api.java.JavaSparkContext;
+import org.apache.spark.api.java.function.Function2;
+
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * https://help.aliyun.com/zh/maxcompute/user-guide/java-sdk-1/?spm=a2c4g.11174283.0.0.6d0111c1E15lI3
+ *
+ * @author dyp
+ */
+@Slf4j
+public class ODPSService {
+    private final String accessId = "LTAIWYUujJAm7CbH";
+    private final String accessKey = "RfSjdiWwED1sGFlsjXv0DlfTnZTG1P";
+    private final String odpsUrl = "http://service.odps.aliyun.com/api";
+    private final String tunnelUrl = "http://dt.cn-hangzhou.maxcompute.aliyun.com";
+    private final String sqlFormat = "select %s from %s where 1=1 %s ;";
+    private final String countSqlFormat = "select count(1) as count from %s where 1=1 %s ;";
+
+
+    public JavaRDD<Map<String, String>> read(JavaSparkContext jsc, String project, String table, String partition,
+                                             int partitionNum) {
+        OdpsOps odpsOps = new OdpsOps(jsc.sc(), accessId, accessKey, odpsUrl, tunnelUrl);
+
+        JavaRDD<Map<String, String>> readData = odpsOps.readTableWithJava(project, table, partition,
+                new RecordToMap(), partitionNum);
+        return readData;
+    }
+
+    static class RecordToMap implements Function2<Record, TableSchema, Map<String, String>> {
+        private List<String> cols;
+
+        public RecordToMap(List<String> cols) {
+            this.cols = cols;
+        }
+
+        public RecordToMap() {
+        }
+
+        @Override
+        public Map<String, String> call(Record r, TableSchema schema) {
+            Map<String, String> map = new HashMap<>();
+            for (int i = 0; i < schema.getColumns().size(); i++) {
+                if (cols == null || cols.contains(r.getColumns()[i].getName())) {
+                    Object obj = r.get(i);
+                    if (obj instanceof SimpleJsonValue) {
+                        map.put(r.getColumns()[i].getName(), ((SimpleJsonValue) obj).toString());
+                    } else if (obj instanceof Long) {
+                        map.put(r.getColumns()[i].getName(), ((Long) obj) + "");
+                    } else {
+                        map.put(r.getColumns()[i].getName(), r.getString(i));
+                    }
+                }
+            }
+            return map;
+        }
+    }
+
+    private List<Map<String, String>> read(String project,
+                                           String table,
+                                           List<String> colNames,
+                                           String condition) {
+        Account account = new AliyunAccount(accessId, accessKey);
+        Odps odps = new Odps(account);
+        odps.setEndpoint(odpsUrl);
+        odps.setDefaultProject(project);
+
+        String sql = String.format(sqlFormat, Joiner.on(",").join(colNames), table, condition);
+
+        List<Record> records;
+        try {
+            Instance i = SQLTask.run(odps, sql);
+            i.waitForSuccess();
+            records = SQLTask.getResult(i);
+        } catch (OdpsException e) {
+            log.error("request odps error", e);
+            return Collections.emptyList();
+        }
+
+        List<Map<String, String>> fieldValues = CommonCollectionUtils.toList(records, r -> {
+            Map<String, String> map = new HashMap<>();
+            for (int i = 0; i < r.getColumnCount(); i++) {
+                map.put(r.getColumns()[i].getName(), r.getString(i));
+            }
+            return map;
+        });
+
+        return fieldValues;
+    }
+}

recommend-model-produce/src/main/java/com/tzld/piaoquan/recommend/model/produce/service/OSSService.java

@@ -0,0 +1,76 @@
+package com.tzld.piaoquan.recommend.model.produce.service;
+
+import com.aliyun.oss.OSS;
+import com.aliyun.oss.OSSClientBuilder;
+import com.aliyun.oss.model.CopyObjectRequest;
+import com.aliyun.oss.model.CopyObjectResult;
+import com.aliyun.oss.model.ObjectMetadata;
+import lombok.extern.slf4j.Slf4j;
+
+import java.io.Serializable;
+import java.util.List;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * @author dyp
+ */
+@Slf4j
+public class OSSService implements Serializable {
+    private String accessId = "LTAI5tHMkNaRhpiDB1yWMZPn";
+    private String accessKey = "XLi5YUJusVwbbQOaGeGsaRJ1Qyzbui";
+    private String endpoint = "https://oss-cn-hangzhou-internal.aliyuncs.com";
+
+    public void transToDeepColdArchive(String bucketName, List<String> objectNames) {
+        OSS ossClient = new OSSClientBuilder().build(endpoint, accessId, accessKey);
+        for (String objectName : objectNames) {
+            try {
+                if (objectName.startsWith("http")) {
+                    continue;
+                }
+                CopyObjectRequest request = new CopyObjectRequest(bucketName, objectName, bucketName, objectName);
+                ObjectMetadata objectMetadata = new ObjectMetadata();
+                objectMetadata.setHeader("x-oss-storage-class", "DeepColdArchive");
+                request.setNewObjectMetadata(objectMetadata);
+                CopyObjectResult result = ossClient.copyObject(request);
+            } catch (Exception e) {
+                log.error("transToDeepColdArchive error {} {}", objectName, e.getMessage(), e);
+            }
+        }
+        if (ossClient != null) {
+            ossClient.shutdown();
+        }
+    }
+
+    public void transToDeepColdArchive2(String bucketName, List<String> objectNames) {
+        OSS ossClient = new OSSClientBuilder().build(endpoint, accessId, accessKey);
+        CountDownLatch cdl = new CountDownLatch(objectNames.size());
+        ExecutorService es = Executors.newFixedThreadPool(3);
+        for (String objectName : objectNames) {
+            es.submit(() -> {
+                try {
+                    if (!objectName.startsWith("http")) {
+                        CopyObjectRequest request = new CopyObjectRequest(bucketName, objectName, bucketName, objectName);
+                        ObjectMetadata objectMetadata = new ObjectMetadata();
+                        objectMetadata.setHeader("x-oss-storage-class", "DeepColdArchive");
+                        request.setNewObjectMetadata(objectMetadata);
+                        ossClient.copyObject(request);
+                    }
+                } catch (Exception e) {
+                    log.error("transToDeepColdArchive error {} {}", objectName, e.getMessage(), e);
+                }
+                cdl.countDown();
+            });
+        }
+        try {
+            cdl.await(1, TimeUnit.HOURS);
+        } catch (InterruptedException e) {
+            log.error("transToDeepColdArchive error", e);
+        }
+        if (ossClient != null) {
+            ossClient.shutdown();
+        }
+    }
+}

recommend-model-produce/src/main/java/com/tzld/piaoquan/recommend/model/produce/util/CommonCollectionUtils.java

@@ -0,0 +1,49 @@
+package com.tzld.piaoquan.recommend.model.produce.util;
+
+import org.apache.commons.collections.CollectionUtils;
+import org.apache.commons.collections.MapUtils;
+
+import java.util.*;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+
+/**
+ * @author dyp
+ */
+public class CommonCollectionUtils {
+    public static <T, R> List<R> toList(Collection<T> list, Function<T, R> map) {
+        if (CollectionUtils.isEmpty(list)) {
+            return Collections.emptyList();
+        }
+        return list.stream().map(map).collect(Collectors.toList());
+    }
+
+    public static <T, K, V> Map<K, V> toMap(List<T> list, Function<T, K> keyFunc, Function<T, V> valueFunc) {
+        if (CollectionUtils.isEmpty(list)) {
+            return Collections.emptyMap();
+        }
+        return list.stream().collect(Collectors.toMap(keyFunc::apply, valueFunc::apply));
+    }
+
+    public static <T, K, V> Map<K, V> toMap(T[] list, Function<T, K> keyFunc, Function<T, V> valueFunc) {
+
+        if (list == null || list.length == 0) {
+            return Collections.emptyMap();
+        }
+        return Arrays.stream(list).collect(Collectors.toMap(keyFunc::apply, valueFunc::apply));
+    }
+
+    public static <K, V> Map<K, V> merge(Map<K, V> map1, Map<K, V> map2) {
+        if (MapUtils.isEmpty(map1)) {
+            return map2;
+        }
+        if (MapUtils.isEmpty(map2)) {
+            return map1;
+        }
+
+        Map<K, V> map = new HashMap<>();
+        map.putAll(map1);
+        map.putAll(map2);
+        return map;
+    }
+}

recommend-model-produce/src/main/java/com/tzld/piaoquan/recommend/model/produce/util/DateUtils.java

@@ -0,0 +1,30 @@
+package com.tzld.piaoquan.recommend.model.produce.util;
+
+import java.text.SimpleDateFormat;
+import java.util.Calendar;
+import java.util.Date;
+
+/**
+ * @author dyp
+ */
+public final class DateUtils {
+    public static String getCurrentDateStr(String format) {
+        SimpleDateFormat dateFormat = new SimpleDateFormat(format);
+        Date currentDate = new Date();
+        return dateFormat.format(currentDate);
+    }
+
+    public static int getCurrentHour() {
+        Calendar calendar = Calendar.getInstance();
+        return calendar.get(Calendar.HOUR_OF_DAY);
+    }
+
+    public static String getBeforeDaysDateStr(String format, int d) {
+        SimpleDateFormat dateFormat = new SimpleDateFormat(format);
+        Calendar calendar = Calendar.getInstance();
+        calendar.setTime(new Date());
+        calendar.add(Calendar.DAY_OF_MONTH, -d);
+        Date previousDate = calendar.getTime();
+        return dateFormat.format(previousDate);
+    }
+}

recommend-model-produce/src/main/java/com/tzld/piaoquan/recommend/model/produce/util/JSONUtils.java

@@ -0,0 +1,39 @@
+package com.tzld.piaoquan.recommend.model.produce.util;
+
+import com.google.common.reflect.TypeToken;
+import com.google.gson.Gson;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.commons.lang3.StringUtils;
+
+import java.io.Serializable;
+
+@Slf4j
+public class JSONUtils implements Serializable {
+
+
+    public static String toJson(Object obj) {
+        if (obj == null) {
+            return "";
+        }
+        try {
+            return new Gson().toJson(obj);
+        } catch (Exception e) {
+            log.error("toJson exception", e);
+            return "";
+        }
+    }
+
+    public static <T> T fromJson(String value, TypeToken<T> typeToken, T defaultValue) {
+
+        if (StringUtils.isBlank(value)) {
+            return defaultValue;
+        }
+        try {
+            return new Gson().fromJson(value, typeToken.getType());
+        } catch (Exception e) {
+            log.error("fromJson error! value=[{}]", value, e);
+        }
+        return defaultValue;
+    }
+
+}

recommend-model-produce/src/main/java/com/tzld/piaoquan/recommend/model/produce/xgboost/XGBoostTrain.java

@@ -0,0 +1,80 @@
+package com.tzld.piaoquan.recommend.model.produce.xgboost;
+
+import com.aliyun.odps.utils.StringUtils;
+import lombok.extern.slf4j.Slf4j;
+import ml.dmlc.xgboost4j.scala.spark.XGBoostClassificationModel;
+import ml.dmlc.xgboost4j.scala.spark.XGBoostClassifier;
+import org.apache.commons.lang.math.NumberUtils;
+import org.apache.spark.api.java.JavaRDD;
+import org.apache.spark.api.java.JavaSparkContext;
+import org.apache.spark.sql.Dataset;
+import org.apache.spark.sql.Row;
+import org.apache.spark.sql.RowFactory;
+import org.apache.spark.sql.SparkSession;
+
+/**
+ * @author dyp
+ */
+@Slf4j
+public class XGBoostTrain {
+    public static void main(String[] args) {
+        try {
+            SparkSession spark = SparkSession.builder()
+                    .appName("XGBoostTrain")
+                    .master("local")
+                    .getOrCreate();
+
+            JavaSparkContext jsc = new JavaSparkContext(spark.sparkContext());
+            String file = "hdfs://dw/recommend/model/33_ad_train_data_v3_checkfeature/20240703/part-00099.gz";
+            JavaRDD<String> rdd = jsc.textFile(file);
+
+            // 将 RDD[LabeledPoint] 转换为 JavaRDD<Row>
+            JavaRDD<Row> rowRDD = rdd.map(s -> {
+                String[] line = StringUtils.split("\t");
+                String label = line[0];
+                double[] values = new double[line.length - 1];
+                for (int i = 1; i < line.length; i++) {
+                    String[] fv = StringUtils.split(":");
+                    values[i - 1] = NumberUtils.toDouble(fv[1], 0.0);
+                }
+                return RowFactory.create(label, values);
+            });
+
+            // 将 JavaRDD<Row> 转换为 Dataset<Row>
+            Dataset<Row> dataset = spark.createDataFrame(rowRDD, Row.class);
+
+            // 如果需要，可以添加列名
+            dataset = dataset.toDF("label", "features");
+
+            // 划分训练集和测试集
+            Dataset<Row>[] splits = dataset.randomSplit(new double[]{0.7, 0.3});
+            Dataset<Row> trainData = splits[0];
+            Dataset<Row> testData = splits[1];
+
+            // 参数
+
+
+            // 创建 XGBoostClassifier 对象
+            XGBoostClassifier xgbClassifier = new XGBoostClassifier()
+                    .setEta(0.1f)
+                    .setFeaturesCol("features")
+                    .setLabelCol("label")
+                    .setMaxDepth(5)
+                    .setObjective("binary:logistic")
+                    .setNthread(4)
+                    .setNumRound(10)
+                    .setNumWorkers(2);
+
+
+            // 训练模型
+            XGBoostClassificationModel model = xgbClassifier.fit(trainData);
+
+            // 显示预测结果
+            Dataset<Row> predictions = model.transform(testData);
+            predictions.select("label", "prediction").show();
+
+        } catch (Exception e) {
+            log.error("", e);
+        }
+    }
+}