Ikhtisar¶

A sitemap is an XML file on your website that tells search-engine indexers how frequently your pages change and how "important" certain pages are in relation to other pages on your site. This information helps search engines index your site.

Kerangka kerja peta situs Django mengotomatiskan pembuatan dari berkas XML ini dengan membiarkan anda menyatakan informasi ini di kode Python.

It works much like Django's syndication framework. To create a sitemap, just write a Sitemap class and point to it in your URLconf.

Pemasangan¶

Untuk memasang aplikasi peta situs, ikuti langkah-langkah ini:

1. Tambah 'django.contrib.sitemaps' ke pengaturan INSTALLED_APPS anda.
2. Make sure your TEMPLATES setting contains a DjangoTemplates backend whose APP_DIRS options is set to True. It's in there by default, so you'll only need to change this if you've changed that setting.
3. Pastikan anda telah memasang sites framework.

(Note: The sitemap application doesn't install any database tables. The only reason it needs to go into INSTALLED_APPS is so that the Loader() template loader can find the default templates.)

Inisialisasi¶

views.sitemap(request, sitemaps, section=None, template_name='sitemap.xml', content_type='application/xml')¶

Untuk mengaktifkan pembangkitan peta situs pada situs Django anda, tambah baris ini ke URLconf anda:

from django.contrib.sitemaps.views import sitemap

path('sitemap.xml', sitemap, {'sitemaps': sitemaps},
     name='django.contrib.sitemaps.views.sitemap')

Ini mengatakan Django membangun sebuah peta situs ketika seorang klien mengakses /sitemap.xml.

The name of the sitemap file is not important, but the location is. Search engines will only index links in your sitemap for the current URL level and below. For instance, if sitemap.xml lives in your root directory, it may reference any URL in your site. However, if your sitemap lives at /content/sitemap.xml, it may only reference URLs that begin with /content/.

The sitemap view takes an extra, required argument: {'sitemaps': sitemaps}. sitemaps should be a dictionary that maps a short section label (e.g., blog or news) to its Sitemap class (e.g., BlogSitemap or NewsSitemap). It may also map to an instance of a Sitemap class (e.g., BlogSitemap(some_var)).

Kelas Sitemap¶

A Sitemap class is a simple Python class that represents a "section" of entries in your sitemap. For example, one Sitemap class could represent all the entries of your Weblog, while another could represent all of the events in your events calendar.

In the simplest case, all these sections get lumped together into one sitemap.xml, but it's also possible to use the framework to generate a sitemap index that references individual sitemap files, one per section. (See Creating a sitemap index below.)

Kelas-kelas Sitemap harus mengsubkelaskan django.contrib.sitemaps.Sitemap. Mereka dapat tinggal dimana saja dalam basis kode anda.

Sebuah contoh sederhana¶

Mari kita beranggapan anda mempunyai sebuah sistem blog, dengan sebuah model Entry, dan anda ingin peta situs anda menyertakan semua tautan ke masukan blog pribadi anda. Ini adalah bagaimana kelas petasitus anda mungkin terlihat:

from django.contrib.sitemaps import Sitemap
from blog.models import Entry

class BlogSitemap(Sitemap):
    changefreq = "never"
    priority = 0.5

    def items(self):
        return Entry.objects.filter(is_draft=False)

    def lastmod(self, obj):
        return obj.pub_date

Catatan:

• changefreq and priority are class attributes corresponding to <changefreq> and <priority> elements, respectively. They can be made callable as functions, as lastmod was in the example.
• items() is simply a method that returns a list of objects. The objects returned will get passed to any callable methods corresponding to a sitemap property (location, lastmod, changefreq, and priority).
• lastmod harus mengembalikan sebuah datetime.
• There is no location method in this example, but you can provide it in order to specify the URL for your object. By default, location() calls get_absolute_url() on each object and returns the result.

Acuan kelas Sitemap¶

class Sitemap[sumber]¶

Sebuah kelas Sitemap dapat menentukan metode/atribut berikut:

items[sumber]¶

Required. A method that returns a list of objects. The framework doesn't care what type of objects they are; all that matters is that these objects get passed to the location(), lastmod(), changefreq() and priority() methods.

location[sumber]¶

Pilihan. Antara sebuah metode atau atribut.

Jika itu adalah sebuah metode, itu harus mengembalikan jalur mutlak untuk obyek yang diberikan sebagai dikembalikan oleh items().

Jika itu adalah sebuah atribut, nilainya harus berupa string mewakili sebuah jalur mutlak untuk digunakan setiap obyek dikembalikan oleh items().

Di kedua kasus, "absolute path" berarti sebuah URL yang tidak menyertakan protokol atau ranah. Contoh:

• Baik: '/foo/bar/'
• Buruk: 'example.com/foo/bar/'
• Buruk: 'https://example.com/foo/bar/'

Jika location tidak disediakan, kerangka kerja akan memanggil metode get_absolute_url() pada setiap obyek sebagai dikembalikan oleh items().

Untuk menentukan sebuah protokol selain dari 'http', gunakan protocol.

lastmod¶

Pilihan. Antara sebuah metode atau atribut.

Jika itu adalah sebuah metode, itu harus mengambil satu argumen - sebuah obyek seperti dikembalikan oleh items() -- dan mengembalikan tanggal/waktu dirubah-terakhir obyek itu seperti datetime.

If it's an attribute, its value should be a datetime representing the last-modified date/time for every object returned by items().

If all items in a sitemap have a lastmod, the sitemap generated by views.sitemap() will have a Last-Modified header equal to the latest lastmod. You can activate the ConditionalGetMiddleware to make Django respond appropriately to requests with an If-Modified-Since header which will prevent sending the sitemap if it hasn't changed.

changefreq¶

Pilihan. Antara sebuah metode atau atribut.

If it's a method, it should take one argument -- an object as returned by items() -- and return that object's change frequency as a string.

If it's an attribute, its value should be a string representing the change frequency of every object returned by items().

Possible values for changefreq, whether you use a method or attribute, are:

• 'always'
• 'hourly'
• 'daily'
• 'daily'
• 'daily'
• 'yearly'
• 'never'

priority¶

Pilihan. Antara sebuah metode atau atribut.

Jika itu adalah sebuah metode, itu harus mengambil satu argumen - sebuah obyek seperti dikembalikan oleh items() -- dan mengembalikan prioritas obyek itu antara string atau float.

Jika itu adalah sebuah atribut, nilainya harus antra string atau float mewakili prioritas dari setiap obyek dikembalikan oleh items().

Contoh nilai-nilai untuk priority: 0.4, 1.0. Prioritas awalan dari sebuah halaman adalah 0.5. Lihat sitemaps.org documentation untuk beberapa.

protocol¶

Pilihan.

Atribut ini menentukan protokol ('http' atau 'https') dari URL di peta situs. Jika itu tidak disetel, protokol dengan peta situs mana yang telah diminta digunakan. Jika peta situs dibangun diluar konteks dari permintaan, awalan adalah 'http'.

limit¶

Pilihan.

This attribute defines the maximum number of URLs included on each page of the sitemap. Its value should not exceed the default value of 50000, which is the upper limit allowed in the Sitemaps protocol.

i18n¶

Pilihan.

Sebuah atribut boolean yang menentukan jika URL dari peta situs ini harus dibangkitkan menggunakan semua LANGUAGES anda. Awalan adalah False.

Jalan pintas¶

Kerangka kerja peta situs menyediakan sebuah kelas mudah untuk kasus tertentu:

class GenericSitemap(info_dict, priority=None, changefreq=None, protocol=None)[sumber]¶

The django.contrib.sitemaps.GenericSitemap class allows you to create a sitemap by passing it a dictionary which has to contain at least a queryset entry. This queryset will be used to generate the items of the sitemap. It may also have a date_field entry that specifies a date field for objects retrieved from the queryset. This will be used for the lastmod attribute in the generated sitemap.

The priority, changefreq, and protocol keyword arguments allow specifying these attributes for all URLs.

New in Django 2.0:

The protocol keyword argument was added.

from django.contrib.sitemaps import GenericSitemap
from django.contrib.sitemaps.views import sitemap
from django.urls import path
from blog.models import Entry

info_dict = {
    'queryset': Entry.objects.all(),
    'date_field': 'pub_date',
}

urlpatterns = [
    # some generic view using info_dict
    # ...

    # the sitemap
    path('sitemap.xml', sitemap,
         {'sitemaps': {'blog': GenericSitemap(info_dict, priority=0.6)}},
         name='django.contrib.sitemaps.views.sitemap'),
]

Peta situs untuk tampilan tetap¶

Often you want the search engine crawlers to index views which are neither object detail pages nor flatpages. The solution is to explicitly list URL names for these views in items and call reverse() in the location method of the sitemap. For example:

# sitemaps.py
from django.contrib import sitemaps
from django.urls import reverse

class StaticViewSitemap(sitemaps.Sitemap):
    priority = 0.5
    changefreq = 'daily'

    def items(self):
        return ['main', 'about', 'license']

    def location(self, item):
        return reverse(item)

# urls.py
from django.contrib.sitemaps.views import sitemap
from django.urls import path

from .sitemaps import StaticViewSitemap
from . import views

sitemaps = {
    'static': StaticViewSitemap,
}

urlpatterns = [
    path('', views.main, name='main'),
    path('about/', views.about, name='about'),
    path('license/', views.license, name='license'),
    # ...
    path('sitemap.xml', sitemap, {'sitemaps': sitemaps},
         name='django.contrib.sitemaps.views.sitemap')
]

Membuat indeks peta situs¶

views.index(request, sitemaps, template_name='sitemap_index.xml', content_type='application/xml', sitemap_url_name='django.contrib.sitemaps.views.sitemap')¶

The sitemap framework also has the ability to create a sitemap index that references individual sitemap files, one per each section defined in your sitemaps dictionary. The only differences in usage are:

• You use two views in your URLconf: django.contrib.sitemaps.views.index() and django.contrib.sitemaps.views.sitemap().
• The django.contrib.sitemaps.views.sitemap() view should take a section keyword argument.

Here's what the relevant URLconf lines would look like for the example above:

from django.contrib.sitemaps import views

urlpatterns = [
    path('sitemap.xml', views.index, {'sitemaps': sitemaps}),
    path('sitemap-<section>.xml', views.sitemap, {'sitemaps': sitemaps},
         name='django.contrib.sitemaps.views.sitemap'),
]

This will automatically generate a sitemap.xml file that references both sitemap-flatpages.xml and sitemap-blog.xml. The Sitemap classes and the sitemaps dict don't change at all.

You should create an index file if one of your sitemaps has more than 50,000 URLs. In this case, Django will automatically paginate the sitemap, and the index will reflect that.

If you're not using the vanilla sitemap view -- for example, if it's wrapped with a caching decorator -- you must name your sitemap view and pass sitemap_url_name to the index view:

from django.contrib.sitemaps import views as sitemaps_views
from django.views.decorators.cache import cache_page

urlpatterns = [
    path('sitemap.xml',
         cache_page(86400)(sitemaps_views.index),
         {'sitemaps': sitemaps, 'sitemap_url_name': 'sitemaps'}),
    path('sitemap-<section>.xml',
         cache_page(86400)(sitemaps_views.sitemap),
         {'sitemaps': sitemaps}, name='sitemaps'),
]

Template customization¶

If you wish to use a different template for each sitemap or sitemap index available on your site, you may specify it by passing a template_name parameter to the sitemap and index views via the URLconf:

from django.contrib.sitemaps import views

urlpatterns = [
    path('custom-sitemap.xml', views.index, {
        'sitemaps': sitemaps,
        'template_name': 'custom_sitemap.html'
    }),
    path('custom-sitemap-<section>.xml', views.sitemap, {
        'sitemaps': sitemaps,
        'template_name': 'custom_sitemap.html'
    }, name='django.contrib.sitemaps.views.sitemap'),
]

Tampilan ini mengembalikan instance TemplateResponse yang mengizinkan anda dengan mudah menyesuaikan data tanggapan sebelum membangun. Untuk rincian lebih, lihat TemplateResponse documentation.

<?xml version="1.0" encoding="UTF-8"?>
<urlset
  xmlns="https://www.sitemaps.org/schemas/sitemap/0.9"
  xmlns:news="http://www.google.com/schemas/sitemap-news/0.9">
{% spaceless %}
{% for url in urlset %}
  <url>
    <loc>{{ url.location }}</loc>
    {% if url.lastmod %}<lastmod>{{ url.lastmod|date:"Y-m-d" }}</lastmod>{% endif %}
    {% if url.changefreq %}<changefreq>{{ url.changefreq }}</changefreq>{% endif %}
    {% if url.priority %}<priority>{{ url.priority }}</priority>{% endif %}
    <news:news>
      {% if url.item.publication_date %}<news:publication_date>{{ url.item.publication_date|date:"Y-m-d" }}</news:publication_date>{% endif %}
      {% if url.item.tags %}<news:keywords>{{ url.item.tags }}</news:keywords>{% endif %}
    </news:news>
   </url>
{% endfor %}
{% endspaceless %}
</urlset>

Pinging Google¶

You may want to "ping" Google when your sitemap changes, to let it know to reindex your site. The sitemaps framework provides a function to do just that: django.contrib.sitemaps.ping_google().

ping_google()[sumber]¶

ping_google() takes an optional argument, sitemap_url, which should be the absolute path to your site's sitemap (e.g., '/sitemap.xml'). If this argument isn't provided, ping_google() will attempt to figure out your sitemap by performing a reverse looking in your URLconf.

ping_google() raises the exception django.contrib.sitemaps.SitemapNotFound if it cannot determine your sitemap URL.

One useful way to call ping_google() is from a model's save() method:

from django.contrib.sitemaps import ping_google

class Entry(models.Model):
    # ...
    def save(self, force_insert=False, force_update=False):
        super().save(force_insert, force_update)
        try:
            ping_google()
        except Exception:
            # Bare 'except' because we could get a variety
            # of HTTP-related exceptions.
            pass

A more efficient solution, however, would be to call ping_google() from a cron script, or some other scheduled task. The function makes an HTTP request to Google's servers, so you may not want to introduce that network overhead each time you call save().

python manage.py ping_google [/sitemap.xml]