EasyWeb4J Blog

Annotated Dynamic Titles

2010-02-05T21:54:00.000+05:30

Web applications usually have two parts in their title. One indicating the current page and the other describing the entire application. It would be nice to put the application wide title and parameterize the page level title within your applications' layout. Starting from 0.5, EasyWeb4J allows you to annotate your action methods with custom annotation and access them easily within any part of your controller.

This sample application would have two pages with titles "Home - Dynamic Title Demo" and "Admin - Dynamic Title Demo". Here, "Home" and "Admin" are specific to the particular page while the rest of the title is common to the entire application.

Download the complete source code for this application.

Layout and Controller

The layout specifies the application wide title as template text and uses an EL expression to include the page specific title before it. It also provides the navigation links for the 2 pages.

src/main/webapp/WEB-INF/layouts/Application.jsp

The controller has 2 actions corresponding to the application's pages.

src/main/java/org/title/controllers/HomeController.java

Making it Work

Let's create a custom annotation specific to this application which will be used on the action methods to specify the page specific title

src/main/java/org/title/annotations/Title.java

Next, we must override the filterRequest() method to make use of the Title annotation when available on action methods. EasyWeb4J 0.5 and above provide the getActionAnnotation() method, which can be used in our filter to access the annotations on the current request's action method.

We then annotate our action methods with @Title("Home") and @Title("Admin") to specify their titles as shown below.

src/main/java/org/title/controllers/HomeController.java

In a real-world application the filter can be moved to an abstract super class to setup the appropriate titles for actions across all controllers.

EasyWeb4J 0.5 Released

2010-01-27T12:21:00.001+05:30

We're proud to announce the release of EasyWeb4J 0.5. This release includes several important changes to further simplify development of web applications using EasyWeb4J.

Components of the request URL after the action name are passed to the action method as parameters. These are also converted to the appropriate basic type of the parameters. getIntegerId(), getLongId(), getStringId(), etc. need not be used any more. See the "Parameters in Action Methods" section of this tutorial page.
You can define and use application-specific custom annotations on action methods. These annotations can be obtained within your controller using the getActionAnnotation() and getActionAnnotations() methods. This can be very handy to do things like action specific authorization and for setting up action specific request attributes like title, stylesheet, etc.
A ResponseHandler interface is provided which can be used to generate raw responses cleanly within the view rendering transaction. See the "Generating Raw Response" section of this tutorial page. Closures should hopefully allow a lot cleaner syntax for this when Java 7 is out.
Attributes of your application's ServletContext can be injected into your controllers' fields using @ContextAttribute annotation.
Model class provides validateRequired() methods which can be used to validate presence of value in fields.
Starting from this release EasyWeb4J will be available from its own maven repository and hence need not be installed to maven manually.
The hbm2ddl.auto hibernate property is set to update when a new project is created to simplify initial development. You might want to disable this before taking your application to production.

Contributing to EasyWeb4J also got simpler as the source repository has been moved to GitHub. :)

If that caught your attention, get yourself started with the tutorial and hit the mailing list for any further assistance.

Simple Authentication and Authorization with EasyWeb4J

2009-12-01T18:40:00.000+05:30

This post demonstrates the implementation of a simple password based Authentication and Authorization system built with EasyWeb4J. This post will demonstrate the hashing API of EasyWeb4J (including salt generation) and put to use EasyWeb4J's simplified request filtering for authorization.

When a user signs up his password is combined with a random salt of 10 bytes. This is then hashed using MD5 algorithm. The salt and the password hash are stored. During login the user is retrieved by his username and the entered password is hashed and compared against the original hash.

Download the complete source code for this application.

Create a new EasyWeb4J Hibernate Project as described in the tutorial. Configure hibernate as shown below.

src/main/resources/hibernate.xml

The Model

src/main/java/net/auth/models/User.java

The encryptPassword method generates a random salt and encrypts the clear text password using MD5 algorithm and the salt, using EasyWeb4J's hashing API. The matchesPassword method takes a clear text password input by the user, hashes it using the previously generated salt and compares it with the original hashed password.

The Controllers

This sample application has three controllers.

UsersController - Handles user signup.
SessionsController - Handles login and logout.
HomeController - The actual application which needs to be secured by requiring login.

src/main/java/net/auth/controllers/UsersController.java

Not much magic there. Just a standard controller to create a user after encrypting the entered password.

Authentication

src/main/java/net/auth/controllers/SessionsController.java

This controller authenticates a user from login screen and redirects them to the secure home page after storing the user ID in session. If login fails, it redirects to the login page back after setting a message in flash. Also, while displaying the login page it checks whether the user has already logged in and if so directly redirects them to home page without requesting credentials.

Authorization

While there is only one controller in this example whose requests need to be secured, in real applications there would be several. Hence we create an abstract controller which will override the filterRequest() method to perform authorization during each request.

src/main/java/net/auth/controllers/SecureController.java

It verifies whether a user is currently logged in and if so, sets the real user as a request attribute. This would be used to greet the user by his full name.

Finally we have the home controller which in this sample does nothing other than rendering the index view.

src/main/java/net/auth/controllers/HomeController.java

There we have a complete DB based login system. :)

EasyWeb4J 0.3 is Out with Support for Cleaner URLs

2009-11-30T16:58:00.001+05:30

After quite a long time of silence, EasyWeb4J 0.3 has been released. Some of the major changes in this release include,

The "/dispatcher" part is dropped from the URLs as EasyWeb4J now uses a filter instead of a servlet for dispatching requests.
An improved API for hashing with support for easy salt generation.
Unified handling of both muti-database and single-database projects.
A significantly improved code architecture.

This release breaks compatibility with 0.2 in few minor ways.

/src/main/resources/repositories.properties must be present even for single-database projects. This file would be auto-generated when creating new projects.
The "dispatcherRoot" attribute is not set anymore as it does not exist.

All previous samples in this blog have been updated to use the new version. Grab it and enjoy web development with Java!

EasyWeb4J 0.2 Supports Multiple Databases and Simplifies Validations

2009-08-22T14:41:00.001+05:30

We're proud to announce the release of EasyWeb4J 0.2. This release focussed on supporting multiple databases within a single application and also simplifies validations in models.

Some of the significant changes in this release include,

Repository management code is re-designed to simplify support for multiple databases and to support more persistence mechanisms.
Support for multiple DBs has been added to Hibernate and JPA repositories.
There is just one validate method to perform all validations.
Validation of basic types are handled automatically.
This release also creates projects with a default message bundle to facilitate internationalization.

This release breaks compatibility with 0.1. The tutorial and all previous posts in this blog have been updated for the new version.

Download the new release and give the tutorial a shot. We're sure you'd love it. :)

Porting Rails Shoutbox to EasyWeb4J

2009-07-31T22:32:00.000+05:30

It is a widely held belief that Java unnecessarily penalizes simple web applications. This post demonstrates that by using EasyWeb4J, you can "almost" achieve the productivity of Rails without missing Java's raw performance.

This tutorial is inspired by this article on Nettuts+. I have included the stylesheets and images from Dan's post to retain the look and feel of the final result.

Download the complete source code for this application.

Create a new EasyWeb4J Hibernate Project as described in the tutorial, with settings as shown below.

MySQL Setup

Run this script to create a database for shoutbox
Edit your pom.xml and add a dependency for MySQL JDBC driver as below.
Point Hibernate to the newly created database as below.

src/main/resources/hibernate.xml

Model

The model specifies the validations for each shout and also generates an MD5 hash of the email used in the shout.

src/main/java/org/shoutbox/models/Shout.java

Repository

Unlike Rails EasyWeb4J uses repositories to load models from database. However, for this simple app, the repository can be an empty class.

src/main/java/org/shoutbox/repositories/ShoutRepository.java

Controller

We create a separate method to load all available shouts as it is needed both in the home action and if an error occurs during shout creation. Edit web.xml and specify Shouts as the ROOT_CONTROLLER.

src/main/java/org/shoutbox/controllers/ShoutsController.java

Layout

Just like Rails, EasyWeb4J also supports layouts. To know more on EasyWeb4J layouts, see this post. We specify the top level elements and include the stylesheet in our layout.

src/main/webapp/WEB-INF/layouts/Application.jsp

View

EasyWeb4J applications use JSTL to loop through elements and errors to be displayed to the user.

src/main/webapp/WEB-INF/views/Shouts/index.jsp

Where EasyWeb4J differs from Rails?

EasyWeb4J uses the Respository pattern (through Hibernate/JPA) instead of ActiveRecord for persistence.
EasyWeb4J does not provide migrations as DDLs need to be optimized anyway in any non-trivial application.
EasyWeb4J needs a bit of XML for config (but way less than many other Java frameworks).
EasyWeb4J allows you to use standard HTML for forms fields and for referencing stylesheets by offering few convenient request parameters.
And yeah, EasyWeb4J app would run way faster than the Rails version. ;)

Highlighting and Placing Focus on Errors in EasyWeb4J

2009-07-30T22:24:00.000+05:30

Highlighting fields with input errors is a common technique used in web applications to gain users attention to the errors. It is also helpful to place the focus on the first field with error so that the user can start correcting the input right away.

This can be implemented in an EasyWeb4J applciation by checking for the presence of error on the field of your model, represented by the input field. If an error is present, use a different CSS class for the input field which does the highlighting. To place the focus on the first field with error, you can use jQuery to select the first field with the CSS class representing errors. The completed application would look like this.

Download the complete source code for this application.

Create a new EasyWeb4J Hibernate Project as described in the tutorial. Since we do not need a database for this demo, delete src/main/resources/repositories.properties from the newly created project.

The Model

src/main/java/org/error/models/Person.java

The View

src/main/webapp/WEB-INF/views/Person/index.jsp

The view uses EL expression to determine whether an error is present on the field represented by each input. If present, it sets the CSS class of the input element to errorField.

The Javascript

src/main/webapp/js/script.js

The script places the focus on the first field with error. If none of the fields have an error in input, it places the focus on the first input field.

AJAX with jQuery and EasyWeb4J

2009-07-27T23:50:00.000+05:30

All modern web applications use AJAX to communicate asynchronously with the web server. EasyWbe4J does not include any tag library for AJAX support. Instead it allows you to use any JavaScript library to communicate with your application and perform AJAX operations. One of the benefits of this approach to AJAX is that it allows the developers to use Unobtrusive JavaScript.

We'd be using jQuery along with EasyWeb4J to build a simple adder which adds two numbers on the server and provides the sum in the response. The completed application would look like this.

Download the complete source code for this application.

The primary difference between the response for a normal request and an AJAX request is that, the response for the AJAX response does not contain the layout components of the page. It would send only the content which needs to be updated in the browser by JavaScript.

Create a new EasyWeb4J Hibernate Project as described in the tutorial. Since we do not need a database for this demo, delete src/main/resources/repositories.properties from the newly created project.

The JavaScript

/src/main/webapp/js/script.js

The Layout File

src/main/webapp/WEB-INF/layouts/Application.jsp

It is important to notice how we pass the context's root path to our script which would use it to post the input to the "add" action. We create a global variable named "contextRoot" just before including our script. The script can use this variable to post the request to our action.

The Model

src/main/java/org/ajax/models/Adder.java

The Controller

src/main/java/org/ajax/controllers/HomeController.java

The add action in our controller renders its default view (add.jsp) without the layout using the renderWithoutLayout() method.

Home View

src/main/webapp/WEB-INF/views/Home/index.jsp

AJAX Response View

src/main/webapp/WEB-INF/views/Home/add.jsp

DRY Views with Nested Templates in EasyWeb4J

2009-07-20T23:26:00.000+05:30

The content of pages in any web application will be composed of three parts.

The elements common across all pages (header, main navigation and footer).
The elements common to specific group of pages (sidebar).
The actual content of the page.

At first glance, it may appear that EasyWeb4J does not support nested layout components as there is only one layout file (Application.jsp). However, since it is a plain JSP page, you can do anything you do with plain old JSP pages in it.

This post, demonstrates how filters of EasyWeb4J can be used along with the EasyWeb4J's templating system to achieve nested layouts. There are two controllers (Products & Services) in this application each with their own sidebar links.

The completed application would look like this

Download the complete source code for this application.

The trick to create nested layout components, is using the filter to setup a request attribute, which will provide the nested layout page. This can then be used within Application.jsp to include the nested layout page. By using a filter you do not have to do this in each action within the controller. Thus both our controllers and views would be DRY.

Create a new EasyWeb4J Hibernate Project as described in the tutorial. Since we do not need a database for this demo, delete src/main/resources/repositories.properties from the newly created project.

The Master Layout

src/main/webapp/WEB-INF/layouts/Application.jsp

As it is seen here, the master layout specifies the header, main vaigation and the copyright notice. It then includes the sidebar specific to the controller and the actual view of the action invoked during the request.

The Sidebars

src/main/webapp/WEB-INF/layouts/ProductsBar.jsp

src/main/webapp/WEB-INF/layouts/ServicesBar.jsp

Filters in Controllers

src/main/java/org/layout/controllers/ProductsController.java

src/main/java/org/layout/controllers/ServicesController.java

The filters in the controllers setup the request attribute ("sidebar") with the appropriate page containing the sidebar for the actions of this controller. The filters may also provide different sidebars for groups of actions if needed, by determining which action has been invoked using the getActionInvoked() method.

If your application needs to have the view of the action within the nested layout page, move the include for ${view}, from Application.jsp to your nested layout page.

Template out as much of your views as possible and DRY them up.

Handling File Uploads with EasyWeb4J

2009-07-18T16:43:00.000+05:30

Most web applications require handling upload of files. A good example of this is an online shopping application which displays an icon for every product available for online purchase.

EasyWeb4J makes handling file uploads in Java web applications really simple. We'd be building a sample application in this post to demonstrate how it can be done.

Every product has a name and a description.
An icon is associated with every product.
The home page lists the icon, name and the description of all the products currently available.

The completed application would look like this

Download the complete source code for this application.

Create a new EasyWeb4J Hibernate Project as described in the tutorial.

MySQL Script

Edit the newly created project's hibernate.xml and update the DB connection information.

Model

src/main/java/org/upload/models/Product.java

Repository

src/main/java/org/upload/repositories/ProductRepository.java

Add Product View

Unlike normal forms, the encoding of forms involving file fields must be "multipart/form-data".

src/main/webapp/WEB-INF/views/Products/add.jsp

Product List View

An interesting thing to note here is that, we use the URL of an action to retrieve the icon of the corresponding product by passing it the product's ID in each row.

src/main/webapp/WEB-INF/views/Products/index.jsp

Controller

src/main/java/org/upload/controllers/ProductsController.java

Some of the points to note in the controller's implementation are:

updateModel() does not process file fields even if they follow the object.property naming convention and hence need to be processed separately in controllers.
Controllers can directly send output to servlets' response and EasyWeb4J will not try to render a view if the action closes the response. This is exactly how the icon() action works.

As it can be seen, EasyWeb4J makes working with file uploads and streaming back uploaded files extremely simple. :)

EasyWeb4J-0.1 is Finally Out in the Wild

2009-07-17T22:23:00.000+05:30

After close to two months of development, EasyWeb4J 0.1 is stable enough to break away from BETA. :)

This release fixes a couple of bugs from the BETA release. Some of the benefits offered by EasyWeb4J over other Java web application stacks are:

Minimal XML configuration (needed only for Servlet and Hibernate/JPA configuration).
Out of the box support for pretty URLs.
Does not require using custom tags where standard HTML elements work just fine. So HTML from designers can be used directly with very little modification.
Simple and yet very effective layout system.
Handles transactions and lazy initializations without the developer having to worry about them.

Grab it, give the Tutorial a shot and re-discover fun in Java web development.

EasyWeb4J-0.1-ALPHA1 is Here

2009-06-27T16:22:00.000+05:30

EasyWeb4J's design is greatly influenced by RoR and integrates with Hibernate and JPA for ORM. It is an open-source project and licensed under, Apache License, Version 2.0.

Home Page: http://easyweb4j.sourceforge.net/

It is significantly simpler than many other Java web frameworks and includes a complete tutorial to get you started. Give it a shot and post your feedback on its design at the EasyWeb4J Developer Discussion forum.

If you like it, spread the word among your geekmates. :)