There is a passage like this in the official sun document.
Official Document Statement
public interface SimpleTag extends JspTag Interface for defining Simple Tag Handlers. Simple Tag Handlers differ from Classic Tag Handlers in that instead of supporting doStartTag() and doEndTag(), the SimpleTag interface provides a simple doTag() method, which is called once and only once for any given tag invocation. All tag logic, iteration, body evaluations, etc. are to be performed in this single method. Thus, simple tag handlers have the equivalent power of BodyTag, but with a much simpler lifecycle and interface. To support body content, the setJspBody() method is provided. The container invokes the setJspBody() method with a JspFragment object encapsulating the body of the tag. The tag handler implementation can call invoke() on that fragment to evaluate the body as many times as it needs. A SimpleTag handler must have a public no-args constructor. Most SimpleTag handlers should extend SimpleTagSupport.
Life cycle and call process
The following is a non-normative, brief overview of the SimpleTag lifecycle. Refer to the JSP Specification for details.
A new tag handler instance is created each time by the container by calling the provided zero-args constructor. Unlike classic tag handlers, simple tag handlers are never cached and reused by the JSP container.
The setJspContext() and setParent() methods are called by the container. The setParent() method is only called if the element is nested within another tag invocation.
The setters for each attribute defined for this tag are called by the container.
If a body exists, the setJspBody() method is called by the container to set the body of this tag, as a JspFragment. If the action element is empty in the page, this method is not called at all.
The doTag() method is called by the container. All tag logic, iteration, body evaluations, etc. occur in this method.
The doTag() method returns and all variables are synchronized.
Small case of using simple tags
You must know that: a simple tag is also a tag, so the declaration process is the same as a tag, and it is also three steps.
1. Create an implementation class that inherits the SimpleTag class and override the doTag method
2. Strict declarations are made in the tld file
3. Declaration of taglib namespace and tag prefix in jsp page, and then call custom simple tags
first step:Create an implementation class:
package ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
/**
* Control whether the tag body is executed
* @author Summer
*
*/
public class BodyController extends SimpleTagSupport {
static{
/*
* The overall execution process of simple tags is as follows:
* 1. The browser sends a request to the web server, and then the web server calls servlet (jsp)
* The interpreter initializes, first calls the setJspContext method and passes the pageContext object into it
* 3. Then look at the parent tag of this tag, i.e. setParent method
* 4. Then call the doTag method, right? But you need to know that doTag will use JspFragment object internally, so you must get it first, so you should call the setJspBody(JspFragment jspBody) method
* 5. Finally, call the doTag method to execute the relevant code logic
*/
}
/**
* Simple tags can use this method to implement all business logic
*/
@Override
public void doTag() throws JspException, IOException {
//Object representing the tag body JspFragment fragment = ();
//(null); refers to whom the content in the tag is written to. null represents the browser
//1. Modify the content of the tag body// (null);
//2. Control the repeated output of tag body content// for(int i=1;i<=5;i++){
// (null);//Set to null, default output to the browser// }
//3. Modify the content of the tag body PageContext context = (PageContext) ();
StringWriter writer = new StringWriter();
(writer);
String content = ().toString();
().getOut().write(());
//4. To control whether the execution of the jsp page is done, you only need to master one principle. /*
* SkipPageException - If the page that (either directly or indirectly) invoked this
* tag is to cease evaluation. A Simple Tag Handler generated from a tag
* file must throw this exception if an invoked Classic Tag Handler
* returned SKIP_PAGE or if an invoked Simple Tag Handler threw
* SkipPageException or if an invoked Jsp Fragment threw a
* SkipPageException.
*/
// throw new SkipPageException();
}
}
Configure the relevant constraints in the tld file:
<?xml version="1.0" encoding="UTF-8" ?>
<taglib xmlns="/xml/ns/j2ee" xmlns:xsi="http:///2001/XMLSchema-instance"
xsi:schemaLocation="/xml/ns/j2ee /xml/ns/j2ee/web-jsptaglibrary_2_0.xsd"
version="2.0">
<description>JSTL 1.1 XML library</description>
<display-name>JSTL XML</display-name>
<tlib-version>1.1</tlib-version>
<short-name>x</short-name>
<uri>/simplesummer</uri>
<!-- Custom tags for simple tags that control the content of tags -->
<tag>
<name>BodyController</name>
<tag-class></tag-class>
<body-content>scriptless</body-content>
</tag>
</taglib>
Step 3:Make a declaration in the jsp page and call:
<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%> <%@taglib uri="/simplesummer" prefix="summer"%> <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http:///TR/html4/"> <html> <head> <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"> <title>useSimpleTagThe test page that controls whether the tag body content is executed by the interface</title> </head> <body> <summer:BodyController>Summer</summer:BodyController> </body> </html>
Summarize:
Simple tags can replace the BodyTag interface to perform the same operation, but it is simpler and lighter
Simple tag lifeCycle is clear logic and the calling rules are clear
Use relevant flow objects to complete manipulation of tag body maniplate
The above is all about this article, I hope it will be helpful to everyone's learning.