Bonjour.

J'utilise Hibernate3 avec Java et je ne comprend pas bien à quoi sert l'attribut inverse, et de quel côté d'une relation il faut le mettre.

J'ai parcouru la documentation en long, en large et en travers, mais je ne comprends pas. Pouvez-vous m'aider ?

@+
Rémi

J'ai un schéma UML ma foi assez basique qui se résume à :

Member<-----possède------>MemberAccount<-----appartient----->Groups

j'ai mappé MemberAccount en tant que Component de Member et Groups en tant que Set dans ce Component. Jusque là tout va bien.
Mon problème est que quand je sauvegarde le tout je peux aisèment naviguer depuis un membre à ses différents groupes mais pas le contraire, je n'arrive pas à retrouver les comptes et encore moins les membres depuis les groupes, j'aimerai obtenir une relation totalement bi-directionnelle sans avoir à faire des requêtes dans ma base (avec des SQL queries). est ce possible?

voilà mes deux fichiers mapping :
1. Groups.hbm.xml
<set name="memberAccount" table="users_groups" lazy="true"
inverse="true" cascade="save-update">
<key column="group_id" />
<many-to-many class="src.users.Member" column="user_id"></many-to-many>
</set>

2. Member.hbm.xml
<component name="MemberAccount"
class="src.accounts.MemberAccount">
<property name="status" type="string" />
<property name="creationDate" type="date" update="false"/>
<set name="myGroups" table="users_groups" lazy="true">
<key column="user_id" />
<many-to-many class="src.groups.Group"
column="group_id">
</many-to-many>
</set>
</component>


j'obtiens ce message d'erreur si je désire sauvegarder :
[CascadingAction] cascading to saveOrUpdate: src.users.Member
Exception in thread "main" org.hibernate.HibernateException: instance not of expected entity type: src.users.Member
at org.hibernate.persister.entity.AbstractEntityPersister.getSubclassEntityPersister(AbstractEntityPersister.java:3301)
at org.hibernate.impl.SessionImpl.getEntityPersister(SessionImpl.java:1311)
at org.hibernate.engine.ForeignKeys.isTransient(ForeignKeys.java:180)
at org.hibernate.event.def.AbstractSaveEventListener.getEntityState(AbstractSaveEventListener.java:460)
at org.hibernate.event.def.DefaultSaveOrUpdateEventListener.performSaveOrUpdate(DefaultSaveOrUpdateEventListener.java:84)
at org.hibernate.event.def.DefaultSaveOrUpdateEventListener.onSaveOrUpdate(DefaultSaveOrUpdateEventListener.java:70)
at org.hibernate.impl.SessionImpl.fireSaveOrUpdate(SessionImpl.java:502)
at org.hibernate.impl.SessionImpl.saveOrUpdate(SessionImpl.java:494)
at org.hibernate.engine.CascadingAction$5.cascade(CascadingAction.java:134)
at org.hibernate.engine.Cascade.cascadeToOne(Cascade.java:213)
at org.hibernate.engine.Cascade.cascadeAssociation(Cascade.java:157)
at org.hibernate.engine.Cascade.cascadeProperty(Cascade.java:108)
at org.hibernate.engine.Cascade.cascadeCollectionElements(Cascade.java:290)
at org.hibernate.engine.Cascade.cascadeCollection(Cascade.java:185)
at org.hibernate.engine.Cascade.cascadeAssociation(Cascade.java:160)
at org.hibernate.engine.Cascade.cascadeProperty(Cascade.java:108)
at org.hibernate.engine.Cascade.cascade(Cascade.java:248)
at org.hibernate.event.def.AbstractFlushingEventListener.cascadeOnFlush(AbstractFlushingEventListener.java:130)
at org.hibernate.event.def.AbstractFlushingEventListener.prepareEntityFlushes(AbstractFlushingEventListener.java:121)
at org.hibernate.event.def.AbstractFlushingEventListener.flushEverythingToExecutions(AbstractFlushingEventListener.java:65)
at org.hibernate.event.def.DefaultFlushEventListener.onFlush(DefaultFlushEventListener.java:26)
at org.hibernate.impl.SessionImpl.flush(SessionImpl.java:985)
at org.hibernate.impl.SessionImpl.managedFlush(SessionImpl.java:333)
at org.hibernate.transaction.JDBCTransaction.commit(JDBCTransaction.java:106)
at src.tests.HibernateTest.associateGroupMember(HibernateTest.java:118)
at src.tests.HibernateTest.scenario1(HibernateTest.java:39)
at src.tests.HibernateTest.main(HibernateTest.java:20)

l'attribut "inverse" permet de dire que les changements sur les objets pour cette relation n'affectera pas la base.

Par exemple tu as des personnes qui participent à des évènements et des évènements qui ont des participants (personnes)

Nous avons donc une relation "participe" et se relation inverse "participants". Dans ton code quand tu ajoute un évènement a une personne il faut également que tu ajoute cette personne à la liste des participants de l'évènement.

Quand tu va ajouter la personne à l'évènement, si tu n'a pas déclarer "participant" comme étant "inverse", au commit un nouvel élément de relation va être créé alors que c'est le même que quand tu ajoute l'évènement à la personne.

Quant au choix du coté de la relation qui va être défini comme "inverse", c'est à ton bon vouloir.

en effet, et c'est ce que je fais dans mon code, je lie mon groupe à un nouveau compte et ajoute le compte en question du membre au groupe. Mais c'est au moement du commit que ça foire. pourtant dans mon mapping je ne vois pas où il y aurai problème.

Pas tout à fait d'accord.
Soit sur ton set tu met le inverse=true et eventuellement un not-null, soit tu mets le not-null dans la key de ton set, et à ce moment la tu fais un insert=false et update=false dans ton many-to-one.

Dans tous les cas, et ce que dit barbu0055 est vrai, il faut forcement bien indiquer d'une maniere ou d une autre qu une relation est l'inverse de sa relation en sens inverse dans le cas des relations bidirectionnelles.

Personnellement, et sauf en occasions tres exotiques, je met toujours le inverse=true sur le set et le not-null sur le many-on-one.


Voila pour le inverse... j ai pas mal galéré moi aussi!