Servlet基础知识点*（初学者）

已于 2022-08-11 09:03:07 修改
阅读量162 收藏
点赞数 1
文章标签： servlet java
于 2022-08-11 09:02:11 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_66740775/article/details/126277882
版权
  1. Servlet 的基本架构
  2. Serclet 的生命周期
  3. Servlet 是一个单列（单列和多列的分别是因为？），是一个多线程 ，存在线程安全性问题
  4. Servlet 中获取request、session、application 内置对象的方式
  5. request 的一些其他方法
  6. response 的一些 方法

1.Servlet 自身是一个接口，处理不用的服务，还有一个ServletConfig 接口

ServletConfig接口的功能就是实现配置加载。

 如：Servle的源码 和ServletConfig的源码

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by FernFlower decompiler)
//

package javax.servlet;

import java.util.Enumeration;

public interface ServletConfig {
    String getServletName();

    ServletContext getServletContext();

    String getInitParameter(String var1);

    Enumeration<String> getInitParameterNames();
}

Servlet接口

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by FernFlower decompiler)
//

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();
}

GenericServlet 类 实现了Servlet接口，但更多是对ServletConfig接口进行了实现，把对应的HTTP请求方法Service 扔给了子类HttpServlet ;
//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by FernFlower decompiler)
//

package javax.servlet;

import java.io.IOException;
import java.io.Serializable;
import java.util.Enumeration;
import java.util.ResourceBundle;

public abstract class GenericServlet implements Servlet, ServletConfig, Serializable {
    private static final String LSTRING_FILE = "javax.servlet.LocalStrings";
    private static ResourceBundle lStrings = ResourceBundle.getBundle("javax.servlet.LocalStrings");
    private transient ServletConfig config;

    public GenericServlet() {
    }

    public void destroy() {
    }

    public String getInitParameter(String name) {
        ServletConfig sc = this.getServletConfig();
        if (sc == null) {
            throw new IllegalStateException(lStrings.getString("err.servlet_config_not_initialized"));
        } else {
            return sc.getInitParameter(name);
        }
    }

    public Enumeration<String> getInitParameterNames() {
        ServletConfig sc = this.getServletConfig();
        if (sc == null) {
            throw new IllegalStateException(lStrings.getString("err.servlet_config_not_initialized"));
        } else {
            return sc.getInitParameterNames();
        }
    }

    public ServletConfig getServletConfig() {
        return this.config;
    }

    public ServletContext getServletContext() {
        ServletConfig sc = this.getServletConfig();
        if (sc == null) {
            throw new IllegalStateException(lStrings.getString("err.servlet_config_not_initialized"));
        } else {
            return sc.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 msg) {
        this.getServletContext().log(this.getServletName() + ": " + msg);
    }

    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() {
        ServletConfig sc = this.getServletConfig();
        if (sc == null) {
            throw new IllegalStateException(lStrings.getString("err.servlet_config_not_initialized"));
        } else {
            return sc.getServletName();
        }
    }
}

HttpServlet 该类主要就是完成用户的请求和响应，自定义Servlet 类必须继承 HttpServlet 类

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by FernFlower decompiler)
//

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(Class<? extends 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");
        }
    }
}

自定义的Servlet类 继承HttpServlet

  1. 自定义的Servlet 是一个单例还是多例？（面试题）
  2. Servlet  是一个单例设计，同时能够支持多线程并发访问，所以可能会造成多线程安全性问题。
  3. xx

配置部署Servlet

在文本.xml 配置Servlet的信息

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">

<!--    步骤1.先设置serclet的位置-->

<!--    定义servlet的名字，提供将来请求时能够找到改servlet-->
    <servlet>
        <servlet-name>TestServlet</servlet-name>
        <servlet-class>com.csi.eshop.controller.TestServlet</servlet-class>
    </servlet>

    <servlet>
        <servlet-name>CodeServlet</servlet-name>
        <servlet-class>com.csi.eshop.utils.CodeServlet</servlet-class>
    </servlet>

    <servlet>
        <servlet-name>LoginController</servlet-name>
        <servlet-class>com.csi.eshop.controller.LoginController</servlet-class>
    </servlet>

    <servlet>
        <servlet-name>RegistController</servlet-name>
        <servlet-class>com.csi.eshop.controller.RegistController</servlet-class>
    </servlet>

    <servlet>
        <servlet-name>InvalidateController</servlet-name>
        <servlet-class>com.csi.eshop.controller.InvalidateController</servlet-class>
    </servlet>

    <servlet>
        <servlet-name>ProductInfoController</servlet-name>
        <servlet-class>com.csi.eshop.controller.ProductInfoController</servlet-class>
    </servlet>

    <servlet>
        <servlet-name>pageIndexController</servlet-name>
        <servlet-class>com.csi.eshop.controller.pageIndexController</servlet-class>
    </servlet>

    <servlet>
        <servlet-name>ListProductBrandController</servlet-name>
        <servlet-class>com.csi.eshop.controller.ListProductBrandController</servlet-class>
    </servlet>

    <servlet>
        <servlet-name>FindProductController</servlet-name>
        <servlet-class>com.csi.eshop.controller.FindProductController</servlet-class>
    </servlet>



    <servlet>
        <servlet-name>FindProductIdController</servlet-name>
        <servlet-class>com.csi.eshop.controller.FindProductIdController</servlet-class>
    </servlet>



    <servlet-mapping>
        <servlet-name>FindProductIdController</servlet-name>
        <url-pattern>/FindProductIdController</url-pattern>
    </servlet-mapping>





    <servlet-mapping>
        <servlet-name>FindProductController</servlet-name>
        <url-pattern>/FindProductController</url-pattern>
    </servlet-mapping>


    <servlet-mapping>
        <servlet-name>ListProductBrandController</servlet-name>
        <url-pattern>/ListProductBrandController</url-pattern>
    </servlet-mapping>

    <servlet-mapping>
        <servlet-name>pageIndexController</servlet-name>
        <url-pattern>/pageIndexController</url-pattern>
    </servlet-mapping>


    <servlet-mapping>
        <servlet-name>ProductInfoController</servlet-name>
        <url-pattern>/ProductInfoController</url-pattern>
    </servlet-mapping>




    <servlet-mapping>
        <servlet-name>InvalidateController</servlet-name>
        <url-pattern>/InvalidateController</url-pattern>
    </servlet-mapping>

    <servlet-mapping>
        <servlet-name>RegistController</servlet-name>
        <url-pattern>/RegistController</url-pattern>
    </servlet-mapping>




    <servlet-mapping>
        <servlet-name>LoginController</servlet-name>
        <url-pattern>/LoginController</url-pattern>
    </servlet-mapping>




    <servlet-mapping>
        <servlet-name>CodeServlet</servlet-name>
        <url-pattern>/CodeServlet</url-pattern>
    </servlet-mapping>

<!--    步骤2.配置什么样的请求 要找到哪一个对应的servlet-->
    <servlet-mapping>
    <servlet-name>TestServlet</servlet-name>
    <url-pattern>/TestServlet</url-pattern>
    </servlet-mapping>

</web-app>

Servlet 运行步骤：
1. 先去 URL 中找到对应的请求 (url partten)
2. 找到请求所对应的 Servlet 的名字(servlet-name)
以上两个部分都是在 servlet mapping 中 .
3. 根据名字找到 Servlet 配置节点中的 Servlet 的名字 (servlet-name)
4. 再确定 Servlet 的 class 所在位置 (servlet-class)

Servlet的生命周期

1.实例化 Servlet：
首先由客户端发起请求，容器会解析请求的
URL ，找到对应 Servlet 配置中的 "url-partten" ，
紧跟着继续查找对应 “servlet-name” ，找到了
“servlet-name” 就会使用 "servlet-class" 实现类实例化。
2.调用 init 方法实现 Servlet 初始化
当容器执行自定义 Servlet 时，会自动调用 init 方
法，实现 Servlet 的初始化
3. 调用 Service 方法提供服务
在 HttpServlet 中的 Service 方法，会根据用户提
交的方式，选择调用 doXXX 方法，如果我们自己
重写了 Service 方法，而没有调用 doXXX 具体的方
法，可能在请求后，如果同时存在 service 以及对
应 doXXX 方法时，只会调用 service 这一个方法。
4.调用 destory 方法实现销毁
当 web 容器销毁时，会调用每一个自定义 Servlet
中的 destory 实现对 Servlet 的销毁功能。

Servlet 中获取request、session、application 内置对象的方式


//获取Session
HttpSession sessiom = request.getSession 

//获取aalicaton
ServletContext application = request.getServletContext
 request 的一些其他方法
getContextPath(): 获取到当前项目的上下文路径
getMethod(): 获取到请求的方式
getHeader(String str): 获取到请求的头信息的内容
response 的一些其他方法
getWriter() : 获取到 PrintWriter 对象，在内置对象中，代表 out 对象。 
PrintWriter out = resp.getWriter();
out.println("n hao a ");
setContentType(String txt): 设置当前页面响应的 内容形式。 
resp.setContentType("application/json;charaset=utf-8");
resp.setContentType("img/jpeg");

广-
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Servlet相关知识点
weixin_48304192的博客
05-22 357
Servlet相关知识点 一、引言 1.1C/S架构和B/S架构 C/S和B/S是软件发展过程中出现的两种软件架构方式。 1.2C/S架构（Client/Server客户端/服务器） 特点：必须在客户端安装特定软件 优点：图形效果显示较好（如：3D游戏） 缺点：服务器软件和功能进行升级，客户端也必须升级、不利于维护 常见的C/S程序：QQ、微信等 1.3B/S架构（Browser/Server浏览器/服务器） 特点：无需安装客户端，任何浏览器都可直接访问 优点：涉及到功能的升级，只需要升级
jspServlet知识点
weixin_43366786的博客
04-19 258
jspServlet个人总结知识点，希望对初学者帮助很大
Servlet新手入门篇
程序员小章的博客
09-22 692
Servlet入门 什么是Servlet Java Servlet 是运行在 Web 服务器或应用服务器上的程序，它是作为来自 Web 浏览器或其他 HTTP 客户端的请求和 HTTP 服务器上的数据库或应用程序之间的中间层。 使用 Servlet，您可以收集来自网页表单的用户输入，呈现来自数据库或者其他源的记录，还可以动态创建网页。 简单的概括： Servlet 是 JavaEE 规范之一。规范就是接口 Servlet 就 JavaWeb 三大组件之一。三大组件分别是：Servlet 程序、Fil
Servlet快速入门
qq_51447436的博客
02-16 562
Servlet快速入门
Servlet初学详解
Yg123345的博客
04-24 461
Servlet学习 一、Servlet的认识 Servlet（Server Applet）是Java Servlet的简称，称为小服务程序或服务连接器，用Java编写的服务器端程序，主要功能在于交互式地浏览和生成数据，生成动态Web内容。 编写一个Servlet程序只需完成下面两步： 编写一个类，实现Servlet接口 把开发好的Java类部署到web服务器中 简单明了一句话就是，实现了Servlet接口的Java程序叫做Servlet! 二、Servlet程序测试 完整步骤思路如下： 构建
javaweb—servlet的简单入门使用
热门推荐
永远不会懂
07-22 3万+
Servlet（Server Applet），全称JavaServlet，未有中文译文。是用Java编写的服务器端程序。其主要功能在于交互式地浏览和修改数据，生成动态Web内容。狭义的Servlet是指Java语言实现的一个接口，广义的Servlet是指任何实现了这个Servlet接口的类，一般情况下，人们将Servlet理解为后者。 Servlet运行于支持Java的应用服务器中。从原理上讲，
万字长文，超详细servlet知识点总结。
2301_79233885的博客
04-26 695
本文详细总结了servlet的知识点，并给出充分的代码演示，实践演示和学习目标，属于博主个人学习时的笔记分享，十分适合初学者的快速上手与学后复习，干货很多，宜多刷
java基础知识点
m0_70860559的博客
10-12 66
java的一些基础知识点，初学者可以看看
Servlet知识总结
立志成为一个前端、后端、测试全方位发展的程序员
08-08 7552
Servlet 一、Servlet介绍 Servlet是JavaEE规范(接口)之一 Servlet是JavaWeb三大组件之一，三大组件分别是Servlet程序、Filter过滤器、Listener监听器 Servlet是运行在服务器上的一个Java程序，可以接收客户端发来的请求，并响应数据给客户端 二、手动实现Servlet程序 编写一个类实现Servlet接口，并重写service方法处理请求、响应数据 在WEB-INF文件夹中的web.xml文件中配置Servlet程序的访问地址 代码演示：
Servlet1知识
weixin_43684831的博客
01-26 187
声明：本博客为学习b站某servlet视频时的笔记，供之后复习理解 C/S架构和B/S架构 客户端<——请求/响应——>web服务器/数据库服务器 Browser浏览器<——请求/响应——>服务器<——>数据库 Web(World Wide Web)万维网 静态资源：Web页面供人们浏览的数据始终保持不变(HTML/CSS) 动态资源：不同时间点、不同设备访问Web页面看到的内容各不相同 Java Web：动态Web资源开发技术 Web服务器 运行以及发布Web应用的容器
Java基础知识整理 初学者.zip
12-01
这份"Java基础知识整理 初学者.zip"压缩包包含了一份名为"Java基础.gmind"的思维导图，旨在帮助初学者构建对Java基础知识的全面理解。以下是根据这个主题详细展开的知识点： 1. **Java简介**：Java是由Sun ...
图书管理系统 servlet+jsp（适合初学者）
01-21
接下来，我们将深入探讨这个系统的主要组件和相关知识点。 1. **Servlet**: Servlet是Java Web开发中的核心组件，它是一种服务器端的小程序，用于扩展服务器的功能，处理HTTP请求。在本项目中，Servlet用于接收和...
bs架构零基础知识点.rar
02-07
本资料将帮助初学者深入理解BS架构及其相关知识点。 一、BS架构的组成 1. **浏览器（Browser）**：作为用户界面，BS架构中的客户端主要由Web浏览器构成，如Chrome、Firefox、Safari等。浏览器负责解析HTML、CSS和...
Servlet初学者笔记+示例代码（学习JSP之前的基础）
02-11
以下是一些关于Servlet的重要知识点： 1. **Servlet的生命周期**： Servlet在服务器端有三个主要阶段：加载、初始化和销毁。当服务器首次接收到对Servlet的请求时，会加载Servlet类并创建其实例，然后调用`init()`...
JavaEE基础知识详解教程（初学者的必选教程，不看后悔，入门级教程）
03-03
JavaEE是企业级应用开发的重要框架，为程序员提供...每个章节都是一个关键知识点，相互关联，共同构建出Java EE开发的坚实基础。对于那些希望通过学习Java EE进入企业级开发领域的人来说，这是一个不容错过的入门资源。
Java内存模型
weixin_44267758的博客
07-19 562
此处的变量不是指java编程中的变量，它包括了实例字段，静态字段和构成数值对象的元素，但不包括局部变量和方法参数。JMM规定所有变量都存储在主内存中。每条线程有自己的工作内存，工作内存中保留了该线程使用到变量的主内存的副本。线程对变量的所有操作都必须在工作内存中进行，不能直接读写主内存的变量，不同的线程间也无法直接访问对方工作内存的变量，线程之间的变量值传递需要通过主内存来完成。
Promise 详解（原理篇）
最新发布
山重水复疑无路，柳暗花明又一村。
07-20 479
Promise 是一种异步编程的解决方案。在异步操作中，callback 会导致回调地狱的问题，Promise 解决了这个问题。一个 Promise对象有以下三种状态:pending：初始状态，既不是成功，也不是失败状态。：意味着操作成功完成。rejected：意味着操作失败。当 new Promise() 被实例化后，即表示 Promise 进入 pending 初始化状态，准备就绪，等待运行。
JVM-垃圾回收与内存分配
m0_50846237的博客
07-19 983
JVM-垃圾回收与内存分配
java算法day19
TOMOT77的博客
07-20 130
我第一时间想到的方法是遍历二叉树+哈希。哈希用来统计数字出现的次数。之后遍历map收集结果。利用了BST的性质，即BST的中序序列是有序序列。
JavaWeb基础：HTTP协议与Servlet详解
本资源主要聚焦于Java Web开发的基础知识，涵盖了HTTP协议以及Servlet的核心概念。首先，HTTP协议是客户端与服务器之间通信的基础...掌握这些内容将有助于初学者快速上手Java Web开发，并为后续深入学习打下坚实基础。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值