腾讯云内容安全实现文本内容安全

        登录腾讯云账号后，进入安全服务：服务体验 - 内容安全 - 控制台，将服务全都开通。之后进入应用管理创建应用（文本内容安全简介_文本内容安全购买指南_文本内容安全操作指南-腾讯云）。应用创建完成后创建secretKey和secretId(访问密钥 - 控制台)。准备工作就做好了。

代码直接就直接给了，

1.pom依赖

<!--腾讯云-->
<dependency>
    <groupId>com.tencentcloudapi</groupId>
    <artifactId>tencentcloud-sdk-java-cvm</artifactId>
    <version>3.1.528</version>
</dependency>

<dependency>
<groupId>com.tencentcloudapi</groupId>
<artifactId>tencentcloud-sdk-java-tms</artifactId>
<version>3.1.528</version>
</dependency>

<dependency>
    <groupId>com.tencentcloudapi</groupId>
    <artifactId>tencentcloud-sdk-java-ims</artifactId>
    <version>3.1.528</version>
</dependency>

<dependency>
    <groupId>com.tencentcloudapi</groupId>
    <artifactId>tencentcloud-sdk-java</artifactId>
    <version>3.1.714</version> <!-- 使用最新版本，参考腾讯云官方文档 -->
</dependency>

2.配置文件

secretId和secretKey替换成自己的

tencentcloud.secretId=  AKID******457ygCV
tencentcloud.secretKey= csADQQdw3*******
tencentcloud.region=ap-guangzhou

3.controller层

import com.tencentcloudapi.cms.v20190321.models.TextData;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.multipart.MultipartFile;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

@RestController
public class ContentModerationController {
    @Autowired
    private ContentModerationService moderationService;

    @PostMapping("/moderate/text")
    public ResponseEntity<ApiResponse> moderateText(
            @RequestParam String content,
            @RequestParam(required = false,defaultValue = "") String bizType) {
        try {
            // 将空字符串转为 null
            String finalBizType = bizType.isEmpty() ? null : bizType;

            TextData response = moderationService.checkText(content, finalBizType);
            // 将原始响应转换为前端需要的结构化数据
            Map<String, Object> result = new HashMap<>();

            // 1. 处理建议类型（Suggestion）
            String suggestion = response.getSuggestion();
            result.put("suggestion", convertSuggestion(suggestion)); // "Review" -> "建议人工审核"

            // 2. 处理违规类型（EvilType）
            int evilType = Math.toIntExact(response.getEvilType());
            result.put("evilType", convertEvilType(evilType)); // 20006 -> "违法/毒品"

            // 3. 关键词和置信度
            result.put("keywords", response.getKeywords()); // ["海洛因"]
            result.put("score", response.getScore() + "%"); // 74 -> "74%"
            return ResponseEntity.ok(ApiResponse.success(result));
        } catch (Exception e) {
            e.printStackTrace();  // 打印堆栈信息
            return ResponseEntity.badRequest().body(ApiResponse.error(e.getMessage()));
        }
    }

    // 建议类型转换
    private String convertSuggestion(String suggestion) {
        switch (suggestion) {
            case "Block": return "建议拦截";
            case "Review": return "建议人工审核";
            case "Pass": return "建议通过";
            default: return "未知建议";
        }
    }

    // 违规类型转换（需根据腾讯云文档完善映射）
    private String convertEvilType(int evilType) {
        switch (evilType) {
            case 20006: return "违法/毒品";
            case 20001: return "暴恐/政治/敏感机构";
            case 100   : return "无";
            case 24001 :return "暴恐/恐怖事件";
            // 其他类型...
            default: return "其他类型";
        }
    }

}

4.实体层

@Data
@Getter
@Setter

public class ApiResponse<T> {
    private int code;
    private String message;
    private T data;

    // 构造方法、Getter、Setter省略，以下是静态工厂方法
    public static <T> ApiResponse<T> success(T data) {
        ApiResponse<T> response = new ApiResponse<>();
        response.setCode(200);
        response.setMessage("success");
        response.setData(data);
        return response;
    }

    public static <T> ApiResponse<T> error(String message) {
        ApiResponse<T> response = new ApiResponse<>();
        response.setCode(400);
        response.setMessage(message);
        return response;
    }
}

5.配置层

import com.tencentcloudapi.cms.v20190321.CmsClient;
import com.tencentcloudapi.common.Credential;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration

public class TencentClogConfig {
    @Value("${tencentcloud.secret-id}")
    private String secretId;

    @Value("${tencentcloud.secret-key}")
    private String secretKey;

    @Value("${tencentcloud.region}")
    private String region;


    @Bean
    public CmsClient cmsClient() {
        Credential cred = new Credential(secretId, secretKey);
        return new CmsClient(cred,region);
    }
}

6.服务层

import com.tencentcloudapi.cms.v20190321.CmsClient;
import com.tencentcloudapi.cms.v20190321.models.TextData;
import com.tencentcloudapi.cms.v20190321.models.TextModerationRequest;
import com.tencentcloudapi.cms.v20190321.models.TextModerationResponse;
import com.tencentcloudapi.common.exception.TencentCloudSDKException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.web.multipart.MultipartFile;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.nio.charset.StandardCharsets;
import java.util.*;

@Service
public class ContentModerationService {
    @Autowired
    private CmsClient cmsClient;

    public TextData checkText(String content, String bizType) throws TencentCloudSDKException {
        // 对 content 进行 Base64 编码
        String encodedContent = Base64.getEncoder().encodeToString(content.getBytes(StandardCharsets.UTF_8));

        TextModerationRequest req = new TextModerationRequest();
        req.setContent(encodedContent); // 设置 Base64 编码后的 content
        if (bizType != null && !bizType.isEmpty()) {
            req.setBizType(Long.valueOf(bizType));
        }
        TextModerationResponse resp = cmsClient.TextModeration(req);
//        System.out.println("Data响应: " + TextModerationResponse.toJsonString(resp.getData())); // 关键日
        return resp.getData();
    }
}

测试页面：

<!DOCTYPE html>
<html lang="zh-CN">
<head>
    <meta charset="UTF-8">
    <title>腾讯云内容安全测试页面</title>
    <style>
        body { font-family: Arial, sans-serif; padding: 20px; max-width: 800px; margin: 0 auto; }
        .form-group { margin-bottom: 15px; }
        label { display: block; margin-bottom: 5px; }
        textarea { width: 100%; height: 150px; padding: 8px; }
        button { padding: 10px 20px; background: #007bff; color: white; border: none; cursor: pointer; }
        button:hover { background: #0056b3; }
        #result { margin-top: 20px; padding: 15px; border: 1px solid #ddd; }
    </style>
</head>
<body>
<h2>文本内容安全检测</h2>

<div class="form-group">
    <label for="content">待检测文本：</label>
    <textarea id="content" placeholder="请输入文本内容..."></textarea>
</div>

<div class="form-group">
    <label for="bizType">策略ID（可选）：</label>
    <input type="text" id="bizType" placeholder="输入自定义策略ID">
</div>

<button onclick="checkContent()">开始检测</button>
<div id="result">
    <div class="section">
        <h3>审核结果</h3>
        <div class="result-item">
            <label>建议处理：</label>
            <span class="suggestion-tag" id="suggestion"></span>
        </div>
        <div class="result-item">
            <label>违规类型：</label>
            <span id="evilType"></span>
        </div>
        <div class="result-item">
            <label>命中关键词：</label>
            <span id="keywords"></span>
        </div>
        <div class="result-item">
            <label>置信度：</label>
            <span id="score"></span>
        </div>
    </div>
</div>

<style>
    .suggestion-tag {
        padding: 4px 8px;
        border-radius: 4px;
        font-weight: bold;
    }
    .suggestion-tag[data-type="建议拦截"] { background: #ffcccc; color: #d33; }
    .suggestion-tag[data-type="建议人工审核"] { background: #ffe6cc; color: #f90; }
    .suggestion-tag[data-type="建议通过"] { background: #ccffcc; color: #090; }
</style>


<script>
    function checkContent() {
        const content = document.getElementById('content').value;
        const bizType = document.getElementById('bizType').value;
        const resultDiv = document.getElementById('result');

        if (!content) {
            resultDiv.innerHTML = '<p style="color: red;">请输入待检测文本！</p>';
            return;
        }

        // 修改前端逻辑：如果 bizType 为空，则不传递该参数
        const params = { 'content': content };
        if (bizType) {  // 仅在 bizType 非空时添加
            params.bizType = bizType;
        }

        fetch('/moderate/text', {
            method: 'POST',
            headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
            body: new URLSearchParams(params)
        }).then(response => response.json())
            .then(data => {
                if (data.code === 200) {
                    const result = data.data;

                    // 动态填充结果
                    document.getElementById('suggestion').innerHTML =
                        `<span class="suggestion-tag" data-type="${result.suggestion}">${result.suggestion}</span>`;
                    document.getElementById('evilType').textContent = result.evilType;
                    document.getElementById('keywords').textContent =
                        result.keywords.length > 0 ? result.keywords.join(', ') : '无';
                    document.getElementById('score').textContent = result.score;
                } });
    }
</script>
</body>
</html>

以上就是实现文本内容安全的所需依赖和代码，更多需求可查看官方文档。