python - for - ¿Algún buen marco AJAX para las aplicaciones de Google App Engine?

google app engine python standard

Question

Estoy tratando de 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 crear AJAX para Google App Engine?

Answer 1

Como Google Web Toolkit es un subconjunto de Java , funciona mejor cuando Java también está en el back-end. Dado que Google App Engine actualmente es Python , creo que tendrías que jugar un montón para que tu servidor y tu servidor se comuniquen entre ellos.

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

Editar: Lo anterior solo 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 de AJAX. Google incluso tiene un tutorial que le muestra cómo hacerlo.

Answer 2

Recomiendo buscar en un framework javascript puro (probablemente Jquery) para su código del lado del cliente, y escribir servicios JSON en python, que parece ser el camino más fácil / mejor para hacer.

Google Web Toolkit le permite escribir la interfaz de usuario en Java y compilarla en JavaScript. Como dice Dave, puede ser una mejor opción que el back-end esté en Java, ya que tiene buenos ganchos RPC para ese caso.

Answer 3

jQuery es una buena biblioteca, pero también echa un vistazo al marco Prototype JavaScript . Realmente convierte JavaScript de un lenguaje ocasionalmente incómodo en un lenguaje bello y elegante.

Answer 4

Si desea 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 las solicitudes de RPC del cliente ", para obtener más información.

Answer 5

Actualmente estoy usando JQuery para mi aplicación GAE y funciona muy bien para mí. Tengo un gráfico (google charts) que es dinámico y usa una llamada Ajax para tomar una cadena JSON. Realmente parece funcionar bien para mí.

Answer 6

Es posible que desee echar un vistazo a Pijamas ( http://pyjs.org/ ), que es "GWT para Python".

Answer 7

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

Tenemos un script de controlador para solicitudes Ajax que responde, principalmente, con respuestas JSON. La estructura se ve más o menos así (esto es un extracto de una secuencia de comandos 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

En el lado del cliente, creamos un delegado de Ajax. Prototype.js hace que esto sea fácil de escribir y entender. 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 8

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

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

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

Answer 9

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

En su javascript simplemente pondría, 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, podrías decir algo como:

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

Y eso es todo lo que necesita para usar las bibliotecas de API de Google.

Answer 10

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

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

Al ser código Java, resulta en optimizaciones en tiempo de compilación algo costosas (Java-> JavaScript) y una refactorización más sencilla.

Bien, no es?

Answer 11

No hay ninguna razón por la cual no deba usar GAE y Google Web Toolkit (GWT) juntos. Usted escribe su código backend en Python y el código frontend en Java (y posiblemente algo de JavaScript), que luego se compila en JavaScript. Al usar otro marco AJAX, también tendrá esta diferencia entre el idioma del lado del servidor y del lado del cliente.

GWT tiene características que facilitan la invocación remota de código Java en el servidor, pero son totalmente opcionales. Puede usar 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 una pieza 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. Existe un buen plugin de Eclipse de Google que hace que sea muy fácil desarrollar e implementar aplicaciones que usan GAE, GWT o ambas.

Answer 12

En mi blog trato con una manera fácil de hacer esto: el enlace es: AJAX con Google App Engine . Incluyo todo el código javascript y python que utilicé.