详谈Feign的配置类是如何生效的

说明，该源码部分只是个人总结，随手记录，不保证正确性；

该源码关注的不是底层Feign是如何完成远程调用的具体细节，而关注在Feign在完成远程调用之前的准备工作，他的一些配置是如何生效的；看完之后对Spring的ImportBeanDefinitionRegistrar接口比之前的理解更加深了，而且想玩自定义注解提供扩展功能的，熟悉了Feign的几个流程之后还是能够提供很大的指导意见的；

1. Feign

特别说明一下，是在使用了Ribbon的基础上加入了Feign的研读，不确定Ribbon是否会对Feign有影响

1.1 配置类：ApiConfiguration.java

@Configuration
@EnableAspectJAutoProxy
@EnableFeignClients(basePackages = "com.sinotrans.hd.microservice.api.feign")
public class ApiConfiguration {
}

重点来看一下@EnableFeignClients做了哪些事情，除了该注解本身提供的属性配置外，可以看到还导入了一个配置类FeignClientsRegistrar

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Documented
@Import(FeignClientsRegistrar.class)
public @interface EnableFeignClients {
}

1.2 FeignClientsRegistrar

现在来看一下FeignClientsRegistrar做了什么事情，该类实现了Spring的众多接口，ImportBeanDefinitionRegistrar接口，简单点说该接口提供了可以给容器动态注入Bean的功能，ResourceLoaderAware可以获得容器资源依赖，BeanClassLoaderAware提供Bean的回调功能，EnvironmentAware获得当前应用的环境变量信息

class FeignClientsRegistrar implements ImportBeanDefinitionRegistrar,
  ResourceLoaderAware, BeanClassLoaderAware, EnvironmentAware {
    @Override
    public void registerBeanDefinitions(AnnotationMetadata metadata,
            BeanDefinitionRegistry registry) {
        registerDefaultConfiguration(metadata, registry);
        registerFeignClients(metadata, registry);
    }
｝

先看一下第一个方法registerDefaultConfiguration(),代码如下,

    private void registerDefaultConfiguration(AnnotationMetadata metadata,
            BeanDefinitionRegistry registry) {
        Map defaultAttrs = metadata
                .getAnnotationAttributes(EnableFeignClients.class.getName(), true);
        if (defaultAttrs != null && defaultAttrs.containsKey("defaultConfiguration")) {
            String name;
            if (metadata.hasEnclosingClass()) {
                name = "default." + metadata.getEnclosingClassName();
            }
            else {
                name = "default." + metadata.getClassName();
            }
            registerClientConfiguration(registry, name,
                    defaultAttrs.get("defaultConfiguration"));
        }
    }

defaultAttrs，先获得当前配置类的注解@EnableFeignClients类的全部属性，目前能够获取到在前面配置的属性basePackages = "com.sinotrans.hd.microservice.api.feign",再往下判断属性是否为空，是否包含defaultConfiguration，程序往下走，目前属性不为空且包含defaultConfiguration，hasEnclosingClass()判断当前注解类是否是内部类，如果是内部类，则使用default. + 顶级类名，否则使用default. + 自己的类名，当前name=default.com.sinotrans.hd.microservice.api.config.ApiConfiguration

registerClientConfiguration()方法，内部代码如下

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

第一行首先预定义一个org.springframework.cloud.netflix.feign.FeignClientSpecification类型的Bean信息，通过构造方法设置FeignClientSpecification的name和configuration类，结合上面name属性的设置，定义的这个Bean的名称为default.com.sinotrans.hd.microservice.api.config.ApiConfiguration.FeignClientSpecification，调用FeignClientSpecification的构造方法来初始化这个类

FeignClientSpecification.java

class FeignClientSpecification implements NamedContextFactory.Specification {
    public FeignClientSpecification(String name, Class[] configuration) {
        this.name = name;
        this.configuration = configuration;
    }
}

现在来看一下registerFeignClients(metadata, registry);方法源码如下：

    public void registerFeignClients(AnnotationMetadata metadata,
            BeanDefinitionRegistry registry) {
        ClassPathScanningCandidateComponentProvider scanner = getScanner();
        scanner.setResourceLoader(this.resourceLoader);
        Set basePackages;
        Map attrs = metadata
                .getAnnotationAttributes(EnableFeignClients.class.getName());
        AnnotationTypeFilter annotationTypeFilter = new AnnotationTypeFilter(
                FeignClient.class);
        final Class[] clients = attrs == null ? null
                : (Class[]) attrs.get("clients");
        if (clients == null || clients.length == 0) {
            scanner.addIncludeFilter(annotationTypeFilter);
            basePackages = getBasePackages(metadata);
        }
        else {
            final Set clientClasses = new HashSet<>();
            basePackages = new HashSet<>();
            for (Class clazz : clients) {
                basePackages.add(ClassUtils.getPackageName(clazz));
                clientClasses.add(clazz.getCanonicalName());
            }
            AbstractClassTestingTypeFilter filter = new AbstractClassTestingTypeFilter() {
                @Override
                protected boolean match(ClassMetadata metadata) {
                    String cleaned = metadata.getClassName().replaceAll("\\$", ".");
                    return clientClasses.contains(cleaned);
                }
            };
            scanner.addIncludeFilter(
                    new AllTypeFilter(Arrays.asList(filter, annotationTypeFilter)));
        }
        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);
                    registerClientConfiguration(registry, name,
                            attributes.get("configuration"));
                    registerFeignClient(registry, annotationMetadata, attributes);
                }
            }
        }
    }

① 这个方法的代码有点长，首先获得包扫描类，获得系统资源加载类，然后获得配置类的@EnableFeignClients注解的所有属性，定义一个匹配FeignClient的过滤器，clients属性，则是判断当前@EnableFeignClients是否有配置过clients属性，该属性的作用是明确指定标注了@FeignClient注解的接口类，如果配置了这个属性，则类路径扫描会被禁用，则basePackages扫描包路径的值会将clients属性的接口类所在的包加入扫描路径，否则使用类路径扫描。当前使用类路径扫描；clients的值一旦为空或长度为0，那么则包扫描规则加入一个includeFilters规则为只扫描带@FeignClient注解的类,packageSearchPath=classpath*:com/sinotrans/hd/microservice/api/feign/**/*.class

② findCandidateComponents()方法循环包扫描路径，查找指定包路径下符合条件的class，然后作为BeanDefinition集合返回，代码如下

    /**
     * Scan the class path for candidate components.
     * @param basePackage the package to check for annotated classes
     * @return a corresponding Set of autodetected bean definitions
     */
    public Set findCandidateComponents(String basePackage) {
        Set candidates = new LinkedHashSet();
        try {
            String packageSearchPath = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX +
                    resolveBasePackage(basePackage) + '/' + this.resourcePattern;
            Resource[] resources = this.resourcePatternResolver.getResources(packageSearchPath);
            boolean traceEnabled = logger.isTraceEnabled();
            boolean debugEnabled = logger.isDebugEnabled();
            for (Resource resource : resources) {
                if (traceEnabled) {
                    logger.trace("Scanning " + resource);
                }
                if (resource.isReadable()) {
                    try {
                        MetadataReader metadataReader = this.metadataReaderFactory.getMetadataReader(resource);
                        if (isCandidateComponent(metadataReader)) {
                            ScannedGenericBeanDefinition sbd = new ScannedGenericBeanDefinition(metadataReader);
                            sbd.setResource(resource);
                            sbd.setSource(resource);
                            if (isCandidateComponent(sbd)) {
                                if (debugEnabled) {
                                    logger.debug("Identified candidate component class: " + resource);
                                }
                                candidates.add(sbd);
                            }
                            else {
                                if (debugEnabled) {
                                    logger.debug("Ignored because not a concrete top-level class: " + resource);
                                }
                            }
                        }
                        else {
                            if (traceEnabled) {
                                logger.trace("Ignored because not matching any filter: " + resource);
                            }
                        }
                    }
                    catch (Throwable ex) {
                        throw new BeanDefinitionStoreException(
                                "Failed to read candidate component class: " + resource, ex);
                    }
                }
                else {
                    if (traceEnabled) {
                        logger.trace("Ignored because not readable: " + resource);
                    }
                }
            }
        }
        catch (IOException ex) {
            throw new BeanDefinitionStoreException("I/O failure during classpath scanning", ex);
        }
        return candidates;
    }

③ 循环返回的candidateComponents，而且类型必须为AnnotatedBeanDefinition并且必须是接口，然后获得该接口上的@FeignClient注解的属性，包含服务名，和请求上下文（包含上下文和控制层的RequestMapping），内容如下

④ 通过方法getClientName()获取服务名，可以看到服务名的规则是value > name > serviceId依次去取，直到取不到抛出异常

   private String getClientName(Map client) {
        if (client == null) {
            return null;
        }
        String value = (String) client.get("value");
        if (!StringUtils.hasText(value)) {
            value = (String) client.get("name");
        }
        if (!StringUtils.hasText(value)) {
            value = (String) client.get("serviceId");
        }
        if (StringUtils.hasText(value)) {
            return value;
        }
        throw new IllegalStateException("Either 'name' or 'value' must be provided in @"
                + FeignClient.class.getSimpleName());
    }

⑤ registerClientConfiguration()方法将服务名注册成FeignClientSpecification类型的Bean放入预定义Bean容器，名称为服务名"." + FeignClientSpecification.class.getSimpleName()，同时也将服务名和配置类分别通过构造方法赋值给FeignClientSpecification的name和configuration属性，每个服务所需要引用的接口类有多个，所以这里可能会重复注册registerClientConfiguration，因为这里只是定义信息，所以应该是hi后来的会覆盖之前的吧。所以最终注入的应当是服务名去重后的数量，注入的时候也应当使用集合来接收注入，这个在后面会碰到；所以到了这里加上之前定义的默认的配置类生成的FeignClientSpecification，目前一共会有（）服务数 + 配置类默认生成的）个FeignClientSpecification

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

⑥ registerFeignClient()方法，首先通过BeanDefinitionBuilder定义FeignClientFactoryBean类型的Bean，然后将@FeignClient里的所有属性都加入到BeanDefinitionBuilder的propertyValues里，通过这种方式给FeignClientFactoryBean的属性赋值，定义注入方式为AbstractBeanDefinition.AUTOWIRE_BY_TYPE，通过BeanDefinitionHolder对象将Bean的alias定义为服务名+“FeignClient”,beanName=类的全路径，注册beanName的alias，这一块存疑，每个接口不同，但服务相同，alias会相同，不知道这个alias的作用是什么？

FeignClientFactoryBean.java属性如下

class FeignClientFactoryBean implements FactoryBean, InitializingBean,
        ApplicationContextAware {
    /***********************************
     * WARNING! Nothing in this class should be @Autowired. It causes NPEs because of some lifecycle race condition.
     ***********************************/
    private Class type;
    private String name;
    private String url;
    private String path;
    private boolean decode404;
    private ApplicationContext applicationContext;
    private Class fallback = void.class;
    private Class fallbackFactory = void.class;
} 
  
 
 
  
private void registerFeignClient(BeanDefinitionRegistry registry,
            AnnotationMetadata annotationMetadata, Map attributes) {
        String className = annotationMetadata.getClassName();
        BeanDefinitionBuilder definition = BeanDefinitionBuilder
                .genericBeanDefinition(FeignClientFactoryBean.class);
        validate(attributes);
        definition.addPropertyValue("url", getUrl(attributes));
        definition.addPropertyValue("path", getPath(attributes));
        String name = getName(attributes);
        definition.addPropertyValue("name", name);
        definition.addPropertyValue("type", className);
        definition.addPropertyValue("decode404", attributes.get("decode404"));
        definition.addPropertyValue("fallback", attributes.get("fallback"));
        definition.addPropertyValue("fallbackFactory", attributes.get("fallbackFactory"));
        definition.setAutowireMode(AbstractBeanDefinition.AUTOWIRE_BY_TYPE);
        String alias = name + "FeignClient";
        AbstractBeanDefinition beanDefinition = definition.getBeanDefinition();
        boolean primary = (Boolean)attributes.get("primary"); // has a default, won't be null
        beanDefinition.setPrimary(primary);
        String qualifier = getQualifier(attributes);
        if (StringUtils.hasText(qualifier)) {
            alias = qualifier;
        }
        BeanDefinitionHolder holder = new BeanDefinitionHolder(beanDefinition, className,
                new String[] { alias });
        BeanDefinitionReaderUtils.registerBeanDefinition(holder, registry);
    }

 
 
 
 
 
 
1.3 FeignAutoConfiguration
 
 
先看一下该类的定义，@ConditionalOnClass(Feign.class)一旦类路径下引入了Feign的包，则该配置类会自动生效，然后导入配置属性类信息
 
 
 
  
@Configuration
@ConditionalOnClass(Feign.class)
@EnableConfigurationProperties({FeignClientProperties.class, FeignHttpClientProperties.class})
public class FeignAutoConfiguration {
    @Autowired(required = false)
    private List configurations = new ArrayList<>();
    
    @Bean
    public FeignContext feignContext() {
        FeignContext context = new FeignContext();
        context.setConfigurations(this.configurations);
        return context;
    }
｝
 
 
 
 
① 注入一个名为feignContext类型为FeignContext的bean,使用默认的配置类FeignClientsConfiguration通过父类NamedContextFactory来构建，，将所有feign相关的配置设置进去，包含了Feign的上下文信息，FeignClientsConfiguration通过实现ApplicationContextAware来注入ApplicationContext， 并将ApplicationContext作为FeignContext的父容器，关于FeignClientsConfiguration在后面章节讲述
 
 
FeignContext.java
 
 
 
  
    public FeignContext() {
        super(FeignClientsConfiguration.class, "feign", "feign.client.name");
    }
 
 
 
 
NamedContextFactory.java
 
 
 
  
/**
 * Creates a set of child contexts that allows a set of Specifications to define the beans
 * in each child context.
 *
 * Ported from spring-cloud-netflix FeignClientFactory and SpringClientFactory
 *
 * @author Spencer Gibb
 * @author Dave Syer
 */
public abstract class NamedContextFactory
        implements DisposableBean, ApplicationContextAware {
    public interface Specification {
        String getName();
        Class[] getConfiguration();
    }
    private Map contexts = new ConcurrentHashMap<>();
    private Map configurations = new ConcurrentHashMap<>();
    private ApplicationContext parent;
    private Class defaultConfigType;
    private final String propertySourceName;
    private final String propertyName;
    public NamedContextFactory(Class defaultConfigType, String propertySourceName,
            String propertyName) {
        this.defaultConfigType = defaultConfigType;
        this.propertySourceName = propertySourceName;
        this.propertyName = propertyName;
    }
    
    public void setConfigurations(List configurations) {
        for (C client : configurations) {
            this.configurations.put(client.getName(), client);
        }
    }
}

 
 
 
 
② FeignContext创建完成之后，下一步context.setConfigurations(this.configurations); 通过代码可以看到this.configurations指向的是本类的一个属性，通过@Autowired注入，然后我们看到注入的这个类型，FeignClientSpecification在前面我们看到了，这个是根据@FeignContext上的服务名来进行创建的类型，详见org.springframework.cloud.netflix.feign.FeignClientsRegistrar#registerClientConfiguration方法，所以在之前我们注入的FeignClientSpecification，也解决了之前的疑惑，既然会注入多个同类型的Bean，所以这里只能通过集合来接收注入，根据NamedContextFactory的源码可以看到它的configurations属性是一个ConcurrentHashMap,ConcurrentHashMap的key是FeignClientSpecification的name属性，关于name属性的值的规则前面也已经看到了， ConcurrentHashMap的value就是每个FeignClientSpecification对象本身
 
 
 
  
@Autowired(required = false)
private List configurations = new ArrayList<>();
 
 
 
 
 
 
1.4 FeignClientFactoryBean的定义
 
 
该类部分源码如下：
 
 
实现了FactoryBean接口来完成Bean的注入，最终注入的对象通过getObject()方法返回，实现了
 
 
InitializingBean接口通过afterPropertiesSet()方法来检查name属性的赋值，实现了ApplicationContextAware接口来获得ApplicationContext容器，其中在前面也已经看到该类的属性赋值过程是如何实现的，这里不再细述。
 
 
 
  
class FeignClientFactoryBean implements FactoryBean, InitializingBean,
        ApplicationContextAware {
    /***********************************
     * WARNING! Nothing in this class should be @Autowired. It causes NPEs because of some lifecycle race condition.
     ***********************************/
    private Class type;
    private String name;
    private String url;
    private String path;
    private boolean decode404;
    private ApplicationContext applicationContext;
    private Class fallback = void.class;
    private Class fallbackFactory = void.class;
    @Override
    public void afterPropertiesSet() throws Exception {
        Assert.hasText(this.name, "Name must be set");
    }
    @Override
    public void setApplicationContext(ApplicationContext context) throws BeansException {
        this.applicationContext = context;
    }
            
    @Override
    public Object getObject() throws Exception {
        FeignContext context = applicationContext.getBean(FeignContext.class);
        Feign.Builder builder = feign(context);
    }
｝
 
  
 
① 现在重点来看一下getObject()方法，首先从ApplicationContext容器中获得FeignContext对象，该对象在上一步已经看到如何注入的，下一步调用feign()方法，该方法代码如下
 
 
 
  
class FeignClientFactoryBean implements FactoryBean, InitializingBean,
        ApplicationContextAware {
    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);
        // 省略其它代码
    }
    
    protected  T get(FeignContext context, Class type) {
        T instance = context.getInstance(this.name, type);
        if (instance == null) {
            throw new IllegalStateException("No bean found of type " + type + " for "
                    + this.name);
        }
        return instance;
    }
            
    protected void configureFeign(FeignContext context, Feign.Builder builder) {
        FeignClientProperties properties = applicationContext.getBean(FeignClientProperties.class);
        // 省略其它代码
    }
} 
  
 
首先第一步FeignLoggerFactory loggerFactory = get(context, FeignLoggerFactory.class);点开get()方法，最终执行org.springframework.cloud.context.named.NamedContextFactory#createContext，传入的name即FeignClientFactoryBean的name属性，也就是服务名，创建一个空的基于注解的容器类，先判断configuration属性的Map里是否包含当前name，之前已经看到configuration的属性来源就是之前注入的FeignClientSpecification的name属性也就是服务名，所以传入的服务名是包含在这里的，判断获得当前name对应的FeignClientSpecification注册到新创建的容器类中，将NamedContextFactory的defaultConfigType属性注入到容器中类型为PropertyPlaceholderAutoConfiguration，当前defaultConfigType具体实现类是通过FeignContext的构造方法调用super也就是NamedContextFactory传参复制为FeignClientSpecification对象，propertySourceName属性添加到当前新创建的服务容器的MutablePropertySources中，并且规定读取的name是当前propertySourceName,的就是说每个服务名所创建的子容器是不同的，如果不特殊指定父容器，则他们的父容器是相同的，都是ApplicationContext，关于FeignClientSpecification在下一节详述
 
 
 
  
NamedContextFactory.java,getInstance() --> getContext() --> createContext()
public abstract class NamedContextFactory
        implements DisposableBean, ApplicationContextAware {
        
    private Map configurations = new ConcurrentHashMap<>();
    
    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);
    }
    
    protected AnnotationConfigApplicationContext createContext(String name) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
        if (this.configurations.containsKey(name)) {
            for (Class configuration : this.configurations.get(name)
                    .getConfiguration()) {
                context.register(configuration);
            }
        }
        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);
        }
        context.refresh();
        return context;
    }
}

 
 
 
 
现在来看Feign.Builder builder = get(context, Feign.Builder.class)这一行代码，其实这一行代码是在FeignClientsConfiguration这个类完成创建并完成Bean对象的注入之后才会执行的，关于具体注入的对象在后面一个章节讲述，这里先大致说一下这一块代码的功能，创建Feign.Builder对象，并将容器中（FeignClientsConfiguration注入的几个Bean）对应的Bean调用setter方法来完成对Feign.Builder的logger-encoder, decoder, contract属性赋值
 
 
 
 
1.5 FeignClientsConfiguration
 
 
接着上面的代码，org.springframework.cloud.netflix.feign.FeignClientFactoryBean#feign里的FeignLoggerFactory loggerFactory = get(context, FeignLoggerFactory.class);代码，会去创建每个服务自己的容器，并且会去实例化当前配置类，下面就来看下该类的作用
 
 
 
  
@Configuration
public class FeignClientsConfiguration {
    @Autowired
    private ObjectFactory messageConverters;
    @Autowired(required = false)
    private List parameterProcessors = new ArrayList<>();
    @Autowired(required = false)
    private List feignFormatterRegistrars = new ArrayList<>();
    @Autowired(required = false)
    private Logger logger;
    @Bean
    @ConditionalOnMissingBean
    public Decoder feignDecoder() {
        return new ResponseEntityDecoder(new SpringDecoder(this.messageConverters));
    }
    @Bean
    @ConditionalOnMissingBean
    public Encoder feignEncoder() {
        return new SpringEncoder(this.messageConverters);
    }
    @Bean
    @ConditionalOnMissingBean
    public Contract feignContract(ConversionService feignConversionService) {
        return new SpringMvcContract(this.parameterProcessors, feignConversionService);
    }
    @Bean
    public FormattingConversionService feignConversionService() {
        FormattingConversionService conversionService = new DefaultFormattingConversionService();
        for (FeignFormatterRegistrar feignFormatterRegistrar : feignFormatterRegistrars) {
            feignFormatterRegistrar.registerFormatters(conversionService);
        }
        return conversionService;
    }
    @Configuration
    @ConditionalOnClass({ HystrixCommand.class, HystrixFeign.class })
    protected static class HystrixFeignConfiguration {
        @Bean
        @Scope("prototype")
        @ConditionalOnMissingBean
        @ConditionalOnProperty(name = "feign.hystrix.enabled", matchIfMissing = false)
        public Feign.Builder feignHystrixBuilder() {
            return HystrixFeign.builder();
        }
    }
    @Bean
    @ConditionalOnMissingBean
    public Retryer feignRetryer() {
        return Retryer.NEVER_RETRY;
    }
    @Bean
    @Scope("prototype")
    @ConditionalOnMissingBean
    public Feign.Builder feignBuilder(Retryer retryer) {
        return Feign.builder().retryer(retryer);
    }
    @Bean
    @ConditionalOnMissingBean(FeignLoggerFactory.class)
    public FeignLoggerFactory feignLoggerFactory() {
        return new DefaultFeignLoggerFactory(logger);
    }
}

 
 
 
 
① 该类为一个配置类，被实例化后，识别当前类下的注入的Bean，messageConverters，parameterProcessors,feignFormatterRegistrars,logger等允许注入，除messageConverters系统有默认值外，其它无默认值，但应该都可以自定义并注入容器，然后使之生效。同时下面默认也会像容器中注入几个Bean，前提是用户没有自定义的时候，如 feignDecoder()注入Decoder, feignEncoder注入Encoder， feignContract()注入Contract, feignConversionService注入FormattingConversionService,同样不细究作用；
 
 
② 有一个内部类，用来判断如果当前类路径下有Hystrix的包，则该配置类生效，并且如果配置了feign.hystrix.enabled属性，则使用Hystrix来构建HystrixFeign`
 
 
 
  
@Configuration
 @ConditionalOnClass({ HystrixCommand.class, HystrixFeign.class })
 protected static class HystrixFeignConfiguration {
  @Bean
  @Scope("prototype")
  @ConditionalOnMissingBean
  @ConditionalOnProperty(name = "feign.hystrix.enabled", matchIfMissing = false)
  public Feign.Builder feignHystrixBuilder() {
   return HystrixFeign.builder();
  }
 }
 
 
 
 
③ feignRetryer，可以看到Feign的重试机制默认是关闭的，该接口有一个内部类，目前调用的是空参的构造函数
 
 
 
  
@Bean
 @ConditionalOnMissingBean
 public Retryer feignRetryer() {
  return Retryer.NEVER_RETRY;
 }
 
 
 
 
④ feignBuilder()方法，构建一个默认的的Feign.Builder对象,入参的retryer会从容器中获取注入的Retryer来覆盖默认的builder中的Retryer没有任何属性，目前容器中已经通过③的方法feignRetryer()来注入了一个Retryer.NEVER_RETRY类型的Retryer,所以会覆盖默认的Feign.builder()构建出来的重试机制，即不提供重试支持，默认值详见⑤
 
 
 
  
 @Bean
 @Scope("prototype")
 @ConditionalOnMissingBean
 public Feign.Builder feignBuilder(Retryer retryer) {
  return Feign.builder().retryer(retryer);
 }
 
 
 
 
这里执行结束后，各个参数的 值如下图
 
 
⑤ Feign.Builder对象,看一下内部类Builder，这一块的步骤往下细分一下，其实会覆盖某些之前设置的属性，下面来详细看一下每个方法的默认实现,某些方法不再贴里面的具体实现，到时候可以自行进入某些方法内部查看源码
 
 
 
  
public abstract class Feign {
  public static Builder builder() {
    return new Builder();
  }
public static class Builder {
    private final List requestInterceptors =
        new ArrayList();
    // 默认的日志级别，可选值有NONE, BASIC, HEADERS, FULL
    private Logger.Level logLevel = Logger.Level.NONE;
   // Defines what annotations and values are valid on interfaces.
    private Contract contract = new Contract.Default();
    // 提交一个feign.Request的http请求，该实现是线程安全的
    private Client client = new Client.Default(null, null);
   // 默认的重试机制，有几个属性period为100，maxPeriod为1000，maxAttempts为5，attempt为1，sleptForMillis为0
    private Retryer retryer = new Retryer.Default();
    // 没有任何属性的logger
    private Logger logger = new NoOpLogger();
   // 编码
    private Encoder encoder = new Encoder.Default();
    // 解码
    private Decoder decoder = new Decoder.Default();
    // 允许自定义对响应异常的处理
    private ErrorDecoder errorDecoder = new ErrorDecoder.Default();
   // 默认的Request.Options，connectTimeoutMillis为10 * 1000， readTimeoutMillis为60 * 1000
    private Options options = new Options();
   // Controls reflective method dispatch.
    private InvocationHandlerFactory invocationHandlerFactory =
        new InvocationHandlerFactory.Default();
    private boolean decode404;
｝

 
 
 
 
 
 
1.6 FeignClientProperties
 
 
① 配置前缀feign.client
 
 
 
  
@ConfigurationProperties("feign.client")
public class FeignClientProperties {
     private boolean defaultToProperties = true;
     private String defaultConfig = "default";
     private Map config = new HashMap<>();
}

 
 
 
 
② 该类有一个内部类FeignClientConfiguration，通过config属性的setter/getter方法来将该内部类赋值给该类的属性，而且该属性是一个map形式，value才是内部类，所以再配置属性的时候，可以指定一个Key,所以如果需要配置FeignClientConfiguration下的属性，经后面分析，为什么使用map形式存储属性对象，是因为当前项目需要调用多个项目的Feign接口，所以可以使用注册的服务名为每个服务单独设置不同的属性，而如果需要所有的服务公用的配置，则配置在default这个key下，为什么是default，是因为取值属性defaultConfig,需要使用feign.client.key.config，可配置属性如下
 
 
 
  
feign:
  client:
    myFeign:
        readTimeout: 5000
        connectTimeout: 2000 
    default: 
        readTimeout: 6000
        connectTimeout: 3000
 
 
 
 
 
  
public static class FeignClientConfiguration {
  private Logger.Level loggerLevel;
  private Integer connectTimeout;
  private Integer readTimeout;
  private Class retryer;
  private Class errorDecoder;
  private List> requestInterceptors;
  private Boolean decode404;
}
 
 
 
 
 
 
1.7 再看FeignClientFactoryBean
 
 
接之前已经露过面的一次configureFeign()方法，这个方法获取了上面FeignClientProperties这个bean，在这里会初始化FeignClientProperties的各种属性，FeignClientProperties有一个属性defaultToProperties默认为true,所以走的是if里的方法，代码如下，
 
 
 
  
class FeignClientFactoryBean implements FactoryBean, InitializingBean,
        ApplicationContextAware {
        
        @Override
    public Object getObject() throws Exception {
        FeignContext context = applicationContext.getBean(FeignContext.class);
        Feign.Builder builder = feign(context);
        if (!StringUtils.hasText(this.url)) {
            String url;
            if (!this.name.startsWith("http")) {
                url = "http://" + this.name;
            }
            else {
                url = this.name;
            }
            url += cleanPath();
            return loadBalance(builder, context, new HardCodedTarget<>(this.type,
                    this.name, url));
        }
        if (StringUtils.hasText(this.url) && !this.url.startsWith("http")) {
            this.url = "http://" + this.url;
        }
        String url = this.url + cleanPath();
        Client client = getOptional(context, Client.class);
        if (client != null) {
            if (client instanceof LoadBalancerFeignClient) {
                // not lod 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 targeter.target(this, builder, context, new HardCodedTarget<>(
                this.type, this.name, url));
    }
            
    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;
    }
    protected void configureFeign(FeignContext context, Feign.Builder builder) {
        FeignClientProperties properties = 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.name), builder);
            } else {
                configureUsingProperties(properties.getConfig().get(properties.getDefaultConfig()), builder);
                configureUsingProperties(properties.getConfig().get(this.name), builder);
                configureUsingConfiguration(context, builder);
            }
        } else {
            configureUsingConfiguration(context, builder);
        }
    }
    
    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.name, RequestInterceptor.class);
        if (requestInterceptors != null) {
            builder.requestInterceptors(requestInterceptors.values());
        }
        if (decode404) {
            builder.decode404();
        }
    }
    protected void configureUsingProperties(FeignClientProperties.FeignClientConfiguration config, Feign.Builder builder) {
        if (config == null) {
            return;
        }
        if (config.getLoggerLevel() != null) {
            builder.logLevel(config.getLoggerLevel());
        }
        if (config.getConnectTimeout() != null && config.getReadTimeout() != null) {
            builder.options(new Request.Options(config.getConnectTimeout(), config.getReadTimeout()));
        }
        if (config.getRetryer() != null) {
            Retryer retryer = getOrInstantiate(config.getRetryer());
            builder.retryer(retryer);
        }
        if (config.getErrorDecoder() != null) {
            ErrorDecoder errorDecoder = getOrInstantiate(config.getErrorDecoder());
            builder.errorDecoder(errorDecoder);
        }
        if (config.getRequestInterceptors() != null && !config.getRequestInterceptors().isEmpty()) {
            // this will add request interceptor to builder, not replace existing
            for (Class bean : config.getRequestInterceptors()) {
                RequestInterceptor interceptor = getOrInstantiate(bean);
                builder.requestInterceptor(interceptor);
            }
        }
        if (config.getDecode404() != null) {
            if (config.getDecode404()) {
                builder.decode404();
            }
        }
    }
}
 
  
 
① 先看方法configureUsingConfiguration,从FeignContext中获取这些bean如果不为空的话，就覆盖之前做的默认值，所以如果我们自定义这些bean的放入到容器的时候，则从FeignContext中一旦能够获取到这些bean，就可以覆盖到系统默认的处理，这里给我们自定义留下了支持
 
 
 
  
configureUsingConfiguration(context, builder);
protected void configureUsingConfiguration(FeignContext context, Feign.Builder builder) {
    // 目前容器没有注入`Logger.Level`，所以这里使用的还是Feign.Builder的默认值
    Logger.Level level = getOptional(context, Logger.Level.class);
    if (level != null) {
        builder.logLevel(level);
    }
    // 参考FeignClientsConfiguration，容器中默认注入了一个`Retryer.NEVER_RETRY`
    Retryer retryer = getOptional(context, Retryer.class);
    if (retryer != null) {
        builder.retryer(retryer);
    }
    // 没有注入`ErrorDecoder`，所以使用的还是Feign.Builder的默认值
    ErrorDecoder errorDecoder = getOptional(context, ErrorDecoder.class);
    if (errorDecoder != null) {
        builder.errorDecoder(errorDecoder);
    }
    // 默认通过`FeignRibbonClientAutoConfiguration`的`feignRequestOptions()`方        // 注入了一个Request.Options
    // 详见下一节FeignRibbonClientAutoConfiguration，拿到这个`bean`，覆盖原属性
    Request.Options options = getOptional(context, Request.Options.class);
    if (options != null) {
        builder.options(options);
    }
    // 未细究
    Map requestInterceptors = context.getInstances(
        this.name, RequestInterceptor.class);
    if (requestInterceptors != null) {
        builder.requestInterceptors(requestInterceptors.values());
    }
    // 未细究
    if (decode404) {
        builder.decode404();
    }
}

 
 
 
 
② configureUsingProperties(properties.getConfig().get(properties.getDefaultConfig()), builder)方法，作用是应用配置文件中的默认的配置,properties的类型为FeignClientProperties，config形式为Map，相关细节在FeignClientProperties这一节已详细讲解，所以这里是把配置文件下的feign.client.default下的属性应用起来，可以配置的属性有如下方法内部，可以看到按照顺序，默认配置会覆盖第一步里的配置，配置文件的优先级高于配置类的优先级（包括使用配置类的方法注入自定义的bean）
 
 
 
  
configureUsingProperties(properties.getConfig().get(properties.getDefaultConfig()), builder)
protected void configureUsingProperties(FeignClientProperties.FeignClientConfiguration config, Feign.Builder builder) {
    if (config == null) {
        return;
    }
    if (config.getLoggerLevel() != null) {
        builder.logLevel(config.getLoggerLevel());
    }
    if (config.getConnectTimeout() != null && config.getReadTimeout() != null) {
        builder.options(new Request.Options(config.getConnectTimeout(), config.getReadTimeout()));
    }
    if (config.getRetryer() != null) {
        Retryer retryer = getOrInstantiate(config.getRetryer());
        builder.retryer(retryer);
    }
    if (config.getErrorDecoder() != null) {
        ErrorDecoder errorDecoder = getOrInstantiate(config.getErrorDecoder());
        builder.errorDecoder(errorDecoder);
    }
    if (config.getRequestInterceptors() != null && !config.getRequestInterceptors().isEmpty()) {
        // this will add request interceptor to builder, not replace existing
        for (Class bean : config.getRequestInterceptors()) {
            RequestInterceptor interceptor = getOrInstantiate(bean);
            builder.requestInterceptor(interceptor);
        }
    }
    if (config.getDecode404() != null) {
        if (config.getDecode404()) {
            builder.decode404();
        }
    }
}

 
 
 
 
③ configureUsingProperties(properties.getConfig().get(this.name), builder);作用是应用当前Feign应用特有的属性配置，可配置的属性与上面一样，但是属性类放入config属性Map的key为Feign接口应用的名称
 
 
④ properties.isDefaultToProperties()，defaultToProperties的默认值为true,如果为true,则应用配置的顺序是先应用属性类的key和自己应用一样名称的配置，然后再应用default的配置，最后应用配置类的属性；而如果这个属性的值为false,则应用顺序正好相反
 
 
⑤ feign()方法执行完成之后，回到getObject()方法，该类的type属性是每个标注了@FeignClient接口类，判断注解中是否明确了url地址，如果没有的话，下面判断来定义url的规则为http://name/path即服务名和注解指定的path属性，即应用的ContextPath和每个接口类的具体实现类的@RequestMapping，new HardCodedTarget<>(this.type, this.name, url)生成调用目标地址信息的代理类
 
 
 
 
1.8 FeignRibbonClientAutoConfiguration
 
 
该类位于Feign包下的ribbon包下，Feign的负载均衡是基于ribbon的，该类的全路径为org.springframework.cloud.netflix.feign.ribbon.FeignRibbonClientAutoConfiguration，
 
 
该类代码如下：
 
 
 
  
@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 {
 @Bean
 @Primary
 @ConditionalOnMissingClass("org.springframework.retry.support.RetryTemplate")
 public CachingSpringLoadBalancerFactory cachingLBClientFactory(
   SpringClientFactory factory) {
  return new CachingSpringLoadBalancerFactory(factory);
 }
 @Bean
 @Primary
 @ConditionalOnClass(name = "org.springframework.retry.support.RetryTemplate")
 public CachingSpringLoadBalancerFactory retryabeCachingLBClientFactory(
  SpringClientFactory factory,
  LoadBalancedRetryPolicyFactory retryPolicyFactory,
  LoadBalancedBackOffPolicyFactory loadBalancedBackOffPolicyFactory,
  LoadBalancedRetryListenerFactory loadBalancedRetryListenerFactory) {
  return new CachingSpringLoadBalancerFactory(factory, retryPolicyFactory, loadBalancedBackOffPolicyFactory, loadBalancedRetryListenerFactory);
 }
 @Bean
 @ConditionalOnMissingBean
 public Request.Options feignRequestOptions() {
  return LoadBalancerFeignClient.DEFAULT_OPTIONS;
 }
}

 
 
 
 
① 先看方法feignRequestOptions()， @ConditionalOnMissingBean注解，如果当前项目中还没有Request.Options这个Bean则注入这个Bean，属于默认配置，可以看到如果自定义这个Bean的注入，则这里的代码会失效。然后参考上一节的FeignClientFactoryBean的configureUsingConfiguration()方法，则我们注入的bean会生效。来看一下系统的默认配置，可以看到最终请求Request.Options.的 connectTimeoutMillis的默认值为10 * 1000， readTimeoutMillis的默认值为60 * 1000
 
 
 
  
 @Bean
 @ConditionalOnMissingBean
 public Request.Options feignRequestOptions() {
  return LoadBalancerFeignClient.DEFAULT_OPTIONS;
 }
// 如上方法指向了这里
public class LoadBalancerFeignClient implements Client {
 static final Request.Options DEFAULT_OPTIONS = new Request.Options();
}
// 如上方法指向了这里
public final class Request {
public static class Options {
    private final int connectTimeoutMillis;
    private final int readTimeoutMillis;
    public Options(int connectTimeoutMillis, int readTimeoutMillis) {
      this.connectTimeoutMillis = connectTimeoutMillis;
      this.readTimeoutMillis = readTimeoutMillis;
    }
    public Options() {
      this(10 * 1000, 60 * 1000);
    }
}

 
 
 
 
 
 
1.9 LoadBalancerFeignClient
 
 
客户端调用Feign接口通过反射最终执行如下方法
 
 
 
  
@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();
  }
  catch (ClientException e) {
   IOException io = findIOException(e);
   if (io != null) {
    throw io;
   }
   throw new RuntimeException(e);
  }
 }

 
 
 
 
request包含当前请求信息url,head,body，charset，如下图
 
 
options包含连接connectTimeoutMillis和readTimeoutMillis，这个在前面已经看到默认分别是10000和60000,关于如何zi自定义配置前面也已经说过
 
 
方法体内代码asUri为完整请求地址，包含请求协议://服务名/服务上下文/请求映射路径+参数,clientName为解析请求中的服务名,uriWithoutHost解析请求地址去除服务名,下一步构建FeignLoadBalancer.RibbonRequest对象ribbonRequest，其中this.delegate的类型为feign.Client，默认使用的是它的实现类Client.Default，构建步骤具体为下，直接贴代码看一眼就行,其中Uri往下看似乎已经是经过UTF-8编码过了，但是body没有经过编码,总体而言该对象包含了当前请求所需要的重要信息 this.delegate的赋值通过以下类指定
 
 
 
  
@Configuration
class DefaultFeignLoadBalancedConfiguration {
 @Bean
 @ConditionalOnMissingBean
 public Client feignClient(CachingSpringLoadBalancerFactory cachingFactory,
         SpringClientFactory clientFactory) {
  return new LoadBalancerFeignClient(new Client.Default(null, null),
    cachingFactory, clientFactory);
 }
}
 
 
 
 
构建Request请求信息
 
 
 
  
RibbonRequest(Client client, Request request, URI uri) {
   this.client = client;
   setUri(uri);
   this.request = toRequest(request);
  }
private Request toRequest(Request request) {
   Map> headers = new LinkedHashMap<>(
     request.headers());
   return Request.create(request.method(),getUri().toASCIIString(),headers,request.body(),request.charset());
  }
 
 
 
 
下面来看下面的代码调用了一个方法getClientConfig(),可以看到这里配置IClientConfig对象的时候如果options使用的是系统默认的对象时，则会触发方法getClientConfig(),而如果不是由系统默认的这个对象，而是我们自己自定义注入过这个对象（无论是配置类还是配置文件），则会触发代码new FeignOptionsClientConfig(options);
 
 
 
  
IClientConfig requestConfig = getClientConfig(options, clientName);
// 方法内部
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;
 }
 
 
 
 
先看简单的requestConfig = new FeignOptionsClientConfig(options);该方法内部如下，则可以看到最终IClientConfig 对象只会有两个属性，一个CommonClientConfigKey.ConnectTimeout，一个CommonClientConfigKey.ReadTimeout，而且两个值的属性使我们自定义的；
 
 
 
  
public FeignOptionsClientConfig(Request.Options options) {
   setProperty(CommonClientConfigKey.ConnectTimeout,
     options.connectTimeoutMillis());
   setProperty(CommonClientConfigKey.ReadTimeout, options.readTimeoutMillis());
  }
 
 
 
 
现在来看如果没有修改过默认的请求属性options == DEFAULT_OPTIONS，这一块看的有点晕乎，在之前看到Feign如果没有任何配置，系统已经默认了connectTimeoutMillis和readTimeoutMillis，这个在前面已经看到默认分别是10000和60000，但是代码在这里处理判断如果使用的是默认的,加载的属性列表如下，会对之前所有的默认操作进行覆盖
 
 
 
 
2.0 FeignLoadBalancer
 
 
 
  
@Override
 public RibbonResponse execute(RibbonRequest request, IClientConfig configOverride)
   throws IOException {
  Request.Options options;
  if (configOverride != null) {
   options = new Request.Options(
     configOverride.get(CommonClientConfigKey.ConnectTimeout,
       this.connectTimeout),
     (configOverride.get(CommonClientConfigKey.ReadTimeout,
       this.readTimeout)));
  }
  else {
   options = new Request.Options(this.connectTimeout, this.readTimeout);
  }
  Response response = request.client().execute(request.toRequest(), options);
  return new RibbonResponse(request.getUri(), response);
 }
 
 
 
 
如果在之前没有对Feign进行过任何配置，那么这里就会加载默认的属性，一旦加载默认的属性，则目前调试下来会有40个属性，默认的ReadTimeout=1000, ConnectTimeout=1000,如下图所示
 
 
如果我们自定义过当前请求Feign的属性，那么IClientConfig对象则会有我们设置的属性以及值，比如我们设置了如下配置则，当前configOverride就会有这两个属性的值，而不是默认的40个。目前还没搞清楚其余字段的意思
 
 
 
  
feign:
 client:
  config:
   default:
     readTimeout: 3333
     connectTimeout: 4444
 
 
 
 
依然是上面的execute()方法，代码从入参之后继续往下走，现在看到new 了一个新的Request.Options对象，下面判断configOverride是否为空，经过上面的描述，这个对象不为空，如果我们自定义过，则会有两个属性，如果没有自定义过，则会有默认的属性，通过configOverride来构建Request.Options对象的代码，可以看到其实仅仅用到了ConnectTimeout和ReadTimeout两个属性，然后调用Request.Options的构造方法来进行赋值，构造方法如下：
 
 
 
  
    public Options(int connectTimeoutMillis, int readTimeoutMillis) {
      this.connectTimeoutMillis = connectTimeoutMillis;
      this.readTimeoutMillis = readTimeoutMillis;
    }
 
 
 
 
自此Request.Options对象的两个属性connectTimeoutMillis和readTimeoutMillis的属性处理完成
 
 
以上为个人经验，希望能给大家一个参考，也希望大家多多支持脚本之家。
 

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(详谈Feign的配置类是如何生效的)

        

            

                
    
                    
  • 斤斤计较的婚姻到底有多难？
                        白心之岂必有为

                        
    很多人私聊我会问到在哪个人群当中斤斤计较的人最多？我都会回答他，一般婚姻出现问题的斤斤计较的人士会非常多，以我多年经验，在婚姻落的一塌糊涂的人当中，斤斤计较的人数占比在20～30%以上，也就是说10个婚姻出现问题的斤斤计较的人有2-3个有多不减。在婚姻出问题当中，有大量的心理不平衡的、尖酸刻薄的怨妇。在婚姻中仅斤斤计较有两种类型：第一种是物质上的，另一种是精神上的。在物质与精神上抠门已经严重的影响
    
                    
    • 
                    
  • 情绪觉察日记第37天
                        露露_e800

                        
    今天是家庭关系规划师的第二阶最后一天，慧萍老师帮我做了个案，帮我处理了埋在心底好多年的一份恐惧，并给了我深深的力量！这几天出来学习，爸妈过来婆家帮我带小孩，妈妈出于爱帮我收拾东西，并跟我先生和婆婆产生矛盾，妈妈觉得他们没有照顾好我…。今晚回家见到妈妈，我很欣赏她并赞扬她，妈妈说今晚要跟我睡我说好，当我们俩躺在床上准备睡觉的时候，我握着妈妈的手对她说:妈妈这几天辛苦你了，你看你多利害把我们的家收拾得
    
                    
    • 
                    
  • 芦花鞋一四
                        许叶晗

                        
    又是在一个寒冷的夏日里，青铜和葵花决定今天一起去卖芦花鞋，奶奶亲手给他们做了一碗热乎乎的粥对他们说:“就靠你们两挣生活费了这碗粥赶紧趁热喝了吧！”于是青铜和葵花喝完了奶奶给她们做的粥，就准备去镇上卖卢花鞋，这回青铜和葵花穿着新的芦花鞋来到了镇上。青铜这回看到了很多人都在卖，用手势表达对葵花说:“这回有好多人在抢我们生意呢！我们必须得吆喝起来。”葵花点了点头。可是谁知他们也大声的叫，卖芦花喽！卖芦花
    
                    
    • 
                    
  • QQ群采集助手，精准引流必备神器
                        2401_87347160
其他经验分享
                        
    功能概述微信群查找与筛选工具是一款专为微信用户设计的辅助工具，它通过关键词搜索功能，帮助用户快速找到相关的微信群，并提供筛选是否需要验证的群组的功能。主要功能关键词搜索：用户可以输入关键词，工具将自动查找包含该关键词的微信群。筛选功能：工具提供筛选机制，用户可以选择是否只显示需要验证或不需要验证的群组。精准引流：通过上述功能，用户可以更精准地找到目标群组，进行有效的引流操作。3.设备需求该工具可以
    
                    
    • 
                    
  • 关于沟通这件事，项目经理不需要每次都面对面进行
                        流程大师兄

                        
    很多项目经理都会遇到这样的问题，项目中由于事情太多，根本没有足够的时间去召开会议，那在这种情况下如何去有效地管理项目中的利益相关者？当然，不建议电子邮件也不需要开会的话，建议可以采取下面几种方式来形成有效的沟通，这几种方式可以帮助你努力的通过各种办法来保持和各方面的联系。项目经理首先要问自己几个问题，项目中哪些利益相关者是必须要进行沟通的？可以列出项目中所有的利益相关者清单，同时也整理出项目中哪些
    
                    
    • 
                    
  • 机器学习与深度学习间关系与区别
                        ℒℴѵℯ心·动ꦿ໊ོ꫞
人工智能学习深度学习python
                        
    一、机器学习概述定义机器学习（MachineLearning,ML）是一种通过数据驱动的方法，利用统计学和计算算法来训练模型，使计算机能够从数据中学习并自动进行预测或决策。机器学习通过分析大量数据样本，识别其中的模式和规律，从而对新的数据进行判断。其核心在于通过训练过程，让模型不断优化和提升其预测准确性。主要类型1.监督学习（SupervisedLearning）监督学习是指在训练数据集中包含输入
    
                    
    • 
                    
  • 铭刻于星（四十二）
                        随风至

                        
    69夜晚，绍敏同学做完功课后，看了眼房外，没听到动静才敢从书包的夹层里拿出那个心形纸团。折痕压得很深，都有些旧了，想来是已经写好很久了。绍敏同学慢慢地、轻轻地捏开折叠处，待到全部拆开后，又反复抚平纸张，然后仔细地一字字默看。只是开头的三个字是第一次看到，让她心漏跳了几拍。“亲爱的绍敏：从四年级的时候，我就喜欢你了，但是我一直不敢说，怕影响你学习。六年级的时候听说有人跟你表白，你接受了，我很难过，但
    
                    
    • 
                    
  • 底层逆袭到底有多难，不甘平凡的你准备好了吗？让吴起给你说说
                        造命者说

                        
    底层逆袭到底有多难，不甘平凡的你准备好了吗？让吴起给你说说我叫吴起，生于公元前440年的战国初期，正是群雄并起、天下纷争不断的时候。后人说我是军事家、政治家、改革家，是兵家代表人物。评价我一生历仕鲁、魏、楚三国，通晓兵家、法家、儒家三家思想，在内政军事上都有极高的成就。周安王二十一年（公元前381年），因变法得罪守旧贵族，被人乱箭射死。我出生在卫国一个“家累万金”的富有家庭，从年轻时候起就不甘平凡
    
                    
    • 
                    
  • 2020-01-25
                        晴岚85

                        
    郑海燕坚持分享590天2020.1.24在生活中只存在两个问题。一个问题是：你知道想要达成的目标是什么，但却不知道如何才能达成；另一个问题是：你不知道你的目标是什么。前一个是行动的问题，后一个是结果的问题。通过制定具体的下一步行动，可以解决不知道如何开始行动的问题。而通过去想象结果，对结果做预估，可以解决找不着目标的问题。对于所有吸引我们注意力，想要完成的任务，你可以先想象一下，预期的结果究竟是什
    
                    
    • 
                    
  • 随笔 | 仙一般的灵气
                        海思沧海

                        
    仙岛今天，我看了你全部，似乎已经进入你的世界我不知道，这是否是梦幻，还是你仙一般的灵气吸引了我也许每一个人都要有一份属于自己的追求，这样才能够符合人生的梦想，生活才能够充满着阳光与快乐我不知道，我为什么会这样的感叹，是在感叹自己的人生，还是感叹自己一直没有孜孜不倦的追求只感觉虚度了光阴，每天活在自己的梦中，活在一个不真实的世界是在逃避自己，还是在逃避周围的一切有时候我嘲笑自己，嘲笑自己如此的虚无，
    
                    
    • 
                    
  • 想家
                        爆米花机

                        
    也许不同于大家对家乡的思念，我对家乡甚至是疯狂的不舍。还未踏出车站就感觉到幸福，我享受这里的夕阳、这里的浓烈柴火味、这里每一口家常菜。我是宅女，我贪恋家的安逸。刚刚踏出大学校门，初出茅庐，无法适应每年只能国庆和春节回家。我焦虑、失眠、无端发脾气，是无法适应工作的节奏，是无法接受我将一步步离开家乡的事实。我不想承认自己胸无大志，选择再次踏上征程。图片发自App
    
                    
    • 
                    
  • 【iOS】MVC设计模式
                        Magnetic_h
iosmvc设计模式objective-c学习ui
                        
    MVC前言如何设计一个程序的结构，这是一门专门的学问，叫做"架构模式"（architecturalpattern），属于编程的方法论。MVC模式就是架构模式的一种。它是Apple官方推荐的App开发架构，也是一般开发者最先遇到、最经典的架构。MVC各层controller层Controller/ViewController/VC（控制器）负责协调Model和View，处理大部分逻辑它将数据从Mod
    
                    
    • 
                    
  • OC语言多界面传值五大方式
                        Magnetic_h
iosui学习objective-c开发语言
                        
    前言在完成暑假仿写项目时，遇到了许多需要用到多界面传值的地方，这篇博客来总结一下比较常用的五种多界面传值的方式。属性传值属性传值一般用前一个界面向后一个界面传值，简单地说就是通过访问后一个视图控制器的属性来为它赋值，通过这个属性来做到从前一个界面向后一个界面传值。首先在后一个界面中定义属性@interfaceBViewController:UIViewController@propertyNSSt
    
                    
    • 
                    
  • 一百九十四章. 自相矛盾
                        巨木擎天

                        
    唉！就这么一夜，林子感觉就像过了很多天似的，先是回了阳间家里，遇到了那么多不可思议的事情儿。特别是小伙伴们，第二次与自己见面时，僵硬的表情和恐怖的气氛，让自己如坐针毡，打从心眼里难受！还有东子，他现在还好吗？有没有被人欺负？护城河里的小鱼小虾们，还都在吗？水不会真的干枯了吧？那对相亲相爱漂亮的太平鸟儿，还好吧！春天了，到了做窝、下蛋、喂养小鸟宝宝的时候了，希望它们都能够平安啊！虽然没有看见家人，也
    
                    
    • 
                    
  • UI学习——cell的复用和自定义cell
                        Magnetic_h
ui学习
                        
    目录cell的复用手动（非注册）自动（注册）自定义cellcell的复用在iOS开发中，单元格复用是一种提高表格（UITableView）和集合视图（UICollectionView）滚动性能的技术。当一个UITableViewCell或UICollectionViewCell首次需要显示时，如果没有可复用的单元格，则视图会创建一个新的单元格。一旦这个单元格滚动出屏幕，它就不会被销毁。相反，它被添
    
                    
    • 
                    
  • element实现动态路由+面包屑
                        软件技术NINI
vue案例vue.js前端
                        
    el-breadcrumb是ElementUI组件库中的一个面包屑导航组件，它用于显示当前页面的路径，帮助用户快速理解和导航到应用的各个部分。在Vue.js项目中，如果你已经安装了ElementUI，就可以很方便地使用el-breadcrumb组件。以下是一个基本的使用示例：安装ElementUI（如果你还没有安装的话）:你可以通过npm或yarn来安装ElementUI。bash复制代码npmi
    
                    
    • 
                    
  • 10月|愿你的青春不负梦想-读书笔记-01
                        Tracy的小书斋

                        
    本书的作者是俞敏洪，大家都很熟悉他了吧。俞敏洪老师是我行业的领头羊吧，也是我事业上的偶像。本日摘录他书中第一章中的金句：『一个人如果什么目标都没有，就会浑浑噩噩，感觉生命中缺少能量。能给我们能量的，是对未来的期待。第一件事，我始终为了进步而努力。与其追寻全世界的骏马，不如种植丰美的草原，到时骏马自然会来。第二件事，我始终有阶段性的目标。什么东西能给我能量？答案是对未来的期待。』读到这里的时候，我便
    
                    
    • 
                    
  • C语言宏函数
                        南林yan
C语言c语言
                        
    一、什么是宏函数？通过宏定义的函数是宏函数。如下，编译器在预处理阶段会将Add(x,y)替换为((x)*(y))#defineAdd(x,y)((x)*(y))#defineAdd(x,y)((x)*(y))intmain(){inta=10;intb=20;intd=10;intc=Add(a+d,b)*2;cout<
                    
    • 
                    
  • 地推话术，如何应对地推过程中家长的拒绝
                        校师学

                        
    相信校长们在做地推的时候经常遇到这种情况：市场专员反馈家长不接单，咨询师反馈难以邀约这些家长上门，校区地推疲软，招生难。为什么？仅从地推层面分析，一方面因为家长受到的信息轰炸越来越多，对信息越来越“免疫”；而另一方面地推人员的专业能力和营销话术没有提高，无法应对家长的拒绝，对有意向的家长也不知如何跟进，眼睁睁看着家长走远；对于家长的疑问，更不知道如何有技巧地回答，机会白白流失。由于回答没技巧和专业
    
                    
    • 
                    
  • 谢谢你们，爱你们！
                        鹿游儿

                        
    昨天家人去泡温泉，二个孩子也带着去，出发前一晚，匆匆下班，赶回家和孩子一起收拾。饭后，我拿出笔和本子（上次去澳门时做手帐的本子）写下了1\2\3\4\5\6\7\8\9,让后让小壹去思考，带什么出发去旅游呢？她在对应的数字旁边画上了，泳衣、泳圈、肖恩、内衣内裤、tapuy、拖鞋……画完后，就让她自己对着这个本子，将要带的，一一带上，没想到这次带的书还是这本《便便工厂》(晚上姑婆发照片过来，妹妹累得
    
                    
    • 
                    
  • C语言如何定义宏函数？
                        小九格物
c语言
                        
    在C语言中，宏函数是通过预处理器定义的，它在编译之前替换代码中的宏调用。宏函数可以模拟函数的行为，但它们不是真正的函数，因为它们在编译时不会进行类型检查，也不会分配存储空间。宏函数的定义通常使用#define指令，后面跟着宏的名称和参数列表，以及宏展开后的代码。宏函数的定义方式：1.基本宏函数：这是最简单的宏函数形式，它直接定义一个表达式。#defineSQUARE(x)((x)*(x))2.带参
    
                    
    • 
                    
  • 微服务下功能权限与数据权限的设计与实现
                        nbsaas-boot
微服务java架构
                        
    在微服务架构下，系统的功能权限和数据权限控制显得尤为重要。随着系统规模的扩大和微服务数量的增加，如何保证不同用户和服务之间的访问权限准确、细粒度地控制，成为设计安全策略的关键。本文将讨论如何在微服务体系中设计和实现功能权限与数据权限控制。1.功能权限与数据权限的定义功能权限：指用户或系统角色对特定功能的访问权限。通常是某个用户角色能否执行某个操作，比如查看订单、创建订单、修改用户资料等。数据权限：
    
                    
    • 
                    
  • 理解Gunicorn：Python WSGI服务器的基石
                        范范0825
ipythonlinux运维
                        
    理解Gunicorn：PythonWSGI服务器的基石介绍Gunicorn，全称GreenUnicorn，是一个为PythonWSGI（WebServerGatewayInterface）应用设计的高效、轻量级HTTP服务器。作为PythonWeb应用部署的常用工具，Gunicorn以其高性能和易用性著称。本文将介绍Gunicorn的基本概念、安装和配置，帮助初学者快速上手。1.什么是Gunico
    
                    
    • 
                    
  • 小丽成长记（四十三）
                        玲玲54321

                        
    小丽发现，即使她好不容易调整好自己的心态下一秒总会有不确定的伤脑筋的事出现，一个接一个的问题，人生就没有停下的时候，小问题不断出现。不过她今天看的书，她接受了人生就是不确定的，厉害的人就是不断创造确定性，在Ta的领域比别人多的确定性就能让自己脱颖而出，显示价值从而获得的比别人多的利益。正是这样的原因，因为从前修炼自己太少，使得她现在在人生道路上打怪起来困难重重，她似乎永远摆脱不了那种无力感，有种习
    
                    
    • 
                    
  • 学点心理知识，呵护孩子健康
                        静候花开_7090

                        
    昨天听了华中师范大学教育管理学系副教授张玲老师的《哪里才是学生心理健康的最后庇护所，超越教育与技术的思考》的讲座。今天又重新学习了一遍，收获匪浅。张玲博士也注意到了当今社会上的孩子由于心理问题导致的自残、自杀及伤害他人等恶性事件。她向我们普及了一个重要的命题，她说心理健康的一些基本命题，我们与我们通常的一些教育命题是不同的，她还举了几个例子，让我们明白我们原来以为的健康并非心理学上的健康。比如如果
    
                    
    • 
                    
  • 2021年12月19日，春蕾教育集团团建活动感受——黄晓丹
                        黄错错加油

                        
    感受:1.从陌生到熟悉的过程。游戏环节让我们在轻松的氛围中得到了锻炼，也增长了不少知识。2.游戏过程中，我们贡献的是个人力量，展现的是团队的力量。它磨合的往往不止是工作的熟悉，更是观念上契合度的贴近。3.这和工作是一样的道理。在各自的岗位上，每个人摆正自己的位置、各司其职充分发挥才能，并团结一致劲往一处使，才能实现最大的成功。新知:1.团队精神需要不断地创新。过去，人们把创新看作是冒风险，现在人们
    
                    
    • 
                    
  • Cell Insight | 单细胞测序技术又一新发现，可用于HIV-1和Mtb共感染个体诊断
                        尐尐呅

                        
    结核病是艾滋病合并其他疾病中导致患者死亡的主要原因。其中结核病由结核分枝杆菌（Mycobacteriumtuberculosis,Mtb）感染引起，获得性免疫缺陷综合症（艾滋病）由人免疫缺陷病毒（Humanimmunodeficiencyvirustype1,HIV-1）感染引起。国家感染性疾病临床医学研究中心/深圳市第三人民医院张国良团队携手深圳华大生命科学研究院吴靓团队，共同研究得出单细胞测序
    
                    
    • 
                    
  • c++ 的iostream 和 c++的stdio的区别和联系
                        黄卷青灯77
c++算法开发语言iostreamstdio
                        
    在C++中，iostream和C语言的stdio.h都是用于处理输入输出的库，但它们在设计、用法和功能上有许多不同。以下是两者的区别和联系：区别1.编程风格iostream（C++风格）：C++标准库中的输入输出流类库，支持面向对象的输入输出操作。典型用法是cin（输入）和cout（输出），使用>操作符来处理数据。更加类型安全，支持用户自定义类型的输入输出。#includeintmain(){in
    
                    
    • 
                    
  • 瑶池防线
                        谜影梦蝶

                        
    冥华虽然逃过了影梦的军队，但他是一个忠臣，他选择上报战况。败给影梦后成逃兵，高层亡尔还活着，七重天失守......随便一条，即可处死冥华。冥华自然是知道以仙界高层的习性此信一发自己必死无疑，但他还选择上报实情，因为责任。同样此信送到仙宫后，知道此事的人，大多数人都认定冥华要完了，所以上到仙界高层，下到扫大街的，包括冥华自己，全都准备好迎接冥华之死。如果仙界现在还属于两方之争的话，冥华必死无疑。然而
    
                    
    • 
                    
  • 爬山后遗症
                        璃绛

                        
    爬山，攀登，一步一步走向制高点，是一种挑战。成功抵达是一种无法言语的快乐，在山顶吹吹风，看看风景，这是从未有过的体验。然而，爬山一时爽，下山腿打颤，颠簸的路，一路向下走，腿部力量不够，走起来抖到不行，停不下来了！第二天必定腿疼，浑身酸痛，坐立难安！
    
                    
    • 
                                
  • 基本数据类型和引用类型的初始值
                                    3213213333332132
java基础
                                    
    package com.array;

/**
 * @Description 测试初始值
 * @author FuJianyong
 * 2015-1-22上午10:31:53
 */
public class ArrayTest {
    
	ArrayTest at;
	String str;
	byte bt;
	short s;
	int i;
	long
    
                                
    • 
                                
  • 摘抄笔记--《编写高质量代码：改善Java程序的151个建议》
                                    白糖_
高质量代码
                                    
            记得3年前刚到公司，同桌同事见我无事可做就借我看《编写高质量代码：改善Java程序的151个建议》这本书，当时看了几页没上心就没研究了。到上个月在公司偶然看到，于是乎又找来看看，我的天，真是非常多的干货，对于我这种静不下心的人真是帮助莫大呀。 
  
        看完整本书，也记了不少笔记
    
                                
    • 
                                
  • 【备忘】Django 常用命令及最佳实践
                                    dongwei_6688
django
                                    
    注意：本文基于 Django 1.8.2 版本 
  
生成数据库迁移脚本（python 脚本） 
python manage.py makemigrations polls 
 说明：polls 是你的应用名字，运行该命令时需要根据你的应用名字进行调整 
  
查看该次迁移需要执行的 SQL 语句（只查看语句，并不应用到数据库上）： 
python manage.p
    
                                
    • 
                                
  • 阶乘算法之一N! 末尾有多少个零
                                    周凡杨
java算法阶乘面试效率
                                    
                                     &n
    
                                
    • 
                                
  • spring注入servlet
                                    g21121
Spring注入
                                    
    传统的配置方法是无法将bean或属性直接注入到servlet中的，配置代理servlet亦比较麻烦，这里其实有比较简单的方法，其实就是在servlet的init()方法中加入要注入的内容： 
ServletContext application = getServletContext();
WebApplicationContext wac = WebApplicationContextUtil
    
                                
    • 
                                
  • Jenkins 命令行操作说明文档
                                    510888780
centos
                                    
     
假设Jenkins的URL为http://22.11.140.38:9080/jenkins/ 
 
 
 
基本的格式为 
 
java 
 
基本的格式为 
 
java -jar jenkins-cli.jar [-s JENKINS_URL] command [options][args] 
 
 
 
 
下面具体介绍各个命令的作用及基本使用方法 
 
 
 
1. &nb
    
                                
    • 
                                
  • UnicodeBlock检测中文用法
                                    布衣凌宇
UnicodeBlock
                                    
    /**  * 判断输入的是汉字  */ public static boolean isChinese(char c) {        Character.UnicodeBlock ub = Character.UnicodeBlock.of(c);    
    
                                
    • 
                                
  • java下实现调用oracle的存储过程和函数
                                    aijuans
javaorale
                                    
      1.创建表：STOCK_PRICES 
   
  2.插入测试数据： 
   
  3.建立一个返回游标：  
PKG_PUB_UTILS 
   4.创建和存储过程：P_GET_PRICE 
  
   5.创建函数： 
   6.JAVA调用存储过程返回结果集 
JDBCoracle10G_INVO
    
                                
    • 
                                
  • Velocity Toolbox
                                    antlove
模板toolboxvelocity
                                    
    velocity.VelocityUtil 
package velocity;

import org.apache.velocity.Template;
import org.apache.velocity.app.Velocity;
import org.apache.velocity.app.VelocityEngine;
import org.apache.velocity.c
    
                                
    • 
                                
  • JAVA正则表达式匹配基础
                                    百合不是茶
java正则表达式的匹配
                                    
      
正则表达式;提高程序的性能,简化代码,提高代码的可读性,简化对字符串的操作 
  
正则表达式的用途; 
字符串的匹配

字符串的分割

字符串的查找

字符串的替换
 
  
  
  
正则表达式的验证语法 
    
  [a]    //[]表示这个字符只出现一次  ,[a] 表示a只出现一
    
                                
    • 
                                
  • 是否使用EL表达式的配置
                                    bijian1013
jspweb.xmlELEasyTemplate
                                    
            今天在开发过程中发现一个细节问题，由于前端采用EasyTemplate模板方法实现数据展示，但老是不能正常显示出来。后来发现竟是EL将我的EasyTemplate的${...}解释执行了，导致我的模板不能正常展示后台数据。 
        网
    
                                
    • 
                                
  • 精通Oracle10编程SQL(1-3)PLSQL基础
                                    bijian1013
oracle数据库plsql
                                    
    --只包含执行部分的PL/SQL块
--set serveroutput off
begin
  dbms_output.put_line('Hello,everyone!');
end;


select * from emp;

--包含定义部分和执行部分的PL/SQL块
declare
   v_ename varchar2(5);
begin
   select 
    
                                
    • 
                                
  • 【Nginx三】Nginx作为反向代理服务器
                                    bit1129
nginx
                                    
    Nginx一个常用的功能是作为代理服务器。代理服务器通常完成如下的功能： 
  
 
 接受客户端请求 
 将请求转发给被代理的服务器 
 从被代理的服务器获得响应结果 
 把响应结果返回给客户端 
 实例 
本文把Nginx配置成一个简单的代理服务器 
 
 对于静态的html和图片，直接从Nginx获取 
 对于动态的页面，例如JSP或者Servlet，Nginx则将请求转发给Res
    
                                
    • 
                                
  • Plugin execution not covered by lifecycle configuration: org.apache.maven.plugin
                                    blackproof
maven报错
                                    
    转：http://stackoverflow.com/questions/6352208/how-to-solve-plugin-execution-not-covered-by-lifecycle-configuration-for-sprin 
  
maven报错： 
Plugin execution not covered by lifecycle configuration: 
    
                                
    • 
                                
  • 发布docker程序到marathon
                                    ronin47
docker 发布应用
                                    
    1 发布docker程序到marathon 1.1 搭建私有docker registry 1.1.1 安装docker regisry 
docker pull docker-registry
docker run -t -p 5000:5000 docker-registry
 下载docker镜像并发布到私有registry 
docker pull consol/tomcat-8.0

    
                                
    • 
                                
  • java-57-用两个栈实现队列&&用两个队列实现一个栈
                                    bylijinnan
java
                                    
    
import java.util.ArrayList;
import java.util.List;
import java.util.Stack;

	/*
	 * Q 57 用两个栈实现队列
	 */

public class QueueImplementByTwoStacks {

	private Stack<Integer> stack1;
	pr
    
                                
    • 
                                
  • Nginx配置性能优化
                                    cfyme
nginx
                                    
    转载地址：http://blog.csdn.net/xifeijian/article/details/20956605 
  
大多数的Nginx安装指南告诉你如下基础知识——通过apt-get安装，修改这里或那里的几行配置，好了，你已经有了一个Web服务器了。而且，在大多数情况下，一个常规安装的nginx对你的网站来说已经能很好地工作了。然而，如果你真的想挤压出Nginx的性能，你必
    
                                
    • 
                                
  • [JAVA图形图像]JAVA体系需要稳扎稳打,逐步推进图像图形处理技术
                                    comsci
java
                                    
     
 
     对图形图像进行精确处理，需要大量的数学工具，即使是从底层硬件模拟层开始设计，也离不开大量的数学工具包，因为我认为，JAVA语言体系在图形图像处理模块上面的研发工作，需要从开发一些基础的，类似实时数学函数构造器和解析器的软件包入手，而不是急于利用第三方代码工具来实现一个不严格的图形图像处理软件...... 
 
  &nb
    
                                
    • 
                                
  • MonkeyRunner的使用
                                    dai_lm
androidMonkeyRunner
                                    
    要使用MonkeyRunner，就要学习使用Python，哎 
 
先抄一段官方doc里的代码 
作用是启动一个程序（应该是启动程序默认的Activity），然后按MENU键，并截屏 
 

# Imports the monkeyrunner modules used by this program
from com.android.monkeyrunner import MonkeyRun
    
                                
    • 
                                
  • Hadoop-- 海量文件的分布式计算处理方案
                                    datamachine
mapreducehadoop分布式计算
                                    
    csdn的一个关于hadoop的分布式处理方案，存档。 
原帖：http://blog.csdn.net/calvinxiu/article/details/1506112。 
 
    Hadoop 是Google MapReduce的一个Java实现。MapReduce是一种简化的分布式编程模式，让程序自动分布到一个由普通机器组成的超大集群上并发执行。就如同ja
    
                                
    • 
                                
  • 以資料庫驗證登入
                                    dcj3sjt126com
yii
                                    
    以資料庫驗證登入 
由於 Yii 內定的原始框架程式, 採用綁定在UserIdentity.php 的 demo 與 admin 帳號密碼:    public function authenticate()    {        $users=array( &nbs
    
                                
    • 
                                
  • github做webhooks：[2]php版本自动触发更新
                                    dcj3sjt126com
githubgitwebhooks
                                    
    上次已经说过了如何在github控制面板做查看url的返回信息了。这次就到了直接贴钩子代码的时候了。       
工具/原料  
 
   git   
   github   
     
方法/步骤  
 
       在github的setting里面的webhooks里把我们的url地址填进去。   
       钩子更新的代码如下： error_reportin
    
                                
    • 
                                
  • Eos开发常用表达式
                                    蕃薯耀
Eos开发Eos入门Eos开发常用表达式
                                    
    Eos开发常用表达式 
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 
蕃薯耀 2014年8月18日 15:03:35 星期一 
  
  
&
    
                                
    • 
                                
  • SpringSecurity3.X--SpEL 表达式
                                    hanqunfeng
SpringSecurity
                                    
    使用 Spring 表达式语言配置访问控制，要实现这一功能的直接方式是在<http>配置元素上添加 use-expressions 属性： 
  
<http auto-config="true"  use-expressions="true"> 
这样就会在投票器中自动增加一个投票器：org.springframework
    
                                
    • 
                                
  • Redis vs Memcache
                                    IXHONG
redis
                                    
    1. Redis中，并不是所有的数据都一直存储在内存中的，这是和Memcached相比一个最大的区别。 
2. Redis不仅仅支持简单的k/v类型的数据，同时还提供list，set，hash等数据结构的存储。 
3. Redis支持数据的备份，即master-slave模式的数据备份。 
4. Redis支持数据的持久化，可以将内存中的数据保持在磁盘中，重启的时候可以再次加载进行使用。 
Red
    
                                
    • 
                                
  • Python - 装饰器使用过程中的误区解读
                                    kvhur
JavaScriptjqueryhtml5css
                                    
    大家都知道装饰器是一个很著名的设计模式，经常被用于AOP(面向切面编程)的场景，较为经典的有插入日志，性能测试，事务处理，Web权限校验， Cache等。 
原文链接：http://www.gbtags.com/gb/share/5563.htm 
Python语言本身提供了装饰器语法（@），典型的装饰器实现如下：     
 
 @function_wrapper 
  de
    
                                
    • 
                                
  • 架构师之mybatis-----update 带case when 针对多种情况更新
                                    nannan408
case when
                                    
    1.前言. 
   如题. 
2. 代码. 
  

	<update id="batchUpdate" parameterType="java.util.List">
			<foreach collection="list" item="list" index=&
    
                                
    • 
                                
  • Algorithm算法视频教程
                                    栏目记者
Algorithm算法
                                    
    课程：Algorithm算法视频教程 
 
百度网盘下载地址： http://pan.baidu.com/s/1qWFjjQW 密码: 2mji 
 
 
程序写的好不好,还得看算法屌不屌！Algorithm算法博大精深。 
 一、课程内容： 
课时1、算法的基本概念 + Sequential search 
课时2、Binary search 
课时3、Hash table 
课时4、Algor
    
                                
    • 
                                
  • C语言算法之冒泡排序
                                    qiufeihu
c算法
                                    
    任意输入10个数字由小到大进行排序。 
代码： 
#include <stdio.h>
int main()
{
	int i,j,t,a[11];        /*定义变量及数组为基本类型*/
	for(i = 1;i < 11;i++){
		scanf("%d",&a[i]);     /*从键盘中输入10个数*/
	}
	for
    
                                
    • 
                                
  • JSP异常处理
                                    wyzuomumu
Webjsp
                                    
    1.在可能发生异常的网页中通过指令将HTTP请求转发给另一个专门处理异常的网页中: 
<%@ page errorPage="errors.jsp"%> 
  
2.在处理异常的网页中做如下声明： 
errors.jsp: 
<%@ page isErrorPage="true"%>，这样设置完后就可以在网页中直接访问exc
    
                                
    •