Dynamic type serialization

[Aaron Hamid <ar...@cornell.edu>]

Hi all,

   Dims, Tom, Glen, I am {aaron} from Freenode.

Anyway, I am having problems implementing "dynamic type" serialization 
  under Axis.  I can probably best explain what I mean with an example:

Say we have some sort of opaque complex type as input and output 
messages to some soap call.  Let's also say I'm doing dynamic 
invocation.  That means I do not have "proper" 
serialization/deserialization stubs for the aforementioned opaque 
input/output types.  Is all lost?  No.  If I take a Map object, I can 
make a best-effort to serialize key/value pairs as elements in the 
opaque type.  Of course this is not going to be accurate, and without 
recursion will only work for one level of nesting, however, it is 
probably going to still catch a majority of cases (at least in my 
environment).

The problem is, that serialization and deserialization factories and 
TypeDescs, are mapped on Class.  This renders the above scheme 
impossible without some sort of ThreadLocal hacks.

Let's examine.  Let's say I create a new custom "bean" DynamicType. 
DynamicType, will take a Map object, inspect the map for key/value 
pairs, and expose those key/value pairs as ElementDescs in the 
TypeDesc it holds.  We will have to create a TypeDesc subclass that 
can store an explicitly constructed BeanPropertyDescriptor array, as 
the default TypeDesc implementation does implicit bean introspection 
(which of course will produce the "wrong thing" when introspecting a 
Map - it will just produce the interface of the Map object itself).

That is straightforward enough.  Since BeanSerializerFactory 
dynamically looks up the TypeDesc from the class it is passed, we must 
subclass BeanSerializerFactory (let's call it 
DynamicSerializerFactory) so that it takes a concrete instance of our 
aforementioned DynamicType, initialized with the Map object. 
Everything looks good so far - our DynamicSerializer factory will 
behave like a BeanSerializerFactory which produces Serializers for 
beans whose interface is that provided by the DynamicTypeDesc and 
explicit properties inspected in the Map.  Sounds good.

But now comes the catch.  We have to register this factory based on 
the _CLASS_ of input type - DynamicType.  However, if we register this 
specific factory instance for ALL DynamicType classes, we will 
inevitably produce the wrong interface at some point if this mapping 
gets overwritten with one initialized with a different concrete Map 
object.

The only solution I see is to go ahead and register our 
DynamicSerializerFactory, however, instead of keeping a member 
instance of DynamicTypeDesc, keep a ThreadLocal instance containing a 
DynamicTypeDesc, so that when we are called somewhere down the line in 
the invoke process we will produce the correct serializer for the 
interface provided by the correct DynamicType for THIS SPECIFIC 
invocation.

HOWEVER this is a big hack, and relies on the assumption that the 
invocation dispatching thread is the SAME THREAD in which we map the 
factory.

So my question is:

1) does this make sense
2) is there any way around it, or better way to implement what I want 
that I haven't found
3) does, in fact, the invocation get executed by the same thread as 
the caller? (I /think/ so, but I don't want to assume this, as all 
sorts of things like thread pools, etc., could potentially be coming 
into play)