Spring 实战(第五版)
  • Spring 实战(第 5 版)
  • 第一部分 Spring 基础
  • 第 1 章 Spring 入门
    • 1.1 什么是 Spring?
    • 1.2 初始化 Spring 应用程序
      • 1.2.1 使用 Spring Tool Suite 初始化 Spring 项目
      • 1.2.2 检查 Spring 项目结构
    • 1.3 编写 Spring 应用程序
      • 1.3.1 处理 web 请求
      • 1.3.2 定义视图
      • 1.3.3 测试控制器
      • 1.3.4 构建并运行应用程序
      • 1.3.5 了解 Spring Boot DevTools
      • 1.3.6 回顾
    • 1.4 俯瞰 Spring 风景线
      • 1.4.1 Spring 核心框架
      • 1.4.2 Spring Boot
      • 1.4.3 Spring Data
      • 1.4.4 Spring Security
      • 1.4.5 Spring Integration 和 Spring Batch
      • 1.4.6 Spring Cloud
    • 1.5 小结
  • 第 2 章 开发 Web 应用程序
    • 2.1 展示信息
      • 2.1.1 建立域
      • 2.1.2 创建控制器类
      • 2.1.3 设计视图
    • 2.2 处理表单提交
    • 2.3 验证表单输入
      • 2.3.1 声明验证规则
      • 2.3.2 在表单绑定时执行验证
      • 2.3.3 显示验证错误
    • 2.4 使用视图控制器
    • 2.5 选择视图模板库
      • 2.5.1 缓存模板
    • 2.6 小结
  • 第 3 章 处理数据
    • 3.1 使用 JDBC 读写数据
      • 3.1.1 为域适配持久化
      • 3.1.2 使用 JdbcTemplate
      • 3.1.3 定义模式并预加载数据
      • 3.1.4 插入数据
    • 3.2 使用 Spring Data JPA 持久化数据
      • 3.2.1 添加 Spring Data JPA 到数据库中
      • 3.2.2 注解域作为实体
      • 3.2.3 声明 JPA repository
      • 3.2.4 自定义 JPA repository
    • 3.3 小结
  • 第 4 章 Spring 安全
    • 4.1 启用 Spring Security
    • 4.2 配置 Spring Security
      • 4.2.1 内存用户存储
      • 4.2.2 基于 JDBC 的用户存储
      • 4.2.3 LDAP 支持的用户存储
      • 4.2.4 自定义用户身份验证
    • 4.3 保护 web 请求
      • 4.3.1 保护请求
      • 4.3.2 创建用户登录页面
      • 4.3.3 登出
      • 4.3.4 阻止跨站请求伪造攻击
    • 4.4 了解你的用户
    • 4.5 小结
  • 第 5 章 使用配置属性
    • 5.1 微调自动配置
      • 5.1.1 理解 Spring 环境抽象
      • 5.1.2 配置数据源
      • 5.1.3 配置嵌入式服务器
      • 5.1.4 配置日志
      • 5.1.5 使用特殊的属性值
    • 5.2 创建自己的配置属性
      • 5.2.1 定义配置属性持有者
      • 5.2.2 声明配置属性元数据
    • 5.3 使用 profile 文件进行配置
      • 5.3.1 定义特定 profile 的属性
      • 5.3.2 激活 profile 文件
      • 5.3.3 有条件地使用 profile 文件创建 bean
    • 5.4 小结
  • 第二部分 集成 Spring
  • 第 6 章 创建 REST 服务
    • 6.1 编写 RESTful 控制器
      • 6.1.1 从服务器获取数据
      • 6.1.2 向服务器发送数据
      • 6.1.3 更新服务器上的资源
      • 6.1.4 从服务器删除数据
    • 6.2 启用超媒体
      • 6.2.1 添加超链接
      • 6.2.2 创建资源装配器
      • 6.2.3 嵌套命名关系
    • 6.3 启用以数据为中心的服务
      • 6.3.1 调整资源路径和关系名称
      • 6.3.2 分页和排序
      • 6.3.3 添加用户端点
      • 6.3.4 向 Spring Data 端点添加用户超链接
    • 6.4 小结
  • 第 7 章 调用 REST 服务
    • 7.1 使用 RestTemplate 调用 REST 端点
      • 7.1.1 请求 GET 资源
      • 7.1.2 请求 PUT 资源
      • 7.1.3 请求 DELETE 资源
      • 7.1.4 请求 POST 资源
    • 7.2 使用 Traverson 引导 REST API
    • 7.3 小结
  • 第 8 章 发送异步消息
    • 8.1 使用 JMS 发送消息
      • 8.1.3 接收 JMS 消息
      • 8.1.2 使用 JmsTemplate 发送消息
      • 8.1.1 设置 JMS
    • 8.2 使用 RabbitMQ 和 AMQP
      • 8.2.1 添加 RabbitMQ 到 Spring 中
      • 8.2.2 使用 RabbitTemplate 发送消息
      • 8.2.3 从 RabbitMQ 接收消息
    • 8.3 使用 Kafka 发送消息
      • 8.3.1 在 Spring 中设置 Kafka
      • 8.3.2 使用 KafkaTemplate 发送消息
      • 8.3.3 编写 Kafka 监听器
    • 8.4 小结
  • 第 9 章 集成 Spring
    • 9.1 声明简单的集成流
      • 9.1.1 使用 XML 定义集成流
      • 9.1.2 在 Java 中配置集成流
      • 9.1.3 使用 Spring Integration 的 DSL 配置
    • 9.2 探索 Spring Integration
      • 9.2.1 消息通道
      • 9.2.2 过滤器
      • 9.2.3 转换器
      • 9.2.4 路由
      • 9.2.5 分割器
      • 9.2.6 服务激活器
      • 9.2.7 网关
      • 9.2.8 通道适配器
      • 9.2.9 端点模块
    • 9.3 创建 Email 集成流
    • 9.4 总结
  • 第三部分 响应式 Spring
  • 第 10 章 Reactor 介绍
    • 10.1 理解响应式编程
      • 10.1.1 定义响应式流
    • 10.2 Reactor
      • 10.2.1 图解响应式流
      • 10.2.2 添加 Reactor 依赖
    • 10.3 通用响应式操作实战
      • 10.3.1 创建响应式类型
      • 10.3.2 响应式类型结合
      • 10.3.3 转换和过滤响应式流
      • 10.3.4 对反应类型执行逻辑操作
    • 10.4 总结
  • 第 11 章 开发响应式 API
    • 11.1 使用 Spring WebFlux
      • 11.1.1 Spring WebFlux 介绍
      • 11.1.2 编写响应式 Controller
    • 11.2 定义函数式请求处理程序
    • 11.3 测试响应式 Controller
      • 11.3.1 测试 GET 请求
      • 11.3.2 测试 POST 请求
      • 11.3.3 使用线上服务器进行测试
    • 11.4 响应式消费 REST API
      • 11.4.1 通过 GET 方式获取资源
      • 11.4.2 通过 POST 方式发送资源
      • 11.4.3 删除资源
      • 11.4.4 处理请求错误
      • 11.4.5 请求转换
    • 11.5 保护响应式 web API
      • 11.5.1 配置响应式 Web 安全
      • 11.5.2 配置响应式用户信息服务
    • 11.6 总结
  • 第 12 章 响应式持久化数据
    • 12.1 理解 Spring Data 响应式历程
      • 12.1.1 Spring Data 响应式精髓
      • 12.1.2 在响应式与非响应式之间进行转换
      • 12.1.3 开发响应式库
    • 12.2 使用响应式 Cassandra 库
      • 12.2.1 开启 Spring Data Cassandra
      • 12.2.2 理解 Cassandra 数据模型
      • 12.2.3 Cassandra 持久化实体映射
      • 12.2.4 编写响应式 Cassandra 库
    • 12.3 编写响应式 MongoDB 库
      • 12.3.1 开启Spring Data MongonDB
      • 12.3.2 MongoDB 持久化实体映射
      • 12.3.3 编写响应式 MongoDB 库
    • 12.4 总结
  • 第四部分 云原生 Spring
  • 第 13 章 服务发现
    • 13.1深入思考微服务
    • 13.2 配置服务注册
      • 13.2.1 配置 Eureka
      • 13.2.2 扩展 Eureka
    • 13.3 注册并发现服务
      • 13.3.1 配置 Eureka 客户端属性
      • 13.3.2 消费服务
    • 13.4 总结
  • 第 14 章 配置管理
    • 14.1 共享配置
    • 14.2 运行配置服务器
      • 14.2.1 启动配置服务器
      • 14.2.2 填写配置库
    • 14.3 消费共享的配置
    • 14.4 服务应用程序和特定配置文件的属性
      • 14.4.1 服务特定应用程序的属性
      • 14.4.2 服务配置文件属性
    • 14.5 为配置的属性加密
      • 14.5.1 在 Git 中加密属性
      • 14.5.2 在 Vault 中存储密码
    • 14.6 远程刷新配置属性
      • 14.6.1 手动刷新配置属性
      • 14.6.2 自动刷新配置属性
    • 14.7 总结
  • 第 15 章 处理失败和时延
    • 15.1 了解断路器
    • 15.2 定义断路器
      • 15.2.1 缓解时延
      • 15.2.2 管理断路器阈值
    • 15.3 管理失败事件
      • 15.3.1 介绍 Hystrix 面板
      • 15.3.2 了解 Hystrix 线程池
    • 15.4 聚合多个 Hystrix 流
    • 15.5 总结
  • 第五部分 部署Spring
  • 第 16 章 使用 SpringBoot Actuator
    • 16.1 介绍 Actuator
      • 16.1.1 配置 Actuator 基本路径
      • 16.1.2 启用和禁用 Actuator 端点
    • 16.2 使用 Actuator 端点
      • 16.2.1 获取重要的应用程序信息
      • 16.2.2 查看配置详细信息
      • 16.2.3 查看应用程序活动
      • 16.2.4 利用运行时指标
    • 16.3 自定义 Actuator
      • 16.3.1 向 /info 端点提供信息
      • 16.3.2 自定义健康指标
      • 16.3.3 注册自定义指标
      • 16.3.4 创建自定义端点
    • 16.4 保护 Actuator
    • 16.5 总结
  • 第 17 章 管理 Spring
    • 17.1 使用 SpringBoot Admin
      • 17.1.1 创建 Admin 服务端
      • 17.1.2 注册 Admin 客户端
    • 17.2 深入 Admin 服务端
      • 17.2.1 查看普通应用程序运行状况和信息
      • 17.2.2 观察关键指标
      • 17.2.3 检查环境属性
      • 17.2.4 查看并设置 log 级别
      • 17.2.5 监控线程
      • 17.2.6 追踪 HTTP 请求
    • 17.3 保护 Admin 服务端
      • 17.3.1 在 Admin 服务端中启用登录
      • 17.3.2 使用 Actuator 进行认证
    • 17.4 总结
  • 第 18 章 使用 JMX 监控 Spring
    • 18.1 使用 Actuator MBean
    • 18.2 创建自己的 MBean
    • 18.3 发送通知
    • 18.4 总结
  • 第 19 章 部署 Spring
    • 19.1 权衡部署选项
    • 19.2 构建并部署 WAR 文件
    • 19.3 将 JAR 文件推送到 Cloud Foundry
    • 19.4 在 Docker 容器中运行 SpringBoot
    • 19.5 终章
    • 19.6 总结
由 GitBook 提供支持
在本页
  • 使用 RestTemplate 消费服务
  • 使用 WebClient 消费服务
  • 定义 Feign 接口客户端

这有帮助吗?

  1. 第 13 章 服务发现
  2. 13.3 注册并发现服务

13.3.2 消费服务

在消费者的代码中,硬编码任何服务实例的 URL 都将是错误的。这不仅将消费者与服务的特定实例相结合,而且如果服务的主机或端口要更改,还会导致消费服务中断。

另一方面,当涉及在 Eureka 中查找服务时,消费应用程序还有一些工作,因为 Eureka 可能回复提供相同服务的多个实例。如果消费者查询 ingredient-service 服务,并收到六个服务实例,那该如何选择正确的服务实例呢?

好消息是,消费应用程序不需要做出选择,甚至不需要自己明确地查找服务。Spring Cloud 的 Eureka 客户端,以及 Ribbon 负载均衡器,使查找、选择和使用一个服务实例变得很简单。使用从 Eureka 查找到的服务有两种方法,包括:

  • 一个负载均衡的 RestTemplate

  • Feign 接口生成的客户端

您可以根据个人喜好来选择。下面将介绍这两种方式,先从负载均衡 RestTemplate开始。然后您自己决定喜欢哪一个。

使用 RestTemplate 消费服务

您在第 7 章中,首次看到了 Spring 的 RestTemplate。重温一下它是如何工作的。一旦创建或注入了 RestTemplate,您就可以发送 HTTP 调用,并将响应绑定到实体类上。例如,要执行 HTTP GET 请求,按 ID 检索 Ingredient,您可以使用以下 RestTemplate 代码:

public Ingredient getIngredientById(String ingredientId) {
  return rest.getForObject("http://localhost:8080/ingredients/{id}",
                            Ingredient.class, ingredientId);
}

这段代码的唯一问题是,传递到 getForObject() 的 URL 是硬编码到特定的主机和端口的。虽然您可以将 URL 提取到一个配置属性中,但如果请求是对 Ingredient 服务的多个实例之一,您配置的任何 URL 都将只针对特定实例,而不能在多个实例中进行负载均衡。

但是,一旦将应用程序设为 Eureka 客户端,您就可以声明这是一个带有负载均衡的 RestTemplate。您所需要做的,就是为方法添加 @Bean 和 @LoadBalanced 注解:

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

@LoadBalanced 注解有两个目的:首先也是最重要的,它告诉 Spring Cloud,这个 RestTemplate 应该能够通过 Ribbon 查找服务。另外,它可以作为一个注入限定符。因为,如果您有两个或两个以上的 RestTemplate,这指定了要使用带有负载均衡的 RestTemplate。

例如,您希望使用负载均衡的 RestTemplate,像以前的代码那样查找 Ingredient。首先,将负载均衡 RestTemplate 注入到实体:

@Component
public class IngredientServiceClient {

  private RestTemplate rest;

  public IngredientServiceClient(@LoadBalanced RestTemplate rest) {
    this.rest = rest;
  }

  ...

}

然后稍微改写一下 getIngredientById() 方法来获取 Ingredient,以便它使用服务的注册名称,而不是显式的指定主机和端口:

public Ingredient getIngredientById(String ingredientId) {
  return rest.getForObject(
              "http://ingredient-service/ingredients/{id}",
              Ingredient.class, ingredientId);
}

你注意到两者的区别了吗?为 getForObject() 指定的 URL,没有使用任何特定的主机名或端口。使用服务名称 ingredient-service 来代替主机名和端口。内部 RestTemplate 要求 Ribbon 查找服务并选择一个实例。Ribbon 很高兴提供帮助,重写 URL 以包含所选服务实例的主机和端口,然后让 RestTemplate 照常进行后续工作。

正如您所看到的,使用负载均衡的 RestTemplate 与使用标准的 RestTemplate 并没有什么不同。关键不同在于,客户端代码只需要使用服务名称,而不是显式的主机名和端口。但是,如果您使用的是 WebClient 而不是 RestTemplate 呢?WebClient 也可以与 Ribbon 一起按名称来使用服务吗?

使用 WebClient 消费服务

在第 11 章,您看到了 WebClient 如何提供类似于 RestTemplate 的 HTTP 客户端。但它处理的是响应式类型,如 Flux 和 Mono。如果您已经被响应式编程错误所困扰,那么您可能更喜欢使用 WebClient 而不是RestTemplate。好消息是,您可以像使用 RestTemplate 那样使用 WebClient。首先要做的是声明一个 WebClient,并添加 @LoadBalanced 注解到 WebClient.Builder 方法上:

@Bean
@LoadBalanced
public WebClient.Builder webClientBuilder() {
  return WebClient.builder();
}

有了 WebClient.Builder bean,现在就可以注入到任何需要使用它的地方了。例如,您可以将其注入到 IngredientServiceClient 的构造函数中:

@Component
public class IngredientServiceClient {

  private WebClient.Builder wcBuilder;

  public IngredientServiceClient(
         @LoadBalanced WebClient.Builder wcBuilder) {
    this.wcBuilder = wcBuilder;
  }

 ...

}

最后,当您准备好使用它时,您可以使用 WebClient.Builder 以构建一个 WebClient,然后使用各服务在Eureka 中注册的服务名称发出实际请求:

public Mono<Ingredient> getIngredientById(String ingredientId) {
  return wcBuilder.build()
    .get()
      .uri("http://ingredient-service/ingredients/{id}", ingredientId)
    .retrieve().bodyToMono(Ingredient.class);
}

与负载均衡的 RestTemplate 一样,在发出请求时无需明确指定主机或端口。服务名称将从给定的 URL 中提取,并用来从 Eureka 查找服务。然后,Ribbon 将选择一个服务实例,并且在发出请求之前,使用所选实例的主机和端口重写 URL。

这个编程模型很容易掌握,特别是如果你已经熟悉 RestTemplate 或 WebClient。Spring Cloud 还有另一个技巧,接下来让我们来看看,如何使用 Feign 来创建基于接口的客户端。

定义 Feign 接口客户端

Feign 是一个 REST 客户端库,它用一种独特的、接口驱动的方式来定义 REST 客户端。简而言之,如果你喜欢 Spring Data 自动实现 Repository 接口的方式,那您肯定会喜欢 Feign。

使用 Feign 的第一步是将依赖项添加到项目中。在 pom.xml 中,以下 <dependency> 做到了这一点:

<dependency>
  <groupId>org.springframework.cloud</groupId>
  <artifactId>spring-cloud-starter-openfeign</artifactId>
</dependency>

使用 Spring Initializr 时,可以通过选中 Feign 复选框,自动添加相同的启动依赖项。不幸的是,基于这个依赖的自动配置无法自动启用 Feign。因此,需要将 @EnableFeignClient 注解添加到其中一个配置类:

@Configuration
@EnableFeignClients
public RestClientConfiguration {
}

现在,有趣的部分来了。假设你想写一个客户端,从 Eureka 注册表中获取 ingredient-service 服务,并进而获取 Ingredient。您应该像下面这样使用:

package tacos.ingredientclient.feign;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import tacos.ingredientclient.Ingredient;

@FeignClient("ingredient-service")
public interface IngredientClient {

   @GetMapping("/ingredients/{id}")
   Ingredient getIngredient(@PathVariable("id") String id);

}

这是一个简单的接口,没有实现。但在运行时,当 Feign 接管以后,这些都不重要。Feign 会自动创建一个实现,并将其公开为 Spring 应用程序上下文的一个 bean。

仔细观察,你会看到有一些新注解。接口级的 @FeignClient 注解,指明了在此接口中声明的任何方法,将对名称为 ingredient-service 的服务发出请求。在内部,将通过 Ribbon 查找,就像使用 RestTemplate 时那样。

然后是 getIngredient() 方法,您一定认出了来自于 Spring MVC 的 @GetMapping 注解。事实上,确实是同样的注解!只是这次是用在客户端上,而不是在 Controller 上。也就是说,任何对 getIngredient() 的调用,都将导致 Ribbon 选择相应主机和端口,并把 GET 请求转到 /ingredients/{id} 上。@PathVariable 注解同样来自 Spring MVC,会将参数映射到给定路径中的占位符中。

剩下的就是在需要时注入 Feign 实现的接口,并开始使用它。例如,要在 Controller 中使用它,您可以执行这样的操作:

@Controller
@RequestMapping("/ingredients")
public class IngredientController {

  private IngredientClient client;

  @Autowired
  public IngredientController(IngredientClient client) {
    this.client = client;
  }

  @GetMapping("/{id}")
  public String ingredientDetailPage(@PathVariable("id") String id,
                                     Model model) {
    model.addAttribute("ingredient", client.getIngredient(id));
    return "ingredientDetail";
 }

}

我不知道您怎么想,但我觉这真是太棒了!很难确定我最喜欢哪一个:负载均衡的 RestTemplate、WebClient,或者这个神奇的 Feign 接口。无论您选择哪一个,您都可以放心,您的 REST 客户端将能够使用在 Eureka 注册的服务,而无需对任何特定的主机名或端口进行硬编码。

另外,Feign 有自己的一组注解。@RequestLine 和 @Param 大致类似于 Spring MVC 的 @RequestMapping 和 @PathVariable,只是使用方式有点差异。不过,能够在客户端上使用已经熟悉的 Spring MVC 注解,这一点是相当好的。

上一页13.3.1 配置 Eureka 客户端属性下一页13.4 总结

最后更新于3年前

这有帮助吗?

Feign 最初是 Netflix 公司的一个项目,但后来作为了一个独立开源项目,名为 OpenFeign ()。Feign 这个词的意思是“假装”,您很快就会看到,使用这个词,对于假装的 REST 的客户端确实是非常合适。

https://github.com/OpenFeign