Tout bon framework AJAX de Google App Engine apps?[fermé]

Question

Je suis en train de mettre en oeuvre AJAX dans mon application Google App Engine, et donc je suis à la recherche d'un bon framework AJAX qui va m'aider.Quelqu'un a une idée?

Je pense à propos de Google Web Toolkit, combien il est bon en termes de création d'AJAX pour Google App Engine?

Answer 1

Google Web Toolkit est un sous-ensemble de Java il fonctionne mieux lorsque vous Java à l'arrière-plan aussi.Depuis que Google App Engine est actuellement Python seulement Je pense que vous avez à faire beaucoup de vous embêter pour obtenir votre serveur et client pour parler gentiment les uns des autres.

jQuery semble être le plus populaire de la bibliothèque JavaScript option dans le AJAX Balise DjangoSnippets.com.

Edit: Le ci-dessus est seulement vrai de Google App Engine applications écrites en Python.Comme Google App Engine prend désormais en charge Java, GWT pourrait maintenant être un bon choix pour l'écriture d'un AJAX avant la fin. Google ont même un tutoriel pour vous montrer comment faire cela.

Answer 2

Une belle façon est d'utiliser une bibliothèque AJAX est de prendre avantage de Google AJAX Bibliothèques de service API.C'est un peu plus rapide et plus propre que le téléchargement du JS et de le mettre dans votre /static/ dossier et ne pas manger dans votre quota de disque.

Dans votre javascript vous venez de mettre, par exemple:

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

et/ou

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

Quelque part dans votre tête vous mettez quelque chose comme:

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

Et c'est tout vous avez besoin pour utiliser l'API Google bibliothèques.

Answer 3

Voici comment nous avons mis en œuvre Ajax sur le Google App Engine, mais l'idée peut être généralisée à d'autres plates-formes.

Nous avons un gestionnaire de script pour les requêtes Ajax qui répond -pour la plupart -, avec des réponses JSON.La structure ressemble à quelque chose comme ceci (c'est un extrait d'un standard GAE gestionnaire de script):

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.

Les commandes sont d'une simplicité de mise en oeuvre du modèle de commande:

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

Sur le côté client, nous créons une requête Ajax délégué.Prototype.js rend ce facile à écrire et à comprendre.Voici un extrait:

/** 
 * 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
        });    
    }

});

appeler le délégué, vous faites quelque chose comme:

new AjaxApi(resultHandlerFunction, faultHandlerFunction).getFriends()

J'espère que cela aide!

Answer 4

Il n'ya aucune raison pourquoi vous ne devriez pas utiliser GAE et Google Web Toolkit (GWT) ensemble.Vous écrivez votre backend code en Python et la gestion de l'interface en Java (et éventuellement un peu de JavaScript), qui est ensuite compilé en JavaScript.Lorsque l'on utilise un framework AJAX vous aurez aussi cette différence entre le serveur et côté client de la langue.

GWT a des caractéristiques qui font de l'invocation distante de code java sur le serveur plus facile, mais ceux-ci sont entièrement facultative.Vous pouvez simplement utiliser JSON ou XML, interfaces, tout comme avec d'autres frameworks AJAX.

GWT 1.5 est également livré avec JavaScript Types d'Incrustation, que, fondamentalement, vous permettent de traiter un morceau de données JSON comme un objet Java lors de l'élaboration de la côté client code.Vous pouvez lire plus à ce sujet ici.

Mise à jour:

Maintenant que Google a ajouté le support de Java pour Google App Engine, vous pouvez développer à la fois backend et frontend code en Java sur un Google complète de la pile si vous le souhaitez.Il y a une belle Plugin Eclipse à partir de Google qui le rend très facile à développer et déployer des applications qui utilisent GAE, GWT ou les deux.

Answer 5

Je vous recommande de rechercher dans un pur framework javascript (probablement Jquery) pour votre code côté client, et d'écrire JSON services en python - qui semble être la plus facile et la meilleurs façon d'aller.

Google Web Toolkit vous permet d'écrire l'INTERFACE utilisateur en Java et de les compiler en javascript.Comme Dave dit, il peut être un meilleur choix pour les applications où le backend est en Java, comme il l'a nice RPC crochets pour ce cas.

Answer 6

Vous voudrez peut-être avoir un coup d'oeil à un Pyjama (http://pyjs.org/), qui est "GWT pour Python".

Answer 7

essayez également GQuery pour GWT.C'est le code Java:

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

Cours de code Java résultant en un peu cher au moment de la compilation (Java->JavaScript) et optimisations plus facile de refactoring.

De Nice, il ne l'est pas?

Answer 8

jQuery est une belle bibliothèque, mais aussi consultez les Prototype framework JavaScript.Il tourne vraiment JavaScript parfois maladroit langue dans une belle et élégante de la langue.

Answer 9

Si vous voulez être en mesure d'appeler les appels de méthode à partir de JavaScript, Python, JSON-RPC fonctionne bien avec Google App Engine.Voir Google de l'article, "L'utilisation d'AJAX pour Permettre aux Clients de Demandes RPC"pour plus de détails.

Answer 10

Je suis actuellement à l'aide de JQuery pour mon GAE application et il fonctionne à merveille pour moi.J'ai un tableau (google charts) qui est dynamique et utilise un appel Ajax pour saisir une chaîne JSON.Il semble vraiment bien fonctionner pour moi.

Answer 11

Google a récemment annoncé la version Java de Google App Engine.Cette version fournit également un plugin Eclipse qui rend le développement GAE applications avec GWT plus facile.

Voir plus de détails ici: http://code.google.com/appengine/docs/java/overview.html

Bien sûr, il serait vous obliger à réécrire votre application en Java au lieu de python, mais comme quelqu'un qui a travaillé avec GWT, permettez-moi de vous le dire, les avantages de l'utilisation d'un IDE moderne sur votre base de code AJAX sont vraiment la peine.