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.
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.
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.
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.
Journalisation
La journalisation est essentielle pour faciliter la localisation rapide des problèmes.
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.
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.
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 :
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.
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.
Décompressez le projet téléchargé et introduisez-le dans votre IDE, puis créez une nouvelle classe : com.wukong.apidemo.controller.ApiController.
Ajouter une méthode dans cette classe, utilisation principale des balises @RestController, @RequestMapping, @ResponseBody.
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.
Nous pouvons utiliser swagger pour nous aider à générer la documentation de l'interface et à optimiser l'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 :
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!
Le rôle des serveurs de noms de domaine
Méthode de détection des liens morts d'un site Web
Comment réparer la base de données SQL
Quelles sont les fonctions de fenêtrage ?
Comment utiliser définir
Quel plugin est Composer ?
Tutoriel de création de site Web simple PHP
Comment supprimer des pages vierges dans Word
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
