Scala中的implicit关键字对于我们初学者像是一个谜一样的存在,一边惊讶于代码的简洁,

一边像在迷宫里打转一样地去找隐式的代码,因此我们团队结合目前的开发工作,将implicit
作为一个专题进行研究,了一些心得。

在研究的过程当中,我们注重三方面:

  1. 为什么需要implicit?
  2. implicit 包含什么,有什么内在规则?
  3. implicit 的应用模式有哪些?

为什么需要Implicit?

Scala在面对编译出现类型错误时,提供了一个由编译器自我修复的机制,编译器试图去寻找
一个隐式implicit的转换方法,转换出正确的类型,完成编译。这就是implicit的意义。

我们正在做Guardian系统的升级,Guardian是公司内部的核心系统,提供统一权限管控、
操作审计、单点登录等服务。系统已经有4年多的历史了,已经难以满足目前的需要,比如:
当时仅提供了RESTFul的服务接口,而随着性能需求的提高,有些服务使用Tcp消息完成远程
调用;另外,在RESTFull接口的协议方面,我们也想做一些优化。

而现状是公司内部系统已经全部接入Guardian,要接入新版,不可能一次全部迁移,甚至
要花很长一段时间才能完成迁移工作,因此新版接口必须同时支持新老两个版本接口协议。

因此我们必须解决两个问题:

  1. 兼容老版本协议, 以便能够平滑升级
  2. 支持多种协议,以满足不同业务系统的需求

我们希望对接口层提供一个稳定的Service接口,以免业务的变动影响前端接口代码,常规
的做法是我们在Service接口上定义多种版本的方法(重载),比如鉴权服务:

trait AuthService {
// 兼容老版本的鉴权业务方法
def auth(p: V1HttpAuthParam): Future[V1HttpAuthResult] // 新版本的鉴权业务方法
def auth(p: V2HttpAuthParam): Future[V2HttpAuthResult] // 新版本中支持的对Tcp消息鉴权的业务方法
def auth(p: V2TcpMsg): Future[V2TcpMsg]
}

这种做法的问题在于一旦业务发生变化,出现了新的参数,势必要修改AuthService接口,
添加新的接口方法,接口不稳定。

假如有一个通用的auth方法就好了:

trait AuthParam {}

trait StableAuthService{
// 稳定的鉴权接口
def auth(p: AuthParam)
}

这样,我们就可以按照下面的方式调用:

//在老版本的REST WS接口层:
val result = authService auth V1HttpAuthParam
response(result) //在新版本的REST WS接口层:
val result = authService auth V2HttpAuthParam
response(result) // .... 在更多的服务接口层,任意的传入参数,获得结果

很明显,这样的代码编译出错。 因为在authService中没有这样的方法签名。

再举个简单的例子, 我们想在打印字符串时,添加一些分隔符,下面是最自然的调用方式:

"hello,world" printWithSeperator "*"

很明显,这样的代码编译出错。 因为String 没有这样的方法。

Scala在面对编译出现类型错误时,提供了一个由编译器自我修复的机制,编译器试图去寻找
一个隐式implicit的转换方法,转换出正确的类型,完成编译。这就是implicit 的意义。

Implicit包含什么,有什么内在规则?

Scala 中的implicit包含两个方面:

  1. 隐式参数(implicit parameters)
  2. 隐式转换(implicit conversion)

隐式参数(implicit parameters)

隐式参数同样是编译器在找不到函数需要某种类型的参数时的一种修复机制,我们可以采用显式的柯里化式
的隐式参数申明,也可以进一步省略,采用implicitly方法来获取所需要的隐式变量。

隐式参数相对比较简单,Scala中的函数申明提供了隐式参数的语法,在函数的最后的柯里化参数
列表中可以添加隐式implicit关键字进行标记, 标记为implicit的参数在调用中可以省略,
Scala编译器会从当前作用域中寻找一个相同类型的隐式变量,作为调用参数。

在Scala的并发库中就大量使用了隐式参数,比如Future:

// Future 需要一个隐式的ExecutionContext
// 引入一个默认的隐式ExecutionContext, 否则编译不通过
import scala.concurrent.ExecutionContext.Implicits.default
Future {
sleep(1000)
println("I'm in future")
}

对于一些常量类的,可共用的一些对象,我们可以用隐式参数来简化我们的代码,比如,我们的应用
一般都需要一个配置对象:

object SomeApp extends App {
//这是我们的全局配置类
class Setting(config: Config) {
def host: String = config.getString("app.host")
}
// 申明一个隐式的配置对象
implicit val setting = new Setting(ConfigFactory.load) // 申明隐式参数
def startServer()(implicit setting: Setting): Unit = {
val host = setting.host
println(s"server listening on $host")
} // 无需传入隐式参数
startServer()
}

甚至,Scala为了更进一步减少隐式参数的申明代码,我们都可以不需要再函数参数上显示的申明,在scala.Predef包中,提供了一个implicitly的函数,帮助我们找到当前上下文中所需要类型的
隐式变量:

@inline def implicitly[T](implicit e: T) = e    // for summoning implicit values from the nether world

因此上面的startServer函数我们可以简化为:

  // 省略隐式参数申明
def startServer(): Unit = {
val host = implicitly[Setting].host
println(s"server listening on $host")
}

需要注意的是,进一步简化之后,代码的可读性有所损失,调用方并不知道startServer需要一个隐式的
配置对象,要么加强文档说明,要么选用显式的申明,这种权衡需要团队达成一致。

隐式转换(implicit conversion)

回顾一下前面说到的小例子,让字符串能够带分隔符打印:

"hello,world" printWithSeperator "*"

此时,Scala编译器尝试从当前的表达式作用域范围中寻找能够将String转换成一个具有printWithSeperator
函数的对象。

为此,我们提供一个PrintOpstrait,有一个printWithSeperator函数:

trait PrintOps {
val value: String
def printWithSepeator(sep: String): Unit = {
println(value.split("").mkString(sep))
}
}

此时,编译仍然不通过,因为Scala编译器并没有找到一个可以将String转换为PrintOps的方法!那我们申明一个:

def stringToPrintOps(str: String): PrintOps = new PrintOps {
override val value: String = str
}

OK, 我们可以显示地调用stringToPrintOps了:

stringToPrintOps("hello,world") printWithSepeator "*"

离我们的最终目标只有一步之遥了,只需要将stringToPrintOps方法标记为implicit即可,除了为String
添加stringToPrintOps的能力,还可以为其他类型添加,完整代码如下:

object StringOpsTest extends App {
// 定义打印操作Trait
trait PrintOps {
val value: String
def printWithSeperator(sep: String): Unit = {
println(value.split("").mkString(sep))
}
} // 定义针对String的隐式转换方法
implicit def stringToPrintOps(str: String): PrintOps = new PrintOps {
override val value: String = str
} // 定义针对Int的隐式转换方法
implicit def intToPrintOps(i: Int): PrintOps = new PrintOps {
override val value: String = i.toString
} // String 和 Int 都拥有 printWithSeperator 函数
"hello,world" printWithSeperator "*"
1234 printWithSeperator "*"
}

隐式转换的规则 -- 如何寻找隐式转换方法

Scala编译器是按照怎样的套路来寻找一个可以应用的隐式转换方法呢? 在Martin Odersky的Programming in Scala, First Edition中总结了以下几条原则:

  1. 标记规则:只会去寻找带有implicit标记的方法,这点很好理解,在上面的代码也有演示,如果不申明为implicit
    只能手工去调用。
  2. 作用域范围规则:
    1. 只会在当前表达式的作用范围之内查找,而且只会查找单一标识符的函数,上述代码中,
      如果stringToPrintOps方法封装在其他对象(加入叫Test)中,虽然Test对象也在作用域范围之内,但编译器不会尝试使用Test.stringToPrintOps进行转换,这就是单一标识符的概念。
    2. 单一标识符有一个例外,如果stringToPrintOps方法在PrintOps的伴生对象中申明也是有效的,Scala
      编译器也会在源类型或目标类型的伴生对象内查找隐式转换方法,本规则只会在转型有效。而一般的惯例,会将隐式转换方法封装在伴生对象中
    3. 当前作用域上下文的隐式转换方法优先级高于伴生对象内的隐式方法
  3. 不能有歧义原则:在相同优先级的位置只能有一个隐式的转型方法,否则Scala编译器无法选择适当的进行转型,编译出错。
  4. 只应用转型方法一次原则:Scala编译器不会进行多次隐式方法的调用,比如需要C类型参数,而实际类型为A,作用域内
    存在A => B,B => C的隐式方法,Scala编译器不会尝试先调用A => B ,再调用B => C
  5. 显示方法优先原则:如果方法被重载,可以接受多种类型,而作用域中存在转型为另一个可接受的参数类型的隐式方法,则不会
    被调用,Scala编译器优先选择无需转型的显式方法,例如:
    def m(a: A): Unit = ???
    def m(b: B): Unit = ??? val b: B = new B //存在一个隐式的转换方法 B => A
    implicit def b2a(b: B): A = ??? m(b) //隐式方法不会被调用,优先使用显式的 m(b: B): Unit

Implicit的应用模式有哪些?

隐式转换的核心在于将错误的类型通过查找隐式方法,转换为正确的类型。基于Scala编译器的这种隐式转换机制,通常有两种应用
模式:Magnet PatternMethod Injection

Magnet Pattern

Magnet Pattern模式暂且翻译为磁铁模式, 解决的是方法参数类型的不匹配问题,能够优雅地解决本文开头所提出的问题,
用一个通用的Service方法签名来屏蔽不同版本、不同类型服务的差异。

磁铁模式的核心在于,将函数的调用参数和返回结果封装为一个磁铁参数,这样方法的签名就统一为一个了,不需要函数重载;再
定义不同参数到磁铁参数的隐式转换函数,利用Scala的隐式转换机制,达到类似于函数重载的效果。

磁铁模式广泛运用于Spray Http 框架,该框架已经迁移到Akka Http中。

下面,我们一步步来实现一个磁铁模式,来解决本文开头提出的问题。

  1. 定义Magnet参数和使用Magnet参数的通用鉴权服务方法

    // Auth Magnet参数
    trait AuthMagnet {
    type Result
    def apply(): Result
    } // Auth Service 方法
    trait AuthService {
    def auth(am: AuthMagnet): am.Result = am()
    }
  2. 实现不同版本的AuthService

    //v1 auth service
    trait V1AuthService extends AuthService
    //v2 auth service
    trait V2AuthService extends AuthService
  3. 实现不同版本AuthService的伴生对象,添加适当的隐式转换方法

    //V1 版本的服务实现
    object V1AuthService {
    case class V1AuthRequest()
    case class V1AuthResponse() implicit def toAuthMagnet(p: V1AuthRequest): AuthMagnet {type Result = V1AuthResponse} = new AuthMagnet {
    override def apply(): Result = {
    // v1 版本的auth 业务委托到magnet的apply中实现
    println("这是V1 Auth Service")
    V1AuthResponse()
    }
    override type Result = V1AuthResponse
    }
    } //V2 版本的服务实现
    object V2AuthService {
    case class V2AuthRequest()
    case class V2AuthResponse() implicit def toAuthMagnet(p: V2AuthRequest): AuthMagnet {type Result = V2AuthResponse} = new AuthMagnet {
    override def apply(): Result = {
    // v2 版本的auth 业务委托到magnet的apply中实现
    println("这是V2 Auth Service")
    V2AuthResponse()
    }
    override type Result = V2AuthResponse
    }
    }
  4. 编写两个版本的资源接口(demo)

    trait V1Resource extends V1AuthService {
    def serv(): Unit = {
    val p = V1AuthRequest()
    val response = auth(p)
    println(s"v1 resource response: $response")
    }
    } trait V2Resource extends V2AuthService {
    def serv(): Unit = {
    val p = V2AuthRequest()
    val response = auth(p)
    println(s"v2 resource response: $response")
    }
    } val res1 = new V1Resource {}
    val res2 = new V2Resource {} res1.serv()
    res2.serv()

    控制台输出结果为:

    这是V1 Auth Service
    v1 resource response: V1AuthResponse()
    这是V2 Auth Service
    v2 resource response: V2AuthResponse()

Method Injection

Method Injection 暂且翻译为方法注入,意思是给一个类型添加没有定义的方法,实际上也是通过隐式转换来实现的,
这种技术在Scalaz中广泛使用,Scalaz为我们提供了和Haskell类似的函数式编程库。

本文中的关于printWithSeperator方法的例子其实就是Method Injection的应用,从表面上看,即是给String
Int类型添加了printWithSeperator方法。

Magnet Pattern不同的是转型所针对的对象,Magnet Pattern是针对方法参数进行转型,
Method Injection是针对调用对象进行转型。

举个简单的例子,Scala中的集合都是一个Functor,都可以进行map操作,但是Java的集合框架却没有,
如果需要对java.util.ArrayList等进行map操作则需要先转换为Scala对应的类型,非常麻烦,借助Method Injection,我们可以提供这样的辅助工具,让Java的集合框架也成为一种Functor,具备map能力:

  1. 首先定义一个Functor

    trait Functor[F[_]] {
    def map[A, B](fa: F[A])(f: A ⇒ B): F[B]
    }
  2. 再定义一个FunctorOps
    final class FunctorOps[F[_], A](l: F[A])(implicit functor: Functor[F]) {
    def map[A, B](f: A ⇒ B): F[B] = functor.map(l)(f)
    }
  3. 在FunctorOps的伴生对象中定义针对java.util.List[E]的隐式Funcotr实例和针对java.util.List[E]到
    FunctorOps的隐式转换方法
    object FunctorOps {
    // 针对List[E]的functor
    implicit val jlistFunctor: Functor[JList] = new Functor[JList] {
    override def map[A, B](fa: JList[A])(f: (A) => B): JList[B] = {
    val fb = new JLinkList[B]()
    val it = fa.iterator()
    while(it.hasNext) fb.add(f(it.next))
    fb
    }
    } // 将List[E]转换为FunctorOps的隐式转换方法
    implicit def jlistToFunctorOps[E](jl: JList[E]): FunctorOps[JList, E] = new FunctorOps[JList, E](jl)
    }
  4. 愉快滴使用map啦
    val jlist = new util.ArrayList[Int]()
    jlist.add(1)
    jlist.add(2)
    jlist.add(3)
    jlist.add(4) import FunctorOps._
    val jlist2 = jlist map (_ * 3)
    println(jlist2)
    // [3, 6, 9, 12]

总结

Implicit 是Scala语言中处理编译类型错误的一种修复机制,利用该机制,我们可以编写出任意参数和返回值的多态方法(这种多
态也被称为Ad-hoc polymorphism -- 任意多态),实现任意多态,我们通常使用Magnet Pattern磁铁模式;同时还可以
给其他类库的类型添加方法来对其他类库进行扩展,通常将这种技术称之为Method Injection

参考资料

  1. 《Programming in Scala》中关于隐式转换和隐式参数章节: http://www.artima.com/pins1ed/implicit-conversions-and-parameters.html
  2. 《The Magnet Pattern》http://spray.io/blog/2012-12-13-the-magnet-pattern/

Scala中的Implicit详解的更多相关文章

  1. Scala进阶之路-Scala高级语法之隐式(implicit)详解

    Scala进阶之路-Scala高级语法之隐式(implicit)详解 作者:尹正杰 版权声明:原创作品,谢绝转载!否则将追究法律责任. 我们调用别人的框架,发现少了一些方法,需要添加,但是让别人为你一 ...

  2. php中关于引用(&)详解

    php中关于引用(&)详解 php的引用(就是在变量或者函数.对象等前面加上&符号) 在PHP 中引用的意思是:不同的变量名访问同一个变量内容. 与C语言中的指针是有差别的.C语言中的 ...

  3. JavaScript正则表达式详解(二)JavaScript中正则表达式函数详解

    二.JavaScript中正则表达式函数详解(exec, test, match, replace, search, split) 1.使用正则表达式的方法去匹配查找字符串 1.1. exec方法详解 ...

  4. AngularJS select中ngOptions用法详解

    AngularJS select中ngOptions用法详解   一.用法 ngOption针对不同类型的数据源有不同的用法,主要体现在数组和对象上. 数组: label for value in a ...

  5. 【转载】C/C++中extern关键字详解

    1 基本解释:extern可以置于变量或者函数前,以标示变量或者函数的定义在别的文件中,提示编译器遇到此变量和函数时在其他模块中寻找其定义.此外extern也可用来进行链接指定. 也就是说extern ...

  6. oracle中imp命令详解 .

    转自http://www.cnblogs.com/songdavid/articles/2435439.html oracle中imp命令详解 Oracle的导入实用程序(Import utility ...

  7. Android中Service(服务)详解

    http://blog.csdn.net/ryantang03/article/details/7770939 Android中Service(服务)详解 标签: serviceandroidappl ...

  8. python中threading模块详解(一)

    python中threading模块详解(一) 来源 http://blog.chinaunix.net/uid-27571599-id-3484048.html threading提供了一个比thr ...

  9. Android中mesure过程详解

    我们在编写layout的xml文件时会碰到layout_width和layout_height两个属性,对于这两个属性我们有三种选择:赋值成具体的数值,match_parent或者wrap_conte ...

随机推荐

  1. Linux系统中无iptables文件的解决

    在RHEL 7 / CentOS 7中,firewalld被引入来管理iptables,CentOS7开始,默认是没有iptables的,而是使用firewall防火墙.本文将屏蔽掉firewall, ...

  2. Sprite(雪碧图)的应用

    雪碧图是根据CSS sprite音译过来的,是将很多很多的小图标放在一张图片上. 使用雪碧图的目的:有时为了美观,我们会使用一张图片来代替一些小图标,但是一个网页可能有很多的小图标,浏览器在显示页面的 ...

  3. CodeWarrior 10 配置Jlint初始化文件

    新建一个项目之后,飞思卡尔的仿真器的配置不如德州仪器那么简单.他需要一些配置. 当我们新建一个工程后,可以采取如下步骤配置Jlint: 1.右击工程名,选择属性. 2.在Run/Debug Setti ...

  4. Android使用scrollview截取整个的屏幕并分享微信

    先看看截图效果图 截取scrollview的屏幕 /** * 截取scrollview的屏幕 **/ public static Bitmap getScrollViewBitmap(ScrollVi ...

  5. python将文本写入剪切板

    import pyperclip pyperclip.copy('The text to be copied to the clipboard.') spam = pyperclip.paste() ...

  6. 返回 字符串的 form和js组合让页面跳转

    router.get("/wy/jhy").handler(ctx->{ ctx.request().response().setChunked(true); System. ...

  7. ios OC 关键字 copy,strong,weak,assign的区别

    一.先介绍 copy.strong.weak 的区别,如代码所示 @property(copy,nonatomic)NSMutableString*aCopyMStr; @property(stron ...

  8. 【转】RabbitMQ基础——和——持久化机制

    这里原来有一句话,触犯啦天条,被阉割!!!! 首先不去讨论我的日志组件怎么样.因为有些日志需要走网络,有的又不需要走网路,也是有性能与业务场景的多般变化在其中,就把他抛开,我们只谈消息RabbitMQ ...

  9. 31. pt-variable-advisor

    pt-variable-advisor h=192.168.100.101,P=3306,u=admin,p=admin mysqladmin var>/root/test/pt-variabl ...

  10. instanceof简单用法

    语法: 对象 instanceof 类: 含义:如果这个对象时这个类或者这个类的子类的实例化,那么结果及时ture, 否则 false. 常常用来判断一个类是否是某个类的子类,以此判断A类是否继承或者 ...