Routing decorator of tornado project

With The current project As an example , Code

1. When we start the project , The first thing you need is to register routes , So we can define a method , This method is called get_handlers, To get the route of the whole project
2. But how to represent a class as a route ？ This is the time , We used decorators open_handler, The class decorated by this decorator , Then he is a route , therefore open_handler There are at least two parameters
   1. path route
   2. index Used for routing sorting

Decorator

We're in the catalog tornado project core\decorators\open_handler Write down a decorator , Class as decorator Click on

class HandlerDecorate:
    """ Route decorator  1.  In essence, the route decorator just adds __url_path__ Properties of  2.  When we initialize, we pass __url_path__ This attribute determines whether the current class is the routing processor  3. __url_path_index__ Used to sort routes  """

    def __init__(self, path, index=None) -> None:
        self.__url_path__ = path
        self.__url_path_index__ = index

    def __call__(self, cls):
        cls.__url_path__ = self.__url_path__
        cls.__url_path_index__ = self.__url_path_index__

        return cls

We are __init__.py Expose this decorator

from core.decorators.open_handler.index import HandlerDecorate

open_handler = HandlerDecorate

Just go through @open_hander Modified class , Will contain __url_paht__ attribute , Such as

@open_handler(path="/api/(.*)", index=1)
class openApiHandlerService(RequestHandler):
    def get(self, *args, **kwargs):
        self.write("hello world")
        self.finish()

that ,openApiHandlerService Will contain __url_paht__ The attribute is /api/(.*)

Collection of routes

Definition get_handlers Method , To get the class decorated by the decorator

Traverse the project file

We need to define a function to traverse the project file , The current function is used to find the items that are open_handler Modified class

We are core\utils\module_utils.py Next , Create a new function , Used to traverse to get all the module

import importlib
import pkgutil
import os

def get_all_modules(path, file_name):
    """  Get all under the path file_name Of module """
    #  Get the configuration of the directory ( The directory must be a package , Just can have __path__ attribute )
    _app = importlib.import_module(path)

    def get_all_moudules_name(package_path, prefix=""):
        #  For deep traversal of folders 
        for loader, name, is_package in pkgutil.iter_modules([package_path]):
            if is_package:
                #  If it's still a bag , Then traverse again , And prefix it when traversing 
                for _name in get_all_moudules_name(os.path.join(package_path, name), prefix=f"{
      name}."):
                    yield prefix + _name
            else:
                yield prefix + name

    return [
        importlib.import_module(f"{
      path}.{
      module_name}")
        for module_name in get_all_moudules_name(_app.__path__[0])
        if module_name.split(".")[-1][:len(file_name)] == file_name
    ]

• import_module Click on , Get the function in the module 、 Properties, etc
• iter_modules Click on , Get module

To regulate , All the classes defined by our route are handlers In the file of

Get all routes under the project

We are core\decorators\open_handler So let's make a new one OpenHandler Class , And define a get_handlers Method is used to get all routes

class OpenHandler:
    """ Routing container  1.  Get the container class and tool class of the route during initialization  2.  return tornado The routing list  """

    def __init__(self, source_libs) -> None:
        self.source_libs = source_libs   #  Pass the directory name , Used to get all classes using decorators in the directory 
        self.handler_libs = []  #  Container for storing routes 

    def get_handlers(self):
        self._handler_libs_ = []
        _modules = []  #  All the moudule Containers 
        for _path in self.source_libs:
            _modules += get_all_modules(_path, "handler")

        for _module in _modules:
            self.handler_libs += [
                dict(
                    path=_member.__url_path__,
                    handler=f"{
      _member.__module__}.{
      _member.__name__}",
                    index = _member.__url_path_index__
                )
                for _name,_member in inspect.getmembers(_module, inspect.isclass)
                if hasattr(_member, "__url_path__")
            ]

        #  Sort 
        self.handler_libs.sort(key=lambda x: x['index'])

        #  Generate tornado The routing object of 
        _result = []
        for _handler_lib in self.handler_libs:
            #  Traversal generation tornado The routing object of 
            _path = _handler_lib.get("path")
            _result.append(
                url(_path, import_object(_handler_lib.get("handler"))))

        #  All routing lists 
        return _result

Registered routing

Generally, we need to register the route when starting the project

obtain handler All routes under

For the purpose of project specification, we have registered all routes under the name handler Under folder , When starting the environment , We usually call Environment Class , We are Environment Next , Write a get handler Routing method under

class Environment:
	...

    def get_all_handlers(self):
        open_handler = OpenHandler(["core"])
        return open_handler.get_handlers()

What he said is to get core All routes under the folder , Then we register the route

class Application(Application):
    def __init__(self):
        #  Initialize database 、redis etc. , When the project starts , Do not introduce model classes 
        #  Registered routing 
        handlers = environment.get_all_handlers()
        #  Add dynamic routing 
        super().__init__(handlers, **config.settings)

test

1. Start project , We type in http://localhost:8888/api/, We will find that we can access the registered route
2.