<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
<bean id="shoppingCart" class="org.springframework.aop.target.scope.ScopedProxyFactoryBean"
singleton="false">
<property name="scopeKey" value="shoppingCart"/>
<property name="targetBeanName" value="__shoppingCart"/>
<property name="scopeMap">
<bean class="org.springframework.web.context.scope.SessionScopeMap"/>
</property>
</bean>
<bean id="__shoppingCart" class="com.opensymphony.webwork.example.ajax.cart.DefaultCart"
singleton="false"/>
</beans>

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:aop="http://www.springframework.org/schema/aop"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">
<bean id="catalog" class="com.opensymphony.webwork.example.ajax.catalog.TestCatalog"
singleton="true"/>
<bean id="shoppingCart" class="com.opensymphony.webwork.example.ajax.cart.DefaultCart"
singleton="true">
<aop:scope type="session"/>
</bean>
</beans>

<filter>
<filter-name>springFilter</filter-name>
<filter-class>org.springframework.web.filter.RequestContextFilter</filter-class>
</filter>
<filter-mapping>
<filter-name>springFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>

package org.tuxbot.webwork.spring;
/* Portions Copyright 2005 The JA-SIG Collaborative.  All rights reserved.
*  See license distributed with this file and
*  available online at http://www.uportal.org/license.html
 */
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.aop.target.AbstractPrototypeBasedTargetSource;
import org.springframework.beans.factory.DisposableBean;
import com.opensymphony.xwork.ActionContext;
import java.util.Map;
/**
* This target source is to be used in collaberation with WebWork.
* The target source binds the target bean to the Session retrieved from
* WebWork. By default the bean is bound to the session
* using the name of the target bean as part of the key. This can be overridden by setting
* the <code>sessionKey</code> property to a not null value.
*
* @author Eric Dalquist <a href="mailto:edalquist@unicon.net">edalquist@unicon.net</a>
* @author Eric Molitor <a href="mailto:eric@tuxbot.com">eric@tuxbot.com</a>
* @version 1.0
*/
public class WebWorkTargetSource extends AbstractPrototypeBasedTargetSource implements DisposableBean {
private final static Log LOG = LogFactory.getLog(WebWorkTargetSource.class);
private transient Object noSessionInstance = null;
private String sessionKey = null;
private String compiledSessionKey = null;
public WebWorkTargetSource() {
this.updateBeanKey();
}
/**
* @return Returns the sessionKey.
*/
public String getSessionKey() {
return this.sessionKey;
}
/**
* @param sessionKey The sessionKey to set.
*/
public void setSessionKey(String sessionKey) {
this.sessionKey = sessionKey;
this.updateBeanKey();
}
/**
* @see org.springframework.aop.target.AbstractBeanFactoryBasedTargetSource#setTargetBeanName(java.lang.String)
*/
public void setTargetBeanName(String targetBeanName) {
super.setTargetBeanName(targetBeanName);
this.updateBeanKey();
}
/**
* @see org.springframework.aop.TargetSource#getTarget()
*/
public Object getTarget() throws Exception {
final Map session = ActionContext.getContext().getSession();
if (session == null) {
LOG.warn("No Session found for thread '" + Thread.currentThread().getName() + "'");
if (this.noSessionInstance == null) {
this.noSessionInstance = this.newPrototypeInstance();
if (LOG.isDebugEnabled()) {
LOG.debug("Created instance of '" + this.getTargetBeanName() + "', not bound to any webWorkSession.");
}
}
else {
if (LOG.isDebugEnabled()) {
LOG.debug("Found instance of '" + this.getTargetBeanName() + "', not bound to any webWorkSession.");
}
}
return this.noSessionInstance;
}
else {
String beanKey = this.compiledSessionKey;
Object instance = session.get(beanKey);
if (instance == null) {
instance = this.newPrototypeInstance();
session.put(beanKey, instance);
if (LOG.isDebugEnabled()) {
LOG.debug("Created instance of '" + this.getTargetBeanName() + "', bound to webWorkSession for '"
+ Thread.currentThread().getName() + "' using key '" + beanKey + "'.");
}
}
else if (LOG.isDebugEnabled()) {
LOG.debug("Found instance of '" + this.getTargetBeanName() + "', bound to webWorkSession for '"
+ Thread.currentThread().getName() + "' using key '" + beanKey + "'.");
}
return instance;
}
}
/**
* @see org.springframework.beans.factory.DisposableBean#destroy()
*/
public void destroy() throws Exception {
if (this.noSessionInstance != null && this.noSessionInstance instanceof DisposableBean) {
if (LOG.isDebugEnabled()) {
LOG.debug("Destroying sessionless bean instance '" + this.noSessionInstance + "'");
}
((DisposableBean)this.noSessionInstance).destroy();
}
}
/**
* Generates the key to store the bean in the session with.
*/
private void updateBeanKey() {
if (this.sessionKey == null) {
final StringBuffer buff = new StringBuffer();
buff.append(this.getClass().getName());
buff.append("_");
buff.append(this.getTargetBeanName());
this.compiledSessionKey = buff.toString();
}
else {
this.compiledSessionKey = this.sessionKey;
}
}
}

package net.itneering.core.spring.session;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.BeanFactoryAware;
import com.opensymphony.xwork.ActionContext;
import java.util.Map;
import java.io.Serializable;
/**
* SessionBackedBeanFactory tries to lookup beans by name in XWork session. If not found,
* it tries to instantiate new bean and attaches it to said session.
*
* @author <a href="mailto:gielen@it-neering.net">Rene Gielen</a>
*/
public class SessionBackedBeanFactory implements Serializable, BeanFactoryAware {
BeanFactory beanFactory = null;
/**
* Find a component by name in session scoped storage implementation. If not found, try to instantiate new one by
* {@link org.springframework.beans.factory.BeanFactory#getBean(String)}. Then found component will be attached
* to session store implementation.
*
* @param componentName
* @return The requested component, if found.
*/
public Object getSessionComponent( String componentName ) {
Object result = getSession().get(componentName);
if ( result == null ) {
result = beanFactory.getBean(componentName);
storeComponent(componentName, result);
}
return result;
}
public void storeComponent(String componentName, Object component ) {
getSession().put(componentName, component);
}
/**
* Actual implementation of the session scoped storage Map.
* Lookup {@link com.opensymphony.xwork.ActionContext#getSession()}.
*
* @return The Map for keeping session objects.
*/
public Map getSession() {
return ActionContext.getContext().getSession();
}
/**
* Callback that supplies the owning factory to a bean instance.
* <p>Invoked after population of normal bean properties but before an init
* callback like InitializingBean's afterPropertiesSet or a custom init-method.
*
* @param beanFactory owning BeanFactory (may not be null).
*                    The bean can immediately call methods on the factory.
*
* @throws org.springframework.beans.BeansException
*          in case of initialization errors
* @see org.springframework.beans.factory.BeanInitializationException
*/
public void setBeanFactory( BeanFactory beanFactory ) throws BeansException {
this.beanFactory = beanFactory;
}
}

<?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="byName">
<bean id="sessionBeanProxy" class="net.itneering.core.spring.session.SessionBackedBeanFactory" singleton="true"/>
<bean id="securityContextComponent" class="net.itneering.security.component.DefaultSecurityContextComponent" singleton="false" />
</beans>

package net.itneering.xwork.action;
import com.opensymphony.xwork.ActionSupport;
import net.itneering.core.spring.session.SessionBackedBeanFactory;
import net.itneering.security.component.DefaultSecurityContextComponent;
/**
* Simple sessionBeanProxy aware action.
*
* @author <a href="mailto:gielen@it-neering.net">Rene Gielen</a>
* @version $Revision: 1.1 $
*/
public class SecurityAwareAction extends ActionSupport implements PrincipalAware {
private static final Logger log = Logger.getLogger(SecurityAwareAction.class);
protected SessionBackedBeanFactory sessionBeanProxy;
/**
* For Spring wiring usage.
*
* @param sessionBeanProxy The sessionBeanProxyto use.
*/
public void setSessionBeanProxy( SessionBackedBeanFactory sessionBeanProxy ) {
this.sessionBeanProxy = sessionBeanProxy;
}
/**
* Getter for actions security context.
*
* @return The securityContextComponent set by IoC.
*/
public SecurityContextComponent getSecurityContextComponent() {
return sessionBeanProxy!= null ? sessionBeanProxy.getSessionComponent("securityContextComponent") : null;
}
/**
* Get the current User Principal for this session.
*
* @return The User Principal.
*/
public UserEntity getPrincipal() {
try {
return getSecurityContextComponent().getPrincipal();
} catch ( NullPointerException e ) {
return null;
}
}
...
}

package net.itneering.security.component;
import net.itneering.core.spring.session.SessionBackedBeanFactory;
/**
* SecurityAwareSessionBeanProxy.
*
* @author <a href="mailto:gielen@it-neering.net">Rene Gielen</a>
*/
public class SecurityAwareSessionBeanProxy extends SessionBackedBeanFactory {
String securityContextComponentName = "securityContextComponent";
/**
* Make component name configurable by spring setup
*/
public void setSecurityContextComponentName( String securityContextComponentName ) {
this.securityContextComponentName = securityContextComponentName;
}
public SecurityContextComponent getSecurityContextComponent() {
return (SecurityContextComponent) getSessionComponent(securityContextComponentName);
}
}

<?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="byName">
<bean id="mySecurityContextComponent" class="net.itneering.security.component.DefaultSecurityContextComponent" singleton="false" />
<bean id="sessionBeanProxy" class="net.itneering.security.component.SecurityAwareSessionBeanProxy" singleton="true">
<property name="securityContextComponentName" value="mySecurityContextComponent" />
</bean>
</beans>

package net.itneering.xwork.action;
import com.opensymphony.xwork.ActionSupport;
import net.itneering.security.component.SecurityAwareSessionBeanProxy;
import net.itneering.security.component.DefaultSecurityContextComponent;
/**
* Simple sessionBeanProxy aware action.
*
* @author <a href="mailto:gielen@it-neering.net">Rene Gielen</a>
* @version $Revision: 1.1 $
*/
public class SecurityAwareAction extends ActionSupport implements PrincipalAware {
private static final Logger log = Logger.getLogger(SecurityAwareAction.class);
protected SecurityAwareSessionBeanProxy sessionBeanProxy;
/**
* For Spring wiring usage.
*
* @param sessionBeanProxy The sessionBeanProxy to use.
*/
public void setSessionBeanProxy( SecurityAwareSessionBeanProxy sessionBeanProxy ) {
this.sessionBeanProxy = sessionBeanProxy;
}
/**
* Get the current User Principal for this session.
*
* @return The User Principal.
*/
public UserEntity getPrincipal() {
try {
return sessionBeanProxy.getSecurityContextComponent().getPrincipal();
} catch ( NullPointerException e ) {
return null;
}
}
...
}

webwork.objectFactory = spring

webwork.objectFactory.spring.autoWire = type

<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"/>
...
</beans>

<!DOCTYPE xwork PUBLIC "-//OpenSymphony Group//XWork 1.0//EN" "http://www.opensymphony.com/xwork/xwork-1.1.dtd">
<xwork>
<include file="webwork-default.xml"/>
<package name="default" extends="webwork-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>
</xwork>

<?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>

package org.petsoar.actions.inventory;
import com.mockobjects.constraint.IsEqual;
import com.mockobjects.dynamic.C;
import com.mockobjects.dynamic.Mock;
import com.opensymphony.xwork.Action;
import junit.framework.TestCase;
import org.petsoar.pets.Pet;
import org.petsoar.pets.PetStore;
public class TestViewPet extends TestCase {
private Mock mockPetStore;
private ViewPet action;
protected void setUp() throws Exception {
mockPetStore = new Mock(PetStore.class);
PetStore petStore = (PetStore) mockPetStore.proxy();
action = new ViewPet();
action.setPetStore(petStore);
}
public void testViewPet() throws Exception {
Pet existingPet = new Pet();
existingPet.setName("harry");
existingPet.setId(1);
Pet expectedPet = new Pet();
expectedPet.setName("harry");
expectedPet.setId(1);
mockPetStore.expectAndReturn("getPet", C.args(new IsEqual(new Long(1))), existingPet);
action.setId(1);
String result = action.execute();
assertEquals(Action.SUCCESS, result);
assertEquals(expectedPet, existingPet);
mockPetStore.verify();
}
public void testViewPetNoId() throws Exception {
mockPetStore.expectAndReturn("getPet", C.ANY_ARGS, null);
String result = action.execute();
assertEquals(Action.ERROR, result);
assertEquals(1, action.getActionErrors().size());
assertEquals("Invalid pet selected.", action.getActionErrors().iterator().next());
assertNull(action.getPet());
mockPetStore.verify();
}
public void testViewPetInvalidId() throws Exception {
action.setId(-1);
testViewPetNoId();
}
}

public void testDoesNotAllowMethodInvocations() {
Map params = new HashMap();
params.put("@java.lang.System@exit(1).dummy", "dumb value");
HashMap extraContext = new HashMap();
extraContext.put(ActionContext.PARAMETERS, params);
try {
ActionProxy proxy = ActionProxyFactory.getFactory().
createActionProxy("", MockConfigurationProvider.MODEL_DRIVEN_PARAM_TEST, extraContext);
assertEquals(Action.SUCCESS, proxy.execute());
ModelDrivenAction action = (ModelDrivenAction) proxy.getAction();
TestBean model = (TestBean) action.getModel();
String property = System.getProperty("webwork.security.test");
assertNull(property);
} catch (Exception e) {
e.printStackTrace();
fail();
}
}