Components

For more information on the components included in CakePHP, check out thechapter for each component:

Many of the core components require configuration. Some examples of componentsrequiring configuration are andRequest Handling. Configuration for these components,and for components in general, is usually done via in yourController’s initialize() method or via the $components array:

You can configure components at runtime using the setConfig() method. Often,this is done in your controller’s beforeFilter() method. The above couldalso be expressed as:

public function beforeFilter(EventInterface $event)
{
    $this->RequestHandler->setConfig('viewClassMap', ['rss' => 'MyRssView']);
}

Like helpers, components implement getConfig() and setConfig() methodsto read and write configuration data:

// Read config data.
$this->RequestHandler->getConfig('viewClassMap');
 
// Set config
$this->Csrf->setConfig('cookieName', 'token');

As with helpers, components will automatically merge their $_defaultConfigproperty with constructor configuration to create the $_config propertywhich is accessible with getConfig() and .

One common setting to use is the className option, which allows you toalias components. This feature is useful when you want toreplace $this->Auth or another common Component reference with a customimplementation:

// src/Controller/PostsController.php
class PostsController extends AppController
{
    public function initialize(): void
    {
        $this->loadComponent('Auth', [
            'className' => 'MyAuth'
        ]);
    }
}
 
// src/Controller/Component/MyAuthComponent.php
use Cake\Controller\Component\AuthComponent;
 
class MyAuthComponent extends AuthComponent
{
    // Add your code to override the core AuthComponent

The above would alias MyAuthComponent to $this->Auth in yourcontrollers.

Note

You might not need all of your components available on every controlleraction. In situations like this you can load a component at runtime using theloadComponent() method in your controller:

Note

Keep in mind that components loaded on the fly will not have missedcallbacks called. If you rely on the beforeFilter or startupcallbacks being called, you may need to call them manually depending on whenyou load your component.

Once you’ve included some components in your controller, using them is prettysimple. Each component you use is exposed as a property on your controller. Ifyou had loaded up the in your controller, you could access it like so:

class PostsController extends AppController
{
    public function initialize(): void
    {
        parent::initialize();
        $this->loadComponent('Flash');
    }
 
    public function delete()
    {
        if ($this->Post->delete($this->request->getData('Post.id')) {
            $this->Flash->success('Post deleted.');
            return $this->redirect(['action' => 'index']);
        }
    }

Note

Since both Models and Components are added to Controllers asproperties they share the same ‘namespace’. Be sure to not give acomponent and a model the same name.

Suppose our application needs to perform a complex mathematical operation inmany different parts of the application. We could create a component to housethis shared logic for use in many different controllers.

The first step is to create a new component file and class. Create the file insrc/Controller/Component/MathComponent.php. The basic structure for thecomponent would look something like this:

namespace App\Controller\Component;
 
use Cake\Controller\Component;
 
class MathComponent extends Component
{
    public function doComplexOperation($amount1, $amount2)
    {
        return $amount1 + $amount2;
    }
}

All components must extend Cake\Controller\Component. Failingto do this will trigger an exception.

Once our component is finished, we can use it in the application’scontrollers by loading it during the controller’s method.Once loaded, the controller will be given a new attribute named after thecomponent, through which we can access an instance of it:

// In a controller
// Make the new component available at $this->Math,
// as well as the standard $this->Csrf
public function initialize(): void
{
    parent::initialize();
    $this->loadComponent('Math');
    $this->loadComponent('Csrf');
}

When including Components in a Controller you can also declare aset of parameters that will be passed on to the Component’sconstructor. These parameters can then be handled bythe Component:

The above would pass the array containing precision and randomGenerator toMathComponent::initialize() in the $config parameter.

Sometimes one of your components may need to use another component.In this case you can include other components in your component the exact sameway you include them in controllers - using the $components var:

// src/Controller/Component/CustomComponent.php
namespace App\Controller\Component;
 
use Cake\Controller\Component;
 
{
    // The other component your component uses
    public $components = ['Existing'];
 
    // Execute any other additional setup for your component.
    public function initialize(array $config): void
    {
        $this->Existing->foo();
    }
 
    public function bar()
    {
        // ...
    }
}
 
// src/Controller/Component/ExistingComponent.php
namespace App\Controller\Component;
 
use Cake\Controller\Component;
 
class ExistingComponent extends Component
{
    public function foo()
    {
        // ...
    }
}

Note

In contrast to a component included in a controllerno callbacks will be triggered on a component’s component.

From within a Component you can access the current controller through theregistry:

$controller = $this->_registry->getController();

$controller = $event->getSubject();

Components also offer a few request life-cycle callbacks that allow them toaugment the request cycle.

beforeFilter(EventInterface $event)
Is called before the controller’sbeforeFilter method, but after the controller’s initialize() method.

startup(EventInterface $event)
Is called after the controller’s beforeFiltermethod but before the controller executes the current actionhandler.

beforeRender(EventInterface $event)
Is called after the controller executes the requested action’s logic,but before the controller renders views and layout.

shutdown(EventInterface $event)
Is called before output is sent to the browser.

beforeRedirect(EventInterface $event, $url, Response $response)
Is invoked when the controller’s redirectmethod is called but before any further action. If this methodreturns false the controller will not continue on to redirect therequest. The $url, and $response parameters allow you to inspect and modifythe location or any other headers in the response.