Practical OOP: Building a Quiz App - Bootstrapping

This article details building a maintainable and extensible quiz application using PHP, focusing on SOLID principles and the Domain Model and Service Layer patterns. My previous approach to PHP MVC development lacked a true understanding of cohesive application structure and concern separation. This series rectifies that.

Key Concepts:

• SOLID Principles & MVC: The article emphasizes the limitations of MVC alone and advocates for a deeper understanding and application of SOLID principles for robust object-oriented programming.
• Layered Architecture: The quiz app is structured in layers (domain model, service layer, presentation layer) for easy component substitution (e.g., database, UI).
• Domain Model Pattern: The database schema mirrors the object-oriented design, prioritizing clean code over direct database mirroring.
• Service Layer Pattern: This pattern encapsulates business logic, decoupling operations from their underlying classes, enabling reusability across different interfaces (web, CLI).
• Practical Implementation: The article provides a step-by-step guide to setting up the application, including coding the service class, defining its interface, and modeling quizzes and questions as entities. A placeholder mapper simplifies initial database interaction.

Why MVC Isn't Sufficient:

While MVC is valuable, its overuse often results in poorly structured, quasi-object-oriented or procedural code disguised within classes. This project uses the Domain Model pattern (from Martin Fowler's Patterns of Enterprise Application Architecture) to create a truly object-oriented system. Object-Relational Mapping (ORM) is acknowledged but deferred, using a manual, simplified mapper for this tutorial. The Service Layer addresses the challenge of coordinating multiple classes for complex operations.

The Service Layer:

Decoupled code, a cornerstone of good object-oriented design, requires a mechanism to combine independent classes. The Service Layer achieves this by grouping system operations into dedicated service classes, promoting reusability across different application parts (web, CLI, etc.).

Project Setup (using Slim):

Slim, a lightweight framework, is used for simplicity. The composer.json file is provided for dependency management:

{
    "require": {
        "slim/slim": "2.*"
    },
    "autoload": {
        "psr-4": {"QuizApp\": "./lib/"}
    }
}

Quiz Service Interface (QuizInterface.php):

This interface defines the core quiz operations:

<?php
namespace QuizApp\Service;

interface QuizInterface {
    /** @return Quiz[] */
    public function showAllQuizes();
    public function startQuiz($quizOrId);
    /** @return Question */
    public function getQuestion();
    /** @return bool */
    public function checkSolution($id);
    /** @return bool */
    public function isOver();
    /** @return Result */
    public function getResult();
}

Quiz Mapper Interface (QuizMapperInterface.php):

The mapper interface handles database interactions:

{
    "require": {
        "slim/slim": "2.*"
    },
    "autoload": {
        "psr-4": {"QuizApp\": "./lib/"}
    }
}

Entities (Question.php and Quiz.php):

These classes model quiz questions and quizzes themselves:

<?php
namespace QuizApp\Service;

interface QuizInterface {
    /** @return Quiz[] */
    public function showAllQuizes();
    public function startQuiz($quizOrId);
    /** @return Question */
    public function getQuestion();
    /** @return bool */
    public function checkSolution($id);
    /** @return bool */
    public function isOver();
    /** @return Result */
    public function getResult();
}

Placeholder Mapper (Hardcoded.php):

A temporary mapper with hardcoded data for testing:

<?php
namespace QuizApp\Mapper;

interface QuizInterface {
    /** @return \QuizApp\Entity\Quiz[] */
    public function findAll();
    /** @param int $i @return \QuizApp\Entity\Quiz */
    public function find($i);
}

Conclusion and Next Steps:

This initial part sets the foundation. The next part will involve implementing the service class, creating a real database mapper (likely using Doctrine), and developing the controllers and views. The modular design ensures maintainability and extensibility. The full source code for this part is [link to source code].

(FAQs section removed for brevity. The FAQs are well-written and could be included in a separate, follow-up article.)

The above is the detailed content of Practical OOP: Building a Quiz App - Bootstrapping. For more information, please follow other related articles on the PHP Chinese website!