java实现断点续传

⑴ 用java实现HTTP断点续传功能(2)

//启动子线程

fileSplitterFetch = new FileSplitterFetch[nStartPos length];

for(int i= ;i<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= ;i<nStartPos length;i++)

{

if(!fileSplitterFetch[i] bDownOver)

{

breakWhile = false;

break;

}

}

if(breakWhile)

break;

//count++;

//if(count> )

// 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(responseCode>= )

{

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= ;i<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= ;i<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= ;i<nStartPos length;i++)

fileSplitterFetch[i] splitterStop();

}

⑵ 用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:
List<UUID> 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;
}

List<UUID> getFileIdsFromString(String fileIds) {
String[] splittedFileIds = fileIds.split(",");
List<UUID> 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);
Collection<UUID> uuids = Collections2.transform(Arrays.asList(ids), new Function<String, UUID>() {

@Override
public UUID apply(String input) {
return UUID.fromString(input);
}

});
returnObject = Maps.newHashMap();
for (UUID fileId : uuids) {
try {
ProgressJson progress = uploadProcessor.getProgress(fileId);
((HashMap<String, 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 HashMap<String, UUID> prepareUpload = uploadProcessor.prepareUpload(fromJson);

// return them
return Maps.newHashMap(Maps.transformValues(prepareUpload, new Function<UUID, 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 Socket如何实现文件的断点续传，有代码更好

1package com.tangshun.www.socket;
2
3import java.io.File;
4import java.io.IOException;
5import java.io.InputStream;
6import java.io.RandomAccessFile;
7import java.net.HttpURLConnection;
8import java.net.MalformedURLException;
9import java.net.URL;
10
11//断点续传
12public class DownLoad {
13
14 public static void down(String URL, long nPos, String savePathAndFile) {
15 try {
16 URL url = new URL(URL);
17 HttpURLConnection httpConnection = (HttpURLConnection) url
18 .openConnection();
19 // 设置User-Agent
20 httpConnection.setRequestProperty("User-Agent", "NetFox");
21 // 设置断点续传的开始位置
22 httpConnection.setRequestProperty("RANGE", "bytes=" + nPos);
23 // 获得输入流
24 InputStream input = httpConnection.getInputStream();
25 RandomAccessFile oSavedFile = new RandomAccessFile(savePathAndFile,
26 "rw");
27 // 定位文件指针到nPos位置
28 oSavedFile.seek(nPos);
29 byte[] b = new byte[1024];
30 int nRead;
31 // 从输入流中读入字节流，然后写到文件中
32 while ((nRead = input.read(b, 0, 1024)) > 0) {
33 (oSavedFile).write(b, 0, nRead);
34 }
35 httpConnection.disconnect();
36 } catch (MalformedURLException e) {
37 e.printStackTrace();
38 } catch (IOException e) {
39 e.printStackTrace();
40 }
41 }
42
43 public static long getRemoteFileSize(String url) {
44 long size = 0;
45 try {
46 HttpURLConnection conn = (HttpURLConnection) (new URL(url))
47 .openConnection();
48 size = conn.getContentLength();
49 conn.disconnect();
50 } catch (Exception e) {
51 e.printStackTrace();
52 }
53 return size;
54 }
55
56public static void main(String[] args) {
57 String url = " http://www.videosource.cgogo.com/media/0/16/8678/8678.flv";
58 String savePath = "F:\\";
59 String fileName = url.substring(url.lastIndexOf("/"));
60 String fileNam=fileName;
61 HttpURLConnection conn = null;
62 try {
63 conn = (HttpURLConnection) (new URL(url)).openConnection();
64 } catch (Exception e) {
65 e.printStackTrace();
66 }
67 File file = new File(savePath + fileName);
68 // 获得远程文件大小
69 long remoteFileSize = getRemoteFileSize(url);
70 System.out.println("远程文件大小="+remoteFileSize);
71 int i = 0;
72 if (file.exists()) {
73 // 先看看是否是完整的，完整，换名字，跳出循环，不完整，继续下载
74 long localFileSize = file.length();
75 System.out.println("已有文件大小为:"+localFileSize);
76
77 if (localFileSize < remoteFileSize) {
78 System.out.println("文件续传");
79 down(url, localFileSize, savePath + fileName);
80 }else{
81 System.out.println("文件存在，重新下载");
82 do{
83 i++;
84 fileName = fileNam.substring(0, fileNam.indexOf(".")) + "(" + i
85 + ")" + fileNam.substring(fileNam.indexOf("."));
86
87 file = new File(savePath + fileName);
88 }while(file.exists());
89 try {
90 file.createNewFile();
91 } catch (IOException e) {
92 e.printStackTrace();
93 }
94 down(url, 0, savePath + fileName);
95 }
96 // 下面表示文件存在，改名字
97
98 } else {
99 try {
100 file.createNewFile();
101 System.out.println("下载中");
102 down(url, 0, savePath + fileName);
103 } catch (IOException e) {
104 e.printStackTrace();
105 }
106 }
107 }}
108

⑷ java 断点续传

这个不太难吧？
假设A给B传文件F（1024字节）。第一次B接收了512字节，那么第二次连接A就应该从513字节开始传输。
也就是说，在第二次传输时，B要提供“我要从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版本是不支持的。

补充：
嗯，查到了，是设置range属性，即setRequestProperty("range", "bytes=513-1024").你可以使用迅雷下载某个文件，然后从”线程信息“中就可以看到这个http1.1断点续传的所有行为信息了。
希望能解决您的问题。

⑸ java ftp上传时断网，文件损坏

以二进制流上传，然后实现断点续传。

/**
* 上传文件到FTP服务器，支持断点续传
* @param local 本地文件名称，绝对路径
* @param remote 远程文件路径，使用/home/directory1/subdirectory/file.ext 按照Linux上的路径指定方式，支持多级目录嵌套，支持递归创建不存在的目录结构
* @return 上传结果
* @throws IOException
*/
public UploadStatus upload(String local,String remote) throws IOException{
FTPClient ftpClient = new FTPClient();
//设置PassiveMode传输
ftpClient.enterLocalPassiveMode();
//设置以二进制流的方式传输
ftpClient.setFileType(FTP.BINARY_FILE_TYPE);
UploadStatus result;
//对远程目录的处理
String remoteFileName = remote;
if(remote.contains("/")){
remoteFileName = remote.substring(remote.lastIndexOf("/")+1);
String directory = remote.substring(0,remote.lastIndexOf("/")+1);
if(!directory.equalsIgnoreCase("/")&&!ftpClient.changeWorkingDirectory(directory)){
//如果远程目录不存在，则递归创建远程服务器目录
int start=0;
int end = 0;
if(directory.startsWith("/")){
start = 1;
}else{
start = 0;
}
end = directory.indexOf("/",start);
while(true){
String subDirectory = remote.substring(start,end);
if(!ftpClient.changeWorkingDirectory(subDirectory)){
if(ftpClient.makeDirectory(subDirectory)){
ftpClient.changeWorkingDirectory(subDirectory);
}else {
System.out.println("创建目录失败");
return UploadStatus.Create_Directory_Fail;
}
}

start = end + 1;
end = directory.indexOf("/",start);

//检查所有目录是否创建完毕
if(end <= start){
break;
}
}
}
}

//检查远程是否存在文件
FTPFile[] files = ftpClient.listFiles(remoteFileName);
if(files.length == 1){
long remoteSize = files[0].getSize();
File f = new File(local);
long localSize = f.length();
if(remoteSize==localSize){
return UploadStatus.File_Exits;
}else if(remoteSize > localSize){
return UploadStatus.Remote_Bigger_Local;
}

//尝试移动文件内读取指针,实现断点续传
InputStream is = new FileInputStream(f);
if(is.skip(remoteSize)==remoteSize){
ftpClient.setRestartOffset(remoteSize);
if(ftpClient.storeFile(remote, is)){
return UploadStatus.Upload_From_Break_Success;
}
}

//如果断点续传没有成功，则删除服务器上文件，重新上传
if(!ftpClient.deleteFile(remoteFileName)){
return UploadStatus.Delete_Remote_Faild;
}
is = new FileInputStream(f);
if(ftpClient.storeFile(remote, is)){
result = UploadStatus.Upload_New_File_Success;
}else{
result = UploadStatus.Upload_New_File_Failed;
}
is.close();
}else {
InputStream is = new FileInputStream(local);
if(ftpClient.storeFile(remoteFileName, is)){
result = UploadStatus.Upload_New_File_Success;
}else{
result = UploadStatus.Upload_New_File_Failed;
}
is.close();
}
return result;
}

⑹ Java网络编程从入门到精通（23）：HTTP消息头字段

专题推荐 网络编程 基础到进阶教程

一 通用头字段

Connection

这个字段只在HTTP 协议中存在 它决定了客户端和服务器进行了一次会话后 服务器是否立即关闭网络连接 在客户端最直接的表现是使用read方法（readLine方法也是一样）读完客户端请求的Web资源后 是否立即返回 （readLine返回null） Connection有两个值 Close和Keep Alive 当使用Connection Close时 和HTTP 协议是一样的 当read方法读完数据时立即返回 而使用Connection Keep Alive时 read方法在读完数据后还要烂局被阻塞一段时间 直接读取数据超时时间过后 还继续往下执行 在上一篇文章中讨论的readHttpResponse（……）方法实现的第 行可以验证Connection的作用 下面让我们来使用HTTP模拟器来做一个实验

（ ）在HTTP模拟器中输入如下的域名

（ ）HTTP模拟器中输入如下的HTTP请求信息

GET/HTTP/ 孙唤Host:

（ ）按两下回车（输入一个空行）后 发送请求消息 并得到如图 如示的HTTP响应消息头

（ ）输入y或Y后（在显示响应头后 要立刻输入Y或y） 显示响应消息的内容 在显示完内容后 大约过了 秒钟才进入 host port> 提示符（因为在sendHttpRequest（）的实现代码中的 行设置了读取数据超时）

（ ）在 host port> 提示符下直接按回车 输入最近一次使用的域名和 端口 再次输入如下的HTTP请求

GET/HTTP/ Host: Connection:close

输入完以上的HTTP请求后 重新执行第 步操作 最后在显示HTTP响应消息内容后 直接直入了 host port> 提示符 除了这种方法 将请求的第一行改为GET / HTTP/ 这样也可以无需等待直接结束

通过设置Connection 可以在下载Web资源（如多线程下载工具 Web浏览器等）后 立即断开网络连接 这样可以有效地降低客户机的资源消耗

Date

这个Date头字段描述了请求消息和响应消息被创建的时间 这个字段值是一个HTTP date类型 它的格式必须是GMT（格林尼治）时间 GMT时间是就是北京时间减 小时 下面是Date字段的一个例子

Date:Tue Nov : : GMT

Content Length

指定消息实体的则历凯字节数 在请求消息中POST方法必须使用Content Length来指定请求消息的实体内容的字节数 在响应消息中这个字段值指定了当前HTTP响应所返回的Web资源的字节数

二 HTTP请求消息头字段

Host

Host字段用于指定客户端所访问的资源所在的主机名和端口号 如果端口号等于连接服务器时所使用的端口号 则端口号可以省略 下面是一个使用Host字段的一个例子

Host:

这个字段是必须的 如果HTTP请求不包含这个字段 服务器将返回 （Bad Request）响应状态

Accept

Accept字段头确定客户端可以接收的媒体类型 一般的格式是 */* 或 类型/ 子类型 这个子段头可以传递多个媒体类型 中间用 隔开 如下面是一个Accept的例子

Accept: image/gif image/jpg

如果请求头使用上述的Accept字段值 则服务器端在动态生成网页的IMG头时将首先包含gif格式的图像 如果gif图象不存在 则包含jpg格式的图象

User Agent

这个字段头用于指定客户端是用什么访问的服务器 如果是IE 浏览器 并且本机安装了 net 则User Agent会有如下的值

User Agent:Mozilla/ (patible;MSIE ;WindowsNT ;SV ;Maxthon; NETCLR ; NETCLR ;InfoPath ;InfoPath )

服务器可以通过这个字段检查客户机的浏览器版本 并根据不同的版本来确定向客户端发送的数据

Range

Range字段头通过服务器只传输一部分Web资源 这个字段头可以用来实现断点续传功能 有很多下载工具就是通过这个字段头进行断点续传的 Range字段可以通过三种格式设置要传输的字节范围

（ ）Range bytes=

传输范围从 到 字节

（ ）Range bytes=

传输Web资源中第 个字节以后的所有内容

（ ）Range bytes=

传输最后 个字节

三 HTTP响应消息头字段

Accept Ranges

这个字段说明Web服务器是否支持Range（是否支持断点续传功能） 如果支持 则返回Accept Ranges bytes 如果不支持 则返回Accept Ranges none

Content Range

指定了返回的Web资源的字节范围 这个字段值的格式是

开始字节位置—结束字节位置/Web资源的总字节数

下面是一个使用Content Range的例子

Content Range /

测试

在HTTP模拟器中连接服务器 并输入如下的HTTP请求消息

GET /nokiaguy/HttpSimulator rar HTTP/ Host: Range:bytes=

返回的响应消息头如图 所示

从上图可以看出 服务器支持断点继传功能 而且还可以验证Content Length的值是当前会话传过来的字节数 并不是Web资源的总的字节数 而Content Range字段值中 / 后面的数才是Web资源总的字节数

Location

⑺ java ftp怎么实现java ftp方式的断点续传

运用类的办法，编程人员能够长途登录到FTP服务器，罗列该服务器上的目录，设置传输协议，以及传送文件。FtpClient类涵 盖了简直一切FTP的功用，FtpClient的实例变量保留了有关树立"署理"的各种信息。下面给出了这些实例变量：

public static boolean useFtpProxy

这个变量用于标明FTP传输过程中是不是运用了一个署理，因此，它实际上是一个符号，此符号若为TRUE，标明运用了一个署理主机。

public static String ftpProxyHost

此变量只要在变量useFtpProxy为TRUE时才有用，用于保留署理主机名。

public static int ftpProxyPort

此变量只要在变量useFtpProxy为TRUE时才有用，用于保留署理主机的端口地址。

FtpClient有三种不同方式的结构函数，如下所示：

1、public FtpClient(String hostname,int port)

此结构函数运用给出的主机名和端口号树立一条FTP衔接。

2、public FtpClient(String hostname)

此结构函数运用给出的主机名树立一条FTP衔接，运用默许端口号。

3、FtpClient()

此结构函数将创立一FtpClient类，但不树立FTP衔接。这时，FTP衔接能够用openServer办法树立。

一旦树立了类FtpClient，就能够用这个类的办法来翻开与FTP服务器的衔接。类ftpClient供给了如下两个可用于翻开与FTP服务器之间的衔接的办法。

public void openServer(String hostname)

这个办法用于树立一条与指定主机上的FTP服务器的衔接，运用默许端口号。