marathon-client 源码分析

简介

源码位置

mesosphere/marathon-client

Feign is used as the underlying REST library.

也就是以restful api 的方式与 marathon server 交流

使用示例

String endpoint = "<Marathon's endpoint>";
Marathon marathon = MarathonClient.getInstance(endpoint);

根据操作对象 Marathon 可以操作marathon 提供的所有v2 http 接口,比如

App app = new App();
app.setId("echohisleepbye-app");
app.setCmd("echo hi; sleep 10; echo bye;");
app.setCpus(1.0);
app.setMem(16.0);
app.setInstances(1);
marathon.createApp(app);

源码分析

主要包结构

mesosphere.marathon.client
 	auth
 	model
 		v2
 			各类请求和相应的model
 	Marathon
 	MarathonClient
 	MarathonException

我们来看 创建 Marathon 操作对象的代码

public static Marathon getInstance(String endpoint, RequestInterceptor… interceptors) {

Builder b = Feign.builder()
			.encoder(new GsonEncoder(ModelUtils.GSON))
			.decoder(new GsonDecoder(ModelUtils.GSON))
			.errorDecoder(new MarathonErrorDecoder());
	if (interceptors != null)
		b.requestInterceptors(asList(interceptors));
	String debugOutput = System.getenv(DEBUG_JSON_OUTPUT);
	if ("System.out".equals(debugOutput)) {
		System.setProperty("org.slf4j.simpleLogger.logFile", "System.out");
		System.setProperty("org.slf4j.simpleLogger.defaultLogLevel", "debug");
		b.logger(new Slf4jLogger()).logLevel(Logger.Level.FULL);
	} else if (debugOutput != null) {
		b.logger(new Logger.JavaLogger().appendToFile(debugOutput)).logLevel(Logger.Level.FULL);
	}
	b.requestInterceptor(new MarathonHeadersInterceptor());
	return b.target(Marathon.class, endpoint);
}

比较一栋,再看下Marathon.class

public interface Marathon {
	// Apps
	@RequestLine("GET /v2/apps")
	@Headers(HeaderUtils.MARATHON_API_SOURCE_HEADER)
	GetAppsResponse getApps() throws MarathonException;

	@RequestLine("GET /v2/apps")
	@Headers(HeaderUtils.MARATHON_API_SOURCE_HEADER)
	GetAppsResponse getApps(@QueryMap Map<String, String> queryMap) throws MarathonException;

	@RequestLine("GET /v2/apps/{id}")
	@Headers(HeaderUtils.MARATHON_API_SOURCE_HEADER)
	GetAppResponse getApp(@Param("id") String id) throws MarathonException;
	...
}

也很易懂,所以重点就在 b.target(Marathon.class, endpoint);
上了,全称是 feign.Builder.target(Class<T> apiType, String url);

public <T> T newInstance(Target<T> target) {
	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()) {
	  if (method.getDeclaringClass() == Object.class) {
	    continue;
	  } else if(Util.isDefault(method)) {
	    DefaultMethodHandler handler = new DefaultMethodHandler(method);
	    defaultMethodHandlers.add(handler);
	    methodToHandler.put(method, handler);
	  } else {
	    methodToHandler.put(method, nameToHandler.get(Feign.configKey(target.type(), method)));
	  }
	}
	InvocationHandler handler = factory.create(target, methodToHandler);
	T proxy = (T) Proxy.newProxyInstance(target.type().getClassLoader(), new Class<?>[]{target.type()}, handler);

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

这段代码最好倒过来看

  1. T proxy = (T) Proxy.newProxyInstance(target.type().getClassLoader(), new Class<?>[]{target.type()}, handler);
    通过 一个InvocationHandler 可以运行时构造一个 interface Marathon
    实例
  2. InvocationHandler,java 源码上如此表述 Each proxy instance has an associated invocation handler. When a method is invoked on a proxy instance, the method invocation is encoded and dispatched to the invoke method of its invocation handler. 每一个代理类都要有一个InvocationHandler,当执行被代理类的方法时,执行逻辑会转入到InvocationHandler 的invoke 方法上。
  3. 根据 interface Marathon 方法上的信息,可以拿到请求uri、参数、返回值等 一个http 请求的基本数据,然后对Marathon 的每一个方法 生成一个MethodHandler,最终将它们聚合成 一个InvocationHandler

类似场景对比

我们能用反射做什么 提到: dynamic proxies 总让人跟代理模式扯上关系,但实际上说dynamic interface implementations 更为直观。

自定义spring namespace handler

spring 自定义一个namespace ,比如 <custom name="",config="",interface="CustomIface">
,然后spring 将其序列化为一个对象,并自动注入到代码中

@Component
Class A {
	@Autowire
	private CustomIface custom;
}

两者的共同点是:

  1. 项目中都没有 CustomIface 的具体实现代码
  2. 代理类都是动态生成的, <custom>
    或者是处理成 spring的BeanDefinition,或者处理成一个FactoryBean, 最终需要 Proxy.newProxyInstance
    来返回一个代理类。

不同的是:

  1. CustomIface 中的方法一般很少,大部分只有一个
  2. Marathon.class 的方法很多,而InvocationHandler 只是笼统的拦截了方法的执行,针对每一个方法的具体逻辑,都写在InvocationHandler 中是不现实的。必然要 抽象一个MethodHandler ,而InvocationHandler 中只是将 调用分发到MethodHandler 上。这也是InvocationHandlerFactory 的作用: Controls reflective method dispatch.

所以,我来看下 Feign 提供的效果

  1. 以一个接口来描述restful api配置,描述url、请求参数、返回值。
  2. 接口实现类完全靠 动态代理实现
  3. 整个过程没有spring的参与

OpenFeign/feign
将这种方式称为Interface Annotations,Feign annotations define the Contract between the interface and how the underlying client should work.

原文 

http://qiankunli.github.io/2018/11/02/marathon_java_client.html

本站部分文章源于互联网,本着传播知识、有益学习和研究的目的进行的转载,为网友免费提供。如有著作权人或出版方提出异议,本站将立即删除。如果您对文章转载有任何疑问请告之我们,以便我们及时纠正。

PS:推荐一个微信公众号: askHarries 或者qq群:474807195,里面会分享一些资深架构师录制的视频录像:有Spring,MyBatis,Netty源码分析,高并发、高性能、分布式、微服务架构的原理,JVM性能优化这些成为架构师必备的知识体系。还能领取免费的学习资源,目前受益良多

转载请注明原文出处:Harries Blog™ » marathon-client 源码分析

赞 (0)
分享到:更多 ()

评论 0

  • 昵称 (必填)
  • 邮箱 (必填)
  • 网址