Gibt es ein gutes AJAX-Framework für Google App Engine-Apps?[geschlossen]

Question

Ich versuche, AJAX in meiner Google App Engine-Anwendung zu implementieren und suche daher nach einem guten AJAX-Framework, das mir hilft.Hat jemand eine Idee?

Ich denke über das Google Web Toolkit nach. Wie gut ist es im Hinblick auf die Erstellung von AJAX für Google App Engine?

Answer 1

Wie Google Web Toolkit ist eine Teilmenge von Java es funktioniert am besten, wenn Sie Java im Backend zu. Da Google App Engine derzeit Python nur Ich denke, müssten Sie zu tun, um eine Menge Unordnung Ihren Server und Client zu sprechen gut miteinander zu erhalten.

scheint jQuery die beliebtesten JavaScript-Bibliothek Option im AJAX Tag bei DjangoSnippets zu sein .com .

Edit: Das oben gilt nur für Google App Engine-Anwendungen in Python geschrieben. Wie Google App Engine unterstützt jetzt Java könnte GWT jetzt eine gute Wahl sein, eine AJAX Frontend für das Schreiben. Google haben sogar ein Tutorial zeigt Ihnen, wie es zu tun.

Answer 2

Eine nette Weise ist eine AJAX-Bibliothek verwenden, um die Vorteile von Google AJAX Libraries API Service in Anspruch nehmen . Das ist ein bisschen schneller und sauberer als die JS heruntergeladen und in Ihrem /static/ Ordner setzen und isst nicht in Ihre Disk Quota.

In Ihrem Javascript würden Sie nur setzen, zum Beispiel:

google.load("jquery", "1.3.2");

und / oder

google.load(google.load("dojo", "1.3.0");

Irgendwo in der Kopfzeile würden Sie setzen so etwas wie:

<script src="http://www.google.com/jsapi?key=your-key-here"></script>

Und das ist alles, was Sie brauchen Googles API-Bibliotheken zu verwenden.

Answer 3

So haben wir Ajax auf der Google App Engine implementiert, aber die Idee kann auf andere Plattformen übertragen werden.

Wir haben ein Handler-Skript für Ajax-Anfragen, das größtenteils mit JSON-Antworten antwortet.Die Struktur sieht in etwa so aus (dies ist ein Auszug aus einem Standard-GAE-Handler-Skript):

def Get(self, user):
    self.handleRequest()

def Post(self, user):
    self.handleRequest()


def handleRequest(self):        
    '''
    A dictionary that maps an operation name to a command.
    aka: a dispatcher map.
    '''
    operationMap = {'getfriends':               [GetFriendsCommand],
                    'requestfriend':            [RequestFriendCommand, [self.request.get('id')]],
                    'confirmfriend':            [ConfirmFriendCommand, [self.request.get('id')]],
                    'ignorefriendrequest':      [IgnoreFriendRequestCommand, [self.request.get('id')]],
                    'deletefriend':             [DeleteFriendCommand, [self.request.get('id')]]}

    # Delegate the request to the matching command class here.

Die Befehle sind eine einfache Implementierung des Befehlsmusters:

class Command():
    """ A simple command pattern.
    """
    _valid = False
    def validate(self):
        """ Validates input. Sanitize user input here.
        """
        self._valid = True

    def _do_execute(self):
        """ Executes the command. 
            Override this in subclasses.
        """
        pass

    @property
    def valid(self):
        return self._valid

    def execute(self):
        """ Override _do_execute rather than this.
        """ 
        try:
            self.validate()
        except:
            raise
        return self._do_execute()

    # Make it easy to invoke commands:
    # So command() is equivalent to command.execute()
    __call__ = execute

Auf der Clientseite erstellen wir einen Ajax-Delegaten.Mit Prototype.js ist dies einfach zu schreiben und zu verstehen.Hier ein Auszug:

/** 
 * Ajax API
 *
 * You should create a new instance for every call.
 */
var AjaxAPI = Class.create({
    /* Service URL */
    url: HOME_PATH+"ajax/",

    /* Function to call on results */
    resultCallback: null,

    /* Function to call on faults. Implementation not shown */
    faultCallback: null,

    /* Constructor/Initializer */
    initialize: function(resultCallback, faultCallback){
        this.resultCallback = resultCallback;
        this.faultCallback = faultCallback;
    },

    requestFriend: function(friendId){
        return new Ajax.Request(this.url + '?op=requestFriend', 
        {method: 'post',
         parameters: {'id': friendId},
         onComplete: this.resultCallback
        });     
    },

    getFriends: function(){
        return new Ajax.Request(this.url + '?op=getfriends', 
        {method: 'get',
         onComplete: this.resultCallback
        });    
    }

});

Um den Delegierten anzurufen, gehen Sie wie folgt vor:

new AjaxApi(resultHandlerFunction, faultHandlerFunction).getFriends()

Ich hoffe das hilft!

Answer 4

Es gibt keinen Grund, warum sollten Sie nicht GAE und Google Web Toolkit (GWT) zusammen verwenden. Sie schreiben Ihren Backend-Code in Python und den Frontend-Code in Java (und möglicherweise einige JavaScript), die dann zu JavaScript kompiliert wird. Wenn Sie einen anderen AJAX-Framework werden Sie auch diesen Unterschied zwischen Server und Client-Seite Sprache.

GWT hat Features, die Remote-Aufruf von Java-Code auf dem Server zu erleichtern, aber diese sind optional. Sie können nur JSON oder XML-Schnittstellen verwenden, genauso wie mit anderen AJAX-Frameworks.

GWT 1.5 kommt auch mit JavaScript Overlay-Typen, die im Grunde ermöglichen es Ihnen, ein Stück von JSON-Daten wie ein Java-Objekt zu behandeln, wenn der Client-Seite Code zu entwickeln. Sie können mehr über diese hier rel="nofollow .

Update:

Nun, da Google Java-Unterstützung für Google App Engine hinzugefügt hat, können Sie sowohl Backend und Frontend-Code in Java auf ein vollwertiges Google-Stack entwickeln - wenn Sie möchten. Es gibt einen schönen Eclipse-Plugin von Google, die es sehr einfach zu entwickeln und Bereitstellen von Anwendungen macht, die GAE verwenden , GWT oder beides.

Answer 5

Ich würde empfehlen, in einen reinen JavaScript-Framework suche (wahrscheinlich JQuery) für Ihren clientseitigen Code, und JSON Dienste in python schreiben, die die einfachste / bestest Weg zu gehen, zu sein scheinen.

Google Web Toolkit können Sie die Benutzeroberfläche in Java schreiben und Javascript kompilieren. Wie Dave sagt, kann es eine bessere Wahl sein, wenn das Backend in Java ist, wie es schön RPC Haken für diesen Fall hat.

Answer 6

Sie können einen Blick auf Pyjamas haben wollen ( http://pyjs.org/ ), die "GWT für Python".

Answer 7

auch versuchen, GQuery für GWT . Dies ist Java-Code:

public void onModuleLoad() { 
    $("div").css("color", "red").click(new Function() { 
        public void f(Element e) { 
            Window.alert("Hello"); 
            $(e).as(Effects).fadeOut(); 
        } 
    }); 
} 

Die Java-Code in etwas teuer Kompilierung-resultierenden (Java-> JavaScript) Optimierungen und einfacher Refactoring.

Nizza, ist es nicht?

Answer 8

ist jQuery eine schöne Bibliothek, sondern auch die Prototype überprüfen. Es stellt sich wirklich JavaScript von einer gelegentlich peinliche Sprache in eine schöne und elegante Sprache.

Answer 9

Wenn Sie in der Lage sein Methodenaufrufe von JavaScript zu Python aufzurufen, JSON- RPC gut mit Google App Engine funktioniert. Siehe Google Artikel " AJAX verwenden, um Client-RPC-Anforderungen zu aktivieren ", für Details .

Answer 10

Ich bin derzeit mit JQuery für meine GAE App und es funktioniert wunderbar für mich. Ich habe ein Diagramm (Google Karten), die dynamisch ist und verwendet einen Ajax-Aufruf ein JSON-String zu greifen. Es scheint wirklich gut für mich zu arbeiten.

Answer 11

Google hat vor kurzem angekündigt, die Java-Version von Google App Engine. Diese Version bietet auch eine Eclipse-Plugin, das einfacher zu entwickeln GAE-Anwendungen mit GWT macht.

Weitere Details hier: http://code.google.com/appengine /docs/java/overview.html

Natürlich wäre es Sie benötigen, um Ihre Anwendung in Java anstelle von Python neu zu schreiben, sondern als jemand, der mit GWT gearbeitet hat, lassen Sie mich Ihnen sagen, die Vorteile einer modernen IDE auf Ihrer AJAX Code-Basis verwenden, sind jeden Cent wert.