Library Management System in Java: Console Version to Spring Boot REST API

Verified against a real run. JDK 25.0.5 (Temurin, LTS), Spring Boot 4.1.2 (4.1.0 went GA on 10 June 2026), Spring Framework 7.0.10, Hibernate ORM 7.4.13.Final, Spring Data JPA 4.1.2, Jakarta Persistence 3.2.0, Tomcat 11.0.27, H2 2.4.240, Maven 3.9.11. Every output block below is copied from a file in the companion module, and the tests that produce those files also assert the numbers.

Start with one file: the whole library in under 100 lines

$ java LibraryConsole.java < library-demo-input.txt

    static void borrow(String isbn, int memberId, LocalDate on) {
        Book book = books.get(isbn);
        if (book == null) { System.out.println("ERROR: no such book " + isbn); return; }
        if (memberId < 1 || memberId > members.size()) { System.out.println("ERROR: no such member #" + memberId); return; }
        Member member = members.get(memberId - 1);
        if (book.available == 0) { System.out.println("ERROR: no copies of '" + book.title + "' are available"); return; }
        long active = loans.stream().filter(l -> l.returned == null && l.member.equals(member)).count();
        if (active >= MAX_LOANS) { System.out.println("ERROR: " + member.name() + " already has " + active + " active loans (max " + MAX_LOANS + ")"); return; }
        Loan loan = new Loan();
        loan.id = loans.size() + 1; loan.book = book; loan.member = member; loan.due = on.plusDays(LOAN_DAYS);
        loans.add(loan);
        book.available--;
        System.out.println("Loan #" + loan.id + ": " + member.name() + " borrowed '" + book.title + "', due " + loan.due);
    }

> add-book 978-0134685991|Effective Java|Joshua Bloch|2
Added book: Effective Java (2 copies)
> add-book 978-0596009205|Head First Java|Kathy Sierra|1
Added book: Head First Java (1 copy)
> add-book 978-0134685991|Effective Java|Joshua Bloch|2
ERROR: ISBN 978-0134685991 already exists
> add-member Asha
Added member #1: Asha
> add-member Ravi
Added member #2: Ravi
> borrow 978-0596009205 1 2026-11-01
Loan #1: Asha borrowed 'Head First Java', due 2026-11-15
> borrow 978-0596009205 2 2026-11-01
ERROR: no copies of 'Head First Java' are available
> borrow 978-0134685991 1 2026-11-01
Loan #2: Asha borrowed 'Effective Java', due 2026-11-15
> report
  Effective Java by Joshua Bloch: 1 available
  Head First Java by Kathy Sierra: 0 available
  ON LOAN #1: 'Head First Java' -> Asha, due 2026-11-15
  ON LOAN #2: 'Effective Java' -> Asha, due 2026-11-15
> return 1 2026-11-20
Loan #1 returned on 2026-11-20, fine Rs 10
> return 1 2026-11-21
ERROR: loan #1 was already returned on 2026-11-20
> borrow 978-0596009205 2 2026-11-21
Loan #3: Ravi borrowed 'Head First Java', due 2026-12-05
> report
  Effective Java by Joshua Bloch: 1 available
  Head First Java by Kathy Sierra: 0 available
  ON LOAN #2: 'Effective Java' -> Asha, due 2026-11-15
  ON LOAN #3: 'Head First Java' -> Ravi, due 2026-12-05
> quit

Why the console version feels finished but is not. The data lives in two HashMap-style collections inside one running program. Close the program and every book and loan is gone; run two copies and they cannot see each other; and only one person at a time can type at the keyboard. Each of those limits is what the next two stages remove.

Stage two: pull the rules out of the code that uses them

public final class LoanPolicy {

    public static final int LOAN_DAYS = 14;
    public static final int MAX_ACTIVE_LOANS = 3;
    public static final int FINE_PER_DAY = 2; // rupees

    private LoanPolicy() {
    }

    public static LocalDate dueOn(LocalDate borrowedOn) {
        return borrowedOn.plusDays(LOAN_DAYS);
    }

    /** Fine in rupees: zero on or before the due date, then FINE_PER_DAY for each day late. */
    public static int fine(LocalDate dueOn, LocalDate returnedOn) {
        long daysLate = ChronoUnit.DAYS.between(dueOn, returnedOn);
        return daysLate > 0 ? (int) daysLate * FINE_PER_DAY : 0;
    }

    public static boolean mayBorrow(int activeLoans) {
        return activeLoans < MAX_ACTIVE_LOANS;
    }
}

borrowed 2026-11-01, due 2026-11-15 (14 days)
returned 2026-11-12 ( -3 days vs due) -> fine Rs 0
returned 2026-11-15 ( +0 days vs due) -> fine Rs 0
returned 2026-11-16 ( +1 days vs due) -> fine Rs 2
returned 2026-11-20 ( +5 days vs due) -> fine Rs 10
returned 2026-12-15 (+30 days vs due) -> fine Rs 60

Stage three: the same library as a web service with a database

  <dependencies>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-webmvc</artifactId>
    </dependency>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-data-jpa</artifactId>
    </dependency>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-validation</artifactId>
    </dependency>
    <dependency>
      <groupId>com.h2database</groupId>
      <artifactId>h2</artifactId>
      <scope>runtime</scope>
    </dependency>

    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-webmvc-test</artifactId>
      <scope>test</scope>
    </dependency>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-data-jpa-test</artifactId>
      <scope>test</scope>
    </dependency>
  </dependencies>

@Entity
public class Book {

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

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

    @Column(nullable = false)
    private String title;

    @Column(nullable = false)
    private String author;

    private int totalCopies;
    private int availableCopies;

    @Version
    private long version;

@Entity
public class Loan {

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

    @ManyToOne(fetch = FetchType.LAZY, optional = false)
    private Book book;

    @ManyToOne(fetch = FetchType.LAZY, optional = false)
    private Member member;

    private LocalDate borrowedOn;
    private LocalDate dueOn;
    private LocalDate returnedOn;
    private int fine;

    @Transactional
    public LoanView borrow(BorrowRequest r) {
        Member member = members.findById(r.memberId())
                .orElseThrow(() -> new NotFoundException("no member with id " + r.memberId()));
        Book book = books.findById(r.bookId())
                .orElseThrow(() -> new NotFoundException("no book with id " + r.bookId()));
        if (book.getAvailableCopies() == 0) {
            throw new ConflictException("no copies of '" + book.getTitle() + "' are available");
        }
        if (loans.existsByMemberIdAndBookIdAndReturnedOnIsNull(member.getId(), book.getId())) {
            throw new RuleViolationException(member.getName() + " already has '" + book.getTitle() + "' on loan");
        }
        long active = loans.countByMemberIdAndReturnedOnIsNull(member.getId());
        if (!LoanPolicy.mayBorrow((int) active)) {
            throw new RuleViolationException(member.getName() + " already has " + active
                    + " active loans (max " + LoanPolicy.MAX_ACTIVE_LOANS + ")");
        }
        LocalDate today = LocalDate.now(clock);
        book.checkOut(); // dirty checking turns this into UPDATE book ... WHERE id=? AND version=?
        return LoanView.of(loans.save(new Loan(book, member, today, LoanPolicy.dueOn(today))));
    }

    @PostMapping("/loans")
    @ResponseStatus(HttpStatus.CREATED)
    LoanView borrow(@Valid @RequestBody BorrowRequest request) {
        return service.borrow(request);
    }

    @PostMapping("/loans/{id}/return")
    LoanView giveBack(@PathVariable Long id, @RequestBody(required = false) ReturnRequest request) {
        return service.giveBack(id, request == null ? null : request.returnedOn());
    }

> POST /books  {"isbn":"","title":"","author":"Nobody","copies":0}
{"detail":"request body failed validation","instance":"/api/books","status":400,"title":"Bad Request","errors":{"copies":"must be greater than or equal to 1","isbn":"must not be blank","title":"must not be blank"}}
< HTTP 400

> POST /loans  {"memberId":1,"bookId":2}
{"id":1,"bookTitle":"Head First Java","memberName":"Asha","borrowedOn":"2026-11-14","dueOn":"2026-11-28","returnedOn":null,"fine":0}
< HTTP 201

> POST /loans  {"memberId":2,"bookId":2}
{"detail":"no copies of 'Head First Java' are available","instance":"/api/loans","status":409,"title":"Conflict"}
< HTTP 409

Pick the status code on purpose. The API answers 404 when an id does not exist, 409 when the request is fine but the library’s current state says no (no copies left, already returned), and 422 when lending rules forbid it (the fourth loan). The tests in 03-rest-api.txt cover every one of them, so a client can rely on the difference.

What breaks first: two people, one last copy

8 threads borrow the last copy at once (Book has @Version)
successful borrows                  : 1
refused by optimistic-lock failure  : 6
refused for any other reason        : 1
loan rows in DB                     : 1
availableCopies                     : 0

8 threads borrow the last copy at once (read, check, write: no @Version)
successful borrows : 8
loan rows in DB    : 8   <- one copy, 8 loans
availableCopies    : 0   <- the counter says everything is fine

The failure is fingerprinted by the numbers, not by an error. If your loan count can exceed your total copies and nothing ever threw an exception, you are missing a version column (or a lock). In the protected run the seven refused borrowers are turned away for one of two reasons: they lost the version check, or they started late enough to find no copy left. The split varies from run to run, which is why the transcript counts the two separately.

        List<String> outcomes = runConcurrently(i -> tx.executeWithoutResult(s -> {
            int available = jdbc.sql("select available_copies from book where id = ?").param(bookId).query(Integer.class).single();
            if (available == 0) {
                throw new IllegalStateException("none left");
            }
            await(readDone); // everyone has now read available = 1
            jdbc.sql("update book set available_copies = ? where id = ?").params(available - 1, bookId).update();
            jdbc.sql("insert into loan (book_id, member_id, borrowed_on, due_on, fine) values (?, ?, ?, ?, 0)")
                    .params(bookId, memberIds.get(i), LocalDate.of(2026, 11, 1), LocalDate.of(2026, 11, 15)).update();
        }));

    /** Two people changed the same Book row at once; the loser is told to retry. */
    @ExceptionHandler(ObjectOptimisticLockingFailureException.class)
    ProblemDetail raced(ObjectOptimisticLockingFailureException e) {
        return ProblemDetail.forStatusAndDetail(HttpStatus.CONFLICT,
                "someone else changed this book at the same moment, please retry");
    }

The SQL your service quietly sends

select m1_0.id,m1_0.email,m1_0.name from member m1_0 where m1_0.id=?
select b1_0.id,b1_0.author,b1_0.available_copies,b1_0.isbn,b1_0.title,b1_0.total_copies,b1_0.version from book b1_0 where b1_0.id=?
select l1_0.id from loan l1_0 where l1_0.member_id=? and l1_0.book_id=? and l1_0.returned_on is null fetch first ? rows only
select count(l1_0.id) from loan l1_0 where l1_0.member_id=? and l1_0.returned_on is null
insert into loan (book_id,borrowed_on,due_on,fine,member_id,returned_on,id) values (?,?,?,?,?,?,default)
update book set author=?,available_copies=?,isbn=?,title=?,total_copies=?,version=? where id=? and version=?

The N+1 trap: LAZY is not free

5 loans, each with its own book and its own member
findAllByOrderByIdAsc() then read book title + member name: 11 SQL statements
findAllWithDetails() (join fetch) then the same reads:      1 SQL statement
LoanService.listLoans() as called by GET /api/loans:         1 SQL statement

interface LoanRepository extends JpaRepository<Loan, Long> {

    long countByMemberIdAndReturnedOnIsNull(Long memberId);

    boolean existsByMemberIdAndBookIdAndReturnedOnIsNull(Long memberId, Long bookId);

    /** The innocent-looking version: loans only, book and member are lazy proxies. */
    List<Loan> findAllByOrderByIdAsc();

    /** The same list in one SQL statement: JOIN FETCH pulls book and member in with each loan. */
    @Query("select l from Loan l join fetch l.book join fetch l.member order by l.id")
    List<Loan> findAllWithDetails();
}

Three smaller surprises from building this on Boot 4

    @ExceptionHandler(MethodArgumentNotValidException.class)
    ProblemDetail invalid(MethodArgumentNotValidException e) {
        Map<String, String> errors = new TreeMap<>();
        e.getBindingResult().getFieldErrors().forEach(f -> errors.putIfAbsent(f.getField(), f.getDefaultMessage()));
        ProblemDetail problem = ProblemDetail.forStatusAndDetail(HttpStatus.BAD_REQUEST, "request body failed validation");
        problem.setProperty("errors", errors);
        return problem;
    }

WARN 2278 --- [           main] JpaBaseConfiguration$JpaWebConfiguration : spring.jpa.open-in-view is enabled by default. Therefore, database queries may be performed during view rendering. Explicitly configure spring.jpa.open-in-view to disable this warning

Should you build it this way?

For a semester project: yes, and keep all three stages in your report. Examiners see a working console app, then a design argument (rules separated from storage), then a real concurrency fix. That is a stronger story than a menu with a database bolted on.

For a real library: not as written. The H2 database here lives in memory and resets on every start, so swap in PostgreSQL or MySQL before storing anything you care about. There is also no login, no search, no reservation queue, and the fine is calculated but never collected. And optimistic locking is the right bet when conflicts are rare; if one popular title is borrowed all day, a pessimistic lock or a retry loop is worth the extra code.

Further reading

• Companion module: library-management, with every transcript in output/
• LibraryConsole.java and demo input: the single-file version from the top of this article
• Spring Data JPA Projections on ankurm.com
• Spring Boot 4 Test Slices on ankurm.com
• Top 50 Java Interview Questions for Freshers on ankurm.com
• Spring Boot 4.1.0 release announcement
• RFC 9457: Problem Details for HTTP APIs