- servlet容器的职责
1，当第一次调用servlet的时候，加载该servlet类并调用servlet的init方法，只有一次，
2，对于每次请求，都要new出一个request请求和response相应实例，
3，调用servlet的service方法，同时传递ServletRequest和ServletResponse对象，
4，当servlet类被关闭的时候，调用servlet的destroy方法写在servlet类。
现在我自己模拟实现了一个最简单的tomcat，除了上面的第1点和第4点，基本的功能还是实现了，代码如下：
package linkin;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;
public class HttpServer1
{
/**
* WEB_ROOT is the directory where our HTML and other files reside. For this
* package, WEB_ROOT is the "webroot" directory under the working directory.
* The working directory is the location in the file system from where the
* java command was invoked.
*/
// shutdown command
private static final String SHUTDOWN_COMMAND = "/SHUTDOWN";
// the shutdown command received
private boolean shutdown = false;
public static void main(String[] args)
{
HttpServer1 server = new HttpServer1();
server.await();
}
public void await()
{
ServerSocket serverSocket = null;
int port = 8080;
try
{
serverSocket = new ServerSocket(port, 1, InetAddress.getByName("127.0.0.1"));
}
catch (IOException e)
{
e.printStackTrace();
System.exit(1);
}
// Loop waiting for a request
while (!shutdown)
{
Socket socket = null;
InputStream input = null;
OutputStream output = null;
try
{
socket = serverSocket.accept();
input = socket.getInputStream();
output = socket.getOutputStream();
// create Request object and parse
Request request = new Request(input);
request.parse();
// create Response object
Response response = new Response(output);
response.setRequest(request);
// check if this is a request for a servlet or
// a static resource
// a request for a servlet begins with "/servlet/"
if (request.getUri().startsWith("/servlet/"))
{
ServletProcessor1 processor = new ServletProcessor1();
processor.process(request, response);
}
else
{
StaticResourceProcessor processor = new StaticResourceProcessor();
processor.process(request, response);
}
// Close the socket
socket.close();
// check if the previous URI is a shutdown command
shutdown = request.getUri().equals(SHUTDOWN_COMMAND);
}
catch (Exception e)
{
e.printStackTrace();
System.exit(1);
}
}
}
}package linkin;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.UnsupportedEncodingException;
import java.util.Enumeration;
import java.util.Locale;
import java.util.Map;
import javax.servlet.RequestDispatcher;
import javax.servlet.ServletInputStream;
import javax.servlet.ServletRequest;
public class Request implements ServletRequest
{
private InputStream input;
private String uri;
public Request(InputStream input)
{
this.input = input;
}
public String getUri()
{
return uri;
}
private String parseUri(String requestString)
{
int index1, index2;
index1 = requestString.indexOf(' ');
if (index1 != -1)
{
index2 = requestString.indexOf(' ', index1 + 1);
if (index2 > index1)
return requestString.substring(index1 + 1, index2);
}
return null;
}
public void parse()
{
// Read a set of characters from the socket
StringBuffer request = new StringBuffer(2048);
int i;
byte[] buffer = new byte[2048];
try
{
i = input.read(buffer);
}
catch (IOException e)
{
e.printStackTrace();
i = -1;
}
for (int j = 0; j < i; j++)
{
request.append((char) buffer[j]);
}
System.out.print(request.toString());
uri = parseUri(request.toString());
}
/* implementation of ServletRequest */
public Object getAttribute(String attribute)
{
return null;
}
public Enumeration getAttributeNames()
{
return null;
}
public String getRealPath(String path)
{
return null;
}
public RequestDispatcher getRequestDispatcher(String path)
{
return null;
}
public boolean isSecure()
{
return false;
}
public String getCharacterEncoding()
{
return null;
}
public int getContentLength()
{
return 0;
}
public String getContentType()
{
return null;
}
public ServletInputStream getInputStream() throws IOException
{
return null;
}
public Locale getLocale()
{
return null;
}
public Enumeration getLocales()
{
return null;
}
public String getParameter(String name)
{
return null;
}
public Map getParameterMap()
{
return null;
}
public Enumeration getParameterNames()
{
return null;
}
public String[] getParameterValues(String parameter)
{
return null;
}
public String getProtocol()
{
return null;
}
public BufferedReader getReader() throws IOException
{
return null;
}
public String getRemoteAddr()
{
return null;
}
public String getRemoteHost()
{
return null;
}
public String getScheme()
{
return null;
}
public String getServerName()
{
return null;
}
public int getServerPort()
{
return 0;
}
public void removeAttribute(String attribute)
{
}
public void setAttribute(String key, Object value)
{
}
public void setCharacterEncoding(String encoding) throws UnsupportedEncodingException
{
}
@Override
public String getLocalAddr()
{
return null;
}
@Override
public String getLocalName()
{
return null;
}
@Override
public int getLocalPort()
{
return 0;
}
@Override
public int getRemotePort()
{
return 0;
}
}package linkin;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.Locale;
import javax.servlet.ServletOutputStream;
import javax.servlet.ServletResponse;
public class Response implements ServletResponse
{
private static final int BUFFER_SIZE = 1024;
public static final String WEB_ROOT = System.getProperty("user.dir") + File.separator + "webroot";
Request request;
OutputStream output;
PrintWriter writer;
public Response(OutputStream output)
{
this.output = output;
}
public void setRequest(Request request)
{
this.request = request;
}
/* This method is used to serve static pages */
public void sendStaticResource() throws IOException
{
byte[] bytes = new byte[BUFFER_SIZE];
FileInputStream fis = null;
try
{
/* request.getUri has been replaced by request.getRequestURI */
File file = new File(WEB_ROOT, request.getUri());
fis = new FileInputStream(file);
/*
* HTTP Response = Status-Line(( general-header | response-header |
* entity-header ) CRLF) CRLF [ message-body ] Status-Line =
* HTTP-Version SP Status-Code SP Reason-Phrase CRLF
*/
int ch = fis.read(bytes, 0, BUFFER_SIZE);
while (ch != -1)
{
output.write(bytes, 0, ch);
ch = fis.read(bytes, 0, BUFFER_SIZE);
}
}
catch (FileNotFoundException e)
{
String errorMessage = "HTTP/1.1 404 File Not Found\r\n" + "Content-Type: text/html\r\n" + "Content-Length: 23\r\n" + "\r\n" + "<h1>File Not Found</h1>";
output.write(errorMessage.getBytes());
}
finally
{
if (fis != null)
fis.close();
}
}
/** implementation of ServletResponse */
public void flushBuffer() throws IOException
{
}
public int getBufferSize()
{
return 0;
}
public String getCharacterEncoding()
{
return null;
}
public Locale getLocale()
{
return null;
}
public ServletOutputStream getOutputStream() throws IOException
{
return null;
}
public PrintWriter getWriter() throws IOException
{
// autoflush is true, println() will flush,
// but print() will not.
writer = new PrintWriter(output, true);
return writer;
}
public boolean isCommitted()
{
return false;
}
public void reset()
{
}
public void resetBuffer()
{
}
public void setBufferSize(int size)
{
}
public void setContentLength(int length)
{
}
public void setContentType(String type)
{
}
@Override
public void setLocale(Locale locale)
{
}
@Override
public String getContentType()
{
return null;
}
@Override
public void setCharacterEncoding(String arg0)
{
}
}package linkin;
import java.io.IOException;
public class StaticResourceProcessor
{
public void process(Request request, Response response)
{
try
{
response.sendStaticResource();
}
catch (IOException e)
{
e.printStackTrace();
}
}
}package linkin;
import java.io.File;
import java.io.IOException;
import java.net.URL;
import java.net.URLClassLoader;
import java.net.URLStreamHandler;
import javax.servlet.Servlet;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
public class ServletProcessor1
{
public void process(Request request, Response response)
{
String uri = request.getUri();
String servletName = uri.substring(uri.lastIndexOf("/") + 1);
URLClassLoader loader = null;
try
{
// create a URLClassLoader
URL[] urls = new URL[1];
URLStreamHandler streamHandler = null;
File classPath = new File(Response.WEB_ROOT);
// the forming of repository is taken from the
// createClassLoader method in
// org.apache.catalina.startup.ClassLoaderFactory
String repository = (new URL("file", null, classPath.getCanonicalPath() + File.separator)).toString();
// the code for forming the URL is taken from
// the addRepository method in
// org.apache.catalina.loader.StandardClassLoader.
urls[0] = new URL(null, repository, streamHandler);
loader = new URLClassLoader(urls);
}
catch (IOException e)
{
System.out.println(e.toString());
}
Class myClass = null;
try
{
System.out.println(servletName);
myClass = loader.loadClass(servletName);
}
catch (ClassNotFoundException e)
{
System.out.println(e.toString());
}
Servlet servlet = null;
try
{
//跑一下反射，初始化一个实例，然后调用这个servlet的service方法。
servlet = (Servlet) myClass.newInstance();
servlet.service((ServletRequest) request, (ServletResponse) response);
}
catch (Exception e)
{
System.out.println(e.toString());
}
catch (Throwable e)
{
System.out.println(e.toString());
}
}
}package linkin;
import java.io.IOException;
import java.io.PrintWriter;
import javax.servlet.Servlet;
import javax.servlet.ServletConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
public class PrimitiveServlet implements Servlet
{
@Override
public void init(ServletConfig config) throws ServletException
{
System.out.println("init");
}
@Override
public void service(ServletRequest request, ServletResponse response) throws ServletException, IOException
{
System.out.println("from service");
PrintWriter out = response.getWriter();
out.println("<html><head><title>linkin.html</title>"+
"<meta http-equiv=\"keywords\" content=\"keyword1,keyword2,keyword3\">"+
"<meta http-equiv='description' content='this is my page'>"+
"<meta http-equiv='content-type' content='text/html; charset=UTF-8'>"+
"<!--<link rel='stylesheet' type='text/css' href='./styles.css'>-->"+
"</head><h1>NightWish，气质在作祟。。。</h1><br></body></html>");
out.println("值得注意的是，要是去web应用去找一个文件那么直接指定物理路径找就好了，要是用类加载加载一个class文件，是要在classpath里面去找的");
out.println("现在一般不需要配置java的classpath了，默认情况就是当前的工作路径，也就是这个项目的bin下面的路径，在类加载找这个文件的时候一定要写上包名");
}
public void destroy()
{
System.out.println("destroy");
}
public String getServletInfo()
{
return null;
}
public ServletConfig getServletConfig()
{
return null;
}
}
补充说明：
首先先看上面的servlet的处理器里面调用servlet的service方法这2行代码：
try {
servlet = (Servlet) myClass.newInstance();
servlet.service((ServletRequest) request,(ServletResponse) response);
}这里有一个问题：我们写的这个处理器并不是说只能接受servlet的请求，所以这里我们传入的参数就是request和response类型的，但是我们现在在调用servlet的时候，又要传入servletRequest和servletResponse类型的参数，这里向下强转是很危险的，万一人家这个请求和相应不是servlet类型的呢，对吧，所以我们就是要达到一种效果就是说：我贴出的这request和response这2块代码呢只能在我们自己的类里面使用，在我自己的包下面使用，在其他的地方不能被访问到，这样子我就随便向下转保证肯定不会出错了，而且也可以保证这2个类里面的方法也是安全的了，比如说外部的类肯定不能调用request的parseURI方法了，怎么办呢？一共有2种实现方式：
1，让上面的request类和response类拥有默认的访问权限，也就是说只能在自己的包中被访问到，那么这样子就安全了
2，使用门面设计模式，具体的讲解请查看我设计模式里面的那篇文章。大致的意思就是在上面的request和response外面再自己封装一次门面，将这个request和response私有化，里面所有的方法呢其实还是用这个request和response类来调用，这样子的话包外面就不能直接访问到request和response这2个类了。代码如下：
package linkin;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.util.Enumeration;
import java.util.Locale;
import java.util.Map;
import javax.servlet.RequestDispatcher;
import javax.servlet.ServletInputStream;
import javax.servlet.ServletRequest;
public class RequestFacade implements ServletRequest
{
private ServletRequest request = null;
public RequestFacade(Request request)
{
this.request = request;
}
/* implementation of the ServletRequest */
public Object getAttribute(String attribute)
{
return request.getAttribute(attribute);
}
public Enumeration getAttributeNames()
{
return request.getAttributeNames();
}
......................
}
1380
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
