java-如何使用EJB 3.0实现适当的计数器bean？
作者：互联网
[编辑]这个问题是“我如何使用EJB 3和JPA 2.0对实体bean进行原子更改”.应该简单吧？
我试图根据到目前为止得到的答案修复代码.我在Hypersonic中使用JBoss 6.0.0M2(只需下载并调用run.bat).
我的测试用例：创建3个线程并在一个循环中调用testCounterMitLock *()之一500次.因此,成功的测试应打印“ Anzahl eingetragene Zeilen：1500”(3 * 500).
我试过了：
CounterTestVersion ct = manager.find(CounterTestVersion.class, 1);
manager.lock(ct, LockModeType.WRITE);
int wert = ct.getWert();
显然不起作用,因为其他线程可以在应用锁之前更改数据库中的值.因此,我尝试解决此问题：
CounterTestVersion ct = manager.find(CounterTestVersion.class, 1);
manager.lock(ct, LockModeType.WRITE);
manager.refresh (ct);
int wert = ct.getWert();
refresh()应该给我当前值,隐式查询还应该确保该对象现在被锁定.没有这种运气.让我们尝试使用JPA 2.0：
CounterTestVersion ct = manager.find(CounterTestVersion.class, 1, LockModeType.WRITE);
int wert = ct.getWert();
那也行不通.也许锁还不够？
CounterTestVersion ct = manager.find(CounterTestVersion.class, 1, LockModeType.PESSIMISTIC_WRITE);
int wert = ct.getWert();
嗯…也不起作用！最后一次绝望的尝试：
CounterTestVersion ct = manager.find(CounterTestVersion.class, 1, LockModeType.PESSIMISTIC_WRITE);
manager.flush();
manager.refresh (ct);
int wert = ct.getWert();
好吧…谁能解释为什么什么都不起作用？我没主意了.
[EDIT2] PS：要加重侮辱,这是最后一个运行线程的最后输出：
commit/rollback: 441/62
(441 62 = 503)…
这是完整的代码.首先是豆：
package server.kap15;
import java.rmi.RemoteException;
import javax.ejb.*;
import javax.persistence.*;
@Stateful
public class CounterTestBean implements CounterTestRemote, SessionSynchronization {
@PersistenceContext(unitName = "JavaEE")
EntityManager manager;
private int commit = 0;
private int rollback = 0;
public void initDatenbank() {
manager.createNamedQuery("CounterTest.deleteAll").executeUpdate();
manager.createNamedQuery("TestTabelle.deleteAll").executeUpdate();
CounterTestVersion ct = new CounterTestVersion();
ct.setNr(1);
ct.setVersion(1);
ct.setWert(1);
manager.persist(ct);
}
public boolean testCounterOhneLock() {
try {
CounterTest ct = manager.find(CounterTest.class, 1);
int wert = ct.getWert();
ct.setWert(wert + 1);
TestTabelle tt = new TestTabelle();
tt.setNr(wert);
manager.persist(tt);
manager.flush();
return true;
} catch (Throwable t) {
return false;
}
}
public boolean testCounterMitLock() {
try {
CounterTestVersion ct = manager.find(CounterTestVersion.class, 1);
manager.lock(ct, LockModeType.WRITE);
int wert = ct.getWert();
ct.setWert(wert + 1);
TestTabelle tt = new TestTabelle();
tt.setNr(wert);
manager.persist(tt);
manager.flush();
return true;
} catch (Throwable t) {
return false;
}
}
public boolean testCounterMitLock2() {
try {
CounterTestVersion ct = manager.find(CounterTestVersion.class, 1);
manager.lock(ct, LockModeType.WRITE);
manager.refresh (ct);
int wert = ct.getWert();
ct.setWert(wert + 1);
TestTabelle tt = new TestTabelle();
tt.setNr(wert);
manager.persist(tt);
manager.flush();
return true;
} catch (Throwable t) {
return false;
}
}
public boolean testCounterMitLock3() {
try {
CounterTestVersion ct = manager.find(CounterTestVersion.class, 1, LockModeType.WRITE);
int wert = ct.getWert();
ct.setWert(wert + 1);
TestTabelle tt = new TestTabelle();
tt.setNr(wert);
manager.persist(tt);
manager.flush();
return true;
} catch (Throwable t) {
return false;
}
}
public boolean testCounterMitLock4() {
try {
CounterTestVersion ct = manager.find(CounterTestVersion.class, 1, LockModeType.PESSIMISTIC_WRITE);
int wert = ct.getWert();
ct.setWert(wert + 1);
TestTabelle tt = new TestTabelle();
tt.setNr(wert);
manager.persist(tt);
manager.flush();
return true;
} catch (Throwable t) {
return false;
}
}
public boolean testCounterMitLock5() {
try {
CounterTestVersion ct = manager.find(CounterTestVersion.class, 1, LockModeType.PESSIMISTIC_WRITE);
manager.flush();
manager.refresh (ct);
int wert = ct.getWert();
ct.setWert(wert + 1);
TestTabelle tt = new TestTabelle();
tt.setNr(wert);
manager.persist(tt);
manager.flush();
return true;
} catch (Throwable t) {
return false;
}
}
public boolean testCounterMitVersion() {
try {
CounterTestVersion ctv = manager.find(CounterTestVersion.class, 1);
int wert = ctv.getWert();
ctv.setWert(wert + 1);
manager.flush();
TestTabelle tt = new TestTabelle();
tt.setNr(wert);
manager.persist(tt);
manager.flush();
return true;
} catch (OptimisticLockException e) {
System.out.println(">>> Versionskonflikt !");
return false;
} catch (Throwable t) {
System.out.println(t.getMessage());
return false;
}
}
public long anzTestZeilen() {
Query query = manager.createNamedQuery("TestTabelle.anzZeilen");
Long anzahl = (Long) query.getSingleResult();
return anzahl;
}
public void afterBegin() throws EJBException, RemoteException {
}
public void beforeCompletion() throws EJBException, RemoteException {
}
public void afterCompletion(boolean committed) throws EJBException,
RemoteException {
if (committed)
commit++;
else
rollback++;
System.out.println("commit/rollback: " + commit + "/" + rollback);
}
}
远程接口：
package server.kap15;
import javax.ejb.Remote;
@Remote
public interface CounterTestRemote {
public void initDatenbank();
public boolean testCounterOhneLock();
public boolean testCounterMitLock();
public boolean testCounterMitLock2();
public boolean testCounterMitLock3();
public boolean testCounterMitLock4();
public boolean testCounterMitLock5();
public boolean testCounterMitVersion();
public long anzTestZeilen();
}
persistence.xml：
<?xml version="1.0" encoding="UTF-8"?>
<persistence xmlns="http://java.sun.com/xml/ns/persistence"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/persistence
http://java.sun.com/xml/ns/persistence/persistence_1_0.xsd"
version="1.0">
<persistence-unit name="JavaEE">
<jta-data-source>java:DefaultDS</jta-data-source>
</persistence-unit>
</persistence>
测试客户端：
package client.kap15;
import java.util.Properties;
import javax.naming.*;
import javax.rmi.PortableRemoteObject;
import server.kap15.CounterTestRemote;
public class CounterTestMitLock extends Thread {
CounterTestRemote ctr;
public static void main(String[] args) {
try
{
testMitLock();
testMitLock2();
testMitLock3();
testMitLock4();
testMitLock5();
}
catch (Exception e)
{
e.printStackTrace ();
}
}
static int N = 3;
static CounterThread[] ct = new CounterThread[N];
private static void testMitLock () throws InterruptedException
{
System.out.println("--- Counter Test MIT Lock ----------------------");
System.out.println("Testinstanzen erzeugen...");
for (int i=0; i<N; i++)
ct[i] = new CounterThreadMitLock();
runTest ();
}
private static void testMitLock2 () throws InterruptedException
{
System.out.println("--- Counter Test MIT Lock2 ----------------------");
System.out.println("Testinstanzen erzeugen...");
for (int i=0; i<N; i++)
ct[i] = new CounterThreadMitLock2();
runTest ();
}
private static void testMitLock3 () throws InterruptedException
{
System.out.println("--- Counter Test MIT Lock3 ----------------------");
System.out.println("Testinstanzen erzeugen...");
for (int i=0; i<N; i++)
ct[i] = new CounterThreadMitLock3();
runTest ();
}
private static void testMitLock4 () throws InterruptedException
{
System.out.println("--- Counter Test MIT Lock4 ----------------------");
System.out.println("Testinstanzen erzeugen...");
for (int i=0; i<N; i++)
ct[i] = new CounterThreadMitLock4();
runTest ();
}
private static void testMitLock5 () throws InterruptedException
{
System.out.println("--- Counter Test MIT Lock5 ----------------------");
System.out.println("Testinstanzen erzeugen...");
for (int i=0; i<N; i++)
ct[i] = new CounterThreadMitLock5();
runTest ();
}
private static void runTest () throws InterruptedException
{
System.out.println("Datenbank initialisieren...");
ct[0].ctr.initDatenbank();
System.out.println("Test durchführen...");
for (int i=0; i<N; i++)
ct[i].start();
System.out.println("Auf Ende warten...");
for (int i=0; i<N; i++)
ct[i].join();
System.out.println("Anzahl eingetragene Zeilen: " + ct[0].ctr.anzTestZeilen());
}
private static CounterTestRemote verbinden() {
try {
Properties p = new Properties();
p.put(Context.INITIAL_CONTEXT_FACTORY, "org.jnp.interfaces.NamingContextFactory");
p.put(Context.URL_PKG_PREFIXES, "org.jboss.naming:org.jnp.interfaces");
p.put(Context.PROVIDER_URL, "jnp://localhost:1099");
Context ctx = new InitialContext(p);
Object ref = ctx.lookup("CounterTestBean/remote");
CounterTestRemote ctr = (CounterTestRemote) PortableRemoteObject.narrow(ref, CounterTestRemote.class);
return ctr;
} catch (NamingException e) {
System.out.println("ERROR - NamingException!");
System.exit(-1);
}
return null;
}
public abstract static class CounterThread extends Thread
{
protected CounterTestRemote ctr;
public CounterThread ()
{
this.ctr = verbinden ();
}
public void run() {
for (int i = 0; i < 500; i++)
test ();
}
public abstract void test ();
}
public static class CounterThreadMitLock extends CounterThread
{
@Override
public void test ()
{
this.ctr.testCounterMitLock();
}
}
public static class CounterThreadMitLock2 extends CounterThread
{
@Override
public void test ()
{
this.ctr.testCounterMitLock2();
}
}
public static class CounterThreadMitLock3 extends CounterThread
{
@Override
public void test ()
{
this.ctr.testCounterMitLock3();
}
}
public static class CounterThreadMitLock4 extends CounterThread
{
@Override
public void test ()
{
this.ctr.testCounterMitLock4();
}
}
public static class CounterThreadMitLock5 extends CounterThread
{
@Override
public void test ()
{
this.ctr.testCounterMitLock5();
}
}
}
解决方法:
由于所有锁定模式都不起作用,因此我尝试使用手动SELECT … FOR UPDATE尝试ewernli的解决方案.那给出了一个有趣的例外：“意外令牌FOR”.所以我看了看数据库.
JBoss默认安装为Hypersonic 1.8(HSQLDB),不支持行锁定.尊敬的JBoss开发人员：如果不支持锁定模式,则JPA实现应该引发异常.
因此,我添加了Oracle数据源并更改了persistence.xml.之后,将执行两个测试：
CounterTestVersion ct = manager.find(CounterTestVersion.class, 1, LockModeType.PESSIMISTIC_WRITE);
int wert = ct.getWert();
和
Query query = manager.createNativeQuery ("select * from COUNTER_TEST where NR = 1 for update", CounterTestVersion.class);
CounterTestVersion ct = (CounterTestVersion)query.getSingleResult ();
int wert = ct.getWert ()+1;
这很有趣.它也应该与LockModeType.PESSIMISTIC_FORCE_INCREMENT一起使用.在这种情况下,我在日志中看到此错误：
ORA-00054: resource busy and acquire with NOWAIT specified
这发生在调用manager.find()中.我看不到为什么两者在负载阶段的行为会有所不同.也许是JBoss或Hibernate中的错误.
标签：concurrency,jpa,ejb-3-0,java,java-ee 来源： https://codeday.me/bug/20191106/2000596.html