ObjectBox allows entity inheritance to share persisted properties in super classes. While ObjectBox always allowed entities to extend a non-entity base class, ObjectBox 1.4+ also allows extending entities. In addition to the @Entity
annotation, we introduced a @BaseEntity
annotation for base classes, which can be used instead of @Entity
.
There three types of base classes, which are defined via annotations:
No annotation: The base class and its properties are not considered for persistence.
@BaseEntity: Properties are considered for persistence in sub classes, but the base class itself cannot be persisted.
@Entity: Properties are considered for persistence in sub classes, and the base class itself is a normally persisted entity.
For example:
// base class:@BaseEntitypublic abstract class Base {@Id long id;String baseString;public Base() {}public Base(long id, String baseString) {this.id = id;this.baseString = baseString;}}// sub class:@Entitypublic class Sub extends Base {String subString;public Sub() {}public Sub(long id, String baseString, String subString) {super(id, baseString);this.subString = subString;}}
The model for Sub, Sub_, will now include all properties: id
, baseString
and subString
.
It is also possible to inherit properties from another entity:
// entities inherit properties from entities@Entitypublic class SubSub extends Sub {String subSubString;public SubSub() {}public SubSub(long id, String baseString, String subString, String subSubString) {super(id, baseString, subString);this.subSubString = subSubString;}}
It is possible to have classes in the inheritance chain that are not annotated with @BaseEntity. Their properties will be ignored and will not become part of the entity model.
It is not generally recommend to have a base entity class consisting of an ID property only. E.g. Java imposes an additional overhead to construct objects with a sub class.
Depending on your use case using interfaces may be more straightforward.
Superclasses annotated with @BaseEntity can not be part of a library.
There are no polymorphic queries (e.g. you cannot query for a base class and expect results from sub classes).
Currently any superclass, whether it is an @Entity or @BaseEntity, can not have any relations (like a ToOne or ToMany property).
// THIS WILL NOT WORK@BaseEntitypublic abstract class Base {@Id long id;ToOne<OtherEntity> other;ToMany<OtherEntity> others;}