SpringCloud

SpringCloud

目录

• 提供者\消费者
• RestTemplate

重点

• 提供者\消费者

难点

• 提供者\消费者

提供者与消费者

什么是提供者与消费者

提供者与消费者
服务提供者:一次业务中，被其它微服务调用的服务。(提供接口给其它微服务)
服务消费者:一次业务中，调用其它微服务的服务。(调用其它微服务提供的接口)

1.服务调用关系
服务提供者:暴露接口给其它微服务调用
服务消费者:调用其它微服务提供的接口
提供者与消费者角色其实是相对的
一个服务可以同时是服务提供者和服务消费者

案例

步骤

把之前搭建好的两个SpringBoot跑起来。

使用postman发起请求

向8082端口的项目发起请求，后台接收到请求并且返回了数据

向8081端口的项目发起请求，后台接收到请求并且返回了数据

现在使用Spring提供的访问rest接口的工具类RestTemplete。

首先

把RestTemplet变成Bean，SpringBoot官方从1.3之后就不再直接注入RestTemplete进入容器。

@Configuration
public class ApplicationConfig {

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

然后修改8082的代码，访问8081的/order/query接口。

    @Autowired
    RestTemplate restTemplate;
    @RequestMapping("/order")
    @ResponseBody
    public String order(@RequestParam Map map){
        return JSON.toJSONString(restTemplate.postForObject("http://127.0.0.1:8081/order/query",map,String.class));
    }

重启8082项目，发起请求观看返回的结果

以上有两个项目，端口8082的项目，访问了端口8081的项目的接口并且返回了结果，咱们就称呼这种8081项目为接口的提供者、端口8082的项目就叫做消费者。

RestTemplet

Rest风格

REST：即 Representational State Transfer。（资源）表现层状态转化。是目前最流行的一种互 联网软件架构。它结构清晰、符合标准、易于理解、扩展方便， 所以正得到越来越多网站的采用。使用 REST 风格的请求方式，可以简化 url，达到使用同一个 url 不同请求方式来执行不同的方法。

REST 风格的请求方式分别对应了以下四种请求，这四种请求有分别对应了四种对资源的操作：

GET -----------> 获取资源

POST ---------> 新建资源

PUT -----------> 更新资源

DELETE ------> 删除资源

简述

​ RestTemplate是Spring提供的用于访问的Rest服务的客户端，提供用于访问Rest服务的客户端，RestTemplate提供了多种便捷访问远程Http服务的方法，能够大大提高客户端的编写效率。

​ RestTemplate是Spring用于同步client端的核心类，简化了与hhtp服务通信，并满足RestFul原则，程序代码可以给它提供URL，并提取结果。默认情况下。RestTemplate默认以来jdk的http连接工具。也可以通过setRequestFactory属性切换到不同的HTTP源，比如Apache，HttpComponents、Netty和OkHttp。

常规配置

` public MyRestClientService(RestTemplateBuilder restTemplateBuilder) {          
        this.restTemplate = restTemplateBuilder              
        .basicAuthorization("username", "password")              
        .setConnectTimeout(3000)             
        .setReadTimeout(5000)              
        .rootUri("http://api.example.com/")              
        .build();    
}`

ClientHttpRequestInterceptor

学习使用带有Spring RestTemplate的ClientHttpRequestInterceptor，以Spring AOP风格记录请求和响应头和主体。

拦截器记录请求和响应

`import org.slf4j.Logger;import org.slf4j.LoggerFactory; import org.springframework.http.HttpRequest; import org.springframework.http.client.ClientHttpRequestExecution; import org.springframework.http.client.ClientHttpRequestInterceptor; import org.springframework.http.client.ClientHttpResponse; import org.springframework.util.StreamUtils;   import java.io.IOException; import java.nio.charset.Charset;  public class RequestResponseLoggingInterceptor implements ClientHttpRequestInterceptor {          private final Logger log = LoggerFactory.getLogger(this.getClass());      @Override    public ClientHttpResponse intercept(HttpRequest request, byte[] body, ClientHttpRequestExecution execution) throws IOException    {        logRequest(request, body);        ClientHttpResponse response = execution.execute(request, body);        logResponse(response);         //Add optional additional headers        response.getHeaders().add("headerName", "VALUE");         return response;    }      private void logRequest(HttpRequest request, byte[] body) throws IOException    {        if (log.isDebugEnabled())        {            log.debug("===========================request begin================================================");            log.debug("URI         : {}", request.getURI());            log.debug("Method      : {}", request.getMethod());            log.debug("Headers     : {}", request.getHeaders());            log.debug("Request body: {}", new String(body, "UTF-8"));            log.debug("==========================request end================================================");        }    }      private void logResponse(ClientHttpResponse response) throws IOException    {        if (log.isDebugEnabled())        {            log.debug("============================response begin==========================================");            log.debug("Status code  : {}", response.getStatusCode());            log.debug("Status text  : {}", response.getStatusText());            log.debug("Headers      : {}", response.getHeaders());            log.debug("Response body: {}", StreamUtils.copyToString(response.getBody(), Charset.defaultCharset()));            log.debug("=======================response end=================================================");        }    } }`

注册ClientHttpRequestInterceptor

`@Bean public RestTemplate restTemplate(){    RestTemplate restTemplate = new RestTemplate();     restTemplate.setRequestFactory(newBufferingClientHttpRequestFactory(clientHttpRequestFactory()));    restTemplate.setMessageConverters(Collections.singletonList(mappingJacksonHttpMessageConverter()));     restTemplate.setInterceptors( Collections.singletonList(newRequestResponseLoggingInterceptor()) );     return restTemplate; }`

请求示例

GET

`private static void getEmployees(){    final String uri = "http://localhost:8080/springrestexample/employees";         RestTemplate restTemplate = new RestTemplate();    String result = restTemplate.getForObject(uri, String.class);         System.out.println(result); }`

使用RestTemplate定制HTTP头文件

`private static void getEmployees(){    final String uri = "http://localhost:8080/springrestexample/employees";         RestTemplate restTemplate = new RestTemplate();         HttpHeaders headers = new HttpHeaders();    headers.setAccept(Arrays.asList(MediaType.APPLICATION_JSON));    HttpEntity entity = new HttpEntity("parameters", headers);         ResponseEntity result = restTemplate.exchange(uri, HttpMethod.GET, entity, String.class);         System.out.println(result); }`

Get请求获取响应为一个对象

`private static void getEmployees(){    final String uri = "http://localhost:8080/springrestexample/employees";    RestTemplate restTemplate = new RestTemplate();         EmployeeListVO result = restTemplate.getForObject(uri, EmployeeListVO.class);         System.out.println(result); }`

URL 参数

`private static void getEmployeeById(){    final String uri = "http://localhost:8080/springrestexample/employees/{id}";         Map params = new HashMap();    params.put("id", "1");         RestTemplate restTemplate = new RestTemplate();    EmployeeVO result = restTemplate.getForObject(uri, EmployeeVO.class, params);         System.out.println(result); }`

POST

`private static void createEmployee(){    
    final String uri = "http://localhost:8080/springrestexample/employees";     
    EmployeeVO newEmployee = new EmployeeVO(-1, "Adam", "Gilly", "test@email.com");     
    RestTemplate restTemplate = new RestTemplate();    
    EmployeeVO result = restTemplate.postForObject( uri, newEmployee, EmployeeVO.class);     
    System.out.println(result);
}`

Submit Form Data

`HttpHeaders headers = new HttpHeaders();
headers.setContentType(MediaType.APPLICATION_FORM_URLENCODED);  
MultiValueMap map= new LinkedMultiValueMap<>(); 
map.add("id", "1");  
HttpEntity request = new HttpEntity<>(map, headers);  
RestTemplate restTemplate = new RestTemplate(); 
EmployeeVO result = restTemplate.postForObject( uri, request, EmployeeVO.class); 
System.out.println(result);`

PUT

`private static void updateEmployee(){    final String uri = "http://localhost:8080/springrestexample/employees/{id}";         Map params = new HashMap();    params.put("id", "2");         EmployeeVO updatedEmployee = new EmployeeVO(2, "New Name", "Gilly", "test@email.com");         RestTemplate restTemplate = new RestTemplate();    restTemplate.put ( uri, updatedEmployee, params); }`

Simple PUT

`Foo updatedInstance = new Foo("newName"); updatedInstance.setId(createResponse.getBody().getId()); String resourceUrl =   fooResourceUrl + '/' + createResponse.getBody().getId(); HttpEntity requestUpdate = new HttpEntity<>(updatedInstance, headers); template.exchange(resourceUrl, HttpMethod.PUT, requestUpdate, Void.class);`

使用.exchange和请求回调

`RequestCallback requestCallback(final Foo updatedInstance) {    return clientHttpRequest -> {        ObjectMapper mapper = new ObjectMapper();        mapper.writeValue(clientHttpRequest.getBody(), updatedInstance);        clientHttpRequest.getHeaders().add(          HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE);        clientHttpRequest.getHeaders().add(          HttpHeaders.AUTHORIZATION, "Basic " + getBase64EncodedLogPass());    }; }`

DELETE

private static void deleteEmployee(){
    final String uri = "http://localhost:8080/springrestexample/employees/{id}";
     
    Map<String, String> params = new HashMap<String, String>();
    params.put("id", "2");
     
    RestTemplate restTemplate = new RestTemplate();
    restTemplate.delete ( uri,  params );
}

该类的入口主要根据HTTP六个方法制定：

​ 在内部，RestTemplate默认使用HttpMessageConverter实例将HTTP消息转换成POJO或者从POJO转换成HTTP消息。默认情况下会注册主mime类型的转换器，但也可以通过setMessageConverters注册其他的转换器。(其实这点在使用的时候是察觉不到的，很多方法有一个responseType 参数，它让你传入一个响应体所映射成的对象，然后底层用HttpMessageConverter将其做映射)

HttpMessageConverterExtractor<T> responseExtractor =
                new HttpMessageConverterExtractor<>(responseType, getMessageConverters(), logger);

HttpMessageConverter.java源码：

public interface HttpMessageConverter<T> {
        //指示此转换器是否可以读取给定的类。
    boolean canRead(Class<?> clazz, @Nullable MediaType mediaType);

        //指示此转换器是否可以写给定的类。
    boolean canWrite(Class<?> clazz, @Nullable MediaType mediaType);

        //返回List<MediaType>
    List<MediaType> getSupportedMediaTypes();

        //读取一个inputMessage
    T read(Class<? extends T> clazz, HttpInputMessage inputMessage)
            throws IOException, HttpMessageNotReadableException;

        //往output message写一个Object
    void write(T t, @Nullable MediaType contentType, HttpOutputMessage outputMessage)
            throws IOException, HttpMessageNotWritableException;

}

在内部，RestTemplate默认使用SimpleClientHttpRequestFactory和DefaultResponseErrorHandler来分别处理HTTP的创建和错误，但也可以通过setRequestFactory和setErrorHandler来覆盖。

get请求实践

getForObject()方法

public <T> T getForObject(String url, Class<T> responseType, Object... uriVariables){}
public <T> T getForObject(String url, Class<T> responseType, Map<String, ?> uriVariables)
public <T> T getForObject(URI url, Class<T> responseType)

getForObject()其实比getForEntity()多包含了将HTTP转成POJO的功能，但是getForObject没有处理response的能力。因为它拿到手的就是成型的pojo。省略了很多response的信息。

pojo

public class Notice {
    private int status;
    private Object msg;
    private List<DataBean> data;
}
public  class DataBean {
  private int noticeId;
  private String noticeTitle;
  private Object noticeImg;
  private long noticeCreateTime;
  private long noticeUpdateTime;
  private String noticeContent;
}

不带get请求

    /**
     * 不带参的get请求
     */
    @Test
    public void restTemplateGetTest(){
        RestTemplate restTemplate = new RestTemplate();
        Notice notice = restTemplate.getForObject("http://xxx.top/notice/list/1/5"
                , Notice.class);
        System.out.println(notice);
    }

控制台打印：

INFO 19076 --- [           main] c.w.s.c.w.c.HelloControllerTest          
: Started HelloControllerTest in 5.532 seconds (JVM running for 7.233)

Notice{status=200, msg=null, data=[DataBean{noticeId=21, noticeTitle='aaa', noticeImg=null, 
noticeCreateTime=1525292723000, noticeUpdateTime=1525292723000, noticeContent='<p>aaa</p>'}, 
DataBean{noticeId=20, noticeTitle='ahaha', noticeImg=null, noticeCreateTime=1525291492000, 
noticeUpdateTime=1525291492000, noticeContent='<p>ah.......'

带参数的get请求1

Notice notice = restTemplate.getForObject("http://fantj.top/notice/list/{1}/{2}"
                , Notice.class,1,5);

明眼人一眼能看出是用了占位符{1}。

带参数的get请求2

        Map<String,String> map = new HashMap();
        map.put("start","1");
        map.put("page","5");
        Notice notice = restTemplate.getForObject("http://fantj.top/notice/list/"
                , Notice.class,map);

明眼人一看就是利用map装载参数，不过它默认解析的是PathVariable的url形式。

getForEntity()方法

public <T> ResponseEntity<T> getForEntity(String url, Class<T> responseType, Object... uriVariables){}
public <T> ResponseEntity<T> getForEntity(String url, Class<T> responseType, Map<String, ?> uriVariables){}
public <T> ResponseEntity<T> getForEntity(URI url, Class<T> responseType){}

与getForObject()方法不同的是返回的是ResponseEntity对象，如果需要转换成pojo，还需要json工具类的引入，这个按个人喜好用。不会解析json的可以百度FastJson或者Jackson等工具类。然后我们就研究一下ResponseEntity下面有啥方法。

ResponseEntity、HttpStatus、BodyBuilder结构

ResponseEntity.java

public HttpStatus getStatusCode(){}
public int getStatusCodeValue(){}
public boolean equals(@Nullable Object other) {}
public String toString() {}
public static BodyBuilder status(HttpStatus status) {}
public static BodyBuilder ok() {}
public static <T> ResponseEntity<T> ok(T body) {}
public static BodyBuilder created(URI location) {}
...

HttpStatus.java

public enum HttpStatus {
public boolean is1xxInformational() {}
public boolean is2xxSuccessful() {}
public boolean is3xxRedirection() {}
public boolean is4xxClientError() {}
public boolean is5xxServerError() {}
public boolean isError() {}
}

BodyBuilder.java

public interface BodyBuilder extends HeadersBuilder<BodyBuilder> {
    //设置正文的长度，以字节为单位，由Content-Length标头
      BodyBuilder contentLength(long contentLength);
    //设置body的MediaType 类型
      BodyBuilder contentType(MediaType contentType);
    //设置响应实体的主体并返回它。
      <T> ResponseEntity<T> body(@Nullable T body);
｝

本栏目推荐文章
• springcloud分布式微服务
• 闪速优选--五天学会SpringCloud实战
• springcloud
• springcloud五大组件之---Nacos
• 一款神仙级SpringCloud微服务开源项目，接私活吊到不行！(附源码)
• SpringCloud是什么
• Gradle+SpringCloud学习记录（一）
• springcloud动力节点-02Ribbon
• springcloud动力节点-01Eureka
• springcloud动力节点-03OpenFeign

SpringCloudspringcloud gateway springcloud架构 springcloud项目 springcloud-gateway springcloud openfeign springcloud笔记 springcloud-eureka springcloud consul springcloud附件 springcloud-zipkin