Гексагональная архитектура со Spring Boot

public class Task {
    private TaskId id;
    private String title;
    private String description;
    private TaskStatus status;
    private UserId assigneeId;
    
    // Конструкторы, геттеры и методы с бизнес-логикой
    
    public void assignTo(UserId userId) {
        this.assigneeId = userId;
        // Дополнительная бизнес-логика при назначении задачи
    }
    
    public void complete() {
        if (this.status != TaskStatus.IN_PROGRESS) {
            throw new IllegalStateException("Только задачи в работе могут быть завершены");
        }
        this.status = TaskStatus.COMPLETED;
        // Другие побочные эффекты при завершении задачи
    }
}

public interface TaskService {
    TaskId createTask(String title, String description);
    Task getTask(TaskId id);
    void assignTask(TaskId taskId, UserId assigneeId);
    void completeTask(TaskId taskId);
    List<Task> findTasksByAssignee(UserId assigneeId);
}

public interface TaskRepository {
    Task findById(TaskId id);
    void save(Task task);
    List<Task> findByAssigneeId(UserId assigneeId);
}

@RestController
@RequestMapping("/api/tasks")
public class TaskController {
    private final TaskService taskService;
    
    @Autowired
    public TaskController(TaskService taskService) {
        this.taskService = taskService;
    }
    
    @PostMapping
    public ResponseEntity<TaskDto> createTask(@RequestBody CreateTaskRequest request) {
        TaskId taskId = taskService.createTask(request.getTitle(), request.getDescription());
        Task task = taskService.getTask(taskId);
        return ResponseEntity.status(HttpStatus.CREATED).body(TaskDto.fromDomain(task));
    }
    
    @PutMapping("/{taskId}/assign")
    public ResponseEntity<Void> assignTask(@PathVariable String taskId, @RequestBody AssignTaskRequest request) {
        taskService.assignTask(new TaskId(taskId), new UserId(request.getAssigneeId()));
        return ResponseEntity.ok().build();
    }
    
    // Другие эндпоинты
}

@Repository
public class JpaTaskRepository implements TaskRepository {
    private final TaskJpaRepository jpaRepository;
    
    @Autowired
    public JpaTaskRepository(TaskJpaRepository jpaRepository) {
        this.jpaRepository = jpaRepository;
    }
    
    @Override
    public Task findById(TaskId id) {
        return jpaRepository.findById(id.getValue())
                .map(TaskMapper::toDomain)
                .orElseThrow(() -> new TaskNotFoundException(id));
    }
    
    @Override
    public void save(Task task) {
        TaskEntity entity = TaskMapper.toEntity(task);
        jpaRepository.save(entity);
    }
    
    @Override
    public List<Task> findByAssigneeId(UserId assigneeId) {
        return jpaRepository.findByAssigneeId(assigneeId.getValue()).stream()
                .map(TaskMapper::toDomain)
                .collect(Collectors.toList());
    }
}

// domain/model/Todo.java
package com.example.application.domain.model;
 
import java.util.UUID;
 
public class Todo {
    private final TodoId id;
    private String title;
    private String description;
    private boolean completed;
 
    public Todo(String title, String description) {
        this.id = new TodoId(UUID.randomUUID());
        this.title = title;
        this.description = description;
        this.completed = false;
    }
 
    // Конструктор для существующих Todo
    public Todo(TodoId id, String title, String description, boolean completed) {
        this.id = id;
        this.title = title;
        this.description = description;
        this.completed = completed;
    }
 
    public void markAsCompleted() {
        this.completed = true;
    }
 
    public void updateDetails(String title, String description) {
        this.title = title;
        this.description = description;
    }
 
    // Геттеры
    public TodoId getId() {
        return id;
    }
 
    public String getTitle() {
        return title;
    }
 
    public String getDescription() {
        return description;
    }
 
    public boolean isCompleted() {
        return completed;
    }
}
 
// domain/model/TodoId.java
package com.example.application.domain.model;
 
import java.util.Objects;
import java.util.UUID;
 
public class TodoId {
    private final UUID id;
 
    public TodoId(UUID id) {
        this.id = id;
    }
 
    public UUID getValue() {
        return id;
    }
 
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        TodoId todoId = (TodoId) o;
        return Objects.equals(id, todoId.id);
    }
 
    @Override
    public int hashCode() {
        return Objects.hash(id);
    }
 
    @Override
    public String toString() {
        return id.toString();
    }
}

// domain/port/api/TodoService.java
package com.example.application.domain.port.api;
 
import com.example.application.domain.model.Todo;
import com.example.application.domain.model.TodoId;
 
import java.util.List;
import java.util.Optional;
 
public interface TodoService {
    TodoId createTodo(String title, String description);
    Optional<Todo> getTodoById(TodoId id);
    List<Todo> getAllTodos();
    void markTodoAsCompleted(TodoId id);
    void updateTodo(TodoId id, String title, String description);
    void deleteTodo(TodoId id);
}

// domain/port/spi/TodoRepository.java
package com.example.application.domain.port.spi;
 
import com.example.application.domain.model.Todo;
import com.example.application.domain.model.TodoId;
 
import java.util.List;
import java.util.Optional;
 
public interface TodoRepository {
    Todo save(Todo todo);
    Optional<Todo> findById(TodoId id);
    List<Todo> findAll();
    void deleteById(TodoId id);
}

// domain/service/TodoServiceImpl.java
package com.example.application.domain.service;
 
import com.example.application.domain.model.Todo;
import com.example.application.domain.model.TodoId;
import com.example.application.domain.port.api.TodoService;
import com.example.application.domain.port.spi.TodoRepository;
 
import java.util.List;
import java.util.Optional;
 
public class TodoServiceImpl implements TodoService {
    private final TodoRepository todoRepository;
 
    public TodoServiceImpl(TodoRepository todoRepository) {
        this.todoRepository = todoRepository;
    }
 
    @Override
    public TodoId createTodo(String title, String description) {
        Todo todo = new Todo(title, description);
        Todo savedTodo = todoRepository.save(todo);
        return savedTodo.getId();
    }
 
    @Override
    public Optional<Todo> getTodoById(TodoId id) {
        return todoRepository.findById(id);
    }
 
    @Override
    public List<Todo> getAllTodos() {
        return todoRepository.findAll();
    }
 
    @Override
    public void markTodoAsCompleted(TodoId id) {
        todoRepository.findById(id).ifPresent(todo -> {
            todo.markAsCompleted();
            todoRepository.save(todo);
        });
    }
 
    @Override
    public void updateTodo(TodoId id, String title, String description) {
        todoRepository.findById(id).ifPresent(todo -> {
            todo.updateDetails(title, description);
            todoRepository.save(todo);
        });
    }
 
    @Override
    public void deleteTodo(TodoId id) {
        todoRepository.deleteById(id);
    }
}

// infrastructure/adapter/output/persistence/entity/TodoEntity.java
package com.example.application.infrastructure.adapter.output.persistence.entity;
 
import jakarta.persistence.Entity;
import jakarta.persistence.Id;
import jakarta.persistence.Table;
import java.util.UUID;
 
@Entity
@Table(name = "todos")
public class TodoEntity {
    @Id
    private UUID id;
    private String title;
    private String description;
    private boolean completed;
 
    // Геттеры и сеттеры
    public UUID getId() {
        return id;
    }
 
    public void setId(UUID id) {
        this.id = id;
    }
 
    public String getTitle() {
        return title;
    }
 
    public void setTitle(String title) {
        this.title = title;
    }
 
    public String getDescription() {
        return description;
    }
 
    public void setDescription(String description) {
        this.description = description;
    }
 
    public boolean isCompleted() {
        return completed;
    }
 
    public void setCompleted(boolean completed) {
        this.completed = completed;
    }
}
 
// infrastructure/adapter/output/persistence/repository/SpringDataTodoRepository.java
package com.example.application.infrastructure.adapter.output.persistence.repository;
 
import com.example.application.infrastructure.adapter.output.persistence.entity.TodoEntity;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;
 
import java.util.UUID;
 
@Repository
public interface SpringDataTodoRepository extends JpaRepository<TodoEntity, UUID> {
}

// infrastructure/adapter/output/persistence/mapper/TodoMapper.java
package com.example.application.infrastructure.adapter.output.persistence.mapper;
 
import com.example.application.domain.model.Todo;
import com.example.application.domain.model.TodoId;
import com.example.application.infrastructure.adapter.output.persistence.entity.TodoEntity;
 
public class TodoMapper {
    public static TodoEntity toEntity(Todo domain) {
        TodoEntity entity = new TodoEntity();
        entity.setId(domain.getId().getValue());
        entity.setTitle(domain.getTitle());
        entity.setDescription(domain.getDescription());
        entity.setCompleted(domain.isCompleted());
        return entity;
    }
 
    public static Todo toDomain(TodoEntity entity) {
        return new Todo(
            new TodoId(entity.getId()),
            entity.getTitle(),
            entity.getDescription(),
            entity.isCompleted()
        );
    }
}

// infrastructure/adapter/output/persistence/TodoRepositoryAdapter.java
package com.example.application.infrastructure.adapter.output.persistence;
 
import com.example.application.domain.model.Todo;
import com.example.application.domain.model.TodoId;
import com.example.application.domain.port.spi.TodoRepository;
import com.example.application.infrastructure.adapter.output.persistence.mapper.TodoMapper;
import com.example.application.infrastructure.adapter.output.persistence.repository.SpringDataTodoRepository;
import org.springframework.stereotype.Component;
 
import java.util.List;
import java.util.Optional;
import java.util.stream.Collectors;
 
@Component
public class TodoRepositoryAdapter implements TodoRepository {
    private final SpringDataTodoRepository repository;
 
    public TodoRepositoryAdapter(SpringDataTodoRepository repository) {
        this.repository = repository;
    }
 
    @Override
    public Todo save(Todo todo) {
        var entity = TodoMapper.toEntity(todo);
        var savedEntity = repository.save(entity);
        return TodoMapper.toDomain(savedEntity);
    }
 
    @Override
    public Optional<Todo> findById(TodoId id) {
        return repository.findById(id.getValue())
                .map(TodoMapper::toDomain);
    }
 
    @Override
    public List<Todo> findAll() {
        return repository.findAll().stream()
                .map(TodoMapper::toDomain)
                .collect(Collectors.toList());
    }
 
    @Override
    public void deleteById(TodoId id) {
        repository.deleteById(id.getValue());
    }
}

// infrastructure/adapter/input/rest/TodoController.java
package com.example.application.infrastructure.adapter.input.rest;
 
import com.example.application.domain.model.Todo;
import com.example.application.domain.model.TodoId;
import com.example.application.domain.port.api.TodoService;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;
 
import java.util.List;
import java.util.UUID;
 
@RestController
@RequestMapping("/api/todos")
public class TodoController {
    private final TodoService todoService;
 
    public TodoController(TodoService todoService) {
        this.todoService = todoService;
    }
 
    @PostMapping
    public ResponseEntity<UUID> createTodo(@RequestBody CreateTodoRequest request) {
        TodoId todoId = todoService.createTodo(request.title, request.description);
        return new ResponseEntity<>(todoId.getValue(), HttpStatus.CREATED);
    }
 
    @GetMapping
    public ResponseEntity<List<Todo>> getAllTodos() {
        return ResponseEntity.ok(todoService.getAllTodos());
    }
 
    @GetMapping("/{id}")
    public ResponseEntity<Todo> getTodoById(@PathVariable UUID id) {
        return todoService.getTodoById(new TodoId(id))
                .map(ResponseEntity::ok)
                .orElse(ResponseEntity.notFound().build());
    }
 
    @PutMapping("/{id}")
    public ResponseEntity<Void> updateTodo(
            @PathVariable UUID id,
            @RequestBody UpdateTodoRequest request) {
        todoService.updateTodo(new TodoId(id), request.title, request.description);
        return ResponseEntity.noContent().build();
    }
 
    @PatchMapping("/{id}/complete")
    public ResponseEntity<Void> markTodoAsCompleted(@PathVariable UUID id) {
        todoService.markTodoAsCompleted(new TodoId(id));
        return ResponseEntity.noContent().build();
    }
 
    @DeleteMapping("/{id}")
    public ResponseEntity<Void> deleteTodo(@PathVariable UUID id) {
        todoService.deleteTodo(new TodoId(id));
        return ResponseEntity.noContent().build();
    }
 
    // Вспомогательные классы для запросов
    public static class CreateTodoRequest {
        public String title;
        public String description;
    }
 
    public static class UpdateTodoRequest {
        public String title;
        public String description;
    }
}

// infrastructure/config/BeanConfiguration.java
package com.example.application.infrastructure.config;
 
import com.example.application.domain.port.api.TodoService;
import com.example.application.domain.port.spi.TodoRepository;
import com.example.application.domain.service.TodoServiceImpl;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
 
@Configuration
public class BeanConfiguration {
    
    @Bean
    public TodoService todoService(TodoRepository todoRepository) {
        return new TodoServiceImpl(todoRepository);
    }
}

// Расширяем наш пример TodoRepositoryAdapter
@Component
public class TodoRepositoryAdapter implements TodoRepository {
    // Здесь автоматически внедряется реализация SpringDataTodoRepository
    private final SpringDataTodoRepository jpaRepository;
    
    // В адаптере происходит конвертация между доменными и 
    // инфраструктурными типами данных
    @Override
    public List<Todo> findByCompletionStatus(boolean isCompleted) {
        return jpaRepository.findByCompleted(isCompleted).stream()
                .map(TodoMapper::toDomain)
                .collect(Collectors.toList());
    }
}

public interface AsyncNotificationPort {
    CompletableFuture<Void> sendTaskCompletionNotification(UUID taskId, String userEmail);
}

@Component
public class EmailNotificationAdapter implements AsyncNotificationPort {
    private final EmailService emailService;
    
    @Override
    @Async
    public CompletableFuture<Void> sendTaskCompletionNotification(UUID taskId, String userEmail) {
        return CompletableFuture.runAsync(() -> {
            emailService.sendEmail(userEmail, "Task completed", 
                    "Task with ID " + taskId + " has been marked as completed.");
        });
    }
}

// domain/model/Book.java
package com.example.library.domain.model;
 
import java.util.UUID;
 
public class Book {
    private BookId id;
    private String title;
    private String author;
    private String isbn;
    private BookStatus status;
 
    // Конструктор для создания новой книги
    public Book(String title, String author, String isbn) {
        this.id = new BookId(UUID.randomUUID());
        this.title = title;
        this.author = author;
        this.isbn = isbn;
        this.status = BookStatus.AVAILABLE;
    }
 
    // Конструктор для восстановления существующей книги из хранилища
    public Book(BookId id, String title, String author, String isbn, BookStatus status) {
        this.id = id;
        this.title = title;
        this.author = author;
        this.isbn = isbn;
        this.status = status;
    }
 
    public void borrowBook() {
        if (status != BookStatus.AVAILABLE) {
            throw new IllegalStateException("Книга недоступна для выдачи");
        }
        status = BookStatus.BORROWED;
    }
 
    public void returnBook() {
        if (status != BookStatus.BORROWED) {
            throw new IllegalStateException("Книга не была выдана");
        }
        status = BookStatus.AVAILABLE;
    }
 
    // Геттеры и базовые методы
    public BookId getId() {
        return id;
    }
 
    public String getTitle() {
        return title;
    }
 
    public String getAuthor() {
        return author;
    }
 
    public String getIsbn() {
        return isbn;
    }
 
    public BookStatus getStatus() {
        return status;
    }
}
 
// domain/model/BookId.java
package com.example.library.domain.model;
 
import java.util.Objects;
import java.util.UUID;
 
public class BookId {
    private final UUID value;
 
    public BookId(UUID value) {
        this.value = value;
    }
 
    public UUID getValue() {
        return value;
    }
 
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        BookId bookId = (BookId) o;
        return Objects.equals(value, bookId.value);
    }
 
    @Override
    public int hashCode() {
        return Objects.hash(value);
    }
}
 
// domain/model/BookStatus.java
package com.example.library.domain.model;
 
public enum BookStatus {
    AVAILABLE,
    BORROWED,
    RESERVED,
    LOST
}

// domain/port/api/BookService.java
package com.example.library.domain.port.api;
 
import com.example.library.domain.model.Book;
import com.example.library.domain.model.BookId;
 
import java.util.List;
import java.util.Optional;
 
public interface BookService {
    BookId addBook(String title, String author, String isbn);
    Optional<Book> findById(BookId id);
    List<Book> findAll();
    List<Book> findByAuthor(String author);
    void borrowBook(BookId bookId);
    void returnBook(BookId bookId);
}

// domain/port/spi/BookRepository.java
package com.example.library.domain.port.spi;
 
import com.example.library.domain.model.Book;
import com.example.library.domain.model.BookId;
 
import java.util.List;
import java.util.Optional;
 
public interface BookRepository {
    Book save(Book book);
    Optional<Book> findById(BookId id);
    List<Book> findAll();
    List<Book> findByAuthor(String author);
}

// domain/service/BookServiceImpl.java
package com.example.library.domain.service;
 
import com.example.library.domain.model.Book;
import com.example.library.domain.model.BookId;
import com.example.library.domain.port.api.BookService;
import com.example.library.domain.port.spi.BookRepository;
 
import java.util.List;
import java.util.Optional;
 
public class BookServiceImpl implements BookService {
    private final BookRepository bookRepository;
 
    public BookServiceImpl(BookRepository bookRepository) {
        this.bookRepository = bookRepository;
    }
 
    @Override
    public BookId addBook(String title, String author, String isbn) {
        Book book = new Book(title, author, isbn);
        Book savedBook = bookRepository.save(book);
        return savedBook.getId();
    }
 
    @Override
    public Optional<Book> findById(BookId id) {
        return bookRepository.findById(id);
    }
 
    @Override
    public List<Book> findAll() {
        return bookRepository.findAll();
    }
 
    @Override
    public List<Book> findByAuthor(String author) {
        return bookRepository.findByAuthor(author);
    }
 
    @Override
    public void borrowBook(BookId bookId) {
        bookRepository.findById(bookId)
                .ifPresent(book -> {
                    book.borrowBook();
                    bookRepository.save(book);
                });
    }
 
    @Override
    public void returnBook(BookId bookId) {
        bookRepository.findById(bookId)
                .ifPresent(book -> {
                    book.returnBook();
                    bookRepository.save(book);
                });
    }
}

// infrastructure/adapter/persistence/entity/BookEntity.java
package com.example.library.infrastructure.adapter.persistence.entity;
 
import jakarta.persistence.Entity;
import jakarta.persistence.Id;
import jakarta.persistence.Table;
import jakarta.persistence.Enumerated;
import jakarta.persistence.EnumType;
import java.util.UUID;
 
@Entity
@Table(name = "books")
public class BookEntity {
    @Id
    private UUID id;
    private String title;
    private String author;
    private String isbn;
    
    @Enumerated(EnumType.STRING)
    private BookStatusEntity status;
    
    // Геттеры и сеттеры
    public UUID getId() {
        return id;
    }
    
    public void setId(UUID id) {
        this.id = id;
    }
    
    public String getTitle() {
        return title;
    }
    
    public void setTitle(String title) {
        this.title = title;
    }
    
    public String getAuthor() {
        return author;
    }
    
    public void setAuthor(String author) {
        this.author = author;
    }
    
    public String getIsbn() {
        return isbn;
    }
    
    public void setIsbn(String isbn) {
        this.isbn = isbn;
    }
    
    public BookStatusEntity getStatus() {
        return status;
    }
    
    public void setStatus(BookStatusEntity status) {
        this.status = status;
    }
}
 
// infrastructure/adapter/persistence/entity/BookStatusEntity.java
package com.example.library.infrastructure.adapter.persistence.entity;
 
public enum BookStatusEntity {
    AVAILABLE,
    BORROWED,
    RESERVED,
    LOST
}

// infrastructure/adapter/persistence/repository/SpringBookRepository.java
package com.example.library.infrastructure.adapter.persistence.repository;
 
import com.example.library.infrastructure.adapter.persistence.entity.BookEntity;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;
 
import java.util.List;
import java.util.UUID;
 
@Repository
public interface SpringBookRepository extends JpaRepository<BookEntity, UUID> {
    List<BookEntity> findByAuthor(String author);
}
 
// infrastructure/adapter/persistence/mapper/BookMapper.java
package com.example.library.infrastructure.adapter.persistence.mapper;
 
import com.example.library.domain.model.Book;
import com.example.library.domain.model.BookId;
import com.example.library.domain.model.BookStatus;
import com.example.library.infrastructure.adapter.persistence.entity.BookEntity;
import com.example.library.infrastructure.adapter.persistence.entity.BookStatusEntity;
 
public class BookMapper {
    public static BookEntity toEntity(Book domain) {
        BookEntity entity = new BookEntity();
        entity.setId(domain.getId().getValue());
        entity.setTitle(domain.getTitle());
        entity.setAuthor(domain.getAuthor());
        entity.setIsbn(domain.getIsbn());
        entity.setStatus(mapStatus(domain.getStatus()));
        return entity;
    }
    
    public static Book toDomain(BookEntity entity) {
        return new Book(
            new BookId(entity.getId()),
            entity.getTitle(),
            entity.getAuthor(),
            entity.getIsbn(),
            mapStatus(entity.getStatus())
        );
    }
    
    private static BookStatusEntity mapStatus(BookStatus status) {
        return BookStatusEntity.valueOf(status.name());
    }
    
    private static BookStatus mapStatus(BookStatusEntity status) {
        return BookStatus.valueOf(status.name());
    }
}

// infrastructure/adapter/persistence/BookRepositoryAdapter.java
package com.example.library.infrastructure.adapter.persistence;
 
import com.example.library.domain.model.Book;
import com.example.library.domain.model.BookId;
import com.example.library.domain.port.spi.BookRepository;
import com.example.library.infrastructure.adapter.persistence.mapper.BookMapper;
import com.example.library.infrastructure.adapter.persistence.repository.SpringBookRepository;
import org.springframework.stereotype.Component;
 
import java.util.List;
import java.util.Optional;
import java.util.stream.Collectors;
 
@Component
public class BookRepositoryAdapter implements BookRepository {
    private final SpringBookRepository springRepository;
    
    public BookRepositoryAdapter(SpringBookRepository springRepository) {
        this.springRepository = springRepository;
    }
    
    @Override
    public Book save(Book book) {
        var entity = BookMapper.toEntity(book);
        var savedEntity = springRepository.save(entity);
        return BookMapper.toDomain(savedEntity);
    }
    
    @Override
    public Optional<Book> findById(BookId id) {
        return springRepository.findById(id.getValue())
                .map(BookMapper::toDomain);
    }
    
    @Override
    public List<Book> findAll() {
        return springRepository.findAll().stream()
                .map(BookMapper::toDomain)
                .collect(Collectors.toList());
    }
    
    @Override
    public List<Book> findByAuthor(String author) {
        return springRepository.findByAuthor(author).stream()
                .map(BookMapper::toDomain)
                .collect(Collectors.toList());
    }
}

// infrastructure/adapter/web/BookController.java
package com.example.library.infrastructure.adapter.web;
 
import com.example.library.domain.model.Book;
import com.example.library.domain.model.BookId;
import com.example.library.domain.port.api.BookService;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;
 
import java.util.List;
import java.util.UUID;
 
@RestController
@RequestMapping("/api/books")
public class BookController {
    private final BookService bookService;
    
    public BookController(BookService bookService) {
        this.bookService = bookService;
    }
    
    @PostMapping
    public ResponseEntity<UUID> addBook(@RequestBody AddBookRequest request) {
        BookId bookId = bookService.addBook(request.title, request.author, request.isbn);
        return new ResponseEntity<>(bookId.getValue(), HttpStatus.CREATED);
    }
    
    @GetMapping
    public ResponseEntity<List<Book>> getAllBooks() {
        return ResponseEntity.ok(bookService.findAll());
    }
    
    @GetMapping("/{id}")
    public ResponseEntity<Book> getBookById(@PathVariable UUID id) {
        return bookService.findById(new BookId(id))
                .map(ResponseEntity::ok)
                .orElse(ResponseEntity.notFound().build());
    }
    
    @GetMapping("/by-author/{author}")
    public ResponseEntity<List<Book>> getBooksByAuthor(@PathVariable String author) {
        return ResponseEntity.ok(bookService.findByAuthor(author));
    }
    
    @PostMapping("/{id}/borrow")
    public ResponseEntity<Void> borrowBook(@PathVariable UUID id) {
        bookService.borrowBook(new BookId(id));
        return ResponseEntity.noContent().build();
    }
    
    @PostMapping("/{id}/return")
    public ResponseEntity<Void> returnBook(@PathVariable UUID id) {
        bookService.returnBook(new BookId(id));
        return ResponseEntity.noContent().build();
    }
    
    // Вспомогательные классы для запросов
    public static class AddBookRequest {
        public String title;
        public String author;
        public String isbn;
    }
}

// infrastructure/config/BeanConfiguration.java
package com.example.library.infrastructure.config;
 
import com.example.library.domain.port.api.BookService;
import com.example.library.domain.port.spi.BookRepository;
import com.example.library.domain.service.BookServiceImpl;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
 
@Configuration
public class BeanConfiguration {
    @Bean
    public BookService bookService(BookRepository bookRepository) {
        return new BookServiceImpl(bookRepository);
    }
}

// test/java/com/example/library/domain/service/BookServiceImplTest.java
package com.example.library.domain.service;
 
import com.example.library.domain.model.Book;
import com.example.library.domain.model.BookId;
import com.example.library.domain.port.spi.BookRepository;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
 
import java.util.Optional;
import java.util.UUID;
 
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.*;
import static org.junit.jupiter.api.Assertions.*;
 
class BookServiceImplTest {
    @Mock
    private BookRepository bookRepository;
    
    private BookServiceImpl bookService;
    
    @BeforeEach
    void setUp() {
        MockitoAnnotations.openMocks(this);
        bookService = new BookServiceImpl(bookRepository);
    }
    
    @Test
    void shouldAddBook() {
        // Arrange
        String title = "Чистая архитектура";
        String author = "Роберт Мартин";
        String isbn = "9785446107728";
        
        Book savedBook = new Book(title, author, isbn);
        when(bookRepository.save(any(Book.class))).thenReturn(savedBook);
        
        // Act
        BookId bookId = bookService.addBook(title, author, isbn);
        
        // Assert
        assertNotNull(bookId);
        verify(bookRepository).save(any(Book.class));
    }
    
    @Test
    void shouldBorrowBook() {
        // Arrange
        BookId bookId = new BookId(UUID.randomUUID());
        Book book = new Book("Гексагональная архитектура", "Алистер Кокберн", "12345");
        when(bookRepository.findById(bookId)).thenReturn(Optional.of(book));
        when(bookRepository.save(any(Book.class))).thenReturn(book);
        
        // Act
        bookService.borrowBook(bookId);
        
        // Assert
        verify(bookRepository).findById(bookId);
        verify(bookRepository).save(any(Book.class));
    }
}

@SpringBootTest
@AutoConfigureMockMvc
class BookControllerIntegrationTest {
    @Autowired
    private MockMvc mockMvc;
    
    @MockBean
    private BookRepository bookRepository;
    
    @Test
    void shouldReturnBooksList() throws Exception {
        // Создаем тестовые данные
        List<Book> books = List.of(
            new Book("Паттерны проектирования", "Банда четырех", "123456"),
            new Book("Spring в действии", "Крейг Уоллс", "654321")
        );
        
        when(bookRepository.findAll()).thenReturn(books);
        
        // Выполняем запрос и проверяем результат
        mockMvc.perform(get("/api/books"))
               .andExpect(status().isOk())
               .andExpect(jsonPath("$", hasSize(2)))
               .andExpect(jsonPath("$[0].title", is("Паттерны проектирования")))
               .andExpect(jsonPath("$[1].title", is("Spring в действии")));
    }
}

// Пример API-шлюза, маршрутизирующего запросы к микросервисам
@RestController
public class ApiGatewayController {
    private final BookServiceClient bookServiceClient;
    private final UserServiceClient userServiceClient;
    
    @GetMapping("/api/books/{id}")
    public ResponseEntity<BookDto> getBook(@PathVariable UUID id) {
        return bookServiceClient.getBook(id);
    }
    
    @GetMapping("/api/users/{id}/borrowed-books")
    public ResponseEntity<List<BookDto>> getUserBorrowedBooks(@PathVariable UUID id) {
        UserDto user = userServiceClient.getUser(id).getBody();
        List<BookDto> books = user.getBorrowedBookIds().stream()
            .map(bookId -> bookServiceClient.getBook(bookId).getBody())
            .collect(Collectors.toList());
        return ResponseEntity.ok(books);
    }
}

@Service
public class ResilientBookServiceClient {
    private final BookServiceClient bookServiceClient;
    
    @CircuitBreaker(name = "bookService", fallbackMethod = "getDefaultBook")
    public ResponseEntity<BookDto> getBook(UUID id) {
        return bookServiceClient.getBook(id);
    }
    
    private ResponseEntity<BookDto> getDefaultBook(UUID id, Exception e) {
        // Возвращаем резервные данные при недоступности сервиса
        return ResponseEntity.ok(new BookDto(id, "Недоступно", "Сервис временно недоступен", "N/A"));
    }
}

@Component
public class CachingBookRepositoryAdapter implements BookRepository {
    private final SpringBookRepository springRepository;
    private final Cache<BookId, Book> bookCache;
    
    @Override
    public Optional<Book> findById(BookId id) {
        return Optional.ofNullable(bookCache.get(id, key -> 
            springRepository.findById(key.getValue())
                .map(BookMapper::toDomain)
                .orElse(null)
        ));
    }
}

@Component
public class AsyncNotificationAdapter implements NotificationPort {
    private final NotificationSender sender;
    private final Executor executor;
    
    @Override
    public void sendBorrowNotification(BookId bookId, UserId userId) {
        CompletableFuture.runAsync(() -> {
            // Асинхронная отправка уведомления
            sender.send(bookId, userId);
        }, executor);
    }
}

@Repository
public interface SpringBookRepository extends JpaRepository<BookEntity, UUID> {
    // Специализированный запрос для оптимизации производительности
    @Query("SELECT b FROM BookEntity b WHERE b.author = :author AND b.status = 'AVAILABLE' ORDER BY b.title")
    List<BookEntity> findAvailableBooksByAuthor(String author);
}

// Пример агрегата в DDD
public class Order {
    private OrderId id;
    private CustomerId customerId;
    private List<OrderLine> orderLines;
    private OrderStatus status;
    
    public void addItem(Product product, int quantity) {
        orderLines.add(new OrderLine(new OrderLineId(), product.getId(), quantity, product.getPrice()));
        // Публикуем доменное событие
        DomainEventPublisher.publish(new OrderItemAddedEvent(this.id, product.getId(), quantity));
    }
    
    public Money calculateTotal() {
        return orderLines.stream()
            .map(OrderLine::getLineTotal)
            .reduce(Money.ZERO, Money::add);
    }
}

@Service
public class OrderProcessingSaga {
    private final OrderService orderService;
    private final PaymentService paymentService;
    private final InventoryService inventoryService;
    private final NotificationService notificationService;
    
    @Transactional
    public void processOrder(OrderId orderId) {
        try {
            // Шаг 1: Резервируем товары
            inventoryService.reserveItems(orderId);
            
            // Шаг 2: Обрабатываем платёж
            paymentService.processPayment(orderId);
            
            // Шаг 3: Подтверждаем заказ
            orderService.confirmOrder(orderId);
            
            // Шаг 4: Отправляем уведомление
            notificationService.sendOrderConfirmation(orderId);
        } catch (InventoryException e) {
            // Компенсирующая транзакция не нужна, просто помечаем заказ как проваленный
            orderService.markOrderAsFailed(orderId, "Недостаточно товаров на складе");
            throw e;
        } catch (PaymentException e) {
            // Компенсирующая транзакция: отменяем резервацию товаров
            inventoryService.releaseReservation(orderId);
            orderService.markOrderAsFailed(orderId, "Ошибка оплаты");
            throw e;
        } catch (Exception e) {
            // Отменяем все предыдущие шаги
            paymentService.refund(orderId);
            inventoryService.releaseReservation(orderId);
            orderService.markOrderAsFailed(orderId, "Неизвестная ошибка");
            throw e;
        }
    }
}