Util和utils

大数据驱动AI

于 2024-05-26 12:38:32 发布

阅读量338

点赞数 2

分类专栏： # 0后端Springboot-A级文章标签： java

本文链接：https://blog.csdn.net/qq_45972323/article/details/139213222

版权

0后端Springboot-A级专栏收录该内容

17 篇文章 0 订阅

订阅专栏

Util

FieldStats

这段代码定义了一个名为`FieldStats`的Java类，位于`com.cqupt.software_1.Util`包中。它使用了`lombok`库的`@Data`和`@AllArgsConstructor`注解，这些注解帮助生成了`getter`、`setter`、`toString`等方法，以及包含所有参数的构造函数。

类中有三个字段：
- `missingRate`：表示缺失率。
- `mean`：表示平均值。
- `variance`：表示方差。

构造函数接受这三个字段作为参数，并将它们赋值给对应的字段。这个类主要用于存储字段的统计信息，例如在数据分析中计算每个字段的缺失率、平均值和方差等统计数据。

package com.cqupt.software_1.Util;

import lombok.AllArgsConstructor;
import lombok.Data;

@Data
@AllArgsConstructor
public class FieldStats {

    private double missingRate;
    private double mean;
    private double variance;
}

ImportXlsxToMysql

这段代码是一个Java程序，它用于将Excel文件（.xlsx格式）中的数据导入到MySQL数据库中。让我详细介绍一下：

1. `ImportXlsxToMysql` 类包含了 `main` 方法，是程序的入口点。它主要负责读取Excel文件中的数据，并将数据插入到MySQL数据库中。

2. 在 `main` 方法中，首先定义了一些变量，如 `xlsxFilePath` 存储了Excel文件的路径，`dbUrl` 存储了数据库的URL，`username` 和 `password` 分别是数据库的用户名和密码，`tableName` 是要插入数据的表名。

3. 在 `try-with-resources` 语句中，打开文件输入流 `fileInputStream`，并使用 `WorkbookFactory.create(fileInputStream)` 创建一个 Workbook 对象，用于处理 Excel 文件。然后，通过 `DriverManager.getConnection` 方法建立数据库连接。

4. 通过 `workbook.getSheetAt(0)` 获取Excel文件的第一个工作表，并通过 `sheet.getRow(0)` 获取表头行，从中获取列数。

5. 构建 SQL 插入语句。通过遍历表头行的每一列，获取列名，并构建插入语句的列部分。然后通过遍历列数，构建插入语句的值部分，同时使用占位符 '?'。

6. 执行插入操作。通过准备好的 SQL 插入语句创建 `PreparedStatement` 对象，然后遍历 Excel 文件的每一行，设置参数值，并执行插入操作。

7. `getCellValueAsString` 方法用于将单元格的值以字符串的形式返回。它接受一个 `Cell` 对象作为参数，首先检查单元格的类型，然后将其值转换为相应类型的字符串，并返回。

8. 最后，在 `catch` 块中捕获可能出现的异常，例如 `IOException` 和 `SQLException`，并打印异常信息。

这个程序的功能是将 Excel 文件中的数据导入到 MySQL 数据库中的指定表中，它支持包含不同数据类型的单元格值，并能处理空单元格。

package com.cqupt.software_1.Util;

import org.apache.poi.ss.usermodel.*;

import java.io.FileInputStream;
import java.io.IOException;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.SQLException;

public class ImportXlsxToMysql {
    public static void main(String[] args) {
        String xlsxFilePath = "C:\\Users\\hp\\Desktop\\example.xlsx";
        String dbUrl = "jdbc:mysql://10.16.48.219:3306/result_save";
        String username = "root";
        String password = "111111";
        String tableName = "";

        try (FileInputStream fileInputStream = new FileInputStream(xlsxFilePath);
             Workbook workbook = WorkbookFactory.create(fileInputStream);
             Connection connection = DriverManager.getConnection(dbUrl, username, password)) {

            Sheet sheet = workbook.getSheetAt(0);

            // 获取表头行
            Row headerRow = sheet.getRow(0);
            int columnCount = headerRow.getLastCellNum();

            // 构建 SQL 插入语句
            StringBuilder sqlBuilder = new StringBuilder();
            sqlBuilder.append("INSERT INTO ").append(tableName).append(" (");
            for (int i = 0; i < columnCount; i++) {
                String columnName = getCellValueAsString(headerRow.getCell(i));
                sqlBuilder.append(columnName);
                if (i < columnCount - 1) {
                    sqlBuilder.append(", ");
                }
            }
            sqlBuilder.append(") VALUES (");
            for (int i = 0; i < columnCount; i++) {
                sqlBuilder.append("?");
                if (i < columnCount - 1) {
                    sqlBuilder.append(", ");
                }
            }
            sqlBuilder.append(")");

            String insertSql = sqlBuilder.toString();

            // 准备插入语句
            try (PreparedStatement statement = connection.prepareStatement(insertSql)) {
                // 遍历行
                for (int rowIndex = 1; rowIndex <= sheet.getLastRowNum(); rowIndex++) {
                    Row row = sheet.getRow(rowIndex);

                    // 设置参数值
                    for (int columnIndex = 0; columnIndex < columnCount; columnIndex++) {
                        Cell cell = row.getCell(columnIndex);
                        String cellValue = getCellValueAsString(cell);
                        statement.setString(columnIndex + 1, cellValue);
                    }

                    // 执行插入操作
                    statement.executeUpdate();
                }
            }

            System.out.println("Data imported successfully!");

        } catch (IOException | SQLException e) {
            e.printStackTrace();
        }
    }

    private static String getCellValueAsString(Cell cell) {
        if (cell == null) {
            return "";
        }

        CellType cellType = cell.getCellType();
        String cellValue;

        if (cellType == CellType.STRING) {
            cellValue = cell.getStringCellValue();
        } else if (cellType == CellType.NUMERIC) {
            cellValue = String.valueOf(cell.getNumericCellValue());
        } else if (cellType == CellType.BOOLEAN) {
            cellValue = String.valueOf(cell.getBooleanCellValue());
        } else if (cellType == CellType.FORMULA) {
            cellValue = cell.getCellFormula();
        } else {
            cellValue = "";
        }

        return cellValue;
    }
}

SecurityUtil

这段代码定义了一个名为`SecurityUtil`的Java类，它包含了一个静态方法`hashDataSHA256`，用于对输入的字符串数据使用SHA-256算法进行哈希加密。

`hashDataSHA256`方法接受一个`String`类型的参数`data`，这是需要被加密的原始数据。方法内部首先尝试获取SHA-256算法的实例，如果获取失败（例如，因为Java环境不支持该算法），则通过`NoSuchAlgorithmException`异常处理。

如果算法实例成功获取，方法将原始数据转换为字节数组，并使用`MessageDigest`的`digest`方法对其进行加密。`digest`方法返回一个字节数组，该数组包含了SHA-256算法加密后的结果。

接下来，方法将加密后的字节数组转换为十六进制的字符串表示形式。它使用`StringBuilder`类来构建这个十六进制字符串，并通过`String.format`方法将每个字节转换为两个字符的十六进制形式。

最后，方法返回生成的十六进制字符串，该字符串代表了原始数据的SHA-256哈希值。如果发生异常，方法将打印堆栈跟踪信息并返回`null`。

`SecurityUtil`类可以被其他Java程序调用，以便对数据进行SHA-256加密。这通常用于密码加密、数据完整性校验等安全相关的应用场景。

package com.cqupt.software_1.Util;

import java.nio.charset.StandardCharsets;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;

public class SecurityUtil {


    /**
     *
     *  SHA-256  加密对密码
     * @param data
     * @return
     */

    public static String hashDataSHA256(String data) {
        try {
            MessageDigest md = MessageDigest.getInstance("SHA-256");
            byte[] hashInBytes = md.digest(data.getBytes(StandardCharsets.UTF_8));

            // Convert the byte array to a hexadecimal string
            StringBuilder sb = new StringBuilder();
            for (byte b : hashInBytes) {
                sb.append(String.format("%02x", b));
            }

            return sb.toString();
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
            return null;
        }
    }
}

utils

HTTPUtils

这段代码定义了一个名为 `HTTPUtils` 的 Java 类，它包含了一个静态方法 `postRequest`，用于向指定的 HTTP 服务器发送 POST 请求，并返回服务器响应的 JSON 数据。
`postRequest` 方法接受两个参数，第一个参数是要发送的数据对象 `paramData`，第二个参数是请求路径 `path`。
方法首先构建了一个 URI 对象，表示请求的完整路径，这个路径由 `rootPath` 和传入的 `path` 拼接而成。
然后，创建了一个 `HttpPost` 对象，用于执行 POST 请求，同时创建了一个 `HttpClient` 对象来执行 HTTP 请求。
接下来，使用 `ObjectMapper` 对象将传入的 `paramData` 对象转换为 JSON 格式的字符串 `jsonData`。在转换过程中，允许非数值字符的存在，这一特性通过 `objectMapper.configure(JsonParser.Feature.ALLOW_NON_NUMERIC_NUMBERS, true)` 实现。
接着，将 JSON 数据设置到请求的实体中，同时设置请求体的编码为 UTF-8。
设置请求头部为 `application/json; charset=UTF-8`，指明请求体的类型和编码格式。
执行 HTTP 请求，得到服务器的响应对象 `response`，然后将响应实体中的数据转换为字符串 `responseData`。
最后，使用 `ObjectMapper` 将响应数据字符串转换为 JSON 对象 `JsonNode`，并返回该对象。
这个 `HTTPUtils` 类提供了一个方便的工具方法，可以用于在 Java 程序中向指定的 HTTP 服务器发送 POST 请求，并获取服务器返回的 JSON 数据。

package com.cqupt.software_1.utils;

import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.apache.http.HttpHeaders;
import org.apache.http.HttpResponse;
import org.apache.http.client.HttpClient;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.util.EntityUtils;
import java.io.IOException;
import java.net.URI;
import java.net.URISyntaxException;
import java.nio.charset.StandardCharsets;

public class HTTPUtils {
    public static final String rootPath = "http://localhost:5000/";
    public static JsonNode postRequest(Object paramData, String path) throws URISyntaxException, IOException {
        URI uri = new URI(rootPath+path);
        // 创建http POST
        HttpPost httpPost = new HttpPost(uri);
        HttpClient httpClient = HttpClients.createDefault();

        ObjectMapper objectMapper = new ObjectMapper();
        objectMapper.configure(JsonParser.Feature.ALLOW_NON_NUMERIC_NUMBERS, true);
        String jsonData = objectMapper.writeValueAsString(paramData);

//        httpPost.setHeader(HttpHeaders.CONTENT_TYPE,"application/json");
//        httpPost.setEntity(new StringEntity(jsonData)); // 设置请求体
        // 设置请求体编码为 UTF-8
        StringEntity entity = new StringEntity(jsonData, StandardCharsets.UTF_8);
        httpPost.setEntity(entity);
        httpPost.setHeader(HttpHeaders.CONTENT_TYPE, "application/json; charset=UTF-8"); // 设置请求头部


        // 执行请求
        HttpResponse response = httpClient.execute(httpPost);
        String responseData = EntityUtils.toString(response.getEntity());

        JsonNode jsonNode = objectMapper.readValue(responseData, JsonNode.class);
        return jsonNode;
    }
}