Ausführliche Erläuterung zweier häufig verwendeter Methoden zum Schreiben von Schnittstellen in PHP

In den letzten Jahren ist mit der kontinuierlichen Entwicklung der Internetbranche das Konzept der API (Application Programming Interface, Anwendungsprogrammschnittstelle) den Menschen nach und nach bekannt geworden. In der modernen Softwarearchitektur und -entwicklung ist API nicht nur eine wichtige technische Komponente, sondern auch der Kern für die Unterstützung des Geschäftswachstums und den Aufbau von Plattformen.

Bei der Implementierung von API ist PHP auch eine der am weitesten verbreiteten Backend-Sprachen. In PHP gibt es normalerweise zwei Methoden zum Schreiben von API-Schnittstellen, die in diesem Artikel vorgestellt werden.

1. Traditionelle Methode

Die traditionelle Methode kann auch als Methode im PHP-basierten MVC-Framework bezeichnet werden. Diese Methode organisiert normalerweise den Code der API-Schnittstelle und des Controllers (Controller) im MVC-Framework.

In dieser Methode müssen wir zuerst eine Controller-Klasse definieren, zum Beispiel:

class ApiController {
    public function index() {
        // 代码逻辑
    }
    public function add() {
        // 代码逻辑
    }
    // 更多的业务方法
}

Dann definieren wir eine Route, um die Anfrage an die entsprechende Controller-Methode weiterzuleiten, zum Beispiel:

// 定义路由
Route::get('api', 'ApiController@index');
Route::post('api/add', 'ApiController@add');
// 更多的路由定义

Schließlich müssen wir Folgendes hinzufügen: Geben Sie am Ende jeder Methode das Ergebnis im JSON-Format zurück:

return json_encode($result);

Unter den traditionellen Methoden ist dies die traditionellere Methode. Die Organisation der API über den Controller des MVC-Frameworks ist im Hinblick auf die Entwicklungsgeschwindigkeit und die Wartbarkeit des Codes sinnvoller, aber einige neue Projekte stellen möglicherweise höhere Leistungsanforderungen. Zu diesem Zeitpunkt müssen wir die Verwendung der zweiten Methode in Betracht ziehen:

2 .Laravels Methode

Laravel ist ein PHP-Webanwendungsentwicklungsframework, das auf der MVC-Architektur basiert und die beste Kombination aus effizienter Webentwicklung und moderner Webentwicklungstechnologie erreichen kann. Die API-Entwicklung in Laravel wird auch mithilfe einer speziellen Komponente abgeschlossen – [Laravel Dingo API](https://github.com/dingo/api/).

Laravel Dingo API-Funktionen:

• Flexibilität und Wartbarkeit des Routings
• Bieten Sie eine bessere API-Ausgabe durch Serializer (Serializer) und Response Builder (Fractal).
• Die auf OAuth2 basierende Authentifizierungsmethode ist derzeit eine der beliebtesten Authentifizierungsmethoden.
• Bietet das API-Dokumentationstool Swagger, um Teams bei der besseren Verwaltung der API-Dokumentation zu unterstützen.

In der Laravel Dingo API können wir ganz einfach API-Routen und Controller erstellen. Zuerst müssen wir die Anforderungsmethode und das URL-Format der API in der Route definieren, zum Beispiel:

$api = app(Dingo\Api\Routing\Router::class);

$api->version('v1', function ($api) {
    $api->get('items/{id}', 'App\Http\Controllers\ItemsController@show');
    $api->post('items', 'App\Http\Controllers\ItemsController@store');
    $api->put('items/{id}', 'App\Http\Controllers\ItemsController@update');
    $api->delete('items/{id}', 'App\Http\Controllers\ItemsController@destroy');
});

Dann müssen wir die Codelogik der API im Controller implementieren, zum Beispiel:

use Illuminate\Http\Request;

class ItemsController extends Controller {
    public function show($id) {
        $item = Item::find($id);
        return $item;
    }

    public function store(Request $request) {
        $item = new Item;
        $item->title = $request->input('title');
        $item->description = $request->input('description');
        $item->save();
        return $item;
    }

    public function update(Request $request, $id) {
        $item = Item::find($id);
        $item->title = $request->input('title');
        $item->description = $request->input('description');
        $item->save();
        return $item;
    }

    public function destroy($id) {
        $item = Item::find($id);
        $item->delete();
        return $item;
    }
}

Im Laravel Mit der Dingo-API können wir flexiblere Ausgabemethoden verwenden, wie zum Beispiel:

use Illuminate\Http\Request;
use Dingo\Api\Routing\Helpers;
use App\Transformers\ItemsTransformer;

class ItemsController extends Controller {
    use Helpers;

    public function show($id) {
        $item = Item::find($id);
        return $this->response->item($item, new ItemsTransformer);
    }

    public function index() {
        $items = Item::all();
        return $this->response->collection($items, new ItemsTransformer);
    }

    public function store(Request $request) {
        $item = new Item;
        $item->title = $request->input('title');
        $item->description = $request->input('description');
        $item->save();
        return $this->response->item($item, new ItemsTransformer);
    }

    public function update(Request $request, $id) {
        $item = Item::find($id);
        $item->title = $request->input('title');
        $item->description = $request->input('description');
        $item->save();
        return $this->response->item($item, new ItemsTransformer);
    }

    public function destroy($id) {
        $item = Item::find($id);
        $item->delete();
        return $this->response->noContent();
    }
}

Wir können die Eigenschaft „Helper“ verwenden, um das Antwortformat flexibel auszugeben, indem wir $this->response->item und $this->response-> verwenden ;Sammlung. Wir können Transformer auch verwenden, um das Modell in der API in das erforderliche Format zu konvertieren.

Zusammenfassung

In diesem Artikel haben wir zwei Methoden zur Implementierung von APIs in PHP kennengelernt: die traditionelle Methode und die Laravel-Methode. Da sich die Internetbranche jedoch weiterentwickelt, ändert sich auch die Implementierung von APIs ständig. Wir müssen eine geeignete Implementierungsmethode basierend auf den spezifischen Projektanforderungen auswählen.

Das obige ist der detaillierte Inhalt vonAusführliche Erläuterung zweier häufig verwendeter Methoden zum Schreiben von Schnittstellen in PHP. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!