JAXB can't handle interfaces

turmaline

turmaline

Bekanntes Mitglied
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
 
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?
 
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?
 
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?
 
Also so langsam komme ich durcheinander.. 🙁 Ich hab jetzt für jedes Interface zwei Adaptern:

Java: 
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

Java: 
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.


Java: 
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... 🙁
 
Zuletzt bearbeitet:
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.
 
ja aber AnnotationIml ist aus dem jar, dh ich kann sie nicht annotieren. Oder meinst Du mit AnnotationImpl die Bean-Implementierung?

Muss es nicht

Java: 
XmlAdapter <AnnotationImpl, Annotation>
heißen? Interface ist ja in diesem Fall BoundType oder
 
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.
 
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

Java: 
Map<Integer, Annotation> map;
wenn Annotation ein Interface ist, wie soll ich sowas annotieren?
 
ich weiß nicht, ob das jetzt sinnvoll war, aber ich habe folgenden Adapter für die Map geschrieben

Java: 
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..😳
 
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
 
so würdes mit Map funktionieren:

Java: 
Map<Integer, String> map = new HashMap<Integer, String>;

ich habe aber eine Map:

Java: 
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:

Java: 
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;
	}

}

Java: 
@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;
	}
	
}

Java: 
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?
 
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 😉)
 
Zuletzt bearbeitet:

Aktuelle Jobs

Neue Themen

Ähnliche Themen

JAXB can't handle interfaces
Antworten: 4
Marshaling eines JAXB Objektes worin ein anderes JAXB Objekt eingeschlossen ist
Antworten: 6
Jaxb und Interfaces
Antworten: 12
JAXB 2 und Java Annotationen/Interfaces generieren
Antworten: 3
JAXB und Interfaces
Antworten: 4

Zurück
Oben