I’ve updated my Spring Mockito Demo app that I demonstrate when teaching with a PowerMock of a final class with a static method.

Demo Features

• Maven 3.0
• Maven Enforcer plugin restricting use of commons-logging, log4j, slf4j > 1.5, maven version range & java 1.6
• All Maven plugin and java dependency versions are current and managed in properties of pom.xml
• Maven Versions plugin for evaluating current configuration for any version updates of dependencies
  • mvn versions:display-dependency-updates scans dependencies and reports dependencies with newer versions
  • mvn versions:display-plugin-updates scans plugins and reports plugins with newer versions
  • To get the version changes w/o the ones that haven’t changed : mvn versions:display-dependency-updates | grep " -> "
• Logback configuration with SLF4J
• Mockito tests of the controller layer (services are mocked)
• PowerMock configuration testing a final class with static method
• All tests are true Unit tests, no use of Spring Context in tests, including the context creates integration tests

Code Repository

https://github.com/gordonad/core-spring-demos/tree/master/demos/mockitodemo

Want to Learn More?

Learn more about Spring by attending a Spring Training class at Chariot, or contact us for onsite training.

Follow Chariot Education on Twitter

for Special Training offers

Share on Facebook

Here is how you can get started quickly with CloudBees Run@Cloud platform.

05-Mar-12 – Updated for Spring Roo 1.2.1

1. Get a CloudBees Account
2. Configure a MySql instance on CloudBees
3. Build a Spring Roo application
   see script below
4. Create a cloudbees-web.xml file in WEB-INF
   same directory as web.xml
5. Add Maven CloudBees Plugin
6. Build and deploy with Maven
   mvn clean install bees:deploy

Roo 1.2.1 Script

Here is a simple item manager application script you can use/customize to create your application.

• NOTE: Provide MySQL credentials in the “jpa setup” line.

# FOR SPRING ROO 1.2.1 - Spring Data JPA and Service Layer

development mode --enabled true

project --topLevelPackage com.gordondickens.roobees --java 6 --projectName roobees

jpa setup --provider HIBERNATE --database MYSQL --userName yourmysqluserid --databaseName yourmysqlinstancename --password yourmysqlpasswd

entity jpa --class ~.domain.Item --activeRecord false

field string --fieldName name --sizeMin 3 --sizeMax 30 --class ~.domain.Item
field string --fieldName description --sizeMax 255 --class ~.domain.Item

repository jpa --interface ~.repository.ItemRepository --entity ~.domain.Item

service --interface ~.service.ItemService --entity ~.domain.Item

web mvc setup
web mvc all --package ~.web

logging setup --level DEBUG

Roo 1.1.5 Script

Here is a simple item manager application script you can use/customize to create your application

# FOR SPRING ROO 1.1.5

development mode --enabled true

project --topLevelPackage com.gordondickens.roobees --java 6 --projectName roobees

persistence setup --provider HIBERNATE --database MYSQL --userName yourmysqluserid --databaseName yourmysqlinstancename --password yourmysqlpasswd

entity --class ~.domain.Item

field string --fieldName name --sizeMin 3 --sizeMax 30 --class ~.domain.Item
field string --fieldName description --sizeMax 255 --class ~.domain.Item

web mvc setup
web mvc all --package ~.web

logging setup --level DEBUG

cloudbees-web.xml

<?xml version="1.0"?>
<cloudbees-web-app xmlns="http://www.cloudbees.com/xml/webapp/1">
  <appid>roobees</appid>
  <context-param>
    <param-name>application.environment</param-name>
    <param-value>prod</param-value>
  </context-param>
</cloudbees-web-app>

Maven CloudBees Plugin

Add the CloudBees repository to the pluginRepositories section.

<pluginRepositories>
  ...
  <pluginRepository>
    <id>bees-plugins-snapshots</id>
    <url>http://repository-cloudbees.forge.cloudbees.com/public-snapshot/</url>
    <releases>
      <enabled>false</enabled>
    </releases>
    <snapshots>
      <enabled>true</enabled>
    </snapshots>
  </pluginRepository>
  ...
</pluginRepositories>

Add the CloudBees Maven plugin to the plugins section.

<plugins>
  ...
  <plugin>
    <groupId>com.cloudbees</groupId>
    <artifactId>bees-maven-plugin</artifactId>
    <version>1.0-SNAPSHOT</version>
    <configuration>
       <!-- your username/appname -->
      <appid>youruserid/roobees</appid>
      <!-- your api key -->
      <apikey>BEBEBE2CEBEBEFBE</apikey>
      <!-- your secret key -->
      <secret>GEE0GERE0E-JE0EQETEHEPET+33MEIEIEI0EEZEEIEE00+</secret>
      <message>Roo ItemManager on CloudBees by Gordon Dickens</message>
    </configuration>
  </plugin>
  ...
</plugins>

Database Properties File

Edit the /src/main/resources/META-INF/spring/database.properties file.
Set the database.url to jdbc:cloudbees://yourmysqlinstance.
Set the database.driverClassName to com.cloudbees.jdbc.Driver.

database.username=yourmysqluserid
database.password=yourmysqlpasswd

database.url=jdbc:cloudbees://yourmysqlinstancename
database.driverClassName=com.cloudbees.jdbc.Driver

Download the Demo App

The demo app is in Git https://github.com/gordonad/gordonad-roo-1.2-cloudbees for Spring Roo 1.2.

Get Your Copy --> Get it NOW! -->

<-- All the cool kids have one <-- You gotta have it!

Want to Learn More?

Learn more about Spring by attending a Spring Training class at Chariot, or contact us for onsite training.

Follow Chariot Education on Twitter

for Special Training offers

Share on Facebook

It is incredibly easy to do with Spring Roo and CloudFoundry!

This post on using Postgres on CloudFoundry helped me get started, however I tried using the 1.2.M1 with the CloudFoundry addon, but was unable to install it successfully in either 1.1.5.RELEASE or 1.2.0.M1.

Recently, Spring Roo moved to GitHub

Steps

1. Get a Free CloudFoundry Account
2. Clone the Spring Roo Git Repository
3. Configure GPG/PGP setup
   see /spring-roo/readme.txt
4. Build Spring Roo with Maven
   mvn -U clean install -Dgpg.passphrase=yourpassphrase
5. Link the Roo startup script
   see /spring-roo/readme.txt

Creating a Project

1. Make a directory for your SimpleItem project
   mkdir /SimpleItem
2. Go to the directory
   cd /SimpleItem
3. Create the script file simpleitem.roo in the /SimpleItem directory
   (see the contents below)
4. Start roo-dev
5. Type the command
   script --file simpleitem.roo
6. Go To: http://mysimpleitem.cloudfoundry.com/

The simpleitem.roo script file

development mode --enabled true
project --topLevelPackage com.gordondickens.simpleitem --java 6 --projectName SimpleItem
jpa setup --provider HIBERNATE --database POSTGRES
entity --class ~.domain.Item --testAutomatically --activeRecord false
field string --fieldName name --sizeMin 3 --sizeMax 30 --class ~.domain.Item
field string --fieldName description --sizeMax 255 --class ~.domain.Item
field date --fieldName visitDate --type java.util.Date --notNull --past
repository jpa --interface ~.repository.ItemRepository --entity ~.domain.Item
service --interface ~.service.ItemService --entity ~.domain.Item
finder add --finderName findItemsByName --class ~.domain.Item
finder add --finderName findVisitsByDescriptionLike
web mvc setup
web mvc all --package ~.web
web mvc finder all
logging setup --level DEBUG
perform package
download accept terms of use
pgp automatic trust

# ###########
# NOTE: Provide your credentials here, or perform these steps at the Roo prompt
# ###########
cloud foundry login --email you@mycompany.com --password n00n3w1llgu3ss

# ###########
# NOTE: The war file is the "--projectName" specified above
# ###########
cloud foundry deploy --appName mysimpleitem --path /target/SimpleItem-0.1.0.BUILD-SNAPSHOT.war --memory 512
cloud foundry create service --serviceName mysimpleitem-postgres --serviceType postgresql
cloud foundry bind service --serviceName mysimpleitem-postgres --appName mysimpleitem
cloud foundry start app --appName mysimpleitem

# ###########
# Go to URL: http://mysimpleitem.cloudfoundry.com/

NOTE CloudFoundry is Public

Since CloudFoundry is public, you may run into an issue deploying the application with the name above. You should change the --projectName to something unique with your name in it such as yourname-simpleitem.

Gunnar Hillert’s Blog explains this well.

Adding CloudFoundry Plugin to Maven

Thanks to Gunnar Hillert’s post, we can add to our project’s Maven pom.xml file the CloudFoundry Plugin.

<plugins>
  ...
  <plugin>
    <groupId>org.cloudfoundry</groupId>
    <artifactId>cf-maven-plugin</artifactId>
    <version>1.0.0.M1</version>
    <configuration>
      <server>mycloudfoundry-instance</server>
      <target>http://api.cloudfoundry.com</target>
      <url>${project.name}.cloudfoundry.com</url>
      <memory>256</memory>
    </configuration>
  </plugin>
  ...
</plugins>

Add CloudFoundry Credentials

Add credentials to our userhome/.m2/settings.xml

<servers>
  ...
  <server>
    <id>mycloudfoundry-instance</id>
    <username>you@mycompany.com</username>
    <password>n00n3w1llgu3ss</password>
  </server>
  ...
</servers>

To push (deploy) the code to CloudFoundry type mvn cf:push
For more plugin details type mvn cf:help

Get Your Copy --> Get it NOW! -->

<-- All the cool kids have one <-- You gotta have it!

Want to Learn More?

Learn more about Spring by attending a Spring Training class at Chariot, or contact us for onsite training.

Follow Chariot Education on Twitter

for Special Training offers

Share on Facebook

Looked at the error console and discovered that shCore.js could not find XRegExp.js.

This blog link was a great start.

Additional Details

1. Syntax Highlighter Git Repo
2. Get the XRegExp.js from the scripts directory: /SyntaxHighlighter/scripts/XRegExp.js
3. In your page above the shCore.js add XRegExp.js

Page Header Example

<script src='js/jquery-1.6.3.min.js' type='text/javascript'></script>
<script type="text/javascript" src="js/syntaxhighlighter/XRegExp.js"></script>
<script type="text/javascript" src="js/syntaxhighlighter/shCore.js"></script>
<script type="text/javascript" src="js/syntaxhighlighter/shBrushPlain.js"></script>
<script type="text/javascript" src="js/syntaxhighlighter/shBrushJava.js"></script>
<script type="text/javascript" src="js/syntaxhighlighter/shBrushGroovy.js"></script>
<script type="text/javascript" src="js/syntaxhighlighter/shBrushXml.js"></script>
<script type="text/javascript" src="js/syntaxhighlighter/shBrushCss.js"></script>
<link href="css/syntaxhighlighter/shCore.css" rel="stylesheet" type="text/css">
<link href="css/syntaxhighlighter/shThemeDefault.css" rel="stylesheet" type="text/css">

Share on Facebook

Download the tcServer Developer Edition free: http://www.springsource.com/developer/tcserver
This comes with Spring Insight: http://www.springsource.org/insight an awesome tool for inspecting application performance, see those expensive sql queries, etc.

1. Add JMX options

File: <appname>/bin/setenv.sh

CATALINA_OPTS="-Dcom.sun.management.jmxremote"
CATALINA_OPTS="$CATALINA_OPTS -Dcom.sun.management.jmxremote.ssl=false"
CATALINA_OPTS="$CATALINA_OPTS -Dcom.sun.management.jmxremote.authenticate=false"

2. Enable JMX

File: <appname>/conf/server.xml

# In the <service> section:

<Connector port="8050"
  handler.list="mx"
  mx.enabled="true"
  mx.httpHost="localhost"
  mx.httpPort="8082"
  protocol="AJP/1.3" />

3. If using JNDI, add JNDI Configuration support for Logback

File: <appname>/bin/setenv.sh

JAVA_OPTS="$JAVA_OPTS -Dlogback.ContextSelector=JNDI"

4. Add Server Logging using Logback

File: <appname>/conf/server.xml

#In the <Hosts> Section:

<Valve className="ch.qos.logback.access.tomcat.LogbackValve" />

5. Create logback-access.xml file in <appname>/conf/ directory

<configuration>
  <statusListener class="ch.qos.logback.core.status.OnConsoleStatusListener" />

  <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
    <encoder>
      <pattern>combined</pattern>
    </encoder>
  </appender>

  <appender name="FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
    <file>myApp.log</file>
    <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
      <fileNamePattern>myApp-%d{yyyy-MM-dd}.%i.txt</fileNamePattern>
      <timeBasedFileNamingAndTriggeringPolicy
            class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
        <maxFileSize>5MB</maxFileSize>
      </timeBasedFileNamingAndTriggeringPolicy>
    </rollingPolicy>
    <encoder>
      <pattern>combined</pattern>
    </encoder>
  </appender>

  <logger name="com.MYAPP.MYPKG" level="debug" />
  <logger name="org.springframework.web" level="debug" />
  <logger name="org.springframework.beans" level="debug" />
  <logger name="org.springframework.orm" level="debug" />
  <logger name="org.springframework.web" level="debug" />
  <logger name="net.sf.ehcache" level="error" />
  <logger name="org.hibernate.cache" level="error" />

  <root level="info">
    <appender-ref ref="FILE" />
    <appender-ref ref="STDOUT" />
  </root>
</configuration>

6. In the <tomcatdir>/lib directory, add the following jars

By including JCL-over-SLF4J, we handle Apache Commons Logging through SLF4J (JCL = Jakarta Commons Logging)
By including JUL-to-SLF4J, we handle Java Util Logging through SLF4J

• jcl-over-slf4j-1.6.2.jar
• jul-to-slf4j-1.6.2.jar
• slf4j-api-1.6.2.jar
• logback-access-0.9.30.jar
• logback-classic-0.9.30.jar
• logback-core-0.9.30.jar

7. Configure the application for Logging Separation

See: http://logback.qos.ch/manual/loggingSeparation.html

<env-entry>
  <description>JNDI logging context for this app</description>
  <env-entry-name>logback/context-name</env-entry-name>
  <env-entry-type>java.lang.String</env-entry-type>
  <env-entry-value>yourAppHere</env-entry-value>
</env-entry>

<env-entry>
  <description>URL for configuring logback context</description>
  <env-entry-name>logback/configuration-resource</env-entry-name>
  <env-entry-type>java.lang.String</env-entry-type>
  <env-entry-value>logback.xml</env-entry-value>
</env-entry>

<listener>
  <listener-class>ch.qos.logback.classic.selector.servlet.ContextDetachingSCL</listener-class>
</listener>

<filter>
  <filter-name>LoggerContextFilter</filter-name>
  <filter-class>ch.qos.logback.classic.selector.servlet.LoggerContextFilter</filter-class>
</filter>

<filter-mapping>
  <filter-name>LoggerContextFilter</filter-name>
  <url-pattern>/*</url-pattern>
</filter-mapping>

8. Optional – To add a servlet to view the logback events

File: <application>/src/main/webapp/WEB-INF/web.xml
See: http://logback.qos.ch/manual/configuration.html
Status Messages will be available: http://yourWebapp/lbClassicStatus

<servlet>
  <servlet-name>ViewStatusMessages</servlet-name>
  <servlet-class>ch.qos.logback.classic.ViewStatusMessagesServlet</servlet-class>
</servlet>

<servlet-mapping>
  <servlet-name>ViewStatusMessages</servlet-name>
  <url-pattern>/lbClassicStatus</url-pattern>
</servlet-mapping>

Summary

Using tcServer with Insight provides us developers with a valuable resource for code inspection at runtime. Logback and SLF4J provides us with fast, flexible logging configuration and the logging separation for our application instances.

Want to Learn More?

Learn more about Spring by attending a Spring Training class at Chariot, or contact us for onsite training.

Follow Chariot Education on Twitter

for Special Training offers

Share on Facebook

Modify the Repository Interface

Simply define the method interface and use the @Query annotation to define the OQL.

package com.gordondickens.myapp.repository;

import org.springframework.data.repository.CrudRepository;
import com.gordondickens.myapp.entity.Product;

public interface ProductRepository
   extends CrudRepository<Product, Long> {

	@Query("FROM Product")
	List<Product> findAllProducts();
}

Modifying Queries

• Parameters can be marked by position with ?1, ?2, etc.
• Parameters can be marked by name with :paramName and annotation @Param("paramName")
• Modifying method signature can only return void, Integer or int
• Updating queries MUST be transactional, mark with @Transactional
• Spring Data will drop all non-flushed changes pending in the EntityManager, change with @Modifying(clearAutomatically=false)

package com.gordondickens.myapp.repository;

import org.springframework.data.jpa.repository.Modifying;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.CrudRepository;
import org.springframework.data.repository.query.Param;
import org.springframework.transaction.annotation.Transactional;

@Transactional(readOnly=true)
public interface ProductRepository
   extends CrudRepository<Product, Long> {

   @Query("FROM Product")
   List<Product> findAllProducts();

   // Example with positional params
   @Modifying
   @Transactional(readOnly=false)
   @Query("update Product p set p.description = ?2 where p.productId = ?1")
   Integer setNewDescriptionForProduct(String productId, String description);

   // Example with named params
   @Modifying
   @Query("update Product p set p.description = :description where p.productId = :productId")
   Integer setNewDescriptionForProduct(@Param("productId") String productId,
      @Param("description") String description);
}

Automatic Query Generation

The <jpa:repositories/> has an option query-lookup-strategy which defaults to “create-if-not-found” which will generate queries for us.

The default is “create-if-not-found“. Other options are “create” or “use-declared-query“.

   <jpa:repositories base-package="com.gordondickens.myapp.repository"
		query-lookup-strategy="create-if-not-found"/>

To create a find method that effectively does @Query("FROM Product p where p.productId = :productId")

public interface ProductRepository extends CrudRepository<Product, Long> {
   ...

   @Query
   Product findByProductId(String productId);

   ...

Summary

We see how simple interface additions provide custom methods based on query language. We can query either by positional or named parameters.

Want to Learn More?

Learn more about Spring by attending a Spring Training class at Chariot, or contact us for onsite training.

Follow Chariot Education on Twitter

for Special Training offers

Share on Facebook