oss、minio、ftp文件系统读写封装

介绍oss、minio、ftp文件系统读写封装。

接口封装

包括文件系统目录创建，文件上传和下载等

public interface RemoteFileClient<T extends FileModel> {

    /**
     * 创建目录
     * @param t
     * @throws Exception
     */
    void createDir(T t) throws Exception;

    /**
     * 根据文件路径上传文件
     * @param t
     * @param path
     * @throws Exception
     */
    void uploadByPath(T t, String path) throws Exception;

    /**
     * 根据文件流上传文件
     * @param t
     * @param inputStream
     * @throws Exception
     */
    void uploadByInputStream(T t, InputStream inputStream) throws Exception;

    /**
     * 下载文件到本地
     * @param t
     * @param path
     * @throws Exception
     */
    void download2File(T t, String path) throws Exception;

    /**
     * 读取文件流
     * @param t
     * @return
     * @throws Exception
     */
    InputStream download2Stream(T t) throws Exception;

    /**
     * 删除文件
     * @param t
     * @throws Exception
     */
    void removeFile(T t) throws Exception;

    /**
     * 移动文件
     * @param f
     * @param t
     * @throws Exception
     */
    void moveFile(T f, T t) throws Exception;

}

接口实现

oss

public class OssRemoteFileClient implements RemoteFileClient<OssFileModel> {


    private final OSS ossClient ;

    @Override
    public void createDir(OssFileModel model) throws OSSException, ClientException {
        PutObjectRequest putObjectRequest =
                new PutObjectRequest(model.getBucketName(), model.getDir() + "/", new ByteArrayInputStream("".getBytes()));
        ossClient.putObject(putObjectRequest);
    }

    @Override
    public void uploadByPath(OssFileModel model, String path) throws OSSException, ClientException, IOException {
        uploadByInputStream(model, Files.newInputStream(Paths.get(path)));
    }

    @Override
    public void uploadByInputStream(OssFileModel model, InputStream inputStream) throws OSSException, ClientException {
        PutObjectRequest putObjectRequest =
                new PutObjectRequest(model.getBucketName(), model.getObjectName(), inputStream) ;
        ossClient.putObject(putObjectRequest) ;
    }

    @Override
    public void download2File(OssFileModel model, String path) throws OSSException, ClientException {
        ossClient.getObject(new GetObjectRequest(model.getBucketName(), model.getObjectName()), new File(path));
    }

    @Override
    public InputStream download2Stream(OssFileModel model) throws OSSException, ClientException {
        OSSObject ossObject = ossClient.getObject(model.getBucketName(), model.getObjectName());
        return ossObject.getObjectContent() ;
    }

    @Override
    public void removeFile(OssFileModel model) throws OSSException, ClientException {
        ossClient.deleteObject(model.getBucketName(), model.getObjectName());
    }

    @Override
    public void moveFile(OssFileModel from, OssFileModel to) throws OSSException, ClientException {
        CopyObjectRequest copyObjectRequest =
                new CopyObjectRequest(from.getBucketName(), from.getObjectName(), to.getBucketName(), to.getObjectName()) ;
        ossClient.copyObject(copyObjectRequest) ;
        removeFile(from);
    }
}

minio

public class MinioRemoteFileClient implements RemoteFileClient<MinioFileModel> {


    private final MinioClient minioClient ;

    @Override
    public void createDir(MinioFileModel model) throws Exception {
        PutObjectArgs putObjectArgs = PutObjectArgs.builder().bucket(model.getBucketName()).object(model.getDir()).stream(
                        new ByteArrayInputStream(new byte[]{}), 0, -1).build();
        minioClient.putObject(putObjectArgs);
    }

    @Override
    public void uploadByPath(MinioFileModel minioFileModel, String path) throws Exception {
        UploadObjectArgs uploadObjectArgs = UploadObjectArgs.builder()
                .bucket(minioFileModel.getBucketName())
                .object(minioFileModel.getObjectName())
                .filename(path)
                .build();
        minioClient.uploadObject(uploadObjectArgs) ;
    }

    @Override
    public void uploadByInputStream(MinioFileModel model, InputStream inputStream) throws Exception {
        PutObjectArgs.Builder builder = PutObjectArgs.builder()
                .bucket(model.getBucketName())
                .object(model.getObjectName())
                .stream(inputStream, inputStream.available(), -1);
        if(!StringUtils.isEmpty(model.getContentType())){
            builder.contentType(model.getContentType()) ;
        }
        PutObjectArgs putObjectArgs = builder.build();
        minioClient.putObject(putObjectArgs) ;

    }

    @Override
    public void download2File(MinioFileModel model, String path) throws Exception {
        DownloadObjectArgs downloadObjectArgs = DownloadObjectArgs.builder()
                .bucket(model.getBucketName())
                .object(model.getObjectName())
                .filename(path).build();
        minioClient.downloadObject(downloadObjectArgs);
    }

    @Override
    public InputStream download2Stream(MinioFileModel model) throws Exception {
        GetObjectArgs getObjectArgs = GetObjectArgs.builder()
                .bucket(model.getBucketName())
                .object(model.getObjectName())
                .build();
        return minioClient.getObject(getObjectArgs) ;
    }

    @Override
    public void removeFile(MinioFileModel model) throws Exception {
        RemoveObjectArgs removeObjectArgs = RemoveObjectArgs.builder()
                .bucket(model.getBucketName())
                .object(model.getObjectName())
                .build();
        minioClient.removeObject(removeObjectArgs);
    }

    @Override
    public void moveFile(MinioFileModel from, MinioFileModel to) throws Exception {
        CopyObjectArgs copyObjectArgs = CopyObjectArgs.builder()
                .bucket(to.getBucketName())
                .object(to.getObjectName())
                .source(
                        CopySource.builder()
                                .bucket(from.getBucketName())
                                .object(from.getObjectName())
                                .build())
                .build();
        minioClient.copyObject(copyObjectArgs) ;

        removeFile(from) ;
    }
}

ftp

public class FtpRemoteFileClient implements RemoteFileClient<FtpFileModel> {

    
    private final FtpClient ftpClient ;
    

    @Override
    public void createDir(FtpFileModel model) throws FtpProtocolException, IOException {
        String dir = model.getDir();
        if(StringUtils.isEmpty(dir)){
            return ;
        }
        String[] dirs = dir.split(Constants.SLASH);
        if(dirs.length == 0){
            return ;
        }
        StringBuilder stringBuilder = new StringBuilder() ;
        for (String d : dirs) {
            if(StringUtils.isEmpty(d)){
                continue;
            }
            stringBuilder.append(d) ;
            ftpClient.makeDirectory(stringBuilder.toString()) ;
            stringBuilder.append(Constants.SLASH) ;
        }
    }

    @Override
    public void uploadByPath(FtpFileModel model, String path) throws IOException, FtpProtocolException {
        uploadByInputStream(model, Files.newInputStream(Paths.get(path))) ;
    }

    @Override
    public void uploadByInputStream(FtpFileModel model, InputStream inputStream) throws FtpProtocolException, IOException {
        mkdir(model) ;
        ftpClient.putFile(model.getRemoteName(), inputStream) ;
    }

    protected void mkdir(FtpFileModel model) throws IOException, FtpProtocolException{
        Path path = Paths.get(model.getRemoteName()).getParent();
        if(path!=null){
            FtpFileModel dir = new FtpFileModel() ;
            dir.setDir(path.toString());
            createDir(dir);
        }
    }


    @Override
    public void download2File(FtpFileModel model, String path) throws IOException, FtpProtocolException {
        IOUtils.copy(download2Stream(model), Files.newOutputStream(Paths.get(path))) ;
    }

    @Override
    public InputStream download2Stream(FtpFileModel model) throws FtpProtocolException, IOException {
        return ftpClient.getFileStream(model.getRemoteName());
    }

    @Override
    public void removeFile(FtpFileModel model) throws FtpProtocolException, IOException {
        ftpClient.deleteFile(model.getRemoteName()) ;
    }


    @Override
    public void moveFile(FtpFileModel from, FtpFileModel to) throws FtpProtocolException, IOException {
        ftpClient.rename(from.getRemoteName(), to.getRemoteName()) ;
    }
}

file-client 源码