设计模式——代理模式

设计模式——代理模式

1. 设计模式分为创建型、结构型、行为型三大类。
2. 创建型设计模式主要解决“对象的创建”问题
   1. 比较常用的有单例模式和工厂模式，相关链接如下：
   2. 设计模式——单例模式
   3. 设计模式——工厂模式
3. 结构型设计模式主要解决“类或对象的组合”问题
   1. 比较常用的有代理模式，装饰器模式，相关链接如下：
   2. 设计模式——代理模式
   3. 设计模式——装饰器模式
4. 行为型设计模式主要解决的就是“类或对象之间的交互”问题
   1. 比较常用的有观察者模式，策略模式，模板模式
   2. 设计模式——观察者模式
   3. 设计模式——策略模式
   4. 设计模式——模板模式

---

目录

1. 模式定义和使用场景
2. 模式结构
3. 代理模式优点？
4. 代理模式缺点？
5. 代理模式代码实现

---

1. 模式定义和使用场景

1. 代理模式原理是在不改变原始类的情况下，通过引入代理类来给原始类附加功能。
2. 使用场景：比如在业务系统中开发一些非功能性的需求，例如监控、统计、鉴权、日志等，可以将这些附加功能和业务功能解耦，放到代理类中统一处理，让开发者只需要关注业务方面的开发。

2. 模式结构

1. 代理模式包含如下角色：
   a. Subject: 抽象主题角色
   b. Proxy: 代理主题角色
   c. RealSubject: 真实主题角色
   

3. 代理模式优点？

1. 代理模式能够协调调用者和被调用者，在一定程度上降低了系统的耦合度，扩展性好。
2. 可以对目标对象的功能增强。
3. 可以保护目标对象对象。

4. 代理模式缺点？

1. 由于在客户端和真实主题之间增加了代理对象，因此有些类型的代理模式可能会造成请求的处理速度变慢。
2. 实现代理模式需要额外的工作，增加了系统的复杂度。
3. 代理模式会造成系统中类的数量增加。

5. 代理模式代码实现

1. C++代码实现

#include <iostream>
#include <vector>

using namespace std;

class Subject {
public:
    Subject() {}

    virtual ~Subject() {}

    virtual void request() = 0;
};

class RealSubject : public Subject {
public:
    RealSubject() {}

    virtual ~RealSubject() {}

    void request() {
        cout << "RealSubject::request" << endl;
    }
};

class Proxy : public Subject {
public:
    Proxy() { realSubject = new RealSubject(); }

    virtual ~Proxy() { delete realSubject; }

    void request() {
        preRequest();
        realSubject->request();
        afterRequest();
    }

private:
    RealSubject *realSubject;

    void afterRequest() {
        cout << "Proxy::afterRequest" << endl;
    }

    void preRequest() {
        cout << "Proxy::preRequest" << endl;
    }
};

int main() {

    Proxy proxy;
    proxy.request();

    return 0;
}

2. Go代码实现

package main

import "fmt"

type Subject interface {
	Proxy() string
}

type RealSubject struct {
}

func (p Proxy) Proxy() string {
	var res string
	// 在调用真实对象之前，检查缓存，判断权限，等等
	p.real.After()

	// 调用真实对象
	p.real.Real()

	// 调用之后的操作，如缓存结果，对结果进行处理，等等
	p.real.After()

	return res
}

type Proxy struct {
	real RealSubject
}

func (r RealSubject) Real() {
	fmt.Println("real")
}

func (r RealSubject) Pre() {
	fmt.Println("per")
}

func (r RealSubject) After() {
	fmt.Println("after")
}

func main() {
	var sub Subject
	sub = new(Proxy)
	sub.Proxy()
}