Gerência de projeto de software nos tempos modernos

O post de hoje é uma crítica à gerência de projeto de software.
Tenho visto ultimamente que muito se fala de processo, metodologia, cronograma e pouco se é falado de construção de software de qualidade.


Um breve comentário para reflexão...
Desenvolvedor faz cronograma? Estimativa? Ou desenvolve?

Abraço!

Obtendo maior reuso de código com o padrão “Application Service”

Durante a concepção de um novo software quase sempre nos deparamos com a mesma estrutura clássica de separação de camadas: dao, service, facade e controller.
Em aplicações corporativas, muitas vezes é interessante reutilizar códigos já usados em outras aplicações. Isso porque, nessas aplicações, geralmente as classes que compõem o modelo de dados são as mesma para a corporação.

O reuso de código é sempre mais eficaz quando temos uma camada de serviço fina, ou seja, com pouca lógica da aplicação em si. Porém, nos casos em que temos uma camada de serviço com muita lógica de negócio específica da aplicação, o reuso destes serviços para outras aplicações torna-se mais difícil.

Para melhor entender, veja considere a seguinte situação de exemplo:

Tem-se duas aplicações: uma de cadastro de funcionários e outra premiação de funcionários (aplicações típicas de empresas). Baseado nisso vamos considerar:

• As aplicações são distintas sendo que, cada uma delas tem a suas lógicas de negócio específicas (serviços);
• As aplicações pertencem à mesma corporação portanto,vamos considerar que o modelo de dados (model) e a camada de persistência (dao) são iguais para ambas;
• Cada aplicação tem sua fachada (facade) que expõe uma interface que controla o acesso dos diferentes clientes aos serviços.

Para maior compreensão veja a figura 1 com projeto das duas aplicações.

Figura 1

No exemplo mostrado pela figura 1, vimos que em algumas situações as aplicações podem requerer alguma lógica extra para que executem corretamente suas tarefas (métodos específicos da figura 1). Preferencialmente, os facades não devem conter lógicas de negócios e os services, idealmente, não devem conter lógicas específicas de um caso de uso ou aplicação. Desta maneira há mais reuso e o acoplamento entre os serviços diminui. Assim, pode-se introduzir uma camada que concentra a lógica específica e coordena ações dos services para que essa lógica específica seja corretamente executada. Esses serviços são chamados de application services.

Voltando ao exemplo, a organização dos serviços ficariam da seguinte forma (figura 2):

Figura 2

Ou seja, os métodos comuns mostrados na figura 1 ficariam dentro de FuncionarioService e os não comuns ficariam dentro FuncionarioAppService de cada aplicação.
Desta forma o facade de cada aplicação fica encarregado de fazer as devidas chamadas para a camada de negócio (figura 3).

Figura 3

Em síntese, isto é o que chama-se de componentização. No momento em que agrupamos coisas comuns e que podem ser reutilizadas em aplicações distintas, pode-se criar um JAR (componente) com esses fontes e usá-lo nas aplicações sem necessidade de replicação de código.

Até breve!

Enumeração de Caminhos - Algoritmo Grafos

Olá pessoal!
Na postagem de hoje irei mudar um pouco o foco atual do blog que, desde seu início, tem sido focado mais em tecnologias (spring, hibernate, jsf entre outras).

Hoje vou comentar um pouco sobre grafos que sempre foi um assunto de meu interesse na época de faculdade. Mais especificamente, através de uma apresentação de slides, vou mostrar dois algoritmos (baseados em rotulação de nós e arcos) para encontrar o número de caminhos entre dois nós de um grafo acíclico.

Os algoritmos são bem interessantes e tranquilos, visto que podemos usar e abusar da orientação a objetos para implementa-los (os que tornam mais interessante ainda).

Para melhor entendimento da apresentação, aconselho que o leitor tenha já um certo conhecimento de conceitos básicos de grafos. Dentre eles pode-se citar: matriz de adjacência, nós sucessores, antecessores etc.

Enumeração Caminhos - Algoritmo Grafos

View more presentations from thiagoprocaci.

Os fontes da implementação mostrada na apresentação estão disponíveis o link abaixo:
Fontes dos algoritmos

Quem desejar somente o executável está disponível em:
JAR da implementação

O implementação foi feita em Java... Só para lembrar!!

Abraço!!

Desvendando o ZK Framework

Olá!
Aproveitando o embalo do post anterior, neste vou apresentar conceitos do ZK Framework e um exemplo de implementação (ressaltando os conceitos) através de alguns slides. Esta apresentação trata-se de apenas uma referencia inicial para as pessoas que desejam se aprofundar na tecnologia.
A apresentação está bem interessante! Vale a pena dar uma olhada!

Zk Framework

View more presentations from thiagoprocaci.

Para maiores informações: http://www.zkoss.org/

Até!

Mundo Java - número 36

O post de hoje será somente para falar um pouco sobre a edição 36 da revista
Mundo Java. Na verdade, o motivo disso é a minha presença na edição com o artigo ZK Framework - Utilizando Ajax sem Javascript.

No artigo procurei ressaltar conceitos referentes os ZK e ainda construir exemplos mostrando seu uso. Segue uma prévia de alguns trechos do artigo publicado..

" Cada vez mais se faz necessário que as aplicações web sejam intuitivas e fáceis de se usar. Esta necessidade está diretamente ligada à camada de visão de tais aplicações. Porém, a criação de aplicações com interfaces ricas exige esforços cada vez maiores. Essa exigência muitas vezes acaba desviando o foco do desenvolvimento que deveria ser, na maior parte do tempo, nas regras de negócio. Com efeito, surgem diversas ferramentas tentando facilitar essa tarefa, sendo uma delas o ZK Framework. "

" ... as tecnologias utilizadas em aplicações web apresentaram uma notável evolução. Inicialmente tinham-se aplicações cujas camadas de visão eram compostas somente por páginas HTML estáticas que, com o decorrer do tempo, foram gradativamente evoluindo para páginas HTML dinâmicas (DHTML), páginas utilizando Flash, Applets e, por fim, para páginas que incorporavam o uso de Ajax ... "

" Com a maturação da tecnologia Ajax, surgiram vários frameworks baseados nela, sendo o ZK um deles. A idéia principal do ZK Framework é facilitar a incorporação de Ajax nas aplicações web desenvolvidas em Java, de maneira a dispensar qualquer conhecimento de Javascript. Essa facilidade é oriunda dos mecanismos internos do ZK que geram código Javascript de forma transparente para o desenvolvedor. "


E por aí vai correndo o assunto..
Além desse artigo, a edição apresenta vários outros assuntos interessantes dos quais cita-se: JRuby, Demoiselle Framework, hábitos eficazes para tratamento de exceções etc.

Para quem desejar saber mais sobre o ZK Framework segue uma dica quente:
http://www.zkoss.org/

Mais adiante vou postar alguns exemplos mostrando o uso do ZK.

até!

Internacionalização de mensagens com JSF – Exemplo prático.

Nesta postagem vamos mostrar como fazer a internacionalização de mensagens utilizando JSF. Internacionalizar mensagens é uma maneira de isolar toda a mensageiria de uma aplicação em arquivos. Desta forma, pode-se definir mensagens em idiomas diferentes em arquivos separados sem que a aplicação sofra nenhum impacto.

Para exemplificar a internacionalização com JSF, vamos aproveitar a aplicação exemplo mostrada na postagem “Iniciando com JSF (Tutorial com exemplo prático)”.

Primeiramente deve-se definir os arquivos com as mensagens. Para isso foi criado um pacote com.sample.messages e lá foram colocados dois arquivos com as mensagens da aplicação (um com mensagens em inglês e outro em português).

A listagem 1 e 2 mostram como ficaram os arquivos com as mensagens da aplicação.

messages_en_US.properties (mensagens em inglês)

portuguese=Portuguese
english=English
save=Save
delete=Delete
name=Name
nationality=Nationality
title=JSF

Listagem 1

messages_pt_BR.properties (mensagens em português)

portuguese=Portugues
english=Ingles
save=Salvar
delete=Excluir
name=Nome
nationality=Nacionalidade
title=JSF

Listagem 2

O pacote com os arquivos de mensagens é ilustrado na figura 1:

Figura 1: Pacote mensagens

Agora temos que configurar o faces-config.xml para o funcionamento da mensageiria. Para isso basta adicionar o seguinte trecho no faces-config.xml conforme a listagem 3:

 <application>   
  <resource-bundle>
     <base-name>com.sample.messages.messages</base-name>
     <var>msgs</var>
  </resource-bundle>
  <locale-config>
         <default-locale>pt_BR</default-locale>
         <supported-locale>en_US</supported-locale>
  </locale-config>
  <message-bundle>
       com.sample.messages.messages
  </message-bundle>      
 </application>

Listagem 3

Vamos agora criar um controller para gerenciar qual será o locale (idioma) usado na aplicação. Esse controller chamaremos de LocaleController e ficará dentro do pacote com.sample.controller do exemplo. A listagem 4 mostra a implementação do LocaleController.

package com.sample.controller;

import java.util.Locale;

import javax.faces.component.UIViewRoot;
import javax.faces.context.FacesContext;

public class LocaleController {
 private Locale currentLocale = new Locale("pt", "BR");

 public void englishLocale() {
  UIViewRoot viewRoot = FacesContext.getCurrentInstance().getViewRoot();
  currentLocale = Locale.US;
  viewRoot.setLocale(currentLocale);
 }

 public void portugueseLocale() {
  UIViewRoot viewRoot = FacesContext.getCurrentInstance().getViewRoot();
  currentLocale = new Locale("pt", "BR");
  viewRoot.setLocale(currentLocale);
 }

 public Locale getCurrentLocale() {
  return currentLocale;
 }
}

Listagem 4

Vamos também definir um managed-bean no faces-config.xml para o LocaleController (listagem 5).

<managed-bean>
  <managed-bean-name>localeController</managed-bean-name>
  <managed-bean-class>
  com.sample.controller.LocaleController
  </managed-bean-class>
  <managed-bean-scope>session</managed-bean-scope>   
</managed-bean>

Listagem 5

Agora vamos definir a página pessoa.jsp para testar a internacionalização (listagem 6).

<%@ page contentType="text/html; charset=UTF-8"%>
<%@ taglib uri="http://java.sun.com/jsf/core" prefix="f"%>
<%@ taglib uri="http://java.sun.com/jsf/html" prefix="h"%>
<html>
<f:view locale="#{localeController.currentLocale}">
 <head> 
 <title><h:outputText value="#{msgs.title}" /></title>
 </head>
 <body>
 <h:form>
  <table>
     <tr>
     <td><h:commandLink value="#{msgs.portuguese}" action="#{localeController.portugueseLocale}" /></td>
     <td><h:commandLink value="#{msgs.english}" action="#{localeController.englishLocale}" /></td>
     </tr>   
   <tr>
    <td><h:outputText value="#{msgs.name}" />:</td>
    <td><h:inputText value="#{pessoaController.pessoa.nome}" /></td>
   </tr>
   <tr>
    <td><h:outputText value="#{msgs.nationality}" />:</td>
    <td><h:inputText value="#{pessoaController.pessoa.nacionalidade}" /></td>
   </tr>
   <tr>
    <td><h:commandButton value="#{msgs.save}" action="#{pessoaController.save}" /></td>
   </tr>
  </table>
  <h:dataTable value="#{pessoaController.pessoas}" var="p" 
rendered="#{not empty pessoaController.pessoas}" border="1">
   <h:column>
    <f:facet name="header">
     <h:outputText value="#{msgs.name}" />
    </f:facet>
    <h:commandLink value="#{p.nome}" action="#{pessoaController.edit}">
     <f:param name="id" value="#{p.id}" />     
    </h:commandLink>    
   </h:column>
   <h:column>
    <f:facet name="header">
     <h:outputText value="#{msgs.nationality}" />
    </f:facet>
    <h:commandLink value="#{p.nacionalidade}" action="#{pessoaController.edit}">
     <f:param name="id" value="#{p.id}" />     
    </h:commandLink>   
   </h:column>
   <h:column>
    <f:facet name="header">
     <h:outputText value="#{msgs.delete}" />
    </f:facet>    
    <h:commandLink value="#{msgs.delete}" action="#{pessoaController.delete}">
     <f:param name="id" value="#{p.id}" />
    </h:commandLink>   
   </h:column>
  </h:dataTable>
 </h:form> 
 </body>
</f:view>
</html>

Listagem 6

Com as configurações mostradas acima podemos ver o comportamento da aplicação (figura 2).

Figura 2: Comportamento da aplicação

Em síntese, com a aplicação exemplificamos como internacionalizar mensagens.
Os fontes do exemplo completo estão disponíveis aqui.

Até!

Iniciando com JSF (Tutorial com exemplo prático)

Nesta postagem será mostrado um exemplo prático (CRUD de pessoas) para aqueles que desejam iniciar o uso da tecnologia JSF. Para isso, será utilizado o servidor de aplicação Apache Tomcat 6.0 e a IDE Eclipse Ganymede.

Para começar, é preciso criar um novo projeto. No Eclipse, basta abrir o menu file conforme mostrado na figura 1. Em seguida, será aberta uma tela para escolher o tipo de aplicação que será desenvolvida. No caso do exemplo, selecione Dynamic Web Project (figura 2) e clique no botão Next.
Na seqüência, dê um nome para o projeto (no exemplo será jsfdemo) e selecione a combo Target RunTime para Apache Tomcat v6.0 (figura 3). Depois, clique no botão Finish que o projeto estará criado.

Um vez criado o projeto, é necessário configurar o ambiente para que a aplicação funcione. Para isso, faça o download da ultima versão do JSF e extraia os jars para a pasta WEB-INF/lib do projeto. Por fim, é necessário configurar o web.xml do projeto, cuja configuração é mostrada na listagem 1.

Figura 1:Novo projeto

Figura 2: Dynamic Web Project

Figura 3: Configuração inicial do projeto

<?xml version="1.0" encoding="UTF-8"?>
<web-app>
<context-param>
<param-name>javax.faces.STATE_SAVING_METHOD</param-name>
<param-value>server</param-value>
</context-param>
<servlet>
<servlet-name>Faces Servlet</servlet-name>
<servlet-class>javax.faces.webapp.FacesServlet</servlet-class>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>Faces Servlet</servlet-name>
<url-pattern>*.faces</url-pattern>
</servlet-mapping>
</web-app>

Listagem 1: web.xml

A partir deste ponto já podemos começar a efetivamente desenvolver a aplicação de exemplo.

Construindo a aplicação

Para iniciar, vamos criar os seguintes pacotes na projeto:

• com.sample.controller;
• com.sample.dao;
• com.sample.model.

A figura 4 ilustra a organização dos pacotes no eclipse.

Figura 4: Pacotes

Dentro do pacote model vamos criar a classe pessoa cujo código é listado na listagem 2.

package com.sample.model;

public class Pessoa {
private Integer id;
private String nome;
private String nacionalidade;

public Integer getId() {
return id;
}

public void setId(Integer id) {
this.id = id;
}

public String getNome() {
return nome;
}

public void setNome(String nome) {
this.nome = nome;
}

public String getNacionalidade() {
return nacionalidade;
}

public void setNacionalidade(String nacionalidade) {
this.nacionalidade = nacionalidade;
}

@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((id == null) ? 0 : id.hashCode());
return result;
}

@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Pessoa other = (Pessoa) obj;
if (id == null) {
if (other.id != null)
return false;
} else if (!id.equals(other.id))
return false;
return true;
}
}

Listagem 2: Pessoa.java

Dentro do pacote dao vamos definir a interface PessoaDao cujo código é mostrado na listagem 3.

package com.sample.dao;

import java.util.List;

import com.sample.model.Pessoa;

public interface PessoaDao {
void save(Pessoa pessoa);
void delete(Integer id);
Pessoa getById(Integer id);
List<Pessoa> findAll();
}

Listagem 3: PessoaDao.java

Dentro do pacote dao é necessário criar também a implementação da interface PessoaDao. No caso do exemplo será definido a classe PessoaDaoImpl (listagem 4).

package com.sample.dao;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import com.sample.model.Pessoa;

public class PessoaDaoImpl implements PessoaDao {
private static PessoaDaoImpl INSTANCE = new PessoaDaoImpl();
private static Map<Integer, Pessoa> database
= new HashMap<Integer, Pessoa>();
private static Integer nextId = 0;

private PessoaDaoImpl() {
}

public static PessoaDaoImpl getInstance() {
return INSTANCE;
}

@Override
public void save(Pessoa pessoa) {
if (pessoa != null) {
if (pessoa.getId() == null) {
nextId++;
pessoa.setId(nextId);
}
database.put(pessoa.getId(), pessoa);
}
}

@Override
public void delete(Integer id) {
if (id != null)
database.remove(id);
}

@Override
public Pessoa getById(Integer id) {
return database.get(id);
}

@Override
public List<Pessoa> findAll() {
return new ArrayList<Pessoa>(database.values());
}
}

Listagem 4: PessoaDaoImpl.java

Dentro do pacote controller vamos definir a classe PessoaController que será o nosso managed bean (listagem 5).

package com.sample.controller;

import java.util.List;

import javax.faces.context.FacesContext;

import com.sample.dao.PessoaDao;
import com.sample.dao.PessoaDaoImpl;
import com.sample.model.Pessoa;

public class PessoaController {
private PessoaDao pessoaDao = PessoaDaoImpl.getInstance();
private Pessoa pessoa;

public PessoaController() {
pessoa = new Pessoa();
}

public void save() {
pessoaDao.save(pessoa);
pessoa = new Pessoa();
}

public void edit() {
// pega o parametro passado no link
Integer id = Integer.parseInt((String)
FacesContext.getCurrentInstance().getExternalContext()
.getRequestParameterMap().get("id"));
pessoa = pessoaDao.getById(id);
}

public void delete(){
// pega o parametro passado no link
Integer id = Integer.parseInt((String)
FacesContext.getCurrentInstance().getExternalContext()
.getRequestParameterMap().get("id"));
pessoaDao.delete(id);
}

// getters e setters
public Pessoa getPessoa() {
return pessoa;
}

public void setPessoa(Pessoa pessoa) {
this.pessoa = pessoa;
}

public List<Pessoa> getPessoas() {
return pessoaDao.findAll();
}
}

Listagem 5: PessoaController.java

Vamos agora configurar o faces-config.xml (localizado dentro da pasta WEB-INF) cuja configuração é mostrada na listagem 6.

<?xml version="1.0" encoding="UTF-8"?>
<faces-config>
<navigation-rule>
<from-view-id>pessoa.jsp</from-view-id>
<navigation-case>
<from-outcome>*</from-outcome>
<to-view-id>pessoa.jsp</to-view-id>
</navigation-case>
</navigation-rule>
<managed-bean>
<managed-bean-name>pessoaController</managed-bean-name>
<managed-bean-class>
com.sample.controller.PessoaController
</managed-bean-class>
<managed-bean-scope>session</managed-bean-scope>
</managed-bean>
</faces-config>

Listagem 6: faces-config.xml

Por fim, vamos criar nossa página pessoa.jsp (listagem 7).

<%@ page contentType="text/html; charset=UTF-8"%>
<%@ taglib uri="http://java.sun.com/jsf/core" prefix="f"%>
<%@ taglib uri="http://java.sun.com/jsf/html" prefix="h"%>
<html>
<f:view>
<head>
<title><h:outputText value="Desvendando JSF" /></title>
</head>
<body>
<h:form>
<table>
<tr>
<td><h:outputText value="Nome" />:</td>
<td><h:inputText value="#{pessoaController.pessoa.nome}" /></td>
</tr>
<tr>
<td><h:outputText value="Nacionalidade" />:</td>
<td><h:inputText value="#{pessoaController.pessoa.nacionalidade}" /></td>
</tr>
<tr>
<td><h:commandButton value="salvar" action="#{pessoaController.save}" /></td>
</tr>
</table>
<h:dataTable value="#{pessoaController.pessoas}"
var="p" rendered="#{not empty pessoaController.pessoas}" border="1">
<h:column>
<f:facet name="header">
<h:outputText value="Nome" />
</f:facet>
<h:commandLink value="#{p.nome}" action="#{pessoaController.edit}">
<f:param name="id" value="#{p.id}" />
</h:commandLink>
</h:column>
<h:column>
<f:facet name="header">
<h:outputText value="Nacionalidade" />
</f:facet>
<h:commandLink value="#{p.nacionalidade}" action="#{pessoaController.edit}">
<f:param name="id" value="#{p.id}" />
</h:commandLink>
</h:column>
<h:column>
<f:facet name="header">
<h:outputText value="Excluir" />
</f:facet>
<h:commandLink value="excluir" action="#{pessoaController.delete}">
<f:param name="id" value="#{p.id}" />
</h:commandLink>
</h:column>
</h:dataTable>
</h:form>
</body>
</f:view>
</html>

Listagem 7: pessoa.jsp

A partir deste ponto, com as definições acima, podemos vizualizar a aplicação através da URL http://localhost:8080/jsfdemo/pessoa.faces .

Veja uma prévia do funcionamento dela (figura 5). Trata-se de um CRUD básico de pessoa.

Figura 5: Aplicação JSF

Um excelente referencia para quem deseja aprender conceitos relacionados ao JSF é o livro Core JavaServer Faces.

Os fontes do exemplo (incluindo Jars) estão disponíveis aqui.

Até!

Veja também:

Internacionalizando mensagens com JSF.