Frameworks Java¶

package com.example.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.*;

import java.util.List;

// Point d'entree de l'application
@SpringBootApplication
public class DemoApplication {
    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }
}

// Controleur REST simple
@RestController
@RequestMapping("/api/messages")
public class MessageController {

    // GET /api/messages — retourne une liste JSON
    @GetMapping
    public List<String> lister() {
        return List.of("Bonjour", "Hello", "Hola");
    }

    // POST /api/messages — recoit un corps JSON
    @PostMapping
    public String creer(@RequestBody String message) {
        return "Recu : " + message;
    }
}

package com.example;

import jakarta.inject.Inject;
import jakarta.ws.rs.*;
import jakarta.ws.rs.core.MediaType;
import jakarta.ws.rs.core.Response;

import java.util.List;

// Quarkus utilise JAX-RS pour les endpoints REST
@Path("/api/produits")
@Produces(MediaType.APPLICATION_JSON)
@Consumes(MediaType.APPLICATION_JSON)
public class ProduitResource {

    @Inject
    ProduitService service;

    // GET /api/produits
    @GET
    public List<Produit> lister() {
        return service.listerTous();
    }

    // GET /api/produits/{id}
    @GET
    @Path("/{id}")
    public Response trouver(@PathParam("id") Long id) {
        return service.trouverParId(id)
            .map(p -> Response.ok(p).build())
            .orElse(Response.status(Response.Status.NOT_FOUND).build());
    }

    // POST /api/produits
    @POST
    public Response creer(Produit produit) {
        Produit cree = service.creer(produit);
        return Response.status(Response.Status.CREATED).entity(cree).build();
    }
}

package com.example;

import io.micronaut.http.HttpResponse;
import io.micronaut.http.annotation.*;

import java.util.List;

// @Controller definit le prefixe de chemin
@Controller("/api/articles")
public class ArticleController {

    private final ArticleService service;

    // Injection par constructeur (recommande)
    public ArticleController(ArticleService service) {
        this.service = service;
    }

    // GET /api/articles
    @Get
    public List<Article> lister() {
        return service.listerTous();
    }

    // GET /api/articles/{id}
    @Get("/{id}")
    public HttpResponse<Article> trouver(Long id) {
        return service.trouverParId(id)
            .map(HttpResponse::ok)
            .orElse(HttpResponse.notFound());
    }

    // DELETE /api/articles/{id}
    @Delete("/{id}")
    public HttpResponse<Void> supprimer(Long id) {
        service.supprimer(id);
        return HttpResponse.noContent();
    }
}

package com.example;

import jakarta.enterprise.context.RequestScoped;
import jakarta.inject.Inject;
import jakarta.ws.rs.*;
import jakarta.ws.rs.core.MediaType;
import jakarta.persistence.*;

// CDI bean a portee requete
@RequestScoped
@Path("/commandes")
@Produces(MediaType.APPLICATION_JSON)
public class CommandeResource {

    @Inject
    private EntityManager em;  // JPA EntityManager injecte par le conteneur

    @GET
    public List<Commande> lister() {
        return em.createQuery("SELECT c FROM Commande c", Commande.class)
                 .getResultList();
    }
}

import jakarta.persistence.*;

// Entite JPA — mappee sur la table "utilisateurs"
@Entity
@Table(name = "utilisateurs")
public class Utilisateur {

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

    @Column(nullable = false, length = 100)
    private String nom;

    @Column(unique = true, nullable = false)
    private String email;
}

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

// Repository Spring Data — pas d'implementation a ecrire
public interface UtilisateurRepository extends JpaRepository<Utilisateur, Long> {

    // Requete derivee du nom de methode
    Optional<Utilisateur> findByEmail(String email);

    // JPQL explicite
    @Query("SELECT u FROM Utilisateur u WHERE u.nom LIKE %:terme%")
    List<Utilisateur> rechercherParNom(String terme);
}

import lombok.*;

// Genere : getters, setters, equals, hashCode, toString, constructeur tous args
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class ProduitDto {
    private Long id;
    private String nom;
    private Double prix;
}

// Utilisation du builder genere par Lombok
ProduitDto dto = ProduitDto.builder()
    .id(1L)
    .nom("Clavier")
    .prix(89.99)
    .build();

import org.mapstruct.*;

@Mapper(componentModel = "spring")  // Genere un bean Spring
public interface UtilisateurMapper {

    // Mapping direct si les noms de champs correspondent
    UtilisateurDto toDto(Utilisateur utilisateur);

    // Mapping inverse avec exclusion d'un champ
    @Mapping(target = "motDePasse", ignore = true)
    Utilisateur toEntity(UtilisateurDto dto);

    // Mapping de liste
    List<UtilisateurDto> toDtoList(List<Utilisateur> utilisateurs);
}

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.web.SecurityFilterChain;

@Configuration
@EnableWebSecurity
public class SecurityConfig {

    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
        return http
            .authorizeHttpRequests(auth -> auth
                .requestMatchers("/api/public/**").permitAll()
                .requestMatchers("/api/admin/**").hasRole("ADMIN")
                .anyRequest().authenticated()
            )
            .oauth2ResourceServer(oauth2 -> oauth2.jwt(jwt -> {}))
            .build();
    }
}