Java - 华为云存储&Ftp文件存储

最新推荐文章于 2024-09-02 22:38:58 发布
最新推荐文章于 2024-09-02 22:38:58 发布
阅读量773 收藏 7
点赞数 7
文章标签： 华为云
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Mryfl/article/details/134781828
版权

目录

一、华为云OBS存储

（1）依赖

（2）SpringBoot集成xml配置

（3）配置类

（4）service层业务接口

（5）serviceimpl业务层接口实现

（6）controller控制层

（7）帮助类

二、Ftp文件存储

（1）配置类

（2）文件上传接口

一、华为云OBS存储

（1）依赖
<dependency>
    <groupId>com.huaweicloud</groupId>
    <artifactId>esdk-obs-java</artifactId>
    <version>3.21.8</version>
</dependency>

<!--
必须制定okhttp3的最新版本号，
否则会出现java.lang.NoSuchMethodError: okhttp3.RequestBody.create
-->
<dependency>
    <groupId>com.squareup.okhttp3</groupId>
    <artifactId>okhttp</artifactId>
    <version>4.9.3</version>
</dependency>

<!--
必须指定与okhttp相匹配的okio的版本，否则会出现okio和okhttp的包冲突问题
java.lang.NoSuchMethodError: kotlin
-->
<dependency>
    <groupId>com.squareup.okio</groupId>
    <artifactId>okio</artifactId>
    <version>2.8.0</version>
</dependency>
（2）SpringBoot集成xml配置
#华为云obs配置
hwyun.obs.accessKey=****
hwyun.obs.securityKey=***
hwyun.obs.endPoint=***
hwyun.obs.bucketName=***
（3）配置类
package com.elink;

import com.obs.services.ObsClient;
import com.obs.services.exception.ObsException;
import lombok.Data;
import org.apache.log4j.Logger;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Configuration;

import java.text.SimpleDateFormat;
import java.util.Date;

@Data
@Configuration
public class HweiOBSConfig {

    private static final Logger log = Logger.getLogger(HweiOBSConfig.class);

    /**
     * 访问密钥AK
     */
    @Value("${hwyun.obs.accessKey}")
    private String accessKey;

    /**
     * 访问密钥SK
     */
    @Value("${hwyun.obs.securityKey}")
    private String securityKey;

    /**
     * 终端节点
     */
    @Value("${hwyun.obs.endPoint}")
    private String endPoint;

    /**
     * 桶
     */
    @Value("${hwyun.obs.bucketName}")
    private String bucketName;

    /**
     * @Description 获取OBS客户端实例
     * @return: com.obs.services.ObsClient
     */
    public ObsClient getInstance() {
        return new ObsClient(accessKey, securityKey, endPoint);
    }

    /**
     * @Description 销毁OBS客户端实例
     * @param: obsClient
     */
    public void destroy(ObsClient obsClient){
        try {
            obsClient.close();
        } catch (ObsException e) {
            log.error("obs执行失败", e);
        } catch (Exception e) {
            log.error("执行失败", e);
        }
    }

    /**
     * @Description 微服务文件存放路径
     * @return: java.lang.String
     */
    public static String getObjectKey() {
        // 项目或者服务名称 + 日期存储方式
        return "Hwei" + "/" + new SimpleDateFormat("yyyy-MM-dd").format(new Date() )+ "/";
    }
}
（4）service层业务接口
package com.elink.license.service;

import org.springframework.web.multipart.MultipartFile;

import java.io.File;
import java.io.InputStream;
import java.util.List;

/**
 * 华为云OBS服务接口
 */
public interface IHweiYunOBSService {

    /**
     * @Description 删除文件
     * @param: objectKey 文件名
     * @return: boolean 执行结果
     */
    boolean delete(String objectKey);
    
      /**
     * @Description 删除文件
     * @param: objectKey 文件路径
     * @return: boolean 执行结果
     */     
    boolean deleteFileByPath(String objectKey);

    /**
     * @Description 批量删除文件
     * @param: objectKeys 文件名集合
     * @return: boolean 执行结果
     */
    boolean delete(List<String> objectKeys);

    /**
     * @Description 上传文件
     * @param: uploadFile 上传文件
     * @param: objectKey 文件名称
     * @return: java.lang.String url访问路径
     */
    String fileUpload(MultipartFile uploadFile, String objectKey);
    String uploadFileByte(byte data[], String objectKey);
    String uploadFile(File file);

    /**
     * @Description 文件下载
     * @param: objectKey
     * @return: java.io.InputStream
     */
    InputStream fileDownload(String objectKey);
}
（5）serviceimpl业务层接口实现
package com.elink.license.service.impl;

import com.elink.HweiOBSConfig;
import com.elink.base.util.PropertiesUtil;
import com.elink.license.service.IHweiYunOBSService;
import com.obs.services.ObsClient;
import com.obs.services.exception.ObsException;
import com.obs.services.model.*;
import org.apache.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.web.multipart.MultipartFile;

import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.util.List;
import java.util.UUID;

/**
 * 华为云OBS服务业务层
 */
@Service
public class HweiYunOBSServiceImpl implements IHweiYunOBSService {

    private static final Logger log = Logger.getLogger(HweiYunOBSServiceImpl.class);


    @Autowired
    private HweiOBSConfig hweiOBSConfig;

    @Override
    public boolean delete(String objectKey) {
        ObsClient obsClient = null;
        try {
            // 创建ObsClient实例
            obsClient = hweiOBSConfig.getInstance();
            // obs删除
            obsClient.deleteObject(hweiOBSConfig.getBucketName(), objectKey);
        } catch (ObsException e) {
            log.error("obs[delete]删除保存失败", e);
        } finally {
            hweiOBSConfig.destroy(obsClient);
        }
        return true;
    }

    @Override
    public boolean deleteFileByPath(String path) {
        //path：https://wwwbak.obs.ap-southeast-1.myhuaweicloud.com/uploadFiles/xiehui/yongjiu/fujian/wode.jpg
        ObsClient obsClient = null;
        try {
            // 创建ObsClient实例
            obsClient = hweiOBSConfig.getInstance();

            String file_http_url = PropertiesUtil.readValue("file_http_url");

            File file = new File(path);
            String key = file.getName();//wode.jpg

            //realPath : uploadFiles/xiehui/yongjiu/fujian
            String realPath = path.replace(file_http_url, "");
            realPath = realPath.substring(0, realPath.lastIndexOf('/'));

            // obs删除
            obsClient.deleteObject(hweiOBSConfig.getBucketName(), realPath + "/" + key);
        } catch (ObsException e) {
            log.error("obs[deleteFileByPath]删除保存失败", e);
        } finally {
            hweiOBSConfig.destroy(obsClient);
        }
        return false;
    }

    @Override
    public boolean delete(List<String> objectKeys) {
        ObsClient obsClient = null;
        try {
            obsClient = hweiOBSConfig.getInstance();
            DeleteObjectsRequest deleteObjectsRequest = new DeleteObjectsRequest(hweiOBSConfig.getBucketName());
            objectKeys.forEach(x -> deleteObjectsRequest.addKeyAndVersion(x));
            // 批量删除请求
            obsClient.deleteObjects(deleteObjectsRequest);
            return true;
        } catch (ObsException e) {
            log.error("obs[delete]删除保存失败", e);
        } finally {
            hweiOBSConfig.destroy(obsClient);
        }
        return false;
    }

    @Override
    public String fileUpload(MultipartFile uploadFile, String objectKey) {
        ObsClient obsClient = null;
        try {
            String bucketName = hweiOBSConfig.getBucketName();
            obsClient = hweiOBSConfig.getInstance();
            // 判断桶是否存在
            boolean exists = obsClient.headBucket(bucketName);
            if (!exists) {
                // 若不存在，则创建桶
                HeaderResponse response = obsClient.createBucket(bucketName);
                log.info("创建桶成功" + response.getRequestId());
            }
            InputStream inputStream = uploadFile.getInputStream();
            long available = inputStream.available();
            PutObjectRequest request = new PutObjectRequest(bucketName, objectKey, inputStream);

            ObjectMetadata objectMetadata = new ObjectMetadata();
            objectMetadata.setContentLength(available);
            request.setMetadata(objectMetadata);
            // 设置对象访问权限为公共读
            request.setAcl(AccessControlList.REST_CANNED_PUBLIC_READ);
            PutObjectResult result = obsClient.putObject(request);

            // 读取该已上传对象的URL
            log.info("已上传对象的URL" + result.getObjectUrl());
            return result.getObjectUrl();
        } catch (ObsException e) {
            log.error("obs[fileUpload]上传失败", e);
        } catch (IOException e) {
            log.error("[fileUpload]上传失败", e);
        } finally {
            hweiOBSConfig.destroy(obsClient);
        }
        return null;
    }

    @Override
    public String uploadFileByte(byte[] data, String fileName) {
        try {
            ObsClient obsClient = null;
            String bucketName = hweiOBSConfig.getBucketName();
            obsClient = hweiOBSConfig.getInstance();
            // 判断桶是否存在
            boolean exists = obsClient.headBucket(bucketName);
            if (!exists) {
                // 若不存在，则创建桶
                HeaderResponse response = obsClient.createBucket(bucketName);
                log.info("创建桶成功" + response.getRequestId());
            }

            String file_http_url = PropertiesUtil.readValue("file_http_url");

            //转为File
            InputStream inputStream = new ByteArrayInputStream(data);
            String prefix = fileName.substring(fileName.lastIndexOf(".") + 1);//后缀
            String uuid = UUID.randomUUID().toString().replace("-", "");//customer_YYYYMMDDHHMM
            fileName = uuid + "." + prefix; //文件全路径
            obsClient.putObject(bucketName, fileName.substring(0, fileName.lastIndexOf("/")) + "/" + fileName, inputStream);
            return file_http_url + fileName;
        } catch (ObsException e) {
            log.error("obs[uploadFileByte]上传失败", e);
        }
        return null;
    }

    @Override
    public String uploadFile(File file) {
        ObsClient obsClient = null;
        try {
            String bucketName = hweiOBSConfig.getBucketName();
            obsClient = hweiOBSConfig.getInstance();
            // 判断桶是否存在
            boolean exists = obsClient.headBucket(bucketName);
            if (!exists) {
                // 若不存在，则创建桶
                HeaderResponse response = obsClient.createBucket(bucketName);
                log.info("创建桶成功" + response.getRequestId());
            }

            String file_http_url = PropertiesUtil.readValue("file_http_url");

            //转为File
            String filename = file.getName();
            String prefix = filename.substring(filename.lastIndexOf(".") + 1);//后缀
            String uuid = UUID.randomUUID().toString().replace("-", "");//customer_YYYYMMDDHHMM
            String fileName = uuid + "." + prefix; //文件全路径
            obsClient.putObject(bucketName, fileName.substring(0, fileName.lastIndexOf("/")) + "/" + fileName, file);
            return file_http_url + fileName;
        } catch (Exception e) {
            log.error("obs[uploadFile]上传失败", e);
        } finally {
            hweiOBSConfig.destroy(obsClient);
        }
        return null;
    }

    @Override
    public InputStream fileDownload(String objectKey) {
        ObsClient obsClient = null;
        try {
            String bucketName = hweiOBSConfig.getBucketName();
            obsClient = hweiOBSConfig.getInstance();
            ObsObject obsObject = obsClient.getObject(bucketName, objectKey);
            return obsObject.getObjectContent();
        } catch (ObsException e) {
            log.error("obs[fileDownload]文件下载失败", e);
        } finally {
            hweiOBSConfig.destroy(obsClient);
        }
        return null;
    }
}
（6）controller控制层
package com.elink.license.controller;

import com.elink.license.service.IHweiYunOBSService;
import com.elink.license.util.StringUtils;
import com.elink.share.result.Result;
import com.elink.share.result.ResultCodeWraper;
import com.obs.services.exception.ObsException;
import org.apache.commons.io.IOUtils;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.*;
import java.net.HttpURLConnection;
import java.net.URL;
import java.net.URLEncoder;
import java.util.List;
import java.util.Map;
import java.util.UUID;

/**
 * OBS服务器Controller
 */

@RestController
@RequestMapping({"file"})
public class HweiYunOBSController {

    @Resource
    private IHweiYunOBSService hweiYunOBSService;


    /**
     * upload
     * 上传 file类型文件
     * @param file
     * @return
     */
    @RequestMapping(value = "upload", method = RequestMethod.POST)
    public Map save(@RequestParam(value = "file", required = false) MultipartFile file) {
        if (StringUtils.isEmpty(file)) {
            return new Result<>(ResultCodeWraper.REQUEST_ERROR, "文件为空");
        }
        final String test = hweiYunOBSService.fileUpload(file, file.getOriginalFilename());
        return new Result<>(ResultCodeWraper.SUCCESS, test);
    }


    /**
     * 下载文件
     * /download/123.jpg
     * 注意：此处未将文件名写在路径最后，是因为使用rest方法去下载文件的话，这个方法是会自动截取文件名的后缀，传入的参数将是123，下载后的文件也将丢失后缀
     * {fileName}/download
     *
     * @param request
     * @param response
     * @param fileName
     * @return
     */
    @RequestMapping(value = "{fileName}/download", method = RequestMethod.POST)
    public Map download(HttpServletRequest request, HttpServletResponse response, @PathVariable String fileName) {
        if (StringUtils.isEmpty(fileName)) {
            return new Result<>(ResultCodeWraper.REQUEST_ERROR, "下载文件为空");
        }
        try (
                InputStream inputStream = hweiYunOBSService.fileDownload(fileName);
                BufferedOutputStream outputStream = new BufferedOutputStream(response.getOutputStream())) {
            if (inputStream == null) {
                return new Result<>(ResultCodeWraper.REQUEST_ERROR, "内部错误");
            }
            // 为防止 文件名出现乱码
            final String userAgent = request.getHeader("USER-AGENT");
            // IE浏览器
            if (userAgent.indexOf("MSIE") > -1) {
                fileName = URLEncoder.encode(fileName, "UTF-8");
            } else {
                // google,火狐浏览器
                if (userAgent.indexOf("Mozilla") > -1) {
                    fileName = new String(fileName.getBytes(), "ISO8859-1");
                } else {
                    // 其他浏览器
                    fileName = URLEncoder.encode(fileName, "UTF-8");
                }
            }
            response.setContentType("application/x-download");
            // 设置让浏览器弹出下载提示框，而不是直接在浏览器中打开
            response.addHeader("Content-Disposition", "attachment;filename=" + fileName);
            IOUtils.copy(inputStream, outputStream);
            return null;
        } catch (IOException | ObsException e) {
            return new Result<>(ResultCodeWraper.REQUEST_ERROR, "内部错误");
        }
    }


    /**
     * 上传文件---直接传file
     *
     * @return
     */
    public Map uploadFile(File file) {

        if (StringUtils.isEmpty(file)) {
            return new Result<>(ResultCodeWraper.REQUEST_ERROR, "文件为空");
        }
        final String test = hweiYunOBSService.uploadFile(file);
        return new Result<>(ResultCodeWraper.SUCCESS, test);

    }

    /**
     * 上传文件---byte类型
     *
     * @return
     */
    public Map uploadFileByte(byte data[], String fileName) {
        if (StringUtils.isEmpty(fileName)) {
            return new Result<>(ResultCodeWraper.REQUEST_ERROR, "文件为空");
        }
        final String test = hweiYunOBSService.uploadFileByte(data, fileName);
        return new Result<>(ResultCodeWraper.SUCCESS, test);
    }

    /**
     * 下载ObsObject
     * @param filePath   需要下载的文件路径。 例："site/a.txt"
     * @return  下载文件的字节数组
     * @throws IOException
     */
    public byte[] getFileByteArray(String filePath) throws IOException {
        //filePath : uploadFiles/xiehui/yongjiu/fujian/wode.jpg
        InputStream input = hweiYunOBSService.fileDownload(filePath.substring(0,filePath.lastIndexOf("/")) + "/" + filePath);
        byte[] b = new byte[1024];
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        int len;
        while ((len = input.read(b)) != -1){
            bos.write(b, 0, len);
        }
        bos.close();
        input.close();
        return bos.toByteArray();
    }


    /**
     * 删除文件
     * 根据文件名称删除
     * @param fileName
     * @return
     */
    @RequestMapping(value = "{fileName}/delete", method = RequestMethod.POST)
    public Map delete(@PathVariable String fileName) {
        if (StringUtils.isEmpty(fileName)) {
            return new Result<>(ResultCodeWraper.REQUEST_ERROR, "删除文件为空");
        }
        final boolean delete = hweiYunOBSService.delete(fileName);
        return new Result<>(delete ? ResultCodeWraper.SUCCESS : ResultCodeWraper.REQUEST_ERROR, delete);
    }

    /**
     * delete
     * 批量删除
     *
     * @param fileNames
     * @return
     */
    @RequestMapping(value = "deletes", method = RequestMethod.POST)
    public Map delete(@RequestParam("fileNames") List<String> fileNames) {
        if (StringUtils.isEmpty(fileNames)) {
            return new Result<>(ResultCodeWraper.REQUEST_ERROR, "删除文件为空");
        }
        final boolean delete = hweiYunOBSService.delete(fileNames);
        return new Result<>(delete ? ResultCodeWraper.SUCCESS : ResultCodeWraper.REQUEST_ERROR, delete);
    }

}
（7）帮助类
    /**
     * 得到文件流
     *
     * @param url 网络图片URL地址
     * @return
     */
    public static byte[] getFileStream(String url) {
        try {
            URL httpUrl = new URL(url);
            HttpURLConnection conn = (HttpURLConnection) httpUrl.openConnection();
            conn.setRequestMethod("GET");
            conn.setConnectTimeout(5 * 1000);
            InputStream inStream = conn.getInputStream();//通过输入流获取图片数据
            byte[] btImg = readInputStream(inStream);//得到图片的二进制数据
            return btImg;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 从输入流中获取数据
     *
     * @param inStream 输入流
     * @return
     * @throws Exception
     */
    public static byte[] readInputStream(InputStream inStream) throws Exception {
        ByteArrayOutputStream outStream = new ByteArrayOutputStream();
        byte[] buffer = new byte[1024];
        int len = 0;
        while ((len = inStream.read(buffer)) != -1) {
            outStream.write(buffer, 0, len);
        }
        inStream.close();
        return outStream.toByteArray();
    }

    /**
     * file转byte
     */
    public static byte[] file2byte(File file) {
        byte[] buffer = null;
        try {
            FileInputStream fis = new FileInputStream(file);
            ByteArrayOutputStream bos = new ByteArrayOutputStream();
            byte[] b = new byte[1024];
            int n;
            while ((n = fis.read(b)) != -1) {
                bos.write(b, 0, n);
            }
            fis.close();
            bos.close();
            buffer = bos.toByteArray();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return buffer;
    }

    /**
     * byte 转file
     */
    public static File byte2File(byte[] buf, String filePath, String fileName) {
        BufferedOutputStream bos = null;
        FileOutputStream fos = null;
        File file = null;
        try {
            File dir = new File(filePath);
            if (!dir.exists() && dir.isDirectory()) {
                dir.mkdirs();
            }
            file = new File(filePath + File.separator + fileName);
            fos = new FileOutputStream(file);
            bos = new BufferedOutputStream(fos);
            bos.write(buf);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (bos != null) {
                try {
                    bos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (fos != null) {
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        return file;
    }

    /**
     * multipartFile转File
     **/
    public static File multipartFile2File(MultipartFile multipartFile) {
        File file = null;
        if (multipartFile != null) {
            try {
                file = File.createTempFile("tmp", null);
                multipartFile.transferTo(file);
                System.gc();
                file.deleteOnExit();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return file;
    }

二、Ftp文件存储

（1）配置类
package com.ruoyi.file.config;

import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

/**
 * @author yfl
 * @date 2023/03/25
 */
@Configuration
public class ImgConfig implements WebMvcConfigurer {
    @Override
    public void addResourceHandlers(ResourceHandlerRegistry registry) {
        registry.addResourceHandler("/upload/**") //虚拟url路径
                .addResourceLocations("file:/home/cgt/img/"); //真实本地路径
    }
}

        这个配置类至关重要，为了解决文件无法直接访问的问题。

（2）文件上传接口
package com.file.service;

import org.springframework.web.multipart.MultipartFile;

/**
 * 文件上传接口
 */
public interface ISysFileService{
    /**
     * 文件上传接口
     * 
     * @param file 上传的文件
     * @return 访问地址
     * @throws Exception
     */
    public String uploadFile(MultipartFile file) throws Exception;
}

（3）实现类

package com.file.service;

import cn.hutool.core.date.DateTime;
import com.jcraft.jsch.*;
import com.ruoyi.file.utils.IDUtils;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Primary;
import org.springframework.stereotype.Service;
import org.springframework.web.multipart.MultipartFile;

import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;

/**
 * @author yfl
 * @date 2023/03/25
 */
@Slf4j
@Service
@Primary
public class FtpSysFileServiceImpl implements ISysFileService {

    /**
     * ftp服务器ip地址
     */
    @Value("${ftp.host}")
    public String host;

    /**
     * 端口
     */
    @Value("${ftp.port}")
    public int port;

    /**
     * 用户名
     */
    @Value("${ftp.userName}")
    public String userName;

    /**
     * 密码
     */
    @Value("${ftp.password}")
    public String password;

    /**
     * 存放图片的根目录
     */
    @Value("${ftp.rootPath}")
    public String rootPath;

    /**
     * 存放图片的路径
     */
    @Value("${ftp.img.url}")
    public String imgUrl;

    /**
     *  将图片上传到 nginx
     * @param uploadFile 文件上传
     * @return 结果
     */
    public String uploadFile(MultipartFile uploadFile) {
        //1、给上传的图片生成新的文件名
        //1.1获取原始文件名
        String oldName = uploadFile.getOriginalFilename();
        //1.2使用IDUtils工具类生成新的文件名，新文件名 = newName + 文件后缀
        String newName = IDUtils.genImageName();
        assert oldName != null;
        newName = newName + oldName.substring(oldName.lastIndexOf("."));
        //1.3生成文件在服务器端存储的子目录
        // 每天都会新建一个文件夹
        String filePath = new DateTime().toString("/yyyyMMdd/");
        //2、把图片上传到图片服务器
        //2.1获取上传的io流
        InputStream input = null;
        try {
            input = uploadFile.getInputStream();
        } catch (IOException e) {
            e.printStackTrace();
        }
        //2.2调用FtpUtil工具类进行上传
        return putImages(input, filePath, newName);
    }

    /**
     * 获取连接
     */
    public ChannelSftp getChannel() throws Exception {
        JSch jsch = new JSch();
        //->ssh root@host:port
        Session sshSession = jsch.getSession(userName, host, port);
        //密码
        sshSession.setPassword(password);
        Properties sshConfig = new Properties();
        sshConfig.put("StrictHostKeyChecking", "no");
        sshSession.setConfig(sshConfig);
        sshSession.connect();
        Channel channel = sshSession.openChannel("sftp");
        channel.connect();
        return (ChannelSftp) channel;
    }

    /**
     * ftp上传图片
     *
     * @param inputStream 图片io流
     * @param imagePath   路径，不存在就创建目录
     * @param imagesName  图片名称
     * @return urlStr 图片的存放路径
     */
    public String putImages(InputStream inputStream, String imagePath, String imagesName) {
        try {
            ChannelSftp sftp = getChannel();
            String path = rootPath + imagePath + "/";
            createDir(path, sftp);
            //上传文件
            sftp.put(inputStream, path + imagesName);
            log.info("上传成功！");
            sftp.quit();
            sftp.exit();
            //处理返回的路径
            String resultFile;
            resultFile = imgUrl + imagePath + imagesName;
            return resultFile;
        } catch (Exception e) {
            log.error("上传失败：" + e.getMessage());
        }
        return "";
    }

    /**
     * 创建目录
     */
    private static void createDir(String path, ChannelSftp sftp) throws SftpException {
        String[] folders = path.split("/");
        sftp.cd("/");
        for (String folder : folders) {
            if (folder.length() > 0) {
                try {
                    sftp.cd(folder);
                } catch (SftpException e) {
                    sftp.mkdir(folder);
                    sftp.cd(folder);
                }
            }
        }
    }

    /**
     * 删除图片
     */
    public void delImages(String imagesName) {
        try {
            ChannelSftp sftp = getChannel();
            String path = rootPath + imagesName;
            sftp.rm(path);
            sftp.quit();
            sftp.exit();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

（3）控制层

package com.file.controller;

import com.balledu.common.core.domain.R;
import com.balledu.common.core.utils.SpringUtils;
import com.balledu.common.core.utils.file.FileUtils;
import com.balledu.system.api.domain.SysFile;
import com.ruoyi.file.service.ISysFileService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.cloud.context.config.annotation.RefreshScope;
import org.springframework.web.bind.annotation.CrossOrigin;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.multipart.MultipartFile;

/**
 * 文件请求处理
 */
@CrossOrigin
@RefreshScope
@RestController
public class SysFileController{
    private static final Logger log = LoggerFactory.getLogger(SysFileController.class);

    @Value("${active}")
    private String active;

    /**
     * 文件上传请求
     */
    @PostMapping("upload")
    public R<SysFile> upload(MultipartFile file){
        try{
            ISysFileService sysFileService = null;
            switch (active){
                case "file":
                case "ftp":
                    sysFileService = (ISysFileService)SpringUtils.getBean(  "ftpSysFileServiceImpl");
                    break;
            }
            String url = sysFileService.uploadFile(file);
            SysFile sysFile = new SysFile();
            sysFile.setName(FileUtils.getName(url));
            sysFile.setUrl(url);
            return R.ok(sysFile);
        }
        catch (Exception e)
        {
            log.error("上传文件失败", e);
            return R.fail(e.getMessage());
        }
    }
}

        上面这种写法可以扩展多种文件存储

Mryfl
关注
  • 7
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
华为云obs在java中的使用
12-01 983
下载后，请在java项目里面以本地形式引入。1、申请obs服务。
java创建FTP服务器创建文件,java ftp服务器创建文件夹
weixin_34322238的博客
08-12 1293
java ftp服务器创建文件夹 内容精选换一换已成功登录Java性能分析。待安装分析辅助软件的服务器已开启sshd。Java性能分析优先选用非交互shell(non-interactive shell)中的JAVA_HOME环境变量所指定的JRE版本运行分析辅助软件，其次选用非交互shell(non-interactive shell)中的PATH环境变量能发现的java命令运行分析已成功登录J...
【对象存储】SpringBoot集成华为云OBS对象存储
Infinity的博客
04-25 918
总体思路是后端向华为云OBS服务器申请授权信息并设置过期时间，后端再将授权信息以Map形式发给前端，前端将文件和授权信息直接发给华为云OBS服务器。
华为云依赖引入错误
qq_42108331的博客
07-25 606
华为云依赖引入错误
java对接华为云obs
HUHAO987654321的博客
11-29 1055
log.error("上传失败文件为空或者超过200M:{}", LogExceptionStackUtil.logExceptionStack(e));log.error("obs上传失败:{}", LogExceptionStackUtil.logExceptionStack(e));log.error("文件下载失败{}", LogExceptionStackUtil.logExceptionStack(e));log.info("生成的文件访问名：{}", objectKey);
Java集成华为云对象存储
青春不打烊的博客
07-06 1987
java封装华为云对象存储
华为云OBS配置及Java代码访问
adminstate的博客
03-30 1015
springboot集成华为云obs
华为云OBS连接Java
m0_66519237的博客
09-18 1125
以上就是连接华为云OBS的基本步骤，具体操作还需根据需求进行相应调整。下载OBS Java SDK，并将SDK添加到项目中。创建OBSClient对象，以便与OBS服务器交互。
源码 SpringBoot 文件管理(支持FastDFS/FTP/阿里/华为OBS/天翼云/联通云/移动云)源代码
04-13
可支持FastDFS存储、FTP存储、天翼云存储、华为云存储（OBS）、阿里云存储（OSS）、移动云。可通过配置自动切换存储类型。本微服务支持临时文件24小时自动删除、文件下载。本资源也包含了Github更新地址
java监控ftp文件服务器文件变化,java监控服务器上ftp文件夹变动
weixin_29704001的博客
08-06 1287
java监控服务器上ftp文件夹变动 内容精选换一换添加节点时提示“添加节点失败，节点已存在”，如图1所示。待添加节点的服务器上已安装系统性能分析或者添加过节点。如果待添加节点的服务器上已安装系统性能分析，需要登录服务器卸载系统性能分析，详细步骤请参见卸载，卸载成功后重新添加节点。卸载前请确认服务器上安装的系统性能分析没有在使用。如果工具卸载失败，需要手动删除“/home/malluma/添加节点...
向ftp服务器上传文件 java,java实现文件上传到ftp服务器上
weixin_34885746的博客
08-09 1140
java实现文件上传到ftp服务器上 内容精选换一换域名认证时，需要将下载的认证文件上传到网站根目录，然后进行认证。用户使用的服务器不同，文件上传的位置有所不同，请参照以下方法完成认证文件的上传。如果网站所使用的服务器是Tomcat、Apache、IIS、WebLogic服务器，请执行以下操作步骤。如果是非root用户，登录后，执行su -root命令切换到root用户。以下的操作仅为示例本教程旨...
华为云鲲鹏服务器部署文档-java微服务.pdf
05-09
华为云鲲鹏服务器部署java微服务的基础软件环境，所有操作均实测通过。包括CentOS 7.6 64bit ARM版基础操作，JDK设置，maven，camke，gcc，node.js，zookeeper，redis，mysql 8.0.17，nginx，golang等等的安装与设置。
华为云 OBS esdk-obs-java
12-26
华为云 后端 OBS 上传图片，文件 sdk maven 引入 <dependency> <groupId>com.huaweicloud</groupId> <artifactId>esdk-obs-java</artifactId> <version>3.21.11</version> </dependency>
Ai+若依（文件存储--阿里云为例）：【09篇】
最新发布
qq_60281421的博客
09-02 627
Ai+若依（文件存储--阿里云为例）：【09篇】
java 对接OBS系统
weixin_45128512的博客
01-11 791
3.具体方法调用,参数要替换成对应的值：域名：domain;桶名：bucketName;4.OBS的一些参数生成规则方法。2. OBS相关配置信息。5.OBS具体方法调用。
java上传图片到华为云
m0_57519941的博客
09-22 428
需要这三个条件就可以将图片上传到华为云了后续会加入删除或者下载目前没用到。endPoint 是地址也就是终端地址也是在控制台或者问甲方要就可以了。ak是甲方提供如果自己测试的话就到华为云的控制台进行创建就可以了。引入依赖然后复制黏贴就可以了。
java 后台实现华为云文件下载服务
FightingITPanda的博客
11-05 1016
需求背景： 页面’点击下载‘拿到这条数据id，去后台查这条数据的华为云文件地址，下载文件，效果如下。。 实战： step one: 拿前台传过来的id去库里查这条数据文件的华为云地址 //1、获取华为云地址 String fileUrl = ""; try{ fileUrl = letterManageService.letterDownload(letterId); }catch(BusinessException e){ logger.info("获取华为云地址失败。。失败原因："+
java集成华为云obs上传下载实战
老徐的博客只有干货
02-12 7178
说明 最近项目上需要开发一个服务去和华为云OBS集成获取一些业务上的文件，此处记录一下简单的java集成obs的入门，希望对大家快速入门有所帮助：） 实现效果 上传对象 下载到本地 操作步骤 1.开通obs 上华为云官网，注册账号后购买，支付后进入控制台。 2.获取ak/sk等信息 参考： https://support.huaweicloud.com/eihealth_faq/eihealth_27_0007.html 3.获取官方java demo https://github.com/hua
华为云obs上传下载
weixin_44862933的博客
02-02 831
华为云obs上传下载粘贴复制即可使用。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值