Analyze of event system in Drupal 8

namespace Drupal\user\EventSubscriber;

use Drupal\Core\Routing\RouteMatch;
use Drupal\Core\Session\AccountInterface;
use Drupal\Core\Site\MaintenanceModeInterface;
use Drupal\Core\Url;
use Symfony\Component\EventDispatcher\EventSubscriberInterface;
use Symfony\Component\HttpFoundation\RedirectResponse;
use Symfony\Component\HttpKernel\Event\GetResponseEvent;
use Symfony\Component\HttpKernel\KernelEvents;

/**
* Maintenance mode subscriber to log out users.
*/
class MaintenanceModeSubscriber implements EventSubscriberInterface {

/**
 * The maintenance mode.
 */
protected $maintenanceMode;

/**
 * The current account.
 */
protected $account;

/**
 * Constructs a new MaintenanceModeSubscriber.
 */
public function __construct(MaintenanceModeInterface $maintenance_mode, AccountInterface $account) {
  // We use services that are defined in the services definition in user.services.yml
  $this->maintenanceMode = $maintenance_mode;
  $this->account = $account;
}

/**
 * Method getSubscribedEvents() is required and is used for describing listeners.
 */
public static function getSubscribedEvents() {
  // Subscribe to the event KernelEvents::REQUEST.
  // When this event occurs, method listener onKernelRequestMaintenance will be triggered.
  // 31 - priority of the listener.  
  $events[KernelEvents::REQUEST][] = ['onKernelRequestMaintenance', 31];
  return $events;
}

/**
 * Logout users if site is in maintenance mode.
 */
public function onKernelRequestMaintenance(GetResponseEvent $event) {
  // Listener implementation.
  $request = $event->getRequest();
  $route_match = RouteMatch::createFromRequest($request);
  if ($this->maintenanceMode->applies($route_match)) {
    // If the site is offline, log out unprivileged users.
    if ($this->account->isAuthenticated() && !$this->maintenanceMode->exempt($this->account)) {
      user_logout();
      // Redirect to homepage.
      $event->setResponse(
        new RedirectResponse(Url::fromRoute('<front>')->toString())
      );
    }
  }
}
}

/**
* Listeners initialisation.
*/
public static function getSubscribedEvents() {
$events[ConfigEvents::SAVE][] = ['onConfigSave', 0];
// Empty value check has high priority to stop further processing if configuration is empty.
$events[ConfigEvents::IMPORT_VALIDATE][] = ['onConfigImporterValidateNotEmpty', 512];
return $events;
}

/**
* No need to import configuration if it is empty. Otherwise import will remove active configuration.
* Stop process on this step.
*/
public function onConfigImporterValidateNotEmpty(ConfigImporterEvent $event) {
$importList = $event->getConfigImporter()->getStorageComparer()->getSourceStorage()->listAll();
if (empty($importList)) {
  $event->getConfigImporter()->logError($this->t('This import is empty and if applied would delete all of your configuration, so has been rejected.'));
  $event->stopPropagation();
}
}

$response = new RedirectResponse($url);
// Listener of the event that is defined dynamically.
$listener = function ($event) use ($response) {
  $event->setResponse($response);
};
// Listener is added to the event registry using “event_dispatcher” service.
$this->dispatcher->addListener(KernelEvents::RESPONSE, $listener);

namespace Drupal\Core\Routing;

/**
* Contains all events thrown in the core routing component.
*/
final class RoutingEvents {

/**
 * Name of the event fired during route collection to allow new routes.
 */
const DYNAMIC = 'routing.route_dynamic';

/**
 * Name of the event fired during route collection to allow changes to routes.
 */
const ALTER = 'routing.route_alter';

/**
 * Name of the event fired to indicate route building has ended.
 */
const FINISHED = 'routing.route_finished';
}

namespace Drupal\Core\Routing;

use Symfony\Component\EventDispatcher\Event;
use Symfony\Component\Routing\RouteCollection;

/**
* Represents route building information as event.
*/
class RouteBuildEvent extends Event {

/**
 * The route collection.
 */
protected $routeCollection;

/**
 * Constructs a RouteBuildEvent object.
 */
public function __construct(RouteCollection $route_collection) {
  $this->routeCollection = $route_collection;
}

/**
 * Gets the route collection.
 */
public function getRouteCollection() {
  return $this->routeCollection;
}
}

namespace Drupal\Core\Routing;

/**
* Managing class for rebuilding the router table.
*/
class RouteBuilder implements RouteBuilderInterface, DestructableInterface {

/**
* The event dispatcher to notify of routes.
*
* @var \Symfony\Component\EventDispatcher\EventDispatcherInterface
*/
protected $dispatcher;

...

public function rebuild() {
 ...
 // DYNAMIC is supposed to be used to add new routes based upon all the
 // static defined ones.
 $this->dispatcher->dispatch(RoutingEvents::DYNAMIC, new RouteBuildEvent($collection));

 // ALTER is the final step to alter all the existing routes. We cannot stop
 // people from adding new routes here, but we define two separate steps to
 // make it clear.
 $this->dispatcher->dispatch(RoutingEvents::ALTER, new RouteBuildEvent($collection));
 $this->checkProvider->setChecks($collection);

 ...
}
}