12/08/2024 – FLASK

2235. INTRODUÇÃO

Flask é um microframework web escrito em Python, projetado para ser simples, flexível e
fácil de usar, permitindo o desenvolvimento de aplicações web rapidamente.

Características principais do Flask:

• Microframework: O Flask é chamado de "micro" porque não inclui muitas funcionalidades
prontas, como autenticação de usuários ou banco de dados, por padrão. Isso permite que
os desenvolvedores escolham quais componentes adicionar conforme necessário, mantendo
o framework leve e ágil.

• Flexibilidade: Flask não impõe uma estrutura rígida para organizar seu código. Você
tem liberdade para estruturar sua aplicação da maneira que achar mais conveniente.

• Extensibilidade: Apesar de ser minimalista, Flask é altamente extensível, com uma

grande variedade de extensões disponíveis para adicionar funcionalidades como bancos
de dados, autenticação, upload de arquivos, e muito mais.

• Roteamento Simples: Flask usa um sistema de roteamento intuitivo, que mapeia URLs para
funções Python, tornando fácil criar rotas e endpoints para sua aplicação.

• Template Engine Jinja2: Flask utiliza o Jinja2, um poderoso mecanismo de templates que
permite gerar HTML de forma dinâmica com código Python embutido.

Exemplo básico de uso:

python
Copy code
from flask import Flask

app = Flask(__name__)

@app.route('/')
def home():
return "Hello, Flask!"

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

Neste exemplo:

• Criamos uma instância do Flask (app).

• Definimos uma rota (/) que mapeia para a função home, que retorna uma mensagem
simples.
• Rodamos a aplicação com app.run().

Quando usar Flask?

• Flask é ideal para projetos pequenos a médios, onde você deseja controle sobre cada
componente.
• É ótimo para criar protótipos ou APIs RESTful rapidamente.
• É uma excelente escolha quando você não precisa de todas as funcionalidades de um
framework maior, como o Django, ou quando você quer mais flexibilidade para escolher
como desenvolver cada parte da sua aplicação.

2236. CRIANDO PROJETO E DETERMINANDO ESTRUTURA DE PASTAS

No contexto do Flask, o padrão MVC (Model-View-Controller) é uma maneira de estruturar e
organizar o código da sua aplicação web para separar responsabilidades e tornar o
desenvolvimento mais organizado e escalável.

Componentes do MVC:

1. Model (Modelo):
• Representa a camada de dados da aplicação. Ele lida com a lógica de negócio, a
comunicação com o banco de dados, e o gerenciamento dos dados.
• Em Flask, os modelos são geralmente definidos utilizando bibliotecas como
SQLAlchemy ou outros ORM (Object-Relational Mapping) para interagir com o banco
de dados.
• Exemplo:

python
Copy code
from flask_sqlalchemy import SQLAlchemy

db = SQLAlchemy()

class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(80), unique=True, nullable=False)
email = db.Column(db.String(120), unique=True, nullable=False)

2. View (Visão):
• Representa a camada de apresentação, ou seja, o que o usuário final vê e
interage. As views são responsáveis por renderizar templates HTML, gerenciar
respostas HTTP, e fornecer a interface do usuário.
 • No Flask, as views são funções Python que retornam respostas. Elas geralmente
usam o Jinja2 para renderizar templates HTML.
• Exemplo:

python
Copy code
from flask import render_template

@app.route('/')
def home():
return render_template('home.html', title='Home Page')

3. Controller (Controlador):
• Representa a camada de lógica de controle, que conecta a visão ao modelo. O
controlador responde às interações do usuário, faz a ponte entre a view e o
model, e decide qual view renderizar.
• No Flask, as rotas (@app.route) atuam como controladores, processando as
requisições HTTP, interagindo com o modelo, e determinando qual view deve ser
retornada.
• Exemplo:

python
Copy code
@app.route('/user/<username>')
def show_user_profile(username):
user = User.query.filter_by(username=username).first_or_404()
return render_template('user_profile.html', user=user)

Como funciona o fluxo no MVC do Flask:

1. Usuário faz uma solicitação (request): Por exemplo, acessa uma URL em seu navegador.
2. O controlador (route) recebe a solicitação: A rota correspondente à URL é acionada,
processando a solicitação e, se necessário, interagindo com o modelo.

3. O modelo (model) realiza operações de negócios: Pode buscar, inserir, atualizar ou

excluir dados no banco de dados.

4. O controlador (route) passa os dados para a visão.

5. A visão (view) renderiza a resposta: Com os dados fornecidos pelo controlador, a view
renderiza um template HTML e o envia de volta ao navegador do usuário.

Estrutura típica de um projeto Flask usando MVC:

plaintext
Copy code
my_flask_app/
│
├── app/
│ ├── __init__.py # Inicialização da aplicação e registro de blueprints
│ ├── models.py # Modelos (Model)
│ ├── routes.py # Controladores (Controller)
│ ├── templates/ # Templates HTML (Views)
│ └── static/ # Arquivos estáticos (CSS, JS, imagens)
│
├── config.py # Configurações da aplicação
├── run.py # Ponto de entrada da aplicação
└── requirements.txt # Dependências do projeto

Resumindo:
• Model: Lida com a lógica de negócios e a interação com o banco de dados.
• View: Responsável pela interface com o usuário, renderizando as páginas HTML.
• Controller: Recebe as requisições, processa a lógica necessária, e escolhe qual view
retornar.
Essa estrutura torna o código mais modular, facilitando a manutenção e a escalabilidade da
aplicação Flask.

2237. CRIANDO PRIMERIA APLICAÇÃO FLASK

pythonFlask/
│
├── app/
│ ├── __init__.py
│ ├── models/
│ ├── templates/
│ ├── view/
│ |__ __init__.py
│ |__ cliente_view.py
├── run.py

run.py

from app import app

if __name__ == "__main__":
app.run()

app/__init__.py

from flask import Flask

app = Flask(__name__)

from .views import cliente_view

app/view/cliente_view.py

from app import app

@app.route("/ola")
def ola():
return "Olá, mundo em Flask!!!"

Essa estrutura de aplicação Flask segue o padrão MVC (Model-View-Controller) de forma

simplificada, com algumas adaptações. Vou explicar o funcionamento de cada parte:

Estrutura de Diretórios e Arquivos

• pythonFlask/: Diretório raiz da aplicação.
• app/: Diretório que contém o código principal da aplicação.
• __init__.py: Arquivo que inicializa a aplicação Flask.
• models/: Diretório (vazio neste exemplo) que normalmente conteria os modelos da
aplicação (representando a lógica de dados).

• templates/: Diretório (vazio neste exemplo) onde seriam armazenados os arquivos

HTML que servem como templates para as views.

• view/: Diretório que contém as views ou controladores da aplicação.

• __init__.py: Arquivo para inicializar o pacote view.
• cliente_view.py: Arquivo que define uma rota específica para a aplicação.
• run.py: Arquivo que serve como ponto de entrada para rodar a aplicação Flask.

Explicação do Funcionamento:

1. run.py:
• Este arquivo é o ponto de entrada da aplicação. Ele importa o objeto app do
módulo app e chama app.run() para iniciar o servidor Flask.
 • Quando você executa run.py, o servidor web embutido do Flask é iniciado.

from app import app

if __name__ == "__main__":
app.run()

2. app/__init__.py:
• Este arquivo inicializa a aplicação Flask.
• O objeto app é criado a partir da classe Flask, e as views são importadas em
seguida.
• A importação de cliente_view garante que as rotas definidas nesse arquivo sejam
registradas na aplicação.

from flask import Flask

app = Flask(__name__)

from .view import cliente_view

3. app/view/cliente_view.py:
• Este arquivo define uma view específica para a aplicação, com a rota /ola.
• Quando um usuário acessa a URL /ola no navegador, a função ola() é executada,
retornando a mensagem "Olá, mundo em Flask!!!".

from app import app

@app.route("/ola")
def ola():
return "Olá, mundo em Flask!!!"

Fluxo de Execução:

1. Quando você executa run.py, ele importa e inicializa a aplicação Flask definida em
app/__init__.py.
2. O arquivo __init__.py carrega o módulo cliente_view.py, registrando a rota /ola.
3. Com o servidor Flask em execução, qualquer requisição HTTP para a URL
http://localhost:5000/ola será tratada pela função ola(), que retorna a mensagem "Olá,
mundo em Flask!!!".

Resumo:
Essa estrutura organiza a aplicação de forma modular, separando a inicialização da aplicação
(__init__.py), as views ou controladores (cliente_view.py), e reservando espaço para modelos
(models/) e templates (templates/). Isso facilita a manutenção e a escalabilidade à medida
que a aplicação cresce.