Arquiteturas Limpas em Python: MVC e MVT

Avatar photoPor /

Ao desenvolver software, seguir boas práticas de arquitetura é essencial para criar código limpo, modular e fácil de manter. Arquiteturas limpas facilitam a separação de preocupações, dessa forma facilitando o desenvolvimento, testes e manutenção. Portanto, neste artigo, vamos explorar algumas das arquiteturas mais populares usadas em Python, como MVC (Model-View-Controller) e MVT (Model-View-Template).

1. Model-View-Controller (MVC)

O MVC é uma das arquiteturas mais conhecidas e amplamente utilizadas no desenvolvimento de software. Ela divide a aplicação em três componentes principais:

  • Model (Modelo): Representa a lógica de dados da aplicação. Ele interage com o banco de dados e trata a lógica de negócio.
  • View (Visão): Responsável pela apresentação dos dados. É a interface com a qual o usuário vê e interage.
  • Controller (Controlador): Age como um intermediário entre o Model e a View. Recebe as entradas do usuário, processa a lógica e atualiza as views.

Exemplo Prático de MVC em Flask

Agora vamos criar um exemplo simples de MVC usando Flask.

Estrutura do Projeto

 

mvc_example/
│
├── app.py
├── models.py
├── views.py
└── controllers.py

Código do Modelo (models.py)

 

class User:
    def __init__(self, id, name, email):
        self.id = id
        self.name = name
        self.email = email

    def __repr__(self):
        return f'User({self.id}, {self.name}, {self.email})'

# Simulando um banco de dados
users = [
    User(1, 'Alice', '[email protected]'),
    User(2, 'Bob', '[email protected]')
]

def get_all_users():
    return users

Código da Visão (views.py)

 

from flask import Flask, render_template

app = Flask(__name__)

def render_users(users):
    return render_template('users.html', users=users)

# Template HTML (users.html)
'''
<!DOCTYPE html>
<html>
<head>
    <title>Users</title>
</head>
<body>
    <h1>Users</h1>
    <ul>
    {% for user in users %}
        <li>{{ user.name }} - {{ user.email }}</li>
    {% endfor %}
    </ul>
</body>
</html>
'''

Código do Controlador (controllers.py)

 

from flask import Flask
from models import get_all_users
from views import render_users

app = Flask(__name__)

@app.route('/users')
def list_users():
    users = get_all_users()
    return render_users(users)

if __name__ == '__main__':
    app.run(debug=True)

2. Model-View-Template (MVT)

O MVT é um padrão de projeto semelhante ao MVC, mas com uma diferença chave: a camada de controle é substituída por uma camada de templates. Além disso, é amplamente utilizado em frameworks como Django.

Estrutura do Projeto Django

 

mvt_example/
│
├── mysite/
│   ├── __init__.py
│   ├── settings.py
│   ├── urls.py
│   ├── wsgi.py
│   └── asgi.py
│
├── myapp/
│   ├── __init__.py
│   ├── admin.py
│   ├── apps.py
│   ├── models.py
│   ├── views.py
│   ├── urls.py
│   └── templates/
│       └── users.html
│
└── manage.py

Código do Modelo (models.py)

 

from django.db import models

class User(models.Model):
    name = models.CharField(max_length=100)
    email = models.EmailField()

    def __str__(self):
        return self.name

Código da Visão (views.py)

 

from django.shortcuts import render
from .models import User

def list_users(request):
    users = User.objects.all()
    return render(request, 'users.html', {'users': users})

Template HTML (templates/users.html)

 

<!DOCTYPE html>
<html>
<head>
    <title>Users</title>
</head>
<body>
    <h1>Users</h1>
    <ul>
    {% for user in users %}
        <li>{{ user.name }} - {{ user.email }}</li>
    {% endfor %}
    </ul>
</body>
</html>

Código das URLs (urls.py)

 

from django.urls import path
from . import views

urlpatterns = [
    path('users/', views.list_users, name='list_users'),
]

3. Outros Padrões Arquiteturais

Microservices

Microservices é uma abordagem arquitetural onde uma aplicação é estruturada como uma coleção de serviços pequenos e independentes. Cada serviço é executado em seu próprio processo e se comunica através de interfaces leves, geralmente APIs HTTP.

Clean Architecture

Clean Architecture, introduzida por Robert C. Martin (Uncle Bob), é uma abordagem que visa separar a lógica de negócios das dependências externas. A ideia é criar sistemas que sejam independentes de frameworks, facilmente testáveis e de fácil manutenção.

Conclusão

Entender e aplicar padrões arquiteturais como MVC e MVT é crucial para desenvolver aplicações escaláveis e de fácil manutenção. Contudo, escolher a arquitetura certa depende do contexto do seu projeto e das suas necessidades específicas. Continue explorando e experimentando diferentes abordagens para encontrar o que funciona melhor para você.

Related Posts

Rolar para cima