Jsp源码浅析（1）

最新推荐文章于 2023-10-28 18:00:00 发布
最新推荐文章于 2023-10-28 18:00:00 发布
阅读量749 收藏 1
点赞数 1
分类专栏： java基础学习 javaweb 文章标签： servlet
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/BryantLmm/article/details/67656560
版权

JSP全称是Java Server Pages，它和servle技术一样，都是SUN公司定义的一种用于开发动态web资源的技术。
　　JSP这门技术的最大的特点在于，写jsp就像在写html，但它相比html而言，
html只能为用户提供静态数据，而Jsp技术允许在页面中嵌套java代码，为用户提供动态数据。
　首先，我们给出一个结论：Jsp其实也是Servlet。
　浏览器向服务器发请求，不管访问的是什么资源，其实都是在访问Servlet，
所以当访问一个jsp页面时，其实也是在访问一个Servlet，服务器在执行jsp的时候，首先把jsp翻译成一个Servlet，所以我们访问jsp时，其实不是在访问jsp，而是在访问jsp翻译过后的那个Servlet。
为了验证Jsp也是Servlet，我们来新建一个Jsp。

<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<%
String path = request.getContextPath();
String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";
%>

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
  <head>
    <base href="<%=basePath%>">

    <title>My JSP 'Test.jsp' starting page</title>

    <meta http-equiv="pragma" content="no-cache">
    <meta http-equiv="cache-control" content="no-cache">
    <meta http-equiv="expires" content="0">    
    <meta http-equiv="keywords" content="keyword1,keyword2,keyword3">
    <meta http-equiv="description" content="This is my page">
    <!--
    <link rel="stylesheet" type="text/css" href="styles.css">
    -->

  </head>

  <body>
    This is my JSP page. <br>
    <h2>JSPEEE</h2>
    <form action="">
    <input type="text" value="朦朦"/>
    </form>
  </body>
</html>

我们访问这个jsp:http://localhost:8080/Jsp/Test.jsp
第一次执行Jsp文件时，在Web容器中找到需要执行的.jsp文件之后，.jsp文件通过转换变为.java文件，.java文件经过编译后，形成*.class文件
最终服务器要执行形成的*.class文件。
之后第二次执行因为已经存在了*.class文件，所以不在需要转换和编译的过程，和Servlet一样，只会被Web容器实例化一次。
修改Jsp后执行：源文件已经被修改过了，所以需要重新转换，重新编译。
那此时Jsp第一次被执行后，转换的java文件和class文件在哪呢？
当我们通过MyEclipse编译的时候，会默认的存放位置，放在tomcat目录下，不需要我们去设置。
这里写图片描述
默认在Tomcat跟目录下的//work//Catalina//localhost//工程名下
但是如果是Eclipse的话，默认的工程名在Eclipse的WorkSpace下的.metadata目录下，不利于我们查找。我们一般要将Jsp的存储路径放在Tomcat目录下，那这时该怎么设置呢。我们找到Servers，双击Servers设置，按下图设置这里写图片描述
现在我们找出相应的java文件

/*
 * Generated by the Jasper component of Apache Tomcat
 * Version: Apache Tomcat/8.0.35
 * Generated at: 2017-03-28 13:16:35 UTC
 * Note: The last modified time of this file was set to
 *       the last modified time of the source file after
 *       generation to assist with modification tracking.
 */
package org.apache.jsp;

import javax.servlet.*;
import javax.servlet.http.*;
import javax.servlet.jsp.*;
import java.util.*;

public final class Test_jsp extends org.apache.jasper.runtime.HttpJspBase
    implements org.apache.jasper.runtime.JspSourceDependent,
                 org.apache.jasper.runtime.JspSourceImports {

  private static final javax.servlet.jsp.JspFactory _jspxFactory =
          javax.servlet.jsp.JspFactory.getDefaultFactory();

  private static java.util.Map<java.lang.String,java.lang.Long> _jspx_dependants;

  private static final java.util.Set<java.lang.String> _jspx_imports_packages;

  private static final java.util.Set<java.lang.String> _jspx_imports_classes;

  static {
    _jspx_imports_packages = new java.util.HashSet<>();
    _jspx_imports_packages.add("javax.servlet");
    _jspx_imports_packages.add("java.util");
    _jspx_imports_packages.add("javax.servlet.jsp");
    _jspx_imports_packages.add("javax.servlet.http");
    _jspx_imports_classes = null;
  }

  private volatile javax.el.ExpressionFactory _el_expressionfactory;
  private volatile org.apache.tomcat.InstanceManager _jsp_instancemanager;

  public java.util.Map<java.lang.String,java.lang.Long> getDependants() {
    return _jspx_dependants;
  }

  public java.util.Set<java.lang.String> getPackageImports() {
    return _jspx_imports_packages;
  }

  public java.util.Set<java.lang.String> getClassImports() {
    return _jspx_imports_classes;
  }

  public javax.el.ExpressionFactory _jsp_getExpressionFactory() {
    if (_el_expressionfactory == null) {
      synchronized (this) {
        if (_el_expressionfactory == null) {
          _el_expressionfactory = _jspxFactory.getJspApplicationContext(getServletConfig().getServletContext()).getExpressionFactory();
        }
      }
    }
    return _el_expressionfactory;
  }

  public org.apache.tomcat.InstanceManager _jsp_getInstanceManager() {
    if (_jsp_instancemanager == null) {
      synchronized (this) {
        if (_jsp_instancemanager == null) {
          _jsp_instancemanager = org.apache.jasper.runtime.InstanceManagerFactory.getInstanceManager(getServletConfig());
        }
      }
    }
    return _jsp_instancemanager;
  }

  public void _jspInit() {
  }

  public void _jspDestroy() {
  }

  public void _jspService(final javax.servlet.http.HttpServletRequest request, final javax.servlet.http.HttpServletResponse response)
        throws java.io.IOException, javax.servlet.ServletException {

final java.lang.String _jspx_method = request.getMethod();
if (!"GET".equals(_jspx_method) && !"POST".equals(_jspx_method) && !"HEAD".equals(_jspx_method) && !javax.servlet.DispatcherType.ERROR.equals(request.getDispatcherType())) {
response.sendError(HttpServletResponse.SC_METHOD_NOT_ALLOWED, "JSPs only permit GET POST or HEAD");
return;
}

    final javax.servlet.jsp.PageContext pageContext;
    javax.servlet.http.HttpSession session = null;
    final javax.servlet.ServletContext application;
    final javax.servlet.ServletConfig config;
    javax.servlet.jsp.JspWriter out = null;
    final java.lang.Object page = this;
    javax.servlet.jsp.JspWriter _jspx_out = null;
    javax.servlet.jsp.PageContext _jspx_page_context = null;


    try {
      response.setContentType("text/html;charset=UTF-8");
      pageContext = _jspxFactory.getPageContext(this, request, response,
                null, true, 8192, true);
      _jspx_page_context = pageContext;
      application = pageContext.getServletContext();
      config = pageContext.getServletConfig();
      session = pageContext.getSession();
      out = pageContext.getOut();
      _jspx_out = out;

      out.write('\r');
      out.write('\n');

String path = request.getContextPath();
String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";

      out.write("\r\n");
      out.write("\r\n");
      out.write("<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\">\r\n");
      out.write("<html>\r\n");
      out.write("  <head>\r\n");
      out.write("    <base href=\"");
      out.print(basePath);
      out.write("\">\r\n");
      out.write("    \r\n");
      out.write("    <title>My JSP 'Test.jsp' starting page</title>\r\n");
      out.write("    \r\n");
      out.write("\t<meta http-equiv=\"pragma\" content=\"no-cache\">\r\n");
      out.write("\t<meta http-equiv=\"cache-control\" content=\"no-cache\">\r\n");
      out.write("\t<meta http-equiv=\"expires\" content=\"0\">    \r\n");
      out.write("\t<meta http-equiv=\"keywords\" content=\"keyword1,keyword2,keyword3\">\r\n");
      out.write("\t<meta http-equiv=\"description\" content=\"This is my page\">\r\n");
      out.write("\t<!--\r\n");
      out.write("\t<link rel=\"stylesheet\" type=\"text/css\" href=\"styles.css\">\r\n");
      out.write("\t-->\r\n");
      out.write("\r\n");
      out.write("  </head>\r\n");
      out.write("  \r\n");
      out.write("  <body>\r\n");
      out.write("    This is my JSP page. <br>\r\n");
      out.write("    <h2>JSPEEE</h2>\r\n");
      out.write("    <form action=\"\">\r\n");
      out.write("    <input type=\"text\" value=\"朦朦\"/>\r\n");
      out.write("    </form>\r\n");
      out.write("  </body>\r\n");
      out.write("</html>\r\n");
    } catch (java.lang.Throwable t) {
      if (!(t instanceof javax.servlet.jsp.SkipPageException)){
        out = _jspx_out;
        if (out != null && out.getBufferSize() != 0)
          try {
            if (response.isCommitted()) {
              out.flush();
            } else {
              out.clearBuffer();
            }
          } catch (java.io.IOException e) {}
        if (_jspx_page_context != null) _jspx_page_context.handlePageException(t);
        else throw new ServletException(t);
      }
    } finally {
      _jspxFactory.releasePageContext(_jspx_page_context);
    }
  }
}

我们看该类实现了HttpJspBase

public final class Test_jsp extends org.apache.jasper.runtime.HttpJspBase
    implements org.apache.jasper.runtime.JspSourceDependent,
                 org.apache.jasper.runtime.JspSourceImports

我们看HttpJspBase这个类

public abstract class HttpJspBase extends HttpServlet implements HttpJspPage {

    private static final long serialVersionUID = 1L;

    protected HttpJspBase() {
    }

    @Override
    public final void init(ServletConfig config) 
        throws ServletException 
    {
        super.init(config);
        jspInit();
        _jspInit();
    }

    @Override
    public String getServletInfo() {
        return Localizer.getMessage("jsp.engine.info");
    }

    @Override
    public final void destroy() {
        jspDestroy();
        _jspDestroy();
    }

    /**
     * Entry point into service.
     */
    @Override
    public final void service(HttpServletRequest request, HttpServletResponse response) 
        throws ServletException, IOException 
    {
        _jspService(request, response);
    }

    @Override
    public void jspInit() {
    }

    public void _jspInit() {
    }

    @Override
    public void jspDestroy() {
    }

    protected void _jspDestroy() {
    }

    @Override
    public abstract void _jspService(HttpServletRequest request, 
                                     HttpServletResponse response) 
        throws ServletException, IOException;
}

我们可以很清楚的看到，这个类实现了HttpServlet,所以，Jsp也是Servlet.
我们再来关注下_jspService方法


    public void _jspService(
            final javax.servlet.http.HttpServletRequest request,
            final javax.servlet.http.HttpServletResponse response)
            throws java.io.IOException, javax.servlet.ServletException {

        final java.lang.String _jspx_method = request.getMethod();
        if (!"GET".equals(_jspx_method)
                && !"POST".equals(_jspx_method)
                && !"HEAD".equals(_jspx_method)
                && !javax.servlet.DispatcherType.ERROR.equals(request
                        .getDispatcherType())) {
            response.sendError(HttpServletResponse.SC_METHOD_NOT_ALLOWED,
                    "JSPs only permit GET POST or HEAD");
            return;
        }

        final javax.servlet.jsp.PageContext pageContext;
        javax.servlet.http.HttpSession session = null;
        final javax.servlet.ServletContext application;
        final javax.servlet.ServletConfig config;
        javax.servlet.jsp.JspWriter out = null;
        final java.lang.Object page = this;
        javax.servlet.jsp.JspWriter _jspx_out = null;
        javax.servlet.jsp.PageContext _jspx_page_context = null;

        try {
            response.setContentType("text/html;charset=UTF-8");
            pageContext = _jspxFactory.getPageContext(this, request, response,
                    null, true, 8192, true);
            _jspx_page_context = pageContext;
            application = pageContext.getServletContext();
            config = pageContext.getServletConfig();
            session = pageContext.getSession();
            out = pageContext.getOut();
            _jspx_out = out;

            out.write('\r');
            out.write('\n');

            String path = request.getContextPath();
            String basePath = request.getScheme() + "://"
                    + request.getServerName() + ":" + request.getServerPort()
                    + path + "/";

            out.write("\r\n");
            out.write("\r\n");
            out.write("<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\">\r\n");
            out.write("<html>\r\n");
            out.write("  <head>\r\n");
            out.write("    <base href=\"");
            out.print(basePath);
            out.write("\">\r\n");
            out.write("    \r\n");
            out.write("    <title>My JSP 'Test.jsp' starting page</title>\r\n");
            out.write("    \r\n");
            out.write("\t<meta http-equiv=\"pragma\" content=\"no-cache\">\r\n");
            out.write("\t<meta http-equiv=\"cache-control\" content=\"no-cache\">\r\n");
            out.write("\t<meta http-equiv=\"expires\" content=\"0\">    \r\n");
            out.write("\t<meta http-equiv=\"keywords\" content=\"keyword1,keyword2,keyword3\">\r\n");
            out.write("\t<meta http-equiv=\"description\" content=\"This is my page\">\r\n");
            out.write("\t<!--\r\n");
            out.write("\t<link rel=\"stylesheet\" type=\"text/css\" href=\"styles.css\">\r\n");
            out.write("\t-->\r\n");
            out.write("\r\n");
            out.write("  </head>\r\n");
            out.write("  \r\n");
            out.write("  <body>\r\n");
            out.write("    This is my JSP page. <br>\r\n");
            out.write("    <h2>JSPEEE</h2>\r\n");
            out.write("    <form action=\"\">\r\n");
            out.write("    <input type=\"text\" value=\"朦朦\"/>\r\n");
            out.write("    </form>\r\n");
            out.write("  </body>\r\n");
            out.write("</html>\r\n");
        } catch (java.lang.Throwable t) {
            if (!(t instanceof javax.servlet.jsp.SkipPageException)) {
                out = _jspx_out;
                if (out != null && out.getBufferSize() != 0)
                    try {
                        if (response.isCommitted()) {
                            out.flush();
                        } else {
                            out.clearBuffer();
                        }
                    } catch (java.io.IOException e) {
                    }
                if (_jspx_page_context != null)
                    _jspx_page_context.handlePageException(t);
                else
                    throw new ServletException(t);
            }
        } finally {
            _jspxFactory.releasePageContext(_jspx_page_context);
        }
    }

我们都知道在jsp中有9大内置对象，其中page对象，request和response已经完成了实例化，这一点在程序中很容易看出来
page就是this，当前对象 request代表HttpServletRequest，response代表HttpResponse，这两个对象在Servlet容器（Tomcat）调用Servlet的Service方法之前
就被实例化
那么其他的对象是怎样被实例化的呢
我们随便百度，很快就可以知道我们可以通过jsp9大内置对象中的pageContext对象获得别的对象引用，那这是怎么做到的呢
我们查看代码一看
application = pageContext.getServletContext();
config = pageContext.getServletConfig();
session = pageContext.getSession();
out = pageContext.getOut();
原来这里的实例化application，config，session,out直接调用了PageContext的相应对象呀。也就是说PageContext对象都保存了其他对象的引用
那PageContext对象是怎样得到这些对象的引用的呢（总不可能一开始就存在PageContext对象中把）
我们看代码，发现，得到pageContext是通过 pageContext = _jspxFactory.getPageContext(this, request, response,
null, true, 8192, true);
这个方法得到的
那么一目了然，肯定是通过这个方法将其他内置对象的引用赋给了pageContext
我们就来看下这个方法的具体实现。

JspFactory抽象类

public abstract PageContext getPageContext(Servlet servlet,
            ServletRequest request, ServletResponse response,
            String errorPageURL, boolean needsSession, int buffer,
            boolean autoflush);

JspFactory的子类JspFactory，实现了getPageContext方法

 public PageContext getPageContext(Servlet servlet, ServletRequest request,
            ServletResponse response, String errorPageURL, boolean needsSession,
            int bufferSize, boolean autoflush) {

        if( Constants.IS_SECURITY_ENABLED ) {
            PrivilegedGetPageContext dp = new PrivilegedGetPageContext(
                    this, servlet, request, response, errorPageURL,
                    needsSession, bufferSize, autoflush);
            return AccessController.doPrivileged(dp);
        } else {
            return internalGetPageContext(servlet, request, response,
                    errorPageURL, needsSession,
                    bufferSize, autoflush);
        }
    }


           @Override
    public void initialize(Servlet servlet, ServletRequest request,
            ServletResponse response, String errorPageURL,
            boolean needsSession, int bufferSize, boolean autoFlush)
            throws IOException {

        _initialize(servlet, request, response, errorPageURL, needsSession,
                bufferSize, autoFlush);
    }

    private void _initialize(Servlet servlet, ServletRequest request,
            ServletResponse response, String errorPageURL,
            boolean needsSession, int bufferSize, boolean autoFlush) {

        // initialize state
        this.servlet = servlet;
        this.config = servlet.getServletConfig();
        this.context = config.getServletContext();
        this.errorPageURL = errorPageURL;
        this.request = request;
        this.response = response;

        // initialize application context
        this.applicationContext = JspApplicationContextImpl.getInstance(context);

        // Setup session (if required)
        if (request instanceof HttpServletRequest && needsSession)
            this.session = ((HttpServletRequest) request).getSession();
        if (needsSession && session == null)
            throw new IllegalStateException(
                    "Page needs a session and none is available");

        // initialize the initial out ...
        depth = -1;
        if (this.baseOut == null) {
            this.baseOut = new JspWriterImpl(response, bufferSize, autoFlush);
        } else {
            this.baseOut.init(response, bufferSize, autoFlush);
        }
        this.out = baseOut;

        // register names/values as per spec
        setAttribute(OUT, this.out);
        setAttribute(REQUEST, request);
        setAttribute(RESPONSE, response);

        if (session != null)
            setAttribute(SESSION, session);

        setAttribute(PAGE, servlet);
        setAttribute(CONFIG, config);
        setAttribute(PAGECONTEXT, this);
        setAttribute(APPLICATION, context);

        isIncluded = request.getAttribute(
                RequestDispatcher.INCLUDE_SERVLET_PATH) != null;
    }

注意最后的setAttribute

其实你发现，就是封装了其他对象而已，并没有做太多的工作
config对象的获取：是通过Servlet容器初始化Servlet对象时，执行构造方法后，调用init(ServletConfig config)，
这时Servlet容器会将ServletConfig对象传递给init(ServletConfig config)
接着才是调用Service。这里调用的是HttpJspBase中的该方法，这个类实现了基类GenericServlet的init(ServletConfig config)
在执行init(ServletConfig config)后，我们便得到了config的引用，所以在Service方法中调用getServletConfig当然可得到
config：即代码中的：this.config = servlet.getServletConfig();
  接着调用：this.context = config.getServletContext();（ServletConfig保存了ServletContext的引用，可查看源码）
  session通过request.getSession();得到
  总之，全都是封装了。一切都是封装，抽象。
public void init(ServletConfig config) throws ServletException {
this.config = config;
this.init();
}

再说一句：注意这里的setAttribute();!!!!!!!!以后会分析到**

BryantLmm
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
jsp网站源码
05-08
jsp网站开发源码，直接导入可用！适合新手
JSP安全编程实例浅析
09-06
JSP安全编程：从脚本编程的角度看JSP的安全，那些诸如源码暴露类的安全隐患就不在这篇文章讨论范围之内了
分享25个JSP源码，总有一款适合您
zy0412326的专栏
11-25 1万+
jsp 源码
第14弹：推荐一些适合练手、课程设计、毕业设计的JSP 项目源码，无任何下载门槛
最新发布
weixin_38343072的博客
10-28 99
一些JSP、JAVA项目源码，涵盖管理系统、网站，大部分项目的源码以及文档已经配齐，可用来练手以及大学生的课程设计、毕业设计等，无下载使用门槛
Jsp的源码剖析
十三月的博客
05-17 619
C:\Users\Administrator\.IntelliJIdea2018.3\system\tomcat\Unnamed_JavaWebStudy\work\Catalina\localhost\ROOT\org\apache\jsp Jsp本质就是一个Servlet JSP的基本语法 重要！！ ...
JSP源码分析
mulinghanxue的博客
07-16 2289
之前的博客中我们会经常使用到jsp,但jsp到底是如何运行的呢,它和HTML有什么区别?下面我们来看看它到底怎么运行的 JSP:Java Service Page ：Java服务器页面 内部可以书写java代码,是用来处理一些Java前后端交互的数据，主要用来显示数据，不建议大量代码写在JSP页面里面； 特点: 优点：简单，和HTML差不多,还可以书写java代码,书写格式灵活多样 缺点：由...
浅析webwork
03-05
本文将深入浅析WebWork的核心概念、工作原理以及与现代框架的对比，帮助读者理解其在IT发展史上的地位和价值。 ### 1. WebWork概述 WebWork是由OpenSymphony团队开发的MVC（模型-视图-控制器）框架，旨在简化Java ...
软件开发JSP基础与实例（张孝祥）源码
09-30
读者注意：这套视频语音讲解中引述的《软件开发课堂 - Java Web基础与案例...09使用技术浅析 10Log4j的应用 11JUint 12Ant的应用 13CVS的应用 14留言管理系统 15电子相册管理系统 16网上商店JpetStore 17传智博客BBS
SpringMVC的执行过程浅析
08-26
SpringMVC是Spring框架的一部分，专门用于处理Web应用程序的请求-响应流程。...同时，通过深入源码和UML图的分析，我们可以更深入地理解SpringMVC内部的工作机制，从而提升开发效率和问题排查能力。
strurts1完整资料
12-24
- "struts1工作原理浅析.doc"可能是对Struts1工作流程的详细解释。 - "struts1%E6%A0%87%E7%AD%BE.doc"和"struts教程.doc"可能是中文教程，讲解Struts1的关键概念和使用方法。 - "精通Struts：基于MVC的Java+Web...
jsp网站源码jsp网站源码
04-09
jsp网站源码jsp网站源码jsp网站源码jsp网站源码jsp网站源码jsp网站源码jsp网站源码
JSP经典网站源码
07-04
JSP ASPNET CSS HTML 经典网站源代码
简单的jsp源码
02-03
其实jsp挺简单的，都是一些基于标签的代码，简单易学好上手。
jsp源码解析
mChenys的博客
07-06 1014
Jsp其实就是一个servlet！！！！Jsp的java类的生命周期和servlet的生命周期一样servlet的生命周期：    构造方法    init方法    service方法    destroy（）jsp的java类的生命周期：    构造方法    _jspInit()    _jspService（）    _jspDestroy()以tomcat服务器为例,当访问jsp页面后,...
springmvc返回JSP源码
非学无以广才，非志无以成学
07-19 3524
问题：请求返回jsp源码 解决：将项目的web.xml中 &lt;servlet-mapping&gt; 下的&lt;url-pattern&gt;/*&lt;/url-pattern&gt;改为&lt;url-pattern&gt;/&lt;/url-pattern&gt; 原理：首先理解/ 和 /*区别 再理解SpringMVC处理请求的流程 DispatcherServl...
JSP管理系统的完整的源码，调试运行的大体步骤
ruglcc's blog
03-26 5155
2010年06月03日 星期四18:59 1、把系统拷到tomcat的webapps下面去 2、把数据库创建起来 3、修改数据库的配置文件，然后启动TOMCAT －－－－－－－－ 这个项目就可以跑起来了 如果要改这个项目什么的，那就按照以下步骤： 1、打开eclipse，新建一个WEB项目，然后把文件拷到刚刚你指定的文件夹去； 2、在ECLIPSE里面配置好
JSP-原理详细分析+源码查看
Ara_Hu的博客
02-28 1012
JSP JSP：Java Server Page，Java服务器端页面，和Servlet一样，用于动态web技术。 JSP页面的展示就是HTML和Java代码组成的页面 JSP原理 JSP执行过程 当某个JSP页面第一次被访问时，它就会进行如下步骤： 准备两个JSP页面如下： 在这里插入代码片 ...
ClassNotFoundException和NoClassDeFoundError
热门推荐
BryantLmm的博客
09-28 1万+
今天又出现了NoClassDefFoundError这个错误，其实已经出现过很多次了，也知道了一般都是缺少相关Jar包之类的造成的，但是也没进行更深入的了解，今天我们就来稍微的探究一下这个错误到底怎么发生的，他和ClassNotFonudException这一常见异常又有什么区别呢。我们知道这两个Java类都属于异常，那么我们首先来看看他们是checked exception还是unchecked
chrome插件 jsp源码
07-18
Chrome插件 jsp源码是指在Chrome浏览器中使用jsp语言编写的插件源代码。 JSP是JavaServer Pages的缩写，是一种基于Java的服务器端技术。使用JSP可以将Java代码嵌入到HTML页面中，实现动态生成网页内容的功能。 当...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值