Java模块化案例

本文目录导读：

1. 项目结构
2. 模块代码示例
3. 编译与运行
4. 模块依赖关系图
5. 关键特点

我将为您提供一个完整的Java模块化系统案例,使用JPMS（Java Platform Module System）构建一个简单的图书管理应用。

项目结构

book-management-system/
├── src/
│   ├── book.api/
│   │   ├── module-info.java
│   │   └── com/bookapp/api/
│   │       ├── Book.java
│   │       └── BookService.java
│   ├── book.core/
│   │   ├── module-info.java
│   │   └── com/bookapp/core/
│   │       ├── BookServiceImpl.java
│   │       └── BookRepository.java
│   ├── book.database/
│   │   ├── module-info.java
│   │   └── com/bookapp/db/
│   │       └── DatabaseBookRepository.java
│   └── book.app/
│       ├── module-info.java
│       └── com/bookapp/main/
│           └── MainApplication.java

模块代码示例

book.api 模块

module-info.java

module book.api {
    exports com.bookapp.api;
}

Book.java

package com.bookapp.api;
public class Book {
    private String id;
    private String title;
    private String author;
    private String isbn;
    private double price;
    public Book(String id, String title, String author, String isbn, double price) {
        this.id = id;
        this.title = title;
        this.author = author;
        this.isbn = isbn;
        this.price = price;
    }
    public String getId() { return id; }
    public String getTitle() { return title; }
    public String getAuthor() { return author; }
    public String getIsbn() { return isbn; }
    public double getPrice() { return price; }
    @Override
    public String toString() {
        return "Book{id='" + id + "', title='" + title + "', author='" + author + 
               "', isbn='" + isbn + "', price=" + price + "}";
    }
}

BookService.java

package com.bookapp.api;
import java.util.List;
import java.util.Optional;
public interface BookService {
    void addBook(Book book);
    Optional<Book> findBookById(String id);
    List<Book> getAllBooks();
    void updateBook(Book book);
    void deleteBook(String id);
}

book.core 模块

module-info.java

module book.core {
    requires book.api;
    requires book.database;
    exports com.bookapp.core;
    uses com.bookapp.db.BookRepository;
}

BookServiceImpl.java

package com.bookapp.core;
import com.bookapp.api.Book;
import com.bookapp.api.BookService;
import com.bookapp.db.BookRepository;
import java.util.List;
import java.util.Optional;
import java.util.ServiceLoader;
public class BookServiceImpl implements BookService {
    private final BookRepository repository;
    public BookServiceImpl() {
        // 使用ServiceLoader进行服务发现
        this.repository = ServiceLoader.load(BookRepository.class)
                .findFirst()
                .orElseThrow(() -> new RuntimeException("没有找到BookRepository的实现"));
    }
    @Override
    public void addBook(Book book) {
        repository.save(book);
    }
    @Override
    public Optional<Book> findBookById(String id) {
        return repository.findById(id);
    }
    @Override
    public List<Book> getAllBooks() {
        return repository.findAll();
    }
    @Override
    public void updateBook(Book book) {
        repository.update(book);
    }
    @Override
    public void deleteBook(String id) {
        repository.delete(id);
    }
}

book.database 模块

module-info.java

module book.database {
    requires book.api;
    exports com.bookapp.db;
    provides com.bookapp.db.BookRepository with com.bookapp.db.DatabaseBookRepository;
}

BookRepository.java

package com.bookapp.db;
import com.bookapp.api.Book;
import java.util.List;
import java.util.Optional;
public interface BookRepository {
    void save(Book book);
    Optional<Book> findById(String id);
    List<Book> findAll();
    void update(Book book);
    void delete(String id);
}

DatabaseBookRepository.java

package com.bookapp.db;
import com.bookapp.api.Book;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.stream.Collectors;
public class DatabaseBookRepository implements BookRepository {
    private final Map<String, Book> bookStore = new ConcurrentHashMap<>();
    @Override
    public void save(Book book) {
        bookStore.put(book.getId(), book);
        System.out.println("[数据库] 保存书籍: " + book);
    }
    @Override
    public Optional<Book> findById(String id) {
        return Optional.ofNullable(bookStore.get(id));
    }
    @Override
    public List<Book> findAll() {
        return bookStore.values().stream()
                .sorted(Comparator.comparing(Book::getId))
                .collect(Collectors.toList());
    }
    @Override
    public void update(Book book) {
        if (bookStore.containsKey(book.getId())) {
            bookStore.put(book.getId(), book);
            System.out.println("[数据库] 更新书籍: " + book);
        } else {
            throw new IllegalArgumentException("书籍不存在: " + book.getId());
        }
    }
    @Override
    public void delete(String id) {
        if (bookStore.remove(id) != null) {
            System.out.println("[数据库] 删除书籍: " + id);
        } else {
            throw new IllegalArgumentException("书籍不存在: " + id);
        }
    }
}

book.app 模块

module-info.java

module book.app {
    requires book.api;
    requires book.core;
}

MainApplication.java

package com.bookapp.main;
import com.bookapp.api.Book;
import com.bookapp.api.BookService;
import com.bookapp.core.BookServiceImpl;
import java.util.List;
import java.util.Optional;
public class MainApplication {
    public static void main(String[] args) {
        BookService bookService = new BookServiceImpl();
        // 创建测试数据
        Book book1 = new Book("001", "Java编程思想", "Bruce Eckel", "978-7-111-54742-6", 108.0);
        Book book2 = new Book("002", "Java核心技术", "Cay S. Horstmann", "978-7-111-54743-3", 128.0);
        Book book3 = new Book("003", "Effective Java", "Joshua Bloch", "978-7-111-54744-0", 98.0);
        // 添加书籍
        System.out.println("\n=== 添加书籍 ===");
        bookService.addBook(book1);
        bookService.addBook(book2);
        bookService.addBook(book3);
        // 查询所有书籍
        System.out.println("\n=== 查询所有书籍 ===");
        List<Book> books = bookService.getAllBooks();
        books.forEach(System.out::println);
        // 按ID查询书籍
        System.out.println("\n=== 按ID查询书籍 (ID: 002) ===");
        Optional<Book> foundBook = bookService.findBookById("002");
        foundBook.ifPresent(book -> System.out.println("找到书籍: " + book));
        // 更新书籍
        System.out.println("\n=== 更新书籍 (ID: 003) ===");
        Book updatedBook = new Book("003", "Effective Java第3版", "Joshua Bloch", "978-7-111-54744-0", 118.0);
        bookService.updateBook(updatedBook);
        // 再次查询验证更新
        System.out.println("\n=== 验证更新结果 ===");
        bookService.findBookById("003").ifPresent(System.out::println);
        // 删除书籍
        System.out.println("\n=== 删除书籍 (ID: 001) ===");
        bookService.deleteBook("001");
        // 最终状态
        System.out.println("\n=== 最终书籍列表 ===");
        bookService.getAllBooks().forEach(System.out::println);
    }
}

编译与运行

# 编译所有模块
javac -d out $(find src -name "*.java")
# 运行应用程序
java --module-path out -m book.app/com.bookapp.main.MainApplication

模块依赖关系图

book.app --- requires ---> book.core
                           |
                           --- requires ---> book.api
                           --- requires ---> book.database
                                              |
                                              --- requires ---> book.api
依赖关系:
book.api       → 无依赖
book.core      → requires book.api, book.database
book.database  → requires book.api
book.app       → requires book.api, book.core

关键特点

1. 强封装性: 每个模块只暴露需要的公共API
2. 显式依赖: 通过requires明确声明依赖
3. 服务加载器: 使用provides和uses实现依赖注入
4. 模块隔离: 每个模块独立编译和打包
5. 版本控制: 模块通过module-info.java管理版本

这个案例展示了Java模块化系统的核心概念,包括模块定义、依赖管理和服务提供机制。