海涛_meteor
海涛_meteor

Feign调用流程解析

0 前言

本文是对上一篇文章的补完，旨在明确以下问题：

  1. feign如何代理本地方法的调用；
  2. http调用参数是如何设置的；
  3. 注册中心的服务数据是如何与feign关联的；
  4. feign的负载均衡的实现。

1 FeignClient对象注入

上一篇文章说过，@FeignClient注解的对象基于FeignClientFactoryBean注册，那么我们分析feign的调用流程就从这个类开始：

class FeignClientFactoryBean
        implements FactoryBean, InitializingBean, ApplicationContextAware {

    @Override
    public void afterPropertiesSet() throws Exception {
        Assert.hasText(this.contextId, "Context id must be set");
        Assert.hasText(this.name, "Name must be set");
    }
    
    @Override
    public Object getObject() throws Exception {
        return getTarget();
    }
    
    
    @Override
    public Class getObjectType() {
        return this.type;
    }

    @Override
    public boolean isSingleton() {
        return true;
    }
    
    
    @Override
    public void setApplicationContext(ApplicationContext context) throws BeansException {
        this.applicationContext = context;
    }
    
    
    @Override
    public boolean equals(Object o) {
        if (this == o) {
            return true;
        }
        if (o == null || getClass() != o.getClass()) {
            return false;
        }
        FeignClientFactoryBean that = (FeignClientFactoryBean) o;
        return Objects.equals(this.applicationContext, that.applicationContext)
                && this.decode404 == that.decode404
                && Objects.equals(this.fallback, that.fallback)
                && Objects.equals(this.fallbackFactory, that.fallbackFactory)
                && Objects.equals(this.name, that.name)
                && Objects.equals(this.path, that.path)
                && Objects.equals(this.type, that.type)
                && Objects.equals(this.url, that.url);
    }

    @Override
    public int hashCode() {
        return Objects.hash(this.applicationContext, this.decode404, this.fallback,
                this.fallbackFactory, this.name, this.path, this.type, this.url);
    }
        
        ***部分省略***
}


FeignClientFactoryBean实现了FactoryBean接口，那么@FeignClient注解的bean注入时依赖于实现的getObject()方法。从上述源码可以看到该方法调用了getTarget()方法，那么我们来看看getTarget()的具体实现：


     T getTarget() {
        FeignContext context = this.applicationContext.getBean(FeignContext.class);
        Feign.Builder builder = feign(context);

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



1.1 feign(FeignContext context)


首先来看builder的创建，调用了feign(context)，来看一下


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

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



这里涉及两个重要方法get(FeignContext context, Class type)和configureFeign(FeignContext context, Feign.Builder builder)，接着逐一来看一下。


1.1.1 get(FeignContext context, Class type)


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



可以看到调用了context.getInstance(this.contextId, type)，该方法继承自FeignContext的父类NamedContextFactory，来看一下


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



    protected AnnotationConfigApplicationContext getContext(String name) {
        if (!this.contexts.containsKey(name)) {
            synchronized (this.contexts) {
                if (!this.contexts.containsKey(name)) {
                    this.contexts.put(name, createContext(name));
                }
            }
        }
        return this.contexts.get(name);
    }



根据上述两个方法可以看出当在contexts中根据contextId找不到对应实例时，将会调用createContext(name)创建一个加入到contexts中，那么我们来看看createContext(name)方法：


    protected AnnotationConfigApplicationContext createContext(String name) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
        //根据name找出configurations中注册的FeignClient类
        if (this.configurations.containsKey(name)) {
            for (Class configuration : this.configurations.get(name)
                    .getConfiguration()) {
                context.register(configuration);
            }
        }
        //根据default前缀找出configurations中注册的EnableFeignClients类
        for (Map.Entry entry : this.configurations.entrySet()) {
            if (entry.getKey().startsWith("default.")) {
                for (Class configuration : entry.getValue().getConfiguration()) {
                    context.register(configuration);
                }
            }
        }
        context.register(PropertyPlaceholderAutoConfiguration.class,
                this.defaultConfigType);
        context.getEnvironment().getPropertySources().addFirst(new MapPropertySource(
                this.propertySourceName,
                Collections.singletonMap(this.propertyName, name)));
        if (this.parent != null) {
            // Uses Environment from parent as well as beans
            context.setParent(this.parent);
            // jdk11 issue
            // https://github.com/spring-cloud/spring-cloud-netflix/issues/3101
            context.setClassLoader(this.parent.getClassLoader());
        }
        context.setDisplayName(generateDisplayName(name));
        context.refresh();
        return context;
    }



该方法从configurations中分别找到指定的FeignClient注解类和EnableFeignClients注解的类，并注册到context中，返回一个AnnotationConfigApplicationContext类型对象。最终通过context.getBean(type)方法，得到已经创建好的bean对象。


1.1.2 configureFeign(FeignContext context, Feign.Builder builder)


回到feign(FeignContext context)方法中接着来看configureFeign(FeignContext context, Feign.Builder builder)的流程：


    protected void configureFeign(FeignContext context, Feign.Builder builder) {
        FeignClientProperties properties = this.applicationContext
                .getBean(FeignClientProperties.class);
        if (properties != null) {
            if (properties.isDefaultToProperties()) {
                configureUsingConfiguration(context, builder);
                configureUsingProperties(
                        properties.getConfig().get(properties.getDefaultConfig()),
                        builder);
                configureUsingProperties(properties.getConfig().get(this.contextId),
                        builder);
            }
            else {
                configureUsingProperties(
                        properties.getConfig().get(properties.getDefaultConfig()),
                        builder);
                configureUsingProperties(properties.getConfig().get(this.contextId),
                        builder);
                configureUsingConfiguration(context, builder);
            }
        }
        else {
            configureUsingConfiguration(context, builder);
        }
    }



这里主要关注configureUsingConfiguration：


    protected void configureUsingConfiguration(FeignContext context,
            Feign.Builder builder) {
        Logger.Level level = getOptional(context, Logger.Level.class);
        if (level != null) {
            builder.logLevel(level);
        }
        Retryer retryer = getOptional(context, Retryer.class);
        if (retryer != null) {
            builder.retryer(retryer);
        }
        ErrorDecoder errorDecoder = getOptional(context, ErrorDecoder.class);
        if (errorDecoder != null) {
            builder.errorDecoder(errorDecoder);
        }
        Request.Options options = getOptional(context, Request.Options.class);
        if (options != null) {
            builder.options(options);
        }
        Map requestInterceptors = context
                .getInstances(this.contextId, RequestInterceptor.class);
        if (requestInterceptors != null) {
            builder.requestInterceptors(requestInterceptors.values());
        }

        if (this.decode404) {
            builder.decode404();
        }
    }



该方法从context中为builder赋值logLevel、retryer、errorDecoder等属性，这里需要说明的是retryer的默认实现如下所示，即默认关闭重试机制。


    @Bean
    @ConditionalOnMissingBean
    public Retryer feignRetryer() {
        return Retryer.NEVER_RETRY;
    }



1.2 loadBalance(Feign.Builder builder, FeignContext context, HardCodedTarget target)


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



回到getTarget()方法，分析完feign(context)创建builder的流程后，来看上述代码段，该情况对应的是@FeignClient注解没有设置url值，也就是没有设置请求的绝对路径的情况。这种情况下得到的url就是类似http://name这样的值，这就需要调用loadBalance方法来处理，来看一下该方法：


    protected  T loadBalance(Feign.Builder builder, FeignContext context,
            HardCodedTarget target) {
        Client client = getOptional(context, Client.class);
        if (client != null) {
            builder.client(client);
            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?");
    }



可以看到这里得到了一个Client类型的实例，由DefaultFeignLoadBalancedConfiguration类注入，具体源码如下：


@Configuration
class DefaultFeignLoadBalancedConfiguration {

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

}



接着还得到了Targeter类型的实例，该对象上一篇文章中有分析过，根据feign.hystrix.HystrixFeign类存在与否会初始化Targeter为HystrixTargeter或者DefaultTargeter类型，这里为了简化分析暂不考虑Hystrix相关内容，就以DefaultTargeter做为实现进行分析，来看看该类的target(this, builder, context, target)方法做了什么。


    @Override
    public  T target(FeignClientFactoryBean factory, Feign.Builder feign,
            FeignContext context, Target.HardCodedTarget target) {
        return feign.target(target);
    }



调用了Feign.Builder的target方法：


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



那么先来看一下build方法


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



这里主要都是些初始化的工作，创建并返回一个ReflectiveFeign类型的对象，其中Feign.Builder对传入的contract、options和encoder等参数均做了初始化，具体如下：


    private final List requestInterceptors =
        new ArrayList();
    private Logger.Level logLevel = Logger.Level.NONE;
    private Contract contract = new Contract.Default();
    private Client client = new Client.Default(null, null);
    private Retryer retryer = new Retryer.Default();
    private Logger logger = new NoOpLogger();
    private Encoder encoder = new Encoder.Default();
    private Decoder decoder = new Decoder.Default();
    private QueryMapEncoder queryMapEncoder = new QueryMapEncoder.Default();
    private ErrorDecoder errorDecoder = new ErrorDecoder.Default();
    private Options options = new Options();
    private InvocationHandlerFactory invocationHandlerFactory =
        new InvocationHandlerFactory.Default();
    private boolean decode404;
    private boolean closeAfterDecode = true;
    private ExceptionPropagationPolicy propagationPolicy = NONE;



2 代理对象创建


接着来看ReflectiveFeign对象的newInstance方法：


  @Override
  public  T newInstance(Target target) {
    Map nameToHandler = targetToHandlersByName.apply(target);
    Map methodToHandler = new LinkedHashMap();
    List defaultMethodHandlers = new LinkedList();

    for (Method method : target.type().getMethods()) {
      if (method.getDeclaringClass() == Object.class) {
        continue;
      } else if (Util.isDefault(method)) {
        DefaultMethodHandler handler = new DefaultMethodHandler(method);
        defaultMethodHandlers.add(handler);
        methodToHandler.put(method, handler);
      } else {
        methodToHandler.put(method, nameToHandler.get(Feign.configKey(target.type(), method)));
      }
    }
    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;
  }



方法的前半部分主要是通过for循环将nameToHandler中的方法（即@FeignClient注解类下的方法）一一注册到methodToHandler中。


后半部分，熟悉JDK动态代理的话一下就会发现，这里是在通过动态代理方式创建代理对象proxy，至于代理对象的具体实现就要来看下factory.create(target, methodToHandler)了，这里的factory是之前ReflectiveFeign初始化时传入的InvocationHandlerFactory对象，其具体定义为：


public interface InvocationHandlerFactory {
    InvocationHandler create(Target var1, Map var2);

    public static final class Default implements InvocationHandlerFactory {
        public Default() {
        }

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

    public interface MethodHandler {
        Object invoke(Object[] var1) throws Throwable;
    }
}



这里可以看到其create方法的具体实现，跟进来看一下这个FeignInvocationHandler类。


3 代理方法调用


  static class FeignInvocationHandler implements InvocationHandler {

    private final Target target;
    private final Map dispatch;

    FeignInvocationHandler(Target target, Map dispatch) {
      this.target = checkNotNull(target, "target");
      this.dispatch = checkNotNull(dispatch, "dispatch for %s", target);
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
      if ("equals".equals(method.getName())) {
        try {
          Object otherHandler =
              args.length > 0 && args[0] != null ? Proxy.getInvocationHandler(args[0]) : null;
          return equals(otherHandler);
        } catch (IllegalArgumentException e) {
          return false;
        }
      } else if ("hashCode".equals(method.getName())) {
        return hashCode();
      } else if ("toString".equals(method.getName())) {
        return toString();
      }

      return dispatch.get(method).invoke(args);
    }
        
        ***部分省略***
  }



该类继承了InvocationHandler接口，根据jdk的动态代理的实现，该类就是代理的实现类，当调用代理接口的方法，即@FeignClient注解类的方法时，最终都会由该FeignInvocationHandler对象的invoke方法来处理。


3.1 apply(Target key)


可以看到这里的实际业务处理调用的是dispatch.get(method).invoke(args)。这里的dispatch即是之前提到过的methodToHandler对象，其通过targetToHandlersByName.apply(target)创建，来看一下该方法：


    public Map apply(Target key) {
      List metadata = contract.parseAndValidatateMetadata(key.type());
      Map result = new LinkedHashMap();
      for (MethodMetadata md : metadata) {
        BuildTemplateByResolvingArgs buildTemplate;
        if (!md.formParams().isEmpty() && md.template().bodyTemplate() == null) {
          buildTemplate = new BuildFormEncodedTemplateFromArgs(md, encoder, queryMapEncoder);
        } else if (md.bodyIndex() != null) {
          buildTemplate = new BuildEncodedTemplateFromArgs(md, encoder, queryMapEncoder);
        } else {
          buildTemplate = new BuildTemplateByResolvingArgs(md, queryMapEncoder);
        }
        result.put(md.configKey(),
            factory.create(key, md, buildTemplate, options, decoder, errorDecoder));
      }
      return result;
    }
  }



这里返回的是一个map对象，其key为类名加方法名的组合，用于唯一标识一个方法，value通过factory.create(key, md, buildTemplate, options, decoder, errorDecoder)生成，其中根据方法的参数和方法体情况不同会创建不同的buildTemplate。这里的factory是之前通过SynchronousMethodHandler.Factory synchronousMethodHandlerFactory = new SynchronousMethodHandler.Factory(client, retryer, requestInterceptors, logger,logLevel, decode404, closeAfterDecode, propagationPolicy);创建的，我们来看看其create方法


    public MethodHandler create(Target target,
                                MethodMetadata md,
                                RequestTemplate.Factory buildTemplateFromArgs,
                                Options options,
                                Decoder decoder,
                                ErrorDecoder errorDecoder) {
      return new SynchronousMethodHandler(target, client, retryer, requestInterceptors, logger,
          logLevel, md, buildTemplateFromArgs, options, decoder,
          errorDecoder, decode404, closeAfterDecode, propagationPolicy);
    }
  }



最后返回的value值即是一个SynchronousMethodHandler对象，那么dispatch.get(method).invoke(args)调用的就是该对象的invoke方法，来看一下：


  @Override
  public Object invoke(Object[] argv) throws Throwable {
    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;
      }
    }
  }



3.2 executeAndDecode(RequestTemplate template)


该方法实质是创建了一个template对象，然后调用executeAndDecode(template)方法：


  Object executeAndDecode(RequestTemplate template) throws Throwable {
    Request request = targetRequest(template);

    if (logLevel != Logger.Level.NONE) {
      logger.logRequest(metadata.configKey(), logLevel, request);
    }

    Response response;
    long start = System.nanoTime();
    try {
      response = client.execute(request, options);
    } catch (IOException e) {
      if (logLevel != Logger.Level.NONE) {
        logger.logIOException(metadata.configKey(), logLevel, e, elapsedTime(start));
      }
      throw errorExecuting(request, e);
    }
        
        ***部分省略***
}



这里的核心是client.execute(request, options)的调用，因为client是LoadBalancerFeignClient的实例，那么需要看一下它的execute方法：


    @Override
    public Response execute(Request request, Request.Options options) throws IOException {
        try {
            URI asUri = URI.create(request.url());
            String clientName = asUri.getHost();
            URI uriWithoutHost = cleanUrl(request.url(), clientName);
            FeignLoadBalancer.RibbonRequest ribbonRequest = new FeignLoadBalancer.RibbonRequest(
                    this.delegate, request, uriWithoutHost);

            IClientConfig requestConfig = getClientConfig(options, clientName);
            return lbClient(clientName)
                    .executeWithLoadBalancer(ribbonRequest, requestConfig).toResponse();
        }
        
        ***部分省略***
    }



分别来看一下其中最核心的getClientConfig和executeWithLoadBalancer方法


3.2.1 getClientConfig


    IClientConfig getClientConfig(Request.Options options, String clientName) {
        IClientConfig requestConfig;
        if (options == DEFAULT_OPTIONS) {
            requestConfig = this.clientFactory.getClientConfig(clientName);
        }
        else {
            requestConfig = new FeignOptionsClientConfig(options);
        }
        return requestConfig;
    }



这里的clientFactory是SpringClientFactory的实例，其getClientConfig方法为


    public IClientConfig getClientConfig(String name) {
        return getInstance(name, IClientConfig.class);
    }



    @Override
    public  C getInstance(String name, Class type) {
        C instance = super.getInstance(name, type);
        if (instance != null) {
            return instance;
        }
        IClientConfig config = getInstance(name, IClientConfig.class);
        return instantiateWithConfig(getContext(name), type, config);
    }



可以看到其实际调用的是super.getInstance(name, type)，也就是父类NamedContextFactory的getInstance方法，这个方法之前已经分析过了，所以很自然的知道getClientConfig最后返回的是IClientConfig类型的bean对象，该bean的初始化在RibbonClientConfiguration类中，源码如下：


    @Bean
    @ConditionalOnMissingBean
    public IClientConfig ribbonClientConfig() {
        DefaultClientConfigImpl config = new DefaultClientConfigImpl();
        config.loadProperties(this.name);
        config.set(CommonClientConfigKey.ConnectTimeout, DEFAULT_CONNECT_TIMEOUT);
        config.set(CommonClientConfigKey.ReadTimeout, DEFAULT_READ_TIMEOUT);
        config.set(CommonClientConfigKey.GZipPayload, DEFAULT_GZIP_PAYLOAD);
        return config;
    }



这里的DefaultClientConfigImpl类中已经定义好了大部分http请求所需参数，如MaxTotalHttpConnections、PoolKeepAliveTime、MaxAutoRetries等，而从代码也可以看出ConnectTimeout、ReadTimeout和GZipPayload三个参数是单独设置的。


3.2.2 executeWithLoadBalancer


首先lbClient(clientName)返回的是一个FeignLoadBalancer的实例，那么我们重点关注其executeWithLoadBalancer(ribbonRequest, requestConfig)的实现：


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

        try {
            return command.submit(
                new ServerOperation() {
                    @Override
                    public Observable call(Server server) {
                        URI finalUri = reconstructURIWithServer(server, request.getUri());
                        S requestForServer = (S) request.replaceUri(finalUri);
                        try {
                            return Observable.just(AbstractLoadBalancerAwareClient.this.execute(requestForServer, requestConfig));
                        } 
                        catch (Exception e) {
                            return Observable.error(e);
                        }
                    }
                })
                .toBlocking()
                .single();
        
        ***部分省略***
    }



可以看到，这里通过AbstractLoadBalancerAwareClient.this.execute(requestForServer, requestConfig)方法即通过http请求方式获取到请求返回值，由于请求不是我关注的重点暂不深入分析，我关注的是server的获取，那么需要继续分析submit方法（这里开始大量使用了rxjava进行异步编程，暂不做讲解）：


    public Observable submit(final ServerOperation operation) {
        final ExecutionInfoContext context = new ExecutionInfoContext();
        
        ***部分省略***

        // Use the load balancer
        Observable o = 
                (server == null ? selectServer() : Observable.just(server))
                .concatMap(new Func1>() {
                    @Override
                    // Called for each server being selected
                    public Observable call(Server server) {
                        context.setServer(server);
        
        ***部分省略***
    }



方法较长，取了其中为server赋值的一段，可以看到当server为空时，会调用selectServer()进行获取：


    private Observable selectServer() {
        return Observable.create(new OnSubscribe() {
            @Override
            public void call(Subscriber next) {
                try {
                    Server server = loadBalancerContext.getServerFromLoadBalancer(loadBalancerURI, loadBalancerKey);   
                    next.onNext(server);
                    next.onCompleted();
                } catch (Exception e) {
                    next.onError(e);
                }
            }
        });
    }



这里的server由loadBalancerContext.getServerFromLoadBalancer(loadBalancerURI, loadBalancerKey)创建：


    public Server getServerFromLoadBalancer(@Nullable URI original, @Nullable Object loadBalancerKey) throws ClientException {
        String host = null;
        int port = -1;
        if (original != null) {
            host = original.getHost();
        }
        if (original != null) {
            Pair schemeAndPort = deriveSchemeAndPortFromPartialUri(original);        
            port = schemeAndPort.second();
        }

        ILoadBalancer lb = getLoadBalancer();
        if (host == null) {

            if (lb != null){
                Server svc = lb.chooseServer(loadBalancerKey);
                if (svc == null){
                    throw new ClientException(ClientException.ErrorType.GENERAL,
                            "Load balancer does not have available server for client: "
                                    + clientName);
                }
                host = svc.getHost();
                if (host == null){
                    throw new ClientException(ClientException.ErrorType.GENERAL,
                            "Invalid Server for :" + svc);
                }
                logger.debug("{} using LB returned Server: {} for request {}", new Object[]{clientName, svc, original});
                return svc;
                        
        ***部分省略***
    }



该方法操作的核心是lb对象，该对象的allServerList属性包含了从注册中心获取的对应服务的所有地址列表，该实例在RibbonClientConfiguration中初始化：


    @Bean
    @ConditionalOnMissingBean
    public ILoadBalancer ribbonLoadBalancer(IClientConfig config,
            ServerList serverList, ServerListFilter serverListFilter,
            IRule rule, IPing ping, ServerListUpdater serverListUpdater) {
        if (this.propertiesFactory.isSet(ILoadBalancer.class, name)) {
            return this.propertiesFactory.get(ILoadBalancer.class, config, name);
        }
        return new ZoneAwareLoadBalancer<>(config, rule, ping, serverList,
                serverListFilter, serverListUpdater);
    }



顺带一提这里的serverList是注册中心的地址列表，并且其类型根据注册中心不同而有所不同，例如我使用的是Nacos，该类就是NacosServerList的实例。其他注册中心相关内容暂不做深入，所以继续来看lb.chooseServer(loadBalancerKey)：


    @Override
    public Server chooseServer(Object key) {
        if (!ENABLED.get() || getLoadBalancerStats().getAvailableZones().size() <= 1) {
            logger.debug("Zone aware logic disabled or there is only one zone");
            return super.chooseServer(key);
        }
                ***部分省略***
    }



ZoneAwareLoadBalancer支持多区域的负载均衡，但这里我们默认以最常见的单个区域情况进行分析，可以看到调用了父类BaseLoadBalancer的chooseServer方法：


    public Server chooseServer(Object key) {
        if (counter == null) {
            counter = createCounter();
        }
        counter.increment();
        if (rule == null) {
            return null;
        } else {
            try {
                return rule.choose(key);
            } catch (Exception e) {
                logger.warn("LoadBalancer [{}]:  Error choosing server for key {}", name, key, e);
                return null;
            }
        }
    }



这里的rule对象是实现请求负载均衡的核心，其默认的实现为（如需要其他的负载均衡实现需要自行进行IRule的注入）：


    @Bean
    @ConditionalOnMissingBean
    public IRule ribbonRule(IClientConfig config) {
        if (this.propertiesFactory.isSet(IRule.class, name)) {
            return this.propertiesFactory.get(IRule.class, config, name);
        }
        ZoneAvoidanceRule rule = new ZoneAvoidanceRule();
        rule.initWithNiwsConfig(config);
        return rule;
    }



ZoneAvoidanceRule类继承了ClientConfigEnabledRoundRobinRule，因此其本质是实现了轮询规则，其choose方法实现为：


    @Override
    public Server choose(Object key) {
        ILoadBalancer lb = getLoadBalancer();
        Optional server = getPredicate().chooseRoundRobinAfterFiltering(lb.getAllServers(), key);
        if (server.isPresent()) {
            return server.get();
        } else {
            return null;
        }       
    }



主要实现在chooseRoundRobinAfterFiltering方法中：


    public Optional chooseRoundRobinAfterFiltering(List servers, Object loadBalancerKey) {
        List eligible = getEligibleServers(servers, loadBalancerKey);
        if (eligible.size() == 0) {
            return Optional.absent();
        }
        return Optional.of(eligible.get(incrementAndGetModulo(eligible.size())));
    }



到这里就很明确了，该方法通过incrementAndGet方式进行计数以轮询方式从servers中获取可访问的Server对象。


4.总结


通过上述流程的分析基本了解了开篇提出的4个问题，对Feign有了一个大概的了解，也知道了如何对Feign进行一些个性化的配置，但我们知道Feign包含了Ribbon和Hystrix的功能，目前的分析中并未涉及Hystrix，这块也是后面有时间的时候要补上的内容。
























你可能感兴趣的:(Feign调用流程解析)






    

  • 外卖霸王餐返利外卖会员卡小程序开发
闹小艾
good506070微信小程序小程序

    外卖霸王餐返利外卖会员卡小程序开发"社交电商赋能下的外卖返利小程序"是专为商家与用户双赢而设计的创新平台。以下是其开发方案的详细步骤：一、需求梳理：首先，我们需要明确小程序的核心功能和特色。包括设定活动类型、返利策略，以及用户体验友好的界面设计。二、技术决策：技术选型是关键。我们采用小程序的开发框架，利用JavaScript作为前端开发语言，并结合微信提供的API进行后端接口调用与数据处理。三、账
    

    • 

  • ROM修改进阶教程------如何修改固件 线刷转卡刷 卡刷转线刷 操作中的一些注意事项
安卓机器
ROM修改进阶教程卡刷转换线刷线刷转换卡刷固件转换

    在接待各种rom定制化服务中。有很多客户需要各种各样的需求。包括修改rom默认开启usb调试类默认开启开发者选项。修改不锁屏不休眠跳过开机引导以及一些内置app和可卸载app等等的定制项目。还有很多导出系统导出数据完整恢复类要求。今天给大家解析下如何将固件转换类的相关步骤解析通过博文可以了解;1--------线刷固件转换卡刷固件的注意事项以及步骤2--------卡刷固件转换线刷固件的注意事项以
    

    • 

  • nfs服务搭建
GHope

    nfs是什么？基哥度娘网络文件系统(NFS)是sun微系统最初开发的分布式文件系统协议,[1]允许客户端计算机上的用户通过计算机网络访问文件很像本地存储被访问。NFS与许多其他协议一样,在开放网络计算远程过程调用(很久以前RPC)系统上建立。NFS是在请求注释(RFC)中定义的开放标准,允许任何人实现协议。NFSNFS优势：节省本地存储空间，将常用的数据存放在一台NFS服务器上且可以通过网络访问，
    

    • 

  • springcloud — 微服务鉴权管理Spring Security原理解析(二)
RachelHwang
springcloudspringjavaspringsecurityoauth2springcloud

    引言：回顾之前介绍的OAuth2简单分析与介绍，微服务鉴权管理之OAuth2原理解析(一)，前面的部分，我们关注了SpringSecurity是如何完成认证工作的，但是另外一部分核心的内容：过滤器，一直没有提到，我们已经知道SpringSecurity使用了springSecurityFilterChain作为了安全过滤的入口，这一节主要分析一下这个过滤器链都包含了哪些关键的过滤器，并且各自的使命
    

    • 

  • jdbc连接池怎么工作
烟雨国度
java数据库服务器

    是否是否是否开始初始化DruidDataSource应用程序请求连接ThreadLocal中有连接?返回ThreadLocal中的连接从连接池获取新连接将连接存入ThreadLocal执行SQL操作调用closeAll()是否自动提交?归还连接到连接池从ThreadLocal移除连接保持连接不变结束开始事务操作调用begin()设置自动提交为false执行多个SQL操作事务是否成功?调用commi
    

    • 

  • Spring Boot 请求处理流程：从负载均衡到多实例并发 - 电子商务网站实例
烟雨国度
springboot负载均衡后端

    SpringBoot请求处理流程：从负载均衡到多实例并发-电子商务网站实例SpringBoot请求处理流程：从负载均衡到多实例并发SpringBoot作为一个强大的Java应用开发框架，能够有效地处理高并发请求。本文将基于三个关键流程图，详细分析SpringBoot应用如何从负载均衡到请求处理，再到多实例并发处理的整个过程。1.负载均衡和多实例处理首先，让我们看一下描述负载均衡和多实例处理的流程图
    

    • 

  • HTTP 请求处理的完整流程到Servlet流程图
烟雨国度
httpservlet流程图

    HTTP请求处理的完整流程。从TCP三次握手开始，一直到Servlet处理请求并返回响应。首先，让我解释一下response.setContentType("text/html;charset=UTF-8");这行代码：这行代码设置了HTTP响应的Content-Type头。它告诉浏览器：响应的内容类型是HTML(text/html)字符编码是UTF-8(charset=UTF-8)这样浏览器就知
    

    • 

  • 中考数学想考满分？必须刷完这60道经典压轴题！（高清打印版）
孔文教育QD

    孔文教育启东校区距离中考还有30多天的时间，如果平常数学可以考100分左右的同学，就可以重视一下压轴题的提升，老师整理了60道压轴题，包括了考点解析等内容，可以做起来哦！孩子升入初中之后，学习压力逐渐增加，孩子的学习能力以及适应环境的能力决定孩子能够分到哪个层次。中考决定孩子进入普通高中还是职业高中，这是个很现实的问题，经数据研究，中考的普职分流比为1:1，换言之，假设有100个考生，其中就有50
    

    • 

  • Orange Pi编译脚本的分析
点点吃得太多了
linuxlinuxbash

    脚本的运行流程/scripts/main.sh变量设置DEST=“${SRC}”/outputREVISION=“2.2.2”DOWNLOAD_MIRROR==“china”NTP_SERVER=“cn.pool.ntp.org”通过网络校准您计算机上的时钟BUILD_ALLCOLUMNS,LINESTTY_X,TTY_YLANGUAGE=“en_US:en”CONSOLE_CHAR=“UTF-8
    

    • 

  • 深度解析：如何使用输出解析器将大型语言模型（LLM）的响应解析为结构化JSON格式
m0_57781768
语言模型json人工智能

    深度解析：如何使用输出解析器将大型语言模型（LLM）的响应解析为结构化JSON格式在现代自然语言处理（NLP）的应用中，大型语言模型（LLM）已经成为了重要的工具。这些模型能够生成丰富的自然语言文本，适用于各种应用场景。然而，在某些应用中，开发者不仅仅需要生成文本，还需要将这些生成的文本转换为结构化的数据格式，例如JSON。这种结构化的数据格式在数据传输、存储以及进一步处理时具有显著优势。本文将深
    

    • 

  • 深入探讨：如何在Python中通过LangChain技术精准追踪大型语言模型（LLM）的Token使用情况
m0_57781768
pythonlangchain语言模型

    深入探讨：如何在Python中通过LangChain技术精准追踪大型语言模型（LLM）的Token使用情况在现代的人工智能开发中，大型语言模型（LLM）已经成为了不可或缺的工具，无论是用于自然语言处理、对话生成，还是其他复杂的文本生成任务。然而，随着这些模型的广泛应用，开发者面临的一个重要挑战是如何有效地追踪和管理Token的使用情况，特别是在生产环境中，Token的使用直接影响着API调用的成本
    

    • 

  • 2020-07-08在js文件中使用elementUi报错TypeError: _this10.$message is not a function
Kason晨

    问题：全局挂在elementUi后，在js文件内调用，报错_this10.$messageisnotafunction原因：在js文件里找不到this.$message这个属性。#错误的写法：this.$message({message:"解除成功",type:"success"});解决方法（正确写法）：单独引入，和换一种方法使用：//引入import{Message}from"element-
    

    • 

  • Open Feign 实战笔记
自强-X
spring-cloudjavaspring微服务ribbonspringcloud

    OpenFeign笔记概念声明式的web服务客户端。使用接口加注解的形式编程。它是对RestTemplate和ribbon做了进一步封装。Feign已经停更，OpenFeign是在Feign的基础上又做了进一步的封装。Feign：Feign是SpringCloud组件中的一个轻量级RESTful的HTTP服务客户端Feign内置了Ribbon，用来做客户端负载均衡，去调用服务注册中心的服务。Fei
    

    • 

  • 2019 11.30
杜永鹏

    体验：工作中流程很重要，不能因为忙而不按照流程干！按照流程干事才不会出错！核心：有流程，有标准！工作一定能做好！
    

    • 

  • Spring Cloud: Hystrix请求队列线程不足
MeazZa

    在SpringCloud中，Feign可以实现本地化的微服务API调用，Hystrix可以实现调用失败时的fallback处理。问题描述：在实际生产环境中使用时，我们遇到了这样一个错误："...,stacktrace:[com.netflix.hystrix.exception.HystrixRuntimeException:QueryNodeImpalaBdService#getQueryRes
    

    • 

  • 11.20晨间感恩日记
夜宁

    1.今天周六，但是其实也没有什么周末的概念了，无非是早上起来冥想，洗漱，喂猫，吃饭，刷碗，扫地墩地，顺便看看最近热播的电视剧，然后就10点钟了。虽然日常流程是这个样子，仿若每天都是一个样子，但是生活还是可以觉得很有意思。比如冥想的时候，虽然断了一阵子，但是再度开始的时候会清晰的发现冥想会让自己静下来，也更能明了自己想要的是什么，不至于浑浑噩噩，什么都想抓到。早上的空气很是清凉，出了院子，不自觉的就
    

    • 

  • Servlet容器的作用、HttpServlet的工作机制流程图
烟雨国度
servlet流程图hive

    HttpServletRequest解析过程是否GETPOST其他方法Servlet生命周期init-初始化Servletservice-处理请求destroy-销毁ServletgetMethod返回HTTP方法getRequestURI返回请求URIgetQueryString返回查询字符串getParameter返回特定参数值客户端发送HTTP请求服务器接收请求Web容器创建ServletR
    

    • 

  • 探索未来，大规模分布式深度强化学习——深入解析IMPALA架构
汤萌妮Margaret

    探索未来，大规模分布式深度强化学习——深入解析IMPALA架构scalable_agent项目地址:https://gitcode.com/gh_mirrors/sc/scalable_agent在当今的人工智能研究前沿，深度强化学习（DRL）因其在复杂任务中的卓越表现而备受瞩目。本文要介绍的是一个开源于GitHub的重量级项目：“ScalableDistributedDeep-RLwithImp
    

    • 

  • 全面指南：用户行为从前端数据采集到实时处理的最佳实践
数字沉思
营销流量运营系统架构前端内容运营大数据

    引言在当今的数据驱动世界，实时数据采集和处理已经成为企业做出及时决策的重要手段。本文将详细介绍如何通过前端JavaScript代码采集用户行为数据、利用API和Kafka进行数据传输、通过Flink实时处理数据的完整流程。无论你是想提升产品体验还是做用户行为分析，这篇文章都将为你提供全面的解决方案。设计一个通用的ClickHouse表来存储用户事件时，需要考虑多种因素，包括事件类型、时间戳、用户信
    

    • 

  • Python 模块导入方式
小丫头呀
#Python随笔python开发语言

    在Python中，导入外部模块有2种方式以Pyhton自带的time模块为例：使用importtime导入方式importtimeprint(time.ctime())注意事项：time模块导入后，使用以下格式来调用模块中的函数:模块名.函数名如果导入的模块名称很长，可以使用as也就是别名的方式，给模块取个自定义的别名。例如：importtimeast;使用示例：t.ctime()使用fromti
    

    • 

  • 【Python】np.hstack()和np.vstack函数详解和示例
木彳
Python学习和使用过程积累python开发语言

    本文通过函数原理和运行示例，对np.hstack()和np.vstack函数进行详解，以帮助大家理解和使用。更多Numpy函数详解和示例，可参考【Python】Numpy库近50个常用函数详解和示例，可作为工具手册使用目录np.hstack()函数解析运行示例一维数组二维数组np.vstack()函数解析运行示例np.hstack()np.hstack()是NumPy库中的一个函数，用于将两个或更
    

    • 

  • 我是谜《最后的自白》剧本杀剧透+真相答案复盘解析攻略
VX搜_奶茶剧本杀

    本文为我是谜《最后的自白》剧本杀测评+部分真相复盘，获取完整真相复盘只需两步：①、关注微信公众号【奶茶剧本杀】→②、回复我是谜《最后的自白》即可获取查看我是谜《最后的自白》剧本杀真相答案复盘+凶手剧透：以下是玩家评测+部分关键证据，凶手，时间线，复盘解析，推理逻辑--------------------------------------------------------------------
    

    • 

  • 怎样使用淘宝优惠券？全面解析优惠券使用技巧
氧惠_飞智666999

    在数字化的购物时代，淘宝优惠券已经成为我们享受购物优惠的重要途径。然而，许多消费者在领取了优惠券后，却不知如何正确使用，导致优惠券的价值无法得到充分发挥。那么，怎样使用淘宝优惠券呢？本文将为您全面解析优惠券的使用技巧，助您轻松享受购物优惠。首先，我们需要了解优惠券的来源。淘宝优惠券可以通过多种途径获取，如淘宝官方活动页面、店铺首页、品牌官方账号等。同时，一些第三方平台也会提供淘宝优惠券的领取服务。
    

    • 

  • 剧本杀《白夜》剧本杀剧透+真相答案复盘解析攻略
VX搜_奶茶剧本杀

    本文为剧本杀《白夜》剧本杀测评+部分真相复盘，获取完整真相复盘只需两步：①、关注微信公众号【奶茶剧本杀】→②、回复剧本杀《白夜》即可获取查看剧本杀《白夜》剧本杀真相答案复盘+凶手剧透：以下是玩家评测+部分关键证据，凶手，时间线，复盘解析，推理逻辑------------------------------------------------------------------------剧本杀《白
    

    • 

  • Quartus II SDC文件建立流程
cattao1989
verilog

    QuartusIISDC文件编写教程第一步：打开TimeQuestTimingAnalyzer，也可以点击图中1所示图标。第二步：点击Netlist,点击CreateTimingNetlist第三步：按照下图所示选择。
    

    • 

  • Quartus sdc UI界面设置（二）
落雨无风
IC设计fpgafpga开发

    Quartussdc设置根据一配置quartus综合简单流程（一）上次文章中，说了自己写sdc需要配置的分类点，这次将说明在UI界面配置sdc。1.在Quartus软件中，导入verilog设计之后，打开Tools/TimeQuestTimingAnalyzer界面大致分为上下两部分，上半部分左侧显示Report、Tasks，右侧显示欢迎界面；下半部分显示Console和History，此处缺图，
    

    • 

  • 【Python】【Opencv】cv2.findContours()、cv2.drawContours()和cv2.contourArea()函数详解和运行示例
木彳
Python学习和使用过程积累pythonopencv开发语言人工智能计算机视觉

    为帮助大家理解和使用cv2.findContours()、cv2.drawContours()和cv2.contourArea()函数，本文通过对函数内容进行详解，并通过运行示例更直观表述。函数解析cv2.findContours()cv2.drawContours()cv2.contourArea()运行示例运行示例示例详解函数解析cv2.findContours()cv2.findContou
    

    • 

  • ⭐Unity 安卓环境中正确地读取和处理 XML 文件
惊鸿醉
Unityunityandroidxml

    写了一个选择题Demo，电脑包和编辑器内无问题，但是打包安卓手机之后题目无法正常使用，想到的是安卓环境中正确地读取文件的问题改进方案：1.由于XmlDocument.Load方法在Android上的路径问题（由于文件位于APK内部，无法像在文件系统中那样直接访问），需要先使用UnityWebRequest来异步加载文件内容，然后再解析XML。2.异步处理：修改你的代码，以支持异步文件加载和处理，这
    

    • 

  • 数字化供应链架构、全景管理、全流程贯通整体解决方案：供应链管理就是利用管理工具、IT技术将企业引入外部资源的过程精细化、标准化管理，实现高效益低成本运营。
数字化建设方案
数字化转型数据治理主数据数据仓库智能制造数字工厂制造业数字化转型工业互联网供应链数字仓储智慧物流智慧仓储物流园区架构大数据

    数字化供应链架构、全景管理、全流程贯通方案数字化供应链架构、全景管理、全流程贯通方案项目背景与目标供应链管理现状及挑战数字化供应链架构概念及优势全景管理与全流程贯通目标预期成果与效益智能管理机制建设需求预测与智能分析应用合同管理智能化提升举措仓储管理自动化和机器人技术应用物流配送优化策略周边系统整合与数据贯通现有系统梳理及评估报告数据接口标准制定和实施计划流程对接和数据交互机制设计监控和报警机制完
    

    • 

  • 【数字化供应链】数字化供应链架构、全景管理、全流程贯通方案
数字化建设方案
数字化转型数据治理主数据数据仓库供应链数字仓储智慧物流智慧仓储物流园区架构微服务数据挖掘大数据人工智能

    原文《数字化供应链架构、全景管理、全流程贯通方案》PPT格式。主要从供应链管理全景、智慧供应链建设总体目标、供应链总体业务流程、供应链总体功能架构、供应链总体技术架构、供应链全流程贯通、供应链全领域管理、供应链数据数据分析、供应链决策中台等进行建设。本文仅对主要内容进行介绍。来源网络公开渠道，旨在交流学习，如有侵权联系速删，更多参考公众号：优享智库基于先进IT技术、大数据能力、物联网应用、区块链平
    

    • 

  • [星球大战]阿纳金的背叛
comsci

    
      本来杰迪圣殿的长老是不同意让阿纳金接受训练的.........
    但是由于政治原因,长老会妥协了...这给邪恶的力量带来了机会
    所以......现代的地球联邦接受了这个教训...绝对不让某些年轻人进入学院
   
    

    • 

  • 看懂它，你就可以任性的玩耍了！
aijuans
JavaScript

              javascript作为前端开发的标配技能，如果不掌握好它的三大特点：1.原型 2.作用域 3. 闭包 ,又怎么可以说你学好了这门语言呢？如果标配的技能都没有撑握好，怎么可以任性的玩耍呢？怎么验证自己学好了以上三个基本点呢，我找到一段不错的代码，稍加改动，如果能够读懂它，那么你就可以任性了。
function jClass(b
    

    • 

  • Java常用工具包 Jodd
Kai_Ge
javajodd

    Jodd 是一个开源的 Java 工具集， 包含一些实用的工具类和小型框架。简单，却很强大！ 写道 Jodd = Tools + IoC + MVC + DB + AOP + TX + JSON + HTML < 1.5 Mb
Jodd 被分成众多模块，按需选择，其中
工具类模块有：
jodd-core    &nb
    

    • 

  • SpringMvc下载
120153216
springMVC

    @RequestMapping(value = WebUrlConstant.DOWNLOAD)
public void download(HttpServletRequest request,HttpServletResponse response,String fileName) {
OutputStream os = null;
InputStream is = null; 
    

    • 

  • Python 标准异常总结
2002wmj
python

    Python标准异常总结
AssertionError 断言语句（assert）失败 AttributeError 尝试访问未知的对象属性 EOFError 用户输入文件末尾标志EOF（Ctrl+d） FloatingPointError 浮点计算错误 GeneratorExit generator.close()方法被调用的时候 ImportError 导入模块失
    

    • 

  • SQL函数返回临时表结构的数据用于查询
357029540
SQL Server

    这两天在做一个查询的SQL，这个SQL的一个条件是通过游标实现另外两张表查询出一个多条数据，这些数据都是INT类型，然后用IN条件进行查询，并且查询这两张表需要通过外部传入参数才能查询出所需数据，于是想到了用SQL函数返回值，并且也这样做了，由于是返回多条数据，所以把查询出来的INT类型值都拼接为了字符串，这时就遇到问题了，在查询SQL中因为条件是INT值，SQL函数的CAST和CONVERST都
    

    • 

  • java 时间格式化 | 比较大小| 时区 个人笔记
7454103
javaeclipsetomcatcMyEclipse

    个人总结！ 不当之处多多包含！
引用 1.0 如何设置 tomcat 的时区：
         位置：(catalina.bat---JAVA_OPTS  下面加上)
         set JAVA_OPT
    

    • 

  • 时间获取Clander的用法
adminjun
Clander时间

    /**
   * 得到几天前的时间
   * @param d
   * @param day
   * @return
   */
  public static Date getDateBefore(Date d,int day){
   Calend
    

    • 

  • JVM初探与设置
aijuans
java

    JVM是Java Virtual Machine（Java虚拟机）的缩写，JVM是一种用于计算设备的规范，它是一个虚构出来的计算机，是通过在实际的计算机上仿真模拟各种计算机功能来实现的。Java虚拟机包括一套字节码指令集、一组寄存器、一个栈、一个垃圾回收堆和一个存储方法域。 JVM屏蔽了与具体操作系统平台相关的信息，使Java程序只需生成在Java虚拟机上运行的目标代码（字节码）,就可以在多种平台
    

    • 

  • SQL中ON和WHERE的区别
avords

    SQL中ON和WHERE的区别  
数据库在通过连接两张或多张表来返回记录时，都会生成一张中间的临时表，然后再将这张临时表返回给用户。   www.2cto.com   在使用left jion时，on和where条件的区别如下：  1、 on条件是在生成临时表时使用的条件，它不管on中的条件是否为真，都会返回左边表中的记录。  
    

    • 

  • 说说自信
houxinyou
工作生活

    自信的来源分为两种,一种是源于实力,一种源于头脑.实力是一个综合的评定,有自身的能力,能利用的资源等.比如我想去月亮上,要身体素质过硬,还要有飞船等等一系列的东西.这些都属于实力的一部分.而头脑不同,只要你头脑够简单就可以了!同样要上月亮上,你想,我一跳,1米,我多跳几下,跳个几年,应该就到了!什么?你说我会往下掉?你笨呀你!找个东西踩一下不就行了吗?
 
 
无论工作还
    

    • 

  • WEBLOGIC事务超时设置
bijian1013
weblogicjta事务超时

            系统中统计数据，由于调用统计过程，执行时间超过了weblogic设置的时间，提示如下错误：
统计数据出错!
原因：The transaction is no longer active - status: 'Rolling Back. [Reason=weblogic.transaction.internal
    

    • 

  • 两年已过去，再看该如何快速融入新团队
bingyingao
java互联网融入架构新团队

    偶得的空闲，翻到了两年前的帖子
该如何快速融入一个新团队，有所感触，就记下来，为下一个两年后的今天做参考。
    时隔两年半之后的今天，再来看当初的这个博客，别有一番滋味。而我已经于今年三月份离开了当初所在的团队，加入另外的一个项目组，2011年的这篇博客之后的时光，我很好的融入了那个团队，而直到现在和同事们关系都特别好。大家在短短一年半的时间离一起经历了一
    

    • 

  • 【Spark七十七】Spark分析Nginx和Apache的access.log
bit1129
apache

    Spark分析Nginx和Apache的access.log，第一个问题是要对Nginx和Apache的access.log文件进行按行解析，按行解析就的方法是正则表达式：
 
Nginx的access.log解析正则表达式
 
val PATTERN = """([^ ]*) ([^ ]*) ([^ ]*) (\\[.*\\]) (\&q
    

    • 

  • Erlang patch
bookjovi
erlang

    Totally five patchs committed to erlang otp, just small patchs.
IMO, erlang really is a interesting programming language, I really like its concurrency feature.
but the functional programming style 
    

    • 

  • log4j日志路径中加入日期
bro_feng
javalog4j

    要用log4j使用记录日志，日志路径有每日的日期，文件大小5M新增文件。
实现方式
log4j:
<appender name="serviceLog"
class="org.apache.log4j.RollingFileAppender">
<param name="Encoding" v
    

    • 

  • 读《研磨设计模式》-代码笔记-桥接模式
bylijinnan
java设计模式

    声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/
/**
* 个人觉得关于桥接模式的例子，蜡笔和毛笔这个例子是最贴切的：http://www.cnblogs.com/zhenyulu/articles/67016.html
* 笔和颜色是可分离的，蜡笔把两者耦合在一起了：一支蜡笔只有一种
    

    • 

  • windows7下SVN和Eclipse插件安装
chenyu19891124
eclipse插件

    今天花了一天时间弄SVN和Eclipse插件的安装，今天弄好了。svn插件和Eclipse整合有两种方式，一种是直接下载插件包，二种是通过Eclipse在线更新。由于之前Eclipse版本和svn插件版本有差别，始终是没装上。最后在网上找到了适合的版本。所用的环境系统：windows7JDK：1.7svn插件包版本：1.8.16Eclipse：3.7.2工具下载地址：Eclipse下在地址：htt
    

    • 

  • [转帖]工作流引擎设计思路
comsci
设计模式工作应用服务器workflow企业应用

     作为国内的同行，我非常希望在流程设计方面和大家交流，刚发现篇好文(那么好的文章，现在才发现，可惜)，关于流程设计的一些原理，个人觉得本文站得高，看得远，比俺的文章有深度，转载如下
=================================================================================
自开博以来不断有朋友来探讨工作流引擎该如何
    

    • 

  • Linux 查看内存，CPU及硬盘大小的方法
daizj
linuxcpu内存硬盘大小

    一、查看CPU信息的命令
[root@R4 ~]# cat /proc/cpuinfo |grep "model name" && cat /proc/cpuinfo |grep "physical id"
model name : Intel(R) Xeon(R) CPU X5450 @ 3.00GHz
model name : 
    

    • 

  • linux 踢出在线用户
dongwei_6688
linux

    两个步骤：
1.用w命令找到要踢出的用户，比如下面：
 
[root@localhost ~]# w
18:16:55 up 39 days, 8:27, 3 users, load average: 0.03, 0.03, 0.00
USER TTY FROM LOGIN@ IDLE JCPU PCPU WHAT
    

    • 

  • 放手吧,就像不曾拥有过一样
dcj3sjt126com

    内容提要：
静悠悠编著的《放手吧就像不曾拥有过一样》集结“全球华语世界最舒缓心灵”的精华故事，触碰生命最深层次的感动，献给全世界亿万读者。《放手吧就像不曾拥有过一样》的作者衷心地祝愿每一位读者都给自己一个重新出发的理由，将那些令你痛苦的、扛起的、背负的，一并都放下吧！把憔悴的面容换做一种清淡的微笑，把沉重的步伐调节成春天五线谱上的音符，让自己踏着轻快的节奏，在人生的海面上悠然漂荡，享受宁静与
    

    • 

  • php二进制安全的含义
dcj3sjt126com
PHP

    PHP里，有string的概念。
string里，每个字符的大小为byte（与PHP相比，Java的每个字符为Character，是UTF8字符，C语言的每个字符可以在编译时选择）。
byte里，有ASCII代码的字符，例如ABC，123，abc，也有一些特殊字符，例如回车，退格之类的。
特殊字符很多是不能显示的。或者说，他们的显示方式没有标准，例如编码65到哪儿都是字母A，编码97到哪儿都是字符
    

    • 

  • Linux下禁用T440s，X240的一体化触摸板(touchpad)
gashero
linuxThinkPad触摸板

    自打1月买了Thinkpad T440s就一直很火大，其中最让人恼火的莫过于触摸板。
 
Thinkpad的经典就包括用了小红点(TrackPoint)。但是小红点只能定位，还是需要鼠标的左右键的。但是自打T440s等开始启用了一体化触摸板，不再有实体的按键了。问题是要是好用也行。
 
实际使用中，触摸板一堆问题，比如定位有抖动，以及按键时会有飘逸。这就导致了单击经常就
    

    • 

  • graph_dfs
hcx2013
Graph

    package edu.xidian.graph;
class MyStack {
private final int SIZE = 20;
private int[] st;
private int top;
public MyStack() {
st = new int[SIZE];
top = -1;
}
public void push(i
    

    • 

  • Spring4.1新特性——Spring核心部分及其他
jinnianshilongnian
spring 4.1

    目录
Spring4.1新特性——综述
Spring4.1新特性——Spring核心部分及其他
Spring4.1新特性——Spring缓存框架增强
Spring4.1新特性——异步调用和事件机制的异常处理
Spring4.1新特性——数据库集成测试脚本初始化
Spring4.1新特性——Spring MVC增强
Spring4.1新特性——页面自动化测试框架Spring MVC T
    

    • 

  • 配置HiveServer2的安全策略之自定义用户名密码验证
liyonghui160com

     
 
具体从网上看
 
http://doc.mapr.com/display/MapR/Using+HiveServer2#UsingHiveServer2-ConfiguringCustomAuthentication
 
LDAP Authentication using OpenLDAP
Setting 
    

    • 

  • 一位30多的程序员生涯经验总结
pda158
编程工作生活咨询

    1.客户在接触到产品之后，才会真正明白自己的需求。
　　这是我在我的第一份工作上面学来的。只有当我们给客户展示产品的时候，他们才会意识到哪些是必须的。给出一个功能性原型设计远远比一张长长的文字表格要好。 2.只要有充足的时间，所有安全防御系统都将失败。
　　安全防御现如今是全世界都在关注的大课题、大挑战。我们必须时时刻刻积极完善它，因为黑客只要有一次成功，就可以彻底打败你。   3.
    

    • 

  • 分布式web服务架构的演变
自由的奴隶
linuxWeb应用服务器互联网

    最开始，由于某些想法，于是在互联网上搭建了一个网站，这个时候甚至有可能主机都是租借的，但由于这篇文章我们只关注架构的演变历程，因此就假设这个时候已经是托管了一台主机，并且有一定的带宽了，这个时候由于网站具备了一定的特色，吸引了部分人访问，逐渐你发现系统的压力越来越高，响应速度越来越慢，而这个时候比较明显的是数据库和应用互相影响，应用出问题了，数据库也很容易出现问题，而数据库出问题的时候，应用也容易
    

    • 

  • 初探Druid连接池之二——慢SQL日志记录
xingsan_zhang
日志连接池druid慢SQL

    由于工作原因，这里先不说连接数据库部分的配置，后面会补上，直接进入慢SQL日志记录。
 
1.applicationContext.xml中增加如下配置：
<bean abstract="true" id="mysql_database" class="com.alibaba.druid.pool.DruidDataSourc
    

    •