Hibernate select update no wait

  • Themenstarter Themenstarter Gast2
  • Beginndatum Beginndatum
G

Gast2

Gast
Hallo zusammen,

ich versuche mit Hibernate ein select update no wait hinzubekommen.
Was ich hier gelesen habe, kann das nur oracle.
Pessimistic Locking in JPA 2 and Hibernate - Developer.com

Gibt es irgendwie ein Hibernate Funktion die sowas nachstellt oder wie man er trotzdem erreichen kann.
Ziel ist es wenn ein Client ein bestimmtes Objekt lädt bekommt dieser den Lock, wenn weitere Clients das Objekt laden sollen diese nur die objekt werte sehen und diese nicht bearbeiten können.
Oder weiß jemand wie man sowas elegganter lösen kann???

Hier mal ein Testfall zum ausprobieren:
Der wo als 2tes den Lock bekommen soll nicht ewig im load hängen bleiben, sondern null oder irgendwas zurück bekommen, dass man sieht er hat den lock nicht bekommen.
Java:
package de.management.test;

import java.util.Date;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;

import org.hibernate.LockMode;
import org.hibernate.LockOptions;
import org.hibernate.Session;
import org.hibernate.Transaction;
import org.junit.BeforeClass;
import org.junit.Test;

import de.management.hibernate.HibCat;

public class HibernateLockingTest {

	private static Session session1;
	private static Session session2;
	private static ExecutorService executorService;
	@BeforeClass
	public static void createController() throws Exception {
		EntityManagerFactory factory = Persistence
				.createEntityManagerFactory("book.management");
		session1 = (Session) factory.createEntityManager().getDelegate();
		session2 = (Session) factory.createEntityManager().getDelegate();
		executorService = Executors.newFixedThreadPool(2);
	}

	@Test
	public void testLocking() {
		HibCat hibCat = new HibCat();
		hibCat.setName("1.");
		Transaction transaction1 = session1.beginTransaction();
		transaction1.begin();
		session1.save(hibCat);
		transaction1.commit();

		aquireLock1();
		aquireLock2();

		try {
			Thread.sleep(50000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}

	}

	private void aquireLock2() {
		executorService.execute(new Runnable() {

			@Override
			public void run() {
				System.out.println("Lock 2 obtained at: " + new Date());
				Transaction transaction = session2.beginTransaction();
				transaction.begin();
				LockOptions lockOptions = new LockOptions(LockMode.UPGRADE_NOWAIT);
				HibCat p = (HibCat) session2.load(HibCat.class, 1l, lockOptions);
				System.out.println("p2" + p);
				try {
					Thread.sleep(20000);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				transaction.commit();
			}

		});
	}
	
	private void aquireLock1() {
		executorService.execute(new Runnable() {

			@Override
			public void run() {
				System.out.println("Lock 1 obtained at: " + new Date());
				Transaction transaction = session1.beginTransaction();
				transaction.begin();
				LockOptions lockOptions = new LockOptions(LockMode.UPGRADE_NOWAIT);
				HibCat p = (HibCat) session1.load(HibCat.class, 1l,lockOptions);
				System.out.println("p1" + p);
				p.setName("2.");
				try {
					Thread.sleep(20000);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				transaction.commit();
			}

		});
	}

}

Java:
package de.management.hibernate;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;

@Entity
@Table
public class HibCat{

	@Id
	@GeneratedValue(strategy=GenerationType.AUTO)
	private Long id;
	
	private String name;

	public String getName() {
		return name;
	}

	public Long getId() {
		return id;
	}

}
 
Du kannst Optimistic Lock implementieren.

Dazu machst du ein neues Feld und annotierst es mit @Version.

Hibternate vergleicht beim SPeichern die Versionen.

Glaube das ist Zeitgemäßer.
 
Kannst du denn nicht mit Session#getCurrentLockMode vorher abfragen ob das Objekt bereits gelockt ist?
 
Hi,

also wir hatten bei dem Pessimistic Lock und der unterschiedlichen Datenbanken (DB2, Informix) auch unsere Probleme.

Außerdem wollten wir wissen, wer das Objekt gelockt hat. Wir haben dies durch eine eigene Locktabelle gelöst, die abgefragt wird. Außerdem können durch Fehlerfälle bestimmte Locks erhalten bleiben. Ein Admin kann locks lösen oder bei systemstart werden ehh alle gelöst.

Man kann also ein Datensatz (egal wieviele Tabellen beteiligt sind) locken und es wird der Zeitpunkt der login mitgeschrieben.

Wir können allerdings unterscheiden zwischen lesend öffnen und bearbeiten öffnen.
 
Hi,

also wir hatten bei dem Pessimistic Lock und der unterschiedlichen Datenbanken (DB2, Informix) auch unsere Probleme.

Außerdem wollten wir wissen, wer das Objekt gelockt hat. Wir haben dies durch eine eigene Locktabelle gelöst, die abgefragt wird. Außerdem können durch Fehlerfälle bestimmte Locks erhalten bleiben. Ein Admin kann locks lösen oder bei systemstart werden ehh alle gelöst.

Man kann also ein Datensatz (egal wieviele Tabellen beteiligt sind) locken und es wird der Zeitpunkt der login mitgeschrieben.

Wir können allerdings unterscheiden zwischen lesend öffnen und bearbeiten öffnen.

Wollte nicht alles selber implementieren =).

Aber heiß konkret jede Entity von euch hatte ein LockObjekt?
Und dann gibt es Methode lock und unlock?
Und in der lock Methode wird nachgeschaut ob es schon ein LockObjekt gibt, wenn ja ist der Datensatz schon gelockt.?
 
Genau.

Jedoch ist dies auf der Business Schicht angesiedelt. Weil die Datensätze über mehrere Entitys und auch verteilte Server laufen.
 

Zurück
Oben