Come abilitare LockModeType.PESSIMISTIC_WRITE quando si cercano entità con Spring Data JPA?

Question

Come posso ottenere l'equivalente di questo codice:

tx.begin(); 
Widget w = em.find(Widget.class, 1L, LockModeType.PESSIMISTIC_WRITE); 
w.decrementBy(4); 
em.flush(); 
tx.commit(); 

... ma utilizzando primavera e la primavera-Data-JPA annotazioni?

La base del mio codice esistente è:

@Service 
@Transactional(readOnly = true) 
public class WidgetServiceImpl implements WidgetService 
{ 
    /** The spring-data widget repository which extends CrudRepository<Widget, Long>. */ 
    @Autowired 
    private WidgetRepository repo; 

    @Transactional(readOnly = false) 
    public void updateWidgetStock(Long id, int count) 
    { 
    Widget w = this.repo.findOne(id); 
    w.decrementBy(4); 
    this.repo.save(w); 
    } 
} 

Ma non so come specificare che tutto nel metodo updateWidgetStock dovrebbe essere fatto con un set di blocco pessimistico.

C'è un'annotazione primavera dati JPA org.springframework.data.jpa.repository.Lock che consente di impostare una LockModeType, ma non so se è valida per metterlo sul metodo updateWidgetStock. Suona più come un'annotazione sul WidgetRepository, perché il Javadoc dice:

org.springframework.data.jpa.repository
@Target (value = METHOD)
@Retention (value = Runtime)
@Documented
public @interface Lock
Annotazione utilizzata per specificare il LockModeType da utilizzare durante l'esecuzione della query. Verrà valutato quando si utilizza Query su un metodo di query o se si ottiene la query dal nome del metodo.

... in modo che non sembra essere utile.

Come è possibile eseguire il metodo updateWidgetStock() con LockModeType.PESSIMISTIC_WRITE impostato?

Answer 1

@Lock è supportato sui metodi CRUD a partire dalla versione 1.6 di Spring Data JPA (infatti, è già disponibile uno milestone). Vedi questo ticket per maggiori dettagli.

Con questa versione è sufficiente dichiarare quanto segue:

interface WidgetRepository extends Repository<Widget, Long> { 

    @Lock(LockModeType.PESSIMISTIC_WRITE) 
    Widget findOne(Long id); 
} 

Questo farà sì che la parte implementazione CRUD della delega repository supporto per applicare la configurazione LockModeType alla find(…) chiamata sul EntityManager.

Answer 2

Se si è in grado di utilizzare Spring Data 1.6 o superiore ignorare questa risposta e fare riferimento alla risposta di Oliver.

Le annotazioni pessimistiche di Spring @Lock si applicano solo (come indicato) alle query. Non ci sono annotazioni che so che possono influenzare un'intera transazione. È possibile creare un metodo findByOnePessimistic che chiama findByOne con un blocco pessimistico oppure è possibile modificare findByOne per ottenere sempre un blocco pessimistico.

Se si volesse implementare la propria soluzione probabilmente lo si potrebbe fare. Sotto il cofano il @Lock annotazione viene elaborata dal LockModePopulatingMethodIntercceptor che esegue le seguenti operazioni:

TransactionSynchronizationManager.bindResource(method, lockMode == null ? NULL : lockMode); 

si potrebbe creare qualche manager serratura statica che aveva una variabile ThreadLocal<LockMode> membro e quindi avere un aspetto avvolto intorno ogni metodo in ogni repository che chiama bindResource con la modalità di blocco impostata su ThreadLocal. Ciò consentirebbe di impostare la modalità di blocco su una base per-thread. È quindi possibile creare la propria annotazione @MethodLockMode che avvolgerebbe il metodo in un aspetto che imposta la modalità di blocco specifica del thread prima di eseguire il metodo e lo cancella dopo l'esecuzione del metodo.

Answer 3

Se non si desidera sovrascrivere metodo standard findOne(), è possibile acquisire un blocco nel vostro metodo personalizzato utilizzando select ... for update interrogazione proprio come questo:

/** 
* Repository for Wallet. 
*/ 
public interface WalletRepository extends CrudRepository<Wallet, Long>, JpaSpecificationExecutor<Wallet> { 

    @Lock(LockModeType.PESSIMISTIC_WRITE) 
    @Query("select w from Wallet w where w.id = :id") 
    Wallet findOneForUpdate(@Param("id") Long id); 
} 

Tuttavia, se si utilizza PostgreSQL, le cose possono diventa un po 'complicato quando si desidera impostare il timeout di blocco per evitare deadlock. PostgreSQL ignora la proprietà standard javax.persistence.lock.timeout impostata nelle proprietà JPA o nell'annotazione @QueryHint.

L'unico modo per farlo funzionare era creare un repository personalizzato e impostare manualmente il timeout prima di bloccare un'entità. Non è bello, ma almeno si sta lavorando:

public class WalletRepositoryImpl implements WalletRepositoryCustom { 

@PersistenceContext 
private EntityManager em; 


@Override 
public Wallet findOneForUpdate(Long id) { 
    // explicitly set lock timeout (necessary in PostgreSQL) 
    em.createNativeQuery("set local lock_timeout to '2s';").executeUpdate(); 

    Wallet wallet = em.find(Wallet.class, id); 

    if (wallet != null) { 
     em.lock(wallet, LockModeType.PESSIMISTIC_WRITE); 
    } 

    return wallet; 
} 

}