<dependency>
			<groupId>org.apache.httpcomponents</groupId>
			<artifactId>httpclient</artifactId>
		</dependency>
		<dependency>
			<groupId>org.apache.httpcomponents</groupId>
			<artifactId>httpmime</artifactId>
		</dependency>

	private static long SIZE = 1024 * 1024;

	public static Long[] sliceFile(String filePath) {
		File file = new File(filePath);
		long length = file.length();
		long start = 0L;

		int arrayLength;
		if (length % SIZE == 0) {
			arrayLength = (int) (length / SIZE);
		} else {
			arrayLength = (int) (length / SIZE) + 1;
		}

		Long[] longs = new Long[arrayLength];
		int i = 0;
		while (start < length) {
			longs[i++] = start;
			start += SIZE;
		}
		return longs;
	}

	public static InputStream readFileToInputStream(long offset, String filePath) {
		RandomAccessFile randomAccessFile = null;
		try {
			// 初使化这个文件
			randomAccessFile = new RandomAccessFile(filePath, "r");
			byte[] tempByte = null;
			// 判断传入的指针是否比总文件长度还要长，只要小于文件长度，才是正常的
			if (offset < randomAccessFile.length()) {
				// 把指针移到要开始的字节位置
				randomAccessFile.seek(offset);
				// 这里是做一个判断，判断从这个位置开始读取，读取这个长度，是否已经超过了文件的长度,一般情况下，我们的块的
				// 长度是固定的，比如1M，而对于一个10.5M的文件，要分11包，当读最后一个包的时候，就会出现这种情况
				if (offset + (SIZE) > randomAccessFile.length()) {
					// 如果已经超过了文件的长度，初使化字节数组的时候，就用文件长度减去指针的位置
					tempByte = new byte[((int) (randomAccessFile.length() - offset))];
					// 这个方法 ，会读取字节长度的数据，然后把数据存储到字节数组
					randomAccessFile.read(tempByte);
				} else {
					// 如果我们要读的一个块的长度，没有超过文件的长度，那就把字节数组初始化为块的长度
					tempByte = new byte[(int) SIZE];
					randomAccessFile.read(tempByte);
				}
				return new ByteArrayInputStream(tempByte);
			}
		} catch (FileNotFoundException e) {
			e.printStackTrace();
			return null;
		} catch (IOException e) {
			e.printStackTrace();
			return null;
		} finally {
			if (randomAccessFile != null) {
				try {
					// 关闭文件流
					randomAccessFile.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
		return null;
	}

	public static void post(InputStream is, String fileName, String offset, String md5) {

		CloseableHttpClient httpClient = HttpClients.createDefault();

		HttpPost httpPost = new HttpPost("http://localhost:8080/upload");

		try {
			MultipartEntityBuilder builder = MultipartEntityBuilder.create();
			builder.setMode(HttpMultipartMode.BROWSER_COMPATIBLE);

			builder.addBinaryBody("stream", is, ContentType.DEFAULT_BINARY, fileName);
			builder.addTextBody("fileName", fileName, ContentType.DEFAULT_TEXT);
			builder.addTextBody("offset", offset, ContentType.DEFAULT_TEXT);
			builder.addTextBody("md5", md5, ContentType.DEFAULT_TEXT);

			// 过时了
			// MultipartEntity multipartEntity = new MultipartEntity();
			// multipartEntity.addPart("stream", inputStreamBody);

			HttpEntity httpEntity = builder.build();
			//
			httpPost.setEntity(httpEntity);

			// 执行请求
			CloseableHttpResponse httpResponse = httpClient.execute(httpPost);

			try {
				// response实体
				HttpEntity entity = httpResponse.getEntity();
				if (null != entity) {
					System.out.println("响应状态码:" + httpResponse.getStatusLine());
					System.out.println("-------------------------------------------------");
					System.out.println("响应内容:" + EntityUtils.toString(entity));
					System.out.println("-------------------------------------------------");
				}
			} finally {
				httpResponse.close();
			}

		} catch (ClientProtocolException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			try {
				if (httpClient != null) {
					httpClient.close();
				}
			} catch (Exception e) {
				e.printStackTrace();
			}
		}

	}

	public static void main(String[] args) throws Exception {
		
		InputStream inputStream = null;
		
		String filePath = "Z:\\1.mp4";
		String fileName = "5.mp4";
		
		FileInputStream fis = new FileInputStream(new File(filePath));
		String md5 = DigestUtils.md5Hex(fis);
		
		Long[] sliceFile = sliceFile(filePath);
		for (Long offset : sliceFile) {
			inputStream = readFileToInputStream(offset, filePath);
			post(inputStream, fileName, String.valueOf(offset), md5);
		}
	}

	@RequestMapping("/upload")
	@ResponseBody
	String a(@RequestParam(value = "stream", required = true) MultipartFile file, HttpServletRequest request,
			String fileName, String offset, String md5) {
		String result = fileName;
		InputStream is = null;
		RandomAccessFile randomAccessFile = null;
		try {
		
			File newFile = new File("z:\\" + fileName);
			boolean exis = newFile.exists();
			if (!exis) {
				newFile.createNewFile();
			}

			randomAccessFile = new RandomAccessFile("Z:\\" + fileName, "rwd");
			randomAccessFile.seek(Long.parseLong(offset));

			is = file.getInputStream();
			byte[] buffer = new byte[1024];
			int length = -1;
			while ((length = is.read(buffer)) != -1) {
				randomAccessFile.write(buffer, 0, length);
			}

			FileInputStream fis = new FileInputStream(new File("z:\\" + fileName));
			String md5Hex = DigestUtils.md5Hex(fis);
			if (md5Hex.equals(md5)) {
				result = "传输完毕!";
				System.out.println(result);
			}

			// file.transferTo(new File("D:\\temp\\filetest\\" + a));
		} catch (Exception e) {
		} finally {
			try {
				if (is != null)
					is.close();
				if (randomAccessFile != null)
					randomAccessFile.close();
			} catch (Exception e) {
				e.printStackTrace();
			}
		}

		return result;
	}