Feign服务通信的实现

feign的用法

还是通过spring官网，首先创建两个项目，demoA和demoB，引入openfeign；我把demoA的端口设置为9000，demoB的端口设置为9001。

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

@EnableFeignClients的使用

在启动类上添加注解，并且把basePackages指向feign的包

package com.example.demoA;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.openfeign.EnableFeignClients;

@SpringBootApplication
@EnableFeignClients(basePackages="com.example.demoA.feign")
public class DemoAApplication {

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

}

@FeignClient的使用

然后创建一个接口，添加@FeignClient注解

package com.example.demoA.feign;

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

@FeignClient(name = "remoteTestB", url = "http://localhost:9001")
public interface RemoteTestB {

    @GetMapping("/testB/test1")
    String testB();
}

就能实现两个服务互相调用了，以上是demoA调用demoB的示例，检验一下

package com.example.demoA.controller;

import com.example.demoA.feign.RemoteTestB;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;


@RestController
@RequestMapping("/testA")
public class TestA {

    @Autowired
    RemoteTestB remoteTestB;

    @GetMapping("/test1")
    public Object test1() {
        return "this is test1 of testA";
    }

    @GetMapping("/test2")
    public Object test2() {
        return remoteTestB.testB();
    }


}

当我调用demoA的test2的方法时，出现

说明demoA成功调用了demoB，此时，我们已经会使用feign了。

如何实现服务间通信

那么feign是怎么实现服务间通信的呢？通过这个调用方式，我们可以大概反推出来一个过程:

1.启动类里加上@EnableFeignClients后，在启动时，被@FeignClient注解过的类会注册到容器中。

2.被@FeignClient注解的是接口，需要用到动态代理方式补全通信逻辑。

所以现在我们拆解这两步，为了搞懂这两个注解的逻辑，我们新建一个项目仿写一个逻辑简单的feign，虽然逻辑比较简单，过程比较粗暴，不过正适合新手学习。

自定义注解

第一步当然是创建两个注解

@EnableFeignClients中的逻辑就是：利用@Import和ImportBeanDefinitionRegistrar配合，重写一个registerBeanDefinitions方法，在这个方法中实现自定义的bean注册逻辑。

这段源码研究好几天，只提炼出最核心的两个步骤：

1.扫描文件，把带有MyFeignClient的接口都找到；

2.把带有MyFeignClient的接口生成一个代理类，注册到容器中；

其他一概没看懂，不过在此挖个坑，以后详细写一篇spring自定义注册。

package com.example.myopenfeign;


import org.springframework.context.annotation.Import;

import java.lang.annotation.*;

@Import(MyFeignRegister.class)
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Documented
public @interface MyEnableFeignClients {
}

package com.example.myopenfeign;

import org.springframework.beans.factory.annotation.AnnotatedBeanDefinition;
import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.beans.factory.support.BeanDefinitionBuilder;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.context.EnvironmentAware;
import org.springframework.context.ResourceLoaderAware;
import org.springframework.context.annotation.ClassPathScanningCandidateComponentProvider;
import org.springframework.context.annotation.ImportBeanDefinitionRegistrar;
import org.springframework.core.env.Environment;
import org.springframework.core.io.ResourceLoader;
import org.springframework.core.type.AnnotationMetadata;
import org.springframework.core.type.filter.AnnotationTypeFilter;
import org.springframework.util.Assert;

import java.util.LinkedHashSet;
import java.util.Map;


public class MyFeignRegister implements ImportBeanDefinitionRegistrar, ResourceLoaderAware, EnvironmentAware {

    private ResourceLoader resourceLoader;

    private Environment environment;

    @Override
    public void setEnvironment(Environment environment) {
        this.environment = environment;
    }

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

    @Override
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
        LinkedHashSet<BeanDefinition> candidateComponents = new LinkedHashSet<>();
        //扫描文件，把带有MyFeignClient的接口都找到
        ClassPathScanningCandidateComponentProvider scanner = getScanner();
        scanner.setResourceLoader(resourceLoader);
        scanner.addIncludeFilter(new AnnotationTypeFilter(MyFeignClient.class));
        candidateComponents.addAll(scanner.findCandidateComponents("com.example"));
        for (BeanDefinition candidateComponent : candidateComponents) {
            if (candidateComponent instanceof AnnotatedBeanDefinition beanDefinition) {
                AnnotationMetadata annotationMetadata = beanDefinition.getMetadata();
                Assert.isTrue(annotationMetadata.isInterface(), "@FeignClient can only be specified on an interface");

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

                String name = attributes.get("value").toString();
                String beanClassName = candidateComponent.getBeanClassName();

                //把带有MyFeignClient的接口生成一个代理类，注册到容器中
                try {
                    Class<?> aClass1 = Class.forName(beanClassName);
                    BeanDefinitionBuilder beanDefinitionBuilder = BeanDefinitionBuilder.genericBeanDefinition(MyFeignFactoryBean.class);
                    beanDefinitionBuilder.addConstructorArgValue(aClass1);
                    registry.registerBeanDefinition(name, beanDefinitionBuilder.getBeanDefinition());
                } catch (ClassNotFoundException e) {
                    throw new RuntimeException(e);
                }

            }
        }
    }

    protected ClassPathScanningCandidateComponentProvider getScanner() {
        return new ClassPathScanningCandidateComponentProvider(false, this.environment) {
            @Override
            protected boolean isCandidateComponent(AnnotatedBeanDefinition beanDefinition) {
                boolean isCandidate = false;
                if (beanDefinition.getMetadata().isIndependent()) {
                    if (!beanDefinition.getMetadata().isAnnotation()) {
                        isCandidate = true;
                    }
                }
                return isCandidate;
            }
        };
    }

}

package com.example.myopenfeign;

import java.lang.annotation.*;

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
public @interface MyFeignClient {

    String value() default "";

    String url() default "";
}

代理生成bean

package com.example.myopenfeign;

import org.springframework.beans.factory.FactoryBean;

import java.lang.reflect.Proxy;

public class MyFeignFactoryBean <T> implements FactoryBean {

    private Class<T> interfaceClass;

    public MyFeignFactoryBean(Class<T> interfaceClass){
        this.interfaceClass = interfaceClass;
    }

    @Override
    public T getObject() throws Exception {
        return (T) Proxy.newProxyInstance(
                interfaceClass.getClassLoader(), // 目标类的类加载器
                new Class[]{interfaceClass},  // 代理需要实现的接口，可指定多个
                new MyFeignInvocationHandler()
        );
    }

    @Override
    public Class<?> getObjectType() {
        return interfaceClass;
    }
}

实现真正的代理方法逻辑

package com.example.myopenfeign;

import cn.hutool.http.HttpUtil;
import org.springframework.web.bind.annotation.GetMapping;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

public class MyFeignInvocationHandler implements InvocationHandler {

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) {
        System.out.println("before method " + method.getName());
        Class<?> declaringClass = method.getDeclaringClass();
        MyFeignClient annotation = declaringClass.getAnnotation(MyFeignClient.class);
        String url = annotation.url();
        GetMapping annotation1 = method.getAnnotation(GetMapping.class);
        String[] value1 = annotation1.value();
        String s = HttpUtil.get(url + value1[0]);
        return s;
    }
}

以上就完成了简单的feign逻辑。

测试

首先在启动类里加上我们自定义的@MyEnableFeignClients

package com.example.myopenfeign;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;

@SpringBootApplication
@MyEnableFeignClients
public class MyOpenFeignApplication {

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

}

然后创建一个用于服务通信的接口，还是指向刚刚新建的demoA服务

package com.example.myopenfeign.test;

import com.example.myopenfeign.MyFeignClient;
import org.springframework.web.bind.annotation.GetMapping;

@MyFeignClient(value = "remote",url = "http://localhost:9000")
public interface Remote {

    @GetMapping("/testA/test1")
    Object getA();
}

最后使用这个接口

package com.example.myopenfeign.test;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/myFeignTest")
public class TestController {

    @Autowired
    Remote remote;

    @GetMapping("/test1")
    public Object test(){
        Object a = remote.getA();
        return a;
    }
}

启动后调用 http://localhost:8080/myFeignTest/test1

结果成功！

以上就是实现feign的过程，掌握这个过程，我们可以照此模式扩展写出自定义的bean注册逻辑。