Wie kann ich die JSON zurückgeben, die ohne Vorlage in Django?

Dies ist im Zusammenhang mit dieser Frage: Django json zurückgeben und html, je nach client python

Habe ich ein Kommandozeilen-Python-API für eine Django-app. Wenn ich auf die app über die API, es sollte JSON zurückgeben und mit einem browser sollte es wieder HTML. Ich kann verschiedene URLs für den Zugriff auf die verschiedenen Versionen, aber wie kann ich das Rendern der HTML-Vorlage und JSON in den views.py mit nur einem template?

Zum Rendern der HTML, die ich benutzen würde:

return render_to_response('sample/sample.html....')

Aber wie würde ich das gleiche tun für JSON, ohne eine JSON-template? (die content-type sollte application/json statt text/html)

Was würde bestimmen, JSON und HTML-Ausgaben?

Also in meinem views.py:

if something:
    return render_to_response('html_template',.....)
else:
    return HttpReponse(jsondata,mimetype='application/json')

Hast du nicht gelesen, meine Antwort?
Sie im Grunde sagte ihm, "Nein, Mach es nicht auf diese Weise", ohne dass ihn ein Beispiel für den richtigen Weg. Das ist es, was dieses scheint mir für...
wenn es das ist, was passiert, sollte Sie nicht angenommen haben, Marcin Antwort auf die andere Frage nicht so schnell. Warten Sie mindestens einen Tag, jemand würde wahrscheinlich beantwortet haben, mit so etwas wie Uku Loskit Antwort
Ich habe tatsächlich sagen Sie ihm, die Bibliothek zu benutzen. Diese Frage scheint für den Zweck des Erhaltens jemand anderes schreibt seinen code für ihn.

InformationsquelleAutor Neeran | 2012-02-13

123

Ich denke das Thema ist mittlerweile verwirrt über das, was Sie wollen. Ich nehme an, du bist nicht wirklich der versucht, die HTML in JSON-Antwort, sondern Sie wollen eher alternativ Rückkehr entweder im HTML-oder JSON.

Erste, Sie brauchen, um zu verstehen, die Kern-Unterschied zwischen den beiden. HTML ist eine Präsentations-format. Es befasst sich mehr mit, wie die Anzeige von Daten als die Daten selbst. JSON ist das Gegenteil. Es ist Reine Daten-im Grunde ein JavaScript-Darstellung einiger Python (in diesem Fall) dataset ein, das Sie haben. Es dient lediglich als Austausch-Schicht, wodurch Sie zum verschieben von Daten von einem Bereich der app (der Blick) in einen anderen Bereich der app (JavaScript), die normalerweise keinen Zugang zu einander.

Mit diesem im Verstand, Sie nicht "render" - JSON -, und es gibt keine Vorlagen beteiligt. Sie nur konvertieren was auch immer die Daten im Spiel (wahrscheinlich ziemlich viel, was du bist vorbei wie der Kontext Ihrer Vorlage) zu JSON. Was kann getan werden, entweder über Django ' s JSON-Bibliothek (simplejson), wenn es Freiform-Daten, oder seine Serialisierungs-framework, wenn es ein queryset.

simplejson
```
from django.utils import simplejson

some_data_to_dump = {
   'some_var_1': 'foo',
   'some_var_2': 'bar',
}

data = simplejson.dumps(some_data_to_dump)
```
Serialisierung
```
from django.core import serializers

foos = Foo.objects.all()

data = serializers.serialize('json', foos)
```
So oder so, Sie dann passieren, dass die Daten in der Antwort:
```
return HttpResponse(data, content_type='application/json')
```
[Bearbeiten] In Django 1.6 und früher der code für die Rückgabe Antwort war
```
return HttpResponse(data, mimetype='application/json')
```
- Danke für die Klarstellung. Wie bestimme ich in meinen Ansichten, dass die Antwort der Anfrage wird von der api für json? Siehe Bearbeiten in Frage.
- Sie können request.is_ajax(). Aber das erfordert, dass die HTTP_X_REQUESTED_WITH - header gesetzt ist. Die meisten JavaScript-Bibliotheken tun dies automatisch, aber wenn Sie eine andere Art von client, Sie brauchen, um sicherzustellen, dass es Sätze gibt es auch. Alternativ können Sie ein querystring-wie ?json mit der URL und überprüfen Sie dann request.GET.has_key('json'), das ist wahrscheinlich ein wenig mehr kinderleicht.
- Beachten Sie, dass simplejson ist heute als nicht von Django 1.5. Verwenden import json ; json.dumps(data) statt.
- Die OP sollte überprüfen Sie die "Akzeptieren" content-type negotiation-header in der request Objekt. Siehe: w3.org/Protocols/rfc2616/rfc2616-sec14.html (big mamoth von einem lese -, sondern eine vereinfachte code-Beispiel könnte verwendet werden, um zu demonstrieren, und es wäre nicht sehr schwer zu schreiben, ein starres system, dass würde zumindest behandeln die beiden Fälle, die Sie gefragt haben)
- In meinem Fall (Django 1.7) es war content_type='application/json', nicht mimetype
InformationsquelleAutor Chris Pratt

In Django 1.7 ist dies noch einfacher mit dem eingebauten JsonResponse.

https://docs.djangoproject.com/en/dev/ref/request-response/#jsonresponse-objects

# import it
from django.http import JsonResponse

def my_view(request):

    # do something with the your data
    data = {}

    # just return a JsonResponse
    return JsonResponse(data)

InformationsquelleAutor davegaeddert

8

Im Fall der JSON-Antwort gibt es keine Vorlage gerendert werden. Vorlagen sind für die Erstellung von HTML-Antworten. Die JSON HTTP-response.

Allerdings können Sie HTML gerendert wird aus einer Vorlage in Ihre JSON-Antwort.
```
html = render_to_string("some.html", some_dictionary)
serialized_data = simplejson.dumps({"html": html})
return HttpResponse(serialized_data, mimetype="application/json")
```
- Muss ich serialisiere die Objekte zuerst?
- simplejson.dumps() ist, was tut die Serialisierung.
InformationsquelleAutor Uku Loskit
7

Sieht es aus wie das Django REST framework verwendet den HTTP-accept-header in einer Anforderung, um automatisch zu bestimmen, welcher renderer:

http://www.django-rest-framework.org/api-guide/renderers/

Mithilfe des HTTP-accept-header kann eine alternative Quelle für Ihre ", wenn etwas".

InformationsquelleAutor Charles Brandt

Für die Darstellung meiner Modelle in JSON in django 1.9 ich hatte zu tun, die folgenden in meinem views.py:

from django.core import serializers
from django.http import HttpResponse
from .models import Mymodel

def index(request):
    objs = Mymodel.objects.all()
    jsondata = serializers.serialize('json', objs)
    return HttpResponse(jsondata, content_type='application/json')

InformationsquelleAutor Raptor

2

Kannst du auch die Anfrage akzeptieren Inhaltstyp spezifiziert in rfc. So können Sie erbringen, indem Sie Standard-HTML-und wo Ihre Kunden akzeptieren, application/jason Sie zurückkehren können, json, in Ihrer Antwort ohne eine Vorlage erforderlich ist

InformationsquelleAutor Greg

from django.utils import simplejson 
from django.core import serializers 

def pagina_json(request): 
   misdatos = misdatos.objects.all()
   data = serializers.serialize('json', misdatos) 
   return HttpResponse(data, mimetype='application/json')

InformationsquelleAutor user3654231

Hier ist ein Beispiel brauchte ich für bedingt rendering json oder html je nach Anforderung Accept header

# myapp/views.py
from django.core import serializers                                                                                
from django.http import HttpResponse                                                                                  
from django.shortcuts import render                                                                                   
from .models import Event

def event_index(request):                                                                                             
    event_list = Event.objects.all()                                                                                  
    if request.META['HTTP_ACCEPT'] == 'application/json':                                                             
        response = serializers.serialize('json', event_list)                                                          
        return HttpResponse(response, content_type='application/json')                                                
    else:                                                                                                             
        context = {'event_list': event_list}                                                                          
        return render(request, 'polls/event_list.html', context)

testen Sie dies mit curl oder httpie

$ http localhost:8000/event/
$ http localhost:8000/event/ Accept:application/json

Hinweis: ich entschied mich nicht zu verwenden JsonReponse als würde reserialize das Modell unnötig.

InformationsquelleAutor Harry Moreno

0

Wenn Sie möchten, übergeben Sie das Ergebnis als gerenderte template zu laden und Rendern eines templates, übergeben Sie das Ergebnis zu Rendern, um das json-Format.Dies könnte beispielsweise so Aussehen:
```
from django.template import loader, RequestContext

#render the template
t=loader.get_template('sample/sample.html')
context=RequestContext()
html=t.render(context)

#create the json
result={'html_result':html)
json = simplejson.dumps(result)

return HttpResponse(json)
```
Diese Weise können Sie eine gerenderte template als json zu Ihrem Kunden. Dies kann nützlich sein, wenn Sie möchten, um vollständig zu ersetzen, dh. eine mit vielen verschiedenen Elementen.
- Als seitliche Anmerkung, die render_to_string ist eine Abkürzung für die 3 "Rendern der Vorlage" Linien und existiert seit der Django 1.0
- Ein diesem Punkt, Sie können auch mit XML statt JSON für den Datenaustausch...
InformationsquelleAutor marue

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.