Reform Java Web Template Technology - FASTM

Reform Java Web Template Technology - FASTM

1. "Simple is beautiful" is anxious (ring)

In the field of software design, there is a famous saying that the famous name is simple.

Almost all masters of software design will be trained in their works:

"Simple and beautiful",

"Keep IT Simple, Stupid",

"Less is more",

... ..

This is a good voice, everyone will say.

But in fact, this is also the most widely used in violation of it.

"Simple is beautiful" this truth is like heaven, everyone says heaven, but everyone is desperate to delay the time to arrive at paradise.

In general, software development technologies have always become more complicated and increasingly huge.

Let's see the development history of Java Web performance layer technology.

(1) First, servlet is born. Web programmers are very happy, I feel that it is much more cool than CGI.

(2) After a while, people think that HTML is too unhappy in the Java program. After all, in HTML, static text tags account for most, and the dynamic display part is just a small part. It is better to write Java code in HTML. So JSP was born. Become a strong competitor of ASP.

(3) After a while, people think that HTML and Java code are mixed together, not only the page structure is poor, but the Java code is difficult to maintain. This is the famous "Java Code Poll" problem. It is better to replace Java code with custom XML elements, so that the entire page is XML. So, taglib appeared.

(4) There is still a problem, Taglib cannot be displayed in a general HTML browser or editor, the page cannot be seen. The ASP.NET is quickly visible to the advantages of developing, and is being taught in the Web Development field. Java world rush to fight, start JSF projects. A large number of Web Framework camps has an authoritative heavyweight player.

Various new concepts have endless, and the page process is more complicated.

It is said that this is to reduce development difficulty, so that the programmer only focuses on business logic, not to care about the underlying technical details; it is said to be an enterprise application, and the demand for enterprise applications is complex, so the simple problem is complicated It is reasonable - it is said that this is for the systematic facing expandability, scalable ...

This is an era of mythology, which is a concept of negative manufacturing.

Deep thinking, I think the complex trend of technology, maybe it is the commercial market for commercial demand?

There are two types of driving force in new technologies:

(1) The first driving force is to solve the true problem.

For example, the appearance of servlet is to solve the problem of spatial time consumption of CGI. More than CGI, servlet is a new idea, an alternative technology.

The new technologies caused by the first driving force are relatively long, not sufficient to maintain people's technical needs.

(2) The second driving force is to make up for the shortcomings of the previous technique.

Complex technologies have some shortcomings, so it creates domestic demand for the next technological innovation. Moreover, the more complex technology, the more inadequate, the technology "innovation" (or "repair" more suitable?) Domestic demand and business opportunities are, forming a technical "repair" industry chain of self-produced sales.

For example, the emergence of JSP is to assist in generating servlet; and Taglib's appearance is to make up for the lack of JSP; the Taglib visualization plug-in is to make up for the shortcomings of Taglib. The business opportunities are unlimited, and a large number of technical vendors that offer a variety of Taglib and Taglib visual plugins, the technology market is booming. The new technique of this second driving force is relatively short, and the children of the children will be unfusited, and there is no broken.

But I firmly believe that the technology will return to the true.

One day, we will return to the road that really solves the problem, rather than continuing a road to technology "repair replenishment".

2. The birth of FASTM - "Simple is the beauty" king returned

The Java World is an open world. I think it is because of this, the majority of Java programmers must not leave this Java development camp.

Java.sun.com announced all Java technical specifications.

Apache.org Open Source Community has attracted a lot of programmers to join the Java development camp.

SourceForge.net provides a larger programmer (not only Java), providing space for communication, sharing, and development.

It is because such openness has promoted the unprecedented development of Java development technology.

It is also because of this openness, forming a Java Web performance layer technology group.

In the field of Java Web performance layer, JSP TAGLIB page technology is authority and standard, but this area does not exclude other technologies.

As mentioned above, JSP Taglib is not perfect, so it has the inherent demand for development.

At the same time, this also has prompted people to continue to explore, compare other technical possibilities.

All levels of the Web performance layer - O / R layer, business layer, web framework, etc. are directly implemented by Java code, which can be well structured, objective, and there is no problem. Only the Web performance layer, the natural structure is loose, and the wild is hard.

I am a Java WebApp programmer, has always worked hard to do the same structured, objectivity. For two or three years, I have applied, studies, compared a variety of web performance layer technology:

(1) velocity http://jakarta.apache.org/Velocity/ (and Webmacro, FreeMarker .. etc)

(2) TapeStry http://jakarta.apache.org/tapestry/

(3) echo http://sourceforge.net/projects/echo

(4) Cocoon (XML XSLT) http://cocoon.apache.org/

(5) XMLC (Static Dom) http://xmlc.enhydra.org/

(6) Nekohtml (Dynamic Dom) http://www.apache.org/~andyc/neko/doc/html/

(7) JDYNAMITE (PHP Template Port) https://sourceforge.net/projects/jdynamite

Through research comparisons, I found the "Source" in template technology - the logic code contained in the template (IF, Else, For, assignment, operation, call, etc.).

These logic code contained in the template is the natural enemies developed by "what you see", and it is also the first culprit to destroy the reuse.

JSP Taglib, Velocity, TapeStry, XSLT, etc. are all logical templates. If there is no special plugin, these templates cannot be properly displayed correctly in a normal HTML browser or editor. Moreover, the logic of mixed in HTML is no way to reuse; you cannot separate these logic into general methods or classes.

JDynamite is an open source project that transplants PHP template technology to Java. JDYNAMITE Template Marks the Dynamic Block with the begin-end. Tag placed variables with the {}. The JDYNAMITE template does not contain any logic, which is a template technology that "WYSIWY", which is capable of correctly displayed in a normal HTML browser or editor.

XMLC and other DOM template techniques directly use the HTML file as a template, of course, the template technology of "what you get".

JDYNAMITE and XMLC is in common, and there is no logic in the template. All template processing logic (inspection judgment, node assembly, variable replacement, etc.) are completed in the code.

Although these two techniques have separated from the template definitions, they do not completely separate the logic and data from the template.

Let's take a look at the usage of HTML DOM in XMLC technology. A HTML DOM just generated, or a pure template. However, the program directly changes the node data of the HTML DOM, and even change the position and quantity of the node. This HTML DOM can no longer be used as a pure template, let alone multiple threads in multithreaded environments. At the same time. Think about it, in a static text accounting for most DOM structures, this practice will cause how big space and time.

JDYNAMITE usage has the same performance problem as XMLC.

I think how to solve this performance defect. Finally, on the basis of JDynamite, PHP, and DOM, I created the concept of Template Dom and ValueSet DOM. From the usage, further data and logic thoroughly from the template. Separate. Thus, the FASTM open source project was born.

3. Small, fast, simple, easy, strong "silver bomb" - FASTM

FASTM has an unparalleled superiority of other pages generation techniques:

What you have come, easy to learn, fast development, small running space, fast running speed, complete separation of template and data, multi-to-many free matching data.

FASTM is the best template technology from all aspects - the fastest, minimum, most easy to use, the most flexible and powerful (very flexible with pure servlet / JSP). I expect FASTM page generation methods to better solve the web page generation problem and can be popular in the world's Java web programmers.

Is it just self-selling self-selling self-selling?

This is easy to distinguish: FASTM is a fully open source project, a trial. Due to FASTM's ideas, implementation and usage easy to understand, this trial can't spend any time.

FASTM truly proves that "simple, beautiful". Let me explain the FASTM ideas and usage.

3.1 FASTM template is a lightweight DOM

Like the PHP template, the FASTM template contains only three elements:

(1) Static text.

(2) Place a variable. Use the {} sign.

(3) Dynamic block. Use the begin-end dynamic logo.

Among them, the dynamic block can contain other elements - sub-dynamic blocks, placeholders, static text. Therefore, the FASTM template is a tree structure, which is equivalent to a lightweight DOM structure. Behind We call this structure as a Template DOM. The following is a simple example. For example, the HTML piece below.

[code]

PT

ION value = "{zipcode}"> {zipcode}

PT

ION>

[/ code]

This piece contains a begin-end block (zipcodes), which contains two identical variables {state}, and other parts are static text.

The Fastm Template DOM structure of this piece is as follows:

[code]

Static text

Dynamic block Zipcodes - | --- Static text

PT

ion value = "| --- Variable {zipcode} | --- static text"> | --- Variable {zipcode} | --- Static text

PT

ION> Static Text [/ Code]

It seems that FASTM Template Dom is not very special. But Template DOM has a vital feature - read-only and cannot be changed. Since only read only, of course, the thread is safe, the same template DOM can be used concurrently by multiple threads simultaneously.

So how do we get dynamic pages from read-only Template Dom? We must load dynamic data into a ValueSet DOM structure (also a tree structure), then match the Template DOM with this ValySet DOM to generate dynamic results. 3.2 Template DOM VALUESET DOM = DYNAMIC RESULT

Template DOM contains three elements nodes: static text nodes, variable assignment nodes, dynamic block nodes. Due to the statically text node does not need to be assigned, ValueSet DOM only contains two element nodes-variable assignment nodes, and dynamic block assignment nodes. Wherein, the dynamic block assignment node can include sub-dynamic block assignment nodes and variable assignment nodes. Therefore, ValueSet DOM is a tree structure corresponding to the dynamic part of the Template DOM.

The node correspondence between the Template DOM and ValueSet DOM is as follows: The Template DOM variable node and the ValueSet DOM variable assignment node are one-on-one relationship. There is a pair of relationships between the dynamic block nodes of the Template DOM and the dynamic block assignment nodes of ValueSet DOM, which is to make dynamic blocks multiple times in the page.

Let's construct a ValueSet Dom for the Template DOM structure (Zipcode Select).

String [] zipcodes = {"361005", "100008"};

IvalueSet Top = new valueSet (); // Corresponding to the entire HTML piece list items = new arraylist (); // corresponds to dynamic part zipcodes for (int i = 0; i

We combine TOP this VALUESET DOM and Template DOM. Generate the following results.

[code]

PT

ION value = "361005"> 361005

PT

ION>

PT

ION Value = "10008"> 100008

PT

ION> [/ code]

A Template DOM can match multiple ValueSet Doms. Similarly, a ValueSet DOM can also match Template DOM, display the same data in a different template.

For example, we have such an HTML piece: [code]

{zipcode} [/ code] We assigned the top valueset to this template. The result obtained is as follows. [code] 361005 100008 [/ code] We can see that Template DOM is template, with only display style and block definition. ValueSet DOM is data and contains only data. The separation of Valueset Dom and Template DOM is a great idea innovation and leap. After all, the dynamic part of the page, and static comparison, is a very small part. Valueset DOM represents the dynamic part, generated by the program, there can be multiple copies. Template DOM represents a static part and only needs to be analyzed once and only one copy is needed. The separation of ValueSet Dom and Template DOM is a unprecedented thorough display and data separation. More thorough than XML / XSLT. XML is indeed pure data, but inevitable in XSLT should include logic. ValueSet Dom is pure data, without any logic, Template Dom is a pure display template, nor is there any logic. Since the data structure is a DOM structure, FASTM implements Tile, Portal and other functions, it can be said that it is super easy. You must not write the page assembly logic, don't twist the pile of complex Taglib, you can write the page assembly logic in a small common method. 3.3 FASTM resources list Http://sourceforge.net/projects/faSTM users can download the source code file for FASTM and FASTMWEB from this address, using documentation. The FASTMWEB is FASTM's auxiliary project FASTMWeb to help define the FASTM template in the load web environment. Like Velocity, users can use FASTM template technology in any Web Framework. http://sourceforge.net/projects/lightweb LightWeb is a lightweight web framework developed by FASTM authors. Its demos Demo-FastLight demonstrates how to use FASTM in the LightWeb framework and compare with the JSP program. After downloading, you can run directly in Web Server (such as Tomcat). 4. Technical Prospect - Saving B / S WebApp? I am sure that FASTM will be popular as a template development standard. Of course, there must be a huge resistance of habits and meet, after all, FASTM's authors is just a nameless unknown generation. But FASTM will win, but it is only time to time. Once FASTM's popularity exceeds a certain threshold, FASTM will sien the city with the trend of the Sparks, compete for users of all "complex" template technology. In the short term, FASTM eliminated complex and equals a lot of business opportunities. FASTM itself is so simple, providing enough new business opportunities; technical writers have no opportunities for "FastM in action", because FASTM definitions and usage are too simple; and FASTM greatly reduces the technical threshold for Java WebApp. Will the Java web programmer depreciate? What is the benefit of FASTM's development camp on Java? In a long time, FASTM can help Java development camps to recover the territory of ASP.NET to take away from the Web Development field, and change the strength of the two camps. FASTM is enough to be more than Visual Studio.net (ASP). The FASTM template does not require any special support, you can "see what you get" in a normal browser; ASP template must be displayed correctly in Visual Studio.NET (and is displayed in form). The FASTM template is much simpler than the ASP template. From the usage, even more simple than its source PHP template. With FASTM, a large number of PHP programmers can go directly to the Java Web development camp without learning those of the complex new template technology. JSR-223 is a JAVA and PHP and other scripting languages ​​(as well as Perl, Python, Ruby, TCL) JSR. http://www.jcp.org/en/jsr/detail?id=223 is currently in the stage of preliminary discipline. This is given from another aspect, and the FASTM is aimed directly to Java Native PHP Improvement Templates for Java and PHP programmers. As for if FASTM will make the Java web programmer depreciate. I think that some complex technologies may be depreciated in the special master of certain complex technologies (such as JSP debug masters, various Taglib use masters). However, FASTM will not make the masters that solve the true problem. Instead, FASTM will help these masters to more focused on solving real problems. Regarding the current JSF, I am very happy to see the emergence of this powerful development framework. But to tell the truth, I don't think Taglib visual drag and drop is sufficient to compete with Visual Studio.net (ASP). That is equal to the shortness of your own, the length of people. Moreover, a potential danger is that the Java Web development framework will be collected by a Microsoft advocated "C / S structure, desktop client" is not returning. One current trend is that the B / S development framework is close to the C / S development framework. Almost all modern web development frameworks are working hard to process the processing mechanism - binding the front page components and background processing code. The ASP development tool for Visual Studio.net is a typical C / S B / S development structure. The JSF's WebApp Development Tool section also steps, followed by this road. Not only there is this trend in the development framework of the server, but it has become more intensified in this trend in the client. After ActiveX, Applet, XMLHTTP, FLEX and other new generations of "browser plug-in client technology" is in the like. Open Source Community Mozilla proposed and supported XUL technology. Microsoft's Longhorn 64-bit operating system proposes "Desktop," (in fact, is equivalent to the demise of the browser), and push XAML. HTML is not optimistic by both sides. HTML prospects are worrying. One possibility: HTML in the future is likely to be existing as a record format of historical data, not as the UI of the application; and HTML browser will only exist as a historical information viewer; HTML B The / s The WebApp era ends. It can be said that B / S WebApp is destroyed in a more and more complex domestic demand and development structure. The interoperability requirements of the B / S WebApp interface are getting stronger. The browser needs to support more and more features, and there are more and more plugins (Java SCRI) PT , ActiveX, Flash, XUL. Since this is, why is it browser? The Web Service protocol is more perfect than the HTTP protocol format, and directly uses the Web Service client to be more direct and more completely? Microsoft grasps and guides this trend, and the Java world is also prepared for both hands. Whether it is Visual Studio.NET, or JSF, its focus is supported by Web Service applications. After all, Web Service is a technology that belongs to the next two years. Web will become more and more powerful, everywhere. Semantic Web more effectively organizes the entire Web resource into a huge document library, database, database, and service library. In this great situation, the protagonist will be a variety of Web Service Agents, and now the red protagonist - HTML B / S WebApp faces the possibility of future (several years). (Oh, don't rush to say this is an alarmist, I just assume that this possibility) Under the nest, do you have a finish? If HTML B / S WebApp dies. A large number of html taglibs have been eliminated. TapeStry, XMLC, Echo also eliminated. The project of XML XSLT may also survive - such as transforming XSL, output XUL or XAML. FASTM is of course surprising - FASTM can also generate XUL and XAML to "what you see". As long as there is a dynamic generation of visualization XML UI, FASTM is useful. If B / S WebApp is destined to withdraw from the historical stage, FASTM is also unable to save, but FASTM can at least delay this process. The very low technical threshold of FASTM can attract a large number of page developers, leaving in the field of HTML B / S WebApp. Moreover, FASTM belongs to the present and future. It can be used as a building now HTML, WML UI, can also be used to build future XUL, XAML UI. Why don't you choose FASTM? ^ _ ^ 转载请注明原文地址:https://www.9cbs.com/read-16395.html 9cbs New Post(0)