本文作为Spring框架的实战指南，通过完整的项目案例，展示Spring框架在实际开发中的应用。从项目规划、架构设计到具体实现，手把手教您完成一个完整的Spring框架项目，将理论知识转化为实际技能。

一、项目概述

1.1 项目需求

项目背景： 开发一个基于Spring框架的图书管理系统，提供图书的增删改查、借阅管理、用户管理等功能。

核心需求

  • 用户注册、登录、权限管理
  • 图书信息CRUD操作
  • 图书借阅和归还功能
  • 借阅记录查询
  • 数据分页和搜索
  • RESTful API设计

1.2 技术选型

技术栈

  • 框架: Spring 5.3 + Spring MVC
  • 数据访问: Spring JDBC / MyBatis
  • 数据库: MySQL 8.0
  • 构建工具: Maven
  • 服务器: Tomcat 9.0

开发工具

  • IDE: IntelliJ IDEA
  • 数据库工具: DBeaver
  • API测试: Postman

二、项目架构

2.1 整体架构

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
┌─────────────────────────────────────┐
│      Controller Layer                │
│  - BookController                   │
│  - UserController                    │
│  - BorrowController                 │
├─────────────────────────────────────┤
│      Service Layer                   │
│  - BookService                       │
│  - UserService                       │
│  - BorrowService                     │
├─────────────────────────────────────┤
│      Repository Layer                │
│  - BookRepository                    │
│  - UserRepository                    │
│  - BorrowRepository                  │
├─────────────────────────────────────┤
│      Database (MySQL)                │
└─────────────────────────────────────┘

2.2 项目结构

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
book-management/
├── src/
│   ├── main/
│   │   ├── java/
│   │   │   └── com/example/book/
│   │   │       ├── BookManagementApplication.java
│   │   │       ├── config/           # 配置类
│   │   │       │   ├── WebConfig.java
│   │   │       │   └── DataSourceConfig.java
│   │   │       ├── controller/       # 控制器
│   │   │       │   ├── BookController.java
│   │   │       │   └── UserController.java
│   │   │       ├── service/         # 服务层
│   │   │       │   ├── BookService.java
│   │   │       │   └── UserService.java
│   │   │       ├── repository/      # 数据访问层
│   │   │       │   ├── BookRepository.java
│   │   │       │   └── UserRepository.java
│   │   │       ├── model/           # 实体类
│   │   │       │   ├── Book.java
│   │   │       │   └── User.java
│   │   │       └── dto/             # 数据传输对象
│   │   │           └── BookDTO.java
│   │   └── resources/
│   │       ├── application.properties
│   │       └── db/
│   │           └── schema.sql
│   └── test/
│       └── java/
└── pom.xml

三、核心实现

3.1 项目初始化

1. 创建Maven项目

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
<!-- pom.xml -->
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.example</groupId>
    <artifactId>book-management</artifactId>
    <version>1.0.0</version>
    <packaging>war</packaging>

    <properties>
<spring.version>5.3.21</spring.version>
<maven.compiler.source>11</maven.compiler.source>
<maven.compiler.target>11</maven.compiler.target>
    </properties>

    <dependencies>
<!-- Spring Core -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>${spring.version}</version>
</dependency>

<!-- Spring Web MVC -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>${spring.version}</version>
</dependency>

<!-- Spring JDBC -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>${spring.version}</version>
</dependency>

<!-- MySQL驱动 -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>8.0.33</version>
</dependency>

<!-- Jackson JSON -->
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>2.13.3</version>
</dependency>

<!-- Servlet API -->
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>javax.servlet-api</artifactId>
<version>4.0.1</version>
<scope>provided</scope>
</dependency>
    </dependencies>
</project>

3.2 配置类实现

WebConfig.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
@Configuration
@EnableWebMvc
@ComponentScan(basePackages = "com.example.book")
public class WebConfig implements WebMvcConfigurer {

    // 视图解析器
    @Bean
    public ViewResolver viewResolver() {
InternalResourceViewResolver resolver = new InternalResourceViewResolver();
resolver.setPrefix("/WEB-INF/views/");
resolver.setSuffix(".jsp");
return resolver;
    }

    // 静态资源处理
    @Override
    public void addResourceHandlers(ResourceHandlerRegistry registry) {
registry.addResourceHandler("/static/")
.addResourceLocations("/static/");
    }

    // JSON消息转换器
    @Override
    public void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
converters.add(new MappingJackson2HttpMessageConverter());
    }
}

DataSourceConfig.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
@Configuration
@PropertySource("classpath:application.properties")
public class DataSourceConfig {

    @Value("${db.driver}")
    private String driver;

    @Value("${db.url}")
    private String url;

    @Value("${db.username}")
    private String username;

    @Value("${db.password}")
    private String password;

    @Bean
    public DataSource dataSource() {
DriverManagerDataSource dataSource = new DriverManagerDataSource();
dataSource.setDriverClassName(driver);
dataSource.setUrl(url);
dataSource.setUsername(username);
dataSource.setPassword(password);
return dataSource;
    }

    @Bean
    public JdbcTemplate jdbcTemplate(DataSource dataSource) {
return new JdbcTemplate(dataSource);
    }

    @Bean
    public PlatformTransactionManager transactionManager(DataSource dataSource) {
return new DataSourceTransactionManager(dataSource);
    }
}

3.3 实体类定义

Book.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class Book {
    private Long id;
    private String title;
    private String author;
    private String isbn;
    private String publisher;
    private Date publishDate;
    private Integer totalCopies;
    private Integer availableCopies;
    private Date createTime;
    private Date updateTime;

    // Getters and Setters
}

3.4 Repository层实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
BookRepository.java：**
java
@Repository
public class BookRepository {

    @Autowired
    private JdbcTemplate jdbcTemplate;

    private final RowMapper<Book> bookRowMapper = (rs, rowNum) -> {
Book book = new Book();
book.setId(rs.getLong("id"));
book.setTitle(rs.getString("title"));
book.setAuthor(rs.getString("author"));
book.setIsbn(rs.getString("isbn"));
book.setPublisher(rs.getString("publisher"));
book.setPublishDate(rs.getDate("publish_date"));
book.setTotalCopies(rs.getInt("total_copies"));
book.setAvailableCopies(rs.getInt("available_copies"));
book.setCreateTime(rs.getTimestamp("create_time"));
book.setUpdateTime(rs.getTimestamp("update_time"));
return book;
    };

    public List<Book> findAll() {
String sql = "SELECT * FROM books ORDER BY create_time DESC";
return jdbcTemplate.query(sql, bookRowMapper);
    }

    public Book findById(Long id) {
String sql = "SELECT * FROM books WHERE id = ?";
return jdbcTemplate.queryForObject(sql, bookRowMapper, id);
    }

    public void save(Book book) {
String sql = "INSERT INTO books (title, author, isbn, publisher, publish_date, total_copies, available_copies) " +
"VALUES (?, ?, ?, ?, ?, ?, ?)";
jdbcTemplate.update(sql,
book.getTitle(), book.getAuthor(), book.getIsbn(),
book.getPublisher(), book.getPublishDate(),
book.getTotalCopies(), book.getAvailableCopies());
    }

    public void update(Book book) {
String sql = "UPDATE books SET title=?, author=?, isbn=?, publisher=?, " +
"publish_date=?, total_copies=?, available_copies=? WHERE id=?";
jdbcTemplate.update(sql,
book.getTitle(), book.getAuthor(), book.getIsbn(),
book.getPublisher(), book.getPublishDate(),
book.getTotalCopies(), book.getAvailableCopies(), book.getId());
    }

    public void deleteById(Long id) {
String sql = "DELETE FROM books WHERE id = ?";
jdbcTemplate.update(sql, id);
    }
}

3.5 Service层实现

BookService.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
@Service
@Transactional
public class BookService {

    @Autowired
    private BookRepository bookRepository;

    public List<Book> getAllBooks() {
return bookRepository.findAll();
    }

    public Book getBookById(Long id) {
return bookRepository.findById(id);
    }

    public void createBook(Book book) {
book.setAvailableCopies(book.getTotalCopies());
bookRepository.save(book);
    }

    public void updateBook(Book book) {
bookRepository.update(book);
    }

    public void deleteBook(Long id) {
bookRepository.deleteById(id);
    }

    @Transactional(readOnly = true)
    public List<Book> searchBooks(String keyword) {
// 实现搜索逻辑
return bookRepository.findByKeyword(keyword);
    }
}

3.6 Controller层实现

BookController.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
@RestController
@RequestMapping("/api/books")
public class BookController {

    @Autowired
    private BookService bookService;

    @GetMapping
    public ResponseEntity<List<Book>> getAllBooks() {
return ResponseEntity.ok(bookService.getAllBooks());
    }

    @GetMapping("/{id}")
    public ResponseEntity<Book> getBookById(@PathVariable Long id) {
Book book = bookService.getBookById(id);
return ResponseEntity.ok(book);
    }

    @PostMapping
    public ResponseEntity<Book> createBook(@RequestBody Book book) {
bookService.createBook(book);
return ResponseEntity.status(HttpStatus.CREATED).body(book);
    }

    @PutMapping("/{id}")
    public ResponseEntity<Book> updateBook(@PathVariable Long id, @RequestBody Book book) {
book.setId(id);
bookService.updateBook(book);
return ResponseEntity.ok(book);
    }

    @DeleteMapping("/{id}")
    public ResponseEntity<Void> deleteBook(@PathVariable Long id) {
bookService.deleteBook(id);
return ResponseEntity.noContent().build();
    }

    @GetMapping("/search")
    public ResponseEntity<List<Book>> searchBooks(@RequestParam String keyword) {
return ResponseEntity.ok(bookService.searchBooks(keyword));
    }
}

四、部署上线

4.1 打包应用

使用Maven打包

1
2
3
4
5
6
7
8
9

# 打包WAR文件

mvn clean package

# 输出位置

# target/book-management-1.0.0.war

4.2 部署到Tomcat

1. 部署步骤

  1. 将WAR文件复制到Tomcat的webapps目录
  2. 启动Tomcat服务器
  3. 访问：http://localhost:8080/book-management-1.0.0/api/books

2. 配置server.xml（可选）

1
<Context path="/book" docBase="/path/to/book-management-1.0.0.war" />

五、项目总结

5.1 经验总结

开发过程中的关键点

  1. 分层架构：清晰的分层便于维护和测试
  2. 依赖注入：使用Spring的IoC容器管理Bean
  3. 事务管理：使用声明式事务简化代码
  4. RESTful设计：遵循REST规范设计API
  5. 异常处理：统一的异常处理机制

5.2 优化建议

性能优化

  • 使用连接池优化数据库连接
  • 添加缓存机制（Redis）
  • 使用分页查询避免全表扫描
  • 优化SQL查询语句

功能扩展

  • 添加用户认证和授权
  • 实现文件上传功能
  • 添加日志记录
  • 集成Swagger API文档

六、总结

通过本系列文章的学习，您已经全面掌握了Spring框架从入门到实战的完整知识体系。希望这些内容能够帮助您在Spring框架开发中取得更好的成果。

本文标题： Spring框架实战篇

本文作者： 狂欢马克思

发布时间： 2019年04月24日 00:00

最后更新： 2026年09月16日 05:40

原始链接： https://haoxiang.eu.org/cc5da76e/

版权声明： 本文著作权归作者所有，均采用CC BY-NC-SA 4.0许可协议，转载请注明出处！

赏
× 喜欢就赞赏一下呗！
打赏二维码