# JAXB can't handle interfaces



## turmaline (28. Jan 2010)

Hallo Leute,

ich habe eine Klasse "Document". Diese hat verschiedene Attribute, unter anderem 

AnnotationSet aSet; // AnnotationSet ist ein Interface aus einem jar
DocumentBase docBase; // DocumentBase ist auch ein Interface

Ich möchte gerne meine Dokumente persistent in einer XML-Datei speichern und nach dem ein bießchen Einlesen heute, entschied ich mich für JAXB. Bei der Ausführung eines einfachen Testprogramms, bakam ich folgende Fehler-Meldung:

AnnotationSet is an interface, and JAXB can't handle interfaces.

Ich habe den Weg mit Annotationen verwendet, wie hier (Galileo Computing :: Java ist auch eine Insel (8. Auflage) – 15.8 Java Architecture for XML Binding (JAXB)).

Es ist ja völlig normal, dass man mit Interfaces programmiert oder? Mach ich etwas falsch oder muss ich eine andere Möglichkeit suchen, meine Dokumente zu speichern?
Bitte, so einfach wie möglich erklären, bin nicht so lange beim Programmieren.

lG,madlena


----------



## Noctarius (28. Jan 2010)

Das Stichwort ist XmlAdapter (bzw @XmlJavaTypeAdapter) von JAXB

http://www.java-forum.org/xml-co/92356-jaxb-interfaces.html#post585370
http://www.java-forum.org/xml-co/94533-jaxb-marshalling.html#post600849


----------



## turmaline (19. Feb 2010)

tolle ausführliche antwort, vielen dank


----------



## Noctarius (19. Feb 2010)

Wow den Thread hatte ich ja schon ganz vergessen


----------



## turmaline (21. Feb 2010)

leider war das ironisch gemeint.. aber ich bin selber schuld, da ich wenig informationen gegeben habe. Ich hab Dein Beispiel (JaxbTest) angeschaut. Entweder verstehe ich das falsch oder ist das nicht das was ich brauche. In meinem Fall gibt es unter anderem Interfaces, die aus einem jar benutzt werden. Ich kann da in der Implementierung nichts ändern.
Kannst Du mir da weiter helfen oder hab ich schon wieder zu wenig gesagt?


----------



## Noctarius (21. Feb 2010)

Dann nimmst du einen Adapter und baust für Xml Zwecke eine einfache Beanimplementierung des Interfaces mit den passenden JAXB Annotations. Im Adapter wechselst du dann quasi (beim speicher oder lesen) zwischen den beiden Implementierungen.

Im Prinzip wie hier: http://www.java-forum.org/xml-co/94533-jaxb-marshalling.html#post600849

Musst halt nur zwischen den beiden Implementierungen wechseln statt wie im Beispiel zwischen Token und String


----------



## turmaline (23. Feb 2010)

Du meinst zwischen der tatsächlichen impl und meiner bean?


----------



## turmaline (23. Feb 2010)

heißt das, dass ich für alle Schnittstellen eine Bean-Implementierung schreiben muss? ich meine wenn

AnnotationSet enthält mehrere Annotations und Annotation besteht aus MappingArgument und MappingValue und dabei AnnotationSet, Annotation, MappingArgument und mappingValue alles Interfaces sind, muss ich für jedes Interface eine Bean-Impl erstellen?


----------



## Noctarius (23. Feb 2010)

Japps, für jedes Interface muss ein Adapter und eine passende Implementierung des Interfaces her.


----------



## turmaline (24. Feb 2010)

Im Prinzip bräucte ich keine (eigene) Bean-Implementierung für das Interface, wenn die Implementierung nicht annotiert werden muss. Also ich könnte dann einen Adapter

public class AnnotationAdapter extends XmlAdapter <AnnotationImpl, Annotation>

wobei Annotation ein Interface ist und AnnotationImpl seine Implementierung aus jar.

Wenn ich aber die Implementierung annotieren muss und das nicht kann, da ich keinen Zugriff auf Code habe, muss ich eine Bean-Impl erstellen, diese annotieren und noch einen zusätzlichen Adapter erstellen:

public class AnnotationImplAdapter extends XmlAdapter <AnnotationBean, AnnotationImpl>

Also im Prinzip brauche ich dann zwei Adapter. Hab ich richtig verstanden? Stimmt die Richtung bei Adaptern?


----------



## turmaline (24. Feb 2010)

Also so langsam komme ich durcheinander..  Ich hab jetzt für jedes Interface zwei Adaptern:


```
public class MappingAdapter extends XmlAdapter <MappingImpl, Mapping> 
{
	@Override
	public MappingImpl marshal(Mapping mapping) throws Exception 
	{
		MappingImpl mImpl = new MappingImpl ();
		mImpl.setMappingArgument(mapping.getMappingArgument());
		mImpl.setMappingValue(mapping.getMappingValue());
		
		return mImpl;
	}

	@Override
	public Mapping unmarshal(MappingImpl mImpl) throws Exception 
	{
		return mImpl;
	}
	
}
```

und


```
public class MappingImplAdapter extends XmlAdapter <MappingBean, MappingImpl> 
{

	@Override
	public MappingBean marshal(MappingImpl mImpl) throws Exception 
	{
		MappingBean mBean = new MappingBean ();
		mBean.setMappingArgument(mImpl.getMappingArgument());
		mBean.setMappingValue(mImpl.getMappingValue());
		return mBean;
	}

	@Override
	public MappingImpl unmarshal(MappingBean mBean) throws Exception 
	{
		MappingImpl mImpl = new MappingImpl ();
		mImpl.setMappingArgument(mBean.getMappingArgument());
		mImpl.setMappingValue(mBean.getMappingValue());
		return mImpl;
	}

}
```

Nun weiß ich nicht wo ich welchen Adapter einsetzen muss.



```
public class AnnotationBean implements Annotation 
{
	private int id;
	@XmlJavaTypeAdapter(MappingAdapter.class)
	private Mapping mapping;
	
	public int getId() 
	{
		return this.id;
	}
	
	public void setId(int id) 
	{
	   this.id = id; 		
	}

	public Mapping getMapping() 
	{
		return this.mapping;
	}

	public void setMapping(Mapping mapping) 
	{
	   this.mapping = mapping;
	}

}
```

Oder muss im letzten Code-Teil stehen:

@XmlJavaTypeAdapter(MappingImplAdapter.class)
MappingBean mappinBean;

In diesem Fall stimmt die Implementierung von setters / getters nicht mehr... Oder soll AnnotationBean nicht implements Annotation...

Also wie Du siehst bin ich völlig verwirrt...


----------



## Noctarius (24. Feb 2010)

Nee kannst das Ganze mit einem Adapter abhandeln. Musst ja nur eine Interface-Implementierung rausgeben. Welche das ist, spielt keine Rolle.

[c]XmlAdapter <Annotation, AnnotationImpl>[/c] würde also reichen.


----------



## turmaline (24. Feb 2010)

ja aber AnnotationIml ist aus dem jar, dh ich kann sie nicht annotieren. Oder meinst Du mit AnnotationImpl die Bean-Implementierung?

Muss es nicht 


```
XmlAdapter <AnnotationImpl, Annotation>
```
 heißen? Interface ist ja in diesem Fall BoundType oder


----------



## Noctarius (24. Feb 2010)

Ja war jetzt nur Beispiel 

Wie du beim marshall und unmarshall die Sachen verpackst ist aber deine Sache, da das Bean ja zwangsweise dann auch eine Interface-Definition ist kannst du dieses einfach rein- bzw rauswerfen.


----------



## turmaline (25. Feb 2010)

ja  mit Anfängern sind solche Beispiele gefährlich 

jetzt habe ich ein Haufen Adaptern geschrieben und anscheinend sie falsch eingesetzt.
Also eine Map ist auch ein Interface, dafür brauche ich auch einen Adapter?

und was mache ich mit


```
Map<Integer, Annotation> map;
```
 wenn Annotation ein Interface ist, wie soll ich sowas annotieren?


----------



## turmaline (25. Feb 2010)

also für die Map soll ich auch einen Adapter schreiben oder?


----------



## turmaline (25. Feb 2010)

ich weiß nicht, ob das jetzt sinnvoll war, aber ich habe folgenden Adapter für die Map geschrieben


```
XmlAdapter <HashMap <Integer, AnnotationBean>, Map<>Integer, Annotation>
```

im Adapter habe ich die map vor der rückgabe ausgegeben und sie war nicht leer, beim marshalling aber schon-- hab ich jetzt quatsch gemacht oder woran liegt es?..

sorry für die dummen fragen..


----------



## Noctarius (25. Feb 2010)

Maps müsste JAXB von Haus aus kennen, kann mich aber grad nicht erinnern, da ich jetzt nicht wüsste, dass ich die daten schonmal in ner map weggespeichert hab


----------



## turmaline (25. Feb 2010)

so würdes mit Map funktionieren:


```
Map<Integer, String> map = new HashMap<Integer, String>;
```

ich habe aber eine Map:


```
Map<Integer, Annotation> map = new HashMap <Integer, Annotation> () ;
```

und Annotation ist ein Interface. Da bekomme ich einen Fehler. Deswegen habe ich einen Adapter geschrieben. Fehler ist verschwunden aber map ist leer... ((

ao sieht jetzt der Test-Adapter aus:


```
public class DingerMapAdapter extends XmlAdapter <HashMap <Integer, Ding>, Map <Integer, IDing>> 
{

	@Override
	public HashMap<Integer, Ding> marshal(Map<Integer, IDing> map)
			throws Exception 
	{
		HashMap<Integer, Ding> hm = new HashMap<Integer, Ding> ();
		for (Map.Entry<Integer, IDing> entry : map.entrySet())
		{
			Ding d = new Ding ();
			d.setID(entry.getValue().getID());
			hm.put(entry.getKey(), d);
			
		}
		
		System.out.println (hm);
		return hm;
	}

	@Override
	public Map<Integer, IDing> unmarshal(HashMap<Integer, Ding> hm)
			throws Exception 
	{
		Map<Integer, IDing> map = new HashMap <Integer, IDing> ();
		for (Map.Entry<Integer, Ding> entry : hm.entrySet())
		{
			IDing i = new Ding ();
			i.setID(entry.getValue().getID());
			map.put(entry.getKey(), i);
		}
		return map;
	}

}
```


```
@XmlRootElement (namespace = "...")
public class Document 
{
	private Map <Integer, IDing> dingerMap = new HashMap <Integer, IDing> ();
	
	public void setDingerMap (Map<Integer, IDing> dingerMap)
	{
		this.dingerMap = dingerMap;
	}
	
	@XmlJavaTypeAdapter (DingerMapAdapter.class)
	public Map<Integer, IDing> getDingerMap ()
	{
		return this.dingerMap;
	}
	
}
```


```
public class XMLBinding 
{

	/**
	 * @param args
	 * @throws IOException 
	 */
	public static void main(String[] args) throws IOException 
	{
		
		
		try 
		{
			Map<Integer, IDing> dingerMap = new HashMap <Integer, IDing> ();
			IDing dingA = new Ding (); dingA.setID(33);
			dingerMap.put(55, dingA);
			IDing dingB = new Ding (); dingB.setID(44);
			dingerMap.put(66, dingB);
			
			Document doc = new Document ();
		
			doc.setID("id1");
			doc.setDingerMap(dingerMap);
			
			Writer w = null;
			w = new FileWriter ("document.xml");
			
			JAXBContext context = JAXBContext.newInstance(Document.class);
			Marshaller m = context.createMarshaller();
			m.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, Boolean.TRUE);
		        m.marshal(doc, w);
			
			m.marshal(doc, System.out);
			
			
			Unmarshaller um = context.createUnmarshaller();
			Document doc2 = (Document) um.unmarshal(new FileReader ("document.xml"));
			System.out.println(doc2.getID());
			System.out.println(doc2.getDingerMap());
		} 
		catch (JAXBException e) 
		{
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

	}

}
```

Hast Du eine Ahnung warum ist die Map beim Marshalling leer?


----------



## plattfuss (3. Mrz 2010)

Noctarius hat gesagt.:


> Japps, für jedes Interface muss ein Adapter und eine passende Implementierung des Interfaces her.



Gibts da nicht ne generische Lösung? Ich muss das leider für ein Package machen, das bald 200 Interfaces hat, die dann noch jeweils 10-20 getter aufweisen.


----------



## Noctarius (3. Mrz 2010)

Klar kannst du das bestimmt generisch über Object, Object machen. Musst dann halt nur mit Reflection und den BeanUtils spielen (und am besten mit einer PropertyDescription).

(Btw: ein nettes kleines Projekt, dem sollte ich mich mal zuwenden )


----------

