问题背景

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

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

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

第一种，传统的方式，服务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语言的各种高阶函数、控制语句来操作，很优雅方便不是。

更直观的例子如下图。

这个项目的我开源在了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)
    }
  }
 
}

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，但想必为以后也打下了基础。

初学的感受总结一下：

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来做远程调用