Routing

• Routing
  • Creating Routes
    • Creating Routes as Attributes or Annotations
    • Creating Routes in YAML, XML or PHP Files
    • Matching HTTP Methods
    • Matching Expressions
    • Debugging Routes
  • Route Parameters
    • Parameters Validation
    • Optional Parameters
    • Priority Parameter
    • Parameter Conversion
    • Special Parameters
    • Extra Parameters
    • Slash Characters in Route Parameters
  • Route Groups and Prefixes
  • Getting the Route Name and Parameters
  • Special Routes
    • Rendering a Template Directly from a Route
    • Redirecting to URLs and Routes Directly from a Route
      • Redirecting URLs with Trailing Slashes
  • Sub-Domain Routing
  • Localized Routes (i18n)
  • Stateless Routes
  • Generating URLs
    • Generating URLs in Controllers
    • Generating URLs in Services
    • Generating URLs in Templates
    • Generating URLs in JavaScript
    • Generating URLs in Commands
    • Checking if a Route Exists
    • Forcing HTTPS on Generated URLs
  • Troubleshooting
  • Learn more about Routing

Routing

When your application receives a request, it calls a controller action to generate the response. The routing configuration defines which action to run for each incoming URL. It also provides other useful features, like generating SEO-friendly URLs (e.g. /read/intro-to-symfony instead of index.php?article_id=57).

Creating Routes

Routes can be configured in YAML, XML, PHP or using either attributes or annotations. All formats provide the same features and performance, so choose your favorite. Symfony recommends attributes because it’s convenient to put the route and controller in the same place.

Creating Routes as Attributes or Annotations

On PHP 8, you can use native attributes to configure routes right away. On PHP 7, where attributes are not available, you can use annotations instead, provided by the Doctrine Annotations library.

In case you want to use annotations instead of attributes, run this command once in your application to enable them:

$ composer require doctrine/annotations

New in version 5.2: The ability to use PHP attributes to configure routes was introduced in Symfony 5.2. Prior to this, Doctrine Annotations were the only way to annotate controller actions with routing configuration.

This command also creates the following configuration file:

# config/routes/annotations.yaml
controllers:
    resource: ../../src/Controller/
    type: annotation
kernel:
    resource: ../../src/Kernel.php
    type: annotation

This configuration tells Symfony to look for routes defined as annotations in any PHP class stored in the src/Controller/ directory.

Suppose you want to define a route for the /blog URL in your application. To do so, create a controller class like the following:

• Annotations

  // src/Controller/BlogController.php
  namespace App\Controller;
  use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
  use Symfony\Component\Routing\Annotation\Route;
  class BlogController extends AbstractController
  {
      /**
       * @Route("/blog", name="blog_list")
       */
      public function list()
      {
          // ...
      }
  }

• Attributes

  // src/Controller/BlogController.php
  namespace App\Controller;
  use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
  use Symfony\Component\Routing\Annotation\Route;
  class BlogController extends AbstractController
  {
      #[Route('/blog', name: 'blog_list')]
      public function list()
      {
          // ...
      }
  }

This configuration defines a route called blog_list that matches when the user requests the /blog URL. When the match occurs, the application runs the list() method of theBlogController` class.

Note

The query string of a URL is not considered when matching routes. In this example, URLs like /blog?foo=bar and /blog?foo=bar&bar=foo will also match the blog_list route.

Caution

If you define multiple PHP classes in the same file, Symfony only loads the routes of the first class, ignoring all the other routes.

The route name (blog_list) is not important for now, but it will be essential later when generating URLs. You only have to keep in mind that each route name must be unique in the application.

Creating Routes in YAML, XML or PHP Files

Instead of defining routes in the controller classes, you can define them in a separate YAML, XML or PHP file. The main advantage is that they don’t require any extra dependency. The main drawback is that you have to work with multiple files when checking the routing of some controller action.

The following example shows how to define in YAML/XML/PHP a route called blog_list that associates the /blog URL with the list() action of theBlogController`:

• YAML

  # config/routes.yaml
  blog_list:
      path: /blog
      # the controller value has the format 'controller_class::method_name'
      controller: App\Controller\BlogController::list
      # if the action is implemented as the __invoke() method of the
      # controller class, you can skip the '::method_name' part:
      # controller: App\Controller\BlogController

• XML

  <!-- config/routes.xml -->
  <?xml version="1.0" encoding="UTF-8" ?>
  <routes xmlns="http://symfony.com/schema/routing"
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
      xsi:schemaLocation="http://symfony.com/schema/routing
          https://symfony.com/schema/routing/routing-1.0.xsd">
      <!-- the controller value has the format 'controller_class::method_name' -->
      <route id="blog_list" path="/blog"
             controller="App\Controller\BlogController::list"/>
      <!-- if the action is implemented as the __invoke() method of the
           controller class, you can skip the '::method_name' part:
           controller="App\Controller\BlogController"/> -->
  </routes>

• PHP

  // config/routes.php
  use App\Controller\BlogController;
  use Symfony\Component\Routing\Loader\Configurator\RoutingConfigurator;
  return function (RoutingConfigurator $routes) {
      $routes->add('blog_list', '/blog')
          // the controller value has the format [controller_class, method_name]
          ->controller([BlogController::class, 'list'])
          // if the action is implemented as the __invoke() method of the
          // controller class, you can skip the 'method_name' part:
          // ->controller(BlogController::class)
      ;
  };

New in version 5.1: Starting from Symfony 5.1, by default Symfony only loads the routes defined in YAML format. If you define routes in XML and/or PHP formats, update the src/Kernel.php file to add support for the .xml and .php file extensions.

Matching HTTP Methods

By default, routes match any HTTP verb (GET, POST, PUT, etc.) Use the methods option to restrict the verbs each route should respond to:

• Annotations

  // src/Controller/BlogApiController.php
  namespace App\Controller;
  use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
  use Symfony\Component\HttpFoundation\Response;
  use Symfony\Component\Routing\Annotation\Route;
  class BlogApiController extends AbstractController
  {
      /**
       * @Route("/api/posts/{id}", methods={"GET","HEAD"})
       */
      public function show(int $id): Response
      {
          // ... return a JSON response with the post
      }
      /**
       * @Route("/api/posts/{id}", methods={"PUT"})
       */
      public function edit(int $id): Response
      {
          // ... edit a post
      }
  }

• Attributes

  // src/Controller/BlogApiController.php
  namespace App\Controller;
  // ...
  class BlogApiController extends AbstractController
  {
      #[Route('/api/posts/{id}', methods: ['GET', 'HEAD'])]
      public function show(int $id): Response
      {
          // ... return a JSON response with the post
      }
      #[Route('/api/posts/{id}', methods: ['PUT'])]
      public function edit(int $id): Response
      {
          // ... edit a post
      }
  }

• YAML

  # config/routes.yaml
  api_post_show:
      path:       /api/posts/{id}
      controller: App\Controller\BlogApiController::show
      methods:    GET|HEAD
  api_post_edit:
      path:       /api/posts/{id}
      controller: App\Controller\BlogApiController::edit
      methods:    PUT

• XML

  <!-- config/routes.xml -->
  <?xml version="1.0" encoding="UTF-8" ?>
  <routes xmlns="http://symfony.com/schema/routing"
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
      xsi:schemaLocation="http://symfony.com/schema/routing
          https://symfony.com/schema/routing/routing-1.0.xsd">
      <route id="api_post_show" path="/api/posts/{id}"
          controller="App\Controller\BlogApiController::show"
          methods="GET|HEAD"/>
      <route id="api_post_edit" path="/api/posts/{id}"
          controller="App\Controller\BlogApiController::edit"
          methods="PUT"/>
  </routes>

• PHP

  // config/routes.php
  use App\Controller\BlogApiController;
  use Symfony\Component\Routing\Loader\Configurator\RoutingConfigurator;
  return function (RoutingConfigurator $routes) {
      $routes->add('api_post_show', '/api/posts/{id}')
          ->controller([BlogApiController::class, 'show'])
          ->methods(['GET', 'HEAD'])
      ;
      $routes->add('api_post_edit', '/api/posts/{id}')
          ->controller([BlogApiController::class, 'edit'])
          ->methods(['PUT'])
      ;
  };

Tip

HTML forms only support GET and POST methods. If you’re calling a route with a different method from an HTML form, add a hidden field called _method with the method to use (e.g. <input type="hidden" name="_method" value="PUT"/>). If you create your forms with Symfony Forms this is done automatically for you.

Matching Expressions

Use the condition option if you need some route to match based on some arbitrary matching logic:

• Annotations

  // src/Controller/DefaultController.php
  namespace App\Controller;
  use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
  use Symfony\Component\HttpFoundation\Response;
  use Symfony\Component\Routing\Annotation\Route;
  class DefaultController extends AbstractController
  {
      /**
       * @Route(
       *     "/contact",
       *     name="contact",
       *     condition="context.getMethod() in ['GET', 'HEAD'] and request.headers.get('User-Agent') matches '/firefox/i'"
       * )
       *
       * expressions can also include configuration parameters:
       * condition: "request.headers.get('User-Agent') matches '%app.allowed_browsers%'"
       */
      public function contact(): Response
      {
          // ...
      }
  }

• Attributes

  // src/Controller/DefaultController.php
  namespace App\Controller;
  use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
  use Symfony\Component\HttpFoundation\Response;
  use Symfony\Component\Routing\Annotation\Route;
  class DefaultController extends AbstractController
  {
      #[Route(
          '/contact',
          name: 'contact',
          condition: "context.getMethod() in ['GET', 'HEAD'] and request.headers.get('User-Agent') matches '/firefox/i'",
      )]
      // expressions can also include config parameters:
      // condition: "request.headers.get('User-Agent') matches '%app.allowed_browsers%'"
      public function contact(): Response
      {
          // ...
      }
  }

• YAML

  # config/routes.yaml
  contact:
      path:       /contact
      controller: 'App\Controller\DefaultController::contact'
      condition:  "context.getMethod() in ['GET', 'HEAD'] and request.headers.get('User-Agent') matches '/firefox/i'"
      # expressions can also include configuration parameters:
      # condition: "request.headers.get('User-Agent') matches '%app.allowed_browsers%'"

• XML

  <!-- config/routes.xml -->
  <?xml version="1.0" encoding="UTF-8" ?>
  <routes xmlns="http://symfony.com/schema/routing"
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
      xsi:schemaLocation="http://symfony.com/schema/routing
          https://symfony.com/schema/routing/routing-1.0.xsd">
      <route id="contact" path="/contact" controller="App\Controller\DefaultController::contact">
          <condition>context.getMethod() in ['GET', 'HEAD'] and request.headers.get('User-Agent') matches '/firefox/i'</condition>
          <!-- expressions can also include configuration parameters: -->
          <!-- <condition>request.headers.get('User-Agent') matches '%app.allowed_browsers%'</condition> -->
      </route>
  </routes>

• PHP

  // config/routes.php
  use App\Controller\DefaultController;
  use Symfony\Component\Routing\Loader\Configurator\RoutingConfigurator;
  return function (RoutingConfigurator $routes) {
      $routes->add('contact', '/contact')
          ->controller([DefaultController::class, 'contact'])
          ->condition('context.getMethod() in ["GET", "HEAD"] and request.headers.get("User-Agent") matches "/firefox/i"')
          // expressions can also include configuration parameters:
          // 'request.headers.get("User-Agent") matches "%app.allowed_browsers%"'
      ;
  };

The value of the condition option is any valid ExpressionLanguage expression and can use any of these variables created by Symfony:

context

An instance of Symfony\Component\Routing\RequestContext, which holds the most fundamental information about the route being matched.

request

The Symfony Request object that represents the current request.

Behind the scenes, expressions are compiled down to raw PHP. Because of this, using the condition key causes no extra overhead beyond the time it takes for the underlying PHP to execute.

Caution

Conditions are not taken into account when generating URLs (which is explained later in this article).

Debugging Routes

As your application grows, you’ll eventually have a lot of routes. Symfony includes some commands to help you debug routing issues. First, the debug:router command lists all your application routes in the same order in which Symfony evaluates them:

$ php bin/console debug:router
----------------  -------  -------  -----  --------------------------------------------
Name              Method   Scheme   Host   Path
----------------  -------  -------  -----  --------------------------------------------
homepage          ANY      ANY      ANY    /
contact           GET      ANY      ANY    /contact
contact_process   POST     ANY      ANY    /contact
article_show      ANY      ANY      ANY    /articles/{_locale}/{year}/{title}.{_format}
blog              ANY      ANY      ANY    /blog/{page}
blog_show         ANY      ANY      ANY    /blog/{slug}
----------------  -------  -------  -----  --------------------------------------------

Pass the name (or part of the name) of some route to this argument to print the route details:

$ php bin/console debug:router app_lucky_number
+-------------+---------------------------------------------------------+
| Property    | Value                                                   |
+-------------+---------------------------------------------------------+
| Route Name  | app_lucky_number                                        |
| Path        | /lucky/number/{max}                                     |
| ...         | ...                                                     |
| Options     | compiler_class: Symfony\Component\Routing\RouteCompiler |
|             | utf8: true                                              |
+-------------+---------------------------------------------------------+

The other command is called router:match and it shows which route will match the given URL. It’s useful to find out why some URL is not executing the controller action that you expect:

$ php bin/console router:match /lucky/number/8
  [OK] Route "app_lucky_number" matches

Route Parameters

The previous examples defined routes where the URL never changes (e.g. /blog). However, it’s common to define routes where some parts are variable. For example, the URL to display some blog post will probably include the title or slug (e.g. /blog/my-first-post or /blog/all-about-symfony).

In Symfony routes, variable parts are wrapped in { ... } and they must have a unique name. For example, the route to display the blog post contents is defined as /blog/{slug}:

• Annotations

  // src/Controller/BlogController.php
  namespace App\Controller;
  use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
  use Symfony\Component\HttpFoundation\Response;
  use Symfony\Component\Routing\Annotation\Route;
  class BlogController extends AbstractController
  {
      // ...
      /**
       * @Route("/blog/{slug}", name="blog_show")
       */
      public function show(string $slug): Response
      {
          // $slug will equal the dynamic part of the URL
          // e.g. at /blog/yay-routing, then $slug='yay-routing'
          // ...
      }
  }

• Attributes

  // src/Controller/BlogController.php
  namespace App\Controller;
  use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
  use Symfony\Component\HttpFoundation\Response;
  use Symfony\Component\Routing\Annotation\Route;
  class BlogController extends AbstractController
  {
      // ...
      #[Route('/blog/{slug}', name: 'blog_show')]
      public function show(string $slug): Response
      {
          // $slug will equal the dynamic part of the URL
          // e.g. at /blog/yay-routing, then $slug='yay-routing'
          // ...
      }
  }

• YAML

  # config/routes.yaml
  blog_show:
      path:       /blog/{slug}
      controller: App\Controller\BlogController::show

• XML

  <!-- config/routes.xml -->
  <?xml version="1.0" encoding="UTF-8" ?>
  <routes xmlns="http://symfony.com/schema/routing"
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
      xsi:schemaLocation="http://symfony.com/schema/routing
          https://symfony.com/schema/routing/routing-1.0.xsd">
      <route id="blog_show" path="/blog/{slug}"
             controller="App\Controller\BlogController::show"/>
  </routes>

• PHP

  // config/routes.php
  use App\Controller\BlogController;
  use Symfony\Component\Routing\Loader\Configurator\RoutingConfigurator;
  return function (RoutingConfigurator $routes) {
      $routes->add('blog_show', '/blog/{slug}')
          ->controller([BlogController::class, 'show'])
      ;
  };

The name of the variable part ({slug} in this example) is used to create a PHP variable where that route content is stored and passed to the controller. If a user visits the /blog/my-first-post URL, Symfony executes the show() method in theBlogControllerclass and passes a$slug = ‘my-first-post’argument to theshow() method.

Routes can define any number of parameters, but each of them can only be used once on each route (e.g. /blog/posts-about-{category}/page/{pageNumber}).

Parameters Validation

Imagine that your application has a blog_show route (URL: /blog/{slug}) and a blog_list route (URL: /blog/{page}). Given that route parameters accept any value, there’s no way to differentiate both routes.

If the user requests /blog/my-first-post, both routes will match and Symfony will use the route which was defined first. To fix this, add some validation to the {page} parameter using the requirements option:

• Annotations

  // src/Controller/BlogController.php
  namespace App\Controller;
  use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
  use Symfony\Component\HttpFoundation\Response;
  use Symfony\Component\Routing\Annotation\Route;
  class BlogController extends AbstractController
  {
      /**
       * @Route("/blog/{page}", name="blog_list", requirements={"page"="\d+"})
       */
      public function list(int $page): Response
      {
          // ...
      }
      /**
       * @Route("/blog/{slug}", name="blog_show")
       */
      public function show(string $slug): Response
      {
          // ...
      }
  }

• Attributes

  // src/Controller/BlogController.php
  namespace App\Controller;
  use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
  use Symfony\Component\HttpFoundation\Response;
  use Symfony\Component\Routing\Annotation\Route;
  class BlogController extends AbstractController
  {
      #[Route('/blog/{page}', name: 'blog_list', requirements: ['page' => '\d+'])]
      public function list(int $page): Response
      {
          // ...
      }
      #[Route('/blog/{slug}', name: 'blog_show')]
      public function show($slug): Response
      {
          // ...
      }
  }

• YAML

  # config/routes.yaml
  blog_list:
      path:       /blog/{page}
      controller: App\Controller\BlogController::list
      requirements:
          page: '\d+'
  blog_show:
      path:       /blog/{slug}
      controller: App\Controller\BlogController::show

• XML

  <!-- config/routes.xml -->
  <?xml version="1.0" encoding="UTF-8" ?>
  <routes xmlns="http://symfony.com/schema/routing"
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
      xsi:schemaLocation="http://symfony.com/schema/routing
          https://symfony.com/schema/routing/routing-1.0.xsd">
      <route id="blog_list" path="/blog/{page}" controller="App\Controller\BlogController::list">
          <requirement key="page">\d+</requirement>
      </route>
      <route id="blog_show" path="/blog/{slug}"
             controller="App\Controller\BlogController::show"/>
  </routes>

• PHP

  // config/routes.php
  use App\Controller\BlogController;
  use Symfony\Component\Routing\Loader\Configurator\RoutingConfigurator;
  return function (RoutingConfigurator $routes) {
      $routes->add('blog_list', '/blog/{page}')
          ->controller([BlogController::class, 'list'])
          ->requirements(['page' => '\d+'])
      ;
      $routes->add('blog_show', '/blog/{slug}')
          ->controller([BlogController::class, 'show'])
      ;
      // ...
  };

The requirements option defines the PHP regular expressions that route parameters must match for the entire route to match. In this example, \d+ is a regular expression that matches a digit of any length. Now:

Tip

Route requirements (and route paths too) can include configuration parameters, which is useful to define complex regular expressions once and reuse them in multiple routes.

Tip

Parameters also support PCRE Unicode properties, which are escape sequences that match generic character types. For example, \p{Lu} matches any uppercase character in any language, \p{Greek} matches any Greek character, etc.

Note

When using regular expressions in route parameters, you can set the utf8 route option to true to make any . character match any UTF-8 characters instead of just a single byte.

If you prefer, requirements can be inlined in each parameter using the syntax {parameter_name<requirements>}. This feature makes configuration more concise, but it can decrease route readability when requirements are complex:

• Annotations

  // src/Controller/BlogController.php
  namespace App\Controller;
  use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
  use Symfony\Component\HttpFoundation\Response;
  use Symfony\Component\Routing\Annotation\Route;
  class BlogController extends AbstractController
  {
      /**
       * @Route("/blog/{page<\d+>}", name="blog_list")
       */
      public function list(int $page): Response
      {
          // ...
      }
  }

• Attributes

  // src/Controller/BlogController.php
  namespace App\Controller;
  use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
  use Symfony\Component\HttpFoundation\Response;
  use Symfony\Component\Routing\Annotation\Route;
  class BlogController extends AbstractController
  {
      #[Route('/blog/{page<\d+>}', name: 'blog_list')]
      public function list(int $page): Response
      {
          // ...
      }
  }

• YAML

  # config/routes.yaml
  blog_list:
      path:       /blog/{page<\d+>}
      controller: App\Controller\BlogController::list

• XML

  <!-- config/routes.xml -->
  <?xml version="1.0" encoding="UTF-8" ?>
  <routes xmlns="http://symfony.com/schema/routing"
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
      xsi:schemaLocation="http://symfony.com/schema/routing
          https://symfony.com/schema/routing/routing-1.0.xsd">
      <route id="blog_list" path="/blog/{page<\d+>}"
             controller="App\Controller\BlogController::list"/>
      <!-- ... -->
  </routes>

• PHP

  // config/routes.php
  use App\Controller\BlogController;
  use Symfony\Component\Routing\Loader\Configurator\RoutingConfigurator;
  return function (RoutingConfigurator $routes) {
      $routes->add('blog_list', '/blog/{page<\d+>}')
          ->controller([BlogController::class, 'list'])
      ;
      // ...
  };

Optional Parameters

In the previous example, the URL of blog_list is /blog/{page}. If users visit /blog/1, it will match. But if they visit /blog, it will not match. As soon as you add a parameter to a route, it must have a value.

You can make blog_list once again match when the user visits /blog by adding a default value for the {page} parameter. When using annotations or attributes, default values are defined in the arguments of the controller action. In the other configuration formats they are defined with the defaults option:

• Annotations

  // src/Controller/BlogController.php
  namespace App\Controller;
  use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
  use Symfony\Component\HttpFoundation\Response;
  use Symfony\Component\Routing\Annotation\Route;
  class BlogController extends AbstractController
  {
      /**
       * @Route("/blog/{page}", name="blog_list", requirements={"page"="\d+"})
       */
      public function list(int $page = 1): Response
      {
          // ...
      }
  }

• Attributes

  // src/Controller/BlogController.php
  namespace App\Controller;
  use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
  use Symfony\Component\HttpFoundation\Response;
  use Symfony\Component\Routing\Annotation\Route;
  class BlogController extends AbstractController
  {
      #[Route('/blog/{page}', name: 'blog_list', requirements: ['page' => '\d+'])]
      public function list(int $page = 1): Response
      {
          // ...
      }
  }

• YAML

  # config/routes.yaml
  blog_list:
      path:       /blog/{page}
      controller: App\Controller\BlogController::list
      defaults:
          page: 1
      requirements:
          page: '\d+'
  blog_show:
      # ...

• XML

  <!-- config/routes.xml -->
  <?xml version="1.0" encoding="UTF-8" ?>
  <routes xmlns="http://symfony.com/schema/routing"
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
      xsi:schemaLocation="http://symfony.com/schema/routing
          https://symfony.com/schema/routing/routing-1.0.xsd">
      <route id="blog_list" path="/blog/{page}" controller="App\Controller\BlogController::list">
          <default key="page">1</default>
          <requirement key="page">\d+</requirement>
      </route>
      <!-- ... -->
  </routes>

• PHP

  // config/routes.php
  use App\Controller\BlogController;
  use Symfony\Component\Routing\Loader\Configurator\RoutingConfigurator;
  return function (RoutingConfigurator $routes) {
      $routes->add('blog_list', '/blog/{page}')
          ->controller([BlogController::class, 'list'])
          ->defaults(['page' => 1])
          ->requirements(['page' => '\d+'])
      ;
  };

Now, when the user visits /blog, the blog_list route will match and $page will default to a value of 1.

Caution

You can have more than one optional parameter (e.g. /blog/{slug}/{page}), but everything after an optional parameter must be optional. For example, /{page}/blog is a valid path, but page will always be required (i.e. /blog will not match this route).

If you want to always include some default value in the generated URL (for example to force the generation of /blog/1 instead of /blog in the previous example) add the ! character before the parameter name: /blog/{!page}

As it happens with requirements, default values can also be inlined in each parameter using the syntax {parameter_name?default_value}. This feature is compatible with inlined requirements, so you can inline both in a single parameter:

• Annotations

  // src/Controller/BlogController.php
  namespace App\Controller;
  use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
  use Symfony\Component\HttpFoundation\Response;
  use Symfony\Component\Routing\Annotation\Route;
  class BlogController extends AbstractController
  {
      /**
       * @Route("/blog/{page<\d+>?1}", name="blog_list")
       */
      public function list(int $page): Response
      {
          // ...
      }
  }

• Attributes

  // src/Controller/BlogController.php
  namespace App\Controller;
  use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
  use Symfony\Component\HttpFoundation\Response;
  use Symfony\Component\Routing\Annotation\Route;
  class BlogController extends AbstractController
  {
      #[Route('/blog/{page<\d+>?1}', name: 'blog_list')]
      public function list(int $page): Response
      {
          // ...
      }
  }

• YAML

  # config/routes.yaml
  blog_list:
      path:       /blog/{page<\d+>?1}
      controller: App\Controller\BlogController::list

• XML

  <!-- config/routes.xml -->
  <?xml version="1.0" encoding="UTF-8" ?>
  <routes xmlns="http://symfony.com/schema/routing"
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
      xsi:schemaLocation="http://symfony.com/schema/routing
          https://symfony.com/schema/routing/routing-1.0.xsd">
      <route id="blog_list" path="/blog/{page<\d+>?1}"
             controller="App\Controller\BlogController::list"/>
      <!-- ... -->
  </routes>

• PHP

  // config/routes.php
  use App\Controller\BlogController;
  use Symfony\Component\Routing\Loader\Configurator\RoutingConfigurator;
  return function (RoutingConfigurator $routes) {
      $routes->add('blog_list', '/blog/{page<\d+>?1}')
          ->controller([BlogController::class, 'list'])
      ;
  };

Tip

To give a null default value to any parameter, add nothing after the ? character (e.g. /blog/{page?}).

Priority Parameter

New in version 5.1: The priority parameter was introduced in Symfony 5.1

Symfony evaluates routes in the order they are defined. If the path of a route matches many different patterns, it might prevent other routes from being matched. In YAML and XML you can move the route definitions up or down in the configuration file to control their priority. In routes defined as PHP annotations or attributes this is much harder to do, so you can set the optional priority parameter in those routes to control their priority:

• Annotations

  // src/Controller/BlogController.php
  namespace App\Controller;
  use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
  use Symfony\Component\Routing\Annotation\Route;
  class BlogController extends AbstractController
  {
      /**
       * This route has a greedy pattern and is defined first.
       *
       * @Route("/blog/{slug}", name="blog_show")
       */
      public function show(string $slug)
      {
          // ...
      }
      /**
       * This route could not be matched without defining a higher priority than 0.
       *
       * @Route("/blog/list", name="blog_list", priority=2)
       */
      public function list()
      {
          // ...
      }
  }

• Attributes

  // src/Controller/BlogController.php
  namespace App\Controller;
  use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
  use Symfony\Component\Routing\Annotation\Route;
  class BlogController extends AbstractController
  {
      /**
       * This route has a greedy pattern and is defined first.
       */
      #[Route('/blog/{slug}', name: 'blog_show')]
      public function show(string $slug)
      {
          // ...
      }
      /**
       * This route could not be matched without defining a higher priority than 0.
       */
      #[Route('/blog/list', name: 'blog_list', priority: 2)]
      public function list()
      {
          // ...
      }
  }

The priority parameter expects an integer value. Routes with higher priority are sorted before routes with lower priority. The default value when it is not defined is 0.

Parameter Conversion

A common routing need is to convert the value stored in some parameter (e.g. an integer acting as the user ID) into another value (e.g. the object that represents the user). This feature is called “param converter” and is only available when using annotations to define routes.

To add support for “param converters” we need SensioFrameworkExtraBundle:

$ composer require sensio/framework-extra-bundle

Now, keep the previous route configuration, but change the arguments of the controller action. Instead of string $slug, add BlogPost $post:

// src/Controller/BlogController.php
namespace App\Controller;
use App\Entity\BlogPost;
use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\Routing\Annotation\Route;
class BlogController extends AbstractController
{
    // ...
    /**
     * @Route("/blog/{slug}", name="blog_show")
     */
    public function show(BlogPost $post): Response
    {
        // $post is the object whose slug matches the routing parameter
        // ...
    }
}

If your controller arguments include type-hints for objects (BlogPost in this case), the “param converter” makes a database request to find the object using the request parameters (slug in this case). If no object is found, Symfony generates a 404 response automatically.

Read the full param converter documentation to learn about the converters provided by Symfony and how to configure them.

Special Parameters

In addition to your own parameters, routes can include any of the following special parameters created by Symfony:

_controller

This parameter is used to determine which controller and action is executed when the route is matched.

_format

The matched value is used to set the “request format” of the Request object. This is used for such things as setting the Content-Type of the response (e.g. a json format translates into a Content-Type of application/json).

_fragment

Used to set the fragment identifier, which is the optional last part of a URL that starts with a # character and is used to identify a portion of a document.

_locale

Used to set the locale on the request.

You can include these attributes (except _fragment) both in individual routes and in route imports. Symfony defines some special attributes with the same name (except for the leading underscore) so you can define them easier:

• Annotations

  // src/Controller/ArticleController.php
  namespace App\Controller;
  use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
  use Symfony\Component\HttpFoundation\Response;
  use Symfony\Component\Routing\Annotation\Route;
  class ArticleController extends AbstractController
  {
      /**
       * @Route(
       *     "/articles/{_locale}/search.{_format}",
       *     locale="en",
       *     format="html",
       *     requirements={
       *         "_locale": "en|fr",
       *         "_format": "html|xml",
       *     }
       * )
       */
      public function search(): Response
      {
      }
  }

• Attributes

  // src/Controller/ArticleController.php
  namespace App\Controller;
  // ...
  class ArticleController extends AbstractController
  {
      #[Route(
          path: '/articles/{_locale}/search.{_format}',
          locale: 'en',
          format: 'html',
          requirements: [
              '_locale' => 'en|fr',
              '_format' => 'html|xml',
          ],
      )]
      public function search(): Response
      {
      }
  }

• YAML

  # config/routes.yaml
  article_search:
    path:        /articles/{_locale}/search.{_format}
    controller:  App\Controller\ArticleController::search
    locale:      en
    format:      html
    requirements:
        _locale: en|fr
        _format: html|xml

• XML

  <!-- config/routes.xml -->
  <?xml version="1.0" encoding="UTF-8" ?>
  <routes xmlns="http://symfony.com/schema/routing"
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
      xsi:schemaLocation="http://symfony.com/schema/routing
          https://symfony.com/schema/routing/routing-1.0.xsd">
      <route id="article_search"
          path="/articles/{_locale}/search.{_format}"
          controller="App\Controller\ArticleController::search"
          locale="en"
          format="html">
          <requirement key="_locale">en|fr</requirement>
          <requirement key="_format">html|xml</requirement>
      </route>
  </routes>

• PHP

  // config/routes.php
  namespace Symfony\Component\Routing\Loader\Configurator;
  use App\Controller\ArticleController;
  return function (RoutingConfigurator $routes) {
      $routes->add('article_show', '/articles/{_locale}/search.{_format}')
          ->controller([ArticleController::class, 'search'])
          ->locale('en')
          ->format('html')
          ->requirements([
              '_locale' => 'en|fr',
              '_format' => 'html|xml',
          ])
      ;
  };

Extra Parameters

In the defaults option of a route you can optionally define parameters not included in the route configuration. This is useful to pass extra arguments to the controllers of the routes:

• Annotations

  // src/Controller/BlogController.php
  namespace App\Controller;
  use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
  use Symfony\Component\HttpFoundation\Response;
  use Symfony\Component\Routing\Annotation\Route;
  class BlogController extends AbstractController
  {
      /**
       * @Route("/blog/{page}", name="blog_index", defaults={"page": 1, "title": "Hello world!"})
       */
      public function index(int $page, string $title): Response
      {
          // ...
      }
  }

• Attributes

  // src/Controller/BlogController.php
  namespace App\Controller;
  use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
  use Symfony\Component\HttpFoundation\Response;
  use Symfony\Component\Routing\Annotation\Route;
  class BlogController extends AbstractController
  {
      #[Route('/blog/{page}', name: 'blog_index', defaults: ['page' => 1, 'title' => 'Hello world!'])]
      public function index(int $page, string $title): Response
      {
          // ...
      }
  }

• YAML

  # config/routes.yaml
  blog_index:
      path:       /blog/{page}
      controller: App\Controller\BlogController::index
      defaults:
          page: 1
          title: "Hello world!"

• XML

  <!-- config/routes.xml -->
  <?xml version="1.0" encoding="UTF-8" ?>
  <routes xmlns="http://symfony.com/schema/routing"
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
      xsi:schemaLocation="http://symfony.com/schema/routing
          https://symfony.com/schema/routing/routing-1.0.xsd">
      <route id="blog_index" path="/blog/{page}" controller="App\Controller\BlogController::index">
          <default key="page">1</default>
          <default key="title">Hello world!</default>
      </route>
  </routes>

• PHP

  // config/routes.php
  use App\Controller\BlogController;
  use Symfony\Component\Routing\Loader\Configurator\RoutingConfigurator;
  return function (RoutingConfigurator $routes) {
      $routes->add('blog_index', '/blog/{page}')
          ->controller([BlogController::class, 'index'])
          ->defaults([
              'page'  => 1,
              'title' => 'Hello world!',
          ])
      ;
  };

Slash Characters in Route Parameters

Route parameters can contain any values except the / slash character, because that’s the character used to separate the different parts of the URLs. For example, if the token value in the /share/{token} route contains a / character, this route won’t match.

A possible solution is to change the parameter requirements to be more permissive:

• Annotations

  // src/Controller/DefaultController.php
  namespace App\Controller;
  use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
  use Symfony\Component\HttpFoundation\Response;
  use Symfony\Component\Routing\Annotation\Route;
  class DefaultController extends AbstractController
  {
      /**
       * @Route("/share/{token}", name="share", requirements={"token"=".+"})
       */
      public function share($token): Response
      {
          // ...
      }
  }

• Attributes

  // src/Controller/DefaultController.php
  namespace App\Controller;
  use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
  use Symfony\Component\HttpFoundation\Response;
  use Symfony\Component\Routing\Annotation\Route;
  class DefaultController extends AbstractController
  {
      #[Route('/share/{token}', name: 'share', requirements: ['token' => '.+'])]
      public function share($token): Response
      {
          // ...
      }
  }

• YAML

  # config/routes.yaml
  share:
      path:       /share/{token}
      controller: App\Controller\DefaultController::share
      requirements:
          token: .+

• XML

  <!-- config/routes.xml -->
  <?xml version="1.0" encoding="UTF-8" ?>
  <routes xmlns="http://symfony.com/schema/routing"
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
      xsi:schemaLocation="http://symfony.com/schema/routing
          https://symfony.com/schema/routing/routing-1.0.xsd">
      <route id="share" path="/share/{token}" controller="App\Controller\DefaultController::share">
          <requirement key="token">.+</requirement>
      </route>
  </routes>

• PHP

  // config/routes.php
  use App\Controller\DefaultController;
  use Symfony\Component\Routing\Loader\Configurator\RoutingConfigurator;
  return function (RoutingConfigurator $routes) {
      $routes->add('share', '/share/{token}')
          ->controller([DefaultController::class, 'share'])
          ->requirements([
              'token' => '.+',
          ])
      ;
  };

Note

If the route defines several parameters and you apply this permissive regular expression to all of them, you might get unexpected results. For example, if the route definition is /share/{path}/{token} and both path and token accept /, then token will only get the last part and the rest is matched by path.

Note

If the route includes the special {_format} parameter, you shouldn’t use the .+ requirement for the parameters that allow slashes. For example, if the pattern is /share/{token}.{_format} and {token} allows any character, the /share/foo/bar.json URL will consider foo/bar.json as the token and the format will be empty. This can be solved by replacing the .+ requirement by [^.]+` to allow any character except dots.

Route Groups and Prefixes

It’s common for a group of routes to share some options (e.g. all routes related to the blog start with /blog) That’s why Symfony includes a feature to share route configuration.

When defining routes as attributes or annotations, put the common configuration in the #[Route] attribute (or @Route annotation) of the controller class. In other routing formats, define the common configuration using options when importing the routes.

• Annotations

  // src/Controller/BlogController.php
  namespace App\Controller;
  use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
  use Symfony\Component\HttpFoundation\Response;
  use Symfony\Component\Routing\Annotation\Route;
  /**
   * @Route("/blog", requirements={"_locale": "en|es|fr"}, name="blog_")
   */
  class BlogController extends AbstractController
  {
      /**
       * @Route("/{_locale}", name="index")
       */
      public function index(): Response
      {
          // ...
      }
      /**
       * @Route("/{_locale}/posts/{slug}", name="show")
       */
      public function show(Post $post): Response
      {
          // ...
      }
  }

• Attributes

  // src/Controller/BlogController.php
  namespace App\Controller;
  use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
  use Symfony\Component\HttpFoundation\Response;
  use Symfony\Component\Routing\Annotation\Route;
  #[Route('/blog', requirements: ['_locale' => 'en|es|fr'], name: 'blog_')]
  class BlogController extends AbstractController
  {
      #[Route('/{_locale}', name: 'index')]
      public function index(): Response
      {
          // ...
      }
      #[Route('/{_locale}/posts/{slug}', name: 'show')]
      public function show(Post $post): Response
      {
          // ...
      }
  }

• YAML

  # config/routes/annotations.yaml
  controllers:
      resource: '../../src/Controller/'
      type: annotation
      # this is added to the beginning of all imported route URLs
      prefix: '/blog'
      # this is added to the beginning of all imported route names
      name_prefix: 'blog_'
      # these requirements are added to all imported routes
      requirements:
          _locale: 'en|es|fr'
      # An imported route with an empty URL will become "/blog/"
      # Uncomment this option to make that URL "/blog" instead
      # trailing_slash_on_root: false
      # you can optionally exclude some files/subdirectories when loading annotations
      # exclude: '../../src/Controller/{DebugEmailController}.php'

• XML

  <!-- config/routes/annotations.xml -->
  <?xml version="1.0" encoding="UTF-8" ?>
  <routes xmlns="http://symfony.com/schema/routing"
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
      xsi:schemaLocation="http://symfony.com/schema/routing
          https://symfony.com/schema/routing/routing-1.0.xsd">
      <!--
          the 'prefix' value is added to the beginning of all imported route URLs
          the 'name-prefix' value is added to the beginning of all imported route names
          the 'exclude' option defines the files or subdirectories ignored when loading annotations
      -->
      <import resource="../../src/Controller/"
          type="annotation"
          prefix="/blog"
          name-prefix="blog_"
          exclude="../../src/Controller/{DebugEmailController}.php">
          <!-- these requirements are added to all imported routes -->
          <requirement key="_locale">en|es|fr</requirement>
      </import>
      <!-- An imported route with an empty URL will become "/blog/"
           Uncomment this option to make that URL "/blog" instead -->
      <import resource="../../src/Controller/" type="annotation"
              prefix="/blog"
              trailing-slash-on-root="false">
              <!-- ... -->
      </import>
  </routes>

• PHP

  // config/routes/annotations.php
  use Symfony\Component\Routing\Loader\Configurator\RoutingConfigurator;
  return function (RoutingConfigurator $routes) {
      // use the optional fourth argument of import() to exclude some files
      // or subdirectories when loading annotations
      $routes->import('../../src/Controller/', 'annotation')
          // this is added to the beginning of all imported route URLs
          ->prefix('/blog')
          // An imported route with an empty URL will become "/blog/"
          // Pass FALSE as the second argument to make that URL "/blog" instead
          // ->prefix('/blog', false)
          // this is added to the beginning of all imported route names
          ->namePrefix('blog_')
          // these requirements are added to all imported routes
          ->requirements(['_locale' => 'en|es|fr'])
          // you can optionally exclude some files/subdirectories when loading annotations
          ->exclude('../../src/Controller/{DebugEmailController}.php')
      ;
  };

In this example, the route of the index() action will be calledblog_indexand its URL will be/blog/{_locale}. The route of theshow() action will be called blog_show and its URL will be /blog/{_locale}/posts/{slug}. Both routes will also validate that the _locale parameter matches the regular expression defined in the class annotation.

See also

Symfony can import routes from different sources and you can even create your own route loader.

Getting the Route Name and Parameters

The Request object created by Symfony stores all the route configuration (such as the name and parameters) in the “request attributes”. You can get this information in a controller via the Request object:

// src/Controller/BlogController.php
namespace App\Controller;
use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\Routing\Annotation\Route;
class BlogController extends AbstractController
{
    /**
     * @Route("/blog", name="blog_list")
     */
    public function list(Request $request): Response
    {
        $routeName = $request->attributes->get('_route');
        $routeParameters = $request->attributes->get('_route_params');
        // use this to get all the available attributes (not only routing ones):
        $allAttributes = $request->attributes->all();
        // ...
    }
}

You can get this information in services too injecting the request_stack service to get the Request object in a service. In templates, use the Twig global app variable to get the request and its attributes:

{% set route_name = app.request.attributes.get('_route') %}
{% set route_parameters = app.request.attributes.get('_route_params') %}
{# use this to get all the available attributes (not only routing ones) #}
{% set all_attributes = app.request.attributes.all %}

Special Routes

Symfony defines some special controllers to render templates and redirect to other routes from the route configuration so you don’t have to create a controller action.

Rendering a Template Directly from a Route

Read the section about rendering a template from a route in the main article about Symfony templates.

Redirecting to URLs and Routes Directly from a Route

Use the RedirectController to redirect to other routes and URLs:

• YAML

  # config/routes.yaml
  doc_shortcut:
      path: /doc
      controller: Symfony\Bundle\FrameworkBundle\Controller\RedirectController
      defaults:
          route: 'doc_page'
          # optionally you can define some arguments passed to the route
          page: 'index'
          version: 'current'
          # redirections are temporary by default (code 302) but you can make them permanent (code 301)
          permanent: true
          # add this to keep the original query string parameters when redirecting
          keepQueryParams: true
          # add this to keep the HTTP method when redirecting. The redirect status changes
          # * for temporary redirects, it uses the 307 status code instead of 302
          # * for permanent redirects, it uses the 308 status code instead of 301
          keepRequestMethod: true
  legacy_doc:
      path: /legacy/doc
      controller: Symfony\Bundle\FrameworkBundle\Controller\RedirectController
      defaults:
          # this value can be an absolute path or an absolute URL
          path: 'https://legacy.example.com/doc'
          permanent: true

• XML

  <!-- config/routes.xml -->
  <?xml version="1.0" encoding="UTF-8" ?>
  <routes xmlns="http://symfony.com/schema/routing"
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
      xsi:schemaLocation="http://symfony.com/schema/routing
          https://symfony.com/schema/routing/routing-1.0.xsd">
      <route id="doc_shortcut" path="/doc"
             controller="Symfony\Bundle\FrameworkBundle\Controller\RedirectController">
          <default key="route">doc_page</default>
          <!-- optionally you can define some arguments passed to the route -->
          <default key="page">index</default>
          <default key="version">current</default>
          <!-- redirections are temporary by default (code 302) but you can make them permanent (code 301)-->
          <default key="permanent">true</default>
          <!-- add this to keep the original query string parameters when redirecting -->
          <default key="keepQueryParams">true</default>
          <!-- add this to keep the HTTP method when redirecting. The redirect status changes:
               * for temporary redirects, it uses the 307 status code instead of 302
               * for permanent redirects, it uses the 308 status code instead of 301 -->
          <default key="keepRequestMethod">true</default>
      </route>
      <route id="legacy_doc" path="/legacy/doc"
             controller="Symfony\Bundle\FrameworkBundle\Controller\RedirectController">
          <!-- this value can be an absolute path or an absolute URL -->
          <default key="path">https://legacy.example.com/doc</default>
          <!-- redirections are temporary by default (code 302) but you can make them permanent (code 301)-->
          <default key="permanent">true</default>
      </route>
  </routes>

• PHP

  // config/routes.php
  use App\Controller\DefaultController;
  use Symfony\Bundle\FrameworkBundle\Controller\RedirectController;
  use Symfony\Component\Routing\Loader\Configurator\RoutingConfigurator;
  return function (RoutingConfigurator $routes) {
      $routes->add('doc_shortcut', '/doc')
          ->controller(RedirectController::class)
           ->defaults([
              'route' => 'doc_page',
              // optionally you can define some arguments passed to the route
              'page' => 'index',
              'version' => 'current',
              // redirections are temporary by default (code 302) but you can make them permanent (code 301)
              'permanent' => true,
              // add this to keep the original query string parameters when redirecting
              'keepQueryParams' => true,
              // add this to keep the HTTP method when redirecting. The redirect status changes:
              // * for temporary redirects, it uses the 307 status code instead of 302
              // * for permanent redirects, it uses the 308 status code instead of 301
              'keepRequestMethod' => true,
          ])
      ;
      $routes->add('legacy_doc', '/legacy/doc')
          ->controller(RedirectController::class)
           ->defaults([
              // this value can be an absolute path or an absolute URL
              'path' => 'https://legacy.example.com/doc',
              // redirections are temporary by default (code 302) but you can make them permanent (code 301)
              'permanent' => true,
          ])
      ;
  };

Tip

Symfony also provides some utilities to redirect inside controllers

Redirecting URLs with Trailing Slashes

Historically, URLs have followed the UNIX convention of adding trailing slashes for directories (e.g. https://example.com/foo/) and removing them to refer to files (https://example.com/foo). Although serving different contents for both URLs is OK, nowadays it’s common to treat both URLs as the same URL and redirect between them.

Symfony follows this logic to redirect between URLs with and without trailing slashes (but only for GET and HEAD requests):

Sub-Domain Routing

Routes can configure a host option to require that the HTTP host of the incoming requests matches some specific value. In the following example, both routes match the same path (/) but one of them only responds to a specific host name:

• Annotations

  // src/Controller/MainController.php
  namespace App\Controller;
  use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
  use Symfony\Component\HttpFoundation\Response;
  use Symfony\Component\Routing\Annotation\Route;
  class MainController extends AbstractController
  {
      /**
       * @Route("/", name="mobile_homepage", host="m.example.com")
       */
      public function mobileHomepage(): Response
      {
          // ...
      }
      /**
       * @Route("/", name="homepage")
       */
      public function homepage(): Response
      {
          // ...
      }
  }

• Attributes

  // src/Controller/MainController.php
  namespace App\Controller;
  use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
  use Symfony\Component\HttpFoundation\Response;
  use Symfony\Component\Routing\Annotation\Route;
  class MainController extends AbstractController
  {
      #[Route('/', name: 'mobile_homepage', host: 'm.example.com')]
      public function mobileHomepage(): Response
      {
          // ...
      }
      #[Route('/', name: 'homepage')]
      public function homepage(): Response
      {
          // ...
      }
  }

• YAML

  # config/routes.yaml
  mobile_homepage:
      path:       /
      host:       m.example.com
      controller: App\Controller\MainController::mobileHomepage
  homepage:
      path:       /
      controller: App\Controller\MainController::homepage

• XML

  <!-- config/routes.xml -->
  <?xml version="1.0" encoding="UTF-8" ?>
  <routes xmlns="http://symfony.com/schema/routing"
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
      xsi:schemaLocation="http://symfony.com/schema/routing
          https://symfony.com/schema/routing/routing-1.0.xsd">
      <route id="mobile_homepage"
          path="/"
          host="m.example.com"
          controller="App\Controller\MainController::mobileHomepage"/>
      <route id="homepage" path="/" controller="App\Controller\MainController::homepage"/>
  </routes>

• PHP

  // config/routes.php
  use App\Controller\MainController;
  use Symfony\Component\Routing\Loader\Configurator\RoutingConfigurator;
  return function (RoutingConfigurator $routes) {
      $routes->add('mobile_homepage', '/')
          ->controller([MainController::class, 'mobileHomepage'])
          ->host('m.example.com')
      ;
      $routes->add('homepage', '/')
          ->controller([MainController::class, 'homepage'])
      ;
  };

The value of the host option can include parameters (which is useful in multi-tenant applications) and these parameters can be validated too with requirements:

• Annotations

  // src/Controller/MainController.php
  namespace App\Controller;
  use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
  use Symfony\Component\HttpFoundation\Response;
  use Symfony\Component\Routing\Annotation\Route;
  class MainController extends AbstractController
  {
      /**
       * @Route(
       *     "/",
       *     name="mobile_homepage",
       *     host="{subdomain}.example.com",
       *     defaults={"subdomain"="m"},
       *     requirements={"subdomain"="m|mobile"}
       * )
       */
      public function mobileHomepage(): Response
      {
          // ...
      }
      /**
       * @Route("/", name="homepage")
       */
      public function homepage(): Response
      {
          // ...
      }
  }

• Attributes

  // src/Controller/MainController.php
  namespace App\Controller;
  use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
  use Symfony\Component\HttpFoundation\Response;
  use Symfony\Component\Routing\Annotation\Route;
  class MainController extends AbstractController
  {
      #[Route(
          '/',
          name: 'mobile_homepage',
          host: '{subdomain}.example.com',
          defaults: ['subdomain' => 'm'],
          requirements: ['subdomain' => 'm|mobile'],
      )]
      public function mobileHomepage(): Response
      {
          // ...
      }
      #[Route('/', name: 'homepage')]
      public function homepage(): Response
      {
          // ...
      }
  }

• YAML

  # config/routes.yaml
  mobile_homepage:
      path:       /
      host:       "{subdomain}.example.com"
      controller: App\Controller\MainController::mobileHomepage
      defaults:
          subdomain: m
      requirements:
          subdomain: m|mobile
  homepage:
      path:       /
      controller: App\Controller\MainController::homepage

• XML

  <!-- config/routes.xml -->
  <?xml version="1.0" encoding="UTF-8" ?>
  <routes xmlns="http://symfony.com/schema/routing"
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
      xsi:schemaLocation="http://symfony.com/schema/routing
          https://symfony.com/schema/routing/routing-1.0.xsd">
      <route id="mobile_homepage"
          path="/"
          host="{subdomain}.example.com"
          controller="App\Controller\MainController::mobileHomepage">
          <default key="subdomain">m</default>
          <requirement key="subdomain">m|mobile</requirement>
      </route>
      <route id="homepage" path="/" controller="App\Controller\MainController::homepage"/>
  </routes>

• PHP

  // config/routes.php
  use App\Controller\MainController;
  use Symfony\Component\Routing\Loader\Configurator\RoutingConfigurator;
  return function (RoutingConfigurator $routes) {
      $routes->add('mobile_homepage', '/')
          ->controller([MainController::class, 'mobileHomepage'])
          ->host('{subdomain}.example.com')
          ->defaults([
              'subdomain' => 'm',
          ])
          ->requirements([
              'subdomain' => 'm|mobile',
          ])
      ;
      $routes->add('homepage', '/')
          ->controller([MainController::class, 'homepage'])
      ;
  };