Storing Objects in columns using Hibernate JPA

Question

Is it possible to store something like the following using only one table? Right now, what hibernate will do is create two tables, one for Families and one for people. I would like for the familymembers object to be serialized into the column in the database.

@Entity(name = "family")
class Family{

    private final List<Person> familyMembers;

}

class Person{

   String firstName, lastName;
   int age;

}

Answer 1

You can create pseudoproperty (getter and setter) which accepts/returns the serialized form, and annotate the familyMembers with @Transient. This would also need to annotate the getters, not fields, for all other properties.

Answer 2

Annotate the property with @Column and define the type to be ArrayList, not just List. And make Person implement Serializable.

But you should do this only if your motives are very clear, because this is the correct solution in some very rare cases. As Pascal noted, if you ever have to change Person you'll have headaches.

Answer 3

This is an horrible design and I'm really not recommending it (you should just create another table) but it is possible.

First, you'll need to use a byte[] attribute to hold a serialized version of the list of persons that will be stored in a BLOB in the database. So annotate it's getter with @Lob (I would make the getter and setter private to not expose them). Then, expose "fake" getter and setter to return or set a List<Person> from the byte[]. I'm using SerializationUtils from Commons Lang in the sample below (provide you own helper class if you don't want to import this library) to serialize/deserialize on the fly to/from the byte[]. Don't forget to mark the "fake" getter with @Transcient or Hibernate will try to create a field (and fail because it won't be able to determine the type for a List).

@Entity(name = "family")
class Family implements Serializable {

    // ...

    private byte[] familyMembersAsByteArray;

    public Family() {}

    @Lob
    @Column(name = "members", length = Integer.MAX_VALUE - 1)
    private byte[] getFamilyMembersAsByteArray() { // not exposed
        return familyMembersAsByteArray;
    }

    private void setFamilyMembersAsByteArray((byte[] familyMembersAsByteArray() { // not exposed
        this.familyMembersAsByteArray = familyMembersAsByteArray;
    }

    @Transient
    public List<Person> getFamilyMembers() {
        return (List<Person>) SerializationUtils.deserialize(familyMembersAsByteArray);
    }

    public void setParticipants(List familyMembers) {
        this.familyMembersAsByteArray = SerializationUtils.serialize((Serializable) familyMembers);
    }
}

Don't forget to make the Person class Serializable and to add a real serialVersionUID (I'm just showing a default here):

public class Person implements Serializable {

   private static final long serialVersionUID = 1L;

   // ...

   private String firstName, lastName;
   private int age;

}

But, let me insist, this is an horrible design and it will be very fragile (changing Person might require to "migrate" the content of the BLOB to avoid deserialization issues and this will become painful. You should really reconsider this idea and use another table for the Person instead (or I don't get why you use a database).

Answer 4

@Type(type = "serializable")
private List<Person> familyMembers;

if you can't use hibernate annotations try this:

@Lob
private Serializable familyMembers;

public List<Person> getFamilyMembers(){
    return (List) familyMembers;
}

public void setFamilyMembers(List<Person> family){
    familyMembers = family;
}

Answer 5

Thank you everyone for your answers.

I guess I should have stated why I wanted to avoid the additional table being created. For each type of object we are storing in the DB, we create a ClientRepositoryJPA class which acts as the DAO for that type of model.

I don't want to have to create a PersonRepositoryJPA just to handle this one little object type which is never used individually -- it is just a part of a larger object.