package jnpf.fileStorage.dms;
|
|
import jnpf.dmsEntity.preview.model.DmsWatermarkSnapshot;
|
import jnpf.exception.DataException;
|
import org.springframework.beans.BeanUtils;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.stereotype.Service;
|
|
import javax.imageio.IIOImage;
|
import javax.imageio.ImageReader;
|
import javax.imageio.ImageWriteParam;
|
import javax.imageio.ImageWriter;
|
import javax.imageio.stream.FileImageOutputStream;
|
import java.awt.Color;
|
import java.awt.Graphics2D;
|
import java.awt.RenderingHints;
|
import java.awt.image.BufferedImage;
|
import java.io.IOException;
|
import java.nio.file.Files;
|
import java.nio.file.Path;
|
import java.util.ArrayList;
|
import java.util.Iterator;
|
import java.util.List;
|
import java.util.Locale;
|
import java.util.concurrent.Semaphore;
|
import java.util.concurrent.TimeUnit;
|
|
@Service
|
public class DmsImageWatermarkService {
|
static final long MAX_SOURCE_BYTES = 50L * 1024L * 1024L;
|
static final int MAX_WATERMARKS = 16;
|
private static final int MAX_DIMENSION = 16_384;
|
private static final long MAX_PIXELS = 16_000_000L;
|
private static final int MAX_OUTPUT_BYTES = 100 * 1024 * 1024;
|
private static final long DEFAULT_RENDER_PERMIT_TIMEOUT_MILLIS = 5_000L;
|
|
private final DmsDocxWatermarkService rasterizer;
|
private final Semaphore renderPermit = new Semaphore(1, true);
|
private final long renderPermitTimeoutMillis;
|
|
@Autowired
|
public DmsImageWatermarkService(DmsDocxWatermarkService rasterizer) {
|
this(rasterizer, DEFAULT_RENDER_PERMIT_TIMEOUT_MILLIS);
|
}
|
|
DmsImageWatermarkService(DmsDocxWatermarkService rasterizer, long renderPermitTimeoutMillis) {
|
this.rasterizer = rasterizer;
|
this.renderPermitTimeoutMillis = Math.max(0L, renderPermitTimeoutMillis);
|
}
|
|
public byte[] apply(byte[] source, String fileName, List<DmsWatermarkSnapshot> watermarks) {
|
return apply(source, fileName, null, watermarks);
|
}
|
|
public byte[] apply(byte[] source, String fileName, String mimeType,
|
List<DmsWatermarkSnapshot> watermarks) {
|
return loadAndApply(() -> source, fileName, mimeType, watermarks);
|
}
|
|
byte[] loadAndApply(SourceReader sourceReader, String fileName, String mimeType,
|
List<DmsWatermarkSnapshot> watermarks) {
|
if (sourceReader == null) {
|
throw new DataException("图片源文件读取器未配置");
|
}
|
if (watermarks == null || watermarks.isEmpty()) {
|
return readSource(sourceReader);
|
}
|
List<DmsWatermarkSnapshot> applicable = applicableWatermarks(watermarks);
|
String expectedFormat = outputFormat(fileName, mimeType);
|
boolean acquired = false;
|
try {
|
acquired = renderPermit.tryAcquire(renderPermitTimeoutMillis, TimeUnit.MILLISECONDS);
|
if (!acquired) {
|
throw new DataException("图片水印处理繁忙，请稍后重试");
|
}
|
byte[] source = sourceReader.read();
|
if (source == null || source.length == 0) {
|
throw new DataException("图片内容为空，不能生成水印");
|
}
|
if (source.length > MAX_SOURCE_BYTES) {
|
throw new DataException("图片超过动态水印处理上限（50 MB）");
|
}
|
BufferedImage composed = readAndCompose(source, expectedFormat);
|
rasterizer.applyImageWatermarks(composed, applicable);
|
return write(composed, expectedFormat);
|
} catch (DataException exception) {
|
throw exception;
|
} catch (InterruptedException exception) {
|
Thread.currentThread().interrupt();
|
throw new DataException("图片水印处理已取消");
|
} catch (Exception exception) {
|
throw new DataException("生成图片水印失败：" + message(exception));
|
} finally {
|
if (acquired) {
|
renderPermit.release();
|
}
|
}
|
}
|
|
private byte[] readSource(SourceReader sourceReader) {
|
try {
|
return sourceReader.read();
|
} catch (DataException exception) {
|
throw exception;
|
} catch (Exception exception) {
|
throw new DataException("读取图片内容失败：" + message(exception));
|
}
|
}
|
|
private BufferedImage readAndCompose(byte[] source, String expectedFormat) throws Exception {
|
int orientation = "jpeg".equals(expectedFormat)
|
? DmsJpegExifOrientation.readOrientation(source) : 1;
|
try (DmsByteArrayImageInputStream input = new DmsByteArrayImageInputStream(source)) {
|
Iterator<ImageReader> readers = javax.imageio.ImageIO.getImageReaders(input);
|
if (!readers.hasNext()) {
|
throw new DataException("图片内容无法识别，不能生成水印");
|
}
|
ImageReader reader = readers.next();
|
try {
|
reader.setInput(input, false, false);
|
String actualFormat = normalizeFormat(reader.getFormatName());
|
if (!expectedFormat.equals(actualFormat)) {
|
throw new DataException("图片文件扩展名与实际格式不一致，不能生成水印");
|
}
|
int width = reader.getWidth(0);
|
int height = reader.getHeight(0);
|
validateDimensions(width, height);
|
if ("gif".equals(actualFormat) && hasMultipleGifFrames(source)) {
|
throw new DataException("暂不支持动态 GIF 水印，请先转换为 PNG 或 JPEG");
|
}
|
BufferedImage original = reader.read(0);
|
if (original == null) {
|
throw new DataException("图片内容无法解码，不能生成水印");
|
}
|
return compose(DmsJpegExifOrientation.normalize(original, orientation), expectedFormat);
|
} finally {
|
reader.dispose();
|
}
|
}
|
}
|
|
private List<DmsWatermarkSnapshot> applicableWatermarks(List<DmsWatermarkSnapshot> watermarks) {
|
List<DmsWatermarkSnapshot> result = new ArrayList<>();
|
if (watermarks == null) {
|
return result;
|
}
|
if (watermarks.size() > MAX_WATERMARKS) {
|
throw new DataException("单张图片最多支持 " + MAX_WATERMARKS + " 个水印");
|
}
|
for (DmsWatermarkSnapshot watermark : watermarks) {
|
if (watermark == null) {
|
throw new DataException("图片水印配置无效");
|
}
|
if (watermark.getRenderPages() != null && (watermark.getRenderPages().isEmpty()
|
|| watermark.getRenderPages().stream().anyMatch(page -> page == null || page != 1))) {
|
throw new DataException("图片只有第 1 页，不支持其他指定页水印");
|
}
|
DmsWatermarkSnapshot imageMark = new DmsWatermarkSnapshot();
|
BeanUtils.copyProperties(watermark, imageMark);
|
if ("TEXT".equalsIgnoreCase(value(imageMark.getWatermarkType(), "TEXT"))) {
|
imageMark.setContent(value(imageMark.getContent(), "")
|
.replace("{/CurrPage}", "1")
|
.replace("{/TotalPage}", "1"));
|
}
|
result.add(imageMark);
|
}
|
return result;
|
}
|
|
private BufferedImage compose(BufferedImage original, String format) {
|
boolean alpha = "png".equals(format) || "gif".equals(format);
|
BufferedImage result = new BufferedImage(original.getWidth(), original.getHeight(),
|
alpha ? BufferedImage.TYPE_INT_ARGB : BufferedImage.TYPE_INT_RGB);
|
Graphics2D graphics = result.createGraphics();
|
try {
|
graphics.setRenderingHint(RenderingHints.KEY_INTERPOLATION,
|
RenderingHints.VALUE_INTERPOLATION_BICUBIC);
|
if (!alpha) {
|
graphics.setColor(Color.WHITE);
|
graphics.fillRect(0, 0, result.getWidth(), result.getHeight());
|
}
|
graphics.drawImage(original, 0, 0, null);
|
} finally {
|
graphics.dispose();
|
}
|
return result;
|
}
|
|
private byte[] write(BufferedImage image, String format) throws Exception {
|
Iterator<ImageWriter> writers = javax.imageio.ImageIO.getImageWritersByFormatName(format);
|
if (!writers.hasNext()) {
|
throw new DataException("当前运行环境不能生成 " + format.toUpperCase(Locale.ROOT) + " 水印图片");
|
}
|
ImageWriter writer = writers.next();
|
Path outputFile = null;
|
try {
|
outputFile = Files.createTempFile("dms-watermark-", "." + format);
|
try (FileImageOutputStream output = new FileImageOutputStream(outputFile.toFile())) {
|
writer.setOutput(output);
|
ImageWriteParam parameters = writer.getDefaultWriteParam();
|
if ("jpeg".equals(format) && parameters.canWriteCompressed()) {
|
parameters.setCompressionMode(ImageWriteParam.MODE_EXPLICIT);
|
parameters.setCompressionQuality(0.92F);
|
}
|
writer.write(null, new IIOImage(image, null, null), parameters);
|
output.flush();
|
}
|
if (Files.size(outputFile) > MAX_OUTPUT_BYTES) {
|
throw new DataException("水印图片输出超过处理上限（100 MB）");
|
}
|
return Files.readAllBytes(outputFile);
|
} finally {
|
writer.dispose();
|
if (outputFile != null) {
|
try {
|
Files.deleteIfExists(outputFile);
|
} catch (IOException ignored) {
|
// Best-effort cleanup must not mask a successful render or its original failure.
|
}
|
}
|
}
|
}
|
|
private void validateDimensions(int width, int height) {
|
long pixels = (long) width * height;
|
if (width <= 0 || height <= 0 || width > MAX_DIMENSION || height > MAX_DIMENSION
|
|| pixels > MAX_PIXELS) {
|
throw new DataException("图片尺寸超过动态水印处理上限");
|
}
|
}
|
|
private boolean hasMultipleGifFrames(byte[] source) {
|
if (source.length < 13 || source[0] != 'G' || source[1] != 'I' || source[2] != 'F') {
|
return false;
|
}
|
int cursor = 13;
|
if ((source[10] & 0x80) != 0) {
|
cursor += 3 << ((source[10] & 0x07) + 1);
|
}
|
if (cursor > source.length) return true;
|
int frames = 0;
|
while (cursor < source.length) {
|
int blockType = source[cursor++] & 0xFF;
|
if (blockType == 0x3B) {
|
return false;
|
}
|
if (blockType == 0x00) {
|
continue;
|
}
|
if (blockType == 0x21) {
|
if (cursor >= source.length) return true;
|
cursor++;
|
cursor = skipGifSubBlocks(source, cursor);
|
if (cursor < 0) return true;
|
continue;
|
}
|
if (blockType != 0x2C || cursor + 9 > source.length) {
|
return true;
|
}
|
if (++frames > 1) {
|
return true;
|
}
|
int packed = source[cursor + 8] & 0xFF;
|
cursor += 9;
|
if ((packed & 0x80) != 0) {
|
cursor += 3 << ((packed & 0x07) + 1);
|
}
|
if (cursor >= source.length) return true;
|
cursor++;
|
cursor = skipGifSubBlocks(source, cursor);
|
if (cursor < 0) return true;
|
}
|
return true;
|
}
|
|
private int skipGifSubBlocks(byte[] source, int cursor) {
|
while (cursor < source.length) {
|
int length = source[cursor++] & 0xFF;
|
if (length == 0) return cursor;
|
if (cursor > source.length - length) return -1;
|
cursor += length;
|
}
|
return -1;
|
}
|
|
private static String outputFormat(String fileName, String mimeType) {
|
String extension = extension(fileName);
|
if ("jpg".equals(extension) || "jpeg".equals(extension)) {
|
return "jpeg";
|
}
|
if ("png".equals(extension) || "bmp".equals(extension) || "gif".equals(extension)) {
|
return extension;
|
}
|
if (!extension.isEmpty()) {
|
throw new DataException("该图片格式不支持动态水印");
|
}
|
String normalizedMime = normalizeMime(mimeType);
|
if ("image/jpeg".equals(normalizedMime) || "image/jpg".equals(normalizedMime)) {
|
return "jpeg";
|
}
|
if ("image/png".equals(normalizedMime)) {
|
return "png";
|
}
|
if ("image/bmp".equals(normalizedMime) || "image/x-ms-bmp".equals(normalizedMime)) {
|
return "bmp";
|
}
|
if ("image/gif".equals(normalizedMime)) {
|
return "gif";
|
}
|
throw new DataException("该图片格式不支持动态水印");
|
}
|
|
static String contentType(String fileName) {
|
return contentType(fileName, null);
|
}
|
|
static String contentType(String fileName, String mimeType) {
|
String format = outputFormat(fileName, mimeType);
|
return "jpeg".equals(format) ? "image/jpeg" : "image/" + format;
|
}
|
|
private static String extension(String fileName) {
|
int dot = fileName == null ? -1 : fileName.lastIndexOf('.');
|
return dot < 0 || dot == fileName.length() - 1
|
? "" : fileName.substring(dot + 1).trim().toLowerCase(Locale.ROOT);
|
}
|
|
private static String normalizeMime(String mimeType) {
|
String normalized = mimeType == null ? "" : mimeType.trim().toLowerCase(Locale.ROOT);
|
int parameters = normalized.indexOf(';');
|
return parameters < 0 ? normalized : normalized.substring(0, parameters).trim();
|
}
|
|
private String normalizeFormat(String format) {
|
String normalized = format == null ? "" : format.toLowerCase(Locale.ROOT);
|
return "jpg".equals(normalized) ? "jpeg" : normalized;
|
}
|
|
private String value(String value, String fallback) {
|
return value == null ? fallback : value;
|
}
|
|
private String message(Exception exception) {
|
Throwable cause = exception;
|
while (cause.getCause() != null) {
|
cause = cause.getCause();
|
}
|
return cause.getMessage() == null ? cause.getClass().getSimpleName() : cause.getMessage();
|
}
|
|
@FunctionalInterface
|
interface SourceReader {
|
byte[] read() throws Exception;
|
}
|
}
|
