Então aqui vai uma dica para quem tem de compilar várias packages, procedures e/ou functions inválidas diariamente devido à esta falha do Oracle.

Existe um comando que força o banco a compilar todos os objetos inválidos sob um determinado usuário, o comando é:

exec dbms_ultility.compile_schema(<USUARIO>);

Substitua por user onde está <USUARIO> se os objetos estiverem sob o usuário que está conectado, ou pelo nome de usuário correspondente.

O comando demora um pouco para ser executado e não compila todos os objetos que estão inválidos por erro de codificação, para descobrir quais objetos estão inválidos, você pode executar a seguinte query:

select object_name
from all_objects
where status = 'INVALID'

Será listado os objetos que estão inválidos na base.

ProxoId, aplicativo gratuito disponível no Android Marketing, lhe permite compartilhar a conexão 3G utilizando somente o cabo USB.

O aplicativo precisa de um programa stand alone rodando no computador para funcionar e que os drivers para o Android estejam instalado neste mesmo equipamento.

O driver, assim como o programa, pode ser encontrado em forma de arquivo ZIP para Windows 32bits aqui e para Windows 64 bits aqui. Se você instalou os drivers que vêm no CD do fabricante, pule para o passo Reconhecendo o smartphone.

Instalando os drivers

Descompacte o arquivo ZIP e conecte o aparelho ao computador. O assistente de novos dispositivos será aberto.

Escolha a opção “Não, não agora” e clique em “Avançar”. Na tela seguinte, escolha a opção “Instalar de uma lista ou local específico”.

Habilite as opções “Procurar o melhor driver nestes locais” e “Incluir este local na pesquisa”, então clique em procurar.

Na caixa de diálogo, selecione o diretório onde você descompactou o arquivo ZIP > “usb_driver” > “x86″, como na imagem.

Clique em avançar e siga os passos até o fim da instalação.

Reconhecendo o smartphone

Com o aparelho plugado, acesse o diretório “proxoid-adb” e execute o arquivo “check.bat”. Deverá aparecer a tela abaixo com o número do dispositivo.

Caso não apareça, tente desconectar o aparelho e conectar novamente ou reinstalar os drivers.

Configurando ProxoId

A tela de configuração é aberto quando o ProxoId é executado:
“Start/Stop ProxoId” – Indica se o serviço está em execução (ticado) ou parado;
“Port” – Número da porta para o proxy
“User-Agent Filter” – Máscara do User-Agent (Browser).

Configurando Browser

Internet Explorer e Google Chrome

Clique no menu “Iniciar” > “Painel de Controle” e “Opções da Internet”. Clique na aba “Conexões” e no botão “Configurações da LAN”.

No campo “Endereço”, digite “localhost” e no campo “Porta” digite o mesmo valor que está nas configurações do “ProxoId”.

FireFox

Abra o Firefox, clique no menu “Opções”. Selecione a guia “Avançado” > “Rede” e clique no botão “Configurar Conexão”. Habilite a opção “Configuração manual de proxy.

No campo “HTTP”, digite “localhost” e no campo “Porta” digite o mesmo valor que está nas configurações do “ProxoId”.

Compartilhando conexão

Habilite a opção “Start/Stop ProxoId” na aplicação do seu Android.
No computador, abra o diretório “proxoid-adb” e execute o arquivo “start-tunnel.bat”.

Pronto! Enquanto estiver usando estas configurações de proxy, todo o tráfego passa a ser disponibilizado pelo sinal 3G do seu aparelho!

Abaixo descrevo o passo-a-passo de como  fazer.

Requisitos:

• Adaptador Bluetooth (caso seu computador/notebook não tenha) – Como estes;
• Cabo USB do controle;
• .NET Framework 4 – Pode ser baixado aqui;
• Sistema operacional Windows XP, Vista ou 7 (seven).

Os drivers padrão dos adaptadores e do Windows não reconhecem o controle do Playstation 3, para isso você precisará baixar o driver customizado do site Motionin Joy para Windows XP, Windows Vista e Windows 7 (32 bits) ou Windows XP, Windows Vista e Windows 7 (64 bits).

Após o download, extraia o arquivo e execute-o. Siga os passos para instalação até o final e execute o DS3 Tool, ou clique no menu Iniciar, Programas, MotioninJoy e DS3 Tool.

Aparecerá a tela abaixo:

Conecte o joystick no PC usando o cabo USB. Clique no menu “Driver Manager”, selecione o dispositivo encontrado e clique no botão “Install all”.

Após o término da instalação (demora cerca de um minuto), clique em “Profiles”.

O controle deve aparecer na lista (indicada pelo círculo). Selecione a opção  ”Playstation 2 (POV, Joysticks, Analog Trigger)”, “Custom” e o número correspondente do controle (no nosso caso “1″).

Para finalizar, clique no menu “Bluetooth Pair”, selecione seu controle na lista “Dual Shock 3″ e clique em “Pair Now”.

Pronto! Quando aparecer o número MAC onde está escrito “Have Paired to”, você poderá desconectar o cabo USB e utilizar o controle via Bluetooth normalmente, como um joystick comum de PC.

Enjoy!

No Android 2.2 existe a possibilidade de migrar o local de instalação dos aplicativos já instalados, porém, alguns não lhe dão a possibilidade de movê-los para o SD.

Atrás de soluções para resolver este probleminha no meu Motorola Milestone, encontrei um excelente tutorial no Mundo Zoom que ensina como instalar aplicativos direto no cartão SD, mesmos aqueles aplicativos que não permitem movê-los, sem a necessidade de ser usuário root.

Primeiro baixe, de preferência, o ZIP de Android SDK e extraia-o e, navegue até o diretório “android-sdk-windows\platform-tools“.

Configure seu aparelho para o modo debug. Não sabe? Vá em “Configurações” > “Aplicativos” > “Desenvolvimento” e ative a opção “Depuração USB”.

Conecte seu smartphone à porta USB e ative a opção “Nenhum” (ou “Somente carregar bateria”) no Gerenciador de Conexão USB.

Agora Abra o prompt de comando clicando no menu Iniciar, executar. Digite “cmd” (sem aspas) e pressione Enter.

Com o prompt e a janela do Windows Explorer abertos, clique no arquivo “adb.exe” e arraste para o prompt, em seguida dê um espaço e digite “shell”. Pressione Enter.

Deverá aparecer o símbolo “$” e o cursor piscando. Agora digite o comando “pm setInstallLocation 2” e pressione Enter.

Este comando define a partição “2″, que é o cartão SD, como local padrão para a instalação dos aplicativos.

Pronto, isto é tudo que você precisa para que, a partir de agora, os aplicativos sejam instalados direto no cartão SD.

Caso o procedimento não tenha dado certo, no site Mundo Zoom existem algumas soluções de problemas que podem te ajudar.

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.

Como o tutorial explica a instalação no Ubuntu 9.10 não foi preciso seguir alguns passos. Então mostrarei abaixo os passos que utilizei para a instalação na versão 10.04 do Ubuntu.

Será necessário baixar os drivers da Avasys, para isso acesse este link, role a página para baixo, escolha a opção “Epson Stylus CX4300/CX4400/CX4450/CX5500/CX5600/DX4400/DX4450“, distribuição “Ubuntu” e versão “10.04” e clique em “Next“.

Na próxima página, baixe os arquivos “iscan-data_1.9.0-1_all.deb“, “iscan_2.26.4-2.ltdl7_i386.deb” e “iscan-plugin-cx4400_2.1.3-1_i386.deb“. Em seguida, execute os comandos abaixo:

sudo dpkg -i iscan-data_1.9.0-1_all.deb
sudo dpkg -i iscan_2.26.4-2.ltdl7_i386.deb
sudo dpkg -i iscan-plugin-cx4400_2.1.3-1_i386.deb

Tudo certo, certifique-se que o scanner está ligado e execute o comando

lsusb

Deverá aparecer uma lista de dispositivos conectados às portas USB, como esta:

Bus 003 Device 004: ID 04b8:083f Seiko Epson Corp. Stylus DX4450
Bus 003 Device 003: ID 04fc:05d8 Sunplus Technology Co., Ltd
Bus 003 Device 002: ID 04f3:0216 Elan Microelectronics Corp.
Bus 003 Device 001: ID 1d6b:0001 Linux Foundation 1.1 root hub
Bus 002 Device 001: ID 1d6b:0001 Linux Foundation 1.1 root hub
Bus 001 Device 003: ID 18e3:9101 Fitipower Integrated Technology Inc
Bus 001 Device 001: ID 1d6b:0002 Linux Foundation 2.0 root hub

A primeira linha “Bus 003 Device 004: ID 04b8:083f Seiko Epson Corp. Stylus DX4450” significa que a multifuncional foi detectada no endereço 003:004.

Este passos foram suficientes para que o scanner fosse detectado pelo XSane, mas só o usuário root conseguia usar o programa.

Para resolver este problema, edite o arquivo /lib/udev/rules.d/40-libsane.rules e acrescente as linhas abaixo:

# Epson CX5600
ATTRS{idVendor}=="04b8", ATTRS{idProduct}=="083f", MODE="0664", GROUP="saned", ENV{libsane_matched}="yes"

Desligue e ligue a impressora novamente. Para saber se deu certo, execute o comando lsusb. A saída deverá ser parecida com a saída abaixo:

Bus 003 Device 004: ID 04b8:083f Seiko Epson Corp. Stylus DX4450

Repare no Bus 003 e no Device 004 (os números poderão ser diferentes). Com estes números execute o comando

ls -l /dev/bus/usb/<BUS>/<DEVICE>

Substituia o <BUS> e <DEVICE> pelos respectivos números, neste caso:

ls -l /dev/bus/usb/003/004

Você verá algo parecido com

crw-rw-r--+ 1 root saned 189, 129 2011-07-01 14:01 /dev/bus/usb/003/004

Neste ponto é possível ver que todos os usuários pertencentes ao grupo saned estão aptos para usar o scanner.

Para descobrir se este é o seu problema, acesse o arquivo error_log que está no diretório wp-admin do WordPress e cheque as últimas linhas.

O procedimento abaixo resolveu o problema, mas, dependendo do servidor de hospedagem, talvez as configurações do PHP não permita o redimensionamento de memória em tempo de execução.

Edite o arquivo wp-settings.php que está na raiz do WordPress e adicione a linha abaixo após “<?php”

define('WP_MEMORY_LIMIT', '64M');

Aqui eu aloquei 64MB para o PHP, mas como saber quanto de espaço foi e deve ser alocado?

Na mensagem de erro ele mostra a quantidade que está sendo alocada, é o número comprido da mensagem “Fatal error: Allowed memory size of 33554432…”. Aqui ele diz que foi alocado 32MB (para converter bytes em megabytes faça o cálculo 33554432 / (1024^2) = 32).

Dependendo do resultado do cálculo, indique um valor superior.

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.

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.

O arquivo .REG está disponível para download aqui.

Antes de executar o arquivo, abra-o no bloco de notas e altere o caminho “C:\\Arquivos de Programas\\Java\\jdk1.6.0_23″ para o diretório onde está instalado o JDK e o caminho “C:\\Arquivos de Programas\\Java\\jre6″ para onde está o JRE.

Esta solução funcionou para mim.

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!

O suporte multi-idioma é nativo nas edições Enterprise e Ultimate do Windows 7, porém, seguindo este tutorial, você também conseguirá alternar entre os idiomas nas edições Professional e Home Premium.

Primeiro você precisará do Vistalizator. Este aplicativo lhe permite instalar o suporte multi-idiomas em todas as versões do Windows 7 e, como ele é portável, não precisa de instalação. Você pode baixa-lo clicando aqui.

Depois baixe os idiomas para a arquitetura x64 (64 bits) ou x86 (32 bits).

Agora execute o Vistalizator e clique em “Add languages”.

Localize o arquivo com o idioma que deseja e clique em “Open”.

Aparecerá a mensagem abaixo, então clique em OK para prosseguir.

Em seguida será aberta uma tela com os dados do arquivo e a descrição do idioma, então clique em “Install Language”.

Aguarde e processo de extração e instalação.

O Vistalizator exibirá os idiomas instalados na sua máquina e, entre eles, estará o idioma que você escolheu. Selecione-o e clique em “Change language”.

Reinicie o sistema e voilá.

Agora você tem um Windows 7 com suporte multi-idioma.

A única coisa ruim que pude perceber até agora é que toda vez que quiser alternar entre os idiomas você precisará usar o Vistalizator, devido as edições Professional e Home Premium não ter esta opção habilitada por padrão.

Depois de checar as configurações do Windows, seus processos e serviços, constatei que o problema estava no serviço “Serviço de compartilhamento de Rede do Windows Media Player”, que me obrigava para-lo antes de remover o dispositivo.

Ainda sim, esta solução não me parecia correta, então encontrei a mais adequada. Segue:

O serviço “Serviço de compartilhamento de Rede do Windows Media Player” é responsável por compartilhar seus arquivos de mídia (músicas e vídeos) em sua rede ou internet (como seu próprio nome já diz). Esta configuração é padrão da instalação do Windows 7, então para desabilitar o recurso…

Clique em “Iniciar”, na caixa de pesquisa digite “Central de rede e Compartilhamento” e selecione o aplicativo, conforme é exibido na imagem acima

Clique na opção “Escolher opções de grupo doméstico e de compartilhamento”

Agora clique em “Escolha opções de streaming de mídia…”

Altere a opção do item “Programas de mídia neste PC e conexões remotas” para “Bloqueado”

Pronto, a partir de agora você poderá remover seu HD externo ou qualquer outro dispositivo de armazenamento removível sem problemas.

1. Você precisará da dll wmpband.dll, que vem com o Windows Vista. Se não tiver, faça o download aqui (contém a dll para 32 e 64 bits);

2. Copie o arquivo (32 ou 64 bits, dependendo do seu Windows) para o diretório onde está instalado o Windows Media Player, no meu caso “C:\Program Files\Windows Media Player“;

3. Agora verifique se o serviço “Serviço de Compartilhamento de rede do Windows Media Player” (“Windows Media Player Network Sharing Service” para Windows em inglês) está parado. Para isso clique no menu Iniciar e, na caixa de busca, digite “Serviços” (ou “Services” para Windows em Inglês) e clique no respectivo item da lista. Agora localize o serviço e pare-o, caso esteja rodando.

4. Abra o prompt de comando em modo administrador. Iniciar > Todos os Programas > Acessórios > clique com o botão direito em “Prompt de Comando” e clique em “Executar como Administrador”.

5. Digite o comando regsvr32 “C:\Program Files\Windows Media Player\wmpband.dll“, substituia o caminho para o local onde o arquivo foi copiado. Espere alguns segundos até aparecer a mensagem:

6. Abra o Windows Media Player e então o minimize-o. Depois clique com o botão direito na barra de tarefas > Barra de Ferramentas > Windows Media Player.

7. E voilá!

Esta característica a Microsoft devia ter mantido nativamente, muita gente que conheço usa este recurso. Só lamentos uncle Bill!

Depois de algumas tentativas acabei achando duas soluções para resolver o problema de acesso: a primeira foi passar como parâmetros Java as configurações do proxy.

$ java -Dhttp.proxyHost=serv -Dhttp.proxyPort=porta -Dhttp.proxyUser=usu -Dhttp.proxyPassword=senha ClasseJava

-Dhttp.proxyHost = IP ou nome do servidor proxy
-Dhttp.proxyPort = Porta do proxy
-Dhttp.proxyUser = Usuário
-Dhttp.proxyPassword = Senha

Desta forma a classe ClasseJava terá acesso à internet através do proxy.

A outra forma foi inserir as configurações na própria classe:

public static void main(String[] args){
...
System.getProperties().put("proxySet", "true");
System.getProperties().put("http.proxyHost", "serv");
System.getProperties().put("http.proxyPort", "porta");
System.getProperties().put("http.proxyUser", "usuario");
System.getProperties().put("http.proxyPassword", "senha");
...
}

proxySet = Define se passará ou não por um servidor proxy
http.proxyHost = IP ou nome do servidor proxy
http.proxyPortt = Porta do proxy
http.proxyUse = Usuário
http.proxyPassword = Senha

Usando um destes recursos você poderá configurar sua aplicação para acessar à internet através de um proxy.

Espero ter ajudado. Até +!

Para resolver este problema: Feche o Amarok, delete o arquivo  ~/.kde/share/apps/amarok/current.xspf e então reinicie o Amarok.

Pelo menos comigo funcionou e espero que funcione com todos!

Até +.

Deixando a janela transparente

Para deixar uma Window (JFrame, JDialog e etc) transparente,  você deve usar o método AWTUtilities.setWindowOpacity. Este método recebe como parâmetro a janela que deve ser alterada e o grau de transparência, que varia entre 0 (zero) e 1, sendo 0 (zero) invisível e 1 totalmente visível.

JFrame  window = new JFrame("Minha janela");

//70% de transparência
AWTUtilities.setWindowOpacity(window, .7f);
window.setSize(800,600);
window.setVisible(true);

O resultado será:

Alterando a forma da janela

Para alterar a forma da janela você deve usar o método AWTUtilities.setWindowShape. Este método recebe como parâmetro a janela que deve ser alterada e a forma (java.awt.Shape) que a janela deverá assumir.

A forma mais eficiente de usar este método é através do componentResized(), pois você poderá recalcular o tamanho da janela para não deforma-la ou não perder os componentes de vista.

Aqui deixaremos nossa janela com a forma de um triângulo com 70% de transparência.

final JFrame  window = new JFrame("Minha janela");

try {
	//Adicionando o ComponentListener responsável pelo componentResized
	window.addComponentListener(new ComponentAdapter(){
		@Override
		//implementando o método componentResized
		public void componentResized(ComponentEvent e) {
			int[] x = {0,400,800}; //Pontos X do polígono
			int[] y = {600,0,600}; //Pontos Y do polígono

			//Criaremos um triângulo de 800 x 600
			Shape shape = new Polygon(x, y, 3);

			AWTUtilities.setWindowShape(window, shape);

			//com transparência de 70%
			AWTUtilities.setWindowOpacity(window, 0.7f);
		}
	});
} catch (SecurityException e) {
	// TODO Auto-generated catch block
	e.printStackTrace();
} catch (IllegalArgumentException e) {
	// TODO Auto-generated catch block
	e.printStackTrace();
}

window.setUndecorated(true); //removendo barra de título
window.setSize(800,600);
window.setVisible(true);

Repare que invoquei o método setUndecorated( ) passando o valor true, este método é responsável por ocultar a barra de título (aquele com o ícone e os botões de maximizar, minimizar e fechar) que, se estiver visível, o método AWTUtilities.setWindowShape( ) não surtirá efeito.

O resultado:

Espero que tenham gostado e até a próxima!

//Pontos X do polígono

PreparedStatemente.setBinaryStream(int índice, Inputstream is, int tamanho);

Para o exemplo definimos uma tabela chamada arquivo que contém um campo BLOB chamado ARQ.

//Conexão normal, como qualquer JDBC
Class.forName("oracle.jdbc.driver.OracleDriver");
Connection conn = DriverManager.getConnection("jdbc:oracle:thin:@<IP>:<PORTA>:<SID>","<USUARIO>","<SENHA>");

//Acessando o arquivo a ser enviado e recuperando um InputStream
File arquivo = new File("<CAMINHO_COMPLETO_DO_ARQUIVO>");
FileInputStream fis = new FileInputStream(arquivo);

//Preparando a chamada normalmente
PreparedStatement ps = conn.prepareStatement("INSERT INTO ARQUIVO (arq) VALUES(?)");

//Informando o inputstream e o tamanho do arquivo a ser enviado
ps.setBinaryStream(1, fis, (int)arquivo.length());

ps.execute();

ps.close();
conn.close();

No meu teste utilizei a base de dados Oracle 8i. Como não tenho à disposição uma base MySQL/PostgreSQL/MS SQL Server, deixo vocês encarregados de testar e me enviar os resultados, OK?

[]‘s e até a próxima!

Para que o cursor possa ser retornado é preciso declara-lo como REF CURSOR no spec da Package.

  --Criando o tipo REF CURSOR que será o cursor
  type g_cursor is ref cursor;

Em ambos, spec e body, você precisa declarar uma variável out do tipo do REF CURSOR mencionado acima.

  procedure PRO_RETORNA_LISTA_CARROS(
    i_id     in     tbl_car.car_id%type,
    o_cursor in out g_cursor);

Para devolver o cursor com os resultados (caso haja), é necessário abri-lo no body da procedure, desta forma:

open o_cursor for
          select car_id, company, model, color, hp, price
          from tbl_car
          where car_id = i_id;

A Package completa ficará assim:

create or replace package PAC_CURSOR is
  --Criando o tipo REF CURSOR que será o cursor
  type g_cursor is ref cursor;

  --Procedure que retornará o cursor
  procedure PRO_RETORNA_LISTA_CARROS(
    i_id     in     tbl_car.car_id%type,
    o_cursor in out g_cursor); -- Nosso cursor

end PAC_CURSOR;
/

create or replace package body PAC_CURSOR is
  procedure PRO_RETORNA_LISTA_CARROS(
    i_id     in     tbl_car.car_id%type,
    o_cursor in out g_cursor) is

       begin
        --Abrindo o cursor para retornar os valores
        open o_cursor for
          select car_id, company, model, color, hp, price
          from tbl_car
          where car_id = i_id;

  end PRO_RETORNA_LISTA_CARROS;

end PAC_CURSOR;

Temos o lado do Oracle pronto, agora precisamos tratar a chamada no Java.

Como o cursor está sendo retornado por uma procedure, usaremos um java.sql.CallableStatement.

CallableStatement cs = conn.prepareCall("{call PAC_CURSOR.PRO_RETORNA_LISTA_CARROS(?,?)}");

O registerOutParameter receberá o tipo oracle.jdbc.OracleTypes.CURSOR e retornará um java.sql.ResultSet. Iteraremos o ResultSet do mesmo modo que iteramos um Iterator.
Cada coluna retornada pelo SELECT será representado como um mapa, usando o getter correpondente. Por exemplo, chamaremos o método getString(<nome coluna>) quando retornar um varchar, getDate(<nome coluna>) quando retornar um date e etc.

O código completo fica assim:

//Chamando o procedure
CallableStatement cs = conn.prepareCall("{call PAC_CURSOR.PRO_RETORNA_LISTA_CARROS(?,?)}");

//Definindo o tipo do retorno, no caso o cursor
cs.registerOutParameter("o_cursor", OracleTypes.CURSOR);
cs.setLong("i_id", id);

cs.execute();//Executando a chamada

//Recuperando o cursor como um Resultset
ResultSet rs = (ResultSet)cs.getObject("o_cursor");

//Iterando as linhas retornadas
while(rs.next()){
	//Obtendo o valor das colunas
	System.out.println("ID: " + rs.getLong("car_id"));
	System.out.println("Marca: " + rs.getString("company"));
	System.out.println("Modelo: " + rs.getString("model"));
	System.out.println("Cor: " + rs.getString("color"));
	System.out.println("HP: " + rs.getString("hp"));
	System.out.println("Preco: " + rs.getFloat("price"));
}

No final você conseguirá obter qualquer valor retornado em um SELECT.

Até a próxima!

Para habilitá-lo clique em Painel de Controle > Programas e Recursos > na lateral esquerda clique em Ativar ou desativar recursos do Windows > habilite o Cliente Telnet e Cliente TFTP e então clique em OK.

Não testei no Windows Vista, mas o processo deve ser o mesmo.

Até mais!

Procurando na internet por uma alternativa Win32 para o comando tail, encontrei o UnixUtils. Uma compilação para Windows dos comandos mais utilizados no Linux/Unix.

Você pode fazer o download do ZIP pelo SourceForge clicando aqui.

Até a próxima!

Eu, que também já passei por isso, encontrei um solução fácil e com muitos recursos: JSmooth.

Este programinha possibilita que você “transforme” seu JAR em um executável (EXE), mas claro, ainda sim você precisará ter o JVM instalado no micro que rodará o executável.

Aqui só destacarei as configurações que considero relevantes, então vamos ao que interessa!

Após instalá-lo (ou descompactá-lo, depende do arquivo que você baixou) execute-o;

No menu lateral, clique em “Skeleton“;

No “Skeleton Selection” você informa como a aplicação será executada, aqui selecionaremos Window Wrapper.

No “Skeleton Properties” você define uma mensagem caso o usuário não tenha o JVM instalador (Message) e onde ele poderá baixá-lo (URL).

“Launch java app in the exe process” indica se o JAR será executado no mesmo processo do EXE, aparecendo somente o executável no Gerenciador de Tarefas do Windows, caso contrário também será o processo javaw.exe.

“Single Instance” define se você ser aberto mais de uma instância.

“Debug Console” executa o EXE em uma janela do prompt de comando, exibindo os possíveis Stacktraces gerados pela aplicação.

Agora clique em “Executable”

Em “Executable Settings” você informa onde o EXE será gerado (“Executable Binary“), o ícone do EXE (“Executable Icon“) e qual será o diretório de execução da aplicação.

Clique em “Application”

Primeiro, clique no ícone e selecione o JAR que contém a classe principal (que contém o método main).

Em seguida, selecione a classe no campo “Main Class” clicando no botão .

O campo “Application arguments” você passa os parâmetros necessário para a sua classe.

“Embedded JAR” possibilita que você integre seu JAR no EXE, ou seja, não será necessário ter os dois arquivos, pois o EXE descompactará o JAR a cada execução.

Agora, clique em “JVM Selection“.

Aqui você pode definir qual versão, mínima (“Minimum JVM Version“) e máxima (“Maximum JVM Version“), da virtual machine  rodará sua aplicação.

O”JVM Search Sequence” indica a ordem de busca do arquivo javaw.exe, neste caso ele procurará primeiro no registro, depois no diretório informado na variável de ambiente “JAVA_HOME” e assim por diante.

E então clique em “JVM Configuration”

Aqui você informa a quantidade máxima de memória que sua aplicação poderá usar (“Maximum Memory“), quanta memória será alocada para sua aplicação assim que ela iniciar (“Initial Memory Allocation“) e os argumentos que será passado à JVM para sua aplicação.

Até este ponto você somente configurou o JSmooth, mas ainda não temos o EXE. Para isso, clique no botão , caso você ainda não tenha salvo o projeto será aberta uma janela para escolher o local de salvamento do arquivo. Feito isso, o EXE será gerado no diretório indicado no campo “Executable Binary” da tela “Executable“.

Agora é só dar um duplo clique no arquivo EXE e aplicação iniciará!

Para mais informações acessem http://jsmooth.sourceforge.net/

Espero que tenham gostado, comentem à vontade!

Até mais!

Para este tutorial, precisamos incluir a tabela TBL_CLASS e adicionar sua primary key como foreign key na TBL_USER.

--num class será a PK e o desc_class será a descrição
create table TBL_CLASS (num_class number, desc_class varchar(100));
alter table TBL_CLASS add primary key(num_class);

alter table TBL_USER add num_class number;
alter table TBL_USER add constraint FK_CLASS foreign key(num_class) references tbl_class(num_class);

Agora precisamos incluir os novos tipos:

create or replace type class_type as object (num_class number, desc_class varchar2(100), users arr_users);
/
create or replace type arr_class as table of class_type;
/

O tipo class_type será o objeto. Repare que na sua assinatura incluímos o tipo arr_users, que será nossa coleção de user_type (vide post anterior), o tipo arr_class será uma coleção de class_type.

Agora incluiremos a procedure responsável por retornar nossa coleção de class_type.

procedure pro_select_class(clas in class_type, class_return in out arr_class)is
  class_ref_cur ref_cur;
  --Coleção de classes
  classes arr_class := arr_class();

  begin
    open class_ref_cur for
      select cast(
                multiset(
                  select num_class,
                         desc_class,
                         (select cast(
                                  multiset(
                                    select user_name,
                                           height,
                                           b_date
                                    from tbl_user
                                    --Fazendo o JOIN com a TBL_USER
                                    where tbl_user.num_class = tbl_class.num_class
                                  ) as arr_users)
                          from dual) users
                  from tbl_class
                  --Usando o atributo num_class do parâmetro de entrada
                  where num_class = clas.num_class) as arr_class
      ) classes
    from dual;

    --incluindo ao retorno no array
    fetch class_ref_cur into classes;
    --passando o array para a variável out
    class_return := classes;
end pro_select_class;

Repare que a procedure recebe o tipo class_type como parâmetro in e retorna o tipo arr_class.

Separando trecho responsável por resgatar e montar nossos objetos teremos:

--Montará a coleção de retorno
select cast(
        multiset(

          --Retornará os objetos class_type e seus atributos
          select num_class,
                 desc_class,

                 --Populará a coleção com user_type
                 (select cast(
                          multiset(
                            select user_name,
                                   height,
                                   b_date
                            from tbl_user
                            where tbl_user.num_class = tbl_class.num_class
                          ) as arr_users)

                  from dual) users

          from tbl_class
          where num_class = clas.num_class) as arr_class
) classes
from dual;

Os objetos de banco estão prontos, agora para o Java!

Criaremos o objeto que será interpretado pelo Oracle. Vamos chamá-lo de TypeClass:

public class TypeClass implements SQLData{
	public static final String ORACLE_OBJECT_NAME = "CLASS_TYPE"; //Nome do tipo no Oracle
	public static final String ORACLE_CLASS_ARRAY_NAME = "ARR_CLASS"; //Nome do array no Oracle

        //campos criados na tabela TBL_CLASS
	private Long number;
	private String desc;
	private Array users; //Esta será a coleção de user_type (ou TypeUser no Java)

	public String getSQLTypeName() throws SQLException {
		return ORACLE_OBJECT_NAME;
	}

	public void readSQL(SQLInput stream, String typeName) throws SQLException {
		setNumber(stream.readLong());
		setDesc(stream.readString());
		setUsers(stream.readArray());//Usado pelo JDBC driver para ler a coleção
	}

	public void writeSQL(SQLOutput stream) throws SQLException {
		stream.writeLong(getNumber());
		stream.writeString(getDesc());
		stream.writeArray(getUsers());//Usado pelo JDBC driver para armazenar a coleção
	}
	//Getters e setters omitidos
}

Precisamos mapear os dois tipos já que ambos serão interpretados na requisição, desta forma:

Map> typeMaps = connection.getTypeMap();
typeMaps.put(TypeUser.ORACLE_OBJECT_NAME, TypeUser.class);
typeMaps.put(TypeClass.ORACLE_OBJECT_NAME, TypeClass.class);

Também precisaremos mapear os dois arrays:

typeMaps.put(TypeClass.ORACLE_CLASS_ARRAY_NAME, TypeClass[].class);//retornado pela procedure
typeMaps.put(TypeUser.ORACLE_USER_ARRAY_NAME, TypeUser[].class);//retornado pela coleção de class_type

Para a requisição faremos:

cs = conn.prepareCall("{call PAC_BEAN.PRO_SELECT_CLASS(?,?)}");
//registrando o tipo de saída, que será um array de TypeClass
cs.registerOutParameter("class_return", OracleTypes.ARRAY, TypeClass.ORACLE_CLASS_ARRAY_NAME);

//passando o objeto de parâmetros da query
cs.setObject("clas", classQry);

cs.execute();
//recuperando e iterando o array de TypeClass
Object[] array = (Object[])cs.getArray("class_return").getArray();

for(Object obj : array){
	TypeClass objClass = ((TypeClass)obj);

	System.out.println("Description: "+objClass.getDesc());

        //Aqui pegamos a coleção (ou array) de user_type(TypeUser) retornada pela query.
	Object[] userArray = (Object[])objClass.getUsers().getArray();
	for(Object user : userArray){
		System.out.println("\tName: " + ((TypeUser)user).getName());
		System.out.println("\tHeight: " + ((TypeUser)user).getHeight());
		System.out.println("\tBirth: " + sdf.format(((TypeUser)user).getBirth())+ "\r\n");
	}
}

O final você terá um TypeClass que contém um java.sql.Array de TypeUser no atributo getUsers().

E aqui cumpro minha promessa. Baixe o código fonte com o exemplo contendo este e o post anterior aqui.

Até a próxima!

Estava pensando com quão complexo seria fazer uma classe que tirasse screen shots do compulador local e o armazenasse em um arquivo. Perguntando ao tio “G” descobri a classe Robot, que possui o método createScreenCapture.

Agora mostrarei como implementar esta funcionalidade:

Robot robot = new Robot();
//Definindo o retângulo que será a área de captura da tela que, neste caso, será a tela inteira.
Rectangle rect = new Rectangle(Toolkit.getDefaultToolkit().getScreenSize());

BufferedImage img = robot.createScreenCapture(rect);

Aqui definimos a área de captura e obtivemos um BufferedImage, que já é nossa imagem. Agora é só persisti-la no disco.

//Capturando o ImageWriter e ImageWriterParam
ImageWriter writer = ImageIO.getImageWritersByFormatName("jpeg").next();
ImageWriteParam iwp = writer.getDefaultWriteParam();

//Definindo o modo de compressão e a qualidade
iwp.setCompressionMode(ImageWriteParam.MODE_EXPLICIT);
iwp.setCompressionQuality(1);

//Persistindo a imagem
writer.setOutput(new FileImageOutputStream(arquivo));

IIOImage iioimage = new IIOImage(img, null, null);

writer.write(null, iioimage, iwp);
writer.dispose();

Aqui capturamos o ImageWriter e ImageWriterParam para configurar o método de compressão e a qualidade da imagem.

Na linha 07 definimos a qualidade como 1, onde o valor varia de 0 (zero), maior compressão e menor qualidade, até 1 (um), menor compressão e maior qualidade. Em seguida persistimos o arquivo no HD.

Pronto! Simples, não?!.

Faça o download do exemplo aqui.

Até a próxima!

Neste caso será a tela inteira.

public class MaxLengthTextDocument extends PlainDocument {
	//Armazena o número máximo de caracteres para o texto.
	private int maxChars;

	@Override
	public void insertString(int offs, String str, AttributeSet a)
			throws BadLocationException {
		if(str != null && (getLength() + str.length() < maxChars)){
            		super.insertString(offs, str, a);
        	}
	}

	//getter e setter omitidos
}

Aqui definimos a classe MaxLengthTextDocument estendendo a PlainDocument. No atributo insertString inserimos uma regra onde só será inserido valor se comprimento não ultrapassar o valor máximo.

Depois é só inserir a implementação no JTextField, desta forma:

	...
	MaxLengthTextDocument maxLength = new MaxLengthTextDocument();
	maxLength.setMaxChars(50);//Limitamos para 50 caracteres

	jTextField.setDocument(maxLength);
	...

E voilá!

Até mais!

...
JLabel jLabel = new JLabel("Meu JLabel");
//Borda usada para o preenchimento
Border paddingBorder = BorderFactory.createEmptyBorder(10,10,10,10);

jLabel.setBorder(BorderFactory.createCompoundBorder(border,paddingBorder));
...

Neste caso colocamos um espaçamento de 10 pixels no topo, à esquerda, à direita e em baixo do JLabel respectivamente.

Se ainda quiser colocar uma borda envolta do JLabel, pode-se usar uma CompoundBorder, inserindo a borda e o preenchimento. Desta forma:

...
JLabel jLabel = new JLabel("Meu JLabel");
//Borda usada para o preenchimento
Border paddingBorder = BorderFactory.createEmptyBorder(10,10,10,10);
//Borda que ficará envolta do JLabel
Border border = BorderFactory.createLineBorder(Color.BLUE);

jLabel.setBorder(BorderFactory.createCompoundBorder(border,paddingBorder));
...

Baixe o código fonte desta dica aqui.

Neste tutorial usarei a versão 2.3.4 build 726.

Configurando o iBatis

Ao contrário dos demais frameworks, para configurar o iBatis você só precisa de um arquivo XML de configuração, chamado SqlMapConfig.

As principais seções do xml são:

<properties resource="tuto/ibatis/config/SqlMap.properties"/>

Este código é opcional e serve para indicar o arquivo properties com as variável de configuração que serão usada no XML.

<typeAlias alias="car" type="tuto.ibatis.beans.Car"/>

Indica o Bean utilizado e qual será seu aliás. Você pode configurar várias linhas, tudo depende da complexidade e necessidade da sua modelagem.
No nosso exemplo, usaremos o bean Car abaixo:

public class Car {
	private Long carId;
	private String company;
	private String model;
	private String color;
	private Integer	hp;
	private Float price;

	//Setters e getters omitidos
}

<transactionManager type="JDBC">
    <dataSource type="SIMPLE">
        <property name="JDBC.Driver" value="${driver}"/>
        <property name="JDBC.ConnectionURL" value="${url}"/>
        <property name="JDBC.Username" value="${username}"/>
        <property name="JDBC.Password" value="${password}"/>
    </dataSource>
</transactionManager>

Parâmetros usados na conexão com o banco. As variáveis ${driver}, ${url}, ${username} e ${password} estão definidas no arquivo .properties indicado na seção  properties. Se você preferir, também pode colocar os valores diretamente nos campos, sem precisar defini-los em outro local.

Veja como será arquivo completo:

<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE sqlMapConfig PUBLIC "-//ibatis.apache.org//DTD SQL Map Config 2.0//EN"
        "http://ibatis.apache.org/dtd/sql-map-config-2.dtd">

<sqlMapConfig>
    <properties resource="tuto/ibatis/config/SqlMap.properties"/>

    <settings
        cacheModelsEnabled="true"
        enhancementEnabled="true"
        lazyLoadingEnabled="true"
        maxRequests="32"
        maxSessions="10"
        maxTransactions="5"
        useStatementNamespaces="false" />

    <typeAlias alias="car" type="tuto.ibatis.beans.Car"/>

    <transactionManager type="JDBC">
        <dataSource type="SIMPLE">
            <property name="JDBC.Driver" value="${driver}"/>
            <property name="JDBC.ConnectionURL" value="${url}"/>
            <property name="JDBC.Username" value="${username}"/>
            <property name="JDBC.Password" value="${password}"/>
        </dataSource>
    </transactionManager>

    <sqlMap resource="tuto/ibatis/sqlmaps/CarSqlMap.xml"/>
</sqlMapConfig>

O properties tem o seguinte conteúdo:

driver=oracle.jdbc.OracleDriver
url=jdbc:oracle:thin:@<host>:<porta>:<sid>
username=<login>
password=<senha>

Em seguida devemos configurar nosso SqlMap. Este XML conterá as querys utilizadas na aplicação e deverá ter o nome do descrito na seçao sqlMap do SqlMapConfig, no nosso caso será CarSqlMap.xml.

No nosso exemplo apenas veremos a utilização das tags select, insert, update e delete.

<select id="getCars" resultClass="tuto.ibatis.beans.Car"
	parameterClass="java.lang.Long">
    SELECT COMPANY  as company,
           MODEL    as model,
           COLOR    as color,
           HP       as hp,
           PRICE    as price
    FROM TBL_CAR
    WHERE CAR_ID = #var#
</select>

Executa o select podendo retornar uma única linha ou uma coleção, o tipo retornado é o mesmo especificado no atributo resultClass, o parameterClass é o tipo passado para executar a query e o id é a identificação para chamada da query.

Usaremos o SqlMap abaixo:

<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE sqlMap PUBLIC "-//ibatis.apache.org//DTD SQL Map 2.0//EN"
	"http://ibatis.apache.org/dtd/sql-map-2.dtd">

<sqlMap namespace="Car">
    <select id="getCars" resultClass="tuto.ibatis.beans.Car"
    parameterClass="java.lang.Long">
        SELECT COMPANY  as company,
               MODEL    as model,
               COLOR    as color,
               HP       as hp,
               PRICE    as price
        FROM TBL_CAR
        WHERE CAR_ID = #var#
    </select>

    <insert id="addCar" parameterClass="tuto.ibatis.beans.Car">
        INSERT INTO TBL_CAR (CAR_ID, COMPANY, MODEL, COLOR, HP, PRICE)
        VALUES (#carId#, #company#, #model#, #color#, #hp#, #price#)
    </insert>

    <delete id="delCar" parameterClass="java.lang.Long">
        DELETE FROM TBL_CAR WHERE CAR_ID = #var#
    </delete>

    <update id="updCar" parameterClass="tuto.ibatis.beans.Car">
        UPDATE TBL_CAR
          SET COMPANY = #company#,
              MODEL = #model#,
              COLOR = #color#,
              HP = #hp#,
              PRICE = #price#
        WHERE CAR_ID = #carId#
    </update>
</sqlMap>

Agora que já configuramos o acesso ao banco de dados e o mapeamento dos objetos, vamos implementar a classe singleton que usaremos como SqlMapClient, aqui nós a chamaremos de OracleMapConfig.

package tuto.ibatis.connection;

import java.io.Reader;

import com.ibatis.common.resources.Resources;
import com.ibatis.sqlmap.client.SqlMapClient;
import com.ibatis.sqlmap.client.SqlMapClientBuilder;

public class OracleMapConfig {
	private static final SqlMapClient sqlMapClient;

	static{
		try{
			//Definindo o caminho para o SqlMapConfig e criando o reader
			String res = "tuto/ibatis/config/SqlMapConfig.xml";
			Reader reader = Resources.getResourceAsReader(res);

			//Recuperando o client para o SqlMap
			sqlMapClient = SqlMapClientBuilder.buildSqlMapClient(reader);
		} catch(Exception e){
			e.printStackTrace();
			throw new RuntimeException(e);
		}
	}

	//Método usado para recuperar o client
	public static SqlMapClient getSqlMapClient(){
		return sqlMapClient;
	}
}

O client é responsável por executar as querys configuradas no SqlMap e nos fornecer os resultados.

Executando Querys e tratando retornos

Para chamar uma das querys é muito simples, apenas chame o cliente e o método correspondente de cada uma.

O select pode ser chamado da seguinte forma:

OracleMapConfig.getSqlMapClient().queryForObject("<id>", <parâmetro>);

O iddeve ser o id correspondente no SqlMap

O código acima tráz apenas uma linha retornada pela query, para trazer todas apenas troque o método para o queryForList, desta forma:

OracleMapConfig.getSqlMapClient().queryForList("<id>", <parâmetro>);

Assim, será retornado uma Collection contendo os objetos.

Vamos aos exemplos:
Select

try{
	Car car = (Car)OracleMapConfig.getSqlMapClient().queryForObject("getCars",
		new Long(readKeyboard()));

	System.out.println("Marca: "+car.getCompany());
	System.out.println("Modelo: "+car.getModel());
	System.out.println("Cor: "+car.getColor());
	System.out.println("HP: "+car.getHp());
	System.out.println("Preço: "+car.getPrice());
}catch (Exception e) {
	e.printStackTrace();
}

O id “getCars” é o que definimos nos atributos do select do SqlMap, passando um Long e recuperando o tipo Car, ambos também definidos na linha <select id=”getCars” resultClass=”tuto.ibatis.beans.Car” parameterClass=”java.lang.Long“>.

Insert

try{
	OracleMapConfig.getSqlMapClient().insert("addCar", newCar);
}catch (Exception e) {
	e.printStackTrace();
}

Agora passamos como parâmetros o próprio tipo Car, <insert id=”addCar” parameterClass=”tuto.ibatis.beans.Car“> e chamamos os métodos usando cerquilha (#, ou jogo-da-velha se preferirem), desta forma:

INSERT INTO TBL_CAR (CAR_ID, COMPANY, MODEL, COLOR, HP, PRICE)
VALUES (#carId#, #company#, #model#, #color#, #hp#, #price#)

Delete

try{
	int lines = OracleMapConfig.getSqlMapClient().delete("delCar",
		new Long(readKeyboard()));

	System.out.println(lines + " linhas excluídas");
}catch (Exception e) {
	e.printStackTrace();
}

O método delete do client retorna um tipo int que representa a quantidade de linhas excluídas.

Update

try{
	int lines = OracleMapConfig.getSqlMapClient().update("updCar", car);

	System.out.println(lines + " carros incluídos");
}catch (Exception e) {
	e.printStackTrace();
}

O Update retorna um tipo int, que informa a quantidade de linhas afetadas pelo update.

Como você pode ver, com apenas três arquivos XML e três classes conseguimos montar um sistema de manutenção de estoque de consulta de preço basico.

Você pode fazer o download com os fontes deste tutorial clicando aqui.

Até a próxima!