Contoh Memcache

Halaman ini menyediakan contoh kode Python untuk menggunakan memcache. Memcache adalah sistem caching objek memori terdistribusi berperforma tinggi yang menyediakan akses cepat ke data yang di-cache. Untuk mempelajari memcache lebih lanjut, baca Ringkasan Memcache.

Halaman ini menjelaskan cara menggunakan layanan dan API paket lama. API ini hanya dapat berjalan di runtime generasi pertama di lingkungan standar App Engine. Jika Anda mengupdate ke runtime App Engine Python 3, baca panduan migrasi guna mempelajari opsi migrasi untuk paket layanan lama.

Pola memcache

Memcache biasanya digunakan dengan pola berikut:

• Aplikasi menerima kueri dari pengguna atau aplikasi.
• Aplikasi memeriksa apakah data yang diperlukan untuk memenuhi kueri tersebut ada dalam memcache.
• Jika data berada dalam memcache, aplikasi menggunakan data tersebut.
• Jika data tidak berada dalam memcache, aplikasi akan melakukan kueri ke Datastore dan menyimpan hasilnya dalam memcache untuk permintaan mendatang.

Kode semu di bawah ini mewakili permintaan memcache yang umum:

def get_data():
    data = memcache.get('key')
    if data is not None:
        return data
    else:
        data = query_for_data()
        memcache.add('key', data, 60)
    return data

ndb secara internal menggunakan memcache untuk mempercepat kueri. Namun, jika ingin, Anda juga dapat menambahkan panggilan memcache secara eksplisit untuk mendapatkan kontrol lebih besar terkait percepatan.

Meng-cache data

Contoh berikut menunjukkan beberapa cara untuk menetapkan nilai dalam memcache menggunakan Python API.

# Add a value if it doesn't exist in the cache
# with a cache expiration of 1 hour.
memcache.add(key="weather_USA_98105", value="raining", time=3600)

# Set several values, overwriting any existing values for these keys.
memcache.set_multi(
    {"USA_98115": "cloudy", "USA_94105": "foggy", "USA_94043": "sunny"},
    key_prefix="weather_",
    time=3600
)

# Atomically increment an integer value.
memcache.set(key="counter", value=0)
memcache.incr("counter")
memcache.incr("counter")
memcache.incr("counter")

Untuk mempelajari metode add(), set_multi(), dan set() lebih lanjut, lihat dokumentasi memcache Python API.

Catatan: Modul pickle Python standar digunakan untuk secara otomatis melakukan pickle dan depickle otomatis pada data yang dipindahkan ke dalam dan keluar dari memcache.

Mengubah guestbook.py untuk menggunakan memcache

Aplikasi Guestbook membuat kueri Datastore pada setiap permintaan (melalui ndb, sehingga sudah mendapatkan beberapa kecepatan memcache). Anda dapat mengubah aplikasi Guestbook untuk menggunakan memcache secara eksplisit sebelum melakukan kueri ke Datastore.

Pertama, kita akan mengimpor modul memcache dan membuat metode yang memeriksa memcache sebelum menjalankan kueri.

def get_greetings(self, guestbook_name):
    """
    get_greetings()
    Checks the cache to see if there are cached greetings.
    If not, call render_greetings and set the cache

    Args:
      guestbook_name: Guestbook entity group key (string).

    Returns:
      A string of HTML containing greetings.
    """
    greetings = memcache.get('{}:greetings'.format(guestbook_name))
    if greetings is None:
        greetings = self.render_greetings(guestbook_name)
        try:
            added = memcache.add(
                '{}:greetings'.format(guestbook_name), greetings, 10)
            if not added:
                logging.error('Memcache set failed.')
        except ValueError:
            logging.error('Memcache set failed - data larger than 1MB')
    return greetings

Selanjutnya, kita akan memisahkan kueri dan pembuatan HTML untuk halaman tersebut. Jika tidak menemukan cache, kita akan memanggil metode ini untuk membuat kueri ke Datastore dan membuat string HTML yang akan kita simpan di memcache.

def render_greetings(self, guestbook_name):
    """
    render_greetings()
    Queries the database for greetings, iterate through the
    results and create the HTML.

    Args:
      guestbook_name: Guestbook entity group key (string).

    Returns:
      A string of HTML containing greetings
    """
    greetings = ndb.gql('SELECT * '
                        'FROM Greeting '
                        'WHERE ANCESTOR IS :1 '
                        'ORDER BY date DESC LIMIT 10',
                        guestbook_key(guestbook_name))
    output = cStringIO.StringIO()
    for greeting in greetings:
        if greeting.author:
            output.write('<b>{}</b> wrote:'.format(greeting.author))
        else:
            output.write('An anonymous person wrote:')
        output.write('<blockquote>{}</blockquote>'.format(
            cgi.escape(greeting.content)))
    return output.getvalue()

Terakhir, kita akan memperbarui pengendali MainPage untuk memanggil metode get_greetings() dan menampilkan beberapa statistik tentang berapa kali cache ditemukan atau terlewat.

import cgi
import cStringIO
import logging
import urllib

from google.appengine.api import memcache
from google.appengine.api import users
from google.appengine.ext import ndb

import webapp2


class Greeting(ndb.Model):
    """Models an individual Guestbook entry with author, content, and date."""
    author = ndb.StringProperty()
    content = ndb.StringProperty()
    date = ndb.DateTimeProperty(auto_now_add=True)


def guestbook_key(guestbook_name=None):
    """Constructs a Datastore key for a Guestbook entity with guestbook_name"""
    return ndb.Key('Guestbook', guestbook_name or 'default_guestbook')


class MainPage(webapp2.RequestHandler):
    def get(self):
        self.response.out.write('<html><body>')
        guestbook_name = self.request.get('guestbook_name')

        greetings = self.get_greetings(guestbook_name)
        stats = memcache.get_stats()

        self.response.write('<b>Cache Hits:{}</b><br>'.format(stats['hits']))
        self.response.write('<b>Cache Misses:{}</b><br><br>'.format(
                            stats['misses']))
        self.response.write(greetings)

        self.response.write("""
          <form action="/sign?{}" method="post">
            <div><textarea name="content" rows="3" cols="60"></textarea></div>
            <div><input type="submit" value="Sign Guestbook"></div>
          </form>
          <hr>
          <form>Guestbook name: <input value="{}" name="guestbook_name">
          <input type="submit" value="switch"></form>
        </body>
      </html>""".format(urllib.urlencode({'guestbook_name': guestbook_name}),
                        cgi.escape(guestbook_name)))

    def get_greetings(self, guestbook_name):
        """
        get_greetings()
        Checks the cache to see if there are cached greetings.
        If not, call render_greetings and set the cache

        Args:
          guestbook_name: Guestbook entity group key (string).

        Returns:
          A string of HTML containing greetings.
        """
        greetings = memcache.get('{}:greetings'.format(guestbook_name))
        if greetings is None:
            greetings = self.render_greetings(guestbook_name)
            try:
                added = memcache.add(
                    '{}:greetings'.format(guestbook_name), greetings, 10)
                if not added:
                    logging.error('Memcache set failed.')
            except ValueError:
                logging.error('Memcache set failed - data larger than 1MB')
        return greetings

    def render_greetings(self, guestbook_name):
        """
        render_greetings()
        Queries the database for greetings, iterate through the
        results and create the HTML.

        Args:
          guestbook_name: Guestbook entity group key (string).

        Returns:
          A string of HTML containing greetings
        """
        greetings = ndb.gql('SELECT * '
                            'FROM Greeting '
                            'WHERE ANCESTOR IS :1 '
                            'ORDER BY date DESC LIMIT 10',
                            guestbook_key(guestbook_name))
        output = cStringIO.StringIO()
        for greeting in greetings:
            if greeting.author:
                output.write('<b>{}</b> wrote:'.format(greeting.author))
            else:
                output.write('An anonymous person wrote:')
            output.write('<blockquote>{}</blockquote>'.format(
                cgi.escape(greeting.content)))
        return output.getvalue()


class Guestbook(webapp2.RequestHandler):
    def post(self):
        # We set the same parent key on the 'Greeting' to ensure each greeting
        # is in the same entity group. Queries across the single entity group
        # are strongly consistent. However, the write rate to a single entity
        # group is limited to ~1/second.
        guestbook_name = self.request.get('guestbook_name')
        greeting = Greeting(parent=guestbook_key(guestbook_name))

        if users.get_current_user():
            greeting.author = users.get_current_user().nickname()

        greeting.content = self.request.get('content')
        greeting.put()
        memcache.delete('{}:greetings'.format(guestbook_name))
        self.redirect('/?' +
                      urllib.urlencode({'guestbook_name': guestbook_name}))


app = webapp2.WSGIApplication([('/', MainPage),
                               ('/sign', Guestbook)],
                              debug=True)