X-Git-Url: http://wamblee.org/gitweb/?a=blobdiff_plain;f=support%2Fgeneral%2Fsrc%2Fmain%2Fjava%2Forg%2Fwamblee%2Fgeneral%2FThreadSpecificProxyFactory.java;h=036a6828648b2cd25153d8ecb6edcd8c517b7e73;hb=a09ef498cd7b52e5c77c2fbfcd26203eca50d643;hp=a5a1cebb3871e8b3334c3ecaabed71fa6232fab3;hpb=c7bccc1c2bd936d67835b1eb20e5e9d984a114ce;p=utils

diff --git a/support/general/src/main/java/org/wamblee/general/ThreadSpecificProxyFactory.java b/support/general/src/main/java/org/wamblee/general/ThreadSpecificProxyFactory.java
index a5a1cebb..036a6828 100644
--- a/support/general/src/main/java/org/wamblee/general/ThreadSpecificProxyFactory.java
+++ b/support/general/src/main/java/org/wamblee/general/ThreadSpecificProxyFactory.java
@@ -15,10 +15,14 @@
  */
 package org.wamblee.general;
 
+import java.io.Serializable;
 import java.lang.reflect.InvocationHandler;
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
 import java.lang.reflect.Proxy;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.UUID;
 
 /**
  * Thread-specific proxy is used to create implementations of interfaces that
@@ -41,13 +45,36 @@ import java.lang.reflect.Proxy;
  * 
  */
 public class ThreadSpecificProxyFactory<T> {
-    private class ThreadSpecificInvocationHandler implements InvocationHandler {
+    
+    /**
+     * We store a map of unique ids of invocation handlers to thread local storage of the 
+     * service. In this way, serialiability of the generated proxy is obtained (required by 
+     * framweorks such as wicket). Also, different factories will still be separate and never
+     * use the same threadlocal storage. 
+     */
+    private static Map<String,ThreadLocal> STORAGE = 
+        initializeThreadLocal();
+    
+    private static class ThreadSpecificInvocationHandler<T> implements InvocationHandler, Serializable {
+        
+        private String id; 
+        private Class clazz; 
+        
+        public ThreadSpecificInvocationHandler(String aId, Class aClass) { 
+            id = aId; 
+            clazz = aClass;
+        }
 
         @Override
         public Object invoke(Object aProxy, Method aMethod, Object[] aArgs)
             throws Throwable {
+            ThreadLocal<T> local = STORAGE.get(id);
+            T actualSvc = local.get();
+            if ( aMethod.getName().equals("toString") && actualSvc == null) { 
+                return "Thread-specific proxy for '" + clazz.getName() + "'";
+            }
             try {
-                return aMethod.invoke(svc.get(), aArgs);
+                return aMethod.invoke(actualSvc, aArgs);
             } catch (InvocationTargetException e) {
                 throw e.getCause();
             }
@@ -74,6 +101,11 @@ public class ThreadSpecificProxyFactory<T> {
         proxy = createProxy(); 
     }
 
+    private static Map<String, ThreadLocal> initializeThreadLocal() {
+        Map<String,ThreadLocal> map = new HashMap<String,ThreadLocal>();
+        return map;
+    }
+
     /**
      * Sets the thread-specific service.
      * 
@@ -105,7 +137,9 @@ public class ThreadSpecificProxyFactory<T> {
     }
 
     private T createProxy() {
-        InvocationHandler handler = new ThreadSpecificInvocationHandler();
+        String id = UUID.randomUUID().toString();
+        STORAGE.put(id, svc);
+        InvocationHandler handler = new ThreadSpecificInvocationHandler(id, clazz);
         Class proxyClass = Proxy.getProxyClass(clazz.getClassLoader(),
             new Class[] { clazz });
         T proxyObj;