下载struts2.5.26jar包
 
官网下载
 
更新jar
 
新增或替换
 
asm-7.3.1.jar
asm-analysis-7.3.1.jar
asm-commons-7.3.1.jar
asm-tree-7.3.1.jar
commons-lang3-3.8.1.jar
commons-io-2.6.jar
commons-fileupload-1.4.jar
javassist-3.20.0-GA.jar
log4j-api-2.12.1.jar
ognl-3.1.28.jar
struts2-core-2.5.26.jar
struts2-json-plugin-2.5.26.jar
struts2-junit-plugin-2.5.26.jar
struts2-spring-plugin-2.5.26.jar
xpp3_min-1.1.4c.jar
xstream-1.4.11.1.jar
xmlpull-1.1.3.1.jar
 
删除
 
xwork-core-2.3.32.jar
2.5.X已把xwork-core整合到struts2-core，所以删除
 
修改web.xml
 
<filter>
	<filter-name>struts2</filter-name>
	<filter-class>org.apache.struts2.dispatcher.filter.StrutsPrepareAndExecuteFilter</filter-class>
</filter>
 
修改weblogic.xml(如果有)
 
新增session-descriptor
 
<weblogic-web-app>
	<session-descriptor>
		<cookie-name>JSESSIONID1</cookie-name>
	</session-descriptor>
</weblogic-web-app>
 
修改struts.xml
 
2.1–》2.5
 
<!DOCTYPE struts PUBLIC "-//Apache Software Foundation//DTD Struts Configuration 2.5//EN" "http://struts.apache.org/dtds/struts-2.5.dtd">
 
新增配置
 
package标签添加strict-method-invocation="false"和下列标签。
global-allowed-methods：放最下面，过滤自定义action的方法，不然不能访问
如果已经配置struts.properties，可不加constant标签
 
<constant name="struts.enable.DynamicMethodInvocation" value="true"/>
<constant name="struts.enable.SlashesInActionNames" value="true"/>
<constant name="struts.action.extension" value="do" />
<package extends="struts-default" strict-method-invocation="false">
	<global-results>
    </global-results>
    <global-allowed-methods>regex:.*</global-allowed-methods>
</package>
 
修改struts.xml的result-types配置
 
注释部分为struts2.3.32配置
 
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE struts PUBLIC
    "-//Apache Software Foundation//DTD Struts Configuration 2.5//EN"
    "http://struts.apache.org/dtds/struts-2.5.dtd">
<struts>
	<package name="struts-default" abstract="true"  strict-method-invocation="false">
		<result-types>
            <result-type name="chain" class="com.opensymphony.xwork2.ActionChainResult"/>
            <!-- <result-type name="dispatcher" class="org.apache.struts2.dispatcher.ServletDispatcherResult"/> -->
            <result-type name="dispatcher" class="org.apache.struts2.result.ServletDispatcherResult" default="true"/>
            <result-type name="freemarker" class="org.apache.struts2.views.freemarker.FreemarkerResult" default="true"/>
            <!-- <result-type name="httpheader" class="org.apache.struts2.dispatcher.HttpHeaderResult"/>
            <result-type name="redirect" class="org.apache.struts2.dispatcher.ServletRedirectResult"/>
            <result-type name="redirectAction" class="org.apache.struts2.dispatcher.ServletActionRedirectResult"/>
            <result-type name="stream" class="org.apache.struts2.dispatcher.StreamResult"/>
            <result-type name="velocity" class="org.apache.struts2.dispatcher.VelocityResult"/> -->
            <result-type name="httpheader" class="org.apache.struts2.result.HttpHeaderResult"/>
            <result-type name="redirect" class="org.apache.struts2.result.ServletRedirectResult"/>
            <result-type name="redirectAction" class="org.apache.struts2.result.ServletActionRedirectResult"/>
            <result-type name="stream" class="org.apache.struts2.result.StreamResult"/>
            <result-type name="velocity" class="org.apache.struts2.result.VelocityResult"/>
            <result-type name="xslt" class="org.apache.struts2.views.xslt.XSLTResult"/>
            <!-- <result-type name="plainText" class="org.apache.struts2.dispatcher.PlainTextResult" />
            <result-type name="postback" class="org.apache.struts2.dispatcher.PostbackResult" /> -->
            <result-type name="plainText" class="org.apache.struts2.result.PlainTextResult" />
            <result-type name="postback" class="org.apache.struts2.result.PostbackResult" />
            <!--自定义result-type-->
        	<result-type name="json" class="org.apache.struts2.json.JSONResult">
				<param name="root">jsonRoot</param>
			</result-type>			
        </result-types>
        <interceptors>
			<interceptor name="i18n" class="org.apache.struts2.interceptor.I18nInterceptor"/>
            <!-- <interceptor name="i18n" class="com.opensymphony.xwork2.interceptor.I18nInterceptor"/> -->
		</interceptors>
		<!-- 其他配置不变，这里略 -->
		<default-class-ref class="com.opensymphony.xwork2.ActionSupport" />
        <global-allowed-methods>regex:.*</global-allowed-methods>
    </package>
</struts>
 
如果重写了ParametersInterceptor.java类
 
原方法
 
protected Map<String, Object> retrieveParameters(ActionContext ac) {
    return ac.getParameters();
}
 
新方法
 
protected Map<String, String[]> retrieveParameters(ActionContext ac) {
   HttpParameters httpParameters = ac.getParameters();
   return httpParameters.toMap();
}
 
处理上传附件问题(2021.03.30修改)
 
修改struts.xml的interceptors配置
 
注释部分为struts2.3.32配置
 
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE struts PUBLIC
    "-//Apache Software Foundation//DTD Struts Configuration 2.5//EN"
    "http://struts.apache.org/dtds/struts-2.5.dtd">
<struts>
	<package name="struts-default" abstract="true"  strict-method-invocation="false">
		<result-types>
            <result-type name="chain" class="com.opensymphony.xwork2.ActionChainResult"/>
            <!-- <result-type name="dispatcher" class="org.apache.struts2.dispatcher.ServletDispatcherResult"/> -->
            <result-type name="dispatcher" class="org.apache.struts2.result.ServletDispatcherResult" default="true"/>
            <result-type name="freemarker" class="org.apache.struts2.views.freemarker.FreemarkerResult" default="true"/>
            <!-- <result-type name="httpheader" class="org.apache.struts2.dispatcher.HttpHeaderResult"/>
            <result-type name="redirect" class="org.apache.struts2.dispatcher.ServletRedirectResult"/>
            <result-type name="redirectAction" class="org.apache.struts2.dispatcher.ServletActionRedirectResult"/>
            <result-type name="stream" class="org.apache.struts2.dispatcher.StreamResult"/>
            <result-type name="velocity" class="org.apache.struts2.dispatcher.VelocityResult"/> -->
            <result-type name="httpheader" class="org.apache.struts2.result.HttpHeaderResult"/>
            <result-type name="redirect" class="org.apache.struts2.result.ServletRedirectResult"/>
            <result-type name="redirectAction" class="org.apache.struts2.result.ServletActionRedirectResult"/>
            <result-type name="stream" class="org.apache.struts2.result.StreamResult"/>
            <result-type name="velocity" class="org.apache.struts2.result.VelocityResult"/>
            <result-type name="xslt" class="org.apache.struts2.views.xslt.XSLTResult"/>
            <!-- <result-type name="plainText" class="org.apache.struts2.dispatcher.PlainTextResult" />
            <result-type name="postback" class="org.apache.struts2.dispatcher.PostbackResult" /> -->
            <result-type name="plainText" class="org.apache.struts2.result.PlainTextResult" />
            <result-type name="postback" class="org.apache.struts2.result.PostbackResult" />
            <!--自定义result-type-->
        	<result-type name="json" class="org.apache.struts2.json.JSONResult">
				<param name="root">jsonRoot</param>
			</result-type>			
        </result-types>
        <interceptors>
			<interceptor name="i18n" class="org.apache.struts2.interceptor.I18nInterceptor"/>
            <!-- <interceptor name="i18n" class="com.opensymphony.xwork2.interceptor.I18nInterceptor"/> -->
            <interceptor name="fileUpload" class="com.struts2.interceptor.FileUploadInterceptor"/>
<!--        <interceptor name="fileUpload" class="org.apache.struts2.interceptor.FileUploadInterceptor"/> -->
		</interceptors>
		<!-- 其他配置不变，这里略 -->
		<default-class-ref class="com.opensymphony.xwork2.ActionSupport" />
        <global-allowed-methods>regex:.*</global-allowed-methods>
    </package>
</struts>
 
FileUploadInterceptor.java
 
package com.struts2.interceptor;

import java.io.File;
import java.text.NumberFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;

import javax.servlet.http.HttpServletRequest;

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.apache.struts2.ServletActionContext;
import org.apache.struts2.dispatcher.LocalizedMessage;
import org.apache.struts2.dispatcher.Parameter;
import org.apache.struts2.dispatcher.multipart.MultiPartRequestWrapper;
import org.apache.struts2.dispatcher.multipart.UploadedFile;
import org.apache.struts2.util.ContentTypeMatcher;

import com.opensymphony.xwork2.ActionContext;
import com.opensymphony.xwork2.ActionInvocation;
import com.opensymphony.xwork2.ActionProxy;
import com.opensymphony.xwork2.LocaleProvider;
import com.opensymphony.xwork2.LocaleProviderFactory;
import com.opensymphony.xwork2.TextProvider;
import com.opensymphony.xwork2.TextProviderFactory;
import com.opensymphony.xwork2.inject.Container;
import com.opensymphony.xwork2.inject.Inject;
import com.opensymphony.xwork2.interceptor.AbstractInterceptor;
import com.opensymphony.xwork2.interceptor.ValidationAware;
import com.opensymphony.xwork2.util.TextParseUtil;


public class FileUploadInterceptor extends AbstractInterceptor {

    private static final long serialVersionUID = -4764627478894962478L;

    protected static final Logger LOG = LogManager.getLogger(FileUploadInterceptor.class);

    protected Long maximumSize;
    protected Set<String> allowedTypesSet = Collections.emptySet();
    protected Set<String> allowedExtensionsSet = Collections.emptySet();

    private ContentTypeMatcher matcher;
    private Container container;

    @Inject
    public void setMatcher(ContentTypeMatcher matcher) {
        this.matcher = matcher;
    }

    @Inject
    public void setContainer(Container container) {
        this.container = container;
    }

    /**
     * Sets the allowed extensions
     *
     * @param allowedExtensions A comma-delimited list of extensions
     */
    public void setAllowedExtensions(String allowedExtensions) {
        allowedExtensionsSet = TextParseUtil.commaDelimitedStringToSet(allowedExtensions);
    }

    /**
     * Sets the allowed mimetypes
     *
     * @param allowedTypes A comma-delimited list of types
     */
    public void setAllowedTypes(String allowedTypes) {
        allowedTypesSet = TextParseUtil.commaDelimitedStringToSet(allowedTypes);
    }

    /**
     * Sets the maximum size of an uploaded file
     *
     * @param maximumSize The maximum size in bytes
     */
    public void setMaximumSize(Long maximumSize) {
        this.maximumSize = maximumSize;
    }

    /* (non-Javadoc)
     * @see com.opensymphony.xwork2.interceptor.Interceptor#intercept(com.opensymphony.xwork2.ActionInvocation)
     */

    public String intercept(ActionInvocation invocation) throws Exception {
        ActionContext ac = invocation.getInvocationContext();

        HttpServletRequest request = (HttpServletRequest) ac.get(ServletActionContext.HTTP_REQUEST);

        if (!(request instanceof MultiPartRequestWrapper)) {
            if (LOG.isDebugEnabled()) {
                ActionProxy proxy = invocation.getProxy();
                LOG.debug(getTextMessage("struts.messages.bypass.request", new String[]{proxy.getNamespace(), proxy.getActionName()}));
            }

            return invocation.invoke();
        }

        ValidationAware validation = null;

        Object action = invocation.getAction();

        if (action instanceof ValidationAware) {
            validation = (ValidationAware) action;
        }

        MultiPartRequestWrapper multiWrapper = (MultiPartRequestWrapper) request;

        if (multiWrapper.hasErrors() && validation != null) {
            TextProvider textProvider = getTextProvider(action);
            for (LocalizedMessage error : multiWrapper.getErrors()) {
                String errorMessage;
                if (textProvider.hasKey(error.getTextKey())) {
                    errorMessage = textProvider.getText(error.getTextKey(), Arrays.asList(error.getArgs()));
                } else {
                    errorMessage = textProvider.getText("struts.messages.error.uploading", error.getDefaultMessage());
                }
                validation.addActionError(errorMessage);
            }
        }

        // bind allowed Files
        Enumeration fileParameterNames = multiWrapper.getFileParameterNames();
        while (fileParameterNames != null && fileParameterNames.hasMoreElements()) {
            // get the value of this input tag
            String inputName = (String) fileParameterNames.nextElement();

            // get the content type
            String[] contentType = multiWrapper.getContentTypes(inputName);

            if (isNonEmpty(contentType)) {
                // get the name of the file from the input tag
                String[] fileName = multiWrapper.getFileNames(inputName);

                if (isNonEmpty(fileName)) {
                    // get a File object for the uploaded File
                    UploadedFile[] files = multiWrapper.getFiles(inputName);
                    if (files != null && files.length > 0) {
                        List<File> acceptedFiles = new ArrayList<>(files.length);
                        List<String> acceptedContentTypes = new ArrayList<>(files.length);
                        List<String> acceptedFileNames = new ArrayList<>(files.length);
                        String contentTypeName = inputName + "ContentType";
                        String fileNameName = inputName + "FileName";

                        for (int index = 0; index < files.length; index++) {
                            if (acceptFile(action, files[index], fileName[index], contentType[index], inputName, validation)) {
                                acceptedFiles.add((File)files[index].getContent());
                                acceptedContentTypes.add(contentType[index]);
                                acceptedFileNames.add(fileName[index]);
                            }
                        }

                        if (!acceptedFiles.isEmpty()) {
                            Map<String, Parameter> newParams = new HashMap<>();
                            newParams.put(inputName, new Parameter.File(inputName, acceptedFiles.toArray(new File[acceptedFiles.size()])));
                            newParams.put(contentTypeName, new Parameter.File(contentTypeName, acceptedContentTypes.toArray(new String[acceptedContentTypes.size()])));
                            newParams.put(fileNameName, new Parameter.File(fileNameName, acceptedFileNames.toArray(new String[acceptedFileNames.size()])));
                            ac.getParameters().appendAll(newParams);
                        }
                    }
                } else {
                    if (LOG.isWarnEnabled()) {
                        LOG.warn(getTextMessage(action, "struts.messages.invalid.file", new String[]{inputName}));
                    }
                }
            } else {
                if (LOG.isWarnEnabled()) {
                    LOG.warn(getTextMessage(action, "struts.messages.invalid.content.type", new String[]{inputName}));
                }
            }
        }

        // invoke action
        return invocation.invoke();
    }

    /**
     * Override for added functionality. Checks if the proposed file is acceptable based on contentType and size.
     *
     * @param action      - uploading action for message retrieval.
     * @param file        - proposed upload file.
     * @param filename    - name of the file.
     * @param contentType - contentType of the file.
     * @param inputName   - inputName of the file.
     * @param validation  - Non-null ValidationAware if the action implements ValidationAware, allowing for better
     *                    logging.
     * @return true if the proposed file is acceptable by contentType and size.
     */
    protected boolean acceptFile(Object action, UploadedFile file, String filename, String contentType, String inputName, ValidationAware validation) {
        boolean fileIsAcceptable = false;

        // If it's null the upload failed
        if (file == null) {
            String errMsg = getTextMessage(action, "struts.messages.error.uploading", new String[]{inputName});
            if (validation != null) {
                validation.addFieldError(inputName, errMsg);
            }

            if (LOG.isWarnEnabled()) {
                LOG.warn(errMsg);
            }
        } else if (file.getContent() == null) {
            String errMsg = getTextMessage(action, "struts.messages.error.uploading", new String[]{filename});
            if (validation != null) {
                validation.addFieldError(inputName, errMsg);
            }
            if (LOG.isWarnEnabled()) {
                LOG.warn(errMsg);
            }
        } else if (maximumSize != null && maximumSize < file.length()) {
            String errMsg = getTextMessage(action, "struts.messages.error.file.too.large", new String[]{inputName, filename, file.getName(), "" + file.length(), getMaximumSizeStr(action)});
            if (validation != null) {
                validation.addFieldError(inputName, errMsg);
            }

            if (LOG.isWarnEnabled()) {
                LOG.warn(errMsg);
            }
        } else if ((!allowedTypesSet.isEmpty()) && (!containsItem(allowedTypesSet, contentType))) {
            String errMsg = getTextMessage(action, "struts.messages.error.content.type.not.allowed", new String[]{inputName, filename, file.getName(), contentType});
            if (validation != null) {
                validation.addFieldError(inputName, errMsg);
            }

            if (LOG.isWarnEnabled()) {
                LOG.warn(errMsg);
            }
        } else if ((!allowedExtensionsSet.isEmpty()) && (!hasAllowedExtension(allowedExtensionsSet, filename))) {
            String errMsg = getTextMessage(action, "struts.messages.error.file.extension.not.allowed", new String[]{inputName, filename, file.getName(), contentType});
            if (validation != null) {
                validation.addFieldError(inputName, errMsg);
            }

            if (LOG.isWarnEnabled()) {
                LOG.warn(errMsg);
            }
        } else {
            fileIsAcceptable = true;
        }

        return fileIsAcceptable;
    }

    private String getMaximumSizeStr(Object action) {
        return NumberFormat.getNumberInstance(getLocaleProvider(action).getLocale()).format(maximumSize);
    }

    /**
     * @param extensionCollection - Collection of extensions (all lowercase).
     * @param filename            - filename to check.
     * @return true if the filename has an allowed extension, false otherwise.
     */
    private boolean hasAllowedExtension(Collection<String> extensionCollection, String filename) {
        if (filename == null) {
            return false;
        }

        String lowercaseFilename = filename.toLowerCase();
        for (String extension : extensionCollection) {
            if (lowercaseFilename.endsWith(extension)) {
                return true;
            }
        }

        return false;
    }

    /**
     * @param itemCollection - Collection of string items (all lowercase).
     * @param item           - Item to search for.
     * @return true if itemCollection contains the item, false otherwise.
     */
    private boolean containsItem(Collection<String> itemCollection, String item) {
        for (String pattern : itemCollection)
            if (matchesWildcard(pattern, item))
                return true;
        return false;
    }

    private boolean matchesWildcard(String pattern, String text) {
        Object o = matcher.compilePattern(pattern);
        return matcher.match(new HashMap<String, String>(), text, o);
    }

    private boolean isNonEmpty(Object[] objArray) {
        boolean result = false;
        for (int index = 0; index < objArray.length && !result; index++) {
            if (objArray[index] != null) {
                result = true;
            }
        }
        return result;
    }

    protected String getTextMessage(String messageKey, String[] args) {
        return getTextMessage(this, messageKey, args);
    }

    protected String getTextMessage(Object action, String messageKey, String[] args) {
        if (action instanceof TextProvider) {
            return ((TextProvider) action).getText(messageKey, args);
        }
        return getTextProvider(action).getText(messageKey, args);
    }

    private TextProvider getTextProvider(Object action) {
        TextProviderFactory tpf = container.getInstance(TextProviderFactory.class);
        return tpf.createInstance(action.getClass());
    }

    private LocaleProvider getLocaleProvider(Object action) {
        LocaleProvider localeProvider;
        if (action instanceof LocaleProvider) {
            localeProvider = (LocaleProvider) action;
        } else {
            LocaleProviderFactory localeProviderFactory = container.getInstance(LocaleProviderFactory.class);
            localeProvider = localeProviderFactory.createLocaleProvider();
        }
        return localeProvider;
    }
}

 
修改xwork-conversion.properties配置
 
java.io.File=com.struts2.UploadedFileConverter
 
UploadedFileConverter.java
 
package com.struts2;

import java.io.File;
import java.lang.reflect.Array;
import java.lang.reflect.Member;
import java.util.Map;

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.apache.struts2.dispatcher.multipart.StrutsUploadedFile;
import org.apache.struts2.dispatcher.multipart.UploadedFile;

import com.opensymphony.xwork2.conversion.impl.DefaultTypeConverter;


public class UploadedFileConverter extends DefaultTypeConverter {

    private static final Logger LOG = LogManager.getLogger(UploadedFileConverter.class);

    @Override
    public Object convertValue(Map<String, Object> context, Object target, Member member, String propertyName, Object value, Class toType) {
        if (File.class.equals(toType)) {
            LOG.debug("Converting {} into {}, consider switching to {} and do not access {} directly!",
                    File.class.getName(), UploadedFile.class.getName(), UploadedFile.class.getName(), File.class.getName());

            Object obj;
            if (value.getClass().isArray() && Array.getLength(value) == 1) {
                obj = Array.get(value, 0);
            } else {
                obj = value;
            }

           if (obj instanceof UploadedFile) {
                UploadedFile file = (UploadedFile) obj;
                if (file.getContent() instanceof File) {
                    return file.getContent();
                }
                return new File(file.getAbsolutePath());
            }else {
            	return new File(obj.toString());
            }
        }

        return super.convertValue(context, target, member, propertyName, value, toType);
    }

}

1.Struts的几个基本概念
 
1.struts是一个开源框架（frameset） 
 2.struts是一个Web框架 
 3.struts是一个基于MVC的Web框架
 
2.为什么有struts
 
因为我们对MVC的理解不同，可能造成不同公司写程序的时候，规范不统一，这样不利于程序的维护和扩展以及提高开发效率，所以我们有必要用一个统一的规范来开发项目。所以出现了struts.
 
struts是通过采用Java的Servlet／JSP技术，实现了基于Java EE Web应用的Model-View-Controller（MVC）设计模式的应用框架，是MVC经典设计模式中的一个经典产品
 
struts的优缺点如下： 
 1.struts的好处：
 
 
 
程序更加规范化 
 程序开发的效率提高了 
 程序的可读性增加 
 程序的可维护性增加
 
 
2.struts的不足之处：
 
 
 
form表单有点鸡肋 
 action是单态（对网站并发性的处理有影响）
 
 
这些内容后面会介绍。
 
我们要知道的是：框架在提高了程序的规范的同时，也约束了程序员的自由。
 
3.struts的原理
 
以一个用户登录验证的例子说明。
 
3.1.时序图
 
 
1.ActionServlet是总控制器，它是struts给我们提供的，我们无需自己写，只需要配置即可。ActionServlet管理struts-config.xml文件，而这个文件是struts的核心文件，该文件配置了ActionForm，还配置了Action，以及它们的对应关系等。 
 2.ActionForm是表单，用于存放数据。开发ActionFrom必须要继承ActionForm类，这是规范。 
 3.Action是分控制器，在Struts中，Action可以有多个.它的本质就是Servlet。开发一个Action也要继承Action类。 
 4.Model(Java类，Service类，ejb等)
 
3.2.struts入门案例
 
以上述用户登录验证来演示，并且使用手动配置的方式来开发第一个struts项目，项目名称为strutslogin。 
 首先，项目目录结构如下所示：
 
 
【步骤】： 
 1.在开发struts的时候，需要struts的开发包
 
struts的开发包可到官网下载【下载地址】，它的最新版本是2.5.1（2016年6月21日）。由于目前所学为1.3的版本，所以我下载Struts 1.3.10。并把所有的jar包加入到当前项目的lib文件夹。
 
 
2.先写出login.jsp
 
写最简单的登录页面login.jsp，如下：
 
<%@ page language="java" import="java.util.*" pageEncoding="utf-8"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
  <head>
    <meta http-equiv="pragma" content="no-cache">
    <meta http-equiv="cache-control" content="no-cache">
    <meta http-equiv="expires" content="0">    
  </head>
  <body>
    <form action="/strutslogin/login.do" method="post">
        UserName:<input type="text" name="username"/><br><br>
        Password:<input type="password" name="password"/><br><br>
        <input type="submit" value="Login"/>    
    </form>
  </body>
</html>
 
注意，为了安全起见，login.jsp放在WEB-INF目录下，在WEB-INF目录外通过index.jsp转发到login.jsp。
注意form中的action跳转地址，是我们的web应用下的login.do页面，这里在稍后介绍的struts-config.xml配置中会再说明。 
 
  
 
3.编写ActionForm和Action
 
(1)首先需要编写ActionForm，即用户登录所用的表单，用于填充用户输入的数据。我们取名为UserForm，它继承自ActionForm类，如下：
 
public class UserForm extends ActionForm {

    private String username;
    private String password;

    public String getUsername() {
        return username;
    }
    public void setUsername(String username) {
        this.username = username;
    }
    public String getPassword() {
        return password;
    }
    public void setPassword(String password) {
        this.password = password;
    }
}
 
其实这就是一个很简单的JavaBean，它和login.jsp中的表单对应，我们在这个UserForm中定义属性username和password，并生成它们的setter和getter方法。 
 这里需要注意的是：
 
 
 
<1>.一般的规范：定义属性名称的时候应该和jsp页面的控件名称一样。 
 <2>.但其实，属性的名称并非一定要一致，而真正要保持一致的是setter和getter方法。也就是说，如果你在jsp中定义的控件名称为username和password，那么setter方法的名称一定是setUsername和setPassword，同理，getter方法的名称一定是getUsername和getPassword。属性可以换其他的名字，但是这几个方法的名称一定要固定格式:get/set+控件名称并且首字母大写 
 <3>.但我们遵守一般的规范最好。 
 <4>.ActionForm一定要按照上述规范写好，才能保证数据能够正确填充，才能保证work
 
 
（2）然后，编写Action，即登录的Action，我们取名为LoginAction，它必须继承自Action类，如下：
 
public class LoginAction extends Action {
    @Override
    public ActionForward execute(ActionMapping mapping, ActionForm form,
            HttpServletRequest request, HttpServletResponse response)
            throws Exception {
        // 把form转成对应的UserForm对象
        UserForm userForm = (UserForm)form;
        System.out.println("用户名="+userForm.getUsername());
        System.out.println("密码="+userForm.getPassword());
        // 简单验证
        if("123".equals(userForm.getPassword())){
            // 如果用户密码为123，则为合法
            return mapping.findForward("ok");
        }else{
            return mapping.findForward("error");
        }
    }
}
 
在这个类中，我们需要重写一个方法：excute。这个方法会处理业务逻辑，会自动调用，它有点类似于Servlet中的service方法，或者doGet/doPost方法。
 
 
4.配置struts-config.xml文件，这个文件一般放在/WEB-INF目录下，它配置Action、ActionForm以及它们的对应关系和跳转
 
<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE struts-config PUBLIC "-//Apache Software Foundation//DTD Structs Configuration 1.3//EN" "http://struts.apache.org/dtds/struts-config_1_3.dtd">

<struts-config>
    <!-- 配置表单 -->
    <form-beans>
        <!-- name是表单名字，可以随意写，但是建议取名规范：表单类名小写 -->
        <!-- type用于指定表单类的全路径 -->
        <form-bean name="userForm" type="com.gavin.forms.UserForm"></form-bean>     
    </form-beans>
    <!-- 配置Action -->
    <action-mappings>
        <!-- 配置一个具体的action -->
        <!-- path表示将来访问该action的资源名，http://localhost:8080/web/path -->
        <!-- name用于关联某个表单 -->
        <!-- type用于指定该Action类的全路径 -->
        <action path="/login" name="userForm" type="com.gavin.actions.LoginAction">
            <!-- 这里配置跳转关系 -->
            <!-- name表示结果名称，path表示转发到的页面地址 -->
            <forward name="ok" path="/WEB-INF/welcome.jsp"/>
            <forward name="error" path="/WEB-INF/error.jsp"/>
        </action>
    </action-mappings>
</struts-config>
 
（1）这个struts-config.xml引入了一个DTD文件：struts-config_1_3.dtd，这个文件可以在我们下载的jar包中找到，它定义了我们这个xml的约束，根元素为struts-config。 
 （2）该配置文件主要通过form-beans来配置ActionForm、通过action-mappings来配置Action。 
 （3）我们在form-beans下用form-bean来配置具体的ActionForm，比如当前文件配置了我们写的UserForm 
 （4）在action-mappings下用action来配置具体的Action，比如当前文件配置了我们写的LoginAction 
 （5）要注意这里action中的path参数配置，它就是我们的login.jsp中的表单action提交的地址，login.jsp中写的是login.do，这个login.do会交给struts的总控制器ActionServlet来处理，最后ActionServlet将通过一定的机制找到这里的path参数配置为/login的action，再通过该action配置的type参数找到具体的类。
 
从这个过程中我们可以发现，login.do在通过ActionServlet的处理后，最后找到的却是路径为/login的action，这似乎和.do这个后缀没有什么关系，的确是这样的，这个后缀只是习惯上的用法，我们完全可以在web.xml文件中将这个后缀设置成其他任何的名字。 
 （6）最后要在具体的action下配置跳转关系。这里配置的参数和LoginAction中的excute方法所写要对应起来。
 
 
5.写出welcome.jsp和error.jsp页面
 
写出两个简单的界面即可。
 
 
6.在web.xml中配置ActionServlet
 
struts的总控制器ActionServlet本质上还是一个Servlet，所以我们要在web.xml中配置，配置如下：
 
<servlet>
    <servlet-name>action</servlet-name>
    <servlet-class>org.apache.struts.action.ActionServlet</servlet-class>
    <!-- 指定配置文件struts-config.xml的路径 -->
    <init-param>
        <param-name>config</param-name>
        <param-value>/WEB-INF/struts-config.xml</param-value>
    </init-param>
</servlet>

<servlet-mapping>
    <servlet-name>action</servlet-name>
    <url-pattern>*.do</url-pattern>
</servlet-mapping>
 
我们要在该配置中指定struts-config.xml文件的地址。同时可以看到，我们在这里配置的后缀为*.do，也就是说所有以.do结尾的请求都要交给ActionServlet来处理。到这里，也就明白了为什么我们的login.jsp中写的提交地址为login.do。
 
4.总结
 
通过手工完成一个简单的struts项目，可以让我们对struts的工作流程和工作原理有更加深刻的认识。这个过程略微繁琐，后面会有工具直接生成，但是掌握底层原理是我们学习必不可少的一个步骤。
 
总结一下，其实struts是对我们通过JSP/Servlet和使用MVC模式开发项目的一个更高层次地提炼，它帮我们做了大部分工作，我们只需要按照struts框架提供的流程填充即可，简化了我们的开发的难度。
 
struts中的核心知识点：ActionServlet总控制器，Action分控制器，ActionForm表单，以及最重要的structs-config.xml和web.xml文件的配置。