Thoughts on SpringBoot

In its new avatar, Spring enters the opinionated frameworks marketspace, and finally takes the Sinatra/Scalatra/Ratpack/Dropwizard/Spark route, where embedded containers (ie no external server containers) will start dictating the future. Whats an opinionated framework anyway? Aint all frameworks opinionated? To me every piece of code is just as opinionated as the developer who wrote it. Here are my observations about SpringBoot, after having worked with it for about 6 weeks.

1. Build support for gradle (+)
SpringBoot apps can be built using both maven and gradle. But I believe Gradle will eventually dominate the world of buildscripts. So the sooner your team moves to gradle, better will be your quality of this life and perhaps, next life too. Are you listening, .Net?

2. Starter poms (+)
Remember your 500 line pom.xml, where the tag <dependency> occurs 25000 times? Say good bye and start using starter-poms. Combined with gradle, a typical build file is now about 30 lines.

3. Configurations (+/-)
Spring is among the last standing action heros of xml-based application configuration in jvm world. Super hit when introduced, but soon became a liability. Thankfully, many developers challenged the xml tag soup and created innovative web frameworks (Wicket, Play etc.). Those who work with the Spring-based framework Grails, may have not touched an xml for a good period of time. If Spring MVC developers are still stuck with Spring without adapting Grails, I fail to understand why (well except for business impositions).

Ironically, SpringBoot seems to have many opinions when it comes to configuration – it supports 3 flavors of bean configurations: xml, annotation and groovy dsl. Having worked with Grails and other non-xml based applications for the last few years, picking up SpringBoot was bit of a chore. Grails autowires beans by name, and when custom beans are required, there is this wonderful bean builder. For me, java annotations are no better than xml configuration. Xml configuration proliferates verbosity but annotations defeat the purpose of wiring objects separate from code. While it brings type-safety, it also lets you mix code, configuration and logic and I think its a total mess. Annotations are like antibiotics – good in small doses (@ToString, @RestController, @AutoClone etc.), too many side-effects with overdose – building whole applications using annotations is @NotMyStyleOfTea.

A typical SpringBoot application has many many annotations – @EnableAutoConfiguration, @Configuration, @ComponentScan, @Conditional etc. Sometimes you end up with more annotations than the code itself and its not intuitive which is doing what when how. SpringBoot is certainly simpler for developers from xml background, but to me as a Grails developer, annotations have been a bit intimidating and sprawling. I don’t see CoC (Convention-over-Configuration), instead I see CoC (Configuration-over-Code).

Thankfully, SpringBoot has great (although not 1:1 xml equivalent) support for groovy beans dsl (via the GroovyBeanDefinitionReader). Groovy dsl is elegant, concise, intuitve and very readable. For some loss of type-safety (which could have been compensated by good tooling support), it comes with a great punch – wiring beans, environmental configurations, programmatic startup logic (as opposed to declarative) etc. I feel Spring can standardize groovy bean as the only configuration mechanism and shed all the fat of xmls and annotations. It would make the framework pretty lean and competitive in the already crowding lean frameworks market. May be thats what grails-boot is?

4. Properties (+/-)
Just like configurations, there are a few ways of defining and injecting properties. Coming from Grails background, the many ways of injecting properties was a bit confusing. SpringBoot supports both .properties and .yaml files. AutoConfiguration uses many default values for properties, but there is no comprehensive documentation on these properties on whats default. Again there are many annotations related to properties @ConfigurationProperties, @PropertySource, @Value, @EnableConfigurationProperties etc. Grails has this amazing single-point grailsApplication bean based on ConfigObject (a glorified Map) and allows nested and runtime evaluate-able configurations – helpful in dynamic scenarios. Again I wish Spring had defacto support for this (injecting properties from a config.groovy).

5. Rest Support (+)
SpringBoot makes it very easy to create rest controllers via @RestController. Instead of creating full-blown web applications, Spring’s eco can be used to create well-rounded rest services backed by Batch/Data/Integration/Security and use js frameworks like Angular/Knockout/Backbone etc. for front end. If using rest over json, Groovy 2.3 is promising to come up with fast json marshaller. While I like the cleanliness of Thymeleaf, the modern js frameworks have a clear advantage over server-side html generators.

6. Logging (+/-)
Yet again, too many logging frameworks in the bag: log4j, log4j2, slf4j, slf4j2, commons.log, java.util.log, logback. I spent some time resolving dependency conflicts, until I finally gave up and switched to logback. Spring team strongly recommends logback – Just Go with it – there is probably a good reason.

7. Data Access (+)
No question about Spring’s versatility here. Name any db and you have SpringBoot autoconfiguration support. Plus the Grails team has done a great job of spinning-off Gorm to standalone component. TexMex, I would say.

8. Testing (+/-)
Many examples still show use of JUnit, but here is a good start on how to use the incredible Spock framework in SpringBoot. Spock is like mom’s recipe – once you taste it, others aint the best.

9. Documentation (+)
It has improved a lot with newer minor releases. It takes time to sift through some old examples in the community, but lets just blame Google for not knowing what you exactly want, though it seems to know all about what food you want to eat when you are near a restaurant.

10. Finally
I think Grails3 (grails-boot?) is going down the trending route of embedded container deployments. I think that’s the only thing against Grails in the current trend. SpringBoot has got there first but I still feel it lacks the simplicity of Grails or the leanness of Play. It has certainly been simplified, but not simple.

If your existing eco system depends a lot on Spring based frameworks, it is worthwhile to adapt SpringBoot. Honestly, Im hoping Grails3 isn’t far off!

Grails Application with AngularJS: Calling a Rest Service – Part 5

Remember the core principle of MVC? Clean separation of model, control and view? Many MVC frameworks, but there hardly is a single framework that provides a puritanical separation between layers. In some, the view is polluted with server-side syntax (jsp, gsp, asp), its equivalents (taglib) or specialized templates (velocity, freemarker); in some others, the server-side code is interspersed with view layer abstractions (css class, href links) or its equivalent html wrappers. One way to measure good separation is how close the view layer is to html semantics itself.

In this part, let us see how we can combine the power of Angular and simplicity of Grails (mainly because of conventions) to make a better separation of model and view.

Note: For the brevity of this post, the tests are not explained, but is included in the github. Specifically, take a look at how angular-mocks provides a cool $httpBackend object that acts as a http service for unit tests and how to invoke them in the controllerSpecs.js.

Goal: Display a star catalog

Techniques Demonstrated

1. Retrieve Star catalog from server via ajax rest call (demonstrates Rest, Ajax and Angular’s $http)
2. Show/Hide star catalog (demonstrates Angular’s implicit scope values)
3. Display the json model in table format (demonstrates Angular’s ng-repeat directive)
4. Simple Grails 2.3.x Rest services (demonstrates Grails 2.3.x Rest capabilities)

Ingredients

• Star domain class, decorated with @Resource annotation to make it Rest-enabled
• New Angular controller to initiate an http request
• http.get() ajax call to retrieve data from Star domain class and bind to Angular scope
• Html table to display scope data

Step: Create Star domain class

cmd> cd c:\projects\angrails
cmd> grails create-domain-class angular.Star

Update the code as:

package angrails
import grails.rest.Resource
@Resource(uri='/starCatalog', formats=['json', 'xml'])
class Star {
String name
 String constellation
 //Bayer Designation
 String bd
 //Distance from Earth in light years
 Integer distance
static constraints = {
 }
}

There are many ways to create restful services in Grails 2.3.x, this is one of the easiest ways – create a domain object and add a @Resource annotation. Works for prototypes, demos and really simple applications. For an advanced method, you may want to use RestController and other methods.

Step: Add some seed data to Bootstrap.groovy

def init = { servletContext ->
 new Star(name: 'Aldebaran', constellation: 'Taurus', bd: 'Alpha Tauri', distance: 65).save(flush:true)
 new Star(name: 'Betelgeuse', constellation: 'Orion', bd: 'Alpha Orionis', distance: 640).save(flush:true)
 new Star(name: 'Regulus', constellation: 'Leo', bd: 'Alpha Leonis', distance: 79).save(flush:true)
 new Star(name: 'Spica', constellation: 'Virgo', bd: 'Alpha Virginis', distance: 260).save(flush:true)
 }

cmd> grails run-app
Goto http://localhost:8080/angrails/starCatalog

You should see json representation of the records from Star domain class. Grails auto-generates Rest url end point /starCatalog.

Step: Create Angular Controller and http.get ajax call

Create another controller (next to the MainCtrl) in angrailsApp.js:

angrailsApp.controller('StarCatalogCtrl',
	function ($scope, $http) {

		$scope.getStarCatalog = function () {
			$http.get('/angrails/starCatalog').
				success(function (data) {
					console.log("success: " + data);
					$scope.starCatalog = data;
				}).error(function (data) {
					console.log("error: " + data);
					$scope.starCatalog = data;
				});
		};

		$scope.getStarCatalog();
	}
);

1. As a convention, I keep Angular controller suffix as “*Ctrl”, while Grails controllers as “*Controller”.
2. Observe that one more parameter is being added to the function – $http. When Angular runs the javascript, it injects a http service object into $http automatically.
3. The $http.get() does the ajax call to the auto-generated Grails Rest endpoint
4. The result data is set to a new variable in scope – “starCatalog”. We will use this variable to display the table data

Step: Display data in table

You can run crazy with your imagination on how to display the data, but a simple step is shown here:

<div ng-controller="StarCatalogCtrl">
	<span><a href="#" ng-click="starCatalogShow = !starCatalogShow">Star Catalog</a></span>
	<div ng-show="starCatalogShow">
		<div>
			<table class="table">
				<tr>
					<th>Common name</th>
					<th>Constellation</th>
					<th>Bayer Designation</th>
					<th>Distance from Earth (light years)</th>
				</tr>
				<tr ng-repeat="star in starCatalog">
					<td>{{star.name}}</td>
					<td>{{star.constellation}}</td>
					<td>{{star.bd}}</td>
					<td>{{star.distance}}</td>
				</tr>
			</table>
		</div>
	</div>
</div>

A few points of interest here:

• AngularJS Directives (ng-show, ng-click, ng-controller, ng-repeat) do appear to be a cleaner way of extending html behaviour.
• Directive ng-controller=StarCatalogCtrl specifies which controller provides the scope of the data
• How an implicit scope variable “starCatalog” hides/shows the table (within the span tag, using the ng-show directive)
• The ng-repeat Angular directive which is the “forEach (item in itemList)” equivalent to iterate through the starCatalog
• With this approach, the binding between client and server is a clean http call. This gives you the ability to call any rest service, as long as you can process what you get.

And before we go nuts about AngularJS, observe the syntax of the <a> tag. This type of construct was popular pre-jquery times (<a href=”#”, onclick=”javascript:openLink()”>Click me</a>). With jQuery, there was a big drive towards separation of presentation of data and manipulation of data – using $(id).onClick() syntax. But AngularJS has put the old construct right back into vogue now, but with a twist.

Does this bother you? The pendulum of imperative-declarative programming will swing on forever. Meanwhile, take a look at these articles about Remix and Innovation Recycle bin.

Grails Application with AngularJS: Tests on build server – Part 4

In the previous post, we got karma running on your local systems, as part of grails unit test plans, enabling continual test against Chrome. How do you ensure your unit tests are running in a build server like Jenkins or Bamboo?

PhantomJS is a headless webkit, ie a browser with no browser UI. Make these changes in your karma.conf.js

browsers: ['Chrome', 'PhantomJS'],
plugins: [
 'karma-jasmine',
 'karma-chrome-launcher',
 'karma-phantomjs-launcher',
 'karma-remote-reporter'
 ]

Now run the karma test again:

cmd> cd c:\projects\angrails
cmd> karma start test\javascript\config\karma.conf.js

Warning: Native modules not compiled. XOR performance will be degraded.
Warning: Native modules not compiled. UTF-8 validation disabled.
INFO [karma]: Karma v0.10.9 server started at http://localhost:8001/
INFO [launcher]: Starting browser Chrome
INFO [launcher]: Starting browser PhantomJS
INFO [Chrome 33.0.1750 (Windows 7)]: Connected on socket Tsk76f8qRWk84nVP6jlC
INFO [PhantomJS 1.9.2 (Windows 7)]: Connected on socket oMQSWXNcCW6hNOoH6jlD
PhantomJS 1.9.2 (Windows 7) LOG: ‘angrails manifest load complete.’
PhantomJS 1.9.2 (Windows 7) LOG: ‘calling’
Chrome 33.0.1750 (Windows 7) LOG: ‘angrails manifest load complete.’
Chrome 33.0.1750 (Windows 7) LOG: ‘calling’
Chrome 33.0.1750 (Windows 7): Executed 1 of 1 SUCCESS (0.352 secs / 0.029 secs)
PhantomJS 1.9.2 (Windows 7): Executed 1 of 1 SUCCESS (0.273 secs / 0.018 secs)
TOTAL: 2 SUCCESS

Notice that Karma runs tests against PhantomJS too. You can also add Firefox, IE and test your javascripts against multiple browsers simultaneously.

Additional Notes

But for your build server you need to test just against PhantomJS and not other browsers. One way to do this, is to create a copy of karma.conf.js as karma.local-conf.js. Use the local copy for your local unit tests and the default karma.conf.js for the builds (ie only PhantomJS). This way grails test-app runs against the karma.conf.js in your build server.

Remember you need to install node.js, karma and other components in the build server too.

In Part 5, we shall see how to invoke grails urls/services from AngularJS.

Grails application with AngularJS: Karma with test-app – Part 3

In Part 2, we added karma test runner to our AnGrails application. Its great that you can test your javascripts on the fly locally. What about testing it as part of your grails test-app lifecycle ?

Step: Setup JUnit/Karma integration so that karma can run via grails test-app

Edit BuildConfig.groovy

Add the following line under plugins

test ':karma-test-runner:0.2.0'

See karma-test-runner grails plugin for more information.

Create new file c:/projects/angrails/test/unit/angrails/JavaScriptUnitTestKarmaSuite.java

Add the following text:

package angrails;
import de.is24.util.karmatestrunner.junit.KarmaTestSuiteRunner;
import org.junit.runner.RunWith;
@RunWith(KarmaTestSuiteRunner.class)
@KarmaTestSuiteRunner.KarmaConfigPath("./test/javascript/config/karma.conf.js")
@KarmaTestSuiteRunner.KarmaRemoteServerPort(9876)
public class JavaScriptUnitTestKarmaSuite {
}

Run the test.

cmd> grails test-app

| Compiling 1 source files.....
Karma will be started with process builder args: [karma.cmd, start, C:\projects\angrails\.\test\javascript\config\karma.conf.js]
| Running 1 javascript test...
Starting karma result receiver server on localhost:9889
Warning: Native modules not compiled. XOR performance will be degraded.
INFO [karma]: Karma v0.10.9 server started at http://localhost:8001/
Warning: Native modules not compiled. UTF-8 validation disabled.
INFO [launcher]: Starting browser Chrome
INFO [Chrome 33.0.1750 (Windows 7)]: Connected on socket yX5XSRbnYl_IzwQp7ocG
LOG: 'angrails manifest load complete.'
LOG: 'calling'
Chrome 33.0.1750 (Windows 7): Executed 1 of 1 SUCCESS (0.248 secs / 0.03 secs)

Issues

If one of the following errors occur:

Could not load class in test type ‘javascript’
ERROR [karma]: { [Error: listen EACCES] code: ‘EACCES’, errno: ‘EACCES’, syscall: ‘listen’ }

There is some issue with how the karma is being started via test-app. I found both cmd line grails test-app and invoking via IntelliJ grails cmd window (Alt+G) yield different results. The common problem of both errors seems to be the port number that karma starts on.

Solutions

1. Change the port number in karma.conf.js to 8001 or try another number (above 1024 and available).
2. Remove line of the port number specified in JavaScriptUnitTestKarmaSuite.java: @KarmaTestSuiteRunner.KarmaRemoteServerPort(8001)

Results

With the above settings (ie karma.conf.js:port = 8001 and no port specified in the java code), the test-app works fine in both IntelliJ and command line.

During your test runs, sometimes the port binding is not released when test is shutdown. On *nix systems, you can just use kill <process-id>. For Windows, use PowerShell and do the following:

netstat -o -n -a | findstr "<portnumber>"
stop-process -Id <pid>

In Part 3, we saw how to add karma to grails test-app lifecycle.
In Part 4, lets see how to get karma tests running on your build server.

Grails application with AngularJS: Adding Karma – Part 2

Step: Install karma, karma cli and angular-mocks

cmd> cd c:/projects/angrails
cmd> mkdir test\javascript\config
cmd> mkdir test\javascript\unit
cmd> mkdir test\javascript\lib
cmd> npm install -g karma
cmd> npm install -g karma-cli
cmd> cd c:/projects/angrails/test/javascript/lib

As of this writing, angular-mocks is at v1.2.14 and does not work with angular v1.2.12. When Karma is run, it fails with following error:

Failed to instantiate module ngMock due to Unknown provider: $$rAFProvider

I had to go back to a previous version of angular-mocks v1.2.3. So install v1.2.3:

cmd> bower install angular-mocks#1.2.3

Both angular and angular-mocks will be installed in c:/projects/angrails/test/javascript/lib/bower_components. You can delete the “angular” directory, because we already included it in the grails-app/assets. You would rather not want two angular imports in your project, as you must remember to update both for version changes.

Step: Configure karma

cmd> cd c:/projects/angrails/test/javascript/config
cmd> karma init karma.conf.js

#Answer in the following manner (of course you can choose to answer differently)

Which testing framework do you want to use ?
Press tab to list possible options. Enter to move to the next question.
> jasmine
Do you want to use Require.js ?
This will add Require.js plugin.
Press tab to list possible options. Enter to move to the next question.
> no
Do you want to capture a browser automatically ?
Press tab to list possible options. Enter empty string to move to the next question.
> Chrome
>
What is the location of your source and test files ?
You can use glob patterns, eg. "js/*.js" or "test/**/*Spec.js".
Enter empty string to move to the next question.
> ../../../grails-app/assets/bower_components/jquery/dist/jquery.js
> ../../../grails-app/assets/bower_components/angular/angular.js
> ../../../grails-app/assets/javascripts/**/*.js
> ../../../test/javascript/lib/bower_components/angular-mocks/angular-mocks.js
> ../../../test/javascript/unit/**/*.js
>
Should any of the files included by the previous patterns be excluded ?
You can use glob patterns, eg. "**/*.swp".
Enter empty string to move to the next question.
>
Do you want Karma to watch all the files and run the tests on change ?
Press tab to list possible options.
> yes
Config file generated at "c:\projects\angrails\test\javascript\config\karma.conf.js".

Optionally, you can edit the karma.conf.js and set the basepath to: basePath: ‘./../../../’, and remove the ../../../ from the file includes.

Step: Start Karma

cmd> karma start karma.conf.js

You should see a chrome browser started pointing to 9876 port. There is nothing to test yet. Keep the Karma running.

Step: Add Angular code

Add a test: test/javascript/unit/controllersSpec.js

'use strict';
describe('angrailsTest', function () {
beforeEach(module('angrailsApp'));
var scope, mainCtrl;
beforeEach(inject(function ($compile, $rootScope) {
 scope = $rootScope.$new();
 }));
describe('angrailsMainCtrl', function () {
beforeEach(inject(function ($controller) {
 mainCtrl = $controller("MainCtrl", {$scope: scope});
 }));
it("should set hello text", function () {
 var helloText = 'Hello Angular Demo!';
 expect(scope.helloText).toEqual(helloText);
 });
})
});

Angular Application module: grails-app/assets/javascripts/angrailsApp.js

var angrailsApp = angular.module('angrailsApp', []);
angrailsApp.controller('MainCtrl', ['$scope',
 function ($scope) {
 $scope.helloText = 'Hello Angrails Demo!';
 }
])

Application dependencies: grails-app/assets/javascripts/application.js

Add line between angular and views:

//= require angular/angular
//= require angrailsApp
//= require_tree views

When you modify the js files, keep watching the karma window, it will run tests automatically. Currently it must have failed, because our test is incorrect:

In controllersSpec.js, change

var helloText = 'Hello Angular Demo!';

to

var helloText = 'Hello Angrails Demo!';

and watch the Karma window, it should pass.

In Part 2, We added Karma to our application. Karma can test javascripts independently. What if we want to test it as part of our grails test lifecycle?

In Part 3, lets ensure that Karma is part of the grails application test lifecycle.

Grails application with AngularJS: Setup – Part 1

There are several posts about setting up AngularJS, but a few specific to Grails environment. If you have been a Grails developer and want to explore using AngularJS framework for front-end, here is step by step guide to get started. Grails and AngularJS are both full-fledged mvc frameworks on their own. Using the positives from both can be a killer comination to build fast and modern dynamic web applications.

Notes:

• Instructions are for Windows OS
• Directories only for reference
• All versions as of writing this article. Substitute with newer versions as appropriate.
• Pre-installed: JDK 1.7.0_51: C:\Programs\Java\jdk_1.7.0_51
• Pre-installed: Grails 2.3.6: C:\Programs\Grails\grails-2.3.6

This setup does not use the angularjs-resources Grails plugin. It replaces the resources plugin entirely with asset-pipeline plugin and uses npm/bower to manage javascript dependencies directly. AngularJS does work with grails resources plugin too, but I feel it becomes difficult to maintain when adding more angular modules.

Step: Install pre-req software

Install Node.js -> http://nodejs.org/ to C:\Programs\nodejs
Install Git -> http://git-scm.com/downloads

Ensure PATH contains: c:\programs\nodejs; c:\programs\git\cmd

Open new command prompt (new, because your PATH would have been modified)

npm install -g npm
npm install -g bower

Step: Create new Grails app

cmd> cd c:\projects
cmd> grails create-app angrails
#All commands executed from the following directory, unless specified
cmd> cd angrails

Step: Switch from resources plugin to using asset-pipeline plugin

AngularJS will work with resources plugin too, but when you start installing many javascript components, the ApplicationResources can become clumsy. Asset pipeline is the new Grails plugin (based on Rails asset pipeline) that makes it easier to manage static resources, javascript, sass/less etc.

Edit BuildConfig.groovy

delete: resources, zipped-resources, cached-resources, yui-minify-resources lines

add: compile “:asset-pipeline:1.6.1”

cmd> grails refresh-dependencies

That will create grails-app/assets/* sub-directories

cmd> move web-app\css\* grails-app\assets\stylesheets
cmd> move web-app\js\* grails-app\assets\javascripts
cmd> move web-app\images\* grails-app\assets\images
cmd> move web-app\images\skin grails-app\assets\images
cmd> rmdir web-app\css web-app\js web-app\images

Step: Fix main.gsp to use asset-pipeline

Edit main.gsp

Comment/Delete following lines:

<link rel="shortcut icon" href="${resource(dir: 'images', file: 'favicon.ico')}" type="image/x-icon">
<link rel="apple-touch-icon" href="${resource(dir: 'images', file: 'apple-touch-icon.png')}">
<link rel="apple-touch-icon" sizes="114x114" href="${resource(dir: 'images', file: 'apple-touch-icon-retina.png')}">
<link rel="stylesheet" href="${resource(dir: 'css', file: 'main.css')}" type="text/css">
<link rel="stylesheet" href="${resource(dir: 'css', file: 'mobile.css')}" type="text/css">
<g:javascript library="application"/>
<r:layoutResources/> (2 places)

Add the following lines above <g:layoutHead/>

<asset:javascript src="application.js"/>
<asset:stylesheet href="main.css"/>
<asset:link rel="shortcut icon" href="favicon.ico" type="image/x-icon"/>

Any other ${resources} images, replace with <asset:image src=”– filename –“/>

Delete ApplicationResources.groovy

Step: Add jQuery dependency

cmd> cd c:/projects/angrails/grails-app/assets
cmd> bower install jquery
cmd> bower install angular

That will create bower_components directory and the js libraries (inside grails-app/assets/bower_components)

Step: Add Javascript dependencies

Edit grails-app/assets/javascripts/application.js

Replace the content with:

//= require jquery/dist/jquery
//= require angular/angular
//= require_tree views
//= require_self
console.log("angrails manifest load complete.");

Note that when using //=require you do not specify the bower_components directory. Asset-pipeline plugin skips the first directory after grails-app/assets.

cmd> grails run-app
Goto http://localhost:8080/angrails

End of Part 1: We have installed AngularJS and asset-pipeline for a Grails app.

In Part 2, we shall install Karma Test Runner for testing AngularJS javascripts.

Validating Map values using Grails constraints

In a recent Grails project, we came up with a requirement where we could collect arbitrary input data from a form and validate them in the Grails controller.

There are several validation techniques and initially I was thinking of creating various standard validation closures (like isEmpty, isNull, hasLength etc) on the map key name and execute them at runtime. By my coworker proposed an idea to use the Grails constraints directly instead of standard validation closures. I liked the idea, because a) it allows reuse of existing constraints and validate it the “Grails-way” and b) It is trivial to create custom constraints.

CommandObject

@Validateable
class DynamicFields {
  Map responses = [:]
}

Controller

class DynamicFieldsController {
def submit() {
  DynamicFields fields = new DynamicFields()
  fields.responses.putAll(params)

  //for illustration, imagine the fields.responses has a key called "firstName" whose value has to be validated
  ConstrainedProperty constrainedProperty = new ConstrainedProperty(DynamicFields, "firstName", String)
  constrainedProperty.applyConstraint("blank", false)
  constrainedProperty.validate(fields, params.firstName, fields.getErrors()) //getErrors() is available  because of @Validateable
  fields.errors.each { println it }
}
}

Problem

The (pseudo) execution stack now is validate() -> processValidate() -> AbstractConstraint.rejectValue -> BeanWrapperImpl.getPropertyValue() -> java.beans.PropertyDescriptor.getMethod() that throws a “NotReadablePropertyException”.

Obviously the java beans framework cannot find the firstName property. I tried several variations on the DynamicFields class: propertyMissing(), @Override getProperty(), setProperty(), metaclass.getProperty(), even AbstractConstraint.metaClass.rejectValue() – none of them were respected by the java beans. Well obviously, because the Grails magic does all this via GroovyObjectSupport, but the underlying Java Beans framework does not know about it.

Solution

Remember that Errors and BindingResult are interfaces and the concrete implementation is provided by AbstractBindingResult and its subclasses. By default Spring uses the BeanPropertyBindingResult for tying back the validation error to the field. From the hierarchy of these classes, I saw the MapBindingResult class, which binds the validation to a target map. Just what I wanted.

So I changed the controller to

DynamicFields fields = new DynamicFields()
fields.responses.putAll(params)
fields.setErrors(new MapBindingResult(fields.responses, DynamicFields.class.getName()))

This cleanly tied the errors to the individual map keys.

Displaying the errors also is trivial:

<g:hasErrors bean="${fields?.errors}">
<g:eachError><p>${it}</p></g:EachError>
</g:hasErrors/>

A cleaner solution is probably to create an AST that ensures that the setErrors (MapBindingResult) is done always or a better way of injecting MapBindingResult into Errors.

In fact, even without Map responses object, using Groovy’s Expando, one can directly store values in the DynamicFields class and validate them. Power of dynamic programming – ensuring valid data is collected even for “non-existent” attributes !