Components¶

Incluindo Componentes em seus Controladores¶

Uma vez que o componente está finalizado, nós podemos usar ele nos controladores de nossa aplicação colocando o nome do componente (sem a parte «Component«) na variável $components do controlador, permitindo que possamos acessar uma instância do mesmo.

/* Fazendo com que o componente esteja disponível através
de $this->Math, bem como o padrão $this->Session */
var $components = array('Math', 'Session');

Componente declarados em AppController serão mesclados com os outros de seus controladores. Então não é necessário redeclarar o mesmo componente duas vezes.

Quando estiver incluindo Componentes em um Controlador você também pode declarar parâmetros que serão passadas para o método initialize() do Componente. Estes parâmetros podem ser tratados pelo Componente.

var $components = array(
    'Math' => array(
        'precision' => 2,
        'randomGenerator' => 'srand'
    ),
    'Session', 'Auth'
);

Acima será passado um vetor contendo os parâmetros precision e randomGenerator para o método initialize() do componente MathComponent’s.

Esta sintaxe não esta implementada em nenhum Componente padrão do CakePHP até o momento

Acessando classes do MVC de dentro dos componentes¶

Os componentes possuem um número de callbacks usados pela classe controller pai. O uso sensato destes callbacks podem fazer criar e usar compomentes muito fácil

initialize($controller, $settings=array())

O método initialize é chamado antes do método beforeFilter do controller

startup($controller)

O método startup é chamado depois do método beforeFilter do controle, mas antes do controller executar a action corrente.

beforeRender($controller)

O método beforeRender é chamado depois do método beforeRender do controller, mas antes do controller renderizar a view e o layout.

shutdown($controller)

O método shutdown é chamado antes da saída ser enviada ao browser.

beforeRedirect($controller, $url, $status=null, $exit=true)

O método beforeRedirect é invocado quando o método redirect do controller é chamado, mas antes de qualquer outra action. Se este método retornar false o controller não continuará na requisição de redirecionamento. As variáveis $url, $status e $exit tem os mesmos significados como o método do controller.

Aqui está um component esqueleto que você pode usar como um template para seus próprios components personalizados.

<?php
class SkeletonComponent extends Object {
    //chamado antes do Controller::beforeFilter()
    function initialize($controller, $settings = array()) {
        // salvando a referência do controller para uso posterior
        $this->controller = $controller;
    }

    //chamado depois do Controller::beforeFilter()
    function startup($controller) {
    }

    //chamado depois do Controller::beforeRender()
    function beforeRender($controller) {
    }

    //chamado depois do Controller::render()
    function shutdown($controller) {
    }

    //chamado antes do Controller::redirect()
    function beforeRedirect($controller, $url, $status=null, $exit=true) {
    }

    function redirectSomewhere($value) {
        // utilizando um método de controller
        $this->controller->redirect($value);
    }
}
?>

Você deve também querer utilizar outro componente dentro de um componente personalizado. Para fazer isso, apenas crie uma variável de classe $components (exatamente como você faria em um controller) como um array que contém os nomes dos components que você deseja utilizar.

<?php
class MyComponent extends Object {

    // Este componente usa outros componentes
    var $components = array('Session', 'Math');

    function doStuff() {
        $result = $this->Math->doComplexOperation(1, 2);
        $this->Session->write('stuff', $result);
    }

}
?>

Acessar ou usar um model em um component não é muito recomendado; Se você acabar precisando usar um, você precisa instanciar sua model class e usá-la manualmente. Aqui vai um exemplo:

<?php
class MathComponent extends Object {
    function doComplexOperation($amount1, $amount2) {
        return $amount1 + $amount2;
    }

    function doReallyComplexOperation ($amount1, $amount2) {
        $userInstance = ClassRegistry::init('User');
        $totalUsers = $userInstance->find('count');
        return ($amount1 + $amount2) / $totalUsers;
    }
}
?>

Usando outros Componentes em seu Componente¶

Em alguns momentos um de seus componentes precisa usar outro componente.

Você pode incluir outro componente em seu componente da mesma maneira que você inclui eles nos controladores: Use a variável $components.

<?php
class CustomComponent extends Object {
    var $name = "Custom"; // o nome do componente
    var $components = array( "Existing" ); // o outro componente que você deseja usar

    function initialize(&$controller) {
        $this->Existing->foo();
    }

    function bar() {
        // ...
    }
}
?>

<?php
class ExistingComponent extends Object {
    var $name = "Existing";

    function initialize(&$controller) {
        $this->Parent->bar();
    }

    function foo() {
        // ...
    }
}
?>