结构型模式描述如何将类或对象按某种布局组成更大的结构。它分为类结构型模式和对象结构型模式，前者采用继承机制来组织接口和类，后者采用组合或聚合来组合对象。
由于组合关系或者聚合关系比继承关系耦合度低，满足"合成复用原则"，所以对象结构模式比类结构模式具有更大的灵活性。
结构型模式分为以下七种:
- 代理模式
- 适配器模式
- 装饰器模式
- 桥接模式
- 外观模式
- 组合模式
- 亨元模式
由于某些原因需要给某对象提供一个代理以控制对该对象的访问。这时，访问对象不适合或者不能直接引用目标对象，代理对象作为访问对象和访问对象之间中介。
Java中代理按照代理类生成时机不同又分为静态代理和动态代理。静态代理代理类在编译期就生成，而动态代理类则是在Java运行时动态生成。动态代理又分为JDK代理和CGLib代理两种。
代理(Proxy)模式分为三种角色:
- 抽象主题类(Subject): 通过接口或抽象类声明真实主题和代理对象实现的业务方法。
- 真实主题类(Real Subject): 实现了抽象主题中的具体业务，是代理对象所代表的真实对象，是最终要引用的对象。
- 代理类(Proxy): 提供了与真实主题相同的接口，其内部含有对真实主题的引用，它可以反问，控制或扩展真实主题的功能。
示例
如果需买火车票的话，需要去火车站买票，排队等一系列的 *** 作，显然比较麻烦，而火车站在多个地方都有代售点，我们去代售点买票就方便很多了。这个例子其实就是典型的代理模式，火车站是目标对象，代售点是代理对象。类图如下:
代码如下
public interface SellTickets{
void sell();
}
public class TrainStation implements SellTickets{
@Override
public void sell(){
System.out.println("火车站买票");
}
}
public class ProxyPoint implements SellTickets{
private SellTickets sellTickets;
public void setSellTickets(SellTickets sellTickets){
this.sellTickets = sellTickets;
}
@Override
public void sell(){
sellTickets.sell();
}
}
public class Client{
public static void main(String[] args){
TrainStation tranStation = new TrainStation();
ProxyPoint proxyPoint = new ProxyPoint();
proxyPoint.setSellTickets(tranStation);
proxyPoint.sell();
}
}
从上面代码中可以看出测试直接访问的是ProxyPoint类对象，也就是说ProxyPoint作为访问对象和目标对象的中介。同时也对sell方法进行增强(代理点收取一些费用)。
(4).JDK动态代理JDK提供的动态代理: Java中提供了一个动态代理类Proxy, Proxy并不是代理对象的类，而是提供一个创建代理对象的静态方法(newProxyInstance方法)来获取代理对象。
示例
/**
*卖票接口
*/
public interface SellTickets{
void sell();
}
/**
* 火车站 火车站具有卖票功能，所以需要实现SellTickets接口
*/
public class TrainStation implements SellTickets{
@Override
public void sell(){
System.out.println("火车站买票");
}
}
/**
* 获取代理对象的工厂类
* 代理类也实现了相应的接口
*/
class ProxyFactory implements InvocationHandler {
private TrainStation trainStation;
public Object bind(TrainStation trainStation) {
this.trainStation = trainStation;
Object obj = Proxy.newProxyInstance(Test01.class.getClassLoader(), trainStation.getClass().getInterfaces(), this);
return obj;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("执行之前....");
method.invoke(trainStation, args);
System.out.println("执行之后....");
return null;
}
}
public class Client {
public static void main(String[] args) {
ProxyFactory factory = new ProxyFactory();
TrainStation trainStation = new TrainStation();
Object bind = factory.bind(trainStation);
SellTickets sellTickets = (SellTickets) bind;
sellTickets.sell();
}
}
还是买票案例, 如果没有定义SellTickets接口，只定义TrainStation(火车站类)。很显然JDK代理是无法使用了，因为JDK动态代理要求必须定义接口，对接口进行代理。
CGLIB是一个功能强大，高性能的代码生成包。它为没有实现接口的类提供代理，为JDK的动态代理提供了很好的补充。
CGLIB是第三方提供的包，所以需要引入jar包的坐标:
<dependency>
<groupId>cglibgroupId>
<artifactId>cglibartifactId>
<version>2.2.2version>
dependency>
代码如下:
package com.xiaotian.test;
public class TrainStation {
public void sell(){
System.out.println("卖票");
}
}
package com.xiaotian.test;
import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
import java.lang.reflect.Method;
public class ProxyFactory implements MethodInterceptor {
private Enhancer enhancer = new Enhancer();
public Object getProxyObj(Class clazz) {
//设置父类
enhancer.setSuperclass(clazz);
enhancer.setCallback(this);
enhancer.setUseCache(false);
return enhancer.create();
}
@Override
public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
System.out.println("卖票前");
methodProxy.invokeSuper(o, objects);
System.out.println("卖票后");
return null;
}
public static void main(String[] args) {
ProxyFactory proxyFactory = new ProxyFactory();
TrainStation trainStation = (TrainStation) proxyFactory.getProxyObj(TrainStation.class);
trainStation.sell();
}
}
- jdk代理和CGLB代理
使用CGLib实现动态代理，CGLib底层采用ASM字节码生成框架，使用字节码技术生成代理类，在JDK1.6之前比使用Java反射效率要高。唯一需要注意的是，CGLib不能对声明为final的类或者方法进行代理，因为CGLib原理是动态生成被代理类的子类。
在JDK1.6，JDK1.7, JDK1.8逐步对JDK动态代理优化之后，在调用次数较少的情况下，JDK代理效率高于CGLib代理效率，只有当进行大量调用的时候，JDK1.6和JDK1.7比CGLib代理效率低一点，但是到JDK1.8的时候，代理效率高于CGLib代理。所以如果有接口使用JDK动态代理，如果没有接口使用CGLib代理。 - 动态代理和静态代理
动态代理与静态代理相比较，最大的好处是接口中声明的所有方法都被转移到调用处理器一个集中的方法中处理(InvoactionHandler.invoke)。这样，在接口方法数量比较多的时候，我们可以进行灵活处理，而不需要静态代理那样每一个方法进行中转。
如果接口增加一个方法，静态代理模式除了所有实现类需要实现这个方法外，所有代理类也需要实现此方法。增加代码维护的复杂度。而动态代理不会出现该问题。
- 代理模式在客户端与目标对象之间起到一个中介作用与保护目标对象的作用。
- 代理对象可以扩展目标对象的功能
- 代理模式能将客户端与目标对象分离，在一定程度上降低了系统的耦合度；
- 增加了系统的复杂度
- 远程(Remote)代理
本地服务通过网络请求远程服务。为了实现本地到远程的通信，我们需要实现网络通信，处理其中可能的异常。为良好的代码设计和可维护性，我们将网络通信部分隐藏起来，只暴露给本地服务一个接口，通过该接口即可访问远程提供的功能，而不必过多关心通信部分的细节。 - 防火墙(Firewall)代理
当你将浏览器配置成使用代理功能时，防火墙就将你的浏览器的请求转给互联网；当互联网返回响应时，代理服务器再把它转给你的浏览器。 - 保护(Protect or Access)代理
控制一个对象的访问，如果需要，可以给不同的用户提供不同级别的使用权限。
如果去欧洲国家去旅行的话，他们的插座如下图所示最左## 边，是欧洲标准。而我们使用的插头如下图所示最右边的。因此我们的笔记本电脑，手机在当地不能直接充电。所以就需要一个插座转换器，转换器第1面插入当地的插座，第2面供我们充电，这样使得我们的插头在当地能使用。生活中这样的例子很多，手机充电器(将220v转换为5v的电压)，读卡器等，其实就是使用到了适配器模式。
将一个类的接口转换成客户希望的另外一个接口，使得原本由于接口不兼容而不能一起工作的那些类能一起工作。
适配器模式分为类适配器模式和对象适配器模式，前者类之间的耦合度比后者高，且要求程序员了解现有组件库中的相关组件的内部结构，所以应用相对较少些。
适配器模式(Adapter)包含以下主要角色:
- 目标(Target)接口: 主要系统业务所期待的接口，它可以是抽象类或接口。
- 被适配者(Adaptee)类: 它是被访问和适配的现存组件库中的组件接口。
- 适配器(Adapter)类: 它是一个转换器，通过集成或引用适配者的对象，把适配者接口转换成目标接口，让客户按目标接口的格式访问适配者。
读卡器
现有一台电脑只能读取sd卡，而要读取TF卡中内容就需要使用到适配器模式。创建一个读卡器，将TF卡中内容读取出来。
类图如下所示:
代码如下:
public interface TFCard{
//从TF卡中读取数据
String readTF();
//往TF卡中写数据
void writeTF(String msg);
}
public class TFCardImpl implements TFCard{
public String readTF(){
String msg = "TFCard read msg: hello world TFCard";
return msg
}
public void writeTF(String msg){
System.out.println("TFCard write msg:" + msg);
}
}
public interface SDCard{
public String readSD();
public void writeSD(String msg);
}
public class SDCardImpl implements SDCard{
public String readSD(){
String msg = "SDCard read msg: hello word SD";
return msg;
}
public void writeSD(String msg){
System.out.println("SDCard write msg:" + msg);
}
}
public class Computer{
//从SD卡中读取数据
public String readSD(SDCard sdCard){
if(sdCard == null){
throw new NullPointerException("sd card is not null");
}
return sdCard.readSD();
}
}
public class SDAdapterTF extends TFCardImpl implements SDCard{
public String readSD(){
System.out.println("adapter read tf card");
return readTF();
}
public void writeSD(String msg){
System.out.println("adapter write tf card");
writeTF(msg);
}
}
public class Client{
public static void main(String[] args){
//创建计算机对象
Computer computer = new Computer();
//读取SD卡中的数据
String msg = computer.readSD(new SDCardImpl());
System.out.println(msg);
System.out.println("===================");
//使用该电脑读取TF卡中的数据
//定义适配器类
String msg1 = computer.readSD(new SDAdapterTTF());
System.out.println(msg1);
}
}
注意:类适配器模式违背了合成复用原则。类适配器是客户类有一个接口规范的情况下可用，反之不可用。
(5).对象适配器模式实现方式:对象适配器模式可采用将现有组件库中已经实现的组件引入适配类中，该类同时实现当前系统的业务接口。
示例
读卡器
将上面的示例进行改写，其类图如下:
代码如下:
public interface TFCard{
//从TF卡中读取数据
String readTF();
//往TF卡中写数据
void writeTF(String msg);
}
public class TFCardImpl implements TFCard{
public String readTF(){
String msg = "TFCard read msg: hello world TFCard";
return msg
}
public void writeTF(String msg){
System.out.println("TFCard write msg:" + msg);
}
}
public interface SDCard{
public String readSD();
public void writeSD(String msg);
}
public class SDCardImpl implements SDCard{
public String readSD(){
String msg = "SDCard read msg: hello word SD";
return msg;
}
public void writeSD(String msg){
System.out.println("SDCard write msg:" + msg);
}
}
public class Computer{
//从SD卡中读取数据
public String readSD(SDCard sdCard){
if(sdCard == null){
throw new NullPointerException("sd card is not null");
}
return sdCard.readSD();
}
}
public class SDAdapterTF implements SDCard{
private TFCard tfCard;
public SDAdapterTF(TFCard tfCard);
public String readSD(){
System.out.println("adapter read tf card");
return tfCard.readTF();
}
public void writeSD(String msg){
System.out.println("adapter write tf card");
writeTF(msg);
}
}
public class Client{
public static void main(String[] args){
//创建计算机对象
Computer computer = new Computer();
//读取SD卡中的数据
String msg = computer.readSD(new SDCardImpl());
System.out.println(msg);
System.out.println("===================");
//使用该电脑读取TF卡中的数据
//定义适配器类
String msg1 = computer.readSD(new SDAdapterTTF(new TFCardImpl()));
System.out.println(msg1);
}
}
注意:还有一个适配器模式是接口适配器模式。当不希望实现一个接口中所有方法时，可以创建一个抽闲类Adapter, 实现所有方法。故只需要继承抽象类即可。
(6).应用场景- 以前开发的系统存在满足新系统功能需求的类，但其接口同新系统的接口不一致。
- 使用第三方提供的组件，但组件接口定义与自己要求的接口定义不同。
Reader(字符流), InputStream(字节流)的适配使用的是就是InputStreamReader和OutputStreamWriter。
InputStreamReader和OutputStreamWriter分别继承自java.io包中Reader和Writer，对他们中抽象的未实现的方法给出实现.如:
public int read() throws IOException{
return sd.read();
}
public int read(char[] cbuf, int offset, int length) throws IOException{
return sd.read(cbuf, offset, length);
}
上述代码中的sd(StreamDeconder类对象)，在Sun的JDK实现中，实际的方法实现对sun.nio.cs.StreamDecoder类的同名方法的调用封账，类结构图如下:
从上图可以看出:
- InputStreamReader是对同样实现了Reader的StreamDecoder的封装。
- StreamDecoder不是Java SE API中的内容，是Sun JDK给出的自身实现。但我们知道他们对构造方法中的字节流类(InputStream)进行封装，并通过该类进行了字节流和字符流之间的解码转换。
结论:
从表层来看，InputStream字节流之间的转换。而从如下Sun JDK中的实现类关系结构中可以看出，是StreamDecoder的设计实现在实际上采用了适配器模式。
示例
快餐店
快餐店有炒面，炒饭这些快餐，可以额外附加鸡蛋，火腿，培根这些配菜，当然加配菜需要额外加钱，每个配菜的加钱通常不太一样，那么计算总价就会显得比较麻烦。
类图如下:
代码如下:
public class FastFood{
private float price;
private String desc;
public void setPrice(float price){
this.price = price;
}
public void setDesc(String desc){
this.desc = desc;
}
public float getPrice(){
return this.price;
}
public String getDesc(){
return this.desc;
}
public float cost(){
return 0.0;
}
}
使用继承的方式存在的问题:
- 扩展性不好
如果要再加一种配料(火腿肠)，我们就会发现需要给FriedRice和FriedNoodles分别定义一个子类。如果要新增一个快餐类(炒河粉)的话，就需要定义更多的子类。 - 产生过多子类
指在不改变现有对象结构的情况下，动态地给该对象增加一些职责(即增加其额外功能)的模式。
(3).结构装饰(Decoator)模式中的角色:
- 抽象构件(Component)角色: 定义一个抽象接口以规范准备接受附加责任的对象。
- 具体构件(Concrete Component)角色: 实现抽象构件，通过装饰角色为其添加一些职责。
- 抽象装饰(Decorator)角色: 继承或实现抽象构件，并包含具体构件的实例，可以通过其子类扩展具体构建的功能。
- 具体装饰(ConcreteDecorator)角色: 实现抽象装饰的相关方法，并给具体构件对象添加附加的责任。
示例:
快餐店
类图如下:
代码具体如下:
public abstract class FastFood{
private float price;
private String desc;
public FastFood(){
}
public FastFood(float price, String desc){
this.price = price;
this.desc = desc;
}
public float getPrice(){
return this.price;
}
public void setPrice(float price){
this.price = price;
}
public String getDesc(){
return this.desc;
}
public void setDesc(String desc){
this.desc = desc;
}
}
public class FriedRice extends FastFood{
public FriedRice(){
super(10, "炒饭");
}
public float cost(){
return getPrice();
}
}
public class FiredNoodles extends FastFood{
public FiredNoodles(){
super(12, "炒面");
}
public float cost(){
return getPrice();
}
}
public abstract class Garnish extends FastFood{
//声明快餐类的变量
private FastFood fastFood;
public Garnish(FastFood fastFood, float price, String desc){
super(price, desc);
this.fastFood = fastFood;
}
public FastFood getFastFood(){
return this.fastFood;
}
public void setFastFood(FastFood fastFood){
this.fastFood = fastFood;
}
}
public class Egg extends Garnish{
public Egg(FastFood fastFood){
super(fastFood, 1, "鸡蛋");
}
public float cost(){
return this.getPrice() + this.getFastFood().const();
}
@Override
public String getDesc(){
return super.getDesc() + this.getFastFood().getDesc();
}
}
public class Client{
public static void main(String[] args){
//点一份炒饭
FriedRice food = new FriedRice();
System.out.println(food.getDesc()+" "+food.cost());
System.out.println("================");
//在上面的炒饭中加一个鸡蛋
food = new Egg(food);
System.out.println(food.getDesc()+" "+ food.cost());
//再加一个鸡蛋
food = new Egg(food);
System.out.println(food.getDesc()+" "+ food.cost());
}
}
- 装饰者模式可以带来比继承更加灵活性的扩展功能，使用更加方便，可以通过组合不同的装饰者对象类获取具有不同行为状态的多样化的结果。装饰者模式比继承更具有良好扩展性，完美的遵循开闭原则，继承是静态的附加责任，装饰者则是动态的附加责任。
- 装饰类和被装饰类可以独立发展，不会相互耦合，装饰模式是继承的一个替代模式，装饰模式可以动态扩展一个实现类的功能。
- 当不能采用继承的方式对系统进行扩充或采用继承不利于系统扩展和维护时。
不能采用继承的情况主要有两类:
[1].第一类是系统中存在大量独立的扩展，为支持每一种组合将产生大量的子类，使得子类数目呈现爆炸性增长
[2].第二类是因为类定义不能继承(如final类) - 在不影响其他对象的情况下，以动态，透明的方式给单个对象添加职责。
- 当对象的功能要求可以动态地添加，也可以再动态地撤销时。
IO流中包装类使用到了装饰者模式。BufferedInputStream, BufferedOutputStream, BufferedReader, BufferedWriter。
以BufferedWriter为例，如何使用BufferedWriter
public class Demo{
public static void main(String[] args){
//创建FileWriter对象
FileWriter fw = new FileWriter("E:\3.txt");
//创建BufferedWriter对象
BufferedWriter bw = new BufferedWriter(fw);
//写数据
bw.write("hello Buffered");
bw.close();
}
}
它们结构如下:
小结:
BufferedWriter使用装饰者模式对Writer子实现类进行了增强，添加了缓冲区，提高了写数据的效率。
静态代理和装饰者模式的区别:
- 相同点:
[1].都要实现与目标类相同的业务接口
[2].在两个类中都要声明目标对象
[3].都可以在不修改目标类的前提下增强目标方法 - 不同点:
[1].目的不同
装饰者是为了增强目标对象
静态代理是为了保护和隐藏目标对象
[2].获取目标对象构建的地方不同
装饰者是由外界传递进来，可以通过构造方法传递
静态代理是在代理类内部创建，以此来隐藏目标对象
现在有一个需求, 需要创建不同的图像，并且每个图形都可能会有不同的颜色。我们可以利用继承的方式设计类的关系:
我们可以发现有很多的类，假如我们再增加一个形状或再增加一种颜色，就需要创建更多的类。
试想，在一个多种可能会变化的维度的体系中, 用继承方式会造成类的爆炸，扩展起来不灵活。每次在一个维度上新增一个具体实现都要增加多个子类。为了更加灵活的设计系统，我们此时可以考虑使用桥接模式。
将抽象与实现分类，使它们可以独立变化。它是用组合关系代替继承关系来实现，从而降低了抽象和实现这两个可变维度的耦合度。
(3).结构桥接(Bridge)模式包含以下主要角色:
- 抽象化(Abstraction)角色: 定义抽象类，并包含一个对实现化对象的引用。
- 扩展抽象化(Refined Abstraction)角色: 是抽象化角色的子类，实现父类中的业务方法，并通过组合关系调用实现化角色的业务方法。
- 实现化(Implementor)角色: 定义实现化角色的接口，供扩展抽象化角色调用。
- 具体实现化(Concrete Implementor)角色: 给出实现化角色接口的具体实现。
视频播放器
需要开发一个跨平台视频播放器，可以在不同 *** 作系统平台(如Windows, Mac, Linux等)上播放多种格式的视频文件，常见的视频格式包括RMVB, AVI, WMV等. 该播放器包含了两个维度，适合使用桥接模式。
类图如下:
代码如下:
public interface VideoFile{
//解码功能
void decode(String fileName);
}
public class AviFile implements VideoFile{
public void decode(String fileName){
System.out.println("avi视频文件:" + fileName);
}
}
public class RmvbFile implements VideoFile{
public void decode(String fileName){
System.out.println("rmvb视频文件:" + fileName);
}
}
public abstract class OperatingSystem{
//声明videFile变量
protected VideoFile videoFile;
public OperatingSystem(VideoFile videoFile){
this.videoFile = videoFile;
}
public abstract void play(String fileName);
}
public class Windows extends OperatingSystem{
public Windows(VideoFile videoFile){
super(videoFile);
}
public void play(String fileName){
videoFile.decode(fileName);
}
}
public class Mac extends OperatingSystem{
public Mac(VideoFile videoFile){
super(videoFile);
}
public void play(String fileName){
videoFile.decode(fileName);
}
}
public class Client{
public static void main(String[] args){
//创建mac系统对象
OperatingSystem system = new Mac(new AviFile())
//使用 *** 作系统播放视频文件
system.play("一路向西");
}
}
- 桥接模式提高了系统的可扩充性，在两个变化维度中任意扩展一个维度，都不需要修改原有系统。
如: 如果现在还有一种视频文件类型wmv, 我们只需要再定义一个类实现VideoFile接口即可，其他类不需要发生变化。 - 实现细节对客户透明
- 当一个类存在两个独立变化维度，且这两个维度都需要进行扩展时。
- 当一个系统不希望使用继承或因为多层次继承导致系统类的个数急剧增加时。
- 当一个系统需要在构件的抽象化角色和具体角色之间增加更多的灵活性时。避免在两个层次之间建立静态的继承联系，通过桥接模式可以使它们在抽象层建立一个关联关系。
有些人可能炒过股票，但其实大部分人都不太懂，但其实大部分人都不太懂，这种没有足够了解证券知识的情况下做股票很容易亏钱的，刚开始炒股肯定都会想，如果有个懂行的帮帮手就好，其实基金就是好的帮手，支付宝里就有许多的基金，它将投资者分散的资金集中起来，交由专业的经理人进行管理，投资于股票，债券，外汇等领域，而基金投资的收益归持有者所有，管理机构收取一定比例的托管管理费用。
(2).定义又名门面模式，是一种通过为多个复杂的子系统提供一个一致的接口，而使这些子系统更加容易被访问的模式。该模式对外有一个统一接口，外部应用程序不用关心内部子系统的具体的细节，这样会大大降低程序的复杂度，提高了程序的可维护性。
外观(Facade)模式是"迪米特法则"的典型应用
外观(Facade)模式包含以下主要角色:
- 外观(Facade)角色: 为多个子系统对外提供一个共同的接口。
- 子系统(Sub system)角色: 实现系统的部分功能，客户可以通过外观角色访问它。
示例
智能家电控制
小明的爷爷已经60岁，一个人在家生活: 每次都需要打开灯，打开空调；睡觉时关闭灯，关闭电视，关闭空调； *** 作起来都比较麻烦。所以小明给爷爷买了智能音响，可以通过语音直接控制这些智能家电的开启和关闭。类图如下:
代码如下:
public class Light{
//开灯
public void on(){
System.out.println("开灯....");
}
//关灯
public void off(){
System.out.println("关灯....");
}
}
public class TV{
public void on(){
System.out.println("打开电视机....");
}
public void off(){
System.out.println("关闭电视机....");
}
}
public class AirCondition{
public void on(){
System.out.println("打开空调....");
}
public void off(){
System.out.println("关闭空凋....");
}
}
public class SmartApplicancesFacade{
//聚合电灯对象，电视机对象，空调对象
private Light light;
private Tv tv;
private AirCondition airCondition;
public SmartApplicancesFacade(){
light = new Light();
tv = new TV();
airCondition = new AirCondition();
}
public void say(String message){
if(message.contains("打开")){
on();
}else if(message.contains("关闭")){
off();
}else{
System.out.println("我还听不懂你说的!!!");
}
}
//一键打开功能
private void on(){
light.on();
tv.on();
airCondition.on();
}
//一键关闭功能
private void off(){
light.off();
tv.off();
airCondition.off();
}
}
public class Client{
public static void main(String[] args){
//创建智能音响对象
SmartApplicancesFacade facade = new SmartApplicancesFacade();
//控制家电
facade.say("打开家电");
System.out.println("=============");
facade.say("关闭家电");
}
}
优点
- 降低了子系统与客户端之间的耦合度，使得子系统的变化不会影响调用它的客户类。
- 对客户屏蔽了子系统组件，减少了客户处理的对象数目，并使得子系统使用起来更加容易。
缺点:
- 不符合开闭原则，修改很麻烦
- 对分层结构系统构建，使用外观模式定义子系统中每层的入口点可以简化子系统之间的依赖关系。
- 当一个复杂系统的子系统很多时，外观模式可以为系统设计一个简单的接口供外界访问。
- 当客户端与多个子系统之间存在很大的联系，引入外观模式可将它们分离，从而提高子系统的独立性和可移植性。
使用tomcat作为web容器时，接收浏览器发送过来的请求，tomcat会将请求信息封装成ServletRequest对象，如下代码所示，
public class ServletDemo extends HttpServlet{
protected void doPost(HttpServletRequest request, HttpServletResponse response){
}
protected void doGet(HttpServletRequest request, HttpServletResponse response){
}
}
其中ServletRequest是一个接口，它还有一个子接口HttpServletRequest, ReqyestFacade是接口的实现类。
RequestFacade类使用了外观模式, 结构图如下所示
为什么在此使用外观模式呢?
定义RequestFacade类， 分别实现ServletRequest, 同时定义了私有成员变量Request, 并且方法的实现调用Request的实现。然后，将RequestFacade上转为ServletRequest，传给servlet的service方法，这样即使在servlet中被下转为RequestFacade, 也不能访问私有成员变量对象中的方法。既用了Request, 又能防止其中方法被不合理的访问。
对于这个图片肯定会非常熟悉，上图我们可以看做是一个文件系统，对于这样的结构我们称之为树形结构。在树形结构中可以通过调用某个方法来遍历整个树，当我们找到某个叶子节点后，就可以对叶子节点进行相关 *** 作。可以将这棵树理解成一个大的容器，容器里面包含很多的成员对象，这些成员对象即可是容器对象也可以是叶子对象。但是由于容器对象和叶子对象在功能上面的区别，使得我们在使用的过程中必须要区分容器对象和叶子对象，但是这样就会给客户带来不必要的麻烦，作为客户而已，它始终希望能够一致的对待容器对象和叶子对象。
又名部分整体模式，是用于把一组相似的对象当作一个单一的对象。组合模式依据树形结构来组合对象，用来表示部分以及整体层次。这种类型的设计模式属于结构型模式，它创建对象组的树形结构。
(3).结构组合模式主要包含三种角色:
- 抽象根节点(Component): 定义系统各层次对象的共有方法和属性，可以预先定义一些默认行为和属性
- 树枝节点(Composite): 定义树枝节点的行为，存储子节点，组合树枝节点和叶子节点形成一个树形结构。
- 叶子节点(Leaf): 叶子节点对象，其下再无分支，是系统层次遍历的最小单位。
示例
软件菜单
如下图，我们在访问别的一些管理系统时，经常可以看到类似的菜单，一个菜单可以包含菜单项(菜单项是指不在包含其他内容的菜单条目)，也可以包含带有其他菜单项的菜单，因此使用组合模式描述菜单就很恰当，我们的需求是针对一个菜单，打印出其包含所有的菜单以及菜单项的名称。
其类图如下:
代码如下:
public abstract class MenuComponent{
//菜单组件的名称
protected String name;
//菜单组件的层级
protected int level;
//添加子菜单
public void add(MenuComponent menumComponent){
throw new UnSupportedOperationException();
}
//移除子菜单
public void remove(MenuComponent menumComponent){
throw new UnSupportedOperationException();
}
//获取指定的子菜单
public MenuComponent getChild(int index){
throw new UnSupportedOperationException();
}
//获取菜单或者菜单项的名称
public String getName(){
return this.name;
}
//打印菜单名称的方法(包含子菜单和菜单项)
public abstract void print();
}
public class Menu extends MenuComponent{
//菜单项可以有多个子菜单或者子菜单项
private List<MenuComponent> menuComponentList = new ArrayList<MenuComponent>();
//构造方法
public Menu(String name, int level){
this.name = name;
this.level = level;
}
@Override
public void add(MenuComponent menuComponent){
menuComponentList.add(menuComponent);
}
@Override
public void remove(MenuComponent menuComponent){
menuComponentList.remove(menuComponent);
}
@Override
public MenuComponent getChild(int index){
return menuComponentList.get(index);
}
@Override
public void print(){
//打印菜单名称
System.out.println(name);
//打印子菜单或者子菜单项名称
for(MenuComponent component : menuComponentList){
component.print();
}
}
public class MenuItem extends MenuComponent{
public MenuItem(String name, int level){
this.name = name;
this.level = level;
}
public void print(){
//打印菜单项名称
System.out.println(this.name);
}
}
public class Client{
public static void main(String[] args){
//创建菜单树
MenuComponent menu1 = new MenuComponent("菜单管理", 2);
menu1.add(new MenuItem("页面访问", 3));
menu1.add(new MenuItem("展开菜单", 3));
menu1.add(new MenuItem("编辑菜单", 3));
menu1.add(new MenuItem("删除菜单", 3));
menu1.add(new MenuItem("新增菜单", 3));
MenuComponent menu2 = new MenuComponent("权限管理", 2);
menu2.add(new MenuItem("页面访问", 3));
menu2.add(new MenuItem("提交保存", 3));
MenuComponent menu3 = new MenuComponent("角色管理", 2);
menu3.add(new MenuItem("页面访问", 3));
menu3.add(new MenuItem("新增角色", 3));
menu3.add(new MenuItem("修改角色", 3));
//创建一级菜单
MenuComponent component = new Menu("系统管理", 1);
//将二级菜单添加到一级菜单中
component.add(menu1);
component.add(menu2);
component.add(menu3);
//打印菜单名称(如果有子菜单一块打印)
component.print();
}
}
在使用组合模式时，根据抽象构件类的定义形式，我们可将组合模式和安全组合模式两种形式。
- 透明组合模式
透明组合模式中，抽象根节点角色中声明了所有用于管理成员对象的方法，比如在示例中MenuComponent声明了add, remove, getChild方法，这样做的好处是确保所有的构建类都有相同的接口。透明组合模式也是组合模式的标准形式。
透明组合模式的缺点是不够安全，因为叶子对象和容器对象在本质上是有区别的，叶子对象不可能有下一个层次的对象，即不可能包含成员对象，因此为其提供add(), remove()等方法是没有意义的，这在编译阶段不会出错，但在运行阶段如果这些方法可能会出错(如果没有提供相应的错误处理代码) - 安全组合模式
在安全组合模式中，在抽象构建角色中没有声明任何用于管理成员对象的方法，而是在树枝节点Menu类中声明并实现这些方法。安全组合模式的缺点是不够透明，因为叶子构件和容器具有不同的方法，且容器构件中那些用于管理成员对象的方法没有在抽象构件类中定义，因此客户端不能完全针对抽象编程，必须有区别地对待叶子构建和容器构建。
- 组合模式可以清楚地定义分层次的复杂对象，表示对象的全部或部分层次，它让客户端忽略了层次的差异，方便对整个层次结构进行控制。
- 客户端可以一致地使用一个组合结构或其中单个对象，不必关心处理的是单个对象还是整个组合结构，简化了客户端代码。
- 在组合模式中增加新的树枝节点和叶子节点都很方便，无须对现有类库进行任何修改，符合"开闭原则"。
- 组合模式为树形结构的面向对象实现提供了一种灵活的解决方案，通过叶子节点和树枝节点的递归组合，可以形成复杂的树形结构，但对树形结构的控制却非常简单、
组合模式正是应树形结构而生，所以组合模式的使用场景就是出现树形结构的地方。比如:文件目录显示，多级目录呈现等树形结构数据的 *** 作。
7.亨元模式 (1).概述定义:
运用共享技术来有效地支持大量细粒度对象的复用。它通过共享已经存在的对象来大幅减少需要创建的对象数量，避免大量相似对象的开销，从而提高系统资源的利用率。
亨元(Flyweight)模式中存在以下两种状态:
1. 内部状态，即不会随着环境的改变而改变的可共享部分。
2. 外部状态，指随着外部改变而改变的不可以共享的部分。亨元模式的实现要领就是区分应用中的这两种状态，并将外部状态外部化。
亨元模式的主要有以下角色:
- 抽象亨元角色(Flyweight): 通常是一个接口或抽象类，在抽象亨元类中声明了具体亨元类公共的方法，这些方法可以向外界提供亨元对象的内部数据(内部状态)，同时也可以通过这些方法来设置外部数据(外部状态)。
- 具体亨元角色(Concrete Flyweight): 它实现了抽象亨元类，称为亨元对象；在具体亨元类中为内部状态提供了存储空间。通常我们可以结合单例模式来设计具体亨元类，为每一个具体亨元类提供唯一的亨元对象。
- 非亨元角色(Unsharable Flyweight): 并不是所有的抽象亨元类的子类都需要被共享，不能被共享的子类可以设计为非共享具体亨元类；当需要一个非共享具体亨元类的对象时可以直接通过实例化创建。
- 亨元工厂(Flyweight Factory)角色: 负责创建和管理亨元角色。当客户对象请求一个亨元对象时，亨元工厂检查系统中是否存在符合要求的亨元对象，如果存在则提供给客户；如果不存在的话，则创建一个新的亨元对象。
俄罗斯方块
下面的图片是众所周知的俄罗斯的一个个方块，如果在俄罗斯方块这个游戏中，每个不同的方块都是一个实例对象，这些对象要占用很多的内存空间。
类图如下:
代码如下:
public abstract class AbstractBox{
//获取图像的方法
public abstract String getShape();
//显示图形及颜色
public void display(String color){
System.out.println("方块形状:" + getShape() + ", 颜色:" + color);
}
}
public class IBox extends AbstractBox{
public String getShape(){
return "I";
}
}
public class LBox extends AbstractBox{
public String getShape(){
return "L";
}
}
public class OBox extends AbstractBox{
public String getShape(){
return "O";
}
}
public class BoxFactory{
private Map<String, AbstractBox> map;
//在构造方法中进行初始化 *** 作
private BoxFactory(){
map = new HashMap<String, AbstractBox>();
map.put("I", new IBox());
map.put("L", new LBox());
map.put("O", new OBox());
}
//根据名称获取图形对象
public AbstractBox getShape(String name){
return map.get(name);
}
private static BoxFactory factory = new BoxFactory();
public static BoxFactory getInstance(){
return factory;
}
}
public class Client{
public static void main(String[] args){
//获取I图形对象
AbstractBox box1 = BoxFactory.getInstance().getShape("I");
box1.display("灰色");
//获取L图形对象
AbstractBox box2 = BoxFactory.getInstance().getShape("L");
box1.display("绿色");
//获取I图形对象
AbstractBox box3 = BoxFactory.getInstance().getShape("O");
box1.display("灰色");
//获取I图形对象
AbstractBox box4 = BoxFactory.getInstance().getShape("O");
box1.display("红色");
System.out.println("两次获取到的O图像对象是否为同一个对象:" + (box3 == box4));
}
}
优点:
- 极大减少内存中相似或相同对象数量，节约系统资源，提升系统性能
- 亨元模式中的外部状态相对对立，且不影响内部独立
缺点:
为了使对象共享，需要将亨元对象的部分状态外部化，分离内部状态和外部状态，使程序逻辑复杂。
- 一个系统有大量相同或者相似的对象，造成内存的大量消耗。
- 对象的大部分状态都可以外部化，可以将这些外部状态传入对象中。
- 在使用亨元模式时需要维护一个存储亨元对象的亨元池，而这需要消耗一定的系统资源，因此，应当在需要多次重复使用亨元对象时才值得使用亨元模式。
Integer类使用了亨元模式。我们先看下面的例子:
public class Demo{
public static void main(String[] args){
Integer i1 = 127;
Integer i2 = 127;
System.out.println("i1和i2对象是否是同一个对象?" +(i1 == i2));
Integer i3 = 128;
Integer i4 = 128;
System.out.println("i3和i4对象是否是同一个对象?" +(i3 == i4));
}
}
运行上面代码，结果如下:
为什么第一个输出语句输出的是true, 第二个输出语句输出是false? 通过反编译软件进行反编译，代码如下:
上面代码可以看到，直接给Integer类型的变量赋值基本数据的 *** 作底层使用的是valueOf().
可以看到Integer默认先创建并缓存-128~127之间数的Integer对象，当调用valueOf时是参数在-128~127之间则计算下标并从缓存中返回，否则创建一个新的Integer对象。
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）