springcloud-远程调用

后端

最好和负载均衡一起学习使用

RestTemplate

基础使用

@Configuration
public class RestConfiguration {

    @Bean
    // 启动负载均衡
    @LoadBalanced
    public RestTemplate restTemplate(){
        return new RestTemplate();
    }
}

@Service("OrderServiceRestImpl")
public class OrderServiceRestImpl implements OrderService {

    @Autowired
    private OrderMapper orderMapper;

    @Autowired
    private RestTemplate restTemplate;

    @Override
    public Order queryOrderById(Long orderId) {
        // 1.查询订单
        Order order = orderMapper.findById(orderId);
        if (null == order){
            return null;
        }
        // 2.利用RestTemplate发起http请求，查询用户
        // 2.1.url路径
        String url = "http://user-service/user/" + order.getUserId();
        // 2.2.发送http请求，实现远程调用
        User user = restTemplate.getForObject(url, User.class);
        // 3.封装user到Order
        order.setUser(user);
        // 4.返回
        return order;
    }
}

RestTemplate存在下面的问题：

•代码可读性差，编程体验不统一

•参数复杂URL难以维护

负载均衡

springcloud-负载均衡

Feign

Feign是一个声明式的http客户端，官方地址：https://github.com/OpenFeign/feign

其作用就是帮助我们优雅的实现http请求的发送，解决RestTemplate存在的问题。

使用

Fegin的使用步骤如下：

引入依赖

在服务的pom文件中引入feign的依赖：

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

声明注解开启

在启动类添加注解开启Feign的功能：@EnableFeignClients

@SpringBootApplication
@EnableFeignClients
public class NacosOrderModuleApplication {

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

}

编写客户端

新建一个接口，内容如下：

package cn.itcast.order.client;

import cn.itcast.order.pojo.User;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;

@FeignClient("userservice")
public interface UserClient {
    @GetMapping("/user/{id}")
    User findById(@PathVariable("id") Long id);
}

这个客户端主要是基于SpringMVC的注解来声明远程调用的信息，比如：

服务名称：userservice
请求方式：GET
请求路径：/user/{id}
请求参数：Long id
返回值类型：User

这样，Feign就可以帮助我们发送http请求，无需自己使用RestTemplate来发送了。

需要注意的是，@FeignClient只能使用在interface上

自定义配置

Feign可以支持很多的自定义配置，如下表所示：

类型	作用	说明
feign.Logger.Level	修改日志级别	包含四种不同的级别：NONE、BASIC、HEADERS、FULL
feign.codec.Decoder	响应结果的解析器	http远程调用的结果做解析，例如解析json字符串为java对象
feign.codec.Encoder	请求参数编码	将请求参数编码，便于通过http请求发送
feign. Contract	支持的注解格式	默认是SpringMVC的注解
feign. Retryer	失败重试机制	请求失败的重试机制，默认是没有，不过会使用Ribbon的重试

一般情况下，默认值就能满足我们使用，如果要自定义时，只需要创建自定义的@Bean覆盖默认Bean即可。

下面以日志为例来演示如何自定义配置。

配置文件方式

基于配置文件修改feign的日志级别可以针对单个服务：

feign:  
  client:
    config: 
      userservice: # 针对某个微服务的配置
        loggerLevel: FULL #  日志级别

也可以针对所有服务：

feign:  
  client:
    config: 
      default: # 这里用default就是全局配置，如果是写服务名称，则是针对某个微服务的配置
        loggerLevel: FULL #  日志级别

而日志的级别分为四种：

NONE：不记录任何日志信息，这是默认值。
BASIC：仅记录请求的方法，URL以及响应状态码和执行时间
HEADERS：在BASIC的基础上，额外记录了请求和响应的头信息
FULL：记录所有请求和响应的明细，包括头信息、请求体、元数据。

Java代码方式

也可以基于Java代码来修改日志级别，先声明一个类，然后声明一个Logger.Level的对象：

public class DefaultFeignConfiguration  {
    @Bean
    public Logger.Level feignLogLevel(){
        return Logger.Level.BASIC; // 日志级别为BASIC
    }
}

如果要全局生效，将其放到启动类的@EnableFeignClients这个注解中：

@EnableFeignClients(defaultConfiguration = DefaultFeignConfiguration .class)

如果是局部生效，则把它放到对应的@FeignClient这个注解中：

@FeignClient(value = "userservice", configuration = DefaultFeignConfiguration .class)

负载均衡

默认集成了负载均衡策略，其调用的核心类为：FeignBlockingLoadBalancerClient的execute方法。

@Override
	public Response execute(Request request, Request.Options options) throws IOException {
		final URI originalUri = URI.create(request.url());
		String serviceId = originalUri.getHost();
		Assert.state(serviceId != null, "Request URI does not contain a valid hostname: " + originalUri);
		String hint = getHint(serviceId);
		DefaultRequest<RequestDataContext> lbRequest = new DefaultRequest<>(
				new RequestDataContext(buildRequestData(request), hint));
		Set<LoadBalancerLifecycle> supportedLifecycleProcessors = LoadBalancerLifecycleValidator
				.getSupportedLifecycleProcessors(
						loadBalancerClientFactory.getInstances(serviceId, LoadBalancerLifecycle.class),
						RequestDataContext.class, ResponseData.class, ServiceInstance.class);
		supportedLifecycleProcessors.forEach(lifecycle -> lifecycle.onStart(lbRequest));
		ServiceInstance instance = loadBalancerClient.choose(serviceId, lbRequest);
		org.springframework.cloud.client.loadbalancer.Response<ServiceInstance> lbResponse = new DefaultResponse(
				instance);
		if (instance == null) {
			String message = "Load balancer does not contain an instance for the service " + serviceId;
			if (LOG.isWarnEnabled()) {
				LOG.warn(message);
			}
			supportedLifecycleProcessors.forEach(lifecycle -> lifecycle
					.onComplete(new CompletionContext<ResponseData, ServiceInstance, RequestDataContext>(
							CompletionContext.Status.DISCARD, lbRequest, lbResponse)));
			return Response.builder().request(request).status(HttpStatus.SERVICE_UNAVAILABLE.value())
					.body(message, StandardCharsets.UTF_8).build();
		}
		String reconstructedUrl = loadBalancerClient.reconstructURI(instance, originalUri).toString();
		Request newRequest = buildRequest(request, reconstructedUrl);
		LoadBalancerProperties loadBalancerProperties = loadBalancerClientFactory.getProperties(serviceId);
		return executeWithLoadBalancerLifecycleProcessing(delegate, options, newRequest, lbRequest, lbResponse,
				supportedLifecycleProcessors, loadBalancerProperties.isUseRawStatusCodeInResponseData());
	}

可以发现和BlockingLoadBalancerClient的execute方法及其相似。而且其中的loadBalancerClient就是BlockingLoadBalancerClient。

其负载均衡最终也是调用的BlockingLoadBalancerClient的choose方法。

在启动时FeignClientFactoryBean中的loadBalance方法中打断点：也可以发现，其初始化了BlockingLoadBalancerClient和LoadBalancerClientFactory

性能优化

Feign底层发起http请求，依赖于其它的框架。其底层客户端实现包括：

URLConnection：默认实现，不支持连接池
Apache HttpClient ：支持连接池
OKHttp：支持连接池

因此提高Feign的性能主要手段就是使用连接池代替默认的URLConnection。

修改客户端支持连接池

这里我们用Apache的HttpClient来演示。

1）引入依赖

在order-service的pom文件中引入Apache的HttpClient依赖：

<!--httpClient的依赖 -->
<dependency>
    <groupId>io.github.openfeign</groupId>
    <artifactId>feign-httpclient</artifactId>
</dependency>

2）配置连接池

在order-service的application.yml中添加配置：

feign:
  client:
    config:
      default: # default全局的配置
        loggerLevel: BASIC # 日志级别，BASIC就是基本的请求和响应信息
  httpclient:
    enabled: true # 开启feign对HttpClient的支持
    max-connections: 200 # 最大的连接数
    max-connections-per-route: 50 # 每个路径的最大连接数

接下来，重启启动时在FeignClientFactoryBean中的loadBalance方法中打断点：

总结

1.日志级别尽量用basic

2.使用HttpClient或OKHttp代替URLConnection

① 引入feign-httpClient依赖

② 配置文件开启httpClient功能，设置连接池参数

最佳使用

实现公共方法

一样的代码可以通过继承来共享：

1）定义一个API接口，利用定义方法，并基于SpringMVC注解做声明。

2）Feign客户端和Controller都集成改接口

优点：

简单
实现了代码共享

缺点：

服务提供方、服务消费方紧耦合
参数列表中的注解映射并不会继承，因此Controller中必须再次声明方法、参数列表、注解

抽取独立模块

将Feign的Client抽取为独立模块，并且把接口有关的POJO、默认的Feign配置都放到这个模块中，提供给所有消费者使用。

例如，将UserClient、User、Feign的默认配置都抽取到一个feign-api包中，所有微服务引用该依赖包，即可直接使用。

抽取独立模块实现

每个单独的服务区分单独的模块。例如普通的controller，service，dao模块。再额外增加一个api模块，这个模块单独给消费者引入使用。

这里只是为了演示，没有细分模块。注意为包含开放的api clients包，入参和返回实体类包，以及自定义client的工具类

@FeignClient("user-service")
public interface UserClient {

    @GetMapping("/user/{id}")
    User queryById(@PathVariable("id") Long id);
}

再定义一个客户端工厂（感觉通过@EnableFeignClients，不论是包扫描还是类指定都不是很优雅），自定义生成客户端。这样需要引入哪个api按需引入接口

public class JecypFeignClientFactory implements ApplicationContextAware {

    private static FeignClientBuilder builder;


    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        builder = new FeignClientBuilder(applicationContext);
    }

    /**
     * 手动生成FeignClient,准备一个FeignClient基类，该类不用打{@link org.springframework.cloud.openfeign.FeignClient}注解
     */
    public  <T> T getFeignClient(Class<T> clazz, String name) {
        FeignClientBuilder.Builder<T> feignClientBuilder = builder.forType(clazz, name);
        return feignClientBuilder.contextId(name).build();
    }

}

如上代码为一个简单的实现。这里个人认为应该结合@FeignClient("user-service")。扫描这个注解的配置来生成对应的代理类，只需要指定一个class即可。其余配置都由服务提供者来指定。

而自定义配置类似与LoadBalance的配置。通过NamedContextFactory.Specification的子类来定义。因为feign每个服务也是通过对应的context上下文来加载的。feign的实现为FeignClientSpecification

    @Bean("userService-feignConfig")
    public FeignClientSpecification userServiceFeignConfig(){
        return new FeignClientSpecification("user-service", new Class[]{FeignClientPropertiesConfiguration.class});
    }

加载这些配置的核心类为FeignClientFactoryBean。其入口方法为 getObject()；

例如其中调用的方法configureFeign(),就是加载指定的FeignClientPropertiesConfiguration的地方

tips：在配置文件中如果配置了feign.client.defaultToProperties: false的话，代码的配置会覆盖配置文件配置。这里按照个人理解来吧

	protected void configureFeign(FeignContext context, Feign.Builder builder) {
		FeignClientProperties properties = beanFactory != null ? beanFactory.getBean(FeignClientProperties.class)
				: applicationContext.getBean(FeignClientProperties.class);

		FeignClientConfigurer feignClientConfigurer = getOptional(context, FeignClientConfigurer.class);
		setInheritParentContext(feignClientConfigurer.inheritParentConfiguration());

		if (properties != null && inheritParentContext) {
			if (properties.isDefaultToProperties()) {
				configureUsingConfiguration(context, builder);
				configureUsingProperties(properties.getConfig().get(properties.getDefaultConfig()), builder);
				configureUsingProperties(properties.getConfig().get(contextId), builder);
			}
			else {
				configureUsingProperties(properties.getConfig().get(properties.getDefaultConfig()), builder);
				configureUsingProperties(properties.getConfig().get(contextId), builder);
				configureUsingConfiguration(context, builder);
			}
		}
		else {
			configureUsingConfiguration(context, builder);
		}
	}

FeignClientPropertiesConfiguration这个类为自定义的配置定义类。其是在初始化服务对应的context的时候加载。在这里控制这个context都有哪些bean，需要额外注意的是不需要@Configuration注解。具体bean类型参考FeignClientFactoryBean中get()每次指定的类型。（后续有时间了会整理出来）

public class FeignClientPropertiesConfiguration {

    @Bean
    public Logger.Level level(){
        return Logger.Level.FULL;
    }

}

如果觉得文章对你有用，请随意赞赏

spring-cloud

springcloud-远程调用

https://www.jecyp.cn//archives/springcloud-yuan-cheng-diao-yong

作者

摸鱼的杰尼龟

发布于

2023-08-27

更新于

2023-08-28

许可协议

CC BY 4.0