# Jaxb und Interfaces



## Andreas29 (30. Nov 2009)

Hi,

ich habe mal eine Frage. Folgende Situation:
Ich habe zwei Interfaces:

```
public interface Interface1 {
    public Date getDatum();

    public void setDatum(Date date);
}
```

und


```
public interface Interface2 {
    public Date getDatum();

    public void setDatum(Date date);
}
```

und eine Klasse

```
public class Klasse1 implements Interface1, Interface2 {
    private Date datum;

    public Date getDatum() {
        return datum;
    }

    public void setDatum(Date datum) {
        this.datum = datum;
    }
}
```

Soweit so gut. Kann ich den Kram jetzt via JaxB irgendwie so mappen, dass ich auf den Interfaces festlege, welche Tags erststellt werden sollen? Momentan schaffe ich es nur, dass er mir das Mapping von Interface1 nimmt. Kann es sein, dass das gar nicht geht, weil er zur Laufzeit ja "nur" ein Objekt der konkreten Klasse hat und somit eigentlich nicht entscheiden kann, welches Mapping er nehmen soll? Oder gibt es da irgendwelche Interfaces / Factorys, in dem ich ihm sage: Unter der Bedingung a nimm Interface1 zum Mapping und unter Bedinung b nimm Interface2?

Dank für die Hilfe,
Andreas


----------



## Noctarius (30. Nov 2009)

Habe hier mal ein irgendwann ein KSKB gegeben gehabt: http://www.java-forum.org/soa/91114-jaxb-type-mapping.html#post576777

Das Stichwort ist JaxbAdapter


----------



## Andreas29 (1. Dez 2009)

Hi Noctarius,

erstmal danke für deine Antwort, aber ich befürchte, dass die Adapter nicht das sind, was ich suche. Soweit ich das verstanden habe, erlauben mir die Adapter den Wert, der in das XML geschrieben bzw aus dem XML gelesen wird zu editieren. Das ist aber nicht das, was ich brauche. Ich möchte irgendwie Einfluss auf den Name der generierten XML-Tags haben. Sprich, ich möchte Jaxb irgendwie sagen:
Nimm unterBedingung blah die Konfiguration von Interface1, unter Bedingung blubb aber die Konfiguration (und somit die Namen der zu erzeugenden Elemente) von Interface2.

Grüße,
Andreas


----------



## Noctarius (1. Dez 2009)

Hm so ganz verstanden was du willst hab ich nicht, sowas da?


```
wenn persistieren {
  wenn foo.valueX ist Foo
    nimm spaltenname von IFoo1
  sonst
    nimm spaltenname von IFoo2
}
```

Wenn ja, was willst du damit versuchen? Hört sich eher nach einem Designfehler an.


----------



## Andreas29 (1. Dez 2009)

Hi,

dass das ganze ein etwas schräges Design ist, sehe ich ein. Hintergrund ist folgender:
Es existiert eine sehr große Datenbanktabelle, aus der mittels Hibernate mehrere verschiedene Datentypen gelesen werden. Darauf habe ich keinen Einfluss, das muss ich so hinnehmen. Diese Datentypen sollen nun mittels JAXB nach XML geschrieben werden. Daher kam die Idee auf, für die Tabelle eine große Entity anzulegen, in der für sämtliche Spalten getter / setter existieren, die dann entsprechend auf die Datenbank gemappt werden. Die verschiedenen Datentypen sollen jetzt "nur" noch als Interfaces existieren, mit entsprechenden Zugriffsmethoden für die jeweils typspezifischen Werte. Da das XML-Mapping aber typspezifisch ist, brauchen wir an den Zugriffsmethoden auf den Interfaces ein JAXB mapping. Und momentan versuche ich herauszufinden, ob ich JAXB überhaupot sagen kann:
Mein Entity "Klasse" implementiert das Interface "Interface1". Liebes JAXB, schau mal auf dem Interface nach dem mapping und nutze alle Informationen, die du dort findest (inkl. wenn es dort für ein Feld keinen getter / setter gibt, schreibe es nicht nach XML). Das wäre im Moment erstmal Schritt 1.
Schritt 2 wäre dann:
Meine Entity "Klasse" implementiert die Interfaces "Interface1" und "Interface2". Liebes JAXB, wenn der Wert des Members "markierung" gleich X ist, dann nimm das mapping von "Interface1", wenn der Wert Y ist, nimm das mapping von "Interface2", ansonsten schmeiß eine UnsupportedOperationException().

Ist sowas möglich?

Ich hoffe, mein Ziel ist jetzt deutlicher geworden...

Grüße,
Andreas


----------



## Noctarius (1. Dez 2009)

Joar aber sowas in der Art funktioniert doch mit den Adaptern. Anstatt AlteKlasse und NeueKlasse aus dem Beispiel nimmst du einmal das Entity von Hibernate und einmal das Interface (je einmal als Eingabewert und einmal als Ausgabewert).

Die jeweiligen Adapterklassen hängst du dann über das Annotation an die Interfaces und musst halt nur entsprechende Methoden haben, welche entsprechend entscheidet als welches Interface das Ganze behandelt wird.


----------



## Noctarius (1. Dez 2009)

So da mich das jetzt auch interessiert hat habe ich mal eine Minidemonstration gebastelt. Wie du darin siehst geht es auch, aber schön ist dann definitiv was anderes.

Ein Datenobjekt mit 2 Unterdatentypen (JaxB Mapper) wäre da schöner. Ist in dem Datenobjekt ein Property null wird es eh nicht persistiert.


----------



## Andreas29 (1. Dez 2009)

Hi,

erstmal danke für deine Mühe, aber entweder verstehe ich dein Beispiel noch nicht oder es nicht nicht das was ich brauche. Mein Code sieht so aus:
Entity:

```
package de.andreasgrund.mapping.test.impl;

import javax.xml.bind.annotation.XmlRootElement;

import de.andreasgrund.mapping.test.interface1.Interface1;
import de.andreasgrund.mapping.test.interface2.Interface2;

@XmlRootElement(name = "entity")
public class Entity implements Interface1, Interface2 {

    private String nummer;

    private String datum;

    public String getNummer() {
        return nummer;
    }

    public void setNummer(String nummer) {
        this.nummer = nummer;
    }

    public String getDatum() {
        return datum;
    }

    public void setDatum(String datum) {
        this.datum = datum;
    }

}
```

Interface1:

```
package de.andreasgrund.mapping.test.interface1;

import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlType;
import javax.xml.bind.annotation.adapters.XmlJavaTypeAdapter;

import de.andreasgrund.mapping.test.impl.Interface1Adapter;

@XmlRootElement(name = "interface1")
@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "kopf", propOrder = { "nummer" })
@XmlJavaTypeAdapter(value = Interface1Adapter.class)
public interface Interface1 {

    @XmlElement(name = "nr")
    public String getNummer();

    public void setNummer(String nummer);
}
```

Interface2:

```
package de.andreasgrund.mapping.test.interface2;

import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlType;

@XmlRootElement(name = "entityroot2")
@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "kopf", propOrder = { "gennr", "gendat" })
public interface Interface2 {
    @XmlElement(name = "gennr")
    public String getNummer();

    public void setNummer(String nummer);

    @XmlElement(name = "gendat")
    public String getDatum();

    public void setDatum(String datum);
}
```
So, das möchte ich jetzt so mappen, dass ich meinetwegen im Adapter sagen kann:
Wenn Bedingung blah, dann schreibe mir ein Mapping laut Interface1, sprich nur ein subtag nummer mit dem root element interface1, ansonsten gehe laut Interface2 vor


----------



## Noctarius (1. Dez 2009)

Beide Interfaces müssen ein gemeinsames Interface erweitern und dieses basisInterface muss als Implementierung aus dem Adapter geschmissen werden.

Die wichtigen Klassen sind alle im Package jaxb definiert.

Und entsprechend in Adapter ist der Adapter.


```
interface IPerson extends IJaxbDelegate
interface IAddress extends IJaxbDelegate

JaxbDelegateImpl implements IJaxbDelegate
PersonImpl extends JaxbDelegateImpl implements IPerson
AddressImpl extends JaxbDelegateImpl implements IAddress

IPersonData extends IPerson, IAddress
PersonDataextends JaxbDelegateImpl implements IPersonData

XmlAdapter von IPersonData nach JaxbDelegateImpl
```

Da alles von JaxbDelegateImpl abgeleitet ist, kannst du es als Supertype aus dem Adapter rauswerfen und halt die passende Implementierung auswählen (je nach Bedingung PersonImpl oder AddressImpl - welche die Daten persistieren).

Die eigentliche Bedingung was geschrieben wird muss in die 2 Methoden des Adapters.


----------



## Andreas29 (2. Dez 2009)

Hi,

das klingt alles gut und sinnvoll und funktioniert auch (wie das Beispiel, das du gepostet hast demonstriert), nur leider ist es nicht das, was ich brauche. Ich habe kein AddressImpl und kein PersonImpl. Ich habe nur ein PersonDataImpl und die beiden Interfaces IAddress und IPerson. Und auf den beiden Interfaces möchte ich das mapping für JAXB unterbringen. Und um das ganze noch ein wenig schwerer zu machen: Sowohl IPerson als auch IAddress haben beide eine Methode getId(), die im Falle von IPerson als <id>1234</id> und im Falle von IAddress als <identifier>1234</identifier> geschrieben werden soll...

Grüße,
Andreas


----------



## Noctarius (2. Dez 2009)

Entweder machst du die 2 Implementierungen einfach oder du nimmst die Lösung die mir heute Nacht eingefallen ist.
Ich habe im Anhang das alte projekt überarbeitet und eine Reihe an "Conditional"-Classes eingefügt welche als Dreh und Angelpunkt den Adapter nutzt.


```
public class JaxbConditionalPersonDataAdapter extends XmlAdapter<ConditionalPersonData, IConditionalPersonData> {

	@Override
	public ConditionalPersonData marshal(IConditionalPersonData arg) throws Exception {
		if (arg.getCity() != null) {
			ConditionalPersonData impl = new ConditionalPersonData();
			
			impl.setId(arg.getId());
			impl.setStreet(arg.getStreet());
			impl.setNumber(arg.getNumber());
			impl.setZipCode(arg.getZipCode());
			impl.setCity(arg.getCity());
			
			return impl;
		} else {
			ConditionalPersonData impl = new ConditionalPersonData();
			
			impl.setId(arg.getId());
			impl.setName(arg.getName());
			impl.setSurname(arg.getSurname());
			impl.setBirthday(arg.getBirthday());
			
			return impl;
		}
	}

	@Override
	public IConditionalPersonData unmarshal(ConditionalPersonData arg) throws Exception {		
		return arg;
	}

}
```

Der komplette Source ist wieder im Anhang zu finden.


----------



## Andreas29 (2. Dez 2009)

Hi,

ich werde wohl die zwei Implementierungen machen. Dürfte wohl das einfachste vorgehen sein.

Dank dir für deine ausführliche Hilfe und deine Mühe.

Grüße,
Andreas


----------



## Noctarius (2. Dez 2009)

Wie gesagt Alternative ist eben den Adapter als Conditional Bindeglied nutzen und eine neue Instanz zurückgeben, welche nur die zu persistierenden Daten beinhaltet.

PS: Ich danke, ich hab darauf hin angefangen gerade unser firmeninternes OSGi Exporter Framework anzupassen  Wieder eine Möglichkeit mehr, die es jetzt geschickt anbindet *hehe*


----------

