Wie erstelle ich eine API mit reinem PHP?

In diesem Projekt erstellen wir eine einfache API, die nur PHP in einem beliebigen Framework verwendet. Alles was wir brauchen werden:

• PHP – Essential
• Komponist – Unverzichtbar
• Editor/IDE wie VScode oder PHPStorm
• Docker – Bevorzugt, aber nicht unbedingt erforderlich
• Postbote – Bevorzugt, aber nicht unbedingt erforderlich

Beginnen wir mit der Definition unserer docker-compose.yml-Datei für unsere Datenbankkonfiguration. Wenn Sie Docker nicht zum Erstellen einer Datenbank in Containern verwenden möchten, besteht eine Lösung darin, die Datenbank auf Ihrem Computer zu installieren. Für dieses Tutorial verwenden wir MySQL.

Einstellungen

Nachdem wir den Ordner erstellt haben, in dem sich unsere Anwendung befinden soll, beginnen wir mit der Konfiguration von docker-compose.yaml:

services:
  mysql:
    image: mysql:9.1.0
    ports:
      - '3306:3306'
    environment:
      MYSQL_ROOT_PASSWORD: useroot
      MYSQL_USER: api_user
      MYSQL_PASSWORD: api_password
      MYSQL_DATABASE: api_example

Lassen Sie uns diese Datei zur Erklärung in Teile aufteilen:

services:
  mysql:

In dieser Datei definieren wir die Dienste, die verwendet werden.
Ich nenne diesen Dienst MySQL. Achtung, der Name dieses Dienstes wird verwendet, um als Host eine Verbindung zur Datenbank herzustellen

image: mysql:9.1.0

Als nächstes definiere ich, welches Bild zum Erstellen unserer Datenbank verwendet wird. Für dieses Projekt verwende ich Version 9.1.0 von MySQL.
Sie finden diese und andere Versionen auf Docker Hub.

ports:
      - '3306:3306'

Der Port wird auf 3306 eingestellt. Dies ist der Standard-MySQL-Port!

Sie können feststellen, dass der Port wie folgt lautet: 3306:3306. Dies : bedeutet, dass wir diesen Port auf unserem lokalen Computer abhören möchten und nicht nur auf dem Docker-Container. damit wir direkt auf unserem Computer darauf zugreifen können.

environment:
      MYSQL_ROOT_PASSWORD: useroot
      MYSQL_USER: api_user
      MYSQL_PASSWORD: api_password
      MYSQL_DATABASE: api_example

Als Umgebung müssen wir die Anmeldeinformationen für unseren MySQL-Dienst definieren.
Daher definieren wir Benutzer, Passwort und Datenbanknamen mithilfe von Umgebungsvariablen:

MYSQL_USER: api_user // <--- Este é nosso usuário

MYSQL_PASSWORD: api_password // <--- Este é nosso password

MYSQL_DATABASE: api_example // <--- Este é nosso banco de dados

MYSQL_ROOT_PASSWORD: useroot // <--- Está é a senha para o usuário root

Um unseren Container zu starten, begeben Sie sich einfach in den Ordner, in dem sich die Datei docker-compose.yaml befindet, und geben Sie den folgenden Befehl in unser Terminal ein:

docker compose up -d

Dadurch wird der MySQL-Dienst in unserem Container initialisiert.
Wenn Sie im Terminal auf MySQL zugreifen möchten, können Sie diesen Befehl verwenden:

docker exec -it <nome do container> bash

Nachdem Sie diesen Befehl eingegeben und die Eingabetaste gedrückt haben, gelangen Sie in den Container, in dem das MySQL-Image ausgeführt wird.

Der Containername wird durch Ordnername-Hostname-Nummer gebildet
In diesem Fall wäre der Name unseres Containers: create-api-php-mysql-1, wenn unsere Anwendung im Verzeichnis „create-api-php“ erstellt wurde.

Wir werden auch eine Composer.json-Datei erstellen. Diese Datei dient als Grundlage für die Installation externer Bibliotheken, die im Projekt verwendet werden. In diesem Projekt werden wir nur Dotenv.
verwenden

services:
  mysql:
    image: mysql:9.1.0
    ports:
      - '3306:3306'
    environment:
      MYSQL_ROOT_PASSWORD: useroot
      MYSQL_USER: api_user
      MYSQL_PASSWORD: api_password
      MYSQL_DATABASE: api_example

In dieser Zeile fügen wir die am häufigsten verwendete Bibliothek für dotenv in PHP hinzu.
Das Repository für diese Bibliothek finden Sie unter: Github Vlucas Repository

services:
  mysql:

In der folgenden Zeile sagen wir grundsätzlich, dass wir Autoload mit der Standardkonfiguration des PSR-4 verwenden werden. Die derzeit am häufigsten verwendeten PSRs sind PSR-12 und PSR-4, wobei 12 bisher am häufigsten verwendet wird. Aber vorerst werden wir weiterhin das PSR-4 verwenden.

image: mysql:9.1.0

Mit diesen beiden erstellten Dateien können wir den Befehl erteilen

ports:
      - '3306:3306'

Es wird die Dotenv-Bibliothek installiert und die Einstellungen für das gewünschte PSR konfiguriert.
Nach diesem Befehl wird die Datei „composer.lock.

“ in unserer Umgebung erstellt

Für diejenigen, die aus der JavaScript-Welt kommen, können diese Dateien mit package.json und package-lock.json verglichen werden.

Sie werden außerdem sehen, dass Ihrem Verzeichnis ein Ordner mit dem Namen „vendor“ hinzugefügt wurde. Er enthält unsere Dotenv-Bibliothek und auch eine sehr wichtige Datei: autoload.php.
Wir müssen nichts in dieser Datei berühren oder ändern, da sie für die Übertragung von Dotenv-Informationen zwischen unseren anderen Dateien verantwortlich ist.

Wir werden auch eine Datei namens „bootstrap.php“ erstellen. Diese Datei ist für die Initialisierung unserer Anwendung und die Verbindung einiger wichtiger Parameter verantwortlich, damit alles wie erwartet funktioniert:

environment:
      MYSQL_ROOT_PASSWORD: useroot
      MYSQL_USER: api_user
      MYSQL_PASSWORD: api_password
      MYSQL_DATABASE: api_example

Wir können dann die .env-Datei erstellen, um die Umgebungsvariablen hinzuzufügen, die für die Verbindung zu unserer MySQL-Datenbank verantwortlich sind.
Wir fügen dann hinzu:

MYSQL_USER: api_user // <--- Este é nosso usuário

Wir werden auch eine .env.example-Datei erstellen, in der eine Kopie dieser Informationen gespeichert wird, für den Fall, dass jemand unser Repository klonen möchte oder sogar für uns in der Zukunft, wenn wir unser Projekt fortsetzen wollen, so werden wir es tun die notwendigen Informationen, um zu wissen, was wir definieren müssen und was nicht.

MYSQL_PASSWORD: api_password // <--- Este é nosso password

Der Grund, warum wir diese beiden Dateien erstellen werden, eine mit allen Informationen und die andere mit nur einem Teil der Informationen, liegt darin, dass die .env-Datei nicht in das Repository hochgeladen werden sollte, da sie vertrauliche Informationen enthält. Nehmen wir an, wir möchten in Zukunft eine Drittanbieter-API verwenden, bei der wir für den Zugriff ein Token hinzufügen müssen. Dann speichern wir diese Informationen in der .env-Datei.

Um zu verhindern, dass die .env-Datei in unser Repository hochgeladen wird, erstellen wir eine Datei namens .gitignore und fügen die folgenden Informationen hinzu:

MYSQL_DATABASE: api_example // <--- Este é nosso banco de dados

Auf diese Weise definieren wir, dass die .env-Datei und der gesamte Inhalt des Vendor-Ordners nicht festgeschrieben werden.

Damit haben wir die Konfiguration unseres Projekts abgeschlossen und können mit dem Codieren fortfahren.

Kodifizierung

Wir erstellen die folgenden Verzeichnisse src/System und innerhalb von System die Datei DatabaseConnector.php

services:
  mysql:
    image: mysql:9.1.0
    ports:
      - '3306:3306'
    environment:
      MYSQL_ROOT_PASSWORD: useroot
      MYSQL_USER: api_user
      MYSQL_PASSWORD: api_password
      MYSQL_DATABASE: api_example

Hier definieren wir einen Namespace für diese Datei, damit wir sie in Zukunft in anderen Dateien verwenden können.

services:
  mysql:

Wir erstellen unsere Klasse mit demselben Namen wie die Datei und erstellen eine private Variable namens $dbConnection, die den Wert null übergibt.
Diese Variable ist für eine neue Instanz dieser Klasse verantwortlich und verbindet uns mit der Datenbank.
Wir werden später mehr sehen, wenn wir try-catch implementieren.

image: mysql:9.1.0

Im Konstruktor erstellen wir die folgenden Variablen und überprüfen die aus der .env-Datei erfassten Werte mit Dotenv.

ports:
      - '3306:3306'

Noch im Konstruktor führen wir einen Try-Catch durch, um die Aktion zu validieren, die wir ausführen möchten:

environment:
      MYSQL_ROOT_PASSWORD: useroot
      MYSQL_USER: api_user
      MYSQL_PASSWORD: api_password
      MYSQL_DATABASE: api_example

In diesem Versuch versuchen wir, eine neue Instanz unserer Klasse zu erstellen und diese an die Variable $dbConnection zu übergeben. Wir verwenden hierfür ein PDO-Modul, das die Parameter

erhält

• DSN – Datenquellenname oder URI
• - MySQL: Der Dienst/die Bank, die wir nutzen.
• - host=$host; Unser Gastgeber
• - port=$port; Unsere Tür
• - charset=utf8mb4; Definition des utf8-Zeichensatzes für die Datenbank
• - dbname=$db Der Name unserer Datenbank
• BENUTZER – Benutzer zum Anmelden bei der Datenbank
• PASS – Passwort für die Anmeldung in der Datenbank

Fehlerfall:

MYSQL_USER: api_user // <--- Este é nosso usuário

Wir lösen eine Ausnahme von PDO aus und geben die Fehlermeldung zurück.
Dies ist eindeutig nur ein Beispiel dafür, wie wir Fehler in einer Entwicklungsumgebung darstellen sollten. Für Produktionsumgebungen empfiehlt es sich, prägnantere Fehler darzustellen, die uns helfen, das Problem klarer zu verstehen.

Außerhalb des Konstruktors, aber innerhalb unserer Klasse erstellen wir die folgende Funktion:

MYSQL_PASSWORD: api_password // <--- Este é nosso password

Sind für den Aufruf unserer Variablen verantwortlich, die die Instanz unserer Verbindung enthält.

Erinnern Sie sich an unsere Datei bootstrap.php? Fügen wir die folgenden Codezeilen hinzu:

MYSQL_DATABASE: api_example // <--- Este é nosso banco de dados

Sieht so aus:

MYSQL_ROOT_PASSWORD: useroot // <--- Está é a senha para o usuário root

Im Ordner src erstellen wir ein weiteres Verzeichnis mit dem Namen Database und darin die Datei Database_seed.php.
Diese Datei ist für das erstmalige Auffüllen unserer Datenbank verantwortlich. Wenn wir dieses Projekt also mit jemandem teilen möchten, wird die Datenbank nicht leer sein.

In dieser Datei werden wir die folgenden Codes hinzufügen:

services:
  mysql:
    image: mysql:9.1.0
    ports:
      - '3306:3306'
    environment:
      MYSQL_ROOT_PASSWORD: useroot
      MYSQL_USER: api_user
      MYSQL_PASSWORD: api_password
      MYSQL_DATABASE: api_example

Wir importieren require 'bootstrap.php'; denn in unserer Bootstrap-Datei haben wir bereits die Variable importiert, die für die Instanziierung unserer Datenbank verantwortlich ist.

services:
  mysql:

Wir erstellen eine Variable mit dem Namen $statement, die den Wert Heredoc
hat

image: mysql:9.1.0

In diesem Heredoc werden wir einige Abfragen hinzufügen:

ports:
      - '3306:3306'

Hier entscheide ich mich für Tabelle löschen, um die gesamte Basis zu löschen und dann eine neue zu starten. Wenn Sie möchten, können Sie diese Codezeile jedoch entfernen.

Die folgende Codezeile gibt an, dass diese Tabelle zur Durchführung von Transaktionen verwendet wird und eine Verbindung zwischen den Tabellen aufweist. Wenn Sie mehr über diese MySQL-Deklaration erfahren möchten: innoDb-Dokumentation

environment:
      MYSQL_ROOT_PASSWORD: useroot
      MYSQL_USER: api_user
      MYSQL_PASSWORD: api_password
      MYSQL_DATABASE: api_example

Im selben Heredoc werden wir eine weitere Abfrage hinzufügen:

MYSQL_USER: api_user // <--- Este é nosso usuário

Hier fügen wir einige Daten in die Personentabelle ein.

Wir erstellen einen Try-Catch am Ende der Datei, in dem wir versuchen, die Abfragen zu initialisieren, und im Fehlerfall geben wir eine Fehlermeldung zurück, genau wie wir es bei der Datenverarbeitung in den obigen Codes getan haben .

MYSQL_PASSWORD: api_password // <--- Este é nosso password

In src erstellen wir ein weiteres Verzeichnis mit dem Namen TableGateways und darin die Datei: PersonGateway.php.

MYSQL_DATABASE: api_example // <--- Este é nosso banco de dados

Die Dateien in diesem Ordner sind für die Interaktion mit unserer Datenbank verantwortlich, fast wie ein Repository.

In unserer PersonGateway-Klasse werden wir den folgenden Konstruktor hinzufügen:

MYSQL_ROOT_PASSWORD: useroot // <--- Está é a senha para o usuário root

Wir werden diesen Konstruktor hinzufügen, da unsere Klasse in anderen Dateien aufgerufen wird, damit wir einige Methoden unserer Klasse auslösen können.

Siehe die folgenden Methoden:

Methode, die für die Auflistung aller Benutzer in unserer Tabelle verantwortlich ist

docker compose up -d

Methode, die für die Auflistung eines einzelnen Benutzers aus unserer Tabelle verantwortlich ist

docker exec -it <nome do container> bash

Verantwortliche Methode zum Einfügen eines Benutzers in unsere Tabelle

{
  "require": {
      "vlucas/phpdotenv": "^2.4"
  },
  "autoload": {
      "psr-4": {
          "Src\": "src/"
      }
  }
}

Methode, die für die Aktualisierung der Benutzerinformationen in unserer Tabelle verantwortlich ist

"require": {
      "vlucas/phpdotenv": "^2.4"
},

Methode, die für das Löschen eines Benutzers aus unserer Tabelle verantwortlich ist

"autoload": {
      "psr-4": {
          "Src\": "src/"
      }
  }

Wir erstellen innerhalb von src ein Verzeichnis mit dem Namen Controller und darin die Datei: PersonController.php.
Die Dateien in diesem Verzeichnis sind für die Interaktion mit unserer Anwendungsroute verantwortlich. Hier interagieren wir direkt mit der Bank, aber wir könnten eine Serviceschicht verwenden und alle Logik- und Geschäftsregeln auf diese Schicht beschränken.
Wenn Sie die Serviceschicht erstellen möchten, sieht das so aus:

services:
  mysql:
    image: mysql:9.1.0
    ports:
      - '3306:3306'
    environment:
      MYSQL_ROOT_PASSWORD: useroot
      MYSQL_USER: api_user
      MYSQL_PASSWORD: api_password
      MYSQL_DATABASE: api_example

Unsere Absicht ist jedoch nicht, tiefer in diese Art von Architektur einzutauchen, sondern wir werden zunächst mit der Controller-Datei fortfahren:

services:
  mysql:

In unserer PersonController-Klasse werden wir Folgendes hinzufügen:

image: mysql:9.1.0

Auf diese Weise garantieren wir, dass wir mit einer neuen Instanz unserer Datenbank interagieren.

Wir haben auch eine Methode zur Bearbeitung unserer Anfragen erstellt:

ports:
      - '3306:3306'

Dieser Header ist für die Übertragung des Statuscodes verantwortlich und wenn ein Körper erstellt wird, gibt er denselben Körper zur Anzeige zurück.

environment:
      MYSQL_ROOT_PASSWORD: useroot
      MYSQL_USER: api_user
      MYSQL_PASSWORD: api_password
      MYSQL_DATABASE: api_example

Wir haben auch die Methoden erstellt, die mit den Routen interagieren:

Methode, die für die Interaktion mit der Eintragsroute des Benutzers verantwortlich ist

MYSQL_USER: api_user // <--- Este é nosso usuário

Methode, die für die Interaktion mit der Erstellungsroute des Benutzers verantwortlich ist

MYSQL_PASSWORD: api_password // <--- Este é nosso password

Methode, die für die Interaktion mit der Aktualisierungsroute des Benutzers verantwortlich ist

MYSQL_DATABASE: api_example // <--- Este é nosso banco de dados

Methode, die für die Interaktion mit der Löschroute des Benutzers verantwortlich ist

MYSQL_ROOT_PASSWORD: useroot // <--- Está é a senha para o usuário root

Für die Validierung verantwortliche Methoden

docker compose up -d

docker exec -it <nome do container> bash

{
  "require": {
      "vlucas/phpdotenv": "^2.4"
  },
  "autoload": {
      "psr-4": {
          "Src\": "src/"
      }
  }
}

Zuletzt erstellen wir ein Verzeichnis außerhalb unseres Ordners src mit dem Namen Public.
Dieser Ordner ist für die Speicherung der PHP-Anzeigedatei verantwortlich.
Wir werden die darin enthaltene Datei erstellen: index.php
Wir werden den folgenden Code hinzufügen:

"require": {
      "vlucas/phpdotenv": "^2.4"
},

Diese Datei ist für das Festlegen der Header und die Überprüfung des Zugriffs auf die URL verantwortlich. Wenn der Zugriff erfolgreich ist, wird der Inhalt zurückgegeben, andernfalls wird ein Fehler zurückgegeben.

Um auf Ihre Anwendung zuzugreifen, laden Sie einfach einen Server über den internen PHP-Server hoch:

"autoload": {
      "psr-4": {
          "Src\": "src/"
      }
  }

Wenn Sie den Container nicht initialisiert haben, geben Sie den folgenden Befehl in das Terminal ein:

composer install

Verwenden Sie jetzt einfach Postman oder eine andere Anwendung, die Ihnen bei der Interaktion mit der URL hilft.

Meine sozialen Netzwerke:
Github Linkedin

Das obige ist der detaillierte Inhalt vonWie erstelle ich eine API mit reinem PHP?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!