André L. S.

Quase todos os programadores Java conhecem os métodos citados no título, mas muito poucos se preocupam em utiliza-los.

Estes dois métodos servem para que o programador não precise “adivinhar” qual é o separador de arquivos e qual é o separador de caminhos em cada sistema operacional.

No Linux/Unix, os métodos File.separator e File.pathSeparator retornam “/” e “.” respectivamente, enquanto que, no Windows, estes mesmos métodos retornam “\” (ou “\\” – escape) e “;”.

Passei por um caso recente, onde o código abaixo lançava a exception FileNotFoundException no Linux, mas funcionava perfeitamente no Windows:

String caminhoAp = ctx.getRealPath();
String caminhoArq = caminhoAp + "\\" + "WEB-INF/classes/pacotes/da/minha/aplicacao/";

File arquivo = new File(caminhoArq, "relatorio.pdf");
OutputStream out = new FileOutputStream(arquivo);
...

Então passou a funcionar nos dois sistemas operacionais após substituir “\\” por File.separator na linha 2, desta forma:

String caminhoAp = ctx.getRealPath();
String caminhoArq = caminhoAp + File.separator + "WEB-INF/classes/pacotes/da/minha/aplicacao/";

File arquivo = new File(caminhoArq, "relatorio.pdf");
OutputStream out = new FileOutputStream(arquivo);
...

A utilização destes métodos, além de ser uma boa prática, é muito útil quando se tem a mesma versão de um sistema feito em Java rodando de diferentes sistemas operacionais.

Resolvi iniciar uma seção no site chamada “Aplicativos que seu Android precisa ter”, nesta seção publicarei dicas e “reviews” de aplicativos úteis que ajudarão a extrair todo o potencial de seu Smartphone Android.

Começarei com o RemoteControl for Earphones, pois ele simplesmente acaba com uma vantagem enorme que o iPhone possuía sobre o Android, que é o controle do player de música através de comandos no botão do fone de ouvido.

O comportamento padrão do botão de lapela da maioria dos Smartphones com Android é pausar e tocar músicas, além de atender ligações. O RemoteControl for Earphones possibilita que você use quase todos os comandos do player padrão apenas com este botão. Por exemplo, para dar play ou pause em uma música, basta apertar o botão uma vez, para ir para a próxima música, basta apertar duas vezes, para voltar, quatro vezes e por aí vai.

Tela do aplicativo (Android Market)

O aplicativo é gratuito e, ao contrário de quase todos os aplicativos gratuitos encontrados no Android Market, não possui aquelas propagandas chatas.

O único problema é que ele não é compatível com todos os players, funcionou perfeitamente no player padrão do Motorola Milestone e Songbird, porém não funcionou no Winamp, no player padrão do Motorola Atrix e do Samsung Galaxy S.

Link para o aplicativo:  RemoteControl for Earphones
Preço: Gratuito
Propaganda: Não

O Character Large Object (ou CLOB), como o próprio nome já diz, é um tipo de campo muito comum em Bancos de Dados usado para armazenar textos com uma quantidade enorme de caracteres.

No MySQL, por exemplo, o tipo CLOB está descrito como MEMO, mas a função é a mesma.

Estes dias precisei recuperar um valor de um campo CLOB que era retornado por um SELECT, como nunca tinha utilizado este campo no Java, resolvi escrever este pequeno tutorial como um memorando e, também, ajudar a quem precisar.

Escrevendo valores em campo CLOB

O método do PreparedStatement utilizado para a gravação de um CLOB é o setAsciiStream, passando a posição do campo CLOB, o InputStream dos dados e o ponto final de leitura do InputStream.

ps.setAsciiStream(posicaoClob, inputStream, tamanhoDoTexto);

Exemplo funcional:

String sql = "INSERT INTO TESTE (texto) VALUES(?)";
		try{
			String txt = leArquivoTxt();
			ByteArrayInputStream bais = new ByteArrayInputStream(txt.getBytes());

			PreparedStatement ps = conexao.prepareStatement(sql);
			//Campo CLOB é a '?' que está na posição 1 do INSERT
			ps.setAsciiStream(1, bais, txt.length());

			ps.execute();

			ps.close();
		}catch (Exception e) {
			e.printStackTrace();
		}

Recuperando valor de um campo CLOB

Como executamos um SELECT, será necessário capturar o ResultSet , iterar as linhas e chamar o método para a recuperação de um CLOB é o getClob, passando a posição em que o campo se encontra na query ou, simplesmente, o nome da coluna.

rs.getClob("xml");

Exemplo funcional:

String sql = "SELECT xml FROM TESTE";
		try{
			PreparedStatement ps = conexao.prepareStatement(sql);
			ResultSet rs = ps.executeQuery();

			while(rs.next()){
				Clob clob = rs.getClob("xml");
				BufferedReader reader = new BufferedReader(clob.getCharacterStream());
				StringBuffer strBuf = new StringBuffer();

				String linha = null;
				while((linha = reader.readLine()) != null){
					strBuf.append(linha);
//Character.LINE_SEPARATOR insere a quebra de linha
					strBuf.append((char)Character.LINE_SEPARATOR);
				}

				System.out.println("=========== CLOB ===========");
				System.out.println(strBuf.toString());
			}

			rs.close();
			ps.close();
		}catch (Exception e) {
			e.printStackTrace();
		}

É isso aí. Simples, fácil e indolor.

Caso queiram, podem baixar a aplicação de exemplo aqui

Para recuperar um campo BLOB veja este tópico.

Algumas vezes dependemos de aplicações de terceiros para testar se nossa aplicação está funcionando corretamente ou, simplesmente, acessar recursos do emulador que não estão disponíveis nas ferramentas que o acompanham.

Nos diretórios de instalação do SDK, geralmente em platform-tools, existe um executável chamado adb, através dele instalaremos aplicações de terceiros.

Antes de mais nada, você precisará do pacote de instalação do aplicativo (.apk). Para isso, procure em sites de busca ou faça backup através de seu aparelho Android usando aplicativos com o AppSaver.

- Inicie o emulador, podendo ser pelo SDK Manager ou pelo plugin do Android no Eclipse.

- Através do prompt do DOS (Windows) ou de um terminal (Linux), acesse o diretório platform-tools, e execute a linha de comando:

$ adb install <caminho do arquivo .apk>

Você verá a mensagem:

$ adb install Aplicativo.apk
125 KB/s (1091937 bytes in 8.474s)
        pkg: /data/local/tmp/Aplicativo.apk
Success

Agora o aplicativo estará disponível no menu do emulador, como se estivesse instalado no seu smartphone.

Se você é um DBA ou trabalha com programação e usa muito banco de dados SQL, este tópico não é você, a menos que não conheça as cláusulas INNER JOIN e OUTER JOIN, muito comuns em SGBDs SQL.

Não sabe o que é SGBD? Os Sistemas de Gerenciamento de Banco de Dados são programas que auxiliam na manipulação dos dados armazenados. O MySQL, PostgreSQL, MS SQL Server ou Oracle, que você tem em sua casa ou empresa, são SGBDs.

Para este tutorial você precisa ter, pelo menos, o conhecimento básico de SQL.

Chega de enrolação, vamos ao que interessa!

INNER JOIN

A cláusula INNER JOIN é usada quando se quer recuperar dados em mais de uma tabela através da igualdade de suas foreign keys.

Por exemplo, pense que você quer criar um programa que sirva como agenda telefônica. Você cadastra as pessoas e os contatos telefônicos, como uma pessoa poderá ter nenhum até N números de telefones, você separa em duas entidades como neste modelo:

Olhando rapidamente você percebe que a entidade TELEFONE tem o atributo NUM_PESSOA que é o número de identificação do registro na entidade PESSOA.

Vamos supor que as tabelas estejam preenchidas com os seguintes registros:

 +----------------------------+  +---------------------------+
 |           PESSOA           |  |         CONTATO           |
 +------------+---------------+  +------------+--------------+
 | NUM_PESSOA | NOME_PESSOA   |  | NUM_PESSOA | NUM_TELEFONE |
 | 1          | José          |  | 1          | 6589-3666    |
 | 2          | Arnaldo       |  | 3          | 9888-6699    |
 | 3          | Maria         |  | 3          | 8956-6666    |
 | 4          | Elverdelando  |  | 2          | 2888-9877    |
 +------------+---------------+  +------------+--------------+

Para recuperar os telefones de uma pessoa você deve usar INNER JOIN, implicitamente ou explicitamente. Vou explicar os dois casos.

O método explícito é usar a cláusula explicitamente (duh!), que é formada por INNER JOIN <tabela filha> ON <atributos de identificação>, no nosso exemplo:

SELECT nome_completo, num_telefone FROM pessoa INNER JOIN telefone ON pessoa.num_pessoa = telefone.num_pessoa

Estamos dizendo: “me traga o nome e os números dos telefones da pessoa onde o número da pessoa em TELEFONE seja igual ao número da pessoa em PESSOA”.

Na forma implícita você não usa a cláusula INNER JOIN, o tratamento de igualdade é feito na cláusula WHERE. Usando o mesmo exemplo:

SELECT nome_completo, num_telefone FROM pessoa, telefone WHERE pessoa.num_pessoa = telefone.num_pessoa

Em ambos os casos o resultado será:

 +---------------------------+
 |         CONTATO           |
 +------------+--------------+
 | NOM_PESSOA | NUM_TELEFONE |
 | José       | 6589-3666    |
 | Maria      | 9888-6699    |
 | Maria      | 8956-6666    |
 | Arnaldo    | 2888-9877    |
 +------------+--------------+

“Que simples! Hummmm espera um pouco… Onde está o Elverdelando (que nominho, hein?!).”

Lembra que dissemos ao banco “me traga o nome e os números dos telefones da pessoa onde o número da pessoa em TELEFONE seja igual ao número da pessoa em PESSOA”? Então! O Elverdelando não esta na tabela TELEFONE, por isso não foi retornado no resultado.

Quando você precisar retornar os dados, mesmo não estando na tabela filha, usamos o OUTER JOIN.

OUTER JOIN

A clásula OUTER JOIN tem duas variantes, LEFT OUTER JOIN e RIGHT OUTER JOIN, sendo que estas cláusula devem ser declaradas sempre de maneira explícita. Alguns SGBDs facilitam a utilização do OUTER JOIN te polpando de declarar toda a sintaxe, como é o caso do Oracle que utiliza o símbolo (+) na identificação fraca, mas NÃO É ANSI, ou seja, não funcionará em qualquer SGBD.

Para que apareçam todas as pessoas, inclusive as que não têm número de telefone cadastrado usamos LEFT OUTER JOIN ou RIGHT OUTER JOIN.

A sintaxe é parecida com a INNER JOIN, mudando apenas o nome da cláusula: LEFT[RIGHT] OUTER JOIN <tabela filha> ON <atributos de identificação>;

Assim, faremos…

SELECT nome_completo, num_telefone FROM pessoa LEFT OUTER JOIN telefone ON pessoa.num_pessoa = telefone.num_pessoa

ou então

SELECT nome_completo, num_telefone FROM telefone RIGHT OUTER JOIN pessoa ON pessoa.num_pessoa = telefone.num_pessoa

Em ambos os casos o resultado será:

 +-----------------------------+
 |         CONTATO             |
 +--------------+--------------+
 | NOM_PESSOA   | NUM_TELEFONE |
 | José         | 6589-3666    |
 | Maria        | 9888-6699    |
 | Maria        | 8956-6666    |
 | Arnaldo      | 2888-9877    |
 | Elverdelando |              |
 +--------------+--------------+

Como você pôde perceber, a única diferença entre o LEFT OUTER JOIN e o RIGHT OUTER JOIN é só a indicação de qual é o lado forte do relacionamento, ou seja, em qual lado da cláusula está a tabela que pode não ter valores na tabela filha. No nosso caso, ambos apontando para a tabela PESSOA.

INNER JOIN é muito usado para consulta em banco de dados, quase que totalmente em seu método implícito. Já as cláusulas OUTER JOIN também são usadas, mas não com tanta frequência, posso dizer que é raro encontra-las por aí.

Espero que este tutorial os ajude!