blog.2solutions.com.br

Abaixo estou listando um passo-a-passo para a implementação de requisitos de um sistema, utilizando a arquitetura Java da 2Solutions.

Em primeiro lugar, os frameworks que adotamos para o desenvolvimento são :

Struts2 : View e Controller
JPA (Hibernate) : Persistência
Spring : IoC e DI

Os frameworks se relacionam, facilitando o nosso trabalho assim, os trabalhos iniciam assim:

Resumo de Levantamento de requerimentos

A primeira coisa a fazer no desenvolvimento de software é o levantamento/descobrimente de requerimentos. Essas informações são bem armazenadas na forma de diagramas de caso de uso.

A ideia dos casos de uso é ser o mais simples possivel, apenas documentando as funcionalidades, deixando de descreve-las a fundo. O caso de uso deve ser documentado com um usuario e quais funcionalidades do sistema ele ira interagir, por exemplo :

Ator : Gerente de contas
Caso de Uso : Cadastrar novo cliente

Se o caso de uso ‘cadastrar novo cliente’ for um pouco complexo, repare bem, SE for complexo, dai sua lógica deve ser armazenada em um diagrama de atividades. Ou podemos utilizar cenários para armazenar as situações.

Junto a isso pode ser feito protótipos para ser apresentado ao cliente e este levantar mais informações pertinentes. Nesta fase não temos codigo compilado, apenas telas e informações sobre a funcionalidade. Podemos agilizar isso com reunioes, ou com viagens ao codigo e planos de teste.

Modelagem

A medida que as funcionalidades vão sendo descobertas o próximo passo é ir descrevendo as entidades encontradas. Essa descrição pode ser feita direto no banco de dados, ou pode ser feita associando classes.

Na 2Solutions nós fazemos as classes e anotamos seu nome e seus atributos para que as tabelas sejam geradas.

Por tanto o primeiro passo é fazer a modelagem das classes.

Uma forma de verificar se o modelo esta bem feito é criando testes unitários. Teste unitário é apenas garantir que aquela funcionalidade especifica da sua entidade como ‘inserir no banco’ esta funcionando. O ideal é criar para cada entidade testes unitarios de insert, select, update e delete.

Action/Jsp

Depois que suas classes estiverem corretamente modeladas e testadas, dai partimos para as interfaces. Por padrão toda entidade criada pode ser manipulada utilizando interfaces genéricas. Para que isso funcione voce precisa.

1 - Criar o arquivo EntidadeAction no pacote actions, seguindo o modelo de uma action padrão :

public class ClienteAction extends GenericAction {
public ClienteAction(GenericService service){
super(service);
}
}

2 - Com a entidade criada, o próximo passo é fazer as associações no Spring. O Spring é o responsável por cuidar da parte de instanciar objetos e seta-los nas entidades. Com o Spring temos benefícios imediatos como a IoC (Inversion Of Control) e a DI (Dependency Injection)

<!--
Entitys
-->
<bean id="clienteEntity" class="br.gov.sp.sucen.controledengue.entity.Cliente" scope="session"/>

<!--
Services
-->
<bean id="clienteService" class="br.gov.sp.sucen.controledengue.service.GenericServiceImpl">
<constructor-arg>
<value>br.gov.sp.sucen.controledengue.entity.Cliente </constructor-arg>
</bean>

<!--
Actions
-->
<bean id="clienteAction" scope="prototype" class="br.gov.sp.sucen.controledengue.action.ClienteAction">
<constructor-arg ref="clienteService" />
<property name="entity" ref="clienteEntity" />
</bean>

3 - Com tudo configurado a sua entidade ja esta com as operações basicas de manipulação prontas.

http://localhost:8080/MeuProjeto/cliente!novo.action
http://localhost:8080/MeuProjeto/cliente!pesquisar.action
http://localhost:8080/MeuProjeto/cliente!salvar.action
http://localhost:8080/MeuProjeto/cliente!remover.action
http://localhost:8080/MeuProjeto/cliente!editar.action
http://localhost:8080/MeuProjeto/cliente!visualizar.action

Personalizando

Procure sempre criar interfaces baseadas nas entidades. Com recursos como AJAX, nós podemos ter uma tela desempenhando varias funções no mesmo ambiente. Por exemplo, se na interface de cadastro de cliente você precisar mostrar uma lista com os vendedores, para selecionar qual o vendedor desse cliente, o processe ficaria assim.

Combo (<select>)

<%
ObjectFactory factory = StrutsSpringObjectFactory.getObjectFactory();
GenericService service = (GenericService)factory.buildBean("vendedorService",null);
pageContext.setAttribute("propertyListName",service.buscarTodos());
%>
<s:select name="entity.vendedor.id" label="Selecione Vendedor" list="%{#attr.propertyListName}" listKey="id" headerKey="" headerValue=""/>

Eu particularmente não gosto muito de Scriptlets no JSP, porém não gosto de ter que ficar criando uma colecao de retorno em toda Action

Radiobuttons (Sim/Nao)

<s:radio label="Ativo" list="#{'true':'Sim','false':'Nao'}" name="entity.ativo"/>

Checkbox (Lista de Elementos)

<%
GenericService service = (GenericService)factory.buildBean("vendedorService",null);
List all = service.buscarTodos();
pageContext.setAttribute("propertyListName",all);
%>
<s:checkboxlist name="entity.vendedores" label="Selecione vendedores" list="%{#attr.propertyListName}"/>

JSON (JavaScript Object Notation) is a lightweight data-interchange format. It is easy for humans to read and write. It is easy for machines to parse and generate. (http://www.json.org/).

Devido ao advento de tecnologias como AJAX, a forma como sua tela em HTML deve conversar (via JavaScript) com o servidor teve alguns conceitos alterados. O principal é que apesar de a tarefa de enviar dados para o servidor continuar sendo a mesma, o retorno precisa ser decodificado para identificar os valores que foram retornados. Formas de retorno:

1 - O servidor enviar uma sequencia de valores com um separador, por exemplo :

Rua Joao da Pitangueira|231|Bairro XYZ|São Paulo

Prós :
1 - Quantidade de informação pequena, agilizando o retorno
2 - Facil recuperação dos valores, bastando apenas um split(’|')

Contras :
1 - Manutenção ineficiente ao adicionar ou remover informações devido a perda da identificação dos campos

2 - O servidor envia um XML


<endereco>
<rua>Rua Joao da Pitangueira</rua>
<numero>231</numero>
<bairro>Bairro XYZ</bairro>
<cidade>São Paulo</cidade>
</endereco>


Prós :
1 - Facil identificação de campos/valores navegando no XML.
2 - XML é padrão de mercado no assunto transmissão de mensagens (vide WebServices)

Contra :
1 - Necessita conhecer uma API de parse XML para Javascript.
2 - Gerar o XML de saida de seus objetos/dados do lado do servidor. (conhecer uma biblioteca para isso)
3 - Aumento do tamanho da resposta devido a inclusão das TAGs XML.

3 - O Servidor envia uma resposta JSON

O processo é bem simples. O servidor ao enviar os dados para o cliente gera uma mensagem em formato JSON, decodificando o objeto/dado em questão. Para isso é interessante a utilização de uma biblioteca (http://json-lib.sourceforge.net/usage.html).


class MyBean{
private String name = "json";
private int pojoId = 1;
private char[] options = new char[]{'a','f'};
private String func1 = "function(i){ return this.options[i]; }";
private JSONFunction func2 = new JSONFunction(new String[]{"i"},"return this.options[i];");

// getters & setters
...
}

JSONObject jsonObject = JSONObject.fromObject( new MyBean() );
PrintWriter out = response.getWriter();
out.println( jsonObject );
/* prints
{"name":"json","pojoId":1,"options":["a","f"],
"func1":function(i){ return this.options[i];},
"func2":function(i){ return this.options[i];}}
*/


No lado do cliente é necessário decodificar esta mensagem JSON. Como o JSON é um subset do Javascript existe uma certa facilidade, necessitando apenas entender como é a estrutura do JSON.

var myObject = eval('(' + myJSONtext + ')');

Assim você ja tem a estrutura do seu objeto criado na variavel myObject.

Prós :
1 - Linguagem leve para a representação dos dados.
2 - Facilidade de leitura e escrita (com as bibliotecas).

Contra :
1 - Necessidade de utilizar uma biblioteca no lado do servidor.
2 - Apesar de simples, é uma nova linguagem.

Conclusão

A forma de transmissão de mensagens entre o client e server da sua aplicação deve ser escolhida com muita caltela pois esta pode levar a problemas de performance, ou segurança ou necessidade de recursos de banda. O JSON entra para servir de facilitador pois possue o melhor de dois mundos, tanto a parte lightweight quanto a parte performatica (um parser JSON é muito mais rapido que um XML).

Eu sugiro a leitura tanto do site oficial http://www.json.org, para entendimento da estrutra e particularidades, quanto do artigo http://blogs.msdn.com/mikechampion/archive/2006/12/21/the-json-vs-xml-debate-begins-in-earnest.aspx que debate um comparativo entre JSON e XML.

Trabalhar com XML envolve a criação/leitura de um documento texto. Esta é a definição mais simples para as tarefas de XML, porém destas podemos ramificar em diversos parsers e validadores que a complexidade aumenta em progressão geométrica.

Neste texto que escrevo quero destacar a leitura de um XML via Javascript. Você ira precisar disto em toda situação que o servidor envia para o cliente um arquivo XML que deve ser interpretado.

Existem inumeros frameworks para isso, inclusive outras estratégias mais elegantes como a transformação do XML com XSL.

Como AJAX esta na moda vamos contextualizar nas chamadas assincronas o XML.

Primeiramente, adicione a API DOM no seu bookmark (http://www.howtocreate.co.uk/tutorials/javascript/domstructure). Este link não é do W3.com mas detalha de forma bem estruturada a API.

1 - Declarando um XML


var responseXML = '<response>'+
'<messages>'+
'<total>30</total>'+
'<message>'+
'<sender>Joao do Caminhao</sender>'+
'<text>Quero saber mais...</text>'+
'</message>'+
'<message>'+
'<sender>Atendente 01</sender>'+
'<text>Ja irei verificar senhor</text>'+
'</message>'+
'</messages>'+
'<status>O usuario esta digitando uma mensagem</status>'+
'<fault>skjdcnskjdncjksdnc</fault>'+
'</response>';


Declarando uma string com conteudo XML.

2 - Utilizando o parser do browser

Alguém precisa fazer o trabalho da leitura do elementos/atributos do XML. Todo browser que suporta elementos DOM possue um parser. Para você poder utiliza-lo pode declarar as linhas abaixo para criar uma referencia do documento associado ao parser. Estas linhas ja indicam parsers Cross-browsers.


var xmldoc = null;
if (window.ActiveXObject) {
xmldoc = new ActiveXObject("Microsoft.XMLDOM");
xmldoc.async="false";
xmldoc.loadXML(responseXML);
} else {
var parser = new DOMParser();
xmldoc = parser.parseFromString(responseXML,"text/xml");
}


O elemento de resultado é o xmldoc e é a partir dele que iremos percorrer os nós do XML.

3 - Acessando os Nodes

var response = xmldoc.getElementsByTagName('response');

No exemplo acima eu quero recuperar a tag do XML. Porem assim como a assinatura do xmldoc indica o resultado é um vetor. Detalhe, se não existir esta tag, é retornado um vetor com tamanho 0.

alert(response[0].tagName)

tagName ira retornar o nome da tag. No entanto o mais importante dela são os nós internos ou seu valor.

Os Nodes internos a esta tag são acessados com outro método.


if(response[0].hasChildNodes()){
for(var k = 0 ; k < response[0].childNodes.length ; k++){
alert(response[0].childNodes[k]);
alert(response[0].childNodes[k].nodeValue);
}
}


Tudo ira depender de como esta formado o seu documento XML. Porem com isso ja podemos montar metodos auxiliares para facilitar a navegação nos Nodes.

4 - Utilizando tudo isso com AJAX

Imagine a situação que uma chamada assíncrona ira retornar as informações de endereço, baseado em um numero de cep.

XML Resultado

Av. Javascript DOM
EMACS
São Paulo
SP

Para recuperar os dados pode-se usar variações do método abaixo :


var cep = xmldoc.getElementsByTagName('response')[0]; //Ja retornar o Node
if(cep.hasChildNodes()){
for(var k = 0 ; k < cep.childNodes.length ; k++){
var valor = cep.childNodes[k].nodeValue;
if(cep.childNodes[k].tagName == 'bairro'){
//..>Atribuir o valor no campo bairro….
}
//…>E assim por diante
}


Não importa se você é um Jedi em linguagens de programação de alto nível como Java e C++. Quando o assunto é desenvolvimento para Web infelizmente precisamos conhecer Javascript.

Por que do infelizmente?

Porque utilizamos Javascript justamente para criarmos uma dinâmica maior do lado do cliente, e assim acabamos chamando funções do ambiente do Navegador, algo como pesquisar um campo, alterar um label de botão ou abrir uma nova janela. Algumas destas funções são particulares de cada Navegador, e isto levou muita gente a duplicar metodos pois os mesmos teriam que possuir um ‘if’ para o navegador IE e o ‘else’ para outros. Isso quando não tinha os ‘else if’.

Hoje muita coisa evoluiu porém eu gostaria de dar algumas dicas para o pessoal que anda batendo cabeça com Javascript.

Tipos

Javascript faz a tipagem em tempo de execução, ou seja, não existem declarações de tipo no seu codigo.


var i = 10;
var j = "Javascript";


Assim nas declarações de métodos tambem nao existe os tipos de retorno.


function mostrarData(){
return "28/06/1979";
}


Gostou ? Eu não gosto muito pois estou acostumado a forte tipagem do Java, que é um recurso interessante inclusive para a parte de manutenção de código.

Varargs

Para quem conhece Java 5.0 vai entender fácil. Existe aquele termo conhecido como sobrecarga de metodo que é voce declarar varios metodos com o mesmo nome, variando sua lista de argumentos. No Javascript o mais utilizado não é a sobrecarga e sim a declaração do método com a passagem de parametro definida em tempo de execução.


function somarNumeros(a,b,c){
var soma = 0;
if(a){
soma += a;
}
if(b){
soma += b;
}
if(c){
soma += c;
}
}

somarNumeros(2);
somarNumeros(2,5);
somarNumeros(2,8,9);


Interessante não? De fato facilita no desenvolvimento, no entanto é um recurso que deve ser utilizado com muito cuidado pois não existe a obrigatoriedade de nenhum parametro, o que pode comprometer o algoritmo do metodo.

AJAX

Existem inumeros tutoriais de AJAX na internet. Quero apenas destacar neste item que sem Javascript você nao vai conseguir aproveitar desta nova onda (a nao ser com a utilização de algum framework). Segue um exemplo.


function AJAXInteraction(url, callback, returnParam) {

var req = init();
req.onreadystatechange = processRequest;

function init() {
try {
return new XMLHttpRequest();
} catch (trymicrosoft) {
try {
return new ActiveXObject("Msxml2.XMLHTTP");
} catch (othermicrosoft) {
try {
return new ActiveXObject("Microsoft.XMLHTTP");
} catch (failed) {
alert("Error initializing XMLHttpRequest!");
}
}
}
}

function processRequest () {
// readyState of 4 signifies request is complete
if (req.readyState == 4) {
// status of 200 signifies sucessful HTTP call
if (req.status == 200) {
if (callback){
callback(req.responseText);
}
}
}
}

this.doGet = function() {
// make a HTTP GET request to the URL asynchronously
req.open("GET", url, true);
req.send(null);
}
}

function buscarClientes() {
var url = "/servlet/ajaxPedido?method=buscarClientesPorRazaoSocial&clienteRazaoSocial=A";
var ajax = new AJAXInteraction(url, callbackBuscarClientes);
ajax.doGet();
}
function callbackBuscarClientes(responseAJAX){
//Fazer o tratamento da resposta.
}

Olha que interessante. Em Javascript você também pode utilizar Objetos. A declaração é um pouco diferente inclusive existe um recurso de Prototipação que ajuda bastante também.

Estas são algumas dicas para a utilização de Javascript. O resto que você precisa conhecer são as diversas operações dos componentes. Esse é um estudo como de outra linguagem qualquer envolvendo a leitura das especificações e a construção de exemplos.

Quero comentar um tutorial postado no guj (guj.com.br) sobre a utilização do Apache Axis para o desenvolvimento/publicação/acesso de um WS.

Segue comentários.

Estou querendo realizar alguns teste de produtividade no desenvolvimento de Web Services.

Vou começar criando um projeto Web no Eclipse (com WTP)

(ja foi feito o download do Apache Axis 1.4 anteriormente)

Vou seguir um tutorial interessante que encontrei no site do guj.

http://www.guj.com.br/java.tutorial.artigo.180.1.guj

Entao vamos ver:

So vou fazer algumas coisas diferentes do tutorial pois ja quero ir desenvolvendo no Eclipse.

Primeiro ja copiei todos os jars do apache para o /lib

Depois copiei o conteudo do web.xml que utiliza o recurso do Apache Axis para o web.xml atual da aplicação

Apos criar as classes RecursosHumanos e Empregado vou executar uma linha de comando para geração do WSDL

Ops, vou ter que colocar as classes do Axis no CLASSPATH

Entrar no diretorio bin do projeto (via prompt mesmo)

SET AXIS_HOME=c:/axis-1_4
SET CLASSPATH=%CLASSPATH%;./
SET CLASSPATH=%CLASSPATH%;%AXIS_HOME%/lib/axis.jar
SET CLASSPATH=%CLASSPATH%;%AXIS_HOME%/lib/saaj.jar
SET CLASSPATH=%CLASSPATH%;%AXIS_HOME%/lib/jaxrpc.jar
SET CLASSPATH=%CLASSPATH%;%AXIS_HOME%/lib/commons-logging-1.0.4.jar
SET CLASSPATH=%CLASSPATH%;%AXIS_HOME%/lib/commons-discovery-0.2.jar
SET CLASSPATH=%CLASSPATH%;%AXIS_HOME%/lib/wsdl4j-1.5.1.jar

java org.apache.axis.wsdl.Java2WSDL -o ../config/resource/rh.wsdl -l"http://localhost:8080/ApacheAxis/services/RecursosHumanosWS" -n "urn:RecursosHumanos" rh.RecursosHumanos

deu alguns erros principalmente por causa da localização dos arquivos.

ou seja, vc tem que executar este comando de dentro de um diretorio que contenha os .class das classes….(Dãããã)

WSDL gerado com sucesso

Executar outro programa agora para gerar as classes de orquestração… Este comando deve ser executado da raiz do seu projeto, indicando qual o diretorio dos fontes

java org.apache.axis.wsdl.WSDL2Java -o ./JavaSource -s -S true -Nurn:RecursosHumanos=rh.ws config/resource/rh.wsdl

Apos a geração de todos os arquivos é preciso instanciar o objeto respectivo e repassar para os metodos deste objeto. Este funciona como uma fachada WS para o teu Objeto (RecursosHumanos), detalhe apenas para o objeto de retorno Empregado

Vamos em frente.

Agora é so rodar a ferramenta de publicação de dentro do diretorio raiz do projeto

java org.apache.axis.client.AdminClient -l"http://localhost:8080/ApacheAxis/servlet/AxisServlet" JavaSource/rh/ws/deploy.wsdd

Depois disso é so acessar pelo browser

http://localhost:8080/ApacheAxis/servlet/AxisServlet

Show de bola…se clicar nos links wsdl é apresentado os WSDL de todos os componentes publicados no Servidor.

Vamos la. Próximo passo fazer um client para acessar os WS.

É lembrado no tutorial da importancia da publicação do WSDL, sem ele nao da para saber como/o que chamar o WebService.

Entrar no diretorio raiz é digitar:

java org.apache.axis.wsdl.WSDL2Java http://localhost:8080/ApacheAxis/services/RecursosHumanosWS?wsdl -o ./JavaSource -p rh.ws.cliente

Show de Bola…foi gerado os arquivos e ta tudo rodando elegancia…

No artigo é apresentado um arquivo de teste cliente que funciona perfeitamente.

Ou seja, a produtividade com o ApacheAxis é muito boa.

Utilizando o mesmo Eclipse WTP é possivel criar um WebService a partir de uma classe de negocio. O processo pode utilizar o Apache Axis e o resultado é mais imporessionante ainda. É quase que Next>>Next>>Finish