1. Architecture¶
This chapter gives an overview of the overall architecture, terminology and constraints of Doctrine ORM. It is recommended to read this chapter carefully.
1.1. Using an Object-Relational Mapper¶
As the term ORM already hints at, Doctrine ORM aims to simplify the translation between database rows and the PHP object model. The primary use case for Doctrine are therefore applications that utilize the Object-Oriented Programming Paradigm. For applications that do not primarily work with objects Doctrine ORM is not suited very well.
1.2. Requirements¶
Doctrine ORM requires a minimum of PHP 7.1. For greatly improved performance it is also recommended that you use APC with PHP.
1.3. Doctrine ORM Packages¶
Doctrine ORM is divided into three main packages.
Common
一般DBAL (includes Common)
DBAL (共通を含む)ORM (includes DBAL+Common)
ORM (DBAL+共通を含む)
This manual mainly covers the ORM package, sometimes touching parts of the underlying DBAL and Common packages. The Doctrine code base is split in to these packages for a few reasons and they are to…
…make things more maintainable and decoupled
…物事をより保守しやすく分離する…allow you to use the code in Doctrine Common without the ORM or DBAL
…ORMまたはDBALなしでDoctrine Commonのコードを使用できるようにする…allow you to use the DBAL without the ORM
…ORM なしで DBAL を使用できるようにする
1.3.1. The Common Package¶
The Common package contains highly reusable components that have no
dependencies beyond the package itself (and PHP, of course). The
root namespace of the Common package is Doctrine\Common
.
1.3.2. The DBAL Package¶
The DBAL package contains an enhanced database abstraction layer on
top of PDO but is not strongly bound to PDO. The purpose of this
layer is to provide a single API that bridges most of the
differences between the different RDBMS vendors. The root namespace
of the DBAL package is Doctrine\DBAL
.
1.3.3. The ORM Package¶
The ORM package contains the object-relational mapping toolkit that
provides transparent relational persistence for plain PHP objects.
The root namespace of the ORM package is Doctrine\ORM
.
1.4. Terminology¶
1.4.1. Entities¶
An entity is a lightweight, persistent domain object. An entity can be any regular PHP class observing the following restrictions:
An entity class must not be final nor read-only but it may contain final methods or read-only properties.
エンティティ クラスは final または読み取り専用であってはなりませんが、final メソッドまたは読み取り専用プロパティを含むことができます。Any two entity classes in a class hierarchy that inherit directly or indirectly from one another must not have a mapped property with the same name. That is, if B inherits from A then B must not have a mapped field with the same name as an already mapped field that is inherited from A.
相互に直接的または間接的に継承するクラス階層内の 2 つのエンティティ クラスは、同じ名前のマップされたプロパティを持ってはなりません。つまり、B が A から継承する場合、B には、A から継承された既にマップされたフィールドと同じ名前のマップされたフィールドがあってはなりません。
Entities support inheritance, polymorphic associations, and polymorphic queries. Both abstract and concrete classes can be entities. Entities may extend non-entity classes as well as entity classes, and non-entity classes may extend entity classes.
Note
The constructor of an entity is only ever invoked when you construct a new instance with the new keyword. Doctrine never calls entity constructors, thus you are free to use them as you wish and even have it require arguments of any type.
1.4.2. Entity states¶
An entity instance can be characterized as being NEW, MANAGED, DETACHED or REMOVED.
A NEW entity instance has no persistent identity, and is not yet associated with an EntityManager and a UnitOfWork (i.e. those just created with the “new” operator).
NEW エンティティ インスタンスには永続的な ID がなく、EntityManager および UnitOfWork (つまり、「new」演算子で作成されたばかりのもの) にまだ関連付けられていません。A MANAGED entity instance is an instance with a persistent identity that is associated with an EntityManager and whose persistence is thus managed.
MANAGED エンティティ インスタンスは、EntityManager に関連付けられた永続アイデンティティを持つインスタンスであり、その永続性が管理されます。A DETACHED entity instance is an instance with a persistent identity that is not (or no longer) associated with an EntityManager and a UnitOfWork.
DETACHED エンティティ インスタンスは、EntityManager および UnitOfWork に関連付けられていない (または関連付けられていない) 永続的なアイデンティティを持つインスタンスです。A REMOVED entity instance is an instance with a persistent identity, associated with an EntityManager, that will be removed from the database upon transaction commit.
REMOVED エンティティ インスタンスは、トランザクション コミット時にデータベースから削除される、EntityManager に関連付けられた永続的な ID を持つインスタンスです。
1.4.3. Persistent fields¶
The persistent state of an entity is represented by instance variables. An instance variable must be directly accessed only from within the methods of the entity by the entity instance itself. Instance variables must not be accessed by clients of the entity. The state of the entity is available to clients only through the entity’s methods, i.e. accessor methods (getter/setter methods) or other business methods.
Collection-valued persistent fields and properties must be defined
in terms of the Doctrine\Common\Collections\Collection
interface. The collection implementation type may be used by the
application to initialize fields or properties before the entity is
made persistent. Once the entity becomes managed (or detached),
subsequent access must be through the interface type.
1.4.4. Serializing entities¶
Serializing entities can be problematic and is not really
recommended, at least not as long as an entity instance still holds
references to proxy objects or is still managed by an EntityManager.
By default, serializing proxy objects does not initialize them. On
unserialization, resulting objects are detached from the entity
manager and cannot be initialiazed anymore. You can implement the
__serialize()
method if you want to change that behavior, but
then you need to ensure that you won’t generate large serialized
object graphs and take care of circular associations.
1.4.5. The EntityManager¶
The EntityManager
class is a central access point to the
functionality provided by Doctrine ORM. The EntityManager
API is
used to manage the persistence of your objects and to query for
persistent objects.
1.4.6. Transactional write-behind¶
An EntityManager
and the underlying UnitOfWork
employ a
strategy called “transactional write-behind” that delays the
execution of SQL statements in order to execute them in the most
efficient way and to execute them at the end of a transaction so
that all write locks are quickly released. You should see Doctrine
as a tool to synchronize your in-memory objects with the database
in well defined units of work. Work with your objects and modify
them as usual and when you’re done call EntityManager#flush()
to make your changes persistent.
1.4.7. The Unit of Work¶
Internally an EntityManager
uses a UnitOfWork
, which is a
typical implementation of the
Unit of Work pattern,
to keep track of all the things that need to be done the next time
flush
is invoked. You usually do not directly interact with a
UnitOfWork
but with the EntityManager
instead.