Stellvertreter (Entwurfsmuster)

Verwendung

UML-Diagramm

Klient

Stellvertreter

Subjekt

Reales Subjekt

Beispiele

Passwortschutz

Ferner Zugriff

Objektorientierte Programmierung

Weiteres Anwendungsbeispiel: Kombination mit Fliegengewicht

C++

#include <iostream>
#include <cstring>

typedef double Koordinate;

class Punkt {
public:
  Punkt(Koordinate x = 0.0, Koordinate y = 0.0) {}
  friend bool operator==(const Punkt&, const Punkt&) {
    return false;
  }
  friend std::ostream& operator<<(std::ostream& o, const Punkt&) {
    return o;
  }
  friend std::istream& operator>>(std::istream& i, Punkt&) {
    return i;
  }
};
static const Punkt NullPunkt;

class Event;

class Grafik {
public:
  virtual ~Grafik() = default;
  virtual void zeichne(const Punkt& position) = 0;
  virtual void bearbeiteMaus(Event& ereignis) = 0;
  virtual const Punkt& getAusmasse() = 0;
  virtual void lade(std::istream& von) = 0;
  virtual void speichere(std::ostream& nach) = 0;
protected:
  Grafik() = default;
};

class Bild : public Grafik {
public:
  Bild(const char* datei) { // lädt Bild aus Datei
    std::cout << "Bild::Bild " << datei << '\n';
  }
  virtual ~Bild() = default;
  virtual void zeichne(const Punkt& position) {
    std::cout << "Bild::zeichne " << &position << "\n";
  }
  virtual void bearbeiteMaus(Event& ereignis) {}
  virtual const Punkt& getAusmasse() {
    return NullPunkt;
  }
  virtual void lade(std::istream& von) {}
  virtual void speichere(std::ostream& nach) {}
private:
  // ...
};

class BildProxy : public Grafik {
public:
  BildProxy(const char* dateiName_)
    :bild(nullptr), ausmasse(NullPunkt), dateiName(nullptr) {
    dateiName = strdup(dateiName_);
  }
  virtual ~BildProxy() {}
  virtual void zeichne(const Punkt& position) {
    std::cout << "BildProxy::zeichne " << &position << "\n";
    getBild()->zeichne(position);
  }
  virtual void bearbeiteMaus(Event& ereignis) {
    getBild()->bearbeiteMaus(ereignis);
  }
  virtual const Punkt& getAusmasse() {
    if (NullPunkt == ausmasse) {
      ausmasse = getBild()->getAusmasse();
    }
    return ausmasse;
  }
  virtual void lade(std::istream& von) {
    von >> ausmasse >> dateiName;
  }
  virtual void speichere(std::ostream& nach) {
    nach << ausmasse << dateiName;
  }
  BildProxy(const BildProxy&) = delete; // Dreierregel
  const BildProxy& operator=(const BildProxy&) = delete;
protected:
  Bild* getBild() {
    if (nullptr == bild) {
      bild = new Bild(dateiName);
    }
    return bild;
  }
private:
  Bild* bild;
  Punkt ausmasse;
  char* dateiName;
};

class TextDokument {
public:
  TextDokument() = default;
  void fuegeHinzu(Grafik*) {}
  // ...
};

int main() {
  TextDokument* text = new TextDokument;
  // ...
  BildProxy* einBildProxy = new BildProxy("DateiName");
  text->fuegeHinzu(einBildProxy);
  
  Punkt p1 = NullPunkt;
  einBildProxy->zeichne(p1);
  Punkt p2 = NullPunkt;
  einBildProxy->zeichne(p2);
}

BildProxy::zeichne 0x7fff436da15f
Bild::Bild DateiName
Bild::zeichne 0x7fff436da15f
BildProxy::zeichne 0x7fff436da15e
Bild::zeichne 0x7fff436da15e

Programmierbeispiel für Bedarfsauswertung in PHP

// Subjekt-Interface: Der Klient hängt nur von dieser Abstraktion ab.

interface Bild {
    public function getBreite();
    public function getHoehe();
    public function getPfad();

    public function Inhalt();
}

// gemeinsame Elemente des echten Subjekts und des Stellvertreters werden hier zusammengefasst.

abstract class AbstraktesBild implements Bild {
    protected $_Breite;
    protected $_Hoehe;
    protected $_Pfad;
    protected $_Daten;

    public function getBreite() {
        return $this->_Breite;
    }

    public function getHoehe() {
        return $this->_Hoehe;
    }

    public function getPfad() {
        return $this->_Pfad;
    }
}

// echtes Subjekt

class EchtesBild extends AbstraktesBild {
    public function __construct($Pfad) {
        $this->_Pfad = $Pfad;
        list ($this->_Breite, $this->_Hoehe) = getimagesize($Pfad);
        $this->_Daten = file_get_contents($Pfad);
    }

    public function Inhalt() {
        return $this->_Daten;
    }
}

// Stellvertreter. Lädt das Bild erst bei Bedarf.

class BildStellvertreter extends AbstraktesBild {
    public function __construct($Pfad) {
        $this->_Pfad = $Pfad;
        list ($this->_Breite, $this->_Hoehe) = getimagesize($Pfad);
    }
    protected function _BedarfsLaden() {
        if ($this->_echtesBild === null) {
            $this->_echtesBild = new EchtesBild($this->_Pfad);
        }
    }
    public function Inhalt() {
        $this->_BedarfsLaden();
        return $this->_echtesBild->Inhalt();
    }
}

// Klient

class Klient {
    public function HtmlImg(Bild $img) {
        return '<img src="' . $img->getPfad() . '" alt="" width="50" height="50" />';
    }
}

function Test() {
    $Pfad = 'https://upload.wikimedia.org/wikipedia/commons/d/de/Wikipedia_Logo_1.0.png';
    $klient = new Klient();

    $image = new EchtesBild($Pfad);
    echo $klient->HtmlImg($image), "\n";

    $proxy = new BildStellvertreter($Pfad);
    echo $klient->HtmlImg($proxy), "\n";
}

Test();

Verwandte Entwurfsmuster

Weblinks

Einzelnachweise