SpringBoot框架入门：轻松搭建第一个SpringBoot应用

本文介绍了SpringBoot框架入门的相关知识，包括SpringBoot的基本概念、特点与优势、应用场景以及环境搭建等内容，帮助开发者快速上手SpringBoot框架。文章详细讲解了从安装Java环境到创建SpringBoot项目，再到运行第一个SpringBoot应用的全过程。

SpringBoot简介

什么是SpringBoot

Spring Boot 是由Pivotal团队提供的全新框架，旨在简化新Spring应用的初始搭建以及开发过程。它通过提供一系列默认配置来简化开发人员的工作，使得开发人员能够专注于业务逻辑的实现，而不是配置。此外，Spring Boot 还提供了大量的自动配置功能，帮助开发人员快速搭建项目。

Spring Boot 自带一个非常丰富的默认配置，可以轻松地创建独立的、基于生产级别的Spring应用。它允许开发者创建独立的 Spring 应用，无需提供额外的配置，就可以运行在任何Java环境中，如Tomcat、Jetty或Undertow。

SpringBoot的特点与优势

1. 自动配置

Spring Boot 能够根据在类路径中的库进行自动配置。例如，添加了 Spring Web 依赖，Spring Boot 将自动配置一个 Tomcat 并配置好 Spring MVC。

2. 嵌入式Servlet容器

Spring Boot 可以自动配置并嵌入一个 Servlet 容器，如 Tomcat、Jetty 或者 Undertow。这样可以省去配置这些容器的麻烦，直接通过 Spring Boot 启动应用，就可以对外提供服务。

3. 特性独立

Spring Boot 的特性是独立的，这意味着你可以选择只使用某个特性，而不必使用其他特性。例如，你可以在没有使用 Spring Data 或 Spring Security 的情况下使用 Spring Boot。

4. 无配置

Spring Boot 可以自定义配置，但是默认情况下几乎不需要配置任何东西。你只需要编写代码，剩下的由 Spring Boot 来处理。

5. 插件支持

Spring Boot 提供了 Maven 和 Gradle 插件，可以简化应用的打包和部署过程。使用这些插件，可以轻松地创建可执行的 jar 或者 war 文件。

SpringBoot的应用场景

Spring Boot 大量应用于以下场景：

• 微服务架构：Spring Boot 与 Spring Cloud 结合可以实现服务治理、配置中心、服务注册与发现等功能，从而支持微服务架构。
• Web开发：通过 Spring Boot 可以快速搭建一个 Web 应用，实现 RESTful API、表单处理等功能。
• 数据访问：Spring Boot 提供了对多种数据访问技术的支持，如 Spring Data JPA、MyBatis 等，可以轻松地实现数据访问层的开发。
• 批处理：Spring Boot 可以用于批处理应用，例如定时任务、日志处理等。
• 测试：Spring Boot 提供了丰富的测试支持，可以方便地进行单元测试、集成测试等。
• 多环境支持：Spring Boot 支持多环境配置，可以根据不同的环境（如开发环境、测试环境、生产环境）配置不同的参数。

环境搭建

开发工具准备

Spring Boot 的开发工具主要包括以下几种：

• IDE：如 IntelliJ IDEA 或 Eclipse。
• 构建工具：如 Maven 或 Gradle。
• 版本控制工具：如 Git 或 SVN。
• 调试工具：如 JDB 或 IntelliJ IDEA 内置的调试工具。

在本教程中，我们将使用 IntelliJ IDEA 作为开发工具，并使用 Maven 作为构建工具。以下是 IntelliJ IDEA 的配置步骤：

1. 安装 IntelliJ IDEA：

   • 下载 IntelliJ IDEA 并安装。
   • 安装完成后，启动 IntelliJ IDEA。
   • 打开 IntelliJ IDEA，进入 File -> Settings（或使用快捷键 Ctrl + Alt + S）。
   • 在设置窗口中，找到 Appearance & Behavior -> System Settings -> Sdks，点击 + 号添加 Java SDK，选择已安装的 JDK 路径。
2. 安装 Maven：
   • 在 IntelliJ IDEA 中，进入 File -> Settings。
   • 选择 Build, Execution, Deployment -> Build Tools -> Maven，在 Maven Home Path 中选择或指定 Maven 安装路径。
   • 确认设置后，点击 Apply 和 OK。

安装Java环境

为了使用 Spring Boot，你首先需要安装 Java 环境。以下是安装步骤：

1. 下载 Java 安装包：从 Oracle 官方网站下载 Java SE Development Kit (JDK)，版本建议使用 Java 11 或更高版本。
2. 安装 JDK：
   • 在 Windows 上，运行下载的安装包，按照向导完成安装。
   • 在 macOS 上，使用 Homebrew 进行安装：brew install --cask adoptopenjdk
   • 在 Linux 上，可以使用包管理器进行安装，如 sudo apt-get install openjdk-11-jdk
3. 配置环境变量：确保 JDK 的 bin 目录已经添加到系统的环境变量 PATH 中。
4. 验证安装：运行 java -version，若能正常显示 Java 的版本信息，说明安装成功。

创建SpringBoot项目

1. 安装并配置 IntelliJ IDEA。
2. 打开 IntelliJ IDEA，点击 File -> New -> Project。
3. 在弹出的窗口中选择 Spring Initializr，点击 Next。
4. 填写 Group 和 Artifact 信息。Group 一般为项目的包名，Artifact 为项目的名称。例如：
   • Group: com.example
   • Artifact: demo
5. 选择 Java 版本，建议选择 11 或更高版本。
6. 选择项目依赖，这里可以选择 Web 依赖，表示将创建一个 Web 应用。当然你也可以选择其他依赖，如 Data JPA、Security 等。
7. 点击 Next，然后点击 Finish，等待项目创建完成。

项目创建完成后，IntelliJ IDEA 会自动导入 Maven 依赖并完成项目初始化。

第一个SpringBoot应用

创建Hello World项目

1. 在项目中创建一个新的 Java 类，命名为 HelloController。
2. 在 HelloController 类中添加一个简单的 Controller 方法。示例代码如下：

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

运行SpringBoot应用

1. 在 src/main/java 目录下找到 com.example.demo 包下的 DemoApplication 类，这是 Spring Boot 项目的启动类。
2. 在 DemoApplication 类中添加 main 方法，用于启动 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);
    }
}

1. 运行 DemoApplication 类中的 main 方法。你可以通过 IntelliJ IDEA 的运行按钮来启动应用。

访问应用测试结果

启动应用后，打开浏览器，访问 http://localhost:8080/hello，你应该能看到如下结果：

Hello, Spring Boot!

这表示你的 Spring Boot 应用已经成功运行，并返回了预期的结果。

控制器与视图

创建控制器类

在 Spring Boot 中，控制器类通常使用 @RestController 注解来定义。这个注解表明该类是一个 REST 风格的控制器，它会将方法的返回值直接作为 HTTP 响应体返回。

1. 在 com.example.demo 包中创建一个新的 Java 类，命名为 UserController。
2. 在 UserController 类中添加控制器方法。示例代码如下：

package com.example.demo;

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

@RestController
public class UserController {

    @GetMapping("/user")
    public String getUser() {
        return "User Information";
    }
}

创建视图页面

Spring Boot 支持使用 Thymeleaf、Freemarker 或者 JSP 等模板引擎来渲染视图。本例中我们使用 Thymeleaf。

1. 添加 Thymeleaf 依赖到 pom.xml：

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

1. 在 src/main/resources/templates 目录下创建一个新的 HTML 文件，命名为 user.html。示例代码如下：

<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<head>
    <title>User Information</title>
</head>
<body>
    <h1>User Information</h1>
</body>
</html>

实现页面跳转

在控制器中添加一个新的方法，用于跳转到 user.html 页面。示例代码如下：

@GetMapping("/user/view")
public String getUserView() {
    return "user"; // 返回模板名称
}

启动应用后，访问 http://localhost:8080/user/view，你应该能看到 user.html 页面的内容。

数据访问

配置数据库连接

为了配置数据库连接，你需要在 application.properties 文件中添加数据库连接参数。application.properties 文件位于 src/main/resources 目录下。

示例代码如下：

spring.datasource.url=jdbc:mysql://localhost:3306/mydatabase
spring.datasource.username=root
spring.datasource.password=root
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

使用SpringData JPA

Spring Data JPA 是 Spring Data 项目的一部分，用于简化 JPA 的使用。Spring Boot 自动配置了 Spring Data JPA，因此你可以直接使用它而无需做额外配置。

1. 添加 JPA 依赖到 pom.xml：

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

1. 创建一个新的 Java 类 User，表示数据库中的用户表。该类需要使用 @Entity 注解，并包含相应的字段和 getter/setter 方法。示例代码如下：

package com.example.demo.model;

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;

    public Long getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

1. 创建一个新的 Java 类 UserRepository，继承 JpaRepository 接口，并定义相应的 CRUD 方法。示例代码如下：

package com.example.demo.repository;

import com.example.demo.model.User;
import org.springframework.data.jpa.repository.JpaRepository;

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

1. 创建一个新的 Java 类 UserService，用于处理业务逻辑。示例代码如下：

package com.example.demo.service;

import com.example.demo.model.User;
import com.example.demo.repository.UserRepository;
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> findAllUsers() {
        return userRepository.findAll();
    }

    public User findUserById(Long id) {
        return userRepository.findById(id).orElse(null);
    }

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

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

1. 创建一个新的 Java 类 UserController，用于处理 HTTP 请求。示例代码如下：

package com.example.demo.controller;

import com.example.demo.model.User;
import com.example.demo.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@RestController
@RequestMapping("/user")
public class UserController {

    @Autowired
    private UserService userService;

    @GetMapping("/list")
    public List<User> getAllUsers() {
        return userService.findAllUsers();
    }

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

    @PostMapping("/add")
    public User addUser(@RequestBody User user) {
        return userService.saveUser(user);
    }

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

启动应用后，你可以通过访问 http://localhost:8080/user/list 来查看所有用户信息，通过 http://localhost:8080/user/1 来查看特定用户的详细信息等。

配置文件与属性注入

使用application.properties文件

配置文件 application.properties 用于存放 Spring Boot 的配置参数。该文件位于 src/main/resources 目录下。

示例配置

# 数据源配置
spring.datasource.url=jdbc:mysql://localhost:3306/mydatabase
spring.datasource.username=root
spring.datasource.password=root
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

# JPA 配置
spring.jpa.hibernate.ddl-auto=update
spring.jpa.show-sql=true
spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.MySQL5Dialect

# 应用配置
server.port=8080

配置环境

Spring Boot 支持多环境配置。假设我们有一个 application-dev.properties 文件用于开发环境，一个 application-prod.properties 文件用于生产环境。

首先，创建 application-dev.properties 和 application-prod.properties 文件：

# application-dev.properties
spring.datasource.url=jdbc:mysql://localhost:3306/devdb
spring.datasource.username=root
spring.datasource.password=root

# application-prod.properties
spring.datasource.url=jdbc:mysql://localhost:3306/proddb
spring.datasource.username=root
spring.datasource.password=root

在运行应用时，可以通过命令行参数指定环境：

java -jar target/demo-0.0.1-SNAPSHOT.jar --spring.profiles.active=dev

属性注入与配置类

Spring Boot 支持通过 @Value 注解或者 @ConfigurationProperties 注解来注入配置文件中的属性值。

1. 使用 @Value 注解注入属性值：

package com.example.demo;

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

@Component
public class AppConfig {

    @Value("${spring.datasource.url}")
    private String dbUrl;

    public String getDbUrl() {
        return dbUrl;
    }

    public void setDbUrl(String dbUrl) {
        this.dbUrl = dbUrl;
    }
}

1. 使用 @ConfigurationProperties 注解注入属性值：

package com.example.demo;

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

@Component
@ConfigurationProperties(prefix = "spring.datasource")
public class DataSourceConfig {

    private String url;
    private String username;
    private String password;

    public String getUrl() {
        return url;
    }

    public void setUrl(String url) {
        this.url = url;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }
}

动态配置属性

Spring Boot 支持通过 @Configuration 类动态配置属性。

1. 创建一个新的 Java 类 AppConfig，用于动态配置属性：

package com.example.demo;

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Configuration;

@Configuration
@ConfigurationProperties(prefix = "app")
public class AppConfig {

    private String name;
    private String version;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getVersion() {
        return version;
    }

    public void setVersion(String version) {
        this.version = version;
    }
}

1. 在 application.properties 文件中添加相应的属性：

app.name=MyApp
app.version=1.0.0

1. 在 DemoApplication 类中注入并使用 AppConfig：

package com.example.demo;

import org.springframework.boot.ApplicationArguments;
import org.springframework.boot.ApplicationRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;

@SpringBootApplication
public class DemoApplication {

    @Bean
    public ApplicationRunner applicationRunner(AppConfig appConfig) {
        return args -> {
            System.out.println("App Name: " + appConfig.getName());
            System.out.println("App Version: " + appConfig.getVersion());
        };
    }

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

启动应用后，控制台将输出 App Name 和 App Version 的值。