JBoss Tools 3 Developers Guide


Author(s): Anghel Leonard
ISBN: 1847196144
Published: April 2009
Relevance: 4/5
Readability: 5/5
Overall: 4/5

More Packt Publishing Books Reviews …

This book teaches us how use use JBoss Tools 3 step by step including a lot of images to get a better understanding. All this helps to have an easy development life with many important technologies and open source frameworks such as JSF, Hibernate and jBPM, JBoss WS, JBoss ESB among others

This is an interesting book, where the author knows how explain the step by step approach while using huge amounts of images throughout the book.

This Book is available here

Chapter 1: An Overview of JBoss Tools

The author starts covering JBoss Tools (3.0.0 CR2) and the following technologies are covered

  • JBoss AS Tools
  • JBoss JSF Tools
  • JBoss Struts Tools
  • JBoss Seam Tools
  • JBoss Hibernate Tools
  • JBoss jBPM Tools
  • JBossWS Tools
  • Portlet Tools
  • JBoss ESB Tools

Among others, how you can see JBoss Tools has an important support for the most important frameworks and technologies

The author follows with the section What’s new in JBoss Tools 3, where he offers a summary about

  • Seam Tools
  • Hibernate Tools
  • JBoss AS Tools
  • JBoss ESB

Now the author follows with the installation based first with Eclipse Java EE Developers (Ganymede) version 3.4.x, through software update and the second based with a manual Installation

You can see for these two approaches the classic step by step approach and using image(s) to get a better understanding – these techniques are utilized well throughout the rest of the book

Chapter 2: JBoss AS Tools

Here the author starts quickly with some previous and important configurations used throughout the rest of the book like:

  • JBoss AS Plug-in and Eclipse Web Tools Platform
  • Adding a WTP Runtime in Eclipse
  • Adding a WTP server in Eclipse

Almost nine pages with important images to cover these configurations

Now is the turn to Create a dynamic web project stub in JBoss 4.2 Server and learning about the perspectives used by JBoss AS like:

  • JBoss Server View
  • Project Archives View
  • Console View
  • Properties

each one has an image available. Furthermore how to start/stop our JBoss AS is covered among other additional operations. This is covered across twelve pages, all with a good amount of images.

To end this chapter the author teaches us how Creating and Developing Projects, based in faceted projects like:

  • Struts projects
  • Seam projects
  • JSF projects
  • J2EE projects

These will be used in the follow chapters.

Chapter 3: JBoss Tools Palette

Even if this is the second shortest chapter, it is important. The chapter starts quickly about this palette which is available through
Web Development perspective based on three buttons

  • Palette Editor
  • Show/Hide
  • Import

For the first element, creation, importation of icon is covered. For creation for group and individual tag library, the author offers a quick sample about a custom tag creation based on a html table element called mytable and how this is used after it is created.

Chapter 4: JSF Tools

In this chapter the book really starts teaching the power of JBoss Tools. The chapter is based around a Registration Form using some primitive data types like String, int, Date and custom class for the fields name, age, date, phone number. If this form is well filled then we forward to a success view

The author includes too an Overview of JSF (two pages for this), followed by Creating a JSF project Stub section. Something very important here is that teaches us about the explanation for each JSF template

  • JSFBlankWithLibs
  • JSFKickStartWithLibs
  • JSFKickStartWithoutLibs
  • JSFBlankWithoutLibs

The author offers us detailed coverage of the JSF application configuration file covering the three views like Diagram, Tree, Source for the first the author teaches very well how create the components for the JSF application –
I mean pages, navigation rules

With Tree View the author teaches us how create our Managed Beans, well covered in six pages with good step by step explanations and images. Custom converters and validators are covered with Java code included.

After this, Source View is shown to see all our previous configurations reflected.

The author teaches us about the edition of our jsp files working with the Insert Tag window to let us do these editions quickly. After this our application is tested

To end the chapter the author offers the approach to Add/Remove JSF capabilities for an existing project and Facelets support sections, for this last one, the following templates are listed and explained quickly

  • FaceletsBlankWithoutLibs
  • FaceletsKickStartWithRILibs
  • FaceletsKickStartWithoutLibs

Chapter 5: Struts Tool

Here we have some coverage for our old friend Struts 1. The sample of this chapter is based almost like the previous chapter, but only covering three fields (name, zip, email)

Before starting the development process, the author does a good Overview of Struts covering:

  • Model component (ActionForm)
  • View component (tag libraries – struts-xxx.tld, presentation tags)
  • Controller component (ActionServlet, Action, etc)

Then we can proceed to Creating a Struts project stub. For Struts we have two templates like

  • Blank
  • KickStart

Something important is the Struts editor, with the graphical editor for struts-config.xml. Just as in the previous chapter we have three views Diagram, Tree, Source.

Therefore we start using Diagram View to create our JSP files and Action mapping. How to connect these JSP files with action mappings is covered too (through forward).

The author includes the creation for global forward and global exception and the addition of code for the JSP files. After this the author teaches us how generate Java class stubs source like actions and bean classes, therefore our RegisterFormAction class is generated and edited for our application purposes

Now the author works with the Tree View to create our form bean called RegisterFormBean that extends ActionForm, where the author has shown us the complete Java class edited for application purposes.
After this Tiles creation is covered, working with three tiles definitions and the related JSP code. All of these are done with two approaches (Tree View or Diagram View)

After this, creation of a start page for the application and testing is covered too. Something important and well covered is validation, with fourteen pages covering this important topic closely related with validator-rules.xml and validation.xml, as well as including Client-side validation (based in JavaScript).

To end the chapter our original RegisterFormBean class is edited now to extend ValidatorForm

Chapter 6: Seam Tools

Here we start quickly with an Overview of Seam and then we follow with the requirements before to create our Seam Project. The important parts of this creation are well covered with explanation and images for a better understanding, including Database and Code Generation After this, the author teaches us how test our application to see if all goes well.

Then we proceed to Create Seam components, covering Seam Action, Form, Conversation, Entity.
This is followed with Seam Components View and Testing with TestNG.

Something interesting that the author offers is how to generate a Seam project from an existing database
and its respective execution.

Modification for Seam preferences ends this chapter.

Chapter 7: Hibernate Tools

The chapter begins with an Overview of Hibernate, followed with preparations where a sql code is shown related with two tables (parent,child) and its respective
relation between them. Installation of Hibernate Tools is covered briefly.

Then the creation of Hibernate mapping files (.hbm.xml) based on two Java classes Parent and Child working with annotations.The author proceeds to teach us the creation of the desired .hbm.xml files, empty for the moment, so we must use the Hibernate XML Editor
(specifically Tree View) to fill our .hbm.xml files using their respective adding elements options for
(class, id, property among others)

Then we proceed to create the Hibernate configuration file, including a concrete explanation for each textfield form for accomplish this configuration, including Session Factory, in the same way you going to find the instructions to create a Hibernate Console Configuration

Following this we have Hibernate Configuration view where we can see our classes/tables
in a mapping relation among them using the Mapping diagram. Even better, we can use HQL Editor working together with Hibernate Criteria Editor and
Query Result View and Hibernate Dynamic SQL Preview View. This is really useful for our development life!

Something very interesting and well covered is Reverse engineering.

The author offers a section called Hibernate Tools for Ant, including Hibernate Tool Exporters
related to

  • Hibernate mapping files (.hbm.xml)
  • POJOs (.Java)
  • Hibernate configuration file (.cfg.xml)
  • SQL DDL(.ddl)
  • Schema Documentation (.html)
  • HQL queries results.

There are fourteen pages for these importants topics. How you can see this is a long chapter!

Chapter 8: jBPM Tools

Not complicating things, the chapter start with a UML diagram to represent an invoice process, and then the instructions to download the jBPM Suite are provided. The creation of our stub project is covered too.

Now we can start the creation of the process definition, with all the previous base configurations we can change now to jBPM JPDL perspective to represent our UML diagram to here, therefore with Diagram View we can quickly add states, task-nodes, nodes, fork-join system, mail node and transitions (according with the UML diagram of course).

After this we customize names for nodes and transitions. We can define swimlanes (about actor and roles). A good explanation and images are offered for Defining task for the start-state, same appreciation to define a task for a task-node

Be careful if you think that all the work must be done by the Editor, you are wrong. Now we must add Java code to our nodes, these classes are called actions or actions classes. The author offers us two Java classes and their respective instructions for association for each node, while in the other way he shows how to configure our Mail node.

Practically to end the chapter how to run the process and testing purposes with JUnit is covered, for JUnit section two pages of a Java code is available about setting fields, leaving some state and doing assertion for such fields

Chapter 9: ESB Tools

Instructions to download the JBossESB Server
are provided along with its respective configuration installation. Then the creation of JBossESB stub project is covered,
followed by instructions on how to work with JBoss ESB Editor covering many definitions for:

  • Service skeleton
  • Action Pipeline
  • Listeners

For this last one we work with Gateway Listener and ESB Aware Listeners, including good XML code for jms-listener and jms-bus, configuration for queues is available too.

Now we include Java code for the sections related with Sending ESB Message through ServiceInvoker
and Sending a JMS Message in a classical manner.

To end the chapter preparation and deployment of the Service to our server, and Testing to ESB Service are both covered. Execution output is shown. To end the chapter an important image about all components working together and sequence call are shown

Chapter 10: Web Services Tools-JBossWS

This tool is closely based on JAX-WS. The chapter starts quickly with an Overview of Web Services, followed by instructions on how to download JBossWS Native and its respective configuration for
integration purposes with JBoss AS, and even instructions to copy some jars according if the JDK is 5 or 6 series is used, more configuration is covered yet for JBossWS under Eclipse.

Now we start creating a web service using our tools (this is done quickly), the important part is adding the JBoss Web Service facet, then the author teaches us how write a WSDL document using a wizard support, we see first almost three pages of pure xml code for a .wsdl file (the desired result output), then the author proceed to teaches us how use the wizard starting creating three most important sections:

  • service
  • binding
  • portType

where these sections you can see them in a graphical, since here we learn how create two new request-response operations and input/output messages among other configurations. Therefore now we proceed to generate the web service from the WSDL document, well covered this approach in five pages, ending the server side with providing service business logic

If we worked with server side, therefore we now work with the client side. We can generate the web service’s client from the WSDL document, the same approach used by the server side and providing client business logic

Then the author tests the web service working with Web Services Explorer (WSE).

Another way to create a Web Service is through from a Java bean, so the author includes Java code working with annotations based in @WebService, @WebMethod among others. From there we use the Web Services tools to create our .wsdl file.

With our created .wsdl file now we must proceed to Publish our web service and business entities. The author covers UDDI, and follows with JBoss AS 4.2 and jUDDI where he covers its default settings. Then we proceed to prepare the jUDDI database where XML lines are edited and sql insert statements are declared. With all these steps we can now use our Web Service Explorer as a UDDI Browser where we add a registry to WSE, Publishing a business entity and finally Publishing a WS, therfore now we can proceed to test to Discovering the WS through the WSE.

To end the chapter a brief but concrete covering about WSDL and WSLI is available too.

Chapter 11: JBoss Portal Tools

The chapter starts quickly with an Overview of Portals and Portlets, with two pages of theory, followed with download instructions for JBoss Portal and its respective configuration with Eclipse. Afterwards we start the JBoss Portal. With all these, two importants configurations are needed – to add Java Portlet and JBoss Portlets Facet support to JBoss Portal.

Now we can create our Java Portlet where the author shown a Java class overriding the method doView and its respective XML files configuration

  • portlet.xml
  • portlet-instances.xml
  • default-object.xml

with all these we can deploy and run the application

Another approach is do this by adding a JSP Portlet in the JBoss Portal, where we override the init, doView, doEdit, doHelp and processAction methods. The author keep the things simple, including a validator class, ending this section with the portlet.xml configuration

JSF Portlet and Seam Portlet for JBoss Portal end this chapter.

Development process can be hard and complicated, this book teaches us how use JBoss Tools to get a development process with many technologies and frameworks that you have read in this review

The book is easy to understand and follow, with images everywhere to have a better understanding, enjoy its 408 pages


More Packt Publishing Books Reviews …