Java/Hibernate using interfaces over the entities

Question

I am using annoted Hibernate, and I'm wondering whether the following is possible.

I have to set up a series of interfaces representing the objects that can be persisted, and an interface for the main database class containing several operations for persisting these objects (... an API for the database).

Below that, I have to implement these interfaces, and persist them with Hibernate.

So I'll have, for example:

public interface Data {
  public String getSomeString();
  public void setSomeString(String someString);
}

@Entity
public class HbnData implements Data, Serializable {
  @Column(name = "some_string")
  private String someString;

  public String getSomeString() {
    return this.someString;
  }
  public void setSomeString(String someString) {
    this.someString = someString;
  }
}

Now, this works fine, sort of. The trouble comes when I want nested entities. The interface of what I'd want is easy enough:

public interface HasData {
  public Data getSomeData();
  public void setSomeData(Data someData);
}

But when I implement the class, I can follow the interface, as below, and get an error from Hibernate saying it doesn't know the class "Data".

@Entity
public class HbnHasData implements HasData, Serializable {
  @OneToOne(cascade = CascadeType.ALL)
  private Data someData;

  public Data getSomeData() {
    return this.someData;
  }

  public void setSomeData(Data someData) {
    this.someData = someData;
  }
}

The simple change would be to change the type from "Data" to "HbnData", but that would obviously break the interface implementation, and thus make the abstraction impossible.

Can anyone explain to me how to implement this in a way that it will work with Hibernate?

And what's the point of using interfaces for entities? What state does an interface have that needs to be persisted? Interfaces are about behavior, not state, and I don't see why you'd like to persist an interface. — Pascal Thivent
– Pascal Thivent, Commented May 9, 2010 at 22:12
I realize this... The intention was to create an abstraction over the persistence framework, to make it possible to implement it several times, using different (or no) frameworks. The application in question has been set up absolutely modular, in a way beyond my control, and I need a way to specify which messages the database should be able to respond to, and which properties the objects have... and so: interfaces. The idea is that one could implement the interfaces, and switch modules. However, implementing the interfaces gives some trouble with Hibernate... and hence my question. — wen
– wen, Commented May 9, 2010 at 22:47
"What state does an interface have that needs to be persisted?" Anything that can be accessed via the getters and setters defined by the interface? — Greg Brown
– Greg Brown, Commented Jul 25, 2018 at 12:14

Sam Donnelly · Accepted Answer · 2010-09-29 01:23:41Z

21

Maybe OneToOne.targetEntity?:

@OneToOne(targetEntity = HbnData.class, cascade = CascadeType.ALL)
private Data someData;

answered Sep 29, 2010 at 1:23

Sam Donnelly

2482 silver badges8 bronze badges

Sign up to request clarification or add additional context in comments.

4 Comments

wen Over a year ago

Thanks, that was actually what I was looking for. ^^

Nicholas Terry Over a year ago

Same here! You are my hero!

MilacH Over a year ago

I don't see how this solve the problem, it is still limited to one type. Replace Data by HbnData is the same no ?

user177800 Over a year ago

@MilacH - that is not the reason to do this, the refactoring with this is a simple as changing the annotation, using the implementation of the interface ties you to that implementation and means changing it you have to change ALL the code that is dependant on that reference. That is the main reason to use Interfaces to being with. List is always preferable to ArrayList for the same reason.

duffymo · Accepted Answer · 2010-05-10 00:28:41Z

4

The interface that I usually use is Data Access Object, or DAO. Using Java generics, I can write it just once; Hibernate makes it possible to write the implementation just once, too:

package persistence;

import java.io.Serializable;
import java.util.List;

public interface GenericDao<T, K extends Serializable>
{
    T find(K id);
    List<T> find();
    List<T> find(T example);
    List<T> find(String queryName, String [] paramNames, Object [] bindValues);

    K save(T instance);
    void update(T instance);
    void delete(T instance);
}

answered May 10, 2010 at 0:28

duffymo

310k46 gold badges377 silver badges572 bronze badges

Collectives™ on Stack Overflow

Java/Hibernate using interfaces over the entities

2 Answers 2

4 Comments

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

4 Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Related