Spring Cloud 微服务注册与发现实验

Eureka项目 23 分钟 读完 (约 3482 字)

Spring Cloud Eureka 组件详解。

Prerequisites

JDK 1.8
IDE
Tomcat

初探：Spring Boot 启动 Eureka Server 和 Eureka Client微服务

The first one is the server which needs only Eureka Server dependency.
Spring Initializr > (Repo location chooses: https://start.aliyun.com/) Generate a Maven Project > Group: com.ustb > Artifact: service-registration-and-discovery-service > Dependencies: Eureka Server

Then second one(a client) requires both Eureka Server and Eureka Discovery Client dependencies.

开启一个 Eureka 服务注册

eureka-server.png
简单地使用注解就可以了，另外需要在application.properties中进行配置

与注册中心对话

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
package com.example.serviceregistrationanddiscoveryclient;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.ServiceInstance;
import org.springframework.cloud.client.discovery.DiscoveryClient;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.*;

@SpringBootApplication
@EnableDiscoveryClient
public class DemoApplication {

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

}

@RestController
class ServiceInstanceRestController {
	@Autowired
	private DiscoveryClient discoveryClient;

	@RequestMapping("/service-instances/{applicationName}")
	public List<ServiceInstance> serviceInstancesByApplicationName(
		@PathVariable String applicationName) {
			return this.discoveryClient.getInstances(applicationName);
		}
}

这里通过注解EnableDiscoveryClient来继承注册微服务的接口

在类中通过注解@RequestMapping(“/service-instances/{applicationName}”) 提供该client的访问接口

提供服务

微服务有两种方法注册到 Eureka 中心，一种是本地启动的Spring Boot程序添加注解 @EnableDiscoveryClient；
第二种是在配置文件中添加 defaultZone: 后加Eureka中心的地址（http://localhost:8761/eureka）

要想从Eureka中心获取可用的微服务，默认的XML方式解析起来比较麻烦。我们可以通过在Eureka里写一个 discoveryClient 的 controller来实现。
配置里写 eureka.client.fetch-registry=true。
但同时又不想 eureka server 自己也被其他服务发现，这时需要配置 eureka.client.register-with-eureka=false

注意：Spring Cloud Gateway 依赖和 Spring Web不能同时添加

学习：源码启动 Eureka Server， Eureka Client 和微服务

安装

1. IDEA选2019.2-2020.1 的版本 ； jdk1.8 ; Tomcat 8/9

2. 注册码云帐号，然后克隆项目：

1
git clone -b web3 --single-branch https://gitee.com/Shane1501/eureka.git

IDEA 打开项目确认已切换到 web3 分支
git-web3.png

3. 配置gradle

把项目根目录下的 build.gradle.IDEA版本号（我是 build.gradle.IDEA2019.3） 拷贝一份新的改为 build.gradle

1
cp build.gradle.IDEA2019.3 build.gradle

gradle-build.png

（可以选用用阿里云镜像，把下面文件保存成 init.gradle 放到 USER 目录下的 .gradle 文件夹里）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
allprojects{
    repositories {
        def ALIYUN_REPOSITORY_URL = 'https://maven.aliyun.com/repository/public/'
        def ALIYUN_JCENTER_URL = 'https://maven.aliyun.com/repository/jcenter/'
        def ALIYUN_GOOGLE_URL = 'https://maven.aliyun.com/repository/google/'
        def ALIYUN_GRADLE_PLUGIN_URL = 'https://maven.aliyun.com/repository/gradle-plugin/'
        all { ArtifactRepository repo ->
            if(repo instanceof MavenArtifactRepository){
                def url = repo.url.toString()
                if (url.startsWith('https://repo1.maven.org/maven2/')) {
                    project.logger.lifecycle "Repository ${repo.url} replaced by $ALIYUN_REPOSITORY_URL."
                    remove repo
                }
                if (url.startsWith('https://jcenter.bintray.com/')) {
                    project.logger.lifecycle "Repository ${repo.url} replaced by $ALIYUN_JCENTER_URL."
                    remove repo
                }
                if (url.startsWith('https://dl.google.com/dl/android/maven2/')) {
                    project.logger.lifecycle "Repository ${repo.url} replaced by $ALIYUN_GOOGLE_URL."
                    remove repo
                }
                if (url.startsWith('https://plugins.gradle.org/m2/')) {
                    project.logger.lifecycle "Repository ${repo.url} replaced by $ALIYUN_GRADLE_PLUGIN_URL."
                    remove repo
                }
            }
        }
        maven { url ALIYUN_REPOSITORY_URL }
        maven { url ALIYUN_JCENTER_URL }
        maven { url ALIYUN_GOOGLE_URL }
        maven { url ALIYUN_GRADLE_PLUGIN_URL }
    }
}

导入
import-gradle

4. 配置 Tomcat

/home/wsd/Clouds/Hexo-blog/source/_posts/2020-07-11-Swagger-tutorial/tomcat1.png
在Tomcat启动时添加

1
2
-Deureka.waitTimeInMsWhenSyncEmpty=0
-Deureka.numberRegistrySyncRetries=0

以加快 eureka 启动速度。
tomcat-vm-options.png

或直接修改 eureka-server/src/main/resources/eureka-server.properties 文件，取消配置注释

1
2
eureka.waitTimeInMsWhenSyncEmpty=0
eureka.numberRegistrySyncRetries=0

也可达到同样效果。
修改eureka-server.properties

配置war包exploded模式可以方便运行时实时更新配置。
/home/wsd/Clouds/Hexo-blog/source/_posts/2020-07-11-Swagger-tutorial/tomcat2.png

6. 点击启动Tomcat，会弹出eureka界面

/home/wsd/Clouds/Hexo-blog/source/_posts/2020-07-11-Swagger-tutorial/eureka.png
源码编译即告完成。

Eureka 源码解析

服务发现组件 package com.netflix.discovery

v1.1版本
DiscoveryClient.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
/**
	* Makes remote calls with the corresponding action(register,renew etc).
	*
	* @param action
	*            the action to be performed on eureka server.
	*
	*            Try the fallback servers in case of problems communicating to
	*            the primary one.
	*
	* @return ClientResponse the HTTP response object.
	* @throws Throwable
	*             on any error.
	*/
private ClientResponse makeRemoteCall(Action action, int serviceUrlIndex) throws Throwable {
	......
}

接收端： package com.netflix.eureka;
RemoteRegionRegistry.java

1
2
3
public RemoteRegionRegistry(String regionName, URL remoteRegionURL) {
	......
}

那么，一个 InstanceInfo 实例是如何产生的呢？
com/netflix/eureka/ExampleEurekaService.java

1
43	InstanceInfo instanceInfo = new EurekaConfigBasedInstanceInfoProvider(instanceConfig).get();

com/netflix/appinfo/providers/EurekaConfigBasedInstanceInfoProvider.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
84	builder.setNamespace(config.getNamespace())
                    .setInstanceId(instanceId)
                    .setAppName(config.getAppname())
                    .setAppGroupName(config.getAppGroupName())
                    .setDataCenterInfo(config.getDataCenterInfo())
                    .setIPAddr(config.getIpAddress())
                    .setHostName(defaultAddress)
                    .setPort(config.getNonSecurePort())
                    .enablePort(PortType.UNSECURE, config.isNonSecurePortEnabled())
                    .setSecurePort(config.getSecurePort())
                    .enablePort(PortType.SECURE, config.getSecurePortEnabled())
                    .setVIPAddress(config.getVirtualHostName())
                    .setSecureVIPAddress(config.getSecureVirtualHostName())
                    .setHomePageUrl(config.getHomePageUrlPath(), config.getHomePageUrl())
                    .setStatusPageUrl(config.getStatusPageUrlPath(), config.getStatusPageUrl())
                    .setASGName(config.getASGName())
                    .setHealthCheckUrls(config.getHealthCheckUrlPath(),
                            config.getHealthCheckUrl(), config.getSecureHealthCheckUrl());


125	instanceInfo = builder.build();
    instanceInfo.setLeaseInfo(leaseInfoBuilder.build());

而config的来源则是
com/netflix/eureka/ExampleEurekaService.java

1
61 DynamicPropertyFactory configInstance = com.netflix.config.DynamicPropertyFactory.getInstance();

com/netflix/config/DynamicPropertyFactory.java

1
2
279	initWithConfigurationSource(configFromManager);
280	initializedWithDefaultConfig = !ConfigurationManager.isConfigurationInstalled();

jsp修改后不立即更新，应改为exploded war
报错：

1
Artifact Gradle : com.netflix.eureka : eureka-server-1.9.26-SNAPSHOT.war (exploded): Error during artifact deployment. See server log for details.

获取 eureka/v2/apps/{appId} 下的xml解析

com.netflix.eureka.registry.ResponseCacheImpl.java

1
private final ConcurrentMap<Key, Value> readOnlyCacheMap
1
2
payload = readWriteCacheMap.get(key);
readOnlyCacheMap.put(key, payload);

如果想往 app 的xml里添加字段（原有字段为appName和instances），即所链接的 合约地址列表
需要从 readWriteCacheMap 里读取，然后往 readOnlyCacheMap 里 put payload（此payload里包含app信息）

generatePayload 里

1
payload = getPayLoad(key, registry.getApplication(key.getName()));

getPayLoad 函数对对象文件做一个 对象 到string的解析，而解析的对象就是 registry.getApplication(key.getName())

里面的解析用converter写在Converters.java 函数里

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
/**
    * Serialize/deserialize {@link Applications} object types.
    */
public static class ApplicationConverter implements Converter {

    private static final String ELEM_NAME = "name";

    /*
        * (non-Javadoc)
        *
        * @see
        * com.thoughtworks.xstream.converters.ConverterMatcher#canConvert(java
        * .lang.Class)
        */
    public boolean canConvert(@SuppressWarnings("rawtypes") Class clazz) {
        return Application.class == clazz;
    }

    /*
        * (non-Javadoc)
        *
        * @see
        * com.thoughtworks.xstream.converters.Converter#marshal(java.lang.Object
        * , com.thoughtworks.xstream.io.HierarchicalStreamWriter,
        * com.thoughtworks.xstream.converters.MarshallingContext)
        */
    @Override
    public void marshal(Object source, HierarchicalStreamWriter writer,
                        MarshallingContext context) {
        Application app = (Application) source;

        writer.startNode(ELEM_NAME);
        writer.setValue(app.getName());
        writer.endNode();

        for (InstanceInfo instanceInfo : app.getInstances()) {
            writer.startNode(NODE_INSTANCE);
            context.convertAnother(instanceInfo);
            writer.endNode();
        }
    }

    /*
        * (non-Javadoc)
        *
        * @see
        * com.thoughtworks.xstream.converters.Converter#unmarshal(com.thoughtworks
        * .xstream.io.HierarchicalStreamReader,
        * com.thoughtworks.xstream.converters.UnmarshallingContext)
        */
    @Override
    public Object unmarshal(HierarchicalStreamReader reader,
                            UnmarshallingContext context) {
        Application app = new Application();

        while (reader.hasMoreChildren()) {
            reader.moveDown();

            String nodeName = reader.getNodeName();

            if (ELEM_NAME.equals(nodeName)) {
                app.setName(reader.getValue());
            } else if (NODE_INSTANCE.equals(nodeName)) {
                app.addInstance((InstanceInfo) context.convertAnother(app,
                        InstanceInfo.class));
            }
            reader.moveUp();
        }
        return app;
    }
}

Renew 操作

InstanceResource.java 里的 Renew 接口

1
2
3
@PUT
public Response renewLease(
    boolean isSuccess = registry.renew(app.getName(), id, isFromReplicaNode);

PeerAwareInstanceRegistryImpl.java

1
2
3
4
5
6
7
public boolean renew(final String appName, final String id, final boolean isReplication) {
        if (super.renew(appName, id, isReplication)) {
            replicateToPeers(Action.Heartbeat, appName, id, null, null, isReplication);
            return true;
        }
        return false;
    }

AbstractInstanceRegistry.java

1
2
public boolean renew(String appName, String id, boolean isReplication) {
    ...

Status Update 操作

InstanceResource.java

1
2
3
4
5
6
7
@PUT
@Path("status")
public Response statusUpdate(

        boolean isSuccess = registry.statusUpdate(app.getName(), id,
                    InstanceStatus.valueOf(newStatus), lastDirtyTimestamp,
                    "true".equals(isReplication));

目前的状态数
InstanceInfo.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public enum InstanceStatus {
    UP, // Ready to receive traffic
    DOWN, // Do not send traffic- healthcheck callback failed
    STARTING, // Just about starting- initializations to be done - do not
    // send traffic
    OUT_OF_SERVICE, // Intentionally shutdown for traffic
    UNKNOWN;

    public static InstanceStatus toEnum(String s) {
        if (s != null) {
            try {
                return InstanceStatus.valueOf(s.toUpperCase());
            } catch (IllegalArgumentException e) {
                // ignore and fall through to unknown
                logger.debug("illegal argument supplied to InstanceStatus.valueOf: {}, defaulting to {}", s, UNKNOWN);
            }
        }
        return UNKNOWN;
    }
}

PeerAwareInstanceRegistryImpl.java

1
2
3
4
5
6
7
8
9
10
@Override
public boolean statusUpdate(final String appName, final String id,
                            final InstanceStatus newStatus, String lastDirtyTimestamp,
                            final boolean isReplication) {
    if (super.statusUpdate(appName, id, newStatus, lastDirtyTimestamp, isReplication)) {
        replicateToPeers(Action.StatusUpdate, appName, id, null, newStatus, isReplication);
        return true;
    }
    return false;
}

AbstractInstanceRegistry.java

1
2
3
4
5
@Override
    public boolean statusUpdate(String appName, String id,
                                InstanceStatus newStatus, String lastDirtyTimestamp,
                                boolean isReplication) {
        ......

v1.9.26 版本

服务发现模块 com.netflix.discovery

服务发现模块通过 Jersey 框架实现了 RESTful 风格访问的 http 客户端，定义在 eureka-client/src/main/java/com/netflix/discovery/DiscoveryClient.java 中。

RESTful(REpresentational State Transfer, 表现层状态转移) 是一种架构风格。它不再使用以往的 php, jsp 架构，而是将前后端明确分工，前端（Web端、客户端、app和第三方开发者）负责渲染和附带处理简单的商务逻辑，后端（Server端）负责处理资源和数据，前后端通过统一的API接口调用来进行交互，接口Uri面向资源为核心进行设计而不是操作。

DiscoveryClient 的职责主要包括：
a) 注册微服务实例到 Eureka Server
b) 向 Eureka Server 更新微服务租约
c) 服务关闭的时候进行租约取消
d) 查询注册到 Eureka Server 中的服务/实例信息

Eureka 自身是可以作为一个微服务实例注册到自己的列表中的，通过配置文件中选项eureka.client.register-with-eureka为true或者false来决定是否注册到自己的列表中。

三级缓存

全量拉取与增量拉取

整体架构设计采用 MVC 模式

Model：业务逻辑层，包括 InstanceInfo.java EurekaServerConfig.java eureka-core的registry文件夹下的InstanceRegistry.java
View：bootstrap
Control：各种resource文件，包括Application(s)Resource.java Instance(s)Resource.java

Register操作为例：
接收Register请求的处理类有ApplicationResource.java下的 addInstance
AbstractInstanceRegistry.java 下的 register 函数

而发送Register请求的是 DiscoveryClient.java 下的 register

873 httpResponse = eurekaTransport.registrationClient.register(instanceInfo);

EurekaHttpClientDecorator.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
@Override
public EurekaHttpResponse<Void> register(final InstanceInfo info) {
    return execute(new RequestExecutor<Void>() {
        @Override
        public EurekaHttpResponse<Void> execute(EurekaHttpClient delegate) {
            return delegate.register(info);
        }

        @Override
        public RequestType getRequestType() {
            return RequestType.Register;
        }
    });
}

调用的是 EurekaHttpClient 下的 register 函数。

java/com/netflix/discovery/shared/transport/jersey/AbstractJerseyEurekaHttpClient.java

做的一些尝试（Deprecated）

为 Application 类添加一个服务提供商 party 的步骤

  1. 在 com.netflix.discovery.shared.Application 类定义中添加 String party 属性，并添上 getter setter toString 方法
  2. 在 com.netflix.discovery.converters.EurekaJacksonCodec 类中定义要解析的属性名：
    public static final String NODE_PARTY = “party”;

在 ApplicationSerializer 子类中添加对 party 属性的序列化处理：
jgen.writeObjectField(NODE_PARTY, value.getParty());

在 ApplicationDeserializer 子类中添加从json到对象的反序列化处理：

1
2
3
4
5
6
enum ApplicationField {
    NAME(ELEM_NAME), INSTANCE(ELEM_INSTANCE), PARTY(NODE_PARTY);
}
case PARTY:
    application.setParty(jp.getText());
    break;
  1. 在 com.netflix.discovery.converters.Converters 类的 ApplicationConverter 子类中定义：
    public static final String NODE_PARTY = “party”;

在 marshal 方法添加：

1
2
3
writer.startNode(NODE_PARTY);
writer.setValue(app.getParty());
writer.endNode();

为了 XStream 解析对象至 str 使用。

unmarshal方法：

1
2
} else if (NODE_PARTY.equals(nodeName)) {
    app.setParty(reader.getValue());

将 str 解析到app中的对象

  1. 在 com.netflix.discovery.converters.jackson.serializer.ApplicationXmlDeserializer 类中 deserialize 方法中添加：
    1
    2
    } else if ("party".equals(fieldName)) {
        party = jp.getValueAsString();

在测试过程中使用XStreamXml 序列化后 party = null， JacksonXml 反序列化的时候，由于 party 为空，
传给 writeText(String text, boolean isAttribute) 的参数 text 为空，而后面又调用
int length = text.length();
导致抛出 NullPointerException. 解决办法，重写Application类的getter和setter为：

1
2
3
4
5
6
7
8
9
10
11
public String getParty() {
    if (null == party) {
        party = "";
    }
    return party;
}

public void setParty(String party) {
    if (null == party) return ;
    this.party = party;
}

多级缓存机制

Eureka Server 使用registry, readWriteCacheMap, readOnlyCacheMap 三个变量保存服务注册信息。默认情况下，定时任务每 30s 将 readWriteCacheMap 同步至 readOnlyCacheMap，每 60s 清理清理超过 90s 未续约的节点。Jsp UI 从 registry 更新服务注册信息
Eureka Client 使用 localRegionApps 和 upServerListZoneMap 两个变量保存服务注册信息，每 30s 从 readOnlyCacheMap 更新服务注册信息。

微服务实例对自己的四种接口操作

Register, Status Update, Renew 和 Cancel 四种操作。
接口都写在 eureka-core/src/main/java/com/netflix/eureka/registry/resources/InstanceResource.java
四个操作都是直接更新 registry

Register注册动作

Renew 续约

Contract status update 操作的算法描述

输入：服务名appName，服务实例信息instanceInfo，合约参与方contractParty，时间戳 timestamp
输出：true/false/异常

  1. 检查当前实例信息的状态status是否为 UP，若不满足，则返回false退出;若满足条件，则继续下一步；
  2. 将服务app名称作为 key 查找注册信息，返回类型为 Map<String, Lease> 的服务注册信息gMap，其中 String 储存服务实例id，Lease 储存上一次服务实例的租约信息；
  3. 若当前时间戳早于gMap中的时间戳，则返回false退出；若当前时间戳晚于gMap中的时间戳，则继续下一步；
  4. instanceInfo 中设置合约参与方属性为 contractParty，开启状态更改动作，设置即将更新的状态 overriddenStatus = IN_CONTRACT；
  5. 将当前租约信息 lease 加入更新队列；
  6. 更新instanceInfo 中的时间戳；
  7. 广播至其他节点，进行更新；若更新出错，则返回异常信息。
  8. 读取更新队列，设置服务实例信息中 status = overriddenStatus
  9. 所有节点执行完毕，状态更新结束，返回 true

jsp 无法识别包依赖自动补全问题

jsp-resolve.png
Then invalidate caches/Restart.
未解决

Spring Cloud Eureka

spring-cloud-netflix-eureka-server 源码阅读

eureka 1.0 之后 Netflix 公司继续开发 2.0。
1.0交由社区维护，Spring Cloud 团队看到了项目的价值，移植过来成为了 Spring Cloud Eureka 组件。

根据前面的实验我们已经知道，在Spring Cloud中开启一个Eureka服务非常方便，通过添加注解 @EnableEurekaServer 即可实现。那么内部原理是怎样的呢。

进入 EnableEurekaServer 所在的源码jar包我们看到：
EnableEurekaServer.java

1
2
3
4
5
6
7
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import(EurekaServerMarkerConfiguration.class)
public @interface EnableEurekaServer {

}

@Import 注解表示一旦添加了 @EnableEurekaServer 注解，就往spring容器中导入一个 EurekaServerMarkerConfiguration 类的bean，继续看
EurekaServerMarkerConfiguration.java

1
2
3
4
5
6
7
8
9
10
11
12
13
@Configuration(proxyBeanMethods = false)
public class EurekaServerMarkerConfiguration {

	@Bean
	public Marker eurekaServerMarkerBean() {
		return new Marker();
	}

	class Marker {

	}

}

看到这里可能会觉得没法继续进行下去了。
如果打开 EurekaServerAutoConfiguration.java

1
2
3
4
5
6
7
8
9
@Configuration(proxyBeanMethods = false)
@Import(EurekaServerInitializerConfiguration.class)
@ConditionalOnBean(EurekaServerMarkerConfiguration.Marker.class)
@EnableConfigurationProperties({ EurekaDashboardProperties.class,
		InstanceRegistryProperties.class })
@PropertySource("classpath:/eureka/server.properties")
public class EurekaServerAutoConfiguration implements WebMvcConfigurer {
    ......
}

看到了 @ConditionalOnBean(EurekaServerMarkerConfiguration.Marker.class)，豁然开朗。

原理就是通过在spring.factories中写入

1
2
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
  org.springframework.cloud.netflix.eureka.server.EurekaServerAutoConfiguration

eureka-server-jar.png
在启动SpringBoot时根据条件决定是否新建 EurekaServerAutoConfiguration 对象。
该对象的创建条件是通过 @ConditionalOnBean 注解监听容器中是否引入了 EurekaServerMarkerConfiguration.Marker 对象。
如果spring boot程序中添加了 @EnableEurekaServer 注解，那么根据 @Import(EurekaServerMarkerConfiguration.class)， 该注解就会激活 EurekaServerMarkerConfiguration 中的 @Bean public Marker eurekaServerMarkerBean()，从而返回一个 EurekaServerMarkerConfiguration.Marker 对象，进而触发 EurekaServerAutoConfiguration 对象的创建条件，启动EurekaServer。
如果spring boot程序中没有添加 @EnableEurekaServer 注解，那么EurekaServerAutoConfiguration 对象的创建条件未被触发，EurekaServer也就不启动了。

#VS Code #Spring #Spring Cloud #Microservices #Nacos
安卓搞机指南 - Termux Translation of Bitcoin notes

评论

You forgot to set the shortname for Disqus. Please set it in _config.yml.
Your browser is out-of-date!

Update your browser to view this website correctly. Update my browser now

×