Struts Interview Questions

Tiles are a type of presentation component that can be reused. Create a basic layout with several sections before using Tiles. Then, in an external configuration file, define a JSP page that should occupy the correct sections.

ActionServlet is a controller in the Struts framework, and it manages all user requests. Because only one object needs to be produced for this controller class, ActionServlet is built on a singleton design pattern. For each user request, many threads are formed subsequently.

ActionServlet is equal to "controller" in the MVC architecture for web apps. Requests to the server are routed to the controller, which is in charge of request management. The typical struts flow starts with the ActionServlet and a call to the RequestProcessor's process() method.

DynaActionForm is a subclass of the ActionForm class that is used to dynamically create form beans. In order to generate a bean form, configuration files are used.

• There is no documentation.
• Transparency isn't complete.
• There is only one servlet controller.
• There is a great deal to learn.
• The strategy is unyielding.

The Struts Framework is an open-source Web application framework for quickly and easily developing Java Enterprise Edition Web applications. It promotes the model-view-controller (MVC) architecture by utilising and extending the Java Servlet API.

The goal of the Struts Framework was to separate the "model," which is the application logic that communicates with the database, from the "view," which is the HTML pages presented to the client/user, and from the "controller," which is the instance that passes data between the model and the client's view.

The most common issue with web applications is a double form submission, which results in the user being charged twice and the database retaining double values. To solve the problem of double form submission, we can use a token interceptor. The struts-default package defines this interceptor.

The struts-default package defines all of the Struts2 interceptors, as well as the most often used interceptor stack. To prevent having to configure interceptors twice, it's best to extend this package while configuring our application package. This is given to aid developers in the configuration of interceptors and result pages in our application.

An ActionForm is a JavaBean that is linked to ActionMappings and manages the apps' session state. When any set of data is entered on the client-side, the ActionForm object populates automatically on the server-side.

• The user first sends the received request to the server.
• The request is then handled by FilterDispatcher, which chooses the best action for it.
• Pre-processing actions such as file upload, error handling, and so on are performed by the designated interceptors.
• The selected action is now carried out, and the operation is completed.
• Interceptors are used to execute post-processing actions such as file upload, exception handling, and so on.
• The user is presented with the final result in the form of a view page.

When a user submits a form with an improper data format, a validation error occurs. To validate this data, Struts provides the Validator() method, which allows the developer or programmer to validate data from both the client and server sides. This syntax can be used to display errors on the JSP page: <html:error/>

The Struts framework uses a centralised control model, with a single servlet controller controlling the entire application. As a result, a servlet application only needs one servlet controller.

ForwardAction is applied when combining an existing application with struts. ForwardAction is also used for transferring total control from one location to another, such as from a JSP to a local server. When the benefits of struts functionality are desired after the integration with Struts, ForwardAction is employed.

To use the framework, we only need to include the struts.jar file in our development environment. After the jar file is in the CLASSPATH, we may use the framework and build Strut-based apps.

For long-running action classes, Struts2 introduces the execAndWait interceptor. We can use this interceptor to provide the client with an interim response page, and once the processing is complete, the client will receive the final response. The ExecuteAndWaitInterceptor class implements this interceptor, which is described in the struts-default package.

During the preprocessing and postprocessing of a request, an object is invoked known as an interceptor. Validation, exception handling, internationalization, showing interim results, and other actions are performed by the interceptor in Struts 2.

An interceptor's lifecycle methods are as follows:

• init public void ():  It is only called once and is used to set up the interceptor.
• public string intercept (ActionInvocation ai):  It is used to specify the request processing logic and is called for each request. The result page will be invoked if it returns a string; otherwise, the next interceptor or action will be invoked if it returns the invoke() function of the ActionInvocation interface.
• public void destroy():  It can only be used once to destroy the interceptor.

MVC stands for Model View Controller. Here is a brief description of the same.

• To store, retrieve, and manipulate data, the model contains the business logic and interacts with the persistence storage.
• The view is in charge of returning the results to the user. JSP is used to implement the view layer in Struts.
• The controller handles all of the user's requests and returns the relevant view. The ActionServlet performs the controller's function in Struts.

Following are the important classes for any struts application.

• Action Servlet: It is the controller class which is in charge of all requests that come in.
• Action Class: All business logic, often known as a Model, is constructed using the Action class.
• Action Form: It is a Java bean that connects one or more Action Mappings. It keeps a web application's session state safe.
• Action Mapping: We can do the mapping between Object and Action using it.
• Action Forward: It's utilised to send the Controller's result to the target.

The following are the components of the struts framework:

• JSP Programs (View Layer Resources): The presentation logic of a JSP program is used to create a user interface for end-users and to prepare the model layer's results.
• FormBean Class (Controller Layer Resources): A form bean is a Java bean type. It is a subclass of the ActionForm class that contains HTML form data from a submitted client request or can store input data from a user-clicked Struts action link.
• Action Servlet(Built-in Controller Servlet): Every Struts application comes with a built-in Controller Servlet. This servlet program's integration logic will be dynamically constructed depending on the rules and guidelines specified in the Struts configuration file. This integration logic determines and regulates the execution flow in struts applications.
• Action Class: It's a Java extension of org.apache.struts.action. This is an action class. It has the functionality to interface with other model layer resources; therefore it can act as a model layer resource.
• web.xml (Deployment Descriptor file of the web application): Because the web.xml web application descriptor file is at the heart of any Java online application, it's only natural that it's also at the heart of the Struts framework. Struts specify its FilterDispatcher, a Servlet Filter class that initializes the Struts framework and handles all requests, in the web.xml file.
• Struts Configuration File (XML File): The struts-config.xml configuration file serves as a connector between the Web application's View and Model components.

validate() is used for conducting validations on incoming data that can be overridden by different subclasses. After a Form Bean has been filled with incoming data, this function is invoked. The ActionErrors return type is included in this method.

public ActionErrors validate(ActionMapping mapping,HttpServletRequest request) {}

Subclasses have the ability to override reset(). It's a hook that gets called before FormBean is filled with HTML request data. All form fields are reset using this way.

public void reset() {}

Conclusion

In this blog, we have listed a good number of common struts interview questions. It also covered the enhanced part of struts i.e struts 2 that would help you gain interest in how this framework is useful in creating good applications and widely used by IT professionals for their applications. Hope this pool of questions will help you in cracking your interview,

Useful Learning Resources

• https://www.interviewbit.com/technical-interview-questions/
• https://www.interviewbit.com/coding-interview-questions/

Happy Learning!

• Action level validators can utilise the plain-validators syntax. In this instance, a single validator can be used to validate many fields. However, the drawback of this technique is that we can't use many validators on a single field.
• The field-level validator can use the field-validator syntax. Multiple validators can be applied to a single field in this case. However, unlike plain-validator, this technique has the drawback of not being able to apply a single validator to several fields.

An interceptor stack allows us to aggregate many interceptors into a package for later usage. BasicStack and defaultStack are two of the most commonly used interceptor stacks created by the struts-default package. At the beginning of the package, we can establish our own interceptor stack and then configure our action classes to use it.

The controller gets all mapping information from a configuration file called "struts-config.xml" before deciding which action to employ for routing the user's request. It acts as a network router, processing and mapping requests to the appropriate action or resource.

The following steps occur after a request is sent:

• The request is received by the ActionServlet.
• Details on Actions, ActionForms, ActionMappings, and ActionForwards can be found in the struts-config.xml file.
• The ActionServelet reads the struts-config.xml file and builds a database of configuration objects when it starts up. Later, when processing the request, the ActionServlet refers to this object to make a decision.

The resource bundle properties document is used to define customised error messages in key-value pairs for any code faults that might arise. This method helps to keep the code clean by removing the need for the developer to avoid all error messages within the function.

The following are the main differences between HTML tags and Strut-specific HTML tags:

• HTML tags are static by nature, while Struts-specific HTML tags are dynamic.
• Although HTML is coordinated in Struts, Struts has its own tag libraries.
• The tags for HTML, on the other hand, cannot be user-defined, whereas the tags for struts can.

ValueStack is a stack where all values and data linked to actions are saved, whereas OGNL is a library through which the ValueStack data or values are changed.

Struts2 has a highly comprehensive framework for handling exceptions. Packages can define global outcomes, and then specific exceptions can be mapped to these result pages. Exception mapping can be performed at both the global package and action levels.

When we have a modular application with various modules working independently, the optimum situation for using the SwitchAction class is. We can transition from a resource in one module to another resource in a separate module of the application using the SwitchAction class.