Bottle 框架和 OOP，使用方法而不是函数

Question

我已经用 Bottle 编写了一些代码。这真的很简单，适合我的需要。但是，当我尝试将应用程序包装到一个类中时，我被卡住了：

import bottle
app = bottle

class App():
    def __init__(self,param):
        self.param   = param

    # Doesn't work
    @app.route("/1")
    def index1(self):
        return("I'm 1 | self.param = %s" % self.param)

    # Doesn't work
    @app.route("/2")
    def index2(self):
        return("I'm 2")

    # Works fine
    @app.route("/3")
    def index3():
        return("I'm 3")

是否可以在 Bottle 中使用方法而不是函数？

Answer 1

您的代码不起作用，因为您试图路由到非绑定方法。非绑定方法没有对self 的引用，如果没有创建App 的实例，它们怎么可能？

如果你想路由到类方法，你首先必须初始化你的类，然后 bottle.route() 到该对象上的方法，如下所示：

import bottle        

class App(object):
    def __init__(self,param):
        self.param   = param

    def index1(self):
        return("I'm 1 | self.param = %s" % self.param)

myapp = App(param='some param')
bottle.route("/1")(myapp.index1)

如果您想在处理程序附近粘贴路由定义，您可以执行以下操作：

def routeapp(obj):
    for kw in dir(app):
        attr = getattr(app, kw)
        if hasattr(attr, 'route'):
            bottle.route(attr.route)(attr)

class App(object):
    def __init__(self, config):
        self.config = config

    def index(self):
        pass
    index.route = '/index/'

app = App({'config':1})
routeapp(app)

不要在App.__init__() 中使用bottle.route() 部分，因为您将无法创建App 类的两个实例。

如果你喜欢装饰器的语法而不是设置属性index.route=，你可以写一个简单的装饰器：

def methodroute(route):
    def decorator(f):
        f.route = route
        return f
    return decorator

class App(object):
    @methodroute('/index/')
    def index(self):
        pass

Answer 2

下面对我来说很好用:) 非常面向对象且易于理解。

from bottle import Bottle, template

class Server:
    def __init__(self, host, port):
        self._host = host
        self._port = port
        self._app = Bottle()
        self._route()

    def _route(self):
        self._app.route('/', method="GET", callback=self._index)
        self._app.route('/hello/<name>', callback=self._hello)

    def start(self):
        self._app.run(host=self._host, port=self._port)

    def _index(self):
        return 'Welcome'

    def _hello(self, name="Guest"):
        return template('Hello {{name}}, how are you?', name=name)

server = Server(host='localhost', port=8090)
server.start()

Answer 3

您必须扩展 Bottle 类。它的实例是 WSGI Web 应用程序。

from bottle import Bottle

class MyApp(Bottle):
    def __init__(self, name):
        super(MyApp, self).__init__()
        self.name = name
        self.route('/', callback=self.index)

    def index(self):
        return "Hello, my name is " + self.name

app = MyApp('OOBottle')
app.run(host='localhost', port=8080)

大多数示例正在做的事情，包括之前为这个问题提供的答案，都是重用“默认应用程序”，而不是创建自己的应用程序，也没有使用面向对象和继承的便利。

Answer 4

我接受了@Skirmantas 的回答并对其进行了一些修改，以允许在装饰器中使用关键字参数，例如方法、跳过等：

def routemethod(route, **kwargs):
    def decorator(f):
        f.route = route
        for arg in kwargs:
            setattr(f, arg, kwargs[arg])
        return f
    return decorator

def routeapp(obj):
    for kw in dir(obj):
        attr = getattr(obj, kw)
        if hasattr(attr, "route"):
            if hasattr(attr, "method"):
                method = getattr(attr, "method")
            else:
                method = "GET"
            if hasattr(attr, "callback"):
                callback = getattr(attr, "callback")
            else:
                callback = None
            if hasattr(attr, "name"):
                name = getattr(attr, "name")
            else:
                name = None
            if hasattr(attr, "apply"):
                aply = getattr(attr, "apply")
            else:
                aply = None
            if hasattr(attr, "skip"):
                skip = getattr(attr, "skip")
            else:
                skip = None

            bottle.route(attr.route, method, callback, name, aply, skip)(attr)

Answer 5

试试这个，对我有用，文档也很不错，可以开始使用...

https://github.com/techchunks/bottleCBV