Routing Phalcon

Komponen routing phalcon membantu menentukan rute yang dipetakan ke controller atau handler yang harus menerima request tersebut. Router hanya mem-parsing URI untuk menentukan informasi ini. Router memiliki dua mode: mode MVC dan modus mencocokan saja. Modus pertama adalah yg paling ideal untuk bekerja dengan aplikasi MVC.

Mendefinisikan Route Phalcon 

Phalcon \ MVC \ Router menyediakan kemampuan routing canggih. Dalam mode MVC, Anda dapat menentukan rute dan memetakannya ke controllers / action yang Anda butuhkan. Sebuah rute didefinisikan sebagai berikut:

<?php

// Create the router
$router = new \Phalcon\Mvc\Router();

//Define a route
$router->add(
    "/admin/users/my-profile",
    array(
        "controller" => "users",
        "action"     => "profile",
    )
);

//Another route
$router->add(
    "/admin/users/change-password",
    array(
        "controller" => "users",
        "action"     => "changePassword",
    )
);

$router->handle();

Metode add () menerima pola sbg parameter pertama  kemudian satu set path sebagai parameter kedua. Dalam hal ini, jika URI berisi: /admin/pengguna/my-profile, maka controller “users”  dengan action “profile” akan dieksekusi. Saat ini, router tidak mengeksekusi controller dan action, itu hanya mengumpulkan informasi ini untuk menginformasikan komponen yang benar (mis. Phalcon \ MVC \ Dispatcher ) yaitu controller / action hendak dieksekusi.

Sebuah aplikasi dapat memiliki banyak route, menentukan rute satu per satu bisa menjadi tugas yang rumit. Dalam kasus ini kita dapat membuat rute yang lebih fleksibel:

<?php

// Create the router
$router = new \Phalcon\Mvc\Router();

//Define a route
$router->add(
    "/admin/:controller/a/:action/:params",
    array(
        "controller" => 1,
        "action"     => 2,
        "params"     => 3,
    )
);

Dalam contoh di atas, dengan menggunakan wildcard kita membuat rute yang valid bagi banyak URI. Misalnya, dengan mengakses URL berikut (/admin/users/a/delete/dave/301) maka:

Controller users
Action delete
Parameter dave
Parameter 301

Metode add () menerima pola yang (opsional) memiliki placeholder yang telah ditetapkan dan regular expression. Semua pola routing harus dimulai dengan karakter slash (/). Sintaks ekspresi reguler yang digunakan adalah sama dengan PCRE regular expression . Perhatikan bahwa, tidak perlu menambahkan delimiter ekspresi reguler. Semua pola rute bersifat case-insensitive.

Parameter kedua mendefinisikan bagaimana pola uri yg cocok tadi dikaitkan ke controller / action / parameter. Bagian yg dicocokan adalah placeholder atau sub pola dibatasi oleh kurung (kurung bulat). Dalam contoh yang diberikan di atas, subpattern pertama cocok (: controller) merupakan  bagian kontroler dari rute, kedua action dan sebagainya.

Placeholder ini membantu menulis regular expression yang lebih mudah dibaca untuk pengembang dan lebih mudah untuk dipahami. Placeholder berikut ini didukung:

Placeholder Regular Expression Pemakaian
/:Modul / ([A-zA-Z0-9_-] +) Cocok hanya dengan nama modul yang valid dengan karakter alpha-numeric 
/:Controller / ([A-zA-Z0-9_-] +) Pertandingan hanya dengan nama kontroler yang valid dengan karakter alpha-numeric
/:Action / ([A-zA-Z0-9_] +) Cocok hanya dengan nama aksi yang valid dengan karakter alpha-numeric
/:Params (/. *) * Cocok dgn daftar kata opsional dipisahkan oleh garis miring. Gunakan placeholder ini hanya pada akhir rute
/:Namespace / ([A-zA-Z0-9_-] +) Cocok dengan nama namespace, satu tingkat
/:Int / ([0-9] +) Cocok hanya dengan parameter integer

Nama controller camel-case, ini berarti bahwa karakter (-) dan (_) akan dihapus dan karakter berikutnya uppercased. Misalnya, some_controller diubah menjadi SomeController.

Karena Anda dapat menambahkan banyak rute yang Anda butuhkan menggunakan add(), urutan rute yg ditambahkan menunjukkan relevansinya, rute terbaru ditambahkan memiliki lebih relevansi dari yg pertama ditambahkan. Secara internal, semua rute didefinisikan diproses dalam urutan terbalik sampai Phalcon \ MVC \ Router menemukan satu yang cocok dengan URI yg diberikan dan memrosesnya, sementara mengabaikan sisanya.

Parameter dengan Nama 

Contoh di bawah ini menunjukkan bagaimana untuk menentukan nama-nama parameter rute:

<?php

$router->add(
    "/news/([0-9]{4})/([0-9]{2})/([0-9]{2})/:params",
    array(
        "controller" => "posts",
        "action"     => "show",
        "year"       => 1, // ([0-9]{4})
        "month"      => 2, // ([0-9]{2})
        "day"        => 3, // ([0-9]{2})
        "params"     => 4, // :params
    )
);

Dalam contoh di atas, route tidak mendefinisikan “controller” atau “action”. Bagian ini diganti dengan nilai yg tetap (“posting” dan “show”). Pengguna tidak akan tahu controller yang benar-benar diarahkan oleh request. Di dalam controller, parameter bernama dapat diakses sebagai berikut:

<?php

class PostsController extends \Phalcon\Mvc\Controller
{

    public function indexAction()
    {

    }

    public function showAction()
    {

        // Return "year" parameter
        $year = $this->dispatcher->getParam("year");

        // Return "month" parameter
        $month = $this->dispatcher->getParam("month");

        // Return "day" parameter
        $day = $this->dispatcher->getParam("day");

    }

}

Perhatikan bahwa nilai-nilai parameter yang diperoleh dari dispatcher. Hal ini terjadi karena komponen yang akhirnya berinteraksi dengan driver aplikasi Anda. Selain itu, ada juga cara lain untuk membuat parameter bernama sebagai bagian dari pola:

<?php

$router->add(
    "/documentation/{chapter}/{name}.{type:[a-z]+}",
    array(
        "controller" => "documentation",
        "action"     => "show"
    )
);

Anda dapat mengakses nilai-nilainya dengan cara yang sama seperti sebelumnya:

<?php

class DocumentationController extends \Phalcon\Mvc\Controller
{

    public function showAction()
    {

        // Returns "name" parameter
        $name = $this->dispatcher->getParam("name");

        // Returns "type" parameter
        $type = $this->dispatcher->getParam("type");

    }

}

Sintaks pendek 

Jika Anda tidak suka menggunakan sebuah array untuk menentukan jalur rute, sintaks alternatif juga tersedia. Contoh berikut menghasilkan hasil yang sama:

<?php

// Short form
$router->add("/posts/{year:[0-9]+}/{title:[a-z\-]+}", "Posts::show");

// Array form
$router->add(
    "/posts/([0-9]+)/([a-z\-]+)",
    array(
       "controller" => "posts",
       "action"     => "show",
       "year"       => 1,
       "title"      => 2,
    )
);

Mencampur Sintaks Array dan pendek 

Sintaks Array dan pendek dapat dicampur untuk menentukan rute, dalam hal ini mencatat bahwa parameter bernama otomatis ditambahkan ke jalur rute sesuai dengan posisi di mana mereka didefinisikan:

<?php

//First position must be skipped because it is used for
//the named parameter 'country'
$router->add('/news/{country:[a-z]{2}}/([a-z+])/([a-z\-+])',
    array(
        'section' => 2, //Positions start with 2
        'article' => 3
    )
);

Routing ke Modul 

Anda dapat menentukan rute yang ada dalam modul. Ini khususnya cocok untuk aplikasi multi-modul. Sangat mungkin menentukan rute default yang mencakup wildcard modul:

<?php

$router = new Phalcon\Mvc\Router(false);

$router->add('/:module/:controller/:action/:params', array(
    'module' => 1,
    'controller' => 2,
    'action' => 3,
    'params' => 4
));

Dalam hal ini, nama modul harus selalu ada sebagai bagian dari URL. Sebagai contoh, URL berikut: /admin/users/mengedit/sonny, akan diproses sebagai:

Modul admin
Controller users
Action edit
Parameter sonny

Atau Anda dapat bind rute spesifik untuk modul tertentu:

<?php

$router->add("/login", array(
    'module' => 'backend',
    'controller' => 'login',
    'action' => 'index',
));

$router->add("/products/:action", array(
    'module' => 'frontend',
    'controller' => 'products',
    'action' => 1,
));

Atau bind untuk namespace tertentu:

<?php

$router->add("/:namespace/login", array(
    'namespace' => 1,
    'controller' => 'login',
    'action' => 'index'
));

namespace/class harus dipisahkan:

<?php

$router->add("/login", array(
    'namespace' => 'Backend\Controllers',
    'controller' => 'login',
    'action' => 'index'
));

Pembatasan Metode HTTP  

Bila Anda menambahkan rute menggunakan hanya add(), rute akan diaktifkan untuk metode HTTP. Kadang-kadang kita dapat membatasi rute ke metode tertentu, ini sangat berguna saat membuat aplikasi RESTful:

<?php

// This route only will be matched if the HTTP method is GET
$router->addGet("/products/edit/{id}", "Products::edit");

// This route only will be matched if the HTTP method is POST
$router->addPost("/products/save", "Products::save");

// This route will be matched if the HTTP method is POST or PUT
$router->add("/products/update")->via(array("POST", "PUT"));

Menggunakan Konversi 

Konversi membantu untuk secara bebas mengubah parameter rute sebelum meneruskannya kepada dispatcher, contoh-contoh berikut menunjukkan bagaimana untuk menggunakannya:

<?php

//The action name allows dashes, an action can be: /products/new-ipod-nano-4-generation
$router
    ->add('/products/{slug:[a-z\-]+}', array(
        'controller' => 'products',
        'action' => 'show'
    ))
    ->convert('slug', function($slug) {
        //Transform the slug removing the dashes
        return str_replace('-', '', $slug);
    });

Kelompok Rute 

Jika satu set rute memiliki path yg sama, mereka dapat dikelompokkan agar mudah mengelolanya:

<?php

$router = new \Phalcon\Mvc\Router();

//Create a group with a common module and controller
$blog = new \Phalcon\Mvc\Router\Group(array(
    'module' => 'blog',
    'controller' => 'index'
));

//All the routes start with /blog
$blog->setPrefix('/blog');

//Add a route to the group
$blog->add('/save', array(
    'action' => 'save'
));

//Add another route to the group
$blog->add('/edit/{id}', array(
    'action' => 'edit'
));

//This route maps to a controller different than the default
$blog->add('/blog', array(
    'controller' => 'blog',
    'action' => 'index'
));

//Add the group to the router
$router->mount($blog);

Anda dapat memindahkan kelompok rute ke file terpisah untuk meningkatkan organisasi dan  menggunakan kode kembali dalam aplikasi:

<?php

class BlogRoutes extends Phalcon\Mvc\Router\Group
{
    public function initialize()
    {
        //Default paths
        $this->setPaths(array(
            'module' => 'blog',
            'namespace' => 'Blog\Controllers'
        ));

        //All the routes start with /blog
        $this->setPrefix('/blog');

        //Add a route to the group
        $this->add('/save', array(
            'action' => 'save'
        ));

        //Add another route to the group
        $this->add('/edit/{id}', array(
            'action' => 'edit'
        ));

        //This route maps to a controller different than the default
        $this->add('/blog', array(
            'controller' => 'blog',
            'action' => 'index'
        ));

    }
}

Kemudian mount kelompok tsb dalam router:

<?php

//Add the group to the router
$router->mount(new BlogRoutes());

Pencocokan Rute 

Sebuah URI yang valid harus diteruskan ke Router untuk membiarkannya memeriksa rute yang cocok dengan  URI yg diberikan. Secara default, routing URI diambil dari $_GET[‘_url’] variabel yang dibuat oleh modul rewrite-engine. Contoh rule rewrite yang bekerja sangat baik dengan Phalcon adalah:

RewriteEngine On
RewriteCond   %{REQUEST_FILENAME} !-d
RewriteCond   %{REQUEST_FILENAME} !-f
RewriteRule   ^(.*)$ index.php?_url=/$1 [QSA,L]

Contoh berikut menunjukkan bagaimana menggunakan komponen ini dalam mode stand-alone:

<?php

// Creating a router
$router = new \Phalcon\Mvc\Router();

// Define routes here if any
// ...

// Taking URI from $_GET["_url"]
$router->handle();

// or Setting the URI value directly
$router->handle("/employees/edit/17");

// Getting the processed controller
echo $router->getControllerName();

// Getting the processed action
echo $router->getActionName();

//Get the matched route
$route = $router->getMatchedRoute();

Penamaan Rute 

Setiap rute yang ditambahkan ke router disimpan secara internal sebagai obyek Phalcon \ MVC \ Router \ Route . Kelas tsb merangkum semua rincian masing-masing rute. Sebagai contoh, kita dapat memberi nama rute untuk mengidentifikasi secara unik dalam aplikasi kita. Hal ini sangat berguna jika Anda ingin membuat URL dari rute tsb.

<?php

$route = $router->add("/posts/{year}/{title}", "Posts::show");

$route->setName("show-posts");

//or just

$router->add("/posts/{year}/{title}", "Posts::show")->setName("show-posts");

Kemudian, misalnya dengan menggunakan komponen Phalcon \ MVC \ Url kita dapat membuat rute dari namanya:

<?php

// returns /posts/2012/phalcon-1-0-released
echo $url->get(array(
    "for" => "show-posts",
    "year" => "2012",
    "title" => "phalcon-1-0-released"
));

Contoh Penggunaan  

Berikut ini adalah contoh rute kustom:

<?php

// matches "/system/admin/a/edit/7001"
$router->add(
    "/system/:controller/a/:action/:params",
    array(
        "controller" => 1,
        "action"     => 2,
        "params"     => 3
    )
);

// matches "/es/news"
$router->add(
    "/([a-z]{2})/:controller",
    array(
        "controller" => 2,
        "action"     => "index",
        "language"   => 1
    )
);

// matches "/es/news"
$router->add(
    "/{language:[a-z]{2}}/:controller",
    array(
        "controller" => 2,
        "action"     => "index"
    )
);

// matches "/admin/posts/edit/100"
$router->add(
    "/admin/:controller/:action/:int",
    array(
        "controller" => 1,
        "action"     => 2,
        "id"         => 3
    )
);

// matches "/posts/2010/02/some-cool-content"
$router->add(
    "/posts/([0-9]{4})/([0-9]{2})/([a-z\-]+)",
    array(
        "controller" => "posts",
        "action"     => "show",
        "year"       => 1,
        "month"      => 2,
        "title"      => 4
    )
);

// matches "/manual/en/translate.adapter.html"
$router->add(
    "/manual/([a-z]{2})/([a-z\.]+)\.html",
    array(
        "controller" => "manual",
        "action"     => "show",
        "language"   => 1,
        "file"       => 2
    )
);

// matches /feed/fr/le-robots-hot-news.atom
$router->add(
    "/feed/{lang:[a-z]+}/{blog:[a-z\-]+}\.{type:[a-z\-]+}",
    "Feed::get"
);

// matches /api/v1/users/peter.json
$router->add('/api/(v1|v2)/{method:[a-z]+}/{param:[a-z]+}\.(json|xml)',
    array(
        'controller' => 'api',
        'version' => 1,
        'format' => 4
    )
);

Waspadalah terhadap karakter yang diizinkan dalam ekspresi reguler untuk kontroler dan namespace. Karena ini menjadi nama kelas dan pada gilirannya akan diteruskan melalui  file sistem, dapat digunakan oleh penyerang untuk membaca file yang tidak dibenarkan. Sebuah ekspresi reguler yg aman adalah: / ([a-zA-Z0-9_-] +)

Perilaku bawaan 

Phalcon \ MVC \ Router memiliki perilaku default yg menyediakan routing yang sangat sederhana yang selalu menerima URI yang sesuai dengan pola berikut: /:controller/:action/:params

Misalnya, untuk URL seperti ini http://phalconphp.com/documentation/show/about.html, router ini akan menerjemahkannya sebagai berikut:

Controller dokumentasi
Action menunjukkan
Parameter about.html

Jika Anda tidak ingin menggunakan ini sebagai default rute dalam aplikasi Anda, Anda harus membuat router yg memberikan parameter false:

<?php

// Create the router without default routes
$router = new \Phalcon\Mvc\Router(false);

Mengatur rute default 

Bila aplikasi Anda diakses tanpa rute, maka rute ‘/’ yang akan digunakan untuk menentukan apa jalan harus digunakan untuk menampilkan halaman awal situs / aplikasi:

<?php

$router->add("/", array(
    'controller' => 'index',
    'action' => 'index'
));

Path yg Tidak Ditemukan  

Jika tidak ada yang cocok pada rute yg telah ditentukan, Anda dapat menentukan sekelompok path yang akan digunakan dalam skenario ini:

<?php

//Set 404 paths
$router->notFound(array(
    "controller" => "index",
    "action" => "route404"
));

Mengatur default path

Anda bisa menentukan nilai default untuk jalur umum semisal modul, controller atau action. Ketika rute tidak menemukan nilai path tsb, dapat secara otomatis diisi oleh router:

<?php

//Setting a specific default
$router->setDefaultModule('backend');
$router->setDefaultNamespace('Backend\Controllers');
$router->setDefaultController('index');
$router->setDefaultAction('index');

//Using an array
$router->setDefaults(array(
    'controller' => 'index',
    'action' => 'index'
));

Menangani garis miring tambahan/sufix 

Kadang-kadang rute dapat diakses dengan ekstra garis miring yg mengikuti atau bisa jadi di akhir rute, garis miring tambahan tsb akan berakibat pada status yang tidak ditemukan di dispatcher. Anda dapat mengatur router untuk secara otomatis menghapus garis miring dari akhir ditangani dengan rute:

<?php

$router = new \Phalcon\Mvc\Router();

//Remove trailing slashes automatically
$router->removeExtraSlashes(true);

Atau, Anda dapat memodifikasi rute tertentu yg secara opsional menerima garis miring dibelakang:

<?php

$router->add(
    '/{language:[a-z]{2}}/:controller[/]{0,1}',
    array(
        'controller' => 2,
        'action'     => 'index'
    )
);

Pencocokan Callback 

Kadang-kadang, rute harus dicocokan pada kondisi tertentu, Anda dapat menambahkan kondisi pengecualian untuk suatu rute menggunakan callback ‘beforeMatch’, jika fungsi ini return false, rute akan dianggak sebagai tidak-cocok:

<?php

$router->add('/login', array(
    'module' => 'admin',
    'controller' => 'session'
))->beforeMatch(function($uri, $route) {
    //Check if the request was made with Ajax
    if ($_SERVER['HTTP_X_REQUESTED_WITH'] == 'xmlhttprequest') {
        return false;
    }
    return true;
});

Anda dapat kembali menggunakan kondisi ekstra dalam kelas:

<?php

class AjaxFilter
{
    public function check()
    {
        return $_SERVER['HTTP_X_REQUESTED_WITH'] == 'xmlhttprequest';
    }
}

Dan menggunakan kelas ini bukannya fungsi anonim:

<?php

$router->add('/get/info/{id}', array(
    'controller' => 'products',
    'action' => 'info'
))->beforeMatch(array(new AjaxFilter(), 'check'));

Batasan Hostname 

Router memungkinkan untuk mengatur batasan hostname, ini berarti bahwa rute tertentu atau sekelompok rute dapat dibatasi hanya cocok jika rute juga memenuhi batasan hostname:

<?php

$router->add('/login', array(
    'module' => 'admin',
    'controller' => 'session',
    'action' => 'login'
))->setHostName('admin.company.com');

Hostname juga bisa berupa ekspresi reguler:

<?php

$router->add('/login', array(
    'module' => 'admin',
    'controller' => 'session',
    'action' => 'login'
))->setHostName('([a-z+]).company.com');

Dalam kelompok rute Anda dapat mengatur kendala hostname yang berlaku untuk setiap rute di grup:

<?php

//Create a group with a common module and controller
$blog = new \Phalcon\Mvc\Router\Group(array(
    'module' => 'blog',
    'controller' => 'posts'
));

//Hostname restriction
$blog->setHostName('blog.mycompany.com');

//All the routes start with /blog
$blog->setPrefix('/blog');

//Default route
$blog->add('/', array(
    'action' => 'index'
));

//Add a route to the group
$blog->add('/save', array(
    'action' => 'save'
));

//Add another route to the group
$blog->add('/edit/{id}', array(
    'action' => 'edit'
));

//Add the group to the router
$router->mount($blog);

Sumber URI  

Secara default informasi URI diperoleh dari variabel $_GET[‘_url’] , ini akan diteruskan oleh Rewrite-Engine untuk Phalcon, Anda juga dapat menggunakan $_SERVER[‘REQUEST_URI’] jika diperlukan:

<?php

$router->setUriSource(Router::URI_SOURCE_GET_URL); // use $_GET['_url'] (default)
$router->setUriSource(Router::URI_SOURCE_SERVER_REQUEST_URI); // use $_SERVER['REQUEST_URI'] (default)

Atau Anda dapat secara manual meneruskan URI dengan metode ‘handle’:

<?php

$router->handle('/some/route/to/handle');

Pengujian rute Anda 

Karena komponen ini tidak memiliki dependensi, Anda dapat membuat sebuah file seperti yang ditunjukkan di bawah ini untuk menguji rute Anda:

<?php

//These routes simulate real URIs
$testRoutes = array(
    '/',
    '/index',
    '/index/index',
    '/index/test',
    '/products',
    '/products/index/',
    '/products/show/101',
);

$router = new Phalcon\Mvc\Router();

//Add here your custom routes
//...

//Testing each route
foreach ($testRoutes as $testRoute) {

    //Handle the route
    $router->handle($testRoute);

    echo 'Testing ', $testRoute, '<br>';

    //Check if some route was matched
    if ($router->wasMatched()) {
        echo 'Controller: ', $router->getControllerName(), '<br>';
        echo 'Action: ', $router->getActionName(), '<br>';
    } else {
        echo 'The route wasn\'t matched by any route<br>';
    }
    echo '<br>';

}

Penjelasan Router 

Komponen ini memberikan varian yang terintegrasi dengan layanan annotations. Menggunakan strategi ini Anda dapat menulis rute langsung dalam kontroler bukannya menambahkan dalam pendaftaran layanan:

<?php

$di['router'] = function() {

    //Use the annotations router
    $router = new \Phalcon\Mvc\Router\Annotations(false);

    //Read the annotations from ProductsController if the uri starts with /api/products
    $router->addResource('Products', '/api/products');

    return $router;
};

Penjelasan/anotasi dapat didefinisikan dengan cara berikut:

<?php

/**
 * @RoutePrefix("/api/products")
 */
class ProductsController
{

    /**
     * @Get("/")
     */
    public function indexAction()
    {

    }

    /**
     * @Get("/edit/{id:[0-9]+}", name="edit-robot")
     */
    public function editAction($id)
    {

    }

    /**
     * @Route("/save", methods={"POST", "PUT"}, name="save-robot")
     */
    public function saveAction()
    {

    }

    /**
     * @Route("/delete/{id:[0-9]+}", methods="DELETE",
     *      conversors={id="MyConversors::checkId"})
     */
    public function deleteAction($id)
    {

    }

    public function infoAction($id)
    {

    }

}

Hanya metode ditandai dengan penjelasan yang valid digunakan sebagai rute. Daftar penjelasan yang didukung:

Nama Deskripsi Pemakaian
RoutePrefix Sebuah awalan yg mendahului setiap uri rute. Penjelasan ini harus ditempatkan di docblock kelas @RoutePrefix(“/api/products”)
Route Penjelasan ini menandai metode sebagai rute. Penjelasan ini harus ditempatkan dalam docblock metode @Route(“/api/products/show”)
Get Penjelasan ini menandai metode sebagai rute khusus metode HTTP GET @Get(“/api/produk/search”)
Post Penjelasan ini menandai metode sebagai rute khusus metode HTTP POST @Post(“/api/produk/save”)
Put Penjelasan ini menandai metode sebagai rute khusus metode HTTP untuk PUT @Put(“/api/produk/save”)
Delete Penjelasan ini menandai metode sebagai rute khusus metode HTTP untuk DELETE @Delete(“/api/produk/menghapus/{id}”)
Options Penjelasan ini menandai metode sebagai rute khusus metode HTTP untuk OPTIONS @Option(“/api/produk/info”)

Untuk anotasi yang menambah rute, parameter berikut ini didukung:

Nama Deskripsi Pemakaian
methods Tentukan satu atau lebih metode HTTP dibolehkan @Route(“/api/produk”, methods={“GET”, “POST”})
name Tentukan nama untuk rute @Route(“/api/produk”, name=”get-produk”)
paths Sebuah array path seperti yang dioper ke Phalcon\MVC\Router::add @Route(“/posts/{id}/{slug}”, paths={module=”backend”})
conversors Sebuah hash dari conversors untuk diterapkan pada parameter @Route(“/posts/{id}/{slug}”, conversors={id=”MyConversor::getId”})

Jika rute dipetakan ke kontroler di dalam modul, lebih baik menggunakan metode addModuleResource:

<?php

$di['router'] = function() {

    //Use the annotations router
    $router = new \Phalcon\Mvc\Router\Annotations(false);

    //Read the annotations from Backend\Controllers\ProductsController if the uri starts with /api/products
    $router->addModuleResource('backend', 'Products', '/api/products');

    return $router;
};

Mendaftarkan Instance Router 

Anda dapat mendaftar router saat pendaftaran layanan dengan Phalcon ketergantungan injector untuk membuatnya tersedia dalam controller.

Anda perlu menambahkan kode di bawah ini dalam file bootstrap Anda (misalnya index.php atau app / config / services.php jika Anda menggunakan Phalcon Developer Tools )

<?php

/**
* add routing capabilities
*/
$di->set('router', function(){
    require __DIR__.'/../app/config/routes.php';
    return $router;
});

Anda perlu membuat app / config / routes.php dan menambahkan  kode inisialisasi router, misalnya:

<?php

$router = new \Phalcon\Mvc\Router();

$router->add("/login", array(
    'controller' => 'login',
    'action' => 'index',
));

$router->add("/products/:action", array(
    'controller' => 'products',
    'action' => 1,
));

return $router;

Menerapkan Router Anda sendiri 

Antarmuka Phalcon \ MVC \ routerinterface harus diimplementasikan untuk membuat router Anda sendiri menggantikan yang disediakan oleh Phalcon.

 

Terjemahan dr Routing Phalcon
http://docs.phalconphp.com/en/latest/reference/routing.html