|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.Chapter 1: An Overview of JBoss Tools
The author starts covering JBoss Tools (3.0.0 CR2) and the following technologies are covered
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
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 bookChapter 2: JBoss AS Tools
Here the author starts quickly with some previous and important configurations used throughout the rest of the book like:
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:
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:
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 perpespective based on three buttons
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
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
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:
Then we can proceed to Creating a Struts project stub. For Struts we have two templates like
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)
To end the chapter our original RegisterFormBean class is edited now to extend ValidatorFormChapter 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
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 fieldsChapter 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:
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 shownChapter 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:
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 respectives XML files configuration
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.
(Note: Opinions expressed in this article and its replies are the opinions of their respective authors and not those of DZone, Inc.)