正文
java断点续传上传代码 java实现断点续传原理
小程序：扫一扫查出行【扫一扫了解最新限行尾号】
复制小程序
用java向hdfs上传文件时，如何实现断点续传
@Component("javaLargeFileUploaderServlet")
@WebServlet(name = "javaLargeFileUploaderServlet", urlPatterns = { "/javaLargeFileUploaderServlet" })
public class UploadServlet extends HttpRequestHandlerServlet
implements HttpRequestHandler {
private static final Logger log = LoggerFactory.getLogger(UploadServlet.class);
@Autowired
UploadProcessor uploadProcessor;
@Autowired
FileUploaderHelper fileUploaderHelper;
@Autowired
ExceptionCodeMappingHelper exceptionCodeMappingHelper;
@Autowired
Authorizer authorizer;
@Autowired
StaticStateIdentifierManager staticStateIdentifierManager;
@Override
public void handleRequest(HttpServletRequest request, HttpServletResponse response)
throws IOException {
log.trace("Handling request");
Serializable jsonObject = null;
try {
// extract the action from the request
UploadServletAction actionByParameterName =
UploadServletAction.valueOf(fileUploaderHelper.getParameterValue(request, UploadServletParameter.action));
// check authorization
checkAuthorization(request, actionByParameterName);
// then process the asked action
jsonObject = processAction(actionByParameterName, request);
// if something has to be written to the response
if (jsonObject != null) {
fileUploaderHelper.writeToResponse(jsonObject, response);
}
}
// If exception, write it
catch (Exception e) {
exceptionCodeMappingHelper.processException(e, response);
}
}
private void checkAuthorization(HttpServletRequest request, UploadServletAction actionByParameterName)
throws MissingParameterException, AuthorizationException {
// check authorization
// if its not get progress (because we do not really care about authorization for get
// progress and it uses an array of file ids)
if (!actionByParameterName.equals(UploadServletAction.getProgress)) {
// extract uuid
final String fileIdFieldValue = fileUploaderHelper.getParameterValue(request, UploadServletParameter.fileId, false);
// if this is init, the identifier is the one in parameter
UUID clientOrJobId;
String parameter = fileUploaderHelper.getParameterValue(request, UploadServletParameter.clientId, false);
if (actionByParameterName.equals(UploadServletAction.getConfig) parameter != null) {
clientOrJobId = UUID.fromString(parameter);
}
// if not, get it from manager
else {
clientOrJobId = staticStateIdentifierManager.getIdentifier();
}
// call authorizer
authorizer.getAuthorization(
request,
actionByParameterName,
clientOrJobId,
fileIdFieldValue != null ? getFileIdsFromString(fileIdFieldValue).toArray(new UUID[] {}) : null);
}
}
private Serializable processAction(UploadServletAction actionByParameterName, HttpServletRequest request)
throws Exception {
log.debug("Processing action " + actionByParameterName.name());
Serializable returnObject = null;
switch (actionByParameterName) {
case getConfig:
String parameterValue = fileUploaderHelper.getParameterValue(request, UploadServletParameter.clientId, false);
returnObject =
uploadProcessor.getConfig(
parameterValue != null ? UUID.fromString(parameterValue) : null);
break;
case verifyCrcOfUncheckedPart:
returnObject = verifyCrcOfUncheckedPart(request);
break;
case prepareUpload:
returnObject = prepareUpload(request);
break;
case clearFile:
uploadProcessor.clearFile(UUID.fromString(fileUploaderHelper.getParameterValue(request, UploadServletParameter.fileId)));
break;
case clearAll:
uploadProcessor.clearAll();
break;
case pauseFile:
ListUUID uuids = getFileIdsFromString(fileUploaderHelper.getParameterValue(request, UploadServletParameter.fileId));
uploadProcessor.pauseFile(uuids);
break;
case resumeFile:
returnObject =
uploadProcessor.resumeFile(UUID.fromString(fileUploaderHelper.getParameterValue(request, UploadServletParameter.fileId)));
break;
case setRate:
uploadProcessor.setUploadRate(UUID.fromString(fileUploaderHelper.getParameterValue(request, UploadServletParameter.fileId)),
Long.valueOf(fileUploaderHelper.getParameterValue(request, UploadServletParameter.rate)));
break;
case getProgress:
returnObject = getProgress(request);
break;
}
return returnObject;
}
ListUUID getFileIdsFromString(String fileIds) {
String[] splittedFileIds = fileIds.split(",");
ListUUID uuids = Lists.newArrayList();
for (int i = 0; i splittedFileIds.length; i++) {
uuids.add(UUID.fromString(splittedFileIds[i]));
}
return uuids;
}
private Serializable getProgress(HttpServletRequest request)
throws MissingParameterException {
Serializable returnObject;
String[] ids =
new Gson()
.fromJson(fileUploaderHelper.getParameterValue(request, UploadServletParameter.fileId), String[].class);
CollectionUUID uuids = Collections2.transform(Arrays.asList(ids), new FunctionString, UUID() {
@Override
public UUID apply(String input) {
return UUID.fromString(input);
}
});
returnObject = Maps.newHashMap();
for (UUID fileId : uuids) {
try {
ProgressJson progress = uploadProcessor.getProgress(fileId);
((HashMapString, ProgressJson) returnObject).put(fileId.toString(), progress);
}
catch (FileNotFoundException e) {
log.debug("No progress will be retrieved for " + fileId + " because " + e.getMessage());
}
}
return returnObject;
}
private Serializable prepareUpload(HttpServletRequest request)
throws MissingParameterException, IOException {
// extract file information
PrepareUploadJson[] fromJson =
new Gson()
.fromJson(fileUploaderHelper.getParameterValue(request, UploadServletParameter.newFiles), PrepareUploadJson[].class);
// prepare them
final HashMapString, UUID prepareUpload = uploadProcessor.prepareUpload(fromJson);
// return them
return Maps.newHashMap(Maps.transformValues(prepareUpload, new FunctionUUID, String() {
public String apply(UUID input) {
return input.toString();
};
}));
}
private Boolean verifyCrcOfUncheckedPart(HttpServletRequest request)
throws IOException, MissingParameterException, FileCorruptedException, FileStillProcessingException {
UUID fileId = UUID.fromString(fileUploaderHelper.getParameterValue(request, UploadServletParameter.fileId));
try {
uploadProcessor.verifyCrcOfUncheckedPart(fileId,
fileUploaderHelper.getParameterValue(request, UploadServletParameter.crc));
}
catch (InvalidCrcException e) {
// no need to log this exception, a fallback behaviour is defined in the
// throwing method.
// but we need to return something!
return Boolean.FALSE;
}
return Boolean.TRUE;
}
}
java web断点续传,我用的是fileupload来做的上传。
使用Struts2上传文件：
Struts文件上传需要使用File Upload Filter。Filter Upload Filter使用一些默认的规则：
Form中的s:file name="image"/s:file标签对应着Action类中的三个属性分别是：上传文件（java.io.File类型），文件名（java.lang.String类型），文件类型（java.lang.String类型，例如：image/jpeg）。命名规约为：
文件：名字与s:file标签中的name属性一致，这里为：image
文件名：文件 + FileName，这里为：imageFileName
文件类型：文件 + ContentType，这里为：imageContentType
所以针对上述s:file name="image"/s:file表示啊的上传文件的JSP和Action类被别为：
imageUpload.jsp：
[html] view plain copy
%@ page contentType="text/html;charset=UTF-8" language="java" %
%@taglib prefix="s" uri="/struts-tags" %
html
headtitleImage Upload/title/head
body
h1 Image Upload Page /h1
s:form action="imageUpload" method="post" enctype="multipart/form-data"
s:file name="image"/s:file
s:submit/s:submit
/s:form
/body
/html
ImageUploadAction.java：
[html] view plain copy
package com.jpleasure;
import com.opensymphony.xwork2.ActionSupport;
import java.io.File;
import java.io.InputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
public class ImageUploadAction extends ActionSupport {
private File image;
private String imageFileName;
private String imageContentType;
public File getImage() {
return image;
}
public void setImage(File image) {
this.image = image;
}
public String getImageFileName() {
return imageFileName;
}
public void setImageFileName(String imageFileName) {
this.imageFileName = imageFileName;
}
public String getImageContentType() {
return imageContentType;
}
public void setImageContentType(String imageContentType) {
this.imageContentType = imageContentType;
}
public String execute() {
if (image != null) {
System.out.println("file name is:" + this.imageFileName);
System.out.println("file content type is:" + this.imageContentType);
System.out.println("file length is:" + this.image.length());
}
return SUCCESS;
}
}
Struts.xml配置文件：
[html] view plain copy
action name="imageUpload" class="com.jpleasure.ImageUploadAction"
result/success.jsp/result
/action
这样当我们选中上传文件，提交的时候：文件内容会以File类型的方式放在image声明的变量中。文件的名字将会被放在imageFileName命名的变量中，文件的类型被放在imageContentType命名的变量中。
文件下载：
文件下载需要使用一个特殊的Result，stream类型的Result。Stream类型的Result主要用来处理文件下载操作。
处理原理为：所有的下载文件都是将一个二进制的流写入到HttpResponse中去。在Action类中定义一个InputSream类型的二进制流，在Result返回给用户的时候返回给用户。
扩展上述的代码，将上传来的文件直接下载给用户：
ImageUploadAction中需要追加一个InputSream类型的对象，并且指向上传的文件，代码如下，红色部分表示变化：
[html] view plain copy
package com.jpleasure;
import com.opensymphony.xwork2.ActionSupport;
import java.io.File;
import java.io.InputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
public class ImageUploadAction extends ActionSupport {
private File image;
private String imageFileName;
private String imageContentType;
private InputStream imageInputStream = null;
public InputStream getImageInputStream() {
return imageInputStream;
}
public void setImageInputStream(InputStream imageInputStream) {
this.imageInputStream = imageInputStream;
}
public File getImage() {
return image;
}
public void setImage(File image) {
this.image = image;
}
public String getImageFileName() {
return imageFileName;
}
public void setImageFileName(String imageFileName) {
this.imageFileName = imageFileName;
}
public String getImageContentType() {
return imageContentType;
}
public void setImageContentType(String imageContentType) {
this.imageContentType = imageContentType;
}
public String execute() {
if (image != null) {
System.out.println("file name is:" + this.imageFileName);
System.out.println("file content type is:" + this.imageContentType);
System.out.println("file length is:" + this.image.length());
try {
this.imageInputStream = new FileInputStream (image);
} catch (FileNotFoundException e) {
e.printStackTrace();
}
}
return SUCCESS;
}
}
配置文件为，红色为变化部分：
[html] view plain copy
action name="imageUpload" class="com.jpleasure.ImageUploadAction"
result name="success" type="stream"
param name="contentType"image/pjpeg/param
param name="inputName"imageInputStream/param
param name="contentDisposition"attachment;filename="image.jpg"/param
param name="bufferSize"1024/param
/result
/action
ContentType表示下载文件的类型。
InputName表示Action类中用来下载文件的字段的名字。
ContentDisposition用来控制文件下载的一些信息，包括是否打开另存对话框，下载文件名等。
BufferSize表示文件下载时使用的缓冲区的大小。
实际项目开发的考虑：
控制上传文件的类型和最大允许上传文件的size
使用File Upload Intercepter的参数可盈控制上传文件的类型和最大允许上传文件的size。例如：
[html] view plain copy
struts
package name="myPackage" extends="struts-default"
interceptor-ref name="fileUpload"
param name="maximumSize"2MB/param
param name="allowedTypes"text/html,image/jpeg/param
/interceptor-ref
interceptor-ref name="basicStack"/
action name="imageUpload" class="com.jpleasure.ImageUploadAction"
result name="success" type="stream"
param name="contentType"image/pjpeg/param
param name="inputName"imageInputStream/param
param name="contentDisposition"
attachment;filename="image.jpg"
/param
param name="bufferSize"1024/param
/result
/action
/package
/struts
上述表示允许上传jpeg和html类型的文件，且最大文件上传size为2MB
显示错误信息：
可以使用如下key表示的message来显示文件上传出错的提示信息：
消息Key 说明
struts.messages.error.uploading 文件无法正常上传时的公共错误
struts.messages.error.file.too.large 文件大小超过最大允许size时的错误提示
struts.messages.error.content.type.not.allowed 文件类型不在上传文件允许类型中的错误提示
Java Socket如何实现文件的断点续传，有代码更好
上传:
上传时附带一个描述数据起始位置的参数。
接受的一端接收到数据后java断点续传上传代码，按照起始位置续写文件。
下载:
按照本地已保存的大小java断点续传上传代码，提交下载请求。
服务器按照请求的位置，传数据。
大概就是这么个意思。还要处理很多异常情况。
JAVA语言，文件传输，实现加密和断点续传功能的程序代码，529162033@qq.com好的话加分
package com.down;
import java.io.File;
import com.common.Common;
import com.common.ExceptionManager;
public class MainThreadDownFile{
private String url;
private String localsavePath;
private String localsaveName;
private int threadNum;
private static String tempStoreDirectory;//临时文件路径
private long eachThreadSzie;//平均每个线程获取文件的大小
boolean isDownStop=false;
private int entid;
public MainThreadDownFile(int entid,String url,String savePath,String saveName,int threadNum) {
this.entid=entid;
this.url=url;
this.localsavePath=savePath;
this.localsaveName=saveName;
this.threadNum=threadNum;
if(!createDirectory(localsavePath)){ //创建存放附件的地址
Common.WriteLog("创建文件失败！");
return;
}
}
/**创建存放临时文件的临时文件夹*/
private String getTempStoreDirectory(String tempDirctoryName){
String tempDirctory = localsavePath +"\\"+ tempDirctoryName;
String tNum = "";
do{
tempDirctory = tempDirctory + tNum;
File file = new File(tempDirctory);
if(file.exists()) tNum = "0";
else return tempDirctory;
} while(true);
}
/**判断是否有存放附件文件夹，如果没有就创建*/
private boolean createDirectory(String localFileAddress){
try{
File file = new File(localFileAddress);
if(!file.exists())
file.mkdir();
}catch(Exception e){
e.printStackTrace();
return false;
}
return true;
}
public void getEachThreadFileSize(long size){
eachThreadSzie=size/threadNum;
}
public boolean checkExistTPFile(){
File file = new File(tempStoreDirectory);
String fileList[] = file.list();
if(fileList.length 0){
for(int i = 0; i fileList.length; i++)
if(fileList[i].indexOf(".tp") 0)
return true;
}
return false;
}
public void init(NetManager nm) throws ExceptionManager{
try{
if(nm.getCode()==200){
String tempDirctoryName="tmp";
DownInfoWriteXml diwx=new DownInfoWriteXml(localsavePath);
String localSaveAddress=diwx.downFileExist(url); //获取临时附件地址
if(localSaveAddress!=null){
this.tempStoreDirectory=localSaveAddress;
}else{
synchronized(this){
tempStoreDirectory=getTempStoreDirectory(tempDirctoryName);
createDirectory(tempStoreDirectory);
diwx.addOneDownRecord(url, tempStoreDirectory);
diwx.saveChange();
}
}
long filesize=nm.getFileSize();
String filename=Common.getSuffixName(nm.getUrlFileName(),"/");
String tempThreadfileName=tempStoreDirectory + "\\" + filename + ".part";
getEachThreadFileSize(filesize);
SingleThreadDownFile[] stdf=new SingleThreadDownFile[threadNum];
long startPos=0L,endPos=0L;
for(int i=1;i=threadNum;i++){
if(i1) startPos+=eachThreadSzie;
endPos=startPos+eachThreadSzie;
DownInfo di=new DownInfo(i,url,startPos,endPos);
stdf[i-1]=new SingleThreadDownFile(tempThreadfileName+i);
stdf[i-1].setDi(di);
stdf[i-1].start();
}
String str[]=new String[threadNum];
boolean isStop=true;
DownState ds=new DownState(filesize);
while(isStop){
int n=0;
long fsize=0L;
long totalsize=0L;
for(int i=1;i=threadNum;i++){
if(stdf[i-1].isAlive())
fsize += stdf[i-1].downPace;
else n++;
long tsize=new Long(stdf[i-1].downSize);
if(tsize==0){
totalsize += Common.FileSize(tempThreadfileName+i);
}else{
totalsize += tsize;
}
}
if(n==threadNum) isStop=false;
ds.updateDownSize(fsize,totalsize);
ds.init(isStop);
}
if(!checkExistTPFile()!isStop){
FileCombination fc=new FileCombination(url,tempStoreDirectory,localsavePath,localsaveName);
fc.init();
isDownStop=true;
}
}else{
Common.WriteLog(nm.getHttpMessage(nm.getCode()));
}
}catch(Exception e){
throw new ExceptionManager(entid,"出现异常",e);
}
}
}
关于JAVA断点续传
024字节）。第一次B接收了512字节java断点续传上传代码，那么第二次连接A就应该从513字节开始传输。
也就是说java断点续传上传代码，在第二次传输时java断点续传上传代码，B要提供“java断点续传上传代码我要从513字节开始传送文件F”的信息，然后A使用FileInputStream构建输入流读取本地文件，使用skip(512)方法跳过文件F的前512字节再传送文件，之后B将数据追加（append）到先前接收的文件末尾即可。
进一步考虑，如果要实现多线程传送，即分块传输，也同样的道理。假如B要求分作两块同时传输，那么A启动两个线程，一个从513字节读到768字节（工256字节），第二个线程从769字节到1024字节即可。
如果你要从网络上下载文件，就是说A方不是你实现的，那么你要先确认A方支不支持断电续传功能（HTTP1.1），然后你查阅下HTTP1.1协议，在HTTP1.1版本里，可以通过设置请求包头某个字段的信息（使用URLConnection创建连接并使用setRequestProperty(String key, String value) 方法设置）从而精确读取文件的某一段数据的。注意，基于HTTP断点续传的关键是1.1版本，1.0版本是不支持的。
补充java断点续传上传代码：
嗯，查到了，是设置range属性，即setRequestProperty("range", "bytes=513-1024").你可以使用迅雷下载某个文件，然后从”线程信息“中就可以看到这个http1.1断点续传的所有行为信息了。
用Java实现HTTP断点续传功能(2)
//启动子线程
fileSplitterFetch = new FileSplitterFetch[nStartPos length];
for(int i= ;ilt;nStartPos length;i++)
{
fileSplitterFetch[i] = new FileSplitterFetch(siteInfoBean getSSiteURL()
siteInfoBean getSFilePath() + File separator + siteInfoBean getSFileName()
nStartPos[i] nEndPos[i] i);
Utility log( Thread + i + nStartPos = + nStartPos[i] + nEndPos = + nEndPos[i]);
fileSplitterFetch[i] start();
}
// fileSplitterFetch[nPos length ] = new FileSplitterFetch(siteInfoBean getSSiteURL()
siteInfoBean getSFilePath() + File separator + siteInfoBean getSFileName() nPos[nPos length ] nFileLength nPos length );
// Utility log( Thread + (nPos length ) + nStartPos = + nPos[nPos length ] +
nEndPos = + nFileLength);
// fileSplitterFetch[nPos length ] start();
//等待子线程结束
//int count = ;
//是否结束while循环
boolean breakWhile = false;
while(!bStop)
{
write_nPos();
Utility sleep( );
breakWhile = true;
for(int i= ;ilt;nStartPos length;i++)
{
if(!fileSplitterFetch[i] bDownOver)
{
breakWhile = false;
break;
}
}
if(breakWhile)
break;
//count++;
//if(countgt; )
// siteStop();
}
System err println( 文件下载结束！ );
}
catch(Exception e){e printStackTrace ();}
}
//获得文件长度
public long getFileSize()
{
int nFileLength = ;
try{
URL url = new URL(siteInfoBean getSSiteURL());
HttpURLConnection Connection = (HttpURLConnection)url openConnection ();
( User Agent NetFox );
int responseCode=();
if(responseCodegt;= )
{
processErrorCode(responseCode);
return ; // represent access is error
}
String sHeader;
for(int i= ;;i++)
{
//DataInputStream in = new DataInputStream( ());
//Utility log(in readLine());
sHeader=(i);
if(sHeader!=null)
{
if(sHeader equals( Content Length ))
{
nFileLength = Integer parseInt((sHeader));
break;
}
}
else
break;
}
}
catch(IOException e){e printStackTrace ();}
catch(Exception e){e printStackTrace ();}
Utility log(nFileLength);
return nFileLength;
}
//保存下载信息（文件指针位置）
private void write_nPos()
{
try{
output = new DataOutputStream(new FileOutputStream(tmpFile));
output writeInt(nStartPos length);
for(int i= ;ilt;nStartPos length;i++)
{
// output writeLong(nPos[i]);
output writeLong(fileSplitterFetch[i] nStartPos);
output writeLong(fileSplitterFetch[i] nEndPos);
}
output close();
}
catch(IOException e){e printStackTrace ();}
catch(Exception e){e printStackTrace ();}
}
//读取保存的下载信息（文件指针位置）
private void read_nPos()
{
try{
DataInputStream input = new DataInputStream(new FileInputStream(tmpFile));
int nCount = input readInt();
nStartPos = new long[nCount];
nEndPos = new long[nCount];
for(int i= ;ilt;nStartPos length;i++)
{
nStartPos[i] = input readLong();
nEndPos[i] = input readLong();
}
input close();
}
catch(IOException e){e printStackTrace ();}
catch(Exception e){e printStackTrace ();}
}
private void processErrorCode(int nErrorCode)
{
System err println( Error Code : + nErrorCode);
}
//停止文件下载
public void siteStop()
{
bStop = true;
for(int i= ;ilt;nStartPos length;i++)
fileSplitterFetch[i] splitterStop();
}
lishixinzhi/Article/program/Java/hx/201311/27070
java断点续传上传代码的介绍就聊到这里吧，感谢你花时间阅读本站内容，更多关于java实现断点续传原理、java断点续传上传代码的信息别忘了在本站进行查找喔。
