大文件上传并进行md5校验过程中遇到的问题，复制InputStream导致内存溢出

最近因为一个项目需求，需要支持上传文件，并且在上传的过程中通过流式的方式生成md5校验码，然后好需要利用这个输入流来生成本地预览文件，而InputStrream是只能读一次的，并不能重复读，所以在这里就需要进行流的复制。

解释一下，fileUpload是自定义的文件Model实体。

  // 生产文件md5校验码，并且复制fileUpload.getInputStream(),否则inputStream只能读取一次
        HashMap<String, Object> map = CopyStreamUtils.copyInputStream(fileUpload.getInputStream());
        
        // 因为之前已经被读取了，需要重新设置inputStream
        fileUpload.setInputStream((InputStream) map.get("inputStream"));
        String MD5Code = (String) map.get("md5");
   
        System.out.println("MD5校验码为------" + MD5Code);

CopyStreamUtils主要是用来复制流和生产md5校验码，一边复制一边生产，减少资源的消耗。（其实不能拿来当工具类，杂交了复制流和生产md5的功能QAQ）

public class CopyStreamUtils {

	/**
	 * @param inputStream
	 * @return
	 */
	public static HashMap<String, Object> copyInputStream(InputStream inputStream) {
		
		/* 
		 * 	因为inputStream只能读取一次，
		 * 	所以将其进行复制
		 * 	复制方法是通过定义一个byteArrayOutputStream
		 * 	然后将byteArrayOutputStream转化为InputStream
		 * 	但是这样存在一个问题，就是当文件比较大的时候，会出现内存溢出
		 * 	将jvm参数调整也效果不佳
		 * 	所以解决方案为采用分段的方法，将原本的inputStream分成很多小的inputStream
		 * 	然后通过SequenceInputStream进行合并输入流
		 * 	合并后的SequenceInputStream和原来的输入流相同，达到复制的效果
		 * */
		
		ByteArrayOutputStream baos = null;

		// 每次读取1024字节
		byte[] buffer = new byte[1024];
		int readNum ;
		
		// 定义一个Vector，用来存储分段后的小的InputStream,最后用于构造SequenceInputStream和并流
		Vector<InputStream> streams = new Vector<InputStream>();
		
		/*   为提高效率，在此处进行流处理的时候，直接进行md5校验码的生成，节省资源         */
		String MD5String = "";
		InputStream sequenceInputStream = null;
		
		try {
			while ((readNum = inputStream.read(buffer)) > -1) {
				baos = new ByteArrayOutputStream();
				baos.write(buffer, 0, readNum);
			
				// 更新md5校验码的输入流
				Md5Utils.updateFileMD5String(buffer, readNum);
				
				
				// 分段的复制inputStream，每次将新产生的小段流与原来的合并
				streams.add(new ByteArrayInputStream(baos.toByteArray()));
				
				/* 不同于其他输出流，二进制流无法通过flush进行刷新，
				 * 所以只能通过close之后再重新new来充值二进制流
				 * */
				baos.close();
			}
			
			// 生成md5校验码
			MD5String = Md5Utils.getFileMD5String() ;
			// 通过之前的分段的小的inputStream进行构造合并流
			Enumeration<InputStream> e = streams.elements();
			sequenceInputStream = new SequenceInputStream(e);
			
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

		HashMap<String, Object> map = new HashMap<String, Object>();
		map.put("md5", MD5String);
		map.put("inputStream", sequenceInputStream);
		
		return map;
	}

生产文件的md5校验码，本来直接通过输入流就行，但是考虑到需要上面的复制流，就增加了一个updateFileMD5String方法来更新文件的输入流，然后将所有字节进行生成校验。

public class Md5Utils {

	private static final Logger logger = LoggerFactory.getLogger(Md5Utils.class);

	protected static char[] hexDegists = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e',
			'f' };

	protected static MessageDigest md5 = null;

	static {
		try {
			md5 = MessageDigest.getInstance("MD5");
		} catch (NoSuchAlgorithmException nsae) {
			// TODO: handle exception
			logger.info(Md5Utils.class.getName() + "初始化失败，MessageDigest不支持md5!");
			nsae.printStackTrace();
		}
	}

	/**
	 * 获取md5校验码
	 * @param inputStream
	 * @return
	 * @throws IOException
	 */
	public static String getFileMD5String(java.io.InputStream inputStream) throws IOException {

		// 每次读取1024字节
		byte[] buffer = new byte[1024];
		int readNum = 0;

		while ((readNum = inputStream.read(buffer)) > 0) {
			md5.update(buffer, 0, readNum);
		}
		inputStream.close();

		return bufferToHex(md5.digest());
	}

	/**
	 * 更新需要校验的文件输入流
	 * @param bs
	 * @return
	 * @throws IOException
	 */
	public static void updateFileMD5String(byte[] bs, int readNum) throws IOException {
		// 每次读取bs字节，更新MD5输入流
		md5.update(bs, 0, readNum);
	}

	/**
	 * 返回md5校验码
	 * @return
	 * @throws IOException
	 */
	public static String getFileMD5String() throws IOException {
		return bufferToHex(md5.digest());
	}

	private static String bufferToHex(byte[] bytes) {
		return bufferToHex(bytes, 0, bytes.length);
	}

	private static String bufferToHex(byte[] bytes, int m, int n) {
		StringBuffer stringBuffer = new StringBuffer(n * 2);
		int k = m + n;
		for (int i = m; i < k; i++) {
			appendHexPair(bytes[i], stringBuffer);
		}

		return stringBuffer.toString();
	}

	private static void appendHexPair(byte bt, StringBuffer stringBuffer) {
		// 取字节中高四位进行转换
		char ch0 = hexDegists[(bt & 0xf0) >> 4];
		// 取字节中低四位进行转换
		char ch1 = hexDegists[(bt & 0xf)];

		stringBuffer.append(ch0);
		stringBuffer.append(ch1);
	}
}

接下来说一说遇到的坑，为了完成复制流，最开始是全部将InputStream全部通过ByteArrayOutputStream来转储，然后通过ByteArrayOutputStream.toByteArray()方法转化为byte，通过InputStream（byte[] byte）构造新的输入流，从而达到复制流的效果。这样的做法适合比较小的文件，当文件比较大（我自己这边测试的是上传600M的文件）就会出现内存溢出，网上查了很多才知道不应把所有的byte都存在内存中。所以想要分段写入，或者刷新ByteArrayOutputStream，

      刚开始的时候用输出流的flush方法，但是一直没用（这个坑了我好久），后面才知道字节流无法flush刷新。所以只能通过最蠢笨的办法，每次都close掉字节流，然后读下一个缓冲区的时候重新new，结果成功。

    最后通过合并流SequenceInputStream将每一小段inputStream合并成一个完整的输入流。从而达到复制流的效果。

其实最开始用的是common.io的copyInputStreamToFile（InputStream,File），但是老大说要改，然后就折腾了一天。。。。。。。