在互联网大厂后端开发的日常工作中，你是否常常被这些问题困扰？使用 Spring Boot 构建文件存储服务时，文件上传速度慢得让人抓狂，下载时又频繁出现路径错误，不同环境下的存储适配更是令人头秃。好不容易搭建好的文件存储服务，在高并发场景下直接 “罢工”，导致线上业务受到影响，不仅要加班排查问题，还得面对领导的质问，这种经历相信不少后端开发人员都深有体会。

背景介绍

随着互联网业务的不断发展，文件存储需求日益增长。在互联网大厂中，用户上传的图片、视频，系统产生的日志文件等，都需要可靠的文件存储服务来支撑。Spring Boot 凭借其快速开发、简化配置等优势，成为了后端开发人员构建文件存储服务的热门选择。然而，在实际开发过程中，由于业务场景复杂、技术选型多样等原因，开发人员在使用 Spring Boot 构建通用文件存储服务时，会遇到各种各样的问题。比如，不同的存储介质（本地磁盘、云存储等）有着不同的操作方式和 API，如何实现统一的调用接口；在分布式环境下，如何保证文件存储的一致性和可用性；文件的安全性也是不容忽视的问题，如何防止文件被非法访问和篡改等等。

搭建基础框架

首先，创建一个 Spring Boot 项目。在 pom.xml 文件中引入必要的依赖，Spring Web 必不可少，它用于处理 HTTP 请求，为文件上传下载等操作提供接口支持。对于文件存储相关依赖，如果采用本地存储，commons - io 工具类库能极大方便文件操作，它提供了丰富的文件处理方法，如文件复制、移动、删除等。若对接云存储，像阿里云 OSS、腾讯云 COS 等，则需引入对应的 SDK 。以阿里云 OSS 为例，引入 aliyun - oss - java - sdk 依赖后，就能使用其提供的 API 与阿里云的存储服务进行交互。

在配置文件中，设置文件存储的基础路径。在 application.yml 里添加如下配置：

file:
  storage - path: /data/files

这一配置指定了文件在本地存储的根目录，后续上传的文件都会存放在这个路径下。若使用云存储，此处则需配置云存储的相关参数，如访问密钥、存储桶名称、地域等。

创建文件存储服务接口 FileStorageService，定义文件上传、下载、删除等核心方法：

public interface FileStorageService {
    String uploadFile(MultipartFile file);
    byte[] downloadFile(String fileName);
    boolean deleteFile(String fileName);
}

这个接口为后续实现文件存储的具体逻辑提供了规范，不同存储方式的实现类都需实现这些方法，保证对外提供统一的服务调用接口。

实现文件上传功能

在 FileStorageService 的实现类 FileStorageServiceImpl 中，实现文件上传方法。以本地存储为例：

@Service
public class FileStorageServiceImpl implements FileStorageService {
    private final String storagePath;
    @Value("${file.storage - path}")
    public FileStorageServiceImpl(String storagePath) {
        this.storagePath = storagePath;
    }
    @Override
    public String uploadFile(MultipartFile file) {
        try {
            // 生成唯一文件名，防止文件覆盖
            String fileName = UUID.randomUUID().toString() + "_" + file.getOriginalFilename();
            Path targetLocation = Paths.get(storagePath, fileName);
            // 将文件内容写入目标路径
            Files.copy(file.getInputStream(), targetLocation, StandardCopyOption.REPLACE_EXISTING);
            return fileName;
        } catch (IOException e) {
            throw new RuntimeException("文件上传失败", e);
        }
    }
    // 下载、删除方法类似实现
}

上述代码中，通过 UUID.randomUUID().toString() 生成唯一标识符，再拼接上原始文件名，确保在同一目录下文件名的唯一性。利用 Files.copy 方法将文件输入流写入指定路径。若上传过程出现 IOException，则抛出运行时异常提示文件上传失败。

对于云存储，实现逻辑有所不同。以腾讯云 COS 为例，首先在配置文件中配置好 COS 的相关信息，如：

cos:
  secretId: your - secret - id
  secretKey: your - secret - key
  region: your - region
  bucket: your - bucket - name

在实现类中，通过注入配置信息，使用腾讯云 COS 的 SDK 进行文件上传：

@Service
public class CosFileStorageServiceImpl implements FileStorageService {
    private final String secretId;
    private final String secretKey;
    private final String region;
    private final String bucket;
    @Value("${cos.secretId}")
    public void setSecretId(String secretId) {
        this.secretId = secretId;
    }
    @Value("${cos.secretKey}")
    public void setSecretKey(String secretKey) {
        this.secretKey = secretKey;
    }
    @Value("${cos.region}")
    public void setRegion(String region) {
        this.region = region;
    }
    @Value("${cos.bucket}")
    public void setBucket(String bucket) {
        this.bucket = bucket;
    }
    @Override
    public String uploadFile(MultipartFile file) {
        try {
            COSClient cosClient = new COSClient(new BasicCOSCredentials(secretId, secretKey), new ClientConfig(new Region(region)));
            String fileName = UUID.randomUUID().toString() + "_" + file.getOriginalFilename();
            PutObjectRequest putObjectRequest = new PutObjectRequest(bucket, fileName, file.getInputStream(), new ObjectMetadata());
            cosClient.putObject(putObjectRequest);
            cosClient.shutdown();
            return fileName;
        } catch (IOException e) {
            throw new RuntimeException("文件上传失败", e);
        }
    }
    // 下载、删除等方法类似实现
}

这里使用腾讯云 COS 的 SDK 创建 COSClient 实例，根据配置信息进行文件上传操作，操作完成后关闭 COSClient 释放资源。

处理高并发与分布式场景

引入分布式文件系统

引入分布式文件系统，如 FastDFS、MinIO 等，可有效解决高并发场景下的性能问题。以 MinIO 为例，它支持分布式部署，能将多个节点组成集群，共同提供存储服务。在集群环境中，数据分片分布在不同服务器，实现冗余备份与负载均衡，提升数据可用性与容错能力，还具备强大的可扩展性，可按需添加服务器。

在 Spring Boot 项目中集成 MinIO，首先在 pom.xml 中添加依赖：

<dependency>
    <groupId>io.minio</groupId>
    <artifactId>minio</artifactId>
    <version>8.4.1</version>
</dependency>

在配置文件 application.yml 中配置 MinIO 连接信息：

minio:
  endpoint: http://your - minio - endpoint:9000
  accessKey: your - access - key
  secretKey: your - secret - key
  bucketName: your - bucket - name

创建 MinIO 工具类，封装文件上传、下载等操作方法：

import io.minio.*;
import io.minio.http.Method;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
import java.io.InputStream;
import java.util.concurrent.TimeUnit;
@Component
public class MinioUtil {
    private final String endpoint;
    private final String accessKey;
    private final String secretKey;
    private final String bucketName;
    @Value("${minio.endpoint}")
    public void setEndpoint(String endpoint) {
        this.endpoint = endpoint;
    }
    @Value("${minio.accessKey}")
    public void setAccessKey(String accessKey) {
        this.accessKey = accessKey;
    }
    @Value("${minio.secretKey}")
    public void setSecretKey(String secretKey) {
        this.secretKey = secretKey;
    }
    @Value("${minio.bucketName}")
    public void setBucketName(String bucketName) {
        this.bucketName = bucketName;
    }
    public MinioClient getMinioClient() {
        return MinioClient.builder()
               .endpoint(endpoint)
               .credentials(accessKey, secretKey)
               .build();
    }
    public void uploadFile(InputStream inputStream, String objectName) throws Exception {
        MinioClient minioClient = getMinioClient();
        minioClient.putObject(PutObjectArgs.builder()
               .bucket(bucketName)
               .object(objectName)
               .stream(inputStream, inputStream.available(), -1)
               .build());
    }
    public InputStream downloadFile(String objectName) throws Exception {
        MinioClient minioClient = getMinioClient();
        return minioClient.getObject(GetObjectArgs.builder()
               .bucket(bucketName)
               .object(objectName)
               .build());
    }
    public String getPresignedUrl(String objectName, int expiry) throws Exception {
        MinioClient minioClient = getMinioClient();
        return minioClient.getPresignedObjectUrl(GetPresignedObjectUrlArgs.builder()
               .method(Method.GET)
               .bucket(bucketName)
               .object(objectName)
               .expiry(expiry, TimeUnit.SECONDS)
               .build());
    }
}

通过上述配置与工具类，在业务代码中就能方便地使用 MinIO 进行文件存储操作，应对高并发场景下的文件读写需求。

使用分布式锁

使用分布式锁，如基于 Redis 的分布式锁，保证文件操作的原子性。例如在多个服务同时上传同名文件时，通过分布式锁避免文件覆盖问题。在 Spring Boot 项目中集成 Redis 分布式锁，首先引入 Redis 依赖：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring - boot - starter - data - redis</artifactId>
</dependency>

创建 Redis 分布式锁工具类：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;
import java.util.concurrent.TimeUnit;
@Component
public class RedisLockUtil {
    private static final String LOCK_PREFIX = "file_upload_lock:";
    @Autowired
    private StringRedisTemplate stringRedisTemplate;
    public boolean tryLock(String key, long timeout, TimeUnit unit) {
        String lockKey = LOCK_PREFIX + key;
        long expireTime = System.currentTimeMillis() + unit.toMillis(timeout);
        boolean success = stringRedisTemplate.opsForValue().setIfAbsent(lockKey, String.valueOf(expireTime));
        if (success) {
            return true;
        } else {
            String currentValue = stringRedisTemplate.opsForValue().get(lockKey);
            if (currentValue != null && Long.parseLong(currentValue) < System.currentTimeMillis()) {
                String oldValue = stringRedisTemplate.opsForValue().getAndSet(lockKey, String.valueOf(expireTime));
                return oldValue != null && oldValue.equals(currentValue);
            }
        }
        return false;
    }
    public void unlock(String key) {
        String lockKey = LOCK_PREFIX + key;
        stringRedisTemplate.delete(lockKey);
    }
}

在文件上传方法中使用分布式锁：

@Service
public class FileStorageServiceImpl implements FileStorageService {
    @Autowired
    private RedisLockUtil redisLockUtil;
    @Override
    public String uploadFile(MultipartFile file) {
        String fileName = file.getOriginalFilename();
        boolean locked = redisLockUtil.tryLock(fileName, 10, TimeUnit.SECONDS);
        if (locked) {
            try {
                // 文件上传逻辑
                String uuidFileName = UUID.randomUUID().toString() + "_" + fileName;
                Path targetLocation = Paths.get(storagePath, uuidFileName);
                Files.copy(file.getInputStream(), targetLocation, StandardCopyOption.REPLACE_EXISTING);
                return uuidFileName;
            } catch (IOException e) {
                throw new RuntimeException("文件上传失败", e);
            } finally {
                redisLockUtil.unlock(fileName);
            }
        } else {
            throw new RuntimeException("获取锁失败，无法上传文件");
        }
    }
    // 其他方法
}

这样，在高并发场景下，通过分布式锁确保同一时间只有一个服务能对特定文件进行操作，保证数据一致性。

保障文件安全性

文件加密存储

对文件进行加密存储，可使用 AES、RSA 等加密算法。以 AES 加密为例，在文件上传时对内容进行加密，下载时再进行解密。首先引入加密相关依赖，如 Bouncy Castle 库：

<dependency>
    <groupId>org.bouncycastle</groupId>
    <artifactId>bcprov - jdk15on</artifactId>
    <version>1.70</version>
</dependency>

创建 AES 加密工具类：

import org.bouncycastle.jce.provider.BouncyCastleProvider;
import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.spec.IvParameterSpec;
import java.security.SecureRandom;
import java.security.Security;
public class AESEncryptionUtil {
    private static final String ALGORITHM = "AES/CBC/PKCS7Padding";
    private static final String TRANSFORMATION = "AES";
    private static final int KEY_SIZE = 256;
    static {
        Security.addProvider(new BouncyCastleProvider());
    }
    public static SecretKey generateKey() throws Exception {
        KeyGenerator keyGenerator = KeyGenerator.getInstance(TRANSFORMATION, "BC");
        keyGenerator.init(KEY_SIZE, new SecureRandom());
        return keyGenerator.generateKey();
    }
    public static byte[] encrypt(byte[] data, SecretKey key, byte[] iv) throws Exception {
        Cipher cipher = Cipher.getInstance(ALGORITHM, "BC");
        IvParameterSpec ivSpec = new IvParameterSpec(iv);
        cipher.init(Cipher.ENCRYPT_MODE, key, ivSpec);
        return cipher.doFinal(data);
    }
    public static byte[] decrypt(byte[] encryptedData, SecretKey key, byte[] iv) throws Exception {
        Cipher cipher = Cipher.getInstance(ALGORITHM, "BC");
        IvParameterSpec ivSpec = new IvParameterSpec(iv);
        cipher.init(Cipher.DECRYPT_MODE, key, ivSpec);
        return cipher.doFinal(encryptedData);
    }
}

在文件上传方法中使用加密：

@Service
public class FileStorageServiceImpl implements FileStorageService {
    @Override
    public String uploadFile(MultipartFile file) {
        try {
            SecretKey key = AESEncryptionUtil.generateKey();
            byte[] iv = new byte[16];
            SecureRandom random = new SecureRandom();
            random.nextBytes(iv);
            byte[] fileBytes = file.getBytes();
            byte[] encryptedBytes = AESEncryptionUtil.encrypt(fileBytes, key, iv);
            String fileName = UUID.randomUUID().toString() + "_" + file.getOriginalFilename();
            Path targetLocation = Paths.get(storagePath, fileName);
            Files.write(targetLocation, encryptedBytes);
            // 保存密钥和IV信息，可存储在数据库等地方，这里简单示例保存到文件
            Path keyPath = Paths.get(storagePath, fileName + ".key");
            Files.write(keyPath, key.getEncoded());
            Path ivPath = Paths.get(storagePath, fileName + ".iv");
            Files.write(ivPath, iv);
            return fileName;
        } catch (IOException | Exception e) {
            throw new RuntimeException("文件上传失败", e);
        }
    }
    @Override
    public byte[] downloadFile(String fileName) {
        try {
            Path targetLocation = Paths.get(storagePath, fileName);
            byte[] encryptedBytes = Files.readAllBytes(targetLocation);
            Path keyPath = Paths.get(storagePath, fileName + ".key");
            byte[] keyBytes = Files.readAllBytes(keyPath);
            SecretKey key = new SecretKeySpec(keyBytes, TRANSFORMATION);
            Path ivPath = Paths.get(storagePath, fileName + ".iv");
            byte[] iv = Files.readAllBytes(ivPath);
            return AESEncryptionUtil.decrypt(encryptedBytes, key, iv);
        } catch (IOException | Exception e) {
            throw new RuntimeException("文件下载失败", e);
        }
    }
    // 其他方法
}

通过上述加密流程，确保文件在存储和传输过程中的安全性，防止文件内容被非法获取。