Über den Registrierungsmodus

Üblicherweise lassen sich Bewerbungen in folgende Ebenen einteilen:
1. Vorderansicht
2. Befehlssteuerung
3.Geschäftslogik
4. Datenverarbeitung
Die Front-End-Ansicht ist für die Anzeige von Benutzerdaten, das Sammeln von Benutzereingabedaten und deren Übermittlung an die Befehls- und Kontrollschicht verantwortlich. Die Befehlssteuerungsschicht empfängt die Daten, führt eine Reihe von Verarbeitungen durch und beauftragt die Geschäftslogikschicht mit der Ausführung bestimmter Aufgaben. Die Geschäftslogikschicht ruft das Datenverarbeitungsmodul auf, um die Speicherung der Benutzerdaten abzuschließen.
Doch wie können die vom Frontend übermittelten Daten auf mehreren Ebenen direkt und sinnvoll übertragen werden? Eine besteht darin, die Parameter über eine vom vorherigen Befehlsmodus bereitgestellte Kontextklasse zu übergeben und sie von der Befehlssteuerungsschicht an die Geschäftslogikschicht zu übergeben den Kontext. Die zweite Möglichkeit besteht darin, die Schnittstelle des Befehlsobjekts zu ändern, um sie an die entsprechende Datenübertragung anzupassen. Diese beiden Methoden unterbrechen manchmal die Kapselung. Wir wissen, dass das Singleton-Muster eine weitere Möglichkeit bietet, auf globale Variablen zuzugreifen. Statische Variablen sind lokal verborgen und können einfach über Schnittstellen festgelegt und abgerufen werden. Der Registrierungsmodus (Registry) macht sich diesen Komfort zunutze.

Hier können Sie sich den Registrierungsmodus auch als Singleton-Version des Kontextobjekts vorstellen.

Eine einfache Registry-Implementierung:

	abstract class Registry{
		abstract protected function get($key);
		abstract protected function set($key, $value);
	}

PHP unterstützt drei Arten von Objektdaten-Lebenszyklen: Einer beginnt mit dem Empfang einer HTTP-Anfrage und endet, nachdem die Anfrage verarbeitet wurde. Die andere besteht darin, Objekte auf Sitzungsebene zu unterstützen, dh die Objektdaten können in der Sitzung gespeichert werden, und PHP befindet sich in
Während session_start werden unterschiedliche Objektdaten basierend auf der in Cookies gespeicherten Sitzungs-ID wiederhergestellt, wodurch der Zweck erreicht werden kann, dass derselbe Benutzer mehrmals Zugriff auf dieselben Objektdaten anfordert. Es gibt auch eine Anwendungsbereichsebene. d.h.
derselben Anwendung Verschiedene Benutzer können dieselben Objektdaten gemeinsam nutzen. Für diesen Vorgang ist die integrierte Serialisierungsfunktion von PHP erforderlich.

Datenregistrierungsmodus basierend auf einer HTTP-Anfrage:

class RequestRegistry extends Registry{
		private static $instance;
		private $values = array();
		
		private function __construct(){}
		
		static public function instance(){
			if(!isset(self::$instance))
			{
				self::$instance = new self();
			}
			return self::$instance;
		}
		
		protected function get($key){
			if(isset($this->values[$key])){
				return $this->values[$key];
			}
			return null;
		}
		protected function set($key, $value){
			$this->values[$key] = $value;
		}
		
		static function set_request(Request $request){
			self::$instance->set('request', $request);
		}
		
		static function get_request(){
			return self::$instance->get('request');
		}
	}

Anmeldeformular für Sitzungsanfragen:

class SessionRegistry extends Registry{
		private $instance;
		
		 private function __construct(){
			session_start();
		 }
		 
		static function instance(){
			if(!isset(self::$instance)){
				self::$instance = new self();
			}
			return self::$instance;
		}
		
		protected function get($key){
			if(isset($_SESSION[__CLASS__][$key])){
				return $_SESSION[__CLASS__][$key]
			}
			return null;
		}
		
		protected function set($key, $value){
			$_SESSION[__CLASS__][$key] = $value;
		}
		
		public function set_complex(Complex $complex){
			self::$instance->set('complex', $complex);
		}
		
		public function get_complex(){
			return self::$instance->get('complex');
		}
	}

Unterstützt Registrierungen auf Anwendungsebene:

class ApplicationRegistry extends Registry{
		
		private $dir = "data";
		private static $instance;
		private $values = array();
		private $mtimes  = array();
		
		private function __construct(){}
		
		static function instance(){
			if(!isset(self::instance)){
				self::$instance = new self();
			}
			return self::$instance;
		}
		
		protected function set($key, $value){
			$this->values[$key] = $value;
			$path = $this->dir . DIRECTORY_SEPARATOR . $key;
			file_put_contents($path, serialize($value));
			$this->mtimes[$key] = time();
		}
		
		protected function get($key){
			$path = $this->dir . DIRECTORY_SEPARATOR . $key;
			if(file_exists($path)){
				$mtime = filetime($path);
				if(!isset($this->mtimes[$key]))	{$this->mtimes[$key] = 0;}
				if($mtime > $this->mtimes[$key]){
					$data = file_get_contents($path);
					$this->mtimes[$key] = $mtime;
					return ($this->values[$key] = unserialize($data));
				}
				if(isset($this->values[$key])){
					return $this->values[$key];
				}
			}
			return null;
		}
		
		static function get_dsn(){
			return self::$instance->get('dsn');
		}
		
		static function set_dsn($dsn){
			self::$instance->set('dsn', $dsn);
		}
	}

Das Ende.

Das Obige hat den Registrierungsmodus und einige Aspekte davon vorgestellt. Ich hoffe, dass er Freunden, die sich für PHP-Tutorials interessieren, hilfreich sein wird.