图片上传及图片处理-----后端技术栈

最新推荐文章于 2024-05-08 23:04:39 发布
最新推荐文章于 2024-05-08 23:04:39 发布
阅读量1.6k 收藏 5
点赞数
分类专栏： mui架构app
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36389107/article/details/82317037
版权

1.前言
前面两节我们跟新了图片上传的前端知识。没看的小伙伴可以返回去看看。
图片上传及图片处理—–前端技术栈
图片上传及图片处理—–5+runtime技术栈
现在，我们要做的就是后端服务器处理图片。
一般来说，对于一张图片。他可能在手机端，平板电脑端以及pc端进行展示。有可能以列表形式展示，也有可能以详情图展示，对于不同的展示方式。我们应该给与不同大小的图片进行展示。这样做，有以下几个好处。

  1. 提高传输效率
  2. 节省用户流量
  3. 减轻客户端渲染的压力（对于手机端，如果全是几百kb以上的图片。在低端安卓机上。真的卡的不行）

基于以上几点，我们可以按照用途把图片划分为以下几个尺寸（本节主要将等宽比例压缩，当然你也可以试试其他的）

  1. 宽度250(20kb左右)——适用于手机横向展示2张以上的图片（比如列表展示）
  2. 宽度550(60kb左右)——适用于手机横向单图、平板电脑端横向2图、pc端横向4图
  3. 宽度1000(150kb左右)——适用于手机图片单张详情预览、平板横向单张展示、平板图片详情、pc端图片详情
  4. 宽度2000(350kb左右)——适用于平板电脑单张详情(不常用)、pc端巨幕<该类为了增加上传速度可单独用作判断>
  5. 原图——适用于对图片质量要求很高的摄影绘画等等的下载<不常用，平台无原图下载功能建议不用>

基于这样的构思我们来构思实现代码逻辑

  1. 拿到前端传过来的文件
  2. 如果图片大小满足压缩按照比例压缩图片
  3. 获取压缩图片的输出流
  4. 输出到本地路径或者远程服务器

废话不多说了，就这个逻辑。上代码。

  • 从file中按照250,550,1000,2000，原图五个方式获得输出流
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.web.multipart.MultipartFile;

import javax.imageio.IIOImage;
import javax.imageio.ImageIO;
import javax.imageio.ImageWriteParam;
import javax.imageio.ImageWriter;
import java.awt.*;
import java.awt.image.BufferedImage;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;

public class CompressUtils {
    private static Logger log = LoggerFactory.getLogger(CompressUtils.class);
    /**
     * 获取宽250返回流(手机列表图)
     * @param file
     * @return
     */
    public static InputStream getMinInputStream(MultipartFile file){
        if (file == null) {
            log.error("文件不能为空:CompressUtils.getMinInputStream");
            return null;
        }
        return handPicture(file,250);
    }
    /**
     * 获取宽550返回流(手机详情图)
     * @param file
     * @return
     */
    public static InputStream getMiddleInputStream(MultipartFile file){
        if (file == null) {
            log.error("文件不能为空:CompressUtils.getMiddleInputStream");
            return null;
        }
        return handPicture(file,550);
    }

    /**
     * 获取宽1000返回流(pad详情图)
     * @param file
     * @return
     */
    public static InputStream getMaxInputStream(MultipartFile file){
        if (file == null) {
            log.error("文件不能为空:CompressUtils.getMaxInputStream");
            return null;
        }
        return handPicture(file,1000);
    }
    /**
     * 获取宽2000返回流(pc详情图)
     * @param file
     * @return
     */
    public static InputStream getSupperInputStream(MultipartFile file){
        if (file == null) {
            log.error("文件不能为空:CompressUtils.getSupperInputStream");
            return null;
        }
        return handPicture(file,2000);
    }
    /**
     * 获取原图返回流
     * @param file
     * @return
     */
    public static InputStream getOrginInputStream(MultipartFile file){
        if (file == null) {
            log.error("文件不能为空:CompressUtils.getOrginInputStream");
            return null;
        }
        try {
            return getPictureInputStream(ImageIO.read(file.getInputStream()),0,0);
        } catch (IOException e) {
            log.error("文件io异常:CompressUtils.getOrginInputStream");
            return null;
        }
    }

    private static InputStream handPicture(MultipartFile file,Integer width){
        try {
            InputStream inputStream = file.getInputStream();
            BufferedImage bufImg=ImageIO.read(inputStream);
            Integer w = bufImg.getWidth(null);
            if(width>w) return getPictureInputStream(bufImg,0,0);
            return getPictureInputStream(bufImg,width,0);
        } catch (IOException e) {
            log.error("文件io异常:CompressUtils.handPicture");
            return null;
        }
    }
    private static InputStream getPictureInputStream(BufferedImage bufImg, int width, int height) {
        try {
            Integer w = bufImg.getWidth(null);
            Integer h = bufImg.getHeight(null);
            double bili;
            if(width>0){
                bili=width/(double)w;
                height = (int) (h*bili);
            }else{
                if(height>0){
                    bili=height/(double)h;
                    width = (int) (w*bili);
                }else{
                    height=h;
                    width =w;
                }
            }

            // 获得缓存流
            BufferedImage newBufferedImage  = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);
            newBufferedImage .getGraphics().drawImage(bufImg.getScaledInstance(width, height, Image.SCALE_SMOOTH), 0, 0, null);

            // 指定写图片的方式为 jpg
            ImageWriter imgWriter = ImageIO.getImageWritersByFormatName("jpg").next();
            ImageWriteParam imgWriteParams = new javax.imageio.plugins.jpeg.JPEGImageWriteParam(null);
            // 获取流
            ByteArrayOutputStream bos = new ByteArrayOutputStream();
            imgWriter.reset();
            imgWriter.setOutput(ImageIO.createImageOutputStream(bos));
            imgWriter.write(null, new IIOImage(newBufferedImage, null, null), imgWriteParams);

            // 转换为输出流
            InputStream inputStream = new ByteArrayInputStream(bos.toByteArray());
            inputStream.close();
            return  new ByteArrayInputStream(bos.toByteArray());
        } catch (IOException e) {
            log.error("图片压缩io异常:CompressUtils.getPictureInputStream<==>"+e.getMessage());
            return null;
        }
    }
}
  • 使用传统方法将图片写在本地
   /**
     * 将InputStream写入本地文件
     * @param input 输入流
     * @throws IOException
     */
    private static String writeToLocal(String destination,InputStream input) throws IOException {
        int index;
        byte[] bytes = new byte[1024];
        FileOutputStream downloadFile = new FileOutputStream(destination);
        while ((index = input.read(bytes)) != -1) {
            downloadFile.write(bytes, 0, index);
            downloadFile.flush();
        }
        downloadFile.close();
        input.close();
    }
    /**
     * web服务器保存图片路径
     */
    public static String createPath(){
         String minUrl= UUID.randomUUID().toString().replace("-","");
         Calendar cale = Calendar.getInstance(); 
         int year =cale.get(Calendar.YEAR);
         int month = cale.get(Calendar.MONTH) + 1;
         int day = cale.get(Calendar.DATE);    
         String pname=year+"y"+month+"/"+day+"/"+minUrl+".jpg";      
         String path ="/pictures/"+ pname
         return path;
    }
    public static void main(String[] args) {
        // 乱写的后期来源于前端文件
        MultipartFile file =new MultipartFile ();
        // 1.路径写死
        String minUrl= UUID.randomUUID().toString().replace("-","");
        writeToLocal("E/ehu/src/main/java/resource/pictures/"+minUrl+".jpg",getOrginInputStream(file));
        // 2.使用相对路径
        String path =createPath();
        writeToLocal(request.getContextPath()+path,getOrginInputStream(file));      
    }

其中 input 用第一个方法获得。destination一般采用配置文件路径+UUID自动生成+”.jpg”后缀。
如上所示main文件写好后，destination为写死的。这样做，读取文件可能麻烦一些。我们可以使用获取项目资源文件路径，从而把图片写在资源文件夹+按照年+月份分第一层包+按照日期分第二层包+文件名称。具体方式见上面代码createPath()方法。这样在前端获取图片文件资源的时候。只需要加上服务器ip+项目端口号（默认80,可不写）+项目名称（一般配置为省略）+createPath()即可

  • 使用三方对象存储服务

当前三方比较流行的有阿里云对象存储，七牛云对象存储，腾讯云对象存储等。他们可用于存任何的文件（我其实一直在考虑要不要用来开辟一块自己的网盘）。该代码借用人人开源代码集成做了一些修改。大致步骤有以下几个。

  1. 写配置类加载配置
  2. 工厂方法调用上传调用
    1. 在pom中引入三方jar包
<properties>
        <qiniu-version>[7.2.0, 7.2.99]</qiniu-version>
        <aliyun-oss-version>2.5.0</aliyun-oss-version>
        <qcloud-cos-version>4.4</qcloud-cos-version>
</properties>
<dependencies>
       <dependency>
           <groupId>com.qiniu</groupId>
           <artifactId>qiniu-java-sdk</artifactId>
           <version>${qiniu-version}</version>
       </dependency>
       <dependency>
           <groupId>com.aliyun.oss</groupId>
           <artifactId>aliyun-sdk-oss</artifactId>
           <version>${aliyun-oss-version}</version>
       </dependency>
       <dependency>
           <groupId>com.qcloud</groupId>
           <artifactId>cos_api</artifactId>
           <version>${qcloud-cos-version}</version>
       </dependency>
 </dependencies>

  1. 分别集成阿里云，七牛云，以及腾讯云

    阿里云存储服务

import com.aliyun.oss.OSSClient;
import com.hannan.ehu.common.exception.RRException;

import java.io.ByteArrayInputStream;
import java.io.InputStream;

/**
 * 阿里云存储
 */
public class AliyunCloudStorageService extends CloudStorageService {
    private OSSClient client;

    public AliyunCloudStorageService(CloudStorageConfig config){
        this.config = config;
        //初始化
        init();
    }

    private void init(){
        client = new OSSClient(config.getAliyunEndPoint(), config.getAliyunAccessKeyId(),
                config.getAliyunAccessKeySecret());
    }

    @Override
    public String upload(byte[] data, String path) {
        return upload(new ByteArrayInputStream(data), path);
    }

    @Override
    public String upload(InputStream inputStream, String path) {
        try {
            client.putObject(config.getAliyunBucketName(), path, inputStream);
        } catch (Exception e){
            throw new RRException("上传文件失败，请检查配置信息", e);
        }

        return config.getAliyunDomain() + "/" + path;
    }

    @Override
    public String uploadSuffix(byte[] data, String suffix) {
        return upload(data, getPath(config.getAliyunPrefix(), suffix));
    }

    @Override
    public String uploadSuffix(InputStream inputStream, String suffix) {
        return upload(inputStream, getPath(config.getAliyunPrefix(), suffix));
    }
}

腾讯云存储服务

import com.hannan.ehu.common.exception.RRException;
import com.qcloud.cos.COSClient;
import com.qcloud.cos.ClientConfig;
import com.qcloud.cos.request.UploadFileRequest;
import com.qcloud.cos.sign.Credentials;
import net.sf.json.JSONObject;
import org.apache.commons.io.IOUtils;

import java.io.IOException;
import java.io.InputStream;

/**
 * 腾讯云存储
 */
public class QcloudCloudStorageService extends CloudStorageService {
    private COSClient client;

    public QcloudCloudStorageService(CloudStorageConfig config){
        this.config = config;
        //初始化
        init();
    }

    private void init(){
        Credentials credentials = new Credentials(config.getQcloudAppId(), config.getQcloudSecretId(),
                config.getQcloudSecretKey());

        //初始化客户端配置
        ClientConfig clientConfig = new ClientConfig();
        //设置bucket所在的区域，华南：gz 华北：tj 华东：sh
        clientConfig.setRegion(config.getQcloudRegion());

        client = new COSClient(clientConfig, credentials);
    }

    @Override
    public String upload(byte[] data, String path) {
        //腾讯云必需要以"/"开头
        if(!path.startsWith("/")) {
            path = "/" + path;
        }

        //上传到腾讯云
        UploadFileRequest request = new UploadFileRequest(config.getQcloudBucketName(), path, data);
        String response = client.uploadFile(request);

        JSONObject jsonObject = JSONObject.fromObject(response);
        if(jsonObject.getInt("code") != 0) {
            throw new RRException("文件上传失败，" + jsonObject.getString("message"));
        }

        return config.getQcloudDomain() + path;
    }

    @Override
    public String upload(InputStream inputStream, String path) {
        try {
            byte[] data = IOUtils.toByteArray(inputStream);
            return this.upload(data, path);
        } catch (IOException e) {
            throw new RRException("上传文件失败", e);
        }
    }

    @Override
    public String uploadSuffix(byte[] data, String suffix) {
        return upload(data, getPath(config.getQcloudPrefix(), suffix));
    }

    @Override
    public String uploadSuffix(InputStream inputStream, String suffix) {
        return upload(inputStream, getPath(config.getQcloudPrefix(), suffix));
    }
}

七牛云存储

import com.hannan.ehu.common.exception.RRException;
import com.qiniu.common.Zone;
import com.qiniu.http.Response;
import com.qiniu.storage.Configuration;
import com.qiniu.storage.UploadManager;
import com.qiniu.util.Auth;
import org.apache.commons.io.IOUtils;

import java.io.IOException;
import java.io.InputStream;

/**
 * 七牛云存储
 */
public class QiniuCloudStorageService extends CloudStorageService {
    private UploadManager uploadManager;
    private String token;

    public QiniuCloudStorageService(CloudStorageConfig config){
        this.config = config;
        //初始化
        init();
    }

    private void init(){
        uploadManager = new UploadManager(new Configuration(Zone.autoZone()));
        token = Auth.create(config.getQiniuAccessKey(), config.getQiniuSecretKey()).
                uploadToken(config.getQiniuBucketName());
    }

    @Override
    public String upload(byte[] data, String path) {
        try {
            Response res = uploadManager.put(data, path, token);
            if (!res.isOK()) {
                throw new RuntimeException("上传七牛出错：" + res.toString());
            }
        } catch (Exception e) {
            throw new RRException("上传文件失败，请核对七牛配置信息", e);
        }
        return config.getQiniuDomain() + "/" + path;
    }

    @Override
    public String upload(InputStream inputStream, String path) {
        try {
            byte[] data = IOUtils.toByteArray(inputStream);
            return this.upload(data, path);
        } catch (IOException e) {
            throw new RRException("上传文件失败", e);
        }
    }

    @Override
    public String uploadSuffix(byte[] data, String suffix) {
        return upload(data, getPath(config.getQiniuPrefix(), suffix));
    }

    @Override
    public String uploadSuffix(InputStream inputStream, String suffix) {
        return upload(inputStream, getPath(config.getQiniuPrefix(), suffix));
    }
}

公共接口服务

import org.apache.commons.lang.StringUtils;

import java.io.InputStream;
import java.util.Date;
import java.util.UUID;

/**
 * 云存储(支持七牛、阿里云、腾讯云)
 */
public abstract class CloudStorageService {
    /** 云存储配置信息 */
    CloudStorageConfig config;

    /**
     * 文件路径
     * @param prefix 前缀
     * @param suffix 后缀
     * @return 返回上传路径
     */
    public String getPath(String prefix, String suffix) {
        //生成uuid
        String uuid = UUID.randomUUID().toString().replaceAll("-", "");
        //文件路径
        String path = DateUtils.format(new Date(), "yyyyMMdd") + "/" + uuid;

        if(StringUtils.isNotBlank(prefix)){
            path = prefix + "/" + path;
        }

        return path + suffix;
    }

    /**
     * 文件上传
     * @param data    文件字节数组
     * @param path    文件路径，包含文件名
     * @return        返回http地址
     */
    public abstract String upload(byte[] data, String path);

    /**
     * 文件上传
     * @param data     文件字节数组
     * @param suffix   后缀
     * @return         返回http地址
     */
    public abstract String uploadSuffix(byte[] data, String suffix);

    /**
     * 文件上传
     * @param inputStream   字节流
     * @param path          文件路径，包含文件名
     * @return              返回http地址
     */
    public abstract String upload(InputStream inputStream, String path);

    /**
     * 文件上传
     * @param inputStream  字节流
     * @param suffix       后缀
     * @return             返回http地址
     */
    public abstract String uploadSuffix(InputStream inputStream, String suffix);
}

配置类

package com.hannan.ehu.common.cloud;

import lombok.Data;
import org.hibernate.validator.constraints.Range;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

import java.io.Serializable;

/**
 * 云存储配置信息
 */
@Component
@Data
public class CloudStorageConfig implements Serializable {
    private static final long serialVersionUID = 1L;

    //类型 1：七牛  2：阿里云  3：腾讯云
    @Range(min=1, max=3, message = "类型错误")
    @Value("${cloudStorageConfig.type}")
    private Integer type;

    //七牛绑定的域名
    @Value("${cloudStorageConfig.qiniuDomain}")
    private String qiniuDomain;
    //七牛路径前缀
    @Value("${cloudStorageConfig.qiniuPrefix}")
    private String qiniuPrefix;
    //七牛ACCESS_KEY
    @Value("${cloudStorageConfig.qiniuAccessKey}")
    private String qiniuAccessKey;
    //七牛SECRET_KEY
    @Value("${cloudStorageConfig.qiniuSecretKey}")
    private String qiniuSecretKey;
    //七牛存储空间名
    @Value("${cloudStorageConfig.qiniuBucketName}")
    private String qiniuBucketName;

    //阿里云绑定的域名
    private String aliyunDomain;
    //阿里云路径前缀
    private String aliyunPrefix;
    //阿里云EndPoint
    private String aliyunEndPoint;
    //阿里云AccessKeyId
    private String aliyunAccessKeyId;
    //阿里云AccessKeySecret
    private String aliyunAccessKeySecret;
    //阿里云BucketName
    private String aliyunBucketName;

    //腾讯云绑定的域名
    private String qcloudDomain;
    //腾讯云路径前缀
    private String qcloudPrefix;
    //腾讯云AppId
    private Integer qcloudAppId;
    //腾讯云SecretId
    private String qcloudSecretId;
    //腾讯云SecretKey
    private String qcloudSecretKey;
    //腾讯云BucketName
    private String qcloudBucketName;
    //腾讯云COS所属地区
    private String qcloudRegion;
}

日期工具类

package com.hannan.ehu.common.cloud;

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

/**
 * 日期处理
 * 
 * @author chenshun
 * @email sunlightcs@gmail.com
 * @date 2016年12月21日 下午12:53:33
 */
public class DateUtils {
    /** 时间格式(yyyy-MM-dd) */
    public final static String DATE_PATTERN = "yyyy-MM-dd";
    /** 时间格式(yyyy-MM-dd HH:mm:ss) */
    public final static String DATE_TIME_PATTERN = "yyyy-MM-dd HH:mm:ss";

    public static String format(Date date) {
        return format(date, DATE_PATTERN);
    }

    public static String format(Date date, String pattern) {
        if(date != null){
            SimpleDateFormat df = new SimpleDateFormat(pattern);
            return df.format(date);
        }
        return null;
    }
}

工厂类

package com.hannan.ehu.common.cloud;

/**
 * 文件上传Factory
 * @author chenshun
 * @email sunlightcs@gmail.com
 * @date 2017-03-26 10:18
 */
public final class OSSFactory {
    private static Interger QINIU_Cloud = 1;
    private static Interger ALIYUN_Cloud = 2;
    private static Interger QCLOUD_Cloud = 3;
    public static CloudStorageService build(CloudStorageConfig config){
        if(config.getType() == QINIU_Cloud ){
            return new QiniuCloudStorageService(config);
        }else if(config.getType() == ALIYUN_Cloud){
            return new AliyunCloudStorageService(config);
        }else if(config.getType() == QCLOUD_Cloud){
            return new QcloudCloudStorageService(config);
        }
        return null;
    }
}

调用文件上传

 @Autowired
 private CloudStorageConfig config;
@ApiOperation(value = "上传图片", notes = "code 200 成功,返回所有大小图片的地址")
    @PostMapping("/uploadPicture")
    public R uploadPicture(@RequestBody MultipartFile file) {
        String minUrl=OSSFactory.build(config).uploadSuffix(CompressUtils.getMinInputStream(file),".jpg");
        String midUrl =OSSFactory.build(config).uploadSuffix(CompressUtils.getMiddleInputStream(file),".jpg");
        String maxUrl =OSSFactory.build(config).uploadSuffix(CompressUtils.getMaxInputStream(file),".jpg");
        String supperUrl =OSSFactory.build(config).uploadSuffix(CompressUtils.getSupperInputStream(file),".jpg");
        String oriUrl =OSSFactory.build(config).uploadSuffix(CompressUtils.getOrginInputStream(file),".jpg");
        return R.ok(oriUrl).put("maxUrl",maxUrl).put("midUrl",midUrl).put("minUrl",minUrl).put("supperUrl",supperUrl);
    }

到此三方上传完结。

附上配置文件获取链接
七牛云注册并获取配置
阿里云对象存储服务开通
腾讯云对象云存储开通

vpk112
关注
  • 0
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【CV算法工程师必看】作为一个图像算法工程师，需要会什么，要学哪些技术栈？
weixin_45037357的博客
06-07 638
作为一个图像算法工程师，除了基本的编程技能和理论知识，还需要掌握一系列的技术栈。
java后端接收 post_JAVA后端接收处理上传图片 超级简单
weixin_34749048的博客
01-27 5243
使用MultipartFile进行接收上传图片非常的简单。文中实例是博智互联在SpringBoot项目上，使用Spring MVC的MultipartFile类在JAVA后端 接收前端上传文件的请求。这里只给大家处理controller层，server保存逻辑具体使用什么技术保存持久化大家可以任意发挥。MultipartFile 单文件图片上传。接收文件，先保存文件，再把文件保存到对象，再保存对象...
上传图片的前后端操作
sun_qqq的博客
10-19 1万+
一：前端 前端思路，可是使用formdata模拟form表单，使用fileReader将图片存成DataURL，上传后端。 二：后端
图片上传及图片处理-----前端技术栈（基础篇）
qq_36389107的博客
08-30 909
1.实现需求 对于图片上传，分为单张上传，和多张上传。以下以多张图片上传。分析图片上传步骤 单图片上传前，一般会做以下处理。 判断图片大小，超过200kb，会在前端进行等比压缩 压缩完成后，需要将压缩的base64转换为blob 将blob作为url放入img中进行预览 blob上传到服务器 基于以上需求，我们实现一个demo 2.功能实现 1.图片上传前处理 // 预览及上传...
[前后端基础]图片传输与异步
最新发布
警警的博客
05-08 862
[前后端基础]图片传输与异步
一文带你看懂 前后端之间图片的上传与回显
m0_48069349的博客
03-22 1793
看了很多类似的文章，发现很多文章，要不就是不对，要不就是代码写的不通俗易懂，所以有了这篇文章，我将会从原理到实战，带你了解 实战包含前端 原生 vue3 react 后端springboot 主流框架来进行实现。
前端如何上传图片给后台？如何传递 multipart/form-data 类型的数据？图片大小、格式检查?
ladream的博客
03-07 2045
图片上传需要传二进制流，请求头的 content-type 类型需为 multipart/form-data，传递的格式如下图所示注：目前我只用过以上这种方法，我能想到的另一种方法是表单及其图片都用 multipart/form-data 格式传递过去，但我和后台目前没用过这种方法。
商业编程-源码-免费上传图片站程序.zip
06-23
总的来说，构建一个免费上传图片站程序涉及到的技术栈广泛，涵盖前端开发、后端开发、数据库设计、安全防护、性能优化等多个方面。通过分析这个源码，我们可以学习到实际项目中的开发流程和最佳实践，对提升我们的...
商业编程-源码-360免费图片上传系统.zip
06-20
【360免费图片上传系统】...以上仅是360免费图片上传系统可能涉及的部分技术栈和知识点，具体实现可能根据项目需求和团队技术选型有所不同。深入研究源码可以提供更详细的见解，有助于学习和理解实际项目中的工程实践。
基于Spring-Boot的外卖点餐
07-11
图片上传和下载: 利用对象存储服务（OOS）来实现用户上传头像或者餐厅上传菜品图片，并提供下载功能，确保图片的存储和访问效率。 技术栈和工具: 后端开发: 使用Spring Boot框架进行后端开发，利用Spring MVC处理...
图片上传接口-Json
08-02
7. **Web后端技术**：描述中的“Java web”表明服务器端使用了Java技术栈。在Java中，可以使用各种框架来处理图片上传，如Spring MVC、Struts2等，它们提供了方便的API来处理HTTP请求和响应，以及文件操作。 8. **...
midlet_servlet.rar_midlet-servlet
09-24
标签"midlet-servlet"进一步确认了这个项目的核心技术栈：Midlet（Java ME客户端）和Servlet（Java服务器端）。 在压缩包的文件列表中，我们可以看到以下几个关键文件： 1. ServletApp.class 和 ServletApp.java：...
基于javaweb+mysql的学生学科竞赛管理管理系统设计和实现(java+springboot+ssm)
m0_68552069的博客
10-26 978
基于javaweb+mysql的学生学科竞赛管理管理系统设计和实现(java+springboot+ssm) 运行环境 Java≥8、MySQL≥5.7 开发工具 eclipse/idea/myeclipse/sts等均可配置运行 适用 课程设计，大作业，毕业设计，项目练习，学习演示等 功能说明
java合成海报的工具类
weixin_33730836的博客
03-26 1123
2019独角兽企业重金招聘Python工程师标准>>> ...
图片上传处理
weixin_46189889的博客
07-23 135
实现将blob格式的图片发送到服务端，图片在服务端的地址保存在mysql中（代码均为为阶段代码，并非完整） （1）客户端代码 // 1 获取到input:file选中的图片文件对象 const file = DOM元素.file.files[0] // 2 获取图片文件对象的URL(用于图片预览，即blob数据) const img = window.URL.createObjectURL(file) // 3 预览图片配置(使用cropperjs) const cropper = new Crop..
前端上传图片到后端
热门推荐
freyaalisa的专栏
07-25 2万+
问题：前端上传了图片，后端该怎样处理才能获得图片的url？ 方法一、前端通过控件传给后端的是经过base64编码的字符串，后端拿到这个字符串后再经过base64解码，把解码后的图片存到服务器的某个位置，然后数据库中存储图片在服务器中路径。（以下代码是转自：http://www.cnblogs.com/libra0920/p/5754356.html） /** * @Descrip
easypoi 导出字节流并且上传到OSS
GG Bond
09-22 1210
protected void uploadExcel(Workbook workbook) { try { ByteArrayOutputStream bos = new ByteArrayOutputStream(); workbook.write(bos); byte[] datas = bos.toByteArray(); String url = OSSFa
图片上传到后端，但是再读取图片显示到前端就不显示
胖墩的IT博客
04-20 1万+
从头开始 前端 <script type="text/javascript"> // 选择图片显示 function imgChange(obj) { //获取点击的文本框 var file =document.getElementById("file"); var imgUrl =window.URL.createObjectURL(file.fil...
阿里云OSS文件上传
helloyuanye的博客
07-04 1万+
阿里云oss文件上传
纹理生成图片系统设计与实现-Java-SpringBoot
"这篇文档是关于纹理生成图片系统设计与实现的本科毕业设计论文参考，主要涉及Java技术栈，包括SpringBoot、Mybatis、Ajax、Vue等，使用MySQL数据库，基于B/S架构和MVC模式。系统实现了字典管理、公告管理、图片管理...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值