一.什麼是Servlet

Servlet（Server Applet）是Java Servlet的簡稱，稱為小服務程式或服務聯結器，用Java編寫的伺服器端程式，主要功能在於互動式地瀏覽和修改資料，生成動態Web內容，它工作在客戶端請求與伺服器響應的中間層，處理請求和傳送響應的過程都是由Servlet的程式來完成的。

二.tomact和servlet的關係

Tomcat 是Web應用伺服器，是一個Servlet/JSP容器。Tomcat 作為Servlet容器,負責處理客戶請求，把請求傳送給Servlet，並將Servlet的響應傳送回給客戶。而Servlet是一種執行在支援Java語言的伺服器上的元件。Tomcat將http請求文字接收並解析，然後封裝成HttpServletRequest型別的request物件，所有的HTTP頭資料讀可以通過request物件呼叫對應的方法查詢到。Tomcat同時會要響應的資訊封裝為HttpServletResponse型別的response物件，通過設定response屬性就可以控制要輸出到瀏覽器的內容，然後將response交給tomcat，tomcat就會將其變成響應文字的格式傳送給瀏覽器。

三.Servlet執行過程

       Servlet程式是由WEB伺服器呼叫，web伺服器收到客戶端的Servlet訪問請求後：
　　①Web伺服器首先檢查是否已經裝載並建立了該Servlet的例項物件。如果是，則直接執行第④步，否則，執行第②步。
　　②裝載並建立該Servlet的一個例項物件。
　　③呼叫Servlet例項物件的init()方法。
　　④建立一個用於封裝HTTP請求訊息的HttpServletRequest物件和一個代表HTTP響應訊息的HttpServletResponse物件，然後呼叫Servlet的service()方法並將請求和響應物件作為引數傳遞進去。
　　⑤WEB應用程式被停止或重新啟動之前，Servlet引擎將解除安裝Servlet，並在解除安裝之前呼叫Servlet的destroy()方法

四.Servlet的生命週期

Servlet 生命週期可被定義為從建立直到毀滅的整個過程。以下是 Servlet 遵循的過程：

第一步：Servlet 通過呼叫 init () 方法進行初始化。

init 方法被設計成只調用一次。當用戶呼叫一個 Servlet 時，就會建立一個 Servlet 例項，每一個使用者請求都會產生一個新的執行緒，init() 方法簡單地建立或載入一些資料，這些資料將被用於 Servlet 的整個生命週期。在使用者傳送請求時呼叫init()，並不是容器啟動時載入(tomact)時呼叫。

第二步：Servlet 呼叫 service() 方法來處理客戶端的請求。

Servlet 容器（即 Web 伺服器）呼叫 service() 方法來處理來自客戶端（瀏覽器）的請求，並把格式化的響應寫回給客戶端，service() 方法檢查 HTTP 請求型別（GET、POST、PUT、DELETE 等），並在適當的時候呼叫 doGet、doPost、doPut，doDelete 等方法。service 方法不需要覆寫，如果覆寫了別忘了super.service(request,response)，不然不會去呼叫doGet或者doPost方法

第三步：Servlet 通過呼叫 destroy() 方法終止（結束）。

destroy() 方法只會呼叫一次，在 Servlet 生命週期結束時被呼叫。destroy() 方法可以讓您的 Servlet 關閉資料庫連線、停止後臺執行緒、把 Cookie 列表或點選計數器寫入到磁碟，並執行其他類似的清理活動。

第四步：最後，Servlet 是由 JVM 的垃圾回收器進行垃圾回收的

在呼叫 destroy() 方法之後，servlet 物件被標記為垃圾回收。

五.Servlet部署

需要告訴容器把請求給哪個servlet，所以需要在web.xml部署路徑。

<servlet>

  <servlet-name>HelloWorld</servlet-name>

  <servlet-class>包名.類名</servlet-class>

</servlet>

<servlet-mapping>

  <servlet-name>HelloWorld</servlet-name>

  <url-pattern>/HelloWorld</url-pattern>

</servlet-mapping>

1.<servlet>

<servlet>標籤用於配置 Servlet 類資訊。<servlet-name>是 Servlet 的標識，必須保證在整個xml 中唯一。<servlet-class>是這個 Servlet 對應的類名。

2.<servlet-mapping>

<servlet-mapping>標籤用於配置Servlet 的訪問路徑。<servlet-name>需要和<servlet>中的<servlet-name>保持一致。<url-pattern>指定訪問路徑。

如上面配置的就能接收到http://localhost:8080/HelloWorld的請求。但是在servlet3.0後有了註解，可以用@WebServlet("/HelloWorld")來代替上面的配置檔案。

六.模擬Servlet

用註解方式來模擬Servlet開發。我簡單的說說註解是什麼，註解(Annotation)相當於一種標記，在程式中加入註解就等於為程式打上某種標記，沒有加，則等於沒有任何標記，以後，javac編譯器、開發工具和其他程式可以通過反射來了解你的類及各種元素上有無何種標記，看你的程式有什麼標記，就去幹相應的事，標記可以加在包、類，屬性、方法，方法的引數以及區域性變數上。@Retention(RetentionPolicy.RUNTIME)表示註解的生存週期，@Target(ElementType.TYPE)表示註解在哪。

1.先建立WebServlet註解

package Annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * 自定義WebServlet註解，模擬Servlet3.0的WebServlet註解
 * @Target 註解的屬性值表明了 @WebServlet註解只能用於類或介面定義宣告的前面， 
 * @WebServlet註解有一個必填的屬性 value 。
 * 呼叫方式為： @WebServlet(value="/xxxx") ，
 * 因語法規定如果屬性名為 value 且只填 value屬性值時，可以省略 value屬性名，即也可以寫作：@WebServlet("/xxxx") 
 */
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface WebServlet {
    //Servlet的訪問URL
    String value();
    //Servlet的訪問URL
    String[] urlPatterns() default {""};
    //Servlet的描述
    String description() default "";
    //Servlet的顯示名稱
    String displayName() default "";
    //Servlet的名稱
    String name() default "";
    //Servlet的init引數
    WebInitParam[] initParams() default {};
}

建立WebInitParam註解

package Annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface WebInitParam {
    //引數名
    String paramName() default "";
    //引數的值
    String paramValue() default "";
}

2.因為要模擬servlet，所以不能直接去建立servlet，應該要實現filter。

package Server;

import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletContext;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import Annotation.WebInitParam;
import Annotation.WebServlet;
import Tool.ScanClassUtil;

public class AnnotationHandleFilter implements Filter {

	private ServletContext servletContext = null;

	/*
	 * 過濾器初始化時掃描指定的包下面使用了WebServlet註解的那些類
	 * 
	 * @see javax.servlet.Filter#init(javax.servlet.FilterConfig)
	 */
	public void init(FilterConfig filterConfig) throws ServletException {
		System.out.println("---AnnotationHandleFilter過濾器初始化開始---");
		servletContext = filterConfig.getServletContext();
		Map<String, Class<?>> classMap = new HashMap<String, Class<?>>();
		// 獲取web.xml中配置的要掃描的包
		String basePackage = filterConfig.getInitParameter("basePackage");
		// 如果配置了多個包，例如：<param-value>me.gacl.web.controller,me.gacl.web.UI</param-value>
		if (basePackage.indexOf(",") > 0) {
			// 按逗號進行分隔
			String[] packageNameArr = basePackage.split(",");
			for (String packageName : packageNameArr) {
				addServletClassToServletContext(packageName, classMap);
			}
		} else {
			addServletClassToServletContext(basePackage, classMap);
		}
		System.out.println("----AnnotationHandleFilter過濾器初始化結束---");
	}

	/**
	 * @Method: addServletClassToServletContext
	 * @Description:新增ServletClass到ServletContext中
	 * @param packageName
	 * @param classMap
	 */
	private void addServletClassToServletContext(String packageName, Map<String, Class<?>> classMap) {
		Set<Class<?>> setClasses = ScanClassUtil.getClasses(packageName);
		for (Class<?> clazz : setClasses) {
			if (clazz.isAnnotationPresent(WebServlet.class)) {
				// 獲取WebServlet這個Annotation的例項
				WebServlet annotationInstance = clazz.getAnnotation(WebServlet.class);
				// 獲取Annotation的例項的value屬性的值
				String annotationAttrValue = annotationInstance.value();
				if (!annotationAttrValue.equals("")) {
					classMap.put(annotationAttrValue, clazz);
				}
				// 獲取Annotation的例項的urlPatterns屬性的值
				String[] urlPatterns = annotationInstance.urlPatterns();
				for (String urlPattern : urlPatterns) {
					classMap.put(urlPattern, clazz);
				}
				servletContext.setAttribute("servletClassMap", classMap);
				System.out.println("annotationAttrValue：" + annotationAttrValue);
				String targetClassName = annotationAttrValue.substring(annotationAttrValue.lastIndexOf("/") + 1);
				System.out.println("targetClassName：" + targetClassName);
				System.out.println(clazz);
			}
		}
	}

	public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
			throws IOException, ServletException {
		System.out.println("---進入註解處理過濾器---");
		// 將ServletRequest強制轉換成HttpServletRequest
		HttpServletRequest req = (HttpServletRequest) request;
		HttpServletResponse res = (HttpServletResponse) response;
		@SuppressWarnings("unchecked")
		Map<String, Class<?>> classMap = (Map<String, Class<?>>) servletContext.getAttribute("servletClassMap");
		// 獲取contextPath
		String contextPath = req.getContextPath();
		// 獲取使用者請求的URI資源
		String uri = req.getRequestURI();
		// 如果沒有指明要呼叫Servlet類中的哪個方法
		if (uri.indexOf("!") == -1) {
			// 獲取使用者使用的請求方式
			String reqMethod = req.getMethod();
			// 獲取要請求的servlet路徑
			String requestServletName = uri.substring(contextPath.length(), uri.lastIndexOf("."));
			// 獲取要使用的類
			Class<?> clazz = classMap.get(requestServletName);
			// 建立類的例項
			Object obj = null;
			try {
				obj = clazz.newInstance();
			} catch (InstantiationException e1) {
				e1.printStackTrace();
			} catch (IllegalAccessException e1) {
				e1.printStackTrace();
			}
			Method targetMethod = null;
			if (reqMethod.equalsIgnoreCase("get")) {
				try {
					targetMethod = clazz.getDeclaredMethod("doGet", HttpServletRequest.class,
							HttpServletResponse.class);
				} catch (SecurityException e) {
					e.printStackTrace();
				} catch (NoSuchMethodException e) {
					e.printStackTrace();
				}
			} else {
				try {
					targetMethod = clazz.getDeclaredMethod("doPost", HttpServletRequest.class,
							HttpServletResponse.class);
				} catch (SecurityException e) {
					e.printStackTrace();
				} catch (NoSuchMethodException e) {
					e.printStackTrace();
				}
			}

			try {
				// 呼叫物件的方法進行處理
				targetMethod.invoke(obj, req, res);
			} catch (IllegalArgumentException e) {
				e.printStackTrace();
			} catch (IllegalAccessException e) {
				e.printStackTrace();
			} catch (InvocationTargetException e) {
				e.printStackTrace();
			}
		} else {
			// 獲取要請求的servlet路徑
			String requestServletName = uri.substring(contextPath.length(), uri.lastIndexOf("!"));
			// 獲取要呼叫的servlet的方法
			String invokeMethodName = uri.substring(uri.lastIndexOf("!") + 1, uri.lastIndexOf("."));

			// 獲取要使用的類
			Class<?> clazz = classMap.get(requestServletName);
			// 建立類的例項
			Object obj = null;
			try {
				obj = clazz.newInstance();
			} catch (InstantiationException e1) {
				e1.printStackTrace();
			} catch (IllegalAccessException e1) {
				e1.printStackTrace();
			}
			// 獲得clazz類定義的所有方法
			Method[] methods = clazz.getDeclaredMethods();
			// 獲取WebServlet這個Annotation的例項
			WebServlet annotationInstance = clazz.getAnnotation(WebServlet.class);
			// 獲取註解上配置的初始化引數陣列
			WebInitParam[] initParamArr = annotationInstance.initParams();
			Map<String, String> initParamMap = new HashMap<String, String>();
			for (WebInitParam initParam : initParamArr) {
				initParamMap.put(initParam.paramName(), initParam.paramValue());
			}
			// 遍歷clazz類中的方法
			for (Method method : methods) {
				// 該方法的返回型別
				Class<?> retType = method.getReturnType();
				// 獲得方法名
				String methodName = method.getName();
				// 列印方法修飾符
				System.out.print(Modifier.toString(method.getModifiers()));
				System.out.print(" " + retType.getName() + " " + methodName + "(");
				// 獲得一個方法引數陣列（getparameterTypes用於返回一個描述引數型別的Class物件陣列）
				Class<?>[] paramTypes = method.getParameterTypes();
				for (int j = 0; j < paramTypes.length; j++) {
					// 如果有多個引數，中間則用逗號隔開，否則直接列印引數
					if (j > 0) {
						System.out.print(",");
					}
					System.out.print(paramTypes[j].getName());
				}
				System.out.println(");");
				if (method.getName().equalsIgnoreCase("init")) {
					try {
						// 呼叫Servlet的初始化方法
						method.invoke(obj, initParamMap);
					} catch (IllegalArgumentException e) {
						e.printStackTrace();
					} catch (IllegalAccessException e) {
						e.printStackTrace();
					} catch (InvocationTargetException e) {
						e.printStackTrace();
					}
				}
			}
			// 獲取WebServlet這個Annotation的例項
			System.out.println("invokeMethodName：" + invokeMethodName);
			try {
				try {
					// 利用反射獲取方法例項，方法的簽名必須符合：
					// public void 方法名(HttpServletRequest request,
					// HttpServletResponse response)
					// 例如：public void loginHandle(HttpServletRequest request,
					// HttpServletResponse response)
					Method targetMethod = clazz.getDeclaredMethod(invokeMethodName, HttpServletRequest.class,
							HttpServletResponse.class);
					// 呼叫物件的方法進行處理
					targetMethod.invoke(obj, req, res);
				} catch (SecurityException e) {
					e.printStackTrace();
				} catch (NoSuchMethodException e) {
					e.printStackTrace();
				} catch (IllegalArgumentException e) {
					e.printStackTrace();
				} catch (InvocationTargetException e) {
					e.printStackTrace();
				}
			} catch (IllegalAccessException e) {
				e.printStackTrace();
			}
		}
	}

	public void destroy() {

	}
}

AnnotationHandleFilter過濾器初始化時掃描指定的包下面使用了WebServlet註解的那些類，然後將類儲存到一個Map集合中，再將Map集合儲存到servletContext物件中

3.需要在web.xml裡配置過濾器

<filter>
        <description>註解處理過濾器</description>
        <filter-name>AnnotationHandleFilter</filter-name>
        <filter-class>Server.AnnotationHandleFilter</filter-class>
        <init-param>
            <description>配置要掃描包及其子包, 如果有多個包,以逗號分隔</description>
            <param-name>basePackage</param-name>
            <param-value>Test</param-value>
        </init-param>
    </filter>
    
    <filter-mapping>
        <filter-name>AnnotationHandleFilter</filter-name>
        <!-- 攔截字尾是.do的請求 -->
        <url-pattern>*.do</url-pattern>
    </filter-mapping>

4.需要的工具類

AnnotationHandleFilter過濾器初始化方法init(FilterConfig filterConfig)使用到了一個用於掃描某個包下面的類的工具類ScanClassUtil，通過上面的配置檔案需要去掃描哪些類帶有註解標籤的，有的話把類用map集合裝起來。

5.簡單測試

package Test;

import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import Annotation.WebServlet;

@WebServlet("/Login")
public class LoginServlet {

    public void doGet(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException{
        request.getRequestDispatcher("/Login.jsp").forward(request, response);
    }
    
    public void doPost(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        doGet(request, response);
    }
}

總結：容器載入的時候，filter的init方法也載入了，當用戶請求時，容器會把請求給servlet，但在service方法執行前會先呼叫dofilter方法，在上面覆寫了dofilter方法，但在初始化filter的時候，獲得該專案路徑，獲得配置檔案中的basePackage，再通過ScanClassUtil類把需要掃描的包下面所有的類用集合裝起來。然後通過addServletClassToServletContext方法去遍歷這個類元素上是否加了WebServlet註解，如果有就得到WebServlet裡的value值和屬性值，並重新放到map集合裡。再執行dofilter方法，並得到請求的url路徑，通過拆分得到要使用的類，再去map集合裡取出來通過反射例項化，通過使用者的請求去呼叫doget還是dopost方法。