Thymeleaf is an easy-to-extend library, and most user-oriented features are not built directly into his core, but are packaged and assembled into a collection of functions called dialect (dialects).
Due to the Spring-boot indirect type of the main push thymeleaf template, so this article mainly introduces the thymeleaf of some of the extended functions, although the performance of THYMELEAF3 compared to 2 of the increase is very large, but compared to other, there is a little difference.
dialect (dialects)
If we have studied some of the basics of thymeleaf, we should be able to realize that what we have previously known is not thymeleaf, but Thymeleaf's standard dialect, such as Th:text, which is just a standard dialect that can be used immediately.
We can also customize a set of attribute or tags to work with our templates in Thymeleaf.
Dialects is the object that implements the Org.thymeleaf.dialect.IDialect interface, as follows:
Public interface Idialect {public
String getName ();
}
At the same time, the most basic interfaces are:
* Iprocessordialect Processor dialect
* Ipreprocessordialect preprocessing dialect
* Ipostprocessordialect post-processing dialect
* Iexpressionobjectdialect Expression Object dialect
* Iexecutionattributedialect executable Properties dialect Iprocessordialect processor dialect
See Interface code
Public interface Iprocessordialect extends Idialect {public
String getprefix ();
public int getdialectprocessorprecedence ();
Public set<iprocessor> getprocessors (final String dialectprefix);
Processor is the object responsible for executing most of the logic in the Thymeleaf template. Also the most important extension dialect.
Three are defined primarily as attribute methods.
* Prefix applies to prefixes that match elements and attributes, similar to th in Th:if,thltext. If you want the processor to execute on an undefined label or property, you can define prefix as null
* Getdialectprocessorprecedence defines the priority of the dialect.
* Getprocessors defines a set of processors provided by this dialect. Ipreprocessordialect preprocessing dialect
Public interface Ipreprocessordialect extends Idialect {public
int getdialectpreprocessorprecedence ();
Public set<ipreprocessor> getpreprocessors ();
}
preprocessing and post-processing are different from processors. The processor is executed at a single time or on a template fragment. preprocessing and post-processing, as an additional step in the engine processing process, are applied throughout the execution of the template.
So they follow the different APIs that are done with the processor, and they are more event-oriented.
Preprocessing is applied in a specific case before the processor is executed for a specific template. The post processor is instead applied after the processor is executed. Ipostprocessordialec post-processing dialect
Public interface Ipostprocessordialect extends Idialect {public
int getdialectpostprocessorprecedence ();
Public set<ipostprocessor> getpostprocessors ();
}
Iexpressionobjectdialect Expression Object dialect
By implementing this interface, dialect can provide a new expression object or an expression application object, such as #strings, #numbers等
Public interface Iexpressionobjectdialect extends Idialect {public
iexpressionobjectfactory Getexpressionobjectfactory ();
}
As you can see from the code, IEXPRESSIONOBJECTDIALECT returns a factory class because some expression objects need to process the data in the context to be built, so it's not possible to build them until we actually process the template. In addition, most expressions do not require expression objects, so they can be built on demand only when certain expressions are really needed.
Public interface Iexpressionobjectfactory {public
map<string,expressionobjectdefinition> Getobjectdefinitions ();
Public Object buildobject (final Iprocessingcontext processingcontext, final String expressionobjectname);
Iexecutionattributedialect executable attribute dialect
The dialect that implements this interface is allowed to provide execution properties, which are objects that are available to each processor during template processing.
For example, Standarddialect implements this interface to provide each processor with the following features:
* Thymeleaf Standard expression parser so that you can parse and execute standard expressions in any property
* Variable Expression calculator ... Expressions are executed in OGNL or Springel (depending on whether we use the Spring Integration module). ∗ in {...} Expressions are executed in OGNL or Springel (depending on whether we use the Spring Integration module). * in {{...}} Transform service to perform transformation operations in an expression
Note that these objects are not available in the context, so they cannot be used in template expressions. Their availability is limited to the implementation of extension points, such as processors, preprocessor, and so on.
Public interface Iexecutionattributedialect extends Idialect {public
map<string,object> Getexecutionattributes ();
}
Processors Processor
The processor's objects all implement the Org.thymeleaf.processor.IProcessor interface.
The interface code is as follows:
Public interface Iprocessor {public
templatemode gettemplatemode ();
public int getprecedence ();
}
The next several common types of processor Ielementprocessor are described below
The element processor is executed on an open element or on a separate element.
Public interface Ielementprocessor extends Iprocessor {
/**
* <p>
* Returns the element name that W Ould make this processor match (if any).
* </p>
*
* @return The element name.
*
/Public matchingelementname getmatchingelementname ();
/**
* <p>
* Returns the attribute name is would make this processor match (if any).
* </p>
*
* @return the attribute name.
*
/Public matchingattributename getmatchingattributename ();
}
The Ielementprocessor processor does not directly implement this interface, it also contains two sub-interfaces
* Ielementtagprocessor
* Ielementmodelprocessor itemplateboundariesprocessor Other processors
The following are other events where Thymeleaf 3.0 allows the declaration of the processor, each of which implements the appropriate interface:
* Text Events: interface Itextprocessor
* Comment Events: interface Icommentprocessor
* CDATA Section events: Interface Icdatasectionprocessor
* DOCTYPE Clause Events: interface Idoctypeprocessor
* XML Declaration Events: interface Ixmldeclarationprocessor
* Processing instruction Events: interface Iprocessinginstructionprocessor
The processor is not described in detail, followed by specific practical use to illustrate