为了账号安全，请及时绑定邮箱和手机立即绑定
首页 手记 SpringCloud Alibaba入门教程

SpringCloud Alibaba入门教程

标签：
Spring Cloud 阿里云 微服务
概述

SpringCloud Alibaba 是阿里巴巴基于 Spring Cloud 的微服务开发框架，提供了服务注册与发现、配置中心、分布式事务等核心功能。该框架集成了阿里巴巴的高性能中间件，简化了微服务的开发流程，支持云原生特性。通过 SpringCloud Alibaba，开发者可以快速构建和维护稳定的微服务应用。

SpringCloud Alibaba简介

SpringCloud Alibaba的定义

SpringCloud Alibaba 是阿里巴巴开源的基于 Spring Cloud 的微服务开发框架，它提供了如服务注册与发现、配置中心、负载均衡、断路器等功能，使得开发者可以更加方便地构建和维护微服务应用。SpringCloud Alibaba 集成了阿里巴巴的高性能中间件，如 Nacos、Sentinel、Seata、RocketMQ 等，这些中间件都是经过阿里巴巴内部大规模实践打磨的，具有很高的稳定性和性能。

使用SpringCloud Alibaba的优势

使用 SpringCloud Alibaba 可以带来以下优势：

  1. 统一的微服务框架：SpringCloud Alibaba 提供了一套完整的微服务解决方案，包括服务注册与发现、配置中心、负载均衡、断路器等功能，使得开发者可以专注于业务逻辑的实现。
  2. 高性能的中间件支持：SpringCloud Alibaba 集成了阿里巴巴的高性能中间件，如 Nacos、Sentinel、Seata 等，这些中间件都是经过阿里巴巴内部大规模实践打磨的，具有很高的稳定性和性能。
  3. 简化开发流程：通过 SpringCloud Alibaba，开发者可以快速搭建微服务架构，减少重复开发的工作量，提高开发效率。
  4. 云原生支持：SpringCloud Alibaba 支持云原生的各种特性，如服务发现、配置中心等，使得微服务架构更容易运行在云环境中。
  5. 社区活跃：SpringCloud Alibaba 作为开源项目，拥有活跃的社区支持，开发者可以在这个社区中获取帮助、交流经验、分享最佳实践。

SpringCloud Alibaba的常用组件介绍

SpringCloud Alibaba 包含了多个重要的组件，包括：

  1. Nacos：服务注册与发现、配置管理。
  2. Sentinel：流量控制、服务保护。
  3. Seata：分布式事务管理。
  4. RocketMQ：分布式消息中间件。

这些组件是构建微服务架构的核心组件，可以帮助开发者实现服务的注册与发现、配置管理、流量控制、分布式事务和消息传递等功能。

快速开始SpringCloud Alibaba

开发环境搭建

要开始使用 SpringCloud Alibaba，首先需要搭建开发环境，具体步骤如下：

  1. 安装 JDK：确保安装了 JDK 8 或更高版本。
  2. 安装 Maven：Maven 是一个强大的项目管理工具，用于构建和管理 Java 项目。
  3. 安装 IDE：推荐使用 IntelliJ IDEA 或 Eclipse。
  4. 配置 Maven 仓库：在 pom.xml 中配置 Maven 仓库，确保能下载到 SpringCloud Alibaba 的依赖。
<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-alibaba-dependencies</artifactId>
            <version>2021.0.2</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>
  1. 创建 Spring Boot 项目：使用 Spring Initializr 创建一个新的 Spring Boot 项目。
  2. 配置 Spring Cloud Alibaba 依赖：在项目中添加 SpringCloud Alibaba 的依赖。
<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
</dependency>

创建第一个SpringCloud Alibaba应用

接下来，创建第一个 SpringCloud Alibaba 应用，具体步骤如下：

  1. 创建主应用类：创建一个主应用类，启动 Spring Boot 应用。
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);
    }
}
  1. 配置服务注册与发现：在 application.yml 中配置服务注册与发现。
spring:
  application:
   name: demo-service  # 应用名称
 cloud:
   nacos:
     discovery:
       server-addr: 127.0.0.1:8848  # Nacos 服务地址
  1. 启动服务：启动应用，服务将自动注册到 Nacos 服务注册中心。
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

通过以上步骤，你已经成功创建了一个简单的 SpringCloud Alibaba 应用，并将其注册到了 Nacos 服务注册中心。

使用Nacos进行服务注册与发现

Nacos简介

Nacos 是由阿里巴巴开源的一个动态服务发现、配置管理和服务管理平台。Nacos 提供了服务注册与发现、配置管理、服务管理等功能，支持多种编程语言和微服务框架，包括 SpringCloud、Dubbo 等。

服务注册和发现的基本概念

服务注册与发现是微服务架构中的关键功能之一。服务注册是指服务启动时向注册中心注册自己的地址和端口，服务发现是指其他服务需要调用某个服务时，向注册中心查询该服务的地址和端口，然后直接通过网络调用该服务。

服务注册

当一个服务启动时，会向注册中心注册自己的地址和端口信息，注册中心会维护一个服务列表，记录所有服务的地址和端口。

import org.springframework.cloud.client.discovery.DiscoveryClient;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.bind.annotation.RequestMapping;

@RestController
public class ServiceDiscoveryController {

    private final DiscoveryClient discoveryClient;

    public ServiceDiscoveryController(DiscoveryClient discoveryClient) {
        this.discoveryClient = discoveryClient;
    }

    @RequestMapping("/services")
    public String services() {
        return discoveryClient.getServices().toString();
    }
}

服务发现

当一个服务需要调用另一个服务时，会向注册中心查询该服务的地址和端口，然后通过网络调用该服务。

import org.springframework.cloud.client.discovery.DiscoveryClient;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.bind.annotation.RequestMapping;

@RestController
public class ServiceDiscoveryController {

    private final DiscoveryClient discoveryClient;

    public ServiceDiscoveryController(DiscoveryClient discoveryClient) {
        this.discoveryClient = discoveryClient;
    }

    @RequestMapping("/service-instance")
    public String serviceInstance() {
        return discoveryClient.getInstances("service-name").toString();
    }
}

实战：使用Nacos实现服务注册与发现

接下来，我们将通过一个简单的示例来演示如何使用 Nacos 实现服务注册与发现。

创建服务注册的示例应用

  1. 创建一个 Spring Boot 项目，使用 Spring Initializr 创建一个新的项目。
  2. 添加依赖：在 pom.xml 中添加 Nacos 服务注册与发现的依赖。
<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
</dependency>
  1. 配置 Nacos 服务地址：在 application.yml 中配置 Nacos 服务地址。
spring:
  application:
   name: demo-service
 cloud:
   nacos:
     discovery:
       server-addr: 127.0.0.1:8848
  1. 创建服务注册的控制器：创建一个简单的控制器，用于注册服务。
import org.springframework.cloud.client.discovery.DiscoveryClient;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.bind.annotation.RequestMapping;

@RestController
public class ServiceRegisterController {

    private final DiscoveryClient discoveryClient;

    public ServiceRegisterController(DiscoveryClient discoveryClient) {
        this.discoveryClient = discoveryClient;
    }

    @RequestMapping("/services")
    public String services() {
        return discoveryClient.getServices().toString();
    }
}

创建服务发现的示例应用

  1. 创建另一个 Spring Boot 项目，同样使用 Spring Initializr 创建一个新的项目。
  2. 添加依赖：在 pom.xml 中添加 Nacos 服务注册与发现的依赖。
<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
</dependency>
  1. 配置 Nacos 服务地址：在 application.yml 中配置 Nacos 服务地址。
spring:
  application:
   name: demo-discovery-service
 cloud:
   nacos:
     discovery:
       server-addr: 127.0.0.1:8848
  1. 创建服务发现的控制器：创建一个简单的控制器，用于发现服务。
import org.springframework.cloud.client.discovery.DiscoveryClient;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.bind.annotation.RequestMapping;

@RestController
public class ServiceDiscoveryController {

    private final DiscoveryClient discoveryClient;

    public ServiceDiscoveryController(DiscoveryClient discoveryClient) {
        this.discoveryClient = discoveryClient;
    }

    @RequestMapping("/service-instance")
    public String serviceInstance() {
        return discoveryClient.getInstances("demo-service").toString();
    }
}

通过上述步骤，你已经成功创建了两个简单的 Spring Boot 应用，分别用于服务注册和服务发现。运行这两个应用，然后通过浏览器访问 /services 和 /service-instance 端点，可以看到服务注册和发现的结果。

Seata分布式事务入门

Seata的基本概念

Seata 是一个开源的分布式事务解决方案，致力于解决微服务架构下的分布式事务一致性问题。Seata 为微服务架构提供了高性能的分布式事务服务，支持多种编程语言和微服务框架，包括 SpringCloud、Dubbo 等。

分布式事务的必要性

在分布式系统中，多个服务之间可能会涉及到事务操作。为了保证分布式事务的一致性，需要对事务进行管理。Seata 提供了一套完整的分布式事务解决方案，包括事务管理器、资源管理器、代理等模块，可以有效地管理分布式事务，保证事务的最终一致性。

分布式事务的必要性

分布式事务的必要性主要体现在以下几个方面：

  1. 保证数据一致性：在分布式系统中，多个服务之间可能会涉及到事务操作。为了保证数据的一致性，需要对事务进行管理。
  2. 提高系统可用性：通过分布式事务，可以提高系统的可用性和稳定性，保证在出现故障时，事务能够正确回滚，不影响其他服务的正常运行。
  3. 简化开发流程：通过使用 Seata 等分布式事务管理工具，可以简化分布式系统的开发流程，减少开发人员的工作量。

实战：使用Seata实现分布式事务管理

接下来，我们将通过一个简单的示例来演示如何使用 Seata 实现分布式事务管理。

创建两个服务

  1. 创建一个订单服务：用于创建订单。
  2. 创建一个库存服务：用于扣减库存。

配置 Seata

  1. 添加 Seata 依赖：在 pom.xml 中添加 Seata 依赖。
<dependency>
    <groupId>io.seata</groupId>
    <artifactId>seata-spring-boot-starter</artifactId>
    <version>1.5.1</version>
</dependency>
  1. 配置 Seata 服务器地址：在 application.yml 中配置 Seata 服务器地址。
seata:
  server:
   enabled: true
   service:
      vgroup-mapping:
         default:
            registry:
               group: default
               load-balance: roundrobin
               server-list:
                  - 127.0.0.1:8091

创建订单服务

  1. 创建一个订单服务：创建一个简单的订单服务，用于创建订单。
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
public class OrderService {

    @Autowired
    private StockService stockService;

    @Transactional
    public void createOrder() {
        // 创建订单
        // 扣减库存
        stockService.decreaseStock();
    }
}
  1. 创建库存服务：创建一个简单的库存服务，用于扣减库存。
import org.springframework.stereotype.Service;

@Service
public class StockService {

    public void decreaseStock() {
        // 扣减库存
    }
}

配置 Seata 事务管理

  1. 配置 Seata 事务管理：在 application.yml 中配置 Seata 事务管理。
seata:
  transaction:
   xa:
      enabled: true
      xaDataSource:
         dataSource:
            driverClassName: com.mysql.jdbc.Driver
            url: jdbc:mysql://localhost:3306/seata?useSSL=false
            username: root
            password: root

通过上述步骤，你已经成功创建了一个简单的分布式事务示例，通过 Seata 实现了订单服务和库存服务之间的事务管理。运行这两个服务，并调用订单服务的 createOrder 方法，可以验证分布式事务的效果。

使用Sentinel进行流量控制

Sentinel简介

Sentinel 是阿里巴巴开源的一个轻量级的、高性能的服务治理与防护组件。Sentinel 提供了流量控制、熔断降级、系统负载保护等功能，可以帮助开发者在高并发场景下保障服务的稳定性和可用性。

流量控制的基本概念

流量控制是指在服务治理中对进入系统的流量进行控制，防止过多的流量进入系统，导致系统负载过高，影响系统的稳定性和性能。Sentinel 提供了多种流量控制策略，包括基于时间窗口、基于令牌桶、基于链路等策略。

基于时间窗口的流量控制

基于时间窗口的流量控制是指在固定的时间窗口内，限制进入系统的请求数量。例如，可以配置在每秒内允许多少个请求进入系统。

基于令牌桶的流量控制

基于令牌桶的流量控制是指使用一个令牌桶来控制进入系统的请求数量。令牌桶中有一个固定的令牌数量，每次进入一个请求时，需要从令牌桶中取出一个令牌。如果令牌桶中的令牌数量不足，则请求会被拒绝。

实战：使用Sentinel进行流量控制

接下来，我们将通过一个简单的示例来演示如何使用 Sentinel 进行流量控制。

创建一个服务

  1. 创建一个简单的服务：创建一个简单的服务，用于处理用户的请求。
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class SimpleController {

    @GetMapping("/simple")
    public String simple() {
        return "Hello, Sentinel!";
    }
}

配置 Sentinel

  1. 添加 Sentinel 依赖：在 pom.xml 中添加 Sentinel 依赖。
<dependency>
    <groupId>com.alibaba.csp</groupId>
    <artifactId>sentinel-spring-boot-starter</artifactId>
    <version>1.8.2</version>
</dependency>
  1. 配置流量控制规则：在 application.yml 中配置流量控制规则。
sentinel:
  flow:
   rules:
      - resource: "/simple"
        count: 10
        strategy: 0  # QPS 限流
        grade: 1  # 阻塞
        warmUp: 0
        controlBehavior: 0
        metricName: ""
        clusterMode: false

测试流量控制效果

  1. 启动服务：启动服务后，可以使用工具如 Postman 或者 JMeter 来测试流量控制的效果。

通过上述步骤，你已经成功创建了一个简单的服务，并配置了 Sentinel 的流量控制规则。运行服务后，可以使用工具测试流量控制的效果，验证是否能有效限制进入系统的请求数量。

使用RocketMQ实现可靠消息传递

RocketMQ简介

RocketMQ 是阿里巴巴开源的一款分布式消息中间件，支持多种消息模式，包括发布/订阅、点对点等。RocketMQ 采用高可用设计，支持消息的可靠传输和消息的顺序消费等特性。RocketMQ 还支持多种消息协议，如 HTTP、WebSocket 等，可以方便地集成到各种应用中。

消息传递的基本概念

消息传递是指在分布式系统中，通过消息中间件传递消息的方式。消息传递可以用来实现服务之间的异步通信，提高系统的解耦度和灵活性。RocketMQ 支持多种消息传递模式，包括发布/订阅和点对点模式。

发布/订阅模式

在发布/订阅模式中，消息生产者将消息发布到一个主题（Topic），多个消息消费者订阅这个主题，接收并处理消息。

点对点模式

在点对点模式中，消息生产者将消息发送到一个队列（Queue），消息消费者从队列中接收并处理消息。

实战：使用RocketMQ实现消息传递功能

接下来，我们将通过一个简单的示例来演示如何使用 RocketMQ 实现消息传递功能。

创建一个消息生产者

  1. 创建一个简单的消息生产者：创建一个简单的消息生产者，用于发送消息。
import org.apache.rocketmq.client.producer.DefaultMQProducer;
import org.apache.rocketmq.client.producer.SendResult;
import org.apache.rocketmq.common.message.Message;

public class SimpleProducer {

    public static void main(String[] args) throws Exception {
        DefaultMQProducer producer = new DefaultMQProducer("ProducerGroup");
        producer.setNamesrvAddr("127.0.0.1:9876");
        producer.start();

        Message msg = new Message("TestTopic", "Tag", "Hello, RocketMQ!".getBytes());
        SendResult result = producer.send(msg);
        System.out.println("Send Result: " + result);

        producer.shutdown();
    }
}

创建一个消息消费者

  1. 创建一个简单的消息消费者：创建一个简单的消息消费者，用于接收并处理消息。
import org.apache.rocketmq.client.consumer.DefaultMQPushConsumer;
import org.apache.rocketmq.client.consumer.listener.MessageListenerConcurrently;
import org.apache.rocketmq.common.consumer.ConsumeFromWhere;
import org.apache.rocketmq.common.message.MessageExt;

public class SimpleConsumer {

    public static void main(String[] args) throws Exception {
        DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("ConsumerGroup");
        consumer.setNamesrvAddr("127.0.0.1:9876");
        consumer.subscribe("TestTopic", "*");
        consumer.setMessageModel(MessageModel.BROADCASTING);
        consumer.setConsumeFromWhere(ConsumeFromWhere.CONSUME_FROM_FIRST_OFFSET);
        consumer.registerMessageListener((MessageListenerConcurrently) (msgs, context) -> {
            for (MessageExt msg : msgs) {
                System.out.println("Received message: " + new String(msg.getBody()));
            }
            return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
        });
        consumer.start();
    }
}

配置 RocketMQ

  1. 添加 RocketMQ 依赖：在 pom.xml 中添加 RocketMQ 依赖。
<dependency>
    <groupId>org.apache.rocketmq</groupId>
    <artifactId>rocketmq-client</artifactId>
    <version>4.9.3</version>
</dependency>
  1. 启动 RocketMQ 服务：启动 RocketMQ 服务，确保服务正常运行。

通过上述步骤，你已经成功创建了一个简单的消息生产者和消息消费者，并配置了 RocketMQ 的相关设置。运行这两个程序，可以验证消息传递的效果。生产者发送的消息会被消费者成功接收并处理。

点击查看更多内容
发表于 2024.09.25 15:54， 共 105 人浏览

本文原创发布于慕课网 ，转载请注明出处，谢谢合作

举报
为 TA 点赞

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

评论

作者其他优质文章

正在加载中

呼唤远方

手记
篇
粉丝
82
获赞与收藏
367

关注作者，订阅最新文章

阅读免费教程

  • 推荐
  • 评论
  • 收藏
  • 共同学习，写下你的评论
感谢您的支持，我会继续努力的～
扫码打赏，你说多少就多少
赞赏金额会直接到老师账户
支付方式
打开微信扫一扫，即可进行扫码打赏哦
今天注册有机会得

100积分直接送

付费专栏免费学

大额优惠券免费领

立即参与 放弃机会
意见反馈 帮助中心 APP下载
官方微信

举报

0/150
提交
取消