基于springboot架构的读取excel 图片并自动上传

简介: 基于springboot架构的读取excel 图片并自动上传


基于springboot架构的读取excel 图片并自动上传


excel 图片上传

页面准备 comment.html

image.png

image.png

image.png



代码如下:

<a class="btn btn-info" onclick="$.table.importExcel()">
    <i class="fa fa-upload"></i> 导入
</a>
<!-- 导入区域 -->
<form id="importForm" enctype="multipart/form-data" class="mt20 mb10" style="display: none;">
  <div class="col-xs-offset-1">
    <input type="file" id="file" name="file"/>
    <!--<div class="mt10 pt5">
            <input type="checkbox" id="updateSupport" name="updateSupport" title="如果登录账户已经存在,更新这条数据。"> 是否更新已经存在的用户数据
            &nbsp;  <a onclick="$.table.importTemplate()" class="btn btn-default btn-xs"><i class="fa fa-file-excel-o"></i> 下载模板</a>
        </div>-->
    <font color="red" class="pull-left mt10">
      提示:仅允许导入“xls”或“xlsx”格式文件!
    </font>
  </div>
</form>


js代码如下:

   // 导入数据
   importExcel: function(formId) {
    var currentId = $.common.isEmpty(formId) ? 'importForm' : formId;
    $.form.reset(currentId);
    layer.open({
      type: 1,
      area: ['400px', '230px'],
      fix: false,
      //不固定
      maxmin: true,
      shade: 0.3,
      title: '导入' + $.table._option.modalName + '数据',
      content: $('#' + currentId),
      btn: ['<i class="fa fa-check"></i> 导入', '<i class="fa fa-remove"></i> 取消'],
      // 弹层外区域关闭
      shadeClose: true,
      btn1: function(index, layero){
        var file = layero.find('#file').val();
        if (file == '' || (!$.common.endWith(file, '.xls') && !$.common.endWith(file, '.xlsx'))){
          $.modal.msgWarning("请选择后缀为 “xls”或“xlsx”的文件。");
          return false;
        }
        var index = layer.load(2, {shade: false});
        $.modal.disable();
        var formData = new FormData();
        formData.append("file", $('#file')[0].files[0]);
        formData.append("updateSupport", $("input[name='updateSupport']").is(':checked'));
        $.ajax({
          url: $.table._option.importUrl,
          data: formData,
          cache: false,
          contentType: false,
          processData: false,
          type: 'POST',
          success: function (result) {
            if (result.code == web_status.SUCCESS) {
              $.modal.closeAll();
              $.modal.alertSuccess(result.msg);
              $.table.refresh();
            } else if (result.code == web_status.WARNING) {
              layer.close(index);
              $.modal.enable();
                        $.modal.alertWarning(result.msg)
                    } else {
              layer.close(index);
              $.modal.enable();
              $.modal.alertError(result.msg);
            }
          }
        });
      }
    });
   }


逻辑处理准备

控制类CommentController.java

image.png

    @PostMapping("/importData")
    @ResponseBody
    public AjaxResult importData(MultipartFile file)
    {
        //导入数据
        AjaxResult ajaxResult = commentService.importData(file);
        return ajaxResult;
    }


接口类ICommentService.java

  /**
   * 导入数据
   * @param file
   * @return
   */
    AjaxResult importData(MultipartFile file);


接口实现类CommentServiceImpl.java

/**
 * 导入数据
 * @param file
 * @return
 */
@Override
@Transactional(rollbackFor = Exception.class)
public AjaxResult importData(MultipartFile file) {
  //获取所有的内容
  try {
    //System.out.println("================"+file.getOriginalFilename());
    Map<String, Map<Integer, Map<Integer, String>>> sheets = UploadUtil.readExcelToMap(file);
    if (sheets != null) {
      Set<String> keys = sheets.keySet();
      List<String> steetsNames = new ArrayList<>();
      //获取所有的页名称
      for (String steetsName : keys) {
        steetsNames.add(steetsName);
      }
      //遍历所有的sheet
      //for (int i = 0; i < sheets.size(); i++) {
        //根据页名称获取页 这里我只获取第一个sheet表格内容
        Map<Integer, Map<Integer, String>> rows = sheets.get(steetsNames.get(0));
        //System.out.println("页名称:"+steetsNames.get(0));
        //根据所有的行 遍历
        for (int j = 1; j < rows.size(); j++) {
          Map<Integer, String> columns = rows.get(j);
          //System.out.println("columns:"+columns.toString());
          //========以下是业务处理逻辑,取出数据并保存==========
          //设置参数并保存
          Comment comment = new Comment();
          //考种 //图书系列
          String examName = columns.get(0);
          String typeName = columns.get(1);
          if (StringUtils.isNotEmpty(examName) && StringUtils.isNotEmpty(typeName)) {
            Exam exam = examMapper.selectExamByName(examName);
            if (exam != null) {
              Type type = typeMapper.selectTypeByParam(typeName,exam.getId());
              if (type != null) {
                comment.setTypeCode(type.getTypeCode());
              }
            }
          }
          //用户头像
          if (StringUtils.isNotEmpty(columns.get(2))) {
            comment.setHeadImageUrl(columns.get(2));
          }else {
            comment.setHeadImageUrl(Constants.OFFICAL_ICON);
          }
          //用户昵称
          comment.setNickName(columns.get(3));
          //评价内容
          comment.setContent(columns.get(4));
          //图片
          if (StringUtils.isEmpty(columns.get(5)) && StringUtils.isEmpty(columns.get(6))  && StringUtils.isEmpty(columns.get(7)) ) {
            //无图
            comment.setCommentType(Constants.COMMENT_TYPE.NO.getValue());
          }else {
            //有图
            comment.setCommentType(Constants.COMMENT_TYPE.YES.getValue());
            String originalUrls = "";
            if (StringUtils.isNotEmpty(columns.get(5)) ) {
              originalUrls = originalUrls + columns.get(5) + ",";
            }
            if (StringUtils.isNotEmpty(columns.get(6)) ) {
              originalUrls = originalUrls + columns.get(6) + ",";
            }
            if (StringUtils.isNotEmpty(columns.get(7)) ) {
              originalUrls = originalUrls + columns.get(7);
            }
            if(StringUtils.isNotEmpty(originalUrls) && originalUrls.endsWith(",")){
              originalUrls = originalUrls.substring(0,originalUrls.length()-1);
            }
            String smallUrls = ThumbnailGenUtil.getThumbnailUrlByMulti(originalUrls);
            if(StringUtils.isNotEmpty(smallUrls) && smallUrls.endsWith(",")){
              smallUrls = smallUrls.substring(0,smallUrls.length()-1);
            }
            comment.setOriginalUrls(originalUrls);
            comment.setSmallUrls(smallUrls);
          }
          comment.setStatus(Constants.STATUS.ACTIVE.getValue());
          insertComment(comment);
          //标签
          String col8 = columns.get(8);
          if (col8 != null ) {
            if (col8.contains(",") || col8.contains(",")) {
               col8 = col8.replace(",", ",");
              //多个标签
              String[] split = col8.split(",");
              for (String s : split) {
                Mark mark = markMapper.selectMarkByName(s);
                if (mark != null) {
                  CommentMark commentMark = new CommentMark();
                  commentMark.setCommentId(comment.getId());
                  commentMark.setMarkId(mark.getId());
                  commentMark.setIsValid(Constants.IS_VALID.YES.getValue());
                  commentMark.setCreateUser(ShiroUtils.getUserId());
                  commentMark.setCreateDate(new Date());
                  commentMarkMapper.insertCommentMark(commentMark);
                }
              }
            }else {
              //一个标签
              Mark mark = markMapper.selectMarkByName(col8);
              if (mark != null) {
                CommentMark commentMark = new CommentMark();
                commentMark.setCommentId(comment.getId());
                commentMark.setMarkId(mark.getId());
                commentMark.setIsValid(Constants.IS_VALID.YES.getValue());
                commentMark.setCreateUser(ShiroUtils.getUserId());
                commentMark.setCreateDate(new Date());
                commentMarkMapper.insertCommentMark(commentMark);
              }
            }
          }
          //===============业务数据处理结束=====================
        }
      //}
      return AjaxResult.success();
    }
  }catch (Exception e) {
    //异常回滚
    TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
    e.printStackTrace();
  }
  return AjaxResult.error();
}


读取表格内容工具类UploadUtil.java

package com.dongao.project.utils;
import com.dongao.project.config.ConfigConstant;
import com.qcloud.cos.model.ObjectMetadata;
import org.apache.poi.POIXMLDocumentPart;
import org.apache.poi.hssf.usermodel.*;
import org.apache.poi.ss.usermodel.*;
import org.apache.poi.xssf.usermodel.*;
import org.openxmlformats.schemas.drawingml.x2006.spreadsheetDrawing.CTMarker;
import org.springframework.web.multipart.MultipartFile;
import java.io.*;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
/**
 * Created by nao'nao on 2020/4/17.
 */
public class UploadUtil {
    /**
     * 读取文件内容到map
     * @param file
     * @return
     * @throws IOException
     */
    public static Map<String, Map<Integer, Map<Integer, String>>> readExcelToMap(MultipartFile file) throws IOException {
        Workbook wb = null;
        Sheet sheet = null;
        Row row = null;
        // 声明所有页的集合
        Map<String, Map<Integer, Map<Integer, String>>> mapSheet = new LinkedHashMap<>();
        try {
      //读取文档
            wb = readExcel(file);
            if (wb != null) {
                // 获取总页数
                int pageSize = wb.getNumberOfSheets();
                //System.out.println("总页数:"+pageSize);
                for (int i = 0; i < pageSize; i++) {
                    // 声明当前页的行和列
                    Map<Integer, Map<Integer, String>> map = new HashMap<>();
                    // 获取当前页
                    sheet = wb.getSheetAt(i);
                    //声明当前页图片的集合
                    Map<String, PictureData> pMap = null;
                    //获取当前页的所有图片
                    if(file.getOriginalFilename().endsWith(".xls")){
            //用于区分 没写方法重载
                        pMap = getPictures1((HSSFSheet) sheet); 
                    }else{
            //用于区分 没写方法重载
                        pMap = getPictures2((XSSFSheet) sheet); 
                    }
          //获取页名称
                    String sheetName = sheet.getSheetName(); 
                    //获取当前页的最大行数
                    int rowSize = sheet.getPhysicalNumberOfRows();
            //System.out.println("总行数:"+rowSize);
                    //System.out.println("遍历所有行");
                    for (int j = 0; j < rowSize; j++) {
                        //System.out.println("获取第"+j+"行");
                        row = sheet.getRow(j);
                        //获取当前页的最大列数;
                        int columnSize = row.getPhysicalNumberOfCells();
                        // 声明当前列
                        Map<Integer, String> columnMap = new HashMap<>();
              //System.out.println("列大小:"+columnSize);
                        for (int j2 = 0; j2 < columnSize; j2++) {
                            // System.out.println("获取第"+j2+"列的内容");
                            String value = (String)getCellFormatValue(row.getCell(j2));
                            // 添加当前列的内容 j2代表第几列 value是内容
                            columnMap.put(j2, value);
                        }
                        // 添加当前行的内容 j代表第几行 value是列的内容 意思是第几行第几列的内容
                        map.put(j, columnMap);
                    }
                    //解析图片并上传到服务器 进行文件上传后 返回上传地址 并根据图片所在的表格位置 赋值表格位置为 上传后的返回地址
                    Object key[] = pMap.keySet().toArray();
                    //上传图片 腾讯云上传图片
                    CosClientUtil cosClientUtil = new CosClientUtil();
                    for (int v = 0; v < pMap.size(); v++) {
                        //获取图像数据对象
                        PictureData pic = pMap.get(key[v]);
                        //获取文件名称
                        String picName = key[v].toString();
            //获取文件后缀名
            String ext = pic.suggestFileExtension();
            //=============本地测试图片上传开始==============
            FileOutputStream out = new FileOutputStream("D:\\" + picName + "." + ext);
            out.write(data);
            out.flush();
            out.close();
            //=============本地测试图片上传结束==============
                        //===============腾讯云上传图片上传开始==============
                        String imgToCos = cosClientUtil.simpleUploadImgToCos(pic, ConfigConstant.comment);
                        //String imgToCos = "22222222";
            //===============腾讯云上传图片上传结束==============
                        //解析key 并根据key 设置 某一行的某一列的 图片链接
                        String[] split = picName.split("-");
                        Integer rowIndex = Integer.parseInt(split[0].toString()),columnIndex = Integer.parseInt(split[1].toString());
                        //根据行下标 获取所有的列
                        Map<Integer, String> columns = map.get(rowIndex);
                        //根据列下标 设置图片链接值
                        //参数2为图片上传后的路径
                        columns.put(columnIndex, imgToCos);
                    }
                    // 添加当前页的所有内容
                    mapSheet.put(sheetName, map);
                }
            }
            return mapSheet;
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }
    // 读取excel
    private static Workbook readExcel(MultipartFile file) {
        Workbook wb = null;
        if (file == null) {
            return null;
        }
        String originalFilename = file.getOriginalFilename();
        String extString = originalFilename.substring(originalFilename.lastIndexOf("."));
        InputStream is = null;
        try {
            is = file.getInputStream();
            if (".xls".equals(extString)) {
                return wb = new HSSFWorkbook(is);
            } else if (".xlsx".equals(extString)) {
                return wb = new XSSFWorkbook(is);
            } else {
                return wb = null;
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return wb;
    }
    // 读取图片
    public static Map<String, PictureData> getPictures1(HSSFSheet sheet) throws IOException {
        Map<String, PictureData> map = new HashMap<String, PictureData>();
        List<HSSFShape> list = sheet.getDrawingPatriarch().getChildren();
        for (HSSFShape shape : list) {
            if (shape instanceof HSSFPicture) {
                HSSFPicture picture = (HSSFPicture) shape;
                HSSFClientAnchor cAnchor = (HSSFClientAnchor) picture.getAnchor();
                PictureData pdata = picture.getPictureData();
                String key = cAnchor.getRow1() + "-" + cAnchor.getCol1(); // 行号-列号
                map.put(key, pdata);
            }
        }
        return map;
    }
    //读取图片
    public static Map<String, PictureData> getPictures2(XSSFSheet sheet) throws IOException {
        Map<String, PictureData> map = new HashMap<String, PictureData>();
        List<POIXMLDocumentPart> list = sheet.getRelations();
        for (POIXMLDocumentPart part : list) {
            if (part instanceof XSSFDrawing) {
                XSSFDrawing drawing = (XSSFDrawing) part;
                List<XSSFShape> shapes = drawing.getShapes();
                for (XSSFShape shape : shapes) {
                    XSSFPicture picture = (XSSFPicture) shape;
                    XSSFClientAnchor anchor = picture.getPreferredSize();
                    CTMarker marker = anchor.getFrom();
                    String key = marker.getRow() + "-" + marker.getCol();
                    map.put(key, picture.getPictureData());
                }
            }
        }
        return map;
    }
    //获取表格字段属性
    private static Object getCellFormatValue(Cell cell) {
        Object cellValue = null;
        if (cell != null) {
            // 判断cell类型
            switch (cell.getCellType()) {
                case Cell.CELL_TYPE_NUMERIC: {
                    cellValue = String.valueOf(cell.getNumericCellValue());
                    break;
                }
                case Cell.CELL_TYPE_FORMULA: {
                    // 判断cell是否为日期格式
                    if (DateUtil.isCellDateFormatted(cell)) {
                        // 转换为日期格式YYYY-mm-dd
                        cellValue = cell.getDateCellValue();
                    } else {
                        // 数字
                        cellValue = String.valueOf(cell.getNumericCellValue());
                    }
                    break;
                }
                case Cell.CELL_TYPE_STRING: {
                    cellValue = cell.getRichStringCellValue().getString();
                    break;
                }
                default:
                    cellValue = "";
            }
        } else {
            cellValue = "";
        }
        return cellValue;
    }
    public static void printImg(Map<String, PictureData> sheetList) throws IOException {
        Object key[] = sheetList.keySet().toArray();
        for (int i = 0; i < sheetList.size(); i++) {
            PictureData pic = sheetList.get(key[i]);
            String picName = key[i].toString();
            String ext = pic.suggestFileExtension();
            byte[] data = pic.getData();
            FileOutputStream out = new FileOutputStream("D:\\" + picName + "." + ext);
            out.write(data);
            out.flush();
            out.close();
        }
    }
  //根据路径去腾讯云判断当前图片是否存在
    public static boolean hasImage(String key){
        CosClientUtil cosClientUtil = new CosClientUtil();
        ObjectMetadata objectMetadata = cosClientUtil.getObjectMetadata(key);
        if (objectMetadata != null) {
            System.out.println("objectMetadata存在!");
            return true;
        }
        return false;
    }
}


腾讯云上传工具类CosClientUtil.java

package com.dongao.project.utils;
import com.dongao.project.config.CosConfig;
import com.qcloud.cos.COSClient;
import com.qcloud.cos.ClientConfig;
import com.qcloud.cos.auth.BasicCOSCredentials;
import com.qcloud.cos.auth.COSCredentials;
import com.qcloud.cos.model.ObjectMetadata;
import com.qcloud.cos.model.PutObjectResult;
import com.qcloud.cos.region.Region;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.common.utils.file.FileUploadUtils;
import com.ruoyi.common.utils.spring.SpringUtils;
import org.apache.poi.ss.usermodel.PictureData;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.web.multipart.MultipartFile;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.Random;
/**
 * Created by nao'nao on 2020/4/17.
 */
public class CosClientUtil {
    private static Logger logger = LoggerFactory.getLogger(CosClientUtil.class);
    private static CosConfig cosConfig = SpringUtils.getBean(CosConfig.class);
    /**初始化密钥信息*/
    private COSCredentials cred = new BasicCOSCredentials(cosConfig.getSecretId(), cosConfig.getSecretKey());
    /**初始化客户端配置,设置bucket所在的区域*/
    private ClientConfig clientConfig = new ClientConfig(new Region(cosConfig.getRegion()));
    /**初始化cOSClient*/
    private COSClient cOSClient = new COSClient(cred, clientConfig);
    /**
     * 上传图片
     * @param file
     * @param businessName
     * @return
     * @throws Exception
     */
    public String uploadImgToCos(MultipartFile file, String businessName) throws Exception {
        int imageSize = Integer.parseInt(cosConfig.getImageSize());
        int maxSize = imageSize << 20;
        if (file.getSize() > maxSize) {
            throw new Exception("上传图片大小不能超过"+imageSize+"M!");
        }
        if (StringUtils.isEmpty(businessName)) {
            businessName = cosConfig.getCommon();
        }
        //生成文件夹层级
        Calendar cale = Calendar.getInstance();
        int year = cale.get(Calendar.YEAR);
        SimpleDateFormat sdf = new SimpleDateFormat("MM");
        Date dd  = cale.getTime();
        String month = sdf.format(dd);
        String folderName = cosConfig.getProjectName()+"/image/"+businessName+"/"+year+"/"+month+"/";
        //图片名称
        String originalFilename = file.getOriginalFilename();
        Random random = new Random();
        //生成新的图片名称(随机数0-9999+系统当前时间+上传图片名)
        String name;
        if (originalFilename.lastIndexOf(".") != -1) {
            name = random.nextInt(10000) + System.currentTimeMillis() + originalFilename.substring(originalFilename.lastIndexOf("."));
        }else {
            String extension = FileUploadUtils.getExtension(file);
            name = random.nextInt(10000) + System.currentTimeMillis() + "." + extension;
        }
        //生成对象键
        String key = folderName+name;
        try {
            InputStream inputStream = file.getInputStream();
            this.uploadFileToCos(inputStream, key);
            //return "http://" + cosConfig.getBucketName() + ".cos."+cosConfig.getRegion()+".myqcloud.com/" + key;
            return key;
        } catch (Exception e) {
            throw new Exception("图片上传失败");
        }
    }
    /**
     * 上传图片 简单上传
     * @param pic
     * @param businessName
     * @return
     * @throws Exception
     */
    public String simpleUploadImgToCos(PictureData pic, String businessName) throws Exception {
        if (StringUtils.isEmpty(businessName)) {
            businessName = cosConfig.getCommon();
        }
        //生成文件夹层级
        Calendar cale = Calendar.getInstance();
        int year = cale.get(Calendar.YEAR);
        SimpleDateFormat sdf = new SimpleDateFormat("MM");
        Date dd  = cale.getTime();
        String month = sdf.format(dd);
        String folderName = cosConfig.getProjectName()+"/image/"+businessName+"/"+year+"/"+month+"/";
        //获取图片后缀名
        String ext = pic.suggestFileExtension();
        Random random = new Random();
        //生成新的图片名称(随机数0-9999+系统当前时间+上传图片名)
        //图片名称
        String name = random.nextInt(10000) + System.currentTimeMillis() + "." + ext;
        //生成对象键
        String key = folderName+name;
        //图片数据
        byte[] data = pic.getData();
        //System.out.println("开始上传图片");
        try {
            //System.out.println("=====================");
            InputStream inputStream = new ByteArrayInputStream(data);
            //System.out.println("===========inputStream");
            this.uploadFileToCos(inputStream, key);
            //return "http://" + cosConfig.getBucketName() + ".cos."+cosConfig.getRegion()+".myqcloud.com/" + key;
            return key;
        } catch (Exception e) {
            throw new Exception("图片上传失败");
        }
    }
    /**
     * 上传到COS服务器 如果同名文件会覆盖服务器上的
     * @param instream
     * @param key
     * @return 出错返回"" ,唯一MD5数字签名
     */
    public String uploadFileToCos(InputStream instream, String key) {
        String etag = "";
        try {
            // 创建上传Object的Metadata
            ObjectMetadata objectMetadata = new ObjectMetadata();
            // 设置输入流长度为500
            objectMetadata.setContentLength(instream.available());
            // 设置 Content type
            objectMetadata.setContentType(getcontentType(key.substring(key.lastIndexOf("."))));
            // 上传文件
            //System.out.println("===============开始上传图片key:"+key);
            logger.info("开始上传图片key:【{}】",key);
            PutObjectResult putResult = cOSClient.putObject(cosConfig.getBucketName(),  key, instream, objectMetadata);
            //System.out.println("===============上传成功!");
            etag = putResult.getETag();
            logger.info("图片上传成功etag:【{}】",etag);
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (instream != null) {
                    //关闭输入流
                    instream.close();
                }
                // 关闭客户端(关闭后台线程)
                cOSClient.shutdown();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return etag;
    }
    /**
     * Description: 判断Cos服务文件上传时文件的contentType
     * @param filenameExtension 文件后缀
     * @return String
     */
    public String getcontentType(String filenameExtension) {
        String bmp = "bmp";
        if (bmp.equalsIgnoreCase(filenameExtension)) {
            return "image/bmp";
        }
        String gif = "gif";
        if (gif.equalsIgnoreCase(filenameExtension)) {
            return "image/gif";
        }
        String jpeg = "jpeg";
        String jpg = "jpg";
        String png = "png";
        if (jpeg.equalsIgnoreCase(filenameExtension) || jpg.equalsIgnoreCase(filenameExtension)
                || png.equalsIgnoreCase(filenameExtension)) {
            return "image/jpeg";
        }
        String html = "html";
        if (html.equalsIgnoreCase(filenameExtension)) {
            return "text/html";
        }
        String txt = "txt";
        if (txt.equalsIgnoreCase(filenameExtension)) {
            return "text/plain";
        }
        String vsd = "vsd";
        if (vsd.equalsIgnoreCase(filenameExtension)) {
            return "application/vnd.visio";
        }
        String pptx = "pptx";
        String ppt = "ppt";
        if (pptx.equalsIgnoreCase(filenameExtension) || ppt.equalsIgnoreCase(filenameExtension)) {
            return "application/vnd.ms-powerpoint";
        }
        String docx = "docx";
        String doc = "doc";
        if (docx.equalsIgnoreCase(filenameExtension) || doc.equalsIgnoreCase(filenameExtension)) {
            return "application/msword";
        }
        String xml = "xml";
        if (xml.equalsIgnoreCase(filenameExtension)) {
            return "text/xml";
        }
        String mp4 = ".mp4";
        if (mp4.equalsIgnoreCase(filenameExtension)) {
            return "application/octet-stream";
        }
        return "image/jpeg";
    }
  //根据图片路径获取图片
    public ObjectMetadata getObjectMetadata(String key) {
        // Bucket的命名格式为 BucketName-APPID ,此处填写的存储桶名称必须为此格式
        ObjectMetadata objectMetadata = null;
        try {
            objectMetadata = cOSClient.getObjectMetadata(cosConfig.getBucketName(), key);
        }catch (Exception e) {
            //e.printStackTrace();
        } finally {
            try {
                // 关闭客户端(关闭后台线程)
                cOSClient.shutdown();
            } catch (Exception e) {
                //e.printStackTrace();
            }
        }
        return objectMetadata;
    }
}


腾讯云上传参数CosConfig.java

package com.dongao.project.config;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;
/**
 * 腾讯云上传参数
 * @author: 
 * @create: 2020/04/17
 */
@Component
@ConfigurationProperties(prefix = "cos")
public class CosConfig {
    private String secretId = "123456qwertty";
    private String secretKey = "123sdfghghjjj";
    private String region = "ap-beijing";
    private String bucketName = "sdffgddg";
    private String projectName = "aaaaaaa";
    private String common = "common";
    private String imageSize = "2";
    private String prefixDomain = "http://aa.bb.com/";
    public String getSecretId() {
        return secretId;
    }
    public void setSecretId(String secretId) {
        this.secretId = secretId;
    }
    public String getSecretKey() {
        return secretKey;
    }
    public void setSecretKey(String secretKey) {
        this.secretKey = secretKey;
    }
    public String getRegion() {
        return region;
    }
    public void setRegion(String region) {
        this.region = region;
    }
    public String getBucketName() {
        return bucketName;
    }
    public void setBucketName(String bucketName) {
        this.bucketName = bucketName;
    }
    public String getProjectName() {
        return projectName;
    }
    public void setProjectName(String projectName) {
        this.projectName = projectName;
    }
    public String getCommon() {
        return common;
    }
    public void setCommon(String common) {
        this.common = common;
    }
    public String getImageSize() {
        return imageSize;
    }
    public void setImageSize(String imageSize) {
        this.imageSize = imageSize;
    }
    public String getPrefixDomain() {
        return prefixDomain;
    }
    public void setPrefixDomain(String prefixDomain) {
        this.prefixDomain = prefixDomain;
    }
}


配置文件application.properties

image.png

如此具备以上即可,仅供参考


相关文章
|
1月前
|
数据采集 监控 前端开发
二级公立医院绩效考核系统源码,B/S架构,前后端分别基于Spring Boot和Avue框架
医院绩效管理系统通过与HIS系统的无缝对接,实现数据网络化采集、评价结果透明化管理及奖金分配自动化生成。系统涵盖科室和个人绩效考核、医疗质量考核、数据采集、绩效工资核算、收支核算、工作量统计、单项奖惩等功能,提升绩效评估的全面性、准确性和公正性。技术栈采用B/S架构,前后端分别基于Spring Boot和Avue框架。
|
21天前
|
负载均衡 Java 开发者
深入探索Spring Cloud与Spring Boot:构建微服务架构的实践经验
深入探索Spring Cloud与Spring Boot:构建微服务架构的实践经验
64 5
|
1月前
|
前端开发 Java easyexcel
SpringBoot操作Excel实现单文件上传、多文件上传、下载、读取内容等功能
SpringBoot操作Excel实现单文件上传、多文件上传、下载、读取内容等功能
99 8
|
3月前
|
设计模式 Java 关系型数据库
【Java笔记+踩坑汇总】Java基础+JavaWeb+SSM+SpringBoot+SpringCloud+瑞吉外卖/谷粒商城/学成在线+设计模式+面试题汇总+性能调优/架构设计+源码解析
本文是“Java学习路线”专栏的导航文章,目标是为Java初学者和初中高级工程师提供一套完整的Java学习路线。
485 37
|
2月前
|
easyexcel Java UED
SpringBoot中大量数据导出方案:使用EasyExcel并行导出多个excel文件并压缩zip后下载
在SpringBoot环境中,为了优化大量数据的Excel导出体验,可采用异步方式处理。具体做法是将数据拆分后利用`CompletableFuture`与`ThreadPoolTaskExecutor`并行导出,并使用EasyExcel生成多个Excel文件,最终将其压缩成ZIP文件供下载。此方案提升了导出效率,改善了用户体验。代码示例展示了如何实现这一过程,包括多线程处理、模板导出及资源清理等关键步骤。
|
2月前
|
JSON 前端开发 Java
Spring Boot框架中的响应与分层解耦架构
在Spring Boot框架中,响应与分层解耦架构是两个核心概念,它们共同促进了应用程序的高效性、可维护性和可扩展性。
65 3
|
3月前
|
前端开发 Java easyexcel
SpringBoot操作Excel实现单文件上传、多文件上传、下载、读取内容等功能
SpringBoot操作Excel实现单文件上传、多文件上传、下载、读取内容等功能
50 6
|
3月前
|
存储 Java 数据库
Spring Boot 优雅实现多租户架构
本文详细介绍如何使用Spring Boot和Spring Cloud实现多租户架构。多租户架构允许多个租户共用一个应用,各自拥有独立资源和数据。其优势包括满足个性化需求、降低成本、复用代码以及增强可扩展性。文中探讨了架构选型、数据库设计、应用部署及租户管理等内容,并提供了具体实现步骤和技术细节。适用于SaaS应用和多租户云服务等场景。
|
3月前
|
缓存 Java 应用服务中间件
随着微服务架构的兴起,Spring Boot凭借其快速开发和易部署的特点,成为构建RESTful API的首选框架
【9月更文挑战第6天】随着微服务架构的兴起,Spring Boot凭借其快速开发和易部署的特点,成为构建RESTful API的首选框架。Nginx作为高性能的HTTP反向代理服务器,常用于前端负载均衡,提升应用的可用性和响应速度。本文详细介绍如何通过合理配置实现Spring Boot与Nginx的高效协同工作,包括负载均衡策略、静态资源缓存、数据压缩传输及Spring Boot内部优化(如线程池配置、缓存策略等)。通过这些方法,开发者可以显著提升系统的整体性能,打造高性能、高可用的Web应用。
80 2
|
17天前
|
弹性计算 API 持续交付
后端服务架构的微服务化转型
本文旨在探讨后端服务从单体架构向微服务架构转型的过程,分析微服务架构的优势和面临的挑战。文章首先介绍单体架构的局限性,然后详细阐述微服务架构的核心概念及其在现代软件开发中的应用。通过对比两种架构,指出微服务化转型的必要性和实施策略。最后,讨论了微服务架构实施过程中可能遇到的问题及解决方案。
下一篇
DataWorks