Python: Inyección de dependencias
Resumen
La inyección de dependencias (DI) es una técnica de ingeniería de software para definir las dependencias entre objetos. Básicamente la inyección de dependencias en Python funciona de forma similar a la inyección de EJB en JAVA. Este proceso permite suministrar un recurso que requiere en una implementación X.
Prerequisitos:
Python 3.x
En Acción:
provider/injectx.py
#!/usr/bin/python3
from injector import inject
class DependencyProvider(object):
def __init__(self):
pass
def get(self) -> object:
try:
return {"message" : "DependencyProvider"}, 200
except Exception as e:
print(e)
return { "error" : "Internal error" }, 500
class InjectProvider(object):
@inject
def __init__(self, dependencyProvider: DependencyProvider):
self.dependencyProvider = dependencyProvider
def get_dependency(self) -> object:
try:
return self.dependencyProvider.get()
except Exception as e:
print(e)
return { "error" : "Internal error" }, 500
def get(self) -> object:
try:
return {"message" : "InjectProvider"}, 200
except Exception as e:
print(e)
return { "error" : "Internal error" }, 500
api/iapi.py
#!/usr/bin/python3
def get_dependency(data_provider) -> object:
try:
return data_provider.get_dependency()
except Exception as e:
return {"error": str(e)}, 400
def get(data_provider) -> object:
try:
return data_provider.get()
except Exception as e:
return {"error": str(e)}, 400
app.py
#!/usr/bin/python3
from flask import Flask, request
from flask_injector import FlaskInjector
from injector import inject, singleton, Binder
from api import api
from provider.injectx import InjectProvider, DependencyProvider
app = Flask(__name__)
def configure(binder: Binder) -> Binder:
binder.bind(interface=DependencyProvider, to=DependencyProvider, scope=singleton)
binder.bind(interface=InjectProvider, to=InjectProvider, scope=request)
@app.route('/ms-inject/v1/get', methods=["GET"])
@inject
def get(data_provider: InjectProvider):
return api.get(data_provider)
@app.route('/ms-inject/v1/get/dependency', methods=["GET"])
@inject
def get_dependency(data_provider: InjectProvider):
return api.get_dependency(data_provider)
@app.after_request
def after_request(response):
response.headers.add('Access-Control-Allow-Origin', '*')
response.headers.add('Access-Control-Allow-Headers', '*')
response.headers.add('Access-Control-Allow-Methods', 'GET,OPTIONS')
return response
if __name__ == '__main__':
FlaskInjector(app=app, modules=[configure])
app.run(port=9010, host="0.0.0.0", debug=True)
Explicación
FlaskInjector se define que aplicación va administrar y va a hacer uso de las dependencias para su inyección.
@inject define en donde se va a realizar la inyección de una dependencia.
Resultados
Con el "get_dependency" de la clase "InjectProvider" se obtendrá una respuesta propia de la clase. Para este caso: "InjectProvider"
Con el "get" de la clase "InjectProvider" se obtendrá una respuesta por parte de la clase "DependencyProvider". Para este caso: "DependencyProvider"
Notas finales:
En términos generales la inyección de dependencias ayuda:
* Disminuir el acoplamiento
* Reducción y rehúso de código repetitivo
* Reducir el conocimiento de una implementación. Aplica el encapsulamiento.
* Flexibilidad al configurar un cliente.
* Entre otros.
No olvides compartir y dar +1
-
Próximos eventos:
* Microservicios en Python
* Python+MongoDB: CRUD
* Python+MongoDB+GridFS: Almacenamiento de archivos
* Colas - Queue Python: Envío de mensajes
* Python+AWS+SNS: Envío de mensajes de textos.
* Python3: Creación de un Chatbot básico
* NodeJS+MongoDB: CRUD
El orden de los eventos puede cambiar
Comentarios
Publicar un comentario