软件设计与体系结构——结构型模式
Posted 耶瞳
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了软件设计与体系结构——结构型模式相关的知识，希望对你有一定的参考价值。
如果有兴趣了解更多相关内容，欢迎来我的个人网站看看：瞳孔空间
结构型模式(Structural Pattern)描述如何将类或对象按某种布局组成更大的结构。就像搭积木，可以通过简单积木的组合形成复杂的、功能更为强大的结构
结构型模式可以分为类结构型模式和对象结构型模式
- 类结构型模式关心类的组合，由多个类可以组合成一个更大的系统，在类结构型模式中一般只存在继承关系和实现关系
- 对象结构型模式关心类与对象的组合，通过关联关系使得在一个类中定义另一个类的实例对象，然后通过该对象调用其方法。根据“合成复用原则”，在系统中尽量使用关联关系来替代继承关系，因此大部分结构型模式都是对象结构型模式
结构型模式分为以下7种：
- 代理模式
- 适配器模式
- 装饰者模式
- 桥接模式
- 外观模式
- 组合模式
- 享元模式
一：代理模式
有时候客户端不能直接操作到某个对象,但又必须和那个对象有所互动，比如以下两种情况：
- 如果对象是一个大图片，需要花费很长时间才能显示出来，此时需要做个图片Proxy来代替真正的图片
- 如果对象在某远端服务器上，直接操作这个对象因为网络速度原因可能比较慢，那我们可以先用Proxy来代替那个对象
如何应对这种变化？如何提供一种机制让原本交互起来比较困难的两个对象实现畅通无阻地交流呢？如何保持系统的结构不随着需求改变而轻易改变？这就是代理模式。
代理模式：为其他对象提供一种代理以控制对这个对象的访问。
代理模式分为三种角色：
- 抽象主题类：通过接口或抽象类声明真实主题和代理对象实现的业务方法。
- 真实主题类：实现了抽象主题中的具体业务，是代理对象所代表的真实对象，是最终要引用的对象。
- 代理类：提供了与真实主题相同的接口，其内部含有对真实主题的引用，他可以访问、控制或扩展真实主题的功能。
Java中的代理按照代理类生成时机不同又分为：
- 静态代理：静态代理代理类在编译期生成
- 动态代理：而动态代理代理类在Java运行时动态生成。动态代理又有两种：
- JDK代理
- CGLib代理
1.1：静态代理
以下是火车站卖票的案例：
public class ProxyDemo1
public static void main(String[] args)
ProxyPoint1 proxyPoint = new ProxyPoint1();
proxyPoint.sell();
// 售票接口
interface SellTickets1
void sell();
// 火车站
class TrainStation1 implements SellTickets1
@Override
public void sell()
System.out.println("火车站卖票");
// 代售点卖票
class ProxyPoint1 implements SellTickets1
// 声明火车站类对象
private TrainStation1 trainStation = new TrainStation1();
@Override
public void sell()
System.out.println("收取服务费");
trainStation.sell();
从上面代码中可以看出主类(充当测试类)直接访问的是ProxyPoint类对象，也就是说ProxyPoint作为访问对象和目标对象的中介。同时也对sell方法进行了增强（代理点收取了服务费用)。
1.2：动态代理
1.2.1：JDK代理
Java中提供了一个动态代理类Proxy，该类提供了一个创建代理对象的静态方法(newProxyInstance方法)来获取代理对象。
改进火车站售票代码如下：
public class ProxyDemo2
public static void main(String[] args)
ProxyFactory2 proxyFactory = new ProxyFactory2();
SellTickets2 proxyObject = proxyFactory.getProxyObject();
proxyObject.sell();
// 售票接口
interface SellTickets2
void sell();
// 火车站
class TrainStation2 implements SellTickets2
@Override
public void sell()
System.out.println("火车站卖票");
// 代理工厂，用于创建代理对象
class ProxyFactory2
private TrainStation2 station = new TrainStation2();
public SellTickets2 getProxyObject()
return (SellTickets2)Proxy.newProxyInstance(
station.getClass().getClassLoader(),
station.getClass().getInterfaces(),
(proxy, method, args) ->
/*
* proxy：与Proxy.newProxyInstance返回值为同一对象
* method：对接口中的方法进行封装的method对象
* args：调用方法的实际参数
*/
System.out.println("收取服务费");
return method.invoke(station, args);
);
1.2.2：CGLIB代理
如果没有定义SellTickets接口，只定义了TrainStation (火车站类)。很显然JDK代理是无法使用了，因为JDk动态代理要求必须定义接口，对接口进行代理。
CGLIB是一个功能强大，高性能的代码生成包。它为没有实现接口的类提供代理，为JDK的动态代理提供了很好的补充。
CGLIB是第三方提供的包，所以需要引入jar包的坐标:
<dependency>
<groupId>cglib</groupId>
<artifactId>cglib</artifactId>
<version>2.2.2</version>
</dependency>
改进火车站售票代码如下：
public class ProxyDemo3
public static void main(String[] args)
ProxyFactory3 proxyFactory3 = new ProxyFactory3();
TrainStation3 proxyObject = proxyFactory3.getProxyObject();
proxyObject.sell();
// 火车站
class TrainStation3
public void sell()
System.out.println("火车站卖票");
// 代理对象工厂
class ProxyFactory3 implements MethodInterceptor
private TrainStation3 station = new TrainStation3();
public TrainStation3 getProxyObject()
// 创建Enhancer对象，类似于JDK代理中的Proxy类
Enhancer enhancer = new Enhancer();
// 设置父类的字节码对象
enhancer.setSuperClass(TrainStation3.class);
// 设置回调函数
enhancer.setCallback(this);
// 创建代理对象
return (proxyObject)enhancer.create();
@Override
public Object intercept(Object o, Method method, Object[] objects. MethodProxy methodProxy)
System.out.println("收取服务费");
return method.invoke(station, objects);
1.3：总结
三种代理的对比：
- JDK代理和CGLIB代理：使用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的时候，JDK代理效率高于CGLib代理。所以如果有接口使用JDK动态代理，如果没有接口使用CGLIB代理。
- 动态代理和静态代理：动态代理与静态代理相比较，最大的好处是接口中声明的所有方法都被转移到调用处理器一个集中的方法中处理(InvocationHandler.invoke)。这样，在接口方法数量比较多的时候，我们可以进行灵活处理，而不需要像静态代理那样每一个方法进行中转。如果接口增加一个方法，静态代理模式除了所有实现类需要实现这个方法外，所有代理类也需要实现此方法。增加了代码维护的复杂度。而动态代理不会出现该问题。
代理模式的优点：
- 代理模式在客户端与目标对象之间起到一个中介作用和保护目标对象的作用
- 代理对象可以扩展目标对象的功能
- 代理模式能将客户端与目标对象分离，在一定程度上降低了系统的耦合度
代理模式的缺点：
- 增加了系统的复杂度
使用场景：
- 远程代理（Remote Proxy）：本地服务通过网络请求远程服务。为了实现本地到远程的通信，我们需要实现网络通信，处理其中可能的异常。为良好的代码设计和可维护性，我们将网络通信部分隐藏起来，只暴露给本地服务一个接口，通过该接口即可访问远程服务提供的功能，而不必过多关心通信部分的细节。
- 虚拟代理（Virtual Proxy）：在需要创建开销很大对象时缓存对象信息
- 保护代理（Protection Proxy）：控制对原始对象的访问。如果需要，可以给不同的用户提供不同级别的使用权限。
- 智能引用代理（Smart Reference Proxy）：当一个对象被引用时，提供一些额外的操作，例如记录访问的流量和次数等
- 防火墙代理（Firewall Proxy）：当你将浏览器配置成使用代理功能时，防火墙就将你的浏览器的请求转给互联网;当互联网返回响应时，代理服务器再把它转给你的浏览器。
二：适配器模式
如果去欧洲国家去旅游的话，他们的插座如下图最左边，是欧洲标准。而我们使用的插头如下图最右边的。因此我们的笔记本电脑，手机在当地不能直接充电。所以就需要一个插座转换器，转换器第1面插入当地的插座，第2面供我们充电，这样使得我们的插头在当地能使用。生活中这样的例子很多，手机充电器（将220x转换为5x的电压)，读卡器等，其实就是使用到了适配器模式。
适配器模式(Adapter Pattern)：将一个类的接口转换成客户希望的另一个接口，使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。
适用场合：
- 使用一个已存在的类，而它的接口不符合要求
- 创建一个可以复用的类，该类可以与其他不相关的类或不可预见的类（即那些接口可能不一定兼容的类）协同工作
- 使用一些已经存在的子类，但不可能通过子类化以匹配各自接口。对象适配器可以适配它的父类接口
适配器模式包含以下主要角色：
- 目标接口：当前系统业务所期待的接口，它可以是抽象类或接口
- 适配者类：它是被访问和适配的现存组件库中的组件接口
- 适配器类：它是一个转换器，通过继承或引用适配者的对象，把适配者接口转换成目标接口，让客户按目标接口的格式访问适配者
适配器模式分为类适配器模式和对象适配器模式，前者类之间的耦合度比后者高，且要求程序员了解现有组件库中的相关组件的内部结构，所以应用相对较少些。
2.1：类适配器
实现方式：定义一个适配器类来实现当前系统的业务接口，同时又继承现有组件库中已经存在的组件。
例如，现有一台电脑只能读取SD卡，而要读取TF卡中的内容的话就需要使用到适配器模式。创建一个读卡器，将TF卡中的内容读取出来。代码如下：
public class AdapterDemo1
public static void main(String[] args)
Computer computer = new Computer();
String msg = computer.readSD(new SDAdapterTF());
System.out.println(msg);
interface TFCard
String readTF();
void writeTF(String msg);
// 具体TF卡
class TFCardImpl implements TFCard
@Override
public String readTF()
return "hello TFCard";
@Override
public void writeTF(String msg)
System.out.println("TFCard write msg：" + msg);
// 目标接口
interface SDCard
String readSD();
void writeSD(String msg);
// 具体SD卡
class SDCardImpl implements SDCard
@Override
public String readSD()
return "hello SDCard";
@Override
public void writeSD(String msg)
System.out.println("SDCard write msg：" + msg);
// 计算机类
class Computer
// 从SD卡中读取数据
public String readSD(SDCard sdCard)
return sdCard.readSD();
// 适配器类
class SDAdapterTF extends TFCardImpl implements SDCard
@Override
public String readSD()
return readTF();
@Override
public void writeSD(String msg)
writeTF(msg);
类适配器模式违背了合成复用原则。类适配器是客户类有一个接口规范的情况下可用，反之不可用。
2.2：对象适配器
实现方式：对象适配器模式可采用将现有组件库中已经实现的组件引入适配器类中，该类同时实现当前系统的业务接口。
改进上述读卡器案例，代码如下：
public class AdapterDemo2
public static void main(String[] args)
Computer2 computer = new Computer2();
String msg = computer.readSD(new SDAdapterTF2(new TFCardImpl2()));
System.out.println(msg);
interface TFCard2
String readTF();
void writeTF(String msg);
// 具体TF卡
class TFCardImpl2 implements TFCard2
@Override
public String readTF()
return "hello TFCard";
@Override
public void writeTF(String msg)
System.out.println("TFCard write msg：" + msg);
// 目标接口
interface SDCard2
String readSD();
void writeSD(String msg);
// 具体SD卡
class SDCardImpl2 implements SDCard2
@Override
public String readSD()
return "hello SDCard";
@Override
public void writeSD(String msg)
System.out.println("SDCard write msg：" + msg);
// 计算机类
class Computer2
// 从SD卡中读取数据
public String readSD(SDCard2 sdCard)
return sdCard.readSD();
// 适配器类
class SDAdapterTF2 implements SDCard2
// 声明适配者类
private final TFCard2 tfCard;
public SDAdapterTF2(TFCard2 tfCard)
this.tfCard = tfCard;
@Override
public String readSD()
return tfCard.readTF();
@Override
public void writeSD(String msg)
tfCard.writeTF(msg);
三：装饰者模式
我们先来看一个快餐店的例子。快餐店有炒面、炒饭这些快餐，可以额外附加鸡蛋、火腿、培根这些配菜，当然加配菜需要额外加钱，每个配菜的价钱通常不太一样，那么计算总价就会显得比较麻烦。
而装饰者模式(Decorator Pattern)，就是在不改变对象结构的情况下，动态地给该对象增加一些职责(即增加其额外功能)的模式。
装饰者模式中的角色
- 抽象构件角色：定义一个抽象接口以规范准备接收附加职责的对象
- 具体构件角色：实现抽象构件，通过装饰角色为其添加一些职责
- 抽象装饰角色：继承或实现抽象构件，并包含具体构件的实例，可以通过其子类扩展具体构件的功能
- 具体装饰角色：实现抽象装饰的相关方法，并给具体构件对象添加附加的责任
示例代码如下：
public class DecoratorDemo1
public static void main(String[] args)
// 点一份炒饭
FastFood food = new FriedRice();
System.out.println(food.getDesc() + "的价格：" + food.cost());
// 再加一份鸡蛋
food = new Egg(food);
System.out.println(food.getDesc() + "的价格：" + food.cost());
// 再加一份培根
food = new Bacon(food);
System.out.println(food.getDesc() + "的价格：" + food.cost());
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 price;
public void setPrice(float price)
this.price = price;
public String getDesc()
return desc;
public void setDesc(String desc)
this.desc = desc;
public abstract float cost();
// 炒饭
class FriedRice extends FastFood
public FriedRice()
super(10, "炒饭");
@Override
public float cost()
return getPrice();
// 炒面
class FriedNoodles extends FastFood
public FriedNoodles()
super(12, "炒面");
@Override
public float cost()
return getPrice();
// 装饰类
abstract class Garnish extends FastFood
// 声明快餐类的变量
private FastFood fastFood;
public FastFood getFastFood()
return fastFood;
public void setFastFood(FastFood fastFood)
this.fastFood = fastFood;
public Garnish(FastFood fastFood, float price, String desc)
super(price, desc);
this.fastFood = fastFood;
// 配料类（鸡蛋）
class Egg extends Garnish
public Egg(FastFood fastFood)
super(fastFood, 1, "鸡蛋");
@Override
public float cost()
// 计算价格
return getPrice() + getFastFood().cost();
@Override
public String getDesc()
return super.getDesc() + getFastFood设计模式 结构型模式 -- 组合模式