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();
  }
 }
}