|Table of Contents|
Spring is a lightweight container, providing centralized, automated configuration and wiring of your application objects, using a technique called "Dependency Injection"
Spring integration is provided by a Struts Plugin.
The Spring Plugin works by overriding the Struts ObjectFactory to enhance the creation of core framework objects. When an object is to be created, it uses the
class attribute in the Struts configuration to correspond to the
id attribute in the Spring configuration. If not found, the class will try to be created as usual, then be autowired by Spring. In the case of Actions, Spring 2's bean scope feature can be used to scope an Action instance to the session, application, or a custom scope, providing advanced customization above the default per-request scoping.
Remember: registering Actions with Spring is not required. The Spring alternative is there if you need it, but the framework will automatically create Actions objects from the action mappings. But, if you want to use Spring to inject your Actions, the option is there.
- Allow Actions, Interceptors, and Results to be created by Spring
- Struts-created objects can be autowired by Spring after creation
- Provides two interceptors that autowire actions, if not using the Spring ObjectFactory
To enable Spring integration, simply include struts2-spring-plugin-x-x-x.jar in your application.
If you are using more than one object factory, (for example, by including both the Spring and Plexus plugins in your application,) you will need to set the struts.objectFactory property in struts.properties or in one of several XML files via Constant Configuration:
struts.objectFactory = spring
<struts> <constant name="struts.objectFactory" value="spring" /> ... </struts>
The framework enables "autowiring" by default. (Autowiring means to look for objects defined in Spring with the same name as your object property). To change the wiring mode, modify the
Auto-wire by matching the name of the bean in Spring with the name of the property in your action. This is the default
Auto-wire by looking for a bean registered with Spring of the same type as the property in your action. This requires you to have only one bean of this type registered with Spring
Spring will attempt to auto-detect the best method for auto-wiring your action
Spring will auto-wire the parameters of the bean's constructor
Turn off externally defined autowiring. Annotation-driven injection and injection based on Springs *Aware-interfaces still applies
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.
<listener> <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class> </listener>
<?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd"> <beans default-autowire="autodetect"> <bean id="personManager" class="com.acme.PersonManager" scope="prototype"/> ... </beans>
Since the Spring integration uses a standard Listener, it can be configured to support configuration files other than
See the Spring documentation for a full description of this parameter.
Initializing Actions from Spring
struts.xml you specify the class for each Action. When using the default SpringObjectFactory, the framework will ask Spring to create the Action and wire up dependencies as specified by the default auto-wire behavior.
<!DOCTYPE struts PUBLIC "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN" "http://struts.apache.org/dtds/struts-2.0.dtd"> <struts> <include file="struts-default.xml"/> <package name="default" extends="struts-default"> <action name="foo" class="com.acme.Foo"> <result>foo.ftl</result> </action> </package> <package name="secure" namespace="/secure" extends="default"> <action name="bar" class="bar"> <result>bar.ftl</result> </action> </package> </struts>
<?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd"> <beans default-autowire="autodetect"> <bean id="bar" class="com.my.BarClass" singleton="false"/> ... </beans>
How the code works
idattribute in the Spring configuration corresponds to the class attribute in the action configuration.
singletonattribute is set to
false, meaning that Spring will create a new Action class upon each request, as Struts 1 would do.
|title||Spring Actions are Optional!|
To use session-scoped components with Spring and Struts, see the Spring Session Components Workarounds analysis.
The Spring plugin can be configured to automatically reload classes that change in the file system. This feature will enable code changes to be "hot deployed" without having to restart the web container. To enable this feature follow these steps:
- Set "struts.devMode" to "true"
- Set "struts.class.reloading.watchList" to a comma separated list of directories, or jar files (absolute or relative paths)
Add this to web.xml:
Code Block type xml
<context-param> <param-name>contextClass</param-name> <param-value>org.apache.struts2.spring.ClassReloadingXMLWebApplicationContext</param-value> </context-param>
Add Apache Commons JCI FAM to the classpath. If you are using maven, add this to pom.xml
Code Block type xml
<dependency> <groupId>org.apache.commons</groupId> <artifactId>commons-jci-fam</artifactId> <version>1.0</version> </dependency>
Letting the reloading class loader handle all the classes can lead to ClassCastException(s) because instances of the same classes loaded by different class loaders can not be assigned to each other. To prevent this problem we suggest that
struts.class.reloading.acceptClasses is used to limit the classes loaded by the reloading class loader, so only actions are handled by it. This constant supports a comma separated list of regular expressions:
<constant name="struts.class.reloading.acceptClasses" value="com\.myproject\.example\.actions\..*" />
This feature is experimental, and should never be used in production systems.
The following settings can be customized. See the developer guide.
The autowire strategy
Whether the autowire strategy should always be used, or if the framework should try to guess the best strategy based on the situation
Whether to have Spring use its class cache or not
List of jar files or directories to watch for changes
Comma separated list of absolute or relative paths to jars or directories
List of regular expressions of accepted class names
Comma separated list of regular expressions of classes that will be loaded by the reloading class loader(we suggest to add regular expressions so only action classes are handled by the reloading class loader)
Reload the runtime configuration (action mappings, results etc) when a change is detected in one of the watched directories
Uses different logic to construct beans to allow support AOP, it uses an old approach to create a bean, switch this flag if you have problems with Spring beans and AOP
This plugin can be installed by copying the plugin jar into your application's
/WEB-INF/lib directory. No other files need to be copied or created.