> ## Content Index
> Fetch the complete content index at: https://www.sfeir.dev/llms.txt
> Use this file to discover other available public pages before exploring further.

# Comment créer son projet Spring Boot de zéro !
- URL: https://www.sfeir.dev/back/creer-son-projet-spring-boot-de-zero/
- Published: 2023-10-27T07:55:32.000Z
- Updated: 2023-10-27T08:10:02.000Z
- Description: Débutant ou expert, lancer un projet Spring Boot de zéro n'a jamais été aussi simple !
- Author: Yves Dautremay
- Tags: Back, Java, Spring Boot

Que l'on soit en train d'apprendre le framework, ou que l'on ait besoin de commencer un nouveau projet, la démarche est la même, et elle est très simple !

## Spring Initializr

On va éviter de commencer un projet en copiant un ancien sur lequel on aurait déjà travaillé. **Repartir de zéro** nous permettra de commencer sur des bases propres, avec les dernières versions des librairies et composants. Spring nous propose un outil pour packager l'initialisation du projet, avec tous les modules dont on pourrait avoir besoin : **Spring Initializr.** Cela se passe sur [start.spring.io](https://start.spring.io/?ref=sfeir.dev)

![](https://storage.ghost.io/c/0b/31/0b31478e-a66a-46f1-8c34-d44388e21192/content/images/2023/10/Spring-Initializr-2.jpg)

On peut laisser les options de gauche par défaut. J'ai personnellement une préférence pour Maven, et le choix de Java 21.

A droite, on va choisir les composants qui correspondent à nos besoin. Tous les composants Spring s'y trouvent, faites votre marché ! On va rester simple et choisir

- **Spring Web**, pour un test simple
- **Spring Data JPA**, pour utiliser une BDD
- **H2 Database**, une BDD in memory

On clique en bas sur ***Generate***, ça télécharge un zip, à dé-zipper et ouvrir en tant que projet dans votre IDE préféré. Pour moi, c'est **IntelliJ**

![](https://storage.ghost.io/c/0b/31/0b31478e-a66a-46f1-8c34-d44388e21192/content/images/2023/10/demo.jpg)

Deux éléments importants ont été générés

- Le fichiers des dépendances, ici le **pom.xml** pour maven
- La méthode main contenue dans la classe **DemoApplication**

Cela suffit pour démarrer l'application !

## Ajoutons une resource REST

Créons un package *controller* et une classe *HelloResource* à l'intérieur.

```java
package com.example.demo.controller;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class HelloResource {

    @GetMapping("/hello")
    public String hello(String param){
        return "Hello " + param;
    }
}

```

On peut démarrer l'application et appeler l'URL [http://localhost:8080/hello?param=World](http://localhost:8080/hello?param=World&ref=sfeir.dev)

```
Hello World
```

## Ajoutons une base de données

Créons un package *domain* et une Entité Hello

```java
package com.example.demo.domain;

import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.GenerationType;
import jakarta.persistence.Id;

@Entity
public class Hello {

    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private Long id;

    private String param;

    public Hello(){}

    public Hello(String param){
        this.param = param;
    }

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getParam() {
        return param;
    }

    public void setParam(String param){
        this.param = param;
    }
}

```

Et son *Repository*

```java
package com.example.demo.domain;

import org.springframework.data.jpa.repository.JpaRepository;

public interface HelloRepository extends JpaRepository<Hello, Long> {
}

```

Dans le package controller, on crée le record DTO associé

```java
package com.example.demo.controller;

public record HelloDto(Long id, String param) {
}

```

On peut maintenant injecter le Repository dans la Ressource et ajouter une méthode de création et de lecture par id

```java
package com.example.demo.controller;

import com.example.demo.domain.Hello;
import com.example.demo.domain.HelloRepository;
import org.springframework.web.bind.annotation.*;

@RestController
public class HelloResource {

    private final HelloRepository helloRepository;

    public HelloResource(HelloRepository helloRepository) {
        this.helloRepository = helloRepository;
    }

    @GetMapping("/hello")
    public String hello(String param){
        return "Hello " + param;
    }

    @PostMapping("/hello")
    public HelloDto create(@RequestBody HelloDto helloDto){
        Hello hello = helloRepository.save(new Hello(helloDto.param()));
        return new HelloDto(hello.getId(), hello.getParam());
    }

    @GetMapping("/hello/{id}")
    public HelloDto get(@PathVariable Long id){
        Hello hello = helloRepository.findById(id).orElseThrow();
        return new HelloDto(hello.getId(), hello.getParam());
    }
}

```

Relançons l'application. On peut maintenant créer un objet Hello sur l'URL [http://localhost:8080/hello](http://localhost:8080/hello?ref=sfeir.dev) en POST avec le body

```json
{
  "param": "World !"
}
```

Réponse :

```json
{
  "id": 1,
  "param": "World !"
}
```

On peut alors requêter l'URL [http://localhost:8080/hello/1](http://localhost:8080/hello/1?ref=sfeir.dev)

Réponse :

```json
{
  "id": 1,
  "param": "World !"
}
```

## Et ensuite ?

Il est très simple d'ajouter des composants Spring que l'on **n'aurait pas ajoutés** à l'initialisation en important les dépendances sur les starters. Un **starter** est un package tout configuré d'un composant Spring. Par exemple, on peut ajouter Sp**ring Security** avec Maven

```xml
<dependencies>
	<!-- ... other dependency elements ... -->
	<dependency>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-security</artifactId>
	</dependency>
</dependencies>
```

Cela ajoutera Spring Security avec son auto-configuration et toutes ses dépendances dans les bonnes versions.