AppletTalk.com

Scorpio · Guest

Salve a tutti,

ho un quesito un po' difficile da sottoporvi. Sto sviluppando
un'applicazione web (con Servlet, JSP ed alcune classi di business) che
utilizza dei dati memorizzati su un database a cui può accedere un altro
applicativo, non scritto in Java.
I dati a cui si vuole accedere sono delle prenotazioni, ed ogni prenotazione
è costituita da parecchi dati, cosicchè si è scelto di presentare questi
dati (che vengono caricati dal database) in più pagine JSP: ogni pagina
presenta alcuni dati logicamente correlati fra di loro. Per accedere ai
dati, non potendo ricorrere per una serie di motivi agli EJB, ho scritto una
serie di "classi di persistenza" che espongono metodi per inserire una nuova
tupla, modificarla, cancellarla o leggere i dati: ad esempio la classe
"Prenotazione" ha un costruttore che richiede come parametri i valori della
chiave primaria (per esempio, codice prenotazione e data prenotazione);
quanto istanziata, viene letta la tupla dal db corrispondente a detta chiave
e gli altri valori sono mappati in campi interni alla classe. La stessa
classe memorizza al suo interno un oggetto Connection che viene utilizzato
per le query e le update; la Connection è recuperata da un pool di
connessioni.

Gli utenti possono, da una certa pagina, caricare i dati relativi ad una
certa prenotazione: la richiesta viene gestita da una servlet che istanzia
la classe di persistenza con i dati della chiave primaria, la memorizza su
sessione in modo che possa essere recuperata dalle JSP di presentazione, e
successivamente l'utente può "navigare" tra i dati della prenotazione che ha
selezionato.

Fin qui, nulla di difficile, ma il problema è che non riesco a mantenere
un lock sulla riga corrispondente alla prenotazione selezionata. L'idea di
partenza era la seguente: quanto carico i dati, eseguo una "SELECT -- FOR
UPDATE", e NON chiudo la connessione in modo automatico; così, il DB
sottostante blocca la tupla. Con la stessa connessione, a seconda di quello
che ho bisogno, eseguo delle update successive sui dati invocando un metodo
apposito (doUpdate()).
Forse troppo ingenuamente, pensavo che una volta che l'utente aveva finito
di esaminare / elaborare la prenotazione, richiedeva alla servlet di
gestione un servizio, il quale recuperava da sessione l'istanza di
persistenza, ne invocava il metodo di close() [che esegue il commit /
rollback a seconda dei casi], rilasciando così il lock. Il giro è più o meno
il seguente:

public class MyServlet ... {

private void iniziaModifica(...)
{
.....
Prenotazione prenotazione = new Prenotazione(chiave); // esegue una
SELECT FOR UPDATE
.... // elaborazioni varie
session.setAttribute("prenotazione",prenotazione);
response.sendRedirect(paginaJspDiVisualizzazione);
....
}

private void fineModifica() {
....
Prenotazione prenotazione = (Prenotazione)
session.getAttribute("prenotazione");
.... // eventuali elab.
prenotazione.close(); // esegue il commit e rilascia il lock
}

}

Il problema è che dalla specifica 2.3 in poi, non possono più esistere
"connessioni pendenti" con delle risorse: se non viene eseguito il commit()
od il rollback(), il web container provvede di suo a chiuderle, invocando un
rollback (od un commit, a seconda di come si configura il comportamento
dell'application server). I due metodi della servlet sono invocati dalla
doGet o doPost a seconda del servizio richiesto.

Quindi a questo punto non so che pesci pigliare: gestire la concorrenza a
livello applicativo sarebbe ovviamente la soluzione ideale, ma non è
praticabile perchè gli stessi dati sono condivisi da altre applicazioni.

Spero che qualcuno di voi, magari più esperto, sappia darmi qualche
suggerimento.

Grazie,

Scorpio.