day03-实现02
实现02
3.实现任务阶段3-处理Servlet02
3.3Servlet规范设计
3.3.1MyServlet
该类模仿Servlet接口，为了简化，只声明了三个方法：init()，service()，destroy()
package com.li.MyTomcat.servlet;
import com.li.MyTomcat.http.MyRequest;
import com.li.MyTomcat.http.MyResponse;
import java.io.IOException;
/**
* @author 李
* @version 1.0
* 只保留了三个核心的方法声明
*/
public interface MyServlet {
void init() throws Exception;
void service(MyRequest request, MyResponse response) throws IOException;
void destroy();
}
3.3.2MyHttpServlet
该类实现MyServlet接口，并声明了doGet()，doPost()方法让MyHttpServlet的子类去实现
package com.li.MyTomcat.servlet;
import com.li.MyTomcat.http.MyRequest;
import com.li.MyTomcat.http.MyResponse;
import java.io.IOException;
/**
* @author 李
* @version 1.0
*/
public abstract class MyHttpServlet implements MyServlet {
@Override
public void service(MyRequest request, MyResponse response) throws IOException {
//equalsIgnoreCase 比较字符串内容是否相同，不区分大小写
if ("GET".equalsIgnoreCase(request.getMethod())) {
//这里会有动态绑定
this.doGet(request, response);
} else if ("POST".equalsIgnoreCase(request.getMethod())) {
//这里会有动态绑定
this.doPost(request, response);
}
}
//这里我们使用一个模板设计模式
//让MyHttpServlet的子类去实现
public abstract void doGet(MyRequest request, MyResponse response);
public abstract void doPost(MyRequest request, MyResponse response);
}
3.3.3MyCalServlet
业务类servlet
package com.li.MyTomcat.servlet;
import com.li.MyTomcat.http.MyRequest;
import com.li.MyTomcat.http.MyResponse;
import com.li.MyTomcat.utils.WebUtils;
import java.io.IOException;
import java.io.OutputStream;
/**
* @author 李
* @version 1.0
*/
public class MyCalServlet extends MyHttpServlet {
@Override
public void doGet(MyRequest request, MyResponse response) {
//动态绑定机制，每次调用doGet方法都会执行service方法
//业务代码
//完成计算任务
int num1 = WebUtils.parseInt(request.getParameter("num1"), 0);
int num2 = WebUtils.parseInt(request.getParameter("num2"), 0);
int sum = num1 + num2;
//返回结算结果给浏览器
//outputStream和当前连接的socket关联
OutputStream outputStream = response.getOutputStream();
String respMes = MyResponse.respHeader + "<h1>" + num1 + "+" + num2 + "=" + sum + "</h1>";
try {
outputStream.write(respMes.getBytes());
outputStream.flush();
outputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
@Override
public void doPost(MyRequest request, MyResponse response) {
doGet(request, response);
}
@Override
public void init() throws Exception {}
@Override
public void destroy() {}
}
3.3.4WebUtils
该类为工具类，供MyCalServlet使用
package com.li.MyTomcat.utils;
public class WebUtils {
public static int parseInt(String str, int defaultVal) {
try {
return Integer.parseInt(str);
} catch (NumberFormatException e) {
System.out.println(str + " 不能转成数字");
}
return defaultVal;
}
}
3.3.5RequestHandler
修改RequestHandler类（线程类），如下：
package com.li.MyTomcat.hander;
import com.li.MyTomcat.http.MyRequest;
import com.li.MyTomcat.http.MyResponse;
import com.li.MyTomcat.servlet.MyCalServlet;
import java.io.*;
import java.net.Socket;
/**
* @author 李
* @version 1.0
* RequestHandler是一个线程对象
* 用来处理一个http请求
*/
public class RequestHandler implements Runnable {
//定义一个Socket
private Socket socket = null;
//在创建RequestHandler对象的时候，将主线程的socket传给线程对象来使用
public RequestHandler(Socket socket) {
this.socket = socket;
}
@Override
public void run() {
//对客户端进行交互
try {
System.out.println("当前线程=" + Thread.currentThread().getName());
InputStream inputStream = socket.getInputStream();
MyRequest myRequest = new MyRequest(inputStream);
//这里我们可以通过myResponse对象返回数据给客户端
MyResponse myResponse = new MyResponse(socket.getOutputStream());
//创建MyCalServlet对象（之后再用反射来构建对象，而不是new）
MyCalServlet myCalServlet = new MyCalServlet();
//之后再用反射来调用方法
myCalServlet.doGet(myRequest, myResponse);
inputStream.close();
socket.close();
} catch (IOException e) {
e.printStackTrace();
} finally {
//一定要确保socket关闭
if (socket != null) {
try {
socket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
MyTomcatV2类不变
3.3.6测试
运行MyTomcatV2，在浏览器中输入地址http://localhost:8080/myCalServlet?num1=100&num2=200，回车，浏览器显示如下：
3.4容器设计
在上面的线程类RequestHandler中，我们是通过new来创建一个 实现了Servlet接口 的对象，但是实际的tomcat是反射来实例化该对象的。
一个问题：Servlet应该在哪里被实例化，以及如何去管理呢？
思路：
将来的Servlet会很多，我们不可能去到MyTomcat源码里面去修改，应该用web.xml文件去配置Servlet
为了管理，应该创建两个容器（使用HashMap或ConcurrentHashMap）
一个容器（ServletMapping）存放 ：HashMap<ServletName，对应的实例>
另一个容器（ServletUrlMapping）存放：HashMap<url-pattern，ServletName>
当浏览器发送请求，我们获取该请求的uri部分，去容器ServletUrlMapping里面去查该uri，如果有，通过该uri获取对应的ServletName。然后到另一个容器ServletMapping，根据ServletName去找对应的反射对象的实例，然后再去调用它。
3.4.1容器实现
- 首先在web.xml文件中配置自己设计的Servlet
<!--配置自己设计的Servlet-->
<servlet>
<servlet-name>MyCalServlet</servlet-name>
<!--忽略报错-->
<servlet-class>com.li.MyTomcat.servlet.MyCalServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>MyCalServlet</servlet-name>
<url-pattern>/myCalServlet</url-pattern>
</servlet-mapping>
注意：<servlet-class>这里会报错，因为非原生的servlet，xml不会识别，我们忽l略报错即。
记得在target\classes目录手动拷贝一份web.xml [默认是自动拷贝，这里不是原生tomcat，因此不会自动拷贝]，配置信息可以从上一个项目web.xml拷贝修改即可。所有报红都忽略
- 注意在pom.xml文件中导入dom4j的jar包：
<!--导入dom4j-->
<dependency>
<groupId>dom4j</groupId>
<artifactId>dom4j</artifactId>
<version>1.1</version>
</dependency>
- MyTomcatV3
package com.li.MyTomcat;
import com.li.MyTomcat.hander.RequestHandler;
import com.li.MyTomcat.servlet.MyHttpServlet;
import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;
import java.io.File;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.List;
import java.util.concurrent.ConcurrentHashMap;
/**
* @author 李
* @version 3.0
* 第三版MyTomcat，实现通过xml和反射来初始化容器
* （这里设置为一启动MyTomcat就实例化servlet）
*/
public class MyTomcatV3 {
//1.容器 ServletMapping 存放 ConcurrentHashMap<ServletName，对应的实例>
public static final ConcurrentHashMap<String, MyHttpServlet>
servletMapping = new ConcurrentHashMap<>();
//2.容器 ServletUrlMapping 存放 ConcurrentHashMap<url-pattern，ServletName>
public static final ConcurrentHashMap<String, String>
servletUrlMapping = new ConcurrentHashMap<>();
public static void main(String[] args) {
MyTomcatV3 myTomcatV3 = new MyTomcatV3();
myTomcatV3.init();
//启动MyTomcatV3容器
myTomcatV3.run();
}
//启动MyTomcatV3容器
public void run() {
try {
ServerSocket serverSocket = new ServerSocket(8080);
System.out.println("=====MyTomcatV3在8080监听=====");
while (!serverSocket.isClosed()) {
Socket socket = serverSocket.accept();
RequestHandler requestHandler = new RequestHandler(socket);
new Thread(requestHandler).start();
}
} catch (IOException e) {
e.printStackTrace();
}
}
//直接对两个容器进行初始化
public void init() {
//读取web.xml文件 => dom4j(注意导jar包)
//path=/D:/IDEA-workspace/li_tomcat/target/classes/
String path = MyTomcatV3.class.getResource("/").getPath();
//使用dom4j技术完成web.xml文件的读取
SAXReader reader = new SAXReader();
try {
Document document = reader.read(new File(path + "web.xml"));
//得到根元素
Element rootElement = document.getRootElement();
//得到根节点下面的所有元素
List<Element> elements = rootElement.elements();
//遍历并过滤到servlet和servlet-mapping
for (Element element : elements) {
//如果元素为servlet
if ("servlet".equalsIgnoreCase(element.getName())) {
//这是一个servlet配置
//System.out.println("发现servlet");
//使用反射将该servlet实例放入到容器servletMapping中
String servletName = element.element("servlet-name").getText().trim();
String servletClass = element.element("servlet-class").getText().trim();
servletMapping.put(servletName,
(MyHttpServlet) Class.forName(servletClass).newInstance());
} else if ("servlet-mapping".equalsIgnoreCase(element.getName())) {
//如果元素为servlet-mapping
//System.out.println("发现servlet-mapping");
String servletName = element.element("servlet-name").getText().trim();
String urlPattern = element.element("url-pattern").getText().trim();
//将uri对应的servletName放入容器servletUrlMapping中
servletUrlMapping.put(urlPattern, servletName);
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
修改RequestHandler：
package com.li.MyTomcat.hander;
import com.li.MyTomcat.MyTomcatV3;
import com.li.MyTomcat.http.MyRequest;
import com.li.MyTomcat.http.MyResponse;
import com.li.MyTomcat.servlet.MyHttpServlet;
import java.io.*;
import java.net.Socket;
/**
* @author 李
* @version 1.0
* RequestHandler是一个线程对象
* 用来处理一个http请求
*/
public class RequestHandler implements Runnable {
//定义一个Socket
private Socket socket = null;
//在创建RequestHandler对象的时候，将主线程的socket传给线程对象来使用
public RequestHandler(Socket socket) {
this.socket = socket;
}
@Override
public void run() {
//对客户端进行交互
try {
System.out.println("当前线程=" + Thread.currentThread().getName());
MyRequest myRequest = new MyRequest(socket.getInputStream());
//这里我们可以通过myResponse对象返回数据给客户端
MyResponse myResponse = new MyResponse(socket.getOutputStream());
//得到浏览器发送的http的uri，作为key，去查找容器里该servletName
//然后去另一容器里找实例，如有就调用，如果没有就返回404
//1.得到uri=>就是servletUrlMapping的ur-pattern
String uri = myRequest.getUri();
String servletName = MyTomcatV3.servletUrlMapping.get(uri);
if (servletName == null) {
servletName = "";
}
//2.通过uri->servletName->servlet的实例
//注意：这里myHttpServlet的编译类型是MyHttpServlet，但是运行类型是MyHttpServlet的子类
MyHttpServlet myHttpServlet = MyTomcatV3.servletMapping.get(servletName);
//3.调用service方法，通过动态绑定机制，调用运行类型的doGet或doPost方法
if (myHttpServlet != null) {//如果找到到该servlet了
myHttpServlet.service(myRequest, myResponse);
} else {
//没有这个servlet，返回404
String resp = MyResponse.respHeader + "<h1>404 Not Found</h1>";
OutputStream outputStream = myResponse.getOutputStream();
outputStream.write(resp.getBytes());
outputStream.flush();
outputStream.close();
}
socket.close();
} catch (IOException e) {
e.printStackTrace();
} finally {
//一定要确保socket关闭
if (socket != null) {
try {
socket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
为了测试，在MyCalServlet类中增加提示信息：
其他类保持不变
3.4.2测试
运行MyTomcatV3，在浏览器输入 http://localhost:8080/myCalServlet?num1=99&num2=1
浏览器显示如下：
在地址栏中输入不存在的资源，返回404NotFound
后台输出：
4.练习
分析html等静态资源，完成通过页面提交数据进行计算，浏览器请求 http://localhost:8080/hspCalServlet, 提交数据，完成计算任务，如果该servlet 不存在，返回 404
思路：在线程类中，拿到浏览器请求的uri的时候，增加新的业务逻辑：
(1)判断uri是什么资源
(2)如果是静态资源，就读取该资源，并返回给浏览器（注意设置Content-Type text/html）
(3)因为是自定义的tomcat，所以maven项目的target不会自动更新
(4)需要自己将静态文件等拷贝到该目录下，浏览器才能访问到(这里把读取的静态资源放到target/classes/下)
练习
- 读取的静态资源放到target/classes/下-cal.html:
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>计算器</title>
</head>
<body>
<h1>计算器</h1>
<form action="/myCalServlet" method="get">
num1：<input type="text" name="num1"/><br/>
num2：<input type="text" name="num2"/><br/>
<input type="submit" value="提交">
</form>
</body>
</html>
- 在工具类中增加如下方法
//1.判断uri是不是html文件
public static boolean isHtml(String uri) {
//endsWith() 方法用于测试字符串是否以指定的后缀结束
return uri.endsWith(".html");
}
//2.根据文件名来读取该文件-->String
public static String readHtml(String fileName) {
////path为程序实际运行的根目录
//path=/D:/IDEA-workspace/li_tomcat/target/classes/
String path = WebUtils.class.getResource("/").getPath();
//使用StringBuilder，便于对字符串的追加
StringBuilder stringBuilder = new StringBuilder();
try {
BufferedReader bufferedReader =
new BufferedReader(new FileReader(path + fileName));
//读取文件
String buff = "";
while ((buff = bufferedReader.readLine()) != null) {
stringBuilder.append(buff);
}
} catch (Exception e) {
e.printStackTrace();
}
return stringBuilder.toString();
}
- 在线程类中的run方法中，在容器中寻找servlet前，先使用浏览器请求的uri在目录下寻找静态资源，如果有就返回，并且结束线程
if (WebUtils.isHtml(uri)) {//如果是静态资源
String context = WebUtils.readHtml(uri.substring(1));//uri最后的/要拿掉
//得到outputstream，返回信息给浏览器
String resp = MyResponse.respHeader + context;
OutputStream outputStream = myResponse.getOutputStream();
outputStream.write(resp.getBytes());
outputStream.flush();
outputStream.close();
socket.close();
return;//结束run方法运行，这之前先关闭socket
}
-
测试
在浏览器中输入
http://localhost:8080/cal.html，显示访问资源成功
输入数据，点击提交，成功访问到对应的servlet资源
