1、搭建框架

  1. 我们只是简单模拟，框架简单分三个模块

  1. a,服务器端server包

  1. b,servlet,根据不同的请求url,利用反射生产对应的servlet

  1. c,IO工具包，用来关闭IO流

  1.     d,编写web.xml
  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <web-app>
  3. 	<servlet>
  4. 		<servlet-name>login</servlet-name>
  5. 		<servlet-class>com.xzlf.servlet.LoginServlet</servlet-class>
  6. 	</servlet>
  7. 	<servlet>
  8. 		<servlet-name>register</servlet-name>
  9. 		<servlet-class>com.xzlf.servlet.RegisterServlet</servlet-class>
  10. 	</servlet>
  11. 	<servlet-mapping>
  12. 		<servlet-name>login</servlet-name>
  13. 		<url-pattern>/login</url-pattern>
  14. 		<url-pattern>/log</url-pattern>
  15. 	</servlet-mapping>
  16. 	<servlet-mapping>
  17. 		<servlet-name>register</servlet-name>
  18. 		<url-pattern>/register</url-pattern>
  19. 		<url-pattern>/reg</url-pattern>
  20. 		<url-pattern>/r</url-pattern>
  21. 	</servlet-mapping>
  22. </web-app>
  1. e,写一个简单的html用于测试
  1. <!DOCTYPE html>
  2. <html>
  3. <head>
  4. <meta charset="UTF-8">
  5. <title>登录</title>
  6. </head>
  7. <body>
  8. 	<form action="http://localhost:8888/log" method="get">
  9. 		<p>
  10. 			用户名:<input type="text" name="uname" id="uname" />
  11. 		</p>
  12. 		<p>
  13. 			密码:<input type="password" name="pwd" id="pwd" />
  14. 		</p>
  15. 		<p>
  16. 			<input type="submit" value="登录" />
  17. 		</p>
  18. 	</form>
  19. </body>
  20. </html>
  1.     f, IO工具包比比较简单，先写了：
  1. package com.xzlf.util;
  3. import java.io.Closeable;
  4. import java.io.IOException;
  6. /**
  7.  * 关闭流
  8.  * @author xzlf
  9.  *
  10.  */
  11. public class IOUtil {
  12. 	public static void closeAll(Closeable...closeables) {
  13. 		for (Closeable close : closeables) {
  14. 			if(close != null) {
  15. 				try {
  16. 					close.close();
  17. 				} catch (IOException e) {
  18. 					e.printStackTrace();
  19. 				}
  20. 			}
  22. 		}
  23. 	}
  24. }

2、编写xml文件以及对xml解析以及数据存储程序

  1. a,编写存放xml文件中servlet-name 和 servlet-class 的javabean 对象Entity
  1. package com.xzlf.server;
  3. /**
  4.  * 映射servlet-name 和 servlet-class
  5.  * @author xzlf
  6.  *
  7.  */
  8. public class Entity {
  9. 	// servlet-name
  10. 	private String name;
  12. 	// servlet -class
  13. 	private String clazz;
  15. 	public Entity() {
  16. 		// TODO Auto-generated constructor stub
  17. 	}
  19. 	public Entity(String name, String clazz) {
  20. 		super();
  21. 		this.name = name;
  22. 		this.clazz = clazz;
  23. 	}
  25. 	public String getName() {
  26. 		return name;
  27. 	}
  29. 	public void setName(String name) {
  30. 		this.name = name;
  31. 	}
  33. 	public String getClazz() {
  34. 		return clazz;
  35. 	}
  37. 	public void setClazz(String clazz) {
  38. 		this.clazz = clazz;
  39. 	}
  41. }
  1. b,编写存放xml文件中servlet-name 和 url-pattern 的javabean 对象Mapping
  1. package com.xzlf.server;
  3. import java.util.ArrayList;
  4. import java.util.List;
  6. /**
  7.  * 映射 servlet-name  和 url-pattern
  8.  * @author xzlf
  9.  *
  10.  */
  11. public class Mapping {
  13. 	// servlet-name
  14. 	private String name;
  16. 	// url-pattern
  17. 	private List<String> urlList;
  19. 	public Mapping() {
  20. 		this.urlList = new ArrayList<String>();
  21. 	}
  23. 	public Mapping(String name, List<String> urlList) {
  24. 		this();
  25. 		this.name = name;
  26. 		this.urlList = urlList;
  27. 	}
  29. 	public String getName() {
  30. 		return name;
  31. 	}
  33. 	public void setName(String name) {
  34. 		this.name = name;
  35. 	}
  37. 	public List<String> getUrlList() {
  38. 		return urlList;
  39. 	}
  41. 	public void setUrlList(List<String> urlList) {
  42. 		this.urlList = urlList;
  43. 	}
  45. }
  1. c,编写解析xml文件（使用Dom4j）的程序
  1. package com.xzlf.server;
  3. import java.io.File;
  4. import java.util.ArrayList;
  5. import java.util.Iterator;
  6. import java.util.List;
  8. import org.dom4j.Document;
  9. import org.dom4j.DocumentException;
  10. import org.dom4j.Element;
  11. import org.dom4j.io.SAXReader;
  13. /**
  14.  * 解析xml
  15.  * @author xzlf
  16.  *
  17.  */
  18. public class WebDom4j {
  19. 	// 存储Entity
  20. 	private List<Entity> entityList;
  22. 	// 存储Mapping
  23. 	private List<Mapping> mappingList;
  25. 	public WebDom4j() {
  26. 		this.entityList = new ArrayList<Entity>();
  27. 		this.mappingList = new ArrayList<Mapping>();
  28. 	}
  30. 	public WebDom4j(List<Entity> entityList, List<Mapping> mappingList) {
  31. 		this();
  32. 		this.entityList = entityList;
  33. 		this.mappingList = mappingList;
  34. 	}
  36. 	public List<Entity> getEntityList() {
  37. 		return entityList;
  38. 	}
  40. 	public void setEntityList(List<Entity> entityList) {
  41. 		this.entityList = entityList;
  42. 	}
  44. 	public List<Mapping> getMappingList() {
  45. 		return mappingList;
  46. 	}
  48. 	public void setMappingList(List<Mapping> mappingList) {
  49. 		this.mappingList = mappingList;
  50. 	}
  52. 	public Document getDocument() {
  53. 		Document doc = null;
  54. 		try {
  55. 			// 1、穿件SAXReader 对象
  56. 			SAXReader reader = new SAXReader();
  57. 			// 2、调用 read() 方法
  58. 			doc = reader.read(new File("src/WEB_INFO/webxml.xml"));
  59. 		} catch (DocumentException e) {
  60. 			e.printStackTrace();
  61. 		}
  62. 		return doc;
  63. 	}
  65. 	public void parse(Document doc) {
  66. 		// 1、获取根元素
  67. 		Element rootElement = doc.getRootElement();
  68. 		// 2、获取servlet 子元素
  69. 		for(Iterator<Element> elementIterator = rootElement.elementIterator("servlet");
  70. 				elementIterator.hasNext();) {
  71. 			Element ele = elementIterator.next();
  72. 			Entity entity = new Entity();
  73. 			for (Iterator<Element> eleIterator = ele.elementIterator(); eleIterator.hasNext();) {
  74. 				Element e = eleIterator.next();
  75. 				if("servlet-name".equals(e.getName())) {
  76. 					entity.setName(e.getText());
  77. 				}else if("servlet-class".equals(e.getName())) {
  78. 					entity.setClazz(e.getText());
  79. 				}
  80. 			}
  81. 			this.entityList.add(entity);
  82. 		}
  83. 		// 3、获取servlet-mapping 子元素
  84. 		for(Iterator<Element> elementIterator = rootElement.elementIterator("servlet-mapping");
  85. 				elementIterator.hasNext();) {
  86. 			Element ele = elementIterator.next();
  87. 			Mapping mapping = new Mapping();
  88. 			for (Iterator<Element> eleIterator = ele.elementIterator(); eleIterator.hasNext();) {
  89. 				Element e = eleIterator.next();
  90. 				if("servlet-name".equals(e.getName())) {
  91. 					mapping.setName(e.getText());
  92. 				}else if("url-pattern".equals(e.getName())) {
  93. 					mapping.getUrlList().add(e.getText());
  94. 				}
  95. 			}
  96. 			this.mappingList.add(mapping);
  97. 		}
  98. 	}
  100. 	/* 测试
  101. 	 * public static void main(String[] args) {
  102. 		WebDom4j web = new WebDom4j();
  103. 		web.parse(web.getDocument());
  104. 		List<Entity> entityList2 = web.getEntityList();
  105. 		System.out.println(entityList2.size());
  106. 		for (Entity entity : entityList2) {
  107. 			System.out.println(entity.getName() + "--" + entity.getClazz());
  108. 		}
  109. 		System.out.println("============================");
  110. 		List<Mapping> mappingList2 = web.getMappingList();
  111. 		System.out.println(mappingList2.size());
  112. 		for (Mapping mapping : mappingList2) {
  113. 			for (String url : mapping.getUrlList()) {
  114. 				System.out.println(mapping.getName() + "-->" + url);
  115. 			}
  116. 			System.out.println("------------------------");
  117. 		}
  118. 	}*/
  119. }
  1. d,封装serlvet 和mapping
  1. package com.xzlf.server;
  3. import java.util.HashMap;
  4. import java.util.Map;
  6. /**
  7.  * Servlet 上下文 ，就是一个容器
  8.  * 映射 Mapping 和 Entity
  9.  * url-pattern --> servlet-class
  10.  * @author xzlf
  11.  *
  12.  */
  13. public class ServletContext {
  14. 	// key:sevlet-name value:servlet-class
  15. 	private Map<String, String> servlet;
  17. 	// key:url-pattern value:servlet-name
  18. 	private Map<String, String> mapping;
  20. 	public ServletContext() {
  21. 		this.servlet = new HashMap<String, String>();
  22. 		this.mapping = new HashMap<String, String>();
  23. 	}
  25. 	public ServletContext(Map<String, String> servlet, Map<String, String> mapping) {
  26. 		this.servlet = servlet;
  27. 		this.mapping = mapping;
  28. 	}
  30. 	public Map<String, String> getServlet() {
  31. 		return servlet;
  32. 	}
  34. 	public void setServlet(Map<String, String> servlet) {
  35. 		this.servlet = servlet;
  36. 	}
  38. 	public Map<String, String> getMapping() {
  39. 		return mapping;
  40. 	}
  42. 	public void setMapping(Map<String, String> mapping) {
  43. 		this.mapping = mapping;
  44. 	}
  46. }
  1. e，处理Entity 和 Maping 找出url 和 servlet-class 的映射
  1. package com.xzlf.server;
  3. import java.util.List;
  4. import java.util.Map;
  6. import com.xzlf.servlet.Servlet;
  8. /**
  9.  * Web应用程序
  10.  * @author xzlf
  11.  *
  12.  */
  13. public class WebApp {
  14. 	private static ServletContext context;
  15. 	static {
  16. 		context = new ServletContext();
  17. 		// 获取对应的map关系
  18. 		Map<String, String> servlet = context.getServlet();
  19. 		Map<String, String> mapping = context.getMapping();
  20. 		// 创建xml解析
  21. 		WebDom4j web = new WebDom4j();
  22. 		web.parse(web.getDocument());
  23. 		// 获取解析xml 之后的List集合
  24. 		List<Entity> entityList = web.getEntityList();
  25. 		List<Mapping> mappingList = web.getMappingList();
  27. 		// 将List集合中的数据存储到Map中
  28. 		for(Entity entity : entityList) {
  29. 			servlet.put(entity.getName(), entity.getClazz());
  30. 		}
  32. 		for (Mapping mapp : mappingList) {
  33. 			for (String url : mapp.getUrlList()) {
  34. 				mapping.put(url, mapp.getName());
  35. 			}
  36. 		}
  38. 	}
  40. 	/**
  41. 	 * 根据不同的url创建不同的servlet对象
  42. 	 * @param url
  43. 	 * @return
  44. 	 */
  45. 	public static Servlet getServlet(String url) {
  46. 		if(url == null || url.trim().equals("")) {
  47. 			return null;
  48. 		}
  50. 		try {
  51. 			String servletName = context.getMapping().get(url);
  52. 			String servletClazz = context.getServlet().get(servletName);
  53. //			System.out.println(servletName + "--" + servletClazz);
  54. 			Class<?> clazz = Class.forName(servletClazz);
  55. 			Object servlet = clazz.newInstance();
  56. 			return (Servlet) servlet;
  57. 		} catch (ClassNotFoundException e) {
  58. 			e.printStackTrace();
  59. 		} catch (InstantiationException e) {
  60. 			e.printStackTrace();
  61. 		} catch (IllegalAccessException e) {
  62. 			e.printStackTrace();
  63. 		}
  64. 		return null;
  65. 	}
  66. 	/*测试
  67. 	public static void main(String[] args) {
  68. 		System.out.println(getServlet("/log"));
  69. 		System.out.println(getServlet("/reg"));
  70. 	}
  71. 	*/
  72. }

3、封装请求数据request：包括请求的url，请求参数

  1. package com.xzlf.server;
  3. import java.io.BufferedReader;
  4. import java.io.IOException;
  5. import java.io.InputStream;
  6. import java.io.InputStreamReader;
  7. import java.io.UnsupportedEncodingException;
  8. import java.net.URLDecoder;
  9. import java.util.ArrayList;
  10. import java.util.Arrays;
  11. import java.util.HashMap;
  12. import java.util.List;
  13. import java.util.Map;
  15. /**
  16.  * 封装请求
  17.  * @author xzlf
  18.  *
  19.  */
  20. public class Request {
  21. 	private InputStream is;
  22. 	private String requestInfo;
  23. 	private String method;
  24. 	private String url;
  25. 	private Map<String, List<String>> parameterValues;
  26. 	private static final String BLANK = " ";
  27. 	private static final String CRLF = "\r\n";
  29. 	public Request() {
  30. 		this.parameterValues = new HashMap<String, List<String>>();
  31. 	}
  33. 	public Request(InputStream is) {
  34. 		this();
  35. 		this.is = is;
  36. 		BufferedReader read = null;
  37. 		char[] buf = new char[20480];
  38. 		int len;
  39. 		try {
  40. 			read = new BufferedReader(new InputStreamReader(is, "utf8"));
  41. 			if ((len = read.read(buf)) != -1) {
  42. 				requestInfo = new String(buf, 0, len);
  43. 			}
  44. 		} catch (IOException e) {
  45. 			requestInfo = "";
  46. 			return;
  47. 		}
  48. 		this.parseRequestInfo();
  49. 	}
  51. 	private void parseRequestInfo() {
  52. 		if(this.requestInfo.equals("")) {
  53. 			return;
  54. 		}
  55. 		int index = this.requestInfo.indexOf('/');
  56. 		this.method = this.requestInfo.substring(0,index - 1).toLowerCase();
  57. 		int end = this.requestInfo.indexOf("HTTP/1.1") - 1;
  58. 		String urlStr = this.requestInfo.substring(index,end);
  59. 		int paramIndex;// 请求参数拆分位置
  60. 		String parameterStr = "";
  61. 		if ("get".equals(method)) {
  62. 			if (urlStr.contains("?")) {
  63. 				paramIndex = urlStr.indexOf('?');
  64. 				this.url = urlStr.substring(0, paramIndex);
  65. 				parameterStr = urlStr.substring(paramIndex + 1);
  66. 			}else {
  67. 				parameterStr = "";
  68. 			}
  69. 		}else {
  70. 			this.url = urlStr;
  71. 			paramIndex = this.requestInfo.lastIndexOf(CRLF);
  72. 			parameterStr = this.requestInfo.substring(paramIndex).trim();
  73. 		}
  74. 		if(parameterStr != null && !"".equals(parameterStr)) {
  75. 			String[] paramArr = parameterStr.split("&");
  76. 			for (String string : paramArr) {
  77. 				String[]  paramKV = string.split("=");
  78. 				paramKV = Arrays.copyOf(paramKV, 2);
  79. 				convertMap(paramKV);
  80. 			}
  81. 		}
  82. //		System.out.println(parameterStr);
  84. 	}
  86. 	private void convertMap(String[] paramKV) {
  87. 		String k = paramKV[0];
  88. 		String v = null;
  89. 		try {
  90. 			v = paramKV[1] == null ? null : new URLDecoder().decode(paramKV[1], "utf8");
  91. 		} catch (UnsupportedEncodingException e) {
  92. 			e.printStackTrace();
  93. 		}
  94. 		if(!this.parameterValues.containsKey(k)) {
  95. 			parameterValues.put(k, new ArrayList<String>());
  96. 		}
  97. 		this.parameterValues.get(k).add(v);
  98. 	}
  100. 	// 根据表单提交的内容获取多个值
  101. 	public String[] getParameterValues(String name) {
  102. 		List<String> list = this.parameterValues.get(name);
  103. 		return list == null ? null : list.toArray(new String[0]);
  104. 	}
  106. 	// 根据表单提交的内容获取一个值
  107. 	public String getParameter(String name) {
  108. 		String[] values = this.getParameterValues(name);
  109. 		return values == null ? null : values[0];
  110. 	}
  112. 	public String getMethod() {
  113. 		return method;
  114. 	}
  116. 	public String getUrl() {
  117. 		return url;
  118. 	}
  120. 	public Map<String, List<String>> getParameterValues() {
  121. 		return parameterValues;
  122. 	}
  124. }

4、封装响应数据reponse：包括响应头和响应正文

  1. package com.xzlf.server;
  3. import java.io.BufferedWriter;
  4. import java.io.IOException;
  5. import java.io.OutputStream;
  6. import java.io.OutputStreamWriter;
  7. import java.io.UnsupportedEncodingException;
  9. import com.xzlf.util.IOUtil;
  11. /**
  12.  * 封装响应
  13.  * @author xzlf
  14.  *
  15.  */
  16. public class Response {
  17. 	private StringBuffer headInfo;
  18. 	private  StringBuffer content;
  19. 	private int length;
  21. 	private BufferedWriter bw;
  23. 	private static final String BLANK = " ";
  24. 	private static final String CRLF = "\r\n";
  25. 	public Response() {
  26. 		headInfo = new StringBuffer();
  27. 		content = new StringBuffer();
  28. 	}
  30. 	public Response(OutputStream os) {
  31. 		this();
  32. 		try {
  33. 			bw = new BufferedWriter(new OutputStreamWriter(os, "utf-8"));
  34. 		} catch (UnsupportedEncodingException e) {
  35. 			e.printStackTrace();
  36. 		}
  37. 	}
  39. 	public Response print(String info) {
  40. 		content.append(info);
  41. 		try {
  42. 			length += info.getBytes("utf-8").length;
  43. 		} catch (UnsupportedEncodingException e) {
  44. 			e.printStackTrace();
  45. 		}
  46. 		return this;
  47. 	}
  49. 	public Response println(String info) {
  50. 		content.append(info);
  51. 		content.append(CRLF);
  52. 		try {
  53. 			length += (info + CRLF).getBytes("utf-8").length;
  54. 		} catch (UnsupportedEncodingException e) {
  55. 			e.printStackTrace();
  56. 		}
  57. 		return this;
  58. 	}
  60. 	public void creatHeadInfo(int code) {
  61. 		headInfo.append("HTTP/1.1").append(BLANK).append(code).append(BLANK);
  62. 		switch(code) {
  63. 		case 200:
  64. 			headInfo.append("OK");
  65. 			break;
  66. 		case 404:
  67. 			headInfo.append("NOT FOUND");
  68. 			break;
  69. 		default:
  70. 			headInfo.append("SERVER ERROR");
  71. 		}
  72. 		headInfo.append(CRLF);
  73. 		headInfo.append("Content-Type: text/html;charset=utf-8").append(CRLF);
  74. 		headInfo.append("Content-Length:").append(length).append(CRLF);
  75. 		headInfo.append(CRLF);
  76. 	}
  78. 	public void pushToClient(int code) {
  79. 		if(headInfo == null) {
  80. 			code = 500;
  81. 		}
  83. 		this.creatHeadInfo(code);
  84. 		try {
  85. 			bw.write(headInfo.toString());
  86. 			bw.write(content.toString());
  87. 			bw.flush();
  88. 		} catch (IOException e) {
  89. 			e.printStackTrace();
  90. 		}
  91. 		close();
  92. 	}
  94. 	public void close() {
  95. 		IOUtil.closeAll(bw);
  96. 	}
  97. }

5、编写servelt 处理请求：

  1. package com.xzlf.servlet;
  3. import com.xzlf.server.Request;
  4. import com.xzlf.server.Response;
  6. /**
  7.  * 所有servlet 父类
  8.  * @author xzlf
  9.  *
  10.  */
  11. public abstract class Servlet {
  12. 	public void service(Request request, Response response) throws Exception {
  13. 		this.doGet(request, response);
  14. 		this.doPost(request, response);
  15. 	}
  17. 	public abstract void doPost(Request request, Response response) throws Exception;
  19. 	public abstract void doGet(Request request, Response response) throws Exception;
  20. }
  1. package com.xzlf.servlet;
  3. import com.xzlf.server.Request;
  4. import com.xzlf.server.Response;
  6. public class LoginServlet extends Servlet {
  8. 	@Override
  9. 	public void doPost(Request request, Response response) throws Exception {
  11. 	}
  13. 	@Override
  14. 	public void doGet(Request request, Response response) throws Exception {
  15. 		String uname = request.getParameter("uname");
  16. 		String pwd = request.getParameter("pwd");
  17. //		System.out.println(uname+"--" + pwd);
  18. 		if(login(uname, pwd)) {
  19. 			response.print(uname + "：登录成功");
  20. 		}else {
  21. 			response.print(uname + " 登录失败，账号或密码错误");
  22. 		}
  24. 	}
  26. 	private boolean login(String uname, String pwd) {
  27. 		if("张三".equals(uname) && "123".equals(pwd)) {
  28. 			return true;
  29. 		}
  30. 		return false;
  31. 	}
  32. }
  1. package com.xzlf.servlet;
  3. import com.xzlf.server.Request;
  4. import com.xzlf.server.Response;
  6. public class RegisterServlet extends Servlet {
  8. 	@Override
  9. 	public void doPost(Request request, Response response) throws Exception {
  10. 		// TODO Auto-generated method stub
  12. 	}
  14. 	@Override
  15. 	public void doGet(Request request, Response response) throws Exception {
  16. 		// TODO Auto-generated method stub
  18. 	}
  20. }

6、加入DIspatcher分发器，开启多线程

  1. package com.xzlf.server;
  3. import java.io.IOException;
  4. import java.net.Socket;
  6. import com.xzlf.servlet.Servlet;
  7. import com.xzlf.util.IOUtil;
  9. /**
  10.  * 请求响应分发器
  11.  * @author xzlf
  12.  *
  13.  */
  14. public class Dispatcher implements Runnable{
  15. 	private Socket client;
  16. 	private Request req;
  17. 	private Response rep;
  18. 	int code = 200;
  19. 	public Dispatcher(Socket client) {
  20. 		this.client = client;
  21. 		try {
  22. 			req = new Request(this.client.getInputStream());
  23. 			rep = new Response(this.client.getOutputStream());
  24. 		} catch (IOException e) {
  25. 			e.printStackTrace();
  26. 		}
  27. 	}
  29. 	@Override
  30. 	public void run() {
  31. 		String url = req.getUrl();
  32. 		System.out.println(url);
  33. 		// 根据不同的url 创建不同的servlet对象
  34. 		Servlet servlet = WebApp.getServlet(url);
  35. 		if(servlet == null) {
  36. 			code = 404;
  37. 		}else {
  38. 			try {
  39. 				servlet.service(req, rep);
  40. 			} catch (Exception e) {
  41. 				code = 500;
  42. 			}
  43. 		}
  45. 		rep.pushToClient(code);
  46. 		IOUtil.closeAll(client);
  47. 	}
  48. }

7、编写服务器端

  1. package com.xzlf.server;
  3. import java.io.IOException;
  4. import java.net.ServerSocket;
  5. import java.net.Socket;
  7. import com.xzlf.util.IOUtil;
  9. /**
  10.  * 启动服务
  11.  * @author xzlf
  12.  *
  13.  */
  14. public class Server {
  15. 	private ServerSocket server;
  16. 	private boolean isRuning;
  17. 	private void start(int port) {
  18. 		isRuning = true;
  19. 		try {
  20. 			server = new ServerSocket(port);
  21. 			recive();
  22. 		} catch (IOException e) {
  23. 			isRuning = false;
  24. 		}
  25. 	}
  27. 	private void recive() {
  28. 		try {
  30. 			while (isRuning) {
  31. 				Socket client = server.accept();
  32. 				Dispatcher dispatcher = new Dispatcher(client);
  33. 				new Thread(dispatcher).start();
  34. 			}
  36. 		} catch (IOException e) {
  37. 			isRuning = false;
  38. 		}
  39. 	}
  41. 	private void stop() {
  42. 		isRuning = false;
  43. 		IOUtil.closeAll(server);
  44. 	}
  46. 	public static void main(String[] args) {
  47. 		Server s = new Server();
  48. 		s.start(8888);
  49. 	}
  51. }

8、进行页面测试

9、简单写个多线程并发进行压测

  1. package com.xzlf.csdnUtil;
  3. import java.io.BufferedReader;
  4. import java.io.InputStreamReader;
  5. import java.net.URL;
  7. /**
  8.  * 对手写服务器进行压测
  9.  * @author xzlf
  10.  *
  11.  */
  12. public class TestMyServer {
  13. 	public static void main(String[] args) {
  14. 		String url = "http://localhost:8888/log?";
  15. 		for (int i = 0; i < 100; i++) {
  16. 			new Thread(new RunThread(url, "张三" + i, "123")).start();
  17. 			new Thread(new RunThread(url, "张三", "123")).start();
  18. 			try {
  19. 				Thread.sleep(200);
  20. 			} catch (InterruptedException e) {
  21. 				// TODO Auto-generated catch block
  22. 				e.printStackTrace();
  23. 			}
  24. 		}
  26. 	}
  28. 	public static void longin(String url, String uname, String pwd) {
  30. 		BufferedReader br = null;
  31. 		try {
  32. 			String loginUrl = url + "uname=" + uname + "&pwd=" + pwd;
  33. 			URL login = new URL(loginUrl);
  34. 			br = new BufferedReader(new InputStreamReader(login.openStream(), "utf-8"));
  35. 			char[] buf = new char[1024];
  36. 			int len = br.read(buf);
  37. 			System.out.println(new String(buf, 0, len));
  38. 		} catch (Exception e) {
  39. 			e.printStackTrace();
  40. 		}
  41. 	}
  43. 	// 为了直接调用请求方法 用下静态内部类
  44. 	static class RunThread implements Runnable {
  45. 		String url;
  46. 		String uname;
  47. 		String pwd;
  49. 		public RunThread(String url, String uname, String pwd) {
  50. 			super();
  51. 			this.url = url;
  52. 			this.uname = uname;
  53. 			this.pwd = pwd;
  54. 		}
  56. 		@Override
  57. 		public void run() {
  58. 			TestMyServer.longin(url, uname, pwd);
  59. 		}
  61. 	}
  62. }

用的电脑还算比较新 没啥压力。

不使用tomcat,仅适用javaSE手写服务器--模拟登陆的更多相关文章

  1. JavaSE 手写 Web 服务器（二）

    原文地址:JavaSE 手写 Web 服务器(二) 博客地址:http://www.extlight.com 一.背景 在上一篇文章 <JavaSE 手写 Web 服务器(一)> 中介绍了 ...

  2. JavaSE 手写 Web 服务器（一）

    原文地址:JavaSE 手写 Web 服务器(一) 博客地址:http://www.extlight.com 一.背景 某日,在 Java 技术群中看到网友讨论 tomcat 容器相关内容,然后想到自 ...

  3. java24 手写服务器最终版本

    手写服务器最终版本; <?xml version="1.0" encoding="UTF-8"?> <web-app> <serv ...

  4. 通过手写服务器的方式，立体学习Http

    前言 Http我们都已经耳熟能详了,而关于Http学习的文章网上有很多,各个知识点的讲解也可说是深入浅出.然而,学习过后,我们对Http还是一知半解.问题出在了哪? Http是一个客户机与服务器之间的 ...

  5. 3.1 spring5源码系列--循环依赖 之 手写代码模拟spring循环依赖

    本次博客的目标 1. 手写spring循环依赖的整个过程 2. spring怎么解决循环依赖 3. 为什么要二级缓存和三级缓存 4. spring有没有解决构造函数的循环依赖 5. spring有没有 ...

  6. 前端面试手写代码——模拟实现new运算符

    目录 1 new 运算符简介 2 new 究竟干了什么事 3 模拟实现 new 运算符 4 补充 预备知识: 了解原型和原型链 了解this绑定 1 new 运算符简介 MDN文档:new 运算符创建 ...

  7. MyTomcat(手写服务器)

    Tomcat 是非常流行的 Web Server,它还是一个满足 Servlet 规范的容器.那么想一想,Tomcat 和我们的 Web 应用是什么关系? 从感性上来说,我们一般需要把 Web 应用打 ...

  8. 手写一个模拟的ReentrantLock

    package cn.daheww.demo.juc.reentrylock; import sun.misc.Unsafe; import java.lang.reflect.Field; impo ...

  9. Java修炼——手写服务器项目

    项目工程总览: 1.Dispatcher类(一个请求与响应就是一个Dispatcher) package com.bjsxt.server; import java.io.IOException; i ...

随机推荐

  1. Math对象常用方法介绍

     <script>         /* 001-Math.abs()  绝对值 */         console.log(Math.abs(123), Math.abs(-998), ...

  2. iOS 缩小 ipa 大小

    一.爱奇艺 爱奇艺移动应用优化之路:如何让崩溃率小于千分之二 iOS8 对于 App 的 text 段有 60MB 的限制: 超过 200MB 的 App 需要连接 WIFI 下载(之前是 150MB ...

  3. [vijos1304]回文数<模拟>

    题目链接:https://vijos.org/p/1304 好久没写博客了,最近一直打不出题,感觉自己是废了,今天做了一道模拟水题,但还是半天没过,后来才发现是忘记考虐10以上的进制是带有字母的,然后 ...

  4. 实验七 MySQL语言结构

    实验七 MySQL语言结构 一.  实验内容: 1. 常量的使用 2. 变量的使用 3. 运算符的使用 4. 系统函数的使用 二.  实验项目:员工管理数据库 用于企业管理的员工管理数据库,数据库名为 ...

  5. Docker基础修炼1--Docker简介及快速入门体验

    本文作为Docker基础系列第一篇文章,将详细阐述和分析三个问题:Docker是什么?为什么要用Docker?如何快速掌握Docker技术? 本系列文章中Docker的用法演示是基于CentOS7进行 ...

  6. XXE白盒审计 PHP

    XXE与XML注入的区别 https://www.cnblogs.com/websecurity-study/p/11348913.html XXE又分为内部实体和外部实体.我简单区分为内部实体就是自 ...

  7. CentOS 6.5系统实现NFS文件共享

    一台Linux server ip 192.168.1.254,一台Linux client ip 192.168.1.100操作系统:CentOS 6.5需求描述:1:将/root 共享给192.1 ...

  8. es--es分词的一些分析技巧

    查看某个字段的分词结果 POST /index/tyhpe/id/_termvectors?fields=fields_name 例如:http://localhost:9200/prod_membe ...

  9. LInux文件管理篇，权限管理

    一: chgrp 改变文件所属用户组 chown 改变文件所有者 注意: 1.使用格式 chgrp/chown     user      file eg: chgrp lanyue permissi ...

  10. Java Array 常见报错ArrayIndexOutOfBoundsException NullPointerException

    本文介绍array报错, 数组索引越界异常: ArrayIndexOutOfBoundsException, 空指针:NullPointerException package myArray; /* ...