SpringBoot上传文件到阿里云OSS服务器(一)

上传文件到阿里云OSS服务器(一)

<dependency>
    <groupId>com.aliyun.oss</groupId>
        <artifactId>aliyun-sdk-oss</artifactId>
        <version>3.10.2</version>
</dependency>

1.工具类 AliOSSCloudUtil

package com.dycx.framework.api.ossutils;

import com.aliyun.oss.OSS;
import com.aliyun.oss.OSSClientBuilder;
import com.aliyun.oss.model.*;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

import java.io.Closeable;
import java.io.IOException;
import java.io.InputStream;
import java.net.URL;
import java.util.Date;

/**
 * 阿里云 OSS文件
 */
public class AliOSSCloudUtil implements Closeable {
    Log log = LogFactory.getLog(AliOSSCloudUtil.class);

    private OSS ossClient;

    public AliOSSCloudUtil() {
        ossClient = new OSSClientBuilder().build(OSSConfig.endpoint, OSSConfig.accessKeyId, OSSConfig.accessKeySecret);
    }


    /**
     * 销毁
     */
    public void destory() {
        ossClient.shutdown();
    }


    /**
     * 上传到OSS服务器
     * @param instream 文件流
     * @param fileName 文件名称 包括后缀名
     * @return 返回文件URL
     */
    @Deprecated
    public String uploadFile2OSS(InputStream instream, String fileName, String filedir, String bucketName) {
        String ret = "";
        // 判断bucket是否已经存在,不存在进行创建
        if (!doesBucketExist(bucketName)) {
            createBucket(bucketName);
        }
        try {
            String objectName = filedir + fileName;
            //上传文件
            ossClient.putObject(bucketName, objectName, instream, createObjectMetadata(instream,fileName));
            // 封装  url 路径
            ret = "http://" + bucketName + "." + OSSConfig.endpoint + "/" + objectName;
        } catch (IOException e) {
            log.error(e.getMessage(), e);
        } finally {
            try {
                if (instream != null) {
                    instream.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return ret;
    }

    /**
     * 上传文件到oss
     * @param instream 文件上传流
     * @param fileName 文件名
     * @param filedir 上传相对路径
     * @param bucketName 上传bucket
     * @return
     */
    public OssUploadDTO uploadFile2OSSResult(InputStream instream, String fileName, String filedir, String bucketName) {
        OssUploadDTO result = new OssUploadDTO();
        // 判断bucket是否已经存在,不存在进行创建
        if (!doesBucketExist(bucketName)) {
            createBucket(bucketName);
        }
        try {
            String objectName = filedir + fileName;

            //上传文件
            ossClient.putObject(bucketName, objectName, instream, createObjectMetadata(instream,fileName));
            // 封装  url 路径
            result.setUrl("http://" + bucketName + "." + OSSConfig.endpoint + "/" + objectName);
            result.setBucketName(bucketName);
            result.setEndpoint(OSSConfig.endpoint);
            result.setObjectName(objectName);
        } catch (IOException e) {
            log.error(e.getMessage(), e);
        } finally {
            try {
                if (instream != null) {
                    instream.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return result;
    }

    public ObjectMetadata createObjectMetadata(InputStream inputStream,String fileName) throws IOException {
        //创建上传Object的Metadata
        ObjectMetadata objectMetadata = new ObjectMetadata();
        objectMetadata.setContentLength(inputStream.available());
        objectMetadata.setCacheControl("no-cache");
        objectMetadata.setHeader("Pragma", "no-cache");
        objectMetadata.setContentType(getcontentType(fileName.substring(fileName.lastIndexOf("."))));
        objectMetadata.setContentDisposition("inline;filename=" + fileName);

        // 指定上传文件操作时是否覆盖同名Object。
        // 不指定x-oss-forbid-overwrite时，默认覆盖同名Object。
        // 指定x-oss-forbid-overwrite为false时，表示允许覆盖同名Object。
        // 指定x-oss-forbid-overwrite为true时，表示禁止覆盖同名Object，如果同名Object已存在，程序将报错。
        objectMetadata.setHeader("x-oss-forbid-overwrite", "false");
        return objectMetadata;
    }
    /**
     * 判断文件是否存在。doesObjectExist还有一个参数isOnlyInOSS，
     * 如果为true则忽略302重定向或镜像；如果为false，则考虑302重定向或镜像。
     * yourObjectName 表示上传文件到OSS时需要指定包含文件后缀在内的完整路径，例如abc/efg/123.jpg。
     *
     * @return 存在返回true
     */
    public boolean doesObjectExist(String objectName, String bucketName, String filedir) {
        return ossClient.doesObjectExist(bucketName, filedir + objectName);
    }

    /**
     * 判断Bucket是否存在
     *
     * @return 存在返回true
     */
    public boolean doesBucketExist(String bucketName) {
        return ossClient.doesBucketExist(bucketName);
    }


    /**
     * 创建Bucket
     */
    public void createBucket(String bucketName) {
        CreateBucketRequest createBucketRequest = new CreateBucketRequest(bucketName);
        // 设置bucket权限为公共读，默认是私有读写
        createBucketRequest.setCannedACL(CannedAccessControlList.PublicRead);
        // 设置bucket存储类型为低频访问类型，默认是标准类型
        createBucketRequest.setStorageClass(StorageClass.IA);
        boolean exists = ossClient.doesBucketExist(bucketName);
        if (!exists) {
            try {
                ossClient.createBucket(createBucketRequest);
            } catch (Exception e) {
                log.error(e.getMessage());
            }
        }
    }

    /**
     * Description: 判断OSS服务文件上传时文件的contentType
     *
     * @param FilenameExtension 文件后缀
     * @return String
     */
    public static String getcontentType(String FilenameExtension) {
        if ("bmp".equalsIgnoreCase(FilenameExtension)) {
            return "image/bmp";
        }
        if ("gif".equalsIgnoreCase(FilenameExtension)) {
            return "image/gif";
        }
        if ("jpeg".equalsIgnoreCase(FilenameExtension) ||
                "jpg".equalsIgnoreCase(FilenameExtension) ||
                "png".equalsIgnoreCase(FilenameExtension)) {
            return "image/jpeg";
        }
        if ("html".equalsIgnoreCase(FilenameExtension)) {
            return "text/html";
        }
        if ("txt".equalsIgnoreCase(FilenameExtension)) {
            return "text/plain";
        }
        if ("vsd".equalsIgnoreCase(FilenameExtension)) {
            return "application/vnd.visio";
        }
        if ("pptx".equalsIgnoreCase(FilenameExtension) ||
                "ppt".equalsIgnoreCase(FilenameExtension)) {
            return "application/vnd.ms-powerpoint";
        }
        if ("docx".equalsIgnoreCase(FilenameExtension) ||
                "doc".equalsIgnoreCase(FilenameExtension)) {
            return "application/msword";
        }
        if ("xml".equalsIgnoreCase(FilenameExtension)) {
            return "text/xml";
        }
        return "image/jpeg";
    }


    /**
     * @param fileName
     * @return 返回流
     * @title: getInputStreamByFileUrl
     * @description: 根据文件路径获取InputStream流
     * @return: InputStream
     */
    public InputStream getInputStreamByFileUrl(String fileName, String bucketName) {
        OSSObject ossObject = ossClient.getObject(bucketName, fileName);
        return ossObject.getObjectContent();
    }

    /**
     * @param bucketName bucket
     * @param objectName OSS上保存文件buckke后面的相对路径URI，包含文件名
     * @param expire     过期时间秒 s
     * @description: 生成临时oss访问URL
     * @return: String 临时访问URL
     */
    public String generatePresignedUrl(String bucketName, String objectName, long expire) {
        // 设置URL默认过期时间为1小时。
        Date expiration = new Date(System.currentTimeMillis() + (expire > 0 ? expire : 3600) * 1000);
        // 生成以GET方法访问的签名URL，访客可以直接通过浏览器访问相关内容。
        URL url = ossClient.generatePresignedUrl(bucketName, objectName, expiration);
        return url.toString();
    }

    @Override
    public void close() {
        ossClient.shutdown();
    }
}

2.OSSUtil

package com.dytz.risk.utils;

import com.dycx.framework.api.ossutils.AliOSSCloudUtil;
import com.dycx.framework.api.ossutils.OssUploadDTO;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Repository;
import org.springframework.web.multipart.MultipartFile;

import java.io.IOException;
import java.io.InputStream;
import java.time.LocalDateTime;
import java.util.UUID;

@Slf4j
@Repository
public class OSSUtil {

    @Value("${oss.bucket}")
    private String bucket;


    /**
     * 上传录音文件
     * @param file
     * @return
     * @throws Exception
     */
    public OssUploadDTO upload(MultipartFile file) throws Exception {
        String dir = "sfc-audio/" + DateUtil.format(LocalDateTime.now(), "yyyy/MM-dd");
        String fileName = file.getResource().getFilename();
        assert fileName != null;
        String name = UUID.randomUUID().toString().replace("-","") + fileName.substring(fileName.lastIndexOf("."));
        InputStream inputStream = null;
        try {
            inputStream = file.getInputStream();
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("上传失败");
        }
        AliOSSCloudUtil util = new AliOSSCloudUtil();
        //上传成功返回完整路径
        OssUploadDTO dto = util.uploadFile2OSSResult(inputStream, name,dir + "/",bucket);

        util.close();

        String url = util.generatePresignedUrl(dto.getBucketName(),dto.getObjectName(),3000) ;
        dto.setUrl(url);
        util.close(); //最后关闭  OOS可以用他们封装好的工具类

        return dto;
    }


}

3.实现类

 @Autowired
    private AudioRecordMapper audioRecordMapper;
    @Autowired
    private OSSUtil ossUtil;

    @Override
    public int save(MultipartFile file, SaveAudioInfo info)throws Exception{
        OssUploadDTO ossUploadDTO=ossUtil.upload(file);
        AudioRecord audioRecord=new AudioRecord();
        if(ossUploadDTO != null){
            BeanUtils.copyProperties(info,audioRecord);
            BeanUtils.copyProperties(ossUploadDTO,audioRecord);
            audioRecord.setCreateTime(new Date());

        }
        return audioRecordMapper.insert(audioRecord);
    }

4.controller

@Autowired
    private IAudioRecordService iAudioRecordService;

    /**
     * 保存录音文件
     * @param file
     * @param userId
     * @param orderId
     * @param travelId
     * @return
     */
    @PostMapping("saveAudio")
    public RestResponse save(@RequestParam(value = "file",required = true) MultipartFile file,
                             @RequestParam(required = true) Long userId,
                             @RequestParam(required = true) Long orderId,
                             @RequestParam(required = false) Long travelId,
                             @RequestParam(required = false)Date startTime,
                             @RequestParam(required = false)Date endTime){
        if(!file.isEmpty()){
            int result = 0;
            try {
                SaveAudioInfo audioInfo = new SaveAudioInfo();
                audioInfo.setUserId(userId);
                audioInfo.setOrderId(orderId);
                audioInfo.setTravelId(travelId);
                audioInfo.setStartTime(startTime);
                audioInfo.setEndTime(endTime);

                result = iAudioRecordService.save(file,audioInfo);
            } catch (Exception e) {
                e.printStackTrace();
                log.info("{}",e);
                return RestResponse.fail(e.getMessage());
            }
            if (result > 0) {
                return RestResponse.success();
            }
            return RestResponse.fail("保存失败");
        }
        return RestResponse.fail("录音文件不存在");
    }

5.OssUploadDTO

@Data
public class OssUploadDTO implements Serializable {
    /**
     * 文件上传后URL
     */
    private String url;
    /**
     * 文件上传buketName
     */
    private String bucketName;
    /**
     * oss endpoint
     */
    private String endpoint;
    /**
     * oss 相对路径含文件名
     */
    private String objectName;
}