现在向大家介绍一下如果创建自己的拦截器并把它应用于Struts的动作。为了使用拦截器，需要做下面的工作。
1，创建一个日志拦截器
Java代码
1. /**
2. * 一个简单的日志记录拦截器
3. */
4. package cn.dip.struts.filter;
5.
6. import java.lang.reflect.Method;
7.
8. import org.springframework.aop.MethodBeforeAdvice;
9.
10. public class LoggingInterceptor implements MethodBeforeAdvice {
11.
12. public void before(Method method, Object[] args, Object target)
13. throws Throwable {
14. System.out.println("Logging before!");
15. System.out.println("method.getName():"+method.getName());
16. System.out.println("method.toString():"+method.toString());
17. System.out.println("args.length:"+args.length);
18. System.out.println("args[0].getClass().getName():"+args[0].getClass().getName());
19. System.out.println("target.getClass().getName():"+target.getClass().getName());
20. }
21.
22. }
2，注册日志拦截器
在Spring的配置文件中添加下面的代码
Java代码
1. <!--注册Struts的动作-->
2. <bean name="/register" class="cn.dip.struts.action.UserAction" scope="prototype">
3. <property name="userManager" ref="userManager"/>
4. </bean>
5. <bean name="/admin" class="cn.dip.struts.action.AdminAction" scope="prototype">
6. <property name="userManager" ref="userManager"/>
7. </bean>
8.
9. <!-- 注册了这个拦截器(1) -->
10. <bean name="logger"
11. class="cn.dip.struts.filter.LoggingInterceptor"/>
12. <!-- 创建了一个 bean 名称自动代理，它描述如何应用拦截器。还有其他的方法定义拦截点，但是这种方法常见而简便。 -->
13. <bean name="loggingAutoProxy"
14. class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">
15. <property name="beanNames">
16. <!-- 将 Struts 动作注册为将被拦截的 bean。如果您想要拦截其他的 Struts 动作，则只需要在 "beanNames" 下面创建附加的 <value> 标记。 -->
17. <list>
18. <value>/register</value>
19. <value>/admin</value>
20. </list>
21. </property>
22. <property name="interceptorNames">
23. <!-- 当拦截发生时，执行了在 (1) 处创建的拦截器 bean 的名称。这里列出的所有拦截器都应用于"beanNames"。 -->
24. <list>
25. <value>logger</value>
26. </list>
27. </property>
28. </bean>
到这里，日志记录拦截器的准备工作都已经做好了，接下来看执行了Struts动作后会得到什么样的结果。
在这个例子中，将Struts动作管理委托给Spring，通过在 struts-config 动作映射中注册一个代理来实现。代理负责在 Spring 环境中查找 Struts 动作。由于动作在 Spring 的控制之下，所以它可以填充动作的 JavaBean 属性，并为应用诸如 Spring 的 AOP 拦截器之类的特性带来了可能。
struts-config.xml
Java代码
1. <?xml version="1.0" encoding="UTF-8"?>
2. <!DOCTYPE struts-config PUBLIC "-//Apache Software Foundation//DTD Struts Configuration 1.3//EN" "http://struts.apache.org/dtds/struts-config_1_3.dtd">
3.
4. <struts-config>
5. <form-beans >
6. <form-bean name="userForm" type="cn.dip.struts.form.UserForm" />
7.
8. </form-beans>
9.
10. <global-exceptions />
11. <global-forwards />
12. <action-mappings >
13. <action
14. attribute="userForm"
15. input="register.jsp"
16. name="userForm"
17. path="/register"
18. scope="request"
19. parameter="method"
20. type="org.springframework.web.struts.DelegatingActionProxy">
21. <forward name="error" path="/register.jsp" />
22. <forward name="success" path="/success.jsp" />
23. </action>
24.
25.
26. </action-mappings>
27.
28. <message-resources parameter="cn.dip.struts.ApplicationResources" />
29.
30. </struts-config>
UserAction的代码如下
Java代码
1. package cn.dip.struts.action;
2.
3. import javax.servlet.http.HttpServletRequest;
4. import javax.servlet.http.HttpServletResponse;
5.
6. import org.apache.struts.action.ActionForm;
7. import org.apache.struts.action.ActionForward;
8. import org.apache.struts.action.ActionMapping;
9. import org.apache.struts.actions.DispatchAction;
10.
11. import cn.dip.model.User;
12. import cn.dip.service.impl.UserManager;
13. import cn.dip.struts.form.UserForm;
14. import cn.dip.utils.DateUtil;
15.
16.
17. public class UserAction extends DispatchAction {
18. /**
19. * Method execute
20. * @param mapping
21. * @param form
22. * @param request
23. * @param response
24. * @return ActionForward
25. */
26. private UserManager userManager;
27. public ActionForward register(ActionMapping mapping, ActionForm form,
28. HttpServletRequest request, HttpServletResponse response) {
29. System.out.println("................");
30. UserForm userForm = (UserForm) form;
31. User user = new User();
32. try {
33. org.apache.commons.beanutils.BeanUtils.copyProperties(user, userForm);
34. } catch (Exception e) {
35. e.printStackTrace();
36. }
37. userManager.save(user);
38. return mapping.findForward("success");
39. }
40.
41. /**
42. * @param userManager the userManager to set
43. */
44. public void setUserManager(UserManager userManager) {
45. this.userManager = userManager;
46. }
47.
48. }
当页面的请求的URL为http://localhost:8080/onlinexam/register.do?method=register时， 将会执行UserAction中的register的方法。在register方法执行之前，定义的拦截器拦截到Struts的动作，执行before方 法。
具体的输出结果如下
Java代码
1. Logging before!
2. method.getName():execute
3. method.toString():public org.apache.struts.action.ActionForward org.apache.struts.actions.DispatchAction.execute(org.apache.struts.action.ActionMapping,org.apache.struts.action.ActionForm,javax.servlet.http.HttpServletRequest,javax.servlet.http.HttpServletResponse) throws java.lang.Exception
4. args.length:4
5. args[0].getClass().getName():org.apache.struts.action.ActionMapping
6. target.getClass().getName():cn.dip.struts.action.UserAction
7. ................
这样，一个简单的日志记录拦截器就实现了。
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
