Q.What is Struts?
Struts is a framework that promotes the use of the Model-View-Controller architecture for designing large scale applications. The framework includes a set of custom tag libaries and their associated Java classes, along with various utility classes. The most powerful aspect of the Struts framework is its support for creating and processing web-based forms.
Q1. What are core classes in struts?
The core classes of Struts framework are:
ActionServlet, ActionForm, Action, Action Mapping, ActionForward
ActionServlet:
ActionServlet is the back bone of the whole web application.
ActionForm:
ActionForm is a Java bean that associates one or more ActionMappings. The bean is initialized from the corresponding parameters of requests well before the Action.execute method is invoked.
The bean’s validate() method will be called, before the execution of execute() method. This process is done before the bean properties have been populated. The verification of properties submitted by the user input form is validated by the validate() method. If the method finds problems, an error messages object those are encapsulated the problems will be returned and the controller servlet will return the control back to the input form. If not , the validate() method returns null, which is the indication of accepting everything, and the Action.execute method should be invoked.
Action:
This class is extended by the org.apache.struts.action.Action class. The business logic is wrapped by the Action class and this class provides an interface to the Model of the application. Action class can be viewed as a glue between the View and the Model layer of MVC architecture. The data transfer from the view layers to the specific business process layer(View to Mode) is done by this class. The processed data from the business layer to view layer is returned ultimately.
The struts controller i.e., ActionServlet , chooses an appropriate Action and the instance is created if necessary and invokes execute() method.
ActionMapping:
The ActionMapping is used to provide mappings for Objects to Actions. An action map is used in association with InputMap to locate an action at time of pressing a key. An action mapping can contain a reference to a form bean that the action can use. A reference to a form bean is contained by an action mapping. The reference to a form is used by an action.
ActionForward:
It is represented as a destination for the controller, RequestProcessor, that might be directed a RequestDispatcher.forward or HttpServletResponse.sendRedirect to. This is the result of processing activities of an Action class. The instances of this classes is created dynamically as the need arises.
Q2. Difference b/w Struts1 & Struts2?
Struts1 Struts2
Action classes
Struts 1 requires Action classes to extend an abstract base class. A common problem in Struts 1 is programming to abstract classes instead of interfaces.
An Struts 2 Action mayimplement an Action interface, along with other interfaces to enable optional and custom services. Struts 2 provide a base ActionSupport class to implement commonly used interfaces. Albeit, the Action interface is not required. Any POJO object with a execute signature can be used as an Struts 2 Action object.
Threading Model
Struts 1 Actions are singletons and must be thread-safe since there will only be one instance of a class to handle all requests for that Action. The singleton strategy places restrictions on what can be done with Struts 1 Actions and requires extra care to develop. Action resources must be thread-safe or synchronized.
Struts 2 Action objects are instantiated for each request, so there are no thread-safety issues. (In practice, servlet containers generate many throw-away objects per request, and one more object does not impose a performance penalty or impact garbage collection.)
ServletDependency
Struts 1 Actions have dependencies on the servlet API since the HttpServletRequest and HttpServletResponse is passed to the execute method when an Action is invoked.
Struts 2 Actions are not coupled to a container. Most often the servlet contexts are represented as simple Maps, allowing Actions to be tested in isolation. Struts 2 Actions can still access the original request and response, if required. However, other architectural elements reduce or eliminate the need to access the HttpServetRequest or HttpServletResponse directly.
Testability
A major hurdle to testing Struts 1 Actions is that the execute method exposes the Servlet API. A third-party extension, Struts TestCase, offers a set of mock object for Struts 1.
Struts 2 Actions can be tested by instantiating the Action, setting properties, and invoking methods. Dependency Injection support also makes testing simpler.
Harvesting Input
Struts 1 uses an ActionForm object to capture input. Like Actions, all ActionForms must extend a base class. Since other JavaBeans cannot be used as ActionForms, developers often create redundant classes to capture input. DynaBeans can used as an alternative to creating conventional ActionForm classes, but, here too, developers may be redescribing existing JavaBeans.
Struts 2 uses Action properties as input properties, eliminating the need for a second input object. Input properties may be rich object types which may have their own properties. The Action properties can be accessed from the web page via the taglibs. Struts 2 also support the ActionForm pattern, as well as POJO form objects and POJO Actions. Rich object types, including business or domain objects, can be used as input/output objects. The ModelDriven feature simplifies taglb references to POJO input objects.
Expression Language
Struts 1 integrates with JSTL, so it uses the JSTL EL. The EL has basic object graph traversal, but relatively weak collection and indexed property support.
Struts 2 can use JSTL, but the framework also supports a more powerful and flexible expression language called “Object Graph Notation Language” (OGNL).
Binding values into views
Struts 1 uses the standard JSP mechanism for binding objects into the page context for access.
Struts 2 uses a “ValueStack” technology so that the taglibs can access values without coupling your view to the object type it is rendering. The ValueStack strategy allows reuse of views across a range of types which may have the same property name but different property types.
Type Conversion
Struts 1 ActionForm properties are usually all Strings. Struts 1 uses Commons-Beanutils for type conversion. Converters are per-class, and not configurable per instance.
Struts 2 uses OGNL for type conversion. The framework includes converters for basic and common object types and primitives.
Validation
Struts 1 supports manual validation via a validate method on the ActionForm, or through an extension to the Commons Validator. Classes can have different validation contexts for the same class, but cannot chain to validations on sub-objects.
Struts 2 supports manual validation via the validate method and the XWork Validation framework. The Xwork Validation Framework supports chaining validation into sub-properties using the validations defined for the properties class type and the validation context.
Control Of Action Execution
Struts 1 supports separate Request Processors (lifecycles) for each module, but all the Actions in the module must share the same lifecycle.
Struts 2 supports creating different lifecycles on a per Action basis via Interceptor Stacks. Custom stacks can be created and used with different Actions, as needed.
Q3. Difference between struts tags and html tags?
The main difference between regular struts tags and struts-el tags is in how you specify a run-time expression in one of the tags. With regular struts, you use a scriptlet. With Struts-el, you use an EL expression.
For example:
Regular struts:
<html:text property="myProperty" disabled='<%=((MyBean)request.getAttribute("myBean")).isDisabled() %>' />
struts-el
<html:text property="myProperty" disabled="${myBean.disabled}" />
If you're using JSTL tags in your JSPs, I'd strongly suggest using the struts-el tags.
Q4. What are tokens in struts2?
Tokens are used to check for invalid path for by the uer:
1) if the user presses back button and submits the same page
2)or if the user refreshes the page which will result to the resubmit of the previous action and might lead to unstabality..
to solve the abv probs we use tokens
1) in previous action type saveTokens(HttpServletreuest)
2) in current action check for duplication bu
if(!isValidToken())
Another important usage of tokens is to trap an event when the user hits the "Submit" button twice. Tokens allows to prevent duplicate processing for such a request.
Q5. Difference between action and actionsupport?
Action provides the interface for webwork action (WebWork action could just be a pojo as well) and default results name (as constants).ActionSupport provides implementation for Action and a bunch more like Validateable, ValidationAware, TextProvider etc, so the actioncould recognized errors, provide i18n messages etc. Most of the time, we'd like to extends from ActionSupport.
Q6. Interceptors work on which design pattern?
dont know..??
Q7. What are Controllers in struts?
The controller is responsible for intercepting and translating user input into actions to be performed by the model. The controller is responsible for selecting the next view based on user input and the outcome of model operations. The Controller receives the request from the browser, invoke a business operation and coordinating the view to return to the client.
The controller is implemented by a java servlet, this servlet is centralized point of control for the web application. In struts framework the controller responsibilities are implemented by several different components like
The ActionServlet Class
The RequestProcessor Class
The Action Class
The ActionServlet extends the javax.servlet.http.httpServlet class. The ActionServlet class is not abstract and therefore can be used as a concrete controller by your application.
Q8. What is local dispatcher?
Dont knew.??
Q9. Action class is class or servlet?
No!!! Action class is not a servlet. it may resemble like Servlet since it is using HttpServletRequest and HttpServletResponse but actually its a plain java class which is been called/Managed by a well defined framework called Struts.
Q10. What is onBlur() method do?
Executes JavaScript whenever a user moves with the mouse the focus away from an element within a form. In other words, whenever a person first clicks an element, and then clicks anywhere outside of it.
