六边形架构（Hexagonal Architecture）在PHP项目中的应用：解耦业务逻辑与基础设施 - 智猿学院-前后端，数据库，人工智能，云计算等领域前沿技术讲座

六边形架构在PHP项目中的应用：解耦业务逻辑与基础设施

各位观众，大家好！今天我们来聊聊六边形架构（Hexagonal Architecture），以及如何在PHP项目中应用它，实现业务逻辑与基础设施的彻底解耦。

在传统的软件开发中，我们经常会遇到这样的问题：业务逻辑和数据库、用户界面、外部服务等基础设施紧密耦合在一起。这导致代码难以测试、难以维护、难以扩展，而且如果需要更换数据库或用户界面，往往需要对整个系统进行大规模的修改。

六边形架构，又名端口与适配器架构（Ports and Adapters Architecture），正是为了解决这些问题而提出的。它通过引入抽象层，将业务逻辑与外部世界隔离开来，从而实现了解耦。

六边形架构的核心概念

六边形架构的核心概念包括：

六边形（Hexagon）： 代表应用程序的核心业务逻辑。它不依赖于任何外部技术细节，只关注业务规则的实现。
端口（Port）： 定义了六边形与外部世界交互的接口。端口是抽象的，定义了六边形需要什么（输入端口）以及六边形能提供什么（输出端口）。
适配器（Adapter）： 实现了端口，将外部世界的技术细节转换为六边形可以理解的格式，反之亦然。适配器是具体的，针对特定的技术实现。

简单来说，六边形内部是纯粹的业务逻辑，通过端口与外部世界进行交互，而适配器负责连接端口和外部世界。

六边形架构的优势

采用六边形架构具有以下优势：

可测试性： 由于业务逻辑与基础设施解耦，可以使用模拟（mock）或桩（stub）来代替真实的外部依赖，从而轻松进行单元测试。
可维护性： 修改基础设施的代码不会影响业务逻辑，降低了维护成本。
可扩展性： 可以方便地添加新的适配器，以支持新的技术或外部服务，而无需修改业务逻辑。
可移植性： 可以将业务逻辑移植到不同的平台或环境中，只需更换相应的适配器即可。
关注点分离： 不同的开发人员可以专注于不同的部分，例如业务逻辑开发人员专注于六边形内部，而基础设施开发人员专注于适配器的实现。

在PHP项目中应用六边形架构

下面我们通过一个简单的例子，演示如何在PHP项目中应用六边形架构。假设我们要开发一个用户注册系统，需要验证用户输入的用户名和密码是否符合要求，并将用户信息保存到数据库中。

1. 定义端口（Ports）

首先，我们需要定义六边形与外部世界交互的端口。在这个例子中，我们需要一个输入端口来接收用户注册请求，以及一个输出端口来将用户信息保存到数据库中。

输入端口 (UserRegistrationInputPort)：

<?php

namespace AppApplicationPortsInput;

interface UserRegistrationInputPort
{
    public function registerUser(string $username, string $password): void;
}

输出端口 (UserRepository)：

<?php

namespace AppApplicationPortsOutput;

use AppDomainUser;

interface UserRepository
{
    public function save(User $user): void;
    public function findByUsername(string $username): ?User;
}

2. 实现六边形（Hexagon）

接下来，我们需要实现六边形，即应用程序的核心业务逻辑。这个六边形需要实现UserRegistrationInputPort接口，并使用UserRepository接口来保存用户信息。

<?php

namespace AppApplicationServices;

use AppApplicationPortsInputUserRegistrationInputPort;
use AppApplicationPortsOutputUserRepository;
use AppDomainUser;
use AppDomainExceptionsUserAlreadyExistsException;

class UserRegistrationService implements UserRegistrationInputPort
{
    private UserRepository $userRepository;

    public function __construct(UserRepository $userRepository)
    {
        $this->userRepository = $userRepository;
    }

    public function registerUser(string $username, string $password): void
    {
        if ($this->userRepository->findByUsername($username) !== null) {
            throw new UserAlreadyExistsException("User with username {$username} already exists");
        }

        $user = new User($username, $password); // 假设User类存在

        // 业务逻辑：验证用户名和密码是否符合要求 (省略具体验证逻辑)
        if (strlen($username) < 3) {
            throw new InvalidArgumentException("Username must be at least 3 characters long.");
        }
        if (strlen($password) < 6) {
            throw new InvalidArgumentException("Password must be at least 6 characters long.");
        }

        $this->userRepository->save($user);
    }
}

3. 实现适配器（Adapters）

现在，我们需要实现适配器，将外部世界的技术细节转换为六边形可以理解的格式。在这个例子中，我们需要一个适配器来接收来自HTTP请求的用户注册数据，以及一个适配器来将用户信息保存到MySQL数据库中。

HTTP适配器 (UserController)：

<?php

namespace AppInfrastructureControllers;

use AppApplicationPortsInputUserRegistrationInputPort;
use SymfonyComponentHttpFoundationRequest;
use SymfonyComponentHttpFoundationResponse;

class UserController
{
    private UserRegistrationInputPort $userRegistrationService;

    public function __construct(UserRegistrationInputPort $userRegistrationService)
    {
        $this->userRegistrationService = $userRegistrationService;
    }

    public function register(Request $request): Response
    {
        $username = $request->request->get('username');
        $password = $request->request->get('password');

        try {
            $this->userRegistrationService->registerUser($username, $password);
            return new Response('User registered successfully', Response::HTTP_CREATED);
        } catch (InvalidArgumentException $e) {
            return new Response($e->getMessage(), Response::HTTP_BAD_REQUEST);
        } catch (Exception $e) {
            // Handle other exceptions (e.g., UserAlreadyExistsException)
            return new Response('An error occurred', Response::HTTP_INTERNAL_SERVER_ERROR);
        }
    }
}

MySQL适配器 (MySQLUserRepository)：

<?php

namespace AppInfrastructurePersistenceMySQL;

use AppApplicationPortsOutputUserRepository;
use AppDomainUser;
use PDO;

class MySQLUserRepository implements UserRepository
{
    private PDO $pdo;

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

    public function save(User $user): void
    {
        $stmt = $this->pdo->prepare("INSERT INTO users (username, password) VALUES (:username, :password)");
        $stmt->execute([
            'username' => $user->getUsername(),
            'password' => $user->getPassword(), // 注意：实际项目中需要加密密码
        ]);
    }

    public function findByUsername(string $username): ?User
    {
        $stmt = $this->pdo->prepare("SELECT username, password FROM users WHERE username = :username");
        $stmt->execute(['username' => $username]);
        $result = $stmt->fetch(PDO::FETCH_ASSOC);

        if ($result) {
            return new User($result['username'], $result['password']);
        }

        return null;
    }
}

4. 依赖注入和配置

最后，我们需要将各个组件连接起来。这通常通过依赖注入（Dependency Injection）来实现。

<?php

// 假设使用Symfony的依赖注入容器

use AppApplicationServicesUserRegistrationService;
use AppInfrastructureControllersUserController;
use AppInfrastructurePersistenceMySQLMySQLUserRepository;
use SymfonyComponentDependencyInjectionContainerBuilder;
use SymfonyComponentDependencyInjectionReference;

$containerBuilder = new ContainerBuilder();

// 注册MySQLUserRepository
$containerBuilder->register('mysql_user_repository', MySQLUserRepository::class)
    ->setArguments([new Reference('pdo')]);

// 注册UserRegistrationService
$containerBuilder->register('user_registration_service', UserRegistrationService::class)
    ->setArguments([new Reference('mysql_user_repository')]);

// 注册UserController
$containerBuilder->register('user_controller', UserController::class)
    ->setArguments([new Reference('user_registration_service')]);

// 注册PDO (模拟PDO连接)
$containerBuilder->register('pdo', PDO::class)
    ->setFactory(function () {
        // 实际项目中，这里应该配置数据库连接信息
        return new PDO('mysql:host=localhost;dbname=mydb', 'user', 'password');
    });

// 获取UserController
$userController = $containerBuilder->get('user_controller');

// 模拟HTTP请求
$request = new SymfonyComponentHttpFoundationRequest(
    [], // query parameters
    ['username' => 'testuser', 'password' => 'password123'] // request body
);

// 调用注册方法
$response = $userController->register($request);

echo $response->getContent(); // 输出 "User registered successfully"

代码结构示意图

文件夹	文件名	描述
AppApplicationPortsInput	UserRegistrationInputPort.php	定义用户注册的输入端口接口
AppApplicationPortsOutput	UserRepository.php	定义用户仓库的输出端口接口
AppApplicationServices	UserRegistrationService.php	实现用户注册的业务逻辑，依赖于输入和输出端口
AppDomain	User.php	领域模型，表示用户
AppInfrastructureControllers	UserController.php	HTTP适配器，接收HTTP请求，调用用户注册服务
AppInfrastructurePersistenceMySQL	MySQLUserRepository.php	MySQL适配器，实现用户仓库接口，将用户信息保存到MySQL数据库

5. 测试

由于业务逻辑与基础设施解耦，我们可以轻松地对UserRegistrationService进行单元测试，而无需连接到真实的数据库。

<?php

namespace TestsUnitApplicationServices;

use AppApplicationPortsOutputUserRepository;
use AppApplicationServicesUserRegistrationService;
use AppDomainUser;
use PHPUnitFrameworkTestCase;

class UserRegistrationServiceTest extends TestCase
{
    public function testRegisterUser(): void
    {
        // 创建一个模拟的UserRepository
        $userRepositoryMock = $this->createMock(UserRepository::class);

        // 配置模拟对象，使其在save方法被调用时不执行任何操作
        $userRepositoryMock->expects($this->once())
            ->method('save')
            ->with($this->isInstanceOf(User::class));

        $userRepositoryMock->expects($this->once())
            ->method('findByUsername')
            ->willReturn(null); // 模拟用户名不存在

        // 创建UserRegistrationService，并注入模拟的UserRepository
        $userRegistrationService = new UserRegistrationService($userRepositoryMock);

        // 调用registerUser方法
        $userRegistrationService->registerUser('testuser', 'password123');

        // 如果没有抛出异常，则测试通过
        $this->assertTrue(true);
    }

    public function testRegisterUser_userAlreadyExists(): void
    {
        // 创建一个模拟的UserRepository
        $userRepositoryMock = $this->createMock(UserRepository::class);

        $existingUser = new User('testuser', 'existingpassword');
        $userRepositoryMock->expects($this->once())
            ->method('findByUsername')
            ->willReturn($existingUser); // 模拟用户名已存在

        // 创建UserRegistrationService，并注入模拟的UserRepository
        $userRegistrationService = new UserRegistrationService($userRepositoryMock);

        // 断言抛出异常
        $this->expectException(AppDomainExceptionsUserAlreadyExistsException::class);

        // 调用registerUser方法
        $userRegistrationService->registerUser('testuser', 'password123');

    }
}

六边形架构的挑战

虽然六边形架构有很多优点，但也存在一些挑战：

学习曲线： 理解和应用六边形架构需要一定的学习成本。
复杂性： 对于简单的应用程序，引入六边形架构可能会增加不必要的复杂性。
代码量： 由于需要定义端口和适配器，代码量可能会增加。

何时使用六边形架构

六边形架构适用于以下场景：

需要高度解耦的应用程序。
需要频繁更换基础设施的应用程序。
需要进行单元测试的应用程序。
需要支持多种外部服务的应用程序。
团队规模较大，需要明确职责分工的应用程序。

对于小型、简单的应用程序，可以考虑使用更简单的架构。

六边形架构的变体

六边形架构有多种变体，例如：

整洁架构（Clean Architecture）： 由Robert C. Martin (Uncle Bob) 提出，与六边形架构非常相似，但更加强调领域模型的中心地位。
洋葱架构（Onion Architecture）： 由Jeffrey Palermo 提出，也是一种分层架构，将领域模型放在最内层，外部依赖放在最外层。

这些架构都遵循相似的设计原则，旨在实现业务逻辑与基础设施的解耦。

总结：解耦核心，灵活应变

六边形架构通过端口与适配器将业务逻辑与外部依赖隔离，实现了更高的可测试性、可维护性和可扩展性。理解和应用六边形架构可以帮助我们构建更加健壮和灵活的PHP应用程序。