首页手记 Spring Boot微服务入门教程

Spring Boot微服务入门教程

标签：

SpringBoot 微服务

Spring Boot 微服务入门教程

概述

本文介绍了如何使用Spring Boot快速搭建微服务，从Spring Boot的基本概念和优势入手，详细讲解了如何创建第一个Spring Boot微服务项目，并介绍了微服务间的通信方式和监控管理。spring boot微服务入门的相关内容将帮助开发者快速掌握微服务开发的关键技术。

1. Spring Boot 简介

什么是Spring Boot

Spring Boot 是由 Pivotal 团队提供的一个用于简化 Spring 应用初始搭建及开发过程的框架。它在 Spring 基础之上，提供了自动配置、约定优于配置、内嵌 Web 服务器等功能，使开发者能够更快速地编写独立的、生产级别的 Spring 应用程序。

Spring Boot 的优势和特点

自动配置：Spring Boot 通过约定优于配置的原则，自动管理了许多常见的配置项。开发者只需提供特定的配置细节，其余部分将由 Spring Boot 进行自动配置。
嵌入式服务器：Spring Boot 可以内嵌 Web 服务器，如 Tomcat、Jetty 或 Undertow，这意味着开发者可以运行独立的可执行应用程序，无需外部的 Web 服务器。
依赖管理：Spring Boot 提供了 Maven 和 Gradle 插件，可以帮助开发者自动管理依赖项，避免手动配置和版本冲突。
快速构建：通过 Spring Initializr，开发者可以快速搭建一个 Spring Boot 项目，减少项目初始化和配置的时间。
监控与健康检查：Spring Boot Actuator 提供了生产环境中的监控和健康检查功能，保证应用的稳定运行。

快速开始一个 Spring Boot 项目

安装 Java 环境：确保你的机器上安装了 Java JDK。
创建新的 Spring Boot 项目：使用 Spring Initializr 创建一个新的 Spring Boot 项目。
- 访问 Spring Initializr。
- 选择项目类型（例如 Maven 项目）、语言（Java）、Spring Boot 版本。
- 输入项目基本信息（如 Group 和 Artifact）。
- 选择所需的依赖，例如 Web、Thymeleaf、JPA 等。
- 下载并解压下载的压缩包，然后导入到你的 IDE（如 IntelliJ IDEA 或 Eclipse）中。

运行第一个应用：

编写一个简单的 Hello World 应用。在 src/main/java 目录下创建一个新的 Java 类 Application.java 和 HelloWorldController.java：

package com.example.demo;

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

@SpringBootApplication
public class Application {

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

package com.example.demo;

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

@RestController
public class HelloWorldController {

 @GetMapping("/")
 public String helloWorld() {
     return "Hello, World!";
 }
}

运行 Application.java 类中的 main 方法。你可以通过启动 Spring Boot 应用程序，访问 http://localhost:8080/ 查看结果。

2. 微服务基础概念

微服务架构概述

微服务架构是一种将单体应用拆分成独立、小型的微服务的方式，每个微服务都运行自己的进程并负责单一业务功能。微服务架构强调的是系统的一致性、松耦合和可伸缩性。

微服务与传统单体应用的区别

代码结构：传统单体应用通常是一个大型代码库，而微服务应用则由多个独立的小型服务组成。
部署方式：传统单体应用通常部署在一个单一的单元中，而微服务则可以独立部署。
扩展方式：在传统单体应用中，扩展意味着扩展整个应用；而在微服务中，可以根据服务的需求独立扩展。
开发周期：传统单体应用的开发周期较长，因为修改任何功能都需要重新构建整个应用。而微服务允许团队独立开发和测试各个服务。

微服务的优点与挑战

优点：

灵活性与扩展性：微服务允许团队独立开发和扩展不同的服务，提高了系统的灵活性。
独立部署：每个服务可以独立部署，提高了部署的效率。
易于维护：每个服务负责单一业务功能，便于维护和理解。

挑战：

复杂性：微服务架构增加了系统的复杂性，需要更多的工具和策略来管理服务间通信。
运维成本：分布式系统需要更多的运维工作，包括监控、日志收集、故障恢复等。
集成难度：集成多个服务可能比集成一个大型传统应用更复杂。

3. 创建第一个 Spring Boot 微服务

使用 Spring Initializr 快速搭建项目

访问 Spring Initializr。
选择项目类型（例如 Maven 项目）、语言（Java）、Spring Boot 版本。
输入项目基本信息（如 Group 和 Artifact）。
选择所需的依赖，例如 Web、Thymeleaf、JPA 等。
下载并解压下载的压缩包，然后导入到你的 IDE（如 IntelliJ IDEA 或 Eclipse）中。

项目结构与依赖管理

项目结构：

/src/main/java
├── com/example/demo
│   ├── Application.java
│   └── HelloWorldController.java
/src/main/resources
├── application.properties
└── static
└── templates
/pom.xml

Application.java：应用启动类。
HelloWorldController.java：简单的 RESTful 控制器。
application.properties：应用配置文件。
pom.xml：Maven 构建文件，包含依赖管理。

<?xml version="1.0" encoding="UTF-8"?>
<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>
<parent>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-parent</artifactId>
  <version>2.7.6</version>
  <relativePath/> <!-- lookup parent from repository -->
</parent>
<groupId>com.example</groupId>
<artifactId>demo</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>demo</name>
<description>Demo project for Spring Boot</description>
<properties>
  <java.version>11</java.version>
</properties>
<dependencies>
  <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
  </dependency>
  <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <scope>test</scope>
  </dependency>
</dependencies>
<build>
  <plugins>
    <plugin>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-maven-plugin</artifactId>
    </plugin>
  </plugins>
</build>
</project>

应用配置文件：

spring.application.name=demo
server.port=8080

编写第一个 RESTful 接口

在 src/main/java 目录下创建一个新的 Java 类 HelloWorldController.java：

package com.example.demo;

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

@RestController
public class HelloWorldController {

   @GetMapping("/")
   public String helloWorld() {
       return "Hello, World!";
   }
}

在 src/main/java 目录下创建一个新的 Java 类 Application.java：

package com.example.demo;

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

@SpringBootApplication
public class Application {

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

运行 Application.java 类中的 main 方法。你可以通过启动 Spring Boot 应用程序，访问 http://localhost:8080/ 查看结果。

4. 微服务间通信

RESTful 服务通信

在微服务架构中，服务之间最常见的通信方式之一是通过 RESTful API 进行通信。RESTful 通信使用 HTTP 协议，允许服务之间进行无状态的通信。以下是 RESTful 服务通信的基本示例。

创建一个简单的 RESTful API 服务。

package com.example.demo;

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

@RestController
public class HelloWorldController {

   @GetMapping("/")
   public String helloWorld() {
       return "Hello, World!";
   }
}

在客户端服务中调用该 RESTful API。

package com.example.demo;

import org.springframework.boot.web.client.RestTemplateBuilder;
import org.springframework.web.client.RestTemplate;

public class ClientService {

   private final RestTemplate restTemplate;

   public ClientService(RestTemplateBuilder restTemplateBuilder) {
       restTemplate = restTemplateBuilder.build();
   }

   public String callService() {
       String result = restTemplate.getForObject("http://localhost:8080/", String.class);
       return result;
   }
}

使用 Spring Cloud 进行服务发现

使用 Spring Cloud 可以简化微服务之间的通信和管理。Spring Cloud 提供了服务注册与发现的功能，使得服务之间可以动态地发现和调用。

引入 Spring Cloud 依赖。

<dependency>
   <groupId>org.springframework.cloud</groupId>
   <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
</dependency>

配置服务注册中心。

# src/main/resources/application.properties
spring.application.name=eureka-server
server.port=8761
eureka.instance.hostname=localhost
eureka.client.register-with-eureka=false
eureka.client.fetch-registry=false

创建服务提供者。

# src/main/resources/application.properties
spring.application.name=service-provider
server.port=8081
eureka.client.service-url.defaultZone=http://localhost:8761/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 ServiceProviderApplication {

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

创建服务消费者。

# src/main/resources/application.properties
spring.application.name=service-consumer
server.port=8082
eureka.client.service-url.defaultZone=http://localhost:8761/eureka/

package com.example.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
import org.springframework.cloud.openfeign.EnableFeignClients;
import org.springframework.cloud.netflix.ribbon.RibbonClient;

@SpringBootApplication
@EnableEurekaClient
@EnableFeignClients
@RibbonClient(name = "service-provider", configuration = MyRibbonConfiguration.class)
public class ServiceConsumerApplication {

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

实现服务间安全通信

为了确保服务之间的通信安全，可以使用 OAuth2 或 JWT 等认证和授权机制。

配置 OAuth2 服务器。

# src/main/resources/application.properties
security.oauth2.client.client-id=clientId
security.oauth2.client.client-secret=clientSecret
security.oauth2.client.access-token-uri=http://localhost:8081/oauth/token

在服务提供者中实现 OAuth2 认证。

package com.example.demo;

import org.springframework.security.oauth2.config.annotation.web.configuration.EnableResourceServer;
import org.springframework.security.oauth2.config.annotation.web.configuration.ResourceServerConfigurerAdapter;

@EnableResourceServer
public class ResourceServerConfiguration extends ResourceServerConfigurerAdapter {
   // 自定义配置
}

在服务消费者中实现 OAuth2 认证。

package com.example.demo;

import org.springframework.security.oauth2.config.annotation.web.configuration.EnableResourceServer;
import org.springframework.security.oauth2.config.annotation.web.configuration.ResourceServerConfigurerAdapter;

@EnableResourceServer
public class ResourceServerConfiguration extends ResourceServerConfigurerAdapter {
   // 自定义配置
}

5. 服务治理与监控

服务注册与发现

Spring Cloud 提供了多种服务注册与发现的实现，其中最常用的包括 Eureka 和 Consul。

引入 Eureka 依赖。

<dependency>
   <groupId>org.springframework.cloud</groupId>
   <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
</dependency>

配置 Eureka 服务注册中心。

# src/main/resources/application.properties
spring.application.name=eureka-server
server.port=8761
eureka.instance.hostname=localhost
eureka.client.register-with-eureka=false
eureka.client.fetch-registry=false

配置服务提供者。

# src/main/resources/application.properties
spring.application.name=service-provider
server.port=8081
eureka.client.service-url.defaultZone=http://localhost:8761/eureka/

使用 Spring Boot Actuator 进行应用监控

Spring Boot Actuator 提供了一系列的生产环境中的监控和健康检查功能，使得开发者可以更好地管理生产环境中的应用。

引入 Actuator 依赖。

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

启用 Actuator。

# src/main/resources/application.properties
management.endpoints.web.exposure.include=*
management.endpoint.health.show-details=always

访问 /actuator 路径查看 Actuator 提供的监控信息。

日志管理和异常处理

日志管理：Spring Boot 提供了强大的日志管理功能，可以配置不同级别的日志输出。默认使用 logback 作为日志框架。

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

# src/main/resources/application.properties
logging.level.root=INFO
logging.level.org.springframework.web=DEBUG

<?xml version="1.0" encoding="UTF-8"?>
<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>

异常处理：可以通过自定义异常处理器来处理全局异常。

package com.example.demo;

import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;

@ControllerAdvice
public class GlobalExceptionHandler {

  @ExceptionHandler(value = Exception.class)
  public ResponseEntity<String> handleException(Exception ex) {
      return new ResponseEntity<>(ex.getMessage(), HttpStatus.INTERNAL_SERVER_ERROR);
  }
}

6. 部署与运行微服务

构建与打包 Spring Boot 应用

构建应用：使用 Maven 或 Gradle 构建 Spring Boot 应用。
```
mvn clean package
```
打包应用：构建完成后，可以在 target 目录下找到生成的可执行 jar 文件。
```
java -jar target/demo-0.0.1-SNAPSHOT.jar
```

微服务的容器化部署

容器化部署是现代应用部署的常见方式之一。通过容器化，可以将应用及其依赖项打包到一个独立的环境中，从而实现应用的快速部署和迁移。

使用 Docker 部署微服务：

docker build -t my-spring-boot-app .
docker run -p 8080:8080 my-spring-boot-app

使用 Docker Compose 部署多个微服务：

version: '3'
services:
 service-provider:
   image: my-spring-boot-app
   ports:
     - "8081:8080"
 service-consumer:
   image: my-spring-boot-app
   ports:
     - "8082:8080"

docker-compose up

使用 Docker 和 Kubernetes 部署微服务

Kubernetes 是一个开源的容器编排平台，可以自动化部署、扩展和管理容器化应用。

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

创建 Kubernetes 部署文件：

apiVersion: apps/v1
kind: Deployment
metadata:
 name: spring-boot-app
spec:
 replicas: 3
 selector:
   matchLabels:
     app: spring-boot-app
 template:
   metadata:
     labels:
       app: spring-boot-app
   spec:
     containers:
     - name: spring-boot-app
       image: my-spring-boot-app
       ports:
       - containerPort: 8080
---
apiVersion: v1
kind: Service
metadata:
 name: spring-boot-app
spec:
 selector:
   app: spring-boot-app
 ports:
 - protocol: TCP
   port: 8080
   targetPort: 8080
 type: LoadBalancer

部署到 Kubernetes 集群：
```
kubectl apply -f deployment.yaml
```

通过这些步骤，你可以使用 Spring Boot 快速构建和部署微服务应用，同时利用容器化和 Kubernetes 等工具来简化部署和管理过程。

点击查看更多内容

为 TA 点赞

若觉得本文不错，就分享一下吧！

评论

评论

共同学习，写下你的评论

评论加载中...

展开查看更多评论

作者其他优质文章

正在加载中

慕哥6287543

手记
篇

粉丝

2

获赞与收藏

1

关注作者，订阅最新文章

阅读免费教程

后端通用面试教程

41个小节 30980 346

网络编程入门教程

20个小节 12758 240

Pandas 入门教程

25个小节 18643 345

推荐

评论

收藏

共同学习，写下你的评论



感谢您的支持，我会继续努力的～

扫码打赏，你说多少就多少

赞赏金额会直接到老师账户

支付方式

打开微信扫一扫，即可进行扫码打赏哦

今天注册有机会得

100积分直接送

付费专栏免费学

大额优惠券免费领

立即参与放弃机会

点击
抽奖

慕课手记新用户专享福利

恭喜你，你的运气太好了，居然抽中了 100个积分！

恭喜你，抽中了价值元的专栏！

太棒了，直接落到你账户里！

积分商城里的罗技鼠标、机械键盘、
Kindle 阅读器、小米平衡车
Apple iPad （10.2英寸）、大额优惠券
在等着你去兑换了噢

作者：

免费赠送

兑换码：1111222211 复制

优惠券可用于购买实战课、体系课
无门槛使用

先去看看，有什么好东西马上兑换我爱学习，选课去


热搜

最近搜索清空