Springboot单体架构搭建入门教程-原创手记-慕课网

概述

Spring Boot 是一个简化应用开发的框架，通过自动配置和嵌入式服务器等功能，使得搭建单体架构变得简单。本文将详细介绍如何使用 Spring Boot 快速搭建单体架构入门项目，包括环境配置、项目创建和基本设置。Spring Boot 的优势在于简化了开发流程和运维工作，非常适合快速构建和部署应用。

Spring Boot简介

什么是Spring Boot

Spring Boot 是由 Pivotal 团队提供的一个开源框架，它旨在简化 Spring 应用程序的开发，减少配置文件的编写。Spring Boot 的设计理念是“约定优于配置”，开发人员只需关注业务逻辑的实现，而无需手动配置大量的 XML 或 Java 配置。Spring Boot 也支持嵌入式的 Web 服务器（如 Tomcat、Jetty 或 Undertow），可以直接将应用打包成一个可执行的 JAR 文件，并通过 java -jar 命令运行。

Spring Boot 不仅简化了开发流程，还通过自动配置、起步依赖等功能，使得单体架构的搭建变得更加高效和便捷。Spring Boot 的这些特性使得开发者能够专注于业务逻辑实现，而无需过多关注基础设置。

Spring Boot的优势

Spring Boot 提供了快速构建独立的、生产级别的基于 Spring 框架的应用程序的能力。以下是 Spring Boot 的主要优势：

简化配置：减少大量的 XML 和 Java 配置，甚至是大部分 Java 配置也不需要。
自动配置：Spring Boot 可以自动配置许多常见的场景，如数据库连接、测试环境等，无需手动配置。
嵌入式 Web 服务器：提供内嵌的 Tomcat、Jetty 或 Undertow 作为 Web 服务器，无需部署到外部容器。
起步依赖：通过 Maven 或 Gradle 的起步依赖功能自动管理依赖版本，避免版本冲突。
命令行接口：提供了一个强大的命令行工具 spring-boot，可以方便地启动和管理应用。

快速上手Spring Boot项目

要快速上手 Spring Boot 项目，首先需要安装 Java 和依赖管理工具（如 Maven 或 Gradle），然后创建一个新的 Spring Boot 项目。以下是详细的步骤：

安装Java和Maven或Gradle

安装 Java：确保你的开发环境中安装了 Java，通常需要 Java 8 及以上版本。
安装 Maven/Gradle：这两个工具都可以用来管理项目依赖和构建项目。这里以 Maven 为例介绍安装步骤。
- Maven：通过官网下载 Maven 安装包，解压后配置环境变量。
- Gradle：通过官网下载 Gradle 安装包，解压后配置环境变量。

创建Spring Boot项目

创建项目目录结构：创建一个工程目录，例如 spring-boot-example，并在其中创建 src 和 pom.xml 文件。
编写 pom.xml 文件：这是 Maven 项目的构建描述文件。以下是 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>spring-boot-example</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.4.2</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>

配置项目的基本设置

创建主类：在 src/main/java/com/example/springbootexample 目录下创建主类文件 Application.java，用于启动 Spring Boot 应用。

package com.example.springbootexample;

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

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

运行项目：通过命令行运行 mvn spring-boot:run 来启动应用，或者在 IDE 中运行主类。

单体架构基础

单体架构的定义

单体架构是指将一个软件应用程序的所有模块和功能都集中在一个单一的代码库中构建为单一的可部署单元。这样的架构通常会包含应用程序的所有组件，包括处理业务逻辑、数据访问、Web 控制器等。这种架构简单直观，易于理解和维护。

单体架构的特点

单体架构的特点如下：

单一代码库：所有的代码、配置、依赖和运行时环境共同构成一个单元，统一维护。
统一部署：整个应用程序作为单一的单元进行部署，易于管理和监控。
开箱即用：通常包括数据库连接、缓存配置、日志记录等，开箱即用。
开发简单：简化了开发流程，无需额外配置和设置。

单体架构的优势与劣势

优势

快速迭代：开发速度较快，可以快速迭代。
简化运维：简化了运维流程，部署简单，易于监控。
易于维护：由于所有代码都在一个代码库中，因此维护起来相对容易。

劣势

扩展性差：难以扩展，特别是随着项目复杂性和团队规模的增加。
技术栈单一：项目中只能使用单一的技术栈，限制了技术选型的灵活性。
性能瓶颈：随着应用功能的扩展，单体应用可能成为性能瓶颈。
部署复杂：大型单体应用的部署和测试可能会变得复杂。

Spring Boot项目搭建

安装Java和Maven或Gradle

安装 Java：确保系统中安装了 Java，通常需要 Java 8 及以上版本。
安装 Maven/Gradle：这两个工具都可以用来管理项目依赖和构建项目。

创建Spring Boot项目

创建项目目录结构：创建一个工程目录，例如 spring-boot-example，并在其中创建 src 和 pom.xml 文件。
编写 pom.xml 文件：这是 Maven 项目的构建描述文件。以下是 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>spring-boot-example</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.4.2</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>

创建主类

在 src/main/java/com/example/springbootexample 目录下创建主类文件 Application.java，用于启动 Spring Boot 应用。

package com.example.springbootexample;

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

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

运行项目

通过命令行运行 mvn spring-boot:run 来启动应用，或者在 IDE 中运行主类。

配置项目的基本设置

配置文件

Spring Boot 使用 application.properties 或 application.yml 文件来配置应用程序的基本设置。例如，可以在 src/main/resources 目录下创建 application.properties 文件，设置数据库连接信息、服务器端口等。

server.port=8080
spring.datasource.url=jdbc:mysql://localhost:3306/db_name
spring.datasource.username=root
spring.datasource.password=root

启动类配置

使用 @SpringBootApplication 注解的主类可以启用自动配置和组件扫描。可以通过以下配置调整 Spring Boot 的行为：

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;

@Configuration
@PropertySource("classpath:application.properties")
@SpringBootApplication
public class Application {
  public static void main(String[] args) {
    SpringApplication.run(Application.class, args);
  }
}

Spring Boot常用组件介绍

Spring MVC

Spring MVC 是 Spring 框架的一部分，用于构建 Web 应用程序。它是一个基于 Java 的 Web 框架，支持 MVC 架构模式，用来构建分层的应用程序。

核心组件

DispatcherServlet：前端控制器，负责接收请求并分发给相应的处理器。
HandlerMapping：处理器映射器，将请求 URL 映射到处理器。
Controller：处理器，处理具体的业务逻辑。
ViewResolver：视图解析器，将逻辑视图名称转换为具体的视图实现。

示例代码

使用 Spring MVC 创建一个简单的控制器来处理 HTTP 请求和响应。

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

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

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

配置 Web 服务器

Spring Boot 会自动配置内嵌的 Tomcat 服务器。为了配置端口号和其他设置，可以在 application.properties 文件中添加以下配置：

server.port=8080

Spring Data JPA

Spring Data JPA 是 Spring Data 项目的一部分，提供了对 JPA（Java Persistence API）的便捷访问。它简化了数据访问层的开发，提供了强大的数据访问功能，如 CRUD 操作、分页查询等。

核心组件

Repository：抽象接口，提供了对数据访问的通用方法。
JpaRepository：扩展了 Repository 接口，提供了更多功能，如分页、排序等。
Entity Manager：与 JPA 一致，管理持久化对象的生命周期。

示例代码

创建一个简单的 JPA 项目来演示如何使用 Spring Data JPA。首先，定义一个简单的实体类：

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
}

然后，创建一个 UserRepository 接口继承自 JpaRepository，自动实现所有基本操作：

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

public interface UserRepository extends JpaRepository<User, Long> {
}

最后，在控制器中使用 UserRepository 进行数据操作：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;

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

  @Autowired
  private UserRepository userRepository;

  @GetMapping("/")
  public List<User> listUsers() {
    return userRepository.findAll();
  }

  @GetMapping("/create")
  public User createUser() {
    User user = new User();
    user.setName("John Doe");
    user.setEmail("john.doe@example.com");
    return userRepository.save(user);
  }

  @GetMapping("/update")
  public User updateUser() {
    User user = userRepository.findById(1L).orElse(null);
    if (user != null) {
      user.setName("Jane Doe");
      return userRepository.save(user);
    }
    return null;
  }

  @GetMapping("/delete")
  public void deleteUser() {
    User user = userRepository.findById(1L).orElse(null);
    if (user != null) {
      userRepository.delete(user);
    }
  }
}

配置数据库连接

Spring Boot 会自动配置数据库连接，只需在 application.properties 文件中配置数据库连接信息：

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

spring.jpa.hibernate.ddl-auto=update
spring.jpa.show-sql=true

Spring Security

Spring Security 是一个强大的安全框架，可以保护 Web 应用程序免受常见的安全威胁，如 CSRF 攻击、XSS 攻击等。它提供了认证、授权等功能。

核心组件

UserDetailsService：负责加载用户信息。
SecurityConfigurer：配置安全相关的属性。
HttpSecurity：配置 HTTP 安全性。
AuthenticationProvider：验证用户的身份。
AuthenticationManager：认证一个用户凭据。

示例代码

创建一个简单的安全配置来保护 API 端点：

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
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(AuthenticationManagerBuilder auth) throws Exception {
    auth.inMemoryAuthentication()
      .withUser("user")
      .password(passwordEncoder().encode("password"))
      .roles("USER");
  }

  @Override
  protected void configure(HttpSecurity http) throws Exception {
    http.authorizeRequests()
      .antMatchers("/api/public").permitAll()
      .antMatchers("/api/**").authenticated()
      .and()
      .formLogin();
  }

  @Bean
  public PasswordEncoder passwordEncoder() {
    return new BCryptPasswordEncoder();
  }
}

在控制器中添加安全注解：

import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;

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

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

  @PreAuthorize("hasRole('USER')")
  @GetMapping("/user")
  public String user() {
    return "User endpoint";
  }
}

Spring Boot应用部署

打包Spring Boot应用

打包 Spring Boot 应用程序的步骤如下：

构建项目：使用 Maven 或 Gradle 构建项目。
生成 JAR 包：通过 Maven 或 Gradle 命令生成可执行的 JAR 包。

使用Maven打包

运行以下命令来构建和打包项目：

mvn clean package

这将在 target 目录下生成 spring-boot-example-0.0.1-SNAPSHOT.jar 文件。

使用Gradle打包

运行以下命令来构建和打包项目：

./gradlew bootJar

这将在 build/libs 目录下生成 spring-boot-example-0.0.1-SNAPSHOT.jar 文件。

使用IDE打包

在大多数 IDE 中，可以使用构建工具（如 Maven 或 Gradle）的插件来构建和打包项目。通常可以在 IDE 的构建选项中找到相关命令。

部署到本地Tomcat服务器

下载和安装Tomcat：从 Apache Tomcat 官网下载并安装 Tomcat。
将JAR包复制到Tomcat的webapps目录：将生成的 JAR 包复制到 Tomcat 的 webapps 目录下。
启动Tomcat服务器：运行 Tomcat 服务器，访问应用。

示例步骤

假设 Tomcat 安装在 C:\apache-tomcat-9.0.37 目录下：

复制JAR包到webapps目录：

copy C:\path\to\spring-boot-example-0.0.1-SNAPSHOT.jar C:\apache-tomcat-9.0.37\webapps\ROOT.jar

启动Tomcat服务器：

C:\apache-tomcat-9.0.37\bin\startup.bat

启动成功后，可以通过浏览器访问 http://localhost:8080 来查看应用。

部署到云服务器

部署到云服务器的过程如下：

上传JAR包到服务器：将生成的 JAR 包上传到云服务器。
运行JAR包：在服务器上运行 JAR 包。
配置服务器环境：确保服务器上安装了 Java 和必要的依赖库。

示例步骤

假设使用 SSH 登录到云服务器：

上传JAR包：

scp C:\path\to\spring-boot-example-0.0.1-SNAPSHOT.jar user@yourserver:/home/user/

运行JAR包：

java -jar spring-boot-example-0.0.1-SNAPSHOT.jar

配置服务器环境：确保 Java 和其他依赖库已经安装。

sudo apt-get update
sudo apt-get install openjdk-11-jdk

常见问题及解决方案

项目启动失败的常见原因

常见的项目启动失败原因包括：

依赖冲突：多个依赖之间存在版本冲突。
配置错误：配置文件中的错误或遗漏。
环境变量未设置：如 Java 安装路径、环境变量未设置。
资源文件未找到：资源文件路径错误或未包含在构建输出中。

解决方案

依赖冲突：检查 pom.xml 或 build.gradle 文件，确保所有依赖的版本一致。
配置错误：检查配置文件 application.properties 或 application.yml，确保没有拼写错误或配置遗漏。
环境变量未设置：确保 Java 环境变量已经设置。
资源文件未找到：确保资源文件路径正确，并且已经包含在构建输出中。

热部署和热重启配置

热部署是指在开发过程中，代码发生变化时无需重新启动应用即可更新。

配置热部署：在 application.properties 或 application.yml 文件中添加热部署配置。

spring.devtools.restart.enabled=true
spring.devtools.restart.poll-interval=1000
spring.devtools.restart.additional-paths=src/main/resources

使用IDE支持：许多现代 IDE（如 IntelliJ IDEA 和 Eclipse）提供了热部署的支持。

示例代码

spring.devtools.restart.enabled=true
spring.devtools.restart.poll-interval=1000
spring.devtools.restart.additional-paths=src/main/resources

使用IDE支持

在 IntelliJ IDEA 中，启用 File -> Settings -> Build, Execution, Deployment -> Compiler -> Build project automatically。

在 Eclipse 中，启用 Project -> Build Automatically。

框架版本兼容性问题

兼容性问题是指不同版本的框架或库之间可能存在的不兼容性。解决这些问题包括：

检查文档和版本兼容性：确保使用的框架或库版本已知并且兼容。
使用版本管理工具：使用 Maven 或 Gradle 的版本管理功能来管理依赖版本。
依赖树检查：使用 mvn dependency:tree 或 gradle dependencies 检查依赖树，确保没有冲突。

示例代码

检查 Maven 项目的依赖树：

mvn dependency:tree

检查 Gradle 项目的依赖树：

./gradlew dependencies

总结

通过以上步骤，你可以成功搭建一个 Spring Boot 单体架构项目，并部署到不同的环境。Spring Boot 通过其强大的功能和简单的配置，极大地简化了应用程序的开发和部署。希望本教程能帮助你快速入门 Spring Boot 项目开发。