从0开始学习Java+AI知识点总结-16.web基础知识
一、SpringBoot Web 入门开发
SpringBoot 简化了传统 Spring 应用的配置流程，通过 "约定大于配置" 的理念实现快速开发。以下是入门核心要点：
1. 工程创建与依赖配置
- 工程初始化：通过 Spring Initializr 创建工程，选择Spring Web依赖（内置 Tomcat 服务器和 Spring MVC 核心组件）。
- 核心依赖：在pom.xml中引入 SpringBoot 父工程和 Web 起步依赖，自动管理版本兼容：
<parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>3.5.0</version> </parent> <dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> </dependencies> |
- 依赖作用：spring-boot-starter-web包含 Spring MVC、嵌入式 Tomcat、JSON 解析等 Web 开发必需组件，无需手动配置。
2. 核心注解与启动机制
- @RestController：组合@Controller和@ResponseBody，标识类为请求处理控制器，方法返回值直接作为响应体（对象会自动转为 JSON）。
- @RequestMapping：映射请求路径，指定方法处理的 URL（如@RequestMapping("/hello")处理/hello请求）。
- @SpringBootApplication：启动类核心注解，包含组件扫描（@ComponentScan）、自动配置等功能，需放在项目根包下以确保注解扫描生效。
- 启动流程：通过SpringApplication.run(启动类.class, args)启动内置 Tomcat，自动部署应用并监听默认端口（8080）。
3. 基础请求处理示例
// 控制器类 @RestController public class HelloController { // 处理GET请求：/hello?name=xxx @RequestMapping("/hello") public String hello(String name) { return "Hello " + name + " ~"; } } // 启动类 @SpringBootApplication public class Application { public static void main(String[] args) { SpringApplication.run(Application.class, args); } } |
启动后访问http://localhost:8080/hello?name=Java，将返回Hello Java ~。
二、HTTP 协议核心解析
HTTP（超文本传输协议）是 Web 通信的基础，规范了浏览器与服务器的数据交互格式。
1. 请求数据格式
HTTP 请求由请求行、请求头、请求体三部分组成：
- 请求行：包含请求方法、资源路径、协议版本（如GET /hello?name=Java HTTP/1.1）。
- 请求头：键值对格式，描述请求附加信息（如Host: localhost:8080、User-Agent: 浏览器标识）。
- 请求体：仅 POST 请求包含，存放请求参数（如 JSON 字符串）。
常见请求方法区别：
方法 | 特点 | 适用场景 |
GET | 参数在 URL 中，无请求体，大小有限制（1-18KB） | 数据查询 |
POST | 参数在请求体中，无大小限制 | 数据提交（如表单、新增数据） |
2. 响应数据格式
HTTP 响应由响应行、响应头、响应体三部分组成：
- 响应行：包含协议版本、状态码、描述（如HTTP/1.1 200 OK）。
- 响应头：键值对格式，描述响应附加信息（如Content-Type: application/json）。
- 响应体：服务器返回的实际数据（如 HTML、JSON）。
状态码分类：
- 1xx：临时响应（如 100 Continue）。
- 2xx：成功（如 200 OK）。
- 3xx：重定向（如 302 Found）。
- 4xx：客户端错误（如 404 Not Found、401 Unauthorized）。
- 5xx：服务器错误（如 500 Internal Server Error）。
3. 请求与响应数据处理
- 获取请求数据：通过HttpServletRequest对象获取请求行、头、体数据：
@RequestMapping("/request") public String handleRequest(HttpServletRequest request) { String method = request.getMethod(); // 请求方法（GET/POST） String uri = request.getRequestURI(); // 资源路径（/request） String userAgent = request.getHeader("User-Agent"); // 请求头 String name = request.getParameter("name"); // 请求参数 return "Method: " + method + ", URI: " + uri; } |
- 设置响应数据：两种常用方式：
- 基于HttpServletResponse：
@RequestMapping("/response1") public void setResponse(HttpServletResponse response) throws IOException { response.setStatus(401); // 状态码：未授权 response.setHeader("Custom-Header", "value"); // 响应头 response.getWriter().write("<h1>Hello Response</h1>"); // 响应体 } |
- 基于ResponseEntity（更优雅的响应封装）：
@RequestMapping("/response2") public ResponseEntity<String> setResponse() { return ResponseEntity.status(401) .header("Custom-Header", "value") .body("<h1>Hello Response</h1>"); } |
三、SpringBoot Web 案例实践
以 "用户列表展示" 为例，掌握数据读取、解析、响应的完整流程。
1. 工程结构与依赖
- 核心依赖：除 Web 依赖外，添加 Lombok（简化实体类）和 Hutool（工具类库）：
<dependencies> <!-- Lombok --> <dependency> <groupId>org.projectlombok</groupId> <artifactId>lombok</artifactId> </dependency> <!-- Hutool工具类 --> <dependency> <groupId>cn.hutool</groupId> <artifactId>hutool-all</artifactId> <version>5.8.28</version> </dependency> </dependencies> |
- 静态资源存放：前端页面（如 HTML、JS）需放在src/main/resources/static目录下，SpringBoot 会自动映射访问。
2. 实体类定义
使用 Lombok 注解简化 get/set、构造方法等代码：
import lombok.Data; import lombok.NoArgsConstructor; import lombok.AllArgsConstructor; import java.time.LocalDateTime; @Data // 生成get/set/toString等方法 @NoArgsConstructor // 无参构造 @AllArgsConstructor // 全参构造 public class User { private Integer id; private String username; private String password; private String name; private Integer age; private LocalDateTime updateTime; } |
3. 数据读取与响应
从文件读取用户数据并解析为 JSON 响应：
@RestController public class UserController { @RequestMapping("/list") public List<User> getUserList() { // 1. 读取文件（user.txt放在resources目录下） InputStream in = UserController.class.getClassLoader().getResourceAsStream("user.txt"); List<String> lines = IoUtil.readUtf8Lines(in, new ArrayList<>()); // Hutool工具类
// 2. 解析数据为User对象 List<User> userList = new ArrayList<>(); for (String line : lines) { String[] parts = line.split(","); User user = new User(); user.setId(Integer.valueOf(parts[0])); user.setUsername(parts[1]); user.setPassword(parts[2]); user.setName(parts[3]); user.setAge(Integer.valueOf(parts[4])); // 字符串转LocalDateTime user.setUpdateTime(LocalDateTime.parse(parts[5], DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"))); userList.add(user); } return userList; // 自动转为JSON数组响应 } } |
访问http://localhost:8080/list将返回用户列表 JSON 数据，前端页面可通过 AJAX 请求渲染。
四、分层架构与解耦设计
为提高代码复用性和可维护性，采用三层架构设计，遵循 "高内聚、低耦合" 原则。
1. 三层架构职责划分
- Controller（控制层）：接收前端请求，调用 Service 层处理业务，响应数据（专注请求 / 响应）。
- Service（业务逻辑层）：实现核心业务逻辑，协调 Dao 层数据操作（专注逻辑处理）。
- Dao（数据访问层）：负责数据读写操作（如文件、数据库），提供数据接口（专注数据访问）。
2. 分层实现示例
（1）Dao 层：数据访问接口与实现
// 接口 public interface UserDao { List<String> readUserLines(); // 读取原始数据行 } // 实现类 public class UserDaoImpl implements UserDao { @Override public List<String> readUserLines() { InputStream in = UserDaoImpl.class.getClassLoader().getResourceAsStream("user.txt"); return IoUtil.readUtf8Lines(in, new ArrayList<>()); } } |
（2）Service 层：业务逻辑处理
// 接口 public interface UserService { List<User> getUserList(); // 获取用户列表 } // 实现类 public class UserServiceImpl implements UserService { private UserDao userDao = new UserDaoImpl(); // 依赖Dao层
@Override public List<User> getUserList() { List<String> lines = userDao.readUserLines(); // 调用Dao获取数据 // 解析逻辑（同之前的解析过程） List<User> userList = new ArrayList<>(); // ... 解析代码 ... return userList; } } |
（3）Controller 层：请求处理
@RestController public class UserController { private UserService userService = new UserServiceImpl(); // 依赖Service层
@RequestMapping("/list") public List<User> list() { return userService.getUserList(); // 调用Service获取数据 } } |
3. 分层优势
- 单一职责：每层专注自身职责，降低代码复杂度。
- 复用性高：Service 和 Dao 层逻辑可被多个 Controller 复用。
- 便于维护：需求变更时只需修改对应层代码（如数据来源从文件改为数据库，仅需修改 Dao 层）。
五、IOC 与 DI：控制反转与依赖注入
Spring 的核心思想是控制反转（IOC） 和依赖注入（DI），解决层间高耦合问题。
1. 核心概念
- IOC（控制反转）：对象的创建权从代码转移到 Spring 容器，由容器统一管理对象生命周期。
- DI（依赖注入）：容器在运行时自动将依赖对象注入到需要的类中，无需手动new对象。
- Bean：被 IOC 容器管理的对象称为 Bean。
2. IOC 注解：将对象交给容器管理
使用注解声明 Bean，容器自动创建并管理：
注解 | 作用 | 适用场景 |
@Component | 基础注解，声明 Bean | 通用类 |
@Controller | @Component 衍生注解 | 控制层类 |
@Service | @Component 衍生注解 | 业务层类 |
@Repository | @Component 衍生注解 | 数据访问层类 |
示例：
@Repository // Dao层Bean public class UserDaoImpl implements UserDao { ... } @Service // Service层Bean public class UserServiceImpl implements UserService { ... } @RestController // Controller层Bean（组合@Controller和@ResponseBody） public class UserController { ... } |
3. DI 注解：依赖注入实现
通过注解让容器自动注入依赖对象，消除手动new的耦合：
- @Autowired：默认按类型注入，容器自动查找对应类型的 Bean。
@Service public class UserServiceImpl implements UserService { @Autowired // 注入UserDao类型的Bean private UserDao userDao; // 无需手动new } |
- 多 Bean 冲突解决：当同一类型有多个 Bean 时，需指定注入目标：
- @Primary：在 Bean 上标记优先注入。
@Primary // 优先注入该Bean @Service public class UserServiceImpl implements UserService { ... } |
- @Autowired + @Qualifier：按 Bean 名称注入。
@Service("userServiceA") // 指定Bean名称 public class UserServiceImpl implements UserService { ... } @RestController public class UserController { @Autowired @Qualifier("userServiceA") // 按名称注入 private UserService userService; } |
- @Resource：JavaEE 规范注解，默认按名称注入，支持指定名称。
@RestController public class UserController { @Resource(name = "userServiceA") // 按名称注入 private UserService userService; } |
4. 组件扫描
- @ComponentScan：指定容器扫描 Bean 的包路径，默认扫描启动类所在包及其子包。
- @SpringBootApplication：已包含@ComponentScan，无需额外配置。
六、总结与最佳实践
- SpringBoot Web 开发：通过起步依赖和核心注解快速搭建应用，内置 Tomcat 简化部署。
- HTTP 协议：掌握请求 / 响应格式、状态码和方法区别，正确处理数据交互。
- 分层架构：按 Controller→Service→Dao 划分职责，提升代码复用性和可维护性。
- IOC/DI：使用注解声明 Bean 和注入依赖，消除硬编码耦合，降低维护成本。
通过本文系统学习，可夯实 Java Web 开发基础，掌握从入门到架构设计的核心技能。建议收藏本文，后续开发中遇到相关问题可随时查阅，关注作者获取更多技术干货！