Servlet是Java Web开发的基石而Spring Boot等框架则在此基础上提供了更高效的开发模式

引言

在Java Web开发的演进历程中，Servlet技术扮演着至关重要的角色。作为Java EE（现Jakarta EE）规范的核心组件，Servlet提供了处理HTTP请求和响应的基础能力。然而，随着应用复杂度的增加和开发效率要求的提升，直接使用Servlet进行开发逐渐暴露出代码冗长、配置繁琐等问题。Spring Boot等现代框架在Servlet的基础上，通过自动化配置、依赖管理和约定优于配置等原则，极大地简化了开发流程，提高了开发效率。本文将深入探讨Servlet的核心原理、Spring Boot如何在其基础上构建更高效的开发模式，并通过具体示例展示两者的差异与联系。

1. Servlet：Java Web开发的基石

1.1 Servlet的基本概念

Servlet是运行在Web服务器（如Tomcat、Jetty）中的Java程序，用于处理客户端（通常是浏览器）发送的HTTP请求并生成响应。它是Java Web开发的底层技术，为上层框架（如Spring MVC、Struts）提供了基础支持。

Servlet的核心接口是javax.servlet.Servlet，但实际开发中通常继承HttpServlet类，重写其doGet()、doPost()等方法来处理不同类型的HTTP请求。

1.2 Servlet的工作原理

Servlet的生命周期由Web容器管理，主要包括以下阶段：

初始化：容器调用init()方法初始化Servlet。
服务：容器调用service()方法处理请求，根据请求类型分发到doGet()、doPost()等方法。
销毁：容器调用destroy()方法释放资源。

1.3 Servlet示例代码

下面是一个简单的Servlet示例，用于处理GET请求并返回”Hello, World!“：

import javax.servlet.ServletException; import javax.servlet.annotation.WebServlet; import javax.servlet.http.HttpServlet; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import java.io.IOException; import java.io.PrintWriter; @WebServlet("/hello") public class HelloServlet extends HttpServlet { @Override protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { // 设置响应内容类型 response.setContentType("text/html;charset=UTF-8"); // 获取输出流 PrintWriter out = response.getWriter(); // 生成HTML响应 out.println("<!DOCTYPE html>"); out.println("<html>"); out.println("<head>"); out.println("<title>Hello Servlet</title>"); out.println("</head>"); out.println("<body>"); out.println("<h1>Hello, World!</h1>"); out.println("<p>当前时间: " + new java.util.Date() + "</p>"); out.println("</body>"); out.println("</html>"); out.close(); } }

1.4 Servlet的局限性

尽管Servlet是Java Web开发的基础，但直接使用Servlet进行开发存在以下问题：

代码冗长：需要手动处理请求参数、响应生成、异常处理等。
配置繁琐：需要在web.xml中配置Servlet映射或使用注解。
缺乏依赖注入：难以实现组件间的松耦合。
重复代码多：每个Servlet都需要处理相似的请求/响应逻辑。
测试困难：Servlet与容器紧密耦合，单元测试复杂。

2. Spring Boot：基于Servlet的高效开发框架

2.1 Spring Boot的核心理念

Spring Boot是基于Spring框架的快速开发脚手架，它遵循”约定优于配置”的原则，通过自动化配置和起步依赖（Starter Dependencies）简化了Spring应用的搭建过程。Spring Boot内嵌了Servlet容器（如Tomcat），使得应用可以独立运行，无需额外部署。

2.2 Spring Boot如何基于Servlet构建

Spring Boot的核心组件spring-boot-starter-web包含了Spring MVC和内嵌的Servlet容器。Spring MVC的DispatcherServlet作为前端控制器，统一处理所有请求，然后分发给具体的控制器（Controller）处理。

Spring Boot的请求处理流程：

客户端请求到达内嵌的Servlet容器（Tomcat）。
容器将请求传递给DispatcherServlet。
DispatcherServlet通过HandlerMapping找到对应的Controller方法。
Controller处理请求并返回模型和视图。
DispatcherServlet渲染视图并返回响应。

2.3 Spring Boot示例代码

下面是一个使用Spring Boot的简单Web应用示例，功能与之前的Servlet示例相同：

1. 项目结构：

src/main/java/com/example/demo/ ├── DemoApplication.java # Spring Boot启动类 └── controller/ └── HelloController.java # 控制器类

2. 启动类：

package com.example.demo; import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; @SpringBootApplication public class DemoApplication { public static void main(String[] args) { SpringApplication.run(DemoApplication.class, args); } }

3. 控制器类：

package com.example.demo.controller; import org.springframework.web.bind.annotation.GetMapping; import org.springframework.web.bind.annotation.RestController; import java.util.Date; @RestController public class HelloController { @GetMapping("/hello") public String hello() { return "<h1>Hello, World!</h1><p>当前时间: " + new Date() + "</p>"; } }

4. 配置文件（application.properties）：

# 服务器配置 server.port=8080 server.servlet.context-path=/demo # 日志配置 logging.level.root=INFO

2.4 Spring Boot的优势

自动化配置：根据类路径自动配置Bean，减少手动配置。
起步依赖：通过spring-boot-starter-*简化依赖管理。
内嵌容器：无需单独部署Servlet容器，应用可独立运行。
生产就绪特性：提供健康检查、指标监控等企业级功能。
简化测试：提供@SpringBootTest等注解简化集成测试。

3. Servlet与Spring Boot的对比分析

3.1 开发效率对比

方面	Servlet	Spring Boot
项目搭建	手动创建项目结构，配置`web.xml`	使用Spring Initializr一键生成项目
依赖管理	手动添加JAR包，管理版本冲突	通过起步依赖自动管理
配置复杂度	需要配置Servlet映射、过滤器等	自动配置，只需少量自定义配置
代码量	较多，需要处理底层细节	简洁，专注于业务逻辑
测试难度	需要模拟容器环境，测试复杂	提供测试工具，易于单元测试

3.2 代码示例对比

Servlet实现用户登录功能：

@WebServlet("/login") public class LoginServlet extends HttpServlet { @Override protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { // 1. 获取参数 String username = request.getParameter("username"); String password = request.getParameter("password"); // 2. 业务逻辑（简化） boolean success = "admin".equals(username) && "123456".equals(password); // 3. 生成响应 response.setContentType("text/html;charset=UTF-8"); PrintWriter out = response.getWriter(); if (success) { out.println("<h1>登录成功！</h1>"); out.println("<p>欢迎，" + username + "！</p>"); } else { out.println("<h1>登录失败！</h1>"); out.println("<p>用户名或密码错误。</p>"); out.println("<a href='/login.html'>返回登录</a>"); } out.close(); } }

Spring Boot实现用户登录功能：

@RestController @RequestMapping("/api") public class LoginController { @PostMapping("/login") public ResponseEntity<Map<String, Object>> login( @RequestParam String username, @RequestParam String password) { Map<String, Object> response = new HashMap<>(); // 业务逻辑 if ("admin".equals(username) && "123456".equals(password)) { response.put("success", true); response.put("message", "登录成功"); response.put("user", username); return ResponseEntity.ok(response); } else { response.put("success", false); response.put("message", "用户名或密码错误"); return ResponseEntity.status(401).body(response); } } }

3.3 架构层次对比

Servlet架构：

客户端 → Servlet容器 → Servlet → 业务逻辑 → 响应

Spring Boot架构：

客户端 → Servlet容器 → DispatcherServlet → HandlerMapping → Controller → Service → Repository → 响应

Spring Boot通过分层架构（Controller-Service-Repository）实现了更好的职责分离和代码组织。

4. Spring Boot的高级特性

4.1 自动配置原理

Spring Boot的自动配置基于@Conditional注解和spring.factories文件。例如，当类路径中存在spring-boot-starter-web时，Spring Boot会自动配置：

内嵌Tomcat：TomcatServletWebServerFactory
DispatcherServlet：DispatcherServletAutoConfiguration
Spring MVC：WebMvcAutoConfiguration

自定义自动配置示例：

@Configuration @ConditionalOnClass({DataSource.class, EmbeddedDatabaseType.class}) @ConditionalOnMissingBean(DataSource.class) @EnableConfigurationProperties(DataSourceProperties.class) public class CustomDataSourceAutoConfiguration { @Bean public DataSource dataSource(DataSourceProperties properties) { return properties.initializeDataSourceBuilder().build(); } }

4.2 依赖注入与AOP

Spring Boot基于Spring框架，提供了强大的依赖注入（DI）和面向切面编程（AOP）支持。

依赖注入示例：

@Service public class UserService { @Autowired private UserRepository userRepository; public User findUserById(Long id) { return userRepository.findById(id).orElse(null); } } @RestController @RequestMapping("/api/users") public class UserController { @Autowired private UserService userService; @GetMapping("/{id}") public User getUser(@PathVariable Long id) { return userService.findUserById(id); } }

AOP示例（日志切面）：

@Aspect @Component public class LoggingAspect { @Around("execution(* com.example.demo.service.*.*(..))") public Object logMethodExecution(ProceedingJoinPoint joinPoint) throws Throwable { String methodName = joinPoint.getSignature().getName(); long startTime = System.currentTimeMillis(); try { Object result = joinPoint.proceed(); long endTime = System.currentTimeMillis(); System.out.println("方法 " + methodName + " 执行耗时: " + (endTime - startTime) + "ms"); return result; } catch (Exception e) { System.err.println("方法 " + methodName + " 执行异常: " + e.getMessage()); throw e; } } }

4.3 数据访问与事务管理

Spring Boot通过Spring Data JPA简化了数据访问层的开发。

实体类：

@Entity @Table(name = "users") public class User { @Id @GeneratedValue(strategy = GenerationType.IDENTITY) private Long id; @Column(nullable = false, unique = true) private String username; @Column(nullable = false) private String password; // 省略getter/setter }

Repository接口：

public interface UserRepository extends JpaRepository<User, Long> { User findByUsername(String username); @Query("SELECT u FROM User u WHERE u.username LIKE %:keyword%") List<User> searchUsers(@Param("keyword") String keyword); }

Service层与事务管理：

@Service @Transactional public class UserService { @Autowired private UserRepository userRepository; public User createUser(User user) { // 业务验证 if (userRepository.findByUsername(user.getUsername()) != null) { throw new RuntimeException("用户名已存在"); } return userRepository.save(user); } public void deleteUser(Long id) { userRepository.deleteById(id); } }

4.4 异常处理

Spring Boot提供了统一的异常处理机制。

全局异常处理器：

@RestControllerAdvice public class GlobalExceptionHandler { @ExceptionHandler(ResourceNotFoundException.class) public ResponseEntity<Map<String, Object>> handleResourceNotFound(ResourceNotFoundException ex) { Map<String, Object> response = new HashMap<>(); response.put("error", "资源未找到"); response.put("message", ex.getMessage()); response.put("timestamp", System.currentTimeMillis()); return ResponseEntity.status(HttpStatus.NOT_FOUND).body(response); } @ExceptionHandler(Exception.class) public ResponseEntity<Map<String, Object>> handleGenericException(Exception ex) { Map<String, Object> response = new HashMap<>(); response.put("error", "系统错误"); response.put("message", "请联系管理员"); response.put("timestamp", System.currentTimeMillis()); return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(response); } }

4.5 配置管理

Spring Boot支持多种配置方式，包括属性文件、YAML、环境变量、命令行参数等。

application.yml示例：

server: port: 8080 servlet: context-path: /api spring: datasource: url: jdbc:mysql://localhost:3306/mydb username: root password: password driver-class-name: com.mysql.cj.jdbc.Driver jpa: hibernate: ddl-auto: update show-sql: true properties: hibernate: dialect: org.hibernate.dialect.MySQL8Dialect logging: level: root: INFO com.example.demo: DEBUG

配置类：

@Configuration @ConfigurationProperties(prefix = "app") public class AppConfig { private String name; private String version; private List<String> admins = new ArrayList<>(); // getter/setter }

5. 实际项目中的应用

5.1 项目结构对比

传统Servlet项目结构：

src/ ├── main/ │ ├── java/ │ │ └── com/example/ │ │ ├── servlet/ │ │ │ ├── LoginServlet.java │ │ │ ├── UserServlet.java │ │ │ └── ProductServlet.java │ │ ├── dao/ │ │ │ ├── UserDAO.java │ │ │ └── ProductDAO.java │ │ └── util/ │ │ └── DBUtil.java │ └── webapp/ │ ├── WEB-INF/ │ │ └── web.xml │ ├── login.html │ └── index.html

Spring Boot项目结构：

src/ ├── main/ │ ├── java/ │ │ └── com/example/demo/ │ │ ├── DemoApplication.java │ │ ├── controller/ │ │ │ ├── UserController.java │ │ │ └── ProductController.java │ │ ├── service/ │ │ │ ├── UserService.java │ │ │ └── ProductService.java │ │ ├── repository/ │ │ │ ├── UserRepository.java │ │ │ └── ProductRepository.java │ │ ├── entity/ │ │ │ ├── User.java │ │ │ └── Product.java │ │ └── config/ │ │ └── WebConfig.java │ └── resources/ │ ├── application.yml │ ├── static/ │ │ └── index.html │ └── templates/ │ └── login.html

5.2 完整示例：RESTful API开发

需求：开发一个简单的用户管理API，包含用户增删改查功能。

1. 实体类：

@Entity @Table(name = "users") public class User { @Id @GeneratedValue(strategy = GenerationType.IDENTITY) private Long id; @Column(nullable = false, unique = true) private String username; @Column(nullable = false) private String password; @Column private String email; @Column private String phone; @Column(name = "created_at") private LocalDateTime createdAt; @Column(name = "updated_at") private LocalDateTime updatedAt; @PrePersist protected void onCreate() { createdAt = LocalDateTime.now(); updatedAt = LocalDateTime.now(); } @PreUpdate protected void onUpdate() { updatedAt = LocalDateTime.now(); } // 省略getter/setter和构造函数 }

2. Repository接口：

@Repository public interface UserRepository extends JpaRepository<User, Long> { Optional<User> findByUsername(String username); Optional<User> findByEmail(String email); @Query("SELECT u FROM User u WHERE u.username LIKE %:keyword% OR u.email LIKE %:keyword%") List<User> searchUsers(@Param("keyword") String keyword); @Modifying @Query("UPDATE User u SET u.password = :password WHERE u.id = :id") int updatePassword(@Param("id") Long id, @Param("password") String password); }

3. Service层：

@Service @Transactional public class UserService { @Autowired private UserRepository userRepository; public List<User> getAllUsers() { return userRepository.findAll(); } public User getUserById(Long id) { return userRepository.findById(id) .orElseThrow(() -> new ResourceNotFoundException("User not found with id: " + id)); } public User createUser(User user) { // 验证用户名唯一性 if (userRepository.findByUsername(user.getUsername()).isPresent()) { throw new ConflictException("Username already exists"); } // 验证邮箱唯一性 if (userRepository.findByEmail(user.getEmail()).isPresent()) { throw new ConflictException("Email already exists"); } // 密码加密（实际项目中应使用BCrypt等） user.setPassword(passwordEncoder.encode(user.getPassword())); return userRepository.save(user); } public User updateUser(Long id, User userDetails) { User existingUser = getUserById(id); // 更新允许修改的字段 if (userDetails.getUsername() != null) { existingUser.setUsername(userDetails.getUsername()); } if (userDetails.getEmail() != null) { existingUser.setEmail(userDetails.getEmail()); } if (userDetails.getPhone() != null) { existingUser.setPhone(userDetails.getPhone()); } return userRepository.save(existingUser); } public void deleteUser(Long id) { getUserById(id); // 确保用户存在 userRepository.deleteById(id); } public List<User> searchUsers(String keyword) { return userRepository.searchUsers(keyword); } @Autowired private PasswordEncoder passwordEncoder; }

4. Controller层：

@RestController @RequestMapping("/api/v1/users") public class UserController { @Autowired private UserService userService; @GetMapping public ResponseEntity<List<User>> getAllUsers() { List<User> users = userService.getAllUsers(); return ResponseEntity.ok(users); } @GetMapping("/{id}") public ResponseEntity<User> getUserById(@PathVariable Long id) { User user = userService.getUserById(id); return ResponseEntity.ok(user); } @PostMapping public ResponseEntity<User> createUser(@Valid @RequestBody User user) { User createdUser = userService.createUser(user); return ResponseEntity.status(HttpStatus.CREATED).body(createdUser); } @PutMapping("/{id}") public ResponseEntity<User> updateUser(@PathVariable Long id, @Valid @RequestBody User userDetails) { User updatedUser = userService.updateUser(id, userDetails); return ResponseEntity.ok(updatedUser); } @DeleteMapping("/{id}") public ResponseEntity<Void> deleteUser(@PathVariable Long id) { userService.deleteUser(id); return ResponseEntity.noContent().build(); } @GetMapping("/search") public ResponseEntity<List<User>> searchUsers(@RequestParam String keyword) { List<User> users = userService.searchUsers(keyword); return ResponseEntity.ok(users); } }

5. 全局异常处理器：

@RestControllerAdvice public class GlobalExceptionHandler { @ExceptionHandler(ResourceNotFoundException.class) public ResponseEntity<ErrorResponse> handleResourceNotFound(ResourceNotFoundException ex) { ErrorResponse error = new ErrorResponse( "RESOURCE_NOT_FOUND", ex.getMessage(), System.currentTimeMillis() ); return ResponseEntity.status(HttpStatus.NOT_FOUND).body(error); } @ExceptionHandler(ConflictException.class) public ResponseEntity<ErrorResponse> handleConflict(ConflictException ex) { ErrorResponse error = new ErrorResponse( "CONFLICT", ex.getMessage(), System.currentTimeMillis() ); return ResponseEntity.status(HttpStatus.CONFLICT).body(error); } @ExceptionHandler(MethodArgumentNotValidException.class) public ResponseEntity<ErrorResponse> handleValidationExceptions( MethodArgumentNotValidException ex) { String errorMessage = ex.getBindingResult().getFieldErrors().stream() .map(error -> error.getField() + ": " + error.getDefaultMessage()) .collect(Collectors.joining(", ")); ErrorResponse error = new ErrorResponse( "VALIDATION_ERROR", errorMessage, System.currentTimeMillis() ); return ResponseEntity.status(HttpStatus.BAD_REQUEST).body(error); } @ExceptionHandler(Exception.class) public ResponseEntity<ErrorResponse> handleGenericException(Exception ex) { ErrorResponse error = new ErrorResponse( "INTERNAL_SERVER_ERROR", "An unexpected error occurred", System.currentTimeMillis() ); return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(error); } }

6. 配置类：

@Configuration public class WebConfig implements WebMvcConfigurer { @Override public void addCorsMappings(CorsRegistry registry) { registry.addMapping("/api/**") .allowedOrigins("http://localhost:3000", "http://localhost:8080") .allowedMethods("GET", "POST", "PUT", "DELETE", "OPTIONS") .allowedHeaders("*") .allowCredentials(true) .maxAge(3600); } @Bean public PasswordEncoder passwordEncoder() { return new BCryptPasswordEncoder(); } @Bean public Jackson2ObjectMapperBuilderCustomizer jacksonCustomizer() { return builder -> { builder.serializationInclusion(JsonInclude.Include.NON_NULL); builder.timeZone(TimeZone.getTimeZone("Asia/Shanghai")); builder.modules(new JavaTimeModule()); }; } }

7. 测试类：

@SpringBootTest @AutoConfigureMockMvc class UserControllerTest { @Autowired private MockMvc mockMvc; @Autowired private UserRepository userRepository; @BeforeEach void setUp() { userRepository.deleteAll(); } @Test void shouldCreateUser() throws Exception { String userJson = """ { "username": "testuser", "password": "password123", "email": "test@example.com", "phone": "13800138000" } """; mockMvc.perform(post("/api/v1/users") .contentType(MediaType.APPLICATION_JSON) .content(userJson)) .andExpect(status().isCreated()) .andExpect(jsonPath("$.username").value("testuser")) .andExpect(jsonPath("$.email").value("test@example.com")); } @Test void shouldReturn409WhenUsernameExists() throws Exception { // 先创建一个用户 User user = new User(); user.setUsername("existing"); user.setPassword("password"); user.setEmail("existing@example.com"); userRepository.save(user); // 尝试创建相同用户名的用户 String userJson = """ { "username": "existing", "password": "password123", "email": "new@example.com" } """; mockMvc.perform(post("/api/v1/users") .contentType(MediaType.APPLICATION_JSON) .content(userJson)) .andExpect(status().isConflict()); } }

6. 性能与扩展性考虑

6.1 性能优化

Servlet层面的优化：

连接池：使用数据库连接池（如HikariCP）。
缓存：实现缓存机制（如Ehcache、Redis）。
异步处理：使用AsyncContext处理长时间运行的任务。

Spring Boot层面的优化：

自动配置优化：禁用不需要的自动配置。
缓存抽象：使用@Cacheable注解。
异步支持：使用@Async注解和CompletableFuture。

示例：异步处理：

@Service public class EmailService { @Async public CompletableFuture<Void> sendEmail(String to, String subject, String content) { // 模拟发送邮件的耗时操作 try { Thread.sleep(2000); System.out.println("邮件已发送到: " + to); } catch (InterruptedException e) { Thread.currentThread().interrupt(); } return CompletableFuture.completedFuture(null); } } @RestController public class NotificationController { @Autowired private EmailService emailService; @PostMapping("/notify") public ResponseEntity<String> sendNotification(@RequestParam String email) { // 异步发送邮件，不阻塞当前请求 emailService.sendEmail(email, "通知", "这是一条测试通知"); return ResponseEntity.ok("通知已发送，处理中..."); } }

6.2 扩展性设计

微服务架构： Spring Boot天然适合微服务架构，可以与Spring Cloud集成。

示例：服务注册与发现：

// 服务提供者 @SpringBootApplication @EnableDiscoveryClient public class UserServiceApplication { public static void main(String[] args) { SpringApplication.run(UserServiceApplication.class, args); } } // 服务消费者 @RestController public class OrderController { @LoadBalanced @Bean public RestTemplate restTemplate() { return new RestTemplate(); } @Autowired private RestTemplate restTemplate; @GetMapping("/orders/{id}") public Order getOrder(@PathVariable Long id) { // 通过服务名调用，无需硬编码IP和端口 User user = restTemplate.getForObject( "http://user-service/api/users/{userId}", User.class, id ); // ... 其他逻辑 return order; } }

7. 迁移与集成策略

7.1 从Servlet迁移到Spring Boot

步骤：

分析现有Servlet应用：识别核心功能和依赖。
创建Spring Boot项目：使用Spring Initializr生成项目。
逐步迁移：先迁移非核心功能，再迁移核心功能。
测试验证：确保功能一致性。
性能测试：确保性能达标。

迁移示例：

// 原Servlet代码 @WebServlet("/user") public class UserServlet extends HttpServlet { @Override protected void doGet(HttpServletRequest req, HttpServletResponse resp) { String id = req.getParameter("id"); User user = userService.getUserById(Long.parseLong(id)); // ... 生成响应 } } // 迁移后的Spring Boot代码 @RestController @RequestMapping("/api/user") public class UserController { @GetMapping public User getUser(@RequestParam Long id) { return userService.getUserById(id); } }

7.2 Spring Boot与Servlet的混合使用

在某些场景下，可能需要在Spring Boot应用中使用自定义Servlet。

配置自定义Servlet：

@WebServlet(urlPatterns = "/custom/*", asyncSupported = true) public class CustomServlet extends HttpServlet { @Override protected void doGet(HttpServletRequest req, HttpServletResponse resp) { // 自定义逻辑 resp.getWriter().write("Custom Servlet Response"); } } // 在Spring Boot中注册Servlet @Configuration public class ServletConfig { @Bean public ServletRegistrationBean<CustomServlet> customServlet() { ServletRegistrationBean<CustomServlet> registration = new ServletRegistrationBean<>(new CustomServlet(), "/custom/*"); registration.setLoadOnStartup(1); return registration; } @Bean public FilterRegistrationBean<CustomFilter> customFilter() { FilterRegistrationBean<CustomFilter> registration = new FilterRegistrationBean<>(new CustomFilter()); registration.addUrlPatterns("/custom/*"); return registration; } }

8. 最佳实践与建议

8.1 项目结构最佳实践

分层架构：Controller → Service → Repository → Entity。
包结构：按功能模块组织，而非按技术分层。
配置分离：不同环境使用不同配置文件（application-dev.yml, application-prod.yml）。
异常处理：统一异常处理，避免在Controller中直接处理异常。

8.2 代码质量最佳实践

使用Lombok：减少样板代码。
接口设计：面向接口编程，便于测试和扩展。
单元测试：为每个Service和Controller编写单元测试。
代码审查：定期进行代码审查，确保代码质量。

8.3 安全最佳实践

输入验证：使用@Valid注解和JSR-303验证。
密码加密：使用BCrypt等强加密算法。
API安全：使用JWT或OAuth2进行认证授权。
SQL注入防护：使用参数化查询或ORM框架。

安全配置示例：

@Configuration @EnableWebSecurity public class SecurityConfig extends WebSecurityConfigurerAdapter { @Override protected void configure(HttpSecurity http) throws Exception { http .csrf().disable() // 对于REST API，通常禁用CSRF .authorizeRequests() .antMatchers("/api/public/**").permitAll() .antMatchers("/api/admin/**").hasRole("ADMIN") .anyRequest().authenticated() .and() .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS) .and() .addFilterBefore(jwtAuthenticationFilter(), UsernamePasswordAuthenticationFilter.class); } @Bean public PasswordEncoder passwordEncoder() { return new BCryptPasswordEncoder(); } }

9. 未来趋势与展望

9.1 云原生与Serverless

Spring Boot 2.x和3.x版本对云原生支持更加完善，可以与Kubernetes、Docker等容器技术无缝集成。Spring Cloud Function等项目支持Serverless架构。

9.2 响应式编程

Spring WebFlux提供了响应式编程模型，适合高并发、低延迟的场景。

响应式示例：

@RestController @RequestMapping("/api/reactive") public class ReactiveController { @GetMapping("/users") public Flux<User> getAllUsers() { return userRepository.findAll(); } @GetMapping("/users/{id}") public Mono<User> getUser(@PathVariable Long id) { return userRepository.findById(id) .switchIfEmpty(Mono.error(new ResourceNotFoundException("User not found"))); } }

9.3 GraalVM与原生镜像

Spring Boot 3.x支持GraalVM原生镜像，可以显著减少启动时间和内存占用。

构建原生镜像：

# 添加依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-graalvm-native</artifactId> </dependency> # 构建原生镜像 ./mvnw -Pnative native:compile

10. 总结

Servlet作为Java Web开发的基石，为Web应用提供了基础的请求处理能力。然而，随着应用复杂度的增加和开发效率要求的提升，直接使用Servlet进行开发逐渐暴露出诸多局限性。Spring Boot等现代框架在Servlet的基础上，通过自动化配置、依赖管理和分层架构等设计，极大地简化了开发流程，提高了开发效率和代码质量。

从Servlet到Spring Boot的演进，体现了Java Web开发从底层技术到高效框架的发展历程。Spring Boot不仅继承了Servlet的稳定性和可靠性，还通过现代软件工程的最佳实践，为开发者提供了更高效、更可靠的开发体验。

在实际项目中，开发者应根据项目需求选择合适的技术栈。对于简单的Web应用，直接使用Servlet可能足够；但对于复杂的企业级应用，Spring Boot无疑是更优的选择。同时，理解Servlet的原理有助于更好地理解和使用Spring Boot，因为Spring Boot的底层仍然是基于Servlet的。

随着云原生、响应式编程等新技术的发展，Spring Boot也在不断演进，为开发者提供更多可能性。掌握Servlet和Spring Boot，将使你在Java Web开发领域具备更全面的技术视野和更强的竞争力。