精华内容
下载资源
问答
  • java文件上传到oss
    2022-06-13 15:15:37

    目录

    1、在pom.xml中添加如下依赖

    2、在application.yml中添加如下配置

    3、创建文件上传工具类

    4、接口调用


    1、在pom.xml中添加如下依赖

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

    2、在application.yml中添加如下配置

      

    oss:
      host: http://xxxx.oss-cn-shenzhen.aliyuncs.com
      bucketName: xxxx-uxm
      endpoint: oss-cn-shenzhen.aliyuncs.com
      accessKeyId: xxxx6rZ7etOfxxx
      accessKeySecret: xxxxxxxxxLc8NUoTTrmxxxxxxxxx

    3、创建文件上传工具类

    文件上传工具类: 

    /**
     * 文件上传工具类
     */
    @Data
    @Component
    @ConfigurationProperties(prefix = "uxm.oss")
    public class OssUtil {
    
        private String host;
    
        private String bucketName;
    
        private String endpoint;
    
        private String accessKeyId;
    
        private String accessKeySecret;
    
        /**
         * 上传文件
         * @param file
         * @return
         */
        public Object upload(MultipartFile file) {
            if (file.isEmpty()) {
                throw new ServiceException("上传文件不能为空");
            }
            if (!checkFileSize(file.getSize(), BaseConstant.LEN, BaseConstant.UNIT_M)) {
                throw new ServiceException("上传文件大小不能超过10M");
            }
            // 创建OSSClient实例。
            OSS ossClient = new OSSClientBuilder().build(endpoint, accessKeyId, accessKeySecret);
            // 上传文件流。
            // 保存路径,注意:这里不要以 / 或 \ 开头
            String path = new SimpleDateFormat("yyyyMMdd").format(new Date());
            String originalFilename = file.getOriginalFilename();
            String fileName = path + "/" + UUID.randomUUID().toString().replace("-", "") + originalFilename.substring(originalFilename.lastIndexOf("."));
            try {
                ossClient.putObject(bucketName, fileName, file.getInputStream());
            } catch (IOException e) {
                throw new ServiceException("上传失败" + e.getMessage());
            }
            // 关闭OSSClient。
            ossClient.shutdown();
            return host + "/" + fileName;
        }
    
        /**
         * 删除文件
         * @param url
         */
        public void remove(String url) {
            for (int i = 0; i < 3; i++) {
                url = url.substring(url.indexOf("/") + 1);
            }
            // 创建OSSClient实例。
            OSS ossClient = new OSSClientBuilder().build(endpoint, accessKeyId, accessKeySecret);
            // 删除操作
            ossClient.deleteObject(bucketName, url);
            // 关闭OSSClient。
            ossClient.shutdown();
        }
    
        /**
         * 校验文件
         * @param len
         * @param size
         * @param unit
         * @return
         */
        public boolean checkFileSize(Long len, int size, String unit) {
            double fileSize = 0;
            if (BaseConstant.UNIT_B.equals(unit.toUpperCase())) {
                fileSize = (double) len;
            } else if (BaseConstant.UNIT_K.equals(unit.toUpperCase())) {
                fileSize = (double) len / 1024;
            } else if (BaseConstant.UNIT_M.equals(unit.toUpperCase())) {
                fileSize = (double) len / 1048576;
            } else if (BaseConstant.UNIT_G.equals(unit.toUpperCase())) {
                fileSize = (double) len / 1073741824;
            }
            if (fileSize > size) {
                return false;
            }
            return true;
        }
    
    }
    

    文件常量类: 

    /**
     * 文件常量类
     */
    public class BaseConstant {
    
        public static final Integer NO = 0;
    
        public static final Integer YES = 1;
    
        public static final int LEN = 10;
    
        public static final String UNIT_M = "M";
    
        public static final String UNIT_B = "B";
    
        public static final String UNIT_K = "K";
    
        public static final String UNIT_G = "G";
    }
    

     

    4、接口调用

    Controller: 

    @Valid
    @RestController
    @RequestMapping("/file")
    @Api(tags = "上传文件", description = "上传文件API")
    public class UploadFileController {
    
        @Autowired
        private OssUtil ossUtil;
    
        /**
         * 上传文件
         */
        @ApiOperation("文件/图片上传")
        @PostMapping("/upload")
        public Result<Object> upload(@RequestParam("file") MultipartFile file) {
            return Result.success(ossUtil.upload(file));
        }
    
    }
    

    更多相关内容
  • 主要介绍了java实现上传文件到oss(阿里云)功能,结合实例形式详细分析了java上传文件到阿里云的具体步骤、配置及相关实现技巧,需要的朋友可以参考下
  • java上传本地文件到oss指定目录,包含具体怎么使用,只需要改变一下配置文件就可以使用,如有疑问联系我QQ1058070168
  • 主要为大家详细介绍了java获取网络图片上传到OSS,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • Java实现文件上传阿里OSS

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

    前言简介

    ​ 这边博文实际上想要展现的是一个文件上传阿里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测试结果

    image-20211111113644158

    展开全文
  • 主要介绍了Java下载https文件上传到阿里云oss服务器,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • JAVA-阿里云OSS文件下载并将文件压缩为ZIP格式保存-附件资源
  • 文章目录1、创建Bucket2、获取AccessKey3、找开发文档4、后端集成OSS1、创建子模块service-oss并配置pom.xml2、配置application.properties3、启动项目4、从配置文件读取信息5、编写上传代码6、使用swagger测试接口7...

    1、创建Bucket

    image-20210328102627712

    2、获取AccessKey

    搜索框搜索accesskey

    image-20210327213354355

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

    image-20210327213257755

    image-20210327213559169

    3、找开发文档

    image-20210327213909910

    0SS学习路径

    image-20210327214541167

    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>
    

    image-20210328095440321

    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、启动项目

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

    image-20210328110246186

    这里有两种解决方案

    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、编写上传代码

    获取文件存放路径

    image-20210328203221239

    image-20210328203340980

    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
    image-20210329091056407

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

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

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

    找到相关子用户,添加权限:
    image-20210328210200755
    在这里插入图片描述
    添加上权限后即可正常上传文件了。

    7、上传成功后查看文件

    image-20210329085438545

    展开全文
  • 代码简单容懂。下载就可以运行。该列子包过了easypoi注解导出exel表格同时导出oss中的图片exel表格中。
  • 导航开通阿里云oss服务选择OSS系统开通服务充值创建bucket查看sdk的使用项目演示pomproperties主启动类初始化工具类service层controller层 开通阿里云oss服务 阿里云官网:https://www.aliyun.com/ 选择OSS系统 ...

    开通阿里云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);
        }
    }
    
    展开全文
  • Java实现阿里云OSS上传文件

    千次阅读 2022-03-30 23:12:11
    1、准备工作:创建操作阿里云OSS许可证 阿里云官方文档 这里不再赘述,根据官方文档一步步的操作就可以了! 下面直接进入实战操作! 2、实战操作 第一步:引入依赖 <dependency> <groupId>...
  • (1)Endpoint(地域节点)--外网访问(2) BucketName(仓库名称)(3) AccessKeyID 和查看的 Secret888 这个自己在头像下面找(没有就创建)...yml文件的配置 TestController index.html 效果图: 总结
  • java oss图片单个上传、多个上传、分片上传、进度条完整代码
  • 在本地文件系统创建了对应的文件,但是在执行文件上传代码时报错,系统找不本地文件 检查一下是否勾选了“文件扩展名” 勾选之前 勾选之后 原因 在创建文件时系统自动添加了文件后缀,因为没有勾选“文件扩展名...
  • 基于java语言实现文件的本地上传oss普通上传,和大文件的分段上传,请手写的,可以使用,可以上传图片,视频压缩包等多种格式文件
  • 主要为大家详细介绍了java利用oss实现下载功能,文中示例代码介绍的非常详细,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • OSS依赖 <!--oss依赖--> <dependency> <groupId>com.aliyun.oss</groupId> <artifactId>aliyun-sdk-oss</artifactId> <version>3.10.2</version> </...
  • 主要讲述了怎么把文件上传到阿里云的oss创建的bucket中,
  • java上传文件夹到oss

    2021-02-28 07:14:10
    前段时间正好做个项目,就是用的oss,普通上传和断点续,代码贴出来,看是不是你们需要的public class OssManage {public static String ACCESS_KEY_ID = null;public static String ACCESS_KEY_SECRET = null;...
  • java 阿里云上传文件到OSS,并返回文件路径
  • 文件上传到OSS文件服务器上
  • (1)引入阿里云的oss依赖(2)代码的书写 3. elementui 异步上传OSS服务器 (1)前端 (2)后端工具: (3) controller接口 4. 保存用户信息--头像 (1)前端的布局 (2)后台代码
  • 之前做springboot项目中遇到文件上传到OSS云服务器,然后把文件路径返回给手机端。文件上传java web中常见的操作,文件上传主要是将文件通过IO流传放云服务器一、请求controller,暴露接口请求@RestController()...
  • OSS使用java文件上传及存储,以及整个OSS使用的详细步骤
  • 主要介绍了Java微信小程序oss图片上传的实现方法,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • 实现文件上传功能,本地上传,需设置本地保存的地址,oss上传需设置自己的oss参数,oss图片可实现添加水印
  • JAVA开发 OSS上传文件

    万次阅读 2021-06-18 14:16:57
    参考链接:OSS 上传压缩文件,并自动解压 相关依赖: <dependency> <groupId>com.aliyun.oss</groupId> <artifactId>aliyun-sdk-oss</artifactId> <version>2.8.3</...
  • 使用阿里云OSS上传文件本文介绍如何利用Java API操作阿里云OSS对象存储。1.控制台操作首先介绍一下阿里云OSS对象存储的一些基本概念。1.1 进入对象存储界面登录阿里云账号,进入对象存储界面(点击跳转),如图所示。...
  • Java试用easyExcel导出文件 压缩上传OSS zipOutputStream, zipInputStream, excel导出

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 15,302
精华内容 6,120
关键字:

java文件上传到oss