Accentsconagua

Uso de Illuminate Database With Eloquent en su aplicación PHP sin Laravel

Código
Share

Illuminate es el motor de base de datos de Laravel menos Laravel. Viene incluido con el ORM Eloquent en Laravel. Si desea construir sus aplicaciones PHP con ORM y prefiere no usar Laravel, este tutorial es para usted.

En este tutorial, vamos a construir el back-end para una aplicación de preguntas y respuestas con PHP, Illuminate Database y el ORM de Eloquent..

Dependencias del proyecto 

  1. PHP: 5.5+
  2. MyshQL
  3. Compositor

Capacidades de la aplicación

Nuestra aplicación realizará diez tareas:

  • Agregar un usuario.
  • Añadir una pregunta.
  • Añadir una respuesta a una pregunta. 
  • Upvote una respuesta.
  • Consigue una pregunta con respuestas.
  • Recibe todas las preguntas y usuarios que les han preguntado..
  • Obtener preguntas particulares, respuestas y upvotes.
  • Contar las preguntas de un usuario en particular.
  • Actualizar respuesta por usuario.
  • Eliminar una pregunta.

Primero, creamos nuestro directorio y estructura del proyecto..

En el directorio principal del proyecto, crearemos un aplicación carpeta, y luego en esta carpeta de aplicaciones, crearemos dos carpetas:modelos y controladores. En esta imagen, nuestra carpeta principal del proyecto se llama elocuente. Deberías reemplazarlo con el nombre que prefieras..

A continuación, creamos un index.php archivo en la carpeta principal del proyecto, al mismo nivel que el aplicación carpeta.

Usaremos git, así que creamos un archivo .gitignore. Tenga en cuenta que este paso es opcional.

A continuación, instalamos las dependencias necesarias para que este proyecto funcione. En la carpeta principal del proyecto, crearemos un archivo composer.json. Luego pegue esto en nuestro archivo composer.json.

“Nombre”: “illuminate-example / eloquent”, “description”: “Implementación de consultas de base de datos con illuminate y Eloquent”, “tipo”: “proyecto”, “require”:

Para instalar la base de datos de Illuminate, agregamos esto a nuestro composer.json:
“Illuminate / database”: “5.1.8”,.

A continuación, agregamos la carga automática de psr-4 para nuestros modelos y controladores:

“Autoload”: “psr-4”: “Controladores \\”: “aplicación / controladores /”, “Modelos \\”: “aplicación / modelos /”

Ahora, nuestro archivo composer.json debería verse así:

“Nombre”: “illuminate-example / eloquent”, “description”: “Implementación de consultas de base de datos con illuminate y Eloquent”, “tipo”: “proyecto”, “require”: “illuminate / database”: “5.1. 8 ”,“ carga automática ”: “ psr-4 ”: “ Controladores \\ ”:“ aplicación / controladores / ”,“ Modelos \\ ”:“ aplicación / modelos / "

Ahora ejecutaremos estos dos comandos de compositor en la misma ubicación que nuestro archivo composer.json:

compositor instalar compositor dump-autoload -o

Esto generará una carpeta de proveedor que podemos agregar a gitignore (este es también un paso opcional).

Vamos a agregar un archivo de configuración para nuestras credenciales de base de datos.

En el directorio principal del proyecto, creamos un archivo llamado config.php y definimos los detalles de la base de datos en el archivo Config.php. Tenga en cuenta que los valores deben reemplazarse con sus propios detalles de conexión.

A continuación, creamos el esquema para nuestra aplicación..
Una cosa a tener en cuenta antes de crear el esquema para las tablas en nuestra base de datos es que podemos agregar marcas de tiempo a nuestro esquema.
El ORM elocuente espera dos columnas de marca de tiempo si queremos habilitar la operación de marca de tiempo en una tabla / modelo en particular. Ellos son los Creado en y updated_at columnas Si habilitamos las marcas de tiempo para un modelo, Eloquent actualiza automáticamente estos campos en el momento en que creamos o actualizamos un registro..
Hay una tercera columna llamada deleted_at. los deleted_at Sin embargo, la marca de tiempo funciona de manera diferente. Eloquent tiene una función de borrado suave que usa el deleted_at columna para determinar si un registro se ha eliminado. Si elimina un registro con la función elocuente de 'eliminar' y habilita la eliminación suave, la columna se actualizará con el tiempo de eliminación. Estos elementos eliminados se pueden recuperar en cualquier momento.
En esta aplicación, aprovecharemos las marcas de tiempo, por lo que utilizaremos las tres en nuestra creación de esquema..
Crea tablas con los siguientes comandos en MySQL:
Preguntas
CREATE TABLE 'questions' ('id' int (11) unsigned NOT NULL AUTO_INCREMENT, 'question' tinytext, 'user_id' int (11) DEFAULT NULL, 'created_at' timestamp NULL DEFAULT NULL, 'updated_at' timestamp NULL DeFAULT NULL ' deleted_at 'timestamp NULL DEFAULT NULL, PRIMARY KEY (' id ')) MOTOR = InnoDB DEFAULT CHARSET = utf8;
Respuestas
CREATE TABLE 'answers' ('id' int (11) sin signo NOT NULL AUTO_INCREMENT, 'answer' tinytext, 'user_id' int (11) DEFAULT NULL, 'question_id' int (11) DEFAULT NULL, 'created_at' timestamp NULL DEFAULT NULL , marca de tiempo 'updated_at' NULL DEFAULT NULL, marca de tiempo 'deleted_at' NULL DEFAULT NULL, LLAVE PRINCIPAL ('id')) MOTOR = InnoDB DEFAULT CHARSET = utf8;
Upvotes
CREAR LA TABLA 'upvotes' ('id' int (11) sin firmar NOT NULL AUTO_INCREMENT, 'answer_id' int (11) DEFAULT NULL, 'user_id' int (11) DEFAULT NULL, 'created_at' timestamp NULL DEFAULT NULL, marca de tiempo 'deleted_at' NULL DEFAULT NULL, PRIMARY KEY ('id')) MOTOR = InnoDB DEFAULT CHARSET = utf8;
Usuarios
CREAR TABLA 'users' ('id' int (11) sin signo NOT NULL AUTO_INCREMENT, 'username' varchar (100) DEFAULT NULL, 'email' varchar (200) DEFAULT NULL, 'password' varchar (200) DEFAULT NULL, 'created_at 'timestamp NULL DEFAULT NULL,' updated_at 'timestamp NULL DEFAULT NULL,' deleted_at 'timestamp NULL DEFAULT NULL, PRIMARY KEY (' id ')) MOTOR = InnoDB DEFAULT CHARSET = utf8;
Continuaremos creando archivos para modelos y controladores para nuestras tablas en las siguientes ubicaciones:
     
  • project_folder / app / models / question.php
    •  
  • carpeta_proyecto / aplicación / modelos / answer.php
    •  
  • project_folder / app / models / upvote.php
    •  
  • project_folder / app / models / user.php
    •  
  • project_folder / app / models / database.php
    •  
  • project_folder / app / controllers / questions.php
    •  
  • carpeta_proyecto / aplicación / controllers / answers.php
    •  
  • project_folder / app / controllers / upvotes.php
    •  
  • project_folder / app / controllers / users.php
    •  
Abierto modelos / base de datos.php con un editor.
Primero creamos la cápsula:
addConnection (['driver' => DBDRIVER, 'host' => DBHOST, 'database' => DBNAME, 'username' => DBUSER, 'password' => DBPASS, 'charset' => 'utf8', 'colación' => 'utf8_unicode_ci', 'prefix' => ",]); // Configurar el ORM Eloquent ... $ capsule-> bootEloquent ();
En el archivo anterior, inicializamos y configuramos la cápsula con las constantes definidas en config.php, y luego iniciamos elocuente.
El siguiente paso es crear un script de inicio. Este será un archivo donde se ejecutará todo lo que debe ejecutarse antes de que funcione nuestra aplicación.
Creamos un archivo de inicio en la ubicación. project_folder / start.php, y luego en el archivo, requiere el archivo de carga automática Composer:
requiere 'vendor / autoload.php';
Después de eso, requerimos config.php Para obtener las credenciales definidas: requiere 'config.php';
Luego inicializamos la clase de base de datos..
Tu start.php debería verse así:
Incluya start.php en su index.php ya que este será nuestro archivo principal.
Nuestro archivo index.php ahora se ve así:
 
A continuación, podemos empezar a trabajar en nuestros controladores y modelos. En carpeta de proyecto/ app /modelos / pregunta.php, añadimos esto:
Entonces en carpeta de proyecto/app/controllers/questions.php:
En carpeta de proyecto/app/controllers/answers.php, hacemos lo mismo
Tarea 1: Agregar un usuario
En el modelo de usuario (carpeta de proyecto/app/models/user.php), agregamos el siguiente código para definir nuestro espacio de nombres, extender el Modelo Eloquent y definir el nombre de la tabla (mesa $ protegida) y qué campos de las tablas se pueden rellenar mediante la creación en masa (protegido $ rellenable).
En el controlador de usuarios (carpeta de proyecto/app/controllers/user.php), definimos nuestro espacio de nombres y clase como de costumbre:
Luego, para crear un usuario, en el controlador de usuarios, importamos el espacio de nombres Modelo del usuario, usar Modelos \ Usuario;, y luego agregar una función para crear el usuario.
$ nombre de usuario, 'correo electrónico' => $ correo electrónico, 'contraseña' => $ contraseña]); devuelve $ usuario; 
Nuestro controlador de usuario ahora se ve así.
$ nombre de usuario, 'correo electrónico' => $ correo electrónico, 'contraseña' => $ contraseña]); devuelve $ usuario; ?>
Luego, en index.php, agregamos estas líneas y ejecutamos la aplicación para crear un nuevo usuario..
Tarea 2: Añadir una pregunta
Para agregar una pregunta, importamos el espacio de nombres del modelo de pregunta en el controlador de preguntas y escribimos un create_question función:
utilizar Modelos \ Pregunta;
Entonces:
$ pregunta, 'user_id' => $ user_id]); devuelve $ pregunta;  
Hemos utilizado los modelos de creación masiva de Eloquent para insertar este registro, pero antes de que funcione, debemos permitir que esos campos se puedan rellenar, porque los modelos de Eloquent protegen contra la creación masiva de forma predeterminada.
Así que vamos a la pregunta modelar y agregar el protegido $ rellenable propiedad a la clase.
protected $ fillable = ['question', 'user_id'];
Para ejecutar esto, importe el controlador de preguntas en index.php y llame al create_question funciona estáticamente
use Controllers \ Question;
Luego cree una pregunta con una pregunta y una identificación de usuario como parámetros:
$ question = Questions :: create_question ("¿Alguna vez has conocido a tu doppelganger?", 1);
Esto devuelve un objeto modelo si tiene éxito.
Ahora ejecutaremos el script index.php con diferentes entradas para agregar más preguntas a la base de datos.
Tarea 3: Agregar una respuesta a una pregunta 
En el modelo de respuesta, repetimos los pasos seguidos para los modelos de pregunta y usuario agregando el siguiente código:
Luego en el controlador de respuestas, escribimos estas líneas:
$ answer, 'question_id' => $ question_id, 'user_id' => $ user_id]); devuelve $ answer; ?>
Luego, en index.php, podemos crear una respuesta para la pregunta con la identificación 1 que agregamos anteriormente, con la identificación de usuario 2. No olvide importar el controlador de respuestas a index.php primero.
Para evitar múltiples entradas, comente todas las demás llamadas en index.php antes de ejecutar una nueva.
Tarea 4: Upvote una respuesta
Esto es más o menos los mismos pasos que estamos acostumbrados.
Así que copiaremos esto en el modelo de Upvote en carpeta de proyecto/ app /modelos / upvote.php.
Luego, en los controladores de respuestas, importamos el espacio de nombres del modelo de Upvote.
use Models \ Upvote;
Entonces creamos un upvote_answer función.
$ answer_id, 'user_id' => $ user_id]); devuelve $ upvote; 
En index.php, podemos llamar a la función con un ID de usuario ficticio para aumentar la respuesta con id 1.
$ upvote = Respuestas :: upvote_answer (1,14); 
Tarea 5: Obtener una pregunta con respuestas
Para tareas como esta, podemos usar relaciones elocuentes..
Los tipos de relaciones incluyen uno a uno, uno a muchos, muchos a muchos, etc..
Al usar estas relaciones, Eloquent asume una clave externa en el formulario nombre del modelo_id existe en los modelos. Para esta tarea, la relación es una relación de uno a muchos porque una sola pregunta puede poseer cualquier cantidad de respuestas.
Primero definimos esta relación agregando esta función a nuestro modelo de pregunta.
hasMany ('\ Models \ Answer'); 
Luego, en el controlador de preguntas, escribimos una función para obtener preguntas con respuestas..
get () -> toArray (); devuelve $ preguntas; 
Esto recupera las preguntas con sus correspondientes respuestas..
En index.php, comentamos todas las demás llamadas y ejecutamos:
$ all = Questions :: get_questions_with_answers ();
Podemos var_dump o print_r la $ todos Variable para ver los resultados..
Tarea 6: Obtenga todas las preguntas y usuarios que las hicieron
Esta es una relación uno a uno porque una pregunta tiene un usuario, por lo que agregamos esto al modelo de preguntas..
belongsTo ('\ Models \ User'); 
Luego creamos una función en el controlador de preguntas y usamos el con función en el modelo de pregunta.
get () -> toArray (); devuelve $ preguntas; 
En index.php, comenta todos los demás y ejecuta esto:
$ all_with_users = Questions :: get_questions_with_users ();
Tarea 7: Obtener una pregunta con respuestas y upvotes
Primero, definimos una relación entre respuestas y upvotes. Una respuesta tiene muchos votos, por lo que la relación es de uno a muchos..
Entonces agregamos la siguiente función a nuestro modelo de respuesta:
hasMany ('\ Models \ Upvote'); 
Luego, en el controlador de preguntas, creamos la función para obtener esto:
responde () -> con ('upvotes') -> get () -> toArray (); devuelve $ preguntas; 
Como en los pasos anteriores, comentamos todas las demás llamadas a index.php y ejecutamos esto:
$ one_question = Preguntas :: get_question_answers_upvotes (1);
Podemos imprimir el $ one_question Variable para ver los resultados..
Tarea 8: contar todas las preguntas de un usuario en particular
Primero importamos el modelo de pregunta en los controladores de los usuarios:
utilizar Modelos \ Pregunta;
Luego escribimos esta función:
contar(); devuelve $ count; 
En index.php, comentamos otras llamadas y agregamos esta línea:
$ user_question_count = Users :: question_count (1);
Esto devuelve un número entero que es el número de preguntas que un usuario ha agregado con id 1. 
Podemos imprimir el $ user_question_count variable y ejecute index.php para ver los resultados.
Tarea 9: actualización de respuesta por usuario
El concepto de actualización con el ORM de Eloquent es bastante simple. Primero encontramos un registro, y luego mutamos y salvamos.
Ahora, en los controladores de respuestas, agregamos esta función:
answer = $ new_answer; $ updated = $ answer-> save (); devuelve $ actualizado; 
En index.php, podemos comentar todas las demás llamadas y actualizar la respuesta con id 1 de esta manera:
$ update_answer = Answers :: update_answer (1, "Esta es una respuesta actualizada");
Esto devuelve un valor booleano verdadero si la actualización es exitosa.
Tarea 10: Eliminar una pregunta (Eliminar suave)
En esta tarea final, implementaremos SoftDelete de Eloquent..
Primero le decimos el modelo de pregunta a utilizar. Softdeletes importando el Softdeletes espacio de nombres, y luego usando el Softdeletes rasgo en nuestra clase.
use Illuminate \ Database \ Eloquent \ SoftDeletes;
Luego, después de la línea de declaración de clase, agregamos esta línea:
utilizar softdeletes;
Luego agregamos deleted_at al fechas $ protegidas Propiedad para el modelo. Estos son los pasos necesarios.. 
protected $ dates = ['deleted_at'];
Nuestro modelo de preguntas ahora se ve así:
hasMany ('\ Models \ Answer');  usuario de la función pública () return $ this-> belongsTo ('\ Models \ User'); ?>
Entonces creamos el delete_question función en el controlador de preguntas.
borrar(); devuelve $ borrado;  
Ejecutar en index.php:
$ delete = Preguntas :: delete_question (1);
¡Felicidades! Acaba de crear un back-end completamente funcional con Illuminate y Eloquent. Y no tuvimos que escribir tanto código para lograr todo esto..
El código para este tutorial se puede encontrar en GitHub. 
Conclusión
Illuminate también viene con el Generador de consultas que puede usar para consultas de bases de datos aún más complejas y es definitivamente algo que desea experimentar y usar en su aplicación.
Lo único que falta en la base de datos Illuminate independiente son las migraciones de base de datos, que son una característica encantadora de Laravel y Lumen, el microframework de Laravel. Debería considerar usar ambas aplicaciones en sus aplicaciones para aprovechar las ventajas de las funciones útiles que vienen con.
Puede encontrar más información sobre Eloquent en la página oficial de documentación de Eloquent.
Referencias
     
  • Ilumina la base de datos en GitHub
    •  
  • Documentos ORM elocuentes
    •  





	
	
			
	   
	







Código
×