PHPDeveloper.orghttp://www.phpdeveloper.org
Up-to-the Minute PHP News, views and communityen-usTue, 03 Mar 2015 14:31:53 -060030http://www.phpdeveloper.org/news/21854http://www.phpdeveloper.org/news/21854
The Laravel Podcast has released their latest episode, Episode #18: Laravel 5 Routing, the War over PHP Annotations, and The Secret Weapon(tm). Join hosts Shawn McCool, Taylor Otwell and Jeffrey Way as they talk all things Laravel.

In this episode, we discuss new Laravel 5 features including annotated routing and middlewares. We discuss some motivations and guiding forces that make Laravel what it is. Also, hints about Jeffrey and Taylor's secret new project. The referenced article by @everzet can be found here: http://everzet.com/post/99045129766/introducing-modelling-by-example.

Link: http://www.buzzsprout.com/11908/212256-episode-18-laravel-5-routing-the-war-over-php-annotations-and-the-secret-weapon-tm]]>Mon, 20 Oct 2014 11:05:05 -0500http://www.phpdeveloper.org/news/21551http://www.phpdeveloper.org/news/21551
The SitePoint PHP blog has a new post by Francesco Malatesta showing how to use the PHPRoute routing library to handle routing of requests quickly and easily.

PHRoute is an interesting package: it's a fast regular expression based router that you can easily implement in small to medium projects. However, it's not just very fast: there are filters, filter groups and named routes. You can also use a basic controllers system if things are getting bigger. That said, today we will see how to use it and how to implement its features in a sample project. Also, we are going to see what's under the hood: PHRoute is a result of many experiments and tests by different people.

Once installed (via Composer), he shows you how to use it in a simple project that manages book information, including authors and categories. He includes some code examples showing how to set up some simple routes and handle the execution of a closure to fulfill the request. He also shows how to work with parameters in routes, using different verbs, working with filters and working with route grouping. The post ends with a look at using controllers with the routing, making it easier to create more modular architectures.

Link: http://www.sitepoint.com/fast-php-routing-phroute/]]>Fri, 08 Aug 2014 12:16:28 -0500http://www.phpdeveloper.org/news/21451http://www.phpdeveloper.org/news/21451
In his latest post Paul Jones comes back to his proposed application structure, the idea of Action-Domain-Responder, and answers some questions about where content negotiation happens and routing.

While talking about Action-Domain-Responder on the Crafting Code Tour, one of the common questions I got was: "Where does content negotiation happen?" My response was always: "Where does it happen in Model-View-Controller?" That opened up a discussion on how content negotiation is a tricky bit that can go in different places, depending on how you want the concerns separated, and is not a problem specific to ADR.

He goes on and tries to answer the question a bit better, pointing out that "it's a problem for everyone" isn't really good enough to take action on. He works through the different pieces of the ADR pattern, trying to reason out where the right fit is. He suggests a "first filter" on the Controller level, more specifically at the Router level. That's not to say that the Router needs to know about content handling, but it does need to know how to pass that information on.

Link: http://paul-m-jones.com/archives/6020]]>Fri, 18 Jul 2014 10:17:57 -0500http://www.phpdeveloper.org/news/21059http://www.phpdeveloper.org/news/21059
If you're relatively new to using the Symfony2 framework, you might be wondering about some of the things happening during requests to your application. One of these things is the routing and handling of each request. In this new post from NetTuts.com they introduce you to the foundations of Symfony2 routing in a screencast.

In the last video, I said we'd take a look at controllers next, but I actually feel it may be easier to learn the framework in a slightly different order. Instead, we're going to learn about the basics of Symfony 2 routing, to give our applications clean and pretty URLs and make it easy to manage our applications URLs and links. We're not going to get too detailed, as Symfony's routing can do quite a bit, but we'll at least cover what we need to know by keeping it straight and to the point.

The screencast is a bit less than 10 minutes long and provides an overview of the routing, how it interacts with bundles and controllers. There's also a bit about using annotations to help define routing information directly in the controller.

Link: http://code.tutsplus.com/tutorials/routing-overview-basics-in-symfony-2--cms-20754]]>Thu, 17 Apr 2014 12:10:12 -0500http://www.phpdeveloper.org/news/20994http://www.phpdeveloper.org/news/20994
Matthew Setter has a new post to his Master Zend Framework site today showing you how to use child and segment routes to create a routing table in your Zend Framework v2 application. These routes are "sub-routes" underneath a main route defined in the main router configuration.

Routing is one of the key requirements in modern applications, especially in Zend Framework 2; but they shouldn't be overly-complicated. Today, we're going to look at how to build a routing table, simply and easily using child and segment routes. [...] But how would we do that? Gladly, it's quite simply, using a combination of [the] two route types: Segment and Child Routes. I've made a complete example, which's available in this Gist. Feel free to skip straight to that. But otherwise, let's step through the annotated version together.

He sets the stage with an example in a "writing pipeline" application that helps him predict his income from his freelance writing. He describes the main controllers and the routing configurations they might share. In his example code, he shows how to define the routes and modify them to use segments and child routes to handle constraints. There's also a section about extracting out the segments from the route.

Link: http://www.masterzendframework.com/tutorial/child-and-segment-routes]]>Thu, 03 Apr 2014 11:15:05 -0500http://www.phpdeveloper.org/news/20802http://www.phpdeveloper.org/news/20802
In his latest postNikita Popov talks about routing and regular expresions. He also shares some work he's done to create a fast request router using them in "userland" code instead of a C extension.

Some time ago I stumbled on the Pux routing library, which claims to implement a request router that is many orders of magnitude faster than the existing solutions. In order to accomplish this, the library makes use of a PHP extension written in C. However, after a cursory look at the code I had the strong suspicion that the library was optimizing the wrong parts of the routing process. [...] To investigate the issue further I wrote a small routing library: FastRoute. This library implements the dispatch process that I will describe below.

He includes some benchmarks against the results from a C-based routing engine showing his solution performing slightly better. What he's really talking about, though, is the dispatch process in general, not just his implementation. He talks about "the routing problem" many engines face - having to loop through a potentially large set of routes to find a match. He offers an alternative using regular expressions and compiling all of the routes down into one large expression. He includes a simple implementation of the method and reruns the same benchmarks with some different results. He offers one potential solution for speeding it up using "chunked expressions" to break it down into more manageable matching. He includes benchmarks for this last solution as well, showing a slight improvement.

Link: http://nikic.github.io/2014/02/18/Fast-request-routing-using-regular-expressions.html]]>Wed, 19 Feb 2014 09:03:07 -0600http://www.phpdeveloper.org/news/20797http://www.phpdeveloper.org/news/20797
The CodeHeaps.com tutorial site, they've posted the latest in their tutorial series creating a blog with the popular Laravel framework. In the first part they looked at models and database seeing, in part two they focused on controllers and in this latest part they focus on routing.

In this article we will create a simple blog using Laravel 4. Our blog application will have the following features: display posts with read more links on home page, search posts on blog, display a single post with comments and allow users to post comments. Administrator will be able to perform CRUD operations on posts and comments [and ] will be able to moderate comments.

In the three parts so far they show some simple migrations to create the "posts" and "comments" table and some basic (lorem ipsum) content. They create a basic "blog" controller and login functionality to identify the current user. Finally, they create the routing to hook it all together including some "before" hooks and authentication protection on the administrative areas.

Link: http://www.codeheaps.com/php-programming/creating-a-blog-using-laravel-4-part-3-routing/]]>Tue, 18 Feb 2014 10:53:20 -0600http://www.phpdeveloper.org/news/20358http://www.phpdeveloper.org/news/20358
On the SitePoint PHP blog today Sandeep Panda has a new article looking at routing, using Active Record and caching with the Yii Framework. The Yii framework is a " a high-performance PHP framework best for developing Web 2.0 applications".

Almost all modern web apps have 3 major concerns: Retrieving data from a database easily and effectively, caching the web content and URL rewriting to create user friendly URLs. Yii, like any other good framework, offers simple and easy solutions to all of the above. [...] In this tutorial we will look at how Yii greatly simplifies the development of database driven websites with its Active Record support. Additionally, Yii lets you further improve your websites by implementing user friendly URLs and powerful caching techniques.

He creates a simple application based on the Yii framework skeleton called "gadgetstore" that works with fictional phone data. He shows how to set up a few sample routes and adding the "phone" table to the database. He then uses the framework's tools to auto-generate the model and shows the save/delete operations. He then creates the "Phone" controller and an add action to handle the create submissions. Finally, he gets into caching the response data and uses the built-in "cache" function for the models to store the results of a "findAll" request.

Link: http://www.sitepoint.com/yii-routing-active-record-caching/]]>Thu, 07 Nov 2013 09:37:31 -0600http://www.phpdeveloper.org/news/20346http://www.phpdeveloper.org/news/20346
On the Aura framework blog there's a new post with a sneak peek at Aura.Dispatcher to handle the mapping between names and objects to handle the given request. The Aura framework provides high-quality, well-tested, standards-compliant, decoupled libraries that can be used in any codebase. This means you can use as much or as little of the project as you like.

In the lessons learned post, I talked about how Aura was born of the idea that we could extract independent decoupled packages from Solar, and how in doing so, we discovered that some of those extracted packages themsleves could be further split into independent pieces. Previously, I wrote about Aura.Sql-v2, Aura.Sql_Query, and Aura.Sql_Schema as extractions from a single Aura.Sql package. Today, I'm going to talk about Aura.Dispatcher as a combined extraction from three separate packages.

He starts off with a look at dispatchers in general, noting that they're usually used with request routing but the concept isn't limited to just that. He points out that CLI dispatching, as it turns out, is a lot like web request handling. The component makes routing both sides equally simple and could also be used as something like a micro-framework router. The post finishes up with this concept, talking about the evolution from micro- to full-stack framework structures and how the component could help.

Link: http://auraphp.com/blog/2013/11/04/aura-v2-dispatcher/]]>Tue, 05 Nov 2013 11:30:32 -0600http://www.phpdeveloper.org/news/20220http://www.phpdeveloper.org/news/20220
On the ServerGrove blog today Raul Fraile has posted another in their spotlights on individual components of the Symfony2 framework. This time the focus is on Routing, the component that, true to its name, handles the translation from HTTP request to the code path to handle it.

This is the third post of the Symfony2 components series, and this time we are going to cover the Routing component, which maps an HTTP request to a set of configuration variables, which can then be used to execute code using PHP callables. The component simplifies the task of defining friendly URLs, without having to worry about complex and cryptic .htaccess files - hurray!.

He talks about the four main parts of the component - the RouteCollection, RequestContext, UrlMatcher and UrlGenerator - and gives a simple example of their use outside of the full framework context. These include normal paths, ones with parameters and constraints. There's also a bit about performance and its use of "matcher dumpers" to compile down and decrease the overall processing time per request.