20090320 (Spring integration)

Integrate with Struts:

Spring plugin features:
1.Allow Actions, Interceptors, and Results to be created by Spring
2.Struts-created objects can be autowired by Spring after creation
3.Provides two interceptors that autowire actions, if not using the Spring ObjectFactory

To enable spring plugin:
1.Include struts2-spring-plugin-x-x-x.ja in classpath
2.If you are using more than one object factory, use:
struts.objectFactory = org.apache.struts2.spring.StrutsSpringObjectFactory
or
<constant name="struts.objectFactory" value="org.apache.struts2.spring.StrutsSpringObjectFactory" />

Settings:
struts.objectFactory.spring.autoWire:
The autowire strategy name name,type,auto, or constructor
struts.objectFactory.spring.autoWire.alwaysRespect:
Whether the autowire strategy should always be used, or if the framework should try to guess the best strategy based on the situation false for backwards-compatibility  true or false
struts.objectFactory.spring.useClassCache:
Whether to have Spring use its class cache or not true true or false

Sets the "class" attribute to a spring bean id, by default, the framework will at least try to use Spring to create all its objects. If the object cannot be created by Spring, then the framework will create the object itself.

Struts will use WebApplicationContext created by org.springframework.web.context.ContextLoaderListener, remember to use singleton="false" for action object.

2 interceptors provided by spring plugin are ActionAutowiringInterceptor and SessionContextAutowiringInterceptor.

Integrate with Hiberate:

org.springframework.beans.factory contains interfaces implemented by special beans, e.g. FactoryBean, BeanNameAware.

org.springframework.orm.hibernate3.LocalSessionFactoryBean is a factory bean, it creates a hibernate SessionFactory. It provides setter using which you can configurate hibernate, these setters including: mappingResources, hibernateProperties, configLocations and so on.

HibernateTemplate and HibernateDaoSupport just add support for exception wrapping, which wrap hibernate exception into spring dao exception.

you can use raw hibernate API while still participate in spring's transaction management

Use Spring managed transaction:

TransactionDefinition, defines: name, readOnly, timeout, isolationLevel, propagationBehavior.
TransactionStatus, status (boolean): hasSavePoint, isCompleted, isNewTransaction, isRollbackOnly; method: setRollbackOnly.
PlatformTransactionManager:
// may or may not create a new transaction, depends on whether there's an outter transaction and how TransactionDefinition is defined.
TransactionStatus status = manager.getTransaction(definition);
try {
    ...
    if (status.isRollbackOnly()) {
 manager.rollback(status);
    } else {
        manager.commit(status);
    }
} catch (Exception e) {
    // may has code to determine whether to rollback or commit base on rollbackFor/notRollbackFor
    manager.rollback(status);
}

Propagtion level: MANDATORY, REQUIRED, REQUIRES_NEW, NOT_SUPPORTED, SUPPORTS, NEVER, NESTED
Inside a (top-level or nested?) transaction?
What will happen? throw exception / do nothing / create a new (maybe nested) transaction / suspend current transaction

To enable spring managed transaction:
1.Define transaction manager bean:
<bean id="txManager" class="org.springframework.orm.hibernate.HibernateTransactionManager">
  <property name="sessionFactory" ref="sessionFactory" />
</bean>
2.Define an advice, the "tx:method" just associate method with transaction definition and (not) rollback for.
<tx:advice id="txAdvice">
  <tx:attributes>
    <tx:method name="get*" read-only="true"/>
    <tx:method name="*"/>
   </tx:attributes>
</tx:advice>
3.Define advisor and pointcut
<aop:config>
  <aop:pointcut id="serviceOperation" expression="execution(* x.y.service..*Service.*(..))"/>
  <aop:advisor pointcut-ref="serviceOperation" advice-ref="txAdvice"/>
</aop:config>

To enable annotation based transaction management:
1.Define transaction manager bean.
2.Marked as annotation driven.
<tx:annotation-driven transaction-manager="txManager"/>
3.Place @Transactional annotation before an interface definition, a method on an interface, a class definition, or a public method on a class.

You certainly can place the @Transactional annotation on an interface (or an interface method), but this will only work as you would expect it to if you are using interface-based proxies.
Method annotation will overrides class annotation.
@Transactional settings are the same as advice

How to define a default transaction isolation level?
Seems no way to set a default value using spring, using mysql+innodb, postgresql or oracle, the default is read committed.