JAVASCRIPT OBJECT NOTATION - JSON
RPC
Uma Chamada de Procedimento Remoto (RPC) é uma comunicação entre processos que permite a um programa de computador executar uma sub-rotina ou procedimento em outro endereço (geralmente em outro computador em uma rede compartilhada) sem que o programador tenha codificado explicitamente os detalhes sobre a interação remota.
Isto é, o programador escreve essencialmente o mesmo código quer a sub-rotina seja para execução local do programa, ou para execução remota.
Quando o software em questão utiliza princípios de orientação a objetos, RPC é chamado de invocação remota ou invocação de método remoto.
Envio de Mensagens
Uma RPC é iniciada pelo cliente, que envia uma mensagem de requisição para um servidor remoto conhecido para executar um procedimento especificado com parâmetros fornecidos.
O servidor remoto envia uma resposta para o cliente, e o aplicativo continua o seu processo.
Enquanto o servidor está processando a chamada, o cliente é bloqueado (ele espera até que o servidor tenha terminado o processamento antes de retomar a execução), a não ser que o cliente envie uma solicitação assíncrona para o servidor, como uma chamada XHTTP.
Há muitas variações e subtilezas em várias implementações, resultando numa variedade de diferentes (incompatíveis) protocolos RPC.
Uma diferença importante entre chamadas de procedimento remoto e chamadas locais é que as chamadas remotas podem falhar por causa de problemas imprevisíveis de rede.
Além disso, os chamadores geralmente tem que lidar com essas falhas sem saber se o procedimento remoto foi aceito, ou se teve a requisição compilada.
Procedimentos idempotentes (aqueles que não têm efeitos adicionais se for chamado mais de uma vez) são facilmente manipulados, mas muitas dificuldades permanecem onde o código para chamar procedimentos remotos é muitas vezes confinado um a escrita cuidadosa em subsistemas de baixo nível.
Seqüência de eventos durante uma RPC
- O cliente chama o stub (um trecho do código usado para conversão de parâmetros passados durante uma RPC) do cliente. A chamada é um de procedimento de chamada local, com parâmetros colocados em pilha de uma forma normal.
- O stub do cliente empacota os parâmetros em uma mensagem e faz uma chamada para o sistema enviar a mensagem. Empacotar dos parâmetros é chamado de marshalling ( serialização - processo de conversão de dados ou objetos em um fluxo de bytes ).
- Sistema operacional local do cliente envia a mensagem a partir da máquina do cliente para a máquina do servidor.
- O sistema operacional na máquina do servidor repassa os pacotes da entrada para o stub do servidor.
- O stub do servidor desempacota os parâmetros da mensagem. Desempacotando os parâmetros é chamado unmarshalling (deserialização - processo inverso de conversão de um fluxo de bytes de volta a seus dados ou objetos originais).
- Finalmente, o stub do servidor chama o procedimento servidor do sistema operacional. A resposta segue os mesmos passos na direção inversa.
Padronização dos Mecanismos de Contato
Para permitir que diferentes clientes acessem os servidores, foram criadas uma série de sistemas RPC padronizados.
A maioria deles usa uma Linguagem de Descrição da interface (IDL) para permitir que várias plataformas possam chamar o RPC.
Os arquivos IDL pode então ser utilizado para gerar o código de interface entre o cliente e o servidor.
JSON_RPC
É um protocolo RPC (Remote Procedural Call) construído em JSON, como um substituto para o XML-RPC e SOAP, sendo um simples protocolo que define somente alguns tipos de dados e comandos.
Em contraste ao XML-RPC ou ao SOAP, ele permite comunicação bidirecional entre o serviço e o cliente, como uma espécie de peer-to-peer, onde cada uma das pontas pode chamar a outra ou enviar notificações(informações enviadas ao servidor que não requerem uma resposta). Ele também permite o envio de múltiplas chamadas de uma ponta a outra que podem ser respondidas fora de ordem.
Uma comunicação JSON pode ser feita em uma requisição HTTP onde o conteúdo é do tipo application/json.1 Além de usar o HTTP para transporte, podem ser usados sockets TCP/IP. Usando sockets, podem ser criadas aplicações web mais responsivas com o JSON-RPC, em comparação com um simples tráfego de um serviço JSON-RPC sobre HTTP.
Abaixo há um exemplo de um JSON-RPC 2.0 com pedido e resposta usando parâmetros posicionais.
--> {"jsonrpc": "2.0", "method": "subtract", "params": [42, 23], "id": 1} <-- {"jsonrpc": "2.0", "result": 19, "id": 1}
Utilização do JSON-RPC
JSON-RPC funciona através do envio de uma solicitação para um servidor de aplicação que implemente este protocolo. O cliente neste caso é tipicamente o software com a intenção de chamar um único método de um sistema remoto.Múltiplos parâmetros de entrada podem ser passados para o método remoto como um array ou objeto, ao passo que o próprio método pode também retornar múltiplos dados de saída (Isso depende da versão implementada)
Um método remoto é invocado pelo envio de uma requisição a um serviço remoto usando HTTP ou um soquete TCP/IP. Ao usar o HTTP, o tipo de conteúdo pode ser definido como application/json.
Todos os tipos de transferência são objetos individuais, serializados (convertidos em um fluxo de bytes) usando JSON.
Requisição é uma chamada enviada um método específico disponível em um sistema remoto. Deve conter três certas propriedades :
- Método - Uma String com o nome do método a ser invocado.
- parâmetros - Um Array de objetos a serem passados como parâmetros para um determinado método.
- id - Um valor de algum tipo, que é usado para comparar a resposta com a requisição que foi executada.
O receptor do pedido deve responder com uma resposta válida a todos os pedidos recebidos. A resposta deve conter as propriedades mencionadas abaixo:
- resultado - Os dados retornados pelo método invocado. Se ocorreu um erro ao chamar o método, esse valor deve ser nulo.
- erro - Um código de erro especificado se houver um erro de chamar do método , caso contrário, nulo.
- id - O ID da requisição que está sendo respondida.
Uma vez que há situações em a resposta não é necessária ou mesmo indesejadas, notificações foram introduzidas.
Uma notificação é semelhante a uma requisição exceto pelo id, que não é necessário porque nenhuma resposta será retornada. Neste caso a propriedade id deve ser omitida ou ser nula.
Exemplos para JSON-RPC Versão 2.0
Nestes exemplos, --> indica os dados enviados a um serviço (requisição), enquanto <-- indica os dados de resposta provenientes de um serviço. (Embora <-- muitas vezes é chamado de resposta em computação cliente-servidor, dependendo da versão JSON-RPC não implica, necessariamente, resposta a um pedido).Chamada de procedimento com parâmetros de posição:
--> {"jsonrpc": "2.0", "method": "subtract", "params": [42, 23], "id": 1} <-- {"jsonrpc": "2.0", "result": 19, "id": 1}
--> {"jsonrpc": "2.0", "method": "subtract", "params": [23, 42], "id": 2} <-- {"jsonrpc": "2.0", "result": -19, "id": 2}
Chamada de procedimento com parâmetros nomeados:
--> {"jsonrpc": "2.0", "method": "subtract", "params": {"subtrahend": 23, "minuend": 42}, "id": 3} <-- {"jsonrpc": "2.0", "result": 19, "id": 3}
--> {"jsonrpc": "2.0", "method": "subtract", "params": {"minuend": 42, "subtrahend": 23}, "id": 4} <-- {"jsonrpc": "2.0", "result": 19, "id": 4}
Exemplo de Notificação:
--> {"jsonrpc": "2.0", "method": "update", "params": [1,2,3,4,5]}
--> {"jsonrpc": "2.0", "method": "foobar"}
Exemplo de Chamada de Procedimento de um Procedimento Não-Existente:
--> {"jsonrpc": "2.0", "method": "foobar", "id": 10} <-- {"jsonrpc": "2.0", "error": {"code": -32601, "message": "Procedure not found."}, "id": 10}
Chamada de Procedimento com JSON inválido:
--> {"jsonrpc": "2.0", "method": "foobar", "params": "bar", "baz"] <-- {"jsonrpc": "2.0", "error": {"code": -32700, "message": "Parse error"}, "id": null}
Chamada de Procedimento com JSON-RPC inválido:
--> [1,2,3] <-- [ {"jsonrpc": "2.0", "error": {"code": -32600, "message": "Invalid Request"}, "id": null}, {"jsonrpc": "2.0", "error": {"code": -32600, "message": "Invalid Request"}, "id": null}, {"jsonrpc": "2.0", "error": {"code": -32600, "message": "Invalid Request"}, "id": null} ]
--> {"jsonrpc": "2.0", "method": 1, "params": "bar"} <-- {"jsonrpc": "2.0", "error": {"code": -32600, "message": "Invalid Request"}, "id": null}
Nenhum comentário:
Postar um comentário