java对网络图片进行签名

对网络图片进行签名，之前在与遇到

JPEGImageEncoder encoder = JPEGCodec.createJPEGEncoder(out);
encoder.encode(image);

启动时候有问题，后来换成了ImageIO.write(image, "jpg", out)，就没有问题。

import java.awt.AlphaComposite;
import java.awt.Color;
import java.awt.Font;
import java.awt.Graphics2D;
import java.awt.Image;
import java.awt.RenderingHints;
import java.awt.geom.AffineTransform;
import java.awt.image.BufferedImage;
import java.awt.image.ColorModel;
import java.awt.image.WritableRaster;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.HttpURLConnection;
import java.net.URL;

import javax.imageio.ImageIO;

/**
 * 读取、输出文件
 * @author tyg
 * @date   2019年3月28日下午4:48:06
 */
public class ImageHelper {

	// 项目根目录路径
	public static final String path = System.getProperty("user.dir");

	/**
	 * 
	 * @param source
	 * @param width
	 * @param height
	 * @param b
	 * @return
	 * @return BufferedImage
	 * @author tyg
	 * @date   2019年3月28日下午5:26:59
	 */
	public static BufferedImage thumb(BufferedImage source, int width, int height, boolean b) {
		// targetW，targetH分别表示目标长和宽
		int type = source.getType();
		BufferedImage target = null;
		double sx = (double) width / source.getWidth();
		double sy = (double) height / source.getHeight();

		if (b) {
			if (sx > sy) {
				sx = sy;
				width = (int) (sx * source.getWidth());
			} else {
				sy = sx;
				height = (int) (sy * source.getHeight());
			}
		}

		if (type == BufferedImage.TYPE_CUSTOM) { // handmade
			ColorModel cm = source.getColorModel();
			WritableRaster raster = cm.createCompatibleWritableRaster(width, height);
			boolean alphaPremultiplied = cm.isAlphaPremultiplied();
			target = new BufferedImage(cm, raster, alphaPremultiplied, null);
		} else
			target = new BufferedImage(width, height, 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;
	}

	/**
	 * 输出文件
	 * @param imgPath
	 * @param markPath
	 * @param x
	 * @param y
	 * @param alpha
	 * @return void
	 * @author tyg
	 * @date   2019年3月28日下午5:23:35
	 */
	public static void waterMark(String imgPath, String markPath, int x, int y, float alpha) {
		try {
			// 加载待处理图片文件
			Image img = ImageIO.read(new File(imgPath));

			BufferedImage image = new BufferedImage(img.getWidth(null), img.getHeight(null),
					BufferedImage.TYPE_INT_RGB);
			Graphics2D g = image.createGraphics();
			g.drawImage(img, 0, 0, null);

			// 加载水印图片文件
			Image src_biao = ImageIO.read(new File(markPath));
			g.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_ATOP, alpha));
			g.drawImage(src_biao, x, y, null);
			g.dispose();

			// 保存处理后的文件
			FileOutputStream out = new FileOutputStream(imgPath);
			ImageIO.write(image, "jpg", out);
//			JPEGImageEncoder encoder = JPEGCodec.createJPEGEncoder(out);
//			encoder.encode(image);
			out.close();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	/**
	 * 输出图片
	 * @param imgPath
	 * @param text
	 * @param font
	 * @param color
	 * @param x
	 * @param y
	 * @param alpha
	 * @return void
	 * @author tyg
	 * @date   2019年3月28日下午5:26:35
	 */
	public static void textMark(String imgPath, String text, Font font, Color color, int x, int y, float alpha) {
		try {
			Font Dfont = (font == null) ? new Font("宋体", 20, 13) : font;

			Image img = ImageIO.read(new File(imgPath));

			BufferedImage image = new BufferedImage(img.getWidth(null), img.getHeight(null), BufferedImage.TYPE_INT_RGB);
			Graphics2D g = image.createGraphics();

			g.drawImage(img, 0, 0, null);
			g.setColor(color);
			g.setFont(Dfont);
			g.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_ATOP, alpha));
			g.drawString(text, x, y);
			g.dispose();
			FileOutputStream out = new FileOutputStream(imgPath);
			
			ImageIO.write(image, "jpg", out);
//			JPEGImageEncoder encoder = JPEGCodec.createJPEGEncoder(out);
//			encoder.encode(image);
			out.close();
		} catch (Exception e) {
			System.out.println(e);
		}
	}

	/**
	 * 读取本地JPEG、JPG图片格式
	 * @param filename
	 * @return
	 * @return BufferedImage
	 * @author tyg
	 * @date   2019年3月28日下午5:24:36
	 */
	public static BufferedImage readJPEGImage(String filename) {
		try {
			InputStream inStream = new FileInputStream(new File(filename));
			BufferedImage sourceImage = ImageIO.read(inStream);
//			// 得到输入的编码器，将文件流进行jpg格式编码
//			JPEGImageDecoder decoder = JPEGCodec.createJPEGDecoder(inStream);
//			// 得到编码后的图片对象
//			BufferedImage sourceImage = decoder.decodeAsBufferedImage();
			return sourceImage;
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
		return null;
	}
	
	/**
	 * 读取http的JPEG、JPG图片格式
	 * @param filename
	 * @return
	 * @return BufferedImage
	 * @author tyg
	 * @date   2019年3月28日下午5:24:26
	 */
	public static BufferedImage readHttpJPEGImage(String filename) {
		try {
			//new一个URL对象  
	        URL url = new URL(filename);  
	        //打开链接  
	        HttpURLConnection conn = (HttpURLConnection)url.openConnection();  
	        //设置请求方式为"GET"  
	        conn.setRequestMethod("GET");  
	        //超时响应时间为5秒  
	        conn.setConnectTimeout(5 * 1000);  
	        //通过输入流获取图片数据  
	        InputStream inStream = conn.getInputStream();  
//	        JPEGImageDecoder imageDecoder = JPEGCodec.createJPEGDecoder(inStream);
//	        BufferedImage sourceImage = imageDecoder.decodeAsBufferedImage();
	        BufferedImage sourceImage = ImageIO.read(inStream);
	     // 得到编码后的图片对象
			return sourceImage;
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
		return null;
	}

	/**
	 * 读取本地PNG图片格式
	 * @param filename
	 * @return
	 * @return BufferedImage
	 * @author tyg
	 * @date   2019年3月28日下午5:25:24
	 */
	public static BufferedImage readPNGImage(String filename) {
		try {
			File inputFile = new File(filename);
			FileInputStream input = new FileInputStream(inputFile);
			BufferedImage sourceImage = ImageIO.read(input);
			return sourceImage;
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}

		return null;
	}

	
	public static int rgbToGray(int pixels) {
		// int _alpha = (pixels >> 24) & 0xFF;
		int _red = (pixels >> 16) & 0xFF;
		int _green = (pixels >> 8) & 0xFF;
		int _blue = (pixels) & 0xFF;
		return (int) (0.3 * _red + 0.59 * _green + 0.11 * _blue);
	}

	public static int average(int[] pixels) {
		float m = 0;
		for (int i = 0; i < pixels.length; ++i) {
			m += pixels[i];
		}
		m = m / pixels.length;
		return (int) m;
	}
}

 这里才有的是16*16=256个像素进行对比。

import java.awt.image.BufferedImage;
import java.io.File;
import java.util.ArrayList;
import java.util.List;

import org.apache.commons.lang3.StringUtils;

/**
 * 对图片进行签名
 * @author tyg
 * @date   2019年3月28日下午5:12:11
 */
public class ImageSign {

	public static final int SAMEVALUE = 5; // 相同图片阀值
	public static final int SIMILARVALUE = 10; // 相似图片阀值

	public static void main(String[] args) {
		// 开始时间
		long startMillis = System.currentTimeMillis();
		
		String httpUrl = "http://thirdwx.qlogo.cn/mmopen/vi_132";
		// 多张图片签名
		moreHttpImageSign(httpUrl);
		// 单张图片签名
		String sourceHashCode = getSigleHttpImageSign(httpUrl);
		System.out.println("sign code: "+sourceHashCode);

		System.out.println("curMillis:" + (System.currentTimeMillis() - startMillis));
	}

	/**
	 * 获取单张图片签名code
	 * @param fileName	(可以是本地文件、网络图片)
	 * @return
	 * @return String
	 * @author tyg
	 * @date   2019年3月28日下午5:31:41
	 */
	public static String getSigleHttpImageSign(String fileName) {
		if (StringUtils.isBlank(fileName)) {
			return null;
		}
		BufferedImage source = fileName.startsWith("http") ? ImageHelper.readHttpJPEGImage(fileName) : ImageHelper.readPNGImage(fileName);

		if (source == null) {
			return null;
		}
		int width = 16;
		int height = 16;

		// 第一步，缩小尺寸。
		// 将图片缩小到8x8的尺寸，总共64个像素。这一步的作用是去除图片的细节，只保留结构、明暗等基本信息，摒弃不同尺寸、比例带来的图片差异。
		BufferedImage thumb = ImageHelper.thumb(source, width, height, false);

		// 第二步，简化色彩。
		// 将缩小后的图片，转为64级灰度。也就是说，所有像素点总共只有64种颜色。
		int[] pixels = new int[width * height];
		for (int i = 0; i < width; i++) {
			for (int j = 0; j < height; j++) {
				pixels[i * height + j] = ImageHelper.rgbToGray(thumb.getRGB(i, j));
			}
		}

		// 第三步，计算平均值。
		// 计算所有64个像素的灰度平均值。
		int avgPixel = ImageHelper.average(pixels);

		// 第四步，比较像素的灰度。
		// 将每个像素的灰度，与平均值进行比较。大于或等于平均值，记为1；小于平均值，记为0。
		int[] comps = new int[width * height];
		for (int i = 0; i < comps.length; i++) {
			if (pixels[i] >= avgPixel) {
				comps[i] = 1;
			} else {
				comps[i] = 0;
			}
		}

		// 第五步，计算哈希值。
		// 将上一步的比较结果，组合在一起，就构成了一个64位的整数，这就是这张图片的指纹。组合的次序并不重要，只要保证所有图片都采用同样次序就行了。
		StringBuffer hashCode = new StringBuffer();
		for (int i = 0; i < comps.length; i += 4) {
			int result = comps[i] * (int) Math.pow(2, 3) + comps[i + 1] * (int) Math.pow(2, 2)
					+ comps[i + 2] * (int) Math.pow(2, 1) + comps[i + 2];
			hashCode.append(binaryToHex(result));
		}
		// 得到指纹以后，就可以对比不同的图片，看看64位中有多少位是不一样的。
		return hashCode.toString();
	}

	/**
	 * 传入一张图片，然后与指定目录下的图片做对比
	 * @param httpUrl
	 * @return void
	 * @author tyg
	 * @date   2019年3月28日下午5:06:56
	 */
	public static void moreHttpImageSign(String httpUrl) {
		List<String> hashCodes = new ArrayList<String>();

		// 网络图片
		List<String> urlList = collectionImgUrl();
		String hashCode = null;
		
		for (String url : urlList) {
			hashCode = getSigleHttpImageSign(url);
			hashCodes.add(hashCode);
		}

		System.out.println("Resources: "+hashCodes);

		String sourceHashCode = getSigleHttpImageSign(httpUrl);
		System.out.println("Source: "+sourceHashCode);

		List<String> resultList = new ArrayList<String>();
		List<String> similarResultList = new ArrayList<String>();
		List<String> differences = new ArrayList<String>();

		for (int i = 0; i < hashCodes.size(); i++) {
			int difference = hammingDistance(sourceHashCode, hashCodes.get(i));
			if (difference <= SAMEVALUE) {
				resultList.add(urlList.get(i).substring(urlList.get(i).lastIndexOf("\\") + 1, urlList.get(i).length()));
			} else if (difference <= SIMILARVALUE) {
				similarResultList
						.add(urlList.get(i).substring(urlList.get(i).lastIndexOf("\\") + 1, urlList.get(i).length()));
			}
			differences.add(difference + "->"
					+ urlList.get(i).substring(urlList.get(i).lastIndexOf("\\") + 1, urlList.get(i).length()));
		}
		System.out.println("搜索图片:" + httpUrl.substring(httpUrl.lastIndexOf("\\") + 1, httpUrl.length()));
		System.out.println("相同图片:" + resultList);
		System.out.println("相似图片:" + similarResultList);
		System.out.println("图片对比:" + differences);
	}
	
	public static List<String> collectionImgUrl() {
		String imgPath = "C:\\Users\\lew\\Desktop\\test";

		List<String> list = new ArrayList<String>();
		File file = new File(imgPath);

		if (file.isDirectory()) {
			String[] fileNames = file.list();
			for (String name : fileNames) {
				list.add(imgPath.concat("\\") + name);
			}
		}

		return list;
	}

	public static int hammingDistance(String sourceHashCode, String hashCode) {
		int difference = 0;
		int len = sourceHashCode.length();

		for (int i = 0; i < len; i++) {
			if (sourceHashCode.charAt(i) != hashCode.charAt(i)) {
				difference++;
			}
		}

		return difference;
	}

	private static char binaryToHex(int binary) {
		char ch = ' ';
		switch (binary) {
		case 0:
			ch = '0';
			break;
		case 1:
			ch = '1';
			break;
		case 2:
			ch = '2';
			break;
		case 3:
			ch = '3';
			break;
		case 4:
			ch = '4';
			break;
		case 5:
			ch = '5';
			break;
		case 6:
			ch = '6';
			break;
		case 7:
			ch = '7';
			break;
		case 8:
			ch = '8';
			break;
		case 9:
			ch = '9';
			break;
		case 10:
			ch = 'a';
			break;
		case 11:
			ch = 'b';
			break;
		case 12:
			ch = 'c';
			break;
		case 13:
			ch = 'd';
			break;
		case 14:
			ch = 'e';
			break;
		case 15:
			ch = 'f';
			break;
		default:
			ch = ' ';
		}
		return ch;
	}
}