1) Login.execute() line: 28
2) DefaultActionInvocation.invokeAction(Object, ActionConfig) line: 452
3) DefaultActionInvocation.invokeActionOnly() line: 291
4) DefaultActionInvocation.invoke() line: 254
5) liasInterceptor.intercept(ActionInvocation) line: 190
6) DefaultActionInvocation.invoke() line: 248
7) ExceptionMappingInterceptor.intercept(ActionInvocation) line: 187
8) DefaultActionInvocation.invoke() line: 248
9) StrutsActionProxy.execute() line: 52
10) Dispatcher.serviceAction(HttpServletRequest, HttpServletResponse, ServletContext, ActionMapping) line: 485
11) ExecuteOperations.executeAction(HttpServletRequest, HttpServletResponse, ActionMapping) line: 77
12) StrutsPrepareAndExecuteFilter.doFilter(ServletRequest, ServletResponse, FilterChain) line: 91
1) StrutsPrepareAndExecuteFilter
Handles both the preparation and execution phases of the Struts dispatching process. This filter is better to use when you don't have another filter that needs access to action context information, such as Sitemesh.
public void doFilter(ServletRequest req, ServletResponse res, FilterChain chain) throws IOException, ServletException {
HttpServletRequest request = (HttpServletRequest) req;
HttpServletResponse response = (HttpServletResponse) res;
try {
prepare .setEncodingAndLocale(request, response);
prepare .createActionContext(request, response);
prepare .assignDispatcherToThread();
if ( excludedPatterns != null && prepare .isUrlExcluded(request, excludedPatterns )) {
chain.doFilter(request, response);
} else {
request = prepare .wrapRequest(request);
ActionMapping mapping = prepare .findActionMapping(request, response, true );
if (mapping == null ) {
boolean handled = execute .executeStaticResourceRequest(request, response);
if (!handled) {
chain.doFilter(request, response);
}
} else {
execute .executeAction(request, response, mapping);
}
}
} finally {
prepare .cleanupRequest(request);
}
}
2) ExecuteOperations
public void executeAction(HttpServletRequest request, HttpServletResponse response, ActionMapping mapping) throws ServletException {
dispatcher .serviceAction(request, response , servletContext , mapping);
}
3) dispatcher
A utility class the actual dispatcher delegates most of its tasks to. Each instance of the primary dispatcher holds an instance of this dispatcher to be shared for all requests.
public void serviceAction(HttpServletRequest request, HttpServletResponse response, ServletContext context,
ActionMapping mapping) throws ServletException {
Map<String, Object> extraContext = createContextMap(request, response, mapping, context);
// If there was a previous value stack, then create a new copy and pass it in to be used by the new Action
ValueStack stack = (ValueStack) request.getAttribute(ServletActionContext. STRUTS_VALUESTACK_KEY );
boolean nullStack = stack == null ;
if (nullStack) {
ActionContext ctx = ActionContext.getContext ();
if (ctx != null ) {
stack = ctx.getValueStack();
}
}
if (stack != null ) {
extraContext.put(ActionContext. VALUE_STACK , valueStackFactory .createValueStack(stack));
}
String timerKey = "Handling request from Dispatcher" ;
try {
UtilTimerStack.push (timerKey);
String namespace = mapping.getNamespace();
String name = mapping.getName();
String method = mapping.getMethod();
Configuration config = configurationManager .getConfiguration();
ActionProxy proxy = config.getContainer().getInstance(ActionProxyFactory. class ).createActionProxy(
namespace, name, method, extraContext, true , false );
request.setAttribute(ServletActionContext. STRUTS_VALUESTACK_KEY , proxy.getInvocation().getStack());
// if the ActionMapping says to go straight to a result, do it!
if (mapping.getResult() != null ) {
Result result = mapping.getResult();
result.execute(proxy.getInvocation());
} else {
proxy.execute();
}
// If there was a previous value stack then set it back onto the request
if (!nullStack) {
request.setAttribute(ServletActionContext. STRUTS_VALUESTACK_KEY , stack);
}
} catch (ConfigurationException e) {
// WW-2874 Only log error if in devMode
if ( devMode ) {
String reqStr = request.getRequestURI();
if (request.getQueryString() != null ) {
reqStr = reqStr + "?" + request.getQueryString();
}
LOG .error( "Could not find action or result/n" + reqStr, e);
}
else {
LOG .warn( "Could not find action or result" , e);
}
sendError(request, response, context, HttpServletResponse. SC_NOT_FOUND , e);
} catch (Exception e) {
sendError(request, response, context, HttpServletResponse. SC_INTERNAL_SERVER_ERROR , e);
} finally {
UtilTimerStack.pop (timerKey);
}
}
4) StrutsActionProxy
5) StrutsActionProxy
public String execute() throws Exception {
ActionContext previous = ActionContext.getContext ();
ActionContext.setContext ( invocation .getInvocationContext());
try {
// This is for the new API:
// return RequestContextImpl.callInContext(invocation, new Callable <String>() {
// public String call() throws Exception {
// return invocation.invoke();
// }
// });
return invocation .invoke();
} finally {
if ( cleanupContext )
ActionContext.setContext (previous);
}
}
6) DefaultActionInvocation
public String invoke() throws Exception {
String profileKey = "invoke: " ;
try {
UtilTimerStack.push (profileKey);
if ( executed ) {
throw new IllegalStateException( "Action has already executed" );
}
if ( interceptors .hasNext()) {
final InterceptorMapping interceptor = (InterceptorMapping) interceptors .next();
String interceptorMsg = "interceptor: " + interceptor.getName();
UtilTimerStack.push (interceptorMsg);
try {
resultCode = interceptor.getInterceptor().intercept(DefaultActionInvocation. this );
}
finally {
UtilTimerStack.pop (interceptorMsg);
}
} else {
resultCode = invokeActionOnly();
}
// this is needed because the result will be executed, then control will return to the Interceptor , which will
// return above and flow through again
if (! executed ) {
if ( preResultListeners != null ) {
for (Object preResultListener : preResultListeners ) {
PreResultListener listener = (PreResultListener) preResultListener;
String _profileKey = "preResultListener: " ;
try {
UtilTimerStack.push (_profileKey);
listener.beforeResult( this , resultCode );
}
finally {
UtilTimerStack.pop (_profileKey);
}
}
}
// now execute the result, if we're supposed to
if ( proxy .getExecuteResult()) {
executeResult();
}
executed = true ;
}
return resultCode ;
}
finally {
UtilTimerStack.pop (profileKey);
}
}
public String invokeActionOnly() throws Exception {
return invokeAction(getAction(), proxy.getConfig());
}
protected String invokeAction(Object action, ActionConfig actionConfig) throws Exception {
String methodName = proxy .getMethod();
if ( LOG .isDebugEnabled()) {
LOG .debug( "Executing action method = " + actionConfig.getMethodName());
}
String timerKey = "invokeAction: " + proxy .getActionName();
try {
UtilTimerStack.push (timerKey);
boolean methodCalled = false ;
Object methodResult = null ;
Method method = null ;
try {
method = getAction().getClass().getMethod(methodName, EMPTY_CLASS_ARRAY );
} catch (NoSuchMethodException e) {
// hmm -- OK, try doXxx instead
try {
String altMethodName = "do" + methodName.substring(0, 1).toUpperCase() + methodName.substring(1);
method = getAction().getClass().getMethod(altMethodName, EMPTY_CLASS_ARRAY );
} catch (NoSuchMethodException e1) {
// well, give the unknown handler a shot
if ( unknownHandlerManager .hasUnknownHandlers()) {
try {
methodResult = unknownHandlerManager .handleUnknownMethod(action, methodName);
methodCalled = true ;
} catch (NoSuchMethodException e2) {
// throw the original one
throw e;
}
} else {
throw e;
}
}
}
if (!methodCalled) {
methodResult = method.invoke(action, new Object[0]);
}
if (methodResult instanceof Result) {
this . explicitResult = (Result) methodResult;
// Wire the result automatically
container .inject( explicitResult );
return null ;
} else {
return (String) methodResult;
}
} catch (NoSuchMethodException e) {
throw new IllegalArgumentException( "The " + methodName + "() is not defined in action " + getAction().getClass() + "" );
} catch (InvocationTargetException e) {
// We try to return the source exception.
Throwable t = e.getTargetException();
if ( actionEventListener != null ) {
String result = actionEventListener .handleException(t, getStack());
if (result != null ) {
return result;
}
}
if (t instanceof Exception) {
throw (Exception) t;
} else {
throw e;
}
} finally {
UtilTimerStack.pop (timerKey);
}
}
7) Login
public String execute() throws Exception {
if (isInvalid(getUsername())) return INPUT ;
if (isInvalid(getPassword())) return INPUT ;
return SUCCESS ;
}
