Java EE 8中的JSF指南：迈向WebSocket与CDI新时代

Java

需积分: 9 186 浏览量更新于2024-07-18 收藏 6.57MB PDF 举报

身份认证购VIP最低享 7 折!

领优惠券(最高得80元）

资源详情

资源推荐

In the second quarter of 2002 two other cornerstones of JSF were discussed: the

Expression Language (inspired by JSTL), which is instrumental for the so-called bindings

of beans from a template to backing code, and the factory finder, which allowed key

parts of JSF to be replaced and although perhaps not fully realized at the time may have

contributed greatly to JSF still being relevant some 16 years later.

It was in this same quarter that Craig McClanahan took over as spec lead, father of

Struts and architect of Tomcat’s Servlet container, took over. Not long after the discussion

about using JSP started, a discussion, perhaps unbeknownst to the team at the time, that

would, unfortunately, have a rather negative impact on JSF later on. Around the end

of the year 2002, Ed Burns, who like McClanahan had also worked on Tomcat before,

joined the team as co-spec lead. Burns is the person who would eventually become the

main spec lead of JSF for well over a decade.

While the team continued to work on things like the aforementioned managed

beans and the so-called value binding, which is the Java representation of the also

aforementioned expression language binding, the first dark cloud appeared when in the

spring of 2003 team member Hans Bergsten realized that there were very real and major

issues with using JSP as the templating language for JSF.He brought these concerns to

the team, but ultimately they weren’t addressed and instead the following months were

spent, among other things, on a variant of the value binding; it later on became clear that

the method binding and the state saving mechanism were another of JSF’s less than ideal

implementations.

JSF 1.0 and its still nameless RI were eventually released on March 11, 2004—

coincidentally, a mere two weeks before the release of another framework that’s still

strong today, Spring 1.0. MyFaces released its 1.0.0 alpha version only days later, on

March 19. It’s perhaps an interesting observation that JSF went final with a full-fledged

XML-based dependency injection (DI) framework just before Spring, which is largely

known for its DI, went final.

JSF 1.0 was generally well received; despite a rather crowded market with

competitors such as Tapestry, WebObjects, Velocity, and Cocoon operating, not less than

three books from writers such as Horst Caymann and Hans Bergsten appeared in the

months after, and the eXo platform (a Digital Collaboration Platform) started using JSF

right away.

Hans Bergsten’s earlier concerns, however, become painfully clear almost just

as quickly; the JSP technology is based on processing a template from start to end,

immediately writing to the response as tags are encountered. JSF, however, requires

a phased approach where components need to be able to inspect and act on the

Chapter 1 history

component tree, which is built from the tags on the page, before starting to write

anything to the response. This mismatch led to many strange issues, such as content

disappearing or being rendered out of order.

Only three months after the introduction of JSF, Hans Bergsten made a strong case

of dropping JSP in his legendary article “Improving JSF by Dumping JSP.” There Bergsten

explains how ill-suited JSP is for use a template language in JSF, but he also presents

a glimmer of hope; because of JSF’s great support for extendibility, it’s relatively easy

to introduce alternative templating simply by replacing the so-called view handler,

something which JSF explicitly allows. It would, however, take five long years until JSF

would indeed ship with a more suitable view templating language, and even though JSP

had been essentially deprecated at that point it’s still present in JSF at the time of writing.

The Adolescent Years

Back in 2004 another first befell JSF; on June 28 Ed Burns announced that the source

of the RI was released by Sun. This represented a major milestone as before that date

most technology in active use by Sun was closed source. Initially the source was licensed

under the somewhat exotic JRL, but later this would be changed to dual licenses, GPL

with classpath exception and CDDL.At the same time as this announcement, the

tradition was established that every new feature or bug fix should be accompanied by a

test, and that all existing tests should be executed before committing the change. Some

14 years later there’s a largely different set of people working on the RI source, and

the project structure and code conventions have changed as well, but the test-driven

tradition is still being uphold in its original form.

At that point Ed Burns decided to focus more on the specification aspects of JSF as

the JSF 1.2 spec work had started right away, and Jayashri Visvanathan, one of the early

team members, took on the lead role concerning the implementation aspects, with Ryan

Lubke, working as the TCK (testing) engineer.

Still only a few months old, a variety of component libraries for JSF had already

started to pop up, although all of them commercial. Among those was the one from

Oracle, ADF Faces. ADF Faces was put on Oracle’s roadmap well before JSF 1.0 went final,

and the first early access release was presented on August 17, 2004. Its lead was Adam

Winer, who represented Oracle in the team that created JSF 1.0. ADF Faces primarily

contained a set of rich components, but also a dialog framework, and remarkably

already featured partial page rendering (PPR), quite a bit ahead of the later crop of AJAX

Chapter 1 history

solutions. ADF Faces also contained a “for each” tag (af:forEach) that actually worked.

Adam Winer explained in these early days that such tag is not quite trivial to build but

promised that Oracle would contribute the knowledge back to JSF itself.

The ADF Faces components originated mostly from the earlier User Interface XML

(UIX) framework, of which Adam Winer was the lead architect as well. Earlier versions

of UIX used the names “Cabo,” “Baja,” and “Marlin.” UIX was a rich client framework

for use in the browser. With JSF sharing more than a few similarities to UIX, and with its

lead, Adam Winer, being part of the original JSF team, it’s perhaps not unreasonable to

surmise that UIX influenced JSF.Such similarities include the concept of components

with separate renderers, JSP tag handlers and declarative options to compose a page,

and the ability to instantiate those same components programmatically in Java. There

was even a conceptually similar data binding, although with a less elegant syntax.

Instead of, say, value="#{user.age}", UIX would use data:value="age@user" but also

required a kind of producer to be defined on each page to declare where “user” comes

from, and then nest the page’s content within that declaration. By contrast, JSF and EL

have always used global definitions and left it up to the user to avoid name clashes.

One of the first, if not the first open source component library in 2004 was

Matthias Unverzagt’s OurFaces. As JSF did not had its own resource API (application

programming interface) at the time to serve up things like images, OurFaces required a

Servlet to be added to web.xml, the so-called SkinServlet (ourfaces.common.webapp.

SkinServlet). The significance of this is that it became a rather common thing for JSF

libraries in those days to ask their users: add something manually to web.xml before the

component library can be used.

Most of the last months of 2004 and early months of 2005 were spent by the

JSF 1.2 expert group (EG) working on various JSP and EL issues, such as the JSTL

<c:forEach> support and the generation of IDs in JSP, as well as on the dreaded “content

interweaving” issue, which refers to the aforementioned content that appears at wrong

places in the response when rendering.

While OurFaces may have been one of the first component libraries, it didn’t last

and few will remember it or have even heard about it today. This is not quite the same

for another framework that has its roots in early 2005, namely, Alexander Smirnov’s

Telamon framework, later renamed Ajax4jsf. This framework was one of the first of its

kind that combined JSF and the then new and fresh AJAX technology. The beauty of

Ajax4Jsf was that it could add AJAX support to existing components, which weren’t built

with AJAX support in mind at all by enclosing them among others in the <a4j:region>

Chapter 1 history

tag. This technology was incorporated in the Exadel Visual Component Platform, which

was released in March 2006 and would later be renamed RichFaces, and would become

one of the most memorable JSF component libraries.

At around the same time Alexander Smirnov started work on what eventually would

become RichFaces, a company called ICEsoft started working on a JSF component

library. ICEsoft had been in business for a couple of years and had been working on

a product called ICEbrowser, a Java-based browser, and a product called ICEbrowser

beans, which were “lightweight, configurable Javabean components that can be rapidly

integrated into Java client applications.” During JavaOne 2005 of that year, on 27 June,

ICEsoft announced their its component library for JSF—ICEfaces. This was based

on AJAX as well but incorporated AJAX directly into the components. ICEsoft called

its specific technique “patent pending Direct-to-DOM™,” which basically meant that

changes coming from the server were directly injected into the DOM tree structure of a

web page. A final version wasn’t available right away though, but an early access release

was provided. This was closed source but cost-free.

Meanwhile, JSF EG member Jacob Hookom, inspired by Hans Bergsten’s concerns

about the unsuitability of JSP, grabbed the bull by the horns and started working himself

on that alternative templating language envisioned by Bergsten. In August 2005 this

work had progressed into a usable initial version. The name of this templating language?

Facelets! It immediately took the JSF world by storm. Kito Mann published the first part

of a series of articles about it on JSFCentral the very first month, and Richard Hightower

published the famous article “Facelets fits JSF like a glove” several months later.

Oracle had not been sitting still either in 2005, and after about 16(!) early access releases

it announced in late 2005 at the JavaPolis conference in Antwerpen (nowadays called

Devoxx) that ADF Faces would be donated to MyFaces and thus become open source.

In the first month of 2006, Jacob Hookom and Adam Winer contemplated the terrible

implementation of JSF’s state save mechanism. This worked by first creating a component

tree from a template and then, near the end of the request, blindly serializing the entire

tree with all data that may have been put there during the request. During a postback the

tree is restored from this serialized form (hence the name of the phase “restore view”).

This is a tremendous waste, as the majority of this information is already available in the

template. Especially when doing AJAX requests with client-side state saving this poses

a very big burden, but it is also a problem when storing this state on the server as it

massively increases JSF’s memory usage. One of the main reasons for doing state saving

in such terrible way again has to do with that one decision: to support JSP.With JSF 1.2

about to go final, there was unfortunately no time left to fix this for version 1.2.

Chapter 1 history

Even though it was clear at this point that Facelets was the future of JSF, when

JSF1.2 was eventually released in May 2006 it still contained only JSP.Not all was bad

though. Thanks to a cooperation between the JSF and JSP EGs, a revision of JSP was

released, JSP 2.1, which was much better aligned with the demands of JSF.On top of

that, JSP’s expression language and JSF’s expression language were merged. The result

was UEL (Unified Expression Language). A very practical advantage of UEL is that JSF

components no longer have to convert Strings manually into expressions but directly

receive a ValueExpression from the templating language. Both JSP 2.1 and JSF 1.2

became part of Java EE 5, which was released at the same time.

On June 13, 2006, the MyFaces community announced that the donated project

would have its name changed to Trinidad. ADF Faces kept existing at Oracle, though,

but was based on Trinidad with some extra features (such as support for Portals, JSR 227,

etc.). Just two weeks prior to that, on May 31, 2006, ICEsoft announced its free, although

still closed source, community edition. A few months later, on November 14, 2006,

ICEsoft would fully open source ICEfaces under the MPL license. RichFaces, still closed

source at that point and being sold by Exadel, would not stay behind for long though,

and some four months later, on March 29, 2007, Exadel announced a partnership with

Red Hat that made RichFaces available under an open source license and available and

supported via its JBoss group.

On toMaturity

On May 22, 2007, the specification work for JSF 2.0 began. The scope was hugely

ambitious and promised not only to fix many of the issues that people had been

complaining about but also to introduce quite a bunch of new features. Mentioned

among the many goals in the JSR was a particularly interesting one when looking at the

bigger picture—extracting the managed bean facility from JSF and making it available for

the entire platform.

During the fall of 2007 the community was polled for a name for the JSF RI.Four

names rose to the top, but as is often the case none of these names could be approved by

Sun’s legal department. Eventually Mojarra was proposed, and perhaps to the surprise

of some this one did pass legal’s scrutiny. Ryan Lubke, one of the main JSF committers

then, made the official announcement on December 5, 2007.

A little under a year later, on October 29, 2008, Çağatay Çivici started a new library,

PrimeFaces. The name derives from Çağatay’s nickname, which is Optimus Prime, the

Chapter 1 history

剩余515页未读，继续阅读

WindStand

粉丝: 35
资源: 367

Java EE 8中的JSF指南：迈向WebSocket与CDI新时代

The Definitive Guide to JSF in Java EE 8 Building Web Applications with epub

the definitive guide to arm cortex-m0 and cortex-m0+ processors (2nd edition

hadoop the definitive guide epub

帮我找到一本书《Ethernet. The Definitive Guide》

the definitive guide to dax (2nd edition).pdf

java performance: the definitive guide by scott oaks

automotive ethernet: the definitive guide 2nd edition

802.11 wireless networks: the definitive guide

automotive ethernet – the definitive guide.42章

大数据软件技术的参考文献

请列出所有对于初学java的书籍

关于java的外语文献_java英文参考文献（涵盖3年最新120个）

近3年的Java参考文献

有关java的参考文献时间在2019年之后五条

java近几年英文文献,Java演进英文文献和中文翻译

Describe the execution of the JMP instruction if R3 contains x369C (refer to Example 4.5). (6 points)

sql数据库设计参考文献

取消work guide

javaweb html网页制作实习参考文献

hadoop.the.definitive.guide.4th.edition.1491901632

最新资源