SpringCloudAlibaba- Feign (Best Practices for Production Environments)

Feign

Feign is Netflix’s open source, load-balancing, declarative Http client that uses Feign to call apis as if they were native methods, eliminating the need to constantly parse/encapsulate JSON data when calling target services. Feign is working to make it easier to write HTTP clients in Java.

Why use Feign

In our microservice environment, service discovery is implemented using NACOS and load balancing is implemented using ribbon. However, the following problems exist in inter-service invocation under the existing technology system, which is why we need to use Feign:

1. Poor code readability
2. Complex urls are difficult to maintain
3. It is difficult to respond to changes in requirements and is painful during rapid iterations
4. Different programming experiences

Feign implements HTTP calls

1. And rely on

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

2. Write notes

   In starting the class add @ EnableFeignClients (basePackages = “com. Samir. Contentcenter. Feignclient”) annotation (basePackages feign interface package path).

3. Write the configuration

4. Rewrite the code

   1. Write the FeIGN interface

      package com.samir.contentcenter.feignclient;
      
      import com.samir.contentcenter.domian.dto.user.UserDTO;
      import org.springframework.cloud.openfeign.FeignClient;
      import org.springframework.web.bind.annotation.GetMapping;
      import org.springframework.web.bind.annotation.RequestParam;
      
      @FeignClient(name = "user-center", path = "/users")
      public interface UserCenterClient {
      
          /**
           * http://user-center/users/{id}
           * @param id
           * @return* /
          @GetMapping(value = "/{id}")
          UserDTO findById(@RequestParam("id") Integer id);
      }
      Copy the code

   2. Modify the original code call

      package com.samir.contentcenter.service.content.impl;
      
      import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
      import com.samir.contentcenter.domian.dto.content.ShareDTO;
      import com.samir.contentcenter.domian.dto.user.UserDTO;
      import com.samir.contentcenter.domian.entity.content.Share;
      import com.samir.contentcenter.dao.content.ShareDao;
      import com.samir.contentcenter.feignclient.UserCenterClient;
      import com.samir.contentcenter.service.content.ShareService;
      import org.springframework.beans.BeanUtils;
      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;
      import java.util.concurrent.ThreadLocalRandom;
      import java.util.stream.Collectors;
      
      /** * Auto created by codeAppend plugin */
      @Service
      public class ShareServiceImpl extends ServiceImpl<ShareDao.Share> implements ShareService {
      
          @Autowired
          private RestTemplate restTemplate;
      
          @Autowired
          private DiscoveryClient discoveryClient;
      
          @Autowired
          private UserCenterClient userCenterClient;
      
          @Override
          public ShareDTO findById(Integer id) {
              // Get share details
              Share share = baseMapper.selectById(id);
              // Get the publisher ID
              Integer userId = share.getUserId();
      
      // List
                
                  instances = discoveryClient.getInstances("user-center");
                
      // List
                
                  urls = instances.stream().map(instance -> instance.getUri().toString() + "/users/{id}").collect(Collectors.toList());
                
      //
      // // random algorithm
      // int i = ThreadLocalRandom.current().nextInt(urls.size());
      // // Remotely invoke the user center service interface
      // UserDTO userDTO = restTemplate.getForObject(urls.get(i), UserDTO.class, userId);
      
              // Call the user-centric interface with feign
              UserDTO userDTO = userCenterClient.findById(userId);
      
              // Message assembly
              ShareDTO shareDTO = ShareDTO.builder()
                      .wxNickname(userDTO.getWxNickname())
                      .build();
              BeanUtils.copyProperties(share, shareDTO);
              returnshareDTO; }}Copy the code

The composition of Feign

Custom Feign log level

Fine-grained Configuration (Log level)

Java code approach

1. Write Feign configuration classes

   package com.samir.contentcenter.configuration;
   
   import feign.Logger;
   import org.springframework.context.annotation.Bean;
   // If the @configuration annotation is added, you need to avoid the problem of the parent and child above, otherwise it will be global; No writing is the best implementation
   public class UserCenterFeignConfigurantion {
       @Bean
       public Logger.Level level(a) {
           returnLogger.Level.FULL; }}Copy the code

2. Introduce configuration classes in the Feign client

   package com.samir.contentcenter.feignclient;
   
   import com.samir.contentcenter.configuration.UserCenterFeignConfigurantion;
   import com.samir.contentcenter.domian.dto.user.UserDTO;
   import org.springframework.cloud.openfeign.FeignClient;
   import org.springframework.web.bind.annotation.GetMapping;
   import org.springframework.web.bind.annotation.RequestParam;
   
   @FeignClient(name = "user-center", path = "/users", configuration = UserCenterFeignConfigurantion.class)
   public interface UserCenterClient {
   
       /**
        * http://user-center/users/{id}
        * @param id
        * @return* /
       @GetMapping(value = "/{id}")
       UserDTO findById(@RequestParam("id") Integer id);
   
   }
   Copy the code

3. Set the log level of the Feign client to DEBUG in the configuration file

   logging:
     level:
       com.samir.contentcenter.feignclient.UserCenterClient: debug
   Copy the code

Configuring Attribute Mode

feign.client.config.. LoggerLevel: indicates the log level

feign:
  client:
    config:
      user-center:
        loggerLevel: full
Copy the code

Global configuration

Java code approach

• Method 1: Make parent-child context ComponentSacn overlap (strongly not recommended)

• @enableFeignClients (defaultConfiguration= XXX.class)

  package com.samir.contentcenter;
  
  import com.samir.contentcenter.configuration.GlobalFeignConfiguration;
  import org.mybatis.spring.annotation.MapperScan;
  import org.springframework.boot.SpringApplication;
  import org.springframework.boot.autoconfigure.SpringBootApplication;
  import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
  import org.springframework.cloud.client.loadbalancer.LoadBalanced;
  import org.springframework.cloud.openfeign.EnableFeignClients;
  import org.springframework.context.annotation.Bean;
  import org.springframework.web.client.RestTemplate;
  
  @SpringBootApplication
  @MapperScan("com.samir.contentcenter.dao")
  @EnableDiscoveryClient
  // Just set the feign configuration in the launcher class
  @EnableFeignClients(basePackages = "com.samir.contentcenter.feignclient", defaultConfiguration = GlobalFeignConfiguration.class)
  public class ContentCenterApplication {
  
      public static void main(String[] args) {
          SpringApplication.run(ContentCenterApplication.class, args);
      }
  
      @Bean
      @LoadBalanced
      RestTemplate restTemplate(a) {
          return newRestTemplate(); }}Copy the code

Configuring Attribute Mode

Feign. Client. Config. Default. LoggerLevel: log level

feign:
  client:
    config:
      default: Default is the global configuration
        loggerLevel: full
Copy the code

Supported configuration items

Code way

Attribute way

Use the * * feign. Client. Config.. Property **. The following attributes:

• ConnectTimeout: 5000
• ReadTimeout: 5000
• LoggerLevel: Full # Log level
• ErrorDecoder: com. Example. SimpleErrorDecoder # error decoder
• Retryer: com. Example. # SimpleRetryer retry strategy
• RequestInterceptors: com. Example. FooRequestInterceptor # interceptors
• Whether decode404: false # 404 error code decoding (see processing logic feign. SynchronousMethodHandler# executeAndDecode)
• Encoder: com. Example. # SimpleEncoder encoder
• Decoder: com. Example. SimpleDecoder # decoder
  • Contract: com. Example. # SimpleContract contract

Configuration best Practices

Ribbon configuration vs Feign configuration

Feign code vs. attribute

Priority: global code configuration < global property configuration < fine-grained code configuration < fine-grained property configuration

The best implementation

• Use attribute configuration as much as possible, and consider code configuration when attribute mode is not possible.
• Try to keep the same microservice simple, do not mix the two ways, increase the complexity of the location code. Simple is beautiful.

The succession of Feign

In the case of the User-Center service, the interface provided by The User-Center service is basically the same as the Feign client interface used by Content-Center to call the User-Center service, so we can consider separating the interface and managing it in a separate MAVEN API module. However, it is not recommended to use it in this way, and many enterprises are using it now, so they need to decide whether to adapt to inheritance according to their own situation.

Multi-parameter request construction

• GET

  • Methods a

    @GetMapping(value = "/find")
    UserDTO find(@RequestParam("id") Integer id, @RequestParam("name") String name);
    Copy the code

  • Way 2

    @GetMapping(value = "/find")
    UserDTO find(@StringQueryMap User user);
    Copy the code

  • Method 3 (Not recommended)

    @GetMapping(value = "/find")
    UserDTO find(@RequestParam Map<String, Object> map);
    Copy the code

• POST

  • Methods a

    @PostMapping(value = "/find")
    UserDTO find(@RequestBody User user);
    Copy the code

  • Method 2 (Recommended)

    @PostMapping(value = "/find", consumes = MediaType.APPLICATION_JSON_UTF8_VALUE)
    UserDTO find(User user);
    Copy the code

Feign is used outside the Ribbon

Use feign to invoke a service that is not registered in the registry, for example, www.baidu.com

package com.samir.contentcenter.feignclient;

import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.GetMapping;

@FeignClient(name = "baidu", url = "http://www.baidu.com") // Do this with the URL attribute
public interface TestBaiduFeignClient {
    @GetMapping("")
    public String index(a);
}
Copy the code

RestTemplate vs Feign

Rule: Use Feign instead of RestTemplate; But when Feign really can’t solve a problem, consider RestTemplate.

Feign performance optimization

Configuring connection pooling for FEign [improves performance by 15% or so]

The underlying feign uses UrlConnection requests by default and has no connection pooling. Feign supports Apache httpClient and OkHTTP. These two HTTP requests support connection pooling, so we need to integrate one of them into our project configuration.

• httpclient

  1. And rely on

     <dependency>
         <groupId>io.github.openfeign</groupId>
         <artifactId>feign-httpclient</artifactId>
     </dependency>
     Copy the code

  2. Write the configuration

     feign:
       httpclient:
         enabled: true # let Feign use Apache HttpClient for requests instead of the default URlConnection
         Configure the optimal connection pool size from the results of the pressure test
         max-connections: 200 # feign maximum number of connections
         max-connections-per-route: 50 # feign Specifies the maximum number of connections for a single path
     Copy the code

• okhttp

  1. And rely on

     <dependency>
         <groupId>io.github.openfeign</groupId>
         <artifactId>feign-okhttp</artifactId>
         <version>10.4.0</version>
     </dependency>
     Copy the code

  2. Write the configuration

     feign:
       okhttp:
         enabled: true Let Feign use okHTTP for requests instead of using the default URlConnection
       httpclient:
       	Configure the optimal connection pool size from the results of the pressure test
         max-connections: 200 # feign maximum number of connections
         max-connections-per-route: 50 # feign Specifies the maximum number of connections for a single path
     Copy the code

The level of logging

If the production environment requires logs, you are advised to set the log level to Basic