Answer / surendraeddy.m

1.Forward Action
2.Dispatch Action
3.include Action
4.lookUpDispatch Actioc
5.MappingDispatch Action
6.switch Action
7.LocaleDispatch Action

Answer / akbar.nk

There are 9 types of Action Classes in struts, but e use
frequently only 5 types:

1.Action class
2.DispatchAction class
3.LookupDispatchAction class
4.MappingDispatchAction class
5.LocaleAction class
6.ForwardAction class
7.IncludeAction class
8.SwitchAction class
9.DownloadAction class

Answer / amit verma

there r only 5 actions:

1. forward action
2. include action
3. dispatch action
4. lookup dispatch action
5. switch action

Answer / saranv

THERE ARE FOUR TYPES.



1)

DispatchAction: In this type of aggregation, the action
class must extend DispatchAction class as shown.

public final class CRUDDispatchAction extends
DispatchAction {

public ActionForward create(ActionMapping mapping,
ActionForm form,
HttpServletRequest request,
HttpServletResponse response) throws Exception {
return (mapping.findForward("success"));
}
...

and the action mapping will be as

<action path="/crudDispatchAction"
type="com.companyname.projname.CRUDDispatchAction"
name="formName" scope="request" input=" homeDef"
parameter="methodToCall">
<forward name="success" path="targetDefName"/>
</action>

in your jsp you can call this action as

<html:link action="crudDispatchAction?
methodToCall=create">Create</html:link>
...

Observe that the above class extends DispatchAction and so
you cannot use this method if your class already extends
your (some) super class (eg., the class where the session
is validated/invalidated). Here the user has to send a
query string variable (methodToCall) to set the action name
to call.


2)



ActionDispatcher: This flavor of aggregation is same as
DispatchAction except that we need not extend
ActionDispatcher, so we can use this method even if our
class extends a super class. The following code snippet
shows this scenario.


public final class CRUDActionDispatcher extends Action {

protected ActionDispatcher dispatcher = new ActionDispatcher
(this, ActionDispatcher.DEFAULT_FLAVOR);

public ActionForward execute(ActionMapping mapping,
ActionForm form,
HttpServletRequest request,
HttpServletResponse response) throws Exception {
return dispatcher.execute(mapping, form, request, response);
}
The DEFAULT_FLAVOR field suggests that the default
parameter is "method" if none is specified as parameter in
struts-config.xml (eg,. methodToCall).
ActionDispatcher flavor also needs methodToCall parameter
to be set (using hidden variable or a query string) as in
case of DispatchAction.




3)



LookupDispatchAction: This type of aggregation is useful in
situations where in you have multiple submit buttons in a
single form. The class must extend LookupDispatchAction.
However, the great thing about this type is that its java
script free. That means, you need not set any hidden
variables or pass query string however, you must use submit
buttons as shown.

<html:submit property="submit"><bean:message
key="button.create"/></html: submit >
<html:submit property="submit"><bean:message
key="button.read"/></html: submit >
...
The example Action class will be as follows

public class CRUDLookUpDispatchAction extends
LookupDispatchAction {

protected Map getKeyMethodMap() {
Map map = new HashMap();
map.put("button.create", "create");
?
return map;
}
public ActionForward create(ActionMapping mapping,
ActionForm form,
HttpServletRequest request,
HttpServletResponse response) throws Exception {
return (mapping.findForward("success"));
}
Observe the getKeyMethodMap() method. The submit button
names are specified in a Map and their keys comes from
MessageResources file. Struts picks up the name from this
file and redirects it to the value specified in the Map.
The calling code in jsp however has multiple submit buttons
only differing in their names.





4)



MappingDispatchAction: This aggregation extends
MappingDispatchAction class. This is the most useful type
among the four types available. But as seen in other cases,
you can use this type only when your action does not extend
any other action. The good thing about this type is that
the action mappings can differ and so need not be the same
as in all other cases. To illustrate this consider the
below mappings.

<action path="/createMappingAction"
type="com.bodhtree.CRUDMappingDispatchAction"
scope="request" input="homeDef" parameter="create">
<forward name="success" path="targetDef"/>
</action>
<action path="/readMappingAction"
type="com.bodhtree.CRUDMappingDispatchAction" name="
formName" scope="request" input="homeDef" parameter=" read">
<forward name="success" path="targetDef"/>
</action>

Notice that in the first action mapping, there is no form
bean while in the second the bean name is specified. This
means that the user has the flexibility to change the
mapping according to his needs and hence not been contained
to use a constant mapping for all the CRUD actions. Note
that in all the other types of aggregations, we must use
the same mapping for all the CRUD actions.

Answer / srinivas

1)Forward Action
2)Include Action
3)Dispatch Action
4)Switch Action.........(one more Action is there)

Answer / sarika singh

there are 7 type of classes--
1.dispatch action class
2.forward action class.
3.include action class.
4.locale action class.
5.lookup dispatch class.
6.mapping dispatch class.
7.switch class.

Answer / raghava

1.ForwardAction class
2.DispatchAction class
3.IncludeAction class
4.LookUpDispatchAction class
5.MappingDispatchAction class
6.SwitchAction class
7.LocaleDispatchAction class
8.DownloadAction class

Answer / ramakrishna goud.n

Different types of action classes
1).Action Class
2).IncludeAction Class
3).ForwardAction Class
4).DispatchAction Class
5).LookUpDispatchAction Class
6).SwitchAction Class

In this we use the Action Class for implementing the
business logic

We use the IncludeAction,ForwardActions,
Suppose if you want to use your servlet application or jsp
application(which are developed previously and u want to
resue it ) should follow the struts MVC pattern then you
can acheieve that using these classes

We use the DispatchAction when you want have to perform
multiple actions through one form

We can use the switchAction when you want to use the
resources from other modules of your struts application

LookupDispatchAction is similer to DispatchAction.

this information is very useful to the guys who has the
intrest to learn struts
All the best.........

Answer / ramesh yampalla

There are six Types of Action Classes are there in Struts----

1.ForwardAction Class
2.IncludeAction Class
3.DispatchAction Class
4.LookupDispatchAction Class
5.MappingDispatchAction Class
6.SwitchAction Class

Answer / nagendrakumar kalagara

There are 8 Action Classes are given in org.apache.struts.actions package and this is given in struts-extras-1.3.8.jar.
1.Dispatch Action
2.LookupDispatch Action
3.MappingDispatch Action
4.Switch Action
5.Forward Action
6.Include Action
7.Download Action
8.Locale Action
this is the correct way of understanding actions.

What configuration changes are required to use Tiles in Struts?

0 Answers  

if u r using eclipse tool how can u debbaging u r application? plz explain with sample code

3 Answers   IBM, Tech Mahindra,

Is struts 1 still supported?

0 Answers  

What are pull and push mvc architecture and which architecture does struts2 follow?

0 Answers  

State an example of struts configuration file as an action parameter for action servlet.

0 Answers  

what is is the use DynaActionForm?

3 Answers   TCS,

collection framework hirarchy?

5 Answers  

Describe the mvc on struts?

0 Answers  

What's mvc pattern ?

0 Answers  

In which method of action class the business logic is executed?

0 Answers  

What is the purpose of constant tag in struts.xml?

0 Answers  

Explain architecture of struts2?

0 Answers