Para quem conhece os dipositivos da nokia que usam a plataforma maemo (maemo.org) segue uma boa notícia. Acabamos de lançar a versão pré-final do ambiente de desenvolvimento integrado com Eclipse IDE para estes dispositivos, daí o nome Maemo IDE Integration.  Ele também já suporta o mais novo dispositivo nokia para maemo e recém lançado no mercado,  é simplesmente uma máquina clique e vejam o N900 !!

Vejam as duas linhas do produto e os screenshots disponíveis em:

ESbox - IDE para aplicações C/C++ e Python, requer instalação de SDK para executar cross-compilation para o dispositivo.

PluThon-  IDE leve para aplicações  python utilizando diretamente o dispositivo como plataforma de desenvolvimento, não requer SDK.

Existem muitas features novas legais além de um novo sistema de ajuda sensível  para o desenvolvedor que é dinamicamente atualizado pelos mantenedores ! =]

Para criação destes dois produtos eclipse,  foi desenvolvido um o novo framework base: Mica (Maemo IDE Common Architecture -  http://mica.garage.maemo.org/2nd_edition/), matendo a aquitetura de cada produto bastante simplificada e fácil para quem desejar colaborar ou estender os mesmos ou ainda criar o seu….  hein? Sim o código é inteiramente open-source e tem licensa EPL .

O link oficial do anúncio: http://maemo.org/news/announcements/maemo_eclipse_integration_2nd_edition_prefinal_released/

Para aqueles que desejam entrar no mundo JEE Web e precisam de um ponta pé inicial, nada melhor que uma apresentação curta e grossa com uma visão simplificada do assunto.

Registre sua dúvida ou opinião sobre o mini-workshop http://fabricioepa.googlepages.com/jeequickstart-webtier

Após um bomtempo sem publicar devido a minha dedicação ao projeto “Easy Accept Web” (mas isso fica para outro post), anuncio um novo componente para auxílio a manipulação e associação de caminhos de arquivos/diretórios com POJOS. Muito útil quando sua aplicação trabalha em conjunto com framework ORM (Hibernate like), onde se deseja por exemplo associar uma entidade com um determinado diretório de arquivos (para upload/download por exemplo), seu nome por enquanto é :

JBean File Storage

O componente ainda apesar de implementado ainda não está disponibilizado publicamente pois ainda necessita de revisão, documentação e algumas possíveis melhorias embora esta versão esteja presente em 2 projetos já em produção.

A idéia chave foi associar um caminho a um tipo java, eu mentiria se dissesse que a idéia foi completamente minha pois me baseei numa solução proposta por Luciano Logrado ao trabalharmos juntos em um outro projeto, digamos que eu incrementei a idéia para suportar polimorfismo e com isto será possível:

• Associar um caminho a uma tipo (classe ou interface) e seus subtipos também estarão associados
• Usar uma Expression Language (semelhante a do JSP 2.0) mínima para usar caminhos dinâmicos
• Herdar um caminho dum outro POJO
• Manter na hierarquia de diretórios a hierarquia nas associações dos POJOS

Estes dois últimos são importantes caso por exemplo existam dois POJO’s com relacionamento de pai/filho e ao excluir o pai os filhos devem ser excluídos:

Cliente ->* Conta

Desta forma o caminho de arquivos do cliente poderia ser:

$/Cliente_99

/Conta_33

MeuExtrato1.txt

/Conta_34

Extrato2008.txt

Com uma operação de exclusão do diretório do cliente haverá propagação no sistema de arquivo para os subdiretórios, ou seja, as contas. Além de manter a organização dos arquivos numa hierarquia de pastas de fácil entendimento visual e manipulação.

Veja detalhes do uso:

Configuração

Consiste em definir num arquivo xml os caminhos (paths) e as formas de amazenamento de arquivos utilizada (Stores).

Arquivo: test-file-storage.xml

<jbfs-conf>
    <stores>
        <local-system-file-store
          name="MySampleFileStorage"
          rootDir="C:/temp" />
    </stores>
<paths>
<path name="root" >/MyRootDir</path>
<path name="fatherDir" type="jbfs.test.FatherBean">
          ${root}/Father/${_bean.name}
       </path>
<path name="childSubdir">
            ${fatherDir}/ChildSubdir
       </path>
<path name="childFileName" type="jbfs.test.ChildBean" >
             ${_bean.father}/ChildDir/${_bean.childName}.txt
       </path>
    </paths>
</jbfs-conf>

Uso

Basta recuperar a instância do JBFS e utlizar os dois objetos principais:

• PathResolver (Resolvedor de Caminhos) -> Resolve qual caminho associado ao objeto ou um nome utilizando os paths configurados.
• FileStorage (O armazenamento de arquivos) -> Representa uma Store configurada e executa as operações sobre o sistema de arquivo escolhido.
  • Podem existir várias implementações de FileStorage conforme o sistema de arquivo utilizado: FTP, sistema de arquivos remoto, etc. Por enquanto só existe a implementação de armazenamento em disco local: <local-system-file-store />

Segue abaixo um teste unitário que exemplifica o uso duma possível classe cliente do nosso componente:

package jbfs.test;

public class TestPathResolver {

    protected JBeanFileStorage jbfs;

   //CONFIGURANDO
    @Before
    public void setUp() {
        jbfs = new JBeanFileStorage("test-storage.xml"); //File must be on classpath
    }

    //Resolvendo um diretório baseado em um nome
    @Test
    public void testResolveSimplePathFromName() {

        String path = jbfs.getPathResolver().resolveName("root", null);

        assertEquals("/MyRootDir", path);

    }

    //Resolvendo um diretório baseado em um Bean
    @Test
    public void testResolvePathFromBean() {

        FatherBean bean = new FatherBean("fatherName");

        String path= jbfs.getPathResolver().resolveBean(bean);

        assertEquals("/MyRootDir/Father/fatherName", path);
    }

    @Test
    public void testResolveComplexPathFromBean() {

        ChildBean bean = new ChildBean("childFile", new FatherBean("fatherName"));

        String filePath = jbfs.getPathResolver().resolveBean(bean);

        assertEquals("/MyRootDir/Father/fatherName/ChildDir/childFile.txt", filePath);
    }

//TESTANDO MANIPULAÇÃO DOS ARQUIVOS
@Test
    public void testFileCRUD() {

        ChildBean bean = new ChildBean("childFile", new FatherBean("fatherName"));

        String filePath= jbfs.getPathResolver().resolveBean(bean);

       FileStorage storage = jbfs.getStore("MySampleFileStorage");

        try {
            storage.createNewFile(filePath, "hellow".getBytes());

            assertTrue(storage.exists(filePath));

            assertEquals("hellow", new String(storage.getBytes(filePath)));

            storage.delete(filePath);

            assertFalse(storage.exists(filePath));

        } catch (IOException e) {
            e.printStackTrace();
            fail("Test fail");
        }
   }
}

Integração com outros Componentes

Quando trabalhando com um framework ORM como Hibernate, pode ser interessante apagar os arquivos associados de uma entidade automaticamente quando for removida do Banco de Dados. Seguindo o exemplo Cliente -> * Conta, quando a transação que remove a entidade Cliente for confirmada os arquivos do cliente e suas contas serão excluídos. Para isto interceptador como o implementado abaixo pode ser utilizado em conjunto com o JBFS:

/**
 * File Garbage Collector tries to remove file paths associated with deleted
 * Hibernate Entities.
 *
 * @author Fabrí­cio Silva
 *
 */
public class FileGarbageCollector extends EmptyInterceptor {

	private FileStorage repository;
	private PathResolver pathResolver;
	private JBeanFileStorage jbfs;
	private static SessionFactory hibernateSessionFactory;

	private Map trash = new HashMap();

       public FileGarbageCollector (SessionFactory hibernateSessionFactory){
            this.hibernateSessionFactory = hibernateSessionFactory;
        } 

	@Override
	public void onDelete(Object entity, Serializable id, Object[] state,
			String[] propertyNames, Type[] types) {

		if (jbfs.getConfiguration().hasPolimorficPath(entity)) {
			putPathInGarbageForDeletion(pathResolver.resolveBean(entity));
		}
	}

	@Override
	public void afterTransactionCompletion(Transaction tx) {
		performGarbageDeletion(tx);
	}

	private void performGarbageDeletion(Transaction tx) {
		Garbage g = trash.remove(tx);
		if (g != null && tx.wasCommitted() && !tx.wasRolledBack()) {
			for (String path : g.paths) {
				try {
					repository.deleteQuietly(path);
				} catch (Exception e) {
					logger.debug(
							"Error when file garbage collector try to delete path:"
									+ path, e);
				}
			}
		}
	}

       private void putPathInGarbageForDeletion(String path) {
		Transaction tx = hibernateSessionFactory.getCurrentSession()
				.getTransaction();

		Garbage g = trash.get(tx);
		if (g == null) {
			g = new Garbage();
			trash.put(tx, g);
		}
		g.addPath(path);
	}

       class Garbage {
		protected List paths = new LinkedList();

		void addPath(String path) {
			paths.add(path);
		}

		List getPaths() {
			return paths;
		}

		void setPaths(List paths) {
			this.paths = paths;
		}

	}

     //O código que inicializa as variáveis de instância foi omitido...
}

Por o JFBS ser um POJO ele pode facilmente se integrar com qualquer framework ou componente de sua aplicação, em especial no framework Spring sua configuração é tão simples como de qualquer outro bean:

<!-- File Storage -->
<bean id="jbfs"
	class="easyaccept.util.file.jbfs.JBeanFileStorage" scope="singleton" >
<property name="confLocation">
		<value>file-storage.xml</value>
	</property>
</bean>

Espero que tenham gostado, quando o componente estiver com o mínimo aceitável de documentação será publicado aqui. Futuramente outras implementações de armazenamento estarão disponíveis:

• FTP
• SVN
• CVS
• Remote System File

Abraço.

Olá pessoal, estou publicando em minha página pessoal uma apresentação rápida que fiz sobre alguns fundamentos para desenvolvimento de projetos em equipes de maneira colaborativa.

Em suporte a este propósito utilizei os recursos do Subversion (SVN), por ser open-source e de livre distribuição, além de integrar novos recursos em relação ao famoso sistema de controle de versão CVS.

O foco do estudo foi relacionado aos usuários de um repositório, como também o recurso de integração com Java/Eclipse IDE.

Enjoy it =) !

Fundamentos do Controle de Versão e SVN

O referido erro também ocorre com mesagem semelhante:

Illegal attempt to associate a collection with two open sessions

Causa:

O erro é provocado quando um hiberObject associado a uma sessão tenta ser alterado por outra sessão do hibernate.

Solução:

Esqueça os métodos session.get/load/update você pode conseguir o mesmo efeito com session.refresh/merge.

Contexto do Problema:

Isso acontece devido a associação de um objeto gerenciado pelo hibernate (hiberOjbect) com a sessão que o carrega. Tecnicamente se um objeto foi carregado por uma sessão, até que o objeto seja desconectado (passando para o estado Detached) ele permanece associado a ela. O que pode ser feito invocando os métodos:

//Apenas se os relacionamentos do hiberOject
//que possuem cascade="evict" eles serão também desconectados
session.evict(hiberObject);
session.clear();
session.close();
 

Se outra sessão tentar alterá-lo sem ele estar destacado da última sessão, o erro será lançado.

Problemas Típicos:

1. 0 Quando se deseja usar um objeto em outra sessão sem fechar a primeira use o evict, lembrando que se os relacionamentos não possuirem cascade=”evict” o efeito do método não servirá para eles e provavelmente o mesmo erro ocorrerá para o “proxy” dos relcionamentos (que podem ser coleções causando Illegal attempt to associate a collection with two open sessions) .

2.0 Em Aplicações WEB Java tipicamente carregamos um hiberObject e o setamos em alguma variável do contexto web (request, session, sevletContext), após algum uso pela camada de apresentação fazemos outra chamada a camada do hibernate usando esse mesmo hiberObject onde ocorre falha com o dito erro. Neste caso temos dois pontos:

• Se a sessão que o carregou anterior ainda estava aberta você recai no erro 1.0

• Caso a velha sessão já tenha morrido, o seu hiberObject não está mais conectado a mesma, porém os seus relacionamentos ainda podem ter algum “proxy” para a velha sessão. Nesse caso é mais simples usar um dos metódos:

//Caso queira reconectar e recarregar
//no seu objeto os dados do banco
session.refresh(detachedHiberObject);

//Caso queira reconectar o objeto fazer um update no banco
//de dados com as novas informações setadas no objeto
connectedHiberObject = session.merge(detachedHiberObject);

O merge/refresh tem funções diferentes, mas ambos reconectam o objeto a uma sessão, seja a mesma ou não, sem provocar erro.

AutoBox/UnBox é a conversão de forma automática entre objetos e tipos primitivos, dicas:

• Use somente quando houver “descasamento” entre tipos primitivos e objetos empacotadores
• Não abuse: um Integer não substitui um int (a performance é pior)
• Cuidado, unboxing com objetos null lança exceção

Probolema:

• Generics não trabalha com tipos primitivos

Após executar o seguinte teste de performance, constatou-se uma diferênça em média de 25% com uso do autobox. O algoritimo de teste baseou-se em comparar as duas execuções:

1. faça 1000 vezes
   • varra um ArrayList<Integer>, capturando o valor sem fazer autobox
2. faça 1000 vezes
   • varra um ArrayList<Integer> usando enhanced-loop fazendo automaticamente unbox para int, capturando o valor e fazendo autbox novamente para um objeto Integer.

Resultado da execução:

___________________________________

autoBoxUnBox()…java.lang.NullPointerException
Sem autoboxing = 6531ms
Com autobox/unbox= 8734ms
Diferença de 26%

___________________________________

Conclusão:

Se sua aplicação é “Performance Driven”, estruturas como o IntHashMap visto no blog anterior entre outras coleções da API que não trabalhem com Generics podem ser a melhor saída para escovar milisegundos de processamento.

Abaixo segue a classe usada no teste:

package update5.boxing;

import java.util.*;

/**
 *
 * @author Fabrício Silva Epaminondas
 */
public class AutoboxingUnboxing {

    static void autoBoxUnBox() {
        // Antes
        int prim = 10;// primitivo
        Integer obj = new Integer(20);// objeto
        Integer nullObj = null;

        // Java 5
        Integer c = 30;// autobox Integer c = new Integer(30)
        prim = obj;// unbox prim = obj.intValue();
        obj = prim;// autobox obj = new Integer(prim);

        try{
            prim = nullObj;// throw NullPointerException
        }catch (NullPointerException e) {
            System.out.println("autoBoxUnBox()..." + e);
        }
    }

    @SuppressWarnings("unchecked")
    static void autoboxComGenerics() {

        // Antes
        Map products = new HashMap();
        products.put(new Integer(2779), new Float(20.45f));
        products.put(Integer.valueOf(922), Float.valueOf(99.99f));
        float price = new Float((Float) products.get(new Integer(922)
                .intValue())).floatValue();

        // AutoBoxing com Generics
        Map<Integer, Float> products2 = new HashMap<Integer, Float>();
        products2.put(10, 20.45f);
        products2.put(20, 99.99f);
        float price2 = products2.get(10);

        // Problema: Performance
        // Generics só aceita Tipos de Objetos e não primitivos

        // Ex: ArrayList de Integers..
        Collection<Integer> values = new ArrayList<Integer>();
        for (int i = 0; i < 100000; i++) {
            values.add(i);
        }

        Integer intObj = null;

        // Teste de Performance 1 (Sem Autobox)
        long time = System.currentTimeMillis();

        // repete 1000 vezes
        for (int i = 0; i < 1000; i++) {
            // for em coleção de objetos Integer
            for (Integer val : values) {
                intObj = val;// sem autobox
            }
        }
        long performance1 = System.currentTimeMillis() - time;
        System.out.println("Sem autoboxing = " + performance1 + "ms");

        // Teste de Performance 2 (Com Autobox/Unbox)
        time = System.currentTimeMillis();

        // repete 1000 vezes
        for (int i = 0; i < 1000; i++) {
            // for em coleção de objetos Integer
            for (int val : values) {// executando unboxing para int
                intObj = val;// autobox para Integer
            }
        }
        long performance2 = System.currentTimeMillis() - time;
        System.out.println("Com autobox/unbox= " + performance2 + "ms");

        System.out.println("Diferença de " + percentGain(performance1,performance2) + "%");
    }

    static long percentGain(long num, long div) {
        return (100 - num*100/div);
    }

    public static void main(String[] args) {

        autoBoxUnBox();

        autoboxComGenerics();
    }
}

O java.util.HashMap como o próprio nome diz utiliza-se do hash code do objeto “chave” para mapear as entradas do mapa. Funciona basicamente assim:

HashMap map = new HashMap();
map.put("matricula.12345", "Fabricio");

A essência do funcionamento do método put() é :

public void put(Object key, Object value){
 int hash = geraHashCode(key);
 int  posicao = geraPosicaoNaTabela(hash);
 adicionaNaTabelaDeEntradas(posicao, value);
}

Quando porém estamos trabalhando com um mapa onde as chaves já são inteiros muitas operações do mapa podem ser simplificadas, solução: IntHashMap.
Algumas coporações como a Oracle, Apache, etc… possuem em suas “foundation classes” alguma implementações que trababalhem desta forma para obterem melhor performance. Afim de comparar o desempenho com HashMap executei dois teste simples

1. Povoando o mapa com 1000000 chaves sequenciais (Puts)
2. Recuperando todos os objetos do mapa (Gets), utilizou-se string como objeto para evitar autobox/unbox.

O resultado foram ganhos em média de 70% para os puts, e 30% para os gets efetuados no mapa. Veja o resultado de uma excução:

Main.testSunMap()…
Main.testIntMap()…

‘Puts’ execution time (milliseconds):
sunMap: 3328 intMap: 922, Percentage of gain: 73%

‘Gets’ execution time (milliseconds):
sunMap: 234 intMap: 140, Percentage of gain: 41%

Conclusão
Se suas chaves são inteiros use IntHashMap. Os resultados foram obtidos usando java 5, o mesmo exemplo foi executado com 1.4 e obteve em média os mesmos valores, no entanto se em sua aplicação você não tomar os devidos cuidados no uso do autoboxing/unboxing de valores primitivos para objetos, a diferença de ganho vai ser ainda em muito melhor para o IntHashMap devido a perda de performance executando o boxing.

Código do Teste:

import java.util.HashMap;

public class Main {

    public static final int NUMBER_LOOPS = 1000000;
    static long sunMapPuts = 0;
    static long sunMapGets = 0;

    static long intMapPuts = 0;
    static long intMapGets = 0;

    /**
     * @param args
     */
    public static void main(String[] args) {
        testSunMap();
        testIntMap();

        System.out.println("\n'Puts' execution time (milliseconds): ");
        System.out.println("sunMap: "+ sunMapPuts +" intMap: " + intMapPuts
                + ", Percentage of gain: " + percentGain(intMapPuts, sunMapPuts) + "%") ;

        System.out.println("\n'Gets' execution time (milliseconds): ");
        System.out.println("sunMap: "+ sunMapGets +" intMap: " + intMapGets
                + ", Percentage of gain: " + percentGain(intMapGets, sunMapGets) + "%") ;

    }

    private static void testSunMap() {
        System.out.println("Main.testSunMap()...");
        HashMap<Integer, Object> sunMap = new HashMap<Integer, Object>();

        Object value = "111";

        //test puts
        long time = System.currentTimeMillis();
        for(int i = 0; i< NUMBER_LOOPS; i++){
            sunMap.put(i, value);
        }
        sunMapPuts =  System.currentTimeMillis() - time;

        //test gets
        time = System.currentTimeMillis();
        for(Integer i :sunMap.keySet()){
            sunMap.get(i);
        }
        sunMapGets =  System.currentTimeMillis() - time;
    }

    private static void testIntMap() {
        System.out.println("Main.testIntMap()...");
        IntHashMap intMap = new IntHashMap();

        Object value = "222";

        //test puts
        long time = System.currentTimeMillis();
        for(int i = 0; i< NUMBER_LOOPS; i++){
            intMap.put(i, value);
        }
        intMapPuts = System.currentTimeMillis() - time;

        //test gets
        time = System.currentTimeMillis();
        int[] keySet = intMap.keySet();
        for(int i =0; i< keySet.length; i++){
            intMap.get(keySet[i]);
        }
        intMapGets =  System.currentTimeMillis() - time;

    }

    static long percentGain(long num, long div) {
        return (100 - num*100/div);
    }

}

Uma implementação de IntHashMap:

/**
 * A hash map mapping int values to objects. This offers the benefit of not having to use objects as keys, which can result in performance benefits.
 */
public class IntHashMap {
    /** The default capacity for hash map instances. */
    public static final int DEFAULT_CAPACITY = 17;

    /** The maximum allowed capacity for hash map instances. */
    public static final int MAXIMUM_CAPACITY = 1 << 30;

    /** The default load factor for hash map instances. */
    public static final float DEFAULT_LOADFACTOR = 0.75f;
    private MapElement[]      map = null; // The first bucket for each key
    private int[]             count = null; // The count of buckets in each chain
    private int               contents = 0;
    private int               objectCounter = 0; // Counter for objects created
    private int               capacity = DEFAULT_CAPACITY;
    private int               initialCap = DEFAULT_CAPACITY;
    private float             loadFactor = DEFAULT_LOADFACTOR;
    private int               maxLoad = 0;
    private boolean           rehashing = true;

    /**
     * Constructs an empty instance with the default initial capacity and the default load factor
     */
    public IntHashMap() {
        this(DEFAULT_CAPACITY, DEFAULT_LOADFACTOR);
    }

    /**
     * Constructs an empty instance with the given initial capacity and the default load factor
     *
     * <p></p>
     *
     * @param initialCapacity The initial capacity for this hash map.
     */
    public IntHashMap(int initialCapacity) {
        this(initialCapacity, DEFAULT_LOADFACTOR);
    }

    /**
     * Constructs an empty instance with the given initial capacity and the given load factor
     *
     * <p></p>
     *
     * @param initialCapacity The initial capacity for this hash map.
     * @param loadFactor The load factor for this hash map.
     */
    public IntHashMap(int   initialCapacity,
                      float loadFactor) {
        construct(initialCapacity, loadFactor);
    }

    /**
     * Constructs a new HashMap with the same mappings as the specified Map. The HashMap  is created with default load factor and an initial capacity
     * sufficient to hold the  mappings in the specified Map.
     *
     * <p></p>
     *
     * @param m The map whose mappings are to be placed in this map. Throws: <p>
     *
     * @throws IllegalArgumentException if the specified map is<code>null</code>.
     */
    public IntHashMap(IntHashMap m) {
        if (m == null) {
            throw new IllegalArgumentException("m may not be null");
        }

        //.... Determine parameters
        loadFactor     = DEFAULT_LOADFACTOR; // As per standard API for java.util.HashMap
        capacity       = (int) (m.size() / loadFactor);

        if (capacity < DEFAULT_CAPACITY) { // Avoid underflow
            capacity = DEFAULT_CAPACITY;
        } else if ((capacity % 2) == 0) { // Make sure we have an odd value
            capacity++;
        }

        //.... Standard initialization for the internal map elements
        maxLoad        = (int) ((loadFactor * capacity) + 0.5f); // Max. number of elements before a rehash occurs
        initialCap     = capacity;

        objectCounter += 2;
        map       = new MapElement[capacity];
        count     = new int[capacity];

        //.... Copy the elements to the new map
        int[] keys = m.keySet();

        for (int i = 0; i < m.size(); i++) {
            put(keys[i], m.get(keys[i]));
        }
    }

    /**
     * Return the current number of mappings in the hash map.
     *
     * <p></p>
     *
     * @return The current number of mappings in the hash map.
     */
    public int size() {
        return contents;
    }

    /**
     * Returns <code>true</code> if this map contains no key-value mappings.
     *
     * @return DOCUMENT ME!
     */
    public boolean isEmpty() {
        return (contents == 0) ? true : false;
    }

    /**
     * Removes all mappings from this map.
     */
    public void clear() {
        construct(initialCap, loadFactor);
    }

    /**
     * Return the number of objects created in / by this instance
     *
     * <p></p>
     *
     * @return The number of objects created
     */
    public int getObjectCounter() {
        return objectCounter;
    }

    /**
     * Return the current capacity of the instance. If rehashing is enabled (which it is per default), the capacity may have been increased as
     * necessary from the initial value.
     *
     * <p></p>
     *
     * @return The current capacity for this hash map.
     */
    public int getCapacity() {
        return capacity;
    }

    /**
     * Return the load factor of the instance.
     *
     * <p></p>
     *
     * @return The load factor for this hash map.
     */
    public float getLoadFactor() {
        return loadFactor;
    }

    /**
     * Return the keys in the hash map
     *
     * <p></p>
     *
     * @return An array containing the keys for which mappings are stored in this hash map.
     */
    public int[] keySet() {
        objectCounter++;

        int[]      keys = new int[contents];
        int        cnt = 0;
        MapElement me = null;

        for (int i = 0; i < capacity; i++) {
            if (map[i] != null) {
                me = map[i];

                for (int j = 0; j < count[i]; j++) {
                    keys[cnt++]     = me.getKey();
                    me              = me.getNext();
                }
            }
        }

        return keys;
    }

    /**
     * Enable/disable rehashing (defaults to <code>true</code>).
     *
     * <p></p>
     *
     * @param rehashing A boolean indicating the desired rehashing status.
     */
    public void setRehash(boolean rehashing) {
        this.rehashing = rehashing;
    }

    /**
     * Associates the specified value with the specified key in this map. If  the map previously contained a mapping for this key, the old value is
     * replaced.
     *
     * <p></p>
     *
     * @param key The key with which the specified value is to be associated.
     * @param value The value to be associated with the specified key.  <p>
     *
     * @return Previous value associated with specified key, or <code>null</code> if there was no mapping  for key. A <code>null</code> return can
     *         also indicate that the HashMap previously associated <code>null</code>  with the specified key.
     */
    public Object put(int    key,
                      Object value) {
        int index = key % capacity;

        if (index < 0) {
            index = -index;
        }

        //.... This is a new key since no bucket exists
        if (map[index] == null) {
            objectCounter++;
            map[index] = new MapElement(key, value);
            count[index]++;
            contents++;

            if (contents > maxLoad) {
                rehash();
            }

            return null;

            //.... A bucket already exists for this index: check whether we already have a mapping for this key
        } else {
            MapElement me = map[index];

            while (true) {
                if (me.getKey() == key) { // We have a mapping: just replace the value for this element

                    Object previous = me.getValue(); // Return the current value - same as for java.util.HashMap.put()
                    me.setValue(value);

                    return previous;
                } else {
                    if (me.getNext() == null) { // No next element: so we have no mapping for this key
                        objectCounter++;
                        me.setNext(new MapElement(key, value));
                        count[index]++;
                        contents++;

                        if (contents > maxLoad) {
                            rehash();
                        }

                        return null;
                    } else {
                        me = me.getNext();
                    }
                }
            }
        }
    }

    /**
     * Returns the value to which the specified key is mapped in this identity  hash map, or <code>null</code> if the map contains no mapping for
     * this key. A return  value of <code>null</code> does not necessarily indicate that the map contains no  mapping for the key; it is also
     * possible that the map explicitly maps  the key to <code>null</code>. The <code>containsKey</code>  method may be used to distinguish these
     * two cases.
     *
     * <p></p>
     *
     * @param key The key whose associated value is to be returned.  <p>
     *
     * @return The value to which this map maps the specified key, or  <code>null</code> if the map contains no mapping for this key.
     */
    public Object get(int key) {
        MapElement me = exists(key);

        if (me == null) {
            return null;
        } else {
            return me.getValue();
        }
    }

    /**
     * Returns <code>true</code> if this map contains a mapping for the specified key.
     *
     * <p></p>
     *
     * @param key The key whose presence in this map is to be tested. <p>
     *
     * @return <code>true</code> if this map contains a mapping for the specified key.
     */
    public boolean containsKey(int key) {
        if (exists(key) == null) {
            return false;
        } else {
            return true;
        }
    }

    /**
     * Removes the mapping for this key from this map if present.
     *
     * <p></p>
     *
     * @param key The key whose mapping is to be removed from the map. <p>
     *
     * @return Previous value associated with specified key, or  <code>null</code>  if there was no mapping for key. A <code>null</code> return can
     *         also indicate that the map previously associated <code>null</code>  with the specified key.
     */
    public Object remove(int key) {
        int index = key % capacity;

        if (index < 0) {
            index = -index;
        }

        if (map[index] == null) {
            return null;
        } else {
            MapElement me = map[index];
            MapElement prev = null;

            while (true) {
                if (me.getKey() == key) { // Keys match

                    if (prev == null) { // The first element in the chain matches
                        map[index] = me.getNext();
                    } else { // An element further down in the chain matches - delete it from the chain
                        prev.setNext(me.getNext());
                    }

                    count[index]--;
                    contents--;

                    return me.getValue();
                } else { // Keys don't match, try the next element
                    prev     = me;
                    me       = me.getNext();

                    if (me == null) {
                        return null;
                    }
                }
            }
        }
    }

    /**
     * Helper method: returns the element matching the key, or <code>null</code> if no such element exists
     *
     * @param key DOCUMENT ME!
     *
     * @return DOCUMENT ME!
     */
    private MapElement exists(int key) {
        int index = key % capacity;

        if (index < 0) {
            index = -index;
        }

        if (map[index] == null) {
            return null;
        } else {
            MapElement me = map[index];

            while (true) {
                if (me.getKey() == key) {
                    return me;
                } else {
                    me = me.getNext();

                    if (me == null) {
                        return null;
                    }
                }
            }
        }
    }

    /**
     * Increase the capacity of the map to improve performance
     */
    private void rehash() {
        if (rehashing) {
            int newCapacity = (2 * capacity) + 1;

            if (newCapacity > MAXIMUM_CAPACITY) {
                return;
            }

            objectCounter += 2;

            MapElement[] newMap = new MapElement[newCapacity];
            int[]        newCount = new int[newCapacity];

            MapElement   me = null;
            MapElement   t = null;
            MapElement   next = null;
            int          newIndex = 0;

            for (int index = 0; index < capacity; index++) {
                me = map[index];

                while (me != null) {
                    next         = me.getNext();
                    newIndex     = me.getKey() % newCapacity;

                    if (newIndex < 0) {
                        newIndex = -newIndex;
                    }

                    newCount[newIndex]++;

                    if (newMap[newIndex] == null) { // No element yet for this new index
                        newMap[newIndex] = me;
                        me.setNext(null);
                    } else { // Hook the element into the beginning of the chain
                        t                    = newMap[newIndex];
                        newMap[newIndex]     = me;
                        me.setNext(t);
                    }

                    me = next;
                }
            }

            map          = newMap;
            count        = newCount;
            capacity     = newCapacity;
            maxLoad      = (int) ((loadFactor * capacity) + 0.5f); // Max. number of elements before a rehash occurs

            newMap = null;
        }
    }

    /**
     * Construction helper method
     *
     * @param initialCapacity DOCUMENT ME!
     * @param loadFactor DOCUMENT ME!
     *
     * @throws IllegalArgumentException DOCUMENT ME!
     */
    private void construct(int   initialCapacity,
                           float loadFactor) {
        if (initialCapacity < 0) {
            throw new IllegalArgumentException("Invalid initial capacity: " + initialCapacity);
        }

        if (initialCapacity < DEFAULT_CAPACITY) {
            initialCapacity = DEFAULT_CAPACITY;
        }

        if (initialCapacity > MAXIMUM_CAPACITY) {
            initialCapacity = MAXIMUM_CAPACITY;
        }

        if ((loadFactor <= 0.0f) || Float.isNaN(loadFactor)) {
            throw new IllegalArgumentException("Invalid load factor: " + loadFactor);
        }

        this.initialCap     = initialCapacity;
        this.capacity       = initialCapacity;
        this.loadFactor     = loadFactor;

        objectCounter += 2;
        maxLoad      = (int) ((loadFactor * capacity) + 0.5f); // Max. number of elements before a rehash occurs
        map          = new MapElement[capacity];
        count        = new int[capacity];
        contents     = 0;
    }

    /**
     * Statistical output for this map.
     *
     * <p></p>
     *
     * @param full A boolean indicating whether just a short of the full information should be printed.
     */
    public void printStatistics(boolean full) {
        if (full) {
            for (int i = 0; i < capacity; i++) {
                System.out.println("Count[" + i + "] = " + count[i]);
            }
        }

        System.out.println("Initial capacity   = " + initialCap);
        System.out.println("Capacity           = " + capacity);
        System.out.println("Number of elements = " + contents);
    }

    /**
         *
         */
    class MapElement {
        private int        key = 0;
        private Object     value = null;
        private MapElement next = null;

        /**
         * Constructor
         *
         * @param key DOCUMENT ME!
         * @param value DOCUMENT ME!
         */
        public MapElement(int    key,
                          Object value) {
            this.key       = key;
            this.value     = value;
        }

        /**
         * Getter method for <code>key</code> property
         *
         * <p></p>
         *
         * @return The value for the <code>key</code> property
         */
        public int getKey() {
            return key;
        }

        /**
         * Setter method for <code>value</code> property
         *
         * <p></p>
         *
         * @param value The value for the <code>value</code> property
         */
        public void setValue(Object value) {
            this.value = value;
        }

        /**
         * Getter method for <code>value</code> property
         *
         * <p></p>
         *
         * @return The value for the <code>value</code> property
         */
        public Object getValue() {
            return value;
        }

        /**
         * Setter method for <code>next</code> property
         *
         * <p></p>
         *
         * @param next The value for the <code>next</code> property
         */
        public void setNext(MapElement next) {
            this.next = next;
        }

        /**
         * Getter method for <code>next</code> property
         *
         * <p></p>
         *
         * @return The value for the <code>next</code> property
         */
        public MapElement getNext() {
            return next;
        }
    }
}

Você já se perguntou como algumas IDE’s configuram o classpath da sua aplicação dinamicamente em tempo de execução?

Aqui vai uma solução técnica alternativa (that means GDD – Gambiarra Driven Development ).

A classe java.net.URLClassLoader é o classloader default do sistema para carregar o jars do classpath quando o aplicativo java é iniciado.
Uma maneira de adicionar jars extras seria invocando no classloder o método addURL(URL url), o que faz o jar localizado por está URL ser carregado na JVM em execuçao. O problema é que este método é protegido (protected) e portanto, a menos que você extenda o URLClassLoader, sobreescreva o método mudando a visibilidade para público e configure seu classloder como default do sistema você não poderá invocá-lo na instância do classloader.
Mas como nem tudo é impossível na computação, você pode contornar o problema usando reflexão e acessando o método protegido. Para isso basta recuperar o método “addURL” declarado e invocar setAccessible(true).

A classe abaixo mostra como você mata os dois coelhos com uma única cajadada:

public class ClassPathHacker {

private static final Class[] parameters = new Class[]{URL.class};

public static void addFile(String s) throws IOException {
 File f = new File(s);
 addFile(f);
}//end method

public static void addFile(File f) throws IOException {
 addURL(f.toURL());
}//end method

public static void addURL(URL u) throws IOException {

	URLClassLoader sysloader = (URLClassLoader)ClassLoader.getSystemClassLoader();
 Class sysclass = URLClassLoader.class;

	try {
 	Method method = sysclass.getDeclaredMethod("addURL",parameters);
 	method.setAccessible(true);
 	method.invoke(sysloader,new Object[]{ u });
 } catch (Throwable t) {
 	t.printStackTrace();
 	throw new IOException("Error, could not add URL to system classloader");
 }//end try catch

}//end method

}//end class

Baseado no Fórum:

http://forum.java.sun.com/thread.jsp?forum=32&thread=300557&tstart=0&trange=15

Proxy4jdbc3 – The Proxy for JDBC 3

É um componente de software desenvolvido para interceptar o SQL executado por um aplicativo Java através das chamadas sobre a JDBC. Uma solução rápida e simples para quem deseja depurar, fazer logging ou perfilar a execução do SQL sem ter que modificar a arquitetura da aplicação.

Para usá-lo primeiro são necessários apenas 4 passos:

1. É necessário saber qual o componente provedor das conexões com os dados da sua aplicação, exemplo: Driver Manager, DataSource, algum Componente de Pooling, etc…,
2. Conhecido o provedor, então deve se escolher o componente correspondente de Proxy. Obs.: Você também pode estender ou criar seu componente customizado.
3. Implementar o Proxy criando a solução vendor-especifc, i.e, especifica do seu SGBD. No pacote proxy4jdbc3.solutions.* você encontrará soluções-exemplo.
4. Substitua a referência ao provedor de conexão pela referência ao Proxy.

O componente foi desenvolvido sobre a JDBC 3, e está ainda em fase de teste (beta).
Maiores informações em: http://proxy4jdbc3.sourceforge.net/