Atualização: Segunda parte do artigo de JavaFX aqui, e veja sobre nosso curso de Adobe Flex e RIA aqui.

No último Falando em Java apresentei uma palestra sobre JavaFX, apresentando a tecnologia e especulando sobre o futuro desse mercado. É a grande aposta da Sun no mercado das Rich Internet Applications – RIA, onde o Adobe Flex – que abordamos no curso FJ-29 – hoje lidera.

O JavaFX foi apresentado[1] pela Sun no último JavaOne em maio desse ano como uma nova estratégia da empresa para levar o Java ao desenvolvimento fácil de interfaces ricas com o usuário. Dois produtos foram anunciados e novidades foram prometidas para breve. Hoje o que temos é o JavaFX Mobile e o JavaFX Script.

O JavaFX Mobile é um novo sistema operacional baseado no kernel do Linux e com uma JVM portátil que pretende levar o Java ao novo mercado dos “smartphones” a la iPhone. Seria voltado ao desenvolvimento fácil de aplicativos bonitos e usáveis em ambiente móvel.

Já o JavaFX Script é uma nova linguagem de programação pensada para o desenvolvimento de interfaces Swing/AWT/Java2D de forma mais fácil do que hoje. A idéia da Sun é atacar o mercado Desktop, onde o Java tem ganho certo mercado ultimamente, mas também atacar o Adobe Flex e o MS Silverlight no mercado de Rich Internet Applications, as RIAs.

Hoje o mercado de aplicativos ricos embutidos no navegador é dominado pelo Adobe Flash (diretamente ou através do Flex, por exemplo). Os Applets foram a primeira tentativa da Sun de atacar esse mercado lá no começo da década de 90 mas o Java não vingou nesse mercado; o JavaFX hoje é a tentativa de retomá-lo. Isso ao mesmo tempo que a Microsoft entra com o Silverlight e onde JavaScript/AJAX consegue fazer já boa parte do que essas tecnologias se propõe a fazer.

Alguns problemas frequentemente apontados para o fracasso dos Applets:

Todas essas questões já estão sendo vislumbradas pela Sun. O Java hoje não é lento (era, uma década atrás) e estima-se que 91% dos PCs possuam Java instalado. Mas ainda temos problemas: o tempo de Startup da JVM ainda é alto (em grande parte devido às operações de I/O para subir a VM) e o download é grande. Ambas as questões devem ser solucionadas com a chamada Consumer JRE[2], uma JRE modular onde se baixa apenas os componentes necessários para rodar as aplicações normais e módulos extra são baixados automaticamente sob demanda.

As questões da dificuldade de desenvolvimento e falta de boas ferramentas são justamente o foco do JavaFX.

O JavaFX Script é uma linguagem de script declarativa e orientada a objetos, com sintaxe simplificada para desenvolvimento de GUIs. É bem diferente do Java tradicional mas já possui plugins para Eclipse e Netbeans para facilitar o desenvolvimento.

Veja uma comparação entre um Hello World em Swing e em JavaFX:

// em Swing
public class HelloSwing {
	public static void main(String[] args) {
		JFrame frame = new JFrame("Meu programa em Swing");
		JLabel label = new JLabel("Olá Mundo");
		Dimension d = new Dimension(300, 50);
		frame.setSize(d);
		frame.add(label);
		frame.setVisible(true);
	}
}

// em JavaFX
Frame {
	title: "Meu programa em javafx"
	width: 200
	height: 50
	visible: true
	content: Label {
		text: "Olá mundo"
	}
}

Note a semelhança com linguagens de marcação como XML, onde a forma declarativa e aninhada de se agrupar os componentes facilita o desenvolvimento e a leitura do programa.

Você pode executar esse exemplo através do Java Web Start, clicando aqui.

Na palestra, desenvolvi um pedaço de uma loja virtual com efeitos 3D e animações. Usamos nesse exemplo recursos avançados do JavaFX como binding de componentes para classes de modelo, buscas otimizadas em arrays, triggers para eventos em variáveis, Java2D, animações e outros. No próximo artigo trato desses assuntos com mais detalhes, mostro como configurar o ambiente de desenvolvimento, bem como outras coisas como concorrência de Threads, integração com o Java e conectividade.

Você pode executar o demo clicando aqui.

Os exemplos são apresentados em Java Web Start em formato jar. O ambiente de execução do JavaFX é distribuído junto e possui 2MB; nas futuras versões do JRE, o JavaFX deverá vir embutido, diminuindo consideravelmente o tamanho do download.

Para ver os fontes, basta descompactar o jar e ver os arquivos .fx. O código fonte é de propriedade da Caelum, exceto o componente DisplayShelf desenvolvido por Chris Oliver e liberado no Site dele. [5]

Até o próximo artigo!

Atualização: Segunda parte do artigo de JavaFX aqui

Algumas referências:

[1] Apresentação do Chris Oliver sobre o JavaFX/F3 no JavaOne

[2] Palestra apresentada no JavaOne sobre o mercado Desktop Java e a Consumer JRE

[3] Tutorial para iniciantes em JavaFX

[4] Especificação da linguagem JavaFX Script

[5] Blog do Chris Oliver, desenvolvedor do JavaFX

[6] Projeto OpenJFX com a implementação do JavaFX e muito material

Criando WebServices num servidor de aplicação como glassfish ou jboss ficou muito fácil. Basta escrever um Session Bean Stateless e usar as anotações do pacote javax.xml.ws que JavaSE 6 já fornece. Veja o exemplo:

@Stateless
@Remote(Oi.class)
@WebService
public class OiMundo {
  
  @WebMethod
  public String oi(String nome) {
    return "Hallo " + nome;
  }
}

public interface Oi { 
  String oi(String nome);
}



Pronto, fazendo deploy dessa classe no servidor do aplicação cria automaticamente o WebService e disponibiliza o WSDL. Aqui tem uma discussão mais ampla sobre webservices em um servidor de aplicação.

Sem servidor de aplicação

Com javaSE 6 nas mãos você nem precisa de um servidor de aplicação, nem mesmo um web server! Basta usar as anotações @WebService e @WebMethod na sua classe e a ferramenta apt (annotation processing tool – não o apt do Debian!, encontra-se na pasta bin do jdk) para gerar um WebService.

A conhecida classe:

@WebService
public class OiMundo {
  
  @WebMethod
  public String oi(String nome) {
    return "Hallo " + nome;
  }
}

O comando (imagina a classe OiMundo está no pacote br.com.caelum.ws):

$apt br/com/caelum/ws/OiMundo.java

gera um pacote br.com.caelum.ws.javaws com duas classes, uma classe Oi.java para os parâmetros do WebService (no nosso caso String nome do método oi) e outra OiResponse.java que representa o retorno.

Falta publicar o serviço/endpoint e iniciá-lo:

public class PublicaService {
  
  public static void main(String[] args){
    OiMundo service = new OiMundo();
    Endpoint endpoint = Endpoint.publish("http://localhost:8080/oi", service);        
  }
}

Pronto, o WebService está rodando sem servidor de aplicação nem web container. Tudo isso com javaSE 6 jdk. Para acessar a wsdl dele, usa-se o URL:

http://localhost:8080/oi?wsdl

Claro que isso não substitui o servidor por questões de performance, configuração e manutenção, mas é útil na hora de desenvolver e testar um serviço rapidamente.

Cliente

Para criar o cliente do serviço, javaSE 6 já vem com as ferramentas necessárias. Precisamos usar o wsimport (na pasta bin do jdk) para gerar as classes do cliente. Com o serviço rodando, fazemos na linha de comando:

$wsimport -keep -p br.com.caelum.cliente http://localhost:8080/oi?wsdl

A opção keep não apaga os arquivos fontes e p gera as classes dentre do pacote especificado.

Para chamar o serviço pelas classes geradas, escreva a seguinte classe dentro do pacote br.com.caelum.cliente:


public class TesteServico {
  
  public static void main(String[] args) {
    
  br.com.caelum.cliente.OiMundo port = new OiMundoService().getOiMundoPort();
  System.out.println(port.oi("Johann"));
  }
}

Repare que a classe OiMundo foi gerada pelo wsimport e é uma interface, não confundir com o serviço OiMundo que é uma implementação.

WebServices no WebContainer

Num WebContainer, usando Tomcat ou Jetty, é preciso usar um framework para criar um WebService. Já foi mencionado o Xfire nesse mesmo blog (que agora faz parte do projeto CXF), mas existem outros como o AXIS da Apache ou Metro do java.net. Metro é a implementação usada pelo Glassfish.

Vamos usar o Metro para criar um WebService dentro numa aplicação web usando Tomcat.

Faça o download do metro, instale e copie os jars da pasta metro/lib para a pasta tomcat/shared/lib, ou então para o lib exclusivo do seu projeto. São os seguintes:

• webservices-api.jar
• webservices-extra.jar
• webservices-tools.jar
• webservices-extra-api.jar
• webservices-rt.jar
• wstx-services.war

Crie um aplicação web comum e adicione a classe TchauMundo no seu projeto com as anotações:

@WebService
public class TchauMundo {

  @WebMethod
  public String tchau(String nome) {
    return "Tschüss " + nome;
  }
}

Gere novamente o serviço e execute o seguinte comando na pasta src do seu projeto:

$apt br/com/caelum/ws/TchauMundo.java

As classes geradas devem ficar na pastas WEB-INF/classes.

Agora é preciso registrar um servlet e listener que recebe as requisições do WebService. O web.xml:

<web-app version="2.4" xmlns="http://java.sun.com/xml/ns/j2ee">
<listener>
<listener-class>com.sun.xml.ws.transport.http.servlet.WSServletContextListener</listener-class>
</listener>
<servlet>
<servlet-name>webServiceServlet</servlet-name>
<servlet-class>com.sun.xml.ws.transport.http.servlet.WSServlet</servlet-class>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>webServiceServlet</servlet-name>
<url-pattern>/tchau</url-pattern>
</servlet-mapping>
</web-app>


Além disso, falta um outro xml (mais um!) com a definição do serviço/endpoint. O arquivo sun-jaxws.xml deve estar na pasta WEB-INF. Veja o exemplo:


<endpoints xmlns='http://java.sun.com/xml/ns/jax-ws/ri/runtime' version='2.0'>
<endpoint
name='tchauMundo'
implementation='br.com.caelum.ws.TchauMundo'
url-pattern='/tchau'/>
</endpoints>


Fazendo o deploy e acessando a seguinte url:

http://localhost:8080/ws/tchau

temos o nosso serviço:

A entrada de uma API para produzir e consumir webservices no Java SE 6 gerou muita polêmica, por inflar o tamanho da Java RE e ser pouco necessário na maioria dos projetos. Apesar disso, ter uma API unificada, além de ferramentas facilitadoras, possibilita uma mais fácil adoção de webservices por parte dos desenvolvedores Java.

O Falando em Java 2007 foi um sucesso, contando com quase 200 participantes no centro universitário FEI. Foi uma tarde de palestras, tecnologia, confraternização e troca de conhecimento. Você pode conferir algumas opiniões nesse post do GUJ, que falam desde as diversas palestras ao incrível coffee break com direito a mousse de maracujá e tortas!

Depois da abertura, contamos com a presença do Phillip Calçado falando dos conceitos da web 2.0. E este foi o tema do evento, onde os instrutores da Caelum apresentaram tecnologias e bibliotecas para AJAX, diferentes formas integração de serviços web, gerenciamento de conteúdo por tags com o Lucene e por último o concorrente do Flex e SilverLight: o JavaFX.

Ao fim do evento tivemos diversos sorteios, que foram de livros, kits, assinaturas da MundoJava até dois Nintendo DS! Postaremos cada uma das palestras neste blog, juntamente com as demos e códigos relacionados. Agradecemos a todos e esperamos ver vocês no próximo encontro.