Используйте Flask Blueprint для проектирования своих приложений

Оглавление

Flask - это очень популярный фреймворк для веб-приложений, который оставляет практически все дизайнерские и архитектурные решения на усмотрение разработчика. В этом руководстве вы узнаете, как Схема Flask, или сокращенно Схема Flask, может помочь вам структурировать ваше приложение Flask, сгруппировав его функциональные возможности в повторно используемые компоненты.

В этом уроке вы узнаете:

  • Что такое схемы элементов Flask и как они работают
  • Как создать и использовать схему элементов Flask для организации вашего кода
  • Как улучшить возможность повторного использования кода, используя свой собственный или сторонний проект Flask Blueprint

В этом руководстве предполагается, что у вас есть некоторый опыт использования Flask и что вы ранее создавали некоторые приложения. Если вы раньше не использовали Flask, ознакомьтесь с Веб-приложениями на Python с использованием Flask (серия руководств).

Как выглядит приложение Flask

Давайте начнем с рассмотрения структуры небольшого приложения Flask. Вы можете создать небольшое веб-приложение, выполнив действия, описанные в этом разделе. Для начала вам необходимо установить Flask пакет Python. Вы можете запустить следующую команду для установки Flask с помощью pip:

$ pip install Flask==1.1.1

Приведенная выше команда устанавливает версию Flask 1.1.1. Именно эту версию вы будете использовать в этом руководстве, хотя вы можете применить то, что узнаете здесь, и к другим версиям.

Примечание: Для получения дополнительной информации о том, как установить Flask в виртуальной среде и других pip параметрах, ознакомьтесь с Виртуальными средами Python: A Букварь и Что такое Pip? Руководство для начинающих питонистов.

После установки Flask вы можете приступать к реализации его функциональности. Поскольку Flask не накладывает никаких ограничений на структуру проекта, вы можете организовать код вашего проекта так, как вам хочется. Для вашего первого приложения вы можете использовать очень простой макет, как показано ниже. В одном файле будет содержаться вся логика приложения:

app/
|
└── app.py

Файл app.py будет содержать определение приложения и его представления.

Когда вы создаете приложение Flask, вы начинаете с создания Flask объекта, представляющего ваше приложение, а затем связываете представления с маршрутами. Flask заботится об отправке входящих запросов в правильное представление на основе URL-адреса запроса и определенных вами маршрутов.

В Flask представления могут быть любыми вызываемыми (например, функциями), которые получают запросы и возвращают ответ на этот запрос. Flask отвечает за отправку ответа обратно пользователю.

Следующий блок кода является полным исходным кодом вашего приложения:

from flask import Flask

app = Flask(__name__)

@app.route('/')
def index():
    return "This is an example app"

Этот код создает объект app, который принадлежит классу Flask. Функция просмотра index() связана с маршрутом / с помощью app.route декоратора. Чтобы узнать больше о декораторах, ознакомьтесь с Руководством по декораторам Python и Декораторами Python. 101.

Вы можете запустить приложение с помощью следующей команды:

$ flask run

По умолчанию Flask запустит приложение, которое вы указали в app.py, через порт 5000. Пока приложение запущено, перейдите на страницу http://localhost:5000, используя свой веб-браузер. Вы увидите страницу с сообщением, This is an example app.

Выбранный макет проекта отлично подходит для очень маленьких приложений, но он плохо масштабируется. По мере роста вашего кода вам может становиться все труднее сохранять все в одном файле. Итак, когда ваше приложение увеличится в размере или сложности, вы можете захотеть структурировать свой код по-другому, чтобы сделать его удобным в обслуживании и понятным для понимания. В этом руководстве вы узнаете, как использовать схему Flask для достижения этой цели.

Как выглядит схема Flask

Схемы элементов Flask инкапсулируют функциональные возможности, такие как представления, шаблоны и другие ресурсы. Чтобы получить представление о том, как будет работать схема Flask, вы можете реорганизовать предыдущее приложение, переместив представление index в схему Flask. Для этого вам необходимо создать схему элементов Flask, содержащую представление index, а затем использовать ее в приложении.

Вот как выглядит файловая структура для этого нового приложения:

app/
|
├── app.py
└── example_blueprint.py

example_blueprint.py будет содержать реализацию Flask Blueprint. Затем вы измените app.py, чтобы использовать его.

В следующем блоке кода показано, как вы можете реализовать эту схему Flask в example_blueprint.py. Он содержит представление на маршруте /, которое возвращает текст This is an example app:

from flask import Blueprint

example_blueprint = Blueprint('example_blueprint', __name__)

@example_blueprint.route('/')
def index():
    return "This is an example app"

В приведенном выше коде вы можете увидеть шаги, общие для большинства определений схемы элементов Flask:

  1. Создайте объект Blueprint с именем example_blueprint.
  2. Добавьте видов в example_blueprint с помощью route декоратора.

Следующий блок кода показывает, как ваше приложение импортирует и использует схему элементов Flask:

from flask import Flask
from example_blueprint import example_blueprint

app = Flask(__name__)
app.register_blueprint(example_blueprint)

Чтобы использовать любую схему элементов Flask, вам необходимо импортировать ее, а затем зарегистрировать ее в приложении с помощью register_blueprint(). Когда проект Flask Blueprint регистрируется, приложение дополняется его содержимым.

Вы можете запустить приложение с помощью следующей команды:

$ flask run

Пока приложение запущено, перейдите на страницу http://localhost:5000, используя свой веб-браузер. Вы увидите страницу с сообщением, This is an example app.

Как работают схемы Flask

В этом разделе вы подробно узнаете, как реализуется и используется схема Flask. Каждая схема Flask представляет собой объект, который работает очень похоже на приложение Flask. У них обоих могут быть ресурсы, такие как статические файлы, шаблоны и представления, связанные с маршрутами.

Однако Flask Blueprint на самом деле не является приложением. Его необходимо зарегистрировать в приложении, прежде чем вы сможете его запустить. Когда вы регистрируете схему элементов Flask в приложении, вы фактически расширяете приложение содержимым схемы элементов.

Это ключевая концепция, лежащая в основе любого проекта Flask Blueprint. В них записываются операции, которые будут выполнены позже, когда вы зарегистрируете их в приложении. Например, когда вы связываете представление с маршрутом в схеме элементов Flask, оно записывает эту связь, которая будет создана позже в приложении, когда схема элементов будет зарегистрирована.

Создание схемы Flask

Давайте вернемся к определению схемы элементов Flask, которое вы видели ранее, и рассмотрим его более подробно. Следующий код показывает создание объекта Blueprint:

from flask import Blueprint

example_blueprint = Blueprint('example_blueprint', __name__)

Обратите внимание, что в приведенном выше коде при создании объекта Blueprint указываются некоторые аргументы. Первый аргумент, "example_blueprint", является именем схемы элементов , которое используется механизмом маршрутизации Flask. Вторым аргументом, __name__, является импортируемое имя , которое Flask использует для определения местоположения ресурсов схемы.

Существуют и другие необязательные аргументы, которые вы можете указать, чтобы изменить поведение схемы элементов:

  • static_folder: папка, в которой можно найти статические файлы схемы элементов

  • static_url_path: URL-адрес для обслуживания статических файлов из

  • template_folder: папка, содержащая шаблоны схемы элементов

  • url_prefix: путь для добавления ко всем URL-адресам схемы элементов

  • поддомен: поддомен, которому по умолчанию будут соответствовать маршруты этой схемы элементов

  • url_defaults: словарь значений по умолчанию, которые будут отображаться в представлениях этой схемы элементов

  • root_path: путь к корневому каталогу схемы элементов, значение которого по умолчанию получается из импортируемого имени схемы элементов

Обратите внимание, что все пути, кроме root_path, относятся к каталогу схемы элементов.

Объект Blueprint example_blueprint содержит методы и декораторы, которые позволяют записывать операции, которые будут выполняться при регистрации схемы элементов Flask в приложении для ее расширения. Одним из наиболее часто используемых декораторов является route. Он позволяет связать функцию просмотра с маршрутом URL-адреса. Следующий блок кода показывает, как используется этот декоратор:

@example_blueprint.route('/')
def index():
    return "This is an example app"

Вы оформляете index() с помощью example_blueprint.route и связываете функцию с URL-адресом /.

Blueprint объекты также предоставляют другие методы, которые могут оказаться полезными для вас:

  • . errorhandler() для регистрации функции обработчика ошибок
  • . before_request() для выполнения действия перед каждым запросом
  • . after_request() для выполнения действия после каждого запроса
  • . app_template_filter() для регистрации шаблонного фильтра на уровне приложения

Вы можете узнать больше об использовании Blueprints и класса Blueprint в документации по Flask Blueprints.

Регистрация схемы элементов в Вашем приложении

Напомним, что схема элементов Flask на самом деле не является приложением. Когда вы регистрируете схему элементов Flask в приложении, вы расширяете приложение вместе с его содержимым. Следующий код показывает, как вы можете зарегистрировать ранее созданную схему элементов Flask в приложении:

from flask import Flask
from example_blueprint import example_blueprint

app = Flask(__name__)
app.register_blueprint(example_blueprint)

Когда вы вызываете .register_blueprint(), вы применяете все операции, записанные в схеме элементов Flask example_blueprint, к app. Теперь запросы к приложению по URL-адресу / будут выполняться с использованием .index() из схемы Flask.

Вы можете настроить, как схема элементов Flask расширяет возможности приложения, предоставив некоторые параметры для register_blueprint:

  • url_prefix - это необязательный префикс для всех маршрутов схемы.
  • поддомен - это поддомен, которому будут соответствовать маршруты Blueprint.
  • url_defaults - это словарь со значениями по умолчанию для аргументов представления.

Возможность выполнять некоторые настройки во время регистрации, а не во время создания, особенно полезна, когда вы используете один и тот же шаблон Flask в разных проектах.

В этом разделе вы увидели, как работают чертежи Flask и как вы можете их создавать и использовать. В следующих разделах вы узнаете, как можно использовать Flask Blueprint для разработки ваших приложений, структурируя их в независимые компоненты. В некоторых случаях вы также можете повторно использовать эти компоненты в различных приложениях, чтобы сократить время разработки!

Как использовать схемы Flask для разработки кода вашего приложения

В этом разделе вы увидите, как можно реорганизовать пример приложения, используя схему элементов Flask. Примером приложения является сайт электронной коммерции со следующими функциями:

  • Посетители могут зарегистрироваться, войти в систему и восстановить пароли.
  • Посетители могут искать товары и просматривать их подробную информацию.
  • Пользователи могут добавлять товары в свою корзину и оформлять заказ.
  • API позволяет внешним системам осуществлять поиск и извлечение информации о продукте.

Вам не нужно особо заботиться о деталях реализации. Вместо этого вы сосредоточитесь главным образом на том, как можно использовать схему Flask для улучшения архитектуры приложения.

Понимание того, почему макет проекта имеет значение

Помните, что Flask не требует какой-либо конкретной компоновки проекта. Вполне возможно организовать код этого приложения следующим образом:

ecommerce/
|
├── static/
|   ├── logo.png
|   ├── main.css
|   ├── generic.js
|   └── product_view.js
|
├── templates/
|   ├── login.html
|   ├── forgot_password.html
|   ├── signup.html
|   ├── checkout.html
|   ├── cart_view.html
|   ├── index.html
|   ├── products_list.html
|   └── product_view.html
|
├── app.py
├── config.py
└── models.py

Код этого приложения организован с использованием следующих каталогов и файлов:

  • static/ содержит статические файлы приложения.
  • шаблоны/ содержит шаблоны приложения.
  • models.py содержит определение моделей приложения.
  • app.py содержит логику приложения.
  • config.py содержит параметры конфигурации приложения.

Это пример того, как создаются многие приложения. Хотя этот макет довольно прост, у него есть несколько недостатков, которые возникают по мере увеличения сложности приложения. Например, вам будет трудно повторно использовать логику приложения в других проектах, поскольку вся функциональность встроена в app.py. Если вместо этого вы разделите эту функциональность на модули, то сможете повторно использовать готовые модули в разных проектах.

Кроме того, если у вас есть только один файл для логики приложения, то в итоге вы получите очень большой app.py, в котором смешивается практически не связанный код. Это может затруднить вам навигацию по скрипту и его обслуживание.

Более того, большие файлы кода являются источником конфликтов при работе в команде, поскольку все будут вносить изменения в один и тот же файл. Это всего лишь несколько причин, по которым предыдущая компоновка хороша только для очень небольших приложений.

Организация Ваших проектов

Вместо структурирования приложения с использованием предыдущего макета вы можете использовать схему элементов Flask для разделения кода на разные модули. В этом разделе вы увидите, как спроектировать предыдущее приложение, чтобы создать схемы, которые инкапсулируют связанные функциональные возможности. В этом макете есть пять схем Flask:

  1. Схема управления API, позволяющая внешним системам осуществлять поиск и извлечение информации о продукте
  2. Схема аутентификации, позволяющая пользователям входить в систему и восстанавливать свой пароль
  3. Схема корзины для функциональности корзины и оформления заказа
  4. Общая схема для главной страницы
  5. Схема продуктов для поиска и просмотра продуктов

Если вы используете отдельный каталог для каждого проекта Flask Blueprint и его ресурсов, то макет проекта будет выглядеть следующим образом:

ecommerce/
|
├── api/
|   ├── __init__.py
|   └── api.py
|
├── auth/
|   ├── templates/
|   |   └── auth/
|   |       ├── login.html
|   |       ├── forgot_password.html
|   |       └── signup.html
|   |
|   ├── __init__.py
|   └── auth.py
|
├── cart/
|   ├── templates/
|   |   └── cart/
|   |       ├── checkout.html
|   |       └── view.html
|   |
|   ├── __init__.py
|   └── cart.py
|
├── general/
|   ├── templates/
|   |   └── general/
|   |       └── index.html
|   |
|   ├── __init__.py
|   └── general.py
|
├── products/
|   ├── static/
|   |   └── view.js
|   |
|   ├── templates/
|   |   └── products/
|   |       ├── list.html
|   |       └── view.html
|   |
|   ├── __init__.py
|   └── products.py
|
├── static/
|   ├── logo.png
|   ├── main.css
|   └── generic.js
|
├── app.py
├── config.py
└── models.py

Чтобы организовать код таким образом, вы перемещаете все представления из app.py в соответствующую схему элементов Flask. Вы также переместили шаблоны и неглобальные статические файлы. Такая структура облегчает вам поиск кода и ресурсов, связанных с заданной функциональностью. Например, если вы хотите найти логику приложения, связанную с продуктами, вы можете перейти к схеме продуктов в разделе products/products.py вместо прокрутки app.py.

Давайте посмотрим на реализацию схемы продуктов в products/products.py:

from flask import Blueprint, render_template
from ecommerce.models import Product

products_bp = Blueprint('products_bp', __name__,
    template_folder='templates',
    static_folder='static', static_url_path='assets')

@products_bp.route('/')
def list():
    products = Product.query.all()
    return render_template('products/list.html', products=products)

@products_bp.route('/view/<int:product_id>')
def view(product_id):
    product = Product.query.get(product_id)
    return render_template('products/view.html', product=product)

Этот код определяет схему products_bp Flask и содержит только тот код, который относится к функциональности продукта. Поскольку у этого шаблона элементов Flask есть свои собственные шаблоны, вам необходимо указать template_folder относительно корня шаблона при создании объекта Blueprint. Поскольку вы указываете static_folder='static' и static_url_path='assets', файлы в ecommerce/products/static/ будут отображаться по URL-адресу /assets/.

Теперь вы можете перенести остальную функциональность вашего кода в соответствующую схему элементов Flask. Другими словами, вы можете создавать схемы элементов для API, аутентификации, корзины и общей функциональности. Как только вы это сделаете, в app.py останется только код, который отвечает за инициализацию приложения и регистрацию Flask Blueprint:

from flask import Flask

from ecommmerce.api.api import api_bp
from ecommmerce.auth.auth import auth_bp
from ecommmerce.cart.cart import cart_bp
from ecommmerce.general.general import general_bp
from ecommmerce.products.products import products_bp

app = Flask(__name__)

app.register_blueprint(api_bp, url_prefix='/api')
app.register_blueprint(auth_bp)
app.register_blueprint(cart_bp, url_prefix='/cart')
app.register_blueprint(general_bp)
app.register_blueprint(products_bp, url_prefix='/products')

Теперь app.py просто импортирует и регистрирует схемы элементов, чтобы расширить приложение. Поскольку вы используете url_prefix, вы можете избежать коллизий URL-адресов между маршрутами схемы элементов Flask. Например, URL-адреса /products/ и /cart/ соответствуют разным конечным точкам, определенным в схемах products_bp и cart_bp для одного и того же маршрута, /.

Включая шаблоны

В Flask, когда представление отображает шаблон, выполняется поиск файла шаблона во всех каталогах, которые были зарегистрированы в пути поиска шаблона в приложении. По умолчанию этот путь равен ["/templates"], поэтому шаблоны ищутся только в каталоге /templates внутри корневого каталога приложения.

Если вы зададите аргумент template_folder при создании схемы элементов, то при регистрации схемы элементов Flask ее папка templates будет добавлена в путь поиска шаблонов приложения. Однако, если пути к файлам в разных каталогах, которые являются частью пути поиска по шаблону, дублируются, то один из них будет иметь приоритет в зависимости от порядка их регистрации.

Например, если представление запрашивает шаблон view.html и в пути поиска по шаблону есть файлы с таким же именем в разных каталогах, то один из них будет иметь приоритет над другим. Поскольку может быть трудно запомнить порядок приоритета, лучше всего избегать размещения файлов по одному и тому же пути в разных каталогах шаблонов. Вот почему следующая структура шаблонов в приложении имеет смысл:

ecommerce/
|
└── products/
    └── templates/
        └── products/
            ├── search.html
            └── view.html

На первый взгляд может показаться излишним, чтобы название схемы элементов Flask появлялось дважды:

  1. Как корневой каталог схемы
  2. Внутри шаблонов каталога

Однако знайте, что, делая это, вы можете избежать возможных коллизий имен шаблонов между различными схемами элементов. Используя эту структуру каталогов, любые представления, для которых требуется шаблон view.html для продуктов, могут использовать products/view.html в качестве имени файла шаблона при вызове render_template. Это позволяет избежать конфликтов с view.html, который принадлежит схеме элементов корзины.

В качестве последнего замечания, важно знать, что шаблоны в каталоге приложения template имеют больший приоритет, чем шаблоны в каталоге шаблонов Blueprint. Это может быть полезно знать, если вы хотите переопределить шаблоны Flask Blueprint без фактического изменения файла шаблона.

Например, если вы хотите переопределить шаблон products/view.html в Схеме продуктов, вы можете сделать это, создав новый файл products/view.html в каталоге приложения templates:

ecommerce/
|
├── products/
|   └── templates/
|       └── products/
|           ├── search.html
|           └── view.html
|
└── templates/
        └── products/
            └── view.html

Когда вы сделаете это, ваша программа будет использовать templates/products/view.html вместо products/templates/products/view.html всякий раз, когда для представления требуется шаблон products/view.html.

Предоставление функций, отличных от представлений

До сих пор вы видели только чертежи, которые расширяют возможности приложений с помощью представлений, но чертежи Flask не обязательно должны содержать только представления! Они могут расширять приложения с помощью шаблонов, статических файлов и фильтров шаблонов. Например, вы могли бы создать схему элементов Flask, чтобы предоставить набор значков и использовать его в своих приложениях. Это может быть файловая структура для такой схемы элементов:

app/
|
└── icons/
    ├── static/
    |   ├── add.png
    |   ├── remove.png
    |   └── save.png
    |
    ├── __init__.py
    └── icons.py

Папка static содержит файлы значков, а icons.py - это определение схемы элементов Flask.

Вот как может выглядеть icons.py:

from flask import Blueprint

icons_bp = Blueprint('icons_bp', __name__,
    static_folder='static',
    static_url_path='icons')

Этот код определяет схему icons_bp Flask, которая предоставляет доступ к файлам в статическом каталоге по URL-адресу /icons/. Обратите внимание, что эта схема не определяет какой-либо маршрут.

Когда вы сможете создавать схемы элементов, которые объединяют представления и другие типы контента, вы сделаете свой код и ресурсы более пригодными для повторного использования в ваших приложениях. Подробнее о возможности повторного использования Flask Blueprint вы узнаете в следующем разделе.

Как использовать схемы элементов Flask для улучшения повторного использования кода

Помимо организации кода, есть еще одно преимущество в структурировании вашего приложения Flask в виде набора независимых компонентов. Вы можете повторно использовать эти компоненты даже в разных приложениях! Например, если вы создали схему элементов Flask, которая обеспечивает функциональность контактной формы, вы можете повторно использовать ее во всех своих приложениях.

Вы также можете использовать чертежи, созданные другими разработчиками, для ускорения своей работы. Хотя централизованного хранилища существующих чертежей Flask не существует, вы можете найти их с помощью индекса пакетов Python , Поиск на GitHub и веб-поисковых систем. Вы можете узнать больше о поиске пакетов PyPI в Что такое Pip? Руководство для начинающих питонистов.

Существуют различные схемы Flask и Расширения Flask (которые реализованы с использованием схем), которые предоставляют функциональность, которая может оказаться полезной для вас:

  • Аутентификация
  • Администрирование/создание CRUD-кода
  • Функциональность CMS
  • И многое другое!

Вместо того, чтобы кодировать свое приложение с нуля, вы можете рассмотреть возможность поиска существующего шаблона или расширения Flask, которые можно использовать повторно. Использование сторонних схем и расширений может помочь вам сократить время разработки и сосредоточиться на основной логике вашего приложения!

Заключение

В этом руководстве вы увидели, как работают схемы элементов Flask, как их использовать и как они могут помочь вам организовать код вашего приложения. Схемы элементов Flask - отличный инструмент для решения проблем, связанных со сложностью приложения по мере его увеличения.

Ты научился:

  • Что такое Чертежи Flask и как они работают
  • Как вы можете реализовать и использовать схему Flask
  • Как схемы элементов Flask могут помочь вам организовать код вашего приложения
  • Как вы можете использовать чертежи Flask для упрощения повторного использования ваших собственных и сторонних компонентов
  • Как использование схемы Flask в вашем проекте может сократить время разработки

Вы можете использовать то, что узнали из этого руководства, чтобы начать организовывать свои приложения в виде набора схем. Создавая приложения таким образом, вы улучшите повторное использование кода, удобство сопровождения и командную работу!

Back to Top