Spring Boot 微服务学习入门涵盖了从快速搭建项目到微服务架构的应用,详细介绍了Spring Boot的核心功能和微服务的实现方法,帮助开发者快速掌握Spring Boot微服务开发。
Spring Boot 是由 Pivotal 团队提供的框架,用于简化新Spring应用的初始搭建及开发过程。Spring Boot使开发者以最少的配置快速构建独立运行的应用程序。它基于Spring框架增加了自动配置的支持,简化了配置过程,使得开发任务更加高效。
java -jar
命令直接运行,无需部署到应用服务器上。Starter
依赖管理,简化了依赖的引入和管理过程。创建Spring Boot项目的方法包括通过Spring Initializr在线创建、使用IDE(IntelliJ IDEA、Eclipse)创建以及使用命令行工具创建。
Spring Initializr是一个在线工具,用于快速创建Spring Boot项目。访问Spring Initializr网站(https://start.spring.io/),选择项目类型、语言、依赖等,点击"Generate"按钮,下载项目压缩包,解压后导入到IDE中进行开发。
mvn archetype:generate -DgroupId=com.example -DartifactId=springboot-demo -Dversion=0.0.1-SNAPSHOT -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false
pom.xml
文件,添加Spring Boot依赖。
<parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>2.3.4.RELEASE</version> </parent>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</build>
5. 执行`mvn spring-boot:run`命令启动项目。 #### 使用Gradle创建 ```shell gradle init --type java-application --dsl groovy
build.gradle
文件,添加Spring Boot依赖。
plugins { id 'org.springframework.boot' version '2.3.4.RELEASE' id 'io.spring.dependency-management' version '1.0.9.RELEASE' id 'java' }
dependencies {
implementation 'org.springframework.boot:spring-boot-starter-web'
}
5. 执行`gradle bootRun`命令启动项目。 ## 初始化项目的基本步骤 1. 创建项目目录结构,如`src/main/java`和`src/main/resources`。 2. 创建`Application.java`文件,作为项目的启动类。 ```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); } }
application.properties
或application.yml
文件,用于配置项目的属性。
# application.properties server.port=8080 spring.application.name=demo-app
# application.yml server: port: 8080 spring: application: name: demo-app
Controller
类,用于定义RESTful接口。
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, World!";
}
}
5. 运行`DemoApplication`类,启动项目。 # Spring Boot核心概念 ## Spring Boot自动配置 Spring Boot自动配置是Spring Boot的核心功能之一。它根据配置文件中的属性,自动配置Spring应用。自动配置通常发生在项目启动时,根据不同的属性值,Spring Boot会自动配置不同的Bean。 ### 自动配置的实现原理 Spring Boot自动配置的实现原理是通过`@Conditional`注解来控制Bean的创建。这些注解可以根据不同的属性值控制Bean的创建。例如,`@ConditionalOnClass`注解可以根据类是否存在来控制Bean的创建,`@ConditionalOnProperty`注解可以根据属性值来控制Bean的创建。 ### 自动配置的配置过程 1. Spring Boot提供大量的`AutoConfiguration`类,这些类定义了自动配置的逻辑。 2. 在项目启动时,Spring Boot会扫描这些`AutoConfiguration`类。 3. 根据配置文件中的属性,Spring Boot会调用`@Conditional`注解,控制Bean的创建。 4. 如果满足条件,Spring Boot会创建相应的Bean。 ### 自动配置的禁用 可以通过`@SpringBootApplication`注解的`exclude`属性来禁用自动配置。例如,可以禁用`DataSourceAutoConfiguration`类的自动配置。 ```java @SpringBootApplication(exclude = {DataSourceAutoConfiguration.class}) public class DemoApplication { public static void main(String[] args) { SpringApplication.run(DemoApplication.class, args); } }
Spring Boot Starter是Spring Boot的依赖管理工具,用于简化依赖的引入和管理过程。Spring Boot Starter提供了一系列的依赖管理,使得开发者能够以最少的配置完成依赖的引入和管理。
Spring Boot Starter的工作原理是将一组常用的依赖打包成一个jar文件。开发者只需要引入这个jar文件,就可以引入这组依赖。
spring-boot-starter-web
依赖来引入Spring Web依赖。
<!-- pom.xml --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency>
@RestController
注解来定义RESTful接口。
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, World!";
}
}
## Spring Boot Actuator监控工具 Spring Boot Actuator是Spring Boot的监控工具,提供了健康检查、审计、信息、端点等特性。 ### Actuator的功能 1. **健康检查**:提供`/actuator/health`端点,用于检查应用的健康状态。 2. **审计**:提供`/actuator/auditevents`端点,用于审计应用的审计事件。 3. **信息**:提供`/actuator/info`端点,用于获取应用的信息。 4. **端点**:提供`/actuator/metrics`端点,用于获取应用的指标。 ### Actuator的配置 1. 引入`spring-boot-starter-actuator`依赖。 ```xml <!-- pom.xml --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-actuator</artifactId> </dependency>
management.endpoints.web.exposure.include
属性来控制哪些端点可以被访问。
# application.properties management.endpoints.web.exposure.include=health,info
/actuator/health
和/actuator/info
端点来获取应用的健康状态和信息。
curl http://localhost:8080/actuator/health curl http://localhost:8080/actuator/info
微服务是一种架构风格,将一个单一的应用程序拆分成一组小型、独立的微服务,每个微服务运行在自己的进程中,彼此之间通过轻量级的通信协议进行通信。微服务强调独立部署、独立扩展、独立开发、独立维护。
一个微服务应用可以分为多个独立的服务,每个服务负责不同的业务逻辑。例如,一个用户服务可以处理用户的注册、登录和信息更新等功能,另一个订单服务可以处理订单的创建、更新和取消等功能。
spring-boot-starter-web
依赖。
<!-- pom.xml --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency>
Controller
类,用于定义RESTful接口。
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, World!";
}
}
3. 运行`DemoApplication`类,启动项目。 ### RESTful服务的配置 1. 配置启动端口。 ```properties # application.properties server.port=8080
# application.properties spring.application.name=demo-app
@GetMapping("/api/hello") public String hello() { return "Hello, World!"; }
Spring Boot支持多种配置文件,如application.properties
、application.yml
、application-{profile}.properties
、application-{profile}.yml
等。可以通过spring.profiles.active
属性来激活不同的配置文件。
# application.properties server.port=8080 spring.application.name=demo-app
# application.yml server: port: 8080 spring: application: name: demo-app
# application-dev.properties server.port=8081 spring.application.name=demo-dev-app
# application-dev.yml server: port: 8081 spring: application: name: demo-dev-app
可以通过spring.profiles.active
属性来激活不同的配置文件。例如,可以在命令行中使用--spring.profiles.active=dev
参数来激活application-dev.properties
配置文件。
java -jar -Dspring.profiles.active=dev demo-app.jar
服务发现与注册是微服务架构中的一个重要环节,用于实现服务之间的发现与注册。服务发现与注册可以实现服务之间的动态发现与注册,提高了系统的可伸缩性。
spring-cloud-starter-netflix-eureka-server
和spring-cloud-starter-netflix-eureka-client
依赖。
<!-- pom.xml --> <dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId> </dependency> <dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId> </dependency>
package com.example.demo;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer;
@SpringBootApplication
@EnableEurekaServer
public class EurekaServerApplication {
public static void main(String[] args) {
SpringApplication.run(EurekaServerApplication.class, args);
}
}
3. 配置Eureka服务注册中心。 ```properties # application.properties server.port=8761 spring.application.name=eureka-server eureka.instance.hostname=localhost eureka.client.register-with-eureka=false eureka.client.fetch-registry=false eureka.client.service-url.defaultZone=http://${eureka.instance.hostname}:${server.port}/eureka/
package com.example.demo;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
@SpringBootApplication
@EnableEurekaClient
public class EurekaClientApplication {
public static void main(String[] args) {
SpringApplication.run(EurekaClientApplication.class, args);
}
}
5. 配置Eureka服务注册。 ```properties # application.properties server.port=8080 spring.application.name=service-provider eureka.client.service-url.defaultZone=http://localhost:8761/eureka/
Spring Cloud Config是Spring Cloud的配置中心,用于实现配置管理。Spring Cloud Config提供了集中化的配置管理,可以实现配置的动态更新。
spring-cloud-starter-config
依赖。
<!-- pom.xml --> <dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-starter-config</artifactId> </dependency>
package com.example.demo;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.config.server.EnableConfigServer;
@SpringBootApplication
@EnableConfigServer
public class ConfigServerApplication {
public static void main(String[] args) {
SpringApplication.run(ConfigServerApplication.class, args);
}
}
3. 配置Config Server。 ```properties # application.properties server.port=8888 spring.application.name=config-server spring.cloud.config.server.git.uri=https://github.com/username/repo spring.cloud.config.server.git.clone-uri=https://github.com/username/repo
spring-cloud-starter-config
依赖。
<!-- pom.xml --> <dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-starter-config</artifactId> </dependency>
package com.example.demo;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class ConfigClientApplication {
public static void main(String[] args) {
SpringApplication.run(ConfigClientApplication.class, args);
}
}
3. 配置Config Client。 ```properties # bootstrap.properties spring.application.name=service-provider spring.cloud.config.uri=http://localhost:8888
spring-cloud-starter-openfeign
依赖。
<!-- pom.xml --> <dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-starter-openfeign</artifactId> </dependency>
package com.example.demo;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.GetMapping;
@FeignClient("service-provider")
public interface ServiceClient {
@GetMapping("/api/hello")
String hello();
}
### 使用RestTemplate实现服务调用 1. 引入`spring-boot-starter-web`依赖。 ```xml <!-- pom.xml --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency>
package com.example.demo;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.web.client.RestTemplateBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.web.client.RestTemplate;
public class DemoApplication {
@Autowired
private RestTemplateBuilder builder;
@Bean public RestTemplate restTemplate() { return builder.build(); }
}
3. 使用RestTemplate实现服务调用。 ```java package com.example.demo; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.web.bind.annotation.GetMapping; import org.springframework.web.bind.annotation.RestController; import org.springframework.web.client.RestTemplate; @RestController public class HelloController { @Autowired private RestTemplate restTemplate; @GetMapping("/hello") public String hello() { return restTemplate.getForObject("http://localhost:8080/api/hello", String.class); } }
Spring Boot支持两种打包方式,分别是jar
和war
。jar
打包方式适用于独立运行的应用程序,war
打包方式适用于部署到应用服务器的应用程序。
mvn clean package
jar
文件位于target
目录下。./gradlew bootJar
jar
文件位于build/libs
目录下。# Maven打包 mvn clean package # Gradle打包 ./gradlew bootJar
java -jar target/demo-app.jar
curl http://localhost:8080/api/hello
jar
文件上传到云平台。# Dockerfile FROM openjdk:11-jre-slim COPY target/demo-app.jar /app/demo-app.jar ENTRYPOINT ["java", "-jar", "/app/demo-app.jar"]
docker build -t demo-app:latest .
docker run -p 8080:8080 demo-app:latest
# Dockerfile FROM openjdk:11-jre-slim COPY target/demo-app.jar /app/demo-app.jar ENTRYPOINT ["java", "-jar", "/app/demo-app.jar"]
# 构建Docker镜像 docker build -t demo-app:latest . # 运行Docker容器 docker run -p 8080:8080 demo-app:latest
通过以上操作,Spring Boot微服务可以被快速搭建、开发、部署和监控。微服务架构的优势也使得Spring Boot微服务更加灵活、可伸缩和可维护。