golang设计模式图解—

设计模式

GoF提出的设计模式有23个，包括：
（1）创建型(Creational)模式：如何创建对象；
（2）结构型(Structural )模式：如何实现类或对象的组合；
（3）行为型(Behavioral)模式：类或对象怎样交互以及怎样分配职责。

在这里插入图片描述

创建型模式

创建型模式处理对象创建机制，试图在不指定具体类的情况下创建对象。

单例模式（Singleton）：确保一个类只有一个实例，并提供一个全局访问点。使用场景：当你想控制某个类的实例数量，或者保存全局状态时。
工厂方法模式（Factory Method）：定义一个创建对象的接口，但由子类决定实例化哪个类。使用场景：当你不知道在运行时应该创建哪个类的对象时。
抽象工厂模式（Abstract Factory）：提供一个接口，用于创建相关或依赖对象的家族，而不需要明确指定具体类。使用场景：当你想创建一组相关或依赖的对象时。
建造者模式（Builder）：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。使用场景：当你想创建一个复杂对象，这个对象由多个部分构成，且对象的创建和表示需要分离时。
原型模式（Prototype）：通过复制现有的实例来创建新的实例。使用场景：当创建一个实例的成本较高，或者类的实例之间差异很小，通过复制一个已有实例并进行少量修改更为有效时。

结构型模式

结构型模式涉及到如何组合类和对象以获得更大的结构。

适配器模式（Adapter）：将一个类的接口转换成客户希望的另外一个接口。使用场景：当你想使用一个已经存在的类，但其接口不符合你的需求时。
桥接模式（Bridge）：将抽象部分与它的实现部分分离，使它们都可以独立地变化。使用场景：当你想避免在抽象和具体实现之间有一个固定的绑定关系时。
组合模式（Composite）：将对象组合成树形结构以表示“部分-整体”的层次结构。使用场景：当你希望用户忽略组合对象和单个对象的不同，用户将统一地使用所有对象时。
装饰器模式（Decorator）：动态地给一个对象添加一些额外的职责。使用场景：当你想在运行时动态地添加职责到对象，而不影响其他对象时。
外观模式（Facade）：为子系统中的一组接口提供一个一致的界面。使用场景：当你想为复杂的子系统提供一个简单的接口时。
享元模式（Flyweight）：运用共享技术有效地支持大量细粒度的对象。使用场景：当你需要大量的对象，并且这些对象大部分状态都可共享时。
代理模式（Proxy）：为其他对象提供一种代理以控制对这个对象的访问。使用场景：当你想在访问一个对象时进行一些额外的操作，比如检查权限、记录日志、远程访问、加载大图像时。

行为型模式

行为型模式涉及到对象之间的通信，关注的是对象之间的责任分配。

责任链模式（Chain of Responsibility）：为解除请求的发送者和接收者之间耦合，而使多个对象都有机会处理这个请求。使用场景：当你希望给多个对象处理一个请求的机会，或者你想动态地指定处理请求的对象集时。
命令模式（Command）：将一个请求封装为一个对象，使发出请求的责任和执行请求的责任分割开。使用场景：当你想用对象来表示操作时，或者你想用命令和回调进行参数化时。
解释器模式（Interpreter）：给定一个语言，定义它的文法的一种表示，并定义一个解释器，这个解释器使用该表示来解释语言中的句子。使用场景：当你有一个简单的语言，并且你希望解释这个语言的句子时。
迭代器模式（Iterator）：提供一种方法顺序访问一个聚合对象中各个元素, 而又不需暴露该对象的内部表示。使用场景：当你需要访问一个聚合对象，而不管这些对象是什么都需要遍历的时候，你就应该考虑用迭代器模式。
中介者模式（Mediator）：用一个中介对象来封装一系列的对象交互。使用场景：当对象之间的交互复杂且混乱，你希望重新定义对象之间的交互以使其更简单时。
备忘录模式（Memento）：在不破坏封装的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态。使用场景：当你需要保存一个对象在某一个时刻的状态或者备份对象的状态，以便在需要的时候恢复到先前的状态时。
观察者模式（Observer）：定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。使用场景：当一个对象状态改变给其他对象通知，而你又不希望这些对象是紧密耦合的时候。
状态模式（State）：允许一个对象在其内部状态改变时改变它的行为。使用场景：当一个对象的行为取决于它的状态，并且它必须在运行时刻根据状态改变它的行为时。
策略模式（Strategy）：定义一系列的算法,把它们一个个封装起来, 并且使它们可互相替换。使用场景：当你有多种类似的行为，或者你需要能在运行时决定行为时。
模板方法模式（Template Method）：定义一个操作中的算法的骨架，而将一些步骤延迟到子类中。使用场景：当你希望在某个算法的骨架中，有一些具体的步骤在运行时能够被重写时。
访问者模式（Visitor）：为一个对象结构中的各元素提供一个在不改变元素类的前提下定义作用于这些元素的新操作。使用场景：当你有一个复杂的对象结构，你想在这个对象结构上执行一些操作，并且你希望能够在不改变这些对象的类的情况下定义新的操作时。

结构型模式

代理模式

package proxy

import "fmt"

type Seller interface {
    sell(name string)
}

// 火车站
type Station struct {
    stock int //库存
}

func (station *Station) sell(name string) {
    if station.stock > 0 {
        station.stock--
        fmt.Printf("在火车站中：%s买了一张票,剩余：%d \n", name, station.stock)
    } else {
        fmt.Println("票已售空")
    }

}

// 火车代理点
type StationProxy struct {
    station *Station // 持有一个火车站对象
}

func (proxy *StationProxy) sell(name string) {
    if proxy.station.stock > 0 {
        proxy.station.stock--
        fmt.Printf("在代理点中：%s买了一张票,剩余：%d \n", name, proxy.station.stock)
    } else {
        fmt.Println("票已售空")
    }
}

测试用例


package proxy

import "testing"

func TestProxy(t *testing.T) {

    station := &Station{3}
    proxy := &StationProxy{station}
    station.sell("小华")
    proxy.sell("派大星")
    proxy.sell("小明")
    proxy.sell("小兰")
}

正向代理

定义

正向代理是客户端的代理。它代表客户端（例如，浏览器）发出请求。客户端设置代理服务器，并通过它访问互联网上的资源。

工作原理

当客户端请求某个资源时，它首先发送请求到正向代理服务器。然后，代理服务器代表客户端，使用自己的IP地址去请求目标服务器。最后，它从目标服务器获取资源，并将其回传给客户端。

使用场景

访问限制内容：绕过地理或网络限制，访问本不可达的资源。
缓存：为了提高访问速度，正向代理可以缓存常用的资源。
监控与过滤：监控用户行为，过滤不适宜的内容。
用户匿名性：隐藏用户真实IP，保护用户隐私。

反向代理

定义

反向代理是服务器的代理。它代表一台或多台服务器接收来自客户端的请求。对于客户端来说，反向代理就像是它正在直接与后端服务器通信。

工作原理

当客户端发送请求到某个服务器时，反向代理接收请求并决定到哪个后端服务器转发。然后，它将请求转发到选定的服务器，获取响应并将其发送回客户端。

使用场景

负载均衡：分散请求到多个服务器，提高网站的可用性和性能。
SSL加密：集中处理SSL加密和解密，减轻后端服务器的负担。
缓存静态内容：提高响应速度和效率。
安全性：作为额外的防火墙层，保护内部网络。

正向代理与反向代理的对比

特点	正向代理	反向代理
代理对象	客户端	服务器
主要作用	服务于客户端，帮助访问外部资源	服务于服务器，管理和优化客户端请求
安全性	保护用户隐私	保护服务器安全
配置	需要在客户端配置代理	对客户端透明，无需特别配置
应用场景	访问限制内容、缓存、用户匿名性	负载均衡、SSL处理、缓存、安全性增强

结论

正向代理和反向代理虽然在功能上有交集，但它们服务的对象、目的和应用场景大相径庭。正向代理更多地关注于客户端的需求，如匿名性、安全访问等，而反向代理侧重于为服务器提供服务，如负载均衡、加密解密等。了解它们的差异和适用场景，能帮助我们更合理地设计网络架构，提升网络的性能和安全性。在实际工作中，根据具体的需求和环境选择合适的代理类型，能有效地提升我们的系统设计能力和解决问题的能力。