my-scala-dispatcher

@Singleton
class Dispatcher {


  private[this] val log = LoggerFactory.getLogger(this.getClass)

  private[this] val allocator = UnpooledByteBufAllocator.DEFAULT

  private[this] var mapping: mutable.Set[MappingCase] = _

  @Inject
  def this(scanner: MappingScanner) {
    this()
    mapping = scanner.routerMapping(Constant.mappingPackage)
  }


  def dispatch(req: FullHttpRequest): Option[DefaultFullHttpResponse] = {
    log.debug("dispatch uri :{}", req.uri())
    mapping
      .find(x => x.pattern.matches(req.uri()) && x.method == req.method.toString.toUpperCase)
      .map(_.mappings)
      .flatMap(routingTo(req, _))
      .orElse(strResponse(str = Constant.NOT_FOUND, status = HttpResponseStatus.NOT_FOUND))
  }

  private def routingTo(req: FullHttpRequest, mapping: Mappings): Option[DefaultFullHttpResponse] = {
     try {
       mapping.execute(req).flatMap {
         case str: String => strResponse(str)
         case bytes: Array[Byte] => response(allocator.heapBuffer(bytes.length).writeBytes(bytes), contentType = "application/octet-stream")
         case ref: AnyRef => Option(ref).map(JSON.toJSONString(_)).flatMap(strResponse(_, contentType = "application/json"))
         case _ => strResponse("null")
       }
     } catch {
       case e: Exception =>
         log.error("execute mapping error:\r\n", e)
         strResponse(str = Option(e.getMessage).getOrElse("exception with 417"), status = HttpResponseStatus.EXPECTATION_FAILED)
     }
   }
...

@Singleton
class HttpServer {

  private[this] val log = LoggerFactory.getLogger(this.getClass)

  private[this] val bossGroup = new NioEventLoopGroup()

  private[this] val workerGroup = new NioEventLoopGroup()

  @Inject
  private[this] var channelIn: HttpChannelInitializer = _


  @throws[InterruptedException]
  def start(): Unit = {
    try {
      log.info("------ http server starting..")
      val serverBootstrap = new ServerBootstrap
      serverBootstrap
        .group(bossGroup, workerGroup)
        .channel(classOf[NioServerSocketChannel])
        .childHandler(channelIn)
        .option(ChannelOption.SO_BACKLOG.asInstanceOf[ChannelOption[Any]], 128)
        .childOption(ChannelOption.SO_KEEPALIVE.asInstanceOf[ChannelOption[Any]], true)
        .option(ChannelOption.RCVBUF_ALLOCATOR, new AdaptiveRecvByteBufAllocator(Constant.MIN_BUFFER_SIZE, Constant.INITIAL_BUFFER_SIZE, Constant.MAXIMUM_BUFFER_SIZE));
      val channelFuture = serverBootstrap.bind(Constant.iNetPort).sync
      log.info("------http server started,port:" + Constant.iNetPort)
      channelFuture.channel.closeFuture.sync
    } finally {
      workerGroup.shutdownGracefully()
      bossGroup.shutdownGracefully()
    }
  }
...

@Singleton
class MappingScanner {

  private val log = LoggerFactory.getLogger(this.getClass)

  val injector: Injector = Application.injector

  def routerMapping(packageName: String = "*"): mutable.Set[MappingCase] = {
    val reflections: Reflections = new Reflections(packageName)
    log.info("scan mappings,package:{}", packageName)
    CollectionConverters.SetHasAsScala(reflections.getTypesAnnotatedWith(classOf[HandlerMapping]))
      .asScala
      .map(k => {
        val mapping = k.getAnnotation(classOf[HandlerMapping])
        MappingCase(mapping.httpMethod(), injector.getInstance(k).asInstanceOf[Mappings], methodMatcher(mapping))
      })
  }

  private def methodMatcher(mapping: HandlerMapping): Regex = ("^" + mapping.value() + "$").r
}