# Hibernate Mapping für Interface



## Guest (2. Jan 2008)

Hallo zuammen!

Ich verwende zum ersten mal Hibernate und stehe schon vor einem (für mich) unlösbarem Problem.
Ich möchte ein Objekt in die DB speichern. An sich kein problem allerdings programmiere ich gegen Interfaces,
hier mein Code beim speichern:



```
IRepositoryData data = null;

...

Session session = sessionFactory.openSession();
Transaction tx = session.beginTransaction();
session.save(data);
tx.commit();
session.close();
```


Ich frage mich nun wie die Mapping-Datei für IRepositoryData aussehen muss. Es muss doch möglich sein die get/set Methoden in den konkreten Klassen zu haben, ohne sich das Interface zu versauen, oder?
Werden Interfaces in den Mapping Dateien wie Abstrakte klassen behandelt? Muss man hier mit dem <subclass> tag arbeiten? 

Grüße!


----------



## Guest (2. Jan 2008)

Das geht nicht. Der Grund ist ganz simpel. Allein schon für die @Column Annotationen benötigst du entweder 
Getter (und Setter) oder die entsprechenden Membervariablen.
Auch wenn du die Mapping-Datei von Hand schreibst, muss es eine konkrete Klasse sein, kein Interface.

Mögliche Lösung: Trennung der ORM-Schicht vom Rest des Codes.

Die Entitites (Klassen) sind nur in der DAO Schicht bekannt. Nach Aussen hast du Schnittstellen, die Interafaces erwarten.
Das Mapping von/zu den Pojos musst du aber selbst schreiben.

z.B.
	
	
	
	





```
IPerson save(IPerson p) throws DAOException {
   Person person = map2Orm(p); // Das gegebene Objekt in Pojo konvertieren.
   ...
   Session session = null;
   Transaction tx = null;

   try {
      session = sessionFactory.openSession();
      tx = session.beginTransaction();
      session.save(person);
      tx.commit();
   }
   catch(PersistenceException e) {
      Logger.log(e);
      throw new DAOException(e);
      if( tx != null ) {
         tx.rollback();
      }
   }
   finally {
      if( session != null ) {
         session.close();
      }
   }
   
   return map2Dao(person); // Konvertiert das Pojo in irgendwas öffentliches, was IPerson implementiert.
}
```


----------



## Guest (2. Jan 2008)

Ätch, kleine Korrektur.  :autsch: Du arbeitest mit Hibernate direkt, nicht mit JPA.  :wink: 
	
	
	
	





```
IPerson save(IPerson p) throws DAOException {
   Person person = map2Orm(p); // Das gegebene Objekt in Pojo konvertieren.
   ...
   Session session = null;
   Transaction tx = null;
   boolean commit = false;

   try {
      session = sessionFactory.openSession();
      tx = session.beginTransaction();
      session.save(person);
      session.flush();
      commit = true;
   }
   catch(HibernateException e) {
      Logger.log(e);
      throw new DAOException(e);
   }
   finally {
      if( tx != null ) {
         try {
            if( commit ) {
               tx.commit();
            }
            else {
               tx.rollback();
            }
         }
         catch(HibernateException e) {
            Logger.log(e);
            throw new DAOException(e);
         }
      }
      if( session != null ) {
         session.close();
      }
   }

   return map2Dao(person); // Konvertiert das Pojo in irgendwas öffentliches, was IPerson implementiert.
}
```


----------



## Gast (3. Jan 2008)

Danke für deine Antwort!

Habe jetzt die Annotationen an den Konkreten Klassen, wobei ich bei Properties die eine Liste von Interface-Objekten zurückgeben, 
"target=" verwendet habe.


```
@OneToMany(targetEntity=Transaction.class)
@JoinColumn(name="importdata_id")
@OrderBy(value="transactionNumber")
@Override
public List<ITransaction> getTransactions() {
	return transactions;
}
```


----------

