最近用到了图片上传,而我太菜了,开此贴记录一下,方便以后使用

导入pom依赖

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
<!--log4j-->
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>1.2.17</version>
</dependency>

<!-- 七牛云 -->
<dependency>
<groupId>com.qiniu</groupId>
<artifactId>qiniu-java-sdk</artifactId>
<version>[7.2.0, 7.2.99]</version>
</dependency>

<dependency>
<groupId>com.squareup.okhttp3</groupId>
<artifactId>okhttp</artifactId>
<version>3.14.2</version>
<scope>compile</scope>
</dependency>
<dependency>
<groupId>com.google.code.gson</groupId>
<artifactId>gson</artifactId>
<version>2.8.5</version>
<scope>compile</scope>
</dependency>
<dependency>
<groupId>com.qiniu</groupId>
<artifactId>happy-dns-java</artifactId>
<version>0.1.6</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<scope>test</scope>
</dependency>

<!--七牛云 End-->

创建需要的几个工具类

  1. QiniuCloudUtil,代码如下

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    package com.jinan.utils;

    /**
    *
    * <p>
    * class类
    */

    import com.google.gson.Gson;
    import com.qiniu.common.QiniuException;
    import com.qiniu.common.Zone;
    import com.qiniu.http.Response;
    import com.qiniu.storage.BucketManager;
    import com.qiniu.storage.Configuration;
    import com.qiniu.storage.Region;
    import com.qiniu.storage.UploadManager;
    import com.qiniu.storage.model.DefaultPutRet;
    import com.qiniu.util.Auth;
    import org.apache.log4j.Logger;
    import org.springframework.stereotype.Component;

    import java.io.File;

    /**
    * @author dsn
    * @createTime 07 21:07
    * @description 七牛云工具
    */
    @Component
    public class QiniuCloudUtil {

    private static final Logger logger = Logger.getLogger(QiniuCloudUtil.class);

    //设置好账号的ACCESS_KEY和SECRET_KEY
    final String ACCESS_KEY = "AK";
    final String SECRET_KEY = "SK";

    //要上传的空间
    final String BUCKET_NAME = "空间名";


    /**
    * 七牛云上传图片
    *
    * @param localFilePath
    * @return
    */
    public String uoloapQiniu(File localFilePath, String fileName) {
    //构造一个带指定Zone对象的配置类
    Configuration cfg;
    cfg = new Configuration(Zone.zone1());
    //...其他参数参考类注释
    UploadManager uploadManager = new UploadManager(cfg);
    //...生成上传凭证,然后准备上传
    String accessKey = ACCESS_KEY;
    String secretKey = SECRET_KEY;
    String bucket = BUCKET_NAME;
    //如果是Windows情况下,格式是 D:\23912475_130759767000_2.jpg
    //默认不指定key的情况下,以文件内容的hash值作为文件名
    String key = "images/" + fileName;
    Auth auth = Auth.create(accessKey, secretKey);
    String upToken = auth.uploadToken(bucket);

    String result = null;

    try {
    Response response = uploadManager.put(localFilePath, key, upToken);
    //解析上传成功的结果
    DefaultPutRet putRet = new Gson().fromJson(response.bodyString(), DefaultPutRet.class);

    logger.info("{七牛图片上传key: " + putRet.key + ",七牛图片上传hash: " + putRet.hash + "}");

    result = "http://你的url/"+putRet.key;

    } catch (QiniuException ex) {
    Response r = ex.response;
    System.err.println(r.toString());
    try {
    System.err.println(r.bodyString());
    } catch (QiniuException ex2) {
    //ignore
    }
    result = null;
    }
    return result;
    }

    /**
    * 通过key删除七牛云上的图片
    */
    public void deleteplus(String key) throws QiniuException {
    //System.out.println(key);
    Configuration cfg = new Configuration(Region.region0());
    Auth auth = Auth.create(ACCESS_KEY, SECRET_KEY);
    BucketManager bucketManager = new BucketManager(auth, cfg);
    try {
    bucketManager.delete(BUCKET_NAME, key);
    } catch (QiniuException ex) {
    //如果遇到异常,说明删除失败
    System.out.println("删除失败:信息如下:");
    System.err.println(ex.code());
    System.err.println(ex.response.toString());
    ex.printStackTrace();
    }
    }
    }
  2. SpringUtils,内容如下

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    package com.jinan.utils;

    import org.springframework.aop.framework.AopContext;
    import org.springframework.beans.BeansException;
    import org.springframework.beans.factory.NoSuchBeanDefinitionException;
    import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
    import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
    import org.springframework.stereotype.Component;

    /**
    * spring工具类 方便在非spring管理环境中获取bean
    *
    * @author ruoyi
    */
    @Component
    public final class SpringUtils implements BeanFactoryPostProcessor
    {
    /** Spring应用上下文环境 */
    private static ConfigurableListableBeanFactory beanFactory;

    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException
    {
    SpringUtils.beanFactory = beanFactory;
    }

    /**
    * 获取对象
    *
    * @param name
    * @return Object 一个以所给名字注册的bean的实例
    * @throws BeansException
    *
    */
    @SuppressWarnings("unchecked")
    public static <T> T getBean(String name) throws BeansException
    {
    return (T) beanFactory.getBean(name);
    }

    /**
    * 获取类型为requiredType的对象
    *
    * @param clz
    * @return
    * @throws BeansException
    *
    */
    public static <T> T getBean(Class<T> clz) throws BeansException
    {
    T result = (T) beanFactory.getBean(clz);
    return result;
    }

    /**
    * 如果BeanFactory包含一个与所给名称匹配的bean定义,则返回true
    *
    * @param name
    * @return boolean
    */
    public static boolean containsBean(String name)
    {
    return beanFactory.containsBean(name);
    }

    /**
    * 判断以给定名字注册的bean定义是一个singleton还是一个prototype。 如果与给定名字相应的bean定义没有被找到,将会抛出一个异常(NoSuchBeanDefinitionException)
    *
    * @param name
    * @return boolean
    * @throws NoSuchBeanDefinitionException
    *
    */
    public static boolean isSingleton(String name) throws NoSuchBeanDefinitionException
    {
    return beanFactory.isSingleton(name);
    }

    /**
    * @param name
    * @return Class 注册对象的类型
    * @throws NoSuchBeanDefinitionException
    *
    */
    public static Class<?> getType(String name) throws NoSuchBeanDefinitionException
    {
    return beanFactory.getType(name);
    }

    /**
    * 验证身份证号号是否合法
    */
    // public static boolean isIDNumber(String number){
    // Regex re = new Regex(@"(^[1-9]\d{5}\d{2}((0[1-9])|(10|11|12))(([0-2][1-9])|10|20|30|31)\d{3}$)|(^[1-9]\d{5}(18|19|([23]\d))\d{2}((0[1-9])|(10|11|12))(([0-2][1-9])|10|20|30|31)\d{3}[0-9Xx]$)");
    // }


    /**
    * 如果给定的bean名字在bean定义中有别名,则返回这些别名
    *
    * @param name
    * @return
    * @throws NoSuchBeanDefinitionException
    *
    */
    public static String[] getAliases(String name) throws NoSuchBeanDefinitionException
    {
    return beanFactory.getAliases(name);
    }

    /**
    * 获取aop代理对象
    *
    * @param invoker
    * @return
    */
    @SuppressWarnings("unchecked")
    public static <T> T getAopProxy(T invoker)
    {
    return (T) AopContext.currentProxy();
    }
    }
  3. VerifyCodeUtils,内容如下

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
    165
    166
    167
    168
    169
    170
    171
    172
    173
    174
    175
    176
    177
    178
    179
    180
    181
    182
    183
    184
    185
    186
    187
    188
    189
    190
    191
    192
    193
    194
    195
    196
    197
    198
    199
    200
    201
    202
    203
    204
    205
    206
    207
    208
    209
    210
    211
    212
    213
    214
    215
    216
    217
    218
    219
    220
    221
    222
    223
    224
    225
    226
    227
    228
    229
    230
    231
    232
    233
    234
    235
    236
    237
    238
    239
    240
    241
    242
    243
    244
    245
    246
    247
    248
    249
    250
    251
    252
    253
    254
    255
    256
    257
    258
    259
    package com.jinan.utils;

    import java.awt.Color;
    import java.awt.Font;
    import java.awt.Graphics;
    import java.awt.Graphics2D;
    import java.awt.RenderingHints;
    import java.awt.geom.AffineTransform;
    import java.awt.image.BufferedImage;
    import java.io.File;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.io.OutputStream;
    import java.util.Arrays;
    import java.util.Random;

    import javax.imageio.ImageIO;

    public class VerifyCodeUtils{

    //使用到Algerian字体,系统里没有的话需要安装字体,字体只显示大写,去掉了1,0,i,o几个容易混淆的字符
    public static final String VERIFY_CODES = "23456789ABCDEFGHJKLMNPQRSTUVWXYZ";
    private static Random random = new Random();


    /**
    * 使用系统默认字符源生成验证码
    * @param verifySize 验证码长度
    * @return
    */
    public static String generateVerifyCode(int verifySize){
    return generateVerifyCode(verifySize, VERIFY_CODES);
    }
    /**
    * 使用指定源生成验证码
    * @param verifySize 验证码长度
    * @param sources 验证码字符源
    * @return
    */
    public static String generateVerifyCode(int verifySize, String sources){
    if(sources == null || sources.length() == 0){
    sources = VERIFY_CODES;
    }
    int codesLen = sources.length();
    Random rand = new Random(System.currentTimeMillis());
    StringBuilder verifyCode = new StringBuilder(verifySize);
    for(int i = 0; i < verifySize; i++){
    verifyCode.append(sources.charAt(rand.nextInt(codesLen-1)));
    }
    return verifyCode.toString();
    }

    /**
    * 生成随机验证码文件,并返回验证码值
    * @param w
    * @param h
    * @param outputFile
    * @param verifySize
    * @return
    * @throws IOException
    */
    public static String outputVerifyImage(int w, int h, File outputFile, int verifySize) throws IOException{
    String verifyCode = generateVerifyCode(verifySize);
    outputImage(w, h, outputFile, verifyCode);
    return verifyCode;
    }

    /**
    * 输出随机验证码图片流,并返回验证码值
    * @param w
    * @param h
    * @param os
    * @param verifySize
    * @return
    * @throws IOException
    */
    public static String outputVerifyImage(int w, int h, OutputStream os, int verifySize) throws IOException{
    String verifyCode = generateVerifyCode(verifySize);
    outputImage(w, h, os, verifyCode);
    return verifyCode;
    }

    /**
    * 生成指定验证码图像文件
    * @param w
    * @param h
    * @param outputFile
    * @param code
    * @throws IOException
    */
    public static void outputImage(int w, int h, File outputFile, String code) throws IOException{
    if(outputFile == null){
    return;
    }
    File dir = outputFile.getParentFile();
    if(!dir.exists()){
    dir.mkdirs();
    }
    try{
    outputFile.createNewFile();
    FileOutputStream fos = new FileOutputStream(outputFile);
    outputImage(w, h, fos, code);
    fos.close();
    } catch(IOException e){
    throw e;
    }
    }

    /**
    * 输出指定验证码图片流
    * @param w
    * @param h
    * @param os
    * @param code
    * @throws IOException
    */
    public static void outputImage(int w, int h, OutputStream os, String code) throws IOException{
    int verifySize = code.length();
    BufferedImage image = new BufferedImage(w, h, BufferedImage.TYPE_INT_RGB);
    Random rand = new Random();
    Graphics2D g2 = image.createGraphics();
    g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING,RenderingHints.VALUE_ANTIALIAS_ON);
    Color[] colors = new Color[5];
    Color[] colorSpaces = new Color[] { Color.WHITE, Color.CYAN,
    Color.GRAY, Color.LIGHT_GRAY, Color.MAGENTA, Color.ORANGE,
    Color.PINK, Color.YELLOW };
    float[] fractions = new float[colors.length];
    for(int i = 0; i < colors.length; i++){
    colors[i] = colorSpaces[rand.nextInt(colorSpaces.length)];
    fractions[i] = rand.nextFloat();
    }
    Arrays.sort(fractions);

    g2.setColor(Color.GRAY);// 设置边框色
    g2.fillRect(0, 0, w, h);

    Color c = getRandColor(200, 250);
    g2.setColor(c);// 设置背景色
    g2.fillRect(0, 2, w, h-4);

    //绘制干扰线
    Random random = new Random();
    g2.setColor(getRandColor(160, 200));// 设置线条的颜色
    for (int i = 0; i < 20; i++) {
    int x = random.nextInt(w - 1);
    int y = random.nextInt(h - 1);
    int xl = random.nextInt(6) + 1;
    int yl = random.nextInt(12) + 1;
    g2.drawLine(x, y, x + xl + 40, y + yl + 20);
    }

    // 添加噪点
    float yawpRate = 0.05f;// 噪声率
    int area = (int) (yawpRate * w * h);
    for (int i = 0; i < area; i++) {
    int x = random.nextInt(w);
    int y = random.nextInt(h);
    int rgb = getRandomIntColor();
    image.setRGB(x, y, rgb);
    }

    shear(g2, w, h, c);// 使图片扭曲

    g2.setColor(getRandColor(100, 160));
    int fontSize = h-4;
    Font font = new Font("Algerian", Font.ITALIC, fontSize);
    g2.setFont(font);
    char[] chars = code.toCharArray();
    for(int i = 0; i < verifySize; i++){
    AffineTransform affine = new AffineTransform();
    affine.setToRotation(Math.PI / 4 * rand.nextDouble() * (rand.nextBoolean() ? 1 : -1), (w / verifySize) * i + fontSize/2, h/2);
    g2.setTransform(affine);
    g2.drawChars(chars, i, 1, ((w-10) / verifySize) * i + 5, h/2 + fontSize/2 - 10);
    }

    g2.dispose();
    ImageIO.write(image, "jpg", os);
    }

    private static Color getRandColor(int fc, int bc) {
    if (fc > 255)
    fc = 255;
    if (bc > 255)
    bc = 255;
    int r = fc + random.nextInt(bc - fc);
    int g = fc + random.nextInt(bc - fc);
    int b = fc + random.nextInt(bc - fc);
    return new Color(r, g, b);
    }

    private static int getRandomIntColor() {
    int[] rgb = getRandomRgb();
    int color = 0;
    for (int c : rgb) {
    color = color << 8;
    color = color | c;
    }
    return color;
    }

    private static int[] getRandomRgb() {
    int[] rgb = new int[3];
    for (int i = 0; i < 3; i++) {
    rgb[i] = random.nextInt(255);
    }
    return rgb;
    }

    private static void shear(Graphics g, int w1, int h1, Color color) {
    shearX(g, w1, h1, color);
    shearY(g, w1, h1, color);
    }

    private static void shearX(Graphics g, int w1, int h1, Color color) {

    int period = random.nextInt(2);

    boolean borderGap = true;
    int frames = 1;
    int phase = random.nextInt(2);

    for (int i = 0; i < h1; i++) {
    double d = (double) (period >> 1)
    * Math.sin((double) i / (double) period
    + (6.2831853071795862D * (double) phase)
    / (double) frames);
    g.copyArea(0, i, w1, 1, (int) d, 0);
    if (borderGap) {
    g.setColor(color);
    g.drawLine((int) d, i, 0, i);
    g.drawLine((int) d + w1, i, w1, i);
    }
    }

    }

    private static void shearY(Graphics g, int w1, int h1, Color color) {

    int period = random.nextInt(40) + 10; // 50;

    boolean borderGap = true;
    int frames = 20;
    int phase = 7;
    for (int i = 0; i < w1; i++) {
    double d = (double) (period >> 1)
    * Math.sin((double) i / (double) period
    + (6.2831853071795862D * (double) phase)
    / (double) frames);
    g.copyArea(i, 0, 1, h1, 0, (int) d);
    if (borderGap) {
    g.setColor(color);
    g.drawLine(i, (int) d, i, 0);
    g.drawLine(i, (int) d + h1, i, h1);
    }

    }

    }
    }

新建一个service

内容如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
package com.jinan.service;

import org.springframework.web.multipart.MultipartFile;

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

public interface FileService {

/**
* 多文件上传
* @param file
* @return
*/
Map<String, Object> uploadImgs(MultipartFile[] file);

void delete(String key);
}

ServiceImpl

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
package com.jinan.service.impl;

import com.jinan.controller.FileController;
import com.jinan.service.FileService;
import com.jinan.utils.QiniuCloudUtil;
import com.jinan.utils.ResultUtils.StringUtils;
import com.jinan.utils.VerifyCodeUtils;
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.*;
import java.text.SimpleDateFormat;
import java.util.*;

@Service
public class FileServiceImpl implements FileService {

@Autowired
private QiniuCloudUtil qiniuCloudUtil;

private static final Logger logger = Logger.getLogger(FileController.class);
/**
* 上传图片
* @param file
* @return
*/
@Override
public Map<String, Object> uploadImgs(MultipartFile[] file) {

Map<String, Object> resultMap = new HashMap<>();
List<String> list = new LinkedList<>();
String result = null;
for (int i = 0; i < file.length; i++) {
Date dNow = new Date( );
SimpleDateFormat ft = new SimpleDateFormat ("yyyyMMdd");
String fileName = ft.format(dNow)+ VerifyCodeUtils.generateVerifyCode(4)+".jpg";
// 创建一个临时目录文件
String tempFiles = "temp/"+fileName;
System.err.println(fileName);
File dest = new File(tempFiles);
if (!dest.getParentFile().exists()) {
dest.getParentFile().mkdirs();
}

BufferedOutputStream out = null;
QiniuCloudUtil qn = new QiniuCloudUtil();

try {
out = new BufferedOutputStream(new FileOutputStream(dest));
out.write(file[i].getBytes());
result = qn.uoloapQiniu(dest,fileName);

if (StringUtils.isNotBlank(result)) {
list.add(result);
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e1) {
e1.getMessage();
} finally{
try {
if (null != out) {
out.flush();
out.close();
}
} catch (IOException e) {
e.printStackTrace();
}

if (dest.getParentFile().exists()) {
dest.delete();
}
}

}
logger.info("imagesList == " + list);
if (list.isEmpty()) {
list.add("error");
}
resultMap.put("result",list);
return resultMap;
}

@Override
public void delete(String key){
try {
qiniuCloudUtil.daleteOnQn(key);
}catch (Exception exception){
System.err.println(exception);
}
}
}

Controller

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
package com.jinan.controller;

import com.jinan.configure.Token;
import com.jinan.service.FileService;
import com.jinan.utils.QRCodeUtils;
import com.jinan.utils.ResultUtils.AjaxResult;
import com.jinan.utils.ResultUtils.StringUtils;
import com.qiniu.util.IOUtils;

import org.apache.log4j.Logger;
import org.apache.tomcat.util.http.fileupload.FileUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.multipart.MultipartFile;
import org.springframework.web.multipart.MultipartHttpServletRequest;

import javax.servlet.http.HttpServletRequest;
import java.io.*;
import java.util.*;

@RestController
@RequestMapping("/system/file")
public class FileController {

private static final Logger logger = Logger.getLogger(FileController.class);

@Autowired
private FileService fileService;
// @Autowired
// private ShmUserOneServiceImpl shmUserOneServiceImpl;

/**
* 上传图片
* @param
* @return
*/
@PostMapping("uploadImg")
public AjaxResult uploadImg(@RequestParam("file") MultipartFile[] files) {

// 返回类型可以自己定义

Map<String,Object> maps = new HashMap<String,Object>();
// 验证非空
if (StringUtils.isBlank(files[0].getOriginalFilename())) {
return AjaxResult.error("数据为空");
} else {
Map<String,Object> map = new HashMap<>();

map = fileService.uploadImgs(files);

List<Object> resultList = (List<Object>) map.get("result");
logger.info("图片上传返回结果:"+resultList);

if ("error".equals(resultList.get(0))) {
return AjaxResult.error("上传失败");
} else {
return AjaxResult.success("上传成功",map);
}
}
}

@PostMapping("/delete")
public void delete(String key){
String file[] = key.split("/");
fileService.delete(file[file.length-1]); // http://qdapiydr5.bkt.clouddn.com/images/202007136BCB.jpg
// for (int i=0;i<file.length;i++){
// System.err.println(file[i]);
// }
}
}

前端

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
						photo:function(){
uni.chooseImage({
count: 1,
sizeType: ['compressed'],
success: function(res) {
uni.showLoading({
title: "上传图片"
});
uni.uploadFile({
url: '请求地址',
filePath: res.tempFilePaths[0],
name: 'file',
header: {
'token': uni.getStorageSync('token')
},
success: (uploadFileRes) => {
console.log(JSON.parse(uploadFileRes.data).data);
_self.artList = _self.artList.concat(JSON.parse(uploadFileRes.data).data);
_self.changemsg.photo= _self.artList[0];
},
complete() {
uni.hideLoading()
}
})
}
})
},

删除图片
removeImg: function(e) {
var pop = null;
pop = _self.truePic;
console.log(pop);
uni.showModal({
content: "确定要删除此图片吗",
title: '提示',
success(e) {
if (e.confirm) {
console.log("出发了");
_self.$api.ny(pop).then((res) => {
console.log(res);
_self.artList = [];
console.log(_self.artList);
}).catch((err => {
console.log('失败', err);
}))
}
}
});
},

未完更·······