为 Eureka 添加 Http Basic 认证

简介

在网络世界中,任何网络中的服务都是不安全的,为了使我们的 Eureka 服务更加安全,我们可以添加各种各样的认证方式,以使客户端在提供相应的证明之后才能够注册到 Eureka 中。而这次我们就添加一个最基本的 Http Basic 认证到 Eureka 中。 HTTP Basic 是简单的用户名密码认证,客户端在发送注册请求时,会附带用户名和密码一起发送到 Eureka Server,这种传输方式也属于不太安全的一种。

项目源码

Gitee码云

配置 Eureka Server

打开远程 git 仓库中的 eureka-server.yml 文件,添加如下配置:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
---
spring:
profiles: peer1
security:
user:
name: test
password: 123456
roles: USER
server:
port: 8761
eureka:
instance:
hostname: peer1
client:
register-with-eureka: false
fetch-registry: false
# serviceUrl:
# defaultZone: http://peer2:8762/eureka

---

为了简化服务注册,我们这次测试只使用 peer1 这个 profile,并且把 register-with-eurekafetch-registry 设置为了 false 以关闭自身注册。然后我们在 spring 下配置了 security.user.namepassword, roles,分别用来指定可以登录的用户名,密码,和用户组。

在我们的 registry 项目中创建一个 Java 类 cn.zxuqian.configurations.WebSecurityConfig,并添加如下代码:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
@Configuration
@EnableWebSecurity
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {

private static Logger log = LoggerFactory.getLogger(WebSecurityConfig.class);

@Override
protected void configure(HttpSecurity http) throws Exception {
http.csrf().disable().httpBasic();
}


@Bean
public UserDetailsService userDetailsService() {
User.UserBuilder builder = User.withDefaultPasswordEncoder();
InMemoryUserDetailsManager manager = new InMemoryUserDetailsManager();
manager.createUser(builder.username("test").password("123456").roles("USER").build());
return manager;
}

}

这里覆盖了 WebSecurityConfigurerAdapter 中的 configure() 方法,用来停用 CSRF 保护,因为我们的 Eureka Server 使用了 peer 做为 hostname,而稍后测试的 product-service 使用了 localhost,会被禁止访问 Eureka 资源。然后在 userDetailsService() 方法中添加了一个 test 用户用于认证。

Product-service

打开远程 git 仓库中的 product-service.yml 文件,添加如下配置:

1
2
3
4
eureka:
client:
serviceUrl:
defaultZone: http://test:123456@peer1:8761/eureka/

这里在 defaultZone 指定的 Url 中添加了 [username]:[password]@host:port/eureka/ 形式的地址,此为 curl 发送用户名和密码的方式。

测试

首先运行 Config Server,然后使用 mvn spring-boot:run -Dspring-boot.run.profiles=peer1 运行 Eureka Server,最后运行 product-service,稍等片刻就会看到 product-service 注册成功,而 Eureka Server 的 log 中会有如下字样(需设置 log level 为 debug):

1
2018-05-19 18:16:45.278 DEBUG 19055 --- [nio-8761-exec-9] w.c.HttpSessionSecurityContextRepository : Obtained a valid SecurityContext from SPRING_SECURITY_CONTEXT: 'org.springframework.security.core.context.SecurityContextImpl@442bd3dc: Authentication: org.springframework.security.authentication.UsernamePasswordAuthenticationToken@442bd3dc: Principal: org.springframework.security.core.userdetails.User@364492: Username: test; Password: [PROTECTED]; Enabled: true; AccountNonExpired: true; credentialsNonExpired: true; AccountNonLocked: true; Granted Authorities: ROLE_USER; Credentials: [PROTECTED]; Authenticated: true; Details: org.springframework.security.web.authentication.WebAuthenticationDetails@957e: RemoteIpAddress: 127.0.0.1; SessionId: null; Granted Authorities: ROLE_USER'

配置 Eureka Server 集群

简介

为了使 Eureka Server 实现高可用,我们需要为它配置集群。这样当有一台 Eureka Server 有故障时,集群中的其他 Server 可以进行代替。Eureka 集群之中的 Node 通过 P2P 通信的方式共享注册表,以使得每个 Eureka Server 的注册表保持一致。本教程将在本地开启两台 Eureka Server 以测试集群的搭建。

项目源码

Gitee码云

配置 Eureka Server

打开远程 git 仓库中的 eureka-server.yml 文件,添加如下配置:

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
---
spring:
profiles: peer1
server:
port: 8761
eureka:
instance:
hostname: peer1
client:
register-with-eureka: true
fetch-registry: true
serviceUrl:
defaultZone: http://peer2:8762/eureka

---
spring:
profiles: peer2
server:
port: 8762
eureka:
instance:
hostname: peer2
client:
register-with-eureka: true
fetch-registry: true
serviceUrl:
defaultZone: http://peer1:8761/eureka

三划线用于区分两个不同的 profile,使用 spring-boot 插件启动项目时可通过命令行参数指定 profile。这两个 profiles 分别指定了 profile 的名字,服务的端口号。ureka.instance.hostname 为主机名,必须要和 eureka.client.serviceUrl.defaultZone 中的 Peer 主机名保持一致。例如,在 peer1 的 profile 中,把 peer2 作为了集群中另一个镜像节点,那么这个 http://peer2:8762/eureka URL 中的 peer2 就要和 peer2 profile 中的 eureka.instance.hostname 保持一致。serviceUrl 是 eureka server 的注册地址,defaultZone 想对于 AWS 的 availability zone,在本地测试可以用 defaultZone 或者其他名称,以把 Eureka Server 部署在不同集群。register-with-eurekafetch-registry 之前设置为了 false, 因为只有一台 Eureka Server,并不需要自己注册自己,而现在有了集群,可在集群的其他节点中注册本服务。

修改 hosts

修改 hosts 文件,以使 peer1 和 peer2 映射到 localhost,因为 eureka server 的主机名必须不同才可互相注册,所以在本地需要模拟两个不同的主机名:

1
2
127.0.0.1 peer1
127.0.0.1 peer2

配置 productService

打开远程 git 仓库中的 product-service.yml 文件,添加如下配置:

1
2
3
4
5
6
7
8
9
10
11
12
server:
port: 8081
spring:
cloud:
config:
allow-override: true
override-system-properties: false

eureka:
client:
serviceUrl:
defaultZone: http://peer1:8761/eureka, http://peer2:8762/eureka

这里通过 eureka.client.serviceUrl.defaultZone 把 eureka 集群中的所有 url 都填写了进来,也可以只写一台,因为各个 eureka server 可以同步注册表。

测试

首先启动 configserver,然后分别运行如下两条命令启动 eureka server 集群:

1
2
mvn spring-boot:run -Dspring-boot.run.profiles=peer1
mvn spring-boot:run -Dspring-boot.run.profiles=peer2

最后启动 productService,访问任一 Eureka Server,如:

1
http://peer1:8761

我们可以看到 Eureka Server 集群和 Product-Service 均在注册表里。

Application AMIs Availability Zones Status
EUREKA-SERVER n/a (2) (2) UP (2) - xuqians-imac:eureka-server:8761 , xuqians-imac:eureka-server:8762
PRODUCT-SERVICE n/a (1) (1) UP (1) - xuqians-imac:product-service:8081

Spring Cloud Config Client 超时与重试

简介

有时客户端需要在 config server 无响应时进行重试,以给 config server 时间进行恢复。利用 spring 提供的重试组件,我们可以方便的配置重试机制,包括重试间隔,重试次数等。

项目源码

Gitee码云

为 web 项目添加依赖

开启客户端重试功能需要两个新依赖,spring-retryspring-boot-starter-aop,把如下代码添加到 web 项目的 pom.xml 文件中:

1
2
3
4
5
6
7
8
9
<dependency>
<groupId>org.springframework.retry</groupId>
<artifactId>spring-retry</artifactId>
<version>1.2.2.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-aop</artifactId>
</dependency>

然后在 bootstrap.yml 文件中添加如下配置:

1
2
3
4
5
6
7
8
9
10
11
12
spring:
application:
name: web-client
cloud:
config:
uri: http://localhost:8888
fail-fast: true
retry:
initial-interval: 1000
max-attempts: 6
max-interval: 2000
multiplier: 1.1

首先把 spring.cloud.config.fail-fast 为true,即在获取不到远程配置时,立即失败,但是用下边的配置进行重试。

spring.cloud.config.retry 所有子项均为默认值:

  • initial-interval: 最初重试间隔为 1000 毫秒
  • max-attempts: 最多重试 6 次
  • max-interval: 最长重试间隔为 2000 毫秒
  • multiplier: 每次重试失败后,重试间隔所增加的倍数

测试

如果使用了本教程的项目,我们需要首先启动 configserver 项目,然后再启动 registry 项目开启 eureka,因为 web 客户端使用了 eureka 服务,之后关闭 configserver,然后启动 web 项目,会看到如下 log:

1
2018-05-15 16:04:58.421  INFO 2663 --- [           main] c.c.c.ConfigServicePropertySourceLocator : Fetching config from server at: http://localhost:8888

重试 6 次失败后,客户端启动失败,如果中途开启 configserver,则 web 客户端启动成功。

细粒度控制重试

我们可以在代码中实现更精细的控制重试机制,在 web 项目中创建一个新的 java 类 cn.zxuqian.configurations.RetryConfiguration,添加如下代码:

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
package cn.zxuqian.configurations;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.context.annotation.Bean;
import org.springframework.retry.interceptor.RetryInterceptorBuilder;
import org.springframework.retry.interceptor.RetryOperationsInterceptor;

public class RetryConfiguration {
private static Logger log = LoggerFactory.getLogger(RetryConfiguration.class);

@Bean
@ConditionalOnMissingBean(name = "configServerRetryInterceptor")
public RetryOperationsInterceptor configServerRetryInterceptor() {
log.info(String.format(
"configServerRetryInterceptor: Changing backOffOptions " +
"to initial: %s, multiplier: %s, maxInterval: %s",
1000, 1.2, 5000));
return RetryInterceptorBuilder
.stateless()
.backOffOptions(1000, 1.2, 5000)
.maxAttempts(10)
.build();
}
}

这里我们定义了configServerRetryInterceptor方法用于 Spring Retry 使用我们自定义的重试拦截器。方法使用 RetryInterceptorBuilder 按要求创建了一个 stateless 的 RetryOperationsInterceptor,并设置了初始重试间隔为 1000 毫秒,增加倍数为 1.2 倍,最大重试间隔为 5000 毫秒,最大重试次数为 10 次,builder 还提供了诸如配置重试机制之类的接口,有兴趣的读者可自行研究。

@ConditionalOnMissingBean 标明当 BeanFactory 中没有名为 configServerRetryInterceptor 的 bean 时才匹配此 Bean。

最后在 src/main/resources/META-INF/ (没有可创建此文件夹) 新建一个 spring.factories 文件,指定我们刚创建类为启动时的配置,以在获取远程配置之前生效:

1
org.springframework.cloud.bootstrap.BootstrapConfiguration=cn.zxuqian.configurations.RetryConfiguration

测试

最后在关闭 configserver 的条件下启动 web 项目,然后就会看到重试十次之后,项目启动失败。

Spring Cloud Config - RSA简介以及使用RSA加密配置文件

简介

RSA非对称加密有着非常强大的安全性,HTTPS的SSL加密就是使用这种方法进行HTTPS请求加密传输的。因为RSA算法会涉及Private Key和Public Key分别用来加密和解密,所以称为非对称加密。Private Key和Public Key有互操作性,即用private key加密的可以用public key解密,用public key加密的可以用private key解密。传统的单向认证则只用public key进行加密,有private key的一方才可进行解密。例如,一个web服务器会有一对private key和public key。浏览器客户端保存着服务器的public key。当客户端需要向服务器发送数据时,就用服务器的public key进行加密,然后服务器收到数据时,再用private key进行解密。客户端验证服务器是否为真实的服务器时,会根据服务器提供的public key和自己本地保存的public key作比较,一致的话才能验证服务器的真实性。

在我们的config server中,一些对加密要求比较高的可以采用RSA算法进行数据的加密和解密。

项目源码

Gitee码云

生成测试Keystore

我们需要使用jdk自带的keytool工具生成一个keystore,里边保存了private key的信息,使用如下命令行:

1
keytool -genkeypair -alias config-server-key -keyalg RSA -dname "CN=Config Server,OU=Xuqian,O=My Own Company,L=Beijing,S=Beijing,C=CN" -keypass changeit -keystore server.jks -storepass changeit

-genkeypair 参数即产生一对public key和private key。
-alias 指定key的别名,用于区分同一keystore中不同的key。
-keyalg 指定生成key的算法,这里使用默认的RSA
-dname 指定common name,即CN,用以验证key的身份。其中各项皆为自定义参数,OU为单位名称,O为组织名称,L为城市,S为省份/州,C为国家
-keypass 为key的密码
-keystore 为keystore的文件名
-storepass 访问keystore的密码

上述工具将产生的 privte key 保存在了名为server.jks的 key store 中。到目前为止,我们只产生了 private key,Spring Cloud Config Server 会根据我们提供的 key 的信息,每次会用程序生成一个 public key,参考如下源代码org.springframework.security.rsa.crypto.KeyStoreKeyFactory

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
public KeyPair getKeyPair(String alias, char[] password) {
try {
synchronized (lock) {
if (store == null) {
synchronized (lock) {
// 根据配置提供的 keystore 文件地址和密码获取 keystore 的实例对象
store = KeyStore.getInstance("jks");
store.load(resource.getInputStream(), this.password);
}
}
}
// 根据配置提供的 alias 和 password 从 keystore 中取得 private key
RSAPrivateCrtKey key = (RSAPrivateCrtKey) store.getKey(alias, password);
// 定义 Public Key 生成规则
RSAPublicKeySpec spec = new RSAPublicKeySpec(key.getModulus(),
key.getPublicExponent());
// 生成 Public Key
PublicKey publicKey = KeyFactory.getInstance("RSA").generatePublic(spec);
return new KeyPair(publicKey, key);
}
catch (Exception e) {
throw new IllegalStateException("Cannot load keys from store: " + resource, e);
}
}

这里使用了 Java Security API 来对key进行操作。参见注释。然后上边的信息通过 configserver 中的 bootstrap.xml 配置文件提供:

1
2
3
4
5
6
7
encrypt:
#key: Thisismysecretkey
key-store:
location: file://${user.home}/development/keys/server.jks
password: changeit
alias: config-server-key
secret: changeit

因为我们不能同时使用对称加密和非对称加密,所以我们把 encrypt.key 配置注释掉,然后指定非对称加密的参数:

  • location: Keystore 的文件路径
  • password: keystore 的密码
  • alias: key 的别名
  • secret: key的密码

测试

我们继续使用 encrypt API加密一项测试数据:

1
curl http://localhost:8888/encrypt -d 23456789

返回加密后的字符:

1
AQAPWOUOh4WVexGgVv+bgtKc5E0d5Aba8VUKnzEXh27HyKSAbW+wyzDwZTbk5QYfXpoCAs413rdeNIdR2ez44nkjT5V+438/VQExySzjZPhP0xYXi9YIaJqA3+Ji+IWK8hrGtJ4dzxIkmItiimCOirLdZzZGDm/yklMUVh7lARSNuMxXGKlpdBPKYWdqHm57ob6Sb0ivm4H4mL1n4d3QUCuE7hh2F4Aw4oln7XueyMkRPTtPy8OpnBEEZhRfmaL/auVZquLU5jjMNJk9JiWOy+DSTscViY/MZ+dypv6F4AfDdVvog89sNmPzcUT+zmB8jXHdjLoKy+63RG326WffY9OPuImW6/kCWZHV6Vws55hHqRy713W6yDBlrQ/gYC3Wils=

然后测试解密

1
curl http://localhost:8888/decrypt -d AQAPWOUOh4+bgtKc5E0d5Aba8VUKnzEXh27HyKSAbW+wyzDwZTbk5QYfXpoCAs413rdeNIdR2ez44nkjT5V+438/VQExySzjZPhP0xYXi9YIaJqA3+Ji+IWK8hrGtJ4dzxIkmItiimCOirLdZzZGDm/yklMUVh7lARSNuMxXGKlpdBPKYWdqHm57ob6Sb0ivm4H4mL1n4d3QUCuE7hh2F4Aw4oln7XueyMkRPTtPy8OpnBEEZhRfmaL/auVZquLU5jjMNJk9JiWOy+DSTscViY/MZ+dypv6F4AfDdVvog89sNmPzcUT+zmB8jXHdjLoKy+63RG326WffY9OPuImW6/kCWZHV6Vws55hHqRy713W6yDBlrQ/gYC3Wils=

会返回

1
23456789

我们还可以修改web-client.yml来验证:

1
2
3
4
#test:
#password: '{cipher}94c1027141add9844ec47f0be13caebb6b38ed1dcf99811b1a5cd2b874c64407'
user:
password: '{cipher}AQAPWOUOh4WVexGgVv+bgtKc5E0d5Aba8VUKnzEXh27HyKSAbW+wyzDwZTbk5QYfXpoCAs413rdeNIdR2ez44nkjT5V+438/VQExySzjZPhP0xYXi9YIaJqA3+Ji+IWK8hrGtJ4dzxIkmItiimCOirLdZzZGDm/yklMUVh7lARSNuMxXGKlpdBPKYWdqHm57ob6Sb0ivm4H4mL1n4d3QUCuE7hh2F4Aw4oln7XueyMkRPTtPy8OpnBEEZhRfmaL/auVZquLU5jjMNJk9JiWOy+DSTscViY/MZ+dypv6F4AfDdVvog89sNmPzcUT+zmB8jXHdjLoKy+63RG326WffY9OPuImW6/kCWZHV6Vws55hHqRy713W6yDBlrQ/gYC3Wils='

注释掉 test.password,新增一个 user.password 使用加密后的配置值。然后提交的gitee仓库,通过 url 访问此配置文件:

1
http://localhost:8888/web-client/default

得到如下结果:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
{
"name": "web-client",
"profiles": [
"default"
],
"label": null,
"version": "3044a5345fb86d09a043ca7404b9e57c8c13c512",
"state": null,
"propertySources": [
{
"name": "https://gitee.com/zxuqian/spring-cloud-config-remote/web-client.yml",
"source": {
"message": "此条消息来自于远程配置仓库",
"management.endpoints.web.exposure.include": "*",
"user.password": "23456789"
}
}
]
}

使用对称加密来加密Spring Cloud Config配置文件

补充

使用Spring Cloud Config加密功能需要下载JCE扩展,用于生成无限长度的密文。链接:http://www.oracle.com/technetwork/java/javase/downloads/jce8-download-2133166.html
下载完成之后解压,把得到到两个Jar包复制到$JAVA_HOME\jre\lib\security目录下。

简介

在真实项目环境下,我们不会在配置文件中明文存储密码等机密性文本,以防被窃。Spring Cloud Config提供了加密方法,以使明文文本加密成密文存储在配置文件中。Spring Cloud Config提供了两种加密解密方式,一种是对称加密,一种是非对称加密。这篇文章将先展示如何使用对称加密。

对称加密简介

对称加密

对称加密即通信双方用同一密钥(key)对文本进行加密和解密。它有两种加密方式:

  • Stream Cipher。对文本进行逐字节或逐字的进行加密。
  • Block Cipher。取一定长度(block size)的字节加密成一个单元,长度不够或者不成block size倍数的用占位符填充。

对称加密是较为简单的一种方式,只要双方都拥有同一key就可以完成文本的加密和解密。不过对称加密的缺点是无法认证来源,即如果Alice和Bob正在通信,Alice使用key把加密后的文本传递给Bob,但是中途被Eve截取到了密文,然后Eve把密文转发给Bob,让Bob误以为Eve就是Alice,然后就会造成数据泄露。

项目源码

Gitee码云

配置configserver

首先我们要先设置一个加密用到的Key,在我们的configserver项目中的bootstrap.yml配置文件中加入如下配置项:

1
2
encrypt:
key: Thisismysecretkey

测试

我们用这个key加密我们的web-client的一个测试项。Spring Cloud Config提供了加密和解密的终端路径,/encrypt/decrypt。启动configserver,然后我们用/encrypt这个终端加密我们的测试文本:

1
curl localhost:8888/encrypt -d 12345678

返回的结果是(结果每次都会不一样):

1
94c1027141add9844ec47f0be13caebb6b38ed1dcf99811b1a5cd2b874c64407

然后在我们的remote config仓库中,修改web-client.yml配置,新增一条配置:

1
2
test:
password: '{cipher}94c1027141add9844ec47f0be13caebb6b38ed1dcf99811b1a5cd2b874c64407'

这里的引号是必须的,然后{cipher}指明了这条数据项为密文。然后我们可以验证一下解密:

1
curl localhost:8888/decrypt -d 94c1027141add9844ec47f0be13caebb6b38ed1dcf99811b1a5cd2b874c64407

正常情况下会得到我们的12345678字符。然后我们通过url访问web-client.yml配置文件,会得到如下结果:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
{
"name": "web-client",
"profiles": [
"default"
],
"label": null,
"version": "6b73c56449acee907fcf37e50892a3afddbf6335",
"state": null,
"propertySources": [
{
"name": "https://gitee.com/zxuqian/spring-cloud-config-remote/web-client.yml",
"source": {
"message": "此条消息来自于远程配置仓库",
"management.endpoints.web.exposure.include": "*",
"test.password": "12345678"
}
}
]
}

会看到解密后的test.password12345678

为Spring Cloud Config Server配置远程git仓库

简介

虽然在开发过程,在本地创建git仓库操作起来非常方便,但是在实际项目应用中,多个项目组需要通过一个中心服务器来共享配置,所以Spring Cloud配置中心支持远程git仓库,以使分散的项目组更方便的进行协作。

基础环境

  • JDK 1.8
  • Maven 3.3.9
  • IntelliJ 2018.1
  • Git

项目源码

Gitee码云

配置远程git仓库

首先我在gitee上创建了一个远程仓库https://gitee.com/zxuqian/spring-cloud-config-remote专门用来存放配置文件,然后我们会通过配置文件来访问此仓库。然后我们把以前本地的配置文件迁移到此库中。为了测试效果,我们把web-client.ymlmessage的值修改为:此条消息来自于远程配置仓库

配置configserver

现在在我们之前的configserver中作一些配置上的改动。首先为了保留之前的本地仓库的配置,我们把application.yml重命名为application-local.yml

这个-local是一个profile,它的值是-后面的,即local,我们可以在bootstrap.yml中指定使用哪个profile。比如实际项目中开发阶段和生产阶段的配置有所不同,所以会有application-development.ymlapplication-production.yml等两种或以上的配置。

然后新建一个application-remote.yml文件,添加如下配置内容:

1
2
3
4
5
6
7
8
9
10
server:
port: 8888
spring:
cloud:
config:
server:
git:
uri: https://gitee.com/zxuqian/spring-cloud-config-remote
username: 您的gitee用户名
password: 您的gitee密码

因为是自用账号的仓库,所以就不提供账号密码了,改成自己对应的。这里uri配置了远程git仓库的地址。

最后在bootstrap.yml中启用我们的remote profile:

1
2
3
4
5
spring:
application:
name: config-server
profiles:
active: remote

spring.profiles.active即指定了我们的remote Profile,使用application-remote.yml配置文件。

测试

使用spring-boot:run启动我们的config server,然后访问http://localhost:8888/web-client/default,看到如下结果:

1
{"name":"web-client","profiles":["default"],"label":null,"version":"cbef7d379ef01d68810c3fdc2105b2226ea6c611","state":null,"propertySources":[{"name":"https://gitee.com/zxuqian/spring-cloud-config-remote/web-client.yml","source":{"message":"此条消息来自于远程配置仓库","management.endpoints.web.exposure.include":"*"}}]}

message的值取自于远程仓库。这里的web-client/default配置文件名/profile,因为我们的web客户端项目没有其他Profile,则默认值为default,只有这样写全,才可以访问到web-client.yml的配置。

使用Spring Boot开发者工具进行自动重启和页面自动刷新

简介

大家可能都听说过开发Node.js应用时可以使用多种工具对开发者提供便利,如WebPack提供了开发者服务器来支持js应用动态更替,并在保存文件时自动刷新浏览器。Spring Boot也提供了相似的开发者工具,让我们更快速、更舒心的开发Spring Boot应用。大家看完本教程就可以学会如何如用Spring Boot开发者工具进行自动重启和自动刷新页面。

自动重启原理

Spring Boot的开发者工具会为应用创建两个classloader。一个是用来加载不会变动的类,称为base classloader。另一个是restart classloader,用来加载经常变动的类,默认情况下Spring Boot开发者工具会监控classpath下所有的类。当有类变动时,旧的restart classloader就会被丢弃,然后再创建一个新的,以此来加快重启速度。

基础环境

  • JDK 1.8
  • Maven 3.3.9
  • IntelliJ 2018.1
  • Git

项目源码

Gitee码云

创建项目

使用IntelliJ创建一个maven项目:

  • groupdId: zxuqian.cn
  • artifactId: devtools

使用如下pom.xml文件配置:

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
72
73
74
75
76
77
<?xml version="1.0" encoding="UTF-8"?>
<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/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>

<groupId>cn.zxuqian</groupId>
<artifactId>devtools</artifactId>
<version>0.0.1-SNAPSHOT</version>
<packaging>jar</packaging>

<name>devtools</name>
<description>Showcase project for Spring Boot developer tools</description>

<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.1.0.BUILD-SNAPSHOT</version>
<relativePath/> <!-- lookup parent from repository -->
</parent>

<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
<java.version>1.8</java.version>
</properties>

<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>

<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-devtools</artifactId>
<optional>true</optional>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
</dependencies>

<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>

<repositories>
<repository>
<id>spring-snapshots</id>
<url>https://repo.spring.io/snapshot</url>
<snapshots><enabled>true</enabled></snapshots>
</repository>
<repository>
<id>spring-milestones</id>
<url>https://repo.spring.io/milestone</url>
</repository>
</repositories>
<pluginRepositories>
<pluginRepository>
<id>spring-snapshots</id>
<url>https://repo.spring.io/snapshot</url>
</pluginRepository>
<pluginRepository>
<id>spring-milestones</id>
<url>https://repo.spring.io/milestone</url>
</pluginRepository>
</pluginRepositories>


</project>

这里我们用了最新的snapshop版本的spring boot 2.1.0,然后添加spring-boot-devtools依赖,并把它设置为optional的,那么这样在最后打包的产品环境中,devtools将不会被打包进来。

接下来添加一个测试用的控制器cn.zxuqian.devtools.controller.HelloController

1
2
3
4
5
6
7
8
9
10
11
12
13
package cn.zxuqian.devtools.controller;

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class HelloController {

@RequestMapping("/")
public String hello() {
return "hello world";
}
}

然后创建cn.zxuqian.devtools.DevtoolsApplication类配置Spring Boot应用:

1
2
3
4
5
6
7
8
9
10
11
12
package cn.zxuqian.devtools;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class DevtoolsApplication {

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

安装LiveReload插件

LiveReload官网下载LiveReload的Chrome或Firefox或Safari浏览器插件,然后启用此插件。

测试

使用spring-boot:run插件启动此应用,在浏览器打开http://localhost:8080会看到hello world字样。然后在我们的控制器中把返回值修改一下,如改为:Hola!,在IntelliJ中,我们必须要执行Build->Build Project才能重新编译新改动的代码,我们也可以用快捷键command + (fn) + F9 mac下,来执行编译。稍等几秒就会看到浏览器自动刷新为修改后的值了。

Spring Cloud入门教程 - Zuul实现API网关和请求过滤

简介

Zuul是Spring Cloud提供的api网关和过滤组件,它提供如下功能:

  • 认证
  • 过滤
  • 压力测试
  • Canary测试
  • 动态路由
  • 服务迁移
  • 负载均衡
  • 安全
  • 静态请求处理
  • 动态流量管理

在本教程中,我们将用zuul,把web端的请求/product转发到对应的产品服务上,并且定义一个pre过滤器来验证是否经过了zuul的转发。

基础环境

  • JDK 1.8
  • Maven 3.3.9
  • IntelliJ 2018.1
  • Git

项目源码

Gitee码云

创建Zuul服务

在IntelliJ中创建一个maven项目:

  • cn.zxuqian
  • apiGateway

然后在pom.xml中添加如下代码:

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
72
73
74
75
76
77
78
<?xml version="1.0" encoding="UTF-8"?>
<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/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>

<groupId>cn.zxuqian</groupId>
<artifactId>apiGateway</artifactId>
<version>1.0-SNAPSHOT</version>

<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.0.1.RELEASE</version>
</parent>

<dependencies>
<dependency>
<groupId>org.springframework.cloud</groupId>
<!-- name has changed, before: spring-cloud-starter-zuul -->
<artifactId>spring-cloud-starter-netflix-zuul</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-config</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-actuator</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>Finchley.M9</version>
<type>pom</type>
<scope>import</scope>
</dependency>
</dependencies>
</dependencyManagement>

<properties>
<java.version>1.8</java.version>
</properties>


<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>

<repositories>
<repository>
<id>spring-milestones</id>
<name>Spring Milestones</name>
<url>https://repo.spring.io/libs-milestone</url>
<snapshots>
<enabled>false</enabled>
</snapshots>
</repository>
</repositories>

</project>

需要注意的是,Spring官网的教程给的zuul的artifactId为spring-cloud-starter-zuul,这个是旧版zuul的名字,在我们的Finchley.M9版本中已经更名为spring-cloud-starter-netflix-zuul

添加src/main/resources/bootstrap.yml文件,指定spring.application.name

1
2
3
spring:
application:
name: zuul-server

创建cn.zxuqian.Application类:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
package cn.zxuqian;

import cn.zxuqian.filters.PreFilter;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.cloud.netflix.zuul.EnableZuulProxy;
import org.springframework.context.annotation.Bean;

@EnableZuulProxy
@EnableDiscoveryClient
@SpringBootApplication
public class Application {

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

@Bean
public PreFilter preFilter() {
return new PreFilter();
}
}

这里使用了@EnableZuulProxy来指定使用zuul的反向代理,把我们的请求转发到对应的服务器上。然后启用了eureka的服务发现。Zuul默认也会使用Ribbon做负载均衡,所以可以通过eureka发现已注册的服务。PreFilter是一个预过滤器,用来在request请求被处理之前进行一些操作,它的代码如下:

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
package cn.zxuqian.filters;

import com.netflix.zuul.ZuulFilter;
import com.netflix.zuul.context.RequestContext;
import com.netflix.zuul.exception.ZuulException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import javax.servlet.http.HttpServletRequest;

public class PreFilter extends ZuulFilter {

private static Logger log = LoggerFactory.getLogger(PreFilter.class);

@Override
public String filterType() {
return "pre";
}

@Override
public int filterOrder() {
return 1;
}

@Override
public boolean shouldFilter() {
return true;
}

@Override
public Object run() throws ZuulException {
RequestContext ctx = RequestContext.getCurrentContext();
HttpServletRequest request = ctx.getRequest();

log.info(String.format("%s 方式请求 %s", request.getMethod(), request.getRequestURL().toString()));

return null;
}
}

filterType - Zuul内置的filter类型有四种,pre, routeposterror,分别代表请求处理前,处理时,处理后和出错后。
filterOrder - 指定了该过滤器执行的顺序。
shouldFilter - 是否开启此过滤器。
run - 过滤器的业务逻辑。这里只是简单的log了一下reqeust的请求方式和请求的路径。

接下来,在我们的配置中心的git仓库中创建zuul-server.yml文件,并添加如下配置:

1
2
3
4
5
6
7
server:
port: 8083
zuul:
routes:
products:
path: /product/**
serviceId: product-service

这里配置了zuul的端口为8083,然后映射所有/product/的请求到我们的product-service服务上。如果不配置serviceId,那么products这个Key就会默认作为ServiceId,而我们的例子中,ServiceId包括了-,所以在下边显示指定了ServiceId。配置完成后提交到git。

更新productService

productService的uri做了一点改动,使其更符合rest风格:

1
2
3
4
5
@RequestMapping("/list")
public String productList() {
log.info("Access to /products endpoint");
return "外套,夹克,毛衣,T恤";
}

这里@RequestMapping匹配的路径改为了/list,之前是/products

更新web客户端

在我们的web客户端的ProductService中添加一个新的方法:

1
2
3
public String productListZuul() {
return this.restTemplate.getForObject("http://zuul-server/product/list", String.class);
}

这次我们直接请求zuul-server服务,然后由它把我们的请求反射代理到product-service服务。最后在ProductController中添加一个请求处理方法:

1
2
3
4
@RequestMapping("/product/list")
public String productListZuul() {
return productService.productListZuul();
}

用来处理/product/list请求,然后调用ProductService类中的方法。

测试

使用mvn spring-boot:run启动configServerregistry, zuulServer, productServiceweb这几个工程,然后启动第二个productService,使用SERVER_PORT=8082 spring-boot:run
访问几次http://localhost:8080/product/list,然后除了会在浏览器看到返回的结果,我们还会在zuulServer的命令行窗口中看到如下字样:

GET 方式请求 http://xuqians-imac:8083/product/list

然后在两个productService的命令行窗口中,我们还会看到随机出现的

Access to /products endpoint

说明zuulServer也会自动进行负载均衡。

欢迎访问我的博客张旭乾的博客

大家有什么想法欢迎来讨论。

Spring Cloud入门教程-Ribbon实现客户端负载均衡

简介

结构

我们继续以之前博客的代码为基础,增加Ribbon组件来提供客户端负载均衡。负载均衡是实现高并发、高性能、可伸缩服务的重要组成部分,它可以把请求分散到一个集群中不同的服务器中,以减轻每个服务器的负担。客户端负载均衡是运行在客户端程序中的,如我们的web项目,然后通过获取集群的IP地址列表,随机选择一个server发送请求。相对于服务端负载均衡来说,它不需要消耗服务器的资源。

基础环境

  • JDK 1.8
  • Maven 3.3.9
  • IntelliJ 2018.1
  • Git

项目源码

Gitee码云

更新配置

我们这次需要在本地启动两个产品服务程序,用来验证负载均衡,所以需要为第二个程序提供不同的端口。Spring Cloud配置服务中心的配置默认会覆盖本地系统环境变量,而我们需要通过系统环境变量来设置产品服务的端口,所以需要在配置中心git仓库中修改产品服务的配置文件product-service.yml

1
2
3
4
5
6
7
server:
port: 8081
spring:
cloud:
config:
allow-override: true
override-system-properties: false

allow-override的默认值即为true,写出它来是想作说明,它的意思是允许远程配置中心的配置项覆盖本地的配置,并不是说允许本地的配置去覆盖远程的配置。当然我们可以把它设置成false,但是为了提供更精确的覆盖规则,这里保留了默认值。
我们添加了override-system-properties=false,即虽然远程配置中心的配置文件可以覆盖本地的配置,但是不要覆盖本地系统变量。修改完成后提交到git仓库。

另外,在productService项目的ProductController中添加一些log,用来验证负载均衡是否生效:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
package cn.zxuqian.controllers;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;


@RestController
public class ProductController {

private static Logger log = LoggerFactory.getLogger(ProductController.class);

@RequestMapping("/products")
public String productList() {
log.info("Access to /products endpoint");
return "外套,夹克,毛衣,T恤";
}
}

为web配置Ribbon

首先在pom.xml中添加Ribbon的依赖:

1
2
3
4
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-netflix-ribbon</artifactId>
</dependency>

然后修改Application类,添加如下代码:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
@EnableCircuitBreaker
@EnableDiscoveryClient
@RibbonClient(name = "product-service")
@SpringBootApplication
public class Application {

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

@Bean
@LoadBalanced
public RestTemplate rest(RestTemplateBuilder builder) {
return builder.build();
}
}

这里用到了@RibbonClient(name = "product-service")注解,用来标记此项目为Ribbon负载均衡的客户端,它需要选择产品服务集群中其中的一台来访问所需要的服务,这里的name属性对应于productService项目中配置的spring.application.name属性。
@LoadBalanced注解标明了RestTemplate会被配置为自动使用Ribbon的LoadBalancerClient来选择服务的uri并发送请求。

在我们在ProductService类中添加如下代码:

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
@Service
public class ProductService {

private final RestTemplate restTemplate;

@Autowired
private DiscoveryClient discoveryClient;

public ProductService(RestTemplate restTemplate) {
this.restTemplate = restTemplate;
}

@HystrixCommand(fallbackMethod = "backupProductList")
public String productList() {
List<ServiceInstance> instances = this.discoveryClient.getInstances("product-service");
if(instances != null && instances.size() > 0) {
return this.restTemplate.getForObject(instances.get(0).getUri() + "/products", String.class);
}

return "";
}

public String backupProductList() {
return "夹克,毛衣";
}


public String productListLoadBalanced() {
return this.restTemplate.getForObject("http://product-service/products", String.class);
}
}

这里新添加了一个productListLoadBalanced方法,跟之前的productList方法访问的是同一服务,只不过是用Ribbon Client去做了负载均衡,这里的uri的host变成了product-service即要访问的服务的名字,跟@RibbonClient中配置的name属性保持一致。最后在我们的ProductController中添加下面的代码:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
@RestController
public class ProductController {

@Autowired
private ProductService productService;

@RequestMapping("/products")
public String productList() {
return productService.productList();
}

@RequestMapping("/productslb")
public String productListLoadBalanced() {
return productService.productListLoadBalanced();
}
}

来创建一个专门处理/productslb请求的方法,调用productServie提供负载均衡的方法。

到这里我们的代码就完成了,代码看似简单,其实是所有的配置都使用了默认值。Ribbon提供了编程式和配置式两种方式来配置Ribbon Client。现简单介绍下,后续深入Ribbon时再和大家一起看看如何修改它的配置。Ribbon提供如下配置(左边是接口,右边是默认实现):

  • IClientConfig ribbonClientConfig: DefaultClientConfigImpl
  • IRule ribbonRule: ZoneAvoidanceRule
  • IPing ribbonPing: DummyPing
  • ServerList<Server> ribbonServerList: ConfigurationBasedServerList
  • ServerListFilter<Server> ribbonServerListFilter: ZonePreferenceServerListFilter
  • ILoadBalancer ribbonLoadBalancer: ZoneAwareLoadBalancer
  • ServerListUpdater ribbonServerListUpdater: PollingServerListUpdater

因为我们这个项目用了Eureka,所以有些配置项和默认实现有所不同,如Eureka使用DiscoveryEnabledNIWSServerList取代ribbonServerList来获取在Eureka上注册的服务的列表。下边有一个简单的Congiguration类,来自Spring官网:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class SayHelloConfiguration {

@Autowired
IClientConfig ribbonClientConfig;

@Bean
public IPing ribbonPing(IClientConfig config) {
return new PingUrl();
}

@Bean
public IRule ribbonRule(IClientConfig config) {
return new AvailabilityFilteringRule();
}

}

Ribbon默认不会发送Ping检查server的健康状态,默认均正常,然后IRune默认实现为ZoneAvoidanceRule用来避免AWS EC2问题较多的zone,这在本地测试环境来说是用不到的,然后替换成了AvailabilityFilteringRule,这个可以开启Ribbon自带的断路器功能,来过滤不正常工作的服务器。

测试

首先启动我们的configserver配置中心服务,然后启动registry Eureka注册与发现服务,然后启动两个productService,第一个我们可以正常使用spring-boot:run插件来启动,第二个我们需要给它提供一个新的端口,可以用如下命令启动:

1
$ SERVER_PORT=8082 mvn spring-boot:run

最后启动我们的web客户端项目,访问http://localhost:8080/productslb,然后刷新几次,会看到运行着productService的两个命令行窗口会随机出现我们的log:

1
Access to /products endpoint

Spring Cloud入门教程-Hystrix断路器实现容错和降级

简介

Spring cloud提供了Hystrix容错库用以在服务不可用时,对配置了断路器的方法实行降级策略,临时调用备用方法。这篇文章将创建一个产品微服务,注册到eureka服务注册中心,然后我们使用web客户端访问/products API来获取产品列表,当产品服务故障时,则调用本地备用方法,以降级但正常提供服务。

基础环境

  • JDK 1.8
  • Maven 3.3.9
  • IntelliJ 2018.1
  • Git

项目源码

Gitee码云

添加产品服务

在intelliJ中创建一个新的maven项目,使用如下配置

  • groupId: cn.zxuqian
  • artifactId: productService

然后在pom.xml中添加如下代码:

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
72
73
74
<?xml version="1.0" encoding="UTF-8"?>
<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/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>

<groupId>cn.zxuqian</groupId>
<artifactId>productService</artifactId>
<version>1.0-SNAPSHOT</version>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.0.1.RELEASE</version>
<relativePath/>
</parent>

<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<java.version>1.8</java.version>
</properties>

<dependencies>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-config</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>

<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
</dependencies>
<dependencyManagement>
<dependencies>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-dependencies</artifactId>
<version>Finchley.M9</version>
<type>pom</type>
<scope>import</scope>
</dependency>
</dependencies>
</dependencyManagement>

<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>

<repositories>
<repository>
<id>spring-milestones</id>
<name>Spring Milestones</name>
<url>https://repo.spring.io/libs-milestone</url>
<snapshots>
<enabled>false</enabled>
</snapshots>
</repository>
</repositories>

</project>

我们继续使用了spring-cloud-starter-netflix-eureka-client以使产品服务自动注册到eureka服务中。然后还使用了spring-cloud-starter-config读取配置服务中心的配置文件。这个项目只是一个简单的spring web项目。

在src/main/resources下创建bootstrap.yml文件,添加如下内容:

1
2
3
4
5
6
spring:
application:
name: product-service
cloud:
config:
uri: http://localhost:8888

在配置中心的git仓库中创建product-service.yml文件 添加如下配置并提交:

1
2
server:
port: 8081

此配置指定了产品服务的端口为8081。接着创建Application类,添加如下代码:

1
2
3
4
5
6
7
8
9
10
11
12
13
package cn.zxuqian;

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

@EnableDiscoveryClient
@SpringBootApplication
public class Application {
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
}
}

@EnableDiscoveryClient注解将指示spring cloud自动把本服务注册到eureka。最后创建cn.zxuqian.controllers.ProductController控制器,提供/products API,返回示例数据:

1
2
3
4
5
6
7
8
9
10
11
12
13
package cn.zxuqian.controllers;

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class ProductController {

@RequestMapping("/products")
public String productList() {
return "外套,夹克,毛衣,T恤";
}
}

配置Web客户端

打开我们之前创建的web项目,在pom.xml中新添Hystrix依赖:

1
2
3
4
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-netflix-hystrix</artifactId>
</dependency>

然后更新Application类的代码:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
package cn.zxuqian;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.web.client.RestTemplateBuilder;
import org.springframework.cloud.client.circuitbreaker.EnableCircuitBreaker;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.context.annotation.Bean;
import org.springframework.web.client.RestTemplate;

@EnableCircuitBreaker
@EnableDiscoveryClient
@SpringBootApplication
public class Application {

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

@Bean
public RestTemplate rest(RestTemplateBuilder builder) {
return builder.build();
}
}

这里使用@EnableCircuitBreaker来开启断路器功能,然后还添加了一个rest方法并使用@Bean注解。这部分属于Spring依赖注入功能,使用@Bean标记的方法将告诉如何初始化此类对象,比如本例中就是使用RestTemplateBuilder来创建一个RestTemplate的对象,这个稍后在使用断路器的service中用到。

创建cn.zxuqian.service.ProductService类,并添加如下代码:

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
package cn.zxuqian.services;

import com.netflix.hystrix.contrib.javanica.annotation.HystrixCommand;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.client.ServiceInstance;
import org.springframework.cloud.client.discovery.DiscoveryClient;
import org.springframework.stereotype.Service;
import org.springframework.web.client.RestTemplate;

import java.util.List;

@Service
public class ProductService {

private final RestTemplate restTemplate;

@Autowired
private DiscoveryClient discoveryClient;

public ProductService(RestTemplate restTemplate) {
this.restTemplate = restTemplate;
}

@HystrixCommand(fallbackMethod = "backupProductList")
public String productList() {
List<ServiceInstance> instances = this.discoveryClient.getInstances("product-service");
if(instances != null && instances.size() > 0) {
return this.restTemplate.getForObject(instances.get(0).getUri() + "/products", String.class);
}

return "";
}

public String backupProductList() {
return "夹克,毛衣";
}
}

之所以要创建一个Service类,是因为Hystrix只能在标记为@Service@Component的类中使用,这样才能够正常使用Spring Context所提供的API。这个以后深入Spring时再作说明。
使用@HystrixCommand注解后,Hystrix将监控被注解的方法即productList(底层使用proxy包装此方法以此实现监控),一旦此方法的错误累积到一定门槛的时候,就会启动断路器,后续所有调用productList方法的请求都会失败,而会临时调用fallbackMethod指定的方法backupProductList(),然后当服务恢复正常时,断路器就会关闭。
我们还在此类中用了DiscoveryClient用以寻找产品服务的uri地址,使用产品服务的spring.application.name配置项的值,即product-service作为serviceID传给discoveryClient.getInstances()方法,然后会返回一个list,因为目前我们只有一个产品服务启动着,所以只需要取第一个实例的uri地址即可。
然后我们使用RestTemplate来访问产品服务的api,注意这里使用了Spring的构造方法注入,即之前我们用@Bean注解的方法会被用来初始化restTemplate变量,不需我们手动初始化。RestTemplate类提供了getForObject()方法来访问其它Rest API并把结果包装成对象的形式,第一个参数是要访问的api的uri地址,第二参数为获取的结果的类型,这里我们返回的是String,所以传给他String.class
backupProductList()方法返回了降级后的产品列表信息。

最后创建一个控制器cn.zxuqian.controllers.ProductController并添加如下代码:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
package cn.zxuqian.controllers;

import cn.zxuqian.services.ProductService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class ProductController {

@Autowired
private ProductService productService;

@RequestMapping("/products")
public String productList() {
return productService.productList();
}
}

这里使用ProductService/products路径提供数据。

测试

首先,我们使用spring-boot:run插件启动配置中心服务,config-server,然后启动eureka-server,再启动product-service,最后启动web客户端,稍等片刻待eureka服务注册成功之后访问http://localhost:8080/products,正常的情况下会得到外套,夹克,毛衣,T恤结果,然后我们关闭product-service,之后再访问同样的路径,会得到降级后的结果:夹克,毛衣

Your browser is out-of-date!

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

×