The proxy pattern and chain of responsibility pattern | Python theme on 11/30

Writing in the front

This article is participating in Python Theme Month. See the link for details

This month is Python Activity month, and I decided to try out the daily and random questions in Python for 30 days. Then if I have the energy for the weekend, I’d like to play around with this Python-Patterns

Design mode for me is more learning than my personal experience summary, so I am likely to understand the partial, if there is a boss to see, please timely point out that I choose to write some personal things in Nuggets because of the higher quality of the article here, I do not hope that the later to see these articles are misleading.

The proxy pattern

Chain of Responsibility model

I mentioned this earlier when I mentioned 3-Tier, but I’m going to elaborate on what I understand to be MVC.

MVC separates the presentation of data in a GUI from the process by which it is received. Rendering naturally is the view here, being accepted is the model there, and separating is what the controller does. Let’s look at the code.

from abc import ABC, abstractmethod


class Model(ABC) :
    @abstractmethod
    def __iter__(self) :
        pass

    @abstractmethod
    def get(self, item) :
        """Returns an object with a .items() call method that iterates over key,value pairs of its information."""
        pass

    @property
    @abstractmethod
    def item_type(self) :
        pass


class ProductModel(Model) :
    class Price(float) :
        """A polymorphic way to pass a float with a particular __str__ functionality."""

        def __str__(self) :
            return f"{self:2.f}"

    products = {
        "milk": {"price": Price(1.50), "quantity": 10},
        "eggs": {"price": Price(0.20), "quantity": 100},
        "cheese": {"price": Price(2.00), "quantity": 10},
    }

    item_type = "product"

    def __iter__(self) :
        yield from self.products

    def get(self, product) :
        try:
            return self.products[product]
        except KeyError as e:
            raise KeyError(str(e) + " not in the model's item list.")


class View(ABC) :
    @abstractmethod
    def show_item_list(self, item_type, item_list) :
        pass

    @abstractmethod
    def show_item_information(self, item_type, item_name, item_info) :
        """Will look for item information by iterating over key,value pairs yielded by item_info.items()"""
        pass

    @abstractmethod
    def item_not_found(self, item_type, item_name) :
        pass


class ConsoleView(View) :
    def show_item_list(self, item_type, item_list) :
        print(item_type.upper() + " LIST:")
        for item in item_list:
            print(item)
        print("")

    @staticmethod
    def capitalizer(string) :
        return string[0].upper() + string[1:].lower()

    def show_item_information(self, item_type, item_name, item_info) :
        print(item_type.upper() + " INFORMATION:")
        printout = "Name: %s" % item_name
        for key, value in item_info.items():
            printout += "," + self.capitalizer(str(key)) + ":" + str(value)
        printout += "\n"
        print(printout)

    def item_not_found(self, item_type, item_name) :
        print(f'That {item_type} "{item_name}" does not exist in the records')


class Controller:
    def __init__(self, model, view) :
        self.model = model
        self.view = view

    def show_items(self) :
        items = list(self.model)
        item_type = self.model.item_type
        self.view.show_item_list(item_type, items)

    def show_item_information(self, item_name) :
        try:
            item_info = self.model.get(item_name)
        except Exception:
            item_type = self.model.item_type
            self.view.item_not_found(item_type, item_name)
        else:
            item_type = self.model.item_type
            self.view.show_item_information(item_type, item_name, item_info)


def main() :
    """ >>> model = ProductModel() >>> view = ConsoleView() >>> controller = Controller(model, view) >>> controller.show_items() PRODUCT LIST: milk eggs cheese 
      
        >>> controller.show_item_information("cheese") PRODUCT INFORMATION: Name: cheese, Price: BLANKLINE> >>> controller.show_item_information("eggs") PRODUCT INFORMATION: Name: eggs, Price: BLANKLINE> >>> controller. show_item_Information ("milk") PRODUCT INFORMATION: Name: milk, Price: 1.50, Quantity: 10 
       
         >>> controller.show_item_information("arepas") That product "arepas" does not exist in the records """
       
      


if __name__ == "__main__":
    import doctest

    doctest.testmod()

Copy the code

The example here is a naive MVC structure where the controller is sandwiched between the view and the model, so the controller has a lot of power and a lot of responsibility.

summary

The front-end controller pattern provides a centralized entry point to control and manage request processing. MVC separates the presentation of data in a GUI from the process by which it is received.

reference

• There is no