How Tomcat Works(Scala语言) 02 一个简单的Servlet容器

最新推荐文章于 2020-07-08 05:08:54 发布
最新推荐文章于 2020-07-08 05:08:54 发布
阅读量1.2k 收藏
点赞数
分类专栏： Scala Tomcat 文章标签： scala tomcat Tomcat
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ivan_pig/article/details/8462202
版权

3 一个简单的Servlet容器

  • Servlet容器除了能访问静态资源以外，还能访问Servlet。所以比前一章多了两个类StaticResourceProcessor和ServletProcessor
  • 此处的Servlet依据Servlet规范实现，所以需要servlet.jar。后续会自己实现此接口
  • 访问静态资源的方式和前篇代码完全相同，只是将response.sendStaticResource()抽成单独的StaticResourceProcessor类
  • 根据url来区分访问的内容，类似/servlet/*的uri会调用ServletProcessor否则调用StaticResourceProcessor
  • ServletProcessor的功能是根据url来加载指定路径下的class,并调用相应的方法
  • 具体区别请见类内注释
package simple

import java.io.InputStream
import java.io.BufferedReader
import java.util.Enumeration
import java.util.Locale
import java.util.Map
import javax.servlet.{ServletInputStream, RequestDispatcher, ServletRequest}
import io.Source

/**
 * Created with IntelliJ IDEA.
 * User: Administrator
 * Date: 13-1-2
 * Time: 下午10:32
 * To change this template use File | Settings | File Templates.
 */
//Request类和前一章的类完全相同
//区别在于，由于此类继承了ServletRequest，所以必须要实现其所有的抽象方法，这里都是空实现
class Request(input: InputStream) extends ServletRequest {

  var uri: String = _

  def parseUri(requestString: String): String = {
    val pattern = """[^ ]* *([^ ]*) *[\s\S]*""".r
    val pattern(result) = requestString
    result
  }

  def parse {
    val lines = Source.fromInputStream(input).getLines()
    if (lines.hasNext) {
      uri = parseUri(lines.next())
    }
  }

  def getAttribute(attribute: String): AnyRef = {
    return null
  }

  def getAttributeNames: Enumeration[_] = {
    return null
  }

  def getRealPath(path: String): String = {
    return null
  }

  def getRequestDispatcher(path: String): RequestDispatcher = {
    return null
  }

  def isSecure: Boolean = {
    return false
  }

  def getCharacterEncoding: String = {
    return null
  }

  def getContentLength: Int = {
    return 0
  }

  def getContentType: String = {
    return null
  }

  def getInputStream: ServletInputStream = {
    return null
  }

  def getLocale: Locale = {
    return null
  }

  def getLocales: Enumeration[_] = {
    return null
  }

  def getParameter(name: String): String = {
    return null
  }

  def getParameterMap: Map[_, _] = {
    return null
  }

  def getParameterNames: Enumeration[_] = {
    return null
  }

  def getParameterValues(parameter: String): Array[String] = {
    return null
  }

  def getProtocol: String = {
    return null
  }

  def getReader: BufferedReader = {
    return null
  }

  def getRemoteAddr: String = {
    return null
  }

  def getRemoteHost: String = {
    return null
  }

  def getScheme: String = {
    return null
  }

  def getServerName: String = {
    return null
  }

  def getServerPort: Int = {
    return 0
  }

  def removeAttribute(attribute: String) {
  }

  def setAttribute(key: String, value: AnyRef) {
  }

  def setCharacterEncoding(encoding: String) {
  }
}

package simple

import java.io.OutputStream
import java.io.FileInputStream
import java.io.FileNotFoundException
import java.io.File
import java.io.PrintWriter
import java.util.Locale
import javax.servlet.ServletResponse
import javax.servlet.ServletOutputStream

/**
 * Created with IntelliJ IDEA.
 * User: Administrator
 * Date: 13-1-2
 * Time: 下午10:34
 * To change this template use File | Settings | File Templates.
 */
//Response类和前一章的类完全相同
//区别在于，由于此类继承了ServletResponse，所以必须要实现其所有的抽象方法，这里都是空实现
object Response {
  val BUFFER_SIZE: Int = 1024
  val bytes: Array[Byte] = new Array[Byte](Response.BUFFER_SIZE)
  val FileNotFoundMessage = """HTTP/1.1 404 File Not Found
                              |Content-Type: text/html
                              |Content-Length: 23
                              |
                              |<h1>File Not Found</h1>"""
}

class Response(output: OutputStream) extends ServletResponse {

  def sendStaticResource() {
    var fis: FileInputStream = null
    try {
      val file: File = new File(HttpServer.WEB_ROOT, request.uri)
      fis = new FileInputStream(file)
      //将文件内容写到响应中
      writeToResponse(fis)
    } catch {
      case e: FileNotFoundException => {
        //将文件内容写到响应中
        output.write(Response.FileNotFoundMessage.getBytes())
      }
    } finally {
      if (fis != null) fis.close
    }
  }

  //递归读取文件，写入到响应流
  def writeToResponse(fis: FileInputStream) {
    val ch = fis.read(Response.bytes, 0, Response.BUFFER_SIZE)
    if (ch != -1) {
      output.write(Response.bytes, 0, ch)
      writeToResponse(fis)
    }
  }

  /** implementation of ServletResponse  */
  def flushBuffer {
  }

  def getBufferSize: Int = {
    return 0
  }

  def getCharacterEncoding: String = {
    return null
  }

  def getLocale: Locale = {
    return null
  }

  def getOutputStream: ServletOutputStream = {
    return null
  }

  def getWriter: PrintWriter = {
    writer = new PrintWriter(output, true)
    return writer
  }

  def isCommitted: Boolean = {
    return false
  }

  def reset {
  }

  def resetBuffer {
  }

  def setBufferSize(size: Int) {
  }

  def setContentLength(length: Int) {
  }

  def setContentType(`type`: String) {
  }

  def setLocale(locale: Locale) {
  }

  var request: Request = _
  var writer: PrintWriter = _
}

package simple

import java.net.ServerSocket
import java.net.InetAddress
import java.io.File

/**
 * Created with IntelliJ IDEA.
 * User: Administrator
 * Date: 13-1-2
 * Time: 下午10:28
 * To change this template use File | Settings | File Templates.
 */

object HttpServer {

  val WEB_ROOT: String = System.getProperty("user.dir") + File.separator + "webroot"
  val SHUTDOWN_COMMAND: String = "/SHUTDOWN"

  def main(args: Array[String]) {
    val server: HttpServer = new HttpServer
    server.await
  }
}

class HttpServer {
  def await {
    val port: Int = 8080
    val serverSocket = new ServerSocket(port, 1, InetAddress.getByName("127.0.0.1"))

    while (!shutdown) {
      try {
        val socket = serverSocket.accept
        val input = socket.getInputStream
        val output = socket.getOutputStream

        val request: Request = new Request(input)
        request.parse

        val response: Response = new Response(output)
        response.request = request

        //此处是HttpServer与前一章不同的地方
        //根据uri是否以/servlet/开头，来判断是静态资源，还是servlet
        //如果是静态资源则调用StaticResourceProcessor，否则调用ServletProcessor
        if (request.uri.startsWith("/servlet/")) {
          val processor: ServletProcessor = new ServletProcessor
          processor.process(request, response)
        } else {
          val processor: StaticResourceProcessor = new StaticResourceProcessor
          processor.process(request, response)
        }

        socket.close
        shutdown = request.uri == HttpServer.SHUTDOWN_COMMAND
      } catch {
        case e: Exception => e.printStackTrace
      }
    }
  }

  private var shutdown: Boolean = false
}

package simple

/**
 * Created with IntelliJ IDEA.
 * User: Administrator
 * Date: 13-1-2
 * Time: 下午10:36
 * To change this template use File | Settings | File Templates.
 */
//仅一行，调用response的sendStaticResource返回静态资源
//此代码原来在HttpServer中，现单独为一个类
class StaticResourceProcessor {
  def process(request: Request, response: Response) {
      response.sendStaticResource
  }
}

package simple

import java.net.URL
import java.net.URLClassLoader
import java.net.URLStreamHandler
import java.io.File
import javax.servlet.Servlet
import javax.servlet.ServletRequest
import javax.servlet.ServletResponse

/**
 * Created with IntelliJ IDEA.
 * User: Administrator
 * Date: 13-1-2
 * Time: 下午10:37
 * To change this template use File | Settings | File Templates.
 */
//根据url,从类路径下加载相应的servlet类
//并相继调用service方法
class ServletProcessor {
  def process(request: Request, response: Response) {
    //根据url找到servletName
    val servletName: String = request.uri.substring(request.uri.lastIndexOf("/") + 1)
    //根据class路径，创建classLoader
    val urls: Array[URL] = new Array[URL](1)
    val streamHandler: URLStreamHandler = null
    val classPath: File = new File(HttpServer.WEB_ROOT)
    val repository: String = (new URL("file", null, classPath.getCanonicalPath + File.separator)).toString
    urls(0) = new URL(null, repository, streamHandler)
    val loader = new URLClassLoader(urls)

    //使用classLoader根据servletName加载类
    val myClass = loader.loadClass(servletName)
    //实例化类并调用service方法
    val servlet = myClass.newInstance.asInstanceOf[Servlet]
    servlet.service(request.asInstanceOf[ServletRequest], response.asInstanceOf[ServletResponse])
  }
}

上面的代码完成了基本的Servlet容器功能。但是在ServletProcessor中有个问题，就是当你把Request和Response传递给servlet时，你需要强制转换为ServletRequest和 ServletResponse。而如果开发人员知道ServletRequest和ServletResponse是Request和Response的话，他就可以强制转回去，并调用parse和sendStaticResource方法。 由于其他类需要调用这两个方法，所以你不能将其设为private。当然你可以设为private[simple]，使得其只能在simple包内访问，但是开发人员依然可以将servlet包设为simple来进行访问。 这里可以使用Facade来解决这个问题。

  • 添加RequestFacade和ResponseFacade方法
  • 修改ServletProcessor类，使用RequestFacade和ResponseFacade来封装request和response
package facade

import javax.servlet.{RequestDispatcher, ServletInputStream, ServletRequest}
import java.util.{Map, Enumeration, Locale}
import java.io.BufferedReader

/**
 * Created with IntelliJ IDEA.
 * User: Administrator
 * Date: 13-1-3
 * Time: 下午8:31
 * To change this template use File | Settings | File Templates.
 */
//仅仅是对request对应方法的调用
//屏蔽了parse方法
class RequestFacade(val request: Request) extends ServletRequest {

  def getAttribute(attribute: String): AnyRef = {
    return request.getAttribute(attribute)
  }

  def getAttributeNames: Enumeration[_] = {
    return request.getAttributeNames
  }

  def getRealPath(path: String): String = {
    return request.getRealPath(path)
  }

  def getRequestDispatcher(path: String): RequestDispatcher = {
    return request.getRequestDispatcher(path)
  }

  def isSecure: Boolean = {
    return request.isSecure
  }

  def getCharacterEncoding: String = {
    return request.getCharacterEncoding
  }

  def getContentLength: Int = {
    return request.getContentLength
  }

  def getContentType: String = {
    return request.getContentType
  }

  def getInputStream: ServletInputStream = {
    return request.getInputStream
  }

  def getLocale: Locale = {
    return request.getLocale
  }

  def getLocales: Enumeration[_] = {
    return request.getLocales
  }

  def getParameter(name: String): String = {
    return request.getParameter(name)
  }

  def getParameterMap: Map[_, _] = {
    return request.getParameterMap
  }

  def getParameterNames: Enumeration[_] = {
    return request.getParameterNames
  }

  def getParameterValues(parameter: String): Array[String] = {
    return request.getParameterValues(parameter)
  }

  def getProtocol: String = {
    return request.getProtocol
  }

  def getReader: BufferedReader = {
    return request.getReader
  }

  def getRemoteAddr: String = {
    return request.getRemoteAddr
  }

  def getRemoteHost: String = {
    return request.getRemoteHost
  }

  def getScheme: String = {
    return request.getScheme
  }

  def getServerName: String = {
    return request.getServerName
  }

  def getServerPort: Int = {
    return request.getServerPort
  }

  def removeAttribute(attribute: String) {
    request.removeAttribute(attribute)
  }

  def setAttribute(key: String, value: AnyRef) {
    request.setAttribute(key, value)
  }

  def setCharacterEncoding(encoding: String) {
    request.setCharacterEncoding(encoding)
  }
}

package facade

import javax.servlet.{ServletOutputStream, ServletResponse}
import java.util.Locale
import java.io.PrintWriter


/**
 * Created with IntelliJ IDEA.
 * User: Administrator
 * Date: 13-1-3
 * Time: 下午8:31
 * To change this template use File | Settings | File Templates.
 */
//仅仅是对response相应方法的调用
//屏蔽了sendStaticResource方法
class ResponseFacade(val response: Response) extends ServletResponse {
  def flushBuffer {
    response.flushBuffer
  }

  def getBufferSize: Int = {
    return response.getBufferSize
  }

  def getCharacterEncoding: String = {
    return response.getCharacterEncoding
  }

  def getLocale: Locale = {
    return response.getLocale
  }

  def getOutputStream: ServletOutputStream = {
    return response.getOutputStream
  }

  def getWriter: PrintWriter = {
    return response.getWriter
  }

  def isCommitted: Boolean = {
    return response.isCommitted
  }

  def reset {
    response.reset
  }

  def resetBuffer {
    response.resetBuffer
  }

  def setBufferSize(size: Int) {
    response.setBufferSize(size)
  }

  def setContentLength(length: Int) {
    response.setContentLength(length)
  }

  def setContentType(`type`: String) {
    response.setContentType(`type`)
  }

  def setLocale(locale: Locale) {
    response.setLocale(locale)
  }
}

package facade

import java.net.URL
import java.net.URLClassLoader
import java.net.URLStreamHandler
import java.io.File
import javax.servlet.Servlet
import javax.servlet.ServletRequest
import javax.servlet.ServletResponse

/**
 * Created with IntelliJ IDEA.
 * User: Administrator
 * Date: 13-1-2
 * Time: 下午10:37
 * To change this template use File | Settings | File Templates.
 */
//根据url,从类路径下加载相应的servlet类
//并相继调用service方法
class ServletProcessor {
  def process(request: Request, response: Response) {
    //根据url找到servletName
    val servletName: String = request.uri.substring(request.uri.lastIndexOf("/") + 1)
    //根据class路径，创建classLoader
    val urls: Array[URL] = new Array[URL](1)
    val streamHandler: URLStreamHandler = null
    val classPath: File = new File(HttpServer.WEB_ROOT)
    val repository: String = (new URL("file", null, classPath.getCanonicalPath + File.separator)).toString
    urls(0) = new URL(null, repository, streamHandler)
    val loader = new URLClassLoader(urls)

    //使用classLoader根据servletName加载类
    val myClass = loader.loadClass(servletName)
    //实例化类并调用service方法
    val servlet = myClass.newInstance.asInstanceOf[Servlet]
    //是用facade封装request和response，屏蔽parse和sendStaticResource方法
    servlet.service(new RequestFacade(request).asInstanceOf[ServletRequest],
                    new ResponseFacade(response).asInstanceOf[ServletResponse])
  }
}
Blog URL:http://www.ivanpig.com/blog/?p=491
IvanEye
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
深入了解 Scala 编程语言
05-18
Scala代表了一个新的语言品种，它抹平了这些人为划分的界限。根据David Rupp在博客中的说法，Scala可能是下一代Java。这么高的评价让人不禁想看看它到底是什么东西。 Scala有几项关键特性表明了它的面向对象的本质。...
linux下搭建scala环境并写个简单的scala程序
08-26
本文对Linux下搭建Scala环境的步骤进行了详细的介绍，并编写了一个简单的Scala程序来测试环境。希望本文对大家的学习和工作具有一定的参考价值。 Scala是一种功能强大且灵活的编程语言，广泛应用于大数据处理、机器...
scala eclipse_我的第一个Scala Servlet（使用Eclipse）
dlz00001的博客
07-08 207
在本文中，我将向您展示如何调整Eclipse，以便能够在Scala中编写“经典” webapp。 我了解Lift，我只想逐步了解Scala如何整合到我现有的基础架构中。 设置您的Eclipse项目 Eclipse有一个插件（可在Scala IDE站点上找到 ），可让您帮助使用Scala进行开发。 该插件绝不是完美的（自动完成功能在Ganymede中不起作用），但是它可以完...
Scala 基础入门教程
热门推荐
tomcat的专栏
03-16 1万+
1.前言最近在参加Hadoop和Spark培训，需要使用Scala，自学了一下作为入门，这里作一个记录。2.下载1) 在scala官网下载，地址: http://www.scala-lang.org/2) 下载IDE，地址: http://scala-ide.org/3）配置环境变量SCALA_HOME:C:\Program Files (x86)\scalaPath:C:\Program Fil
tomcat容器启动web应用(sbt和scala环境下)
一路风景
11-30 1593
首先明确, 此方法适用场景:  > 只修改前端, 不修改后台, 尤其适用于修改前台时还需要后台数据的情况, 可以减少你频繁的container:start操作和等待(就是替换spray里的jetty). 不适用场景:  如果修改后台scala代码的话,需要重新替换jar包,并重启tomcat, 此时不如直接使用container:start  ---------
用Scala实现简单的Web和API服务器
CSDN资讯
10-07 3068
【CSDN 编者按】大家都知道Web和API服务器在互联网中的重要性，在计算机网络方面提供了最基本的界面。本文主要介绍了怎样利用Scala实现实时聊天网站和API服务器，通过本篇文章，你定将受益匪浅。 作者 | Haoyi 译者 |弯月，责编 | 刘静 出品 | CSDN（ID：CSDNnews） 以下为译文： Web和API服务器是互联网系统的骨干，它们为计算机通过网...
How Tomcat Works(Scala语言) 01 一个简单的Web服务器
PEAK
01-01 1808
1 简介 此文算是《How Tomcat Works》的Scala代码解析版。主要从代码角度来分析Tomcat的结构。使用Scala来进行说明。 采用简单说明+代码注释的方式来描述，代码也尽量简单化，做到以最少的文字来进行表述。 2 一个简单的Web服务器 一个静态服务器，根据请求，返回请求的静态文件内容三个类HttpServer,Response,RequestRe
JAVA工程师成神道路--一个萝卜一个坑
weixin_33851177的博客
03-19 201
2019独角兽企业重金招聘Python工程师标准>>> ...
如何成为一个牛掰的Java大神
fick777的专栏
12-28 3677
如何成为一个牛掰的Java大神？ 2015-12-24 java那些事 这个文章不错，所以转载过来，怕过一段这个页面不存在了。 来自：HollisChuang's Blog 链接：http://www.hollischuang.com/archives/489 一、基础篇 1.1 JVM 1.1.1. Java内存模
springboot-scala-withswagger：Scala语言采用Spring-Boot结合Swagger的一个简单例子
02-04
在Scala中结合使用Spring Boot的基本指南 将JDK版本更新为1.8，以使用Lambda 动作可以返回rx.Observable，就像返回Callable或DeferredResult一样，请参见RxJavaController 当控制器返回Callable / DeferredResult ...
chess-game-scala:用Scala编程语言简单实现象棋游戏
07-11
"chess-game-scala" 这个标题明确指出了我们要讨论的是一个使用Scala编程语言实现的象棋游戏项目。"scala" 是关键标签，表明这个项目是用Scala这一现代、函数式编程语言编写的。通过标题我们可以预见到，这个项目将...
如何成为一个牛掰的Java大神？
weixin_33840661的博客
03-21 87
一、基础篇 1.1 JVM 1.1.1. Java内存模型，Java内存管理，Java堆和栈，垃圾回收 http://www.jcp.org/en/jsr/detail?id=133http://ifeve.com/jmm-faq/ 1.1.2. 了解JVM各种参数及调优 1.1.3. 学习使用Java工具 jps, jstack, ...
快学Scala习题解答—第三章 数组相关操作
PEAK
12-04 3300
4 数组相关操作 4.1 编写一段代码，将a设置为一个n个随机整数的数组，要求随机数介于0(包含)和n(不包含)之间 random和yield的使用 import scala.collection.mutable.ArrayBuffer import scala.math.random def randomArray(n:Int):Array[Int]={ val
快学Scala习题解答—第二章 控制结构和函数
PEAK
12-03 3219
3 控制结构和函数 3.1 一个数字如果为正数，则它的signum为1;如果是负数,则signum为-1;如果为0,则signum为0.编写一个函数来计算这个值 简单的逻辑判断 def signum(num:Int){if(num>0)print(1)else if(numelse print(0)} Scala中已经有此方法了，刚才查找API的时候，应该能看到 Big
快学Scala习题解答—第一章 基础
PEAK
12-02 2810
1 简介 近期对Scala比较感兴趣，买了本《快学Scala》,感觉不错。比《Programming Scala:Tackle Multi-Core Complexity on the Java Virtual Machine》好很多。 是本不错的入门书。而且每个章节都设置了难度级别，每章有习题，可以巩固Scala语法。 本文的目的就是针对这些习题进行解答 2 基础
快学Scala习题解答—第十四章 模式匹配和样例类
PEAK
03-10 2520
15 模式匹配和样例类 15.1 JDK发行包有一个src.zip文件包含了JDK的大多数源代码。解压并搜索样例标签(用正则表达式case [^:]+:)。然后查找以//开头并包含[Ff]alls?thr的注释，捕获类似// Falls through或// just fall thru这样的注释。假定JDK的程序员们遵守Java编码习惯，在该写注释的地方写下了这些注释，有多少百分比
scala语言写一个简单鲜花代码
最新发布
05-24
以下是一个简单的 Scala 代码，演示如何创建一个鲜花类和使用它： ```scala class Flower(val name: String, val color: String) { def bloom(): Unit = { println(s"A $color $name is blooming.") } } val rose = new Flower("rose", "red") rose.bloom() // 输出 "A red rose is blooming." ``` 在这个例子中，我们定义了一个 `Flower` 类，并在类中定义了两个属性 `name` 和 `color`，以及一个 `bloom` 方法来描述鲜花开放的过程。然后我们创建了一个 `rose` 对象，并调用它的 `bloom` 方法。 输出结果是 "A red rose is blooming."，说明我们成功地创建了一个鲜花对象并调用了它的方法。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值