Muita coisa aconteceu nesse pouco tempo que fiquei sem escrever, mudei bastante minha vida profissional, enfrentando novas frentes de trabalho e novas tecnologias. Mas é extremamente gratificante poder trabalhar com novas tecnologias, sair da zona de conforto e enfrentar novos desafios. Nesse tempo tive a oportunidade de conhecer muitas coisas novas, que até então eu só conhecia na teoria, outras nem isso, mas estou crescendo bastante com isso, e apesar de requerer mais esforço, dedicação e muito mais tempo de estudo, vale muito a pena.

Há algum tempo mudei bastante meu foco que era trabalhar somente com desenvolvimento Java e comecei a trabalhar com integração de sistemas, com base nos conceitos de SOA e BPM, e há aproximadamente 3 meses meu foco de trabalho mudou novamente, e estou tendo a oportunidade de atuar em projetos de Business Intelligence. Para quem não conhece irei explicar um pouco todos esses conceitos em próximos artigos.

Atualmente estou trabalhando na Splenda, uma empresa de consultoria em TI relativamente nova, mas que está alavancando seu crescimento em uma velocidade incrível e o melhor de tudo é que estou tendo a oportunidade de fazer parte disso tudo, e podendo trabalhar com pessoas fantásticas!

Também estou ajudando a manter outros dois blogs, e convido cada um de vocês a visitá-los. Um deles é sobre a ferramenta open source de integração Talend, é uma ferramenta simplesmente fantástica, o endereço para acesso é www.talendbrasil.com.br. O segundo é sobre o appliance de Data Warehouse Netezza, que realiza o acesso e consultas de dados na casa do terabytes em uma velocidade mínima, a url para acesso é www.netezzabrasil.com.br.

 O objetivo inicial desse blog era falar sobre a tecnologia java, e sim, sempre que puder continuarei a escrever sobre ela, mas irei entrar em muitos outros assuntos, não restringirei o blog só a Java, quero abranger esse blog para assuntos relacionados como carreira, negócios, e tudo mais o que aparecer.

Basicamente é isso, espero poder ampliar o leque de conhecimento disponibilizado aqui no blog, e que possa facilitar e agregar conhecimento na vida de quem passar por aqui. Em próximos posts vou falar sobre algumas ferramentas open source nas áreas de SOA, BPM e BI, com review de todas elas, alguns exemplos, etc. E espero poder contar a ajuda de vocês, com críticas e sugestões, etc. E não deixem de acessar: Netezza Brasil e Talend Brasil.

Um grande abraço a todos!

Supomos que iremos criar um módulo de manutenção de clientes (incluir, excluir, recuperar e atualizar), e convenhamos que ao efetuar tais processos possam ocorrer erros, como tentar recuperar um cliente e o mesmo não constar no banco de dados, incluir um cliente já existente, efetuar login e os dados estarem incorretos, etc. Então criaremos uma exceção genérica que representa os erros que podem ocorrer com o nosso módulo de manutenção de clientes.

Para criarmos nossa exceção basta estender a classe Exception, presente no pacote java.lang.Exception, da seguinte forma:

public class UserException extends Exception {

     public  UserException() {
          super();
     }

      public  UserException(String message) {
          super(message);
      }

 }

E pronto, nossa exceção está criada! Agora vamos criar um método que valida um usuário, ou seja, toda vez que quisermos adicionar, recuperar, etc, passaremos para os respectivos métodos um modo de validar um usuário para verificar se ele possui dados válidos como id, nome, login, password, etc.

public void validateUser(User user) throws UserException {

     boolean validate = true;
     String msg = "";
     if (user.getName() == null) {
         msg = "Invalid Name!";
         validate = false;
     } else if (user.getPassword() == null) {
         msg = "Password is Empty!";
         validate = false;
     }
     if (!validate) {
         throw new UserException(msg);
     }

}

Analisando o código, na declaração do método utilizamos a palavra chave throws, isso significa que todo método que utilizar o “validateUser()” terá que tratar a exceção ou então utilizar a palavra chave throws novamente no cabeçalho do método para informar que ele não irá tratar a exceção naquele momento, ou seja estamos declarando nossa exceção. Na linha 22, utilizo a palavra chave throw, que indica que a exceção será lançada quando chegar naquela linha, e passo como parâmetro da exceção a minha mensagem de erro personalizada. Vejamos como funcionam o tratamento com o bloco try, catch, e a declaração utilizando throws.

Supomos que temos classe que responsável por efetuar o login do usuário chamada LoginUser, na qual possui um método para efetuar login, vejamos a versão do método utilizando try – catch:

public boolean login(User user) {

      boolean validate = false;
      try {
          new User().validateUser(user);
          validate = true;
          System.out.println("Success on Login!");
      } catch (UserException ex) {
          System.out.println(ex.getMessage());
          validate = false;
      }
      return validate;
 }

Nessa versão do método login nós utilizamos o método validateUser() da classe User, e tratamos a exceção utilizando o bloco try – catch. Dentro do bloco validamos o usuário, caso tudo tenha ocorrido corretamente ele retorna verdadeiro, caso contrário, a execução entrará no bloco catch e lançará uma mensagem utilizando o método getMessage() da superclasse de todas as exceções e erros, Throwable. Vejamos agora a versão do método login() utilizando a palavra chave throws e deixando o tratamento para outro momento, efetuando somente a declaração da exceção.

public void login(User user) throws UserException {
      new User().validateUser(user);
}

Nesse caso como não tratamos a exceção, simplesmente declaramos que ela pode ser lançada é necessário adicionar throws nomeDaExceção, no cabeçalho do método, lembrando que dessa forma eu estou deixando para a exceção ser tratada na próxima utilização do método login, diferente caso ao tivesse tratado a exceção.

Lembrando que também poderíamos ter utilizado a palavra chave throw(não confundam com throws), simplesmente para lançar nossa exceção em determinada parte do código, como fizemos na segunda listagem desse artigo.

Finalizamos aqui uma visão prática sobre o mecanismo de exceções em Java, sendo que essa é só a ponta do iceberg, pois ainda há bastante conteúdo sobre o assunto para se discutir, mas por hora fico por aqui, espero que tenham gostado e principalmente entendido, até o próximo artigo.

public class UserException extends Exception {

public  UserException() {

super();
}

public  UserException(String message) {

super(message);
}

}

public void validateUser(User user) throws UserException {

boolean validate = true;

String msg = "";

if (user.getName() == null) {

msg = "Invalid
Name!";

validate = false;

} else if (user.getPassword() ==
null) {

msg = "Password is
Empty!";

validate = false;
}

if (!validate) {

throw new UserException(msg);
}

}

public boolean login(User user) {

boolean validate = false;

try {

new User().validateUser(user);

validate = true;

System.<em>out</em>.println("Success on Login!");

} catch (UserException ex) {

System.<em>out</em>.println(ex.getMessage());
validate = false;
}
return validate;

}

public void login(User user) throws UserException {
new User().validateUser(user);
}

Na primeira parte desse artigo irei abordar de forma sucinta como funciona o tratamento de exceções em Java, como manipular, criar e lançar.

O que é?

É uma ocorrência que altera o fluxo normal de um programa, algo que foge do fluxo padrão.

A estrutura básica para o tratamento de uma exceção é formada pelas seguintes palavras-chave:

• try – É usado para inserir um código que possa causar alguma exceção.
• catch – Manipula a exceção.
• finally – Sempre será executado, independente do que acontecer  dentro do bloco try-catch.

Ex.:

try{

Coloque aqui código que poderá resultar em algum erro.

}catch(Exceção e){

Coloque aqui código que manipula a exceção.

}finally{

Coloque aqui código que sempre será executado independente do que ocorra dentro do bloco try-catch-finally.

}

Existem dois tipos de exceções: verificadas e não verificadas, vejamos a árvore de herança das exceções e depois analisaremos e diferenciaremos seus tipos.

Hierarquia de exceções

Throwable é a classe pai de todas as Exceções, e dela saem duas subclasses principais “Error” e “Exception”. As classes derivadas de Error significam erros que não ocorrem normalmente e que não são causadas por erros de lógica no programa, e sim por problemas externos como falta de memória, geralmente não são manipulados. As exceções são derivadas da classe Exception. Existem dois tipos de exceções, as verificadas e não verificadas. Todas as subclasses de RuntimeException (incluindo ela mesma) são consideradas exceções não verificadas, ou seja, mesmo se você declarar uma RuntimeException em seu código, você não será obrigado a manipulá-la. Sendo que a maioria das RuntimeExceptions terão sua origem em um problema de lógica do seu programa, um exemplo é a classe NullPointerException.

As demais exceções derivadas de Exception são as chamadas exceções verificadas, ou seja, podem ser manipuladas com cláusulas try-catch, declaradas ou lançadas com a palavra chave “throws”.

Algumas observações são válidas:

-Não é válido usar uma claúsula try sem uma catch ou finally (É possível omitir uma cláusula catch ou uma finally, mas não as duas);

-Não é válido usar uma cláusula catch sem uma try.

-Qualquer claúsula finally deve vir imediatamente após a claúsula catch ou após a try, caso não haja uma cláusula catch.

Por enquanto fico por aqui, espero que tenham gostado, e no próximo artigo citarei de forma prática o tratamento de exceções.