Améliorer les performances de vos programmes Java.

04/09/2004

Par Lionel Roux (site)
 

Développer un cache réutilisable d'appels méthodes avec le Dynamic Proxy Handler.
V1.0

IMyClass cachedMyClass = (IMyClass)CallbackFramework.register(new MyClass());

public class CallBackFramework 
  implements InvocationHandler 
{
  ...
  // le reste du code ici;
}

public static Object register(Object object) 
{
  Class clazz = object.getClass();
  return Proxy.newProxyInstance
    (
      clazz.getClassLoader(),
      clazz.getInterfaces(),
      new CallbackFramework(object)
    );
}

Object object = null;

private CallBackFramework(Object object) 
{
  this.object = object;
  ...
}

public Object invoke(Object proxy, Method method, Object[] args) 
  throws Throwable 
{
  if(method.getReturnType().equals(Void.TYPE)) 
  {
   // les méthodes retournant void ne doivent pas être cachées,
   // car elles ne retourne pas de résultats exploitables.
   // Nous appelons donc la méthode invoke() classique de la reflexion.
   // voir le bloc de code suivant.
   return invoke(method, args);
  } 
  else 
  {
    Map mCache    = getMethodCache(method);
    List argsKey  = Arrays.asList(args);
    Object value  = mCache.get(argsKey);

    if (value == null && !mCache.containsKey(argsKey)) 
    {
      value = invoke(method, args);
      mCache.put(argsKey, value);
    }

    return value;
  }
}

private Object invoke(Method method, Object[] args)
    throws Throwable 
{
  try 
  {
    return method.invoke(object, args);
  } 
  catch (InvocationTargetException e) 
  {
    throw e.getTargetException();
  }
}

// Nous récupérons dans le cache des méthodes, le cache spécifique
// mCache à la méthode method.
Map mCache    = getMethodCache(method);

// Nous construisons la clé avec l'ensemble des arguments args.
List argsKey = Arrays.asList(args);

// Nous tentons de récupérer dans le cache spécifique le résultat
// pour les arguments présentés.
Object value = mCache.get(argsKey);

public class DataBaseHelper extends ICachedDb
{
  Connection connection;
  //…

  public ResultSet executeQuery(String query)
  {
    connection.executeQuery(query);
  }
}

public interface ICachedDb
{
  public ResultSet executeQuery(String query);
}

ICachedDb cachedDbHelper = (ICachedDb)CallbackFramework.register(new DataBaseHelper(…));

ICachedDb notCachedDbHelper = new DataBaseHelper(…);

... 

// cette requête est mise en cache. Elle ne sera exécutée qu'une fois
ResultSet countries = cachedDbHelper.executeQuery("Select * from Country");

// cette requête n'est pas dans le cache, elle sera exécutée à 
// chaque invocation
ResultSet stocks = notCachedDbHelper.executeQuery("Select * from Stock");

import java.util.*;

public class ExpireCache extends Cache
{
  Map cache;
  Map time;
  long timeout;

  public ExpireCache(long timeout)
  {
    this.cache = new HashMap();
    this.time = new HashMap();
    this.timeout = timeout;
  }
  
  public Object get(Object key)
  {
    if(!isExpired(key))
    {
      return cache.get(key);
    }
    else
    {
        cache.remove(key);
        time.remove(key);
        return null;
    }
  }
  
  public Object put(Object key, Object value)
  {
    time.put(key, new Long(System.currentTimeMillis()));
    return cache.put(key, value);
  }
  
  private boolean isExpired(Object key)
  {
    Long keyTime = (Long)time.get(key);
    
    if(keyTime != null)
    {
      return(keyTime.longValue()+timeout < System.currentTimeMillis());
    }
    return true;
  }
}

public static Object register(Object object, Cache cache) 
{
  Class clazz = object.getClass();
  return Proxy.newProxyInstance
    (
      clazz.getClassLoader(),
      clazz.getInterfaces(),
      new CallbackFramework(object, cache)
    );
}

Object object = null;
Cache cache = null;

private CallBackFramework(Object object, Cache cache) 
{
  this.object = object;
  this.cache = cache
}

// Nous récupérons dans le cache des méthodes, le cache spécifique
// mCache à la méthode method.
Cache mCache    = getMethodCache(method);

// Nous construisons la clé avec l'ensemble des arguments args.
List argsKey = Arrays.asList(args);

// Nous tentons de récupérer dans le cache spécifique le résultat
// pour les arguments présentés.
Object value = mCache.get(argsKey);

// définition d'un proxy dont les requêtes sont valables 2 minutes.
ICachedDb shortCachedDbHelper = (ICachedDb)CallbackFramework
                                  .register(new DataBaseHelper(…), 
                                            new ExpireCache(120000L));

// définition d'un proxy dont les requêtes sont valables 1 heure.
ICachedDb longCachedDbHelper = (ICachedDb)CallbackFramework
                                  .register(new DataBaseHelper(…), 
                                            new ExpireCache(3600000L));

Lisp - Pau Graham on Lisp :
 http://www.paulgraham.com/onlisp.html Sun.com - Joshua Bloch effective java on reflection :
 http://java.sun.com/docs/books/effective/ OnJava.com - Tom White :
 http://www.onjava.com/pub/a/onjava/2003/07/20/memoization.html Sun.com - La documentation du Proxy :
 http://java.sun.com/j2se/1.4.1/docs/api/java/lang/reflect/Proxy.html Sun.com - The reflection API:
 http://java.sun.com/docs/books/tutorial/reflect/

Pour toute question ou précision, ou encore pour toute demande ou prestation, n'hésitez pas à me contacter par email : lionel.roux at redaction-developpez dot com.
Visitez  mon site (http://lroux.developpez.com) régulièrement pour vérifier les mises à jour et lire d'autres articles.

 Telecharger ce document au format PDF