org.springframework.cloud.openfeign.FeignContext Java Examples

@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
	/**
	 * args[0]: FeignClientFactoryBean factory args[1]: Feign.Builder feign args[2]:
	 * FeignContext context args[3]: Target.HardCodedTarget<T> target
	 */
	FeignContext feignContext = cast(args[2]);
	Target.HardCodedTarget<?> target = cast(args[3]);

	// Execute Targeter#target method first
	method.setAccessible(true);
	// Get the default proxy object
	Object defaultProxy = method.invoke(bean, args);
	// Create Dubbo Proxy if required
	return createDubboProxyIfRequired(feignContext, target, defaultProxy);
}
 

@Override
public Object postProcessBeforeInitialization(Object bean, String beanName)
		throws BeansException {
	if (bean instanceof FeignContext && !(bean instanceof SeataFeignContext)) {
		return new SeataFeignContext(getSeataFeignObjectWrapper(),
				(FeignContext) bean);
	}
	return bean;
}
 

private Object createDubboProxyIfRequired(FeignContext feignContext, Target target,
		Object defaultProxy) {

	DubboInvocationHandler dubboInvocationHandler = createDubboInvocationHandler(
			feignContext, target, defaultProxy);

	if (dubboInvocationHandler == null) {
		return defaultProxy;
	}

	return newProxyInstance(target.type().getClassLoader(),
			new Class<?>[] { target.type() }, dubboInvocationHandler);
}
 

private DubboInvocationHandler createDubboInvocationHandler(FeignContext feignContext,
		Target target, Object defaultFeignClientProxy) {

	// Service name equals @FeignClient.name()
	String serviceName = target.name();
	Class<?> targetType = target.type();

	// Get Contract Bean from FeignContext
	Contract contract = feignContext.getInstance(serviceName, Contract.class);

	DubboTransportedMethodMetadataResolver resolver = new DubboTransportedMethodMetadataResolver(
			environment, contract);

	Map<DubboTransportedMethodMetadata, RestMethodMetadata> feignRestMethodMetadataMap = resolver
			.resolve(targetType);

	if (feignRestMethodMetadataMap.isEmpty()) { // @DubboTransported method was not
												// found from the Client interface
		if (logger.isDebugEnabled()) {
			logger.debug("@{} method was not found in the Feign target type[{}]",
					DubboTransported.class.getSimpleName(), targetType.getName());
		}
		return null;
	}

	// Update Metadata
	repository.initializeMetadata(serviceName);

	Map<Method, FeignMethodMetadata> feignMethodMetadataMap = getFeignMethodMetadataMap(
			serviceName, feignRestMethodMetadataMap);

	InvocationHandler defaultFeignClientInvocationHandler = Proxy
			.getInvocationHandler(defaultFeignClientProxy);

	DubboInvocationHandler dubboInvocationHandler = new DubboInvocationHandler(
			feignMethodMetadataMap, defaultFeignClientInvocationHandler, classLoader,
			contextFactory);

	return dubboInvocationHandler;
}
 

@Override
public Object postProcessBeforeInitialization(Object bean, String name) throws BeansException {
  if (bean instanceof FeignContext && !(bean instanceof TraceFeignContext)) {
    return new TraceFeignContext(tracer, (FeignContext) bean, beanFactory, spanDecorators);
  }
  return bean;
}
 

@Test
public void loadFeignTracingByDefault() {
  AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
  context.register(FeignContextConfig.class, TracerConfig.class,
      FeignTracingAutoConfiguration.class);
  context.refresh();
  FeignContext feignContext = context.getBean(TraceFeignContext.class);
  assertNotNull(feignContext);
}
 

@Override
public Object postProcessAfterInitialization(Object bean, String beanName)
		throws BeansException {
	if (bean instanceof FeignContext && !(bean instanceof TraceFeignContext)) {
		return new TraceFeignContext(traceFeignObjectWrapper(), (FeignContext) bean);
	}
	return bean;
}
 

SeataFeignContext(SeataFeignObjectWrapper seataFeignObjectWrapper,
		FeignContext delegate) {
	this.seataFeignObjectWrapper = seataFeignObjectWrapper;
	this.delegate = delegate;
}
 

@Override
public void setApplicationContext(ApplicationContext applicationContext)
		throws BeansException {
	this.applicationContext = applicationContext;
	feignContext = this.applicationContext.getBean(FeignContext.class);
}
 

TraceFeignContext(Tracer tracer, FeignContext delegate, BeanFactory beanFactory,
                  List<FeignSpanDecorator> spanDecorators) {
  this.delegate = delegate;
  this.tracedFeignBeanFactory = new TracedFeignBeanFactory(tracer, beanFactory, spanDecorators);
}
 

TraceFeignContext(TraceFeignObjectWrapper traceFeignObjectWrapper,
		FeignContext delegate) {
	this.traceFeignObjectWrapper = traceFeignObjectWrapper;
	this.delegate = delegate;
}