Files
mosty-common/common-token-starter/src/main/java/com/mosty/common/util/ImageUtils.java

548 lines
21 KiB
Java
Raw Normal View History

2025-09-04 18:20:44 +08:00
package com.mosty.common.util;
import org.apache.commons.lang3.StringUtils;
import org.apache.poi.util.IOUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import sun.misc.BASE64Encoder;
import javax.imageio.ImageIO;
import javax.imageio.ImageReader;
import javax.imageio.stream.ImageInputStream;
import javax.net.ssl.*;
import java.awt.*;
import java.awt.color.ColorSpace;
import java.awt.geom.AffineTransform;
import java.awt.image.*;
import java.io.*;
import java.net.HttpURLConnection;
import java.net.URL;
import java.net.URLConnection;
import java.util.Arrays;
import java.util.Iterator;
/**
* 图片处理类<br>
*
* @author Esacpe
* @version 2014-8-22
*/
public class ImageUtils {
private static final Logger log = LoggerFactory.getLogger(ImageUtils.class);
public static byte[] getImage(String imagePath)
{
InputStream is = getFile(imagePath);
try
{
return IOUtils.toByteArray(is);
}
catch (Exception e)
{
log.error("图片加载异常 {}", e);
return null;
}
finally
{
IOUtils.closeQuietly(is);
}
}
public static InputStream getFile(String imagePath)
{
try
{
byte[] result = readFile(imagePath);
result = Arrays.copyOf(result, result.length);
return new ByteArrayInputStream(result);
}
catch (Exception e)
{
log.error("获取图片异常 {}", e);
}
return null;
}
/**
* 读取文件为字节数据
*
* @param url 地址
* @return 字节数据
*/
public static byte[] readFile(String url)
{
InputStream in = null;
try
{
// 网络地址
URL urlObj = new URL(url);
URLConnection urlConnection = urlObj.openConnection();
urlConnection.setConnectTimeout(30 * 1000);
urlConnection.setReadTimeout(60 * 1000);
urlConnection.setDoInput(true);
in = urlConnection.getInputStream();
return IOUtils.toByteArray(in);
}
catch (Exception e)
{
log.error("访问文件异常 {}", e);
return null;
}
finally
{
IOUtils.closeQuietly(in);
}
}
/**
* 将图片缩放处理方法<br>
*
* @param source 源图片对象
* @param targetW 转换后的宽度
* @param targetH 转换后的高度
* @param sameScale 是否等比例缩放
* @return BufferedImage
*/
public static BufferedImage resize(BufferedImage source, int targetW,
int targetH, boolean sameScale) { // targetWtargetH分别表示目标长和宽
int type = source.getType();
BufferedImage target = null;
double sx = (double) targetW / source.getWidth();
double sy = (double) targetH / source.getHeight();
if (sameScale) { // 需要等比例缩放
if (sx > sy) {
sx = sy;
targetW = (int) (sx * source.getWidth());
} else {
sy = sx;
targetH = (int) (sy * source.getHeight());
}
}
if (type == BufferedImage.TYPE_CUSTOM) { // handmade
ColorModel cm = source.getColorModel();
WritableRaster raster = cm.createCompatibleWritableRaster(targetW,
targetH);
boolean alphaPremultiplied = cm.isAlphaPremultiplied();
target = new BufferedImage(cm, raster, alphaPremultiplied, null);
} else {
target = new BufferedImage(targetW, targetH, type);
}
Graphics2D g = target.createGraphics();
// smoother than exlax:
g.setRenderingHint(RenderingHints.KEY_RENDERING,
RenderingHints.VALUE_RENDER_QUALITY);
g.drawRenderedImage(source, AffineTransform.getScaleInstance(sx, sy));
g.dispose();
return target;
}
/**
* 将图片放大与缩小<br>
*
* @param sourceByte 源图片的字节数组
* @param width 转换后的宽度
* @param height 转换后的高度
* @param sameScale 是否等比例缩放
* @return byte[]
*/
public static byte[] convertImageSize(byte[] sourceByte, int width,
int height, boolean sameScale) throws Exception {
byte[] returnValue = null;
if (sourceByte != null && sourceByte.length > 0) {
ByteArrayInputStream in = new ByteArrayInputStream(sourceByte);
// BufferedImage srcImage = getReadImage(in);
BufferedImage srcImage = null;
try {
srcImage = ImageIO.read(in); // RGB
} catch (Exception e) {
}
if (srcImage != null) {
BufferedImage srcImageTarget = resize(srcImage, width, height,
sameScale);
ByteArrayOutputStream out = new ByteArrayOutputStream();
boolean flag = ImageIO.write(srcImageTarget, "JPEG", out);
returnValue = out.toByteArray();
}
}
return returnValue;
}
/**
* 将图片放大与缩小后另存<br>
*
* @param fromFileStr 来源文件名
* @param saveToFileStr 目标文件名
* @param width 转换后的宽度
* @param height 转换后的高度
* @param sameScale 是否等比例缩放
*/
public static void saveImageAsJpg(String fromFileStr, String saveToFileStr,
int width, int height, boolean sameScale) throws Exception {
String imgType = "JPEG";
if (fromFileStr.toLowerCase().endsWith(".png")) {
imgType = "PNG";
}
File saveFile = new File(saveToFileStr);
File fromFile = new File(fromFileStr);
BufferedImage srcImage = getReadImage(fromFile);
if (srcImage != null) {
if (width > 0 || height > 0) {
srcImage = resize(srcImage, width, height, sameScale);
}
ImageIO.write(srcImage, imgType, saveFile);
}
}
/**
* 根据文件取得bufferedImage对象自动识别RGB与CMYK<br>
*
* @param file 来源文件名
* @return BufferedImage
*/
private static BufferedImage getReadImage(File file) throws Exception {
BufferedImage srcImage = null;
ImageInputStream input = ImageIO.createImageInputStream(file); // 只能接收File或FileInputStreamByteArrayInputStream无效
Iterator readers = ImageIO.getImageReaders(input);
if (readers == null || !readers.hasNext()) {
throw new RuntimeException("1 No ImageReaders found");
}
ImageReader reader = (ImageReader) readers.next();
reader.setInput(input);
String format = reader.getFormatName();
if ("JPEG".equalsIgnoreCase(format) || "JPG".equalsIgnoreCase(format)) {
try {
srcImage = ImageIO.read(file); // RGB
} catch (Exception e) {
Raster raster = reader.readRaster(0, null);// CMYK
srcImage = createJPEG4(raster);
}
input.close();
}
return srcImage;
}
/**
* RGB彩色空间转换为CMYK<br>
*
* @param raster
* @return BufferedImage
*/
private static BufferedImage createJPEG4(Raster raster) {
int w = raster.getWidth();
int h = raster.getHeight();
byte[] rgb = new byte[w * h * 3]; // 彩色空间转换
float[] Y = raster.getSamples(0, 0, w, h, 0, (float[]) null);
float[] Cb = raster.getSamples(0, 0, w, h, 1, (float[]) null);
float[] Cr = raster.getSamples(0, 0, w, h, 2, (float[]) null);
float[] K = raster.getSamples(0, 0, w, h, 3, (float[]) null);
for (int i = 0, imax = Y.length, base = 0; i < imax; i++, base += 3) {
float k = 220 - K[i], y = 255 - Y[i], cb = 255 - Cb[i], cr = 255 - Cr[i];
double val = y + 1.402 * (cr - 128) - k;
val = (val - 128) * .65f + 128;
rgb[base] = val < 0.0 ? (byte) 0 : val > 255.0 ? (byte) 0xff
: (byte) (val + 0.5);
val = y - 0.34414 * (cb - 128) - 0.71414 * (cr - 128) - k;
val = (val - 128) * .65f + 128;
rgb[base + 1] = val < 0.0 ? (byte) 0 : val > 255.0 ? (byte) 0xff
: (byte) (val + 0.5);
val = y + 1.772 * (cb - 128) - k;
val = (val - 128) * .65f + 128;
rgb[base + 2] = val < 0.0 ? (byte) 0 : val > 255.0 ? (byte) 0xff
: (byte) (val + 0.5);
}
raster = Raster.createInterleavedRaster(new DataBufferByte(rgb,
rgb.length), w, h, w * 3, 3, new int[]{0, 1, 2}, null);
ColorSpace cs = ColorSpace.getInstance(ColorSpace.CS_sRGB);
ColorModel cm = new ComponentColorModel(cs, false, true,
Transparency.OPAQUE, DataBuffer.TYPE_BYTE);
return new BufferedImage(cm, (WritableRaster) raster, true, null);
}
public static byte[] encodeImageTobyte(String url) {
//打开链接
try {
URL urls = new URL(url);
HttpURLConnection conn = null;
conn = (HttpURLConnection) urls.openConnection();
//设置请求方式为"GET"
conn.setRequestMethod("GET");
//超时响应时间为5秒
conn.setConnectTimeout(5 * 1000);
//通过输入流获取图片数据
InputStream inStream = conn.getInputStream();
//得到图片的二进制数据,以二进制封装得到数据,具有通用性
ByteArrayOutputStream outStream = new ByteArrayOutputStream();
//创建一个Buffer字符串
byte[] buffer = new byte[1024];
//每次读取的字符串长度,如果为-1代表全部读取完毕
int len = 0;
//使用一个输入流从buffer里把数据读取出来
while ((len = inStream.read(buffer)) != -1) {
//用输出流往buffer里写入数据中间参数代表从哪个位置开始读len代表读取的长度
outStream.write(buffer, 0, len);
}
//关闭输入流
inStream.close();
byte[] data = outStream.toByteArray();
return data;//返回Base64编码过的字节数组字符串
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
/**
* 网络图片转成base64 https
*
* @param url
* @return
* @throws Exception
*/
public static byte[] encodeImageToByteHttps(String url) {
byte[] data = null;
try {
SSLContext sslcontext = SSLContext.getInstance("SSL", "SunJSSE");
sslcontext.init(null, new TrustManager[]{new MyX509TrustManager()}, new java.security.SecureRandom());
URL urls = new URL(url);
HostnameVerifier ignoreHostnameVerifier = new HostnameVerifier() {
public boolean verify(String s, SSLSession sslsession) {
System.out.println("WARNING: Hostname is not matched for cert.");
return true;
}
};
HttpsURLConnection.setDefaultHostnameVerifier(ignoreHostnameVerifier);
HttpsURLConnection.setDefaultSSLSocketFactory(sslcontext.getSocketFactory());
//之后任何Https协议网站皆能正常访问同第一种情况
HttpURLConnection conn = null;
conn = (HttpURLConnection) urls.openConnection();
//设置请求方式为"GET"
conn.setRequestMethod("GET");
//超时响应时间为5秒
conn.setConnectTimeout(5 * 1000);
if (conn.getResponseCode() == HttpURLConnection.HTTP_MOVED_PERM) {
String location = conn.getHeaderField("Location");
byte[] data1 = encodeImageToByteHttps(location.trim());
if (null != data && data1.length > 0) {
return data1;
}
} else {
//通过输入流获取图片数据
InputStream inStream = conn.getInputStream();
//得到图片的二进制数据,以二进制封装得到数据,具有通用性
ByteArrayOutputStream outStream = new ByteArrayOutputStream();
//创建一个Buffer字符串
byte[] buffer = new byte[1024];
//每次读取的字符串长度,如果为-1代表全部读取完毕
int len = 0;
//使用一个输入流从buffer里把数据读取出来
while ((len = inStream.read(buffer)) != -1) {
//用输出流往buffer里写入数据中间参数代表从哪个位置开始读len代表读取的长度
outStream.write(buffer, 0, len);
}
//关闭输入流
inStream.close();
data = outStream.toByteArray();
}
} catch (Exception e) {
System.out.println("解析失败!------》" + e.getMessage());
}
return data;
}
/**
* 网络图片转成base64 https
*
* @param url
* @return
* @throws Exception
*/
public static String encodeImageToBase64Https(String url) {
String base64 = null;
try {
SSLContext sslcontext = SSLContext.getInstance("SSL", "SunJSSE");
sslcontext.init(null, new TrustManager[]{new MyX509TrustManager()}, new java.security.SecureRandom());
URL urls = new URL(url);
HostnameVerifier ignoreHostnameVerifier = new HostnameVerifier() {
public boolean verify(String s, SSLSession sslsession) {
System.out.println("WARNING: Hostname is not matched for cert.");
return true;
}
};
HttpsURLConnection.setDefaultHostnameVerifier(ignoreHostnameVerifier);
HttpsURLConnection.setDefaultSSLSocketFactory(sslcontext.getSocketFactory());
//之后任何Https协议网站皆能正常访问同第一种情况
HttpURLConnection conn = null;
conn = (HttpURLConnection) urls.openConnection();
//设置请求方式为"GET"
conn.setRequestMethod("GET");
//超时响应时间为5秒
conn.setConnectTimeout(5 * 1000);
if (conn.getResponseCode() == HttpURLConnection.HTTP_MOVED_PERM) {
String location = conn.getHeaderField("Location");
String s = encodeImageToBase64Https(location.trim());
if (StringUtils.isNotBlank(s)) {
return s;
}
} else {
//通过输入流获取图片数据
InputStream inStream = conn.getInputStream();
//得到图片的二进制数据,以二进制封装得到数据,具有通用性
ByteArrayOutputStream outStream = new ByteArrayOutputStream();
//创建一个Buffer字符串
byte[] buffer = new byte[1024];
//每次读取的字符串长度,如果为-1代表全部读取完毕
int len = 0;
//使用一个输入流从buffer里把数据读取出来
while ((len = inStream.read(buffer)) != -1) {
//用输出流往buffer里写入数据中间参数代表从哪个位置开始读len代表读取的长度
outStream.write(buffer, 0, len);
}
//关闭输入流
inStream.close();
byte[] data = outStream.toByteArray();
//对字节数组Base64编码
BASE64Encoder encoder = new BASE64Encoder();
base64 = encoder.encode(data).replaceAll("[\\s*\t\n\r]", "");
}
} catch (Exception e) {
System.out.println("解析失败!------》" + e.getMessage());
}
return base64;
}
/**
* 网络图片转成base64
*
* @param url
* @return
* @throws Exception
*/
public static String encodeImageToBase64(String url) throws Exception {
//打开链接
URL urls = new URL(url);
HttpURLConnection conn;
try {
conn = (HttpURLConnection) urls.openConnection();
//设置请求方式为"GET"
conn.setRequestMethod("GET");
//超时响应时间为5秒
conn.setConnectTimeout(5 * 1000);
//通过输入流获取图片数据
InputStream inStream = conn.getInputStream();
//得到图片的二进制数据,以二进制封装得到数据,具有通用性
ByteArrayOutputStream outStream = new ByteArrayOutputStream();
//创建一个Buffer字符串
byte[] buffer = new byte[1024];
//每次读取的字符串长度,如果为-1代表全部读取完毕
int len = 0;
//使用一个输入流从buffer里把数据读取出来
while ((len = inStream.read(buffer)) != -1) {
//用输出流往buffer里写入数据中间参数代表从哪个位置开始读len代表读取的长度
outStream.write(buffer, 0, len);
}
//关闭输入流
inStream.close();
byte[] data = outStream.toByteArray();
//对字节数组Base64编码
BASE64Encoder encoder = new BASE64Encoder();
return encoder.encode(data).replaceAll("[\\s*\t\n\r]", "");
} catch (IOException e) {
e.printStackTrace();
throw new Exception("解析失败!");
}
}
public static String ImageToBase64(String imgPath) {
byte[] data = null;
try {
InputStream in = new FileInputStream(imgPath);
data = new byte[in.available()];
in.read(data);
in.close();
} catch (Exception e) {
e.printStackTrace();
}
// return StringUtils.replaceBlank(StringUtils.getByteToBase64(data));
return "";
}
/**
* 网络图片转成base64
*
* @param url
* @return
* @throws Exception
*/
public static byte[] encodeImageToByte(String url) throws Exception {
//打开链接
URL urls = new URL(url);
HttpURLConnection conn = null;
try {
conn = (HttpURLConnection) urls.openConnection();
//设置请求方式为"GET"
conn.setRequestMethod("GET");
//超时响应时间为5秒
conn.setConnectTimeout(5 * 1000);
//通过输入流获取图片数据
InputStream inStream = conn.getInputStream();
//得到图片的二进制数据,以二进制封装得到数据,具有通用性
ByteArrayOutputStream outStream = new ByteArrayOutputStream();
//创建一个Buffer字符串
byte[] buffer = new byte[1024];
//每次读取的字符串长度,如果为-1代表全部读取完毕
int len = 0;
//使用一个输入流从buffer里把数据读取出来
while ((len = inStream.read(buffer)) != -1) {
//用输出流往buffer里写入数据中间参数代表从哪个位置开始读len代表读取的长度
outStream.write(buffer, 0, len);
}
//关闭输入流
inStream.close();
byte[] data = outStream.toByteArray();
return data;
} catch (IOException e) {
e.printStackTrace();
throw new Exception("解析失败!");
}
}
public static void main(String argv[]) throws Exception{
// ImageUtils.saveImageAsJpg("C:/test.jpg", "c:/test2.jpg", 179, 220,
// true);
// String s = ImageUtils.ImageToBase64("C:\\Users\\admin\\Desktop\\ryxp.jpg");
// System.out.println(s);
// String str = "normal://repository-builder/20190628/ehlZxEcjZp09UubZQugxug==@11";
// //编码加密
// String encodeStr = Base64.getEncoder().encodeToString(str.getBytes("UTF-8"));
// System.out.println("加密后的字符串为:" + encodeStr);
// //解码解密
// String decoderStr = new String(Base64.getDecoder().decode(encodeStr), StandardCharsets.UTF_8); //
// // 推荐使用StandardCharsets类指定
// System.out.println("解密后的字符串为" + decoderStr);
String tp="http://10.64.201.128:7266/xlpcAdminNew/requestservice/czrk/ryxp.jpg?sfzh=510502195403065021";
String s = ImageUtils.encodeImageToBase64(tp);
System.out.println(s);
}
}