Difference between physical and logical transactions in spring

Question

In this spring document http://static.springsource.org/spring/docs/3.2.x/spring-framework-reference/html/transaction.html .It talks about physical and logical transactions.I have written a very simple program to understand it

TransactionObject.java

class TransactionObject {

    private static Connection conn;

    TransactionObject() {
        try {
            conn = DriverManager.getConnection("DB_URL", "USER", "PASS");
        } catch (SQLException e) {}
    }

    void rollBack() {
        try {
            conn.rollback();
        } catch (SQLException e) { }
    }

    void Commit() {
        try {
            conn.commit();
        } catch (SQLException e) { }
    }
}

ClassMethodUnderTransactionObject.java

public class ClassMethodUnderTransactionObject {
    // start fresh TransactionObject
    TransactionObject  logical= new TransactionObject();

    M2(); // call M2 use same logical object
    M3(); // call M3 use same logical object
    // For M2 and M3 it is logical transaction because both using same transaction object

    if(error){
        logical.rollBack();  
    } else {
        logical.Commit(); 
    }

    // create another instance of TransactionObject
    TransactionObject  physical=new TransactionObject();

    M4(); // call M4 use different TransactionObject object
    if(error){
        physical.rollBack();  
    } else {
        physical.Commit(); 
    }

So M4 uses physical transaction in respect to M2 and M3 becuase M4 uses different trasnactionObject

Is that the way we should understand ?Is there more to understand.Please help me to understand it.

Answer 1

I understand this like this

• physical transaction is from external world
• logical transaction is your internal.

This has many consequences described in documentation.

I dont get your example.

Answer 2

According to the Spring documentation, PROPAGATION.PROPAGATION_REQUIRED creates a new transaction if a transaction doesn't exist yet or uses an existing one if one already exists.

Suppose we already have a transaction running and are going to apply a transaction to methodA, methodB and methodC in one of our services.

In this scenario, methodA, methodB, methodC will be running in logical transactions while there will be only one physical transaction which encapsulates all other logical transactions. All these logical transaction scopes are logically independent from the physical transaction scope. But they are mapped to the same physical transaction.

So: logical transaction of methodA + logical transaction of methodB + logical transaction of methodB -> physical transaction

Every logical transaction can define its separate rollback rules. Once the rollback rule triggered from logical transaction, an UnexpectedRollbackException is thrown but the physical transaction can still call commit because the physical transaction is independent from the scope of the logical transaction. But when the physical transaction encounters UnexpectedRollbackException (which is an unchecked RuntimeException), it triggers the rollback of the entire physical transaction and the client will see that a rollback occurred.