This interface is used to tell the Application instance to inject its MvcEvent into this controller. The controller can access the request, response, and route matched using the MvcEvent object and can modify the contents if needed. Let's see an example on how this interface can be used inside a controller to validate that the parameter id is present in the request:

$matches = $this->getEvent()->getRouteMatch();
$id      = $matches->getParam('id', false);
if (!$id) {
    $response = $this->getResponse();
    $response->setStatusCode(500);
    $this->getEvent()->setResult('Invalid identifier; cannot complete request'),
    return;
}

The InjectApplicationEvent class defines two methods: setEvent() and getEvent(). If you take a look at the first line of the previous code example, you can see that we are calling getEvent() to retrieve the MvcEvent object; from there we will call getRouteMatch() to get the RouteMatch object. From there it's just a matter of getting a parameter providing false as the default value. In case the parameter is not in the request, false will be returned and the condition below will succeed taking care of returning the proper error.

In ZF2, you usually develop your controllers in a way that the dependencies are injected on the constructor or using setters. Sometimes you can have objects that will not be needed on every request handled by the controller and it makes no sense to have it injected every time, for example during navigation, forms, and pagination. In this case, you will need to use the ServiceLocatorAware interface to tell ServiceManager to inject itself to the controller so that you can use it to retrieve the dependencies you need.

class IndexController extends AbstractActionController
{
    public function indexAction()
    {
        $config = $this->getServiceLocator()->get('ApplicationConfig'),

        //More code here

    }
}

This is a usage example of this interface. As you can see on the class definition, we are extending the AbstractActionController class. We said before that this controller already provides some boilerplate code; in this case, this class not only implements this interface but also implements InjectApplicationEvent and EventManagerAware. So, if you stick with it while developing your controllers, you will benefit from this automatically.

As in the case of the previous interface, this one also defines two methods: setServiceLocator() and getServiceLocator().

As with the other two interfaces, this one is also to tell ServiceManager that we want something injected by default. In this case, we want the EventManager instance to be injected by default. This interface defines two methods: setEventManager() and getEventManager().

Let's see how to use it on a controller:

$eventManager = $this->getEventManager();
$eventManager->trigger(INDEX_LOADED);

As you can see, once the interface is implemented, it is easy to retrieve the EventManager instance and use it; in this case we are firing a custom event called INDEX_LOADED.

The MVC layer of Zend Framework 2 not only provides interfaces to help you with controllers but also provides plugins to use inside controllers. There are a few types, but the most common ones are URL, Redirect, FlashMessenger, and PostRedirectGet. In order to ease the usage of these plugins, ZF2 provides PluginManager. As usual, to utilize it you should define three methods: setPluginManager(), getPluginManager(), and plugin(), unless you are extending the AbstractActionController class that provides this by default.

$pm = $this->getPluginManager();
$flashMessenger = $pm->get('FlashMessenger'),
$flashMessenger->addMessage('Using the flash messenger plugin'),

As you can see in the example, it is pretty straightforward; you only need to get the PluginManager configuration, and then get any plugin you need, referencing them by name as in the previous code example, the FlashMessenger view helper.

The last thing provided by the new implementation of the MVC pattern in ZF2 is a collection of two base controllers that we can extend to create our controllers. These two base controllers are designed to provide some functionality by default and both of them extend a common controller called AbstractController.

namespace FooController;

use ZendMvcControllerAbstractActionController;

class BarController extends AbstractActionController
{
    public function bazAction()
    {
        return array('title' => __METHOD__);
    }

    public function batAction()
    {
        return array('title' => __METHOD__);
    }
}