Alguma boa estrutura AJAX para aplicativos do Google App Engine?[fechado]

Question

Estou tentando implementar AJAX em meu aplicativo Google App Engine e, por isso, estou procurando uma boa estrutura AJAX que me ajude.Alguém tem alguma ideia?

Estou pensando no Google Web Toolkit. Quão bom ele é em termos de criação de AJAX para Google App Engine?

Answer 1

Como o Google Web Toolkit é um subconjunto de Java funciona melhor quando você usa Java no back-end também.Como o Google App Engine está atualmente Somente Python Eu acho que você teria que fazer muita bagunça para que seu servidor e cliente se comunicassem bem.

jQuery parece ser a opção de biblioteca JavaScript mais popular no Tag AJAX em DjangoSnippets.com.

Editar: O que foi dito acima só se aplica aos aplicativos do Google App Engine escritos em Python.Como o Google App Engine agora oferece suporte a Java, o GWT agora pode ser uma boa opção para escrever um front-end AJAX. O Google ainda tem um tutorial mostrando como fazer isso.

Answer 2

Uma boa maneira é usar uma biblioteca AJAX é aproveitar Serviço de API de bibliotecas AJAX do Google.Isso é um pouco mais rápido e limpo do que baixar o JS e colocá-lo no seu /static/ pasta e não consome sua cota de disco.

No seu javascript você colocaria apenas, por exemplo:

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

e/ou

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

Em algum lugar do seu cabeçalho você colocaria algo como:

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

E isso é tudo que você precisa para usar as bibliotecas de API do Google.

Answer 3

Veja como implementamos o Ajax no Google App Engine, mas a ideia pode ser generalizada para outras plataformas.

Temos um script manipulador para solicitações Ajax que responde -principalmente- com respostas JSON.A estrutura é mais ou menos assim (este é um trecho de um script de manipulador GAE padrão):

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.

Os comandos são uma implementação simples do padrão 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

No lado do cliente, criamos um delegado Ajax.Prototype.js torna isso fácil de escrever e entender.Aqui está um trecho:

/** 
 * 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 chamar o delegado, você faz algo como:

new AjaxApi(resultHandlerFunction, faultHandlerFunction).getFriends()

Eu espero que isso ajude!

Answer 4

Não há razão para que você não deva usar o GAE e o Google Web Toolkit (GWT) juntos.Você escreve seu código backend em Python e o código frontend em Java (e possivelmente algum JavaScript), que é então compilado em JavaScript.Ao usar outro framework AJAX você também terá essa diferença entre a linguagem do servidor e do lado do cliente.

O GWT possui recursos que facilitam a invocação remota de código Java no servidor, mas são totalmente opcionais.Você pode apenas usar interfaces JSON ou XML, assim como outras estruturas AJAX.

O GWT 1.5 também vem com JavaScript Overlay Types, que basicamente permitem tratar um dado JSON como um objeto Java ao desenvolver o código do lado do cliente.Você pode ler mais sobre isso aqui.

Atualizar:

Agora que o Google adicionou suporte Java para o Google App Engine, você pode desenvolver código de back-end e front-end em Java em uma pilha completa do Google - se desejar.Há um bom Plug-in Eclipse do Google que facilita muito o desenvolvimento e a implantação de aplicativos que usam GAE, GWT ou ambos.

Answer 5

Eu recomendo procurar uma estrutura javascript pura (provavelmente Jquery) para o seu código do lado do cliente e escrever serviços JSON em python - essa parece ser a maneira mais fácil/melhor de fazer isso.

O Google Web Toolkit permite escrever a IU em Java e compilá-la em javascript.Como Dave diz, pode ser uma escolha melhor onde o backend está em Java, já que possui ótimos ganchos RPC para esse caso.

Answer 6

Você pode querer dar uma olhada em Pijamas (http://pyjs.org/), que é "GWT para Python".

Answer 7

tente também GQuery para GWT.Este é o 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(); 
        } 
    }); 
} 

Sendo código Java, resultando em otimizações de tempo de compilação (Java-> JavaScript) um tanto caras e refatoração mais fácil.

Legal, não é?

Answer 8

jQuery é uma ótima biblioteca, mas verifique também o Protótipo de estrutura JavaScript.Isso realmente transforma o JavaScript de uma linguagem ocasionalmente estranha em uma linguagem bonita e elegante.

Answer 9

Se você quiser invocar chamadas de método de JavaScript para Python, JSON-RPC funciona bem com o Google App Engine.Veja o artigo do Google, "Usando AJAX para ativar solicitações RPC do cliente", para detalhes.

Answer 10

Atualmente estou usando JQuery para meu aplicativo GAE e funciona perfeitamente para mim.Eu tenho um gráfico (google charts) que é dinâmico e usa uma chamada Ajax para capturar uma string JSON.Realmente parece funcionar bem para mim.

Answer 11

O Google anunciou recentemente a versão Java do Google App Engine.Esta versão também fornece um plugin Eclipse que facilita o desenvolvimento de aplicações GAE com GWT.

Veja detalhes aqui: http://code.google.com/appengine/docs/java/overview.html

Claro, seria necessário reescrever seu aplicativo em Java em vez de python, mas como alguém que trabalhou com GWT, deixe-me dizer, as vantagens de usar um IDE moderno em sua base de código AJAX valem totalmente a pena.