Comment réaliser une interface API ?

L'API est l'interface de programmation d'applications, elle peut être comprise comme un canal pour communiquer avec différents systèmes logiciels. Il s'agit essentiellement de fonctions prédéfinies.

L'API a de nombreuses formes, la plus populaire consiste à utiliser le protocole HTTP pour fournir des services (tels que : RESTful), à condition qu'elle respecte la réglementation et puisse être utilisée normalement. De nos jours, de nombreuses entreprises utilisent des API fournies par des tiers et fournissent également des API à des tiers. La conception des API doit donc également être prudente.

Comment concevoir une bonne interface API ?

1. Clarifier la fonctionnalité
   Au début de la conception, vous devez organiser les fonctions de l'API en fonction des points ou modules de fonctions métiers pour clarifier que votre API doit fournir.

2. Effacer la logique du code
   Gardez votre code bien rangé et ajoutez les commentaires nécessaires pour garantir que l'interface a une seule fonction. Si une interface nécessite une logique métier complexe, il est recommandé de la diviser en plusieurs interfaces ou d'encapsuler les fonctions dans des méthodes publiques indépendamment pour éviter trop de code dans l'interface, ce qui n'est pas propice à la maintenance et aux itérations ultérieures.

3. Somme de contrôle de sécurité nécessaire
   Une solution courante consiste à utiliser une signature numérique. Ajoutez une signature à chaque requête HTTP et le côté serveur vérifie la validité de la signature pour garantir l'authenticité de la requête.

4. Journalisation
   La journalisation est essentielle pour faciliter la localisation rapide des problèmes.

5. Réduire le couplage
   Une bonne API doit être aussi simple que possible. Si le couplage métier entre les API est trop élevé, il est facile de provoquer une exception dans un certain code, entraînant l'indisponibilité de l'API concernée. Il vaut donc mieux éviter autant que possible la complexité de la relation entre les API.

6. Renvoyer des codes d'état significatifs
   Les données du code d'état doivent être contenues dans les données de retour de l'API. Par exemple, 200 signifie que la requête est normale, 500 signifie qu'il y a une erreur interne dans le serveur. Renvoyer un code d'état commun est utile pour la localisation des problèmes.

7. Documentation de développement
   Étant donné que l'API est fournie pour un usage tiers ou interne, la documentation de développement est essentielle, sinon les autres ne sauraient pas comment l'utiliser.

Une bonne documentation de développement d'API doit contenir les éléments suivants :

1. Description du modèle d'architecture API, outils et version de développement, dépendances du système et autres informations sur l'environnement.
2. les fonctions fournies par l'API.
3. Dépendances du module API.
4. règles d'invocation, notes.
5. notes de déploiement, etc.

Comment développer une interface API ?

Si vous êtes satisfait de l'environnement de développement, probablement en moins de 10 minutes, vous pouvez terminer le développement d'une interface API simple (juste une démo).

Avant le développement, vous devez installer le JDK, Maven et l'IDE.

1. Créez un nouveau projet basé sur Spring Boot. Afin de terminer rapidement, je choisis d'utiliser (start.spring.io) pour générer mon projet. Grâce à [Rechercher les dépendances à ajouter], vous pouvez choisir le package. J'ai uniquement importé Spring MVC, si vous avez besoin d'accéder à la base de données via Mybatis, vous pouvez également choisir ici, puis cliquer pour générer le projet.

2. Décompressez le projet téléchargé et introduisez-le dans votre IDE, puis créez une nouvelle classe : com.wukong.apidemo.controller.ApiController.

3. Ajouter une méthode dans cette classe, utilisation principale des balises @RestController, @RequestMapping, @ResponseBody.

4. L'interface API la plus simple est terminée. Nous pouvons démarrer le projet, accéder à l'adresse de l'interface correspondante et obtenir les informations de retour de l'interface.

5. Nous pouvons utiliser swagger pour nous aider à générer la documentation de l'interface et à optimiser l'interface API.

Un moyen plus efficace de créer une interface API ?

Python Flask et Java Spring Boot peuvent être utilisés pour créer efficacement une interface API.

Spring Boot a simplifié le processus de développement à un simple. Pour python, je recommande un package tiers pour développer des interfaces API : fastapi.

C'est un outil rapide et efficace avec les fonctionnalités suivantes :

1. Rapide : comparable à NodeJS et Go. L'un des frameworks Python les plus rapides.
2. Codage rapide : augmente la vitesse de développement d'environ 200 % à 300 %.
3. Moins d'erreurs : réduit environ 40 % des erreurs causées par les développeurs.
4. Simple : facile à utiliser et à apprendre. Moins de temps passé à lire la documentation.
5. Basé sur des normes : basé sur et entièrement compatible avec les normes ouvertes de l'API.

Créez une API RESTful avec Python3 et Flask（Interface Testing Services et Mockserver Tool）

Construire des API RESTful semble être le travail du développeur. En fait, il existe de nombreux scénarios dans lesquels le développeur de tests doit créer des API RESTful.

Certains testeurs créeront une API RESTful, détourneront le nom de domaine côté serveur vers leur propre API et renverront volontairement toutes sortes d'exceptions pour voir la stabilité du client.

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

Exigences：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 comme suit :
Flask - microframework pour python
Flask_restful - une extension de flask pour créer rapidement une API REST.
Flask_script - prend en charge l'écriture de scripts externes dans Flask.
Flask_migrate - utilisez l'application Flask d'Alembic pour la migration de la base de données SQLAlchemy.
Marshmallow - pour les types de données complexes et les conversions de types de données Python.
Flask_sqlalchemy - extension flask qui ajoute la prise en charge de SQLAlchemy.
Flask_marshmallow - la couche intermédiaire entre le flacon et la guimauve.
Marshmallow-sqlalchemy - la couche intermédiaire entre sqlalchemy et guimauve.
psycopg - API PostgreSQL pour python.

Installer les dépendances

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

Installer et configurer PostgreSQL (Prenez Ubuntu 16.04 comme exemple)

# pip3 install -r requirements.txt

Configurations

# 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';"

Démarrage rapide

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

ressource/Bonjour.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!"}

Démarrage des services

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)

Utilisez le navigateur pour visiter : 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

Accès aux bases de données

{
    "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()

migration de données

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

Tests
Vous pouvez utiliser curl, par exemple :

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

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!