Spring Boot框架入门介绍了一个简化新Spring应用初始搭建及开发过程的框架，它采用约定大于配置的思想，帮助开发者快速创建独立的生产级Spring应用。文章详细讲解了Spring Boot的核心特性、优势、开发环境搭建、自动配置机制、RESTful API开发以及项目打包部署等内容。通过本文，读者可以快速掌握Spring Boot框架入门知识，提高开发效率。

Spring Boot是什么

Spring Boot 是一个用于简化新Spring应用初始搭建及开发过程的框架。它采用约定大于配置的思想，使得开发者可以直接创建独立的、生产级的Spring应用。

Spring Boot的核心特性包括：

• 内置的web服务器（如Tomcat或Jetty）
• 内置的配置
• 自动配置
• 嵌入式运行（无需外部容器）
• 无代码生成，也无需XML配置
• 热部署

Spring Boot的优势

1. 快速启动：Spring Boot可以帮助开发者快速搭建项目，减少需要配置的文件，简化项目结构，从而加快开发进度。
2. 无需配置文件：大多数情况下，Spring Boot可以自动配置应用程序，从而减少或甚至消除XML文件的需要。
3. 开箱即用：在大多数情况下，Spring Boot提供了一系列开箱即用的特性，如web服务器、数据库连接、安全等。
4. 嵌入式运行：Spring Boot应用可以独立运行，不需要外部容器，如Tomcat或Jetty。
5. 快速构建：通过Spring Initializr快速创建Spring Boot项目。
6. 热部署：使用IDE（如IntelliJ IDEA或Spring Boot Devtools）可以实现热部署，减少开发和测试时间。

开发环境搭建

为了搭建Spring Boot开发环境，你需要安装以下工具和库：

1. Java JDK：Spring Boot应用运行在Java虚拟机上，需要Java JDK环境。最低要求是Java 8。
2. IDE：推荐使用IntelliJ IDEA、Eclipse或Spring Tool Suite等。
3. Spring Boot CLI：Spring Boot提供了一个命令行工具，可以用来创建、运行和测试Spring Boot应用。但通常使用IDE会更加方便。
4. Maven或Gradle：用于构建Spring Boot应用。
5. Spring Initializr：用于快速创建Spring Boot项目。

接下来，我们通过Spring Initializr快速创建一个Spring Boot项目。

创建项目

访问Spring Initializr网站：https://start.spring.io/，选择项目的基本配置：

• Project：Maven Project
• Language：Java
• Spring Boot：选择最新的版本
• Packaging：Jar
• Java：选择Java 8及以上版本
• Dependencies：添加Spring Web依赖

点击Generate按钮，下载项目压缩包，解压后导入到IDE中。

配置IDE

导入项目后，确保IDE正确配置了Spring Boot支持。例如，在IntelliJ IDEA中，可以通过以下步骤进行配置：

1. 打开File -> Settings -> Plugins，安装Spring插件。
2. 打开File -> Settings -> Build, Execution, Deployment -> Compiler，确保Add output folder to classpath选项被勾选。

创建Spring Boot项目

创建一个名为HelloSpringBoot的Spring Boot项目。按照前面的步骤，使用Spring Initializr创建项目，然后导入到IDE中。

创建项目结构

创建一个简单的项目结构，包含以下文件和目录：

src
└───main
    ├───java
    │   └───com
    │       └───example
    │           └───HelloSpringBoot
    │               ├───HelloSpringBootApplication.java
    │               └───controller
    │                   └───HelloController.java
    └───resources
        ├───application.properties
        └───static
            └───index.html

编写第一个Hello World程序

在HelloSpringBootApplication.java中创建Spring Boot应用的入口类：

package com.example.HelloSpringBoot;

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

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

在controller包下创建HelloController.java，该控制器会提供一个简单的HTTP GET请求处理程序，返回“Hello World”响应：

package com.example.HelloSpringBoot.controller;

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

@RestController
public class HelloController {
    @GetMapping("/")
    public String home() {
        return "Hello World";
    }
}

运行并测试项目

运行HelloSpringBootApplication.java中的main方法来启动应用。启动后，Spring Boot会创建一个默认的Tomcat服务器，并在端口8080上监听HTTP请求。

使用浏览器或curl命令访问http://localhost:8080/，可以看到返回“Hello World”。

application.properties与application.yml

Spring Boot使用两个配置文件：application.properties和application.yml。它们用于定义应用的配置属性。

application.properties格式简单，使用键值对的形式进行配置，例如：

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

application.yml使用了更简洁的格式：

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

常见配置项解析

服务器配置

server.port=8080
server.context-path=/myapp
server.tomcat.access-log-enabled=true

数据源配置

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

日志配置

logging.level.root=INFO
logging.level.com.example=DEBUG

启动日志

spring.boot.admin.notify.log.enabled=true
spring.boot.admin.notify.log.level=INFO

静态资源配置

spring.resources.static-locations=classpath:/static/,classpath:/public/

数据源配置（使用JPA和Hibernate）

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

资源自动配置

Spring Boot会根据类路径中的类和jar包自动配置应用程序。例如，如果应用程序中包含DataSourceAutoConfiguration类，Spring Boot会自动配置数据源。

数据源自动配置示例

package org.springframework.boot.autoconfigure.jdbc;

import org.springframework.boot.autoconfigure.AutoConfigureBefore;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingClass;
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
@AutoConfigureBefore(DataSourceAutoConfiguration.class)
@EnableConfigurationProperties(DataSourceProperties.class)
@ConditionalOnClass({DataSource.class, Connection.class})
public class CustomDataSourceAutoConfiguration {

    @Bean
    @ConditionalOnMissingClass("org.apache.tomcat.jdbc.pool.DataSource")
    @ConditionalOnMissingBean(DataSource.class)
    @ConfigurationProperties(prefix = "spring.datasource.hikari")
    public DataSource dataSource() {
        return new HikariDataSource();
    }
}

启动器自动配置

启动器（Starter）是Spring Boot的核心特性之一。启动器提供了一种快速配置Spring Boot应用的方法，自动导入所需的依赖关系和配置。

启动器使用示例

创建一个新项目，并在pom.xml中添加spring-boot-starter-web依赖以启用web功能：

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

创建REST服务

创建一个简单的REST服务，例如用户服务。首先定义一个简单的用户实体类：

package com.example.HelloSpringBoot.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;
    private String email;

    // getters and setters
}

然后定义一个控制器来处理HTTP请求：

package com.example.HelloSpringBoot.controller;

import com.example.HelloSpringBoot.model.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

import java.util.List;

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

    @Autowired
    private UserRepository userRepository;

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

    @PostMapping
    public User createUser(@RequestBody User user) {
        return userRepository.save(user);
    }

    @GetMapping("/{id}")
    public User getUserById(@PathVariable Long id) {
        return userRepository.findById(id).orElse(null);
    }

    @PutMapping("/{id}")
    public User updateUser(@PathVariable Long id, @RequestBody User user) {
        User existingUser = userRepository.findById(id).orElse(null);
        if (existingUser != null) {
            existingUser.setName(user.getName());
            existingUser.setEmail(user.getEmail());
            return userRepository.save(existingUser);
        }
        return null;
    }

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

使用Spring Data JPA进行数据操作

Spring Data JPA是一个简化数据访问的框架，它通过简化数据访问层的开发，提供了一套标准的方式来访问数据库。

创建JPA仓库接口

定义一个JPA仓库接口，继承JpaRepository接口：

package com.example.HelloSpringBoot.repository;

import com.example.HelloSpringBoot.model.User;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

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

配置JPA

在application.properties中配置数据源和JPA：

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

运行并测试REST服务

运行Spring Boot应用，访问http://localhost:8080/api/users来查看所有用户。发送POST请求以创建新用户，例如：

{
    "name": "Alice",
    "email": "alice@example.com"
}

打包项目

使用Maven或Gradle打包Spring Boot应用。运行以下命令：

mvn clean package

或

./gradlew bootJar

这将生成一个可执行的JAR文件。

部署到服务器

使用Tomcat服务器

将生成的JAR文件拷贝到远程服务器上，解压并运行：

java -jar hello-springboot.jar

使用Docker

创建Dockerfile：

FROM openjdk:8-jdk-alpine
VOLUME /tmp
COPY target/hello-springboot.jar /app/hello-springboot.jar
EXPOSE 8080
ENTRYPOINT ["java","-jar","/app/hello-springboot.jar"]

运行以下命令构建并运行Docker镜像：

docker build -t my-springboot-app .
docker run -p 8080:8080 my-springboot-app

使用脚本部署到服务器

创建一个简单的脚本（例如deploy.sh）来部署应用到远程服务器：

#!/bin/bash
# 部署到远程服务器
scp target/hello-springboot.jar user@remote-server:/path/to/deploy
ssh user@remote-server "cd /path/to/deploy; java -jar hello-springboot.jar"

确保在远程服务器上已经安装了Java环境，并确保脚本具有执行权限：

chmod +x deploy.sh

然后运行脚本：

./deploy.sh

Spring Boot通过提供快速创建、自动配置和简化配置的能力，使得Java开发者能够快速搭建生产级的Spring应用。本文介绍了Spring Boot的基本概念、环境搭建、项目创建、配置文件、自动配置机制、RESTful API开发以及项目打包部署。希望这些知识能够帮助你快速入门并掌握Spring Boot框架，进一步提高你的开发效率。