Spring Boot项目实战：从入门到简单应用-原创手记-慕课网

概述

本文详细介绍了如何进行Spring Boot项目实战，从环境搭建到项目部署，涵盖了Spring Boot的各项核心功能和实战案例。文章内容包括配置文件详解、常用注解使用，以及构建简单的RESTful API等，旨在帮助读者快速掌握Spring Boot项目开发。

Spring Boot简介

什么是Spring Boot

Spring Boot是由Pivotal团队提供的基于Spring框架的一个开源项目，旨在简化Spring应用的初始搭建以及开发过程。Spring Boot允许开发者通过提供一组默认设置来最大限度地减少配置，帮助开发者快速搭建独立运行的Spring应用。此外，Spring Boot还提供了大量的自动配置功能，可以极大地减少开发者在配置文件上的工作量。

Spring Boot的优势和特点

自动配置：Spring Boot通过自动配置机制简化了Spring应用的配置。例如，Spring Boot可以根据应用的依赖自动配置Bean，并且默认情况下，对于Web应用，它会自动配置嵌入式Tomcat服务器。
独立运行：Spring Boot应用可以打包成独立的可运行的jar或war文件，不需要部署到外部的Web容器中。
快速构建：借助Spring Boot，开发者可以快速搭建项目结构，通过Spring Initializr工具，可以自动生成项目模板。
内嵌Web服务器：Spring Boot支持内嵌的Tomcat、Jetty或Undertow，可以方便地进行开发、测试及部署。
约定大于配置：Spring Boot推崇约定大于配置的理念，通过约定来减少项目的配置。例如，它默认会将主配置文件命名为application.properties或application.yml。
嵌入式Servlet容器：Spring Boot支持内嵌的Servlet容器（如Tomcat、Jetty等），使得应用可以直接运行。
生产就绪功能：Spring Boot提供了一系列的生产就绪功能，如健康检查、性能指标、外部化配置等。

开发环境搭建

搭建Java开发环境

JDK安装：首先安装Java开发工具包（JDK）。推荐版本为JDK 11或更高版本。
IDE选择：选择一个合适的IDE，例如IntelliJ IDEA、Eclipse或Spring Tool Suite（STS）。
安装Maven或Gradle：选择一个构建工具，推荐使用Maven或Gradle。

创建Hello World项目

安装Maven：下载并安装Maven。
创建Maven项目：使用命令行或IDE创建一个新的Maven项目。
添加依赖：在pom.xml文件中添加Spring Boot的依赖。示例代码如下：

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
        <version>2.7.4</version>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <version>2.7.4</version>
        <scope>test</scope>
    </dependency>
</dependencies>

编写代码：创建一个简单的Spring Boot应用。

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

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

创建Spring Boot项目

使用Spring Initializr：访问Spring Initializr网站，创建一个新的Spring Boot项目。
选择项目配置：选择项目的基本设置，如语言（Java）、依赖（如Web开发）、Java版本等。
下载并导入项目：下载生成的项目文件，并导入到IDE中。

创建第一个Spring Boot项目

使用Spring Initializr创建项目

访问Spring Initializr网站

打开Spring Initializr网站。
选择项目的基本配置，如语言（Java）、依赖（如Web开发）、Java版本等。
点击“Generate”按钮生成项目文件。

下载项目

从Spring Initializr生成的项目文件中，下载生成的.zip或.tar.gz文件。
解压文件，将项目导入到IDE中。

项目结构解析

一个典型的Spring Boot项目结构包括以下几个主要部分：

src/main/java：存放Java源代码，包括主类、配置类、控制器、服务类和数据访问类等。
src/main/resources：存放资源文件，如配置文件（application.properties或application.yml）、静态资源文件（如CSS、JS、HTML等）。
src/test/java：存放测试代码。
pom.xml：Maven项目的配置文件，定义了项目的依赖、构建配置等。

运行第一个Spring Boot应用

启动应用

运行主类：找到并运行项目中的主类（通常标记了@SpringBootApplication注解的类）。

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

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

查看日志：在控制台输出的日志中，可以观察到应用成功启动的信息。默认情况下，Spring Boot应用会运行在8080端口。

访问应用

打开浏览器：在浏览器中输入http://localhost:8080，访问应用。
查看默认首页：Spring Boot默认提供了/路径的欢迎页面，显示“Welcome to Spring Boot”。

Spring Boot中的常用注解

@SpringBootApplication

@SpringBootApplication是Spring Boot中最重要的注解之一，它包含了三个注解：@Configuration、@EnableAutoConfiguration和@ComponentScan。

@Configuration：表示当前类是配置类，可以用来定义配置Bean。
@EnableAutoConfiguration：启用自动配置功能。
@ComponentScan：扫描指定包下的组件，自动注册为Spring Bean。

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

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

@RestController和@RequestMapping

@RestController：标记一个类为RESTful风格的控制器。
@RequestMapping：用于映射处理请求的控制器方法到具体的URL映射，可以配置在类或方法级别。
- @GetMapping：用于映射HTTP GET请求。
- @PostMapping：用于映射HTTP POST请求。

示例代码：

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 HelloWorldController {
    @GetMapping("/hello")
    public String hello() {
        return "Hello, World!";
    }
}

@Service和@Repository

@Service：标记一个类为业务逻辑组件。
@Repository：标记一个类为数据访问组件。

示例代码：

import org.springframework.stereotype.Service;

@Service
public class UserService {
    public String getUser() {
        return "John Doe";
    }
}

import org.springframework.stereotype.Repository;

@Repository
public class UserRepository {
    public String getUserFromDatabase() {
        return "John Doe";
    }
}

实战案例：构建简单的RESTful API

数据模型设计

假设我们要构建一个图书管理系统，需要设计图书的模型。定义图书类如下：

import java.util.Date;

public class Book {
    private String id;
    private String title;
    private String author;
    private Date publishDate;

    public Book(String id, String title, String author, Date publishDate) {
        this.id = id;
        this.title = title;
        this.author = author;
        this.publishDate = publishDate;
    }

    public String getId() {
        return id;
    }

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

    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    public String getAuthor() {
        return author;
    }

    public void setAuthor(String author) {
        this.author = author;
    }

    public Date getPublishDate() {
        return publishDate;
    }

    public void setPublishDate(Date publishDate) {
        this.publishDate = publishDate;
    }
}

控制器实现

定义图书控制器，处理图书的增删改查操作。

import org.springframework.web.bind.annotation.*;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;

@RestController
@RequestMapping("/api/books")
public class BookController {
    private List<Book> books = new ArrayList<>();

    @GetMapping
    public List<Book> getAllBooks() {
        return books;
    }

    @PostMapping
    public Book addBook(@RequestBody Book book) {
        books.add(book);
        return book;
    }

    @GetMapping("/{id}")
    public Book getBookById(@PathVariable String id) {
        for (Book book : books) {
            if (book.getId().equals(id)) {
                return book;
            }
        }
        return null;
    }

    @DeleteMapping("/{id}")
    public void deleteBook(@PathVariable String id) {
        Book bookToDelete = null;
        for (Book book : books) {
            if (book.getId().equals(id)) {
                bookToDelete = book;
                break;
            }
        }
        if (bookToDelete != null) {
            books.remove(bookToDelete);
        }
    }

    @PutMapping("/{id}")
    public Book updateBook(@PathVariable String id, @RequestBody Book updatedBook) {
        for (int i = 0; i < books.size(); i++) {
            Book book = books.get(i);
            if (book.getId().equals(id)) {
                books.set(i, updatedBook);
                return updatedBook;
            }
        }
        return null;
    }
}

服务层实现

定义图书服务层，处理业务逻辑。

import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;

@Service
public class BookService {
    private List<Book> books = new ArrayList<>();

    public List<Book> getAllBooks() {
        return books;
    }

    public Book addBook(Book book) {
        books.add(book);
        return book;
    }

    public Book getBookById(String id) {
        for (Book book : books) {
            if (book.getId().equals(id)) {
                return book;
            }
        }
        return null;
    }

    public void deleteBook(String id) {
        Book bookToDelete = null;
        for (Book book : books) {
            if (book.getId().equals(id)) {
                bookToDelete = book;
                break;
            }
        }
        if (bookToDelete != null) {
            books.remove(bookToDelete);
        }
    }

    public Book updateBook(String id, Book updatedBook) {
        for (int i = 0; i < books.size(); i++) {
            Book book = books.get(i);
            if (book.getId().equals(id)) {
                books.set(i, updatedBook);
                return updatedBook;
            }
        }
        return null;
    }
}

数据访问层实现

定义图书数据访问层，模拟数据库操作。

import org.springframework.stereotype.Repository;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;

@Repository
public class BookRepository {
    private List<Book> books = new ArrayList<>();

    public List<Book> findAll() {
        return books;
    }

    public Book save(Book book) {
        books.add(book);
        return book;
    }

    public Book findById(String id) {
        for (Book book : books) {
            if (book.getId().equals(id)) {
                return book;
            }
        }
        return null;
    }

    public Book deleteById(String id) {
        Book bookToDelete = null;
        for (Book book : books) {
            if (book.getId().equals(id)) {
                bookToDelete = book;
                break;
            }
        }
        if (bookToDelete != null) {
            books.remove(bookToDelete);
        }
        return bookToDelete;
    }

    public Book updateById(String id, Book updatedBook) {
        Book bookToUpdate = findById(id);
        if (bookToUpdate != null) {
            books.remove(bookToUpdate);
            books.add(updatedBook);
            return updatedBook;
        }
        return null;
    }
}

测试API

启动应用：
- 在IDE中运行主类HelloWorldApplication。
测试添加图书：
- 使用Postman或其他工具，发送POST请求到http://localhost:8080/api/books，请求体为：

{
    "id": "1",
    "title": "Spring in Action",
    "author": "Craig Walls",
    "publishDate": "2023-01-01"
}

测试查询图书：
- 使用Postman或其他工具，发送GET请求到http://localhost:8080/api/books。
测试查询特定图书：
- 使用Postman或其他工具，发送GET请求到http://localhost:8080/api/books/1。
测试更新图书：
- 使用Postman或其他工具，发送PUT请求到http://localhost:8080/api/books/1，请求体为：

{
    "id": "1",
    "title": "Spring Boot in Action",
    "author": "Craig Walls",
    "publishDate": "2023-01-01"
}

测试删除图书：
- 使用Postman或其他工具，发送DELETE请求到http://localhost:8080/api/books/1。

配置文件详解

application.properties和application.yml

Spring Boot支持两种主要的配置文件格式：application.properties和application.yml。

application.properties

使用键值对形式表示配置信息，例如：

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

application.yml

使用YAML格式表示配置信息，例如：

server:
  port: 8080
spring:
  datasource:
  url: jdbc:mysql://localhost:3306/mydb
  username: root
  password: root

配置文件的加载机制

Spring Boot配置文件的加载顺序如下：

命令行参数：命令行中指定的参数优先级最高。
环境变量：Spring Boot会自动读取环境变量。
外部配置文件：可以从/config目录或当前工作目录加载配置文件。
默认配置：内置的默认配置。

常用配置项介绍

Spring MVC配置项：
- spring.mvc.view.prefix：视图解析器前缀。
- spring.mvc.view.suffix：视图解析器后缀。
- spring.mvc.servlet.path：配置Servlet路径。
数据源配置项：
- spring.datasource.url：数据源URL。
- spring.datasource.username：数据源用户名。
- spring.datasource.password：数据源密码。
- spring.datasource.driver-class-name：数据源驱动类名。
- spring.datasource.hikaricp.connection-timeout：连接超时时间。
日志配置项：
- logging.file：日志文件路径。
- logging.level.root：根日志级别。
- logging.level.com.example：指定包的日志级别。
服务器配置项：
- server.port：服务器端口。
- server.address：服务器地址。
- server.tomcat.uri-encoding：Tomcat URI编码。
数据源连接池配置项：
- spring.datasource.hikaricp.minimum-idle：最小空闲连接数。
- spring.datasource.hikaricp.maximum-pool-size：最大连接数。
- spring.datasource.hikaricp.connection-timeout：连接超时时间。

示例代码：

server:
  port: 8080

spring:
  datasource:
  url: jdbc:mysql://localhost:3306/mydb
  username: root
  password: root
  driver-class-name: com.mysql.cj.jdbc.Driver
  hikaricp:
    minimum-idle: 10
    maximum-pool-size: 20
    connection-timeout: 30000

logging:
  file: ./logs/app.log
  level:
    root: info
    com.example: debug

Spring Boot项目部署

打包项目

打包为Jar文件

使用Maven命令打包：

mvn clean package

打包后会在target目录生成*.jar文件。

打包为War文件

如果需要打包为War文件，可以在pom.xml中添加spring-boot-maven-plugin插件配置。

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

运行Maven打包命令：

mvn clean package

打包后会在target目录生成*.war文件。

部署到Tomcat服务器

手动部署

将生成的War文件复制到Tomcat的webapps目录下。
启动Tomcat服务器，访问应用。

使用Docker部署

编写Dockerfile：

FROM openjdk:8-jdk-alpine
COPY target/*.war /app/app.war
EXPOSE 8080
ENTRYPOINT ["java", "-jar", "/app/app.war"]

构建并运行Docker镜像：

docker build -t my-spring-boot-app .
docker run -p 8080:8080 my-spring-boot-app

部署到云平台

使用阿里云

登录阿里云控制台。
创建ECS服务器。
在ECS服务器上安装Java环境和Tomcat。
将打包好的War文件上传到ECS服务器。
启动Tomcat服务器。

示例代码：

# 安装Java
sudo yum install -y java-1.8.0-openjdk

# 安装Tomcat
wget https://downloads.apache.org/tomcat/tomcat-9/v9.0.62/bin/apache-tomcat-9.0.62.tar.gz
tar -xvf apache-tomcat-9.0.62.tar.gz
cd apache-tomcat-9.0.62
./bin/startup.sh

使用腾讯云

登录腾讯云控制台。
创建CVM服务器。
在CVM服务器上安装Java环境和Tomcat。
将打包好的War文件上传到CVM服务器。
启动Tomcat服务器。

示例代码：

# 安装Java
sudo yum install -y java-1.8.0-openjdk

# 安装Tomcat
wget https://downloads.apache.org/tomcat/tomcat-9/v9.0.62/bin/apache-tomcat-9.0.62.tar.gz
tar -xvf apache-tomcat-9.0.62.tar.gz
cd apache-tomcat-9.0.62
./bin/startup.sh

使用华为云

登录华为云控制台。
创建ECS服务器。
在ECS服务器上安装Java环境和Tomcat。
将打包好的War文件上传到ECS服务器。
启动Tomcat服务器。

示例代码：

# 安装Java
sudo yum install -y java-1.8.0-openjdk

# 安装Tomcat
wget https://downloads.apache.org/tomcat/tomcat-9/v9.0.62/bin/apache-tomcat-9.0.62.tar.gz
tar -xvf apache-tomcat-9.0.62.tar.gz
cd apache-tomcat-9.0.62
./bin/startup.sh

使用百度云

登录百度云控制台。
创建ECS服务器。
在ECS服务器上安装Java环境和Tomcat。
将打包好的War文件上传到ECS服务器。
启动Tomcat服务器。

示例代码：

# 安装Java
sudo yum install -y java-1.8.0-openjdk

# 安装Tomcat
wget https://downloads.apache.org/tomcat/tomcat-9/v9.0.62/bin/apache-tomcat-9.0.62.tar.gz
tar -xvf apache-tomcat-9.0.62.tar.gz
cd apache-tomcat-9.0.62
./bin/startup.sh

使用谷歌云

登录谷歌云控制台。
创建Compute Engine实例。
在Compute Engine实例上安装Java环境和Tomcat。
将打包好的War文件上传到Compute Engine实例。
启动Tomcat服务器。

示例代码：

# 安装Java
sudo apt-get update
sudo apt-get install -y openjdk-8-jdk

# 安装Tomcat
wget https://downloads.apache.org/tomcat/tomcat-9/v9.0.62/bin/apache-tomcat-9.0.62.tar.gz
tar -xvf apache-tomcat-9.0.62.tar.gz
cd apache-tomcat-9.0.62
./bin/startup.sh

以上是Spring Boot项目实战的详细介绍，涵盖从入门到简单应用的各个方面。希望这些内容能帮助你更好地理解和使用Spring Boot。