Tomcat启动后，获取到项目当中所有的servlet的@WebServlet中的配置信息。将配置信息和类对象都写入一个map集合当中。
map就是一个key-value类型的集合。
在MyTomcat中我们获取到了类对象和注解值。
Tomcat与请求连通
1. ServletConfigMapping
1. 创建一个config包，包下新建一个ServletConfigMapping类，写一个static代码块，static代码块在main方法执行之前执行。把MyTomcat中的代码搬过来。
package com.qcby.tomcat.config;
import com.qcby.tomcat.webServlet.WebServlet;
import java.io.File;
import java.net.URL;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.List;
/*
* servlet容器
*
*
* */
public class ServletConfigMapping {
//static代码块在main方法执行之前执行
static{
try {
// 1. 扫描包路径 ()
String packageName = "com.qcby.tomcat.myweb";
//通过调用getclass方法，获取到了myweb这个包下的所有类的类对象，并将其放入到了容器当中
List<Class<?>> classes = getClasses(packageName);
// 2. 遍历所有类，检查是否有@WebServlet注解
for (Class<?> clazz : classes) {
if (clazz.isAnnotationPresent(WebServlet.class)) {//检查是否含有@WebServlet注解
// 3. 获取@WebServlet注解的值
WebServlet webServlet = clazz.getAnnotation(WebServlet.class);
System.out.println("类名: " + clazz.getName() + " | URL路径: " + webServlet.path());
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* 获取指定包下的所有类
*
* @param packageName 包名，例如 "com.qcby.tomcat.myweb"
* @return 类对象列表
* @throws Exception
*/
private static List<Class<?>> getClasses(String packageName) throws Exception {
List<Class<?>> classes = new ArrayList<>();//定义一个可变长数组，放置类对象
String path = packageName.replace('.', '/'); // 将包名转换为文件路径
// 通过类加载器获取包的资源路径 ClassLoader是类加载器，负责动态加载Java类到Java虚拟机（JVM）中。
ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
//Thread.currentThread() 方法返回对当前执行线程的引用。
//.getContextClassLoader() 方法则返回该线程的上下文类加载器。上下文类加载器是线的程在创建时从父线程继承，
// 或者在创建线程时没有设置父线程的上下文类加载器时，默认使用应用程序类加载器（Application ClassLoader）
//ClassLoader 类提供了 getResources(String name) 方法，该方法用于---查找具有指定名称的资源
Enumeration<URL> resources = classLoader.getResources(path);
//Enumeration<URL> 对象包含了所有找到的资源的URL。
while (resources.hasMoreElements()) {//通过hasMoreElements()方法来检查是否还有更多的元素
如果返回true，则表示枚举中还有元素未被遍历，可以继续调用nextElement()方法来获取下一个元素
URL resource = resources.nextElement();
//调用URL对象的toURI()方法将其转换为URI对象。
//使用new File(URI uri)构造函数将URI对象转换为File对象。
File directory = new File(resource.toURI());
//File对象代表目录，不是文件
// 扫描文件夹下的所有类文件
if (directory.exists()) {
for (File file : directory.listFiles()) {//可以利用listFiles()方法来获取该目录下所有文件和子目录的数组
if (file.getName().endsWith(".class")) {
//java文件自己创建的话是xx.java文件，后经过编译是：xx.class文件，这里用的是编译后的文件
// 获取类的完整类名
String className = packageName + "." + file.getName().replace(".class", "");
classes.add(Class.forName(className));
}
}
}
}
return classes;
}
public static void main(String[] args) {
}
}
执行这个main方法，就自动会先执行static代码块。通常是这样用的。（也可以直接写在main方法里）。
2. 创建map映射表，类对象用HttpServlet类型承接。
！！为什么这里是HttpServlet？
for (Class<?> clazz : classes) { if (clazz.isAnnotationPresent(WebServlet.class)) {//检查是否含有@WebServlet注解 // 3. 获取@WebServlet注解的值 WebServlet webServlet = clazz.getAnnotation(WebServlet.class); //System.out.println("类名: " + clazz.getName() + " | URL路径: " + webServlet.path()); //classMap.put(webServlet.path(),(Class<HttpServlet>) clazz); } }这里的类对象：
MyFirstServlet的类对象
MySecondServlet的类对象
MyThirdServlet的类对象
这几个都继承了HttpServlet，都是HttpServlet的子类。
我们就可以用父类的容器去承接子类的对象，这样的话就可以承接这几个，如果写MyFirstServlet，就不能写其他的类，无法转型。父类的引用指向子类的对象，子类可以向上转型为父类的引用。他们之间没有父子类的关系。
故写HttpServlet。
代码修改：
public static Map<String,Class<HttpServlet>> classMap=new HashMap<>();
//static代码块在main方法执行之前执行
static{
try {
// 1. 扫描包路径 ()
String packageName = "com.qcby.tomcat.myweb";
//通过调用getclass方法，获取到了myweb这个包下的所有类的类对象，并将其放入到了容器当中
List<Class<?>> classes = getClasses(packageName);
// 2. 遍历所有类，检查是否有@WebServlet注解
for (Class<?> clazz : classes) {
if (clazz.isAnnotationPresent(WebServlet.class)) {//检查是否含有@WebServlet注解
// 3. 获取@WebServlet注解的值
WebServlet webServlet = clazz.getAnnotation(WebServlet.class);
//System.out.println("类名: " + clazz.getName() + " | URL路径: " + webServlet.path());
classMap.put(webServlet.path(),(Class<HttpServlet>) clazz);
}
}2. MyTomcat
当执行MyTomcat的main方法时，ServletConfigMapping并没有执行。
启动和后两个没有连接上。
我们想要当启动Tomcat时，就能获取到项目当中所有的配置信息，根据生成类对象，并且把类对象放入到容器中。
即，想要当MyTomcat的main方法执行时，ServletConfigMapping也执行。
方法很简单，只需要在ServletConfigMapping写一个静态方法，什么名字都可以，在MyTomcat调用即可。
因为static代码块在main方法之前执行，所以在static代码块执行之后，定义的www方法（改名init()）才会执行。
或者直接把static代码块中的代码放进init方法中。
3. Server
同样，在Server类中，把main方法改成serverInit方法（把该方法直接调到MyTomcat类中）
public static void serverInit() throws Exception{
// 1.打开通信端口 tomcat：8080 3306 ---------》进行网络通信
ServerSocket serverSocket = new ServerSocket(8080);//监听8080端口号
System.out.println("****************server start.....");
//2.接受请求数据
while (true){
Socket socket = serverSocket.accept(); //--------------------->注意：此时监听网卡的是：主线程
System.out.println("有客户进行了链接");
new Thread(()->{ //利用子线程方式处理数据
//处理数据---------》数据的处理在于读和写
try {
handler(socket);
} catch (Exception e) {
e.printStackTrace();
}
}).start();
}
}然后，在MyTomcat中调用。
public class MyTomcat {
public static void main(String[] args) {
try{
ServletConfigMapping.init();//初始化servlet容器
Server.serverInit();//启动server服务
}catch (Exception e){
e.printStackTrace();
}
}
现在，请求也打过来了，该执行下一步，根据key值,获取类对象。
4. 如何做好匹配？
将请求的信息封装到了request对象当中，根据request当中的path，去解决掉当前匹配问题。
当程序启动之后，已经把map集合创建好了，此时用户的请求打过来了，请求信息处理完之后封装在request对象当中，
package com.qcby.tomcat;
import com.qcby.tomcat.HttpServlet.HttpServlet;
import com.qcby.tomcat.Request.Request;
import com.qcby.tomcat.Response.Response;
import com.qcby.tomcat.config.ServletConfigMapping;
import com.qcby.tomcat.socket.Server;
import com.qcby.tomcat.webServlet.WebServlet;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.lang.annotation.Annotation;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.URL;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.List;
public class MyTomcat {
public static Request request=new Request();
public static Response response=new Response();
public static void main(String[] args) throws Exception {
ServletConfigMapping.init();
serverInit();
}
public static void serverInit() throws Exception{
// 1.打开通信端口 tomcat：8080 3306 ---------》进行网络通信
ServerSocket serverSocket = new ServerSocket(8080);//监听8080端口号
System.out.println("****************server start.....");
//2.接受请求数据
while (true){
Socket socket = serverSocket.accept(); //--------------------->注意：此时监听网卡的是：主线程
System.out.println("有客户进行了链接");
new Thread(()->{ //利用子线程方式处理数据
//处理数据---------》数据的处理在于读和写
try {
handler(socket);
} catch (Exception e) {
e.printStackTrace();
}
}).start();
}
}
public static void handler(Socket socket) throws Exception {
//读取请求的数据
InputStream inputStream = socket.getInputStream();
requestContext(inputStream);
}
public static void requestContext(InputStream inputStream) throws IOException, InstantiationException, IllegalAccessException {
//将bit流转为文字信息
int count = 0;
while (count == 0){
count = inputStream.available();
}
byte[] bytes = new byte[count];
inputStream.read(bytes);
String Context = new String(bytes);
System.out.println(Context);
//解析数据
if(Context.equals("")){
System.out.println("你输入了一个空请求");
}else {
//获得第一行的前两个
String firstLine=Context.split("\\n")[0];//根据换行来获取第一行数据
String path=firstLine.split("\\s")[1];
String method=firstLine.split("\\s")[0];
System.out.println(path+" "+method);
request.setMethod(method);
request.setPath(path);
}
dis(request);
}
public static void dis(Request request) throws InstantiationException, IllegalAccessException {
if(!request.getPath().equals("")){//不是空请求
if(ServletConfigMapping.classMap.get(request.getPath())!=null){//当前请求地址能否从classMap中查找到
Class<HttpServlet> ClassServlet=ServletConfigMapping.classMap.get(request.getPath());//获取类对象
HttpServlet servlet=ClassServlet.newInstance();//根据获取到的类对象，创建对应的对象 用父类去接，多态（父类的引用指向子类的对象）
servlet.service(request,response);//调用HttpServlet的service方法，判断是get请求还是post请求
}
}
}
}
其中，
public static void dis(Request request) throws InstantiationException, IllegalAccessException { if(!request.getPath().equals("")){//不是空请求 if(ServletConfigMapping.classMap.get(request.getPath())!=null){//当前请求地址能否从classMap中查找到，匹配成功 Class<HttpServlet> ClassServlet=ServletConfigMapping.classMap.get(request.getPath());//获取类对象 HttpServlet servlet=ClassServlet.newInstance();//根据获取到的类对象，创建对应的对象 用父类去接，多态（父类的引用指向子类的对象） servlet.service(request,response);//调用HttpServlet的service方法，判断是get请求还是post请求 } } }方法是对象当中的一块内存空间
但是这是类对象，不是对象，想要得到信息就得生成对象。
通过类对象去创建对象，是我们需要做的。
用类对象创建对象， 因为不确定是请求的哪个对象，需要用父类去承接（多态）， 根据对象调用它的doGet或doPost方法。
如此，
即可在启动Tomcat之后，通过浏览器输入请求，得到信息。
