Utilisation de Illuminate Database avec Eloquent dans votre application PHP sans Laravel

Illuminate est le moteur de base de données de Laravel moins Laravel. Il est livré avec l'ORM Eloquent à Laravel. Si vous souhaitez créer vos applications PHP avec des ORM et que vous préférez ne pas utiliser Laravel, ce tutoriel est pour vous..

Dans ce tutoriel, nous allons créer le back-end d'une application de questions-réponses avec PHP, Illuminate Database et Eloquent ORM..

Dépendances du projet 

1. PHP: 5.5+
2. MYSQL
3. Compositeur

Capacités d'application

Notre application effectuera dix tâches:

• Ajouter un utilisateur.
• Ajouter une question.
• Ajouter une réponse à une question. 
• Upvote une réponse.
• Obtenez une question avec des réponses.
• Obtenez toutes les questions et les utilisateurs qui les ont posées.
• Obtenez des questions particulières, des réponses et des votes positifs.
• Compter les questions d'un utilisateur particulier.
• Mise à jour de la réponse par utilisateur.
• Supprimer une question.

Tout d'abord, nous créons notre répertoire et structure de projet.

Dans le répertoire principal du projet, nous allons créer un app dossier, puis dans ce dossier d'application, nous allons créer deux dossiers:des modèles et contrôleurs. Sur cette image, notre dossier de projet principal s’appelle éloquent. Vous devriez le remplacer par le nom que vous préférez.

Ensuite, nous créons un index.php fichier dans le dossier principal du projet, au même niveau que le app dossier.

Nous allons utiliser git, nous créons donc un fichier .gitignore. Notez que cette étape est facultative.

Ensuite, nous installons les dépendances nécessaires au fonctionnement de ce projet. Dans le dossier principal du projet, nous allons créer un fichier composer.json. Puis collez ceci dans notre fichier composer.json.

"Nom": "illuminate-example / éloquent", "description": "Implémentation de requêtes de base de données avec illuminate et Eloquent", "type": "projet", "require": 

Pour installer la base de données Illuminate, nous ajoutons ceci à notre composer.json:
“Illuminate / database”: “5.1.8”,.

Ensuite, nous ajoutons le chargement automatique psr-4 pour nos modèles et nos contrôleurs:

“Autoload”: “psr-4”: “Contrôleurs \\”: “app / contrôleurs /”, “Modèles \\”: “app / modèles /”

Maintenant, notre fichier composer.json devrait ressembler à ceci:

«Nom»: «illuminate-example / éloquent», «description»: «Implémentation de requêtes de base de données avec illuminate et éloquent», «type»: «projet», «require»: «illuminate / database»: «5.1. 8 ”,“ autoload ”: “ psr-4 ”: “ Contrôleurs \\ ”:“ app / contrôleurs / ”,“ Modèles \\ ”:“ app / modèles / " 

Nous allons maintenant exécuter ces deux commandes composer au même endroit que notre fichier composer.json:

composer installer composer dump-autoload -o

Cela générera un dossier de fournisseur que nous pourrons ajouter à gitignore (c'est aussi une étape optionnelle).

Ajoutons un fichier de configuration pour nos informations d'identification de base de données.

Dans le répertoire principal du projet, nous créons un fichier nommé config.php et définissons les détails de la base de données dans le fichier Config.php. Notez que les valeurs doivent être remplacées par vos propres détails de connexion..

Ensuite, nous créons le schéma pour notre application.
Une chose à noter avant de créer le schéma pour les tables de notre base de données est que nous pouvons ajouter des horodatages à notre schéma..
Eloquent ORM attend deux colonnes d’horodatage si nous voulons activer l’opération d’horodatage sur une table / un modèle particulier. Ils sont les créé à et updated_at colonnes. Si nous activons les horodatages pour un modèle, Eloquent met automatiquement à jour ces champs avec l'heure à laquelle nous créons ou mettons à jour un enregistrement..
Il y a une troisième colonne appelée delete_at. le delete_at l'horodatage fonctionne différemment, cependant. Eloquent a une capacité de suppression douce qui utilise le delete_at colonne pour déterminer si un enregistrement a été supprimé. Si vous supprimez un enregistrement avec la fonction "supprimer" éloquente et que vous activez la suppression logicielle, la colonne est mise à jour avec l'heure de la suppression. Ces éléments supprimés peuvent ensuite être récupérés à tout moment..
Dans cette application, nous allons tirer parti des horodatages. Nous allons donc utiliser les trois dans notre création de schéma..
Créez des tables avec les commandes suivantes dans MySQL:
Des questions
CREATE TABLE 'questions' ('id' int (11) non signé NOT NULL AUTO_INCREMENT, 'question' tinytext, 'id_utilisateur' int (11) DEFAULT NULL, horodatage 'created_at' NULL DEFAULT NULL, 'updated_at' horodatage NULL DEFAULT NULL, ' delete_at 'horodatage NULL DEFAULT NULL, PRIMARY KEY (' id ')) ENGINE = InnoDB DEFAULT CHARSET = utf8;
Réponses
CREATE TABLE 'answers' ('id' int (11) non signé NOT NULL AUTO_INCREMENT, 'answer' minuscule, 'user_id' int (11) DEFAULT NULL, 'question_id' int (11) DEFAULT NULL, 'created_at' horodatage NULL DEFAULT NULL , 'updated_at' horodatage NULL DEFAULT NULL, 'delete_at' horodatage NULL DEFAULT NULL, PRIMARY KEY ('id')) ENGINE = InnoDB DEFAULT CHARSET = utf8;
Upvotes
CREATE TABLE 'upvotes' ('id' int (11) non signé NOT NULL AUTO_INCREMENT, 'answer_id' int (11) DEFAULT NULL, 'user_id' int (11) DEFAULT NULL, 'created_at' estampille NULL DEFAULT NULL, 'updated_at' NULL DEFAULT NULL, horodatage 'delete_at' NULL DEFAULT NULL, PRIMARY KEY ('id')) ENGINE = InnoDB DEFAULT CHARSET = utf8;
Utilisateurs
CREATE TABLE 'users' ('id' int (11) non signée NOT NULL AUTO_INCREMENT, 'nom_utilisateur' varchar (100) NULL PAR DEFAUT, email 'varchar (200) NULL PAR DEFAUT, mot de passe' varchar (200) NULL DEFAULT, 'created_at 'horodatage NULL DEFAULT NULL,' updated_at 'horodatage NULL DEFAULT NULL, horodatage' delete_at 'NULL DEFAULT NULL, PRIMARY KEY (' id ')) ENGINE = InnoDB DEFAULT CHARSET = utf8;
Nous allons procéder en créant des fichiers pour les modèles et les contrôleurs pour nos tables aux emplacements suivants:
 
dossier_projet / app / models / question.php
 
dossier_projet / app / models / answer.php
 
dossier_projet / app / models / upvote.php
 
dossier_projet / app / models / user.php
 
dossier_projet / app / models / database.php
 
dossier_projet / app / controllers / questions.php
 
dossier_projet / app / controllers / answers.php
 
dossier_projet / app / controllers / upvotes.php
 
dossier_projet / app / controllers / users.php
 
Ouvrir models / database.php avec un éditeur.
Nous créons d'abord la capsule:
addConnection (['driver' => DBDRIVER, 'host' => DBHOST, 'database' => DBNAME, 'username' => DBUSER, 'password' => DBPASS, 'charset' => 'utf8', 'collation' => 'utf8_unicode_ci', 'prefix' => ",]); // Configurez l'OR éloquent… $ capsule-> bootEloquent ();
Dans le fichier ci-dessus, nous initialisons et configurons la capsule avec les constantes définies dans config.php, puis nous démarrons éloquent.
L'étape suivante consiste à créer un script de démarrage. Ce sera un fichier où tout ce qui doit être exécuté avant que notre application fonctionne est exécuté.
Nous créons un fichier de démarrage à l'emplacement dossier_projet / start.php, puis, dans le fichier, demandez le fichier de chargement automatique du compositeur:
nécessite 'vendor / autoload.php';
Après cela, nous avons besoin config.php pour obtenir les identifiants définis: nécessite 'config.php';
Puis on initialise la classe de base de données.
Votre fichier start.php devrait ressembler à ceci:
Incluez start.php dans votre index.php car ce sera notre fichier principal.
Notre fichier index.php ressemble maintenant à ceci:
 
Ensuite, nous pouvons commencer à travailler sur nos contrôleurs et nos modèles. Dans dossier de projet/ app /modèles / question.php, nous ajoutons ceci:
Puis dans dossier de projet/app/controllers/questions.php:
Dans dossier de projet/app/controllers/answers.php, nous faisons la même chose:
Tâche 1: Ajouter un utilisateur
Dans le modèle utilisateur (dossier de projet/app/models/user.php), nous ajoutons le code suivant pour définir notre espace de noms, étendre le modèle Eloquent et définir le nom de la table (table protégée) et quels champs des tables peuvent être remplis par la création en masse (protégé $ remplissable).
Dans le contrôleur d'utilisateurs (dossier de projet/app/controllers/user.php), nous définissons notre espace de noms et notre classe comme d'habitude:
Ensuite, pour créer un utilisateur, dans le contrôleur des utilisateurs, nous importons l’espace de noms de modèles, utilisez Models \ User;, puis ajoutez une fonction pour créer l'utilisateur.
$ username, 'email' => $ email, 'password' => $ password]); return $ user; 
Notre contrôleur d'utilisateur ressemble maintenant à ceci.
$ username, 'email' => $ email, 'password' => $ password]); return $ user; ?>
Ensuite, dans index.php, nous ajoutons ces lignes et exécutons l'application pour créer un nouvel utilisateur..
Tâche 2: Ajouter une question
Pour ajouter une question, importons l’espace de nom du modèle Question dans le contrôleur de questions et écrivons un create_question une fonction:
utilisez Models \ Question;
Ensuite:
$ question, 'user_id' => $ user_id]); return $ question;  
Nous avons utilisé des modèles de création de masse Eloquent pour insérer cet enregistrement, mais avant que cela fonctionne, nous devons permettre à ces champs de pouvoir être remplis, car les modèles Eloquent protègent contre la création de masse par défaut..
Alors on va au question modèle et ajouter le protégé $ remplissable propriété à la classe.
protected $ fillable = ['question', 'user_id'];
Pour exécuter cela, importez le contrôleur de questions dans index.php et appelez le create_question fonction statique:
utiliser les contrôleurs \ Question;
Créez ensuite une question avec une question et un ID utilisateur en tant que paramètres:
$ question = Questions :: create_question ("Avez-vous déjà rencontré votre doppelganger?", 1);
Ceci retourne un objet de modèle en cas de succès.
Nous allons maintenant exécuter le script index.php avec différentes entrées pour ajouter plus de questions à la base de données.
Tâche 3: Ajouter une réponse à une question 
Dans le modèle de réponse, nous répétons les étapes suivies pour les modèles de question et d'utilisateur en ajoutant le code ci-dessous:
Ensuite, dans le correcteur de réponses, nous écrivons ces lignes:
$ answer, 'question_id' => $ question_id, 'user_id' => $ user_id]); return $ answer; ?>
Ensuite, dans index.php, nous pouvons créer une réponse à la question portant l'id 1 que nous avons ajoutée précédemment, avec l'utilisateur id 2. N'oubliez pas d'importer le contrôleur de réponses dans index.php en premier.
Pour empêcher plusieurs entrées, commentez tous les autres appels dans index.php avant d’en exécuter un nouveau..
Tâche 4: vote positif et réponse
C’est à peu près les mêmes étapes que celles auxquelles nous sommes habitués.
Donc, nous allons copier ceci dans le modèle Upvote à dossier de projet/ app /models / upvote.php.
Ensuite, dans les réponses des contrôleurs, nous importons l’espace de noms Upvote Model..
utilisez Models \ Upvote;
Ensuite, nous créons un upvote_answer une fonction.
$ answer_id, 'user_id' => $ user_id]); renvoyer $ upvote; 
Dans index.php, nous pouvons appeler la fonction avec un ID utilisateur fictif pour inverser la réponse avec l'id 1.
$ upvote = Answers :: upvote_answer (1,14); 
Tâche 5: Obtenez une question avec des réponses
Pour de telles tâches, nous pouvons utiliser les relations Eloquent.
Les types de relations incluent les relations un à un, un à plusieurs, plusieurs à plusieurs, etc..
Lors de l'utilisation de ces relations, Eloquent suppose une clé étrangère sous la forme nom du modèle_id existe sur les modèles. Pour cette tâche, la relation est une relation un-à-plusieurs, car une seule question peut avoir toutes les réponses.
Nous définissons d'abord cette relation en ajoutant cette fonction à notre modèle de question.
hasMany ('\ Models \ Answer'); 
Ensuite, dans le contrôleur de questions, nous écrivons une fonction pour obtenir des questions avec des réponses.
get () -> toArray (); retourne $ questions; 
Ceci récupère les questions avec leurs réponses correspondantes.
Dans index.php, nous commentons tous les autres appels et exécutons:
$ all = Questions :: get_questions_with_answers ();
nous pouvons var_dump ou print_r la $ tout variable pour voir les résultats.
Tâche 6: Obtenez toutes les questions et les utilisateurs qui les ont posées
Il s'agit d'une relation un à un, car une question a un utilisateur, nous l'ajoutons donc au modèle de question..
appartient à ('\ Models \ User'); 
Ensuite, nous créons une fonction dans le contrôleur de questions et utilisons le avec fonction sur le modèle de question.
get () -> toArray (); retourne $ questions; 
Dans index.php, commentez tous les autres et lancez ceci:
$ all_with_users = Questions :: get_questions_with_users ();
Tâche 7: Obtenez une question avec réponses et votes positifs
Premièrement, nous définissons une relation entre les réponses et les votes positifs. Une réponse a beaucoup de votes positifs, donc la relation est un à plusieurs.
Nous ajoutons donc la fonction suivante à notre modèle de réponse:
hasMany ('\ Models \ Upvote'); 
Ensuite, dans le contrôleur de questions, nous créons la fonction pour obtenir ceci:
réponses () -> avec ('upvotes') -> get () -> toArray (); retourne $ questions; 
Comme dans les étapes précédentes, nous commentons tous les autres appels à index.php et exécutons ceci:
$ one_question = Questions :: get_question_answers_upvotes (1);
Nous pouvons imprimer le $ one_question variable pour voir les résultats.
Tâche 8: Compter toutes les questions d'un utilisateur particulier
Nous importons d’abord le modèle de question dans les contrôleurs d’utilisateurs:
utilisez Models \ Question;
Ensuite, nous écrivons cette fonction:
compter(); return $ count; 
Dans index.php, nous commentons d'autres appels et ajoutons cette ligne:
$ user_question_count = Users :: question_count (1);
Ceci retourne un entier qui correspond au nombre de questions ajoutées par un utilisateur ayant l'identifiant 1. 
Nous pouvons imprimer le $ user_question_count variable et lancez index.php pour voir les résultats.
Tâche 9: Réponse mise à jour par utilisateur
Le concept de mise à jour avec l'ORM Eloquent est assez simple. Nous trouvons d’abord un enregistrement, puis nous mutons et sauvons.
Maintenant, dans les réponses des contrôleurs, nous ajoutons cette fonction:
answer = $ new_answer; $ updated = $ answer-> save (); return $ updated; 
Dans index.php, nous pouvons commenter tous les autres appels et mettre à jour la réponse avec l'id 1 comme ceci:
$ update_answer = Answers :: update_answer (1, "Ceci est une réponse mise à jour");
Ceci retourne une valeur booléenne-true-si la mise à jour est réussie.
Tâche 10: Supprimer une question (suppression progressive)
Dans cette tâche finale, nous allons implémenter Eloquent SoftDelete.
Tout d'abord, nous disons au modèle de question à utiliser SoftDeletes en important le SoftDeletes espace de noms, puis en utilisant le SoftDeletes trait dans notre classe.
utilisez Illuminate \ Database \ Eloquent \ SoftDeletes;
Ensuite, après la ligne de déclaration de classe, nous ajoutons cette ligne:
utilisez SoftDeletes;
Puis on ajoute delete_at au dates protégées $ propriété pour le modèle. Ce sont les étapes requises. 
protected $ dates = ['delete_at'];
Notre modèle de question ressemble maintenant à ceci:
hasMany ('\ Models \ Answer');  fonction publique user () return $ this-> appartientTo ('\ Models \ User'); ?>
Ensuite, nous créons le delete_question fonction dans le contrôleur de questions.
effacer(); retour $ supprimé;  
Exécuter dans index.php:
$ delete = Questions :: delete_question (1);
Toutes nos félicitations! Vous venez de construire un back-end entièrement fonctionnel avec Illuminate et Eloquent. Et nous n'avons pas eu à écrire autant de code pour accomplir tout cela.
Le code de ce tutoriel est disponible sur GitHub. 
Conclusion
Illuminate est également livré avec le générateur de requêtes que vous pouvez utiliser pour des requêtes de base de données encore plus complexes. Il s'agit certainement de quelque chose que vous souhaitez expérimenter et utiliser dans votre application..
La seule chose qui manque dans la base de données Illuminate autonome, ce sont les migrations de base de données, qui sont une jolie fonctionnalité de Laravel, et Lumen, le microframework de Laravel. Vous devriez envisager d'utiliser les deux applications dans vos applications pour tirer parti des fonctionnalités utiles fournies avec ces applications..
Vous pouvez en savoir plus sur Eloquent sur la page de documentation officielle Eloquent.
Références
 
Illuminate Database sur GitHub
 
Eloquent ORM docs
 



		
			
	   
	




Code