structure-applications.md 27.7 KB
Newer Older
1 2 3 4
Aplicações
==========

Aplicações são objetos que regem a estrutura e ciclo de vida gerais de
5
aplicações em Yii. Cada aplicação contém um único objeto Application que é criado no
6 7 8
[script de entrada](structure-entry-scripts.md) e que pode ser acessado
globalmente pela expressão `\Yii::$app`.

9
> Informação: Dependendo do contexto, quando dizemos "uma aplicação", pode significar
10 11 12
  tanto um objeto Application quanto um sistema.

Existem dois tipos de aplicações: [[yii\web\Application|aplicações Web]] e
13
[[yii\console\Application|aplicações console]]. Como o próprio nome indica,
14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68
o primeiro manipula requisições Web enquanto o segundo trata requisições de
comandos do console.


## Configurações da Aplicação <a name="application-configurations"></a>

Quando um [script de entrada](structure-entry-scripts.md) cria uma aplicação, ele
carregará uma [configuração](concept-configurations.md) e a aplicará à aplicação,
da seguinte forma:

```php
require(__DIR__ . '/../vendor/autoload.php');
require(__DIR__ . '/../vendor/yiisoft/yii2/Yii.php');

// carrega a configuração da aplicação
$config = require(__DIR__ . '/../config/web.php');

// instancia e configura a aplicação
(new yii\web\Application($config))->run();
```

Tal como [configurações](concept-configurations.md) normais, as configurações da
aplicação especificam como inicializar as propriedades de objetos Application.
Uma vez que geralmente são muito complexas, elas normalmente são mantidas em 
[arquivos de configuração](concept-configurations.md#configuration-files),
como o arquivo `web.php` no exemplo acima.


## Propriedades da Aplicação <a name="application-properties"></a>

Existem muitas propriedades importantes da aplicação que deveriam ser configuradas.
Essas propriedades tipicamente descrevem o ambiente em que as aplicaçõe estão
rodando. Por exemplo, as aplicações precisam saber como carregar os
[controllers](structure-controllers.md), onde armazenar os arquivos temporários,
etc. A seguir resumiremos essas propriedades.


### Propriedades Obrigatórias <a name="required-properties"></a>

Em qualquer aplicação, você deve pelo menos configurar duas propriedades:
[[yii\base\Application::id|id]] e [[yii\base\Application::basePath|basePath]].


#### [[yii\base\Application::id|id]] <a name="id"></a>

A propriedade [[yii\base\Application::id|id]] especifica um ID único que diferencia
uma aplicação das outras. É usado principalmente programaticamente. Apesar de não
ser obrigatório, para melhor interoperabilidade recomenda-se que você só use
caracteres alfanuméricos ao especificar um ID de aplicação.


#### [[yii\base\Application::basePath|basePath]] <a name="basePath"></a>

A propriedade [[yii\base\Application::basePath|basePath]] especifica o diretório
raiz de um sistema. É o diretório que contém todo o código fonte protegido de um
69
sistema. Sob este diretório, você normalmente verá subdiretórios tais como
70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86
`models`, `views`, `controllers`, que contém o código fonte correspondente ao
padrão MVC.

Você pode configurar a propriedade [[yii\base\Application::basePath|basePath]]
usando um [alias de caminho](concept-aliases.md). Em ambas as formas, o diretório
correspondente precisa existir, doutra forma será lançada uma exceção. O caminho
será normnalizado chamando-se a função `realpath()`.

A propriedade [[yii\base\Application::basePath|basePath]] frequentemente é
usada para derivar outros caminhos importantes (por exemplo, o diretório de
runtime). Por esse motivo, um alias de caminho `@app` é pré-definido para
representar esse caminho. Assim os caminhos derivados podem ser formados usando
esse alias (por exemplo, `@app/runtime` para referenciar o diretório runtime).


### Propriedades Importantes <a name="important-properties"></a>

87 88
As propriedades descritas nesta subseção frequentemente precisam ser
configuradas porque elas variam em diferentes aplicações.
89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114


#### [[yii\base\Application::aliases|aliases]] <a name="aliases"></a>

Esta propriedade permite que você defina um conjunto de
[aliases](concept-aliases.md) em termos de um array. As chaves do array representam
os nomes de alias, e os valores são as definições correspondentes. Por exemplo,

```php
[
    'aliases' => [
        '@name1' => 'path/to/path1',
        '@name2' => 'path/to/path2',
    ],
]
```

Essa propriedade está disponível de modo que você possa definir aliases em termos
de configurações da aplicação ao invés de chamadas ao método [[Yii::setAlias()]].


#### [[yii\base\Application::bootstrap|bootstrap]] <a name="bootstrap"></a>

Esta é uma propriedade muito útil. Ela permite que você especifique um array de
componentes que devem ser executados durante o [[yii\base\Application::bootstrap()|processo de inicialização]]
da aplicação. Por exemplo, se você quer que um [módulo](structure-modules.md)
115
personalize as [regras de URL](runtime-routing.md), você pode listar seu
116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151
ID como um elemento nesta propriedade.

Cada componente listado nesta propriedade deve ser especificado em um dos
seguintes formatos:

- o ID de um componente de aplicação conforme especifcado via [components](#components).
- o ID de um módulo conforme especificado via [modules](#modules).
- o nome de uma classe.
- um array de configuração.
- uma função anônima que cria e retorna um componente.

Por exemplo,

```php
[
    'bootstrap' => [
        // o ID de uma aplicação ou de um módulo
        'demo',

        // um nome de classe
        'app\components\Profiler',

        // um array de configuração
        [
            'class' => 'app\components\Profiler',
            'level' => 3,
        ],

        // uma função anônima
        function () {
            return new app\components\Profiler();
        }
    ],
]
```

152
> Informação: Se o ID de um módulo é o mesmo que o ID de um componente da aplicação,
153 154 155
  o componente será usado durante o processo de inicialização. Se você quiser
  usar o módulo ao invés dele, você pode especificá-lo usando uma função anônima
  conforme a seguir:
Carsten Brandt committed
156
> ```php
157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183
[
    function () {
        return Yii::$app->getModule('user');
    },
]
```


Durante o processo de inicialização, cada componente será instanciado. Se a classe
do componente implementa [[yii\base\BootstrapInterface]], seu método [[yii\base\BootstrapInterface::bootstrap()|bootstrap()]]
também será chamado.

Outro exemplo prático está na configuração do [Modelo Básico de Aplicação](start-installation.md),
onde os módulos `debug` e `gii` estão configurados como componentes de inicialização
quando a aplicação está rodando no ambiente de desenvolvimento,

```php
if (YII_ENV_DEV) {
    // ajustes da configuração para o ambiente 'dev'
    $config['bootstrap'][] = 'debug';
    $config['modules']['debug'] = 'yii\debug\Module';

    $config['bootstrap'][] = 'gii';
    $config['modules']['gii'] = 'yii\gii\Module';
}
```

184
> Observação: Colocar componentes demais em `bootstrap` degradará o desempenho de sua
185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279
  aplicação, porque para cada requisição o mesmo conjunto de componentes precisará
  ser carregado. Desta forma, use os componentes de inicialização com juízo.


#### [[yii\web\Application::catchAll|catchAll]] <a name="catchAll"></a>

Essa propriedade só é suportada por [[yii\web\Application|aplicações Web]]. Ela
especifica uma [action de um controller](structure-controllers.md) que deve
manipular todas as requisições. Isso é geralmente usado quando a aplicação está
em modo de manutenção e precisa tratar todas as requisições através de uma
única action.

A configuração é um array, cujo primeiro elemento especifica a rota para a action.
O restante dos elementos do array (pares de chave-valor) especificam os parâmetros
que devem ser atrelados à action. Por exemplo,

```php
[
    'catchAll' => [
        'offline/notice',
        'param1' => 'value1',
        'param2' => 'value2',
    ],
]
```


#### [[yii\base\Application::components|components]] <a name="components"></a>

Essa é a propriedade mais importante. Ela permite que você registre uma lista
de componentes chamados [componentes de aplicação](structure-application-components.md)
que você pode usar em outros lugares. Por exemplo,

```php
[
    'components' => [
        'cache' => [
            'class' => 'yii\caching\FileCache',
        ],
        'user' => [
            'identityClass' => 'app\models\User',
            'enableAutoLogin' => true,
        ],
    ],
]
```

Cada componente da aplicação é especiifcado como um par de chave-valor em um array.
A chave representa o ID do componente, enquanto o valor representa o nome ou a
[configuração](concept-configurations.md) da classe do componente.

Você pode registrar qualquer componente com uma aplicação, e o componente depois
poderá ser acessado globalmente através da expressão `\Yii::$app->IDdoComponente`.

Por favor leia a seção [Componentes de Aplicação](structure-application-components.md)
para mais detalhes.


#### [[yii\base\Application::controllerMap|controllerMap]] <a name="controllerMap"></a>

Essa propriedade permite que você mapeie um ID de um controller a uma classe
de controller arbitrária. Por padrão, o Yii mapeia os IDs de controllers a classes
de controllers baseado em uma [convenção](#controllerNamespace) (por exemplo, o
ID `post` será mapeado para `app\controllers\PostController`). Ao configurar essa
propriedade, você pode quebrar a convenção de controllers em específico. No exemplo
a seguir, `account` será meapeado para `app\controllers\UserController`,
enquanto `article` será mapeado para `app\controllers\PostController`.

```php
[
    'controllerMap' => [
        [
            'account' => 'app\controllers\UserController',
            'article' => [
                'class' => 'app\controllers\PostController',
                'enableCsrfValidation' => false,
            ],
        ],
    ],
]
```

As chaves do array dessa propriedade representam os IDs dos controllers, enquanto
os valores do array representam o nome ou as [configurações](concept-configurations.md)
da classe do controller.


#### [[yii\base\Application::controllerNamespace|controllerNamespace]] <a name="controllerNamespace"></a>

Essa propriedade especifica o namespace padrão sob o qual as classes dos
controllers deverão ser localizadas. Seu valor padrão é `app\controllers`. Se um
ID de um controller for `post`, por convenção o nome da classe de controller
correspondente (sem namespace) seria `PostController`, e o nome da classe
completo e qualificado seria `app\controllers\PostController`.

280
As classes de controllers também podem estar localizadas em subdiretórios do
281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421
diretório correspondente ao namespace. Por exemplo, dado um ID de controller
`admin/post`, a classe completa e qualificada correspondente seria
`app\controllers\admin\PostController`.

É importante que as classes completas e qualificadas possam ser [carregadas automaticamente](concept-autoloading.md)
e que o namespace das suas classes de controller correspondam ao valor dessa
propriedade. Doutra forma, você receberia um erro "Página Não Encontrada" ao
acessar a aplicação.

Caso você queira quebrar a convenção conforme descrito acima, você pode configurar
a propriedade [controllerMap](#controllerMap).


#### [[yii\base\Application::language|language]] <a name="language"></a>

Essa propriedade especifica o idioma no qual a aplicação deve exibir o conteúdo
aos usuários finais. O valor padrão dessa propriedade é `en`, significando inglês.
Você deve configurar essa propriedade se a sua aplicação suportar múltiplos
idiomas.

O valor dessa propriedade determina vários aspectos da [internacionalização](tutorial-i18n.md),
incluindo tradução de mensagens, formato de datas, formato de números, etc. Por
exemplo, o widget [[yii\jui\DatePicker]] usará o valor dessa propriedade por
padrão para determinar em qual idioma o calendário deverá ser exibido e
como a data deve ser formatada.

Recomenda-se que você especifique um idioma em termos de um [código de idioma IETF](http://en.wikipedia.org/wiki/IETF_language_tag).
Por exenplo, `en` corresponde ao inglês, enquanto `en-US` significa inglês dos
Estados Unidos.

Mais detalhes sobre essa propriedade podem ser encontrados na seção
[Internacionalização](tutorial-i18n.md).


#### [[yii\base\Application::modules|modules]] <a name="modules"></a>

Essa propriedade especifica os [módulos](structure-modules.md) que uma aplicação
contém.

A propriedade recebe um array de classes de módulos ou [configurações](concept-configurations.md)
com as chaves do array sendo os IDs dos módulos. Por exemplo,

```php
[
    'modules' => [
        // um módulo "booking" especificado com a classe do módulo
        'booking' => 'app\modules\booking\BookingModule',

        // um módulo "comment" especificado com um array de configurações
        'comment' => [
            'class' => 'app\modules\comment\CommentModule',
            'db' => 'db',
        ],
    ],
]
```

Por favor consulte a seção [Módulos](structure-modules.md) para mais detalhes.


#### [[yii\base\Application::name|name]] <a name="name"></a>

Essa propriedade especifica o nome da aplicação que pode ser exibido aos
usuários finais. Ao contrário da propriedade [[yii\base\Application::id|id]] que
deveria receber um valor único, o valor desta propriedade serve principalmente
para fins de exibição e não precisa ser único.

Você nem sempre precisa configurar essa propriedade se nenhuma parte do código
a estiver usando.


#### [[yii\base\Application::params|params]] <a name="params"></a>

Essa propriedade especifica um array de parâmetros da aplicação que podem ser
acessados globalmente. Ao invés de usar números e strings fixos espalhados por
toda parte no seu código, é uma boa prática defini-los como parâmetros da
aplicação em um único lugar e usá-los nos lugares onde for necessário. Por
exemplo, você pode definir o tamanho de uma miniatura de imagem como um parâmetro
conforme a seguir:

```php
[
    'params' => [
        'thumbnail.size' => [128, 128],
    ],
]
```

Então no seu código onde você precisar usar o valor do tamanho, você pode
simplesmente usar o código conforme a seguir:

```php
$size = \Yii::$app->params['thumbnail.size'];
$width = \Yii::$app->params['thumbnail.size'][0];
```

Mais tarde, se você decidir mudar o tamanho da miniatura, você só precisa
modificá-lo na configuração da aplicação sem tocar em quaisquer códigos
dependentes.


#### [[yii\base\Application::sourceLanguage|sourceLanguage]] <a name="sourceLanguage"></a>

Essa propriedade especifica o idioma no qual o código da aplicação foi escrito.
O valor padrão é `'en-US'`, significando inglês dos Estados Unidos. Você deve
configurar essa propriedade se o conteúdo do texto no seu código não estiver
em inglês.

Conforme a propriedade [language](#language), você deve configurar essa propriedade
em termos de um [código de idioma IETF](http://en.wikipedia.org/wiki/IETF_language_tag).
Por exemplo, `en` corresponde ao inglês, enquanto `en-US` significa inglês dos
Estados Unidos.

Mais detalhes sobre essa propriedade podem ser encontrados na seção
[Internacionalização](tutorial-i18n.md).


#### [[yii\base\Application::timeZone|timeZone]] <a name="timeZone"></a>

Essa propriedade é disponibilizada como uma maneira alternativa de definir a
timezone do PHP em tempo de execução. Ao confiugrar essa propriedade, você está
essencialmente chamando a função
[date_default_timezone_set()](http://php.net/manual/en/function.date-default-timezone-set.php)
do PHP. Por exemplo,

```php
[
    'timeZone' => 'America/Los_Angeles',
]
```


#### [[yii\base\Application::version|version]] <a name="version"></a>

Essa propriedade especifica a versão da aplicação. Seu valor padrão é `'1.0'`.
Você nem sempre precisa configurar essa propriedade se nenhuma parte do seu código
a está usando.


### Propriedades Úteis <a name="useful-properties"></a>

422
As propriedades descritas nesta subseção não são comumente configuradas porque
423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510
seus valores padrão estipulam convenções comuns. No entanto, você pode ainda
configurá-las no caso de querer quebrar as convenções.


#### [[yii\base\Application::charset|charset]] <a name="charset"></a>

Essa propriedade especifica o charset que a aplicação usa. O valor padrão é
`'UTF-8'`, que deveria ser mantido como está para a maioria das aplicações, a
menos que você esteja trabalhando com sistemas legados que usam muitos dados que
não são unicode.


#### [[yii\base\Application::defaultRoute|defaultRoute]] <a name="defaultRoute"></a>

Essa propriedade especifica a [rota](runtime-routing.md) que uma aplicação deveria
usar quando uma requisição não especifica uma. A rota pode consistir de um ID de
módulo, ID de controller e/ou ID de action. Por exemplo, `help`, `post/create`,
`admin/post/create`. Se não for passado um ID de action, ele assumirá o valor
conforme especificado em [[yii\base\Controller::defaultAction]].

Para [[yii\web\Application|aplicações Web]], o valor padrão dessa propriedade é
`'site'`, o que significa que deve usar o controller `SiteController` e sua
action padrão. Como resultado disso, se você acessar a aplicação sem especificar
uma rota, ele exibirá o resultado de `app\controllers\SiteController::actionIndex()`.

Para [[yii\console\Application|aplicações do console]], o valor padrão é `'help'`,
o que significado que deve usar o comando do core
[[yii\console\controllers\HelpController::actionIndex()]]. Como resultado, se
você executar o comando `yii` sem fornecer quaisquer argumentos, ele exibirá a
informação de ajuda.


#### [[yii\base\Application::extensions|extensions]] <a name="extensions"></a>

Essa propriedade especifica a lista de [extensões](structure-extensions.md) que
estão instaladas e são usadas pela aplicação. Por padrão, ela receberá o array
retornado pelo arquivo `@vendor/yiisoft/extensions.php`. O arquivo `extensions.php`
é gerado e mantido automaticamente quando você usa o [Composer](http://getcomposer.org)
para instalar extensões. Então na maioria dos casos você não precisa configurar
essa propriedade.

No caso especial de você querer manter extensões manualmente, você pode configurar
essa propriedade da seguinte forma:

```php
[
    'extensions' => [
        [
            'name' => 'extension name',
            'version' => 'version number',
            'bootstrap' => 'BootstrapClassName',  // opcional, também pode ser um array de configuração
            'alias' => [  // opcional
                '@alias1' => 'to/path1',
                '@alias2' => 'to/path2',
            ],
        ],

        // ... mais extensões conforme acima ...

    ],
]
```

Como você pode ver, a propriedade recebe um array de especificações de extensões.
Cada extensão é especificada com um array composto pelos elementos `name` e
`version`. Se uma extensão precisa executar durante o processo de
[inicialização](runtime-bootstrapping.md), um elemento `bootstrap` pode ser
especificado com um nome de uma classe de inicialização ou um array de
[configuração](concept-configurations.md). Uma extensão também pode definir
alguns [aliases](concept-aliases.md).


#### [[yii\base\Application::layout|layout]] <a name="layout"></a>

Essa propriedade especifica o nome do layout padrão que deverá ser usado ao
renderizar uma [view](structure-views.md). O valor padrão é `'main'`, significando
que o arquivo de layout `main.php` sob o [caminho dos layouts](#layoutPath) deverá
ser usado. Se tanto o [caminho do layout](#layoutPath) quanto o
[caminho da view](#viewPath) estiverem recebendo os valores padrão, o arquivo de
layout padrão pode ser representado como o alias de caminho `@app/views/layouts/main.php`.

Você pode configurar esta propriedade como `false` se você quiser desativar o
layout por padrão, embora isso seja muito raro.


#### [[yii\base\Application::layoutPath|layoutPath]] <a name="layoutPath"></a>

Essa propriedade especifica o caminho onde os arquivos de layout devem ser
511
procurados. O valor padrão é o subdiretório `layouts` dentro do diretório do
512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547
[caminho das views](#viewPath). Se o [caminho das views](#viewPath) estiver
recebendo seu valor padrão, o caminho padrão dos layouts pode ser representado
como o alias de caminho `@app/views/layouts`.

Você pode configurá-la como um diretório ou um [alias](concept-aliases.md) de
caminho.


#### [[yii\base\Application::runtimePath|runtimePath]] <a name="runtimePath"></a>

Essa propriedade especifica o caminho onde os arquivos temporários, tais como
arquivos de log e de cache, podem ser gerados. O valor padrão é o diretório
representado pelo alias `@app/runtime`.

Você pode configurá-la como um diretório ou [alias](concept-aliases.md) de
caminho. Perceba que o caminho de runtime precisa ter permissão de escrita para
o processo que executa a aplicação. E o caminho deveria ser protegido para não
ser acessado pelos usuários finais, porque os arquivos temporários dentro dele
podem conter informações sensíveis.

Para simplificar o acesso a esse caminho, o Yii possui um alias de caminho
pré-definido chamado `@runtime` para ele.


#### [[yii\base\Application::viewPath|viewPath]] <a name="viewPath"></a>

Essa propriedade especifica o diretório raiz onde os arquivos de views estão
localizados. O valor padrão do diretório é representado pelo alias `@app/views`.
Você pode configurá-lo como um diretório ou [alias](concept-aliases.md) de
caminho.


#### [[yii\base\Application::vendorPath|vendorPath]] <a name="vendorPath"></a>

Essa propriedade especifica o diretório vendor gerenciado pelo [Composer](http://getcomposer.org).
Ele contém todas as bibliotecas de terceiros usadas pela sua aplicação, incluindo
548
o framework do Yii. O valor padrão é o diretório representado pelo alias `@app/vendor`.
549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695

Você pode configurar essa propriedade como um diretório ou [alias](concept-aliases.md)
de caminho. Quando você modificar essa propriedade, assegure-se de ajustar a
configuração do Composer de acordo.

Para simplificar o acesso a esse caminho, o Yii tem um alias de caminho pré-definido
para ele chamado de `@vendor`.


#### [[yii\console\Application::enableCoreCommands|enableCoreCommands]] <a name="enableCoreCommands"></a>

Essa propriedade só é suportada por [[yii\console\Application|aplicações do console]].
Ela especifica se os comandos do core inclusos no pacote do Yii devem estar
ativos. O valor padrão é `true`.


## Eventos da Aplicação <a name="application-events"></a>

Uma aplicação dispara muitos eventos durante o ciclo de vida de manipulação de
uma requisição. Você pode vincular manipuladores a esses eventos nas
configurações da aplicação do seguinte modo,

```php
[
    'on beforeRequest' => function ($event) {
        // ...
    },
]
```

A sintaxe de uso de `on eventName` é descrita na seção
[Configurações](concept-configurations.md#configuration-format).

Alternativamente, você pode vincular manipuladores de evento durante o
[processo de inicialização](runtime-bootstrapping.md) após a instância da aplicação
ser criada. Por exemplo,

```php
\Yii::$app->on(\yii\base\Application::EVENT_BEFORE_REQUEST, function ($event) {
    // ...
});
```

### [[yii\base\Application::EVENT_BEFORE_REQUEST|EVENT_BEFORE_REQUEST]] <a name="beforeRequest"></a>

Este evento é disparado *antes* de uma aplicação manipular uma requisição. O nome
do evento é `beforeRequest`.

Quando esse evento é disparado, a instância da aplicação foi configurada e
inicializada. Então é um bom lugar para inserir código personalizado por meio
do mecanismo de eventos para interceptar o processo de tratamento da requisição.
Por exemplo, no manipulador de eventos, você pode definir dinamicamente a
propriedade [[yii\base\Application::language]] baseado em alguns parâmetros.


### [[yii\base\Application::EVENT_AFTER_REQUEST|EVENT_AFTER_REQUEST]] <a name="afterRequest"></a>

Este evento é disparado *depois* que uma aplicação finaliza o tratamento da
requisição, mas *antes* de enviar a resposta. O nome do evento é `afterRequest`.

Quando este evento é disparado, o tratamento da requisição está completo e você
pode aproveitar essa ocasião para fazer um pós-processamento da requisição ou
personalizar a resposta.

Perceba que o componente [[yii\web\Response|response]] também dispara alguns
eventos enquanto está enviando conteúdo de resposta para os usuários finais. 
Esses eventos são disparados *depois* deste evento.


### [[yii\base\Application::EVENT_BEFORE_ACTION|EVENT_BEFORE_ACTION]] <a name="beforeAction"></a>

Este evento é disparado *antes* de executar cada [action de controller](structure-controllers.md).
O nome do evento é `beforeAction`.

O parâmetro do evento é uma instância de [[yii\base\ActionEvent]]. Um manipulador
de evento pode definir o valor da propriedade [[yii\base\ActionEvent::isValid]]
como `false` para interromper a execução da action. Por exemplo,

```php
[
    'on beforeAction' => function ($event) {
        if (alguma condição) {
            $event->isValid = false;
        } else {
        }
    },
]
```

Perceba que o mesmo evento `beforeAction` também é disparado pelos [módulos](structure-modules.md)
e [controllers](structure-controllers.md). Os objetos Application são os primeiros
a disparar este evento, seguidos pelos módulos (se houver algum) e finalmente pelos
controllers. Se um manipulador de evento definir [[yii\base\ActionEvent::isValid]]
como `false`, todos os eventos seguintes NÃO serão disparados.


### [[yii\base\Application::EVENT_AFTER_ACTION|EVENT_AFTER_ACTION]] <a name="afterAction"></a>

Este evento é disparado *depois* de executar cada [action de controller](structure-controllers.md).
O nome do evento é `afterAction`.

O parâmetro do evento é uma instância de [[yii\base\ActionEvent]]. Através da
propriedade [[yii\base\ActionEvent::result]], um manipulador de evento pode
acessar ou modificar o resultado da action. Por exemplo,

```php
[
    'on afterAction' => function ($event) {
        if (alguma condição) {
            // modifica $event->result
        } else {
        }
    },
]
```

Perceba que o mesmo evento `afterAction` também é disparado pelos [módulos](structure-modules.md)
e [controllers](structure-controllers.md). Estes objetos disparam esse evento
na order inversa da do `beforeAction`. Ou seja, os controllers são os primeiros
objetos a disparar este evento, seguidos pelos módulos (se houver algum) e
finalmente pelos objetos Application.


## Ciclo de Vida da  Aplicação <a name="application-lifecycle"></a>

Quando um [script de entrada](structure-entry-scripts.md) estiver sendo executado
para manipular uma requisição, uma aplicação passará pelo seguinte ciclo de vida:

1. O script de entrada carrega a configuração da aplicação como um array.
2. O script de entrada cria uma nova instância da aplicação:
  * [[yii\base\Application::preInit()|preInit()]] é chamado, que configura algumas
    propriedades da aplicação de alta prioridade, tais como
    [[yii\base\Application::basePath|basePath]].
  * Registra o [[yii\base\Application::errorHandler|manipulador de erros]].
  * Configura as propriedades da aplicação.
  * [[yii\base\Application::init()|init()]] é chamado, que por sua vez chama
    [[yii\base\Application::bootstrap()|bootstrap()]] para rodar os componentes
    de inicialização.
3. O script de entrada chama [[yii\base\Application::run()]] para executar a aplicação:
  * Dispara o evento [[yii\base\Application::EVENT_BEFORE_REQUEST|EVENT_BEFORE_REQUEST]].
  * Trata a requisição: resolve a requisição em uma [rota](runtime-routing.md)
    e os parâmetros associados; cria os objetos do módulo, do controller e da
    action conforme especificado pela rota; e executa a action.
  * Dispara o evento [[yii\base\Application::EVENT_AFTER_REQUEST|EVENT_AFTER_REQUEST]].
  * Envia a resposta para o usuário final.
4. O script de entrada recebe o status de saída da aplicação e completa o
   processamento da requisição.