Php – good (neat) architecture in programming a simple website, e.g. a contact book

ArchitecturedesignPHP

When I build a simple website, e.g. a contact book where I can add, delete and update contacts, I create an index.php file where a user, if he's not logged in, is requested to enter a password and if he enters the right password, he's assigned a session and can do certain things with the contacts.

I have two files:

The first (contacts.php) is for the HTML code to be shown. Above the HTML code I include the second file and create the class.
The second (contacts_class.php) contains all methods for adding, deleting and updating.

I think that's ok, but when it comes to implement a big project, how should I do it? Do I have to create folders for every page and put files in them (like above, HTML and class), and how should I do it? What is a good and neat architecture for building large projects that every other programmer would understand perfectly?

Best Answer

You raised a very interesting and fundamental question. The question concerning the large scale project architecture and the folder structure organization (which is secondary to the architecture).

Today the most common approach to building the CMS framework architecture is the use of MVC pattern. There are some good articles about building your own MVC frameworks, one of them is Build an MVC Framework with PHP.

MVC stands for Model, View, Controller. You may call these approaches whatever you like - MVC, HMVC, MVP. The essence is to isolate the individual components of your system. The "Controller" retrieves the data from the "Model" and sends them to "View", which renders the final HTML. You have already implemented the "V" in your contacts.php and "MC" in your contacts_class.php. So you have isolated the view from the model and controller. Now you can easily change your "View" leaving other parts intact.

I am not suggesting you to blindly follow the MVC, MVP or whatever else "MV" pattern. It is the matter of appropriateness, efficacy and taste.

The common dynamic website application may include such components like:

The entry point, say index.php
The helper libraries / classes
The request router
The modules, components or controllers
The template engine or maybe single views

The real web application may include any other components like event handlers, event dispatchers and hooks, but these are in fact nuances. Well, let me present it the way I want to present it:

The operation routine diagram

The common framework operation routine as follows:

The browser request is sent directly to the entry point executable / script (index.php).
The entry point script loads the helper libraries, classes and performs some further initialization of our programming environment.
The URL is passed to the request router instance. This step can be the part of step 2.
The request router parses the URL and dispatches the operation to a particular component, module or controller.
The component (or controller) processes the routed request and sends the data to the view to be rendered.

The corresponding project folder structure is shown in the diagram.

I would suggest you to investigate how the other frameworks are implemented. The recommended CMS / frameworks to begin with are CodeIgniter, OpenCart, Joomla 1.5 and Tango CMS.

Related Solutions

Php – How to structure template system using plain PHP

I wouldn't do the second approach as the parameters aren't named.

A well-written essay on describing how a template system should work is coming from Parr, it's often quoted by people writing template systems and/or web-mvc frameworks.

Personally, what I usually prefer is to implement an ArrayObject class with a properties array, and the template would refer to $this->propertyName, which in fact would be the template object's $this->property['name']. This could be also achieved simply by using __set and __get, so:

class Template {
  private $_scriptPath=TEMPLATE_PATH;//comes from config.php
  public $properties;
  public function setScriptPath($scriptPath){
    $this->_scriptPath=$scriptPath;
  }
  public function __construct(){
      $this->properties = array();
  }
  public function render($filename){

   ob_start();
   if(file_exists($this->_scriptPath.$filename)){
     include($this->_scriptPath.$filename);
    } else throw new TemplateNotFoundException();
    return ob_get_clean();
  }
  public function __set($k, $v){
      $this->properties[$k] = $v;
  }
  public function __get($k){
      return $this->properties[$k];
  }
}

and a template would look like:

<html>
      <head>
         <title><?=$this->title?></title>
      </head>
      <body>Hey <?=$this->name?></body>
</html>

and invoking it would look like:

$view = new Template();
$view->title="Hello World app";
$view->properties['name'] = "Jude";
echo $view->render('hello.inc');

As far as I remember, this is how the old Symfony 1.x and the Zend_View template engines look like, and for me it's fine.

PHP Development – Web Application Structure Review

I'd suggest following MVC because in the current layout I don't see separation of functionalities in the code. E.g. grouping code in ajax means each file is responsible to fetch and process data (Model), presenting it to client (Controller) and formatting (View).

Edit to clarify if the current layout was already MVC like, it's not clear that it is. Looking at the .php files, you can't tell that .php files in views/ are controllers/models, but usually when using templates, only .tpl belong in views/. So to fix that, we have to keep views/*.php together with other .php in ajax/, say in src/.

If you do that, then it'd be clear that you have View in views/ and Model and Controller in src/. Then the next step is to break src/ to models/ and controllers/. This is not as easy as moving files around because you need to break up the files too. E.g. you mention that the ajax files perform INSERT and UPDATE. Those parts that do that would need to be placed in separate files and in models/. Once you removed those parts from the original files, you can put them together as controllers. This is quite rough but should make it clear enough.

So, from your current layout, I'd put and break the php files in controllers/ and model/, put .tpl files in view/ and put all other files that must be accessible by public (.js, .css, etc.) in public/. Also, put 3rd party library in a separate directory, like vendor/.

You might also want to consider using an MVC framework, which most likely will make/suggest a layout for you. Caveat I only wrote to make the php part to be MVC. As you it seems like javascript is used substantially, you can make javascript to be MVC too.

Best Answer

Related Solutions

Php – How to structure template system using plain PHP

PHP Development – Web Application Structure Review

Related Topic