使用Zend Expressive快速进行企业应用开发

朱雀 2022-12-03 09:08 199阅读 0赞

If you’ve ever done a Zend Framework quick start, you’ve probably never worked in Zend Framework. The quick start has historically been anything but quick, and it’s easy to lose interest and move on to the next thing.

如果您曾经做过Zend Framework快速入门，那么您可能从未在Zend Framework中工作过。 从历史上看，快速的开始几乎没有什么快的，而且很容易失去兴趣并继续下一步。

[Zend Expressive][] greatly improves upon this experience with the wizard driven `composer create-project` command. However, it can still be daunting to set up because there are so many choices to make up front. This tutorial guides you through my recommended setup for rapid development which will yield an enterprise level, robust application.

[Zend Expressive][]通过向导驱动的`composer create-project`命令大大改善了这种体验。 但是，设置仍然是艰巨的，因为有很多选择要准备。 本教程将指导您完成我建议的快速开发设置，这将产生一个企业级的，强大的应用程序。

![Zend Framework logo][]

This tutorial is not about setting up your environment, so I am going to assume that you have a good working environment like [Homestead Improved][].

本教程不是关于设置您的环境的，因此我将假设您拥有一个良好的工作环境，例如[Homestead Improvement][Homestead Improved] 。

*If you’re not familiar with [Vagrant][] or isolated virtual environments, we’ve got an amazing book to guide you through the concepts available in our shop [here][].*

*如果你不熟悉[流浪][Vagrant]或相互隔离的虚拟环境中，我们已经得到了一个惊人的书来指导你通过在我们的商店提供的概念[在这里][here] 。*

## 项目设置 **(**Project Setup**)** ##

Start your project by running the following command your the folder where you keep your projects (`Code` on [Homestead Improved][]):

通过在保存项目的文件夹中运行以下命令来启动项目( [Homestead改进][Homestead Improved] `Code` )：

composer create-project zendframework/zend-expressive-skeleton expressive

You will be prompted to make a few decisions along the way. Use these answers:

系统会提示您做出一些决定。 使用以下答案：

*  What type of installation would you like?
    
    您想要哪种类型的安装？
    
     *  Modular
        
        模块化的
 *  Which container do you want to use for dependency injection?
    
    您要使用哪个容器进行依赖项注入？
    
     *  Zend ServiceManager
        
        Zend ServiceManager
 *  Which router do you want to use?
    
    您要使用哪个路由器？
    
     *  Zend Router
        
        Zend路由器
 *  Which template engine do you want to use?
    
    您要使用哪个模板引擎？
    
     *  Twig
        
        枝条
 *  Which error handler do you want to use during development?
    
    您要在开发期间使用哪个错误处理程序？
    
     *  Whoops
        
        哎呀
 *  Please select which config file you wish to inject ‘Zend\\Validator\\ConfigProvider’ into?
    
    请选择要将“ Zend \\ Validator \\ ConfigProvider”注入哪个配置文件？
    
     *  config/config.php
        
        config / config.php
 *  Remember this option for other packages of the same type?
    
    还记得其他相同类型的软件包的此选项吗？
    
     *  y
        
        ÿ

Then, run these commands:

然后，运行以下命令：

cd expressive &&
    git init &&
    git config color.ui true &&
    git add . &&
    git commit -m "Initial commit" &&
    chmod -R +w data;

This initializes a repository in the newly created folder and makes the `data` folder writable.

这将初始化新创建的文件夹中的存储库，并使`data`文件夹可写。

Then, start up a php server for testing with

然后，启动php服务器进行测试

composer serve

… and browse to http://localhost:8080 or just visit the VM’s IP or virtual host if you’re using [Homestead Improved][].

…并浏览到http：// localhost：8080，或者，如果您正在使用[Homestead Improvement，][Homestead Improved]则只需访问VM的IP或虚拟主机。

![Zend Expressive Homepage][]

## 了解表现力 **(**Understanding Expressive**)** ##

Expressive’s folder structure looks like this:

Expressive的文件夹结构如下所示：

bin/
    config/
    data/
      cache/
    public/
      index.php
    src/
      App
    test/
      AppTest
    vendor/

Most of it is self explanatory. Expressive provides an `App` module by default. You can put all your code in here, or build separate modules as you build larger features.

大部分是自我解释。 Expressive默认情况下提供一个`App`模块。 您可以将所有代码放在此处，也可以在构建较大的功能时构建单独的模块。

Expressive comes with some handy commands:

Expressive附带一些方便的命令：

*  `./vendor/bin/expressive` – Create, register, and deregister modules. Create a middleware class, etc.
    
    `./vendor/bin/expressive` –创建，注册和注销模块。 创建一个中间件类，等等。
 *  `composer serve` – Alias to run a php-fpm server
    
    `composer serve` –别名以运行php-fpm服务器
 *  `composer cs-check` – Perform a coding standards check on your code.
    
    `composer cs-check` –对您的代码执行编码标准检查。
 *  `composer cs-fix` – Perform a coding standards check on your code and fix issues, where possible.
    
    `composer cs-fix` –对您的代码执行编码标准检查，并在可能的情况下解决问题。
 *  `composer test` – Run PHPUnit tests on your code.
    
    `composer test` –在您的代码上运行PHPUnit测试。
 *  `composer check` – Alias for running `cs-check`, then test.
    
    `composer check` –运行`cs-check`别名，然后进行测试。

Expressive also comes with the Whoops error handler. To test it, open `src/App/src/Action/HomePageAction.php` and type `echo $badVar` in the `process()` method, then refresh the page. You will see the Whoops error handler.

Expressive还附带了Whoops错误处理程序。 要对其进行测试，请打开`src/App/src/Action/HomePageAction.php` ，然后在`process()`方法中键入`echo $badVar` ，然后刷新页面。 您将看到Whoops错误处理程序。

![Whoops Error Handler][]

## 必要的改进 **(**Necessary Improvements**)** ##

### 基于反射的抽象工厂 **(**Reflection Based Abstract Factory**)** ###

Zend Expressive uses the Zend ServiceManager for Dependency Injection. In the default setup, you need to add configuration and potentially create a factory class for every single class you write. This feels burdensome after doing this about twice.

Zend Expressive使用Zend ServiceManager进行依赖注入。 在默认设置中，您需要添加配置并可能为编写的每个单个类创建一个工厂类。 这样做大约两次后，这感觉很沉重。

To avoid this, we will enable the reflection based abstract factory provided with Zend Expressive.

为避免这种情况，我们将启用Zend Expressive提供的基于反射的抽象工厂。

Add this to `config/autoload/dependencies.global.php` within the `dependencies` array:

加入这`config/autoload/dependencies.global.php`的内`dependencies`数组：

'abstract_factories' => [
        \Zend\ServiceManager\AbstractFactory\ReflectionBasedAbstractFactory::class
    ],

Now, whenever you are working in a class and need a dependency, just add it to your constructor. The reflection abstract factory will see what your class needs and automatically grab it from the service container. You only need to create factories now in exceptional cases where you need something different from the default service provided by the service container.

现在，无论何时在类中工作并需要依赖项，只需将其添加到构造函数中即可。 反射抽象工厂将看到您的类需要什么，并自动从服务容器中获取它。 仅在例外情况下，您现在需要创建工厂，在这种情况下，您需要与服务容器提供的默认服务有所不同的东西。

If you’re concerned about speed; In production, we can have a process that generates factories for your classes that were being handled by the reflection factory with `vendor/bin/generate-factory-for-class`.

如果您担心速度； 在生产中，我们可以有一个过程为您的类生成工厂，这些工厂由反射工厂使用`vendor/bin/generate-factory-for-class` 。

### 教义 **(**Doctrine**)** ###

Zend Expressive provides no database tooling or ORM. I’ve chosen Doctrine as my ORM of choice after much research and building a few ORMs of my own. It just works.

Zend Expressive不提供数据库工具或ORM。 经过大量研究并建立了一些自己的ORM之后，我选择了Doctrine作为我的ORM。 它只是工作。

Install Doctrine and Symfony Yaml via Composer:

通过Composer安装Doctrine和Symfony Yaml：

composer require dasprid/container-interop-doctrine symfony/yaml

Create a file `config/cli-config.php` with these contents:

使用以下内容创建文件`config/cli-config.php` ：

<?php
    
    use Doctrine\ORM\Tools\Console\ConsoleRunner;
    
    chdir(dirname(__DIR__));
    require 'vendor/autoload.php';
    
    /**
     * Self-called anonymous function that creates its own scope and keep the global namespace clean.
     */
    return call_user_func(function () {
        /** @var \Interop\Container\ContainerInterface \$container */
        $container = require 'config/container.php';
    
        $entityManager = $container->get(\Doctrine\ORM\EntityManager::class);
        return ConsoleRunner::createHelperSet($entityManager);
    });

Replace the contents of `config/autoload/dependencies.global.php` with the following:

将`config/autoload/dependencies.global.php`的内容替换为以下内容：

<?php
    
    use Zend\Expressive\Application;
    use Zend\Expressive\Container;
    use Zend\Expressive\Delegate;
    use Zend\Expressive\Helper;
    use Zend\Expressive\Middleware;
    
    return [
        // Provides application-wide services.
        // We recommend using fully-qualified class names whenever possible as
        // service names.
        'dependencies' => [
            'abstract_factories' => [
                \Zend\ServiceManager\AbstractFactory\ReflectionBasedAbstractFactory::class
            ],
            // Use 'aliases' to alias a service name to another service. The
            // key is the alias name, the value is the service to which it points.
            'aliases' => [
                'Zend\Expressive\Delegate\DefaultDelegate' => Delegate\NotFoundDelegate::class,
            ],
            // Use 'invokables' for constructor-less services, or services that do
            // not require arguments to the constructor. Map a service name to the
            // class name.
            'invokables' => [
                // Fully\Qualified\InterfaceName::class => Fully\Qualified\ClassName::class,
                \Doctrine\DBAL\Logging\DebugStack::class => \Doctrine\DBAL\Logging\DebugStack::class,
                Helper\ServerUrlHelper::class => Helper\ServerUrlHelper::class,
                Middleware\ImplicitHeadMiddleware::class => Middleware\ImplicitHeadMiddleware::class,
                Middleware\ImplicitOptionsMiddleware::class => Middleware\ImplicitOptionsMiddleware::class,
            ],
            // Use 'factories' for services provided by callbacks/factory classes.
            'factories'  => [
                Application::class                => Container\ApplicationFactory::class,
                Delegate\NotFoundDelegate::class  => Container\NotFoundDelegateFactory::class,
                \Doctrine\ORM\EntityManager::class  => \ContainerInteropDoctrine\EntityManagerFactory::class,
                Helper\ServerUrlMiddleware::class => Helper\ServerUrlMiddlewareFactory::class,
                Helper\UrlHelper::class           => Helper\UrlHelperFactory::class,
                Helper\UrlHelperMiddleware::class => Helper\UrlHelperMiddlewareFactory::class,
                Zend\Stratigility\Middleware\ErrorHandler::class => Container\ErrorHandlerFactory::class,
                Middleware\ErrorResponseGenerator::class         => Container\ErrorResponseGeneratorFactory::class,
                Middleware\NotFoundHandler::class                => Container\NotFoundHandlerFactory::class,
            ],
        ],
    ];

Create this file to set up the Doctrine driver `config/autoload/doctrine.global.php`.

创建此文件以设置Doctrine驱动程序`config/autoload/doctrine.global.php` 。

<?php
    
    return [
        'doctrine' => [
            'driver' => [
                'orm_default' => [
                    'class' => \Doctrine\Common\Persistence\Mapping\Driver\MappingDriverChain::class,
                    'drivers' => [],
                ],
            ],
        ],
    ];

Create this file for your database credentials `config/autoload/doctrine.local.php`.

为您的数据库凭据`config/autoload/doctrine.local.php`创建此文件。

<?php
    return [
        'doctrine' => [
            'connection' => [
                'orm_default' => [
                    'params' => [
                        'url' => 'mysql://root:password1@localhost/expressive',
                    ],
                ],
            ],
        ],
    ];

Test by running `./vendor/bin/doctrine`. You should see the help prompt.

通过运行`./vendor/bin/doctrine`测试。 您应该看到帮助提示。

### 古尔普 **(**Gulp**)** ###

Gulp is my current tool of choice for frontend workflow. There are many, many frontend build tools available. Look if you like, but you may get lost in the sea of shiny new JavaScript libraries out there. I don’t want to get too involved here as this is more a PHP tutorial than JS, but I do want to show how gulp should be configured to work with Zend Expressive.

Gulp是我当前选择的前端工作流工具。 有很多可用的前端构建工具。 看看是否喜欢，但您可能会迷失在闪亮的新JavaScript库的海洋中。 我不想在这里参与过多，因为这比JS更像是PHP教程，但我想展示如何配置gulp以与Zend Expressive一起使用。

Create a `package.json` file with these contents:

创建具有以下内容的`package.json`文件：

{
      "name": "expressive",
      "version": "1.0.0",
      "description": "",
      "main": "index.js",
      "devDependencies": {
        "del": "^3.0.0",
        "gulp": "github:gulpjs/gulp#4.0",
        "gulp-cached": "^1.1.1",
        "gulp-imagemin": "^3.3.0",
        "gulp-minify-css": "^1.2.4",
        "gulp-rename": "^1.2.2",
        "gulp-sass": "^3.1.0",
        "gulp-uglify": "^2.1.2",
        "gulp-usemin": "^0.3.28"
      },
      "scripts": {
        "test": "echo \"Error: no test specified\" && exit 1"
      },
      "author": "",
      "license": "ISC"
    }

Run `npm install`. You may want to run `npm update` also, if you are reading this tutorial a while after it was written.

运行`npm install` 。 如果在编写本教程后的一段时间内正在阅读本教程，则可能还需要运行`npm update` 。

Then, create a `gulpfile.js` with these contents:

然后，使用以下内容创建一个`gulpfile.js` ：

'use strict';
    
    var cache = require('gulp-cached');
    var del = require('del');
    var gulp = require('gulp');
    var imagemin = require('gulp-imagemin');
    var minifyCss = require('gulp-minify-css');
    var path = require('path');
    var rename = require('gulp-rename');
    var sass = require('gulp-sass');
    var uglify = require('gulp-uglify');
    
    // CSS Processing
    gulp.task('clean-css', function() {
        return del('public/css', { force: true });
    });
    
    gulp.task('compile-sass', function() {
        return gulp.src('src/*/public/sass/**/*.scss', { base: './' })
            .pipe(cache('compile-sass'))
            .pipe(sass().on('error', sass.logError))
            .pipe(rename(function (path) {
                path.dirname = path.dirname.replace(/^src\/([^\/]+\/)public\/sass/, '$1');
            }))
            .pipe(gulp.dest('public/css/'));
    });
    
    gulp.task('copy-css', function() {
        return gulp.src('src/*/public/css/**/*.css', { base: './' })
            .pipe(cache('copy-css'))
            .pipe(rename(function (path) {
                path.dirname = path.dirname.replace(/^src\/([^\/]+\/)public\/css/, '$1');
            }))
            .pipe(gulp.dest('public/css/'));
    });
    
    gulp.task('minify-css', function() {
        return gulp.src(['public/css/**/*.css', '!public/css/**/*.min.css'], { base: './' })
            .pipe(cache('minify-css'))
            .pipe(minifyCss())
            .pipe(rename(function (path) {
                path.dirname = path.dirname.replace(/^public\/css/, '');
            }))
            .pipe(rename({ extname: '.min.css' }))
            .pipe(gulp.dest('public/css'))
        ;
    });
    gulp.task('process-css', gulp.series(['compile-sass', 'copy-css'], 'minify-css'));
    
    // JS Processing
    gulp.task('clean-js', function() {
        return del('public/js', { force: true });
    });
    
    gulp.task('copy-js', function() {
        return gulp.src('src/*/public/js/**/*.js', { base: './' })
            .pipe(cache('copy-js'))
            .pipe(rename(function (path) {
                path.dirname = path.dirname.replace(/^src\/([^\/]+\/)public\/js/, '$1');
            }))
            .pipe(gulp.dest('public/js/'));
    });
    
    gulp.task('minify-js', function() {
        return gulp.src(['public/js/**/*.js', '!public/js/**/*.min.js'], { base: './' })
            .pipe(cache('minify-js'))
            .pipe(uglify())
            .pipe(rename(function (path) {
                path.dirname = path.dirname.replace(/^public\/js/, '');
            }))
            .pipe(rename({ extname: '.min.js' }))
            .pipe(gulp.dest('public/js'))
        ;
    });
    gulp.task('process-js', gulp.series('copy-js', 'minify-js'));
    
    // Image processing
    gulp.task('clean-img', function() {
        return del('public/img', { force: true });
    });
    
    gulp.task('process-img', function() {
        return gulp.src('src/*/public/img/**/*.{gif,jpg,jpeg,png,svg}', { base: './' })
            .pipe(cache('process-img'))
            .pipe(imagemin())
            .pipe(rename(function (path) {
                path.dirname = path.dirname.replace(/^src\/([^\/]+\/)public\/img/, '$1');
            }))
            .pipe(gulp.dest('public/img'));
    });
    
    
    // Top level commands
    gulp.task('default', gulp.parallel('process-js', 'process-css', 'process-img'));
    gulp.task('clean', gulp.parallel('clean-js', 'clean-css', 'clean-img'));
    
    gulp.task('watch', function() {
        gulp.watch(['src/*/public/sass/**/*.scss','src/*/public/css/**/*.css'], gulp.series('process-css'));
        gulp.watch('src/*/public/js/**/*.js', gulp.series('process-js'));
        gulp.watch('src/*/public/img/**/*.{gif,jpg,jpeg,png,svg}', gulp.series('process-img'));
    });

Run `gulp` and ensure that it runs without errors.

运行`gulp`并确保其运行无误。

Now you can run `gulp` to compile sass, minify css, minify js, and optimize images across all of your modules. You can follow that up with `gulp watch` to have these all automatically be processed as they are changed. The cache gulp module ensures that only changed files are ever processed so this should process changes very quickly.

现在，您可以运行`gulp`来编译sass，最小化css，最小化js并优化所有模块中的图像。 您可以使用`gulp watch`进行后续操作，以在更改它们时自动对其进行处理。 缓存gulp模块可确保仅处理已更改的文件，因此该处理将非常Swift地进行。

Test this by creating one of these files:

通过创建以下文件之一进行测试：

*  `src/App/public/sass/sasstest.scss`
    
    `src/App/public/sass/sasstest.scss`
 *  `src/App/public/css/test.css`
    
    `src/App/public/css/test.css`
 *  `src/App/public/js/test.js`
    
    `src/App/public/js/test.js`
 *  `src/App/public/img/test.jpg`
    
    `src/App/public/img/test.jpg`

And then run `gulp`. Look for the files in `public/css/App`, `public/js/App`, or `public/img/App`.

然后运行`gulp` 。 在`public/css/App` ， `public/js/App`或`public/img/App`查找文件。

Run `gulp watch`, change the source files, and then watch for the files in public to update.

运行`gulp watch` ，更改源文件，然后监视公共文件是否更新。

## 控制台命令 **(**Console Commands**)** ##

And last, but definitely not least, you will need a way to run console commands. We will use [Symfony’s Console][Symfony_s Console] for this,which already ships with Zend Expressive so we do not need to manually require it.

最后，但同样重要的是，您将需要一种运行控制台命令的方法。 我们将为此使用[Zenf][Symfony_s Console] Expressive随附的[Symfony控制台][Symfony_s Console] ，因此我们不需要手动要求它。

Create a file called `bin/console`:

创建一个名为`bin/console`的文件：

#!/usr/bin/env php
    <?php
    
    chdir(dirname(__DIR__));
    require 'vendor/autoload.php';
    
    /**
     * Self-called anonymous function that creates its own scope and keep the global namespace clean.
     */
    call_user_func(function () {
        /** @var \Interop\Container\ContainerInterface $container */
        $container = require 'config/container.php';
    
        $app = new \Symfony\Component\Console\Application('Application console');
    
        $commands = $container->get('config')['console']['commands'];
        foreach ($commands as $command) {
            $app->add($container->get($command));
        }
    
        $app->run();
    });

Then, you can create Symfony commands and register them via `config/autoload/console.global.php` or from within your modules like this:

然后，您可以创建Symfony命令并通过`config/autoload/console.global.php`或从模块中注册它们，如下所示：

<?php
    
    return [
        'console' => [
            'commands' => [
                \App\Command\HelloWorldCommand::class,
            ],
        ],
    ];

Add any dependencies your console commands need to the constructor just like any other class in Expressive. Make sure to call `parent::__construct()` in your constructor or your command won’t work.

就像Expressive中的任何其他类一样，将控制台命令需要的所有依赖项添加到构造函数中。 确保在`parent::__construct()`调用`parent::__construct()` ，否则您的命令将无效。

Here is an example command with a dependency:

这是带有依赖项的示例命令：

<?php
    
    namespace App\Command;
    
    use Doctrine\ORM\EntityManager;
    use Monolog\Logger;
    use Symfony\Component\Console\Command\Command;
    use Symfony\Component\Console\Input\InputArgument;
    use Symfony\Component\Console\Input\InputInterface;
    use Symfony\Component\Console\Input\InputOption;
    use Symfony\Component\Console\Output\OutputInterface;
    
    class HellowWorld extends Command
    {
        /**
         * @var EntityManager
         */
        private $entityManager;
    
        public function __construct(EntityManager $entityManager, $name = null)
        {
            $this->entityManager = $entityManager;
            parent::__construct($name);
        }
    
        /**
         * Configures the command
         */
        protected function configure()
        {
            $this->setName('hello')
                ->setDescription('Says hello')
            ;
        }
    
        /**
         * Executes the current command
         */
        protected function execute(InputInterface $input, OutputInterface $output)
        {
            $output->writeln("Hello World!");
    
            // Do something with the entityManager
            $this->entityManager->find('Blog\Entity\BlogEntity');
        }
    }

To run your command:

运行命令：

php bin/console hello

We can go a little bit further and add a logger. This is useful for passing to service models that encapsulate a lot of logic and need debug logging throughout.

我们可以再进一步添加一个记录器。 这对于传递给封装了许多逻辑并需要调试日志记录的服务模型很有用。

Run this command:

运行以下命令：

composer require monolog/monolog symfony/monolog-bridge;

Then, add this to your execute method in your command:

然后，将其添加到命令中的execute方法中：

protected function execute(InputInterface $input, OutputInterface $output)
    {
        $logger = new \Monolog\Logger('collect-product-data');
        $logger->pushHandler(new \Symfony\Bridge\Monolog\Handler\ConsoleHandler($output));
        $logger->debug('Log something);
    }

## 结论 **(**Conclusion**)** ##

You are now ready to begin building an enterprise level application with all of the tools you could ever want at your fingertips.

现在，您就可以开始使用触手可及的所有工具来构建企业级应用程序。

In the next post we’ll start learning how to build modules on this foundation, starting off with a blog module.

在下一篇文章中，我们将从博客模块开始学习如何在此基础上构建模块。

> 翻译自: [https://www.sitepoint.com/rapid-enterprise-app-development-zend-expressive/][https_www.sitepoint.com_rapid-enterprise-app-development-zend-expressive]

[Zend Expressive]: https://docs.zendframework.com/zend-expressive/
[Zend Framework logo]: /images/20221123/35f0dd95d34e48a68ec0203d07b2b8e1.png
[Homestead Improved]: https://www.sitepoint.com/quick-tip-get-homestead-vagrant-vm-running/
[Vagrant]: https://www.sitepoint.com/re-introducing-vagrant-right-way-start-php/
[here]: http://bit.ly/phpenv-sp
[Zend Expressive Homepage]: /images/20221123/ab564069bb654303a5f78ec6c59f1d9a.png
[Whoops Error Handler]: /images/20221123/6eee56d022ca4f62aca9a228cefcc10f.png
[Symfony_s Console]: https://www.sitepoint.com/re-introducing-symfony-console-cli-php-uninitiated/
[https_www.sitepoint.com_rapid-enterprise-app-development-zend-expressive]: https://www.sitepoint.com/rapid-enterprise-app-development-zend-expressive/