The Data Mapper pattern decouples the domain model from the database schema, enabling you to work with domain objects independently of how they are stored. This approach is particularly beneficial in complex applications where the domain logic is intricate and requires a clean separation from the database interactions.

Understanding the Data Mapper Pattern

The Data Mapper pattern consists of two primary components:

  1. Domain Objects: These are the entities that represent the business logic of your application.
  2. Mapper: This is the layer responsible for transferring data between the domain objects and the database.

Example Domain Object

Let's create a simple User domain object:

class User {
    private $id;
    private $name;
    private $email;

    public function __construct($name, $email) {
        $this->name = $name;
        $this->email = $email;
    }

    public function getId() {
        return $this->id;
    }

    public function setId($id) {
        $this->id = $id;
    }

    public function getName() {
        return $this->name;
    }

    public function getEmail() {
        return $this->email;
    }
}

Creating the UserMapper

Next, we will implement the UserMapper class, which will handle the database interactions for the User domain object.

class UserMapper {
    private $pdo;

    public function __construct(\PDO $pdo) {
        $this->pdo = $pdo;
    }

    public function find($id) {
        $stmt = $this->pdo->prepare('SELECT * FROM users WHERE id = :id');
        $stmt->execute(['id' => $id]);
        $data = $stmt->fetch(\PDO::FETCH_ASSOC);

        if ($data) {
            $user = new User($data['name'], $data['email']);
            $user->setId($data['id']);
            return $user;
        }

        return null;
    }

    public function save(User $user) {
        if ($user->getId()) {
            $stmt = $this->pdo->prepare('UPDATE users SET name = :name, email = :email WHERE id = :id');
            $stmt->execute(['name' => $user->getName(), 'email' => $user->getEmail(), 'id' => $user->getId()]);
        } else {
            $stmt = $this->pdo->prepare('INSERT INTO users (name, email) VALUES (:name, :email)');
            $stmt->execute(['name' => $user->getName(), 'email' => $user->getEmail()]);
            $user->setId($this->pdo->lastInsertId());
        }
    }

    public function delete(User $user) {
        if ($user->getId()) {
            $stmt = $this->pdo->prepare('DELETE FROM users WHERE id = :id');
            $stmt->execute(['id' => $user->getId()]);
        }
    }
}

Using the UserMapper

To utilize the UserMapper, you will need to create a PDO connection and then use the mapper to interact with the database.

$pdo = new \PDO('mysql:host=localhost;dbname=test', 'username', 'password');
$userMapper = new UserMapper($pdo);

// Creating a new user
$newUser = new User('John Doe', '[email protected]');
$userMapper->save($newUser);

// Finding a user
$existingUser = $userMapper->find(1);
if ($existingUser) {
    echo "User found: " . $existingUser->getName();
}

// Updating a user
if ($existingUser) {
    $existingUser->setName('Jane Doe');
    $userMapper->save($existingUser);
}

// Deleting a user
if ($existingUser) {
    $userMapper->delete($existingUser);
}

Advantages of Using a Data Mapper

AdvantageDescription
Separation of ConcernsKeeps the domain logic separate from the database logic.
FlexibilityAllows changes to the database schema without affecting the domain objects.
TestabilitySimplifies unit testing by allowing you to mock the mapper layer.
MaintainabilityImproves code organization and readability.

Best Practices

  1. Use Dependency Injection: Inject the PDO instance into the mapper to enhance testability.
  2. Error Handling: Implement proper error handling in your mapper methods to manage database exceptions.
  3. Batch Operations: Consider implementing batch operations in your mapper to improve performance when dealing with multiple records.
  4. Use Transactions: For operations that involve multiple steps, use transactions to ensure data integrity.

Conclusion

Implementing a custom Data Mapper in PHP allows for a clean separation between your domain logic and data persistence concerns. By following the structure outlined in this tutorial, you can create a robust and maintainable application architecture.

Learn more with useful resources: