1. Overview

Groovy has a number of capabilities we might want to use in our Spring web applications.

So, in this tutorial, we'll build a simple todo application with Spring Boot and Groovy. Also, we'll explore their integration points.

2. Todo Application

Our application will have the following features:

  • Create task
  • Edit task
  • Delete task
  • View specific task
  • View all tasks

It'll be a REST-based application and we'll use Maven as our build tool.

2.1. Maven Dependencies

Let's include all the dependencies required in our pom.xml file:


Here, we're including spring-boot-starter-web to build REST endpoints, and importing the groovy dependency to provide Groovy support to our project.

For the persistence layer, we're using spring-boot-starter-data-jpa, and h2 is the embedded database.

Also, we've got to include gmavenplus-plugin with all the goals in the pom.xml:


2.2. JPA Entity Class

Let's write a simple Todo Groovy class with three fields – id, task, and isCompleted:

@Table(name = 'todo')
class Todo {
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    Integer id
    String task
    Boolean isCompleted

Here, the id field is the unique identifier of the task. task contains the details of the task and isCompleted shows whether the task is completed or not.

Notice that, when we don't provide access modifiers to the field, then the Groovy compiler will make that field as private and also will generate getter and setter methods for it.

2.3. The Persistence Layer

Let's create a Groovy interface – TodoRepository which implements JpaRepository. It'll take care of all the CRUD operations in our application:

interface TodoRepository extends JpaRepository<Todo, Integer> {}

2.4. The Service Layer

The TodoService interface contains all the abstract methods required for our CRUD operation:

interface TodoService {

    List<Todo> findAll()

    Todo findById(Integer todoId)

    Todo saveTodo(Todo todo)

    Todo updateTodo(Todo todo)

    Todo deleteTodo(Integer todoId)

The TodoServiceImpl is an implementation class which implements all the methods of TodoService:

class TodoServiceImpl implements TodoService {

    List<Todo> findAll() {

    Todo findById(Integer todoId) {
        todoRepository.findById todoId get()
    Todo saveTodo(Todo todo){
        todoRepository.save todo
    Todo updateTodo(Todo todo){
        todoRepository.save todo
    Todo deleteTodo(Integer todoId){
        todoRepository.deleteById todoId

2.5. The Controller Layer

Now, let's define all the REST APIs in the TodoController which is our @RestController:

public class TodoController {

    TodoService todoService

    List<Todo> getAllTodoList(){

    Todo saveTodo(@RequestBody Todo todo){
        todoService.saveTodo todo

    Todo updateTodo(@RequestBody Todo todo){
        todoService.updateTodo todo

    deleteTodo(@PathVariable Integer todoId){
        todoService.deleteTodo todoId

    Todo getTodoById(@PathVariable Integer todoId){
        todoService.findById todoId

Here, we've defined five endpoints which user can call to perform CRUD operations.

2.6. Bootstrapping the Spring Boot Application

Now, let's write a class with the main method that will be used to start our application:

class SpringBootGroovyApplication {
    static void main(String[] args) {
        SpringApplication.run SpringBootGroovyApplication, args

Notice that, in Groovy, the use of parenthesis is optional when calling a method by passing arguments – and this is what we're doing in the example above.

Also, the suffix .class is not needed for any class in Groovy that's why we're using the SpringBootGroovyApplication directly.

Now, let's define this class in pom.xml as start-class:


3. Running the Application

Finally, our application is ready to run. We should simply run the SpringBootGroovyApplication class as the Java application or run the Maven build:


This should start the application on http://localhost:8080 and we should be able to access its endpoints.

4. Testing the Application

Our application is ready for testing. Let's create a Groovy class – TodoAppTest to test our application.

4.1. Initial Setup

Let's define three static variables – API_ROOT, readingTodoId, and writingTodoId in our class:

static API_ROOT = "http://localhost:8080/todo"
static readingTodoId
static writingTodoId

Here, the API_ROOT contains the root URL of our app. The readingTodoId and writingTodoId are the primary keys of our test data which we'll use later to perform testing.

Now, let's create another method – populateDummyData() by using the annotation @BeforeClass to populate the test data:

static void populateDummyData() {
    Todo readingTodo = new Todo(task: 'Reading', isCompleted: false)
    Todo writingTodo = new Todo(task: 'Writing', isCompleted: false)

    final Response readingResponse = 
    Todo cookingTodoResponse = readingResponse.as Todo.class
    readingTodoId = cookingTodoResponse.getId()

    final Response writingResponse = 
    Todo writingTodoResponse = writingResponse.as Todo.class
    writingTodoId = writingTodoResponse.getId()

We'll also populate variables – readingTodoId and writingTodoId in the same method to store the primary key of the records we're saving.

Notice that, in Groovy we can also initialize beans by using named parameters and the default constructor like we're doing for beans like readingTodo and writingTodo in the above snippet.

4.2. Testing CRUD Operations

Next, let's find all the tasks from the todo list:

void whenGetAllTodoList_thenOk(){
    final Response response = RestAssured.get(API_ROOT)
    assertEquals HttpStatus.OK.value(),response.getStatusCode()
    assertTrue response.as(List.class).size() > 0

Then, let's find a specific task by passing readingTodoId which we've populated earlier:

void whenGetTodoById_thenOk(){
    final Response response = 
    assertEquals HttpStatus.OK.value(),response.getStatusCode()
    Todo todoResponse = response.as Todo.class
    assertEquals readingTodoId,todoResponse.getId()

Here, we've used interpolation to concatenate the URL string.

Furthermore, let's try to update the task in the todo list by using readingTodoId:

void whenUpdateTodoById_thenOk(){
    Todo todo = new Todo(id:readingTodoId, isCompleted: true)
    final Response response = 
    assertEquals HttpStatus.OK.value(),response.getStatusCode()
    Todo todoResponse = response.as Todo.class
    assertTrue todoResponse.getIsCompleted()

And then delete the task in the todo list by using writingTodoId:

void whenDeleteTodoById_thenOk(){
    final Response response = 
    assertEquals HttpStatus.OK.value(),response.getStatusCode()

Finally, we can save a new task:

void whenSaveTodo_thenOk(){
    Todo todo = new Todo(task: 'Blogging', isCompleted: false)
    final Response response = 
    assertEquals HttpStatus.OK.value(),response.getStatusCode()

5. Conclusion

In this article, we've used Groovy and Spring Boot to build a simple application. We've also seen how they can be integrated together and demonstrated some of the cool features of Groovy with examples.

As always, the full source code of the example is available over on GitHub.

Generic bottom

I just announced the new Learn Spring course, focused on the fundamentals of Spring 5 and Spring Boot 2:

Comments are closed on this article!