Thursday, September 29, 2011

The recipes covered in Spring Roo 1.1 Cookbook are applicable to version 1.1.3, 1.1.4 and 1.1.5 version of Spring Roo. The Spring Roo 1.2 is currently in the milestone release, and it's final release will come sometime in December or early next year. Here, a few of my recommendations when going through recipes in Spring Roo 1.1 Cookbook:

1 - Use Spring Roo 1.1.5 when working with recipes described in Spring Roo 1.1 Cookbook.

3 - If you are evaluating Spring Roo for developing an application which makes use of a set of technologies or frameworks, then pay close attention to 'How it works...' section, which describes what all configuration and code is generated by Spring Roo.

4 - If you are using Spring Roo to learn a technology, it is important to focus on 'How it works...' section.

5 - Be prepared to write code or customize the Roo-generated code. A lot of recipes show what to customize and how to customize Roo-generated code.

Wednesday, September 28, 2011

As a follow up to the previous post, here I've detailed what information you'll find in Spring Roo 1.1 Cookbook and for what information you need to refer to other resources.

AspectJ ITDs - Information about AspectJ ITDs and how they are used by Spring Roo is covered in extensive detail. You'll recipes related to Push-in and Push-out refactoring also.

Spring framework and Maven - The Spring Roo Cookbook assumes that you have enough understanding of Spring and Maven. If not, then please refer to Spring reference documentation or any other tutorial or book.

Technology or framework information - Spring Roo Cookbook attempts to give a crash course in JPA, GWT, Flex, Spring Web Flow, Spring Web MVC, Selenium, Solr, and other technologies for which base add-ons are provided by Roo. If you have never used these frameworks, Spring Roo Cookbook woul;d still be an easy read for you. If you are looking for details on these technologies or frameworks, then it is recommended that you refer to some other resources.

OSGi - You'll find some introductory information about OSGi, as this forms the heart of Spring Roo add-ons

Roo-generated code information - This is at the heart of Spring Roo Cookbook. It attempts to cover all the Roo-generated code and configuration information. You'll find information about maven plugins that are configured by Roo in pom.xml file, AspectJ ITDs, Java source code, and so on.

Add-on development - Chapter 7 shows the code generated by Roo for simple and advanced add-ons. It should give you a solid starting point to create your own add-ons. This should give enough information about internal workings of Spring Roo.

Let me say this upfront -Spring Roo is not a replacement for a developer's technical skills. It'll only help you to be more productive but don't expect the tool to do everything for you.

To get the most out of Spring Roo, you need understanding of the following areas:

1. AspectJ ITDs

2. Maven

3. Spring framework

The first 3 points address the must-haves for using Spring Roo or you
won't be able to understand what's going on when you execute commands.

4. Good understanding of the framework or technology for which you are using Spring Roo to generate code

This is important if you want to modify the code generated by Spring Roo.
For instance, if you don't know Spring Web MVC, then it won't be easy
for you to figure out what you need to change to meet your application's
requirements.

5. Some understanding of OSGi

If you have some understanding of OSGi, then you can easily understand what add-ons are and why Spring Roo follows add-on based architecture. This could also be helpful if you want to get started with developing your custom add-ons.

6. A solid understanding of the code generated by Spring Roo

The code generated by Spring Roo follows best practices and gives a solid foundation for developing your application. This understanding is important if you want to make changes to Roo-generated code to meet specific requirements of your applications.

7. A good understanding of add-ons

Not all features that you need are part of base add-ons provided by Spring Roo. So some understanding of how to install and remove add-ons is helpful. For instance, if there is a Portlet add-on, you need to know how to install it in your Spring Roo installation to create portlets.

8. A good understanding of how Spring Roo works when you execute commands from Roo shell

It is important to know how code generation works in Spring Roo. For instance, add-ons are responsible for managing AspectJ ITDs so you should not modify them.

Tuesday, September 27, 2011

We saw in earlier two posts that using project command you can create a Java project, and by using persistence setup command you can setup a persistence provider (Hibernate, OpenJPA, and so on).

It's important to note the following when using Spring Roo:
- You don't need to remember commands because Roo is a very user-friendly development tool. You can look at all the Roo commands and their brief description using help command.
- Also, Roo offers auto-completion features - which means you partially type a command or an argument name, and Roo auto-completes it for you.

You can scaffold a Spring Web MVC application from JPA entities using controller all command.

Executing ch04_web-app.roo script createsflight-appRoo project, sets up
Hibernate as persistence provider, configures MySQL as the database for the
application, creates Flightand FlightDescriptionJPA entities and defines many-to-one relationship between Flightand FlightDescriptionentities. If you are
using a different database than MySQL or your connection settings are different
than what is specified in the script, then modify the script accordingly.

Step 2: Execute controller all command:

.. roo>
controller all --package ~.web

The controller all command creates JSPX views, controllers, copies custom tags, default themes, and so on. The package argument specifies the location where the Spring Web MVC controllers are created by Roo.

Step 3. You can now convert the project into an Eclipse IDE project using perform eclipse command. The perform eclipse command generates .project and .classpath files required by Eclipse IDE.

Step 4. You can also run the flight-app application in embedded Tomcat container by exiting the Roo shell (by executing quit command) and executing mvn tomcat:run goal from the command prompt. Now, you access the web application by going to the following URL: http://localhost:8080/flight-app

The following figure shows how the scaffolded web application looks like:

By default, the scaffolded web application allows you to perform CRUD operations on JPA entities, and to search entities based on the dynamic finder methods that you added to them.

Monday, September 26, 2011

In the previous post we saw how you can create a Java project using project command of Roo. In this post, you'll see that how you can create JPA entities using Roo.

Before we go about creating JPA entities, if you take a quick look at the pom.xml file of flight-app project, you'll see that it contains standard dependencies that you'll typically have in your Spring-based Java projects. The extra dependencies that you see are related to AspectJ and Spring Roo's annotation. You'll also notice that pom.xml configures Eclipse Maven plugin and Tomcat Maven Plugin.

Follow these steps to create a Flight JPA entity:1. Setup a Hibernate as the persistence provider. Open command prompt and execute persistence setup command, as shown here:

provider argument identifier a JPA provider (a couple of JPA providers are supported by Spring Roo)database argument identifies the database that you are going to use for your application (a couple of databases are supported by Spring Roo)databaseName argument identifies the name of the database

The entity command shown above creates a Flight.java class (representing a JPA entity) in com.sample.flightapp.domain package. The table argument identifies the table to which the Flight entity maps. You'll see couple of more files created with .aj extension....these AspectJ ITD files, which you should never modify.

The following code shows the Flight.java class:

@RooJavaBean@RooToString@RooEntity(...)public class Flight {...}

As you can see, Flight.java is annotated with couple of @Roo* annotations. These annotations trigger code generation in Spring Roo. The identifier definition, getter/setters for properties defined in Flight.java class, the persistence related methods (create, merge, update, and so on), and the toString methods are all inside the AspectJ ITD files generated by Roo.

The following things to note:
- AspectJ ITD files are like any other Java file, with a slightly different syntax. You don't need to learn a new language to understand AspecJ ITDs.
- The method, constructor, and so on, definitions in AspectJ ITD files are compiled into the corresponding Java source file. In our case, declarations contained in Flight_Roo_Entity.aj file are compiled into Flight class. This means resulting bytecode is not dependent on Roo at all.
- AspectJ ITD files are managed by Spring Roo when you make modifications to Java source file. So, you should not change them.
- If you want to modify a declaration in AspectJ ITD file, you can simply use Push-in Refactoring (using your IDE) to push the declaration (which could be method, attribute or constructor) into the corresponding Java source file. After doing push-in refactoring, you can modify the code manually in Java source file.

In the next post we'll go a step further and scaffold a Spring Web MVC application.

Sunday, September 25, 2011

Spring Roo is a productivity improvement tool....and you got to use it to believe this. In this post I'll show how to quickly get started with Spring Roo and create a Roo project. I will also talk about some of the artifacts created by Roo.

Note - Some of the information covered in this post are covered in Chapter 1 of Spring Roo 1.1 Cookbook. Once the book is released, Chapter 1 will become freely available. (Update - Sample Chapter 1 of book is now available here: https://www.packtpub.com/spring-roo-1-1-cookbook/book)

Pre-requisite

Install Java SE 6 or later and set JAVA_HOME variable

Install Maven 3.x or later

1. Setting up Roo

Setting up Roo is simple, download the ZIP file from SpringSource website (http://www.springsource.org/roo/start) and unzip into a folder. Now, add path to bin directory of Roo to your PATH variable.

2. Verify installation

Create a directory named myfirst-app. Open command prompt and go to myfirst-app directory and enter roo on the command line. You'll see the following output if your installation was correct:

____ ____ ____

/ __ \/ __ \/ __ \

/ /_/ / / / / / / /

/ _, _/ /_/ / /_/ /

/_/ |_|\____/\____/ x.y.z.RELEASE

roo>

The command prompt now becomes roo> indicating that you are now inside the Roo shell. The output shows the Spring Roo release that you are using. All the commands that you enter now will be processed by Spring Roo. You can think of a Roo shell as nothing but a standalone Java application that processes commands.

3. Creating a project

The first step is to create a Roo project. Though this is called a Roo project, it's just a simple mavenized project. To create a Roo project enter project command of Roo, as shown here:

As you can see from the above output, nothing specific to Spring Roo is created. It is like any maven project for creating a Spring-based application.

topLevelPackage specifies the root package of your project.

projectName specifies the name of the project. This becomes the <artifact-id> and <name> element values in pom.xml file.

The applicationContext.xml file is shown here:

<beans ..>

<context:property-placeholder

location="classpath*:META-INF/spring/*.properties"/>

<context:spring-configured/>

<context:component-scan base-package="sample.roo.flightapp"

>

<context:exclude-filter

expression=".*_Roo_.*" type="regex"/

>

<context:exclude-filter expression=

"org.springframework.stereotype.Controller"

type="annotation"/

>

</context:component-scan

>

</beans

>

As the above listing shows, it contain <component-scan> element to auto-register Spring components. It excludes classes that follow the naming convention *_Roo_* and which are annotated with @Controller annotation.

As you can see, project command simply creates a maven project with some Roo-specific configuration. These Roo-specific configurations are quite limited and you can remove them, when you decide to do so. For instance, you can modify the <component-scan> shown above to exclude Roo-specific exclusion rule, and you can use this project as any other Spring project.

In the next post, we'll look at how create a JPA entity and import the flight-app project into Eclipse or STS or IDEA IDE.

Tuesday, September 20, 2011

In Installing an installable add-on recipe of Spring Roo Cookbook, I showed how to download and install gvNIX add-on for creating Services in your Roo-based application.
Spring Roo 1.2 M1 adds a new service command which you can use to create service layer of your application, as mentioned in this Spring Roo blog entry.