Django Leichtigkeit des Aufbaus einer RESTful Schnittstelle

Question

Ich suche nach einer Entschuldigung, um Django für ein neues Projekt zu lernen, das aufkam. Normalerweise möchte ich RESTful serverseitige Schnittstellen erstellen, bei denen eine URL Ressourcen zugeordnet wird, die Daten in einem plattformunabhängigen Kontext wie XML oder JSON ausspeien. Dies ist ziemlich einfach zu tun, ohne die Verwendung von Frameworks, aber einige von ihnen wie Ruby on Rails ermöglichen es Ihnen einfach, XML auf einem Client zurückzuspucken, basierend auf dem Typ der URL, die Sie übergeben, basierend auf Ihrem vorhandenen Modellcode.

Meine Frage ist, hat so etwas wie Django Unterstützung dafür? Ich habe gegoogelt und einen 'RESTful' 3rd-Party-Code gefunden, der über Django hinausgehen kann. Ich bin mir nicht sicher, ob ich zu scharf darauf bin.

Wenn nicht Django, irgendein anderes Python-Framework, das bereits in diesem Sinne entwickelt wurde, muss ich das Rad nicht neu erfinden, wie ich es bereits in Sprachen wie PHP getan habe?

Answer 1

Dies ist wahrscheinlich ziemlich einfach zu tun.

URL-Zuordnungen sind leicht zu konstruieren, zum Beispiel:

urlpatterns = patterns('books.views', 
    (r'^books/$', 'index'), 
    (r'^books/(\d+)/$', 'get')) 

Django model serialization unterstützt, so ist es einfach Modelle in XML zu verwandeln:

from django.core import serializers 
from models import Book 

data = serializers.serialize("xml", Book.objects.all()) 

die beiden mit decorators Kombinieren und Sie können bauen schnelle, schnelle Handler:

from django.http import HttpResponse 
from django.shortcuts import get_object_or_404 

def xml_view(func): 
    def wrapper(*args, **kwargs): 
    result = func(*args, **kwargs) 
    return HttpResponse(serializers.serialize("xml", result), 
     mimetype="text/xml") 
    return wrapper 

@xml_view 
def index(request): 
    return Books.objects.all() 

@xml_view 
def get(request, id): 
    return get_object_or_404(Book, pk=id) 

Answer 2

Es kann mit jeder Art von Daten reagieren. JSON/XML/PDF/Bilder/CSV ...

Django selbst kommt mit einem set of serializers.

bearbeiten

Ich hatte nur einen Blick auf auf Piston - sieht vielversprechend aus. Beste Eigenschaft:

Bleibt aus dem Weg.

:)

Answer 3

A l Vor über einem Jahr schrieb ich einen REST-Webservice in Django für eine große Firma in Seattle, die Streaming-Medien im Internet anbietet.

Django war ausgezeichnet für den Zweck. Als "ein bezahlter Nerd" beobachtet, ist die Django-URL-Konfiguration wunderbar: Sie können Ihre URLs genau so einrichten, wie Sie es möchten, und die entsprechenden Objekte bereitstellen.

Die eine Sache, die ich nicht mochte: das Django ORM hat absolut keine Unterstützung für binäre BLOBs. Wenn Sie Fotos oder etwas anderes bereitstellen möchten, müssen Sie sie in einem Dateisystem und nicht in einer Datenbank speichern. Da wir mehrere Server verwendeten, musste ich entweder meine eigene BLOB-Unterstützung schreiben oder ein Replikations-Framework finden, das alle Server mit den neuesten binären Daten auf dem neuesten Stand hielt. (Ich entschied mich, meine eigene BLOB-Unterstützung zu schreiben. Es war nicht sehr schwer, also war ich eigentlich genervt, dass die Django-Jungs diese Arbeit nicht machten. Es sollte einen, und vorzugsweise nur einen, offensichtlichen Weg geben, etwas zu tun.)

Ich mag wirklich das Django ORM. Es macht den Datenbank Teil wirklich einfach; Sie müssen keine SQL wissen.(Ich mag SQL nicht, und ich mag Python, also ist es ein doppelter Gewinn.) Die "admin interface", die Sie kostenlos erhalten, gibt Ihnen eine gute Möglichkeit, Ihre Daten durchzusehen und Daten während des Testens zu pokern und Entwicklung.

Ich empfehle Django ohne Reservierung.

Answer 4

Werfen Sie einen Blick auf Piston, es ist ein Mini-Framework für Django zum Erstellen von RESTful APIs.

Ein aktueller Blog-Eintrag von Eric Holscher bietet etwas mehr Einblick über den Vor der Verwendung von Kolben: Large Problems in Django, Mostly Solved: APIs

Answer 5

(. Ich hatte die naheliegendste Links zu bearbeiten out)

+1 für piston - (link über). Ich hatte apibuilder (Washington Times Open Source) in der Vergangenheit verwendet, aber Piston funktioniert einfacher für mich. Am schwierigsten ist es für mich, meine URL-Strukturen für die API herauszufinden und bei den regulären Ausdrücken zu helfen. Ich habe auch surlex benutzt, was diese Arbeit viel einfacher macht.

Beispiel, unter Verwendung dieses Modells für Group (von einem Zeitplan System wir arbeiten):

class Group(models.Model): 
    """ 
    Tree-like structure that holds groups that may have other groups as leaves. 
    For example ``st01gp01`` is part of ``stage1``. 
    This allows subgroups to work. The name is ``parents``, i.e.:: 

     >>> stage1group01 = Group.objects.get(unique_name = 'St 1 Gp01') 
     >>> stage1group01 
     >>> <Group: St 1 Gp01> 
     # get the parents... 
     >>> stage1group01.parents.all() 
     >>> [<Group: Stage 1>] 

    ``symmetrical`` on ``subgroup`` is needed to allow the 'parents' attribute to be 'visible'. 
    """ 
    subgroup = models.ManyToManyField("Group", related_name = "parents", symmetrical= False, blank=True) 
    unique_name = models.CharField(max_length=255) 
    name = models.CharField(max_length=255) 
    academic_year = models.CharField(max_length=255) 
    dept_id = models.CharField(max_length=255) 
    class Meta: 
     db_table = u'timetable_group' 
    def __unicode__(self): 
     return "%s" % self.name 

Und dieses urls.py Fragment (beachten Sie, dass surlex ermöglicht regulären Ausdruck Makros leicht eingerichtet werden) :

from surlex.dj import surl 
from surlex import register_macro 
from piston.resource import Resource 
from api.handlers import GroupHandler 
group_handler = Resource(GroupHandler) 

# add another macro to our 'surl' function 
# this picks up our module definitions 
register_macro('t', r'[\w\W ,-]+') 

urlpatterns = patterns('', 
# group handler 
# all groups 
url(r'^groups/$', group_handler), 
surl(r'^group/<id:#>/$', group_handler), 
surl(r'^group/<name:t>/$', group_handler),) 

Dann wird dieser Handler sucht nach der Ausgabe JSON (Standard) und kann auch XML und YAML tun.

class GroupHandler(BaseHandler): 
    """ 
    Entry point for Group model 
    """ 

    allowed_methods = ('GET',) 
    model = Group 
    fields = ('id', 'unique_name', 'name', 'dept_id', 'academic_year', 'subgroup') 

    def read(self, request, id=None, name=None): 
     base = Group.objects 
     if id: 
      print self.__class__, 'ID' 
      try: 
       return base.get(id=id) 
      except ObjectDoesNotExist: 
       return rc.NOT_FOUND 
      except MultipleObjectsReturned: # Should never happen, since we're using a primary key. 
       return rc.BAD_REQUEST 
     else: 
      if name: 
       print self.__class__, 'Name' 
       return base.filter(unique_name = name).all() 
      else: 
       print self.__class__, 'NO ID' 
       return base.all() 

Wie Sie sehen können, die meisten der Handler-Code ist in herauszufinden, welche Parameter in urlpatterns übergeben werden.

Einige Beispiel-URLs sind api/groups/, api/group/3301/ und api/group/st1gp01/ - die alle JSON ausgeben.

Answer 6

In Bezug auf Ihren Kommentar über nicht 3rd-Party-Code - das ist schade, weil die Pluggable-Apps sind eines der größten Features von Django. Wie andere geantwortet haben, wird Kolben die meiste Arbeit für dich erledigen.