1. 代理模式

1.1 概述

定义：由于一些原因需要给某个对象提供一个代理用于控制对该对象的访问。这时，访问对象不适合或者不能直接引用目标对象，代理对象作为访问对象和目标对象之间的中介。
Java中的代理按照代理类生成的时机不同分为静态代理和动态代理。静态代理在编译期就生成，动态代理在Java运行时动态生成。动态代理分JDK动态代理和CGLib动态代理两种。

1.2 结构

代理（Proxy）模式分三种角色：

抽象主题（Subject）类：通过接口或抽象类声明真实主题和代理对象实现的业务方法；
真实主题（Real Subject）类：实现了抽象主题的具体方法，是代理对象所代理的真实对象，是最终引用的对象；
代理（Proxy）类：提供了和真实主题相同接口，其内部含有对真实主题的引用，它可以访问、控制或扩展真实主题的功能；
1.3 静态代理
【例】通过代售点买火车票 ```java /**
- Step1: 卖票接口 */ interface SellTickets { void sell(); }

/**

Step2: 火车站 */ public class TrainStation implements SellTickets{ @Override public void sell() {
```
 System.out.println("火车站出售车票...");
```
} }

/**

Step3: 代售点 */ public class ProxyPoint implements SellTickets{ TrainStation trainStation = new TrainStation(); @Override public void sell() {
```
 System.out.println("代售点手续费5元...");
 trainStation.sell();
```
} }

@Test public void test(){ ProxyPoint proxyPoint = new ProxyPoint(); proxyPoint.sell(); }

<a name="KEaVv"></a>
## 1.4 JDK动态代理
Java中提供了一个动态代理类`Proxy`，`Proxy`并不是直接代理对象，而是提供了一个创建代理对象的静态方法`newPorxyInstance`来获取代理对象。
```java
/**卖票接口*/
public interface SellTickets {
    void sell();
}

/**火车站售票*/
public class TrainStation implements SellTickets{
    @Override
    public void sell() {
        System.out.println("火车站出售车票...");
    }
}

/** 代理工厂 */
public class ProxyFactory {
    private TrainStation trainStation = new TrainStation();
    public SellTickets getProxyObject() {
        SellTickets sellTickets = (SellTickets) Proxy.newProxyInstance(trainStation.getClass().getClassLoader(), trainStation.getClass().getInterfaces(), new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                System.out.println("[JDK动态代理]代售点收取服务费5元...");
                Object result = method.invoke(trainStation, args);
                return result;
            }
        });
        return sellTickets;
    }
}

/** JDK动态代理测试 */
class DynamicProxyTest {
    public static void main(String[] args) {
        ProxyFactory proxyFactory = new ProxyFactory();
        SellTickets proxyObject = proxyFactory.getProxyObject();
        proxyObject.sell();
    }
}

📜 执行流程：

在测试类中通过代理对象调用sell()方法；
根据多态特性，执行的是代理类$Proxy0中的sell()方法；
代理类$Proxy0中的sell()方法调用InvocationHandler接口的子实现类对象的invoke()方法；
invoke()方法通过反射执行了真实对象所属类Transtation中的sell()方法。
1.5 CGLib动态代理（待完善）😶
1.6 代理模式-优缺点
优点：

代理模式在访问对象和目标对象之间起到一个中介和保护目标对象的作用；
代理对象可以扩展目标对象的功能；
代理模式将访问对象和目标对象分开，一定程度上降低了系统的耦合度；

缺点：

增加了系统的复杂度。

2. 适配器模式

2.1 概述

定义：将一个类的接口转换成客户希望的另一个接口，使得原本由于接口不兼容而不能一起工作的类能一起工作。
适配器模式分为类适配器模式和对象适配器模式，前置类之间的耦合度比后者高，并且要求程序员了解现有组件库中的相关组件的内部结构，所以应用相对较少。

2.2 结构

适配器模式（Adapter）包含以下角色：

目标（Target）接口：当前系统业务所期待的接口，可以是抽象类或者接口；
适配者（Adaptee）类：它是被访问和适配的现存组件库中的组件接口；
适配器（Adapter）类：它是一个转换器，通过继承或者引用适配者的对象，把适配者接口转换为目标接口，让客户目标接口的格式访问适配者。

2.3 类适配器（待完善）😶

2.4 对象适配器模式
实现方式：对象适配器模式可采用将现有组件库中已经实现的组件引入适配器类中，该类同时实现当前系统的业务接口。
【例】读卡器
现有一台电脑只能读取SD卡，而要读取TF卡中的内容的话就需要使用到适配器模式。创建一个读卡器，将TF卡中的内容读取出来。 ```java /*SD卡接口/ public interface SDCard {

/*读取SD卡/ String readSD();

/*写入SD卡/ void writeSD(String msg); }

/*SD卡实现/ public class SDCardImpl implements SDCard {

@Override
public String readSD() {
    String msg = "读取SD卡内容...";
    return msg;
}
@Override
public void writeSD(String msg) {
    System.out.println("写入SD卡内容：" + msg);
}

} /*计算机类/ public class Computer {

public String readSD(SDCard sdCard){
    if (sdCard == null){
        throw new NullPointerException("sdCard is null");
    }
    return sdCard.readSD();
}

}

/*TF卡接口/ public interface TFCard {

/**读取TF卡*/
String readTF();
/**写入TF卡*/
void writeTF(String msg);

}

/*TF卡实现/ public class TFCardImpl implements TFCard{

@Override
public String readTF() {
    return "读取TF卡内容...";
}
@Override
public void writeTF(String msg) {
    System.out.println("写入TF卡内容：" + msg);
}

}

```java
/**对象适配器*/
public class SDAdaptorTF implements SDCard {
    private TFCard tfCard;
    public SDAdaptorTF(TFCard tfCard) {
        this.tfCard = tfCard;
    }
    @Override
    public String readSD() {
        System.out.println("兼容模式读取TF卡");
        return tfCard.readTF();
    }
    @Override
    public void writeSD(String msg) {
        System.out.println("兼容模式写入TF卡");
        tfCard.writeTF(msg);
    }
}
/**对象适配器测试*/
public class ObjectAdaptorTest {
    public static void main(String[] args) {
        Computer computer = new Computer();
        String str1 = computer.readSD(new SDCardImpl());
        System.out.println(str1);
        System.out.println("--------------------------------------------------------");
        String str2 = computer.readSD(new SDAdaptorTF(new TFCardImpl()));
        System.out.println(str2);
    }
}

2.5 应用场景

旧系统存在满足新系统功能需求的类，但其接口与新系统接口定义不一致；
使用第三方提供的组件，但三方组件接口和自己系统接口定义不相同。

3. 装饰者模式

3.1 概述

定义：指在不改变现有对象结构的情况下，动态的给该对象增加一些职责（增加额外的功能）的模式。

3.2 结构

装饰者（Decorator）模式结构：

抽象构建（Component）角色：定义一个抽象接口用于规范准备接收附加功能的对象；
具体构建（Concrete Component）角色：实现抽象构建，通过装饰角色为其添加一些职责；
抽象装饰（Decorator）角色：继承或实现抽象构建，并包含具体构建实例，可以通过其子类扩展具体构建职责；
具体装饰（Concreate Decorator）角色：实现抽象装饰的相关方法，并给具体构建对象添加附加责任。

3.3 案例
📌【例】快餐店提供炒面、炒饭等餐品，可以额外添加配菜有鸡蛋、培根等。 ```java /**
- @Description: 快餐店接口
- @Author: zhang lei */ public abstract class FastFood { private String desc; private double price;
  
  public FastFood(String desc, double price) {
```
this.desc = desc;
this.price = price;
```
  }
  
  public double getPrice() {
```
return price;
```
  }
  
  public void setPrice(double price) {
```
this.price = price;
```
  }
  
  public String getDesc() {
```
return desc;
```
  }
  
  public void setDesc(String desc) {
```
this.desc = desc;
```
  }
  
  /**
  - 获取价格 */ public abstract double getCost(); }

/**

@Description: 炒饭
@Author: zhang lei */ public class FriedRice extends FastFood { public FriedRice() {
```
 super("炒饭", 10);
```
}

@Override public double getCost() {
```
 return getPrice();
```
} }

/**

@Description: 炒面
@Author: zhang lei */ public class FriedNoodles extends FastFood{ public FriedNoodles() {
```
 super("炒面", 12);
```
}

@Override public double getCost() {
```
 return getPrice();
```
} }

/**

@Description:配料类
@Author: zhang lei */ public abstract class Garnish extends FastFood{ private FastFood fastFood;

public FastFood getFastFood() {
```
 return fastFood;
```
}

public void setFastFood(FastFood fastFood) {
```
 this.fastFood = fastFood;
```
}

public Garnish(String desc, double price, FastFood fastFood) {
```
 super(desc, price);
 this.fastFood = fastFood;
```
} }

/**

@Description: 配料-鸡蛋
@Author: zhang lei */ public class EggGarnish extends Garnish{ public EggGarnish(FastFood fastFood) {
```
 super("+鸡蛋", 2, fastFood);
```
}

@Override public double getCost() {
```
 return super.getPrice() + getFastFood().getPrice();
```
}

@Override public String getDesc() {
```
 return getFastFood().getDesc() + super.getDesc();
```
} }

/**

@Description:配菜-培根
@Author: zhang lei */ public class BaconGarnish extends Garnish{

public BaconGarnish(FastFood fastFood) {
```
 super("+培根", 5, fastFood);
```
}

@Override public double getCost() {
```
 return getFastFood().getPrice() + super.getPrice();
```
}

@Override public String getDesc() {
```
 return getFastFood().getDesc() + super.getDesc();
```
} }

/**

@Description: 装饰者模式测试

@Author: zhang lei */ public class DecoratorTest { public static void main(String[] args) {

 EggGarnish eggGarnish = new EggGarnish(new FriedRice());
 System.out.println(eggGarnish.getDesc() + eggGarnish.getCost());
 System.out.println("------------------------------------------");
 BaconGarnish baconGarnish = new BaconGarnish(new FriedNoodles());
 System.out.println(baconGarnish.getDesc() + baconGarnish.getCost());

} } ```

4. 桥接模式

4.1 概述

定义：将抽象与实现分离，使他们可以独立变化。它是用组合关系代替继承关系来实现，从而降低了抽象和实现这两个可变维度的耦合度。

4.2 结构

桥接（Bridge）模式包含以下主要角色：

抽象化（Abstraction）角色：定义一个抽象类，并包含一个对实现化对象的引用；
扩展抽象化（Refined Abstraction）角色：是抽象化角色的子类，实现父类中的业务方法，并通过组合关系调用实例化角色中的业务方法；
实例化（Implementor）角色：定义实现化角色接口，供扩展抽象化角色调用；
具体实例化（Concrete Implementor）角色：给出实现化角色接口的具体实现。
4.3 案例
📌【例】视频播放器
需要开发一个跨平台视频播放器，可以在不同操作系统平台（如Windows、Mac、Linux等）上播放多种格式的视频文件，常见的视频格式包括RMVB、AVI、WMV等。该播放器包含了两个维度，适合使用桥接模式。 ```java /**
- @Description: 视频文件接口
- @Author: zhang lei */ public interface VideoFile { void decode(String fileName); }

/**

@Description: .avi格式文件
@Author: zhang lei */ public class AVIFile implements VideoFile { @Override public void decode(String fileName) {
```
 System.out.println("正在播放: " + fileName + ".avi");
```
} }

/**

@Description: .rmvb格式文件
@Author: zhang lei */ public class RMVBFile implements VideoFile { @Override public void decode(String fileName) {
```
 System.out.println("正在播放: " + fileName + ".avi");
```
} } java /**
@Description: 操作系统抽象类
@Author: zhang lei */ public abstract class OperatingSystem { protected VideoFile videoFile;

public OperatingSystem(VideoFile videoFile) {
```
 this.videoFile = videoFile;
```
}

/* 播放视频 */ public abstract void paly(String fileName); }

/**

@Description: Windows系统
@Author: zhang lei */ public class Windows extends OperatingSystem{ public Windows(VideoFile videoFile) {
```
 super(videoFile);
```
}

@Override public void paly(String fileName) {
```
 videoFile.decode(fileName);
```
} }

/**

@Description: Mac系统
@Author: zhang lei */ public class Mac extends OperatingSystem{ public Mac(VideoFile videoFile) {
```
 super(videoFile);
```
}

@Override public void paly(String fileName) {
```
 videoFile.decode(fileName);
```
} } java /**
@Description: 桥接模式测试
@Author: zhang lei */ public class PridgeTest { public static void main(String[] args) {
```
 Windows windows = new Windows(new AVIFile());
 windows.paly("肖申克的救赎");
```
} } ```

4.4 应用场景
1. 当一个类存在两种以上独立变化的维度，并且多个维度都需要进行扩展时；
2. 当一个类不希望使用继承或因多层继承导致系统类数量急剧增加时；
3. 当一个类需要在抽象化角色和具体化角色之间增加更多灵活性时，避免两个类之间建立静态的继承关系，通过桥接模式可以使他们在抽象层建立关联关系。

5. 外观模式

5.1 概述

定义：又名门面模式，是一种通过为多个负载子系统提供一个一致的接口，而使这些子系统更加容易被访问的模式。该模式对外有一个统一的接口，外部应用程序不用关心内部子系统的具体实现细节，这样会大大降低应用的复杂度，提高程序的可维护性。

5.2 结构

外观（Facade）模式包含以下主要角色：

外观（Facade）角色：为多个子系统对外提供一个统一的接口；
子系统（Sub System）角色：实现系统的部分功能，客户可以通过外观角色访问它。

5.3 案例
【例】智能家电控制
使用智能音响控制一键打开/关闭全部家电。 ```java /**
- @Description: 灯
- @Author: zhang lei */ public class Light { public void on() { System.out.println(“开灯…”); }
public void off() { System.out.println(“关灯”); } }

/**

@Description: TV

@Author: zhang lei */ public class TV { public void on(){

 System.out.println("打开电视...");

}

public void off(){

 System.out.println("关闭电视...");

} }

/**

@Description: 空调
@Author: zhang lei */ public class Aricondition { public void on() {
```
 System.out.println("打开空调...");
```
}

public void off() {
```
 System.out.println("关闭空调...");
```
} }

/**

@Description: 智能音响

@Author: zhang lei */ public class SmartSound {

private Light light; private TV tv; private Aricondition aricondition;

public SmartSound() {

 this.light = new Light();
 this.tv = new TV();
 this.aricondition = new Aricondition();

}

public void say(String msg) {

 if (msg.contains("打开")) {
     on();
 } else if (msg.contains("关闭")) {
     off();
 } else {
     System.out.println("我还不懂你所说的~");
 }

}

private void on() {

 light.on();
 tv.on();
 aricondition.on();

}

private void off() {

 light.off();
 tv.off();
 aricondition.off();

}

```java
/**
 * @Description: 门面模式测试
 * @Author: zhang lei
 */
public class FacadeTest {
    public static void main(String[] args) {
        SmartSound smartSound = new SmartSound();
        smartSound.say("打开");
    }
}

5.4 应用场景

对于构建分层系统，使用门面模式定义子系统中每层的入口点可以简化子系统之间的依赖关系；
当一个复杂系统有很多子系统时，外观模式可以为系统设计一个简单接口供外界访问；
当客户端与多个子系统之间存在很大联系时，引入外观模式可以将其分离，从而提供子系统的独立性和可移植性。

6. 组合模式😀

6.1 概述

定义：又名部分整体模式，是用于把一组相似的对象当作一个单一的对象。组合模式依据树形接口来组合对象，用来表示部分以及整体层次。

6.2 结构

组合（Combination）模式结构包含以下主要角色：

抽象根节点（Component）：定义系统各层次对象共有方法和属性，可以预先定义一些默认行为和属性；
树枝节点（Composite）：定义树枝节点的行为，存储子节点，组合树枝节点和叶子节点形成一个树形结构；
叶子节点（Leaf）：叶子节点对象，其下再无分支，是系统层次遍历的最小单元。

6.3 案例
【例】软件菜单
一个菜单可以包含菜单项（菜单项是指不再包含其他内容的菜单条目），也可以包含带有其他菜单项的菜单，因此使用组合模式描述菜单项就很恰当。我们的需求是针对一个菜单，打印出所有的菜单已经菜单项的名称。 ```java /**
- @Description: 菜单组件-抽象根节点
- @Author: zhang lei */ public abstract class MenuComponent { //菜单名称 protected String name; //菜单层级 protected int level;
/**
- 添加菜单 *
- @param menuComponent */ public void addMenu(MenuComponent menuComponent) { throw new UnsupportedOperationException(); }
/**
- 移除菜单 *
- @param menuComponent */ public void delMenu(MenuComponent menuComponent) { throw new UnsupportedOperationException(); }
/**
- 获取指定子菜单 *
- @param index
- @return */ public MenuComponent getChild(int index) { throw new UnsupportedOperationException(); }
/**
- 获取菜单名称 *
- @param menuComponent
- @return */ public String getName(MenuComponent menuComponent) { return name; }
public void print() { throw new UnsupportedOperationException(); } }

/**

@Description: 菜单-树枝节点

@Author: zhang lei */ public class Menu extends MenuComponent { private List menuComponentList;

public Menu(String name, int level) {

 this.name = name;
 this.level = level;
 menuComponentList = new ArrayList<MenuComponent>();

}

@Override public void addMenu(MenuComponent menuComponent) {

 menuComponentList.add(menuComponent);

}

@Override public void delMenu(MenuComponent menuComponent) {

 menuComponentList.remove(menuComponent);

}

@Override public MenuComponent getChild(int index) {

 return menuComponentList.get(index);

}

@Override public void print() {

 for (int i = 0; i < level; i++) {
     System.out.print("--");
 }
 System.out.println(name);
 for (MenuComponent menuComponent : menuComponentList) {
     menuComponent.print();
 }

} }

/**

@Description: 菜单项-叶子节点
@Author: zhang lei */ public class MenuItem extends MenuComponent{ public MenuItem(String name, int level) {
```
 this.name = name;
 this.level = level;
```
}

@Override public void print() {
```
 for (int i = 0; i < level; i++) {
     System.out.print("--");
 }
 System.out.println(name);
```
} } java /**
@Description: 组合模式测试

@Author: zhang lei */ public class CombinationTest {

public static void main(String[] args) {

 MenuComponent menu1 = new Menu("菜单管理", 2);
 menu1.addMenu(new MenuItem("页面访问",3));
 menu1.addMenu(new MenuItem("展开菜单",3));
 menu1.addMenu(new MenuItem("新增菜单",3));
 menu1.addMenu(new MenuItem("修改访问",3));
 MenuComponent menu2 = new Menu("角色管理", 2);
 menu2.addMenu(new MenuItem("角色列表",3));
 menu2.addMenu(new MenuItem("新增角色",3));
 menu2.addMenu(new MenuItem("修改角色",3));
 menu2.addMenu(new MenuItem("删除角色",3));
 MenuComponent menu3 = new Menu("权限管理", 2);
 menu3.addMenu(new MenuItem("用户管理",3));
 menu3.addMenu(new MenuItem("菜单管理",3));
 MenuComponent component = new Menu("系统管理", 1);
 component.addMenu(menu1);
 component.addMenu(menu2);
 component.addMenu(menu3);
 component.print();

} } ```

6.4 应用场景

组合模式正是针对属性结构而生，所以组合模式使用场景就是属性结构出现的场景。

7. 享元模式

7.1 概述

定义：运用共享技术来有效地支持大量细粒度对象的复用。它通过共享已经存在的对象来大幅减少需要创建的对象数量、避免创建相似对象的开销，从而提高系统资源利用率。

7.2 结构

享元（Flyweight）模式存在以下两种状态：

内部状态，不会随着环境的改变而改变的可共享部分；
外部状态，指随着环境改变而改变的可共享部分。享元模式实现的要领就是区分应用中的两种状态，并将外部状态外部化。

享元（Flyweight）模式存在以下角色：

抽象享元（Abstract Flyweight）角色：通常是一个接口或者抽象类，在抽象享元类中声明具体享元类的公共方法，这些方法可以向外部提供享元对象的内部数据（外部数据），同时通过这些方法设置外部数据（外部状态）；
具体享元（Concreate Flyweight）角色：他实现了抽象享元类，成为享元对象。在具体享元对象中为内部数据提供了存储空间。通过我们通过单例模式来设计具体享元类，为每个具体享元类提供唯一的享元对象；
非享元（Unsharable Flayweight）角色：并非所有的抽象享元子类都需要被共享，不能被共享的子类可以设计为非共享具体享元类；当需要一个非具体享元类时，可以通过实例化创建；
享元工厂（Flyweight Factory）角色：负责创建和管理享元角色。当客户对象请求一个享元对象时，享元对象检查系统中是否存在符合要求的享元对象。如果不存在的话，则创建一个新的享元对象。

7.3 案例
【例】俄罗斯方块 ```java /**
- @Description: 抽象享元类
- @Author: zhang lei */ public abstract class AbstractBox { public abstract String getShape();
  
  public void display(String color) { System.out.println(“方块形状：” + this.getShape() + “，颜色：” + color); } }

/**

@Description: 具体享元-I型盒子
@Author: zhang lei */ public class Ibox extends AbstractBox{ @Override public String getShape() {
```
 return "I";
```
} }

/**

@Description: 具体享元-L型盒子
@Author: zhang lei */ public class LBox extends AbstractBox{ @Override public String getShape() {
```
 return "L";
```
} }

/**

@Description: 具体享元-O型盒子
@Author: zhang lei */ public class OBox extends AbstractBox{ @Override public String getShape() {
```
 return "O";
```
} }

/**

@Description:
@Author: zl */ public class BoxFactory { private static final BoxFactory BOX_FACTORY = new BoxFactory(); private static HashMap map;

private BoxFactory(){
```
map = new HashMap<String, AbstractBox>();
 Ibox ibox = new Ibox();
 LBox lBox = new LBox();
 OBox oBox = new OBox();
 map.put("I",ibox);
 map.put("L",lBox);
 map.put("O",oBox);
```
}

public static BoxFactory getInstance(){
```
 return BOX_FACTORY;
```
}

public AbstractBox getBox(String key){
```
 return map.get(key);
```
} } java /**
@Description: 享元模式测试

@Author: zhang lei */ public class FlyweightTest { public static void main(String[] args) {

 BoxFactory instance = BoxFactory.getInstance();
 instance.getBox("I").display("红色");
 instance.getBox("L").display("灰色");
 AbstractBox o1 = instance.getBox("O");
 AbstractBox o2 = instance.getBox("O");
 System.out.println(o1 == o2);

} } ```

7.4 应用场景

一个系统有大量相似或相同的对象，造成内存的大量消耗；
对象的大部分状态都可以外部化，可以将这些外部状态传入对象中；
在使用享元模式需要维护一个外部享元对象的享元池，而这需要耗费一定的系统资源。因此，应当在需要多次重复使用享元对象时才值得使用享元模式。

Java 设计模式

🟣 结构型模式

1. 代理模式

1.1 概述

1.2 结构

1.3 静态代理

1.5 CGLib动态代理（待完善）😶

1.6 代理模式-优缺点

2. 适配器模式

2.1 概述

2.2 结构

2.3 类适配器（待完善）😶

2.4 对象适配器模式

2.5 应用场景

3. 装饰者模式

3.1 概述

3.2 结构

3.3 案例

4. 桥接模式

4.1 概述

4.2 结构

4.3 案例

4.4 应用场景

5. 外观模式

5.1 概述

5.2 结构

5.3 案例

5.4 应用场景

6. 组合模式😀

6.1 概述

6.2 结构

6.3 案例

6.4 应用场景

7. 享元模式

7.1 概述

7.2 结构

7.3 案例

7.4 应用场景