第五章 Web开发：基础Web开发的支持

标签：Web -- Spring Boot springframework 开发 第五章 import org

学习目标

• 5.1 前期准备
• 5.2 控制器开发
• • 5.2.1 JSON的支持
  • • 5.2.2 RESTful的支持
    • 5.2.2.1 什么是RESTful
    • 5.2.2.2 Spring Boot 对 RESTful 的支持
  • 5.2.3 Web测试的支持
• 5.3 视图(JSP)开发
• • 5.3.1 整合JSP
  • • 5.3.1.1 项目结构
    • 5.3.1.2 配置文件
    • 5.3.1.3 引入依赖包
    • 5.3.1.4 编写LoginController

如果没有了解可以去我主页看看 第一至四章的内容来学习)第一章我们开发了一个Spring Boot 的HelloWorld入门程序，第二、三章学习了数据访问层相关技术：MyBaits、MyBAtis-Plus、JPA。接下来我们开始学习表示层相关知识点。
  表示层的开发通常包括控制器、视图、公共功能处理(过滤器、拦截器)等。本章我们将在控制器开发部分掌握@RestController注解对JSON的支持；Spring Boot 对 RESTful的支持，以及使用 MockMvc测试Web请求。在视图开发部分学习整合JSP进行开发。使用自定义过滤器或拦截器完成访问控制。最后还会简单介绍一下打包部署。

5.1 前期准备

在使用MyBatis-Plus与JSP进行开发的前期准备工作中，主要涉及以下几个方面：

1. 项目构建
首先，需要构建一个Java Web项目，这通常可以通过集成开发环境（IDE）如IntelliJ IDEA、Eclipse等完成。在构建项目时，需要选择或配置相应的项目模板，确保支持Spring Boot、MyBatis-Plus以及JSP等技术的使用。

2. 添加依赖
在项目的pom.xml文件中（如果是Maven项目）或build.gradle文件中（如果是Gradle项目），需要添加MyBatis-Plus、Spring Boot Web Starter、数据库驱动（如MySQL）、JSP相关依赖等。以下是一个Maven项目中的部分依赖示例：

<dependencies>  
    <!-- Spring Boot Web Starter -->  
    <dependency>  
        <groupId>org.springframework.boot</groupId>  
        <artifactId>spring-boot-starter-web</artifactId>  
    </dependency>  
    <!-- MyBatis-Plus Starter -->  
    <dependency>  
        <groupId>com.baomidou</groupId>  
        <artifactId>mybatis-plus-boot-starter</artifactId>  
        <version>最新稳定版本</version> <!-- 请替换为实际使用的最新版本 -->  
    </dependency>  
    <!-- MySQL数据库驱动 -->  
    <dependency>  
        <groupId>mysql</groupId>  
        <artifactId>mysql-connector-java</artifactId>  
        <version>最新稳定版本</version> <!-- 请替换为实际使用的最新版本 -->  
    </dependency>  
    <!-- JSP支持（如果使用内嵌Tomcat，则可能不需要显式添加JSP API依赖） -->  
    <!-- 注意：Spring Boot 2.x及以后版本默认使用Thymeleaf等模板引擎，若要使用JSP，则需额外配置 -->  
    <!-- JSP API（如果IDE或构建工具未自动包含） -->  
    <!-- Servlet API（同样，如果IDE或构建工具未自动包含） -->  
    <!-- 其他可能需要的依赖，如Lombok等 -->  
    <dependency>  
        <groupId>org.projectlombok</groupId>  
        <artifactId>lombok</artifactId>  
        <optional>true</optional>  
    </dependency>  
</dependencies>

3. 配置文件
配置application.properties或application.yml文件，以设置数据库连接、MyBatis-Plus相关配置、JSP视图解析器配置等。以下是一个application.yml的示例配置：

spring:  
  datasource:  
    url: jdbc:mysql://localhost:3306/yourdatabase?useSSL=false&serverTimezone=UTC  
    username: yourusername  
    password: yourpassword  
    driver-class-name: com.mysql.cj.jdbc.Driver  
mybatis-plus:  
  mapper-locations: classpath:/mapper/**/*.xml  
  type-aliases-package: com.yourpackage.entity  
  configuration:  
    map-underscore-to-camel-case: true  
  global-config:  
    db-config:  
      id-type: auto  
      table-prefix: t_  
server:  
  servlet:  
    context-path: /yourapp  
  port: 8080

4. 数据库准备
在数据库中创建必要的表和视图，确保这些表和视图与MyBatis-Plus中的Entity类相对应。可以使用SQL脚本手动创建，也可以通过MyBatis-Plus的代码生成器自动生成。
5. 编写Entity类
根据数据库表结构，编写对应的Entity类。这些类将作为MyBatis-Plus操作数据库时的数据模型。

6. 编写Mapper接口
Mapper接口是MyBatis-Plus与数据库交互的接口。通常，只需要继承MyBatis-Plus提供的BaseMapper接口，并指定泛型为对应的Entity类即可。

7. 配置JSP视图
如果项目中使用JSP作为视图技术，需要在项目中配置JSP视图解析器，并创建JSP文件用于展示数据。

8. 其他配置
根据项目需要，还可能需要配置日志、安全性、事务管理等方面的内容。

  综上所述，MyBatis-Plus+JSP的前期准备工作涉及项目构建、依赖添加、配置文件编写、数据库准备、Entity类编写、Mapper接口编写、JSP视图配置等多个方面。

5.2 控制器开发

  前面我们已经将项目构建好，Model(模型)也已经开发完毕，接下来我们先开发控制器。

5.2.1 JSON的支持

  在Java中处理JSON数据，有几种流行的库可以帮助你轻松地解析和生成JSON数据，比如Jackson、Gson和org.json。以下是使用这些库中每个库的一个简单示例，展示如何在Java中支持JSON。

1. 使用Jackson
首先，你需要在你的项目中包含Jackson的依赖。如果你使用Maven，可以在pom.xml中添加如下依赖：

<dependency>  
    <groupId>com.fasterxml.jackson.core</groupId>  
    <artifactId>jackson-databind</artifactId>  
    <version>2.13.0</version> <!-- 请检查最新版本 -->  
</dependency>

然后，你可以使用ObjectMapper类来解析和生成JSON：

import com.fasterxml.jackson.databind.ObjectMapper;  
  
public class JacksonExample {  
    public static void main(String[] args) throws Exception {  
        ObjectMapper mapper = new ObjectMapper();  
  
        // 将Java对象转换为JSON字符串  
        String jsonString = mapper.writeValueAsString(new User("John", 30));  
        System.out.println(jsonString);  
  
        // 将JSON字符串转换为Java对象  
        User user = mapper.readValue(jsonString, User.class);  
        System.out.println(user.getName() + ", " + user.getAge());  
    }  
  
    static class User {  
        private String name;  
        private int age;  
  
        // 构造函数、getter和setter省略  
    }  
}

2. 使用Gson
对于Gson，你需要在pom.xml中添加如下依赖（如果你使用Maven）：

<dependency>  
    <groupId>com.google.code.gson</groupId>  
    <artifactId>gson</artifactId>  
    <version>2.8.9</version> <!-- 请检查最新版本 -->  
</dependency>

然后，使用Gson类来解析和生成JSON：

import com.google.gson.Gson;  
  
public class GsonExample {  
    public static void main(String[] args) {  
        Gson gson = new Gson();  
  
        // 将Java对象转换为JSON字符串  
        String jsonString = gson.toJson(new User("Jane", 25));  
        System.out.println(jsonString);  
  
        // 将JSON字符串转换为Java对象  
        User user = gson.fromJson(jsonString, User.class);  
        System.out.println(user.getName() + ", " + user.getAge());  
    }  
  
    static class User {  
        private String name;  
        private int age;  
  
        // 构造函数、getter和setter省略  
    }  
}

3. 使用org.json
虽然org.json库不像Jackson和Gson那样流行，但它也足够用于简单的JSON处理。你可以通过添加jar文件到你的项目或者通过Maven/Gradle添加依赖来使用它。

这里是一个简单的例子，展示如何使用org.json库：

import org.json.JSONObject;  
  
public class OrgJsonExample {  
    public static void main(String[] args) {  
        // 创建一个JSONObject  
        JSONObject jsonObj = new JSONObject();  
        jsonObj.put("name", "Alice");  
        jsonObj.put("age", 28);  
  
        // 将JSONObject转换为字符串  
        String jsonString = jsonObj.toString();  
        System.out.println(jsonString);  
  
        // 解析JSON字符串  
        JSONObject parsedObj = new JSONObject(jsonString);  
        String name = parsedObj.getString("name");  
        int age = parsedObj.getInt("age");  
  
        System.out.println(name + ", " + age);  
    }  
}

请注意：对于每个库，你都可能需要根据你的项目需求进行适当的错误处理和配置。上述示例仅用于展示基本概念。

5.2.2 RESTful的支持

RESTful API 是一种设计风格，它使用 HTTP 方法（如 GET、POST、PUT、DELETE 等）来对资源进行操作。在 Java 中，支持 RESTful API 的常见方式是通过框架，如 Spring Boot、Jersey（JAX-RS 的一个实现）等。下面，我将以 Spring Boot 为例，展示一个简单的 RESTful API 的实现。

1. 添加 Spring Boot 依赖
首先，你需要在你的项目中包含 Spring Boot 的依赖。如果你使用 Maven，可以在 pom.xml 中添加如下依赖：

<parent>  
    <groupId>org.springframework.boot</groupId>  
    <artifactId>spring-boot-starter-parent</artifactId>  
    <version>2.5.4</version> <!-- 请检查最新版本 -->  
</parent>  
  
<dependencies>  
    <dependency>  
        <groupId>org.springframework.boot</groupId>  
        <artifactId>spring-boot-starter-web</artifactId>  
    </dependency>  
    <!-- 其他依赖 -->  
</dependencies>

2. 创建一个 RESTful 控制器
接下来，你可以创建一个控制器类，该类将使用 @RestController 注解来标记它是一个 RESTful 控制器，并使用 @RequestMapping（或其变体）来定义 URL 路径。

package com.example.demo.controller;  
  
import org.springframework.web.bind.annotation.GetMapping;  
import org.springframework.web.bind.annotation.PathVariable;  
import org.springframework.web.bind.annotation.RestController;  
  
@RestController  
@RequestMapping("/api/users")  
public class UserController {  
  
    @GetMapping("/{id}")  
    public String getUserById(@PathVariable String id) {  
        // 这里只是模拟返回数据，实际应用中应从数据库或其他数据源获取  
        return "User with ID " + id + " found!";  
    }  
  
    @GetMapping  
    public String getAllUsers() {  
        // 模拟返回所有用户列表的字符串表示  
        return "All users listed here!";  
    }  
}

3. 启动 Spring Boot 应用
最后，你需要一个主类来启动 Spring Boot 应用。

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);  
    }  
}

4. 运行和测试
运行你的 Spring Boot 应用，并使用如 Postman、Curl 或浏览器等工具来测试你的 RESTful API。

• 访问 http://localhost:8080/api/users/1，你应该会看到 “User with ID 1 found!” 的响应。
• 访问 http://localhost:8080/api/users，你应该会看到 “All users listed here!” 的响应。

请注意：这些示例是高度简化的，仅用于展示基本概念。在实际应用中，你可能需要处理数据库交互、异常处理、安全性（如认证和授权）、数据验证、日志记录等更多复杂的问题。

5.2.2.1 什么是RESTful

  RESTful Java代码是指使用Java编程语言编写的、遵循REST（Representational State Transfer，表述性状态转移）架构风格的Web服务。REST是一种网络架构原则，它定义了一组约束和属性，用于创建分布式系统，特别是无状态的客户端-服务器应用程序。在Java中，开发者通常会利用各种框架（如Spring Boot、Jersey等）来构建RESTful API，这些框架提供了对REST原则的内置支持。

RESTful Java代码通常包含以下几个关键方面：

1. 资源： RESTful API中的一切都被视为资源。这些资源可以是数据库中的实体、文件系统中的文件、计算结果等。每个资源都有一个唯一的标识符（URI）。
2. 无状态通信： 服务器不保存客户端的任何状态信息，每个请求都包含理解该请求所需的所有信息。
3. 统一的接口： RESTful API使用HTTP标准方法（如GET、POST、PUT、DELETE等）对资源执行操作。这些方法定义了资源的标准行为（例如，GET用于检索资源，POST用于创建新资源）。
4. 自描述的消息： 客户端可以通过查看响应的内容类型、状态码和可选的响应体来理解如何与API进行交互。
5. 分层系统： 客户端和服务器之间的通信可以通过多个层（如负载均衡器、安全层等）进行，每一层都可以增加额外的约束。
6. 可缓存性： 客户端可以缓存响应以提高性能，但前提是这些响应必须是可缓存的（例如，通过HTTP缓存控制头）。

在Java中编写RESTful API通常涉及以下几个步骤：

1. 定义资源： 确定你的API将提供哪些资源，并为每个资源定义唯一的URI。
2. 选择框架： 选择一个支持RESTful原则的Java框架（如Spring Boot）。
3. 创建控制器： 使用框架提供的注解（如@RestController和@RequestMapping）来创建控制器类，该类定义了API的端点（即URI）和与之关联的处理函数。
4. 实现业务逻辑： 在控制器的处理函数中实现业务逻辑，包括与数据库的交互、计算等。
5. 处理HTTP请求和响应： 使用框架提供的机制来处理HTTP请求和生成HTTP响应。
6. 测试： 使用适当的工具（如Postman、JUnit等）测试你的API，以确保它按预期工作。
7. 部署： 将你的API部署到适当的服务器上，使其可供客户端访问。

RESTful Java代码的目标是创建一个易于理解、易于使用、易于扩展的Web服务，它遵循REST原则，能够跨平台、跨语言地工作。

5.2.2.2 Spring Boot 对 RESTful 的支持

Spring Boot 对 RESTful API 的支持非常强大，它基于 Spring MVC 框架，提供了丰富的注解和自动配置功能，使得开发者可以轻松地创建 RESTful Web 服务。下面是一个简单的 Spring Boot 应用程序示例，该示例演示了如何创建一个 RESTful API。

1. 添加 Spring Boot 依赖
首先，确保你的 pom.xml（如果你使用的是 Maven）中包含了 Spring Boot 的起步依赖（starter），特别是 spring-boot-starter-web，它包含了创建 RESTful API 所需的所有东西。

<dependencies>  
    <dependency>  
        <groupId>org.springframework.boot</groupId>  
        <artifactId>spring-boot-starter-web</artifactId>  
    </dependency>  
    <!-- 其他依赖，如数据库连接池、JPA等（如果需要） -->  
</dependencies>

2. 创建 RESTful 控制器
然后，你可以创建一个控制器类，该类使用 @RestController 注解来标记它是一个 RESTful 控制器。在类内部，你可以定义多个方法来处理不同的 HTTP 请求，并使用 @RequestMapping 或其变体（如 @GetMapping、@PostMapping 等）来指定请求的路径和类型。

package com.example.demo.controller;  
  
import org.springframework.web.bind.annotation.GetMapping;  
import org.springframework.web.bind.annotation.PathVariable;  
import org.springframework.web.bind.annotation.RestController;  
  
@RestController  
public class GreetingController {  
  
    @GetMapping("/greeting")  
    public String greeting() {  
        return "Hello, World!";  
    }  
  
    @GetMapping("/greeting/{name}")  
    public String greeting(@PathVariable String name) {  
        return String.format("Hello, %s!", name);  
    }  
}

3. 创建 Spring Boot 应用程序
你还需要一个主类来启动 Spring Boot 应用程序。这个类通常使用 @SpringBootApplication 注解来标记，并包含一个 main 方法来启动应用。

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);  
    }  
}

4. 运行和测试
现在，你可以运行你的 Spring Boot 应用程序，并使用浏览器、Postman 或 curl 等工具来测试你的 RESTful API。

• 运行你的应用程序（例如，通过 Maven 插件或 IDE 中的运行按钮）。
• 访问 http://localhost:8080/greeting，你应该会看到 “Hello, World!” 的响应。
• 访问 http://localhost:8080/greeting/John，你应该会看到 “Hello, John!” 的响应。

5. 扩展你的 API
你可以继续在你的控制器中添加更多的方法，以支持更多的 HTTP 请求类型和路径。Spring Boot 的自动配置和 Spring MVC 的注解将帮助你保持代码的清晰和简洁。

注意:

• 确保你的 Spring Boot 应用程序端口（默认为 8080）没有被其他应用程序占用。
• 如果你使用的是 IDE（如 IntelliJ IDEA、Eclipse 等），请确保你的项目设置正确，并且你的 IDE 识别了你的 Spring Boot 应用程序。
• 如果你遇到任何问题，请检查你的 pom.xml（或 build.gradle，如果你使用的是 Gradle）以确保所有依赖都已正确解析。

5.2.3 Web测试的支持

Spring Boot 提供了对 Web 测试的强大支持，主要通过 Spring Test 和 Spring Boot Test 模块来实现。这些模块允许你编写集成测试，以验证你的 Spring Boot 应用程序的 Web 层是否按预期工作。以下是一个使用 Spring Boot 进行 Web 测试的基本示例，我们将使用 JUnit 5 和 MockMvc 来测试一个 RESTful 控制器。

首先，确保你的 pom.xml 文件中包含了必要的依赖项：

<dependencies>  
    <!-- Spring Boot Starter Web -->  
    <dependency>  
        <groupId>org.springframework.boot</groupId>  
        <artifactId>spring-boot-starter-web</artifactId>  
    </dependency>  
  
    <!-- Spring Boot Starter Test -->  
    <dependency>  
        <groupId>org.springframework.boot</groupId>  
        <artifactId>spring-boot-starter-test</artifactId>  
        <scope>test</scope>  
    </dependency>  
  
    <!-- 其他依赖项 -->  
</dependencies>

接下来，我们创建一个简单的 RESTful 控制器来测试：

package com.example.demo.controller;  
  
import org.springframework.web.bind.annotation.GetMapping;  
import org.springframework.web.bind.annotation.RestController;  
  
@RestController  
public class HelloController {  
  
    @GetMapping("/hello")  
    public String hello() {  
        return "Hello, World!";  
    }  
}

现在，我们编写一个测试类来测试这个控制器：

package com.example.demo.controller;  
  
import org.junit.jupiter.api.Test;  
import org.springframework.beans.factory.annotation.Autowired;  
import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest;  
import org.springframework.test.web.servlet.MockMvc;  
  
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;  
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.content;  
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;  
  
@WebMvcTest(HelloController.class) // 只加载 HelloController  
public class HelloControllerTest {  
  
    @Autowired  
    private MockMvc mockMvc;  
  
    @Test  
    public void testHello() throws Exception {  
        mockMvc.perform(get("/hello"))  
                .andExpect(status().isOk())  
                .andExpect(content().string("Hello, World!"));  
    }  
}

  在这个测试类中，我们使用了 @WebMvcTest 注解来加载 HelloController 及其相关的 Spring MVC 组件，但不加载整个应用程序上下文。这使得测试运行得更快，并且只关注于 Web 层。
  MockMvc 是一个强大的类，用于模拟 HTTP 请求并验证响应。在 testHello 方法中，我们使用 mockMvc.perform(get(“/hello”)) 来模拟对 /hello 端点的 GET 请求，并使用 andExpect 方法来验证响应的状态码和内容。
  通过这种方式，你可以编写针对你的 Spring Boot 应用程序中各个 RESTful 端点的集成测试，以确保它们按预期工作。

5.3 视图(JSP)开发

5.3.1 整合JSP

在Spring Boot中使用JSP作为视图技术稍微有些不同，因为Spring Boot默认支持的是更轻量级的模板引擎，如Thymeleaf或FreeMarker。然而，你仍然可以在Spring Boot项目中使用JSP，但需要一些额外的配置。

以下是一个基本的步骤指南，展示如何在Spring Boot项目中使用JSP作为视图技术。

1. 添加依赖
首先，你需要在pom.xml中添加Spring Boot的spring-boot-starter-web依赖（如果你还没有添加的话），并且需要添加对JSP的支持，虽然Spring Boot没有直接支持JSP的starter，但你可以通过添加Servlet API和JSP API的依赖来实现。

<dependencies>  
    <!-- Spring Boot Web Starter -->  
    <dependency>  
        <groupId>org.springframework.boot</groupId>  
        <artifactId>spring-boot-starter-web</artifactId>  
    </dependency>  
  
    <!-- Servlet API -->  
    <dependency>  
        <groupId>javax.servlet</groupId>  
        <artifactId>javax.servlet-api</artifactId>  
        <scope>provided</scope>  
    </dependency>  
  
    <!-- JSP API -->  
    <dependency>  
        <groupId>javax.servlet.jsp</groupId>  
        <artifactId>javax.servlet.jsp-api</artifactId>  
        <version>2.3.3</version>  
        <scope>provided</scope>  
    </dependency>  
  
    <!-- Tomcat Embed (用于内嵌Tomcat服务器) -->  
    <dependency>  
        <groupId>org.apache.tomcat.embed</groupId>  
        <artifactId>tomcat-embed-jasper</artifactId>  
        <scope>provided</scope>  
    </dependency>  
  
    <!-- JSTL (用于JSP标签库) -->  
    <dependency>  
        <groupId>javax.servlet</groupId>  
        <artifactId>jstl</artifactId>  
    </dependency>  
</dependencies>

注意：tomcat-embed-jasper和JSP API的依赖都被标记为provided，因为当你将应用打包成WAR文件并部署到外部的Servlet容器时，这些依赖将由容器提供。但如果你打算使用Spring Boot的内嵌Tomcat服务器，则可以省略provided作用域。

2. 配置JSP视图解析器
在Spring Boot中，你通常需要自定义一个配置类来配置JSP视图解析器。这可以通过实现WebMvcConfigurer接口并覆盖addViewResolvers方法来完成。

import org.springframework.context.annotation.Bean;  
import org.springframework.context.annotation.Configuration;  
import org.springframework.web.servlet.ViewResolver;  
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;  
import org.springframework.web.servlet.view.InternalResourceViewResolver;  
  
@Configuration  
public class MvcConfig implements WebMvcConfigurer {  
  
    @Bean  
    public ViewResolver viewResolver() {  
        InternalResourceViewResolver resolver = new InternalResourceViewResolver();  
        resolver.setPrefix("/WEB-INF/jsp/");  
        resolver.setSuffix(".jsp");  
        return resolver;  
    }  
}

但是，对于JSP，Spring Boot推荐使用JspServlet和TomcatJasperInitializer来自动配置JSP支持。通常，你不需要显式地配置视图解析器，除非你有特殊的配置需求。

3. 放置JSP文件
将你的JSP文件放在src/main/webapp/WEB-INF/jsp/目录下（注意：对于Maven项目，你可能需要将webapp目录重命名为src/main/resources/META-INF/resources/WEB-INF或使用其他方式来处理静态资源和JSP文件，具体取决于你的打包和部署策略）。

4. 编写Controller
编写一个简单的Controller来返回JSP视图。

import org.springframework.stereotype.Controller;  
import org.springframework.web.bind.annotation.GetMapping;  
  
@Controller  
public class WebController {  
  
    @GetMapping("/")  
    public String index() {  
        return "home"; // 对应 /WEB-INF/jsp/home.jsp  
    }  
}

5. 运行和测试
   运行你的Spring Boot应用，并在浏览器中访问根URL（如http://localhost:8080/），你应该能看到home.jsp页面被渲染的结果。

注意：确保你的IDE或构建工具正确配置了对JSP文件的处理。如果你使用的是Maven和嵌入式Tomcat，通常不需要额外的配置。但是，如果你打算将应用打包为WAR文件并部署到外部服务器，你可能需要调整你的pom.xml文件来正确打包JSP文件。

5.3.1.1 项目结构

Spring Boot 项目结构相对简洁和标准化，这有助于快速开发和部署。下面是一个典型的 Spring Boot 项目结构，主要关注 Java 代码部分：

my-spring-boot-project/  
|-- src/  
|   |-- main/  
|   |   |-- java/  
|   |   |   |-- com/  
|   |   |   |   |-- mycompany/  
|   |   |   |   |   |-- myproject/  
|   |   |   |   |   |   |-- MySpringBootApplication.java  // 主应用类  
|   |   |   |   |   |   |-- controller/  
|   |   |   |   |   |   |   |-- MyController.java          // 控制器层  
|   |   |   |   |   |   |-- service/  
|   |   |   |   |   |   |   |-- MyService.java              // 服务层  
|   |   |   |   |   |   |-- repository/  
|   |   |   |   |   |   |   |-- MyRepository.java           // 仓库层（与数据库交互）  
|   |   |   |   |   |   |-- config/  
|   |   |   |   |   |   |   |-- MyConfig.java               // 配置文件或配置类  
|   |   |   |   |   |   |-- model/  
|   |   |   |   |   |   |   |-- MyModel.java                // 数据模型  
|   |   |   |   |   |   |-- util/  
|   |   |   |   |   |       |-- MyUtils.java                // 工具类  
|   |   |   |-- resources/  
|   |   |   |   |-- static/  
|   |   |   |   |   |-- css/  
|   |   |   |   |   |-- js/  
|   |   |   |   |   |-- images/  
|   |   |   |   |-- templates/  
|   |   |   |   |   |-- mytemplate.html                     // 模板文件（如果使用Thymeleaf等）  
|   |   |   |   |-- application.properties                 // 全局配置文件  
|   |   |   |   |-- application.yml                        // 另一种格式的全局配置文件  
|   |-- test/  
|       |-- java/  
|           |-- com/  
|           |   |-- mycompany/  
|           |   |   |-- myproject/  
|           |   |   |   |-- MySpringBootApplicationTests.java  // 主应用测试类  
|           |   |   |-- controller/  
|           |   |   |   |-- MyControllerTest.java             // 控制器层测试  
|           |   |   |-- service/  
|           |   |   |   |-- MyServiceTest.java                // 服务层测试  
|           |   |   |-- repository/  
|           |   |   |   |-- MyRepositoryTest.java             // 仓库层测试

5.3.1.2 配置文件

在Spring Boot中，配置文件（如application.properties或application.yml）通常用于外部配置，这些配置在应用程序启动时由Spring Boot自动加载并应用到应用程序的上下文中。然而，有时候你可能需要在Java代码中直接处理这些配置，或者通过Java代码来动态地修改配置。

Spring Boot提供了多种方式来实现这一点，其中最常见的是使用@Value注解或@ConfigurationProperties注解来注入配置属性到Java类中。

使用@Value注解
@Value注解可以直接将配置文件中的值注入到Bean的字段中。这种方法适用于注入单个配置值。

import org.springframework.beans.factory.annotation.Value;  
import org.springframework.stereotype.Component;  
  
@Component  
public class MyConfigComponent {  
  
    @Value("${my.property}")  
    private String myProperty;  
  
    // Getter 和 Setter  
    public String getMyProperty() {  
        return myProperty;  
    }  
  
    public void setMyProperty(String myProperty) {  
        this.myProperty = myProperty;  
    }  
  
    // 其他逻辑...  
}

在application.properties或application.yml中：

# application.properties  
my.property=someValue

或者

# application.yml  
my:  
  property: someValue

使用@ConfigurationProperties注解
当你需要注入一组相关的配置属性时，@ConfigurationProperties注解是一个更好的选择。它允许你将配置的前缀与一个POJO（Plain Old Java Object）绑定，Spring Boot会自动将匹配的属性填充到这个POJO中。

首先，定义一个配置类：

import org.springframework.boot.context.properties.ConfigurationProperties;  
import org.springframework.stereotype.Component;  
  
@Component  
@ConfigurationProperties(prefix = "my")  
public class MyConfigProperties {  
  
    private String property;  
  
    // Getter 和 Setter  
    public String getProperty() {  
        return property;  
    }  
  
    public void setProperty(String property) {  
        this.property = property;  
    }  
  
    // 其他属性...  
}

然后，在application.properties或application.yml中配置相应的属性：

# application.properties  
my.property=someValue

或者

# application.yml  
my:  
  property: someValue

Spring Boot会自动将my.property的值注入到MyConfigProperties类的property字段中。

注意

• 当你使用@ConfigurationProperties时，通常需要在Spring Boot的主类或配置类上添加@EnableConfigurationProperties注解（但在Spring Boot 2.x中，如果@ConfigurationProperties注解的类上有@Component或@Configuration注解，则不需要@EnableConfigurationProperties）。
• 你可以通过@ConfigurationProperties(prefix = “some.prefix”)注解来指定配置属性的前缀，Spring Boot会自动将匹配该前缀的所有属性注入到对应的类中。
• 对于更复杂的配置场景，你可能需要自定义配置处理器或使用Spring的Environment抽象来直接访问配置属性。但是，对于大多数应用程序来说，@Value和@ConfigurationProperties已经足够用了。

5.3.1.3 引入依赖包

在Spring Boot中，依赖包通常不是通过Java代码直接引入的，而是通过构建工具（如Maven或Gradle）的依赖管理功能来引入的。这些构建工具允许你在项目的pom.xml（对于Maven）或build.gradle（对于Gradle）文件中声明所需的依赖项，然后它们会自动下载并包含这些依赖项到你的项目中。

Maven 示例
如果你使用的是Maven作为构建工具，你需要在pom.xml文件中添加依赖项。以下是一个添加Spring Boot Starter Web依赖的示例：

<dependencies>  
    <!-- Spring Boot Starter Web 依赖 -->  
    <dependency>  
        <groupId>org.springframework.boot</groupId>  
        <artifactId>spring-boot-starter-web</artifactId>  
    </dependency>  
  
    <!-- 其他依赖项 -->  
    <!-- ... -->  
</dependencies>

注意：在上面的示例中，<version>标签被省略了，因为Spring Boot的spring-boot-starter-parent（或你选择的任何其他Spring Boot Starter Parent）POM已经管理了这些依赖项的版本。如果你没有继承spring-boot-starter-parent，你需要在<dependency>标签中明确指定<version>。

Gradle 示例
如果你使用的是Gradle作为构建工具，你需要在build.gradle文件中添加依赖项。以下是一个添加Spring Boot Starter Web依赖的示例：

dependencies {  
    // Spring Boot Starter Web 依赖  
    implementation 'org.springframework.boot:spring-boot-starter-web'  
  
    // 其他依赖项  
    // ...  
}

在Gradle中，你不需要像Maven那样继承一个特定的父POM来管理版本，因为Gradle允许你在build.gradle文件的dependencies块中直接指定依赖项及其版本（尽管你也可以使用Gradle的依赖管理功能来管理版本）。

注意：

• 当你添加依赖项时，请确保你使用的是与你的Spring Boot版本兼容的依赖项版本。
• 依赖项的版本号通常可以省略，特别是当你使用Spring Boot的starter POM或Gradle插件时，因为它们已经为你管理了依赖项的版本。
• 如果你需要添加不在Spring Boot Starter POM中的依赖项，你可以直接在你的pom.xml或build.gradle文件中添加它们，并指定适当的版本号（如果需要的话）。
• 始终确保你的构建工具（Maven或Gradle）配置正确，以便能够下载并包含你声明的依赖项。这通常涉及到配置仓库（repositories）的位置，以便构建工具可以找到并下载所需的依赖项。

5.3.1.4 编写LoginController

在Spring Boot中编写一个LoginController来处理登录请求是一个常见的任务。下面是一个简单的示例，展示了如何使用Spring MVC来创建一个处理登录请求的LoginController。这个示例假设你正在使用Spring Security来处理安全认证，但即使没有Spring Security，基本的逻辑也是类似的。

首先，确保你的Spring Boot项目中包含了Spring Web的依赖。如果你使用的是Maven，你的pom.xml文件中应该包含类似下面的依赖：

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

如果你还打算使用Spring Security，那么你也需要添加Spring Security的依赖：

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

但请注意，对于本示例，我们将重点放在LoginController的编写上，而不是Spring Security的配置。

以下是一个简单的LoginController示例，它展示了如何定义一个处理登录表单提交的方法：

package com.example.demo.controller;  
  
import org.springframework.stereotype.Controller;  
import org.springframework.ui.Model;  
import org.springframework.web.bind.annotation.GetMapping;  
import org.springframework.web.bind.annotation.PostMapping;  
import org.springframework.web.bind.annotation.RequestParam;  
  
@Controller  
public class LoginController {  
  
    // 映射到登录页面  
    @GetMapping("/login")  
    public String loginForm(Model model) {  
        // 这里可以添加一些登录页面需要的数据到模型中  
        // 例如，可以添加错误消息（如果有的话）  
        return "login"; // 返回登录页面的视图名，假设你有一个名为login的Thymeleaf模板  
    }  
  
    // 处理登录表单的提交  
    @PostMapping("/login")  
    public String loginSubmit(@RequestParam String username, @RequestParam String password, Model model) {  
        // 在这里，你应该会验证用户名和密码  
        // 但为了简单起见，我们假设它们总是有效的  
  
        // 在实际的应用中，这里会调用Spring Security的认证服务  
        // 或者你可能会有一个服务层来检查用户名和密码  
  
        // 登录成功后，重定向到主页或其他页面  
        return "redirect:/home"; // 假设你有一个名为home的视图或控制器方法  
  
        // 如果登录失败，你可以将错误消息添加到模型中，并重新返回登录页面  
        // model.addAttribute("error", "用户名或密码错误");  
        // return "login";  
    }  
}

注意：

1. 上面的loginSubmit方法中的逻辑非常简单，只是为了说明如何处理登录表单的提交。在真实的应用中，你应该会调用Spring Security的API来处理认证逻辑。
2. 如果你使用了Spring Security，那么通常不需要自己编写loginSubmit方法，因为Spring Security会为你处理这些。但是，你可能需要自定义登录页面，并在Spring Security的配置中指定它。
3. 在上面的示例中，我使用了Model来向视图传递数据（尽管在loginForm方法中我没有实际使用它）。这是Spring MVC中常见的做法，用于在控制器和视图之间传递数据。
4. 我使用了@GetMapping和@PostMapping注解来分别映射GET和POST请求。这些注解是@RequestMapping的特定HTTP方法版本，用于简化代码。
5. 返回值是视图名（例如"login"或"redirect:/home"），Spring MVC会根据这些名称来查找并渲染相应的视图（例如，一个Thymeleaf模板）。如果你使用的是其他视图技术（如JSP），则可能需要相应地调整这些视图名。

标签：Web,--,Spring,Boot,springframework,开发,第五章,import,org
From： https://blog.csdn.net/2301_78884095/article/details/142218243