Building a Simple Web Application with Spring Boot and Groovy

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:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>
    <version>2.2.6.RELEASE</version>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
    <version>2.2.6.RELEASE</version>
</dependency>
<dependency>
    <groupId>org.codehaus.groovy</groupId>
    <artifactId>groovy</artifactId>
    <version>3.0.3</version>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <version>2.2.6.RELEASE</version>
    <scope>test</scope>
</dependency>
<dependency>
    <groupId>com.h2database</groupId>
    <artifactId>h2</artifactId>
    <version>1.4.200</version>
    <scope>runtime</scope>
</dependency>

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:

<build>
    <plugins>
        //...
        <plugin>
            <groupId>org.codehaus.gmavenplus</groupId>
            <artifactId>gmavenplus-plugin</artifactId>
            <version>1.9.0</version>
            <executions>
                <execution>
                    <goals>
                        <goal>addSources</goal>
                        <goal>addTestSources</goal>
                        <goal>generateStubs</goal>
                        <goal>compile</goal>
                        <goal>generateTestStubs</goal>
                        <goal>compileTests</goal>
                        <goal>removeStubs</goal>
                        <goal>removeTestStubs</goal>
                    </goals>
                </execution>
            </executions>
        </plugin>
    </plugins>
</build>

2.2. JPA Entity Class

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

@Entity
@Table(name = 'todo')
class Todo {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    Integer id
    
    @Column
    String task
    
    @Column
    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:

@Repository
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:

@Service
class TodoServiceImpl implements TodoService {

    //...
    
    @Override
    List<Todo> findAll() {
        todoRepository.findAll()
    }

    @Override
    Todo findById(Integer todoId) {
        todoRepository.findById todoId get()
    }
    
    @Override
    Todo saveTodo(Todo todo){
        todoRepository.save todo
    }
    
    @Override
    Todo updateTodo(Todo todo){
        todoRepository.save todo
    }
    
    @Override
    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:

@RestController
@RequestMapping('todo')
public class TodoController {

    @Autowired
    TodoService todoService

    @GetMapping
    List<Todo> getAllTodoList(){
        todoService.findAll()
    }

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

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

    @DeleteMapping('/{todoId}')
    deleteTodo(@PathVariable Integer todoId){
        todoService.deleteTodo todoId
    }

    @GetMapping('/{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:

@SpringBootApplication
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:

<properties>
    <start-class>com.baeldung.app.SpringBootGroovyApplication</start-class>
</properties>

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:

spring-boot:run

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:

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

    final Response readingResponse = 
      RestAssured.given()
        .contentType(MediaType.APPLICATION_JSON_VALUE)
        .body(readingTodo).post(API_ROOT)
          
    Todo cookingTodoResponse = readingResponse.as Todo.class
    readingTodoId = cookingTodoResponse.getId()

    final Response writingResponse = 
      RestAssured.given()
        .contentType(MediaType.APPLICATION_JSON_VALUE)
        .body(writingTodo).post(API_ROOT)
          
    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:

@Test
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:

@Test
void whenGetTodoById_thenOk(){
    final Response response = 
      RestAssured.get("$API_ROOT/$readingTodoId")
    
    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:

@Test
void whenUpdateTodoById_thenOk(){
    Todo todo = new Todo(id:readingTodoId, isCompleted: true)
    final Response response = 
      RestAssured.given()
        .contentType(MediaType.APPLICATION_JSON_VALUE)
        .body(todo).put(API_ROOT)
          
    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:

@Test
void whenDeleteTodoById_thenOk(){
    final Response response = 
      RestAssured.given()
        .delete("$API_ROOT/$writingTodoId")
    
    assertEquals HttpStatus.OK.value(),response.getStatusCode()
}

Finally, we can save a new task:

@Test
void whenSaveTodo_thenOk(){
    Todo todo = new Todo(task: 'Blogging', isCompleted: false)
    final Response response = 
      RestAssured.given()
        .contentType(MediaType.APPLICATION_JSON_VALUE)
        .body(todo).post(API_ROOT)
          
    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.