Timelines utilisateur efficaces dans une application PHP avec Neo4j

Les plats clés

• La mise en œuvre des délais utilisateur pour les applications sociales peut être difficile avec les bases de données SQL ou NOSQL courantes en raison de la complexité des requêtes et des impacts de performance. Les bases de données de graphiques, comme Neo4j, peuvent éliminer ces problèmes.
• Une technique de modélisation courante pour les flux d'utilisateurs dans les bases de données de graphiques est la liste liée. Cela permet un accès immédiat au dernier article d'un utilisateur, sans avoir besoin d'un horodatage pour récupérer la chronologie.
• Le tutoriel montre comment étendre une application de démonstration construite sur SILEX pour modéliser efficacement les flux d'utilisateurs. Il s'agit de créer un itinéraire pour afficher les flux d'un utilisateur spécifique, récupérer les flux de la base de données NEO4J et les passer au modèle avec le nœud utilisateur.
• Pour afficher une chronologie de l'utilisateur, il faut récupérer tous les utilisateurs qu'il suit et étendre la requête à la relation Last_Post de chaque utilisateur. Les publications sont ensuite filtrées par le temps de les commander entre les utilisateurs.
• L'ajout d'une publication à la chronologie consiste à créer le nœud de poste, à supprimer la relation Last_Post de l'utilisateur à l'ancien dernier_post, à créer une nouvelle relation entre le dernier nœud de post et l'utilisateur, et la création de la relation précédente_post entre le nouveau et ancien Dernier message nœuds.

Toute application sociale que vous rencontrez de nos jours présente une chronologie, montrant les statuts de vos amis ou abonnés généralement dans un ordre décroissant de temps. La mise en œuvre d'une telle fonctionnalité n'a jamais été facile avec les bases de données SQL ou NOSQL communes.

complexité des requêtes, des impacts de performance augmentant avec le nombre d'amis / abonnés et les difficultés pour faire évoluer votre modèle social sont des points que les bases de données graphiques éliminent.

Dans ce tutoriel, nous allons étendre l'application de démonstration utilisée par les deux articles d'introduction sur NEO4J et PHP, respectivement:

• Découvrez des bases de données de graphiques avec Neo4j et Php

• Ajout de fonctionnalités de réseau social à une application PHP avec Neo4j

L'application est construite sur Silex et a des utilisateurs suivant d'autres utilisateurs. L'objectif tout au long de cet article sera de modéliser la caractéristique des flux efficacement afin de récupérer les deux derniers articles des personnes que vous suivez et de les commander par le temps.

Vous découvrirez une technique de modélisation particulière appelée liste liée et quelques requêtes avancées avec Cypher.

Le code source de cet article peut être trouvé dans son propre référentiel GitHub.

Modélisation d'une chronologie dans une base de données de graphiques

Les personnes habituées à d'autres techniques de modélisation de la base de données ont tendance à relier chaque publication à l'utilisateur. Un poste aurait une propriété d'horodatage et l'ordre des postes sera effectué contre cette propriété.

Voici une représentation simple:

Bien qu'un tel modèle fonctionnera sans aucun problème, il y a quelques inconvénients:

• Pour chaque utilisateur, vous devrez commander ses messages à l'heure pour obtenir le dernier
• L'opération de commande augmentera linéairement avec la quantité de messages et d'utilisateurs que vous suivez
• Il oblige la base de données à exécuter des opérations pour la commande

Tirez parti de la puissance d'une base de données de graphiques

Un nœud dans une base de données de graphiques contient une référence aux connexions qu'il a, fournissant des performances rapides pour les traversées de graphiques.

Une technique de modélisation courante pour les flux d'utilisateurs est appelée liste liée. Dans notre application, le nœud utilisateur aura une relation nommée last_post au dernier post créé par l'utilisateur. Ce message aura une relation précédente_post avec la précédente qui a également un précédent_post au deuxième post précédent, etc., etc…

Avec ce modèle, vous avez immédiatement accès au dernier message d'un utilisateur. En fait, vous n'avez même pas du tout besoin d'avoir un horodat

Plus important encore, ce que l'utilisateur fait dans le temps est modélisé de manière naturelle dans une base de données de graphiques. Être capable de stocker les données d'une manière qui correspond à la façon dont ces données vivent en dehors de la base de données est un réel avantage pour l'analyse, les recherches et la compréhension de vos données.

Configuration initiale

Je vous suggère de télécharger le référentiel utilisé pour les articles d'introduction et de le renommer sur le temps social par exemple:

<span>git clone git@github.com:sitepoint-editors/social-network
</span><span>mv social-network social-timeline
</span>
<span>cd social-timeline
</span><span>rm -rf .git
</span><span>composer install
</span>bower <span>install</span>

Comme dans les articles précédents, nous allons charger la base de données avec un ensemble de données factices généré à l'aide de Graphgen.

Vous devrez avoir une base de données en cours d'exécution (locale ou distante), accédez à ce lien, cliquez sur Générer, puis sur "remplir votre base de données".

Si vous utilisez Neo4j 2.2, vous devrez fournir le nom d'utilisateur NEO4J et votre mot de passe dans la boîte Graphgen Populator:

Cela importera 50 utilisateurs avec une connexion, un prénom et un nom de famille. Chaque utilisateur aura deux articles de blog, un avec une relation Last_Post avec l'utilisateur et une avec une relation précédente_post avec l'autre flux.

Si vous ouvrez maintenant le navigateur NEO4J, vous pouvez voir comment les utilisateurs et les publications sont modélisés:

Affichage des flux d'utilisateurs

L'application a déjà un ensemble de contrôleurs et de modèles. Vous pouvez choisir un utilisateur en cliquant sur eux et il affichera leurs abonnés et quelques suggestions de personnes à suivre.

L'utilisateur alimente la route

Tout d'abord, nous ajouterons un itinéraire pour afficher les flux d'un utilisateur spécifique. Ajoutez cette partie du code à la fin du fichier web / index.php

<span>git clone git@github.com:sitepoint-editors/social-network
</span><span>mv social-network social-timeline
</span>
<span>cd social-timeline
</span><span>rm -rf .git
</span><span>composer install
</span>bower <span>install</span>

Le contrôleur de flux utilisateur et la requête Cypher

Nous allons cartographier l'itinéraire vers une action dans le fichier src / contrôleur / webController.php.

Dans cette action, nous allons récupérer les flux de l'utilisateur donné de la base de données NEO4J et les passer au modèle avec le nœud utilisateur.

<span>$app->get('/users/{user_login}/posts', 'Ikwattro\SocialNetwork\Controller\WebController::showUserPosts')
</span>    <span>->bind('user_post');</span>

quelques explications:

• Nous correspondons d'abord à un utilisateur par son nom de connexion.
• Nous correspondons ensuite au dernier flux de l'utilisateur et nous nous étendons au précédent_feed (l'utilisation de la profondeur de la relation * 0..2 aura un effet pour intégrer le nœud dernier_post à l'intérieur de la collection de nœuds de poste) et nous limitons la profondeur maximale à 2.
• Nous renvoyons les flux trouvés dans une collection.

Affichage des flux dans le modèle

Nous allons d'abord ajouter un lien dans le profil utilisateur pour accéder à leurs flux, en ajoutant simplement cette ligne après à la fin du bloc d'informations utilisateur:

<span>public function showUserPosts(Application $application, Request $request)
</span>    <span>{
</span>        <span>$login = $request->get('user_login');
</span>        <span>$neo = $application['neo'];
</span>        <span>$query = 'MATCH (user:User) WHERE user.login = {login}
</span><span>        MATCH (user)-[:LAST_POST]->(latest_post)-[PREVIOUS_POST*0..2]->(post)
</span><span>        RETURN user, collect(post) as posts';
</span>        <span>$params = ['login' => $login];
</span>        <span>$result = $neo->sendCypherQuery($query, $params)->getResult();
</span>
        <span>if (null === $result->get('user')) {
</span>            <span>$application->abort(404, 'The user $login was not found');
</span>        <span>}
</span>
        <span>$posts = $result->get('posts');
</span>
        <span>return $application['twig']->render('show_user_posts.html.twig', array(
</span>            <span>'user' => $result->getSingle('user'),
</span>            <span>'posts' => $posts,
</span>        <span>));
</span>    <span>}</span>

Nous allons maintenant créer notre modèle affichant la chronologie de l'utilisateur (Posts). Nous définissons une rubrique et une boucle itérant notre collection de flux pour les afficher dans une div HTML dédiée:

<span><span><span><p</span>></span><span><span><a</span> href<span>="{{ path('user_post', {user_login: user.property('login') }) }}"</span>></span>Show posts<span><span></a</span>></span><span><span></p</span>></span></span>

Si vous choisissez maintenant un utilisateur et cliquez sur le lien Afficher les messages d'utilisateur , vous pouvez voir que nos messages sont bien affichés et commandés par heure décroissante sans spécifier une propriété de date.

Affichage de la chronologie

Si vous avez importé l'échantillon de données avec Graphgen, chacun de vos utilisateurs suivra environ 40 autres utilisateurs.

Pour afficher une chronologie de l'utilisateur, vous devez récupérer tous les utilisateurs qu'il suit et étendre la requête à la relation Last_Post de chaque utilisateur.

Lorsque vous obtenez tous ces messages, vous devez les filtrer en les commander entre les utilisateurs.

La route de la chronologie de l'utilisateur

Le processus est le même que le précédent - nous ajoutons l'itinéraire à index.php, nous créons notre action de contrôleur, nous ajoutons un lien à la chronologie du modèle de profil utilisateur et nous créons notre modèle de chronologie utilisateur.

Ajoutez l'itinéraire au fichier web / index.php

{% extends "layout.html.twig" %}

{% block content %}
    <span><span><span><h1</span>></span>Posts for {{ user.property('login') }}<span><span></h1</span>></span>
</span>
    {% for post in posts %}
        <span><span><span><div</span> class<span>="row"</span>></span>
</span>        <span><span><span><h4</span>></span>{{ post.properties.title }}<span><span></h4</span>></span>
</span>        <span><span><span><div</span>></span>{{ post.properties.body }}<span><span></div</span>></span>
</span>        <span><span><span></div</span>></span>
</span>        <span><span><span><hr</span>/></span>
</span>    {% endfor %}

{% endblock %}

L'action du contrôleur:

<span>$app->get('/user_timeline/{user_login}', 'Ikwattro\SocialNetwork\Controller\WebController::showUserTimeline')
</span>    <span>->bind('user_timeline');</span>

Explications sur la requête:

• Nous correspondons d'abord à notre utilisateur.
• Ensuite, nous correspondons au chemin entre cet utilisateur, les autres utilisateurs qu'il suit et leur dernier flux (voir ici comment Cypher est vraiment expressif sur ce que vous voulez récupérer).
• Nous commandons les flux par leur horodatage.
• Nous renvoyons les flux dans les collections contenant l'auteur et le flux.
• Nous limitons le résultat à 20 aliments.

Ajoutez un lien au modèle de profil utilisateur, juste après le lien de flux utilisateur:

<span>public function showUserTimeline(Application $application, Request $request)
</span>    <span>{
</span>        <span>$login = $request->get('user_login');
</span>        <span>$neo = $application['neo'];
</span>        <span>$query = 'MATCH (user:User) WHERE user.login = {user_login}
</span><span>        MATCH (user)-[:FOLLOWS]->(friend)-[:LAST_POST]->(latest_post)-[:PREVIOUS_POST*0..2]->(post)
</span><span>        WITH user, friend, post
</span><span>        ORDER BY post.timestamp DESC
</span><span>        SKIP 0
</span><span>        LIMIT 20
</span><span>        RETURN user, collect({friend: friend, post: post}) as timeline';
</span>        <span>$params = ['user_login' => $login];
</span>        <span>$result = $neo->sendCypherQuery($query, $params)->getResult();
</span>
        <span>if (null === $result->get('user')) {
</span>            <span>$application->abort(404, 'The user $login was not found');
</span>        <span>}
</span>
        <span>$user = $result->getSingle('user');
</span>        <span>$timeline = $result->get('timeline');
</span>
        <span>return $application['twig']->render('show_timeline.html.twig', array(
</span>            <span>'user' => $result->get('user'),
</span>            <span>'timeline' => $timeline,
</span>        <span>));
</span>    <span>}</span>

et créez le modèle de chronologie:

<span><span><span><p</span>></span><span><span><a</span> href<span>="{{ path('user_timeline', {user_login: user.property('login') }) }}"</span>></span>Show timeline<span><span></a</span>></span><span><span></p</span>></span></span>

Nous avons maintenant une chronologie assez cool montrant les 20 derniers flux des personnes que vous suivez qui sont efficaces pour la base de données.

ajoutant un message à la chronologie

Afin d'ajouter des publications aux listes liées, la requête Cypher est un peu plus Tricky . Vous devez créer le nœud post, supprimer la relation Last_Post de l'utilisateur à l'ancien dernier_post, créer la nouvelle relation entre le tout dernier nœud de post et l'utilisateur et enfin créer la relation précédente_post entre les nouveaux et anciens derniers nœuds de message.

Simple, n'est-ce pas? Allons-y!

Comme d'habitude, nous allons créer la route postale pour le formulaire pointant vers l'action WebController:

<span>git clone git@github.com:sitepoint-editors/social-network
</span><span>mv social-network social-timeline
</span>
<span>cd social-timeline
</span><span>rm -rf .git
</span><span>composer install
</span>bower <span>install</span>

Ensuite, nous ajouterons un formulaire HTML de base pour insérer le titre de publication et le texte dans le modèle d'utilisateur:

<span>$app->get('/users/{user_login}/posts', 'Ikwattro\SocialNetwork\Controller\WebController::showUserPosts')
</span>    <span>->bind('user_post');</span>

Et enfin, nous créons notre nouvelle action:

<span>public function showUserPosts(Application $application, Request $request)
</span>    <span>{
</span>        <span>$login = $request->get('user_login');
</span>        <span>$neo = $application['neo'];
</span>        <span>$query = 'MATCH (user:User) WHERE user.login = {login}
</span><span>        MATCH (user)-[:LAST_POST]->(latest_post)-[PREVIOUS_POST*0..2]->(post)
</span><span>        RETURN user, collect(post) as posts';
</span>        <span>$params = ['login' => $login];
</span>        <span>$result = $neo->sendCypherQuery($query, $params)->getResult();
</span>
        <span>if (null === $result->get('user')) {
</span>            <span>$application->abort(404, 'The user $login was not found');
</span>        <span>}
</span>
        <span>$posts = $result->get('posts');
</span>
        <span>return $application['twig']->render('show_user_posts.html.twig', array(
</span>            <span>'user' => $result->getSingle('user'),
</span>            <span>'posts' => $posts,
</span>        <span>));
</span>    <span>}</span>

quelques explications:

• Nous correspondons d'abord à l'utilisateur, puis nous correspondons éventuellement à son nœud Last_Post.
• Nous supprimons la relation entre l'utilisateur et son dernier dernier post.
• Nous créons notre nouveau message (qui est en fait son dernier post dans sa chronologie réelle).
• Nous créons la relation entre l'utilisateur et son «nouveau» dernier message.
• Nous cassons la requête et passons à l'utilisateur, le dernier post et une collection de ses anciens derniers_posts.
• Nous allons ensuite parcourir la collection et créer une relation précédente_post entre le nouveau dernier post et le suivant.

La partie délicate ici, c'est que la collection OldlatestPosts contiendra toujours 0 ou 1 éléments, ce qui est idéal pour notre requête.

Conclusion

Dans cet article, nous avons découvert une technique de modélisation appelée liste liée, appris à implémenter cela dans une application sociale et à récupérer les nœuds et les relations de manière efficace. Nous avons également appris de nouvelles clauses Cypher comme Skip and Limit, utile pour la pagination.

Bien que les délais du monde réel soient un peu plus complexes que ce que nous avons vu ici, j'espère qu'il est évident comment les bases de données graphiques comme Neo4j sont vraiment le meilleur choix pour ce type d'application.

Questions fréquemment posées (FAQ) sur les délais efficaces des utilisateurs dans l'application PHP avec neo4j

Comment puis-je visualiser mes données de chronologie dans Neo4j?

Visualiser les données de la chronologie dans Neo4j peut être obtenue à l'aide de divers outils tels que Kronograph. Cet outil vous permet de créer des délais interactifs, dynamiques et visuellement attrayants. Vous pouvez personnaliser le calendrier pour répondre à vos besoins, ajouter des événements et même les lier à d'autres événements. Cela facilite la compréhension des relations et des modèles de vos données.

Comment puis-je utiliser NEO4J pour analyser les données Twitter?

Neo4j peut être utilisée pour analyser les données Twitter en créant une chronologie visuelle. Cela implique d'extraire les données de Twitter, de les importer dans NEO4J, puis d'utiliser des requêtes Cypher pour analyser les données. La chronologie visuelle peut aider à révéler les modèles et les tendances des données, telles que l'activité d'un utilisateur particulier ou la propagation d'un hashtag spécifique.

Comment puis-je représenter les événements de la chronologie dans Neo4j?

Les événements de chronologie dans NEO4J peuvent être représentés comme des nœuds et des relations. Chaque événement est un nœud, et les relations entre elles représentent la séquence d'événements. Vous pouvez utiliser des propriétés sur les nœuds et les relations pour stocker des informations supplémentaires sur les événements, tels que le temps où ils se sont produits ou leur durée.

Quelles versions de PHP sont prises en charge avec Neo4j?

NEO4J Une large gamme de versions PHP. Cependant, il est toujours recommandé d'utiliser la dernière version stable de PHP pour les meilleures performances et sécurité. Vous pouvez consulter le site Web officiel de PHP pour obtenir des informations sur les versions actuellement prises en charge.

Comment PHP a-t-il évolué au fil des ans?

PHP a évolué considérablement depuis sa création. Il a commencé comme un langage de script simple pour le développement Web, mais est devenu un langage de programmation à part entière avec le support pour la programmation orientée objet, la programmation fonctionnelle, etc. Chaque nouvelle version de PHP apporte des améliorations des performances, de la sécurité et des fonctionnalités.

Comment puis-je optimiser les performances de mon application PHP avec Neo4j?

Optimisation des performances d'une application PHP avec Neo4j implique plusieurs stratégies. Ceux-ci incluent l'optimisation de vos requêtes Cypher, l'utilisation d'index pour accélérer la récupération des données et la gestion efficacement de vos connexions de base de données. De plus, vous devez toujours utiliser la dernière version de PHP et NEO4J pour les meilleures performances.

Comment puis-je sécuriser mon application PHP avec Neo4j?

La sécurisation d'une application PHP avec Neo4j implique plusieurs étapes. Il s'agit notamment de l'utilisation de connexions de base de données sécurisées, de désinfecter la saisie des utilisateurs pour empêcher les attaques d'injection et d'implémenter une gestion des erreurs appropriée. De plus, vous devez toujours garder votre logiciel PHP et NEO4J à jour pour bénéficier des derniers correctifs de sécurité.

Comment puis-je gérer les erreurs dans mon application PHP avec Neo4j?

Gestion des erreurs dans un L'application PHP avec NEO4J peut être effectuée à l'aide de blocs de capture d'essai. Cela vous permet d'attraper toutes les exceptions qui se produisent lors de l'exécution de votre code et de les gérer de manière appropriée. Vous pouvez également utiliser la journalisation des erreurs pour suivre les problèmes qui se produisent.

Comment puis-je mettre à l'échelle mon application PHP avec Neo4j?

La mise à l'échelle d'une application PHP avec NEO4J peut être réalisée par diverses stratégies. Il s'agit notamment de l'utilisation des fonctionnalités de clustering de Neo4j pour distribuer vos données sur plusieurs serveurs, d'optimisation de votre schéma de base de données et de requêtes pour les performances, et de l'utilisation de la mise en cache pour réduire la charge de base de données.

Comment puis-je migrer mon application PHP existante pour utiliser Neo4j?

Migrating Une application PHP existante pour utiliser Neo4j implique plusieurs étapes. Tout d'abord, vous devez modéliser vos données en tant que graphique et les importer dans NEO4J. Ensuite, vous devez mettre à jour votre code d'application pour utiliser le pilote PHP de Neo4j pour les opérations de base de données. Enfin, vous devez tester soigneusement votre application pour vous assurer qu'il fonctionne correctement avec Neo4j.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!