Home > Tutorials > Bootstrap > TutorialLesson06 |
Interceptors allow arbitrary code to be included in the call stack for your action before and/or after processing the action, which can vastly simplify your code itself and provide excellent opportunities for code reuse. Many of the features of XWork and WebWork are implemented as interceptors and can be applied via external configuration along with your own Interceptors in whatever order you specify for any set of actions you define.
In other words, when you access a *.action
URL, WebWork's ServletDispatcher
proceeds to the invocation of the an action object. Before it is executed, however, the invocation can be intercepted by another object, that is hence called interceptor. To have an interceptor executed before (or after) a given action, just configure xwork.xml
properly, like the example below, taken from lesson 4.1.1:
As you can see, lesson 4.1.1's formProcessing
Action uses the validationWorkflowStack
. That is an interceptor stack, which organizes a bunch of interceptors in the order in which they are to be executed. That stack is configured in webwork-default.xml
, so all we have to do to use it is declare a <interceptor-ref />
under the action configuration or a <default-interceptor-ref />
, under package configuration, as seen in lesson 3's first example:
But let's see how it works from scracth:
com.opensymphony.xwork.interceptor.Interceptor
interface (bundled in xwork-1.0.jar
);xwork.xml
) using the element <interceptor />
nested within <interceptors />
;<interceptor-stack />
element (optional);<interceptor-ref />
or <default-interceptor-ref />
. The former defines the interceptors to be used in a specific action, while the latter determines the default interceptor stack to be used by all actions that do not specify their own <interceptor-ref />
.Looking inside webwork-default.xml
we can see how it's done:
Since we included webwork-default.xml
in our xwork.xml
, all the interceptors and stacks above are available for us to use in our actions. Here's what these interceptors do:
xwork.xml
onto the action. These are the <param />
tags that are direct children of the <action />
tag;ModelDriven
, pushes the getModel()
result onto the Value Stack;Action}-validation.xml
(reference: Validation). We've seen an example of this in lesson 4.1.1;INPUT
view. Good to use together with the validation interceptor (reference: Validation);HttpServletRequest
and HttpServletResponse
(think twice before using this since this ties you to the Servlet API);If none of the above interceptors suit your particular need, you will have to implement your own interceptor. Fortunately, this is an easy task to accomplish. Suppose we need an interceptor that places a greeting in the Session according to the time of the day (morning, afternoon or evening). Here's how we could implement it:
Let's take a look at our interceptor class first. As explained before, the interceptor must implement com.opensymphony.xwork.interceptor.Interceptor
's methods: init()
, called during interceptor initialization, destroy()
, called during destruction, and most importantly, intercept(ActionInvocation invocation)
, which is where we place the code that does the work.
Notice that our interceptor returns the result from invocation.invoke()
which is the method responsible for executing the next interceptor in the stack or, if this is the last one, the action. This means that the interceptor has the power of short-circuiting the action invocation and return a result string without executing the action at all! Use this with caution, though.
One other thing that interceptors can do is execute code after the action has executed. To do that, just place code after the invocation.invoke() call. WebWork provides an abstract class that already implements this kind of behaviour: com.opensymphony.xwork.interceptor.AroundInterceptor
. Just extend it and implement the methods before(ActionInvocation invocation)
and after(ActionInvocation dispatcher, String result)
.
The xwork.xml
configuration, the action class and the result page are pretty straightforward and require no further explanation.