1.4. Começando a escrever um framework MVC

Já descrevemos o suficiente sobre o que nosso framework deve ter, agora é hora de implementá-lo. Para começar, você precisa de um servidor web. Você pode tentar Denver, mas pode ser necessário atualizar o PHP.

Você pode baixar o Denver com PHP 5.5.20 nesta página:

https://drupalbook.org/ru/drupal/denwer-obnovlenie-php

ou do github

https://github.com/levmyshkin/denwer-php-5.5.20

O trabalho do nosso framework começará com o arquivo index.php, que retorna instâncias do registro, chama o controlador necessário e passa os resultados do registro para ele, o controlador por sua vez pode chamar os modelos de que precisa.

Implementação de Padrões

Existem várias maneiras diferentes de implementar os padrões que discutimos. Escolheremos uma das opções possíveis, no futuro você pode alterar a implementação de qualquer um dos padrões.

Vamos começar, em um dos artigos anteriores analisamos a estrutura do nosso framework, portanto precisamos criar pastas de acordo com essa estrutura.

Agora crie o arquivo Registry/registry.class.php. Neste arquivo escreveremos a classe do nosso registro.

<?php
/**
 * Objeto de registro
 * Implementa o padrão de Registro e classe Singleton
 *
 */
class Registry {

    /**
     * Array de nossos objetos
     * @access private
     */
    private static $objects = array();

    /**
     * Array de nossas configurações
     * @access private
     */
    private static $settings = array();

    /**
     * Nome legível do nosso framework
     * @access private
     */
    private static $frameworkName = 'Framework version 0.1';

    /**
     * Instância do nosso registro
     * @access private
     */
    private static $instance;

    /**
     * Construtor para nosso registro
     * @access private
     */
    private function __construct()
    {

    }

    /**
     * Método singleton para acessar o objeto
     * @access public
     * @return
     */
    public static function singleton()
    {
        if( !isset( self::$instance ) )
        {
            $obj = __CLASS__;
            self::$instance = new $obj;
        }

        return self::$instance;
    }

    /**
     * Prevenção de clonagem do nosso objeto: dispara E_USER_ERROR se isso ocorrer
     */
    public function __clone()
    {
        trigger_error( 'Cloning the registry is not permitted', E_USER_ERROR );
    }

    /**
     * Armazena objeto em nosso registro
     * @param String $object the name of the object
     * @param String $key the key for the array
     * @return void
     */
    public function storeObject( $object, $key )
    {
        require_once('objects/' . $object . '.class.php');
        self::$objects[ $key ] = new $object( self::$instance );
    }

    /**
     * Obter objeto do nosso registro
     * @param String $key the array key
     * @return object
     */
    public function getObject( $key )
    {
        if( is_object ( self::$objects[ $key ] ) )
        {
            return self::$objects[ $key ];
        }
    }

    /**
     * Armazena configurações do nosso registro
     * @param String $data
     * @param String $key the key for the array
     * @return void
     */
    public function storeSetting( $data, $key )
    {
        self::$settings[ $key ] = $data;


    }

    /**
     * Obter configurações do nosso registro
     * @param String $key the key in the array
     * @return void
     */
    public function getSetting( $key )
    {
        return self::$settings[ $key ];
    }

    /**
     * Obter nome do framework
     * @return String
     */
    public function getFrameworkName()
    {
        return self::$frameworkName;
    }


}

?>

Então, como funciona nosso Registro e como ele armazena nossos objetos?

• Os objetos são armazenados como um array
• Quando um novo objeto é adicionado ao registro, o arquivo de classe também é adicionado, uma instância do objeto é criada e adicionada ao array
• Os objetos são retornados passando a chave do objeto ao método getObject

Como se evita a criação de outra cópia do objeto de registro?

• O construtor é privado, o que evita criar o objeto diretamente
• Clonar o objeto causa um erro
• Se você deseja acessar o objeto de registro de nosso Framework e isso não é possível no arquivo que está sendo executado agora, você pode usar o método estático singleton (Registry::singleton()) para obter uma instância do Registro.

Agora que temos o Registro, vamos escrever o index.php para chamar o trabalho do framework e acessar o Registro.

Index.php

Index.php é o ponto de partida do trabalho do nosso framework.

Em seguida, adicionaremos a capacidade de criar URLs legíveis usando o arquivo .htaccess. Por enquanto, vamos analisar o código index.php:

<?php
/**
 * Framework
 * Framework loader - acts as a single point of access to the Framework
 *
 */

// iniciar sessão
session_start();

// definir algumas constantes
// Defina a raiz do framework para obter facilmente em qualquer script
define( "APP_PATH", dirname( __FILE__ ) ."/" );
// Usaremos isso para evitar chamar scripts fora do nosso framework
define( "FW", true );

/**
 * Função mágica de carregamento automático
 * permite chamar o -controller- necessário quando necessário
 * @param String the name of the class
 */
function __autoload( $class_name )
{
    require_once('Controllers/' . $class_name . '/' . $class_name . '.php' );
}

// conectar nosso registro
require_once('Registry/registry.class.php');
$registry = Registry::singleton();

// exibir o nome do framework para verificar se tudo funciona
print $registry->getFrameworkName();

exit();

?>

Se tudo estiver correto, deve exibir uma mensagem com o nome do nosso framework:

Framework version 0.1

 Vamos entender como nosso index.php funciona no momento:

• A sessão é chamada para que possamos gravar dados e recuperá-los em qualquer lugar do framework.
• Definimos a pasta raiz do nosso framework, isso nos permite trabalhar normalmente não na raiz do site, mas em uma pasta.
• Carregamos controladores usando carregamento automático
• Conectar a classe de Registro
• e exiba o nome do nosso framework.