Its WEB application, with MVC and registry

I want to bring a simple and working project template, with which any new to PHP programming can create their own web application and at the same time get involved in the MVC theme.

The article is aimed at beginners, i.e. there is nothing new in it, just a few ideas are collected in a working draft that solves most of the problems.

The project begins with a structure. Simple and logical structure - the key to success of the project and the fact that someone other than the creator will be able to understand it.

In detail, what is MVC, can be found here and here .
')
In short, this is the division of code into Model (logic), Representation and Controller.


In the MVC architecture, it is important that the components know nothing about each other, and therefore are independent. If we want to change the appearance of the form on the site, it should affect only the presentation. If we make changes to the database, then this should apply only to the model.

The advantages of such an architecture: it is possible to test the components separately - it is easier to look for bugs, the designer can correct the layout on the site, and the logic can be transferred to another project.

I suggest using as a simple application architecture:


Controllers are separate, models are separate, the presentation is folded into folders (in the base folder there are universal reusable templates, such as pagination). In the folder s - resources: images, JavaScript and styles.

First of all, the rules for the server in htacess:

# AddDefaultCharset utf-8 RewriteEngine on RewriteBase / #     RewriteCond %{REQUEST_FILENAME} !-f RewriteCond %{REQUEST_FILENAME} !-d #    /employee/ RewriteRule ^([Az]*)\/$ ?type=page&controller=$1&action=main [L,QSA] #   RewriteRule ^([Az]*)\/([Az]*)\/$ ?type=page&controller=$1&action=$2 [L,QSA] #Ajax RewriteRule ^ajax\/([Az]*)\/([Az]*)\/$ ?type=ajax&controller=$1&action=$2 [L,QSA] ErrorDocument 404 /404.html 

The application will have a single entry point (that is, all requests to the site, with the exception of files, will be redirected to 1 script) - index.php. In him:

 <? session_start(); //   $type = $_REQUEST['type']; //   include $_SERVER['DOCUMENT_ROOT']. "/config.php"; //   include $_SERVER['DOCUMENT_ROOT']."/model/functions.php"; //       include $_SERVER['DOCUMENT_ROOT']."/model/db.php"; //  include $_SERVER['DOCUMENT_ROOT']."/model/reestr.php"; //   r::g('Controller_Main')->setRequest($_REQUEST); if ($type == 'ajax') { r::g('Controller_Main')->ajax($_REQUEST['controller'], $_REQUEST['action'], $_REQUEST['send']); } else { r::g('Controller_Main')->page($_REQUEST['controller'], $_REQUEST['action'],$_REQUEST); } 

Our application will have 2 types of requests: pages and ajax requests, both types are processed in the main controller, the corresponding functions.


Classes will be loaded at initialization using the autoloader. That is, when you initialize the class new Controller_main (), provided that a file with such a class is not connected, 'Controller_main' will be transferred to our function loader, and it will break up the class name by "_" and try to connect the /controller/main.php file . If it fails, it will redirect the user to 404 page. Announcement and autoloader connections, we will write in the /model/function.php file, which we manually connected.

 <?php function autoload($class_name) { $class_name = mb_strtolower($class_name); $arPath = explode("_", $class_name); if (file_exists($_SERVER['DOCUMENT_ROOT'] . "/" .implode("/", $arPath) . ".php")) { include_once($_SERVER['DOCUMENT_ROOT'] . "/" .implode("/", $arPath) . ".php"); }else{ //   r::g('Controller_main')->error404(); die(); } } //     spl_autoload_register('autoload'); 

To work with a database, a class with static functions. It can be used anywhere in the program. (This is done to make it easier to use the logging function; it is not necessary to access the database outside the model.).


Instead of a great bike class , you can use a wrapper implementation for a plugin, for example db simple.


The application uses a registry — a singleton pattern implementation — a loner that stores all instances (initialized class objects) of all models and controllers. Thanks to him, each class in the project will be initialized only once, and we will easily get access to it. To do this, refer to the classes as follows:

 r::g(" ") 

Registry implementation:

 <? //     class r { //       protected static $instance = array();//  //   static function g($name){ if(self::$instance[$name]){ return self::$instance[$name]; }else{ //     return self::add($name, new $name() ); } } //     static function add($name,$val){ return self::$instance[$name] = $val; } } 

Each controller will inherit a base one in which we implement the function that outputs a representation.

 <?php class controller_base{ function view($name,$args=null,$isBase=0){ ob_start(); if($isBase){ $tpl = $_SERVER['DOCUMENT_ROOT']. "/view/base/{$name}.php"; }else{ //   $class = explode("_",get_class($this)); $tpl = $_SERVER['DOCUMENT_ROOT']. "/view/{$class[1]}/{$name}.php"; } if(file_exists($tpl)){ if($args){ //    ,     extract($args); } include $tpl; }else{ echo "no tpl {$class[1]}/{$name}"; } return ob_get_clean(); } 

Even in the base controller, we implement the registry to store the page title, with the ability to change it from any controller.



The main controller, all calls will come to him first

 class Controller_main extends Controller_base{ function __construct(){ $this->model = r::g('Model_main'); } 

In it, and in every other controller, we create a link to its model. To handle requests for building a page, we will entrust the page functions:

 function page($controller,$action,$param){ //    ( ) if(!$controller){ $controller = 'main'; } //   main if(!$action){ $action = 'main'; } $method_name = "page_".$action; $controller_name = 'Controller_'.$controller; if(method_exists(r::g($controller_name), $method_name)){ //   ob_start(); r::g($controller_name)->{$method_name}($param); $html = ob_get_clean(); //   echo $this->view('page',array( 'html' => $html, 'title' => $this->getTitle() )); }else{ //    404 $this->error404(); } } 

It checks for the existence of the requested method in the requested controller, well, when you try to connect a non-existent controller, 404 will fall out (we arranged this in the class loader).

The body of the page is generated by the page_ {action} methods. So visually you can immediately see which functions are responsible for the generation of the pilgrim, and the methods with the name dropDataBase are protected from outside calls. An example of such a function:

 function page_main($param){ echo $this->view('main'); } 

Ajax requests are handled by the function:

 function ajax($controller,$action,$send){ $method_name = "ajax_".$action; $controller_name = 'Controller_'.$controller; if(method_exists(r::g($controller_name), $method_name)){ $res = r::g($controller_name)->$method_name($send); if($res){ echo "<ja>" . json_encode($res) . "</ja>"; } } } 

It works like a page, with a few exceptions:

• Searches for methods with the prefix ajax_
• Does not buffer the output, but immediately displays the printed ajax_ {action} method
• If the ajax_ {action} method returns data, serialize this data and frame it with ja tags, print.

The latter is needed if we need to return more and structured data in javascript. In the method called ajax_ {action}, you just need to return an array, and then the Controller_main-> ajax function will “figure out” how to transfer the data to the frontend.

Tags ja need to easily disassemble the answer on the frontend. Let's receive separately the text, separately serialized array. This will save traffic and CPU, so that we will not encode / decode html page. And still protected from errors, no extra output will not break our front end.


I strongly recommend that you call templates by the name of the function they perform, or the method in which they are used. And not only templates, but also functions in js.

It turns out: in javascript you create the method “addEmployee”, it sends a request to “ajax_addEmployee”, and the function uses the template “addEmployee”. Then it will be much easier to find them. Then you want to fix the template, look in js for the name of the function and immediately edit the view, no need to search in the controller.

A little bit about the frontend:

The folder with the scripts will look like a folder of controllers:


Also a basic script that all JS controllers will inherit from.

 function base(){ this.post = function(method,send,callback){ var controller = this.url ; var url = "/ajax/"+controller+"/"+method+"/"; return $.post(url,{ send : send },function (re) { var res = re.split('<ja>'); if (res[1] != undefined) { var text = res[0]; res = res[1].split('</ja>'); text += res[1]; re = text; var mas = $.parseJSON(res[0]); } else { var mas = {}; } if (typeof (callback) == 'function') { callback(re, mas) } }) } this.createPop = function(title, html) {} } }base = new base(); 

Actually inheritance and use of ajax:

 function employee(){ //  this.url = "employee"; //   var self = this; this.add = function(){ var $win = self.createPop(' ',null); self.post('add',{},function(re){ $win.update(re); }) } } employee.prototype = base; employee = new employee(); 

And also, in order to protect your project from accessing scripts, in the folder controller, model and. view it is necessary to put .htacess with the content:

 Deny from all 

Using this template, you can implement most of the tasks for web applications. And most importantly, any other programmer who is familiar with MVC can easily understand your project.

→ All source code