彦_cd69
彦_cd69

Feign 调用过程分析

概述

SpringCloud feign 对Netflix feign进行了包装和增强，本文从源码角度梳理一个请求链路中参与的各个组件及其它们如何配合交互完成请求。组件包括feign、ribbon、hystrix、sleuth等

核心类及流程

主要流程

上图为部分流程图，大致可以分为以下3个步骤

  • 元数据的注册
    FeignClient配置及BeanDefinition的注册等
  • Feign初始化
    Feign的上下文信息、负载均衡代理、Feign代理的实例化等
  • 请求调用
    接受请求，进行负载均衡，调用http client客户端完成请求调用等

源码分析

从上文中的几个方面来解读源码

元数据的注册

从EnableXXX开始 -> @EnableFeignClients:

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Documented
@Import(FeignClientsRegistrar.class) 
public @interface EnableFeignClients {
    ...
}
//通过import方式，引入FeignClientsRegistrar，处理逻辑在这
class FeignClientsRegistrar
        implements ImportBeanDefinitionRegistrar, ResourceLoaderAware, EnvironmentAware {
    @Override
    public void registerBeanDefinitions(AnnotationMetadata metadata,
            BeanDefinitionRegistry registry) {
        //1. 先注册默认配置
        registerDefaultConfiguration(metadata, registry);
        //2. 注册所有的feignClient BeanDefinition
        registerFeignClients(metadata, registry);
    }
}

实现了ImportBeanDefinitionRegistrar接口，开始进行BeanDefinition的注入,分别看下registerBeanDefinitions中的两个方法

//注册默认配置
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();
            }
            //以default为前缀，注册feignClient configuration 第一处
            registerClientConfiguration(registry, name,
                    defaultAttrs.get("defaultConfiguration"));
        }
    }

上述方法读取@EnableFeignClients注解中声明的defaultConfiguration配置，name以default为前缀，一般情况不需要配置。

//注册所有的FeignClient 的BeanDefinition
public void registerFeignClients(AnnotationMetadata metadata,
            BeanDefinitionRegistry registry) {
        ...
        //获取扫描目录下面所有的bean deanDefinition  
        for (String basePackage : basePackages) {
            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");

                    Map attributes = annotationMetadata
                            .getAnnotationAttributes(
                                    FeignClient.class.getCanonicalName());

                    String name = getClientName(attributes);
                   //注册feignClient configuration 第二处
                    registerClientConfiguration(registry, name,
                            attributes.get("configuration"));
                    //注册feignClient
                    registerFeignClient(registry, annotationMetadata, attributes);
                }
            }
        }
    }

上述两个代码片段中都调用了registerClientConfiguration,注册了FeignClientSpecification，这个类很重要，是feign client配置的载体，包含FeignClient的核心配置重试策略、超时策略、日志等配置。某个服务没有设置就读取默认(default)的配置。再看看单个FeignClient的注册registerFeignClient

private void registerFeignClient(BeanDefinitionRegistry registry,
            AnnotationMetadata annotationMetadata, Map attributes) {
        String className = annotationMetadata.getClassName();
        //注册FeignClientFactoryBean
        BeanDefinitionBuilder definition = BeanDefinitionBuilder
                .genericBeanDefinition(FeignClientFactoryBean.class);
        // ... 装配@FeignClient定义的元数据

        BeanDefinitionHolder holder = new BeanDefinitionHolder(beanDefinition, className,
                new String[] { alias });
        BeanDefinitionReaderUtils.registerBeanDefinition(holder, registry);
    }

扫描到所有@FeignClient的BeanDefinition后，包装成FeignClientFactoryBean，然后注册到spring上下文中。FeignClientFactoryBean是后续处理的关键，它是一个FactoryBean，也即一个代理，在从spring容器中注入时进行被代理对象的处理。到此配置信息及BeanDefinition注册结束。

Feign初始化

承接上文，直接分析FeignClientFactoryBean，这个类是Feign初始化的最核心的类，先整体看下代码结构

    @Override
    public Object getObject() throws Exception {
        return getTarget();
    }

     T getTarget() {
        //实例化FeignContext
        FeignContext context = this.applicationContext.getBean(FeignContext.class);
       //实例化Feign.Builder，用来生成Feign
        Feign.Builder builder = feign(context);
       //判断生成代理对象的url, 如果为空，走负载均衡，生成负载均衡的代理类
        if (!StringUtils.hasText(this.url)) {
            if (!this.name.startsWith("http")) {
                this.url = "http://" + this.name;
            }
            else {
                this.url = this.name;
            }
            this.url += cleanPath();
            //负载均衡
            return (T) loadBalance(builder, context,
                    new HardCodedTarget<>(this.type, this.name, this.url));
        }
        if (StringUtils.hasText(this.url) && !this.url.startsWith("http")) {
            this.url = "http://" + this.url;
        }
        String url = this.url + cleanPath();
        Client client = getOptional(context, Client.class);
        if (client != null) {
            if (client instanceof LoadBalancerFeignClient) {
                // not load balancing because we have a url,
                // but ribbon is on the classpath, so unwrap
                client = ((LoadBalancerFeignClient) client).getDelegate();
            }
            builder.client(client);
        }
        Targeter targeter = get(context, Targeter.class);
                //生成默认代理类，不走负载均衡直连
        return (T) targeter.target(this, builder, context,
                new HardCodedTarget<>(this.type, this.name, url));
    }

FeignClientFactoryBean 完成了调用前的所有准备工作，如FeignContext，Feign.builder的创建、判断是否需要负载均衡及设置及Feign的代理类的创建等，下文逐个说明

第一步 实例化Feign上下文FeignContext

FeignContext是Feign初始化需要的上下信息，通过FeignAutoConfiguration引入

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

}

FeignAutoConfiguration是Feign 配置的第一个入口，在这里上文中注册的FeignClientSpecification派上了用场，注入到了FeignClientSpecification集合，顺便提一下Spring支持集合类型对象的注入如List,Map等。在没有引入Sleuth时会注入FeignContext，引入Sleuth之后呢？再看下TraceFeignClientAutoConfiguration:

@Configuration
@ConditionalOnProperty(value = "spring.sleuth.feign.enabled", matchIfMissing = true)
@ConditionalOnClass({ Client.class, FeignContext.class })
@ConditionalOnBean(HttpTracing.class)
@AutoConfigureBefore(FeignAutoConfiguration.class)
@AutoConfigureAfter({ SleuthHystrixAutoConfiguration.class,
        TraceHttpAutoConfiguration.class })
public class TraceFeignClientAutoConfiguration {

    @Configuration
    @ConditionalOnProperty(name = "spring.sleuth.feign.processor.enabled", matchIfMissing = true)
    protected static class FeignBeanPostProcessorConfiguration {

        //引入Sleuth后，初始化FeignContextBeanPostProcessor
        @Bean
        static FeignContextBeanPostProcessor feignContextBeanPostProcessor(
                BeanFactory beanFactory) {
            return new FeignContextBeanPostProcessor(beanFactory);
        }

    }
}

final class FeignContextBeanPostProcessor implements BeanPostProcessor {
    //PostProcessor 将FeignContext包装成TraceFeignContext
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName)
            throws BeansException {
        if (bean instanceof FeignContext && !(bean instanceof TraceFeignContext)) {
            return new TraceFeignContext(traceFeignObjectWrapper(), (FeignContext) bean);
        }
        return bean;
    }
}

@AutoConfigureBefore(FeignAutoConfiguration.class),保证了在FeignAutoConfiguration前初始化，这里定义了一个BeanPostProcessor, 将FeignContext包装成TranceFeignContext，加上了trace的配置信息

第二步 实例化Feign.Builder

Builder是Feign的构造器，进行Feign属性的设置，方便后续Feign对象的创建。回到主类FeignClientFactoryBean中的feign()方法

   protected Feign.Builder feign(FeignContext context) {
        FeignLoggerFactory loggerFactory = get(context, FeignLoggerFactory.class);
        Logger logger = loggerFactory.create(this.type);

        // 从FeignContext获取Feign.Builder
        // @formatter:off
        Feign.Builder builder = get(context, Feign.Builder.class)
                // required values
                .logger(logger)
                .encoder(get(context, Encoder.class))
                .decoder(get(context, Decoder.class))
                .contract(get(context, Contract.class));
        // @formatter:on
        // 加载自定义的配置
        configureFeign(context, builder);

        return builder;
    }
    //从FeignContext中获取配置信息
    protected  T get(FeignContext context, Class type) {
        T instance = context.getInstance(this.contextId, type);
        if (instance == null) {
            throw new IllegalStateException(
                    "No bean found of type " + type + " for " + this.contextId);
        }
        return instance;
    }

从FeignContext中获取上下文信息来实例化Feign.Builder。回到上文中的FeignContext的创建过程，构造函数中一个入参FeignClientsConfiguration,这个类就是FeignClient的属性配置类，源码如下：

public class FeignContext extends NamedContextFactory {
    //构造函数，指定了FeignClientsConfiguration
    public FeignContext() {
        super(FeignClientsConfiguration.class, "feign", "feign.client.name");
    }

}

public class FeignClientsConfiguration {
    //其他属性设置
    ...

    //缺省设置，直接使用Feign.Builder
    @Bean
    @Scope("prototype")
    @ConditionalOnMissingBean
    public Feign.Builder feignBuilder(Retryer retryer) {
        return Feign.builder().retryer(retryer);
    }

    //引入hystrix后，使用HystrixFeign.Builder
    @Configuration
    @ConditionalOnClass({ HystrixCommand.class, HystrixFeign.class })
    protected static class HystrixFeignConfiguration {

        @Bean
        @Scope("prototype")
        @ConditionalOnMissingBean
        @ConditionalOnProperty(name = "feign.hystrix.enabled")
        public Feign.Builder feignHystrixBuilder() {
            return HystrixFeign.builder();
        }

    }

}

引入Sleuth又会如何变化呢？继续深入看下上文中的TraceFeignClientAutoConfiguration，有如下片段

public class TraceFeignClientAutoConfiguration {

    @Bean
    @Scope("prototype")
    @ConditionalOnClass(name = { "com.netflix.hystrix.HystrixCommand",
            "feign.hystrix.HystrixFeign" })
    @ConditionalOnProperty(name = "feign.hystrix.enabled", havingValue = "true")
    Feign.Builder feignHystrixBuilder(BeanFactory beanFactory) {
        return SleuthHystrixFeignBuilder.builder(beanFactory);
    }

    @Bean
    @ConditionalOnMissingBean
    @Scope("prototype")
    @ConditionalOnProperty(name = "feign.hystrix.enabled", havingValue = "false", matchIfMissing = true)
    Feign.Builder feignBuilder(BeanFactory beanFactory) {
        return SleuthFeignBuilder.builder(beanFactory);
    }
}

又出现了两个Builder, SleuthHystrixFeignBuilder、SleuthFeignBuilder,分别适用于有Hystrix和无Hystrix。跟进后会发现，它们内部仍然使用上述的两个Builder,Feign.Builder和HystrixFeign.Builder。更多的是将Client包装成了Sleuth的LazyClient。

第三步 实例化负载均衡代理

ribbon开始登场，继续回到主类FeignClientFactoryBean。

//1. 负载入口
protected  T loadBalance(Feign.Builder builder, FeignContext context,
            HardCodedTarget target) {
        //从FeignContext中获取Client
        Client client = getOptional(context, Client.class);
        if (client != null) {
            builder.client(client);
                //从FeignContext或获取Targeter
            Targeter targeter = get(context, Targeter.class);
            return targeter.target(this, builder, context, target);
        }

        throw new IllegalStateException(
                "No Feign Client for loadBalancing defined. Did you forget to include spring-cloud-starter-netflix-ribbon?");
}
//2. 负载配置入口
@ConditionalOnClass({ ILoadBalancer.class, Feign.class })
@Configuration
@AutoConfigureBefore(FeignAutoConfiguration.class)
@EnableConfigurationProperties({ FeignHttpClientProperties.class })
// Order is important here, last should be the default, first should be optional
// see
// https://github.com/spring-cloud/spring-cloud-netflix/issues/2086#issuecomment-316281653
@Import({ HttpClientFeignLoadBalancedConfiguration.class,
        OkHttpFeignLoadBalancedConfiguration.class,
        DefaultFeignLoadBalancedConfiguration.class })
public class FeignRibbonClientAutoConfiguration {

    ...
}
//3. 默认配置
class DefaultFeignLoadBalancedConfiguration {

    @Bean
    @ConditionalOnMissingBean
    public Client feignClient(CachingSpringLoadBalancerFactory cachingFactory,
            SpringClientFactory clientFactory) {
        return new LoadBalancerFeignClient(new Client.Default(null, null), cachingFactory,
                clientFactory);
    }

}

从FeignContext中获取的Client, Client在FeignRibbonClientAutoConfiguration中自动配置，代码中@Import中的XXXFeignLoadBalancedConfiguration根据classpath中Http Client完成LoadBalancerFeignClient的实例化。从XXX名字可以看出, 分别对应Apache HttpClient、 OkHttpClient和Java HttpClient(默认)。这里建议使用Apache HttpClient或OkHttpClient，有线程池支持，性能更好。加上sleuth的支持又如何变化？看一看增强后的 TranceFeignContext

class TraceFeignContext extends FeignContext {

    @Override
    @SuppressWarnings("unchecked")
    public  Map getInstances(String name, Class type) {
        //从基类FeignContext中获取属性集合
        Map instances = this.delegate.getInstances(name, type);
        if (instances == null) {
            return null;
        }
        Map convertedInstances = new HashMap<>();
        //逐个遍历属性，进行wrap
        for (Map.Entry entry : instances.entrySet()) {
            convertedInstances.put(entry.getKey(),
                    (T) this.traceFeignObjectWrapper.wrap(entry.getValue()));
        }
        return convertedInstances;
    }

    //把Client包装成TraceLoadBalancerFeignClient
    Object wrap(Object bean) {
        if (bean instanceof Client && !(bean instanceof TracingFeignClient)) {
            if (ribbonPresent && bean instanceof LoadBalancerFeignClient
                    && !(bean instanceof TraceLoadBalancerFeignClient)) {
                LoadBalancerFeignClient client = ((LoadBalancerFeignClient) bean);
                return new TraceLoadBalancerFeignClient(
                        (Client) new TraceFeignObjectWrapper(this.beanFactory)
                                .wrap(client.getDelegate()),
                        factory(), (SpringClientFactory) clientFactory(),
                        this.beanFactory);
            }
            else if (ribbonPresent && bean instanceof TraceLoadBalancerFeignClient) {
                return bean;
            }
            return new LazyTracingFeignClient(this.beanFactory, (Client) bean);
        }
        return bean;
    }
}

TraceFeignContext 把FeignClient返回的Client包装成TraceLoadBalancerFeignClient。注意在没有引入ribbon、sleuth时Client直接使用默认对象Client.Default。 至此负载均衡的client代理就完成了创建。

第四步 实例化Feign代理

继续分析FeignClientFactoryBean， 有如下片段

Targeter targeter = get(context, Targeter.class);
return targeter.target(this, builder, context, target);

这里的Targeter是用来生成ReflectiveFeign(Feign的实现类)的工具类，有如下两种实现,再次回到FeignAutoConfiguration：

public class FeignAutoConfiguration {

    @Configuration
    @ConditionalOnClass(name = "feign.hystrix.HystrixFeign")
    protected static class HystrixFeignTargeterConfiguration {

        @Bean
        @ConditionalOnMissingBean
        public Targeter feignTargeter() {
            return new HystrixTargeter();
        }
    }

    @Configuration
    @ConditionalOnMissingClass("feign.hystrix.HystrixFeign")
    protected static class DefaultFeignTargeterConfiguration {

        @Bean
        @ConditionalOnMissingBean
        public Targeter feignTargeter() {
            return new DefaultTargeter();
        }
    }
}

默认使用DefaultTargeter, 引入hystrix后使用HystrixTargeter。继续跟进会发现最终是在实例化Feign代理

public abstract class Feign {
    // Targeter 调用的地方
    public  T target(Target target) {
      return build().newInstance(target);
    }
    //实例化Feign实现类并填充SynchronousMethodHandler.Factory
    public Feign build() {
      SynchronousMethodHandler.Factory synchronousMethodHandlerFactory =
          new SynchronousMethodHandler.Factory(client, retryer, requestInterceptors, logger,
              logLevel, decode404, closeAfterDecode, propagationPolicy);
      ParseHandlersByName handlersByName =
          new ParseHandlersByName(contract, options, encoder, decoder, queryMapEncoder,
              errorDecoder, synchronousMethodHandlerFactory);
      return new ReflectiveFeign(handlersByName, invocationHandlerFactory, queryMapEncoder);
    }
}

public class ReflectiveFeign extends Feign {

  //创建Feign代理类
  @Override
  public  T newInstance(Target target) {
    Map nameToHandler = targetToHandlersByName.apply(target);
    Map methodToHandler = new LinkedHashMap();
    List defaultMethodHandlers = new LinkedList();

    //将Feign Client 接口中的所有方法，包装成MethodHandler
    for (Method method : target.type().getMethods()) {
      if (method.getDeclaringClass() == Object.class) {
        continue;
      } else if (Util.isDefault(method)) {//判断方法是否是默认方法，启用默认handler
        DefaultMethodHandler handler = new DefaultMethodHandler(method);
        defaultMethodHandlers.add(handler);
        methodToHandler.put(method, handler);
      } else {
        methodToHandler.put(method, nameToHandler.get(Feign.configKey(target.type(), method)));
      }
    }
    //创建InvocationHandler,调用时转发到methodHandler
    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;
  }}

到这就很明朗了，使用Targeter来创建ReflectiveFeign,同时引出了SynchronousMethodHandler,这个类很重要，是发送请求的关键类,后文再叙。也可以看到动态代理的基础类InvocationHandler，InvocationHandler的最终实现有两种选择：FeignInvocationHandler（无hystrix）、HystrixInvocationHandler（有hystrix）

//1. 使用Feign.Builder 最终使用的是FeignInvocationHandler
public abstract class Feign {
  public static class Builder {
    //默认
    private InvocationHandlerFactory invocationHandlerFactory =
        new InvocationHandlerFactory.Default();
  }
}

static final class Default implements InvocationHandlerFactory {

    @Override
    public InvocationHandler create(Target target, Map dispatch) {
      return new ReflectiveFeign.FeignInvocationHandler(target, dispatch);
    }
}

//2. 使用HystrixFeign.Builder 最终使用的是HystrixInvocationHandler

    /** Configures components needed for hystrix integration. */
    Feign build(final FallbackFactory nullableFallbackFactory) {
      super.invocationHandlerFactory(new InvocationHandlerFactory() {
        @Override
        public InvocationHandler create(Target target,
                                        Map dispatch) {
          return new HystrixInvocationHandler(target, dispatch, setterFactory,
              nullableFallbackFactory);
        }
      });
      super.contract(new HystrixDelegatingContract(contract));
      return super.build();
    }

Feign 的动态代理创建完成，并交由Spring容器管理。第二阶段的初始化阶段至此结束。http请求发生时，创建的代理对象最终聚合ribbon、hystrix、sleuth的功能完成整个调用链路的增强或跟踪。

请求调用

上一章节的最后，创建了InvocationHandler，在请求发生时invoke将被调用。以引入hystrix场景说明，看一看HystrixInvocationHandler

HystrixInvocationHandler

final class HystrixInvocationHandler implements InvocationHandler {
  @Override
  public Object invoke(final Object proxy, final Method method, final Object[] args)
      throws Throwable {
    ...
  
    HystrixCommand hystrixCommand =
        new HystrixCommand(setterMethodMap.get(method)) {
          @Override
          protected Object run() throws Exception {
            try {
              return HystrixInvocationHandler.this.dispatch.get(method).invoke(args);
            } catch (Exception e) {
              throw e;
            } catch (Throwable t) {
              throw (Error) t;
            }
          }
          @Override
          protected Object getFallback() {

            ...
          }
         
    }
    ...

}
 
 
 
  
HystrixCommand hystrix功能的入口，其提供的fallback,熔断等都经由此入口进行增强。在run()方法中开始发起调用，找到方法对应的methodHandler,methodHandler中封装了loadBalanceClient、retryer等组件。methodHandler 上文已有提及，也就是SynchronousMethodHandler，继续跟进
 
 
 
 
final class SynchronousMethodHandler implements MethodHandler {

  @Override
  public Object invoke(Object[] argv) throws Throwable {
    //根据请求参数构建RequestTemplate
    RequestTemplate template = buildTemplateFromArgs.create(argv);
    //定义重试策略
    Retryer retryer = this.retryer.clone();
    while (true) {
      try {
        // 重要方法在这里
        return executeAndDecode(template);
      } catch (RetryableException e) {
        try {
          retryer.continueOrPropagate(e);
        } catch (RetryableException th) {
          Throwable cause = th.getCause();
          if (propagationPolicy == UNWRAP && cause != null) {
            throw cause;
          } else {
            throw th;
          }
        }
        if (logLevel != Logger.Level.NONE) {
          logger.logRetry(metadata.configKey(), logLevel);
        }
        continue;
      }
    }
  }

  Object executeAndDecode(RequestTemplate template) throws Throwable {
    Request request = targetRequest(template);
    try {
      //在初始化阶段创建的Client在这里开始调用
      response = client.execute(request, options);
    } catch (IOException e) {
     ...
    }
    //省略响应处理
    ...
 }
}

 
 
 
  
这里已经很明确，LoadBalancerFeignClient (Ribbon)开始起作用了。继续跟进
 
 
 
 
public class LoadBalancerFeignClient implements Client {

    @Override
    public Response execute(Request request, Request.Options options) throws IOException {
        try {
            //获取URI
            URI asUri = URI.create(request.url());
            String clientName = asUri.getHost();
            URI uriWithoutHost = cleanUrl(request.url(), clientName);
            //封装成RibbonRequest请求
            FeignLoadBalancer.RibbonRequest ribbonRequest = new FeignLoadBalancer.RibbonRequest(
                    this.delegate, request, uriWithoutHost);
            //封装请求参数
            IClientConfig requestConfig = getClientConfig(options, clientName);
            //进行负载并请求
            return lbClient(clientName)
                    .executeWithLoadBalancer(ribbonRequest, requestConfig).toResponse();
        }
        catch (ClientException e) {
            IOException io = findIOException(e);
            if (io != null) {
                throw io;
            }
            throw new RuntimeException(e);
        }
    }

}
    
    public T executeWithLoadBalancer(final S request, final IClientConfig requestConfig) throws ClientException {
        LoadBalancerCommand command = this.buildLoadBalancerCommand(request, requestConfig);

        try {
            return (IResponse)command.submit(new ServerOperation() {
                public Observable call(Server server) {
                    URI finalUri = AbstractLoadBalancerAwareClient.this.reconstructURIWithServer(server, request.getUri());
                    ClientRequest requestForServer = request.replaceUri(finalUri);

                    try {
                        // 执行ribbon负载均衡请求
                        return Observable.just(AbstractLoadBalancerAwareClient.this.execute(requestForServer, requestConfig));
                    } catch (Exception var5) {
                        return Observable.error(var5);
                    }
                }
            }).toBlocking().single();
        } catch (Exception var6) {
            Throwable t = var6.getCause();
            if (t instanceof ClientException) {
                throw (ClientException)t;
            } else {
                throw new ClientException(var6);
            }
        }
    }

 
 
 
  
这里是ribbon发起请求的地方，至于到底选择何种http 客户端，在FeignRibbonClientAutoConfiguration中进行配置，上文已经说明。默认使用Client.Default设置的客户端
 
 
 
 
class Default implements Client {
    @Override
    public Response execute(Request request, Options options) throws IOException {
      // 这里使用的java httpclient
      HttpURLConnection connection = convertAndSend(request, options);
      return convertResponse(connection, request);
    }
}

 
 
 
  
写在最后：本文只梳理了feign如何与spring cloud生态中组件进行交互完成请求，每个组件的功能实现没有涉及，有兴趣的同学可以自行研究，特别是Hystrix和ribbon中使用的rxjava,可以参考
 Hystrix核心基础 - 滑动窗口创建过程及demo
 
 
 
 

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(Feign 调用过程分析)

        

            

                
    
                    
  • 域名如何绑定服务
                        我真的不想做程序员
javajava后端开发语言服务器阿里云容器
                        
    目录一、理解域名与Java服务之间的关系二、DNS解析三、配置DNS记录四、Java服务的配置1.部署Java应用2.配置反向代理五、DNS解析六、验证绑定是否成功七、代码示例八、总结在现代网络应用中，域名和Java服务的绑定是实现用户友好访问和后台服务的关键步骤。本文将详细介绍这一过程，包括DNS解析、反向代理以及Java服务的配置，最后会展示代码示例和视觉化流程图。一、理解域名与Java服务之
    
                    
    • 
                    
  • 动态规划算法求解背包问题的全面剖析
                        15号外媒
算法
                        
    摘要本文深入剖析动态规划算法在求解背包问题中的应用，详细阐述动态规划算法的基本原理、核心要素与解题步骤。通过对0-1背包问题和完全背包问题的具体分析，展示动态规划算法在解决背包问题上的高效性与独特优势。同时，结合实际案例进行算法实现与结果分析，并探讨算法的优化策略与拓展应用，旨在帮助读者全面掌握动态规划算法求解背包问题的方法与技巧。一、引言背包问题作为组合优化领域的经典问题，在资源分配、投资决策、
    
                    
    • 
                    
  • golang-方法
                        lmryBC49
golang开发语言后端
                        
    方法概述方法是给类型增加的，通过类型实例.方法名()调用。例如我们用自定义类型保存了整数，我们想给该类型的变量都增加一个方法可以直接判断该数是不是奇数。packagemethod_knowledgeimport"fmt"//案例1:给Myint自定义类型添加奇数判断方法typeMyintintfunc(aMyint)IsOdd(){if(a%2==0){fmt.Println("a不是奇数")}e
    
                    
    • 
                    
  • Android HAL服务注册与获取服务
                        令狐掌门
Android开发笔记androidandroidaosp
                        
    HAL服务注册在AndroidHAL（硬件抽象层）开发中，当使用HIDL（硬件接口定义语言）定义接口时，生成的C++头文件会包含一个关键的registerAsService函数。该函数的作用是将HAL实现注册到系统服务管理器，使其他进程能够发现并调用该服务。以下是详细介绍：功能与作用服务注册：registerAsService用于将HAL接口的实现实例注册到Android的hwserviceman
    
                    
    • 
                    
  • 基于python+django的家教预约网站-家教信息管理系统源码+运行步骤
                        冷琴1996
Python系统设计pythondjango开发语言
                        
    该系统是基于python+django开发的家教预约网站。是给师妹做的课程作业。大家在学习过程中，遇到问题可以在github给作者留言。共同学习进步哦效果演示前台地址：http://jiajiao.gitapp.cn后台地址：http://jiajiao.gitapp.cn/admin后台管理帐号：用户名：admin123密码：admin123源码地址https://github.com/geee
    
                    
    • 
                    
  • 揭秘时空大数据：详细介绍、真实应用场景和数据示例解析
                        陈书予
GIS开发（时空大数据）前端大数据python时序数据库
                        
    时空大数据(SpatialBigData)是指利用空间环境和时间环境信息，以及数字技术，从多种来源获取的海量、动态的、多维的数据，对空间环境和时间环境进行实时监测，并基于复杂的数据分析和挖掘，获取有价值的信息。时空大数据示例：1）社会网络数据：Twitter、Facebook、Instagram等社交媒体上的海量数据，可以通过时间、空间、主题等来提取有价值的信息。2）遥感图像数据：通过遥感技术从卫
    
                    
    • 
                    
  • LoadRunner 11 性能测试全面教程
                        金融先生-Frank

                        
    本文还有配套的精品资源，点击获取简介：LoadRunner11（LR11）是HP开发的一款企业级性能测试工具，支持多应用程序类型的负载测试，用于性能评估、瓶颈识别和系统优化。教程详细介绍LR11的组件功能、脚本开发、场景设置、测试执行、结果分析、性能指标监测、故障诊断以及自动化测试等，提供从初级到高级的完整学习路径。1.LoadRunner11(LR11)功能概述LoadRunner11(LR11
    
                    
    • 
                    
  • Vue.js 中的 Memoization：提升性能的缓存技术
                        vvilkim
vuevue.js前端javascript
                        
    在现代前端开发中，性能优化是一个永恒的话题。随着应用规模的增大，复杂的计算和频繁的函数调用可能会导致性能瓶颈。Vue.js作为一个流行的前端框架，提供了多种优化手段，其中memoization（记忆化）就是一种非常有效的技术。本文将详细介绍Vue.js中的memoization，以及如何利用它来提升应用性能。什么是Memoization？Memoization是一种优化技术，通过缓存函数的结果来避
    
                    
    • 
                    
  • CVPR2025 | 对抗样本&智能安全方向论文汇总 | 持续更新中~
                        四口鲸鱼爱吃盐
文献阅读安全transformer深度学习对抗样本神经网络视觉语言模型后门攻击
                        
    汇总结果来源：CVPR2025AcceptedPapers若文中出现的论文链接和GitHub链接点不开，则说明还未公布，在公布后笔者会及时添加.若笔者未及时添加，欢迎读者告知.文章根据题目关键词搜索，可能会有遗漏.若笔者出现遗漏，欢迎告知.部分文章还未公布正文，只有名称.MindtheGap：通过查询更新分析检测正在进行中的黑盒对抗攻击MindtheGap:DetectingBlack-boxAd
    
                    
    • 
                    
  • 使用大语言模型API在AI应用中的实现
                        qq_37836323
人工智能语言模型自然语言处理python
                        
    随着人工智能技术的迅速发展，大语言模型（LLM）在自然语言处理（NLP）领域的应用越来越广泛。本文将介绍如何使用大语言模型API来实现一些基础的AI应用，并提供一个简单的demo代码，帮助大家更好地理解和使用这些技术。大语言模型API简介大语言模型（如GPT-4）能够理解和生成类似人类的文本。这些模型可以应用于各种任务，包括文本生成、语言翻译、情感分析、对话系统等。为了方便国内用户访问这些强大的模
    
                    
    • 
                    
  • python基于Django的旅游景点数据分析及可视化的设计与实现 7blk7
                        qq2295116502
pythondjango数据分析
                        
    目录项目介绍技术栈具体实现截图Scrapy爬虫框架关键技术和使用的工具环境等的说明解决的思路开发流程爬虫核心代码展示系统设计论文书写大纲详细视频演示源码获取项目介绍大数据分析是现下比较热门的词汇，通过分析之后可以得到更多深入且有价值的信息。现实的科技手段中，越来越多的应用都会涉及到大数据随着大数据时代的到来，数据挖掘、分析与应用成为多个行业的关键,本课题首先介绍了网络爬虫的基本概念以及技术实现方法
    
                    
    • 
                    
  • 用python执行js代码：PyExecJS库详解
                        数据知道
2025年爬虫和逆向教程pythonjavascript爬虫数据采集nodejs
                        
    更多内容请见：爬虫和逆向教程-专栏介绍和目录文章目录1.介绍和安装1.1PyExecJS介绍1.2安装JavaScript运行时1.3安装PyExecJS2.PyExecJS的基本使用2.1执行简单的JavaScript代码2.2使用外部JavaScript文件2.3先编译、后调用2.4传递参数和获取返回值3.PyExecJS的高级功能3.1指定JavaScript运行时3.2处理异步JavaSc
    
                    
    • 
                    
  • 手机端Flutter、React Native与原生安卓、iOS交互的方案及设计原理
                        JafarOne
智能手机flutterreactnativeAndroidiOSJava
                        
    手机端Flutter、ReactNative与原生安卓、iOS交互的方案及设计说明一、交互方案与代码示例1.Flutter与原生交互方案核心方案：通过MethodChannel和EventChannel实现双向通信。原理：Flutter的Channel机制基于平台信道（如MethodChannel），通过Dart引擎与原生层的二进制消息传递完成调用。原生代码需监听信道，并根据方法名执行操作，结果通
    
                    
    • 
                    
  • 二分查找算法在有序数组中的解题分析与优化
                        带给我一点小幸运
算法
                        
    摘要本文深入剖析二分查找算法在有序数组中的应用，详细阐述其基本原理、实现步骤与时间复杂度，通过实际案例展示其解题过程，并针对算法在实际应用中的常见问题提出优化策略，旨在帮助读者全面掌握二分查找算法，提升解决相关问题的能力。一、引言在计算机科学领域，查找算法是解决众多问题的基础。二分查找算法作为一种高效的查找方法，在有序数组的查找场景中具有显著优势。随着数据规模的不断增大，二分查找算法相较于其他查找
    
                    
    • 
                    
  • 利用Python爬虫获取淘宝商品评论：实战案例分析
                        数据小爬虫@
APIpython爬虫开发语言
                        
    在数字化时代，数据的价值日益凸显，尤其是对于电商平台而言，商品评论作为用户反馈的重要载体，蕴含着丰富的信息。本文将详细介绍如何利用Python爬虫技术获取淘宝商品评论，包括代码示例和关键步骤解析。淘宝商品评论的重要性淘宝商品评论不仅对消费者购买决策有着重要影响，而且对于商家来说，也是了解市场需求、改进产品和服务的重要途径。因此，获取并分析淘宝商品评论数据，对于电商运营和市场分析具有重要意义。Pyt
    
                    
    • 
                    
  • 【NLP】 API在大语言模型中的应用
                        Nerous_
深度学习自然语言处理语言模型人工智能
                        
    大语言模型（LargeLanguageModels,LLMs）通过API（应用程序接口）为开发者提供了便捷的调用方式，使其能够快速集成自然语言处理能力到各类应用中。以下是API在LLM中的核心应用场景及技术实现细节：一、核心应用场景自然语言理解与生成应用示例：智能客服：解析用户问题并生成回复（如ChatGPTAPI）。内容创作：自动生成文章、广告文案或代码（如OpenAI的GPT-4）。技术实现：
    
                    
    • 
                    
  • Python 自动探索性数据分析库———KLib
                        若木胡
toolspython数据分析开发语言
                        
    Python自动探索性数据分析库——KLib一、引言在当今数据驱动的时代，数据分析师和科学家们面临着海量的数据需要处理和分析。探索性数据分析（EDA）作为数据处理流程中的关键环节，旨在帮助人们快速理解数据的特征、分布、相关性等重要信息，从而为后续的深入分析、建模以及决策提供坚实的基础。Python以其丰富的生态系统和强大的功能在数据分析领域占据着重要地位，而KLib则是其中一款专注于自动探索性数据
    
                    
    • 
                    
  • 源码篇：python生成《蔬菜店销售数据分析报告》案例
                        IT小本本
pythonpython数据分析开发语言
                        
    本文将通过Python实现一个完整的蔬菜销售数据分析项目，涵盖数据生成、清洗、分析及可视化全流程。我们将利用模拟数据生成技术创建90天的销售记录，通过Pandas进行数据处理，结合Matplotlib和Seaborn实现多样化的可视化图表，并最终生成动态交互报告。一、数据生成：模拟真实销售场景为了模拟真实的蔬菜销售数据，我们设计了包含10种蔬菜（白菜、土豆、西红柿等）的90天销售记录。数据生成逻辑
    
                    
    • 
                    
  • 软件工程（数据字典）
                        Rain:)
软件工程数据分析软件开发
                        
    数据字典数据字典是关于数据的信息的集合，也就是对数据流图中包含的所有元素的定义的集合。任何字典最主要的用这都是供人查阅对不了解的条目的解释，数据字典的作用也正是在软件分析和设计的过程中给人提供关于数据的描述信息。数据流图和数据字典共同构成系统的逻辑模型，没有数据字典，数据流图就不严格，然而没有数据流图，数据字典也难于发挥作用。只有数据流图和对数据流图中每个元素的精确定义放在一起，才能共同构成系统的
    
                    
    • 
                    
  • 路由交换技术——多私网下NAPT、FTP服务公网映射配置的实验
                        「J1e」
网络网络协议tcp/ip
                        
    网络地址转换（NAT）技术概述1.定义与背景网络地址转换（NetworkAddressTranslation,NAT）是一种在IP数据包传输过程中修改源或目标IP地址及端口的技术，主要用于解决IPv4地址短缺问题。随着互联网设备激增，NAT通过允许多个设备共享单一公网IP地址，显著延缓了IPv4地址耗尽的速度。2.工作原理NAT的核心是通过中间设备（如路由器、防火墙）建立内网私有地址与外网公有地址
    
                    
    • 
                    
  • 对比与详解：QR 分解、奇异值分解（SVD）与 Schur 分解及其他可产生正交基的方法
                        DuHz
机器学习人工智能信号处理算法矩阵信息与通信线性代数
                        
    对比与详解：QR分解、奇异值分解（SVD）与Schur分解及其他可产生正交基的方法在数值线性代数与矩阵分析中，常见的能产生正交（或酉）矩阵的分解方法包括QR分解、奇异值分解（SVD）、Schur分解等。这些方法虽然都会产生一个（或多个）正交矩阵，但它们在适用范围、分解形式、计算重点和应用场景等方面各不相同。本文将尽量对这些分解方法进行系统地介绍与对比。1.正交矩阵（Orthogonal/Unita
    
                    
    • 
                    
  • JVM垃圾回收器全面解析：从核心概念到选型指南
                        Debug Your Career
面试jvmjava
                        
    一、引言在Java应用运行过程中，垃圾回收（GarbageCollection,GC）是内存管理的核心机制，直接影响程序性能。JVM提供了多种垃圾回收器，适用于不同场景。本文将系统梳理主流垃圾回收器的工作原理、适用场景及选型策略。二、GC核心概念分代收集：堆内存分为新生代（YoungGeneration）和老年代（OldGeneration），采用不同回收策略。STW（Stop-The-World
    
                    
    • 
                    
  • DeepSeek来袭！低代码+AI竟让程序员摸鱼接私单月入5W！
                        工业甲酰苯胺
低代码人工智能
                        
    目录一、引言：开启低代码+AI新时代二、DeepSeek与低代码、AI的关联（一）DeepSeek简介（二）低代码开发概述（三）AI赋能低代码三、低代码+AI开启私单赚钱大门（一）成功案例剖析（二）私单项目类型（三）赚钱模式解析四、实战：利用DeepSeek接私单（一）工具准备与环境搭建（二）需求分析与项目规划（三）低代码开发实战（四）AI技术融合应用（五）项目测试与交付五、挑战与应对策略（一）技
    
                    
    • 
                    
  • 亿级分布式系统架构演进实战（一）- 总体概要
                        power-辰南
java技术架构师成长专栏高并发分布式系统微服务架构设计springcloud
                        
    前言不说废话，这次分享是某500强企业真实亿级流量业务中台技术架构演进过程实战。核心目标构建一个兼具高性能、高可用、强一致性的分布式系统，支撑亿级流量场景下的稳定运行。演进路线大纲阶段一：横向扩展（应对万级QPS）核心目标：突破单机性能瓶颈，建立弹性基础[Nginx]/|\[App1][App2][App3]←无状态服务集群\|/[DBProxy]←读写分离中间件/\[Master]←写节点[Sl
    
                    
    • 
                    
  • [软件工程] 数据字典
                        枪枪枪
SoftwareEngineering
                        
    =======================================================================  学习过程中很容易忘记绘图的符号、图的定义，为避免重新翻书查定义，还是整理整理放博客上，方便查看吧。基本上都是书上的内容，在这里集合一下。参考资料：软件工程（张海藩、吕云翔）=========================================
    
                    
    • 
                    
  • 3分钟带你了解Vue3的nextTick()
                        嫣嫣细语
vue.js前端javascriptvue.jsjavascript前端
                        
    前言Vue实现响应式并不是数据发生变化之后DOM立即变化，而是按一定的策略进行DOM的更新。简单来说，Vue在修改数据后，视图不会立刻更新，而是等同一事件循环中的所有数据变化完成之后，再统一进行视图更新，nextTick()方法就会在这样的DOM更新循环结束后调用指定的函数。概念在Vue3中nextTick()方法的行为和Vue2中基本相似，但它进行了一些优化，以提高性能和稳定性。nextTick
    
                    
    • 
                    
  • 时间序列分析的军火库：AutoTS、Darts、Kats、PaddleTS、tfts 和 FancyTS解析
                        赛卡
大数据人工智能深度学习python概率论数学建模
                        
    引言：时间序列分析的现代挑战时间序列分析在多个领域中扮演着关键角色，包括工程、金融、气象、工业预测等。随着开源工具的快速发展，开发者可以通过多种库快速实现时间序列预测与分析。本文将对AutoTS、Darts、Kats、PaddleTS、tfts和FancyTS六大主流库进行详细解析，并提供代码示例，帮助你根据实际需求选择最佳工具。核心库技术解析与场景化实践1.AutoTS：自动化时间序列预测技术亮
    
                    
    • 
                    
  • 自动驾驶中间件技术辨析：ROS、Apex.Grace、DDS、AutoSAR和AutoSAR Adaptive
                        赛卡
自动驾驶中间件人工智能
                        
    在自动驾驶技术的演进中，中间件作为连接硬件、操作系统与应用软件的核心枢纽，其安全性、实时性和可扩展性至关重要。当前市场上主流的中间件技术包括ROS/ROS2、Apex.Grace（Apex.OS）、DDS、AutoSAR（经典平台CP）和AutoSARAdaptive（自适应平台AP）。这些技术各有特点，但也存在交叉与互补。本文将从功能定位、技术架构、安全认证和应用场景等方面，深入分析它们的联系与
    
                    
    • 
                    
  • 【Q&A】Qt中直接渲染和离屏渲染效率哪个高？
                        浅慕Antonio
Q&Aqt信息可视化开发语言
                        
    直接渲染和离屏渲染的效率取决于具体场景和实现方式，以下是详细对比分析：一、直接渲染（On-screenRendering）原理直接将图形数据绘制到屏幕缓冲区（BackBuffer），完成后通过交换缓冲区显示到屏幕。通常在paintEvent等事件中通过QPainter直接绘制。优势减少数据复制：无需额外的缓冲区传输，直接写入屏幕缓冲区。实时性高：适合需要快速更新的场景（如动画、实时数据可视化）。简
    
                    
    • 
                    
  • 数据分析面临的三大挑战该如何解决
                        銨靜菂等芐紶
数据挖掘大数据数据分析
                        
    转载自品略图书馆http://www.pinlue.com/article/2020/09/0712/2611202048648.html有效的分析已成为决定性因素，很明显，掌握它的人会蓬勃发展。但是，实现这一目标的过程并非没有障碍。最常见的数据分析挑战是什么？公司如何自信地应对它们？下面就来介绍一下。1、浏览预算限制数据分析领导者需要在当下采取行动，但同时也需要考虑未来。平衡这些需求要求他们在制
    
                    
    • 
                                
  • mysql主从数据同步
                                    林鹤霄
mysql主从数据同步
                                    
    配置mysql5.5主从服务器(转)   
教程开始：一、安装MySQL 
说明：在两台MySQL服务器192.168.21.169和192.168.21.168上分别进行如下操作，安装MySQL 5.5.22 
 二、配置MySQL主服务器（192.168.21.169）mysql  -uroot  -p   &nb
    
                                
    • 
                                
  • oracle学习笔记
                                    caoyong
oracle
                                    
    1、ORACLE的安装 
   a>、ORACLE的版本 
   8i,9i :   i是internet 
   10g,11g : grid (网格) 
   12c : cloud (云计算) 
   
   b>、10g不支持win7 
&
    
                                
    • 
                                
  • 数据库，SQL零基础入门
                                    天子之骄
sql数据库入门基本术语
                                    
    数据库，SQL零基础入门 
       做网站肯定离不开数据库，本人之前没怎么具体接触SQL，这几天起早贪黑得各种入门，恶补脑洞。一些具体的知识点，可以让小白不再迷茫的术语，拿来与大家分享。 
  
       数据库，永久数据的一个或多个大型结构化集合，通常与更新和查询数据的软件相关
    
                                
    • 
                                
  • pom.xml
                                    一炮送你回车库
pom.xml
                                    
    1、一级元素dependencies是可以被子项目继承的 
2、一级元素dependencyManagement是定义该项目群里jar包版本号的，通常和一级元素properties一起使用，既然有继承，也肯定有一级元素modules来定义子元素 
3、父项目里的一级元素<modules> 
<module>lcas-admin-war</module> 
<
    
                                
    • 
                                
  • sql查地区省市县
                                    3213213333332132
sqlmysql
                                    
    
-- db_yhm_city   
SELECT * FROM db_yhm_city WHERE class_parent_id = 1 -- 海南 class_id = 9 港、奥、台 class_id = 33、34、35   
  
SELECT * FROM db_yhm_city WHERE class_parent_id =169   
  
SELECT d1.cla
    
                                
    • 
                                
  • 关于监听器那些让人头疼的事
                                    宝剑锋梅花香
画图板监听器鼠标监听器
                                    
           本人初学JAVA，对于界面开发我只能说有点蛋疼，用JAVA来做界面的话确实需要一定的耐心（不使用插件，就算使用插件的话也没好多少）既然Java提供了界面开发，老师又要求做，只能硬着头皮上啦。但是监听器还真是个难懂的地方，我是上了几次课才略微搞懂了些。 
      
    
                                
    • 
                                
  • JAVA的遍历MAP
                                    darkranger
map
                                    
    Java Map遍历方式的选择 
1. 阐述 
　　对于Java中Map的遍历方式，很多文章都推荐使用entrySet，认为其比keySet的效率高很多。理由是：entrySet方法一次拿到所有key和value的集合；而keySet拿到的只是key的集合，针对每个key，都要去Map中额外查找一次value，从而降低了总体效率。那么实际情况如何呢？ 
　　为了解遍历性能的真实差距，包括在遍历ke
    
                                
    • 
                                
  • POJ 2312 Battle City 优先多列+bfs
                                    aijuans
搜索
                                    
    来源：http://poj.org/problem?id=2312 
题意：题目背景就是小时候玩的坦克大战，求从起点到终点最少需要多少步。已知S和R是不能走得，E是空的，可以走，B是砖，只有打掉后才可以通过。 
思路：很容易看出来这是一道广搜的题目，但是因为走E和走B所需要的时间不一样，因此不能用普通的队列存点。因为对于走B来说，要先打掉砖才能通过，所以我们可以理解为走B需要两步，而走E是指需要1
    
                                
    • 
                                
  • Hibernate与Jpa的关系，终于弄懂
                                    avords
javaHibernate数据库jpa
                                    
    我知道Jpa是一种规范，而Hibernate是它的一种实现。除了Hibernate，还有EclipseLink(曾经的toplink)，OpenJPA等可供选择，所以使用Jpa的一个好处是，可以更换实现而不必改动太多代码。 
在play中定义Model时，使用的是jpa的annotations，比如javax.persistence.Entity, Table, Column, OneToMany
    
                                
    • 
                                
  • 酸爽的console.log
                                    bee1314
console
                                    
    在前端的开发中，console.log那是开发必备啊，简直直观。通过写小函数，组合大功能。更容易测试。但是在打版本时，就要删除console.log，打完版本进入开发状态又要添加，真不够爽。重复劳动太多。所以可以做些简单地封装，方便开发和上线。 
/**
 * log.js hufeng
 * The safe wrapper for `console.xxx` functions
 *  
    
                                
    • 
                                
  • 哈佛教授：穷人和过于忙碌的人有一个共同思维特质
                                    bijian1013
时间管理励志人生穷人过于忙碌
                                    
            一个跨学科团队今年完成了一项对资源稀缺状况下人的思维方式的研究，结论是：穷人和过于忙碌的人有一个共同思维特质，即注意力被稀缺资源过分占据，引起认知和判断力的全面下降。这项研究是心理学、行为经济学和政策研究学者协作的典范。 
　　这个研究源于穆来纳森对自己拖延症的憎恨。他7岁从印度移民美国，很快就如鱼得水，哈佛毕业
    
                                
    • 
                                
  • other operate
                                    征客丶
OSosx
                                    
    一、Mac Finder 设置排序方式，预览栏 在显示－》查看显示选项中 
二、有时预览显示时，卡死在那，有可能是一些临时文件夹被删除了，如：/private/tmp[有待验证] 
 
-------------------------------------------------------------------- 
若有其他凝问或文中有错误，请及时向我指出， 
我好及时改正，同时也让我们一
    
                                
    • 
                                
  • 【Scala五】分析Spark源代码总结的Scala语法三
                                    bit1129
scala
                                    
    1. If语句作为表达式 
    val properties = if (jobIdToActiveJob.contains(jobId)) {
      jobIdToActiveJob(stage.jobId).properties
    } else {
      // this stage will be assigned to "default" po
    
                                
    • 
                                
  • ZooKeeper 入门
                                    BlueSkator
中间件zk
                                    
    ZooKeeper是一个高可用的分布式数据管理与系统协调框架。基于对Paxos算法的实现，使该框架保证了分布式环境中数据的强一致性，也正是基于这样的特性，使得ZooKeeper解决很多分布式问题。网上对ZK的应用场景也有不少介绍，本文将结合作者身边的项目例子，系统地对ZK的应用场景进行一个分门归类的介绍。 
值得注意的是，ZK并非天生就是为这些应用场景设计的，都是后来众多开发者根据其框架的特性，利
    
                                
    • 
                                
  • MySQL取得当前时间的函数是什么 格式化日期的函数是什么
                                    BreakingBad
mysqlDate
                                    
    取得当前时间用 now() 就行。
在数据库中格式化时间 用DATE_FORMA T(date, format) .
根据格式串format 格式化日期或日期和时间值date，返回结果串。

  可用DATE_FORMAT( ) 来格式化DATE 或DATETIME 值，以便得到所希望的格式。根据format字符串格式化date值:

  %S, %s 两位数字形式的秒（ 00,01,
    
                                
    • 
                                
  • 读《研磨设计模式》-代码笔记-组合模式
                                    bylijinnan
java设计模式
                                    
    声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/ 
 
 



import java.util.ArrayList;
import java.util.List;

abstract class Component {
	
	public abstract void printStruct(Str
    
                                
    • 
                                
  • 4_JAVA+Oracle面试题(有答案)
                                    chenke
oracle
                                    
    基础测试题 
 卷面上不能出现任何的涂写文字，所有的答案要求写在答题纸上，考卷不得带走。 
选择题 
1、 What will happen when you attempt to compile and run the following code? （3） 
public class Static { 
 static { 
 int x = 5; // 在static内有效 
 } 
 st
    
                                
    • 
                                
  • 新一代工作流系统设计目标
                                    comsci
工作算法脚本
                                    
     
  用户只需要给工作流系统制定若干个需求，流程系统根据需求，并结合事先输入的组织机构和权限结构，调用若干算法，在流程展示版面上面显示出系统自动生成的流程图，然后由用户根据实际情况对该流程图进行微调，直到满意为止，流程在运行过程中，系统和用户可以根据情况对流程进行实时的调整，包括拓扑结构的调整，权限的调整，内置脚本的调整。。。。。 
 
 在这个设计中，最难的地方是系统根据什么来生成流
    
                                
    • 
                                
  • oracle 行链接与行迁移
                                    daizj
oracle行迁移
                                    
    表里的一行对于一个数据块太大的情况有二种(一行在一个数据块里放不下) 
 
第一种情况: 
INSERT的时候，INSERT时候行的大小就超一个块的大小。Oracle把这行的数据存储在一连串的数据块里(Oracle Stores the data for the row in a chain of data blocks)，这种情况称为行链接(Row Chain)，一般不可避免(除非使用更大的数据
    
                                
    • 
                                
  • [JShop]开源电子商务系统jshop的系统缓存实现
                                    dinguangx
jshop电子商务
                                    
    前言 
jeeshop中通过SystemManager管理了大量的缓存数据，来提升系统的性能，但这些缓存数据全部都是存放于内存中的，无法满足特定场景的数据更新（如集群环境）。JShop对jeeshop的缓存机制进行了扩展，提供CacheProvider来辅助SystemManager管理这些缓存数据，通过CacheProvider,可以把缓存存放在内存,ehcache,redis，memcache
    
                                
    • 
                                
  • 初三全学年难记忆单词
                                    dcj3sjt126com
englishword
                                    
    several 儿子；若干 
shelf 架子 
knowledge 知识；学问 
librarian 图书管理员 
abroad 到国外，在国外 
surf 冲浪 
wave 浪；波浪 
twice 两次；两倍 
describe 描写；叙述 
especially 特别；尤其 
attract 吸引 
prize 奖品；奖赏 
competition 比赛；竞争 
event 大事；事件 
O
    
                                
    • 
                                
  • sphinx实践
                                    dcj3sjt126com
sphinx
                                    
      
安装参考地址:http://briansnelson.com/How_to_install_Sphinx_on_Centos_Server 
  
yum install sphinx 
如果失败的话使用下面的方式安装 
wget http://sphinxsearch.com/files/sphinx-2.2.9-1.rhel6.x86_64.rpm 
yum loca
    
                                
    • 
                                
  • JPA之JPQL（三）
                                    frank1234
ormjpaJPQL
                                    
    1 什么是JPQL 
JPQL是Java Persistence Query Language的简称，可以看成是JPA中的HQL， JPQL支持各种复杂查询。 
 
2 检索单个对象 
@Test 
public  void querySingleObject1() { 
    Query query = em.createQuery("sele
    
                                
    • 
                                
  • Remove Duplicates from Sorted Array II
                                    hcx2013
remove
                                    
    Follow up for "Remove Duplicates":What if duplicates are allowed at most twice? 
For example,Given sorted array nums = [1,1,1,2,2,3], 
Your function should return length 
    
                                
    • 
                                
  • Spring4新特性——Groovy Bean定义DSL
                                    jinnianshilongnian
spring 4
                                    
    Spring4新特性——泛型限定式依赖注入 
Spring4新特性——核心容器的其他改进 
Spring4新特性——Web开发的增强 
Spring4新特性——集成Bean Validation 1.1(JSR-349)到SpringMVC  
Spring4新特性——Groovy Bean定义DSL 
Spring4新特性——更好的Java泛型操作API  
Spring4新
    
                                
    • 
                                
  • CentOS安装Mysql5.5
                                    liuxingguome
centos
                                    
    CentOS下以RPM方式安装MySQL5.5 
 
首先卸载系统自带Mysql： 
yum remove mysql mysql-server mysql-libs compat-mysql51 
rm -rf /var/lib/mysql 
rm /etc/my.cnf 
查看是否还有mysql软件： 
rpm -qa|grep mysql 
 
 
 
去http://dev.mysql.c
    
                                
    • 
                                
  • 第14章 工具函数（下）
                                    onestopweb
函数
                                    
    index.html 
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/
    
                                
    • 
                                
  • POJ 1050
                                    SaraWon
二维数组子矩阵最大和
                                    
    POJ ACM第1050题的详细描述，请参照 
http://acm.pku.edu.cn/JudgeOnline/problem?id=1050 
 
题目意思： 
给定包含有正负整型的二维数组，找出所有子矩阵的和的最大值。 
如二维数组 
0 -2 -7 0 
9 2 -6 2 
-4 1 -4 1 
-1 8 0 -2 
中和最大的子矩阵是 
9 2 
-4 1 
-1 8 
且最大和是15
    
                                
    • 
                                
  • [5]设计模式——单例模式
                                    tsface
java单例设计模式虚拟机
                                    
    单例模式：保证一个类仅有一个实例，并提供一个访问它的全局访问点 
  
安全的单例模式： 
  
  
/*
 * @(#)Singleton.java  2014-8-1
 *
 * Copyright 2014 XXXX, Inc. All rights reserved.
 */
package com.fiberhome.singleton;


    
                                
    • 
                                
  • Java8全新打造，英语学习supertool
                                    yangshangchuan
javasuperword闭包java8函数式编程
                                    
    superword是一个Java实现的英文单词分析软件，主要研究英语单词音近形似转化规律、前缀后缀规律、词之间的相似性规律等等。Clean code、Fluent style、Java8 feature: Lambdas, Streams and Functional-style Programming。 
  
升学考试、工作求职、充电提高，都少不了英语的身影，英语对我们来说实在太重要
    
                                
    •