Wie erstelle ich eine API-Schnittstelle?

API ist die Anwendungsprogrammierschnittstelle, sie kann als Kanal zur Kommunikation mit verschiedenen Softwaresystemen verstanden werden. Es handelt sich im Wesentlichen um vordefinierte Funktionen.

API hat viele Formen, die beliebteste ist die Verwendung des HTTP-Protokolls zur Bereitstellung von Diensten (z. B. RESTful), solange es den Vorschriften entspricht, kann es normal verwendet werden. Heutzutage nutzen viele Unternehmen von Dritten bereitgestellte APIs und stellen auch APIs für Dritte bereit, sodass auch beim Design von APIs Vorsicht geboten ist.

Wie entwerfe ich eine gute API-Schnittstelle?

1. Funktionalität klären
   Zu Beginn des Entwurfs müssen Sie die Funktionen der API entsprechend den Geschäftsfunktionspunkten oder Modulen organisieren, um zu klären, was Ihre API bereitstellen muss.

2. Codelogik löschen
   Sorgen Sie für Ordnung in Ihrem Code und fügen Sie die erforderlichen Kommentare hinzu, um sicherzustellen, dass die Schnittstelle eine einzige Funktion hat. Wenn eine Schnittstelle eine komplexe Geschäftslogik erfordert, wird empfohlen, sie in mehrere Schnittstellen aufzuteilen oder die Funktionen unabhängig voneinander in öffentliche Methoden zu kapseln, um zu viel Code in der Schnittstelle zu vermeiden, was der Wartung und späteren Iteration nicht förderlich ist.

3. Notwendige Sicherheitsprüfsumme
   Eine gängige Lösung ist die Verwendung einer digitalen Signatur. Fügen Sie jeder HTTP-Anfrage eine Signatur hinzu, und die Serverseite überprüft die Gültigkeit der Signatur, um die Authentizität der Anfrage sicherzustellen.

4. Protokollierung
   Die Protokollierung ist wichtig, um eine rechtzeitige Lokalisierung von Problemen zu ermöglichen.

5. Kopplung minimieren
   Eine gute API sollte so einfach wie möglich sein. Wenn die Geschäftskopplung zwischen APIs zu hoch ist, kann es leicht zu einer Ausnahme in einem bestimmten Code kommen, was dazu führt, dass die entsprechende API nicht verfügbar ist. Daher ist es besser, die Komplexität der Beziehung zwischen APIs so weit wie möglich zu vermeiden.

6. Aussagekräftige Statuscodes zurückgeben
   Statuscodedaten sollten in den API-Rückgabedaten enthalten sein. Beispielsweise bedeutet 200, dass die Anfrage normal ist, 500 bedeutet, dass ein interner Fehler im Server vorliegt. Die Rückgabe eines allgemeinen Statuscodes ist gut für die Problemlokalisierung.

7. Entwicklungsdokumentation
   Da die API für die Verwendung durch Dritte oder für den internen Gebrauch bereitgestellt wird, ist eine Entwicklungsdokumentation unerlässlich, da anderen sonst nicht bekannt wäre, wie sie verwendet wird.

Eine gute API-Entwicklungsdokumentation sollte die folgenden Elemente enthalten:

1. Beschreibung des API-Architekturmodells, Entwicklungstools und -version, Systemabhängigkeiten und andere Umgebungsinformationen.
2. die von der API bereitgestellten Funktionen.
3. API-Modulabhängigkeiten.
4. Aufrufregeln, Hinweise.
5. Bereitstellungshinweise usw.

Wie entwickle ich eine API-Schnittstelle?

Wenn Sie mit der Entwicklungsumgebung zufrieden sind, können Sie die Entwicklung einer einfachen API-Schnittstelle (nur eine Demo) wahrscheinlich in weniger als 10 Minuten abschließen.

Vor der Entwicklung müssen Sie JDK, Maven und IDE installieren.

1. Erstellen Sie ein neues Projekt basierend auf Spring Boot. Um den Vorgang schnell abzuschließen, verwende ich (start.spring.io) zum Generieren meines Projekts. Über [Zu hinzufügende Abhängigkeiten durchsuchen] können Sie das Paket auswählen. Ich habe nur Spring MVC importiert. Wenn Sie über Mybatis auf die Datenbank zugreifen müssen, können Sie auch hier auswählen und dann klicken, um das Projekt zu generieren.

2. Entpacken Sie das heruntergeladene Projekt und fügen Sie es in Ihre IDE ein, um dann eine neue Klasse zu erstellen: com.wukong.apidemo.controller.ApiController.

3. Fügen Sie dieser Klasse eine Methode hinzu, die hauptsächlich die Tags @RestController, @RequestMapping und @ResponseBody verwendet.

4. Die einfachste API-Schnittstelle wurde fertiggestellt. Wir können das Projekt starten, auf die entsprechende Schnittstellenadresse zugreifen und die Schnittstellenrückgabeinformationen abrufen.

5. Wir können Swagger verwenden, um die Schnittstellendokumentation zu erstellen und die API-Schnittstelle zu optimieren.

Effizientere Möglichkeit, eine API-Schnittstelle zu erstellen?

Sowohl Python Flask als auch Java Spring Boot können verwendet werden, um effizient eine API-Schnittstelle zu erstellen.

Spring Boot hat den Entwicklungsprozess auf einen einfachen vereinfacht. Für Python empfehle ich ein Drittanbieterpaket zur Entwicklung von API-Schnittstellen: fastapi.

Es ist ein schnelles und effizientes Tool mit den folgenden Funktionen:

1. Schnell: vergleichbar mit NodeJS und Go. Eines der schnellsten Python-Frameworks.
2. Schnelles Codieren: Erhöht die Entwicklungsgeschwindigkeit um etwa 200 % bis 300 %.
3. Weniger Fehler: Reduziert etwa 40 % der von Entwicklern verursachten Fehler.
4. Einfach: einfach zu bedienen und zu erlernen. Weniger Zeitaufwand für das Lesen der Dokumentation.
5. Standardbasiert: Basierend auf den offenen Standards der API und vollständig kompatibel mit diesen.

Erstellen Sie eine RESTful-API mit Python3 und Flask (Interface Testing Services und Mockserver Tool)

Das Erstellen von RESTful-APIs scheint die Arbeit des Entwicklers zu sein. Tatsächlich gibt es viele Szenarien, in denen Testentwickler RESTful-APIs erstellen müssen.

Einige Tester erstellen eine RESTful-API, entführen den serverseitigen Domänennamen in ihre eigene API und geben absichtlich alle Arten von Ausnahmen zurück, um die Stabilität des Clients zu überprüfen.

REST： REpresentational State Transfer
GET - /api/Category - Retrieve all categories
POST - /api/Category - Add a new category
PUT - /api/Category - Update a category
DELETE - /api/Category - Delete a category
GET - /api/Comment - Retrieve all the stored comments
POST - /api/Comment - Add new comment

Anforderungen:python3.*,PostgreSQL.

REST： REpresentational State Transfer
GET - /api/Category - Retrieve all categories
POST - /api/Category - Add a new category
PUT - /api/Category - Update a category
DELETE - /api/Category - Delete a category
GET - /api/Comment - Retrieve all the stored comments
POST - /api/Comment - Add new comment

Requirements.txt wie folgt:
Flask – Mikroframework für Python
Flask_restful – eine Erweiterung für Flask zum schnellen Erstellen einer REST-API.
Flask_script – bietet Unterstützung für das Schreiben externer Skripte in flask.
Flask_migrate – Verwenden Sie die Flask-App von Alembic für die SQLAlchemy-Datenbankmigration.
Marshmallow – für komplexe Datentypen und Python-Datentypkonvertierungen.
Flask_sqlalchemy – Flask-Erweiterung, die Unterstützung für SQLAlchemy hinzufügt.
Flask_marshmallow – die mittlere Schicht zwischen Flasche und Marshmallow.
Marshmallow-SQLalchemy – die mittlere Schicht zwischen SQLalchemy und Marshmallow.
psycopg – PostgreSQL-API für Python.

Abhängigkeiten installieren

project/
├── app.py
├── config.py
├── migrate.py
├── Model.py
├── requirements.txt
├── resources
│   └── Hello.py
│   └── Comment.py
│   └── Category.py
└── run.py

PostgreSQL installieren und konfigurieren (Nehmen Sie Ubuntu 16.04 als Beispiel)

# pip3 install -r requirements.txt

Konfigurationen

# sudo apt-get update && sudo apt-get upgrade
# apt-get install postgresql postgresql-contrib
# su - postgres
$ createdb api
$ createuser andrew --pwprompt #Create User
$ psql -d api -c "ALTER USER andrew WITH PASSWORD 'api';"

Schnellstart

app.py

from flask import Blueprint
from flask_restful import Api
from resources.Hello import Hello
from resources.Category import CategoryResource
from resources.Comment import CommentResource


api_bp = Blueprint('api', __name__)
api = Api(api_bp)

# Routes
api.add_resource(Hello, '/Hello')
api.add_resource(CategoryResource, '/Category')
api.add_resource(CommentResource, '/Comment')

resource/Hello.py

from flask import Blueprint
from flask_restful import Api
from resources.Hello import Hello

api_bp = Blueprint('api', __name__)
api = Api(api_bp)

# Route
api.add_resource(Hello, '/Hello')

run.py

#!/usr/bin/python
# -*- coding: utf-8 -*-
# Author:    xurongzhong#126.com wechat:pythontesting qq:37391319
# CreateDate: 2018-1-10

from flask_restful import Resource


class Hello(Resource):
    def get(self):
        return {"message": "Hello, World!"}

    def post(self):
        return {"message": "Hello, World!"}

Startdienste

from flask import Flask


def create_app(config_filename):
    app = Flask(__name__)
    app.config.from_object(config_filename)

    from app import api_bp
    app.register_blueprint(api_bp, url_prefix='/api')

    return app


if __name__ == "__main__":
    app = create_app("config")
    app.run(debug=True)

Besuchen Sie mit dem Browser: http://127.0.0.1:5000/api/Hello

$ python3 run.py
 * Running on http://127.0.0.1:5000/ (Press CTRL+C to quit)
 * Restarting with stat
 * Debugger is active!
 * Debugger PIN: 136-695-873

Zugriff auf Datenbanken

{
    "hello": "world"
}

migrate.py

from flask import Flask
from marshmallow import Schema, fields, pre_load, validate
from flask_marshmallow import Marshmallow
from flask_sqlalchemy import SQLAlchemy


ma = Marshmallow()
db = SQLAlchemy()


class Comment(db.Model):
    __tablename__ = 'comments'
    id = db.Column(db.Integer, primary_key=True)
    comment = db.Column(db.String(250), nullable=False)
    creation_date = db.Column(db.TIMESTAMP, server_default=db.func.current_timestamp(), nullable=False)
    category_id = db.Column(db.Integer, db.ForeignKey('categories.id', ondelete='CASCADE'), nullable=False)
    category = db.relationship('Category', backref=db.backref('comments', lazy='dynamic' ))

    def __init__(self, comment, category_id):
        self.comment = comment
        self.category_id = category_id


class Category(db.Model):
    __tablename__ = 'categories'
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(150), unique=True, nullable=False)

    def __init__(self, name):
        self.name = name


class CategorySchema(ma.Schema):
    id = fields.Integer()
    name = fields.String(required=True)


class CommentSchema(ma.Schema):
    id = fields.Integer(dump_only=True)
    category_id = fields.Integer(required=True)
    comment = fields.String(required=True, validate=validate.Length(1))
    creation_date = fields.DateTime()

Datenmigration

from flask_script import Manager
from flask_migrate import Migrate, MigrateCommand
from Model import db
from run import create_app

app = create_app('config')

migrate = Migrate(app, db)
manager = Manager(app)
manager.add_command('db', MigrateCommand)


if __name__ == '__main__':
    manager.run()

Testen
Sie können zum Beispiel Curl verwenden:

$ python3 migrate.py db init
$ python3 migrate.py db migrate
$ python migrate.py db upgrade

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