MVC设计模式：Struts的Action思想

来源：互联网发布：怎样做好淘宝才有生意编辑：程序博客网时间：2024/05/16 22:39

Struts实质就是MVC模式的体现；因为它强制把程序分成三层结构，大大提高了灵活性，使得程序更加利于开发、扩展和维护。

MVC包含三个基础部分：Model、View和Controller，这三个部分以最小的耦合协同工作，以增加程序的可扩展性和可维护性。各个部分的实现技术可以总结如下：

Model: 封装了所有的商业逻辑以及规则。通常被JavaBean或EJB的EntityBean实现。
View: 使用商业逻辑处理后的结果并构建呈现给客户端的响应。通常被JSP、Struts的TagLib实现。
Controller：管理和控制所有用户和应用程序间的交互。通常被Struts的ActionServlet、Action实现。

通常是一个Servlet接收用户的请求并把所有的输入转交给实际工作的Model。最后调用JSP返回输出。概括起来MVC的优点主要有以下方面：

多个视图可以对应一个模型。按MVC设计模式，一个模型对应多个视图，可以减少代码的复制及代码的维护量，一旦模型发生改变，也易于维护。
模型返回的数据与显示逻辑分离。模型数据可以应用任何的显示技术，例如，使用JSP页面、Velocity模板或者直接产生Excel文档等。
应用被分隔为三层，降低了各层之间的耦合，提供了应用的可扩展性。
控制层的概念也很有效，由于它把不同的模型和不同的视图组合在一起，完成不同的请求。因此，控制层可以说是包含了用户请求权限的概念。
MVC更符合软件工程化管理的精神。不同的层各司其职，每一层的组件具有相同的特征，有利于通过工程化和工具化产生管理程序代码。

Struts的基本执行流程

客户端发送请求；
请求先通过Filter Chain（ActionContextCleanUp–>FilterDispatcher）；
ActionContextCleanUp主要清理当前线程的ActionContext和Dispatcher；
FilterDispatcher通过ActionMapper来决定这个Request需要调用哪个Action；
如果ActionMapper决定调用某个Action，FilterDispatcher把请求的处理交给ActionProxy，这儿已经转到它的Delegate–Dispatcher来执行；
ActionProxy根据ActionMapping和ConfigurationManager找到需要调用的Action类；
ActionProxy创建一个ActionInvocation的实例；
ActionInvocation真正的Action，当然这涉及到相关拦截器的调用
Action执行完毕，ActionInvocation创建Result并返回，当然，如果要在返回之前做些什么，可以实现PreResultListener。添加PreResultListener可以在Interceptor中实现。

ActionMapper ActionMapper其实是HttpServletRequest和Action调用请求的一个映射，它屏蔽了Action对于Request等java Servlet类的依赖。Struts2中它的默认实现类是DefaultActionMapper，ActionMapper很大的用处可以根据自己的需要来设计url格式，它自己也有Restful的实现，具体可以参考文档的docs\actionmapper.html。
ActionProxy&ActionInvocation Action的一个代理，由ActionProxyFactory创建，它本身不包括Action实例，默认实现DefaultActionProxy是由ActionInvocation持有Action实例。ActionProxy作用是如何取得Action，无论是本地还是远程。而ActionInvocation的作用是如何执行Action，拦截器的功能就是在ActionInvocation中实现的。
ConfigurationProvider&Configuration ConfigurationProvider就是Struts2中配置文件的解析器，Struts2中的配置文件主要是尤其实现类XmlConfigurationProvider及其子类StrutsXmlConfigurationProvider来解析。
Struts2(2.1.2)部分源码分析

从org.apache.struts2.dispatcher.FilterDispatcher开始

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
    //创建Dispatcher，此类是一个Delegate，它是真正完成根据url解析，读取对应Action的地方
    publicvoidinit(FilterConfigfilterConfig)throwsServletException{
        try{
            this.filterConfig=filterConfig;
 
            initLogging();
 
            dispatcher=createDispatcher(filterConfig);
            dispatcher.init();
            dispatcher.getContainer().inject(this);
            //读取初始参数pakages，调用parse()，解析成类似/org/apache/struts2/static,/template的数组
            Stringparam=filterConfig.getInitParameter("packages");
            Stringpackages="org.apache.struts2.static template org.apache.struts2.interceptor.debugging";
            if(param!=null){
                packages=param+" "+packages;
            }
            this.pathPrefixes=parse(packages);
        }finally{
            ActionContext.setContext(null);
        }
    }

顺着流程我们看Disptcher的init方法。init方法里就是初始读取一些配置文件等，先看init_DefaultProperties，主要是读取properties配置文件。

1
2
3
    privatevoidinit_DefaultProperties(){
       configurationManager.addConfigurationProvider(newDefaultPropertiesProvider());
   }

打开DefaultPropertiesProvider

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
  publicvoidregister(ContainerBuilderbuilder,LocatablePropertiesprops)
           throwsConfigurationException{
 
       SettingsdefaultSettings=null;
       try{
           defaultSettings=newPropertiesSettings("org/apache/struts2/default");
       }catch(Exceptione){
           thrownewConfigurationException("Could not find or error in org/apache/struts2/default.properties",e);
       }
 
       loadSettings(props,defaultSettings);
   }
 
   //PropertiesSettings
   //读取org/apache/struts2/default.properties的配置信息，如果项目中需要覆盖，可以在classpath里的struts.properties里覆写
   publicPropertiesSettings(Stringname){
 
       URLsettingsUrl=ClassLoaderUtils.getResource(name+".properties",getClass());
 
       if(settingsUrl==null){
           LOG.debug(name+".properties missing");
           settings=newLocatableProperties();
           return;
       }
 
       settings=newLocatableProperties(newLocationImpl(null,settingsUrl.toString()));
 
       // Load settings
       InputStreamin=null;
       try{
           in=settingsUrl.openStream();
           settings.load(in);
       }catch(IOExceptione){
           thrownewStrutsException("Could not load "+name+".properties:"+e,e);
       }finally{
           if(in!=null){
               try{
                   in.close();
               }catch(IOExceptionio){
                   LOG.warn("Unable to close input stream",io);
               }
           }
       }
   }

再来看init_TraditionalXmlConfigurations方法，这个是读取struts-default.xml和Struts.xml的方法。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
    privatevoidinit_TraditionalXmlConfigurations(){
        //首先读取web.xml中的config初始参数值
        //如果没有配置就使用默认的"struts-default.xml,struts-plugin.xml,struts.xml"，
        //这儿就可以看出为什么默认的配置文件必须取名为这三个名称了
        //如果不想使用默认的名称，直接在web.xml中配置config初始参数即可
        StringconfigPaths=initParams.get("config");
        if(configPaths==null){
            configPaths=DEFAULT_CONFIGURATION_PATHS;
        }
        String[]files=configPaths.split("\\s*[,]\\s*");
        //依次解析配置文件，xwork.xml单独解析
        for(Stringfile:files){
            if(file.endsWith(".xml")){
                if("xwork.xml".equals(file)){
                    configurationManager.addConfigurationProvider(newXmlConfigurationProvider(file,false));
                }else{
                    configurationManager.addConfigurationProvider(newStrutsXmlConfigurationProvider(file,false,servletContext));
                }
            }else{
                thrownewIllegalArgumentException("Invalid configuration file name");
            }
        }
    }

对于其它配置文件只用StrutsXmlConfigurationProvider，此类继承XmlConfigurationProvider，而XmlConfigurationProvider又实现ConfigurationProvider接口。

类XmlConfigurationProvider负责配置文件的读取和解析；
addAction()方法负责读取<action>标签，并将数据保存在ActionConfig中；
addResultTypes()方法负责将<result-type>标签转化为ResultTypeConfig对象；
loadInterceptors()方法负责将<interceptor>标签转化为InterceptorConfi对象；
loadInterceptorStack()方法负责将<interceptor-ref>标签转化为InterceptorStackConfig对象；
loadInterceptorStacks()方法负责将<interceptor-stack>标签转化成InterceptorStackConfig对象。

上面的方法最终会被addPackage()方法调用，将所读取到的数据汇集到PackageConfig对象中。来看下XmlConfigurationProvider的源代码。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
    protectedPackageConfigaddPackage(ElementpackageElement)throwsConfigurationException{
        PackageConfig.BuildernewPackage=buildPackageContext(packageElement);
 
        if(newPackage.isNeedsRefresh()){
            returnnewPackage.build();
        }
        .
 
        addResultTypes(newPackage,packageElement);
        loadInterceptors(newPackage,packageElement);
        loadDefaultInterceptorRef(newPackage,packageElement);
        loadDefaultClassRef(newPackage,packageElement);
        loadGlobalResults(newPackage,packageElement);
        loadGobalExceptionMappings(newPackage,packageElement);
        NodeListactionList=packageElement.getElementsByTagName("action");
 
        for(inti=0;i&lt;actionList.getLength();i++){
            ElementactionElement=(Element)actionList.item(i);
            addAction(actionElement,newPackage);
        }
        loadDefaultActionRef(newPackage,packageElement);
        PackageConfigcfg=newPackage.build();
        configuration.addPackageConfig(cfg.getName(),cfg);
        returncfg;
    }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
    privateListloadConfigurationFiles(StringfileName,ElementincludeElement){
        Listdocs=newArrayList();
        if(!includedFileNames.contains(fileName)){
 
                ElementrootElement=doc.getDocumentElement();
                NodeListchildren=rootElement.getChildNodes();
                intchildSize=children.getLength();
 
                for(inti=0;i&lt;childSize;i++){
                    NodechildNode=children.item(i);
 
                    if(childNodeinstanceofElement){
                        Elementchild=(Element)childNode;
 
                        finalStringnodeName=child.getNodeName();
                        //解析每个action配置是，对于include文件可以使用通配符*来进行配置
                        //如Struts.xml中可配置成
                        if(nodeName.equals("include")){
                            StringincludeFileName=child.getAttribute("file");
                            if(includeFileName.indexOf('*')!=-1){
                                ClassPathFinderwildcardFinder=newClassPathFinder();
                                wildcardFinder.setPattern(includeFileName);
                                VectorwildcardMatches=wildcardFinder.findMatches();
                                for(Stringmatch:wildcardMatches){
                                    docs.addAll(loadConfigurationFiles(match,child));
                                }
                            }
                            else{
 
                                docs.addAll(loadConfigurationFiles(includeFileName,child));
                            }
                    }
                }
                }
                docs.add(doc);
                loadedFileUrls.add(url.toString());
            }
        }
        returndocs;
    }

init_CustomConfigurationProviders方式初始自定义的Provider，配置类全名和实现ConfigurationProvider接口，用逗号隔开即可。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
    privatevoidinit_CustomConfigurationProviders(){
        StringconfigProvs=initParams.get("configProviders");
        if(configProvs!=null){
            String[]classes=configProvs.split("\\s*[,]\\s*");
            for(Stringcname:classes){
                try{
                    Classcls=ClassLoaderUtils.loadClass(cname,this.getClass());
                    ConfigurationProviderprov=(ConfigurationProvider)cls.newInstance();
                    configurationManager.addConfigurationProvider(prov);
                }
 
            }
        }
    }

现在再回到FilterDispatcher，每次发送一个Request，FilterDispatcher都会调用doFilter方法。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
    publicvoiddoFilter(ServletRequestreq,ServletResponseres,FilterChainchain)throwsIOException,ServletException{
 
        HttpServletRequestrequest=(HttpServletRequest)req;
        HttpServletResponseresponse=(HttpServletResponse)res;
        ServletContextservletContext=getServletContext();
 
        StringtimerKey="FilterDispatcher_doFilter: ";
        try{
            ValueStackstack=dispatcher.getContainer().getInstance(ValueStackFactory.class).createValueStack();
            ActionContextctx=newActionContext(stack.getContext());
            ActionContext.setContext(ctx);
 
            UtilTimerStack.push(timerKey);
            //根据content type来使用不同的Request封装，可以参见Dispatcher的wrapRequest
            request=prepareDispatcherAndWrapRequest(request,response);
            ActionMappingmapping;
            try{
                //根据url取得对应的Action的配置信息--ActionMapping，actionMapper是通过Container的inject注入的
                mapping=actionMapper.getMapping(request,dispatcher.getConfigurationManager());
            }catch(Exceptionex){
                log.error("error getting ActionMapping",ex);
                dispatcher.sendError(request,response,servletContext,HttpServletResponse.SC_INTERNAL_SERVER_ERROR,ex);
                return;
            }
            //如果找不到对应的action配置，则直接返回。比如你输入***.jsp等等
            //这儿有个例外，就是如果path是以“/struts”开头，则到初始参数packages配置的包路径去查找对应的静态资源并输出到页面流中，当然.class文件除外。如果再没有则跳转到404
            if(mapping==null){
                // there is no action in this request, should we look for a static resource?
                StringresourcePath=RequestUtils.getServletPath(request);
 
                if("".equals(resourcePath)&amp;&amp;null!=request.getPathInfo()){
                    resourcePath=request.getPathInfo();
                }
 
                if(serveStatic&amp;&amp;resourcePath.startsWith("/struts")){
                    Stringname=resourcePath.substring("/struts".length());
                    findStaticResource(name,request,response);
                }else{
                    chain.doFilter(request,response);
                }
                return;
            }
            //正式开始Action的方法了
            dispatcher.serviceAction(request,response,servletContext,mapping);
 
        }finally{
            try{
                ActionContextCleanUp.cleanUp(req);
            }finally{
                UtilTimerStack.pop(timerKey);
            }
        }
    }

Dispatcher类的serviceAction方法：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
    publicvoidserviceAction(HttpServletRequestrequest,HttpServletResponseresponse,ServletContextcontext,ActionMappingmapping)throwsServletException{
 
        MapextraContext=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
        ValueStackstack=(ValueStack)request.getAttribute(ServletActionContext.STRUTS_VALUESTACK_KEY);
        if(stack!=null){
            extraContext.put(ActionContext.VALUE_STACK,valueStackFactory.createValueStack(stack));
        }
 
        StringtimerKey="Handling request from Dispatcher";
        try{
            UtilTimerStack.push(timerKey);
            Stringnamespace=mapping.getNamespace();
            Stringname=mapping.getName();
            Stringmethod=mapping.getMethod();
 
            Configurationconfig=configurationManager.getConfiguration();
            ActionProxyproxy=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){
                Resultresult=mapping.getResult();
                result.execute(proxy.getInvocation());
            }else{
                proxy.execute();
            }
 
            // If there was a previous value stack then set it back onto the request
            if(stack!=null){
                request.setAttribute(ServletActionContext.STRUTS_VALUESTACK_KEY,stack);
            }
        }catch(ConfigurationExceptione){
            LOG.error("Could not find action or result",e);
            sendError(request,response,context,HttpServletResponse.SC_NOT_FOUND,e);
        }catch(Exceptione){
            sendError(request,response,context,HttpServletResponse.SC_INTERNAL_SERVER_ERROR,e);
        }finally{
            UtilTimerStack.pop(timerKey);
        }
    }

第一句createContextMap()方法，该方法主要把Application、Session、Request的key value值拷贝到Map中，并放在HashMap中，可以参见createContextMap方法：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
    publicMapcreateContextMap(HttpServletRequestrequest,HttpServletResponseresponse,
            ActionMappingmapping,ServletContextcontext){
 
        // request map wrapping the http request objects
        MaprequestMap=newRequestMap(request);
        // parameters map wrapping the http parameters.  ActionMapping parameters are now handled and applied separately
        Mapparams=newHashMap(request.getParameterMap());
        // session map wrapping the http session
        Mapsession=newSessionMap(request);
        // application map wrapping the ServletContext
        Mapapplication=newApplicationMap(context);
        MapextraContext=createContextMap(requestMap,params,session,application,request,response,context);
        extraContext.put(ServletActionContext.ACTION_MAPPING,mapping);
        returnextraContext;
    }

后面才是最主要的–ActionProxy，ActionInvocation。ActionProxy是Action的一个代理类，也就是说Action的调用是通过ActionProxy实现的，其实就是调用了ActionProxy.execute()方法，而该方法又调用了ActionInvocation.invoke()方法。归根到底，最后调用的是DefaultActionInvocation.invokeAction()方法。先看DefaultActionInvocation的init方法。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
    publicvoidinit(ActionProxyproxy){
        this.proxy=proxy;
        MapcontextMap=createContextMap();
 
        // Setting this so that other classes, like object factories, can use the ActionProxy and other
        // contextual information to operate
        ActionContextactionContext=ActionContext.getContext();
 
        if(actionContext!=null){
            actionContext.setActionInvocation(this);
        }
        //创建Action，可Struts2里是每次请求都新建一个Action
        createAction(contextMap);
 
        if(pushAction){
            stack.push(action);
            contextMap.put("action",action);
        }
 
        invocationContext=newActionContext(contextMap);
        invocationContext.setName(proxy.getActionName());
 
        // get a new List so we don't get problems with the iterator if someone changes the list
        ListinterceptorList=newArrayList(proxy.getConfig().getInterceptors());
        interceptors=interceptorList.iterator();
    }
 
    protectedvoidcreateAction(MapcontextMap){
        // load action
        StringtimerKey="actionCreate: "+proxy.getActionName();
        try{
            UtilTimerStack.push(timerKey);
            //这儿默认建立Action是StrutsObjectFactory，实际中我使用的时候都是使用Spring创建的Action，这个时候使用的是SpringObjectFactory
            action=objectFactory.buildAction(proxy.getActionName(),proxy.getNamespace(),proxy.getConfig(),contextMap);
        }
        ..
        }finally{
            UtilTimerStack.pop(timerKey);
        }
 
        if(actionEventListener!=null){
            action=actionEventListener.prepare(action,stack);
        }
    }

接下来看看DefaultActionInvocation 的invoke方法。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
    publicvoidinit(ActionProxyproxy){
        this.proxy=proxy;
        MapcontextMap=createContextMap();
 
        // Setting this so that other classes, like object factories, can use the ActionProxy and other
        // contextual information to operate
        ActionContextactionContext=ActionContext.getContext();
 
        if(actionContext!=null){
            actionContext.setActionInvocation(this);
        }
        //创建Action，可Struts2里是每次请求都新建一个Action
        createAction(contextMap);
 
        if(pushAction){
            stack.push(action);
            contextMap.put("action",action);
        }
 
        invocationContext=newActionContext(contextMap);
        invocationContext.setName(proxy.getActionName());
 
        // get a new List so we don't get problems with the iterator if someone changes the list
        ListinterceptorList=newArrayList(proxy.getConfig().getInterceptors());
        interceptors=interceptorList.iterator();
    }
 
    protectedvoidcreateAction(MapcontextMap){
        // load action
        StringtimerKey="actionCreate: "+proxy.getActionName();
        try{
            UtilTimerStack.push(timerKey);
            //这儿默认建立Action是StrutsObjectFactory，实际中我使用的时候都是使用Spring创建的Action，这个时候使用的是SpringObjectFactory
            action=objectFactory.buildAction(proxy.getActionName(),proxy.getNamespace(),proxy.getConfig(),contextMap);
        }
        ..
        }finally{
            UtilTimerStack.pop(timerKey);
        }
 
        if(actionEventListener!=null){
            action=actionEventListener.prepare(action,stack);
        }
    }
 
    //接下来看看DefaultActionInvocation 的invoke方法。
  publicStringinvoke()throwsException{
        StringprofileKey="invoke: ";
        try{
            UtilTimerStack.push(profileKey);
 
            if(executed){
                thrownewIllegalStateException("Action has already executed");
            }
                //先执行interceptors
            if(interceptors.hasNext()){
                finalInterceptorMappinginterceptor=(InterceptorMapping)interceptors.next();
                UtilTimerStack.profile("interceptor: "+interceptor.getName(),
                        newUtilTimerStack.ProfilingBlock(){
                            publicStringdoProfiling()throwsException{
                                resultCode=interceptor.getInterceptor().intercept(DefaultActionInvocation.this);
                                returnnull;
                            }
                });
            }else{
                        //interceptor执行完了之后执行action
                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){
                        //在Result返回之前调用preResultListeners
                if(preResultListeners!=null){
                    for(Iteratoriterator=preResultListeners.iterator();
                        iterator.hasNext();){
                        PreResultListenerlistener=(PreResultListener)iterator.next();
 
                        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;
            }
 
            returnresultCode;
        }
        finally{
            UtilTimerStack.pop(profileKey);
        }
    }

看程序中的if(interceptors.hasNext())语句，当然，interceptors里存储的是interceptorMapping列表（它包括一个Interceptor和一个name），所有的截拦器必须实现Interceptor的intercept方法，而该方法的参数恰恰又是ActionInvocation，在intercept方法中还是调用invocation.invoke()，从而实现了一个Interceptor链的调用。当所有的Interceptor执行完，最后调用invokeActionOnly方法来执行Action相应的方法。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
    protectedStringinvokeAction(Objectaction,ActionConfigactionConfig)throwsException{
        StringmethodName=proxy.getMethod();
        StringtimerKey="invokeAction: "+proxy.getActionName();
        try{
            UtilTimerStack.push(timerKey);
 
            booleanmethodCalled=false;
            ObjectmethodResult=null;
            Methodmethod=null;
            try{
                //获得需要执行的方法
                method=getAction().getClass().getMethod(methodName,newClass[0]);
            }catch(NoSuchMethodExceptione){
                //如果没有对应的方法，则使用do+Xxxx来再次获得方法
                try{
                    StringaltMethodName="do"+methodName.substring(0,1).toUpperCase()+methodName.substring(1);
                    method=getAction().getClass().getMethod(altMethodName,newClass[0]);
                }catch(NoSuchMethodExceptione1){
                    // well, give the unknown handler a shot
                    if(unknownHandler!=null){
                        try{
                            methodResult=unknownHandler.handleUnknownActionMethod(action,methodName);
                            methodCalled=true;
                        }catch(NoSuchMethodExceptione2){
                            // throw the original one
                            throwe;
                        }
                    }else{
                        throwe;
                    }
                }
            }
 
            if(!methodCalled){
                methodResult=method.invoke(action,newObject[0]);
            }
            //根据不同的Result类型返回不同值
            //如输出流Result
            if(methodResultinstanceofResult){
                this.explicitResult=(Result)methodResult;
                returnnull;
            }else{
                return(String)methodResult;
            }
        }catch(NoSuchMethodExceptione){
            thrownewIllegalArgumentException("The "+methodName+"() is not defined in action "+getAction().getClass()+"");
        }catch(InvocationTargetExceptione){
            // We try to return the source exception.
            Throwablet=e.getTargetException();
 
            if(actionEventListener!=null){
                Stringresult=actionEventListener.handleException(t,getStack());
                if(result!=null){
                    returnresult;
                }
            }
            if(tinstanceofException){
                throw(Exception)t;
            }else{
                throwe;
            }
        }finally{
            UtilTimerStack.pop(timerKey);
        }
    }

action执行完了，还要根据ResultConfig返回到view，也就是在invoke方法中调用executeResult方法。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
  privatevoidexecuteResult()throwsException{
        //根据ResultConfig创建Result
        result=createResult();
        StringtimerKey="executeResult: "+getResultCode();
        try{
            UtilTimerStack.push(timerKey);
            if(result!=null){
                //这儿正式执行:)
                //可以参考Result的实现，如用了比较多的ServletDispatcherResult,ServletActionRedirectResult,ServletRedirectResult
                result.execute(this);
            }elseif(resultCode!=null&amp;&amp;!Action.NONE.equals(resultCode)){
                thrownewConfigurationException("No result defined for action "+getAction().getClass().getName()
                        +" and result "+getResultCode(),proxy.getConfig());
            }else{
                if(LOG.isDebugEnabled()){
                    LOG.debug("No result returned for action "+getAction().getClass().getName()+" at "+proxy.getConfig().getLocation());
                }
            }
        }finally{
            UtilTimerStack.pop(timerKey);
        }
    }
    publicResultcreateResult()throwsException{
        if(explicitResult!=null){
            Resultret=explicitResult;
            explicitResult=null;;
            returnret;
        }
        ActionConfigconfig=proxy.getConfig();
        Mapresults=config.getResults();
        ResultConfigresultConfig=null;
        synchronized(config){
            try{
                //根据result名称获得ResultConfig，resultCode就是result的name
                resultConfig=(ResultConfig)results.get(resultCode);
            }catch(NullPointerExceptione){
            }
            if(resultConfig==null){
                //如果找不到对应name的ResultConfig，则使用name为*的Result
                resultConfig=(ResultConfig)results.get("*");
            }
        }
        if(resultConfig!=null){
            try{
                //参照StrutsObjectFactory的代码
                Resultresult=objectFactory.buildResult(resultConfig,invocationContext.getContextMap());
                returnresult;
            }catch(Exceptione){
                LOG.error("There was an exception while instantiating the result of type "+resultConfig.getClassName(),e);
                thrownewXWorkException(e,resultConfig);
            }
        }elseif(resultCode!=null&amp;&amp;!Action.NONE.equals(resultCode)&amp;&amp;unknownHandler!=null){
            returnunknownHandler.handleUnknownResult(invocationContext,proxy.getActionName(),proxy.getConfig(),resultCode);
        }
        returnnull;
    }
    //StrutsObjectFactory
    publicResultbuildResult(ResultConfigresultConfig,MapextraContext)throwsException{
        StringresultClassName=resultConfig.getClassName();
        if(resultClassName==null)
            returnnull;
        //创建Result，因为Result是有状态的，所以每次请求都新建一个
        Objectresult=buildBean(resultClassName,extraContext);
        //这句很重要，后面将会谈到，reflectionProvider参见OgnlReflectionProvider；
        //resultConfig.getParams()就是result配置文件里所配置的参数
        //setProperties方法最终调用的是Ognl类的setValue方法
        //这句其实就是把param名值设置到根对象result上
        reflectionProvider.setProperties(resultConfig.getParams(),result,extraContext);
        if(resultinstanceofResult)
            return(Result)result;
        thrownewConfigurationException(result.getClass().getName()+" does not implement Result.");
    }

这样，一个Struts2的请求流程基本上就结束了。

参考链接：http://www.blogjava.net/myyate/articles/Struts2_source_java.html

0 0