In-memory repository

In this lesson, we introduce a proper layered architecture by adding Service and Repository layers between the controllers and the data. Instead of returning hardcoded responses, controllers now delegate to services, which persist and retrieve data from thread-safe in-memory repositories backed by ConcurrentHashMap.

1.Create Model classes

These classes will be used to store data in in-memory repositories.

Author model

Represents an author entity with a unique UUID identifier and a name field.


7 collapsed lines
1
package com.romach007.spring_boot.model;
2

3
import lombok.Builder;
4
import lombok.Data;
5

6
import java.util.UUID;
7

8
@Data
9
@Builder
10
public class Author {
11
    private UUID id;
12
    private String name;
13
}

Book model

Represents a book entity with fields for id, title, isbn, description, authors, and publicationDate.


9 collapsed lines
1
package com.romach007.spring_boot.model;
2

3
import lombok.Builder;
4
import lombok.Data;
5

6
import java.time.LocalDate;
7
import java.util.List;
8
import java.util.UUID;
9

10
@Data
11
@Builder
12
public class Book {
13
    private UUID id;
14
    private String title;
15
    private String isbn;
16
    private String description;
17
    private List<UUID> authorIds;
18
    private LocalDate publicationDate;
19
}

2.Create Repositories

AuthorRepository

Interface defining CRUD operations for Author entities.


8 collapsed lines
1
package com.romach007.spring_boot.repository;
2

3
import com.romach007.spring_boot.model.Author;
4

5
import java.util.List;
6
import java.util.Optional;
7
import java.util.UUID;
8

9
public interface AuthorRepository {
10
    List<Author> findAll();
11
    Optional<Author> findById(UUID id);
12
    Author save(Author author);
13
    void deleteById(UUID id);
14
}

BookRepository

Interface defining CRUD operations for Book entities.


8 collapsed lines
1
package com.romach007.spring_boot.repository;
2

3
import com.romach007.spring_boot.model.Book;
4

5
import java.util.List;
6
import java.util.Optional;
7
import java.util.UUID;
8

9
public interface BookRepository {
10
    List<Book> findAll();
11
    Optional<Book> findById(UUID id);
12
    Book save(Book book);
13
    void deleteById(UUID id);
14
}

InMemoryAuthorRepository

Thread-safe in-memory implementation of AuthorRepository backed by ConcurrentHashMap.


11 collapsed lines
1
package com.romach007.spring_boot.repository;
2

3
import com.romach007.spring_boot.model.Author;
4
import org.springframework.stereotype.Repository;
5

6
import java.util.ArrayList;
7
import java.util.List;
8
import java.util.Optional;
9
import java.util.UUID;
10
import java.util.concurrent.ConcurrentHashMap;
11

12
@Repository
13
public class InMemoryAuthorRepository implements AuthorRepository {
14

15
    private final ConcurrentHashMap<UUID, Author> store = new ConcurrentHashMap<>();
16

17
    @Override
18
    public List<Author> findAll() {
19
        return new ArrayList<>(store.values());
20
    }
21

22
    @Override
23
    public Optional<Author> findById(UUID id) {
24
        return Optional.ofNullable(store.get(id));
25
    }
26

27
    @Override
28
    public Author save(Author author) {
29
        store.put(author.getId(), author);
30
        return author;
31
    }
32

33
    @Override
34
    public void deleteById(UUID id) {
35
        store.remove(id);
36
    }
37
}

InMemoryBookRepository

Thread-safe in-memory implementation of BookRepository backed by ConcurrentHashMap.


11 collapsed lines
1
package com.romach007.spring_boot.repository;
2

3
import com.romach007.spring_boot.model.Book;
4
import org.springframework.stereotype.Repository;
5

6
import java.util.ArrayList;
7
import java.util.List;
8
import java.util.Optional;
9
import java.util.UUID;
10
import java.util.concurrent.ConcurrentHashMap;
11

12
@Repository
13
public class InMemoryBookRepository implements BookRepository {
14

15
    private final ConcurrentHashMap<UUID, Book> store = new ConcurrentHashMap<>();
16

17
    @Override
18
    public List<Book> findAll() {
19
        return new ArrayList<>(store.values());
20
    }
21

22
    @Override
23
    public Optional<Book> findById(UUID id) {
24
        return Optional.ofNullable(store.get(id));
25
    }
26

27
    @Override
28
    public Book save(Book book) {
29
        store.put(book.getId(), book);
30
        return book;
31
    }
32

33
    @Override
34
    public void deleteById(UUID id) {
35
        store.remove(id);
36
    }
37
}

3.Create Services

AuthorService

Service layer for Author business logic; delegates persistence operations to AuthorRepository. Throws 404 Not Found when an author does not exist on get, update, or delete.

Possible responses

Method	Response status code	Description
`list()`	200 OK	Get list of all authors
`get(id)`	200 OK	Get author by id
	404 NOT FOUND	Author not found
`create(dto)`	201 CREATED	Create new author
`update(id, dto)`	200 OK	Update existing author
	404 NOT FOUND	Author not found
`delete(id)`	204 NO CONTENT	Delete author
	404 NOT FOUND	Author not found


14 collapsed lines
1
package com.romach007.spring_boot.service;
2

3
import com.romach007.spring_boot.dto.AuthorDTO;
4
import com.romach007.spring_boot.dto.SaveAuthorDTO;
5
import com.romach007.spring_boot.model.Author;
6
import com.romach007.spring_boot.repository.AuthorRepository;
7
import lombok.RequiredArgsConstructor;
8
import org.springframework.http.HttpStatus;
9
import org.springframework.stereotype.Service;
10
import org.springframework.web.server.ResponseStatusException;
11

12
import java.util.List;
13
import java.util.UUID;
14

15
@Service
16
@RequiredArgsConstructor
17
public class AuthorService {
18

19
    private final AuthorRepository authorRepository;
20

21
    public List<AuthorDTO> list() {
22
        return authorRepository.findAll().stream()
23
                .map(this::toDTO)
24
                .toList();
25
    }
26

27
    public AuthorDTO get(UUID id) {
28
        return authorRepository.findById(id)
29
                .map(this::toDTO)
30
                .orElseThrow(() -> new ResponseStatusException(HttpStatus.NOT_FOUND, "Author not found: " + id));
31
    }
32

33
    public AuthorDTO create(SaveAuthorDTO dto) {
34
        Author author = Author.builder()
35
                .id(UUID.randomUUID())
36
                .name(dto.getName())
37
                .build();
38
        return toDTO(authorRepository.save(author));
39
    }
40

41
    public AuthorDTO update(UUID id, SaveAuthorDTO dto) {
42
        Author author = authorRepository.findById(id)
43
                .orElseThrow(() -> new ResponseStatusException(HttpStatus.NOT_FOUND, "Author not found: " + id));
44
        author.setName(dto.getName());
45
        return toDTO(authorRepository.save(author));
46
    }
47

48
    public void delete(UUID id) {
49
        authorRepository.findById(id)
50
                .orElseThrow(() -> new ResponseStatusException(HttpStatus.NOT_FOUND, "Author not found: " + id));
51
        authorRepository.deleteById(id);
52
    }
53

54
    private AuthorDTO toDTO(Author author) {
55
        return new AuthorDTO(author.getId(), author.getName());
56
    }
57
}

BookService

Service layer for Book business logic; delegates persistence operations to BookRepository. Throws 404 Not Found when a book does not exist, and 400 Bad Request when a provided authorId does not match any existing author.

Possible responses

Method	Response status code	Description
`list()`	200 OK	Get list of all books
`get(id)`	200 OK	Get book by id
	404 NOT FOUND	Book not found
`create(dto)`	201 CREATED	Create new book
	400 BAD REQUEST	Author not found
`update(id, dto)`	200 OK	Update existing book
	404 NOT FOUND	Book not found
	400 BAD REQUEST	Author not found
`delete(id)`	204 NO CONTENT	Delete book
	404 NOT FOUND	Book not found


15 collapsed lines
1
package com.romach007.spring_boot.service;
2

3
import com.romach007.spring_boot.dto.AuthorDTO;
4
import com.romach007.spring_boot.dto.BookDTO;
5
import com.romach007.spring_boot.dto.SaveBookDTO;
6
import com.romach007.spring_boot.model.Book;
7
import com.romach007.spring_boot.repository.BookRepository;
8
import lombok.RequiredArgsConstructor;
9
import org.springframework.http.HttpStatus;
10
import org.springframework.stereotype.Service;
11
import org.springframework.web.server.ResponseStatusException;
12

13
import java.util.List;
14
import java.util.UUID;
15

16
@Service
17
@RequiredArgsConstructor
18
public class BookService {
19

20
    private final BookRepository bookRepository;
21
    private final AuthorService authorService;
22

23
    public List<BookDTO> list() {
24
        return bookRepository.findAll().stream()
25
                .map(this::toDTO)
26
                .toList();
27
    }
28

29
    public BookDTO get(UUID id) {
30
        return bookRepository.findById(id)
31
                .map(this::toDTO)
32
                .orElseThrow(() -> new ResponseStatusException(HttpStatus.NOT_FOUND, "Book not found: " + id));
33
    }
34

35
    public BookDTO create(SaveBookDTO dto) {
36
        validateAuthorIds(dto.getAuthorIds());
37
        Book book = Book.builder()
38
                .id(UUID.randomUUID())
39
                .title(dto.getTitle())
40
                .isbn(dto.getIsbn())
41
                .description(dto.getDescription())
42
                .authorIds(dto.getAuthorIds())
43
                .publicationDate(dto.getPublicationDate())
44
                .build();
45
        return toDTO(bookRepository.save(book));
46
    }
47

48
    public BookDTO update(UUID id, SaveBookDTO dto) {
49
        Book book = bookRepository.findById(id)
50
                .orElseThrow(() -> new ResponseStatusException(HttpStatus.NOT_FOUND, "Book not found: " + id));
51
        validateAuthorIds(dto.getAuthorIds());
52
        book.setTitle(dto.getTitle());
53
        book.setIsbn(dto.getIsbn());
54
        book.setDescription(dto.getDescription());
55
        book.setAuthorIds(dto.getAuthorIds());
56
        book.setPublicationDate(dto.getPublicationDate());
57
        return toDTO(bookRepository.save(book));
58
    }
59

60
    public void delete(UUID id) {
61
        bookRepository.findById(id)
62
                .orElseThrow(() -> new ResponseStatusException(HttpStatus.NOT_FOUND, "Book not found: " + id));
63
        bookRepository.deleteById(id);
64
    }
65

66
    private void validateAuthorIds(List<UUID> authorIds) {
67
        for (UUID authorId : authorIds) {
68
            try {
69
                authorService.get(authorId);
70
            } catch (ResponseStatusException e) {
71
                throw new ResponseStatusException(HttpStatus.BAD_REQUEST, "Author not found: " + authorId);
72
            }
73
        }
74
    }
75

76
    private BookDTO toDTO(Book book) {
77
        List<AuthorDTO> authors = book.getAuthorIds().stream()
78
                .map(authorService::get)
79
                .toList();
80
        return new BookDTO(
81
                book.getId(),
82
                book.getTitle(),
83
                book.getIsbn(),
84
                book.getDescription(),
85
                authors,
86
                book.getPublicationDate()
87
        );
88
    }
89
}

4.Update Controllers

AuthorController

Updated to inject AuthorService and delegate CRUD operations instead of returning hardcoded responses.

1
package com.romach007.spring_boot.controller;
2

3
import com.romach007.spring_boot.dto.AuthorDTO;
4
import com.romach007.spring_boot.dto.SaveAuthorDTO;
5
import com.romach007.spring_boot.service.AuthorService;
6
import lombok.RequiredArgsConstructor;
7
import org.springframework.http.HttpStatus;
8
import org.springframework.web.bind.annotation.*;
9

10
import java.util.List;
11
import java.util.UUID;
12

13
@RestController
14
@RequestMapping("/api/authors")
15
@RequiredArgsConstructor
16
public class AuthorController {
17

18
    private final AuthorService authorService;
19

20
    @GetMapping
21
    public List<AuthorDTO> list() {
22
        return List.of(
23
            new AuthorDTO(UUID.fromString("c77eff4d-d6c0-4386-9c8e-9e6e7b0d9c55"), "John Doe")
24
        );
25
        return authorService.list();
26
    }
27

28
    @GetMapping("/{id}")
29
    public AuthorDTO get(@PathVariable UUID id) {
30
        return new AuthorDTO(id, "John Doe");
31
        return authorService.get(id);
32
    }
33

34
    @PostMapping
35
    @ResponseStatus(HttpStatus.CREATED)
36
    public AuthorDTO create(@RequestBody SaveAuthorDTO dto) {
37
        return new AuthorDTO(UUID.randomUUID(), dto.getName());
38
        return authorService.create(dto);
39
    }
40

41
    @PutMapping("/{id}")
42
    public AuthorDTO update(@PathVariable UUID id, @RequestBody SaveAuthorDTO dto) {
43
        return new AuthorDTO(id, dto.getName());
44
        return authorService.update(id, dto);
45
    }
46

47
    @DeleteMapping("/{id}")
48
    @ResponseStatus(HttpStatus.NO_CONTENT)
49
    public void delete(@PathVariable UUID id) {}
50
    public void delete(@PathVariable UUID id) {
51
        authorService.delete(id);
52
    }
53
}

BookController

Updated to inject BookService and delegate CRUD operations instead of returning hardcoded responses.

1
package com.romach007.spring_boot.controller;
2

3
import com.romach007.spring_boot.dto.AuthorDTO;
4
import com.romach007.spring_boot.dto.BookDTO;
5
import com.romach007.spring_boot.dto.SaveBookDTO;
6
import com.romach007.spring_boot.service.BookService;
7
import lombok.RequiredArgsConstructor;
8
import org.springframework.http.HttpStatus;
9
import org.springframework.web.bind.annotation.*;
10

11
import java.time.LocalDate;
12
import java.util.List;
13
import java.util.UUID;
14

15
@RestController
16
@RequestMapping("/api/books")
17
@RequiredArgsConstructor
18
public class BookController {
19

20
    private final BookService bookService;
21

22
    @GetMapping
23
    public List<BookDTO> list() {
24
        return List.of(
25
            new BookDTO(
26
                UUID.fromString("7acf89b7-7aaf-4a8c-bb98-1d85ea7d0e96"),
27
                "Book Title",
28
                "978-3-16-148410-0",
29
                "description",
30
                List.of(
31
                    new AuthorDTO(UUID.fromString("c77eff4d-d6c0-4386-9c8e-9e6e7b0d9c55"), "John Doe")
32
                ),
33
                LocalDate.parse("2007-12-03")
34
            )
35
        );
36
        return bookService.list();
37
    }
38

39
    @GetMapping("/{id}")
40
    public BookDTO get(@PathVariable UUID id) {
41
        return new BookDTO(
42
            id,
43
            "Book Title",
44
            "978-3-16-148410-0",
45
            "description",
46
            List.of(
47
                new AuthorDTO(UUID.fromString("c77eff4d-d6c0-4386-9c8e-9e6e7b0d9c55"), "John Doe")
48
            ),
49
            LocalDate.parse("2007-12-03")
50
        );
51
        return bookService.get(id);
52
    }
53

54
    @PostMapping
55
    @ResponseStatus(HttpStatus.CREATED)
56
    public BookDTO create(@RequestBody SaveBookDTO dto) {
57
        return new BookDTO(
58
            UUID.randomUUID(),
59
            dto.getTitle(),
60
            dto.getIsbn(),
61
            dto.getDescription(),
62
            dto.getAuthorIds().stream().map(id -> new AuthorDTO(id, "John Doe")).toList(),
63
            dto.getPublicationDate()
64
        );
65
        return bookService.create(dto);
66
    }
67

68
    @PutMapping("/{id}")
69
    public BookDTO update(@PathVariable UUID id, @RequestBody SaveBookDTO dto) {
70
        return new BookDTO(
71
            id, dto.getTitle(),
72
            dto.getIsbn(),
73
            dto.getDescription(),
74
            dto.getAuthorIds().stream()
75
                .map(authorId -> new AuthorDTO(authorId, "John Doe"))
76
                .toList(),
77
            dto.getPublicationDate()
78
        );
79
        return bookService.update(id, dto);
80
    }
81

82
    @DeleteMapping("/{id}")
83
    @ResponseStatus(HttpStatus.NO_CONTENT)
84
    public void delete(@PathVariable UUID id) {}
85
    public void delete(@PathVariable UUID id) {
86
        bookService.delete(id);
87
    }
88
}