神刀安全网

使用Scala开发一个DSL来做远程调用

问题背景

最近在实施微服务化过程中,发现了一类潜在需求(这就是传说中开发者的敏锐嗅觉=_ =?):

如何快速的来进行远程RPC调用,来进行测试、排查问题?

服务调用方式有两种形式,如下图所示。

使用Scala开发一个DSL来做远程调用

第一种,传统的方式,服务provider提供SDK,服务consumer在构建环境中引入SDK依赖,并且配置IP:PORT,直连调用。

第二种,改进的方式,服务provider通过平台治理中心来生成SDK,实际就是将API的接口和签名、类定义信息进行统一的schema描述(可以使用proto)后,由平台负责生成SDK,服务consumer可以通过契约schema的方式、或者引入SDK依赖,然后去治理中心订阅服务endpoint的拓扑,来进行调用,这中间的协调者不仅简化了复杂的依赖关系,并且对于依赖的变更,可以有很大的自由度来进行管控。

回到原题,在这种形式下,要发起调用,需要在IDE里或者一些Toolkit来进行,如果是RESTful的HTTP调用,甚至最简陋的可以用wget/curl命令模拟。等等,这么说我要在IDE里专门维护一个project或者专门开发一个toolkit,或者写一个shell脚本?Oh,My god,好像都对快速排查和测试不太友好。

解决方案

我的一个想法是,能够有个Tab自动提示输入的命令行工具直接调?那这样就舒服多了。

解决方案是,前提是我的微服务是用Java语言开发的,使用Scala自带的REPL来做console,引入服务provider的SDK在Classpath下,然后在命令行中调用,摆脱沉重的IDE和需要大量额外开发的Toolkit以及简陋的linux命令。

先名词解释安利下,

  • REPL(Read-eval-print-loop):

交互式的命令行,常见于Python/Ruby等语言原生支持,以及Javascript通过浏览器内置工具支持。

  • Scala:

关键词概括=>兼容Java,类型安全,由JDK编译器作者Martin Odersky创始,函数式编程(FP),OO,优雅的并发模型,较为复杂、灵活的使用方式和高上手门槛的“白领”语言。

  • DSL:

领域特定语言,最简单通俗的理解,诸如2 days ago返回一个前两天的一个Date对象,这看起来就非常DSL。

自行开发的DSL语法结构大致如下:

MSOA {on "IP:PORT"} [listserver/desc/call/tojson] classOf[XXXClazz] method(args)

顺畅的读作:微服务(Micro SOA),(可选)在IP:PORT上,调用XXXClazz的method方法,用args参数,返回结果由REPL保存。

例如,

> val r: GetMediaByAdUnitIdRequest = new GetMediaByAdUnitIdRequest > MSOA call classOf[MediaService] getMediaByAdUnitId(r)

GetMediaByAdUnitIdRequest可以通过import语句和Tab键输入,简单的通过REPL交互式命令行来直接调用,调用完毕,结果缓存到了REPL中,可以使用Scala语言的各种高阶函数、控制语句来操作,很优雅方便不是。

更直观的例子如下图。

使用Scala开发一个DSL来做远程调用

这个项目的我开源在了github上,源代码可以在这里面找到 https://github.com/neoremind/scala-dsl-rpc-client

一旦有了这样的工具,排查问题、测试调用就方便了很多,直接提高了开发效率。

解决实现深入讲解

github上为了简单,代码我就放在了一个文件中 msoaexec.scala 。(注意这个工程的某些依赖未开源,因此仅作demo展示)

首先定义一个包命名为msoa,类叫做MSOA,类构造函数含有两个成员变量,第一个是否是online的配置,第二个是一个带有String泛型的Option,默认为空,不为空则为Some("XXX"),扩展自一个trait,叫做UrlDefine。

class MSOA(var isOnline: Boolean = false, var endPoint: Option[String] = None) extends UrlDefine {

核心的调用方法如下,就是DSL中的call语法,接收一个Class实例,返回的是这个Class对应的对象。由于要做远程调用,因此这里复用了JDK自带的动态代理,可以通过反射拿到调用上下文信息,包括出入参、调用接口等,然后自行进行RPC,这里不得不说下Scala作为一个函数式编程的新生力军,相比起其纯前辈Haskell和Lisp来说,对于“元编程”的支持不是很强,不过也只能是依托JDK自带的API来做一些工作了。

/**  * 调用某个微服务  *  * @param t 微服务的类型,用classOf[XXX]表示  * @return 微服务访问代理  */ def call[T](t: Class[T]): T = {     Proxy.newProxyInstance(Thread.currentThread.getContextClassLoader, Array[Class[_]](t), DynamicStubProxy[T](isOnline, endPoint)).asInstanceOf[T] }

然后回到DSL,之所以可以按照类似流式、自然语言的语法来调用,其实是Scala语言支持的,例如一个参数的情况下,可以不写括号(),对象是一等公民,因此语句block的最后一个语句的返回值就是函数的返回值,因此看起来就非常的fluent的不是。

Java中要实例化一个对象,要用new关键词,但是Scala提供了伴生对象(Companion Object),它取消了static,并且本身实现的就是一个单例Singleton对象。因此才可以直接使用MSOA对象,而不用new出来。

/**  * MSOA微服务化DSL方式调用的伴生对象  */ object MSOA extends MSOA(   false, Some("") ) { }

深入刚刚提到的动态代理来看,如下所示,class前面加入case是为了更好的模式匹配,因此默认就会带有一个伴生对象出来,可以看出extends就是实现了JDK的InvocationHandler接口,然后with了两个特质,这相当于Scala提供了一种多重继承的特性。

case class DynamicStubProxy[A](val isOnline: Boolean, var endPoint: Option[String]) extends InvocationHandler with UrlDefine with Constans {     /**    * 序列化协议,默认使用protostuff    */   private val CODEC: Navi2ProtoCodec = new Navi2ProtoCodec     /**    * Processes a method invocation on a proxy instance and returns    * the result.  This method will be invoked on an invocation handler    * when a method is invoked on a proxy instance that it is    * associated with.    *    * @param proxy 代理对象    * @param method 代理方法    * @param args 方法参数    * @return 远程访问结果    */   override def invoke(proxy: Object, method: Method, args: Array[Object]): Object = {     // 获取Stub SDK上的BundleService注解     val bundle = method.getDeclaringClass.getAnnotation(classOf[BundleService])       // 如果没有设置访问地址的endpoint,则从治理中心获取一个     if (endPoint.isEmpty || StringUtils.isEmpty(endPoint.get)) {       endPoint = Some(GovernanceHelper.getOneEndPoint(isOnline, bundle, method.getName))     }       // 构造HTTP请求,包括header以及body,发送POST-HTTP请求到Restful API的服务server     // 使用Dispatch框架,以及async-http-client和netty做通讯层     // 返回future回执     val URL = toServiceUrl(endPoint.get, bundle, method.getName)     println("Start to call " + URL)     val req = url(URL).POST       .addHeader("Content-Type", "application/proto")       .addHeader("navi2.requestid", "-1")       .addHeader("navi2.traceid", "9999")       .addHeader("navi2.spanid", "999")       .addHeader("navi2.userid", "0")       .setBody(if (ArrayUtils.isEmpty(args)) new Array[Byte](0) else CODEC.encode(args))     val response: Future[ResponseWithSC] = Http.configure(_ setConnectionTimeoutInMs CONNECT_TIMEOUT_IN_MILLISECONDS)(MSOARequestHandlerTupleBuilder       (req).build[ResponseWithSC]       (BytesWithSC))       // 异步非阻塞方式,进行response future的回调,使用模式匹配来打印一些日志     response onComplete {       case Success(content) => {         printf("Successfully call %s.%s/n", method.getDeclaringClass.getSimpleName, method.getName)       }       case Failure(t) => {         throw MSOACallException("An error has occured when calling: " + t.getMessage)       }     }       // 等待请求返回后,序列化还原成对象,返回方法     // 对于http status = 500的响应,还原异常抛出     Await.result(response, Duration(READ_TIMEOUT_IN_SECONDS, TimeUnit.SECONDS))     val responseWithSC = response.value.get.get     if (responseWithSC.statusCode == 200) {       CODEC.decode(responseWithSC.bytes, method.getReturnType).asInstanceOf[Object]     } else {       val errorInfo = CODEC.decode(responseWithSC.bytes, classOf[ErrorInfo])       val clazz = Thread.currentThread.getContextClassLoader.loadClass(errorInfo.exceptionType).asInstanceOf[Class[_ <: Throwable]]       throw ProtoStuffReflect.decode(errorInfo.throwable, clazz)     }   }   }

实现接口关键字用override,def表示下面是一个函数,参数有三个,分别是被代理接口对象,被调用方法,参数,返回值是个Object。

由于我们内部的msoa框架,会在SDK Stub API的接口上打注解叫做@BundleService,内含该服务的名称、版本信息,因此可以帮助构造RPC调用请求体。

这里的RPC调用采用HTTP RESTful方式,利用了 Dispatch 这个Scala框架,底层使用了 async-http-client ,核心的调用语句如下:

val response: Future[ResponseWithSC] = Http.configure(_ setConnectionTimeoutInMs CONNECT_TIMEOUT_IN_MILLISECONDS)(MSOARequestHandlerTupleBuilder       (req).build[ResponseWithSC]       (BytesWithSC))

Http是一个带有伴生对象的实例,内含apply方法,参数就是MSOARequestHandlerTupleBuilder(req).build[ResponseWithSC](BytesWithSC),这个builder的入参是构造的HTTP Request对象,build函数的参数是一个函数对象,也就是从响应中Response中返回一个对象T,这里的T实际是就是讲一个对象转换为另外一个对象,我们要的是Array[Byte],这样方便后续做反序列化。可以看出,这个就是函数式编程的威力和简介之处,相比Java这种必须带有接口的传入参数,简洁了很多,当然Java8很好的吸收了Scala的这个优势,也可以省略接口了,由编译器做自动推断,也就是lambda表达式了。

使用async-http-client的有点就是纯异步、非阻塞调用,API也是异步的,这就是为什么返回的是一个回执Future,然后利用Scala的模式匹配能力,在future的onComplete方法上做结果匹配,成功了打印,失败了抛异常,注意这里的异常也是一个带有case关键词的伴生对象。

当然我们的调用要做到同步,因此这里用了Await来阻塞住,一旦调用成功即返回,然后拿到成功返回的Array[Byte],也就是HTTP返回的body,做反序列化,这里使用了protobuf技术,最后是服务化框架实现的,对于服务端的异常可以还原到客户端,因此做了一个小分支,如果是HTTP返回码不为200,则尝试还原异常,重新抛出。

case class MSOARequestHandlerTupleBuilder(req: Req) {   def build[T](f: Response => T) =     (req.toRequest, new MSOAFunctionHandler(f)) }

其他的代码这里不做展开,有兴趣的读者可以去github再挖掘。

篇后语

从有这个需求,到完成这个DSL的开发,用时1周左右,期间读了两遍《快学Scala》,真的就是给我这种快速实现上手人量身定做的,使我可以快速入门,虽然暂时还没有时间研究一些Scala实现的名宿,例如Spark,Kafka,但想必为以后也打下了基础。

使用Scala开发一个DSL来做远程调用

初学的感受总结一下:

1、函数是一等公民

正如这句话所说——"Every value is an object in Scala and functions are first class values"。

在函数式编程中,函数就是一等公民,在Scala中函数必须有返回值,即使是空也算个Unit类型。

另外Scala在函数上支持默认参数,带名参数,使用起来也非常方便。

最有意思的一点是,看似是别的语言的操作符重载特性,例如a+b,或者干脆就是内置的操作符,在Scala看来,全是对象,a+b,相当于调用a.+(b)。你调用array(0) = "abc",实际调用的是array.update(0, "abc")。

2、高阶函数与集合框架

最典型的例子就是集成框架上的操作,这也就是为什么Spark采用Scala,因为写起实现来太流畅和舒服了。想象一下,用filter、map、foreach等来完成一个Collection的过滤、映射、针对每个输出到文件,一行搞定是多么舒服。

(1 to 9).filter(_ % 2 == 0).map(10 * _).foreach(print _)

可以看出为啥Lisp程序员笑称Java为B&D(Bondage & Disipline 捆绑与管教——SM的一种)的语言,而函数式编程则太优雅了。

还有currying科里化,可以使接受两个参数的函数,变成一个接受一个函数的过程,这无形中可以省去接口定义的冗余。 偏函数 可以做到固定某几个参数的值。

3、再见NPE

这是大名鼎鼎的空指针NullPointerException,使用Option、Some、None来规避,guava也是采用了这种思想来实现其collection框架的。

4、再见static

Scala里没有static,取而代之的是伴生对象,默认可以在类前面加入case关键词,表示让编译器自动生成伴生对象,以及apply方法,还可以方便做模式匹配。

5、模式匹配

类似switch,然后比这个强大的多,可以在某个对象上做match,类型依次匹配,并且支持apply、unapply、unapplySeq等提取器功能。

def matchTest(x: Any): Any = x match {   case 1 => "one"   case "two" => 2   case y: Int => "scala.Int"   case _ => "many" }

6、继承

为了弥补Java中接口只可以有抽象,没有实现以及多重继承的不方便之处,引入了trait,其实JDK8接口里允许实现也是吸取了这个特性。

7、隐式转换

以implicit关键字晟敏的带有单个参数的函数,例如在Scala-lib中的Predef中有很多体现,下面就是将一个普通的字符串默认转换为StringOps对象,所以我们就可以用"12345".map(_ + 1)这种来操作字符串了。

@inline implicit def augmentString(x: String): StringOps = new StringOps(x)

8、OO特性和兼容Java

Scala是一门给函数式语言和命令式语言搭桥的语言,它同时保有两者的性格。可以把Scala看做基本就是一个在JVM上实现了的Haskell,但一不如Haskell简单,二不如Haskell功能完整。它的发明者Martin Odersky真是编译器的大神,他的Generic Java和javac就是Sun当时选择的方案,同时从pizza这门实验室语言,开发出了Scala,会被编译成为JVM的字节码,这样Scala就可以充分享受Java平台已有的所有成果,并且也同样是类型安全的。

同时简洁的特性也融入到Scala中,试想

case class MyClass(index: Int, name: String)

这个语句等于Java的多少行?

9、并发编程

由于函数式编程提倡变量不可变immutable、无side effect以及lazy evaluation,使异步编程变得非常容易。同时Scala提供的Future、Promise等, 和基于Actor模型的akka类库,使得异步、并发编程变得非常容易,无锁,不用JUC那么重,想写出安全的代码容易了许多。

总结一下,上面基本都是开发过程中的一些对于Scala语言的体会和随想,和Java是好兄弟的Scala,其先进性还是非常值得肯定的,另外最近爆出了LinkedIn抛弃Scala,转投Java8,这其中还涉及到商业公司的利益,例如TypeSafe这家Scala的拥有者,anyway,多接触一门语言就对编程多了一份热爱和未知,感受到自己需要进步的还非常的多,路漫漫其修远兮,与君共勉。 

转载本站任何文章请注明:转载至神刀安全网,谢谢神刀安全网 » 使用Scala开发一个DSL来做远程调用

分享到:更多 ()

评论 抢沙发

  • 昵称 (必填)
  • 邮箱 (必填)
  • 网址
分享按钮