【Spring 篇】深入探索：Spring集成Web环境的奇妙世界

曾经终败给现在 2024-04-27 15:56 74阅读 0赞

![在这里插入图片描述][00284c26956d4b778c232f61e9bac424.png]

嗨，亲爱的小白们！欢迎来到这篇有关Spring集成Web环境的博客。如果你曾对如何在Spring中构建强大的Web应用程序感到好奇，那么这里将为你揭示Web开发的神秘面纱。我们将用情感丰富、语句通顺的文字，以小白友好的方式，一探Spring在Web环境中的强大功能。

### 前言：Web开发的新时代 ###

在我们踏入Spring Web环境的奇妙世界之前，让我们简单了解一下什么是Web开发。Web开发是指构建和维护通过互联网或内联网访问的网页的过程。而Spring作为一个全能型的Java框架，提供了强大的支持来简化Web应用程序的开发。

现代Web应用不仅需要提供丰富的用户体验，还需要保证性能、可维护性和安全性。Spring就像是一位强大的导演，为我们打造了一个舞台，让我们在这个Web开发的新时代中轻松驾驭。

### Spring框架简介 ###

在探索Spring Web环境之前，让我们简单回顾一下Spring框架的基本概念。Spring是一个开源框架，它简化了Java应用程序的开发，提供了广泛的基础设施支持。

Spring的核心特性包括依赖注入（DI）、面向切面编程（AOP）、事务管理、以及我们即将深入讨论的Web模块。这些特性使得Spring成为一个理想的选择，不仅用于构建大型企业级应用，也可以轻松地用于小型项目的开发。

### Spring集成Web环境：如何搭建舞台 ###

#### 1. 项目初始化 ####

首先，我们需要创建一个新的Spring项目。可以使用Spring Initializr（https://start.spring.io/）来初始化一个基本的Spring Boot项目。选择你需要的配置，点击"Generate"下载项目压缩包，解压后导入到你喜欢的集成开发环境中。

#### 2. 添加Web依赖 ####

在`pom.xml`文件中，添加Spring Web的依赖：

<dependencies>
        
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>

这个依赖包含了构建基本的Spring Web应用所需的一切。

#### 3. 创建一个简单的Controller ####

在`src/main/java/com/example/demo`目录下，创建一个名为`DemoController.java`的类，用于处理Web请求：

import org.springframework.web.bind.annotation.GetMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    @RestController
    public class DemoController {
        
    
        @GetMapping("/hello")
        public String hello() {
        
            return "Hello, Spring Web!";
        }
    }

这个简单的Controller定义了一个`/hello`的GET请求，返回一条简单的问候语。

#### 4. 启动应用 ####

在项目的根目录下执行以下命令启动应用：

./mvnw spring-boot:run

或者在集成开发环境中直接运行`DemoApplication.java`中的`main`方法。

打开浏览器访问：http://localhost:8080/hello，你将看到页面上显示着"Hello, Spring Web!"。

至此，我们已经成功搭建了一个简单的Spring Web应用。接下来，让我们更深入地探讨Spring Web环境中的一些核心概念。

### MVC模式：将舞台分工明确 ###

在Spring Web环境中，MVC（Model-View-Controller）是一个重要的设计模式。它将应用程序划分为三个主要的组件：

*  **Model（模型）**：负责处理数据逻辑，与数据库交互，提供数据给View展示。
 *  **View（视图）**：负责用户界面的展示，将Model提供的数据呈现给用户。
 *  **Controller（控制器）**：负责处理用户请求，调用Model获取数据，并将数据传递给View展示。

#### 1. 创建一个简单的Model ####

在`src/main/java/com/example/demo`目录下，创建一个名为`DemoModel.java`的类，用于表示我们的数据：

public class DemoModel {
        
    
        private String message;
    
        public DemoModel(String message) {
        
            this.message = message;
        }
    
        public String getMessage() {
        
            return message;
        }
    }

#### 2. 修改Controller，引入Model ####

修改`DemoController.java`，将返回值从`String`改为`DemoModel`：

@RestController
    public class DemoController {
        
    
        @GetMapping("/hello")
        public DemoModel hello() {
        
            return new DemoModel("Hello, Spring Web!");
        }
    }

#### 3. 创建一个简单的View ####

在`src/main/resources/templates`目录下，创建一个名为`hello.html`的HTML文件，用于展示我们的数据：

<!DOCTYPE html>
    <html>
    <body>
    
    <h2 th:text="${message}"></h2>
    
    </body>
    </html>

#### 4. 修改Controller，指定View ####

修改`DemoController.java`，指定要使用的View：

import org.springframework.stereotype.Controller;
    import org.springframework.ui.Model;
    import org.springframework.web.bind.annotation.GetMapping;
    
    @Controller
    public class DemoController {
        
    
        @GetMapping("/hello")
        public String hello(Model model) {
        
            model.addAttribute("message", "Hello, Spring Web!");
            return "hello";
        }
    }

#### 5. 启动应用 ####

重新启动应用，访问http://localhost:8080/hello，你将看到页面上显示着"Hello, Spring Web!"。这一次，我们使用了MVC模式，将数据从Controller传递到了View，让整个Web应用更加结构清晰、分工明确。

### 数据绑定和表单处理：与用户互动的艺术 ###

在真实的Web应用中，我们不仅仅是向用户展示静态的信息，还需要与用户进行交互。Spring提供了强大的数据绑定和表单处理功能，让我们能够轻松地处理用户提交的数据。

#### 1. 创建一个简单的表单 ####

在`src/main/resources/templates`目录下，创建一个名为`form.html`的HTML文件，用于展示表单：

<!DOCTYPE html>
    <html>
    <body>
    
    <form action="/submit" method="post">
        <label for="name">Name:</label>
        <input type="text" id="name" name="name" required><br><br>
        
        <label for="email">Email:</label>
        <input type="email" id="email" name="email" required><br><br>
        
        <input type="submit" value="Submit">
    </form>
    
    </body>
    </html>

#### 2. 创建一个Controller处理表单提交 ####

在`src/main/java/com/example/demo`目录下，创建一个名为`FormController.java`的类，用于处理表单提交：

import org.springframework.stereotype.Controller;
    import org.springframework.ui.Model;
    import org.springframework.web.bind.annotation.GetMapping;
    import org.springframework.web.bind.annotation.PostMapping;
    
    @Controller
    public class FormController {
        
    
        @GetMapping("/form")
        public String showForm() {
        
            return "form";
        }
    
        @PostMapping("/submit")
        public String submitForm(String name, String email, Model model) {
        
            // 处理表单提交逻辑
            model.addAttribute("name", name);
            model.addAttribute("email", email);
            return "result";
        }
    }

#### 3. 创建一个显示结果的View ####

在`src/main/resources/templates`目录下，创建一个名为`result.html`的HTML文件，用于展示表单提交的结果：

<!DOCTYPE html>
    <html>
    <body>
    
    <h2 th:text="'Hello, ' + ${name} + '! Thanks for submitting your email: ' + ${email}"></h2>
    
    </body>
    </html>

#### 4. 启动应用 ####

重新启动应用，访问http://localhost:8080/form，填写表单并提交，你将看到页面上显示着你提交的信息。通过这个简单的例子，我们演示了Spring如何处理表单提交，实现了用户与应用的互动。

### 拦截器和过滤器：定制Web应用的护卫 ###

有时，我们需要在请求到达Controller之前或者之后执行一些额外的逻辑。这时，拦截器和过滤器就发挥了重要的作用。让我们看看如何在Spring中使用拦截器和过滤器。

#### 拦截器 ####

##### 1. 创建一个拦截器 #####

在`src/main/java/com/example/demo`目录下，创建一个名为`DemoInterceptor.java`的类，用于定义我们的拦截器：

import org.springframework.web.servlet.HandlerInterceptor;
    import org.springframework.web.servlet.ModelAndView;
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    
    public class DemoInterceptor implements HandlerInterceptor {
        
    
        @Override
        public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) {
        
            // 在请求到达Controller之前执行
            System.out.println("Pre Handle method is Calling");
            return true;
        }
    
        @Override
        public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) {
        
            // 在请求处理之后但视图未渲染前执行
            System.out.println("Post Handle method is Calling");
        }
    
        @Override
        public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) {
        
            // 在视图渲染之后执行
            System.out.println("Request and Response is completed");
        }
    }

##### 2. 注册拦截器 #####

在`src/main/java/com/example/demo`目录下，创建一个名为`WebConfig.java`的类，用于注册我们的拦截器：

import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
    import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
    
    @Configuration
    public class WebConfig implements WebMvcConfigurer {
        
    
        @Bean
        public DemoInterceptor demoInterceptor() {
        
            return new DemoInterceptor();
        }
    
        @Override
        public void addInterceptors(InterceptorRegistry registry) {
        
            registry.addInterceptor(demoInterceptor());
        }
    }

#### 过滤器 ####

##### 1. 创建一个过滤器 #####

在`src/main/java/com/example/demo`目录下，创建一个名为`DemoFilter.java`的类，用于定义我们的过滤器：

import javax.servlet.Filter;
    import javax.servlet.FilterChain;
    import javax.servlet.FilterConfig;
    import javax.servlet.ServletException;
    import javax.servlet.ServletRequest;
    import javax.servlet.ServletResponse;
    import java.io.IOException;
    
    public class DemoFilter implements Filter {
        
    
        @Override
        public void init(FilterConfig filterConfig) throws ServletException {
        
            // 初始化过滤器
            System.out.println("Filter initialized");
        }
    
        @Override
        public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
                throws IOException, ServletException {
        
            // 在请求处理之前执行
            System.out.println("Filter is doing its job");
            chain.doFilter(request, response);
            // 在请求处理之后执行
            System.out.println("Filter is done");
        }
    
        @Override
        public void destroy() {
        
            // 销毁过滤器
            System.out.println("Filter destroyed");
        }
    }

##### 2. 注册过滤器 #####

在`src/main/java/com/example/demo`目录下，创建一个名为`FilterConfig.java`的类，用于注册我们的过滤器：

import org.springframework.boot.web.servlet.FilterRegistrationBean;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    
    @Configuration
    public class FilterConfig {
        
    
        @Bean
        public FilterRegistrationBean<DemoFilter> demoFilter() {
        
            FilterRegistrationBean<DemoFilter> registrationBean = new FilterRegistrationBean<>();
            registrationBean.setFilter(new DemoFilter());
            registrationBean.addUrlPatterns("/hello"); // 过滤的URL
            return registrationBean;
        }
    }

#### 测试拦截器和过滤器 ####

重新启动应用，通过访问http://localhost:8080/hello，你将在控制台上看到拦截器和过滤器的输出信息。这证明了拦截器在请求到达Controller之前和之后，过滤器在请求处理前后都能够执行相应的逻辑。

### 异常处理：妙用ControllerAdvice ###

在真实的Web应用中，异常处理是一个必不可少的部分。Spring提供了`@ControllerAdvice`注解，允许我们集中处理全局的异常情况。

#### 1. 创建一个自定义异常 ####

在`src/main/java/com/example/demo`目录下，创建一个名为`CustomException.java`的类，用于表示我们的自定义异常：

public class CustomException extends RuntimeException {
        
    
        public CustomException(String message) {
        
            super(message);
        }
    }

#### 2. 创建一个异常处理器 ####

在`src/main/java/com/example/demo`目录下，创建一个名为`CustomExceptionHandler.java`的类，用于处理自定义异常：

import org.springframework.http.HttpStatus;
    import org.springframework.ui.Model;
    import org.springframework.web.bind.annotation.ControllerAdvice;
    import org.springframework.web.bind.annotation.ExceptionHandler;
    import javax.servlet.http.HttpServletResponse;
    
    @ControllerAdvice
    public class CustomExceptionHandler {
        
    
        @ExceptionHandler(CustomException.class)
        public String handleCustomException(CustomException ex, Model model, HttpServletResponse response) {
        
            model.addAttribute("error", ex.getMessage());
            response.setStatus(HttpStatus.BAD_REQUEST.value());
            return "error";
        }
    }

#### 3. 创建一个显示错误信息的View ####

在`src/main/resources/templates`目录下，创建一个名为`error.html`的HTML文件，用于展示错误信息：

<!DOCTYPE html>
    <html>
    <body>
    
    <h2 th:text="${error}"></h2>
    
    </body>
    </html>

#### 4. 测试异常处理 ####

在`DemoController.java`中，添加一个新的请求处理方法，用于抛出自定义异常：

@GetMapping("/error-demo")
    public String errorDemo() {
        
        throw new CustomException("This is a custom exception");
    }

重新启动应用，访问http://localhost:8080/error-demo，你将看到页面上显示着自定义异常的错误信息。

通过这个简单的例子，我们演示了如何使用`@ControllerAdvice`注解来集中处理全局的异常情况，使得异常处理更加统一和可维护。

### 安全性：保护Web应用的护盾 ###

Web应用的安全性是非常重要的，Spring提供了一套强大的安全性机制，使我们能够轻松地保护我们的Web应用。

#### 1. 添加Spring Security依赖 ####

在`pom.xml`文件中，添加Spring Security的依赖：

<dependencies>
        
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-security</artifactId>
        </dependency>
    </dependencies>

#### 2. 创建一个简单的Security配置 ####

在`src/main/java/com/example/demo`目录下，创建一个名为`SecurityConfig.java`的类，用于配置Spring Security：

import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.security.config.annotation.web.builders.HttpSecurity;
    import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
    import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
    import org.springframework.security.crypto.password.PasswordEncoder;
    
    @Configuration
    @EnableWebSecurity
    public class SecurityConfig extends WebSecurityConfigurerAdapter {
        
    
        @Override
        protected void configure(HttpSecurity http) throws Exception {
        
            http
                .authorizeRequests()
                    .antMatchers("/", "/home").permitAll()
                    .anyRequest().authenticated()
                    .and()
                .formLogin()
                    .loginPage("/login")
                    .permitAll()
                    .and()
                .logout()
                    .permitAll();
        }
    
        @Bean
        public PasswordEncoder passwordEncoder() {
        
            return new BCryptPasswordEncoder();
        }
    }

#### 3. 创建一个登录页面 ####

在`src/main/resources/templates`目录下，创建一个名为`login.html`的HTML文件，用于展示登录页面：

<!DOCTYPE html>
    <html>
    <body>
    
    <form th:action="@{/login}" method="post">
        <label for="username">Username:</label>
        <input type="text" id="username" name="username" required><br><br>
        
        <label for="password">Password:</label>
        <input type="password" id="password" name="password" required><br><br>
        
        <input type="submit" value="Login">
    </form>
    
    </body>
    </html>

#### 4. 测试Spring Security ####

重新启动应用，访问http://localhost:8080/login，你将看到登录页面。输入任意用户名和密码，点击登录按钮，你将被重定向到首页。

通过这个简单的例子，我们演示了如何使用Spring Security来保护我们的Web应用，限制访问权限，以及提供登录认证功能。

### 结语：在Spring的指导下舞动Web的旋律 ###

通过这篇博客，我们深入浅出地探讨了Spring集成Web环境的世界。从项目初始化、MVC模式、数据绑定和表单处理，到拦截器和过滤器、异常处理、以及安全性，我们一步步地领略了Spring框架在Web开发中的强大功能。

在这个Web的舞台上，Spring为我们打造了一个灵活而强大的舞台，让我们能够自如地表演、与用户互动，同时又有着强大的安全性保障。希望这篇博客对于初学者来说是一次愉快的学习之旅，让你能够在Web的世界里舞动自如。

如果你有任何疑问或者想要分享自己的经验，不妨在评论区留下你的足迹。让我们一起共同探索Spring集成Web环境的奇

妙之处，愉快地编写出安全、高效、可维护的Web应用。感谢你的阅读，希望你在Web的旋律中找到属于自己的节奏！??

<table> 
 <tbody> 
  <tr> 
   <td> <strong><font>作者信息</font></strong><br> <br> <font> 作者 ： 繁依Fanyi</font><br> <font>CSDN：</font> <a href="https://blog.csdn.net/qq_21484461?spm=1000.2115.3001.5343" rel="nofollow"><font>https://techfanyi.blog.csdn.net</font></a><br> <font>掘金：</font><a href="https://juejin.cn/user/4154386571867191" rel="nofollow"><font>https://juejin.cn/user/4154386571867191</font></a> </td> 
  </tr> 
 </tbody> 
</table>

[00284c26956d4b778c232f61e9bac424.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/27/69d78a331b9f40b2af5d2f49d510ad89.png