下面我们将以 **IntelliJ IDEA** 为开发工具，从零开始详细演示如何创建一个 Spring MVC 项目，包含核心组件配置、控制器编写、参数绑定实现，并完成 Tomcat 部署与测试的全过程。
---
## ✅ 一、Spring MVC 核心组件回顾
| 组件 | 作用 |
|------|------|
| `DispatcherServlet` | 前端控制器，接收所有请求并分发给对应 Controller |
| `Controller` | 处理具体业务逻辑，返回模型数据或视图 |
| `ViewResolver` | 将逻辑视图名（如 `"userDetail"`）解析为实际页面路径（如 `/WEB-INF/jsp/userDetail.jsp`） |
### 🔄 请求处理流程：
```
浏览器 → DispatcherServlet → HandlerMapping → Controller →
(ModelAndView / JSON
) → ViewResolver → JSP 或 @ResponseBody → 返回响应
```
---
## ✅
二、IDEA 中创建 Spring MVC 项目的详细步骤
### 步骤 1：新建 Maven Web 项目
1. 打开 IntelliJ IDEA → `File` → `New` → `Project`
2. 选择左侧 `Maven` → 勾选 **"Create from archetype"**
3. 在列表中找到并选择：
`org.apache.maven.archetypes
:maven-archetype-webapp`
4. 点击 Next
5. 输入项目信息：
- GroupId
: `com.example`
- ArtifactId
: `ssm-demo`
- Version
: `1.0-SNAPSHOT`
6. 点击 Next → 设置本地 Maven 路径（一般自动识别）
7. 点击 Finish
> ⚠️ 注意：此时生成的是传统 Web 项目，缺少 Java 和 resources 目录，需要手动补全。
---
### 步骤 2：补全标准目录结构
右键项目根目录 → `New` → `Directory`
创建以下目录：
```
src/main/java → 存放 Java 源码
src/main/resources → 存放配置文件
src/main/webapp/WEB-INF/jsp → 存放 JSP 页面
```
然后设置源码目录：
1. 右键 `java` 目录 → `Mark Directory as` → `Sources Root`
2. 右键 `resources` 目录 → `Mark Directory as` → `Resources Root`
3. 确保 `webapp` 是 Web Resource Directory（IDEA 会自动识别）
---
### 步骤 3：添加依赖（pom.xml）
编辑 `pom.xml` 文件，添加 Spring MVC 及相关依赖：
```xml
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http
://maven.apache.org/POM/4.0.0"
xmlns
:xsi="http
://www.w3.org/2001/XMLSchema-instance"
xsi
:schemaLocation="http
://maven.apache.org/POM/4.0.0
http
://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.example</groupId>
<artifactId>ssm-demo</artifactId>
<version>1.0-SNAPSHOT</version>
<packaging>war</packaging>
<properties>
<spring.version>5.3.21</spring.version>
<maven.compiler.source>8</maven.compiler.source>
<maven.compiler.target>8</maven.compiler.target>
</properties>
<dependencies>
<!-- Spring MVC -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>${spring.version}</version>
</dependency>
<!-- Servlet API -->
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>javax.servlet-api</artifactId>
<version>4.0.1</version>
<scope>provided</scope>
</dependency>
<!-- JSP 支持 -->
<dependency>
<groupId>javax.servlet.jsp</groupId>
<artifactId>jsp-api</artifactId>
<version>2.3.3</version>
<scope>provided</scope>
</dependency>
<!-- JSTL 标签库 -->
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>jstl</artifactId>
<version>1.2</version>
</dependency>
<!-- 日志 -->
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>1.2.17</version>
</dependency>
</dependencies>
<build>
<finalName>ssm-demo</finalName>
<plugins>
<!-- 编译插件 -->
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.8.1</version>
<configuration>
<source>8</source>
<target>8</target>
</configuration>
</plugin>
<!-- WAR 打包插件 -->
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-war-plugin</artifactId>
<version>3.3.0</version>
</plugin>
</plugins>
</build>
</project>
```
保存后，Maven 会自动下载依赖。可在右侧 `Maven` 面板点击刷新按钮同步。
---
### 步骤 4：创建 Java 类结构
在 `src/main/java/com/example` 下创建如下包和类：
#### 1. 实体类：User.java
```java
package com.example.model;
public class User {
private Long id;
private String name;
private String email;
// 构造方法
public User
() {}
public User
(Long id, String name, String email
) {
this.id = id;
this.name = name;
this.email = email;
}
// Getters and Setters
public Long getId
() { return id; }
public void setId
(Long id
) { this.id = id; }
public String getName
() { return name; }
public void setName
(String name
) { this.name = name; }
public String getEmail
() { return email; }
public void setEmail
(String email
) { this.email = email; }
}
```
---
#### 2. Service
接口与实现
```java
package com.example.service;
import com.example.model.User;
public interface UserService {
User findById
(Long id
);
void save
(User user
);
}
```
```java
package com.example.service.impl;
import com.example.model.User;
import com.example.service.UserService;
import org.springframework.stereotype.Service;
@Service
public class UserServiceImpl implements UserService {
@Override
public User findById
(Long id
) {
if
(id == 1
) {
return new User
(1L, "张三", "zhangsan@example.com"
);
}
return null;
}
@Override
public void save
(User user
) {
System.out.println
("保存用户：" + user.getName
());
}
}
```
---
#### 3. 控制器：UserController.java
```java
package com.example.controller;
import com.example.model.User;
import com.example.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.*;
@Controller
@
RequestMapping("/user"
)
public class UserController {
@Autowired
private UserService userService;
// ▪ 基本参数绑定：/getUser?id=1
@
RequestMapping("/getUser"
)
public String getUser
(@RequestParam
("id"
) Long id, Model model
) {
User user = userService.findById
(id
);
model.addAttribute
("user", user
);
return "userDetail"; // 查找 /WEB-INF/jsp/userDetail.jsp
}
// ▪ 实体类参数绑定：POST /addUser
@
RequestMapping("/addUser"
)
@ResponseBody
public String addUser
(User user
) {
userService.save
(user
);
return "{\"status\"
:\"success\",\"message\"
:\"用户添加成功\"}";
}
// ▪ 路径参数绑定：/getUser/1
@
RequestMapping("/getUser/{id}"
)
@ResponseBody
public User getUserByPath
(@PathVariable
("id"
) Long id
) {
return userService.findById
(id
);
}
}
```
---
### 步骤 5：配置 Spring MVC（spring-mvc.xml）
在 `src/main/resources/` 下创建文件：`spring-mvc.xml`
```xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http
://www.springframework.org/schema/beans"
xmlns
:xsi="http
://www.w3.org/2001/XMLSchema-instance"
xmlns
:context="http
://www.springframework.org/schema/context"
xmlns
:mvc="http
://www.springframework.org/schema/mvc"
xsi
:schemaLocation="
http
://www.springframework.org/schema/beans
http
://www.springframework.org/schema/beans/spring-beans.xsd
http
://www.springframework.org/schema/context
http
://www.springframework.org/schema/context/spring-context.xsd
http
://www.springframework.org/schema/mvc
http
://www.springframework.org/schema/mvc/spring-mvc.xsd">
<!-- 扫描 controller 包 -->
<context
:component-scan base-package="com.example.controller" />
<!-- 启用注解驱动（支持 @ResponseBody 等） -->
<mvc
:annotation-driven />
<!-- 视图解析器 -->
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<property name="prefix" value="/WEB-INF/jsp/" />
<property name="suffix" value=".jsp" />
</bean>
</beans>
```
---
### 步骤 6：配置 web.xml
修改 `src/main/webapp/WEB-INF/web.xml`：
```xml
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http
://xmlns.jcp.org/xml/ns/javaee"
xmlns
:xsi="http
://www.w3.org/2001/XMLSchema-instance"
xsi
:schemaLocation="http
://xmlns.jcp.org/xml/ns/javaee
http
://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
version="4.0">
<!-- 配置 DispatcherServlet -->
<servlet>
<servlet-name>dispatcher</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath
:spring-mvc.xml</param-value>
</init-param>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>dispatcher</servlet-name>
<url-pattern>/</url-pattern>
</servlet-mapping>
<!-- 字符编码过滤器 -->
<filter>
<filter-name>encodingFilter</filter-name>
<filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
<init-param>
<param-name>encoding</param-name>
<param-value>UTF-8</param-value>
</init-param>
</filter>
<filter-mapping>
<filter-name>encodingFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
</web-app>
```
---
### 步骤 7：创建 JSP 页面
在 `src/main/webapp/WEB-INF/jsp/userDetail.jsp` 创建：
```jsp
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head><title>用户详情</title></head>
<body>
<h2>用户信息</h2>
<ul>
<li>编号：${user.id}</li>
<li>姓名：${user.name}</li>
<li>邮箱：${user.email}</li>
</ul>
</body>
</html>
```
---
## ✅ 三、配置 Tomcat 并运行（IDEA 图形化操作）
### 步骤 1：添加 Tomcat Server
1. 点击右上角 **Add Configuration**（绿色加号）
2. 点击 `+` → 选择 `Tomcat Server` → `Local`
3. 如果提示未配置，点击 `Configure...` 设置 Tomcat 安装路径（如 `C
:\apache-tomcat-9.0.xx`）
### 步骤 2：部署应用
1. 在弹出窗口中切换到 **Deployment** 标签页
2. 点击 `+` → 选择 `Artifact`
: `ssm-demo
:war exploded`
3. 设置 Application context 为 `/ssm-demo`
### 步骤 3：启动服务器
点击 ▶️ 运行按钮，等待控制台输出：
```
INFO
: Starting ProtocolHandler ["http-nio-8080"]
...
Root WebApplicationContext
: initialization completed
```
说明启动成功！
---
## ✅
四、测试请求（浏览器 / Postman）
### 1. 测试基本参数绑定（跳转 JSP）
URL
:
```
http
://localhost
:8080/ssm-demo/user/getUser?id=1
```
✅ 预期结果：显示用户“张三”的信息页面。
---
### 2. 测试路径参数绑定（返回 JSON）
URL
:
```
http
://localhost
:8080/ssm-demo/user/getUser/1
```
✅ 返回：
```json
{"id"
:1,"name"
:"张三","email"
:"zhangsan@example.com"}
```
---
### 3. 测试表单提交添加用户（Postman）
- URL
: `http
://localhost
:8080/ssm-demo/user/addUser`
- Method
: POST
- Body → x-www-form-urlencoded
:
```
id=2
name=李
四
email=lisi@example.com
```
✅ 返回：
```json
{"status"
:"success","message"
:"用户添加成功"}
```
---
## ✅ 五、常见问题与解决
| 问题 | 解决方案 |
|------|----------|
| 报错 `ClassNotFoundException` | 检查是否引入了正确的 Spring 和 Servlet 依赖 |
| 访问 404 | 检查 URL 是否带上下文 `/ssm-demo`；确认 `@
RequestMapping` 路径拼接正确 |
| 参数绑定失败 | 确保字段名与属性一致；使用 `@RequestParam` 明确指定 |
| 中文乱码 | 已配置 `CharacterEncodingFilter`，前后端统一 UTF-8 |
| JSP 不渲染 | 检查 `InternalResourceViewResolver` 的 prefix/suffix 是否匹配实际路径 |
---
本文详细介绍了Spring MVC框架处理HTTP请求的过程，从DispatcherServlet的作用开始，解析如何通过URL映射定位到具体的Handler方法，再到参数解析及绑定的具体实现。
扫一扫
6632
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
