JSXP 0.2

JSXP is a simple, free and open source web framework for Kava. JSXPs main features are: Compile-time saftey when accessing elements of the HTML page,  simple XHTML used for the design, strict separation of code and design, human readable URLs, and much more.

Main features:
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 JSPs 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.
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.

System requirements:
- Java