MikeChen專注電子商務(wù)

一：使用場(chǎng)景

   1）使用的地方：樹形結(jié)構(gòu)，分支結(jié)構(gòu)等

   2）使用的好處：降低客戶端的使用，為了達(dá)到元件與組合件使用的一致性，增加了元件的編碼

   3）使用后的壞處：代碼不容易理解，需要你認(rèn)真去研究，發(fā)現(xiàn)元件與組合件是怎么組合的

二：一個(gè)實(shí)際的例子

    畫圖形，這個(gè)模式，稍微要難理解一點(diǎn)，有了例子就說(shuō)明了一切，我畫的圖是用接口做的，代碼實(shí)現(xiàn)是抽象類為基類，你自己選擇了，接口也可以。

1）先建立圖形元件

   package com.mike.pattern.structure.composite;
/**
* 圖形元件
* 
* @author taoyu
* 
* @since 2010-6-23
*/
public abstract class Graph {
/**圖形名稱*/
protected String name;

public Graph(String name){
   this.name=name;
}

/**畫圖*/
public abstract void draw()throws GraphException;

/**添加圖形*/
public abstract void add(Graph graph)throws GraphException;

/**移掉圖形*/
public abstract void remove(Graph graph)throws GraphException;

}

2)建立基礎(chǔ)圖形圓

package com.mike.pattern.structure.composite;
import static com.mike.util.Print.print;

/**
* 圓圖形
* 
* @author taoyu
* 
* @since 2010-6-23
*/
public class Circle extends Graph {

public Circle(String name){
   super(name);
}

/**
* 圓添加圖形
* @throws GraphException 
*/
@Override
public void add(Graph graph) throws GraphException {
   throw new GraphException("圓是基礎(chǔ)圖形，不能添加");
}

/**
* 圓畫圖
*/
@Override
public void draw()throws GraphException {
   print(name+"畫好了");
}

/**
* 圓移掉圖形
*/
@Override
public void remove(Graph graph)throws GraphException {
   throw new GraphException("圓是基礎(chǔ)圖形，不能移掉");
}

}

3）建立基礎(chǔ)圖形長(zhǎng)方形

package com.mike.pattern.structure.composite;
import static com.mike.util.Print.print;
/**
* 長(zhǎng)方形
* 
* @author taoyu
* 
* @since 2010-6-23
*/
public class Rectangle extends Graph {

public Rectangle(String name){
   super(name);
}

/**
* 長(zhǎng)方形添加
*/
@Override
public void add(Graph graph) throws GraphException {
   throw new GraphException("長(zhǎng)方形是基礎(chǔ)圖形，不能添加");
}

/**
* 畫長(zhǎng)方形
*/
@Override
public void draw() throws GraphException {
   print(name+"畫好了");
}

@Override
public void remove(Graph graph) throws GraphException {
   throw new GraphException("長(zhǎng)方形是基礎(chǔ)圖形，不能移掉");
}

}

4）最后簡(jiǎn)歷組合圖形

package com.mike.pattern.structure.composite;

import java.util.ArrayList;
import java.util.List;
import static com.mike.util.Print.print;

/**
* 圖形組合體
* 
* @author taoyu
* 
* @since 2010-6-23
*/
public class Picture extends Graph {
private List<Graph> graphs;

public Picture(String name){
   super(name);
   /**默認(rèn)是10個(gè)長(zhǎng)度*/
   graphs=new ArrayList<Graph>();
}


/**
* 添加圖形元件
*/
@Override
public void add(Graph graph) throws GraphException {
   graphs.add(graph);
}

/**
* 圖形元件畫圖
*/
@Override
public void draw() throws GraphException {
   print("圖形容器："+name+" 開始創(chuàng)建");
   for(Graph g : graphs){
    g.draw();
   }
}

/**
* 圖形元件移掉圖形元件
*/
@Override
public void remove(Graph graph) throws GraphException {
   graphs.remove(graph);
}

}

5）最后測(cè)試

public static void main(String[] args)throws GraphException {
   /**畫一個(gè)圓，圓里包含一個(gè)圓和長(zhǎng)方形*/
   Picture picture=new Picture("立方體圓");
   picture.add(new Circle("圓"));
   picture.add(new Rectangle("長(zhǎng)方形"));
  
   Picture root=new Picture("怪物圖形"); 
   root.add(new Circle("圓"));
   root.add(picture);
   root.draw();
}

6)使用心得：的確降低了客戶端的使用情況，讓整個(gè)圖形可控了，當(dāng)是你要深入去理解，才真名明白采用該模式的含義，不太容易理解。

一：使用場(chǎng)景

     1）使用的地方：我想使用兩個(gè)不同類的方法，這個(gè)時(shí)候你需要把它們組合起來(lái)使用

     2）目前使用的情況：我會(huì)把兩個(gè)類用戶組合的方式放到一起，編程思想think in java里已經(jīng)提到個(gè)，能盡量用組合就用組合，繼承一般考慮再后。

     3）使用后的好處：你不需要改動(dòng)以前的代碼，只是新封裝了一新類，由這個(gè)類來(lái)提供兩個(gè)類的方法，這個(gè)時(shí)候：一定會(huì)想到facade外觀模式，本來(lái)是多個(gè)類使用的情況，我新封裝成一個(gè)類來(lái)使用，而這個(gè)類我采用組合的方式來(lái)包裝新的方法。我的理解是，設(shè)計(jì)模式本身就是為了幫助解決特定的業(yè)務(wù)場(chǎng)景而故意把模式劃分對(duì)應(yīng)的模式類別，其實(shí)大多數(shù)情況，都解決了同樣的問(wèn)題，這個(gè)時(shí)候其實(shí)沒(méi)有必要過(guò)多的糾纏到模式的名字上了，你有好的注意，你甚至取一個(gè)新的名字來(lái)概括這樣的使用場(chǎng)景。

    4）使用的壞處：適配器模式，有兩種方式來(lái)實(shí)現(xiàn)。一個(gè)是組合一個(gè)是繼承，我覺(jué)得，首先應(yīng)該考慮組合，能用組合就不要用繼承，這是第一個(gè)。第二個(gè)，你采用繼承來(lái)實(shí)現(xiàn)，那肯定會(huì)加大繼承樹結(jié)構(gòu)，如果你的繼承關(guān)系本身就很復(fù)雜了，這肯定會(huì)加大繼承關(guān)系的維護(hù)，不有利于代碼的理解，或則更加繁瑣。繼承是為了解決重用的為題而出現(xiàn)的，所以我覺(jué)得不應(yīng)該濫用繼承，有機(jī)會(huì)可以考慮同樣別的方案。

二：一個(gè)實(shí)際的例子

      關(guān)聯(lián)營(yíng)銷的例子，用戶購(gòu)買完商品后，我又推薦他相關(guān)別的商品

      由于減少代碼，方法我都不采用接口，直接由類來(lái)提供，代碼只是一個(gè)范例而已，都精簡(jiǎn)了。

1)創(chuàng)建訂單信息

public class Order {
private Long orderId;
private String nickName;

public Order(Long orderId,String nickName){
   this.orderId=orderId;
   this.nickName=nickName;
}

/**
* 用戶下訂單
*/
public void insertOrder(){
  
}
}

2）商品信息

public class Auction {
/**商品名稱*/
private String name;

/**制造商*/
private String company;

/**制造日期*/
private Date date;


public Auction(String name,String company, Date date){
   this.name=name;
   this.company=company;
   this.date=date;
}

/**
* 推廣的商品列表
*/
public void commendAuction(){
  
}

}

3）購(gòu)物

public class Trade {
/**用戶訂單*/
private Order order;

/**商品信息*/
private Auction auction;

public Trade(Order order ,Auction auction){
   this.order=order;
   this.auction=auction;
}

/**
* 用戶產(chǎn)生訂單以及后續(xù)的事情
*/
public void trade(){
   /**下訂單*/
   order.insertOrder();
  
   /**關(guān)聯(lián)推薦相關(guān)的商品*/
   auction.commendAuction();
}

}

   4）使用心得：其實(shí)外面采用了很多繼承的方式，order繼承auction之后，利用super .inserOrder()再加一個(gè)auction.recommendAuction(),實(shí)際上大同小異，我到覺(jué)得采用組合更容易理解以及代碼更加優(yōu)美點(diǎn)。

一：使用場(chǎng)景

   1)使用到的地方：如果你想創(chuàng)建類似汽車這樣的對(duì)象，首先要?jiǎng)?chuàng)建輪子，玻璃，桌椅，發(fā)動(dòng)機(jī)，外廓等，這些部件都創(chuàng)建好后，最后創(chuàng)建汽車成品，部件的創(chuàng)建和汽車的組裝過(guò)程本身都很復(fù)雜的情況，希望把部件的創(chuàng)建和成品的組裝分開來(lái)做，這樣把要做的事情分割開來(lái)，降低對(duì)象實(shí)現(xiàn)的復(fù)雜度，也降低以后成本的維護(hù)，把汽車的部件創(chuàng)建和組裝過(guò)程獨(dú)立出兩個(gè)對(duì)應(yīng)的工廠來(lái)做，有點(diǎn)類似建立兩個(gè)對(duì)應(yīng)的部件創(chuàng)建工廠和汽車組裝工廠兩個(gè)工廠，而工廠只是創(chuàng)建一個(gè)成品，并沒(méi)有把里面的步驟也獨(dú)立出來(lái)，應(yīng)該說(shuō)Builder模式比工廠模式又進(jìn)了一步。

    2）采用Builder模式后的好處：把一個(gè)負(fù)責(zé)的對(duì)象的創(chuàng)建過(guò)程分解，把一個(gè)對(duì)象的創(chuàng)建分成兩個(gè)對(duì)象來(lái)負(fù)責(zé)創(chuàng)建，代碼更有利于維護(hù)，可擴(kuò)性比較好。

   3）采用Builder模式后的壞處：實(shí)現(xiàn)起來(lái)，對(duì)應(yīng)的接口以及部件的對(duì)象的創(chuàng)建比較多，代碼相對(duì)來(lái)講，比較多了，估計(jì)剛開始你會(huì)有點(diǎn)暈，這個(gè)可以考慮代碼精簡(jiǎn)的問(wèn)題，增加代碼的可讀性。  

二：一個(gè)實(shí)際的例子

汽車的組裝

  1)首先創(chuàng)建汽車這個(gè)成品對(duì)象，包含什么的成員

public class Car implements Serializable{

/**
* 汽車序列號(hào)
*/
private static final long serialVersionUID = 1L;

/**汽車輪子*/
private Wheel wheel;

/**汽車發(fā)動(dòng)機(jī)*/
private Engine engine;

/**汽車玻璃*/
private Glass glass;

/**汽車座椅*/
private Chair chair;

public Wheel getWheel() {
   return wheel;
}

public void setWheel(Wheel wheel) {
   this.wheel = wheel;
}

public Engine getEngine() {
   return engine;
}

public void setEngine(Engine engine) {
   this.engine = engine;
}

public Glass getGlass() {
   return glass;
}

public void setGlass(Glass glass) {
   this.glass = glass;
}

public Chair getChair() {
   return chair;
}

public void setChair(Chair chair) {
   this.chair = chair;
}

}

2）創(chuàng)建對(duì)應(yīng)汽車零部件

public class Wheel {
public Wheel(){
   print("--汽車輪子構(gòu)建完畢--");
}
}

public class Engine {
public Engine(){
   print("--汽車發(fā)動(dòng)機(jī)構(gòu)建完畢--");
}
}

public class Glass {
public Glass(){
   print("--汽車玻璃構(gòu)建完畢--");
}
}

public class Chair {
public Chair(){
   print("--汽車座椅構(gòu)建完畢--");
}
}

3）開始重點(diǎn)了，汽車成品的組裝過(guò)程

   public interface Builder {
/**組裝汽車輪子*/
public void buildWheel();

/**組裝汽車發(fā)動(dòng)機(jī)*/
public void buildEngine();

/**組裝汽車玻璃*/
public void buildGlass();

/**組裝汽車座椅*/
public void buildChair();

/**返回組裝好的汽車*/
public Car getCar();
}

以及實(shí)現(xiàn)類

public class CarBuilder implements Builder {
/**汽車成品*/
private Car car;

public CarBuilder(){
   car=new Car();
}

/**組裝汽車輪子*/
@Override
public void buildChair() {
   car.setChair(new Chair());
}

/**組裝汽車發(fā)動(dòng)機(jī)*/
@Override
public void buildEngine() {
   car.setEngine(new Engine());
}

/**組裝汽車玻璃*/
@Override
public void buildGlass() {
   car.setGlass(new Glass());
}

/**組裝汽車座椅*/
@Override
public void buildWheel() {
   car.setWheel(new Wheel());
}

/**返回組裝好的汽車*/
@Override
public Car getCar() {
   buildChair();
   buildEngine();
   buildGlass();
   buildWheel();
   print("--整個(gè)汽車構(gòu)建完畢--");
   return car;
}

}

4）最后汽車創(chuàng)建測(cè)試

   public static void main(String[] args) {
   /**創(chuàng)建汽車組裝*/
   Builder carBuilder=new CarBuilder();
   Car car=carBuilder.getCar();
}

   最后輸出：

--汽車座椅構(gòu)建完畢--
--汽車發(fā)動(dòng)機(jī)構(gòu)建完畢--
--汽車玻璃構(gòu)建完畢--
--汽車輪子構(gòu)建完畢--
--整個(gè)汽車構(gòu)建完畢--

   5）體會(huì)心得：Builder模式實(shí)際的重點(diǎn)就把汽車的組裝過(guò)程和零部件的生產(chǎn)分開來(lái)實(shí)現(xiàn)，零部件的生成主要靠自己的對(duì)象來(lái)實(shí)現(xiàn)，我上面只是在構(gòu)造函數(shù)里創(chuàng)建了，比較簡(jiǎn)單，而重點(diǎn)汽車的組裝則交給CarBuilder來(lái)實(shí)現(xiàn)，最終由builder來(lái)先負(fù)責(zé)零部件的創(chuàng)建，最后返回出成品的汽車。

一：使用場(chǎng)景

    1）經(jīng)常使用的地方：一個(gè)類只有一個(gè)實(shí)例，eg:頁(yè)面訪問(wèn)統(tǒng)計(jì)pv，統(tǒng)計(jì)的個(gè)數(shù)就只能保證一個(gè)實(shí)例的統(tǒng)計(jì)。

    2）我們目前使用的情況：比如我想創(chuàng)建一個(gè)對(duì)象，這個(gè)對(duì)象希望只有一份實(shí)例的維護(hù)，在內(nèi)存的保存也只有一份，也就是在同一個(gè)jvm的java堆里只保存一份實(shí)例對(duì)象，所以你會(huì)想一辦法，在創(chuàng)建這個(gè)對(duì)象的時(shí)候，就已經(jīng)能保證只有一份。

    3）怎么改進(jìn)：定義該對(duì)象的時(shí)候，就保證是同一份實(shí)例，比如：定義為私有構(gòu)造函數(shù)，防止通過(guò)new的方式可以創(chuàng)建對(duì)象，然后在對(duì)象里定義一個(gè)靜態(tài)的私有成員（本身對(duì)象的一個(gè)實(shí)例），然后再創(chuàng)建一個(gè)外面訪問(wèn)該對(duì)象的方法就好了。

    4）改進(jìn)的好處：代碼在編譯代碼這個(gè)級(jí)別就被控制了，不至于在jvm里運(yùn)行的時(shí)候才來(lái)保證，把唯一實(shí)例的創(chuàng)建保證在編譯階段；jvm里內(nèi)存只有一份，從而內(nèi)存占有率更低，以及更方便java垃圾回收

    5）改進(jìn)后的壞處：只能是代碼稍微需要更多點(diǎn)，其實(shí)大家最后發(fā)現(xiàn)改進(jìn)后的壞處，都是代碼定義比之間要多一點(diǎn)，但以后的維護(hù)代碼就降下來(lái)了，也短暫的代碼量偏大來(lái)?yè)Q取以后代碼的精簡(jiǎn)。

二：一個(gè)實(shí)際的例子

總體的例子

package com.mike.pattern.singleton;

/**
* 總統(tǒng)
* 
* @author taoyu
* 
* @since 2010-6-22
*/
public class President {
private President(){
   System.out.println("總統(tǒng)已經(jīng)選舉出來(lái)了");
}

/**總統(tǒng)只有一個(gè)*/
private static President president=new President();

/**
* 返回總統(tǒng)
*/
public static President getPresident(){
   return president;
}

/**
* 總統(tǒng)宣布選舉成功
*/
public void announce(){
   System.out.println("偉大的中國(guó)人民，我將成你們新的總統(tǒng)");
}
}

/**
* @param args
*/
public static void main(String[] args) {
   President president=President.getPresident();
   president.announce();
}

1.使用場(chǎng)景

     1）子類過(guò)多，不容易管理；構(gòu)造對(duì)象過(guò)程過(guò)長(zhǎng)；精簡(jiǎn)代碼創(chuàng)建；

    2)目前我們代碼情況： 編寫代碼的時(shí)候，我們經(jīng)常都在new對(duì)象，創(chuàng)建一個(gè)個(gè)的對(duì)象，而且還有很多麻煩的創(chuàng)建方式，eg:HashMap<String,Float> grade=new HashMap<String,Float>(),這樣的代碼創(chuàng)建方式太冗長(zhǎng)了，難道你沒(méi)有想過(guò)把這個(gè)創(chuàng)建變的短一點(diǎn)么，比如：HashMap<String,Float>grade=HashMapFactory.new(),可以把你創(chuàng)建精簡(jiǎn)一點(diǎn)；你也可以還有別的需求，在創(chuàng)建對(duì)象的時(shí)候，你需要不同的情況，創(chuàng)建統(tǒng)一種類別的對(duì)象，eg:我想生成不同的汽車，創(chuàng)建小轎車，創(chuàng)建卡車，創(chuàng)建公交汽車等等，都屬于同種類別：汽車，你難道沒(méi)有想過(guò)，我把這些創(chuàng)建的對(duì)象在一個(gè)工廠里來(lái)負(fù)責(zé)創(chuàng)建，我把創(chuàng)建分開化，交給一人來(lái)負(fù)責(zé)，這樣可以讓代碼更加容易管理，創(chuàng)建方式也可以簡(jiǎn)單點(diǎn)。

比如：Car    BMW=CarFactory.create(bmw);   把創(chuàng)建new由一個(gè)統(tǒng)一負(fù)責(zé)，這樣管理起來(lái)相當(dāng)方便

    3）怎么改進(jìn)：這個(gè)時(shí)候，你會(huì)想到，創(chuàng)建這樣同類別的東西，我把這個(gè)權(quán)利分出去，讓一個(gè)人來(lái)單獨(dú)管理，它只負(fù)責(zé)創(chuàng)建我的對(duì)象這個(gè)事情，所以你單獨(dú)簡(jiǎn)歷一個(gè)對(duì)象來(lái)創(chuàng)建同類的對(duì)象，這個(gè)時(shí)候，你想這個(gè)東西有點(diǎn)像工廠一樣，生成同樣的產(chǎn)品，所以取了個(gè)名字：工廠模式，顧名思義，只負(fù)責(zé)對(duì)象的創(chuàng)建

    4）改進(jìn)后的好處：代碼更加容易管理了，代碼的創(chuàng)建要簡(jiǎn)潔很多。

    5）改進(jìn)后的壞處：那就是你需要單獨(dú)加一個(gè)工廠對(duì)象來(lái)負(fù)責(zé)創(chuàng)建，多需要寫點(diǎn)代碼。

2.一個(gè)實(shí)際的例子

   創(chuàng)建寶馬汽車與奔馳汽車的例子

   1）先提取出一個(gè)汽車的公用接口Car

       public interface Car{

          /**行駛*/    

          public void drive();

        }

   2)寶馬和奔馳汽車對(duì)象

public class BMWCar implements Car {

/**
* 汽車發(fā)動(dòng)
*/
public void drive(){
   System.out.println("BMW Car drive");
}
}

public class BengCar implements Car {

/**
* 汽車發(fā)動(dòng)
*/
public void drive(){
   System.out.println("BengChi Care drive");
}
}

    3)單獨(dú)一個(gè)汽車工廠來(lái)負(fù)責(zé)創(chuàng)建

     public class FactoryCar {
/**
* 制造汽車
*
* @param company 汽車公司
* @return 汽車
* @throws CreateCarException 制造汽車失敗異常
*/
public static Car createCar(Company company)throws CreateCarException{
   if(company==Company.BMW){
    return new BMWCar();
   }else if(company==Company.Beng){
    return new BengCar();
   }
   return null;
}
}

    4）最后的代碼實(shí)現(xiàn)：

    Car BMWCar=FactoryCar.createCar(Company.BMW);
     BMWCar.drive();

   1. 我說(shuō)下我對(duì)設(shè)計(jì)模式的理解：任何一樣事物都是因?yàn)橛行枨蟮尿?qū)動(dòng)才誕生的，所以設(shè)計(jì)模式也不例外，我們平時(shí)在編寫代碼的時(shí)候，隨著時(shí)間的深入，發(fā)現(xiàn)很多代碼很難維護(hù)，可擴(kuò)展性級(jí)差，以及代碼的效率也比較低，這個(gè)時(shí)候你肯定會(huì)想辦法讓代碼變的優(yōu)美又能解決你項(xiàng)目中的問(wèn)題，所以在面向?qū)ο笳Z(yǔ)言里，你肯定會(huì)去發(fā)現(xiàn)很多可以重用的公用的方法，比如：接口的存在，你自然就想到了，讓你定義的方法與你的實(shí)現(xiàn)分開，也可以很方便把不同的類與接口匹配起來(lái)，形成了一個(gè)公用的接口，你會(huì)發(fā)現(xiàn)這樣做，好處會(huì)是非常多的，解決了你平時(shí)想把代碼的申明與邏輯實(shí)現(xiàn)的分開。

    2. 這個(gè)時(shí)候，你發(fā)現(xiàn)了，本身面向?qū)ο蟮恼Z(yǔ)言里，已經(jīng)暗藏了很多好處，你肯定會(huì)仔細(xì)去分析面向?qū)ο筮@個(gè)語(yǔ)言，認(rèn)真去挖掘里面更多的奧秘，最后，你發(fā)現(xiàn)了，原來(lái)你可以把面向?qū)ο蟮奶匦蕴崛〕梢粋€(gè)公用的實(shí)現(xiàn)案例，這些案例里能幫助你解決你平時(shí)編寫代碼的困擾，而這樣一群人，就是所謂gof的成員，他們從平時(shí)設(shè)計(jì)建筑方面找到了靈感，建筑的設(shè)計(jì)也可以公用化以及重用化，所以他們也提取了相關(guān)的軟件設(shè)計(jì)方面的公用案例，也就有了下面的相關(guān)的所謂23種設(shè)計(jì)模式，而里面這么多模式，你也可以把他們歸類起來(lái)，最后發(fā)現(xiàn)就幾類模式：創(chuàng)建，結(jié)構(gòu)，行為等模式類別，而這些現(xiàn)成的方案，也可以在實(shí)際應(yīng)用中充分發(fā)揮作用，隨著大家的使用以及理解，發(fā)現(xiàn)其實(shí)這些所謂的模式里，你的確可以讓你的代碼變的更加優(yōu)美與簡(jiǎn)練。

    3. 我比較喜歡把代碼變的更加優(yōu)美與簡(jiǎn)練，優(yōu)美的代碼就是一看就懂，結(jié)構(gòu)很清晰，而簡(jiǎn)歷就是一目了然，又可以解決你的問(wèn)題，就是代碼又少效率又高，所以平時(shí)要養(yǎng)成寫java doc的習(xí)慣，這樣的代碼才為清晰，所以才會(huì)更加優(yōu)美。

    4. 這些就是我對(duì)設(shè)計(jì)模式的理解，所以這么好的寶貝，我們不去深入的了解，的確可惜了，這就叫站到巨人的肩膀上.....

package com.gewara.web.module.base;

import org.apache.mina.core.service.IoHandlerAdapter;
import org.apache.mina.core.session.IoSession;

/**
 * 服務(wù)器端業(yè)務(wù)邏輯
 * 
 * @author mike
 *
 * @since 2012-3-15
 */
public class HelloServerHandler extends IoHandlerAdapter {
         @Override
        /**
         * 連接創(chuàng)建事件
         */
        public void sessionCreated(IoSession session){
            // 顯示客戶端的ip和端口
            System.out.println(session.getRemoteAddress().toString());
        }

        @Override
        /**
         * 消息接收事件
         */
        public void messageReceived(IoSession session, Object message) throws Exception{
            String str = message.toString();
            if (str.trim().equalsIgnoreCase("quit")){
                // 結(jié)束會(huì)話
                session.close(true);
                return;
            }
            
            // 返回消息字符串
            session.write("Hi Client!");
            // 打印客戶端傳來(lái)的消息內(nèi)容
            System.out.println("Message written" + str);
        }
}

2012-03-15 14:45:41,456  INFO  logging.LoggingFilter - CREATED
/192.168.2.89:2691
2012-03-15 14:45:41,456  INFO  logging.LoggingFilter - OPENED
2012-03-15 14:45:41,487  INFO  logging.LoggingFilter - RECEIVED: HeapBuffer[pos=0 lim=11 cap=2048: 48 69 20 53 65 72 76 65 72 21 0A]
2012-03-15 14:45:41,487  DEBUG codec.ProtocolCodecFilter - Processing a MESSAGE_RECEIVED for session 1
Message writtenHi Server!
2012-03-15 14:45:41,487  INFO  logging.LoggingFilter - SENT: HeapBuffer[pos=0 lim=0 cap=0: empty]
2012-03-15 14:45:41,487  INFO  logging.LoggingFilter - RECEIVED: HeapBuffer[pos=0 lim=5 cap=2048: 71 75 69 74 0A]
2012-03-15 14:45:41,487  DEBUG codec.ProtocolCodecFilter - Processing a MESSAGE_RECEIVED for session 1
2012-03-15 14:45:41,487  INFO  logging.LoggingFilter - CLOSED

但這種模式在用戶負(fù)載增加時(shí)，性能將下降非常的快。我們需要重新尋找一個(gè)新的方案，保持?jǐn)?shù)據(jù)處理的流暢，很顯然，事件觸發(fā)機(jī)制是最好的解決辦法，當(dāng)有事件發(fā)生時(shí)，會(huì)觸動(dòng)handler,然后開始數(shù)據(jù)的處理。
Reactor模式類似于AWT中的Event處理。

Reactor模式參與者

1.Reactor 負(fù)責(zé)響應(yīng)IO事件，一旦發(fā)生，廣播發(fā)送給相應(yīng)的Handler去處理,這類似于AWT的thread
2.Handler 是負(fù)責(zé)非堵塞行為，類似于AWT ActionListeners；同時(shí)負(fù)責(zé)將handlers與event事件綁定，類似于AWT addActionListener

并發(fā)系統(tǒng)常采用reactor模式，簡(jiǎn)稱觀察者模式，代替常用的多線程處理方式，利用有限的系統(tǒng)的資源，提高系統(tǒng)的吞吐量。

1、傳輸?shù)臉?biāo)準(zhǔn)格式是什么？

      是Java ObjectStream。

2、怎么樣將請(qǐng)求轉(zhuǎn)化為傳輸?shù)牧鳎?/div>

      基于Java串行化機(jī)制將請(qǐng)求的java object信息轉(zhuǎn)化為流。

3、怎么接收和處理流？

      根據(jù)采用的協(xié)議啟動(dòng)相應(yīng)的監(jiān)聽端口，當(dāng)有流進(jìn)入后基于Java串行化機(jī)制將流進(jìn)行反序列化，并根據(jù)RMI協(xié)議獲取到相應(yīng)的處理對(duì)象信息，進(jìn)行調(diào)用并處理，處理完畢后的結(jié)果同樣基于java串行化機(jī)制進(jìn)行返回。

4、傳輸協(xié)議是？

      tcp/ip。

原理講了，開始實(shí)踐：

創(chuàng)建RMI程序的6個(gè)步驟： 
1、定義一個(gè)遠(yuǎn)程接口的接口，該接口中的每一個(gè)方法必須聲明它將產(chǎn)生一個(gè)RemoteException異常。 
2、定義一個(gè)實(shí)現(xiàn)該接口的類。 
3、使用RMIC程序生成遠(yuǎn)程實(shí)現(xiàn)所需的殘根和框架。 
4、創(chuàng)建一個(gè)服務(wù)器，用于發(fā)布2中寫好的類。 
5. 創(chuàng)建一個(gè)客戶程序進(jìn)行RMI調(diào)用。 
6、啟動(dòng)rmiRegistry并運(yùn)行自己的遠(yuǎn)程服務(wù)器和客戶程序     
    
 
1）首先創(chuàng)建遠(yuǎn)程接口：
 /**

•     最大的區(qū)別是與servlet成功解耦，不在依賴容器來(lái)初始化HttpServletRequest和HttpServletResponse

    struts1里依賴的核心控制器為ActionServlet而struts2依賴ServletDispatcher,一個(gè)是servlet一個(gè)是filter,正是采用了filter才不至于和servlet耦合，所有的數(shù)據(jù) 都是通過(guò)攔截器來(lái)實(shí)現(xiàn)，如下圖顯示：

•     web層表現(xiàn)層的豐富，struts2已經(jīng)可以使用jsp、velocity、freemarker
•     線程模式方面：struts1的action是單例模式而且必須是線程安全或同步的，是struts2的action對(duì)每一個(gè)請(qǐng)求都產(chǎn)生一個(gè)新的實(shí)例，因此沒(méi)有線程安全問(wèn)       題。
•     封裝請(qǐng)求參數(shù)：是struts1采用ActionForm封裝請(qǐng)求參數(shù)，都必須繼承ActionForm基類，而struts2通過(guò)bean的屬性封裝，大大降低了耦合。
•     類型轉(zhuǎn)換：struts1封裝的ActionForm都是String類型，采用Commons- Beanutils進(jìn)行類型轉(zhuǎn)換，每個(gè)類一個(gè)轉(zhuǎn)換器；struts2采用OGNL進(jìn)行類型轉(zhuǎn)       換，支持基本數(shù)據(jù)類型和封裝類型的自動(dòng)轉(zhuǎn)換。
•     數(shù)據(jù)校驗(yàn)：struts1在ActionForm中重寫validate方法；struts2直接重寫validate方法，直接在action里面重寫即可，不需要繼承任何基類，實(shí)際的調(diào)用順序是，validate()-->execute()，會(huì)在執(zhí)行execute之前調(diào)用validate,也支持xwork校驗(yàn)框架來(lái)校驗(yàn)。