Flask1.1.4 werkzeug1.0.1 source code analysis: Blueprint

Blueprints are used in daily projects to group user side and management side api, Use different prefixes . Today, let's explore the principle behind the blueprint .
Let's first look at an example of using blueprints .

from flask import Flask, Blueprint

#  Instantiation 
app = Flask(__name__)
#  Building blueprint objects 
some_blueprint = Blueprint('some', __name__)

#  Use the method of blueprint object to decorate view_function
@some_blueprint.route("/a")
def hello_world():
    return "<p>Hello, World!</p>"

#  Register blueprints with  flask_app
app.register_blueprint(some_blueprint, url_prefix='/pre')

We have figured out the previous series Flask take url_rule and view_function Save them separately to url_map and view_functions Properties of the . Blueprints are just a new form of routing packet management , Ultimately, the information in the blueprint must be saved to the same place in the same way , Let's study the process .

Let's start with @some_blueprint.route(“/a”)

class Blueprint(_PackageBoundObject):

    def route(self, rule, **options):
       	#  and flask_app.route() Like a hair 
        def decorator(f):
        	# endpoint  Default function name 
            endpoint = options.pop("endpoint", f.__name__)
            self.add_url_rule(rule, endpoint, f, **options)
            return f

        return decorator

    def add_url_rule(self, rule, endpoint=None, view_func=None, **options):
        #  The parameter is one   function ！
        #  This function is closed   Routing and function related information 
        self.record(lambda s: s.add_url_rule(rule, endpoint, view_func, **options))

    def record(self, func):
    	# self.deferred_functions  It's a  []
    	#  Here is simply to save this function to the blueprint object 
        self.deferred_functions.append(func)

By the visible on , The blueprint Simple will Information such as routes and functions are saved , It's just a special way to save , Save this anonymous function lambda s: s.add_url_rule(rule, endpoint, view_func, **options) , You will see later that you are registering blueprints to flask_app When , Will call this function .

Let's take a look app.register_blueprint(some_blueprint, url_prefix=‘/pre’)

class Flask(_PackageBoundObject):

    @setupmethod
    def register_blueprint(self, blueprint, **options):
        first_registration = False
		#  call buleprint Methods 
		#  The first parameter is zero  flask_app
        blueprint.register(self, options, first_registration)

class Blueprint(_PackageBoundObject):

    def make_setup_state(self, app, options, first_registration=False):
    	#  The first parameter  Blueprint example 
    	#  The second parameter  flask_app example 
        return BlueprintSetupState(self, app, options, first_registration)

    def register(self, app, options, first_registration=False):
        self._got_registered_once = True
        # state  It's a  BlueprintSetupState example   The following research 
        state = self.make_setup_state(app, options, first_registration)
		
		#  Before  Blueprint.route()  Saved function list   In turn, calls 
        for deferred in self.deferred_functions:
        	#  Remember  deferred  The function is  lambda s: s.add_url_rule(rule, endpoint, view_func, **options)
        	#  in other words  deferred(state)  Would call  state.add_url_rule(rule, endpoint, view_func, **options)
            deferred(state)

        cli_resolved_group = options.get("cli_group", self.cli_group)

look down BlueprintSetupState class

class BlueprintSetupState(object):

    def __init__(self, blueprint, app, options, first_registration):
        
        self.app = app
        self.blueprint = blueprint
        self.options = options
		
		#  first   Use  flask_app.register_blueprint()  When it came in  url_prefix
		#  If not   Reuse Blueprint Of  url_prefix
        url_prefix = self.options.get("url_prefix")
        if url_prefix is None:
            url_prefix = self.blueprint.url_prefix
        
        self.url_prefix = url_prefix

    #  above  deferred(state)  This method is called 
    def add_url_rule(self, rule, endpoint=None, view_func=None, **options):
        if self.url_prefix is not None:
            if rule:
            	#  both  url_prefix  And then there is  url_rule Under the circumstances   Splice both 
                rule = "/".join((self.url_prefix.rstrip("/"), rule.lstrip("/")))
            else:
                rule = self.url_prefix
        # endpoint  By default, the function name 
        if endpoint is None:
            endpoint = _endpoint_from_view_func(view_func)
        defaults = self.url_defaults
        #  Eventually   Go to the  flask_app.add_url_rule
        #  Pay attention to  endpoint by  {bulprint.name}.{endpoint}  Very reasonable.   Full paths should be used to avoid duplication of elements within a group 
        self.app.add_url_rule(
            rule,
            "%s.%s" % (self.blueprint.name, endpoint),
            view_func,
            defaults=defaults,
            **options
        )

Sum up ：

1. Blueprint Contains a set of routing information , You can use a uniform prefix . There is an interesting design in Blueprint.deferred_functions Property is a Anonymous function object lambda s: s.add_url_rule(rule, endpoint, view_func, **options), Anonymous function closures contain information such as routing .
2. flask.register_blueprint() It finally triggered Blueprint.deferred_functions Function call in sequence , But it is not directly transmitted flask_app, But use BlueprintSetupState This holder class Some information is recorded and preprocessed , Then pass it as a parameter . Final , call BlueprintSetupState.add_url_rule(), Its internal finally calls flask_app.add_url_rule()