WEBCODELOG

Dando continuidade a customização do toString(), certamente existirá aquele atributo que você não irá querer exibir no toString(), então seguindo a dica do @pauloprestes, resolvido com annotations:

Aqui está a interface para a anotação, o melhor seria utilizar o Target como FIELD, porém, como falei vamos exibir os atributos com base nos métodos públicos Getters.

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface NoToString{}

Na classe ToStringUtil foi apenas acrescentado uma regra para não exibir os métodos marcados com a anotação @NoToString, sendo:

// Nao exibir os métodos que estejam com a Annotação NoToString
boolean isNotAnnotation = m.isAnnotationPresent(NoToString.class);

Realizei alguns testes com tipos complexos e funcionou, talvez você tenha alguma sugestão para melhorar este tipo de tratamento.

Baixe aqui a versão 1.0.2.

Namastê!

É comum sobrescrever o método toString() da classe Object, facilita em situações como quando é necessário saber o conteúdo de um Bean, por exemplo. Sobretudo, reescrever este método poderá ser trabalhoso se você tem muitos atributos e cansativo, se você o fizer para todos os seu beans.

Pensando nisso resolvi criar uma classe útil que mostre todos os atributos Privates da sua classe juntamente com seus respectivos valores. Veja o código abaixo, em um bean eu reescrevi o método toString() fazendo um looping em todos os atributos:

public class Equipamento implements Serializable {
private String modelo;
private String marca;
private String descricao;
private Date fabricacao;

/*** getters/setters ocultados **/

public String toString(){
StringBuffer b = new StringBuffer();
// Obtem todos os atributos da classe
Field[] fields = this.getClass().getDeclaredFields();
b.append( this.getClass().getName() );
b.append( " { \n" );
for (int i = 0; i < fields.length; i++) {
try {

Field field = fields[i];
b.append( field.getName() );
b.append( " = " );
b.append( field.get(this) );
b.append("\n");

} catch (IllegalArgumentException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
}
}
b.append( " } " );
return b.toString();
}
}

A reescrita do método acima resolve parcialmente o nosso problema, além de não atender aos tipos de dados complexos, você terá que fazer o famoso copy-paste para todas as classes que forem implementa-lo.

Voltamos então para nossa idéia inicial, então criaremos uma classe útil para que a automatização do toString(), sendo assim, qualquer classe poderá utiliza-la. Saiba que não iremos ter acesso aos atributos assinados com o modificador Private da classe que deseja utilizar o toString customizado, para resolver tal problema utilizaremos os Métodos públicos, ignorando os métodos da classe Object e aproveitando apenas os métodos acessores.

public final class ToStringUtil{
/*** ocultado ***/

public static String getText(Object object){
StringBuffer buffer = new StringBuffer("");
Method[] methods = object.getClass().getMethods();

for( Method method : methods ){
//
// verifica se o método é um Getter de attributo da classe
//
if( isGetterFieldMethod(method, object.getClass()) ){
buffer.append( getResumeNameMethod( method.getName() ) );
buffer.append("   = ");
buffer.append( getMethodReturnValue(object, method) );
buffer.append( NEW_LINE );
}

}// for each end

return buffer.toString();
}

/*** ocultado ***/
}

Esta versão ainda continua com o problema de tipos complexos, assim que eu for melhorando vou disponibilizar por aqui.

Download
Versão completa ToStringUtil 1.0.1.

Referência
Reflection

Lembro de um camarada me dizendo: “Fiz um browser em Java com menos de 20 linhas de código” – Acredite, era verdade! Okay! Okay! Sem recurso nenhum básicamente, apenas a barra de endereços, mas e daí? Assim como esse meu amigo, provavelmente você já tem aquela classe para envio de e-mails guardada na manga, muito útil naqueles dias em que seu chefe pressiona: “É pra ontem!”

Mas… você já tentou montar seu cliente de email? “Pra quê, cara? Eu uso o Gmail” – você irônicamente me responderia, e na tréplica eu diria: Ué! Pra quê o Gmail, se você pode fazer melhor meu rapaz! (sarcástico, não?) Mãos a obra!

O pacote javax.mail.* fornece uma série de recursos para protocolos de internet, utilizando-o como uma receita de bolo o sucesso é garantido. Basicamente vamos criar um programa que monitore a caixa de entrada de um determinado endereço POP3.

Coloque os dados de acesso ao mail em um arquivo config.properties, assim:

pop.hst=pop.lucianosilva.com.br
pop.usr=boss@lucianosilva.com.br
pop.pwd=ABC123#XYZ

A classe abaixo se encarregará de obter estes dados de conexão:

public class PropertiesMail extends Properties{
private static final String ARQUIVO_CONFIGURACAO = "C:\\config.properties";

public PropertiesMail(){
try{
FileInputStream file = new FileInputStream( ARQUIVO_CONFIGURACAO);
this.load( file );

}catch(IOException e){
e.printStackTrace();
}
}

public String getHost(){
return this.getProperty("pop.hst");
}

public String getAccountUser(){
return this.getProperty("pop.usr");
}

public String getAccountPassword(){
return this.getProperty("pop.pwd");
}

}

Agora, a caixa de correios. Veja que o processo abaixo básicamente segue um roteiro, mas é óbvio que isto é feito apenas para a leitura.

public class Inbox{

public Inbox(){
try {
init();
} catch (MessagingException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}

private void init() throws MessagingException, IOException{
// Instância das Propriedades de Conexão
PropertiesMail ppm = new PropertiesMail();
// Seta o endereço do host
Properties pp        = System.getProperties();
pp.put("mail.pop3.host", ppm.getHost());

// Se o servidor exigir autenticação segura
Authenticator auth = new PopAuthentication();
Session session    = Session.getDefaultInstance(pp, auth);

Store store           = session.getStore("pop3");
// Dados básicos de conexão
store.connect(ppm.getHost(), ppm.getAccountUser(), ppm.getAccountPassword());

// Obtem o diretório (INBOX)
Folder folder       = store.getFolder("INBOX");
folder.open(Folder.READ_ONLY);

// ler as mensagens do diretório
Message message[] = folder.getMessages();

processMessage(message);

// Close connection
folder.close(false);
store.close();
}

private void processMessage( Message[] message ) throws MessagingException, IOException{
if( message == null || message.length==0 ){
System.out.println("Nenhuma mensagem encontrada");
}else{
for (int i=0, n=message.length; i
System.out.println(i + ": " + message[i].getFrom()[0] + "\t" + message[i].getSubject());
String content = message[i].getContent().toString();
System.out.print(content);
}// for end
}
}

public static void main(String[] args){
Inbox inbox = new Inbox();
}
}

Muito fácil não? Mas este é um exemplo simples mesmo, saiba que é possível fazer todo o controle de um cliente de e-mail não só Ler, como Escrever, Apagar, Mover, etc.

Downloads

Projeto utilizado para este post.
JavaMail API

Veja mais sobre JavaMail

JavaMail API
jGuru: Fundamentals of the JavaMail API
WebMail in Java: Reading E-mail
Have a fun!

Conhecida em várias linguagens e ambientes o InitCap tem a função de transformar o primeiro caracter de cada palavra em maíusculo e o restante em minúsculo. Infelizmente o MySql não disponibiliza essa funcionalidade nativa, portanto, você terá que criá-la.

Essa é a minha versão do InitCap em Java.

private static final String SEPARADOR[] = {"do","da","de","e","dos","das"};

/**
* @author lsilva
* @param in
* @return
*/
public static String initCap( String in ){
String out    = null;
String[] part = in.split(" ");
StringBuffer temp = new StringBuffer();

for (int i = 0; i<part.length; i++){

if( i>0 ) temp.append(" ");
if( ehSeparador( part[i] ) ){
temp.append( part[i].toLowerCase() );
}else{
temp.append( part[i].substring(0, 1).toUpperCase() );
temp.append( part[i].toLowerCase().substring(1, part[i].length()) );
}
}// for end

out = temp.toString();
return out;
}

/**
* @author lsilva
* @param sep
* @return
*/
private static boolean ehSeparador(String sep){
boolean r = false;
for (int i = 0; i < SEPARADOR.length; i++){

if( sep.equalsIgnoreCase( SEPARADOR[i] ) ){
r = true;
break;
}else{
r = false;
}
}
return r;
}

Depois de algumas discussões e muita zuação, meu amigo Orlando disse: “Muita firula pra pouca coisa, faz assim cara:

/**
* @author oneto
* @param n
* @return
*/
public static String initCap( String n ){
String[] x                      = n.split(" ");
StringBuffer r  = new StringBuffer();
String e                        = " de , da , des , da ";

for (int i = 0;i<x.length;i++){
if(e.indexOf(x[i].trim().toLowerCase())< 0){
r.append(x[i].substring(0,1).toUpperCase() + x[i].substring(1,x[i].length()).toLowerCase() + " " );
}else{
r.append(x[i].toLowerCase() + " ");
}
}
return r.toString().trim();
}

Essa função pode ser feita de diversas outras maneiras, aqui foram apenas sugeridas algumas. Muitas vezes você não precisará criar basta pesquisar sobre a linguagem utilizada, por exemplo, em PHP a função nativa para isto é o ucwords.

That’s all.