具有Hibernate批注的多态映射

Question

I am hoping that someone will be kind enough to provide some advice as to how to best approach the following problem.

I am trying to use Hibernate with annotations to create a common library of mapped superclasses, which can be used from client applications by extending the common entities. The names of database tables used by all client applications are the same, although application-specific columns might be present in addition to the common columns mapped in the common mappings.

Here's an example. 5 different applications all share common UserLogon code. So, in the common library the class might look like this:

@Entity
@Table(name="DRY_USER_LOGON")
@Inheritance(strategy=InheritanceType.SINGLE_TABLE)
@DiscriminatorFormula("666") // A trick - any subclass mapped with @DiscriminatorValue("666") found on the classpath will be used!
public abstract class CommonUserLogon  {
    @Id
    @Column(name = "USER_LOGON_OID")
    Long oid;

    @Column(name = "USER_LOGON_NAME")
    String userLogonName;

    @OneToOne(mappedBy="userLogon")
    CommonUserProfile userProfile;

    ... etc ...
}

@Entity
@Table(name="DRY_USER_PROFILE")
@Inheritance(strategy=InheritanceType.SINGLE_TABLE)
@DiscriminatorFormula("666") // A trick - any subclass mapped with @DiscriminatorValue("666") found on the classpath will be used!
public abstract class CommonUserProfile {
    @Id
    @Column(name = "USER_PROFILE_OID")
    Long oid;

    // Hibernate will use the subclass that matches the discriminator at runtime, which is great
    @ManyToOne
    @JoinColumn(name = "USER_LOGON_OID")
    CommonUserLogon userLogon;

    ... etc ...
}

This approach works very well. All I have to do in my client applications is something like:

@Entity
@DiscriminatorValue("666") // Has to match @DiscriminatorFormula in superclass
public class UserLogon extends CommonUserLogon {

    @OneToMany(mappedBy="userLogon")
    Set <ClientSpecificStuff> clientExtensions;

    .. etc ..

}

@Entity
@DiscriminatorValue("666") // Has to match @DiscriminatorFormula in superclass
public class UserProfile extends CommonUserProfile {

    /**
     * @return Cast to program-specific UserLogon
     */
    public UserLogon getUserLogon() {
        (UserLogon)super.getUserLogon();
    }

    @Column(name = "APP_SPECIFIC_COL1")
    String appSpecificThing;

    ... etc ...
}

I like this approach b/c I was able to re-use all common mapping, and I did not have to repeat myself anywhere.

Now for the problem. Let's say that I want to create another common component, which adds something to CommonUserLogon .

// ????? - How to map this?
public abstract class CommonUserLogonWithDigitalSignature extends CommonUserLogon {

    @OneToMany(mappedBy="userLogon")
    List<UserKeyPair> userKeyPairs;

    ... etc ...
}

@Entity
@Table(name="DRY_USER_SECURITY_KEY")
public class UserKeyPair {
    @Id
    @Column(name = "USER_SECURITY_KEY_OID")
    Long oid;

    @ManyToOne
    @JoinColumn(name = "USER_LOGON_OID", nullable = false)
    CommonUserLogonWithDigitalSignature userLogon;

    ... etc ...

}

Now that we have more than one level of subclasses, the DiscriminatorFormula approach is not so convenient anymore, b/c it gets difficult to control which specific subclasses get loaded at runtime. It still works in principle if there is EXACTLY one subclass with @DiscriminatorValue("666") on the classpath, but that is not easy to do during testing, where we might want to test both, CommonUserLogonWithDigitalSignature and CommonUserLogon subclasses.

So at this point I wanted to stop and make sure that I am actually on the right track, or maybe there is a better way to do what I described?

Any advice would be greatly appreciated.

Answer 1

Decided to continue with the demonstrated paradigm, and it worked out really well.

The only thing I had to do was change the DiscriminatorFormula values from hard-coded numbers to database-configured values. The idea is that client applications will have to tell hibernate which common mappings should be used by storing a value in a dedicated single-column table.

This turned out to be a good approach for testing too, b/c tests can update that table before running, thus getting access to any of the available configurations.

So the hierarchy looks like this now:

@Entity
@DiscriminatorValue("USER_LOGON_WITH_SIGNATURES")
public class Client1UserLogon extends CommonUserLogonWithDigitalKeys {

    @OneToMany(mappedBy="userLogon")
    Set <ClientSpecificStuff> clientExtensions1;

}

@Entity
@DiscriminatorValue("USER_LOGON_BASIC")
public class Client2UserLogon extends CommonUserLogon {

    @OneToMany(mappedBy="userLogon")
    Set <ClientSpecificStuff> clientExtensions2;

}

@Entity
public abstract class CommonUserLogonWithDigitalKeys extends CommonUserLogon {

    @OneToMany(mappedBy="userLogon")
    List<UserKeyPair> userKeyPairs = [];

    ... etc ...
}

@Entity
@Table(name="DRY_USER_LOGON")
@Inheritance(strategy=InheritanceType.SINGLE_TABLE)
@DiscriminatorFormula("(select humm.MAP_MODE from DRY_HIBERNATE_USER_MAP_MODE humm)) 
public abstract class CommonUserLogon  {
    @Id
    @Column(name = "USER_LOGON_OID")
    Long oid;

    @Column(name = "USER_LOGON_NAME")
    String userLogonName;

    @OneToOne(mappedBy="userLogon")
    CommonUserProfile userProfile;

    ... etc ...
}

@Entity
@Table(name="DRY_USER_PROFILE")
@Inheritance(strategy=InheritanceType.SINGLE_TABLE)
@DiscriminatorFormula("(select humm.MAP_MODE from DRY_HIBERNATE_USER_MAP_MODE humm))
public abstract class CommonUserProfile {
    @Id
    @Column(name = "USER_PROFILE_OID")
    Long oid;

    // Hibernate will use the subclass that matches the discriminator at runtime, which is great
    @ManyToOne
    @JoinColumn(name = "USER_LOGON_OID")
    CommonUserLogon userLogon;

    ... etc ...
}

@Entity
@DiscriminatorValue("USER_LOGON_WITH_SIGNATURES")
public class UserProfileWithDigitalKeys extends CommonUserProfile {

    public UserLogonWithSignature getUserLogon() {
        (UserLogonWithSignature)super.getUserLogon();
    }

    public UserProfileWithDigitalKeys() {
        userLogon = new UserLogonWithSignature();
    }

}

@Entity
@DiscriminatorValue("USER_LOGON_BASIC")
public class UserProfile extends CommonUserProfile {

    public UserLogon getUserLogon() {
        (UserLogon)super.getUserLogon();
    }

    public UserProfile() {
        userLogon = new UserLogon();
    }

}

All the client applications need to do now is subclass the correct common superclass, and set the corresponding value in DRY_HIBERNATE_USER_MAP_MODE.MAP_MODE column.