为了账号安全,请及时绑定邮箱和手机立即绑定

SpringCloud应用教程:新手入门与实践指南

标签:
Spring Cloud
概述

本文详细介绍了Spring Cloud应用教程,涵盖了环境搭建、服务发现与注册、负载均衡与Ribbon、服务熔断与降级以及配置中心与Spring Cloud Config等内容,帮助开发者快速上手Spring Cloud微服务架构。

Spring Cloud简介与环境搭建

Spring Cloud是什么

Spring Cloud是一系列框架的有序集合,它利用Spring Boot的开发便利性巧妙地简化了分布式系统基础设施的开发。Spring Cloud为开发人员提供了快速构建分布式系统的一整套配置和工具,例如服务发现、配置中心、断路器、路由、微代理、集群状态等。Spring Cloud基于Spring Boot自动配置简化了分布式系统的开发过程,它主要针对大型分布式系统的宏观服务治理关注,而具体到某个服务的具体业务逻辑,我们仍然可以使用Spring Boot的标准开发流程来实现。

开发环境配置

在开始一个Spring Cloud项目之前,您需要确保您的开发环境已经配置好。以下是配置步骤:

  1. 安装Java: 确保您的机器上已经安装了JDK 1.8或以上版本。可以通过命令 java -version 来检查。

  2. 配置环境变量: 将JDK的bin目录添加到环境变量PATH中,以确保Java命令可以被系统识别。

    export PATH=$PATH:/path/to/jdk/bin
  3. 安装Maven: Maven是一个强大的项目管理和构建工具,它通过一个中央仓库来支持项目的构建、依赖管理和项目信息的一致性。

    • 下载并安装最新版本的Maven。
    • 配置Maven环境变量,将Maven的bin目录添加到环境变量PATH中。
  4. 安装IDE: 推荐使用IntelliJ IDEA或者Spring Tool Suite (STS)作为开发Spring Cloud项目的IDE。

    • 下载并安装IntelliJ IDEA。
    • 下载并安装STS。
  5. 创建Spring Boot项目:
    使用Spring Initializr或者STS创建一个新的Spring Boot项目。这里以STS为例:

    • 打开STS,点击"File" -> "New" -> "Spring Starter Project"。
    • 在弹出的对话框中,选择相应版本的Spring Boot和Maven作为构建工具。
    • 在"Project Name"栏输入项目名称,选择Java版本以及项目位置。
    • 在"Dependencies"框中勾选Spring Cloud Starter、Spring Web等依赖。

快速开始一个Spring Cloud项目

创建了一个Spring Boot项目后,接下来可以通过以下步骤快速入门Spring Cloud:

  1. 创建Spring Cloud项目:
    使用Maven创建一个基本的Spring Boot项目。在pom.xml中添加Spring Cloud Starter依赖:

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.7.3</version>
    </parent>
    
    <dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>
    
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>2021.0.1</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>
  2. 配置Eureka客户端:
    配置Spring Cloud应用作为Eureka服务注册中心的客户端。编辑application.yml文件,配置服务名称及注册中心的地址:

    spring:
      application:
        name: my-service
      cloud:
        config:
          enabled: false
    server:
      port: 8081
    
    eureka:
      client:
        service-url:
          defaultZone: http://localhost:8761/eureka/
  3. 启动Spring Cloud服务:
    在Spring Boot项目中,添加一个基本的REST服务。创建一个简单的HelloController

    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 from Spring Cloud Service!";
        }
    }
  4. 启动服务:
    在STS中右键点击项目,选择"Run As" -> "Spring Boot App"来启动服务。
服务发现与注册

服务发现与注册是微服务架构中一个非常重要的特性。服务提供者将自己注册到服务注册中心,服务消费者从注册中心获取服务提供者的地址列表进行服务调用。Spring Cloud提供了多种服务注册中心实现,比如Eureka、Consul和Zookeeper等。

Eureka服务注册与发现

Eureka是一个高可用的服务注册与发现组件,主要用于实现服务间的信息互通。Eureka服务注册分为服务提供者和服务消费者两种角色。服务提供者将自己的服务注册到Eureka Server,服务消费者从Eureka Server获取服务提供者的信息,从而实现服务调用。

  1. 服务提供者的设置:

    • pom.xml中添加Eureka服务注册相关依赖:
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
    </dependency>
    • 修改application.yml配置为服务提供者模式:
    spring:
      application:
        name: service-provider
    server:
      port: 8081
    eureka:
      client:
        service-url:
          defaultZone: http://localhost:8761/eureka/
  2. 创建服务提供者:
    创建一个简单的服务提供者,实现一个REST服务:

    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
    @RestController
    public class ServiceProviderApplication {
    
        @GetMapping("/greeting")
        public String greeting() {
            return "Hello from Service Provider!";
        }
    
        public static void main(String[] args) {
            SpringApplication.run(ServiceProviderApplication.class, args);
        }
    }
  3. 启动服务提供者:
    启动服务提供者应用,此时该服务会自动注册到Eureka Server上。

  4. 服务消费者的设置:

    • pom.xml中添加Eureka服务发现相关依赖:
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
    </dependency>
    • 修改application.yml配置为服务消费者模式:
    spring:
      application:
        name: service-consumer
    server:
      port: 8082
    eureka:
      client:
        service-url:
          defaultZone: http://localhost:8761/eureka/
  5. 创建服务消费者:
    创建一个简单的服务消费者,实现一个REST服务,该服务会调用服务提供者的greeting接口:

    package com.example.demo;
    
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    import org.springframework.cloud.openfeign.EnableFeignClients;
    import org.springframework.web.bind.annotation.GetMapping;
    import org.springframework.web.bind.annotation.RestController;
    import org.springframework.cloud.client.discovery.DiscoveryClient;
    
    @SpringBootApplication
    @EnableFeignClients
    @RestController
    public class ServiceConsumerApplication {
    
        private final DiscoveryClient discoveryClient;
    
        public ServiceConsumerApplication(DiscoveryClient discoveryClient) {
            this.discoveryClient = discoveryClient;
        }
    
        @GetMapping("/greeting")
        public String greeting() {
            String serviceId = "SERVICE-PROVIDER";
            return discoveryClient.getInstances(serviceId).stream()
                .map(instance -> instance.getUri().toString())
                .findFirst().orElse("Not Found");
        }
    
        public static void main(String[] args) {
            SpringApplication.run(ServiceConsumerApplication.class, args);
        }
    }
  6. 启动服务消费者:
    启动服务消费者应用,此时该服务会从Eureka Server获取服务提供者的地址,并调用服务提供者的greeting接口。

Consul与Zookeeper对比

Consul和Zookeeper都是常用的服务注册与发现组件,它们都提供了服务发现、配置共享和键值存储的功能。但是,两者在设计和使用上存在一些差异:

  • Consul:

    • Consul是一个分布式高可用的服务发现和配置工具,其目标是实现分布式系统基础设施的关键组件。
    • Consul除了提供服务发现和配置服务之外,还提供了健康检查、KV存储等功能。
    • Consul支持多数据中心,使服务注册与发现、配置等任务变得更加简单。
    • Consul提供了一个Web界面,使服务注册与发现变得更加直观。
  • Zookeeper:
    • Zookeeper最初是为了解决分布式系统中的一致性问题而设计的。Zookeeper提供了一种分布式协调服务,用于在分布式环境中实现配置管理、命名服务、分布式锁等。
    • Zookeeper在提供服务发现的同时,还提供了一个观察者模式,允许节点监听其他节点状态的变化。
    • Zookeeper在分布式系统中的使用场景更广泛,它不仅仅是服务发现,还可以用于实现分布式锁、分布式队列等。

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

  1. 添加Consul依赖:

    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-consul-discovery</artifactId>
    </dependency>
  2. 配置Consul客户端:

    spring:
      application:
        name: service-provider
    server:
      port: 8081
    consul:
      host: localhost
      port: 8500
      registration:
        enabled: true
  3. 创建服务提供者:

    package com.example.demo;
    
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    
    @SpringBootApplication
    public class ServiceProviderApplication {
    
        public static void main(String[] args) {
            SpringApplication.run(ServiceProviderApplication.class, args);
        }
    }
  4. 配置服务消费者:

    spring:
      application:
        name: service-consumer
    server:
      port: 8082
    consul:
      host: localhost
      port: 8500
      registration:
        enabled: false
  5. 创建服务消费者:

    package com.example.demo;
    
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    import org.springframework.cloud.client.discovery.DiscoveryClient;
    import org.springframework.web.bind.annotation.GetMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    @SpringBootApplication
    @RestController
    public class ServiceConsumerApplication {
    
        private final DiscoveryClient discoveryClient;
    
        public ServiceConsumerApplication(DiscoveryClient discoveryClient) {
            this.discoveryClient = discoveryClient;
        }
    
        @GetMapping("/greeting")
        public String greeting() {
            String serviceId = "SERVICE-PROVIDER";
            return discoveryClient.getInstances(serviceId).stream()
                .map(instance -> instance.getUri().toString())
                .findFirst().orElse("Not Found");
        }
    
        public static void main(String[] args) {
            SpringApplication.run(ServiceConsumerApplication.class, args);
        }
    }

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

  1. 添加Zookeeper依赖:

    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-zookeeper-discovery</artifactId>
    </dependency>
  2. 配置Zookeeper客户端:

    spring:
      application:
        name: service-provider
    server:
      port: 8081
    zookeeper:
      connect-string: localhost:2181
  3. 创建服务提供者:

    package com.example.demo;
    
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    
    @SpringBootApplication
    public class ServiceProviderApplication {
    
        public static void main(String[] args) {
            SpringApplication.run(ServiceProviderApplication.class, args);
        }
    }
  4. 配置服务消费者:

    spring:
      application:
        name: service-consumer
    server:
      port: 8082
    zookeeper:
      connect-string: localhost:2181
  5. 创建服务消费者:

    package com.example.demo;
    
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    import org.springframework.cloud.client.discovery.DiscoveryClient;
    import org.springframework.web.bind.annotation.GetMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    @SpringBootApplication
    @RestController
    public class ServiceConsumerApplication {
    
        private final DiscoveryClient discoveryClient;
    
        public ServiceConsumerApplication(DiscoveryClient discoveryClient) {
            this.discoveryClient = discoveryClient;
        }
    
        @GetMapping("/greeting")
        public String greeting() {
            String serviceId = "SERVICE-PROVIDER";
            return discoveryClient.getInstances(serviceId).stream()
                .map(instance -> instance.getUri().toString())
                .findFirst().orElse("Not Found");
        }
    
        public static void main(String[] args) {
            SpringApplication.run(ServiceConsumerApplication.class, args);
        }
    }

负载均衡与Ribbon

负载均衡是将服务请求均匀地分配到多个服务实例上,以提高系统的可用性和资源利用率。Spring Cloud Ribbon是一个基于Netflix Ribbon实现的客户端负载均衡工具,它可以在服务消费端为服务调用提供负载均衡的能力。

Ribbon的基本使用

Ribbon是一个基于客户端的负载均衡器,可以与Eureka等服务注册中心配合使用。Ribbon会从服务注册中心获取服务提供者列表,并通过负载均衡策略选择一个服务实例进行调用。

  1. 添加Ribbon依赖:

    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-netflix-ribbon</artifactId>
    </dependency>
  2. 使用Ribbon进行服务调用:
    在服务消费者端,可以使用Ribbon进行服务调用:

    package com.example.demo;
    
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.cloud.client.loadBalancer.LoadBalancerClient;
    import org.springframework.web.bind.annotation.GetMapping;
    import org.springframework.web.bind.annotation.RestController;
    import org.springframework.web.client.RestTemplate;
    
    @RestController
    public class RibbonClientController {
    
        @Autowired
        private LoadBalancerClient loadBalancerClient;
    
        @Autowired
        private RestTemplate restTemplate;
    
        @GetMapping("/ribbon")
        public String callService() {
            String serviceId = "SERVICE-PROVIDER";
            String serviceUrl = loadBalancerClient.choose(serviceId).getUri().toString();
            return restTemplate.getForEntity(serviceUrl + "/greeting", String.class).getBody();
        }
    }

自定义Ribbon规则

默认情况下,Ribbon使用轮询方式选择服务实例。但如果需要自定义负载均衡策略,可以通过实现IRule接口来实现:

  1. 创建自定义负载均衡规则:

    package com.example.demo;
    
    import com.netflix.loadbalancer.AbstractLoadBalancerRule;
    import com.netflix.loadbalancer.ILoadBalancer;
    import com.netflix.loadbalancer.Server;
    
    import java.util.List;
    import java.util.Random;
    
    public class CustomRandomRule extends AbstractLoadBalancerRule {
    
        private Random random = new Random();
    
        @Override
        public Server choose(Object key) {
            if (key == null) {
                return null;
            }
    
            List<Server> reachableServers = getLoadBalancer().getReachableServers();
            int count = reachableServers.size();
            if (count == 0) {
                return null;
            }
    
            int index = random.nextInt(count);
            return reachableServers.get(index);
        }
    
        @Override
        public void initWithLoadBalancer(ILoadBalancer lb) {
            super.initWithLoadBalancer(lb);
        }
    }
  2. 配置使用自定义规则:

    spring:
      application:
        name: service-consumer
    server:
      port: 8082
    eureka:
      client:
        service-url:
          defaultZone: http://localhost:8761/eureka/
    ribbon:
      NFLoadBalancerRuleClassName: com.example.demo.CustomRandomRule
  3. 使用自定义规则进行服务调用:

    package com.example.demo;
    
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.cloud.client.loadBalancer.LoadBalancerClient;
    import org.springframework.web.bind.annotation.GetMapping;
    import org.springframework.web.bind.annotation.RestController;
    import org.springframework.web.client.RestTemplate;
    
    @RestController
    public class RibbonClientController {
    
        @Autowired
        private LoadBalancerClient loadBalancerClient;
    
        @Autowired
        private RestTemplate restTemplate;
    
        @GetMapping("/ribbon")
        public String callService() {
            String serviceId = "SERVICE-PROVIDER";
            String serviceUrl = loadBalancerClient.choose(serviceId).getUri().toString();
            return restTemplate.getForEntity(serviceUrl + "/greeting", String.class).getBody();
        }
    }
服务熔断与降级

服务熔断与降级是微服务架构中用来提高系统稳定性的关键策略之一。当服务调用出现异常时,熔断器会暂时屏蔽对该服务的调用,防止服务雪崩效应,同时通过降级策略提供备选方案,确保应用程序的可用性和稳定性。

Hystrix工作原理

Hystrix是Netflix开源的一款提供断路器功能的Java库,主要用于处理分布式系统中的延迟和容错问题。Hystrix通过使用断路器模式来管理远程服务调用,当服务调用失败次数超过阈值时,Hystrix会开启断路器,阻止服务调用,防止雪崩效应。

  1. Hystrix的基本概念:

    • 断路器(Circuit Breaker): 断路器监控服务调用,当服务调用失败次数超过阈值时,断路器会进入“打开”状态,阻止服务调用,防止雪崩效应。
    • 隔离(Isolation): Hystrix使用线程池来隔离服务调用,每个依赖服务调用都会在不同的线程池中执行,避免一个服务的慢响应影响其他服务。
    • 超时(Fallback): 当服务调用失败或超时时,Hystrix会执行预先定义的备选方案,返回一个默认值或执行其他逻辑,确保系统可用性。
  2. Hystrix的工作流程:
    • 当客户端发起请求时,Hystrix会在对应的线程池中执行服务调用。
    • 如果线程池已满或服务调用超时,请求将被拒绝,断路器会进入“打开”状态。
    • 当断路器关闭时,请求将正常调用服务;如果服务调用失败,断路器会进入“半开”状态,重新尝试调用服务。
    • 如果服务调用成功,断路器会“关闭”,否则继续保持“打开”状态。

实战:配置Hystrix断路器

接下来通过一个具体的示例来配置Hystrix断路器,确保服务调用的稳定性。

  1. 添加Hystrix依赖:

    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-netflix-hystrix</artifactId>
    </dependency>
  2. 创建服务提供者:
    修改服务提供者的greeting接口,使其偶尔返回错误:

    package com.example.demo;
    
    import org.springframework.cloud.netflix.hystrix.EnableHystrix;
    import org.springframework.web.bind.annotation.GetMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    @EnableHystrix
    @RestController
    public class ServiceProviderApplication {
    
        @GetMapping("/greeting")
        public String greeting() {
            if (Math.random() < 0.5) {
                throw new RuntimeException("Service provider error");
            }
            return "Hello from Service Provider!";
        }
    
        public static void main(String[] args) {
            SpringApplication.run(ServiceProviderApplication.class, args);
        }
    }
  3. 创建服务消费者:
    修改服务消费者的greeting接口,添加Hystrix断路器,并定义备选方案:

    package com.example.demo;
    
    import org.springframework.cloud.netflix.hystrix.EnableHystrix;
    import org.springframework.cloud.netflix.hystrix.HystrixCommand;
    import org.springframework.cloud.netflix.hystrix.HystrixCommandProperties;
    import org.springframework.web.bind.annotation.GetMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    @EnableHystrix
    @RestController
    public class ServiceConsumerApplication {
    
        @GetMapping("/greeting")
        public String greeting() {
            return new HystrixCommand<String>(HystrixCommandProperties.Setter()
                .withExecutionTimeoutEnabled(true)
                .withExecutionTimeoutInMilliseconds(2000)) {
                @Override
                protected String run() {
                    return callService();
                }
    
                @Override
                protected String getFallback() {
                    return "Fallback: Service Provider is down";
                }
            }.execute();
        }
    
        private String callService() {
            String serviceId = "SERVICE-PROVIDER";
            return restTemplate.getForEntity("http://SERVICE-PROVIDER/greeting", String.class).getBody();
        }
    
        public static void main(String[] args) {
            SpringApplication.run(ServiceConsumerApplication.class, args);
        }
    }
  4. 启动服务提供者和服务消费者:
    启动服务提供者和服务消费者应用,测试服务调用,当服务提供者返回错误时,服务消费者将执行备选方案并返回默认值。
配置中心与Spring Cloud Config

在微服务架构中,配置中心是一个非常重要的组件,它负责管理各个微服务的配置信息,使得在不同的环境中快速部署和切换配置。Spring Cloud Config提供了丰富的配置共享和管理功能,可以帮助开发者集中管理应用配置。

配置中心的概念

配置中心本质上是一个存储配置信息的中心化服务。其主要功能包括:

  1. 集中化管理:

    • 将应用的所有配置信息集中存储,便于统一管理。
    • 配置信息可以是环境变量、数据库连接信息、第三方服务的访问参数等。
  2. 版本控制:

    • 配置中心支持版本控制,可以追踪配置的变更历史。
    • 当配置发生变更时,可以回滚到之前的版本。
  3. 环境区分:

    • 支持多环境的配置管理,例如开发环境、测试环境、生产环境。
    • 可以针对不同的环境设置不同的配置信息。
  4. 动态刷新:

    • 支持配置的动态刷新,可以在不重启应用的情况下更新配置信息。
    • 当配置发生变更时,可以通过特定机制通知应用进行配置刷新。
  5. 加密支持:
    • 配置中心可以提供加密支持,确保敏感信息的安全性。
    • 例如,可以对数据库密码、API密钥等敏感信息进行加密存储。

使用Spring Cloud Config共享配置

Spring Cloud Config提供了集中化的配置管理功能,可以将应用的配置信息集中存储在Git仓库或其他存储系统中,并通过Spring Cloud Config Server来提供配置信息的访问服务。

  1. 创建Git仓库:
    在Git仓库中创建一个文件夹,用于存放配置文件。例如:git config/。其中,配置文件的命名规则为application-{profile}.properties,例如application-dev.properties用于开发环境。

  2. 配置Spring Cloud Config Server:
    在Spring Cloud Config Server中配置仓库地址和版本信息:

    spring:
      cloud:
        config:
          server:
            git:
              uri: file:///path/to/config/repo
              username: username
              password: password
              clone-on-start: true
              default-label: master
  3. 创建Spring Cloud Config Client:
    在Spring Cloud Config Client中配置配置中心地址和环境信息:

    spring:
      application:
        name: my-service
      cloud:
        config:
          uri: http://localhost:8888
          profile: dev
          label: master
  4. 服务端与客户端的交互:
    当服务端启动后,会自动从Git仓库中读取配置信息并提供服务。客户端启动时会从服务端获取配置信息,并根据环境变量进行配置加载。

  5. 测试配置共享:
    在客户端中访问配置信息,例如:

    package com.example.demo;
    
    import org.springframework.beans.factory.annotation.Value;
    import org.springframework.web.bind.annotation.GetMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    @RestController
    public class ConfigController {
    
        @Value("${server.port}")
        private String port;
    
        @GetMapping("/config")
        public String getConfig() {
            return "Port: " + port;
        }
    }
入门案例:构建微服务应用

构建微服务应用需要对微服务架构有基本的理解,并针对具体的需求设计服务架构。接下来我们将通过一个简单的案例,展示如何构建一个微服务应用。

设计简单的微服务架构

假设我们需要构建一个在线图书管理系统,系统包括图书列表、图书详情等功能。根据功能不同,我们可以将应用划分为多个微服务,例如:

  • 图书服务(Book Service):

    • 提供图书的增删改查等操作,负责管理图书数据。
  • 作者服务(Author Service):

    • 提供作者的增删改查等操作,负责管理作者数据。
  • 用户服务(User Service):

    • 提供用户的增删查等操作,负责管理用户数据。
  • 前端服务(Frontend Service):
    • 提供Web界面,通过调用其他微服务的接口,展示图书列表、详情等信息。

实战演练:实现一个简单的服务注册与调用

接下来我们将实现一个简单的图书服务和图书详情服务,展示服务注册与调用的过程。

创建图书服务

  1. 配置文件:

    • application.yml中配置服务名称和Eureka注册中心地址:
    spring:
      application:
        name: book-service
    server:
      port: 8081
    eureka:
      client:
        service-url:
          defaultZone: http://localhost:8761/eureka/
  2. 服务实现:

    • 创建一个简单的图书服务,提供图书列表的查询接口:
    package com.example.book;
    
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
    import org.springframework.web.bind.annotation.GetMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    import java.util.Arrays;
    import java.util.List;
    
    @SpringBootApplication
    @EnableEurekaClient
    @RestController
    public class BookServiceApplication {
    
        @GetMapping("/books")
        public List<Book> getBooks() {
            return Arrays.asList(
                new Book(1, "Spring in Action"),
                new Book(2, "Effective Java")
            );
        }
    
        public static void main(String[] args) {
            SpringApplication.run(BookServiceApplication.class, args);
        }
    
        public static class Book {
            private int id;
            private String title;
    
            public Book(int id, String title) {
                this.id = id;
                this.title = title;
            }
    
            public int getId() {
                return id;
            }
    
            public String getTitle() {
                return title;
            }
        }
    }

创建图书详情服务

  1. 配置文件:

    • application.yml中配置服务名称和Eureka注册中心地址:
    spring:
      application:
        name: book-detail-service
    server:
      port: 8082
    eureka:
      client:
        service-url:
          defaultZone: http://localhost:8761/eureka/
  2. 服务实现:

    • 创建一个简单的图书详情服务,通过调用图书服务获取图书列表并展示:
    package com.example.bookdetail;
    
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.cloud.openfeign.FeignClient;
    import org.springframework.cloud.netflix.ribbon.RibbonClient;
    import org.springframework.cloud.netflix.ribbon.RibbonProperties;
    import org.springframework.web.bind.annotation.GetMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    import java.util.List;
    
    @FeignClient(name = "BOOK-SERVICE", url = "http://localhost:8081", configuration = RibbonConfiguration.class)
    public interface BookClient {
    
        @GetMapping("/books")
        List<Book> getBooks();
    }
    
    @RibbonClient(name = "BOOK-SERVICE", configuration = RibbonConfiguration.class)
    public class RibbonConfiguration {
    
    }
    
    @RibbonProperties(name = "BOOK-SERVICE")
    public class RibbonPropertiesCustomizer implements RibbonPropertiesCustomizer {
    
        @Override
        public void customize(RibbonProperties properties) {
            properties.setListOfServers("localhost:8081");
        }
    }
    
    @RestController
    public class BookDetailController {
    
        @Autowired
        private BookClient bookClient;
    
        @GetMapping("/book-detail")
        public List<Book> getBooks() {
            return bookClient.getBooks();
        }
    
        public static class Book {
            private int id;
            private String title;
    
            public Book(int id, String title) {
                this.id = id;
                this.title = title;
            }
    
            public int getId() {
                return id;
            }
    
            public String getTitle() {
                return title;
            }
        }
    }
  3. 添加Feign依赖:

    • pom.xml中添加Feign相关依赖:
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-openfeign</artifactId>
    </dependency>
  4. 启动服务:
    • 启动图书服务和图书详情服务,确保它们能够正确注册到Eureka Server。
    • 在图书详情服务中访问/book-detail,展示从图书服务获取的图书列表。
点击查看更多内容
TA 点赞

若觉得本文不错,就分享一下吧!

评论

作者其他优质文章

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

100积分直接送

付费专栏免费学

大额优惠券免费领

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

举报

0/150
提交
取消