简化本地Feign调用,老手教你这么玩

系统性解决复杂技术难题:从问题定位到根因分析的全流程指南 在软件开发和系统运维中,复杂技术难题的排查与解决是工程师的核心能力之一。这类问题通常涉及多组件交互、现象难以稳定复现、根因与表象距离遥远等特征,需要系统性的方法论而非零散的技巧。其原理在于通过科学的问题定位、环境隔离和深度调试,将模糊的异常转化为可分析、可验证的技术假设。掌握这套方法论的技术价值在于,它能显著提升团队对生产环境偶发故障、性能瓶颈和诡异Bug的响应与解决效率,减少MTTR(平均修复时间),保障系统稳定性。在实际应用场景中,无论是微服务架构下的偶发性超时、难以捉摸的内存泄漏,还是依赖冲突导致的运 阅读详情

点击上方“芋道源码”,选择“设为星标”

管她前浪,还是后浪?

能浪的浪,才是好浪!

每天 10:33 更新文章,每天掉亿点点头发...

源码精品专栏

 

来源:码农参上

28125d04553c25128bb4f5f22058b89e.jpeg


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

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

先看问题

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

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

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

74389c65a59ff5c75fb9f52af5a7e2cd.png

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

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

4f68525cbd055d955e10db1d81ee66c4.png

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

501d64f3fc83ffb27cf767d945317acd.jpeg

总结一下:

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

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

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

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

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

01da491b1bfcb04c6765e0b9e2c687f3.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注解的接口,然后一步步生成代理对象,具体流程可以看一下下面这张图:

13ba595ababe4928921a977fcdd3eb5b.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客户端。

7e2c0153d12932a925d3ab3ab430c38c.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();
}

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

c046691aa25f451a2d10e37571b93998.png

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

9921ebc3cd2c86ec8312ccf85060de46.png

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

65688871072f0d80e39ba5d67385e878.png

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

总结

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

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

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



欢迎加入我的知识星球,一起探讨架构,交流源码。加入方式,长按下方二维码噢:

b0031df783012373671b73b1b30fd5fe.png

已在知识星球更新源码解析如下:

1c4ebfdba2296f813a9d8f3e8b7ae081.jpeg

8a8e10cd0918ec51069ebbec4d80054c.jpeg

bb29f46e8ad352439c5e96781ead77f9.jpeg

04c09741e9563e493257f1ecbc334fd0.jpeg

最近更新《芋道 SpringBoot 2.X 入门》系列,已经 101 余篇,覆盖了 MyBatis、Redis、MongoDB、ES、分库分表、读写分离、SpringMVC、Webflux、权限、WebSocket、Dubbo、RabbitMQ、RocketMQ、Kafka、性能测试等等内容。

提供近 3W 行代码的 SpringBoot 示例,以及超 4W 行代码的电商微服务项目。

获取方式:点“在看”,关注公众号并回复 666 领取,更多内容陆续奉上。

文章有帮助的话,在看,转发吧。
谢谢支持哟 (*^__^*)
oracle合并行---解决listagg 拼接字段返回过长 (Ora-01489 result of String concatenation is too long) 阅读详情

相关推荐

ConvLSTM时空预测实战代码详解

ConvLSTM代码复现

JaysonWong的博客 1万+

手撸一个动态Feign,实现一个“万能”接口调用

点击上方“芋道源码”,选择“设为星标”管她前浪,还是后浪?能浪的浪,才是好浪!每天 10:33更新文章,每天掉亿点点头发...源码精品专栏原创 | Java 2021超神之路,很肝~中文详细注释的开源项目RPC 框架 Dubbo 源码解析网络应用框架 Netty 源码解析消息中间件 RocketMQ 源码解析数据库中间件 Sharding-JDBC 和 MyCAT 源码解析作业调度中间件 E...

芋艿V 820

wsl2内核版本和模块版本不一致解决方法

** /lib/modules/…build: No such file or directory错误解决办法这篇文章历时1个月整,从4月5日一直到5月5日,这一问题才得以解决。

m0_60634555的博客 5105

芋道源码yudao-cloud 二开笔记(Feign服务调用,如何定义一个 API 接口)

在yudao-cloud如何定义一个Api接口,提供给另一个服务去调用?下面是 `yudao-module-syetem系统服务` 调用 `yudao-module-infra文件服务`的示例

qq_31676725的博客 2731

零代码做游戏:AI辅助开发HTML5网页小游戏从创意到发布全流程

在软件开发领域,自然语言编程正成为一种新兴的人机协作方式,而AI辅助开发则是其最典型的落地形态。它让开发者无需精通语法,只需用清晰的语言描述游戏规则与交互逻辑,AI便能自动生成可运行的代码。这种模式大幅降低了编程门槛,尤其适合快速验证创意、制作原型。对于HTML5网页游戏而言,借助AI生成单个HTML文件,配合在线运行环境,即可在浏览器中直接试玩、迭代与分享。无论是产品经理验证玩法、运营人员制作互动小游戏,还是教育者设计课堂闯关,都能通过自然语言描述需求,让AI完成代码实现与报错修复。本文完整记录了一个“接

weixin_31497453的博客 339

ISP Tuning实战:从零开始调校相机传感器的完整流程(附避坑指南)

本文详细介绍了ISP Tuning的完整实战流程,即如何从零开始调校相机传感器以优化成像质量。内容涵盖从黑电平校正、镜头阴影校正等基础标定,到自动曝光、伽马校正、色彩校正等核心画质调校,再到降噪与锐化的平衡策略,并提供了关键的避坑指南。掌握ISP Tuning是提升相机传感器性能、实现从‘能用’到‘好用’的关键技术。

weixin_32098457的博客 196

Cloud服务调用

服务调用 一、Ribbon 1、概述 Spring Cloud Ribbon是基于Netflix Ribboh实现的一套客户端负载均衡的工具。 简单的说,Ribbon是Netflix发布的开源项目, 主要功能是提供客户端的软件负载均衡算法和服务调用。Ribbon客户端组件提供- 系列完善的配置项如连接超时,重试等。简单的说,就是在配置文件中列出Load Balancer (简称LB)后面所有的机器,Ribbon会自动的帮助你基于某种规则(如简单轮询,随机连接等)去连接这些机器。我们很容易使用Ribbon实

瑞文のBlog 803

Oracle数据库RMAN异机恢复保姆级教程,按照步骤来操作,一次就成功!

本文深入解析RMAN异机恢复四大核心场景(演练、数据恢复、故障应急、测试环境搭建),提供从备份到验证的完整步骤和实战脚本。包含RAC到单机迁移技巧、路径调整、常见报错解决方案,助你彻底掌握数据库恢复的“救命技能”。DBA必备干货,强烈推荐

Jackyimi的博客 941

基于OpenFeign的服务调用

OpenFeign是Spring Cloud提供的一个声明式的伪Http客户端, 它使得调用远程服务就像调用本地服务一样简单, 只需要创建一个接口并添加一个注解即可。 Nacos很好的兼容了OpenFeign, OpenFeign默认集成了 Ribbon, 所以在Nacos下使用OpenFeign默认就实现了负载均衡的效果。...

在路上 1538

BACnet/IP BBMD跨网段通信深度解析与最佳实践

本文介绍了在BACnet/IP网络中通过BBMD实现跨子网设备通信的关键配置方法。重点阐述了广播分发表(BDT)中掩码设置的重要性:使用子网掩码(255.255.255.0)会导致路由器拦截广播消息,而必须采用主机掩码(255.255.255.255)才能启用单播隧道机制,使BACnet广播消息封装为可路由的单播UDP包。文章详细说明了BDT条目的正确配置格式、BIP广播地址的作用,并提供了验证步骤,强调在跨网段场景中,正确设置掩码是确保设备发现和通信成功的关键因素。

零一架构师的专栏 1538

YOLOv11改进 | 检测头篇 | 利用AFPN辅助YOLOv11检测头进行特征融合识别(全网独家创新)

本文给大家带来的最新改进机制是利用AFPN(渐近特征金字塔网络)来优化检测头,AFPN的核心思想是通过引入一种渐近的特征融合策略,将底层、高层和顶层的特征逐渐整合到目标检测过程中。这种渐近融合方式有助于减小不同层次特征之间的语义差距,提高特征融合效果,使得检测模型能更好地适应不同层次的语义信息。本文在AFPN的结构基础上,为了适配YOLOv11改进AFPN结构,同时将AFPN融合到YOLOv11中(因为AFPN需要四个检测头,我们只有三个,下一篇文章我会出YOLOv11适配AFPN增加小目标检测头)

Snu77的博客 3751

简化本地 Feign 调用,老手教你该怎么玩

在平常的工作中,OpenFeign作为微服务间的调用组件使用的非常普遍,接口配合注解的调用方式突出一个简便,让我们能无需关注内部细节就能实现服务间的接口调用。但是工作中用久了,发现Feign也有些使用起来麻烦的地方,下面先来看一个问题,再看看我们在工作中是如何解决,以达到简化Feign使用的目的。先看问题在一个项目开发的过程中,我们通常会区分开发环境、测试环境和生产环境,如果有的项目要求更高的话,...

Java知音 185

无人驾驶Autoware导读

认知有限,望大家多多包涵,有什么问题也希望能够与大家多交流,共同成长!本文先对无人驾驶Autoware介绍做个简单的介绍,具体内容后续再更,其他模块可以参考去我其他文章提示:以下是本篇文章正文内容。

qq_35635374的博客 2399

简化本地Feign调用,老手都是这么玩的!

本文提供了一个在本地开发过程中简化Feign调用的思路,相比之前需要麻烦的修改FeignClient中的url而言,能够节省不少的无效劳动,并且通过这个过程,也可以帮助大家了解我们平常使用的这些组件是怎么与spring结合在一起的,熟悉spring的扩展点。并且,FeignClientsRegistrar的源码中已经实现好了很多基础的功能,比如扫扫描包、获取FeignClient的name、contextId、url等等,所以需要改动的地方非常少,可以放心的大抄特超它的代码。

欢迎来到我的博客 486

廖雪峰Python教程[完整版]

廖雪峰的python教程整理的,已经排好版了,而且还是完整的,适合小白

汉书HE8,好用的汇编代码编写工具

汉书HE8,好用的汇编代码编写工具早期编写汇编代码所用功能强大

Feign调用技巧!老手分享如何优雅地进行本地调用!

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

欢迎来到我的博客 4123

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

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

Spring Cloud本地开发:Feign调用直连配置与负载均衡器定制

在微服务架构中,服务间通信是核心基础,通常通过HTTP客户端实现远程调用。其原理是基于服务发现与负载均衡机制,动态定位并调用目标服务实例,以实现服务解耦与水平扩展。这一技术价值在于提升了系统的可维护性和弹性,但在本地开发与测试场景中,依赖注册中心的远程调用会引入不必要的网络开销和复杂性,影响开发调试效率。针对这一痛点,可以通过配置静态服务实例列表或自定义ServiceInstanceListSupplier,在本地环境中实现Feign调用的“短路”,直接指向本地运行的服务实例。这种方法特别适用于Spring

weixin_30384217的博客 486

老版QQ原生表情gif动态

这是老版的QQ表情,不过全是动态的的,Windows照片查看器是不会动的,可以右击用浏览器打开查看,再说一遍是老版的,只是分享给宁愿用老版也要动态的人。

Spring Cloud Alibaba 基础教程:支持的几种服务消费方式(RestTemplate、WebClient、Feign)

使用RestTemplate 在之前的例子中,已经使用过RestTemplate来向服务的某个具体实例发起HTTP请求,但是具体的请求路径是通过拼接完成的,对于开发体验并不好。但是,实际上,在Spring Cloud中对RestTemplate做了增强,只需稍加配置,就能简化之前的调用方式。 比如: @EnableDiscoveryClient @SpringBootApplication pub...

P923284735的博客 326

从老式 MVC 到微服务:飞算 JavaAI 如何一天帮你成为分布式系统开发高手?

要是你想把老式 MVC 的用户模块改成微服务,飞算 JavaAI 还能帮你 “改造旧代码”:自动把单体项目里的 UserController 拆成微服务的接口,把原来的本地调用改成 Feign 远程调用,甚至会帮你处理数据库表的迁移 —— 生成 SQL 脚本时,自动保留原有字段,只新增微服务所需的 “service_id”“create_time” 等字段。按官方文档说的,哪怕你只知道 “要把单体电商项目拆成微服务”,说不出具体组件,打开飞算 JavaAI 输入项目名,它立马启动 “需求拆解模式”。

2201_75994616的博客 360

推荐项目:SpringBoot Java Template - 打造高效启动的Java项目基石

推荐项目:SpringBoot Java Template - 打造高效启动的Java项目基石 在快速迭代和追求生产力的现代软件开发中,选择正确的起点至关重要。今天,我们为您推荐一个精心设计的开源项目——SpringBoot Java Template。它不仅是一个项目模板,更是您构建健壮、可扩展服务的得力助手。 项目介绍 SpringBoot Java Template旨在提供一个既实用又灵活的...

gitblog_00893的博客 821

Spring Boot核心原理与实战:从配置地狱到微服务基石

在Java企业级应用开发中,框架配置的复杂性一直是开发者面临的挑战。Spring Boot通过‘约定大于配置’的设计哲学,从根本上解决了传统Spring框架中繁琐的XML配置和依赖管理混乱问题。其核心机制包括自动配置和Starter依赖管理,能够根据项目Classpath自动推断并装配所需组件,实现了真正的‘开箱即用’。这种设计显著提升了开发效率,降低了心智负担,使得开发者能够快速构建独立、可执行的应用程序。在技术价值层面,Spring Boot不仅简化了开发流程,还通过内嵌容器实现了从开发到部署的范式转移

weixin_30435261的博客 391

1.3java面试题:微服务架构中的分布式事务 Seata

要理解它,得先看一个更根本的问题:为什么在微服务里,保证数据一致这么难?最终一致性:是一种设计哲学,指导我们在分布式系统中,为了高可用性,可以接受数据的短暂不一致。Seata:是一个实用工具,它提供了AT、TCC等多种模式,帮我们把“最终一致性”这个思想落地,以不同的方式管理跨服务的数据一致性。好的,我们接着上次的话题,用一个具体的电商下单场景,把“最终一致性”和Seata的四种模式掰开揉碎了讲清楚。想象一下,我们正在搭建一个微服务架构的电商系统。用户下单这个看似简单的动作,背后需要订单服务。

你是人间四月天 312

从国赛到生产:SkyWalking分布式链路追踪部署与调优实战指南

分布式链路追踪是微服务架构下实现系统可观测性的核心技术,它通过记录请求在多个服务间的完整调用路径、耗时与状态,帮助开发者透视复杂的服务间依赖与性能瓶颈。其原理是在服务调用时注入并传递唯一的追踪标识,由各节点的探针收集数据并上报至分析平台进行聚合与可视化。这项技术的核心价值在于将原本黑盒的分布式调用过程透明化,极大提升了故障定位、性能分析和系统理解的效率,是构建高可靠、易维护的云原生应用的基石。在服务网格、容器化部署等现代应用场景中,分布式链路追踪已成为不可或缺的运维工具。本文以Apache SkyWalki

weixin_30709061的博客 292
上一篇: 基于Mybatis拦截器实现数据范围权限
下一篇: 腾讯捐赠Java编译器基础软件
公众号-芋道源码
博客等级 码龄10年 1639粉丝 377原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值