Créer une application Web simple avec Spring Boot et Groovy

1. Vue d'ensemble

Groovy dispose d'un certain nombre de fonctionnalités que nous souhaitons peut-être utiliser dans nos applications Web Spring.

Donc, dans ce didacticiel, nous allons créer une application todo simple avec Spring Boot et Groovy. Nous explorerons également leurs points d'intégration.

2. Application Todo

Notre application aura les fonctionnalités suivantes:

  • Créer une tâche
  • Modifier la tâche
  • Supprimer la tâche
  • Afficher une tâche spécifique
  • Afficher toutes les tâches

Ce sera une application basée sur REST et nous utiliserons Maven comme outil de construction .

2.1. Dépendances de Maven

Incluons toutes les dépendances requises dans notre fichier pom.xml :

 org.springframework.boot spring-boot-starter-data-jpa 2.2.6.RELEASE   org.springframework.boot spring-boot-starter-web 2.2.6.RELEASE   org.codehaus.groovy groovy 3.0.3   org.springframework.boot spring-boot-starter-test 2.2.6.RELEASE test   com.h2database h2 1.4.200 runtime 

Ici, nous y compris le printemps-boot-démarreur Web pour construire points d' extrémité REST , et l' importation de la groovy dépendance à fournir un soutien Groovy à notre projet .

Pour la couche de persistance, nous utilisons spring-boot-starter-data-jpa , et h2 est la base de données intégrée .

De plus, nous devons inclure gmavenplus-plugin avec tous les objectifs dans le pom.xml:

  //...  org.codehaus.gmavenplus gmavenplus-plugin 1.9.0    addSources addTestSources generateStubs compile generateTestStubs compileTests removeStubs removeTestStubs      

2.2. Classe d'entité JPA

Écrivons une classe Todo Groovy simple avec trois champs - id , task et isCompleted :

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

Ici, le champ id est l'identifiant unique de la tâche. task contient les détails de la tâche et isCompleted indique si la tâche est terminée ou non.

Notez que, lorsque nous ne fournissons pas de modificateurs d'accès au champ, le compilateur Groovy rendra ce champ privé et générera également des méthodes getter et setter pour celui-ci .

2.3. La couche de persistance

Créons une interface Groovy - TodoRepository qui implémente JpaRepository . Il s'occupera de toutes les opérations CRUD dans notre application:

@Repository interface TodoRepository extends JpaRepository {}

2.4. La couche de service

L' interface TodoService contient toutes les méthodes abstraites requises pour notre opération CRUD :

interface TodoService { List findAll() Todo findById(Integer todoId) Todo saveTodo(Todo todo) Todo updateTodo(Todo todo) Todo deleteTodo(Integer todoId) }

Le TodoServiceImpl est une classe de mise en œuvre qui met en œuvre toutes les méthodes de TodoService:

@Service class TodoServiceImpl implements TodoService { //... @Override List 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. La couche contrôleur

Maintenant, définissons toutes les API REST dans le TodoController qui est notre @RestController :

@RestController @RequestMapping('todo') public class TodoController { @Autowired TodoService todoService @GetMapping List 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 } }

Ici, nous avons défini cinq points de terminaison que l'utilisateur peut appeler pour effectuer des opérations CRUD.

2.6. Démarrage de l'application Spring Boot

Maintenant, écrivons une classe avec la méthode principale qui sera utilisée pour démarrer notre application:

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

Notez que, dans Groovy, l'utilisation de parenthèses est facultative lors de l'appel d'une méthode en passant des arguments - et c'est ce que nous faisons dans l'exemple ci-dessus.

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:

 com.baeldung.app.SpringBootGroovyApplication 

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 //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 = "//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

Dans cet article, nous avons utilisé Groovy et Spring Boot pour créer une application simple. Nous avons également vu comment ils peuvent être intégrés ensemble et démontré certaines des fonctionnalités intéressantes de Groovy avec des exemples.

Comme toujours, le code source complet de l'exemple est disponible à l'adresse over sur GitHub.