Mostrando postagens com marcador Dicas de Programação. Mostrar todas as postagens
Mostrando postagens com marcador Dicas de Programação. Mostrar todas as postagens

sexta-feira, 12 de agosto de 2011

Maus cheiros nos códigos

sexta-feira, 12 de agosto de 2011
As vezes na ânsia de terminar e ver o programa funcionando, o programador acaba implementando as funcionalidades de forma descuidada e acaba por ter um código de baixa qualidade.

vejamos um exemplo:

public void baixarCliente(){
  boolean abertas = false;
  
  for (Fatura fatura : cliente.getFaturas()){
    if (fatura.getStatus().equals(Status.EM_ABERTO)){
      abertas = true; 
      break;
    }
  }

  if (abertas)
    throw new FaturasEmAbertoException();

  cliente.setBaixado(true);
  cliente.setDataBaixa(new Date());
  MailSender mail = new MailSender("Baixa.modelo");
  mail.send(cliente.getEmail());

}
Este Código por exemplo ao ler ele com cuidado podemos entender e ele faz o que é necessário.
Mas poderia ser simplificado para poder transmitir mais conhecimento. Vejam como ficaria refatorado.

public void baixarCliente(){
  
  if (clientePossuiFaturasEmAberto())
    throw new FaturasEmAbertoException();

  registraBaixaDoClienteEEnviaEmailParaOCliente();

}

private void registraBaixaDoClienteEEnviaEmailParaOCliente(){
  cliente.setBaixado(true);
  cliente.setDataBaixa(new Date());
  enviaEmailParaOClienteNotificandoABaixa();
}

private void enviaEmailParaOClienteNotificandoABaixa(){
  new MailSender("Baixa.modelo").send(cliente.getEmail());
}

private boolean clientePossuiFaturasEmAberto(){
  for (Fatura fatura : cliente.getFaturas())
    if (fatura.getStatus().equals(Status.EM_ABERTO))
      return true;

  return false;
}


Com um código como esse fica mais claro as operações que estão sendo executadas. Ao ler o código que faz a baixa do cliente:


if (clientePossuiFaturasEmAberto())
throw new FaturasEmAbertoException();

registraBaixaDoClienteEEnviaEmailParaOCliente();

fica claro as verificações que são feitas.

ao desenvolver pense em fazer isso, pois os benefícios serão vistos na manutenção do seu sistema.



Nenhum comentário :

quinta-feira, 14 de janeiro de 2010

Framework JBee Behavior-driven development Lançado

quinta-feira, 14 de janeiro de 2010
É bem aceito na comunidade um novo paradigma de desenvolvimento de sistemas o TDD, em que consiste o desenvolvimento de testes antes da aplicação ser construida, utimamente em ganhado muita força o BDD que é o desenvolvimento orientado a comportamento, os benefícios de aplicar o BDD é a facilidade de fazer testes de aceitação e regressão no sistema.

Para programar usando a metodologia do BDD (Behavior-driven development) o desenvolvedor escreve uma história que consiste nos passos para o usuário, sendo que esta história é coduzida pelo uso de palavras chaves (Dado que, Quando, Então, E) que são interpretadas e executadas no sistema.

Para facilitar o desenvolvimento orientado a BDD eu desenvolvi um framework chamado JBee onde o objetivo dele é facilitar o uso desta metodologia de testes.

O framework é compatível com o Junit.

Acessem a pagina http://sites.google.com/site/jbeetest/ para conhecer o framework e ver a sua utilidade em ação.


Nenhum comentário :

segunda-feira, 21 de dezembro de 2009

Best Pratices - Static factory

segunda-feira, 21 de dezembro de 2009
Ao iniciarmos no conceito da orientação a objetos, muitas vezes não entendemos plenamente como usar a orientação a objetos, ninguém está isento disso, e o maior problema é que muitas vezes as pessoas se fecham a acham que sabem tudo sobre orientação a objetos, ou que apenas por usar uma classe já está usando orientação a objetos, estes são erros comuns, por exemplo veja os programadores que utilizam o Delphi, embora usem objetos, a programação parece ser mais estruturada e a lógica fica dispersa nas ações, o código fica de difícil manutenção.

Geralmente quando ocorre este problema o mais fácil as vezes é reescrever todo o sistema, isto mesmo se você já teve este pensamento, você possivelmente está fazendo alguma coisa errada.

Martin Flower se refere a estes problemas como mal cheiros no código, bem agora iremos abordar exatamente um destes problemas.

A forma mais natural de obtermos uma instância de um objeto é através do uso de um construtor, usado em java da seguinte forma:
Relatorio relContas = new Relatorio();
ao executarmos este código obteremos um objeto chamado relatório, mas uma abordagem como está é pouco flexível, considere que você precisa configurar dados do relatório para que o mesmo seja usado, uma forma de fazer isto é por oferecer a os dados necessários para a classe relatório funcionar, como parametros no construtor, veja o exemplo:
Relatorio relContas = new Relatorio("Relatorio de contas dos clientes",new Date());
repare que agora o nosso objeto relatório é gerado usando parâmetros no construtor, qual o problema desta abordagem? apenas analisando este trecho de código você não seria capaz de dizer o que os parâmetros que estão sendo passados representam, repare que você neste momento teria de fazer uma consulta ao javadoc da classe ou mesmo acessá-la para verificar o que ela está querendo dizer.

Outro problema que temos é que não conseguimos expandir as funcionalidades da classe, repare que se requisermos fazer cache o objeto relatório isto não será possível.

Usarmos uma abordagem como está com certeza (uso do operador new), torna o sistema menos flexível e conseqüentemente de mais difícil manutenção.

Podemos resolver este problema de duas maneiras, usarmos StaticFactorys.

Uma static factory permite você configurar melhor a sua classe e expor também o que você deseja fazer.

Veja o exemplo usando o conceito de static factory:
Relatorio relContas = Relatorio.comTitulo("Relatorio de contas do Cliente");
repare que agora o código parece fazer mais sentido, ao ver esta linha fica claro que você está dizendo qual é o título do relatório.

a classe fica assim:
public class Relatorio{
    ...

    private Relatorio(){}
    
    public static Relatorio comTitulo(String titulo){
        Relatorio rel = new Relatorio();
        rel.setTitulo(titulo);
        return rel;
    }

    ...
}
O uso de static factory method possui as vantagens que se você deseja tornar o objeto um Sigleton, basta modificar a fábrica estática, se você deseja fazer cache de objetos num pool para compartilhar entre as chamadas, uma abordagem como está com toda certeza permite esta flexibilidade.

Posteriormente irei abordar o uso do padrão Builder para a construção de objetos.


Nenhum comentário :

quinta-feira, 11 de dezembro de 2008

Padrões de Projeto - Adapter

quinta-feira, 11 de dezembro de 2008
Prezados, no artigo anterior da série, falei sobre o padrão singleton e como o mesmo pode ser usado. Agora veremos sobre outro padrão de projeto chamado Adapter.

Adapter é um padrão que é usando quando se deseja adaptar sua classe para ser usada por outro objeto.

Exemplo:

Sua tomada em casa é de 2 pinos, mas o computador é de 3 pinos então usa-se um adaptador para ligar na tomada (beijamin).

O mesmo em Software:

tenho o seguinte problema:

Preciso comparar uma array de bytes com regex. só que regex somente aceita objetos do tipo CharSequence.
byte[] sca = "helo carlos".getBytes();   

Pattern p = Pattern.compile("^(?i)(helo) .+");   
Matcher m = p.matcher(sca);   
return m.matches();  


O código acima vai da erro, mas eu preciso usar array de bytes. o que fazer?

use um adaptador (Adapter) que adapta a array para ser usada como uma CharSequence,

veja a interface da charSequence:

public interface CharSequence {
int length();
char charAt(int index);
CharSequence subSequence(int start, int end);
public String toString();
}

Aqui está o adaptador:
public class CharSequenceByteArray implements CharSequence {

private byte[] buffer;

public CharSequenceByteArray(byte[] buffer) {
this.buffer = buffer;
}

public int length() {
return buffer.length;
}

public char charAt(int index) {
return (char) buffer[index];
}

public CharSequence subSequence(int start, int end) {
return new CharSequenceByteArray(Arrays.copyOfRange(buffer, start, end));
}
}

agora eu faço assim uso o adaptador:
byte[] sca = "helo carlos".getBytes();

Pattern p = Pattern.compile("^(?i)(helo) .+");
Matcher m = p.matcher(new CharSequenceByteArray(sca));
return m.matches();


Este código não da erro, porque eu adaptei uma interface em outra.

Isto é o padrão adapter.

Att. Carlos


Nenhum comentário :

segunda-feira, 8 de dezembro de 2008

Padrões de projeto - Singleton

segunda-feira, 8 de dezembro de 2008
Quando estava iniciando o desenvolvimento orientado a objetos, sempre me perguntava, "para que serve um método estático?", "polimorfismo em que raios de situação usaria isto?", "há interfaces servem apenas para duplicar artefatos.".

E quanto mais passava o tempo mais as minhas pesquisas me mostravam que a orientação a objetos era algo de outro mundo, também para quem desenvolvia em Clipper e via muitas autoridades em programação falarem sobre a morte da orientação a objetos, que a orientação a objetos é ruim, que adiciona complexidade.

Hoje olhando para traz vejo que na verdade o que muitos destes tinham era medo da mudança, e de descobrir, tentar algo novo, o que me ajudou a ver a utilidade da orientação a objetos foi os padrões de projeto.

Quando estava iniciando o meu desenvolvimento em Java, acabei caindo em uma página que falava sobre padrões de projeto J2EE, mais especificamente o DAO. Agora sim me fazia sentido o uso de interfaces e outras coisas. Pude ver a utilidade de uma Factory, Interface, sobrecarga de métodos, etc. Afinal agora a coisa toda estava fazendo sentido.

Você também deve estar curioso, em ENTENDER o que é um padrão de projeto e como utilizá-lo. Pois bem, lá vai.

O que é um padrão de Projeto:

O modelo de programação orientado a objetos é um grande avanço visto que você pode componentizar e melhor organizar o seu sistema. Assim sendo podemos construir programas criando um conjunto de objetos e fazendo os mesmos conversarem entre sí para podermos obter um sistema. Um padrão de projeto é como uma receita de como construir os seus objetos e arranjá-los de forma que você consiga fazer o sistema ser fácil de manter. Vias de passagem manter um sistema não é uma tarefa fácil.

Portanto organizar o sistema de forma que o mesmo mude mais facilmente é muito desejável.

Os padrões de projeto se dividem em 3 partes, sendo que cada parte demonstra um padrão para uma área específica do sistema.
A divisão está entre padrões comportamentais, que mostram formas de os objetos interagirem entre si (comportamento), criacionais, mostrando a forma de criar objetos, e estruturais, no que tange as estruturas de seus objetos.

Nesta série de artigos veremos como os padrões podem nos ajudar, ao invés de apenas apresentar conceitos, veremos em que situações reais eles podem ser usados.

O primeiro padrão a ser apresentado será o Sigleton, este é um dos padrões mais simples de ser usado. E dependendo da situação ele pode ser realmente útil.

Até a próxima.


Nenhum comentário :

sexta-feira, 5 de dezembro de 2008

Maven - você deveria usar...

sexta-feira, 5 de dezembro de 2008
O que é o Maven é uma ferramenta indispensável para o desenvolvimento e gerenciamento de projetos, com certeza você como eu já ficamos de cabelo em pé, porque faltava alguma biblioteca no projeto, ou o sistema da erros estranhos simplesmente por falta de bibliotecas...

O Maven resolve isto de forma interessante, ele usa o conceito de dependência transitiva, assim o funcionamento se da através de um arquivo de configuração chamado POM, e um repositório de bibliotecas identificadas onde ao precisar de uma biblioteca por exemplo basta adicionar a sua identificação no arquivo POM que o Maven baixa a biblioteca no repositório local.

Estas são apenas algumas das funcionalidades do Maven.

Você com certeza todos deveriam usar.


Nenhum comentário :

domingo, 17 de agosto de 2008

Ordenação por mais de um campo

domingo, 17 de agosto de 2008
Algo comum no desenvolvimento java é a necessidade de ordenar objetos, o java com a API collections dele disponibiliza formas de efetuar esta tarefa, você pode fazer isto:
  1. Implementando a interface Comparable no objeto a ser comparado.
  2. Implementando um objeto comparador

Para a 1º situação você deve conforme a interface criar um método chamado compareTo, o retorno deste método deve ser um int (primitivo) onde deve conter o valor -1 se o objeto comparado foi menor do que o objeto atual, 0 se objeto for igual e 1 se o objeto for maior.

Para a situação 2 você deve fazer uma classe que implemente a interface Comparable como na situação 1.

para realizar a ordenação você deve utilizar um método estático da API Collections o SORT, este método sobrecarregado tem 2 implementações a primeira você passa a list que contém os seus objetos e ele coloca em ordem, lembrando que para ele fazer isto você deve implementar Comparable, caso contrário ele disparará uma exception, e a outra forma é passar a lista e o objeto comparador, desta forma você pode ordenar os seus objetos.

Mais ai vem um detalhe importante com a qual esta semana me deparei, precisei colocar não um só campo do objeto em ordem, mas sim 5 campos do objeto, como fazer isto? depois de pesquisar encontrei a solução a Apache tem uma API Common Collections e BeanUtil (veja as dependências) estas bibliotecas contém funções comuns e uma delas advinhem só, faz exatamente isto, segue um código de exemplo de ordenação por mais de um campo:

List sortFields = new ArrayList();

sortFields.add(new BeanComparator("nome"));
sortFields.add(new BeanComparator("sobrenome"));

ComparatorChain multiSort = new ComparatorChain(sortFields);

java.util.Collections.sort(clientes,multiSort);

O código acima faz a ordenação das lista de objetos clientes pelos campos nome e sobrenome, facilitando assim a ordenação de objetos.

espero que gostem da dica.



2 comentários :