完成图片上传接口

f5d58b02 · zgy · 7ccbf8f4 · f5d58b02 · f5d58b02
--- a/platform-admin/src/main/java/com/platform/controller/api/uploadController.java
+++ b/platform-admin/src/main/java/com/platform/controller/api/uploadController.java
 package com.platform.controller.api;

 import com.platform.annotation.IgnoreAuth;
+import com.platform.entity.BASE64DecodedMultipartFile;
 import com.platform.utils.OssUtil;
 import com.platform.utils.R;
 import com.platform.utils.util.UuidUtil;
 import org.springframework.stereotype.Controller;
+import org.springframework.web.bind.annotation.RequestBody;
 import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.RequestParam;
 import org.springframework.web.bind.annotation.ResponseBody;
 import org.springframework.web.multipart.MultipartFile;

 import java.io.File;
+import java.util.Map;

 /**
 * @Auther: wudepeng
@@ -63,4 +66,25 @@ public class uploadController {
        }
    }

+    @IgnoreAuth
+    @ResponseBody
+    @RequestMapping(value = "/uploadBase64", produces = "application/json;charset=UTF-8")
+    public String uploadBase64(@RequestBody Map map) throws Exception {
+        try {
+            Object strImg = map.get("file");
+            String secondaryFolderName = "Afrishop";
+            String str = strImg.toString();
+            MultipartFile file = BASE64DecodedMultipartFile.base64ToMultipart(str);
+            String url = OssUtil.upload(file, secondaryFolderName);
+            System.out.println(url);
+            return url;
+        } catch (Exception e) {
+            e.printStackTrace();
+            return "err";
+        }
+
+    }
+    /**
+     * data:image/jpg;base64,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
+     */
 }
\ No newline at end of file
--- a/platform-admin/src/main/java/com/platform/entity/BASE64DecodedMultipartFile.java
+++ b/platform-admin/src/main/java/com/platform/entity/BASE64DecodedMultipartFile.java
+package com.platform.entity;
+
+import cn.hutool.core.codec.Base64;
+import org.springframework.web.multipart.MultipartFile;
+import sun.misc.BASE64Decoder;
+
+import java.io.*;
+
+/**
+ * @Auther: wudepeng
+ * @Date: 2020/03/22
+ * @Description:
+ */
+public class BASE64DecodedMultipartFile implements MultipartFile {
+
+    private final byte[] imgContent;
+    private final String header;
+
+    public BASE64DecodedMultipartFile(byte[] imgContent, String header) {
+        this.imgContent = imgContent;
+        this.header = header.split(";")[0];
+    }
+
+    @Override
+    public String getName() {
+        return System.currentTimeMillis() + Math.random() + "." + header.split("/")[1];
+    }
+
+    @Override
+    public String getOriginalFilename() {
+        return System.currentTimeMillis() + (int) Math.random() * 10000 + "." + header.split("/")[1];
+    }
+
+    @Override
+    public String getContentType() {
+        return header.split(":")[1];
+    }
+
+    @Override
+    public boolean isEmpty() {
+        return imgContent == null || imgContent.length == 0;
+    }
+
+    @Override
+    public long getSize() {
+        return imgContent.length;
+    }
+
+    @Override
+    public byte[] getBytes() throws IOException {
+        return imgContent;
+    }
+
+    @Override
+    public InputStream getInputStream() throws IOException {
+        return new ByteArrayInputStream(imgContent);
+    }
+
+    @Override
+    public void transferTo(File dest) throws IOException, IllegalStateException {
+        new FileOutputStream(dest).write(imgContent);
+    }
+
+    public static MultipartFile base64ToMultipart(String base64) {
+        try {
+            String[] baseStrs = base64.split(",");
+
+            BASE64Decoder decoder = new BASE64Decoder();
+            byte[] b = new byte[0];
+            b = decoder.decodeBuffer(baseStrs[1]);
+
+            for (int i = 0; i < b.length; ++i) {
+                if (b[i] < 0) {
+                    b[i] += 256;
+                }
+            }
+            return new BASE64DecodedMultipartFile(b, baseStrs[0]);
+        } catch (IOException e) {
+            e.printStackTrace();
+            return null;
+        }
+    }
+
+    public static File base64ToFile(String base64) {
+        if(base64==null||"".equals(base64)) {
+            return null;
+        }
+        byte[] buff= Base64.decode(base64);
+        File file=null;
+        FileOutputStream fout=null;
+        try {
+            file = File.createTempFile("tmp", null);
+            fout=new FileOutputStream(file);
+            fout.write(buff);
+        } catch (IOException e) {
+            e.printStackTrace();
+        }finally {
+            if(fout!=null) {
+                try {
+                    fout.close();
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+        }
+        return file;
+    }
+
+
+}