设计模式：结构型（Structural）

适配器模式（Adapter Pattern）

适配器模式是一种结构型设计模式，用于将一个类的接口转换为客户端所期望的另一种接口，以便可以使用不兼容的类协同工作。

适配器模式包含三个核心角色：

• 目标接口（Target）：客户端所期望的接口。
• 源接口（Adaptee）：需要被转换的接口。
• 适配器（Adapter）：将源接口转换成目标接口的类。

电压转换的例子：

public class Adaptee {

    public int output220v() {
        return 220;
    }

}

public interface Target {

    int output5v();

}


public class Adapter implements Target {
    private Adaptee adaptee;

    public Adapter(Adaptee adaptee) {
        this.adaptee = adaptee;
    }

    @Override
    public int output5v() {
        int i = adaptee.output220v();
        System.out.println(String.format("原始电压：%d v -> 输出电压：%d v", i, 5));
        return 5;
    }

}


public class UseAdapter {

    public static void main(String[] args) {
        Adaptee adaptee = new Adaptee();
        Target target = new Adapter(adaptee);
        target.output5v();
    }

}

解决的问题：适配器模式主要解决两个不兼容接口之间的转换问题。

例如，一个系统需要使用一个新的日志框架，但是原有的代码使用的是旧的日志框架，这时可以使用适配器模式。可以创建一个适配器类，该类实现新的日志框架的接口，并在其内部调用旧的日志框架的接口。这样，原有的代码就可以使用新的日志框架了，而不需要修改原有的代码。

第一，确定目标接口

系统原来的日志接口如下

public interface LogFactory {
    void debug(String tag, String message);
}

 第二，三方库接口及实现

下面是第三方库提供的日志功能，但是其接口与二狗他们系统目前使用的不兼容。

public interface NbLogger {
    void d(int priority, String message, Object ... obj);
}
//具体提供日志功能的实现类
public class NbLoggerImp implements NbLogger {
    @Override
    public void d(int priority, String message, Object... obj) {
        System.out.println(String.format("牛逼logger记录:%s",message));
    }
}

 第三，构建适配器类

这个类是适配器模式的核心，通过此类就可以将三方库提供的接口转换为系统的目标接口。

public class LogAdapter implements LogFactory {
    private NbLogger nbLogger;

    public LogAdapter(NbLogger nbLogger) {
        this.nbLogger = nbLogger;
    }

    @Override
    public void debug(String tag, String message) {
        Objects.requireNonNull(nbLogger);
        nbLogger.d(1, message);
    }
}

 LogAdapter 实现了系统的目标接口，同时持有三方库NbLogger的引用。

第四，客户端使用

public class AdapterClient {
    public void recordLog() {
        LogFactory logFactory = new LogAdapter(new NbLoggerImp());
        logFactory.debug("Test", "我将使用牛逼logger打印log");
    }
}

 可以看到，通过适配器客户端就可以很轻松的切换到新的日志系统了。

桥接模式（Bridge Pattern）

桥接模式（Bridge Pattern）是一种结构型设计模式，它将抽象部分和实现部分分离开来，以便两者可以独立地变化。桥接模式的核心思想是将一个系统分成多个维度，每个维度单独考虑，从而简化系统，提高可扩展性和可维护性。 

解决的问题：类的爆炸性增长，类与实现之间的紧耦合。例如通过应用桥接模式，可以将抽象部分（形状）和实现部分（绘制方式）解耦，使得它们可以独立地变化。

桥接模式所涉及的角色有：

• Abstraction：抽象类
• RefinedAbstraction：扩充抽象类
• Implementor：实现类接口
• ConcreteImplementor：具体实现类 

 举个例子，假设有一个形状接口 Shape 和一个颜色接口 Color，如果需要实现各种形状和各种颜色的组合，传统的做法是定义大量的子类，如 RedCircle、GreenCircle、BlueCircle、RedRectangle、GreenRectangle、BlueRectangle 等等。而使用桥接模式，可以把形状和颜色分别抽象出来，分别作为抽象类 Shape 和 Color 的实现类，然后将它们组合起来即可，如 RedCircle、GreenRectangle 等等。这样，在新增一种形状或颜色时，只需要新增一个实现类即可，不需要修改现有的代码，从而提高了代码的可扩展性和维护性。这里是一个简单的 Java 代码示例，演示了如何使用桥接模式来实现 Shape 和 Color 的组合，而不需要定义大量的子类：

// 定义颜色接口
public interface Color {
    void fill();
}

// 实现 Red Color
public class Red implements Color {

    @Override
    public void fill() {
        System.out.println("Filling with red color...");
    }
}

// 实现 Green Color
public class Green implements Color {

    @Override
    public void fill() {
        System.out.println("Filling with green color...");
    }
}

// 定义形状抽象类
public abstract class Shape {
    protected Color color;

    public Shape(Color color) {
        this.color = color;
    }

    abstract void draw();
}

// 实现 Circle 形状
public class Circle extends Shape {

    public Circle(Color color) {
        super(color);
    }

    @Override
    void draw() {
        System.out.print("Drawing circle with ");
        color.fill();
    }
}

// 实现 Rectangle 形状
public class Rectangle extends Shape {

    public Rectangle(Color color) {
        super(color);
    }

    @Override
    void draw() {
        System.out.print("Drawing rectangle with ");
        color.fill();
    }
}

// 测试
public class BridgePatternDemo {

    public static void main(String[] args) {
        Color red = new Red();
        Shape circle = new Circle(red);
        circle.draw();

        Color green = new Green();
        Shape rectangle = new Rectangle(green);
        rectangle.draw();
    }
}

组合模式（Composite Pattern）

组合模式是一种结构型设计模式，它将对象组织成树形结构，使得客户端可以以一致的方式处理单个对象和对象组合。

组合模式由以下两种对象组成：

1. 叶子节点：表示树形结构中的单个对象。
2. 组合节点：表示树形结构中的对象组合，它可以包含其他组合节点和叶子节点。

组合模式的核心思想是将对象组织成树形结构，并且让客户端能够以一致的方式处理单个对象和对象组合。这种结构可以使得客户端将组合对象和单个对象一视同仁，从而简化了客户端的代码。此外，组合模式还可以通过递归方式访问整个树形结构，使得我们可以方便地对树形结构中的对象进行操作。

一个常见的例子是文件系统，文件系统由目录和文件两种元素组成，目录可以包含子目录和文件，而文件只能包含数据。

我们可以使用组合模式来构建文件系统的结构。首先定义一个抽象类 AbstractFile，表示文件和目录的基类，包含了一些基本的操作方法。然后定义 File 类和 Directory 类，分别表示文件和目录。Directory 类维护了一个子节点的列表，可以添加、删除子节点，以及对子节点进行操作。这样就可以通过组合方式来构建出任意复杂的目录结构。

示例代码如下：

// 抽象文件类
abstract class AbstractFile {
    public abstract void add(AbstractFile file);
    public abstract void remove(AbstractFile file);
    public abstract AbstractFile getChild(int index);
    public abstract void operation();
}

// 文件类
class File extends AbstractFile {
    private String name;
    
    public File(String name) {
        this.name = name;
    }
    
    public void add(AbstractFile file) {
        System.out.println("不支持该方法");
    }
    
    public void remove(AbstractFile file) {
        System.out.println("不支持该方法");
    }
    
    public AbstractFile getChild(int index) {
        System.out.println("不支持该方法");
        return null;
    }
    
    public void operation() {
        System.out.println("访问文件 " + name);
    }
}

// 目录类
class Directory extends AbstractFile {
    private List<AbstractFile> files = new ArrayList<>();
    private String name;
    
    public Directory(String name) {
        this.name = name;
    }
    
    public void add(AbstractFile file) {
        files.add(file);
    }
    
    public void remove(AbstractFile file) {
        files.remove(file);
    }
    
    public AbstractFile getChild(int index) {
        return files.get(index);
    }
    
    public void operation() {
        System.out.println("访问目录 " + name);
        for (AbstractFile file : files) {
            file.operation();
        }
    }
}

 使用组合模式可以方便地构建出任意复杂的文件系统结构，增加、删除和操作文件和目录也十分简单。

装饰者模式（Decorator Pattern）

 装饰者模式（Decorator Pattern）是一种结构型设计模式，它允许在不修改现有代码的情况下，通过将对象包装在装饰器对象中来动态地添加新的行为和功能。

public interface Coffee {
    String getDescription();
    double getCost();
}

public class Espresso implements Coffee {
    @Override
    public String getDescription() {
        return "Espresso";
    }

    @Override
    public double getCost() {
        return 1.99;
    }
}

public abstract class CoffeeDecorator implements Coffee {
    protected Coffee coffee;

    public CoffeeDecorator(Coffee coffee) {
        this.coffee = coffee;
    }

    @Override
    public String getDescription() {
        return coffee.getDescription();
    }

    @Override
    public double getCost() {
        return coffee.getCost();
    }
}

public class Milk extends CoffeeDecorator {
    public Milk(Coffee coffee) {
        super(coffee);
    }

    @Override
    public String getDescription() {
        return coffee.getDescription() + ", Milk";
    }

    @Override
    public double getCost() {
        return coffee.getCost() + 0.5;
    }
}

public class Syrup extends CoffeeDecorator {
    public Syrup(Coffee coffee) {
        super(coffee);
    }

    @Override
    public String getDescription() {
        return coffee.getDescription() + ", Syrup";
    }

    @Override
    public double getCost() {
        return coffee.getCost() + 0.25;
    }
}

// 创建一个 Espresso 对象
Coffee espresso = new Espresso();
System.out.println("Description: " + espresso.getDescription());
System.out.println("Cost: " + espresso.getCost());

// 为 Espresso 添加 Milk 和 Syrup 装饰者
Coffee espressoWithMilkAndSyrup = new Milk(new Syrup(new Espresso()));
System.out.println("Description: " + espressoWithMilkAndSyrup.getDescription());
System.out.println("Cost: " + espressoWithMilkAndSyrup.getCost());

外观模式（Facade Pattern）

 外观模式（Facade Pattern）是一种结构型设计模式，它提供了一个简化复杂系统的接口，用于隐藏系统的复杂性，使得客户端可以更加方便地与系统进行交互，同时降低了客户端与系统之间的耦合度。

外观模式的主要目的是通过一个外观类（Facade Class）将一个复杂系统的子系统（或多个对象）进行封装，提供一个统一的高层接口，以便客户端可以通过这个简化的接口来访问系统，而不需要了解系统的复杂内部结构。

外观模式的核心思想是将复杂的系统划分为多个子系统，然后通过一个外观类来对这些子系统进行封装，从而提供一个简化的接口给客户端。外观类通常包含了对各个子系统的引用，并且对子系统的调用进行了适当的封装，对外提供了一个简洁、易用的接口。

// 子系统：窗口管理
class WindowManager {
    public void createWindow(String title, int width, int height) {
        System.out.println("Create window with title: " + title + ", width: " + width + ", height: " + height);
    }

    public void closeWindow(String title) {
        System.out.println("Close window with title: " + title);
    }
}

// 子系统：绘图
class Graphics {
    public void drawLine(int x1, int y1, int x2, int y2) {
        System.out.println("Draw line from (" + x1 + ", " + y1 + ") to (" + x2 + ", " + y2 + ")");
    }

    public void drawRectangle(int x, int y, int width, int height) {
        System.out.println("Draw rectangle at (" + x + ", " + y + ") with width: " + width + ", height: " + height);
    }
}

// 子系统：事件处理
class EventManager {
    public void registerEvent(String eventType, EventListener listener) {
        System.out.println("Register event type: " + eventType + " with listener: " + listener);
    }

    public void unregisterEvent(String eventType, EventListener listener) {
        System.out.println("Unregister event type: " + eventType + " with listener: " + listener);
    }

    public void handleEvent(String eventType) {
        System.out.println("Handle event type: " + eventType);
    }
}

// 外观类：图形界面库外观
class GUIFacade {
    private WindowManager windowManager;
    private Graphics graphics;
    private EventManager eventManager;

    public GUIFacade() {
        windowManager = new WindowManager();
        graphics = new Graphics();
        eventManager = new EventManager();
    }

    // 提供简化的接口供客户端使用
    public void createWindow(String title, int width, int height) {
        windowManager.createWindow(title, width, height);
    }

    public void closeWindow(String title) {
        windowManager.closeWindow(title);
    }

    public void drawLine(int x1, int y1, int x2, int y2) {
        graphics.drawLine(x1, y1, x2, y2);
    }

    public void drawRectangle(int x, int y, int width, int height) {
        graphics.drawRectangle(x, y, width, height);
    }

    public void registerEvent(String eventType, EventListener listener) {
        eventManager.registerEvent(eventType, listener);
    }

    public void unregisterEvent(String eventType, EventListener listener) {
        eventManager.unregisterEvent(eventType, listener);
    }

    public void handleEvent(String eventType) {
        eventManager.handleEvent(eventType);
    }
}

享元模式（Flyweight Pattern）

享元模式（Flyweight Pattern）是一种结构型设计模式，旨在通过共享对象的方式来减少内存使用和提高性能。享元模式适用于需要创建大量相似对象，且这些对象中有很多可以共享的状态或属性的场景，从而避免创建过多的重复对象，节省内存开销。

享元模式的核心思想是将对象的状态划分为内部状态（Intrinsic State）和外部状态（Extrinsic State）。内部状态是对象共享的部分，它不随外部环境的变化而变化，可以被多个对象共享；而外部状态是对象特定的部分，它随外部环境的变化而变化，每个对象都有自己的外部状态。

享元模式的主要角色包括：

1. 享元接口（Flyweight）：定义了共享对象的接口，包含了享元对象的共享方法。
2. 具体享元（Concrete Flyweight）：实现了享元接口，表示具体的享元对象。
3. 享元工厂（Flyweight Factory）：负责创建和管理享元对象的工厂，通过池化的方式来管理和共享对象。
4. 客户端（Client）：使用享元模式的客户端，通过享元工厂获取享元对象，并通过外部状态来定制享元对象的行为。

import java.util.HashMap;
import java.util.Map;

// 享元接口
interface ChessPiece {
    void move(int x, int y);
}

// 具体享元
class ConcreteChessPiece implements ChessPiece {
    private String type; // 内部状态

    public ConcreteChessPiece(String type) {
        this.type = type;
    }

    public void move(int x, int y) {
        System.out.println("Move " + type + " to (" + x + ", " + y + ")");
    }
}

// 享元工厂
class ChessPieceFactory {
    private Map<String, ChessPiece> chessPieces = new HashMap<>();

    public ChessPiece getChessPiece(String type) {
        if (!chessPieces.containsKey(type)) {
            chessPieces.put(type, new ConcreteChessPiece(type));
        }
        return chessPieces.get(type);
    }
}

// 客户端
public class FlyweightExample {
    public static void main(String[] args) {
        ChessPieceFactory factory = new ChessPieceFactory();
        ChessPiece blackPawn = factory.getChessPiece("blackPawn");
        ChessPiece whitePawn = factory.getChessPiece("whitePawn");

        blackPawn.move(2, 3);
        whitePawn.move(4, 5);
    }
}

代理模式（Proxy Pattern） 

代理模式（Proxy Pattern）是一种结构型设计模式，用于在访问对象时引入一个中间层（代理）以控制对目标对象的访问。代理模式可以为目标对象提供额外的功能或者控制对目标对象的访问方式，同时隐藏目标对象的具体实现细节。

代理模式通常涉及三种角色：

1. 目标对象（Subject）：定义了代理和真实对象共同实现的接口，代理模式的目标对象是客户端最终要访问的对象。

2. 代理对象（Proxy）：实现了目标对象的接口，并在其内部持有一个真实对象的引用。代理对象可以在访问目标对象之前或之后执行一些额外的操作，例如权限控制、缓存、日志记录等。

3. 客户端（Client）：通过代理对象来访问目标对象，无需直接与目标对象交互。

代理模式主要解决了以下几个问题：

1. 隐藏目标对象的具体实现细节，将其与客户端分离，提供了更加简洁的接口，降低了系统的耦合度。

2. 在访问目标对象之前或之后可以执行额外的操作，例如权限控制、缓存、日志记录等，从而对目标对象的访问进行了控制和增强。

3. 可以为目标对象提供代理，从而实现一些懒加载、延迟初始化等优化策略。

一个简单的代理模式的示例是数据库连接池，其中代理对象（连接池代理）可以在访问真实的数据库连接之前进行连接的获取和释放、连接的复用、连接的管理等操作，从而对数据库连接的访问进行了控制和优化。

// 目标对象接口
interface Server {
    void doSomething();
}

// 目标对象的实现类
class RealServer implements Server {
    public void doSomething() {
        System.out.println("RealServer: Doing something...");
    }
}

// 代理对象
class ServerProxy implements Server {
    private RealServer realServer; // 持有真实对象的引用

    public void doSomething() {
        // 在访问目标对象之前可以执行一些额外的操作
        System.out.println("ServerProxy: Before doing something...");

        // 懒加载，只在需要时才创建真实对象
        if (realServer == null) {
            realServer = new RealServer();
        }

        // 调用真实对象的方法
        realServer.doSomething();

        // 在访问目标对象之后可以执行一些额外的操作
        System.out.println("ServerProxy: After doing something...");
    }
}

// 客户端
public class Client {
    public static void main(String[] args) {
        Server server = new ServerProxy();
        server.doSomething();
    }
}

 

动态代理是一种在运行时动态生成代理对象的方式，它是代理模式的一种实现方式。与静态代理不同，静态代理需要编写具体的代理类，而动态代理则可以在运行时通过反射等方式动态生成代理对象，从而减少了手动编写大量代理类的工作。

在 Java 中，动态代理主要通过 Java 的反射机制来实现。Java 提供了两种方式来实现动态代理：基于接口的 JDK 动态代理和基于类的 CGLIB 动态代理。

JDK 动态代理基于接口，通过 java.lang.reflect.Proxy 类和 java.lang.reflect.InvocationHandler 接口来实现。使用 JDK 动态代理时，需要定义一个 InvocationHandler 实现类，该类负责处理代理对象的方法调用，并通过 Proxy.newProxyInstance() 方法生成代理对象。 

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

interface Subject {
    void doSomething();
}

class RealSubject implements Subject {
    public void doSomething() {
        System.out.println("RealSubject doSomething");
    }
}

class DynamicProxyHandler implements InvocationHandler {
    private Object target;

    public DynamicProxyHandler(Object target) {
        this.target = target;
    }

    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("Before calling method: " + method.getName());
        Object result = method.invoke(target, args);
        System.out.println("After calling method: " + method.getName());
        return result;
    }
}

public class DynamicProxyExample {
    public static void main(String[] args) {
        RealSubject realSubject = new RealSubject();
        DynamicProxyHandler handler = new DynamicProxyHandler(realSubject);
        Subject proxySubject = (Subject) Proxy.newProxyInstance(
                realSubject.getClass().getClassLoader(),
                realSubject.getClass().getInterfaces(),
                handler
        );
        proxySubject.doSomething();
    }
}