Springboot项目开发入门教程-原创手记-慕课网

概述

本文详细介绍了Spring Boot项目开发入门的相关内容，包括Spring Boot的基本概念、开发环境搭建、项目创建、核心配置与功能、常见开发实践以及项目打包与部署等。通过本文的学习，读者可以快速掌握Spring Boot的基本使用方法，从而开发出简单的Spring Boot应用程序。

Spring Boot 简介

Spring Boot 是什么

Spring Boot 是一个由 Pivotal 提供的基于 Apache 2.0 适用协议的开源框架。它简化了 Spring 应用程序的开发流程，使开发者能够快速搭建独立的 Spring 应用程序。Spring Boot 的目标是减少 Spring 应用程序的配置和复杂性，从而加快开发和部署速度。

Spring Boot 的特点与优势

无需配置 XML：Spring Boot 鼓励使用 Java 注解进行配置，而不是传统的 XML 配置文件。这样可以简化配置并减少样板代码。
自动配置：Spring Boot 通过自动配置功能使 Spring 应用程序的配置变得简单。它可以根据类路径中的 jar 包和类自动配置 Spring 应用程序。
起步依赖：Spring Boot 提供了一种名为“起步依赖”的机制来简化依赖管理。这些起步依赖帮助开发者引入所需的 jar 包，而无需自己手动查找和配置。
内嵌容器支持：Spring Boot 可以内嵌一个 Tomcat、Jetty 或 Undertow 等 Web 服务器。这意味着 Spring Boot 应用程序可以直接作为一个可执行的 jar 包运行。
命令行工具：Spring Boot 提供了一个命令行工具，可以方便地运行、打包和管理应用程序。
Actuator：Spring Boot Actuator 提供了一个端点（endpoint）来监控应用程序的状态，包括健康检查、指标和详细的配置信息。
热部署：Spring Boot 支持热部署，这意味着在开发过程中可以无需重启应用程序即可修改代码。

Spring Boot 的应用场景

微服务开发：Spring Boot 与 Spring Cloud 结合，可以方便地开发微服务。Spring Cloud 提供了服务发现、配置中心、断路器、负载均衡等功能。
Web 应用程序：Spring Boot 可以用于开发基于 REST 的 Web 服务或 Web 应用程序，提供了丰富的 Web 支持。
批处理应用：Spring Boot 可以用于开发批处理应用，处理大量数据。
数据集成：Spring Boot 与 Spring Data 集成，可以方便地访问和操作数据库。
命令行工具：Spring Boot 可以开发命令行工具，处理各种任务和脚本。
单元测试：Spring Boot 提供了丰富的单元测试支持，使用 Spring Boot 的测试支持，可以轻松地编写和运行单元测试。

开发环境搭建

JDK 环境配置

安装 JDK 之前，请确保系统中不包含旧版的 JDK 版本。

下载并安装 JDK 8 或更高版本。访问 Oracle 官方网站下载 JDK：https://www.oracle.com/java/technologies/javase-downloads.html
安装完成后，配置环境变量。在系统环境变量中添加 JAVA_HOME 和 PATH。

set JAVA_HOME=C:\Program Files\Java\jdk1.8.0_281
set PATH=%JAVA_HOME%\bin;%PATH%

验证安装是否成功：

java -version

如果安装成功，将显示 JDK 版本信息。

IDE 安装与配置

IntelliJ IDEA

下载并安装 IntelliJ IDEA：https://www.jetbrains.com/idea/
配置 IntelliJ IDEA 以支持 Maven 或 Gradle。

配置 Maven：

打开 IntelliJ IDEA，选择 File > Settings（或按 Ctrl + Alt + S）。
在 Settings 窗口中，选择 Plugins，搜索并安装 Maven 插件。
安装完成后，重启 IntelliJ IDEA。
配置 Maven 的本地仓库路径，在 Settings > Maven 中设置。

配置 Gradle：

打开 IntelliJ IDEA，选择 File > Settings（或按 Ctrl + Alt + S）。
在 Settings 窗口中，选择 Plugins，搜索并安装 Gradle 插件。
安装完成后，重启 IntelliJ IDEA。
配置 Gradle 的本地仓库路径，在 Settings > Gradle 中设置。

Eclipse

下载并安装 Eclipse：https://www.eclipse.org/downloads/
配置 Eclipse 以支持 Maven 或 Gradle。

配置 Maven：

打开 Eclipse，选择 Help > Eclipse Marketplace。
搜索并安装 Maven Integration for Eclipse 插件。
安装完成后，重启 Eclipse。
配置 Maven 的本地仓库路径，在 Window > Preferences > Maven 中设置。

配置 Gradle：

打开 Eclipse，选择 Help > Eclipse Marketplace。
搜索并安装 Gradle Integration 插件。
安装完成后，重启 Eclipse。
配置 Gradle 的本地仓库路径，在 Window > Preferences > Gradle 中设置。

Maven 或 Gradle 依赖管理工具配置

Maven

创建一个 Maven 项目，或在现有的项目中添加 Maven 依赖。
编辑 pom.xml 文件，添加所需的依赖和插件。

示例 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>1.0-SNAPSHOT</version>
    <packaging>jar</packaging>
    <name>demo</name>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
            <version>2.4.0</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <version>2.4.0</version>
            <scope>test</scope>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <version>2.4.0</version>
            </plugin>
        </plugins>
    </build>
</project>

Gradle

创建一个 Gradle 项目，或在现有的项目中添加 Gradle 依赖。
编辑 build.gradle 文件，添加所需的依赖和插件。

示例 build.gradle 文件：

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

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

test {
    useJUnitPlatform()
}

创建第一个 Spring Boot 项目

使用 Spring Initializr 创建项目

访问 Spring Initializr 网站：https://start.spring.io/
选择项目的基本信息，如语言、版本、依赖等。

示例配置：

Group (org.springframework.boot)
Artifact (demo)
Name (demo)
Package Name (com.example.demo)
Dependencies (Spring Web)

生成项目文件，下载并解压。
在解压后的项目目录中，使用 Maven 或 Gradle 构建项目。

使用 Maven：

mvn clean install

使用 Gradle：

./gradlew build

项目目录结构解析

Spring Boot 项目的典型目录结构如下：

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

src/main/java：存放 Java 源代码文件。
src/main/resources：存放静态资源文件，如配置文件、模板文件、静态资源文件等。
src/test/java：存放测试代码文件。

编写第一个 Hello World 应用

在 src/main/java/com/example/demo 目录下创建 DemoApplication.java 文件：

package com.example.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

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

    @RequestMapping("/")
    public String home() {
        return "Hello World!";
    }
}

在 src/main/resources 目录下创建 application.properties 文件：

server.port=8080

启动项目：

mvn spring-boot:run

或使用 Gradle：

./gradlew bootRun

访问 http://localhost:8080，可以看到输出 "Hello World!"。

核心配置与功能介绍

application.properties 与 application.yml 配置文件

Spring Boot 使用 application.properties 或 application.yml 文件来配置各种属性。这些文件通常位于 src/main/resources 目录下。

application.properties 示例

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

application.yml 示例

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

动态属性注入

通过 @Value 注解可以将配置文件中的属性注入到 Java 类中。

package com.example.demo;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

@Component
public class ConfigProperties {
    @Value("${server.port}")
    private String serverPort;

    public String getServerPort() {
        return serverPort;
    }
}

自动配置与 @EnableAutoConfiguration 注解

Spring Boot 通过自动配置功能简化了 Spring 应用程序的配置。默认情况下，Spring Boot 会根据类路径中的 jar 包和类自动配置应用程序。

自动配置通过 @EnableAutoConfiguration 注解启用。在 DemoApplication.java 文件中，@SpringBootApplication 注解包含了 @EnableAutoConfiguration。

如果需要关闭自动配置，可以在 @SpringBootApplication 注解上加上 exclude 参数。

@SpringBootApplication(exclude = {DataSourceAutoConfiguration.class})
public class DemoApplication {
    // ...
}

常用 starter 依赖介绍

Spring Boot 提供了许多预定义的依赖包，称为“starter”。这些 starter 依赖简化了依赖管理，可以帮助开发者快速配置相关功能。

常用 starter 依赖

spring-boot-starter-web：包含 Spring MVC 相关的功能。
spring-boot-starter-data-jpa：包含 JPA 和 Hibernate 相关的功能。
spring-boot-starter-data-redis：包含 Redis 相关的功能。
spring-boot-starter-security：包含 Spring Security 相关的功能。
spring-boot-starter-actuator：包含 Actuator 相关的功能。

常见开发实践

RESTful API 开发

Spring Boot 通过 @RestController 和 @RequestMapping 注解可以快速开发 RESTful API。

示例代码

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

访问 http://localhost:8080/hello，可以看到输出 "Hello, World!"。

数据库集成（JPA/Hibernate）

Spring Boot 通过 spring-boot-starter-data-jpa 依赖简化了数据库操作。

示例代码

在 application.properties 或 application.yml 中添加数据库配置：

application.properties

spring.datasource.url=jdbc:mysql://localhost:3306/mydb
spring.datasource.username=root
spring.datasource.password=root
spring.jpa.hibernate.ddl-auto=update

application.yml

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/mydb
    username: root
    password: root
jpa:
  hibernate:
    ddl-auto: update

在 src/main/java/com/example/demo/entity 目录下创建实体类 Book.java：

package com.example.demo.entity;

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

@Entity
public class Book {

    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private Long id;
    private String title;
    private String author;

    public Book() {}

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

    // Getter and Setter
}

在 src/main/java/com/example/demo/repository 目录下创建仓库接口 BookRepository.java：

package com.example.demo.repository;

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

public interface BookRepository extends JpaRepository<Book, Long> {
}

在 src/main/java/com/example/demo/service 目录下创建服务类 BookService.java：

package com.example.demo.service;

import com.example.demo.entity.Book;
import com.example.demo.repository.BookRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class BookService {

    @Autowired
    private BookRepository bookRepository;

    public Book saveBook(Book book) {
        return bookRepository.save(book);
    }
}

在 src/main/java/com/example/demo/controller 目录下创建控制器 BookController.java：

package com.example.demo.controller;

import com.example.demo.entity.Book;
import com.example.demo.service.BookService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

@RestController
public class BookController {

    @Autowired
    private BookService bookService;

    @PostMapping("/books")
    public Book createBook(@RequestBody Book book) {
        return bookService.saveBook(book);
    }

    @GetMapping("/books/{id}")
    public Book getBook(@PathVariable Long id) {
        return bookService.getBook(id);
    }
}

访问 http://localhost:8080/books，可以创建和查询书籍。

静态资源文件配置

Spring Boot 默认支持 static、public、resources、classpath:/resources 等路径下的静态资源文件。

示例代码

在 src/main/resources/static 目录下创建 index.html 文件：

<!DOCTYPE html>
<html>
<head>
    <title>Home Page</title>
</head>
<body>
    <h1>Welcome to Spring Boot!</h1>
</body>
</html>

访问 http://localhost:8080/，可以看到 index.html 文件的内容。

日志配置与使用

Spring Boot 使用 Logback 作为默认的日志实现。可以通过 application.properties 或 application.yml 文件配置日志。

示例代码

在 application.properties 或 application.yml 中配置日志：

application.properties

logging.level.root=INFO
logging.file.name=logs/application.log

application.yml

logging:
  level:
    root: INFO
  file:
    name: logs/application.log

在应用程序中使用配置文件中的日志配置：

package com.example.demo;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.core.env.Environment;

@SpringBootApplication
public class DemoApplication {
    @Autowired
    private Environment env;

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

    @Bean
    public CommandLineRunner commandLineRunner() {
        return args -> {
            System.out.println("App started with properties: " + env.getProperty("server.port"));
        };
    }
}

项目打包与部署

Maven/Gradle 打包项目

使用 Maven 打包：

mvn clean package

使用 Gradle 打包：

./gradlew clean build

打包完成后，可以在 target 或 build/libs 目录下找到可执行的 jar 文件。

运行打包后的 jar 包

使用 Maven 打包后的 jar 文件运行：

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

使用 Gradle 打包后的 jar 文件运行：

java -jar build/libs/demo-1.0-SNAPSHOT.jar

部署到 Tomcat 或 Jetty 服务器

部署到 Tomcat 服务器

将打包后的 jar 文件复制到 Tomcat 的 webapps 目录下，启动 Tomcat 服务器即可。

部署到 Jetty 服务器

将打包后的 jar 文件复制到 Jetty 的 webapps 目录下，启动 Jetty 服务器即可。

示例代码

启动 Tomcat 服务器：

cd /path/to/apache-tomcat/webapps
cp /path/to/demo-1.0-SNAPSHOT.jar demo.war
cd /path/to/apache-tomcat/bin
./startup.sh

启动 Jetty 服务器：

cd /path/to/jetty/webapps
cp /path/to/demo-1.0-SNAPSHOT.jar demo.war
cd /path/to/jetty/start.jar
java -jar start.jar

访问 http://localhost:8080/demo，可以看到应用已成功部署。

总结

本文介绍了 Spring Boot 的基本概念、开发环境搭建、创建第一个项目、核心配置与功能介绍、常见开发实践以及项目打包与部署等内容。通过学习本文，读者可以快速掌握 Spring Boot 的基本使用方法，并能够开发简单的 Spring Boot 应用程序。