openfeign源码解析

概括

Feign是Netflix开发的声明式、模板化的HTTP客户端,其灵感来自Retrofit、JAXRS-2.0以及WebSocket。 Feign可帮助我们更加便捷、优雅地调用HTTP API。 Feign支持多种注解,例如Feign自带的注解或者JAX-RS注解等。Spring Cloud openfeign对Feign进行了 增强,使其支持Spring MVC注解,另外还整合了Ribbon和Eureka,从而使得Feign的使用更加方便

OpenFeign源码解析

我们先看下添加的依赖

<dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-openfeign</artifactId>
        </dependency>

可以看到starter?看到这个第一反应就是和springboot的自动装配联系在一起,我们去看下fascories文件

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
org.springframework.cloud.openfeign.ribbon.FeignRibbonClientAutoConfiguration,\
org.springframework.cloud.openfeign.FeignAutoConfiguration,\
org.springframework.cloud.openfeign.encoding.FeignAcceptGzipEncodingAutoConfiguration,\
org.springframework.cloud.openfeign.encoding.FeignContentGzipEncodingAutoConfiguration

FeignAutoConfiguration 自动装配 FeignContext 和 Targeter,以及 Client 配置。

FeignContext 是每个 FeignClient 的装配上下文,默认的配置是 FeignClientsConfiguration
Targeter 有两种实现:一是 DefaultTargeter,直接调用 Feign.Builder; 二是 HystrixTargeter,调用 HystrixFeign.Builder,开启熔断。
Client :自动装配 ApacheHttpClient,OkHttpClient,装配条件不满足时,默认就是 Client.Default。但这些 Client 都没有实现负载均衡。

FeignRibbonClientAutoConfiguration 实现负载均衡,负载均衡是在 Client 这一层实现的。

HttpClientFeignLoadBalancedConfiguration ApacheHttpClient 实现负载均衡
OkHttpFeignLoadBalancedConfiguration OkHttpClient实现负载均衡
DefaultFeignLoadBalancedConfiguration Client.Default实现负载均衡

org.springframework.cloud.openfeign.encoding.FeignAcceptGzipEncodingAutoConfiguration,org.springframework.cloud.openfeign.encoding.FeignContentGzipEncodingAutoConfiguration: 这两个自动化装配类是关于 请求和响应的压缩配置的.

接下来我们通过思考下面的问题,进行源码的学习:

@FeignClient被注入的接口,如何被解析和注入的呢
@Autowired可以针对@FeignClient注入实例对象,是如何注入的,注入的又是什么对象呢
FeingClient声明的接口被解析后,以什么方式存储和调用的呢
OpenFeign如何集成Ribbon实现负载均衡的呢

openfeign和springboot继承需要要用@EnableFeignClients注解:

@SpringBootApplication
@EnableEurekaClient
@EnableHystrix
@EnableFeignClients
public class XXXApiApplication {

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

}

那么我们知道哪些可以把外部bean注入到ioc容器的方法呢?

1、importSelector (批量注入bean,例如spring boot自动装配原理)
2、ImportBeanDefinitionRegister (动态构建bean)
3、BeanFactoryPostProcessor (spring提供的扩展,首先他必须是一个Bean)
4、SpringFactoryLoad (spi的机制)

ImportBeanDefinitionRegister可以实现动态bean的构建,也就是我们可以把自己需要的bean注入到ioc容器中

我们点进去看下@EnableFeignClients注解:

在这里插入图片描述
@Import支持 三种方式
1.带有@Configuration的配置类(4.2 版本之前只可以导入配置类,4.2版本之后 也可以导入 普通类)
2.ImportSelector 的实现
3.ImportBeanDefinitionRegistrar 的实现
这里FeignClientsRegistrar类就是通过第三种方式导入到ioc容器中的

通过@Impor为我们注入FeignClientsRegistrar.class

FeignClientsRegistrar
在这里插入图片描述
实现了ImportBeanDefinitionRegistrar接口并重写了registerBeanDefinitions方法

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

其中registerDefaultConfiguration(metadata, registry);方法主要是获取@EnableFeignClients注解参数defaultConfiguration

重点来了registerFeignClients(metadata, registry)

public void registerFeignClients(AnnotationMetadata metadata,
			BeanDefinitionRegistry registry) {
		ClassPathScanningCandidateComponentProvider scanner = getScanner();
		scanner.setResourceLoader(this.resourceLoader);

		Set<String> basePackages;
		//收集该注解的元数据信息:value ,basePackages ,basePackageClasses 等
		Map<String, Object> attrs = metadata
				.getAnnotationAttributes(EnableFeignClients.class.getName());
		AnnotationTypeFilter annotationTypeFilter = new AnnotationTypeFilter(
				FeignClient.class);
		//获取@EnableFeignClients注解中的client属性
		final Class<?>[] clients = attrs == null ? null
				: (Class<?>[]) attrs.get("clients");
		//如果没有配置client相关属性会进入到这里
		if (clients == null || clients.length == 0) {
			//添加需要扫描的注解@FeignClient
			scanner.addIncludeFilter(annotationTypeFilter);
			//该方法就是根据@EnableFeignClients注解的属性信息去获取需要扫描的路径
			basePackages = getBasePackages(metadata);
		}
		//基于client属性配置的类以及类所在的包进行扫描
		else {
			final Set<String> 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)));
		}
		//遍历所有的路径获取标有@FeignClient注解的接口
		for (String basePackage : basePackages) {
			//找到候选的对象(标有@FeignClient注解的接口)封装成BeanDefinition对象
			Set<BeanDefinition> 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");
					//获取每个接口中定义的元数据信息,即@FeignClient注解中配置的属性值例如,value,name,path,url等
					Map<String, Object> attributes = annotationMetadata
							.getAnnotationAttributes(
									FeignClient.class.getCanonicalName());
					//获取name的属性值
					String name = getClientName(attributes);
					//注册被调用客户端配置
                    //注册(微服务名).FeignClientSpecification类型的bean
                    //对beanname的名称进行拼接: name.FeignClientSpecification ,例如我们上面获取的naem值等于:${feign.baseInfoManagement.name:baseInfoManagement/baseInfoManagement}
                    //拼接后:${feign.baseInfoManagement.name:baseInfoManagement/baseInfoManagement}.FeignClientSpecification               
					registerClientConfiguration(registry, name,
							attributes.get("configuration"));
                    注册 FeignClient 重点分析*****
					registerFeignClient(registry, annotationMetadata, attributes);
				}
			}
		}
	}

	protected Set<String> getBasePackages(AnnotationMetadata importingClassMetadata) {
		//@EnableFeignClients 元数据信息就是我们在该注解中配置的key:value值
		Map<String, Object> attributes = importingClassMetadata
				.getAnnotationAttributes(EnableFeignClients.class.getCanonicalName());
		//遍历属性信息,拿到需要扫描的路径
		Set<String> basePackages = new HashSet<>();
		for (String pkg : (String[]) attributes.get("value")) {
			if (StringUtils.hasText(pkg)) {
				basePackages.add(pkg);
			}
		}
		for (String pkg : (String[]) attributes.get("basePackages")) {
			if (StringUtils.hasText(pkg)) {
				basePackages.add(pkg);
			}
		}
		for (Class<?> clazz : (Class[]) attributes.get("basePackageClasses")) {
			basePackages.add(ClassUtils.getPackageName(clazz));
		}

		if (basePackages.isEmpty()) {
			basePackages.add(
					ClassUtils.getPackageName(importingClassMetadata.getClassName()));
		}
		return basePackages;
	}

egisterFeignClients(metadata, registry)该方法的主要步骤如下:
1.查找FeignClient
2.得到一个@FeignClient的接口的集合
3.解析@FeignClient注解中的元数据信息
4.遍历这些FeignClient接口,注入一个动态Bean实例(通过动态代理的方式实现)

registerFeignClient

把接口对应的代理类注入到ioc容器中:注册 FeignClient,组装BeanDefinition,实质是一个FeignClientFactoryBean,然后注册到Spring IOC容器。

private void registerFeignClient(BeanDefinitionRegistry registry,
			AnnotationMetadata annotationMetadata, Map<String, Object> attributes) {
			//获取到标注了@FeignClient注解的接口全路径:com.train.service.feign.BaseInfoManagementFeign
		String className = annotationMetadata.getClassName();
		//构建FeignClientFactoryBean类型的BeanDefinitionBuilder
		BeanDefinitionBuilder definition = BeanDefinitionBuilder
				.genericBeanDefinition(FeignClientFactoryBean.class);
	    //属性值校验
		validate(attributes);
		//将属性设置到 FeignClientFactoryBean 中,也就是我们在@FeignClient中配置的属性值
		definition.addPropertyValue("url", getUrl(attributes));
		definition.addPropertyValue("path", getPath(attributes));
		String name = getName(attributes);
		definition.addPropertyValue("name", name);
		String contextId = getContextId(attributes);
		definition.addPropertyValue("contextId", contextId);
		definition.addPropertyValue("type", className);
		definition.addPropertyValue("decode404", attributes.get("decode404"));
		definition.addPropertyValue("fallback", attributes.get("fallback"));
		definition.addPropertyValue("fallbackFactory", attributes.get("fallbackFactory"));
		//设置 Autowire注入的类型,按类型注入
		definition.setAutowireMode(AbstractBeanDefinition.AUTOWIRE_BY_TYPE);

		String alias = contextId + "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;
		}
        //将BeanDefinition包装成BeanDefinitionHolder,用于注册
		BeanDefinitionHolder holder = new BeanDefinitionHolder(beanDefinition, className,
				new String[] { alias });
		//注册 BeanDefinition  
		BeanDefinitionReaderUtils.registerBeanDefinition(holder, registry);
	}

分析到这里其实只是把我们的代理类封装成BeanDefinition对象,但是并没有实例化,在spring中我们知道,加载到IOC容器中的类都要先封装成BeanDefinition对象,因为我们不仅需要类的类的信息,还可能配置了一些其他属性,例如@Lazy,@DependsOn等。那这里后续肯定是通过sring进行实例化的,这里就不做过多分析,主要流程如下:

Spring容器启动,调用AbstractApplicationContext#refresh方法,
在refresh方法内部调用finishBeanFactoryInitialization方法对单例bean进行初始化,
finishBeanFactoryInitialization方法调用getBean获取name对应的bean实例,如果不存在,则创建一个,即调用doGetBean方法。
doGetBean调用createBean方法,createBean方法调用doCreateBean方法。
doCreateBean()方法主要是根据 beanName、mbd、args,使用对应的策略创建 bean 实例,并返回包装类 BeanWrapper。
doCreateBean方法中调用populateBean对 bean 进行属性填充;其中,可能存在依赖于其他 bean 的属性,则会递归初始化依赖的 bean 实例,初始化阶段又涉及到三级缓存以及AOP的实现。

FeignClientFactoryBean

上面我们分析会构建FeignClientFactoryBean类型的BeanDefinitionBuilder,那么这个对象是什么呢,我们接下来进行分析:
在这里插入图片描述
首先我们可以看到它实现了Spring中给我们提供扩展使用的三个类分别是FactoryBean,InitializingBean,ApplicationContextAware

InitializingBean的作用
1:spring为bean提供了两种初始化bean的方式,实现InitializingBean接口,实现afterPropertiesSet方法,或者在配置文件中同过init-method指定,两种方式可以同时使用
2:实现InitializingBean接口是直接调用afterPropertiesSet方法,比通过反射调用init-method指定的方法效率相对来说要高点。但是init-method方式消除了对spring的依赖
3:如果调用afterPropertiesSet方法时出错,则不调用init-method指定的方法。

ApplicationContextAware
通过它Spring容器会自动把上下文环境对象调用ApplicationContextAware接口中的setApplicationContext方法,可以通过这个上下文环境对象得到Spring容器中的Bean

FactoryBean的作用
实现了factoryBean的接口会调用getObject方法创建bean

	@Override
	public Object getObject() throws Exception {
		return getTarget();
	}
	<T> T getTarget() {
	//从applicationContext取出FeignContext,FeignContext继承了NamedContextFactory,
	//它是用来统一维护feign中各个feign客户端相互隔离的上下文。
	//FeignContext注册到容器是在FeignAutoConfiguration上完成的。
		FeignContext context = this.applicationContext.getBean(FeignContext.class);
		
		//构建feign.builder,在构建时会向FeignContext获取配置的Encoder,Decoder等各种信息。
		//FeignContext在上文中已经提到会为每个Feign客户端分配了一个容器,它们的父容器就是spring容器。
		Feign.Builder builder = feign(context);
        //如果url为空,则走负载均衡,生成有负载均衡功能的代理类 (重点分析*****)
		if (!StringUtils.hasText(this.url)) {
			if (!this.name.startsWith("http")) {
				this.url = "http://" + this.name;
			}
			else {
				this.url = this.name;
			}
			this.url += cleanPath();
			//@FeignClient没有配置url属性,返回有负载均衡功能的代理对象
			return (T) loadBalance(builder, context,
					new HardCodedTarget<>(this.type, this.name, this.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));
	}


	protected <T> T loadBalance(Feign.Builder builder, FeignContext context,
			HardCodedTarget<T> target) {
		// 从上下文中获取一个 Client,默认是LoadBalancerFeignClient。
		//它是在FeignRibbonClientAutoConfiguration这个自动装配类中,通过Import实现的
		Client client = getOptional(context, Client.class);
		if (client != null) {
			builder.client(client);
			Targeter targeter = get(context, Targeter.class);
			//这里就是为每个接口创建代理类这里有两个实现 HystrixTargeter 、DefaultTargeter 
			//很显然,如果没有配置 Hystrix ,这里会走 DefaultTargeter
			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?");
	}

DefaultTargeter

class DefaultTargeter implements Targeter {

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

}

Feign

public <T> T target(Target<T> target) {
	//创建一个动态代理类,最终会调用 ReflectiveFeign.newInstance
      return build().newInstance(target);
    }

public Feign build() {
//这个方法是用来创建一个动态代理的方法,在生成动态代理之前,会根据Contract协议(协议解析规则,解析接口类的注解信息,解析成内部的MethodHandler的处理方式。会解析我们在每个接口中定义的参数,方法类型等。
      SynchronousMethodHandler.Factory synchronousMethodHandlerFactory =
          new SynchronousMethodHandler.Factory(client, retryer, requestInterceptors, logger,
              logLevel, decode404, closeAfterDecode, propagationPolicy);
      ParseHandlersByName handlersByName =
          new ParseHandlersByName(contract, options, encoder, decoder, queryMapEncoder,
              errorDecoder, synchronousMethodHandlerFactory);
      //ReflectiveFeign创建一个动态代理类
      return new ReflectiveFeign(handlersByName, invocationHandlerFactory, queryMapEncoder);
    }

//target就是我们的原始接口
public <T> T newInstance(Target<T> target) {
//根据接口类和Contract协议解析方式,解析接口类上的方法和注解,转换成内部的MethodHandler处理方式
//nameToHandle集合包含的属性可以看下面的图进行理解
    Map<String, MethodHandler> nameToHandler = targetToHandlersByName.apply(target);
    Map<Method, MethodHandler> methodToHandler = new LinkedHashMap<Method, MethodHandler>();
    List<DefaultMethodHandler> defaultMethodHandlers = new LinkedList<DefaultMethodHandler>();
    //遍历接口中的所有方法
    for (Method method : target.type().getMethods()) {
    //如果是Object中提供的方法,跳过
      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)));
      }
    }
    // 基于Proxy.newProxyInstance 为接口类创建动态实现,将所有的请求转换给InvocationHandler 处理。
    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;
  }

在前面的分析中,我们知道OpenFeign最终返回的是一个 ReflectiveFeign.FeignInvocationHandler 的对象。那么当客户端发起请求时,会进入到 FeignInvocationHandler.invoke 方法中,这个大家都知道,它是一个动态代理的实现。
OpenFeign调用过程 :

    @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();
      }
// 利用分发器筛选方法,找到对应的handler 进行处理,也就是根据请求目标对应的url找到需要执行的方法进行调用
      return dispatch.get(method).invoke(args);
    }

SynchronousMethodHandler.invoke
而接着,在invoke方法中,会调用 this.dispatch.get(method)).invoke(args) 。this.dispatch.get(method) 会返回一个SynchronousMethodHandler,进行拦截处理。这个方法会根据参数生成完成的RequestTemplate对象,这个对象是Http请求的模版,代码如下

  @Override
  public Object invoke(Object[] argv) throws Throwable {
  	//得到RequestTemplate 对象
    RequestTemplate template = buildTemplateFromArgs.create(argv);
    Options options = findOptions(argv);
    //重试机制的实现
    Retryer retryer = this.retryer.clone();
    while (true) {
      try {
      	//请求的调用 执行调用和解码工作
        return executeAndDecode(template, options);
      } catch (RetryableException e) {
        try {
          retryer.continueOrPropagate(e);
        } catch (RetryableException th) {
          Throwable cause = th.getCause();
          if (propagationPolicy == UNWRAP && cause != null) {
            throw cause;
          } else {
            throw th;
          }
        }
        //如果实现了日志类的打印,会打印日志信息
        if (logLevel != Logger.Level.NONE) {
          logger.logRetry(metadata.configKey(), logLevel);
        }
        continue;
      }
    }
  }

  Object executeAndDecode(RequestTemplate template, Options options) throws Throwable {
  //获取Request对象
    //此处也是自定义拦截器的实现
    Request request = targetRequest(template);

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

    Response response;
    long start = System.nanoTime();
    try {
    //发起远程通信
    //这里的 client.execute 的 client 的类型是LoadBalancerFeignClient
    //走到这里就是我们前门分析的ribbon那一套了,这里不做说明
      response = client.execute(request, options);
    } catch (IOException e) {
      if (logLevel != Logger.Level.NONE) {
        logger.logIOException(metadata.configKey(), logLevel, e, elapsedTime(start));
      }
      throw errorExecuting(request, e);
    }
    long elapsedTime = TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - start);
	获取返回结果,并解析
    boolean shouldClose = true;
    try {
      if (logLevel != Logger.Level.NONE) {
        response =
            logger.logAndRebufferResponse(metadata.configKey(), logLevel, response, elapsedTime);
      }
      if (Response.class == metadata.returnType()) {
        if (response.body() == null) {
          return response;
        }
        if (response.body().length() == null ||
            response.body().length() > MAX_RESPONSE_BUFFER_SIZE) {
          shouldClose = false;
          return response;
        }
        // Ensure the response body is disconnected
        byte[] bodyData = Util.toByteArray(response.body().asInputStream());
        return response.toBuilder().body(bodyData).build();
      }
      if (response.status() >= 200 && response.status() < 300) {
        if (void.class == metadata.returnType()) {
          return null;
        } else {
          Object result = decode(response);
          shouldClose = closeAfterDecode;
          return result;
        }
      } else if (decode404 && response.status() == 404 && void.class != metadata.returnType()) {
        Object result = decode(response);
        shouldClose = closeAfterDecode;
        return result;
      } else {
        throw errorDecoder.decode(metadata.configKey(), response);
      }
    } catch (IOException e) {
      if (logLevel != Logger.Level.NONE) {
        logger.logIOException(metadata.configKey(), logLevel, e, elapsedTime);
      }
      throw errorReading(request, response, e);
    } finally {
      if (shouldClose) {
        ensureClosed(response.body());
      }
    }
  }

上面主要进行的步骤就是,我们根据@FeignClient注解定义的接口,会通过动态代理给每个接口生成一个代理类,每个代理类中保存了URL和目标方法的对应管理,来调用对应的方法。

总体过程:

主程序入口添加了@EnableFeignClients注解开启对FeignClient扫描加载处理。根据Feign Client的开发规范,定义接口并加@FeignClient注解。
当程序启动时,会进行包扫描,扫描所有@FeignClients的注解的类,并且将这些信息注入Spring IOC容器中,当定义的的Feign接口中的方法被调用时,通过JDK动态代理方式,来生成具体的RequestTemplate。当生成代理时,Feign会为每个接口方法创建一个RequestTemplate对象,该对象封装可HTTP请求需要的全部信息,如请求参数名,请求方法等信息都是在这个过程中确定的。
然后RequestTemplate生成Request,然后把Request交给Client去处理,这里指的Client可以是JDK原生的URLConnection、Apache的HttpClient、也可以是OKhttp,最后Client被封装到LoadBalanceClient类,这个类结合Ribbon负载均衡发起服务之间的调用。

最后附上原理图
在这里插入图片描述

下一篇:OpenFeign的使用

  • 0
    点赞
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值