CODEWITHSUNDEEP
javaspringtransactions
Rohit Bansal
Rohit Bansal

Reputation: 1199

Will called function be still in transaction if we have a @Transaction in caller function?

I understand we need to keep @Transactional boundaries as short as possible. Here is the code :

I am using userDAO object through Spring dependency injection :

private static ApplicationContext context ;
private UserDAO userDAO;

public TransactionsTest() {
    userDAO = (UserDAO) context.getBean("userDAO");
}

I am calling testSaveUserAccounts() from TransactionsTest class trying to use userDAO for insertion/updation of data.

Case 1:

@Transactional
public void testSaveUserAccounts() {
    UserAccounts userAccounts = new UserAccounts();
    userAccounts.setCommunityId(10L);
    userDAO.saveObject(userAccounts);
}

// This method is inside UserDAO
        public void saveObject(Object object) {
        entityManager.merge(object);
    }

Case 2:

@Transactional
public void testSaveUserAccounts() {
    UserAccounts userAccounts = new UserAccounts(); 
    userAccounts.setCommunityId(10L);
    userDAO.saveObject(userAccounts);
}

// This method is inside UserDAO
    @Transactional(propagation=Propagation.REQUIRED)
    public void saveObject(Object object) {
        entityManager.merge(object);
    }

Spring Context :

    <tx:annotation-driven transaction-manager="transactionManager" />

        <bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
            <property name="entityManagerFactory" ref="entityManagerFactory" />
        </bean>

        <bean class="org.springframework.orm.jpa.support.PersistenceAnnotationBeanPostProcessor" />

        <bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
            <property name="dataSource" ref="dataSourceLocal" />
            <property name="jpaVendorAdapter">
                <bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter" />
            </property>
            <property name="persistenceUnitName" value="spring-jpa" />
      </bean>

UserDAO :

@Repository
public class UserDAO extends BaseDAO {

    @Transactional(propagation=Propagation.REQUIRED)
    public void saveObject(Object object) {
        entityManager.merge(object);
    }

}

BaseDAO :

public abstract class BaseDAO {

    protected EntityManager entityManager;
    protected HashMap<String,Long>  eventIdMap = new HashMap<String,Long>();


    @PersistenceContext
    public void setEntityManager(EntityManager entityManager) {
        this. entityManager = entityManager;
    }


    public <T> T getById(final Class<T> clazz, final Serializable id) {
        T object = clazz.cast(entityManager.find(clazz, id));
        return object;
    }


    @Transactional
    public Object save(Object ob) {
        Object object = entityManager.merge(ob);
        return object;
    }


    @Transactional
    public void persist(Object ob) {
        entityManager.persist(ob);
    }


    @SuppressWarnings("unchecked")
    public <T>  ArrayList<T> getAll(final Class<T> clazz) {
        String hqlQuery = "from "+ clazz.getSimpleName();
        ArrayList<T> list  = (ArrayList<T>)entityManager.createQuery(hqlQuery).getResultList();
        return list;
    }

}

I have been experimenting around several transactional boundaries REQUIRED, REQUIRES_NEW, SUPPORTS, etc but couldn't confidently make out as to why Case 1 (when method2 is called which is inside transactional boundary of method1) does not merges the data, while, this is solved in Case 2.

Why do I need to specify @Transactional in inner methods as well when already I have marked calling function within Transaction boundary ?

Upvotes: 0

Views: 771

Answers (2)

ams
ams

Reputation: 62652

Your transaction test class is not a Spring Bean that is why Case 1 does not work. Spring needs to detected that a method has @Transactional on it and it does that when spring registers the bean with the spring bean factory.

Also keep in mind that the if you are doing Proxy Based AOP calls within the same bean will not be caught by the transaction aspect unless you use AspectJ load time weaving or AspectJ compile time weaving.

Also putting @Transactional on your Dao's is not a really a good idea because transaction boundaries are best marked at the service layer. The reason why is that a particular service method might need to interact with multiple Dao's and you would want those Dao's actions to be part of the tx started by the service layer, rather than having to analyze the Dao's to see what the propagation behavior is.

Can you post the complete code for the test class?

Upvotes: 1

Rasmus Franke
Rasmus Franke

Reputation: 4524

@Transactional does nothing locally, it only has an effect when called from a different service. In other words, you have to leave your current context for transaction annotations to do anything. so calling method 1 is identical in both cases, Case 2 only does anything if method2 is called from another service.

Upvotes: 0

Related Questions