转自: struts2笔记（1）--工作流程
关键字: struts2 流程 核心类
核心控制器FilterDispatcher
核心控制器FilterDispatcher是Struts 2框架的基础，包含了框架内部的控制流程和处理机制。业务控制器Action和业务逻辑组件是需要用户来自己实现的。用户在开发Action和业务逻辑组件的同时，还需要编写相关的配置文件，供核心控制器FilterDispatcher来使用。
Struts 2的工作流程相对于Struts 1要简单，与WebWork框架基本相同，所以说Struts 2是WebWork的升级版本。Struts 2框架按照模块来划分，可以分为Servlet Filters、Struts核心模块、拦截器和用户实现部分。Struts 2框架结构图如图3.1所示。
图3.1 Struts 2框架结构图
一个请求在Struts 2框架中的处理大概分为以下几个步骤。
* 客户端提交一个（HttpServletRequest）请求，如上文在浏览器中输入
http://localhost: 8080/bookcode/ch2/Reg.action就是提交一个（HttpServletRequest）请求。
* 请求被提交到一系列（主要是3层）的过滤器（Filter），如（ActionContextCleanUp、其他过滤器（SiteMesh 等）、 FilterDispatcher）。注意：这里是有顺序的，先ActionContext CleanUp，再其他过滤器（Othter Filters、SiteMesh等），最后到FilterDispatcher。
* FilterDispatcher是控制器的核心，就是MVC的Struts 2实现中控制层（Controller）的核心。
* FilterDispatcher询问ActionMapper是否需要调用某个Action来处理这个（HttpServlet Request）请求，如果ActionMapper决定需要调用某个Action，FilterDispatcher则把请求的处理交给 ActionProxy。
* ActionProxy通过Configuration Manager（struts.xml）询问框架的配置文件，找到需要调用的Action类。例如，用户注册示例将找到UserReg类。
* ActionProxy创建一个ActionInvocation实例，同时ActionInvocation通过代理模式调用Action。但在调用之前，ActionInvocation会根据配置加载Action相关的所有Interceptor（拦截器）。
* 一旦Action执行完毕，ActionInvocation负责根据struts.xml中的配置找到对应的返回结果result。
Struts 2的核心控制器是FilterDispatcher，有3个重要的方法：destroy()、doFilter()和Init()，可以在Struts 2的下载文件夹中找到源代码，如代码3.1所示。
代码3.1 核心控制器FilterDispatcher
1. public class FilterDispatcher implements StrutsStatics, Filter {
2.
3. /**
4.
5. * 定义一个Log实例
6.
7. */
8.
9. private static final Log LOG = LogFactory.getLog(FilterDispatcher.class);
10.
11. /**
12.
13. * 存放属性文件中的.STRUTS_I18N_ENCODING值
14.
15. */
16.
17. private static String encoding;
18.
19. /**
20.
21. * 定义ActionMapper实例
22.
23. */
24.
25. private static ActionMapper actionMapper;
26.
27. /**
28.
29. * 定义FilterConfig实例
30.
31. */
32.
33. private FilterConfig filterConfig;
34.
35. protected Dispatcher dispatcher;
36.
37. /**
38.
39. * 创建一个默认的dispatcher，初始化filter
40.
41. * 设置默认的packages *
42.
43. */
44.
45. public void init(FilterConfig filterConfig) throws ServletException {
46.
47. this.filterConfig = filterConfig;
48.
49. dispatcher = createDispatcher(filterConfig);
50.
51. dispatcher.init();
52.
53. String param = filterConfig.getInitParameter("packages");
54.
55. String packages = "org.apache.struts2.static template org.apache.struts2.interceptor.debugging";
56.
57. if (param != null) {
58.
59. packages = param + " " + packages;
60.
61. }
62.
63. this.pathPrefixes = parse(packages);
64.
65. }
66.
67. //销毁filter方法
68.
69. public void destroy() {
70.
71. if (dispatcher == null) {
72.
73. LOG.warn("something is seriously wrong, Dispatcher is not initialized (null) ");
74.
75. } else {
76.
77. dispatcher.cleanup();
78.
79. }
80.
81. }
82.
83. /**
84.
85. * 处理一个Action或者资源请求
86.
87. *
88.
89. * filter尝试将请求同action mapping相匹配
90.
91. * 如果找到，将执行dispatcher的serviceAction方法
92.
93. * 如果Action处理失败, doFilter将建立一个异常
94.
95. *
96.
97. * 如果请求静态资源
98.
99. * 资源将被直接复制给 response
100.
101. *
102.
103. * 如果找不到匹配Action 或者静态资源，则直接跳出
104.
105. public void doFilter(ServletRequest req, ServletResponse res, FilterChain chain) throws IOException, ServletException {
106.
107. HttpServletRequest request = (HttpServletRequest) req;
108.
109. HttpServletResponse response = (HttpServletResponse) res;
110.
111. ServletContext servletContext = getServletContext();
112.
113. String timerKey = "FilterDispatcher_doFilter: ";
114.
115. try {
116.
117. UtilTimerStack.push(timerKey);
118.
119. request = prepareDispatcherAndWrapRequest(request, response);
120.
121. ActionMapping mapping;
122.
123. try {
124.
125. mapping=actionMapper.getMapping(request, dispatcher.getConfigurationManager());
126.
127. } catch (Exception ex) {
128.
129. LOG.error("error getting ActionMapping", ex);
130.
131. dispatcher.sendError(request, response, servletContext, HttpServletResponse.SC_INTERNAL_SERVER_ERROR, ex);
132.
133. return;
134.
135. }
136.
137. if (mapping == null) {
138.
139. String resourcePath = RequestUtils.getServletPath(request);
140.
141. if ("".equals(resourcePath) && null != request.getPathInfo()) {
142.
143. resourcePath = request.getPathInfo();
144.
145. }
146.
147. if (serveStatic && resourcePath.startsWith("/struts")) {
148.
149. String name = resourcePath.substring("/struts".length());
150.
151. findStaticResource(name, request, response);
152.
153. } else {
154.
155. //为一个普通的request, 则通过
156.
157. chain.doFilter(request, response);
158.
159. }
160.
161. return;
162.
163. }
164.
165. /**
166.
167. *这个方法询问ActionMapper是否需要调用某个Action来处理这个（request）请求，
168.
169. *如果ActionMapper决定需要调用某个Action，
170.
171. *FilterDispatcher则把请求的处理交给ActionProxy
172.
173. dispatcher.serviceAction(request, response, servletContext, mapping);
174.
175. } finally {
176.
177. try {
178.
179. ActionContextCleanUp.cleanUp(req);
180.
181. } finally {
182.
183. UtilTimerStack.pop(timerKey);
184.
185. }
186.
187. }
188.
189. }
190.
191. … …
192.
193. }
在doFilter()方法中，将调用dispatcher.serviceAction，该方法如果找到相应的Action，将把用户请求交给ActionProxy。serviceAction()代码在Dispatcher.java中，如代码3.2所示。
代码3.2 Dispatcher类
1. public class Dispatcher {
2.
3. ...
4.
5. /**
6.
7. * 为mapping加载类，并调用相应的方法或者直接返回result
8.
9. *
10.
11. * 根据用户请求的参数，建立Action上下文
12.
13. * 根据指定的Action’名称和包空间名称，加载一个Action代理 ActionProxy
14.
15. * 然后Action的相应方法将被执行，
16.
17. */
18.
19. public void serviceAction(HttpServletRequest request, HttpServletResponse response, ServletContext context, ActionMapping mapping) throws ServletException {
20.
21. Map
22.
23. //如果存在一个值栈，则建立一个新的并复制以备Action使用
24.
25. ValueStack stack = (ValueStack) request.getAttribute(ServletActionContext.STRUTS_VALUESTACK_KEY);
26.
27. if (stack!= null) {
28.
29. extraContext.put(ActionContext.VALUE_STACK, ValueStackFactory.getFactory().createValueStack(stack));
30.
31. }
32.
33. String timerKey = "Handling request from Dispatcher";
34.
35. try {
36.
37. UtilTimerStack.push(timerKey);
38.
39. String namespace = mapping.getNamespace();
40.
41. String name = mapping.getName();
42.
43. String method = mapping.getMethod();
44.
45. Configuration config = configurationManager.getConfiguration();
46.
47. //FilterDispatcher把请求的处理交给ActionProxy
48.
49. ActionProxy proxy = config.getContainer().getInstance(ActionProxyFactory.class).createActionProxy(namespace, name, extraContext, true, false);
50.
51. proxy.setMethod(method);
52.
53. request.setAttribute(ServletActionContext.STRUTS_VALUESTACK_KEY, proxy.getInvocation().getStack());
54.
55. //ActionMapping 直接返回一个result
56.
57. if (mapping.getResult() != null) {
58.
59. Result result = mapping.getResult();
60.
61. result.execute(proxy.getInvocation());
62.
63. } else {
64.
65. proxy.execute();
66.
67. }
68.
69. if (stack != null) {
70.
71. request.setAttribute(ServletActionContext.STRUTS_VALUESTACK_KEY, stack);
72.
73. }
74.
75. } catch (ConfigurationException e) {
76.
77. LOG.error("Could not find action or result", e);
78.
79. sendError(request, response, context, HttpServletResponse.SC_NOT_FOUND, e);
80.
81. } catch (Exception e) {
82.
83. throw new ServletException(e);
84.
85. } finally {
86.
87. UtilTimerStack.pop(timerKey);
88.
89. }
90.
91. }
92.
93. …
94.
95. ｝
从上面代码中可以看出来，Struts 2用于处理用户请求的Action实例，并不是用户实现的业务控制器，而是Action代理。关于Action代理相关内容，读者可以参考拦截器章节的介绍。
前面一直在说Action可以是一个普通的Java类，与Servlet API完全分离，但是为了实现业务逻辑，Action需要使用HttpServletRequest内容。
Struts 2设计的精巧之处就是使用了Action代理，Action代理可以根据系统的配置，加载一系列的拦截器，由拦截器将 HttpServletRequest参数解析出来，传入Action。同样，Action处理的结果也是通过拦截器传入 HttpServletResponse，然后由HttpServletRequest传给用户。
其实，该处理过程是典型的AOP（面向切面编程）的方式。Struts 2处理过程模型如图3.2所示。
图3.2 Struts 2处理过程模型
拦截器是Struts 2框架的核心，通过拦截器，实现了AOP（面向切面编程）。使用拦截器，可以简化Web开发中的某些应用，例如，权限拦截器可以简化Web应用中的权限检查。
3.1.2 业务控制器Action
业务控制器Action是由开发者自己编写实现的，Action类可以是一个简单的Java类，与Servlet API完全分离。Action一般都有一个execute()方法，也可以定义其他业务控制方法，详细内容将在后面介绍。
Action的execute()返回一个String类型值，这与Struts 1返回的ActionForward相比，简单易懂。Struts 2提供了一个ActionSupport工具类，该类实现了Action接口和validate()方法，一般开发者编写Action可以直接继承 ActionSupport类。编写Action类后，开发者还必须在配置文件中配置Action。一个Action的配置应该包含下面几个元素：
* 1、该Action的name，即用户请求所指向的URL。
* 2、Action所对应的class元素，对应Action类的位置。
* 3、指定result逻辑名称和实际资源的定位。
Action是业务控制器，笔者建议在编写Action的时候，尽量避免将业务逻辑放到其中，尽量减少Action与业务逻辑模块或者组件的耦合程度。
Posts
No comments:
Post a Comment