Java Micronaut в Docker: контейнеризация с Maven и Jib

@Controller("/hello")
public class HelloController {
    
    @Get
    public String sayHello() {
        return "Hello, Micronaut with Docker!";
    }
}

@Controller("/reactive")
public class ReactiveController {
    
    @Get
    public Flux<String> getReactiveData() {
        return Flux.just("Micronaut", "доказывает", "свою", "эффективность",
                         "в", "реактивных", "сценариях");
    }
}

@Client("/users")
public interface UserClient {
    @Get("/{id}")
    User getUser(Long id);
}

package com.example.micronautdocker;
 
import io.micronaut.runtime.Micronaut;
 
public class Application {
    public static void main(String[] args) {
        Micronaut.run(Application.class, args);
    }
}

package com.example.micronautdocker;
 
import io.micronaut.http.annotation.Controller;
import io.micronaut.http.annotation.Get;
 
@Controller("/hello")
public class HelloController {
 
    @Get
    public String sayHello() {
        return "Привет из Micronaut!";
    }
}

package com.example.micronautdocker.config;
 
import io.micronaut.context.annotation.ConfigurationProperties;
 
@ConfigurationProperties("app.service")
public class ServiceConfiguration {
    private String endpoint;
    private int timeout = 30;
    
    // Геттеры и сеттеры
    public String getEndpoint() {
        return endpoint;
    }
    
    public void setEndpoint(String endpoint) {
        this.endpoint = endpoint;
    }
    
    public int getTimeout() {
        return timeout;
    }
    
    public void setTimeout(int timeout) {
        this.timeout = timeout;
    }
}

package com.example.micronautdocker.service;
 
import com.example.micronautdocker.config.ServiceConfiguration;
import jakarta.inject.Singleton;
 
@Singleton
public class ExternalService {
    private final ServiceConfiguration config;
    
    public ExternalService(ServiceConfiguration config) {
        this.config = config;
    }
    
    public void doSomething() {
        System.out.println("Подключение к " + config.getEndpoint() + 
                           " с таймаутом " + config.getTimeout() + " сек.");
        // Реальная логика здесь...
    }
}

package com.example.micronautdocker.model;
 
import io.micronaut.serde.annotation.Serdeable;
 
@Serdeable
public class Product {
    private Long id;
    private String name;
    private String description;
    private Double price;
    
    // Конструкторы
    public Product() {}
    
    public Product(Long id, String name, String description, Double price) {
        this.id = id;
        this.name = name;
        this.description = description;
        this.price = price;
    }
    
    // Геттеры и сеттеры
    public Long getId() { return id; }
    public void setId(Long id) { this.id = id; }
    
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    
    public String getDescription() { return description; }
    public void setDescription(String description) { this.description = description; }
    
    public Double getPrice() { return price; }
    public void setPrice(Double price) { this.price = price; }
}

package com.example.micronautdocker.service;
 
import com.example.micronautdocker.model.Product;
import jakarta.inject.Singleton;
import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicLong;
 
@Singleton
public class ProductService {
    private final ConcurrentHashMap<Long, Product> products = new ConcurrentHashMap<>();
    private final AtomicLong idGenerator = new AtomicLong(0);
    
    public ProductService() {
        // Добавим несколько тестовых продуктов
        addProduct(new Product(null, "Ноутбук", "Мощный ноутбук для разработки", 1299.99));
        addProduct(new Product(null, "Монитор", "27-дюймовый 4K монитор", 349.99));
        addProduct(new Product(null, "Клавиатура", "Механическая клавиатура", 89.99));
    }
    
    public Product addProduct(Product product) {
        if (product.getId() == null) {
            product.setId(idGenerator.incrementAndGet());
        }
        products.put(product.getId(), product);
        return product;
    }
    
    public List<Product> getAllProducts() {
        return new ArrayList<>(products.values());
    }
    
    public Optional<Product> getProductById(Long id) {
        return Optional.ofNullable(products.get(id));
    }
    
    public boolean updateProduct(Product product) {
        if (product.getId() == null || !products.containsKey(product.getId())) {
            return false;
        }
        products.put(product.getId(), product);
        return true;
    }
    
    public boolean deleteProduct(Long id) {
        return products.remove(id) != null;
    }
}

package com.example.micronautdocker.controller;
 
import com.example.micronautdocker.model.Product;
import com.example.micronautdocker.service.ProductService;
import io.micronaut.http.HttpResponse;
import io.micronaut.http.HttpStatus;
import io.micronaut.http.annotation.*;
import jakarta.inject.Inject;
import java.util.List;
 
@Controller("/api/products")
public class ProductController {
    private final ProductService productService;
    
    @Inject
    public ProductController(ProductService productService) {
        this.productService = productService;
    }
    
    @Get
    public List<Product> getAllProducts() {
        return productService.getAllProducts();
    }
    
    @Get("/{id}")
    public HttpResponse<Product> getProduct(Long id) {
        return productService.getProductById(id)
            .map(HttpResponse::ok)
            .orElse(HttpResponse.notFound());
    }
    
    @Post
    public HttpResponse<Product> addProduct(@Body Product product) {
        return HttpResponse.created(productService.addProduct(product));
    }
    
    @Put("/{id}")
    public HttpResponse updateProduct(Long id, @Body Product product) {
        product.setId(id);
        if (productService.updateProduct(product)) {
            return HttpResponse.ok();
        }
        return HttpResponse.notFound();
    }
    
    @Delete("/{id}")
    public HttpResponse deleteProduct(Long id) {
        if (productService.deleteProduct(id)) {
            return HttpResponse.ok();
        }
        return HttpResponse.notFound();
    }
}

package com.example.micronautdocker.test;
 
import io.micronaut.http.client.HttpClient;
import io.micronaut.http.client.annotation.Client;
import io.micronaut.test.extensions.junit5.annotation.MicronautTest;
import jakarta.inject.Inject;
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.*;
 
@MicronautTest
public class ProductControllerTest {
    @Inject
    @Client("/")
    HttpClient client;
    
    @Test
    void testGetAllProducts() {
        var response = client.toBlocking().exchange("/api/products");
        assertEquals(200, response.code());
    }
    
    // Другие тесты...
}

@Testcontainers
@MicronautTest
public class DockerizedIntegrationTest {
    
    @Container
    static GenericContainer<?> app = new GenericContainer<>("micronaut-app:latest")
        .withExposedPorts(8080);
    
    @Test
    void testApplicationInContainer() {
        String url = String.format("http://%s:%d/api/products", 
                                   app.getHost(), 
                                   app.getMappedPort(8080));
        
        RestAssured.given()
            .when()
            .get(url)
            .then()
            .statusCode(200);
    }
}