AnnotationDrivenBeanDefinitionParser<\/strong><\/h5>\n\r\n\/**\r\n* Parses the '<code><\/code>' tag. Will\r\n* {@link AopNamespaceUtils#registerAutoProxyCreatorIfNecessary register an AutoProxyCreator}\r\n* with the container as necessary.\r\n*\/\r\npublic BeanDefinition parse(Element element, ParserContext parserContext) {\r\n String mode = element.getAttribute("mode");\r\n if ("aspectj".equals(mode)) {\r\n \/\/ mode="aspectj"\r\n registerTransactionAspect(element, parserContext);\r\n \u00a0}\r\n else {\r\n \/\/ mode="proxy"\r\n \/\/ DEFAULT MODE\r\n AopAutoProxyConfigurer.configureAutoProxyCreator(element, parserContext);\r\n \u00a0}\r\n return null;\r\n}\r\n<\/pre>\nFor most users, we fall into the else block (mode=”proxy”<\/em>) so we’re calling AopAutoProxyConfigurer<\/strong>.configureAutoProxyCreator()<\/em><\/p>\n\r\n\r\nprivate static class AopAutoProxyConfigurer {\r\n\r\n public static void configureAutoProxyCreator(Element element, ParserContext parserContext) {\r\n AopNamespaceUtils.registerAutoProxyCreatorIfNecessary(parserContext, element);\r\n\r\n if (!parserContext.getRegistry().containsBeanDefinition(TRANSACTION_ADVISOR_BEAN_NAME)) {\r\n Object eleSource = parserContext.extractSource(element);\r\n\r\n \/\/ Create the TransactionAttributeSource definition.\r\n RootBeanDefinition sourceDef = new RootBeanDefinition(AnnotationTransactionAttributeSource.class);\r\n sourceDef.setSource(eleSource);\r\n sourceDef.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);\r\n\r\n \/\/ The bean AnnotationTransactionAttributeSource is created and registed dynamically here\r\n String sourceName = parserContext.getReaderContext().registerWithGeneratedName(sourceDef);\r\n\r\n \/\/ Create the TransactionInterceptor definition.\r\n \/\/ Point A\r\n RootBeanDefinition interceptorDef = new RootBeanDefinition(TransactionInterceptor.class);\r\n interceptorDef.setSource(eleSource);\r\n interceptorDef.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);\r\n\r\n \/\/ Set the declared transaction manager in\u00a0 to the transactionInterceptor, when available\r\n registerTransactionManager(element, interceptorDef);\r\n interceptorDef.getPropertyValues().add("transactionAttributeSource", new RuntimeBeanReference(sourceName));\r\n\r\n \/\/\u00a0 The bean TransactionInterceptor is created and registed dynamically here\r\n String interceptorName = parserContext.getReaderContext().registerWithGeneratedName(interceptorDef);\r\n\r\n \/\/ Create the TransactionAttributeSourceAdvisor definition.\r\n\r\n \/\/ This bean is an AOP definition\r\n RootBeanDefinition advisorDef = new RootBeanDefinition(BeanFactoryTransactionAttributeSourceAdvisor.class);\r\n advisorDef.setSource(eleSource);\r\n advisorDef.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);\r\n\r\n \/\/ Inject the bean AnnotationTransactionAttributeSource into the AOP definition\r\n \/\/ Point B\r\n advisorDef.getPropertyValues().add("transactionAttributeSource", new RuntimeBeanReference(sourceName));\r\n\r\n \/\/ Definition of advice bean = TransactionInterceptor previously declared\r\n advisorDef.getPropertyValues().add("adviceBeanName", interceptorName);\r\n if (element.hasAttribute("order")) {\r\n advisorDef.getPropertyValues().add("order", element.getAttribute("order"));\r\n }\r\n \/\/\u00a0 The bean BeanFactoryTransactionAttributeSourceAdvisor is created and registed dynamically here\r\n parserContext.getRegistry().registerBeanDefinition(TRANSACTION_ADVISOR_BEAN_NAME, advisorDef);\r\n\r\n CompositeComponentDefinition compositeDef = new CompositeComponentDefinition(element.getTagName(), eleSource);\r\n compositeDef.addNestedComponent(new BeanComponentDefinition(sourceDef, sourceName));\r\n compositeDef.addNestedComponent(new BeanComponentDefinition(interceptorDef, interceptorName));\r\n compositeDef.addNestedComponent(new BeanComponentDefinition(advisorDef, TRANSACTION_ADVISOR_BEAN_NAME));\r\n parserContext.registerComponent(compositeDef);\r\n }\r\n }\r\n\r\n \/\/ Retrieve the transactionManager attribute defined on when available\r\n \/\/ Example\r\n private static void registerTransactionManager(Element element, BeanDefinition def) {\r\n def.getPropertyValues().add("transactionManagerBeanName",\r\n TxNamespaceHandler.getTransactionManagerName(element));\r\n }\r\n}\r\n<\/pre>\nThe transaction interceptor class is created at line 19<\/strong><\/p>\nThen the declared transaction manager in <tx:annotation-driven><\/em> is searched in the Spring context and attached to this transaction interceptor, line 24<\/strong><\/p>\nFinally the bean is registered in the Spring context at line 28<\/strong><\/p>\nFrom\u00a0 line 32<\/strong> to line 47<\/strong>, Spring declares an\u00a0 TransactionAttributeSourceAdvisor<\/strong> bean and registers it into the context.
\n <\/p>\nB @Transactional parsing<\/h2>\n
<\/p>\n
1) org.springframework.transaction.interceptor.BeanFactoryTransactionAttributeSourceAdvisor<\/strong> extends AbstractBeanFactoryPointcutAdvisor<\/strong><\/h5>\n
\nIn this chapter, we’ll see how the @Transactional<\/strong> annotation is parsed during runtime by Spring to retrieve transaction-related properties<\/p>\n\r\n \/\/ Injected at Point B\r\n private TransactionAttributeSource transactionAttributeSource;\r\n\r\n \/\/ Define a pointcut here for AOP, injecting the transactionAttributeSource that was\r\n \/\/ set in AopAutoProxyConfigurer\r\n \/\/ see Point B\r\n private final TransactionAttributeSourcePointcut pointcut =\r\n new TransactionAttributeSourcePointcut() {\r\n @Override\r\n protected TransactionAttributeSource getTransactionAttributeSource() {\r\n return transactionAttributeSource;\r\n }\r\n };\r\n<\/pre>\nHere Spring just defines a poincut advisor. It is composed of a poincut handled by the class TransactionAttributeSourcePointcut<\/strong>. Here the transactionAttributeSource<\/em> is passed to the anonymous class dynamically within the overriden getTransactionAttributeSource()<\/em> method<\/p>\n2) abstract class org.springframework.transaction.interceptor.TransactionAttributeSourcePointcut<\/strong><\/h5>\n\r\nabstract class org.springframework.transaction.interceptor.TransactionAttributeSourcePointcut\r\n\r\n \/\/ Determine whether a call on a particular method matches the poincut\r\n \/\/ If it matches then the advice bean will be called\r\n \/\/ The advice bean that has been registered for this pointcut is the\r\n \/\/ TransactionInterceptor class (see Point A)\r\n public boolean matches(Method method, Class targetClass) {\r\n TransactionAttributeSource tas = getTransactionAttributeSource();\r\n\r\n \/\/ Call getTransactionAttribute of the injected transactionAttributeSoirce\r\n \/\/ (see Point C)\r\n return (tas == null || tas.getTransactionAttribute(method, targetClass) != null);\r\n}\r\n<\/pre>\nThis abstract class only defines the default bahavior of the maches()<\/em> method to check whether the join point matches this poincut<\/p>\n3) org.springframework.transaction.annotation.AnnotationTransactionAttributeSource<\/strong> extends AbstractFallbackTransactionAttributeSource<\/strong><\/h5>\n\r\n \/\/ Should be false in a context of J2SE\r\n private static final boolean ejb3Present = ClassUtils.isPresent("javax.ejb.TransactionAttribute",\r\n AnnotationTransactionAttributeSource.class.getClassLoader());\r\n\r\n \/\/ Default constructor\r\n public AnnotationTransactionAttributeSource() {\r\n this(true);\r\n }\r\n\r\n \/\/ publicMethodsOnly = true because this bean has been registered dynamically\r\n \/\/ by AopAutoProxyConfigurer with no argument so the default constructor above applies\r\n \/\/\r\n \/\/ ejb3Present = false\r\n public AnnotationTransactionAttributeSource(boolean publicMethodsOnly) {\r\n this.publicMethodsOnly = publicMethodsOnly;\r\n this.annotationParsers = new LinkedHashSet(2);\r\n this.annotationParsers.add(new SpringTransactionAnnotationParser());\r\n if (ejb3Present) {\r\n this.annotationParsers.add(new Ejb3TransactionAnnotationParser());\r\n }\r\n }\r\n<\/pre>\nThe second constructor of AnnotationTransactionAttributeSource<\/strong> registers the SpringTransactionAnnotationParser<\/strong> as default parser for the @Transactional<\/strong> annotation<\/p>\n4) org.springframework.transaction.interceptor.AbstractFallbackTransactionAttributeSource<\/strong><\/h5>\nPoint C & Point D <\/strong><\/p>\n\r\n \/\/ Point C\r\n public TransactionAttribute getTransactionAttribute(Method method, Class targetClass) {\r\n \/\/ First, see if we have a cached value.\r\n Object cacheKey = getCacheKey(method, targetClass);\r\n Object cached = this.attributeCache.get(cacheKey);\r\n if (cached != null) {\r\n ....\r\n ....\r\n \/\/ Not interesting code\r\n }\r\n else {\r\n \/\/ We need to work it out.\r\n \/\/ (see Point D below)\r\n TransactionAttribute txAtt = computeTransactionAttribute(method, targetClass);\r\n \/\/ Put it in the cache.\r\n if (txAtt == null) {\r\n this.attributeCache.put(cacheKey, NULL_TRANSACTION_ATTRIBUTE);\r\n }\r\n else {\r\n if (logger.isDebugEnabled()) {\r\n logger.debug("Adding transactional method '" + method.getName()\r\n + "' with attribute: " + txAtt);\r\n }\r\n this.attributeCache.put(cacheKey, txAtt);\r\n }\r\n return txAtt;\r\n }\r\n }\r\n\r\n \/\/ Point D\r\n private TransactionAttribute computeTransactionAttribute(Method method, Class targetClass) {\r\n \/\/ Don't allow no-public methods as required.\r\n \/\/ Here allowPublicMethodsOnly() will return true because we set the attribute\r\n \/\/ publicMethodOnly = true in the constructor of AnnotationTransactionAttribute\r\n if (allowPublicMethodsOnly() && !Modifier.isPublic(method.getModifiers())) {\r\n return null;\r\n }\r\n\r\n \/\/ Ignore CGLIB subclasses - introspect the actual user class.\r\n Class userClass = ClassUtils.getUserClass(targetClass);\r\n\r\n \/\/ The method may be on an interface, but we need attributes from the target class.\r\n \/\/ If the target class is null, the method will be unchanged.\r\n Method specificMethod = ClassUtils.getMostSpecificMethod(method, userClass);\r\n\r\n \/\/ If we are dealing with method with generic parameters, find the original method.\r\n specificMethod = BridgeMethodResolver.findBridgedMethod(specificMethod);\r\n\r\n \/\/ Find the @Transactional attributes of the method in the target class.\r\n \/\/ (see Point E)\r\n TransactionAttribute txAtt = findTransactionAttribute(specificMethod);\r\n if (txAtt != null) {\r\n return txAtt;\r\n }\r\n ...\r\n \/\/ Not interesting code\r\n }\r\n<\/pre>\nThe getTransactionAttribute()<\/em> of the abstract class ultimately delegates the work to the computeTransactionAttribute()<\/em> method.<\/p>\nFirst it determines the target class (in case the annotation being put on an interface method) then calls the method findTransactionAttribute()<\/em><\/p>\n5) org.springframework.transaction.annotation.AnnotationTransactionAttributeSource<\/strong> extends AbstractFallbackTransactionAttributeSource<\/strong><\/h5>\nPoint E<\/strong><\/p>\n\r\n \/\/ Point E\r\n protected TransactionAttribute findTransactionAttribute(Method method) {\r\n \/\/ See below\r\n return determineTransactionAttribute(method);\r\n }\r\n\r\n protected TransactionAttribute determineTransactionAttribute(AnnotatedElement ae) {\r\n for (TransactionAnnotationParser annotationParser : this.annotationParsers) {\r\n \/\/ (see Point F)\r\n TransactionAttribute attr = annotationParser.parseTransactionAnnotation(ae);\r\n if (attr != null) {\r\n return attr;\r\n }\r\n }\r\n return null;\r\n }\r\n<\/pre>\nAgain the real job is not done here but is delegated to the annotation parser class SpringTransactionAnnotationParser<\/strong> registered previously in the constructor of AnnotationTransactionAttributeSource<\/strong><\/p>\n6) org.springframework.transaction.annotation.SpringTransactionAnnotationParser<\/strong><\/h5>\nPoint F<\/strong><\/p>\n\r\n \/\/ Point F\r\n public TransactionAttribute parseTransactionAnnotation(AnnotatedElement ae) {\r\n Transactional ann = ae.getAnnotation(Transactional.class);\r\n if (ann == null) {\r\n for (Annotation metaAnn : ae.getAnnotations()) {\r\n \/\/ @Transactional annotation\r\n ann = metaAnn.annotationType().getAnnotation(Transactional.class);\r\n if (ann != null) {\r\n break;\r\n }\r\n }\r\n }\r\n if (ann != null) {\r\n \/\/See below\r\n return parseTransactionAnnotation(ann);\r\n }\r\n else {\r\n return null;\r\n }\r\n }\r\n\r\n public TransactionAttribute parseTransactionAnnotation(Transactional ann) {\r\n RuleBasedTransactionAttribute rbta = new RuleBasedTransactionAttribute();\r\n rbta.setPropagationBehavior(ann.propagation().value());\r\n rbta.setIsolationLevel(ann.isolation().value());\r\n rbta.setTimeout(ann.timeout());\r\n rbta.setReadOnly(ann.readOnly());\r\n\r\n \/* Set qualifier name in the case multiple transaction managers are used\r\n * bean id="myTransactionManager" class="org.springframework.orm.jpa.JpaTransactionManager"\r\n * property name="entityManagerFactory" ref="myEntityManagerFactory" \/\r\n * \/bean\r\n *\r\n * @Transactional(value = "myTransactionManager")\r\n *\/\r\n rbta.setQualifier(ann.value());\r\n ArrayList rollBackRules = new ArrayList();\r\n ...\r\n \/\/ Not interesting code\r\n return rbta;\r\n }\r\n\r\n<\/pre>\nThe parser will retrieve all attributes of the @Transactional<\/strong> annotation, among which:<\/p>\n\n- propagation behavior<\/li>\n
- isolation level<\/li>\n
- timeout value for the transaction<\/li>\n
- readOnly<\/strong> flag<\/li>\n
- and the most important attribute of all: value<\/strong>, which corresponds to the bean name of the transactionManager declared in the Spring context and responsible for the current transaction.<\/li>\n<\/ul>\n
\nIf omitted, the value<\/strong> attribute defaults to “transactionManager”<\/strong>. When dealing with multiple databases or multiple datasources applications, more than one transactionManager are defined in the Spring context so the value<\/strong> is important to help Spring choosing the right one.
\n <\/p>\nC Transactional interceptor invocation<\/h2>\n
<\/p>\n
In this chapter we’ll look under the hood to see how Spring achieves transaction demarcations<\/p>\n
\n1) org.springframework.transaction.interceptor.TransactionInterceptor<\/strong> extends TransactionAspectSupport<\/strong>
\n<\/h5>\n\r\n \/\/ The real job is done here\r\n public Object invoke(final MethodInvocation invocation) throws Throwable {\r\n\r\n \/\/ Work out the target class: may be <code>null<\/code>.\r\n \/\/ The TransactionAttributeSource should be passed the target class\r\n \/\/ as well as the method, which may be from an interface.\r\n Class<?> targetClass = (invocation.getThis() != null ?\r\n AopUtils.getTargetClass(invocation.getThis()) : null);\r\n\r\n \/\/ If the transaction attribute is null, the method is non-transactional.\r\n \/\/Similar to Point C\r\n final TransactionAttribute txAttr =\r\n getTransactionAttributeSource().getTransactionAttribute(invocation.getMethod(),\r\n targetClass); \r\n\r\n \/\/ (see Point G)\r\n final PlatformTransactionManager tm = determineTransactionManager(txAttr); \r\n final String joinpointIdentification = methodIdentification(invocation.getMethod(), targetClass);\r\n\r\n \/\/ The txAttr is not null but the transactionManager is NOT an instance \r\n \/\/ of CallbackPreferringPlatformTransactionManager so we still enter the if block\r\n if (txAttr == null || !(tm instanceof CallbackPreferringPlatformTransactionManager)) {\r\n\r\n \/\/ Standard transaction demarcation with getTransaction() and commit\/rollback calls.\r\n \/\/ (see Point H) \r\n TransactionInfo txInfo = createTransactionIfNecessary(tm, txAttr, joinpointIdentification); \r\n\r\n \r\n Object retVal = null;\r\n try {\r\n \/\/ This is an around advice: Invoke the next interceptor in the chain.\r\n \/\/ This will normally result in a target object being invoked.\r\n retVal = invocation.proceed();\r\n }\r\n catch (Throwable ex) {\r\n \/\/ target invocation exception\r\n completeTransactionAfterThrowing(txInfo, ex);\r\n throw ex;\r\n }\r\n finally {\r\n cleanupTransactionInfo(txInfo);\r\n }\r\n \/\/ Commit after the method call returns\r\n \/\/ (see Point O)\r\n commitTransactionAfterReturning(txInfo); \r\n return retVal;\r\n }\r\n<\/pre>\n\n- First Spring retrieves the transaction attributes (line 12, 13 & 14<\/strong>)<\/li>\n
- Then it gets the transaction manager from the Spring context and transaction attributes (line 17<\/strong>)<\/li>\n
- A transaction is created by the underlying entity manager (line 26<\/strong>)<\/li>\n
- The target method is invoked (line 33<\/strong>)<\/li>\n
- After returning from the method invocation, the transaction is committed (line 45<\/strong>)<\/li>\n<\/ul>\n
2) public abstract class org.springframework.transaction.interceptor.TransactionAspectSupport<\/strong><\/h5>\nPoint G & Point H <\/strong><\/p>\n\r\n \/\/Point G\r\n protected PlatformTransactionManager determineTransactionManager(TransactionAttribute txAttr) {\r\n if (this.transactionManager != null || this.beanFactory == null || txAttr == null) {\r\n return this.transactionManager;\r\n }\r\n String qualifier = txAttr.getQualifier();\r\n \r\n \/\/ Case when the transaction manager has been declared directly in the @Transactional annotation\r\n \/\/ Example @Transactional(value = "myTransactionManager")\r\n if (StringUtils.hasLength(qualifier)) {\r\n return TransactionAspectUtils.getTransactionManager(this.beanFactory, qualifier);\r\n }\r\n\r\n \/\/ Case when the transaction manager has been declared in the tx:annotation-driven tag\r\n \/\/ Example tx:annotation driven transaction-manager="myTransactionManager"\r\n else if (this.transactionManagerBeanName != null) {\r\n return this.beanFactory.getBean(this.transactionManagerBeanName,\r\n PlatformTransactionManager.class);\r\n }\r\n ...\r\n \/\/ Not interesting code\r\n \r\n }\r\n\r\n \/\/ Point H\r\n protected TransactionInfo createTransactionIfNecessary(PlatformTransactionManager tm, \r\n TransactionAttribute txAttr, \r\n final String joinpointIdentification) \r\n {\r\n \/\/ If no name specified, apply method identification as transaction name.\r\n \/\/ This is the default case\r\n if (txAttr != null && txAttr.getName() == null) {\r\n txAttr = new DelegatingTransactionAttribute(txAttr) {\r\n @Override\r\n public String getName() {\r\n return joinpointIdentification;\r\n }\r\n };\r\n }\r\n\r\n TransactionStatus status = null;\r\n if (txAttr != null) {\r\n if (tm != null) {\r\n \/\/ Call to the AbstractPlatFormTransactionManager to start a transaction\r\n \/\/ (see Point I)\r\n status = tm.getTransaction(txAttr); \r\n }\r\n else {\r\n if (logger.isDebugEnabled()) {\r\n logger.debug("Skipping transactional joinpoint [" + joinpointIdentification +\r\n "] because no transaction manager has been configured");\r\n }\r\n }\r\n }\r\n return prepareTransactionInfo(tm, txAttr, joinpointIdentification, status);\r\n }\r\n<\/pre>\nThis class is doing 2 main tasks:<\/p>\n
\n- determine the transaction manager to manage the current transaction, either using the value<\/strong> attribute of the @Transactional<\/strong> annotation or using the transaction-manager<\/strong> attribute of the the tx:annotation-driven<\/em> tag <\/li>\n
- delegates the creation of the transaction to the AbstractPlatFormTransactionManager<\/strong> class<\/li>\n<\/ul>\n
\n3) abstract class org.springframework.transaction.support.AbstractPlatformTransactionManager<\/strong>
\n<\/h5>\nPoint I<\/strong><\/p>\n\r\n \/\/Point I\r\n public final TransactionStatus getTransaction(TransactionDefinition definition) throws\r\n TransactionException {\r\n \/\/ Retrieve the transaction from JpaTransactionManager.doGetTransaction()\r\n \/\/ (see Point J)\r\n Object transaction = doGetTransaction();\r\n\r\n \/\/ Cache debug flag to avoid repeated checks.\r\n boolean debugEnabled = logger.isDebugEnabled();\r\n\r\n if (definition == null) {\r\n \/\/ Use defaults if no transaction definition given.\r\n definition = new DefaultTransactionDefinition();\r\n }\r\n\r\n if (isExistingTransaction(transaction)) {\r\n \/\/ Existing transaction found -> check propagation behavior to find out how to behave.\r\n return handleExistingTransaction(definition, transaction, debugEnabled);\r\n }\r\n\r\n ...\r\n\r\n \/\/ No existing transaction found -> check propagation behavior to find out how to proceed.\r\n if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_MANDATORY) {\r\n throw new IllegalTransactionStateException(\r\n "No existing transaction found for transaction marked with propagation 'mandatory'");\r\n }\r\n \/\/ Our case\r\n else if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_REQUIRED ||\r\n definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_REQUIRES_NEW ||\r\n definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NESTED) {\r\n SuspendedResourcesHolder suspendedResources = suspend(null);\r\n if (debugEnabled) {\r\n logger.debug("Creating new transaction with name [" + definition.getName() \r\n + "]: " + definition);\r\n }\r\n try {\r\n boolean newSynchronization = (getTransactionSynchronization() != SYNCHRONIZATION_NEVER);\r\n \/*\r\n * Return a new DefaultTransactionStatus(transaction, \r\n * newTransaction = true,\r\n * newSynchronization = true,\r\n * definition.isReadOnly(),debugEnabled,\r\n * suspendedResources)\r\n * for a new transaction\r\n *\/\r\n DefaultTransactionStatus status = newTransactionStatus(\r\n definition, transaction, true, newSynchronization, \r\n debugEnabled, suspendedResources);\r\n \r\n \/\/ Real job here, delegates call to JpaTransactionManager.doBegin()\r\n \/\/ (see Point K)\r\n doBegin(transaction, definition); \r\n \r\n \/\/ Set some synchronization flags to the TransactionSynchronizationManager thread local\r\n prepareSynchronization(status, definition);\r\n return status;\r\n }\r\n catch (RuntimeException ex) {\r\n resume(null, suspendedResources);\r\n throw ex;\r\n }\r\n catch (Error err) {\r\n resume(null, suspendedResources);\r\n throw err;\r\n }\r\n }\r\n else {\r\n \/\/ TransactionDefinition = PROPAGATION_SUPPORTS or PROPAGATION_NOT_SUPPORTED\r\n \/\/ or PROPAGATION_NEVER\r\n \/\/ Create "empty" transaction: no actual transaction, but potentially synchronization.\r\n boolean newSynchronization = (getTransactionSynchronization() == SYNCHRONIZATION_ALWAYS);\r\n return prepareTransactionStatus(definition, null, true, newSynchronization, \r\n debugEnabled, null);\r\n }\r\n }\r\n<\/pre>\nThe getTransaction()<\/em> delegates the creation and the start of the transaction itself to the underlying JpaTransactionManager<\/strong>.<\/p>\nWe can see here how Spring manages different types of Propagation behavior.<\/p>\n
\n4) org.springframework.orm.jpa.JpaTransactionManager<\/strong><\/h5>\nPoint J & Point K <\/strong><\/p>\n\r\n \/\/Point J\r\n protected Object doGetTransaction() {\r\n JpaTransactionObject txObject = new JpaTransactionObject();\r\n txObject.setSavepointAllowed(isNestedTransactionAllowed());\r\n\r\n \/\/ Try to retrieve an EntityManagerHolder from the thread local map of \r\n \/\/ TransactionSynchronizationManager using the EntityManagerFactory as search key\r\n \/\/ The EntityManagerFactory was injected in the JpaTransactionManager in the XML config file\r\n \/\/\r\n \/\/ bean id="myTransactionManager" class="org.springframework.orm.jpa.JpaTransactionManager"\r\n \/\/ property name="entityManagerFactory" ref="myEntityManagerFactory" \r\n \/\/ bean\r\n \/\/\r\n \/\/\r\n \r\n \/\/ this EntityManagerHolder might be null when called the first time\r\n EntityManagerHolder emHolder = (EntityManagerHolder)\r\n TransactionSynchronizationManager.getResource(getEntityManagerFactory());\r\n if (emHolder != null) {\r\n if (logger.isDebugEnabled()) {\r\n logger.debug("Found thread-bound EntityManager [" +\r\n emHolder.getEntityManager() + "] for JPA transaction");\r\n }\r\n \/\/ attach the EntityManagerHolder to the JpaTransactionObject\r\n \/\/ the flag false is set to the property newEntityManagerHolder\r\n txObject.setEntityManagerHolder(emHolder, false);\r\n }\r\n\r\n \/\/ The datasource is injected directly into the JpaTransactionManager \r\n \/\/ after bean initialization (afterPropertySet())\r\n \/\/ by inspecting the injected EntityManagerFactory\r\n \/\/\r\n \/\/ bean id="myEntityManagerFactory" \r\n \/\/ class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean"\r\n \/\/ property name="dataSource" ref="myDataSource"\r\n \/\/ property name="persistenceUnitName" value="myPersistenceUnit"\r\n \/\/ bean\r\n \/\/\r\n \/\/\r\n \r\n \/\/ this test always evaluates to true\r\n if (getDataSource() != null) {\r\n ConnectionHolder conHolder = (ConnectionHolder)\r\n TransactionSynchronizationManager.getResource(getDataSource());\r\n \/\/ attach a connectionHolder to the JpaTransactionObject (to start JDBC transaction probably)\r\n txObject.setConnectionHolder(conHolder);\r\n }\r\n return txObject;\r\n }\r\n\r\n \/\/Point K\r\n protected void doBegin(Object transaction, TransactionDefinition definition) {\r\n JpaTransactionObject txObject = (JpaTransactionObject) transaction;\r\n\r\n ...\r\n\r\n try {\r\n \r\n \/\/ The EntityManagerHolder can be null if not registered already in the \r\n \/\/ thread local map of TransactionSynchronizationManager\r\n if (txObject.getEntityManagerHolder() == null ||\r\n txObject.getEntityManagerHolder().isSynchronizedWithTransaction()) {\r\n \/\/ Create a new EntityManager from the EntityManagerFactory \r\n EntityManager newEm = createEntityManagerForTransaction();\r\n if (logger.isDebugEnabled()) {\r\n logger.debug("Opened new EntityManager [" + newEm + "] for JPA transaction");\r\n }\r\n\r\n \/\/ attach the EntityManagerHolder to the JpaTransactionObject\r\n \/\/ newEntityManagerHolder = true\r\n \/\/ because the EntityManager has just been created from scratch\r\n txObject.setEntityManagerHolder(new EntityManagerHolder(newEm), true);\r\n }\r\n\r\n EntityManager em = txObject.getEntityManagerHolder().getEntityManager();\r\n final int timeoutToUse = determineTimeout(definition);\r\n\r\n \/* Delegate to JpaDialect for actual transaction begin, passing the EntityManager\r\n * \r\n * META-INF|persistence.xml\r\n *\r\n * persistence-unit name="myPersistenceUnit" transaction-type="RESOURCE_LOCAL"\r\n * provider \r\n * org.hibernate.ejb.HibernatePersistence \r\n * provider\r\n * properties\r\n * property name="hibernate.dialect" value="org.hibernate.dialect.SQLServerDialect"\r\n * ... \r\n *\/\r\n\r\n \/\/ (see Point L for HibernateJpaDialect)\r\n Object transactionData = getJpaDialect().beginTransaction(em,\r\n new DelegatingTransactionDefinition(definition) {\r\n @Override\r\n public int getTimeout() {\r\n return timeoutToUse;\r\n }\r\n });\r\n\r\n \/\/ Set transaction data to the JpaTransactionObject\r\n txObject.setTransactionData(transactionData);\r\n\r\n \/\/ Register transaction timeout.\r\n if (timeoutToUse != TransactionDefinition.TIMEOUT_DEFAULT) {\r\n txObject.getEntityManagerHolder().setTimeoutInSeconds(timeoutToUse);\r\n }\r\n\r\n \/\/ Register the JPA EntityManager's JDBC Connection for the DataSource, if set.\r\n if (getDataSource() != null) {\r\n \/\/ Retrieve the underlying JDBC connection by calling the JPA Dialect class \r\n ConnectionHandle conHandle = getJpaDialect().getJdbcConnection(em, definition.isReadOnly());\r\n if (conHandle != null) {\r\n ConnectionHolder conHolder = new ConnectionHolder(conHandle);\r\n if (timeoutToUse != TransactionDefinition.TIMEOUT_DEFAULT) {\r\n conHolder.setTimeoutInSeconds(timeoutToUse);\r\n }\r\n if (logger.isDebugEnabled()) {\r\n logger.debug("Exposing JPA transaction as JDBC transaction [" + conHolder.getConnectionHandle() + "]");\r\n }\r\n\r\n \/\/ Set the JDBC connection to the current Threadlocal resources map, the \r\n \/\/ datasource being the key \r\n TransactionSynchronizationManager.bindResource(getDataSource(), conHolder);\r\n \r\n \/\/ Set JDBC connection holder to the JpaTransactionObject\r\n txObject.setConnectionHolder(conHolder);\r\n }\r\n else {\r\n if (logger.isDebugEnabled()) {\r\n logger.debug("Not exposing JPA transaction [" + em \r\n + "] as JDBC transaction because JpaDialect [" +\r\n getJpaDialect() + "] does not support JDBC Connection retrieval");\r\n }\r\n }\r\n }\r\n\r\n \/\/ If the EntityManager has been created from scratch (see Point L)\r\n if (txObject.isNewEntityManagerHolder()) {\r\n\r\n \/\/ register the EntityManagerHolder to the current Threadlocal resources map, the EntityManagerFactory being the key\r\n TransactionSynchronizationManager.bindResource(\r\n getEntityManagerFactory(), txObject.getEntityManagerHolder());\r\n }\r\n txObject.getEntityManagerHolder().setSynchronizedWithTransaction(true);\r\n }\r\n\r\n catch (TransactionException ex) {\r\n closeEntityManagerAfterFailedBegin(txObject);\r\n throw ex;\r\n }\r\n catch (Exception ex) {\r\n closeEntityManagerAfterFailedBegin(txObject);\r\n throw new CannotCreateTransactionException("Could not open JPA EntityManager for transaction", ex);\r\n }\r\n }\r\n<\/pre>\nMost of the important jobs are done in this class.<\/p>\n
Point J : doGetTransaction()<\/strong>
\n<\/p>\n\n- \n first Spring tries to look in the TransactionSynchronizationManager<\/strong> ThreadLocal map to see if there is an existing entity manager using the entity manager factory as search key (lines 17 & 18<\/strong>)<\/p>\n
\n- \n The entity manager factory was injected into the Jpa transaction manager in the Spring XML definition.
\nIf this is not done explicitely, Spring will do the job for you during initialization of the transaction manager by looking for a bean named “entityManagerFactory”<\/em> (default name by convention) in the context.<\/p>\n\n- \n If an entity manager is found in the ThreadLocal map, Spring wraps it around an EntityManagerHolder<\/strong> object with a boolean flag isNew = false<\/em> since this entity manager has been created before hand somewhere in the code. (line 26<\/strong>)\n <\/li>\n
- \n Otherwise the EntityManagerHolder<\/strong> of the JpaTransactionObject<\/strong> will be null<\/strong>\n <\/li>\n<\/ul>\n<\/li>\n
- \n Spring also retrieves the dataSource<\/strong> declared for this transaction manager and stores it in the JpaTransactionObject<\/strong> (line 46<\/strong>)\n <\/li>\n<\/ul>\n<\/li>\n
- \n<\/li>\n<\/ul>\n
Point K : doBegin()<\/strong><\/p>\n\n- Spring checks the JpaTransactionObject<\/strong> to look for an EntityManagerHolder<\/strong>.\n
\n- If not found, Spring delegates the creation of the entity manager to the attached entity manager factory (line 65<\/strong>). Then Spring wraps an EntityManagerHolder<\/strong> object around this entity manager with the flag isNew = true<\/em> to indicate that this entity manager was created in the current transaction and not before (line 73<\/strong>)\n <\/li>\n<\/ul>\n<\/li>\n
- Then Spring delegates the creation of a new JDBC transaction to the underlying JPA Dialect (line 91 to 97<\/strong>). This dialect is defined in the META-INF\/persistence.xml<\/strong> file for each persistenceUnit<\/em>\n <\/li>\n
- Spring registers the current JDBC connection to the TransactionSynchronizationManager<\/strong> ThreadLocal map using the dataSource as key (line 125<\/strong>)\n <\/li>\n
- If the flag isNew = true<\/em> is set on the JpaTransactionObject<\/strong>, Spring will also register the newly created entity manager to the TransactionSynchronizationManager<\/strong> ThreadLocal map using the entity manager factory as key.\n <\/li>\n<\/ul>\n
\n5) org.springframework.orm.jpa.HibernateJpaDialect<\/strong> extends DefaultJpaDialect<\/strong>
\n<\/h5>\nPoint L <\/strong><\/p>\n\r\n \/\/ Point L\r\n public Object beginTransaction(EntityManager entityManager, TransactionDefinition definition)\r\n\t\t\tthrows PersistenceException, SQLException, TransactionException {\r\n\r\n\tif (definition.getTimeout() != TransactionDefinition.TIMEOUT_DEFAULT) {\r\n\t\tgetSession(entityManager).getTransaction().setTimeout(definition.getTimeout());\r\n\t}\r\n \/\/ (see Point M)\r\n\tsuper.beginTransaction(entityManager, definition);\r\n\r\n \/\/ (see Point N)\r\n\treturn prepareTransaction(entityManager, definition.isReadOnly(), definition.getName());\r\n} \r\n<\/pre>\nLet’s consider the HibernateJpaDialect<\/strong> as default Jpa dialect. We can see that this class is calling the superclass DefaultJpaDialect<\/strong> to start the transaction (line 9<\/strong>)<\/p>\nThen it calls the internal method prepareTransaction()<\/em> (line 12<\/strong>)<\/p>\n\n6) org.springframework.orm.jpa.DefaultJpaDialect<\/strong>
\n<\/h5>\nPoint M<\/strong><\/p>\n\r\n \/\/ Point M\r\n public Object beginTransaction(EntityManager entityManager, TransactionDefinition definition) \r\n throws PersistenceException, SQLException, TransactionException {\r\n\t\r\n if (definition.getIsolationLevel() != TransactionDefinition.ISOLATION_DEFAULT) {\r\n\t\tthrow new InvalidIsolationLevelException(\r\n "Standard JPA does not support custom isolation levels - " \r\n +"use a special JpaDialect for your JPA implementation");\r\n\t}\r\n\tentityManager.getTransaction().begin();\r\n\treturn null;\r\n} \r\n<\/pre>\nThe transaction is started by the entity manager. We can clearly see that only the default ISOLATION level is supported by vanilla HibernateJpaDialect<\/strong>. Any attempt to set the isolation level to something other that ISOLATION_DEFAULT will trigger an Exception.<\/p>\n\n7) org.springframework.orm.jpa.HibernateJpaDialect<\/strong> extends DefaultJpaDialect<\/strong>
\n<\/h5>\nPoint N<\/strong><\/p>\n\r\n \/\/Point N\r\n public Object prepareTransaction(EntityManager entityManager, boolean readOnly, String name)\t\r\n throws PersistenceException {\r\n\r\n\tSession session = getSession(entityManager);\r\n\tFlushMode flushMode = session.getFlushMode();\r\n\tFlushMode previousFlushMode = null;\r\n\tif (readOnly) {\r\n\t\t\/\/ We should suppress flushing for a read-only transaction.\r\n\t\tsession.setFlushMode(FlushMode.MANUAL);\r\n\t\tpreviousFlushMode = flushMode;\r\n\t}\r\n\telse {\r\n\t\t\/\/ We need AUTO or COMMIT for a non-read-only transaction.\r\n\t\tif (flushMode.lessThan(FlushMode.COMMIT)) {\r\n\t\t\tsession.setFlushMode(FlushMode.AUTO);\r\n\t\t\tpreviousFlushMode = flushMode;\r\n\t\t}\r\n\t}\r\n\treturn new SessionTransactionData(session, previousFlushMode);\r\n }\r\n<\/pre>\nThe prepareTransaction()<\/em> method is setting and saving previous flush mode, nothing more that that…<\/p>\n\n8 ) org.springframework.transaction.interceptor.TransactionAspectSupport<\/strong>
\n<\/h5>\nPoint O<\/strong><\/p>\n\r\n \/\/ Point O\r\n protected void commitTransactionAfterReturning(TransactionInfo txInfo) {\r\n if (txInfo != null && txInfo.hasTransaction()) {\r\n if (logger.isTraceEnabled()) {\r\n logger.trace("Completing transaction for [" + txInfo.getJoinpointIdentification() + "]");\r\n }\r\n \/\/ Delegate the commit call to the underlying TransactioManager\r\n \/\/ (see Point P)\r\n txInfo.getTransactionManager().commit(txInfo.getTransactionStatus());\r\n }\r\n }\r\n<\/pre>\nThis method is just delegating the transaction commit to the transaction manager<\/p>\n
\n9) org.springframework.transaction.support.AbstractPlatformTransactionManager<\/strong>
\n<\/h5>\nPoint P<\/strong><\/p>\n\r\n \/\/ Point P\r\n public final void commit(TransactionStatus status) throws TransactionException {\r\n if (status.isCompleted()) {\r\n throw new IllegalTransactionStateException(Transaction is already completed - do not call commit or rollback more than once per transaction");\r\n }\r\n ... \r\n \/\/ Not interesting code\r\n processCommit(defStatus); \/\/ See below\r\n }\r\n\r\n private void processCommit(DefaultTransactionStatus status) throws TransactionException {\r\n try {\r\n boolean beforeCompletionInvoked = false;\r\n try {\r\n \/\/ Commit pre-processing, not always implemented by the actual TransactionManager\r\n prepareForCommit(status);\r\n triggerBeforeCommit(status);\r\n triggerBeforeCompletion(status);\r\n \u2026\r\n \/\/ Delegate the real commit to the actual TransactionManager\r\n \/\/ (see Point Q)\r\n doCommit(status); \r\n }\r\n ...\r\n try {\r\n \/\/ Commit post-processing, not always implemented by the actual TransactionManager\r\n triggerAfterCommit(status);\r\n }\r\n finally {\r\n triggerAfterCompletion(status, TransactionSynchronization.STATUS_COMMITTED);\r\n }\r\n }\r\n\tfinally {\r\n \/\/ (see Point M)\r\n\t cleanupAfterCompletion(status);\r\n\t}\r\n ...\r\n }\r\n<\/pre>\nAgain, apart from calling some trigger code to prepare the commit, the real job of committing is delegated to the method doCommit()<\/em>
\nAfter the commit is done, cleanupAfterCompletion()<\/em> is called to clean up the TransactionSynchronizationManager<\/strong> ThreadLocal map if necessary<\/p>\n\n10) org.springframework.orm.jpa.JpaTransactionManager<\/strong>
\n<\/h5>\nPoint Q<\/strong><\/p>\n\r\n \/\/Point Q\r\n protected void doCommit(DefaultTransactionStatus status) {\r\n JpaTransactionObject txObject = (JpaTransactionObject) status.getTransaction();\r\n if (status.isDebug()) {\r\n logger.debug("Committing JPA transaction on EntityManager [" +\r\n txObject.getEntityManagerHolder().getEntityManager() + "]");\r\n }\r\n try {\r\n \/\/ The real commit is done here !\r\n EntityTransaction tx = txObject.getEntityManagerHolder().getEntityManager().getTransaction();\r\n tx.commit();\r\n }\r\n catch (RollbackException ex) {\r\n if (ex.getCause() instanceof RuntimeException) {\r\n DataAccessException dex = getJpaDialect().\r\n translateExceptionIfPossible((RuntimeException) ex.getCause());\r\n if (dex != null) {\r\n throw dex;\r\n }\r\n }\r\n throw new TransactionSystemException("Could not commit JPA transaction", ex);\r\n }\r\n catch (RuntimeException ex) {\r\n \/\/ Assumably failed to flush changes to database.\r\n throw DataAccessUtils.translateIfNecessary(ex, getJpaDialect());\r\n }\r\n }\r\n<\/pre>\nAgain, the commit is a plain call to getEntityManager().getTransaction().commit()<\/em>, no magic in it.<\/p>\n\n11) org.springframework.transaction.support.AbstractPlatformTransactionManager<\/strong>
\n<\/h5>\nPoint M<\/strong><\/p>\n\r\n \/\/ Point M\r\n private void cleanupAfterCompletion(DefaultTransactionStatus status) {\r\n\tstatus.setCompleted();\r\n\tif (status.isNewSynchronization()) {\r\n\t\tTransactionSynchronizationManager.clear();\r\n\t}\r\n\tif (status.isNewTransaction()) { \r\n \/\/ (see Point N)\r\n\t\tdoCleanupAfterCompletion(status.getTransaction());\r\n\t}\r\n\tif (status.getSuspendedResources() != null) {\r\n\t\tif (status.isDebug()) {\r\n\t \t logger.debug("Resuming suspended transaction after completion of inner transaction");\r\n\t\t}\r\n\t\tresume(status.getTransaction(), (SuspendedResourcesHolder) \r\n status.getSuspendedResources());\r\n\t}\r\n } \r\n<\/pre>\nJust an indirection of code, the real job is done in doCleanupAfterCompletion()<\/em><\/p>\n\n12) org.springframework.orm.jpa.JpaTransactionManager<\/strong>
\n<\/h5>\nPoint N<\/strong><\/p>\n\r\n \/\/ Point N \r\n protected void doCleanupAfterCompletion(Object transaction) {\r\n\tJpaTransactionObject txObject = (JpaTransactionObject) transaction;\r\n\r\n\t\/\/ Remove the entity manager holder from the thread.\r\n\tif (txObject.isNewEntityManagerHolder()) {\r\n\t\tTransactionSynchronizationManager.unbindResource(getEntityManagerFactory());\r\n\t}\r\n\ttxObject.getEntityManagerHolder().clear();\r\n\r\n\t\/\/ Remove the JDBC connection holder from the thread, if exposed.\r\n\tif (txObject.hasConnectionHolder()) {\r\n\t\tTransactionSynchronizationManager.unbindResource(getDataSource());\r\n\t\ttry {\r\n\t\t\tgetJpaDialect().releaseJdbcConnection(\r\n txObject.getConnectionHolder().getConnectionHandle(),\r\n\t\t\t\t\ttxObject.getEntityManagerHolder().getEntityManager());\r\n\t\t}\r\n\t\tcatch (Exception ex) {\r\n\t\t\t\/\/ Just log it, to keep a transaction-related exception.\r\n\t\t\tlogger.error("Could not close JDBC connection after transaction", ex);\r\n\t\t}\r\n\t}\r\n\tgetJpaDialect().cleanupTransaction(txObject.getTransactionData());\r\n\r\n\t\/\/ Remove the entity manager holder from the thread.\r\n\tif (txObject.isNewEntityManagerHolder()) {\r\n\t\tEntityManager em = txObject.getEntityManagerHolder().getEntityManager();\r\n\t\tif (logger.isDebugEnabled()) {\r\n\t\t\tlogger.debug("Closing JPA EntityManager [" + em + "] after transaction");\r\n\t\t}\r\n\t\tEntityManagerFactoryUtils.closeEntityManager(em);\r\n\t}\r\n\telse {\r\n\t\tlogger.debug("Not closing pre-bound JPA EntityManager after transaction");\r\n\t}\r\n}\r\n<\/pre>\nLots of interesting pieces of code here:<\/p>\n
\n- Line 6 & 7<\/strong> : if the JpaTransactionObject<\/strong> has its flag isNew = true<\/em> then Spring remove its from the TransactionSynchronizationManager<\/strong> ThreadLocal map. Indeed isNew = true<\/em> means that the entity manager was created from scratch for this current transaction and now since the transaction is committed there is no reason to keep it in the ThreadLocal map\n <\/li>\n
<\/p>\n
- \n Similarly, at line 32<\/strong> Spring will close gracefully the entity manager if flag