前言简介

​ 这边博文实际上想要展现的是一个文件上传阿里OSS的工具类,但是过程是完全实现一个公司根据业务需求去开发实现上传的一个业务需求,综合比较其他博文,这篇博文可能比较罗嗦点.所以根据自身需求来决定是否需要借用此篇博客.

开发工具

idea + maven + postman(用来作为测试工具)

开发环境

jdk 1.8 + SpringBoot + maven(jar包管理)

jar包版本:2.8.2

<!--阿里云oss存储-->
<dependency>
    <groupId>com.aliyun.oss</groupId>
    <artifactId>aliyun-sdk-oss</artifactId>
    <version>2.8.2</version>
</dependency>

OSS-初始化OSSClient

生成一个已经配置好的OSSClient对象

endpoint: 带有地域节点的请求地址

keyid: 阿里云用户id

keysecret:阿里云用户密码

oss.endpoint = oss-cn-shanghai.aliyuncs.com
oss.keyid= *********
oss.keysecret= *********

import com.aliyun.oss.OSSClient;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * oss配置类
 *
 * @author chenpengfei
 */
@Configuration
public class OSSClientConfig {
    @Value("${oss.endpoint}")
    String endpoint;
    @Value("${oss.keyid}")
    String accessKeyId;
    @Value("${oss.keysecret}")
    String accessKeySecret;

    // 创建OSS客户端Bean
    @Bean
    public OSSClient getOSSClient() {
        return new OSSClient(endpoint, accessKeyId, accessKeySecret);
    }
}

OSS-上传工具类

bucketname: 阿里云存储空间名

fileHost: 阿里服务器的域名

filePath: 上传文件路径

oss.bucketname = xxxxxx
oss.fileHost= xxxxxx
oss.filePath= upload

package com.gd.common.utils.oss;

import com.aliyun.oss.ClientException;
import com.aliyun.oss.OSSClient;
import com.aliyun.oss.OSSException;
import com.aliyun.oss.model.CannedAccessControlList;
import com.aliyun.oss.model.CreateBucketRequest;
import com.aliyun.oss.model.PutObjectRequest;
import com.aliyun.oss.model.PutObjectResult;
import lombok.extern.log4j.Log4j2;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
import javax.annotation.Resource;
import java.io.File;

/**
 * 阿里OSS上传服务
 */
@Component
@Log4j2
public class AliyunOSSUtil {
    @Value("${oss.bucketname}")
    String bucketName;
    @Resource
    private OSSClient client;

    /**
     * 上传文件
     */
    public String upLoad(File file, String fileUrl) {
        log.info("------OSS文件上传开始--------" + file.getName());
        // 判断文件是否为空
        if (file == null) {
            return null;
        }

        try {
            // 判断容器是否存在,不存在就创建
            if (!client.doesBucketExist(bucketName)) {
                client.createBucket(bucketName);
                CreateBucketRequest createBucketRequest = new CreateBucketRequest(bucketName);
                createBucketRequest.setCannedACL(CannedAccessControlList.PublicRead);
                client.createBucket(createBucketRequest);
                // 设置权限(公开读)
                client.setBucketAcl(bucketName, CannedAccessControlList.PublicRead);
            }
            // 上传文件
            PutObjectResult result = client.putObject(new PutObjectRequest(bucketName, fileUrl, file));
            if (result != null) {
                log.info("------OSS文件上传成功------" + fileUrl);
                return fileUrl;
            }
        } catch (OSSException oe) {
            log.error(oe.getMessage());
        } catch (ClientException ce) {
            log.error(ce.getErrorMessage());
        } finally {
        }
        return null;
    }
}

业务功能实现

• 获取服务器域名网址
• 单文件上传
• 多文件上传

service

import org.springframework.web.multipart.MultipartFile;
 
public interface OssUploadService {

    /**
     * 上传文件
     * @param file
     * @return
     */
    String upload(MultipartFile file);
}

impl

package com.maoni.ssmtest.service.impl;

import com.maoni.ssmtest.service.OssUploadService;
import com.maoni.ssmtest.utils.date.DatePattern;
import com.maoni.ssmtest.utils.date.DateUtils;
import com.maoni.ssmtest.utils.aliOSSUtil.AliyunOSSUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import org.springframework.web.multipart.MultipartFile;

import java.io.File;
import java.io.FileOutputStream;
import java.util.Date;

/**
 * @author ouj
 */

@Service
public class OssUploadServiceImpl implements OssUploadService {

    private  final AliyunOSSUtil aliyunOSSUtil;

    @Autowired
    public OssUploadServiceImpl(AliyunOSSUtil aliyunOSSUtil){
        this.aliyunOSSUtil = aliyunOSSUtil;
    }

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

    @Override
    public String upload(MultipartFile file) {
        // 返回客户端文件系统中的原始文件名
        String fileName = file.getOriginalFilename();
        System.out.println(fileName);

        try{
            if (file != null) {
                // 判定文件名是否为 ""
                if (!"".equals(fileName.trim())) {
                    File newFile = new File(fileName);
                    FileOutputStream os = new FileOutputStream(newFile);
                    // 以字节数组的形式返回文件的内容,再输出到文件输出流中
                    os.write(file.getBytes());
                    os.close();
                    // 将接受的文件传输到给定的目标文件 file-->newFile
                    file.transferTo(newFile);
                    // 根据不同文件 类型/日期 生成不同的文件夹
                    Date date = new Date();
                    String datePath = DateUtils.formatDateByStyle(date, DatePattern.CN_DATE_BASIC_STYLE4.getDatePattern());
                    String timeStamp = String.valueOf(System.currentTimeMillis());
                    fileName = timeStamp + fileName.substring(fileName.lastIndexOf("."));
                    String path;
                    if (fileName.endsWith(".jpg") || fileName.endsWith(".jpeg") || fileName.endsWith(".png")) {
                        // images
                        path = filePath + "images/" + datePath + "/" + fileName;
                    } else {
                        path = filePath + "other/" + datePath + "/" + fileName;
                    }
                    // 上传到OSS
                    String uploadUrl = aliyunOSSUtil.upLoad(newFile, path);
                    newFile.delete();
                    if (uploadUrl != null) {
                        return uploadUrl;
                    }
                }
            }
        }catch (Exception e){
            e.printStackTrace();
        }
        return null;
    }
}

controller

import com.maoni.ssmtest.domain.OssData;
import com.maoni.ssmtest.service.OssUploadService;
import com.maoni.ssmtest.utils.AjaxResult;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Scope;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * @author ouj
 */
@RestController
@Scope("prototype")
@RequestMapping("oss")
public class OssUploadController {

    private final OssUploadService ossUploadService;

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

    @Autowired
    public OssUploadController(OssUploadService ossUploadService) {
        this.ossUploadService = ossUploadService;
    }

    /**
     * 获取服务器的ip地址
     * @return
     */
    @GetMapping("getHost")
    public AjaxResult getHost() {
        OssData ossData = new OssData();
        ossData.setHost(fileHost);
        return AjaxResult.AjaxSuccess(ossData);
    }

    /**
     * oss上传文件(单个文件上传)
     * @param file
     * @return
     */
    @PostMapping("fileUpload")
    public AjaxResult fileUpload(@RequestParam("file") MultipartFile file) {
        OssData ossData = new OssData();
        // 上传文件返回url
        String url = ossUploadService.upload(file);
        if (url != null) {
            ossData.setHost(fileHost);
            ossData.setPath(fileHost + url);
            return AjaxResult.AjaxSuccess(ossData);
        } else {
            return AjaxResult.AjaxError(300, "上传失败");
        }
    }

    /**
     * oss多文件上传
     * @param files
     * @return
     */
    @PostMapping("filesUpload")
    public AjaxResult filesUpload(@RequestParam("file") List<MultipartFile> files) {
        OssData ossData = new OssData();
        Map<String, String> urls = new HashMap<>();
        for (MultipartFile file : files) {
            String url = ossUploadService.upload(file);
            if (url != null) {
                String fileName = file.getOriginalFilename();
                url = fileHost + url;
                urls.put(fileName, url);
            } else {
                ossData.setFileName(file.getOriginalFilename());
                ossData.setPath(fileHost + url);
                return AjaxResult.AjaxError(100, ossData, "上传失败");
            }
        }
        return AjaxResult.AjaxSuccess(urls);
    }

    /**
     * oss 分俩个file,多文件上传
     * @param file01
     * @param file02
     * @return
     */
    @PostMapping("filesUploadMore")
    public AjaxResult filesUploadMore(@RequestParam("file01") List<MultipartFile> file01, @RequestParam("file02") List<MultipartFile> file02) {
        OssData ossData = new OssData();
        Map<String, String> urls = new HashMap<>();
        for (MultipartFile file : file01) {
            try {
                String url = ossUploadService.upload(file);
                if (url != null) {
                    String fileName = file.getOriginalFilename();
                    url = fileHost + url;
                    urls.put(fileName, url);
                } else {
                    ossData.setFileName(file.getOriginalFilename());
                    return AjaxResult.AjaxError(100, ossData, "上传失败");
                }
            } catch (Exception e) {
                e.printStackTrace();
                ossData.setFileName(file.getOriginalFilename());
                return AjaxResult.AjaxError(100, ossData, "上传失败");
            }
        }

        for (MultipartFile file : file02) {
            try {
                String url = ossUploadService.upload(file);
                if (url != null) {
                    String fileName = file.getOriginalFilename();
                    url = fileHost + url;
                    urls.put(fileName, url);
                } else {
                    ossData.setFileName(file.getOriginalFilename());
                    return AjaxResult.AjaxError(100, ossData, "上传失败");
                }
            } catch (Exception e) {
                e.printStackTrace();
                ossData.setFileName(file.getOriginalFilename());
                return AjaxResult.AjaxError(100, ossData, "上传失败");
            }
        }
        return AjaxResult.AjaxSuccess(urls);
    }
}

OssData 封装类(服务器域名+上传文件路径+上传文件名)

/**
 * @author ouj
 */
@Data
public class OssData {
    /**
     * 服务器域名
     */
    private String host;
    /**
     * 上传文件路径
     */
    private String path;
    /**
     * 上传文件名
     */
    private String fileName;
}

Postman测试结果

1、创建Bucket

2、获取AccessKey

搜索框搜索accesskey

进到创建页面后点击人员管理-用户

3、找开发文档

0SS学习路径

4、后端集成OSS

1、创建子模块service-oss并配置pom.xml

<dependencies>
    <!-- 阿里云oss依赖 -->
    <dependency>
        <groupId>com.aliyun.oss</groupId>
        <artifactId>aliyun-sdk-oss</artifactId>
    </dependency>

    <!-- 日期工具栏依赖 -->
    <dependency>
        <groupId>joda-time</groupId>
        <artifactId>joda-time</artifactId>
    </dependency>
</dependencies>

2、配置application.properties

#服务端口
server.port=8002
#服务名
spring.application.name=service-oss

#环境设置：dev、test、prod
spring.profiles.active=dev

#阿里云 OSS
#不同的服务器，地址不同
#地域节点
aliyun.oss.file.endpoint=your endpoint
#accessKeyId
aliyun.oss.file.keyid=your accessKeyId
#accessKeySecret
aliyun.oss.file.keysecret=your accessKeySecret
#bucket可以在控制台创建，也可以使用java代码创建
aliyun.oss.file.bucketname=your bucketName

3、启动项目

启动时可能会报数据源未配置异常

这里有两种解决方案

1、在资源文件中配置数据库连接信息

2、在启动类上使用注解取消自动配置数据源

//exclude表示不包含,在启动的时候不需要自动配置数据源
@SpringBootApplication(exclude = DataSourceAutoConfiguration.class)
@ComponentScan(basePackages = {"com.atguigu"})
public class OssApplication {
    public static void main(String[] args) {
        SpringApplication.run(OssApplication.class,args);
    }
}

4、从配置文件读取信息

@Component
public class ConstantPropertiesUtils implements InitializingBean {
    @Value("${aliyun.oss.file.endpoint}")
    private String endpoint;

    @Value("${aliyun.oss.file.keyid}")
    private String keyId;

    @Value("${aliyun.oss.file.keysecret}")
    private String keySecret;

    @Value("${aliyun.oss.file.bucketname}")
    private String bucketName;

    public static String END_POINT;
    public static String ACCESS_KEY_ID;
    public static String ACCESS_KEY_SECRET;
    public static String BUCKET_NAME;

    @Override
    public void afterPropertiesSet() throws Exception {
        END_POINT = endpoint;
        ACCESS_KEY_ID = keyId;
        ACCESS_KEY_SECRET = keySecret;
        BUCKET_NAME = bucketName;
    }
}

5、编写上传代码

获取文件存放路径

serviceImpl

@Service
public class OssServiceImpl implements OssService {

    @Override
    public String uploadFileAvatar(MultipartFile file) {
        String endpoint = ConstantPropertiesUtils.END_POINT;
        String accessKeyId = ConstantPropertiesUtils.ACCESS_KEY_ID;
        String accessKeySecret = ConstantPropertiesUtils.ACCESS_KEY_SECRET;
        String bucketName = ConstantPropertiesUtils.BUCKET_NAME;

        try {
            // 创建OSSClient实例。
            OSS ossClient = new OSSClientBuilder().build(endpoint, accessKeyId, accessKeySecret);

            // 填写本地文件的完整路径。如果未指定本地路径，则默认从示例程序所属项目对应本地路径中上传文件流。
            InputStream inputStream = file.getInputStream();

            //获取文件名称,前面跟上UUID防止名字重复
            String uuid = UUID.randomUUID().toString().replaceAll("-","");
            String originalFilename = uuid+file.getOriginalFilename();

            //将文件按照日期进行分类
            //org.joda.time.DateTime
            String datePath = new DateTime().toString("yyyy/MM/dd");
            originalFilename = datePath +"/"+ originalFilename;
            // 第一个参数  Bucket名称
            // 第二个参数  上传到oss文件路径和文件名称
            // 第三个参数  上传文件输入流
            ossClient.putObject(bucketName, originalFilename, inputStream);

            // 关闭OSSClient。
            ossClient.shutdown();

            //https://edu-2021-3-27.oss-cn-beijing.aliyuncs.com/日期/uuidXXX.png
            String url = "https://"+bucketName+"."+endpoint+"/"+originalFilename;
            return url;
        } catch (IOException e) {
            e.printStackTrace();
            return null;
        }
    }
}

service

import org.springframework.web.multipart.MultipartFile;

public interface OssService {
    String  uploadFileAvatar(MultipartFile file);
}

controller

@Api(description="阿里云文件管理")
@RestController
@RequestMapping("/eduoss/fileoss")
@CrossOrigin
public class OssController {
    @Autowired
    private OssService ossService;

    @ApiOperation(value = "文件上传")
    @PostMapping("upload")
    public R uploadOssFile(
            @ApiParam(name = "file", value = "文件", required = true)
            MultipartFile file){
        String url = ossService.uploadFileAvatar(file);
        return R.ok().data("url",url);
    }
}

6、使用swagger测试接口

本地swaggerURL

可能会报You have no right to access this object because of bucket acl.异常

这是使用阿里云OSS上传文件服务时报的错，这是由于新建的子用户AccessKey没有配置相应的权限所导致的。

解决方法，配置上相应权限。

找到相关子用户，添加权限：


添加上权限后即可正常上传文件了。

7、上传成功后查看文件

开通阿里云oss服务

阿里云官网：https://www.aliyun.com/

选择OSS系统

开通服务

充值

充值一元就够个人使用很长时间了

创建bucket

• 选择：添加名称、标准存储、公共读、不开通
  
• 查看生成的id和秘钥
  
  

查看sdk的使用

帮助文档：https://help.aliyun.com/document_detail/32006.html

项目演示

pom

    <dependencies>
        <!--阿里云-->
        <dependency>
            <groupId>com.aliyun.oss</groupId>
            <artifactId>aliyun-sdk-oss</artifactId>
        </dependency>
        <!--日期工具栏-->
        <dependency>
            <groupId>joda-time</groupId>
            <artifactId>joda-time</artifactId>
        </dependency>
    </dependencies>

properties

#端口号
server.port=8082
#服务名称
spring.application.name=service_oss
#开发环境
spring.profiles.active=dev
#oss的网址、id、秘钥
aliyun.oss.file.endpoint=你的公开的endpoint
aliyun.oss.file.keyid=你的keiId
aliyun.oss.file.keysecret=keyId对应的secret
#buket名称
aliyun.oss.file.bucketname=创建时的bucketname
#nacos地址
spring.cloud.nacos.discovery.server-addr=localhost:8848
#项目名称
project.name=cinema-online

主启动类

/**
 * @author : Abo
 * @date : 2022/1/23 19:37
 */
// 不需要加载项目的数据源
@SpringBootApplication(exclude = DataSourceAutoConfiguration.class)
@EnableDiscoveryClient
@EnableSwagger2
public class OssApplication {
    public static void main(String[] args) {
        SpringApplication.run(OssApplication.class, args);
    }
}

初始化工具类

/**
 * @author : Abo
 * @date : 2022/1/23 19:39
 */
// 启动时自动读取
@Component
public class ConstantPropertiesUtils implements InitializingBean {
    @Value("${aliyun.oss.file.endpoint}")
    private String endpoint;
    @Value("${aliyun.oss.file.keyid}")
    private String keyId;
    @Value("${aliyun.oss.file.keysecret}")
    private String keySecret;
    @Value("${aliyun.oss.file.bucketname}")
    private String bucketName;

    public static String END_POINT;
    public static String ACCESS_KEY_ID;
    public static String ACCESS_KEY_SECRET;
    public static String BUCKET_NAME;


    @Override
    public void afterPropertiesSet() throws Exception {
        END_POINT = endpoint;
        ACCESS_KEY_ID = keyId;
        ACCESS_KEY_SECRET = keySecret;
        BUCKET_NAME = bucketName;
    }
}

service层

/**
 * @author : Abo
 * @date : 2022/1/23 19:42
 */
@Service
public class OssServiceImpl implements OssService {

    @Value("${project.name}")
    private String projectName;

    /**
     * 图片上传
     */
    @Override
    public ResponseResult uploadFileAvatar(MultipartFile file) {
        // 通过工具类获取配置数据
        String endPoint = ConstantPropertiesUtils.END_POINT;
        String accessKeyId = ConstantPropertiesUtils.ACCESS_KEY_ID;
        String accessKeySecret = ConstantPropertiesUtils.ACCESS_KEY_SECRET;
        String bucketName = ConstantPropertiesUtils.BUCKET_NAME;

        // 完成上传
        try {
            // 获取上传的输入流
            InputStream inputStream = file.getInputStream();
            // 防止恶意程序伪装成图片
            BufferedImage image = ImageIO.read(inputStream);
            if (image == null || image.getWidth() == 0 || image.getHeight() == 0) {
                return ResponseResult.error().message("请上传符合规范的图片");
            }

            // 获取文件名称
            String filename = file.getOriginalFilename();

            // 为文件设定唯一名称
           /* 数字类型
            CRC32 crc32 = new CRC32();
            crc32.update(UUID.randomUUID().toString().getBytes());*/
            filename = UUID.randomUUID().toString().replaceAll("-", "") + filename;
            // 按照年月日创建上传的目录存放图片
            String datePath = new DateTime().toString("yyyy/MM/dd");
            filename = projectName + "/" + datePath + "/" + filename;

            /*
             * 调用oss实现上传
             * 第一个参数  bucket名称
             * 第二个参数  文件名称
             * 第三个参数  输入流
             */
            OSS ossClient = new OSSClientBuilder().build(endPoint, accessKeyId, accessKeySecret);
            ossClient.putObject(bucketName, filename, inputStream);
            ossClient.shutdown();
            String url = "https://" + bucketName + "." + endPoint + "/" + filename;
            return ResponseResult.success().data("url", url);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
}

controller层

/**
 * @author : Abo
 * @date : 2022/1/23 19:59
 */
@RestController
@RequestMapping("/oss/")
public class OssController {
    @Autowired
    private OssService ossService;

    @ApiOperation("图片上传")
    @PostMapping("upload")
    public ResponseResult uploadOssFile(MultipartFile file) {
         return ossService.uploadFileAvatar(file);
    }
}