Architecture at a Glance - huanfenz/BookManager2

Source Files

This page is generated from the following source files:

This document provides a comprehensive architectural analysis of the BookManager2 system, a Spring Boot-based library management application. The system implements a classic three-tier architecture with clear separation between presentation, business logic, and data access layers.

Technology Stack and Dependencies

The project is built on a mature Java technology stack designed for enterprise web applications. The core framework and dependencies are defined in the Maven configuration.

Technology	Version	Purpose	Selection Rationale
Spring Boot	2.5.6	Core framework	Rapid development, auto-configuration, embedded server
MyBatis	2.0.0	ORM framework	SQL flexibility, fine-grained control over queries
MySQL	-	Primary database	Relational data model, ACID compliance
Redis	-	Caching layer	Session storage, performance optimization
Maven	-	Build tool	Dependency management, build lifecycle
Java	1.8	Runtime platform	Enterprise compatibility, LTS support

The pom.xml:1-82 file defines all project dependencies including the Spring Boot starter web, MyBatis integration, Redis support, and MySQL connector. The configuration also includes the MyBatis generator plugin for reverse engineering database schemas into Java entities and mappers.

The MyBatis framework provides the data persistence layer, with mapper interfaces defining database operations. The src/main/java/com/wangpeng/bms/mapper/BookInfoMapper.java:8-35 demonstrates the standard CRUD operations pattern including selectByPrimaryKey, insertSelective, updateByPrimaryKeySelective, and custom query methods for pagination and search functionality.

Application Architecture Layers

The system follows a strict layered architecture pattern with well-defined boundaries between components. Each layer has specific responsibilities and communicates only with adjacent layers.

正在加载图表渲染器...

Controller Layer

The controller layer handles HTTP request routing and response formatting. Controllers are annotated with @RestController and @RequestMapping to define REST endpoints. The src/main/java/com/wangpeng/bms/web/BookInfoController.java:61-64 shows a typical update endpoint that receives a BookInfo object via @RequestBody and delegates to the service layer.

Key responsibilities:

Request validation and parameter binding
HTTP status code management
JSON serialization/deserialization
Service layer invocation

Service Layer

The service layer encapsulates business logic and transaction management. Services implement interfaces and are annotated with @Service. The src/main/java/com/wangpeng/bms/service/impl/BookInfoServiceImpl.java:69-73 demonstrates the delegation pattern where the service method calls the mapper's updateByPrimaryKeySelective method, which only updates non-null fields.

Data Access Layer

MyBatis mappers define database operations through Java interfaces paired with XML mapping files. The src/main/java/com/wangpeng/bms/mapper/BookInfoMapper.java:8-35 interface declares methods for:

Primary key operations: selectByPrimaryKey, deleteByPrimaryKey
Selective operations: insertSelective, updateByPrimaryKeySelective
Batch operations: selectAll, selectAllByLimit
Search functionality: selectBySearch, selectCountBySearch

Request Interception and Security

The security architecture implements a session-based authentication pattern with configurable path-based access control. The interceptor configuration defines which URLs require authentication and which are publicly accessible.

正在加载图表渲染器...

Interceptor Configuration

The src/main/java/com/wangpeng/bms/config/InterceptorConfig.java:10-61 class implements WebMvcConfigurer to register interceptors. The configuration defines three path categories:

Protected paths (all array): All HTML pages and API endpoints under /bookInfo/**, /bookType/**, /borrow/**, /update/**, /user/**
Public paths (aboutLogin array): Root path, index.html, register.html, login and registration endpoints
Reader paths (aboutReader array): Reader-specific pages and requests

The interceptor registration is currently commented out in the configuration, indicating the system may be in development mode or using alternative security mechanisms.

Authentication Logic

The src/main/java/com/wangpeng/bms/interceptor/UserInterceptor.java:10-26 implements HandlerInterceptor to validate user sessions. The preHandle method:

Retrieves the userObj attribute from the HTTP session
Returns true if the user is authenticated, allowing the request to proceed
Redirects to /index.html and returns false if no user is found in session

Business Logic and Transaction Management

The system implements transactional business operations to ensure data consistency across multiple database tables. The borrowing workflow demonstrates the transaction management pattern.

Book Borrowing Transaction

The src/main/java/com/wangpeng/bms/web/BorrowController.java:67-106 implements the book borrowing logic with the @Transactional annotation. The operation performs:

Book availability check: Queries the book by ID and verifies isborrowed status
Business rule validation: Throws NotEnoughException if book is already borrowed
Book status update: Sets isborrowed flag to 1
Borrow record creation: Inserts a new record with user ID, book ID, and timestamp

The transaction includes manual rollback handling via TransactionAspectSupport.currentTransactionStatus().setRollbackOnly() when exceptions occur, ensuring atomicity of the multi-step operation.

File Upload Handling

The src/main/java/com/wangpeng/bms/web/UpdateController.java:21-88 manages file uploads for book cover images. The implementation:

Resolves the static directory path using ResourceUtils.getURL("classpath:")
Creates target directories if they don't exist
Parses multipart request data using ServletFileUpload
Generates unique filenames by prepending timestamps
Returns the public URL for the uploaded file

The upload endpoint at /updateImg accepts multipart form data and stores files in the pictures subdirectory under static resources.

Core Module Interactions

The following sequence diagram illustrates the end-to-end flow of a book update operation, showing the interaction between layers.

正在加载图表渲染器...

Evidence Points

The sequence diagram is based on the following code evidence:

Controller endpoint definition: src/main/java/com/wangpeng/bms/web/BookInfoController.java:61-64
Service layer delegation: src/main/java/com/wangpeng/bms/service/impl/BookInfoServiceImpl.java:69-73
Mapper interface method: src/main/java/com/wangpeng/bms/mapper/BookInfoMapper.java:8-35

Module Dependency Graph

The following diagram illustrates the dependency relationships between core modules in the system.

正在加载图表渲染器...

Key Design Decisions

1. MyBatis Over JPA/Hibernate

The project chose MyBatis for data persistence instead of JPA/Hibernate. This decision provides:

Fine-grained SQL control: Developers can optimize queries for specific use cases
Explicit mapping: XML mapping files clearly define the relationship between objects and tables
Legacy database compatibility: Easier integration with existing database schemas

The trade-off is increased boilerplate code and manual mapping maintenance.

2. Session-Based Authentication

The system uses HTTP session storage for user authentication rather than JWT tokens. This approach:

Simplifies implementation for a monolithic application
Provides automatic session expiration handling
Integrates seamlessly with Spring Security patterns

The limitation is reduced scalability for distributed deployments requiring session replication.

3. Selective Update Pattern

The mapper methods insertSelective and updateByPrimaryKeySelective only modify non-null fields. This pattern:

Reduces unnecessary database updates
Allows partial entity updates without fetching the full record
Prevents accidental null overwrites

Evidence: src/main/java/com/wangpeng/bms/mapper/BookInfoMapper.java:8-35 shows both selective and full update methods.

4. Manual Transaction Rollback

The borrowing operation implements manual rollback via TransactionAspectSupport.currentTransactionStatus().setRollbackOnly(). This approach:

Provides explicit control over transaction boundaries
Allows custom exception handling before rollback
Enables logging and debugging of failure scenarios

Evidence: src/main/java/com/wangpeng/bms/web/BorrowController.java:67-106 shows the try-catch block with manual rollback.

5. File Storage Strategy

Uploaded files are stored in the application's static resources directory rather than external storage. This design:

Simplifies deployment for single-server installations
Provides direct URL access to uploaded files
Requires no additional infrastructure

The limitation is lack of scalability for distributed deployments and potential issues with containerized deployments where the static directory may not persist.

6. Commented Interceptor Configuration

The interceptor registration in InterceptorConfig is commented out, suggesting:

Development mode with disabled security for testing
Alternative security mechanism in use
Configuration to be enabled in production deployment

Evidence: src/main/java/com/wangpeng/bms/config/InterceptorConfig.java:10-61 shows commented registry.addInterceptor() calls.

7. Vue.js Frontend Integration

The frontend is pre-built and served as static JavaScript files from src/main/resources/static/. This architecture:

Separates frontend and backend development
Enables independent deployment of frontend assets
Uses REST API for communication

Evidence: src/main/resources/static/static/js/app.3082c59a.js:1-1 contains the compiled Vue.js application.

Configuration and Startup

The application follows Spring Boot conventions for configuration and startup:

Main Application Class: BookManagerApplication serves as the entry point with @SpringBootApplication annotation
Externalized Configuration: Application properties defined in application.properties or application.yml (需要确认: configuration file not provided in source files)
Component Scanning: Spring automatically discovers and registers beans in the com.wangpeng.bms package
MyBatis Mapper Scanning: Mapper interfaces are located via @MapperScan or individual @Mapper annotations (需要确认: scanner configuration not visible in provided files)

Build Configuration

The pom.xml:1-82 defines resource handling to include XML mapper files:

Java source directory includes **/*.xml for MyBatis mapper files
Resources directory includes all files for static assets and configuration

The Maven wrapper (.mvn/wrapper/MavenWrapperDownloader.java:1-118) ensures consistent Maven versions across development environments.

Known Limitations

Hardcoded URL in File Upload: The UpdateController returns a hardcoded localhost URL (http://localhost:8092/BookManager/), which will break in production environments. Evidence: src/main/java/com/wangpeng/bms/web/UpdateController.java:21-88
Console Logging: Error handling uses System.out.println() and e.printStackTrace() instead of proper logging frameworks. Evidence: src/main/java/com/wangpeng/bms/web/BorrowController.java:67-106
Disabled Security: The interceptor configuration is commented out, potentially leaving endpoints unprotected. Evidence: src/main/java/com/wangpeng/bms/config/InterceptorConfig.java:10-61
No Input Validation: Controllers lack explicit input validation annotations (@Valid, @NotNull), relying on frontend validation. Evidence: src/main/java/com/wangpeng/bms/web/BookInfoController.java:61-64