BlogJava-业精于勤荒于嬉，行成于思毁于随-文章分类-MVCFramework

温故知新:springMVC_02参数传递

都较瘦 — Tue, 31 Mar 2015 15:56:00 GMT

后续记录

都较瘦 2015-03-31 23:56 发表评论

温故知新:springMVC_01初步

都较瘦 — Tue, 31 Mar 2015 15:55:00 GMT

框架的使用和学习，总要从环境的搭建和第一个实例做起。
1：类库的引用，新建一个maven项目，将springMVC的依赖添加进来

1
2 <dependency>
3   <groupId>org.springframeworkgroupId>
4   <artifactId>spring-webmvcartifactId>
5   <version>4.0.3.RELEASEversion>
6 dependency>

2：在web.xml中添加springMVC的控制器

1   <servlet>
2       <servlet-name>demoservlet-name>
3       <servlet-class>org.springframework.web.servlet.DispatcherServletservlet-class>
4   servlet>
5
6   <servlet-mapping>
7       <servlet-name>demoservlet-name>
8       <url-pattern>/url-pattern>
9   servlet-mapping>

3：添加springMVC的配置文件，注意：文件的名字需要是xxx-servlet，xxx就是刚才web.xml中添加的控制器的名称

1 xml version="1.0" encoding="UTF-8"?>
2 <beans xmlns="http://www.springframework.org/schema/beans"
3      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"
4      xmlns:mvc="http://www.springframework.org/schema/mvc" xmlns:context="http://www.springframework.org/schema/context"
5      xmlns:util="http://www.springframework.org/schema/util"
6      xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
7              http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd
8              http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd
9              http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-3.0.xsd">
10
11
12      <mvc:annotation-driven />
13
14
15      <context:component-scan base-package="com.demo.*" />
16
17
21
22
23      <bean class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter" />
24
25
26      <bean id="viewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
27          <property name="prefix">
28              <value>/WEB-INF/jsp/value>
29          property>
30          <property name="suffix">
31              <value>.jspvalue>
32          property>
33      bean>
34
35 beans>
36

4：添加一个控制器

1 package com.duyt.controllor;
2
3 import org.springframework.stereotype.Controller;
4 import org.springframework.web.bind.annotation.RequestMapping;
5
6 //注明当前这个类是控制器，项目启动时会被扫描
7 @Controller
8 //该类的请求映射，为"/"
9 @RequestMapping("/")
10 public class HelloControllor {
11
12     //该方法的请求映射，需要将类的请求映射和方法的请求映射拼接起来，也就是"/hello"（类的请求映射为"/"）
13     @RequestMapping("/hello")
14     public String Hello(){
15
16         //视图的响应，根据配置文件的配置，会在WEB-INF/jsp文件夹中查找以hello为名称，.jsp结尾的视图文件
17         return "hello";
18     }
19 }
20

视图就省略了，以上就是使用springMVC的流程，这篇就不记录其他相关的功能了，传参，异常，文件上传等功能后续再整理，这里就只是记录一个最简单的体验案例。

都较瘦 2015-03-31 23:55 发表评论

温故知新:struts2_09其他功能：异常的处理

都较瘦 — Mon, 03 Nov 2014 02:37:00 GMT

针对运行时产生的异常，除了try/catch捕获之后进行自定义处理，还可以考虑使用struts2提供的全局结果集。

Action：

1 package demo.action;
2
3 public class HelloWorld {
4
5     public String execute() throws Exception {
6         //模拟一个异常
7         if (true) {
8             throw new Exception("Exception test");
9         }
10         return "success";
11     }
12
13 }
14

struts.xml

1 xml version="1.0" encoding="UTF-8"?>
2 DOCTYPE struts PUBLIC
3     "-//Apache Software Foundation//DTD Struts Configuration 2.3//EN"
4     "http://struts.apache.org/dtds/struts-2.3.dtd">
5 <struts>
6
7     <constant name="struts.devMode" value="true" />
8     <package name="helloworld" extends="struts-default" namespace="/">
9
10         <global-results>
11
12             <result name="error">/error.jspresult>
13         global-results>
14
15         <global-exception-mappings>
16
17             <exception-mapping result="error" exception="Exception" />
18         global-exception-mappings>
19
20         <action name="hello" class="demo.action.HelloWorld">
21             <result name="success">/helloWorld.jspresult>
22         action>
23
24     package>
25
26 struts>

全局异常结果集的配置很简便，可以配置一些404或者一些通用的异常页面，在页面中使用${exception.message}就可以获得异常信息。

都较瘦 2014-11-03 10:37 发表评论

温故知新:struts2_08其他功能：表单验证

都较瘦 — Mon, 03 Nov 2014 01:50:00 GMT

摘要: 其实，struts2的表单验证感觉真的好鸡肋，要不是为了系统的整理一下struts2的功能，根本不会去想它，抽取一个官方的例子吧。struts2的验证分为客户端和服务端，可以通过注解和配置文件的方式去配置，以下是通过配置文件的方式定义一个Action，自定义的Action必须继承ActionSupport才能使得校验生效Code highlighting produced by Actipro C... 阅读全文

都较瘦 2014-11-03 09:50 发表评论

温故知新:struts2_07其他功能：国际化

都较瘦 — Sun, 02 Nov 2014 07:13:00 GMT

说起国际化，第一次接触的时候感到这个功能很神奇，起初很天真的以为是什么国际通讯之类的功能，其实不是的。。。这个功能用中文叫国际化，英文里就有一个很高大上的称呼，叫i18n，其实i18n就是internationalization的偷懒写法，听起来很有逼格。除了i18n，L10n（localization），g11n（globalization），还有m17n（multilingualization），这些解决方案都是为了能让站点的页面能够适应多国语言，当然，如果有必要的话。

其实多语言问题，Java本身就提供了解决方案，util工具包中ResourceBundle就可以解决该问题，ResourceBundle的说明如下写道

......
This allows you to write programs that can:

be easily localized, or translated, into different languages
handle multiple locales at once
be easily modified later to support even more locales

......

显然，为了能使用国家化，我们需要为每一个需要使用的语言单独配置他们的语言内容。分别新建中文和英文的语言配置文件置于src下

Message_zh.properties

1 username=\u7528\u6237\u540D（用户名）
2 password=\u5BC6\u7801（密码）

Message_en.properties

1 username=username
2 password=password

由于properties只支持iso-8859格式的编码，所以在输入中文的时候会有些问题，只是Eclipse自带的properties编辑器可以进行可视化的文本输入，不需要关注编码。另外我们可以通过Java自带的转码工具native2ascii进行转码。
测试类如下，getBundle方法接收两个参数，第一个是BaseName，可以理解为资源的基础名，第二个是语言码，中文是zh，英文是en等等，测试类运行完毕之后会给出英文资源文件中username所对应的值，同理Locale设置为中文则输出中文的值。所以资源文件我们以Message_en.properties这种格式来命名，其中en之后还可以添加下划线跟第三个值区域码，但是一般可以省略。

1 package demo.i18n;
2
3 import java.util.Locale;
4 import java.util.ResourceBundle;
5
6 public class I18nTest {
7
8     public static void main(String[] args) {
9         ResourceBundle rb = ResourceBundle.getBundle("Message", Locale.ENGLISH);
10         System.out.println(rb.getString("username"));
11     }
12
13 }
14

基于上面的内容，struts2使用它们配置全局国际化资源，在struts.xml中添加国家化的配置，其中value就是资源的基础名

1 <constant name="struts.custom.i18n.resources" value="Message" />

之后，在页面上使用struts2的标签进行对应语言内容的显示，当然，显示哪种语言需要显式的将语言码作为参数传入，请求地址需要写作/XXX.action?request_locale=en

1 全局国际化<br/>
2 <s:text name="username"/><br/>

除了全局国际化的配置，struts2还提供了包范围和action范围的国际化，其中包范围的国际化，需要将资源文件命名为“package_语言码.properties”的形式，然后置于需要的包下，struts2会优先取得较小范围的国际化资源文件，同时定义全局国际化资源和包国际化资源，那么包范围的资源会优先生效。至于action范围的国际化，因为国际化在日常的开发中本来用的就不是很多，就算真的碰到需要双语开发的情况，或许也是做两套页面，或者直接做两套网站，除非是那种跨国性质的“因特噗啦一吇”，否则不要说struts2的全局国际化的使用，针对包范围和action范围的国际化，都是少有问津。

都较瘦 2014-11-02 15:13 发表评论

温故知新:struts2_06其他功能：拦截器

都较瘦 — Sun, 02 Nov 2014 01:28:00 GMT

struts2的拦截器其实和过滤器是一个概念，虽然自定义的过滤器用的不多，但是struts2的核心功能都是用拦截器来实现的，异常捕获，参数绑定，和国际化等等。

写一个最简单的过滤器的例子，感受一下自定义过滤器的使用就好。
先上action

1 package demo.action;
2
3 public class InterceptorDemo {
4
5     private String name;
6
7     public String execute(){
8         System.out.println("我是Execute的方法");
9         System.out.println("name：" + name);
10         return "success";
11     }
12
13     //get/set方法略
14
15 }
16

创建一个interceptor只需要新建一个类，继承struts2的AbstractInterceptor，重写intercept方法

1 package demo.interceptor;
2
3 import com.opensymphony.xwork2.ActionInvocation;
4 import com.opensymphony.xwork2.interceptor.AbstractInterceptor;
5
6 public class InterceptorDemo extends AbstractInterceptor{
7
8     private static final long serialVersionUID = -1739072578539674220L;
9
10     @Override
11     public String intercept(ActionInvocation invocation) throws Exception {
12
13         System.out.println("我是一个炫酷的拦截器");
14
15         //校验用户是否登陆等操作
16         //ServletActionContext.getContext().getSession()...
17
18         //校验用户是否有权限访问等操作
19         //invocation.getProxy().getActionName()...
20
21         return invocation.invoke();
22     }
23
24 }
25

如此一来，拦截器就创建好了，接下来就是对拦截器的配置，看到struts.xml

1    <package name="interceptorDemo" extends="struts-default" namespace="/">
2
3
4        <interceptors>
5            <interceptor name="InterceptorDemo" class=demo.interceptor.InterceptorDemo"/>
6        interceptors>
7
8
9       <action name="interceptorDemo"
10             class="demo.action.InterceptorDemo"
11             method="execute">
12             <interceptor-ref name="InterceptorDemo"/>
13       action>

15 package>

将定义好的拦截器添加到某个action的定义中，让拦截器拦截对应的action，但如果如上述那样去配置的话，除了自定义拦截器的功能，struts2 的拦截器功能都会失效，action中的name值根本拿不到。配置中的每个包都会继承struts-default这个包，简单看一下struts-default.xml这个文件

1 <interceptor-stack name="defaultStack">
2   <interceptor-ref name="exception"/>
3  <interceptor-ref name="alias"/>
4  <interceptor-ref name="servletConfig"/>
5  <interceptor-ref name="i18n"/>
6  <interceptor-ref name="prepare"/>
7  <interceptor-ref name="chain"/>
8  <interceptor-ref name="scopedModelDriven"/>
9  <interceptor-ref name="modelDriven"/>
10  <interceptor-ref name="fileUpload"/>
11  <interceptor-ref name="checkbox"/>
12  <interceptor-ref name="multiselect"/>
                    ...
     <interceptor-ref name="debugging"/>
interceptor-stack>

...

<default-interceptor-ref name="default-stack"/>

...

上述就是部分配置，定义了默认的拦截器栈，也就是一组拦截器，从名字就可以看出很多功能都由拦截器完成，所以，自定义的拦截器也需要引用这一组拦截器，需要在配置中添加默认拦截器栈

1 <action name="interceptorDemo"
2             class="org.duyt.action.InterceptorDemo"
3             method="execute">
4             <interceptor-ref name="InterceptorDemo"/>
5             <interceptor-ref name="defaultStack"/>
6 action>

或者定义一组拦截器栈

1        <interceptors>
2            <interceptor name="InterceptorDemo" class="demo.interceptor.InterceptorDemo"/>
3
4
5            <interceptor-stack name="selfStack">
6                <interceptor-ref name="InterceptorDemo"/>
7                <interceptor-ref name="defaultStack"/>
8            interceptor-stack>
9        interceptors>
10
11
12       <action name="interceptorDemo"
13             class="demo.action.InterceptorDemo"
14             method="execute">
15             <interceptor-ref name="selfStack"/>
16       action>

这样，自定义的拦截器就能融入到完整的功能之中。

都较瘦 2014-11-02 09:28 发表评论

温故知新:struts2_05其他功能：文件上传

都较瘦 — Sat, 01 Nov 2014 14:10:00 GMT

不得不说，struts2的文件上传功能做的实在是太方便了，如果脱离struts2的文件上传功能，单纯使用servlet结合fileUpload工具包，1k1k的读，1k1k的写，那么struts2的文件上传功能，简直是把代码量缩减的不止一点半点。
首先，文件上传的表单必须是以下设置

1 <form action="XXX" method="post" enctype="multipart/form-data">

设置完毕之后，看一下servlet的post的方法的设置

1 protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
2
3         request.setCharacterEncoding("utf-8");
4
5         // 首先需要确认，到底是不是文件上传的请求，
6         boolean isMultipart = ServletFileUpload.isMultipartContent(request);
7
8         if (isMultipart) {
9             // 创建一个文件处理对象
10             ServletFileUpload upload = new ServletFileUpload();
11             InputStream is = null;
12             FileOutputStream os = null;
13             try {
14                 // 解析请求中的所有元素
15                 FileItemIterator iter = upload.getItemIterator(request);
16                 while (iter.hasNext()) {
17                     FileItemStream item = iter.next();
18                     is = item.openStream();
19                     //是否是表单域
20                     if (item.isFormField()) {
21                         //其他操作，保存参数等
22                     } else {
23                         //不是表单域则保存文件
24                         String path = request.getSession().getServletContext().getRealPath("/");
25                         path = path + "/upload/" + item.getName();
26                         os = new FileOutputStream(path);

27 //流读写

28                         byte[] buf = new byte[1024];
29                         while(is.read(buf)>0){
30                             os.write(buf);
31                         }
32                     }
33
34                 }
35             } catch (FileUploadException e) {
36                 e.printStackTrace();
37             } finally{
38                 if (is != null) {
39                     is.close();
40                 }
41                 if (os != null) {
42                     os.close();
43                 }
44             }
45         }
46     }

洋洋洒洒一大堆，struts2封装了这些通用的处理，我们可以按照struts2的风格来获取要上传文件的对象，直接写一个多文件上传的例子吧

1 <%@ page language="java" contentType="text/html; charset=UTF-8"
2     pageEncoding="UTF-8"%>
3 DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
4 <html>
5 <head>
6 <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
7 <title>文件上传title>
8 head>
9 <body>
10     <form action="FileUpload" method="post" enctype="multipart/form-data">
11         文件上传测试：<br>
12         <input type="file" name="text"/><br>
13         <input type="file" name="text"/><br>
14         <input type="file" name="text"/><br>
15         <input type="submit" value="提交">
16     form>
17 body>
18 html>

action为

1 package demo.fileUpload;
2
3 import java.io.File;
4 import java.io.IOException;
5
6 import org.apache.commons.io.FileUtils;
7 import org.apache.struts2.ServletActionContext;
8
9 public class FileUpload {
10
11     //文件接收数组，如果是单文件上传，那就不需要定义数组了，定义单个文件对象就行
12     private File text[];
13     //对应的文件名，这里的文件名是“名字.后缀”的形式，这个属性的命名需要是“文件属性的名字”+FileName。
14     private String[] textFileName;
15     //对应的文件类型，是文件的真实类型，比如“text/plain”，这个属性的命名需要是“文件属性的名字”+ContentType
16     private String[] textContentType;
17
18     public String execute() throws IOException{
19
20         String dir = "";
21         File file = null;
22
23         for (int i = 0; i < text.length; i++) {
24             //创建要新建的文件位置
25             dir = ServletActionContext.getServletContext().getRealPath("/") +  "/upload/" + textFileName[i];
26             file = new File(dir);
27             //保存文件
28             if (!file.exists()) {
29                 //使用common.io工具包保存文件
30                 FileUtils.copyFile(text[i], file);
31             }
32         }
33
34         return "success";
35     }

37}

都较瘦 2014-11-01 22:10 发表评论

温故知新:struts2_04常用标签

都较瘦 — Fri, 31 Oct 2014 09:54:00 GMT

struts2提供的一套from标签使得数据的展示变得非常容易，想必这是它如此流行的原因之一，真的很方便。。

首先，为了能够使用struts2提供的标签，我们需要先添加标签的引用
在JSP页面上添加，uri的具体值可以在struts2包的META-INF的struts-tags.tld文件中查看

<%@taglib prefix="s" uri="/struts-tags"%>

先看一下最常用的

1 <s:property value="str" default="" escapeCsv="" escapeHtml="" escapeJavaScript="" escapeXml=""/>

和EL表达式${str}的作用类似，展示动态数据，只不过property标签强化了很多功能，可以免去判断直接设定默认值，忽略cvs，html等内容，虽然struts2的标签不支持EL表达式但是有一种类似的写法

1 <s:property value="%{str}"/>

其次是流程控制标签

1 <s:if test="condition != null">
2
3 s:if>

test的内容可以使用OGNL表达式获取，除了Java那些常规的判断写法，可以将&&可以写作and，||可以写作or，和JSTL的判断类似，都有自己的个性

之后是迭代标签，迭代标签可以说是struts2标签中最常用的标签之一，不仅是因为列表功能很常见，而且迭代标签给出了很好用的功能
假定vals是个list，那么遍历这个list

1 <s:iterator value="vals" var="val" begin="0" end="5" status="st" step="2">
2 <s:property value="val"/>-<s:property value="#st.index"/>-<s:property value="#st.count"/><br>
3 s:iterator>

begin和end属性可以灵活的设定遍历的区间，step则是步进的长度，但是step必须在指定了begin之后才生效，特别要说明status这个属性，声明了st之后，便可以获得当前遍历的下标或者行号，这样一来就可以根据需求执行其他的操作。var属性则声明了当前的遍历对象，使用var属性之后，会在ValueStack中的root和ActionContext中各生成一份当前对象，所以也可以写为<s:property value="#val"/>，如果不声明var属性，则只会在root中生成一份当前对象，是否声明var属性，取决于当前遍历的元素类型，比如vals是一个user列表，那么迭代标签会把当前迭代的user对象置于栈顶，循环内直接写<s:property value="name"/>就可以获取user的name值，无需声明var属性。

假定vals是个map，那么遍历这个map

1 <s:iterator value="mapVals" var="val" begin="0" end="5" status="st" step="2">
2 <s:property value="mapVals.get(#val.getKey())"/>-<s:property value="#st.index"/>-<s:property value="#st.count"/><br>
3 s:iterator>

或者写为

1 <s:iterator value="mapVals.keySet()" var="keyId" begin="0" end="5" status="st" step="2">
2 <s:property value="mapVals.get(#keyId)"/>-<s:property value="#st.index"/>-<s:property value="#st.count"/><br>
3 s:iterator>

一些其他的表单标签

1 <s:textfield label="username" name="%{user.username}"/>
2 <s:checkboxlist name="name" label="多选框" list="#{'1':'Nick','2':'lily','3':'Mary' }" listKey="key" listValue="value" value="#{'1','2'}"/>
3 <s:radio label="Conutry" name="Conutry" value="2" list="#{'1':'中国','2':'美国','3':'俄罗斯' }" listKey="key" listValue="value"/>
4 <s:select list="users" label="姓名" value="1" listKey="id" listValue="username" headerKey="-1" headerValue="请选择"/>

这些标签虽然能很好的完成任务，但是不怎么灵活，一般来说前端的这些控件或多或少的都需要的添加自定义的样式，所以这些标签出现的机会比较少，只是简单记录一下。
还有很多其他的标签，比如form等，HTML自带标签完全可以满足一般需求。
这里特别提一下两个工具类的标签，其中格式化时间的date标签用的比较频繁，其次格式化数字的标签number，可以用来截取数字长度，四舍五入等操作

1 <s:date name="time" format="yyyy-MM-dd"/>
2 <s:number name="money"/>

都较瘦 2014-10-31 17:54 发表评论

温故知新:struts2_03参数的传递

都较瘦 — Thu, 30 Oct 2014 08:38:00 GMT

摘要: struts2的参数传递和OGNL息息相关，先从几个OGNL的案例来感受一下OGNL的概念和作用，不赘述，直接百科传送门：http://baike.baidu.com/view/1347280.htm。使用OGNL可以极为灵活的在页面上对目标对象进行存取操作，而不仅仅是只是数据的展示。下面使用OGNL给出几个常用的例子。测试用实体类User和DepartmentCode highlighting ... 阅读全文

都较瘦 2014-10-30 16:38 发表评论

温故知新:struts2_02请求和处理的映射

都较瘦 — Wed, 29 Oct 2014 16:38:00 GMT

请求和处理的映射，也就是常说的action和url之间的关系，struts2提供了很多种方式来配置他们之间的映射，01中提到的struts.xml配置

就是一种方式。这个配置中，就已经能很明显的看出action和url之间的关系，只是这段配置没有指明具体调用action中的哪个方法，所有默认调用了execute方法，虽然比较笨拙，但是这可以记为配置映射的第一个方法。需要特别一提的是struts.action.extension配置，它代表了action的后缀名，逗号隔开。也就是说，它指定了哪些结尾的请求为struts请求，默认是action和空结尾的请求。

方法一：
一个action只对应一个请求，默认调用execute方法，这样，为了满足业务需求，package中就会出现大量的action配置。实际开发中，除非这个请求进行的操作非常多，以至于书写的代码几千行，甚至上万行，否则一般不会这么配置，就算真的出现这样的情况，也极有可能和其他配置方式混搭使用，单独使用的比较少。
优点：配置简单明了，而且action中只有一个方法，方便阅读
缺点：会出现大量的action配置，大量的action类

方法二：
为了让一个action能够对应多个请求，可以在方法一的基础上为action的配置添加method属性

1 xml version="1.0" encoding="UTF-8"?>
2 DOCTYPE struts PUBLIC
3     "-//Apache Software Foundation//DTD Struts Configuration 2.3//EN"
4     "http://struts.apache.org/dtds/struts-2.3.dtd">
5 <struts>
6
7    <package name="helloworld" extends="struts-default" namespace="/">
8       <action name="hello" method="method01"
9             class="demo.action.HelloWorld">
10             <result name="success">/helloWorld.jspresult>
11       action>
12    package>
13
14 struts>

如此一来，action中的method01方法就会对应/hello请求。
优点：可以减少action类的数量
缺点：还是有大量的配置！！

方法三：
这种请求和处理的映射有点类似于将方法名当做参数来传递，struts.xml的配置和方法一一致，无需更改，只是在发送请求的时候需要将请求的方法一并发送，原始的请求是/hello，而连带方法名的请求是/hello!hello，或者还可以写/hello?method:hello（假定Helloworld类中有hello方法），这样一来，就是直接调用hello方法来完成处理。
优点：不仅可以完成一个action和多个请求的映射，还能减少action的配置，仅仅只是额外配置action的result即可
缺点：地址注意不能写错，实际开发中不常用，或许只是看起来请求地址怪怪的。。。但依然是个不错的配置方式

方法四：
基于通配符的映射

1 xml version="1.0" encoding="UTF-8"?>
2 DOCTYPE struts PUBLIC
3     "-//Apache Software Foundation//DTD Struts Configuration 2.3//EN"
4     "http://struts.apache.org/dtds/struts-2.3.dtd">
5 <struts>
6
7    <package name="helloworld" extends="struts-default" namespace="/">
8       <action name="*_*"
9             class="demo.action.{1}action" method="{2}">
10             <result name="success">/{1}/{2}.jspresult>
11       action>
12    package>
13
14 struts>

显而易见，任何形式的“XX_XX”请求都会得到映射，{1}代表第一个*的值，{2}代表第二个，以此类推，最主要的是，一定要从action的名称，到action内的方法，直至最后响应视图的位置，都要好好的在请求中写好。基于通配符的配置方式显得十分灵活，但也要求十分的细心，是一种能同时简化action类和配置内容的映射方式。这里要特别提到result的结果，结果可以是struts提供的SUCCESS，ERROR等但不限于这些返回结果，自定义的返回结果只要有对应的相应视图即可。
优点：配置灵活，精简
缺点：配置时要求仔细，使用统一的规则，所谓的“约定优于配置”

实际开发中，根据各个配置方式的优缺点自行选择，配置没有绝对的好坏

都较瘦 2014-10-30 00:38 发表评论

温故知新:struts2_01整体流程感受

都较瘦 — Wed, 29 Oct 2014 07:52:00 GMT

使用了一阵子struts2，但是一直没能好好整理一下，所以将平时学习工作中的一些心得记录一下，温故知新，时刻保持空杯心态。

环境如下
系统：64位win7

测试环境：

先从一个helloworld的简单案例开始吧
新建一个maven项目，选择

其实不论使用哪个框架技术，都无非三步走，import，config，run，首先，我们import
因为使用maven来管理项目，所以直接添加struts2的依赖到pom.xml

    <dependency>
        <groupId>org.apache.strutsgroupId>
        <artifactId>struts2-coreartifactId>
        <version>2.3.7version>
    dependency>

之后，我们开始config，具体配置哪些呢，首先要让struts2去过滤请求，那么肯定要在web.xml中配置struts2的过滤器，然后还需要让struts2知道请求和控制器之间的关系，那么肯定还需要再给struts2单独进行配置。
首先添加struts2的过滤器到web.xml中

    <filter>
      <filter-name>struts2filter-name>
      <filter-class>
         org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter
      filter-class>
   filter>
   <filter-mapping>
      <filter-name>struts2filter-name>
      <url-pattern>/*url-pattern>

</filter-mapping>

其次添加struts2的配置struts.xml，特别说一下constant的name值是配置在org.apache.struts.default.properties中的，还有其他常用的常量，比如struts.action.extension=action,,，请求后缀等
配置头部的dtd在jar包中会有struts-2.X.dtd的配置，也不用到处搜索了。

xml version="1.0" encoding="UTF-8"?>
DOCTYPE struts PUBLIC
    "-//Apache Software Foundation//DTD Struts Configuration 2.3//EN"
    "http://struts.apache.org/dtds/struts-2.3.dtd">
<struts>

   <constant name="struts.devMode" value="true" />
   <package name="helloworld" extends="struts-default" namespace="/">
      <action name="hello"
            class="demo.action.HelloWorld">
            <result name="success">/helloWorld.jspresult>
      action>
   package>

struts>

action的内容

package demo.action;

public class HelloWorld {
    public String execute() {
        System.out.println("Hello Struts2");
        return "success";
    }
}

整个配置的过程就是这样了，非常简易。

都较瘦 2014-10-29 15:52 发表评论