Struts2 面试问题与答案

Struts2是Java开发Web应用程序的著名框架之一。最近，我撰写了许多关于Struts2的教程，并在本文中列出了一些重要的Struts2面试问题及答案，以帮助你面试。

Struts2面试问题

1. Struts2是什么？

 

1. Struts2与Struts1有什么区别，或者说Struts2比Struts1好在哪里？

 

1. Struts2有哪些核心组件？

 

1. 在Struts2中，拦截器是什么？

 

1. Struts2拦截器实现了哪种设计模式？

 

1. 在Struts2中，创建Action类的不同方式有哪些？

 

1. Struts2的Action和拦截器是否线程安全？

 

1. 在Struts2中，哪个类是前端控制器？

 

1. 拦截器在Struts2中有什么好处？

 

1. ValueStack和OGNL是什么？

 

1. Struts2中引入了哪些有用的注解？

 

1. 提供一些您使用过的重要的Struts2常量。

 

1. 在Struts2中，动作映射中的命名空间有什么用途？

 

1. 哪个拦截器负责将请求参数映射到动作类的Java Bean属性？

 

1. 哪个拦截器负责i18n支持？

 

1. 在使用动作接口和ActionSupport类来开发动作类时有何区别，您更喜欢哪个？

 

1. 在动作类中，我们如何获取Servlet API的Request、Response、HttpSession等对象？

 

1. execAndWait拦截器的用途是什么？

 

1. 令牌拦截器在Struts2中的用途是什么？

 

1. 我们如何在Struts2应用程序中集成log4j日志记录？

 

1. Struts2有哪些不同的标签？我们如何使用它们？

 

1. 自定义类型转换器在Struts2中是什么？

 

1. 我们如何编写自己的拦截器并将其映射到动作中？

 

1. 拦截器的生命周期是什么？

 

1. 什么是拦截器堆栈？

 

1. struts-default包是什么，它的好处是什么？

 

1. Struts2动作URI的默认后缀是什么，我们如何更改它？

 

1. 结果页面的默认位置是什么，我们如何更改它？

 

1. 我们如何在Struts2应用程序中上传文件？

 

1. 在开发Struts2应用程序时应遵循哪些最佳实践？

 

我们如何处理应用程序抛出的异常在Struts2中？

Struts2 面试问题与回答

1. 什么是Struts2？

 

1. Apache Struts2是一个用于构建Java Web应用程序的开源框架。Struts2基于OpenSymphony WebWork框架进行改进。它相对于Struts1有很大的改进，使其更加灵活、易于使用和扩展。Struts2的核心组件包括Action、拦截器和结果页面。Struts2提供了许多创建Action类并通过struts.xml或注解进行配置的方法。我们可以为常见任务创建自己的拦截器。Struts2提供了许多标签，并使用OGNL表达式语言。我们可以创建自己的类型转换器来呈现结果页面。结果页面可以是JSP和FreeMarker模板。

Struts1和Struts2之间有什么区别，或者说Struts2比Struts1更好在哪里？
Struts2旨在克服Struts1的不足，并使其更加灵活和可扩展。一些明显的区别包括：

组件
Struts1
Struts2

Action类
Struts1的Action类必须继承一个抽象类，这使得它不可扩展。
Struts2的Action类更灵活，我们可以通过实现Action接口、扩展ActionSupport类或只是包含execute()方法来创建它们。

线程安全
Struts1的Action类是单例的，不是线程安全的，这就需要开发人员特别注意避免多线程造成的副作用。
Struts2的Action类在每个请求中实例化，因此不存在多线程问题，使其线程安全。

Servlet API耦合
Struts1的API与Servlet API紧密耦合，请求和响应对象被传递到Action类的execute()方法中。
Struts2的API与Servlet API解耦，并自动将表单bean数据映射到Action类的Java bean属性中，这是我们经常使用的。然而，如果确实需要引用Servlet API类，可以使用相应的*Aware接口。

测试
由于与Servlet API的耦合，Struts1的Action类很难进行测试。
Struts2的Action类就像普通的Java类一样，我们可以通过实例化它们并设置它们的属性来轻松地进行测试。

请求参数映射
Struts1需要我们创建ActionForm类来保存请求参数，并需要在struts配置文件中进行配置。
Struts2的请求参数映射是即时完成的，我们只需要在Action类中拥有Java bean属性，或者实现ModelDriven接口以提供用于映射的Java bean类名即可。

标签支持
Struts1使用JSTL标签，因此功能有限。
Struts2使用OGNL，并提供不同类型的UI、控制和数据标签。它更加多样化和易于使用。

验证
Struts1通过手动的validate()方法支持验证。
Struts2支持手动验证和验证框架集成。

视图渲染
Struts1使用标准的JSP技术将bean值提供给JSP页面进行视图展示。
Struts2使用ValueStack来存储请求参数和属性，我们可以使用OGNL和Struts2标签来访问它们。

模块支持
Struts1的模块设计复杂，看起来像是独立的项目。
Struts2提供了“命名空间”配置来轻松创建模块。

1. Struts2拦截器实现了哪种设计模式？

 

Struts2拦截器实现了责任链模式。拦截器链由ActionInvocation负责封装Action类和拦截器，并按顺序触发它们。在ActionInvocation中，最重要的方法是invoke()方法，它跟踪拦截器链并调用下一个拦截器或动作。这是Java EE框架中责任链模式的最佳示例之一。

Struts2 interceptors are based on intercepting filters design pattern. The invocation of interceptors in interceptor stack closely resembles Chain of Responsibility design pattern.

在Struts2中，创建Action类的不同方式有哪些？

Struts2 provide different ways to create action classes.
1.  By implementing Action interface
2.  Using Struts2 @Action annotation
3.  By extending ActionSupport class
4.  Any normal java class with execute() method returning String can be configured as Action class.

Struts2的action和拦截器是否是线程安全的？

Struts2 Action classes are thread safe because an object is instantiated for every request to handle it. Struts2 interceptors are singleton classes and a new thread is created to handle the request, so it's not thread safe and we need to implement them carefully to avoid any issues with shared data.

Struts2中的前端控制器是在哪个类中？

`org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter` is the Front Controller class in Struts2 and every request processing starts from this class. Earlier versions of Struts2 uses `org.apache.struts2.dispatcher.FilterDispatcher` as Front Controller class.

Struts2中的拦截器有哪些优势？

Some of the benefits of interceptors are:
-   Interceptor plays a crucial role in achieving high level of separation of concerns.
-   Struts2 interceptors are configurable, we can configure it for any action we want.
-   We can create our own custom interceptors to perform some common tasks such as request params logging, authentication etc. This helps us in taking care of common tasks at a single location, achieving low maintenance cost.
-   We can create interceptors stack to use with different actions.

ValueStack 是什么？OGNL 是什么？

ValueStack is the storage area where the application data is stored by Struts2 for processing the client requests. The data is stored in `ActionContext` objects that use ThreadLocal to have values specific to the particular request thread. Object-Graph Navigation Language (OGNL) is a powerful Expression Language that is used to manipulate data stored on the ValueStack. As you can see in architecture diagram, both interceptors and result pages can access data stored on ValueStack using OGNL.

在Struts2中引入了哪些有用的注解？

Some of the important annotations introduced in Struts2 are:
1.  @Action to create action class
2.  @Actions to configure single class for multiple actions
3.  @Namespace and @Namespaces for creating different modules
4.  @Result for result pages
5.  @ResultPath for configuring result pages location

提供一些你使用过的重要的Struts2常量。

Some of the Struts2 constants that I have used are:

1.  **struts.devMode** to run our application in development mode. This mode does reload properties files and provides extra logging and debugging feature. It's very useful while developing our application but we should turn it off while moving our code to production.
2.  **struts.convention.result.path** to configure the location of result pages. By default Struts2 look for result pages at {WEBAPP-ROOT}/{Namespace}/ and we can change the location with this constant.
3.  **struts.custom.i18n.resources** to define global resource bundle for i18n support.
4.  **struts.action.extension** to configure the URL suffix to for Struts2 application. Default suffix is .action but sometimes we might want to change it to .do or something else.

We can configure above constants in the struts.xml file like below.

```
<constant name="struts.devMode" value="true"></constant>
<constant name="struts.action.extension" value="action,do"></constant>
<constant name="struts.custom.i18n.resources" value="global"></constant>
<constant name="struts.convention.result.path" value="/"></constant>
```

在Struts2中，命名空间在操作映射中的用途是什么？

Struts2 namespace configuration allows us to create modules easily. We can use namespace to separate our action classes based on their functionality, for example admin, user, customer etc.

哪个拦截器负责将请求参数映射到动作类 Java Bean 的属性？

`com.opensymphony.xwork2.interceptor.ParametersInterceptor` interceptor is responsible for mapping request parameters to the Action class java bean properties. This interceptor is configured in struts-default package with name "params". This interceptor is part of basicStack and defaultStack interceptors stack.

哪个拦截器负责i18n支持？

`com.opensymphony.xwork2.interceptor.I18nInterceptor` interceptor is responsible for i18n support in Struts2 applications. This interceptor is configured in struts-default package with name "i18n" and it's part of i18nStack and defaultStack.

使用Action接口和ActionSupport类在我们的action类中有何区别，你更喜欢哪一个？

We can implement Action interface to create our action classes. This interface has a single method execute() that we need to implement. The only benefit of using this interface is that it contains some constants that we can use for result pages, these constants are SUCCESS, ERROR, NONE, INPUT and LOGIN. ActionSupport class is the default implementation of Action interface and it also implements interfaces related to Validation and i18n support. ActionSupport class implements Action, Validateable, ValidationAware, TextProvider and LocaleProvider interfaces. We can override the validate() method of ActionSupport class to include field level validation login in our action classes. Depending on the requirements, we can use any of the approaches to creating Struts 2 action classes, my favorite is ActionSupport class because it helps in writing validation and i18n logic easily in action classes.

在Action类中，我们如何获取Servlet API的Request、Response、HttpSession等对象？

Struts2 action classes don't provide direct access to Servlet API components such as Request, Response, and Session. However, sometimes we need these access in action classes such as checking HTTP method or setting cookies in response. That's why Struts2 API provides a bunch of \*Aware interfaces that we can implement to access these objects. Struts2 API uses dependency injection to inject Servlet API components in action classes. Some of the important Aware interfaces are SessionAware, ApplicationAware, ServletRequestAware, and ServletResponseAware. You can read more about them in How to get [Servlet API Session in Struts2 Action Classes](/community/tutorials/get-servlet-session-request-response-context-attributes-struts-2-action) tutorial.

“execAndWait 拦截器有什么用？”

Struts2 provides execAndWait interceptor for long running action classes. We can use this interceptor to return an intermediate response page to the client and once the processing is finished, final response is returned to the client. This interceptor is defined in the struts-default package and implementation is present in `ExecuteAndWaitInterceptor` class. Check out [Struts2 execAndWait interceptor example](/community/tutorials/struts2-execandwait-interceptor-example-for-long-running-actions) to learn more about this interceptor and how to use it.

在Struts2中，令牌拦截器有什么用途？

One of the major problems with web applications is the double form submission. If not taken care, double form submission could result in charging double amount to customer or updating database values twice. We can use a token interceptor to solve the double form submission problem. This interceptor is defined in the struts-default package but it's not part of any interceptor stack, so we need to include it manually in our action classes. Read more at [Struts2 token interceptor](/community/tutorials/struts2-token-interceptor-example) example.

我们如何在Struts2应用程序中集成log4j？

Struts2 provides easy integration of log4j API for logging purpose, all we need to have is log4j configuration file in the WEB-INF/classes directory. You can check out the sample project at [Struts2 Log4j integration](/community/tutorials/struts2-and-log4j-integration-example-project).

有哪些不同的Struts2标签？我们如何使用它们？

Struts2 provides a lot of custom tags that we can use in result pages to create views for client request. These tags are broadly divided into three categories- Data tags, Control tags and UI tags. We can use these tags by adding these in JSP pages using taglib directive.

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

Some of the important Data tags are property, set, push, bean, action, include, i18n and text tag. Read more at [Struts2 Data Tags](/community/tutorials/struts-2-data-tags-example-tutorial). Control tags are used for manipulation and navigation of data from a collection. Some of the important Control tags are if-elseif-else, iterator, append, merge, sort, subset and generator tag. Read more at [Struts2 Control Tags](/community/tutorials/struts-2-control-tags-example-tutorial). Struts2 UI tags are used to generate HTML markup language, binding HTML form data to action classes properties, type conversion, validation, and i18n support. Some of the important UI tags are form, textfield, password, textarea, checkbox, select, radio and submit tag. Read more about them at [Struts2 UI Tags](/community/tutorials/struts-2-ui-tags-form-checkbox-radio-select-submit).

Struts2中的自定义类型转换器是什么？

Struts2 support OGNL expression language and it performs two important tasks in Struts 2 – data transfer and type conversion. OGNL is flexible and we can easily extend it to create our own custom converter class. Creating and configuring custom type converter class is very easy. The first step is to fix the input format for the custom class. The second step is to implement the converter class. Type converter classes should implement `com.opensymphony.xwork2.conversion.TypeConverter` interface. Since in web application, we always get the request in form of String and send the response in the form of String, Struts 2 API provides a default implementation of TypeConverter interface, StrutsTypeConverter. StrutsTypeConverter contains two abstract methods – convertFromString to convert String to Object and convertToString to convert Object to String. For implementation details, read [Struts2 OGNL Example Tutorial](/community/tutorials/struts2-ognl).

我们如何编写自己的拦截器并将其映射到操作中？

We can implement `com.opensymphony.xwork2.interceptor.Interceptor` interface to create our own interceptor. Once the interceptor class is ready, we need to define that in struts.xml package where we want to use it. We can also create interceptor stack with our custom interceptor and defaultStack interceptors. After that we can configure it for action classes where we want to use our interceptor. One of the best example of using custom interceptor is to validate session, read more about it at [Struts2 Interceptor Tutorial](/community/tutorials/struts-2-interceptor-example).

拦截器的生命周期是怎样的？

Interceptor interface defines three methods - init(), destroy() and intercept(). init and destroy are the life cycle methods of an interceptor. Interceptors are Singleton classes and Struts2 initialize a new thread to handle each request. init() method is called when interceptor instance is created and we can initialize any resources in this method. destroy() method is called when application is shutting down and we can release any resources in this method. intercept() is the method called every time client request comes through the interceptor.

拦截器栈是什么？

An interceptor stack helps us to group together multiple interceptors in a package for further use. struts-default package creates some of the mostly used interceptor stack - basicStack and defaultStack. We can create our own interceptor stack at the start of the package and then configure our action classes to use it.

Struts-default套件是什么，有哪些好处？

struts-default is an abstract package that defines all the Struts2 interceptors and commonly used interceptor stack. It is advisable to extend this package while configuring our application package to avoid configuring interceptors again. This is provided to help developers by eliminating the trivial task of configuring interceptor and result pages in our application.

Struts2的动作URI的默认后缀是什么，我们如何进行更改？

The default URI suffix for Struts2 action is .action, in Struts1 default suffix was .do. We can change this suffix by defining struts.action.extension constant value in our Struts2 configuration file as:

```
<constant name="struts.action.extension" value="action,do"></constant>
```

结果页面的默认位置是什么，我们如何更改它？

By default Struts2 looks for result pages in {WEBAPP-ROOT}/{Namespace}/ directory but sometimes we want to keep result pages in another location, we can provide struts.convention.result.path constant value in Struts2 configuration file to change the result pages location. Another way is to use @ResultPath annotation in action classes to provide the result pages location.

怎样在Struts2应用程序中上传文件？

File Upload is one of the common tasks in a web application. That's why Struts2 provides built-in support for file upload through FileUploadInterceptor. This interceptor is configured in the struts-default package and provide options to set the maximum size of a file and file types that can be uploaded to the server. Read more about FileUpload interceptor at [Struts2 File Upload Example](/community/tutorials/struts-2-file-upload-example).

在开发Struts2应用程序时应该遵循哪些最佳实践？

Some of the best practices while developing Struts2 application are:
1.  Always try to extend struts-default package while creating your package to avoid code redundancy in configuring interceptors.
2.  For common tasks across the application, such as logging request params, try to use interceptors.
3.  Always keep action classes java bean properties in a separate bean for code reuse and implement ModelDriven interface.
4.  If you have custom interceptor that you will use in multiple actions, create interceptor stack for that and then use it.
5.  Try to divide your application in different modules with namespace configuration based on functional areas.
6.  Try to use Struts2 tags in result pages for code clarify, if needed create your own type converters.
7.  Use development mode for faster development, however make sure production code doesn't run in dev mode.
8.  Use Struts2 i18n support for resource bundles and to support localization.
9.  Struts2 provides a lot of places where you can have resource bundles but try to keep one global resource bundle and one for action class to avoid confusion.
10.  struts-default package configures all the interceptors and creates different interceptor stacks. Try to use only what is needed, for example if you don't have localization requirement, you can avoid i18n interceptor.

在Struts2中，我们如何处理应用程序抛出的异常？

Struts2 provides a very robust framework for exception handling. We can specify global results in packages and then map specific exceptions to these result pages. The exception mapping can be done at the global package level as well as the action level. It's a good idea to have exception result pages to provide some information to the user when some unexpected exception occurs that is not processed by the application. The sample configuration in the struts.xml file looks like below.

```
<package name="user" namespace="/" extends="struts-default">
 
<global-results>
    <result name="exception">/exception.jsp</result>
    <result name="runtime_exception">/runtime_exception.jsp</result>
    <result name="error">/error.jsp</result>
</global-results>
 
<global-exception-mappings>
    <exception-mapping exception="java.lang.Exception" result="exception"></exception-mapping>
    <exception-mapping exception="java.lang.Error" result="error"></exception-mapping>
    <exception-mapping exception="java.lang.RuntimeException" result="runtime_exception"></exception-mapping>
</global-exception-mappings>
 
    <action name="myaction" class="com.Olivia.struts2.exception.MyAction">
    </action>
    <action name="myspecialaction" class="com.Olivia.struts2.exception.MySpecialAction">
    <exception-mapping exception="java.io.IOException" result="login"></exception-mapping>
    <result name="login">/error.jsp</result>
    </action>
</package>
```

Read more at [Struts2 Exception Handling Example](/community/tutorials/struts2-exception-handling-example-tutorial).

如果你在Struts2面试问题和答案中发现了我漏掉的重要问题，请通过评论告诉我。