Python的结构型设计模型之修饰器模式

一般来说，“修饰器”是个单参数的函数，其参也是函数。框架经常使用修饰器把用户所编写的函数集成进来。
白话说就是在一个函数定义的前一行，写上修饰器，就代表此函数具有修饰器的功能。
我现在用的最多的就是 flask 框架，有的函数其修饰器，可以设置成只有已登录用户进行操作。框架里面的路由视图多了，这样的一个修饰器起到了极大的作用。

以下代码依次对修饰器进行举例：

def float_args_and_return(function):
    @functools.wraps(function)
    def wapper(*args, **kwargs):
        args = [float(arg) for arg in args]
        return float(function(*args, **kwargs))
    return wapper()


@float_args_and_return
def mean1(first, second, *rest):
    numbers = (first, second) + rest
    return sum(numbers) / len(numbers)


def mean2(first, second, *rest):
    numbers = (first, second) + rest
    return sum(numbers) / len(numbers)
mean2 = float_args_and_return(mean2)

这个是无参数化的修饰器，意思就是 @XXXXX 这里的 XXXX 是没有参数的，直接对 mean 进行修饰。
mean2 就是对修饰器进行一次讲解，两个是等价的。方便大家理解。

def statically_typed(return_type=None, *item):
#     因 python3.x 和 2.x 版本还是有些许差别
#     这里带有参数的修饰器只介绍逻辑思路
#     1.先创建修饰器工厂
#     2.由工厂创建包装函数
    def decorator(function):
        @functools.wraps(function)
        def wrapper(*args, **kwargs):
            dosomething()
            result = dosomething
            return result
        return wrapper
    return decorator


@statically_typed(return_type=str, str, str)
def make_tagged(text, tag):
    return "<{0}>{1}</{0}>".format(tag, text)


@statically_typed(str, int, str)
def repeat(what, count, separator):
    return ((what + separator) * count)[:-len(separator)]

参数化的修饰器，能复杂一点，如上所说，得先创建一个 decorator 的修饰器工厂，由工厂来创建修饰器。
值得注意一点：
decorator 修饰器工厂会返回 wrapper() ，wrapper() 函数就是来捕获其外围函数的状态，就是 types 和 return_type 关键字参数。
能够捕获状态的函数或方法就叫做“闭包”。

@application.post("/mailinglists/add")
@Web.ensure_logged_in
def person_add_submit(username):
    name = bottle.request.forms.get("name")
    try:
        id = Data.MailingLists.add(name)
        bottle.redirect("/mailinglists/view")
    except Data.Sql.Error as err:
        return bottle.mako_template("error", url="/mailinglists/add", text="Add mailinglist", message=str(err))


def ensuer_logged_in(function):
    @functools.wraps(function)
    def wrapper(*args, **kwargs):
        username = bottle.request.get_cookie(COOKIE, sercet=sercet(bottle.request))
        if username is not None:
            kwargs["username"] = username
            return function(*args, **kwargs)
        bottle.redirect("/login")
    return wrapper

bottle框架的例子，确认是否登录的修饰器，和我一开始说的如出一辙，大概就是这么回事。
这个修饰器，用 cookie 来判断用户是否登录，登录的话，就默认用户存在，否则返回登录界面。

类修饰器，就是对一个类里面的属性进行修饰。因大量重复的 getter 和 setter，类修饰器慢慢呈现出来。

def ensuer(name, validate, doc=None):
    def decorator(Class):
        privateName = "__" + name
        def getter(self):
            return getattr(self, privateName)
        def setter(self, value):
            validate(name, value)
            return setattr(self, privateName, value)
        setattr(Class, name, property(getter, setter, doc=doc))
        return Class
    return decorator


def is_non_empty_str(name, value):
    if not isinstance(value, str):
        raise ValueError("Type must str, not {}".format(name))
    if not bool(value):
        raise ValueError("{} may not be empty".format(name))


def is_in_range(minimum=None, maximum=None):
    assert minimum is not None or maximum is not None
    def is_in_range(name, value):
        if not isinstance(value, numbers.Number):
            raise ValueError("{} must be a number".format(name))
        if minimum is not None and value < minimum:
            raise ValueError("{} is too small {}".format(name, value))
        if maximum is not None and value > maximum:
            raise ValueError("{} is too big {}".format(name, value))
    return is_in_range()


@ensuer("title", is_non_empty_str)
@ensuer("price", is_in_range(1, 10000))
@ensuer("quantity", is_in_range(0, 1000000))
class Book:

    def __init__(self, title, price, quantity):
        self.title = title
        self.price = price
        self.quantity = quantity

    @property
    def value(self):
        return self.price * self.quantity

一个 book 有三个属性，三个修饰器可以对三个属性进行控制操作。
而这样看是不是觉得 ensuer 太多了，可以简化成一个修饰器吗？

def db_ensure(Class):
    def make_property(name, attribute):
        privateName = "__" + name
        def getter(self):
            return getattr(self, privateName)
        def setter(self, value):
            attribute.validate(name, value)
            setattr(self, privateName, value)
        return property(getter, setter, doc=attribute.doc)
    for name, attribute in Class.__dict__.items():
        if isinstance(attribute, Ensure):
            setattr(Class, name, make_property(name, attribute))
    return Class


class Ensure:

    def __init__(self, validate, doc=None):
        self.validate = validate
        self.doc = doc


@db_ensure
class book:
    title = Ensure(is_non_empty_str)
    price = Ensure(is_in_range(1, 10000))
    quantity = Ensure(is_in_range(1, 100000))

    def __init__(self, title, price, quantity):
        self.title = title
        self.price = price
        self.quantity = quantity

    @property
    def value(self):
        return self.price * self.quantity

关键在于 attribute 和 Ensuer，大概意思就是把 Ensuer 当作属性的方法

总的来说，修饰器就是能简化，方便，改善程序。如书上讲“是 Python 中易用且强大的功能”。而我认为要灵活使用修饰器，必须学会 Python 在面向对象方面的基础。