Laten we zeggen dat ik de volgende POJO heb:
public class MyThing {
private int myNumber;
private String myData;
//assume getter/setter methods
}
Is het nu mogelijk om deze POJO uit te breiden als een JPA-entiteit?
@Entity
@Table(name = "my_thing")
public class MyThingEntity extends MyThing implements Serializable {
@Column(name = "my_number")
//?????????
@Column(name = "my_data")
//????????
}
Ik wil de POJO gescheiden houden van de JPA-entiteit. De POJO leeft in een ander project en wordt vaak gebruikt zonder een persistentielaag, mijn project wil het in een database bewaren en dit doen zonder de overhead van het in kaart brengen van een POJO naar een entiteit en terug.
Ik begrijp dat JPA-entiteiten POJO’s zijn, maar om het te gebruiken zou ik een bibliotheek moeten opnemen die javax.persistence implementeert en de andere projecten die hetzelfde basisobject gebruiken, hebben geen gebruik voor een persistentielaag.
Is dit mogelijk? Is dit een goed idee?
Antwoord 1, autoriteit 100%
Staten van de JPA-specificatie
Entiteiten kunnen zowel niet-entiteitsklassen als entiteitsklassen uitbreiden, en niet-entiteitsklassen kunnen entiteitsklassen uitbreiden.
@javax.persistence.MappedSuperclass annotatie stelt u in staat om dit soort mapping te definiëren
@MappedSuperclass
public class MyThing implements Serializable {
private int myNumber;
private String myData;
// getter's and setter's
}
En
@Entity
@Table(name="MY_THING")
public class MyThingEntity extends MyThing {
}
Zoals gezegd door de JPA-specificatie
De MappedSuperclass-annotatie duidt een klasse aan waarvan de toewijzingsinformatie wordt toegepast op de entiteiten die ervan overerven.
En
Een klasse die is aangeduid met de annotatie MappedSuperclass kan op dezelfde manier worden toegewezen als een entiteit, behalve dat de toewijzingen alleen van toepassing zijn op zijn subklassenaangezien er geen tabel bestaat voor de toegewezen superklasse zelf.
>
Als u een eigenschap gedefinieerd door MyThing moet overschrijven, gebruik dan @AttributeOverride (wanneer u een enkele eigenschap wilt overschrijven) of @AttributeOverrides (wanneer u meer dan één eigenschap wilt overschrijven)
@Entity
@Table(name="MY_THING")
@AttributeOverride(name="myData", column=@Column(name="MY_DATA"))
public class MyThingEntity extends MyThing {
}
En
@Entity
@Table(name="MY_OTHER_THING")
@AttributeOverrides({
@AttributeOverride(name="myData1", column=@Column(name="MY_DATA_1")),
@AttributeOverride(name="myData2", column=@Column(name="MY_DATA_2"))
})
public class MyOtherThingEntity extends MyThing {
}
Als u uw basisklasse niet wilt wijzigen, kunt u xml gebruiken om deze te definiëren als een @MappedSuperClass
Let op: standaard zoekt de persistentieprovider in de META-INF-directory naar een bestand met de naam orm.xml
<?xml version="1.0" encoding="UTF-8"?>
<entity-mappings xmlns="http://java.sun.com/xml/ns/persistence/orm" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/persistence/orm http://java.sun.com/xml/ns/persistence/orm_1_0.xsd" version="1.0">
<mapped-superclass class="MyThing">
</mapped-superclass>
</entity-mappings>
Niets anders. Als u een eigenschap wilt overschrijven, gebruikt u @AttributeOverride zoals hierboven weergegeven
Antwoord 2, autoriteit 8%
Het is mogelijk:
- je kunt het toewijzen met XML – maak een
orm.xml(conform de orm schema), en breng de kolommen van uw POJO in kaart, zonder deze zelfs maar uit te breiden. Het zal in de ene omgeving JPA-enabled zijn, en een POJO in de andere - overschrijf alleen de getter-methoden en annoteer ze – (ik weet niet zeker of dit zal werken)
Dat gezegd hebbende, denk ik niet dat het nodig is om dit te doen. Annoteer gewoon uw POJO en voeg de afhankelijkheid van compileren toe aan uw projecten. Vervolgens zal elk project beslissen of het ze als PPV-entiteiten zal gebruiken of niet.