SpringCloud 系列文章

SpringCloud

生产者与消费者

上一篇文章我们介绍了Euarka的搭建，本篇文章，我们搭建俩个服务，生产者服务与消费者服务。

我们就以电商系统为例：服务生产者，订单查询服务order-server，服务消费者order-client

说明：order-server 服务提供查询订单信息的功能<br>order-client作为消费者服务，查询订单信息。

生产者服务搭建

选择我们需要的依赖,具体依赖如下：

1<dependency>
2  <groupId>org.springframework.boot</groupId>
3   <artifactId>spring-boot-starter-web</artifactId>
4</dependency>
5<dependency>
6  <groupId>org.springframework.cloud</groupId>
7  <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
8</dependency>

spring-cloud-starter-netflix-eureka-client 表示该服务是一个eureka的客户端，<br>订单服务会注册到eureka服务端上

依赖添加完成后，我们需要在SpringBoot项目的入口类上加上@EnableDiscoveryClient注解，</br>表示开启服务注册到eureka服务上：

1@SpringBootApplication
2@EnableDiscoveryClient
3public class OrderServiceApplication {
4
5    public static void main(String[] args) {
6        SpringApplication.run(OrderServiceApplication.class, args);
7    }
8
9}

接下来，需要我们对订单服务进行必要的配置：

1server:
2  port: 8081
3
4spring:
5  application:
6    name: order-service
7
8eureka:
9  client:
10    service-url:
11      defaultZone: http://localhost:8761/eureka

说明：server.prot:订单服务的端口</br>spring.application.name:订单服务的名称，</br>这个名称会注册到eureka服务上</br>eureka.client.service-url.defaultZone:eureka服务的地址。

经过简单的配置以后，我们启动服务，访问eureka服务,http://localhost:8761，如下图：

我们将订单服务以及注册到eureka服务上了。此事，我们提供一个订单查询的接口，模拟订单查询功能。

1@RestController
2@RequestMapping("query")
3public class OrderQueryController {
4    @Autowired
5    OrderQueryService queryService;
6
7    @RequestMapping("info")
8    public String queryOrder(){
9        return queryService.queryOrder();
10    }
11}
12
13
14@Service
15public class OrderQueryService {
16
17    public String queryOrder(){
18        return "订单信息查询成功";
19    }
20}

消费者服务搭建

只需要像搭建服务提供者一样搭建服务消费者就可以，搭建完成以后，我们使用RestTemplate来调用订单服务进行订单信息查询，具体配置及代码如下：

1server:
2  port: 8082
3
4spring:
5  application:
6    name: order-client
7
8eureka:
9  client:
10    service-url:
11      defaultZone: http://localhost:8761/eureka
12
13
14//提供一个RestTemplate实例
15@SpringBootApplication
16@EnableDiscoveryClient
17public class OrderClientApplication {
18
19    public static void main(String[] args) {
20        SpringApplication.run(OrderClientApplication.class, args);
21    }
22
23    @Bean
24    @LoadBalanced
25    public RestTemplate restTemplate() {
26        return new RestTemplate();
27    }
28}
29
30//编写测试接口
31@RestController
32public class ClientController {
33    @Autowired
34    ClientService clientService;
35
36    @RequestMapping(value = "/info",method = RequestMethod.GET)
37    public String queryOrderInfo(){
38        return "restTemplate访问服务提供者返回的信息:"+clientService.queryOrderInfo();
39    }
40}
41
42//模拟具体查询业务逻辑
43@Service
44public class ClientService {
45
46    @Autowired
47    RestTemplate restTemplate;
48
49    public String queryOrderInfo(){
50        System.out.println("通过restTemplate访问服务提供者");
51        return restTemplate.getForEntity("http://ORDER-SERVER/query/info", 			  String.class).getBody();
52    }
53
54}

RestTemplate 介绍：<br>是spring框架提供的可用于在应用中调用rest服务，它简化了与http服务的通信方式，统一了RESTful的标准，封装了http链接， 我们只需要传入url及返回值类型即可。相较于之前常用的HttpClient，RestTemplate是一种更优雅的调用RESTful服务的方式。

源码分析

部分源码如下，可以看出，它包含了Get、Post、Put等请求，比如Get请求包含俩种方法getForObject、getForEntity,他们有什么区别呢？

• 从接口的签名上，可以看出一个是直接返回预期的对象，一个则是将对象包装到 ResponseEntity 封装类中

• 如果只关心返回结果，那么直接用 getForObject 即可

• 如果除了返回的实体内容之外，还需要获取返回的header等信息，则可以使用 getForEntity

  @Override @Nullable public <T> T getForObject(String url, Class<T> responseType, Object... uriVariables) throws RestClientException { RequestCallback requestCallback = acceptHeaderRequestCallback(responseType); HttpMessageConverterExtractor<T> responseExtractor = new HttpMessageConverterExtractor<>(responseType, getMessageConverters(), logger); return execute(url, HttpMethod.GET, requestCallback, responseExtractor, uriVariables); }

  1@Override
  2@Nullable
  3public <T> T getForObject(String url, Class<T> responseType, Map<String, ?> uriVariables) throws RestClientException {
  4	RequestCallback requestCallback = acceptHeaderRequestCallback(responseType);
  5	HttpMessageConverterExtractor<T> responseExtractor =
  6			new HttpMessageConverterExtractor<>(responseType, getMessageConverters(), logger);
  7	return execute(url, HttpMethod.GET, requestCallback, responseExtractor, uriVariables);
  8}
  9
  10@Override
  11@Nullable
  12public <T> T getForObject(URI url, Class<T> responseType) throws RestClientException {
  13	RequestCallback requestCallback = acceptHeaderRequestCallback(responseType);
  14	HttpMessageConverterExtractor<T> responseExtractor =
  15			new HttpMessageConverterExtractor<>(responseType, getMessageConverters(), logger);
  16	return execute(url, HttpMethod.GET, requestCallback, responseExtractor);
  17}
  18
  19@Override
  20public <T> ResponseEntity<T> getForEntity(String url, Class<T> responseType, Object... uriVariables)
  21		throws RestClientException {
  22
  23	RequestCallback requestCallback = acceptHeaderRequestCallback(responseType);
  24	ResponseExtractor<ResponseEntity<T>> responseExtractor = responseEntityExtractor(responseType);
  25	return nonNull(execute(url, HttpMethod.GET, requestCallback, responseExtractor, uriVariables));
  26}
  27
  28@Override
  29public <T> ResponseEntity<T> getForEntity(String url, Class<T> responseType, Map<String, ?> uriVariables)
  30		throws RestClientException {
  31
  32	RequestCallback requestCallback = acceptHeaderRequestCallback(responseType);
  33	ResponseExtractor<ResponseEntity<T>> responseExtractor = responseEntityExtractor(responseType);
  34	return nonNull(execute(url, HttpMethod.GET, requestCallback, responseExtractor, uriVariables));
  35}
  36
  37@Override
  38public <T> ResponseEntity<T> getForEntity(URI url, Class<T> responseType) throws RestClientException {
  39	RequestCallback requestCallback = acceptHeaderRequestCallback(responseType);
  40	ResponseExtractor<ResponseEntity<T>> responseExtractor = responseEntityExtractor(responseType);
  41	return nonNull(execute(url, HttpMethod.GET, requestCallback, responseExtractor));
  42}
  43
  44
  45// HEAD
  46
  47@Override
  48public HttpHeaders headForHeaders(String url, Object... uriVariables) throws RestClientException {
  49	return nonNull(execute(url, HttpMethod.HEAD, null, headersExtractor(), uriVariables));
  50}
  51
  52@Override
  53public HttpHeaders headForHeaders(String url, Map<String, ?> uriVariables) throws RestClientException {
  54	return nonNull(execute(url, HttpMethod.HEAD, null, headersExtractor(), uriVariables));
  55}
  56
  57@Override
  58public HttpHeaders headForHeaders(URI url) throws RestClientException {
  59	return nonNull(execute(url, HttpMethod.HEAD, null, headersExtractor()));
  60}
  61
  62
  63// POST
  64
  65@Override
  66@Nullable
  67public URI postForLocation(String url, @Nullable Object request, Object... uriVariables)
  68		throws RestClientException {
  69
  70	RequestCallback requestCallback = httpEntityCallback(request);
  71	HttpHeaders headers = execute(url, HttpMethod.POST, requestCallback, headersExtractor(), uriVariables);
  72	return (headers != null ? headers.getLocation() : null);
  73}
  74
  75@Override
  76@Nullable
  77public URI postForLocation(String url, @Nullable Object request, Map<String, ?> uriVariables)
  78		throws RestClientException {
  79
  80	RequestCallback requestCallback = httpEntityCallback(request);
  81	HttpHeaders headers = execute(url, HttpMethod.POST, requestCallback, headersExtractor(), uriVariables);
  82	return (headers != null ? headers.getLocation() : null);
  83}
  84
  85@Override
  86@Nullable
  87public URI postForLocation(URI url, @Nullable Object request) throws RestClientException {
  88	RequestCallback requestCallback = httpEntityCallback(request);
  89	HttpHeaders headers = execute(url, HttpMethod.POST, requestCallback, headersExtractor());
  90	return (headers != null ? headers.getLocation() : null);
  91}
  92
  93@Override
  94@Nullable
  95public <T> T postForObject(String url, @Nullable Object request, Class<T> responseType,
  96		Object... uriVariables) throws RestClientException {
  97
  98	RequestCallback requestCallback = httpEntityCallback(request, responseType);
  99	HttpMessageConverterExtractor<T> responseExtractor =
  100			new HttpMessageConverterExtractor<>(responseType, getMessageConverters(), logger);
  101	return execute(url, HttpMethod.POST, requestCallback, responseExtractor, uriVariables);
  102}
  103
  104@Override
  105@Nullable
  106public <T> T postForObject(String url, @Nullable Object request, Class<T> responseType,
  107		Map<String, ?> uriVariables) throws RestClientException {
  108
  109	RequestCallback requestCallback = httpEntityCallback(request, responseType);
  110	HttpMessageConverterExtractor<T> responseExtractor =
  111			new HttpMessageConverterExtractor<>(responseType, getMessageConverters(), logger);
  112	return execute(url, HttpMethod.POST, requestCallback, responseExtractor, uriVariables);
  113}
  114
  115@Override
  116@Nullable
  117public <T> T postForObject(URI url, @Nullable Object request, Class<T> responseType)
  118		throws RestClientException {
  119
  120	RequestCallback requestCallback = httpEntityCallback(request, responseType);
  121	HttpMessageConverterExtractor<T> responseExtractor =
  122			new HttpMessageConverterExtractor<>(responseType, getMessageConverters());
  123	return execute(url, HttpMethod.POST, requestCallback, responseExtractor);
  124}
  125
  126@Override
  127public <T> ResponseEntity<T> postForEntity(String url, @Nullable Object request,
  128		Class<T> responseType, Object... uriVariables) throws RestClientException {
  129
  130	RequestCallback requestCallback = httpEntityCallback(request, responseType);
  131	ResponseExtractor<ResponseEntity<T>> responseExtractor = responseEntityExtractor(responseType);
  132	return nonNull(execute(url, HttpMethod.POST, requestCallback, responseExtractor, uriVariables));
  133}
  134
  135@Override
  136public <T> ResponseEntity<T> postForEntity(String url, @Nullable Object request,
  137		Class<T> responseType, Map<String, ?> uriVariables) throws RestClientException {
  138
  139	RequestCallback requestCallback = httpEntityCallback(request, responseType);
  140	ResponseExtractor<ResponseEntity<T>> responseExtractor = responseEntityExtractor(responseType);
  141	return nonNull(execute(url, HttpMethod.POST, requestCallback, responseExtractor, uriVariables));
  142}
  143
  144@Override
  145public <T> ResponseEntity<T> postForEntity(URI url, @Nullable Object request, Class<T> responseType)
  146		throws RestClientException {
  147
  148	RequestCallback requestCallback = httpEntityCallback(request, responseType);
  149	ResponseExtractor<ResponseEntity<T>> responseExtractor = responseEntityExtractor(responseType);
  150	return nonNull(execute(url, HttpMethod.POST, requestCallback, responseExtractor));
  151}
  

接下来，我们启动，服务消费者，此时访问我们的eureka服务，已经有俩个服务注册上来了，如下：

最后我们来验证一下，服务消费者是否能调用到服务提供者，在浏览器输出http://localhost:8082/info

根据返回的信息，确认服务调用成功。

总结：以上就是我们基于eureka的服务注册发现机制，实现的服务之间的相互调用。当然，这里边还有很多的细节需要讨论，后续的文章，继续和大家讨论。