The GroovySpringBootBatchGormGroovyDslBeanFactory

See spring-boot-batch-sample at github for the updated source code.

I was recently working on setting up a not-so-trivial Spring Batch application and wanted to use SpringBoot, because of its embeded-web container capabilities. I could have used Grails and Spring Batch plugin, but wanted to give an opportunity for our Ops/DevOps team a peek at running and maintaining apps via plain “java -jar”. I hadn’t used Spring since 2009 (switching between SharePoint and Grails). Xml is no more a necessity for Spring and it has good support for java annotation configuration. But I am not very comfortable with annotation oriented programming. Xml provided the separation of wiring dependencies from code, but its verbose. Annotations are less verbose, but allows to mix configurations, logic and code, which I feel can spiral out of control pretty soon. I still feel wiring dependencies independently of “code” is a very desirable feature for large applications. Both xml and annotations seem to be at opposite ends of the spectrum.

Fortunately there is a middle ground. SpringBoot provides support for Groovy beans dsl, via the GroovyBeanDefinitionReader. Groovy bean dsls solve the problems of xml and annotations: DI wiring + concise readable syntax + some logic (eg environment-based). But this comes at a price of loosing type-safety. I am surprised that groovy dsl has not yet gone mainstream with Spring apps. If Spring comes with a Groovy DSLD schema (may be there is one already?), it could be a killer feature. For example, Spring Integration is already offering a dsl based “workflow”, which is pretty elegant to read, write and maintain.

I was also new to SpringBatch so it took a while to get them all wired up. So here is a starting point, if you want to use Groovy lang + SpringBoot + SpringBatch + Groovy DSL + Gorm. I haven’t figured out dsl equivalents of @EnableScheduling and @Scheduled yet.

Part 1: appcontext.groovy

//Note that config is not defined as a bean, but directly evaluated and then injected into other beans
//the 'grailsApplication' equivalent
ConfigObject configObject = new ConfigSlurper().parse(Config)

//Note the syntax beans {} not beans = {} like in Grails resources.groovy
beans {

	xmlns([ctx: 'http://www.springframework.org/schema/context', batch: 'http://www.springframework.org/schema/batch'])
	ctx.'component-scan'('base-package': 'org.mypackage')
	ctx.'annotation-config'()

	myController(MyController) {
		config = configObject 
	}

	myService(MyService) {
		config = configObject 
  }

  //MyItemReader implements ItemReader
	myItemReader(MyItemReader) { bean ->
		bean.initMethod = 'init' //required if initializing some data from external dao
		bean.scope = 'step' //for job restartability
	}

	myItemProcessor(MyItemProcessor) {
		myService = ref('myService')
	}

	myItemWriter(FlatFileItemWriter) {
		lineAggregator = new DelimitedLineAggregator(delimiter: ',', fieldExtractor: new BeanWrapperFieldExtractor(names: ["id", "title"]))
		resource = '/apps/springboot/myproject/output'
	}

  //create a job
	batch.job(id: 'job1') {
		batch.step(id: 'step1') {
			batch.tasklet {
				batch.chunk(
					reader: 'myItemReader',
					writer: 'myItemWriter',
					processor: 'myItemProcessor',
					'commit-interval': 10
				)
			}
		}
	}

  //the following beans are minimum mandate because there is no equivalent of xml's <batch:job-repository /> in groovy dsl
  //http://stackoverflow.com/questions/23436477/groovy-bean-syntax-for-spring-batch-job-repository
  //thanks to https://github.com/johnrengelman/grails-spring-batch/blob/master/SpringBatchGrailsPlugin.groovy for the bean definitions
	jobRepository(MapJobRepositoryFactoryBean) {
		transactionManager = ref('transactionManager')
	}

	jobRegistry(MapJobRegistry) { }

	jobLauncher(SimpleJobLauncher) {
		jobRepository = ref('jobRepository')
		taskExecutor = { SyncTaskExecutor executor -> }
	}

	jobExplorer(JobExplorerFactoryBean) {
    //dataSource is auto-configured
		dataSource = ref('dataSource')
	}

	jobOperator(SimpleJobOperator) {
		jobLauncher = ref('jobLauncher')
		jobRepository = ref('jobRepository')
		jobRegistry = ref('jobRegistry')
		jobExplorer = ref('jobExplorer')
	}

}

Part 2: Application and Scheduler

@Configuration
@ComponentScan
@EnableAutoConfiguration
@EnableScheduling
class MyJobApplication {

	private static final Logger logger = LoggerFactory.getLogger(MyJobApplication.class.getName())

	@Autowired
	JobLauncher jobLauncher

	@Autowired
	Job myJob

//  You can also create configObject bean like this and refer back in beans.groovy using ref('config')
//	@Bean(name="config")
//	ConfigObject configObject() {
//		return new ConfigSlurper().parse(Config)
//	}

	
  @Scheduled(fixedDelayString = '${myJobFixedDelay}', initialDelayString = '${myJobInitialDelay}')
	public void startMyJob() {
		logger.info "startMyJob()"
    //Add time if your job runs repeatedly on different parameters - this will make it an unique entry in the batch-job tables
		JobParameters jobParameters = new JobParametersBuilder().addLong("time",System.currentTimeMillis()).toJobParameters()
		jobLauncher.run(myJob, jobParameters)
	}

	public static void main(String[] args) {
		logger.info "Starting MyJobApplication..."
		Object[] sources = [MyJobApplication.class, new ClassPathResource("appcontext.groovy")]
		SpringApplication.run(sources, args);
	}
}

Part 3: Datasource

Datasource bean is autoconfigured via @EnableAutoConfiguration and if you define the application.properties (or application.yaml). Just add the right driver in your build.gradle. If you dont specify any, hsql db is used.

Part 4: build.gradle

buildscript {
	ext {
		springBootVersion = '1.0.2.RELEASE'
		spockVersion = '0.7-groovy-2.0'
	}
	repositories {
		mavenLocal()
		mavenCentral()
		maven { url "http://repo.spring.io/libs-snapshot" }
	}
	dependencies {
		classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
	}
}

apply plugin: 'groovy'
apply plugin: 'idea'
apply plugin: 'spring-boot'

jar {
	baseName = 'myapp'
	version = '0.1'
}

repositories {
	mavenCentral()
	mavenLocal()
	maven { url "http://repo.spring.io/libs-snapshot" }
}

dependencies {
	compile("org.springframework.boot:spring-boot-starter-web")
	//if you want to use Jetty, instead of Tomcat, replace the above line with the next two lines
	//compile("org.springframework.boot:spring-boot-starter-web:${springBootVersion}") { exclude module: "spring-boot-starter-tomcat" }
	//compile("org.springframework.boot:spring-boot-starter-jetty:0.5.0.M2")
	compile("org.springframework.boot:spring-boot-starter-actuator")
	compile("org.springframework.boot:spring-boot-starter-batch")
	compile("org.springframework.boot:spring-boot-starter-logging")
	compile("org.springframework.boot:spring-boot-starter-jdbc")

  compile("org.codehaus.groovy:groovy-all:2.2.2")
	
  compile("org.springframework:spring-orm:4.0.3.RELEASE")
  //For those Grails guys, just throw in the new and shiny standalone gorm dependency
	compile("org.grails:gorm-hibernate4-spring-boot:1.0.0.RC3") {
    //currently brings in spring-orm:3.2.8, exclude it and explicitly include new one above
		exclude module: 'spring-orm'
	}

	testCompile "org.springframework.boot:spring-boot-starter-test"
	testCompile "org.spockframework:spock-core:${spockVersion}"
	testCompile "org.spockframework:spock-spring:${spockVersion}"
}

task wrapper(type: Wrapper) {
	gradleVersion = '1.11'
}

A few more features for the future:

1. Defining multiple datasources in groovy dsl
2. Using spring-loaded for hot-swapping runtime (as of now I can’t get this to work with Intellij Idea)
3. Using Spring-batch-admin to control jobs via UI

Advertisements

Spring Boot with Groovy config

While working on converting a Grails application to a SpringBoot based application, I was trying to understand how the auto configurations and custom configurations work under the hood. Just like CoC of Groovy/Grails, there seems to be a lot of hide-and-seek going on under the Spring boot hood. Admittedly its been a while for me with good ol’ raw Spring, so the many different ways of skinning the configuration felt a bit overwhelming. I counted several concepts around configurations – application.properties, application.yaml, PropertySource, PropertyPlaceHolder, @Value, @EnableConfiguration, @EnableConfigurationProperties, @EnableAutoConfiguration, @Configuration, @ConfigurationProperties, pre-defined property name prefixes, creating classes specifically for holding configuration values – so much information just for accessing key-value pairs? Compare to Grails – one Config.groovy (or multiple externalized) and a simple grailsApplication injection takes care of making configuration available anywhere. When I read Spring Boot support for Groovy, I somehow assumed that support for a groovy config is automatically enabled.

My Grails application already had a groovy config, and I was not in a mood to convert them to .properties or .yaml. Groovy configs are DSLs in essence – it provides many advantages over the traditional properties file: key=value (like .properties), a structured format like .yaml – sans the indent-erasure-phobia, type-enriched config values like list/map etc, functions via closures and more.

So, here is a very simple way to expose the groovy config to your Spring Boot apps:

Create a Config.groovy in the same folder as the ConfigProperties class.

/** Config.groovy **/

//simple key-value
spring.boot.guide = 'https://github.com/spring-guides?page=1'
//formatted structure
google {
searchurl = 'http://www.google.com'
apiKey = '1234'
}

/** ConfigProperties.groovy **/

import org.springframework.context.annotation.Bean
import org.springframework.context.annotation.Configuration

@Configuration
class ConfigProperties {

@Bean(name="configObject")
ConfigObject configObject() {
return new ConfigSlurper().parse(Config)
}

}
/** HelloController.groovy **/

import ConfigProperties
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.web.bind.annotation.RequestMapping
import org.springframework.web.bind.annotation.RestController

@RestController
class HelloController {
@Autowired
ConfigObject configObject

@RequestMapping("/")
String home() {
return "Hello World! " + configObject.spring.boot.guide
}

}

/** Application.groovy **/

@EnableAutoConfiguration
@ComponentScan
class Application {
static void main(String[] args) {
Object[] sources = [Application.class, ConfigProperties.class]
SpringApplication.run(sources, args)
}
}

Note: @Bean returns must be typed. Habitually, I wrote def configObject() { return new ConfigSlurper().parse(Config) } and the @Autowired did not wire it up.

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 -&gt;
 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(&quot;success: &quot; + data);
					$scope.starCatalog = data;
				}).error(function (data) {
					console.log(&quot;error: &quot; + 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:

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

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.