Struts Interview Questions and Answers
Table Of Contents
- What is Struts, and how does it work in a web application?
- What is the role of an Action class in Struts?
- What is the difference between Struts 1.x and Struts 2.x?
- What is the purpose of the ActionServlet in the Struts framework?
- Can you explain the role of interceptors in Struts 2?
- How do you handle session management in Struts?
- Describe a scenario where you encountered an issue with Struts’ action mapping.
- Imagine you are working on a Struts 2 application where an action needs to be executed before the view is rendered. How would you approach this scenario using interceptors?
When preparing for a Struts interview, I know how critical it is to have a solid understanding of the framework and its core components. Struts interview questions typically dive deep into the architecture of Struts, including the Model-View-Controller (MVC) design pattern, action classes, and form beans. I’ve faced questions about configuring Struts tags, handling exceptions, and integrating Struts with other technologies like Spring or Hibernate. The interviewers usually test my knowledge of both Struts 1.x and Struts 2.x, making it essential to know the differences and how to leverage them in real-world projects. These questions are designed to assess how well I can use Struts to build scalable, efficient web applications.
Enroll in our project-focused Java training in Hyderabad for in-depth learning and real-world experience. Gain practical skills through hands-on sessions and expert-led interview preparation, setting you on the path to Java career success.
In this guide, I’ve put together the most common Struts interview questions and answers that helped me prepare for interviews. By going through these, I’ve gained the confidence to tackle technical questions with ease and precision. Whether you’re just starting with Struts or have years of experience, this content will help you understand the framework at a deeper level and answer interview questions effectively. I’ve made sure to focus on practical insights and real-world scenarios, so you can confidently approach your next Struts interview and stand out as a skilled and knowledgeable developer.
1. What is Struts, and how does it work in a web application?
Struts is an open-source web application framework used for developing Java-based web applications. It follows the Model-View-Controller (MVC) design pattern, which separates the application into three components: Model, View, and Controller. The primary purpose of Struts is to simplify the development of web applications by providing a structure for managing user requests and responses. It allows developers to create reusable code and promotes the use of best practices like separation of concerns and easy integration with other technologies like JSP and EJB.
In a Struts-based application, the ActionServlet acts as the front controller that intercepts all incoming HTTP requests. The request is then forwarded to a specific Action class, which processes the request, interacts with the Model (such as databases or business logic), and finally returns a View (usually a JSP page). For example, a login action might look like this:
public class LoginAction extends Action {
public ActionForward execute(ActionMapping mapping, ActionForm form,
HttpServletRequest request, HttpServletResponse response) {
LoginForm loginForm = (LoginForm) form;
// Validate credentials and forward based on success/failure
if (isValidUser(loginForm)) {
return mapping.findForward("success");
} else {
return mapping.findForward("failure");
}
}
}Code Description: In this example, we have a LoginAction class extending Action. The execute() method is called when the login request is triggered. It validates the user credentials by calling the isValidUser() method (which is assumed to be defined elsewhere). If the credentials are valid, the user is forwarded to the “success” view, otherwise to the “failure” view. This process is typical in Struts, where the request is processed and forwarded to an appropriate view based on business logic.
See also: Spring Boot interview questions for 5 years experience
2. Can you explain the Model-View-Controller (MVC) design pattern used in Struts?
The Model-View-Controller (MVC) design pattern is at the heart of Struts. It is a way to organize the components of a web application so that the business logic, user interface, and input control are separated into different layers. This separation of concerns makes the application easier to maintain and scale. In the context of Struts, the Model represents the data and business logic of the application, such as interacting with the database or performing business operations. The View is responsible for presenting the data to the user, often using JSP pages to display the results. Lastly, the Controller is responsible for handling user input and coordinating the flow between the Model and View.
In Struts, the ActionServlet functions as the Controller, which intercepts user requests and forwards them to the appropriate Action class. The Action class processes the request, retrieves or updates data through the Model, and determines which View (a JSP or other UI component) should be displayed. Here’s an example where a request is handled by the controller (ActionServlet) and forwarded to the appropriate JSP:
<action path="/login" type="com.example.LoginAction" name="loginForm" scope="request" input="/login.jsp">
<forward name="success" path="/home.jsp"/>
<forward name="failure" path="/login.jsp"/>
</action>Code Description: In this struts-config.xml snippet, the action is mapped with the path /login, which corresponds to the LoginAction class. The name attribute specifies the form bean (loginForm), and the input attribute indicates the input JSP page (login.jsp). The forwards are defined for “success” and “failure” outcomes, leading to either home.jsp or login.jsp based on the validation results in the action class. This mapping demonstrates how Struts uses the ActionServlet to manage the flow between requests, actions, and views.
See also: Enum Java Interview Questions
3. What is the role of an Action class in Struts?
In Struts, an Action class serves as the controller component in the Model-View-Controller (MVC) architecture. It is responsible for processing user requests, interacting with the Model (business logic and data), and determining the next View (typically a JSP page) to display. When a user makes a request, the ActionServlet forwards the request to a specific Action class. This class executes the business logic associated with the request, like querying a database or updating records, and then returns an ActionForward that indicates which page should be shown to the user.
Each Action class usually contains an execute() method, which is called when the request is processed. The execute() method receives the ActionMapping and ActionForm objects, which provide information about the request and the form data submitted by the user. Here’s an example of an Action class for handling a login request:
public class LoginAction extends Action {
public ActionForward execute(ActionMapping mapping, ActionForm form,
HttpServletRequest request, HttpServletResponse response) {
LoginForm loginForm = (LoginForm) form;
// Check if the username and password are valid
if (loginForm.getUsername().equals("admin") && loginForm.getPassword().equals("admin123")) {
return mapping.findForward("success");
} else {
return mapping.findForward("failure");
}
}
}Code Description: In this LoginAction class, the execute() method is responsible for validating the user’s login credentials. It compares the entered username and password with hardcoded values (admin and admin123). If the credentials match, the user is forwarded to the “success” view; otherwise, the user is directed to the “failure” view. This demonstrates the basic functionality of an Action class, which processes business logic and handles navigation based on the result.
4. What is the difference between Struts 1.x and Struts 2.x?
Struts 1.x and Struts 2.x are both web application frameworks, but they differ significantly in terms of their architecture, features, and ease of use. The most noticeable difference is that Struts 1.x is based on the traditional ActionServlet and action classes while Struts 2.x introduced a more modern architecture based on the Interceptors and ActionSupport classes. This design change in Struts 2.x makes it more flexible and easier to integrate with other frameworks like Spring or Hibernate.
Some key differences include:
- ActionForm in Struts 1.x is used for form data, while Struts 2.x directly uses POJOs (Plain Old Java Objects) for actions.
- Struts 2.x uses OGNL (Object Graph Navigation Language) for data binding, making it more dynamic and easier to use.
- Struts 2.x has built-in support for validation and error handling through interceptors.
Here’s an example of Action class in Struts 2.x using a POJO:
public class LoginAction {
private String username;
private String password;
public String execute() {
if ("admin".equals(username) && "admin123".equals(password)) {
return "success";
}
return "failure";
}
}Code Description: In Struts 2.x, we no longer need ActionForm. The action class uses POJOs (Plain Old Java Objects) for simple property-based data binding. The execute() method processes the request by validating the username and password, and based on the result, it returns either a “success” or “failure” string. This is much simpler and more flexible compared to Struts 1.x, which required form beans and action mappings in the configuration file.
See also: Java 8 interview questions
5. How do you configure Struts using the struts-config.xml file?
In Struts 1.x, the struts-config.xml file is the primary configuration file where all the application settings and mappings are defined. It is a key component that allows me to set up various elements like action mappings, form beans, global forwards, and exception handling. This configuration file acts as the central hub for defining how requests are routed within the application. It is important to correctly map each Action class to its corresponding URL pattern so that the ActionServlet knows which class to invoke for a given user request.
A simple struts-config.xml file might look like this:
<struts-config>
<form-beans>
<form-bean name="loginForm" type="com.example.LoginForm"/>
</form-beans>
<action-mappings>
<action path="/login" type="com.example.LoginAction" name="loginForm" scope="request" input="/login.jsp">
<forward name="success" path="/home.jsp"/>
<forward name="failure" path="/login.jsp"/>
</action>
</action-mappings>
</struts-config>Code Description: In this struts-config.xml example, the action-mappings section maps the “/login” path to the LoginAction class. It also specifies the form bean (loginForm) and the input JSP page (login.jsp). The forwards are defined to show either the home.jsp or login.jsp based on the outcome of the action.
6. What is a Form Bean in Struts, and why is it important?
A Form Bean in Struts is a JavaBean that acts as a container for the form data submitted by the user. The Form Bean is used to store form input from the user, and it helps transfer that data between the Action class and the view (usually a JSP page). It is especially useful in Struts 1.x applications where the ActionForm class is needed to hold the form data and facilitate the form submission process. Form beans play a crucial role in validation and data binding. They allow me to validate input and process form submissions effectively.
In Struts 1.x, the form bean is typically defined in the struts-config.xml file and linked to an action. This bean contains the form properties (like username, password, etc.) as private variables with getter and setter methods. When the form is submitted, the Action class retrieves the values from the Form Bean and processes them accordingly. Here’s an example of a simple Form Bean:
public class LoginForm 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;
}
}Code Description: In this LoginForm class, the form fields username and password are represented as private variables, and getter/setter methods are provided to access and modify their values. This class is then mapped in struts-config.xml to capture the form data when a user submits the login form.
See also: Java Senior developer interview Questions
7. How do Struts tags simplify the development of web applications?
Struts tags are special tags used in JSP pages that simplify the integration of the Struts framework into the user interface. These tags make it easier for me to handle common tasks like form submission, data binding, displaying error messages, and navigating between pages without having to write too much Java code. The Struts Tag Library includes various tags such as <html:form>, <html:text>, <html:errors>, and <html:submit>, which allow for cleaner and more maintainable code.
For instance, the <html:form> tag is used to create an HTML form, and it binds the form to a Form Bean. Similarly, the <html:text> tag binds an input field to a form property. Here’s an example of how these tags work:
<html:form action="/login">
<html:text property="username" />
<html:text property="password" />
<html:submit value="Login"/>
</html:form>Code Description: In this JSP snippet, the <html:form> tag binds the form to the LoginAction (which processes the login request). The <html:text> tags bind the input fields for username and password to their corresponding properties in the LoginForm. The form submits to the “/login” action when the user clicks the “Login” button. These Struts tags simplify form handling by automatically binding form fields to ActionForms and processing the form submission.
See also: Top 50 Git Interview Questions and Answers
8. What is the purpose of the ActionServlet in the Struts framework?
The ActionServlet is the central controller in the Struts framework. It acts as the front controller that intercepts all incoming HTTP requests and determines which Action class will handle the request. It uses the struts-config.xml file to map URLs to their corresponding actions and forwards the requests to the appropriate Action class. Essentially, the ActionServlet manages the workflow of the application, from receiving a request to routing it to an appropriate Action class and then forwarding the response to the correct view (usually a JSP page).
When a request is received, the ActionServlet looks for the relevant Action class in the configuration file, creates an instance of the class, and then calls its execute() method to process the request. Here’s a snippet showing how the ActionServlet is configured:
<servlet>
<servlet-name>struts</servlet-name>
<servlet-class>org.apache.struts.action.ActionServlet</servlet-class>
<init-param>
<param-name>config</param-name>
<param-value>/WEB-INF/struts-config.xml</param-value>
</init-param>
</servlet>Code Description: In this web.xml configuration, the ActionServlet is mapped to the struts servlet name. It reads the struts-config.xml file (which contains the action mappings and form beans) to determine how to route incoming requests. This servlet is responsible for managing the lifecycle of the application, ensuring that requests are routed to the right Action class for processing.
See also: Java interview questions for 10 years
9. Can you explain the function of the ActionForward in Struts?
In Struts, the ActionForward is an object that represents the next destination after the Action class has processed a user request. It determines where to forward the request next, usually to a JSP page or another Action. After processing the request, the Action class returns an ActionForward to the ActionServlet, which then forwards the response to the destination page.
The ActionForward can either be defined in the struts-config.xml file or created dynamically in the Action class. It’s essential for controlling the navigation flow of the application. For example:
public ActionForward execute(ActionMapping mapping, ActionForm form,
HttpServletRequest request, HttpServletResponse response) {
if (isValidUser(user)) {
return mapping.findForward("success");
} else {
return mapping.findForward("failure");
}
}Code Description: In this example, based on the validation result of the user (using isValidUser(user)), the method returns an ActionForward named “success” or “failure”. These forwards are defined in the struts-config.xml file and correspond to different JSP pages or other resources.
10. How does exception handling work in Struts, and what are some best practices?
In Struts, exception handling is typically done using global exception mappings and exception classes defined in the struts-config.xml file. If an exception occurs in an Action class, Struts will automatically handle it and forward the user to an appropriate error page or action based on the configuration. This makes it easier to manage errors without cluttering the Action class with try-catch blocks.
Here’s how to define an exception mapping in struts-config.xml:
<exception-mappings>
<exception key="error" type="java.lang.Exception" path="/error.jsp"/>
</exception-mappings>Code Description: In this example, any exception that occurs in an Action class will be mapped to the error.jsp page, displaying an appropriate error message to the user. This centralizes error handling and ensures that all exceptions are handled consistently across the application. Best practices include using specific exception types, logging exceptions for debugging, and creating custom error pages for better user experience.
11. How would you implement custom validations in Struts?
In Struts, custom validations can be implemented by creating a ValidationForm or by using the Validator framework provided by Struts. Custom validation logic is written in the validate() method of the ActionForm class, which is invoked before the action is executed. This allows me to perform validations on form data before processing it in the Action class.
Here’s an example of how to implement custom validation logic in the ActionForm:
public class LoginForm extends ActionForm {
private String username;
private String password;
public ActionErrors validate(ActionMapping mapping, HttpServletRequest request) {
ActionErrors errors = new ActionErrors();
if (username == null || username.length() < 5) {
errors.add("username", new ActionMessage("error.username.short"));
}
return errors;
}
}Code Description: In this LoginForm class, the validate() method checks if the username length is less than 5. If it is, an error message is added to the ActionErrors object, which will be displayed in the view. This is a simple form of custom validation, ensuring the username is of the correct length before the form is submitted.
See also: Java interview questions for 5 years experience
12. Can you explain the role of interceptors in Struts 2?
In Struts 2, interceptors provide a mechanism to perform tasks before or after the execution of an Action. They are similar to filters in that they can intercept requests and responses. Interceptors can be used to perform a variety of tasks, such as logging, authentication, authorization, or modifying the request or response objects.
Interceptors are part of the Struts 2 ActionInvocation framework, and I can configure them to be applied globally or on specific actions. Here’s an example of defining interceptors in struts.xml:
<interceptors>
<interceptor name="loggingInterceptor" class="com.example.LoggingInterceptor"/>
</interceptors>Code Description: In this struts.xml configuration, the LoggingInterceptor is applied to intercept all actions. This interceptor could be used to log details about incoming requests or responses, helping with debugging or auditing.
13. What are Struts plugins, and how do you use them?
Struts plugins are pre-built components or modules that extend the functionality of the Struts framework. They allow me to add new features to the framework without having to write all the code from scratch. Plugins can be used to integrate third-party libraries or provide additional functionality like file uploads, custom validation, or internationalization.
To use a plugin, I typically add the necessary dependencies and configure it in the struts-config.xml or struts.xml file, depending on the version of Struts. An example of using a file upload plugin might look like this:
<action path="/uploadFile" type="com.example.UploadAction" name="fileForm" scope="request">
<forward name="success" path="/uploadSuccess.jsp"/>
</action>Code Description: This configuration shows how an UploadAction class is mapped to handle file uploads. The action class can then use a plugin like Struts File Upload to process the file sent by the user.
14. How can you integrate Struts with Spring and Hibernate?
Integrating Struts with Spring and Hibernate is a common approach for building enterprise applications. Spring provides a robust framework for dependency injection, transaction management, and other essential services, while Hibernate is an Object-Relational Mapping (ORM) tool that simplifies database interaction. By integrating these frameworks with Struts, I can leverage their strengths to create a more maintainable and scalable application.
To integrate Struts with Spring, I use Spring’s DispatcherServlet for handling requests, while Struts’ ActionServlet can still be used for handling actions. The integration is typically done by replacing the Struts Action class with a Spring bean. This allows the Struts actions to be managed by the Spring container, giving me access to Spring’s features, such as AOP and transaction management.
For Hibernate integration, I configure a SessionFactory bean in Spring’s applicationContext.xml and inject it into my Struts Action classes. The Hibernate DAO (Data Access Object) layer will handle the database operations, while the Spring transaction management ensures that the operations are atomic.
Here’s a basic configuration for integrating Spring and Hibernate with Struts:
<!-- Spring Bean Configuration -->
<bean id="sessionFactory" class="org.springframework.orm.hibernate5.LocalSessionFactoryBean">
<property name="dataSource" ref="dataSource" />
<property name="packagesToScan" value="com.example.model" />
</bean>
<!-- Action Class Bean Configuration -->
<bean id="loginAction" class="com.example.LoginAction">
<property name="loginService" ref="loginService" />
</bean>Code Description: In this configuration, the SessionFactory bean is responsible for creating Hibernate sessions, while the loginAction bean is configured in Spring and can be used within Struts to handle user login. The loginService (a Spring bean) would handle the business logic, utilizing Hibernate for database operations.
See also: Accenture Java interview Questions
15. How do you handle session management in Struts?
In Struts, session management is primarily handled through the HttpSession object, which is automatically created by the servlet container (e.g., Tomcat) when a user makes their first request. The HttpSession stores user-specific information, such as user authentication details or preferences, across multiple requests.
By default, Struts uses session scope for form beans and action mappings, meaning the form bean and action are accessible throughout the user’s session. In cases where I need to manage more complex session behaviors, I can directly interact with the HttpSession object in the Action class.
For instance, if I need to store user-specific data in the session, I can do so like this:
public ActionForward execute(ActionMapping mapping, ActionForm form,
HttpServletRequest request, HttpServletResponse response) {
HttpSession session = request.getSession();
session.setAttribute("user", user); // Store user object in session
return mapping.findForward("success");
}Code Description: In this example, the HttpSession is obtained from the HttpServletRequest object, and the user object is stored in the session with the key “user”. This allows the user’s details to persist across multiple requests, and I can retrieve the data on subsequent pages by accessing the session.
For session expiration, I can configure the web.xml file to set a timeout for the session:
<session-config>
<session-timeout>30</session-timeout> <!-- Session timeout in minutes -->
</session-config>Code Description: This web.xml snippet sets the session timeout to 30 minutes, meaning that the session will expire if the user is inactive for that duration. By adjusting the session timeout, I can manage user sessions more effectively, especially in applications where sensitive data is involved.
16. How would you manage file uploads in a Struts-based application?
In a Struts-based application, managing file uploads requires integrating a file upload mechanism. Typically, I use the Struts File Upload Plugin, which simplifies the process of receiving and processing uploaded files. This plugin allows me to handle multipart form data, which is necessary for file uploads.
I start by adding the necessary dependencies in the web.xml to configure the FileUploadInterceptor. This interceptor processes the file before the action is executed. Then, in the action class, I access the uploaded file through the form bean. Here’s an example of how I can manage file uploads:
public class FileUploadAction extends ActionSupport {
private File uploadedFile;
private String uploadedFileContentType;
private String uploadedFileFileName;
public String execute() {
// Handle the file upload logic
if (uploadedFile != null) {
// Save the file or process it
}
return SUCCESS;
}
// Getters and setters for uploadedFile, uploadedFileContentType, and uploadedFileFileName
}Code Description: In this example, the FileUploadAction handles the uploaded file. The File class is used to store the uploaded file, and I can retrieve the file’s content type and file name for further processing. I can save this file to the server or process it based on the requirements of the application.
To ensure that file uploads are processed, I configure the struts.xml file to specify the action:
<action name="uploadFile" class="com.example.FileUploadAction">
<result name="success">/uploadSuccess.jsp</result>
</action>17. How would you configure struts.xml for a multi-module application?
In a multi-module Struts application, I divide the application into separate modules for better maintainability and scalability. Each module represents a specific functional area and may have its own struts.xml configuration file. In this setup, I use Struts‘s module configuration feature to include the individual configuration files for each module.
To configure struts.xml for a multi-module application, I include the configuration files from each module into the main struts.xml file using the <include> tag. This allows the Struts framework to recognize actions and forward them appropriately across modules. Here’s an example:
<struts>
<package name="module1" extends="struts-default">
<action name="module1Action" class="com.example.module1.Module1Action">
<result>/module1.jsp</result>
</action>
</package>
<package name="module2" extends="struts-default">
<action name="module2Action" class="com.example.module2.Module2Action">
<result>/module2.jsp</result>
</action>
</package>
</struts>Code Description: This configuration defines two packages: module1 and module2, each having its own set of actions and results. When a request is made for module1Action, Struts will look for the Module1Action class in the module1 package. By structuring the application this way, I keep each module’s configuration isolated while still allowing for seamless integration between modules.
18. Describe a scenario where you encountered an issue with Struts’ action mapping and how you resolved it.
I once worked on a project where an Action was not being mapped correctly, and the error was a 404 Not Found. The issue occurred because the action mapping in struts.xml was incorrectly specified, leading the framework to not recognize the action path.
To resolve the issue, I carefully reviewed the action name in the struts.xml file and ensured it matched the path specified in the HTML form or the URL. Here’s how I fixed it:
<action name="login" class="com.example.LoginAction">
<result>/loginSuccess.jsp</result>
</action>Code Description: In this configuration, the action name was “login”. I had to ensure that the form or the request was targeting the correct action path. I also double-checked for any typos or incorrect paths in the configuration and resolved the issue by matching the action’s path with the URL being requested.
19. How would you handle performance optimization for a Struts application with heavy traffic?
For performance optimization in a Struts application with heavy traffic, I focus on several key areas to ensure the application can handle large numbers of concurrent users effectively:
- Caching: Implementing caching for frequently accessed data reduces the need for expensive database queries. I can use cache tags in JSPs or integrate a caching solution like EHCache.
- Load Balancing: Distributing incoming traffic across multiple servers helps manage high traffic more efficiently. Using reverse proxies like Nginx or Apache HTTP Server enables load balancing.
- Database Optimization: I ensure efficient database queries by using indexing and proper query optimization techniques. Using Hibernate‘s lazy loading also helps reduce unnecessary database calls.
Here’s an example of using EHCache for caching in a Struts application:
<bean id="cacheManager" class="net.sf.ehcache.CacheManager" />
<bean id="ehcache" class="net.sf.ehcache.Cache">
<property name="name" value="userCache"/>
<property name="maxEntriesLocalHeap" value="1000"/>
</bean>Code Description: In this configuration, EHCache is set up to cache user data. By using caching, repeated requests for the same data do not require accessing the database, improving response time and reducing server load.
20. Imagine you are working on a Struts 2 application where an action needs to be executed before the view is rendered. How would you approach this scenario using interceptors?
In a Struts 2 application, interceptors allow me to execute logic before or after an action is executed. If I need an action to be executed before the view is rendered, I can use Struts 2 interceptors to manage this behavior. I typically use an Interceptor to pre-process the request before it is handed over to the Action class.
To execute an action before rendering the view, I can configure a preResult interceptor in struts.xml. Here’s an example configuration:
<interceptors>
<interceptor name="preResultInterceptor" class="com.example.PreResultInterceptor"/>
<interceptor-stack name="defaultStack">
<interceptor-ref name="preResultInterceptor"/>
<interceptor-ref name="struts.defaultStack"/>
</interceptor-stack>
</interceptors>Code Description: In this configuration, the preResultInterceptor is added to the defaultStack, meaning it will run before the result (view) is rendered. The PreResultInterceptor can execute any pre-processing logic (like setting data or checking conditions) before the action is displayed in the view.
Conclusion
Becoming proficient in Struts is crucial for developers looking to excel in Java-based web applications. By mastering the core components like the Model-View-Controller (MVC) pattern, Action classes, and struts.xml configuration, you’ll be well-prepared to tackle any challenges that come your way. The detailed answers in this guide not only cover fundamental concepts but also address advanced Struts topics and scenario-based questions that are often asked in interviews. Whether you’re just starting or aiming to refine your skills, this resource is designed to help you build a strong foundation and excel in your Struts interview.
Preparing with these Struts interview questions and answers will give you the confidence to answer complex queries and demonstrate your expertise. The clear explanations, practical examples, and relevant code snippets will ensure that you’re ready to tackle any Struts-related challenge in a professional setting. Armed with this knowledge, you’ll be able to confidently discuss the intricacies of file uploads, interceptors, performance optimization, and integration with other frameworks—ultimately setting yourself apart as a capable and skilled Struts developer in your next interview.
