数据源架构模式之数据映射器

http://lobert.iteye.com/blog/2102312

前面分别介绍了数据源架构模式之表数据入口、数据源架构模式之行和数据入口数据源架构模式之活动记录，相较于这三种数据源架构模式，数据映射器显得更加“高大上”。

 

一、概念

数据映射器（Data Mapper）：在保持对象和数据库（以及映射器本身）彼此独立的情况下，在二者之间移动数据的一个映射器层。概念永远都是抽象的，简单的说，数据映射器就是一个负责将数据映射到对象的类数据。

 

二、为什么要使用数据映射器？

数据映射器实现起来比前三种模式都要复杂，那为什么还要使用它呢？

对象间的组织关系和关系数据库中的表是不同的。数据库表可以看成是由行与列组成的格子，表中的一行可以通过外键和另一个表（甚至同一个表）中的一行关联，而对象的组织关系更为复杂：一个对象可能包含其他对象；不同的数据结构可能通过不同的方式组织相同的对象。

 

对象和关系数据库之间的这种分歧被称为“对象关系阻抗不匹配”或“阻抗不匹配”。

数据映射器可以很好地解决这个问题，由它来负责对象和关系数据库两者数据的转换，从而有效地在领域模型中隐藏数据库操作并管理数据库转换中不可以避免的冲突。

 

 

三、简单实现数据映射器

Php代码  

1. <?php  
2. //领域抽象类  
3. abstract class DomainObject {  
4.     private $id = -1;  
5.   
6.     function __construct( $id=null ) {  
7.         if ( is_null( $id ) ) {  
8.             $this->markNew();  
9.         } else {  
10.             $this->id = $id;  
11.         }  
12.     }  
13.   
14.     function getId( ) {  
15.         return $this->id;  
16.     }  
17.   
18.     static function getCollection( $type ) {  
19.         //这里通过一个工广生成此对象对应的数组数据对象  
20.         return HelperFactory::getCollection( $type );   
21.     }  
22.    
23.     function collection() {  
24.         return self::getCollection( get_class( $this ) );  
25.     }  
26.   
27.     function finder() {  
28.         return self::getFinder( get_class( $this ) );  
29.     }  
30.   
31.     static function getFinder( $type ) {  
32.         //这里通过一个工厂生成此对象对应的map对象  
33.         return HelperFactory::getFinder( $type );   
34.     }  
35.   
36.     function setId( $id ) {  
37.         $this->id = $id;  
38.     }  
39.   
40.     function __clone() {  
41.         $this->id = -1;  
42.     }  
43. }  
44.   
45. //场所类  
46. class Venue extends DomainObject {  
47.     private $name;  
48.     private $spaces;  
49.   
50.     function __construct( $id=null, $name=null ) {  
51.         $this->name = $name;  
52.         parent::__construct( $id );  
53.     }  
54.       
55.     function setSpaces( SpaceCollection $spaces ) {  
56.         $this->spaces = $spaces;  
57.     }   
58.   
59.     function getSpaces() {  
60.         if ( ! isset( $this->spaces ) ) {  
61.             //创建对应的SpaceMapper对象  
62.             $finder = self::getFinder( 'Space' );   
63.             $this->spaces = $finder->findByVenue( $this->getId() );  
64.             //$this->spaces = self::getCollection("Space");  
65.         }  
66.         return $this->spaces;  
67.     }   
68.   
69.     function addSpace( Space $space ) {  
70.         $this->getSpaces()->add( $space );  
71.         $space->setVenue( $this );  
72.     }  
73.   
74.     function setName( $name_s ) {  
75.         $this->name = $name_s;  
76.     }  
77.   
78.     function getName( ) {  
79.         return $this->name;  
80.     }  
81.       
82.     static function findAll() {  
83.         $finder = self::getFinder( __CLASS__ );   
84.         return $finder->findAll();  
85.     }  
86.     static function find( $id ) {  
87.         $finder = self::getFinder( __CLASS__ );   
88.         return $finder->find( $id );  
89.     }  
90.   
91. }  
92.   
93.   
94. abstract class Mapper{  
95.     protected static $PDO;   
96.     function __construct() {  
97.    
98.         if ( ! isset(self::$PDO) ) {   
99.             //此处可加缓存  
100.             self::$PDO = new PDO( $dsn );  
101.             self::$PDO->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);  
102.         }  
103.     }  
104.   
105.     private function getFromMap( $id ) {  
106.         //从内存取出此$id的DomainObject对象  
107.     }  
108.   
109.     private function addToMap( DomainObject $obj ) {  
110.         //将此DomainObject对象加入到内存  
111.     }  
112.   
113.     function find( $id ) {  
114.         $old = $this->getFromMap( $id );  
115.         if ( $old ) { return $old; }  
116.         $this->selectstmt()->execute( array( $id ) );  
117.         $array = $this->selectstmt()->fetch( );   
118.         $this->selectstmt()->closeCursor( );  
119.         if ( ! is_array( $array ) ) { return null; }  
120.         if ( ! isset( $array['id'] ) ) { return null; }  
121.         $object = $this->createObject( $array );  
122.         return $object;   
123.     }  
124.   
125.     function findAll( ) {  
126.         $this->selectAllStmt()->execute( array() );  
127.         return $this->getCollection( $this->selectAllStmt()->fetchAll( PDO::FETCH_ASSOC ) );  
128.     }  
129.    
130.     function createObject( $array ) {  
131.         $old = $this->getFromMap( $array['id']);  
132.         if ( $old ) { return $old; }  
133.         $obj = $this->doCreateObject( $array );  
134.         $this->addToMap( $obj );  
135.         return $obj;  
136.     }  
137.   
138.     function insert( DomainObject $obj ) {  
139.         $this->doInsert( $obj );   
140.         $this->addToMap( $obj );  
141.     }  
142.   
143.     protected abstract function getCollection( array $raw );  
144.     protected abstract function doCreateObject( array $array );  
145.     protected abstract function doInsert( DomainObject $object );  
146.     protected abstract function targetClass();  
147.     protected abstract function selectStmt( );  
148.     protected abstract function selectAllStmt( );  
149. }  
150.   
151. class VenueMapper extends Mapper {  
152.   
153.     function __construct() {  
154.         parent::__construct();  
155.         $this->selectAllStmt = self::$PDO->prepare(   
156.                             "SELECT * FROM venue");  
157.         $this->selectStmt = self::$PDO->prepare(   
158.                             "SELECT * FROM venue WHERE id=?");  
159.         $this->updateStmt = self::$PDO->prepare(   
160.                             "UPDATE venue SET name=?, id=? WHERE id=?");  
161.         $this->insertStmt = self::$PDO->prepare(   
162.                             "INSERT into venue ( name )   
163.                              values( ? )");  
164.     }   
165.       
166.     function getCollection( array $raw ) {  
167.         //这里简单起见用个对象数组  
168.         $ret = array();  
169.         foreach ($raw as $value) {  
170.             $ret[] = $this->createObject($value);  
171.         }  
172.         return $ret;  
173.     }  
174.   
175.     protected function doCreateObject( array $array ) {  
176.         $obj = new Venue( $array['id'] );  
177.         $obj->setname( $array['name'] );  
178.         //$space_mapper = new SpaceMapper();  
179.         //$space_collection = $space_mapper->findByVenue( $array['id'] );  
180.         //$obj->setSpaces( $space_collection );  
181.         return $obj;  
182.     }  
183.   
184.     protected function targetClass() {  
185.         return "Venue";  
186.     }  
187.   
188.     protected function doInsert( DomainObject $object ) {  
189.         $values = array( $object->getname() );   
190.         $this->insertStmt->execute( $values );  
191.         $id = self::$PDO->lastInsertId();  
192.         $object->setId( $id );  
193.     }  
194.       
195.     function update( DomainObject $object ) {  
196.         $values = array( $object->getname(), $object->getid(), $object->getId() );   
197.         $this->updateStmt->execute( $values );  
198.     }  
199.   
200.     function selectStmt() {  
201.         return $this->selectStmt;  
202.     }  
203.   
204.     function selectAllStmt() {  
205.         return $this->selectAllStmt;  
206.     }  
207.   
208. }  
209.   
210. //client代码  
211.   
212. $venue = new venue();  
213. $venue->setName("XXXXXXX");  
214. //插入一条数据  
215. $mapper = new VenueMapper();  
216. $mapper->insert($venue);  
217. //获取刚插入的数据  
218. $venueInfo = $mapper->find($venue->getId());  
219. //修改数据   
220. $venue->setName('OOOOOOOOOOO');  
221. $mapper->update($venue);  
222. ?>  

 代码省略了一些辅助类，保留最主要的领域对象和数据映射器。数据映射器模式最强大的地方在于消除了领域层和数据库操作之间的耦合。Mapper对象在幕后运作，可以应用于各种对象关系映射。而与之带来的是需要创建大量具体的映射器类。不过现在框架都可以通过程序自动生成了。

 

 

四、使用时机

使用数据库映射器的主要是数据库方案和对象模型需要彼此独立演变的时候。最常见的当然是和领域模式一起使用。数据映射器无论是在设计阶段、开发阶段，还是测试阶段，在领域模型上操作时可以不考虑数据库。领域对象对数据库的结构一无所知，因为所有这些对应关系都由数据映射器完成。

当然，数据映射器引入了新的层次，因此使用这些模式的前提条件是业务逻辑的复杂性，如果很简单，那就没必要了。

如果没有领域模型，我不会选用数据映射器。但是没有数据映射器时，能使用领域模型吗？如果领域模型简单，且数据库受领域模型开发者的控制，则领域对象用活动记录直接访问数据库也是合理的。

 

不必创建完全意义上的数据库映射层。创建这样的数据映射器很复杂。大多数情况下，建议使用开源的数据库映射层而不是自己动手创建