Spring Boot学习：从入门到实战指南-原创手记-慕课网

概述

本文介绍了Spring Boot学习的相关内容，从安装和环境搭建到创建第一个Spring Boot应用，涵盖了自动配置、起步依赖和配置文件解析等核心概念，并通过实战案例详细讲解了如何构建RESTful服务。此外，还介绍了如何部署和运行Spring Boot应用，包括打包、部署到云平台和使用Docker容器化应用。

Spring Boot简介

什么是Spring Boot

Spring Boot是一个基于Spring框架的快速开发框架，它简化了Spring应用的初始搭建以及开发过程。Spring Boot允许开发者通过配置文件或注解的方式快速开发出独立运行的程序，无需繁琐的配置和复杂的依赖管理。Spring Boot旨在减少开发者的配置时间，使得开发者能够更快地构建应用程序。

Spring Boot的优势

快速启动：Spring Boot能够快速启动一个Spring项目，无需配置大量的XML或Java配置。
自动配置：通过@SpringBootApplication注解，Spring Boot能够自动配置项目中的许多组件。
独立运行：Spring Boot应用可以独立运行，可以打包成一个可执行的jar文件，通过java -jar命令启动。
嵌入式服务器：Spring Boot支持嵌入式Web服务器，如Tomcat、Jetty或Undertow，使得部署和运行更加方便。
插件支持：Spring Boot支持各种插件，如Spring Data、Spring Security等，提供了丰富的功能支持。
外部化配置：Spring Boot支持外部化配置，可以通过环境变量、命令行参数或配置文件来配置应用程序。
健康检查：Spring Boot Actuator模块提供了健康检查和监控功能。

Spring Boot的安装和环境搭建

安装Java：首先确保系统中安装了Java，推荐使用Java 8或更高版本。
安装Maven或Gradle：Spring Boot项目可以使用Maven或Gradle进行构建管理。
创建项目：可以使用Spring Initializr（在线或IDE插件）来快速创建Spring Boot项目。

使用Spring Initializr创建项目

访问Spring Initializr官网：https://start.spring.io/
选择项目配置，如下图所示：
点击Generate Project按钮，下载项目压缩包。
解压项目压缩包，导入到IDE中（如IntelliJ IDEA或Eclipse）。
运行项目，可以使用mvn spring-boot:run或gradle bootRun命令启动。

创建第一个Spring Boot应用

使用Spring Initializr创建项目

创建项目时，可以选择所需的依赖。例如，可以选择Spring Web（用于构建Web应用）和Spring Data JPA（用于数据库操作）。

详细展示如何通过Spring Initializr创建项目

mvn spring-boot:run  # 使用Maven运行项目
gradle bootRun        # 使用Gradle运行项目

编写第一个Spring Boot应用程序

在项目中创建一个简单的Spring Boot应用，如下所示：

在src/main/java目录下创建一个包，例如com.example.demo。

在该包下创建一个主类DemoApplication.java，如下：

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);
   }
}

这里使用了@SpringBootApplication注解，它是一个组合注解，相当于@Configuration、@EnableAutoConfiguration和@ComponentScan三个注解的组合。

在src/main/resources目录下创建一个配置文件application.properties，如下：
```
server.port=8080
```
配置文件用于设置应用的端口号。

运行和测试应用

在IDE中运行DemoApplication类的main方法。
打开浏览器，访问http://localhost:8080，可以看到应用成功启动。

Spring Boot核心概念与组件

自动配置

Spring Boot通过自动配置来简化开发过程，自动配置基于类路径中的类和属性来猜测和设置应用的配置。例如，如果项目中引入了spring-boot-starter-web依赖，Spring Boot会自动配置一个Tomcat服务器，并自动注册相关的Spring MVC组件。

起步依赖

Spring Boot使用起步依赖来简化项目的构建。每个起步依赖都是一个包含了特定功能的所有依赖的集合。例如，spring-boot-starter-web包含了构建Web应用所需的所有依赖。

起步依赖的详细展示

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

配置文件解析

Spring Boot支持多种配置文件，包括application.properties和application.yml。配置文件可以放置在src/main/resources目录下，并且可以被环境变量和系统属性覆盖。

实战：使用Spring Boot构建RESTful服务

创建REST控制器

在项目中创建一个新的包，例如com.example.demo.controller。

在该包下创建一个控制器类DemoController.java，如下：

package com.example.demo.controller;

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

@RestController
public class DemoController {
   @GetMapping("/hello")
   public String hello() {
       return "Hello, World!";
   }
}

这里使用了@RestController注解，它是一个@Controller和@ResponseBody的组合注解，用于创建REST控制器。

重新启动应用，访问http://localhost:8080/hello，可以看到返回了Hello, World!。

使用Spring Data JPA进行数据操作

在项目中引入spring-boot-starter-data-jpa依赖。

在application.properties中配置数据库连接：

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

创建一个实体类User.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 User {
   @Id
   @GeneratedValue(strategy = GenerationType.IDENTITY)
   private Long id;
   private String name;
   private String email;

   // 省略getter和setter方法
}

创建一个仓库接口UserRepository.java：

package com.example.demo.repository;

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

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

修改DemoController.java，添加数据操作逻辑：

package com.example.demo.controller;

import com.example.demo.entity.User;
import com.example.demo.repository.UserRepository;
import org.springframework.web.bind.annotation.*;

@RestController
public class DemoController {
   private final UserRepository userRepository;

   public DemoController(UserRepository userRepository) {
       this.userRepository = userRepository;
   }

   @GetMapping("/users")
   public Iterable<User> getUsers() {
       return userRepository.findAll();
   }

   @PostMapping("/users")
   public User addUser(@RequestBody User user) {
       return userRepository.save(user);
   }

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

   @PutMapping("/users/{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("/users/{id}")
   public void deleteUser(@PathVariable Long id) {
       userRepository.deleteById(id);
   }
}

跨域访问与安全配置

配置跨域访问：

package com.example.demo;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.CorsRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

@Configuration
public class WebConfig {
   @Bean
   public WebMvcConfigurer corsConfigurer() {
       return new WebMvcConfigurer() {
           @Override
           public void addCorsMappings(CorsRegistry registry) {
               registry.addMapping("/**")
                       .allowedOrigins("*")
                       .allowedMethods("GET", "POST", "PUT", "DELETE");
           }
       };
   }
}

配置Spring Security：

package com.example.demo.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
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.config.http.SessionCreationPolicy;

@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {
   @Override
   protected void configure(HttpSecurity http) throws Exception {
       http
               .csrf().disable()
               .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)
               .and()
               .authorizeRequests()
               .antMatchers("/users").permitAll()
               .anyRequest().authenticated();
   }
}

日志管理和监控

配置日志框架（如Logback）

在src/main/resources目录下创建logback-spring.xml文件：

<configuration>
   <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
       <encoder>
           <pattern>%d{yyyy-MM-dd HH:mm:ss} - %msg%n</pattern>
       </encoder>
   </appender>

   <root level="info">
       <appender-ref ref="STDOUT" />
   </root>
</configuration>

使用Spring Boot Actuator进行健康检查和监控

在项目中添加spring-boot-starter-actuator依赖。

在application.properties中启用Actuator端点：

management.endpoints.web.exposure.include=*
management.endpoint.health.show-details=always

访问http://localhost:8080/actuator可以看到所有可用的端点。
访问http://localhost:8080/actuator/health获取应用的健康信息。

部署与运行

打包Spring Boot应用

使用Maven或Gradle打包Spring Boot应用，可以使用以下命令：

Maven：
```
mvn clean package
```
打包完成后，可以在target目录下找到可执行的jar文件。
Gradle：
```
./gradlew bootJar
```
打包完成后，可以在build/libs目录下找到可执行的jar文件。

部署到Tomcat或云平台

部署到Tomcat：将打包好的jar文件复制到Tomcat的webapps目录下，启动Tomcat即可。
部署到云平台：可以将打包好的jar文件上传到云平台，如阿里云或AWS，并配置相应的启动脚本。

使用Docker容器化Spring Boot应用

创建Dockerfile文件，如下：

FROM openjdk:11-jre-slim
COPY target/*.jar app.jar
ENTRYPOINT ["java","-jar","/app.jar"]

构建Docker镜像：
```
docker build -t my-spring-boot-app .
```

运行Docker容器：

docker run -p 8080:8080 my-spring-boot-app

通过以上步骤，可以将Spring Boot应用容器化，并部署到任何支持Docker的环境中。

总结

本文介绍了Spring Boot的基础知识，从安装和环境搭建，到创建第一个Spring Boot应用，再到核心概念和组件的介绍，以及实战案例的详细讲解。同时，还介绍了如何部署和运行Spring Boot应用，包括打包、部署到云平台和使用Docker容器化应用。希望读者通过本文能够快速入门并熟练使用Spring Boot进行开发。