Máscara javascript para qualquer formato

Fazer máscaras em javascript é sempre chato e trabalhoso. Para cada máscara do sistema deve-se criar uma função javascript e utilizá-la no sistema. A algum tempo criei uma função javascript que funciona para a grande maioria das mascaras que são utilizadas no sistema. A função é mostrada abaixo:

/**
* Funcao de mascara. Esta funcao recebe como parametro o campo (this) no qual a
* mascara sera aplicada, o formato da mascara (99/99/9999), o conteúdo (1
* numeros, 2 letras e 3 letras e numeros) e o evento passa-se o this.
*/
function mask(campo, formato, conteudo, event) {

 valor = campo.value;

 var i, j;
 var caracs = [ '.', '/', '-', ':', '(', ')', ',' ];
 var auxPonto = formato;
 var auxBarra = formato;
 var auxHifen = formato;
 var auxDblPonto = formato;
 var auxAbrePar = formato;
 var auxFechaPar = formato;
 var auxVirgula = formato;
 var tamanho = formato.length;
 var posPonto = new Array(tamanho);
 var posBarra = new Array(tamanho);
 var posHifen = new Array(tamanho);
 var posDblPonto = new Array(tamanho);
 var posAbrePar = new Array(tamanho);
 var posFechaPar = new Array(tamanho);
 var posVirgula = new Array(tamanho);
 var keyPress = event;

 campo.maxLength = tamanho;

 if (event.keyCode != 17) {
  switch (conteudo) {
  case 1: // Verifica se soh podem ser entrados valores numericos
   if (!(event.keyCode >= 48 && (event.keyCode <= 57)))
    event.keyCode = 0;
   break;
  case 2: // Somente Letras
   if (!((event.keyCode >= 97 && event.keyCode <= 122)
     || event.keyCode >= 65
     && event.keyCode <= 90))
    event.keyCode = 0;
   break;
  case 3: // Letras e numeros
   if (!((event.keyCode >= 48 && event.keyCode <= 57)
     || (event.keyCode >= 97 && event.keyCode <= 122)
     || (event.keyCode >= 65 && event.keyCode <= 90)))
    event.keyCode = 0;
   break;
  }
 }

 // ----------------------------- PEGA A FORMATACAO DA MASCARA
 // ------------------
 for (i = 0; i < tamanho; i++) {

  posPonto[i] = auxPonto.indexOf('.');
  posBarra[i] = auxBarra.indexOf('/');
  posHifen[i] = auxHifen.indexOf('-');
  posDblPonto[i] = auxDblPonto.indexOf(':');
  posAbrePar[i] = auxAbrePar.indexOf('(');
  posFechaPar[i] = auxFechaPar.indexOf(')');
  posVirgula[i] = auxVirgula.indexOf(',');

  auxPonto = auxPonto.substring(posPonto[i] + 1, tamanho);
  auxBarra = auxBarra.substring(posBarra[i] + 1, tamanho);
  auxHifen = auxHifen.substring(posHifen[i] + 1, tamanho);
  auxDblPonto = auxDblPonto.substring(posDblPonto[i] + 1, tamanho);
  auxAbrePar = auxAbrePar.substring(posAbrePar[i] + 1, tamanho);
  auxFechaPar = auxFechaPar.substring(posFechaPar[i] + 1, tamanho);
  auxVirgula = auxVirgula.substring(posVirgula[i] + 1, tamanho);

  if (i > 0) {
   posPonto[i] = posPonto[i] + posPonto[i - 1];
   posBarra[i] = posBarra[i] + posBarra[i - 1];
   posHifen[i] = posHifen[i] + posHifen[i - 1];
   posDblPonto[i] = posDblPonto[i] + posDblPonto[i - 1];
   posAbrePar[i] = posAbrePar[i] + posAbrePar[i - 1];
   posFechaPar[i] = posFechaPar[i] + posFechaPar[i - 1];
   posVirgula[i] = posVirgula[i] + posVirgula[i - 1];
   posPonto[i] = posPonto[i] + 1;
   posBarra[i] = posBarra[i] + 1;
   posHifen[i] = posHifen[i] + 1;
   posDblPonto[i] = posDblPonto[i] + 1;
   posAbrePar[i] = posAbrePar[i] + 1;
   posFechaPar[i] = posFechaPar[i] + 1;
   posVirgula[i] = posVirgula[i] + 1;
  }
 }

 // Retirando a máscara
 for (i = 0; i < campo.value.length; i++) {
  valor = valor.replace('-', '');
  valor = valor.replace('(', '');
  valor = valor.replace(')', '');
  valor = valor.replace(':', '');
  valor = valor.replace('/', '');
  valor = valor.replace('.', '');
  valor = valor.replace(',', '');
 }

 // Faz a validação se for apenas número
 // utilizado para fazer a validação de Ctrl+V
 if (conteudo == 1) {
  if (isNaN(valor)) {
   if (isNaN(valor.charAt(valor.length - 2)))
    valor = "";
   else
    valor = valor.substring(0, valor.length - 1);
  }
 }

 indicePonto = 0;
 indiceBarra = 0;
 indiceHifen = 0;
 indiceDblPonto = 0;
 indiceVirgula = 0;
 indiceAbrePar = 0;
 indiceFechaPar = 0;

 // Varre o campo aplicando a máscara
 for (i = 0; i < valor.length; i++) {
  if (i == posPonto[indicePonto]) {
   if (valor.charAt(i) != '.') {
    if (i == 0) {
     valor = '.' + valor;
    } else if (i == valor.length) {
     valor = valor + '.';
    } else {
     valor = valor.substring(0, i) + '.' + valor.substring(i);
    }
    indicePonto++;
   }
  }
  if (i == posBarra[indiceBarra]) {
   if (valor.charAt(i) != '/') {
    if (i == 0) {
     valor = '/' + valor;
    } else if (i == valor.length) {
     valor = valor + '/';
    } else {
     valor = valor.substring(0, i) + '/' + valor.substring(i);
    }
    indiceBarra++;
   }
  }

  if (i == posHifen[indiceHifen]) {
   if (valor.charAt(i) != '-') {
    if (i == 0) {
     valor = '-' + valor;
    } else if (i == valor.length) {
     valor = valor + '-';
    } else {
     valor = valor.substring(0, i) + '-' + valor.substring(i);
    }
    indiceHifen++;
   }
  }

  if (i == posDblPonto[indiceDblPonto]) {
   if (valor.charAt(i) != ':') {
    if (i == 0) {
     valor = ':' + valor;
    } else if (i == valor.length) {
     valor = valor + ':';
    } else {
     valor = valor.substring(0, i) + ':' + valor.substring(i);
    }
    indiceDblPonto++;
   }
  }

  if (i == posAbrePar[indiceAbrePar]) {
   if (valor.charAt(i) != '(') {
    if (i == 0) {
     valor = '(' + valor;
    } else if (i == valor.length) {
     valor = valor + '(';
    } else {
     valor = valor.substring(0, i) + '(' + valor.substring(i);
    }
    indiceAbrePar++;
   }
  }

  if (i == posFechaPar[indiceFechaPar]) {
   if (valor.charAt(i) != ')') {
    if (i == 0) {
     valor = ')' + valor;
    } else if (i == valor.length) {
     valor = valor + ')';
    } else {
     valor = valor.substring(0, i) + ')' + valor.substring(i);
    }
    indiceFechaPar++;
   }
  }

  if (i == posVirgula[indiceVirgula]) {
   if (valor.charAt(i) != ',') {
    if (i == 0) {
     valor = ',' + valor;
    } else if (i == valor.length) {
     valor = valor + ',';
    } else {
     valor = valor.substring(0, i) + ',' + valor.substring(i);
    }
    indiceVirgula++;
   }
  }
 }

 if (campo.value.length > tamanho) {
  campo.value = campo.value.substring(0, tamanho);
 }

 campo.value = valor;
}

Segue abaixo um exemplo de como utilizar a função:

Para a máscara pode se passar qualquer mascara que possua os caracteres (ponto, barra, menos, dois pontos, virgula, e abre e fecha parenteses. Os valores que são passados entre os caracteres acima serão desconsiderados, então tanto faz colocar 999.999.999-99 quanto 111.111.111-11. Espero que esta máscara ajude vcs assim como vem me ajudando durante este longo período de desenvolvimento.

É isto aí pessoal. Qualquer problema mandem mensagem.

Palestra interessante no evento Maratona JBoss

Olá pessoal,

Fui em um evento a algum tempo aqui em SP e queria comentar sobre uma palestra que particularmente me chamou bastante atenção. Esta palestra foi sobre o JBoss Performance e foi ministrada pelo Bill Coutinho, funcionário da empresa Dextra.

Entre as principais lições da palestra posso listar as seguintes:

• Por não saber aonde está os gargalos, nunca otimize cedo demais (Só a medição mostrará os gargalos).
• Deve-se sempre fazer um paralelo entre a corretude versus a performance. (A corretude depende da aplicação. Para uma aplicação, ficar com dados antigos, pode ser um erro enquanto para outras pode ser tolerável desde que a aplicação fique mais rápida)
• Escolhas sempre devem ser feitas. (Objetivos na sua grande maioria das vezes serão conflitantes como por exemplo, performance e segurança)

Foi falado também sobre as principais técnicas para o aumento da performance que podem ser:

• Pool de recursos, como no exemplo do pool de conexões com o BD.
• Caching, como no exemplo do cache de segundo nível do Hibernate (Neste caso deve-se analisar a corretude versus a performance)
• Clustering como o exemplo do cluster do Jboss.
• Melhorias nas configurações da JVM. (Evolução do Java 5 com o Ergonomics)

O evento em sí foi muito bom, mas gostaria de parabenizar o palestrante pela excelente apresentação. É isto aí pessoal.

Mapeamento de objetos com JPA e Hibernate

Para auxiliar quem está começando com algum projeto resolvi explicar algumas poucas anotações para realizar o mapeamento de entidades utilizando JPA e Hibernate. Para se realizar a modelagem de classes persistentes e da base de dados pode se utilizar as anotações do JPA e do Hibernate.

Uma das anotações mais utilizadas é a anotação @Entity que define que aquela classe anotada deve ser uma entidade persistida na base de dados. Uma vez utilizada esta anotação, todos os métodos gets e sets e campos (dependendo do seu tipo de acesso) são descobertos e são gerados mapeamento para estas propriedades no banco de dados. Cada uma destas propriedades então gera uma coluna na tabela com o nome da entidade. Para que uma propriedade não seja persistida deve se utilizar a anotação @Transient.

Para se mapear objetos complexos devem ser usadas as anotações @OneToOne, @OneToMany, @ManyToOne e @ManyToMany. Quando mapeamos objetos com o tipo @ManyToMany o próprio JPA é responsável por gerar a tabela entre os dois objetos.

Quando se mapeia objetos deve se definir a política de quando estes objetos devem ser buscados. Normalmente quando se busca um objeto os outros objetos nem sempre precisam ser exibidos e buscá-los no banco causaria uma perda de desempenho indesejável. Um exemplo seria uma busca de pessoas que somente queremos mostrar seus dados e não seu endereço. Para este problema podemos mapear a propriedade como LAZY que indica que o objeto mapeado não é buscado inicialmente e sim somente depois dela ser necessária. Para isto definimos na anotação de mapeamento o trecho fetch = FetchType.LAZY. Para colocar propriedades simples LAZY deve se utilizar a seguinte anotação @Basic(fetch=FetchType.LAZY).

Para constantes únicas como, por exemplo, CPF de uma pessoa é interessante se utilizar a seguinte anotação @Table (uniqueConstraints = @UniqueConstraint ( columnNames = { "cpf" })). Para determinar que uma propriedade não deva ser nula deve-se utilizar a anotação @NotNull. Outra anotação importante é a anotação @NotEmpty que verifica se alguma propriedade do tipo String não é vazia. Para se determinar o tamanho máximo e mínimo de um campo do tipo String pode se utilizar a anotação @Length(min=3, Max=100) e para se determinar qual o intervalo válido de valores de campos inteiros pode se utilizar a anotação @Range(min=12, max=12).

Para propriedades que podem ser validadas com expressões regulares deve se utilizar a seguinte anotação @Pattern(regex="expressão regular") e para validação de email pode se utilizar a anotação @Email. Para outras validações mais complexas podem-se utilizar as anotações @AssertTrue, @AssertFalse, @Valid.

As validações devem ser utilizadas sempre que possível, para que o modelo esteja sempre coerente e correto.

É isto aí pessoal. Existem várias outras anotações de mapeamento que não foram citadas, mas em um outro momento iremos falar delas. Quaisquer problemas enviem mensagem.

Gerenciamento de Transações com JTA

Segue abaixo algumas considerações acerca da API JTA e de como EJB3 suporta transações declarativamente.

Normalmente as transações em aplicações são controladas em nível de métodos de negócio. Para se declarar que se está sendo utilizada alguma transação deve se utilizar a anotação @TransactionAttribute.

Por padrão a transação utiliza a estratégia REQUIRED, que significa que se o método do serviço não possuir alguma transação, uma será criada, e se já possuir uma transação esta será aproveitada. Esta é a estratégia que deve ser utilizada na maior parte dos casos uma vez que é bem lógica.

O que esta estratégia quer dizer resumidamente? Quando você estiver em um contexto de transação e caso ocorra alguma exceção do tipo Runtime ou exceção com a anotação @ApplicationException(rollback=true), deve ser dado o rollback na base de dados. Com esta estratégia padrão sempre será dado o rollback da transação mais externa, o que na maioria dos casos faz todo sentido.

Outras estratégias são:

• SUPPORTS - Não cria nenhuma transação, mas se já existir alguma ela será utilizada.
• MANDATORY - Requer que quem chamou o método tenha criado uma transação.
• NEVER - Proíbe que quem chamou o método tenha iniciado uma transação.
• REQUIRESNEW - Sempre começa uma nova transação, suspendendo a antiga existente.
• NOTSUPPORTED - Suspende qualquer transação ativa.
  

Como padrão, pode-se anotar toda a classe com a anotação @TransactionAttribute, o que determina que todos os métodos da classe utilizam transação e com a estratégia REQUIRED. Caso exista algum método que deva usar outra estratégia basta sobrescrever a estratégia usando acima do método alguma das anotações abaixo:

• @TransactionAttribute(TransactionAttributeType.NEVER)
• @TransactionAttribute(TransactionAttributeType.MANDATORY)
• @TransactionAttribute(TransactionAttributeType.NOT_SUPPORTED)
• @TransactionAttribute(TransactionAttributeType.REQUIRES_NEW)
• @TransactionAttribute(TransactionAttributeType.SUPPORTS)
  

Agora é definir para os métodos qual o melhor tipo de estratégia de transação e sobreescrever.É isto aí pessoal. Qualquer problema me avisem.

DAO Factory Genérico EJB3

Pessoal,

Como dito pelo excelente post do meu amigo Ricardo Ferreira em http://architecture-journal.blogspot.com/2007/07/enterprise-java-beans-30-anti-patterns.html não é uma boa prática termos todos os DAOs controlados pelo EJB apenas para podermos injetar o EntityManager.

Então fiz um DAOFactory bem genérico que serve muito bem aos meus propósitos, mas que pode ajudar quem quer criar uma factory para EJB3. Para se buscar o DAO, deve-se então injetar o DaoFactory e utilizar o método getDAO passando como argumento a classe persistente a ser utilizada.

Segue abaixo a classe:

@Stateless
@SuppressWarnings("unchecked")
public class DAOFactory implements DaoFactoryLocal {

   @PersistenceContext(unitName = "BioModel")
   private EntityManager em;

   private final static String POS_FIXO_DAO = "DAO";
   private final static String PACOTE_ENTIDADE = ".entidade.";
   private final static String PACOTE_DAO = ".dao.";

   private static String getDAOName(Class classeEntidade) {
       String resultado = classeEntidade.getName().replace(PACOTE_ENTIDADE,
               PACOTE_DAO);
       resultado = resultado.concat(POS_FIXO_DAO);

       return resultado;
   }

   @Override
   public GenericDAOImpl getDAO(Class classeEntidade) {

       GenericDAOImpl result = null;

       try {
           result = (GenericDAOImpl) Class.forName(getDAOName(classeEntidade))
                   .newInstance();
           result.setEntityManager(em);
       } catch (InstantiationException e) {
           e.printStackTrace();
       } catch (IllegalAccessException e) {
           e.printStackTrace();
       } catch (ClassNotFoundException e) {
           e.printStackTrace();
       }

       return result;
   }

}

Segue abaixo um exemplo de sua utilização:

    @EJB
   private DaoFactoryLocal daoFactory;
 
   @SuppressWarnings("unchecked")
   protected GenericDAOImpl getDAO() {
       return daoFactory.getDAO(classePersistente);
    }

Qualquer problema me avisem.

DAO Genérico com JPA e Hibernate

Olá pessoal,

Criei uma estrutura inicial de um DAO Genérico que gostaria de compartilhar com vcs. Ainda não existe todos os métodos que vou precisar, mas vou atualizando aqui a cada mudança no código. Para esta implementação utilizei JPA + Hibernate e para meu caso vem me atendendo bem por enquanto. Segue abaixo a implementação:

-----------------------------------------------


/**
* Esta classe é responsável por conter as operações genéricas para realização
* do acesso aos dados do sistema.
*
* @author Samuel
*
* @param 
*/
@SuppressWarnings("unchecked")
public abstract class GenericDAOImpl {
 
 private EntityManager entityManager;

 private Class classePersistente;

 /**
  * Contrutor que guarda o tipo atual da classe T.
  */
 public GenericDAOImpl() {
  this.classePersistente = (Class) ((ParameterizedType) getClass()
    .getGenericSuperclass()).getActualTypeArguments()[0];
 }
 
 /**
  * Atualiza o objeto que se encontra em memória.
  *
  * @param object
  *            objeto a ser atualizado
  */
 public final void refresh(T object) {
  getEntityManager().refresh(object);
 }

 /**
  * Executa o flush no entity manager.
  *
  */
 public final void flush() {
  getEntityManager().flush();
 }
 
 /**
  * Executa o flush no entity manager.
  *
  */
 public final void clear() {
  flush();
  getEntityManager().clear();
 }


 /**
  * Executa o merge do objeto que se encontra em memória.
  *
  * @param objeto
  *            a ser realizado o merge
  * @return objeto que foi executado o merge
  */
 public final T merge(T objeto) {
  objeto = getEntityManager().merge(objeto);
  return objeto;
 }
 
 /**
  * Salva o objeto atual na base de dados.
  *
  * @param objeto
  *            a ser salvo
  */
 public final void salvar(T objeto) {
  getEntityManager().persist(objeto);
 }

 /**
  * Remove o objeto da base de dados.
  *
  * @param objeto
  *            a ser removido
  */
 public final void remover(T objeto) {
  getEntityManager().remove(objeto);
 }

 /**
  * Remove o objeto uma vez passado sua chave como parâmetro.
  *
  * @param chave
  *            identificadora do objeto
  */
 public final void removerPorChave(Integer chave) {
  getEntityManager().createQuery(
    "delete from " + getClassePersistente().getName()
      + " where id = " + chave).executeUpdate();
 }

 /**
  * Busca o objeto uma vez passado sua chave como parâmetro.
  *
  * @param chave
  *            identificador
  * @return Objeto do tipo T
  */
 public final T buscarPorChave(Integer chave) {
  T instance = null;
  try {
   instance = getEntityManager().find(getClassePersistente(), chave);
  } catch (RuntimeException re) {
   re.printStackTrace();
  }
  return instance;
 }

 /**
  * Busca o objeto de acordo com o objeto preenchido com os valores passado
  * como exemplo.
  *
  * @param objeto
  *            utilizado para realizar a busca
  * @param ordenacoes
  *            lista de critérios de ordenação
  * @return Lista de objetos retornada
  */
 public final List buscarPorExemplo(T objeto, Order... ordenacoes) {
  Session session = (Session) getEntityManager().getDelegate();
  Example example = criaExemplo(objeto);
  Criteria criteria = session.createCriteria(objeto.getClass()).add(
    example);
  for (int i = 0; i < ordenacoes.length; i++) {
   criteria.addOrder(ordenacoes[i]);
  }
  return (List) criteria.list();
 }

 /**
  * Busca o objeto de acordo com o objeto preenchido com os valores passado
  * como exemplo.
  *
  * @param objeto
  * @param indiceInicial
  * @param indiceFinal
  * @param ordenacoes
  *            lista de critérios de ordenação.
  * @return Lista de orden
  */
 public final List buscarPorExemplo(T objeto, Integer indiceInicial,
   Integer indiceFinal, Order... ordenacoes) {
  Example example = criaExemplo(objeto);
  Criteria criteria = criaCriteria().add(example);
  criteria.setFirstResult(indiceInicial);
  criteria.setMaxResults(indiceFinal);

  for (int i = 0; i < ordenacoes.length; i++) {
   criteria.addOrder(ordenacoes[i]);
  }

  return (List) criteria.list();
 }

 /**
  * Retorna a quantidade total de objetos para aquela entidade específica.
  *
  * @return quantidade total de objetos
  */
 public final int buscaQuantidadeTotal() {
  Criteria criteria = criaCriteria();
  criteria.setProjection(Projections.rowCount());
  return (Integer) criteria.uniqueResult();
 }

 /**
  * Busca todos os objetos para aquela entidade específica.
  *
  * @param ordenacoes
  *            lista de ordenações para pesquisa
  * @return lista de todos os objetos da entidade
  */
 public List buscarTodos(Order... ordenacoes) {
  List results = null;
  try {
   Query query = getEntityManager().createQuery(
     "from " + getClassePersistente().getName()
       + adicionaOrderByHql(ordenacoes));
   results = query.getResultList();
  } catch (RuntimeException re) {
   re.printStackTrace();
  }
  return results;
 }

 /**
  *
  * Busca todos os objetos de uma entidade específica de um índice inicial
  * até um índice final.
  *
  * @param indiceInicial
  *            indice inicial da busca
  * @param indiceFinal
  *            indice final da pesquisa.
  * @param ordenacoes
  *            lista de ordenação a ser criado
  * @return uma lista de objetos do tipo T
  */
 public List buscarTodos(Integer indiceInicial,
   Integer indiceFinal, Order... ordenacoes) {
  List results = null;
  try {
   Query query = getEntityManager().createQuery(
     "from " + getClassePersistente().getName()
       + adicionaOrderByHql(ordenacoes));
   query.setFirstResult(indiceInicial);
   query.setMaxResults(indiceFinal);

   results = (List) query.getResultList();
  } catch (RuntimeException re) {
   re.printStackTrace();
  }
  return results;
 }

 /**
  * Utilizado para se injetar o Entity manager no DAO.
  *
  * @param entityManager
  *            entity manager
  */
 public void setEntityManager(EntityManager entityManager) {
  this.entityManager = entityManager;
 }

 /**
  * Utilizado para se utilizar o entity manager nos DAOS que herdam do DAO
  * genérico.
  *
  * @return Entity manager.
  */
 protected EntityManager getEntityManager() {
  return entityManager;
 }

 /**
  * Adiciona o orderBy no final da query a ser utilizada.
  *
  * @param ordenacoes
  *            a serem utilizadas para a busca
  * @return string com o orderBy
  */
 protected final static String adicionaOrderByHql(Order... ordenacoes) {
  String result = "";
  if (ordenacoes.length > 0) {
   StringBuilder builder = new StringBuilder(" order by ");
   for (int i = 0; i < ordenacoes.length - 1; i++) {
    builder.append(ordenacoes[i].toString());
    builder.append(", ");
   }
   builder.append(ordenacoes[ordenacoes.length - 1]);
   result = builder.toString();
  }

  return result;
 }

 /**
  * Busca a classe persistente do objeto utilizado na classe.
  *
  * @return classe persistente
  */
 protected final Class getClassePersistente() {
  return classePersistente;
 }

 /**
  * Retorna o objeto da clases Criteria.
  *
  * @return um objeto do tipo Criteria do Hibernate
  */
 protected final Criteria criaCriteria() {
  Session session = (Session) getEntityManager().getDelegate();
  return session.createCriteria(getClassePersistente());
 }

 /**
  * Método utilizado para criar o objeto Example. Este objeto é utilizado
  * para realizar a busca por exemplo.
  *
  * @param objeto
  *            sobre o qual o Example será criado
  * @return em objeto do tipo Example
  */
 protected final Example criaExemplo(T objeto) {

  Example example = Example.create(objeto);
  example.enableLike(MatchMode.ANYWHERE);
  example.excludeZeroes();
  example.ignoreCase();

  return example;
 }

}

-----------------------------------------------

Para ilustrar como esta classe é utilizada mostrarei abaixo como extender este DAO genérico:

-----------------------------------------------

public class PessoaDAO extends GenericDAOImpl {

    public List buscarTodosTelefoneEndereco(Integer indiceInicial, Integer indiceFinal,
            Order... ordenacoes) {
        List pessoas = super.buscarTodos(indiceInicial, indiceFinal,
                ordenacoes);

        for (Pessoa pessoa : pessoas) {
            // Carrega os relazionamentos que são LAZY. Este método chama o
            // método initialize do Hibernate.
            pessoa.getTelefones().size();
            pessoa.getEnderecos().size();
        }

        return pessoas;
    }
   
    @SuppressWarnings("unchecked")
    public List buscarTodosHQL() {
        Query query = getEntityManager().createNamedQuery("selectAllHQL");
        List pessoas = query.getResultList();

        return pessoas;
    }

    @SuppressWarnings("unchecked")
    public List buscarTodosSQL() {
       
        Query query = getEntityManager().createNamedQuery("selectAllNativo");
        List pessoas = query.getResultList();

        return pessoas;
    }
   
    @SuppressWarnings("unchecked")
    public List buscarTodosComTelefone() {
       
        List resultado = new ArrayList();
        Query query = getEntityManager().createNamedQuery("selectAllNativoTelefone");

        List resultados = query.getResultList();
        for (Object object : resultados) {
            Object[] arranjo = (Object[]) object;
            Pessoa pessoa = (Pessoa) arranjo[0];
            Telefone telefone = (Telefone) arranjo[1];
            Collection telefones = new ArrayList();
            telefones.add(telefone);
            pessoa.setTelefones(telefones);
           
            resultado.add(pessoa);
        }

        return resultado;
    }

-----------------------------------------------

Em breve postarei como realizo a injeção do Entity Manager utilizando a classe DAOFactory. Qualquer dúvida ou coisa que precisarem me mandem mensagem.

Livro de EJB3 interessante

Estou começando um novo projeto e estou na parte das definições de tecnologias a serem utilizadas. Por falta de tempo para poder esperar algum livro em inglês resolvi comprar um livro em português mesmo sobre EJB3. O livro se encontra abaixo:

Enterprise JavaBeans 3.0 (Editora O'Reilly)

Pra minha surpresa a tradução do livro é muito boa e o livro é excelente. Possui exemplos bem explicados e cobre todos os tópicos de EJB3. As explicações são muito bem escritas e explicam desde o básico ao avançado. O livro em Inglês é muito bem avaliado na amazon e pelo que ví a versão traduzida não deixou muito a desejar.

Vai aí uma dica para quem quer aprender EJB3 e também não tem tempo para comprar um livro em inglês.

Livro de arquitetura interessante

O papel de arquiteto é bem interessante e desafiador e para isto devemos estar munidos de um bom arsenal de livros e sites que nos auxiliem. Queria através deste post comentar sobre um livro que estou lendo que estou achando bastante interessante.

Software Systems Architecture: Working
With Stakeholders Using Viewpoints and Perspectives

O livro como o próprio nome diz fala a respeito de arquitetura de software e alguns dos tópicos são bem interessantes. Entre eles cito os seguintes:

• Como projetar uma arquitetura que reflita os interesses dos stakeholders (partes interessadas).
• Como comunicar que sua arquitetura atende os requisitos dos diferentes interessados.
  
• Focar em aspectos arquiteturais importantes.
• Uso de perspectivas para verificar que sua arquitetura endereça importantes qualidades como escalabilidade, performance e segurança.
• Documentar a arquitetura como um conjunto de visões.

Ainda não terminei de ler o livro, mas até o momento ele se mostrou bem interessante. É bem esclarecedor tentar ver a arquitetura com diferentes visões de partes interessadas diferentes. Ele também mostra também alguns exemplos práticos o que torna a leitura mais fácil.

É isto aí pessoal. Para quem tem interesse no assunto vai aí uma boa dica de livro.

JSF versus Struts

O objetivo de ambos os frameworks é facilitar a implementação da lógica da parte de visão e implementar a divisão da lógica de visão e da lógica de negócios. Para comparar as duas tecnologias vamos comparar alguns quesitos importantes.

Um fator muito importante para arquitetos de software é o risco que se tem em um projeto. E podemos dizer que com relação ao numero de desenvolvedores Struts ganha e muito de JSF. Para tomar a decisão entre usar ou não esta tecnologia é bom conhecer a equipe de desenvolvimento do projeto em questão.

Outro fator importante é a maturidade do framework. Temos hoje vários sistemas em produção utilizando a tecnologia Struts enquanto temos uma quantidade bem menor de sistemas em produção utilizando JSF. Apesar de JSF ter evoluído bastante nestes últimos anos, temos que Struts ainda possui uma maturidade maior.

Com relação à evolução do framework JSF ganha de lavada, por se tratar de uma especificação. O Struts original parou na versão 1.3.9 e mudou totalmente de conceito na versão 2.0 em que foi substituído pelo framework WebWork apenas por questões de marketing.

Outro ponto que JSF ganha de lavada é com relação à maior flexibilidade do controle e o tratamento de eventos. Utilizando JSF não é necessária a extensão das classes Action e nem a utilização de formulários o que simplifica o desenvolvimento por tirar camadas desnecessárias.
Com relação à navegação tanto Struts quanto JSF são bem flexíveis, mas JSF supera devido ao fato das regras de navegação estar desacopladas das ações. Além disto, com JSF é mais fácil ter uma página com várias regras de navegação uma vez que não é necessária a utilização de ifs e elses.

Com relação à integração e extensibilidade mais pontos para JSF. Struts é neutro neste ponto, possuindo integração com apenas poucos frameworks, enquanto JSF possui integração com vários frameworks.

Com relação ao desenvolvimento de páginas temos mais ferramentas RAD para o desenvolvimento JSF, uma vez que o framework foi feito se pensando neste ponto. Outro fator a ser considerado é o apoio de grandes empresas. JSF tem tido o apoio de grandes empresas como IBM, Oracle e Red Hat o que torna a adoção ao framework maior, uma vez que dá o aval que o framework irá crescer e evoluir.

Uma desvantagem de JSF é o fato de ser menos transparente do que Struts. Com JSF existem muito mais coisas acontecendo por trás das cenas do que aplicações feitas em Struts, o que faz com que JSF seja mais difícil de entender e mais difícil de verificar a performance e otimizar.

E agora? O que vamos usar para decidir entre as duas tecnologias? Se vamos começar um projeto hoje, devemos considerar vários fatores. Se você não tem muito tempo para realizar a avaliação de frameworks e não tem uma equipe qualificada para a utilização de JSF decida por utilizar o framework Struts. Mas por uma visão estratégica, por ser uma tecnologia que irá evoluir, ter apoio das grandes empresas de mercado e por existirem ferramentas de desenvolvimento rápido eu encorajo a utilização de JSF.

Questões de UML

O que é UML?

UML ou Unified Modeling Language é uma linguagem gráfica para visualizar, especificar e construir e documentar os artefatos de um sistema.Ela permite criar boas práticas para todos os aspectos do sistema antes de efetivamente implementar o sistema.

O que é modelagem? Quais as vantagens de criar um modelo?

Modelos são simplificações da realidade. Modelagem é uma técnica de engenharia de software que permite a criação de modelos. A vantagem maior de se criar um modelo é poder se especificar a estrutura e os comportamentos do sistema.

O que são diagramas?

Diagramas são representações gráficas de um conjunto de elementos normalmente composto de objetos e associações.

Quais são os diagramas mais comumente utilizados?

Os diagramas mais comumente utilizados são: Diagramas de Caso de Uso, Diagrama de classes, Diagrama de Objetos, Diagrama de seqüência, Diagrama de estados, Diagrama de Colaboração, Diagrama de Atividades, Diagrama de componentes, Diagrama de Deploy.

O que são relacionamentos?

Relacionamentos são como ocorre a comunicação entre os diferentes elementos da UML.

Como os diagramas são divididos?

Os diagramas são divididos em diagramas estáticos e dinâmicos.

O que são mensagens?

Uma mensagem é uma especificação de uma comunicação entre dois elementos da UML. A message is the specification of a communication, when a message is passed that results in action that is in turn an executable statement.

O que é um caso de uso?

Um caso de uso especifica o comportamento de um sistema ou parte dele. Eles são utilizados para capturar o comportamento que precisa ser desenvolvido. Eles envolvem interação de atores e do sistema.

É isto aí pessoal. Espero que ajude...

Questões de Hibernate

Como configurar o Hibernate?

Você deve configurar o arquivo hibernate.cfg.xml ou hibernate.properties e os arquivos de mapeamento (*.hbm.xml) que são usados pelo SessionFactory. Utilizando o Hibernate com JPA os arquivos de mapeamento podem ser substituídos por anotações.

O que é o SessionFactory? Ele é um objeto thread-safe?

É um objeto responsável por gerenciar a criação de sessions para uma fonte de dados específica. SessionFactory é thread-safe de forma que várias threads podem o acessar simultaneamente requisitando objetos session.

O que são objetos transientes?

Um objeto é dito transiente quando não tem representação no banco de dados e nem o EntityManager o conhece. Isto significa que alguma alteração no objeto não é refletida na base de dados.

O que são detached Objects?

Objetos detached são objetos que são persistidos, mas não estão associados a uma sessão do Hibernate. Ou seja, o Entity Manager não o reconhece apesar de ser um objeto que possivelmente possui representação na base de dados.

Como o Hibernate distingue entre objetos transientes e objetos detached?

Para distinguir entre objetos transientes e detached o hibernate utiliza a propriedade version do objeto.

É isto aí pessoal. Se precisarem de outras questões podem mandar email. Espero que ajude...

EJB 3 versus Spring

O objetivo dos frameworks é esconder a complexidade dos desenvolvedores (como, por exemplo, controle de transações, segurança e persistência), facilitar o reúso de código, melhorar a produtividade e conseqüentemente melhorar a qualidade do software. E neste ponto podemos dizer que tanto Spring quanto o EJB 3 cumprem muito bem este objetivo.

O que podemos dizer então sobre os dois frameworks:

• O framework Spring é um framework popular, Open Source e é desenvolvido inicialmente pela empresa Interface21 Inc. Sua arquitetura é baseada principalmente em arquivos de configuração XML. O framework Spring não é um padrão de mercado e não possui apoio de grandes empresas como IBM, Oracle e Sun.
• O framework EJB 3 é um padrão de mercado definido pela JCP e é suportado pelas maiores empresas que utilizam J2EE. Possuem implementações disponíveis pelas empresas Jboss e Oracle. EJB 3 faz forte uso de anotações disponíveis a partir de Java 5. As versões anteriores de EJB se mostraram pouco produtivas e complicadas, o que foi modificado na versão 3 do framework.

Uma vantagem que vejo é o fato de EJB 3 ser independente de empresas. Como exemplo disto, temos o fato do Oracle usar o TopLink como implementação da especificação JPA e o JBoss ter como implementação o Hibernate.

Por outro lado temos que podemos rodar o Spring em qualquer servidor de aplicação, mas pelo fato do Spring não ser um padrão da indústria estamos travados ao Spring e os serviços fornecidos por ele.

Outra vantagem do EJB 3 é o fato de como o framework está fortemente acoplado com o servidor, estes servidores podem melhorar suas performance atuando em conjunto com o framework. A integração entre JTA e JPA com os servidores é bem alta o que faz com que os servidores sejam extremamente otimizados para este tipo de operação com EJB3.
Uma vantagem do Spring seria a facilidade de utilizar a injeção de quaisquer componentes. Com EJB 3 só se possui controle dos componentes que são Beans do EJB e também do contexto de persistência.

Com relação a XML ou anotação, temos EJB 3 utilizando preferencialmente anotações e Spring utilizando preferencialmente XML. Isto, podemos dizer que é a gosto do freguês. Particularmente prefira a anotações por ser menos verboso, mais robusto, além de possuir verificação de consistência em tempo de compilação.

Como conclusão, temos que ambos, são ótimos frameworks, sendo que cada um deles possui suas vantagens. Particularmente em um projeto novo decidiria pelo EJB 3 devido ao maior suporte das grandes empresas e por ser um padrão.

É isto aí pessoal. Espero que isto ajude alguém...

Questões de Struts para prova de seleção

Questões de Struts:

Como configurar o web.xml para utilizar o framework Struts?
Deve primeiramente configurar a ActionServlet que receberá todas as requisições e depois mapear alguma extensão como .do para o nome mapeado da servlet acima.

Quais são as classes principais do framework Struts?
As classes principais são:
ActionServlet, ActionForm, Action, ActionMapping, ActionForward e ActionErrors.

O que são classes Action?
Classes Action são responsáveis por realizar a adaptação entre a requisição http e a lógica de negócio correspondente. O controle selecionará a cada requisição a Action especifica, criará uma instância se necessário e chamará o método execute.

Uma Action é ou não Thread Safe?
Não. Apenas uma instancia da Action será utilizada para todas as requisições e por isto ela deve ser feita de uma maneira Thread Safe.

Qual arquivo deve ser alterado para prover suporte ao tiles?
Para prover suporte ao tiles deve ser alterado o arquivo struts-config para prover suporte a ele e deve ser definido um arquivo chamado tiles-def.xml.

Struts provê suporte ao Validator por default?
Não. Plugins adicionais devem ser utilizados para prover suporte ao Validate.

Estas são apenas algumas questões e possíveis respostas. Espero que estas perguntas ajudem.

Questões de EJB para prova de seleção

Questões de EJB:

Quais são os diferentes tipos de Enterprise Beans?

Os tipos de Enterprise Beans são Stateless Session Bean, Stateful Session Beans, Entity Beans e Message Driven Beans.

O que são Entity Beans?

Entity Beans são utilizados para representar os dados que serão persistidos no banco de dados. Eles provêem uma interface para dados que deveriam normalmente ser acessados utilizando JDBC ou outra API.

Qual a diferença entre Container-Managed Persistent (CMP) Bean e Bean-Managed Persistent (BMP)?

CMP é mais simples para desenvolver e mais difícil para o servidor EJB suportar, pois toda lógica de sincronização com a base de dados é realizada automaticamente pelo Container. Com CMP o Container é responsável por controlar a persistência de um Entity Bean.

Com BMP o Enterprise Bean é responsável por controlar o sincronismo do estado do objeto com o banco de dados. BMP permite ao desenvolvedor a flexibilidade de realizar operações que são muito complicadas para o Container ou utilizar um SGBD que não é suportado pelo Container.

O que é Bean Managed Transaction?

Se o desenvolvedor não deseja que o Container gerencie as transações pode-se programar todas as operações manualmente escrevendo o código JDBC apropriado. Para se utilizar o Bean Managed Transaction todo controle de transação deve ser feito pelo desenvolvedor. Utilizar BMT pode tornar sua implementação incompatível com algumas bases de dados e pode aumentar a quantidade de código a ser escrita.

É isto pessoal. Se quiserem mais perguntas e respostas sobre EJB me avisem. Em breve posto algumas perguntas e respostas sobre outras tecnologias.

Resultado da prova

Olá pessoal,

Desculpem mais um bom tempo sem postar. Estava fazendo um curso estas últimas semanas sobre JSF e não estava tendo muito tempo. A boa notícia é que fui aprovado na parte 3 da certificação de arquiteto e agora com o fim do curso terei mais tempo de postar no site.

Como próximo tópico para os posts colocarei algumas perguntas frequentes em provas de arquitetura e desenvolvimento. Todas as perguntas com uma resposta bem resumida. Agradeço muito aqueles que continuam lendo os posts.

Certificação SCEA

Olá pessoal,

Acabei de fazer hoje a parte 3 da certificação de arquiteto (SCEA). Para fazer pesquisei antes no site do javaranch algumas dicas sobre esta parte da certificação. A que achei mais interessante foi a seguinte:

Responda as seguintes perguntas e tome nota. As perguntas estão em Inglês propositalmente, pois a parte 3 deve ser respondida em Inglês. Inclusive é interessante responder estas perguntas durante a parte 2, pois isto te ajuda a verificar se sua solução está completa.

1) How does your design handle Scalability?
2) How does your design handle performance?
3) How does your design handle security?
4) How does your design handle Reliability?
5) How does your design handle Availability?
6) How does your design handle Extensibility?
7) How does your design handle Manageability?
8) How does your design handle Maintainability?

Para cada uma das perguntas abaixo responda também "Porque você escolheu?".

1) How does your design support session/state handling?
2) How does your design handle persistence?
3) How does your client tier talk to business tier?
4) How does your design handle Qos 5 Sec in peak time?
5) How does your design handle transactions?
6) How does your design handle authentication and authorization?

É isto aí pessoal. Espero ter ajudado...

Remodelagem no portal

Olá pessoal,

Nestes últimos tempos não tenho escrito muito. Mas tenho uma desculpa boa. Estou trabalhando no portal do arquiteto. Este que foi o pensamento inicial da criação deste blog e agora estou trabalhando nele. Em breve teremos um portal de arquitetura bem bacana.

Então aguardem pessoal pois em breve me porei uma meta de um post por dia e teremos um portal muito bacana.

[]s,

Samuel

Eclipse fechando sozinho

Olá pessoal,

Outro problema muito comum com o eclipse é quando ele fecha sozinho. Você está bem desenvolvendo sua aplicação e surpresa e ele simplesmente fecha. Porque isto acontece? Em grande parte dos casos isto acontece quando acaba a memória reservada para o eclipse simplesmente acaba.

Quando se esta programando para internet e se utiliza servidores web isto é muito comum. Na hora que se começa o servidor o eclipse inteiro fecha. Para acabar com este problema siga os seguintes passos:

1. Clique com o botão direito no atalho do eclipse.
2. Clique em propriedades.
3. Clique na aba atalho.
4. Onde está escrito Destino adicione no final o seguinte trecho “-vmargs -Xms256m -Xmx768m”.
   

Segue uma imagem que demonstra como isto será feito:



É isto aí pessoal. Qualquer problema podem enviar email...

Aumentando a memória do tomcat no eclipse

Olá pessoal,

Algumas pessoas me perguntaram sobre problemas com falta de memória utilizando o tomcat de dentro do eclipse. Então resolvi escrever este post falando sobre como isto seria feito.

Primeira coisa a ser verificada: O erro que estou tendo é por falta de memória mesmo? Como eu sei se o erro é por causa disto? Você vai conseguir identificar procurando no console do servidor o seguinte trecho: java.lang.OutOfMemoryError.

Este tipo de erro ocorre por falta de memória alocada para a JVM do Servidor Web. Se você estiver utilizando algum eclipse com plugins baseados no WTP a solução segue abaixo. Como fazer então para aumentá-la. Siga os seguintes passos:

1. No eclipse clique em -> Window -> Preference.
2. Na caixa de text digite tomcat.
3. Clique em JDK.
4. Escolha a JDK que você está utilizando.
5. Aonde está escrito Optional Java VM Arguments escreva -Xms256m -Xmx768m.
   

É isto aí pessoal. Bons estudos...

Aumentando a memória do tomcat no eclipse

Olá pessoal,

Algumas pessoas me perguntaram sobre problemas com falta de memória utilizando o tomcat de dentro do eclipse. Então resolvi escrever este post falando sobre como isto seria feito.

Primeira coisa a ser verificada: O erro que estou tendo é por falta de memória mesmo? Como eu sei se o erro é por causa disto? Você vai conseguir identificar procurando no console do servidor o seguinte trecho: java.lang.OutOfMemoryError.

Este tipo de erro ocorre por falta de memória alocada para a JVM do Servidor Web. Se você estiver utilizando algum eclipse com plugins baseados no WTP a solução segue abaixo. Como fazer então para aumentá-la. Siga os seguintes passos:

1. No eclipse clique em -> Window -> Preference.

2. Na caixa de text digite tomcat.

3. Clique em JDK.

4. Escolha a JDK que você está utilizando.

5. Aonde está escrito Optional Java VM Arguments escreva -Xms256m -Xmx768m.


Segue abaixo a imagem de demonstração:
Segue abaixo a imagem de demonstração:

É isto aí pessoal. Qualquer problema me avisem...

Passos para a prova SCWCD

Olá pessoal,

Depois de um bom tempo sem postar nada agora finalmente voltei. Estes ultimos tempos gastei bastante tempo fazendo a parte 2 da prova de arquiteto. Hoje finalmente consegui um tempo para escrever.

Para voltar a escrever resolvi voltar a falar sobre a certificação Sun Certified Web Component Developer (SCWCD). Esta é uma certificação que é bem interessante, pois a maior parte dos profissionais conhecem algum framework de desenvolvimento Web, mas grande parte não possui a mínima noção do que está acontecendo por trás.

Alguns conceitos não se aprendem por experiência apenas e sim somente depois de ler um bom livro.

Livros que recomendo:

Livro: Head first Servlets & JSP
http://www.amazon.com/Head-First-Servlets-JSP-Developer/dp/0596005407/sr=8-1/qid=1160009779/ref=pd_bbs_1/002-0192800-2332034?ie=UTF8&s=books

Sun Certified Web Component Developer Study Guide
http://www.amazon.com/Certified-Component-Developer-310-081-310-082/dp/0072258810/ref=pd_bbs_3?ie=UTF8&s=books&qid=1213039489&sr=8-3

Aconselho fortemente que vocês busquem esta certificação, pois acho ela bem importante para profissionais da área. Bons estudos...

Passos para a prova SCJP

Esta é a primeira das certificações Java. Na verdade é a segunda depois da criação da SCJA que é uma prova mais global. Como primeiro passo para a certificação, uma vez que vc adquiriu o voucher como explicado em http://portalarquiteto.blogspot.com/2008/03 é então se preparar para a prova.

E esta é a pior parte. Para a preparação então é interessante ler algum livro e também fazer provas sobre o assunto. Como livro aconselho que você dê uma olhada em 2 que são muito interessantes.

Um é o SCJP Sun Certified Programmer for Java 5 Study Guide que é um livro da Katie Sierra mais voltado para a certificação. Existe neste livro várias questões da prova com resposta e também explicação para as respostas. Este não é um livro para explicar passo a passo a linguagem, mas sim para te treinar para a certificação.

Outro livro muito bom também, que foi o que estudei e se chama Head First Java, 2nd Edition. Ele explica muito melhor sobre a linguagem e sobre sua lógica em sí, mas não explica muito sobre a prova. É uma leitura muito bacana (pelo menos eu achei), mas não é muito voltada para a certificação.

Vale a pena também estudar através de provas e simulados que se encontram nos seguintes sites abaixo:

• http://www.javaranch.com
• http://www.danchisholm.net
• http://www.michael-thomas.com/tech/java/index.html
• http://www.tipsmart.com
• http://www.whizlabs.com

Existem alguns programas que possuem simulados da mesma maneira, mas realmente nunca comprei, mas sei que são muito bons para quem quiser fazer a prova com mais tranquilidade.

Para quem for se aventurar a fazer as provas boa sorte e estudem porque não é tão simples como a maioria acha. Vou tentar postar mais posts, mas realmente estas semanas estão muito corridas, pois estou entregando minha monografia da pós.

Passos para realizar certificações SUN

A sequência de passos que vc precisa para qualquer certificação da SUN são:

1. Se prepare para os exames da maneira que você achar necessário.
2. Contate os Serviços Educacionais Sun para adquirir um voucher de testes ligando para 0800-55-78-63. (Os vouchers demoram algum tempo pra chegar)
3. De posse dos vouchers, marque seu teste em um local que seja mais conveniente através do site www.prometric.com.
4. Faça o teste no local e data indicada.

Como para realizar os testes da Sun não é necessário fazer o treinamento com eles, cada um se prepara da maneira que achar conveniente. Meu conselho pessoal é estudar por algum livro e se possível fazer alguns simulados.

Algumas pessoas também acham melhor comprar o voucher e depois se preparar, pois ele demora um pouco para chegar. Depois de comprar o voucher você tem um ano para utilizá-lo e isto é importante, pois muita gente perde a data.

Há também sites que disponibilizam conteudo e provas na web tais como:

• http://www.javaranch.com
• http://www.danchisholm.net
• http://www.michael-thomas.com/tech/java/index.html
• http://www.tipsmart.com
• http://www.whizlabs.com

A sequência de certificações é:
Para as provas SCEA, SCJA e SCJP não existe nenhum pré-requisito. Para o restante é necessário possuir a certificação SCJP que por sinal é a mais procurada.

Vou tentar postar ao longo destas semanas mais detalhes sobre algumas destas certificações.

Porque integrar mantis e subversion

Hoje me perguntaram sobre qual o benefício de se integrar o Mantis e o Subversion e então resolvi escrever este post. No ultimo serviço trabalhávamos com o Bugzilla, o SVN e também com o Cruise control.

Então a seqüência de passos lá era a seguinte:

1. Desenvolvíamos nossa parte do sistema e subíamos com nossas alterações para o SVN.
2. Então o Cruise control executava a integração de tudo que todo mundo mexeu.
3. Para cada vez que o Cruise control integrava e executava os testes de unidade com sucesso era gerada uma nova versão no SVN.
4. Então os testadores procuravam os erros nas versões geradas pelo Cruise Control (e consequentemente também no SVN).
5. Se achassem algum erro era cadastrado no Bugzilla junto com o número da versão do SVN.
6. Uma vez encontrado o erro este era corrigido e era colocada a versão provável em que a correção já estaria corrigida. Neste caso era mais uma estimativa, porque queríamos evitar que os testadores verificassem erros corrigidos antes deste ter sido integrado pelo Cruise Control.

Esta era a seqüência normal. No nosso caso não existia integração entre o SVN e o Bugzilla e então a gente olhava no Cruise control e colocava na mão o número da versão. Esta versão era importante para depois conseguirmos ver quando o erro ocorreu e também funcionava como uma proteção para os testadores. O pessoal só poderia colocar o erro como inválido se fosse testado na mesma versão em que o erro foi cadastrado.

Não utilizei ainda os dois integrados ainda, mas a integração é então importante para que você cadastre o erro para a versão correspondente e para que a ferramenta te auxilie com isto.

Diagrama de objetos

Na prática este é mais um dos diagramas muito pouco utilizados. O diagrama de objetos é uma variação do diagrama de classes e utiliza quase à mesma notação. O diagrama de objetos é como se fosse o perfil do sistema em certo momento de sua execução.

Existem apenas duas diferenças entre o diagrama de classes os objetos são escritos com seus nomes sublinhados e todas as instâncias num relacionamento são mostradas. Este diagrama é importante para se ter uma visão do sistema em determinado tempo e para se conferir se os dados estão atribuídos corretamente no tempo e se são consistentes.

Segue abaixo um exemplo de um diagrama de objetos:

O exemplo acima mostra um diagrama de objetos para o cliente Michael Richardson e seus dois pedidos na Virtual LTDA. O diagrama pode ser lido da seguinte maneira: O objeto R. Michael Richardson da classe Cliente está associado a ambos os objetos 123456 e 123700 da classe Pedido. Usa-se o diagrama de objetos para modelar a visão estática de um sistema. Ele mostra o retrato do sistema em determinado momento.

É isto aí pessoal. Qualquer problema entrem em contato...

Diagrama de robustez

Este é um diagrama que não existe na UML e é geralmente um diagrama de colaboração adaptado e que faz uso dos estereótipos entity, boundary e control. Ele é utilizado em processos como o ICONIX para passar da análise (o que) para o desenho (como).

Através da análise de robustez, podemos fazer a verificação de sanidade, isto é, a verificação se o texto do caso de uso está correto e que ele não representa para o sistema que não é razoável ou impossível.

Este é um diagrama que não é necessário ser mantido atualizado uma vez que é utilizado apenas para a transição. Sendo assim, ao criar os diagramas, é perfeitamente plausível usar apenas lápis e papel.

A análise de robustez consiste então em ler o texto do caso de uso e identificar de forma preliminar, o conjunto de objetos que irão participar do caso de uso. Em seguida deve-se percorrer cada passo do caso de uso desenhando os atores, as classes de fronteira, os controladores, as entidades e a conexões entre elas.

As seguintes regras devem ser obedecidas:

1. Atores interagem apenas com objetos de fronteira (boundary)
2. Objetos de fronteira podem interagir com atores e controladores.
3. Objetos de entidade interagem apenas com controladores
4. Controladores interagem com qualquer outro tipo de objeto e também com outros controladores, mas nunca com atores.

Diagrama de componentes

O Diagrama de componentes da UML ilustra como as classes deverão se encontrar organizadas através da noção de componentes de trabalho. O diagrama tem por objetivo apresentar a disposição dos componentes físicos de um sistema.

O principal objetivo deste diagrama segundo Scott Ambler, é possibilitar a construção de artefatos para o perfil de arquitetura da solução, seja para a arquitetura técnica ou a de negócios.

O diagrama é composto normalmente por componentes, interfaces e portas. Os componentes são representados pelo estereótipo da uml <> ou um retângulo vertical de duas hastes. Interfaces são representadas através de uma linha com um círculo ou semicírculo ligado ao componente. Portas são representados através de retângulos saindo dos componentes.

Normalmente é utilizado para:

• Modelar os componentes do código-fonte, do código executável do software.
• Destacar a função de cada módulo para facilitar a sua reutilização.
• Auxiliar no processo de engenharia reversa, por meio da organização dos módulos do sistema e seus relacionamentos.

Retirado de http://www.rnp.br

Diagrama de máquina de estados

O diagrama de máquina de estados era conhecido nas versões anteriores como diagrama de gráfico ou simplesmente como diagrama de estados, tendo então mudado para este novo nome após a versão 2.0. Este diagrama procura acompanhar as mudanças sofridas nos estados de uma instância de uma classe ao longo da execução de um caso de uso, subsistema ou mesmo sistema.

O Diagrama de máquina de estados muitas vezes se baseia no caso de uso e se apóia no Diagrama de Classes.

Retirado de http://www.comp.ita.br/~olany/State_Diag2.jpg

O diagrama acima mostra um diagrama de máquinas de estado. Este diagrama mostra como ocorrem as alterações nos estados de um objeto após terem sido realizados ações sobre este.

Diagrama de Comunicação

O diagrama de comunicação é o antigo diagrama de colaboração até a versão 1.5 da UML, tendo modificado seu nome a partir da versão 2.0. Este é um diagrama bem parecido com o diagrama de seqüência, mas não possui seu aspecto temporal.

Ele normalmente é utilizado como complemento do diagrama de seqüência, porem possui um enfoque diferente, concentrando-se em como os objetos estão vinculados através de mensagens. Pode ser gerado a partir do diagrama de seqüências por representar os mesmos dados. Outra característica do diagrama de comunicação é que as mensagens possuem numeração para designar seqüência.

Figura retirada de http://www.novatec.com.br

Nesta figura é mostrado o diagrama de comunicação do caso de uso realizar submissão. É mostrado as mensagens trocadas entre o Submissor, a página do congresso, o controlador do congresso, o tema e a Submissão.

Diagrama de estrutura composta

Olá pessoal,

Quis hoje começar a debater sobre alguns diagramas da uml 2.0 que são pouco utilizados. O primeiro da lista de diagramas pouco utilizados é o diagrama de estrutura composta.

O diagrama de estrutura composta é utilizado para modelar colaborações. Uma colaboração descreve uma visão de um conjunto de entidades cooperativas interpretadas por instâncias que cooperam entre si para executar uma função específica.

Então podemos dizer que o diagrama de estrutura composta reflete a colaboração interna das classes para descrever a funcionalidade. São bem similares aos diagramas de classes, exceto pelo fato de que eles modelam um uso específico da estrutura.

Retirado de http://www.novatec.com.br

O termo estrutura se refere à composição dos elementos estruturais interconectados de forma a atingir algum objetivo comum. O exemplo acima mostra como as instâncias das classes autor, submissão, tema e tipo colaboram entre si para submeter à submissão. As colaborações podem também possuir multiplicidade, se as regras seguidas pelas classes utilizarem múltiplas instâncias.

Este é um diagrama que não é muito utilizado na UML e provavelmente é mais um diagrama teórico do que um diagrama utilizado nos processos de desenvolvimento.

Ferramenta de integração contínua

Integração contínua consiste em integrar o trabalho diversas vezes ao dia, assegurando que a base de código permaneça consistente ao final de cada integração.

A este mesmo procedimento de construção podem ser adicionadas rotinas como:

• Execução de testes automatizados
• Geração de versões internacionalizadas de seu software
• Disponibilizar a versão atual em desenvolvimento para o cliente
• Criação de relatórios de código como:
• Cobertura de testes
• Inspeção de padrões de codificação
• Estatísticas de acoplamento

Todo o processo segue a arquitetura descrita na imagem abaixo:

O cenário acima pode ser descrito como: (Fonte: Continuous Integration)

1. O desenvolvedor envia o código para o controle de versão (SVN, CVS, etc). Enquanto isso a máquina de integração (servidor de Integração Contínua) está verificando o repositório buscando por modificações
2. Logo após um commit ser efetuado, o servidor ao verificar que alguma mudança ocorreu no repositório inicia o processo de build baixando os arquivos do Servidor de Controle de Versão. Assim, o script de build é executado, testes são realizados, relatórios gerados, e todo o projeto é integrado.
3. O Servidor de Integração envia por e-mail ou outros dispositivos o feedback sobre build para usuários específicos do projeto
4. O servidor volta ao estado de Poll buscando por mudanças no repositório

Com relação a ferramentas a serem utilizadas e a comparação entre elas temos 3 que se destacaram. Entre elas temos as ferramentas cruise-control, continuum e hudson.

Minha escolha pessoal é a utilização do Hudson. Entre as funcionalidades que mais me agradam estão:

• Permite a configuração de novos jobs através de interface web.
• Permite a realização de builds distribuídos.
• É um projeto mais ativo com mais desenvolvedores.
• Possui plugin para o eclipse.
• Possui instalador do windows.
• Utilização por parte de grandes projetos.
• Integração com o Maven, SVN, CVS e com outras ferramentas.
• Facilidade maior para configuração do que as outras ferramentas.

Controle de versão

A cada dia sistemas de versão concorrente vem sendo utilizados para os mais diversos fins. No passado era realidade apenas em grandes ambientes de desenvolvimento paralelo, onde literalmente dezenas de desenvolvedores demandavam acesso simultâneo aos mesmos arquivos, e ter um sistema de versão concorrente era imperativo para garantir adequadamente um ambiente de trabalho concorrente, e principalmente, garantir segurança desses dados, de forma que se um desenvolvedor interferisse negativamente no trabalho de outro, as mudanças em questão pudessem ser facilmente revertidas ao estado anterior.

Então o controle de versões é visto como uma extensão natural do processo de desenvolvimento, permitindo que se possa paralelizar o desenvolvimento de forma coerente e padronizada.

Hoje existem dezenas de opções de sistemas de versionamento de projetos, esses sistemas são conhecidos com SCM ou apenas VCS (Version Control System). Alguns sistemas VCS comerciais, mais conhecidos são:

• Clear Case
• Microsoft Team Foundation

E alguns sistemas de controle de versão livre, mais conhecidos são:

• CVS
• Subversion
• GIT

Outros sistemas menos conhecidos:

• Visual Source Safe
• PVCS
• SVK
• HG
• BZR
• Perforce

Temos como preferência utilizar sistemas open source e pelo conhecimento do CVS e do Subversion iremos basear os estudos e comparações nos dois sistemas.

O sistema aberto mais conhecido é o CVS, exatamente por existir a mais tempo, e ser a primeira implementação livre com um número de recursos que o tornasse viável a ser utilizado em todo tipo de ambiente, de qualquer porte, de projetos pequenos a gigantescos. O CVS é a opção de escolha mais comum, entre livres e comerciais. Ao menos por enquanto.

Subversion é uma ferramenta open-source de controle de versão (veja o tutorial sobre controle de versão de software para mais informações). Segue a licença de software livre nos moldes da licença Apache/BSD.

O projeto do Subversion iniciou em 2000 com a idéia de se construir um CVS melhor, isto é, mantendo o mesmo modelo de trabalho, mas consertando as falhas e limitações que o CVS apresenta. Desde então, vem atraindo uma comunidade cada vez maior de colaboradores e usuários.

O Subversion tem a maior parte das funcionalidades do CVS. De modo geral, a interface do Subversion segue à do CVS. Isto facilita a transição dos usuários do CVS para o Subversion.

Controle de Diretórios, Renomeações e Meta-Dados

Esta era uma das maiores reclamações sobre o CVS. Subversion não só controla a versão do conteúdo dos arquivos, mas também de diretórios, cópias, renomeações e meta-dados.

Operações Atômicas de commit

Um conjunto de modificações a serem realizadas num commit é aceito como um todo ou nenhuma alteração é feita. Não há a possibilidade que apenas uma parte das alterações seja aceita quando enviadas ao repositório tal como acontecia no CVS. Além disso, os números de revisão estão atrelados a cada operação de commit e não aos arquivos.

Opções de Acesso à Rede

Subversion foi projetado para uma camada abstrata de acesso ao repositório, o que permite a implementação de novos mecanismos de rede. Um dos mecanismos existentes usa o protocolo WebDAV/DeltaV baseado em HTTP através do Apache 2. A outra opção é o servidor dedicado svnserve como opção ao Apache, e que pode ser combinado ao ssh.

Arquivos Binários e de Texto Tratados Consistentemente

Outro grande problema bastante conhecido é que o CVS que não funciona tão bem com arquivos binários. Por outro lado, o Subversion usa um algoritmo de diferenciação binário que funciona de modo idêntico tanto para arquivos texto (legíveis por humanos) quanto para arquivos binários (ilegíveis para humanos).

Ramificações e Rotulações em Tempo Constante

O tempo das operações de ramificação (branching) e rotulação (tagging) é constante, e não depende do tamanho do projeto no repositório. Esse resultado é obtido através da forma de implementação do Subversion para essas operações, que é feita como uma operação de cópia que resulta em links, ocupando pouco espaço e um intervalo de tempo constante.

Uso mais Eficiente da Rede

O protocolo de rede usa a largura de banda eficientemente enviando as diferenças entre cliente/servidor e servidor/cliente sempre que possível, ao contrário do CVS que envia as diferenças do servidor ao cliente, mas não do cliente ao servidor.

A seguir, é apresentado um pequeno quadro comparativo entre o CVS e o Subversion (SVN). Ressaltamos que este quadro não representa uma comparação completa.

Funcionalidade	CVS	SVN
Commit Atômico	X	V
Renomeações e cópias de arquivos e diretórios	X	V
Rastreamento de Fusões (Merge)	P	PF
Permissões de Repositório	P	V
Documentação Disponível	V	V
Portabilidade	V	V
Open Source	V	V
Interfaces Gráficas	V	V
Suporta Grande Repositório	V	V

Legenda:

(V) Possui tal funcionalidade

(X) Não possui tal funcionalidade

(P) Atende parcialmente o requisito

(F) Existe previsão para implementação da funcionalidade no futuro

(A) Informações insuficientes para classificação