Spring Cloud Dalston.SR5 英文PDF文档：带书签的云原生应用指南

官方文档

需积分: 10 12 浏览量更新于2024-07-18 收藏 2.51MB PDF 举报

身份认证购VIP最低享 7 折!

领优惠券(最高得80元）

“Spring Cloud文档PDF版（带书签），版本：Dalston.SR5，英文版，包含了Spring Cloud的相关功能和组件的详细说明。” 本文档是Spring Cloud Dalston.SR5版本的官方英文版，提供了关于Spring Cloud生态系统的全面指南。Spring Cloud是一个框架集合，用于简化构建微服务应用的过程，它提供了很多服务发现、配置管理、断路器模式等关键功能。 1. 主要特性 - 文档涵盖了Spring Cloud支持云原生应用的特性，这包括对分布式系统和微服务架构的支持。 2. Spring Cloud Context：应用上下文服务 - Bootstrap ApplicationContext：在主应用上下文启动之前运行，用于加载配置服务器的配置，使得在应用启动时就可以获取远程配置。 - ApplicationContext Hierarchies：讨论了如何组织多个应用上下文层次，以便更好地管理和隔离不同层次的配置。 - Changing the Location of Bootstrap Properties：解释如何自定义引导层属性的位置。 - Overriding the Values of Remote Properties：介绍如何覆盖远程配置服务器中的属性值。 - Customizing the Bootstrap Configuration 和 Customizing the Bootstrap Property Sources：指导用户如何个性化引导配置和源。 - Environment Changes：讨论了环境变化时的应用响应机制。 - Refresh Scope：提供了刷新作用域的功能，允许在运行时更新bean的配置。 - Encryption and Decryption：阐述了如何在Spring Cloud中实现安全的加密和解密。 3. Spring Cloud Commons：通用抽象 - @EnableDiscoveryClient：一个注解，用于启用服务发现功能。 - Service Registry：关于服务注册和发现的讨论，包括自动注册和服务注册操作端点。 - Spring RestTemplate as a LoadBalancer Client：展示了如何使用Spring RestTemplate作为负载均衡客户端，以及如何处理失败请求的重试策略。 - Multiple RestTemplate objects：讨论了在项目中使用多个RestTemplate实例的情况。 - Ignore Network Interfaces：配置不参与服务发现的网络接口。 4. Spring Cloud Config - 快速入门：为客户端使用提供了快速上手的指导。 - Spring Cloud Config Server：深入介绍了配置服务器的使用，特别是与环境仓库的交互，如Git后端，用于存储和检索应用的配置。 5. 其他组件和功能 - EnvironmentRepository：探讨了配置服务器如何与各种后端（如Git）交互来存储和检索环境信息。这份文档对于Spring Cloud开发者来说是宝贵的参考资料，它详尽地解释了Spring Cloud各个组件的工作原理和使用方法，有助于开发者更有效地构建和管理分布式系统。

资源详情

资源推荐

2018/7/31 Spring Cloud

http://cloud.spring.io/spring-cloud-static/Dalston.SR5/single/spring-cloud.html#_reactive_programming_support 16/289

The bootstrap context can be trained to do anything you like by adding entries to /META-INF/spring.factories under the key

org.springframework.cloud.bootstrap.BootstrapConfiguration . This is a comma-separated list of Spring @Configuration classes

which will be used to create the context. Any beans that you want to be available to the main application context for autowiring can be created

here, and also there is a special contract for @Beans of type ApplicationContextInitializer . Classes can be marked with an @Order if

you want to control the startup sequence (the default order is "last").

Be careful when adding custom BootstrapConfiguration that the classes you add are not @ComponentScanned by mistake

into your "main" application context, where they might not be needed. Use a separate package name for boot configuration

classes that is not already covered by your @ComponentScan or @SpringBootApplication annotated configuration classes.

The bootstrap process ends by injecting initializers into the main SpringApplication instance (i.e. the normal Spring Boot startup sequence,

whether it is running as a standalone app or deployed in an application server). First a bootstrap context is created from the classes found in

spring.factories and then all @Beans of type ApplicationContextInitializer are added to the main SpringApplication before it

is started.

2.6 Customizing the Bootstrap Property Sources

The default property source for external configuration added by the bootstrap process is the Config Server, but you can add additional sources

by adding beans of type PropertySourceLocator to the bootstrap context (via spring.factories ). You could use this to insert additional

properties from a different server, or from a database, for instance.

As an example, consider the following trivial custom locator:

@Configuration

public class CustomPropertySourceLocator implements PropertySourceLocator {

@Override

public PropertySource<?> locate(Environment environment) {

return new MapPropertySource("customProperty",

Collections.<String, Object>singletonMap("property.from.sample.custom.source", "worked as intended"));

}

The Environment that is passed in is the one for the ApplicationContext about to be created, i.e. the one that we are supplying additional

property sources for. It will already have its normal Spring Boot-provided property sources, so you can use those to locate a property source

specific to this Environment (e.g. by keying it on the spring.application.name , as is done in the default Config Server property source

locator).

If you create a jar with this class in it and then add a META-INF/spring.factories containing:

org.springframework.cloud.bootstrap.BootstrapConfiguration=sample.custom.CustomPropertySourceLocator

then the "customProperty" PropertySource will show up in any application that includes that jar on its classpath.

2.7 Environment Changes

The application will listen for an EnvironmentChangeEvent and react to the change in a couple of standard ways (additional

ApplicationListeners can be added as @Beans by the user in the normal way). When an EnvironmentChangeEvent is observed it will

have a list of key values that have changed, and the application will use those to:

Re-bind any @ConfigurationProperties beans in the context

Set the logger levels for any properties in logging.level.*

Note that the Config Client does not by default poll for changes in the Environment , and generally we would not recommend that approach for

detecting changes (although you could set it up with a @Scheduled annotation). If you have a scaled-out client application then it is better to

broadcast the EnvironmentChangeEvent to all the instances instead of having them polling for changes (e.g. using the Spring Cloud Bus).

The EnvironmentChangeEvent covers a large class of refresh use cases, as long as you can actually make a change to the Environment

and publish the event (those APIs are public and part of core Spring). You can verify the changes are bound to @ConfigurationProperties

beans by visiting the /configprops endpoint (normal Spring Boot Actuator feature). For instance a DataSource can have its maxPoolSize

changed at runtime (the default DataSource created by Spring Boot is an @ConfigurationProperties bean) and grow capacity

dynamically. Re-binding @ConfigurationProperties does not cover another large class of use cases, where you need more control over the

2018/7/31 Spring Cloud

http://cloud.spring.io/spring-cloud-static/Dalston.SR5/single/spring-cloud.html#_reactive_programming_support 17/289

refresh, and where you need a change to be atomic over the whole ApplicationContext . To address those concerns we have

@RefreshScope .

2.8 Refresh Scope

A Spring @Bean that is marked as @RefreshScope will get special treatment when there is a configuration change. This addresses the

problem of stateful beans that only get their configuration injected when they are initialized. For instance if a DataSource has open

connections when the database URL is changed via the Environment , we probably want the holders of those connections to be able to

complete what they are doing. Then the next time someone borrows a connection from the pool he gets one with the new URL.

Refresh scope beans are lazy proxies that initialize when they are used (i.e. when a method is called), and the scope acts as a cache of

initialized values. To force a bean to re-initialize on the next method call you just need to invalidate its cache entry.

The RefreshScope is a bean in the context and it has a public method refreshAll() to refresh all beans in the scope by clearing the target

cache. There is also a refresh(String) method to refresh an individual bean by name. This functionality is exposed in the /refresh

endpoint (over HTTP or JMX).

@RefreshScope works (technically) on an @Configuration class, but it might lead to surprising behaviour: e.g. it does not

mean that all the @Beans defined in that class are themselves @RefreshScope . Specifically, anything that depends on those

beans cannot rely on them being updated when a refresh is initiated, unless it is itself in @RefreshScope (in which it will be

rebuilt on a refresh and its dependencies re-injected, at which point they will be re-initialized from the refreshed

@Configuration ).

2.9 Encryption and Decryption

Spring Cloud has an Environment pre-processor for decrypting property values locally. It follows the same rules as the Config Server, and

has the same external configuration via encrypt.* . Thus you can use encrypted values in the form {cipher}* and as long as there is a

valid key then they will be decrypted before the main application context gets the Environment . To use the encryption features in an

application you need to include Spring Security RSA in your classpath (Maven co-ordinates "org.springframework.security:spring-security-rsa")

and you also need the full strength JCE extensions in your JVM.

If you are getting an exception due to "Illegal key size" and you are using Sun’s JDK, you need to install the Java Cryptography Extension

(JCE) Unlimited Strength Jurisdiction Policy Files. See the following links for more information:

Java 6 JCE

Java 7 JCE

Java 8 JCE

Extract files into JDK/jre/lib/security folder (whichever version of JRE/JDK x64/x86 you are using).

2.10 Endpoints

For a Spring Boot Actuator application there are some additional management endpoints:

POST to /env to update the Environment and rebind @ConfigurationProperties and log levels

/refresh for re-loading the boot strap context and refreshing the @RefreshScope beans

/restart for closing the ApplicationContext and restarting it (disabled by default)

/pause and /resume for calling the Lifecycle methods ( stop() and start() on the ApplicationContext )

3. Spring Cloud Commons: Common Abstractions

Patterns such as service discovery, load balancing and circuit breakers lend themselves to a common abstraction layer that can be consumed

by all Spring Cloud clients, independent of the implementation (e.g. discovery via Eureka or Consul).

3.1 @EnableDiscoveryClient

Commons provides the @EnableDiscoveryClient annotation. This looks for implementations of the DiscoveryClient interface via

META-INF/spring.factories . Implementations of Discovery Client will add a configuration class to spring.factories under the

org.springframework.cloud.client.discovery.EnableDiscoveryClient key. Examples of DiscoveryClient implementations: are

Spring Cloud Netflix Eureka, Spring Cloud Consul Discovery and Spring Cloud Zookeeper Discovery.

2018/7/31 Spring Cloud

http://cloud.spring.io/spring-cloud-static/Dalston.SR5/single/spring-cloud.html#_reactive_programming_support 18/289

By default, implementations of DiscoveryClient will auto-register the local Spring Boot server with the remote discovery server. This can be

disabled by setting autoRegister=false in @EnableDiscoveryClient .

3.2 ServiceRegistry

Commons now provides a ServiceRegistry interface which provides methods like register(Registration) and

deregister(Registration) which allow you to provide custom registered services. Registration is a marker interface.

@Configuration

@EnableDiscoveryClient(autoRegister=false)

public class MyConfiguration {

private ServiceRegistry registry;

public MyConfiguration(ServiceRegistry registry) {

this.registry = registry;

}

// called via some external process, such as an event or a custom actuator endpoint

public void register() {

Registration registration = constructRegistration();

this.registry.register(registration);

}

Each ServiceRegistry implementation has its own Registry implementation.

3.2.1 ServiceRegistry Auto-Registration

By default, the ServiceRegistry implementation will auto-register the running service. To disable that behavior, there are two methods. You

can set @EnableDiscoveryClient(autoRegister=false) to permanently disable auto-registration. You can also set

spring.cloud.service-registry.auto-registration.enabled=false to disable the behavior via configuration.

3.2.2 Service Registry Actuator Endpoint

A /service-registry actuator endpoint is provided by Commons. This endpoint relys on a Registration bean in the Spring Application

Context. Calling /service-registry/instance-status via a GET will return the status of the Registration . A POST to the same

endpoint with a String body will change the status of the current Registration to the new value. Please see the documentation of the

ServiceRegistry implementation you are using for the allowed values for updating the status and the values retured for the status.

3.3 Spring RestTemplate as a Load Balancer Client

RestTemplate can be automatically configured to use ribbon. To create a load balanced RestTemplate create a RestTemplate @Bean

and use the @LoadBalanced qualifier.

A RestTemplate bean is no longer created via auto configuration. It must be created by individual applications.

@Configuration

public class MyConfiguration {

@LoadBalanced

@Bean

RestTemplate restTemplate() {

return new RestTemplate();

}

public class MyClass {

@Autowired

private RestTemplate restTemplate;

public String doOtherStuff() {

String results = restTemplate.getForObject("http://stores/stores", String.class);

return results;

}

2018/7/31 Spring Cloud

http://cloud.spring.io/spring-cloud-static/Dalston.SR5/single/spring-cloud.html#_reactive_programming_support 19/289

The URI needs to use a virtual host name (ie. service name, not a host name). The Ribbon client is used to create a full physical address. See

RibbonAutoConfiguration for details of how the RestTemplate is set up.

3.3.1 Retrying Failed Requests

A load balanced RestTemplate can be configured to retry failed requests. By default this logic is disabled, you can enable it by adding Spring

Retry to your application’s classpath. The load balanced RestTemplate will honor some of the Ribbon configuration values related to retrying

failed requests. If you would like to disable the retry logic with Spring Retry on the classpath you can set

spring.cloud.loadbalancer.retry.enabled=false . The properties you can use are client.ribbon.MaxAutoRetries ,

client.ribbon.MaxAutoRetriesNextServer , and client.ribbon.OkToRetryOnAllOperations . See the Ribbon documentation for a

description of what there properties do.

client in the above examples should be replaced with your Ribbon client’s name.

3.4 Multiple RestTemplate objects

If you want a RestTemplate that is not load balanced, create a RestTemplate bean and inject it as normal. To access the load balanced

RestTemplate use the @LoadBalanced qualifier when you create your @Bean .

Important

Notice the @Primary annotation on the plain RestTemplate declaration in the example below, to disambiguate the unqualified

@Autowired injection.

@Configuration

public class MyConfiguration {

@LoadBalanced

@Bean

RestTemplate loadBalanced() {

return new RestTemplate();

}

@Primary

@Bean

RestTemplate restTemplate() {

return new RestTemplate();

}

public class MyClass {

@Autowired

private RestTemplate restTemplate;

@Autowired

@LoadBalanced

private RestTemplate loadBalanced;

public String doOtherStuff() {

return loadBalanced.getForObject("http://stores/stores", String.class);

}

public String doStuff() {

return restTemplate.getForObject("http://example.com", String.class);

}

If you see errors like

java.lang.IllegalArgumentException: Can not set org.springframework.web.client.RestTemplate field com.my.app.Fo

try injecting RestOperations instead or setting spring.aop.proxyTargetClass=true .

3.5 Ignore Network Interfaces

2018/7/31 Spring Cloud

http://cloud.spring.io/spring-cloud-static/Dalston.SR5/single/spring-cloud.html#_reactive_programming_support 20/289

Sometimes it is useful to ignore certain named network interfaces so they can be excluded from Service Discovery registration (eg. running in a

Docker container). A list of regular expressions can be set that will cause the desired network interfaces to be ignored. The following

configuration will ignore the "docker0" interface and all interfaces that start with "veth".

application.yml.

spring:

cloud:

inetutils:

ignoredInterfaces:

- docker0

- veth.*

You can also force to use only specified network addresses using list of regular expressions:

application.yml.

spring:

cloud:

inetutils:

preferredNetworks:

- 192.168

- 10.0

You can also force to use only site local addresses. See Inet4Address.html.isSiteLocalAddress() for more details what is site local address.

application.yml.

spring:

cloud:

inetutils:

useOnlySiteLocalInterfaces: true

Part II. Spring Cloud Config

Dalston.SR5

Spring Cloud Config provides server and client-side support for externalized configuration in a distributed system. With the Config Server you

have a central place to manage external properties for applications across all environments. The concepts on both client and server map

identically to the Spring Environment and PropertySource abstractions, so they fit very well with Spring applications, but can be used with

any application running in any language. As an application moves through the deployment pipeline from dev to test and into production you can

manage the configuration between those environments and be certain that applications have everything they need to run when they migrate.

The default implementation of the server storage backend uses git so it easily supports labelled versions of configuration environments, as well

as being accessible to a wide range of tooling for managing the content. It is easy to add alternative implementations and plug them in with

Spring configuration.

4. Quick Start

Start the server:

$ cd spring-cloud-config-server

$ ../mvnw spring-boot:run

The server is a Spring Boot application so you can run it from your IDE instead if you prefer (the main class is ConfigServerApplication ).

Then try out a client:

$ curl localhost:8888/foo/development

{"name":"development","label":"master","propertySources":[

{"name":"https://github.com/scratches/config-repo/foo-development.properties","source":{"bar":"spam"}},

{"name":"https://github.com/scratches/config-repo/foo.properties","source":{"foo":"bar"}}

]}

The default strategy for locating property sources is to clone a git repository (at spring.cloud.config.server.git.uri ) and use it to

initialize a mini SpringApplication . The mini-application’s Environment is used to enumerate property sources and publish them via a

剩余288页未读，继续阅读

试水流连

粉丝: 36
资源: 1

Spring Cloud Dalston.SR5 英文PDF文档：带书签的云原生应用指南

SpringCloud中文学习文档

spring-cloud.pdf

《深入理解SpringCloud与微服务构建》_sample.pdf

spring cloud alibaba pdf

spring cloud alibab 对应 spring cloud 版本

springcloud中文文档下载

springcloud对应springcloud-alibaba版本

springcloud 与spring cloud alibaba版本依赖

springcloud官方文档

springcloud和springboot版本兼容

spring cloud gateway 与spring cloud版本对应问题

Spring Cloud 和 Spring Cloud Alibaba 对应关系官网

springcloudalibaba对应Spring Boot对应springcloud版本

spring cloud alibaba内部文档.pdf

springcloud版本sr8

spring-cloud-commons版本和spring cloud finchley，spring cloud alibaba有什么关系

spring cloud pdf 英文原版

springcloud alibaba 版本

springcloud和springboot版本对应关系

spring cloud alibaba pdf(2022最新版)

最新资源