JaxB reference resolving

For the follwing example XML input:

<Participants course="someCourse">
  <workers>
    <Worker ref="p3">
    <Worker ref="p2">
  </workers>
  <Trainer ref="p1"/>
</Participants>

<Group id="group1" name="some mixed Person group">
   <trainers>
     <Trainer id="p1" name="John Doe">
   </trainers>
   <workers>
     <Worker id="p2" name="Jim Scott">
     <Worker id="p3" name="Walter Peace">
   </workers>
</Group>

I am trying to make sure that the PersonList in Participants points to the Persons read from group1. (see code snipptes below for the JaxB annotations used). This is just an example for the more generic approach I am seeking. I need to be generally able to follow id="" and ref="" attributes in a way that the list elements are correctly unmarshalled as references.

With an UnmarshalListener and Unmarshalling twice I get around the problem of the references from the ref attribute to the id attribute. In the first phase the lookup Map is filled from the id attributes. In the second phase the refs are looked up. Unfortunately this solution will create copies instead of references. I could use the parent object to fix this but I am looking for a more generic solution. What would be a good way to achieve the proper dereferencing using ref/id attributes in the manner shown?

/**
 * intercept the unmarshalling
 */
public static class ModelElementMarshallerListener extends javax.xml.bind.Unmarshaller.Listener {

 public Map<String,Person> lookup=new HashMap<String,Person>();

 @Override
 public void afterUnmarshal(java.lang.Object target, java.lang.Object parent) {
  if (target instanceof Person) {
    person=(Person) target;
    if (person.getId()!=null) {
       lookup.put(person.getId(), person);
    }
    if (person.getRef()!=null) {
      if (lookup.containsKey(person.getRef())) {
        Person personRef=lookup.get(person.getRef());
        person.copyFrom(personRef);
        person.setRef(null);
      }
    }
   }
 }

}

@XmlRootElement(name="Participants")
public class Participants  {
  private List<Worker> workers;

 /**
   * getter for List<Worker> workers
   * @return workers
   */
  @XmlElementWrapper(name="workers")
  @XmlElement(name="Worker", type=Worker.class)
  public List<Worker> getWorkers() { 
    return workers; 
  }

...

}

@XmlRootElement(name="Group")
public class Group {

  private List<Worker> workers;

 /**
   * getter for List<Worker> workers
   * @return workers
   */
  @XmlElementWrapper(name="workers")
  @XmlElement(name="Worker", type=Worker.class)
  public List<Worker> getWorkers() { 
    return workers; 
  }
 ...

}
@XmlRootElement(name="Trainer")
public class Trainer extends Person {}


@XmlRootElement(name="Worker")
public class Worker extends Person {}

@XmlRootElement(name="Person")
public class Person {
 private String name;

 /**
   * getter for xsd:string/String name
   * @return name
   */
  @XmlAttribute(name="name")  
  public String getName() {
    return name;
  }

  public void setName(String name) {
     this.name=name;
  }
  private String ref;

 /**
   * getter for xsd:string/String id
   * @return id
   */
  @XmlAttribute(name="ref")  
  public String getRef() {
    return ref;
  }

  public void setRef(String ref) {
    this.ref=ref;
  }

  private String id;
 /**
   * getter for xsd:string/String id
   * @return id
   */
  @XmlAttribute(name="id")  
  @XmlID
  public String getId() { 
    this.id;
  }

  /**
   * setter for xsd:string/String id
   * @param pid - new value for id
   */
  public void setId(String pid) { 
    this.id=pid; 
  }
}

To better illustrate the point I have modified the question to fit his answer. There is now a generic base class Person and I am trying to use it as per Can generic XmlAdapter be written

I solved the issue of being able to actually make sure the Adapters are used by writing specific derived Classes and using them with @XmlJavaTypeAdapter. I preregister the adapters using:

JAXBContext context = JAXBContext.newInstance(type);
Unmarshaller u = context.createUnmarshaller();
u.setAdapter(Worker.WorkerAdapter.class,new Worker.WorkerAdapter());
u.setAdapter(Trainer.TrainerAdapter.class,new Trainer.TrainerAdapter());

and then unmarshalling twice. The debug shows that the Adapter instance for both passes is the same. Still the lookup somehow seemed to fail ... The reason was the way the @XmlJavaTypeAdapter annotation works see:

What package-info do I annotate with XmlJavaTypeAdapters?

There seem to be multiple modes for @XmlJavaTypeAdapter:

it can be an annotation for a class
it can be an annotation for a field (getter)
it can be used in a package-info.java file to annotate a whole package

At this point I am using all three annotations and now have to debug which ones are necessary. I assume the global annotations (class,package) are not working as expected. The reason might be the type= usage in the @XmlElementWrapper which explicitly calls for a type. Personally I do not understand what is going on yet. At least things are now working as expected.

the local field annotation is now e.g.:

@XmlElementWrapper(name="workers")
@XmlElement(name="Worker", type=Worker.class)
@XmlJavaTypeAdapter(WorkerAdapter.class)

the package-info.java annotation is:

@XmlJavaTypeAdapters({
 @XmlJavaTypeAdapter(value=WorkerAdapter.class,type=Worker.class),
 @XmlJavaTypeAdapter(value=TrainerAdapter.class,type=Trainer.class),
})
package com.bitplan.jaxb.refidtest;

import javax.xml.bind.annotation.adapters.*;

the class annotation is:

@XmlJavaTypeAdapter(Worker.WorkerAdapter.class)
public class Worker extends Person {

...

/**
 * Worker Adapter
 * @author wf
 *
 */
public static class WorkerAdapter extends  PersonAdapter<Worker>{
    @Override
    public Worker marshal(Worker me)
            throws Exception {
        return super.marshal(me);
    }


    @Override
    public Worker unmarshal(Worker me) throws Exception {
        return super.unmarshal(me);
    }
}


/**
 * https://stackoverflow.com/questions/7587095/can-jaxb-marshal-by-containment-at-first-then-marshal-by-xmlidref-for-subsequen/7587727#7587727
 * @author wf
 *
 */
public class PersonAdapter<T extends Person> extends XmlAdapter<T, T>{

    public boolean debug=true;

    /**
     * keep track of the elements already seen
     */
    public Map<String,T> lookup=new HashMap<String,T>();


    @Override
    public T marshal(T me)
            throws Exception {
        return me;
    }

    /**
     * show debug information
     * @param title
     * @param key
     * @param me
     * @param found
     */
    public void showDebug(String title,String key,T me, T found) {
        String deref="?";
        if (found!=null)
            deref="->"+found.getId()+"("+found.getClass().getSimpleName()+")";
        if (debug)
            System.err.println(title+": "+key+"("+me.getClass().getSimpleName()+")"+deref+" - "+this);
    }


    @Override
    public T unmarshal(T me)    throws Exception {
        if (me.getId()!=null) {
            showDebug("id",me.getId(),me,null);
            lookup.put(me.getId(), me);
            return  me;
        }
        if (me.getRef()!=null) {
            if (lookup.containsKey(me.getRef())) {
                T meRef=lookup.get(me.getRef());
                showDebug("ref",me.getRef(),me,meRef);
                me.setRef(null);
                            return  meRef;
            } else {
                if (debug)
                    showDebug("ref",me.getRef(),me,null);
            }
        }
        return  me;
    }

}