陌上花開

１。Hash關聯數組定義

// 定義空數組
myhash = { }

// 直接定義數組
myhash = {”key1″:”val1″, “key2″:”val2″ }

// 用Array 定義數組
myhash = new Array();
myhash[”key1″] = “val1″;
myhash[”key2″] = “val2″;

２。向Hash關聯數組添加鍵值

// 添加一個新鍵 newkey ，鍵值為 newval
myhash[”newkey”] = “newval”;

３。刪除Hash關聯數組已有鍵值

// 刪除一個鍵 newkey ，同時，該鍵值對應的 newval 也就消失了
delete myhash[”newkey”];

４。遍歷Hash關聯數組

// 遍歷整個hash 數組
for (key in myhash) {
val = myhash[key];
}

５。Hash關聯數組簡易使用示例

// 轉向腳本
<script type=”text/javascript”>
urlhash = { “yahoo”:”www.yahoo.cn“,
“baidu”:”www.baidu.com“,
“google”:”www.google.cn” };

// 交互式使用示例
userinfo = prompt(”請輸入您最想去的搜索引擎：(yahoo|baidu|google)”, “yahoo”);
document.write (”您的選擇：” + userinfo + “，<a href=http://” + getURL(userinfo) + ” target=_blank>” + “按此即可進入” + “</a>” + userinfo + “。”);

// getURL
// 如果參數未定義，默認返回 www.yahoo.cn 網址
// @param choice 選擇名稱
// @return url 實際的URL
function getURL(choice) {
url = urlhash[choice];
if (typeof(urlhash[choice]) == “undefined”)
url = “www.yahoo.cn“;
return url;
}

// 獲得hash列表的所有 keys
// @param hash hash數組
// @return keys 鍵名數據
function array_keys(hash) {
keys = [];
for (key in hash)
keys.push(key);
return keys;
}
</script>

原文地址：http://www.cnblogs.com/Lewis/archive/2010/04/27/1722024.html

關于JQuery上傳插件Uploadify使用詳解網上一大把，基本上內容都一樣。我根據網上的步驟配置成功后，會報一些錯誤，而我根據這些錯誤去網上找解決方案，卻沒有相關資料，所以為了不讓更多的朋友走彎路，我把我遇到的一些問題進行匯總，也方便我自己以后查閱。

　　什么是Uploadify

　　Uploadify是JQuery的一個上傳插件，支持多文件上傳，實現的效果非常不錯，帶進度顯示。

　　官網提供的是PHP的DEMO,在這里我詳細介紹在Asp.net下的使用.

　　下載

　　　　官方下載

　　　　官方文檔

　　　　官方演示

　　如何使用

　　1 創建Web項目，命名為JQueryUploadDemo，從官網上下載最新的版本解壓后添加到項目中

　　2 在項目中添加UploadHandler.ashx文件用來處理文件的上傳。

　　3 在項目中添加UploadFile文件夾，用來存放上傳的文件。

　　進行完上面三步后項目的基本結構如下圖:

　　4 Default.aspx的html頁的代碼修改如下：

　　5  UploadHandler類的ProcessRequest方法代碼如下：

　　注意:這里一定要注意，一定要引用using System.IO;命名空間，我出錯的原因也是在這里，網上的教程基本上都沒提到這一點，所以有很多網友會遇到IOError的錯誤。

6 運行后效果如下圖：

　　7 選擇了兩個文件后，點擊上傳，就可以看到UploadFile文件夾中會增加這兩個文件。

　　上面的代碼就簡單實現了上傳的功能，依靠函數uploadify實現，uploadify函數的參數為json格式，可以對json對象的key值的修改來進行自定義的設置，如multi設置為true或false來控制是否可以進行多文件上傳，下面就來介紹下這些key值的意思：

uploader ： uploadify.swf 文件的相對路徑，該swf文件是一個帶有文字BROWSE的按鈕，點擊后淡出打開文件對話框，默認值：uploadify.swf。
script ：   后臺處理程序的相對路徑 。默認值：uploadify.php
checkScript ：用來判斷上傳選擇的文件在服務器是否存在的后臺處理程序的相對路徑
fileDataName ：設置一個名字，在服務器處理程序中根據該名字來取上傳文件的數據。默認為Filedata
method ： 提交方式Post 或Get 默認為Post
scriptAccess ：flash腳本文件的訪問模式，如果在本地測試設置為always，默認值：sameDomain 
folder ：  上傳文件存放的目錄 。
queueID ： 文件隊列的ID，該ID與存放文件隊列的div的ID一致。
queueSizeLimit ： 當允許多文件生成時，設置選擇文件的個數，默認值：999 。
multi ： 設置為true時可以上傳多個文件。
auto ： 設置為true當選擇文件后就直接上傳了，為false需要點擊上傳按鈕才上傳 。
fileDesc ： 這個屬性值必須設置fileExt屬性后才有效，用來設置選擇文件對話框中的提示文本，如設置fileDesc為“請選擇rar doc pdf文件”，打開文件選擇框效果如下圖：

fileExt ： 設置可以選擇的文件的類型，格式如：'*.doc;*.pdf;*.rar' 。
sizeLimit ： 上傳文件的大小限制 。
simUploadLimit ： 允許同時上傳的個數 默認值：1 。
buttonText ： 瀏覽按鈕的文本，默認值：BROWSE 。
buttonImg ： 瀏覽按鈕的圖片的路徑 。
hideButton ： 設置為true則隱藏瀏覽按鈕的圖片 。
rollover ： 值為true和false，設置為true時當鼠標移到瀏覽按鈕上時有反轉效果。
width ： 設置瀏覽按鈕的寬度 ，默認值：110。
height ： 設置瀏覽按鈕的高度 ，默認值：30。
wmode ： 設置該項為transparent 可以使瀏覽按鈕的flash背景文件透明，并且flash文件會被置為頁面的最高層。 默認值：opaque 。
cancelImg ：選擇文件到文件隊列中后的每一個文件上的關閉按鈕圖標，如下圖：

上面介紹的key值的value都為字符串或是布爾類型，比較簡單，接下來要介紹的key值的value為一個函數，可以在選擇文件、出錯或其他一些操作的時候返回一些信息給用戶。

onInit : 做一些初始化的工作。

onSelect ：選擇文件時觸發，該函數有三個參數

• event:事件對象。
• queueID：文件的唯一標識，由6為隨機字符組成。
• fileObj：選擇的文件對象，有name、size、creationDate、modificationDate、type 5個屬性。

代碼如下：

當選擇一個文件后彈出的消息如下圖：

onSelectOnce ：在單文件或多文件上傳時，選擇文件時觸發。該函數有兩個參數event，data，data對象有以下幾個屬性：

fileCount：選擇文件的總數。
filesSelected：同時選擇文件的個數，如果一次選擇了3個文件該屬性值為3。
filesReplaced：如果文件隊列中已經存在A和B兩個文件，再次選擇文件時又選擇了A和B，該屬性值為2。
allBytesTotal：所有選擇的文件的總大小。
 

onCancel : 當點擊文件隊列中文件的關閉按鈕或點擊取消上傳時觸發。該函數有event、queueId、fileObj、data四個參數，前三個參數同onSelect 中的三個參數，data對象有兩個屬性fileCount和allBytesTotal。

fileCount：取消一個文件后，文件隊列中剩余文件的個數。
allBytesTotal：取消一個文件后，文件隊列中剩余文件的大小。
 

onClearQueue ：當調用函數fileUploadClearQueue時觸發。有event和data兩個參數，同onCancel 中的兩個對應參數。

onQueueFull ：當設置了queueSizeLimit并且選擇的文件個數超出了queueSizeLimit的值時觸發。該函數有兩個參數event和queueSizeLimit。

onError ：當上傳過程中發生錯誤時觸發。該函數有event、queueId、fileObj、errorObj四個參數，其中前三個參數同上，errorObj對象有type和info兩個屬性。

type：錯誤的類型，有三種‘HTTP’, ‘IO’, or ‘Security’
info：錯誤的描述
 

onOpen ：點擊上傳時觸發，如果auto設置為true則是選擇文件時觸發，如果有多個文件上傳則遍歷整個文件隊列。該函數有event、queueId、fileObj三個參數，參數的解釋同上。

onProgress ：點擊上傳時觸發，如果auto設置為true則是選擇文件時觸發，如果有多個文件上傳則遍歷整個文件隊列，在onOpen之后觸發。該函數有event、queueId、fileObj、data四個參數，前三個參數的解釋同上。data對象有四個屬性percentage、bytesLoaded、allBytesLoaded、speed：

percentage：當前完成的百分比
bytesLoaded：當前上傳的大小
allBytesLoaded：文件隊列中已經上傳完的大小
speed：上傳速率 kb/s
 

onComplete：文件上傳完成后觸發。該函數有四個參數event、queueId、fileObj、response、data五個參數，前三個參數同上。response為后臺處理程序返回的值，在上面的例子中為1或0，data有兩個屬性fileCount和speed

fileCount：剩余沒有上傳完成的文件的個數。
speed：文件上傳的平均速率 kb/s
注：fileObj對象和上面講到的有些不太一樣，onComplete 的fileObj對象有個filePath屬性可以取出上傳文件的路徑。

onAllComplete：文件隊列中所有的文件上傳完成后觸發。該函數有event和data兩個參數，data有四個屬性，分別為：

filesUploaded :上傳的所有文件個數。
errors ：出現錯誤的個數。
allBytesLoaded ：所有上傳文件的總大小。
speed ：平均上傳速率 kb/s
 

相關函數介紹

在上面的例子中已經用了uploadifyUpload和uploadifyClearQueue兩個函數，除此之外還有幾個函數：

uploadifySettings：可以動態修改上面介紹的那些key值，如下面代碼

　　$('#uploadify').uploadifySettings('folder','JS');　

如果上傳按鈕的事件寫成下面這樣，文件將會上傳到uploadifySettings定義的目錄中

<a href="javascript:$('#uploadify').uploadifySettings('folder','JS');$('#uploadify').uploadifyUpload()">上傳</a>

　　uploadifyCancel：該函數接受一個queueID作為參數，可以取消文件隊列中指定queueID的文件。

　　
　　$('#uploadify').uploadifyCancel(id); 

　　好了，所有的配置都完成了。下面說說我遇到的一些問題。 span style="font-size: 18pt;">　可能遇到的問題 　　1.我剛開始配置完成后，并不能正常工作 ，flash（uploadify.swf' ）沒有加載。后來我查看jquery.uploadify.v2.1.0.js發現該插件是利用swfobject.js動態創建的FLASH，后來我單獨做試驗還是不能顯示flash，無耐之下重啟電腦后就可以了。暈倒～～～　　2.FLASH終于加載進來了，但上傳又失敗了。報IOError,如圖：　　

百思不得其解，翻遍了各大網絡，終于在國外的一網站看到了這么一句using System.IO; 添加之豁然開朗！！

暫時還沒有遇到其它問題，后續發現問題再加。

特性:

• ThickBox 是用超輕量級的 jQuery 庫 編寫的. 壓縮過 jQuery 庫只15k, 未壓縮過的有39k.
• ThickBox 的 JavaScript 代碼和 CSS 文件只占12k. 所以壓縮過的 jQuery 代碼和 ThickBox 總共只有27k.
• ThickBox 能重新調整大于瀏覽器窗口的圖片.
• ThickBox 的多功能性包括 (圖片, iframed 的內容, 內嵌的內容, 和 AJAX 的內容).
• ThickBox 能隱藏 Windows IE 6 里的元素.
• ThickBox 能在使用者滾動頁面或改變瀏覽器窗口大小的同時始終保持居中. 點擊圖片, 覆蓋層, 或關閉鏈接能移除 ThickBox.
• ThickBox 的創作者決定動畫應該因人而異, 所以 ThickBox 不再使用動畫了. 這是特性嗎? 哦, 有人說是呀.

下載

在Java中有時候需要使程序暫停一點時間，稱為延時。普通延時用Thread.sleep(int)方法，這很簡單。它將當前線程掛起指定的毫秒數。如

在這里需要解釋一下線程沉睡的時間。sleep()方法并不能夠讓程序"嚴格"的沉睡指定的時間。例如當使用5000作為sleep()方法的參數時，線 程可能在實際被掛起5000.001毫秒后才會繼續運行。當然，對于一般的應用程序來說，sleep()方法對時間控制的精度足夠了。

但是如果要使用精確延時，最好使用Timer類：

這種延時比sleep精確。上述延時方法只運行一次，
如果需要運行多次， 使用timer.schedule(new MyTask(), 1000, 2000); 則每間隔2秒執行MyTask()

本課題參考自《Spring in action》。并非應用系統中發生的所有事情都是由用戶的動作引起的。有時候，系統自己也需要發起一些動作。例如，集抄系統每天早上六點把抄表數據傳送 給營銷系統。我們有兩種選擇：或者是每天由用戶手動出發任務，或者讓應用系統中按照預定的計劃自動執行任務。 
在Spring中有兩種流行配置：Java的Timer類和OpenSymphony的Quartz來執行調度任務。下面以給商丘做的接口集抄900到中間庫的日凍結數據傳輸為例： 

1. Java Timer調度器 
首先定義一個定時器任務，繼承java.util.TimerTask類實現run方法 
import java.util.TimerTask; 
import xj.service.IJdbc1Service; 
import xj.service.IJdbc2Service; 
public class DayDataTimerTask extends TimerTask{ 
private IJdbc2Service jdbc2Service=null; 
private IJdbc1Service jdbc1Service=null; 
public void run(){ 
SimpleDateFormat df=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); 
System.out.println("日凍結轉接任務開始時間："+df.format(Calendar.getInstance().getTime())); 
System.out.println("日凍結轉接任務結束時間："+df.format(Calendar.getInstance().getTime())); 
} 

//通過set方法獲取service服務，如果沒有該方法，則為null 
public void setJdbc2Service(IJdbc2Service jdbc2Service) { 
this.jdbc2Service = jdbc2Service; 
} 

public void setJdbc1Service(IJdbc1Service jdbc1Service) { 
this.jdbc1Service = jdbc1Service; 
} 
} 
Run()方法定義了當任務運行時該做什么。jdbc1Service，jdbc2Service通過依賴注入的方式提供給DayDataTimerTask。如果該任務中沒有service服務的set方法，則取到的該service服務為null。 
其次，在Spring配置文件中聲明 dayDataTimerTask： 
<!-- 聲明定時器任務 --> 
<bean id="dayDataTimerJob" class="xj.action.DayDataTimerTask"> 
<property name="jdbc1Service"> 
<ref bean="jdbc1Service"/> 
</property> 
<property name="jdbc2Service"> 
<ref bean="jdbc2Service"/> 
</property> 
</bean> 
該聲明將DayDataTimerTask放到應用上下文中，并在jdbc1Service、jdbc2Service屬性中分別裝配jdbc1Service、jdbc2Service。在調度它之前，它不會做任何事情。 
<!-- 調度定時器任務 --> 
<bean id="scheduledDayDataTimerJob" class="org.springframework.scheduling.timer.ScheduledTimerTask"> 
<property name="timerTask"> 
<ref bean="dayDataTimerJob"/> 
</property> 
<property name="delay"> 
<value>3000</value> 
</property> 
<property name="period"> 
<value>864000000</value> 
</property> 
</bean> 
屬性timerTask告訴ScheduledTimerTask運行哪個TimerTask。再次，該屬性裝配了指向 scheduledDayDataTimerJob的一個引用，它就是DayDataTimerTask。屬性period告訴 ScheduledTimerTask以怎樣的頻度調用TimerTask的run()方法。該屬性以毫秒作為單位，它被設置為864000000，指定 這個任務應該每24小時運行一次。屬性delay允許你指定當任務第一次運行之前應該等待多久。在此指定DayDataTimerTask的第一次運行相 對于應用程序的啟動時間延遲3秒鐘。 
<!-- 啟動定時器 --> 
<bean class="org.springframework.scheduling.timer.TimerFactoryBean"> 
<property name="scheduledTimerTasks"> 
<list> 
<ref bean="scheduledDayDataTimerJob"/> 
</list> 
</property> 
</bean> 
Spring的TimerFactoryBean負責啟動定時任務。屬性scheduledTimerTasks要求一個需要啟動的定時器任務的列表。在此只包含一個指向scheduledDayDataTimerJob的引用。 
    Java Timer只能指定任務執行的頻度，但無法精確指定它何時運行，這是它的一個局限性。要想精確指定任務的啟動時間，就需要使用Quartz[kw?:ts]調度器。 

2.Quartz調度器 
Quartz調度器不僅可以定義每隔多少毫秒執行一個工作，還允許你調度一個工作在某個特定的時間或日期執行。 
首先創建一個工作，繼承QuartzJobBean類實現executeInternal方法 
import org.quartz.JobExecutionContext; 
import org.quartz.JobExecutionException; 
import org.springframework.dao.DataIntegrityViolationException; 
import org.springframework.scheduling.quartz.QuartzJobBean; 

import xj.service.IJdbc1Service; 
import xj.service.IJdbc2Service; 
public class DayDataQuartzTask extends QuartzJobBean{ 
private IJdbc2Service jdbc2Service=null; 
private IJdbc1Service jdbc1Service=null; 
protected void executeInternal(JobExecutionContext context) throws JobExecutionException{ 
SimpleDateFormat df=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); 
System.out.println("日凍結轉接任務開始時間："+df.format(Calendar.getInstance().getTime())); 
System.out.println("日凍結轉接任務結束時間："+df.format(Calendar.getInstance().getTime())); 
} 

//通過set方法獲取service服務，如果沒有該方法，則為null 
public void setJdbc2Service(IJdbc2Service jdbc2Service) { 
this.jdbc2Service = jdbc2Service; 
} 

public void setJdbc1Service(IJdbc1Service jdbc1Service) { 
this.jdbc1Service = jdbc1Service; 
} 

} 

在Spring配置文件中按照以下方式聲明這個工作： 
<!-- 定時啟動任務 Quartz--> 
<!—聲明工作--> 
<bean id="dayDataJob" class="org.springframework.scheduling.quartz.JobDetailBean"> 
<property name="jobClass"> 
<value>xj.action.DayDataQuartzTask</value> 
</property> 
<property name="jobDataAsMap"> 
<map> 
<entry key="jdbc1Service"> 
<ref bean="jdbc1Service"/> 
</entry> 
<entry key="jdbc2Service"> 
<ref bean="jdbc2Service"/> 
</entry> 
</map> 
</property> 
</bean> 
Quartz的org.quartz.Trigger類描述了何時及以怎樣的頻度運行一個Quartz工作。Spring提供了兩個觸發器 SimpleTriggerBean和CronTriggerBean。SimpleTriggerBean與scheduledTimerTasks類 似。指定工作的執行頻度，模仿scheduledTimerTasks配置。 
<!-- 調度Simple工作 --> 
<bean id="simpleDayDataJobTrigger" class="org.springframework.scheduling.quartz.SimpleTriggerBean"> 
<property name="jobDetail"> 
<ref bean="dayDataJob"/> 
</property> 
<property name="startDelay"> 
<value>1000</value> 
</property> 
<property name="repeatInterval"> 
<value>86400000</value> 
</property> 
</bean> 
<!—調度cron工作--> 
<bean id="dayDataJobTrigger" class="org.springframework.scheduling.quartz.CronTriggerBean"> 
<property name="jobDetail"> 
<ref bean="dayDataJob"/> 
</property> 
<property name="cronExpression"> 
<value>0 30 2 * * ?</value> 
</property> 
</bean> 
一個cron表達式有6個或7個由空格分隔的時間元素。從左至右，這些元素的定義如下：1、秒（0-59）；2、分（0-59）；3、小時 （0-23）；4、月份中的日期（1-31）；5、月份（1-12或JAN-DEC）；6、星期中的日期（1-7或SUN-SAT）；7、年份 （1970-2099）。 
每一個元素都可以顯式地規定一個值（如6），一個區間（如9-12），一個列表（如9,11,13）或一個通配符（如*）。“月份中的日期”和“星期中的日期”這兩個元素互斥，應該通過設置一個問號（？）來表明你不想設置的那個字段。

corn表達式API具體見 

我們在此定義該任務在每天凌晨兩點半開始啟動。 
<!—啟動工作--> 
<bean class="org.springframework.scheduling.quartz.SchedulerFactoryBean"> 
<property name="triggers"> 
<list> 
<ref bean="simpleDayDataJobTrigger"/> 
<ref bean="dayDataJobTrigger"/> 
</list> 
</property> 
</bean> 
屬性triggers接受一組觸發器，在此只裝配包含simpleDayDataJobTrigger bea和dayDataJobTrigger bean的一個引用列表。

mport java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.nio.MappedByteBuffer;
import java.nio.channels.FileChannel;

public class MbbDemo {
 
 public static  void main(String []args)throws Exception
 {
  File file=new File("d://a.txt");
  FileInputStream fis=new FileInputStream(file);
     FileOutputStream fos=new FileOutputStream("d://acopy.txt");
     FileChannel fChannel=fis.getChannel();
     FileChannel out=fos.getChannel();
     MappedByteBuffer mbb=fChannel.map(FileChannel.MapMode.READ_ONLY, 0,file.length());
     out.write(mbb);
     if(fis!=null)fis.close();
     if(fos!=null)fos.close();
  
  
 }

}

轉載自 http://www.ibm.com/developerworks/cn/java/joy-down/

斷點續傳的原理

其實斷點續傳的原理很簡單，就是在 Http 的請求上和一般的下載有所不同而已。
打個比方，瀏覽器請求服務器上的一個文時，所發出的請求如下：
假設服務器域名為 wwww.sjtu.edu.cn，文件名為 down.zip。
GET /down.zip HTTP/1.1
Accept: image/gif, image/x-xbitmap, image/jpeg, image/pjpeg, application/vnd.ms-
excel, application/msword, application/vnd.ms-powerpoint, */*
Accept-Language: zh-cn
Accept-Encoding: gzip, deflate
User-Agent: Mozilla/4.0 (compatible; MSIE 5.01; Windows NT 5.0)
Connection: Keep-Alive

服務器收到請求后，按要求尋找請求的文件，提取文件的信息，然后返回給瀏覽器，返回信息如下：

200
Content-Length=106786028
Accept-Ranges=bytes
Date=Mon, 30 Apr 2001 12:56:11 GMT
ETag=W/"02ca57e173c11:95b"
Content-Type=application/octet-stream
Server=Microsoft-IIS/5.0
Last-Modified=Mon, 30 Apr 2001 12:56:11 GMT

所謂斷點續傳，也就是要從文件已經下載的地方開始繼續下載。所以在客戶端瀏覽器傳給 Web 服務器的時候要多加一條信息 -- 從哪里開始。
下面是用自己編的一個"瀏覽器"來傳遞請求信息給 Web 服務器，要求從 2000070 字節開始。
GET /down.zip HTTP/1.0
User-Agent: NetFox
RANGE: bytes=2000070-
Accept: text/html, image/gif, image/jpeg, *; q=.2, */*; q=.2

仔細看一下就會發現多了一行 RANGE: bytes=2000070-
這一行的意思就是告訴服務器 down.zip 這個文件從 2000070 字節開始傳，前面的字節不用傳了。
服務器收到這個請求以后，返回的信息如下：
206
Content-Length=106786028
Content-Range=bytes 2000070-106786027/106786028
Date=Mon, 30 Apr 2001 12:55:20 GMT
ETag=W/"02ca57e173c11:95b"
Content-Type=application/octet-stream
Server=Microsoft-IIS/5.0
Last-Modified=Mon, 30 Apr 2001 12:55:20 GMT

和前面服務器返回的信息比較一下，就會發現增加了一行：
Content-Range=bytes 2000070-106786027/106786028
返回的代碼也改為 206 了，而不再是 200 了。

知道了以上原理，就可以進行斷點續傳的編程了。

回頁首

Java 實現斷點續傳的關鍵幾點

1. (1) 用什么方法實現提交 RANGE: bytes=2000070-。
   當然用最原始的 Socket 是肯定能完成的，不過那樣太費事了，其實 Java 的 net 包中提供了這種功能。代碼如下：
   
   URL url = new URL("http://www.sjtu.edu.cn/down.zip");
   HttpURLConnection httpConnection = (HttpURLConnection)url.openConnection();
   
   // 設置 User-Agent
   httpConnection.setRequestProperty("User-Agent","NetFox");
   // 設置斷點續傳的開始位置
   httpConnection.setRequestProperty("RANGE","bytes=2000070");
   // 獲得輸入流
   InputStream input = httpConnection.getInputStream();
   

   從輸入流中取出的字節流就是 down.zip 文件從 2000070 開始的字節流。大家看，其實斷點續傳用 Java 實現起來還是很簡單的吧。接下來要做的事就是怎么保存獲得的流到文件中去了。

2. 保存文件采用的方法。
   我采用的是 IO 包中的 RandAccessFile 類。
   操作相當簡單，假設從 2000070 處開始保存文件，代碼如下：
   RandomAccess oSavedFile = new RandomAccessFile("down.zip","rw");
   long nPos = 2000070;
   // 定位文件指針到 nPos 位置
   oSavedFile.seek(nPos);
   byte[] b = new byte[1024];
   int nRead;
   // 從輸入流中讀入字節流，然后寫到文件中
   while((nRead=input.read(b,0,1024)) > 0)
   {
   oSavedFile.write(b,0,nRead);
   }
   

怎么樣，也很簡單吧。接下來要做的就是整合成一個完整的程序了。包括一系列的線程控制等等。

斷點續傳內核的實現

主要用了 6 個類，包括一個測試類。
SiteFileFetch.java 負責整個文件的抓取，控制內部線程 (FileSplitterFetch 類 )。
FileSplitterFetch.java 負責部分文件的抓取。
FileAccess.java 負責文件的存儲。
SiteInfoBean.java 要抓取的文件的信息，如文件保存的目錄，名字，抓取文件的 URL 等。
Utility.java 工具類，放一些簡單的方法。
TestMethod.java 測試類。

下面是源程序：

/* 
 /*
 * SiteFileFetch.java 
 */ 
 package NetFox; 
 import java.io.*; 
 import java.net.*; 
 public class SiteFileFetch extends Thread { 
 SiteInfoBean siteInfoBean = null; // 文件信息 Bean 
 long[] nStartPos; // 開始位置
 long[] nEndPos; // 結束位置
 FileSplitterFetch[] fileSplitterFetch; // 子線程對象
 long nFileLength; // 文件長度
 boolean bFirst = true; // 是否第一次取文件
 boolean bStop = false; // 停止標志
 File tmpFile; // 文件下載的臨時信息
 DataOutputStream output; // 輸出到文件的輸出流
 public SiteFileFetch(SiteInfoBean bean) throws IOException 
 { 
 siteInfoBean = bean; 
 //tmpFile = File.createTempFile ("zhong","1111",new File(bean.getSFilePath())); 
 tmpFile = new File(bean.getSFilePath()+File.separator + bean.getSFileName()+".info");
 if(tmpFile.exists ()) 
 { 
 bFirst = false; 
 read_nPos(); 
 } 
 else 
 { 
 nStartPos = new long[bean.getNSplitter()]; 
 nEndPos = new long[bean.getNSplitter()]; 
 } 
 } 
 public void run() 
 { 
 // 獲得文件長度
 // 分割文件
 // 實例 FileSplitterFetch 
 // 啟動 FileSplitterFetch 線程
 // 等待子線程返回
 try{ 
 if(bFirst) 
 { 
 nFileLength = getFileSize(); 
 if(nFileLength == -1) 
 { 
 System.err.println("File Length is not known!"); 
 } 
 else if(nFileLength == -2) 
 { 
 System.err.println("File is not access!"); 
 } 
 else 
 { 
 for(int i=0;i<nStartPos.length;i++) 
 { 
 nStartPos[i] = (long)(i*(nFileLength/nStartPos.length)); 
 } 
 for(int i=0;i<nEndPos.length-1;i++) 
 { 
 nEndPos[i] = nStartPos[i+1]; 
 } 
 nEndPos[nEndPos.length-1] = nFileLength; 
 } 
 } 
 // 啟動子線程
 fileSplitterFetch = new FileSplitterFetch[nStartPos.length]; 
 for(int i=0;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-1] = new FileSplitterFetch(siteInfoBean.getSSiteURL(),
 siteInfoBean.getSFilePath() + File.separator 
 + siteInfoBean.getSFileName(),nPos[nPos.length-1],nFileLength,nPos.length-1); 
 // Utility.log("Thread " +(nPos.length-1) + ",nStartPos = "+nPos[nPos.length-1]+",
 nEndPos = " + nFileLength); 
 // fileSplitterFetch[nPos.length-1].start(); 
 // 等待子線程結束
 //int count = 0; 
 // 是否結束 while 循環
 boolean breakWhile = false; 
 while(!bStop) 
 { 
 write_nPos(); 
 Utility.sleep(500); 
 breakWhile = true; 
 for(int i=0;i<nStartPos.length;i++) 
 { 
 if(!fileSplitterFetch[i].bDownOver) 
 { 
 breakWhile = false; 
 break; 
 } 
 } 
 if(breakWhile) 
 break; 
 //count++; 
 //if(count>4) 
 // siteStop(); 
 } 
 System.err.println("文件下載結束！"); 
 } 
 catch(Exception e){e.printStackTrace ();} 
 } 
 // 獲得文件長度
 public long getFileSize() 
 { 
 int nFileLength = -1; 
 try{ 
 URL url = new URL(siteInfoBean.getSSiteURL()); 
 HttpURLConnection httpConnection = (HttpURLConnection)url.openConnection ();
 httpConnection.setRequestProperty("User-Agent","NetFox"); 
 int responseCode=httpConnection.getResponseCode(); 
 if(responseCode>=400) 
 { 
 processErrorCode(responseCode); 
 return -2; //-2 represent access is error 
 } 
 String sHeader; 
 for(int i=1;;i++) 
 { 
 //DataInputStream in = new DataInputStream(httpConnection.getInputStream ()); 
 //Utility.log(in.readLine()); 
 sHeader=httpConnection.getHeaderFieldKey(i); 
 if(sHeader!=null) 
 { 
 if(sHeader.equals("Content-Length")) 
 { 
 nFileLength = Integer.parseInt(httpConnection.getHeaderField(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=0;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=0;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=0;i<nStartPos.length;i++) 
 fileSplitterFetch[i].splitterStop(); 
 } 
 } 
 

 /* 
 **FileSplitterFetch.java 
 */ 
 package NetFox; 
 import java.io.*; 
 import java.net.*; 
 public class FileSplitterFetch extends Thread { 
 String sURL; //File URL 
 long nStartPos; //File Snippet Start Position 
 long nEndPos; //File Snippet End Position 
 int nThreadID; //Thread's ID 
 boolean bDownOver = false; //Downing is over 
 boolean bStop = false; //Stop identical 
 FileAccessI fileAccessI = null; //File Access interface 
 public FileSplitterFetch(String sURL,String sName,long nStart,long nEnd,int id)
 throws IOException 
 { 
 this.sURL = sURL; 
 this.nStartPos = nStart; 
 this.nEndPos = nEnd; 
 nThreadID = id; 
 fileAccessI = new FileAccessI(sName,nStartPos); 
 } 
 public void run() 
 { 
 while(nStartPos < nEndPos && !bStop) 
 { 
 try{ 
 URL url = new URL(sURL); 
 HttpURLConnection httpConnection = (HttpURLConnection)url.openConnection (); 
 httpConnection.setRequestProperty("User-Agent","NetFox"); 
 String sProperty = "bytes="+nStartPos+"-"; 
 httpConnection.setRequestProperty("RANGE",sProperty); 
 Utility.log(sProperty); 
 InputStream input = httpConnection.getInputStream(); 
 //logResponseHead(httpConnection); 
 byte[] b = new byte[1024]; 
 int nRead; 
 while((nRead=input.read(b,0,1024)) > 0 && nStartPos < nEndPos 
 && !bStop) 
 { 
 nStartPos += fileAccessI.write(b,0,nRead); 
 //if(nThreadID == 1) 
 // Utility.log("nStartPos = " + nStartPos + ", nEndPos = " + nEndPos); 
 } 
 Utility.log("Thread " + nThreadID + " is over!"); 
 bDownOver = true; 
 //nPos = fileAccessI.write (b,0,nRead); 
 } 
 catch(Exception e){e.printStackTrace ();} 
 } 
 } 
 // 打印回應的頭信息
 public void logResponseHead(HttpURLConnection con) 
 { 
 for(int i=1;;i++) 
 { 
 String header=con.getHeaderFieldKey(i); 
 if(header!=null) 
 //responseHeaders.put(header,httpConnection.getHeaderField(header)); 
 Utility.log(header+" : "+con.getHeaderField(header)); 
 else 
 break; 
 } 
 } 
 public void splitterStop() 
 { 
 bStop = true; 
 } 
 } 
 
 /* 
 **FileAccess.java 
 */ 
 package NetFox; 
 import java.io.*; 
 public class FileAccessI implements Serializable{ 
 RandomAccessFile oSavedFile; 
 long nPos; 
 public FileAccessI() throws IOException 
 { 
 this("",0); 
 } 
 public FileAccessI(String sName,long nPos) throws IOException 
 { 
 oSavedFile = new RandomAccessFile(sName,"rw"); 
 this.nPos = nPos; 
 oSavedFile.seek(nPos); 
 } 
 public synchronized int write(byte[] b,int nStart,int nLen) 
 { 
 int n = -1; 
 try{ 
 oSavedFile.write(b,nStart,nLen); 
 n = nLen; 
 } 
 catch(IOException e) 
 { 
 e.printStackTrace (); 
 } 
 return n; 
 } 
 } 
 
 /* 
 **SiteInfoBean.java 
 */ 
 package NetFox; 
 public class SiteInfoBean { 
 private String sSiteURL; //Site's URL 
 private String sFilePath; //Saved File's Path 
 private String sFileName; //Saved File's Name 
 private int nSplitter; //Count of Splited Downloading File 
 public SiteInfoBean() 
 { 
 //default value of nSplitter is 5 
 this("","","",5); 
 } 
 public SiteInfoBean(String sURL,String sPath,String sName,int nSpiltter)
 { 
 sSiteURL= sURL; 
 sFilePath = sPath; 
 sFileName = sName; 
 this.nSplitter = nSpiltter; 
 } 
 public String getSSiteURL() 
 { 
 return sSiteURL; 
 } 
 public void setSSiteURL(String value) 
 { 
 sSiteURL = value; 
 } 
 public String getSFilePath() 
 { 
 return sFilePath; 
 } 
 public void setSFilePath(String value) 
 { 
 sFilePath = value; 
 } 
 public String getSFileName() 
 { 
 return sFileName; 
 } 
 public void setSFileName(String value) 
 { 
 sFileName = value; 
 } 
 public int getNSplitter() 
 { 
 return nSplitter; 
 } 
 public void setNSplitter(int nCount) 
 { 
 nSplitter = nCount; 
 } 
 } 
 
 /* 
 **Utility.java 
 */ 
 package NetFox; 
 public class Utility { 
 public Utility() 
 { 
 } 
 public static void sleep(int nSecond) 
 { 
 try{ 
 Thread.sleep(nSecond); 
 } 
 catch(Exception e) 
 { 
 e.printStackTrace (); 
 } 
 } 
 public static void log(String sMsg) 
 { 
 System.err.println(sMsg); 
 } 
 public static void log(int sMsg) 
 { 
 System.err.println(sMsg); 
 } 
 } 
 
 /* 
 **TestMethod.java 
 */ 
 package NetFox; 
 public class TestMethod { 
 public TestMethod() 
 { ///xx/weblogic60b2_win.exe 
 try{ 
 SiteInfoBean bean = new SiteInfoBean("http://localhost/xx/weblogic60b2_win.exe",
     "L:\\temp","weblogic60b2_win.exe",5); 
 //SiteInfoBean bean = new SiteInfoBean("http://localhost:8080/down.zip","L:\\temp",
     "weblogic60b2_win.exe",5); 
 SiteFileFetch fileFetch = new SiteFileFetch(bean); 
 fileFetch.start(); 
 } 
 catch(Exception e){e.printStackTrace ();} 
 } 
 public static void main(String[] args) 
 { 
 new TestMethod(); 
 } 
 }

Ajax+Flash多文件上傳是一個開源的上傳組件，名稱是FancyUpload，其官方網址是：http://digitarald.de/project/fancyupload/。這個組件僅僅是客戶端的應用組件，即與任何服務器端的技術沒有關系，服務器端可以采用任何后臺技術（如JSP、Servlet、ASP等）。應用該組件提供 給我們的最大的好處有如下幾點（個人認為，呵呵）：