彦_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 调用过程分析)

        

            

                
    
                    
  • 关于Spring基础了解
                        党和人民
基础spring
                        
    Spring简介Spring框架是一个开源的Java应用框架，旨在简化企业级应用程序的开发。它提供了一系列强大的工具和服务，帮助开发者构建高质量的Java应用程序。Spring框架的核心理念是使开发过程更加模块化、可测试和可维护。主要特性依赖注入（DependencyInjection,DI）定义：DI是一种设计模式，用于实现控制反转（InversionofControl,IoC）。通过DI，对象
    
                    
    • 
                    
  • PyCharm极速安装指南：3分钟掌握Python开发环境
                        三流搬砖艺术家
pythonpythonpycharmide
                        
    目录为什么选择PyCharm？️准备工具步骤一：下载安装包⚙️步骤二：安装配置步骤三：首次启动配置步骤四：创建第一个项目效率优化技巧❗常见问题排雷社区版vs专业版为什么选择PyCharm？✅智能代码补全：媲美IDE的语法高亮与提示✅跨平台支持：Windows/macOS/Linux全兼容✅插件生态丰富：支持Web开发、数据分析等场景✅社区版免费：无功能限制，个人开发者首选️准备工具操作系统：Win
    
                    
    • 
                    
  • 轮式机器人在复杂地形中如何选择合适的全局路径规划算法
                        luoganttcc
规划控制算法机器人算法前端
                        
    已思考完成收起好的，我现在需要回答用户关于轮式机器人局部路径规划算法的问题。用户之前已经提过这个问题，现在提供了更多的参考内容，我需要仔细分析这些内容，整理出合适的答案。首先，我需要回顾用户提供的参考内容，找出提到的各种局部路径规划算法。参考内容中有知乎文章、回答以及一些网页资料，涵盖了不同的算法。例如，在多个地方提到了动态窗口法（DWA）、时间弹性带（TEB）、模型预测控制（MPC）、人工势场法
    
                    
    • 
                    
  • 数据结构-算法
                        wind_one1
数据结构与算法数据结构算法
                        
    目录2.1算法的定义2.2算法的特性2.2.1输入输出2.2.2有穷性2.2.3确定性2.2.4可行性2.3算法设计的要求2.3.1正确性2.3.2可读性2.3.3健壮性2.3.4时间效率高和储存量低2.4算法效率的度量方法2.4.1事后统计方法2.4.2事前分析估算方法2.5函数的渐进增长2.6算法时间复杂度2.6.1算法时间复杂度定义2.6.2推导大O阶方法2.6.3常数阶2.6.3线性阶2.
    
                    
    • 
                    
  • 嵌入式工程师必学（63）：频谱分析仪的使用方法
                        芯片-嵌入式
嵌入式硬件
                        
    概述：自19世纪60年代以来，工程师和科学家一直在寻找射频技术的创新用途，当时詹姆斯·克拉克·麦克斯韦（JamesClerkMaxwell）在数学上预测了能够在太空中传输能量的电磁波的存在。1886年，海因里希·赫兹（HeinrichHertz）对“无线电波”进行了物理演示，尼古拉·特斯拉（NikolaTesla）、古列尔莫·马可尼（GuglielmoMarconi）和其他人开创了操纵这些电波以实
    
                    
    • 
                    
  • 【DeepSeek】DeepSeek让教学效果翻倍！AI教学案例大揭秘
                        深度求索者
人工智能
                        
    DeepSeek作为一款功能强大的AI大语言模型，在教育领域的应用场景广泛且深入，能够显著提升教师的工作效率和教学质量，并为教务系统的智能化升级提供技术支持。以下是其核心功能与应用方向的详细分析：一、教师使用DeepSeek的核心功能1.教学设计与备课支持教案自动生成输入课程主题、教学目标等关键信息后，DeepSeek可快速生成结构化的教案框架，包括课堂导入设计、互动环节、课后作业等。例如，初中语
    
                    
    • 
                    
  • 【模型部署】大模型部署工具对比：SGLang, Ollama, VLLM, LLaMA.cpp如何选择？
                        深度求索者
llama人工智能
                        
    在选择大模型部署工具时，需要考虑多个因素，包括性能、支持的语言和模型、硬件支持、易用性以及社区支持等。以下是对比分析：性能VLLM(VirtualTensorLanguage):VLLM是一个高性能的推理库，特别适用于长序列任务。它通过虚拟张量技术优化了内存使用，并支持多GPU加速，适合需要高性能推理的场景。LLaMA.cpp:这是一个针对C++优化的LLaMA模型实现，特别适合在资源受限的环境中
    
                    
    • 
                    
  • OpenCV Python 版使用教程（三）摄像头读取延迟解决方法
                        tianchengwang
opencvopencvpython人工智能
                        
    文章目录一、上篇回顾二、产生原因三、解决方法1.cap.grab()方法2.多线程法总结一、上篇回顾在上一篇中，简单介绍了如何使用OpenCV操作摄像头，本期来讲在摄像头读取时，可能会出现画面延迟的解决方法。二、产生原因OpenCV在读取的时候，会将视频流放在缓冲区中，然后每次调用的时候，会从缓冲区内读取视频帧。虽然说大多数情况难以出现写入缓冲区远大于读取缓冲区的速度，但是当设备出现性能瓶颈，尤其
    
                    
    • 
                    
  • 【Python爬虫(95)】Python爬虫进阶：构建大型垂直领域爬虫系统
                        奔跑吧邓邓子
Python爬虫python爬虫开发语言垂直领域系统
                        
    【Python爬虫】专栏简介：本专栏是Python爬虫领域的集大成之作，共100章节。从Python基础语法、爬虫入门知识讲起，深入探讨反爬虫、多线程、分布式等进阶技术。以大量实例为支撑，覆盖网页、图片、音频等各类数据爬取，还涉及数据处理与分析。无论是新手小白还是进阶开发者，都能从中汲取知识，助力掌握爬虫核心技能，开拓技术视野。目录一、项目需求分析1.1确定垂直领域1.2业务需求分析1.3用户需求
    
                    
    • 
                    
  • 【Python爬虫(86)】元宇宙浪潮下，Python爬虫能否乘风破浪？
                        奔跑吧邓邓子
Python爬虫python爬虫开发语言元宇宙
                        
    【Python爬虫】专栏简介：本专栏是Python爬虫领域的集大成之作，共100章节。从Python基础语法、爬虫入门知识讲起，深入探讨反爬虫、多线程、分布式等进阶技术。以大量实例为支撑，覆盖网页、图片、音频等各类数据爬取，还涉及数据处理与分析。无论是新手小白还是进阶开发者，都能从中汲取知识，助力掌握爬虫核心技能，开拓技术视野。目录一、元宇宙：概念与架构的深度剖析1.1元宇宙概念溯源1.2元宇宙架
    
                    
    • 
                    
  • 【Python爬虫(94)】爬虫生存指南：风险识别与应对策略
                        奔跑吧邓邓子
Python爬虫python爬虫开发语言
                        
    【Python爬虫】专栏简介：本专栏是Python爬虫领域的集大成之作，共100章节。从Python基础语法、爬虫入门知识讲起，深入探讨反爬虫、多线程、分布式等进阶技术。以大量实例为支撑，覆盖网页、图片、音频等各类数据爬取，还涉及数据处理与分析。无论是新手小白还是进阶开发者，都能从中汲取知识，助力掌握爬虫核心技能，开拓技术视野。目录一、爬虫项目中的风险识别1.1反爬虫导致的爬虫失效1.2数据泄露风
    
                    
    • 
                    
  • windows10 ELK保姆级教程以及踩坑记录 适用于新版8.1.3
                        bug柯南
ELKjava
                        
    elk其实就是ElasticSearch（ES）、Logstash和Kibana三个开源的工具组成。1.ES是个开源的分布式搜索引擎，它的特点是：分布式、零配置、自动发现，索引自动分片，索引副本机制，restful风格接口，多数据源，自动搜索负载等。2.Logstash是一个完全开源的工具，开源对日志进行收集、分析、并将其储存以后使用。3.Kibana也是一个完全开源的免费的工具，它为Logsta
    
                    
    • 
                    
  • pytorch与深度学习随记——AlexNet
                        黑色的山岗在沉睡
深度学习随记深度学习pytorch人工智能
                        
    AlexNet和LeNet的设计理念非常相似，但也存在显著差异：基本结构对比网络深度：AlexNet比LeNet-5要深得多，AlexNet由八层组成：五个卷积层、两个全连接隐藏层和一个全连接输出层。激活函数：AlexNet使用ReLU而不是sigmoid作为其激活函数，这有助于缓解梯度消失问题并加速训练过程。AlexNet架构的创新点局部响应归一化(LRN)：AlexNet引入LRN层，可以创建
    
                    
    • 
                    
  • GD32F4xx SD卡读写及FATFS移植记录
                        madao1024
GD32F4xxMCUGD32F4xxSDIOFATFS
                        
      最近调试了一下GD32F450Z的SDIO接口，读写microSD卡并移植了FATFS调试过程记录如下，调试时使用的是16GBKingstonTF卡。说一下思路：分3步实现1、从资料中首先学习一下SDIO接口的相关内容；2、根据例程调通SDcard的读写驱动程序；3、最后移植FATFS文件系统，文件系统来操作SD卡。目录1、GD32F4xxSDIO接口2、GD32F4xxSDIO驱动3、FAT
    
                    
    • 
                    
  • 鸿蒙轻内核M核源码分析系列二一 05 文件系统FatFS
                        愿天堂没有996
OpenHarmony鸿蒙内核移动开发harmonyos鸿蒙开发移动开发鸿蒙内核LiteOS-M鸿蒙源码轻内核
                        
    3、LiteOS-MFATFS的文件系统操作接口快速记录下各个操作接口，对每个接口的用途用法不再描述。可以参考之前的系列文章，《鸿蒙轻内核M核源码分析系列十九MuslLibC》中介绍了相关的接口，那些接口会调用VFS文件系统中操作接口，然后进一步调用FatFS文件操作接口。3.1挂载和卸载操作先看下挂载操作，FatFS支持重新挂载操作。如果挂载选项包含MS_REMOUNT时，会调用函数Remoun
    
                    
    • 
                    
  • 穿越AI边界：深度集成DeepSeek API与云平台的实践之路
                        云边有个稻草人
热门文章人工智能DeepSeek大数据集成DeepSeekAPIDeepSeek算法阿里云百炼平台集成
                        
    云边有个稻草人-CSDN博客随着人工智能技术的日益发展，深度学习和自然语言处理（NLP）已经在很多领域得到了广泛的应用。DeepSeek作为一款领先的大型语言生成模型，凭借其强大的推理和生成能力，已经被越来越多的开发者和行业专家所青睐。通过DeepSeek提供的API接口，开发者可以在多个领域中实现先进的自然语言理解和生成任务。本文将深入探讨如何使用Python调用DeepSeek的API接口，并
    
                    
    • 
                    
  • 从0开始的IMX6ULL学习篇——裸机篇之外设资源分析
                        charlie114514191
从0开始的学习ARMv7aIMX6ULL芯片学习IMX6ULL外设嵌入式硬件
                        
    这个就是现在可以买到之后开发板的模样。我们从最右上角那一处依次逆时针一个个分析。我们跳过显然的电源插孔，拨动开关和3V3与5V的外接板。第一个就是USBHOST接口。USBHost是USB通信协议中的一个重要概念，它指的是控制USB总线数据传输的主端设备。在USB通信中，只能有一个Host，它负责管理整个USB总线上的数据传输。与之相对的是USBDevice或USBSlave，即从设备，它们依赖于
    
                    
    • 
                    
  • Qt 多线程误区：QThread 任务未正确执行及收尾回调未触发的原因分析
                        丰年稻香
QTqt
                        
    问题背景在开发Qt项目时，我们希望并行执行多个任务来提高效率，并在所有任务完成后进行收尾处理。为此，我们使用QThread来执行任务，并在QThread::finished事件触发时调用收尾函数。原始代码voidMyClass::runTaskInThread(void(MyClass::*task)(),void(MyClass::*onFinished)()){QThread*thread=n
    
                    
    • 
                    
  • 智慧医疗伙伴：AI助手与医疗知识库的协同创新
                        LJ_Kindi
人工智能
                        
    在数字化转型的大潮中，医疗行业正以前所未有的速度探索提升医疗服务质量、优化医疗资源配置、加速医学研究的途径。AI助手与医疗知识库的协同创新，作为这一探索过程中的关键驱动力，正逐步成为未来医疗环境中不可或缺的智能伙伴。本文将深入探讨AI助手与医疗知识库在未来医疗环境中的协同创新趋势，特别是在临床决策支持、医学研究激发、疾病风险预警等方面的应用前景。一、临床决策支持：从海量数据到精准医疗在信息爆炸的时
    
                    
    • 
                    
  • 京东Hive SQL面试题实战：APP路径分析场景解析与幽默生存指南
                        数据大包哥
#大厂SQL面试指南hivesqlhadoop
                        
    京东HiveSQL面试题实战：APP路径分析场景解析与幽默生存指南“数据开发工程师的终极浪漫，就是把用户路径写成诗——用HiveSQL押韵。”——某不愿透露姓名的SQL诗人一、题目背景：来自京东的真实需求假设你是京东APP的数据工程师，现在需要分析用户在APP中的访问路径特征。原始日志表user_behavior结构如下：字段名类型说明user_idBIGINT用户ID（脱敏）session_id
    
                    
    • 
                    
  • 腾讯SQL面试题解析：如何找出连续5天涨幅超过5%的股票
                        数据大包哥
#大厂SQL面试指南sql大数据数据库
                        
    腾讯SQL面试题解析：如何找出连续5天涨幅超过5%的股票作者：某七年数据开发工程师|2025年02月23日关键词：SQL窗口函数、连续问题、股票分析、腾讯面试题一、问题背景与难点拆解在股票量化分析场景中，"连续N天满足条件"是高频面试题类型。本题要求在单表stock_data中，筛选出连续5天以上（含）每日涨幅≥5%的股票，并输出连续天数及起止日期。其核心难点在于：涨幅计算：需通过时间窗口函数获取
    
                    
    • 
                    
  • AI在农业中的应用:精准农业的新时代
                        AI大模型应用之禅
DeepSeekR1&AI大模型与大数据计算科学神经计算深度学习神经网络大数据人工智能大型语言模型AIAGILLMJavaPython架构设计AgentRPA
                        
    AI,农业,精准农业,机器学习,深度学习,计算机视觉,农业机器人1.背景介绍农业是人类文明的基石，也是全球经济的重要支柱。然而，随着人口增长和资源短缺，传统农业面临着诸多挑战，例如低效率、资源浪费、环境污染和气候变化的影响。为了应对这些挑战，精准农业应运而生。精准农业是指利用现代信息技术和数据分析手段，对农业生产进行精细化管理，提高资源利用效率、产量和产品质量，同时减少环境污染。人工智能（AI）作
    
                    
    • 
                    
  • MySQL 存储过程详解
                        学堂在线
Mysql数据库mysql数据库
                        
    文章目录1.存储过程定义1.1基本概念1.2核心特点1.3存储过程vs函数2.工作原理与示意图2.1执行流程2.2示意图3.使用场景3.1复杂业务逻辑3.2批量数据处理3.3权限控制3.4性能优化4.示例与说明4.1基础示例：创建存储过程4.2带输出参数的存储过程4.3条件判断与循环4.4事务处理示例5.注意事项5.1性能优化5.2维护复杂性5.3安全性5.4调试与错误处理5.5其他注意事项6.总
    
                    
    • 
                    
  • 使用 Java 更新 Word 文档中的图表数据-超详细
                        Ben_F
javaword开发语言
                        
    使用Java更新Word文档中的图表数据在日常的工作中，尤其是在数据分析和报告自动化的场景中，可能会遇到需要定期更新Word文档中的图表数据的需求。比如，生成数据报告时，我们需要在图表中更新一些动态的数据值。今天，我将展示如何使用Java和ApachePOI库来实现这一功能：自动读取Word文件中的图表，提取Excel数据源，修改数据并更新图表。背景我们要处理的是Word文档中的图表，而这些图表的
    
                    
    • 
                    
  • PHP Captcha实现图片验证码生成及识别（附源码）
                        mayday1102
PHPphpcaptcha
                        
    目录什么是Captchacomposer安装思路修改Captcha.php源码调用什么是CaptchaCAPTCHA（CompletelyAutomatedPublicTuringTesttoTellComputersandHumansApart）是区分计算机和人类的一种程序算法。composer安装composerrequirephp-quickorm/captcha思路由于原扩展基于sessi
    
                    
    • 
                    
  • 表单排版_流程引擎——OA流程表单的认识及优化
                        SchwatzWagen
表单排版
                        
    编辑导语：在工作中经常会遇到流程表单的运用，OA工作流的表单设计器是最常用控件的用法；本文作者分享了工作流引擎流程表单的相关内容，以及对OA流程表单的一些细节优化，我们一起来看一下。现在企业内部产品大多会涉及工作流，不论CRM、OA、WMS、ERP等，都有流程引擎应用的场景。我在工作中一直接触OA，流程表单运用很多，但在之前的使用过程中发现还有些细节可以优化；所以根据应用经验及使用的需求整理了如下
    
                    
    • 
                    
  • 【MySQL】MySQL数据库安装以及报错处理技巧
                        web13688565871
面试学习路线阿里巴巴数据库mysqladb
                        
    前言：本节内容讲述在Ubuntu环境下怎么进行MySQL的安装。以及一些安装过程中遇到的报错如何处理的问题。ps:注意，本篇文章不是图形化界面的MySQL安装教程哦。想要安装图形化界面的MySQL的友友们可以另寻资源了。目录更新软件包列表安装MySQL服务器检查MySQL服务是否启动配置密码重新restartMySQL?编辑删除MySQL报错信息更新软件包列表这里的软件包就类似于centos里面的
    
                    
    • 
                    
  • Dockerfile实战：从代码到容器的自动化构建
                        一碗黄焖鸡三碗米饭
Docker技术之路自动化运维docker
                        
    Dockerfile实战：从代码到容器的自动化构建在现代软件开发中，容器化技术已经成为了一种主流趋势，Docker更是其中的佼佼者。Docker为开发人员提供了一个高效的方式来构建、打包和运行应用程序。而Dockerfile则是Docker镜像构建过程中的核心，作为一份配置文件，Dockerfile让自动化构建Docker镜像成为可能。本文将通过一个实际的案例，深入讲解如何编写Dockerfile
    
                    
    • 
                    
  • FFT去除频率分量的完整流程与数学分析
                        喵喵锤锤你小可爱
pythonFFT数字滤波器通信
                        
    FFT去除频率分量的完整流程与数学分析1.FFT处理的分段本质FFT确实是处理离散时间信号的，一般是对一段采样数据进行分析。在实际应用中，通常会将连续的信号分段处理。每段信号称为“帧”或“窗口”，每帧信号的长度为固定的$N$点。2.如何保证输出的连续性？关键方法a)重叠处理（Overlap）原理：对输入信号分段时，相邻数据块部分重叠（例如50%重叠）。假设块长度为1024，每次新块保留前512点，
    
                    
    • 
                    
  • ave-form.vue 组件中 如何将产品名称发送给后端 ？
                        小丁学Java
产品资质管理系统前端
                        
    如何将产品名称发送给后端。在这段代码中，产品名称（productName）的处理和发送主要发生在save()方法中。让我逐步分析：产品ID的选择：在表单中，用户通过下拉框选择产品，这里的v-model="form.productId"会绑定所选产品的id到form.productId。:list="productList"是产品列表数据，来自getProducts()方法从后端获取的。option
    
                    
    • 
                                
  • 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。 
  
升学考试、工作求职、充电提高，都少不了英语的身影，英语对我们来说实在太重要
    
                                
    •