squbs-23. 资源解决方案

原文地址：Resource Resolution

鉴于很少-如果存在-真实的生活应用可以不依赖外部资源工作，环境识别资源解决方案成为应用基础设施的一个关键部分。squbs通过ResolverRegistry提供资源解决方案，并允许任何类型的资源通过名称解决，环境指的是在开发环境、测试环境、研发环境下使用不同的资源。

依赖

这个解析器在 squbs-ext。在你的build.sbt或scala构建文件中加入以下依赖：

"org.squbs" %% "squbs-ext" % squbsVersion

用法

Resolver的基础用法来发现资源。类型由注册表生产，可以拥有多种类型的资源。在我们的例子中，我们使用 URI类型在本篇文档中。查找调用如下所示：

Scala

//在指定的环境下处理资源
val resource: Option[URI] = ResolverRegistry(system).resolve[URI]("myservice", QA)

Java

//在指定的环境下处理资源
val resource: Optional<URI> = ResolverRegistry.get(system).resolve(URI.class, "myservice", QA.value());

ResolverRegistry

ResolverRegistry是一个Akka的扩展，并在Scala和Java中遵循Akka扩展使用模式。它可以托管各种类型的资源解释器，因此通过将它传递给register调用在注册时提供资源类型。同类型或不同类型的多个解释器可以被注册。

发现链

资源发现遵循后进后出模型。最近注册的解释器优先于先前注册的。ResolverRegistry逐一走链直到有一个解释器兼容该类型并生产资源，或者将链走完。在那种情况下，这个注册表将返回None在Scala API中，在Java API中返回Optional.empty()。

类型兼容

在调用 resolve 时， ResolverRegistry 检查请求类型。如果这个注册的解释器的类型与请求类型是同类型或自类型，这个解释器（resolver ）将被用于尝试通过名称解释该资源。

由于JVM类型擦除，注册类型参数或请求类型不计算在内。举个例子，一个注册类型 java.util.ArrayList<String>可能被resolve调用匹配上java.util.List<Int>，因为String 和Int 类型在运行时被擦除了。因为这个限制，使用参数类型来注册和查找通常不建议使用。结果是未定义的-你可能获得一个错误的资源。

简单的来说，这里不建议使用类型的层次结构。所有注册的类型应该是唯一类型。

注册解释器

这里有两套解释器注册的API风格。一个是一个快捷的API通过传递一个闭包/lambda作为解释器。这个闭包 /lambda返回 Option[T]类型在Scala中，Optional<T>在Java中。另一个，完全的API使用 Resolver[T]在Scala中，AbstractResolver<T>在Java中。T为资源类型。参见如下：

Scala

// To register a new resolver for type URI using a closure. Note the return
// type of the closure must be `Option[T]` or in this case `Option[URI]`
ResolverRegistry(system).register[URI]("MyResolver") { (svc, env) =>
  (svc, env) match {
    case ("myservice", QA) => Some(URI.create("http://myservice.qa.mydomain.com"))
    case ("myservice", Default) => Some(URI.create("http://myservice.mydomain.com"))
    case ("myservice2", QA) => Some(URI.create("http://myservice2.qa.mydomain.com"))
    case ("myservice2", Default) => Some(URI.create("http://myservice2.mydomain.com"))
    case _ => None
  }
}

// To register a new resolver for type URI by extending the `Resolver` trait
class MyResolver extends Resolver[URI] {
  def name: String = "MyResolver"
  
  def resolve(svc: String, env: Environment = Default): Option[URI] = {
    (svc, env) match {
      case ("myservice", QA) => Some(URI.create("http://myservice.qa.mydomain.com"))
      case ("myservice", Default) => Some(URI.create("http://myservice.mydomain.com"))
      case ("myservice2", QA) => Some(URI.create("http://myservice2.qa.mydomain.com"))
      case ("myservice2", Default) => Some(URI.create("http://myservice2.mydomain.com"))
      case _ => None
    }
  }
}

//然后只需要注册解释器
ResolverRegistry(system).register[URI](new MyResolver)

Java

// To register a new resolver for type URI using a lambda. Note the return
// type of the lambda must be `Optional<T>` or in this case `Optional<URI>`
ResolverRegistry.get(system).register("MyResolver", (svc, env) -> {
    if ("myservice".equals(svc)) {
        if (QA.value().equals(env)) {
          return Optional.of(URI.create("http://myservice.qa.mydomain.com"));
        } else {
          return Optional.of(URI.create("http://myservice.mydomain.com"));
        }
    } else if ("myservice2".equals(svc)) {
        if (QA.value().equals(env)) {
          return Optional.of(URI.create("http://myservice2.qa.mydomain.com"));
        } else {
          return Optional.of(URI.create("http://myservice2.mydomain.com"));
        }    
    } else {
        return Optional.empty();
    }
});

// To register a new resolver for type URI by extending an abstract class
public class MyResolver extends AbstractResolver<URI> {
    @Override
    public String name() {
        return "MyResolver";
    }
    
    @Override
    public Optional<URI> resolve(String svc, Environment env) {
        if ("myservice".equals(svc)) {
            if (QA.value().equals(env)) {
                return Optional.of(URI.create("http://myservice.qa.mydomain.com"));
            } else {
                return Optional.of(URI.create("http://myservice.mydomain.com"));
            }
        } else if ("myservice2".equals(svc)) {
            if (QA.value().equals(env)) {
                return Optional.of(URI.create("http://myservice2.qa.mydomain.com"));
            } else {
                return Optional.of(URI.create("http://myservice2.mydomain.com"));
            }    
        } else {
            return Optional.empty();
        }
    }
}

// Then register MyResolver.
ResolverRegistry.get(system).register(URI.class, new MyResolver());

解释资源（Resolving for a Resource）

类似于注册，解决方案需要一个类型兼容注册类型；注册类型必须相同或为解决类型的子类。

Scala

// To resolve a resource with `Default` environment.
val resource: Option[URI] = ResolverRegistry(system).resolve[URI]("myservice")

// To resolve a resource for a specific environment.
val resource: Option[URI] = ResolverRegistry(system).resolve[URI]("myservice", QA)

Java

val resource: Optional<URI> = ResolverRegistry.get(system).resolve(URI.class, "myservice", QA.value());

取消注册解析器

取消注册解析器通过名称使用以下API完成

Scala

ResolverRegistry(system).unregister("MyResolver")

Java

ResolverRegistry.get(system).unregister("MyResolver");

并发考虑

注册解析器和取消注册解析器以非并发方式完成，在初始化时间。这里没有对并发注册进行保护，因此并发注册的结果是未定义的。你的解释器可能，亦或是不可能在一个并发注册解析器上注册或取消注册。

然而，在ResolverRegistry级别上，Resolve调用是线程安全的并且可以无限次的并发访问。每个注册解释器需要线程安全。