JSXP is a simple, light-weight web framework for the Java programming language. It's features are:

Compile-time safety

In the controllers for your views, all elements of the views are accessed using generated get-Methods. This ensures that you can only refer to elements which really exist in the XHTML file. When an element is re-named or deleted, the java compiler immediately reports an error. This means you do not have to wait until your application is running to see if all the referenced elements still exist (this would be the case with other web frameworks for java: You get a runtime error).

Separation of code and design

The design of your views is simple XML code (XHTML for example). In this XML code you specify the elements you want to access in your controller using a special id-attribute from the JSXP namespace. You can also define Variables - the Generator will create set-Methods for them. All the programming is done in Java-source-files. There is no such thing like JSP's expression language, which adds more possibilites for runtime errors. Also there are no special xml elements like in Wicket, which can not be generated using HTML tools.

Simple XHTML design

JSXP allows your designer to create complete, fully functioning HTML pages. All the links can already refer the correct pages, and all the pages can contain mock-ups for navigation, header,... . This means the designs render nicely in the browser, and all the links are already clickable. Later you can programmatically apply view templates (which will remove all the mock-ups from your XHTML designs). This also means that you can work together with the designer on the same XHTML files, and all the changes made by the designer are directly reflected in your application.

Component-Orientation

JSXP supports creating components an composing your views from the components. There are powerful mechanisms for view-templating and element-templating. This allows us to have no special XML elements, only "server-side includes".

Human readable URLs

When the URL in your browser says "index.xhtml", you really see the index page in JSXP by default (of course this can be changed by the business logic of the index page, but this is discouraged). This even works in combination with redirects. This means that the URLs are not only bookmarkable by default, they are also human readable. Both things are rather difficult to achieve with other Java web frameworks.

Server side state

JSXP manages your server side state. There are several different scopes which can contain your data, and the contents of these scopes are managed automatically. You only have to annotate a get- or set- method to manage an object in one of the scopes. For example, the following code will put a String into the session scope:

@SessionScope
public String getSessionScopeString() {
	return sessionScopeString;
}
public void setSessionScopeString(String sessionScopeString) {
	this.sessionScopeString = sessionScopeString;
}

View Flows

View Flows are units of work which have one entry point view, and a defined set of result views. When the flow is not active, the user can not access a view in the middle of the flow, he will automatically be redirected to the entry point. When the user reaches one of the result views, the flow is "committed", when the user accesses any page outside of the flow it is "aborted".

Ajax Support

JSXP has built-in AJAX support and works well with other AJAX libraries, like JQuery or Prototype.

Internationalization / Resource Management

Both internationalization and resource-management are supported and easy to add to your web applications.