随着网络安全威胁的日益增多，用户上传的文件成为了潜在的安全隐患。本文将详细介绍如何在 SpringBoot 应用中集成 ClamAV 防病毒引擎，实现文件上传时的自动病毒扫描，为系统安全保驾护航。

目录

1. 为什么需要文件病毒扫描
2. ClamAV 简介
3. 整体架构设计
4. 核心实现方案
5. ClamAV 服务部署
6. 文件上传与扫描流程
7. 安全增强措施
8. 性能优化
9. 完整代码示例
10. 最佳实践总结

为什么需要文件病毒扫描

安全威胁现状

• 恶意文件上传是 OWASP 十大安全风险之一
• 攻击者通过上传恶意文件获取服务器控制权
• 勒索软件攻击日益增多，文件上传是重要攻击途径
• 合规要求：金融、医疗等行业必须对上传文件进行安全检查

真实案例

• 某教育平台：用户上传含有勒索软件的压缩包，导致服务器被加密勒索
• 某企业内部系统：员工上传带有宏病毒的Excel文件，感染整个内网
• 某云存储服务：用户上传恶意脚本，利用服务器漏洞获取权限

适用场景

ClamAV 简介

什么是 ClamAV

ClamAV 是一个开源的防病毒引擎，专为邮件网关、文件服务器和云服务设计。

核心特性

• 开源免费：Apache 2.0 许可证
• 高性能：多线程扫描，支持大文件
• 广泛的病毒库：每天自动更新
• 支持多种文件格式：压缩文件、文档、可执行文件等
• 轻量级：占用资源少，适合服务器部署
• 多种接口：TCP 端口、Unix 套接字、命令行

支持的文件格式

整体架构设计

系统架构图

flowchart TB
    subgraph 客户端层
        User[用户]
        Browser[浏览器]
        App[移动App]
    end
    
    subgraph 应用服务层
        SpringBoot[SpringBoot应用]
        UploadController[文件上传Controller]
        VirusScanService[病毒扫描服务]
        ClamAVClient[ClamAV客户端]
        FileStorage[文件存储服务]
    end
    
    subgraph 安全服务层
        ClamAV[ClamAV服务<br/>(clamd)]
        Freshclam[病毒库更新服务<br/>(freshclam)]
    end
    
    subgraph 存储层
        LocalStorage[(本地存储)]
        ObjectStorage[(对象存储<br/>S3/OBS)]
        DB[(数据库<br/>扫描记录)]
    end
    
    User --> Browser
    User --> App
    Browser --> UploadController
    App --> UploadController
    UploadController --> VirusScanService
    VirusScanService --> ClamAVClient
    ClamAVClient --> ClamAV
    VirusScanService --> FileStorage
    FileStorage --> LocalStorage
    FileStorage --> ObjectStorage
    VirusScanService --> DB
    ClamAV --> Freshclam

核心工作流程

1. 文件上传：用户通过浏览器或App上传文件
2. 文件接收：SpringBoot 接收文件并暂存
3. 病毒扫描：调用 ClamAV 服务进行扫描
4. 结果处理：
   • 安全文件：存储到正式位置
   • 病毒文件：隔离并记录日志
5. 响应客户端：返回上传结果

部署方案

核心实现方案

1. 依赖配置

<dependencies>
    <!-- Spring Boot Web -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    
    <!-- ClamAV 客户端 -->
    <dependency>
        <groupId>com.github.kaitoy.sneo</groupId>
        <artifactId>clamav-client</artifactId>
        <version>1.0.0</version>
    </dependency>
    
    <!-- Apache Commons IO -->
    <dependency>
        <groupId>commons-io</groupId>
        <artifactId>commons-io</artifactId>
        <version>2.11.0</version>
    </dependency>
    
    <!-- Spring Boot Test -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
</dependencies>

2. ClamAV 客户端配置

@Configuration
public class ClamAVConfig {
    
    @Value("${clamav.host:localhost}")
    private String host;
    
    @Value("${clamav.port:3310}")
    private int port;
    
    @Value("${clamav.timeout:30000}")
    private int timeout;
    
    @Bean
    public ClamAvClient clamAvClient() {
        InetSocketAddress address = new InetSocketAddress(host, port);
        return new ClamAvClient(address, timeout);
    }
}

3. 病毒扫描服务

@Service
@Slf4j
public class VirusScanService {
    
    @Autowired
    private ClamAvClient clamAvClient;
    
    @Autowired
    private VirusScanRecordRepository recordRepository;
    
    /**
     * 扫描文件
     */
    public ScanResult scanFile(MultipartFile file) {
        String fileName = file.getOriginalFilename();
        String userId = SecurityUtils.getCurrentUserId();
        
        try {
            // 1. 读取文件内容
            byte[] fileContent = file.getBytes();
            
            // 2. 调用 ClamAV 扫描
            ClamScanResult result = clamAvClient.scan(fileContent);
            
            // 3. 记录扫描结果
            VirusScanRecord record = VirusScanRecord.builder()
                .fileName(fileName)
                .fileSize(file.getSize())
                .userId(userId)
                .scanTime(LocalDateTime.now())
                .result(result.getStatus().name())
                .virusName(result.getVirusName())
                .build();
            recordRepository.save(record);
            
            // 4. 处理扫描结果
            if (result.getStatus() == ClamScanStatus.VIRUS_FOUND) {
                log.warn("病毒文件检测到: fileName={}, virusName={}, userId={}", 
                    fileName, result.getVirusName(), userId);
                return ScanResult.builder()
                    .safe(false)
                    .virusName(result.getVirusName())
                    .message("文件包含病毒: " + result.getVirusName())
                    .build();
            } else if (result.getStatus() == ClamScanStatus.ERROR) {
                log.error("扫描失败: fileName={}, error={}", fileName, result.getVirusName());
                return ScanResult.builder()
                    .safe(false)
                    .message("扫描失败: " + result.getVirusName())
                    .build();
            } else {
                log.info("文件安全: fileName={}, userId={}", fileName, userId);
                return ScanResult.builder()
                    .safe(true)
                    .message("文件安全")
                    .build();
            }
        } catch (Exception e) {
            log.error("扫描异常: fileName={}, error={}", fileName, e.getMessage(), e);
            return ScanResult.builder()
                .safe(false)
                .message("扫描异常: " + e.getMessage())
                .build();
        }
    }
    
    /**
     * 批量扫描文件
     */
    public List<ScanResult> scanFiles(List<MultipartFile> files) {
        return files.stream()
            .map(this::scanFile)
            .collect(Collectors.toList());
    }
}

@Data
@Builder
public class ScanResult {
    private boolean safe;
    private String virusName;
    private String message;
}

4. 文件上传控制器

@RestController
@RequestMapping("/api/upload")
@Slf4j
public class FileUploadController {
    
    @Autowired
    private VirusScanService virusScanService;
    
    @Autowired
    private FileStorageService fileStorageService;
    
    /**
     * 单个文件上传
     */
    @PostMapping("/single")
    public ResponseEntity<ApiResponse<UploadResult>> uploadFile(
            @RequestParam("file") MultipartFile file) {
        
        // 1. 检查文件大小
        if (file.getSize() > 100 * 1024 * 1024) { // 100MB
            return ResponseEntity.badRequest()
                .body(ApiResponse.error("文件大小超过限制"));
        }
        
        // 2. 检查文件类型
        String contentType = file.getContentType();
        if (!isAllowedContentType(contentType)) {
            return ResponseEntity.badRequest()
                .body(ApiResponse.error("不支持的文件类型"));
        }
        
        // 3. 病毒扫描
        ScanResult scanResult = virusScanService.scanFile(file);
        if (!scanResult.isSafe()) {
            return ResponseEntity.badRequest()
                .body(ApiResponse.error(scanResult.getMessage()));
        }
        
        // 4. 存储文件
        String fileUrl = fileStorageService.storeFile(file);
        
        return ResponseEntity.ok(ApiResponse.success(UploadResult.builder()
            .fileName(file.getOriginalFilename())
            .fileSize(file.getSize())
            .fileUrl(fileUrl)
            .message("上传成功")
            .build()));
    }
    
    /**
     * 多文件上传
     */
    @PostMapping("/multiple")
    public ResponseEntity<ApiResponse<List<UploadResult>>> uploadFiles(
            @RequestParam("files") MultipartFile[] files) {
        
        List<UploadResult> results = new ArrayList<>();
        
        for (MultipartFile file : files) {
            try {
                // 检查文件大小
                if (file.getSize() > 50 * 1024 * 1024) { // 50MB
                    results.add(UploadResult.builder()
                        .fileName(file.getOriginalFilename())
                        .error("文件大小超过限制")
                        .build());
                    continue;
                }
                
                // 检查文件类型
                if (!isAllowedContentType(file.getContentType())) {
                    results.add(UploadResult.builder()
                        .fileName(file.getOriginalFilename())
                        .error("不支持的文件类型")
                        .build());
                    continue;
                }
                
                // 病毒扫描
                ScanResult scanResult = virusScanService.scanFile(file);
                if (!scanResult.isSafe()) {
                    results.add(UploadResult.builder()
                        .fileName(file.getOriginalFilename())
                        .error(scanResult.getMessage())
                        .build());
                    continue;
                }
                
                // 存储文件
                String fileUrl = fileStorageService.storeFile(file);
                results.add(UploadResult.builder()
                    .fileName(file.getOriginalFilename())
                    .fileSize(file.getSize())
                    .fileUrl(fileUrl)
                    .message("上传成功")
                    .build());
                    
            } catch (Exception e) {
                log.error("文件处理失败: {}", file.getOriginalFilename(), e);
                results.add(UploadResult.builder()
                    .fileName(file.getOriginalFilename())
                    .error("处理失败: " + e.getMessage())
                    .build());
            }
        }
        
        return ResponseEntity.ok(ApiResponse.success(results));
    }
    
    /**
     * 检查是否允许的文件类型
     */
    private boolean isAllowedContentType(String contentType) {
        Set<String> allowedTypes = Set.of(
            "image/jpeg", "image/png", "image/gif",
            "application/pdf", "application/msword",
            "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
            "application/vnd.ms-excel",
            "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
            "application/zip", "application/x-rar-compressed",
            "text/plain", "application/json"
        );
        return allowedTypes.contains(contentType);
    }
}

ClamAV 服务部署

1. Docker 部署（推荐）

# docker-compose.yml
version: '3.8'
services:
  clamav:
    image: clamav/clamav:latest
    ports:
      - "3310:3310"
    volumes:
      - clamav-data:/var/lib/clamav
    environment:
      - CLAMD_CONF_MaxScanSize=100M
      - CLAMD_CONF_MaxFileSize=100M
      - CLAMD_CONF_StreamMaxLength=100M
    restart: always

volumes:
  clamav-data:

启动服务：

docker-compose up -d

2. 本地部署

Ubuntu/Debian

# 安装 ClamAV
sudo apt update
sudo apt install clamav clamav-daemon

# 停止服务并更新病毒库
sudo systemctl stop clamav-freshclam
sudo freshclam

# 启动服务
sudo systemctl start clamav-daemon

# 查看状态
sudo systemctl status clamav-daemon

CentOS/RHEL

# 安装 ClamAV
sudo yum install epel-release
sudo yum install clamav clamd

# 更新病毒库
sudo freshclam

# 启动服务
sudo systemctl start clamd

# 查看状态
sudo systemctl status clamd

3. 配置文件

/etc/clamav/clamd.conf

# 监听地址
TCPSocket 3310
TCPAddr 0.0.0.0

# 扫描配置
MaxScanSize 100M
MaxFileSize 100M
StreamMaxLength 100M

# 性能优化
MaxThreads 10
ReadTimeout 30

# 日志
LogFile /var/log/clamav/clamd.log
LogTime yes

文件上传与扫描流程

详细流程图

sequenceDiagram
    participant U as 用户
    participant C as 客户端
    participant S as SpringBoot
    participant V as 病毒扫描服务
    participant CL as ClamAV
    participant FS as 文件存储
    participant DB as 数据库
    
    U->>C: 选择文件
    C->>S: 上传文件
    S->>S: 检查文件大小和类型
    S->>V: 调用病毒扫描
    V->>CL: 发送文件内容
    CL->>CL: 病毒库匹配
    CL-->>V: 返回扫描结果
    V->>DB: 记录扫描记录
    
    alt 安全文件
        V-->>S: 安全
        S->>FS: 存储文件
        FS-->>S: 返回文件URL
        S-->>C: 上传成功
        C-->>U: 显示成功消息
    else 病毒文件
        V-->>S: 包含病毒
        S-->>C: 上传失败（病毒检测）
        C-->>U: 显示病毒警告
    else 扫描失败
        V-->>S: 扫描异常
        S-->>C: 上传失败（扫描错误）
        C-->>U: 显示错误消息
    end

扫描结果处理

错误处理策略

1. ClamAV 服务不可用：

   • 临时降级：记录日志，允许上传但标记为「未扫描」
   • 或拒绝上传：返回服务暂时不可用

2. 扫描超时：

   • 大文件：增加超时时间或异步处理
   • 频繁超时：检查 ClamAV 性能

3. 病毒库过期：

   • 监控病毒库更新状态
   • 超过7天未更新时告警

安全增强措施

1. 文件类型验证

/**
 * 双重文件类型验证
 */
private boolean validateFileType(MultipartFile file) {
    // 1. MIME类型验证
    String contentType = file.getContentType();
    if (!allowedMimeTypes.contains(contentType)) {
        return false;
    }
    
    // 2. 文件扩展名验证
    String fileName = file.getOriginalFilename();
    String extension = FilenameUtils.getExtension(fileName).toLowerCase();
    if (!allowedExtensions.contains(extension)) {
        return false;
    }
    
    // 3. 文件头验证（Magic Number）
    try {
        byte[] header = new byte[8];
        file.getInputStream().read(header);
        String fileSignature = bytesToHex(header);
        return allowedSignatures.stream()
            .anyMatch(signature -> fileSignature.startsWith(signature));
    } catch (Exception e) {
        return false;
    }
}

2. 文件内容限制

/**
 * 限制文件内容
 */
private void validateFileContent(MultipartFile file) {
    // 1. 压缩文件深度限制
    if (isArchiveFile(file)) {
        int depth = getArchiveDepth(file);
        if (depth > 5) {
            throw new FileValidationException("压缩文件层级过深");
        }
    }
    
    // 2. 可执行文件检测
    if (isExecutableFile(file)) {
        throw new FileValidationException("不允许上传可执行文件");
    }
    
    // 3. 脚本文件检测
    if (isScriptFile(file)) {
        throw new FileValidationException("不允许上传脚本文件");
    }
}

3. 防止 DOS 攻击

/**
 * 限流保护
 */
@Bean
public RateLimiter uploadRateLimiter() {
    // 每用户每分钟最多10次上传
    return RateLimiter.create(10.0);
}

@PostMapping("/single")
public ResponseEntity<ApiResponse<UploadResult>> uploadFile(
        @RequestParam("file") MultipartFile file) {
    
    // 限流检查
    if (!uploadRateLimiter.tryAcquire(500, TimeUnit.MILLISECONDS)) {
        return ResponseEntity.status(HttpStatus.TOO_MANY_REQUESTS)
            .body(ApiResponse.error("上传过于频繁，请稍后再试"));
    }
    
    // 后续处理...
}

4. 审计日志

@Aspect
@Component
@Slf4j
public class FileUploadAuditAspect {
    
    @Autowired
    private AuditLogRepository auditLogRepository;
    
    @Around("@annotation(org.springframework.web.bind.annotation.PostMapping) && args(file, ..)")
    public Object aroundUpload(ProceedingJoinPoint point, MultipartFile file) throws Throwable {
        String userId = SecurityUtils.getCurrentUserId();
        String fileName = file.getOriginalFilename();
        long fileSize = file.getSize();
        
        AuditLog log = AuditLog.builder()
            .userId(userId)
            .operationType("FILE_UPLOAD")
            .resourceType("FILE")
            .resourceName(fileName)
            .resourceSize(fileSize)
            .operationTime(LocalDateTime.now())
            .status(OperationStatus.PENDING)
            .build();
        
        auditLogRepository.save(log);
        
        try {
            Object result = point.proceed();
            log.setStatus(OperationStatus.SUCCESS);
            log.setResultSummary("上传成功");
            auditLogRepository.save(log);
            return result;
        } catch (Exception e) {
            log.setStatus(OperationStatus.FAILED);
            log.setErrorMessage(e.getMessage());
            auditLogRepository.save(log);
            throw e;
        }
    }
}

性能优化

1. 异步扫描

@Service
public class AsyncVirusScanService {
    
    @Autowired
    private VirusScanService virusScanService;
    
    @Autowired
    private FileStorageService fileStorageService;
    
    @Async
    public CompletableFuture<ScanResult> scanFileAsync(MultipartFile file) {
        return CompletableFuture.completedFuture(virusScanService.scanFile(file));
    }
    
    @Async
    public void processFileAsync(MultipartFile file, Consumer<UploadResult> callback) {
        try {
            // 1. 病毒扫描
            ScanResult scanResult = virusScanService.scanFile(file);
            
            if (scanResult.isSafe()) {
                // 2. 存储文件
                String fileUrl = fileStorageService.storeFile(file);
                
                UploadResult result = UploadResult.builder()
                    .fileName(file.getOriginalFilename())
                    .fileSize(file.getSize())
                    .fileUrl(fileUrl)
                    .message("上传成功")
                    .build();
                
                callback.accept(result);
            } else {
                UploadResult result = UploadResult.builder()
                    .fileName(file.getOriginalFilename())
                    .error(scanResult.getMessage())
                    .build();
                callback.accept(result);
            }
        } catch (Exception e) {
            UploadResult result = UploadResult.builder()
                .fileName(file.getOriginalFilename())
                .error("处理失败: " + e.getMessage())
                .build();
            callback.accept(result);
        }
    }
}

2. 缓存优化

@Configuration
public class CacheConfig {
    
    @Bean
    public CacheManager cacheManager(RedisConnectionFactory factory) {
        RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()
            .entryTtl(Duration.ofMinutes(30))
            .prefixCacheNameWith("virus-scan:");
        
        return RedisCacheManager.builder(factory)
            .withCacheConfiguration("scan-results", config)
            .build();
    }
}

@Service
public class CachedVirusScanService {
    
    @Autowired
    private VirusScanService virusScanService;
    
    @Cacheable(value = "scan-results", key = "#file.getOriginalFilename() + '-' + #file.getSize()")
    public ScanResult scanFileWithCache(MultipartFile file) {
        return virusScanService.scanFile(file);
    }
}

3. ClamAV 性能调优

4. 批量处理

/**
 * 批量扫描优化
 */
private List<ScanResult> batchScanFiles(List<MultipartFile> files) {
    // 1. 按文件大小分组
    Map<Boolean, List<MultipartFile>> groupedFiles = files.stream()
        .collect(Collectors.partitioningBy(f -> f.getSize() > 10 * 1024 * 1024));
    
    List<ScanResult> results = new ArrayList<>();
    
    // 2. 小文件并行扫描
    List<CompletableFuture<ScanResult>> smallFileFutures = groupedFiles.get(false).stream()
        .map(file -> CompletableFuture.supplyAsync(() -> virusScanService.scanFile(file)))
        .collect(Collectors.toList());
    
    // 3. 大文件顺序扫描（避免内存问题）
    for (MultipartFile largeFile : groupedFiles.get(true)) {
        results.add(virusScanService.scanFile(largeFile));
    }
    
    // 4. 收集小文件扫描结果
    for (CompletableFuture<ScanResult> future : smallFileFutures) {
        try {
            results.add(future.get(60, TimeUnit.SECONDS));
        } catch (Exception e) {
            results.add(ScanResult.builder()
                .safe(false)
                .message("扫描超时")
                .build());
        }
    }
    
    return results;
}

完整代码示例

1. 项目结构

springboot-clamav-demo/
├── src/
│   ├── main/
│   │   ├── java/com/example/clamav/
│   │   │   ├── ClamAVApplication.java          # 启动类
│   │   │   ├── config/
│   │   │   │   ├── ClamAVConfig.java           # ClamAV配置
│   │   │   │   └── SecurityConfig.java          # 安全配置
│   │   │   ├── controller/
│   │   │   │   └── FileUploadController.java    # 文件上传控制器
│   │   │   ├── entity/
│   │   │   │   ├── VirusScanRecord.java         # 扫描记录
│   │   │   │   └── AuditLog.java                # 审计日志
│   │   │   ├── repository/
│   │   │   │   ├── VirusScanRecordRepository.java
│   │   │   │   └── AuditLogRepository.java
│   │   │   ├── service/
│   │   │   │   ├── VirusScanService.java        # 病毒扫描服务
│   │   │   │   ├── FileStorageService.java      # 文件存储服务
│   │   │   │   └── AsyncVirusScanService.java   # 异步扫描服务
│   │   │   ├── aspect/
│   │   │   │   └── FileUploadAuditAspect.java   # 审计切面
│   │   │   ├── exception/
│   │   │   │   └── FileValidationException.java # 文件验证异常
│   │   │   └── utils/
│   │   │       ├── SecurityUtils.java            # 安全工具
│   │   │       └── FileUtils.java               # 文件工具
│   │   └── resources/
│   │       ├── application.yml                  # 配置文件
│   │       └── banner.txt                       # 启动横幅
│   └── test/
│       └── java/com/example/clamav/
│           └── VirusScanServiceTest.java        # 单元测试
├── docker/
│   ├── docker-compose.yml                       # Docker配置
│   └── Dockerfile                               # 应用Dockerfile
├── pom.xml                                      # Maven配置
└── README.md                                    # 项目说明

2. ClamAV 客户端封装

@Service
public class ClamAVClientService {
    
    private final ClamAvClient client;
    
    public ClamAVClientService(@Value("${clamav.host:localhost}") String host,
                             @Value("${clamav.port:3310}") int port,
                             @Value("${clamav.timeout:30000}") int timeout) {
        InetSocketAddress address = new InetSocketAddress(host, port);
        this.client = new ClamAvClient(address, timeout);
    }
    
    /**
     * 扫描文件内容
     */
    public ClamScanResult scan(byte[] content) throws IOException {
        return client.scan(content);
    }
    
    /**
     * 扫描文件流
     */
    public ClamScanResult scan(InputStream inputStream) throws IOException {
        byte[] content = IOUtils.toByteArray(inputStream);
        return scan(content);
    }
    
    /**
     * 检查 ClamAV 服务状态
     */
    public boolean ping() {
        try {
            client.ping();
            return true;
        } catch (Exception e) {
            return false;
        }
    }
    
    /**
     * 获取 ClamAV 版本
     */
    public String getVersion() {
        try {
            return client.version();
        } catch (Exception e) {
            return "Unknown";
        }
    }
}

3. 文件存储服务

@Service
public class FileStorageService {
    
    @Value("${file.storage.path:/tmp/uploads}")
    private String storagePath;
    
    @Value("${file.storage.base-url:http://localhost:8080/files}")
    private String baseUrl;
    
    @PostConstruct
    public void init() {
        File directory = new File(storagePath);
        if (!directory.exists()) {
            directory.mkdirs();
        }
    }
    
    /**
     * 存储文件
     */
    public String storeFile(MultipartFile file) {
        try {
            // 生成唯一文件名
            String originalFileName = file.getOriginalFilename();
            String fileExtension = FilenameUtils.getExtension(originalFileName);
            String fileName = UUID.randomUUID().toString() + "." + fileExtension;
            
            // 创建存储目录
            String subDir = LocalDate.now().format(DateTimeFormatter.ofPattern("yyyy/MM/dd"));
            File dir = new File(storagePath + File.separator + subDir);
            if (!dir.exists()) {
                dir.mkdirs();
            }
            
            // 保存文件
            File dest = new File(dir, fileName);
            file.transferTo(dest);
            
            // 返回访问URL
            return baseUrl + "/" + subDir + "/" + fileName;
        } catch (Exception e) {
            throw new RuntimeException("文件存储失败", e);
        }
    }
    
    /**
     * 删除文件
     */
    public void deleteFile(String filePath) {
        File file = new File(storagePath + File.separator + filePath);
        if (file.exists()) {
            file.delete();
        }
    }
}

4. 健康检查

@RestController
@RequestMapping("/health")
public class HealthController {
    
    @Autowired
    private ClamAVClientService clamAVClientService;
    
    @GetMapping("/clamav")
    public ResponseEntity<Map<String, Object>> checkClamAV() {
        Map<String, Object> status = new HashMap<>();
        
        try {
            boolean pingResult = clamAVClientService.ping();
            String version = clamAVClientService.getVersion();
            
            status.put("status", pingResult ? "UP" : "DOWN");
            status.put("version", version);
            status.put("timestamp", LocalDateTime.now().toString());
            
            return ResponseEntity.ok(status);
        } catch (Exception e) {
            status.put("status", "DOWN");
            status.put("error", e.getMessage());
            status.put("timestamp", LocalDateTime.now().toString());
            
            return ResponseEntity.status(HttpStatus.SERVICE_UNAVAILABLE).body(status);
        }
    }
}

最佳实践总结

1. 安全配置

2. 部署建议

• 生产环境：使用独立的 ClamAV 服务，多实例部署
• 测试环境：使用 Docker 容器快速部署
• 高并发场景：增加 ClamAV 实例，使用负载均衡
• 存储方案：生产环境使用对象存储（S3/OBS）

3. 监控与告警

• 监控指标：

  • 扫描成功率
  • 平均扫描时间
  • 病毒检测数量
  • ClamAV 服务状态
  • 病毒库更新状态

• 告警机制：

  • ClamAV 服务不可用
  • 病毒库超过7天未更新
  • 扫描失败率超过10%
  • 检测到病毒文件

4. 故障处理

5. 性能优化

• 异步扫描：大文件使用异步处理
• 缓存机制：缓存相同文件的扫描结果
• 批量处理：小文件并行扫描
• ClamAV 调优：根据硬件资源调整参数
• 连接池：使用连接池管理 ClamAV 连接

小结

本文详细介绍了在 SpringBoot 应用中集成 ClamAV 实现文件病毒扫描的完整方案，通过这套方案，可以有效防止恶意文件上传，保障系统安全，满足合规要求。

互动话题

1. 你在项目中是否遇到过文件上传安全问题？如何解决的？
2. 除了 ClamAV，你还使用过哪些文件安全扫描工具？
3. 在高并发场景下，如何平衡文件扫描的安全性和性能？
4. 对于大文件上传，你有什么优化建议？