Java Studio Creator 2 Offers Across the Board Improvement
Regular readers of Developer.com will probably notice that I have written many articles for Java Studio Creator. It is a development tool that I keep coming back to, not just for articles, but for Web UI development at work and at home.
What is Java Studio Creator?
If you are already familiar with Creator, by all means skip ahead. However, it has been my experience that Creator is still one of the best kept secrets in Java—or worse, that what it does is misunderstood.
Java Studio Creator is a Rapid Application Development environment for constructing Web-based clients around existing databases, Web services, EJBs, or other Java class libraries. At least for the present, it concentrates on the construction of Web user interfaces, not Wwing or other interface options. It also is not intended for constructing class libraries, server, or middle-tier code, and so forth. It's not that these tasks cannot be undertaken in it, but that there is no inherent support for doing such development.
By concentrating on the task of Web UI client development, it provides an extremely streamlined and approachable IDE for beginners, and also a highly productive tool for experts who need to slap a Web-based UI together with a minimum of fuss.
Why is Java Studio Creator so important?
The Java development space is extremely well supported by development tools, so what makes Creator so important?
The thing is, there are lots of extremely good options for Java development running all the way up from creating apps and class libraries to full-on enterprise development with UML, and there are at least a dozen options that do exactly that—excellent tools that cover every conceivable level of development.
And you know what? Try putting a beginner down in front of one of these tools and telling them to write something.
The fact is these tools are excellent in the hands of an experienced developer who needs to do everything, but the beginner will be quickly overwhelmed. Java Studio Creator presents a manageable interface that has the functionality to carry out the task at hand without a developer getting lost in thousands of different options and views.
Also, by concentrating on just Web UI development, it is very good at it. Creator pushes a development approach used in the Microsoft development world for a very long time—that of component-based development. This is what made tools such as Delphi and VB so popular for client development.
Component-based development, and the graphical nature of the UI building environment, make for a very productive tool for experienced developers as well.
Of course, this means using a separate UI for client development than for the rest of the system, and again, in my opinion this is a win as well. Using separate tools means that architectural boundaries cannot be crossed, so the parts that are written to provide an API for the client portion of the application will, by necessity, be kept clean of UI concerns, whereas the UI portion of the application will similarly be kept clear of middle- and server-tier concerns.
The previous "standard" for Java Web UI development was Struts, and JSF is being positioned to take its place. Craig McClanahan, the creator of Struts, is now one of the driving forces behind JSF. JSF is supposed to fix many of the problems facing Struts development, and for the most part it does an admirable job, and Creator is based on JSF. Of course, it's not perfect, but as an architect I gave up looking for the perfect solution a long time ago. What I seek now is something that works with the developers and resources available to get a job done within the allotted time. For that, Creator is a good fit.
Okay, so Creator 1.0 was a great tool, a good start down the road to easier, faster component based development in Java. What does 2.0 offer that was missing in 1.0? Why is the update noteworthy?
Firstly, and most noticeably, there are the new components. 1.0 shipped with the components from the reference implementation (RI) of JSF. These were not bad components, but there were a few omissions of commonly desired components, and they were fairly basic requiring some CSS beautification in most cases.
The new 2.0 components are a far richer set. There are many more included components, and some welcome additions, such as a popup calendar, file upload, tree, and a fantastic new grid component with sortable columns, paging, and inline editing support.
There are also several composite components that provide some for some common tasks, such as alert messages, add and remove lists (the double pane selector style), and a breadcrumb trail. Previously components like this were only available by using Oracle's ADF Faces or MyFaces.
These components are also themable, and there are four included sample themes that make for a pleasant looking selection of UIs. At present, there is no easy way to create your own themes, but I believe there are plans to make some kind of theme editor available in time. At present, altering the themes means delving into CSS files.
EJBs and custom data providers
Another big improvement is in the handling of EJBs. Some of the beta features of 1.0 have fed into the new EJB data provider, which means that binding the results of EJB methods to components in 2.0 is now as easy (as in drag-and-drop easy) as it was to bind query results to components in Creator 1.0.
This means that, by using Creator 2.0, you can drag and drop your way to a front end for databases (through JDBC rowsets), Web Services (using the WSDL wizard), and now EJBs—or any combination of the three.
Of course, it is also pretty easy to bind in any kind of class library you want to use. (Just import the library and start using it to set the values of beans; or, if it happens to provide a set of bean properties, bind them directly.) However Creator 2.0 does not stop there. Now, it also is possible to define your own data providers for legacy systems, file formats—indeed, anything you can think of (or maybe ones that you have not thought of yet).
Creator 1.0 had a great feature, with a single but fairly large flaw. Validators could be attached to components to automatically check input values for various properties (length, format, and so forth). The flaw was that, when you submitted a page (in other words, clicked on a button or otherwise caused an event to fire), all validators for all input would be applied for the page and any failures would abort the submission and signal the error.
This meant that you could not use validators on pages where you wanted to section the page and provide different sections for different operations. Any action button would submit the page, and so all fields on the page would have to pass validation, not just fields in the section for that operation.
Creator 2.0 corrects this shortcoming. Virtual forms collect fields and components that fire events into partitions, meaning that a button or dropdown causing an event for a particular section of the page will only need validation to pass for the fields in that section of the page. This means validation becomes a lot more useful.
Creator 2.0 is built on top of the NetBeans 4.1 base, rather than 4.0 as was the case with Creator 1.0. This makes a bigger difference than you might suppose. For one, Creator is now distributed with Java 5. Although developers cannot take advantage yet of the new language features like annotations, generics, and the new for loop, the difference is noticeable in speed, improved look and feel, and overall solidity of the IDE. Creator wasn't a real problem for crashing before, but it feels better now. On Linux, in particular, the ability to turn on anti-aliasing of fonts. (Put -J-Dswing.aatext=true in the creator.conf file under /etc in the installation directory) and the fact that the new metal look and feel is a big improvement on the somewhat aging metal of Java 1.4, and the whole interface is just a lot prettier.)
NetBeans 4.1 also introduced some refactoring options as well, which are carried across to Creator 2.0. Don't expect IntelliJ levels of refactoring here, but there is some useful refactoring included.
There are many new features—some of which are not covered here and some of which I haven't even found yet, but four more that are worthy of mention are:
There are several new hooks in the page beans for different stages of the lifecycle now; some of these are very useful for calling code when a page is first hit, but not when an event fires on the page and the result stays on the same page. This means you can avoid some overhead in unnecessary data queries and lookups by hooking into the right events.
JSR-168 standard portlets now can be developed using Creator 2.0 and then used in Java portals. This will either mean a great deal to you (if you use portals) or not a lot (if you don't), but it is nice to have this ease of use for portals as well as full Web apps.