|
|
13分27秒 步骤 1 : 拓扑图点亮 步骤 2 : 配置 Servlet 步骤 3 : Constant 步骤 4 : context.xml 步骤 5 : ContextXMLUtil 步骤 6 : WebConfigDuplicatedException 步骤 7 : Context 步骤 8 : 继续 步骤 9 : HttpProcessor 步骤 10 : j2ee 步骤 11 : TestTomcat 步骤 12 : 比较可运行项目，快速定位问题
增值内容，请先登录
自己写一个Tomcat， 几乎使用到了除开框架外的所有Java 技术，如多线程，Socket, J2EE, 反射，Log4j, JSoup, JUnit, Html 等一整套技术栈， 从无到有，循序渐进涵盖全部74个知识点，549个开发步骤, 为竞争高薪资职位加上一个有吸引力的砝码.
增值内容，点击购买
使用爬虫已经被系统记录，请勿使用爬虫，增大封号风险。 如果是误封 ，请联系站长，谢谢
增值内容，请先登录
自己写一个Tomcat， 几乎使用到了除开框架外的所有Java 技术，如多线程，Socket, J2EE, 反射，Log4j, JSoup, JUnit, Html 等一整套技术栈， 从无到有，循序渐进涵盖全部74个知识点，549个开发步骤, 为竞争高薪资职位加上一个有吸引力的砝码.
增值内容，点击购买
使用爬虫已经被系统记录，请勿使用爬虫，增大封号风险。 如果是误封 ，请联系站长，谢谢
增值内容，请先登录
自己写一个Tomcat， 几乎使用到了除开框架外的所有Java 技术，如多线程，Socket, J2EE, 反射，Log4j, JSoup, JUnit, Html 等一整套技术栈， 从无到有，循序渐进涵盖全部74个知识点，549个开发步骤, 为竞争高薪资职位加上一个有吸引力的砝码.
增值内容，点击购买
使用爬虫已经被系统记录，请勿使用爬虫，增大封号风险。 如果是误封 ，请联系站长，谢谢
package cn.how2j.diytomcat.util;
import cn.hutool.system.SystemUtil;
import java.io.File;
public class Constant {
public final static String response_head_202 =
"HTTP/1.1 200 OK\r\n" +
"Content-Type: {}\r\n\r\n";
public static final String response_head_404 =
"HTTP/1.1 404 Not Found\r\n" +
"Content-Type: text/html\r\n\r\n";
public static final String response_head_500 = "HTTP/1.1 500 Internal Server Error\r\n"
+ "Content-Type: text/html\r\n\r\n";
public static final String textFormat_404 =
"<html><head><title>DIY Tomcat/1.0.1 - Error report</title><style>" +
"<!--H1 {font-family:Tahoma,Arial,sans-serif;color:white;background-color:#525D76;font-size:22px;} " +
"H2 {font-family:Tahoma,Arial,sans-serif;color:white;background-color:#525D76;font-size:16px;} " +
"H3 {font-family:Tahoma,Arial,sans-serif;color:white;background-color:#525D76;font-size:14px;} " +
"BODY {font-family:Tahoma,Arial,sans-serif;color:black;background-color:white;} " +
"B {font-family:Tahoma,Arial,sans-serif;color:white;background-color:#525D76;} " +
"P {font-family:Tahoma,Arial,sans-serif;background:white;color:black;font-size:12px;}" +
"A {color : black;}A.name {color : black;}HR {color : #525D76;}--></style> " +
"</head><body><h1>HTTP Status 404 - {}</h1>" +
"<HR size='1' noshade='noshade'><p><b>type</b> Status report</p><p><b>message</b> <u>{}</u></p><p><b>description</b> " +
"<u>The requested resource is not available.</u></p><HR size='1' noshade='noshade'><h3>DiyTocmat 1.0.1</h3>" +
"</body></html>";
public static final String textFormat_500 = "<html><head><title>DIY Tomcat/1.0.1 - Error report</title><style>"
+ "<!--H1 {font-family:Tahoma,Arial,sans-serif;color:white;background-color:#525D76;font-size:22px;} "
+ "H2 {font-family:Tahoma,Arial,sans-serif;color:white;background-color:#525D76;font-size:16px;} "
+ "H3 {font-family:Tahoma,Arial,sans-serif;color:white;background-color:#525D76;font-size:14px;} "
+ "BODY {font-family:Tahoma,Arial,sans-serif;color:black;background-color:white;} "
+ "B {font-family:Tahoma,Arial,sans-serif;color:white;background-color:#525D76;} "
+ "P {font-family:Tahoma,Arial,sans-serif;background:white;color:black;font-size:12px;}"
+ "A {color : black;}A.name {color : black;}HR {color : #525D76;}--></style> "
+ "</head><body><h1>HTTP Status 500 - An exception occurred processing {}</h1>"
+ "<HR size='1' noshade='noshade'><p><b>type</b> Exception report</p><p><b>message</b> <u>An exception occurred processing {}</u></p><p><b>description</b> "
+ "<u>The server encountered an internal error that prevented it from fulfilling this request.</u></p>"
+ "<p>Stacktrace:</p>" + "<pre>{}</pre>" + "<HR size='1' noshade='noshade'><h3>DiyTocmat 1.0.1</h3>"
+ "</body></html>";
public final static File webappsFolder = new File(SystemUtil.get("user.dir"),"webapps");
public final static File rootFolder = new File(webappsFolder,"ROOT");
public static final File confFolder = new File(SystemUtil.get("user.dir"),"conf");
public static final File serverXmlFile = new File(confFolder, "server.xml");
public static final File webXmlFile = new File(confFolder, "web.xml");
public static final File contextXmlFile = new File(confFolder, "context.xml");
}
增值内容，请先登录
自己写一个Tomcat， 几乎使用到了除开框架外的所有Java 技术，如多线程，Socket, J2EE, 反射，Log4j, JSoup, JUnit, Html 等一整套技术栈， 从无到有，循序渐进涵盖全部74个知识点，549个开发步骤, 为竞争高薪资职位加上一个有吸引力的砝码.
增值内容，点击购买
使用爬虫已经被系统记录，请勿使用爬虫，增大封号风险。 如果是误封 ，请联系站长，谢谢
<?xml version='1.0' encoding='utf-8'?>
<Context>
<WatchedResource>WEB-INF/web.xml</WatchedResource>
</Context>
<?xml version='1.0' encoding='utf-8'?>
<Context>
<WatchedResource>WEB-INF/web.xml</WatchedResource>
</Context>
增值内容，请先登录
自己写一个Tomcat， 几乎使用到了除开框架外的所有Java 技术，如多线程，Socket, J2EE, 反射，Log4j, JSoup, JUnit, Html 等一整套技术栈， 从无到有，循序渐进涵盖全部74个知识点，549个开发步骤, 为竞争高薪资职位加上一个有吸引力的砝码.
增值内容，点击购买
使用爬虫已经被系统记录，请勿使用爬虫，增大封号风险。 如果是误封 ，请联系站长，谢谢
package cn.how2j.diytomcat.util;
import cn.hutool.core.io.FileUtil;
import org.jsoup.Jsoup;
import org.jsoup.nodes.Document;
import org.jsoup.nodes.Element;
public class ContextXMLUtil {
public static String getWatchedResource() {
try {
String xml = FileUtil.readUtf8String(Constant.contextXmlFile);
Document d = Jsoup.parse(xml);
Element e = d.select("WatchedResource").first();
return e.text();
} catch (Exception e) {
e.printStackTrace();
return "WEB-INF/web.xml";
}
}
}
增值内容，请先登录
自己写一个Tomcat， 几乎使用到了除开框架外的所有Java 技术，如多线程，Socket, J2EE, 反射，Log4j, JSoup, JUnit, Html 等一整套技术栈， 从无到有，循序渐进涵盖全部74个知识点，549个开发步骤, 为竞争高薪资职位加上一个有吸引力的砝码.
增值内容，点击购买
使用爬虫已经被系统记录，请勿使用爬虫，增大封号风险。 如果是误封 ，请联系站长，谢谢
package cn.how2j.diytomcat.exception;
public class WebConfigDuplicatedException extends Exception {
public WebConfigDuplicatedException(String msg) {
super(msg);
}
}
package cn.how2j.diytomcat.exception;
public class WebConfigDuplicatedException extends Exception {
public WebConfigDuplicatedException(String msg) {
super(msg);
}
}
增值内容，请先登录
自己写一个Tomcat， 几乎使用到了除开框架外的所有Java 技术，如多线程，Socket, J2EE, 反射，Log4j, JSoup, JUnit, Html 等一整套技术栈， 从无到有，循序渐进涵盖全部74个知识点，549个开发步骤, 为竞争高薪资职位加上一个有吸引力的砝码.
增值内容，点击购买
使用爬虫已经被系统记录，请勿使用爬虫，增大封号风险。 如果是误封 ，请联系站长，谢谢
package cn.how2j.diytomcat.catalina;
import cn.how2j.diytomcat.exception.WebConfigDuplicatedException;
import cn.how2j.diytomcat.util.ContextXMLUtil;
import cn.hutool.core.date.DateUtil;
import cn.hutool.core.date.TimeInterval;
import cn.hutool.core.io.FileUtil;
import cn.hutool.core.util.StrUtil;
import cn.hutool.log.LogFactory;
import org.jsoup.Jsoup;
import org.jsoup.nodes.Document;
import org.jsoup.nodes.Element;
import org.jsoup.select.Elements;
import java.io.File;
import java.util.*;
public class Context {
private String path;
private String docBase;
private File contextWebXmlFile;
private Map<String, String> url_servletClassName;
private Map<String, String> url_servletName;
private Map<String, String> servletName_className;
private Map<String, String> className_servletName;
public Context(String path, String docBase) {
this.path = path;
this.docBase = docBase;
this.contextWebXmlFile = new File(docBase, ContextXMLUtil.getWatchedResource());
this.url_servletClassName = new HashMap<>();
this.url_servletName = new HashMap<>();
this.servletName_className = new HashMap<>();
this.className_servletName = new HashMap<>();
deploy();
}
private void deploy() {
TimeInterval timeInterval = DateUtil.timer();
LogFactory.get().info("Deploying web application directory {}", this.docBase);
init();
LogFactory.get().info("Deployment of web application directory {} has finished in {} ms",this.getDocBase(),timeInterval.intervalMs());
}
private void init() {
if (!contextWebXmlFile.exists())
return;
try {
checkDuplicated();
} catch (WebConfigDuplicatedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
return;
}
String xml = FileUtil.readUtf8String(contextWebXmlFile);
Document d = Jsoup.parse(xml);
parseServletMapping(d);
}
private void parseServletMapping(Document d) {
// url_ServletName
Elements mappingurlElements = d.select("servlet-mapping url-pattern");
for (Element mappingurlElement : mappingurlElements) {
String urlPattern = mappingurlElement.text();
String servletName = mappingurlElement.parent().select("servlet-name").first().text();
url_servletName.put(urlPattern, servletName);
}
// servletName_className / className_servletName
Elements servletNameElements = d.select("servlet servlet-name");
for (Element servletNameElement : servletNameElements) {
String servletName = servletNameElement.text();
String servletClass = servletNameElement.parent().select("servlet-class").first().text();
servletName_className.put(servletName, servletClass);
className_servletName.put(servletClass, servletName);
}
// url_servletClassName
Set<String> urls = url_servletName.keySet();
for (String url : urls) {
String servletName = url_servletName.get(url);
String servletClassName = servletName_className.get(servletName);
url_servletClassName.put(url, servletClassName);
}
}
private void checkDuplicated(Document d, String mapping, String desc) throws WebConfigDuplicatedException {
Elements elements = d.select(mapping);
// 判断逻辑是放入一个集合，然后把集合排序之后看两临两个元素是否相同
List<String> contents = new ArrayList<>();
for (Element e : elements) {
contents.add(e.text());
}
Collections.sort(contents);
for (int i = 0; i < contents.size() - 1; i++) {
String contentPre = contents.get(i);
String contentNext = contents.get(i + 1);
if (contentPre.equals(contentNext)) {
throw new WebConfigDuplicatedException(StrUtil.format(desc, contentPre));
}
}
}
private void checkDuplicated() throws WebConfigDuplicatedException {
String xml = FileUtil.readUtf8String(contextWebXmlFile);
Document d = Jsoup.parse(xml);
checkDuplicated(d, "servlet-mapping url-pattern", "servlet url 重复,请保持其唯一性:{} ");
checkDuplicated(d, "servlet servlet-name", "servlet 名称重复,请保持其唯一性:{} ");
checkDuplicated(d, "servlet servlet-class", "servlet 类名重复,请保持其唯一性:{} ");
}
public String getServletClassName(String uri) {
return url_servletClassName.get(uri);
}
public String getPath() {
return path;
}
public void setPath(String path) {
this.path = path;
}
public String getDocBase() {
return docBase;
}
public void setDocBase(String docBase) {
this.docBase = docBase;
}
}
增值内容，请先登录
自己写一个Tomcat， 几乎使用到了除开框架外的所有Java 技术，如多线程，Socket, J2EE, 反射，Log4j, JSoup, JUnit, Html 等一整套技术栈， 从无到有，循序渐进涵盖全部74个知识点，549个开发步骤, 为竞争高薪资职位加上一个有吸引力的砝码.
增值内容，点击购买
使用爬虫已经被系统记录，请勿使用爬虫，增大封号风险。 如果是误封 ，请联系站长，谢谢
增值内容，请先登录
自己写一个Tomcat， 几乎使用到了除开框架外的所有Java 技术，如多线程，Socket, J2EE, 反射，Log4j, JSoup, JUnit, Html 等一整套技术栈， 从无到有，循序渐进涵盖全部74个知识点，549个开发步骤, 为竞争高薪资职位加上一个有吸引力的砝码.
增值内容，点击购买
使用爬虫已经被系统记录，请勿使用爬虫，增大封号风险。 如果是误封 ，请联系站长，谢谢
package cn.how2j.diytomcat.catalina;
import cn.how2j.diytomcat.http.Request;
import cn.how2j.diytomcat.http.Response;
import cn.how2j.diytomcat.util.Constant;
import cn.how2j.diytomcat.util.WebXMLUtil;
import cn.how2j.diytomcat.webappservlet.HelloServlet;
import cn.hutool.core.io.FileUtil;
import cn.hutool.core.thread.ThreadUtil;
import cn.hutool.core.util.ArrayUtil;
import cn.hutool.core.util.ReUtil;
import cn.hutool.core.util.ReflectUtil;
import cn.hutool.core.util.StrUtil;
import cn.hutool.log.LogFactory;
import org.apache.el.util.ReflectionUtil;
import javax.servlet.http.HttpServletRequest;
import java.io.File;
import java.io.IOException;
import java.io.OutputStream;
import java.net.Socket;
public class HttpProcessor {
public void execute(Socket s, Request request, Response response){
try {
String uri = request.getUri();
if(null==uri)
return;
Context context = request.getContext();
String servletClassName = context.getServletClassName(uri);
if(null!=servletClassName){
Object servletObject = ReflectUtil.newInstance(servletClassName);
ReflectUtil.invoke(servletObject, "doGet", request, response);
}
else{
if("/500.html".equals(uri)){
throw new Exception("this is a deliberately created exception");
}
else{
if("/".equals(uri))
uri = WebXMLUtil.getWelcomeFile(request.getContext());
String fileName = StrUtil.removePrefix(uri, "/");
File file = FileUtil.file(context.getDocBase(),fileName);
if(file.exists()){
String extName = FileUtil.extName(file);
String mimeType = WebXMLUtil.getMimeType(extName);
response.setContentType(mimeType);
byte body[] = FileUtil.readBytes(file);
response.setBody(body);
if(fileName.equals("timeConsume.html"))
ThreadUtil.sleep(1000);
}
else{
handle404(s, uri);
return;
}
}
}
handle200(s, response);
} catch (Exception e) {
LogFactory.get().error(e);
handle500(s,e);
}
finally{
try {
if(!s.isClosed())
s.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
private static void handle200(Socket s, Response response) throws IOException {
String contentType = response.getContentType();
String headText = Constant.response_head_202;
headText = StrUtil.format(headText, contentType);
byte[] head = headText.getBytes();
byte[] body = response.getBody();
byte[] responseBytes = new byte[head.length + body.length];
ArrayUtil.copy(head, 0, responseBytes, 0, head.length);
ArrayUtil.copy(body, 0, responseBytes, head.length, body.length);
OutputStream os = s.getOutputStream();
os.write(responseBytes);
}
private void handle404(Socket s, String uri) throws IOException {
OutputStream os = s.getOutputStream();
String responseText = StrUtil.format(Constant.textFormat_404, uri, uri);
responseText = Constant.response_head_404 + responseText;
byte[] responseByte = responseText.getBytes("utf-8");
os.write(responseByte);
}
private void handle500(Socket s, Exception e) {
try {
OutputStream os = s.getOutputStream();
StackTraceElement stes[] = e.getStackTrace();
StringBuffer sb = new StringBuffer();
sb.append(e.toString());
sb.append("\r\n");
for (StackTraceElement ste : stes) {
sb.append("\t");
sb.append(ste.toString());
sb.append("\r\n");
}
String msg = e.getMessage();
if (null != msg && msg.length() > 20)
msg = msg.substring(0, 19);
String text = StrUtil.format(Constant.textFormat_500, msg, e.toString(), sb.toString());
text = Constant.response_head_500 + text;
byte[] responseBytes = text.getBytes("utf-8");
os.write(responseBytes);
} catch (IOException e1) {
e1.printStackTrace();
}
}
}
增值内容，请先登录
自己写一个Tomcat， 几乎使用到了除开框架外的所有Java 技术，如多线程，Socket, J2EE, 反射，Log4j, JSoup, JUnit, Html 等一整套技术栈， 从无到有，循序渐进涵盖全部74个知识点，549个开发步骤, 为竞争高薪资职位加上一个有吸引力的砝码.
增值内容，点击购买
使用爬虫已经被系统记录，请勿使用爬虫，增大封号风险。 如果是误封 ，请联系站长，谢谢
<?xml version="1.0" encoding="UTF-8"?>
<web-app>
<servlet>
<servlet-name>HelloServlet</servlet-name>
<servlet-class>cn.how2j.diytomcat.webappservlet.HelloServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>HelloServlet</servlet-name>
<url-pattern>/hello</url-pattern>
</servlet-mapping>
</web-app>
<?xml version="1.0" encoding="UTF-8"?>
<web-app>
<servlet>
<servlet-name>HelloServlet</servlet-name>
<servlet-class>cn.how2j.diytomcat.webappservlet.HelloServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>HelloServlet</servlet-name>
<url-pattern>/hello</url-pattern>
</servlet-mapping>
</web-app>
增值内容，请先登录
自己写一个Tomcat， 几乎使用到了除开框架外的所有Java 技术，如多线程，Socket, J2EE, 反射，Log4j, JSoup, JUnit, Html 等一整套技术栈， 从无到有，循序渐进涵盖全部74个知识点，549个开发步骤, 为竞争高薪资职位加上一个有吸引力的砝码.
增值内容，点击购买
使用爬虫已经被系统记录，请勿使用爬虫，增大封号风险。 如果是误封 ，请联系站长，谢谢
package cn.how2j.diytomcat.test;
import cn.how2j.diytomcat.util.MiniBrowser;
import cn.hutool.core.date.DateUtil;
import cn.hutool.core.date.TimeInterval;
import cn.hutool.core.util.NetUtil;
import cn.hutool.core.util.StrUtil;
import cn.hutool.core.util.ZipUtil;
import cn.hutool.http.HttpUtil;
import org.junit.Assert;
import org.junit.BeforeClass;
import org.junit.Test;
import sun.net.www.content.text.plain;
import java.io.ByteArrayOutputStream;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
public class TestTomcat {
private static int port = 18080;
private static String ip = "127.0.0.1";
@BeforeClass
public static void beforeClass() {
//所有测试开始前看diy tomcat 是否已经启动了
if(NetUtil.isUsableLocalPort(port)) {
System.err.println("请先启动 位于端口: " +port+ " 的diy tomcat，否则无法进行单元测试");
System.exit(1);
}
else {
System.out.println("检测到 diy tomcat已经启动，开始进行单元测试");
}
}
@Test
public void testHelloTomcat() {
String html = getContentString("/");
Assert.assertEquals(html,"Hello DIY Tomcat from how2j.cn");
}
@Test
public void testTimeConsumeHtml() throws InterruptedException {
ThreadPoolExecutor threadPool = new ThreadPoolExecutor(20, 20, 60, TimeUnit.SECONDS,
new LinkedBlockingQueue<Runnable>(10));
TimeInterval timeInterval = DateUtil.timer();
for(int i = 0; i<3; i++){
threadPool.execute(new Runnable(){
public void run() {
getContentString("/timeConsume.html");
}
});
}
threadPool.shutdown();
threadPool.awaitTermination(1, TimeUnit.HOURS);
long duration = timeInterval.intervalMs();
Assert.assertTrue(duration < 3000);
}
@Test
public void testaIndex() {
String html = getContentString("/a");
Assert.assertEquals(html,"Hello DIY Tomcat from index.html@a");
}
@Test
public void testbIndex() {
String html = getContentString("/b/");
Assert.assertEquals(html,"Hello DIY Tomcat from index.html@b");
}
@Test
public void test404() {
String response = getHttpString("/not_exist.html");
containAssert(response, "HTTP/1.1 404 Not Found");
}
@Test
public void test500() {
String response = getHttpString("/500.html");
containAssert(response, "HTTP/1.1 500 Internal Server Error");
}
@Test
public void testaTxt() {
String response = getHttpString("/a.txt");
containAssert(response, "Content-Type: text/plain");
}
@Test
public void testPNG() {
byte[] bytes = getContentBytes("/logo.png");
int pngFileLength = 1672;
Assert.assertEquals(pngFileLength, bytes.length);
}
@Test
public void testPDF() {
byte[] bytes = getContentBytes("/etf.pdf");
int pngFileLength = 3590775;
Assert.assertEquals(pngFileLength, bytes.length);
}
@Test
public void testhello() {
String html = getContentString("/j2ee/hello");
Assert.assertEquals(html,"Hello DIY Tomcat from HelloServlet");
}
private byte[] getContentBytes(String uri) {
return getContentBytes(uri,false);
}
private byte[] getContentBytes(String uri,boolean gzip) {
String url = StrUtil.format("http://{}:{}{}", ip,port,uri);
return MiniBrowser.getContentBytes(url,false);
}
private String getContentString(String uri) {
String url = StrUtil.format("http://{}:{}{}", ip,port,uri);
String content = MiniBrowser.getContentString(url);
return content;
}
private String getHttpString(String uri) {
String url = StrUtil.format("http://{}:{}{}", ip,port,uri);
String http = MiniBrowser.getHttpString(url);
return http;
}
private void containAssert(String html, String string) {
boolean match = StrUtil.containsAny(html, string);
Assert.assertTrue(match);
}
}
增值内容，请先登录
自己写一个Tomcat， 几乎使用到了除开框架外的所有Java 技术，如多线程，Socket, J2EE, 反射，Log4j, JSoup, JUnit, Html 等一整套技术栈， 从无到有，循序渐进涵盖全部74个知识点，549个开发步骤, 为竞争高薪资职位加上一个有吸引力的砝码.
增值内容，点击购买
使用爬虫已经被系统记录，请勿使用爬虫，增大封号风险。 如果是误封 ，请联系站长，谢谢
HOW2J公众号，关注后实时获知最新的教程和优惠活动，谢谢。
问答区域
2022-04-30
无法通过反射获取类
回答已经提交成功，正在审核。 请于 我的回答 处查看回答记录，谢谢
2020-08-19
检验配置文件中映射重复可以用Set来做啊
1 个答案
how2j 跳转到问题位置 答案时间：2020-08-20 实现方式有多种，并非只有一种。
何况，Set 只是保证容器内的数据没有重复，并不能在重复的时候抛出异常，依然要进行更多代码的开发。
回答已经提交成功，正在审核。 请于 我的回答 处查看回答记录，谢谢
提问之前请登陆
提问已经提交成功，正在审核。 请于 我的提问 处查看提问记录，谢谢
|
|||||||||||||||||
