경량급 웹 프레임 워 크 Flask 에서 모듈 화 응용 실현

Flask 는 경량급 웹 프레임 워 크 입 니 다.비록 경량급 이지 만 구성 요소 의 대형,모듈 화 응용 도 실현 할 수 있다.'청사진'은 바로 이런 실현 이다.모듈 화 응용의 실현 에 대해 Flask 0.2 버 전에 서 디자인 했다.본 고 는 잠시'청사진'에 대해 상세 하 게 소개 하지 않 고 0.2 버 전의 Module 류 의 실현 부터 말한다.사실'청사진'의 실현 은 모듈 류 의 실현 과 비슷 하 다.
왜 모듈 화 응용 을 실현 합 니까?
대형 응용 에 있어 기능 이 계속 증가 함 에 따라 전체 응용 규모 도 확 대 될 것 이다.일정한 규칙 에 따라 응용 하 는 서로 다른 부분 을 모듈 화 하면 전체 응용 논 리 를 명확 하 게 할 수 있 을 뿐만 아니 라 유지 하기 도 쉽다.예 를 들 어 Flask 에서 다음 과 같은 간단 한 프로젝트 를 구축 하고 싶 을 수도 있 습 니 다.

/myapplication
  /__init__.py
  /views
    /__init__.py
    /admin.py
    /frontend.py

상기 디 렉 터 리 구조 에서 저 희 는 이전의 Flask 단일 파일 을 하나의 응용 패키지 로 수정 하 였 습 니 다.모든 보기 함 수 는 views 에 있 고 기능 에 따라 admin 과 frontend 두 부분 으로 나 누 었 습 니 다.이러한 모듈 화 애플 리 케 이 션 구축 을 위해 0.2 버 전에 서 Flask 는 Module 류 를 구현 했다.이 인 스 턴 스 는 등록 을 통 해 Flask 응용 프로그램 을 만 든 후에 응용 프로그램 에 추가 할 수 있 습 니 다.
Module 류 는 일련의 방법 을 실현 했다.
•route(rule, **options)
•add_url_rule(rule, endpoint, view_func=None, **options)
•before_request(f)
•before_app_request(f)
•after_request(f)
•after_app_request(f)
•context_processor(f)
•app_context_processor(f)
•_record(func)
이상 방법 은 add 제외url_rule 와record 외 에 모두 장식 기로 자신의 모듈 에서 사용 할 수 있 으 며,이 장식 기 들 은 모두 함 수 를 되 돌려 줍 니 다.호출 을 통 해record 방법,장식 기 를 되 돌려 주 는 함 수 를register_이벤트 중.Flask 응용 프로그램 생 성 후 실행 을 통 해register_이벤트 목록 의 함수 입 니 다.이 모듈 을 응용 프로그램 에 등록 할 수 있 습 니 다.
Flask 응용 프로그램 은 Module 을 어떻게 등록 합 니까?
다음은 Flask 응용 프로그램 이 모듈 을 어떻게 등록 하 는 지 예 를 들 어 설명 합 니 다.
1.프로젝트 구성
이 간단 한 예 항목 구 조 는 다음 과 같다.

/myapplication
  /__init__.py
  /app.py
  /views
    /__init__.py
    /admin.py
    /blog.py

admin.py 와 blog.py 두 모듈 의 코드 는 다음 과 같 습 니 다.

# admin.py
from flask import Module
admin = Module(__name__)
@admin.route('/')
def index():
  return "This is admin page!"
@admin.route('/profile')
def profile():
  return "This is profile page."

# blog.py
from flask import Module
blog = Module(__name__)
@blog.route('/')
def index():
  return "This is my blog!"
@blog.route('/article/<int:id>')
def article(id):
  return "The article id is %d." % id

상기 두 모듈 에서 우 리 는 먼저 하나의 Module 류 를 만 든 다음 에 일반적인 보기 함 수 를 쓰 는 것 처럼 각 모듈 에 규칙 을 추가 합 니 다.이후 Flask 애플 리 케 이 션 을 만 들 때 이 모듈 을 도입 하면 등록 할 수 있다.

# app.py
from flask import Flask
from views.admin import admin
from views.blog import blog
app = Flask(__name__)
@app.route('/')
def index():
  return "This is my app."
app.register_module(blog, url_prefix='/blog')
app.register_module(admin, url_prefix='/admin')
if __name__ == '__main__':
  from werkzeug.serving import run_simple
  run_simple('localhost', 5000, app)

app.py 에서:
•우 리 는 먼저 admin 과 blog 두 개의 Module 대상 을 도입 했다.
•그 후에 우 리 는 Flask 응용 프로그램 app 을 만 들 었 고 이 응용 프로그램 에 보기 함 수 를 추가 했다.
•모듈 등록 을 위해 애플 리 케 이 션 register 를 호출 했 습 니 다.module 방법;
•마지막 으로,werkzeug.serving 에서 run 을 호출 합 니 다.Simple 방법 은 이 Flask 응용 프로그램 을 테스트 하기 위해 로 컬 서버 를 만 드 는 데 사 용 됩 니 다.
이상 의 절차 에 따라 우 리 는 이 응용 을 테스트 할 수 있다.각각/blog 와/admin 을 URL 접두사 로 하여 blog 와 admin 두 모듈 을 방문 할 수 있 습 니 다.
2.모듈 을 등록 할 때 무슨 일이 일 어 났 는 지
위의 예 에 따 르 면 Flask 응용 프로그램의 register 를 간단하게 호출 하면모듈 방법,모듈 을 등록 할 수 있 습 니 다.register 에 대하 여module 방법의 코드 는 다음 과 같다.

def register_module(self, module, **options):
  """Registers a module with this application. The keyword argument
  of this function are the same as the ones for the constructor of the
  :class:`Module` class and will override the values of the module if
  provided.
  """
  options.setdefault('url_prefix', module.url_prefix)
  state = _ModuleSetupState(self, **options)
  for func in module._register_events:
    func(state)

상기 코드 를 통 해 알 수 있 습 니 다:
•url 증가 로prefix 는 서로 다른 Module 을 구분 합 니 다.이것 은 app 이 admin 과 blog 를 등록 할 때 우 리 는 이미 보 았 습 니 다.
•등록 할 때 우 리 는ModuleSetupState 클래스 입 니 다.이 클래스 는 Flask 응용 프로그램 과 일부 매개 변 수 를 받 아 state 인 스 턴 스 를 생 성 합 니 다.이 인 스 턴 스 는 현재 Flask 응용 상 태 를 반영 합 니 다.
•앞에서 모듈 류 에 대해 이야기 할 때,우 리 는 모듈 이 등록 되 지 않 았 을 때,자신의 모듈 의 일부 기능 을 실현 하 는 것 을 모두register_이벤트 목록 에서 이 기능 들 은 모두 함수 형식 입 니 다.모듈 을 특정한 응용 프로그램 에 등록 해 야 할 때 이 응용 정보 에 대한 매개 변수 만 전달 하면 됩 니 다.즉,위의 state 인 스 턴 스 입 니 다.이렇게 하면 실행 함 수 를 통 해 일부 속성 을 현재 응용 에 연결 할 수 있 습 니 다.
위의 예 에서 서로 다른 모듈 의 URL 바 인 딩 에 있어 등록 을 통 해 app 은 다음 과 같은 URL'지도'를 형성 했다.

>>> app.url_map
Map([<Rule '/admin/profile' (HEAD, GET) -> admin.profile>,
   <Rule '/admin/' (HEAD, GET) -> admin.index>,
   <Rule '/blog/' (HEAD, GET) -> blog.index>,
   <Rule '/' (HEAD, GET) -> index>,
   <Rule '/blog/article/<id>' (HEAD, GET) -> blog.article>,
   <Rule '/static/<filename>' (HEAD, GET) -> static>]
  )
>>> app.url_map._rules_by_endpoint
{'admin.index': [<Rule '/admin/' (HEAD, GET) -> admin.index>],
 'admin.profile': [<Rule '/admin/profile' (HEAD, GET) -> admin.profile>],
 'blog.article': [<Rule '/blog/article/<id>' (HEAD, GET) -> blog.article>],
 'blog.index': [<Rule '/blog/' (HEAD, GET) -> blog.index>],
 'index': [<Rule '/' (HEAD, GET) -> index>],
 'static': [<Rule '/static/<filename>' (HEAD, GET) -> static>]
}
>>> app.view_functions
{'admin.index': <function views.admin.index>,
 'admin.profile': <function views.admin.profile>,
 'blog.article': <function views.blog.article>,
 'blog.index': <function views.blog.index>,
 'index': <function __main__.index>
}

이렇게 하면 서로 다른 모듈 의 URL 규칙 을 함께 놓 고 endpoint 와 보기 함수 사이 에 대응 관 계 를 형성 할 수 있 습 니 다.Flask 응용 프로그램의 URL 처리 에 대해 서 는 Flask 응용 프로그램의 URL 처 리 를 참고 할 수 있 습 니 다.