Frete Grátis
  • Google Plus

Web Services Em Php - Apis Para A Web Moderna (Cód: 4925621)

Mitchell,Lorna Jane

NOVATEC

Ooopss! Este produto está temporariamente indisponível.
Mas não se preocupe, nós avisamos quando ele chegar.

Ooops! Este produto não está mais a venda.
Mas não se preocupe, temos uma versão atualizada para você.

Ooopss! Este produto está fora de linha, mas temos outras opções para você.
Veja nossas sugestões abaixo!

R$ 45,00
Cartão Saraiva R$ 42,75 (-5%) em até 1x no cartão ou em até 2x de R$ 22,50 sem juros
Grátis

Cartão Saraiva

Descrição

Não importa que você esteja compartilhando dados entre dois sistemas internos ou criando uma API para que os usuários possam acessar seus dados, este livro prático oferece tudo de que você necessita para desenvolver APIs para web services usando PHP. A autora Lorna Jane Mitchell utiliza exemplos de código, exemplos do mundo real e conselhos baseados em sua ampla experiência para orientá-lo ao longo de todo o processo – desde a teoria subjacente até os métodos para tornar seu serviço robusto. O PHP é ideal tanto para consumir quanto para criar web services. Você aprenderá a usar essa linguagem com JSON, XML e outras tecnologias usadas em web services. Explore o HTTP do ciclo de solicitação/resposta até seus verbos, passando por seus cabeçalhos e cookies. Determine se JSON ou XML é o melhor formato de dados para seu aplicativo. Obtenha conselhos práticos para trabalhar com serviços RPC, SOAP e RESTful. Use uma variedade de ferramentas e técnicas para depuração de web services HTTP. Escolha o serviço que seja mais adequado ao seu aplicativo e aprenda a torná-lo robusto. Aprenda a documentar sua API – e a projetá-la de modo a lidar com erros.

Características

Produto sob encomenda Não
Editora NOVATEC
Cód. Barras 9788575223697
Altura 22.50 cm
I.S.B.N. 9788575223697
Profundidade 1.00 cm
Acabamento Brochura
Número da edição 1
Ano da edição 2013
Idioma Português
Número de Páginas 136
Peso 0.40 Kg
Largura 15.70 cm
AutorMitchell,Lorna Jane

Leia um trecho

Capítulo 1
HTTP

HTTP é o acrônimo de HyperText Transfer Protocol (Protocolo de Transferência
de Hipertexto), e é a base sobre a qual a web está construída.
Toda transação HTTP consiste em uma solicitação e uma resposta. O protocolo
HTTP por si só é composto de várias partes: a URL para a qual a
solicitação foi direcionada, o verbo usado, outros cabeçalhos e códigos
de status e, é claro, o corpo das respostas, que é o que geralmente vemos
quando navegamos pela web usando um navegador.
Ao navegar pela web, no plano ideal, experimentamos uma jornada tranquila,
passando pelos vários locais que queremos visitar. No entanto isso
representa um contraste marcante com o que está acontecendo por trás das
cortinas, à medida que fazemos essa jornada. Ao prosseguirmos, clicando
em links ou fazendo o navegador criar solicitações para nós, uma série de
pequenos “passos” ocorre nos bastidores. Cada passo é composto de um
par solicitação/resposta; o cliente (geralmente, seu navegador ou telefone,
se você estiver navegando na web) faz uma solicitação ao servidor, e o
servidor processa a solicitação e envia a resposta de volta. A cada passo
ao longo do caminho, o cliente faz uma solicitação e o servidor envia a
resposta.
Como exemplo, insira o endereço http://oreilly.com/ em um navegador e você
verá uma página semelhante àquela mostrada na figura 1.1; as informações
desejadas poderão ser encontradas na página, ou os hiperlinks nessa
página nos direcionarão para o caminho em direção a elas.
A página de web chega no corpo da resposta HTTP, mas ela conta somente
parte da história. O restante está em outros locais no tráfego HTTP.
Considere os exemplos a seguir.

Cabeçalho da solicitação:
GET / HTTP/1.1
User-Agent: Mozilla/5.0 (X11; Linux i686) AppleWebKit/537.8 (KHTML, like Gecko)
Chrome/23.0.1246.0 Safari/537.8
Host: oreilly.com
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Encoding: gzip,deflate,sdch
Accept-Language: en-GB,en-US;q=0.8,en;q=0.6

Cabeçalho da resposta:
HTTP/1.1 200 OK
Date: Thu, 15 Nov 2012 09:36:05 GMT
Server: Apache
Last-Modified: Thu, 15 Nov 2012 08:35:04 GMT
Accept-Ranges: bytes
Content-Length: 80554
Content-Type: text/html; charset=utf-8
Cache-Control: max-age=14400
Expires: Thu, 15 Nov 2012 13:36:05 GMT
Vary: Accept-Encoding

Como você pode ver, há uma quantidade enorme de outras informações
úteis sendo trocadas via HTTP, que geralmente não são vistas quando
usamos um navegador. Compreender essa separação entre cliente e servidor,
e os passos executados pelos pares solicitação e resposta, é fundamental
para entender o HTTP e trabalhar com web services. Aqui está
um exemplo do que acontece quando consultamos o Google à procura
de kittens (gatinhos):
1. Fazemos uma solicitação para http://www.google.com/ e a resposta contém
um cabeçalho Location e um código de status igual a 301 que nos
envia para uma página regional de pesquisas; para mim, essa página
é http://www.google.co.uk/ (no Brasil, é http://www.google.com.br).
2. O navegador segue a instrução de redirecionamento (sem confirmação
do usuário; os navegadores redirecionam por padrão), faz
uma solicitação para http://www.google.co.uk/ e recebe a página com a
caixa de pesquisas (Somente por diversão, veja o código-fonte dessa
página. Há muita coisa acontecendo!). Nós preenchemos o campo
e acionamos a pesquisa.
3. Fazemos uma solicitação para https://www.google.co.uk/search?q=kittens
(com mais alguns parâmetros) e obtemos uma resposta que mostra
os resultados de nossa pesquisa.
Na história mostrada aqui, todas as solicitações foram feitas pelo navegador,
em resposta a ações do usuário, embora algumas ocorram nos bastidores,
tais como seguir os redirecionamentos ou solicitar componentes
adicionais. Todos os componentes de uma página, como imagens, folhas
de estilo e outros, são acessados por meio de solicitações separadas, tratadas
por um servidor. Qualquer conteúdo carregado assincronamente
(pelo JavaScript, por exemplo) também gera mais solicitações. Quando
trabalhamos com APIs, nós nos aproximamos mais das solicitações e as
fazemos de modo mais deliberado, mas os mecanismos são os mesmos
que usamos para criar páginas de web bem básicas. Se você já estiver
criando sites, então já deve conhecer tudo o que é necessário para criar
web services!

Clientes e servidores
Anteriormente, neste capítulo, falamos sobre uma solicitação e uma resposta
entre um cliente e um servidor. Quando criamos sites usando PHP,
a parte em PHP sempre corresponde ao servidor. Quando usamos APIs,
construímos o servidor em PHP, mas podemos também consumir APIs
a partir do PHP. É aqui que a situação começa a ficar confusa. Podemos
criar tanto um cliente quanto um servidor em PHP, e as solicitações e as
respostas podem ser tanto de entrada quanto de saída – ou ambas!
Quando construímos um servidor, seguimos padrões semelhantes à
maneira pela qual criamos páginas de web. Quando uma solicitação
chega, usamos o PHP para descobrir o que foi solicitado e elaboramos
a resposta correta. Por exemplo, se desenvolvêssemos uma API para que
os clientes pudessem obter atualizações sobre seus pedidos de maneira
programática, estaríamos construindo um servidor.
Usar o PHP para consumir APIs significa que estamos criando um cliente.
Nosso aplicativo PHP faz solicitações a serviços externos via HTTP e,
então, usa as respostas para seus próprios propósitos. Um exemplo de
um cliente poderia ser uma página que busca seus tuítes mais recentes
e os apresenta.
Não é incomum que um aplicativo seja ambos, um cliente e um servidor,
conforme mostrado na figura 1.2. Um aplicativo que aceite uma solicitação
e, em seguida, chame outros serviços para obter as informações de que
necessita para gerar a resposta estará atuando tanto como cliente quanto
como servidor.
Quando estiver trabalhando em aplicativos como esse, tome cuidado
com a maneira pela qual você dá nome às variáveis que envolvam
a palavra “request” (solicitação) para evitar confusão!
Fazendo solicitações HTTP
Há algumas maneiras diferentes de se comunicar via HTTP. Nesta seção,
abordaremos três delas: Curl, ferramentas em seu navegador e o próprio
PHP. A ferramenta que você escolher dependerá totalmente de sua experiência
e do que você está tentando realizar. Também daremos uma
olhada em ferramentas para inspecionar e depurar o HTTP no capítulo 9.
Os exemplos aqui utilizam um site que está configurado para registrar as
solicitações feitas a ele (http://requestb.in), o que é perfeito para explorar a
forma como diferentes solicitações de API são vistas por um servidor. Para
usá-lo, acesse o site e crie um novo “request bin” (contêiner de solicitações).
Você verá a URL necessária para a qual deverá fazer solicitações e será
redirecionado para uma página que mostra o histórico das solicitações
feitas a esse contêiner.
Outra maneira excelente de tentar fazer diferentes tipos de solicitações é
usar os endereços reservados (http://example.com, http://example.net e http://
example.org), definidos pelo IANA (Internet Assigned Numbers Authority)
em http://www.iana.org/domains/special.

Curl
O Curl é uma ferramenta de linha de comando disponível em todas as
plataformas. Ele nos permite fazer qualquer solicitação imaginável de web
em qualquer formato, repetir essas solicitações e observar, com detalhes,
quais informações, exatamente, são trocadas entre cliente e servidor. Com
efeito, a saída de exemplo no início deste capítulo foi gerada pelo Curl. É
uma ferramenta brilhante e rápida para inspecionar o que está acontecendo
com uma solicitação web, particularmente quando lidamos com
aquelas que estão fora do escopo usual de um navegador.
Em sua forma mais básica, uma solicitação Curl pode ser feita desta
maneira (substitua as URLs pelas suas):
curl http://requestb.in/example
Podemos controlar todos os aspectos da solicitação a ser enviada; alguns
dos recursos mais comumente usados serão apresentados aqui e usados
ao longo de todo este livro para ilustrar e testar as várias APIs mostradas.
Se você já criou sites antes, então saberá a diferença entre solicitações GET
e POST usadas na criação de formulários web. A mudança entre GET, POST e
outros verbos HTTP usando Curl é realizada por meio da opção -X, de
modo que uma solicitação POST pode ser feita especificamente usando o
comando a seguir:
curl -X POST http://requestb.in/example
Existem algumas opções úteis que podem ser usadas para obter mais informações
do Curl, além do corpo da resposta. Experimente usar a opção
–v, pois ela mostrará de tudo: cabeçalhos das solicitações, cabeçalhos das
respostas e todo o corpo da resposta! Porém ela divide a resposta, enviando
as informações de cabeçalho para STDERR e o corpo para STDOUT.
Se a resposta for razoavelmente extensa, poderá ser difícil encontrar uma
determinada informação quando estiver usando Curl. Para ajudar nesse
caso, é possível combinar o Curl com outras ferramentas, como o less ou
o grep; contudo o Curl mostra uma barra de progressão na saída quando
está em operação normal, o que pode causar confusão para essas outras
ferramentas. Para inibir a barra de progressão, utilize a opção –s (mas
tome cuidado, pois ela também inibe a apresentação dos erros do Curl).
Pode ser produtivo usar -s em combinação com –v para criar uma saída
que possa ser enviada a um paginador, como o less, para que ela possa
ser examinada de modo detalhado, por meio de um comando como este:
curl -s -v http://requestb.in/example 2>&1 | less
O 2>&1 extra está presente para enviar a saída de STDERR para STDOUT,
de modo que você possa ver os cabeçalhos e o corpo; por padrão, somente
o STDOUT seria visível ao less.
Trabalhar com a web em geral, e com APIs em particular, significa trabalhar
com dados. O Curl nos permite fazer isso de algumas maneiras
diferentes. O modo mais simples é enviar os dados juntamente com uma
solicitação em pares chave/valor – exatamente como ocorre quando um
formulário é submetido na web – utilizando a opção –d. A opção é usada
tantas vezes quantos forem os campos a serem incluídos:
curl -X POST http://requestb.in/example -d name="Lorna" -d email="lorna@example.
com" -d message="gostei desse tal HTTP"
As APIs aceitam seus dados em diferentes formatos; às vezes, os dados
não podem ser POSTados como um formulário, mas devem ser criados em
formato JSON ou XML, por exemplo. Em casos como esse, todo o corpo
de uma solicitação pode ser organizado em um arquivo e passado para
o Curl. Inspecione a solicitação anterior, e você verá que seu corpo foi
enviado como:
name=Lorna&email=lorna@example.com&message=gostei desse tal HTTP
Em vez de enviar os dados como pares chave/valor na linha de comando,
eles podem ser colocados em um arquivo chamado data.txt (por exemplo).
Esse arquivo pode, então, ser fornecido sempre que a solicitação for feita.
Essa técnica é especialmente útil para evitar linhas de comando muito
extensas ao trabalhar com uma grande quantidade de campos, e ao enviar
dados que não são de formulários, tais como JSON ou XML. Para usar o
conteúdo de um arquivo como corpo de uma solicitação, fornecemos o
nome do arquivo precedido por @ com uma única opção –d para o Curl:
curl -X POST http://requestb.in/example -d @data.txt
Trabalhar com os recursos estendidos do HTTP exige a capacidade de
trabalhar com vários cabeçalhos. O Curl permite enviar qualquer cabeçalho
desejado (é por isso que, do ponto de vista de segurança, nunca
podemos confiar no cabeçalho!), usando a opção –H, seguida do cabeçalho
completo a ser enviado. O comando para definir o cabeçalho Accept para
solicitar uma resposta HTML é:
curl -H "Accept: text/html" http://requestb.in/example
Antes de passar do Curl para outras ferramentas, vamos dar uma olhada
em mais um recurso: como lidar com cookies. Os cookies serão discutidos
com mais detalhes em um capítulo posterior, mas, por enquanto, é importante
saber que os cookies são armazenados pelo cliente e enviados com
as solicitações, e que novos cookies podem ser recebidos juntamente com
cada resposta. Os navegadores enviam cookies com as solicitações como
comportamento padrão, mas no Curl é preciso fazer isso manualmente,
pedindo ao Curl que armazene os cookies em uma resposta e depois os
utilize na próxima solicitação. O arquivo que armazena os cookies chama-
-se "cookie jar” (pote de biscoitos); está claro que até mesmo os geeks em
HTTP possuem senso de humor.
Para receber e armazenar cookies de uma solicitação digite:
curl -c cookiejar.txt http://requestb.in/example
A essa altura, cookiejar.txt pode ser alterado da maneira que você julgar
adequada (novamente, nunca confie em informações provenientes de fora
do aplicativo!) e, em seguida, enviado ao servidor com a próxima solicitação
que você fizer. Para isso, use a opção –b e especifique o arquivo no
qual os cookies poderão ser encontrados:
curl -b cookiejar.txt http://requestb.in/example
Para capturar cookies e enviá-los novamente junto a cada solicitação, use
as opções -b e -c, fazendo referência ao mesmo arquivo cookiejar. Dessa
maneira, todos os cookies de entrada serão capturados e enviados para
um arquivo e serão enviados de volta ao servidor em qualquer solicitação
subsequente, comportando-se exatamente como em um navegador.

Ferramentas para navegadores
Todas as versões mais recentes dos navegadores modernos (Chrome, Firefox,
Opera, Safari, Internet Explorer) possuem ferramentas embutidas ou
plug-ins disponíveis para ajudar a inspecionar o HTTP que estiver sendo
transferido; para serviços simples, talvez você ache que as ferramentas de
seu navegador sejam uma maneira acessível de trabalhar com uma API.
Essas ferramentas variam entre os navegadores e são constantemente
atualizadas, mas aqui estão algumas ferramentas favoritas para que você
possa ter uma ideia.
No Firefox, essa funcionalidade é proporcionada pelo Developer Toolbar
(Barra de Ferramentas do Desenvolvedor) e por vários plug-ins. Muitos
desenvolvedores de web estão familiarizados com o FireBug (http://getfirebug.
com/), que possui algumas ferramentas úteis, mas há outra ferramenta
desenvolvida especificamente para mostrar todos os cabeçalhos de todas
as solicitações feitas pelo seu navegador: o LiveHTTPHeaders (http://livehttpheaders.
mozdev.org/). Ao usá-lo, podemos observar todos os detalhes
de cada solicitação, conforme pode ser visto na figura 1.3.
Todos os navegadores oferecem alguma maneira de inspecionar e alterar
os cookies que estiverem sendo usados para solicitações em um determinado
site. No Chrome, por exemplo, essa funcionalidade é oferecida por
uma extensão que se chama “Edit This Cookie” (Editar este cookie) e por
outras extensões similares. Ela mostra os cookies já criados e permite que
você os edite ou apague – e também permite adicionar novos cookies. Dê
uma olhada nas ferramentas de seu navegador favorito e veja os cookies
enviados pelos sites que você visita com mais frequência.
Às vezes, cabeçalhos adicionais devem ser incluídos em uma solicitação,
como, por exemplo, quando enviamos cabeçalhos de autenticação ou
cabeçalhos específicos para indicar ao serviço que queremos fazer uma
depuração extra. Com frequência, o Curl será a ferramenta correta para
esse tipo de tarefa, mas também é possível adicionar os cabeçalhos em
seu navegador. Diferentes navegadores possuem diferentes ferramentas;
no Chrome, experimente usar uma extensão chamada ModHeader, vista
na figura 1.4.

PHP
Não é de se surpreender que haja mais de uma maneira de lidar com solicitações
HTTP usando PHP, e cada um dos frameworks também oferece
suas próprias contribuições. Esta seção está focada no PHP básico e analisa
três diferentes maneiras de trabalhar com APIs: usando a extensão Curl
que já vem com o PHP, usando a extensão pecl_http e fazendo chamadas
HTTP usando o tratamento de streams do PHP.
Anteriormente neste capítulo, discutimos uma ferramenta de linha de
comando chamada Curl (veja “Curl” na página 18). O PHP possui seus
próprios wrappers (empacotadores) para o Curl, portanto podemos usar
a mesma ferramenta de dentro do PHP. Uma solicitação GET simples tem
o seguinte aspecto:
<?php
$url = "http://oreilly.com";
$ch = curl_init($url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
$result = curl_exec($ch);
curl_close($ch);
O exemplo anterior representa o modo mais simples, definindo a URL,
fazendo uma solicitação para sua localização (por padrão, essa é uma
solicitação GET) e capturando a saída. Observe o uso de curl_setopt();
essa função é usada para definir várias opções diferentes sobre o
funcionamento do Curl e possui uma documentação excelente e bastante
abrangente em http://php.net. Nesse exemplo, ela foi usada para configurar a
opção CURLOPT_RETURNTRANSFER para true, o que faz o Curl retornar os resultados
da solicitação HTTP, em vez de apresentá-los. Na maioria dos casos, essa
opção deve ser usada para capturar a resposta, em vez de deixar que o
PHP a ecoe à medida que ocorrer.
Podemos usar essa extensão para fazer todos os tipos de solicitações HTTP,
incluindo enviar cabeçalhos personalizados, enviar dados no corpo e
usar diferentes verbos para fazer nossa solicitação. Dê uma olhada neste
exemplo, que envia alguns campos de formulário e um cabeçalho Content-
Type com a solicitação POST:
<?php
$url = "http://requestb.in/example";
$data = array("name" => "Lorna", "email" => "lorna@example.com");
$ch = curl_init($url);
curl_setopt($ch, CURLOPT_POST, 1);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));
curl_setopt($ch, CURLOPT_HTTPHEADER, array('Content-Type: application/json'));
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
$result = curl_exec($ch);
curl_close($ch);
Novamente, curl_setopt() é usado para controlar os vários aspectos da
solicitação que enviamos. Nesse caso, uma solicitação POST é feita configurando-
se a opção CURLOPT_POST com 1 e passando os dados que pretendemos
enviar na forma de um array para a opção CURLOPT_POSTFIELDS. Também
definimos um cabeçalho Content-Type, que indica ao servidor o formato
em que estão os dados do corpo; os vários cabeçalhos serão discutidos
com mais detalhes no capítulo 3.
A extensão Curl do PHP não é a interface mais fácil de ser usada, embora
tenha a vantagem de estar disponível de maneira confiável. Uma ótima
alternativa, caso você controle suas próprias plataformas, é adicionar a
extensão pecl_http do PECL (http://pecl.php.net/package/pecl_http). Ela oferece
uma maneira muito mais intuitiva de trabalhar e possui tanto funções
quanto interfaces orientadas a objetos. Por exemplo, aqui está o exemplo
anterior, dessa vez usando pecl_http:
<?php
$url = "http://requestb.in/example";
$data = array("name" => "Lorna", "email" => "lorna@example.com");
$request = new HTTPRequest($url, HTTP_METH_POST);
$request->setPostFields($data);
$request->setHeaders(array("Content-Type" => "application/json"));
$request->send();
$result = $request->getResponseBody();
Essa extensão funciona de maneira mais elegante por meio da criação de
um objeto HTTPRequest, em seguida trabalhando com as propriedades desse
objeto, antes de chamar seu método send(). Uma vez que a solicitação tiver
sido enviada, o corpo da resposta será acessado por meio da chamada ao
método getResponseBody().
Por fim, vamos dar uma olhada em mais uma maneira de fazer solicitações
HTTP a partir do PHP: usando as capacidades do PHP de lidar com streams,
juntamente com as funções de arquivo. Em sua forma mais básica,
isso significa que, se allow_url_fopen estiver habilitado (consulte o manual
do PHP em http://www.php.net/manual/en/filesystem.configuration.php#ini.allow-
-url-fopen), será possível fazer uma solicitação GET usando file_get_contents():
<?php
$result = file_get_contents("http://oreilly.com");
Podemos tirar vantagens do fato de o PHP conseguir lidar com uma variedade
de protocolos diferentes (HTTP, FTP, SSL e outros) e com arquivos
usando streams. As solicitações GET simples são fáceis, mas e quando
houver algo mais complicado? Aqui está um exemplo que faz a mesma
solicitação POST com cabeçalhos, ilustrando como usar vários aspectos da
funcionalidade de streams:
<?php
$url = "http://requestb.in/example";
$data = array("name" => "Lorna", "email" => "lorna@example.com");
$context = stream_context_create(array(
'http' => array(
'method' => 'POST',
26 Web Services em PHP
'header' => array('Accept: application/json',
'Content-Type: application/x-www-form-urlencoded'),
'content' => http_build_query($data)
)
));
$result = file_get_contents($url, false, $context);
As opções são definidas como parte do contexto que criamos para determinar
como a solicitação deverá funcionar. Em seguida, quando o PHP
abrir o stream, ele usará as informações fornecidas para determinar como
lidará corretamente com o stream – incluindo enviar os dados fornecidos
e definir os cabeçalhos corretos.
Como você pode observar, há algumas opções diferentes para lidar com
o HTTP, tanto a partir do PHP quanto da linha de comando, e você verá
todas elas sendo usadas ao longo deste livro. Todas essas abordagens
estão voltadas para o PHP padrão, mas se você estiver trabalhando com
um framework, provavelmente ele irá oferecer algumas funcionalidades
parecidas; todos os frameworks estarão encapsulando um desses métodos,
portanto será útil ter um bom domínio do que está acontecendo
por dentro desses encapsulamentos. Após experimentar vários exemplos,
é comum eleger um com o qual você trabalhará mais do que com os
demais; todos eles podem executar a mesma tarefa, de modo que aquele
que você eleger será o resultado tanto de sua preferência pessoal quanto
das ferramentas que estiverem disponíveis (ou que podem se tornar disponíveis)
em sua plataforma.

Avaliações

Avaliação geral: 0

Você está revisando: Web Services Em Php - Apis Para A Web Moderna