¿Algún buen marco AJAX para aplicaciones de Google App Engine?[cerrado]

Question

Estoy intentando implementar AJAX en mi aplicación Google App Engine, por lo que estoy buscando un buen marco AJAX que me ayude.¿Alguien tiene alguna idea?

Estoy pensando en Google Web Toolkit, ¿qué tan bueno es en términos de creación de AJAX para Google App Engine?

Answer 1

Dado que Google Web Toolkit es un subconjunto de Java También funciona mejor cuando usas Java en el backend.Dado que Google App Engine es actualmente Sólo pitón Creo que tendrías que esforzarte mucho para que tu servidor y tu cliente se comuniquen bien entre sí.

jQuery parece ser la opción de biblioteca JavaScript más popular en el mundo. Etiqueta AJAX en DjangoSnippets.com.

Editar: Lo anterior sólo se aplica a las aplicaciones de Google App Engine escritas en Python.Como Google App Engine ahora es compatible con Java, GWT ahora podría ser una buena opción para escribir una interfaz AJAX. Google incluso tiene un tutorial que te muestra cómo hacerlo.

Answer 2

Una buena manera es utilizar una biblioteca AJAX y aprovechar Servicio API de bibliotecas AJAX de Google.Esto es un poco más rápido y limpio que descargar el JS y ponerlo en tu /static/ carpeta y no consume su cuota de disco.

En tu javascript simplemente pondrías, por ejemplo:

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

y/o

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

En algún lugar de tu encabezado pondrías algo como:

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

Y eso es todo lo que necesitas para utilizar las bibliotecas API de Google.

Answer 3

Así es como implementamos Ajax en Google App Engine, pero la idea se puede generalizar a otras plataformas.

Tenemos un script de controlador para solicitudes Ajax que responde -en su mayoría- con respuestas JSON.La estructura se parece a esto (este es un extracto de un script de controlador GAE estándar):

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.

Los comandos son una implementación simple del patrón de comando:

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

Del lado del cliente, creamos un delegado Ajax.Prototype.js hace que esto sea fácil de escribir y comprender.Aquí hay un extracto:

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

});

para llamar al delegado, haces algo como:

new AjaxApi(resultHandlerFunction, faultHandlerFunction).getFriends()

¡Espero que esto ayude!

Answer 4

No hay ninguna razón por la que no debas utilizar GAE y Google Web Toolkit (GWT) juntos.Escribe su código de backend en Python y el código de frontend en Java (y posiblemente algo de JavaScript), que luego se compila en JavaScript.Cuando utilice otro marco AJAX, también tendrá esta diferencia entre el lenguaje del lado del servidor y del cliente.

GWT tiene características que facilitan la invocación remota de código Java en el servidor, pero son completamente opcionales.Puede utilizar interfaces JSON o XML, al igual que con otros marcos AJAX.

GWT 1.5 también viene con tipos de superposición de JavaScript, que básicamente le permiten tratar un fragmento de datos JSON como un objeto Java al desarrollar el código del lado del cliente.Puedes leer más sobre esto. aquí.

Actualizar:

Ahora que Google ha agregado compatibilidad con Java para Google App Engine, puede desarrollar código de backend y frontend en Java en una pila completa de Google, si lo desea.hay un lindo Complemento de eclipse de Google que hace que sea muy fácil desarrollar e implementar aplicaciones que utilizan GAE, GWT o ambos.

Answer 5

Recomiendo buscar un marco de JavaScript puro (probablemente Jquery) para su código del lado del cliente y escribir servicios JSON en Python; esa parece ser la mejor y más fácil manera de hacerlo.

Google Web Toolkit te permite escribir la interfaz de usuario en Java y compilarla en javascript.Como dice Dave, puede ser una mejor opción si el backend está en Java, ya que tiene buenos ganchos RPC para ese caso.

Answer 6

Quizás quieras echarle un vistazo a Pijamas (http://pyjs.org/), que es "GWT para Python".

Answer 7

prueba también GQuery para GWT.Este es el código Java:

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

Ser código Java da como resultado optimizaciones en tiempo de compilación (Java->JavaScript) algo costosas y una refactorización más sencilla.

Bonito, ¿no lo es?

Answer 8

jQuery es una excelente biblioteca, pero también consulte la Prototipo de marco JavaScript.Realmente hace que JavaScript pase de ser un lenguaje ocasionalmente incómodo a convertirse en un lenguaje hermoso y elegante.

Answer 9

Si desea poder invocar llamadas a métodos desde JavaScript a Python, JSON-RPC Funciona bien con Google App Engine.Consulte el artículo de Google, "Uso de AJAX para habilitar solicitudes RPC del cliente", para detalles.

Answer 10

Actualmente estoy usando JQuery para mi aplicación GAE y me funciona de maravilla.Tengo un gráfico (gráficos de Google) que es dinámico y utiliza una llamada Ajax para capturar una cadena JSON.Realmente parece funcionar bien para mí.

Answer 11

Google ha anunciado recientemente la versión Java de Google App Engine.Esta versión también proporciona un complemento de Eclipse que facilita el desarrollo de aplicaciones GAE con GWT.

Ver detalles aquí: http://code.google.com/appengine/docs/java/overview.html

Por supuesto, requeriría que reescribieras tu aplicación en Java en lugar de Python, pero como alguien que ha trabajado con GWT, déjame decirte que las ventajas de usar un IDE moderno en tu código base AJAX valen la pena.