Java开发中的23种设计模式之结构型模式

如有转载，请说明出处：http://blog.csdn.net/zhangerqing

我们接着讨论设计模式，上篇文章我讲完了5种创建型模式，这章开始，我将讲下7种结构型模式：适配器模式、装饰模式、代理模式、外观模式、桥接模式、组合模式、享元模式。其中对象的适配器模式是各种模式的起源，我们看下面的图：

6、适配器模式（Adapter）

 适配器模式将某个类的接口转换成客户端期望的另一个接口表示，目的是消除由于接口不匹配所造成的类的兼容性问题。主要分为三类：类的适配器模式、对象的适配器模式、接口的适配器模式。首先，我们来看看，先看类图：

类的适配器模式 

适用场景：

1、已经存在的类的接口不符合我们的需求；

2、创建一个可以复用的类，使得该类可以与其他不相关的类或不可预见的类（即那些接口可能不一定兼容的类）协同工作；

3、在不对每一个都进行子类化以匹配它们的接口的情况下，使用一些已经存在的子类。

通用类图：

 

我们生活中常常听到的是

电源适配器，它是用于电流变换（整流）的设备。适配器的存在，就是为了将已存在的东西（接口）转换成适合我们的需要、能被我们所利用。在现实生活中，适配器更多的是作为一个中间层来实现这种转换作用。

在上面的通用类图中，Cient 类最终面对的是 Target 接口（或抽象类），它只能够使用符合这一目标标准的子类；而 Adaptee 类则是被适配的对象（也称 源角色），因为它包含specific （特殊的）操作、功能等，所以我们想要在自己的系统中使用它，将其转换成符合我们标准的类，使得 Client 类可以在透明的情况下任意选择使用 ConcreteTarget 类或是具有特殊功能的 Adatee 类。

代码实现如下：

// 已存在的、具有特殊功能、但不符合我们既有的标准接口的类class Adaptee {public void specificRequest() {System.out.println("被适配类具有 特殊功能...");}}

// 目标接口，或称为标准接口interface Target {public void request();}// 具体目标类，只提供普通功能class ConcreteTarget implements Target {public void request() {System.out.println("普通类 具有 普通功能...");}}

// 适配器类，继承了被适配类，同时实现标准接口class Adapter extends Adaptee implements Target{public void request() {super.specificRequest();}}

// 测试类public class Client {public static void main(String[] args) {// 使用普通功能类Target concreteTarget = new ConcreteTarget();concreteTarget.request();// 使用特殊功能类，即适配类Target adapter = new Adapter();adapter.request();}}

 测试结果：

普通类 具有 普通功能...被适配类具有 特殊功能...

上面这种实现的适配器称为类适配器，因为 Adapter 类既继承了 Adaptee （被适配类），也实现了 Target 接口（因为 Java 不支持多继承，所以这样来实现），在 Client 类中我们可以根据需要选择并创建任一种符合需求的子类，来实现具体功能。

对象的适配器模式

基本思路和类的适配器模式相同，只是将Adapter类作修改，这次不继承Source类，而是持有Source类的实例，以达到解决兼容性的问题。看图：

 

代码实现如下：

// 适配器类，直接关联被适配类，同时实现标准接口class Adapter implements Target{// 直接关联被适配类private Adaptee adaptee;// 可以通过构造函数传入具体需要适配的被适配类对象public Adapter (Adaptee adaptee) {this.adaptee = adaptee;}public void request() {// 这里是使用委托的方式完成特殊功能this.adaptee.specificRequest();}}

// 测试类public class Client {public static void main(String[] args) {// 使用普通功能类Target concreteTarget = new ConcreteTarget();concreteTarget.request();// 使用特殊功能类，即适配类，// 需要先创建一个被适配类的对象作为参数Target adapter = new Adapter(new Adaptee());adapter.request();}}

测试结果与上面的一致。从类图中我们也知道需要修改的只不过就是 Adapter 类的内部结构，即 Adapter 自身必须先拥有一个被适配类的对象，再把具体的特殊功能委托给这个对象来实现。使用对象适配器模式，可以使得 Adapter 类（适配类）根据传入的 Adaptee 对象达到适配多个不同被适配类的功能，当然，此时我们可以为多个被适配类提取出一个接口或抽象类。这样看起来的话，似乎对象适配器模式更加灵活一点。

小结：

1、适配器模式也是一种包装模式，与之前的 Decorator 装饰模式同样具有包装的功能；此外，对象适配器模式还具有显式委托的意思在里面（其实类适配器也有这种意思，只不过比较隐含而已），那么我在认为它与 Proxy 代理模式也有点类似；

2、从上面一点对比来看， Decorator 、 Proxy、 Adapter 在实现了自身的最主要目的（这个得看各个模式的最初动机、描述）之外，都可以在包装的前后进行额外的、特殊的功能上的增减，因为我认为它们都有委托的实现意思在里面；

3、我所看的书中说适配器模式不适合在详细设计阶段使用它，它是一种补偿模式，专用来在系统后期扩展、修改时所用。

接口的适配器模式

第三种适配器模式是，接口的适配器是这样的：有时我们写的一个接口中有多个抽象方法，当我们写该接口的实现类时，必须实现该接口的所有方法，这明显有时比较浪费，因为并不是所有的方法都是我们需要的，有时只需要某一些，此处为了解决这个问题，我们引入了接口的适配器模式，借助于一个抽象类，该抽象类实现了该接口，实现了所有的方法，而我们不和原始的接口打交道，只和该抽象类取得联系，所以我们写一个类，继承该抽象类，重写我们需要的方法就行。看一下类图：

这个很好理解，在实际开发中，我们也常会遇到这种接口中定义了太多的方法，以致于有时我们在一些实现类中并不是都需要。看代码：

[java] view plain copy

1. public interface Sourceable {  
2.       
3.     public void method1();  
4.     public void method2();  
5. }  

抽象类Wrapper2：

[java] view plain copy

1. public abstract class Wrapper2 implements Sourceable{  
2.       
3.     public void method1(){}  
4.     public void method2(){}  
5. }  

[java] view plain copy

1. public class SourceSub1 extends Wrapper2 {  
2.     public void method1(){  
3.         System.out.println("the sourceable interface's first Sub1!");  
4.     }  
5. }  

[java] view plain copy

1. public class SourceSub2 extends Wrapper2 {  
2.     public void method2(){  
3.         System.out.println("the sourceable interface's second Sub2!");  
4.     }  
5. }  

[java] view plain copy

1. public class WrapperTest {  
2.   
3.     public static void main(String[] args) {  
4.         Sourceable source1 = new SourceSub1();  
5.         Sourceable source2 = new SourceSub2();  
6.           
7.         source1.method1();  
8.         source1.method2();  
9.         source2.method1();  
10.         source2.method2();  
11.     }  
12. }  

测试输出：

the sourceable interface's first Sub1!
the sourceable interface's second Sub2!

达到了我们的效果！

 讲了这么多，总结一下三种适配器模式的应用场景：

类的适配器模式：当希望将一个类转换成满足另一个新接口的类时，可以使用类的适配器模式，创建一个新类，继承原有的类，实现新的接口即可。

对象的适配器模式：当希望将一个对象转换成满足另一个新接口的对象时，可以创建一个Wrapper类，持有原类的一个实例，在Wrapper类的方法中，调用实例的方法就行。

接口的适配器模式：当不希望实现一个接口中所有的方法时，可以创建一个抽象类Wrapper，实现所有方法，我们写别的类的时候，继承抽象类即可。

类适配器和对象适配器的权衡

　　●　　类适配器使用对象继承的方式，是静态的定义方式；而对象适配器使用对象组合的方式，是动态组合的方式。

　　●　　对于类适配器，由于适配器直接继承了Adaptee，使得适配器不能和Adaptee的子类一起工作，因为继承是静态的关系，当适配器继承了Adaptee后，就不可能再去处理  Adaptee的子类了。

　　　　 对于对象适配器，一个适配器可以把多种不同的源适配到同一个目标。换言之，同一个适配器可以把源类和它的子类都适配到目标接口。因为对象适配器采用的是对象组合的关系，只要对象类型正确，是不是子类都无所谓。

　　●　  对于类适配器，适配器可以重定义Adaptee的部分行为，相当于子类覆盖父类的部分实现方法。

　　　　 对于对象适配器，要重定义Adaptee的行为比较困难，这种情况下，需要定义Adaptee的子类来实现重定义，然后让适配器组合子类。虽然重定义Adaptee的行为比较困难，但是想要增加一些新的行为则方便的很，而且新增加的行为可同时适用于所有的源。

　　●　　对于类适配器，仅仅引入了一个对象，并不需要额外的引用来间接得到Adaptee。

　　　　 对于对象适配器，需要额外的引用来间接得到Adaptee。

　　建议尽量使用对象适配器的实现方式，多用合成/聚合、少用继承。当然，具体问题具体分析，根据需要来选用实现方式，最适合的才是最好的。

适配器模式的优点

• 　　更好的复用性

　　系统需要使用现有的类，而此类的接口不符合系统的需要。那么通过适配器模式就可以让这些功能得到更好的复用。

• 　　更好的扩展性

　　在实现适配器功能的时候，可以调用自己开发的功能，从而自然地扩展系统的功能。

适配器模式的缺点

　　过多的使用适配器，会让系统非常零乱，不易整体进行把握。比如，明明看到调用的是A接口，其实内部被适配成了B接口的实现，一个系统如果太多出现这种情况，无异于一场灾难。因此如果不是很有必要，可以不使用适配器，而是直接对系统进行重构。

 

---

 

缺省适配模式

　　缺省适配(Default Adapter)模式为一个接口提供缺省实现，这样子类型可以从这个缺省实现进行扩展，而不必从原有接口进行扩展。作为适配器模式的一个特例，缺省是适配模式在JAVA语言中有着特殊的应用。

7、装饰模式（Decorator）

装饰模式（Decorator）：动态地给一个对象添加一些额外的职责，就增加功能来说，装饰 模式相比生成子类更为灵活。

使用场景：

1、在不影响其他对象的情况下，以动态、透明的方式给单个对象添加职责；

2、处理那些可以撤消的职责；

3、当不能采用生成子类的方法进行扩充时。

 

下面是装饰模式的通用类图： 

顾名思义，装饰模式就是给一个对象增加一些新的功能，而且是动态的，要求装饰对象和被装饰对象实现同一个接口，装饰对象持有被装饰对象的实例， 

 http://www.cnblogs.com/java-my-life/archive/2012/04/20/2455726.html

装饰模式的结构

　　装饰模式以对客户透明的方式动态地给一个对象附加上更多的责任。换言之，客户端并不会觉得对象在装饰前和装饰后有什么不同。装饰模式可以在不使用创造更多子类的情况下，将对象的功能加以扩展。

　　装饰模式的类图如下：

　　

　　在装饰模式中的角色有：

　　●　　抽象构件(Component)角色：给出一个抽象接口，以规范准备接收附加责任的对象。

　　●　　具体构件(ConcreteComponent)角色：定义一个将要接收附加责任的类。

　　●　　装饰(Decorator)角色：持有一个构件(Component)对象的实例，并定义一个与抽象构件接口一致的接口。

　　●　　具体装饰(ConcreteDecorator)角色：负责给构件对象“贴上”附加的责任。

源代码

　　抽象构件角色

public interface Component {        public void sampleOperation();    }

　　具体构件角色

public class ConcreteComponent implements Component {    @Override    public void sampleOperation() {        // 写相关的业务代码    }}

　　装饰角色

public class Decorator implements Component{    private Component component;        public Decorator(Component component){        this.component = component;    }    @Override    public void sampleOperation() {        // 委派给构件        component.sampleOperation();    }    }

　　具体装饰角色

public class ConcreteDecoratorA extends Decorator {    public ConcreteDecoratorA(Component component) {        super(component);    }        @Override    public void sampleOperation() {
　　　　　super.sampleOperation();        // 写相关的业务代码    }}

public class ConcreteDecoratorB extends Decorator {    public ConcreteDecoratorB(Component component) {        super(component);    }        @Override    public void sampleOperation() {
　　　　  super.sampleOperation();        // 写相关的业务代码    }}

装饰模式的简化

　　大多数情况下，装饰模式的实现都要比上面给出的示意性例子要简单。

　　如果只有一个ConcreteComponent类，那么可以考虑去掉抽象的Component类（接口），把Decorator作为一个ConcreteComponent子类。如下图所示：

 

　　如果只有一个ConcreteDecorator类，那么就没有必要建立一个单独的Decorator类，而可以把Decorator和ConcreteDecorator的责任合并成一个类。甚至在只有两个ConcreteDecorator类的情况下，都可以这样做。如下图所示：

　　

装饰模式的优点

　　（1）装饰模式与继承关系的目的都是要扩展对象的功能，但是装饰模式可以提供比继承更多的灵活性。装饰模式允许系统动态决定“贴上”一个需要的“装饰”，或者除掉一个不需要的“装饰”。继承关系则不同，继承关系是静态的，它在系统运行前就决定了。

　　（2）通过使用不同的具体装饰类以及这些装饰类的排列组合，设计师可以创造出很多不同行为的组合。

装饰模式的缺点

　　由于使用装饰模式，可以比使用继承关系需要较少数目的类。使用较少的类，当然使设计比较易于进行。但是，在另一方面，使用装饰模式会产生比使用继承关系更多的对象。更多的对象会使得查错变得困难，特别是这些对象看上去都很相像。

 

---

设计模式在JAVA I/O库中的应用

　　装饰模式在Java语言中的最著名的应用莫过于Java I/O标准库的设计了。

　　由于Java I/O库需要很多性能的各种组合，如果这些性能都是用继承的方法实现的，那么每一种组合都需要一个类，这样就会造成大量性能重复的类出现。而如果采用装饰模式，那么类的数目就会大大减少，性能的重复也可以减至最少。因此装饰模式是Java I/O库的基本模式。

　　Java I/O库的对象结构图如下，由于Java I/O的对象众多，因此只画出InputStream的部分。

　　根据上图可以看出：

　　●　　抽象构件(Component)角色：由InputStream扮演。这是一个抽象类，为各种子类型提供统一的接口。

　　●　　具体构件(ConcreteComponent)角色：由ByteArrayInputStream、FileInputStream、PipedInputStream、StringBufferInputStream等类扮演。它们实现了抽象构件角色所规定的接口。

　　●　　抽象装饰(Decorator)角色：由FilterInputStream扮演。它实现了InputStream所规定的接口。

　　●　　具体装饰(ConcreteDecorator)角色：由几个类扮演，分别是BufferedInputStream、DataInputStream以及两个不常用到的类LineNumberInputStream、PushbackInputStream。

 

 半透明的装饰模式

　　装饰模式和适配器模式都是“包装模式(Wrapper Pattern)”，它们都是通过封装其他对象达到设计的目的的，但是它们的形态有很大区别。

　　理想的装饰模式在对被装饰对象进行功能增强的同时，要求具体构件角色、装饰角色的接口与抽象构件角色的接口完全一致。而适配器模式则不然，一般而言，适配器模式并不要求对源对象的功能进行增强，但是会改变源对象的接口，以便和目标接口相符合。

　　装饰模式有透明和半透明两种，这两种的区别就在于装饰角色的接口与抽象构件角色的接口是否完全一致。透明的装饰模式也就是理想的装饰模式，要求具体构件角色、装饰角色的接口与抽象构件角色的接口完全一致。相反，如果装饰角色的接口与抽象构件角色接口不一致，也就是说装饰角色的接口比抽象构件角色的接口宽的话，装饰角色实际上已经成了一个适配器角色，这种装饰模式也是可以接受的，称为“半透明”的装饰模式，如下图所示。

　　在适配器模式里面，适配器类的接口通常会与目标类的接口重叠，但往往并不完全相同。换言之，适配器类的接口会比被装饰的目标类接口宽。

　　显然，半透明的装饰模式实际上就是处于适配器模式与装饰模式之间的灰色地带。如果将装饰模式与适配器模式合并成为一个“包装模式”的话，那么半透明的装饰模式倒可以成为这种合并后的“包装模式”的代表。

InputStream类型中的装饰模式

　　InputStream类型中的装饰模式是半透明的。为了说明这一点，不妨看一看作装饰模式的抽象构件角色的InputStream的源代码。这个抽象类声明了九个方法，并给出了其中八个的实现，另外一个是抽象方法，需要由子类实现。

public abstract class InputStream implements Closeable {    public abstract int read() throws IOException;     public int read(byte b[]) throws IOException {}    public int read(byte b[], int off, int len) throws IOException {}    public long skip(long n) throws IOException {}    public int available() throws IOException {}        public void close() throws IOException {}        public synchronized void mark(int readlimit) {}        public synchronized void reset() throws IOException {}    public boolean markSupported() {}}

　　

　　下面是作为装饰模式的抽象装饰角色FilterInputStream类的源代码。可以看出，FilterInputStream的接口与InputStream的接口是完全一致的。也就是说，直到这一步，还是与装饰模式相符合的。

public class FilterInputStream extends InputStream {    protected FilterInputStream(InputStream in) {}        public int read() throws IOException {}    public int read(byte b[]) throws IOException {}        public int read(byte b[], int off, int len) throws IOException {}    public long skip(long n) throws IOException {}    public int available() throws IOException {}    public void close() throws IOException {}    public synchronized void mark(int readlimit) {}    public synchronized void reset() throws IOException {}    public boolean markSupported() {}}

　　

　　下面是具体装饰角色PushbackInputStream的源代码。

public class PushbackInputStream extends FilterInputStream {    private void ensureOpen() throws IOException {}        public PushbackInputStream(InputStream in, int size) {}    public PushbackInputStream(InputStream in) {}    public int read() throws IOException {}    public int read(byte[] b, int off, int len) throws IOException {}    public void unread(int b) throws IOException {}    public void unread(byte[] b, int off, int len) throws IOException {}    public void unread(byte[] b) throws IOException {}    public int available() throws IOException {}    public long skip(long n) throws IOException {}    public boolean markSupported() {}    public synchronized void mark(int readlimit) {}     public synchronized void reset() throws IOException {}    public synchronized void close() throws IOException {}}

 　　查看源码，你会发现，这个装饰类提供了额外的方法unread()，这就意味着PushbackInputStream是一个半透明的装饰类。换言 之，它破坏了理想的装饰模式的要求。如果客户端持有一个类型为InputStream对象的引用in的话，那么如果in的真实类型是 PushbackInputStream的话，只要客户端不需要使用unread()方法，那么客户端一般没有问题。但是如果客户端必须使用这个方法，就 必须进行向下类型转换。将in的类型转换成为PushbackInputStream之后才可能调用这个方法。但是，这个类型转换意味着客户端必须知道它 拿到的引用是指向一个类型为PushbackInputStream的对象。这就破坏了使用装饰模式的原始用意。

　　现实世界与理论总归是有一段差距的。纯粹的装饰模式在真实的系统中很难找到。一般所遇到的，都是这种半透明的装饰模式。

　　下面是使用I/O流读取文件内容的简单操作示例。

public class IOTest {    public static void main(String[] args) throws IOException {        // 流式读取文件        DataInputStream dis = null;        try{            dis = new DataInputStream(                    new BufferedInputStream(                            new FileInputStream("test.txt")                    )            );            //读取文件内容            byte[] bs = new byte[dis.available()];            dis.read(bs);            String content = new String(bs);            System.out.println(content);        }finally{            dis.close();        }    }}

　　观察上面的代码，会发现最里层是一个FileInputStream对象，然后把它传递给一个BufferedInputStream对象，经过BufferedInputStream处理，再把处理后的对象传递给了DataInputStream对象进行处理，这个过程其实就是装饰器的组装过程，FileInputStream对象相当于原始的被装饰的对象，而BufferedInputStream对象和DataInputStream对象则相当于装饰器。

装饰器模式的应用场景：

1、需要扩展一个类的功能。

2、动态的为一个对象增加功能，而且还能动态撤销。（继承不能做到这一点，继承的功能是静态的，不能动态增删。）

缺点：产生过多相似的对象，不易排错！

8、代理模式（Proxy）

其实每个模式名称就表明了该模式的作用，代理模式就是多一个代理类出来，替原对象进行一些操作，比如我们在租房子的时候回去找中介，为什么呢？因为你对该地区房屋的信息掌握的不够全面，希望找一个更熟悉的人去帮你做，此处的代理就是这个意思。再如我们有的时候打官司，我们需要请律师，因为律师在法律方面有专长，可以替我们进行操作，表达我们的想法。先来看看关系图：

代理模式类图如下：

　　

　　在代理模式中的角色：

　　●　　抽象对象角色：声明了目标对象和代理对象的共同接口，这样一来在任何可以使用目标对象的地方都可以使用代理对象。

　　●　　目标对象角色：定义了代理对象所代表的目标对象。

　　●　　代理对象角色：代理对象内部含有目标对象的引用，从而可以在任何时候操作目标对象；代理对象提供一个与目标对象相同的接口，以便可以在任何时候替代目标对象。代理对象通常在客户端调用传递给目标对象之前或之后，执行某个操作，而不是单纯地将调用传递给目标对象。

源代码

　　抽象对象角色

public abstract class AbstractObject {    //操作    public abstract void operation();}

　　目标对象角色

public class RealObject extends AbstractObject {    @Override    public void operation() {        //一些操作        System.out.println("一些操作");    }}

　　代理对象角色

public class ProxyObject extends AbstractObject{    RealObject realObject = new RealObject();    @Override    public void operation() {        //调用目标对象之前可以做相关操作        System.out.println("before");                realObject.operation();                //调用目标对象之后可以做相关操作        System.out.println("after");    }}

　　客户端

public class Client {    public static void main(String[] args) {        // TODO Auto-generated method stub        AbstractObject obj = new ProxyObject();        obj.operation();    }}

　　从上面的例子可以看出代理对象将客户端的调用委派给目标对象，在调用目标对象的方法之前跟之后都可以执行特定的操作。

代理模式的应用场景：

如果已有的方法在使用的时候需要对原有的方法进行改进，此时有两种办法：

1、修改原有的方法来适应。这样违反了“对扩展开放，对修改关闭”的原则。

2、就是采用一个代理类调用原有的方法，且对产生的结果进行控制。这种方法就是代理模式。

使用代理模式，可以将功能划分的更加清晰，有助于后期维护！

9、外观模式（Facade）

外观模式是为了解决类与类之家的依赖关系的，像spring一样，可以将类和类之间的关系配置到配置文件中，而外观模式就是将他们的关系放在一个Facade类中，降低了类类之间的耦合度，该模式中没有涉及到接口，看下类图：（我们以一个计算机的启动过程为例）

整体结构图如下：

　　在这个对象图中，出现了两个角色：

　　●　　门面(Facade)角色 ：客户端可以调用这个角色的方法。此角色知晓相关的（一个或者多个）子系统的功能和责任。在正常情况下，本角色会将所有从客户端发来的请求委派到相应的子系统去。

　　●　　子系统(SubSystem)角色 ：可以同时有一个或者多个子系统。每个子系统都不是一个单独的类，而是一个类的集合（如上面的子系统就是由ModuleA、ModuleB、ModuleC三个类组合而成）。每个子系统都可以被客户端直接调用，或者被门面角色调用。子系统并不知道门面的存在，对于子系统而言，门面仅仅是另外一个客户端而已。

源代码

　　子系统角色中的类：

public class ModuleA {    //示意方法    public void testA(){        System.out.println("调用ModuleA中的testA方法");    }}

public class ModuleB {    //示意方法    public void testB(){        System.out.println("调用ModuleB中的testB方法");    }}

public class ModuleC {    //示意方法    public void testC(){        System.out.println("调用ModuleC中的testC方法");    }}

　　门面角色类：

public class Facade {    //示意方法，满足客户端需要的功能    public void test(){        ModuleA a = new ModuleA();        a.testA();        ModuleB b = new ModuleB();        b.testB();        ModuleC c = new ModuleC();        c.testC();    }}

　　客户端角色类：

public class Client {    public static void main(String[] args) {                Facade facade = new Facade();        facade.test();    }}

　　Facade类其实相当于A、B、C模块的外观界面，有了这个Facade类，那么客户端就不需要亲自调用子系统中的A、B、C模块了，也不需要知道系统内部的实现细节，甚至都不需要知道A、B、C模块的存在，客户端只需要跟Facade类交互就好了，从而更好地实现了客户端和子系统中A、B、C模块的解耦，让客户端更容易地使用系统。

 

---

门面模式的实现

　　使用门面模式还有一个附带的好处，就是能够有选择性地暴露方法。一个模块中定义的方法可以分成两部分，一部分是给子系统外部使用的，一部分是子系统内部模块之间相互调用时使用的。有了Facade类，那么用于子系统内部模块之间相互调用的方法就不用暴露给子系统外部了。

一个系统可以有几个门面类

　　在门面模式中，通常只需要一个门面类，并且此门面类只有一个实例，换言之它是一个单例类。当然这并不意味着在整个系统里只有一个门面类，而仅仅是说对每一个子系统只有一个门面类。或者说，如果一个系统有好几个子系统的话，每一个子系统都有一个门面类，整个系统可以有数个门面类。

为子系统增加新行为

　　初学者往往以为通过继承一个门面类便可在子系统中加入新的行为，这是错误的。门面模式的用意是为子系统提供一个集中化和简化的沟通管道，而不能向子系统加入新的行为。比如医院中的接待员并不是医护人员，接待员并不能为病人提供医疗服务。

 

门面模式的优点

　　门面模式的优点：

　　●　　松散耦合

　　门面模式松散了客户端与子系统的耦合关系，让子系统内部的模块能更容易扩展和维护。

　　●　　简单易用

　　门面模式让子系统更加易用，客户端不再需要了解子系统内部的实现，也不需要跟众多子系统内部的模块进行交互，只需要跟门面类交互就可以了。

　　●　　更好的划分访问层次

　　通过合理使用Facade，可以帮助我们更好地划分访问的层次。有些方法是对系统外的，有些方法是系统内部使用的。把需要暴露给外部的功能集中到门面中，这样既方便客户端使用，也很好地隐藏了内部的细节。

　　　　　　

---

 

门面模式在Tomcat中的使用

　　Tomcat中门面模式使用的很多，因为Tomcat中有很多不同组件，每个组件要相互通信，但是又不能将自己内部数据过多的暴露给其他组件。用门面模式隔离数据是个很好的方法。

　　下面是Request上使用的门面模式：

　　

　　使用过Servlet的人都清楚，除了要在web.xml做相应的配置外，还需继承一个叫HttpServlet的抽象类，并且重写doGet与doPost方法（当然只重写service方法也是可以的）。

public class TestServlet extends HttpServlet {    public void doGet(HttpServletRequest request, HttpServletResponse response)            throws ServletException, IOException {                this.doPost(request, response);                }    public void doPost(HttpServletRequest request, HttpServletResponse response)            throws ServletException, IOException {                        }}

　　可以看出doGet与doPost方法有两个参数，参数类型是接口HttpServletRequest与接口HttpServletResponse，那么从Tomcat中传递过来的真实类型到底是什么呢？通过debug会发现，在真正调用TestServlet类之前，会经过很多Tomcat中的方法。如下图所示

　　注意红色方框圈中的类，StandardWrapperValue类中的invoke方法225行代码如下：

                        filterChain.doFilter                            (request.getRequest(), response.getResponse());

　　在StandardWrapperValue类中并没有直接将Request对象与Response对象传递给ApplicationFilterChain类的doFilter方法，传递的是RequestFacade与ResponseFacade对象，为什么这么说呢，看一下request.getRequest()与response.getResponse()方法就真相大白了。

　　Request类

    public HttpServletRequest getRequest() {        if (facade == null) {            facade = new RequestFacade(this);        }        return facade;    }

　　Response类

    public HttpServletResponse getResponse() {        if (facade == null) {            facade = new ResponseFacade(this);        }        return (facade);    }

　　可以看到它们返回都是各自的一个门面类，那么这样做有什么好处呢？

　　Request对象中的很多方法都是内部组件之间相互交互时使用的，比如setComet、setRequestedSessionId等方法（这里就不一一列举了）。这些方法并不对外部公开，但是又必须设置为public，因为还需要跟内部组件之间交互使用。最好的解决方法就是通过使用一个Facade类，将与内部组件之间交互使用的方法屏蔽掉，只提供给外部程序感兴趣的方法。

　　如果不使用Facade类，直接传递的是Request对象和Response对象，那么熟悉容器内部运作的程序员可以分别把ServletRequest和ServletResponse对象向下转换为Request和Response，并调用它们的公共方法。比如拥有Request对象，就可以调用setComet、setRequestedSessionId等方法，这会危害安全性。

10、桥接模式（Bridge）

桥接模式就是把事物和其具体实现分开，使他们可以各自独立的变化。桥接的用意是：将抽象化与实现化解耦，使得二者可以独立变化，像我们常用的JDBC桥DriverManager一样，JDBC进行连接数据库的时候，在各个数据库之间进行切换，基本不需要动太多的代码，甚至丝毫不用动，原因就是JDBC提供统一接口，每个数据库提供各自的实现，用一个叫做数据库驱动的程序来桥接就行了。我们来看看关系图：

http://blog.csdn.net/jason0539/article/details/22568865

概述:
在软件系统中，某些类型由于自身的逻辑，它具有两个或多个维度的变化，那么如何应对这种“多维度的变化”？如何利用面向对象的技术来使得该类型能够轻松的沿着多个方向进行变化，而又不引入额外的复杂度？这就要使用Bridge模式。
意图:
　　　将抽象部分与实现部分分离，使它们都可以独立的变化。
                                                                    ——《设计模式》GOF 

上面这些话我也没看懂。。太抽象了，但是一看代码你就明白是怎么回事了。
结构图:

 

传统的做法:
        通过类继承的方式来做上面的例子;
先看一下类结构图:

代码实现：

[java] view plain copy

 print?

1.         //基类 路  
2. class Road {  
3.     void run() {  
4.         System.out.println("路");  
5.     }  
6. }  
7.   
8. //市区街道  
9. class Street extends Road {  
10.     void run() {  
11.         System.out.println("市区街道");  
12.     }  
13. }  
14.   
15. //高速公路  
16. class SpeedWay extends Road {  
17.     void run() {  
18.         System.out.println("高速公路");  
19.     }  
20. }  
21. //小汽车在市区街道行驶  
22. class CarOnStreet extends Street {  
23.     void run() {  
24.         System.out.println("小汽车在市区街道行驶");  
25.     }  
26. }  
27. //小汽车在高速公路行驶  
28. class CarOnSpeedWay extends SpeedWay {  
29.     void run() {  
30.         System.out.println("小汽车在高速公路行驶");  
31.     }  
32. }  
33. //公交车在市区街道行驶  
34. class BusOnStreet extends Street {  
35.     void run() {  
36.         System.out.println("公交车在市区街道行驶");  
37.     }  
38. }  
39. //公交车在高速公路行驶  
40. class BusOnSpeedWay extends SpeedWay {  
41.     void run() {  
42.         System.out.println("公交车在高速公路行驶");  
43.     }  
44. }  
45. //测试  
46. public static void main(String[] args) {  
47.       
48.     //小汽车在高速公路行驶  
49.     CarOnSpeedWay carOnSpeedWay = new CarOnSpeedWay();  
50.     carOnSpeedWay.run();  
51.     //公交车在市区街道行驶  
52.     BusOnStreet busOnStreet = new BusOnStreet();  
53.     busOnStreet.run();  
54.   
55. }  

缺点:

     但是我们说这样的设计是脆弱的，仔细分析就可以发现，它还是存在很多问题，首先它在遵循开放-封闭原则的同时，违背了类的单一职责原则，即一个类只有一个引起它变化的原因，而这里引起变化的原因却有两个，即路类型的变化和汽车类型的变化；其次是重复代码会很多，不同的汽车在不同的路上行驶也会有一部分的代码是相同的；

再次是类的结构过于复杂，继承关系太多，难于维护，最后最致命的一点是扩展性太差。如果变化沿着汽车的类型和不同的道路两个方向变化，我们会看到这个类的结构会迅速的变庞大。

应用设计模式

       桥接模式（Bridge）来做;
先看一下类结构图:

代码实现：

[java] view plain copy

 print?

1. abstract class AbstractRoad{  
2.     AbstractCar aCar;  
3.     void run(){};  
4. }  
5. abstract class AbstractCar{  
6.     void run(){};  
7. }  
8.   
9. class Street extends AbstractRoad{  
10.     @Override  
11.     void run() {  
12.         // TODO Auto-generated method stub  
13.         super.run();  
14.         aCar.run();  
15.         System.out.println("在市区街道行驶");  
16.     }  
17. }  
18. class SpeedWay extends AbstractRoad{  
19.     @Override  
20.     void run() {  
21.         // TODO Auto-generated method stub  
22.         super.run();  
23.         aCar.run();  
24.         System.out.println("在高速公路行驶");  
25.     }  
26. }  
27. class Car extends AbstractCar{  
28.     @Override  
29.     void run() {  
30.         // TODO Auto-generated method stub  
31.         super.run();  
32.         System.out.print("小汽车");  
33.     }  
34. }  
35. class Bus extends AbstractCar{  
36.     @Override  
37.     void run() {  
38.         // TODO Auto-generated method stub  
39.         super.run();  
40.         System.out.print("公交车");  
41.     }  
42. }  
43.   
44. public static void main(String[] args){  
45.       
46.     AbstractRoad speedWay = new SpeedWay();  
47.     speedWay.aCar = new Car();  
48.     speedWay.run();  
49.       
50.     AbstractRoad street = new Street();  
51.     street.aCar = new Bus();  
52.     street.run();  
53. }  

 可以看到，通过对象组合的方式，Bridge 模式把两个角色之间的继承关系改为了耦合的关系，从而使这两者可以从容自若的各自独立的变化，这也是Bridge模式的本意。
      这样增加了客户程序与路与汽车的耦合。其实这样的担心是没有必要的，因为这种耦合性是由于对象的创建所带来的，完全可以用创建型模式去解决。在应用时结合创建型设计模式来处理具体的问题。

应用设计模式:

       桥接模式（Bridge）来做(多维度变化);
       结合上面的例子,增加一个维度"人",不同的人开着不同的汽车在不同的路上行驶(三个维度);
       结合上面增加一个类"人",并重新调用.
代码实现:

[java] view plain copy

 print?

1. abstract class People {  
2.     AbstractRoad road;  
3.   
4.     void run() {}  
5. }  
6.   
7. class Man extends People{  
8.     @Override  
9.     void run() {  
10.         // TODO Auto-generated method stub  
11.         super.run();  
12.         System.out.print("男人开着");  
13.         road.run();  
14.     }  
15. }  
16. class Woman extends People{  
17.     @Override  
18.     void run() {  
19.         // TODO Auto-generated method stub  
20.         super.run();  
21.         System.out.print("女人开着");  
22.         road.run();  
23.     }  
24. }  
25.   
26. public static void main(String[] args) {  
27.   
28.     AbstractRoad speedWay = new SpeedWay();  
29.     speedWay.aCar = new Car();  
30.       
31.     People man = new Man();  
32.     man.road = speedWay;  
33.     man.run();  
34. }  

效果及实现要点：

1．Bridge模式使用“对象间的组合关系”解耦了抽象和实现之间固有的绑定关系，使得抽象和实现可以沿着各自的维度来变化。
2．所谓抽象和实现沿着各自维度的变化，即“子类化”它们，得到各个子类之后，便可以任意它们，从而获得不同路上的不同汽车。
3．Bridge模式有时候类似于多继承方案，但是多继承方案往往违背了类的单一职责原则（即一个类只有一个变化的原因），复用性比较差。Bridge模式是比多继承方案更好的解决方法。
4．Bridge模式的应用一般在“两个非常强的变化维度”，有时候即使有两个变化的维度，但是某个方向的变化维度并不剧烈——换言之两个变化不会导致纵横交错的结果，并不一定要使用Bridge模式。

适用性：
   在以下的情况下应当使用桥梁模式：
1．如果一个系统需要在构件的抽象化角色和具体化角色之间增加更多的灵活性，避免在两个层次之间建立静态的联系。 
2．设计要求实现化角色的任何改变不应当影响客户端，或者说实现化角色的改变对客户端是完全透明的。
3．一个构件有多于一个的抽象化角色和实现化角色，系统需要它们之间进行动态耦合。 
4．虽然在系统中使用继承是没有问题的，但是由于抽象化角色和具体化角色需要独立变化，设计要求需要独立管理这两者。
总结：
      Bridge模式是一个非常有用的模式，也非常复杂，它很好的符合了开放-封闭原则和优先使用对象，而不是继承这两个面向对象原则。

11、组合模式（Composite）

组合模式有时又叫部分-整体模式在处理类似树形结构的问题时比较方便，看看关系图：

合成模式属于对象的结构模式，有时又叫做“部分——整体”模式。合成模式将对象组织到树结构中，可以用来描述整体与部分的关系。合成模式可以使客户端将单纯元素与复合元素同等看待。

---

合成模式

　　合成模式把部分和整体的关系用树结构表示出来。合成模式使得客户端把一个个单独的成分对象和由它们复合而成的合成对象同等看待。

　　比如，一个文件系统就是一个典型的合成模式系统。下图是常见的计算机XP文件系统的一部分。

　　从上图可以看出，文件系统是一个树结构，树上长有节点。树的节点有两种，一种是树枝节点，即目录，有内部树结构，在图中涂有颜色；另一种是文件，即树叶节点，没有内部树结构。

　　显然，可以把目录和文件当做同一种对象同等对待和处理，这也就是合成模式的应用。

　　合成模式可以不提供父对象的管理方法，但是合成模式必须在合适的地方提供子对象的管理方法，诸如：add()、remove()、以及getChild()等。

　　合成模式的实现根据所实现接口的区别分为两种形式，分别称为安全式和透明式。

安全式合成模式的结构

　　安全模式的合成模式要求管理聚集的方法只出现在树枝构件类中，而不出现在树叶构件类中。

　　这种形式涉及到三个角色：

　　●　　抽象构件(Component)角色：这是一个抽象角色，它给参加组合的对象定义出公共的接口及其默认行为，可以用来管理所有的子对象。合成对象通常把它所包含的子对象当做类型为Component的对象。在安全式的合成模式里，构件角色并不定义出管理子对象的方法，这一定义由树枝构件对象给出。

　　●　　树叶构件(Leaf)角色：树叶对象是没有下级子对象的对象，定义出参加组合的原始对象的行为。

　　●　　树枝构件(Composite)角色：代表参加组合的有下级子对象的对象。树枝构件类给出所有的管理子对象的方法，如add()、remove()以及getChild()。

源代码

　抽象构件角色类

public interface Component {    /**     * 输出组建自身的名称     */    public void printStruct(String preStr);}

　树枝构件角色类

public class Composite implements Component {    /**     * 用来存储组合对象中包含的子组件对象     */    private List<Component> childComponents = new ArrayList<Component>();    /**     * 组合对象的名字     */    private String name;    /**     * 构造方法，传入组合对象的名字     * @param name    组合对象的名字     */    public Composite(String name){        this.name = name;    }    /**     * 聚集管理方法，增加一个子构件对象     * @param child 子构件对象     */    public void addChild(Component child){        childComponents.add(child);    }    /**     * 聚集管理方法，删除一个子构件对象     * @param index 子构件对象的下标     */    public void removeChild(int index){        childComponents.remove(index);    }    /**     * 聚集管理方法，返回所有子构件对象     */    public List<Component> getChild(){        return childComponents;    }    /**     * 输出对象的自身结构     * @param preStr 前缀，主要是按照层级拼接空格，实现向后缩进     */    @Override    public void printStruct(String preStr) {        // 先把自己输出        System.out.println(preStr + "+" + this.name);        //如果还包含有子组件，那么就输出这些子组件对象        if(this.childComponents != null){            //添加两个空格，表示向后缩进两个空格            preStr += "  ";            //输出当前对象的子对象            for(Component c : childComponents){                //递归输出每个子对象                c.printStruct(preStr);            }        }            }}

　树叶构件角色类

public class Leaf implements Component {    /**     * 叶子对象的名字     */    private String name;    /**     * 构造方法，传入叶子对象的名称     * @param name 叶子对象的名字     */    public Leaf(String name){        this.name = name;    }    /**     * 输出叶子对象的结构，叶子对象没有子对象，也就是输出叶子对象的名字     * @param preStr 前缀，主要是按照层级拼接的空格，实现向后缩进     */    @Override    public void printStruct(String preStr) {        // TODO Auto-generated method stub        System.out.println(preStr + "-" + name);    }}

　客户端类

public class Client {    public static void main(String[]args){        Composite root = new Composite("服装");        Composite c1 = new Composite("男装");        Composite c2 = new Composite("女装");                Leaf leaf1 = new Leaf("衬衫");        Leaf leaf2 = new Leaf("夹克");        Leaf leaf3 = new Leaf("裙子");        Leaf leaf4 = new Leaf("套装");                root.addChild(c1);        root.addChild(c2);        c1.addChild(leaf1);        c1.addChild(leaf2);        c2.addChild(leaf3);        c2.addChild(leaf4);                root.printStruct("");    }}

　　可以看出，树枝构件类(Composite)给出了addChild()、removeChild()以及getChild()等方法的声明和实现，而树叶构件类则没有给出这些方法的声明或实现。这样的做法是安全的做法，由于这个特点，客户端应用程序不可能错误地调用树叶构件的聚集方法，因为树叶构件没有这些方法，调用会导致编译错误。

　　安全式合成模式的缺点是不够透明，因为树叶类和树枝类将具有不同的接口。

透明式合成模式的结构

　　与安全式的合成模式不同的是，透明式的合成模式要求所有的具体构件类，不论树枝构件还是树叶构件，均符合一个固定接口。

　　

源代码

　　抽象构件角色类

public abstract class Component {    /**     * 输出组建自身的名称     */    public abstract void printStruct(String preStr);    /**     * 聚集管理方法，增加一个子构件对象     * @param child 子构件对象     */    public void addChild(Component child){        /**         * 缺省实现，抛出异常，因为叶子对象没有此功能         * 或者子组件没有实现这个功能         */        throw new UnsupportedOperationException("对象不支持此功能");    }    /**     * 聚集管理方法，删除一个子构件对象     * @param index 子构件对象的下标     */    public void removeChild(int index){        /**         * 缺省实现，抛出异常，因为叶子对象没有此功能         * 或者子组件没有实现这个功能         */        throw new UnsupportedOperationException("对象不支持此功能");    }        /**     * 聚集管理方法，返回所有子构件对象     */    public List<Component> getChild(){        /**         * 缺省实现，抛出异常，因为叶子对象没有此功能         * 或者子组件没有实现这个功能         */        throw new UnsupportedOperationException("对象不支持此功能");    }}

　　树枝构件角色类，此类将implements Conponent改为extends Conponent，其他地方无变化。

public class Composite extends Component {    /**     * 用来存储组合对象中包含的子组件对象     */    private List<Component> childComponents = new ArrayList<Component>();    /**     * 组合对象的名字     */    private String name;    /**     * 构造方法，传入组合对象的名字     * @param name    组合对象的名字     */    public Composite(String name){        this.name = name;    }    /**     * 聚集管理方法，增加一个子构件对象     * @param child 子构件对象     */    public void addChild(Component child){        childComponents.add(child);    }    /**     * 聚集管理方法，删除一个子构件对象     * @param index 子构件对象的下标     */    public void removeChild(int index){        childComponents.remove(index);    }    /**     * 聚集管理方法，返回所有子构件对象     */    public List<Component> getChild(){        return childComponents;    }    /**     * 输出对象的自身结构     * @param preStr 前缀，主要是按照层级拼接空格，实现向后缩进     */    @Override    public void printStruct(String preStr) {        // 先把自己输出        System.out.println(preStr + "+" + this.name);        //如果还包含有子组件，那么就输出这些子组件对象        if(this.childComponents != null){            //添加两个空格，表示向后缩进两个空格            preStr += "  ";            //输出当前对象的子对象            for(Component c : childComponents){                //递归输出每个子对象                c.printStruct(preStr);            }        }            }}

　　树叶构件角色类，此类将implements Conponent改为extends Conponent，其他地方无变化。

public class Leaf extends Component {    /**     * 叶子对象的名字     */    private String name;    /**     * 构造方法，传入叶子对象的名称     * @param name 叶子对象的名字     */    public Leaf(String name){        this.name = name;    }    /**     * 输出叶子对象的结构，叶子对象没有子对象，也就是输出叶子对象的名字     * @param preStr 前缀，主要是按照层级拼接的空格，实现向后缩进     */    @Override    public void printStruct(String preStr) {        // TODO Auto-generated method stub        System.out.println(preStr + "-" + name);    }}

　　客户端类的主要变化是不再区分Composite对象和Leaf对象。

public class Client {    public static void main(String[]args){        Component root = new Composite("服装");        Component c1 = new Composite("男装");        Component c2 = new Composite("女装");                Component leaf1 = new Leaf("衬衫");        Component leaf2 = new Leaf("夹克");        Component leaf3 = new Leaf("裙子");        Component leaf4 = new Leaf("套装");                root.addChild(c1);        root.addChild(c2);        c1.addChild(leaf1);        c1.addChild(leaf2);        c2.addChild(leaf3);        c2.addChild(leaf4);                root.printStruct("");    }}

　　可以看出，客户端无需再区分操作的是树枝对象(Composite)还是树叶对象(Leaf)了；对于客户端而言，操作的都是Component对象。

两种实现方法的选择

　　这里所说的安全性合成模式是指：从客户端使用合成模式上看是否更安全，如果是安全的，那么就不会有发生误操作的可能，能访问的方法都是被支持的。

　　这里所说的透明性合成模式是指：从客户端使用合成模式上，是否需要区分到底是“树枝对象”还是“树叶对象”。如果是透明的，那就不用区分，对于客户而言，都是Compoent对象，具体的类型对于客户端而言是透明的，是无须关心的。

　　对于合成模式而言，在安全性和透明性上，会更看重透明性，毕竟合成模式的目的是：让客户端不再区分操作的是树枝对象还是树叶对象，而是以一个统一的方式来操作。

　　而且对于安全性的实现，需要区分是树枝对象还是树叶对象。有时候，需要将对象进行类型转换，却发现类型信息丢失了，只好强行转换，这种类型转换必然是不够安全的。

因此在使用合成模式的时候，建议多采用透明性的实现方式。　

使用场景：将多个对象组合在一起进行操作，常用于表示树形结构中，例如二叉树，数等。

12、享元模式（Flyweight）

享元模式的主要目的是实现对象的共享，即共享池，当系统中对象多的时候可以减少内存的开销，通常与工厂模式一起使用。

http://www.cnblogs.com/java-my-life/archive/2012/04/26/2468499.html

Flyweight在拳击比赛中指最轻量级，即“蝇量级”或“雨量级”，这里选择使用“享元模式”的意译，是因为这样更能反映模式的用意。享元模式是对象的结构模式。享元模式以共享的方式高效地支持大量的细粒度对象。

---

Java中的String类型

　　在JAVA语言中，String类型就是使用了享元模式。String对象是final类型，对象一旦创建就不可改变。在JAVA中字符串常量都是存在常量池中的，JAVA会确保一个字符串常量在常量池中只有一个拷贝。String a="abc"，其中"abc"就是一个字符串常量。

public class Test {    public static void main(String[] args) {                String a = "abc";        String b = "abc";        System.out.println(a==b);            }}

　　上面的例子中结果为：true ，这就说明a和b两个引用都指向了常量池中的同一个字符串常量"abc"。这样的设计避免了在创建N多相同对象时所产生的不必要的大量的资源消耗。 

享元模式的结构

　　享元模式采用一个共享来避免大量拥有相同内容对象的开销。这种开销最常见、最直观的就是内存的损耗。享元对象能做到共享的关键是区分内蕴状态(Internal State)和外蕴状态(External State)。

　　一个内蕴状态是存储在享元对象内部的，并且是不会随环境的改变而有所不同。因此，一个享元可以具有内蕴状态并可以共享。

　　一个外蕴状态是随环境的改变而改变的、不可以共享的。享元对象的外蕴状态必须由客户端保存，并在享元对象被创建之后，在需要使用的时候再传入到享元对象内部。外蕴状态不可以影响享元对象的内蕴状态，它们是相互独立的。

　　享元模式可以分成单纯享元模式和复合享元模式两种形式。

单纯享元模式　　

　　在单纯的享元模式中，所有的享元对象都是可以共享的。

　　单纯享元模式所涉及到的角色如下：

　　●　　抽象享元(Flyweight)角色 ：给出一个抽象接口，以规定出所有具体享元角色需要实现的方法。

　　●　　具体享元(ConcreteFlyweight)角色：实现抽象享元角色所规定出的接口。如果有内蕴状态的话，必须负责为内蕴状态提供存储空间。

　　●　　享元工厂(FlyweightFactory)角色 ：本角色负责创建和管理享元角色。本角色必须保证享元对象可以被系统适当地共享。当一个客户端对象调用一个享元对象的时候，享元工厂角色会检查系统中是否已经有一个符合要求的享元对象。如果已经有了，享元工厂角色就应当提供这个已有的享元对象；如果系统中没有一个适当的享元对象的话，享元工厂角色就应当创建一个合适的享元对象。

源代码

　　抽象享元角色类

public interface Flyweight {    //一个示意性方法，参数state是外蕴状态    public void operation(String state);}

　　具体享元角色类ConcreteFlyweight有一个内蕴状态，在本例中一个Character类型的intrinsicState属性代表，它的值应当在享元对象被创建时赋予。所有的内蕴状态在对象创建之后，就不会再改变了。

　　如果一个享元对象有外蕴状态的话，所有的外部状态都必须存储在客户端，在使用享元对象时，再由客户端传入享元对象。这里只有一个外蕴状态，operation()方法的参数state就是由外部传入的外蕴状态。

public class ConcreteFlyweight implements Flyweight {    private Character intrinsicState = null;    /**     * 构造函数，内蕴状态作为参数传入     * @param state     */    public ConcreteFlyweight(Character state){        this.intrinsicState = state;    }            /**     * 外蕴状态作为参数传入方法中，改变方法的行为，     * 但是并不改变对象的内蕴状态。     */    @Override    public void operation(String state) {        // TODO Auto-generated method stub        System.out.println("Intrinsic State = " + this.intrinsicState);        System.out.println("Extrinsic State = " + state);    }}

　　享元工厂角色类，必须指出的是，客户端不可以直接将具体享元类实例化，而必须通过一个工厂对象，利用一个factory()方法得到享元对象。一般而言，享元工厂对象在整个系统中只有一个，因此也可以使用单例模式。

　　当客户端需要单纯享元对象的时候，需要调用享元工厂的factory()方法，并传入所需的单纯享元对象的内蕴状态，由工厂方法产生所需要的享元对象。

public class FlyweightFactory {    private Map<Character,Flyweight> files = new HashMap<Character,Flyweight>();        public Flyweight factory(Character state){        //先从缓存中查找对象        Flyweight fly = files.get(state);        if(fly == null){            //如果对象不存在则创建一个新的Flyweight对象            fly = new ConcreteFlyweight(state);            //把这个新的Flyweight对象添加到缓存中            files.put(state, fly);        }        return fly;    }}

　　客户端类

public class Client {    public static void main(String[] args) {        // TODO Auto-generated method stub        FlyweightFactory factory = new FlyweightFactory();        Flyweight fly = factory.factory(new Character('a'));        fly.operation("First Call");                fly = factory.factory(new Character('b'));        fly.operation("Second Call");                fly = factory.factory(new Character('a'));        fly.operation("Third Call");    }}

　　虽然客户端申请了三个享元对象，但是实际创建的享元对象只有两个，这就是共享的含义。运行结果如下：

复合享元模式

　　在单纯享元模式中，所有的享元对象都是单纯享元对象，也就是说都是可以直接共享的。还有一种较为复杂的情况，将一些单纯享元使用合成模式加以复合，形成复合享元对象。这样的复合享元对象本身不能共享，但是它们可以分解成单纯享元对象，而后者则可以共享。

　　

　　复合享元角色所涉及到的角色如下：

　　●　　抽象享元(Flyweight)角色 ：给出一个抽象接口，以规定出所有具体享元角色需要实现的方法。

　　●　　具体享元(ConcreteFlyweight)角色：实现抽象享元角色所规定出的接口。如果有内蕴状态的话，必须负责为内蕴状态提供存储空间。

　　●　  复合享元(ConcreteCompositeFlyweight)角色 ：复合享元角色所代表的对象是不可以共享的，但是一个复合享元对象可以分解成为多个本身是单纯享元对象的组合。复合享元角色又称作不可共享的享元对象。

　　●　  享元工厂(FlyweightFactory)角色 ：本角 色负责创建和管理享元角色。本角色必须保证享元对象可以被系统适当地共享。当一个客户端对象调用一个享元对象的时候，享元工厂角色会检查系统中是否已经有 一个符合要求的享元对象。如果已经有了，享元工厂角色就应当提供这个已有的享元对象；如果系统中没有一个适当的享元对象的话，享元工厂角色就应当创建一个 合适的享元对象。

源代码

　　抽象享元角色类

public interface Flyweight {    //一个示意性方法，参数state是外蕴状态    public void operation(String state);}

　　具体享元角色类

public class ConcreteFlyweight implements Flyweight {    private Character intrinsicState = null;    /**     * 构造函数，内蕴状态作为参数传入     * @param state     */    public ConcreteFlyweight(Character state){        this.intrinsicState = state;    }            /**     * 外蕴状态作为参数传入方法中，改变方法的行为，     * 但是并不改变对象的内蕴状态。     */    @Override    public void operation(String state) {        // TODO Auto-generated method stub        System.out.println("Intrinsic State = " + this.intrinsicState);        System.out.println("Extrinsic State = " + state);    }}

　　复合享元对象是由单纯享元对象通过复合而成的，因此它提供了add()这样的聚集管理方法。由于一个复合享元对象具有不同的聚集元素，这些聚集元素在复合享元对象被创建之后加入，这本身就意味着复合享元对象的状态是会改变的，因此复合享元对象是不能共享的。

　　复合享元角色实现了抽象享元角色所规定的接口，也就是operation()方法，这个方法有一个参数，代表复合享元对象的外蕴状态。一个复合享元对象的所有单纯享元对象元素的外蕴状态都是与复合享元对象的外蕴状态相等的；而一个复合享元对象所含有的单纯享元对象的内蕴状态一般是不相等的，不然就没有使用价值了。

public class ConcreteCompositeFlyweight implements Flyweight {        private Map<Character,Flyweight> files = new HashMap<Character,Flyweight>();    /**     * 增加一个新的单纯享元对象到聚集中     */    public void add(Character key , Flyweight fly){        files.put(key,fly);    }    /**     * 外蕴状态作为参数传入到方法中     */    @Override    public void operation(String state) {        Flyweight fly = null;        for(Object o : files.keySet()){            fly = files.get(o);            fly.operation(state);        }            }}

　　享元工厂角色提供两种不同的方法，一种用于提供单纯享元对象，另一种用于提供复合享元对象。

public class FlyweightFactory {    private Map<Character,Flyweight> files = new HashMap<Character,Flyweight>();    /**     * 复合享元工厂方法     */    public Flyweight factory(List<Character> compositeState){        ConcreteCompositeFlyweight compositeFly = new ConcreteCompositeFlyweight();                for(Character state : compositeState){            compositeFly.add(state,this.factory(state));        }                return compositeFly;    }    /**     * 单纯享元工厂方法     */    public Flyweight factory(Character state){        //先从缓存中查找对象        Flyweight fly = files.get(state);        if(fly == null){            //如果对象不存在则创建一个新的Flyweight对象            fly = new ConcreteFlyweight(state);            //把这个新的Flyweight对象添加到缓存中            files.put(state, fly);        }        return fly;    }}

　　客户端角色

public class Client {    public static void main(String[] args) {        List<Character> compositeState = new ArrayList<Character>();        compositeState.add('a');        compositeState.add('b');        compositeState.add('c');        compositeState.add('a');        compositeState.add('b');                FlyweightFactory flyFactory = new FlyweightFactory();        Flyweight compositeFly1 = flyFactory.factory(compositeState);        Flyweight compositeFly2 = flyFactory.factory(compositeState);        compositeFly1.operation("Composite Call");                System.out.println("---------------------------------");                System.out.println("复合享元模式是否可以共享对象：" + (compositeFly1 == compositeFly2));                Character state = 'a';        Flyweight fly1 = flyFactory.factory(state);        Flyweight fly2 = flyFactory.factory(state);        System.out.println("单纯享元模式是否可以共享对象：" + (fly1 == fly2));    }}

 

运行结果如下：

　　从运行结果可以看出，一个复合享元对象的所有单纯享元对象元素的外蕴状态都是与复合享元对象的外蕴状态相等的。即外运状态都等于Composite Call。

　　从运行结果可以看出，一个复合享元对象所含有的单纯享元对象的内蕴状态一般是不相等的。即内蕴状态分别为b、c、a。

　　从运行结果可以看出，复合享元对象是不能共享的。即使用相同的对象compositeState通过工厂分别两次创建出的对象不是同一个对象。

　　从运行结果可以看出，单纯享元对象是可以共享的。即使用相同的对象state通过工厂分别两次创建出的对象是同一个对象。

享元模式的优缺点

　　享元模式的优点在于它大幅度地降低内存中对象的数量。但是，它做到这一点所付出的代价也是很高的：

　　●　　享元模式使得系统更加复杂。为了使对象可以共享，需要将一些状态外部化，这使得程序的逻辑复杂化。

　　●　　享元模式将享元对象的状态外部化，而读取外部状态使得运行时间稍微变长。

通过连接池的管理，实现了数据库连接的共享，不需要每一次都重新创建连接，节省了数据库重新创建的开销，提升了系统的性能！本章讲解了7种结构型模式，因为篇幅的问题，剩下的11种行为型模式，我们将另起篇章，敬请读者朋友们持续关注！