七牛云文件HASH算法，SHA1，分块

问题概述
标题： 如果避免用户上传同名文件呢（即相同key值的文件）？
以前自己做存储的时候，是自己计算文件 hash，上传时查询如果存在的就不保存了。

现在改用七牛做存储了，看七牛上传返回的有文件 hash，但是不知道七牛的是如何计算出来的。

有没有办法在上传之前就可以知道七牛的存储空间里有没有相同的 hash 已经存在了，这样就不用向七牛上传相同的文件了，还是仍然需要自己实现这种排重计算？

答：
七牛的 hash 算法是公开的。见： https://github.com/qiniu/qetag

算法大体如下：

如果你能够确认文件 <= 4M，那么 hash = UrlsafeBase64([0x16, sha1(FileContent)])

如果文件 > 4M，则 hash = UrlsafeBase64([0x96, sha1([sha1(Block1), sha1(Block2), ...])])

其中 Block 是把文件内容切分为 4M 为单位的一个个块，也就是 BlockI = FileContent[I*4M:(I+1)*4M]

上传到七牛云存储的时候，key 是可选的。如果你不指定 key，则自动以 hash 值作为 key，此时自动带了消重能力。两个用户上传相同的文件，最终的 key 是一样的。

• QETag.java

package com.qiniu;

/*
java 最新版本 
https://github.com/qiniu/java-sdk/blob/master/src/main/java/com/qiniu/util/Etag.java
android 最新版本
https://github.com/qiniu/android-sdk/blob/master/library/src/main/java/com/qiniu/android/utils/Etag.java
*/

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import javax.xml.bind.DatatypeConverter;

public class QETag {
	private final int CHUNK_SIZE = 1 << 22;

	public byte[] sha1(byte[] data) throws NoSuchAlgorithmException {
		MessageDigest mDigest = MessageDigest.getInstance("sha1");
		return mDigest.digest(data);
	}

	public String urlSafeBase64Encode(byte[] data) {
		String encodedString = DatatypeConverter.printBase64Binary(data);
		encodedString = encodedString.replace('+', '-').replace('/', '_');
		return encodedString;
	}

	public String calcETag(String fileName) throws IOException,
			NoSuchAlgorithmException {
		String etag = "";
		File file = new File(fileName);
		if (!(file.exists() && file.isFile() && file.canRead())) {
			System.err.println("Error: File not found or not readable");
			return etag;
		}
		long fileLength = file.length();
		FileInputStream inputStream = new FileInputStream(file);
		if (fileLength <= CHUNK_SIZE) {
			byte[] fileData = new byte[(int) fileLength];
			inputStream.read(fileData, 0, (int) fileLength);
			byte[] sha1Data = sha1(fileData);
			int sha1DataLen = sha1Data.length;
			byte[] hashData = new byte[sha1DataLen + 1];
			System.arraycopy(sha1Data, 0, hashData, 1, sha1DataLen);
			hashData[0] = 0x16;
			etag = urlSafeBase64Encode(hashData);
		} else {
			int chunkCount = (int) (fileLength / CHUNK_SIZE);
			if (fileLength % CHUNK_SIZE != 0) {
				chunkCount += 1;
			}
			byte[] allSha1Data = new byte[0];
			for (int i = 0; i < chunkCount; i++) {
				byte[] chunkData = new byte[CHUNK_SIZE];
				int bytesReadLen = inputStream.read(chunkData, 0, CHUNK_SIZE);
				byte[] bytesRead = new byte[bytesReadLen];
				System.arraycopy(chunkData, 0, bytesRead, 0, bytesReadLen);
				byte[] chunkDataSha1 = sha1(bytesRead);
				byte[] newAllSha1Data = new byte[chunkDataSha1.length
						+ allSha1Data.length];
				System.arraycopy(allSha1Data, 0, newAllSha1Data, 0,
						allSha1Data.length);
				System.arraycopy(chunkDataSha1, 0, newAllSha1Data,
						allSha1Data.length, chunkDataSha1.length);
				allSha1Data = newAllSha1Data;
			}
			byte[] allSha1DataSha1 = sha1(allSha1Data);
			byte[] hashData = new byte[allSha1DataSha1.length + 1];
			System.arraycopy(allSha1DataSha1, 0, hashData, 1,
					allSha1DataSha1.length);
			hashData[0] = (byte) 0x96;
			etag = urlSafeBase64Encode(hashData);
		}
		inputStream.close();
		return etag;
	}

	public static void main(String[] args) {
		if (args.length != 1) {
			System.out.println("Usage: qetag <filename>");
		} else {
			String fileName = args[0];
			QETag etag = new QETag();
			try {
				System.out.println(etag.calcETag(fileName));
			} catch (NoSuchAlgorithmException ex) {
				System.err.println("Unsupported algorithm:" + ex.getMessage());
			} catch (IOException ex) {
				System.err.println("IO Error:" + ex.getMessage());
			}
		}
	}
}