JFileChooser, com algumas dicas fica melhor ainda.

Em algum momento você precisou, precisa ou precisará utilizar essa Classe, que contém os métodos necessários para"abrir" um arquivo.
Com ele, você pode exibir aquela janelinha legal do Sistema Operacional que permite ao usuário selecionar algum arquivo, para que ele seja "aberto" pelo seu sistema.
Mas não existe nada de complicado, muito pelo contrário, é muito simples fazer essa janelinha aparecer.

Crie uma classe chamada FileChooser, e copie o código abaixo para ela.

package br.teste;
            import javax.swing.JFileChooser;
            public class FileChooser {
                        public static void main(String[] args){
                               JFileChooser arquivo = new JFileChooser();
                               arquivo.showOpenDialog(null);
                        }
            }

Pode executar!
Viu que legal?
Mas o que acontece com o arquivo selecionado? Por enquanto nada! Seu código está apenas mandando a janela abrir, mas não está nem ao menos verificando se ela abriu!
Podemos contornar esse pequeno problema com o seguinte ajuste.

package br.teste;
            import javax.swing.JFileChooser;
            public class FileChooser {
                        public static void main(String[] args){
                              JFileChooser arquivo = new JFileChooser();
                              int retorno = arquivo.showOpenDialog(null);
                              if(retorno == JFileChooser.APPROVE_OPTION){
                                     //abriu!
                              }else{
                                      //não abriu
                              }
                     }
            }

A janelinha retorna um INTEIRO, dizendo se foi clicado no botão Abrir, no botão Cancelar, se deu Erro, ou qualquer outra coisa que aconteça, mas não nos interessa saber quais são esses inteiros, por que a própra classe temConstantes para esse tipo de situação.
O ajuste acima cria um inteiro para receber o retorno do JFileChooser, se o retorno for o botão "Abrir", representado pela constante APPROVE_OPTION, então faz alguma coisa, senão faz outra coisa.

Mas o que fazer?

O JFileChooser serve "apenas" para localizar um arquivo, mas abrir, deletar, copiar, etç, deve ser feito por você, utilizando algum outro código. O JFileChooser te ajuda informando o caminho do arquivo, e é isso que devemos pegar depois que o botão "Abrir" for selecionado.

O comando que faz essa magica é o getSelectedFile().getAbsolutePath(), que retorna uma String. Depois você decide o que faz com essa String.

O código atualizado.

            package br.teste;
            import javax.swing.JFileChooser;
            import javax.swing.JOptionPane;
            public class FileChooser {
                   public static void main(String[] args){
                       String caminhoArquivo = "";
                       JFileChooser arquivo = new JFileChooser();
                       int retorno = arquivo.showOpenDialog(null);
                       if(retorno == JFileChooser.APPROVE_OPTION){
                              caminhoArquivo = arquivo.getSelectedFile().getAbsolutePath();
                              JOptionPane.showMessageDialog(null, caminhoArquivo);
                        }else{
                              //não abriu
                        }
                  }
            }

Como pode ver, logo no inicio é criada uma String, para armazenar o path do arquivo, e se o botão "Abrir" for acionado, o caminho do arquivo que foi selecionado vai ser armazenado nessa variável.
Pronto, agora você sabe "abrir" um arquivo.

Quer saber como ler e manipular o arquivo depois de obter o caminho? (Em breve)

O JFileChooser possui mais algumas utilidades, e as veremos agora.

Filtro de extensões

É possível definir um filtro, para abrir somente arquivos *.xxx, deixando a extensão a seu critério, é claro.
Antes de abrir a janela de seleção, configure a variável do JFileChooser com o seguinte código.

        arquivo.setFileFilter(new javax.swing.filechooser.FileFilter(){
             //Filtro, converte as letras em minúsculas antes de comparar
             public boolean accept(File f){
                  return f.getName().toLowerCase().endsWith(".jpg") || f.isDirectory();
             }
             //Texto que será exibido para o usuário
             public String getDescription() {
                  return "Arquivos de imagem (.jpg)";
             }
        });

O primeiro método converte todas as letras em minúsculas e depois compara as extensões, exibindo somente as que forem iguais as definidas dentro dos parênteses de endsWith, no exemplo, estou criando o filtro para exibir somente arquivos com a extensão JPG.
O segundo método serve apenas para avisar ao usuário que só serão exibidos somente os arquivos desta extensão.
É possível definir vários filtros, para isso crie vários métodos setFileFilter.

Alterando o título da janela

Essa é mais fácil, se quiser alterar o título da janelinha, configure a variável do JFileChooser com o comandosetDialogTitle(""), antes de mandar abrir a janela.

            arquivo.setDialogTitle("Selecione uma imagem");

Configurar o diretorio/pasta inicial do JFileChooser

Isso é muito útil, evita que o usuário perca a paciência sempre que quiser abrir um arquivo, porque, por padrão, o JFileChooser abre sempre a pasta principal do usuário, configurada pelo sistema operacional, no meu caso é a pasta "Meus Documentos" do windows e "/home" do Linux.

O comando que configura o diretório inicial é o setCurrentDirectory() que recebe um objeto File, esse método deve ser utilizado exatamente da mesma maneira que os anteriores, antes de mandar abrir a janela.

Uma dica legal é, crie uma variável para armazenar o caminho do ultimo arquivo selecionado, e crie um objeto File utilizando esse caminho, desta forma o JFileChooser irá abrir sempre na ultima pasta utilizada!

String caminhoCompleto = arquivo.getSelectedFile().getAbsolutePath();
caminhoUltimoArquivo = caminhoCompleto.substring(0,caminhoCompleto.lastIndexOf("\\"));

Explicação: Na primeira linha, é coletado o path completo do arquivo selecionado, e isso inclui o nome do arquivo(c:\pasta\pasta\arquivo.jpg). Na segunda linha estou fazendo um SubString, pegando esse caminho completo da primeira letra até a ultima barra encontrada (c:\pasta\pasta\), desta forma conseguimos pegar somente a pasta do arquivo selecionado.

Este comando você coloca dentro daquele IF que verifica se o botão "Abrir" foi acionado, e a variávelcaminhoUltimoArquivo tem que estar acessível da proxima vez que o JFileChooser for chamado.

Antes de abrir a janela, você insere o código abaixo, verificando se a variável caminhoUltimoArquivo não está em branco ou nula, porque se for a primeira vez que o JFileChooser estiver sendo chamado, essa variável estará vazia, e você vai ser surpreendido com uma NullPointerException ou alguma de suas irmãs.

            File pathInicial = new File(caminhoUltimoArquivo);
            arquivo.setCurrentDirectory(pathInicial);

No exemplo que estou utilizando isso não irá funcionar, por que não possui um JFrame, Classe e nem ao menos um botão controlando a abertura do JFileChooser, então não existe uma classe "Pai" que eu possa guardar a variável caminhoUltimoArquivo, mas se você está precisando utilizar o JFileChooser, obviamente tem uma(s) janela(s) pai(s) para fazer esse controle.

Qualquer dúvida ou sugestão, pode postar aqui.

Boa sorte!

Remover tags HTML de uma String

Bom dia, tarde e/ou noite!
Em determinadas situações podemos precisar remover formatações em HTML de uma determinada String, como no meu caso, um aplicativo (Gestor de Conteúdo) espera um texto digitado pelo usuário, que formata como se estivesse em um editor de texto, colocando negrito, cor, tamanho, etç. O gestor de conteúdo armazena este texto no banco de dados, para que ele possa ser lido em outro(s) programas web. O problema é que toda a formatação incluída pelo usuário é transformada em HTML, já que o texto será exibido em um site.
Em determinado momento foi necessário utilizar o texto limpo, sem nenhuma formatação, mas o que fazer para limpar o texto?
Nem precisa pensar muito, a solução está aqui.
Basta utilizar o código (método) abaixo e pronto!

public static String removeCodigoAcentos(String texto){
texto = texto.replaceAll("<[/]*?.+?[/]*  ?>","");
             return texto;
    }

Calma, calma, eu explico.
O método apenas recebe uma String, de preferência o texto que se deseja limpar. É aplicada uma alteração nessa string e depois o resultado é devolvido. O pulo do gato está na “expressão regular” utilizada.
A Expressão Regular dentro do replaceAll significa mais ou menos isso,
Remove dessa string tudo que:
- Possuir um sinal de menor à extrema esquerda;
- E talvez tenha uma barra após o sinal de menor;
- E possuir um sinal de maior à extrema direita;
- E talvez tenha uma barra antes do sinal de maior;
- E tenha qualquer tipo de texto entre essas coisas descritas acima.
Entendeu? Então boa sorte!

Eclipse, Debug Error - java.lang.NullPointerException

Ocasionalmente, o eclipse acusa um erro (ou vários erros) java.lang.NullPointerException durante o debug. Isso fica muito chato porque, a medida em que é pressionada as teclas F5, F6, F7 ou F8, para percorrer o código, um novo erro é ocasionado e alertado em tela.

Mas isso tem uma explicação, e muito simples, isso acontece por que em algum momento você (ou outra pessoa que utiliza o mesmo eclipse) adicionou um ponto de observação em alguma variável ou expressão, porém essa variável ou expressão não existem mais ou não estão na memória. Um ponto de observação é atualizado a cada linha do código e como a variável observada não existe é retornado um erro, no caso NullPointerException.

Para resolver este pequeno problema, basta abrir a aba “"Expressions” e deletar todos os pontos de observações inválidos.

Pronto, problema resolvido!
Pode voltar a debugar sem aquelas mensagens de erro inconvenientes.

Classes e seus Controles de Acesso

O que são Controladores ou Modificadores de Acesso?
Com certeza você já os viu, aqui mesmo neste blog. O projeto JSF, jReMSN, Hibernate e até mesmo o projeto Webservice estão cheios deles, mas o que são?

• default
• public
• private
• protected
• final
• abstract

Como pode ver, essas são palavras que sempre nos acompanham nas declarações de classes, métodos e variáveis, aqui vamos ver uma breve descrição de cada uma.

Classes
Para criar classes, só podemos utilizar dois controladores de acesso, na verdade um controlador (default) e um modificador (public).
É possível adicional à declaração da classe, junto com o public ou default, alguns outros modificadores como final eabstract.
Esses e todos os outros modificadores são acessíveis também à métodos e variáveis.

default
O controlador de acesso default é, como o próprio nome diz, padrão, ele está presente em TODAS as classes que não possuam um modificador, ele não é uma palavra que você indica na declaração da classe, na verdade, para utilizá-lo você não deve dizer nada para a classe!
Vejamos um exemplo básico:

class MinhaClasse{
}

Viu? Essa classe acima está utilizando o controlador de acesso default, esse controlador está presente em todas as classes que não tem uma declaração implícita (public), e ele define que esta classe está acessível à todas as classes DO MESMO PACOTE. Se você tentar instanciar ou extender esta classe de qualquer outra classe do mesmo pacote irá conseguir, porém se tentar fazer isso com uma classe de outro pacote não conseguirá!

public
O modificador de acesso public é exatamente isso, um modificador de acesso, quando declaramos uma classe comopublic estamos modificando o acesso, permitindo que todas as classes do projeto, indiferente do pacote consigam enxergar esta classe.
Exemplo:

public class MinhaClasse{
}

Esta classe acima conseguirá ser instanciada ou extendida por qualquer outra classe, indiferente do pacote que a instanciadora esteja!

final
O modificador final indica que está classe/método/variável termina aqui, esta é a ultima instancia, deste ponto em diante não muda mais!
Quando utilizado em classes, o final não deixa esta classe ser extendida (herdada), ela pode apenas ser instanciada. Desta forma você garante que os métodos desta classe serão utilizados sempre da mesma forma e nunca serão sobreescritos.

abstract
Abstract funciona de forma contrária ao final, uma classe abstract pode ser herdada, porém nunca poderá ser instanciada, funcionando apenas como "matéria prima" para a criação de uma nova subclasse que à extender.
A classe abstract pode possuir métodos abstracts, e estes não precisam possuir conteúdo, apenas a "assinatura", quando um método for marcado como abstract, ele deverá obrigatóriamente ser reescrito na subclasse e ai sim irá possuir um conteúdo.
Exemplo:

abstract class MinhaClasse{
public abstract String meuMetodo();
}

Repare que o método não possui conteúdo, nem ao menos possui chaves "{}", e termina com ponto-e-vírgula! Que absurdo!
Mas não é nenhum absurdo, esse código irá compilar sem problema algum e está 100% correto, isso por que esta é uma classe abstract e o método também é um método abstract, ou seja a classe só pode ser extendida, e a classe que fizer isso será obrigada a possuir um método com o nome meuMetodo() e retorno String.
Uma classe abstract pode também possuir métodos e variáveis normais, que também serão herdados para as subclasses.

private
Quando você declara um método ou variável como private, você o está escondendo do resto do mundo, nenhuma outra classe do seu projeto conseguirá enxergar os métodos e variáveis private, eles só serão acessíveis dentro da própria classe!

protected
Este é o primo de segundo  grau do acesso default, quando declaramos um método ou variável com acesso protectedestamos informando que para instancias, este método ou variável só está acessível à classes do mesmo pacote (idêntico ao acesso default), porém note que eu destaquei o trecho "para instancias" e isso tem um motivo, a diferença do protected para o default é em casos de herança, se a classe que possui o tal método protected for extendida por outra classe, mesmo que de pacote diferente, o método protected estará acessível à esta subclasse.

JavaBean - Wata hell??

Se você já está no mundo da programação Java, mesmo que a pouco tempo, já deve ter ouvido falar em JavaBean ou seu apelido mais carinhoso e utilizado na prática "Bean", aqui mesmo, no projeto JSF falei várias vezes sobre beans, inserir códigos, inserir gets, insetir sets, etç, etç, mas não cheguei a me aprofundar neste assunto. Pois bem, agora é a hora!
Para ser mais exato e direto ao ponto, informarei logo alguns exemplo.
Digamos que você esteja trabalhando com JSF, com certeza existem métodos para pegar/setar valores em váriáveis.
Agora digamos que você foi trabalhar com Struts, e este por sua vez tem seu próprio padrão de nomenclatura para pegar/setar valores nas benditas variáveis.
Depois de um tempo, você teve que prestar suporte em um site que utiliza o componente da empresa XYZ-KY, porém quem desenvolveu este componente não conhecia os JavaBeans, e colocou nomes estranhos nos métodos que pegam/setam atributos em váriáveis, por exemplo o método "meuPai()" estava setando valores na variável"minha_mae", e o método "minhaTia()" estava recolhendo as informações desta mesma variável. Ou seja, será praticamente impossível prestar manutenção para este componente.
Entendeu mais ou menos onde quero chegar?
A moral da história aqui, seriam os nomes dos métodos/classes/variáveis/etç/etç, e é basicamente isso que JavaBeansignifica, esta especificação foi criada visando ajudar os desenvolvedores a criar seu métodos de forma legível e compreensível por qualquer sistema ou programador, independente da sua origem (país).
Mas chega de teoria, vamos para a prática... opa não tem prática nessa matéria...
Vamos ao que interessa!
Padrões JavaBeans
Regras de Nomeação
Lembra das primeiras aulas de Java? Classe Pessoa tem características e métodos? É exatamente assim que devemos trabalhar, fazendo classes para cada tipo de coisa, sem misturar nada!
Em uma classe ContaCorrente, devemos ter APENAS as características (variáveis) de uma conta corrente, e os métodos BÁSICOS da mesma, métodos BÁSICOS são apenas os métodos de acesso às variáveis e ações simples, mas as ações simples não contém a lógica de negócio.
Esta classe tem variáveis, porém as variáveis precisam receber e informar valores, como fazer isso?
Através de métodos!
Um método para setar valores nesta variável e outro método para recolher o valor desta mesma variável.
Alguma sugestão para os nomes? setaVariavel? pegaValor? ERRADO! Devemos utilizar o padrão JavaBean!
:::::
Para recolher valores de variáveis (ou objetos) de qualquer tipo diferente de boolean, ou seja, int, double, String, char, float, etç, etç., deve-se utilizar a palavra get seguida do nome da variável iniciada com letra maíuscula.
Para setar valores de variáveis (ou objetos) de qualquer tipo ou seja, boolean, int, double, String, char, float, etç, etç., deve-se utilizar a palavra set seguida do nome da variável iniciada com letra maíuscula.
Exemplo:

private int meuNumero;
public int getMeuNumero(){
return meuNumero;
}
public void setMeuNumero(int novoNumero){
meuNumero = novoNumero;
}

Mas e para receber valores de variáveis booleanas?
Basta utilizar a palavra is seguida do nome da variável iniciada com letra maíuscula.
Exemplo:

private boolean azul;
public int isAzul(){
return azul;
}
public void setAzul(boolean novoAzul){
azul = novoAzul;
}

Entendeu? Não? Então comente e poste sua dúvida!
Boa sorte!

Converter Array em Vetor

Sim isso mesmo, no lugar de "progredir" vamos "regredir" um pouco, por que não é sempre que podemos trabalhar com as melhores condições possíveis, muitas vezes também precisamos colocar a mão na sujeira e editar algum código um tanto quanto ultrapassado, que ainda trabalha com vetores.

Se você já trabalhou com vetores, mesmo que apenas na faculdade, deve saber que com eles não conseguimos manipular os dados incluindo ou excluindo, só conseguimos criar (e destruir).

Ex.: String[] meuVetor = new String[] {"A", "B", "C", "D", "E"};

Neste exemplo, criamos um vetor com 5 posições, até aqui tudo bem, podemos solicitar cada posição do vetor com a chamada meuVetor[n],  trocando "n" pela posição do vetor, é claro, no nosso caso de 0 a 4.

Mas e se for necessário, em tempo de execução, adicionar algum valor ao vetor? Não é possível fazer um"meuVetor.add()", então como fazer?
Simples! Basta trabalhar com Array, List ou Collection e jogar esse vetor no lixo!
Mas e se a aplicação nos forçar a trabalhar com vetor, caso contrário seria necessário refazer todo o código?

Simples! Basta trabalhar com Array e converter para Vetor!
Como?

Vejamos o exemplo, em javanês:

ArrayList<String> meuArray = new ArrayList<String>();
String[] meuVetor = null;

for(int i = 0; i < 10; i++){
meuArray.add("POSICAO: " + i);
}

meuVetor = meuArray.toArray(new String[meuArray.size()]);

Explicando!

A primeira e segunda linha não tem segredo, ali estão sendo criadas nossas variáveis base, um ArrayList meuArraye um vetor String[] meuVetor.
O laço "for" também não tem muita complicação, de 0 até 9 ele está inserindo valores no Array.

Na ultima linha que a mágica acontece, vamos por partes:

Primeiro, estamos vazendo meuVetor = meuArray.toArray() este método (toArray) é da própria linguagem Java, e serve exatamente para isso que precisamos, ele prepara um Array para ser convertido em Vetor, mas este método sozinho não faz muita coisa, então precisamos informar o tipo de vetor que estamos querendo, no caso é um vetor de String, então dentro do toArray basta informar new String[n]. Mas que "n"? para criar um Vetor, precisamos informar a quantidade de posições que ele terá, e para conseguir esta façanha, basta invocar o método size() do meuArray, que devolve o tamanho do array, justamente o que precisamos para iniciar o Vetor!

Simples né?!
Boa sorte!

Swing: Comunicação entre duas janelas distintas

Algumas vezes é necessário realizar uma conversa básica entre duas janelas, para isso podemos adotar algumas soluções:
Janelas em projetos diferentes:
1 - Comunicação por arquivo/banco de dados.
    > Ao serem instanciadas, as janelas devem iniciar uma Thread que fica varrendo a cada x tempo o arquivo ou banco de dados, a procura de novas informações.
    > Quando alguma das janelas quiser enviar uma mensagem para a outra, basta gravar a informação no arquivo/banco de dados.
    > Dica: Junto com a mensagem, grave também algum ID ou Código que identifique qual janela deve ler aquela mensagem, caso contrário todas as janelas, inclusive a que enviou a mensagem, recolherão as informações.
2 - Comunicação via Sockets.
      Funciona da mesma forma que a comunicação por arquivos/banco de dados, porém neste caso deve-se trabalhar com sockets e computadores diferentes, a comunicação só pode ser feita entre duas janelas, e uma deve saber o ip da outra, as Threads iniciadas ficam responsáveis por recepcionar os pacotes de dados enviados. Para efetuar a comunicação com mais janelas, é necessário possuir um "servidor" que fica recebendo as mensagens de todo mundo e as repassando, neste caso as janelas precisam saber apenas o ip do "servidor".
Janelas em um mesmo projeto:
1 - Comunicação direta!
      Trabalhando com janelas em um mesmo projeto, a comunicação pode ser direta, ou seja, uma janela pode acessar os métodos ou objetos da outra, desde que estes estejam definidos como public e/ou static. Porém, para que isso se torne possível, ambas as janelas precisam ser iniciadas de um mesmo lugar (uma única classe que inicia as duas janelas, mesmo que em momentos distintos), ou uma das janelas inicie a Fazendo isso elas estarão instanciadas em uma mesma "rua" na jvm e uma enxergará a outra.
Para ilustrar um pouco mais, segue o exemplo abaixo onde possuímos três classes: ChamaOsDois, JanelaUm eJanelaDois.
Funciona da seguinte maneira, a classe ChamaOsDois inicia as duas janelas, a JanelaUm recebe as informações enviadas pela JanelaDois.
Para a mágica acontecer, a JanelaUm deve ter seu frame marcado como estático e possuir algum método public que acessa os objetos internos. A classe JaneDois simplesmente cria uma referência para a JanelaUm (uma instância sem a palavra new), e acessa o método publico da JanelaUm. Neste caso,  comunicação da JanelaDois para a JanelaUm deve ser mediada pela classe ChamaOsDois, uma vez que foi essa classe que instanciou as duas janelas, para casos em que uma janela inicia a outra não é necessário esse mediador.

public class JanelaUm extends javax.swing.JFrame{ 
//Inicialização dos Objetos  
private javax.swing.JLabel labelEscreva; 
private javax.swing.JTextArea txtAreaRecebedor = new javax.swing.JTextArea(); 
public static JanelaUm frame; 
//Construtor
public JanelaUm(){ 
super("Janela UM - TextArea Recebedor"); 
        constroiTela(); 
    } 
   //Método de construção de janela
private void constroiTela(){ 
this.setLayout(null); 
this.setSize(300,300); 
this.setPreferredSize(getSize()); 
labelEscreva = new javax.swing.JLabel("TextArea Recebedor:"); 
labelEscreva.setBounds(10,20,250,20); 
labelEscreva.setVisible(true); 
        this.add(labelEscreva); 
txtAreaRecebedor.setBounds(10,50,270,210); 
txtAreaRecebedor.setLineWrap(true); 
txtAreaRecebedor.setVisible(true); 
txtAreaRecebedor.setBorder(new javax.swing.border.LineBorder(new java.awt.Color(0,0,0), 1,false)); 
        this.add(txtAreaRecebedor); 
    } 
//Este método está marcado como public para poder ser acessado de outras classes 
    //ele recebe uma string e adiciona ao TextArea. 
public void adicionaTexto(String msg){ 
txtAreaRecebedor.append(msg + "\n"); 
    } 
}

public class JanelaDois extends javax.swing.JFrame{ 
//Criação dos objetos
private javax.swing.JLabel labelEscreva; 
private javax.swing.AbstractAction action2OK; 
private javax.swing.JTextField txtEscreva; 
private javax.swing.JButton btnOk; 
//Aqui estou criando uma referencia ao frameUm da classe pai ChamaOsDois, esta variável da classe 
    //ChamaOsDois já está fazendo referencia ao frame da classe JanelaUm, então esta variável 
    //janelaUm recebe a referencia da propria classe JanelaUm. 
    //Note que nem aqui, nem na classe ChamaOsDois estou indicando a palavra "new" por que não quero 
    //criar uma nova instancia, mas apenas pegar a referencia do objeto que já está criado. 
    JanelaUm janelaUm = ChamaOsDois.frameUm; 
//Construtor
public JanelaDois(){ 
super("Janela Dois - Escreva algum texto"); 
        constroiJanela(); 
    } 
//Método de construção da janela
private void constroiJanela(){ 
this.setSize(300,125); 
this.setPreferredSize(getSize()); 
this.setLayout(null); 
labelEscreva = new javax.swing.JLabel("Escreva algo e clique em OK:"); 
labelEscreva.setBounds(10, 20, 250, 20); 
labelEscreva.setVisible(true); 
txtEscreva = new javax.swing.JTextField(); 
txtEscreva.setBounds(10, 40, 270, 20); 
txtEscreva.setVisible(true); 
btnOk = new javax.swing.JButton("OK"); 
btnOk.setText("OK"); 
btnOk.setBounds(120,65,60,20); 
btnOk.setAction(getAction2OK()); 
btnOk.setVisible(true); 
        this.add(labelEscreva); 
        this.add(txtEscreva); 
        this.add(btnOk); 
    } 
//Ação do botão "OK" 
private javax.swing.AbstractAction getAction2OK() { 
        if(action2OK == null) { 
            action2OK = new javax.swing.AbstractAction("OK", null) { 
public void actionPerformed(java.awt.event.ActionEvent evt) { 
  //Verifica se a variavel está nula, se estiver tenta pegar a 
                    //referencia novamente.
                    if(janelaUm == null){ 
janelaUm = ChamaOsDois.frameUm; 
                    } 
//chama o método adicionaTexto da classe JanelaUm e informa o que foi 
                    //digitado no txtEscreva desta janela.
janelaUm.adicionaTexto(txtEscreva.getText()); 
txtEscreva.setText(""); 
                } 
            }; 
        } 
return action2OK; 
    } 
}

public class ChamaOsDois { 
//Referencia da JanelaUm, marcada como public static para poder ser 
    //referenciada de outras classes que iniciarem a partir deste ponto  
public static JanelaUm frameUm; 
public static void main(String[] args){ 
//Criação da JanelaUm 
frameUm = new JanelaUm(); 
frameUm.setLocationRelativeTo(null); 
frameUm.pack(); 
frameUm.setDefaultCloseOperation(javax.swing.JFrame.EXIT_ON_CLOSE); 
frameUm.setVisible(true); 
//Criação da JanelaDois
        JanelaDois frameDois = new JanelaDois(); 
frameDois.setLocationRelativeTo(null); 
frameDois.setDefaultCloseOperation(javax.swing.JFrame.EXIT_ON_CLOSE); 
frameDois.setVisible(true); 
    } 
}

Neste exemplo, coloque as três classes em um mesmo local e execute a classe ChamaOsDois.

Div fixa, com CSS!

Já viu aqueles sites que ficam exibindo propagandas e mais propagandas como se fossem pop-ups, mas não são pop-ups?
Aquilo é muito irritante, mas está presente em muitos portais. Como a maioria dos navegadores hoje em dia ficam bloqueando as popups, a saída é apelar para a criatividade, e alguns recursos de programação.
Materiais:
- Uma página HTML;
- Um Layer (DIV);
- Um conteúdo para o layer;
- Um comentário W3 (para navegadores que não suportam o css 'fixed');
- Algumas linhas em CSS;
Modo de preparo:
Misture tudo e depois veja se deu certo, se não funcionou, tente o exemplo abaixo:

<!-- Comentário DOCTYPE necessário para alguns navegadores -->
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<!-- Código de estilo que define as margens e posições do DIV  -->
<style>
body{margin:0; padding:0;}
div {
//~> Esta posição "fixed" que informa que a DIV deve ficar fixa.
position:fixed;
top:10px;
left:10px;
border:1px solid black;
background:#CCC;
}
html, body
{
_height: 100%;
_overflow: auto;
}
div {
_position: absolute;
}
</style>

</head>
<body>
<div align="center">
TESTE DE DIV FIXA NA TELA

</div>
<br><br><br><br><br><br><br>a<br><br><br><br><br><br>
<br><br><br>a<br><br><br><br><br><br><br><br><br><br>
<br><br><br><br><br><br><br><br><br><br><br><br>a<br>
<br><br><br>a<br><br>a<br><br><br><br><br><br><br><br>
<br><br><br><br><br><br><br>a<br><br><br><br>a
</body>
</html>

Agora é só adaptar esse exemplo ao seu código e se divertir!

Plugin sysdeo, Tomcat no Eclipse

Este plugin é muito útil, pois permite o controle do Tomcat através do próprio Eclipse desde o Start/Stop até o controle da memória utilizada pelo tomcat na virtual machine.

Aparentemente o site da Sysdeo (www.sysdeo.com) estava fora do ar há certo tempo quando comecei a escrever este post, porém é possível baixar o plugin em algumas de suas versões no site http://www.eclipsetotale.com/tomcatPlugin.html. Escolha a versão compatível com seu Eclipse/Tomcat, caso tenham tirado esta página do ar, baixe todas as versões no meu repositório aqui.

Após o download, descompacte o arquivo e copie o pasta com.sysdeo.eclipse.tomcat_X.X.X para a pasta PLUGINS que está onde o Eclipse foi instalado, por exemplo, no meu computador está em C:\Desenvolvimento\Eclipse\plugins.

Feito isso basta inicializar o Eclipse.

Note que apareceram 3 botões na barra de ferramentas, conforme imagem acima. O primeiro botão serve para iniciaro Tomcat, o segundo botão serve para parar o Tomcat, e o terceiro botão serve para reiniciar. Porém eles não funcionam assim como mágica, devemos informar onde o tomcat está instalado pelo menos.

Acesse o menu Window e depois clique em Preferences...
Selecione Tomcat, indique a versão que está instalada em seu computador e em "Tomcat home" indique a pasta onde o tomcat está instalado.

Faça a mesma coisa no item Avançado (para acessar o item Avançado expanda o item Tomcat clicando no sinal de +), indique onde está instalado o tomcat.
Vá em JVM Settings e verifique se a JRE foi reconhecida. Caso não possua nenhuma JRE ou JDK na lista suspensa, será necessário configurar isto também.

Para configurar a JRE ou JDK expanda o item Java e selecione Installed JREs.
Clique em ADD. Na caixa que irá abrir clique no botão Browse e selecione a pasta da JRE ou JDK que está instalada.
Após selecionar a instalação Java, os demais campos são preenchidos automaticamente, basta clicar em OK .

Plugin instalado e configurado!

JavaEE + Tomcat – Preparando o Ambiente de Desenvolvimento WEB

> Instalação da JDK;
> Instalação do Tomcat;
> Configuração das variáveis de ambiente;
> Testes;

Tomcat é o servidor mais utilizado em Java, tanto a nível acadêmico quanto a nível profissional, ele é fácil de configurar, “leve” e é possível encontrar muita coisa sobre ele na internet. O Tomcat também é o servidor modelo, ou seja, todos os outros servidores em Java são baseados em Tomcat, isso na prática é muito bom para o programador, você pode fazer qualquer coisa utilizando o servidor Tomcat e sua aplicação tem que funcionar em qualquer outro servidor, seja ele pago ou gratuito. Se você fez um portal que funciona em Tomcat, mas o seu cliente tem um Websphere e a aplicação não roda no websphere, se não for nenhum erro de configuração (o websphere é muito chato pra configurar) você pode ligar para a IBM e reclamar por que com certeza o WS está com problemas. Mas isso é só um exemplo, é praticamente impossível algo não funcionar no websphere desde que bem configurado.

Para instalar o Tomcat, o primeiro passo é baixar o servidor.

Acesse http://tomcat.apache.org/download-60.cgi e procure o download do arquivo ZIP. Esta página é da versão 6, porém no menu à esquerda você pode encontrar outras versões.

Instale também a JRE ou JDK: http://java.sun.com/javase/downloads/index.jsp
Esses são os pacotes para rodar/programar em Java.

- Execute o instalador da JRE ou JDK, neste caso é só clicar em Next, Next...Finish.
- Descompacte o ZIP do tomcat em algum lugar do seu computador. Pronto, Tomcat e Java estão instalados! Agora temos que informar para o Windows onde estão as coisas.

Vá ao Painel de Controle e entre no item Sistema, com a janela de sistemas aberta clique na aba Avançado e depois no botão Variáveis de Ambiente.

Clique no botão “Nova” referente o grupo “Variáveis do sistema”.

Em Nome da variável escreva JAVA_HOME e em Valor da variável insira o caminho onde a JRE ou JDK está instalada, geralmente é c:\Arquivos de Programas\Java\jre_XXX-XX-XX\.

Após inserir estas informações clique em OK.

Este mesmo processo deve ser realizado novamente, mas agora para definir a variável CATALINA_HOME, neste variável devemos informar onde o Tomcat está (Aquele local onde você descompactou o Tomcat).

Já informamos onde estão instalados o Java e o Tomcat, agora temos que informar onde estão as classes do Java.
Clique novamente em Nova e em Nome da variável escreva CLASSPATH.
Em Valor da variável escreva exatamente isso: .;%JAVA_HOME%\lib\

Agora devemos informar que os comandos do Java estão na pasta Bin.

Esta parte merece uma pequena explicação.
Quando você abre o Prompt de Comando e digita por exemplo dir, como o Windows sabe onde está o programa dir? O mesmo vale para todos os outros comandos como ping, cls, md, rd, Del, todos são “programas” que estão na pasta System32, porém como o Windows sabe que eles estão na pasta system32?

Nas variáveis de ambiente existe uma variável chamada PATH, esta variável informa para o Windows que os programas estão na pasta system32.

Vamos fazer o mesmo com o Java, procure a variável PATH e clique em editar, tome muito cuidado para não apagar nada desta variável senão outras coisas podem parar de funcionar.
No final do Valor da variável coloque um ponto-e-vírgula (;) e insira a seguinte informação: %JAVA_HOME%\bin;

Pronto! O Tomcat e o Java estão instalados e prontos para serem utilizados, vamos testá-los.

Abra o prompt de comando e digite java -version.

Será exibida a versão do JRE/JDK que você instalou, se for exibida uma versão diferente da que você baixou no site algo está errado, verifique se a variável JAVA_HOME está apontando para o caminho correto.

Depois digite javac, se for exibido um monte de coisa a configuração do Java está correta, mas se em qualquer um dos dois comandos for exibida a mensagem “java não é reconhecido como um comando interno” ou “javac não é reconhecido como um comando interno” sinto informar que você terá que fazer tudo novamente, por que algo deu errado.

Agora vamos testar o tomcat.

Abra a pasta onde você descompactou o Tomcat, e procure a pasta BIN.

Dentro da pasta Bin, execute o arquivo startup.bat. Um monte de palavras vai começar a subir no console, não se desespere é o tomcat inicializando. Quando o console ficar parado e aparecer na ultima linha “Server startup in XXX ms”, abra seu browser e digite HTTP://localhost:8080, se uma página com o logo do tomcat for aberta parabéns, o tomcat está instalado e configurado corretamente, mas se aparecer “A página não pode ser encontrada” apague tudo e volte para o topo desta página.

Configurar virtual host no Tomcat (5+)

Particularmente acho isso desnecessário, mas fica até bonito, ao invés de chamar localhost:8080/MeuProjeto, basta simplesmente chamar www.meuprojeto.com.br, se for apresentar o trabalho fica até mais profissional.
Primeiro devemos remover aquele 8080, para isso abra o arquivo server.xml (que está na pasta conf do tomcat).
Procure a linha < Connector port="8080" maxhttpheadersize="8192" > e altere para < Connector port="80" maxhttpheadersize="8192" >
Pronto, agora não será mais necessário informar :8080 para chamar a aplicação, por que a porta 80 é a porta padrão para “internet”.
O próximo passo é definir hosts e contextos.
Geralmente criamos apenas contextos dentro do host "localhost":
< Host name="localhost" appBase="webapps" unpackWARs="true" autoDeploy="true" xmlValidation="false"  xmlNamespaceAware="false" >
< Context path="meuprojeto1" docbase="c:\algumlugar\meuprojeto1" />
< Context path="meuprojeto2" docbase="c:\algumlugar\meuprojeto2" />
< /Host >
Mas para criar virtual hosts vamos deixar cada projeto em um host diferente:
< Host name="www.meuprojeto1.com.br" appBase="c:\algumlugar\meuprojeto1" unpackWARs="true" autoDeploy="true" xmlValidation="false"  xmlNamespaceAware="false" >
< Context path="" docbase="c:\algumlugar\meuprojeto1" />
</Host>
< Host name="www.meuprojeto2.com.br" appBase="c:\algumlugar\meuprojeto2" unpackWARs="true" autoDeploy="true" xmlValidation="false"  xmlNamespaceAware="false" >
< Context path="" docbase="c:\algumlugar\meuprojeto2" />
</Host>
OBS1.: Se você tem algum proxy configurado vai ser necessário informar ao proxy que o dominio www.meuprojetoX.com.br está no ip xxx.xxx.xxx.xxx.
OBS2: Se não der certo dessa forma, na linha <Context path=”” coloque uma barra no path, ficando <Context path=”/”
OBS3: Se ainda assim não der certo, abra o arquivo hosts (windows) que está na pasta windows\system32\drivers\etç.
Abra o arquivo com algum editor de texto unicode (notepad) e adicione uma linha conforme abaixo:

127.0.0.1       www.meuprojeto1.com.br

Esse arquivo simula um ambiente proxy, assim sempre que você digitar www.meuprojeto1.com.br no navegador, ele será redirecionado para seu endereço local, e se o tomcat estiver ligado ele irá capturar a URL e exibir seu projeto.

iFrame auto-ajustável

Página dentro de páginas, eis a questão.
É realmente necessário criar uma página dentro de outra página que provavelmenta já está dentro de outra página?
Se você não quer trabalhar com ajax ou Servlet, acho que é necessário mesmo. Então como podemos deixar o conteúdo do bendito iFrame se ajustar ao seu conteúdo da página chamadora?
Digamos que tenho a página 1.html, esta página tem um iframe em seu conteúdo:

<iframe id="xxx" src="xxx.html"/>

O conteúdo da página xxx.html tem que estar dentro de uma div, com o nome "conteudo".
No final da página xxx.html eu coloco o script:

<script language="JavaScript" type="text/javascript">
parent.document.getElementById("xxx").height = (document.getElementById("conteudo").scrollHeight) + 20;
</script>

Comentário do script:
Procure o elemento com o nome "xxx" e altere sua altura para a mesma altura do elemento com o nome "conteúdo" adicionando mais 20 pixels.
Simples né? Quem nuca fez gambiarra que atire a primeira pedra...

Verificar se a PopUp abriu!

Pop-ups são as coisas mais chatas que existem em sites! Mas isso é quando estamos navegando, quando vamos "criar"um site a coisa se inverte.
Recomendo não fazer pop-up, mas se você é aquele tipo de programador chato e preguiçoso (como eu), vai essa dica.
Armazene o comando window.open em uma variável ou diretamente em um if:

if(window.open(...)){
alert("Se você tem um bloqueador de pop-up, faça o favor de desativá-lo...");
}

Agora é só usar a criatividade e implantar/complementar o código.

Remover Frames Chatos

Se você é pão duro como eu e não quer comprar uma hospedagem java, pode tentar fazer um servidor em casa com essa dica, mas se tem preguiça de fazer o servidor provavelmente vai procurar alguma hospedagem gratis. O problema destas hospedagens é que sempre tem um frame chato na parte superior denunciando onde o site está hospedado, e as vezes este banner tem imagens que não possuem nenhuma sentido de acordo com o conteúdo de seu site.
Mas não se preocupe, nada é impossível na informática. Com um simples JavaScript em sua index é possível remover esses frames na maioria dos casos.

<SCRIPT>
<!--
if (top.frames.length!=0)top.location=self.document.
location;
// -->
</SCRIPT>

Coloque este script em suas páginas e adeus frame chato!
OBS.: Não da pra garantir que esse script vai funcionar em 100% dos servidores, mas pelo menos nos poucos que eu tentei funcionou.

Tomcat Portable!

Hoje em dia notebooks estão cada vez mais baratos, mas se você é como eu, não tem carro e tem preguiça de carregar o notebook pra cima e para baixo só pra mostrar ao seu cliente como está ficando o sistema, preste atenção nesta dica!
Com o Tomcat Portable você pode instalar o servidor em um pendrive e carregar suas aplicações literalmente no bolso, para visualizá-las em qualquer computador com acessso à usb. Só tem um problema, essa portabilidade só funciona em Windows...
Chega de ladainha, vamos ao que interessa.
Você vai precisar dos seguintes programas:
JRE5 - ou superior.
Tomcat 5.x - Servidor web.
Tomcat2Go - Ferramenta que transforma o servidor em portátil.
Administration Web Application - Para administração dos contextos.
1- Descompacte os arquivos do Tomcat2Go em alguma pasta.
2 - Instela a JRE e copie seu conteúdo para a pasta ...\Tomcat2Go\jre.
3 - Descompacte o tomcat em qualquer lugar e copie todo seu conteúdo para a pasta ...\Tomcat2Go\jakarta-tomcat. Mas preste atenção, não é pra copiar a pasta "Tomcat" é pra copiar todo o conteúdo dela!
4 - Descompacte o arquivo apache-tomcat-5.x.x-admin.zip em qualquer lugar e copie todo o conteúdo dela (mesma coisa que acima) para a pasta ...\Tomcat2Go\jakarta-tomcat\server\webapps\admin.
A estrutura de pastas é basicamente essa, execute o arquivo ...\Tomcat2Go\tomcat.exe, se estiver tudo certo o tomcat vai ser inicializado e o navegador será aberto chamando o domínio localhost:8080. Caso isso não aconteça você fez alguma coisa errada, delete tudo e comece novamente.
Depois disso é só adicionar seu projeto na pasta webapps do tomcat e chamá-lo normalmente: localhost:8080/meuProjeto.
Se quiser acessar a administração do tomcat, abra o arquivo ...\Tomcat2Go\jakarta-tomcat\conf\tomcat-users.xml e adicione um user para você, depois acesse localhost:8080/admin.
OBS.: Não foi eu quem hospedou os arquivos, então se algum link estiver quebrado poste um comentário que eu tento procurar outro, ou se você for uma boa alma procure no google e poste o link para nós, por favor!

Servidor com IP dinâmico!?!

Parece brincadeira de 1º de Abril mas não é. Realmente é possível fazer um servidor seja ele qual for, utilizando sua conexão "Home" com ip dinâmico.
Vejamos como!
Primeiro você tem que ter um servidor pronto, seja ele um Tomcat, IIS, Apache ou até mesmo um Conter Strike da vida.
Com o servidor configurado (quando digo configurado é, sempre que algum outro computador da rede chamar o ip do seu servidor pelo navegador alguma página é mostrada), o próximo passo é configurar o serviço que vai transformar seu ip dinâmico em ip fixo, ou mais ou menos isso.
Exitem alguns sites que fornecem este tipo de serviço, vou explicar como funciona.
Você se cadastra no site e escolhe um Alias para você, depois instala um programinha no seu "servidor" caseiro. Este programinha fica se comunicando com o site informando a cada X tempo o  ip atual do seu servidor.
Quando você fez o cadastro no site teve que criar um alias, esse alias que deve ser chamado nos browsers externos. Quando, por exemplo, de uma lan house você digita MeuAlias.dominio.com, aquele site que você se cadastrou é chamado e pesquisa no banco de dados qual ip seu servidor tem agora, e te direciona para aquele ip, o resto é com o seu servidor.
Da até pra comprar um dominio no Registro.br.
Existem alguns sites que fornecem gratuitamente este serviço, o mais utilizado é o NO-IP, porém você tem que ficar acessando sua conta de tempos em tempos, senão seu alias é cancelado. Mas vale a pena procurar mais opções e ver qual é a melhor, não se prenda apenas no que eu indiquei, por isso não postei o link para o site, apenas informei o nome.
Isso é muito útil para você brincar de fazer sites em Java com algum banco de dados mas não quer pagar um absurdo do hospedagem. Ou até mesmo para fazer um site pessoal, um "curriculum on-line".

Aumentando a Memória do Eclipse

“Algumas vezes” o eclipse começa a ficar lento, pesado, mensagens de erro começam a aparecer do nada como, por exemplo, IOConsole Update GMT e quando isso acontece o rendimento e a vontade de trabalhar que já podem estar dando adeus, se mandam de vez.

Com uma simples alteração em um arquivo de configuração é possível devolver a “juventude” ao eclipse e acabar com as mensagens chatas de erro.

No diretório do eclipse procure um arquivo chamado eclipse.ini e abra-o com algum editor de texto Unicode como o Notepad++ ou TextPad por exemplo.

Procure pelas seguintes linhas:

-vmargs
-Xms40m
-Xmx256m

Os números podem estar diferentes mas os comandos devem estar iguais.
Altere os números para algum valor maior, como por exemplo, 128 e 512 e salve o arquivo.
Ficará assim:

-vmargs
-Xms128m-
Xmx512m

Pronto, reinicie o eclipse e bom divertimento!

PermGem

PermGen space é um erro muito chato que ocorre quando menos se espera!

Antes de qualquer coisa vou falar um pouco do que é PermGen.

Esse é o nome de uma área pequena e limitada (tamanho fixo) da Virtual Machine, é nessa PermGem ou Perm Generation ou Geração Permanente que são guardados objetos de pouca movimentação como por exemplo poll de strings e objetos de reflexão.

E o que esse blá-blá-blá quer dizer?

Como a PermGen tem memória curta, se for usada demais, o entra e sai de códigos pode lotar sua capacidade e gerar o erro java.lang.OutOfMemoryError: PermGen space!

Como resolver isso?

Para aumentar um pouco a memória da virtual machine, podemos utilizar o comando -XX:MaxPermSize em sua inicialização, esse comando aumenta a memória da PermGem na virtual machine!

Um exemplo simples: vamos chamar uma classe mandando a virtual machine utilizar 256mb de memória pra executá-la.

java -XX:MaxPermSize=256m meupacote.MinhaClasse

Ótimo! Mas a menos que você esteja brincando de estourar a memória do computador na faculdade, é muito raro alguem ficar abrindo classes pelo console. Então digamos que você possua uma aplicação web e um servidor Tomcat e ide Eclipse (vou utilizar estes dois como exemplo por que são os mais utilizados), onde colocar esse comando?

Utilizando o Eclipse clique em Window, Preferences, escolha expanda o menu Tomcat e selecione JVM Settings.

Clique em Add, digite na caixa -XX:MaxPermSize=256m e clique em OK.

Pronto, agora a PermGem reservada para o Tomcat será maior e aquele erro chato não vai mais ficar incomodando.

Se você possuir um computador com bastante memória sobrando, pode reservar mais memória para a PermGem, eu coloquei 256 por que é quanto eu uso, mas você pode colocar 512, 1024, 2048, etç, vai da sua vontade.

Hello World

public static void main(String args[]){
System.out.prinln("Hello World!!");
}