[php] マークアップ投影と作業単位

[php] タグマッピングとワークユニット
タグマッピング

システム内には同じ値を持つが同じ参照ではない 2 つのオブジェクトが存在する可能性があり、そのような重複したオブジェクトがデータベースから読み取られるため、不必要なクエリが発生します。

タグ マッピングは ObjectWatcher クラスであり、プロセス内で重複オブジェクトが出現しないようにプロセス内のドメイン オブジェクトを管理する役割を果たします。

マーク マッピングにより、データベース クエリ データの再読み取りを防ぐことができます。マーク マッピングに対応するオブジェクトが ObjectWatcher クラスに存在しない場合にのみデータベースがクエリされます。これにより、プロセス内で 1 つの データが 1 つのオブジェクトにのみ対応することが保証されます。

コードは非常に理解しやすいもので、配列の値にアクセスして取得する操作です。

ObjectWatcher コード:

namespace demo\domain;

use \demo\domain\DomainObject;

/**
 *  标记映射
 */
class ObjectWatcher {
	private static $instance;
	// 标记映射
	private $all = array();
	
	private function __construct() {
		
	}
	
	public  static function getInstance() {
		if (!isset(self::$instance)) {
			self::$instance = new self();
		}
		
		return self::$instance;
	}
	
	/**
	 * 获得对象对应的键值
	 * @param DomainObject $obj
	 */
	public function getGobalKey(DomainObject $obj) {
		$key = get_class($obj) . '_' . $obj->getId();
		return $key;
	}
	
	/**
	 * 添加到all
	 * @param DomainObject $obj
	 */
	public static function add(DomainObject $obj) {
		$instance = self::getInstance();
		$key = $instance->getGobalKey($obj);
		$instance->all[$key] = $obj;
	}
	
	/**
	 * 从all中删除
	 * @param DomainObject $obj
	 */
	public static function delete(DomainObject $obj) {
		$instance = self::getInstance();
		$key = $instance->getGobalKey($obj);
		unset($instance->all[$key]);
	}
	
	/**
	 * 判断标记是否存在
	 * @param string $className
	 * @param int $id
	 */
	public  static function exists($className, $id) {
		$instance = self::getInstance();
		$key = "{$className}_{$id}";
		if (isset($instance->all[$key])) {
			return $instance->all[$key];
		}
		
		return null;
	}
}

では、どこにマークを付けるのでしょうか? もちろん、Mapper::find()、Mapper::insert()、Mapper::createObject() などのクエリ オブジェクトが生成される場所です。 MapperにAddToMap()とgetFromMap()が新たに追加されました。 (その他のメソッドは変更されていないため、無視してください。)

マッパーコード:

namespace demo\mapper;

use \demo\base\AppException;
use \demo\base\ApplicationRegistry;
use \demo\domain\DomainObject;
use \demo\domain\ObjectWatcher;

/**
 * Mapper
 */
abstract  class Mapper {
	// PDO
	protected static $PDO;
	// config
	protected static  $dsn, $dbUserName, $dbPassword;
	// PDO选项
	protected static $options = array(
    	\PDO::MYSQL_ATTR_INIT_COMMAND => 'SET NAMES utf8',
    	\PDO::ATTR_ERRMODE,
    	\PDO::ERRMODE_EXCEPTION,
	); 
	
	public function __construct() {
		if (!isset(self::$PDO)) {
			// ApplicationRegistry获取数据库连接信息
			$appRegistry = ApplicationRegistry::getInstance();
			self::$dsn = $appRegistry->getDsn();
			self::$dbUserName = $appRegistry->getDbUserName();
			self::$dbPassword = $appRegistry->getDbPassword();
			
			if (!self::$dsn || !self::$dbUserName || !self::$dbPassword) {
				throw  new AppException('Mapper init failed!');
			}
			
			self::$PDO = new \PDO(self::$dsn, self::$dbUserName, self::$dbPassword, self::$options);
		}
	}
	
	/**
	 * 查找指定ID
	 * @param int $id
	 */
	public function findById($id) {
		// 从ObjectWatcher中获取
		$obj = $this->getFromMap($id);
		if (!is_null($obj)) {
			return $obj;
		}
		
		$pStmt = $this->getSelectStmt();		
		$pStmt->execute(array($id));	
		$data = $pStmt->fetch();		
		$pStmt->closeCursor();		
		if (!is_array($data) || !isset($data['id'])) {
			return $obj;
		}
		$obj = $this->createObject($data);
		
		return $obj;
	}
	
	/**
	 * 返回Collection
	 */
	public function findAll() {
		$pStmt = $this->getSelectAllStmt();
		$pStmt->execute(array());
		$raws = $pStmt->fetchAll(\PDO::FETCH_ASSOC);
		$collection = $this->getCollection($raws);
		
		return $collection;
	}
	
	/**
	 * 插入数据
	 * @param \demo\domain\DomainObject $obj
	 */
	public function insert(DomainObject $obj) {
		$flag = $this->doInsert($obj);
		// 保存或者更新ObjectWatcher的$all[$key]的对象
		$this->addToMap($obj);

		return $flag;
	}
	
	/**
	 *  更新对象
	 * @param \demo\domain\DomainObject $obj
	 */
	public  function update(\demo\domain\DomainObject $obj) {
		$flag = $this->doUpdate($obj);
		
		return $flag;
	}
	
	/**
	 * 删除指定ID
	 * @param int $id
	 */
	public function deleteById($id) {
		$pStmt = $this->getDeleteStmt();
		$flag = $pStmt->execute(array($id));
		
		return $flag;
	}
	
	/**
	 * 生成一个$data中值属性的对象
	 * @param array $data
	 */
	public function createObject(array $data) {
		// 从ObjectWatcher中获取
		$obj = $this->getFromMap($data['id']);
		if (!is_null($obj)) {
			return $obj;
		}
		
		// 创建对象
		$obj = $this->doCreateObject($data);
		// 添加到ObjectWatcher
		$this->addToMap($obj);
		
		return $obj;
	}
	
	/**
	 * 返回对应key标记的对象
	 * @param int $id
	 */
	private function getFromMap($id) {
		return ObjectWatcher::exists($this->getTargetClass(), $id);
	}
	
	/**
	 * 添加对象到标记映射ObjectWatcher类
	 * @param DomainObject $obj
	 */
	private function addToMap(DomainObject $obj) {
		return ObjectWatcher::add($obj);
	}
	
	/**
	 * 返回子类Collection
	 * @param array $raw
	 */
	public function getCollection(array $raws) {
		return $this->getFactory()->getCollection($raws);
	}
	
	/**
	 * 返回子类持久化工厂对象
	 */
	public function getFactory() {
		return PersistanceFactory::getFactory($this->getTargetClass());		
	}
	
	protected abstract function doInsert(\demo\domain\DomainObject $obj);
	
	protected abstract function doCreateObject(array $data);
	
	protected abstract function getSelectStmt();
	
	protected abstract function getSelectAllStmt();
	
	protected abstract function doUpdate(\demo\domain\DomainObject $obj);
	
	protected abstract function getDeleteStmt();

	protected abstract function getTargetClass();
}

コードの大部分は以前と同じで、ほんの一部だけが変更されています。下の写真:

ここで、

Mapper がデータベースから取得したデータからマッピングされたオブジェクトがすべて ObjectWatcher にマークされている場合、オブジェクトを ObjectWatcher に手動でマークする必要はありません。Mapper がすでにそれを行っています。 。この利点は、データベースに対する操作と、find や createObject などの新しいオブジェクトの作成を削減できることです。ただし、プログラムでデータを同時に処理する必要がある場合、マークされたオブジェクトのデータに一貫性がない可能性があるため、この時点でデータをロックする必要がある可能性があります。

ワークユニット

場合によっては、データの値を変更せずにデータベースにデータを複数回保存することがありますが、これはもちろん不要です。作業単位を使用すると、必要なオブジェクトのみを保存できます。 ワークユニットは、リクエストが終了しようとしているときに、このリクエストで変更されたオブジェクトをデータベースに保存できます。 コントローラー (Controller) が Command と View を呼び出した後がリクエストの終了です。その後、ここでワークユニットにタスクを実行させることができます。 マーキングマッピングの役割は、処理プロセスの開始時に不要なオブジェクトをデータベースにロードすることであり、作業ユニットは、処理プロセス後にデータベースに

が不必要に保存されるのを防ぐことです。 。これら 2 つの作業方法は補完的であるように見えます。

どのデータベース操作が必要かを判断するには、オブジェクトに関連するさまざまなイベントを追跡する必要があります (例: setter() はオブジェクトの属性値をリセットします)。もちろん、追跡作業は追跡対象のオブジェクト内に配置するのが最適です。

変更された ObjectWatcher クラス:

ObjectWatcher はまだタグマッピングですが、ここではシステム内のオブジェクトの変更を追跡する機能が追加されています。 ObjectWatcher クラスは、オブジェクトを検索、削除、データベースに追加するためのメカニズムを提供します。

namespace demo\domain;

use \demo\domain\DomainObject;

/**
 *  标记映射
 */
class ObjectWatcher {
	private static $instance;
	// 标记映射
	private $all = array();
	// 保存新建对象
	private $new = array();
	// 保存被修改过的对象（“脏对象”）
	private $dirty = array();
	// 保存删除对象
	private $delete = array();
	
	private function __construct() {
		
	}
	
	public  static function getInstance() {
		if (!isset(self::$instance)) {
			self::$instance = new self();
		}
		
		return self::$instance;
	}
	
	/**
	 * 获得对象对应的键值
	 * @param DomainObject $obj
	 */
	public function getGobalKey(DomainObject $obj) {
		$key = get_class($obj) . '_' . $obj->getId();
		return $key;
	}
	
	/**
	 * 添加到all
	 * @param DomainObject $obj
	 */
	public static function add(DomainObject $obj) {
		$instance = self::getInstance();
		$key = $instance->getGobalKey($obj);
		$instance->all[$key] = $obj;
	}
	
	/**
	 * 从all中删除
	 * @param DomainObject $obj
	 */
	public static function delete(DomainObject $obj) {
		$instance = self::getInstance();
		$key = $instance->getGobalKey($obj);
		unset($instance->all[$key]);
	}
	
	/**
	 * 添加到new
	 * @param DomianObject $obj
	 */
	public static function addNew(DomainObject $obj) {
		$instance = self::getInstance();
		$instance->new[] = $obj;
	}
	
	/**
	 * 添加到dirty
	 * @param DomianObject $obj
	 */
	public static function addDirty(DomainObject $obj) {
		$instance = self::getInstance();
		if (!in_array($obj, $instance->dirty, true)) {
			$instance->dirty[$instance->getGobalKey($obj)] = $obj;
		}
	}
	
	/**
	 * 添加到delete
	 * @param DomainObject $obj
	 */
	public static function addDelete(DomainObject $obj) {
		$instance = self::getInstance();
		$instance->delete[$instance->getGobalKey($obj)] = $obj;
	}
	
	/**
	 * 清除标记dirty new delete
	 * @param DomainObject $obj
	 */
	public static function addClean(DomainObject $obj) {
		$instance = self::getInstance();
		// unset删除保存的对象
		unset($instance->dirty[$instance->getGobalKey($obj)]);
		unset($instance->delete[$instance->getGobalKey($obj)]);
		// 删除new中的对象
		$instance->new = array_filter($instance->new, function($a) use ($obj) {
			return !($a === $obj);
		});
	}
	
	/**
	 * 判断标记是否存在
	 * @param string $className
	 * @param int $id
	 */
	public  static function exists($className, $id) {
		$instance = self::getInstance();
		$key = "{$className}_{$id}";
		if (isset($instance->all[$key])) {
			return $instance->all[$key];
		}
		
		return null;
	}
	
	/**
	 * 对new dirty delete 中的标记对象执行操作
	 */
	public function performOperations() {
		$instance = self::getInstance();
		
		// new
		foreach ($instance->new as $obj) {
			$obj->finder()->insert($obj);
		}
		
		// dirty
		foreach ($instance->dirty as $obj) {
			$obj->finder()->update($obj);
		}
		
		// delete
		foreach ($instance->delete as $obj) {
			$obj->finder()->delete($obj);
		}
		
		$this->new = array();
		$this->dirty = array();
		$this->delete = array();
	}
}

ObjectWatcher はオブジェクトを操作するため、これらのオブジェクトが ObjectWatcher 自体を実行するのに非常に適しています。

変更された DomainObject クラス (markNew()、markDirty()、markDelete()、markClean()):

namespace demo\domain;

use \demo\domain\HelperFactory;
use \demo\domain\ObjectWatcher;

/**
 * 领域模型抽象基类
 */
abstract class DomainObject {
	protected  $id = -1;
	
	public function __construct($id = null) {
		if (is_null($id)) {
			// 标记为new 新建
			$this->markNew();
		} else {
			$this->id = $id;
		}
	}
	
	public function getId() {
		return $this->id;
	}
	
	public function setId($id) {
		$this->id = $id;
		$this->markDirty();
	}
	
	public function markNew() {
		ObjectWatcher::addNew($this);
	}
	
	public function markDirty() {
		ObjectWatcher::addDirty($this);
	}
	
	public function markDeleted() {
		ObjectWatcher::addDelete($this);
	}
	
	public function markClean() {
		ObjectWatcher::addClean($this);
	}
	
	public static function getCollection($type) {
		return HelperFactory::getCollection($type);
	}
	
	public function collection() {
		return self::getCollection(get_class($this));
	}
	
	public static function getFinder($type) {
		return HelperFactory::getFinder($type);
	}
	
	public function finder() {
		return self::getFinder(get_class($this));
	}
}

        DomainObject和ObjectWatcher的关系图一张：
                                                     

         修改过的Mapper（和上面相同部分略去了，太占位子了）：

/**
 * Mapper
 */
abstract  class Mapper {
	//...
	
	/**
	 * 查找指定ID
	 * @param int $id
	 */
	public function findById($id) {
		// 从ObjectWatcher中获取
		$obj = $this->getFromMap($id);
		if (!is_null($obj)) {
			return $obj;
		}
		
		$pStmt = $this->getSelectStmt();		
		$pStmt->execute(array($id));	
		$data = $pStmt->fetch();		
		$pStmt->closeCursor();		
		if (!is_array($data) || !isset($data['id'])) {
			return $obj;
		}
		$obj = $this->createObject($data);
		
		return $obj;
	}
	
	
	/**
	 * 插入数据
	 * @param \demo\domain\DomainObject $obj
	 */
	public function insert(DomainObject $obj) {
		$flag = $this->doInsert($obj);
		// 保存或者更新ObjectWatcher的$all[$key]的对象
		$this->addToMap($obj);
		$obj->markClean();
		// 调试用的		
		echo 'insert :' . get_class($obj) . '_' . $obj->getName() . '_' . $obj->getId() .'<br/>';	

		return $flag;
	}
	
	/**
	 *  更新对象
	 * @param \demo\domain\DomainObject $obj
	 */
	public  function update(\demo\domain\DomainObject $obj) {
		$flag = $this->doUpdate($obj);
		$obj->markClean();
		// 调试用的		
		echo 'update :' . get_class($obj) . '_' . $obj->getName() . '_' . $obj->getId() .'<br/>';	
		
		return $flag;
	}
	
	
	/**
	 * 生成一个$data中值属性的对象
	 * @param array $data
	 */
	public function createObject(array $data) {
		// 从ObjectWatcher中获取
		$obj = $this->getFromMap($data['id']);
		if (!is_null($obj)) {
			return $obj;
		}
		
		// 创建对象
		$obj = $this->doCreateObject($data);
		// 添加到ObjectWatcher
		$this->addToMap($obj);
		// 清除new标记
        ObjectWatcher::addClean($obj);
		
		return $obj;
	}
	
	//...
}

        可以看到Mapper中修改的部分都是有改变对象的事件发生，即find()、update()、insert()、delete()。

        对象的变化都能被跟踪到了，那么应该在哪里处理这些变化过的对象（“脏数据”）呢？上面说到了，应该在一次请求即将完成的时候。

        一次请求即将结束时，Controller中调用工作单元（同样省略了没改变的代码）：

namespace demo\controller;

/**
 * Controller
 */
class Controller {
	// ...
	
	private function handleReuqest() {
		$request = new \demo\controller\Request();
		$appController = \demo\base\ApplicationRegistry::getInstance()->getAppController();

		// 执行完所有Command，有可能存在forward
		while ($cmd = $appController->getCommand($request)) {
			// var_dump($cmd);
			$cmd->execute($request);
			// 把当前Command设为已执行过
			$request->setLastCommand($cmd);
		}
		// 工作单元执行任务
		ObjectWatcher::getInstance()->performOperations();
		// 获取视图
		$view = $appController->getView($request);
		// 显示视图
		$this->invokeView($view);
	}
	
	// ...
}

        ObjectWatcher::getInstance()->performOperations()

        好的，现在来个使用例子吧：

namespace demo\command;

use demo\domain\Classroom;
use demo\base\ApplicationRegistry;
use demo\domain\ObjectWatcher;
use demo\domain\HelperFactory;

class Test extends Command {
	protected function doExecute(\demo\controller\Request $request) {
		$crMapper = HelperFactory::getFinder('demo\domain\Classroom');
		
		// 新创建的对象 markNew()
		$crA = new Classroom();
		$crA->setName('四年（3）班');
		
		// 修改后的“脏”数据
		$crB = $crMapper->findById(1);
		$crB->setName("五年（2）班");
	}
}

        输入的Url：

localhost/demo/runner.php?cmd=Test

      输出结果与预期的一样：

insert :demo\domain\Classroom_四年（3）班_58
update :demo\domain\Classroom_五年（2）班_1

        

        现在对领域对象的管理有了较大的改进了。还有，我们使用模式的目的是提高效率，而不是降低效率。