叩丁狼教育
叩丁狼教育

SpringCloud-源码分析 Feign

本文作者：陈刚，叩丁狼高级讲师。原创文章，转载请注明出处。

回顾

我们还是在之前Feign的使用案例集成上来分析Feign源码，在分析 之前我们先简单来回顾一下Feign的用法，要用Feign首选是需要在配置类似开启Feign客户端支持

@EnableEurekaClient
@SpringBootApplication
@EnableFeignClients
public class ConsumerApplication {

    public static void main(String[] args) {
        SpringApplication.run(ConsumerApplication.class, args);
    }

然后我们需要去定义Feign客户端接口

//PRODUCER:指向要访问的服务
//configuration = FooConfiguration.class  Feign Client配置类，指定负载均衡策略

//fallback = MyFeignClientImpl.class: MyFeignClient结构的实现类，需要复写 provide方法，并实现错误处理逻辑
//当访问出现故障，程序会自动调用实现类的 provide方法的错误处理逻辑。
@FeignClient(value = "PRODUCER",configuration = FooConfiguration.class,fallback = MyFeignClientImpl.class)
public interface MyFeignClient {


    //当此方法别调用会自动请求到 PRODUCER服务的 /provide 资源
    @RequestMapping(value = "/provide")
    public String provide(@RequestParam("name") String name);

}

在使用的时候就只需要调用 MyFeignClient 接口即可，SpringCloud会自动去调用对应的目标服务。

分析Feign我们还是从他的@EnableFeignClients标签开始，我们先看下他的源码

  /**
 * Scans for interfaces that declare they are feign clients (via {@link FeignClient
 * @FeignClient}). Configures component scanning directives for use with
 * {@link org.springframework.context.annotation.Configuration
 * @Configuration} classes.
 *
 * @author Spencer Gibb
 * @author Dave Syer
 * @since 1.0
 */
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Documented
@Import(FeignClientsRegistrar.class)
public @interface EnableFeignClients {

该标签的注释告诉我们，它开启了对打了 @FeignClient 标签所在的接口的扫描，和对期配置组件的扫描支持 ，并且该标签import了一个FeignClientsRegistrar类，我们跟踪进去看一下


/**
 * @author Spencer Gibb
 * @author Jakub Narloch
 * @author Venil Noronha
 * @author Gang Li
 */
class FeignClientsRegistrar implements ImportBeanDefinitionRegistrar,
        ResourceLoaderAware, EnvironmentAware {

    // patterned after Spring Integration IntegrationComponentScanRegistrar
    // and RibbonClientsConfigurationRegistgrar

    private ResourceLoader resourceLoader;

    private Environment environment;

    public FeignClientsRegistrar() {

他实现了 ImportBeanDefinitionRegistrar接口，我们继续看ImportBeanDefinitionRegistrar的源码

/**
 * Interface to be implemented by types that register additional bean definitions when
 * processing @{@link Configuration} classes. Useful when operating at the bean definition
 * level (as opposed to {@code @Bean} method/instance level) is desired or necessary.
 *
 * 
Along with {@code @Configuration} and {@link ImportSelector}, classes of this type
 * may be provided to the @{@link Import} annotation (or may also be returned from an
 * {@code ImportSelector}).
 *
 * 
An {@link ImportBeanDefinitionRegistrar} may implement any of the following
 * {@link org.springframework.beans.factory.Aware Aware} interfaces, and their respective
 * methods will be called prior to {@link #registerBeanDefinitions}:
 * 
    
 * 
  • {@link org.springframework.context.EnvironmentAware EnvironmentAware}
    • 
 * 
  • {@link org.springframework.beans.factory.BeanFactoryAware BeanFactoryAware}
 * 
  • {@link org.springframework.beans.factory.BeanClassLoaderAware BeanClassLoaderAware}
 * 
  • {@link org.springframework.context.ResourceLoaderAware ResourceLoaderAware}
 * 

 *
 * 
See implementations and associated unit tests for usage examples.
 *
 * @author Chris Beams
 * @since 3.1
 * @see Import
 * @see ImportSelector
 * @see Configuration
 */
public interface ImportBeanDefinitionRegistrar {

    /**
     * Register bean definitions as necessary based on the given annotation metadata of
     * the importing {@code @Configuration} class.
     * 
Note that {@link BeanDefinitionRegistryPostProcessor} types may not be
     * registered here, due to lifecycle constraints related to {@code @Configuration}
     * class processing.
     * @param importingClassMetadata annotation metadata of the importing class
     * @param registry current bean definition registry
     */
    public void registerBeanDefinitions(
            AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry);

}

翻译“Interface to be implemented by types that register additional bean definitions when processing @{@link Configuration} classes.”得知，该接口提供了注册bean的功能支持，而registerBeanDefinitions则是bean注册的方法。 AnnotationMetadata是bean的元注解对象 ，BeanDefinitionRegistry是当前注册的bean的注册表，
我们继续跟踪一下 FeignClientsRegistrar#registerBeanDefinitions 方法

@Override
    public void registerBeanDefinitions(AnnotationMetadata metadata,
            BeanDefinitionRegistry registry) {
        registerDefaultConfiguration(metadata, registry);
        registerFeignClients(metadata, registry);
    }

registerDefaultConfiguration(metadata, registry);注册默认配置，我们跟踪一下源码

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();
            }
                      //name以  "default."+类名
            registerClientConfiguration(registry, name,
                    defaultAttrs.get("defaultConfiguration"));
        }
    }

这里获取了主程序配置类的@EnableFeignClients注解中的feign默认配置 ，然后用 “default.” 开头加上类名作为名字来注册 ,继续跟踪

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

这里把 configuration 配置交给了 BeanDefinitionBuilder然后去创建了一个 FeignClientSpecification 对象出来 ，然后调用BeanDefinitionRegistry的registerBeanDefinition方法把 包装了配置类的FeignClientSpecification对象进行注册，注册到哪儿去了呢？最终会调用BeanDefinitionRegistryd的子类DefaultListableBeanFactory#registerBeanDefinition方法注册

...省略代码...
/** Map of bean definition objects, keyed by bean name */
private final Map beanDefinitionMap = new ConcurrentHashMap<>(256);

@Override
    public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
            throws BeanDefinitionStoreException {
  ...省略代码...
    this.beanDefinitionMap.put(beanName, beanDefinition);

这里最终会put到一个线程安全的map：beanDefinitionMap = new ConcurrentHashMap<>(256); 中，这个东西就是ico容器o(￣︶￣)o 。

回过头来我们继续看 FeignClientsRegistrar#registerBeanDefinitions 方法

@Override
    public void registerBeanDefinitions(AnnotationMetadata metadata,
            BeanDefinitionRegistry registry) {
        //注册默认配置到ioc容器中
        registerDefaultConfiguration(metadata, registry);
        registerFeignClients(metadata, registry);
    }

到这里我们已经知道 registerDefaultConfiguration(metadata, registry);注册默认配置，那么 registerFeignClients(metadata, registry);方法看名字应该是注册所有的feignClient的bean，我们一步一步进去看

public void registerFeignClients(AnnotationMetadata metadata,
            BeanDefinitionRegistry registry) {
//得到组件扫描器，resourceLoader是资源加载器，
//比如加载spring配置文件就会用到ResourceLoader
        ClassPathScanningCandidateComponentProvider scanner = getScanner();
        scanner.setResourceLoader(this.resourceLoader);

        Set basePackages;
  //获取元注解上EnableFeignClients的属性配置
        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) {
                //扫描候选的组件，会把basePackage报下的bean都扫描到，然后过滤出打了 @FeignClient 标签的接口，封装成 BeanDefinition bean描述对象
            Set candidateComponents = scanner
                    .findCandidateComponents(basePackage);
            for (BeanDefinition candidateComponent : candidateComponents) {
                if (candidateComponent instanceof AnnotatedBeanDefinition) {
                    // verify annotated class is an interface
                    AnnotatedBeanDefinition beanDefinition = (AnnotatedBeanDefinition) candidateComponent;
                     //获取FeignClient接口上的的注解(我定义的FeignClient接口是MyFeignClient)
                    AnnotationMetadata annotationMetadata = beanDefinition.getMetadata();
                      //如果贴上 @FeignClient标签的不是接口，抛出异常
                    Assert.isTrue(annotationMetadata.isInterface(),
                            "@FeignClient can only be specified on an interface");
                      //获取到@FeignClient 注解上我们配置的所有属性
                    Map attributes = annotationMetadata
                            .getAnnotationAttributes(
                                    FeignClient.class.getCanonicalName());
//获取@FeignClient标签的服务名我这指定是“PRODUCER”
//(@FeignClient(value = "PRODUCER",configuration = FooConfiguration.class,fallback = MyFeignClientImpl.class))
                    String name = getClientName(attributes);

//注册配置对象：即会获取到configuration = FooConfiguration.class然后实现注册(将bean封装成beanDefinition对象放到ioc容器中)，
//而FooConfiguration中我们自己实现了负载均衡规则
                    registerClientConfiguration(registry, name,
                            attributes.get("configuration"));
                      //注册 registerFeign
                    registerFeignClient(registry, annotationMetadata, attributes);
                }
            }
        }

这里面做的事情挺多的
1.通过组件扫描器ClassPathScanningCandidateComponentProvider
2.获取元注解所在配置类的包名，
3.然后通过ClassPathScanningCandidateComponentProvider扫描打了@FeignClient标签的接口 ，然后封装成 Set
4.获取 FeignClient 接口上的 @FeignClient标签的配置类，完成注册
5.完成 FeignClient接口本身的注册

我们继续跟踪 registerFeignClient 方法

private void registerFeignClient(BeanDefinitionRegistry registry,
            AnnotationMetadata annotationMetadata, Map attributes) {
        String className = annotationMetadata.getClassName();
//这里使用了FeignClientFactoryBean 
        BeanDefinitionBuilder definition = BeanDefinitionBuilder
                .genericBeanDefinition(FeignClientFactoryBean.class);
        validate(attributes);
//这里把FeignClient的所有配置属性都设置给了 FeignClientFactoryBean
        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);
      //取别名 FeignClient结尾
        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 });
            //注册 FeignClientFactoryBean
        BeanDefinitionReaderUtils.registerBeanDefinition(holder, registry);
    }

这里使用 FeignClientFactoryBean来封装 FeignClient的描述信息 ，并且注册到ioc容器中 ，使用FeignClientFactoryBean 的目的是为了在spring容器刷新过程中会使用代理工厂来创建出代理类(你是否想过，我们的MyFeignClient始终是个接口，那么他是如何实现远程服务的调用的？肯定需要创建出具体的实例去处理)，我们跟踪一下 FeignClientFactoryBean

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;
...省略代码...
    @Override
    public Object getObject() throws Exception {
        return getTarget();
    }
...省略代码...
 T getTarget() {
//初始化Feign上下文对象,使用的TraceFeignContext的实例
        FeignContext context = applicationContext.getBean(FeignContext.class);
//Feign.Builder用来创建feign的构建器
        Feign.Builder builder = feign(context);
            //判断 @FeignClient 是否配置url,这里的url，name等都是从@FeignClient读取过来的
        if (!StringUtils.hasText(this.url)) {
            String url;
            //拼接http协议地址
            if (!this.name.startsWith("http")) {
                url = "http://" + this.name;
            }
            else {
                url = this.name;
            }
                  //给服务名拼接地址，
                  //如果是@FeignClient(value="PRODUCER") ,那么这里就是拼接成 http://PRODUCER
            url += cleanPath();
                    //创建负载均衡的代理类，底层使用到了jdk动态代理，见：feign.ReflectiveFeign#newInstance方法
            return (T) loadBalance(builder, context, new HardCodedTarget<>(this.type,
                    this.name, url));
        }
//如果url不为空，
        if (StringUtils.hasText(this.url) && !this.url.startsWith("http")) {
            this.url = "http://" + this.url;
        }
        String url = this.url + cleanPath();
        Client client = getOptional(context, Client.class);
        if (client != null) {
            if (client instanceof LoadBalancerFeignClient) {
                // not load balancing because we have a url,
                // but ribbon is on the classpath, so unwrap
                client = ((LoadBalancerFeignClient)client).getDelegate();
            }
            builder.client(client);
        }
            //创建默认的代理类
        Targeter targeter = get(context, Targeter.class);
        return (T) targeter.target(this, builder, context, new HardCodedTarget<>(
                this.type, this.name, url));
    }
....省略代码..
 
 
首先FeignClientFactoryBean实现了 FactoryBean ，而FactoryBean就是spring提供给我们实例化bean的一种方式，bean的实例化过程在 getObject 方法中进行处理 ，而在这里他在getObject方法中调用getTarget()方法。
 这个方法里面做了很多事情
 1.首先获取FeignContext feigin上下文对象，可以把它理解为是feign的容器对象，而FeignContext使用FeignClientsConfiguration进行配置，在FeignClientsConfiguration中会把feignClient相关的配置绑定到FeignContext中
 
 
public class FeignContext extends NamedContextFactory {

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

}
----------------------------------------------------------------------
@Configuration
@ConditionalOnClass(Feign.class)
@EnableConfigurationProperties({FeignClientProperties.class, FeignHttpClientProperties.class})
public class FeignAutoConfiguration {

    @Autowired(required = false)
    private List configurations = new ArrayList<>();

    @Bean
    public HasFeatures feignFeature() {
        return HasFeatures.namedFeature("Feign", Feign.class);
    }

    @Bean
    public FeignContext feignContext() {
        FeignContext context = new FeignContext();
              //绑定配置
        context.setConfigurations(this.configurations);
        return context;
    }

 
 
2.Feign.Builder builder = feign(context); 获取Feign构建器
 3.判断 url是否为null，如果为null则创建负载均衡的代理对象
 4.如果url不为null，创建默认的代理对象
 
 
我们继续跟踪一下 feign(context)方法
 
 
protected Feign.Builder feign(FeignContext context) {
        FeignLoggerFactory loggerFactory = get(context, FeignLoggerFactory.class);
        Logger logger = loggerFactory.create(this.type);
    //获取Feign.Builder 
        // @formatter:off
        Feign.Builder builder = get(context, Feign.Builder.class)
                // required values
                .logger(logger)
                .encoder(get(context, Encoder.class))
                .decoder(get(context, Decoder.class))
                .contract(get(context, Contract.class));
        // @formatter:on

        configureFeign(context, builder);

        return builder;
    }

............
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);
        }
//设置重试策略到 Feign.Builder
        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();
        }
    }

 
 
这里获取到 builder 之后又做了后续的一些设置，比如重试策略 ，错误处理，请求超时时间设定等 。
 我们跟踪一下 Feign.Builder builder = get(context, Feign.Builder.class) 方法
 
 
protected  T get(FeignContext context, Class type) {
//调用 TraceFeignContext的getInstance方法,根据name即服务的名字来创建builder
        T instance = context.getInstance(this.name, type);
        if (instance == null) {
            throw new IllegalStateException("No bean found of type " + type + " for "
                    + this.name);
        }
        return instance;
    }
...............................
public  T getInstance(String name, Class type) {
        AnnotationConfigApplicationContext context = getContext(name);
        if (BeanFactoryUtils.beanNamesForTypeIncludingAncestors(context,
                type).length > 0) {
         //创建builder
            return context.getBean(type);
        }
        return null;
    }
...............................

    protected AnnotationConfigApplicationContext getContext(String name) {
//这里的参数name就是目标服务的名字，如果contexts中没有就创建一个放进去
        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中是否存在实例(Map contexts = new ConcurrentHashMap<>();)，如果不存在就根据名字创建一个(这里使用了AnnotationConfigApplicationContext进行封装)放入进去，其实就是在做缓存,我们跟踪一下 createContext方法看下怎么创建的
 
 

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);
            }
        }
//加载主程序配置类的@EnableFeignClients注解指定的配置， 还记得最开始会扫描配置类并以“default”开头为key注册到ioc中吗？
        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.setDisplayName(generateDisplayName(name));
        context.refresh();
        return context;
    }

 
 
我们可以看到这里每调用一个次 createContext方法就会根据服务名字去创建一个新的AnnotationConfigApplicationContext 容器对象，然后获取Feign的配置类给context绑定 ，最后会调用context.refresh();容器刷新，最后会调用 context.getBean(type); 创建出一个 FeignBuilder出来
 
 
回到我们的主线 org.springframework.cloud.openfeign.FeignClientFactoryBean#getTarget方法 ，我们看下 return (T) loadBalance(builder, context, new HardCodedTarget<>(this.type,this.name, url));部分是如何创建负载均衡的代理类的
 
 
protected  T loadBalance(Feign.Builder builder, FeignContext context,
            HardCodedTarget target) {
//获得FeignClient
        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 client = getOptional(context, Client.class); 这里会调用TraceFeignContext#getInstance方法获取到 Client对象，而Client有三个子实现 ，当我们使用了Feign ，这里会使用LoadBalancerFeignClient ，看名字就能知道他是一个负载均衡的FeignClient客户端 ，我们跟踪一下targeter.target，这里在创建代理类
 
 
class HystrixTargeter implements Targeter {

    @Override
    public  T target(FeignClientFactoryBean factory, Feign.Builder feign, FeignContext context,
                        Target.HardCodedTarget target) {
        if (!(feign instanceof feign.hystrix.HystrixFeign.Builder)) {
            return feign.target(target);
        }
------------------------------------
   public  T target(Target target) {
      return build().newInstance(target);
    }

    public Feign build() {
      SynchronousMethodHandler.Factory synchronousMethodHandlerFactory =
          new SynchronousMethodHandler.Factory(client, retryer, requestInterceptors, logger,
                                               logLevel, decode404, closeAfterDecode);
      ParseHandlersByName handlersByName =
          new ParseHandlersByName(contract, options, encoder, decoder, queryMapEncoder,
                                  errorDecoder, synchronousMethodHandlerFactory);
      return new ReflectiveFeign(handlersByName, invocationHandlerFactory, queryMapEncoder);
    }
  }

 
 
这里调用到了 HystrixTargeter的target方法，调用 Feign的target方法，通过 ReflectiveFeign 工具类的 newInstance 创建实例
 
 
 public  T newInstance(Target target) {
//target封装了FeignClient ，这里在获取FeignClient接口的方法封装为MethodHandler
    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，接收请求，转发到methodHandler
    InvocationHandler handler = factory.create(target, methodToHandler);
//动态代理创建出代理类
    T proxy = (T) Proxy.newProxyInstance(target.type().getClassLoader(), new Class[]{target.type()}, handler);

    for(DefaultMethodHandler defaultMethodHandler : defaultMethodHandlers) {
      defaultMethodHandler.bindTo(proxy);
    }
    return proxy;
  }

 
 
这里在获取 FeignClient接口的方法，然后封装到 MethodHandler ，如果继续跟踪targetToHandlersByName.apply(target);你会看到他底层对FeignClient的元注解做了解析
 
 
   public Map apply(Target key) {
//解析FeignClient接口上的注解，把配置信息封装到MethodMetadata，
//并且MethodMetadata中会有一个RequestTemplate对象会封装好要请求的服务名,参数类型等信息
      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 {
//根据元注解创建出BuildTemplateByResolvingArgs对象，而这个东西其实就是RequestTemplate的工厂
          buildTemplate = new BuildTemplateByResolvingArgs(md, queryMapEncoder);
        }
//这里在创建 MethodHandler ，
        result.put(md.configKey(),
                   factory.create(key, md, buildTemplate, options, decoder, errorDecoder));
      }
      return result;
    }

 
 
，获取到MethodHandler，然后根据 FeignClient 时间jdk动态代理创建出代理类
 InvocationHandler handler = factory.create(target, methodToHandler);的底层会把 target和 methodToHandler封装到 FeignInvocationHandler ，而FeignInvocationHandler就是对InvocationHandler的实现，当我们在代码中调用FeignClient接口实现远程调用时，代理类就会被执行，即 FeignInvocationHandler的invoke接受到请求时就会调用 methodToHandler的方法 。源码如下
 
 
 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);
    }


 
 
dispatch.get(method).invoke(args) 这里在获取要执行的方法(MethodHandler),然后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) {
      //重试机制继续或传播
        retryer.continueOrPropagate(e);
        if (logLevel != Logger.Level.NONE) {
          logger.logRetry(metadata.configKey(), logLevel);
        }
        continue;
      }
    }
  }

 
 
可以看到这里创建了RequestTemplate请求模板 ，然后调用executeAndDecode执行请求，并且对重试机制做了处理，我们跟踪一下buildTemplateFromArgs.create(argv);
 
 
 @Override
    public RequestTemplate create(Object[] argv) {
//创建请求模板，metadata.template()获取到的就是一个RequestTemplate，只是这里面的RequestTemplate对请求服务id，参数等做了封装
      RequestTemplate mutable = new RequestTemplate(metadata.template());
      if (metadata.urlIndex() != null) {
        int urlIndex = metadata.urlIndex();
        checkArgument(argv[urlIndex] != null, "URI parameter %s was null", urlIndex);

        mutable.insert(0, String.valueOf(argv[urlIndex]));
      }
      Map varBuilder = new LinkedHashMap();
      for (Entry> entry : metadata.indexToName().entrySet()) {
        int i = entry.getKey();
        Object value = argv[entry.getKey()];
        if (value != null) { // Null values are skipped.
          if (indexToExpander.containsKey(i)) {
            value = expandElements(indexToExpander.get(i), value);
          }
//这里在把请求参数放到map中
          for (String name : entry.getValue()) {
            varBuilder.put(name, value);
          }
        }
      }
//解析处理请求地址，参数，和编码等
      RequestTemplate template = resolve(argv, mutable, varBuilder);
      if (metadata.queryMapIndex() != null) {
        // add query map parameters after initial resolve so that they take
        // precedence over any predefined values
        Object value = argv[metadata.queryMapIndex()];
        Map queryMap = toQueryMap(value);
        template = addQueryMapQueryParameters(queryMap, template);
      }

      if (metadata.headerMapIndex() != null) {
        template = addHeaderMapHeaders((Map) argv[metadata.headerMapIndex()], template);
      }

      return template;
    }

 
 
这里在封装RequestTemplate请求模板和处理请求地址和参数，我们继续跟踪 executeAndDecode 方法，看一下是如何执行的
 
 

 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 {
//调用LoadBalancerFeignClient负载均衡器客户端执行请求
      response = client.execute(request, options);
      // ensure the request is set. TODO: remove in Feign 10
      response.toBuilder().request(request).build();
    } catch (IOException e) {
...省略代码...


 
 
这里调用了 LoadBalancerFeignClient的execute方法
 
 
@Override
    public Response execute(Request request, Request.Options options) throws IOException {
        try {
//得到完整的请求地址 http://xxxx/xx?xx=xx
            URI asUri = URI.create(request.url());
            String clientName = asUri.getHost();
            URI uriWithoutHost = cleanUrl(request.url(), clientName);
//构建  FeignLoadBalancer.RibbonRequest Feign负载均衡的请求对象
            FeignLoadBalancer.RibbonRequest ribbonRequest = new FeignLoadBalancer.RibbonRequest(
                    this.delegate, request, uriWithoutHost);

//客户端配置
            IClientConfig requestConfig = getClientConfig(options, clientName);
//发送请求
            return lbClient(clientName).executeWithLoadBalancer(ribbonRequest,
                    requestConfig).toResponse();
        }
        catch (ClientException e) {
            IOException io = findIOException(e);
            if (io != null) {
                throw io;
            }
            throw new RuntimeException(e);
        }
    }
-------------------------------------------------
public T executeWithLoadBalancer(final S request, final IClientConfig requestConfig) throws ClientException {
        LoadBalancerCommand command = 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();
        } catch (Exception e) {
            Throwable t = e.getCause();
            if (t instanceof ClientException) {
                throw (ClientException) t;
            } else {
                throw new ClientException(e);
            }
        }
        
    }

 
 
这里调用AbstractLoadBalancerAwareClient#executeWithLoadBalancer 方法名的大致意思是 使用负载均衡的方式去执行请求 ，而call(Server server) 的Server这是进行了负载均衡选择后的调用目标服务，那么是如何进行选择的呢，我们跟踪一下 command.submit方法
 
 
com.netflix.loadbalancer.reactive.LoadBalancerCommand#submit：
============================================================
 public Observable submit(final ServerOperation operation) {
        final ExecutionInfoContext context = new ExecutionInfoContext();
        
        if (listenerInvoker != null) {
            try {
                listenerInvoker.onExecutionStart();
            } catch (AbortExecutionException e) {
                return Observable.error(e);
            }
        }

        final int maxRetrysSame = retryHandler.getMaxRetriesOnSameServer();
        final int maxRetrysNext = retryHandler.getMaxRetriesOnNextServer();

        // 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);
                        final ServerStats stats = loadBalancerContext.getServerStats(server);
                        

 
 
selectServer()在选择调用的服务 ，我们跟踪进去
 
 
com.netflix.loadbalancer.reactive.LoadBalancerCommand#selectServer
============================================================
    private Observable selectServer() {
        return Observable.create(new OnSubscribe() {
            @Override
            public void call(Subscriber next) {
                try {
//从LoadBalancer中选择服务
                    Server server = loadBalancerContext.getServerFromLoadBalancer(loadBalancerURI, loadBalancerKey);   
                    next.onNext(server);
                    next.onCompleted();
                } catch (Exception e) {
                    next.onError(e);
                }
            }
        });
    }
---------------------------------------
com.netflix.loadbalancer.LoadBalancerContext#getServerFromLoadBalancer

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

        // Various Supported Cases
        // The loadbalancer to use and the instances it has is based on how it was registered
        // In each of these cases, the client might come in using Full Url or Partial URL
        ILoadBalancer lb = getLoadBalancer();
        if (host == null) {
            // Partial URI or no URI Case
            // well we have to just get the right instances from lb - or we fall back
            if (lb != null){
//选择服务，lb就是LoadBalancer
                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;
......
============================================================
public class ZoneAwareLoadBalancer extends DynamicServerListLoadBalancer {
    ......
//选择服务
 @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);
        }
        Server server = null;
        try {
            LoadBalancerStats lbStats = getLoadBalancerStats();
            Map zoneSnapshot = ZoneAvoidanceRule.createSnapshot(lbStats);
......

public abstract class PredicateBasedRule extends ClientConfigEnabledRoundRobinRule {
  @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;
        }       
    }
----------------------------------------
   /**                                                                                                                                                
    * Choose a server in a round robin fashion after the predicate filters a given list of servers and load balancer key.        

轮询的方式选择服务                     
    */                                                                                                                                                
   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())));                                                                      
   }                                                                                                                                                  


 
 
看到这里你是否看到了熟悉的代码，没错我们一路跟踪最终发现这里的服务选择和上一章Robin的负载均衡选择服务的代码是一样的 ，因为 Feign默认是集成了Ribbon技术默认轮询，当然也可以添加自己的负载均衡规则
 
 
远程调用服务我们已经知道是如何进行选择的了，我们继续跟踪一下看下是怎么调用服务的，回到主线 FeignLoadBalancer. execute
 
 
----------------------------------------------------
public class FeignLoadBalancer extends
        AbstractLoadBalancerAwareClient {
...省略代码......
@Override
    public RibbonResponse execute(RibbonRequest request, IClientConfig configOverride)
            throws IOException {
        Request.Options options;
        if (configOverride != null) {
            RibbonProperties override = RibbonProperties.from(configOverride);
            options = new Request.Options(
                    override.connectTimeout(this.connectTimeout),
                    override.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);
    }

.......方法调用链太长.省略......
 public static class Default implements Client {

    private final SSLSocketFactory sslContextFactory;
    private final HostnameVerifier hostnameVerifier;

    /**
     * Null parameters imply platform defaults.
     */
    public Default(SSLSocketFactory sslContextFactory, HostnameVerifier hostnameVerifier) {
      this.sslContextFactory = sslContextFactory;
      this.hostnameVerifier = hostnameVerifier;
    }

    @Override
    public Response execute(Request request, Options options) throws IOException {
      HttpURLConnection connection = convertAndSend(request, options);
      return convertResponse(connection).toBuilder().request(request).build();
    }
//发送请求啦，最终调用了feign.Client.Default#convertAndSend方法使用HttpUrlConnection发送请求
    HttpURLConnection convertAndSend(Request request, Options options) throws IOException {
      final HttpURLConnection
          connection =
          (HttpURLConnection) new URL(request.url()).openConnection();
      if (connection instanceof HttpsURLConnection) {
        HttpsURLConnection sslCon = (HttpsURLConnection) connection;
        if (sslContextFactory != null) {
          sslCon.setSSLSocketFactory(sslContextFactory);
        }
        if (hostnameVerifier != null) {
          sslCon.setHostnameVerifier(hostnameVerifier);
        }
      }
      connection.setConnectTimeout(options.connectTimeoutMillis());
      connection.setReadTimeout(options.readTimeoutMillis());
      connection.setAllowUserInteraction(false);
      connection.setInstanceFollowRedirects(options.isFollowRedirects());
      connection.setRequestMethod(request.method());

      Collection contentEncodingValues = request.headers().get(CONTENT_ENCODING);
      boolean
          gzipEncodedRequest =
          contentEncodingValues != null && contentEncodingValues.contains(ENCODING_GZIP);
      boolean
          deflateEncodedRequest =
          contentEncodingValues != null && contentEncodingValues.contains(ENCODING_DEFLATE);

      boolean hasAcceptHeader = false;
      Integer contentLength = null;
      for (String field : request.headers().keySet()) {
        if (field.equalsIgnoreCase("Accept")) {
          hasAcceptHeader = true;
        }
        for (String value : request.headers().get(field)) {
          if (field.equals(CONTENT_LENGTH)) {
            if (!gzipEncodedRequest && !deflateEncodedRequest) {
              contentLength = Integer.valueOf(value);
              connection.addRequestProperty(field, value);
            }
          } else {
            connection.addRequestProperty(field, value);
          }
        }
      }
      // Some servers choke on the default accept string.
      if (!hasAcceptHeader) {
        connection.addRequestProperty("Accept", "*/*");
      }

      if (request.body() != null) {
        if (contentLength != null) {
          connection.setFixedLengthStreamingMode(contentLength);
        } else {
          connection.setChunkedStreamingMode(8196);
        }
        connection.setDoOutput(true);
        OutputStream out = connection.getOutputStream();
        if (gzipEncodedRequest) {
          out = new GZIPOutputStream(out);
        } else if (deflateEncodedRequest) {
          out = new DeflaterOutputStream(out);
        }
        try {
          out.write(request.body());
        } finally {
          try {
            out.close();
          } catch (IOException suppressed) { // NOPMD
          }
        }
      }
      return connection;
    }


 
 
最终还是使用了HttpURLConnection来实现远程调用
 
 
好吧大致总结一下步骤：
 
 
     
  
  1. EnableFeignClients开启 feign功能后会调用 FeignClientsRegistrar 的registerBeanDefinitions方法来给bean的注册
    2.  
  
  2. FeignClientsRegistrar.registerBeanDefinitions方法中会调用 FeignClientsRegistrar .registerDefaultConfiguration方法通过获取主程序配置类的原始注解扫描到Feign的配置类，并以“default”开头为key对配置类进行注册(在给 feign代理上下文对象时会用到)
    3.  
 
 
 
3.然后会调用 FeignClientsRegistrar .registerBeanDefinitions方法中会调用 FeignClientsRegistrar. registerFeignClients方法去注册FeignClient(生成代理类时当然要知道FeignClient接口是哪个)
 
 
4.扫描并获取到FeiginClient 接口，然后获取到FeignClient的配置相关属性进行注册(这里的注册其实就是用一个map存储起来，后面拿来用)
 
 
5.使用 FeignClientFactoryBean 对FeignClient进行封装(设置FeignClient的配置属性等)，然后再使用BeanDefinitionHolder进行包裹，最后交给BeanDefinitionReaderUtils.registerBeanDefinition进行注册
 
 
6.而 FeignClientFactoryBean 中的 getObject 方法根据FeignClient的配置属性中的url时候有值来决定是否创建负载均衡的FeignClient接口的代理 ，如果咩有设置url者创建负载均衡的FeignClient代理实例
 
 
7.底层使用jdk动态代理去创建代理类，底层调用是用到了LoadBalancerFeignClient负载均衡客户端，调用FeignLoadBalancer.execute ,使用Ribbon的负载均衡选择服务,最终使用到HttpURLConnection发送请求
 
 
 
  
想获取更多技术干货，请前往叩丁狼官网：http://www.wolfcode.cn/all_article.html
 
 
 

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(SpringCloud-源码分析 Feign)

        

            

                
    
                    
  • JVM源码分析之堆外内存完全解读
                        HeapDump性能社区

                        
    概述广义的堆外内存说到堆外内存，那大家肯定想到堆内内存，这也是我们大家接触最多的，我们在jvm参数里通常设置-Xmx来指定我们的堆的最大值，不过这还不是我们理解的Java堆，-Xmx的值是新生代和老生代的和的最大值，我们在jvm参数里通常还会加一个参数-XX:MaxPermSize来指定持久代的最大值，那么我们认识的Java堆的最大值其实是-Xmx和-XX:MaxPermSize的总和，在分代算法
    
                    
    • 
                    
  • Golang Channel
                        PandaSkr
golang
                        
    Channel解析1.Channel源码分析1.1Channel数据结构typehchanstruct{qcountuint//channel的元素数量dataqsizuint//channel循环队列长度bufunsafe.Pointer//指向循环队列的指针elemsizeuint16//元素大小closeduint32//channel是否关闭0-未关闭elemtype*_type//元素类
    
                    
    • 
                    
  • Java集合类框架源码分析 之 RoleList源码解析 【6】
                        yunzhonghefei
Java集合类源码分析RoleList源码解析
                        
    该类继承于ArrayList，针对Role进行了一些扩展。其他方法和ArrayList中基本相同，源码不做针对性分析：看一下类简介：/***代表了一个roles的列表，作为方法setRoles()的参数，去创建一个关联关系，并且尝试在同一个关系中设置多个角色。*ARoleListrepresentsalistofroles(Roleobjects).Itisusedas*parameterwhen
    
                    
    • 
                    
  • 【鸿蒙OH-v5.0源码分析之 Linux Kernel 部分】004 - Kernel 启动引导代码head.S 源码逐行分析
                        "小夜猫&小懒虫&小财迷"的男人
鸿蒙OH-v5.0源码分析之Uboot+Kernel部分harmonyoslinux华为
                        
    【鸿蒙OH-v5.0源码分析之LinuxKernel部分】004-Kernel启动引导代码head.S源码逐行分析系列文章汇总：《鸿蒙OH-v5.0源码分析之Uboot+Kernel部分】000-文章链接汇总》本文链接：《【鸿蒙OH-v5.0源码分析之LinuxKernel部分】004-Kernel启动引导代码head.S源码逐行分析》head.S主要工作如下：保存内核启动参数,无效化处理器缓存(
    
                    
    • 
                    
  • Open Feign 实战笔记
                        自强-X
spring-cloudjavaspring微服务ribbonspringcloud
                        
    OpenFeign笔记概念声明式的web服务客户端。使用接口加注解的形式编程。它是对RestTemplate和ribbon做了进一步封装。Feign已经停更，OpenFeign是在Feign的基础上又做了进一步的封装。Feign：Feign是SpringCloud组件中的一个轻量级RESTful的HTTP服务客户端Feign内置了Ribbon，用来做客户端负载均衡，去调用服务注册中心的服务。Fei
    
                    
    • 
                    
  • Spring Cloud: Hystrix请求队列线程不足
                        MeazZa

                        
    在SpringCloud中，Feign可以实现本地化的微服务API调用，Hystrix可以实现调用失败时的fallback处理。问题描述：在实际生产环境中使用时，我们遇到了这样一个错误："...,stacktrace:[com.netflix.hystrix.exception.HystrixRuntimeException:QueryNodeImpalaBdService#getQueryRes
    
                    
    • 
                    
  • Java高并发编程详解系列-深入理解Thread构造
                        nihui123
高并发Java高并发Java高并发
                        
    上篇分享中主要是对线程的基本概念和基本操作做了一个分享，同时提出了两种常用的创建多线程的方法，当然在后期的分享中也会提及到更多的创建线程的方式，到后期的分享的时候再说。这次主要是深入的理解一下Thread的构造函数，通过构造函数对于Thread有一个更加深入的了解。这里首先提供一个JDK1.6的ThreadAPI截图线程命名规范  从源码分析可以看到在Thread类中默认提供了线程的命名方式，这个
    
                    
    • 
                    
  • 【QT教程】QT6硬件图形界面编程 QT硬件编程
                        QT性能优化QT原理源码QT界面美化
qtqt6.3qt5c++QT教程
                        
    QT6硬件图形界面编程使用AI技术辅助生成QT界面美化视频课程QT性能优化视频课程QT原理与源码分析视频课程QTQMLC++扩展开发视频课程免费QT视频课程您可以看免费1000+个QT技术视频免费QT视频课程QT统计图和QT数据可视化视频免费看免费QT视频课程QT性能优化视频免费看免费QT视频课程QT界面美化视频免费看1QT6硬件图形界面编程概述1.1QT6硬件图形界面编程简介1.1.1QT6硬件
    
                    
    • 
                    
  • Jetpack LiveData源码分析
                        xiangxiongfly915
#AndroidJetpack系列JetpackLiveData源码分析
                        
    文章目录JetpackLiveData源码分析前提源码分析注册订阅流程LiveData#observe()LifecycleRegistry#addObserver()ObserverWithState#dispatchEvent()LiveData#removeObserver()LiveData$LifecycleBoundObserver类LifecycleBoundObserver#sho
    
                    
    • 
                    
  • ExoPlayer架构详解与源码分析（17）——TrackSelector
                        山雨楼
ExoPlayer架构android音视频ExoPlayerMedia3源码
                        
    系列文章目录ExoPlayer架构详解与源码分析（1）——前言ExoPlayer架构详解与源码分析（2）——PlayerExoPlayer架构详解与源码分析（3）——TimelineExoPlayer架构详解与源码分析（4）——整体架构ExoPlayer架构详解与源码分析（5）——MediaSourceExoPlayer架构详解与源码分析（6）——MediaPeriodExoPlayer架构详解与
    
                    
    • 
                    
  • ExoPlayer架构详解与源码分析（12）——Cache
                        山雨楼
ExoPlayer架构android音视频ExoPlayerMedia3源码
                        
    系列文章目录ExoPlayer架构详解与源码分析（1）——前言ExoPlayer架构详解与源码分析（2）——PlayerExoPlayer架构详解与源码分析（3）——TimelineExoPlayer架构详解与源码分析（4）——整体架构ExoPlayer架构详解与源码分析（5）——MediaSourceExoPlayer架构详解与源码分析（6）——MediaPeriodExoPlayer架构详解与
    
                    
    • 
                    
  • ExoPlayer架构详解与源码分析（7）——SampleQueue(4)
                        2401_83740189
程序员架构
                        
    long[]newSourceIds=newlong[newCapacity];long[]newOffsets=newlong[newCapacity];long[]newTimesUs=newlong[newCapacity];int[]newFlags=newint[newCapacity];int[]newSizes=newint[newCapacity];CryptoData[]newC
    
                    
    • 
                    
  • 项目内部调用的远程接口开发
                        cyt涛
javaOpenFeign远程调用FeignClient内部调用同步调用远程接口
                        
    编写一个项目内部调用的远程接口通常是为了在分布式系统或者微服务架构中，实现各个服务之间的通信和数据交换。这样的远程接口专门用于服务之间的调用，而不是直接暴露给外部用户或前端。项目内部的远程接口统一放在api工程首先进入api编写接口，注意使用@FeignClient注解进入服务提供者微服务，编写接口实现类1.在api工程中编写接口在api工程中，定义远程调用的接口。这个接口将通过Feign进行服务
    
                    
    • 
                    
  • 【HarmonyOS】- 常见算法简单写法
                        数的羊都睡了
HarmonyOSArkTS鸿蒙
                        
    文章目录知识回顾前言源码分析1.冒泡排序2.二分法查找拓展知识时间、空间复杂度总结知识回顾前言常见算法简单写法源码分析1.冒泡排序functionbubbleSort(arr:number[]):number[]{constn=arr.length;for(leti=0;iarr[j+1]){//交换元素consttemp=arr[j];arr[j]=arr[j+1];arr[j+1]=temp;
    
                    
    • 
                    
  • [ docker-ce源码分析系列 ] 修改resolv.conf文件被还原的原因
                        nangonghen
dockerdocker
                        
    1概述：1.1环境版本信息如下：a、操作系统：centos7.6，amd64b、服务器docker版本：v18.09.22resolv.conf文件被还原的现象：容器中的/etc/resolv.conf文件，是由宿主机/var/lib/docker/containers/xxxx/resolv.conf文件挂载。在dockerrestart容器之前，手动修改了/var/lib/docker/con
    
                    
    • 
                    
  • dispatch_once源码分析
                        福伟_Y

                        
    GCD里的单例函数dispatch_once是我们经常会用到的，今天我们来稍做深入分析一下。GCD的源码都在libdispatch.dylib库里，这个库在libSystem_initializer被初始化，可理解为在dyld里被加载和初始化的(之前的文章有分析过)。dispatch_once作为单例的使用入口，通过分析得到它是一个宏定义，_dispatch_once函数在libdispatch.
    
                    
    • 
                    
  • Hystrix&Feign
                        快乐肥翟z
hystrixjava运维
                        
    Hystrix1，概念Hystrix是一个用于处理分布式系统的延迟和容错的开源库，可以保证一个服务出现故障时，不会导致整个系统出现雪崩效应，以提高分布式系统弹性；作为“断路器”，在一个服务出现故障时，可以通过短路器监控，返回一个可以处理的响应结果，保证服务调用线程不会长时间被占用，避免故障蔓延。雪崩当一个服务器中要同时处理多个请求时，当一个请求无法正确响应，请求超时。会将请求阻塞到该服务的线程池中
    
                    
    • 
                    
  • feign和hystrix
                        小林嘞
springcloudhystrixjavaspring
                        
    网上教程说feign中集成了hystrix,但是引入的最新版本的3.1.4版本的feign在运行程序时提示,feign中没有hystrix的实例.于是手动添加:org.springframework.cloudspring-cloud-starter-netflix-hystrix2.2.10.RELEASE同时需要注意,在使用时出现了很多教程说的开启hystrix的方法如下:#开启feign对h
    
                    
    • 
                    
  • jQuery Easyui 源码分析之combo组件
                        90后北京程序员
前端-easyuieasyui之combobox
                        
    /***jQueryEasyUI1.3.1*该源码完全由压缩码翻译而来，并非网络上放出的源码，请勿索要。*/(function($){functionsetSize(target,width){varopts=$.data(target,"combo").options;varcombo=$.data(target,"combo").combo;varpanel=$.data(target,"co
    
                    
    • 
                    
  • html5carousel图片轮播,全面解析Bootstrap中Carousel轮播的使用方法
                        RemusrickCat

                        
    本文实例为大家全面的解析了Bootstrap中Carousel的使用方法，供大家参考，具体内容如下源码文件：Carousel.scssCarousel.js实现原理：隐藏所有要显示的元素，然后指定当前要显示的为block，宽、高自适应源码分析：1、Html结构：主要分为以四个部分1.1、容器：最外层div，需要一个data-ride=”carousel”来指定为轮播放插件，并且提供一个Id，方便圆
    
                    
    • 
                    
  • Java集合-----List接口及其实现类：ArrayList、LinkedList、Vector
                        Colourful．
Java集合java集合
                        
    文章目录List接口概述List接口的常用方法List接口的实现类ArrayList源码分析类继承关系ArrayList中的属性：ArrayList构造函数：ArrayList中常用方法添加操作：add()删除操作：remove()获取元素：get()ArrayList是如何实现序列化的？ArrayList的总结LinkedList源码分析类继承关系类成员属性类构造器LinkedList的List
    
                    
    • 
                    
  • React Native通讯原理
                        zbl_zbl
androidReactNativ
                        
    之前写过一篇文章ReactNativeAndroid源码分析，在此文章的基础上分析和总结下RN与Native的通讯流程。本文基于Android代码分析，iOS实现原理类似。1.通讯框架图先来解析下各个模块的角色与作用：Java层，这块的实现在ReactAndroid中-ReactContext:Android上下文子类，包含一个CatalystInstance实例，用于获取NativeModule
    
                    
    • 
                    
  • Fegin超时时间设置的优先级
                        小胖学编程

                        
    feign的底层是ribbon、ribbon最终借助的是client完成服务调用，且SpringBoot即可以设置feign的超时时间。又可设置ribbon超时时间，还可以设置client(例如okhttp)超时时间。那么超时时间设置的优先级哪个高呢？版本信息：springBoot2.2.6.RELEASEspringCloudHoxton.RELEASEFeign调用流程如下图所示：feign调
    
                    
    • 
                    
  • [linux 驱动]增加一个文件节点控制led灯亮灭
                        嵌入式成长家
linux内核的系统实战linux驱动linux驱动led灯驱动
                        
    目录1修改设备树2修改驱动3驱动源码3.1驱动源码3.2设备树节点3.3驱动源码分析3.3.1##解释3.3.2class_create解释3.3.3class_create_file解释3.3.4of_get_named_gpio_flags解释3.3.5devm_gpio_request解释3.3.6platform_driver_register解释3.3.7platform_driver_
    
                    
    • 
                    
  • 【QT教程】QT6对话框编程
                        QT性能优化QT原理源码QT界面美化
qtqt6.3qt5c++QT教程
                        
    QT6对话框编程使用AI技术辅助生成QT界面美化视频课程QT性能优化视频课程QT原理与源码分析视频课程QTQMLC++扩展开发视频课程免费QT视频课程您可以看免费1000+个QT技术视频免费QT视频课程QT统计图和QT数据可视化视频免费看免费QT视频课程QT性能优化视频免费看免费QT视频课程QT界面美化视频免费看1QT6对话框编程基础1.1QT6对话框简介1.1.1QT6对话框简介QT6对话框简介
    
                    
    • 
                    
  • 鸿蒙轻内核M核源码分析系列十二 事件Event
                        OpenHarmony_小贾
OpenHarmonyHarmonyOS鸿蒙开发harmonyosopenharmony鸿蒙内核鸿蒙开发移动开发嵌入式硬件驱动开发
                        
    事件（Event）是一种任务间通信的机制，可用于任务间的同步。多任务环境下，任务之间往往需要同步操作，一个等待即是一个同步。事件可以提供一对多、多对多的同步操作。本文通过分析鸿蒙轻内核事件模块的源码，深入掌握事件的使用。本文中所涉及的源码，以OpenHarmonyLiteOS-M内核为例，均可以在开源站点https://gitee.com/openharmony/kernel_liteos_m获取
    
                    
    • 
                    
  • 鸿蒙轻内核M核源码分析系列四 中断Hwi
                        OpenHarmony_小贾
鸿蒙开发OpenHarmonyHarmonyOSharmonyos单片机OpenHarmony嵌入式硬件鸿蒙开发移动开发鸿蒙内核
                        
    在鸿蒙轻内核源码分析系列前几篇文章中，剖析了重要的数据结构。本文，我们讲述一下中断，会给读者介绍中断的概念，鸿蒙轻内核的中断模块的源代码。本文中所涉及的源码，以OpenHarmonyLiteOS-M内核为例。1、中断概念介绍中断是指出现需要时，CPU暂停执行当前程序，转而执行新程序的过程。当外设需要CPU时，将通过产生中断信号使CPU立即中断当前任务来响应中断请求。在剖析中断源代码之前，下面介绍些
    
                    
    • 
                    
  • 鸿蒙轻内核M核源码分析系列五 时间管理
                        OpenHarmony_小贾
HarmonyOSOpenHarmony鸿蒙开发harmonyosopenharmony鸿蒙开发NAPI鸿蒙内核移动开发嵌入式
                        
    在鸿蒙轻内核源码分析上一篇文章中，我们剖析了中断的源码，简单提到了Tick中断。本文会继续分析Tick和时间相关的源码，给读者介绍鸿蒙轻内核的时间管理模块。本文中所涉及的源码，以OpenHarmonyLiteOS-M内核为例，均可以在开源站点https://gitee.com/openharmony/kernel_liteos_m获取。时间管理模块以系统时钟为基础，可以分为2部分，一部分是SysT
    
                    
    • 
                    
  • 鸿蒙轻内核M核源码分析系列六 任务及任务调度（1）任务栈
                        OpenHarmony_小贾
鸿蒙开发OpenHarmonyHarmonyOSHarmonyOSopenharmony鸿蒙开发移动开发鸿蒙内核驱动开发嵌入式硬件
                        
    继续分析鸿蒙轻内核源码，我们本文开始要分析下任务及任务调度模块。首先，我们介绍下任务栈的基础概念。任务栈是高地址向低地址生长的递减栈，栈指针指向即将入栈的元素位置。初始化后未使用过的栈空间初始化的内容为宏OS_TASK_STACK_INIT代表的数值0xCACACACA，栈顶初始化为宏OS_TASK_MAGIC_WORD代表的数值0xCCCCCCCC。一个任务栈的示意图如下，其中，栈底指针是栈的最
    
                    
    • 
                    
  • 鸿蒙轻内核M核源码分析系列三 数据结构-任务排序链表
                        OpenHarmony_小贾
HarmonyOSOpenHarmony鸿蒙开发数据结构harmonyos移动开发OpenHarmony鸿蒙内核鸿蒙开发嵌入式硬件
                        
    在鸿蒙轻内核源码分析系列一和系列二，我们分析了双向循环链表、优先级就绪队列的源码。本文会继续给读者介绍鸿蒙轻内核源码中重要的数据结构：任务排序链表TaskSortLinkAttr。鸿蒙轻内核的任务排序链表，用于任务延迟到期/超时唤醒等业务场景，是一个非常重要、非常基础的数据结构。本文中所涉及的源码，以OpenHarmonyLiteOS-M内核为例。1任务排序链表我们先看下任务排序链接的数据结构。任
    
                    
    • 
                                
  • 关于旗正规则引擎规则中的上传和下载问题
                                    何必如此
文件下载压缩jsp文件上传
                                    
    文件的上传下载都是数据流的输入输出，大致流程都是一样的。 
一、文件打包下载 
1.文件写入压缩包 
string mainPath="D:\upload\";     下载路径 
 
string tmpfileName=jar.zip;        &n
    
                                
    • 
                                
  • 【Spark九十九】Spark Streaming的batch interval时间内的数据流转源码分析
                                    bit1129
Stream
                                    
      
以如下代码为例（SocketInputDStream）： 
Spark Streaming从Socket读取数据的代码是在SocketReceiver的receive方法中，撇开异常情况不谈(Receiver有重连机制，restart方法，默认情况下在Receiver挂了之后，间隔两秒钟重新建立Socket连接)，读取到的数据通过调用store(textRead)方法进行存储。数据
    
                                
    • 
                                
  • spark master web ui 端口8080被占用解决方法
                                    daizj
8080端口占用sparkmaster web ui
                                    
    spark master web ui 默认端口为8080，当系统有其它程序也在使用该接口时，启动master时也不会报错，spark自己会改用其它端口，自动端口号加1，但为了可以控制到指定的端口，我们可以自行设置，修改方法： 
  
1、cd SPARK_HOME/sbin 
  
2、vi start-master.sh 
  
  
3、定位到下面部分
    
                                
    • 
                                
  • oracle_执行计划_谓词信息和数据获取
                                    周凡杨
oracle执行计划
                                    
      
oracle_执行计划_谓词信息和数据获取(上) 
一：简要说明  
在查看执行计划的信息中，经常会看到两个谓词filter和access，它们的区别是什么，理解了这两个词对我们解读Oracle的执行计划信息会有所帮助。 
简单说，执行计划如果显示是access，就表示这个谓词条件的值将会影响数据的访问路径（表还是索引），而filter表示谓词条件的值并不会影响数据访问路径，只起到
    
                                
    • 
                                
  • spring中datasource配置
                                    g21121
dataSource
                                    
    datasource配置有很多种，我介绍的一种是采用c3p0的，它的百科地址是： 
http://baike.baidu.com/view/920062.htm 
  
	<!-- spring加载资源文件 -->
	<bean name="propertiesConfig"
		class="org.springframework.b
    
                                
    • 
                                
  • web报表工具FineReport使用中遇到的常见报错及解决办法（三）
                                    老A不折腾
finereportFAQ报表软件
                                    
    这里写点抛砖引玉，希望大家能把自己整理的问题及解决方法晾出来，Mark一下，利人利己。 
  
出现问题先搜一下文档上有没有，再看看度娘有没有，再看看论坛有没有。有报错要看日志。下面简单罗列下常见的问题，大多文档上都有提到的。 
1、repeated column width is largerthan paper width： 
这个看这段话应该是很好理解的。比如做的模板页面宽度只能放
    
                                
    • 
                                
  • mysql 用户管理
                                    墙头上一根草
linuxmysqluser
                                    
    1.新建用户 //登录MYSQL@>mysql -u root -p@>密码//创建用户mysql> insert into mysql.user(Host,User,Password) values(‘localhost’,'jeecn’,password(‘jeecn’));//刷新系统权限表mysql>flush privileges;这样就创建了一个名为：
    
                                
    • 
                                
  • 关于使用Spring导致c3p0数据库死锁问题
                                    aijuans
springSpring 入门Spring 实例Spring3Spring 教程
                                    
    这个问题我实在是为整个 springsource 的员工蒙羞  
如果大家使用 spring 控制事务，使用 Open Session In View 模式，  
com.mchange.v2.resourcepool.TimeoutException: A client timed out while waiting to acquire a resource from com.mchange.
    
                                
    • 
                                
  • 百度词库联想
                                    annan211
百度
                                    
    

<!DOCTYPE html>
<html>
    <head>
        <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
        <title>RunJS</title&g
    
                                
    • 
                                
  • int数据与byte之间的相互转换实现代码
                                    百合不是茶
位移int转bytebyte转int基本数据类型的实现
                                    
    在BMP文件和文件压缩时需要用到的int与byte转换,现将理解的贴出来; 
  
主要是要理解;位移等概念 http://baihe747.iteye.com/blog/2078029 
  
int转byte; 
  
byte转int; 
  
/**
 * 字节转成int,int转成字节
 * @author Administrator
 *

    
                                
    • 
                                
  • 简单模拟实现数据库连接池
                                    bijian1013
javathreadjava多线程简单模拟实现数据库连接池
                                    
    简单模拟实现数据库连接池 
实例1： 
package com.bijian.thread;

public class DB {

	//private static final int MAX_COUNT = 10;
	private static final DB instance = new DB();

	private int count = 0;
	private i
    
                                
    • 
                                
  • 一种基于Weblogic容器的鉴权设计
                                    bijian1013
javaweblogic
                                    
            服务器对请求的鉴权可以在请求头中加Authorization之类的key，将用户名、密码保存到此key对应的value中，当然对于用户名、密码这种高机密的信息，应该对其进行加砂加密等，最简单的方法如下： 
String  vuser_id = "weblogic";
String  vuse
    
                                
    • 
                                
  • 【RPC框架Hessian二】Hessian 对象序列化和反序列化
                                    bit1129
hessian
                                    
     任何一个对象从一个JVM传输到另一个JVM，都要经过序列化为二进制数据(或者字符串等其他格式，比如JSON)，然后在反序列化为Java对象，这最后都是通过二进制的数据在不同的JVM之间传输(一般是通过Socket和二进制的数据传输)，本文定义一个比较符合工作中。 
  1. 定义三个POJO 
   Person类 
package com.tom.hes
    
                                
    • 
                                
  • 【Hadoop十四】Hadoop提供的脚本的功能
                                    bit1129
hadoop
                                    
    1. hadoop-daemon.sh 
1.1 启动HDFS 
./hadoop-daemon.sh start namenode
./hadoop-daemon.sh start datanode 
 通过这种逐步启动的方式，比start-all.sh方式少了一个SecondaryNameNode进程，这不影响Hadoop的使用，其实在 Hadoop2.0中，SecondaryNa
    
                                
    • 
                                
  • 中国互联网走在“灰度”上
                                    ronin47
管理 灰度
                                    
    中国互联网走在“灰度”上（转） 
文/孕峰 
  
第一次听说灰度这个词，是任正非说新型管理者所需要的素质。第二次听说是来自马化腾。似乎其他人包括马云也用不同的语言说过类似的意思。 
  
灰度这个词所包含的意义和视野是广远的。要理解这个词，可能同样要用“灰度”的心态。灰度的反面，是规规矩矩，清清楚楚，泾渭分明，严谨条理，是决不妥协，不转弯，认死理。黑白分明不是灰度，像彩虹那样
    
                                
    • 
                                
  • java-51-输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字。
                                    bylijinnan
java
                                    
    

public class PrintMatrixClockwisely {

	/**
	 * Q51.输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字。
例如：如果输入如下矩阵：

1              2             3            4
5              6             7            8
9 
    
                                
    • 
                                
  • mongoDB 用户管理
                                    开窍的石头
mongoDB用户管理
                                    
      1:添加用户 
   第一次设置用户需要进入admin数据库下设置超级用户（use admin） 
  
   db.addUsr({user:'useName',pwd:'111111',roles:[readWrite,dbAdmin]}); 
   第一个参数用户的名字 
   第二个参数
    
                                
    • 
                                
  • [游戏与生活]玩暗黑破坏神3的一些问题
                                    comsci
生活
                                    
        暗黑破坏神3是有史以来最让人激动的游戏。。。。但是有几个问题需要我们注意 
 
 
     玩这个游戏的时间，每天不要超过一个小时，且每次玩游戏最好在白天 
 
     结束游戏之后，最好在太阳下面来晒一下身上的暗黑气息，让自己恢复人的生气 
 
  &nb
    
                                
    • 
                                
  • java 二维数组如何存入数据库
                                    cuiyadll
java
                                    
    using System;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.Xml;
using System.Xml.Serialization;
using System.IO;
 
namespace WindowsFormsApplication1
{
    
    
                                
    • 
                                
  • 本地事务和全局事务Local Transaction and Global Transaction(JTA)
                                    darrenzhu
javaspringlocalglobaltransaction
                                    
    Configuring Spring and JTA without full Java EE 
 
http://spring.io/blog/2011/08/15/configuring-spring-and-jta-without-full-java-ee/ 
 
Spring doc -Transaction Management 
 
http://docs.spring.io/spri
    
                                
    • 
                                
  • Linux命令之alias - 设置命令的别名，让 Linux 命令更简练
                                    dcj3sjt126com
linuxalias
                                    
    用途说明 
设置命令的别名。在linux系统中如果命令太长又不符合用户的习惯，那么我们可以为它指定一个别名。虽然可以为命令建立“链接”解决长文件名的问 题，但对于带命令行参数的命令，链接就无能为力了。而指定别名则可以解决此类所有问题【1】。常用别名来简化ssh登录【见示例三】，使长命令变短，使常 用的长命令行变短，强制执行命令时询问等。 
  常用参数 
格式：alias 
格式：ali
    
                                
    • 
                                
  • yii2 restful web服务[格式响应]
                                    dcj3sjt126com
PHPyii2
                                    
    响应格式 
当处理一个 RESTful API 请求时， 一个应用程序通常需要如下步骤 来处理响应格式： 
 
 确定可能影响响应格式的各种因素， 例如媒介类型， 语言， 版本， 等等。 这个过程也被称为 content negotiation。 
 资源对象转换为数组， 如在 Resources 部分中所描述的。 通过 [[yii\rest\Serializer]]
    
                                
    • 
                                
  • MongoDB索引调优（2）——[十]
                                    eksliang
mongodbMongoDB索引优化
                                    
    转载请出自出处：http://eksliang.iteye.com/blog/2178555 一、概述 
      上一篇文档中也说明了，MongoDB的索引几乎与关系型数据库的索引一模一样，优化关系型数据库的技巧通用适合MongoDB，所有这里只讲MongoDB需要注意的地方 二、索引内嵌文档 
    可以在嵌套文档的键上建立索引，方式与正常
    
                                
    • 
                                
  • 当滑动到顶部和底部时，实现Item的分离效果的ListView
                                    gundumw100
android
                                    
    拉动ListView，Item之间的间距会变大，释放后恢复原样； 
 

package cn.tangdada.tangbang.widget;

import android.annotation.TargetApi;
import android.content.Context;
import android.content.res.TypedArray;
import andr
    
                                
    • 
                                
  • 程序员用HTML5制作的爱心树表白动画
                                    ini
JavaScriptjqueryWebhtml5css
                                    
    体验效果：http://keleyi.com/keleyi/phtml/html5/31.htmHTML代码如下： 
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><meta charset="UTF-8" >
<ti
    
                                
    • 
                                
  • 预装windows 8 系统GPT模式的ThinkPad T440改装64位 windows 7旗舰版
                                    kakajw
ThinkPad预装改装windows 7windows 8
                                    
      
该教程具有普遍参考性，特别适用于联想的机器，其他品牌机器的处理过程也大同小异。 
该教程是个人多次尝试和总结的结果，实用性强，推荐给需要的人！ 
  
缘由 
小弟最近入手笔记本ThinkPad T440，但是特别不能习惯笔记本出厂预装的Windows 8系统，而且厂商自作聪明地预装了一堆没用的应用软件，消耗不少的系统资源（本本的内存为4G，系统启动完成时，物理内存占用比
    
                                
    • 
                                
  • Nginx学习笔记
                                    mcj8089
nginx
                                    
    一、安装nginx                      1、在nginx官方网站下载一个包，下载地址是：  
http://nginx.org/download/nginx-1.4.2.tar.gz  
     2、WinSCP(ftp上传工
    
                                
    • 
                                
  • mongodb 聚合查询每天论坛链接点击次数
                                    qiaolevip
每天进步一点点学习永无止境mongodb纵观千象
                                    
    /* 18 */
{
    "_id" : ObjectId("5596414cbe4d73a327e50274"),
    "msgType" : "text",
    "sendTime" : ISODate("2015-07-03T08:01:16.000Z"
    
                                
    • 
                                
  • java术语（PO/POJO/VO/BO/DAO/DTO）
                                    Luob.
DAOPOJODTOpoVO BO
                                    
    
PO(persistant object) 持久对象
在o/r 映射的时候出现的概念,如果没有o/r映射,就没有这个概念存在了.通常对应数据模型(数据库),本身还有部分业务逻辑的处理.可以看成是与数据库中的表相映射的java对象.最简单的PO就是对应数据库中某个表中的一条记录,多个记录可以用PO的集合.PO中应该不包含任何对数据库的操作.

VO(value object) 值对象
通
    
                                
    • 
                                
  • 算法复杂度
                                    Wuaner
Algorithm
                                    
    Time Complexity & Big-O： 
 
http://stackoverflow.com/questions/487258/plain-english-explanation-of-big-o 
 
http://bigocheatsheet.com/ 
 
http://www.sitepoint.com/time-complexity-algorithms/ 
 
 

    
                                
    •