Programación y secuencias de comandos

Introducción a la doctrina ORM y el patrón de mapeador de datos en PHP

Introducción a la doctrina ORM y el patrón de mapeador de datos en PHP

Objetivo

Aprenda los conceptos básicos de doctrina ORM, implementando el patrón de mapeador de datos con PHP.

Requisitos

  • Compositor (Administrador de paquetes PHP)
  • Una configuración de lámpara de trabajo
  • Comprender la programación básica orientada a objetos y PHP
  • Comprender los conceptos básicos de la base de datos

Convenciones

  • # - requiere que los comandos de Linux dados se ejecuten con privilegios raíz
    directamente como usuario raíz o mediante el uso de sudo dominio
  • ps - Requiere que los comandos de Linux dados se ejecuten como un usuario regular no privilegiado

Introducción

El Patrón mapeador de datos es un patrón arquitectónico por medio del cual es posible lograr la separación entre una capa de persistencia de datos (en este caso, una base de datos MySQL) y una representación de datos en memoria (en este caso, objetos PHP), de modo que las dos capas se pueden separar y separarse y completamente desconocidos el uno del otro, respetando así la separación de las preocupaciones.

En este tutorial veremos cómo dar nuestros primeros pasos con doctrina, una implementación de patrón de mapeador de datos que es parte de la Simpatía marco de PHP, pero también se puede usar por sí solo.

La creación de la base de datos

Antes de cualquier otra cosa, deberíamos crear la base de datos que utilizaremos para la persistencia de datos. En este tutorial representaremos a un usuario y sus publicaciones en un blog:

Mariadb [(ninguno)]> Crear blog de base de datos; Mariadb [(ninguno)]> otorgue todos los privilegios en el blog.* A 'testUser'@'localhost' identificado por 'testPassword'; Mariadb [(ninguno)]> privilegios de descarga; Mariadb [(ninguno)]> salida;

Instalar e inicializar doctrina

El siguiente paso en nuestro viaje será la instalación de la doctrina: usaremos compositor, el paquete PHP y el administrador de dependencia. En la raíz de nuestro proyecto creamos el compositor.archivo json, especificando doctrina/ORM Como dependencia:

"requerir": "doctrina/orm": "^2.6 "
Copiar

Ahora, para continuar con la instalación, mientras que en el mismo directorio, abra un terminal y ejecute:

$ compositor instalación

El compositor instalará doctrina y todas sus dependencias dentro del proveedor directorio que creará. Una vez que se instala la doctrina, necesitamos inicializarla. Guarde el código a continuación en un archivo (para este tutorial, lo llamaremos bootstrap.php):

 'Blog'; 'user' => 'testUser', 'contraseña' => 'testPassword', 'host' => 'localhost', 'controlador' => 'pdo_mysql']; // Obtenga el administrador de entidad $ entity_manager = doctrine \ orm \ entityManager :: create ($ conecte_parameters, $ configuración);
Copiar

En primer lugar, requerimos en la línea 2 el archivo de AutOload del compositor autolaad.php, que se encarga de la auto -acristalamiento de las bibliotecas necesarias.

Llamando al createannotationmetadataconfiguration método estático del Configuración Clase en la línea 5, comenzamos a configurar la doctrina. Este método toma 5 argumentos, pero proporcionaremos solo los dos primeros, dejando el resto a sus valores predeterminados, ya que no estamos interesados ​​en ellos en este momento.

El primer argumento en la línea 6 es una variedad de rutas donde se encuentran clases de entidad en nuestro proyecto. Una entidad es una clase que representa una fila en la base de datos (la memoria de rapsentation en memoria que mencionamos anteriormente): En nuestro ejemplo, usaremos dos entidades: autor y post.

El segundo argumento en la línea 7 toma un valor booleano y define si estamos trabajando en modo "dev" o no. Esto define el comportamiento de doctrina sobre los objetos proxy y el almacenamiento en caché: cuando en el modo "dev", los objetos proxy se regeneran en cada solicitud y el almacenamiento en caché ocurrirá en la memoria, porque se supone que durante el desarrollo, los cambios ocurrirán muy a menudo. Lo estableceremos en verdad por ahora.

Después de eso, debemos especificar los parámetros de conexión en las líneas 11-16, en forma de una matriz asociativa que contiene, en orden, el nombre de la base de datos, el usuario de la base de datos, la contraseña de la base de datos, el host de la base de datos y el controlador para usar para acceder a la base de datos. Es importante notar que en un nivel más bajo, la doctrina usa PDO para interactuar con la base de datos, y está diseñado para ser la base de datos.

Finalmente, creamos una instancia del objeto EntityManager en la línea 20, llamando al método de fábrica "crear" de la clase EntityManager, pasando la matriz de información de conexión que acabamos de definir como el primer parámetro y el Configuración objeto como el segundo. El objeto EntityManager nos dará acceso a todas nuestras entidades y nos hará capaces de administrar fácilmente su persistencia y ciclo de vida.

Creando nuestras entidades

Es hora de crear nuestras entidades. Al igual que dijimos en la configuración, vamos a crear un directorio de 'entidades' en la raíz de nuestro proyecto para almacenar nuestras entidades. La primera entidad que vamos a definir es Autor:

Copiar

Definimos nuestra primera entidad, muy simple,. Nosotros usamos anotaciones para dar a la doctrina la información necesaria para manejarla. Primero en la línea 5, usando, @Entidad Estamos diciendo a la doctrina que la clase debe considerarse una entidad, que se persistirá en el autor tabla de base de datos. En este caso, utilizamos la anotación @Table (name = "autor") en la línea 6 para especificar esto, sin embargo, en esta situación es redundante, y podríamos haber omitido por completo: es opcional, y si no se usa, la entidad será persistido en una mesa que lleva el nombre de la no cualificado nombre de la clase.

Cada propiedad de la clase corresponde a una columna en la tabla, y debemos proporcionar información sobre el tipo de datos de la tabla. El $ ID La propiedad, por ejemplo, representa la clave principal de la tabla: declaramos esto utilizando el @Identificación Anotación en la línea 11.

El valor del identificación La columna se generará automáticamente, por eso usamos el @GeneratedValue Anotación en la línea 12. Tiene sentido solo cuando está asociado con @identificación, y al usarlo, incluso es posible especificar la estrategia de generación para adoptar (si no se especifica ninguno, será predeterminado a AUTO).

El tipo de datos utilizado para nuestra clave principal será Pequeño, que definimos a través del @Column (type = "smallint") Anotación en la línea 13. Las otras dos propiedades son $ First_Name y $ Last_Name, y se definen con la misma técnica. Ellos son de tipo cadena: Al usar MySQL, se traducirá al Varar Tipo de datos de la base de datos. Para obtener una referencia completa sobre las asociaciones de tipo de datos, puede consultar esta página.

Al usar doctrina, la visibilidad de las propiedades de una clase de entidad puede ser protegido o privado pero no público.

No definimos a Getters y Setters para la clase todavía. No hay necesidad de hacerlo manualmente, ya que la doctrina puede hacerlo por nosotros, y veremos cómo en un momento, todavía tenemos otra entidad para definir, Correo:

Copiar

Introdujimos dos nuevos tipos de datos. El primero es texto En la línea 23 que mapeará y convertirá los datos de cadena sin una longitud máxima: cuando se use mySQL, se convertirá en el TEXTO LARGO tipo de datos. El segundo es fecha y hora en la línea 28, para nuestro $ Fecha propiedad. Se traducirá al mismo tipo para MySQL, y en un caso de PHP's Fecha y hora objeto.

Ahora podemos generar nuestros Getters and Setters, pero antes de hacer eso debemos crear el concreto de cli.php Script en la raíz de nuestro proyecto: es necesario para usar doctrina desde la línea de comandos:

Copiar

Ahora, abra un shell de terminal en el directorio raíz del proyecto y ejecute el siguiente comando Linux:

$ php proveedor/bin/doctrine orm: generar entidades .

El comando anterior generará getters y setters para las entidades encontradas, y los colocará dentro del directorio especificado. Ahora, si echamos un vistazo al Autor entidad podemos ver que se han generado getters y setters:

identificación;  /*** Establecer primer nombre. * * @param String $ FirstName * * @return autor */ public Function setFirstName ($ firstName) $ this-> first_name = $ firstName; devolver $ esto;  /*** Obtenga el nombre de primer. * * @return string */ public function getFirstName () return $ this-> first_name;  /*** Establecer lastname. * * @param cadena $ lastName * * @return autor */ public setLastName ($ lastName) $ this-> last_name = $ lastName; devolver $ esto;  /*** Obtener el nombre de último. * * @return string */ public function getLastName () return $ this-> last_name;
Copiar

Lo mismo ha pasado por el Correo entidad:

identificación;  /*** Establecer título. * * @param cadena $ title * * @return post */ public function settitle ($ title) $ this-> title = $ title; devolver $ esto;  /*** Obtener título. * * @return string */ public function gettitle () return $ this-> title;  /*** Establecer texto. * * @param cadena $ text * * @return post */ public function setText ($ text) $ this-> text = $ text; devolver $ esto;  /*** Recibe texto. * * @return string */ public function getText () return $ this-> text;  /** * Define la fecha. * * @Param \ DateTime $ date * * @return post */ public function setDate ($ date) $ this-> date = $ date; devolver $ esto;  /** * Obtener la fecha. * * @return \ dateTime */ public function getDate () return $ this-> date;
Copiar

Definir la relación entre las entidades

Para nuestro ejemplo, queremos definir un bidireccional a muchos relación entre nuestras entidades, donde bidireccional significa que cada entidad tiene una referencia a la otra. La relación entre un autor y sus publicaciones es muchos a uno (un autor puede escribir muchas publicaciones y muchas publicaciones pueden pertenecer a un autor). Usando la doctrina, definir dicha asociación es muy simple:

Copiar

Agregamos una nueva propiedad en cada entidad. En el autor, es $ publicaciones en la línea 16, y en la entidad post, $ autor en la línea 36. ¿Qué tipo de tipo de datos tendrán esas variables?? El primero, $ publicaciones será una instancia de doctrina Arraycolletion Objeto: es una clase especial utilizada para gestionar mejor la colección de entidades.

El segundo, $ autor, en Correo.php, Será una instancia de la entidad del autor, que representa al autor de la publicación: como se dijo antes, cada entidad tiene una referencia a la otra.

De manera similar a lo que hicimos por las otras propiedades, definimos la relación utilizando anotaciones. En nuestro caso, dado que estamos lidiando con una relación bidireccional de uno a muchos, utilizamos la @Uno a muchos anotación en la línea 13, en la entidad del autor, y @ManytoOne En la línea 32 en la publicación.

En ambos casos, con Colocación Definimos a qué entidad apunta la propiedad. Por ejemplo en el caso del autor $ publicaciones propiedad, la entidad objetivo está post. Como puede ver, usamos respectivamente el Inversedby y mapeado anotaciones. Estas anotaciones se utilizan para decir doctrina qué propiedad, en el otro lado de la relación, se refiere al objeto: Inversedby debe usarse en el lado que posee el CLAVE EXTERNA, (En este caso la entidad post).

Como puede ver, en el autor, usamos mapeado, especificando eso en el entidad objetivo Post, la propiedad correspondiente es $ autor. También presentamos un nuevo parámetro, cascada, Configurarlo en "todo". Esto significa que al persistir o eliminar la entidad de la base de datos, todas sus publicaciones también estarán influenciadas: por ejemplo, eliminar a un usuario también causará la eliminación de todas sus publicaciones. Es lo que definimos a través de En la cascada de eliminación en código SQL.

Viceversa, en la entidad post, que contiene la clave extranjera en la base de datos, utilizamos Inversedby, Decir la doctrina que en el autor de la entidad objetivo, la propiedad que se refiere al objeto es postes. También hemos usado el @Joincolumn anotación en la línea 33, especificando las columnas involucradas en la unión SQL, estableciendo la clave extranjera como no anulable (NO NULO).

Una vez que se define la relación entre las dos entidades, debemos actualizar los métodos necesarios para administrar las propiedades adicionales. De nuevo solo corremos:

$ php proveedor/bin/doctrine orm: generar entidades .

Generar el esquema de la base de datos

En nuestro ejemplo, tenemos suficientes datos para poder generar nuestro esquema de base de datos. Nuevamente, la doctrina puede ayudarnos, generarla automáticamente en función de nuestras anotaciones. Todo lo que necesitamos hacer es ejecutar el siguiente comando Linux:

$ PHP Vendor/bin/Doctrine Orm: Schema-Tool: Update --force

Si todo va bien, se generarán las tablas de la base de datos, verifiquemos:

Mariadb [(ninguno)]> Describa el blog.autor; +------------+--------------+------+-----+-------- -+ ----------------+ | Campo | Tipo | NULL | Clave | Predeterminado | Extra | +------------+--------------+------+-----+-------- -+ ----------------+ | ID | Smallint (6) | No | PRI | NULL | auto_increment | | First_Name | Varchar (255) | No | | NULL | | | Last_Name | Varchar (255) | No | | NULL | | +------------+--------------+------+-----+-------- -+ ----------------+ mariadb [(ninguno)]> Describa el blog.correo; +-----------+--------------+------+-----+--------- + ----------------+ | Campo | Tipo | NULL | Clave | Predeterminado | Extra | +-----------+--------------+------+-----+--------- + ----------------+ | ID | Smallint (6) | No | PRI | NULL | auto_increment | | autor_id | Smallint (6) | No | MUL | NULL | | | título | Varchar (255) | No | | NULL | | | texto | Textexto | No | | NULL | | | Fecha | DateTime | No | | NULL | | +-----------+--------------+------+-----+---------+----------------+
Copiar

Como se esperaba, se han generado las tablas correspondientes a nuestra entidad y refleja las anotaciones que especificamos. El código SQL utilizado para generarlos es respectivamente:

Mariadb [(ninguno)]> Mostrar blog Crear mesa.autor; Tabla: Autor Crear tabla: Crear tabla 'Autor' ('Id' SmallInt (6) No Null Auto_incement, 'First_Name' Varchar (255) Collate Utf8_unicode_ci no null, 'Last_Name' Varchar (255) COLLATE UTF8_UNICODE_CI NO NULL, TECLA PRIMARIA (CELECHA PRIMERA (( 'id')) motor = innoDB Auto_Increment = 2 Default Charset = UTF8 Collate = UTF8_UNICODE_CI MARIADB [(NINGUNO)]> MOSTRAR CREAR TABLE Blog.correo; Tabla: Publica Crear tabla: Crear tabla 'post' ('id' smallInt (6) no null Auto_incement, 'autor_id' smallInt (6) no nulo, 'title' varchar (255) Collate UTF8_Unicode_ci no nulo, 'Text' LongText recopilado UTF8_UNICODE_CI NO NULL, 'Date' DateTime no NULL, KEY primaria ('id'), clave 'IDX_5A8A6C8DF675F31B' ('Autor_id'), restricción 'FK_5A8A8A6C8DF675F31B' Clave extraña ('Autor_id') Autor ') Autor' ('Id')))) Motor = innoDB Auto_Increment = 2 Default Charset = UTF8 Collate = UTF8_UNICODE_CI
Copiar

Usando el gerente de entidad

Ahora es el tiempo, muestre cómo usar el gerente de entidad:

setFirstName ("John") -> SetLastName ("Smith"); $ entity_manager-> persist ($ autor); // Crear una nueva publicación $ post = (nuevas entidades \ post ()) -> settitle ("Hello Wold") -> settext ("Esta es una publicación de prueba") -> setauthor ($ autor) -> setDate (nuevo Fecha y hora()); // Agregue la publicación de la lista de las publicaciones del autor. Dado que usamos cascade = "all", nosotros // no necesitamos persistir la publicación por separado: persistirá cuando persistirá // el autor $ autor-> addPost ($ post); // Finalmente, enjuague y ejecute la transacción de la base de datos $ entity_manager-> flush ();
Copiar

Ejecutando este código creamos un autor y su primera publicación, luego agregamos la publicación a la colección de publicaciones del autor y finalmente los persistimos a la base de datos. Con el persistir() Método Estamos diciendo a la doctrina que administre la entidad, mientras que la transacción de la base de datos real ocurre solo al llamar enjuagar(). Si ahora echamos un vistazo al autor y correo Tabla, podemos ver que existe un nuevo registro en ambos:

Mariadb [(ninguno)]> seleccionar * del blog.autor; +----+------------+-----------+| ID | First_Name | Last_Name | +----+------------+-----------+| 1 | John | Smith | +----+------------+-----------+mariadb [(ninguno)]> Seleccionar * del blog.correo; +----+-----------+------------+------------------- -+ ---------------------+ | ID | autor_id | título | texto | Fecha | +----+-----------+------------+------------------- -+ ---------------------+ | 1 | 1 | Hola Wold | Esta es una publicación de prueba | 2018-04-17 08:37:44 | +----+-----------+------------+---------------------+---------------------+
Copiar

También podemos usar el administrador de entidad para recuperar una entidad existente, por ejemplo:

// recuperar al autor por su apellido $ autor = $ entity_manager-> getRepository ('entidades \ autor')-> findoneby (['last_name' => 'smith']);
Copiar

Conclusiones

El objetivo de este tutorial era presentarle el patrón de mapeador de datos en PHP usando doctrina: vimos cómo configurar y obtener un administrador de entidades, cómo definir dos entidades básicas y definir una relación común entre ellos a través de anotaciones.

La doctrina es una biblioteca muy poderosa: puede usar la documentación del proyecto para comenzar a dominarla, con suerte este podría ser un punto de partida mínimo.

Tutoriales de Linux relacionados:

  • Cosas para instalar en Ubuntu 20.04
  • Instalación de ampache Raspberry Pi
  • Cómo crear una pila de lámparas basada en Docker usando Docker en ..
  • Cómo instalar la pila de lámparas en Almalinux
  • Cosas que hacer después de instalar Ubuntu 20.04 fossa focal Linux
  • Una introducción a la automatización, herramientas y técnicas de Linux
  • Ubuntu 20.04 trucos y cosas que quizás no sepas
  • Mint 20: Mejor que Ubuntu y Microsoft Windows?
  • Manipulación de Big Data para la diversión y las ganancias Parte 1
  • Ubuntu 20.04 WordPress con instalación de Apache