Exit the Roo shell and delete the contents of the C: oo-cookbookch03-recipes directory.

Start the Roo shell from the C: oo-cookbookch03-recipes directory.

Execute the ch03_jpa_setup.roo script which creates the flight-app Roo project, sets up Hibernate as persistence provider, and configures MySQL as the database for the application. If you are using a different database than MySQL or your connection settings are different than what is specified in the script, then modify the script accordingly.

To create an entity which inherits a mapped superclass, follow the given steps:

The mappedSuperclass argument of the entity command is responsible for creating a mapped superclass. It's a flag type argument; if present, it indicates that the generated class must be annotated with the @MappedSuperclass JPA annotation. The following code shows the relevant annotations of the AuditFields mapped superclass, as generated by the entity command:

@RooJavaBean
@RooToString
@RooEntity(mappedSuperclass = true)
public class AuditFields {..}

As shown in this code, the AuditFields class is annotated with the @RooEntity annotation. As we saw earlier, the @RooEntity annotation triggers Roo to generate a *_Roo_Entity.aj AspectJ ITD file corresponding to the AuditFields class. The mappedSuperclass attribute of the @RooEntity annotation instructs Roo to add a declaration in the corresponding *_Roo_Entity.aj that annotates the AuditFields class with the @MappedSuperclass annotation (instead of the @Entity JPA annotation).

When an entity class extends a mapped superclass, the Roo generates a *_Roo_Entity.aj Aspect ITD file corresponding to the mapped superclass and defines an identifier field (annotated with @Id JPA annotation), along with methods such as persist, merge, refresh, and so on. (that we saw in the Creating persistent entities recipe of Chapter 2). In this case, the inheriting entity's *_Roo_Entity.aj file only defines the static count and finder methods for the entity.

The following code listing shows the AuditFields_Roo_Entity.aj file:

privileged aspect AuditFields_Roo_Entity
{
   declare @type: AuditFields: @MappedSuperclass;

   @PersistenceContext
   transient EntityManager AuditFields.entityManager;
   @Id
   @GeneratedValue(strategy = GenerationType.AUTO)
   @Column(name = "id")
    private Long AuditFields.id;
    
   @Version
   @Column(name = "version")
   private Integer AuditFields.version;
   @Transactional
   public void AuditFields.persist()
   {
      if (this.entityManager == null) 
        this.entityManager = entityManager();
      this.entityManager.persist(this);
}
    
   @Transactional
   public void AuditFields.remove() {...}

    public static final EntityManager 
             AuditFields.entityManager() {...}
   ...
}

The given code shows that the AuditFields_Roo_Entity.aj ITD annotates the AuditFields class with the @MappedSuperclass annotation. Also, notice that the ITD doesn't annotate the AuditFields class with @Entity and @Table annotation. This code shows that the *_Roo_Entity.aj ITD of a mapped superclass is the same as that of an entity—consisting of identifier and version definitions, persist, remove, and so on methods, and a method to obtain the JPA EntityManager instance.

As the Flight entity inherits from the AuditFields class, Roo generates a Flight_Roo_Entity.aj ITD that doesn't contain identifier and version definitions or persistence methods for persisting, refreshing, and merging the

Flight entity, as shown in the following code listing:

privileged aspect Flight_Roo_Entity
{
   declare @type: Flight: @Entity;
   declare @type: Flight: @Table(name = "FLIGHT_TBL");
   public static long Flight.countFlights() {..}
   public static List<Flight> Flight.findAllFlights(){..}
   public static Flight Flight.findFlight(Long id) {..}
   public static List<Flight> Flight.findFlightEntries(
      int firstResult, int maxResults) {..}
}

The given code shows that the Flight entity contains only the find and count methods and inherits the identity, version definitions, and persistence related methods from the AuditFields mapped superclass. As in the case of any other JPA entity, the ITD annotates the Flight class with the @Entity and the @Table annotations.

Even though the mapped superclass contains the identifier definition, you can override it in the inheriting entity by using @AttributeOverride or @AttributeOverrides JPA annotation. The following code shows how the Flight entity can override the identifier definition in the AuditFields class to map the identifier field to the FLT_ID column of FLIGHT_TBL table:

@RooJavaBean
@RooToString
@RooEntity(table="FLIGHT_TBL")
@AttributeOverride(name="id", column=@Column(name="FLT_ID"))
public class Flight extends AuditFields {..}

@RooJavaBean
@RooToString
@Embeddable
public class AuditFields
{
   @Temporal(TemporalType.TIMESTAMP)
   @DateTimeFormat(style = "S-")
   private Date createdDate;

   @Temporal(TemporalType.TIMESTAMP)
   @DateTimeFormat(style = "S-")
   private Date modifiedDate;

   private String createdBy;

   private String modifiedBy;
}

@RooJavaBean
@RooToString
@RooEntity(table = "FLIGHT_TBL")
public class Flight
{
...
   @Embedded
   private AuditFields auditFields;
}

@Embedded
@AttributeOverrides({
  @AttributeOverride(name="createdDate",
    column=@Column(name="C_DATE")),
  @AttributeOverride(name="modifiedDate", 
    column=@Column(name="M_DATE"))
})
private AuditFields auditFields;