Java web基础知识

Servlet

Servlet是sun公司开发的动态web技术

sun在API中提供了一个接口叫做 Servlet ，一个简单的Servlet 程序只需要完成两个步骤

编写一个实现了Servlet接口的类
把这个Java部署到web服务器中

一般来说把实现了Servlet接口的java程序叫做，Servlet

初步认识Servlet

Servlet接口sun公司有两个默认的实现抽象类：HttpServlet，GenericServlet

看看Serlvet接口是怎么在这两个类中实现的

Servlet接口


package javax.servlet;
 
import java.io.IOException;
 
public interface Servlet {
    void init(ServletConfig var1) throws ServletException;
 
    ServletConfig getServletConfig();
 
    void service(ServletRequest var1, ServletResponse var2) throws ServletException, IOException;
 
    String getServletInfo();
 
    void destroy();
}

这个接口里有五个抽象方法

init(ServletConfig var1)
getServletConfig()
service(ServletRequest var1, ServletResponse var2)
getServletInfo()
destroy()

这五个方法建立起了Servlet的基本框架：初始化、获取配置、服务功能、获取状态信息、销毁

也体现了servlet的生命周期

Servlet 初始化后调用 init () 方法。
Servlet 调用 service() 方法来处理客户端的请求。
Servlet 销毁前调用 destroy() 方法。
最后，Servlet 是由 JVM 的垃圾回收器进行垃圾回收的。

其中比较值得观察的是service方法

GenericServlet


package javax.servlet;
 
import java.io.IOException;
import java.io.Serializable;
import java.util.Enumeration;
 
public abstract class GenericServlet implements Servlet, ServletConfig, Serializable {
    private static final long serialVersionUID = 1L;
    private transient ServletConfig config;
 
    public GenericServlet() {
    }
 
    public void destroy() {
    }
 
    public String getInitParameter(String name) {
        return this.getServletConfig().getInitParameter(name);
    }
 
    public Enumeration getInitParameterNames() {
        return this.getServletConfig().getInitParameterNames();
    }
 
    public ServletConfig getServletConfig() {
        return this.config;
    }
 
    public ServletContext getServletContext() {
        return this.getServletConfig().getServletContext();
    }
 
    public String getServletInfo() {
        return "";
    }
 
    public void init(ServletConfig config) throws ServletException {
        this.config = config;
        this.init();
    }
 
    public void init() throws ServletException {
    }
 
    public void log(String message) {
        this.getServletContext().log(this.getServletName() + ": " + message);
    }
 
    public void log(String message, Throwable t) {
        this.getServletContext().log(this.getServletName() + ": " + message, t);
    }
 
    public abstract void service(ServletRequest var1, ServletResponse var2) throws ServletException, IOException;
 
    public String getServletName() {
        return this.config.getServletName();
    }
}

还是那五个抽象方法

init(ServletConfig var1)
getServletConfig()
service(ServletRequest var1, ServletResponse var2)
getServletInfo()
destroy()

可以看到对于service方法这个类并没有做任何的改变，只是对初始化和状态信息获取做出了改变

HttpServlet


 
package javax.servlet.http;
 
import java.io.IOException;
import java.lang.reflect.Method;
import java.text.MessageFormat;
import java.util.Enumeration;
import java.util.ResourceBundle;
import javax.servlet.GenericServlet;
import javax.servlet.ServletException;
import javax.servlet.ServletOutputStream;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
 
public abstract class HttpServlet extends GenericServlet {
    private static final String METHOD_DELETE = "DELETE";
    private static final String METHOD_HEAD = "HEAD";
    private static final String METHOD_GET = "GET";
    private static final String METHOD_OPTIONS = "OPTIONS";
    private static final String METHOD_POST = "POST";
    private static final String METHOD_PUT = "PUT";
    private static final String METHOD_TRACE = "TRACE";
    private static final String HEADER_IFMODSINCE = "If-Modified-Since";
    private static final String HEADER_LASTMOD = "Last-Modified";
    private static final String LSTRING_FILE = "javax.servlet.http.LocalStrings";
    private static ResourceBundle lStrings = ResourceBundle.getBundle("javax.servlet.http.LocalStrings");
 
    public HttpServlet() {
    }
 
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        String protocol = req.getProtocol();
        String msg = lStrings.getString("http.method_get_not_supported");
        if (protocol.endsWith("1.1")) {
            resp.sendError(405, msg);
        } else {
            resp.sendError(400, msg);
        }
 
    }
 
    protected long getLastModified(HttpServletRequest req) {
        return -1L;
    }
 
    protected void doHead(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        NoBodyResponse response = new NoBodyResponse(resp);
        this.doGet(req, response);
        response.setContentLength();
    }
 
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        String protocol = req.getProtocol();
        String msg = lStrings.getString("http.method_post_not_supported");
        if (protocol.endsWith("1.1")) {
            resp.sendError(405, msg);
        } else {
            resp.sendError(400, msg);
        }
 
    }
 
    protected void doPut(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        String protocol = req.getProtocol();
        String msg = lStrings.getString("http.method_put_not_supported");
        if (protocol.endsWith("1.1")) {
            resp.sendError(405, msg);
        } else {
            resp.sendError(400, msg);
        }
 
    }
 
    protected void doDelete(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        String protocol = req.getProtocol();
        String msg = lStrings.getString("http.method_delete_not_supported");
        if (protocol.endsWith("1.1")) {
            resp.sendError(405, msg);
        } else {
            resp.sendError(400, msg);
        }
 
    }
 
    private Method[] getAllDeclaredMethods(Classextends HttpServlet> c) {
        Class clazz = c;
 
        Method[] allMethods;
        for(allMethods = null; !clazz.equals(HttpServlet.class); clazz = clazz.getSuperclass()) {
            Method[] thisMethods = clazz.getDeclaredMethods();
            if (allMethods != null && allMethods.length > 0) {
                Method[] subClassMethods = allMethods;
                allMethods = new Method[thisMethods.length + allMethods.length];
                System.arraycopy(thisMethods, 0, allMethods, 0, thisMethods.length);
                System.arraycopy(subClassMethods, 0, allMethods, thisMethods.length, subClassMethods.length);
            } else {
                allMethods = thisMethods;
            }
        }
 
        return allMethods != null ? allMethods : new Method[0];
    }
 
    protected void doOptions(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        Method[] methods = this.getAllDeclaredMethods(this.getClass());
        boolean ALLOW_GET = false;
        boolean ALLOW_HEAD = false;
        boolean ALLOW_POST = false;
        boolean ALLOW_PUT = false;
        boolean ALLOW_DELETE = false;
        boolean ALLOW_TRACE = true;
        boolean ALLOW_OPTIONS = true;
 
        for(int i = 0; i < methods.length; ++i) {
            String methodName = methods[i].getName();
            if (methodName.equals("doGet")) {
                ALLOW_GET = true;
                ALLOW_HEAD = true;
            } else if (methodName.equals("doPost")) {
                ALLOW_POST = true;
            } else if (methodName.equals("doPut")) {
                ALLOW_PUT = true;
            } else if (methodName.equals("doDelete")) {
                ALLOW_DELETE = true;
            }
        }
 
        StringBuilder allow = new StringBuilder();
        if (ALLOW_GET) {
            allow.append("GET");
        }
 
        if (ALLOW_HEAD) {
            if (allow.length() > 0) {
                allow.append(", ");
            }
 
            allow.append("HEAD");
        }
 
        if (ALLOW_POST) {
            if (allow.length() > 0) {
                allow.append(", ");
            }
 
            allow.append("POST");
        }
 
        if (ALLOW_PUT) {
            if (allow.length() > 0) {
                allow.append(", ");
            }
 
            allow.append("PUT");
        }
 
        if (ALLOW_DELETE) {
            if (allow.length() > 0) {
                allow.append(", ");
            }
 
            allow.append("DELETE");
        }
 
        if (ALLOW_TRACE) {
            if (allow.length() > 0) {
                allow.append(", ");
            }
 
            allow.append("TRACE");
        }
 
        if (ALLOW_OPTIONS) {
            if (allow.length() > 0) {
                allow.append(", ");
            }
 
            allow.append("OPTIONS");
        }
 
        resp.setHeader("Allow", allow.toString());
    }
 
    protected void doTrace(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        String CRLF = "\r\n";
        StringBuilder buffer = (new StringBuilder("TRACE ")).append(req.getRequestURI()).append(" ").append(req.getProtocol());
        Enumeration reqHeaderEnum = req.getHeaderNames();
 
        while(reqHeaderEnum.hasMoreElements()) {
            String headerName = (String)reqHeaderEnum.nextElement();
            buffer.append(CRLF).append(headerName).append(": ").append(req.getHeader(headerName));
        }
 
        buffer.append(CRLF);
        int responseLength = buffer.length();
        resp.setContentType("message/http");
        resp.setContentLength(responseLength);
        ServletOutputStream out = resp.getOutputStream();
        out.print(buffer.toString());
    }
 
    protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        String method = req.getMethod();
        long lastModified;
        if (method.equals("GET")) {
            lastModified = this.getLastModified(req);
            if (lastModified == -1L) {
                this.doGet(req, resp);
            } else {
                long ifModifiedSince = req.getDateHeader("If-Modified-Since");
                if (ifModifiedSince < lastModified) {
                    this.maybeSetLastModified(resp, lastModified);
                    this.doGet(req, resp);
                } else {
                    resp.setStatus(304);
                }
            }
        } else if (method.equals("HEAD")) {
            lastModified = this.getLastModified(req);
            this.maybeSetLastModified(resp, lastModified);
            this.doHead(req, resp);
        } else if (method.equals("POST")) {
            this.doPost(req, resp);
        } else if (method.equals("PUT")) {
            this.doPut(req, resp);
        } else if (method.equals("DELETE")) {
            this.doDelete(req, resp);
        } else if (method.equals("OPTIONS")) {
            this.doOptions(req, resp);
        } else if (method.equals("TRACE")) {
            this.doTrace(req, resp);
        } else {
            String errMsg = lStrings.getString("http.method_not_implemented");
            Object[] errArgs = new Object[]{method};
            errMsg = MessageFormat.format(errMsg, errArgs);
            resp.sendError(501, errMsg);
        }
 
    }
 
    private void maybeSetLastModified(HttpServletResponse resp, long lastModified) {
        if (!resp.containsHeader("Last-Modified")) {
            if (lastModified >= 0L) {
                resp.setDateHeader("Last-Modified", lastModified);
            }
 
        }
    }
 
    public void service(ServletRequest req, ServletResponse res) throws ServletException, IOException {
        if (req instanceof HttpServletRequest && res instanceof HttpServletResponse) {
            HttpServletRequest request = (HttpServletRequest)req;
            HttpServletResponse response = (HttpServletResponse)res;
            this.service(request, response);
        } else {
            throw new ServletException("non-HTTP request or response");
        }
    }
}

可以看到这层的类实现了service方法的处理，每次服务器接收到一个 Servlet 请求时，服务器会产生一个新的线程并调用服务。service() 方法检查 HTTP 请求类型（GET、POST、PUT、DELETE 等），并在适当的时候调用 doGet、doPost、doPut，doDelete 等方法。

但是它默认处理并不是我们所需要的，所以我们自己写的java类就是要重写这些方法。

现在，这个简单的Servlet基础使用链就明了了

RMI

RMI (Java Remote Method Invocation) Java 远程方法调用，是一种允许一个 JVM 上的 object 调用另一个 JVM 上 object 方法的机制

⼀个RMI Server分为三部分：

⼀个继承了 java.rmi.Remote 的接⼝，其中定义我们要远程调⽤的函数
⼀个实现了此接⼝的类
⼀个主类，⽤来创建Registry，并将上⾯的类实例化后绑定到⼀个地址

来分析一下这个RMI设计的意图

一个RMI服务器的三个部分：一个接口、两个类，我理解的它们的作用如下：

接口：作为远程方法调用的调用目标
实现接口的类：用来承载接口方法

为什么要有这样一个类？

有类就可以序列化，序列化之后就可以把一个难以传输的目标变成一个便于传输的流

一个主类：作为Registry存在。

打个比方，它就像一个车站的售票处一样，你来坐车你就要先去它哪里找他买票，你有了对应的票才能找到、乘坐对应的车。

在RMI整体流程它也差不多扮演这个角色，客户端去向Registry请求某个方法，Registry返回一个stub给客户端，客户端在通过stub种的信息找到对应的地址端口建立TCP连接

RMI简单流程

一个简单的demo

服务端


package rmilearn;
 
import java.net.MalformedURLException;
import java.rmi.Naming;
import java.rmi.RemoteException;
import java.rmi.registry.LocateRegistry;
import java.rmi.server.UnicastRemoteObject;
 
public class Learn01 {
    public static void main(String[] args) throws RemoteException, MalformedURLException {
        HelloRmi rmi = new HelloRmi();
        LocateRegistry.createRegistry(1099);
        Naming.rebind("rmi://127.0.0.1:1099/hello",rmi);
    }
}
 
class HelloRmi extends  UnicastRemoteObject implements Hello {
    protected HelloRmi() throws RemoteException {
        super();
    }
 
    @Override
    public String HelloRm() throws RemoteException {
       return "hello rmi";
    }
}
--------------------------------------------------------------------------
package rmilearn;
 
import java.rmi.Remote;
import java.rmi.RemoteException;
 
public interface Hello extends Remote {
    String HelloRm() throws RemoteException;
}

客户端


public class client {
 
    public static void main(String[] args) throws RemoteException, NotBoundException {
      Registry re = LocateRegistry.getRegistry("localhost",1099);
      Hello h = (Hello) re.lookup("hello");
      String s = h.HelloRm();
      System.out.println(s);
    }
}

相关阅读:
[经验] 玄殿社区qq堂4.2 #笔记#媒体
 安装 Red Hat Enterprise Linux 9.1 虚拟机
 Django老项目升级到新版本
 网络编程扩展
 ambari搭建HDP集群后修改存储元数据的mysql数据库配置
 闭关三个月，腾讯大咖手写Framework最新源码笔记，从基础到进阶直接封神
 中国程序员做独立开发者的怎么这么少呢？
堪比坐牢！深圳一公司给每个工位都装监控，只为防止泄密？
Elasticsearch 8.9 Bulk批量给索引增加数据源码
 微信小程序反编译 2024 unveilr.exe
原文地址：https://blog.csdn.net/why811/article/details/133020263