Welcome to BeanView!
Released October 15, 2006.
BeanView exists because I got tired of having to manually create forms for CRUD (create, retrieve, update, delete) operations. Specifically, this includes the create/update forms.
Certainly, there are some great drag-and-drop tools for creating forms. You can build forms via drag & drop in DreamWeaver, NetBeans, Java Studio Creator, or any other tool. You create a database table, and then you wire up every single form element, by hand. Drag-and-drop. Over and over and over. If you have, say, fifty tables, with an average of ten fields for each table, you are going to drag-and-drop roughly 1,500 form elements by hand (500 labels, 500 entry fields, and 500 error fields). That's tedious, boring, error-prone dragging-and-dropping.
If you aren't using a drag-and-drop tool, it's even worse.
So.
BeanView is intended to simplify this tremendously, generating the forms automatically from your Java code. It's based on the notion of intelligent defaults, maintaining a clear line between your views and your logic, annotations - and nary an XML configuration file to be found.
BeanView is intended to play very nicely with Hibernate 3.X and EJB 3.0. Conflicts between Hibernate 3.0/EJB 3.0 and BeanView will be considered bugs. Eventually, EJB 3.0 annotations will be respected by BeanView as well in certain areas (for example, if you specify a string to have a maximum length of 30 characters with an EJB 3.0 Persistence annonation, BeanView should be smart enough to respect that).
In technical terms, it relies on the default information obtained from reflection of the JavaBean to generate forms and update the beans from these forms - so, if you create a JavaBean with a method get/setFirstName(String in), BeanView will automatically generate the form. From there, a simple method can be called to get the current JavaBean value and/or update the form.
Supported features include:
The goal is to improve productivity from prototype to deployment when building web applications. At the early stage, a working app can be built from a JavaBean based model - the forms and display of your application can be updated by merely updating your code. As the funtionality is locked down, incremental changes to the system can be made in as painless a fashion as possible.
In addition to prototyping, BeanView can also ease validation. For example, if your model defines a property to be, say, an int, then the user must obviously enter an int in the text field. When BeanView gets a form, it will validate the entire form against both the properties and your validators (for example, a text field should be an email address, or a minimum of three characters but no more than six, or whatever). If there are errors, BeanView will automatically display the error next to the appropriate component[s].
BeanView is smart enough to help you deal custom object properties and array properties. For example, let's say that you have a class Cat that has a property motherCat. You can pass in an array of possible cats, and BeanView is smart enough to figure out which possible cat is your cat's current mother, and stitch the whole thing together into a popup. You could even have an array of childrenCats, with a multiselect.
Check out the screenshots to see it in action.
BeanView is available via one of two licenses. It may either be used under the terms of the LGPL -or- via a commercial license from Will Iverson or Will Iverson's assigns. For more information regarding the commercial license, feel free to contact Will Iverson.
Committers/contributors to BeanView will be required to sign an agreement similar to the Apache Individual Contributor License Agreement.
@author $Author: wiverson $
@version $Revision: 1.1.1.1 $, $Date: 2006/09/19 04:42:28 $