百度ai之鉴黄接口

注册官网并开通内容审核平台

官网注册

百度ai的官网如下：https://cloud.baidu.com/

完成个人认证

注意一定要进行个人认证否则接口调用会报错

在控制台搜索内容审核

开通内容审核

选择配置

配置策略

百度AI内容审核平台的核心是提供一套全面、精准、可定制的内容审核服务。其“审核策略”是用户在使用该平台时，根据自身业务需求所制定的一套规则和标准的集合，用于告诉系统：“我需要审核什么内容？” 以及 “什么样的内容算违规？”

• 图像

• 文本

• 短视频

• 长视频

• 音频审核

查看文档

根据以下地址下载所需工具类

https://ai.baidu.com/file/658A35ABAB2D404FBF903F64D47C1F72
https://ai.baidu.com/file/C8D81F3301E24D2892968F09AE1AD6E2
https://ai.baidu.com/file/470B3ACCA3FE43788B5A963BF0B625F3

okhttpsUtils

package com.hz.identify.utils;

import okhttp3.*;
import org.springframework.stereotype.Component;
import java.io.IOException;
import java.util.concurrent.TimeUnit;

/**
 * OkHttp 工具类
 */
@Component
public class OkHttpUtil {

    private static final MediaType FORM_URLENCODED = MediaType.parse("application/x-www-form-urlencoded");

    private final OkHttpClient client;

    public OkHttpUtil() {
        // 配置 OkHttpClient
        this.client = new OkHttpClient.Builder()
                .connectTimeout(10, TimeUnit.SECONDS)
                .readTimeout(30, TimeUnit.SECONDS)
                .writeTimeout(30, TimeUnit.SECONDS)
                .build();
    }
    /**
     * POST 请求
     */
    public String post(String url, String accessToken, String param) throws IOException {
        // 构建完整的 URL（包含 access_token）
        String fullUrl = url + "?access_token=" + accessToken;
        // 构建请求体
        RequestBody body = RequestBody.create(param, FORM_URLENCODED);

        // 构建请求
        Request request = new Request.Builder()
                .url(fullUrl)
                .post(body)
                .addHeader("Content-Type", "application/x-www-form-urlencoded")
                .addHeader("Connection", "Keep-Alive")
                .build();

        // 执行请求
        long startTime = System.currentTimeMillis();

        try (Response response = client.newCall(request).execute()) {
            long endTime = System.currentTimeMillis();
            Headers headers = response.headers();
            for (int i = 0; i < headers.size(); i++) {
                System.out.println(headers.name(i) + "--->" + headers.value(i));
            }
            if (!response.isSuccessful()) {
                String errorMsg = "HTTP " + response.code() + " - " + response.message();
                System.err.println("请求失败: " + errorMsg);
                throw new IOException("Unexpected code: " + response.code() + ", message: " + response.message());
            }
            ResponseBody responseBody = response.body();
            if (responseBody == null) {
                System.err.println("错误: 响应体为空");
                throw new IOException("Response body is null");
            }
            String result = responseBody.string();
            // 打印返回结果
            System.out.println("\n=== 百度AI返回结果 ===");
            System.out.println(result);
            return result;
        }
    }
    public OkHttpClient getClient() {
        return client;
    }
}

获得accessToken

post请求:https://aip.baidubce.com/oauth/2.0/token

输入参数grant_type，client_id，client_secret

• grant_type： 必须参数，固定为client_credentials；
• client_id： 必须参数，应用的API Key；
• client_secret： 必须参数，应用的Secret Key；

创建SpringBoot项目

导入jar包

<!--okhttp -->
<dependency>
    <groupId>com.squareup.okhttp3</groupId>
    <artifactId>okhttp</artifactId>
    <version>4.12.0</version>
</dependency>
<!-- 添加百度AI Java SDK -->
<dependency>
    <groupId>com.baidu.aip</groupId>
    <artifactId>java-sdk</artifactId>
    <version>4.16.14</version>
    <exclusions>
        <exclusion>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-simple</artifactId>
        </exclusion>
    </exclusions>
</dependency>

导入工具类

包括刚下载的3个工具类+OkHttpUtil

ApiResult类：统一响应格式

@Data
@AllArgsConstructor
@NoArgsConstructor
public class ApiResult {
    private Integer code;        // 状态码
    private String message;      // 返回消息
    private Boolean success;     // 是否成功
    private Object data;         // 返回数据
    // 成功静态方法
    public static ApiResult success(String message) {
        return new ApiResult(200, message, true, null);
    }

    public static ApiResult success(String message, Object data) {
        return new ApiResult(200, message, true, data);
    }

    // 失败静态方法
    public static ApiResult error(String message) {
        return new ApiResult(500, message, false, null);
    }

    public static ApiResult error(Integer code, String message) {
        return new ApiResult(code, message, false, null);
    }

    // 审核专用方法
    public static ApiResult censorSuccess(Object data) {
        return new ApiResult(200, "审核通过", true, data);
    }

    public static ApiResult censorError(String message) {
        return new ApiResult(400, message, false, null);
    }

    /**
     * 创建图片审核结果
     */
    public static ApiResult createImageCensorResult(Map<String, Object> resultMap) {
        String conclusion = (String) resultMap.getOrDefault("conclusion", "未知");

        if ("合规".equals(conclusion)) {
            return ApiResult.censorSuccess(resultMap);
        } else {
            return ApiResult.censorError("图片内容违规");
        }
    }

    /**
     * 创建文本审核结果
     */
    public static ApiResult createTextCensorResult(Map<String, Object> resultMap) {
        String conclusion = (String) resultMap.getOrDefault("conclusion", "未知");

        if ("合规".equals(conclusion)) {
            return ApiResult.censorSuccess(resultMap);
        } else {
            return ApiResult.censorError("文本内容违规");
        }
    }
}

yml配置文件

server:
  port: 8080
# 百度AI配置
baidu:
  ai:
    api-key: 
    secret-key: 
    access-token: 
    img-censor-url: 

配置类

用于管理和映射application.yml中的百度AI相关配置

配置集中管理：所有百度AI相关的配置都在一个地方

依赖注入：@Autowired 可以直接注入整个配置对象

类型安全：Spring Boot 会验证配置是否正确

@Data
@Component
@ConfigurationProperties(prefix = "baidu.ai")
public class BaiduAiConfig {
    private String apiKey;
    private String secretKey;
    private String accessToken;
    private String imgCensorUrl ;
    private String textCensorUrl ;
}

文字审核

TextRequest实体类

@Data
public class TextRequest {
    /**
     * 待审核的文本内容
     */
    private String text;

}

service层

public interface TextCensorService {

    /**
     * 文字内容审核
     * @param text 待审核文本
     * @return 审核结果
     */
    ApiResult censorText(String text);

}

service实现

@Service 
public class TextCensorServiceImpl implements TextCensorService {

    // JSON序列化/反序列化工具
    private final ObjectMapper objectMapper = new ObjectMapper();

    // 百度AI配置类，包含API密钥、URL等配置信息
    @Autowired
    private BaiduAiConfig baiduAiConfig;

    // HTTP请求工具类，封装了OkHttp客户端的操作
    @Autowired
    private OkHttpUtil okHttpUtil;

    /**
     * 文本内容审核方法
     * 调用百度AI内容审核API，检测文本中的违规内容
     *
     * @param text 待审核的文本内容
     * @return ApiResult 包含审核结果的统一响应对象
     * 成功：返回审核状态、违规类型、置信度等信息
     * 失败：返回错误信息和错误码
     */
    @Override  // 实现接口中的方法
    public ApiResult censorText(String text) {
        try {
            // ==================== 参数验证阶段 ====================

            // 验证文本是否为空或空字符串
            if (text == null || text.trim().isEmpty()) {
                // 返回参数错误响应
                return ApiResult.error("待审核文本不能为空");
            }

            // 验证文本长度是否超过限制（百度API限制为20000字符）
            if (text.length() > 20000) {
                // 返回文本超长错误响应
                return ApiResult.error("文本长度不能超过20000个字符");
            }

            // ==================== 请求准备阶段 ====================

            // 对文本进行URL编码，确保特殊字符不会破坏URL格式
            // 注意：百度API要求参数名为"text"
            String param = "text=" + URLEncoder.encode(text, "UTF-8");

            // 获取百度AI的访问令牌（Access Token）
            // Access Token需要通过API Key和Secret Key获取，有效期通常为30天
            String accessToken = getAccessToken();

            // ==================== API调用阶段 ====================

            // 使用OkHttp工具发送POST请求到百度AI文本审核接口
            // 参数说明：
            // - baiduAiConfig.getTextCensorUrl(): 百度文本审核API地址
            // - accessToken: 访问令牌，用于身份验证
            // - param: URL编码后的文本参数
            String resultJson = okHttpUtil.post(
                    baiduAiConfig.getTextCensorUrl(),  // API端点URL
                    accessToken,                        // 认证令牌
                    param                               // 请求参数
            );

            // ==================== 结果解析阶段 ====================

            // 将百度API返回的JSON字符串解析为Map对象
            // TypeReference用于指定泛型类型，确保正确解析嵌套的JSON结构
            Map<String, Object> resultMap = objectMapper.readValue(
                    resultJson,  // 百度API返回的原始JSON
                    new TypeReference<Map<String, Object>>() {
                    }  // 目标类型引用
            );

            // ==================== 结果封装阶段 ====================

            // 使用ApiResult的工具方法将百度API结果转换为统一的响应格式
            // 该方法会提取审核结论、置信度、违规类型等关键信息
            return ApiResult.createTextCensorResult(resultMap);

        } catch (Exception e) {
            // ==================== 异常处理阶段 ====================

            // 捕获并处理所有可能的异常，包括：
            // - 网络异常（连接超时、请求失败等）
            // - JSON解析异常
            // - 编码异常
            // - 参数验证异常
            // - 百度API返回的错误
            // 返回统一的错误响应，避免暴露系统内部细节
            return ApiResult.error("文字审核失败: " + e.getMessage());
        }
    }

    /**
     * 获取百度AI访问令牌
     * Access Token是调用百度AI服务API的凭证
     *
     * @return String 有效的访问令牌
     * @throws RuntimeException 当Access Token为空或无效时抛出异常
     * @implNote 该方法从配置类中获取预先生成的Access Token
     * 实际项目中，Access Token可能需要动态获取和刷新
     * 百度AI的Access Token通常通过以下方式获取：
     * 1. 使用API Key和Secret Key调用OAuth接口获取
     * 2. Access Token有效期通常为30天
     * 3. 需要定期刷新或重新获取
     */
    private String getAccessToken() {
        // 从配置类中获取Access Token
        String accessToken = baiduAiConfig.getAccessToken();

        // 验证Access Token是否有效
        if (accessToken == null || accessToken.isEmpty()) {
            // 抛出运行时异常，表示系统配置错误
            // 在实际项目中，可以考虑：
            // 1. 自动重新获取Access Token
            // 2. 发送告警通知管理员
            // 3. 降级处理或使用备用审核服务
            throw new RuntimeException("Access Token为空，请检查百度AI配置");
        }
        // 返回有效的Access Token
        return accessToken;
    }
}

controller

@RestController
@RequestMapping("/censor")
public class TextCensorController {
    @Autowired
    private TextCensorService textCensorService;
    /**
     * 单条文字审核
     */
    @PostMapping("/single")
    public ApiResult censorText(@RequestParam String text) {
        try {
            if (text == null || text.trim().isEmpty()) {
                return ApiResult.error("待审核文本不能为空");
            }
            // 限制文本长度（百度AI限制为20000字符）
            if (text.length() > 20000) {
                return ApiResult.error("文本长度不能超过20000个字符");
            }
            ApiResult result = textCensorService.censorText(text);
            return result;
        } catch (Exception e) {
            return ApiResult.error("文字审核失败: " + e.getMessage());
        }
    }

    /**
     * JSON格式文字审核
     */
    @PostMapping("/json")
    public ResponseEntity<ApiResult> censorTextJson(@RequestBody TextRequest textRequest) {
        try {
            if (textRequest == null || textRequest.getText() == null || textRequest.getText().trim().isEmpty()) {
                return ResponseEntity.ok(ApiResult.error("待审核文本不能为空"));
            }
            // 限制文本长度（百度AI限制为20000字符）
            if (textRequest.getText().length() > 20000) {
                return ResponseEntity.ok(ApiResult.error("文本长度不能超过20000个字符"));
            }
            ApiResult result = textCensorService.censorText(textRequest.getText());
            return ResponseEntity.ok(result);
        } catch (Exception e) {
            return ResponseEntity.ok(ApiResult.error("JSON文字审核失败: " + e.getMessage()));
        }
    }
}

图片审核

service层

public interface ImageCensorService {

    /**
     * 图片内容审核
     * @param imagePath 图片路径
     * @return 审核结果
     */
    public ApiResult censorImage(String imagePath);

    /**
     * 图片内容审核 (Base64)
     * @param imageBase64 图片Base64编码
     * @return 审核结果
     */
    public ApiResult censorImageByBase64(String imageBase64) ;

    /**
     * 图片内容审核 (MultipartFile)
     * @param file 图片文件
     * @return 审核结果
     */
    public ApiResult censorImageByFile(MultipartFile file) ;
}

service实现

@Service
public class ImageCensorServiceImpl implements ImageCensorService {

    @Autowired
    private BaiduAiConfig baiduAiConfig;

    @Autowired
    private OkHttpUtil okHttpUtil;

    private ObjectMapper objectMapper = new ObjectMapper();

    @Override
    public ApiResult censorImage(String imagePath) {
        try {
            return censorImageByBase64(Base64Util.encode(FileUtil.readFileByBytes(imagePath)));
        } catch (Exception e) {
            throw new RuntimeException("图片审核失败: " + e.getMessage());
        }
    }

    @Override
    public ApiResult censorImageByBase64(String imageBase64) {
        try {
            // 构建请求参数
            String param = "image=" + URLEncoder.encode(imageBase64, "UTF-8");

            // 使用 OkHttp 发送请求
            String resultJson = okHttpUtil.post(
                    baiduAiConfig.getImgCensorUrl(),
                    getAccessToken(),
                    param
            );

            // 解析结果
            Map<String, Object> resultMap = objectMapper.readValue(
                    resultJson,
                    new TypeReference<Map<String, Object>>() {}
            );

            return ApiResult.createImageCensorResult(resultMap);
        } catch (Exception e) {
            throw new RuntimeException("图片审核失败: " + e.getMessage());
        }
    }

    @Override
    public ApiResult censorImageByFile(MultipartFile file) {
        try {
            return censorImageByBase64(Base64Util.encode(file.getBytes()));
        } catch (Exception e) {
            throw new RuntimeException("图片文件审核失败: " + e.getMessage());
        }
    }

    /**
     * 获取访问令牌
     */
    private String getAccessToken() {
        String accessToken = baiduAiConfig.getAccessToken();
        if (accessToken == null || accessToken.isEmpty()) {
            throw new RuntimeException("Access Token为空，请检查百度AI配置");
        }
        return accessToken;
    }
}

controller

@RestController
@RequestMapping("/censor")
public class ImageCensorController {
    @Autowired
    private  ImageCensorService imageCensorService;
    /**
     * 通过文件路径审核图片
     */
    @PostMapping("/by-path")
    public ApiResult censorByPath(@RequestParam String imagePath) {
        try {
            ApiResult result = imageCensorService.censorImage(imagePath);
            return result;
        } catch (Exception e) {
            return ApiResult.error("图片审核失败: " + e.getMessage());
        }
    }
    /**
     * 上传图片文件进行审核
     */
    @PostMapping("/upload")
    public ApiResult censorByUpload(@RequestParam("file") MultipartFile file) {
        try {
            if (file.isEmpty()) {
                return ApiResult.error("请选择要上传的图片文件");
            }

            String contentType = file.getContentType();
            if (contentType == null || !contentType.startsWith("image/")) {
                return ApiResult.error("请上传图片文件");
            }

            ApiResult  result = imageCensorService.censorImageByFile(file);
            return ApiResult.success(result.toString());
        } catch (Exception e) {
            return ApiResult.error("图片上传审核失败: " + e.getMessage());
        }
    }
}