Struts2（原理笔记下）

╰半橙微兮° 2022-06-04 01:55 284阅读 0赞

### 国际化和获得资源包内容 ###

创建一个消息资源包

一个资源包由多个文件组成，这些文件名都有命名规范：主要文件名\_语言代码.properties。语言代码：由iso规定。

当文件只有主要文件名.properties时，表明它是默认资源包。浏览器会根据不同语言环境找对应语言环境的资源包，当没有时，找默认的。

message\_zh\_CN.properties message\_zh\_HK.properties message\_en\_US.properties

读取资源包中内容

第一种方式：ResourceBundle.getBundle(String baseName)：获取类加载器（src）的默认语言环境的资源包

第二种方式：jstl的fmt标签

第三种：Struts2的国际化

### Struts2的国际化（了解） ###

使用步骤：

1.前提，动作类必须继承ActionSupport类

2.回顾Struts2上部分，我们知道有default.properties加载配置文件有设置参数，其中就有国际化参数设置

struts.custom.i18n.resources=testmessages,testmessages2

在struts.xml中配置属性<constant name="" value="包名+文件名（不带后缀名properties）">

3.在Action中使用getText("key");获取message属性（getText是ActionSupport类的一个国际化的方法）

action中资源包查找循序是就近原则(动作类资源(动作类名称)>包(package)>全局)

在jsp使用国际化，导入Struts2标签，使用<s:text name="key">，当找不到key值，直接把name属性的值输出页面

jsp中资源包是全局资源（struts.xml配置的地方），因为jsp不是action（没有动作类范围和包范围一说）

在jsp也可以使用<s:i18n name="资源包名称"><s:text name="key"/></s:i18n>指定配置文件地址

### Struts2中的拦截器（特别重要） ###

拦截器的重要性：Struts2的很多功能都是由拦截器完成，比如

servletConfig拦截器：给action实现 ServletRequestAware，ServletResponseAware等注入对象。

staticParame拦截器：静态参数拦截器，主要是struts.xml文件中定义的param标签的参数进行动态注入。

params拦截器：动态参数拦截器，主要是把请求参数封装给action的属性中（拦截器从上往下执行，所以动态覆盖静态拦截器）

modelDriven拦截器：模型驱动，主要是给bean封装参数用的，参数不需要写对象名，因为压栈后，只有属性Key和value。

自定义拦截器：

1.实现Interceptor接口的三个方法

destroy();//销毁，只执行一次

init();//初始化方法，只执行一次

intercept(ActionInvocation invocation);//拦截方法，访问action之前执行,参数可以获取action类

或者继承AbstractInterceptor抽象类（推荐）

好处：只需要实现抽象方法intercept，初始化和销毁方法可以无视（类似适配器模式）

2.在struts2中配置拦截器声明

3.使用自定义拦截器（当配置了任何一个拦截器后，默认的拦截器栈就不会工作了）

<interceptors-ref name="demo1">

4.这时候就拦截了，但是需要放行

invocation.invoke();//此方法有String类型的返回值，返回的就是结果视图的名称！！！

所以拦截器正着走一遍，执行完最后一个拦截器时候，返回结果视图,然后反着走一边!!!

既然是结果视图名称,所以可以动态的改变返回视图的名称，比如你明明返回success,但是因为

报错，直接返回到错误页面，就是因为拦截器动态的改变了结果视图名称。

拦截器的执行顺序

与声明无关，主要看<interceptor-ref>引用的顺序

使用拦截器后，默认拦截器失效（重点）

<interceptor-stack name="myDefaultStack">

<interceptor-ref name="defaultStack"></interceptor>

<interceptor-ref name="xxx"></interceptor>

</interceptor-stack>

</interceptors>

以上设置后引用就可以使用，但还是需要在每个要用到地方使用拦截器应用

解决办法：覆盖struts-default.xml配置文件中默认的拦截器栈，让我们定义的称为默认的

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

但是又出现问题，登录动作类也被拦截了，这时候需要继承MethodFilterInterceptor(interceptor的实现类其中一种)

MethodFilterInterceptor中有两个参数

Set<String> excludeMethods:排除方法

Set<String>includeMethods:添加方法

我们都知道，可以在xml中静态注入参数（因为有staticParame拦截器）

<interceptor-stack name="myDefaultStack">

<interceptor-ref name="defaultStack"></interceptor>

<interceptor-ref name="xxx">

<param name="excludeMethods">login</param>

</interceptor>

</interceptor-stack>

</interceptors>

又有个问题是，我们一开始不知道拦截那个方法，所以直接在不需要被拦截的action中配置(开发中推荐)

<interceptor-ref name="myDefaultStack">

</interceptor>

### Struts2的文件上传和下载 ###

Struts2文件上传

文件上传必要前提：

请求必须是post

enctype属性必须是multipart/form-data

提供文件选择域

以下是jsp代码和action代码

<s:form action="user" method="post" enctype="multipart/form-data"> <s:textfield name="name" label="姓名"></s:textfield> <s:file name="photo" label="上传文件"></s:file> <s:submit value="提交"></s:submit> </s:form>

private String name; private File photo;//上传文件 private String photoFileName;//上传文件名称。上传字段名称+FileName 注意大小写 private String photoContentType;//上传文件的MIME类型 public String upload(){ //拿到servletContext ServletContext context = ServletActionContext.getServletContext(); //此方法返回的是服务器真实地址（就是服务器发布后的地址，如果查看文件，只能在部署服务器的项目中去查看） String path = context.getRealPath("WEB-INF/files"); //不存在创建 File file=new File(path); if(!file.exists()){ file.mkdirs(); } //剪切：把临时文件剪切到指定位置并且给他重命名(因为文件过大会产生临时文件,剪切临时文件没有了) photo.renameTo(new File(file,photoFileName)); return null; }

Struts2上传大小限制（默认是2MB）

第一种方式：如果想更改就会想到default.properties中的常量属性

struts.multipart.maxSize=2097152

所以在xml去覆盖常量值（加载顺序请看Struts2原理上）

第二种方式：通过FileUploadInterceptor拦截器静态注入参数,看源码属性有个叫maximumSize（行不通····，可能是上面问题把）

Struts2上传类型和扩展名

看FileUploadInterceptor源码（注意设置param的时候，通过set属性名称，获取属性名称开头转为小写）

protected Long maximumSize; protected Set<String> allowedTypesSet;//上传类型 看set方法的属性名 protected Set<String> allowedExtensionsSet;//扩展名 看set方法的属性名 private PatternMatcher matcher; private Container container;

<action name="user" class="com.mck.resource.UserAction" method="upload"> <result name="input">/NewFile.jsp</result> <interceptor-ref name="defaultStack">  <param name="fileUpload.allowedExtensions">png,jpg</param> </interceptor-ref> </action>

Struts2多个文件上传，把file属性改成数组，fileFileName改成数组就可以了

Struts2文件下载

通过结果类型stream来下载文件

<result-type name="stream" class="org.apache.struts2.dispatcher.StreamResult"/>

<result name="success" type="stream">  <param name="contentType">application/octet-stream</param>   <param name="contentDisposition">attachment;filename=${@java.net.URLEncoder@encode(filename,"UTF-8")}</param>  <param name="inputName">inputStream</param> </result>

###    OGNL(非常重要) ###

什么是OGNL

对象图导航语言，struts2框架使用的ognl作为默认的表达式语言。

OGNL的功能

在struts2中，想使用OGNL必须使用struts2的标签库

自定义jstl标签

1.编写一个普通的类，提供一个实现功能的静态方法

2.在WEB-INF目录中创建一个扩展名.tld文件，文件不能放在classes和lib目录中

<?xml version="1.0" encoding="UTF-8" ?> <taglib xmlns="http://java.sun.com/xml/ns/j2ee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-jsptaglibrary_2_0.xsd" version="2.0"> <tlib-version>1.0</tlib-version> <short-name>mf</short-name> <uri>http://www.cc.com/function/myfunciton</uri>  <function> <name>caps</name> <function-class>com.cc.MyFunction</function-class>  <function-signature>java.lang.String toUpperCase( java.lang.String )</function-signature> </function> </taglib>

编写好的tld文件，在jsp调用  
<%taglib uri="" prefix="mf"%>

$\{my:caps\}来调用转换大小写功能！！！

el表达式：只能调用静态方法，而OGNL表达式，它可以访问普通方法

表达式(el，jsp表达式，struts2表达式)

el表达式：$\{\}

jsp表达式:<%=%>

OGNL表达式:<s:property value="OGNL-Expression"/>输出结果为0

value属性中内容不在是字符串，它是一个OGNL表达式，如果想变成字符串，在值上套单引号

<s:property value="'OGNL-Expression'"/>输出为OGNL-Expression

<s:property value="'OGNL-Expression'.length()"/>打印长度（可以看出，能调用普通方法）

访问静态属性的方式：@全类名@静态属性名称

<s:property value="@java.lang.Integer@MAX\_VALUE"/>

访问静态方法的方式：@全类名@静态方法名称

<s:property value="@java.lang.Math@random()"/>

值得注意文件下载地方出现的$\{\}也是OGNL表达式用法，

<param name="contentDisposition">attachment;filename=${@java.net.URLEncoder@encode(filename,"UTF-8")}</param>

注意：struts2默认是禁止访问静态方法的，需要覆盖常量struts.ognl.allowStaticMethodAccess=false改为true

Struts2中标签的OGNL使用

\{\}就相当于创建一个list集合，list属性中取值是一个OGNL表达式

<s:radio name="gender"list="\{‘男’,'女'\}"></s:radio>

\#\{\}就相当于创建一个map集合，map属性key中取值是一个OGNL表达式

<s:radio name="gender"list="\#\{‘1’：'男','2'：'女'\}"></s:radio>

这里面牵扯到stack和contextmap问题，记住一句话，contextmap中的获取用\#,stack的直接获取

### contextMap(非常重要) ###

OGNL的上下文就是contextMap(贯穿整个action的生命周期)，除了value stack（list集合，特性是栈）外其他都是map类型（特性是不可重复）

![Center][]

明确：动作类是多列的，每次动作访问，动作类都会实例化，所以线程是安全的

问题：

每次请求时，都会产生请求数据，这些数据存放在那里？

明确：

在每次动作类执行前，核心控制器StrutsPrepareAndExecuteFilter都会创建一个ActionContext（维护一个名字叫context的map）和ValueStack对象，且每次动作访问都会创建,并且ActionContext绑定在ThreadLocad中，保证的线程数据的唯一性和安全性

public void doFilter(ServletRequest req, ServletResponse res, FilterChain chain) throws IOException, ServletException { HttpServletRequest request = (HttpServletRequest) req; HttpServletResponse response = (HttpServletResponse) res; try { if (excludedPatterns != null && prepare.isUrlExcluded(request, excludedPatterns)) { chain.doFilter(request, response); } else { prepare.setEncodingAndLocale(request, response); prepare.createActionContext(request, response);//给ActionContext设置值 prepare.assignDispatcherToThread(); request = prepare.wrapRequest(request); ActionMapping mapping = prepare.findActionMapping(request, response, true); if (mapping == null) { boolean handled = execute.executeStaticResourceRequest(request, response); if (!handled) { chain.doFilter(request, response); } } else { execute.executeAction(request, response, mapping); } } } finally { prepare.cleanupRequest(request); } }

public ActionContext createActionContext(HttpServletRequest request, HttpServletResponse response) {         ActionContext ctx;         Integer counter = 1;         Integer oldCounter = (Integer) request.getAttribute(CLEANUP_RECURSION_COUNTER);         if (oldCounter != null) {             counter = oldCounter + 1;         }                  ActionContext oldContext = ActionContext.getContext();//这是老的ActionContext         if (oldContext != null) {             // detected existing context, so we are probably in a forward             ctx = new ActionContext(new HashMap<String, Object>(oldContext.getContextMap()));//原先的数据设置进去，因为有application         } else {             ValueStack stack = dispatcher.getContainer().getInstance(ValueStackFactory.class).createValueStack();             stack.getContext().putAll(dispatcher.createContextMap(request, response, null));//把requset和response设置给stack栈中             ctx = new ActionContext(stack.getContext());//创建ActionContext并且把stack（list）存入ActionContext中         }         request.setAttribute(CLEANUP_RECURSION_COUNTER, counter);         ActionContext.setContext(ctx);         return ctx;     }

我们知道拦截器在拦截后，把请求和响应设置给ValueStack,从源码可知，ValueStack中维护一个context(map)集合。

这时候又把map设置给了ActionContext的map中，这不是多此一举？不，在上面已经说了ActionContext中维护一个ThreadLoad集合的ActionContext，也就是获取map仅当前线程的map，保证了数据的安全性！！！，并且次类的方法大部分是静态，方便调用方法，所以把ActionContext类也可以看做工具类

问题：

既然知道context（map）还是在ValueStack封装进去，那么，ValueStack我们还说是一个list集合呢？

明确：

ValueStack源码可知道，虽然维护了一个map，但是ValueStack为抽象类，而抽象类中的抽象方法被OgnlValueStack实现了，实现的就是栈存储结构方式，而OgnlValueStack有个属性叫做CompoundRoot，而CompoundRoot里面维护一个list

public class CompoundRoot extends CopyOnWriteArrayList<Object> {
    
        private static final long serialVersionUID = 8563229069192473995L;
    
        public CompoundRoot() {
        }
        public CompoundRoot(List<?> list) {
            super(list);
        }
        public CompoundRoot cutStack(int index) {
            return new CompoundRoot(subList(index, size()));
        }
        public Object peek() {
            return get(0);
        }
        public Object pop() {
            return remove(0);
        }
        public void push(Object o) {
            add(0, o);
        }
    }

所以，我们操控的ValueStack的方法时候实际就是操控一个list集合，并且是压栈的方式存储数据，而context（map）中也添加了ValueStack的一份引用，所以 ActionContext的map就是ValueStack中的map传递进来的,所以ValueStack叫值栈（栈结构）,其他就是contextmap。哦了

问题：action是多列的，那么actionContext如何知道那个action对应那个actionContext，不会出现线程安全问题？

明确：actionContext内部使用ThreadLocal，所以返回都是当前线程的actionContext，保证了安全性(actionContext是map结构)

查看ContextMap中的数据，使用<s:debug/>标签查看（不列举图片），可以看出，上部分是value stack，下部分是contextMap

### **获取ActionContext** ###

在动作类中使用ActionContext.getContext();//静态方法

ActionContext context=ActionContext.getContext();

context.put("abc","hello context");//把数据直接存入actionContext维护context中（大map中）

//如果想存入context（map）的小map中（session,request,application）

//第一种方式：获取session

context.getSession();//获取context中key为session的value（看源码可知）

//第二种方式：获取session

ServletActionContext.getRequset.getSession();

![Center 1][]

ActionContext和ServletActionContext都可以获得域对象，从代码片段可以看出，ServletActionContext是继承ActionContext，对域对象进行封装，也就是说，底层一样是获取map中的key值

public class ServletActionContext extends ActionContext implements StrutsStatics {

public static HttpServletRequest getRequest() {
            return (HttpServletRequest) ActionContext.getContext().get(HTTP_REQUEST);//还是操控map
        }

以上两种方式，能用ActionContext对象满足就尽量使用ActionContext,另外，不要在Action还没实例化的时候去通过ActionContext调用方法，因为Action实例在ActionContext实例之前创建，ActionContext中一些值还没有设置，会返回null。

总结：我们知道了ActionContext维护了一个线程安全的context(map)，并且可以获取map中的key(session,request,application等获取这些value，还是map),并且推荐使用actionContext。

### jsp页面获取ContextMap中的数据 ###

使用<s:property>来获取ActionContext中的数据

<s:property value="\#abc">//获取map中的key,自己添加的key

<s:property value="\#session.abc>//获取大map中session（也是个map）在key,key.key

### ValueStack操作 ###

获取ValueStack方式

1.通过ActionContext.getRequest.getAttribute("struts.valueStack");

2.ActionContext.getContext.getValueStack();//推荐，上面已经说过map中维护着一份ValueStack的集合

给valueStack压入值

vs.push(new Student());

vs.setValue("name","张山")//把ValueStack中第一个name属性值换成张山，如果没有name属性，就报错！！！

vs.setValue("\#name","张山")//把数据放在contextMap中key为name，value为张山

vs.set(key,object)//把数据存入到map中压入栈顶，获取直接key.属性(object.属性)

在jsp获取valueStack值

<s:property value="name">//取valueStack中的对象属性时，不使用\#，它是从栈顶逐个对象查找指定属性，找到了就不找了。

<s:property value="\[1\].name">获取第二个name

默认Action是栈顶，上面操作，Action就不是栈顶

### ValueStack的findValue和findString方法 ###

vs.findValue("name");一样可以拿到valueStack的栈结构的属性<s:property>标签底层就是findValue

而 vs.findValue("\[0\].name")；//是排除valueStack第一个索引往后的name

而 vs.findValue("\[3\].name")；//是排除valueStack第三个索引往后的name开始找

底层用到的一个（cutStack(index)）切片方法，\[index\]，就从索引位置开始切片

subList(index,size())，可以看出给1的时候，list集合第1个位置没有了，也就是索引0没有了

### Struts2对EL表达式的改变（非常重要） ###

问题：

为什么el表达式也能获取到action类中属性，el表达式查找循序明明是page->request->session->application

明确：

这是因为el表达式在获取request的时候获取的是一个包装的request对象，源码

public class StrutsRequestWrapper extends HttpServletRequestWrapper {
       public Object getAttribute(String key) {
            if (key == null) {
                throw new NullPointerException("You must specify a key value");
            }
    
            if (disableRequestAttributeValueStackLookup || key.startsWith("javax.servlet")) {
                // don't bother with the standard javax.servlet attributes, we can short-circuit this
                // see WW-953 and the forums post linked in that issue for more info
                return super.getAttribute(key);
            }
    
            ActionContext ctx = ActionContext.getContext();
            Object attribute = super.getAttribute(key);//调用父类的request看有没有key，有就直接返回，没有就执行下面方法
    
            if (ctx != null && attribute == null) {
                boolean alreadyIn = isTrue((Boolean) ctx.get(REQUEST_WRAPPER_GET_ATTRIBUTE));
    
                // note: we don't let # come through or else a request for
                // #attr.foo or #request.foo could cause an endless loop
                if (!alreadyIn && !key.contains("#")) {
                    try {
                        // If not found, then try the ValueStack
                        ctx.put(REQUEST_WRAPPER_GET_ATTRIBUTE, Boolean.TRUE);
                        ValueStack stack = ctx.getValueStack();//获取值栈
                        if (stack != null) {
                            attribute = stack.findValue(key);//值栈中查找key，我们知道值栈默认压入action,而action中的属性名变成key
                        }
                    } finally {
                        ctx.put(REQUEST_WRAPPER_GET_ATTRIBUTE, Boolean.FALSE);
                    }
                }
            }
            return attribute;
        }

源码一步了然，所以el表达式变成

page->request->valueStack->contextMap->session->application  
而OGNL表达式（当我们不写\#号，他就会从值栈的栈顶找对应的属性，如果没有属性，还要去ActionContext中map的key找）

Struts2常用标签

<s:iterator value="" var="">//value属性：要遍历的集合，是OGNL表达式，获取stack直接名称，获取map加上\#

遍历过程中集合被压入栈顶，所以通过$\{s.属性名\}一样可以取出

### Struts2中的\#,$,%符号的使用(重要) ###

### \# ###

a、取contextMap中key时使用，例如<s:property value="\#name"/>

b、OGNL中创建Map对象时使用，例如：<s:radio list="\#\{ 'male':'男','female':'女'\}" />

** $**

a、在JSP中使用EL表达式时使用，例如$\{ name\}

b、在xml配置文件中，编写OGNL表达式时使用，例如文件下载时，文件名编码。

struts.xml——>$\{ @java.net.URLEncoder.encode(filename)\}

### % ###

在struts2中，有些标签的value属性取值就是一个OGNL表达式，例如<s:property value="OGNL Expression" />

还有一部分标签，value属性的取值就是普通字 符串，例如<s:textfield value="username"/>，如果想把一个普通的字符串强制看成时OGNL，就需要使用%\{\}把字符串套起来。

例如<s:textfield value="%\{ username\}"/>。当然在<s:property value="%\{ OGNL Expression\}"/>也可以使用，但不会这么用。

### ModelDriven的工作原理 ###

public String intercept(ActionInvocation invocation) throws Exception {
            Object action = invocation.getAction();//获取action
    
            if (action instanceof ModelDriven) {//如果实现ModelDriven接口
                ModelDriven modelDriven = (ModelDriven) action;//强转
                ValueStack stack = invocation.getStack();//获得valueStack
                Object model = modelDriven.getModel();//获得Model对象
                if (model !=  null) {
                	stack.push(model);//把model对象压入栈顶，所以在表单中不用输入对象.name就是因为值栈中有这个对象对应的属性名称
                }
                if (refreshModelBeforeResult) {
                    invocation.addPreResultListener(new RefreshModelBeforeResult(modelDriven, model));
                }
            }
            return invocation.invoke();
        }

### Struts2中表单重复提交问题 ###

问题：

用户登录后，刷新页面，重复提交表单数据

明确：

表单提交后使用重顶向解决问题

问题：

虽然上面问题解决了，但是用户后退上一个页面，再次点击登录，还是可以重复提交，就成一个问题

明确：

使用struts2的标签<s:token>令牌的意思。

要想让标签生效，需要使用struts2的一个token拦截器

这时候重复提交没有效果，并且后退再次提交会报错错误提示是No result defined for action result  invalid.token

意思是没有定义一个结果视图invalid.token，所以我们需要在<result name="invalid.token">/错误页面.jsp</result >