PHP 고급 기능: 리플렉션과 팩토리 디자인 패턴을 함께 사용하는 방법

고급 PHP 기능 - Reflection과 Factory 디자인 패턴의 조합 사용 [코드 예]

고급 PHP 기능 - Reflection과 Factory 디자인 패턴의 조합 사용 [Laravel-Admin 코드 예를 사용한 설명]

Reflection을 사용하여 Factory 패턴 구현 없이 Production 특정 팩토리 클래스 만들기

Reflection [반사]

Reflection이란

Reflection, 즉 리플렉션입니다. Reflection은 객체 지향 프로그래밍에 자기 성찰 기능을 제공합니다. 이러한 이해는 일반인의 관점에서 볼 때 이벤트의 결과를 기반으로 원인을 찾을 수 있다는 의미입니다. 프로그래밍에서는 인스턴스화된 개체를 기반으로 해당 개체가 속한 클래스와 해당 클래스가 갖는 모든 속성 및 메서드를 찾을 수 있으며 문서 주석도 읽을 수 있습니다. 이러한 역방향 확인 프로세스를 리플렉션이라고 합니다. [권장 학습:

PHP 비디오 튜토리얼

]PHP는 완전한 리플렉션 API를 제공하여 클래스, 인터페이스, 함수, 메서드 및 확장을 검사할 수 있는 기능을 제공합니다. 또한 Reflection API는 함수, 클래스 및 메서드에서 문서 주석을 추출하는 메서드를 제공합니다. 자세한 내용은 PHP 공식 웹사이트를 참조하세요. PHP Reflection 소개

Reflection이 할 수 있는 일

위에서 언급했듯이 리플렉션을 사용하면 주석 문서뿐만 아니라 클래스의 모든 속성과 메서드를 얻을 수 있으며 심지어 액세스 권한도 얻을 수 있습니다. 클래스 속성 및 메소드([protected/private])에 대한 권한을 제공하므로 이러한 기능은 PHP의 유연성을 크게 향상시킵니다. 예:

– 소위 Laravel 프레임워크의 우아함, 즉 컨테이너, 종속성 주입 및 IOC 제어 반전은 이러한 기능을 사용하여 달성됩니다.

– Hyperf 프레임워크의 주석 라우팅도 다음으로 구현됩니다. 리플렉션을 기반으로 주석 얻기

– 리플렉션이 클래스 속성 및 메서드에 대한 액세스를 얻을 수 있고 전체 프로젝트의 모든 파일을 스캔한 다음 리플렉션을 사용하여 문서를 생성할 수 있기 때문에 문서가 생성됩니다

– 테스트 중심 개발은 리플렉션을 사용하여 테스트 주도 개발을 위한 클래스의 모든 메소드 특성

– 플러그인 개발 리플렉션을 사용하여 클래스 내부 구조의 특성을 파악하고 프레임워크 플러그인 구현 등 Hook 기능 구현

장점 그리고 Reflection의 단점

장점 Reflection은 클래스에 대한 안티 분석 기능을 제공하므로 원래의 객체 지향 프로그래밍 방법에 비해 장점을 얻습니다. 매우 높은 유연성과 합리적인 사용으로 코드를 더욱 우아하고 간결하게 만들 수 있습니다. 원래 객체지향 프로그래밍에서는 클래스의 인스턴스를 사용하려면 먼저 객체를 새로 만든 다음 메서드를 사용해야 하지만 리플렉션 메커니즘을 사용하면 클래스의 메서드만 제공한 다음 사용하면 됩니다. 객체나 메소드를 사용하는 반사 메커니즘. Laravel 프레임워크는 우아하다는 평판을 얻기 위해 많은 리플렉션을 사용합니다. Swoole의 Hyperf 프레임워크의 주석 라우팅 구현도 리플렉션을 사용합니다

단점 동시에 리플렉션은 클래스 인스턴스화의 역 과정이므로 객체를 파괴합니다. 지향 캡슐화 클래스의 전체 내부 구조를 직접 노출하므로 리플렉션이 남용되면 코드 관리가 어려워지고 전체 프로젝트가 매우 혼란스러워지며 비즈니스 실행이 혼란스러워질 수도 있습니다. 특히 대규모 프로젝트에 수십 명의 사람들이 있는 팀에서는 원래의 객체 지향 시스템이 사용할 수 있는 것과 사용할 수 없는 것만 알려주고 CTO가 기본 코드를 작성하고 다른 사람들이 이를 상속하여 사용할 수 있다고 상상해 보십시오. .. 내부 구조나 기타 사항은 아무도 모릅니다. 일단 리플렉션을 사용하면 프로그래머가 실수로 원래 보호되거나 비공개였던 속성이나 메서드를 액세스 가능하게 설정하고, 다른 프로그래머가 이를 모르고 숨겨야 할 데이터나 메서드를 호출하면 예측할 수 없는 재앙이 발생합니다. [샘플 코드 참조 아래]

둘째, 리플렉션의 유연성이 매우 높기 때문에 IDE에서 코드 소스를 직접 클릭하는 것이 불가능합니다. 이는 Laravel과 Hyperf 모두 초보자에게 정말 고통스럽습니다. 그래서

아래 코드에서, 리플렉션 메커니즘은 프라이빗 메소드를 외부에서 액세스할 수 있도록 직접 설정합니다

#Example:
<?php
class Foo {
  private function myPrivateMethod() {
    return 7;
  }
}
$method = new ReflectionMethod(&#39;Foo&#39;, &#39;myPrivateMethod&#39;);
//该反射功能直接将原本是private权限的方法设置成可访问
$method->setAccessible(true);
echo $method->invoke(new Foo);
// echos "7"
?>

Factory 디자인 패턴

3가지 팩토리 디자인 패턴 [Simple Factory Pattern] [Factory Pattern] [Abstract Factory Pattern]

Simple Factory 패턴이라고도 합니다 정적 팩토리 메소드 패턴. 간단히 말해서 객체를 생성하는 방법은 정적 메서드를 사용하는 것입니다. 단순 팩토리 패턴에서는 전달된 매개변수에 따라 다양한 클래스의 인스턴스가 반환됩니다.

PHP에는 단순 팩토리 패턴에 추상 제품 클래스(즉, 추상 클래스 Calculate)가 있습니다. 이 추상 클래스는 인터페이스/추상일 수 있습니다. 수업/공통 수업. 이 추상 제품 클래스는 여러 특정 제품 클래스(예: CalculateAdd 클래스 및 CalculateSub 클래스)를 파생할 수 있습니다. 마지막으로, 특정 팩토리 클래스[즉, CalculateFactory 클래스]는 필요한 제품 클래스의 인스턴스를 얻는 데 사용됩니다

코드 구현

1) 추상 제품 생산 클래스: 작업 추상 클래스

//生产抽象类
abstract class Calculate{
    //数字A
    protected $number_a = null;
    //数字B
    protected $number_b = null;
    //设置数字A
    public function setNumberA( $number ){
        $this->number_a = $number;
    }
    //设置数字B
    public function setNumberB( $number ){
        $this->number_b = $number;
    }
    //获取数字A
    public function getNumberA(){
        return $this->number_a;
    }
    //获取数字B
    public function getNumberB(){
        return $this->number_b;
    }
    //获取计算结果【获取生产出的产品】
    public function getResult(){
        return null;
    }
}

2) 특정 제품 생산 클래스: 덧셈 연산/뺄셈 연산 등

//加法运算
class CalculateAdd extends Calculate{
    //获取运算结果【获取具体的产品】
    public function getResult(){
        return $this->number_a + $this->number_b;
    }
}
//减法运算
class CalculateSub extends Calculate{
    //获取运算结果【获取具体的产品】
    public function getResult(){
        return $this->number_a - $this->number_b;
    }
}
//乘法 / 除法 等等其他运算【其他产品】

3) 工厂：工厂类。即用一个单独的类来创造实例化的过程，这个类就是工厂。也就是 简单工厂模式

在 php 中，实现的方式其实就一个 switch 函数或者是 php8 新出的 match 函数来实例化所需要的产品生产类

//根据运算不同实例化不同的对象
//【也就是根据所需产品，实例化对应的产品类进行生产】
//对应的实现其实就是一个switch或者php8函数新出的match函数
//下面用最新的match函数做演示
class CalculateFactory{
    public static function setCalculate( $type = null ){
        return match( $type ){
            'add' => (function(){
                return new CalculateAdd();
            })(),
            'sub' => (function(){
                return new CalculateSub();
            })(),
            default => null;
        };
    }
}
//具体使用
$calculate = CalculateFactory::setCalculate('add');
$calculate->setNumberA = 1;
$calculate->setNumberB = 2;
//计算
echo $calculate->getResult;//echo 3

总结：

简单工厂模式其实就是创建一个基类【abstract】，该类存放所有具体生产产品类的共用的代码，但是没有执行过程，然后具体生产产品的类全部继承基类再实现各自的生产过程。最后创建一个工厂类，该类用来根据传入的参数来获取所需的生产类

工厂方法模式 又称为工厂模式，属于创造型模式。在工厂模式中，工厂类的父类只负责定义公共接口，并不执行实际的生产动作。实际的生产动作则交给工厂的子类来完成。这样做将类的的实例化延迟到了工厂的子类，通过工厂的子类来完成实例化具体的产品，也就是生产

在工厂模式中，跟简单工厂模式不一样的是，有一个抽象的工厂类【即interface CalculateFactory】，可以是接口/抽象类，这个抽象的工厂类可以派生出多个具体的工厂类【即FactoryAdd以及FactorySub】

代码实现【以下代码需要用到上面的生产抽象类】

以下代码需要用到上面的生产抽象类：abstract class Calculate

以及具体的生产类，即：CalculateAdd 以及 CalculateSub。下面不再重复实现

interface CalculateFactory{
    public function CreateCalculate();
}
class FactoryAdd implements CalculateFactory{
    public function CreateCalculate(){
        return new CalculateAdd();
    }
}
class FactorySub implements CalculateFactory{
    public function CreateCalculate(){
        return new CalculateSub();
    }
}
//具体使用
//创建工厂实例
$calculateFactory = new FactoryAdd();
$add = $calculateFactory->CreateCalculate();
$add->setNumberA( 1 );
$add->setNumberB( 2 );
//计算
echo $add->getResult();//echo 3

总结：

工厂模式相比于简单工厂模式的区别在于，在简单工厂模式中，只有一个工厂来生产对应的生产对象【即CalculateFactory】。而在工厂模式中，每一个生产产对象都由自己的工厂来生产，并且这些工厂都继承自同一个接口【即 interface CalculateFactory】

抽象工厂模式 抽象工厂模式提供创建一系列相关或相互依赖对象的接口，而且无需指定它们具体的类。这么理解很抽象。通俗一点的解释就是，相比于上面的工厂模式来讲，抽象工厂模式在每个不同的工厂之上又有一个超级工厂，这个超级工厂是抽象的接口【interface】，用来生产具体的工厂

在抽象工厂模式中，有多个抽象的产品类【即abstract class Phone以及abstract class Android】，可以是接口/抽象类/普通类，每个抽象产品类可以派生出多个具体产品类【即class IPhone / class MiPhone 以及 class IOS / class Android】。一个抽象的工厂类【即interface AbstractFactory】可以派生出多个具体的工厂类【即class iPhoneFactory以及class MiFactory】，且每个具体的工厂类可以创建多个产品类的实例【即都有createPhone和createSystem】

代码实现

//抽象的产品类
abstract class Phone{}
abstract class System{}
//具体的产品类
class IPhone extends Phone{}
class MiPhone extends Phone{}
//具体的产品类
class IOS extends System{}
class Android extends System{}
//超级工厂
interface AbstractFactory{
    public function createPhone();
    public function createSystem();
}
//具体的苹果工厂
class iPhoneFactory implements AbstractFactory{
    //生产苹果手机
    public function createPhone(){
        return new IPhone();
    }
    //生产苹果系统
    public function createSystem(){
        return new IOS();
    }
}
//具体的小米工厂
class MiFactory implements AbstractFactory{
    //生产小米手机
    public function createPhone(){
        return new MiPhone();
    }
    //生产安卓系统
    public function createSystem(){
        return new Android();
    }
}

总结：

抽象工厂模式相比于工厂模式，抽象工厂模式提供了一个接口用来规定所需要生产的产品。每个继承于该接口的工厂都能按照指定的模式进行生产【代码中的AbstarctFactory】

以上三种工厂模式，最终都是为了将重复的代码提取出来，并且按照特定的需求场景归纳好，进行解耦和复用，以便在需要的场景中直接使用

三种模式的概括为：

简单工厂：

一个抽象产品类（可以是：接口，抽象类，普通类），可以派生出多个具体产品类

单独一个具体的工厂类

每个具体工厂类只能创建一个具体产品类的实例

工厂模式：

一个抽象产品类（可以是：接口，抽象类，普通类），可以派生出多个具体产品类

一个抽象工厂类（可以是：接口，抽象类），可以派生出多个具体工厂类

每个具体工厂类只能创建一个具体产品类的实例

抽象工厂：

多个抽象产品类（可以是：接口，抽象类，普通类），每个抽象产品类可以派生出多个具体产品类

一个抽象工厂类（可以是：接口，抽象类），可以派生出多个具体工厂类

每个具体工厂类可以创建多个具体产品类的实例

三个模式之间的区别：

简单工厂模式只有一个抽象产品类，只有一个具体的工厂类

工厂方法模式只有一个抽象产品类，而抽象工厂模式有多个抽象产品类

工厂方法模式的具体工厂类只能创建一个具体产品类的实例，而抽象工厂模式可以创建多个具体产品类的实例

工厂模式与反射的结合使用

可以利用反射的特性来实现工厂模式的生产过程，结合Laravel-admin进行举例

先看下以下的代码，需求背景：需要根据角色不同显示不同的权限按钮

<?php
class TaskController extends BaseController
{
    use HasResourceActions;
    /**
     * Make a grid builder.
     *
     * @return Grid
     */
    protected function grid()
    {
            //Grid Columns...
            if (Admin::user()->inRoles([AdminUserModel::getAssignmentRole()])) {
                $grid->disableBatchActions();
                $grid->disableEditButton();
                $grid->disableCreateButton();
                $grid->disableDeleteButton();
            } elseif (Admin::user()->inRoles([AdminUserModel::getEvaluatorRole()])) {
                $grid->disableBatchActions();
                $grid->disableEditButton();
                $grid->disableCreateButton();
                $grid->disableDeleteButton();
                $grid->actions(function (Grid\Displayers\Actions $actions) {
                    $actions->append(new ConfirmCloseTaskAction());
                });
            } else {
                $grid->disableCreateButton();
                $grid->disableDeleteButton();
                $grid->disableEditButton();
                $grid->disableBatchActions();
                $grid->disableViewButton();
                $grid->disableActions();
            }
    }
}

以上的代码很明显一看就显得很臃肿。且随着业务的增加【即Controller的增加】以及角色的增加，需要写更多重复的判断以及重复的代码

解决思路：

不同的角色需要拥有的不同的权限，每个角色都可以用一个固定的方法来设置权限，这个固定的方法可以为不同的角色设置权限。这些条件刚好满足工厂模式的使用场景：即：

抽象出一个产品类来派生出多个角色的权限产品类

抽象出一个工厂类来派生出多个具体的工厂类，这些工厂类表现为对应要使用权限按钮的场景

每个具体工厂【使用权限按钮的场景】可以创建多个具体产品类【即实例化多个角色的权限产品】

代码如下【在下面的代码中，将使用反射来代替工厂的生产】

1) 抽象出一个产品类来派生出多个角色的权限产品类

<?php
namespace App\GridActionFactory;
use Dcat\Admin\Grid;
/**
 * 工厂接口
 */
interface GridActionInterface
{
    //业务员角色的权限
    function salesmanAction(Grid $grid);
    //分配员角色的权限
    function assignmentAction(Grid $grid);
    //财务角色的权限
    function financeAction(Grid $grid);
    //....其他角色的权限
}

2,3) 2,3两个步骤包含在一起。抽象出一个工厂类来派生出多个具体的工厂类，这些工厂类表现为对应要使用权限按钮的场景。其中，setRoleAction方法使用反射来直接生产，也就是替代了每个具体工厂类创建实例的过程

<?php
namespace App\GridActionFactory;
use Dcat\Admin\Admin;
use Dcat\Admin\Grid;
/**
 * 设置Action权限抽象类
 */
abstract class GridActionAbstract
{
    //
    abstract public static function setAction(Grid $grid, string $role);
    /**
     * 过滤角色
     *
     * @param string $role
     * @return bool
     */
    protected static function isInRoles(string $role): bool
    {
        return Admin::user()->inRoles([$role]);
    }
    /**
     * 调用对应的方法
     * [该方法其实就是工厂模式中的工厂，专门来生产的]
     * [多个工厂对应的就是各个需要用到Action权限的Controller控制器]
     * [每个Controller控制器来生产自己的Action权限]
     * [这个生产是通过反射来实现]
     *
     * @param Grid $grid
     * @param string $role
     * @param string $class
     * @throws \ReflectionException
     */
    protected static function setRoleAction(Grid $grid, string $role, string $class)
    {
        $r = new \ReflectionClass($class);
        $methodName = $role . &#39;Action&#39;;
        if (!$r->hasMethod($methodName))
            throw new \Exception(&#39;Method Not Found [ method : &#39; . $methodName . &#39; ] &#39;);
        $method = $r->getMethod($methodName);
        $method->invoke($r->newInstance(), $grid);
    }
}

根据以上的反射来实现实例化的过程，上面的TaskController的权限可以简化成下面的代码：

<?php
namespace App\GridActionFactory;
use Dcat\Admin\Grid;
class TaskAction extends GridActionAbstract implements GridActionInterface
{
    /**
     * @param Grid $grid
     * @param string $role
     * @throws \ReflectionException
     */
    public static function setAction(Grid $grid, string $role)
    {
        if (!parent::isInRoles($role)) return;
        //通过调用父类的setRoleAction直接实现生产的过程
        parent::setRoleAction($grid, $role, self::class);
    }
    //在TaskController下有需要使用权限按钮的角色
    //分配员角色
    public function assignmentAction(Grid $grid)
    {
        //权限按钮
        $grid->showActions();
        $grid->showViewButton();
    }
    //在TaskController下有需要使用权限按钮的角色
    //财务角色
    public function financeAction(Grid $grid)
    {
        $grid->showActions();
        $grid->showViewButton();
    }
    //在TaskController下有需要使用权限按钮的角色
    //业务员角色
    public function salesmanAction(Grid $grid)
    {
    }
    //....其他角色
}

经过使用设计模式封装后，上面TaskController中控制权限的代码直接优化成如下：【优雅了不少~】

<?php
class TaskController extends BaseController
{
    use HasResourceActions;
    /**
     * Make a grid builder.
     *
     * @return Grid
     */
    protected function grid()
    {
            //Grid Columns...
            //财务角色按钮
              TaskAction::setAction($grid, AdminUserModel::getFinanceRole());
            //分配员角色按钮
              TaskAction::setAction($grid, AdminUserModel::getAssignmentRole());
            //...其他角色按钮
            /*
            if (Admin::user()->inRoles([AdminUserModel::getAssignmentRole()])) {
                $grid->disableBatchActions();
                $grid->disableEditButton();
                $grid->disableCreateButton();
                $grid->disableDeleteButton();
            } elseif (Admin::user()->inRoles([AdminUserModel::getEvaluatorRole()])) {
                $grid->disableBatchActions();
                $grid->disableEditButton();
                $grid->disableCreateButton();
                $grid->disableDeleteButton();
                $grid->actions(function (Grid\Displayers\Actions $actions) {
                    $actions->append(new ConfirmCloseTaskAction());
                });
            } else {
                $grid->disableCreateButton();
                $grid->disableDeleteButton();
                $grid->disableEditButton();
                $grid->disableBatchActions();
                $grid->disableViewButton();
                $grid->disableActions();
            }
            */
    }
}

总结：

设计模式以及反射通常在写框架的时候用的比较多。但是在项目中，适当的使用设计模式以及反射，能够让代码更加健壮以及可扩展，也很优雅～

原文地址：http://janrs.com/?p=833

위 내용은 PHP 고급 기능: 리플렉션과 팩토리 디자인 패턴을 함께 사용하는 방법의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!