简化本地Feign调用,这样封装真香!

Feign客户端调用 Feign是一个声明式WebService客户端。使用Feign能让编写WebService客户端更加加单,它的使用方法是定义一个接口,然后在上面添加注解,同时也支持JAX-RS标准的注解。Feign也支持可插拔式的编码器和解码器。Spring Cloud对Feign进行了封装,使其支持了SpringMVC白哦准注解和HttpMessageConverters。Feign可以与Eureka和Rib... 阅读详情

👉 这是一个或许对你有用的社群

🐱 一对一交流/面试小册/简历优化/求职解惑,欢迎加入「芋道快速开发平台」知识星球。下面是星球提供的部分资料: 

88cc1af1e4644d1f50b13e0fbcfc5e7c.gif

👉这是一个或许对你有用的开源项目

国产 Star 破 10w+ 的开源项目,前端包括管理后台 + 微信小程序,后端支持单体和微服务架构。

功能涵盖 RBAC 权限、SaaS 多租户、数据权限、商城、支付、工作流、大屏报表、微信公众号、CRM 等等功能:

  • Boot 仓库:https://gitee.com/zhijiantianya/ruoyi-vue-pro

  • Cloud 仓库:https://gitee.com/zhijiantianya/yudao-cloud

  • 视频教程:https://doc.iocoder.cn

【国内首批】支持 JDK 21 + SpringBoot 3.2.2、JDK 8 + Spring Boot 2.7.18 双版本 

来源:码农参上

c643df5e8f8b7f8c290fb3e60d293853.jpeg


在平常的工作中,OpenFeign作为微服务间的调用组件使用的非常普遍,接口配合注解的调用方式突出一个简便,让我们能无需关注内部细节就能实现服务间的接口调用。

但是工作中用久了,发现Feign也有些使用起来麻烦的地方,下面先来看一个问题,再看看我们在工作中是如何解决,以达到简化Feign使用的目的。

先看问题

在一个项目开发的过程中,我们通常会区分开发环境、测试环境和生产环境,如果有的项目要求更高的话,可能还会有个预生产环境。

开发环境作为和前端开发联调的环境,一般使用起来都比较随意,而我们在进行本地开发的时候,有时候也会将本地启动的微服务注册到注册中心nacos上,方便进行调试。

这样,注册中心的一个微服务可能就会拥有多个服务实例,就像下面这样:

48ecf944914b561c1f4e9705d354d0c0.png

眼尖的小伙伴肯定发现了,这两个实例的ip地址有一点不同。

线上环境现在一般使用容器化部署,通常都是由流水线工具打成镜像然后扔到docker中运行,因此我们去看一下服务在docker容器内的ip:

086a58e19f4961c9742e707b75e77263.png

可以看到,这就是注册到nacos上的服务地址之一,而列表中192开头的另一个ip,则是我们本地启动的服务的局域网地址。看一下下面这张图,就能对整个流程一目了然了。

2d3e229f3fc2807ba6bd3e1e89e94a2e.jpeg

总结一下:

  • 两个service都是通过宿主机的ip和port,把自己的信息注册到nacos上

  • 线上环境的service注册时使用docker内部ip地址

  • 本地的service注册时使用本地局域网地址

那么这时候问题就来了,当我本地再启动一个serviceB,通过FeignClient来调用serviceA中的接口时,因为Feign本身的负载均衡,就可能把请求负载均衡到两个不同的serviceA实例。

如果这个调用请求被负载均衡到本地serviceA的话,那么没什么问题,两个服务都在同一个192.168网段内,可以正常访问。但是如果负载均衡请求到运行在docker内的serviceA的话,那么问题来了,因为网络不通,所以会请求失败:

b80219c03315f2a31edce150047831fe.png

说白了,就是本地的192.168和docker内的虚拟网段172.17属于纯二层的两个不同网段,不能互访,所以无法直接调用。

那么,如果想在调试时把请求稳定打到本地服务的话,有一个办法,就是指定在FeignClient中添加url参数,指定调用的地址:

@FeignClient(value = "serviceA",url = "http://127.0.0.1:8088/")
public interface ClientA {
    @GetMapping("/test/get")
    String get();
}

但是这么一来也会带来点问题:

  • 代码上线时需要再把注解中的url删掉,还要再次修改代码,如果忘了的话会引起线上问题

  • 如果测试的FeignClient很多的话,每个都需要配置url,修改起来很麻烦

那么,有什么办法进行改进呢?为了解决这个问题,我们还是得从Feign的原理说起。

基于 Spring Boot + MyBatis Plus + Vue & Element 实现的后台管理系统 + 用户小程序,支持 RBAC 动态权限、多租户、数据权限、工作流、三方登录、支付、短信、商城等功能

  • 项目地址:https://github.com/YunaiV/ruoyi-vue-pro

  • 视频教程:https://doc.iocoder.cn/video/

Feign原理

简单来说,就是项目中加的@EnableFeignClients这个注解,实现时有一行很重要的代码:

@Import(FeignClientsRegistrar.class)

这个类实现了ImportBeanDefinitionRegistrar接口,在这个接口的registerBeanDefinitions方法中,可以手动创建BeanDefinition并注册,之后spring会根据BeanDefinition实例化生成bean,并放入容器中。

Feign就是通过这种方式,扫描添加了@FeignClient注解的接口,然后一步步生成代理对象,具体流程可以看一下下面这张图:

44d928dab685b7d931509dae8c4aa5a6.jpeg

后续在请求时,通过代理对象的FeignInvocationHandler进行拦截,并根据对应方法进行处理器的分发,完成后续的http请求操作。

基于 Spring Cloud Alibaba + Gateway + Nacos + RocketMQ + Vue & Element 实现的后台管理系统 + 用户小程序,支持 RBAC 动态权限、多租户、数据权限、工作流、三方登录、支付、短信、商城等功能

  • 项目地址:https://github.com/YunaiV/yudao-cloud

  • 视频教程:https://doc.iocoder.cn/video/

ImportBeanDefinitionRegistrar

上面提到的ImportBeanDefinitionRegistrar,在整个创建FeignClient的代理过程中非常重要, 所以我们先写一个简单的例子看一下它的用法。先定义一个实体类:

@Data
@AllArgsConstructor
public class User {
    Long id;
    String name;
}

通过BeanDefinitionBuilder,向这个实体类的构造方法中传入具体值,最后生成一个BeanDefinition:

public class MyBeanDefinitionRegistrar
        implements ImportBeanDefinitionRegistrar {
    @Override
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata,
                                        BeanDefinitionRegistry registry) {
        BeanDefinitionBuilder builder
                = BeanDefinitionBuilder.genericBeanDefinition(User.class);
        builder.addConstructorArgValue(1L);
        builder.addConstructorArgValue("Hydra");

        AbstractBeanDefinition beanDefinition = builder.getBeanDefinition();
        registry.registerBeanDefinition(User.class.getSimpleName(),beanDefinition);
    }
}

registerBeanDefinitions方法的具体调用时间是在之后的ConfigurationClassPostProcessor执行postProcessBeanDefinitionRegistry方法时,而registerBeanDefinition方法则会将BeanDefinition放进一个map中,后续根据它实例化bean。

在配置类上通过@Import将其引入:

@Configuration
@Import(MyBeanDefinitionRegistrar.class)
public class MyConfiguration {
}

注入这个User测试:

@Service
@RequiredArgsConstructor
public class UserService {
    private final User user;

    public void getUser(){
        System.out.println(user.toString());
    }
}

结果打印,说明我们通过自定义BeanDefinition的方式成功手动创建了一个bean并放入了spring容器中:

User(id=1, name=Hydra)

好了,准备工作铺垫到这结束,下面开始正式的改造工作。

改造

到这里先总结一下,我们纠结的点就是本地环境需要FeignClient中配置url,但线上环境不需要,并且我们又不想来回修改代码。

除了像源码中那样生成动态代理以及拦截方法,官方文档中还给我们提供了一个手动创建FeignClient的方法。

https://docs.spring.io/spring-cloud-openfeign/docs/2.2.9.RELEASE/reference/html/#creating-feign-clients-manually

简单来说,就是我们可以像下面这样,通过Feign的Builder API来手动创建一个Feign客户端。

f08268ecda295b21d0d6bf7cb846edad.png

简单看一下,这个过程中还需要配置Client、Encoder、Decoder、Contract、RequestInterceptor等内容。

  • Client:实际http请求的发起者,如果不涉及负载均衡可以使用简单的Client.Default,用到负载均衡则可以使用LoadBalancerFeignClient,前面也说了,LoadBalancerFeignClient中的delegate其实使用的也是Client.Default

  • Encoder和Decoder:Feign的编解码器,在spring项目中使用对应的SpringEncoder和ResponseEntityDecoder,这个过程中我们借用GsonHttpMessageConverter作为消息转换器来解析json

  • RequestInterceptor:Feign的拦截器,一般业务用途比较多,比如添加修改header信息等,这里用不到可以不配

  • Contract:字面意思是合约,它的作用是将我们传入的接口进行解析验证,看注解的使用是否符合规范,然后将关于http的元数据抽取成结果并返回。如果我们使用RequestMapping、PostMapping、GetMapping之类注解的话,那么对应使用的是SpringMvcContract

其实这里刚需的就只有Contract这一个,其他都是可选的配置项。我们写一个配置类,把这些需要的东西都注入进去:

@Slf4j
@Configuration(proxyBeanMethods = false)
@EnableConfigurationProperties({LocalFeignProperties.class})
@Import({LocalFeignClientRegistrar.class})
@ConditionalOnProperty(value = "feign.local.enable", havingValue = "true")
public class FeignAutoConfiguration {
    static {
        log.info("feign local route started");
    }

    @Bean
    @Primary
    public Contract contract(){
        return new SpringMvcContract();
    }

    @Bean(name = "defaultClient")
    public Client defaultClient(){
        return new Client.Default(null,null);
    }

    @Bean(name = "ribbonClient")
    public Client ribbonClient(CachingSpringLoadBalancerFactory cachingFactory,
                               SpringClientFactory clientFactory){
        return new LoadBalancerFeignClient(defaultClient(), cachingFactory,
                clientFactory);
    }

    @Bean
    public Decoder decoder(){
        HttpMessageConverter httpMessageConverter=new GsonHttpMessageConverter();
        ObjectFactory<HttpMessageConverters> messageConverters= () -> new HttpMessageConverters(httpMessageConverter);
        SpringDecoder springDecoder = new SpringDecoder(messageConverters);
        return new ResponseEntityDecoder(springDecoder);
    }

    @Bean
    public Encoder encoder(){
        HttpMessageConverter httpMessageConverter=new GsonHttpMessageConverter();
        ObjectFactory<HttpMessageConverters> messageConverters= () -> new HttpMessageConverters(httpMessageConverter);
        return new SpringEncoder(messageConverters);
    }
}

在这个配置类上,还有三行注解,我们一点点解释。

首先是引入的配置类LocalFeignProperties,里面有三个属性,分别是是否开启本地路由的开关、扫描FeignClient接口的包名,以及我们要做的本地路由映射关系,addressMapping中存的是服务名和对应的url地址:

@Data
@Component
@ConfigurationProperties(prefix = "feign.local")
public class LocalFeignProperties {
    // 是否开启本地路由
    private String enable;

    //扫描FeignClient的包名
    private String basePackage;

    //路由地址映射
    private Map<String,String> addressMapping;
}

下面这行注解则表示只有当配置文件中feign.local.enable这个属性为true时,才使当前配置文件生效:

@ConditionalOnProperty(value = "feign.local.enable", havingValue = "true")

最后,就是我们重中之重的LocalFeignClientRegistrar了,我们还是按照官方通过ImportBeanDefinitionRegistrar接口构建BeanDefinition然后注册的思路来实现。

并且,FeignClientsRegistrar的源码中已经实现好了很多基础的功能,比如扫扫描包、获取FeignClient的name、contextId、url等等,所以需要改动的地方非常少,可以放心的大抄特超它的代码。

先创建LocalFeignClientRegistrar,并注入需要用到的ResourceLoader、BeanFactory、Environment。

@Slf4j
public class LocalFeignClientRegistrar implements
        ImportBeanDefinitionRegistrar, ResourceLoaderAware,
        EnvironmentAware, BeanFactoryAware{

    private ResourceLoader resourceLoader;
    private BeanFactory beanFactory;
    private Environment environment;

    @Override
    public void setResourceLoader(ResourceLoader resourceLoader) {
        this.resourceLoader=resourceLoader;
    }

    @Override
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        this.beanFactory = beanFactory;
    }

    @Override
    public void setEnvironment(Environment environment) {
        this.environment=environment;
    }
 
 //先省略具体功能代码...
}

然后看一下创建BeanDefinition前的工作,这一部分主要完成了包的扫描和检测@FeignClient注解是否被添加在接口上的测试。下面这段代码基本上是照搬源码,除了改动一下扫描包的路径,使用我们自己在配置文件中配置的包名。

@Override
public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
    ClassPathScanningCandidateComponentProvider scanner = ComponentScanner.getScanner(environment);
    scanner.setResourceLoader(resourceLoader);
    AnnotationTypeFilter annotationTypeFilter = new AnnotationTypeFilter(FeignClient.class);
    scanner.addIncludeFilter(annotationTypeFilter);

    String basePackage =environment.getProperty("feign.local.basePackage");
    log.info("begin to scan {}",basePackage);

    Set<BeanDefinition> candidateComponents = scanner.findCandidateComponents(basePackage);

    for (BeanDefinition candidateComponent : candidateComponents) {
        if (candidateComponent instanceof AnnotatedBeanDefinition) {
            log.info(candidateComponent.getBeanClassName());

            // verify annotated class is an interface
            AnnotatedBeanDefinition beanDefinition = (AnnotatedBeanDefinition) candidateComponent;
            AnnotationMetadata annotationMetadata = beanDefinition.getMetadata();
            Assert.isTrue(annotationMetadata.isInterface(),
                    "@FeignClient can only be specified on an interface");

            Map<String, Object> attributes = annotationMetadata
                    .getAnnotationAttributes(FeignClient.class.getCanonicalName());

            String name = FeignCommonUtil.getClientName(attributes);
            registerFeignClient(registry, annotationMetadata, attributes);
        }
    }
}

接下来创建BeanDefinition并注册,Feign的源码中是使用的FeignClientFactoryBean创建代理对象,这里我们就不需要了,直接替换成使用Feign.builder创建。

private void registerFeignClient(BeanDefinitionRegistry registry,
                                 AnnotationMetadata annotationMetadata, Map<String, Object> attributes) {
    String className = annotationMetadata.getClassName();
    Class clazz = ClassUtils.resolveClassName(className, null);
    ConfigurableBeanFactory beanFactory = registry instanceof ConfigurableBeanFactory
            ? (ConfigurableBeanFactory) registry : null;
    String contextId = FeignCommonUtil.getContextId(beanFactory, attributes,environment);
    String name = FeignCommonUtil.getName(attributes,environment);

    BeanDefinitionBuilder definition = BeanDefinitionBuilder
            .genericBeanDefinition(clazz, () -> {
                Contract contract = beanFactory.getBean(Contract.class);
                Client defaultClient = (Client) beanFactory.getBean("defaultClient");
                Client ribbonClient = (Client) beanFactory.getBean("ribbonClient");
                Encoder encoder = beanFactory.getBean(Encoder.class);
                Decoder decoder = beanFactory.getBean(Decoder.class);

                LocalFeignProperties properties = beanFactory.getBean(LocalFeignProperties.class);
                Map<String, String> addressMapping = properties.getAddressMapping();

                Feign.Builder builder = Feign.builder()
                        .encoder(encoder)
                        .decoder(decoder)
                        .contract(contract);

                String serviceUrl = addressMapping.get(name);
                String originUrl = FeignCommonUtil.getUrl(beanFactory, attributes, environment);

                Object target;
                if (StringUtils.hasText(serviceUrl)){
                    target = builder.client(defaultClient)
                            .target(clazz, serviceUrl);
                }else if (StringUtils.hasText(originUrl)){
                    target = builder.client(defaultClient)
                            .target(clazz,originUrl);
                }else {
                    target = builder.client(ribbonClient)
                            .target(clazz,"http://"+name);
                }

                return target;
            });

    definition.setAutowireMode(AbstractBeanDefinition.AUTOWIRE_BY_TYPE);
    definition.setLazyInit(true);
    FeignCommonUtil.validate(attributes);

    AbstractBeanDefinition beanDefinition = definition.getBeanDefinition();
    beanDefinition.setAttribute(FactoryBean.OBJECT_TYPE_ATTRIBUTE, className);

    // has a default, won't be null
    boolean primary = (Boolean) attributes.get("primary");
    beanDefinition.setPrimary(primary);

    String[] qualifiers = FeignCommonUtil.getQualifiers(attributes);
    if (ObjectUtils.isEmpty(qualifiers)) {
        qualifiers = new String[] { contextId + "FeignClient" };
    }

    BeanDefinitionHolder holder = new BeanDefinitionHolder(beanDefinition, className,
            qualifiers);
    BeanDefinitionReaderUtils.registerBeanDefinition(holder, registry);
}

在这个过程中主要做了这么几件事:

  • 通过beanFactory拿到了我们在前面创建的Client、Encoder、Decoder、Contract,用来构建Feign.Builder

  • 通过注入配置类,通过addressMapping拿到配置文件中服务对应的调用url

  • 通过target方法替换要请求的url,如果配置文件中存在则优先使用配置文件中url,否则使用@FeignClient注解中配置的url,如果都没有则使用服务名通过LoadBalancerFeignClient访问

在resources/META-INF目录下创建spring.factories文件,通过spi注册我们的自动配置类:

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
  com.feign.local.config.FeignAutoConfiguration

最后,本地打包即可:

mvn clean install

测试

引入我们在上面打好的包,由于包中已经包含了spring-cloud-starter-openfeign,所以就不需要再额外引feign的包了:

<dependency>
    <groupId>com.cn.hydra</groupId>
    <artifactId>feign-local-enhancer</artifactId>
    <version>1.0-SNAPSHOT</version>
</dependency>

在配置文件中添加配置信息,启用组件:

feign:
  local:
    enable: true
    basePackage: com.service
    addressMapping:
      hydra-service: http://127.0.0.1:8088
      trunks-service: http://127.0.0.1:8099

创建一个FeignClient接口,注解的url中我们可以随便写一个地址,可以用来测试之后是否会被配置文件中的服务地址覆盖:

@FeignClient(value = "hydra-service",
 contextId = "hydra-serviceA",
 url = "http://127.0.0.1:8099/")
public interface ClientA {
    @GetMapping("/test/get")
    String get();

    @GetMapping("/test/user")
    User getUser();
}

启动服务,过程中可以看见了执行扫描包的操作:

cd36dfbf65a517391d27949c8f5a0756.png

在替换url过程中添加一个断点,可以看到即使在注解中配置了url,也会优先被配置文件中的服务url覆盖:

8c6487cf1cbdea704f07d9cc99594186.png

使用接口进行测试,可以看到使用上面的代理对象进行了访问并成功返回了结果:

f433272af1d7fd4cc4106e7903c83d9b.png

如果项目需要发布正式环境,只需要将配置feign.local.enable改为false或删掉,并在项目中添加Feign原始的@EnableFeignClients即可。

总结

本文提供了一个在本地开发过程中简化Feign调用的思路,相比之前需要麻烦的修改FeignClient中的url而言,能够节省不少的无效劳动,并且通过这个过程,也可以帮助大家了解我们平常使用的这些组件是怎么与spring结合在一起的,熟悉spring的扩展点。

组件代码已提交到我的github,有需要的小伙伴们可以自取,码字不易,也欢迎大家点个star~

https://github.com/trunks2008/feign-local-enhancer


欢迎加入我的知识星球,全面提升技术能力。

👉 加入方式,“长按”或“扫描”下方二维码噢:

55f84790dfb1bc9a4ea9d69f1d091aa8.png

星球的内容包括:项目实战、面试招聘、源码解析、学习路线。

11a6a2265484d8fc4feb8527b5a9a8cc.png

230b50fca6977db7fe57cf55bf954b2c.pnge10a8cd632af4d6cdd4c861c1d06025f.png1fda8e5d94025e89f8c6ac4c98bdbcac.png84e4045b219fa671bcc8ae8f7af0ca97.png

文章有帮助的话,在看,转发吧。
谢谢支持哟 (*^__^*)
OkHttp的高级封装Feign学习(一): Feign注解的使用 说明 在项目开发中,避免不了通过HTTP请求进行对第三方服务的调用,在之前的两遍博文《OkHttp使用踩坑记录总结(一):OkHttpClient单例和长连接Connection Keep-Alive 》和《OkHttp使用踩坑记录总结(二):OkHttp同步异步请求和连接池线程池》中,我对OkHttp使用过程中遇到的一些问题进行了总结记录。在微服务架构体系中,我们通常使用netflix开源的sp... 阅读详情

相关推荐

【云原生】Spring Cloud Alibaba 之 Feign 远程调用 实战

分布式系统下远程调用该如何选择?RestTemplate 与 Feign,Feign是最佳选择!

wanghuichen的博客 6445

(三) Spring Cloud - 断路器+(普通调用和feign封装调用)

(三) Spring Cloud - 断路器+(普通调用和feign封装调用) 1. Ribbon+Hystrix(断路器), 普通调用方式 pom.xml加入两个Hystrix依赖maven <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-i

yehuang_0801的博客 1781

详细教程:如何使用elasticsearch 8.x进行向量搜索

大模型的热度使得向量数据库和embedding也成了ai领域的热门话题,有别于从头开始训练一个大模型或基于基础模型进行微调的方式,embedding检索相关上下文是对大模型进行定制的各种方法中成本最低、技术实现最便捷的方式。从技术实现的角度,

qq_50790981的博客 1万+

简化本地Feign调用,这样封装真香

基于 Spring Cloud Alibaba + Gateway + Nacos + RocketMQ + Vue & Element 实现的后台管理系统 + 用户小程序,支持 RBAC 动态权限、多租户、数据权限、工作流、三方登录、支付、短信、商城等功能。而言,能够节省不少的无效劳动,并且通过这个过程,也可以帮助大家了解我们平常使用的这些组件是怎么与spring结合在一起的,熟悉spring的扩展点。下面这段代码基本上是照搬源码,除了改动一下扫描包的路径,使用我们自己在配置文件中配置的包名。

cgk_ALEM的博客 814

AI数字人:口播与唇形同步的福音,支持本地部署/批量生成/口齿清晰

你也可以直接输入语音,虚拟化身会根据语音的节奏和语调,同步做出相应的动作和表情,表现更加生动。不过这依然是个值得关注的工具。借助先进的 AI 算法,Heygem 高精度捕捉五官、轮廓等特征,构建逼真的虚拟模型。同时,它还能克隆语音,捕捉人声的细微特征,支持多种语音参数设置,打造高度相似的音色效果。打开设置,调整镜像存储位置,镜像文件比较大70~80G,选择合适的盘,设置完成后点击“Apply & Restart”。数字人视频画面与声音高度同步,口型匹配自然流畅,智能优化音视频效果,带来极佳的视听体验。

m0_72580657的博客 5865

安卓无障碍服务保活实战:如何用AccessibilityService实现后台常驻(附完整代码)

本文深入解析如何利用Android无障碍服务(AccessibilityService)实现后台服务保活,涵盖多版本系统适配、前台服务集成、开机自启机制等关键技术。通过详细的Kotlin代码示例和合规性指导,帮助开发者构建稳定可靠的后台服务解决方案,同时避免因滥用无障碍服务导致的应用下架风险。

milk5的博客 1078

Feign 的重试调用,这样封装真香!

???? 这是一个或许对你有用的社群???? 一对一交流/面试小册/简历优化/求职解惑,欢迎加入「芋道快速开发平台」知识星球。下面是星球提供的部分资料:《项目实战(视频)》:从书中学,往事上“练”《互联网高频面试题》:面朝简历学习,春暖花开《架构 x 系统设计》:摧枯拉朽,掌控面试高频场景题《精进 Java 学习指南》:系统学习,互联网主流技术栈《必读 Java 源码专栏》:知其然,知其所以然????这是一个或许...

芋艿V 174

学习C++的递归函数(包含汉诺塔讲解)

简单来讲,递归函数就是函数本身自己调用自己,那么函数又是什么呢?#include <stdio.h> //这行是头文件,不同的头文件可以用不同的函数int main() //这里就是一个main函数//这里是你要编写程序的内容return 0;(这是个小细节如下)所以我们平时用来练习的就是一个main函数,而且是一个整型类型的函数,而这也是最后一句话为什么要加一句 return 0;了,因为它最后要返回整数类型,其它整数也可以,但是大家规定为0,这是C++自带的函数。

2302_81032013的博客 2596

Feign服务接口调用

openFeign 是作为微服务之间调用的解决方案,是一种声明式、模板化的 HTTP 的模板,使 HTTP 请求就像调用本地方法一样,通过 openFeign 可以替代基于 RestTemplate 的远程服务调用,并且默认集成了 Ribbon 进行负载均衡。本文对Feign主要的工作流程做了一些简单的分析,其实关于Feign的原理还有很多细节值得深入探究。另外关于Feign的相关配置本文都省略了,后续将陆续更新Feign使用中的坑以及Feign的各种配置。

weixin_58216062的博客 7973

数据中台:大数据平台,数据仓库(DM),数据中台之间的联系以及异同分析

大数据平台是一个技术平台。这个技术平台提供了对于大数据的分布式采集,存储,流处理和计算,实时分析等能力。在没有大数据平台前也有数据集成和管理的平台,这种平台可以实现对结构化数据本身的采集,集成和管理。 管理平台,是在原生的大数据生态的基础之上,为了更好的管理集群服务,管理集群的资源,提供灵活SRE能力和资源核算审计能力的一系列工具和合称整体架构数据中台包括数据仓库的全部内容,数据仓库为数据中台提供了数据对外提供服务的基础资源,数据中台将数据仓库建设的投入价值进行最大化,以加快数据赋能业务的速度大家都知道数据

GIS摆渡人 2136

MTK平台Wi-Fi学习--wifi channel 通过国家码进行功率限制和wifi eFEM 基本配置和wifi Tx SEM问题

本文介绍了WiFi功率限制配置和eFEM硬件设置方法。在功率限制方面,通过国家码可针对不同信道设置功率上限,需在rlm_txpwr_init.h文件中配置信道和功率值(单位0.5dBm),WiFi6的HE_TB模式还可分RU设置。eFEM硬件配置需参考平台设计,注意VDET接口处理,首次使用建议提交HW/SW案例审核。软件配置需获取专用FEM包,包含NVRAM、GPIO等文件,按指导合并后版本才会切换为eFEM版本。

专业开发者的博客,一个从事Android WiFi和蓝牙的工程师 492

简化远程代码的调用SpringClioud_Feign

1,为什么要学习feign 简化远程代码的调用 之前我们远程调用restTemplate String baseUrl = &amp;amp;amp;quot;http://user-service/user/&amp;amp;amp;quot;; User user = this.restTemplate.getForObject(baseUrl + id, User.class) 但是我们以后需要编写类似的大量重复代码,格式基本相同,无非参数不一样。有没...

随风而欲的博客 1101

手把手教你学AI GPU UMD驱动软件开发专栏--1.1 UMD(用户模式驱动)的定义与定位

摘要:UMD(用户模式驱动)是GPU驱动架构中的关键组件,负责连接AI应用与硬件。作为运行在用户空间的动态链接库,UMD通过减少系统调用开销显著提升AI计算性能。其核心功能包括API转换、资源管理和命令生成,同时具备安全性高(崩溃不影响系统)、开发灵活等优势。随着AI发展,UMD已从图形驱动演变为深度学习加速的关键组件,支持TensorCore等硬件特性优化。未来趋势包括深度框架集成、硬件感知增强和虚拟化支持。UMD通过性能优化和安全隔离机制,成为现代AI计算基础设施的理想选择。

MHD0815的博客 172

Feign的工作原理

文章目录Feign的简单介绍Feign的工作原理1.创建远程接口的本地代理实例2.封装Request对象并进行编码3.`feign.Client`发送请求并对获取结果进行解码总结 Feign的简单介绍 Feign组件主要用于微服务项目中,用来简化服务之间的远程调用,相信大家对他的使用方法已经相当熟悉了。那么Feign到底是如何实现服务的远程调用的呢?又是如何发送请求的呢?发送的请求又是什么样子的呢...

weixin_43111776的博客 1万+

Airtest进阶使用篇-提高脚本稳定性+批量运行脚本

Airtest进阶篇,主要分享如何提高脚本稳定性+如何批量运行脚本生成测试报告!

程序员小杨哥的博客 2574

VC中sqlite的使用

在VC中对sqlite的使用,实现数据库大批数据的快速插入,读取数据库中的数据在ListCtrl中显示

SpringBoot项目中使用feign调用远程http接口(超详细文档)

参考文档: Feign远程调用原理 在实际生产需要中,经常会遇到调用远程http接口的场景. 举例: 比如我的Springboot项目会调用另一个Springboot项目的接口, 或者调用一些第三方服务的Restful api. 采用常规的方案,需要配置请求head、body,然后才能发起请求。获得响应体后,还需解析等操作,十分繁琐。 Feign是一个http请求调用的轻量级框架,可以以Java接口注解的方式调用Http请求。 Feign通过处理注解,将请求模板化,当实际调用的时候,传入参数,根据参数再应用

.... 2万+

Probability and Statistics - 4th edition

Probability and Statistics - 4th edition

(七)feign-简化服务调用

前面的章节虽然完成了服务的注册以及相互间的调用,但是调用方发起调用时,还是硬编码的形式,如果服务比较多,代码不好管理。如,用户服务调用订单服务: @PostMapping("/findOrderList") public JSONArray findOrderList() throws Exception { String serviceId = "ORDER"; String url = "http://" + serviceId + "/order/fin

长风破浪会有33的博客 2189

精雕软件(JDpaint) 5.5 绿色版

精雕软件(JDpaint) 5.5 绿色版精雕软件(JDpaint) 5.5 绿色版精雕软件(JDpaint) 5.5 绿色版

迈瑞BS系列全自动生化分析仪LIS协议接口手册(内含HL7和ASTM)

迈瑞BS系列全自动生化分析仪LIS协议接口手册,内含HL7和ASTM)

Feign远程调用

一、Feign简介 Feign是Netflix开发的一个轻量级RESTful的HTTP服务客户端(用它来发起请求, 远程调用的),是以Java接口注解的方式调用Http请求,而不用像Java中通过封装 HTTP请求报文的方式直接调用,Feign被广泛应用在Spring Cloud 的解决方案中。类似于Dubbo,服务消费者拿到服务提供者的接口,然后像调用本地接口方法一样 去调用,实际发出的是远...

吴大侠的博客 6323

基于Feign的远程服务调用

Feign是什么 Feign 是一种声明式Web服务客户端,底层封装了对Rest技术的应用,通过Feign可以简化服务消费方对远程服务提供方法的调用实现。 Feign的远程服务调用步骤: 第一步:添加pom依赖 spring-cloud-starter-openfeign 第二步:主启动类添加@EnableFeignClients 第三步:建立feign接口(此接口中写具体调用的业务) 3.1.添加 @FeignClien...

qq_63686393的博客 4405

feign调用是否会经过网关

结论 不会. 原理: feign原理解析

weixin_43831204的博客 1万+

Spring Cloud Feign全解析:简化微服务调用的最佳实践

Feign 是一个声明式的 Web Service 客户端。它的出现使开发 Web Service 客户端变得很简单。使用 Feign 只需要创建一个接口加上对应的注解,比如:@FeignClient 注解。Feign 有可插拔的注解,包括 Feign 注解和 AX-RS 注解。Feign 也支持编码器和解码器,Spring Cloud Open Feign 对 Feign 进行增强支持 Spring Mvc 注解,可以像 Spring Web 一样使用 HttpMessageConverters 等。

m0_74022498的博客 1885

SpringCloud关于远程调用Feign的知识点

后端接收前端传输的消息,需要使用到@RequestMapping接收映射的URI路径,使用@RequestParam和@RequestVariable和@RequestBody接收参数,对于多个参数的URI,可以使用@RequestParam接收参数,对于单个参数可以不用加注解,直接在方法中使用同名参数接收即可。对于对象的传递,使用@RequestBody接收。对于注册发现的微服务架构而言,fegin接口下的方法对应的URL是通过value对应的微服务的ip+端口号的地址+URL映射路径访问对应功能的。

Ahjbvj的博客 1847

Feign实现远程接口的调用

在自己跟着做项目过程中,对springcloud中的feign实现远程调用不太熟悉,故记录一下。

xyhxuyonghao的博客 2867
上一篇: Mybatis Plus多租户实践:从踩坑到精通的详细历程
下一篇: SpringBoot 实现 License 认证(只校验有效期)
公众号-芋道源码
博客等级 码龄10年 1640粉丝 377原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值