Auf der Suche nach dem perfekten PHP Application Framework

Das mit dem lustigen Pilz

PRADO is a component-based and event-driven framework for rapid Web programming in PHP 5. PRADO reconceptualizes Web application development in terms of components, events and properties instead of procedures, URLs and query parameters.

A PRADO component is a combination of a specification file (in XML), an HTML template and a PHP class. PRADO components are combined together to form larger components or complete PRADO pages.

Developing PRADO Web applications mainly involves instantiating prebuilt and application-specific component types, configuring them by setting their properties, responding to their events by writing handler functions, and composing them into application tasks.

binarycloud is a web application framework for the PHP language. It provides a set of services that are frequently used when writing web applications and helps to improve reuseability by providing a modular application infrastructure.

The centerpiece of this framework is the presentation system (Node Tree), which enforces a strict separation of your business logic from your presentation logic. The Node tree uses a unique, hierarchical scale free object design that is extremely powerful because applications can be arbitrarily infinitely nested. The Smarty template engine is the default rendering layer and is tightly integrated into binarycloud.

Just another framework? - there aren’t many frameworks that have millions of dollars running through them, installations at fortune 500 companies and brutal production runs in load balanced installations. If you need serious tools, this is the place.

Mojavi is an open-source MVC (model-view-controller) php framework, licensed under the LGPL. Developing with Mojavi php framework enables you to easily divide your web application into tiers, allowing for independent custom web application development.

Features
Modular Design
Filter Chains
Action Chains
Customizable User Containers
Parameter Validation
Validator Library
Built-in Authentication

What is Cake?
Cake is a rapid development framework for PHP which uses commonly known design patterns like ActiveRecord, Association Data Mapping, Front Controller and MVC. Our primary goal is to provide a structured framework that enables PHP users at all levels to rapidly develop robust web applications, without any loss to flexibility.

Why use Cake?
Cake takes the monotony out of the development process, allowing you to get on with what really matters: creating a secure, stable application quickly with code that can be maintained easily.

Regardless of your application's goals, many developers end up re-coding a number of foundational elements: database objects, connecting database objects to the database (and each other), forms, form validation, and more. If you are tired of maintaining old applications because the code has turned into spaghetti, then try Cake. It is a lot sweeter.

Using Cake allows you to get started with your application right now. It handles database interactions, associations, debugging, templating, and even does some handy dandy things like pretty URLs and access control lists.

Tired of repeating yourself? Ever copied and pasted your code? Want to get your applications into production quicker? Cake is for you!

Key Features
compatibile with PHP4 and PHP5
supplies integrated CRUD for database and simplified querying
request dispatcher with good looking, custom URLs
fast, flexible templating (PHP syntax with helper methods)
works from any website subdirectory, with little to no Apache configuration involved

BlueShoes is a comprehensive application framework and content management system. It is written in the widely used web-scripting language PHP.

BlueShoes offers excellent support for the popular MySQL database as well as support for Oracle and MSSQL.

BlueShoes provides developers with real-world solutions for common system components such as User Management, Session Handling, Closed User Groups, Exception Handling and Logging, Object Persisting as well as Form Building and Handling.

BlueShoes' extensive feature set can also simplify or eliminate many common, and often tedious, programming tasks.

Welcome to the Seagull Framework project, created and maintained by Demian Turner and the Seagull community. Seagull is an object oriented framework written in PHP that focuses on best practices, clean code and reusable components. The core libraries are free for you to use in your own projects and a number of modules developed by the community are also available. The design goals of the project play an important role in the code's direction as does Open Source philosophy. Since it's the code that sells a framework, please take a look at some code examples to see what's on offer.

php.MVC implements the Model-View-Controller (MVC) design pattern, and encourages application design based on the Model 2 paradigm. This design model allows the Web page or other contents (View) to be mostly separated from the internal application code (Controller/Model), making it easier for designers and programmers to focus on their respective areas of expertise.

The framework provides a single entry point Controller. The Controller is responsible for allocating HTTP requests to the appropriate Action handler (Model) based on configuration mappings.

The Model contains the business logic for the application. The Controller then forwards the request to the appropriate View component, which is usually implemented using a combination of HTML with PHP tags in the form of templates. The resulting contents are returned to the client browser, or via another protocol such as SMTP.

php.MVC is a PHP port of Jakarta Struts. It currently supports many features of Struts, including declarative application configuration via the XML digester. For example, mappings from the various Action business logic components to appropriate results pages can be specified declaratively in the XML configuration file.

Solar is a "simple object library and application repository" for PHP5. That is, Solar is a combined class library, component suite, and application development framework.

Solar provides simple, easy-to-comprehend classes and components for the common aspects of web-based rapid application development, all under the LGPL.

Solar is designed for developers who intend to distribute their applications to the whole world. This means the database driver functions work exactly the same way for each supported database. It also means that localization support is built in from the start. Additionally, Solar comes with convenience functions that help you to secure your application against common expoits (such as cross-site scripting from URL tampering).

Phrame is a web development platform for PHP based on the design of Jakarta Struts. Phrame provides your basic Model-View-Controller architecture, and also takes a step further adding standard components such as HashMap, ArrayList?, Stack, ListIterator?, Object and more... All of this functionality was designed to be as easy as possible to use by developers and designers.

Phrame encourages application architectures based on the "Model2" approach, a variation of the classic Model-View-Controller (MVC) design paradigm. Phrame provides its own Controller component and integrates with other technologies to provide the Model and the View. For the Model, Phrame can interact with any standard data access technology, including Pear DB/DataObjects?, and ADODB. For the View, Phrame works well with PHP, Smarty Templates, XSLT, Flash MX, and other presentation systems.

Phrame provides an extensible development environment for your application, based on published standards and proven design patterns. Phrame was originally sponsored by the Software Development department of Texas Tech University and is released under the LGPL.

What is WASP?
WASP is a powerful web application framework built on PHP 5. WASP strives to allow web developers to make great applications with more fun and less code, but in the familiar playground of PHP.


Why use WASP?
WASP was written from the ground up in pure Object Oriented PHP5. WASP fully utilizes all of the enhancements made to PHP in version 5.

This means you use less code to create enterprise class applications.
This isn't your hacker's PHP.

Medusa is a PHP implementation of an MVC framework based on different good concepts of the Model View Controller design pattern. Taking most of the patterns that may perfectly be suited for web applications, Medusa is aimed at being the framework implementing the main core for small to medium web applications.

With Medusa, it will be very convenient to hard code your application's business logic (Models) and keep them separate from your main template files (Views). The best thing about Medusa is when you need to reuse Models, all you have to do is just drop the Model file into your new application code repository and add it to medusa through the bootstrap file, only bringing about the least changes like DB connections or globally used variables.

Biscuit :: PHP MVC Framework
This is the webpage for Biscuit. Biscuit was originally written by Ben Nolan - but is mostly maintained by the friendly folks on the PHP Biscuit Google Group.

Support
If you are new to biscuit - you should work through the tutorial. Biscuit is based on Ruby on Rails, so you might find the documentation at that site helpful.

The Qcodo Development Framework is an open-source PHP 5 framework that focuses on freeing developers from unnecessary tedious, mundane coding.

The result is that developers can do what they do best: focus on implementing functionality and usability, improving performance and ensuring security.

It is a completely object-oriented framework that takes the best of PHP and provides a truly rapid application development platform. Initial prototypes roll out in minutes instead of hours. Iterations come around in hours instead of days (or even weeks). As projects iterate into more cohesive solutions, the framework allows developers to take prototypes to the next level by providing the capability of bringing the application maturity.

The framework consists of two main components: the Code Generator and Qforms (see below for more). While the framework was designed to support the complexities of large projects, it is an incredibly lightweight framework which can be utilized by small and large web applications alike.

Based on the best practices of web development, thoroughly tried on several active websites, symfony aims to speed up the creation and maintenance of web applications, and to replace the repetitive coding tasks by power, control and pleasure.

If you have been looking for a Rails/Django-like framework for PHP projects with features such as:

simple templating and helpers
cache management
multiple environments support
deployment management
scaffolding
smart URLs
multilingual and I18N support
object model and MVC separation
Ajax support
...where all elements work seamlessly together, then symfony is made for you.

Studs began simply as a port of Apache's Jakarta Struts MVC Framework to PHP, though it has turned out to be decidedly more. I started this project to study the internals of J2EE web applications and then to bring these design concepts into the PHP environment. Now it is time the see if the code lives up to this challenge.

The primary goal of this project, apart from being a road tested implementation of the MVC pattern for PHP, is to provide a learning platform for developers looking to give J2EE a try, while at the same time providing a comfortable PHP environment for those people familiar with Java Servlet technology. One way Studs manages this neutral ground is by relying on many of the standard deployment descriptors used in Java Servlets and Struts, including such files as web.xml, struts-config.xml and taglib.tld. By achiving this level of compatibility, existing tools can be leveraged to help develop applications in this environment.

If you are web developer and are fed up with the spaghetti code you have come to the right place. Php On Trax(formerly Php On Rails) is a web-application and persistance framework that is based on Ruby on Rails and includes everything needed to create database-backed web-applications according to the Model-View-Control pattern of separation. This pattern splits the view (also called the presentation) into "dumb" templates that are primarily responsible for inserting pre-build data in between HTML tags. The model contains the "smart" domain objects (such as Account, Product, Person, Post) that holds all the business logic and knows how to persist themselves to a database. The controller handles the incoming requests (such as Save New Account, Update Product, Show Post) by manipulating the model and directing data to the view.

In Trax, the model is handled by what's called a object-relational mapping layer entitled Active Record. This layer allows you to present the data from database rows as objects and embellish these data objects with business logic methods.

SMART3 is a modular designed PHP5 framework that helps developers to organize their code in a clean, well structured and scalable way. The framework package size without any module is small (~70kb).

It wasn't the goal to build a framework, which follows the MVC pattern. Nevertheless you can identify this pattern in SMART3. The ModelViewController outline is there. Futhermore SMART3 make use of a ORM (Object Relational Mapping) like structure when communicating to action classes.


The base framework has no build in high level functionalities. An application based on this framework becomes alive through modules. Smart3 is delivered with a couple of default modules through which it is possible to build web projects and to learn how it works. This webpage is entierly build up on SMART3. The modules require mysql 4.1.

In SMART3 a request is related to a view, which holds the contact to as many different module action classes as needed to proceed. There is a loose coupling between the view and the actions (model). The benefit of this mechanism is that it is easier to build a view, that interacts with many different module items. In some MVC frameworks, solving such problems isn’t evident.

In SMART3 you have the choice between 2 template engines for your projects. 1. PHP (default) and 2. Smarty. If your are not convenient with the build in template engines you can use your prefered engine. This also counts for a database layer. SMART3 isn't fixed to a specific DB layer. This is the choice of the module designer to include the required layer.


The SMART3 core framework is released under the GNU LESSER GENERAL PUBLIC LICENSE.

What is rwfPHP?
The rwfPHP framework is a set of Object Oriented classes that allows development of Object Oriented Event driven web applications.

The main goals of rwfPHP is to speed development through the use of a simple event driven model, reuse of code through web controls, and separation of presentation and logic layers through the use of templates.

In terms of MVC, rwfPHP has a FrontController, Model level is provide by using Web Controls and the View is completed by use of Smarty Templates or PHP.

Model - Code Reuse with Web Controls
With major frameworks today the classes you create will inherit from a particular framework class. The most important inherited class in the rwfPHP framework, which all classes are inherited from at some point, is the Control. The WebControl class inherits from the Control class. Controls made from the Control class are the building blocks of the rwfPHP framework. The interaction and implementation of controls is the rwfPHP model in which web applications are built. The control is the basic structure for creating abstraction. Coupling controls together will build more complex abstract controls. The reuse of the controls is directly related to the level and simplicity of your abstraction.

Events are the communication that welds the controls together. Events are caught within each control. The event does not need to know of any specific instance of another control except that it is the kind of class that it expects.

View - Use of Templates
We have abstraction of the communication level and the code through the event model and the building blocks of controls. All that is left is the abstraction of the presentation level. Templates are built into the rwfPHP framework. With templates we can separate the code and the presentation levels. Each control added to any other objects controls collection will be automatically set to show up in the template. All the template needs to do is put in a line to display the control. Each handles its own template and display functionality. This gives each control the power to make sure it will look a certain way no matter where it is reused. The template engine that rwfPHP framework uses is Smarty (smarty.php.net).

Controller - Simple Event Driven Model
The simple event driven model is to help speed the learning curve of window’s application developers. People with a background in the basic concepts of the window’s event driven model will see the similarities between the two. To explain in further detail we need to touch on code reuse with web controls.