设计模式八九中介者模式和代理：边学边做个生成电子书的工具（python+dart）

代理模式是结构性模式，侧重于对对象调用的接口控制，

而中介者模式是行为性模式，解决对象与对象之间相互调用的行为问题。

代理模式是单向嘱托,中介者模式是双向交互

python 实现中介者

class Consumer:
    def __init__(self,product,price):
        self.name = "消费者"
        self.product = product
        self.price = price
    def shopping(self,name):
        print("向{} 购买 {}价格内的 {}产品".format(name,self.price,self.product))


class Producer:
    def __init__(self,product,price):
        self.name="生产商"
        self.product = product
        self.price = price
    def sale(self,name):
        print("向{} 销售 {}价格的 {}产品".format(name,self.price,self.product))

class Mediator:
    def __init__(self):
        self.name = "中介"
        self.consume = None
        self.producer = None
    def sale(self):
        self.consume.shopping(self.producer.name)
    def shopping(self):
        self.producer.sale(self.consume.name)
    def profit(self):
        print('中介净赚：{}'.format(self.consume.price-self.producer.price))
    def complete(self):
        self.sale()
        self.shopping()
        self.profit()

consumer = Consumer("shouji",3000)
producer = Producer("shouji",2000)
mediator =Mediator()
mediator.consume = consumer
mediator.producer = producer
mediator.complete()

dart 实现中介者

class Consumer {
  String name;
  String product;
  int price;
  Consumer(this.name, this.product, this.price);
  shopping(name) {
    print("向{$name} 购买 {${this.price}}价格的 {(${this.product})}产品");
  }
}

class Producer {
  String name;
  String product;
  int price;
  Producer(this.name, this.product, this.price);
  sale(name) {
    print("向{$name} 销售 ${this.price}价格的${this.product}产品");
  }
}

class Mediator {
  String name;

  late Producer producer;
  late Consumer consumer;
  Mediator(this.name, this.producer, this.consumer);
  sale() {
    this.consumer.shopping(this.producer.name);
  }

  shopping() {
    this.producer.sale(this.consumer.name);
  }

  profit() {
    num chajia = this.consumer.price - this.producer.price;
    print("'中介净赚：{($chajia)}'");
  }

  complete() {
    this.sale();
    this.shopping();
    this.profit();
  }
}

void main() {
  Consumer consumer = Consumer("xiaofei", "shouji", 2000);
  Producer producer = Producer("shengchan", "shouji", 1000);
  Mediator mediator = Mediator(
    "zhongjie",
    producer,
    consumer,
  );

  mediator.complete();
}

代理模式（Proxy Pattern）

意图：为其他对象提供一种代理以控制对这个对象的访问。

主要解决：在直接访问对象时带来的问题，比如说：要访问的对象在远程的机器上。在面向对象系统中，有些对象由于某些原因（比如对象创建开销很大，或者某些操作需要安全控制，或者需要进程外的访问），直接访问会给使用者或者系统结构带来很多麻烦，我们可以在访问此对象时加上一个对此对象的访问层。

何时使用：想在访问一个类时做一些控制。

如何解决：增加中间层。

代理模式的python实现

from abc import ABCMeta,abstractmethod
class FemaleA():
    def __init__(self,name):
        self.name =name

class Male():
    __metaclass__ = ABCMeta

    @abstractmethod
    def send_flower(self):
        pass

    @abstractmethod
    def send_chocolate(self):
        pass
    @abstractmethod
    def send_book(self):
        pass


class MaleA(Male):
    def __init__(self,name,love_female):
        self.name = name
        self.love_female = FemaleA(love_female)
    def send_flower(self):
        print(self.name +"send flow "+self.love_female.name)
    def send_chocolate(self):

        print(self.name +"send chocolate "+self.love_female.name)
    def send_book(self):
        print(self.name +"send book "+self.love_female.name)

class Proxy(Male):
    def __init__(self,name,proxyed_name,love_female):
        self.name = name
        self.proxyed = MaleA(proxyed_name,love_female)
    def send_flower(self):
        print(self.name +" 留了一朵")
        self.proxyed.send_flower()
    def send_chocolate(self):
        print(self.name + " 吃了一口")
        self.proxyed.send_chocolate()
    def send_book(self):
        self.proxyed.send_book()


p = Proxy("boyB","boyA","girlA")
p.send_book()
p.send_chocolate()
p.send_flower()

dart 代理模式实现

abstract class Image {
  void display();
}

class RealImage implements Image {
  String filename;
  RealImage(this.filename) {
    loadFromDisk(filename);
  }
  @override
  void display() {
    print("display ing $filename");
  }

  void loadFromDisk(String filename) {
    print("load $filename");
  }
}

class ProxyImage implements Image {
  RealImage? realImage;
  String filename;
  ProxyImage(this.filename);

  @override
  void display() {
    print("display by Proxy image");
    if (realImage == null) {
      realImage = RealImage(filename);
    }
    realImage?.display();
  }
}

void main(List<String> args) {
  Image img = new ProxyImage("dart_logo.png");
  // 图像将从磁盘加载
  img.display();

  print("-" * 50);
  // 图像不需要从磁盘加载
  img.display();
}




// [Running] dart "e:\source\dart\designpatterns\proxy.dart"
// display by Proxy image
// load dart_logo.png
// display ing dart_logo.png
// --------------------------------------------------
// display by Proxy image
// display ing dart_logo.png