As opções que temos:

- Antes de existir Java: a velha e boa stored procedure em PL/SQL … é um código pré-compilado em p-code que fica armazenado dentro do banco de dados… acesso local e nativo aos dados.

- Java client com driver JDBC Thin – acesso remoto aos dados.

- Java client com driver OCI Thin – acesso remoto e nativo aos dados.

- Java em stored procedure – desde o Oracle 8i temos uma engine em Java dentro do banco, o que nos possibilita executar rotinas em Java dentro do banco, com acesso local e nativo aos dados.

É impressionante a quantidade de profissionais Java que trabalha há anos com Oracle não conhece metade das opções existentes.

A implementação mais usada é a JDBC Thin, pois é a mais fácil de configurar, mas de acordo com a Oracle é a mais lenta de todas.

O Oracle OCI (Oracle Call Interface) é a maneira nativa que os clients utilizam para se conectar ao banco de dados, essa maneira nativa pode ser feita em várias linguagens (C, Cobol , Java) utilizando as bibliotecas do Oracle Client para acessar o banco de dados. Isso significa que para usar OCI, a instalação do Oracle client é obrigatória.

Ferramentas como Oracle SQL*Plus, PL/SQL Developer são rápidas porque usam OCI para acessar o banco de dados.

A configuração adequada do OCI pode ser complicada a primeira vez, e somente nesse fórum russo eu encontrei um simples resumo que explica como configurar o seu ambiente para usar OCI (depois de instalado o Oracle Client):

Em plataforma Windows:

- Adicione [ORACLE_HOME] \ jdbc \ lib \ ojdbc5.jar ao CLASSPATH para JDK 1.5 ou
[ORACLE_HOME] \ jdbc \ lib \ ojdbc6.jar para JDK 1.6.
- Adicione [ORACLE_HOME] \ jlib \ orai18n.jar ao CLASSPATH.
- Adicione [ORACLE_HOME] \ bin ao PATH (que fica nas variáveis de ambiente, nas configurações avançadas do Sistema)

Em plataforma Unix:

- Adicione [ORACLE_HOME] / jdbc / lib / ojdbc5.jar ao CLASSPATH para JDK 1.5 ou
[ORACLE_HOME] / jdbc / lib / ojdbc6.jar para JDK 1.6.
- Adicione [ORACLE_HOME] / jlib / orai18n.jar ao CLASSPATH.
- Adicione [ORACLE_HOME] / jdbc / lib ao LD_LIBRARY_PATH

Para trabalhar com Oracle Stored Procedures, você precisa primeiro ter uma ferramenta como Eclipse para desenvolver suas rotinas, e depois gerar suas classes com compatibilidade para JDK 1.5 (se for Oracle 11i) e JDK 1.4 (se for Oracle 10g).

Além disso, a opção de Java deve estar ativa no banco de dados, verifique com o SQL:

SQL> select value from V$option where parameter='Java';

VALUE
-------------------------------------------------------
TRUE

Essa opção Java não está disponível no Oracle Express Edition, é preciso instalar uma versão Personal Oracle, Standard ou Enterprise Edition.

Para carregar as classes em Java no banco é utilizado o loadjava, como por exemplo para carregar a nossa classe para o teste da corrida:

C:\workspace\corridaOracle\bin\>loadjava -user=boaglio1/boaglio1@boaglio1 -verbose TesteDeInternalProcedure.class

arguments: '-user' 'boaglio1/***@boaglio1' '-verbose' 'TesteDeInternalProcedure.
class'
creating : class com/boaglio/corridaOracle/TesteDeInternalProcedure
loading  : class com/boaglio/corridaOracle/TesteDeInternalProcedure
Classes Loaded: 1
Resources Loaded: 0
Sources Loaded: 0
Published Interfaces: 0
Classes generated: 0
Classes skipped: 0
Synonyms Created: 0
Errors: 0

E depois amarramos essa classe com uma procedure, dessa maneira:

create or replace procedure teste_java
 as
 language java
 name 'com/boaglio/corridaOracle/TesteDeInternalProcedure.main(java.lang.String[])';

Bom, vamos falar agora do processo de carga… temos o primeiro exemplo que é executado inteiramente em PL/SQL:

 create or replace procedure teste_proc
is
 cursor todos_ceps is select * from cep;
 id_corrida integer;
begin

select corrida.nextval into id_corrida from dual;

for linha in todos_ceps loop
 if loweR(linha.cidade) like '%paulo%' then
  INSERT INTO TESTE_PROCEDURE (ID,UF,CIDADE,BAIRRO,ENDERECO_CEP,LOGRADOURO,ID_CORRIDA)
  VALUES (seq1.nextval,linha.uf,linha.cidade,linha.bairro,linha.endereco_cep,linha.logradouro,id_corrida);
 end if;
end loop;

end teste_proc;

Depois temos o outro exemplo que será chamado por todas as outras classes Java:

package com.boaglio.corridaOracle;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

public class CargaDeDadosDoCEP {

	static final String todos_ceps = "select * from cep";

	static final int DRIVER_JDBC_THIN=1;
	static final int DRIVER_JDBC_OCI=2;
	public  static final int INTERNAL_JAVA_PROC=3;

	public static void runLoad(Connection conexao,int tipoDeDriver) {

		Statement stmt = null;
		ResultSet rset = null;
		try {
			int idCorrida = buscaIdCorrida(conexao);
			stmt = conexao.createStatement();
			rset = stmt.executeQuery(todos_ceps);
			while (rset.next())
				validaDados(rset,conexao,tipoDeDriver,idCorrida);
		} catch (Exception ignore) {
		} finally {
			try {
				rset.close();
				stmt.close();
				if (tipoDeDriver!=CargaDeDadosDoCEP.INTERNAL_JAVA_PROC)
				   conexao.close();
			} catch (Exception ignore) {
			}
		}
	}

	private static int buscaIdCorrida(Connection conexao) {

		Statement stmt = null;
		ResultSet rset = null;
		int idCorrida =0;
		try {
			stmt = conexao.createStatement();
			rset = stmt.executeQuery("select corrida.nextval from dual");
			while (rset.next())
				idCorrida = rset.getInt(1);
		} catch (Exception ignore) {
		} finally {
			try {
				rset.close();
				stmt.close();
			} catch (Exception ignore) {
			}
		}
		return idCorrida;
	}

	private static void validaDados(ResultSet rset,Connection conexao,int tipoDeDriver,int idCorrida) throws SQLException {

		String cidade = rset.getString("cidade");
		String busca = "paulo";

		String SQL_CARGA="";
		if (tipoDeDriver==DRIVER_JDBC_THIN) {
			SQL_CARGA="INSERT INTO TESTE_DRIVER_THIN             (ID,UF,CIDADE,BAIRRO,ENDERECO_CEP,LOGRADOURO,ID_CORRIDA) "+
            "VALUES (seq2.nextval,?,?,?,?,?,?)";
		} else if (tipoDeDriver==DRIVER_JDBC_OCI) {
			SQL_CARGA="INSERT INTO TESTE_DRIVER_OCI (ID,UF,CIDADE,BAIRRO,ENDERECO_CEP,LOGRADOURO,ID_CORRIDA) "+
			"VALUES (seq3.nextval,?,?,?,?,?,?)";
		} else	if (tipoDeDriver==INTERNAL_JAVA_PROC) {
			SQL_CARGA="INSERT INTO TESTE_JAVA_PROC (ID,UF,CIDADE,BAIRRO,ENDERECO_CEP,LOGRADOURO,ID_CORRIDA) "+
	        "VALUES (seq4.nextval,?,?,?,?,?,?)";
		}
		if (cidade==null) return;
		if (cidade.toLowerCase().indexOf(busca)>=0) {
			PreparedStatement pstmt = null;
			try {
			        pstmt = conexao.prepareStatement(SQL_CARGA);
				pstmt.setString(1,rset.getString("uf"));
				pstmt.setString(2,cidade);
				pstmt.setString(3,rset.getString("bairro"));
				pstmt.setString(4,rset.getString("endereco_cep"));
				pstmt.setString(5,rset.getString("logradouro"));
				   pstmt.setInt(6,idCorrida);
				pstmt.executeUpdate();

			} catch (Exception e) {
				e.printStackTrace();
			} finally {
				try {
				pstmt.close();
				} catch (Exception ignore) {
				}
			}
		}
	}
}

Em ambos os casos temos o mesmo processo: buscar em uma View de todos os endereços do Brasil os que contém “paulo” no nome da cidade e armazenar em uma tabela separada.

Temos 57789 de 699307 registros (8,25%) em cada execução da rotina.

O cálculo foi feito da diferença do primeiro e o último insert (o tempo de 57789 inserções na base).

O teste foi feito sem envolver rede, no próprio servidor para tirar essa dúvida da nossa corrida.

Em todos os quatro casos as rotinas foram executadas dez vezes, com a seguinte performance:

1. Em primeiro lugar não é nenhuma surpresa que foi o PL/SQL, com tempo mínimo de 10 segundos, máximo de 12 e médio de 11.3
2. Em segundo lugar, pertinho vieram as stored procedures em Java, com tempo mínimo de 23 segundos, máximo de 25 e médio de 23,9
3. Em terceiro lugar, bem atrás vieram os drivers JDBC Thin, com tempo mínimo de 59 segundos, máximo de 79 e médio de 67
4. Em último lugar vieram os drivers JDBC OCI, com tempo mínimo de 64 segundos, máximo de 95 e médio de 71,9

Vamos fazer algumas comparações com os tempos médios… a mesma rotina em PL/SQL roda 2 vezes mais rápido que uma stored procedure Java e 6 vezes mais rápido uma rotina de OCI, isso mesmo 6 vezes!

O interessante é que a Oracle recomenda usar o driver Thin para maior portabilidade e o driver OCI para melhor performance, mas nessa minha corrida e em outras literaturas dizem exatamente o oposto.

Quer testar você mesmo? Acesse o fonte do projeto e tire suas próprias conclusões!

No começo dos anos 90, a Digital cria um banco de dados chamado RDB que começa a ganhar uma boa fatia do mercado. Provavelmente você nunca ouviu falar dele , pois em 1994 a Oracle comprou a empresa inteira e deu um jeito de oficialmente descontinuar o produto e garantir mais uma fatia do mercado.

No começo dos anos 2000, uma empresa começa a ganhar nome no mercado com seu excelente servidor de aplicação chamado Weblogic. Em 2008 a Oracle compra mais essa e em alguns anos o nome da BEA cairá no esquecimento. Se eu ficar escrevendo sobre todas as aquisições da Oracle, você vai parar de ler esse artigo nesse parágrafo mesmo.

A linguagem Java sempre foi open source, mas a engine que roda as aplicações não ( a JVM ), e a Sun Microsystems chegou a anunciar que tinha planos para abrir o código, mas logo em seguida a empresa foi comprada pela Oracle e aparentemente os planos não mudaram e agora todo mundo quer ajudar pra quando chegar a hora levar crédito também.

Quando se compra uma empresa e talvez até um jabá por fora para garantir que a coisa ande, normalmente os envolvidos são poucos. Quando se fala de uma comunidade, e ainda com trabalho voluntário, o dinheiro não ajuda muito. Por esse motivo que nenhuma empresa grande é dona ou tem controle sobre o movimento open source.

Foi criado o projeto LibreOffice como resposta da ameaça ao projeto OpenOffice ser descontinuado, apesar das tentativas da Oracle de atrapalhar o processo.

Também foi criado o projeto MariaDB como resposta da compra do MySQL e da mudança de sua licença.

Além , disso a comunidade open source não investe o seu precioso tempo voluntário em projetos proprietários que foram abertos mas não valem a pena. As vezes essas empresas grandes podem pensar: “vamos abrir o fonte daquela coisa velha que a molecada open source atualiza e melhora o código pra gente” . Pois é, felizmente não é assim que a coisa funciona.

Recentemente o framework Qt passou por uma onda de boatos que iria acabar justamente por um acordo que a Nokia fez com a Microsoft. Se você já usou Skype, Virtual Box ou Google Earth, então já usou o Qt, pois ele é o responsável pela parte visual. Com ele também é feito o ambiente gráfico KDE, que também muita gente desinformada achou que estaria ameaçado… em primeiro lugar o KDE e o Qt existiam antes da aquisição da Nokia e o seu responsável sempre foi a comunidade open source. Em segundo lugar, devido à importância do projeto do KDE, foi criada uma entidade sem fins lucrativos que visa manter a parte legal e financeira do projeto KDE. Pois é, a comunidade open source não é só um bando de moleques trabalhando de graça, é algo maior que isso que está se organizando aos poucos, por esse motivo eu acho que o mínimo que ela merece é o nosso respeito.

Fernando Boaglio, para a comunidade

Claro que na nossa realidade brasileira esse número é muito pior, mas Pareto foi o primeiro a colocar sua descoberta no papel.

Essa descoberta ficou conhecida como a princípio de Pareto, ou a regra do 80/20. Essa regra se aplica em diversos cenários, como por exemplo que 80% das vendas vem de 20% dos clientes.

Até a Microsoft usou esse princípio aplicando que corrigindo 20% de seus mais reportados bugs, ela eliminaria 80% dos erros e problemas.

Você que desenvolve software e sabe que a garantia da qualidade da entrega são os testes, também sabe que nem sempre é possível ter uma cobertura total de sua aplicação, ainda mais que seu chefe não entende por que você precisa testar algo que fez há seis meses ou um ano, que teoricamente está pronto… pois é, bem-vindo ao mundo do reuso de componentes!

Por esse motivo sempre que possível nas entregas que faço eu procuro aplicar o que eu chamo de “testes de Pareto”, que nada mais são do que testes em 20% das telas do sistema que são responsáveis por 80% dos problemas reportados.

Do que adianta então você gastar uma hora testando uma tela complexa se quase ninguém usa? Não daria melhor resultado se você testasse aquela tela que todo mundo usa todo dia?

Aplicar os testes de Pareto nas suas entregas não é uma invenção fabulosa, é apenas o uso do bom senso.

Tenha esse hábito e terá melhores resultados.

Fernando Boaglio, para a comunidade.

Na época que lecionava Java para a Sun Microsystems, eu sempre orientava os meus alunos a adotar algumas das dicas abaixo e não se limitar ao conteúdo da apostila.

Lembre-se que o melhor dos cursos apenas é uma ferramenta, de nada adianta se você não estiver comprometido com o aprendizado.

Saiba que Java não é algo tão intuitivo como PHP, mas também não é algo do outro mundo, que alguém não possa aprender. Quando você conhecer o potencial do Java, vai entender porque empresas enormes como IBM , Oracle sempre apoiaram a utilização dessa plataforma.

1. Entenda as origens do Java e por que ele foi criado – entender o porquê da linguagem ser criada pelas necessidades da época ajuda muito na compreensão de suas bibliotecas e de seu funcionamento. Procure estudar a diferença da linguagem Java e da plataforma Java.

2. Não comece usando Eclipse / NetBeans – as IDEs mascaram muita coisa essencial para o aprendizado, por isso apenas mude para essas ferramentas depois de alguns meses de prática. No momento você precisa apenas de um bom editor de textos para ajudar na sintaxe.

3. Procure apostilas conceituadas - antigamente existiam apostilas básicas na Internet, resumos incoerentes e algumas dissertações de mestrado sobre o assunto. Hoje existe muito mais coisa, mas a melhor referência que existe é a apostila do curso de Java da Caelum, uma excelente fonte de informação escrita por experientes profissionais da área.

4. Monte um plano de estudo com intervalos curtos – planejar um roteiro de estudos precisamos de compromisso e ser bem realista na programação. Procure dedicar um tempo todo dia para o estudo, alguns dias você terá horas, outros apenas meia hora. Não deixe de ficar um dia sem dar uma olhada, nem que seja por 10 minutos.

5. Inscreva-se em fóruns de Java e leia periódicos – existem muitos fóruns por aí e alguns periódicos nas bancas. Participe dos fóruns tirando suas dúvidas no começo e ajudando os iniciantes mais tarde.

6. Compre um bom livro de Java ou faça um curso conceituado - se você prefere livro, compre o Head First Java, se prefere curso, faça numa escola conceituada.

7. Estude as APIs do Java direto no código fonte- muita coisa está documentada no código fonte com exemplos, é um ótimo lugar para aprender a usar alguns padrões.

8. Não comece a desenvolver para web ainda – o erro de muitos iniciantes é partirem para o desenvolvimento web antes de conhecerem o básico. Quem aprende o básico primeiro, tem um rendimento muito melhor no futuro.

9. Aprenda o que são e como usar bibliotecas e frameworks – quando precisa de algum recurso no Java, como por exemplo gerar um arquivo PDF, fazer um acesso SSH, etc; antes de sair reinventando a roda, saiba que existe uma chance de quase 100% de alguém já ter feito isso. Por esse motivo, crie o hábito de procurar por bibliotecas e frameworks antes de sair programando.

10.Faça um programa exemplo – a melhor maneira de testar os seus conhecimentos de uma linguagem é fazer um programa que junte todas as peças que aprendeu. Pode ser uma pequena agenda, uma lista de ramais de uma empresa, não importa. Comece criando uma aplicação dessas primeiro armazenando os valores na memória dentro de Arrays e depois avance para armazenar em um banco de dados. Mais tarde use esse mesmo esquema para criar uma aplicação web ou uma aplicação em um celular.

Além de cursos ou livros, tem gente que prefere criar um blog para incentivar o aprendizado, escrever resumos, aí cada um é de um jeito.

Não é tarde para ingressar no mercado de Java, mesmo com outras linguagens emergindo, os trabalhos em Java ainda são abundantes e mesmo que isso mude, o legado hoje é enorme e manterá o mercado aquecido por um bom tempo.

Dica extra: aprenda SQL ! Se você conseguir ser um profissional que realmente conhece SQL, será um profissional diferenciado entre os profissionais Java.

Boa sorte!

Fernando Boaglio, para a comunidade.

É impressionante a quantidade de revistas, livros,anotações que a gente guarda com a ilusão que algum dia vamos consultar. Na prática a gente usa o Google, essa é a verdade, mas continuamos a guardar as coisas por talvez algum apelo emocional pelo esforço de ter estudado ou anotado várias coisas.

As vezes alguma anotação é preciosa e merece ser guardada, mas será que ela não está ultrapassada? Faça uma nova anotação se necessário, faça um resumo do que interessa e livre-se do resto.

Vamos ser práticos ?

Então doem seus livros e revistas velhas e livrem-se de suas anotações antigas e ultrapassadas, elas não servem mais!

Fazendo uma limpeza nas minhas coisas guardadas da época da faculdade, encontrei nove ilustrações usadas num curso de orientação a objetos com C++, é impressionante como eles são interessantes e ao mesmo tempo atuais.

Bom proveito e boa limpeza!

Fernando Boaglio, para a comunidade.