Spring Cloud_3_微服务发布与调用

最新推荐文章于 2024-07-30 15:29:38 发布

'嗯哼。

最新推荐文章于 2024-07-30 15:29:38 发布

阅读量3.9w

点赞数 1

分类专栏： Java Spring Cloud 文章标签： SpringCloud 分布式 Eureka 微服务

本文链接：https://blog.csdn.net/zhaozao5757/article/details/79354626

版权

Spring Cloud 同时被 2 个专栏收录

34 篇文章 37 订阅

订阅专栏

Java

17 篇文章 0 订阅

订阅专栏

微服务发布与调用

认识Eureka框架
运行Eureka服务器
发布微服务
调用微服务
本章将讲述SpringCloud中Eureka的使用，包括在Eureka服务器上发布、调用微服务，Eureka的配置以及集群等内容

1、Eureka介绍

提供了Eureka服务器端与客户端
主要用于服务管理（维护服务列表，自动检查其状态）
SpringCloud集成了Netflix OSS的多个项目，形成了Spring-Cloud-Netflix项目，该项目包含了多个子模块，这些子模块对集成的Netflix旗下框架进行了封装
Spring Cloud Netflix提供了一系列搭建微服务基础架构的功能组件
1. Eureka（服务注册与发现框架）
2. Hystrix（服务容错组件）：容错管理工具，旨在通过控制服务和第三方库的节点，从而对延迟和故障提供强大的容错能力
3. Zuul（服务网关）：边缘服务工具，提供动态路由、监控等边缘服务
4. Ribbon（客户端负载均衡器）：提供客服端负载均衡算法，将Netflix的中间层服务连接起来
5. Feign（声明式Http客户端）：可以创建声明式、模板化的Http客户端，进行微服务调用
本小节将讲述其中一个较为重要的服务管理框架：Eureka[juˈri:kə]

1.1、关于Eureka

一个基于REST风格的服务组件，用于定位服务，以实现云端的负载均衡和中间层服务器的故障转移
提供了基于Java的客户端组件，使得与服务的交互更加方便
客户端还有一个内置的负载均衡器，用于执行基本的轮询负载均衡，为业务组件的集群部署创造了条件
使用该框架，可以将业务组件注册到Eureka容器中，进行集群部署
Eureka提供服务调用功能，可以发布容器中的服务并进行调用

1.2、Eureka架构

一个简单的Eureka集群，需要一个Eureka服务器、若干个服务提供者
将业务组件注册到Eureka服务器中，其他客户端组件可以向服务器获取服务并且进行远程调用

图中有两个服务器，服务器支持集群部署，每个服务器也可以作为对方服务器的客户端进行相互注册与复制
3个Eureka客户端，2个用于发布服务，1个用于调用服务
不管是服务器还是客户端，都可以部署多个实例，因此，就很容易构建高可用的服务集群

Eureka服务器（114电话查询平台）
Eureka客户端服务提供者（医院、警察局电话放置114电话查询平台）
Eureka客户端服务调用者（查询电话的我们）
我们去114平台查询某处电话号码（服务查找），得到电话号码后（获取注册信息），拨打电话（服务调用）

Eureka Server实例作为服务注册中心的角色，负责接收来自Eureka Client的服务注册，并加以保存
Eureka Client内嵌于一个微服务中，会将当前实例作为服务实例注册中心（Eureka Server），注册内容包括IP、Port和服务实例名称
消费者同样内嵌了Eureka Client，在进行微服务调用的时候，可以通过Eureka提供的DiscoveryClient和服务实例的名称，从服务注册中心（Eureka Server）获取服务实例列表，然后得到服务实例的IP和Port，以完成服务调用

1.3、服务器端

对于注册到服务器的服务组件，Eureka服务器并没有提供后台的存储，这些注册的服务实例被保存在内存的服务注册中心，它们通过心跳来保持其最新状态，这些操作都可以在内存中完成。
客户端存在相同的机制，同样在内存中保存了注册表信息，这样的机制提升了Eureka组件性能，每次服务的请求都不用经过服务器端的注册中心。

1.4、服务提供者

作为Eureka客户端存在的服务提供者，主要进行以下工作：
第一：向服务器注册服务
第二：发送心跳给服务器
第三：向服务器端获取注册列表
当客户端注册到服务器时，它将会提供一些关于它自己的信息给服务器端，例如：IP、Port、健康链接等

1.5、服务调用者

对于发布到Eureka服务器的服务，使用调用者可对其进行服务查找和调用，服务调用者也是作为客户端存在，但是其职责主要是发现和调用服务。
在实际情况中，有可能出现本身既是服务提供者，又是服务调用者的情况，例如：传统的企业应用三层架构中，服务层（service）会调用数据访问层（dao）的接口进行数据操作，它本身也会提供服务给控制层（controller）使用。

2、Eureka应用

2.1、构建服务器

创建一个maven项目：atm-eureka-server

2.1.1、添加依赖

在pom.xml中添加Spirng Cloud的依赖

<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/maven-v4_0_0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.atm.cloud</groupId>
  <artifactId>atm_enreka_server</artifactId>
  <packaging>war</packaging>
  <version>0.0.1-SNAPSHOT</version>
  <name>atm_enreka_server Maven Webapp</name>
  <url>http://maven.apache.org</url>

  <!-- Spring Cloud -->
  <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>Dalston.SR1</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>3.8.1</version>
      <scope>test</scope>
    </dependency>


    <!--不需要再引入-->
    <!--
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    -->

     <!--Eureka-->
     <!--
        加入的spring-cloud-starter-eureka-server会自动引入spring-boot-starter-web
        因此只需要加入该依赖，我们的项目就具有 Web 容器的功能
     -->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-eureka-server</artifactId>
    </dependency>


  </dependencies>

  <build>
    <finalName>atm_enreka_server</finalName>
  </build>
</project>

2.1.2、编写启动类

package com.atm.cloud;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer;

@SpringBootApplication
@EnableEurekaServer
public class MyApplicationServer {

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

}

可以发现与SpringBoot的启动类基本没有差异，只是加入了@EnableEurekaServer，声明这是一个 Eureka 服务器。直接运行 FirstServer 即可启动 Eureka 服务器
application.yml（Eureka默认 localhost:8761）

server:
  port: 8761

执行main方法，启动，虽然启动成功，但是出现了异常

异常暂时不管，先进行访问

可以看到服务的实例列表，目前我们并没有注册服务，因此列表为空

2.1.3、服务器注册开关（解决异常）

在上面我们已经发现，启动的时候会出现异常
这是由于在服务器启动时，服务器会把自己当作一个客户端，去 Eureka 服务器注册，并且会到 Eureka 服务器抓取注册信息，它自己本身只是一个服务器，而不是服务的提供者（客户端），因此可以修改application.yml 文件，修改以下两个配置：

server:
  port: 8761

eureka:
 client:
  registerWithEureka: false
  fetchRegistry: false

2.2、编写服务提供者

新创建一个maven项目：atm_eureka_provider

2.2.1、添加依赖

<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/maven-v4_0_0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.atm.cloud</groupId>
    <artifactId>atm_enreka_provider</artifactId>
    <packaging>war</packaging>
    <version>0.0.1-SNAPSHOT</version>
    <name>atm_enreka_provider Maven Webapp</name>
    <url>http://maven.apache.org</url>

    <!-- Spring Cloud -->
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>Dalston.SR1</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>3.8.1</version>
            <scope>test</scope>
        </dependency>

        <!-- 服务提供者 -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-config</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-eureka</artifactId>
        </dependency>
        <!-- 服务提供者 -->

    </dependencies>
    <build>
        <finalName>atm_enreka_provider</finalName>
    </build>
</project>

2.2.2、配置文件

server:
 port: 8080
spring:
 application:
  name: first-service-provider  
eureka:
 client:
  serviceUrl:
   defaultZone: http://localhost:8761/eureka/
 instance:
  hostname: localhost

defaultZone: http://localhost:8761/eureka/，让客户端知道去哪里注册

2.2.3、编写控制器

Person类

package com.atm.cloud;

public class Person {

    private Integer id;

    private String name;

    private Integer age;

    //...省略setter/getter...
}

MyController类

package com.atm.cloud;

import org.springframework.http.MediaType;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class MyController {


    @RequestMapping(value = "/info", method = RequestMethod.GET,
            produces = MediaType.APPLICATION_JSON_VALUE)
    public Person findPerson(){
        Person person=new Person();

        person.setId(1);
        person.setAge(18);
        person.setName("atm");

        return person;
    }

    @RequestMapping(value = "/person/{personId}", method = RequestMethod.GET,
            produces = MediaType.APPLICATION_JSON_VALUE)
    public Person findPerson(@PathVariable("personId")Integer personId){
        Person person=new Person();

        person.setId(personId);
        person.setAge(18);
        person.setName("atm");

        return person;
    }
}

2.2.4、编写启动类

@EnableEurekaClient，默认注册到8761的服务器上

package com.atm.cloud;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;

@SpringBootApplication
@EnableEurekaClient
public class MyApplicationProvider {

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

}

启动服务器MyApplicationServer、启动服务提供者MyApplicationProvider

2.3、编写服务调用者

服务被注册、发布到Euraka服务器后，就需要程序去发现它，并且进行调用
此处所说的调用者，是指同样注册到Eureka的客户端，来调用其他客户端发布的服务，简单来说，就是Eureka内部调用
由于同一个服务，可能会部署多个实例，调用过程可能涉及负载均衡，服务器查找等问题，Netflix已经帮我们解决了这个问题，并且SpringCloud已经封装了一次
创建新maven项目：atm_eureka_invoker

2.3.1、添加依赖

<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/maven-v4_0_0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.atm.cloud</groupId>
    <artifactId>atm_enreka_invoker</artifactId>
    <packaging>war</packaging>
    <version>0.0.1-SNAPSHOT</version>
    <name>atm_enreka_invoker Maven Webapp</name>
    <url>http://maven.apache.org</url>

    <!-- Spring Cloud -->
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>Dalston.SR1</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>3.8.1</version>
            <scope>test</scope>
        </dependency>

        <!-- 服务调用者 -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-config</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-eureka</artifactId>
        </dependency>
        <dependency><!-- 负载均衡框架 -->
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-ribbon</artifactId>
        </dependency>
        <!-- 服务调用者 -->

    </dependencies>
    <build>
        <finalName>atm_enreka_invoker</finalName>
    </build>
</project>

2.3.2、配置文件

server:
 port: 9000
spring:
 application:
  name: first-service-invoker
eureka:
 instance:
  hostname: localhost
 client:
  serviceUrl:
   defaultZone: http://localhost:8761/eureka/

在配置文件中，配置了应用名称为 “first-service-invoker”，这个调用者的访问端口为9000，需要注意的是，这个调用本身也可以对外提供服务
与提供者一样，使用eureka的配置，将调用者注册到“atm_enreka_server”

2.3.3、编写控制器

package com.atm.cloud;

import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.MediaType;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

@RestController
@Configuration
public class InvokerController {

    @Bean
    @LoadBalanced
    public RestTemplate getRestTemplate() {
        return new RestTemplate();
    }

    @RequestMapping(value="/router",method=RequestMethod.GET,
            produces=MediaType.APPLICATION_JSON_VALUE)
    public String router() {
        RestTemplate restTemplate = getRestTemplate();

        // 根据应用名称调用服务
        String json = restTemplate.getForObject(
                "http://first-service-provider/person/1", String.class);

        return json;
    }
}

在控制器中，配置了RestTemplate的bean，RestTemplate本来是spring-web模块下的类，主要用调用REST服务，本身并不具备调用分布式服务的能力，但是RestTemplate的bean被@LoadBalanced注解修饰后，这个RestTemplate实例就具备访问分布式服务的能力

2.3.4、编写启动类

在控制器中，新建了一个router的测试方法，用来对外发布REST服务，该方法只是一个路由的作用
实际上，使用RestTemplate来调用“first-service-provider”（服务者提供）的服务
需要注意的是，仅仅是通过服务名称来进行调用

package com.atm.cloud;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;

@SpringBootApplication
@EnableDiscoveryClient
public class MyApplicationInvoker {

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

}