Open this article in Dearbloggers App
PHP is a powerful language, with a wide range of offerings that make utilizing it for anything from basic websites to complex APIs a very strong proposition. It’s got a wonderful low barrier of entry, a gigantic ecosystem of solutions, and a variety of framework implementations that can make it do almost whatever you dream.
In this piece, we’re going to discuss five lightweight PHP frameworks for building REST APIs. We’ll discuss a bit of their history, highlight their pros and cons, and discuss some alternatives that you can start implementing today.
Laravel is an open-source, free PHP framework from Taylor Otwell based around the model-view-controller (MVC) architectural concept. The framework was first released in beta form in June of 2011 and has since been continuously developed and expanded from its initial versions.
First and foremost, Laravel is extremely Configurable and Extendable. Due to the fact that it’s open-source, free, and very popular, Laravel has a variety of derivatives, forks, manipulations, and extensions that make it pretty much able to do whatever you might have it do.
Finally, and perhaps one of the strongest selling points for Laravel, there’s an included authentication package for APIs in the form of Laravel Passport. Passport is a full OAuth 2.0 server implementation that is touted as being configurable in “minutes”.
With all that being said, Laravel does have some issues that might make it hard to adopt. Laravel is far too dependent on database queries, often calling in a manner that some devs would consider “excessive.” While this isn’t really a problem with larger services, as a lightweight framework, this does become a problem, causing backend congestion.
Lumen is intimately related to Laravel, having been developed by Taylor Otwell to quickly build Laravel microservices in a rapidly deployable way. Since 5.2, however, it has moved in a slightly different direction, eschewing a lot of the holdovers to become much sleeker than Laravel.
Notably, Lumen as of version 5.2 no longer includes sessions and views as part of its framework, relegating that to Laravel alone. This results in a much leaner framework than Laravel and shifts the focus more towards stateless APIs.
Lumen is basically Laravel, but fast. By getting rid of a lot of the extra components that don’t mesh well with stateless APIs, Lumen has managed to slim down considerably, making it an extremely fast and lightweight solution over other frameworks.
Due in large part to this and other design choices, Lumen is a great choice for microservices and optimizing APIs for quick response time. The framework has been designed from day one to be fast more than anything else, so it’s often quoted as an optimal choice for speed-dependent implementations. Additionally, Lumen is simple in its syntax, allowing for ease of deployment.
One of the greatest strengths of Lumen is a non-measurable entity — the fact that it was designed by Otwell, who has quite a bit of experience in microservices framework, is something to be mentioned. Additionally, Lumen projects can simply be dropped into a Laravel installation for instant functionality, meaning that anything written for Lumen can function with all the benefits and features in Laravel proper.
Interestingly enough, most of the cons of Lumen are actually derived from the same place its pros are — its intimate relationship with Laravel. While much has diverged in development, there’s still a lot of small handguns from Laravel that make Lumen imperfect.
Perhaps the biggest draw of Wave is that it is very, very small, but gets so much done with so little. Wave boasts some pretty impressive support that other frameworks don’t, notably supporting full UTF–8 and jQuery natively. Additionally, Wave supports a wide range of data return types, including XML, CSV, JSON, HTML, native PHP, and more.
The biggest negative, however, is the fact that it’s so different from other implementations. With so many frameworks being based on previous efforts, such as Laravel and Lumen, having a novel approach is both a blessing and a curse, requiring developers to essentially relearn what would otherwise be implied in other frameworks.
You can certainly get around this by adding additional implementations, extensions, etc., but at a certain point, this becomes untenable. This isn’t necessarily a problem with the framework itself, of course, but it’s definitely something to consider. Wave Framework, perhaps more than any other framework on this list, is truly a “micro” framework.
Silex is a bit interesting. Written in PHP and based on Symfony, Silex is scalable in every sense of the word — the design concept from the very beginning was to make the framework as lightweight as you need it to be, enabling additional functionality through base extensions.
As such, Silex currently exists in two forms. There is the “fat” version, which includes a template engine, Symfony components, database abstraction, a Twig wrapper, and more, and then there is the “slim” version, which contains just the basic routing engine and the various methods of tying in additional functionality through extensions.
Judging Silex is very hard to do in a general sense when we discuss lightweight frameworks because so much of it depends entirely on which version you use.
With the fat version, the integration of Symfony’s HttpKernel to abstract requests and responses aids drastically in application testing, which can speed up time to market by leaps and bounds. The use of Pimple for dependency injection makes for Application classes which can be used as if they were arrays, making Silex classes extremely flexible.
With all of that being said, the double choice is somewhat of an issue as much as it’s a feature. Depending on which version you get, Silex might not actually do what you want it to do out of the box and discovering this only after a long process of attempting to get it to do what you want is perhaps one of the most frustrating things a developer can experience.
Limonade is, like Wave, all about simplicity and lightweight functionality. Stated by the developers to be “inspired by frameworks like Sinatra or Camping in Ruby, or Orbit in Lua,” Limonade is relatively easy to implement and use, and is very attractive to developers looking for a simple, straight forward implementation.
Limonade’s main draw is the fact that it’s entirely self-contained. Limonade arrives in a single file, and because of how it’s structured, everything is done within the contents of the lib folder. Limonade is designed to be extremely lightweight, and it really comes through in how it’s packaged and how developers interact with it.
Unfortunately, that minimalism is part of the problem. Limonade is extremely small, both in terms of size and in what it can do compared to its contemporaries.
And while this would generally not be a problem with something like Silex, which can be expanded upon, Limonade is self-contained and has no “fat” and “slim” version. This has resulted in a situation where even though Limonade is just as useful as it was when it was first published, it’s been drastically overshadowed by more modern frameworks.