首页手记创建Springboot项目实战：新手入门教程

创建Springboot项目实战：新手入门教程

标签：

SpringBoot

概述

本文详细介绍了创建Springboot项目实战的全过程，从环境搭建到项目结构配置，再到RESTful API的构建和前端集成，全面指导开发者快速启动和运行Spring Boot应用。文中还涵盖了项目打包和部署的多种方式，包括传统服务器部署和Docker容器化部署，确保项目能够在不同环境中稳定运行。

Spring Boot简介与环境搭建

什么是Spring Boot

Spring Boot是由Pivotal团队提供的基于Spring平台的开发框架，其主要目的是简化新Spring应用的初始搭建以及开发过程。Spring Boot框架可以让你快速的开发出独立的、基于生产级别的应用。它默认配置好了大量的框架，使得开发者无需编写大量的配置代码，只需要关注业务逻辑即可。

Spring Boot的核心功能包括:

自动配置: Spring Boot通过自动配置功能来简化配置过程，使得开发者可以快速搭建和启动应用。
起步依赖: 提供的起步依赖简化了依赖管理。通过在POM文件中添加起步依赖，可以获取到所有所需的依赖。
内置的Web服务器: Spring Boot默认包含了一个嵌入式的Web服务器（如Tomcat、Jetty、Undertow），使得开发者可以直接运行应用，无需打包成WAR文件。
外部配置支持: 支持多种外部配置文件，如properties和YAML格式，可以方便地进行配置。
健康检查: 内置了健康检查的功能，可以帮助开发者快速定位问题。

开发环境配置

要开始使用Spring Boot，需要先准备开发环境。开发环境一般包括以下工具:

IDE: IntelliJ IDEA、Eclipse或Sts（Spring Tool Suite）
JDK: 安装Java开发工具包（JDK 8或更高版本）
Maven或Gradle: 用于管理和构建项目依赖
文本编辑器: 如Visual Studio Code、Sublime Text等，用于编写代码

下面以IntelliJ IDEA为例，详细说明如何配置开发环境。

下载并安装IntelliJ IDEA: 访问官网下载页面，根据系统版本下载对应版本的IntelliJ IDEA。选择安装版本时，建议选择Community版本，因为它的功能已经足够强大，且免费。
配置JDK: 下载并安装JDK（版本建议为1.8或更高）。安装完成后，需要在IntelliJ IDEA中设置Java SDK。
- 打开IntelliJ IDEA，选择File -> Project Structure（或者快捷键Ctrl+Alt+Shift+S）。
- 在弹出的对话框中选择SDKs标签，点击+号添加新的Java SDK（选择你安装的JDK路径）。
- 选择Project标签，在Project SDK下拉菜单中选择你刚刚添加的SDK。
配置Maven或Gradle: 因为Spring Boot项目使用Maven或Gradle进行构建，所以需要配置对应的构建工具。
- File -> Settings -> Build, Execution, Deployment -> Build Tools -> Maven 或 Gradle，确保已安装Maven或Gradle插件。
- 下载并安装Maven或Gradle（Maven推荐版本为3.6+，Gradle推荐版本为4.4+）。
- 在IntelliJ IDEA中，配置Maven或Gradle的安装路径。
创建新项目: 创建一个新项目，选择Spring Initializr以快速开始。
- File -> New -> Project，选择Spring Initializr。
- 在弹出的对话框中，选择Maven或Gradle作为构建工具，选择Java作为项目类型。
- 输入项目的基本信息（Group ID、Artifact ID、Version等），在Dependencies选项卡中选择所需的依赖项，如Spring Web、Spring Data JPA等。
- 点击Next，然后点击Finish。

下载与安装Spring Boot

Spring Boot无需单独下载，因为它集成在了Maven或Gradle中。你需要在POM文件或build.gradle文件中添加Spring Boot的起步依赖。以下是使用Maven的示例：

<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>demo</artifactId>
    <version>0.0.1-SNAPSHOT</version>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.7.5</version>
    </parent>

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

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

或者使用Gradle的示例：

plugins {
    id 'org.springframework.boot' version '2.7.5'
    id 'io.spring.dependency-management' version '1.0.11.RELEASE'
    id 'java'
}

group = 'com.example'
version = '0.0.1-SNAPSHOT'

repositories {
    mavenCentral()
}

dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-web'
}

创建第一个Spring Boot项目

创建一个简单的Spring Boot项目，实现一个简单的“Hello World”应用。

创建项目

使用Spring Initializr创建一个新的Spring Boot项目。在IDE中选择File -> New -> Project，选择Spring Initializr。选择Maven或Gradle作为构建工具，选择Java作为项目类型。
输入项目的基本信息（Group ID、Artifact ID、Version等），在Dependencies选项卡中选择所需的依赖项，如Spring Web。
点击Next，然后点击Finish。

编写代码

主类: 创建一个主类，它会是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);
}
}

2. **创建一个简单的Controller**:
```java
package com.example.demo;

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!";
    }
}

运行项目

在IDE中，可以通过点击Run按钮或使用IDE的运行配置来运行Spring Boot项目。
应用启动后，可以在控制台看到启动日志，显示应用启动成功。
打开浏览器，访问http://localhost:8080/hello，页面显示Hello, World!

项目目录结构：

src
├── main
│   ├── java
│   │   └── com
│   │       └── example
│   │           └── demo
│   │               ├── DemoApplication.java
│   │               └── HelloController.java
│   └── resources
│       └── application.properties
└── test
    └── java
        └── com
            └── example
                └── demo
                    └── DemoApplicationTests.java

现在，你的第一个Spring Boot项目已经完成了。这个项目包含了一个简单的Controller，返回一个简单的字符串“Hello, World!”，运行后可以通过浏览器访问到。

Spring Boot核心概念解析

@SpringBootApplication注解详解

@SpringBootApplication是Spring Boot的核心注解，用于引导Spring Boot应用的启动。它是一个组合注解，包含了多个其他注解的功能。

@Configuration: 该注解表示当前类是一个配置类，可以包含@Bean方法，定义Spring Bean。
@EnableAutoConfiguration: 该注解用来开启自动配置机制。Spring Boot会尝试根据类路径中的依赖自动配置应用程序。
@ComponentScan: 该注解用来开启组件扫描功能，扫描指定包及其子包下的组件类（如@Service、@Controller、@Repository、@Component等标记的类）。

代码示例

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

在上述代码中，@SpringBootApplication注解被应用于DemoApplication类，表示这个类是Spring Boot应用的入口类。通过这个注解，Spring Boot可以自动扫描该类所在包及其子包中的组件类，并进行自动配置。

Spring Boot的自动配置机制

Spring Boot的自动配置机制是其核心特性之一，它根据类路径中的依赖自动配置Spring应用。自动配置根据类路径中找到的jar依赖推测出需要进行的配置，从而省去了手动配置的麻烦。

自动配置的原理

Spring Boot的自动配置机制主要依靠@Conditional注解家族。这些注解定义了特定条件下才会生效的条件。当类路径中包含某些特定的依赖时，Spring Boot会自动创建和配置相应的Bean。

自动配置的类

Spring Boot使用@Configuration类中的@Bean方法来完成自动配置。通常，这些类位于META-INF/spring.factories文件中，并以SpringBootConfiguration的形式提供。

自动配置的优先级

如果自动配置行为不合适，可以通过提供自定义配置类来覆盖默认的行为。Spring Boot允许通过在主类或其他配置类中添加@SpringBootApplication(exclude = {特定的自动配置类.class})来排除特定的自动配置。

代码示例

假设你想禁用Spring Security的自动配置，可以在DemoApplication类中添加以下注解：

package com.example.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.autoconfigure.security.servlet.SecurityAutoConfiguration;

@SpringBootApplication(exclude = {SecurityAutoConfiguration.class})
public class DemoApplication {
    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }
}

Spring Boot的依赖管理

Spring Boot使用“起步依赖”简化了依赖管理。这些起步依赖提供了常用功能的依赖和配置。例如，spring-boot-starter-web包含了构建Web应用的所有依赖，而spring-boot-starter-data-jpa包含了数据库连接和JPA的依赖。

起步依赖

Spring Boot的起步依赖是所有Spring Boot应用的基础，它们可以帮助开发者快速构建应用。起步依赖通常是几个不同库的组合，它们共同提供了一些常用的特性。

起步依赖的使用

在Maven的POM文件或Gradle的build.gradle文件中，可以添加起步依赖。例如，添加spring-boot-starter-web：

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

或者在Gradle的build.gradle文件中：

dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-web'
}

起步依赖的排除

如果不需要某些依赖，可以通过排除功能来移除不需要的依赖。例如，排除Spring Security的依赖：

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

通过这些起步依赖，开发者可以快速构建出一个功能完备的应用，而不需要手动管理每一个依赖项。

Spring Boot项目结构与基本配置

项目目录结构介绍

Spring Boot项目的基本目录结构如下：

src
├── main
│   ├── java
│   │   └── com.example.demo
│   │       ├── DemoApplication.java
│   │       └── HelloController.java
│   └── resources
│       └── application.properties
└── test
    └── java
        └── com.example.demo
            └── DemoApplicationTests.java

项目目录结构解析

src/main/java: 包含应用程序的主要代码，如主类DemoApplication.java、控制器HelloController.java等。
src/main/resources: 包含资源文件，如配置文件application.properties、静态资源等。
src/test/java: 包含测试代码，如单元测试DemoApplicationTests.java。
src/main/resources/application.properties: 项目的基本配置文件，包含应用所需的配置信息，如端口号、数据源配置等。

资源文件加载位置

Spring Boot会自动加载src/main/resources目录下的application.properties或application.yml文件。如果需要加载更多的配置文件，可以在resources目录下创建新的配置文件，并在主配置文件中引用它们。

资源文件的加载顺序

Spring Boot按照以下顺序加载资源文件：

application.properties
application.yml
application-{profile}.properties 或 application-{profile}.yml，其中{profile}是当前活动的环境配置文件。

示例代码

假设你有一个项目需要在不同的环境中使用不同的数据库配置，可以通过以下方式实现：

在application.properties中定义默认配置：

spring.datasource.url=jdbc:mysql://localhost:3306/defaultdb
spring.datasource.username=root
spring.datasource.password=root

创建一个特定环境的配置文件，如application-dev.properties：

spring.datasource.url=jdbc:mysql://localhost:3306/devdb
spring.datasource.username=root
spring.datasource.password=root

启动应用时，切换到dev环境：
```
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 app = new SpringApplication(DemoApplication.class);
app.setEnvironment(app.getEnvironment().clone());
app.setAdditionalProfiles("dev");
app.run(args);
}
}


## application.properties配置详解
`application.properties`文件是Spring Boot项目的默认配置文件，用于存放各种配置，如端口号、数据库连接信息等。

### 常用配置项
1. **Server配置**:
    - `server.port`: 设置应用运行时的端口号。
    - `server.servlet.context-path`: 设置应用的上下文路径。
    - `server.tomcat.basedir`: 设置Tomcat的临时目录。
2. **数据库配置**:
    - `spring.datasource.url`: 数据库连接URL。
    - `spring.datasource.username`: 数据库连接用户名。
    - `spring.datasource.password`: 数据库连接密码。
    - `spring.datasource.driver-class-name`: 数据库驱动类名。
3. **日志配置**:
    - `logging.level.root`: 设置根日志级别。
    - `logging.level.org.springframework`: 设置Spring框架的日志级别。
4. **缓存配置**:
    - `spring.cache.type`: 设置缓存类型，如`none`、`couchbase`、`ehcache`等。
5. **线程池配置**:
    - `spring.task.execution.pool.core-size`: 设置线程池核心线程数。
    - `spring.task.execution.pool.max-size`: 设置线程池最大线程数。

```properties
server.port=8080
server.servlet.context-path=/app

spring.datasource.url=jdbc:mysql://localhost:3306/testdb
spring.datasource.username=root
spring.datasource.password=root

logging.level.root=INFO
logging.level.org.springframework=DEBUG

配置文件的覆盖

如果需要覆盖默认配置，可以在application.properties文件中直接修改相应配置项。或者，可以创建一个新的配置文件，如application-local.properties，并在主配置文件中引用它：

spring.datasource.url=jdbc:mysql://localhost:3306/localdb
spring.datasource.username=root
spring.datasource.password=root

然后，在application.properties中引用该配置文件：

spring.datasource.url=@spring.datasource.url@
spring.datasource.username=@spring.datasource.username@
spring.datasource.password=@spring.datasource.password@

配置文件的外部化

Spring Boot支持将配置文件放置在外部，这样可以避免将敏感信息（如数据库密码）硬编码在代码中。Spring Boot支持以下几种方式来加载外部配置文件：

命令行参数:
- --server.port=8080
环境变量:
- SERVER_PORT=8080
JVM参数:
- -Dserver.port=8080
Java System Properties:
- java -Dserver.port=8080 -jar myapp.jar

示例代码

配置文件的外部化可以简化配置的管理，特别是在实际生产环境中，将敏感信息（如数据库密码）保存在外部配置文件中更为安全。

假设你需要在开发环境中使用不同的数据库配置，可以通过以下方式实现：

创建一个配置文件application-dev.properties：

spring.datasource.url=jdbc:mysql://localhost:3306/devdb
spring.datasource.username=root
spring.datasource.password=root

修改主配置文件application.properties：

spring.datasource.url=@spring.datasource.url@
spring.datasource.username=@spring.datasource.username@
spring.datasource.password=@spring.datasource.password@

在开发环境中，启动应用时指定dev配置文件：
```
package com.example.demo;
```

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;


## 日志配置与调试
Spring Boot提供了灵活的日志配置，支持多种日志框架（如Logback、Log4j2、JUL等）。

### 日志框架
Spring Boot默认使用Logback作为日志框架，但在`spring-boot-starter-logging`依赖中，已经包含了Logback、Log4j、JUL等多个日志框架的依赖，你可以根据自己的喜好选择一个日志框架。

### 配置日志级别
在`application.properties`文件中，可以配置不同的日志级别，以控制输出的日志信息量。常用的日志级别有`TRACE`、`DEBUG`、`INFO`、`WARN`和`ERROR`。

```properties
logging.level.root=INFO
logging.level.org.springframework=DEBUG

日志文件输出位置

默认情况下，Logback将日志输出到/tmp目录下的spring.log文件中。如果需要自定义日志文件的位置和名称，可以在application.properties中进行配置：

logging.file.name=logs/spring.log
logging.file.path=/var/log

示例代码

假设你想将日志输出到/var/log/spring-boot.log文件中，并设置日志级别为DEBUG：

logging.level.root=DEBUG
logging.file.name=spring-boot.log
logging.file.path=/var/log

配置日志格式

在application.properties文件中，可以配置日志的输出格式。Logback的配置文件logback.xml可以包含更详细的日志格式配置。

<configuration>
    <property name="LOG_PATTERN" value="%d{yyyy-MM-dd HH:mm:ss} %-5level %logger{36} - %msg%n" />

    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <pattern>${LOG_PATTERN}</pattern>
        </encoder>
    </appender>

    <appender name="FILE" class="ch.qos.logback.core.FileAppender">
        <file>/var/log/spring-boot.log</file>
        <encoder>
            <pattern>${LOG_PATTERN}</pattern>
        </encoder>
    </appender>

    <root level="DEBUG">
        <appender-ref ref="STDOUT" />
        <appender-ref ref="FILE" />
    </root>
</configuration>

调试模式

Spring Boot可以通过设置spring.profiles.active属性来启用不同的配置文件，从而进行调试。例如，可以在开发环境中启用dev配置文件，以获取更多的调试信息。

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 app = new SpringApplication(DemoApplication.class);
        app.setEnvironment(app.getEnvironment().clone());
        app.setAdditionalProfiles("dev");
        app.run(args);
    }
}

通过这种方式，可以灵活地调整应用的配置，以满足不同的开发和生产环境需求。

构建RESTful API

创建Controller

Controller是Spring Boot应用中处理HTTP请求的组件。一个典型的Controller类会包含多个处理HTTP请求的方法，每个方法对应一个URL路径。

创建Controller

创建一个新的Controller类，并定义一些处理HTTP请求的方法。

package com.example.demo;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.Arrays;
import java.util.List;

@RestController
@RequestMapping("/api")
public class MyController {

    @GetMapping("/greetings")
    public List<String> greetings() {
        return Arrays.asList("Hello", "World");
    }
}

测试Controller

创建Controller后，可以通过运行Spring Boot应用并访问相应的URL路径来测试Controller。

http://localhost:8080/api/greetings

返回结果：

["Hello", "World"]

更复杂的Controller示例

假设我们想要创建一个更复杂的Controller，提供多个处理HTTP请求的方法:

package com.example.demo;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

@RestController
@RequestMapping("/api")
public class ComplexController {

    private Map<Integer, String> greetings = new HashMap<>();

    public ComplexController() {
        greetings.put(1, "Hello");
        greetings.put(2, "World");
    }

    @GetMapping("/greetings")
    public List<String> listGreetings() {
        return new ArrayList<>(greetings.values());
    }

    @GetMapping("/greetings/{id}")
    public String getGreeting(@PathVariable int id) {
        return greetings.get(id);
    }

    @PostMapping("/greetings")
    public String addGreeting(@PathVariable int id, @PathVariable String greeting) {
        greetings.put(id, greeting);
        return "Greeting added successfully";
    }

    @PostMapping("/greetings/{id}")
    public void deleteGreeting(@PathVariable int id) {
        greetings.remove(id);
    }
}

测试Controller:

GET /api/greetings: 返回所有问候语。
GET /api/greetings/1: 返回ID为1的问候语。
POST /api/greetings: 添加新的问候语。
POST /api/greetings/1: 删除ID为1的问候语。

使用Spring Data JPA操作数据库

Spring Data JPA是Spring Data的一部分，提供了对JPA的简化操作。使用Spring Data JPA，可以方便地操作数据库，而不需要编写复杂的SQL语句。

创建实体类

首先，创建一个实体类，表示数据库中的表。

package com.example.demo;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@Entity
public class User {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;
    private String email;

    // Getters and Setters
}

创建Repository接口

接下来，创建一个Repository接口，继承JpaRepository接口，定义CRUD操作。

package com.example.demo;

import org.springframework.data.jpa.repository.JpaRepository;

public interface UserRepository extends JpaRepository<User, Long> {
    User findByName(String name);
}

创建Service类

创建一个Service类，用于封装业务逻辑。

package com.example.demo;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class UserService {

    @Autowired
    private UserRepository userRepository;

    public List<User> findAll() {
        return userRepository.findAll();
    }

    public User findByName(String name) {
        return userRepository.findByName(name);
    }

    public User save(User user) {
        return userRepository.save(user);
    }

    public void deleteById(Long id) {
        userRepository.deleteById(id);
    }

    public User update(User user) {
        return userRepository.save(user);
    }
}

测试数据库操作

创建一个Controller，用于测试数据库操作。

package com.example.demo;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@RestController
@RequestMapping("/api/users")
public class UserController {

    @Autowired
    private UserService userService;

    @GetMapping
    public List<User> getAllUsers() {
        return userService.findAll();
    }

    @GetMapping("/{id}")
    public User getUserById(@PathVariable Long id) {
        return userService.findById(id).orElse(null);
    }

    @PostMapping
    public User createUser(@RequestBody User user) {
        return userService.save(user);
    }

    @PutMapping("/{id}")
    public User updateUser(@PathVariable Long id, @RequestBody User user) {
        user.setId(id);
        return userService.update(user);
    }

    @DeleteMapping("/{id}")
    public void deleteUser(@PathVariable Long id) {
        userService.deleteById(id);
    }
}

添加Swagger文档自动生成

Swagger是一个用于定义RESTful API的规范，可以帮助开发者快速生成API文档。Springfox是Swagger在Spring框架中的实现。

添加Swagger依赖

在pom.xml文件中添加Swagger的依赖。

<dependency>
    <groupId>io.springfox</groupId>
    <artifactId>springfox-swagger2</artifactId>
    <version>2.9.2</version>
</dependency>
<dependency>
    <groupId>io.springfox</groupId>
    <artifactId>springfox-swagger-ui</artifactId>
    <version>2.9.2</version>
</dependency>

配置Swagger

创建一个配置类，用于配置Swagger。

package com.example.demo;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import springfox.documentation.builders.PathSelectors;
import springfox.documentation.builders.RequestHandlerSelectors;
import springfox.documentation.spi.DocumentationType;
import springfox.documentation.spring.web.plugins.Docket;
import springfox.documentation.swagger2.annotations.EnableSwagger2;

@Configuration
@EnableSwagger2
public class SwaggerConfig {

    @Bean
    public Docket api() {
        return new Docket(DocumentationType.SWAGGER_2)
                .select()
                .apis(RequestHandlerSelectors.any())
                .paths(PathSelectors.any())
                .build();
    }
}

访问Swagger文档

启动Spring Boot应用后，可以通过访问http://localhost:8080/swagger-ui.html来查看生成的API文档。

集成前端技术栈

使用Thymeleaf模板引擎

Thymeleaf是一个功能强大的模板引擎，用于渲染HTML，并可以集成到Spring Boot应用中。

添加Thymeleaf依赖

在pom.xml文件中添加Thymeleaf的依赖。

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

创建Thymeleaf模板

在src/main/resources/templates目录下创建一个HTML模板文件。

<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<head>
    <title>Thymeleaf Example</title>
</head>
<body>
    <h1 th:text="'Hello, ' + ${name}"></h1>
</body>
</html>

创建Controller

在Controller中，返回Thymeleaf模板。

package com.example.demo;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;

@Controller
public class MyController {

    @GetMapping("/hello")
    public String greeting(Model model) {
        model.addAttribute("name", "World");
        return "greeting";
    }
}

测试Thymeleaf模板

启动Spring Boot应用，并访问http://localhost:8080/hello，可以看到页面显示了Hello, World。

前端页面与后端API的交互

Spring Boot应用可以通过前后端分离的方式，使用前端框架（如Vue.js、React等）来构建前端页面，并通过API与后端交互。

前端页面请求后端API

在前端页面中，使用JavaScript发送请求到后端API。

<!DOCTYPE html>
<html>
<head>
    <title>Spring Boot API Example</title>
    <script class="lazyload" src="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAADsQAAA7EAZUrDhsAAAANSURBVBhXYzh8+PB/AAffA0nNPuCLAAAAAElFTkSuQmCC" data-original="https://unpkg.com/axios/dist/axios.min.js"></script>
</head>
<body>
    <h1 id="greeting"></h1>

    <script>
        axios.get('/api/greetings')
            .then(response => {
                document.getElementById('greeting').innerHTML = response.data.join(', ');
            });
    </script>
</body>
</html>

后端API响应前端请求

在Spring Boot应用中，定义一个API来响应前端请求。

package com.example.demo;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.Arrays;
import java.util.List;

@RestController
@RequestMapping("/api")
public class MyController {

    @GetMapping("/greetings")
    public List<String> greetings() {
        return Arrays.asList("Hello", "World");
    }
}

静态资源处理

Spring Boot默认将src/main/resources/static目录下的文件作为静态资源提供。

静态资源目录结构

src/main/resources/static
├── css
│   └── style.css
└── js
    └── script.js

在页面中使用静态资源

在HTML页面中引用静态资源。

<!DOCTYPE html>
<html>
<head>
    <title>Static Resources Example</title>
    <link rel="stylesheet" type="text/css" href="/css/style.css">
</head>
<body>
    <h1 id="greeting"></h1>

    <script class="lazyload" src="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAADsQAAA7EAZUrDhsAAAANSURBVBhXYzh8+PB/AAffA0nNPuCLAAAAAElFTkSuQmCC" data-original="/js/script.js"></script>
</body>
</html>

在静态资源中使用Thymeleaf

在静态资源中使用Thymeleaf语法。

<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<head>
    <title>Static Resources Example</title>
    <link rel="stylesheet" type="text/css" href="/css/style.css">
</head>
<body>
    <h1 th:text="'Hello, ' + ${name}"></h1>
</body>
</html>

处理静态资源请求

在Controller中处理静态资源请求。

package com.example.demo;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;

@Controller
public class StaticResourceController {

    @GetMapping("/css/style.css")
    public String cssStyle() {
        return "css/style.css";
    }

    @GetMapping("/js/script.js")
    public String jsScript() {
        return "js/script.js";
    }
}

通过这些步骤，可以方便地将前端页面与后端API集成，并处理静态资源。

打包与部署

构建与打包项目

Spring Boot支持多种构建工具（如Maven和Gradle）来构建和打包项目。

Maven打包

使用Maven构建和打包项目。

mvn clean package

Maven会生成一个包含所有依赖的可执行JAR文件，位于target目录下。

Gradle打包

使用Gradle构建和打包项目。

./gradlew build

Gradle会生成一个包含所有依赖的可执行JAR文件，位于build/libs目录下。

部署到Tomcat服务器

可以将Spring Boot应用部署到任何传统Java应用服务器（如Tomcat）。

打包为WAR文件

使用Maven或Gradle打包为WAR文件。

<packaging>war</packaging>

或者

apply plugin: 'war'

然后执行相应的构建命令：

mvn clean package

或者

./gradlew build

部署到Tomcat

将生成的WAR文件复制到Tomcat的webapps目录下。

cp target/myapp.war /path/to/tomcat/webapps/

启动Tomcat服务器，等待应用启动。

使用Docker部署Spring Boot应用

可以使用Docker来部署Spring Boot应用，从而实现环境隔离和容器化部署。

创建Dockerfile

在项目根目录下创建一个Dockerfile文件。

FROM openjdk:8-jdk-alpine
VOLUME /tmp
ADD target/myapp.jar app.jar
ENTRYPOINT ["java","-Djava.security.egd=file:/dev/./urandom","-jar","/app.jar"]

构建Docker镜像

使用Dockerfile构建Docker镜像。

docker build -t myapp .

运行Docker容器

运行Docker镜像。

docker run -d -p 8080:8080 --name myapp myapp

通过以上步骤，可以将Spring Boot应用打包并部署到Tomcat服务器，或者使用Docker进行容器化部署。

点击查看更多内容

为 TA 点赞

若觉得本文不错，就分享一下吧！

评论

评论

共同学习，写下你的评论

评论加载中...

展开查看更多评论

作者其他优质文章

正在加载中

HUX布斯

手记
篇

粉丝

84

获赞与收藏

378

关注作者，订阅最新文章

阅读免费教程

后端通用面试教程

41个小节 30585 343

网络编程入门教程

20个小节 12562 237

Pandas 入门教程

25个小节 18499 337

推荐

评论

收藏

共同学习，写下你的评论



感谢您的支持，我会继续努力的～

扫码打赏，你说多少就多少

赞赏金额会直接到老师账户

支付方式

打开微信扫一扫，即可进行扫码打赏哦

今天注册有机会得

100积分直接送

付费专栏免费学

大额优惠券免费领

立即参与放弃机会

点击
抽奖

慕课手记新用户专享福利

恭喜你，你的运气太好了，居然抽中了 100个积分！

恭喜你，抽中了价值元的专栏！

太棒了，直接落到你账户里！

积分商城里的罗技鼠标、机械键盘、
Kindle 阅读器、小米平衡车
Apple iPad （10.2英寸）、大额优惠券
在等着你去兑换了噢

作者：

免费赠送

兑换码：1111222211 复制

优惠券可用于购买实战课、体系课
无门槛使用

先去看看，有什么好东西马上兑换我爱学习，选课去


热搜

最近搜索清空

创建Springboot项目实战：新手入门教程

创建项目

编写代码

运行项目

代码示例

自动配置的原理

自动配置的类

自动配置的优先级

代码示例

起步依赖

起步依赖的使用

起步依赖的排除

项目目录结构解析

资源文件加载位置

资源文件的加载顺序

示例代码

配置文件的覆盖

配置文件的外部化

示例代码

日志文件输出位置

示例代码

配置日志格式

调试模式

创建Controller

测试Controller

更复杂的Controller示例

创建实体类

创建Repository接口

创建Service类

测试数据库操作

添加Swagger依赖

配置Swagger

访问Swagger文档

添加Thymeleaf依赖

创建Thymeleaf模板

创建Controller

测试Thymeleaf模板

前端页面请求后端API

后端API响应前端请求

静态资源目录结构

在页面中使用静态资源

在静态资源中使用Thymeleaf

处理静态资源请求

Maven打包

Gradle打包

打包为WAR文件

部署到Tomcat

创建Dockerfile

构建Docker镜像

运行Docker容器

阅读免费教程