Hallo Leute!

Ich versuche, den "optimistic lock" in meiner Web-Anwendung zu realisieren. Ich mache folgendes: wenn ein Benutzer einen Datensatz liest, hole ich ein Objekt, schließe die Sitzung und speichere das "detachte" Objekt in der HTTP Sitzung:

SessionFactory sf = HUtils.getSf();
Session s = sf.openSession();
Transaction tx = s.beginTransaction();
Adressen a = (Adressen)s.get(Adressen.class,"K-0010-5");
tx.commit();
s.close();
req.getSession().setAttribute("adresse",a);
req.getRequestDispatcher("edit.jsp").forward(req,res);


wenn der Benutzer den Objekt geändert hat und möchte die geänderte Adresse speichern, mache ich so wie es im Buch beschrieben:


"The application manipulates the state of detached instances originally
loaded in another Session and then reattaches them using Session.update(), Session.
saveOrUpdate(), or Session.merge().
// foo is an instance loaded by a previous Session
foo.setProperty("bar");
session = factory.openSession();
Transaction t = session.beginTransaction();
session.saveOrUpdate(foo); // Use merge() if "foo" might have been loaded already
t.commit();
session.close();
Again, Hibernate will check instance versions during flush, throwing an exception if conflicting updates occured."

Mein Code:

Adressen a = (Adressen) req.getSession().getAttribute("adresse");
a.setHausnr(req.getParameter("hausnr"));
a.setName1(req.getParameter("name1"));
a.setName2(req.getParameter("name2"));
a.setStrasse(req.getParameter("strasse"));
a.setPLZ(req.getParameter("plz"));
a.setOrt(req.getParameter("ort"));
SessionFactory sf = HUtils.getSf();
Session s = sf.openSession();
Transaction t = s.beginTransaction();
s.update(a);
t.commit();
s.close();

Wenn zwei Benutzer gleichzeitig eine und dieselbe Adresse zum Editieren laden, dann überschreibt der zweite Benutzer den Satz der vom ersten Benutzer vorher geändert wurde. Keine Exception wird geworfen.

Was mache ich falsch?

Danke für Ihre Antworten.

Zeig doch mal deine Adresse-Klasse und besonders das Mapping-Dokument her.

da ist nichts besonderes, eine alleinstehende Klasse mit entsprechender Mapping

Adresse:


public class Adressen {

private String KundenNr;
private String name1;
private String name2;
private String strasse;
private String hausnr;
private String PLZ;
private String ort;

//+ alle Getters und Setters

}

Mapping:

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
<class name="mypack.Adressen" table="Adressen">
<id name="KundenNr">
<generator class="assigned"/>
</id>
<property name="name1"/>
<property name="name2"/>
<property name="strasse"/>
<property name="hausnr"/>
<property name="PLZ"/>
<property name="ort"/>
</class>
</hibernate-mapping>

Also wenn Du über die Version ein "optimistic lock" machen willst, solltest Du das "<version>"-Tag richtig vergeben und die Version auch in Dein Bean mit aufnehmen ;-)
(entsprechende Spalte in der Tabelle bitte nicht vergessen)