Advertisement
  1. Code
  2. PHP

Creando un Framework PHP5 - Parte 1

Scroll to top
Read Time: 11 min

() translation by (you can also view the original English article)

Con los sitios web cada vez más dinámicos e interactivos, los desarrolladores a menudo recurren a los marcos para ayudar a crear sitios web y aplicaciones web rápidamente. Si bien hay una gran cantidad de marcos disponibles, un marco personalizado le brinda la posibilidad de personalizar fácilmente el marco que necesita, y de construirlo aún más rápido, ya que ya sabría los entresijos del mismo antes de trabajar con él. En esta serie de tutoriales, vamos a construir nuestro propio Marco de Desarrollo PHP5. Comencemos con la planificación de nuestro marco y pongamos la estructura básica en su lugar.




* Nota: la ejecución de la demostración debe mostrar "PCA Framework versión 0.1 el resultado HTML", lo que demuestra la primera etapa de nuestro marco.

Paso 1: Esta serie

En esta serie, crearemos nuestro propio Framework PHP5 desde cero. El marco incluirá funciones básicas de administración de contenido, y lo utilizaremos para crear un directorio basado en la web para una organización pequeña.

Con suerte, a medida que avancemos, mejorará, construirá y optimizará este marco para satisfacer mejor sus necesidades, sin embargo, en estos tutoriales nuestro objetivo es obtener un marco simple en funcionamiento y potenciar un sitio web.

Durante las próximas semanas, durante estos tutoriales cubriremos:

  • Creación de controlador de autenticación, capa de abstracción de base de datos y administrador de plantillas.
  • Juntando estos objetos
  • Uso del marco para administrar contenido y potenciar nuestro sitio
  • Creando un fantástico diseño frontal.
  • Diseño para el proceso de inicio de sesión mediante guión gráfico.
  • Cómo se puede ampliar y ampliar el Marco

Paso 2: Patrones de diseño y su uso dentro de nuestro marco

Al crear cualquier sistema grande basado en computadora, ya sea una aplicación de escritorio, un sistema de red distribuida o una aplicación web, siempre habrá desafíos arquitectónicos asociados con su implementación.

Los patrones de diseño abordan algunos de estos problemas comunes, y utilizaremos una serie de patrones de diseño a medida que creamos nuestro Marco, para garantizar que tengamos un marco de calidad, flexible, robusto y utilizable, adecuado para cualquier propósito. En particular, en este tutorial veremos el patrón de Singleton y el patrón de Registro.

Paso 3: Archivos y carpetas

Lo primero que debe comenzar a crear nuestro Marco es crear una estructura de archivos adecuada, de modo que todo tenga su lugar. Además de los archivos que impulsan el marco, también debemos hacer provisiones para los archivos relacionados con el sitio web que vamos a crear con nuestro marco. La mayoría de los sitios web y aplicaciones web tienen:

  • Algunas funciones / objetos de uso común.
  • Lógica de negocios.
  • Un diseño

Esto nos da un gran punto de partida, los archivos relacionados con cada una de esas tres categorías deben agruparse en su propia sección. Eche un vistazo a la estructura del directorio a continuación, luego analizaremos las razones de la estructura.

Tenga en cuenta que la carpeta .settings y el archivo .project fueron creados por el IDE que uso, y no es necesario que estén presentes en su aplicación

Las funciones y objetos principales, como el acceso a la base de datos, la autenticación, el manejo de plantillas, los objetos de envío de correo electrónico, los objetos de análisis de correo electrónico, deben almacenarse dentro de una carpeta llamada objetos, dentro de la carpeta PCARegistry. Esto nos permite separar la lógica del Registro (que veremos en breve) de los objetos almacenados en el Registro.

A continuación, necesitamos un lugar donde almacenar nuestra lógica de negocios, que son los archivos que crearemos que hagan uso de nuestro marco. Debemos mantener estos archivos en una carpeta llamada controladores. Cada función principal que realiza nuestro sitio web o nuestra aplicación web (por ejemplo, la lista de directorios de empresas, el suministro y la gestión de contenido, el suministro de una galería de imágenes, etc.) sería un controlador independiente, almacenado dentro de su propia carpeta dentro de la carpeta de controladores. No vamos a utilizarlos en este tutorial, pero es importante tener nuestra estructura de directorios en su lugar, para que sepamos cómo funcionará.

El diseño de los sitios y las plantillas, deben almacenarse dentro de la carpeta de máscaras. Como es posible que queramos diferentes diseños (ya sea para que los usuarios de la aplicación / sitio web que creamos con nuestro marco puedan elegir entre una serie de diseños, o para cambiar el diseño según la temporada o el evento especial), cada aspecto estará dentro de su propia carpeta.

Paso 4: El Registro

En el corazón de nuestro marco tendremos las funciones principales, como el acceso a bases de datos, la autenticación de usuarios, etc. Al implementar el patrón de diseño del Registro, podemos mantener estos objetos almacenados de manera central, dentro del Registro, facilitando el acceso a nuestro Marco y cualquier aplicación que utilice nuestro marco.

El patrón de diseño del registro almacena y recupera referencias a objetos, y funciona de manera similar a un directorio telefónico: almacenando y recuperando contactos. Lo utilizaremos para almacenar estos objetos centrales, configuraciones de todo el sistema y, posteriormente, cualquier otro dato o información que deba compartirse en todo el sistema.

Debido a que almacenamos esta información de manera centralizada, solo queremos que una instancia de este objeto de registro esté disponible dentro de nuestro marco, si hubiera más de una disponible, tendríamos problemas en los que esperábamos cierta información o cierta información. objeto para estar en el registro, cuando de hecho se almacenó en otra instancia del objeto de registro. Para resolver este problema, nuestro objeto de Registro también implementará el patrón de diseño de Singleton, que impide que haya disponible más de una instancia del objeto.

A continuación se muestra el código PHP para el archivo registry.class.php, veremos cómo funciona en breve.

1
<?php
2
/**

3
 * The PCARegistry object

4
 * Implements the Registry and Singleton design patterns

5
 *

6
 * @version 0.1

7
 * @author Michael Peacock

8
 */
9
class PCARegistry {
10
  
11
	/**

12
	 * Our array of objects

13
	 * @access private

14
	 */
15
	private static $objects = array();
16
	
17
	/**

18
	 * Our array of settings

19
	 * @access private

20
	 */
21
	private static $settings = array();
22
	
23
	/**

24
	 * The frameworks human readable name

25
	 * @access private

26
	 */
27
	private static $frameworkName = 'PCA Framework version 0.1';
28
	
29
	/**

30
	 * The instance of the registry

31
	 * @access private

32
	 */
33
	private static $instance;
34
	
35
	/**

36
	 * Private constructor to prevent it being created directly

37
	 * @access private

38
	 */
39
	private function __construct()
40
	{
41
	
42
	}
43
		
44
	/**

45
	 * singleton method used to access the object

46
	 * @access public

47
	 * @return 

48
	 */
49
	public static function singleton()
50
	{
51
		if( !isset( self::$instance ) )
52
		{
53
			$obj = __CLASS__;
54
			self::$instance = new $obj;
55
		}
56
		
57
		return self::$instance;
58
	}
59
	
60
	/**

61
	 * prevent cloning of the object: issues an E_USER_ERROR if this is attempted

62
	 */
63
	public function __clone()
64
	{
65
		trigger_error( 'Cloning the registry is not permitted', E_USER_ERROR );
66
	}
67
	
68
	/**

69
	 * Stores an object in the registry

70
	 * @param String $object the name of the object

71
	 * @param String $key the key for the array

72
	 * @return void

73
	 */
74
	public function storeObject( $object, $key )
75
	{
76
		require_once('objects/' . $object . '.class.php');
77
		self::$objects[ $key ] = new $object( self::$instance );
78
	}
79
	
80
	/**

81
	 * Gets an object from the registry

82
	 * @param String $key the array key

83
	 * @return object

84
	 */
85
	public function getObject( $key )
86
	{
87
		if( is_object ( self::$objects[ $key ] ) )
88
		{
89
			return self::$objects[ $key ];
90
		}
91
	}
92
	
93
	/**

94
	 * Stores settings in the registry

95
	 * @param String $data

96
	 * @param String $key the key for the array

97
	 * @return void

98
	 */
99
	public function storeSetting( $data, $key )
100
	{
101
		self::$settings[ $key ] = $data;
102
103
104
	}
105
	
106
	/**

107
	 * Gets a setting from the registry

108
	 * @param String $key the key in the array

109
	 * @return void

110
	 */
111
	public function getSetting( $key )
112
	{
113
		return self::$settings[ $key ];
114
	}
115
	
116
	/**

117
	 * Gets the frameworks name

118
	 * @return String

119
	 */
120
	public function getFrameworkName()
121
	{
122
		return self::$frameworkName;
123
	}
124
	
125
	
126
}
127
128
?>

Entonces, ¿cómo funciona el objeto de registro y cómo mantiene nuestros objetos bien almacenados?

  • Los objetos se almacenan dentro de una matriz.
  • Cuando un nuevo objeto se almacena en el Registro, el archivo de clase se incluye, el objeto se crea una instancia y luego se almacena en la matriz.
  • Los objetos se recuperan al pasar la "clave" del objeto al método getObject.

¿Cómo impide que se cree otra copia del objeto de Registro?

  • El constructor es privado, evitando que el objeto se cree directamente.
  • La clonación del objeto desencadena un error.
  • Si necesitamos acceder al objeto desde nuestro Marco y no está directamente disponible para el archivo en el que estamos trabajando, podemos llamar al método estático singleton (PCARegistry :: singleton ()) para obtener la instancia del Registro.

Paso 5: index.php

Con la estructura lista para la funcionalidad principal que agregaremos en otro tutorial, veamos cómo accederemos al Registro y comenzaremos a trabajar en nuestro único punto de acceso de Frameworks, nuestro archivo index.php.

Las URL amigables están comúnmente disponibles en todas las formas de sitios web dinámicos y aplicaciones web, y una de las formas más sencillas de hacerlo (y administrar el control de la información a través de nuestro Marco) es garantizar que todas nuestras solicitudes de página pasen por index.php expediente. En un tutorial posterior, crearemos un archivo .htaccess para redirigir las solicitudes desde un formato agradable y amigable a un formato que nuestro archivo index.php pueda entender.

El código del archivo index.php está abajo. No hace mucho en este momento, pero nos permite poner las cosas en su lugar.

1
<?php
2
/**

3
 * PCAFramework

4
 * Framework loader - acts as a single point of access to the Framework

5
 *

6
 * @version 0.1

7
 * @author Michael Peacock

8
 */
9
 
10
// first and foremost, start our sessions

11
session_start();
12
13
// setup some definitions

14
// The applications root path, so we can easily get this path from files located in other folders

15
define( "APP_PATH", dirname( __FILE__ ) ."/" );
16
// We will use this to ensure scripts are not called from outside of the framework

17
define( "PCAFW", true );
18
19
/** 

20
 * Magic autoload function

21
 * used to include the appropriate -controller- files when they are needed

22
 * @param String the name of the class

23
 */
24
function __autoload( $class_name )
25
{
26
	require_once('controllers/' . $class_name . '/' . $class_name . '.php' );
27
}
28
29
// require our registry

30
require_once('PCARegistry/pcaregistry.class.php');
31
$registry = PCARegistry::singleton();
32
33
// print out the frameworks name - just to check everything is working

34
print $registry->getFrameworkName();
35
36
exit();
37
38
?>

Entonces ... ¿qué hace nuestro archivo index.php en este momento? Eso:

  • Llama a start_session de inmediato para garantizar que podamos usar sesiones en todo el Framework (esto debe llamarse antes de cualquier salida).
  • Crea una definición de la ruta del archivo actual, por lo que podemos hacer referencia al directorio raíz de Frameworks desde cualquier otro lugar, y crea una definición que usaremos para asegurar que todos los archivos de Frameworks sean llamados desde el mismo Framework, y que alguien no lo esté t tratando de llamar a uno de los archivos directamente
  • Utiliza la función de carga automática para determinar dónde se pueden ubicar las clases. En este caso, apunta al directorio de los controladores, ya que aquí es donde se almacenará nuestra lógica de negocios.
  • Incluye la clase de registro (esto es necesario ya que la clase no está dentro de la carpeta de controladores donde la función de carga automática la encontraría, y hace referencia a la instancia del registro a la variable $ registro.
  • Finalmente, imprime el nombre del marco, para demostrar una función simple desde dentro del Registro.

Podemos ver con más detalle cómo funcionará el Registro dentro de nuestro Marco, al crear algunos archivos de clase ficticios para su uso. Con una clase de plantilla en un nuevo archivo template.class.php en la carpeta PCARegsitry / objects, podemos demostrar esto, agregando un código adicional a nuestro archivo index.php.

En la línea después de que primero hacemos referencia al registro de $, podríamos agregar:

1
$registry->storeObject('template','template');

Si nuestra clase de plantilla tuviera un método contenido dentro de ella, como generateOutput, podríamos llamar a este método desde index.php así:

1
$registry->getObject('template')->generateOutput();

Nuestro marco ahora tiene una estructura básica, y tenemos un Registro implementado para nuestra funcionalidad principal. En el siguiente tutorial, veremos cómo crear los objetos que nuestro Registro almacenará, comenzando con una capa básica de abstracción de base de datos y una seguridad. gerente.

Advertisement
Did you find this post useful?
Want a weekly email summary?
Subscribe below and we’ll send you a weekly email summary of all new Code tutorials. Never miss out on learning about the next big thing.
Advertisement
Looking for something to help kick start your next project?
Envato Market has a range of items for sale to help get you started.