Effiziente Benutzerzeitpläne in einer PHP -Anwendung mit NEO4J

Key Takeaways

• Implementierung von Benutzerzeitplänen für soziale Anwendungen kann aufgrund der Komplexität von Abfragen und Leistungsauswirkungen mit gemeinsamen SQL- oder NoSQL -Datenbanken eine Herausforderung sein. Diagrammdatenbanken wie Neo4j können diese Probleme beseitigen.
• Eine gemeinsame Modellierungstechnik für Benutzer -Feeds in Graph -Datenbanken ist die verknüpfte Liste. Dies ermöglicht sofortigen Zugriff auf den neuesten Beitrag eines Benutzers, ohne einen Zeitstempel zu benötigen, um die Zeitleiste abzurufen.
• Das Tutorial zeigt, wie eine Demo -Anwendung erweitert wird, die auf Silex basiert, um Benutzer -Feeds effizient zu modellieren. Es wird eine Route zum Anzeigen der Feeds eines bestimmten Benutzers erstellen, die Feeds aus der NEO4J -Datenbank abrufen und sie zusammen mit dem Benutzerknoten an die Vorlage weitergeben.
• Um eine Benutzerzeitleiste anzuzeigen, muss man alle Benutzer abrufen, die er folgt, und die Abfrage von jedem Benutzer auf die Last_Post -Beziehung erweitern. Die Beiträge werden dann nach der Zeit filtriert, um sie zwischen Benutzern zu bestellen.
• Hinzufügen eines Beitrags zur Zeitleiste beinhaltet das Erstellen des Postknoten Letzte Postknoten.

Jede soziale Anwendung, auf die Sie heutzutage begegnen, verfügt über eine Zeitleiste, in der Status Ihrer Freunde oder Follower im Allgemeinen in einer absteigenden Reihenfolge angezeigt wird. Die Implementierung einer solchen Funktion war in den gemeinsamen SQL- oder NoSQL -Datenbanken noch nie einfach.

Komplexität von Abfragen, Leistungseinflüsse, die mit der Anzahl der Freunde/Follower zunehmen, und Schwierigkeiten, Ihr soziales Modell zu entwickeln

In diesem Tutorial werden wir die Demo -Anwendung erweitern, die von den beiden Einführungsartikeln über NEO4J bzw. PHP verwendet wird:

• DIPH -Datenbanken mit NEO4J und PHP
  entdecken
• Hinzufügen sozialer Netzwerkfunktionen zu einer PHP -App mit NEO4J

Die Anwendung basiert auf Silex und hat Benutzer, die anderen Benutzern folgen. Das Ziel in diesem Artikel wird darin bestehen, das Merkmal von Feeds effizient zu modellieren, um die letzten beiden Beiträge der Personen abzurufen, denen Sie folgen, und sie nach Zeit zu bestellen.

Sie werden eine bestimmte Modellierungstechnik namens Linked List und einige erweiterte Abfragen mit Cypher entdecken.

Der Quellcode für diesen Artikel ist in seinem eigenen Github -Repository zu finden.

Modellierung einer Zeitleiste in einer Diagrammdatenbank

Personen, die an andere Datenbankmodellierungstechniken gewöhnt sind, beziehen jeden Beitrag an den Benutzer. Ein Beitrag hätte eine Zeitstempeleigenschaft und die Reihenfolge der Stellen wird gegen diese Eigenschaft durchgeführt.

Hier ist eine einfache Darstellung:

Während ein solches Modell ohne Probleme funktioniert, gibt es einige Nachteile:

• Für jeden Benutzer müssen Sie seine Beiträge nach Zeit bestellen, um den letzten
zu erhalten
• Der Bestellvorgang wächst linear mit der Anzahl der Beiträge und den Benutzern, denen Sie
folgen, linear
• erzwingt die Datenbank, Operationen für die Bestellung
auszuführen

Nutzen Sie die Leistung einer Diagrammdatenbank

Ein Knoten in einer Diagrammdatenbank enthält einen Verweis auf die Verbindungen, die er hat, und bietet eine schnelle Leistung für Graphen -Travers.

Eine gemeinsame Modellierungstechnik für Benutzerfeeds wird als verlinkte Liste bezeichnet. In unserer Anwendung hat der Benutzerknoten eine Beziehung mit dem Namen last_post zum letzten vom Benutzer erstellten Beitrag. Dieser Beitrag hat eine vorherige Beziehung zur vorherigen Beziehung, die auch einen vorherigen zum zweiten vorherigen Beitrag usw. hat usw.

Mit diesem Modell haben Sie sofortigen Zugriff auf den neuesten Beitrag eines Benutzers. Tatsächlich müssen Sie gar nicht einen Zeitstempel haben, um seine Zeitleiste abzurufen (wir werden es jedoch behalten, um die Beiträge über verschiedene Benutzer hinweg zu sortieren).

Noch wichtiger ist, was der Benutzer in der Zeit in einer Grafikdatenbank auf natürliche Weise modelliert wird. Die Möglichkeit, die Daten auf eine Weise zu speichern, die entspricht, wie diese Daten außerhalb der Datenbank leben

Erstes Setup

Ich schlage vor, Sie laden das Repository herunter, das für die Einführungsartikel verwendet wird, und benennen Sie es zum Beispiel in Social-Timeline um:

<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>

Wie in den vorherigen Artikeln werden wir die Datenbank mit einem generierten Dummy -Datensatz mit Hilfe von Graphgen laden.

Sie müssen eine laufende Datenbank (lokal oder fern) haben, zu diesem Link gehen, auf Generieren klicken und dann unter "Ihre Datenbank populieren".

Wenn Sie NEO4J 2.2 verwenden, müssen Sie den NEO4J -Benutzernamen und Ihr Passwort im Populatorbox Graphgen angeben:

importiert 50 Benutzer mit Anmeldung, Vorname und Nachname. Jeder Benutzer hat zwei Blog -Beiträge, eine mit einer last_post -Beziehung zum Benutzer und eines mit einer vorherigen Beziehung zu dem anderen Feed.

Wenn Sie jetzt den NEO4J -Browser öffnen, können Sie sehen, wie die Benutzer und Beiträge modelliert werden:

Anzeigen des Benutzer -Feeds

Die Anwendung verfügt bereits über eine Reihe von Controllern und Vorlagen. Sie können einen Benutzer auswählen, indem Sie auf sie klicken, und er zeigt ihre Follower und einige Vorschläge von Personen an.

Der Benutzer füttert Route

Erstens werden wir eine Route zum Anzeigen der Feeds eines bestimmten Benutzers hinzufügen. Fügen Sie diesen Teil des Codes zum Ende der Web/index.php -Datei

hinzu

<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>

Der Benutzer füttert den Controller und die Cypher -Abfrage

Wir werden die Route zu einer Aktion in der Datei src/Controller/webcontroller.php zuordnen.

In dieser Aktion werden wir die Feeds des gegebenen Benutzers aus der NEO4J -Datenbank abrufen und sie zusammen mit dem Benutzerknoten an die Vorlage weitergeben.

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

Einige Erklärungen:

• Wir stimmen zuerst mit seinem Login -Namen mit einem Benutzer überein.
• Wir stimmen dann mit dem letzten Feed des Benutzer 2.
• Wir geben die gefundenen Feeds in einer Sammlung zurück.

Anzeigen der Feeds in der Vorlage

Wir werden zuerst einen Link im Benutzerprofil hinzufügen, um auf ihre Feeds zuzugreifen, indem wir diese Zeile am Ende des Benutzerinformationsblocks nur hinzufügen:

<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>

Wir werden jetzt unsere Vorlage erstellen, die die User Timeline (Beiträge) angezeigt wird. Wir setzen eine Überschrift und eine Schleife, die unsere Feeds -Sammlung iteriert, um sie in einem dedizierten HTML Div:

anzuzeigen

<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>

Wenn Sie jetzt einen Benutzer auswählen und auf den Link Benutzerbeiträge anzeigen klicken, können Sie feststellen, dass unsere Beiträge gut angezeigt und durch Abstiegszeit bestellt werden, ohne eine Datumseigenschaft anzugeben.

Zeigen Sie die Timeline

an

Wenn Sie den Beispieldatensatz mit Graphgen importiert haben, folgt jeder Ihrer Benutzer ungefähr 40 andere Benutzer.

Um eine Benutzerzeitleiste anzuzeigen, müssen Sie alle Benutzer abrufen, die er folgt, und die Abfrage von jedem Benutzer auf die Last_Post -Beziehung erweitern.

Wenn Sie alle diese Beiträge erhalten, müssen Sie sie nach Zeit filtern, um sie zwischen Benutzern zu bestellen.

Die User Timeline Route

Der Vorgang ist der gleiche wie der vorherige. Wir fügen die Route zum Index.php hinzu, erstellen unsere Controller -Aktion, wir fügen einen Link zur Zeitleiste in der Benutzerprofilvorlage hinzu und erstellen unsere Benutzer -Timeline -Vorlage.

Fügen Sie die Route zum Web/index.php -Datei

hinzu

{% 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 %}

Die Controller -Aktion:

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

Erklärungen zur Abfrage:

Zuerst stimmen wir mit unserem Benutzer überein.
Dann stimmen wir mit dem Pfad zwischen diesem Benutzer, den anderen Benutzern und ihrem letzten Feed überein (siehe hier, wie Cypher wirklich ausdrucksstark ist, was Sie abrufen möchten).
Wir bestellen die Feeds nach dem Zeitstempel.
Wir geben die Feeds in Sammlungen zurück, die den Autor und den Feed enthalten.
wir beschränken das Ergebnis auf 20 Feeds.

Fügen Sie einen Link zur Benutzerprofilvorlage hinzu, kurz nachdem der Benutzerversorgungslink:

<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>

und erstellen Sie die Timeline -Vorlage:

<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>

Wir haben jetzt eine ziemlich coole Zeitleiste, die die letzten 20 Feeds der Personen zeigt, denen Sie folgen, die für die Datenbank effizient sind.

Hinzufügen eines Beitrags zur Zeitleiste

Um Beiträge zu verknüpften Listen hinzuzufügen, ist die Cypher -Abfrage etwas mehr knifflig . Sie müssen den Postknoten erstellen, die Last_Post -Beziehung vom Benutzer zum alten neuesten_Post entfernen, die neue Beziehung zwischen dem allerersten Postknoten und dem Benutzer erstellen und schließlich die Vorgängerbeziehung zwischen den neuen und alten letzten Postknoten erstellen.

Einfach, nicht wahr? Lass uns gehen!

Wie gewohnt erstellen wir die Postroute für das Formular, das auf die WebController -Aktion hinweist:

<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>

Als nächstes werden wir ein grundlegendes HTML -Formular zum Einfügen des Posttitels und des Textes in die Benutzervorlage hinzufügen:

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

Und schließlich erstellen wir unsere NewPost -Aktion:

<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>

Einige Erklärungen:

• Wir stimmen zuerst mit dem Benutzer überein, dann stimmen wir optional mit seinem last_post -Knoten überein.
• Wir löschen die Beziehung zwischen dem Benutzer und seinem letzten letzten Beitrag.
• Wir erstellen unseren neuen Beitrag (der tatsächlich sein letzter Beitrag in seiner Zeitleiste im wirklichen Leben ist).
• Wir erstellen die Beziehung zwischen dem Benutzer und seinem „neuen“ letzten Beitrag.
• Wir brechen die Abfrage und übergeben den Benutzer, den letzten Beitrag und eine Sammlung seiner alten neuesten_Posts.
• wir iterer über die Sammlung und erstellen eine vorherige Beziehung zwischen dem neuen letzten und dem nächsten.
.

Der schwierige Teil hier ist, dass die OldLatestPosts -Sammlung immer 0 oder 1 Elemente enthält, was für unsere Abfrage ideal ist.

Schlussfolgerung

In diesem Artikel haben wir eine Modellierungstechnik namens Linked List entdeckt, gelernt, wie man diese in einer sozialen Anwendung implementiert und wie Sie Knoten und Beziehungen auf effiziente Weise abrufen. Wir haben auch einige neue Cypher -Klauseln wie Skip and Limit gelernt, die für die Pagination nützlich sind.

Während die Zeitlinien der realen Welt etwas komplexer sind als das, was wir hier gesehen haben, hoffe ich, dass Grafikdatenbanken wie Neo4j wirklich die beste Wahl für diese Art von Anwendung sind.

häufig gestellte Fragen (FAQs) zu effizienten Benutzerzeitplänen in der PHP -Anwendung mit NEO4J

Wie kann ich meine Timeline -Daten in NEO4J visualisieren? Mit diesem Tool können Sie interaktive, dynamische und visuell ansprechende Zeitpläne erstellen. Sie können die Zeitleiste an Ihre Anforderungen anpassen, Ereignisse hinzufügen und sie sogar mit anderen Ereignissen verknüpfen. Dies erleichtert es, die Beziehungen und Muster in Ihren Daten zu verstehen.

Wie kann ich NEO4J verwenden, um Twitter -Daten zu analysieren? Dies beinhaltet das Extrahieren der Daten von Twitter, das Importieren von NEO4J und die Verwendung von Cypher -Abfragen zur Analyse der Daten. Die visuelle Zeitleiste kann dazu beitragen, Muster und Trends in den Daten zu enthüllen, z. B. die Aktivität eines bestimmten Benutzers oder die Verbreitung eines bestimmten Hashtags. Timeline -Ereignisse in NEO4J können als Knoten und Beziehungen dargestellt werden. Jedes Ereignis ist ein Knoten, und die Beziehungen zwischen ihnen repräsentieren die Abfolge der Ereignisse. Sie können Eigenschaften für die Knoten und Beziehungen verwenden, um zusätzliche Informationen über die Ereignisse zu speichern, wie z. B. die Zeit, die sie aufgetreten sind oder deren Dauer Eine breite Palette von PHP -Versionen. Es wird jedoch immer empfohlen, die neueste stabile Version von PHP für die beste Leistung und Sicherheit zu verwenden. Sie können die offizielle PHP -Website nach Informationen zu den aktuell unterstützten Versionen überprüfen.

Wie hat sich PHP im Laufe der Jahre entwickelt? Es begann als einfache Skriptsprache für die Webentwicklung, wurde jedoch zu einer vollwertigen Programmiersprache mit Unterstützung für objektorientierte Programmierung, funktionaler Programmierung und vieles mehr. Jede neue Version von PHP bringt Verbesserungen in Bezug auf Leistung, Sicherheit und Funktionen mit sich.

Wie kann ich die Leistung meiner PHP mehrere Strategien. Dazu gehört die Optimierung Ihrer Cypher -Abfragen, die Verwendung von Indizes zur Beschleunigung der Datenabnahme und zur effizienten Verwaltung Ihrer Datenbankverbindungen. Darüber hinaus sollten Sie immer die neueste Version von PHP und NEO4J für die beste Leistung verwenden. Dazu gehören die Verwendung sicherer Datenbankverbindungen, die Bereinigung der Benutzereingaben, um Injektionsangriffe zu verhindern, und die Implementierung der ordnungsgemäßen Fehlerbehandlung. Darüber hinaus sollten Sie immer Ihre PHP- und NEO4J -Software auf dem neuesten Stand halten, um von den neuesten Sicherheitspatches zu profitieren. Die PHP-Anwendung mit NEO4J kann mit Try-Catch-Blöcken durchgeführt werden. Auf diese Weise können Sie alle Ausnahmen aufnehmen, die während der Ausführung Ihres Codes auftreten und sie angemessen behandeln. Sie können auch die Fehlerprotokollierung verwenden, um alle Probleme im Auge zu behalten. Dazu gehören die Verwendung von NEO4J -Clustering -Funktionen, um Ihre Daten über mehrere Server hinweg zu verteilen, die Optimierung Ihres Datenbankschemas und Abfragen für die Leistung sowie die Verwendung von Caching zur Reduzierung der Datenbanklast.

Wie kann ich meine vorhandene PHP -Anwendung migrieren, um NEO4J zu verwenden? Zunächst müssen Sie Ihre Daten als Diagramm modellieren und in Neo4J importieren. Anschließend müssen Sie Ihren Anwendungscode aktualisieren, um den PHP -Treiber von NEO4J für Datenbankvorgänge zu verwenden. Schließlich müssen Sie Ihre Anwendung gründlich testen, um sicherzustellen, dass sie mit Neo4j ordnungsgemäß funktioniert.

Das obige ist der detaillierte Inhalt vonEffiziente Benutzerzeitpläne in einer PHP -Anwendung mit NEO4J. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!