chenweicai

Historical Collection Classes（JDK1.1 之前）
提供的容器有Arrays,Vector,Stack,Hashtable,Properties,BitSet。其中定義出一種走訪群集內(nèi)各元素的標(biāo)準(zhǔn)方式，稱為Enumeration（列舉器）接口，用法如下：
而在JDK1.2版本中引入了Iterator接口，新版本的集合對象（HashSet,HashMap,WeakHeahMap,ArrayList,TreeSet,TreeMap, LinkedList）是通過Iterator接口訪問集合元素的。
例如：

這樣，如果將老版本的程序運(yùn)行在新的Java編譯器上就會出錯(cuò)。因?yàn)長ist接口中已經(jīng)沒有elements()，而只有iterator()了。那么如何可以使老版本的程序運(yùn)行在新的Java編譯器上呢?如果不加修改，是肯定不行的，但是修改要遵循“開－閉”原則。
這時(shí)候我想到了Java設(shè)計(jì)模式中的適配器模式。

NewEnumeration是一個(gè)適配器類，通過它實(shí)現(xiàn)了從Iterator接口到Enumeration接口的適配，這樣我們就可以使用老版本的代碼來使用新的集合對象了。

一、反射的概念 ：
反射的概念是由Smith在1982年首次提出的，主要是指程序可以訪問、檢測和修改它本身狀態(tài)或行為的一種能力。這一概念的提出很快引發(fā)了計(jì)算機(jī)科學(xué)領(lǐng)域關(guān)于應(yīng)用反射性的研究。它首先被程序語言的設(shè)計(jì)領(lǐng)域所采用,并在Lisp和面向?qū)ο蠓矫嫒〉昧顺煽儭Ｆ渲蠰EAD/LEAD++ 、OpenC++ 、MetaXa和OpenJava等就是基于反射機(jī)制的語言。最近，反射機(jī)制也被應(yīng)用到了視窗系統(tǒng)、操作系統(tǒng)和文件系統(tǒng)中。

反射本身并不是一個(gè)新概念，它可能會使我們聯(lián)想到光學(xué)中的反射概念，盡管計(jì)算機(jī)科學(xué)賦予了反射概念新的含義，但是，從現(xiàn)象上來說，它們確實(shí)有某些相通之處，這些有助于我們的理解。在計(jì)算機(jī)科學(xué)領(lǐng)域，反射是指一類應(yīng)用，它們能夠自描述和自控制。也就是說，這類應(yīng)用通過采用某種機(jī)制來實(shí)現(xiàn)對自己行為的描述（self-representation）和監(jiān)測（examination），并能根據(jù)自身行為的狀態(tài)和結(jié)果，調(diào)整或修改應(yīng)用所描述行為的狀態(tài)和相關(guān)的語義。可以看出，同一般的反射概念相比，計(jì)算機(jī)科學(xué)領(lǐng)域的反射不單單指反射本身，還包括對反射結(jié)果所采取的措施。所有采用反射機(jī)制的系統(tǒng)（即反射系統(tǒng)）都希望使系統(tǒng)的實(shí)現(xiàn)更開放。可以說，實(shí)現(xiàn)了反射機(jī)制的系統(tǒng)都具有開放性，但具有開放性的系統(tǒng)并不一定采用了反射機(jī)制，開放性是反射系統(tǒng)的必要條件。一般來說，反射系統(tǒng)除了滿足開放性條件外還必須滿足原因連接（Causally-connected）。所謂原因連接是指對反射系統(tǒng)自描述的改變能夠立即反映到系統(tǒng)底層的實(shí)際狀態(tài)和行為上的情況，反之亦然。開放性和原因連接是反射系統(tǒng)的兩大基本要素.

Java中，反射是一種強(qiáng)大的工具。它使您能夠創(chuàng)建靈活的代碼，這些代碼可以在運(yùn)行時(shí)裝配，無需在組件之間進(jìn)行源代表鏈接。反射允許我們在編寫與執(zhí)行時(shí)，使我們的程序代碼能夠接入裝載到JVM中的類的內(nèi)部信息，而不是源代碼中選定的類協(xié)作的代碼。這使反射成為構(gòu)建靈活的應(yīng)用的主要工具。但需注意的是：如果使用不當(dāng)，反射的成本很高。

二、Java中的類反射：
Reflection 是 Java 程序開發(fā)語言的特征之一，它允許運(yùn)行中的 Java 程序?qū)ψ陨磉M(jìn)行檢查，或者說“自審”，并能直接操作程序的內(nèi)部屬性。Java 的這一能力在實(shí)際應(yīng)用中也許用得不是很多，但是在其它的程序設(shè)計(jì)語言中根本就不存在這一特性。例如，Pascal、C 或者 C++ 中就沒有辦法在程序中獲得函數(shù)定義相關(guān)的信息。

1．檢測類：

1.1 reflection的工作機(jī)制

考慮下面這個(gè)簡單的例子，讓我們看看 reflection 是如何工作的。

import java.lang.reflect.*;
public class DumpMethods {
    public static void main(String args[]) {
        try {
            Class c = Class.forName(args[0]);
            Method m[] = c.getDeclaredMethods();
            for (int i = 0; i < m.length; i++)
                System.out.println(m[i].toString());
        } catch (Throwable e) {
            System.err.println(e);
        }
    }
}

按如下語句執(zhí)行：

java DumpMethods java.util.Stack

它的結(jié)果輸出為：

public java.lang.Object java.util.Stack.push(java.lang.Object)

public synchronized java.lang.Object java.util.Stack.pop()

public synchronized java.lang.Object java.util.Stack.peek()

public boolean java.util.Stack.empty()

public synchronized int java.util.Stack.search(java.lang.Object)

這樣就列出了java.util.Stack 類的各方法名以及它們的限制符和返回類型。

這個(gè)程序使用 Class.forName 載入指定的類，然后調(diào)用 getDeclaredMethods 來獲取這個(gè)類中定義了的方法列表。java.lang.reflect.Methods 是用來描述某個(gè)類中單個(gè)方法的一個(gè)類。

1.2 Java類反射中的主要方法

對于以下三類組件中的任何一類來說 -- 構(gòu)造函數(shù)、字段和方法 -- java.lang.Class 提供四種獨(dú)立的反射調(diào)用，以不同的方式來獲得信息。調(diào)用都遵循一種標(biāo)準(zhǔn)格式。以下是用于查找構(gòu)造函數(shù)的一組反射調(diào)用：

       Constructor getConstructor(Class[] params) -- 獲得使用特殊的參數(shù)類型的公共構(gòu)造函數(shù)，

       Constructor[] getConstructors() -- 獲得類的所有公共構(gòu)造函數(shù)

       Constructor getDeclaredConstructor(Class[] params) -- 獲得使用特定參數(shù)類型的構(gòu)造函數(shù)(與接入級別無關(guān))

       Constructor[] getDeclaredConstructors() -- 獲得類的所有構(gòu)造函數(shù)(與接入級別無關(guān))

獲得字段信息的Class 反射調(diào)用不同于那些用于接入構(gòu)造函數(shù)的調(diào)用，在參數(shù)類型數(shù)組中使用了字段名：

l         Field getField(String name) -- 獲得命名的公共字段

l         Field[] getFields() -- 獲得類的所有公共字段

l         Field getDeclaredField(String name) -- 獲得類聲明的命名的字段

l         Field[] getDeclaredFields() -- 獲得類聲明的所有字段

用于獲得方法信息函數(shù)：

l         Method getMethod(String name, Class[] params) -- 使用特定的參數(shù)類型，獲得命名的公共方法

l         Method[] getMethods() -- 獲得類的所有公共方法

l         Method getDeclaredMethod(String name, Class[] params) -- 使用特寫的參數(shù)類型，獲得類聲明的命名的方法

l         Method[] getDeclaredMethods() -- 獲得類聲明的所有方法

 

1.3開始使用 Reflection：

用于 reflection 的類，如 Method，可以在 java.lang.relfect 包中找到。使用這些類的時(shí)候必須要遵循三個(gè)步驟：第一步是獲得你想操作的類的 java.lang.Class 對象。在運(yùn)行中的 Java 程序中，用 java.lang.Class 類來描述類和接口等。

下面就是獲得一個(gè) Class 對象的方法之一：

Class c = Class.forName("java.lang.String");

這條語句得到一個(gè) String 類的類對象。還有另一種方法，如下面的語句：

Class c = int.class;

或者

Class c = Integer.TYPE;

它們可獲得基本類型的類信息。其中后一種方法中訪問的是基本類型的封裝類 (如 Integer) 中預(yù)先定義好的 TYPE 字段。

第二步是調(diào)用諸如 getDeclaredMethods 的方法，以取得該類中定義的所有方法的列表。

一旦取得這個(gè)信息，就可以進(jìn)行第三步了——使用 reflection API 來操作這些信息，如下面這段代碼：

Class c = Class.forName("java.lang.String");

Method m[] = c.getDeclaredMethods();

System.out.println(m[0].toString());

它將以文本方式打印出 String 中定義的第一個(gè)方法的原型。

2．處理對象：

如果要作一個(gè)開發(fā)工具像debugger之類的，你必須能發(fā)現(xiàn)filed values,以下是三個(gè)步驟:

a.創(chuàng)建一個(gè)Class對象
b.通過getField 創(chuàng)建一個(gè)Field對象
c.調(diào)用Field.getXXX(Object)方法(XXX是Int,Float等，如果是對象就省略；Object是指實(shí)例).

例如：
import java.lang.reflect.*;
import java.awt.*;

class SampleGet {

   public static void main(String[] args) {
      Rectangle r = new Rectangle(100, 325);
      printHeight(r);

   }

   static void printHeight(Rectangle r) {
      Field heightField;
      Integer heightValue;
      Class c = r.getClass();
      try {
        heightField = c.getField("height");
        heightValue = (Integer) heightField.get(r);
        System.out.println("Height: " + heightValue.toString());
      } catch (NoSuchFieldException e) {
          System.out.println(e);
      } catch (SecurityException e) {
          System.out.println(e);
      } catch (IllegalAcces***ception e) {
          System.out.println(e);
      }
   }
}

三、安全性和反射：
在處理反射時(shí)安全性是一個(gè)較復(fù)雜的問題。反射經(jīng)常由框架型代碼使用，由于這一點(diǎn)，我們可能希望框架能夠全面接入代碼，無需考慮常規(guī)的接入限制。但是，在其它情況下，不受控制的接入會帶來嚴(yán)重的安全性風(fēng)險(xiǎn)，例如當(dāng)代碼在不值得信任的代碼共享的環(huán)境中運(yùn)行時(shí)。

由于這些互相矛盾的需求，Java編程語言定義一種多級別方法來處理反射的安全性。基本模式是對反射實(shí)施與應(yīng)用于源代碼接入相同的限制：

n         從任意位置到類公共組件的接入

n         類自身外部無任何到私有組件的接入

n         受保護(hù)和打包（缺省接入）組件的有限接入

不過至少有些時(shí)候，圍繞這些限制還有一種簡單的方法。我們可以在我們所寫的類中，擴(kuò)展一個(gè)普通的基本類java.lang.reflect.AccessibleObject 類。這個(gè)類定義了一種setAccessible方法，使我們能夠啟動或關(guān)閉對這些類中其中一個(gè)類的實(shí)例的接入檢測。唯一的問題在于如果使用了安全性管理器，它將檢測正在關(guān)閉接入檢測的代碼是否許可了這樣做。如果未許可，安全性管理器拋出一個(gè)例外。

下面是一段程序，在TwoString 類的一個(gè)實(shí)例上使用反射來顯示安全性正在運(yùn)行：

public class ReflectSecurity {

    public static void main(String[] args) {

        try {

            TwoString ts = new TwoString("a", "b");

            Field field = clas.getDeclaredField("m_s1");

//          field.setAccessible(true);

            System.out.println("Retrieved value is " +

                field.get(inst));

        } catch (Exception ex) {

            ex.printStackTrace(System.out);

        }

    }

}

如果我們編譯這一程序時(shí)，不使用任何特定參數(shù)直接從命令行運(yùn)行，它將在field .get(inst)調(diào)用中拋出一個(gè)IllegalAcces***ception異常。如果我們不注釋field.setAccessible(true)代碼行，那么重新編譯并重新運(yùn)行該代碼，它將編譯成功。最后，如果我們在命令行添加了JVM參數(shù)-Djava.security.manager以實(shí)現(xiàn)安全性管理器，它仍然將不能通過編譯，除非我們定義了ReflectSecurity類的許可權(quán)限。

四、反射性能：
反射是一種強(qiáng)大的工具，但也存在一些不足。一個(gè)主要的缺點(diǎn)是對性能有影響。使用反射基本上是一種解釋操作，我們可以告訴JVM，我們希望做什么并且它滿足我們的要求。這類操作總是慢于只直接執(zhí)行相同的操作。

下面的程序是字段接入性能測試的一個(gè)例子，包括基本的測試方法。每種方法測試字段接入的一種形式 -- accessSame 與同一對象的成員字段協(xié)作，accessOther 使用可直接接入的另一對象的字段，accessReflection 使用可通過反射接入的另一對象的字段。在每種情況下，方法執(zhí)行相同的計(jì)算 -- 循環(huán)中簡單的加/乘順序。

程序如下：

public int accessSame(int loops) {

    m_value = 0;

    for (int index = 0; index < loops; index++) {

        m_value = (m_value + ADDITIVE_VALUE) *

            MULTIPLIER_VALUE;

    }

    return m_value;

}

 

public int accessReference(int loops) {

    TimingClass timing = new TimingClass();

    for (int index = 0; index < loops; index++) {

        timing.m_value = (timing.m_value + ADDITIVE_VALUE) *

            MULTIPLIER_VALUE;

    }

    return timing.m_value;

}

 

public int accessReflection(int loops) throw* **ception {

    TimingClass timing = new TimingClass();

    try {

        Field field = TimingClass.class.

            getDeclaredField("m_value");

        for (int index = 0; index < loops; index++) {

            int value = (field.getInt(timing) +

                ADDITIVE_VALUE) * MULTIPLIER_VALUE;

            field.setInt(timing, value);

        }

        return timing.m_value;

    } catch (Exception ex) {

        System.out.println("Error using reflection");

        throw ex;

    }

}

在上面的例子中，測試程序重復(fù)調(diào)用每種方法，使用一個(gè)大循環(huán)數(shù)，從而平均多次調(diào)用的時(shí)間衡量結(jié)果。平均值中不包括每種方法第一次調(diào)用的時(shí)間，因此初始化時(shí)間不是結(jié)果中的一個(gè)因素。下面的圖清楚的向我們展示了每種方法字段接入的時(shí)間：

圖 1：字段接入時(shí)間 ：


我們可以看出：在前兩副圖中(Sun JVM)，使用反射的執(zhí)行時(shí)間超過使用直接接入的1000倍以上。通過比較，IBM JVM可能稍好一些，但反射方法仍舊需要比其它方法長700倍以上的時(shí)間。任何JVM上其它兩種方法之間時(shí)間方面無任何顯著差異，但I(xiàn)BM JVM幾乎比Sun JVM快一倍。最有可能的是這種差異反映了Sun Hot Spot JVM的專業(yè)優(yōu)化，它在簡單基準(zhǔn)方面表現(xiàn)得很糟糕。反射性能是Sun開發(fā)1.4 JVM時(shí)關(guān)注的一個(gè)方面，它在反射方法調(diào)用結(jié)果中顯示。在這類操作的性能方面，Sun 1.4.1 JVM顯示了比1.3.1版本很大的改進(jìn)。

如果為為創(chuàng)建使用反射的對象編寫了類似的計(jì)時(shí)測試程序，我們會發(fā)現(xiàn)這種情況下的差異不象字段和方法調(diào)用情況下那么顯著。使用newInstance()調(diào)用創(chuàng)建一個(gè)簡單的java.lang.Object實(shí)例耗用的時(shí)間大約是在Sun 1.3.1 JVM上使用new Object()的12倍，是在IBM 1.4.0 JVM的四倍，只是Sun 1.4.1 JVM上的兩部。使用Array.newInstance(type, size)創(chuàng)建一個(gè)數(shù)組耗用的時(shí)間是任何測試的JVM上使用new type[size]的兩倍，隨著數(shù)組大小的增加，差異逐步縮小。

結(jié)束語：
Java語言反射提供一種動態(tài)鏈接程序組件的多功能方法。它允許程序創(chuàng)建和控制任何類的對象(根據(jù)安全性限制)，無需提前硬編碼目標(biāo)類。這些特性使得反射特別適用于創(chuàng)建以非常普通的方式與對象協(xié)作的庫。例如，反射經(jīng)常在持續(xù)存儲對象為數(shù)據(jù)庫、XML或其它外部格式的框架中使用。Java reflection 非常有用，它使類和數(shù)據(jù)結(jié)構(gòu)能按名稱動態(tài)檢索相關(guān)信息，并允許在運(yùn)行著的程序中操作這些信息。Java 的這一特性非常強(qiáng)大，并且是其它一些常用語言，如 C、C++、Fortran 或者 Pascal 等都不具備的。

但反射有兩個(gè)缺點(diǎn)。第一個(gè)是性能問題。用于字段和方法接入時(shí)反射要遠(yuǎn)慢于直接代碼。性能問題的程度取決于程序中是如何使用反射的。如果它作為程序運(yùn)行中相對很少涉及的部分，緩慢的性能將不會是一個(gè)問題。即使測試中最壞情況下的計(jì)時(shí)圖顯示的反射操作只耗用幾微秒。僅反射在性能關(guān)鍵的應(yīng)用的核心邏輯中使用時(shí)性能問題才變得至關(guān)重要。

許多應(yīng)用中更嚴(yán)重的一個(gè)缺點(diǎn)是使用反射會模糊程序內(nèi)部實(shí)際要發(fā)生的事情。程序人員希望在源代碼中看到程序的邏輯，反射等繞過了源代碼的技術(shù)會帶來維護(hù)問題。反射代碼比相應(yīng)的直接代碼更復(fù)雜，正如性能比較的代碼實(shí)例中看到的一樣。解決這些問題的最佳方案是保守地使用反射——僅在它可以真正增加靈活性的地方——記錄其在目標(biāo)類中的使用。

public class ServerSocket
extends Object

此類實(shí)現(xiàn)服務(wù)器套接字。服務(wù)器套接字等待請求通過網(wǎng)絡(luò)傳入。它基于該請求執(zhí)行某些操作，然后可能向請求者返回結(jié)果。

服務(wù)器套接字的實(shí)際工作由 SocketImpl 類的實(shí)例執(zhí)行。應(yīng)用程序可以更改創(chuàng)建套接字實(shí)現(xiàn)的套接字工廠來配置它自身，從而創(chuàng)建適合本地防火墻的套接字。

public class Socket
extends Object

此類實(shí)現(xiàn)客戶端套接字（也可以就叫“套接字”）。套接字是兩臺機(jī)器之間的通信端點(diǎn)。

套接字的實(shí)際工作由 SocketImpl 類的實(shí)例執(zhí)行。應(yīng)用程序通過更改創(chuàng)建套接字實(shí)現(xiàn)的套接字工廠可以配置它自身，以創(chuàng)建適合本地防火墻的套接字。

/**
 * 為了驗(yàn)證我們的服務(wù)器程序能否正常工作，還必須有一個(gè)客戶端程序與之通信。
 * 我們也沒必要每次都要編寫客戶端程序來測試。其實(shí)， Windows提供的telnet
 * 程序，就是一個(gè)TCP客戶端程序，我們只要使用telnet程序?qū)ξ覀兊姆?wù)器程序
 * 進(jìn)行測試，我們只要在運(yùn)行telnet程序時(shí)指定所要連接的服務(wù)器程序的IP地址
 * 和端口號，telnet程序就會按照指定的參數(shù)去與服務(wù)器程序進(jìn)行連接。建立連接
 * 后，在telnet程序窗口中鍵入的內(nèi)容會發(fā)送到服務(wù)器，從服務(wù)器端接收到的數(shù)據(jù)
 * 會顯示在窗口中。
 * 先運(yùn)行TcpServer程序，然后在命令行中輸入 telnet 10.214.16.80 8001
 * 就會執(zhí)行
 */

// TCP 服務(wù)端程序
public class TcpServer {

 public static void main(String[] args){
  
  try{
   //建立一個(gè)在8001端口上等待連接的ServerSocket對象
   ServerSocket ss = new ServerSocket(8001);
   
   //偵聽并接受到此套接字的連接。此方法在進(jìn)行連接之前一直阻塞,返回客戶端套接字
   Socket s = ss.accept();
   
   InputStream ips = s.getInputStream();//返回此套接字的輸入流
   OutputStream ops = s.getOutputStream();//返回此套接字的輸出流
   
   //將字節(jié)從指定的字節(jié)數(shù)組寫入此輸出流
   ops.write("chenweicai...".getBytes());
   
//   byte[] buf = new byte[1024];
//   // 從輸入流中讀取一定數(shù)量的字節(jié)并將其存儲在緩沖區(qū)數(shù)組buf中
//   int len = ips.read(buf);
//   System.out.println(new String(buf, 0, len));
   
   //由于telent只要輸入就發(fā)送，而不管有沒有回車，所以只有第一個(gè)字符被發(fā)送。
   //java提供了一個(gè)BufferedReader類，可以幫助我們按行處理輸入流。
   BufferedReader br = new BufferedReader (new InputStreamReader(ips));
   System.out.println("The message comes form client: " + br.readLine());//輸出客戶端輸入的內(nèi)容
   
   br.close();//關(guān)閉包裝類，會自動關(guān)閉包裝類中所包裝的底層類，所以不用調(diào)用ips.close().
//   ips.close();
   ops.close();
   s.close();
   ss.close();
  }catch (Exception e){
   e.printStackTrace();
  }
 }
}

給個(gè)具體的例子

/**
 * 實(shí)現(xiàn)服務(wù)器和客戶端之間的對話功能
 */
public class Servicer implements Runnable {

 Socket s;
 
 public Servicer (Socket s){
  this.s = s;
 }
 
 public void run(){
  
  try {
   InputStream ips = s.getInputStream();
   OutputStream ops = s.getOutputStream();
   BufferedReader br = new BufferedReader(new InputStreamReader(ips));
   DataOutputStream dos = new DataOutputStream(ops);
   
   while(true){
    String strWord = br.readLine();
    System.out.println("From Client StrWord: " + strWord + strWord.length());
    if(strWord.equalsIgnoreCase("quit"))
     break;
    
    String strEcho = (new StringBuffer(strWord).reverse()).toString();
    dos.writeBytes(strWord + "---->" + strEcho + System.getProperty("line.separator"));
   }
   br.close();
   dos.close();
   s.close();
  } catch (IOException e) {
   e.printStackTrace();
  }
  
 }
}


import java.net.ServerSocket;
import java.net.Socket;

public class TcpServer {

 public static void main(String[] args){
  
  try{
   ServerSocket ss = new ServerSocket(8001);
   
   while(true){
    Socket s = ss.accept();
    new Thread(new Servicer(s)).start();
   }
  }catch(Exception e){
   
  }
 }
}



public class TcpClient {

 public static void main(String[] args){
  
  try{
   if(args.length < 2){
    System.out.println("Usage: java TcpClient ServerIP ServerPort");
    return;
   }
   
   Socket s = new Socket(InetAddress.getByName(args[0]), Integer.parseInt(args[1]));
   InputStream ips = s.getInputStream();
   OutputStream ops = s.getOutputStream();
   
   BufferedReader brKey = new BufferedReader(new InputStreamReader(System.in));
   DataOutputStream dos = new DataOutputStream(ops);
   BufferedReader brNet = new BufferedReader(new InputStreamReader(ips));
   
   while(true){
    String strWord = brKey.readLine();
    dos.writeBytes(strWord + System.getProperty("ling.separator"));
    if(strWord.equalsIgnoreCase("quit"))
     break;
    else
     System.out.println(brNet.readLine());
   }
   dos.close();
   brNet.close();
   brKey.close();
   s.close();
  }catch (Exception e){
   
  }
 }
}

public class DatagramSocket
extends Object

此類表示用來發(fā)送和接收數(shù)據(jù)報(bào)包的套接字。

數(shù)據(jù)報(bào)套接字是包投遞服務(wù)的發(fā)送或接收點(diǎn)。每個(gè)在數(shù)據(jù)報(bào)套接字上發(fā)送或接收的包都是單獨(dú)編址和路由的。從一臺機(jī)器發(fā)送到另一臺機(jī)器的多個(gè)包可能選擇不同的路由，也可能按不同的順序到達(dá)。

在 DatagramSocket 上總是啟用 UDP 廣播發(fā)送。為了接收廣播包，應(yīng)該將 DatagramSocket 綁定到通配符地址。在某些實(shí)現(xiàn)中，將 DatagramSocket 綁定到一個(gè)更加具體的地址時(shí)廣播包也可以被接收。

示例：DatagramSocket s = new DatagramSocket(null); s.bind(new InetSocketAddress(8888)); 這等價(jià)于：DatagramSocket s = new DatagramSocket(8888); 兩個(gè)例子都能創(chuàng)建能夠在 UDP 8888 端口上接收廣播的 DatagramSocket。

public final class DatagramPacket
extends Object

此類表示數(shù)據(jù)報(bào)包。

數(shù)據(jù)報(bào)包用來實(shí)現(xiàn)無連接包投遞服務(wù)。每條報(bào)文僅根據(jù)該包中包含的信息從一臺機(jī)器路由到另一臺機(jī)器。從一臺機(jī)器發(fā)送到另一臺機(jī)器的多個(gè)包可能選擇不同的路由，也可能按不同的順序到達(dá)。不對包投遞做出保證。

給個(gè)具體實(shí)現(xiàn)的例子

//UDP數(shù)據(jù)的發(fā)送類似發(fā)送尋呼一樣的道理。就像尋呼機(jī)必須先處于開機(jī)接收狀態(tài)才能接收尋呼一樣的道理
//我們先要運(yùn)行UDP接收程序，再運(yùn)行UDP發(fā)送程序。UDP數(shù)據(jù)包的接收是過期作廢的。
public class UdpSend {

 public static void main(String[] args) throws SocketException, UnknownHostException{
  DatagramSocket ds = new DatagramSocket();//創(chuàng)建用來發(fā)送數(shù)據(jù)報(bào)包的套接字
  String str = "Hello World，陳偉才";
  DatagramPacket dp = new DatagramPacket(str.getBytes(), str.getBytes().length,
    InetAddress.getByName("10.214.16.80"), 3000);
  //構(gòu)造數(shù)據(jù)報(bào)包，用來將長度為 length 的包發(fā)送到指定主機(jī)上的指定端口號
  
  try {
   ds.send(dp);
  } catch (IOException e) {
   e.printStackTrace();
  }
  ds.close();
 }
}

public class UdpRecv {

 public static void main(String[] args) throws Exception{
  DatagramSocket ds = new DatagramSocket(3000);//創(chuàng)建接收數(shù)據(jù)報(bào)套接字并將其綁定到本地主機(jī)上的指定端口
  byte[] buf = new byte[1024];
  DatagramPacket dp = new DatagramPacket(buf, 1024);
  ds.receive(dp);
  String strRecv = new String (dp.getData(), 0, dp.getLength()) + " from "
  + dp.getAddress().getHostAddress() + ":" + dp.getPort();
  System.out.println(strRecv);
  ds.close();
  
 }
}

再給個(gè)例子Chat

public class Chat {

 Frame f = new Frame("我的聊天室");
 
 /*
  * tfIp 是用于輸入IP地址的文本框，在發(fā)送數(shù)據(jù)時(shí)， 要取出其中的IP地址，
  * 所以將其定義成員變量，以便發(fā)送消息的程序代碼能訪問。
  */
 TextField tfIP = new TextField(15);
 
 /**
  * lst時(shí)用于顯示接收消息的列表框， 在接收到數(shù)據(jù)時(shí)，要向其中增加新的記錄項(xiàng)
  * 所以將其定義成員變量，以便發(fā)送消息的程序代碼能訪問
  */
 List lst = new List(6);
 
 DatagramSocket ds;
 
 public Chat(){
  try{
   ds = new DatagramSocket(3000);
  }catch(Exception e){
   e.printStackTrace();
  }
  
  new Thread (new Runnable(){
   
   public void run(){
    
    byte[] buf = new byte[1024];
    DatagramPacket dp = new DatagramPacket(buf, 1024);
    while (true){
     try{
      ds.receive(dp);
      lst.add(new String(buf, 0 , dp.getLength()) +
        " : form " + dp.getAddress().getHostAddress(), 0);
     }catch(Exception ee){
      ee.printStackTrace();
     }
    }
   }
  }).start();
 }
 
 public void init(){
  f.setSize(300, 300);
  f.add(lst);
  
  Panel p = new Panel();
  p.setLayout(new BorderLayout());
  p.add("West", tfIP);
  TextField tfData = new TextField (20);
  p.add("East", tfData);
  f.add("South", p);
  
  f.setVisible(true);
  f.setResizable(false);//不能改變窗口大小
  
  //增加關(guān)閉窗口的事件處理代碼
  f.addWindowListener(new WindowAdapter(){
   public void windowClosing(WindowEvent e){
    ds.close();//程序退出時(shí)，關(guān)閉Socket，釋放相關(guān)的資源
    f.setVisible(false);
    f.dispose();
    System.exit(0);
   }
  });
  
  //增加在消息文本框中按下回車鍵的事件處理代碼
  tfData.addActionListener(new ActionListener(){
   public void actionPerformed (ActionEvent e){
    //要在這里增加網(wǎng)絡(luò)消息發(fā)送相關(guān)程序代碼
    //下面的語句用于數(shù)據(jù)發(fā)送后，清空文本框中原來的內(nèi)容
    
    // 取出文本框的消息字符串，并將其轉(zhuǎn)換成字節(jié)數(shù)組
    byte[] buf;
    buf = e.getActionCommand().getBytes();
    try {
     DatagramPacket dp = new DatagramPacket(buf, buf.length,
       InetAddress.getByName(tfIP.getText()), 3000);
     try {
      ds.send(dp);
     } catch (IOException e1) {
      e1.printStackTrace();
     }
    } catch (UnknownHostException e1) {
     e1.printStackTrace();
    }
    ((TextField)e.getSource()).setText("");
   }
  });
 }
 
 public static void main(String[] args){
  Chat chat = new Chat();
  chat.init();
 }
}

課前思考
　　1. 什么是TCP/ IP協(xié)議？
　　2. TCP/IP有哪兩種傳輸協(xié)議,各有什么特點(diǎn)？
　　3. 什么是URL？
　　4. URL和IP地址有什么樣的關(guān)系？
　　5. 什么叫套接字（Socket）？
　　6. 套接字（Socket）和TCP/IP協(xié)議的關(guān)系？
　　7. URL和套接字（Socket）的關(guān)系？
8．1 網(wǎng)絡(luò)編程基本概念，TCP/IP協(xié)議簡介

8.1.1 網(wǎng)絡(luò)基礎(chǔ)知識

網(wǎng)絡(luò)編程的目的就是指直接或間接地通過網(wǎng)絡(luò)協(xié)議與其他計(jì)算機(jī)進(jìn)行通訊。網(wǎng)絡(luò)編程中有兩個(gè)主要的問題，一個(gè)是如何準(zhǔn)確的定位網(wǎng)絡(luò)上一臺或多臺主機(jī)，另一個(gè)就是找到主機(jī)后如何可靠高效的進(jìn)行數(shù)據(jù)傳輸。在TCP/IP協(xié)議中IP層主要負(fù)責(zé)網(wǎng)絡(luò)主機(jī)的定位，數(shù)據(jù)傳輸?shù)穆酚桑?/span>IP地址可以唯一地確定Internet上的一臺主機(jī)。而TCP層則提供面向應(yīng)用的可靠的或非可靠的數(shù)據(jù)傳輸機(jī)制，這是網(wǎng)絡(luò)編程的主要對象，一般不需要關(guān)心IP層是如何處理數(shù)據(jù)的。
　　目前較為流行的網(wǎng)絡(luò)編程模型是客戶機(jī)/服務(wù)器（C/S）結(jié)構(gòu)。即通信雙方一方作為服務(wù)器等待客戶提出請求并予以響應(yīng)。客戶則在需要服務(wù)時(shí)向服務(wù)器提出申請。服務(wù)器一般作為守護(hù)進(jìn)程始終運(yùn)行，監(jiān)聽網(wǎng)絡(luò)端口，一旦有客戶請求，就會啟動一個(gè)服務(wù)進(jìn)程來響應(yīng)該客戶，同時(shí)自己繼續(xù)監(jiān)聽服務(wù)端口，使后來的客戶也能及時(shí)得到服務(wù)。

8.1.3兩類傳輸協(xié)議：TCP；UDP
　　盡管TCP/IP協(xié)議的名稱中只有TCP這個(gè)協(xié)議名，但是在TCP/IP的傳輸層同時(shí)存在TCP和UDP兩個(gè)協(xié)議。

TCP是Tranfer Control Protocol的簡稱，是一種面向連接的保證可靠傳輸?shù)膮f(xié)議。通過TCP協(xié)議傳輸，得到的是一個(gè)順序的無差錯(cuò)的數(shù)據(jù)流。發(fā)送方和接收方的成對的兩個(gè)socket之間必須建立連接，以便在TCP協(xié)議的基礎(chǔ)上進(jìn)行通信，當(dāng)一個(gè)socket（通常都是server socket）等待建立連接時(shí)，另一個(gè)socket可以要求進(jìn)行連接，一旦這兩個(gè)socket連接起來，它們就可以進(jìn)行雙向數(shù)據(jù)傳輸，雙方都可以進(jìn)行發(fā)送或接收操作。
　　UDP是User Datagram Protocol的簡稱，是一種無連接的協(xié)議，每個(gè)數(shù)據(jù)報(bào)都是一個(gè)獨(dú)立的信息，包括完整的源地址或目的地址，它在網(wǎng)絡(luò)上以任何可能的路徑傳往目的地，因此能否到達(dá)目的地，到達(dá)目的地的時(shí)間以及內(nèi)容的正確性都是不能被保證的。
　　下面我們對這兩種協(xié)議做簡單比較：
　　使用UDP時(shí)，每個(gè)數(shù)據(jù)報(bào)中都給出了完整的地址信息，因此無需要建立發(fā)送方和接收方的連接。對于TCP協(xié)議，由于它是一個(gè)面向連接的協(xié)議，在socket之間進(jìn)行數(shù)據(jù)傳輸之前必然要建立連接，所以在TCP中多了一個(gè)連接建立的時(shí)間。
 　使用UDP傳輸數(shù)據(jù)時(shí)是有大小限制的，每個(gè)被傳輸?shù)臄?shù)據(jù)報(bào)必須限定在64KB之內(nèi)。而TCP沒有這方面的限制，一旦連接建立起來，雙方的socket就可以按統(tǒng)一的格式傳輸大量的數(shù)據(jù)。UDP是一個(gè)不可靠的協(xié)議，發(fā)送方所發(fā)送的數(shù)據(jù)報(bào)并不一定以相同的次序到達(dá)接收方。而TCP是一個(gè)可靠的協(xié)議，它確保接收方完全正確地獲取發(fā)送方所發(fā)送的全部數(shù)據(jù)。
　　總之，TCP在網(wǎng)絡(luò)通信上有極強(qiáng)的生命力，例如遠(yuǎn)程連接（Telnet）和文件傳輸（FTP）都需要不定長度的數(shù)據(jù)被可靠地傳輸。相比之下UDP操作簡單，而且僅需要較少的監(jiān)護(hù)，因此通常用于局域網(wǎng)高可靠性的分散系統(tǒng)中client/server應(yīng)用程序。
　　讀者可能要問，既然有了保證可靠傳輸?shù)?/span>TCP協(xié)議，為什么還要非可靠傳輸?shù)?/span>UDP協(xié)議呢？主要的原因有兩個(gè)。一是可靠的傳輸是要付出代價(jià)的，對數(shù)據(jù)內(nèi)容正確性的檢驗(yàn)必然占用計(jì)算機(jī)的處理時(shí)間和網(wǎng)絡(luò)的帶寬，因此TCP傳輸?shù)男什蝗?/span>UDP高。二是在許多應(yīng)用中并不需要保證嚴(yán)格的傳輸可靠性，比如視頻會議系統(tǒng)，并不要求音頻視頻數(shù)據(jù)絕對的正確，只要保證連貫性就可以了，這種情況下顯然使用UDP會更合理一些。

8．2 基于URL的高層次Java網(wǎng)絡(luò)編程

8.2.1一致資源定位器URL

URL(Uniform Resource Locator)是一致資源定位器的簡稱，它表示Internet上某一資源的地址。通過URL我們可以訪問Internet上的各種網(wǎng)絡(luò)資源，比如最常見的WWW，FTP站點(diǎn)。瀏覽器通過解析給定的URL可以在網(wǎng)絡(luò)上查找相應(yīng)的文件或其他資源。

8.2.2 URL的組成

protocol://resourceName
　　協(xié)議名（protocol）指明獲取資源所使用的傳輸協(xié)議，如http、ftp、gopher、file等，資源名（resourceName）則應(yīng)該是資源的完整地址，包括主機(jī)名、端口號、文件名或文件內(nèi)部的一個(gè)引用。例如：
　　http://www.sun.com/ 協(xié)議名://主機(jī)名
　　http://home.netscape.com/home/welcome.html 協(xié)議名://機(jī)器名＋文件名
　　http://www.gamelan.com:80/Gamelan/network.html#BOTTOM 協(xié)議名://機(jī)器名＋端口號＋文件名＋內(nèi)部引用.

8.2.3 創(chuàng)建一個(gè)URL

為了表示URL， java.net中實(shí)現(xiàn)了類URL。我們可以通過下面的構(gòu)造方法來初始化一個(gè)URL對象：
　　（1） public URL (String spec);
　　　　　通過一個(gè)表示URL地址的字符串可以構(gòu)造一個(gè)URL對象。
　　　　　URL urlBase=new URL("http://www. 263.net/")
　　（2） public URL(URL context, String spec);
　　　　　通過基URL和相對URL構(gòu)造一個(gè)URL對象。
　　　　　URL net263=new URL ("http://www.263.net/");
　　　　　URL index263=new URL(net263, "index.html")
　　（3） public URL(String protocol, String host, String file);
　　　　　new URL("http", "www.gamelan.com", "/pages/Gamelan.net. html");
　　（4） public URL(String protocol, String host, int port, String file);
　　　　　URL gamelan=new URL("http", "www.gamelan.com", 80, "Pages/Gamelan.network.html");

　　注意：類URL的構(gòu)造方法都聲明拋棄非運(yùn)行時(shí)例外（MalformedURLException），因此生成URL對象時(shí)，我們必須要對這一例外進(jìn)行處理，通常是用try-catch語句進(jìn)行捕獲。格式如下：

try{
　　　　　URL myURL= new URL(…)
　　}catch (MalformedURLException e){
　　…　　}

8.2.4 解析一個(gè)URL

一個(gè)URL對象生成后，其屬性是不能被改變的，但是我們可以通過類URL所提供的方法來獲取這些屬性：
　　　public String getProtocol() 獲取該URL的協(xié)議名。
　　　public String getHost() 獲取該URL的主機(jī)名。
　　　public int getPort() 獲取該URL的端口號，如果沒有設(shè)置端口，返回-1。
　　　public String getFile() 獲取該URL的文件名。
　　　public String getRef() 獲取該URL在文件中的相對位置。
　　　public String getQuery() 獲取該URL的查詢信息。
　　　public String getPath() 獲取該URL的路徑
　　 public String getAuthority() 獲取該URL的權(quán)限信息
　　　public String getUserInfo() 獲得使用者的信息
　　　 public String getRef() 獲得該URL的錨

8.2.5 從URL讀取WWW網(wǎng)絡(luò)資源

當(dāng)我們得到一個(gè)URL對象后，就可以通過它讀取指定的WWW資源。這時(shí)我們將使用URL的方法openStream()，其定義為：
　　　　　　　　　InputStream openStream();
　　
　　方法openSteam()與指定的URL建立連接并返回InputStream類的對象以從這一連接中讀取數(shù)據(jù)。
　　public class URLReader {
　　public static void main(String[] args) throws Exception {
　　　　　　　　　　　　　　　　　　　　　　//聲明拋出所有例外
　　　　URL tirc = new URL("http://www.tirc1.cs.tsinghua.edu.cn/");
　　　　　　　　　　　　　　　　　　　　　　//構(gòu)建一URL對象
　　　　BufferedReader in = new BufferedReader(new InputStreamReader(tirc.openStream()));
　　　　//使用openStream得到一輸入流并由此構(gòu)造一個(gè)BufferedReader對象
　　　　String inputLine;
　　　　while ((inputLine = in.readLine()) != null)
　　　　　　　　　　　　　　　　　//從輸入流不斷的讀數(shù)據(jù)，直到讀完為止
　　　　　　　System.out.println(inputLine); //把讀入的數(shù)據(jù)打印到屏幕上
　　　　in.close(); //關(guān)閉輸入流
　　}
　　}

8.2.6 通過URLConnetction連接WWW

通過URL的方法openStream()，我們只能從網(wǎng)絡(luò)上讀取數(shù)據(jù)，如果我們同時(shí)還想輸出數(shù)據(jù)，例如向服務(wù)器端的CGI程序發(fā)送一些數(shù)據(jù)，我們必須先與URL建立連接，然后才能對其進(jìn)行讀寫，這時(shí)就要用到類URLConnection了。CGI是公共網(wǎng)關(guān)接口（Common Gateway Interface）的簡稱，它是用戶瀏覽器和服務(wù)器端的應(yīng)用程序進(jìn)行連接的接口，有關(guān)CGI程序設(shè)計(jì)，請讀者參考有關(guān)書籍。
　　類URLConnection也在包java.net中定義，它表示Java程序和URL在網(wǎng)絡(luò)上的通信連接。當(dāng)與一個(gè)URL建立連接時(shí)，首先要在一個(gè)URL對象上通過方法openConnection()生成對應(yīng)的URLConnection對象。例如下面的程序段首先生成一個(gè)指向地址http://edu.chinaren.com/index.shtml的對象，然后用openConnection（）打開該URL對象上的一個(gè)連接，返回一個(gè)URLConnection對象。如果連接過程失敗，將產(chǎn)生IOException.
　　Try{
　　　　URL netchinaren = new URL ("http://edu.chinaren.com/index.shtml");
　　　　URLConnectonn tc = netchinaren.openConnection();
　　}catch(MalformedURLException e){ //創(chuàng)建URL()對象失敗
　　…
　　}catch (IOException e){ //openConnection()失敗
　　…
　　}
　　類URLConnection提供了很多方法來設(shè)置或獲取連接參數(shù)，程序設(shè)計(jì)時(shí)最常使用的是getInputStream()和getOurputStream(),其定義為：
　　　　　InputSteram getInputSteram();
　　　　　OutputSteram getOutputStream();
　　通過返回的輸入/輸出流我們可以與遠(yuǎn)程對象進(jìn)行通信。看下面的例子：
　　URL url =new URL ("http://www.javasoft.com/cgi-bin/backwards");
　　//創(chuàng)建一URL對象
　　URLConnectin con=url.openConnection();
　　//由URL對象獲取URLConnection對象
　　DataInputStream dis=new DataInputStream (con.getInputSteam());
　　//由URLConnection獲取輸入流，并構(gòu)造DataInputStream對象
　　PrintStream ps=new PrintSteam(con.getOutupSteam());
　　//由URLConnection獲取輸出流，并構(gòu)造PrintStream對象
　　String line=dis.readLine(); //從服務(wù)器讀入一行
　　ps.println("client…"); //向服務(wù)器寫出字符串 "client…"
　　　　其中backwards為服務(wù)器端的CGI程序。實(shí)際上，類URL的方法openSteam（）是通過URLConnection來實(shí)現(xiàn)的。它等價(jià)于
　　　　openConnection().getInputStream();
　　基于URL的網(wǎng)絡(luò)編程在底層其實(shí)還是基于下面要講的Socket接口的。WWW，FTP等標(biāo)準(zhǔn)化的網(wǎng)絡(luò)服務(wù)都是基于TCP協(xié)議的，所以本質(zhì)上講URL編程也是基于TCP的一種應(yīng)用.

8．3 基于Socket的低層次Java網(wǎng)絡(luò)編程

8.3.1 Socket通訊

網(wǎng)絡(luò)上的兩個(gè)程序通過一個(gè)雙向的通訊連接實(shí)現(xiàn)數(shù)據(jù)的交換，這個(gè)雙向鏈路的一端稱為一個(gè)Socket。Socket通常用來實(shí)現(xiàn)客戶方和服務(wù)方的連接。Socket是TCP/IP協(xié)議的一個(gè)十分流行的編程界面，一個(gè)Socket由一個(gè)IP地址和一個(gè)端口號唯一確定。
　　在傳統(tǒng)的UNIX環(huán)境下可以操作TCP/IP協(xié)議的接口不止Socket一個(gè)，Socket所支持的協(xié)議種類也不光TCP/IP一種，因此兩者之間是沒有必然聯(lián)系的。在Java環(huán)境下，Socket編程主要是指基于TCP/IP協(xié)議的網(wǎng)絡(luò)編程。

8.3.2 Socket通訊的一般過程

使用Socket進(jìn)行Client/Server程序設(shè)計(jì)的一般連接過程是這樣的：Server端Listen(監(jiān)聽)某個(gè)端口是否有連接請求，Client端向Server端發(fā)出Connect(連接)請求，Server端向Client端發(fā)回Accept（接受）消息。一個(gè)連接就建立起來了。Server端和Client端都可以通過Send，Write等方法與對方通信。

對于一個(gè)功能齊全的Socket，都要包含以下基本結(jié)構(gòu)，其工作過程包含以下四個(gè)基本的步驟：
　　（1） 創(chuàng)建Socket；
　　（2） 打開連接到Socket的輸入/出流；
　　（3） 按照一定的協(xié)議對Socket進(jìn)行讀/寫操作；
　　（4） 關(guān)閉Socket.

8.3.3 創(chuàng)建Socket

java在包java.net中提供了兩個(gè)類Socket和ServerSocket，分別用來表示雙向連接的客戶端和服務(wù)端。這是兩個(gè)封裝得非常好的類，使用很方便。其構(gòu)造方法如下：
　　Socket(InetAddress address, int port);
　　Socket(InetAddress address, int port, boolean stream);
　　Socket(String host, int prot);
　　Socket(String host, int prot, boolean stream);
　　Socket(SocketImpl impl)
　　Socket(String host, int port, InetAddress localAddr, int localPort)
　　Socket(InetAddress address, int port, InetAddress localAddr, int localPort)
　　ServerSocket(int port);
　　ServerSocket(int port, int backlog);
　　ServerSocket(int port, int backlog, InetAddress bindAddr)
　　其中address、host和port分別是雙向連接中另一方的IP地址、主機(jī)名和端口號，stream指明socket是流socket還是數(shù)據(jù)報(bào)socket，localPort表示本地主機(jī)的端口號，localAddr和bindAddr是本地機(jī)器的地址（ServerSocket的主機(jī)地址），impl是socket的父類，既可以用來創(chuàng)建serverSocket又可以用來創(chuàng)建Socket。count則表示服務(wù)端所能支持的最大連接數(shù)。例如：
　　Socket client = new Socket("127.0.01.", 80);
　　ServerSocket server = new ServerSocket(80);
　　注意，在選擇端口時(shí)，必須小心。每一個(gè)端口提供一種特定的服務(wù)，只有給出正確的端口，才能獲得相應(yīng)的服務(wù)。0~1023的端口號為系統(tǒng)所保留，例如http服務(wù)的端口號為80,telnet服務(wù)的端口號為21,ftp服務(wù)的端口號為23, 所以我們在選擇端口號時(shí)，最好選擇一個(gè)大于1023的數(shù)以防止發(fā)生沖突。
　　在創(chuàng)建socket時(shí)如果發(fā)生錯(cuò)誤，將產(chǎn)生IOException，在程序中必須對之作出處理。所以在創(chuàng)建Socket或ServerSocket是必須捕獲或拋出例外。

8.3.8 簡單的Client/Server程序設(shè)計(jì)

下面我們給出一個(gè)用Socket實(shí)現(xiàn)的客戶和服務(wù)器交互的典型的C/S結(jié)構(gòu)的演示程序，讀者通過仔細(xì)閱讀該程序，會對前面所討論的各個(gè)概念有更深刻的認(rèn)識。程序的意義請參考注釋。

1. 客戶端程序
　　import java.io.*;
　　import java.net.*;
　　public class TalkClient {
　　　　public static void main(String args[]) {
　　　　　　try{
　　　　　　　　Socket socket=new Socket("127.0.0.1",4700);
　　　　　　　　//向本機(jī)的4700端口發(fā)出客戶請求
　　　　　　　　BufferedReader sin=new BufferedReader(new InputStreamReader(System.in));
　　　　　　　　//由系統(tǒng)標(biāo)準(zhǔn)輸入設(shè)備構(gòu)造BufferedReader對象
　　　　　　　　PrintWriter os=new PrintWriter(socket.getOutputStream());
　　　　　　　　//由Socket對象得到輸出流，并構(gòu)造PrintWriter對象
　　　　　　　　BufferedReader is=new BufferedReader(new InputStreamReader(socket.getInputStream()));
　　　　　　　　//由Socket對象得到輸入流，并構(gòu)造相應(yīng)的BufferedReader對象
　　　　　　　　String readline;
　　　　　　　　readline=sin.readLine(); //從系統(tǒng)標(biāo)準(zhǔn)輸入讀入一字符串
　　　　　　　　while(!readline.equals("bye")){
　　　　　　　　//若從標(biāo)準(zhǔn)輸入讀入的字符串為 "bye"則停止循環(huán)
　　　　　　　　　　os.println(readline);
　　　　　　　　　　//將從系統(tǒng)標(biāo)準(zhǔn)輸入讀入的字符串輸出到Server
　　　　　　　　　　os.flush();
　　　　　　　　　　//刷新輸出流，使Server馬上收到該字符串
　　　　　　　　　　System.out.println("Client:"+readline);
　　　　　　　　　　//在系統(tǒng)標(biāo)準(zhǔn)輸出上打印讀入的字符串
　　　　　　　　　　System.out.println("Server:"+is.readLine());
　　　　　　　　　　//從Server讀入一字符串，并打印到標(biāo)準(zhǔn)輸出上
　　　　　　　　　　readline=sin.readLine(); //從系統(tǒng)標(biāo)準(zhǔn)輸入讀入一字符串
　　　　　　　　} //繼續(xù)循環(huán)
　　　　　　　　os.close(); //關(guān)閉Socket輸出流
　　　　　　　　is.close(); //關(guān)閉Socket輸入流
　　　　　　　　socket.close(); //關(guān)閉Socket
　　　　　　}catch(Exception e) {
　　　　　　　　System.out.println("Error"+e); //出錯(cuò)，則打印出錯(cuò)信息
　　　　　　}
　　}
}

　2. 服務(wù)器端程序
　　import java.io.*;
　　import java.net.*;
　　import java.applet.Applet;
　　public class TalkServer{
　　　　public static void main(String args[]) {
　　　　　　try{
　　　　　　　　ServerSocket server=null;
　　　　　　　　try{
　　　　　　　　　　server=new ServerSocket(4700);
　　　　　　　　//創(chuàng)建一個(gè)ServerSocket在端口4700監(jiān)聽客戶請求
　　　　　　　　}catch(Exception e) {
　　　　　　　　　　System.out.println("can not listen to:"+e);
　　　　　　　　//出錯(cuò)，打印出錯(cuò)信息
　　　　　　　　}

　　　　　　　　Socket socket=null;
　　　　　　　　try{
　　　　　　　　　　socket=server.accept();
　　　　　　　　　　//使用accept()阻塞等待客戶請求，有客戶
　　　　　　　　　　//請求到來則產(chǎn)生一個(gè)Socket對象，并繼續(xù)執(zhí)行
　　　　　　　　}catch(Exception e) {
　　　　　　　　　　System.out.println("Error."+e);
　　　　　　　　　　//出錯(cuò)，打印出錯(cuò)信息
　　　　　　　　}
　　　　　　　　String line;
　　　　　　　　BufferedReader is=new BufferedReader(new InputStreamReader(socket.getInputStream()));
　　　　　　　　　//由Socket對象得到輸入流，并構(gòu)造相應(yīng)的BufferedReader對象
　　　　　　　　PrintWriter os=newPrintWriter(socket.getOutputStream());
　　　　　　　　　//由Socket對象得到輸出流，并構(gòu)造PrintWriter對象
　　　　　　　　BufferedReader sin=new BufferedReader(new InputStreamReader(System.in));
　　　　　　　　　//由系統(tǒng)標(biāo)準(zhǔn)輸入設(shè)備構(gòu)造BufferedReader對象

　　　　　　　　System.out.println("Client:"+is.readLine());
　　　　　　　　//在標(biāo)準(zhǔn)輸出上打印從客戶端讀入的字符串
　　　　　　　　line=sin.readLine();
　　　　　　　　//從標(biāo)準(zhǔn)輸入讀入一字符串
　　　　　　　　while(!line.equals("bye")){
　　　　　　　　//如果該字符串為 "bye"，則停止循環(huán)
　　　　　　　　　　os.println(line);
　　　　　　　　　　//向客戶端輸出該字符串
　　　　　　　　　　os.flush();
　　　　　　　　　　//刷新輸出流，使Client馬上收到該字符串
　　　　　　　　　　System.out.println("Server:"+line);
　　　　　　　　　　//在系統(tǒng)標(biāo)準(zhǔn)輸出上打印讀入的字符串
　　　　　　　　　　System.out.println("Client:"+is.readLine());
　　　　　　　　　　//從Client讀入一字符串，并打印到標(biāo)準(zhǔn)輸出上
　　　　　　　　　　line=sin.readLine();
　　　　　　　　　　//從系統(tǒng)標(biāo)準(zhǔn)輸入讀入一字符串
　　　　　　　　} 　//繼續(xù)循環(huán)
　　　　　　　　os.close(); //關(guān)閉Socket輸出流
　　　　　　　　is.close(); //關(guān)閉Socket輸入流
　　　　　　　　socket.close(); //關(guān)閉Socket
　　　　　　　　server.close(); //關(guān)閉ServerSocket
　　　　　　}catch(Exception e){
　　　　　　　　System.out.println("Error:"+e);
　　　　　　　　//出錯(cuò)，打印出錯(cuò)信息
　　　　　　}
　　　　}
　　}

8.3.9 支持多客戶的client/server程序設(shè)計(jì)

前面提供的Client/Server程序只能實(shí)現(xiàn)Server和一個(gè)客戶的對話。在實(shí)際應(yīng)用中，往往是在服務(wù)器上運(yùn)行一個(gè)永久的程序，它可以接收來自其他多個(gè)客戶端的請求，提供相應(yīng)的服務(wù)。為了實(shí)現(xiàn)在服務(wù)器方給多個(gè)客戶提供服務(wù)的功能，需要對上面的程序進(jìn)行改造，利用多線程實(shí)現(xiàn)多客戶機(jī)制。服務(wù)器總是在指定的端口上監(jiān)聽是否有客戶請求，一旦監(jiān)聽到客戶請求，服務(wù)器就會啟動一個(gè)專門的服務(wù)線程來響應(yīng)該客戶的請求，而服務(wù)器本身在啟動完線程之后馬上又進(jìn)入監(jiān)聽狀態(tài)，等待下一個(gè)客戶的到來。

ServerSocket serverSocket=null;
　　　　boolean listening=true;
　　　　try{
　　　　　　serverSocket=new ServerSocket(4700);
　　　　　　//創(chuàng)建一個(gè)ServerSocket在端口4700監(jiān)聽客戶請求
　　　　}catch(IOException e) {　　}
　　　　while(listening){ //永遠(yuǎn)循環(huán)監(jiān)聽
　　　　　　new ServerThread(serverSocket.accept(),clientnum).start();
　　　　　　//監(jiān)聽到客戶請求，根據(jù)得到的Socket對象和
　　　　　　　客戶計(jì)數(shù)創(chuàng)建服務(wù)線程，并啟動之
　　　　　　clientnum++; //增加客戶計(jì)數(shù)
　　　　}
　　　　serverSocket.close(); //關(guān)閉ServerSocket

設(shè)計(jì)ServerThread類

　public class ServerThread extends Thread{
　　　Socket socket=null; //保存與本線程相關(guān)的Socket對象
　　　int clientnum; //保存本進(jìn)程的客戶計(jì)數(shù)
　　　public ServerThread(Socket socket,int num) { //構(gòu)造函數(shù)
　　　　this.socket=socket; //初始化socket變量
　　　　clientnum=num+1; //初始化clientnum變量
　　　}
　　　public void run() { //線程主體
　　　　try{//在這里實(shí)現(xiàn)數(shù)據(jù)的接受和發(fā)送}

8.3.10 據(jù)報(bào)Datagram通訊

前面在介紹TCP/IP協(xié)議的時(shí)候，我們已經(jīng)提到，在TCP/IP協(xié)議的傳輸層除了TCP協(xié)議之外還有一個(gè)UDP協(xié)議，相比而言UDP的應(yīng)用不如TCP廣泛，幾個(gè)標(biāo)準(zhǔn)的應(yīng)用層協(xié)議HTTP，FTP，SMTP…使用的都是TCP協(xié)議。但是，隨著計(jì)算機(jī)網(wǎng)絡(luò)的發(fā)展，UDP協(xié)議正越來越來顯示出其威力，尤其是在需要很強(qiáng)的實(shí)時(shí)交互性的場合，如網(wǎng)絡(luò)游戲，視頻會議等，UDP更是顯示出極強(qiáng)的威力，下面我們就介紹一下Java環(huán)境下如何實(shí)現(xiàn)UDP網(wǎng)絡(luò)傳輸。

8.3.11 什么是Datagram

所謂數(shù)據(jù)報(bào)（Datagram）就跟日常生活中的郵件系統(tǒng)一樣，是不能保證可靠的寄到的，而面向鏈接的TCP就好比電話，雙方能肯定對方接受到了信息。在本章前面，我們已經(jīng)對UDP和TCP進(jìn)行了比較，在這里再稍作小節(jié)：
　　TCP，可靠，傳輸大小無限制，但是需要連接建立時(shí)間，差錯(cuò)控制開銷大。
　　UDP，不可靠，差錯(cuò)控制開銷較小，傳輸大小限制在64K以下，不需要建立連接。

8.3.12 Datagram通訊的表示方法：DatagramSocket；DatagramPacket

包java.net中提供了兩個(gè)類DatagramSocket和DatagramPacket用來支持?jǐn)?shù)據(jù)報(bào)通信，DatagramSocket用于在程序之間建立傳送數(shù)據(jù)報(bào)的通信連接， DatagramPacket則用來表示一個(gè)數(shù)據(jù)報(bào)。先來看一下DatagramSocket的構(gòu)造方法：
　　　DatagramSocket（）；
　　　DatagramSocket（int prot）;
　　　DatagramSocket(int port, InetAddress laddr)
　　　　其中，port指明socket所使用的端口號，如果未指明端口號，則把socket連接到本地主機(jī)上一個(gè)可用的端口。laddr指明一個(gè)可用的本地地址。給出端口號時(shí)要保證不發(fā)生端口沖突，否則會生成SocketException類例外。注意：上述的兩個(gè)構(gòu)造方法都聲明拋棄非運(yùn)行時(shí)例外SocketException，程序中必須進(jìn)行處理，或者捕獲、或者聲明拋棄。
   用數(shù)據(jù)報(bào)方式編寫client/server程序時(shí)，無論在客戶方還是服務(wù)方，首先都要建立一個(gè)DatagramSocket對象，用來接收或發(fā)送數(shù)據(jù)報(bào)，然后使用DatagramPacket類對象作為傳輸數(shù)據(jù)的載體。下面看一下DatagramPacket的構(gòu)造方法 ：
　　　DatagramPacket（byte buf[],int length）；
　　　DatagramPacket(byte buf[], int length, InetAddress addr, int port);
　　　DatagramPacket(byte[] buf, int offset, int length)；
　　　DatagramPacket(byte[] buf, int offset, int length, InetAddress address, int port)；

　　其中，buf中存放數(shù)據(jù)報(bào)數(shù)據(jù)，length為數(shù)據(jù)報(bào)中數(shù)據(jù)的長度，addr和port旨明目的地址，offset指明了數(shù)據(jù)報(bào)的位移量。
　　在接收數(shù)據(jù)前，應(yīng)該采用上面的第一種方法生成一個(gè)DatagramPacket對象，給出接收數(shù)據(jù)的緩沖區(qū)及其長度。然后調(diào)用DatagramSocket 的方法receive()等待數(shù)據(jù)報(bào)的到來，receive()將一直等待，直到收到一個(gè)數(shù)據(jù)報(bào)為止。
　　DatagramPacket packet=new DatagramPacket(buf, 256);
　　Socket.receive (packet);
　　發(fā)送數(shù)據(jù)前，也要先生成一個(gè)新的DatagramPacket對象，這時(shí)要使用上面的第二種構(gòu)造方法，在給出存放發(fā)送數(shù)據(jù)的緩沖區(qū)的同時(shí)，還要給出完整的目的地址，包括IP地址和端口號。發(fā)送數(shù)據(jù)是通過DatagramSocket的方法send()實(shí)現(xiàn)的，send()根據(jù)數(shù)據(jù)報(bào)的目的地址來尋徑，以傳遞數(shù)據(jù)報(bào)。
　　DatagramPacket packet=new DatagramPacket(buf, length, address, port);
　　Socket.send(packet)；
    在構(gòu)造數(shù)據(jù)報(bào)時(shí)，要給出InetAddress類參數(shù)。類InetAddress在包java.net中定義，用來表示一個(gè)Internet地址，我們可以通過它提供的類方法getByName（）從一個(gè)表示主機(jī)名的字符串獲取該主機(jī)的IP地址，然后再獲取相應(yīng)的地址信息。

8.3.14 用數(shù)據(jù)報(bào)進(jìn)行廣播通訊

DatagramSocket只允許數(shù)據(jù)報(bào)發(fā)送一個(gè)目的地址，java.net包中提供了一個(gè)類MulticastSocket，允許數(shù)據(jù)報(bào)以廣播方式發(fā)送到該端口的所有客戶。MulticastSocket用在客戶端，監(jiān)聽服務(wù)器廣播來的數(shù)據(jù)。

1. 客戶方程序:MulticastClient.java
　　import java.io.*;
　　import java.net.*;
　　import java.util.*;
　　public class MulticastClient {
　　　　public static void main(String args[]) throws IOException
　　　　{
　　　　　MulticastSocket socket=new MulticastSocket(4446);
　　　　　//創(chuàng)建4446端口的廣播套接字
　　　　　InetAddress address=InetAddress.getByName("230.0.0.1");
　　　　　//得到230.0.0.1的地址信息
　　　　　socket.joinGroup(address);
　　　　　//使用joinGroup()將廣播套接字綁定到地址上
　　　　　DatagramPacket packet;

　　　　　for(int i=0;i<5;i++) {
　　　　　　　byte[] buf=new byte[256];
　　　　　　　//創(chuàng)建緩沖區(qū)
　　　　　　　packet=new DatagramPacket(buf,buf.length);
　　　　　　　//創(chuàng)建接收數(shù)據(jù)報(bào)
　　　　　　　socket.receive(packet); //接收
　　　　　　　String received=new String(packet.getData());
　　　　　　　//由接收到的數(shù)據(jù)報(bào)得到字節(jié)數(shù)組，
　　　　　　　//并由此構(gòu)造一個(gè)String對象
　　　　　　　System.out.println("Quote of theMoment:"+received);
　　　　　　　//打印得到的字符串
　　　　　} //循環(huán)5次
　　　　　socket.leaveGroup(address);
　　　　　//把廣播套接字從地址上解除綁定
　　　　　socket.close(); //關(guān)閉廣播套接字
　　　}
　}

　2. 服務(wù)器方程序:MulticastServer.java
　　public class MulticastServer{
　　　　public static void main(String args[]) throws java.io.IOException
　　　　{
　　　　　　new MulticastServerThread().start();
　　　　　　//啟動一個(gè)服務(wù)器線程
　　　　}
　　}

　3. 程序MulticastServerThread.java
　　import java.io.*;
　　import java.net.*;
　　import java.util.*;
　　public class MulticastServerThread extends QuoteServerThread
　　//從QuoteServerThread繼承得到新的服務(wù)器線程類MulticastServerThread
　　{
　　　　Private long FIVE_SECOND=5000; //定義常量，5秒鐘
　　　　public MulticastServerThread(String name) throws IOException
　　　　{
　　　　　　super("MulticastServerThread");
　　　　　　//調(diào)用父類，也就是QuoteServerThread的構(gòu)造函數(shù)
　　　　}

　　　　public void run() //重寫父類的線程主體
　　　　{
　　　　　while(moreQuotes) {
　　　　　//根據(jù)標(biāo)志變量判斷是否繼續(xù)循環(huán)
　　　　　　try{
　　　　　　　　byte[] buf=new byte[256];
　　　　　　　　//創(chuàng)建緩沖區(qū)
　　　　　　　　String dString=null;
　　　　　　　　if(in==null) dString=new Date().toString();
　　　　　　　　//如果初始化的時(shí)候打開文件失敗了，
　　　　　　　　//則使用日期作為要傳送的字符串
　　　　　　　　else dString=getNextQuote();
　　　　　　　　//否則調(diào)用成員函數(shù)從文件中讀出字符串
　　　　　　　　buf=dString.getByte();
　　　　　　　　//把String轉(zhuǎn)換成字節(jié)數(shù)組，以便傳送send it
　　　　　　　　InetAddress group=InetAddress.getByName("230.0.0.1");
　　　　　　　　//得到230.0.0.1的地址信息
　　　　　　　　DatagramPacket packet=new DatagramPacket(buf,buf.length,group,4446);
　　　　　　　　//根據(jù)緩沖區(qū)，廣播地址，和端口號創(chuàng)建DatagramPacket對象
　　　　　　　　socket.send(packet); //發(fā)送該P(yáng)acket
　　　　　　　　try{
　　　　　　　　　　sleep((long)(Math.random()*FIVE_SECONDS));
　　　　　　　　　　//隨機(jī)等待一段時(shí)間，0～5秒之間
　　　　　　　　}catch(InterruptedException e) { } //異常處理
　　　　　　}catch(IOException e){ //異常處理
　　　　　　　　e.printStackTrace( ); //打印錯(cuò)誤棧

　　　　　　　　moreQuotes=false; //置結(jié)束循環(huán)標(biāo)志
　　　　　　}
　　　　}
　　　　socket.close( ); //關(guān)閉廣播套接口
　　　}
　}

【本講小結(jié)】

本講主要講解了Java環(huán)境下的網(wǎng)絡(luò)編程。因?yàn)?/span>TCP/IP協(xié)議是Java網(wǎng)絡(luò)編程的基礎(chǔ)知識，本講開篇重點(diǎn)介紹了TCP/IP協(xié)議中的一些概念，TCP/IP協(xié)議本身是一個(gè)十分龐大的系統(tǒng)，用幾個(gè)小節(jié)是不可能講清楚的。所以我們只是聯(lián)系實(shí)際，講解了一些最基本的概念，幫助學(xué)生理解后面的相關(guān)內(nèi)容。重點(diǎn)有一下幾個(gè)概念：主機(jī)名，IP，端口，服務(wù)類型，TCP，UDP。
　　后續(xù)的內(nèi)容分為兩大塊，一塊是以URL為主線，講解如何通過URL類和URLConnection類訪問WWW網(wǎng)絡(luò)資源，由于使用URL十分方便直觀，盡管功能不是很強(qiáng)，還是值得推薦的一種網(wǎng)絡(luò)編程方法，尤其是對于初學(xué)者特別容易接受。本質(zhì)上講，URL網(wǎng)絡(luò)編程在傳輸層使用的還是TCP協(xié)議。
　　另一塊是以Socket接口和C/S網(wǎng)絡(luò)編程模型為主線，依次講解了如何用Java實(shí)現(xiàn)基于TCP的C/S結(jié)構(gòu)，主要用到的類有Socket，ServerSocket。以及如何用Java實(shí)現(xiàn)基于UDP的C/S結(jié)構(gòu)，還討論了一種特殊的傳輸方式，廣播方式，這種方式是UDP所特有的，主要用到的類有DatagramSocket , DatagramPacket, MulticastSocket。這一塊在Java網(wǎng)絡(luò)編程中相對而言是最難的（盡管Java在網(wǎng)絡(luò)編程這方面已經(jīng)做的夠"傻瓜"了，但是網(wǎng)絡(luò)編程在其他環(huán)境下的卻是一件極為頭痛的事情，再"傻瓜"還是有一定的難度），也是功能最為強(qiáng)大的一部分,讀者應(yīng)該好好研究，領(lǐng)悟其中的思想。
　　最后要強(qiáng)調(diào)的是要學(xué)好Java網(wǎng)絡(luò)編程，Java語言，最重要的還是在于多多練習(xí)！

java中的事件機(jī)制

Java做的圖形界面軟件通過事件響應(yīng)機(jī)制實(shí)現(xiàn)用戶與程序的交互，原理大概是這樣：

 

首先，在java控件對象（比如文本框）上添加一個(gè)監(jiān)控對象，方法是one.addXXXListenner(two)，這就相當(dāng)于你要對某人進(jìn)行監(jiān)聽，先要在他身上綁定一個(gè)竊聽器一樣，這里“one”就是你要監(jiān)聽的那個(gè)家伙，two就是你自己造的一個(gè)竊聽器。

 

第二步就是要考慮怎樣造這個(gè)竊聽器了，我們首先要搞清楚它要實(shí)現(xiàn)的功能：它不僅能夠監(jiān)聽one的一舉一動，還能夠把監(jiān)聽到的事件告訴系統(tǒng)，并讓系統(tǒng)對這個(gè)事件做出相應(yīng)的處理。Java中是通過接口實(shí)現(xiàn)這樣的功能的。這些接口請參見jdk中java.awt.event包，里面那幾個(gè)XXXListener就是（不是很多，常用的更少）。在這些接口中定義了一些方法，這些方法就是相應(yīng)的事件處理方式，它們只由系統(tǒng)調(diào)用并且都有一個(gè)事件類的對象作為參數(shù)，這個(gè)參數(shù)正是聯(lián)系發(fā)生事件主體one和操作系統(tǒng)的紐帶。當(dāng)然接口是虛的，不能產(chǎn)生對象的；所以想必你也猜到，上面的“竊聽器”two的類型肯定是某個(gè)實(shí)現(xiàn)了XXXListener接口的類。

好了，現(xiàn)在在回顧一下這個(gè)過程：

（1）用戶通過鼠標(biāo)、鍵盤等在one對象上做動作（比如點(diǎn)擊鼠標(biāo)），

（2）這個(gè)動作被two監(jiān)聽到并產(chǎn)生事件對象e（即XXXEvent的對象），

（3）two通過事件e對象向系統(tǒng)打報(bào)告，

（4）系統(tǒng)調(diào)用two中實(shí)現(xiàn)的方法對事件進(jìn)行處理，并向方法傳送事件e。

 

 

如果你清楚了這個(gè)過程，再來細(xì)看一下這個(gè)XXXListener接口。我們必須用類來實(shí)現(xiàn)接口的方法（這是java基礎(chǔ)知識吧◎），再用這個(gè)類產(chǎn)生two這樣的對象。類實(shí)現(xiàn)接口必須實(shí)現(xiàn)接口中的每個(gè)方法，而實(shí)際上我們需要的也許只是該接口中的某一個(gè)方法（比如處理鼠標(biāo)右鍵點(diǎn)擊的那個(gè)），那么每個(gè)方法還得去實(shí)現(xiàn)一個(gè)空的，真是浪費(fèi)。Sun為了讓程序員省點(diǎn)事，在JDK中已經(jīng)為我們把這些接口實(shí)現(xiàn)好了，這些類就是我們所謂的“適配器”（XXXAdapter），我們只需要繼承（extends）這些類并重寫里面我們需要的方法就OK了，所以，其實(shí)適配器就是類，只不過這些類中只有一些空的方法，別無所有。

到此，你大概明白程序員在事件處理過程中該做哪些事了吧：

（1）制造“竊聽器”，即：實(shí)現(xiàn)事件監(jiān)聽接口，重寫相關(guān)方法，

（2）安裝竊聽器，即：為監(jiān)控對象添加監(jiān)聽器。

 

下面，我們通過程序再來仔細(xì)看看事件響應(yīng)的實(shí)現(xiàn)方式（待續(xù)）：

（以下內(nèi)容參考陳剛《eclipse從入門到精通》）

（1）、 匿名內(nèi)部類寫法

例程：

text.addMouseListener(new MouseAdapter() {

    public void mouseDoubleClick(MouseEvent e) {//鼠標(biāo)雙擊事件的方法

         //打開一個(gè)信息框

        MessageDialog.openInformation (null,"","Hello World");

    }

});

new MouseAdapter()就是一個(gè)匿名內(nèi)部類。其實(shí)就是在實(shí)現(xiàn)類的同時(shí)用new構(gòu)造一個(gè)該類的對象，并把它作為addMouseListener的參數(shù)，它的效果和下面的一樣，只不過代碼比較集中。

 

（2）、命名內(nèi)部類寫法

public class HelloWorld {

    public static void main(String[] args) {

           ……

        Text text = new Text(shell, SWT.BORDER);

//加入鼠標(biāo)事件監(jiān)聽器，并用下面代碼所定義的內(nèi)部類生成一個(gè)對象

        text.addMouseListener(new MyMouseDoubleClick());

        ……

    }

 

//定義一個(gè)名為MyMouseDoubleClick的內(nèi)部類

    private static final class MyMouseDoubleClick extends MouseAdapter {

        public void mouseDoubleClick(MouseEvent e) {

            MessageDialog.openInformation(null, "", "Hello World");

        }

    }

}

 

（3）、外部類寫法

這種寫法和命名內(nèi)部類有些相似，只不過是將MyMouseDoubleClick類從HelloWorld.java中拿出去，單獨(dú)寫成一個(gè)類文件。實(shí)現(xiàn)代碼如下

//文件1： HelloWorld.java

public class HelloWorld {

    public static void main(String[] args) {

              ……

        Text text = new Text(shell, SWT.BORDER);

//加入鼠標(biāo)事件監(jiān)聽器，并用下面代碼所定義的內(nèi)部類生成一個(gè)對象

        text.addMouseListener(new MyMouseDoubleClick());

        ……

    }

}

 

//文件2：MyMouseDoubleClick.java

public class MyMouseDoubleClick extends MouseAdapter {

    public void mouseDoubleClick(MouseEvent e) {

        MessageDialog.openInformation(null, "", "Hello World");

    }

}

（4）、實(shí)現(xiàn)監(jiān)聽接口的寫法

將HelloWorld類實(shí)現(xiàn)MouseListener接口，這樣類本身就成了一個(gè)監(jiān)聽器，使得加入監(jiān)聽器的代碼可以更簡潔。這種方式適合加入監(jiān)聽器的組件較多，且要求監(jiān)聽器的事件處理代碼可以被組件共用。這種方式還有一個(gè)要注意的地方：事件方法和其他方法混合在了一起，容易引起誤讀，所以應(yīng)該在事件方法前加入詳細(xì)的注釋說明。

實(shí)現(xiàn)MouseListener接口要寫的事件方法多一些，當(dāng)然沒用的事件方法可以空實(shí)現(xiàn)。如果繼承MouseListener接口的適配器MouseAdapter，則只寫需要的方法就行了。另外要注意：只有接口才能有多繼承的特性，所以如果HelloWorld已經(jīng)是某個(gè)類的子類，就只能用實(shí)現(xiàn)接口的方式，而不能繼承接口的適配器了。

給出示例代碼如下：

public class HelloWorld extends MouseAdapter{//或implements MouseListener

    public static void main(String[] args) {

            ……

        Text text1 = new Text(shell, SWT.BORDER);

        Text text2 = new Text(shell, SWT.BORDER);

        text1.addMouseListener(this);

        text2.addMouseListener(this);

        ……

    }

 

    public void mouseDoubleClick(MouseEvent e) {

        MessageDialog.openInformation(null, "", "Hello World");

    }

}

java中的事件機(jī)制的參與者有3種角色：

1.event object：就是事件產(chǎn)生時(shí)具體的“事件”，用于listener的相應(yīng)的方法之中，作為參數(shù)，一般存在與listerner的方法之中

2.event source：具體的接受事件的實(shí)體，比如說，你點(diǎn)擊一個(gè)button，那么button就是event source，這樣你必須使button對某些事件進(jìn)行相應(yīng)，你就需要注冊特定的listener，比如說MouseEvent之中的MouseClicked方法，這是他就必須有了add方法

3.event listener：具體的對監(jiān)聽的事件類，當(dāng)有其對應(yīng)的event object產(chǎn)生的時(shí)候，它就調(diào)用相應(yīng)的方法，進(jìn)行處理。在windows程序設(shè)計(jì)里邊這種相應(yīng)使用callback機(jī)制來實(shí)現(xiàn)的

先看看jdk提供的event包：

public interface EventListener：所有事件偵聽器接口必須擴(kuò)展的標(biāo)記接口。

public class EventObject extends Object implements Serializable

所有事件狀態(tài)對象都將從其派生的根類。 所有 Event 在構(gòu)造時(shí)都引用了對象 "source"，在邏輯上認(rèn)為該對象是最初發(fā)生有關(guān) Event 的對象。

        在Java2處理事件時(shí)，沒有采用dispatchEvent()-postEvent()-handleEvent()方式，采用了監(jiān)聽器類，每個(gè)事件類都有相關(guān)聯(lián)的監(jiān)聽器接口。事件從事件源到監(jiān)聽者的傳遞是通過對目標(biāo)監(jiān)聽者對象的Java方法調(diào)用進(jìn)行的。

　　對每個(gè)明確的事件的發(fā)生，都相應(yīng)地定義一個(gè)明確的Java方法。這些方法都集中定義在事件監(jiān)聽者（EventListener）接口中，這個(gè)接口要繼承 java.util.EventListener。 實(shí)現(xiàn)了事件監(jiān)聽者接口中一些或全部方法的類就是事件監(jiān)聽者。

　　伴隨著事件的發(fā)生，相應(yīng)的狀態(tài)通常都封裝在事件狀態(tài)對象中，該對象必須繼承自java.util.EventObject。事件狀態(tài)對象作為單參傳遞給應(yīng)響應(yīng)該事件的監(jiān)聽者方法中。發(fā)出某種特定事件的事件源的標(biāo)識是：遵從規(guī)定的設(shè)計(jì)格式為事件監(jiān)聽者定義注冊方法，并接受對指定事件監(jiān)聽者接口實(shí)例的引用。

開始之前首先問個(gè)問題：您熟悉java.util.EventObject 和java.util.EventListener兩個(gè)類以及他們已有的子類嗎？

如果你已經(jīng)能夠熟練使用jdk為我們提供的事件監(jiān)聽器，并且很熟悉MouseEvent, KeyEvent, WindowEvent等等這些jdk為我們準(zhǔn)備好的事件，那么想必你對java的事件機(jī)制已經(jīng)有所理解。但是也許你還是覺得雖然用起來沒什么問題，但是原理還是有些糊涂，那么下面我們再進(jìn)一步自己實(shí)現(xiàn)這些事件和監(jiān)聽器，我們把這個(gè)取名為自定義事件。

其實(shí)自定義事件在java中很有用處，我們有的時(shí)候想讓自己的程序產(chǎn)生一個(gè)事件，但有不希望（或者不可能）用鼠標(biāo)，鍵盤之類的輸入設(shè)備進(jìn)行操作，比如你寫一個(gè)應(yīng)用程序，在這個(gè)程序中一旦收到郵件就對郵件進(jìn)行相關(guān)處理，對于“收到郵件”這個(gè)事件，jdk中就沒有定義。對于這樣的事件，以及對于這樣的事件的監(jiān)聽器，我們只能自己動手完成了。

那么下面就以實(shí)例開始我們這個(gè)“創(chuàng)新”的過程：首先，我們要明確jdk中需要的資源：類EventObject作為父類用來生成我們自己的事件類，接口EventListener用來實(shí)現(xiàn)我們自己的監(jiān)聽器；剩下的事情就是如何注冊這些事件以及測試他們了。

（1）       通過DemoEvent.java文件創(chuàng)建DemoEvent類，這個(gè)類繼承EventObject。這個(gè)類的構(gòu)造函數(shù)的參數(shù)傳遞了產(chǎn)生這個(gè)事件的事件源（比如各種控件），方法getSource用來獲得這個(gè)事件源的引用。

DemoEvent.java

package demo.listener;   import java.util.EventObject;   public class DemoEvent extends EventObject {         Object obj;         public DemoEvent(Object source)         {                super(source);                obj = source;         }         public Object getSource()         {                return obj;         }         public void say()         {                System.out.println("This is say method...");         } }

 

（2）       定義新的事件監(jiān)聽接口，該接口繼承自EventListener；該接口包含對DemeEvent事件的處理程序：

DemoListener.java

package demo.listener;   import java.util.EventListener;   public interface DemoListener extends EventListener {        public void demoEvent(DemoEvent dm); }

 

通過上面的接口我們再定義事件監(jiān)聽類，這些類具體實(shí)現(xiàn)了監(jiān)聽功能和事件處理功能。回想一下上文中那四種實(shí)現(xiàn)方式，我們這里不正是使用了其中的第三種——外部類寫法的方式嗎？

Listener1.java

package demo.listener;   public class Listener1 implements DemoListener {        public void demoEvent(DemoEvent de)        {               System.out.println("Inside listener1...");        } }

Listener2.java

package demo.listener;   public class Listener2 implements DemoListener {        public void demoEvent(DemoEvent de)        {               System.out.println("Inside listener2...");        } }

Listener3.java

package demo.listener;   public class Listener3 implements DemoListener {        public void demoEvent(DemoEvent de)        {               System.out.println("Inside listener3...");        } }

 

（3）       通過DemeSource..ava文件創(chuàng)造一個(gè)事件源類，它用一個(gè)java.utile.Vector對象來存儲所有的事件監(jiān)聽器對象，存儲方式是通過addListener(..)這樣的方法。notifyDemeEvent(..)是觸發(fā)事件的方法，用來通知系統(tǒng)：事件發(fā)生了，你調(diào)用相應(yīng)的處理函數(shù)（回調(diào)函數(shù)）吧。

DemoSource.java

package demo.listener; import java.util.*;   public class DemoSource {        private Vector repository = new Vector();        DemoListener dl;        public DemoSource()        {          }        public void addDemoListener(DemoListener dl)        {               repository.addElement(dl);        }        public void notifyDemoEvent()        {               Enumeration enum = repository.elements();               while(enum.hasMoreElements())               {                     dl = (DemoListener)enum.nextElement();                     dl.demoEvent(new DemoEvent(this));               }        } }

 

             

（4）       好了，最后寫一個(gè)測試程序測試一下我們自定義的事件吧，這段程序應(yīng)該不難理解吧：）

TestDemo.java

package demo.listener;   public class TestDemo {        DemoSource ds;          public TestDemo()        {               try{                     ds = new DemoSource();                     Listener1 l1 = new Listener1();                     Listener2 l2 = new Listener2();                     Listener3 l3 = new Listener3();                       ds.addDemoListener(l1);                     ds.addDemoListener(l2);                     ds.addDemoListener(l3);                     ds.addDemoListener(new DemoListener(){                                public void demoEvent(DemoEvent event){                                          System.out.println("Method come from 匿名類...");                                }                        });                     ds.notifyDemoEvent();                 }catch(Exception ex)               {ex.printStackTrace();}        }          public static void main(String args[])        {               new TestDemo();        } }

1.
import java.net.InetAddress;
import java.net.UnknownHostException;

public class NetWork {

 //static fields and static block
 
    //InetAddress of the local host
 private static InetAddress local = null;
 
 //integer version of the local host
 private static int packedLocal = 0;
 
 static {
  try{
   local = InetAddress.getLocalHost();
  }catch(UnknownHostException e){
   e.printStackTrace();
  }

  System.out.println("localhost : " + local);
  packedLocal = translate(local);
 }
 
 public static InetAddress getLocalHost(){
  return local;
 }
 
 public static String getLocalHostName(){
  return local.getHostName();
 }
 
 public static String getLocalMachineName(){
  String hostname = local.getHostName();
  int machEndIndex = hostname.indexOf('.');
  if(machEndIndex == -1)
   return hostname;
  else
   return hostname.substring(0, machEndIndex);
 }
 
 public static boolean isLocal(InetAddress address){
  return local.equals(address);
 }
 
 public static boolean isLocal(int packedAddress){
  return packedAddress == packedLocal;
 }
 
 /**
  * return an integer representation of the specified
  * InetAddress. This is used for efficiency
  */
 public static int translate(InetAddress address){
  byte[] ad = address.getAddress();//原始IP地址
  if(ad.length != 4)
   throw new IllegalArgumentException("only accept 32-byte IP address");
  int packedAddress = ((ad[0] << 24) & 0xFF000000) |
       ((ad[1] << 16) & 0xFF0000) |
       ((ad[2] <<  8) & 0xFF00) |
       (ad[3] & 0xFF);
  return packedAddress;
 }
 
 /**
  * return an InetAddress representation of the specified integer.
  * This is used for performance improvements in serivalization.
  */
 public static InetAddress translate (int packed)
  throws UnknownHostException{
  int[] ad = new int[4];
     ad[0] = (packed  >>> 24);
     ad[1] = ((packed >>> 16) & 0x000000FF);
     ad[2] = ((packed >>>  8) & 0x000000FF);
     ad[3] = (packed          & 0x000000FF);
     StringBuffer buf = new StringBuffer();
     buf.append(ad[0]);
     buf.append(".");
     buf.append(ad[1]);
     buf.append(".");
     buf.append(ad[2]);
     buf.append(".");
     buf.append(ad[3]);
    
     return InetAddress.getByName(buf.toString());
 }
 
 public static String translateToString(int packed){
  int[] ad = new int[4];
  ad[0] = (packed >>> 24);
  ad[1] = ((packed >>> 16) & 0x000000FF);
  ad[2] = ((packed >>> 8) & 0x000000FF);
  ad[3] = (packed & 0x000000FF);
  
  StringBuffer buf = new StringBuffer();
  buf.append(ad[0]);
  buf.append(".");
  buf.append(ad[1]);
  buf.append(".");
  buf.append(ad[2]);
  buf.append(".");
  buf.append(ad[3]);
  
  return buf.toString();
 }
 
 public static void main(String[] args){
  InetAddress localhost = getLocalHost();
  System.out.println("Local Host Name is : " + getLocalHostName());
  System.out.println("Local Host Machine Name is : " + getLocalMachineName());
  if(isLocal(localhost))
   System.out.println(localhost.getHostName() + " is Local Host.");
  int intforaddress = translate(localhost);
  System.out.println("localhost integer representation is " + intforaddress);
  System.out.println("localhost string representation is " + translateToString(intforaddress));
  System.out.println(translateToString(intforaddress).toString());
  
 }
}

2. public interfece Externalizable extendx Serializable
Externalizable 實(shí)例類的惟一特性是可以被寫入序列化流中，該類負(fù)責(zé)保存和恢復(fù)實(shí)例內(nèi)容。 若某個(gè)要完全控制某一對象及其超類型的流格式和內(nèi)容，則它要實(shí)現(xiàn) Externalizable 接口的 writeExternal 和 readExternal 方法。這些方法必須顯式與超類型進(jìn)行協(xié)調(diào)以保存其狀態(tài)。這些方法將代替自定義的 writeObject 和 readObject 方法實(shí)現(xiàn)。
Serialization 對象將使用 Serializable 和 Externalizable 接口。對象持久性機(jī)制也可以使用它們。要存儲的每個(gè)對象都需要檢測是否支持 Externalizable 接口。如果對象支持 Externalizable，則調(diào)用 writeExternal 方法。如果對象不支持 Externalizable 但實(shí)現(xiàn)了 Serializable，則使用 ObjectOutputStream 保存該對象。
在重構(gòu) Externalizable 對象時(shí)，先使用無參數(shù)的公共構(gòu)造方法創(chuàng)建一個(gè)實(shí)例，然后調(diào)用 readExternal 方法。通過從 ObjectInputStream 中讀取 Serializable 對象可以恢復(fù)這些對象。
Externalizable 實(shí)例可以通過 Serializable 接口中記錄的 writeReplace 和 readResolve 方法來指派一個(gè)替代對象。

writeExternal

void writeExternal(ObjectOutput out)
throws IOException

該對象可實(shí)現(xiàn) writeExternal 方法來保存其內(nèi)容，它可以通過調(diào)用 DataOutput 的方法來保存其基本值，或調(diào)用 ObjectOutput 的 writeObject 方法來保存對象、字符串和數(shù)組。

 

參數(shù)：

out - 要寫入對象的流

拋出：

IOException - 包含可能發(fā)生的所有 I/O 異常

readExternal

void readExternal(ObjectInput in)
throws IOException,
ClassNotFoundException

對象實(shí)現(xiàn) readExternal 方法來恢復(fù)其內(nèi)容，它通過調(diào)用 DataInput 的方法來恢復(fù)其基礎(chǔ)類型，調(diào)用 readObject 來恢復(fù)對象、字符串和數(shù)組。readExternal 方法必須按照與 writeExternal 方法寫入值時(shí)使用的相同順序和類型來讀取這些值。

 

參數(shù)：

in - 為了恢復(fù)對象而從中讀取數(shù)據(jù)的流

拋出：

IOException - 如果發(fā)生 I/O 錯(cuò)誤

ClassNotFoundException - 如果無法找到需要恢復(fù)的某個(gè)對象的類。

import java.io.Externalizable;
import java.net.InetAddress;

public interface EndPoint extends Externalizable {

 /**
  *
  * @return Returns the IP address contained in this endpoint.
  */
 public InetAddress getAddress();
 
 /**
  * returns the IP address contained in this endpoint.
  * enclosed in an integer value.
  */
 public int getIntAddress();
 
 /**
  * Returns the port number contained in this endpoint.
  */
 public int getPort();
 
 
 /**
  * Return true if this endpoint is the local endpoint.
  */
 public boolean isLocal();
 
 /**
  * Returns true if this endpoint is a multicast endpoint.
  */
 public boolean isMulticastEndPoint();
}

import internet.network.NetWork;

import java.io.Externalizable;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectInputStream;
import java.io.ObjectOutput;
import java.io.ObjectOutputStream;
import java.net.InetAddress;
import java.net.UnknownHostException;

public class EndPointImpl implements EndPoint, Comparable, Externalizable{

 //Constants
 
 /* Size of this object (in bytes) when marshalled. */
 public static final int SIZE = 6;
 
 //Fields
 protected InetAddress address;
 
 private int packedAddress;
 
 private int port;
 
 protected boolean local;
 
 //Constructors
 
 /**
  * Default constructor for externalization
  */
 public EndPointImpl(){
  
 }
 
 public EndPointImpl(InetAddress address, int port){
  this.address = address;
  this.port = port;
  packedAddress = NetWork.translate(address);
  local = NetWork.isLocal(packedAddress);
 }
 
 public EndPointImpl(int packedAddress, int port){
  this.packedAddress = packedAddress;
  this.port = port;
  this.local = NetWork.isLocal(packedAddress);
  //The InetAddress version of the address is computed
  //only when needed, to avoid uselesss DNS lookups.
  address = null;
 }
 
 public InetAddress getAddress() {
  if(address == null)
   try{
    address = NetWork.translate(packedAddress);
   }catch(UnknownHostException e){
    System.out.println(e.getMessage());
   }
   return address;
 }

 public int getIntAddress() {
  return this.packedAddress;
 }

 public int getPort() {
  return this.port;
 }

 public boolean isLocal() {
  return this.local;
 }

 public boolean isMulticastEndPoint() {
  return address.isMulticastAddress();
 }
 
 
 ////////////////////////////////////////////////////////////
 // Methods from Externalizable
 ////////////////////////////////////////////////////////////

 /**
  * Restores the content of this object form the marshaled data contained
  * in the specified input stream.
  *
  * @param in the stream to be read.
  */
 public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
  
  packedAddress = in.readInt();
  port = (int) in.readUnsignedShort();
  local = NetWork.isLocal(packedAddress);
  address = null;
 }

 /**
  * Marshals the content of this object to the specified output stream.
  *
  * @param out the stream to be written
  */
 public void writeExternal(ObjectOutput out) throws IOException {
  
  out.writeInt(packedAddress);
  out.writeShort(port);
 }

 
 ////////////////////////////////////////////////////////////
 // Methods from Object and Comparable
 ////////////////////////////////////////////////////////////
 /**
  *  Compares this object with the specified object for order.
  */
 public int compareTo(Object obj) {
  if(this == obj){
   return 0;
  }
  else{
   EndPointImpl endpoint = (EndPointImpl) obj;
   if(packedAddress < endpoint.packedAddress){
    return -1;
   }
   else if(packedAddress == endpoint.packedAddress){
    if(port < endpoint.port)
     return -1;
    else if(port == endpoint.port)
     return 0;
    else
     return 1;
   }
   else{
    return 1;
   }
  }
 }
 
 public int hashcode(){
  return packedAddress ^ port;
 }

 /**
  * Compares two EndPointImpl objects for content equality.
  */
 public boolean equals (Object obj){
  if(!(obj instanceof EndPointImpl))
   return false;
  EndPointImpl endpoint = (EndPointImpl) obj;
  return (endpoint.packedAddress == packedAddress && endpoint.port == port);
 }
 
 /**
  * Returns a string representation of this object.
  */
 public String toString(){
  StringBuffer buf = new StringBuffer();
  buf.append("[");
  buf.append(NetWork.translateToString(packedAddress));
  buf.append(":");
  buf.append(port);
  buf.append("]");
  
  return buf.toString();
 }
 
 
 public static void main(String[] args) throws FileNotFoundException, IOException{
  InetAddress localhost = NetWork.getLocalHost();
  EndPointImpl endpoint = new EndPointImpl(localhost, 100);
  System.out.println("This EndPoint is : " + endpoint.toString());
  EndPointImpl endpoint2 = new EndPointImpl();
  ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("endpoint.txt"));
  try {
   endpoint.writeExternal(oos);
  } catch (IOException e) {
   e.printStackTrace();
  }
  oos.close();
  
  ObjectInputStream ios = new ObjectInputStream(new FileInputStream("endpoint.txt"));
  try {
   endpoint2.readExternal(ios);
  } catch (IOException e) {
   e.printStackTrace();
  } catch (ClassNotFoundException e) {
   e.printStackTrace();
  }
  ios.close();
  System.out.println("This EndPoint is : " + endpoint2.toString());
 }
}

類Deflater 和 類Inflater：此類使用流行的 ZLIB 壓縮程序庫為通用壓縮提供支持。ZLIB 壓縮程序庫最初是作為 PNG 圖形標(biāo)準(zhǔn)的一部分開發(fā)的，不受專利的保護(hù)。

  //encoding a string into bytes
  String inputString = "chenweicai";
  byte[] input = inputString.getBytes("UTF-8");
  System.out.println("before compressed, the bytes length is :" + input.length);
  
  //compress the bytes
  byte[] output = new byte[100];
  Deflater compresser = new Deflater();
  compresser.setInput(input);
  compresser.finish();
  int compressedDataLength = compresser.deflate(output);
  System.out.println("compressed bytes length is :" + compressedDataLength);
  
  //decompress the bytes
  Inflater decompresser = new Inflater();
  decompresser.setInput(output, 0, compressedDataLength);
  byte[] result = new byte[100];
  int resultLength = decompresser.inflate(result);
  decompresser.end();
  System.out.println("after decompressed, the bytes length is :" + resultLength);
  
  //decode the bytes into a string
  String outputString = new String(result, 0, resultLength, "UTF-8");
  System.out.println("after compress and decompress the string is :" + outputString);


2.


import java.io.Serializable;

public class Employee implements Serializable {

 private String name;
 
 private double salary;

 public Employee(String name, double salary) {
  super();
  // TODO Auto-generated constructor stub
  this.name = name;
  this.salary = salary;
 }
 
 public void raiseSalary(double byPercent){
  double temp = salary * byPercent / 100;
  salary += temp;
 }

 public String toString() {
  // TODO Auto-generated method stub
  return getClass().getName() +
   "[ Name = " + name + ", salary = " + salary +"]";
 }
 
}





public class Test2 {

 protected byte[] deflate(Object object) throws IOException{
  
  ByteArrayOutputStream baos = new ByteArrayOutputStream();
  Deflater def = new Deflater (Deflater.BEST_COMPRESSION);
  DeflaterOutputStream dos = new DeflaterOutputStream(baos, def);
  
  ObjectOutputStream out = new ObjectOutputStream(dos);
  out.writeObject(object);
  out.close();
  dos.finish();
  dos.close();
  
  return baos.toByteArray();
 }
 
 protected Object inflate(byte[] compressedContent) throws IOException{
  if(compressedContent == null)
   return null;
  
  try{
   ObjectInputStream in = new ObjectInputStream(
     new InflaterInputStream(new ByteArrayInputStream(compressedContent)));
   Object object = in.readObject();
   in.close();
   return object;
  }catch(Exception e){
   throw new IOException(e.toString());
  }
 }
 
 public static void main(String[] args) throws IOException{
  Employee employee = new Employee("LiLei", 1000);
  Test2 test2 = new Test2();
  byte[] bytes = new byte[1000];
  
  bytes = test2.deflate(employee);
  System.out.println(bytes);
  
  System.out.println(test2.inflate(bytes));
  
 }
}

　 JDK為程序員提供了大量的類庫，而為了保持類庫的可重用性，可擴(kuò)展性和靈活性，其中使用到了大量的設(shè)計(jì)模式，本文將介紹JDK的I/O包中使用到的Decorator模式，并運(yùn)用此模式，實(shí)現(xiàn)一個(gè)新的輸出流類。

　　Decorator模式簡介

　　Decorator模式又名包裝器(Wrapper)，它的主要用途在于給一個(gè)對象動態(tài)的添加一些額外的職責(zé)。與生成子類相比，它更具有靈活性。
有時(shí)候，我們需要為一個(gè)對象而不是整個(gè)類添加一些新的功能，比如，給一個(gè)文本區(qū)添加一個(gè)滾動條的功能。我們可以使用繼承機(jī)制來實(shí)現(xiàn)這一功能，但是這種方法不夠靈活，我們無法控制文本區(qū)加滾動條的方式和時(shí)機(jī)。而且當(dāng)文本區(qū)需要添加更多的功能時(shí)，比如邊框等，需要創(chuàng)建新的類，而當(dāng)需要組合使用這些功能時(shí)無疑將會引起類的爆炸。

　　我們可以使用一種更為靈活的方法，就是把文本區(qū)嵌入到滾動條中。而這個(gè)滾動條的類就相當(dāng)于對文本區(qū)的一個(gè)裝飾。這個(gè)裝飾(滾動條)必須與被裝飾的組件(文本區(qū))繼承自同一個(gè)接口，這樣，用戶就不必關(guān)心裝飾的實(shí)現(xiàn)，因?yàn)檫@對他們來說是透明的。裝飾會將用戶的請求轉(zhuǎn)發(fā)給相應(yīng)的組件(即調(diào)用相關(guān)的方法)，并可能在轉(zhuǎn)發(fā)的前后做一些額外的動作(如添加滾動條)。通過這種方法，我們可以根據(jù)組合對文本區(qū)嵌套不同的裝飾，從而添加任意多的功能。這種動態(tài)的對對象添加功能的方法不會引起類的爆炸，也具有了更多的靈活性。

　　以上的方法就是Decorator模式，它通過給對象添加裝飾來動態(tài)的添加新的功能。如下是Decorator模式的UML圖：



　　Component為組件和裝飾的公共父類，它定義了子類必須實(shí)現(xiàn)的方法。

　　ConcreteComponent是一個(gè)具體的組件類，可以通過給它添加裝飾來增加新的功能。

　　Decorator是所有裝飾的公共父類，它定義了所有裝飾必須實(shí)現(xiàn)的方法，同時(shí)，它還保存了一個(gè)對于Component的引用，以便將用戶的請求轉(zhuǎn)發(fā)給Component，并可能在轉(zhuǎn)發(fā)請求前后執(zhí)行一些附加的動作。

　　ConcreteDecoratorA和ConcreteDecoratorB是具體的裝飾，可以使用它們來裝飾具體的Component。

　　Java IO包中的Decorator模式

　　JDK提供的java.io包中使用了Decorator模式來實(shí)現(xiàn)對各種輸入輸出流的封裝。以下將以java.io.OutputStream及其子類為例，討論一下Decorator模式在IO中的使用。

　　首先來看一段用來創(chuàng)建IO流的代碼：

以下是代碼片段： try { 　OutputStream out = new DataOutputStream(new FileOutputStream("test.txt")); } catch (FileNotFoundException e) { 　e.printStackTrace(); }

　　這段代碼對于使用過JAVA輸入輸出流的人來說再熟悉不過了，我們使用DataOutputStream封裝了一個(gè)FileOutputStream。這是一個(gè)典型的Decorator模式的使用，F(xiàn)ileOutputStream相當(dāng)于Component，DataOutputStream就是一個(gè)Decorator。將代碼改成如下，將會更容易理解：

以下是代碼片段： try { 　OutputStream out = new FileOutputStream("test.txt"); 　out = new DataOutputStream(out); } catch(FileNotFoundException e) { 　e.printStatckTrace(); }

　　由于FileOutputStream和DataOutputStream有公共的父類OutputStream，因此對對象的裝飾對于用戶來說幾乎是透明的。下面就來看看OutputStream及其子類是如何構(gòu)成Decorator模式的：



　　OutputStream是一個(gè)抽象類，它是所有輸出流的公共父類，其源代碼如下：

以下是代碼片段： public abstract class OutputStream implements Closeable, Flushable { 　public abstract void write(int b) throws IOException; 　... }

　　它定義了write(int b)的抽象方法。這相當(dāng)于Decorator模式中的Component類。

　　ByteArrayOutputStream，F(xiàn)ileOutputStream 和 PipedOutputStream 三個(gè)類都直接從OutputStream繼承，以ByteArrayOutputStream為例：

以下是代碼片段： public class ByteArrayOutputStream extends OutputStream { 　protected byte buf[]; 　protected int count; 　public ByteArrayOutputStream() { 　　this(32); 　} 　public ByteArrayOutputStream(int size) { 　　if (size 〈 0) { 　　　throw new IllegalArgumentException("Negative initial size: " + size); 　　} 　　buf = new byte[size]; 　} 　public synchronized void write(int b) { 　　int newcount = count + 1; 　　if (newcount 〉 buf.length) { 　　　byte newbuf[] = new byte[Math.max(buf.length 〈〈 1, newcount)]; 　　　System.arraycopy(buf, 0, newbuf, 0, count); 　　　buf = newbuf; 　　} 　　buf[count] = (byte)b; 　　count = newcount; 　} 　... }

　　它實(shí)現(xiàn)了OutputStream中的write(int b)方法，因此我們可以用來創(chuàng)建輸出流的對象，并完成特定格式的輸出。它相當(dāng)于Decorator模式中的ConcreteComponent類。

　　接著來看一下FilterOutputStream，代碼如下：

以下是代碼片段： public class FilterOutputStream extends OutputStream { 　protected OutputStream out; 　public FilterOutputStream(OutputStream out) { 　　this.out = out; 　} 　public void write(int b) throws IOException { 　　out.write(b); 　} 　... }

　　同樣，它也是從OutputStream繼承。但是，它的構(gòu)造函數(shù)很特別，需要傳遞一個(gè)OutputStream的引用給它，并且它將保存對此對象的引用。而如果沒有具體的OutputStream對象存在，我們將無法創(chuàng)建FilterOutputStream。由于out既可以是指向FilterOutputStream類型的引用，也可以是指向ByteArrayOutputStream等具體輸出流類的引用，因此使用多層嵌套的方式，我們可以為ByteArrayOutputStream添加多種裝飾。這個(gè)FilterOutputStream類相當(dāng)于Decorator模式中的Decorator類，它的write(int b)方法只是簡單的調(diào)用了傳入的流的write(int b)方法，而沒有做更多的處理，因此它本質(zhì)上沒有對流進(jìn)行裝飾，所以繼承它的子類必須覆蓋此方法，以達(dá)到裝飾的目的。

　　BufferedOutputStream 和 DataOutputStream是FilterOutputStream的兩個(gè)子類，它們相當(dāng)于Decorator模式中的ConcreteDecorator，并對傳入的輸出流做了不同的裝飾。以BufferedOutputStream類為例：

以下是代碼片段： public class BufferedOutputStream extends FilterOutputStream { 　... 　private void flushBuffer() throws IOException { 　　if (count 〉 0) { 　　　out.write(buf, 0, count); 　　　count = 0; 　　} 　} 　public synchronized void write(int b) throws IOException { 　　if (count 〉= buf.length) { 　　　flushBuffer(); 　　} 　　buf[count++] = (byte)b; 　} 　... }

　　這個(gè)類提供了一個(gè)緩存機(jī)制，等到緩存的容量達(dá)到一定的字節(jié)數(shù)時(shí)才寫入輸出流。首先它繼承了FilterOutputStream，并且覆蓋了父類的write(int b)方法，在調(diào)用輸出流寫出數(shù)據(jù)前都會檢查緩存是否已滿，如果未滿，則不寫。這樣就實(shí)現(xiàn)了對輸出流對象動態(tài)的添加新功能的目的。

　　下面，將使用Decorator模式，為IO寫一個(gè)新的輸出流。　 JDK為程序員提供了大量的類庫，而為了保持類庫的可重用性，可擴(kuò)展性和靈活性，其中使用到了大量的設(shè)計(jì)模式，本文將介紹JDK的I/O包中使用到的Decorator模式，并運(yùn)用此模式，實(shí)現(xiàn)一個(gè)新的輸出流類。

　　Decorator模式簡介

　　Decorator模式又名包裝器(Wrapper)，它的主要用途在于給一個(gè)對象動態(tài)的添加一些額外的職責(zé)。與生成子類相比，它更具有靈活性。
有時(shí)候，我們需要為一個(gè)對象而不是整個(gè)類添加一些新的功能，比如，給一個(gè)文本區(qū)添加一個(gè)滾動條的功能。我們可以使用繼承機(jī)制來實(shí)現(xiàn)這一功能，但是這種方法不夠靈活，我們無法控制文本區(qū)加滾動條的方式和時(shí)機(jī)。而且當(dāng)文本區(qū)需要添加更多的功能時(shí)，比如邊框等，需要創(chuàng)建新的類，而當(dāng)需要組合使用這些功能時(shí)無疑將會引起類的爆炸。

　　我們可以使用一種更為靈活的方法，就是把文本區(qū)嵌入到滾動條中。而這個(gè)滾動條的類就相當(dāng)于對文本區(qū)的一個(gè)裝飾。這個(gè)裝飾(滾動條)必須與被裝飾的組件(文本區(qū))繼承自同一個(gè)接口，這樣，用戶就不必關(guān)心裝飾的實(shí)現(xiàn)，因?yàn)檫@對他們來說是透明的。裝飾會將用戶的請求轉(zhuǎn)發(fā)給相應(yīng)的組件(即調(diào)用相關(guān)的方法)，并可能在轉(zhuǎn)發(fā)的前后做一些額外的動作(如添加滾動條)。通過這種方法，我們可以根據(jù)組合對文本區(qū)嵌套不同的裝飾，從而添加任意多的功能。這種動態(tài)的對對象添加功能的方法不會引起類的爆炸，也具有了更多的靈活性。

　　以上的方法就是Decorator模式，它通過給對象添加裝飾來動態(tài)的添加新的功能。如下是Decorator模式的UML圖：



　　Component為組件和裝飾的公共父類，它定義了子類必須實(shí)現(xiàn)的方法。

　　ConcreteComponent是一個(gè)具體的組件類，可以通過給它添加裝飾來增加新的功能。

　　Decorator是所有裝飾的公共父類，它定義了所有裝飾必須實(shí)現(xiàn)的方法，同時(shí)，它還保存了一個(gè)對于Component的引用，以便將用戶的請求轉(zhuǎn)發(fā)給Component，并可能在轉(zhuǎn)發(fā)請求前后執(zhí)行一些附加的動作。

　　ConcreteDecoratorA和ConcreteDecoratorB是具體的裝飾，可以使用它們來裝飾具體的Component。

　　Java IO包中的Decorator模式

　　JDK提供的java.io包中使用了Decorator模式來實(shí)現(xiàn)對各種輸入輸出流的封裝。以下將以java.io.OutputStream及其子類為例，討論一下Decorator模式在IO中的使用。

　　首先來看一段用來創(chuàng)建IO流的代碼：

以下是代碼片段： try { 　OutputStream out = new DataOutputStream(new FileOutputStream("test.txt")); } catch (FileNotFoundException e) { 　e.printStackTrace(); }

　　這段代碼對于使用過JAVA輸入輸出流的人來說再熟悉不過了，我們使用DataOutputStream封裝了一個(gè)FileOutputStream。這是一個(gè)典型的Decorator模式的使用，F(xiàn)ileOutputStream相當(dāng)于Component，DataOutputStream就是一個(gè)Decorator。將代碼改成如下，將會更容易理解：

以下是代碼片段： try { 　OutputStream out = new FileOutputStream("test.txt"); 　out = new DataOutputStream(out); } catch(FileNotFoundException e) { 　e.printStatckTrace(); }

　　由于FileOutputStream和DataOutputStream有公共的父類OutputStream，因此對對象的裝飾對于用戶來說幾乎是透明的。下面就來看看OutputStream及其子類是如何構(gòu)成Decorator模式的：



　　OutputStream是一個(gè)抽象類，它是所有輸出流的公共父類，其源代碼如下：

以下是代碼片段： public abstract class OutputStream implements Closeable, Flushable { 　public abstract void write(int b) throws IOException; 　... }

　　它定義了write(int b)的抽象方法。這相當(dāng)于Decorator模式中的Component類。

　　ByteArrayOutputStream，F(xiàn)ileOutputStream 和 PipedOutputStream 三個(gè)類都直接從OutputStream繼承，以ByteArrayOutputStream為例：

以下是代碼片段： public class ByteArrayOutputStream extends OutputStream { 　protected byte buf[]; 　protected int count; 　public ByteArrayOutputStream() { 　　this(32); 　} 　public ByteArrayOutputStream(int size) { 　　if (size 〈 0) { 　　　throw new IllegalArgumentException("Negative initial size: " + size); 　　} 　　buf = new byte[size]; 　} 　public synchronized void write(int b) { 　　int newcount = count + 1; 　　if (newcount 〉 buf.length) { 　　　byte newbuf[] = new byte[Math.max(buf.length 〈〈 1, newcount)]; 　　　System.arraycopy(buf, 0, newbuf, 0, count); 　　　buf = newbuf; 　　} 　　buf[count] = (byte)b; 　　count = newcount; 　} 　... }

　　它實(shí)現(xiàn)了OutputStream中的write(int b)方法，因此我們可以用來創(chuàng)建輸出流的對象，并完成特定格式的輸出。它相當(dāng)于Decorator模式中的ConcreteComponent類。

　　接著來看一下FilterOutputStream，代碼如下：

以下是代碼片段： public class FilterOutputStream extends OutputStream { 　protected OutputStream out; 　public FilterOutputStream(OutputStream out) { 　　this.out = out; 　} 　public void write(int b) throws IOException { 　　out.write(b); 　} 　... }

　　同樣，它也是從OutputStream繼承。但是，它的構(gòu)造函數(shù)很特別，需要傳遞一個(gè)OutputStream的引用給它，并且它將保存對此對象的引用。而如果沒有具體的OutputStream對象存在，我們將無法創(chuàng)建FilterOutputStream。由于out既可以是指向FilterOutputStream類型的引用，也可以是指向ByteArrayOutputStream等具體輸出流類的引用，因此使用多層嵌套的方式，我們可以為ByteArrayOutputStream添加多種裝飾。這個(gè)FilterOutputStream類相當(dāng)于Decorator模式中的Decorator類，它的write(int b)方法只是簡單的調(diào)用了傳入的流的write(int b)方法，而沒有做更多的處理，因此它本質(zhì)上沒有對流進(jìn)行裝飾，所以繼承它的子類必須覆蓋此方法，以達(dá)到裝飾的目的。

　　BufferedOutputStream 和 DataOutputStream是FilterOutputStream的兩個(gè)子類，它們相當(dāng)于Decorator模式中的ConcreteDecorator，并對傳入的輸出流做了不同的裝飾。以BufferedOutputStream類為例：

以下是代碼片段： public class BufferedOutputStream extends FilterOutputStream { 　... 　private void flushBuffer() throws IOException { 　　if (count 〉 0) { 　　　out.write(buf, 0, count); 　　　count = 0; 　　} 　} 　public synchronized void write(int b) throws IOException { 　　if (count 〉= buf.length) { 　　　flushBuffer(); 　　} 　　buf[count++] = (byte)b; 　} 　... }

　　這個(gè)類提供了一個(gè)緩存機(jī)制，等到緩存的容量達(dá)到一定的字節(jié)數(shù)時(shí)才寫入輸出流。首先它繼承了FilterOutputStream，并且覆蓋了父類的write(int b)方法，在調(diào)用輸出流寫出數(shù)據(jù)前都會檢查緩存是否已滿，如果未滿，則不寫。這樣就實(shí)現(xiàn)了對輸出流對象動態(tài)的添加新功能的目的。

　　下面，將使用Decorator模式，為IO寫一個(gè)新的輸出流。


自己寫一個(gè)新的輸出流

　　了解了OutputStream及其子類的結(jié)構(gòu)原理后，我們可以寫一個(gè)新的輸出流，來添加新的功能。這部分中將給出一個(gè)新的輸出流的例子，它將過濾待輸出語句中的空格符號。比如需要輸出"java io OutputStream"，則過濾后的輸出為"javaioOutputStream"。以下為SkipSpaceOutputStream類的代碼：

以下是代碼片段： import java.io.FilterOutputStream; import java.io.IOException; import java.io.OutputStream; /** * A new output stream, which will check the space character * and won’t write it to the output stream. * @author Magic * */ public class SkipSpaceOutputStream extends FilterOutputStream { 　public SkipSpaceOutputStream(OutputStream out) { 　　super(out); 　} 　/** 　* Rewrite the method in the parent class, and 　* skip the space character. 　*/ 　public void write(int b) throws IOException{ 　　if(b!=’ ’){ 　　　super.write(b); 　　} 　} }

　　它從FilterOutputStream繼承，并且重寫了它的write(int b)方法。在write(int b)方法中首先對輸入字符進(jìn)行了檢查，如果不是空格，則輸出。

　　以下是一個(gè)測試程序：

以下是代碼片段： import java.io.BufferedInputStream; import java.io.DataInputStream; import java.io.DataOutputStream; import java.io.IOException; import java.io.InputStream; import java.io.OutputStream; /** * Test the SkipSpaceOutputStream. * @author Magic * */ public class Test { 　public static void main(String[] args){ 　　byte[] buffer = new byte[1024]; 　　/** 　　* Create input stream from the standard input. 　　*/ 　　InputStream in = new BufferedInputStream(new DataInputStream(System.in)); 　　/** 　　* write to the standard output. 　　*/ 　　OutputStream out = new SkipSpaceOutputStream(new DataOutputStream(System.out)); 　　try { 　　　System.out.println("Please input your words: "); 　　　int n = in.read(buffer,0,buffer.length); 　　　for(int i=0;i〈n;i++){ 　　　　out.write(buffer[i]); 　　　} 　　} catch (IOException e) { 　　　e.printStackTrace(); 　　} 　} }

　　執(zhí)行以上測試程序，將要求用戶在console窗口中輸入信息，程序?qū)⑦^濾掉信息中的空格，并將最后的結(jié)果輸出到console窗口。比如：

以下是引用片段： Please input your words: a b c d e f abcdef

　　總 結(jié)

　　在java.io包中，不僅OutputStream用到了Decorator設(shè)計(jì)模式，InputStream，Reader，Writer等都用到了此模式。而作為一個(gè)靈活的，可擴(kuò)展的類庫，JDK中使用了大量的設(shè)計(jì)模式，比如在Swing包中的MVC模式，RMI中的Proxy模式等等。對于JDK中模式的研究不僅能加深對于模式的理解，而且還有利于更透徹的了解類庫的結(jié)構(gòu)和組成。