Learning Groovy and GRails – 1 of X

I want to learn Groovy and Grails because I want to deliver applications faster and with better quality.

I am unsure if this is the right strategy but it is going to be a fun experiment. Learning is always fun.

I will start with a few videos and go from there:

I will also have to look at the documentation on the spring site to figure out all the static variables and built-in methods that can be used.

JSON API with Spring 3.1.2 and Jackson 2.2.0

It took me a few hours to get everything working but I am quite happy at how simple it really is.

I read this blog post that had most of the instructions on how to do it: Spring MVC with JSON via Jackson 2.0

Norris mentions that you need to make sure that you have the jackson-databind dependency otherwise you will get a 406 error. I was getting a 406 error even with the jackson databind because I did not have the mvc:annotation-driven specified. I assumed I had it and was surprised that it was not there (lost an hour to something so trivial).

I was also not sure how to submit a JSON post to the API that I was creating to validate that it worked. I found a few example but the one that worked for me was this answer on stackoverflow: Parsing JSON into Java objects in spring-mvc.

The other testing I needed to do was what the JSON message format was to send to Spring. I tried something like:

{ objectName: [ {“field1”: “value”, “field2”: “value”} ] }

But that was giving me 400 errors.

The JSON message format that works is:

{ “field1”: “value1”, “field2”: “value2” }

Note that I am submitting only 1 object at a time to the API.

The last error that I encountered is that I had an internal class for the status (return object on submission) that was private. I got a 500 error when the spring bean was trying to access it so I switched to a protected class and everything is working.

I like the short code that Spring allows me to write to get this to work. Should make it quite easy to maintain.

Gradle Test Failure Telling You More

I read this article:

http://java.dzone.com/articles/gradle-goodness-show-more

and tried the code to see how it worked for me.

Code:
https://github.com/cinq/gradle-test.git

The only real gotcha was that FC17 installed Gradle 1.0 while 1.6 is available and the example only works with 1.6. I downloaded and installed the latest version to get the same results as outlined in the article.

I know that Spring has switched over to Gradle as the build system so I should probably get more familiar with it.

They have a free online ebook that I will read:

http://www.gradleware.com/registered/books/building-and-testing/

Spring Data JPA and the id field

When you make mistakes you learn more. Since this is true I can tell you that I am learning a lot every day.

Today I learned that your id field type in the entity need to be the same as the generics in the interface that implements the Spring Repository (CrudRepository in my case).

My entity has some code similar to this:

@Entity
public class Table {

    @Id
    @GeneratedValue
    private Long id;
    // more fields
}

And the code for the Repository is something similar to this:

public interface TableRepository extends CrudRepository<Table, Long> {
}

My mistake today was that my id field in the Table class was a int. My Spring application was returning this generic error message:

Could not execute JDBC batch update; SQL [insert into Table (name, id) values (?, ?)]; constraint [null]; nested exception is org.hibernate.exception.ConstraintViolationException: Could not execute JDBC batch update

Bonus: I also learned that it will throw the same error if you try to insert twice the same name value.

First try of Node.js

Spring Source has been advertising the scripted editor for a little while and I decided that I was going to give it a try.

First thing was to download an install Node.js itself.
Went to http://nodejs.org/ and downloaded the 64 bit linux tar ball.
Untarred in my /opt/ directory: tar zxvf node-v0.10.0-linux-x64.tar.gz

Once installed I could easily start node.js: /opt/node-v0.10.0-linux-x64/bin/node

Not much can be done with that but at least I know that it is running.

I copied the sample code from their documentation to an example.js

var http = require('http');

http.createServer(function (request, response) {
  response.writeHead(200, {'Content-Type': 'text/plain'});
  response.end('Hello Worldn');
}).listen(8124);

console.log('Server running at http://127.0.0.1:8124/');

And I can easily run this sample code: /opt/node-v0.10.0-linux-x64/bin/node example.js

Which gives you this output (at the command line): Server running at http://127.0.0.1:8124/

Which gives you the “Hello World” web page when you open the link in your browser.

The real step is then to install scripted. It seems too easy from the Spring Source page since all you have to do is: npm install -g scripted

Did a lot of work but it currently ends with errors:

> scripted@0.4.0 postinstall /opt/node-v0.10.0-linux-x64/lib/node_modules/scripted
> cd client && bower install
path.js:360
throw new TypeError(‘Arguments to path.join must be strings’);
^
TypeError: Arguments to path.join must be strings
at path.js:360:15
at Array.filter (native)
at Object.exports.join (path.js:358:36)
at Object.<anonymous> (/opt/node-v0.10.0-linux-x64/lib/node_modules/scripted/node_modules/bower/lib/core/config.js:35:22)
at Module._compile (module.js:456:26)
at Object.Module._extensions..js (module.js:474:10)
at Module.load (module.js:356:32)
at Function.Module._load (module.js:312:12)
at Module.require (module.js:364:17)
at require (module.js:380:17)
npm ERR! scripted@0.4.0 postinstall: `cd client && bower install`
npm ERR! `sh “-c” “cd client && bower install”` failed with 8
npm ERR!
npm ERR! Failed at the scripted@0.4.0 postinstall script.
npm ERR! This is most likely a problem with the scripted package,
npm ERR! not with npm itself.
npm ERR! Tell the author that this fails on your system:
npm ERR! cd client && bower install
npm ERR! You can get their info via:
npm ERR! npm owner ls scripted
npm ERR! There is likely additional logging output above.

npm ERR! System Linux 3.7.3-101.fc17.x86_64
npm ERR! command “/opt/node-v0.10.0-linux-x64/bin/node” “/opt/node-v0.10.0-linux-x64/bin/npm” “install” “-g” “scripted”
npm ERR! cwd /home/mc
npm ERR! node -v v0.10.0
npm ERR! npm -v 1.2.14
npm ERR! code ELIFECYCLE
npm ERR!
npm ERR! Additional logging details can be found in:
npm ERR! /home/mc/npm-debug.log
npm ERR! not ok code 0

I also tried downloading the scripted 0.4.0 zip file and the install gives the same errors. As the scripted site is recommending to use Node.js 0.8.6 it is obviously not working with the latest (0.10) yet.

Spring Data JPA

I have an existing project where I wanted to start using the Spring Data JPA library to stop having to do all the code involved in a DAO. It sounded like a smart idea (without any prior knowledge) but when I tried to implement I realized that every time you try something new there are a few hurdles and unexpected surprises.

Searching for solution and tutorial with Google might be a good fallback plan but I found so many references to different ways that I got confused before sorting it out a bit. What you don’t easily see in all the solutions is which version of which library they are using until you have read most of the solution. I wish we could more easily search for examples and tutorial based on library versions.

Versions

Here is what I used for my project:

Spring Core 3.1.2.RELEASE
Spring Data 1.1.0.RELEASE
Apache Derby 10.2.2.0 (old version)
Hibernate 3.6.9 (old version)

 Limitations

Since I was working within an existing project I needed to work with certain things in place that I could not remove to use the Spring Data JPA library.

I needed to work with some XML files for the application context.

I needed to work with Apache Derby (old version).

I needed to work with Hibernate (old version).

Code changes

First thing that I needed to do was to add some dependencies in my pom.xml to be able to use Spring Data JPA.


<dependency>
<groupId>org.springframework.data</groupId>
<artifactId>spring-data-jpa</artifactId>
<version>1.1.0.RELEASE</version>
</dependency>

It took me some trial and error to also realize that I needed an entity manager and since I was using Hibernate the logical choice was:


<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-entitymanager</artifactId>
<version>3.6.9.Final</version>
</dependency>

I already had the Hibernate dependency in my pom.xml before starting:


<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-core</artifactId>
<version>3.6.9.Final</version>
</dependency>

In my Java code I already had an entity that I wanted to use but because of the other entities that were managed under hibernate without Spring Data JPA I had to move this one to its own package so I could use some package scanning. Here is the entity code:


package com.cinq.test.domain;

import java.util.GregorianCalendar;

import javax.persistence.Column;
import javax.persistence.Entity;

@Entity
public class Event {

@Column(nullable=false)
private Long id;
@Column(nullable=false)
private String title;
@Column
private String Description;
@Column(nullable=false)
private GregorianCalendar date;

public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public String getTitle() {
return title;
}
public void setTitle(String title) {
this.title = title;
}
public String getDescription() {
return description;
}
public void setDescription(String description) {
this.description = description;
}
public GregorianCalendar getDate() {
return date;
}
public void setDate(GregorianCalendar date) {
this.date = date;
}

}

I needed to create a public interface to bind this entity to the Spring Data JPA “magic”. It simply needs to extend the CrudRepository and all the CRUD code is created for you.


package com.cinq.test.repository;

import org.springframework.data.repository.CrudRepository;

import com.cinq.test.domain.Event;

public interface EventRepository extends CrudRepository{

}

I also needed to add some quick configuration to my app-servlet.xml to get Spring to scan for repositories at startup:

All the code is available at:

Issues that needs to be worked out

The application runs on Tomcat but is giving an exception for a class not found on JBoss 7.1.1. I will have to look at the vfs settings for a default install.

I still need to fix the form submission.

 

References:

Spring Data – JPA (Starting point at SpringSource)
The Persistence Layer with Spring 3.1 and JPA (Starting point – tutorial)
Difference between configuring data source in persistence.xml and in spring configuration files (highlighted that with Spring 3.1 you don’t need the persistence.xml)
5 minutes with – Jpa transaction (highlighted the databasePlatform property in the xml configuration)
Problems with Spring maven hibernate org/hibernate/ejb/HibernatePersistence (need for hibernate-entity-manager)
13. Data access with JDBC (reference material for many items)

Eclipse completion template

Someone gave me some  code for a logger auto-completion template that I should use in Eclipse.

After searching on Google and discovering where it is in STS 3.1.0 I added this simple template to auto-complete my logger to use slf4j:

${:import(org.slf4j.Logger, org.slf4j.LoggerFactory)}private static final Logger ${logger} = LoggerFactory.getLogger(${enclosing_type}.class);

This is configurable under the Window -> Preferences -> Java -> Editor -> Templates

 

sts31-editor-template

 

I created a new template that I named logger, context is Java, a description (slf4j logging) and the pattern mentioned earlier.

Quite simple and so convenient that it will remove this bad habit of copying and pasting code with the wrong class name.

 

Spring 3 @Secured

I wanted to use the security annotation for my controllers and needed to do some searching to figure out how to get it to work.

Our application has a lot of legacy Spring 2.0 code so sometimes I am not sure how it will workout to mix the different ways to do things.

In my experimentation I was able to add security with the good old way:

<http auto-config="true">
    <intercept-url pattern="/something/protected**" access="ROLE_ADMIN">
    <... more config...>
</http>

As much as this was working I wanted the new annotation way in my controller code more than this xml configuration.

After reading a few articles I understood that I needed to add this line:

<global-method-security secured-annotations="enabled"/>

But it only works if it is within the same file where I have my other annotation scanning done for the application:

<!– @MVC –>
<context:component-scan base-package=”com.cinq.test”/>

I have a separate file for my security configuration but if I inserted the global-method-security configuration in there Spring would not apply my security annotation. A couple of answers on Stack Overflow mentioned that it needed to be in the same configuration file as the component-scan to work and as soon as I did this modification it started to work. So my main servlet xml configuration looks something like:

<?xml version=”1.0″ encoding=”UTF-8″?>
<beans xmlns=”http://www.springframework.org/schema/beans&#8221;
xmlns:xsi=”http://www.w3.org/2001/XMLSchema-instance&#8221;
xmlns:context=”http://www.springframework.org/schema/context&#8221;
xmlns:mvc=”http://www.springframework.org/schema/mvc&#8221;
xmlns:p=”http://www.springframework.org/schema/p&#8221;
xmlns:sec=”http://www.springframework.org/schema/security&#8221;
xsi:schemaLocation=”http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-3.0.xsd
http://www.springframework.org/schema/mvc
http://www.springframework.org/schema/mvc/spring-mvc.xsd
http://www.springframework.org/schema/security
http://www.springframework.org/schema/security/spring-security-3.1.xsd&#8221;
default-autowire=”byName” default-init-method=”init”>

<!– @MVC –>
<context:component-scan base-package=”com.cinq.test”/>
<context:component-scan base-package=”com.cinq.something”/>
<!– Security Annotation –>
<sec:global-method-security secured-annotations=”enabled”/>

My controller can now use this type of code:

@Controller
@RequestMapping("/protected/something")
public class SomethingController {
    @Autowired
    private ModelObject modelObject;
    @Secured("ROLE_TRANSFER")
    @RequestMapping(method=RequestMethod.GET)
    public String transferForm(Model model){
        // We need the list of sites
        ArrayList<String> sites = new ArrayList<String>();
        for ( ModelObject oneofthem : modelObjectDao.findAll()) {
            sites.add(oneofthem.getSite());
        }
        Collections.sort(sites);
        model.addAttribute("sites", sites);
 
       <SNIP SOME CODE>
       return "/WEB-INF/views/Transfer/form.jsp";
   }
 
    @Secured("ROLE_TRANSFER")
    @RequestMapping(value="/confirmation", method=RequestMethod.POST)
    public String confirmation(@RequestParam("site") String site, @RequestParam("date") String date, @RequestParam("requester") String requester) {

        return "/WEB-INF/views/schemaTransfer/confirmation.jsp";
    }
}

The URL calls will return a 403 if your credentials don’t have the ROLE_TRANSFER as an assigned role.

I like this simple way of annotating the behavior you want from your controller. Less file to maintain makes it easier for me to understand what behavior to expect from the code.

Spring 3.1 modelAttribute

Still working on this post…

Maddening searches to figure out how to properly use the modelAttribute keyword in the controller and the forms.

Here is a list of the mistakes I corrected to get to my goal

  • Typo: @ModelAttribute in the Java classes but modelAttribute in the jsp. Lower case “m” for jsp pages. When you have it right the id field in your rendered jsp page shows the proper model attribute name.
    <form:form modelAttribute=”madmartin” action=”/madmartin/${id}” method=”post”>
    gives html like this:
    <form id=”madmartin” action=”/madmartin/393216″ method=”post”>
    Got it from this page:  http://www.springbyexample.org/examples/spring-web-flow-subflow-webapp-jsp-example.html
    Too many other pages had it wrong. Mad +1
  • Could not use the @ModelAttribute on a method to create my object and then put data in the method processing the request. I had to put the @ModelAttribute in the argument of the method processing the request.
    I think this is the result of my misunderstanding of some feature. Idiot +1
  • Stole some code from the Spring documentation to fix a conversion issue from String to Date format I used in one of my model.
        @InitBinder
        public void initBinder(WebDataBinder binder) {
            SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
            dateFormat.setLenient(false);
            binder.registerCustomEditor(Date.class, new CustomDateEditor(dateFormat, false));
        }

    Code re-use at it’s best. Copy and Paste +1