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伺服器的銜接，運用默許埠號。