OSGI架构结合低版本Spring如何引进Feign

本文介绍用不了spring cloud的低版本系统如何借鉴cloud openfeign的封装思想来封装Feign，也能在多个工程以同样的接口申明方式来调用远程接口。

OpenFeign源于Netflix的Feign，是http通信的客户端。屏蔽了网络通信的细节，直接面向接口的方式开发，让开发者感知不到网络通信细节。 所有远程调用，都像调用本地方法一样完成！

封装的关键是OpenFeign 这两个注解,我们后续就是围绕这两个注解来封装

@FeignClient	该注解用于通知 OpenFeign 组件对 @RequestMapping 注解下的接口进行解析，并通过动态代理的方式产生实现类，实现负载均衡和服务调用。
@EnableFeignClients	该注解用于开启 OpenFeign 功能（一般使用在SpringBoot启动类上），当 Spring Cloud 应用启动时，OpenFeign 会扫描标有 @FeignClient 注解的接口，生成代理并注册到 Spring 容器中。

注解声明，面向接口：

/**
* REST 声明式规范(即支持的注解)有以下几种：Feign、JAX-RS 1/2、Spring Web MVC 都需要进行适配。这几种声明式注解的适配接口是 feign.Contract
* 这里选的是JAX-RS 1/2
*/
@FeignClient(name ="InnerOperatorService", path = "business/inner-invoke/", url = "${rootServiceUrl}", primary = false, contextId = "jaxrs")
@Consumes(MediaType.APPLICATION_JSON)
@Produces(MediaType.APPLICATION_JSON)
@Path("/operator")
public interface IInnerOperatorService {
    @POST
 @Path("/login/{code}/{password}")
    Response login(@PathParam("code") String code, @PathParam("password")String password);
}

启动类配置

@SpringBootApplication(scanBasePackages ={"com.liangmixian.selfserviceApp"})
@EnableCaching
@EnableFeignClients({"com.liangmixian.sms.business.api.service"})
@EnableConfigurationProperties({LoginMap.class, AuthSmsParamsConfig.class})
public class FsaApplication extends SpringBootServletInitializer {

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

    @Override
    protected SpringApplicationBuilder configure(SpringApplicationBuilder builder) {
        return builder.sources(FsaApplication.class);
    }

}

替换默认的底层通信

默认远程访问协议为jdk自带的sun.net.www.protocol.http.HttpURLConnection效率低，可改为okHttp

application.properties 配置，关闭默认的sun.net.www.protocol.http.HttpURLConnection，开启okhttp

feign.httpclient.enable=false

feign.okhttp.enable=true

超时控制:

OpenFeign默认超时时间为1s，超过1s就会返回错误页面。如果我们的接口处理业务确实超过1s,就需要对接口进行超时配置，如下：

ribbon: #设置feign客户端连接所用的超时时间，适用于网络状况正常情况下，两端连接所用时间

ReadTimeout: 1000 #指的是建立连接所用时间

ConnectTimeout: 1000 #指建立连接后从服务读取到可用资源所用时间

工作原理分析（这是我们后续封装工作的核心）

SpringBoot 应用启动时， 由针对 @EnableFeignClient 这一注解的处理逻辑触发程序扫描 classPath中所有被@FeignClient 注解的类， 将这些类解析为 BeanDefinition 并生成bean注册到 Spring 容器中，当业务请求真实发生时，Spring 会尝试从容器中查找创建好的动态代理对象,最终的调用被统一转发到了由 Feign 框架实现的 InvocationHandler 中， InvocationHandler 负责将接口中的入参转换为 HTTP 的形式， 发到服务端， 最后再解析 HTTP 响应， 将结果转换为 Java 对象， 予以返回。

扫描@FeignClient注解的接口并注册到Spring容器：

class FeignClientsRegistrar
      implements ImportBeanDefinitionRegistrar, ResourceLoaderAware, EnvironmentAware {

   // patterned after Spring Integration IntegrationComponentScanRegistrar
   // and RibbonClientsConfigurationRegistgrar

   private ResourceLoader resourceLoader;

   private Environment environment;

   FeignClientsRegistrar() {
   }

   static void validateFallback(final Class clazz) {
      Assert.isTrue(!clazz.isInterface(),
            "Fallback class must implement the interface annotated by @FeignClient");
   }

   static void validateFallbackFactory(final Class clazz) {
      Assert.isTrue(!clazz.isInterface(), "Fallback factory must produce instances "
            + "of fallback classes that implement the interface annotated by @FeignClient");
   }

   static String getName(String name) {
      if (!StringUtils.hasText(name)) {
         return "";
      }

      String host = null;
      try {
         String url;
         if (!name.startsWith("http://") && !name.startsWith("https://")) {
            url = "http://" + name;
         }
         else {
            url = name;
         }
         host = new URI(url).getHost();

      }
      catch (URISyntaxException e) {
      }
      Assert.state(host != null, "Service id not legal hostname (" + name + ")");
      return name;
   }

   static String getUrl(String url) {
      if (StringUtils.hasText(url) && !(url.startsWith("#{") && url.contains("}"))) {
         if (!url.contains("://")) {
            url = "http://" + url;
         }
         try {
            new URL(url);
         }
         catch (MalformedURLException e) {
            throw new IllegalArgumentException(url + " is malformed", e);
         }
      }
      return url;
   }

   static String getPath(String path) {
      if (StringUtils.hasText(path)) {
         path = path.trim();
         if (!path.startsWith("/")) {
            path = "/" + path;
         }
         if (path.endsWith("/")) {
            path = path.substring(0, path.length() - 1);
         }
      }
      return path;
   }

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

   @Override
   public void registerBeanDefinitions(AnnotationMetadata metadata,
         BeanDefinitionRegistry registry) {
      registerDefaultConfiguration(metadata, registry);
      registerFeignClients(metadata, registry);
   }

   private void registerDefaultConfiguration(AnnotationMetadata metadata,
         BeanDefinitionRegistry registry) {
      Map defaultAttrs = metadata
            .getAnnotationAttributes(EnableFeignClients.class.getName(), true);

      if (defaultAttrs != null && defaultAttrs.containsKey("defaultConfiguration")) {
         String name;
         if (metadata.hasEnclosingClass()) {
            name = "default." + metadata.getEnclosingClassName();
         }
         else {
            name = "default." + metadata.getClassName();
         }
         registerClientConfiguration(registry, name,
               defaultAttrs.get("defaultConfiguration"));
      }
   }

   public void registerFeignClients(AnnotationMetadata metadata,
         BeanDefinitionRegistry registry) {

      LinkedHashSet candidateComponents = new LinkedHashSet<>();
      Map attrs = metadata
            .getAnnotationAttributes(EnableFeignClients.class.getName());
      final Class[] clients = attrs == null ? null
            : (Class[]) attrs.get("clients");
      if (clients == null || clients.length == 0) {
         ClassPathScanningCandidateComponentProvider scanner = getScanner();
         scanner.setResourceLoader(this.resourceLoader);
         scanner.addIncludeFilter(new AnnotationTypeFilter(FeignClient.class));
         Set basePackages = getBasePackages(metadata);
         for (String basePackage : basePackages) {
            candidateComponents.addAll(scanner.findCandidateComponents(basePackage));
         }
      }
      else {
         for (Class clazz : clients) {
            candidateComponents.add(new AnnotatedGenericBeanDefinition(clazz));
         }
      }

      for (BeanDefinition candidateComponent : candidateComponents) {
         if (candidateComponent instanceof AnnotatedBeanDefinition) {
            // 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 attributes = annotationMetadata
                  .getAnnotationAttributes(FeignClient.class.getCanonicalName());

            String name = getClientName(attributes);
            registerClientConfiguration(registry, name,
                  attributes.get("configuration"));

            registerFeignClient(registry, annotationMetadata, attributes);
         }
      }
   }

   private void registerFeignClient(BeanDefinitionRegistry registry,
         AnnotationMetadata annotationMetadata, Map attributes) {
      String className = annotationMetadata.getClassName();
      Class clazz = ClassUtils.resolveClassName(className, null);
      ConfigurableBeanFactory beanFactory = registry instanceof ConfigurableBeanFactory
            ? (ConfigurableBeanFactory) registry : null;
      String contextId = getContextId(beanFactory, attributes);
      String name = getName(attributes);
      FeignClientFactoryBean factoryBean = new FeignClientFactoryBean();
      factoryBean.setBeanFactory(beanFactory);
      factoryBean.setName(name);
      factoryBean.setContextId(contextId);
      factoryBean.setType(clazz);
      BeanDefinitionBuilder definition = BeanDefinitionBuilder
            .genericBeanDefinition(clazz, () -> {
               factoryBean.setUrl(getUrl(beanFactory, attributes));
               factoryBean.setPath(getPath(beanFactory, attributes));
               factoryBean.setDecode404(Boolean
                     .parseBoolean(String.valueOf(attributes.get("decode404"))));
               Object fallback = attributes.get("fallback");
               if (fallback != null) {
                  factoryBean.setFallback(fallback instanceof Class
                        ? (Class) fallback
                        : ClassUtils.resolveClassName(fallback.toString(), null));
               }
               Object fallbackFactory = attributes.get("fallbackFactory");
               if (fallbackFactory != null) {
                  factoryBean.setFallbackFactory(fallbackFactory instanceof Class
                        ? (Class) fallbackFactory
                        : ClassUtils.resolveClassName(fallbackFactory.toString(),
                              null));
               }
               return factoryBean.getObject();
            });
      definition.setAutowireMode(AbstractBeanDefinition.AUTOWIRE_BY_TYPE);
      definition.setLazyInit(true);
      validate(attributes);

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

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

      beanDefinition.setPrimary(primary);

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

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

   private void validate(Map attributes) {
      AnnotationAttributes annotation = AnnotationAttributes.fromMap(attributes);
      // This blows up if an aliased property is overspecified
      // FIXME annotation.getAliasedString("name", FeignClient.class, null);
      validateFallback(annotation.getClass("fallback"));
      validateFallbackFactory(annotation.getClass("fallbackFactory"));
   }

   /* for testing */ String getName(Map attributes) {
      return getName(null, attributes);
   }

   String getName(ConfigurableBeanFactory beanFactory, Map attributes) {
      String name = (String) attributes.get("serviceId");
      if (!StringUtils.hasText(name)) {
         name = (String) attributes.get("name");
      }
      if (!StringUtils.hasText(name)) {
         name = (String) attributes.get("value");
      }
      name = resolve(beanFactory, name);
      return getName(name);
   }

   private String getContextId(ConfigurableBeanFactory beanFactory,
         Map attributes) {
      String contextId = (String) attributes.get("contextId");
      if (!StringUtils.hasText(contextId)) {
         return getName(attributes);
      }

      contextId = resolve(beanFactory, contextId);
      return getName(contextId);
   }

   private String resolve(ConfigurableBeanFactory beanFactory, String value) {
      if (StringUtils.hasText(value)) {
         if (beanFactory == null) {
            return this.environment.resolvePlaceholders(value);
         }
         BeanExpressionResolver resolver = beanFactory.getBeanExpressionResolver();
         String resolved = beanFactory.resolveEmbeddedValue(value);
         if (resolver == null) {
            return resolved;
         }
         return String.valueOf(resolver.evaluate(resolved,
               new BeanExpressionContext(beanFactory, null)));
      }
      return value;
   }

   private String getUrl(ConfigurableBeanFactory beanFactory,
         Map attributes) {
      String url = resolve(beanFactory, (String) attributes.get("url"));
      return getUrl(url);
   }

   private String getPath(ConfigurableBeanFactory beanFactory,
         Map attributes) {
      String path = resolve(beanFactory, (String) attributes.get("path"));
      return getPath(path);
   }

   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;
         }
      };
   }

   protected Set getBasePackages(AnnotationMetadata importingClassMetadata) {
      Map attributes = importingClassMetadata
            .getAnnotationAttributes(EnableFeignClients.class.getCanonicalName());

      Set basePackages = new HashSet<>();
      for (String pkg : (String[]) attributes.get("value")) {
         if (StringUtils.hasText(pkg)) {
            basePackages.add(pkg);
         }
      }
      for (String pkg : (String[]) attributes.get("basePackages")) {
         if (StringUtils.hasText(pkg)) {
            basePackages.add(pkg);
         }
      }
      for (Class clazz : (Class[]) attributes.get("basePackageClasses")) {
         basePackages.add(ClassUtils.getPackageName(clazz));
      }

      if (basePackages.isEmpty()) {
         basePackages.add(
               ClassUtils.getPackageName(importingClassMetadata.getClassName()));
      }
      return basePackages;
   }

   private String getQualifier(Map client) {
      if (client == null) {
         return null;
      }
      String qualifier = (String) client.get("qualifier");
      if (StringUtils.hasText(qualifier)) {
         return qualifier;
      }
      return null;
   }

   private String[] getQualifiers(Map client) {
      if (client == null) {
         return null;
      }
      List qualifierList = new ArrayList<>(
            Arrays.asList((String[]) client.get("qualifiers")));
      qualifierList.removeIf(qualifier -> !StringUtils.hasText(qualifier));
      if (qualifierList.isEmpty() && getQualifier(client) != null) {
         qualifierList = Collections.singletonList(getQualifier(client));
      }
      return !qualifierList.isEmpty() ? qualifierList.toArray(new String[0]) : null;
   }

   private String getClientName(Map client) {
      if (client == null) {
         return null;
      }
      String value = (String) client.get("contextId");
      if (!StringUtils.hasText(value)) {
         value = (String) client.get("value");
      }
      if (!StringUtils.hasText(value)) {
         value = (String) client.get("name");
      }
      if (!StringUtils.hasText(value)) {
         value = (String) client.get("serviceId");
      }
      if (StringUtils.hasText(value)) {
         return value;
      }

      throw new IllegalStateException("Either 'name' or 'value' must be provided in @"
            + FeignClient.class.getSimpleName());
   }

   private void registerClientConfiguration(BeanDefinitionRegistry registry, Object name,
         Object configuration) {
      BeanDefinitionBuilder builder = BeanDefinitionBuilder
            .genericBeanDefinition(FeignClientSpecification.class);
      builder.addConstructorArgValue(name);
      builder.addConstructorArgValue(configuration);
      registry.registerBeanDefinition(
            name + "." + FeignClientSpecification.class.getSimpleName(),
            builder.getBeanDefinition());
   }

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

}

生成代理对象的FactoryBean：

public class FeignClientFactoryBean implements FactoryBean