其他分享
首页 > 其他分享> > DesignPatternProxy代理模式

DesignPatternProxy代理模式

作者:互联网

目录

DesignPatternProxy代理模式

为其他对象提供一种代理以控制对这个对象的访问。代理模式用于延迟处理操作或者在进行实际操作前后进行其它处理。

官方简洁代码

package proxy

type Subject interface {
	Do() string
}

type RealSubject struct{}

func (RealSubject) Do() string {
	return "real"
}

type Proxy struct {
	real RealSubject
}

func (p Proxy) Do() string {
	var res string

	// 在调用真实对象之前的工作,检查缓存,判断权限,实例化真实对象等。。
	res += "pre:"

	// 调用真实对象
	res += p.real.Do()

	// 调用之后的操作,如缓存结果,对结果进行处理等。。
	res += ":after"

	return res
}


# 测试代码
package proxy

import "testing"

func TestProxy(t *testing.T) {
	FromAgentBuy()

	var sub Subject
	sub = &Proxy{}

	res := sub.Do()

	if res != "pre:real:after" {
		t.Fail()
	}
}

自己根据业务场景模拟

  • 买房子需要地皮,证件,和装修
  • 如果这些活自己做,太忙了
  • 直接找个托管公司帮你完成就好了
  • 最后这些证件直接交付给你就好了

代码文件结构

iface是抽象层,real是实现层

抽象层代码

IAgent.go
package iface

type IAgent interface {
	GetCard(house IHouse, person IPerson)
	GetFinish(house IHouse, person IPerson)
	BuyHouse(house IHouse, person IPerson)
	Work(house IHouse)
}
ICard.go
package iface

type ICardSpace interface {
	CardDo(house IHouse)
}
IFinish.go
package iface

// 装修模块
type IFinish interface {
	FinishDo(house IHouse, person IPerson)
}
IHouse.go
package iface

type IHouse interface {
	// 房子地皮产出
	FloorDo(person IPerson)
}
IPerson.go
package iface

type IPerson interface {
	// 办理所有手续
	Work(house IHouse)
	GetPerson() interface{}
}

实现层代码

agent.go
package real

import (
	"g-a/09_proxy/house/iface"
)

type Agent struct {
	Name   string
	Person *Person
}

func NewAgent(s string, person *Person) *Agent {
	return &Agent{
		Name:   s,
		Person: person,
	}
}

func (a *Agent) GetCard(house iface.IHouse, person iface.IPerson) {
	card := NewCard("agent_card")
	card.CardDo(house, person)
}

func (a *Agent) GetFinish(house iface.IHouse, person iface.IPerson) {
	finish := NewFinish("agent_f")
	finish.FinishDo(house, person)
}

func (a *Agent) BuyHouse(house iface.IHouse, person iface.IPerson) {
	newHouse := NewHouse("gent_house")
	newHouse.FloorDo(person)
}

func (a *Agent) Work(house iface.IHouse) {
	a.Person.Work(house)
	a.BuyHouse(house, a.Person)
	a.GetCard(house, a.Person)
	a.GetFinish(house, a.Person)
}
card.go
package real

import "g-a/09_proxy/house/iface"

type Card struct {
	Name string
}

func NewCard(n string) *Card {
	return &Card{Name: n}
}

func (c *Card) CardDo(house iface.IHouse, person iface.IPerson) {
	pass_word := c.Name + "-pass"

	p := person.GetPerson().(*Person)
	p.HouseNowPro[pass_word] = true
}
finish.go
package real

import "g-a/09_proxy/house/iface"

type Finish struct {
	Name string
}

func NewFinish(n string) *Finish {
	return &Finish{Name: n}
}

func (f *Finish) FinishDo(house iface.IHouse, person iface.IPerson) {
	f_pass := f.Name + "装修标准标识"

	p := person.GetPerson().(*Person)
	p.HouseNowPro[f_pass] = true
}
house.go
package real

import "g-a/09_proxy/house/iface"

type House struct {
	Name string
}

func NewHouse(n string) *House {
	return &House{Name: n}
}

func (h *House) FloorDo(person iface.IPerson) {
	h_pass := "房子地皮标识"
	p := person.GetPerson().(*Person)

	p.HouseNowPro[h_pass] = true
}
person.go
package real

import (
	"fmt"
	"g-a/09_proxy/house/iface"
)

type Person struct {
	Name        string
	HouseNowPro map[string]bool
}

func NewPerson(n string) *Person {
	return &Person{
		Name:        n,
		HouseNowPro: make(map[string]bool),
	}
}

func (p *Person) GetPerson() interface{} {
	return p
}

func (p *Person) Work(house iface.IHouse) {
	fmt.Println(p.Name, "出身份证去买房,房子名字是:")
}

调试输出

t.go
package house

import (
	"fmt"
	real2 "g-a/09_proxy/house/real"
)

func TTT() {
	house := real2.NewHouse("汤臣一品")
	jane := real2.NewPerson("JANE")
	agent := real2.NewAgent("黑市", jane)
	agent.Work(house)

	for k, _ := range jane.HouseNowPro {
		fmt.Println(k)
	}
}
t_test.go
package house

import "testing"

func TestTTT(t *testing.T) {
	TTT()
}

最终输出

JANE 出身份证去买房,房子名字是:
房子地皮标识
agent_card-pass
agent_f装修标准标识

·额外收获

先看抽象层IPerson代码和实现层Persomn代码

设计的初衷是我才看完zinx框架设计,接口设计模式都渗透了一些,自己也玩玩

在设计IPerson接口时候,在实现层用的是后,因为实现承层传参是

person iface.IPerson,发现取不到真正的person结构体,只能是在写个get方法,最后IPerson是这样的

package iface

type IPerson interface {
	// 办理所有手续
	Work(house IHouse)
	GetPerson() interface{}
}

发现了吧,我写的是interface{},那就在实现层这样写

func (p *Person) GetPerson() interface{} {
   return p
}

最后用的时候,直接断言。so smart!

标签:IHouse,iface,house,代理,模式,person,IPerson,func,DesignPatternProxy
来源: https://www.cnblogs.com/maomaomaoge/p/14126287.html