基于Spring AI+MySQL实现文件内容相似度的简单检测

<!-- Apache Tika 核心功能 -->
<dependency>
    <groupId>org.apache.tika</groupId>
    <artifactId>tika-core</artifactId>
    <version>2.9.2</version>
</dependency>

<!-- Apache Tika 标准解析器包，支持多种文件格式（PDF、Word、Excel、PPT 等） -->
<dependency>
    <groupId>org.apache.tika</groupId>
    <artifactId>tika-parsers-standard-package</artifactId>
    <version>2.9.2</version>
</dependency>

/**
* 上传文件，抽取可读文本内容
*/
@PostMapping(value = "/{textId}/upload", consumes = MediaType.MULTIPART_FORM_DATA_VALUE)
    public UploadResp uploadAndVectorize(@PathVariable Long textId, @RequestPart("file") MultipartFile file) throws Exception {
        String mime = file.getContentType();
        String name = file.getOriginalFilename();
        // 通过 Tika 抽取文本
        String content = tika.parseToString(file.getInputStream());
        // ...
}

// 规范化并按句末标点分句：将句末标点后插入换行，再按空行切分
String[] raw = text.replace('\r', '\n') // 换行符
    .replaceAll("[。！？!?]", "$0\n") // 在句末标点后插入换行，保留原标点
    .split("\n+"); // 按连续换行分割

输入: "这是第一句。这是第二句！这是第三句？"
代码处理后: ["这是第一句。", "这是第二句！", "这是第三句？"]

// 清洗：去空白、移除空串
List<String> cleaned = Arrays.stream(raw)
    .map(String::trim)
    .filter(s -> !s.isEmpty())
    .collect(Collectors.toList());

List<String> result = new ArrayList<>();
        StringBuilder buf = new StringBuilder();
        for (String s : cleaned) {
            // 聚合段：控制单段最大到 300 字，超过则先输出缓冲区
            if (buf.length() + s.length() > 300) {
                if (buf.length() > 0) {
                    result.add(buf.toString());
                    buf.setLength(0);
                }
            }
            // 超长句子：按 500 字硬切，保证不会出现过长片段
            if (s.length() > 500) {
                for (int i = 0; i < s.length(); i += 500) {
                    result.add(s.substring(i, Math.min(s.length(), i + 500)));
                }
            } else {
                if (buf.length() > 0) buf.append('\n');
                buf.append(s);
            }
        }

<!-- SpringAI DashScope -->
<dependency>
    <groupId>com.alibaba.cloud.ai</groupId>
    <artifactId>spring-ai-alibaba-starter-dashscope</artifactId>
    <version>1.0.0.4</version>
</dependency>

  ai:
    dashscope:
      api-key: your-api-key
      embedding:
        options:
          model: text-embedding-v2

private final EmbeddingModel embeddingModel;

private final TextSegmenter textSegmenter;

// ...

List<String> segments = textSegmenter.segment(fullText);
if (segments.isEmpty()) return 0;

// 计算嵌入向量
float[] vectorArray = embeddingModel.embed(seg); 

// 向量序列化与存储
String segmentId = segmentIdGenerator.idFor(seg);
String content = seg;
if (content != null && content.length() > 500) content = content.substring(0, 500);
DocumentVector dv = new DocumentVector();
dv.setTextId(textId);
dv.setSegmentId(segmentId);
dv.setContent(content);
dv.setEmbeddingVector(vectorCodec.serialize(vectorArray));

private final ObjectMapper objectMapper;

// ...

@Override
public String serialize(float[] vector) {
    try {
        // 以 JSON 数组形式持久化
        return objectMapper.writeValueAsString(vector);
    } catch (Exception e) {
        throw new IllegalStateException("序列化嵌入向量失败", e);
    }
}

// 反序列化向量，构建便于计算的数据结构
Map<String, double[]> segVec = new HashMap<>();
for (var s : segments) {
    segVec.put(s.getSegmentId(), vectorCodec.deserialize(s.getEmbeddingVector()));
}
Map<DocumentVector, double[]> corpusMap = new HashMap<>();
for (var c : corpus) {
    corpusMap.put(c, vectorCodec.deserialize(c.getEmbeddingVector()));
}

public double[] deserialize(String json) {
    //...
    try {
         // 直接反序列化为 double[]，配合后续相似度计算的双精度实现
        double[] arr = objectMapper.readValue(json, double[].class);
        return arr == null ? new double[0] : arr;
            } catch (Exception e) {
                throw new IllegalArgumentException("反序列化嵌入向量失败", e);
        }
}

/**
 * 余弦相似度计算工具
 */
public class CosineSimilarityUtils {

    /**
     * 计算两个向量的余弦相似度
     *
     * @param a 向量A
     * @param b 向量B
     * @return 余弦相似度 [-1, 1]
     */
    public static double cosine(double[] a, double[] b) {
        // 参数为空/维度不一致直接返回0
        if (a == null || b == null || a.length == 0 || b.length == 0 || a.length != b.length) return 0.0;
        double dot = 0.0;
        double na = 0.0;
        double nb = 0.0;
        // 累计点积与各自范数平方
        for (int i = 0; i < a.length; i++) {
            dot += a[i] * b[i];
            na += a[i] * a[i];
            nb += b[i] * b[i];
        }
        // 任一向量为零向量：相似度定义为0，避免除零
        if (na == 0.0 || nb == 0.0) return 0.0;
        return dot / (Math.sqrt(na) * Math.sqrt(nb));
    }
}

/**
 * 相似度度量接口
 * 定义两向量之间的相似度计算方式
 */
public interface SimilarityMetric {

    /**
     * 计算两个同维度向量的相似度值。
     * @param a 向量A
     * @param b 向量B
     * @return 相似度（数值越大越相似）
     */
    double similarity(double[] a, double[] b);
}

PriorityQueue<Map.Entry<T, Double>> heap = new PriorityQueue<>(Map.Entry.comparingByValue());

for (Map.Entry<T, double[]> e : corpus.entrySet()) {
    double[] v = e.getValue();
    // 维度不一致直接跳过
    if (v == null || v.length != query.length) continue;
    double sim = metric.similarity(query, v); // 使用余弦相似度
    // ...
 }

if (heap.size() < k) {
        // 未满K，直接入堆
        heap.offer(Map.entry(e.getKey(), sim));
    } else if (heap.peek().getValue() < sim) {
        // 比堆顶大：弹出最小，再加入
        heap.poll();
        heap.offer(Map.entry(e.getKey(), sim));
}

// 结果按相似度降序输出
List<Map.Entry<T, Double>> top = new ArrayList<>(heap);
top.sort((a, b) -> Double.compare(b.getValue(), a.getValue()));
return top;

for (var s : segments) {
    double[] v = segVec.get(s.getSegmentId());
    if (v == null || v.length == 0) continue;
    // 使用 TopK 检索策略 + 相似度度量，获取最相近候选
    List<Map.Entry<DocumentVector, Double>> top = topKSearcher.topK(v, corpusMap, k, similarityMetric);
}

public SimilarityReportDTO computeSimilarityReport(Long textId, Integer topK, Double threshold) {
    // TopK 合法化：限制在 [1, 20]，默认为 5
    int k = topK == null ? 5 : Math.max(1, Math.min(20, topK));
    // 阈值夹取：限制在 [0.5, 0.99]，默认为 0.90
    double tau = threshold == null ? 0.90 : Math.max(0.5, Math.min(0.99, threshold));
    // ...
}    

// segments：当前文本（textId）的所有片段向量
List<DocumentVector> segments = documentVectorMapper.selectByTextId(textId);
if (segments == null || segments.isEmpty()) {
    throw new RuntimeException("该文本尚未向量化");
}
// corpus：排除当前文本后的其他文档片段
List<DocumentVector> corpus = documentVectorMapper.selectCorpusForSimilarity(textId);
if (corpus == null || corpus.isEmpty()) {
    throw new RuntimeException("对比语料为空");
}

<select id="selectCorpusForSimilarity" parameterType="long" resultMap="DocumentVectorMap">
    SELECT * FROM document_vector
    WHERE text_id != #{excludeTextId}
    LIMIT 2000
</select>

int highSimCount = 0;
double sumTopSim = 0.0;

for (var s : segments) {
    double[] v = segVec.get(s.getSegmentId());
    if (v == null || v.length == 0) continue;

    List<Map.Entry<DocumentVector, Double>> top = topKSearcher.topK(v, corpusMap, k, similarityMetric);
    if (top.isEmpty()) continue;

    double bestSim = top.get(0).getValue(); // 取 Top1 相似度
    sumTopSim += bestSim;
    if (bestSim >= tau) highSimCount++;
}

double coverage = segments.isEmpty() ? 0 : (double) highSimCount / segments.size(); // 达阈值片段占比
double avgTopSim = segments.isEmpty() ? 0 : (sumTopSim / segments.size());          // 平均最高相似度
double overall = 100.0 * (0.6 * coverage + 0.4 * avgTopSim);                       // 加权综合评分
String risk = overall >= 70 ? "HIGH" : (overall >= 40 ? "MEDIUM" : "LOW");         // 风险等级判定

SimilarityReportDTO report = new SimilarityReportDTO();
report.setTextId(textId);
report.setCoverage(coverage);
report.setAvgTopSim(avgTopSim);
report.setOverallScore(Math.round(overall * 10.0) / 10.0); // 保留一位小数
report.setRiskLevel(risk);
report.setGeneratedAt(LocalDateTime.now());
return report;