Hankin晚风
Hankin晚风

第四章 Feign接口服务及源码解析笔记

前面已经学习了Ribbon，从Eureka获取服务的实例在通过RestTemplate调用，并转换成需要的对象

如：List list = restTemplate.exchange(PRODUCT_LIST_URL,HttpMethod.GET,new HttpEntity(httpHeaders), List.class).

getBody();

可以发现所有的数据调用和转换都是由用户直接来完成的，我们可能不想直接访问Rest接口，如果转换回来的直接是对象而不需要直接使用RestTemplate进行转换就好了，这个时候就需要使用Feign了。

代码Git地址：https://gitee.com/hankin_chj/springcloud-micro-service.git

注意：Feign不建议大家使用，流程简单并发不高的方法可以用一用。

一、Feign基本使用

1、创建新模块Feign

复制springcloud-micro-consumer成一个新的模块springcloud-micro-consumer-feign

Feign服务修改pom文件，增加对feign的支持：

<dependencies>
    <dependency>
        <groupId>com.chjgroupId>
        <artifactId>springcloud-micro-apiartifactId>
    dependency>
    <dependency>
        <groupId>org.springframework.bootgroupId>
        <artifactId>spring-boot-starter-webartifactId>
    dependency>
    <dependency>
        <groupId>org.springframework.bootgroupId>
        <artifactId>spring-boot-starter-testartifactId>
        <scope>testscope>
    dependency>
    <dependency>
        <groupId>org.springframework.bootgroupId>
        <artifactId>spring-boot-devtoolsartifactId>
    dependency>
    
    <dependency>
        <groupId>org.springframework.cloudgroupId>
        <artifactId>spring-cloud-starter-netflix-eureka-clientartifactId>
    dependency>
    
    <dependency>
        <groupId>org.springframework.cloudgroupId>
        <artifactId>spring-cloud-starter-openfeignartifactId>
    dependency>
dependencies>

注意：这里又有版本问题，如果是Edgware或之前的版本，使用下面的版本

<dependency>
    <groupId>org.springframework.cloudgroupId>
    <artifactId>spring-cloud-starter-feignartifactId>
dependency>

feign的操作其实需要ribbon的支持。

2、新建springcloud-micro-service-feign模块

2.1、这个模块专门定义客户端的调用接口，修改pom文件如下：

<dependencies>
    <dependency>
        <groupId>org.springframework.cloudgroupId>
        <artifactId>spring-cloud-starter-openfeignartifactId>
    dependency>
    <dependency>
        <groupId>com.chjgroupId>
        <artifactId>springcloud-micro-apiartifactId>
    dependency>
dependencies>

2.2、安全服务提供方的认证问题

service-feign模块如果要通过Feign进行远程调用，依然需要安全服务提供方的认证问题，不过在feign里面已经集成了这块功能，代码如下：

@Configuration
public class FeignClientConfig {
    @Bean
    public BasicAuthRequestInterceptor getBasicAuthRequestInterceptor() {
        return new BasicAuthRequestInterceptor("admin", "admin");
    }
}

2.3、service-feign模块新建一个IProductClientService接口

@FeignClient(name = "SPRINGCLOUD-MICRO-PRODUCT", configuration = FeignClientConfig.class)
public interface IProductClientService {
    @RequestMapping("/prodcut/get/{id}")
    public Product getProduct(@PathVariable("id")long id);
    @RequestMapping("/prodcut/list")
    public List listProduct() ;
    @RequestMapping("/prodcut/add")
    public boolean addPorduct(Product product) ;
}

3、模块springcloud-micro-consumer-feign配置

3.1、consumer-feign引入service-feign包

springcloud-micro-consumer-feign模块修改pom文件，引入springcloud-micro-service-feign包：


<dependency>
    <groupId>com.chjgroupId>
    <artifactId>springcloud-micro-service-feignartifactId>
dependency>

3.2、consumer-feign模块删除RestConfig.java类

springcloud-micro-consumer-feign模块由于microcloud-service里面已经做了安全验证，并且后面并不直接使用RestTemplate ，所以删除RestConfig.java类。

3.3、consumer-feign模块修改ConsumerProductController

springcloud-micro-consumer-feign模块修改ConsumerProductController，这个时候直接使用microcloud-service定义的服务就可以了，具体实现如下：

@RestController
@RequestMapping("/consumer")
public class ConsumerProductController {
    @Resource
    private IProductClientService iProductClientService;
    @RequestMapping("/product/get")
    public Object getProduct(long id) {
        return  iProductClientService.getProduct(id);
    }
    @RequestMapping("/product/list")
    public  Object listProduct() {
        return iProductClientService.listProduct();
    }
    @RequestMapping("/product/add")
    public Object addPorduct(Product product) {
        return  iProductClientService.addPorduct(product);
    }
}

由此可见，这个时候ConsumerProductController的代码已经简洁了不少。

3.4、consumer-feign模块修改程序主类

由于使用了feign接口功能，需要添加@EnableFeignClients()注解：

@SpringBootApplication
@EnableEurekaClient
//@RibbonClient(name ="SPRINGCLOUD-MICRO-PRODUCT" ,configuration = RibbonConfig.class)
@EnableFeignClients("com.chj.service") // 扫描feign接口服务的service包
public class ConsumerFeignApp {
    public static void main(String[] args) {
        SpringApplication.run(ConsumerFeignApp.class,args);
    }
}

4、启动测试:

访问地址：http://localhost/consumer/product/list

可以发现Feign在调用接口的时候自带负载均衡，并且使用了默认的轮询方式，这也不奇怪，因为Fegin里面内置就使用了Ribbon，可以做个测试，看下是否真的如此consumer-feign修改程序主类ConsumerFeignApp。

添加注解：@RibbonClient(name ="MICROCLOUD-PROVIDER-PRODUCT" ,configuration = RibbonConfig.class)

启动测试：http://localhost/consumer/product/list

可以发现，现在的路由规则以及变成了随机访问

二、其他配置

1、数据压缩

前面我们已经知道Feign之中最核心的作用就是将Rest服务的信息转化为接口，这其中还有其他的一些地方应该要考虑，比如，数据的压缩。Rest协议更多的传输的是文本，JSON或者XML，如果用户发送的请求很大，这个时候有必要对数据进行压缩处理，好在feign本身就提供了压缩的支持。

FeignContentGzipEncodingAutoConfiguration可以先看下这个类：

@Configuration
@EnableConfigurationProperties({FeignClientEncodingProperties.class})
@ConditionalOnClass({Feign.class})
@ConditionalOnBean({Client.class})
@ConditionalOnMissingBean(
    type = { "okhttp3.OkHttpClient"}
)
@ConditionalOnProperty(
    value = { "feign.compression.request.enabled"},
    matchIfMissing = false
)
@AutoConfigureAfter({FeignAutoConfiguration.class})
public class FeignContentGzipEncodingAutoConfiguration {

虽然Feign支持压缩，但默认是不开启的，再看下FeignClientEncodingProperties，可以根据这里面的属性进行相关压缩的配置。

@ConfigurationProperties("feign.compression.request")
public class FeignClientEncodingProperties {
    private String[] mimeTypes = new String[]{ "text/xml", "application/xml", "application/json"};
    private int minRequestSize = 2048;

consumer-feign模块修改application.yml配置文件：

feign:
  compression:
    request:
      enabled: true
      mime-types: # 可以被压缩的类型
        - text/xml
        - application/xml
        - application/json
      min-request-size: 2048 # 超过2048的字节进行压缩

2、日志配置

在构建@FeignClient注解修饰的服务客户端时，会为一个客户端都创建一个feign.Logger实例，可以利用日志来分析Feign的请求细节，不过默认Feign的日志是不开启的。

2.1、consumer-feign模块修改

 修改application.yml配置文件，增加日志信息：

logging:
  level:
    com.chj.service: DEBUG

只添加上面配置还无法实现对DEBUG日志的输出，以因为Feign客户端默认的logger.level对象定义为none级别，所以不会记录feign调用过程中的信息。

public static enum Level {
    NONE, // 默认
    BASIC,
    HEADERS,
    FULL;
    private Level() {
    }
}

2.2、service-feign模块修改FeignClientConfig，开启日志输出

@Configuration
public class FeignClientConfig {
    @Bean
    public BasicAuthRequestInterceptor getBasicAuthRequestInterceptor() {
        return new BasicAuthRequestInterceptor("admin", "admin");
    }
    @Bean
    public Logger.Level getFeignLoggerLevel() {
        return feign.Logger.Level.FULL ;
    }
}

2.3、启动访问，查看日志输出

访问诶之：localhost/consumer/product/list

日志打印结果：

2019-11-21 01:41:46.696 DEBUG 313788 --- [p-nio-80-exec-4] com.chj.service.IProductClientService    : [IProductClientService#listProduct] ---> GET http://SPRINGCLOUD-MICRO-PRODUCT/prodcut/list HTTP/1.1

2019-11-21 01:41:46.697 DEBUG 313788 --- [p-nio-80-exec-4] com.chj.service.IProductClientService    : [IProductClientService#listProduct] Authorization: Basic YWRtaW46YWRtaW4=

2019-11-21 01:41:46.697 DEBUG 313788 --- [p-nio-80-exec-4] com.chj.service.IProductClientService    : [IProductClientService#listProduct] ---> END HTTP (0-byte body)

2019-11-21 01:41:46.782 DEBUG 313788 --- [p-nio-80-exec-4] com.chj.service.IProductClientService    : [IProductClientService#listProduct] <--- HTTP/1.1 200 (85ms)

2019-11-21 01:41:46.783 DEBUG 313788 --- [p-nio-80-exec-4] com.chj.service.IProductClientService    : [IProductClientService#listProduct] cache-control: no-cache, no-store, max-age=0, must-revalidate

2019-11-21 01:41:46.783 DEBUG 313788 --- [p-nio-80-exec-4] com.chj.service.IProductClientService    : [IProductClientService#listProduct] content-type: application/json;charset=UTF-8

2019-11-21 01:41:46.783 DEBUG 313788 --- [p-nio-80-exec-4] com.chj.service.IProductClientService    : [IProductClientService#listProduct] date: Wed, 20 Nov 2019 17:41:46 GMT

2019-11-21 01:41:46.783 DEBUG 313788 --- [p-nio-80-exec-4] com.chj.service.IProductClientService    : [IProductClientService#listProduct] expires: 0

2019-11-21 01:41:46.783 DEBUG 313788 --- [p-nio-80-exec-4] com.chj.service.IProductClientService    : [IProductClientService#listProduct] pragma: no-cache

2019-11-21 01:41:46.783 DEBUG 313788 --- [p-nio-80-exec-4] com.chj.service.IProductClientService    : [IProductClientService#listProduct] transfer-encoding: chunked

2019-11-21 01:41:46.783 DEBUG 313788 --- [p-nio-80-exec-4] com.chj.service.IProductClientService    : [IProductClientService#listProduct] x-content-type-options: nosniff

2019-11-21 01:41:46.783 DEBUG 313788 --- [p-nio-80-exec-4] com.chj.service.IProductClientService    : [IProductClientService#listProduct] x-frame-options: DENY

2019-11-21 01:41:46.783 DEBUG 313788 --- [p-nio-80-exec-4] com.chj.service.IProductClientService    : [IProductClientService#listProduct] x-xss-protection: 1; mode=block

2019-11-21 01:41:46.783 DEBUG 313788 --- [p-nio-80-exec-4] com.chj.service.IProductClientService    : [IProductClientService#listProduct]

2019-11-21 01:41:46.783 DEBUG 313788 --- [p-nio-80-exec-4] com.chj.service.IProductClientService    : [IProductClientService#listProduct] [{"productId":null,"productName":"java编程

","productDesc":"springcloud"},{"productId":null,"productName":"Springboot","productDesc":"springcloud"},{"productId":null,"productName":"西游记","productDesc":"springcloud"},{"productId":null,"productName":"水浒传

","productDesc":"springcloud"},{"productId":null,"productName":"西厢记","productDesc":"springcloud"}]

2019-11-21 01:41:46.783 DEBUG 313788 --- [p-nio-80-exec-4] com.chj.service.IProductClientService    : [IProductClientService#listProduct] <--- END HTTP (368-byte body)

3、总结

·当使用Feign要通过接口的方法访问Rest服务的时候会根据设置的服务类型发出请求，这个请求是发送给Eureka。

·随后由于配置了授权处理，所以继续发送授权信息（Authorization），其实在外面使用RestTemplate的时候也是这么做的，可以对应日志的加密内容和直接访问其实是一样的。

·在进行服务调用的时候Feign融合了Ribbon技术，所以也支持有负载均衡的处理。

Feign = RestTempate + HttpHeader + Ribbon + Eureka 综合体，使用feign大大增加了代码的灵活程度。

三、Feign源码解析

1、代码入口分析

@SpringBootApplication
@EnableEurekaClient
@RibbonClient(name ="SPRINGCLOUD-MICRO-PRODUCT" ,configuration = RibbonConfig.class)
@EnableFeignClients("com.chj.service") // 扫描feign接口服务的service包
public class ConsumerFeignApp {
    public static void main(String[] args) {
        SpringApplication.run(ConsumerFeignApp.class,args);
    }
}

在@EnableFeignClients标签中，import了一个FeignClientsRegistrar类：

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Documented
@Import(FeignClientsRegistrar.class)
public @interface EnableFeignClients {
    String[] value() default {};
    String[] basePackages() default {};
    Class[] basePackageClasses() default {};
    Class[] defaultConfiguration() default {};
    Class[] clients() default {};
}

org.springframework.cloud.openfeign.FeignClientsRegistrar#registerBeanDefinitions方法里面有两个核心方法，它会在AbstractApplicationContext#refresh()方法中被调用，这部分可以参考spring的源代码。

核心方法registerDefaultConfiguration()：从EnableFeignClients的属性值来构建Feign的Configuration。

核心方法registerFeignClients()：扫描package，注册被@FeignClient修饰的接口类Bean的信息。

@Override
public void registerBeanDefinitions(AnnotationMetadata metadata, BeanDefinitionRegistry registry) {
    //TODO 从EnableFeignClients的属性值来构建Feign的Configuration
    registerDefaultConfiguration(metadata, registry);
    //TODO 扫描package,注册被@FeignClient修饰的接口类Bean的信息
    registerFeignClients(metadata, registry);
}

2、核心方法registerDefaultConfiguration分析

org.springframework.cloud.openfeign.FeignClientsRegistrar#registerDefaultConfiguration

private void registerDefaultConfiguration(AnnotationMetadata metadata, BeanDefinitionRegistry registry) {
    //TODO 获取到metadata中关于EnableFeignClients的属性值键值对。
    Map defaultAttrs = metadata.getAnnotationAttributes(EnableFeignClients.class.getName(), true);
    //TODO 如果配置了defaultConfiguration 进行配置,如果没有使用默认的configuration
    if (defaultAttrs != null && defaultAttrs.containsKey("defaultConfiguration")) {
        String name;
        if (metadata.hasEnclosingClass()) {
            name = "default." + metadata.getEnclosingClassName();
        }else {
            name = "default." + metadata.getClassName();
        }
        //TODO 进行注册
        registerClientConfiguration(registry, name,defaultAttrs.get("defaultConfiguration"));
    }
}

2.1、registerClientConfiguration进行注册方法分析

org.springframework.cloud.openfeign.FeignClientsRegistrar#registerClientConfiguration接下来进行注册：

private void registerClientConfiguration(BeanDefinitionRegistry registry, Object name,Object configuration) {

//使用BeanDefinitionBuilder来生成BeanDefinition,并把它进行注册
   BeanDefinitionBuilder builder = BeanDefinitionBuilder .genericBeanDefinition(FeignClientSpecification.class);
   builder.addConstructorArgValue(name);
   builder.addConstructorArgValue(configuration);
   registry.registerBeanDefinition( name + "." + FeignClientSpecification.class.getSimpleName(),
         builder.getBeanDefinition());
}

方法的入参BeanDefinitionRegistry是spring框架用于动态注册BeanDefinition信息的接口，调用registerBeanDefinition方法可以将BeanDefinition注册到Spring容器中，其中name属性就是注册的BeanDefinition的名称，在这里它注册了一个FeignClientSpecification的对象。

FeignClientSpecification实现了NamedContextFactory.Specification接口，它是Feign实例化的重要一环，在上面的方法中，它持有自定义配置的组件实例，SpringCloud使用NamedContextFactory创建一些列的运行上下文ApplicationContext来让对应的Specification在这些上下文中创建实例对象。

2.2、NamedContextFactory有3个功能：

·创建AnnotationConfigApplicationContext上下文。

·在上下文中创建并获取bean实例。

·当上下文销毁时清除其中的feign实例。

NamedContextFactory有个非常重要的子类FeignContext，用于存储各种OpenFeign的组件实例。

public class FeignContext extends NamedContextFactory {
   public FeignContext() {
      super(FeignClientsConfiguration.class, "feign", "feign.client.name");
   }
}

2.3、FeignContext是哪里构建的呢？

配置见：pring-cloud-openfeign-core-2.0.0.RELEASE.jar!\META-INF\spring.factories

 

第四章 Feign接口服务及源码解析笔记_第1张图片

2.4、启动配置类FeignAutoConfiguration代码分析：

org.springframework.cloud.openfeign.FeignAutoConfiguration#feignContext方法代码如下：

@Configuration
@ConditionalOnClass(Feign.class)
@EnableConfigurationProperties({FeignClientProperties.class, FeignHttpClientProperties.class})
public class FeignAutoConfiguration {
   @Autowired(required = false)
   private List configurations = new ArrayList<>();
   @Bean
   public HasFeatures feignFeature() {
      return HasFeatures.namedFeature("Feign", Feign.class);
   }
   @Bean
   public FeignContext feignContext() {
      FeignContext context = new FeignContext();
      context.setConfigurations(this.configurations);
      return context;
   }

public class FeignContext extends NamedContextFactory {
   public FeignContext() {

//将默认的FeignClientsConfiguration作为参数传递给构造函数
      super(FeignClientsConfiguration.class, "feign", "feign.client.name");
   }
}

FeignContext创建的时候会将之前FeignClientSpecification通过setConfigurations设置给context上下文。

2.5、NamedContextFactory的createContext方法解析：

代码详见：org.springframework.cloud.context.named.NamedContextFactory#createContext方法。

FeignContext的父类的createContext方法会将创建AnnotationConfigApplicationContext实例，这实例将作为当前上下文的子上下文，用于关联feign组件的不同实例。

protected AnnotationConfigApplicationContext createContext(String name) {
    AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
    //TODO 获取name所对应的configuration,如果有就注册到子context中
    if (this.configurations.containsKey(name)) {
        for (Class configuration : this.configurations.get(name).getConfiguration()) {
            context.register(configuration);
        }
    }
    //TODO 注册default的Configuration,也就是 FeignClientsRegistrar类中registerDefaultConfiguration方法中注册的Configuration
    for (Map.Entry entry : this.configurations.entrySet()) {
        if (entry.getKey().startsWith("default.")) {
            for (Class configuration : entry.getValue().getConfiguration()) {
                context.register(configuration);
            }
        }
    }
    //TODO 注册PropertyPlaceholderAutoConfiguration
    context.register(PropertyPlaceholderAutoConfiguration.class,this.defaultConfigType);
    //TODO 设置Environment的propertySources属性源
    context.getEnvironment().getPropertySources().addFirst(new MapPropertySource(this.propertySourceName,
            Collections. singletonMap(this.propertyName, name)));
    if (this.parent != null) { // Uses Environment from parent as well as beans
        context.setParent(this.parent);
    }
    context.setDisplayName(generateDisplayName(name));
    context.refresh();
    return context;
}

由于NamedContextFactory实现了DisposableBean，所以当实例消亡的时候会调用

@Override
public void destroy() {
   Collection values = this.contexts.values();
   for (AnnotationConfigApplicationContext context : values) {
      context.close();
   }
   this.contexts.clear();
}

2.6、总结一下：

NamedContextFactory会创建出AnnotationConfigApplicationContext实例，并以name作为唯一标识，然后每个AnnotationConfigApplicationContext实例都会注册部分配置类，从而可以给出一系列的基于配置类生成的组件实例，这样就可以基于name来管理一系列的组件实例，为不同的FeignClient准备不同配置组件实例。

3、核心方法registerFeignClients()分析

3.1、registerFeignClients源码分析

FeignClientsRegistrar做的第二件事就是扫描指定包下的类文件，注册@FeignClient修饰的接口类信息。

org.springframework.cloud.openfeign.FeignClientsRegistrar.registerFeignClients(metadata, registry)源码：

public void registerFeignClients(AnnotationMetadata metadata, BeanDefinitionRegistry registry) {
    //TODO 生成自定义的ClassPathScanningCandidateComponentProvider
    ClassPathScanningCandidateComponentProvider scanner = getScanner();
    scanner.setResourceLoader(this.resourceLoader);
    Set basePackages;
    //TODO 获取EnableFeignClients所有属性的键值对
    Map attrs = metadata.getAnnotationAttributes(EnableFeignClients.class.getName());
    //TODO 依照AnnotationTypeFilter 来进行过滤，只会扫描出EnableFeignClients修饰的类
    AnnotationTypeFilter annotationTypeFilter = new AnnotationTypeFilter(FeignClient.class);
    final Class[] clients = attrs == null ? null: (Class[]) attrs.get("clients");
    //TODO 如果没有配置clients属性，那么就要扫描basePackages
    if (clients == null || clients.length == 0) {
        scanner.addIncludeFilter(annotationTypeFilter);
        basePackages = getBasePackages(metadata);
    } else {
        final Set clientClasses = new HashSet<>();
        basePackages = new HashSet<>();
        //TODO 遍历上诉过程中获取basePackages 的列表
        for (String basePackage : basePackages) {
            //TODO 获取basePackage中所有的BeanDefinition
            Set candidateComponents = scanner.findCandidateComponents(basePackage);
            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");
                    //TODO 从这些BeanDefinition中获取FeignClient的属性值
                    Map attributes = annotationMetadata.getAnnotationAttributes(

FeignClient.class.getCanonicalName());
                    String name = getClientName(attributes);
                    //TODO 对单独的某个FeignClient的configuration进行配置
                    registerClientConfiguration(registry, name,attributes.get("configuration"));
                    //TODO 注册
                    registerFeignClient(registry, annotationMetadata, attributes);
                }
            }
        }
    }

接下来分析注册方法registerFeignClient()如下：

private void registerFeignClient(BeanDefinitionRegistry registry,
      AnnotationMetadata annotationMetadata, Map attributes) {
   String className = annotationMetadata.getClassName();
   BeanDefinitionBuilder definition = BeanDefinitionBuilder.genericBeanDefinition(FeignClientFactoryBean.class);
   validate(attributes);
   definition.addPropertyValue("url", getUrl(attributes));
   definition.addPropertyValue("path", getPath(attributes));
   String name = getName(attributes);
   definition.addPropertyValue("name", name);
   definition.addPropertyValue("type", className);
   definition.addPropertyValue("decode404", attributes.get("decode404"));
   definition.addPropertyValue("fallback", attributes.get("fallback"));
   definition.addPropertyValue("fallbackFactory", attributes.get("fallbackFactory"));
   definition.setAutowireMode(AbstractBeanDefinition.AUTOWIRE_BY_TYPE);
   String alias = name + "FeignClient";
   AbstractBeanDefinition beanDefinition = definition.getBeanDefinition();
   boolean primary = (Boolean)attributes.get("primary"); // has a default, won't be null
   beanDefinition.setPrimary(primary);
   String qualifier = getQualifier(attributes);
   if (StringUtils.hasText(qualifier)) {
      alias = qualifier;
   }
   BeanDefinitionHolder holder = new BeanDefinitionHolder(beanDefinition, className, new String[] { alias });
   BeanDefinitionReaderUtils.registerBeanDefinition(holder, registry);
}

总结：

FeignClientsRegistrar方法会依据@EnableFeignClients的属性获取要扫描的包路径信息，然后获取这些包下被@FeignClient注解修饰的接口的BeanDefinition。例如springcloud-micro-service-feign模块的IProductClientService接口实现：

@FeignClient(name = "SPRINGCLOUD-MICRO-PRODUCT", configuration = FeignClientConfig.class)
public interface IProductClientService {

3.2、实例化@FeignClient修饰的接口

FeignClientFactoryBean是工厂类，Spring容器通过调用它的getObject方法来获取对应的bean实例，被@FeignClient修饰的接口都是通过FeignClientFactoryBean的getObject方法来进行实例化的。

源码见org.springframework.cloud.openfeign.FeignClientFactoryBean#getObject方法：

@Override
public Object getObject() throws Exception {
   FeignContext context = applicationContext.getBean(FeignContext.class);
   Feign.Builder builder = feign(context);
   if (!StringUtils.hasText(this.url)) {
      String url;
      if (!this.name.startsWith("http")) {
         url = "http://" + this.name;
      } else {
         url = this.name;
      }
      url += cleanPath();
      return loadBalance(builder, context, new HardCodedTarget<>(this.type,this.name, url));
   }
   if (StringUtils.hasText(this.url) && !this.url.startsWith("http")) {
      this.url = "http://" + this.url;
   }
   String url = this.url + cleanPath();

   //调用FeignContext的getInstance方法获取Client对象
   Client client = getOptional(context, Client.class);
   if (client != null) {
      if (client instanceof LoadBalancerFeignClient) {
         client = ((LoadBalancerFeignClient)client).getDelegate();
      }
      builder.client(client);
   }
   Targeter targeter = get(context, Targeter.class);
   return targeter.target(this, builder, context, new HardCodedTarget<>(this.type, this.name, url));
}

3.3、调用FeignContext的getInstance方法获取Client对象

protected <T> T getOptional(FeignContext context, Class<T> type) {
   return context.getInstance(this.name, type);
}

public <T> T getInstance(String name, Class<T> type) {
   AnnotationConfigApplicationContext context = getContext(name);
   if (BeanFactoryUtils.beanNamesForTypeIncludingAncestors(context,type).length > 0) {
      return context.getBean(type);
   }
   return null;
}

3.4、DefaultTargeter的实现

 

第四章 Feign接口服务及源码解析笔记_第2张图片

Targeter是一个接口，它的target方法会生成对应实例对象，它有两个实现类，分表为DefaultTargeter和HystrixTargeter，fegign使用HystrixTargeter这一层抽象来封装关于Hystrix的实现，DefaultTargeter的实现如下所示，只是调用了Feign.Builder的target方法

class DefaultTargeter implements Targeter {
   @Override
   public <T> T target(FeignClientFactoryBean factory, Feign.Builder feign, FeignContext context,
                  Target.HardCodedTarget<T> target) {
      return feign.target(target);
   }
}

Feign.Builder负责生成被@FeignClient修饰的FeignClient接口类实例，它通过JAVA反射机制构建：

代码见：feign-core-9.5.1.jar!\feign\Feign.target方法：

public T target(Target target) {
    return this.build().newInstance(target);
}

public Feign build() {
    Factory synchronousMethodHandlerFactory = new Factory(this.client, this.retryer,

this.requestInterceptors, this.logger, this.logLevel, this.decode404);
    ParseHandlersByName handlersByName = new ParseHandlersByName(this.contract, this.options, this.encoder,

 this.decoder, this.errorDecoder, synchronousMethodHandlerFactory);
    return new ReflectiveFeign(handlersByName, this.invocationHandlerFactory);
}

3.5、实例化方法ReflectiveFeign

feign-core-9.5.1.jar!\feign\ReflectiveFeign.newInstance()方法分析：

这方法主要做两件事：

1）扫描FeignClient接口类的所有函数，生成对应的Handler

2）使用Proxy生成FeignClient的实例对象

public <T> T newInstance(Target<T> target) {
    //TODO arseHandlersByName.appy方法填充信息
    Map nameToHandler = targetToHandlersByName.apply(target);
    Map methodToHandler = new LinkedHashMap();
    List defaultMethodHandlers = new LinkedList();
    for (Method method : target.type().getMethods()) {
        if (method.getDeclaringClass() == Object.class) {
            continue;
        } else if(Util.isDefault(method)) {
            //TODO 为每一个默认方法生成一个DefaultMethodHandler
            DefaultMethodHandler handler = new DefaultMethodHandler(method);
            defaultMethodHandlers.add(handler);
            methodToHandler.put(method, handler);
        } else {
            methodToHandler.put(method, nameToHandler.get(Feign.configKey(target.type(), method)));
        }
    }
    //TODO 生成java  InvocationHandler 是个动态代理的类
    InvocationHandler handler = factory.create(target, methodToHandler);
    T proxy = (T) Proxy.newProxyInstance(target.type().getClassLoader(), new Class[]{target.type()}, handler);
    for(DefaultMethodHandler defaultMethodHandler : defaultMethodHandlers) {
        defaultMethodHandler.bindTo(proxy);
    }
    return proxy;
}

3.6、扫描FeignClient接口类的所有函数，生成对应的Handler

 在扫描FeignClient接口类所有函数生成对应的Handle过程中，feign会生成调用该函数时发送网络请求的模板，也就是RequestTemplate实例，RequestTemplate中包含了发送网络请求的URL和产生填充信息，@RequestMapping、@RequestVariable等注解信息也会包含到RequestTemplate中，这一具体过程就是ParseHandlersByName.apply()方法来实现的。

1）feign.ReflectiveFeign.ParseHandlersByName#apply方法分析：

public Map apply(Target key) {

//获取type中所有的方法信息，会根据注解生成每个方法的RequestTemplate
        List metadata = this.contract.parseAndValidatateMetadata(key.type());
        Map result = new LinkedHashMap();
        MethodMetadata md;
        Object buildTemplate;
        for(Iterator var4 = metadata.iterator(); var4.hasNext(); result.put(md.configKey(),

this.factory.create(key, md, (Factory)buildTemplate,

this.options, this.decoder, this.errorDecoder))) {
            md = (MethodMetadata)var4.next();
            if (!md.formParams().isEmpty() && md.template().bodyTemplate() == null) {
                buildTemplate = new ReflectiveFeign.BuildFormEncodedTemplateFromArgs(md, this.encoder);
            } else if (md.bodyIndex() != null) {
                buildTemplate = new ReflectiveFeign.BuildEncodedTemplateFromArgs(md, this.encoder);
            } else {
                buildTemplate = new ReflectiveFeign.BuildTemplateByResolvingArgs(md);
            }
        }
        return result;
    }
}

Contract的默认实现是org.springframework.cloud.openfeign.support.SpringMvcContract其基类为Contract.BaseContract。

 

第四章 Feign接口服务及源码解析笔记_第3张图片

public abstract static class BaseContract implements Contract {

2）parseAndValidateMetadata()方法代码解析

org.springframework.cloud.openfeign.support.SpringMvcContract.parseAndValidateMetadata()方法会与HTTP请求相关的所有函数的基本信息和注解信息

@Override
public MethodMetadata parseAndValidateMetadata(Class targetType, Method method) {
   this.processedMethods.put(Feign.configKey(targetType, method), method);

   //调用父类BaseContract的函数
   MethodMetadata md = super.parseAndValidateMetadata(targetType, method);
   RequestMapping classAnnotation = findMergedAnnotation(targetType, RequestMapping.class);

//处理RequestMapping注解
   if (classAnnotation != null) {
      if (!md.template().headers().containsKey(ACCEPT)) {
         parseProduces(md, method, classAnnotation);
      }
      if (!md.template().headers().containsKey(CONTENT_TYPE)) {
         parseConsumes(md, method, classAnnotation);
      }
      parseHeaders(md, method, classAnnotation);
   }
   return md;
}

3）feign.Contract.BaseContract#parseAndValidateMetadata 父类的parseAndValidateMetadata方法会依次解析接口类中的注解，方法中的注解，和各种参数注解，并将这些注解包含的信息封装到MethodMetadata 对象中，然后返回。

protected MethodMetadata parseAndValidateMetadata(Class targetType, Method method) {
    MethodMetadata data = new MethodMetadata();
    //TODO 函数的返回值
    data.returnType(Types.resolve(targetType, targetType, method.getGenericReturnType()));
    data.configKey(Feign.configKey(targetType, method));
    //TODO 获取并处理修饰class的注解信息
    if(targetType.getInterfaces().length == 1) {
        processAnnotationOnClass(data, targetType.getInterfaces()[0]);
    }
    //TODO 调用子类processAnnotationOnClass的实现
    processAnnotationOnClass(data, targetType);
    //TODO 处理修饰method的注解信息
    for (Annotation methodAnnotation : method.getAnnotations()) {
        processAnnotationOnMethod(data, methodAnnotation, method);
    }
    checkState(data.template().method() != null,
            "Method %s not annotated with HTTP method type (ex. GET, POST)",method.getName());
    //TODO 方法参数的类型
    Class[] parameterTypes = method.getParameterTypes();
    Type[] genericParameterTypes = method.getGenericParameterTypes();
    //TODO 方法参数的注解
    Annotation[][] parameterAnnotations = method.getParameterAnnotations();
    int count = parameterAnnotations.length;
    //TODO 依次处理各个函数参数的注解
    for (int i = 0; i < count; i++) {
        boolean isHttpAnnotation = false;
        if (parameterAnnotations[i] != null) {
            isHttpAnnotation = processAnnotationsOnParameter(data, parameterAnnotations[i], i);
        }
        if (parameterTypes[i] == URI.class) {
            data.urlIndex(i);
        } else if (!isHttpAnnotation) {
            checkState(data.formParams().isEmpty(), "Body parameters cannot be used with form parameters.");
            checkState(data.bodyIndex() == null, "Method has too many Body parameters: %s", method);
            data.bodyIndex(i);
            data.bodyType(Types.resolve(targetType, targetType, genericParameterTypes[i]));
        }
    }
    if (data.headerMapIndex() != null) {
        checkMapString("HeaderMap", parameterTypes[data.headerMapIndex()], genericParameterTypes[data.headerMapIndex()]);
    }
    if (data.queryMapIndex() != null) {
        checkMapString("QueryMap", parameterTypes[data.queryMapIndex()], genericParameterTypes[data.queryMapIndex()]);
    }
    return data;
}

3.7、使用Proxy生成FeignClient的实例对象

1）实例化方法分析feign.ReflectiveFeign#newInstance：

InvocationHandler handler = factory.create(target, methodToHandler);中另外一件事情是OpenFeign使用Proxy.newProxyInstance方法来创建FeignClient接口类的实例，然后将InvocationHandle绑定到接口实例上，用于处理接口类函数调用。

feign.InvocationHandlerFactory.Default()方法：

public interface InvocationHandlerFactory {
    InvocationHandler create(Target var1, Map var2);
    public static final class Default implements InvocationHandlerFactory {
        public Default() {
        }
        public InvocationHandler create(Target target, Map dispatch) {
            return new FeignInvocationHandler(target, dispatch);
        }
    }
    public interface MethodHandler {
        Object invoke(Object[] var1) throws Throwable;
    }
}

Default 实现了InvocationHandlerFactory 接口，create方法其实返回FeignInvocationHandler的实例。

2）ReflectiveFeign.FeignInvocationHandler.invoke()方法源码如下：

static class FeignInvocationHandler implements InvocationHandler {
    private final Target target;
    private final Map dispatch;
    FeignInvocationHandler(Target target, Map dispatch) {
        this.target = (Target)Util.checkNotNull(target, "target", new Object[0]);
        this.dispatch = (Map)Util.checkNotNull(dispatch, "dispatch for %s", new Object[]{target});
    }
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        if (!"equals".equals(method.getName())) {
            if ("hashCode".equals(method.getName())) {
                return this.hashCode();
            } else {
                return "toString".equals(method.getName()) ? this.toString() :

((MethodHandler)this.dispatch.get(method)).invoke(args);
            }
        } else {
            try {
            Object otherHandler = args.length > 0 && args[0] != null ? Proxy.getInvocationHandler(args[0]) : null;
                return this.equals(otherHandler);
            } catch (IllegalArgumentException var5) {
                return false;
            }
        }
    }

注意：((MethodHandler)this.dispatch.get(method)).invoke(args)，Invoke方法会根据函数名称来调用不同的MethodHandle实例invoke方法。

3.8、网络请求

接下来就直接使用FeignClient接口类的实例，调用它的函数来发送网络请求，发送网络请求可以分为3个阶段：

1）是将函数实际参数添加到RequestTemplate中

2）调用Target生成具体的Request对象

3）调用Client来发送网络请求，将Response转化为对象返回

首先分析feign.SynchronousMethodHandler#invoke()方法：

public Object invoke(Object[] argv) throws Throwable {

//根据函数参数创建RequestTemplate
    RequestTemplate template = this.buildTemplateFromArgs.create(argv);
    Retryer retryer = this.retryer.clone();
    while(true) {
        try {
            return this.executeAndDecode(template);
        } catch (RetryableException var5) {
            retryer.continueOrPropagate(var5);
            if (this.logLevel != Level.NONE) {
                this.logger.logRetry(this.metadata.configKey(), this.logLevel);
            }
        }
    }
}

3.9、根据函数参数创建RequestTemplate.create()

@Override
public RequestTemplate create(Object[] argv) {
    RequestTemplate mutable = new RequestTemplate(metadata.template());
    //TODO 设置url
    if (metadata.urlIndex() != null) {
        int urlIndex = metadata.urlIndex();
        checkArgument(argv[urlIndex] != null, "URI parameter %s was null", urlIndex);
        mutable.insert(0, String.valueOf(argv[urlIndex]));
    }
    Map varBuilder = new LinkedHashMap();
    //TODO 遍历MethodMetadata中关于参数的所以以及对应名称的配置信息
    for (Entry> entry : metadata.indexToName().entrySet()) {
        int i = entry.getKey();
        //TODO entry.getKey就是参数的索引
        Object value = argv[entry.getKey()];
        if (value != null) { // Null values are skipped.
            //TODO indexToExpander保存着将各种类型参数的值转化为String类型的Expander转换器
            if (indexToExpander.containsKey(i)) {
                //TODO 将Value值为String
                value = expandElements(indexToExpander.get(i), value);
            }
            for (String name : entry.getValue()) {
                varBuilder.put(name, value);
            }
        }
    }
    RequestTemplate template = resolve(argv, mutable, varBuilder);
    //TODO 设置queryMap参数
    if (metadata.queryMapIndex() != null) {
        template = addQueryMapQueryParameters((Map) argv[metadata.queryMapIndex()], template);
    }
    //TODO 设置headersMap参数
    if (metadata.headerMapIndex() != null) {
        template = addHeaderMapHeaders((Map) argv[metadata.headerMapIndex()], template);
    }
    return template;
}

3.10、feign.RequestTemplate#resolve()方法代码：

protected RequestTemplate resolve(Object[] argv, RequestTemplate mutable, Map variables) {
        Map variableToEncoded = new LinkedHashMap();
        Iterator var5 = this.metadata.indexToEncoded().entrySet().iterator();

        while(var5.hasNext()) {
            Entry entry = (Entry)var5.next();
            Collection names = (Collection)this.metadata.indexToName().get(entry.getKey());
            Iterator var8 = names.iterator();

            while(var8.hasNext()) {
                String name = (String)var8.next();
                variableToEncoded.put(name, entry.getValue());
            }
        }

        return mutable.resolve(variables, variableToEncoded);
    }
}

回调到feign-core-9.5.1.jar!\feign\RequestTemplate.resolve()方法：

RequestTemplate resolve(Map unencoded, Map alreadyEncoded) {

//替换query数值，将{queryVariable} 替换成实际的值
    this.replaceQueryValues(unencoded, alreadyEncoded);
    Map encoded = new LinkedHashMap();
    Iterator var4 = unencoded.entrySet().iterator();
    while(var4.hasNext()) {

//把所有参数进行编码
        Entry entry = (Entry)var4.next();
        String key = (String)entry.getKey();
        Object objectValue = entry.getValue();
        String encodedValue = this.encodeValueIfNotEncoded(key, objectValue, alreadyEncoded);
        encoded.put(key, encodedValue);
    }
    String resolvedUrl = expand(this.url.toString(), encoded).replace("+", "%20");
    if (this.decodeSlash) {
        resolvedUrl = resolvedUrl.replace("%2F", "/");
    }
    this.url = new StringBuilder(resolvedUrl);

//把头部信息进行传串行化
    Map> resolvedHeaders = new LinkedHashMap();
    Iterator var14 = this.headers.keySet().iterator();
    while(var14.hasNext()) {
        String field = (String)var14.next();
        Collection resolvedValues = new ArrayList();
        Iterator var9 = Util.valuesOrEmpty(this.headers, field).iterator();
        while(var9.hasNext()) {
            String value = (String)var9.next();
            String resolved = expand(value, unencoded);
            resolvedValues.add(resolved);
        }
        resolvedHeaders.put(field, resolvedValues);
    }
    this.headers.clear();
    this.headers.putAll(resolvedHeaders);
    if (this.bodyTemplate != null) {

//处理body信息
        this.body(urlDecode(expand(this.bodyTemplate, encoded)));
    }
    return this;
}

feign.SynchronousMethodHandler#invoke方法中的executeAndDecode()方法会根据RequestTemplate生成Request对象，然后交给Client实例发送网络请求，最后返回对应的函数返回类型的实例。

这里的client为org.springframework.cloud.openfeign.ribbon.LoadBalancerFeignClient

3.11、executeAndDecode()源码分析

源码位置：feign.SynchronousMethodHandler.executeAndDecode()

Object executeAndDecode(RequestTemplate template) throws Throwable {
    //TODO 根据RequestTemplate生成Request
    Request request = targetRequest(template);
    if (logLevel != Logger.Level.NONE) {
        logger.logRequest(metadata.configKey(), logLevel, request);
    }
    Response response;
    long start = System.nanoTime();
    try {
        //TODO client发送网络请求
        response = client.execute(request, options);
        //TODO  ensure the request is set. TODO: remove in Feign 10
        response.toBuilder().request(request).build();
    } catch (IOException e) {
        if (logLevel != Logger.Level.NONE) {
            logger.logIOException(metadata.configKey(), logLevel, e, elapsedTime(start));
        }
        throw errorExecuting(request, e);
    }
    long elapsedTime = TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - start);
    boolean shouldClose = true;
    try {
        if (logLevel != Logger.Level.NONE) {
            response =logger.logAndRebufferResponse(metadata.configKey(), logLevel, response, elapsedTime);
            // ensure the request is set. TODO: remove in Feign 10
            response.toBuilder().request(request).build();
        }
        //TODO 如果是response返回类型就可以直接返回
        if (Response.class == metadata.returnType()) {
            if (response.body() == null) {
                return response;
            }
            //TODO 设置body
            if (response.body().length() == null || response.body().length() > MAX_RESPONSE_BUFFER_SIZE) {
                shouldClose = false;
                return response;
            }
            // Ensure the response body is disconnected
            byte[] bodyData = Util.toByteArray(response.body().asInputStream());
            return response.toBuilder().body(bodyData).build();
        }
        if (response.status() >= 200 && response.status() < 300) {
            if (void.class == metadata.returnType()) {
                return null;
            } else {
                return decode(response);
            }
        } else if (decode404 && response.status() == 404 && void.class != metadata.returnType()) {
            return decode(response);
        } else {
            throw errorDecoder.decode(metadata.configKey(), response);
        }
    } catch (IOException e) {
        if (logLevel != Logger.Level.NONE) {
            logger.logIOException(metadata.configKey(), logLevel, e, elapsedTime);
        }
        throw errorReading(request, response, e);
    } finally {
        if (shouldClose) {
            ensureClosed(response.body());
        }
    }
}

你可能感兴趣的:(SpringCloud框架解读,spring)

  • Linux下QT开发的动态库界面弹出操作（SDL2） 13jjyao QT类qt开发语言sdl2linux
    需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
  • 利用LangChain的StackExchange组件实现智能问答系统 nseejrukjhad langchainmicrosoft数据库python
    利用LangChain的StackExchange组件实现智能问答系统引言在当今的软件开发世界中，StackOverflow已经成为程序员解决问题的首选平台之一。而LangChain作为一个强大的AI应用开发框架，提供了StackExchange组件，使我们能够轻松地将StackOverflow的海量知识库集成到我们的应用中。本文将详细介绍如何使用LangChain的StackExchange组件
  • 读书||陶新华《教育中的积极心理学》1—28 流水淙淙2022
    读一本好书，尤如和一位高尚者对话，亦能对人的精神进行洗礼。但是若不能和实践结合起来，也只能落到空读书的状态。读书摘要与感想1、塞利格曼在《持续的幸福》一书中提出了幸福2.0理论，提出幸福由5个元素决定——积极情绪、投入的工作和生活、目标和意义、和谐的人际关系、成就感。2、人的大脑皮层在进行智力活动时，都伴有皮下中枢活动，对这些活动进行体验请假，并由此产生了情感解读。人的情绪情感体验总是优先于大脑的
  • node.js学习 小猿L node.jsnode.js学习vim
    node.js学习实操及笔记温故node.js，node.js学习实操过程及笔记~node.js学习视频node.js官网node.js中文网实操笔记githubcsdn笔记为什么学node.js可以让别人访问我们编写的网页为后续的框架学习打下基础，三大框架vuereactangular离不开node.jsnode.js是什么官网：node.js是一个开源的、跨平台的运行JavaScript的运行
  • 自我意识 徐立华
    ----读帕克.帕尔默《教学勇气》（P18----19）5.铸造我们的学科帕克.帕尔默说学科知识对我们的自身认同和外部世界有启发意义。学科会铸造我们。“在我们与学科的命题概念和学科的生活框架相遇之前，自我意识知识处于潜伏状态，通过回想学科是怎样唤醒自我意识，我们就可以找回教学心灵。”《教学勇气》（P18）我们的自我意识像冰山表面下无限延伸的冰层，常常处于潜伏状态。但是在我们对所教授的学科进行深入思
  • 基于CODESYS的多轴运动控制程序框架：逻辑与运动控制分离，快速开发灵活操作 GPJnCrbBdl python开发语言
    基于codesys开发的多轴运动控制程序框架，将逻辑与运动控制分离，将单轴控制封装成功能块，对该功能块的操作包含了所有的单轴控制（归零、点动、相对定位、绝对定位、设置当前位置、伺服模式切换等等）。程序框架由主程序按照状态调用分归零模式、手动模式、自动模式、故障模式，程序状态的跳转都已完成，只需要根据不同的工艺要求完成所需的动作即可。变量的声明、地址的规划都严格按照C++的标准定义，能帮助开发者快速
  • SpringBlade dict-biz/list 接口 SQL 注入漏洞 文章永久免费只为良心 oracle数据库
    SpringBladedict-biz/list接口SQL注入漏洞POC:构造请求包查看返回包你的网址/api/blade-system/dict-biz/list?updatexml(1,concat(0x7e,md5(1),0x7e),1)=1漏洞概述在SpringBlade框架中，如果dict-biz/list接口的后台处理逻辑没有正确地对用户输入进行过滤或参数化查询（PreparedSta
  • insert into select 主键自增_mybatis拦截器实现主键自动生成 weixin_39521651 insertintoselect主键自增mybatisdelete返回值mybatisinsert返回主键mybatisinsert返回对象mybatisplusinsert返回主键mybatisplus插入生成id
    前言前阵子和朋友聊天，他说他们项目有个需求，要实现主键自动生成，不想每次新增的时候，都手动设置主键。于是我就问他，那你们数据库表设置主键自动递增不就得了。他的回答是他们项目目前的id都是采用雪花算法来生成，因此为了项目稳定性，不会切换id的生成方式。朋友问我有没有什么实现思路，他们公司的orm框架是mybatis，我就建议他说，不然让你老大把mybatis切换成mybatis-plus。mybat
  • spring如何整合druid连接池？ 惜.己 springspringjunit数据库javaidea后端xml
    目录spring整合druid连接池1.新建maven项目2.新建mavenModule3.导入相关依赖4.配置log4j2.xml5.配置druid.xml1)xml中如何引入properties2)下面是配置文件6.准备jdbc.propertiesJDBC配置项解释7.配置druid8.测试spring整合druid连接池1.新建maven项目打开IDE（比如IntelliJIDEA,Ecl
  • ArrayList 源码解析 程序猿进阶 Java基础ArrayListListjava面试性能优化架构设计idea
    ArrayList是Java集合框架中的一个动态数组实现，提供了可变大小的数组功能。它继承自AbstractList并实现了List接口，是顺序容器，即元素存放的数据与放进去的顺序相同，允许放入null元素，底层通过数组实现。除该类未实现同步外，其余跟Vector大致相同。每个ArrayList都有一个容量capacity，表示底层数组的实际大小，容器内存储元素的个数不能多于当前容量。当向容器中添
  • Java爬虫框架（一）--架构设计 狼图腾-狼之传说 java框架java任务html解析器存储电子商务
    一、架构图那里搜网络爬虫框架主要针对电子商务网站进行数据爬取，分析，存储，索引。爬虫：爬虫负责爬取，解析，处理电子商务网站的网页的内容数据库：存储商品信息索引：商品的全文搜索索引Task队列：需要爬取的网页列表Visited表：已经爬取过的网页列表爬虫监控平台：web平台可以启动，停止爬虫，管理爬虫，task队列，visited表。二、爬虫1.流程1)Scheduler启动爬虫器，TaskMast
  • Java：爬虫框架 dingcho Javajava爬虫
    一、ApacheNutch2【参考地址】Nutch是一个开源Java实现的搜索引擎。它提供了我们运行自己的搜索引擎所需的全部工具。包括全文搜索和Web爬虫。Nutch致力于让每个人能很容易,同时花费很少就可以配置世界一流的Web搜索引擎.为了完成这一宏伟的目标,Nutch必须能够做到:每个月取几十亿网页为这些网页维护一个索引对索引文件进行每秒上千次的搜索提供高质量的搜索结果简单来说Nutch支持分
  • SpringCloudAlibaba—Sentinel(限流) 菜鸟爪哇
    前言：自己在学习过程的记录，借鉴别人文章，记录自己实现的步骤。借鉴文章：https://blog.csdn.net/u014494148/article/details/105484410Sentinel介绍Sentinel诞生于阿里巴巴，其主要目标是流量控制和服务熔断。Sentinel是通过限制并发线程的数量（即信号隔离）来减少不稳定资源的影响，而不是使用线程池，省去了线程切换的性能开销。当资源
  • springboot+vue项目实战一-创建SpringBoot简单项目 苹果酱0567 面试题汇总与解析springboot后端java中间件开发语言
    这段时间抽空给女朋友搭建一个个人博客，想着记录一下建站的过程，就当做笔记吧。虽然复制zjblog只要一个小时就可以搞定一个网站，或者用cms系统，三四个小时就可以做出一个前后台都有的网站，而且想做成啥样也都行。但是就是要从新做，自己做的意义不一样，更何况，俺就是专门干这个的，嘿嘿嘿要做一个网站，而且从零开始，首先呢就是技术选型了，经过一番思量决定选择-SpringBoot做后端，前端使用Vue做一
  • Spring MVC 全面指南：从入门到精通的详细解析 一杯梅子酱 技术栈学习springmvcjava
    引言：SpringMVC，作为Spring框架的一个重要模块，为构建Web应用提供了强大的功能和灵活性。无论是初学者还是有一定经验的开发者，掌握SpringMVC都将显著提升你的Web开发技能。本文旨在为初学者提供一个全面且易于理解的学习路径，通过详细的知识点分析和实际案例，帮助你快速上手SpringMVC，让学习过程既深刻又高效。一、SpringMVC简介1.1什么是SpringMVC？Spri
  • Spring Boot中实现跨域请求 BABA8891 springboot后端java
    在SpringBoot中实现跨域请求（CORS，Cross-OriginResourceSharing）可以通过多种方式，以下是几种常见的方法：1.使用@CrossOrigin注解在SpringBoot中，你可以在控制器或者具体的请求处理方法上使用@CrossOrigin注解来允许跨域请求。在控制器上应用：importorg.springframework.web.bind.annotation.
  • WebMagic：强大的Java爬虫框架解析与实战 Aaron_945 Javajava爬虫开发语言
    文章目录引言官网链接WebMagic原理概述基础使用1.添加依赖2.编写PageProcessor高级使用1.自定义Pipeline2.分布式抓取优点结论引言在大数据时代，网络爬虫作为数据收集的重要工具，扮演着不可或缺的角色。Java作为一门广泛使用的编程语言，在爬虫开发领域也有其独特的优势。WebMagic是一个开源的Java爬虫框架，它提供了简单灵活的API，支持多线程、分布式抓取，以及丰富的
  • 博客网站制作教程 2401_85194651 javamaven
    首先就是技术框架：后端：Java+SpringBoot数据库：MySQL前端：Vue.js数据库连接：JPA(JavaPersistenceAPI)1.项目结构blog-app/├──backend/│├──src/main/java/com/example/blogapp/││├──BlogApplication.java││├──config/│││└──DatabaseConfig.java
  • 00. 这里整理了最全的爬虫框架（Java + Python） 有一只柴犬 爬虫系列爬虫javapython
    目录1、前言2、什么是网络爬虫3、常见的爬虫框架3.1、java框架3.1.1、WebMagic3.1.2、Jsoup3.1.3、HttpClient3.1.4、Crawler4j3.1.5、HtmlUnit3.1.6、Selenium3.2、Python框架3.2.1、Scrapy3.2.2、BeautifulSoup+Requests3.2.3、Selenium3.2.4、PyQuery3.2
  • 樊登读书人是如何学习的？ 恒如止水
    2021年11月10号早晨听书。这本书听完樊登老师的解读后，我觉得有必要自己好好的复盘写下来，真正想写的时候才发现我记住的没多少，那就按照叶武斌老师的说法，烂开始好结果，能记下多少复述多少，写下自己的感悟。人是如何学习的呢？第一点蝌蚪和鱼的故事，当蝌蚪变成青蛙后，告诉于外边的人是什么样的？牛是长什么样的？而与认为就是鱼身子，然后下面长了两条角，这样的样子是人。鱼的身体形状，它的鳍变成了4条腿，这样
  • 今天是总结 薛帅
    今天来个最后一天的总结。为什么要学习写作技巧呢？就如同建房子，如果想要住的安全、舒服，我们要先打地基，建房子的框架，这样才能随意的装修。那么我们要怎么建好才能建好写作的地基呢？1走直路，少弯路01利他：能够给别人带来价值。02吸引：吸住读者的眼球。03打动：打动人心，引起共鸣。04说服：用数据说话。05刻意：通过有意识的训练。06修改：好的文章至上修改10遍。07模仿：10万+的文章必有成功的道理
  • Python 课程10-单元测试 可愛小吉 Python教學python单元测试开发语言TDDunittest
    前言在现代软件开发中，单元测试已成为一种必不可少的实践。通过测试，我们可以确保每个功能模块在开发和修改过程中按预期工作，从而减少软件缺陷，提高代码质量。而测试驱动开发（TDD）则进一步将测试作为开发的核心部分，先编写测试，再编写代码，以测试为指导开发出更稳定、更可靠的代码。Python提供了强大的unittest模块，它是Python标准库的一部分，专门用于编写和执行单元测试。与其他测试框架相比，
  • RabbitMQ生产者重复机制与确认机制 java炒饭小能手 java-rabbitmqrabbitmqjava
    重复机制生产者发送消息时，出现了网络故障，导致与MQ的连接中断。为了解决这个问题，SpringAMQP提供的消息发送时的重试机制。即：当RabbitTemplate与MQ连接超时后，多次重试。需要修该发送端模块的application.yaml文件，添加下面的内容：spring:rabbitmq:connection-timeout:1s#设置MQ的连接超时时间template:retry:ena
  • MyBatis 详解 阿贾克斯的黎明 javamybatis
    目录目录一、MyBatis是什么二、为什么使用MyBatis（一）灵活性高（二）性能优化（三）易于维护三、怎么用MyBatis（一）添加依赖（二）配置MyBatis（三）创建实体类和接口（四）使用MyBatis一、MyBatis是什么MyBatis是一个优秀的持久层框架，它支持自定义SQL、存储过程以及高级映射。MyBatis免除了几乎所有的JDBC代码以及设置参数和获取结果集的工作。它可以通过简
  • 【自动化测试】UI自动化的分类、如何选择合适的自动化测试工具以及其中appium的设计理念、引擎和引擎如何工作 Lossya ui自动化测试工具自动化测试appium
    引言UI自动化测试主要针对软件的用户界面进行测试，以确保用户界面元素的交互和功能符合预期文章目录引言一、UI自动化的分类1.1基于代码的自动化测试1.2基于录制/回放的自动化测试1.3基于框架的自动化测试1.4按测试对象分类1.5按测试层次分类1.6按测试执行方式分类1.7按测试目的分类二、如何选择合适的自动化测试工具2.1项目需求分析2.2工具特性评估2.3成本考虑2.4团队技能2.5试用和评估
  • python爬取微信小程序数据,python爬取小程序数据 2301_81900439 前端
    大家好，小编来为大家解答以下问题，python爬取微信小程序数据，python爬取小程序数据，现在让我们一起来看看吧！Python爬虫系列之微信小程序实战基于Scrapy爬虫框架实现对微信小程序数据的爬取首先，你得需要安装抓包工具，这里推荐使用Charles，至于怎么使用后期有时间我会出一个事例最重要的步骤之一就是分析接口，理清楚每一个接口功能，然后连接起来形成接口串思路,再通过Spider的回调
  • 字节二面 Redstone Monstrosity 前端面试
    1.假设你是正在面试前端开发工程师的候选人，面试官让你详细说出你上一段实习过程的收获和感悟。在上一段实习过程中，我获得了宝贵的实践经验和深刻的行业洞察，以下是我的主要收获和感悟：一、专业技能提升框架应用熟练度：通过实际项目，我深入掌握了React、Vue等前端框架的使用，不仅提升了编码效率，还学会了如何根据项目需求选择合适的框架。问题解决能力：在实习期间，我遇到了许多预料之外的技术难题。通过查阅文
  • 【Golang】实现 Excel 文件下载功能 RumIV Golanggolangexcel开发语言
    在当今的网络应用开发中，提供数据导出功能是一项常见的需求。Excel作为一种广泛使用的电子表格格式，通常是数据导出的首选格式之一。在本教程中，我们将学习如何使用Go语言和GinWeb框架来创建一个Excel文件，并允许用户通过HTTP请求下载该文件。准备工作在开始之前，请确保您的开发环境中已经安装了Go语言和相关的开发工具。此外，您还需要安装GinWeb框架和excelize包，这两个包都将用于我
  • golang 实现文件上传下载 wangwei830 go
    Gin框架上传下载上传（支持批量上传）httpRouter.POST("/upload",func(ctx*gin.Context){forms,err:=ctx.MultipartForm()iferr!=nil{fmt.Println("error",err)}files:=forms.File["fileName"]for_,v:=rangefiles{iferr:=ctx.SaveUplo
  • 探索ASPICE V3.1：汽车行业软件开发的中文指南 阮懿同
    探索ASPICEV3.1：汽车行业软件开发的中文指南ASPICE_V3.1中文版.pdf.zip项目地址:https://gitcode.com/open-source-toolkit/422a2在汽车软件工程领域，高质量的标准对于确保行车安全和提升用户体验至关重要。今天，我们为您介绍一个珍贵的开源宝藏——ASPICEV3.1中文版资源。这是一篇专为国内汽车行业开发者、质量管理者准备的深度解读，旨
  • java责任链模式 3213213333332132 java责任链模式村民告县长
    责任链模式，通常就是一个请求从最低级开始往上层层的请求，当在某一层满足条件时，请求将被处理，当请求到最高层仍未满足时，则请求不会被处理。 就是一个请求在这个链条的责任范围内，会被相应的处理，如果超出链条的责任范围外，请求不会被相应的处理。 下面代码模拟这样的效果： 创建一个政府抽象类,方便所有的具体政府部门继承它。 package 责任链模式; /** *
  • linux、mysql、nginx、tomcat 性能参数优化 ronin47
    一、linux 系统内核参数 /etc/sysctl.conf文件常用参数 net.core.netdev_max_backlog = 32768 #允许送到队列的数据包的最大数目 net.core.rmem_max = 8388608 #SOCKET读缓存区大小 net.core.wmem_max = 8388608 #SOCKET写缓存区大
  • php命令行界面 dcj3sjt126com PHPcli
    常用选项 php -v php -i PHP安装的有关信息 php -h 访问帮助文件 php -m 列出编译到当前PHP安装的所有模块 执行一段代码 php -r 'echo "hello, world!";' php -r 'echo "Hello, World!\n";' php -r '$ts = filemtime("
  • Filter&Session 171815164 session
    Filter HttpServletRequest requ = (HttpServletRequest) req; HttpSession session = requ.getSession(); if (session.getAttribute("admin") == null) { PrintWriter out = res.ge
  • 连接池与Spring,Hibernate结合 g21121 Hibernate
            前几篇关于Java连接池的介绍都是基于Java应用的，而我们常用的场景是与Spring和ORM框架结合，下面就利用实例学习一下这方面的配置。         1.下载相关内容：     &nb
  • [简单]mybatis判断数字类型 53873039oycg mybatis
           昨天同事反馈mybatis保存不了int类型的属性,一直报错，错误信息如下:       Caused by: java.lang.NumberFormatException: For input string: "null" at sun.mis
  • 项目启动时或者启动后ava.lang.OutOfMemoryError: PermGen space 程序员是怎么炼成的 eclipsejvmtomcatcatalina.sheclipse.ini
       在启动比较大的项目时，因为存在大量的jsp页面，所以在编译的时候会生成很多的.class文件，.class文件是都会被加载到jvm的方法区中，如果要加载的class文件很多，就会出现方法区溢出异常 java.lang.OutOfMemoryError: PermGen space.     解决办法是点击eclipse里的tomcat，在
  • 我的crm小结 aijuans crm
    各种原因吧，crm今天才完了。主要是接触了几个新技术： Struts2、poi、ibatis这几个都是以前的项目中用过的。 Jsf、tapestry是这次新接触的，都是界面层的框架，用起来也不难。思路和struts不太一样，传说比较简单方便。不过个人感觉还是struts用着顺手啊，当然springmvc也很顺手，不知道是因为习惯还是什么。jsf和tapestry应用的时候需要知道他们的标签、主
  • spring里配置使用hibernate的二级缓存几步 antonyup_2006 javaspringHibernatexmlcache
    ．在spring的配置文件中 applicationContent.xml，hibernate部分加入 xml 代码 <prop key="hibernate.cache.provider_class">org.hibernate.cache.EhCacheProvider</prop> <prop key="hi
  • JAVA基础面试题 百合不是茶 抽象实现接口String类接口继承抽象类继承实体类自定义异常
    /*   * 栈（stack）：主要保存基本类型（或者叫内置类型）（char、byte、short、   *int、long、 float、double、boolean）和对象的引用，数据可以共享，速度仅次于   * 寄存器（register），快于堆。堆（heap）：用于存储对象。   */  &
  • 让sqlmap文件 "继承" 起来 bijian1013 javaibatissqlmap
            多个项目中使用ibatis , 和数据库表对应的 sqlmap文件（增删改查等基本语句)，dao, pojo 都是由工具自动生成的, 现在将这些自动生成的文件放在一个单独的工程中，其它项目工程中通过jar包来引用 ，并通过"继承"为基础的sqlmap文件，dao,pojo 添加新的方法来满足项
  • 精通Oracle10编程SQL(13)开发触发器 bijian1013 oracle数据库plsql
    /* *开发触发器 */ --得到日期是周几 select to_char(sysdate+4,'DY','nls_date_language=AMERICAN') from dual; select to_char(sysdate,'DY','nls_date_language=AMERICAN') from dual; --建立BEFORE语句触发器 CREATE O
  • 【EhCache三】EhCache查询 bit1129 ehcache
    本文介绍EhCache查询缓存中数据，EhCache提供了类似Hibernate的查询API，可以按照给定的条件进行查询。   要对EhCache进行查询，需要在ehcache.xml中设定要查询的属性   数据准备 @Before public void setUp() { //加载EhCache配置文件 Inpu
  • CXF框架入门实例 白糖_ springWeb框架webserviceservlet
    CXF是apache旗下的开源框架，由Celtix + XFire这两门经典的框架合成，是一套非常流行的web service框架。 它提供了JAX-WS的全面支持，并且可以根据实际项目的需要，采用代码优先（Code First）或者 WSDL 优先（WSDL First）来轻松地实现 Web Services 的发布和使用，同时它能与spring进行完美结合。 在apache cxf官网提供
  • angular.equals boyitech AngularJSAngularJS APIAnguarJS 中文APIangular.equals
    angular.equals   描述: 比较两个值或者两个对象是不是 相等。还支持值的类型，正则表达式和数组的比较。   两个值或对象被认为是 相等的前提条件是以下的情况至少能满足一项： 两个值或者对象能通过=== （恒等） 的比较 两个值或者对象是同样类型，并且他们的属性都能通过angular
  • java-腾讯暑期实习生-输入一个数组A[1,2,...n]，求输入B，使得数组B中的第i个数字B[i]=A[0]*A[1]*...*A[i-1]*A[i+1] bylijinnan java
    这道题的具体思路请参看 何海涛的微博：http://weibo.com/zhedahht import java.math.BigInteger; import java.util.Arrays; public class CreateBFromATencent { /** * 题目：输入一个数组A[1,2,...n]，求输入B，使得数组B中的第i个数字B[i]=A
  • FastDFS 的安装和配置 修订版 Chen.H linuxfastDFS分布式文件系统
    FastDFS Home:http://code.google.com/p/fastdfs/ 1. 安装 http://code.google.com/p/fastdfs/wiki/Setup http://hi.baidu.com/leolance/blog/item/3c273327978ae55f93580703.html 安装libevent (对libevent的版本要求为1.4.
  • [强人工智能]拓扑扫描与自适应构造器 comsci 人工智能
          当我们面对一个有限拓扑网络的时候,在对已知的拓扑结构进行分析之后,发现在连通点之后,还存在若干个子网络,且这些网络的结构是未知的,数据库中并未存在这些网络的拓扑结构数据....这个时候,我们该怎么办呢?       那么,现在我们必须设计新的模块和代码包来处理上面的问题
  • oracle merge into的用法 daizj oraclesqlmerget into
    Oracle中merge into的使用 http://blog.csdn.net/yuzhic/article/details/1896878 http://blog.csdn.net/macle2010/article/details/5980965 该命令使用一条语句从一个或者多个数据源中完成对表的更新和插入数据. ORACLE 9i 中，使用此命令必须同时指定UPDATE 和INSE
  • 不适合使用Hadoop的场景 datamachine hadoop
    转自：http://dev.yesky.com/296/35381296.shtml。 　　Hadoop通常被认定是能够帮助你解决所有问题的唯一方案。 当人们提到“大数据”或是“数据分析”等相关问题的时候，会听到脱口而出的回答：Hadoop!  实际上Hadoop被设计和建造出来，是用来解决一系列特定问题的。对某些问题来说，Hadoop至多算是一个不好的选择，对另一些问题来说，选择Ha
  • YII findAll的用法 dcj3sjt126com yii
    看文档比较糊涂，其实挺简单的： $predictions=Prediction::model()->findAll("uid=:uid",array(":uid"=>10));   第一个参数是选择条件：”uid=10″。其中:uid是一个占位符，在后面的array(“:uid”=>10)对齐进行了赋值； 更完善的查询需要
  • vim 常用 NERDTree 快捷键 dcj3sjt126com vim
    下面给大家整理了一些vim NERDTree的常用快捷键了，这里几乎包括了所有的快捷键了，希望文章对各位会带来帮助。 切换工作台和目录 ctrl + w + h 光标 focus 左侧树形目录ctrl + w + l 光标 focus 右侧文件显示窗口ctrl + w + w 光标自动在左右侧窗口切换ctrl + w + r 移动当前窗口的布局位置 o 在已有窗口中打开文件、目录或书签，并跳
  • Java把目录下的文件打印出来 蕃薯耀 列出目录下的文件文件夹下面的文件目录下的文件
    Java把目录下的文件打印出来 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 蕃薯耀 2015年7月11日 11:02:
  • linux远程桌面----VNCServer与rdesktop hanqunfeng Desktop
    windows远程桌面到linux，需要在linux上安装vncserver，并开启vnc服务，同时需要在windows下使用vnc-viewer访问Linux。vncserver同时支持linux远程桌面到linux。   linux远程桌面到windows，需要在linux上安装rdesktop，同时开启windows的远程桌面访问。   下面分别介绍，以windo
  • guava中的join和split功能 jackyrong java
    guava库中，包含了很好的join和split的功能，例子如下： 1） 将LIST转换为使用字符串连接的字符串    List<String> names = Lists.newArrayList("John", "Jane", "Adam", "Tom");
  • Web开发技术十年发展历程 lampcy androidWeb浏览器html5
    回顾web开发技术这十年发展历程： Ajax 03年的时候我上六年级，那时候网吧刚在小县城的角落萌生。传奇，大话西游第一代网游一时风靡。我抱着试一试的心态给了网吧老板两块钱想申请个号玩玩，然后接下来的一个小时我一直在，注，册，账，号。 彼时网吧用的512k的带宽，注册的时候，填了一堆信息，提交，页面跳转，嘣，”您填写的信息有误，请重填”。然后跳转回注册页面，以此循环。我现在时常想，如果当时a
  • 架构师之mima-----------------mina的非NIO控制IOBuffer(说得比较好) nannan408 buffer
    1.前言。   如题。 2.代码。   IoService IoService是一个接口，有两种实现：IoAcceptor和IoConnector；其中IoAcceptor是针对Server端的实现，IoConnector是针对Client端的实现；IoService的职责包括： 1、监听器管理 2、IoHandler 3、IoSession
  • ORA-00054:resource busy and acquire with NOWAIT specified Everyday都不同 oraclesessionLock
    [Oracle] 今天对一个数据量很大的表进行操作时，出现如题所示的异常。此时表明数据库的事务处于“忙”的状态，而且被lock了，所以必须先关闭占用的session。   step1，查看被lock的session：   select t2.username, t2.sid, t2.serial#, t2.logon_time from v$locked_obj
  • javascript学习笔记 tntxia JavaScript
      javascript里面有6种基本类型的值:number、string、boolean、object、function和undefined。number：就是数字值，包括整数、小数、NaN、正负无穷。string:字符串类型、单双引号引起来的内容。boolean:true、false object:表示所有的javascript对象，不用多说function:我们熟悉的方法，也就是
  • Java enum的用法详解 xieke90 enum枚举
    Java中枚举实现的分析：     示例：  public static enum SEVERITY{ INFO,WARN,ERROR }     enum很像特殊的class，实际上enum声明定义的类型就是一个类。 而这些类都是类库中Enum类的子类      (java.l