设计模式3-结构型模式

package main

import "fmt"

type Goods struct {
	Kind string   //商品种类
	Fact bool	  //商品真伪
}

// =========== 抽象层 ===========
//抽象的购物主题Subject
type Shopping interface {
	Buy(goods *Goods) //某任务
}


// =========== 实现层 ===========
//具体的购物主题， 实现了shopping， 去韩国购物
type KoreaShopping struct {}

func (ks *KoreaShopping) Buy(goods *Goods) {
	fmt.Println("去韩国进行了购物, 买了 ", goods.Kind)
}


//具体的购物主题， 实现了shopping， 去美国购物
type AmericanShopping struct {}

func (as *AmericanShopping) Buy(goods *Goods) {
	fmt.Println("去美国进行了购物, 买了 ", goods.Kind)
}

//具体的购物主题， 实现了shopping， 去非洲购物
type AfrikaShopping struct {}

func (as *AfrikaShopping) Buy(goods *Goods) {
	fmt.Println("去非洲进行了购物, 买了 ", goods.Kind)
}


//海外的代理
type OverseasProxy struct {
	shopping Shopping //代理某个主题，这里是抽象类型
}

func (op *OverseasProxy) Buy(goods *Goods) {
	// 1. 先验货
	if (op.distinguish(goods) == true) {
		//2. 进行购买
		op.shopping.Buy(goods) //调用原被代理的具体主题任务
		//3 海关安检
		op.check(goods)
	}
}

//创建一个代理,并且配置关联被代理的主题
func NewProxy(shopping Shopping) Shopping {
	return &OverseasProxy{shopping}
}

//验货流程
func (op *OverseasProxy) distinguish(goods *Goods) bool {
	fmt.Println("对[", goods.Kind,"]进行了辨别真伪.")
	if (goods.Fact == false) {
		fmt.Println("发现假货",goods.Kind,", 不应该购买。")
	}
	return goods.Fact
}

//安检流程
func (op *OverseasProxy) check(goods *Goods) {
	fmt.Println("对[",goods.Kind,"] 进行了海关检查， 成功的带回祖国")
}


func main() {
	g1 := Goods{
		Kind: "韩国面膜",
		Fact: true,
	}

	g2 := Goods{
		Kind: "CET4证书",
		Fact: false,
	}

	//如果不使用代理来完成从韩国购买任务
	var shopping Shopping
	shopping = new(KoreaShopping) //具体的购买主题

	//1-先验货
	if g1.Fact == true {
		fmt.Println("对[", g1.Kind,"]进行了辨别真伪.")
		//2-去韩国购买
		shopping.Buy(&g1)
		//3-海关安检
		fmt.Println("对[",g1.Kind,"] 进行了海关检查， 成功的带回祖国")
	}

	fmt.Println("---------------以下是 使用 代理模式-------")
	var overseasProxy Shopping
	overseasProxy = NewProxy(shopping)
	overseasProxy.Buy(&g1)
	overseasProxy.Buy(&g2)
}

// 计算器
type Calculate interface {
    Cal() int
}


//创建一个基准struct，后面的装饰器给这个基准struct加功能
type OriCalculate struct {
    num int
}
func NewOriCalculate(num int)*OriCalculate{
    return &OriCalculate{num:num}
}
func (o *OriCalculate)Cal()  int{
    return o.num
}

//创建基于基准struct的乘法
type MutCalculate struct{
    Calculate
    num int
}
func NewMutCalculate(C Calculate,num int) *MutCalculate {
    return &MutCalculate{Calculate:C,num:num}
}
func (m *MutCalculate) Cal() int {
    return m.num*m.Calculate.Cal()
}

//创建基于基准struct的加法
type AddCalculate struct {
    Calculate
    num int
}

func NewAddCalculate(C Calculate,num int) *AddCalculate  {
    return &AddCalculate{Calculate:C,num:num}
}
func (a *AddCalculate)Cal()int  {
    return a.num+a.Calculate.Cal()
}

// 使用
func ExampleDecorator() {
    //o:=NewOriCalculate(1)
    //定义的时候，接口实现的是指针接收，所以用指针初始化
  
    o:=&OriCalculate{1}
    m:=MutCalculate{o,2}
    a:=AddCalculate{o,3}

    log.Printf("Oricalculate is %d \n MutCalculate is %d\n AddCalculate is %d \n",o.Cal(),m.Cal(),a.Cal())
    // Output: The output of
    // this example.
}

package main

import "fmt"

type HttpRequest interface {
	Do()
}

type HttpClient struct {
	H    HttpRequest
	Url  string
	Host string
}

func (h *HttpClient) DoReq() {
	h.H.Do()
}

func NewHttpClient(req HttpRequest) *HttpClient {
	return &HttpClient{H: req}
}

// 实现HttpRequest就恶口
type Http struct{}

func (h *Http) Do() {
	fmt.Println("发送http请求")
}

type RPCAdapter struct {
	R *RPC
}

func (a *RPCAdapter) Do() {
	// 做一些rpc适配
	// 发送rpc请求s
	a.R.DoRPC()
}
func NewRPCAdapter(r *RPC) HttpRequest {
	return &RPCAdapter{R: r}
}

type RPC struct {
}

func (r *RPC) DoRPC() {
	fmt.Println("发送rpc请求")
}

func main() {

	// -----不使用适配器-----
	http := NewHttpClient(&Http{})
	http.DoReq()

	// -----使用适配器-----
	// 初始化一个rpc请求
	rpc := &RPC{}
	// 将rpc请求装入适配器
	adapter := NewRPCAdapter(rpc)
	// 初始化一个http请求
	http = NewHttpClient(adapter)
	// 发送http请求，实际上被转化成了rpc请求
	http.DoReq()
}