Object Relational Mapping (ORM) Basics: Understanding Doctrine ORM

Object Relational Mapping (ORM) Basics: Understanding Doctrine ORM

When we develop applications, we need to operate on the database to store and obtain data. However, it is inconvenient to use the original database query code directly. We need to establish a mapping relationship between objects and data. This is the role of ORM. ORM automatically maps and converts objects and database tables, allowing easy data manipulation, making our code easier to maintain.

Doctrine ORM is one of the most popular ORM frameworks in PHP. It uses a simple but effective method to map PHP objects and database tables, providing an easy-to-use API for CRUD operations.

This article will introduce some basic knowledge of Doctrine ORM, including configuration, entity (Entity), mapping (Mapping) and query (query), etc.

Configuration

Before we begin, we need to install Doctrine ORM. It can be installed through Composer, using the following command:

composer require doctrine/orm

Next, in our PHP file, we need to initialize Doctrine. You can pass the following code:

use DoctrineORMToolsSetup;
use DoctrineORMEntityManager;

require_once "vendor/autoload.php";

$paths = array("path/to/entity-files");
$isDevMode = false;

// the connection configuration
$dbParams = array(
    'driver'   => 'pdo_mysql',
    'user'     => 'your_database_user',
    'password' => 'your_database_password',
    'dbname'   => 'your_database_name',
);

$config = Setup::createAnnotationMetadataConfiguration($paths, $isDevMode);
$entityManager = EntityManager::create($dbParams, $config);

In the above code, we first specify the path to the entity file. We then specified the database connection parameters such as driver, username, password, and database name. Finally, we use the Setup::createAnnotationMetadataConfiguration() function to configure the metadata, and then use the EntityManager::create() function to create the entity manager.

Entity

In fact, Model and Entity are the same thing. We need to create an entity class to map the database table. This class needs to inherit the DoctrineORMMappingClassMetadata class and use DoctrineORMMappingEntity and DoctrineORMMappingTable annotations.

use DoctrineORMMapping as ORM;

/**
 * @ORMEntity
 * @ORMTable(name="users")
 */
class User
{
    /**
     * @ORMId
     * @ORMGeneratedValue
     * @ORMColumn(type="integer")
     */
    private $id;

    /**
     * @ORMColumn(type="string")
     */
    private $name;

    /**
     * @ORMColumn(type="string", length=100, unique=true)
     */
    private $email;

    // ... getters and setters
}

In the above code, we have defined a User entity class that will map the database table named "users". It has three attributes: $id, $name and $email. Annotations tell Doctrine ORM how to map these properties, for example the $id property is the primary key and is auto-incremented, the $name property is mapped to a database column of type varchar, the $email property is mapped to type varchar and must be unique within the database table.

Mapping

After we define the entity, we need to tell Doctrine ORM how to map the entity to the database table. We can use XML, comments or YAML to define mapping relationships.

Here, we use annotation to define the mapping relationship. For example, in the code below, we define a mapping relationship to map the User entity to the users database table:

/**
 * @ORMEntity
 * @ORMTable(name="users")
 */
class User
{
    // properties ...

    // many-to-one association
    /**
     * @ORMManyToOne(targetEntity="Department")
     * @ORMJoinColumn(name="department_id", referencedColumnName="id")
     */
    private $department;
}

In the code above, we define a User entity with Department Many-to-one relationships between entities. All mapping relationship definitions need to be marked with annotations.

Query

Doctrine ORM provides a set of easy-to-use query APIs that allow us to easily perform CRUD operations. For example, the following code demonstrates how to query an entity using Doctrine:

$userRepository = $entityManager->getRepository('User');
$users = $userRepository->findAll();

foreach ($users as $user) {
    echo sprintf("-%s
", $user->getName());
}

In the above code, we use the $entityManager variable to obtain a User repository instance. We then retrieve all User instances using the findAll() method, printing the username of each instance.

Summary

This article introduces the basic knowledge of Doctrine ORM, including configuration, entities, mapping and queries. ORM is a very powerful tool that can greatly simplify the coding of database-related functions. I hope this article will help you understand ORM, and I hope you can learn more about Doctrine ORM and start using it.

The above is the detailed content of Object Relational Mapping (ORM) Basics: Understanding Doctrine ORM. For more information, please follow other related articles on the PHP Chinese website!