Is é trádáil bhunúsach i láithreáin ghréasáin dinimiciúla, go maith, tá siad dinimiciúil. Gach uair a iarrann úsáideoir leathanach, déanann an freastalaí gréasáin gach cineál ríomhanna - ó cheisteanna bunachar sonraí go rindreáil teimpléad go loighic ghnó - chun an leathanach a fheiceann cuairteoir do shuíomh a chruthú. Tá sé seo i bhfad níos costasaí, ó pheirspictíocht las-phróiseála, ná do shocrú caighdeánach freastalaí freastalaí léamh comhad lasmuigh den chóras comhaid.
\nFor most web applications, this overhead isn't a big deal. Most web\napplications aren't washingtonpost.com or slashdot.org; they're\nsmall-to medium-sized sites with so-so traffic. But for medium- to high-traffic\nsites, it's essential to cut as much overhead as possible.
Sin an áit a dtagann caching isteach.
\nIs é rud éigin a thaisceadh ná toradh ríofa daor a shábháil ionas nach mbeidh ort an ríomh a dhéanamh an chéad uair eile. Seo roinnt pseudocode a mhíníonn conas a oibreodh sé seo le haghaidh leathanach gréasáin a ghintear go dinimiciúil:
\ngiven a URL, try finding that page in the cache\nif the page is in the cache:\n return the cached page\nelse:\n generate the page\n save the generated page in the cache (for next time)\n return the generated page\nTagann Django le córas taisce láidir a ligeann duit leathanaigh dhinimiciúla a shábháil ionas nach gá iad a ríomh do gach iarratas. Ar mhaithe le háisiúlacht, cuireann Django leibhéil éagsúla gráinneachta taisce ar fáil: Is féidir leat aschur radhairc ar leith a thaisceadh, ní féidir leat ach na píosaí atá deacair a tháirgeadh a thaisceadh, nó is féidir leat do shuíomh iomlán a thaisceadh.
\nOibríonn Django go maith freisin le taiscí “íossrutha”, mar shampla `Squid`< http://www.squid-cache.org/> _ agus taiscí brabhsálaí-bhunaithe. Is iad seo na cineálacha taiscí nach ndéanann tú rialú go díreach ach ar féidir leat leideanna a sholáthar dóibh (trí cheanntásca HTTP) faoi na codanna de do shuíomh ba chóir a stóráil, agus conas.
\n\nÉilíonn an córas taisce méid beag socraithe. Eadhon, caithfidh tú a insint dó cá háit ar chóir go gcónaíonn do shonraí taiscéadaithe - cibé acu i mbunachar sonraí, ar an gcóras comhaid nó go díreach i gcuimhne. Is cinneadh tábhachtach é seo a théann i bhfeidhm ar fheidhmíocht do taisce; sea, tá roinnt cineálacha taisce níos gasta ná a chéile.
\nTéann do rogha taisce sa socrú:setting: CACHES i do chomhad socruithe. Seo míniú ar na luachanna go léir atá ar fáil le haghaidh: socrú: CACHES.
\nIs freastalaí taisce go hiomlán bunaithe ar chuimhne é Memcached__, a forbraíodh ar dtús chun ualaí arda a láimhseáil ag LiveJournal.com agus foinse oscailte ina dhiaidh sin ag Danga Interactive. Úsáideann suíomhanna mar Facebook agus Wikipedia é chun rochtain ar bhunachar sonraí a laghdú agus feidhmíocht an láithreáin a mhéadú go mór.
\nRitheann Memcached mar démon agus leithdháiltear méid sonraithe RAM air. Níl le déanamh aige ach comhéadan tapa a sholáthar chun sonraí sa taisce a chur leis, a aisghabháil agus a scriosadh. Stóráiltear na sonraí go léir go díreach i gcuimhne, mar sin níl aon lasbhunachar sonraí nó úsáid chórais chomhad ann.
\nTar éis duit Memcached féin a shuiteáil, beidh ort ceangailt Memcached a shuiteáil. Tá roinnt ceangail Python Memcached ar fáil; is iad an dá cheann a thacaíonn Django: pypi: pylibmc agus:pypi: pymemcache.
\nChun Memcached a úsáid le Django:
\nSocraigh: Socrú: BACKEND `go ``Django.core.cache.backends.memcached.pymemcachecache`<CACHES-BACKEND> nó django.core.cache.backends.memcached.pylibmccache (ag brath ar an gceangailt memcached roghnaithe agat)
SOC:SET:SETING: LOCATION <CACHES-LOCATION>`go luachanna ``ip: port `, áit is é ip` seoladh IP an daemon Memcached agus port an calafort ar a bhfuil Memcached ag rith, nó go luach unix:path, áit is é path an cosán chuig comhad soicéad Memcached Unix.
Sa sampla seo, tá Memcached ag rith ar chalafort localhost (127.0.0.1) 11211, ag baint úsáide as an cheangailteach ``pymemcache`:
\nCACHES = {\n "default": {\n "BACKEND": "django.core.cache.backends.memcached.PyMemcacheCache",\n "LOCATION": "127.0.0.1:11211",\n }\n}\nSa sampla seo, tá Memcached ar fáil trí chomhad soicéad áitiúil Unix: file: /tmp/memcached.sock ag baint úsáide as an ceangailt pymemcache:
CACHES = {\n "default": {\n "BACKEND": "django.core.cache.backends.memcached.PyMemcacheCache",\n "LOCATION": "unix:/tmp/memcached.sock",\n }\n}\nGné den scoth amháin de Memcached is ea a chumas taisce a roinnt thar fhreastalaithe iolracha. Ciallaíonn sé seo gur féidir leat daemons Memcached a reáchtáil ar iliomad meaisíní, agus déileálfaidh an clár leis an ngrúpa meaisíní mar taisce* aonair*, gan gá luachanna taisce a dhúbailt ar gach meaisín. Ch <CACHES-LOCATION>un leas a bhaint as an ngné seo, cuir gach seoladh freastalaí san áireamh in:socrú: `LOCATION `, mar shreang teoranta leath-cholún nó camóg, nó mar liosta.
\nSa sampla seo, roinntear an taisce thar chásanna Memcached atá ag rith ar sheoladh IP 172.19.26.240 agus 172.19.26.242, araon ar chalafort 11211:
\nCACHES = {\n "default": {\n "BACKEND": "django.core.cache.backends.memcached.PyMemcacheCache",\n "LOCATION": [\n "172.19.26.240:11211",\n "172.19.26.242:11211",\n ],\n }\n}\nSa sampla seo a leanas, roinntear an taisce thar chásanna Memcached atá ag rith ar na seoltaí IP 172.19.26.240 (calafort 11211), 172.19.26.242 (calafort 11212), agus 172.19.26.244 (calafort 11213):
\nCACHES = {\n "default": {\n "BACKEND": "django.core.cache.backends.memcached.PyMemcacheCache",\n "LOCATION": [\n "172.19.26.240:11211",\n "172.19.26.242:11212",\n "172.19.26.244:11213",\n ],\n }\n}\n<CACHES-OPTIONS>De réir réamhshocraithe, socraíonn an cúltaca PymemCacheCache` na roghanna seo a leanas (is féidir leat iad a shárú i d:setting: `OPTIONS `):
\n"OPTIONS": {\n "allow_unicode_keys": True,\n "default_noreply": False,\n "serde": pymemcache.serde.pickle_serde,\n}\nPointe deiridh faoi Memcached ná go bhfuil míbhuntáiste ag taiscáil cuimhne bunaithe: toisc go stóráiltear na sonraí taisceáilte i gcuimhne, caillfear na sonraí má thimpíonn do fhreastalaí. Is léir nach bhfuil cuimhne beartaithe le haghaidh stórála sonraí buan, mar sin ná bí ag brath ar chaching cuimhne mar an t-aon stóráil sonraí atá agat. Gan amhras, níor cheart aon cheann de na cúltaca caching Django a úsáid le haghaidh stórála buan - tá sé beartaithe go léir a bheith ina réitigh le haghaidh taiscéála, ní stóráil - ach cuirimid é seo in iúl anseo toisc go bhfuil caching bunaithe ar chuimhne go háirithe sealadach.
\nIs bunachar sonraí in-chuimhne é Redis__ is féidir a úsáid le haghaidh taiscála. Chun tús a chur beidh freastalaí Redis ag teastáil uait ag rith go háitiúil nó ar mheaisín iargúlta.
\nTar éis duit an freastalaí Redis a bhunú, beidh ort ceangail Python a shuiteáil do Redis. :pypi: Is é `redis-py <redis>`an ceangailt a thacaíonn Django go dúchasach. <hiredis>Moltar an pacáiste: pypi: `hiredis-py `a shuiteáil freisin.
\nChun Redis a úsáid mar do chúltaca taisce le Django:
\n<CACHES-BACKEND>Socraigh: socrú: BACKEND `go ``Django.Core.Cache.Backends.Redis.RedisCache `.
Set LOCATION to the URL pointing to your Redis\ninstance, using the appropriate scheme. See the redis-py docs for\ndetails on the available schemes.
Mar shampla, má tá Redis ag rith ar chalafort localhost (127.0.0.1) 6379:
\nCACHES = {\n "default": {\n "BACKEND": "django.core.cache.backends.redis.RedisCache",\n "LOCATION": "redis://127.0.0.1:6379",\n }\n}\nIs minic a chosnaítear freastalaithe Redis le fíordheimhniú. D'fhonn ainm úsáideora agus pasfhocal a sholáthar, cuir iad sa SUÍOMH` mar aon leis an URL:
\nCACHES = {\n "default": {\n "BACKEND": "django.core.cache.backends.redis.RedisCache",\n "LOCATION": "redis://username:password@127.0.0.1:6379",\n }\n}\nMá tá iolracha freastalaithe Redis curtha ar bun agat sa mhodh macasamhail, is féidir leat na freastalaithe a shonrú mar shreang teoranta leath-cholún nó camóg, nó mar liosta. Agus freastalaithe iolracha á úsáid agat, déantar oibríochtaí scríofa ar an gcéad fhreastalaí (ceannaire) Déantar oibríochtaí léite ar na freastalaithe eile (macasamhail) a roghnaítear go randamach:
\nCACHES = {\n "default": {\n "BACKEND": "django.core.cache.backends.redis.RedisCache",\n "LOCATION": [\n "redis://127.0.0.1:6379", # leader\n "redis://127.0.0.1:6378", # read-replica 1\n "redis://127.0.0.1:6377", # read-replica 2\n ],\n }\n}\nIs féidir le Django a chuid sonraí taiscéadaithe a stóráil i do bhunachar sonraí. Oibríonn sé seo is fearr má tá freastalaí bunachar sonraí tapa, innéacsaithe go maith agat.
\nChun tábla bunachar sonraí a úsáid mar do chúltaca taisce:
\n<CACHES-BACKEND>Socraigh: socrú: BACKEND `go ``Django.core.cache.backends.db.databaseCache `
Socraigh: socrú: LOCATION <CACHES-LOCATION>`go ``tablename`, ainm an tábla bunachar sonraí. Is féidir leis an ainm seo a bheith cibé rud is mian leat, fad is ainm tábla bailí é nach bhfuil á úsáid cheana féin i do bhunachar sonraí.
Sa sampla seo, is é my_cache_table` ainm an tábla taisce:
\nCACHES = {\n "default": {\n "BACKEND": "django.core.cache.backends.db.DatabaseCache",\n "LOCATION": "my_cache_table",\n }\n}\nMurab ionann agus cúltaca taisce eile, ní thacaíonn taisce an bhunachar sonraí le cur isteach in éag go huathoibríoch ag leibhéal an bhunachar sonraí. Ina áit sin, déantar iontrálacha taisce in éag a scriosadh gach uair a thugtar add () ``, `set (), nó ``touch () ``.
Sula n-úsáidtear taisce an bunachar sonraí, ní mór duit an tábla taisce a chruthú leis an ordú seo:
\npython manage.py createcachetable\nCruthaíonn sé seo tábla i do bhunachar sonraí atá san fhormáid cheart a bhfuil súil ag córas taisce bunachar sonraí Django. <CACHES-LOCATION>Tógtar ainm an tábla ó:socrú: `SUÍOMH `.
\nMá tá iolracha bunachar sonraí á úsáid agat, cruthaíonn: djadmin: createcachetable tábla amháin do gach taisce.
\nMá tá bunachar sonraí iolracha á úsáid agat, breathnaíonn: djadmin: createcachetable modh `allow_migration () ``ar do ródairí bunachar sonraí (féach thíos).
\nMar shampla: Djadmin: migrate, :djadmin: ní dhéanfaidh createcachetable teagmháil le tábla atá ann cheana. Ní chruthóidh sé ach táblaí ar iarraidh.
\nChun an SQL a reáchtálfaí a phriontáil, seachas é a reáchtáil, bain úsáid as an roghna:option: createcachetable --dry-run.
\nMá úsáideann tú táscáil bunachar sonraí le bunachair sonraí iolracha, beidh ort treoracha ródaithe a chur ar bun do thábla taisce bunachar sonraí freisin. Chun críocha ródaithe, tá tábla taisce an bhunachar sonraí le feiceáil mar mhúnla darb ainm cacheentry`, i bhfeidhmchlár darb ainm ``django_cache. Ní bheidh an tsamhail seo le feiceáil i taisce na samhlacha, ach is féidir sonraí an tsamhail a úsáid chun críocha ródaithe.
Mar shampla, threoródh an ródaire seo a leanas gach oibríocht léite taisce chuig cache_replica, agus scríobhfadh gach oibríocht chuig cache_primary`. Ní dhéanfar an tábla taisce a shioncronú ach ar cache_primary`:
class CacheRouter:\n """A router to control all database cache operations"""\n\n def db_for_read(self, model, **hints):\n "All cache read operations go to the replica"\n if model._meta.app_label == "django_cache":\n return "cache_replica"\n return None\n\n def db_for_write(self, model, **hints):\n "All cache write operations go to primary"\n if model._meta.app_label == "django_cache":\n return "cache_primary"\n return None\n\n def allow_migrate(self, db, app_label, model_name=None, **hints):\n "Only install the cache model on primary"\n if app_label == "django_cache":\n return db == "cache_primary"\n return None\nMura sonraíonn tú treoracha ródaithe don tsamhail taisce bunachar sonraí, úsáidfidh an cúltaca taisce an bunachar sonraí réamhshocraithe.
Agus mura n-úsáideann tú cúltaca taisce an bhunachar sonraí, ní gá duit a bheith buartha faoi threoracha ródaithe a sholáthar don tsamhail taisce bunachar sonraí.
\nDéanann an cúltaca comhad-bhunaithe gach luach taisce a shraitheadh agus a stóráil mar chomhad ar leithligh. <CACHES-LOCATION>Chun an tacar cúltaca seo a úsáid: socrú: BACKEND `go ``<CACHES-BACKEND>"django.core.cache.backends.fileBasedCache"` agus:setting: LOCATION chuig eolaire oiriúnach. Mar shampla, chun sonraí taisceáilte a stóráil i /var/tmp/django_cache, bain úsáid as an socrú seo:
CACHES = {\n "default": {\n "BACKEND": "django.core.cache.backends.filebased.FileBasedCache",\n "LOCATION": "/var/tmp/django_cache",\n }\n}\nMá tá tú ar Windows, cuir an litir tiomána ag tús an chosáin, mar seo:
\nCACHES = {\n "default": {\n "BACKEND": "django.core.cache.backends.filebased.FileBasedCache",\n "LOCATION": "c:/foo/bar",\n }\n}\nBa chóir go mbeadh an cosán eolaire iomlán - is é sin, ba chóir go dtosódh sé ag fréamh do chóras comhaid. Is cuma an gcuireann tú slash ag deireadh an shocraithe.
\nDéan cinnte go bhfuil an eolaire a luaitear ag an socrú seo ann agus go bhfuil sé inléite agus inscríofa, nó gur féidir le húsáideoir an chórais faoina ritheann do fhreastalaí gréasáin é a chruthú. Ag leanúint leis an sampla thuas, má ritheann do fhreastalaí mar an úsáideoir apache, déan cinnte go bhfuil an eolaire /var/tmp/django_cache ann agus go bhfuil sé inléite agus inscríofa ag an úsáideoir apache, nó gur féidir leis an úsáideoir apache é a chruthú.
Is é seo an taisce réamhshocraithe mura sonraítear ceann eile i do chomhad socruithe. Más mian leat na buntáistí luais a bhaineann le caching in-chuimhne ach nach bhfuil an cumas agat Memcached a reáchtáil, smaoinigh ar an gcúltaca taisce cuimhne áitiúil. Tá an taisce seo in aghaidh an phróisis (féach thíos) agus sábháilte ó snáithe. <CACHES-BACKEND>Chun é a úsáid, socraí:setting: BACKEND `go `"django.core.cache.backends.locmem.locmemcache"``. Mar shampla:
\nCACHES = {\n "default": {\n "BACKEND": "django.core.cache.backends.locmem.LocMemCache",\n "LOCATION": "unique-snowflake",\n }\n}\nÚsáidtear an cache:setting: LOCATION <CACHES-LOCATION>`chun siopaí cuimhne aonair a aithint. Mura bhfuil ach taisce ``locmem` amháin agat, is féidir leat an:setting: `LOCATION `a fhágáil<CACHES-LOCATION>; áfach, má tá níos mó ná taisce cuimhne áitiúil amháin agat, beidh ort ainm a shannadh do cheann acu ar a laghad d'fhonn iad a choinneáil ar leithligh.
\nÚsáideann an taisce straitéis díothaithe is lú a úsáidtear le déanaí (LRU).
\nTabhair faoi deara go mbeidh a shampla taisce príobháideach féin ag gach próiseas, rud a chiallaíonn nach féidir aon chaching trasphróisis a dhéanamh. Ciallaíonn sé seo freisin nach bhfuil an taisce cuimhne áitiúil go háirithe éifeachtach ó chuimhne, mar sin is dócha nach rogha maith é do thimpeallachtaí táirgeachta. Tá sé go deas le haghaidh forbartha.
\nFaoi dheireadh, tagann Django le taisce “dummy” nach ndéanann taisce i ndáiríre - ní chuireann sé ach an comhéadan taisce i bhfeidhm gan aon rud a dhéanamh.
\nTá sé seo úsáideach má tá suíomh táirgeachta agat a úsáideann taiscáil tromshaothair in áiteanna éagsúla ach timpeallacht forbarta/tástála nach dteastaíonn uait taisce a dhéanamh agus nach dteastaíonn uait do chód a athrú go speisialta an dara ceann. <CACHES-BACKEND>Chun caching dummy a ghníomhachtú, socraí:setting: `BACKEND `mar sin:
\nCACHES = {\n "default": {\n "BACKEND": "django.core.cache.backends.dummy.DummyCache",\n }\n}\nCé go gcuimsíonn Django tacaíocht do roinnt cúltaca taisce lasmuigh den bhosca, uaireanta b'fhéidir gur mhaith leat cúltaca taisce saincheaptha a úsáid. Chun cúltaca taisce seachtrach a úsáid le Django, bain úsáid as an gcosán allmhairithe Python mar an:setting: BACKEND `den socrú: `CACHES<CACHES-BACKEND>, mar shampla:
\nCACHES = {\n "default": {\n "BACKEND": "path.to.backend",\n }\n}\nMá tá do chúlcheann féin á thógáil agat, is féidir leat na cúltaca caighdeánacha taisce a úsáid mar chur i bhfeidhm tagartha. Gheobhaidh tú an cód san eolaire: source: django/core/cache/backends/ foinse Django.
\nNóta: Gan cúis an-láidir, mar óstach nach dtacaíonn leo, ba chóir duit cloí leis na cúltaca taisce atá san áireamh le Django. Rinneadh tástáil mhaith orthu agus tá siad doiciméadaithe go maith.
\nIs féidir argóintí breise a thabhairt do gach cúltaca taisce chun iompar taisce a rialú. Cuirtear na hargóintí seo ar fáil mar eochracha breise sa socrú: socrú: CACHES. Is iad seo a leanas argóintí bailí:
\nTIMEOUT: The default timeout, in\nseconds, to use for the cache. This argument defaults to 300 seconds\n(5 minutes). You can set TIMEOUT to None so that, by default, cache\nkeys never expire. A value of 0 causes keys to immediately expire\n(effectively "don't cache").
OPTIONS: Any options that should be\npassed to the cache backend. The list of valid options will vary\nwith each backend, and cache backends backed by a third-party library\nwill pass their options directly to the underlying cache library.
Déanfaidh cúltaca taisce a chuireann a straitéis díothaithe féin i bhfeidhm (ie, na cúltaca locmem, córas comhad ``agus ``bunachar sonraí) onóir na roghanna seo a leanas:
MAX_ENTRIES: An líon uasta na n-iontrálacha a cheadaítear sa taisce sula scriostar seanluachanna. Tá an argóint seo réamhshocraithe go 300.
CULL_FREQUENCY: An codán na n-iontrálacha a dhíothaítear nuair a shroichtear MAX_ENTRIES. Is é an cóimheas iarbhír ná 1/CULL_FREQUENCY, mar sin socraigh CULL_FREQUENCY go 2 chun leath na n-iontrálacha a scriosadh nuair a shroichtear MAX_ENTRIES ``. Ba chóir go mbeadh an argóint seo ina shláimhir agus réamhshocraithe go ``3.
Ciallaíonn luach 0 do CULL_FREQUENCY` go ndéanfar an taisce iomlán a dumpáil nuair a shroichfear MAX_ENTRIES. Ar roinnt cúltaca (``bunachar sonraí ``go háirithe) déanann sé seo go gcaithfeach* i bhfad níos gasta ar chostas níos mó caitheamh taisce.
Cuireann cúltaca Memcached agus Redis ábhar: socrú: `OPTIONS <CACHES-OPTIONS>`mar argóintí eochairfhocal chuig tógálaí na gcliant, rud a cheadaíonn rialú níos airde ar iompar cliant. Mar shampla úsáid, féach thíos.
\nKEY_PREFIX: A string that will be\nautomatically included (prepended by default) to all cache keys\nused by the Django server.
Féach na:ref: `cáipéisíocht taiscéala <cache_key_prefixing>`le haghaidh tuilleadh faisnéise.
\nVERSION: The default version number\nfor cache keys generated by the Django server.
Féach na:ref: `cáipéisíocht taiscéala <cache_versioning>`le haghaidh tuilleadh faisnéise.
\nKEY_FUNCTION\nA string containing a dotted path to a function that defines how\nto compose a prefix, version and key into a final cache key.
Féach na:ref: `cáipéisíocht taiscéala <cache_key_transformation>`le haghaidh tuilleadh faisnéise.
\nSa sampla seo, tá cúltaca córas comhaid á chumrú le haon ama 60 soicind, agus cumas uasta 1000 mír:
\nCACHES = {\n "default": {\n "BACKEND": "django.core.cache.backends.filebased.FileBasedCache",\n "LOCATION": "/var/tmp/django_cache",\n "TIMEOUT": 60,\n "OPTIONS": {"MAX_ENTRIES": 1000},\n }\n}\nSeo cumraíocht shampla le haghaidh cúltaca bunaithe ar pylibmc a chumasaíonn an prótacal dénártha, fíordheimhniú SASL, agus an modh iompraíochta ketama:
\nCACHES = {\n "default": {\n "BACKEND": "django.core.cache.backends.memcached.PyLibMCCache",\n "LOCATION": "127.0.0.1:11211",\n "OPTIONS": {\n "binary": True,\n "username": "user",\n "password": "pass",\n "behaviors": {\n "ketama": True,\n },\n },\n }\n}\nSeo cumraíocht shamplach le haghaidh cúltaca bunaithe ar pymemcache a chuireann ar chumas comhdhlúthú cliant (a d'fhéadfadh feidhmíocht a fheabhsú trí chliaint a choinneáil ceangailte), déileálann sé le hearráidí memcache/líonra mar chailleann taisce, agus socraíonn an bratach TCP_NODELAY ar soicéad an nasc:
CACHES = {\n "default": {\n "BACKEND": "django.core.cache.backends.memcached.PyMemcacheCache",\n "LOCATION": "127.0.0.1:11211",\n "OPTIONS": {\n "no_delay": True,\n "ignore_exc": True,\n "max_pool_size": 4,\n "use_pooling": True,\n },\n }\n}\nSeo cumraíocht shampla le haghaidh cúltaca bunaithe ar redis a roghnaíonn bunachar sonraí `10 (de réir réamhshocraithe loingíonn Redis le 16 bhunachar sonraí loighciúla), agus a leagann saincheaptha rang linn nasc (Redis.connectionPool úsáidtear de réir réamhshocraithe):
CACHES = {\n "default": {\n "BACKEND": "django.core.cache.backends.redis.RedisCache",\n "LOCATION": "redis://127.0.0.1:6379",\n "OPTIONS": {\n "db": "10",\n "pool_class": "redis.BlockingConnectionPool",\n },\n }\n}\nNuair a bheidh an taisce curtha ar bun, is é an bealach is simplí chun caching a úsáid ná do shuíomh iomlán a thaisceadh. Beidh ort ``django.middleware.cache.UpdateCacheMiddleware'` agus ``django.middleware.cache.fetchfromCacheMiddleware'` a chur le do shuíomh: MIDDLEWARE, mar atá sa sampla seo:
\nMIDDLEWARE = [\n "django.middleware.cache.UpdateCacheMiddleware",\n "django.middleware.common.CommonMiddleware",\n "django.middleware.cache.FetchFromCacheMiddleware",\n]\nAnsin, cuir na socruithe riachtanacha seo a leanas le do chomhad socruithe Django:
\nCACHE_MIDDLEWARE_ALIAS -- The cache alias to use for storage.
CACHE_MIDDLEWARE_SECONDS -- The integer number of seconds each\npage should be cached.
CACHE_MIDDLEWARE_KEY_PREFIX -- If the cache is shared across\nmultiple sites using the same Django installation, set this to the name of\nthe site, or some other string that is unique to this Django instance, to\nprevent key collisions. Use an empty string if you don't care.
Tugann Fetchfromcachemiddleware freagraí GET agus HEAD le stádas 200, nuair a cheadaíonn na ceannteidil iarratais agus freagartha. Meastar gur leathanaigh uathúla iad freagraí ar iarratais ar an URL céanna le paraiméadair cheisteanna éagsúla agus cuirtear iad a chosc ar leithligh Tá an middleware seo ag súil go bhfreagraítear iarratas HEAD leis na ceannteidil freagartha céanna leis an iarratas GET comhfhreagrach; sa chás sin féadfaidh sé freagra GET a chosaithe ar iarratas HEAD a thabhairt ar ais.
<downstream-caches>Ina theannta sin, socraíonn UpdateCacheMiddleware cúpla ceannteideal go huathoibríoch i ngach:class: ~django.http.httpResponse a théann i bhfeidh:ref: `caches downstream `:
Socraíonn an ceannteideal Expires go dtí an dáta/am reatha móide an sainmhínithe:setting: CACHE_MIDDLEWARE_SECONDS.
Socraíonn sé an ceanntásc Cache-Control chun aoise uasta a thabhairt don leathanach -- arís, ón socrú:setting: CACHE_MIDDLEWARE_SECONDS.
Féach: doc: /topics/http/middleware le haghaidh tuilleadh ar middleware.
\nMá shocraíonn amharc a chuid ama éaga taisce féin (ie tá rannán max-aos aige ina cheanntásc Cache-Control) ansin déanfar an leathanach a stóráil go dtí an t-am éaga, seach:setting: CACHE_MIDDLEWARE_SECONDS. Ag baint úsáide as na maisitheoirí i django.views.decorators.cache` is féidir leat am éaga amharc a shocrú go héasca (ag baint úsáide as:func: ~django.views.decorators.cache.cache_control decorator) nó díchumasú a chaching le haghaidh amharc (ag baint úsáide as an: func: ~django.decorators.cache.neverator _cache). Féach an chuid `ceannteidil eile a úsáid `__ le haghaidh tuilleadh eolais faoi na maisitheoirí seo.
<language code>Más rud é: Socrú: USE_I18N socraithe go True ansin beidh ainm an ghníomhaí:term: language `san eochair taisce a ghintear san eochair taisce ginte -- féach freis:ref: `how django-discovers-language-preference). Ligeann sé seo duit suíomhanna ilteangacha a thaisceadh go héasca gan an eochair taisce a chruthú tú féin.
Cuimsíonn eochracha taisce an: ref: crios ama reatha `nuai:setting: `USE <default-current-time-zone>_TZ socraithe go True.
Bealach níos gráinneach chun an creat taiscéála a úsáid ná aschur tuairimí aonair a chaitheamh. Sainmhíníonn django.views.decorators.cache maisitheoir cache_page a thaisceoidh freagra an amharc duit go huathoibríoch:
from django.views.decorators.cache import cache_page\n\n\n@cache_page(60 * 15)\ndef my_view(request): ...\nTógann cache_page argóint amháin: an t-am taisce, i soicindí. Sa sampla thuas, déanfar toradh an radharc my_view () `a stóráil ar feadh 15 nóiméad. (Tabhair faoi deara go bhfuil sé scríofa againn mar `60* 15 chun críche inléiteachta. Meastófar 60* 15 go 900` - is é sin, 15 nóiméad iolraithe le 60 soicind in aghaidh an nóiméid.)
Tá tosaíocht ag an am taisce atá leagtha síos ag cache_page` thar an treoir max-aois ``ón gceannteideal ``Cache-Control.
Cuirtear an taisce in aghaidh an amharc, cosúil leis an taisce in aghaidh an láithreáin, as an URL. Má thaispeánann URLanna iolracha ar an radharc céanna, déanfar gach URL a stóráil ar leithligh. Ag leanúint leis an sampla my_view, má tá cuma seo ar do URLConf:
urlpatterns = [\n path("foo/<int:code>/", my_view),\n]\nansin cuirfear iarratais ar /foo/1/ agus /foo/23/ a chosc ar leithligh, mar a d'fhéadfá a bheith ag súil leis. Ach nuair a iarrtar URL áirithe (m.sh., /foo/23/), úsáidfidh iarratais ina dhiaidh sin chuig an URL sin an taisce.
Is féidir le cache_page argóint eochairfhocal roghnach a ghlacadh freisin, cache`, a threoraíonn don mhaisitheoir taisce ar leith a úsáid (ó do shuíomh: SETING: `CACHES) agus torthaí amharc á chaitheamh agat. De réir réamhshocraithe, úsáidfear an taisce default, ach is féidir leat aon taisce a theastaíonn uait a shonrú:
@cache_page(60 * 15, cache="special_cache")\ndef my_view(request): ...\nYou can also override the cache prefix on a per-view basis. cache_page\ntakes an optional keyword argument, key_prefix,\nwhich works in the same way as the CACHE_MIDDLEWARE_KEY_PREFIX\nsetting for the middleware. It can be used like this:
@cache_page(60 * 15, key_prefix="site1")\ndef my_view(request): ...\nIs féidir na hargóintí key_prefix agus cache a shonrú le chéile. <CACHES-KEY_PREFIX>Déanfar an argóint key_prefix agus an:setting: KEY_PREFIX a shonraítear fao:setting: CACHES a chomhcheangal.
<downstream-caches>Ina theannta sin, socraíonn cache_page ceannteidil Cache-Control agus Expires go huathoibríoch sa fhreagra a théann i bhfeidh:ref: `caches downstream `.
The examples in the previous section have hardcoded the fact that the view is\ncached, because cache_page alters the my_view function in place. This\napproach couples your view to the cache system, which is not ideal for several\nreasons. For instance, you might want to reuse the view functions on another,\ncache-less site, or you might want to distribute the views to people who might\nwant to use them without being cached. The solution to these problems is to\nspecify the per-view cache in the URLconf rather than next to the view\nfunctions themselves.
Is féidir leat é sin a dhéanamh tríd an bhfeidhm amharc a fhilleadh le cache_page` nuair a thagann tú tagairt dó sa URLConf. Seo an sean-URLConf ó níos luaithe:
\nurlpatterns = [\n path("foo/<int:code>/", my_view),\n]\nSeo an rud céanna, le my_view fillte i cache_page:
from django.views.decorators.cache import cache_page\n\nurlpatterns = [\n path("foo/<int:code>/", cache_page(60 * 15)(my_view)),\n]\nMá tá tú tar éis níos mó smachta fós, is féidir leat blúirí teimpléad a thaiscáil ag baint úsáide as an gclib teimpléad cache`. Chun rochtain a thabhairt do do theimpléad ar an gclib seo, cuir ``{% load cache%} in aice le barr do theimpléad.
Cuireann an chlib teimpléid {% cache%} ábhar an bhloc a chosc ar feadh méid áirithe ama. Tógann sé dhá argóint ar a laghad: an t-am taisce, i soicindí, agus an t-ainm chun an blúire taisce a thabhairt. Déantar an blúire a stóráil go deo má tá an t-am amach ``None ``. Glacfar an t-ainm mar atá, ná húsáid athróg. Mar shampla:
{% load cache %}\n{% cache 500 sidebar %}\n .. sidebar ..\n{% endcache %}\nUaireanta b'fhéidir gur mhaith leat cóipeanna iolracha de bhrúin a thaisceadh ag brath ar roinnt sonraí dinimiciúla atá le feiceáil taobh Mar shampla, b'fhéidir gur mhaith leat cóip taiscéadaithe ar leithligh den taobh barra a úsáideadh sa sampla roimhe seo do gach úsáideoir de do shuíomh. Déan é seo trí argóint bhreise amháin nó níos mó, a d'fhéadfadh a bheith ina athróga le scagairí nó gan scagairí, a chur chuig an gclib teimpléid ``{% cache%} `chun an blúir taisce a aithint go uathúil:
\n{% load cache %}\n{% cache 500 sidebar request.user.username %}\n .. sidebar for logged-in user ..\n{% endcache %}\n<i18n-cache-key>Má tá: SETTING: USE_I18N socraithe go True, beidh taisce meán-earraí in aghaidh an láithreáin: ref: meas a thabhairt don teanga ghníomhach. <template-translation-vars>Maidir leis an gclib teimpléad cache d'fhéadfá ceann de na hathróga:ref: `aistriúcháin-shonracha `atá ar fáil i dteimpléid a úsáid chun an toradh céanna a bhaint amach:
{% load i18n %}\n{% load cache %}\n\n{% get_current_language as LANGUAGE_CODE %}\n\n{% cache 600 welcome LANGUAGE_CODE %}\n {% translate "Welcome to example.com" %}\n{% endcache %}\nIs féidir leis an t-am taisce a bheith ina athróg teimpléad, chomh fada agus a réitíonn an t-athróg teimpléad ar luach slámhshláir. Mar shampla, má tá an t-athróg teimpléad my_timeout socraithe go luach 600, ansin tá an dá shampla seo a leanas coibhéiseach:
{% cache 600 sidebar %} ... {% endcache %}\n{% cache my_timeout sidebar %} ... {% endcache %}\nTá an ghné seo úsáideach chun athdhéanamh i dteimpléid a sheachaint. Is féidir leat an t-am a shocrú in athróg, in aon áit amháin, agus an luach sin a athúsáid.
\nDe réir réamhshocraithe, déanfaidh an clib taisce iarracht an taisce ar a dtugtar “template_fragments” a úsáid. Mura bhfuil taisce den sórt sin ann, tiocfaidh sé ar ais chun an taisce réamhshocraithe a úsáid. Féadfaidh tú cúltaca taisce malartach a roghnú le húsáid leis an argóint eochairfhocal ``úsáid ``, nach mór gurb é an argóint deireanach don chlib.
\n{% cache 300 local-thing ... using="localcache" %}\nMeastar gur earráid é ainm taisce nach bhfuil cumraithe a shonrú.
\nIf you want to obtain the cache key used for a cached fragment, you can use\nmake_template_fragment_key. fragment_name is the same as the second\nargument to the cache template tag; vary_on is a list of all additional\narguments passed to the tag. This function can be useful for invalidating or\noverwriting a cached item, for example:
>>> from django.core.cache import cache\n>>> from django.core.cache.utils import make_template_fragment_key\n# cache key for {% cache 500 sidebar username %}\n>>> key = make_template_fragment_key("sidebar", [username])\n>>> cache.delete(key) # invalidates cached template fragment\nTrue\nUaireanta, ní ghnóthaíonn sé go mór duit a chaitheamh ar leathanach iomlán rindreáilte agus bíonn sé, i ndáiríre, ró-dhochaoithiúil.
\nB'fhéidir, mar shampla, tá radharc ar do shuíomh ag brath a thorthaí ar roinnt ceisteanna daor, a n-athraíonn a dtorthaí ag eatraimh éagsúla. Sa chás seo, ní bheadh sé oiriúnach an taisce leathanaigh lán-leathanaigh a thairgeann na straitéisí taisce in aghaidh an láithreáin nó in aghaidh an amharc a úsáid, toisc nach mbeadh tú ag iarraidh an toradh iomlán a thaisceadh (ós rud é go n-athraíonn cuid de na sonraí go minic), ach ba mhaith leat fós na torthaí a athraíonn.
\nFor cases like this, Django exposes a low-level cache API. You can use this API\nto store objects in the cache with any level of granularity you like. You can\ncache any Python object that can be pickled safely: strings, dictionaries,\nlists of model objects, and so forth. (Most common Python objects can be\npickled; refer to the Python documentation for more information\nabout pickling.)
Is féidir leat rochtain a fháil ar na táscáin atá cumraithe sa socrú:: CACHES trí réad cosúil le dict: django.core.cache.caches. Tabharfaidh iarratais arís agus arís eile ar an alias céanna sa snáithe céanna ar ais an réad céanna.
>>> from django.core.cache import caches\n>>> cache1 = caches["myalias"]\n>>> cache2 = caches["myalias"]\n>>> cache1 is cache2\nTrue\nMura bhfuil an eochair ainmnithe ann, ardófar InvalidCacheBackendError.
Chun sábháilteacht snáithe a sholáthar, cuirfear sampla difriúil den chúltaca taisce ar ais do gach snáithe.
\nMar aicearra, tá an taisce réamhshocraithe ar fáil mar django.core.cache.cache:
>>> from django.core.cache import cache\nTá an réad seo comhionann le ``caches ['réamhshocraithe'] ``.
\nIs é an comhéadan bunúsach:
\n>>> cache.set("my_key", "hello, world!", 30)\n>>> cache.get("my_key")\n'hello, world!'\nBa chóir go mbeadh eochair ina str`, agus is féidir luach a bheith ina aon rud Python inpictilte.
Tá an argóint timeout roghnach agus réamhshocraíonn sé ar an argóint timeout den chúltaca cuí sa socrúit:setting: CACHES (mínithe thuas). Is é líon na soicind ba chóir an luach a stóráil sa taisce. Ag dul isteach None le haghaidh timeout, beidh an luach a thaisceadh go deo. Ní dhéanfaidh timeout de 0 a thaisceadh an luach.
Mura bhfuil an réad ann sa taisce, filleann cache.get () ````None:
>>> # Wait 30 seconds for 'my_key' to expire...\n>>> cache.get("my_key")\nNone\nMás gá duit a chinneadh an bhfuil an réad sa taisce agus go bhfuil luach litriúil “None” stóráilte agat, bain úsáid as réad sentinel mar réamhshocraithe:
\n>>> sentinel = object()\n>>> cache.get("my_key", sentinel) is sentinel\nFalse\n>>> # Wait 30 seconds for 'my_key' to expire...\n>>> cache.get("my_key", sentinel) is sentinel\nTrue\nIs féidir le cache.get () ``argóint ``default a ghlacadh. Sonraíonn sé seo cén luach atá le filleadh mura bhfuil an réad ann sa taisce:
>>> cache.get("my_key", "has expired")\n'has expired'\nChun eochair a chur leis ach amháin mura bhfuil sé ann cheana féin, bain úsáid as an modh ``add () ``. Tógann sé na paraiméadair chéanna le ``set () ``, ach ní dhéanfaidh sé iarracht an taisce a nuashonrú má tá an eochair a shonraítear i láthair cheana féin:
\n>>> cache.set("add_key", "Initial value")\n>>> cache.add("add_key", "New value")\n>>> cache.get("add_key")\n'Initial value'\nMás gá duit fios a bheith agat an stóráil add () ``luach sa taisce, is féidir leat an luach tuairisceáin a sheiceáil. Tabharfaidh sé ar ais ``True má stóráilíodh an luach, False ar shlí eile.
Más mian leat luach eochair a fháil nó luach a shocrú mura bhfuil an eochair sa taisce, tá an modh ``get_or_set () `ann. Tógann sé na paraiméadair chéanna le ``get () ``ach socraítear an réamhshocrú mar an luach taisce nua don eochair sin, seachas a thabhairt ar ais:
\n>>> cache.get("my_new_key") # returns None\n>>> cache.get_or_set("my_new_key", "my new value", 100)\n'my new value'\nIs féidir leat aon ghlaoch a chur ar aghaidh mar luach*réamhshocraithe*:
\n>>> import datetime\n>>> cache.get_or_set("some-timestamp-key", datetime.datetime.now)\ndatetime.datetime(2014, 12, 11, 0, 15, 49, 457920)\nTá comhéadan ``get_many () ``ann freisin nach mbuaileann an taisce ach uair amháin. Tugann ``get_many () ``foclóir ar ais leis na heochracha go léir a d'iarr tú orthu atá ann i ndáiríre sa taisce (agus níor éag):
\n>>> cache.set("a", 1)\n>>> cache.set("b", 2)\n>>> cache.set("c", 3)\n>>> cache.get_many(["a", "b", "c"])\n{'a': 1, 'b': 2, 'c': 3}\nChun luachanna iolracha a shocrú níos éifeachtaí, bain úsáid as ``set_many () ``chun foclóir péirí eochairluacha a rith:
\n>>> cache.set_many({"a": 1, "b": 2, "c": 3})\n>>> cache.get_many(["a", "b", "c"])\n{'a': 1, 'b': 2, 'c': 3}\nCosúil le cache.set () ``, glacann ``set_many () paraiméadar roghnach timeout.
Ar chúltaca tacaithe (memcached), filleann ``set_many () ``liosta eochracha ar theip orthu a chur isteach.
\nIs féidir leat eochracha a scriosadh go sainráite le ``delete () ``chun an taisce do réad áirithe a ghlanadh:
\n>>> cache.delete("a")\nTrue\nTugann delete () ``filleadh ``True má scriosadh an eochair go rathúil, False ar shlí eile.
Más mian leat dornán eochracha a ghlanadh ag an am céanna, is féidir le ``delete_many () ``liosta eochracha atá le glanadh a ghlanadh:
\n>>> cache.delete_many(["a", "b", "c"])\nFinally, if you want to delete all the keys in the cache, use\ncache.clear(). Be careful with this; clear() will remove everything\nfrom the cache, not just the keys set by your application:
>>> cache.clear()\nSocraíonn ``cache.touch () ``éag nua le haghaidh eochair. Mar shampla, chun eochair a nuashonrú chun dul in éag 10 soicind as seo:
\n>>> cache.touch("a", 10)\nTrue\nCosúil le modhanna eile, tá an argóint timeout roghnach agus réamhshocraíonn sé ar an rogha TIMEOUT den chúltaca cuí sa socrúit:setting: CACHES.
Filleann touch () ```True má rinneadh teagmháil leis an eochair go rathúil, False ar shlí eile.
Is féidir leat eochair atá ann cheana féin a mhéadú nó a laghdú ag baint úsáide as na modhanna incr () ``nó `decr (), faoi seach. De réir réamhshocraithe, déanfar an luach taisce atá ann cheana a mhéadú nó a laghdú faoi 1. Is féidir luachanna fáis/laghdaithe eile a shonrú trí argóint a sholáthar don ghlao fáis/laghdaithe. Ardófar ValueError má dhéanann tú iarracht eochair taisce nach bhfuil ann a mhéadú nó a laghdú:
>>> cache.set("num", 1)\n>>> cache.incr("num")\n2\n>>> cache.incr("num", 10)\n12\n>>> cache.decr("num")\n11\n>>> cache.decr("num", 5)\n6\nIs féidir leat an nasc le do taisce a dhúnadh le ``close () ``má chuireann an cúltaca taisce i bhfeidhm.
\n>>> cache.close()\nMá tá sampla taisce á roinnt agat idir freastalaithe, nó idir do thimpeallachtaí táirgeachta agus forbartha, is féidir go n-úsáidfidh freastalaí eile sonraí a chuimsíonn freastalaí amháin. Má tá formáid na sonraí taisceáilte difriúil idir freastalaithe, d'fhéadfadh fadhbanna an-deacair a dhiagnóisiú a bheith mar thoradh air seo.
\nChun é seo a chosc, soláthraíonn Django an cumas na heochracha taisce go léir a úsáideann freastalaí a réamhú <CACHES-KEY_PREFIX>Nuair a shábháiltear eochair taisce áirithe nó a aisghabháil, déanfaidh Django réamh-eochair an taisce go huathoibríoch le luach an socrú taisce: socrú: KEY_PREFIX.
\nTrí chinntiú go bhfuil difri:setting: `KEY_PREFIX <CACHES-KEY_PREFIX>`ag gach cás Django, is féidir leat a chinntiú nach mbeidh aon imbhuailtí i luachanna taisce.
\nNuair a athraíonn tú cód reatha a úsáideann luachanna taiscthe, b'fhéidir go mbeidh ort aon luachanna taiscéadaithe atá ann cheana a ghlanadh. Is é an bealach is éasca le seo a dhéanamh ná an taisce iomlán a shruthlú, ach d'fhéadfadh sé seo go gcaillfear luachanna taisce atá fós bailí agus úsáideach.
\nSoláthraíonn Django bealach níos fearr chun luachanna taisce aonair a dhíriú. <CACHES-VERSION>Tá aitheantóir leagan ar fud an chórais ag creat taisce Django, sonraithe ag baint úsáide as an socrú taisce: leagan: VERSION. Déantar luach an socraithe seo a chomhcheangal go huathoibríoch leis an réimír taisce agus leis an eochair taisce a sholáthraíonn an úsáideoir chun an eochair taisce de
\nDe réir réamhshocraithe, áireofar leagan eochair taisce réamhshocraithe an láithreáin go huathoibríoch Mar sin féin, tá argóint ``leagan ``sa fheidhmeanna taisce príomha uile, ionas gur féidir leat eochrleagan taisce áirithe a shonrú le socrú nó a fháil. Mar shampla:
\n>>> # Set version 2 of a cache key\n>>> cache.set("my_key", "hello world!", version=2)\n>>> # Get the default version (assuming version=1)\n>>> cache.get("my_key")\nNone\n>>> # Get version 2 of the same key\n>>> cache.get("my_key", version=2)\n'hello world!'\nIs féidir leagan eochair shonrach a mhéadú agus a shocrú ag baint úsáide as na modhanna incr_version () ``agus `decr_version (). Cuireann sé seo ar chumas eochracha ar leith a chur chuig leagan nua, rud a fhágann gan tionchar ar eochracha eile. Leanúint lenár sampla roimhe seo:
>>> # Increment the version of 'my_key'\n>>> cache.incr_version("my_key")\n>>> # The default version still isn't available\n>>> cache.get("my_key")\nNone\n# Version 2 isn't available, either\n>>> cache.get("my_key", version=2)\nNone\n>>> # But version 3 *is* available\n>>> cache.get("my_key", version=3)\n'hello world!'\nMar a thuairiscítear sa dá chuid roimhe seo, ní úsáidtear an eochair taisce a sholáthraíonn úsáideoir focal focal - déantar é a chomhcheangal leis an réimír taisce agus an leagan eochair chun eochair taisce deiridh a sholáthar. De réir réamhshocraithe, ceanglaítear na trí chuid ag baint úsáide as colons chun sreang deiridh a tháirgeadh:
\ndef make_key(key, key_prefix, version):\n return "%s:%s:%s" % (key_prefix, version, key)\nMás mian leat na codanna a chur le chéile ar bhealaí éagsúla, nó próiseáil eile a chur i bhfeidhm ar an eochair dheiridh (m.sh., díleá hash de na príomhchodanna a thógáil), is féidir leat eochairfheidhm saincheaptha a sholáthar.
\nSonraíonn an socrú taisce: `KEY_FUNCTION <CACHES-KEY_FUNCTION>`cosán poncair chuig feidhm a mheaitseann le fréamhshamhail ``make_key () ``thuas. Má chuirtear ar fáil, úsáidfear an eochrfheidhm saincheaptha seo in ionad na feidhme comhcheangailte eochair réamhshocrai
\nNí cheadaíonn Memcached, an cúltaca taisce táirgeachta is coitianta a úsáidtear, eochracha taisce níos faide ná 250 carachtar nó ina bhfuil spás bán nó carachtair rialaithe, agus beidh eisceacht ina chúis le heochracha den sórt sin a úsáid. Chun cód taisce iniompartha a spreagadh agus iontas míthaitneamhach a íoslaghdú, eisíonn na cúltaca taisce ionsuite eile rabhadh (django.core.cache.backends.base.cachekeyWarning) má úsáidtear eochair a chuirfeadh earráid ar memcached.
Má tá cúltaca táirgeachta á úsáid agat ar féidir leat glacadh le raon níos leithne eochracha (cúltaca saincheaptha, nó ceann de na cúltaca neamh-mheasta), agus gur mhaith leat an raon níos leithne seo a úsáid gan rabhaidh, is féidir leat CachekeyWarning` a thostú leis an gcód seo sa mhodúl bainistí` de cheann de do:
\nimport warnings\n\nfrom django.core.cache import CacheKeyWarning\n\nwarnings.simplefilter("ignore", CacheKeyWarning)\nMás mian leat loighic bailíochtaithe eochair saincheaptha a sholáthar ina ionad sin do cheann de na cúltaca ionsuite, is féidir leat é a fho-aicmiú, díreach an modh validate_key a shárú, agus na treoracha chun cúltaca taisce saincheaptha a úsáid `_ a leanúint. Mar shampla, chun é seo a dhéanamh don chúltaca ``locmem`, cuir an cód seo i modúl:
\nfrom django.core.cache.backends.locmem import LocMemCache\n\n\nclass CustomLocMemCache(LocMemCache):\n def validate_key(self, key):\n """Custom validation, raising exceptions or warnings as needed."""\n ...\n... agus bain úsáid as an gcosán poncaigh Python chuig an rang seo sa chuid: setting: BACKEND `de do shuíomh: <CACHES-BACKEND>CACHES`.
\nTá tacaíocht ag forbairt ag Django do chúltaca taisce asincrónacha, ach ní thacaíonn sé le caching asincrónach fós. Beidh sé ag teacht i scaoileadh amach anseo.
\n<cache-basic-interface>Tá leaganacha async ag django.core.cache.backends.base.baseCache de:ref: gach modh bonn `. De réir choinbhinsiúin, tá na leaganacha asincrónacha de na modhanna go léir réamhshocraithe le `a `. De réir réamhshocraithe, tá na hargóintí don dá leagan mar an gcéanna:
>>> await cache.aset("num", 1)\n>>> await cache.ahas_key("num")\nTrue\nGo dtí seo, dhírigh an doiciméad seo ar do shonraí* díniú* a chaitheamh. Ach tá cineál eile caighdeáin ábhartha d'fhorbairt gréasáin freisin: caistriú arna ndéanamh ag taiscí “downstream”. Is córais iad seo a dhéanann taisce leathanaigh d'úsáideoirí fiú sula sroicheann an t-iarratas do shuíomh Gréasáin.
\nSeo cúpla sampla de chaches iarshrutha:
\nAgus HTTP á úsáid agat, féadfaidh do: abbr: ISP (Soláthraí Seirbhíse Idirlín) `leathanaigh áirithe a thaisceadh, mar sin má d'iarr tú leathanach ó ``http://example.com/`, chuirfeadh do ISP an leathanach chugat gan rochtain a fháil go díreach ar example.com. Níl aon eolas ag cothabhálaí example.com ar an gcaistriú seo; suíonn an ISP idir example.com agus do bhrabhsálaí gréasáin, ag láimhseáil an caistriú go léir go trédhearcach. Ní féidir a chaiteáil den sórt sin indéanta faoi HTTPS toisc gur ionsaí fear sa lár a bheadh ann.
D'fhéadfadh go mbeadh do shuíomh Gréasáin Django taobh thiar de*cache* seachfhreastalaí*, mar shampla Squid Web Proxy Cache (http://www.squid-cache.org/), a choscann leathanaigh le haghaidh feidhmíochta. Sa chás seo, déanfadh an seachfhreastalaí gach iarratas a láimhseáil ar dtús, agus ní chuirfeadh sé chuig d'iarratas ach amháin más gá.
Coscann do bhrabhsálaí gréasáin leathanaigh, freisin. Má sheolann leathanach gréasáin na ceanntála cuí amach, úsáidfidh do bhrabhsálaí an chóip thaisceáilte áitiúil le haghaidh iarratais ina dhiaidh sin chuig an leathanach sin, gan teagmháil a dhéanamh leis an leathanach gréasáin arís chun a fheiceáil an bhfuil athrú aige.
Is borradh deas éifeachtúlachta é an chaching anuas, ach tá contúirt ann dó: Tá difríocht idir ábhar go leor leathanaigh ghréasáin bunaithe ar fhíordheimhniú agus go leor athróg eile, agus d'fhéadfadh córais taisce a shábháil leathanaigh atá bunaithe go dall ar URLanna sonraí míchearta nó íogair a nochtadh do chuairteoirí ina dhiaidh sin ar na leathanaigh sin.
\nFor example, if you operate a web email system, then the contents of the\n"inbox" page depend on which user is logged in. If an ISP blindly cached your\nsite, then the first user who logged in through that ISP would have their\nuser-specific inbox page cached for subsequent visitors to the site. That's\nnot cool.
\nAr ámharaí an tsaoil, soláthraíonn HTTP réiteach don fhadhb seo. Tá roinnt ceanntásca HTTP ann chun treoir a thabhairt do chaches iarshrutha a n-ábhar taisce a dhifriú ag brath ar athróga ainmnithe, agus chun meicníochtaí taiscéála a insint gan leathanaigh áirithe a thaisceadh. Breathnóimid ar chuid de na ceanntásca seo sna codanna a leanann.
\nVaryLink to this heading#Sainmhíníonn an ceannteideal Vary cén ceannteideal iarratais ba chóir do mheicníocht taisce a chur san áireamh agus a eochair taisce á thógáil. Mar shampla, má bhraitheann ábhar leathanaigh ghréasáin ar rogha teanga úsáideora, deirtear go n-athraíonn an leathanach ar an teanga.
\nDe réir réamhshocraithe, cruthaíonn córas taisce Django a heochracha taisce ag baint úsáide as an URL láncháilithe a iarrtar - m.sh., ” https://www.example.com/stories/2005/?order_by=author “. Ciallaíonn sé seo go n-úsáidfidh gach iarratas ar an URL sin an leagan taisceáilte céanna, beag beann ar dhifríochtaí gníomhaire úsáideora amhail fianáin nó roghanna teanga. Mar sin féin, má tháirgeann an leathanach seo ábhar éagsúil bunaithe ar dhifríocht éigin i gceanntásca iarratais - mar shampla fianán, nó teanga, nó gníomhaire úsáideora - beidh ort an ceannteideal Vary a úsáid chun meicníochtaí caching a insint go mbraitheann aschur an leathanaigh ar na rudaí sin.
Chun é seo a dhéanamh i Django, bain úsáid as an maisitheoir amharc áisiú:func: django.views.decorators.vary.vary_on_headers, mar sin:
\nfrom django.views.decorators.vary import vary_on_headers\n\n\n@vary_on_headers("User-Agent")\ndef my_view(request): ...\nSa chás seo, déanfaidh meicníocht caching (mar shampla middleware taisce Django féin) leagan ar leithligh den leathanach a thaisceadh do gach gníomhaire úsáideora uathúil.
\nIs é an buntáiste a bhaineann leis an maisitheoir vary_on_headers` a úsáid seachas an ceannteideal Vary a shocrú de láimh (ag baint úsáide as response.heads ['Vary'] = 'user-agent' `) ná go gcuireann an maisitheoir ** leis an gceannteideal Vary` (a d'fhéadfadh a bheith ann cheana féin).
Is féidir leat ceanntásca iolracha a chur chuig ``vary_on_heads () ``:
\n@vary_on_headers("User-Agent", "Cookie")\ndef my_view(request): ...\nInsíonn sé seo do chaisceanna iarshrutha go n-athróidh ar*an bheath*, rud a chiallaíonn go bhfaighidh gach teaglaim de ghníomhaire úsáideora agus fianán a luach taisce féin. Mar shampla, measfar iarratas leis an ngníomhaire úsáideora Mozilla agus an luach fianáin foo=bar difriúil ó iarratas leis an ngníomhaire úsáideora Mozilla agus an luach fianáin foo=ham.
Toisc go bhfuil éagsúlacht ar fhianán chomh coitianta, tá a: func: django.views.decorators.vary.vary_on_cookie maisitheoir ann. Tá an dá thuairim seo coibhéiseach:
\n@vary_on_cookie\ndef my_view(request): ...\n\n\n@vary_on_headers("Cookie")\ndef my_view(request): ...\nNíl na ceanntásca a chuireann tú chuig vary_on_headers` íogair do chásanna; ``"Gníomhaireacht úsáideora” ``an rud céanna le ``"úsáideach-gníomhaireaí"`.
\nIs féidir leat feidhm chúntóra a úsáid freisin, :func: django.utils.cache.patch_vary_headers, go díreach. Socraíonn an fheidhm seo, nó cuireann sé leis an “Ceannteideal éagsúla”. Mar shampla:
\nfrom django.shortcuts import render\nfrom django.utils.cache import patch_vary_headers\n\n\ndef my_view(request):\n ...\n response = render(request, "template_name", context)\n patch_vary_headers(response, ["Cookie"])\n return response\nGlacann patch_vary_headers an:class: ~django.http.http.httpResponse mar an chéad argóint agus liosta/tiúpla d'ainmneacha ceanntásc cás-neamh-íogair mar an dara argóint.
<9110 #section -12.5.5>Le haghaidh tuilleadh eolais faoi cheanntásca Vary, féach an:rfc: official Vary spec.
\n\n\nIs iad fadhbanna eile a bhaineann le caistriú ná príobháideacht sonraí agus an cheist cá háit ar chóir sonraí a stóráil i gcaitheamh taiscí.
\nDe ghnáth bíonn dhá chineál taisce ag úsáideoir: taisce a bhrabhsálaí féin (taisce príobháideach) agus taisce a sholáthraí (taisce poiblí). Úsáideann iolrúsáideoirí taisce poiblí agus tá sé á rialú ag duine eile. Cuireann sé seo fadhbanna le sonraí íogair - níl tú ag iarraidh, abair, d'uimhir chuntais bhainc a stóráiltear i taisce poiblí. Mar sin teastaíonn bealach ó fheidhmchláir ghréasáin chun na sonraí atá príobháideach agus na sonraí atá poiblí a insint
\nIs é an réiteach ná a chur in iúl gur chóir go mbeadh taisce leathanaigh “príobháideach.” Chun é seo a dhéanamh i Django, bain úsáid as an maisitheoir amharc: :func: ~django.views.decorators.cache.cache_control. Sampla:
\nfrom django.views.decorators.cache import cache_control\n\n\n@cache_control(private=True)\ndef my_view(request): ...\nTugann an maisitheoir seo aire don cheannteideal HTTP cuí a sheoladh amach taobh thiar de na radhairc.
\nTabhair faoi deara go bhfuil na socruithe rialaithe taisce “príobháideach” agus “poiblí” go comhpháirteach. Cinntíonn an maisitheoir go mbaintear an treoir “phoiblí” más chóir “príobháideach” a shocrú (agus a mhalairt). Bheadh úsáid samplach den dá threoir ná suíomh blag a thairgeann iontrálacha príobháideacha agus poiblí araon. Féadfar iontrálacha poiblí a stóráil ar aon taisce roinnte. Úsáideann an cód seo a leanas: func: ~django.utils.cache.patch_cache_control, an bealach láimhe chun an ceannteideal rialaithe taisce a mhodhnú (tugtar air go hinmheánach ag an maisitheoir:: ~django.views.decorators.cache.cache_control):
\nfrom django.views.decorators.cache import patch_cache_control\nfrom django.views.decorators.vary import vary_on_cookie\n\n\n@vary_on_cookie\ndef list_blog_entries_view(request):\n if request.user.is_anonymous:\n response = render_only_public_entries()\n patch_cache_control(response, public=True)\n else:\n response = render_private_and_public_entries(request.user)\n patch_cache_control(response, private=True)\n\n return response\nIs féidir leat taiscí iarshrutha a rialú ar bhealaí eile freisin (féach: rfc: 9111 le haghaidh sonraí faoi chaching HTTP). <9111 #section -5.2.2.1>Mar shampla, fiú mura n-úsáideann tú creat taisce taobh freastalaí Django, is féidir leat a rá fós do chliaint radharc a thaisceadh ar feadh méid áirithe ama leis an treor:rfc: max-age:
\nfrom django.views.decorators.cache import cache_control\n\n\n@cache_control(max_age=3600)\ndef my_view(request): ...\n(Má úsáideann t* an middleware caching, socraíonn sé an max-aois ``luach an socruithe: `CACHE_MIDDLEWARE_SECONDS cheana féin. Sa chás sin, beidh tosaíocht ag an maisitheoir saincheaptha ``max_age ``óna:func: ~django.views.decorators.cache.cache_control, agus cumasófar na luachanna ceanntásc i gceart.)
\nTá aon treoir bhailí freagartha Cache-Control bailí i ``cache_control () ``. Seo roinnt samplaí eile:
no_transform=True
must_revalidate=True
stale_while_revalidate=uimh_soicind
no_cache=True
Is féidir liosta iomlán na dtreoracha ar eolas a fháil sa chlárlann IANA`_ (tabhair faoi deara nach mbaineann gach ceann acu le freagraí).
\nMás mian leat ceanntásca a úsáid chun cúisceáin a dhíchumasú ar fad, is maisitheoir amharc é: :func: ~django.views.decorators.cache.never_cache a chuireann ceanntásc leis chun a chinntiú nach ndéanfaidh brabhsálaithe nó caches eile an freagra a stóráil. Sampla:
\nfrom django.views.decorators.cache import never_cache\n\n\n@never_cache\ndef myview(request): ...\nMIDDLEWARELink to this heading#Má úsáideann tú middleware caching, tá sé tábhachtach gach leath a chur san áit cheart laistigh den socrú: setting: MIDDLEWARE. Sin toisc go gcaithfidh an middleware taisce a bheith ar an eolas faoi na ceannteidil trína ndéanfaidh an stóráil taisce a athrú. Cuireann Middleware rud éigin i gcónaí leis an gceannteideal freagartha ``Vary` nuair is féidir leis.
\nRitheann UpdateCacheMiddleware le linn na céime freagartha, áit a reáchtáiltear middleware in ord droim, mar sin ritheann mír ag barr an liosta*deireana* le linn na céime freagartha. Mar sin, ní mór duit a chinntiú go bhfeictear UpdateCacheMiddleware roimh aon mheán-earraí eile a d'fhéadfadh rud éigin a chur leis an gceannteideal Vary. Déanann na modúil middleware seo a leanas amhlaidh:
Cuireann SessionMiddleware leis Cookie
Cuireann GZipMiddleWare Accept-Encoding
Cuireann Localemiddleware leis Accept-Language
Ar an láimh eile, ritheann fetchfromcachemiddleware le linn na céime iarratais, áit a gcuirtear meán-earraí i bhfeidhm den chéad uair go deireanach, mar sin ritheann mír ag barr an liosta*an chéad* le linn na céime iarratais. Caithfidh an FetchFromCacheMiddleware rith freisin tar éis lár earraí eile an ceannteideal Vary a nuashonrú, mar sin caithfidh FetchfromCacheMiddleware a bheith aith* tar éis aon earra a dhéanann amhlaidh.