python - 在 model.py 中的函数内进行 API 调用是否可以，为什么我的应用程序在执行此操作后速度减慢这么多？

Question

我正在创建一个加密货币应用程序，我正在使用加密数据填充一些表，为了获取其中一些数据，我需要根据数据库值计算 api 值。我通过创建函数并在 models.py 文件中执行 api 调用来完成此操作，但它大大减慢了我的应用程序的速度。难道我做错了什么？有更好的方法可以编码吗？

下面的 models.py。自从添加 4 个属性以来，速度大大减慢了

class Transaction(models.Model):
    currency = models.CharField(max_length=20)
    amount = models.IntegerField()
    total_price = models.DecimalField(max_digits=8, decimal_places=2)
    date_purchased = models.DateTimeField()
    note = models.TextField(default="")
    owner = models.ForeignKey(User, on_delete=models.CASCADE)
    amount_per_coin = models.DecimalField(max_digits=8, decimal_places=2, editable=False)

    def save(self, *args, **kwargs):
        self.amount_per_coin = self.total_price / self.amount
        super(Transaction, self).save(*args, **kwargs)

    def __str__(self):
        return str(self.pk)+','+self.currency + ', '+str(self.amount)

    def get_absolute_url(self):
        return reverse('transaction-detail', kwargs={'pk': self.pk})

    @property
    def coin_value(self):
        try:
            current_price = requests.get("https://min-api.cryptocompare.com/data/price?fsym="+self.currency+"&tsyms=EUR")
            price = json.loads(current_price.content)
            return price["EUR"]
        except:
            return 0


    @property
    def total_value(self):
        value = self.coin_value * self.amount
        return round(value, 2)

    @property
    def profit_loss(self):
        value = float(self.total_value) - float(self.total_price)
        return round(value, 2)

    @property
    def profit_loss_percent(self):
        value = ((float(self.total_value) - float(self.total_price))/self.total_value)*100
        return round(value, 1)

我添加到下面的表格

 {% for transaction in transactions %}
            <tr>
                <td>{{transaction.currency}}</td>
                <td>{{transaction.amount}}</td>
                <td>{{transaction.amount_per_coin}}</td>
                <td>{{transaction.total_price}}</td>
                <td>{{transaction.coin_value}}</td>
                <td>{{transaction.total_value}}</td>
                <td>{{transaction.date_purchased|date:"j N Y"}}</td>
                <td>{{transaction.profit_loss}}</td>
                <td>{{transaction.profit_loss_percent}} %</td>
                <td><a href="{% url 'transaction-detail' transaction.id %}">View</a></td>
            </tr>
            {% endfor %}

Answer 1

与其他服务的网络连接总是相对较慢。因此，您要做的就是找到避免提出太多此类请求的方法。

一种常见的方法是将结果缓存一段时间。如果您正在处理全部使用少量货币的大量交易，即使是短的、几秒范围的缓存也可以提供巨大帮助。现在，您对访问的每个属性发出新请求，因此呈现表会触发四个请求每个显示的事务行。

Django 已经有 support for caching data ;以下代码将使用 CACHES = {..., 'currencies': {...},} 下配置的缓存(如果存在)，否则使用 'default'配置。通过设置专用缓存配置，您可以仅设置货币数据的超时等内容。

如果您有 Cryptocompare API key ，请将其设置在 settings.py 文件的 CRYPTOCOMPARE_API_KEY 中:

import requests
from django.conf import settings
from django.core.cache import caches, InvalidCacheBackendError

APIURL = 'https://min-api.cryptocompare.com/data/price'

class CurrencyPrices:
    def __init__(self):
        self.session = requests.Session()  # re-use connections
        api_key = getattr(settings, 'CRYPTOCOMPARE_API_KEY', None)
        if api_key is not None:
            self.session.headers['Authorization'] = f'Apikey {api_key}'
        try:
            self.cache = caches['currencies']
            self.key_prefix = ''
        except InvalidCacheBackendError:
            self.cache = caches['default']
            self.key_prefix = 'currency_cache_'

    def get_currency_price(self, currency):
        key = f'{self.key_prefix}{currency}'
        value = self.cache.get(key)
        if value is None:
            params = {"fsym": currency, "tsyms": "EUR"}
            response = self.session.get(APIURL, params=params)
            value = response.json()['EUR']
            self.cache.set(key, value)
        return value

_currency_prices = CurrencyPrices()  # single instance per process
get_currency_price = _currency_prices.get_currency_price

然后导入 get_currency_price 并使用它来获取您的值:

@property
def coin_value(self):
    return get_currency_price(self.currency)

以下是一个缓存配置示例，它将响应缓存在本地内存中 10 秒:

CACHES = {
    'currencies': {
        'BACKEND': 'django.core.cache.backends.locmem.LocMemCache',
        'LOCATION': 'currencies',
        'TIMEOUT': 10,
    }
}

检查什么other settings might be needed .