Interceptor Implementation Principle

Interceptors (Interceptor) are one of the most powerful features of Struts2, and can be said to be the core of struts2, which allows you to do some processing before or after action and result are executed. At the same time, interceptors allow you to modularize generic Code and act as a reusable class. Many of the features in Struts2 are done by interceptors. Interception is an implementation strategy of AOP. The Chinese document in WebWork is interpreted as: Interceptors are objects that dynamically intercept action calls. It provides a mechanism to enable developers to define code that executes before and after an action executes, or to prevent it from executing before an action executes. It also provides a way to extract the reusable parts of an action. When it comes to interceptors, there's one more word you should know-the interceptor chain (Interceptor Chain, called the Interceptor stack interceptor stack in struts 2). The Interceptor chain is a chain that binds the interceptor in a certain order. When accessing an intercepted method or field, interceptors in the interceptor chain are called in the order in which they were previously defined.

A The implementation principle of interceptors:

Most of the time, the Interceptor method is invoked in the form of proxies. The block implementation of Struts 2 is relatively straightforward. When the request arrives at the servletdispatcher of Struts 2, struts 2 looks for the configuration file, instantiates the relative interceptor object based on its configuration, and then strings it into a list, the last one to invoke the interceptor in the list. In fact, the reason we are able to use interceptors so flexibly is due to the use of dynamic agents . A dynamic agent is a proxy object that makes different processing based on the customer's needs. For the customer, just know a proxy object on the line. In that Struts2, How is the interceptor invoked through a dynamic proxy ? When the action request arrives, an action proxy object is generated by the agent of the system, which invokes the action's execute () or the specified method, and finds the interceptor corresponding to the action in Struts.xml. If there is a corresponding interceptor, these interceptors are called before the action's method executes, and if there is no corresponding interceptor, the action method is executed. The system's call to the Interceptor is implemented by Actioninvocation. The code is as follows:

[Java]View Plaincopyprint?

1. if (Interceptors.hasnext ()) {
2. Interceptor Interceptor= (Interceptor) Interceptors.next ();
3. ResultCode = Interceptor.intercept (this);
4. } Else {
5. if (Proxy.getconfig (). Getmethodname () = = null) {
6. ResultCode = Getaction (). Execute ();
7. } Else {
8. ResultCode = Invokeaction (Getaction (), Proxy.getconfig ());
9. }
10. }

You can see that the action is not directly associated with the interceptor, but rather that the agent works with the interceptor in the organization action. Such as:

Two Interceptor Execution Analysis

As we all know, there is nothing special about the interface definition of interceptor, except the Init and Destory methods, The Intercept method is the core method to implement the whole interceptor mechanism. And it relies on the parameter actioninvocation is the famous action dispatcher. Let's take a look at a typical interceptor abstract implementation class:

[Java]View Plaincopyprint?

2. Public abstract class Aroundinterceptor extends Abstractinterceptor {
8. /* (Non-javadoc)
12. * @see Com.opensymphony.xwork2.interceptor.abstractinterceptor#intercept ( Com.opensymphony.xwork2.ActionInvocation)
16. */
20. @Override
24. Public String intercept (actioninvocation invocation) throws Exception {
28. String result = null;
34. Before (invocation);
38. //Call the next interceptor, if the interceptor does not exist, execute the action
42. result = Invocation.invoke ();
46. After (invocation, result);
52. return result;
56. }
62. Public abstract Void before (Actioninvocation invocation) throws Exception;
68. Public abstract void after (actioninvocation invocation, String ResultCode) throws Exception;
74. }

In this implementation class, you have actually implemented the simplest interceptor prototype. What needs to be pointed out here is a very important method of Invocation.invoke (). This is the method in Actioninvocation, and Actioninvocation is the action dispatcher, so this method has the following 2-layer meanings:

1. If there are other interceptor in the interceptor stack, then Invocation.invoke () will call the execution of the next interceptor in the stack.
2. If there is only action in the interceptor stack, then Invocation.invoke () will invoke action execution.

So, we can see that the Invocation.invoke () method is actually the core of the entire interceptor framework implementation. Based on this implementation mechanism, we can also get the following 2 very important inferences:
1. If in the interceptor, we do not use Invocation.invoke () to complete the call of the next element of the stack, but instead directly return a string as the result of execution, then the entire execution will be aborted.
2. We can divide the code in the interceptor into 2 parts with Invocation.invoke (), and the Code before Invocation.invoke () will be executed sequentially before the action, and in Invocation.invoke () The subsequent code will be executed in reverse order after the action.
Thus, we can implement AOP by Invocation.invoke () as the real intercept point of the action code.

Three. Source code parsing

Let's look at the source code to see how STRUTS2 guarantees the order of execution between the Interceptor, action, and result. As I mentioned before, Actioninvocation is the scheduler in the Struts2, so in fact, the execution of these code is done in the Actioninvocation implementation class, here, I extracted the Invoke () method in Defaultactioninvocation, which will show us everything.

2. /**
6. * @throws configurationexception If No result can be found with the returned code
10. */
14. Public String Invoke () throws Exception {
18. String Profilekey = "Invoke:";
22. try {
26. Utiltimerstack.push (Profilekey);
34. if (executed) {
38. throw New IllegalStateException ("Action has already executed");
42. }
46. ///Call the Interceptor Code execution in the interceptor stack in turn
50. if (Interceptors.hasnext ()) {
54. Final Interceptormapping Interceptor = (interceptormapping) interceptors.next ();
58. Utiltimerstack.profile ("Interceptor:" +interceptor.getname (),
62. New Utiltimerstack.profilingblock<string> () {
66. Public String doprofiling () throws Exception {
70. //Actioninvocation as a parameter, call the Intercept method in interceptor to execute
74. ResultCode = Interceptor.getinterceptor (). Intercept (defaultactioninvocation.   this);
78. return null;
82. }
86. });
90. } Else {
94. ResultCode = Invokeactiononly ();
98. }
104. //This is needed because the result would be executed and then control would return to the interceptor, which would
108. //return above and flow through again
112. if (!executed) {
116. //Execute Preresultlistener
120. if (preresultlisteners! = null) {
124. For (Iterator Iterator = Preresultlisteners.iterator ();
128. Iterator.hasnext ();) {
132. Preresultlistener listener = (Preresultlistener) iterator.next ();
140. String _profilekey="Preresultlistener:";
144. try {
148. Utiltimerstack.push (_profilekey);
152. Listener.beforeresult (this, ResultCode);
156. }
160. finally {
164. Utiltimerstack.pop (_profilekey);
168. }
172. }
176. }
182. //Now execute the result, if we ' re supposed to
186. //action and interceptor executed, execution result
190. if (Proxy.getexecuteresult ()) {
194. Executeresult ();
198. }
204. executed = true;
208. }
214. return resultcode;
218. }
222. finally {
226. Utiltimerstack.pop (Profilekey);
230. }
234. }

From the source code, we can see the Action layer of the 4 different levels, in this method is reflected, they are: Interceptor (Interceptor), Action, Preresultlistener and result. In this method, the sequential invocation and execution of these levels are ensured. As a result, we can see that Struts2 's many considerations in the action hierarchy design, each level has a high degree of extensibility and insertion point, allowing programmers to add their own implementation mechanism at any preferred level to change action behavior.
Here, a special emphasis is placed on the execution invocation of the interceptor part:

[Java]View Plaincopyprint?

1. ResultCode = Interceptor.getinterceptor (). Intercept (defaultactioninvocation.     this);

On the surface, it just executes the Intercept method in the interceptor, and if we combine the interceptor, we can see the point:

[Java]View Plaincopyprint?

2. Public String intercept (actioninvocation invocation) throws Exception {
6. String result = null;
10. Before (invocation);
14. //Call the Invoke () method of invocation, where a recursive call is formed
18. result = Invocation.invoke ();
22. After (invocation, result);
26. return result;
30. }

Originally in The Intercept () method and the Actioninvocation invoke () method recursive call, actioninvocation loop nested in intercept (), until the statement result = Invocation.invoke () execution ends. In this way, the interceptor is executed in the reverse order in which it was first executed. an ordered linked list, which is transformed into a stack execution by recursive invocation, turns an orderly execution of code into a 2-stage code process that executes exactly the opposite sequence, thus subtly implementing AOP. This also becomes the AOP foundation of the action layer of the Struts2.

Interceptor Implementation Principle