java实现图片水印添加并自动上传七牛云

于 2024-06-18 11:28:25 发布
阅读量438 收藏 6
点赞数 3
分类专栏： 项目实战 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ghoul___/article/details/139768359
版权

图片左下角水印添加

满足需求：可以对不同类型尺寸的照片、图片进行水印的添加，实现尺寸自适应添加水印。

水印效果

在这里插入图片描述

代码实现

Controller

package com.wlh.zetc.restore.controller;

import cn.hutool.core.date.DateUtil;
import com.alibaba.nacos.client.utils.TenantUtil;
import com.wlh.zetc.admin.api.feign.RemoteTenantService;
import com.wlh.zetc.common.core.util.R;
import com.wlh.zetc.common.data.tenant.TenantBroker;
import com.wlh.zetc.common.data.tenant.TenantContextHolder;
import com.wlh.zetc.restore.service.QiniuService;
import com.wlh.zetc.restore.utils.ComplexWatermarkUtils;
import com.wlh.zetc.restore.utils.TextUtils;
import io.swagger.v3.oas.annotations.security.SecurityRequirement;
import io.swagger.v3.oas.annotations.tags.Tag;
import lombok.AllArgsConstructor;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpHeaders;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;

import javax.annotation.Resource;
import java.io.IOException;
import java.io.InputStream;
import java.io.UnsupportedEncodingException;
import java.util.HashMap;
import java.util.Map;

/**
 * 七牛云存储
 *
 * @author wanghailin
 * @date 2024-03-12 10:19:56
 */
@Controller
@RequestMapping("/qiniu" )
@Tag(description = "file" , name = "七牛云文件存储" )
@AllArgsConstructor
//@SecurityRequirement(name = HttpHeaders.AUTHORIZATION)
public class QiniuController
{
	private final QiniuService qiniuService;
	private final ComplexWatermarkUtils complexWatermarkUtils;
	/**
	 *
	 * @param file
	 * @param location
	 * @param latitudeLongitude
	 * @param remarks
	 * @param weather
	 * @param watermark 0:不添加水印 1：添加水印 2：添加水印但是不添加天气、位置、经纬度
	 * @return
	 * @throws IOException
	 */
	@PostMapping("/image/upload")
	@ResponseBody
	public R uploadImage(@RequestParam(value = "file", required = false) MultipartFile file,
						 @RequestParam(value = "location", required = false) String location,
						 @RequestParam(value = "latitudeLongitude", required = false) String latitudeLongitude,
						 @RequestParam(value = "remarks", required = false) String remarks,
						 @RequestParam(value = "weather", required = false) String weather,
						 @RequestParam(value = "watermark", required = false,defaultValue = "1") Integer watermark) throws IOException {
		MultipartFile multipartFile = null;
		if (watermark != null && watermark.equals(0)){
			multipartFile = file;
		}else {
			multipartFile = complexWatermarkUtils.addComplexWatermark(file, DateUtil.now(), location, weather,latitudeLongitude,remarks,watermark);
		}
		System.out.println(multipartFile.getSize());
		if(!multipartFile.isEmpty())
		{
			InputStream in = multipartFile.getInputStream();
			String filename = multipartFile.getOriginalFilename();
			String project = "project"+ TenantContextHolder.getTenantId()+"/";
			try
			{
				String key = project+ TextUtils.generateFileName(filename);
				String imageUrl = qiniuService.uploadImage2qiniu(in,key);
				if(imageUrl!=null)
				{
					HashMap<String, String> map = new HashMap<>();
					String privateDownloadUrl = qiniuService.getPrivateDownloadUrl(imageUrl);
					map.put("url",imageUrl);
					map.put("accessibleUrl",privateDownloadUrl);
					return R.ok(map).setMsg("上传成功");
				}
			}
			catch(IllegalArgumentException e)
			{
				e.printStackTrace();
			}
		}
		return R.failed("上传失败");
	}

	@DeleteMapping("/image/delete")
	@ResponseBody
	public R deleteImage(@RequestParam("image")String imageUrl)
	{
		boolean deleted = qiniuService.deleteImageFromQiniu(imageUrl);
		if(deleted)
		{
			return R.ok(null,"删除成功");
		}
		return R.failed("删除失败");
	}


	@GetMapping("/image/download")
	@ResponseBody
	public R downloadImage(@RequestParam("image")String imageUrl)
	{
		try {
			String privateDownloadUrl = qiniuService.getPrivateDownloadUrl(imageUrl);
			Map<String, String> map = new HashMap<>();
			map.put("url",privateDownloadUrl);
			return R.ok().setData(map);
		} catch (UnsupportedEncodingException e) {
			e.printStackTrace();
		}
		return R.ok();
	}
}

Utils

package com.wlh.zetc.restore.utils;

import cn.hutool.core.img.ImgUtil;
import cn.hutool.core.io.IoUtil;
import com.baomidou.mybatisplus.core.toolkit.StringUtils;
import com.drew.imaging.ImageMetadataReader;
import com.drew.metadata.Directory;
import com.drew.metadata.Metadata;
import com.drew.metadata.Tag;
import com.wlh.zetc.admin.api.entity.SysTenant;
import com.wlh.zetc.admin.api.feign.RemoteTenantService;
import com.wlh.zetc.admin.api.feign.RemoteUserService;
import com.wlh.zetc.common.core.util.R;
import com.wlh.zetc.common.data.tenant.TenantContextHolder;
import com.wlh.zetc.common.security.util.SecurityUtils;
import lombok.AllArgsConstructor;
import lombok.NoArgsConstructor;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.mock.web.MockMultipartFile;
import org.springframework.stereotype.Service;
import org.springframework.web.multipart.MultipartFile;

import javax.imageio.ImageIO;
import java.awt.*;
import java.awt.image.BufferedImage;
import java.io.*;
import java.net.HttpURLConnection;
import java.net.URL;
import java.util.ArrayList;
import java.util.List;

/**
 * 至农水印处理工具类
 *
 * @author wanghailin
 * @date 2024-03-18 10:49:33
 */
@Service
@AllArgsConstructor
public class ComplexWatermarkUtils {

	private final RemoteTenantService tenantService;

	//水印图片地址
	private static String watermarkImageURL = "https://qiniu.zjshjkj.com/logo/zhinong12.png";

	//水印添加
	public MultipartFile addComplexWatermark(MultipartFile file, String time, String location, String weather, String latitudeLongitude, String remarks,Integer watermark) {
		try {

			//MultipartFile multipartFile = correctImg(file);
			BufferedImage srcImg = null;
			srcImg = ImgUtil.read(file.getInputStream());
			Graphics2D g2d = srcImg.createGraphics();
			g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
			int watermarkAreaHeight = (int) (srcImg.getHeight() * 0.10);
			int watermarkAreaWide = (int) (srcImg.getWidth() * 0.01);
			BufferedImage watermarkImage = ImgUtil.read(getWatermarkImage(watermarkImageURL).getInputStream());
			int scaledWatermarkWidth = watermarkImage.getWidth() * watermarkAreaHeight / watermarkImage.getHeight();
			Image scale = ImgUtil.scale(watermarkImage, scaledWatermarkWidth, watermarkAreaHeight);

			int x = watermarkAreaWide;
			int y = watermarkAreaHeight * 7 - watermarkAreaHeight / 2;
			g2d.drawImage(scale, x, y, null);
			//获取当前项目名称
			R tenant = tenantService.getByTenantId(TenantContextHolder.getTenantId());
			SysTenant project = (SysTenant) tenant.getData();
			// 设置较大字体属性，仅用于 projectName
			int projectNameFontSize = watermarkAreaHeight / 3;
			Font projectNameFont = new Font("宋体", Font.BOLD, projectNameFontSize);
			g2d.setFont(projectNameFont);
			g2d.setColor(Color.WHITE);
			// 将 projectName 分割为多行文本
			if(StringUtils.isNotEmpty(project.getName())){
				List<String> projectNameLines =splitTextToLines(project.getName(), 20);
				int projectNameY = y + watermarkAreaHeight +projectNameFontSize;
				for (String line : projectNameLines) {
					g2d.drawString(line, x, projectNameY);
					projectNameY += g2d.getFontMetrics().getHeight();
				}
				// 设置文本属性，根据水印区域大小调整字体大小
				int fontSize = watermarkAreaHeight / 5;
				Font font = new Font("宋体", Font.BOLD, fontSize);
				g2d.setFont(font);
				FontMetrics metrics = g2d.getFontMetrics(font);
				int textHeight = metrics.getHeight();
				// 绘制黄色竖杠
				g2d.setColor(Color.YELLOW);
				int barX = x;
				int barY = projectNameY - watermarkAreaHeight / 3; // 根据 projectName 的最终位置调整
				if(watermark.equals(2)){
					g2d.fillRect(barX, barY, textHeight /4, textHeight * 2 + 5 * 3);
				}else {
					g2d.fillRect(barX, barY, textHeight /4, textHeight * 5 + 5 * 3);
				}
				g2d.setColor(Color.WHITE);
				int textX = barX + watermarkAreaWide ;
				int textY = barY + textHeight;

				if(!StringUtils.isNotEmpty(remarks)){
					remarks = "";
				}
				if(watermark.equals(2)){
					String[] texts = new String[]{"时 间："+time, "备 注："+remarks};
					for (String text : texts) {
						g2d.drawString(text, textX, textY);
						textY += textHeight + 5;
					}
				}else {
					String[] texts = new String[]{"时 间："+time, "地 点："+location, "天 气："+weather, "经纬度："+latitudeLongitude, "备 注："+remarks};
					for (String text : texts) {
						g2d.drawString(text, textX, textY);
						textY += textHeight + 5;
					}
				}
			}

			g2d.dispose();
			ByteArrayOutputStream baos = new ByteArrayOutputStream();
			try {
				ImageIO.write(srcImg, "png", baos);
			} catch (Exception e) {
				e.printStackTrace();
				return null;
			}
			MultipartFile resultFile = new MockMultipartFile(file.getName(), file.getOriginalFilename(), file.getContentType(), baos.toByteArray());
			IoUtil.close(baos);
			return resultFile;
		} catch (IOException e) {
			e.printStackTrace();
			return null;
		}
	}

	//文件下载
	public static MultipartFile getWatermarkImage(String fileUrl) {
		try {
			URL url = new URL(fileUrl);
			HttpURLConnection httpURLConnection = (HttpURLConnection) url.openConnection();
			httpURLConnection.setRequestMethod("GET");
			httpURLConnection.connect();
			String fileName = fileUrl.substring(fileUrl.lastIndexOf("/") + 1);
			String contentType = httpURLConnection.getContentType();
			InputStream inputStream = httpURLConnection.getInputStream();
			ByteArrayOutputStream baos = new ByteArrayOutputStream();
			byte[] buffer = new byte[1024];
			int len;
			while ((len = inputStream.read(buffer)) > -1) {
				baos.write(buffer, 0, len);
			}
			baos.flush();
			MultipartFile multipartFile = new MockMultipartFile(fileName, fileName, contentType, baos.toByteArray());
			inputStream.close();
			baos.close();
			return multipartFile;
		} catch (Exception e) {
			e.printStackTrace();
			return null;
		}
	}

	//图片矫正
	public static MultipartFile correctImg(MultipartFile srcFile) {
		File outFile = new File(srcFile.getName());
		try (FileOutputStream fos = new FileOutputStream(outFile)) {
			int angle = getAngle(srcFile);
			if (angle != 90 && angle != 270) {
				// todo 不需要旋转，直接返回
				return srcFile;
			} else {
				BufferedImage srcImg = ImageIO.read(srcFile.getInputStream());
				int imgWidth = srcImg.getHeight();
				int imgHeight = srcImg.getWidth();
				double centerWidth = ((double) imgWidth) / 2;
				double centerHeight = ((double) imgHeight) / 2;
				BufferedImage targetImg = new BufferedImage(imgWidth, imgHeight, BufferedImage.TYPE_INT_RGB);
				Graphics2D g = targetImg.createGraphics();
				g.rotate(Math.toRadians(angle), centerWidth, centerHeight);
				g.drawImage(srcImg, (imgWidth - srcImg.getWidth()) / 2, (imgHeight - srcImg.getHeight()) / 2, null);
				g.rotate(Math.toRadians(-angle), centerWidth, centerHeight);
				g.dispose();
				// 输出图片
				ImageIO.write(targetImg, "jpg", fos);
				ByteArrayOutputStream baos = new ByteArrayOutputStream();
				try {
					ImgUtil.write(srcImg, srcFile.getContentType(), baos);
				} catch (Exception e) {
					e.printStackTrace();
					return null;
				}
				MultipartFile resultFile = new MockMultipartFile(srcFile.getName(), srcFile.getOriginalFilename(), srcFile.getContentType(), baos.toByteArray());
				IoUtil.close(baos);
				return resultFile;
			}
		} catch (Exception e) {
			e.printStackTrace();
			return null;
		}
	}

	//角度判断
	private static int getAngle(MultipartFile file) throws Exception {
		Metadata metadata = ImageMetadataReader.readMetadata(file.getInputStream());
		for (Directory directory : metadata.getDirectories()) {
			for (Tag tag : directory.getTags()) {
				if ("Orientation".equals(tag.getTagName())) {
					String orientation = tag.getDescription();
					if (orientation.contains("90")) {
						return 90;
					} else if (orientation.contains("180")) {
						return 180;
					} else if (orientation.contains("270")) {
						return 270;
					}
				}
			}
		}
		return 0;
	}

	// 辅助方法：将文本分割为多行
	private static List<String> splitTextToLines(String text, int maxCharsPerLine) {
		List<String> lines = new ArrayList<>();
		for (int start = 0; start < text.length(); start += maxCharsPerLine) {
			int end = Math.min(start + maxCharsPerLine, text.length());
			lines.add(text.substring(start, end));
		}
		return lines;
	}
}

七牛云service

package com.wlh.zetc.restore.service;

import java.io.InputStream;
import java.io.UnsupportedEncodingException;

/**
 * 七牛文件存储
 *
 * @author wanghailin
 * @date 2024-03-12 10:21:35
 */
public interface QiniuService {
	String uploadImage2qiniu(InputStream in, String key);
	boolean deleteImageFromQiniu(String key);
	String getPrivateDownloadUrl(String fileName) throws UnsupportedEncodingException;

}

七牛云impl

package com.wlh.zetc.restore.service.impl;

import com.google.gson.Gson;
import com.qiniu.common.QiniuException;
import com.qiniu.common.Zone;
import com.qiniu.http.Response;
import com.qiniu.storage.*;
import com.qiniu.storage.model.DefaultPutRet;
import com.qiniu.util.Auth;
import com.wlh.zetc.restore.properties.QiniuProperties;
import com.wlh.zetc.restore.service.QiniuService;
import com.wlh.zetc.restore.utils.TextUtils;
import io.netty.channel.unix.Unix;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.io.InputStream;
import java.io.UnsupportedEncodingException;
import java.net.URLEncoder;

/**
 * 七牛文件存储
 *
 * @author wanghailin
 * @date 2024-03-12 10:21:35
 */
@Service
public class QiniuServiceImpl implements QiniuService
{
	private final String domain;
	private final String bucketName;
	private final String ak;
	private final String sk;

	// 七牛文件上传管理器
	private final Configuration cfg;
	private final Auth auth;

	@Autowired
	public QiniuServiceImpl(QiniuProperties oss)
	{
		this.ak = oss.getAccessKey();
		this.sk = oss.getSecretKey();
		this.domain = oss.getDomain(); // CDN域名
		this.bucketName = oss.getBucketName();

		// //构造一个带指定 Region 对象的配置类
		cfg = new Configuration(Zone.zone0());
		auth = Auth.create(ak,sk);
	}

	/**
	 * 上传图片到七牛云
	 * @return 图片url
	 * */
	@Override
	public String uploadImage2qiniu(InputStream in, String key)
	{
		try {
			UploadManager uploadManager = new UploadManager(cfg);
			// 根据命名空间生成的上传token
			String upToken = auth.uploadToken(bucketName);
			Response response = uploadManager.put(in,key,upToken,null, null);
			//解析上传成功的结果
			DefaultPutRet putRet = new Gson().fromJson(response.bodyString(), DefaultPutRet.class);
			//System.out.println(putRet.key);
			//System.out.println(putRet.hash);
            //return String.format("http://%s/%s",this.domain,putRet.key);
			return putRet.key;
		} catch (QiniuException ex) {
			Response r = ex.response;
			System.err.println(r.toString());
			try {
				System.err.println(r.bodyString());
			} catch (QiniuException ex2) {
				//ignore
			}
		}
		return null;
	}
	/**
	 * 删除图片
	 * */
	@Override
	public boolean deleteImageFromQiniu(String imageUrl)
	{
		BucketManager bucketManager = new BucketManager(auth, cfg);
		try {
			String key= TextUtils.getKey(imageUrl);
			Response response = bucketManager.delete(bucketName,key);
			return response.isOK();
		} catch (QiniuException ex) {
			//如果遇到异常，说明删除失败
			System.err.println(ex.code());
			System.err.println(ex.response.toString());
		}
		return false;
	}


	/**
	 * 获取文件下载路径
	 *
	 * @param fileName
	 * @return
	 * @throws UnsupportedEncodingException
	 */
	public String getPrivateDownloadUrl(String fileName) throws UnsupportedEncodingException {
		//文件https访问配置
		DownloadUrl url = new DownloadUrl(domain, true, fileName);
		//DownloadUrl url = new DownloadUrl(domain, false, fileName);
		long expireInSeconds = 3600;//1小时，可以自定义链接过期时间
		long deadline = System.currentTimeMillis()/1000 + expireInSeconds;
		Auth auth = Auth.create(ak, sk);
        String urlString = null;
        try {
            urlString = url.buildURL(auth, deadline);
        } catch (QiniuException e) {
            throw new RuntimeException(e);
        }
		return urlString;

	}
}

七牛云配置类

package com.wlh.zetc.restore.properties;

import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;
/**
 * 七牛文件存储
 *
 * @author wanghailin
 * @date 2024-03-12 10:21:35
 */
@Component
@ConfigurationProperties(prefix = "oss.qiniu")
@Data
public class QiniuProperties
{
	private String domain; // CDN域名
	private String accessKey; // ACCESS_KEY
	private String secretKey; // SECRET_KEY
	private String bucketName; // 空间名称
}

七牛云配置yml

oss:
  qiniu:
    domain: qiniu.znkj0215.com # 访问域名(正式访问域名地址) 暂未配置https
#    domain: qiniu.iswhl.com # 访问域名(测试访问域名地址) 已配置https
    accessKey: APlM_0fW1A_PRS5bQ92rdGf9oSW-5q9mZK3Tv6yk # 公钥
    secretKey: Ri2eN9h4htBjZa8J8n_7QBfsAAvM_Arz5_CLqWth # 私钥
    bucketName: zhinonggengdi  #存储空间名称
三横同学
关注
  • 3
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
七牛云 转码_七牛云4：上传后自动添加水印、视频转码
weixin_42537919的博客
12-24 1538
为了不让别人盗取资源盗的那么爽，我们有时候需要对图片／视频添加水印，也有可能对视频进行一些转码，这在七牛云中都比较容易实现。在七牛云上传文件之前，是需要先进行一些配置的，如配置scope，上传token的截至时间deadline，返回的数据returnBody，回调地址callbackUrl等等，图片水印设置需要设置persistentOps 和persistentPipeline。{"scope...
android七牛云存储,使用七牛云存储上传android本地视频并播放
weixin_34626779的博客
05-26 1135
项目最近又来了添加视频的需求，暂定存储到七牛。具体步骤大致分为三步：1:获取本地视频缩略图展示，当用户选择某一段视频时，拿到该视频的地址。2:通过七牛sdk，将该视频地址传入，上传到七牛云存储，然后获取视频videoUrl和videoThumail。3:通过视频播放器播放视频。2017-06-21 20_59_30.gif一：获取视频列表并在手机中展示。这里大致可以分为一下几步：1:由于获取视频列...
java 图片回显_java实现Simditor图片上传七牛云并回显
weixin_39606911的博客
02-21 335
首先呢，我们有这样一个需求：当图片上传Simditor时，将其保存到七牛云上，然后并回显在我们的Simditor中。首先，需要我们有一个七牛云帐号，并且配置Simditor富文本编辑器。其次，我们需要在写文章的jsp页面配置以下js$(function() {var editor,toolbar;Simditor.locale = 'zh-CN';toolbar = ['title', 'bold...
使用七牛上传图片并加水印
热门推荐
志远的博客
03-16 1万+
这里介绍的面板操作，所使用的界面是旧版的界面，如下图所示 如果是在新版的界面，请切换到旧版界面，操作如下 新建一个存储空间（bucket），操作如下 新建一个队列，操作如下 查看自己的密钥，操作如下 创建图片样式，操作如下 在java的maven工程中，导入相关jar包 com.qiniu
java上传图片到七牛云 七牛云 七牛 图片上传 demo JS java
01-05
在本文中，我们将深入探讨如何使用Java和JavaScript将图片上传到七牛云存储服务。七牛云是一个提供云端存储和CDN加速的平台，广泛应用于图片、视频等多媒体资源的托管。图片上传功能是其核心服务之一，为开发者提供...
七牛云上传图片添加水印
12-26
七牛云上传图片实现添加水印java代码测试类注意事项要先获取七牛的ak，sk以及空间水印样式
java实现七牛云图片文件的上传
12-23
java实现七牛云图片文件的上传 七牛云：https://portal.qiniu.com/create#resource 首先需要去注册一个账号实现实名认证 之后打开七牛云的 我们需要先创建一个储存空间来给我们使用 这里的key也需要记录下来我们...
java springboot 七牛云文件上传，下载，删除
04-18
本文将详细介绍如何使用Spring Boot集成七牛云服务，实现文件的上传、下载和删除功能。 首先，我们需要在Spring Boot项目中引入七牛云的SDK。在`pom.xml`文件中添加对应的Maven依赖： ```xml <groupId>...
node koa2实现上传图片并且同步上传到七牛云存储
08-29
总的来说，这个示例展示了如何使用Node.js和Koa2框架搭建一个简单的图片上传服务，并结合七牛云存储实现图片的云端同步。这有助于在高并发和大文件上传场景下提高服务的稳定性和效率。为了保证服务的安全性，还可以...
Activi工作流引擎快速入门（整合idea）
三横同学的博客
09-04 4754
activi工作流引擎整合idea
记录问题：class “org.bouncycastle.asn1.ASN1Object“‘s signer information does not match signer information
三横同学的博客
09-14 3968
jar包冲突
关于Nginx配置Vue、nuxt请求代理的配置
三横同学的博客
09-05 1657
Nginx的使用
功能扩展——邮件发送、网页注册
三横同学的博客
07-15 1336
邮件收发 转自这位大佬 电子邮件 要在网络上实现邮件功能，必须要有专门的邮件服务器。 这些邮件服务器类似于现实生活中的邮局，它主要负责接收用户投递过来的邮件，并把邮件投递到邮件接收者的电子邮箱中。 SMTP服务器地址:一般是smtp.xxx.com，比如163邮箱是smtp.163.com，qq邮箱是smtp.qq.com, 电子邮箱(E-Mail地址)的获得需要在邮件服务器上进行申请。比如我们要使用QQ邮箱就需要开通邮箱功能; 传输协议 SMTP协议 发送邮件: 我们通常把处理用户smtp请求(邮件发送
三步教你异步调用@Async的使用
三横同学的博客
10-08 1204
@Async的使用
大文件word生成的处理与解决策略
最新发布
三横同学的博客
06-12 1184
对于简单word文档的生成导出，java已经有着很多技术来进行处理，在有着相对固定的格式样板下，采用word模板导出相对会是比较好的选择。但是当数据量且包含大量图片后，采用模板导出就显得无力了，模板的缺点是无法应对动态复杂的数据文档生成，这时候采用动态生成word是唯一的选择。问题背景：需要生成一个包含大量图片表格的word文档，该文档内容在百兆与1G中间 可以看到该模板是一个相当复杂的文件，既需要对不同类型的图片设置不同的格式还需要动态生成每个类型表格的位置，并将图片插入的word文件当中去control
mysql5.7版本 - 函数sql函数编写（减少sql代码量）
三横同学的博客
09-14 588
mysql5.7版本- 函数编写
实习中遇到的问题--（关于springBoot分页第一条数据查询不出来的问题）
三横同学的博客
10-19 586
解决办法： springBoot的分页默认是从0开始的，所以将返回过来的页面码在后台减1即可，显示成功；
java高级注解与反射的使用与思考
三横同学的博客
10-10 560
java高级注解与反射的使用与思考
layui实现小程序图片上传七牛云
04-12
您好，关于layui如何实现小程序图片上传七牛云，您可以参考以下步骤： 1. 在小程序配置文件中添加七牛云的AccessKey、SecretKey、Bucket等信息。 2. 利用七牛云提供的SDK或API实现图片上传功能。 3. 在小程序中使用layui的文件上传模块，并设置上传路径及回调函数，实现将客户端的图片上传到七牛云。 希望对您有所帮助！如果还有问题，请随时咨询。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

三横同学

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值