JOINED strategy not sufficient?

[Tim Storms]

Hi ranchers,

I'm struggeling with a mapping strategy for a couple of entities. Note that I'm using JPA 2.0 and Hibernate 3.5.6. The application serves as a learing app for this frameworks. This is the scenario I've implemented:

- a person can be an actor or a director
- both of the previous types can participate in one or multiple (different) movies
- a movie can include one or multiple actors and one or more directors
- and what's giving me a headache: an actor and a director can be one and the same person!

This is what my mapping is looking like:

@MappedSuperclass
public abstract class BaseEntity {
    /** The maximum {@link String} size. */
    protected static final int MAX_SIZE = 50;

    /** The minimum {@link String} size. */
    protected static final int MIN_SIZE = 1;

    /** The date pattern. */
    protected static final String DATE_PATTERN = "dd/MM/yyyy";

    /** The entity identifier. */
    @Id
    @Column(name = "ID")
    @GeneratedValue(strategy = GenerationType.AUTO)
    private Long id;
}

@Entity
@Inheritance(strategy = InheritanceType.JOINED)
public abstract class Person extends BaseEntity {
    /** The first name. */
    @Column(name = "FIRST_NAME", nullable = false, length = MAX_SIZE)
    @NotNull
    @Size(min = MIN_SIZE, max = MAX_SIZE)
    private String firstName;

    /** The last name. */
    @Column(name = "LAST_NAME", nullable = false, length = MAX_SIZE)
    @NotNull
    @Size(min = MIN_SIZE, max = MAX_SIZE)
    private String lastName;

    /** The birth date. */
    @Column(name = "BIRTH_DATE")
    @Temporal(TemporalType.DATE)
    @DateTimeFormat(pattern = DATE_PATTERN)
    private Date birthDate;

    /** The nationality. */
    @Column(name = "NATIONALITY")
    @Enumerated(EnumType.ORDINAL)
    private Nationality nationality;
}

@Entity
@Table(name = "ACTOR")
public final class Actor extends Person {
    /** The movies the actor appeared in. */
    @ManyToMany(mappedBy = "actors")
    private Set < Movie > movies;
}

@Entity
@Table(name = "DIRECTOR")
public final class Director extends Person {
    /** The movies the director has directed. */
    @ManyToMany(mappedBy = "directors")
    private Set < Movie > movies;
}

@Entity
@Table(name = "MOVIE")
public class Movie extends BaseEntity {
    /** The movie title. */
    @Column(name = "TITLE", nullable = false, length = MAX_SIZE)
    @NotNull
    @Size(min = MIN_SIZE, max = MAX_SIZE)
    private String title;

    /** The director(s). */
    @ManyToMany(cascade = {
            CascadeType.PERSIST, CascadeType.MERGE, CascadeType.REFRESH})
    @JoinTable(name = "MOVIE_DIRECTOR", joinColumns = {
        @JoinColumn(name = "MOVIE_ID")}, inverseJoinColumns = {
        @JoinColumn(name = "DIRECTOR_ID")})
    private Set < Person > directors;

    /** The actors. */
    @ManyToMany(cascade = {
            CascadeType.PERSIST, CascadeType.MERGE, CascadeType.REFRESH})
    @JoinTable(name = "MOVIE_ACTOR", joinColumns = {
        @JoinColumn(name = "MOVIE_ID")}, inverseJoinColumns = {
        @JoinColumn(name = "ACTOR_ID")})
    private Set < Person > actors;

    /** The movie genre. */
    @ElementCollection
    @CollectionTable(name = "MOVIE_GENRE", joinColumns = @JoinColumn(name = "ID"))
    @Column(name = "GENRE", nullable = false)
    @Enumerated(EnumType.ORDINAL)
    private Set < Genre > genres;
}

I've not included the getters and setters, plus the builder classes to easily create a director or an actor. Just for now, suppose I've created an actor like this:

Actor actor = new Actor("abc","def",new Date("02/02/2000"),Nationality.AMERICAN);

As this is the first entity to be saved, an identifier with value 1 will be generated. Now here comes the part I'm struggling with. This actor should also be known as an director of several other movies. The (dirty) solution I was thinking about, was to copy all the values of the actor into the director, including the identifer. But because the identifier is auto generated when an entity is persisted, the given identifier will be overridden by a new generated id. Thus the director and the actor are two different persons in the database. Does anyone know a clean sollution for this? Should I map my entities differently? Should I choose another id generation strategy? Thanks for sharing your thoughts!

[Ran Pleasant]

Tim

I think the problem is in the inheritance from Person. Director and Actor are not types of Person, rather they are roles that a person can fulfill. A solution would be to create an abstract class named Role and define both Director and Actor as subclasses of Role. The Person class would then have a list of Roles that they fulfill.

Ran Pleasant

[Tim Storms]

Hi Ran,

Thanks for your reply. You object structure suggestion seems to be better than mine. I've quickly created the new model classes. This is what they look like:

@Entity
@Inheritance(strategy = InheritanceType.JOINED)
public abstract class Role extends BaseEntity {
    @ManyToOne
    private Person person;
}

@Entity
public class Actor extends Role {
    @ManyToMany(mappedBy = "actors")
    private Set < Movie > movies;
}

@Entity
public class Director extends Role {
    @ManyToMany(mappedBy = "directors")
    private Set < Movie > movies;
}

@Entity
public class Person extends BaseEntity {
    private String lastName;

    private String firstName;

    private Date birthDate;

    private Nationality nationality;

    @OneToMany(mappedBy = "person")
    private Set < Role > roles;
}

@Entity
public class Movie extends BaseEntity {
    private String title;

    @ManyToMany
    @JoinTable(name = "MOVIE_DIRECTOR", joinColumns = {
        @JoinColumn(name = "MOVIE_ID")}, inverseJoinColumns = {
        @JoinColumn(name = "DIRECTOR_ID")})
    private Set < Director > directors;

    @ManyToMany
    @JoinTable(name = "MOVIE_ACTOR", joinColumns = {
        @JoinColumn(name = "MOVIE_ID")}, inverseJoinColumns = {
        @JoinColumn(name = "ACTOR_ID")})
    private Set < Actor > actors;
}

The attachment contains the generated database schema.
Do you still see some improvements, or is it fine as it is?