精华内容
下载资源
问答
  • servlet书籍推荐
    千次阅读
    2014-05-27 08:39:28
    入门不错的我建议你看《Head First Servlet&JSP》,这本书同时也是SCWCD的官方指定教材。

    另外强烈推荐张孝祥同志的两本书(呵呵,我不是书拖哈),一本是《深入体验Java Web开发内幕——核心基础》另一本是《深入体验java web开发内幕--高级特性》,这两本书我正在看。
    市面上大部分讲解Servlet&JSP的书实际上在Servlet上基本没有花什么功夫,而且很多都是抄官方文档,这两本书恰恰相反,第一本书重点是Servlet,讲解了Servlet的Request,Response,Session,ServletContext等等,讲得很深入,JSP只做为最后一张讲解的,第二本书重点讲解JSP,Servlet部分讲了Servlet的过滤器和事件监听器。其实Servlet还是建议深入学学的,对你以后学习一些Web框架很有帮助。

    另外如果你主要想看看JSP的话,wrox出版社的JSP书还是不错的。



    最后自己看到的不错的书籍:

    Servlet与JSP核心编程


    更多相关内容
  • 推荐servlet的书

    千次阅读 2014-05-30 20:12:25
    1,尚学堂马士兵老师讲的servlet和jsp视频就可以了,迅雷就能下到,讲解的清晰易懂,还有实例,你跟着视频一步一步操作就ok2,电子工业出版社的 Java Servlets 2.3编程指南 3,孙卫琴的《Tomcat与Java Web开发技术...

    1,尚学堂马士兵老师讲的servlet和jsp视频就可以了,迅雷就能下到,
    讲解的清晰易懂,还有实例,你跟着视频一步一步操作就ok
    2,
    电子工业出版社的 Java Servlets 2.3编程指南
    3,
    孙卫琴的《Tomcat与Java Web开发技术详解》(第二版) 电子出版社
    4,
    Java Servlet & JSP经典实例
    (美)Bruce W. Perry
    5,
    servlet与jsp核心编程
    (美)Marty Hall,Larry Brown
    6,
    深入体验Java Web开发内幕——核心基础》另一本是《深入体验java web开发内幕--高级特性
    7,
     http://www.verycd.com/topics/93279/ 这里是视频
     http://download.csdn.net/source/435954  详细的jsp知识介绍
     http://download.csdn.net/source/794405
     学习jsp开发web应用系统参考书籍,里面有很详细的介绍,如果想要学好动态网站开发,不妨看看!
     http://download.csdn.net/source/657602
     JSP高级编程书籍教程(强烈推荐)
     8,
     Servlet/JSP深入详解:基于Tomcat的Web开发
     

    展开全文
  • @WebServlet(urlPatterns = {"/async"}, asyncSupported = true) public class AsyncServlet extends HttpServlet { // Web应用线程池,用来处理异步Servlet ExecutorService executor = Executors.newSingle

    ==========================================================================

    @WebServlet(urlPatterns = {"/async"}, asyncSupported = true)

    public class AsyncServlet extends HttpServlet {

    // Web应用线程池,用来处理异步Servlet

    ExecutorService executor = Executors.newSingleThreadExecutor();

    public void service(HttpServletRequest req, HttpServletResponse resp) {

    // 1. 调用startAsync或者异步上下文

    final AsyncContext ctx = req.startAsync();

    //用线程池来执行耗时操作

    executor.execute(new Runnable() {

    @Override

    public void run() {

    //在这里做耗时的操作

    try {

    ctx.getResponse().getWriter().println(“Handling Async Servlet”);

    } catch (IOException e) {}

    //3. 异步Servlet处理完了调用异步上下文的complete方法

    ctx.complete();

    }

    });

    }

    }

    通过注解注册Servlet:@WebServlet注解,asyncSupported=true表明当前的Servlet是一个异步Servlet。

    Web

    【一线大厂Java面试题解析+后端开发学习笔记+最新架构讲解视频+实战项目源码讲义】

    开源分享完整内容戳这里

    应用程序需要调用Request对象的startAsync方法来拿到一个异步上下文AsyncContext。这个上下文保存了请求和响应对象。

    Web应用需要开启一个新线程处理耗时操作:处理完成后调用AsyncContext#complete,通知Tomcat,请求已经处理完。

    虽然异步Servlet允许用更长的时间来处理请求,但是也有超时限制的,默认是30秒,如果30秒内请求还没处理完,Tomcat会触发超时机制,向浏览器返回超时错误,如果这个时候你的Web应用再调用ctx.complete方法,会得到IllegalStateException。

    异步Servlet原理

    ==========================================================================

    Tomcat在这个过程的关键:

    startAsync方法

    创建一个异步上下文AsyncContext对象,保存请求的中间信息,比如Request和Response对象等上下文信息。

    这是因为Tomcat的工作线程在request.startAsync调用之后,就直接结束回到线程池中了,线程本身不会保存任何信息。也就是说一个请求到服务端,执行到一半,你的Web应用正在处理,这个时候Tomcat的工作线程没了,这就需要有个缓存能够保存原始的Request和Response对象,而这个缓存就是AsyncContext。

    有了AsyncContext,你的Web应用通过它拿到Request和Response对象,拿到Request对象后就可以读取请求信息,请求处理完了还需要通过Response对象将HTTP响应发送给浏览器。

    除了创建AsyncContext对象,startAsync还需要完成一个关键任务,那就是告诉Tomcat当前的Servlet处理方法返回时,不要把响应发到浏览器,因为这个时候,响应还没生成呢;并且不能把Request对象和Response对象销毁,因为后面Web应用还要用呢。

    在Tomcat中,负责flush响应数据的是CoyoteAdapter,它还会销毁Request对象和Response对象,因此需要通过某种机制通知CoyoteAdapter,具体来说是通过下面这行代码:

    this.request.getCoyoteRequest().action(ActionCode.ASYNC_START, this);

    你可以把它理解为一个Callback,在这个action方法里设置了Request对象的状态,设置它为一个异步Servlet请求。

    连接器调用CoyoteAdapter#service处理请求的,而CoyoteAdapter会调用容器的service,当容器的service方法返回,CoyoteAdapter判断当前的请求是不是异步Servlet请求:

    • 如果是,就不会销毁Request和Response对象,也不会把响应信息发到浏览器。

    CoyoteAdapter#service

    public void service(org.apache.coyote.Request req, org.apache.coyote.Response res) {

    //调用容器的service方法处理请求

    connector.getService().getContainer().getPipeline().

    getFirst().invoke(request, response);

    //如果是异步Servlet请求,仅仅设置一个标志,

    //否则说明是同步Servlet请求,就将响应数据刷到浏览器

    if (request.isAsync()) {

    async = true;

    } else {

    request.finishRequest();

    response.finishResponse();

    }

    //如果不是异步Servlet请求,就销毁Request对象和Response对象

    if (!async) {

    request.recycle();

    response.recycle();

    }

    }

    当CoyoteAdapter#service返回到ProtocolHandler组件,ProtocolHandler判断返回值,如果当前请求是一个异步Servlet请求,它会把当前Socket的协议处理者Processor缓存起来,将SocketWrapper对象和相应的Processor存到Map

    private final Map<S,Processor> connections = new ConcurrentHashMap<>();

    缓存是因为这个请求接下来还要接着处理,还由原来Processor处理,通过SocketWrapper就能从Map里找到相应Processor。

    complete方法


    当请求处理完成时,Web应用调用这个方法:把响应数据发送到浏览器。

    这事不能由Web应用线程负责,即ctx.complete不能直接把响应数据发送到浏览器,因为这件事情应该由Tomcat线程处理。

    连接器中的Endpoint组件检测到有请求数据达到时,会创建一个SocketProcessor对象交给线程池去处理,因此Endpoint的通信处理和具体请求处理在两个线程里运行。

    在异步Servlet场景,Web应用通过调用ctx.complete方法时,也可生成一个新的SocketProcessor任务类,交给线程池处理。

    对于异步Servlet请求来说,相应的Socket和协议处理组件Processor都被缓存起来了,并且这些对象都可以通过Request对象拿到。

    public void complete() {

    //检查状态合法性,我们先忽略这句

    check();

    //调用Request对象的action方法,其实就是通知连接器,这个异步请求处理完了

    request.getCoyoteRequest().action(ActionCode.ASYNC_COMPLETE, null);

    }

    调用了Request#action。action里则调用了Processor#processSocketEvent,并传入操作码OPEN_READ

    case ASYNC_COMPLETE: {

    clearDispatches();

    if (asyncStateMachine.asyncComplete()) {

    processSocketEvent(SocketEvent.OPEN_READ, true);

    }

    break;

    }

    processSocketEvent

    调用SocketWrapper#processSocket

    protected void processSocketEvent(SocketEvent event, boolean dispatch) {

    SocketWrapperBase<?> socketWrapper = getSocketWrapper();

    if (socketWrapper != null) {

    socketWrapper.processSocket(event, dispatch);

    }

    }

    展开全文
  • 想书中着重介绍Servlet的原理,Servletconfig,servletContext用来做什么的,怎样的原理,以及Listener机制,加载顺序等等 可结合tomcat
  • book_recommend 基于协同过滤的书籍推荐
  • 1、java初学者,首先推荐看《java从入门到精通》很基础的 2、基础掌握之后去练习,做小项目swing之类的 3、开始学java web知识,将jdbc+servlet做个中级左右的项目出来 4、开始学SSH、SSM、SpringMVC等三大框架...
  • 尚学堂书籍推荐

    2012-11-13 11:26:24
    我网上找的尚学堂书籍推荐,希望对自学的朋友有帮助
  • 教材订购系统(jsp+servlet+mysql)完整源码+数据库源码+过程设计文档
  • jsp初学书籍推荐Welcome to the JSP Example Tutorial for Beginners. In last few posts, a wrote a lot about Java Servlet and got very good response from our readers. So I have started another series on ...

    jsp初学书籍推荐

    Welcome to the JSP Example Tutorial for Beginners. In last few posts, a wrote a lot about Java Servlet and got very good response from our readers. So I have started another series on JSP tutorials and this is the first post of the series.

    欢迎使用面向初学者的JSP示例教程。 在最近的几篇文章中,A撰写了许多有关Java Servlet的文章,并获得了读者的良好响应。 因此,我开始了有关JSP教程的另一个系列,这是该系列的第一篇文章。

    JSP示例教程 (JSP Example Tutorial)

    jsp example, jsp tutorial, jsp example programs, jsp programming, jsp tutorial for beginners

    In this JSP example tutorial, we will look into the basics of JSP, advantages of JSP over Servlets, Life Cycle of JSP, JSP API interfaces and Classes and where can we put JSP files in the web application.


    在本JSP示例教程中,我们将研究JSP的基础知识,JSP相对于Servlet的优势,JSP的生命周期,JSP API接口和类,以及在何处将JSP文件放入Web应用程序中。

    We will also look into the JSP Comments, Scriptlets, Directives, Expression, Declaration and JSP attributes in brief detail. Some of these topics are very important and we will look into them in more detail in future posts.

    我们还将简要介绍一下JSP注释,脚本,指令,表达式,声明和JSP属性。 其中一些主题非常重要,我们将在以后的文章中对其进行更详细的研究。

    JSP教程 (JSP Tutorial)

    1. What is JSP and why do we need JSP?

      什么是JSP,为什么我们需要JSP?
    2. Advantages of JSP over Servlets?

      JSP优于Servlet?
    3. Life cycle of JSP Page

      JSP页面的生命周期
    4. Life cycle methods of JSP

      JSP的生命周期方法
    5. Simple JSP Example with Eclipse and Tomcat

      Eclipse和Tomcat的简单JSP示例
    6. JSP Files location in Web Application WAR File

      Web应用程序WAR文件中的JSP文件位置
    7. JSP API Interfaces and Classes

      JSP API接口和类
    • JSP Comments

      JSP注释
    • JSP Scriptlets

      JSP脚本
    • JSP Expression

      JSP表达式
    • JSP Directives

      JSP指令
    • JSP Declaration

      JSP宣言
    • JSP transformed Servlet Source Code and Class File location in Tomcat

      JSP转换了Tomcat中的Servlet源代码和类文件位置
    • JSP init parameters

      JSP初始化参数
    • Overriding JSP init() method

      重写JSP init()方法
    • Attributes in a JSP

      JSP中的属性
      1. 什么是JSP,为什么我们需要JSP? (What is JSP and why do we need JSP?)

        JSP (JavaServer Pages) is server side technology to create dynamic java web application. JSP can be thought as an extension to servlet technology because it provides features to easily create user views.

        JSP Page consists of HTML code and provide option to include java code for dynamic content. Since web applications contain a lot of user screens, JSPs are used a lot in web applications. To bridge the gap between java code and HTML in JSP, it provides additional features such as JSP Tags, Expression Language, Custom tags. This makes it easy to understand and helps a web developer to quickly develop JSP pages.

        JSP (JavaServer Pages)是创建动态Java Web应用程序的服务器端技术。 JSP可以看作是Servlet技术的扩展,因为它提供了易于创建用户视图的功能。

        JSP页面由HTML代码组成,并提供选项以包含用于动态内容的Java代码。 由于Web应用程序包含许多用户屏幕,因此JSP在Web应用程序中使用很多。 为了弥合Java代码和JSP中HTML之间的鸿沟,它提供了其他功能,例如JSP标记,表达式语言,自定义标记。 这使它易于理解,并帮助Web开发人员快速开发JSP页面。

      2. JSP优于Servlet? (Advantages of JSP over Servlets?)

        • We can generate HTML response from servlets also but the process is cumbersome and error prone, when it comes to writing a complex HTML response, writing in a servlet will be a nightmare. JSP helps in this situation and provide us flexibility to write normal HTML page and include our java code only where it’s required.
        • JSP provides additional features such as tag libraries, expression language, custom tags that helps in faster development of user views.
        • JSP pages are easy to deploy, we just need to replace the modified page in the server and container takes care of the deployment. For servlets, we need to recompile and deploy whole project again.

        Actually Servlet and JSPs compliment each other. We should use Servlet as server side controller and to communicate with model classes whereas JSPs should be used for presentation layer.

        • 我们也可以从servlet生成HTML响应,但是过程繁琐且容易出错,当涉及到编写复杂HTML响应时,编写servlet将是一场噩梦。 JSP可在这种情况下提供帮助,并为我们提供了编写普通HTML页面的灵活性,并且仅在需要时才包含Java代码。
        • JSP提供了其他功能,例如标签库,表达语言,自定义标签,这些功能有助于更快地开发用户视图。
        • JSP页面易于部署,我们只需要替换服务器中已修改的页面即可,容器负责部署。 对于servlet,我们需要重新编译并再次部署整个项目。

        实际上,Servlet和JSP相互补充。 我们应该使用Servlet作为服务器端控制器并与模型类进行通信,而JSP应该用作表示层。

      3. JSP页面的生命周期 (Life cycle of JSP Page)

        JSP life cycle is also managed by container. Usually every web container that contains servlet container also contains JSP container for managing JSP pages.

        JSP pages life cycle phases are:

        • Translation – JSP pages doesn’t look like normal java classes, actually JSP container parse the JSP pages and translate them to generate corresponding servlet source code. If JSP file name is home.jsp, usually its named as home_jsp.java.
        • Compilation – If the translation is successful, then container compiles the generated servlet source file to generate class file.
        • Class Loading – Once JSP is compiled as servlet class, its lifecycle is similar to servlet and it gets loaded into memory.
        • Instance Creation – After JSP class is loaded into memory, its object is instantiated by the container.
        • Initialization – The JSP class is then initialized and it transforms from a normal class to servlet. After initialization, ServletConfig and ServletContext objects become accessible to JSP class.
        • Request Processing – For every client request, a new thread is spawned with ServletRequest and ServletResponse to process and generate the HTML response.
        • Destroy – Last phase of JSP life cycle where it’s unloaded into memory.

        JSP生命周期也由容器管理。 通常,每个包含servlet容器的Web容器还包含用于管理JSP页面的JSP容器。

        JSP页面的生命周期阶段为:

        • 转换 – JSP页面看起来不像普通的Java类,实际上是JSP容器解析JSP页面并转换它们以生成相应的servlet源代码。 如果JSP文件名是home.jsp,通常将其命名为home_jsp.java。
        • 编译 –如果转换成功,则容器会编译生成的servlet源文件以生成类文件。
        • 类加载 –将JSP编译为servlet类后,其生命周期类似于servlet,并且将其加载到内存中。
        • 实例创建 –将JSP类加载到内存中后,其对象将由容器实例化。
        • 初始化 –然后初始化JSP类,并将其从普通类转换为servlet。 初始化之后,JSP类可以访问ServletConfig和ServletContext对象。
        • 请求处理 –对于每个客户端请求,都会使用ServletRequest和ServletResponse生成一个新线程来处理和生成HTML响应。
        • 销毁 -JSP生命周期的最后阶段,将其卸载到内存中。
      4. JSP的生命周期方法 (Life cycle methods of JSP)

        JSP lifecycle methods are:

        1. jspInit() declared in JspPage interface. This method is called only once in JSP lifecycle to initialize config params.
        2. _jspService(HttpServletRequest request, HttpServletResponse response) declared in HttpJspPage interface and response for handling client requests.
        3. jspDestroy() declared in JspPage interface to unload the JSP from memory.

        JSP生命周期方法是:

        1. 在JspPage接口中声明的jspInit() 。 在JSP生命周期中仅调用一次此方法以初始化配置参数。
        2. 在HttpJspPage接口中声明的_jspService(HttpServletRequest请求,HttpServletResponse响应)和用于处理客户端请求的响应。
        3. 在JspPage接口中声明的jspDestroy ()可以从内存中卸载JSP。
      5. Eclipse和Tomcat的简单JSP示例 (Simple JSP Example with Eclipse and Tomcat)

        We can use Eclipse IDE for building dynamic web project with JSPs and use Tomcat to run it. Please read Java Web Applications tutorial to learn how can we easily create JSPs in Eclipse and run it in tomcat.

        A simple JSP example page example is:

        home.jsp

        <%@ page language="java" contentType="text/html; charset=US-ASCII"
            pageEncoding="US-ASCII"%>
        <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "https://www.w3.org/TR/html4/loose.dtd">
        <html>
        <head>
        <meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
        <title>First JSP</title>
        </head>
        <%@ page import="java.util.Date" %>
        <body>
        <h3>Hi Pankaj</h3><br>
        <strong>Current Time is</strong>: <%=new Date() %>
        
        </body>
        </html>

        If you have a simple JSP that uses only JRE classes, we are not required to put it as WAR file. Just create a directory in the tomcat webapps folder and place your JSP file in the newly created directory. For example, if your JSP is located at apache-tomcat/webapps/test/home.jsp, then you can access it in browser with URL https://localhost:8080/test/home.jsp. If your host and port is different, then you need to make changes in URL accordingly.

        我们可以使用Eclipse IDE通过JSP构建动态Web项目,并使用Tomcat运行它。 请阅读Java Web应用程序教程,以了解如何在Eclipse中轻松创建JSP并在tomcat中运行它。

        一个简单的JSP示例页面示例是:

        home.jsp

        如果您有一个仅使用JRE类的简单JSP,则不需要将其作为WAR文件放置。 只需在tomcat webapps文件夹中创建一个目录,然后将JSP文件放置在新创建的目录中。 例如,如果您的JSP位于apache- tomcat/webapps/test/home.jsp ,则可以在浏览器中使用URL https://localhost:8080/test/home.jsp 。 如果主机和端口不同,则需要相应地更改URL。

      6. Web应用程序WAR文件中的JSP文件位置 (JSP Files location in Web Application WAR File)

        We can place JSP files at any location in the WAR file, however if we put it inside the WEB-INF directory, we wont be able to access it directly from client.

        We can configure JSP just like servlets in web.xml, for example if I have a JSP example page like below inside WEB-INF directory:

        test.jsp

        <%@ page language="java" contentType="text/html; charset=US-ASCII"
            pageEncoding="US-ASCII"%>
        <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "https://www.w3.org/TR/html4/loose.dtd">
        <html>
        <head>
        <meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
        <title>Test JSP</title>
        </head>
        <body>
        Test JSP Page inside WEB-INF folder.<br>
        Init Param "test" value =<%=config.getInitParameter("test") %><br>
        HashCode of this object=<%=this.hashCode() %>
        </body>
        </html>

        And I configure it in web.xml configuration as:

        Then I can access it with both the URLs https://localhost:8080/FirstJSP/Test.do and https://localhost:8080/FirstJSP/Test1.do

        Notice that container will create two instances in this case and both will have their own servlet config objects, you can confirm this by visiting these URLs in browser.

        For Test.do URI, you will get response like below.

        Test JSP Page inside WEB-INF folder.
        Init Param "test" value =Test Value
        HashCode of this object=1839060256

        For Test1.do URI, you will get response like below.

        Notice the init param value in second case is null because it’s not defined for the second servlet, also notice the hashcode is different.
        If you will make further requests, the hashcode value will not change because the requests are processed by spawning a new thread by the container.

        Did you noticed the use of config variable in above JSP example but there is no variable declared, it’s because its one of the 9 implicit objects available in JSP page, read more about them at JSP Implicit Objects.

        我们可以将JSP文件放在WAR文件中的任何位置,但是,如果将其放在WEB-INF目录中,我们将无法直接从客户端访问它。

        我们可以像配置web.xml中的servlet一样配置JSP,例如,如果我在WEB-INF目录中具有如下所示的JSP示例页面:

        test.jsp

        <%@ page language="java" contentType="text/html; charset=US-ASCII"
            pageEncoding="US-ASCII"%>
        <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "https://www.w3.org/TR/html4/loose.dtd">
        <html>
        <head>
        <meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
        <title>Test JSP</title>
        </head>
        <body>
        Test JSP Page inside WEB-INF folder.<br>
        Init Param "test" value =<%=config.getInitParameter("test") %><br>
        HashCode of this object=<%=this.hashCode() %>
        </body>
        </html>

        我在web.xml配置中将其配置为:

        然后我可以使用URL https:// localhost:8080 / FirstJSP / Test.do和https:// localhost:8080 / FirstJSP / Test1.do来访问它

        注意,在这种情况下,容器将创建两个实例,并且两个实例都将具有自己的servlet配置对象,您可以通过在浏览器中访问这些URL来确认。

        对于Test.do URI,您将获得如下响应。

        Test JSP Page inside WEB-INF folder.
        Init Param "test" value =Test Value
        HashCode of this object=1839060256

        对于Test1.do URI,您将获得如下响应。

        注意第二种情况下的init参数值是null,因为它没有为第二个servlet定义,还请注意哈希码是不同的。
        如果您将发出进一步的请求,则哈希码值将不会更改,因为通过容器产生新线程来处理请求。

        你有没有注意到使用配置变量在上面的JSP的例子,但没有声明的变量,这是因为在JSP页面中提供的9个隐含对象的一个,以了解更多有关他们JSP隐式对象

      7. JSP API接口和类 (JSP API Interfaces and Classes)

        All the core JSP interfaces and classes are defined in javax.servlet.jsp package. Expression Language API interfaces are classes are part of javax.servlet.jsp.el package. JSP Tag Libraries interfaces and classes are defined in javax.servlet.jsp.tagext package.

        Here we will look into interfaces and classes of Core JSP API.

        所有核心JSP接口和类都在javax.servlet.jsp包中定义。 表达式语言API接口的类是javax.servlet.jsp.el软件包的一部分。 JSP标记库接口和类在javax.servlet.jsp.tagext包中定义。

        在这里,我们将研究Core JSP API的接口和类。

      • JspPage接口 (JspPage Interface)

        JspPage interface extends Servlet interface and declares jspInit() and jspDestroy() life cycle methods of the JSP pages.

        JspPage接口扩展了Servlet接口,并声明了JSP页面的jspInit()和jspDestroy()生命周期方法。

      • HttpJspPage接口 (HttpJspPage Interface)

        HttpJspPage interface describes the interaction that a JSP Page Implementation Class must satisfy when using the HTTP protocol. This interface declares the service method of JSP page for HTTP protocol as public void _jspService(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException.

        HttpJspPage接口描述了使用HTTP协议时JSP页面实现类必须满足的交互。 此接口声明用于HTTP协议的JSP页面的服务方法,因为public void _jspService(HttpServletRequest request,HttpServletResponse response)抛出ServletException,IOException

      • JspWriter抽象类 (JspWriter abstract Class)

        Similar to PrintWriter in servlets with additional facility of buffering support. This is one of the implicit variables in a JSP page with name “out”. This class extends java.io.Writer and container provide their own implementation for this abstract class and use it while translating JSP page to Servlet. We can get it’s object using PageContext.getOut() method. Apache Tomcat concrete class for JspWriter is org.apache.jasper.runtime.JspWriterImpl.

        与Servlet中的PrintWriter相似,具有额外的缓冲支持功能。 这是名称为“ out”的JSP页面中的隐式变量之一。 此类扩展了java.io.Writer,并且容器为该抽象类提供了自己的实现,并在将JSP页面转换为Servlet时使用它。 我们可以使用PageContext.getOut()方法获取它的对象。 JspWriter的Apache Tomcat具体类是org.apache.jasper.runtime.JspWriterImpl

      • JspContext抽象类 (JspContext abstract Class)

        JspContext serves as the base class for the PageContext class and abstracts all information that is not specific to servlets. The JspContext provides mechanism to obtain the JspWriter for output, mechanism to work with attributes and API to manage the various scoped namespaces.

        JspContext用作PageContext类的基类,并抽象出所有非特定于servlet的信息。 JspContext提供了获取用于输出的JspWriter的机制,与属性配合使用的机制以及用于管理各种作用域名称空间的API。

      • PageContext抽象类 (PageContext abstract Class)

        PageContext extends JspContext to provide useful context information when JSP is used for web applications. A PageContext instance provides access to all the namespaces associated with a JSP page, provides access to several page attributes, as well as a layer above the implementation details. Implicit objects are added to the pageContext automatically.

        当将JSP用于Web应用程序时,PageContext扩展了JspContext以提供有用的上下文信息。 PageContext实例提供对与JSP页面关联的所有命名空间的访问,提供对若干页面属性的访问,以及在实现详细信息上方的一层。 隐式对象会自动添加到pageContext中。

      • JspFactory抽象类 (JspFactory abstract Class)

        The JspFactory is an abstract class that defines a number of factory methods available to a JSP page at runtime for the purposes of creating instances of various interfaces and classes used to support the JSP implementation.

        JspFactory是一个抽象类,它定义了一些在运行时可用于JSP页面的工厂方法,目的是创建用于支持JSP实现的各种接口和类的实例。

      • JspEngineInfo抽象类 (JspEngineInfo abstract Class)

        The JspEngineInfo is an abstract class that provides information on the current JSP engine.

        JspEngineInfo是一个抽象类,提供有关当前JSP引擎的信息。

      • ErrorData最终类 (ErrorData final Class)

        Contains information about an error, for error pages.

        包含有关错误的信息,用于错误页面。

      • JspException类 (JspException Class)

        A generic exception known to the JSP container, similar to ServletException.If JSP pages throw JspException then errorpage mechanism is used to present error information to user.

        JSP容器已知的通用异常,类似于ServletException。如果JSP页面抛出JspException,则使用errorpage机制将错误信息呈现给用户。

      • JspTagException类别 (JspTagException Class)

        Exception to be used by a Tag Handler to indicate some unrecoverable error.

        标签处理程序将使用该异常来指示某些不可恢复的错误。

      • SkipPageException类 (SkipPageException Class)

        Exception to indicate the calling page must cease evaluation. Thrown by a simple tag handler to indicate that the remainder of the page must not be evaluated. This exception should not be thrown manually in a JSP page.

        指示调用页面的异常必须停止评估。 由简单的标记处理程序抛出,以指示不得评估页面的其余部分。 不应在JSP页面中手动引发此异常。

    • JSP注释 (JSP Comments)

      Since JSP is built on top of HTML, we can write comments in JSP file like html comments as

      <-- This is HTML Comment -->

      These comments are sent to the client and we can look it with view source option of browsers.

      We can put comments in JSP files as:

      <%-- This is JSP Comment--%>

      This comment is suitable for developers to provide code level comments because these are not sent in the client response.

      由于JSP建立在HTML之上,因此我们可以在JSP文件中编写注释,例如html注释,如下所示:

      <-- This is HTML Comment -->

      这些评论发送到客户端,我们可以使用浏览器的查看源选项来查看它。

      我们可以在JSP文件中添加如下注释:

      <%-- This is JSP Comment--%>

      此注释适合开发人员提供代码级注释,因为这些注释不会在客户端响应中发送。

    • JSP脚本 (JSP Scriptlets)

      Scriptlet tags are the easiest way to put java code in a JSP page. A scriptlet tag starts with <% and ends with %>.

      Any code written inside the scriptlet tags go into the _jspService() method.

      For example:

      <%
      Date d = new Date();
      System.out.println("Current Date="+d);
      %>

      Scriptlet标记是将Java代码放入JSP页面的最简单方法。 scriptlet标记以<%开头,以%>结束。

      在scriptlet标记内编写的任何代码都将放入_jspService()方法。

      例如:

    • JSP表达式 (JSP Expression)

      Since most of the times we print dynamic data in JSP page using out.print() method, there is a shortcut to do this through JSP Expressions. JSP Expression starts with <%= and ends with %>.

      <% out.print("Pankaj"); %> can be written using JSP Expression as <%= "Pankaj" %>

      Notice that anything between <%= %> is sent as parameter to out.print() method. Also notice that scriptlets can contain multiple java statements and always ends with semicolon (;) but expression doesn’t end with semicolon.

      由于大多数情况下,我们使用out.print()方法在JSP页面中打印动态数据,因此存在通过JSP表达式执行此操作的捷径。 JSP表达式以<%=开头,以%>结束。

      <% out.print("Pankaj"); %> 可以使用JSP表达式将<% out.print("Pankaj"); %>编写为<%= "Pankaj" %>

      注意, <%= %>之间的任何内容都作为参数发送到out.print()方法。 还要注意,scriptlet可以包含多个java语句,并且始终以分号(;)结尾,但表达式不以分号结尾。

    • JSP指令 (JSP Directives)

      JSP Directives are used to give special instructions to the container while JSP page is getting translated to servlet source code. JSP directives starts with <%@ and ends with %>

      For example, in above JSP Example, I am using page directive to to instruct container JSP translator to import the Date class.

      JSP指令用于在将JSP页面转换为Servlet源代码时向容器提供特殊说明。 JSP指令以<%@开头,以%>结尾

      例如,在上面的JSP示例中,我使用page指令来指示容器JSP转换器导入Date类。

    • JSP宣言 (JSP Declaration)

      JSP Declarations are used to declare member methods and variables of servlet class. JSP Declarations starts with <%! and ends with %>.

      For example we can create an int variable in JSP at class level as <%! public static int count=0; %>

      JSP声明用于声明servlet类的成员方法和变量。 JSP声明以<%!开头<%! 并以%>结尾。

      例如,我们可以在JSP中以<%! public static int count=0; %>级别创建int变量<%! public static int count=0; %> <%! public static int count=0; %>

    • JSP转换了Tomcat中的Servlet源代码和类文件位置 (JSP transformed Servlet Source Code and Class File location in Tomcat)

      Once JSP files are translated to Servlet source code, the source code (.java) and compiled classes both are place in Tomcat/work/Catalina/localhost/FirstJSP/org/apache/jsp directory. If the JSP files are inside other directories of application, the directory structure is maintained.

      For JSPs inside WEB-INF directory, its source and class files are inside Tomcat/work/Catalina/localhost/FirstJSP/org/apache/jsp/WEB_002dINF directory.

      Here is the source code generated for above test.jsp page.

      test_jsp.java

      /*
       * Generated by the Jasper component of Apache Tomcat
       * Version: Apache Tomcat/7.0.32
       * Generated at: 2013-08-21 03:40:59 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.WEB_002dINF;
      
      import javax.servlet.*;
      import javax.servlet.http.*;
      import javax.servlet.jsp.*;
      
      public final class test_jsp extends org.apache.jasper.runtime.HttpJspBase
          implements org.apache.jasper.runtime.JspSourceDependent {
      
        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 javax.el.ExpressionFactory _el_expressionfactory;
        private org.apache.tomcat.InstanceManager _jsp_instancemanager;
      
        public java.util.Map<java.lang.String,java.lang.Long> getDependants() {
          return _jspx_dependants;
        }
      
        public void _jspInit() {
          _el_expressionfactory = _jspxFactory.getJspApplicationContext(getServletConfig().getServletContext()).getExpressionFactory();
          _jsp_instancemanager = org.apache.jasper.runtime.InstanceManagerFactory.getInstanceManager(getServletConfig());
        }
      
        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 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=US-ASCII");
            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("\n");
            out.write("<!DOCTYPE html PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\" \"https://www.w3.org/TR/html4/loose.dtd\">\n");
            out.write("<html>\n");
            out.write("<head>\n");
            out.write("<meta http-equiv=\"Content-Type\" content=\"text/html; charset=US-ASCII\">\n");
            out.write("<title>Test JSP</title>\n");
            out.write("</head>\n");
            out.write("<body>\n");
            out.write("Test JSP Page inside WEB-INF folder.<br>\n");
            out.write("Init Param \"test\" value =");
            out.print(config.getInitParameter("test") );
            out.write("<br>\n");
            out.write("HashCode of this object=");
            out.print(this.hashCode() );
            out.write("\n");
            out.write("</body>\n");
            out.write("</html>");
          } catch (java.lang.Throwable t) {
            if (!(t instanceof javax.servlet.jsp.SkipPageException)){
              out = _jspx_out;
              if (out != null && out.getBufferSize() != 0)
                try { 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);
          }
        }
      }

      Notice following points in above servlet code;

      • The package of class starts with org.apache.jsp and if JSPs are inside other folders, it includes directory hierarchy too. Usually we dont care about it.
      • The generates servlet class is final and can’t be extended.
      • It extends org.apache.jasper.runtime.HttpJspBase that is similar to HttpServlet except that it’s internal to Tomcat JSP Translator implementation. HttpJspBase extends HttpServlet and implements HttpJspPage interface.
      • Notice the local variables at the start of _jspService() method implementation, they are automatically added by JSP translator and available for use in service methods, i.e in scriptlets.

      As a java programmer, sometimes it helps to look into the generated source for debugging purposes.

      将JSP文件转换为Servlet源代码后,源代码(.java)和已编译的类都将放置在Tomcat / work / Catalina / localhost / FirstJSP / org / apache / jsp目录中。 如果JSP文件位于应用程序的其他目录中,则将维护目录结构。

      对于WEB-INF目录中的JSP,其源文件和类文件位于Tomcat / work / Catalina / localhost / FirstJSP / org / apache / jsp / WEB_002dINF目录中。

      这是为以上test.jsp页面生成的源代码。

      test_jsp.java

      注意上面的servlet代码中的以下几点;

      • 该类的软件包以org.apache.jsp开头,如果JSP位于其他文件夹中,则它也包括目录层次结构。 通常我们不关心它。
      • 生成的Servlet类是最终的,不能扩展。
      • 它扩展了类似于HttpServlet的org.apache.jasper.runtime.HttpJspBase ,但它是Tomcat JSP Translator实现的内部。 HttpJspBase扩展了HttpServlet并实现了HttpJspPage接口。
      • 注意在_jspService()方法实现开始时的局部变量,它们由JSP转换程序自动添加,并且可用于服务方法(即scriptlet)中。

      作为Java程序员,有时出于调试目的,有助于查看生成的源代码。

    • JSP初始化参数 (JSP init parameters)

      We can define init parameters for the JSP page as shown in above example and we can retrieve them in JSP using config implicit object, we will look into implicit objects in JSP in more detail in future posts.

      我们可以为JSP页面定义初始化参数,如上面的示例所示,我们可以使用config隐式对象在JSP中检索它们,我们将在以后的文章中更详细地研究JSP中的隐式对象。

    • 重写JSP init()方法 (Overriding JSP init() method)

      We can override JSP init method for creating resources to be used by JSP service() method using JSP Declaration tags, we can override jspInit() and jspDestroy() or any other methods also. However we should never override _jspService() method because anything we write in JSP goes into service method.

      我们可以使用JSP声明标签覆盖JSP初始化方法来创建供JSP service()方法使用的资源,也可以覆盖jspInit()和jspDestroy()或任何其他方法。 但是,我们绝不应该重写_jspService()方法,因为我们在JSP中编写的所有内容都会进入服务方法。

    • JSP中的属性 (Attributes in a JSP)

      Apart from standard servlet attributes with request, session and context scope, in JSP we have another scope for attributes, i.e Page Scope that we can get from pageContext object. We will look it’s importance in custom tags tutorial. For normal JSP programming, we don’t need to worry about page scope.

      除了具有请求,会话和上下文范围的标准servlet属性外,在JSP中,我们还有另一个属性范围,即我们可以从pageContext对象获得的页面范围。 我们将在自定义标签教程中看到它的重要性。 对于普通的JSP编程,我们不必担心页面范围。

    • Thats all for JSP example tutorial for beginners. I hope it helps you in understanding the basic concepts of JSPs and help you in getting started. We will look into other JSP features in future posts.

      以上就是针对初学者的JSP示例教程。 我希望它能帮助您理解JSP的基本概念并帮助您入门。 我们将在以后的文章中探讨其他JSP功能。

      翻译自: https://www.journaldev.com/2021/jsp-example-tutorial-for-beginners

      jsp初学书籍推荐

    展开全文
  • 简介:本文为小编原创文章,首发于Java识堂,一个高原创,高收藏,有干货的微信公众号,一起成长,一起进步,欢迎关注前言分享知识和分享苹果是不一样的,苹果会越分越少,而... 小伙伴们还有其他推荐书籍吗?欢迎留言
  • 我们的数据源非常有限,因此我们几乎没有关于 Kafka 的详细信息可用于推荐其他书籍。 该应用程序查询作者的出版体裁和出版年限。 资料显示,卡夫卡以喜剧、悬疑和科幻小说的体裁写作,其著作出版时间为 1925 年至 ...
  • 主要介绍了10本Java架构师必读书籍,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • javaee 学习书籍推荐

    万次阅读 2017-06-01 11:13:30
    书籍推荐:一.技术 J2EE技术是架构师的基础。 1.《 Java 编程思想》初学Java时阅读这本书觉得好难,阅读第二遍时才觉得讲的很细致。这是一本不怕多读的好书。 2.《J2EE应用与BEA WebLogic Server》用实例...
  • jsp+servlet+jquery+bootstrap http://localhost:8080/books/login.jsp zuidaima 111111 添加新书籍 添加读者 图书分类列表 图书借阅信息 图书归还信息 图书管理员登录 http://localhost:8080/books/admin_login.jsp...
  • Servlet】 # servlet的入门概述

    千次阅读 2021-05-20 11:33:30
    1. Servlet 1.1 什么是Servlet? 是⼀个遵循Servlet开发的java类。Servlet是由服务器调⽤的,运⾏在服务器端。 1.2 HTTP协议 超⽂本传输协议(HTTP,HyperText Transfer Protocol)是互联⽹上应⽤最为⼴泛的⼀种⽹络...
  • 我是灼灼,一只初学Java的大一金渐层。 向往余秀华和狄兰·托马斯的疯狂,时常沉溺于将情感以诗相寄;追逐过王尔德、王小波的文字,后陷于毛姆和斯蒂芬·金不可自拔;热爱文学的浪潮,白日梦到底却...Servlet 为创建基.
  • 推荐书籍 《大话Java:程序设计从入门到精通》 —— 零基础 《Java核心技术·卷 I(原书第10版) : 基础知识》 —— 有一点基础 《Java核心技术·卷 II(原书第10版) : 高级特性》 —— 有一点基础《Java编程思想 ...
  • JAVA优秀书籍推荐

    2009-11-16 19:12:03
    JAVA优秀书籍推荐,纯属个人意见,仅供参考,
  • Servlet学习总结(一)

    2021-03-15 13:53:58
    一、Servlet介绍 1.Servlet概述 Servlet是JavaEE规范之一,是一个运行在web服务端的java小程序,它可以用于接收和响应客户端的请求。 2.Servlet的实现方法 1.实现Servlet接口 需要重写Servlet接口中所有的...
  • Java中的设计模式,书籍推荐

    千次阅读 2014-07-31 09:43:56
    在此我推荐一本好书,当我在火车上阅读了它不完整的电子版后,大有收获,为了支持正版,当时立刻决定买一本书来看。 作者有着深厚的技术功底,对每一个设计模式深入浅出的进行了研磨,值得我们反复翻阅。 他人...
  • JAVA方面的书籍推荐

    千次阅读 2017-01-16 09:20:34
    真的非常全,HTTP、DNS、CDN、静态化、Jetty、Tomcat、Servlet、Spring、MyBatis等等,什么都有,涉及知识面非常广,但又不像专门精讲某个知识点的书籍一样讲得非常深入,感觉这本书就是尽量去用短的篇幅讲清楚一些...
  • Java学习书籍推荐

    2018-04-26 10:31:32
    (1) Servlet规范 (2) JSP规范 (3) JavaBean规范 (4) JMS/Java Naming and Directory Interface(JNDI)/JDBC/Java Transaction API(JTA) (5) Struct2 + Spring + ibatis/hibernate/jdbc/ 四、模式与设计 1架构模式、 1...
  • 使用jsp+servlet、layui、mysql完成的图书馆系统,包含用户图书借阅、图书管理员、系统管理员界面,功能齐全。 开发工具为eclipse/IDEA,环境java8,tomcat9.0+,mysql为5.7(mysql8也行) 项目详细介绍 本图书...
  • 这篇开始我们要有些必要的基础,如HTML、java基础, 本章推荐书籍 《网络是怎样连接的》 《图解HTTP》 《Head First Servlets&JSP(第二版·中文版)》 一、需要简单了解http和tcp协议 Servlet基本上属于网站了,...
  • 基于servlet+jsp 个人博客系统

    千次阅读 多人点赞 2019-12-22 16:04:27
    人日志系统是基于我个人需要开发的,采用JSP+Servlet+JavaBean开发模式进行底层设计,前端采用h5前端框架和JavaScript的Ajax库进行前台页面设计,在持久层采用C3P0数据库连接池框架将数据库存入mysql。这个系统功能...
  • Java后端书籍推荐

    万次阅读 2017-05-09 14:09:31
    可能很多人嫌读书太花时间,曾经的我一度也是这么认为的,觉得一个程序员不敲代码,捧着一本大块头(编程类书籍往往比较厚)的书实在太花时间了。研究生期间虽然关注了很多公众号,也保持每天都看技术博客的习惯,...
  • 楼主正在自学servlet,然后学jsp,请大家推荐一本书
  • 一、书籍推荐 二、推荐线上免费教程 这章节推荐一些servlet和jsp学习资料,在实际开发中一般不会直接使用servet和jsp,但有些框架会用到servlet的内容,所以还是得学习一下的。jsp一般情况不会直接使用,因为它和...
  • 本文存在视频版本,请知悉 项目简介 ... 这次分享的也是毕设或课程设计选择一样很多的图书管理系统,适合新手...本系统基于JSP+Servlet+C3P0+Mysql。涉及技术少,易于理解,适合JavaWeb初学者学习使用。 难度等级:...
  • 我想就我自己读过的技术书籍中挑选出来一些,按照学习的先后顺序,推荐给大家,特别是那些想不断提高自己技术水平的Java程序员们。 一、Java编程入门类 对于没有Java编程经验的程序员要入门,随便读什么入门书籍都...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 8,791
精华内容 3,516
关键字:

servlet书籍推荐