chenweicai

Flyweight模式定義:
避免大量擁有相同內容的小類的開銷(如耗費內存),使大家共享一個類(元類).

為什么使用?
面向對象語言的原則就是一切都是對象,但是如果真正使用起來,有時對象數可能顯得很龐大,比如,字處理軟件,如果以每個文字都作為一個對象,幾千個字,對象數就是幾千,無疑耗費內存,那么我們還是要"求同存異",找出這些對象群的共同點,設計一個元類,封裝可以被共享的類,另外,還有一些特性是取決于應用(context),是不可共享的,這也Flyweight中兩個重要概念內部狀態intrinsic和外部狀態extrinsic之分.

說白點,就是先捏一個的原始模型,然后隨著不同場合和環境,再產生各具特征的具體模型,很顯然,在這里需要產生不同的新對象,所以Flyweight模式中常出現Factory模式.Flyweight的內部狀態是用來共享的,Flyweight factory負責維護一個Flyweight pool(模式池)來存放內部狀態的對象.

Flyweight模式是一個提高程序效率和性能的模式,會大大加快程序的運行速度.應用場合很多:比如你要從一個數據庫中讀取一系列字符串,這些字符串中有許多是重復的,那么我們可以將這些字符串儲存在Flyweight池(pool)中.

如何使用?

我們先從Flyweight抽象接口開始:

下面是接口的具體實現(ConcreteFlyweight) ,并為內部狀態增加內存空間, ConcreteFlyweight必須是可共享的,它保存的任何狀態都必須是內部(intrinsic),也就是說,ConcreteFlyweight必須和它的應用環境場合無關.

當然,并不是所有的Flyweight具體實現子類都需要被共享的,所以還有另外一種不共享的ConcreteFlyweight:

Flyweight factory負責維護一個Flyweight池(存放內部狀態),當客戶端請求一個共享Flyweight時,這個factory首先搜索池中是否已經有可適用的,如果有,factory只是簡單返回送出這個對象,否則,創建一個新的對象,加入到池中,再返回送出這個對象.池

至此,Flyweight模式的基本框架已經就緒,我們看看如何調用:

FlyweightFactory factory = new FlyweightFactory();
Flyweight fly1 = factory.getFlyweight( "Fred" );
Flyweight fly2 = factory.getFlyweight( "Wilma" );
......

從調用上看,好象是個純粹的Factory使用,但奧妙就在于Factory的內部設計上.

Flyweight模式在XML等數據源中應用
我們上面已經提到,當大量從數據源中讀取字符串,其中肯定有重復的,那么我們使用Flyweight模式可以提高效率,以唱片CD為例,在一個XML文件中,存放了多個CD的資料.

每個CD有三個字段:
1.出片日期(year)
2.歌唱者姓名等信息(artist)
3.唱片曲目 (title)

其中,歌唱者姓名有可能重復,也就是說,可能有同一個演唱者的多個不同時期 不同曲目的CD.我們將"歌唱者姓名"作為可共享的ConcreteFlyweight.其他兩個字段作為UnsharedConcreteFlyweight.

首先看看數據源XML文件的內容:

雖然上面舉例CD只有3張,CD可看成是大量重復的小類,因為其中成分只有三個字段,而且有重復的(歌唱者姓名).

CD就是類似上面接口 Flyweight:

將"歌唱者姓名"作為可共享的ConcreteFlyweight:

再看看Flyweight factory,專門用來制造上面的可共享的ConcreteFlyweight:Artist

當你有幾千張甚至更多CD時,Flyweight模式將節省更多空間,共享的flyweight越多,空間節省也就越大.

給個例子，coffee商店

package FlyWeight.coffeeshop;

public class Table {
?
?private int number;

?public int getNumber() {
??return number;
?}

?public void setNumber(int number) {
??this.number = number;
?}

?public Table(int number) {
??super();
??// TODO Auto-generated constructor stub
??this.number = number;
?}

}


package FlyWeight.coffeeshop;

public abstract class Order {
?
?public abstract void serve(Table table);
?
?public abstract String getFlavor();

}


package FlyWeight.coffeeshop;

public class Flavor extends Order {

?private String flavor;

?public Flavor(String flavor) {
??super();
??// TODO Auto-generated constructor stub
??this.flavor = flavor;
?}

?public String getFlavor() {
??return flavor;
?}

?public void setFlavor(String flavor) {
??this.flavor = flavor;
?}

?public void serve(Table table) {
??System.out.println("Serving table " + table.getNumber() + " with flavor " + flavor );
?}?
}

package FlyWeight.coffeeshop;

public class FlavorFactory {

?private Order[] flavors = new Flavor[10];
?private int ordersMade = 0;//已經處理好的訂單數
?private int totalFlavors = 0;//已購買的coffee風味種類數
?
?public Order getOrder(String flavorToGet){
??if(ordersMade > 0){
???for(int i=0; i<ordersMade; i++){
????if(flavorToGet.equalsIgnoreCase(flavors[i].getFlavor()))
?????return flavors[i];
???}
??}
??flavors[ordersMade] = new Flavor(flavorToGet);
??totalFlavors++;
??return flavors[ordersMade++];
?}
?
?public int getTotalFlavorsMade(){
??return totalFlavors;
?}
}


package FlyWeight.coffeeshop;

public class Client {
?
?private static Order[] flavors = new Flavor[100];
?
?private static int ordersMade = 0;
?private static FlavorFactory flavorFactory;
?
?private static void takeOrders(String aFlavor){
??flavors[ordersMade++] = flavorFactory.getOrder(aFlavor);
?}
?
?public static void main(String[] args){
??flavorFactory = new FlavorFactory();
??
???? takeOrders("Black Coffee");
???? takeOrders("Capucino");
???? takeOrders("Espresso");
???? takeOrders("Espresso");
???? takeOrders("Capucino");
???? takeOrders("Capucino");
???? takeOrders("Black Coffee");
???? takeOrders("Espresso");
???? takeOrders("Capucino");
???? takeOrders("Black Coffee");
???? takeOrders("Espresso");
????
???? for(int i=0; i<ordersMade; i++){
???? ?flavors[i].serve(new Table(i));
???? }
????
???? System.out.println("\nTotal Flavor objrcts made: " +
???? ??flavorFactory.getTotalFlavorsMade());
?}
?
}

//-------------------------------------------------------------------

運行結果：

Serving table 0 with flavor Black Coffee
Serving table 1 with flavor Capucino
Serving table 2 with flavor Espresso
Serving table 3 with flavor Espresso
Serving table 4 with flavor Capucino
Serving table 5 with flavor Capucino
Serving table 6 with flavor Black Coffee
Serving table 7 with flavor Espresso
Serving table 8 with flavor Capucino
Serving table 9 with flavor Black Coffee
Serving table 10 with flavor Espresso

Total Flavor objrcts made: 3

使用Struts有一段時間了，但也僅僅涉及到一部分內容，比如Action做邏輯控制、FormBean對象化用戶提交的Form數據、國際化資源文件，Struts很重要的一部分Struts Tag卻一直沒有使用到，一是因為要熟練的使用Struts Tag需要一定的時間來，二也是因為自己有一套比較好的Tag可用。JSP頁面上Tag使用的較多雖然能讓頁面看起來比較整潔，但可讀性會相對降低，開發時的靈活性也會降低。相對來說還是比較看中Action的邏輯控制部分。

重新翻看Struts書本，特別注意了Tag部分，也還是覺得有些眩暈，或許使用熟練是才能體驗出其中的玄妙。摘錄幾個Tag放在這里。

1、<bean:message key="hello.jsp.page.heading"/>
用于輸出資源文件中的內容

2、<html:errors/>或者寫成<html:error property="xxx"/>
用于輸出錯誤信息，當指定peoperty時，則只顯示對應的錯誤信息，如：
ActionErrors errors = new ActionErrors();
errors.add("xxx",new ActionError("username.null"));

3、<html:form action="/Helloworld">
Form表單

4、<html:text property="userName" size="16"/>
表單中的輸入域

5、<html:submit property="submit" value="Submit"/>
提交按鈕

6、<html:reset/>
重置按鈕

7、<bean:write name="bitiliu" property="userName"/>
從request中或者session中獲得bitiliu對象，并輸出userName屬性的值，可指定scope

8、非空邏輯判斷
<logic:notEmpty name="bitiliu" property="userName" scope="request">
?do something...??
</logic:notEmpty>

9、<html:link>
用于生成鏈接，可以增加參數
<%
?pageContext.setAttribute("name","I am a boy!");

?HashMap myMap = new HashMap();?
?myMap.put("name","bitiliu");
?myMap.put("password",new String[]{"1","2","3"});
?pageContext.setAttribute("myMap",myMap);
%>
<html:link page="/Test.jsp" paramId="haha" paramName="name" name="myMap">Test</html:link>
生成的超鏈接為：
<a href="/Struts2/Test.jsp?password=1&amp;password=2&amp;password=3&amp;haha=I+am+a+boy%21&amp;name=bitiliu">Test</a>

10、<html:img>
生成圖片標記，如<html:img page="/logo.gif"/>，生成的HTML為<img src="/web/logo.gif">
<html:img>也可以包含請求參數，可參考<html:link>

11、<html:cancel>
增加取消按鈕，點擊取消按鈕也會請求form的action事件，可以在execute方法中通過方法isCancelled(request)來判斷是否點擊了取消按鈕。

12、<html:hidden>
生成隱藏域，如<html:hidden property="name"/>，生成的HTML為<input type="hidden" name="name"/>

13、<html:checkbox property="check">
對應的Form中應該有一對應屬性check類型為boolean

14、<html:multibox property="strArray" value="value1">
對應的Form中對應屬性strArray類型為String

15、<html:radio property="strArray" value="value1">
同<html:multibox>，但為單選框

16、<html:select>
下拉選擇框，可指定property、size和multiple(true\false)，標簽內可包含<html:option>、<html:options>和<html:optionCollections>

17、<html:option>
可寫成：<html:option value="color.orange" key="color.orange"/>或<html:option value="color.orange">Orange</html:option>

18、<html:options>
一次生成多個option，使用示例：
Vector vec = new Vector();
vec.add(new org.apache.struts.util.LabelValueBean("label1","value1"));
vec.add(new org.apache.struts.util.LabelValueBean("label2","value2"));
pageContext.setAttribute("vec",vec);

<html:options collection="vec" property="value" labelProperty="label"/>

19、<html:file>
用于實現文件上傳，其中<html:form>的enctype="multipart/form-date"，Form的對應屬性類型應為File類型，

邏輯判斷標簽：
1、<logic:equal>
相等，示例如下：
<logic:equal name="strValue" value="112" scope="request">equal</logic:equal>
標簽從request中獲得strValue對象，然后和112比較，如果相等，則輸入字符串equal，否則不輸出。下面標簽相同。

2、<logic:greateEqual>
大于等于

3、<logic:greaterThan>
大于

4、<logic:lessEqual>
小于等于

5、<logic:lessThan>
小于

6、<logic:notEqual>
不等于

7、<logic:match>
指定的值是變量的子串

8、<logic:notMatch>
指定的值不是變量的子串

9、<logic:iterate>
疊代標簽

其它：
1、在國際化文件中添加兩個errors.header和errors.footer用于指定錯誤信息顯示時前后追加的內容。

struts標簽bean

當序列化遇到繼承…

當一個父類實現Serializable接口后，他的子類都將自動的實現序列化。

以下驗證了這一點：
package InherSerialTest;

import java.io.Serializable;

public class SuperA implements Serializable {

?private int supervalue;

?public SuperA(int supervalue) {
??super();
??// TODO Auto-generated constructor stub
??this.supervalue = supervalue;
?}
?
?public int getSupervalue() {
??return supervalue;
?}

?public void setSupervalue(int supervalue) {
??this.supervalue = supervalue;
?}

?public String toString(){
??return "supervalue is :" + supervalue;
?}
}

package InherSerialTest;

public class SubB extends SuperA {

?private int subvalue;

?public SubB(int supervalue, int subvalue) {
??super(supervalue);
??// TODO Auto-generated constructor stub
??this.subvalue = subvalue;
?}

?public int getSubvalue() {
??return subvalue;
?}

?public void setSubvalue(int subvalue) {
??this.subvalue = subvalue;
?}

?public String toString() {
??// TODO Auto-generated method stub
??return super.toString() + " ,subvalue " + subvalue;
?}
?
}

package InherSerialTest;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

public class InherSerialTest {

?/**
? * @param args
? */
?public static void main(String[] args) {
??// TODO Auto-generated method stub

??SubB sub = new SubB(100,200);
??
??try{
???ObjectOutputStream oos = new ObjectOutputStream(
?????new FileOutputStream("c:\\InherSerialTest.txt"));
???oos.writeObject(sub);
???oos.close();
???
???ObjectInputStream ois = new ObjectInputStream(
?????new FileInputStream("c:\\InherSerialTest.txt"));
???SubB sub2 = (SubB)ois.readObject();
???System.out.println(sub2);
???ois.close();
??}catch(Exception e){
???e.printStackTrace();
??}
?}

}


結果是：supervalue is :100 ,subvalue 200

怎管讓子類實現序列化看起來是一件很簡單的事情，但有的時候，往往我們不能夠讓父類實現Serializable接口，原因是有時候父類是抽象的（這并沒有關系），并且父類不能夠強制每個子類都擁有序列化的能力。換句話說父類設計的目的僅僅是為了被繼承。

要為一個沒有實現Serializable接口的父類，編寫一個能夠序列化的子類是一件很麻煩的事情。java docs中提到：

“To allow subtypes of non-serializable classes to be serialized, the subtype may assume responsibility for saving and restoring the state of the supertype's public, protected, and (if accessible) package fields. The subtype may assume this responsibility only if the class it extends has an accessible no-arg constructor to initialize the class's state. It is an error to declare a class Serializable if this is not the case. The error will be detected at runtime. ”

也就是說，要為一個沒有實現Serializable接口的父類，編寫一個能夠序列化的子類要做兩件事情：

其一，父類要有一個無參的constructor；

其二，子類要負責序列化（反序列化）父類的域。
如果我們將上列中的SuperA沒有實現Serializable接口，而是在SubB類中實現Serializable接口的話，即：

public class SuperA? {}
public class SubB extends SuperA implements Serializable{}

我們再次運行時，將會產生錯誤：

java.io.InvalidClassException: InherSerialTest.SubB; no valid constructor
?at java.io.ObjectStreamClass.<init>(Unknown Source)
?at java.io.ObjectStreamClass.lookup(Unknown Source)
?at java.io.ObjectOutputStream.writeObject0(Unknown Source)
?at java.io.ObjectOutputStream.writeObject(Unknown Source)
?at InherSerialTest.InherSerialTest.main(InherSerialTest.java:21)

果真如docs中所說的一樣，父類缺少無參構造函數是不行的。



接下來，按照docs中的建議我們改寫這個例子：
package InherSerialTest2;

import java.io.Serializable;

public abstract class SuperC {

?int supervalue;

?public SuperC(int supervalue) {
??super();
??// TODO Auto-generated constructor stub
??this.supervalue = supervalue;
?}
?
//?父類沒有實現Serializable接口，子類要可序列化的話，父類必須要有無參構造函數
?public SuperC(){
??
?}

?public int getSupervalue() {
??return supervalue;
?}

?public void setSupervalue(int supervalue) {
??this.supervalue = supervalue;
?}

?public String toString() {
??// TODO Auto-generated method stub
??return "supervalue : " + supervalue;
?}

}

package InherSerialTest2;

import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.Serializable;

import InherSerialTest.SuperA;

public class SubC extends SuperC implements Serializable{
?
?private int subvalue;

?public SubC(int supervalue, int subvalue) {
??super(supervalue);
??// TODO Auto-generated constructor stub
??this.subvalue = subvalue;
?}

?public int getSubvalue() {
??return subvalue;
?}

?public void setSubvalue(int subvalue) {
??this.subvalue = subvalue;
?}

?public String toString() {
??// TODO Auto-generated method stub
??return super.toString() + " ,subvalue :" + subvalue;
?}
?
?private void writeObject(java.io.ObjectOutputStream oos)throws IOException{
??
??//先序列化對象
??oos.defaultWriteObject();
??//在序列化父類的域
??oos.writeInt(supervalue);
?}
?
?private void readObject(ObjectInputStream ois)throws IOException, ClassNotFoundException{
??
??//先反序列化對象
??ois.defaultReadObject();
??//再反序列化父類的域
??supervalue = ois.readInt();
?}
}

測試成功！

序列化概述

簡單來說序列化就是一種用來處理對象流的機制，所謂對象流也就是將對象的內容進行流化，流的概念這里不用多說(就是I/O)，我們可以對流化后的對象進行讀寫操作，也可將流化后的對象傳輸于網絡之間(注：要想將對象傳輸于網絡必須進行流化)！在對對象流進行讀寫操作時會引發一些問題，而序列化機制正是用來解決這些問題的！

問題的引出：

如上所述，讀寫對象會有什么問題呢？比如：我要將對象寫入一個磁盤文件而后再將其讀出來會有什么問題嗎？別急，其中一個最大的問題就是對象引用！舉個例子來說：假如我有兩個類，分別是A和B，B類中含有一個指向A類對象的引用，現在我們對兩個類進行實例化{ A a = new A(); B b = new B(); }，這時在內存中實際上分配了兩個空間，一個存儲對象a，一個存儲對象b，接下來我們想將它們寫入到磁盤的一個文件中去，就在寫入文件時出現了問題！因為對象b包含對對象a的引用，所以系統會自動的將a的數據復制一份到b中，這樣的話當我們從文件中恢復對象時(也就是重新加載到內存中)時，內存分配了三個空間，而對象a同時在內存中存在兩份，想一想后果吧，如果我想修改對象a的數據的話，那不是還要搜索它的每一份拷貝來達到對象數據的一致性，這不是我們所希望的！

以下序列化機制的解決方案：

1.保存到磁盤的所有對象都獲得一個序列號(1, 2, 3等等)

2.當要保存一個對象時，先檢查該對象是否被保存了。

3.如果以前保存過，只需寫入"與已經保存的具有序列號x的對象相同"的標記，否則，保存該對象

通過以上的步驟序列化機制解決了對象引用的問題！

序列化的實現

將需要被序列化的類實現Serializable接口，該接口沒有需要實現的方法，implements Serializable只是為了標注該對象是可被序列化的，然后使用一個輸出流(如：FileOutputStream)來構造一個ObjectOutputStream(對象流)對象，接著，使用ObjectOutputStream對象的writeObject(Object obj)方法就可以將參數為obj的對象寫出(即保存其狀態)，要恢復的話則用輸入流。
package serializable;

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 +"]";
?}

package serializable;

public class Manager extends Employee {
?
?private Employee secretary;

?public Manager(String name, double salary) {
??super(name, salary);
??// TODO Auto-generated constructor stub
??secretary = null;
?}

?public Employee getSecretary() {
??return secretary;
?}

?public void setSecretary(Employee secretary) {
??this.secretary = secretary;
?}

?public String toString() {
??// TODO Auto-generated method stub
??return super.toString() + "[ secretary = " + secretary +"]";
?}
?
}

package serializable;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

public class Test {
?
?public static void main(String[] args){
??
??Employee employee = new Employee("LiLei", 1000);
??Manager manager1 = new Manager("Jim", 20000);
??manager1.setSecretary(employee);
??
??Employee[] staff = new Employee[2];
??staff[0] = employee;
??staff[1] = manager1;
??
??try{
???ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("employee.dat"));
???oos.writeObject(staff);
???oos.close();
???
???ObjectInputStream ois = new ObjectInputStream(new FileInputStream("employee.dat"));
???Employee[] newStaff = (Employee[])ois.readObject();
???ois.close();
???
???newStaff[0].raiseSalary(1000);
???
???for(int i=0; i<newStaff.length; i++)
????System.out.println(newStaff[i]);
???
??}catch(Exception e)
??{
???e.printStackTrace();
??}
?}
}

修改默認的序列化機制?

在序列化的過程中，有些數據字段我們不想將其序列化，對于此類字段我們只需要在定義時給它加上transient關鍵字即可，對于transient字段序列化機制會跳過不會將其寫入文件，當然也不可被恢復。但有時我們想將某一字段序列化，但它在SDK中的定義卻是不可序列化的類型，這樣的話我們也必須把他標注為transient，可是不能寫入又怎么恢復呢？好在序列化機制為包含這種特殊問題的類提供了如下的方法定義：

private?void readObject(ObjectInputStream in) throws

IOException, ClassNotFoundException;

private void writeObject(ObjectOutputStream out) throws

IOException;

(注：這些方法定義時必須是私有的，因為不需要你顯示調用，序列化機制會自動調用的)

使用以上方法我們可以手動對那些你又想序列化又不可以被序列化的數據字段進行寫出和讀入操作。

下面是一個典型的例子，java.awt.geom包中的Point2D.Double類就是不可序列化的，因為該類沒有實現Serializable接口，在我的例子中將把它當作LabeledPoint類中的一個數據字段，并演示如何將其序列化
package transientTest;

import java.awt.geom.Point2D;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;

public class LabeledPoint implements Serializable {

?private String label;
?transient private Point2D.Double point;
?
?public LabeledPoint(String label, double x, double y) {
??super();
??// TODO Auto-generated constructor stub
??this.label = label;
??this.point = new Point2D.Double(x,y);
?}
?
?private void writeObject(ObjectOutputStream oos)throws IOException{
??
??oos.defaultWriteObject();
??oos.writeDouble(point.getX());
??oos.writeDouble(point.getY());
?}
?
?private void readObject(ObjectInputStream ois)throws IOException, ClassNotFoundException{
??
??ois.defaultReadObject();
??double x = ois.readDouble() + 1.0;
??double y = ois.readDouble() + 1.0;
??point = new Point2D.Double(x,y);
?}

?public String toString() {
??// TODO Auto-generated method stub
??return getClass().getName() + "[ Label = " + label + ", point.getX() = "
???+ point.getX() + ", point.getY() = " + point.getY() + "]";
?}
}

package transientTest;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

public class transientTest {

?public static void main(String[] args){
??LabeledPoint label = new LabeledPoint("Book", 5.0, 5.0);
??
??try{
???System.out.println("before:\n" + label);
???
???ObjectOutputStream oos = new ObjectOutputStream(
?????new FileOutputStream("c:\\label.txt"));
???oos.writeObject(label);
???oos.close();
???
???System.out.println("after:\n" + label);
???ObjectInputStream ois = new ObjectInputStream(
?????new FileInputStream("c:\\label.txt"));
???LabeledPoint label1 = (LabeledPoint)ois.readObject();
???ois.close();
???
???System.out.println("after add 1.0:\n" + label);
??}catch(Exception e)
??{
???e.printStackTrace();
??}
?}
}