News Feed

News Archive
feed this:

Looking for more information on how to do PHP the right way? Check out PHP: The Right Way

SitePoint PHP Blog:
Fast PHP Routing with PHRoute
August 08, 2014 @ 12:16:28

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.

0 comments voice your opinion now!
routing phproute tutorial introduction


Paul Jones:
Action-Domain-Responder, Content Negotiation, and Routers
July 18, 2014 @ 10:17:57

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.

0 comments voice your opinion now!
action domain responder content negotiation routing

Routing Overview & Basics in Symfony 2
April 17, 2014 @ 12:10:12

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 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.

0 comments voice your opinion now!
routing basics symfony2 introduction screencast demo


Master Zend Framework:
HowTo Use Child and Segment Routes to Build Simple Routing Tables
April 03, 2014 @ 11:15:05

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.

0 comments voice your opinion now!
child segment routes tutorial routing zendframework2


Nikita Popov:
Fast request routing using regular expressions
February 19, 2014 @ 09:03:07

In his latest post Nikita 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.

0 comments voice your opinion now!
regularexpression routing dispatch engine chunk compile

Creating a Blog Using Laravel 4 (Series)
February 18, 2014 @ 10:53:20

The 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.

0 comments voice your opinion now!
series tutorial laravel framework blog beginner model controller routing


SitePoint PHP Blog:
Yii Routing, Active Record and Caching
November 07, 2013 @ 09:37:31

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.

0 comments voice your opinion now!
yii framework caching activerecord routing


Aura Framework Blog:
A Peek At Aura v2 -- Aura.Dispatcher
November 05, 2013 @ 11:30:32

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.

0 comments voice your opinion now!
aura framework component spotlight dispatcher routing


ServerGrove Blog:
Symfony2 components overview Routing
October 08, 2013 @ 11:45:24

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.

0 comments voice your opinion now!
symfony2 framework component routing example introduction


Google Developer Blog:
Getting started with Twilio on Google App Engine for PHP
August 06, 2013 @ 11:55:51

On the Google Developers Blog there's a new post from Keith Casey showing you how to get started with Twilio on a Google App engine, PHP-based application. It requires the use of the latest Twilio helper library, so be sure to upgrade.

I've wanted to explore Google App Engine for years. Between its SLA, automatic scaling, and queuing system, it has always been compelling. Unfortunately, since my Python skills are somewhere between "Hello World" and "OMG What did I just do!?" I decided to save myself the embarrassment. When Google announced PHP support for App Engine, I was both ecstatic and intrigued about what might be possible. To get something running in just a few minutes, I decided to use our Twilio PHP helper.

He walks you through the full process - setting up an App Engine account and instance, using the a href="">helper library and how you'll need to configure your routing for the files in your application.

0 comments voice your opinion now!
google appengine twilio helper tutorial routing


Community Events

Don't see your event here?
Let us know!

podcast install framework application interview list community configure release code wordpress bugfix library developer language introduction laravel threedevsandamaybe api series

All content copyright, 2014 :: - Powered by the Solar PHP Framework