Springboot单体架构搭建学习指南-原创手记-慕课网

概述

本文介绍了如何搭建Spring Boot单体架构，通过详细步骤和示例代码，帮助读者快速掌握Spring Boot单体架构搭建学习。

Spring Boot简介

Spring Boot是什么

Spring Boot 是由 Spring 团队提供的框架，旨在简化基于 Spring 的应用程序开发过程。它通过约定优于配置的方式，减少配置文件的数量，使开发者能够快速搭建独立的、生产级别的应用。Spring Boot 使开发者在没有外部配置的情况下，能够运行一个完整的 Spring 应用程序。Spring Boot 可用于构建各种类型的应用程序，包括 Web 应用、命令行工具、批处理作业等。Spring Boot 不仅仅是一个框架，它更像一个构建模块，可以在里面放入各种库和配置，开发者只需要关心代码逻辑实现即可。

Spring Boot的优点

Spring Boot 的优点主要包括以下几点：

快速启动：Spring Boot 可以让你的应用程序快速启动，而不需要大量的配置文件。
自动配置：Spring Boot 可以根据项目依赖自动配置应用程序，减少配置文件的需要。
开箱即用：Spring Boot 提供了许多内置的特性，如内置的 Servlet 容器、安全配置、日志管理等。
无须 XML 配置：Spring Boot 使用 Java 注解进行配置，减少了 XML 配置文件的使用。
嵌入式容器支持：Spring Boot 支持 Tomcat、Jetty、Undertow 等嵌入式容器，开发者不需要手动部署到外部容器。
模块化开发：Spring Boot 使用模块化开发，可以将应用分割成多个独立的模块，每个模块可以独立开发和测试。
监控和日志：Spring Boot 提供了应用运行时的监控和日志管理功能，可以方便地监控应用运行状态并进行故障排查。
无须修改源码：Spring Boot 提供了大量的配置选项，大部分情况下可以通过修改配置文件来改变应用的行为，而不需要修改源代码。

单体架构概述

什么是单体架构

单体架构是一种将一个应用的所有功能模块打包成一个单独的可执行文件或部署单元的架构模式。在这种架构中，所有的组件，包括业务逻辑、持久层、视图层等，都紧密地集成在同一个过程中。单体架构通常使用传统的 MVC（Model-View-Controller）模式或类似的架构风格来构建。

单体架构的特点和优缺点

特点

简单易懂：单体架构简单明了，易于理解和维护。
易于部署：由于所有功能都在一个部署单元中，所以部署相对简单。
开发快速：对于小型项目，由于所有功能都在一个应用中，所以开发周期短，开发速度快。
测试方便：由于所有功能在一个应用中，测试比较方便，可以使用集成测试来测试整个应用。
配置简化：由于所有的配置都在一个地方，所以配置相对简洁。

优缺点

优点
- 简单易懂：单体架构由于所有功能都在一个应用中，所以整个应用架构简单易懂。
- 易于部署：由于所有功能都在一个部署单元中，所以部署相对简单。
- 开发快速：对于小型项目，由于所有功能都在一个应用中，所以开发周期短，开发速度快。
- 测试方便：由于所有功能在一个应用中，测试比较方便，可以使用集成测试来测试整个应用。
- 配置简化：由于所有的配置都在一个地方，所以配置相对简洁。
缺点
- 部署时间长：随着应用功能越来越复杂，应用的大小也会越来越大，部署时间会变长。
- 开发效率降低：随着应用功能越来越多，开发效率会降低，代码维护变得困难，重构和升级的成本也会增加。
- 扩展性差：单体架构扩展性差，当应用需要扩展时，往往需要重新部署整个应用。
- 维护困难：单体架构维护困难，由于所有的功能都在一个应用中，所以当其中一个模块出现问题时，会影响到整个应用的运行。
- 性能瓶颈：随着应用的复杂度和数据量的增加，单体架构容易出现性能瓶颈，影响用户体验。

单体架构的应用场景

小型项目：对于小型项目，单体架构是一种简单、高效的选择。
简单的功能：如果应用只是简单的功能，不需要复杂的架构设计，单体架构是一种合适的选择。
快速迭代：对于需要快速迭代的应用，单体架构可以快速开发和部署，减少了开发周期。
简单的业务场景：对于简单的业务场景，单体架构可以满足需求，不需要复杂的架构设计。
易于维护：对于需要易于维护的应用，单体架构是一种合适的选择，由于所有功能都在一个应用中，所以维护比较方便。

搭建Spring Boot开发环境

安装Java开发环境

为了搭建 Spring Boot 开发环境，需要先安装 Java 开发环境。以下是一个简单的步骤来安装 Java：

访问 Java 官方网站，下载最新的 JDK（Java Development Kit）版本。
安装 JDK，并确保 Java 的环境变量配置正确。
验证 Java 安装是否成功。可以使用以下命令来检查：

java -version
javac -version

这两个命令分别用于查看 Java 和 Java 编译器的版本信息。

安装IDE（如IntelliJ IDEA或Eclipse）

安装一个适合开发 Spring Boot 应用的集成开发环境（IDE），例如 IntelliJ IDEA 或 Eclipse。

IntelliJ IDEA 安装步骤：

访问 IntelliJ IDEA 官方网站，下载并安装 IntelliJ IDEA 社区版或专业版。
打开 IntelliJ IDEA，选择“Open”或“Create New Project”。
在“Create New Project”窗口中，选择“Spring Initializr”，点击“Next”按钮。
在“Spring Initializr”窗口中，选择“Maven”或“Gradle”作为构建工具，选择 Java 版本。
选择“Spring Boot”版本和项目名称，点击“Next”按钮。
选择项目依赖，例如 Web、JPA、Thymeleaf 等，点击“Finish”按钮。
IntelliJ IDEA 会自动生成项目文件和依赖。

Eclipse 安装步骤：

访问 Eclipse 官方网站，下载并安装 Eclipse IDE for Enterprise Java Developers（Eclipse EE）。
打开 Eclipse，选择“File” -> “New” -> “Spring Starter Project”。
在“New Spring Starter Project”窗口中，选择“Maven”或“Gradle”作为构建工具，选择 Java 版本。
选择“Spring Boot”版本和项目名称，点击“Next”按钮。
选择项目依赖，例如 Web、JPA、Thymeleaf 等，点击“Finish”按钮。
Eclipse 会自动生成项目文件和依赖。

下载和配置Spring Boot Starter

Spring Boot Starter 是一组可以自动配置 Spring 应用程序的库。以下是在 IntelliJ IDEA 中下载和配置 Spring Boot Starter 的步骤：

打开 IntelliJ IDEA，选择“File” -> “New” -> “Project”。
在“New Project”窗口中，选择“Spring Initializr”，点击“Next”按钮。
在“Spring Initializr”窗口中，选择“Maven”或“Gradle”作为构建工具，选择 Java 版本。
选择“Spring Boot”版本和项目名称，点击“Next”按钮。
选择项目依赖，例如 Web、JPA、Thymeleaf 等，点击“Finish”按钮。
IntelliJ IDEA 会自动生成项目文件和依赖，此时可以使用 Maven 或 Gradle 的命令来下载并配置 Spring Boot Starter。

例如，使用 Maven 下载依赖：

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
        <version>2.5.4</version>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-jpa</artifactId>
        <version>2.5.4</version>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-thymeleaf</artifactId>
        <version>2.5.4</version>
    </dependency>
</dependencies>

使用 Gradle 下载依赖：

dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-web:2.5.4'
    implementation 'org.springframework.boot:spring-boot-starter-data-jpa:2.5.4'
    implementation 'org.springframework.boot:spring-boot-starter-thymeleaf:2.5.4'
}

创建Spring Boot项目

使用Spring Initializr创建项目

Spring Initializr 是一个在线工具，可以帮助开发者快速创建 Spring Boot 项目。以下是使用 Spring Initializr 创建项目的步骤：

访问 Spring Initializr 官方网站（https://start.spring.io/）。
在网站上选择项目类型（例如 Maven 项目或 Gradle 项目），并选择 Java 版本。
选择 Spring Boot 版本和项目名称。
添加项目依赖，例如 Web、JPA、Thymeleaf 等。
点击“Generate”按钮，下载项目压缩包。
解压压缩包，将项目导入到 IDE 中（例如 IntelliJ IDEA 或 Eclipse）。

导入项目到IDE中

打开 IntelliJ IDEA，选择“File” -> “Open”。
选择解压后的项目文件夹，点击“OK”按钮。
IntelliJ IDEA 会自动检测项目依赖并导入项目。
打开 Eclipse，选择“File” -> “Import”。
在“Import”窗口中，选择“Existing Maven Projects”，点击“Next”按钮。
在“Import Maven Projects”窗口中，选择解压后的项目文件夹，点击“Finish”按钮。
Eclipse 会自动检测项目依赖并导入项目。

添加依赖和配置

在项目中添加依赖和配置，以便 Spring Boot 能够自动配置应用程序。以下是一个示例 pom.xml 文件的内容：

<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.5.4</version>
    </parent>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-thymeleaf</artifactId>
        </dependency>
        <dependency>
            <groupId>com.h2database</groupId>
            <artifactId>h2</artifactId>
            <scope>runtime</scope>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

实现基本功能

编写控制器（Controller）

控制器是 Spring MVC 中的重要组成部分，用于处理 HTTP 请求并返回响应。以下是一个简单的控制器示例：

package com.example.demo.controller;

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

@Controller
@RequestMapping("/hello")
public class HelloController {

    @GetMapping("/")
    @ResponseBody
    public String hello() {
        return "Hello, World!";
    }
}

在这个示例中，HelloController 类使用了 @Controller 注解，表示这是一个控制器。@RequestMapping("/hello") 注解指定了该控制器处理的所有请求都以 /hello 开头。@GetMapping("/") 注解指定了该方法处理所有的 HTTP GET 请求，URL 为 /hello/ 时会调用 hello() 方法，该方法返回字符串 Hello, World!。

使用Spring Boot启动器

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

在这个示例中，DemoApplication 类使用了 @SpringBootApplication 注解，该注解是一个组合注解，包含了 @Configuration、@EnableAutoConfiguration 和 @ComponentScan 等注解。main() 方法中调用了 SpringApplication.run() 方法来启动应用。

配置数据库连接和基本的CRUD操作

为了实现数据库连接和基本的 CRUD 操作，需要配置数据库连接和定义持久层。

配置数据库连接

在 application.properties 文件中配置数据库连接信息：

spring.datasource.url=jdbc:h2:mem:testdb
spring.datasource.driverClassName=org.h2.Driver
spring.datasource.username=root
spring.datasource.password=root
spring.h2.console.enabled=true
spring.jpa.hibernate.ddl-auto=update

定义持久层

定义一个简单的持久层实体类和对应的仓库接口：

package com.example.demo.entity;

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

@Entity
public class Person {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String firstName;
    private String lastName;

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getFirstName() {
        return firstName;
    }

    public void setFirstName(String firstName) {
        this.firstName = firstName;
    }

    public String getLastName() {
        return lastName;
    }

    public void setLastName(String lastName) {
        this.lastName = lastName;
    }
}

package com.example.demo.repository;

import org.springframework.data.jpa.repository.JpaRepository;
import com.example.demo.entity.Person;

public interface PersonRepository extends JpaRepository<Person, Long> {
}

实现CRUD操作

在控制器中实现 CRUD 操作：

package com.example.demo.controller;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import com.example.demo.entity.Person;
import com.example.demo.repository.PersonRepository;

@RestController
@RequestMapping("/people")
public class PersonController {

    @Autowired
    private PersonRepository personRepository;

    @GetMapping("/")
    public Iterable<Person> getAllPeople() {
        return personRepository.findAll();
    }

    @PostMapping("/")
    public Person createPerson(@RequestBody Person person) {
        return personRepository.save(person);
    }

    @GetMapping("/{id}")
    public Person getPersonById(@PathVariable Long id) {
        return personRepository.findById(id).orElse(null);
    }

    @PutMapping("/{id}")
    public Person updatePerson(@PathVariable Long id, @RequestBody Person person) {
        return personRepository.findById(id).map(personToUpdate -> {
            personToUpdate.setFirstName(person.getFirstName());
            personToUpdate.setLastName(person.getLastName());
            return personRepository.save(personToUpdate);
        }).orElse(null);
    }

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

在这个示例中，PersonController 类定义了几个 REST 接口来实现 CRUD 操作。@Autowired 注解用于注入 PersonRepository 接口的实现。

测试和部署Spring Boot应用

使用JUnit进行单元测试

JUnit 是一个流行的 Java 单元测试框架。以下是一个简单的单元测试示例：

package com.example.demo;

import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.assertEquals;

class DemoApplicationTests {

    @Test
    void contextLoads() {
        assertEquals(2, 2, "Test failed");
    }
}

在这个示例中，DemoApplicationTests 类包含一个简单的单元测试方法 contextLoads()，该方法使用 assertEquals 断言来验证两个数字是否相等。

编写测试用例

在 PersonController 中的方法进行测试，例如：

package com.example.demo.controller;

import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import org.springframework.boot.test.context.SpringBootTest;
import com.example.demo.entity.Person;
import com.example.demo.repository.PersonRepository;

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

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.mockito.Mockito.*;

@SpringBootTest
class PersonControllerTest {

    @Mock
    private PersonRepository personRepository;

    @InjectMocks
    private PersonController personController;

    @BeforeEach
    void setUp() {
        MockitoAnnotations.openMocks(this);
    }

    @Test
    void testGetAllPeople() {
        List<Person> people = Arrays.asList(
                new Person(1L, "John", "Doe"),
                new Person(2L, "Jane", "Doe")
        );
        when(personRepository.findAll()).thenReturn(people);

        List<Person> result = personController.getAllPeople();

        assertEquals(2, result.size());
    }

    @Test
    void testCreatePerson() {
        Person person = new Person();
        person.setFirstName("John");
        person.setLastName("Doe");

        when(personRepository.save(any(Person.class))).thenReturn(person);

        Person result = personController.createPerson(person);

        assertEquals("John", result.getFirstName());
        assertEquals("Doe", result.getLastName());
    }

    @Test
    void testGetPersonById() {
        Person person = new Person(1L, "John", "Doe");
        when(personRepository.findById(1L)).thenReturn(java.util.Optional.of(person));

        Person result = personController.getPersonById(1L);

        assertEquals("John", result.getFirstName());
        assertEquals("Doe", result.getLastName());
    }

    @Test
    void testUpdatePerson() {
        Person person = new Person(1L, "John", "Doe");
        person.setFirstName("Jane");
        person.setLastName("Smith");

        when(personRepository.findById(1L)).thenReturn(java.util.Optional.of(person));
        when(personRepository.save(person)).thenReturn(person);

        Person result = personController.updatePerson(1L, person);

        assertEquals("Jane", result.getFirstName());
        assertEquals("Smith", result.getLastName());
    }

    @Test
    void testDeletePerson() {
        personController.deletePerson(1L);
        verify(personRepository, times(1)).deleteById(1L);
    }
}

应用打包和部署

打包Spring Boot应用

使用 Maven 或 Gradle 打包 Spring Boot 应用程序。以下是如何使用 Maven 打包应用程序：

mvn clean package

这将生成一个名为 demo-0.0.1-SNAPSHOT.jar 的可执行 JAR 文件。

部署Spring Boot应用

将生成的 JAR 文件部署到任何支持 Java 的环境中。例如，可以使用命令行启动 JAR 文件：

java -jar target/demo-0.0.1-SNAPSHOT.jar

也可以部署到云服务提供商，如 AWS、Google Cloud 或阿里云等。

应用监控和日志管理

Spring Boot 提供了许多监控和日志管理的功能，可以通过配置文件来启用这些功能。

启用Actuator

Actuator 是 Spring Boot 的一个模块，提供了一系列的端点来监控和管理应用程序的状态。以下是如何启用 Actuator：

management.endpoints.web.exposure.include=*
management.endpoint.health.show-details=always

启用 Actuator 后，可以通过访问 /actuator 地址来查看应用程序的状态信息。

启用日志管理

Spring Boot 默认使用 Logback 作为日志框架，可以在 application.properties 文件中配置日志级别、日志格式等信息。例如：

logging.level.root=INFO
logging.file.name=app.log

总结

通过以上步骤，您已经了解了如何搭建 Spring Boot 开发环境，创建 Spring Boot 项目，实现基本功能，并测试和部署 Spring Boot 应用程序。希望这些指南和示例代码能够帮助您快速上手 Spring Boot 开发。