What is action in jsp

The Action class in JSP is the bridge between user requests and business logic. Each Action acts as a business agent for the customer. When the "RequestProcessor" class preprocesses the request, and after creating the Action instance, You can call its own "processActionPerform" method.

The Action class is the bridge between user requests and business logic. Each Action acts as a business agent for the customer. When the RequestProcessor class preprocesses a request, after creating an instance of Action, it calls its own processActionPerform() method, which calls execute() of the Action class.

Recommended course: Java Tutorial.

The following introduces the function of action in jsp:

Complete action

<action path="/aFullAction" 
type="somePackage.someActionClass">  
name="someForm" 
input="someJSP.jsp" 
<forward name="successful" path="someJSP.jsp"/>  
<forward name="failed" path="someOtherJSP.jsp"/>  
</action>

First, the ActionServlet of Struts receives a request, and then according to struts- The configuration of config.xml locates the corresponding mapping; then, if the scope of the form is request or it is difficult to find the form in the defined scope, create a new form instance; after obtaining the form instance, call its reset ( ) method, and then put the parameters in the form into the form. If the validate attribute is not false, call the validate() method; if validate() returns non-empty ActionErrors, it will be transferred to the URI specified by the input attribute. If it returns empty ActionErrors, then execute the execute() method of Action and determine the target URI based on the returned ActionForward.

The effect of this is: execute() will only be executed after validate() succeeds; the input attribute specifies a URI.

Only JSP action

<action path="/aJSPOnlyAction" 
type="org.apache.struts.actions.ForwardAction" 
parameter="someOtherJSP.jsp" 
/>

First, ActionServlet calls the execute() method of ForwardAction after receiving the request. execute() forwards according to the configured parameter attribute value. to that URI.

The effect of this is: no form is instantiated. A more realistic situation may be that the form is defined in the higher-level scope of the request; or this action is used to act as a system after the application is compiled. Parameters, you only need to change this configuration document without recompiling the system.

Two actions correspond to one form

<action path="/anAction" 
type="somePackage.someActionClass">  
name="someForm" 
input="someJSP.jsp" 
<forward name="successful" path="/anotherAction.do"/>  
</action>  
<action path="/anotherAction" 
type="somePackage.someOtherActionClass">  
name="someForm" 
input="someOtherJSP.jsp" 
<forward name="successful" path="someResultJSP.jsp"/>  
</action>

As far as each individual action is concerned, the processing is not complete. What is the actual difference between actions? This combination pattern can be used to pass command objects (forms). It should be noted that the reset() and validate() methods of the form will also be called in the latter action, so we must ensure that the information in the form is not overwritten.

The processing methods are roughly divided into two types:

a) Put an indicator in the request to indicate that the previous action intends to pass the form to the next action, so that the next action Action can retain the value in that form. This method can only be used when using forward.

b) When using redirect instead of forward, you can put the indicator at the session or higher level, and clear this indicator at the last link of the command chain.

<action path="/anAction" 
type="somePackage.someActionClass">  
name="someForm" 
input="someJSP.jsp" 
<forward name="successful" path="/anotherAction.do" redirect="true"/>  
</action>  
<action path="/anotherAction" 
type="somePackage.someOtherActionClass">"  
name="someOtherForm" 
input="someOtherJSP.jsp" 
<forward name="successful" path="someResultJSP.jsp"/>  
</action>

This combination method is not much different from the previous one in terms of process, except that we now provide forms for the two actions separately, so the code looks clearer. So we can handle the input and output of the WEB application separately.

It is worth noting that the latter action will also try to write those parameters into the form, but we can handle it like this:

a) Use another set of attribute names in the latter form ;

b) Only getters are provided but not setters.

The rough processing is as follows:

The previous action receives input, verifies it, then writes the data to the business layer or persistence layer, and redirects to the next action. The latter action manually retrieves the data from the business layer/persistence layer, writes it into the form (through other methods), and hands it to the front-end JSP for display.

The advantage of this is that you do not have to retain the value in the input form, so you can use redirect instead of forward. This reduces the coupling between the two actions and avoids unnecessary repeated submissions.

The above is the detailed content of What is action in jsp. For more information, please follow other related articles on the PHP Chinese website!