jsp学习笔记:jsp和servlet的关系,jsp的生命周期,jsp页面中嵌入java代码

1.jsp是什么
jsp全称Java Server Pages,是一种动态网页开发技术。
jsp servlet php asp等属于动态网页技术
jsp页面是以.jsp结尾的文件

.html文件是静态页面
.jsp 文件是动态页面

jsp页面允许我们在html代码中嵌入java代码,这样我们就可以在html中使用java代码来完成的功能了

简单的理解,jsp就是html页面+java代码
但是jsp中能写的内容还不止这些,可以包含如下内容:
	1.html标签
	2.css
	3.javascript
	4.java代码
	5.EL表达式
	6.引入并使用其他标签库,例如jstl标签库等

所以jsp页面里面除了能写之前在html里面写东西之外,还可以写很多和java相关的东西,java代码、el表达式、动态标签库等(这些东西的本质都是执行java代码)

注意:jsp页面中可以只有java代码,也可以一句java代码也没有,也可以一句html页面也没有

使用jsp页面完成一个HelloWorld程序
    <%@ page language="java" contentType="text/html; charset=UTF-8"
        pageEncoding="UTF-8"%>
    <!DOCTYPE html>
    <html>
    <head>
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
    <title>test2</title>
    </head>
    <body>
        <%
            for(int i=0;i<5;i++){
                out.println("hello World");
            }
        %>
    </body>
    </html>

2.jsp的运行
浏览器可以直接运行html页面,但是不能直接运行jsp页面,jsp是需要在拥有jsp引擎的服务器中运行的,例如tomcat服务器
所以jsp是运行在服务器端的,运行完之后,把动态生成的html页面再使用io流写回给浏览器,浏览器接收并且解析后再呈现出来效果.

3.jsp和servlet的关系
简单的讲,一个jsp页面就是一个servlet
jsp页面第一次被访问的时候,会被tomcat服务器编译成一个java类,这个java默认继承HttpJspBase类,而HttpJspBase类是HttpServlet的子类。
我们编写的jsp页面最终就被tomcat服务器编译成了一个HttpServlet的子类,所以说jsp本身就是一个servlet,那么jsp为什么是需要运行在tomcat服务器中原因也就很好理解了。
jsp页面被tomcat服务器编译成的java文件及其class文件保存在tomcat服务器里面的work目录中,在这里的代码中,我们还可以看见它是如何使用io流把生成的html页面代码一行一行写回给浏览器的。
总的来说:
jsp 本质上来说就是servlet.
1.jsp间接继承了HttpServlet。
2.jsp页面对应的java程序。什么是够生成的?
当第一次访问jsp页面生成对应的java文件和字节码文件;
当多次访问jsp页面使用生成好的java文件和字节码文件;
当jsp页面发生修改后如果第一次访问。tomcat会重新生成java文件和字节码文件。

4.jsp的生命周期

4.1 编译阶段
	客户端第一次访问jsp的时候,服务器会把这个jsp页面翻译成对应的java文件,然后把java文件编译成对应的class文件

	hello.jsp--->hello_jsp.java--->hello_jsp.class

	观察这个java文件的内容可知,这就是一个servlet

4.2 初始化阶段
	客户端第一次访问jsp页面,在服务器把jsp翻译成java文件并编译成class文件后,服务器会加载这个class文件内容,并且创建出此servlet对象(因为jsp就是一个servlet),然后调用这个servlet对象中的init方法进行初始化
	
	如果我们想给jsp进行自定义的初始化内容,只要在【jsp声明】中重写jspInit()方法即可。(查看源码可知)
	例如:
		<%!
			public void jspInit(){
				System.out.println("我的jsp自定义初始化");
			}
		%>


4.3 执行阶段
	客户端访问jsp页面的时候,服务器会调用其对应的servlet对象中的一个指定方法_jspService(request,response)
	就是在这个_jspService(request,response)方法中使用io流,把动态生成的html一行一行写给了浏览器

	注:本来是调用servlet对象中的service方法的,但是在HttpJspBase中重写的service方法中又调用了这个_jspService(request,response)方法
    httpServlet---->doGet
4.4 销毁阶段
	当服务器正常关闭的时候,jsp对应的servlet对象会被销毁,并且调用servlet中的destroy方法

	如果我们在jsp对应的servlet对象销毁时完成一些工作时,只要在jsp声明中重写jspDestroy()方法即可。(查看源码可知)
	例如:
		<%!
			public void jspDestroy(){
				System.out.println("我的jsp进行销毁");
			}
		%>


4.5 客户端访问jsp页面的特点
	通过上述jsp的生命周期可知,写完一个jsp项目之后,第一次部署运行的时候,整个项目的运行速度会慢一些,因为第一次访问运行jsp的时候,需要先翻译成.java文件然后再编译成.class文件,最后再运行,这个过程会耗费一些时间,但是第二访问运行的时候就会比较快了.

5.jsp页面中嵌入java代码
jsp的脚本元素 jsp的指令元素 jsp的动作元素
5.1 jsp的脚本元素

  • 第一种:表达式(expression) 形式:<%= %>

     	例如:<%="hello" %>
     		 <%=1+1 %>
     		 <%=s.getName() %>
    
     	将来翻译到java文件中的位置:
     	_jspService方法中的out.print(..)里面的参数.
     	例如上面那几个例子会翻译成
     	out.print("hello");
     	out.print(1+1);
     	out.print(s.getName());
     	
     	所以System.out.prntln()这个方法的参数可以写什么,那么我们这个jsp页面中表达式里面就可以写什么.
    
     	注意:在jsp中的表达式里面不需要加;号。
    
  • 第二种:脚本(scriptlet) 形式:<% … %>
    或者
    <%

    %>

     	例如:
     		 <%
     		 Student s = new Student();
    
     		 String name = "tom";
    
     		 String username = s.getName();
    
     		 List<String> list = new ArrayList<String>();
     		 list.add("hello")
     		 %>
          思考:为什么 List接口和ArrayList类报错?
          原因: 没有使用 import 导入接口和类
      
     	 将来翻译到java文件中的位置:
     	 脚本中的代码将来会被直接翻译到_jspService这个方法中.
     	 
     	 在一个普通的方法中我们可以写什么样的代码,那么在脚本中就可以写什么样的代码.
    
     	 注意:在脚本中所写的代码,代码的最后是要加上;号的.因为我们在一个方法里面所写的没一句代码后面都是要加;号。
     	 在脚本声明的变量,我们是可以在表达式里面使用的,但是要注意要先声明变量再使用变量.只要查看脚本和表达式分别翻译到java文件中的位置,就可以很清楚的认识到这一点.
    
  • 第三种:声明(declaration) 形式:<%!

    %>

     	例如:
     	 <%!
     		private String name;
     
     		public String go(){
     			System.out.println("hello world "+name);
     			return "this is go()";
     		}
     	 
     	 %>
    
     	 将来翻译到java文件中的位置:
     	  直接将声明中的代码翻译到java文件里面所定义的类中。
     	  所以我们直接可以在一个类中写什么,就可以在声明中写什么.(一般在声明中会去定义一些类中的成员变量或者方法)
    
     	注意:这里面的代码,定义变量的时候要加;号,定义方法的时候不用加;号,这是和我们写一个java类语法是一样的。
    

    5.2 jsp的指令元素
    jsp的指令是给jsp引擎看的,让jsp引擎在翻译jsp页面成java文件的时候,知道需要注意哪些地方的设置.比如页面中的编码、页面中脚本里面所用的编程语言、翻译的java文件中需要引入哪些其他包下的java类等等.

     写法: <%@指令名字  属性="值" ..  %>
    
     指令包含page include taglib三种
    
     (1)page指令:
         //表示当前页面中的编程语言是java,目前这个属性值只能写java
         language="java"
    
         //在当前页面中要引入哪些包下的类.
         import="java.util.HashMap"
         import="java.util.HashMap,java.sql.Connection"
    
         //设置jsp页面文件保存时候所用的编码
         pageEncoding="UTF-8"
         //设置服务器将来使用io把jsp页面内容一行一行的输出给浏览器的时候,使用什么编码向浏览器输出.
         contentType="text/html; charset=UTF-8"
    
         //设置jsp页面被翻译成java文件的时候,java文件中的类要继承那个父类.这个属性不用设置,jsp引擎会给它一个默认的父类去继承的.
         extends=""
    
         //设置当前这个jsp页面是否支持session对象的使用.默认是支持的.
         session="true"
    
         //设置jsp页面是否是线程安全的.
         isThreadSafe="true"
    
         //如果a.jsp页面中设置了errorPage="b.jsp",那么a.jsp页面在运行的时候一旦出错,就会自动跳转到b.jsp里面.
             a.jsp中设置errorPage="b.jsp"
         
         //如果一个页面中设置了isErrorPage="true",那么就表示这个页面是用来专门显示错误信息的页面.然后在这个页面中就能够使用到隐藏对象exception来显示出错误的信息了.(需要使用jsp的内置对象)
         isErrorPage=""
             b.jsp中设置isErrorPage="true"
    
     (2)include指令:
         <%@ include file="" %>
         作用:在当前页面中使用include指令可以把另外一个页面的内容引入到当前页面。
         引入的位置:指令位置。
         一个页面包含/引入另外一个页面有俩种方式:静态包含 动态包含。
         这个include指令就属于静态包含
         
         静态包含特点:例如a.jsp页面中静态包含了b.jsp页面,那么在翻译期间,jsp引擎在翻译a.jsp成为一个a_jsp.java文件的时候,发现jsp页面中有include指令,这时候jsp引擎就会把被包含的页面b.jsp中内容原封不动的拿到a_jsp.java中,然后用io输出出去.
         
     (3)taglib指令:
         作用:在当前jsp页面中引入一些特殊的标签库.比如jstl标签库、struts2标签库等等.
         放在JSTL标签库内容中讲
    

    5.3 jsp的动作元素
    1.定义格式: <jsp:action_name attribute=“value” />

     (1) jsp:useBean 寻找或者实例化一个JavaBean。
         <jsp:useBean id="s" class="com.briup.bean.Student" scope="request"></jsp:useBean>
         相当于代码:
         <%
             Student s = null;
             s = (Student)request.getAttribute("s");
             if(s==null){
                 s = new Student();
                 request.setAttribute("s",s);
             }
         %>
    
    (2) jsp:setProperty 设置JavaBean的属性。
        <jsp:setProperty property="name" value="tom" name="s"/>
        相当于代码:
        <%
         Student s = (Student)pageContext.getAttribute("s");
         s.setName("tom");
        %>
    
    (3) jsp:getProperty 输出某个JavaBean的属性。
        <jsp:getProperty property="name" name="s"/>
        相当于代码:
        <%
         Student s = (Student)pageContext.getAttribute("s");
         out.write(s.getName());
        %>
     	      
    (4)jsp:forward 把请求转到一个新的页面。
       <jsp:forward page="target.jsp"></jsp:forward> //页面跳转
    
        //跳转的同时还可以传参数
        <jsp:forward page="target.jsp?name=tom"></jsp:forward>
        或者
        <jsp:forward page="target.jsp">
             <jsp:param value="tom" name="name"/>
        </jsp:forward>
    	   
    (5) jsp:param 向页面或对象传递参数
        <jsp:param value="tom" name="name"/> //这个动作元素专门是传参数使用的
    
        //动态包含
        <jsp:include page="foot.jsp">
             <jsp:param value="lisi" name="name"/>
        </jsp:include>
        注意不能使用url?name=tom这种方式传
    
        动态包含特点:在把jsp文件翻译成java文件的期间,动态包含并不会去把被包含的页面原封不动的拿过来,而是会把动态包含这个标签翻译成一个方法的调用,将来运行页面调用到这个方法的时候才会去拿被包含页面的内容.同时还可以给动态包含的页面传参数.静态包含是不能传参数的。
    
        注意:总结和对比后,分析出动态包含和静态包含各自的特点,以及哪一个执行的效率更快一些.
             答:静态包含执行效率会更快
      
    (6) jsp:element 定义动态XML元素
       <jsp:element name="font">//使用jsp的动作元素向浏览器输出一个标签
     	<jsp:attribute name="color">blue</jsp:attribute>
     	<jsp:body>hello world</jsp:body>
       </jsp:element>
    
        这个效果相当于在页面代码中直接写上
        <font color="blue">hello world</font>
        或者:
        <%
        out.println("<font color='blue'>hello world</font>");
        %>
    
  • 0
    点赞
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值