View source for Software:Jspx-bay

{{Infobox software
| name                   = jspx
| logo                   = Jspx.png
| screenshot             =
| caption                =
| latest release version = 2.1
| latest release date    = {{Release date|2015|12|23}}
| operating system       = Cross-platform
| programming language   = [[Java (programming language)|Java]]
| genre                  = Web application framework
| license                = [[Software:Apache License|Apache License]] 2.0  [[Software:WTFPL|WTFPL]] [[File:WTFPL badge.svg|frameless|right|88px|WTFPL badge]]
| website                = {{url|http://www.jspx-bay.sourceforge.net}}<br/>{{url|http://www.jspx.sourceforge.net}}
}}

'''jspx-bay''', commonly referred to as '''jspx''', is a free open source pure Java web [[Rapid application development|RAD]] framework. Jspx should not be confused with other technologies using the same name like [[Software:Oracle Application Framework|Oracle Application Framework]] and XML [[JavaServer Pages|JSP]].

Jspx extends Java EE servlets to provide an Object-oriented programming model for HTML declarative code. Jspx can be compared to [[Software:JavaServer Faces|JSF]] as a web framework. There are many other Java Web frameworks like [[Software:Apache Wicket|Apache Wicket]] that implement such ideas.

==History==

[[Image:Jspx icon.gif|thumb|100px]]
Jspx development initially started in February 2008 as a trial to provide an easier way to develop rich interactive web applications in Java. In July 2008, jspx was introduced to the Java community through [[Java.net|java.net]]. Initially jspx had very limited features, including support for web form based development only.

In December 2008, the project moved to [[Software:SourceForge|SourceForge]],<ref>[http://jspx-bay.sourceforge.net http://jspx-bay.sourceforge.net]</ref> where it has been hosted since.

==The Name==
The name was chosen to indicate the next step of JSP technology, despite the fact that jspx is significantly different from JSP in that it does not directly embed Java code in HTML. The suffix '''X''' is analogous to [[Software:ASP.NET|ASP.NET]] pages, which have the extension aspx. The official jspx framework name on SourceForge is jspx-bay. The suffix '''bay''' distinguished the framework from an earlier inactive SourceForge project named jspx.<ref>{{cite web|url =http://jspx-press.blogspot.com/2009/09/jspx-bay.html|title = Jspx Bay Name}}</ref>

On 16 November 2009, the jspx project on SourceForge was purged, and it provides the same content as jspx-bay.<ref>{{cite web|url =http://sourceforge.net/projects/jspx/|title = Jspx Name on SourceForge}}</ref>

==Framework Target==
Jspx aims at providing easy to use, developer-friendly APIs. Based on the idea that [[Web development|web development]] is mostly about customizing the HTML that is presented based on user-input, jspx offers an object-oriented '''view layer''' interface to HTML. Jspx provides a means of implementing a stateful user interface over a stateless protocol ([[HTTP]]). [[Software:JavaServer Faces|JSF]] provides similar functionality, but requires that developers learn an entire new set of tags.

==Design Goals==

[[File:Jsxp arch.png|thumb|400px]]
Jspx is relatively new, and combines many features and advantages from existing frameworks while eliminating what might be considered disadvantages. Jspx had the following design goals:<ref>{{cite web|url =http://jspx-bay.sourceforge.net/index.html?l=pages/tout/design.html|title = Jspx Design Aspects}}</ref>

# Business case Driven Framework  <br /><small>''Remove [[Boilerplate code|boilerplate code]] and tasks.''</small>
# Zero configuration <br />	<small>''Unlike JSF, does not require any external configuration.''</small>
# Declarative and Imperative code <br /> <small>''Attributes declared in HTML are accessible by fully object-oriented APIs. ''</small>
# Optional and Default Implementation<br /> <small>''No need to specify the value of every feature, because they have reasonable default values.''</small>
# Integration with other frameworks <br /> <small>''Import existing jsp files into jspx HTML pages.''</small>
# Portable framework <br /> <small>''Run on almost every Application Server without extra effort.''</small>

==Comparison with Other Frameworks==

===ASP.NET===
Jspx has the following similarities with ASP.NET:
# Webform-based framework.
# Page life cycle and events.
# Page Templates through Master/Content pages.

Jspx is different from ASP.NET in the following ways:
# Jspx does not require a particular extension for the html file (i.e. aspx).
# Jspx uses standard HTML tags.
# Jspx provides many extra features (such as Jspx Beans for View-Controller binding).

===JSF===
Jspx is similar to JSF in the following ways:
# The same goal of providing an object-oriented interface to HTML.
# Bean Binding.
# Binding to Page properties.

Jspx differs from JSF in the following ways:
# Uses standard HTML tags.
# Does not rely on any external configuration.
# Full control of the page life cycle.

Jspx can be also compared to many other frameworks, such as [[Software:Apache Wicket|Apache Wicket]], but jspx uses HTML tags and attributes without an additional XML namespace.

==Web Development Using Jspx==
As Jspx is a webform-based framework, for each business case there is one development unit. A development unit in a jspx application consists of two parts:<ref>{{cite web|url =http://jspx-bay.sourceforge.net/index.html?l=pages/tout/helloweb.html|title = Jspx Hello Web}}</ref>
# Declarative HTML code (myPage.htm)
# Imperative Java code (MyPageController.java)
In addition, the '''web.xml''' file must direct traffic to jspx main servlet controller (RequestHandler).

==Example==
A '''hello world''' example can be implemented in many different ways. The following example demonstrates one of them.

;web.xml
<source lang="xml">
<?xml version="#0" encoding="UTF-8"?>

<web-app xmlns:xsi="http://www.w#org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee"
 xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_#xsd"
 xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_#xsd"
 id="WebApp_ID" version="#5">
  <display-name>jspx-demo</display-name>
	<servlet>
	    <servlet-name>JspxHandler</servlet-name>
	    <servlet-class>eg.java.net.web.jspx.engine.RequestHandler</servlet-class>
        </servlet>
	<servlet>
	    <servlet-name>ResourceHandler</servlet-name>
	    <servlet-class>eg.java.net.web.jspx.engine.ResourceHandler</servlet-class>
	</servlet>
	<servlet-mapping>
	    <servlet-name>JspxHandler</servlet-name>
	    <url-pattern>*.html</url-pattern>
	</servlet-mapping>
	<servlet-mapping>
	    <servlet-name>ResourceHandler</servlet-name>
	    <url-pattern>/jspxEmbededResources/*</url-pattern>
	</servlet-mapping>
</web-app>
</source>

;HelloWorld.html
<source lang="xml">
<page controller="HelloWorld">
    <html>
	 <body>
    	     <label id="message" />
	 </body>
    </html>
</page>
</source>

;HelloWorld.java
<source lang="java">
import eg.java.net.web.jspx.ui.controls.html.elements.Label;
public class HelloWorld extends Page
{
	Label message;

	protected void pageLoaded()
	{
		if (!isPostBack)
			message.setValue("Hello Jspx World");
	}

	public void setMessage(Label message)
	{
		this.message = message;
	}

	public Label getMessage()
	{
		return message;
	}
}
</source>

Note the following about the example above:
# The only configurations required are to register two servlets of jspx; one for the normal requests on the pages, and the second for embedded resources (such as JavaScript and images).
# The HTML must be contained within a root element {{code|<page>}}, and must be well-formed XHTML.
# The Java code must extend the root Page controller from the jspx page.
# The page has life cycle phases as with ASP.NET, with similar names like '''pageLoaded'''
# The HTML page should point to the Java controller class through the '''controller''' attribute of the {{code|<page>}} element.
# In the Java controller, in case it is needed to interact with an HTML control, a control of the same type should be declared as a java property with getter and setter, and the property name should be the same as the value of the attribute ID in the HTML control.

For the note number 6, the framework is considering using of Dependency Injection to eliminate such limitation and any coupling of HTML and java code.

==Dependency Injection==
Jspx build 1.0.9 provided new way of linking HTML controls to Java controls in the page controller. The above example showed the need to add getter and setter for each control. This methodology created the following cons:
# Developer has to type a lot of code to link HTML control to Java control.
# The Page controller is getting very crowded with irrelevant code.
# Coupling between the HTML control and Java Control; as the link is created only if the Java control name is the same as the value of the attribute id in the HTML control.
# Any change in the HTML requires changing the getter and setter in the page Java controller.

For all these reasons build 1.0.9 is using Java Annotation to link Java objects to HTML. The following example is an alternative to the above one.

<source lang="java">
import eg.java.net.web.jspx.ui.controls.html.elements.Label;
public class HelloWorld extends Page
{
	@JspxWebControl(name="message")
	Label msg;
	protected void pageLoaded()
	{
		if (!isPostBack)
			msg.setValue("Hello Jspx World");
	}
}
</source>

As noted the size of the code is very much reduced. Also it is noted that the annotation @JspxWebControl is using an attribute ''name'' which is an optional attribute. The value of this attribute should be the same as the id of the HTML control. This technique removes the coupling between HTML and Java code.<ref>{{cite web|url = http://jspx-press.blogspot.com/2009/10/jspx-dependency-injection.html|title = jspx dependency injection}}</ref>

Some consider this new feature an insignificant addition to the framework. They use the JspxBean to link the HTML form to Java Model Object, and do not declare server side controls linked to the HTML controls.

JspxBean in build 1.0.9 also has been improved, there is no need to create getter and setter for every JspxBean. Forgetting to add getter and setter was a very common mistake causing the developer to loose the link with the HTML. Dependency Injection is used to inject the JspxBeans without the need for getters and setters.

==Expression Language Support==
Jspx does not allow Java code inside HTML page. However, in order to satisfy the need of injecting data from the controller; Jspx fully supports [[Unified Expression Language|Expression Language]].

Some examples on EL as following:
* '''${this.customerName}'''. The keyword ''this'' refers to the current instant of the page controller. ''customerName'' is the name of the Java property in the controller class. The property should have a getter method as  <source lang="java">public String getCustomerName()</source>
* '''${request.parameters.id}'''. The keyword ''request'' refers to the HTTP Servlet Request. ''parameters'' refers to the Request parameters. ''id'' refers to the parameter name. HTTP Servlet Request attributes can be also accessed as ''${request.attributes.id}''.
* '''${session.id}'''.The keyword ''session'' is used to access parameters in the HTTP Servlet Session.
* '''${var.age}'''. In Data Item Controls like DataTable and List Table, custom rendering of Data Column can be done by using ItemTemplate. in order to access the current Database record a variable should be declared in the DataTable with name ''var'' for example. Then inside the ItemTemplate the values inside the ''var'' variable can be accessed as shown in the EL.
* '''${size(this.username)}''' JEXL provides static methods to be invoked .
* '''${user.age>21?'You are OK':'You are minor'}''' ''user'' must be a jspx-bean defined in the Page controller and the expression is checking on the value of the age (member property of the user bean).

==Limitations and Disadvantages==
Any framework is evaluated according to different criteria aspects,  the following which jspx needs more improvements.
# '''IDE support'''. Jspx can be developed using any IDE, however there is no direct support for jspx. Developer has to write the event handling manually.
# '''Documentation'''. Tutorials and examples are found on the official website. There is a section on the website for documentation, however not sufficient.
# '''EL Support'''. Jspx did not fully support EL language until version 2.0, JEXL is used starting from jspx version 2.0 to fully support EL.

==Features==
Jspx offers some powerful features like:
# Native support for Ajax through AjaxPanel<ref>{{cite web|url =http://jspx-bay.sourceforge.net/index.html?l=pages/tout/ajax.html|title = Jspx Ajax}}</ref><ref>{{cite web|url =http://jspx-press.blogspot.com/2009/09/ajax-in-jspx.html|title =  Ajax in Jspx}}</ref><ref>{{cite web|url =http://jspx-press.blogspot.com/2009/09/ajax-panel-limitations.html|title = Jspx AjaxPanel Limitation}}</ref>
# Data Controls like DataTable and ListTable.
# Integration with [[Java Authentication and Authorization Service|JAAS]] and adding more features.<ref>{{cite web|url = http://jspx-press.blogspot.com/2009/09/jaas-on-web-control-level.html|title = JAAS on the webcontrol level}}.</ref>
# Data Binding through JspxBean.
# HTML Template through Master/Content Pages.
# Client/Server side validation.<ref>{{cite web|url = http://jspx-bay.sourceforge.net/index.html?l=pages/jspx/features.html|title = jspx features}}</ref>
# Embedded JQuery, JQuery UI, Bootstrap style and many other open source libraries inside.
# Embedded JEXL to support EL expressions.

==External Jar Dependency==
Jspx tries to minimize external jar dependencies, however there are some essential jars:
<ref>{{cite web|url =http://jspx-bay.sourceforge.net/pages/tout/start.html|title =  jspx jar dependency}}</ref>
# commons-fileupload-1.2.1.jar (when using File Upload)
# slf4j-api-1.7.2.jar (Mandatory for logging)
# poi-3.1-FINAL-20080629.jar (when using Export To Excel)
# servlet-api.jar (only during compilation)
# commons-io-1.3.2.jar (when using File Upload)
# commons-jexl-2.1.1.jar 
# jcl-over-slf4j-1.7.5.jar slf4j bridge for Commons logging (As JEXL is using it)

==JDC 2010==
Jspx had made its first public appearance at Java Developer Conference 2010 (JDC). Java Developer Conference is the largest Java event in [[Finance:MENA|MENA]], organized by EGJUG.<ref>{{cite web|url = http://jdc2010.egjug.org/node/24|title = jspx in JDC 2010|url-status = dead|archive-url = https://web.archive.org/web/20100210231924/http://jdc2010.egjug.org/node/24|archive-date = 2010-02-10}}</ref>

==Jspx Demo Projects==

[[File:Jspx1.1.0.demoapp.png|thumb|200px]]
Jspx distribution package includes several files beside the binary jar and the source code. Since the first release on SourceForge the distribution included a demo project as a binary war file and a zipped source code. That project was a simple discrete pages showing different features of Jspx. There was no common business module wrapping these pages, beside it had a poor GUI design. Jspx build 1.1.0 add new demo project that facilitates the easy use of jspx to develop common business case of interacting with DB. The demo is using [[Software:MySQL|MySQL]]. Sql script file is separately downloadable.

Some of jspx features are used like Master/Content pages, Ajax, DataTable, Validators and web forms.

With Jspx 1.2 there were two new demo projects added. One offline Demo was jspx-demo3, that is demonstrating the use of jspx to create simple asset tracking application. The other demo was an online jspx live demo.

==See also==
*Tapestry
*[[Software:Apache Wicket|Wicket]]

==References==
<references />

==External links==
*[http://www.jspx-bay.sourceforge.net jspx project website]
*[https://jspx.dev.java.net jspx.dev.java.net]{{dead link|date=April 2017 |bot=InternetArchiveBot |fix-attempted=yes }}

{{Application frameworks}}

[[Category:Java enterprise platform]]
[[Category:Free software programmed in Java (programming language)]]
[[Category:Web frameworks]]

{{Sourceattribution|Jspx-bay|1}}