jsp

jsp的访问原理：

浏览器发送请求，请求jsp，请求被tomcat服务器接收后，执行jspservlet将请求的jsp文件转义成对应的java文件也是servlet()，然后执行转义好的java文件。

jsp的基本语法和指令：

jsp的page指令

jsp的taglib指令

jsp的局部代码块

jsp的全局代码块

jsp的脚本端

jsp

<%@page language="java" %><%--申明转义的语言 --%>
<%@page import="java.util.*,java.lang.*"%><%--声明转义时导入的java的包文件 --%>
<%@page pageEncoding="utf-8"%><%--设置jsp的数据保存的编码格式 --%>
<%@page contentType="text/html;charset=utf-8"%><%--设置数据的响应编码格式 --%>
<%@page session="false"%>   <%--设置session的状态，默认为true，也可以转义为servlet文件中默认session是开启的，使用false关闭--%>
<%@page isErrorPage="true"%> <%--默认为false true表示开启exception异常对象的使用--%>
<%@page errorPage="error.jsp"%><%--设置当jsp运行出现异常错误的时候跳转指定的页面--%>
<%--page指令的作用：设置jsp转义的时候的一些配置信息。--%>

View Code

<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<%--

局部代码块
声明特点：<%使用局部代码块声明的java代码会被原样转译到_jspService方法中。也就是局部代码%>
 --%>
 <%
 int a=123;
System.out.println(a);
test();
 %>
 
<%--全局代码块 
           申明方式：<%!声明全局java代码%>
               特点：
               全局代码块中声明java代码，在被转译成jsp对应的java文件的全局代码
     作用：
             声明方法和全局变量等
     注意：
            使用全局代码块声明方法，使用局部代码块调用方法
--%>

<%!
int b=456;
public void test(){
    System.out.print("全局代码块声明");
}
%>


<%--
java脚本段、表达式
声明方式：<%变量名或者方法名()%> 
注意：
    在该表达式中不能使用分号结尾
--%>
<i><%=a %></i>

<%out.write(a+""); %>


<%--
注释
      html注释：会被转义也会被响应给浏览器，但是浏览器不会执行
      css注释会被转义也会被响应给浏览器，但是浏览器不会执行、
      js的注释：会被转义也会被响应给浏览器，但是浏览器不会执行
      java注释：会被转译，但不会执行
  jsp注释：注释内容不会被转义，也不会被执行。
         格式：<%--注释内容 ---

 --%>
<html>
<head>
   <style type="text/css">
   /*我是css注释*/
   </style>
   <script type="text/javascript">
   //我是js注释
   </script>
</head>
<%
//int i=3;

%>
<body>
<!-- 我是html注释 -->
<b>HTML注释</b>

</body>

</html>

View Code

<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<%--
        问题:
        发现不同的jsp页面会是使用相同的资源。如果将资源在每个jsp页面都单独声明
     则会 造成代码冗余量过高，不易于代码的维护和升级。
     
    解决：
       使用静态引入和动态引入的方式
  使用：
      静态引入
         《%@include file="要引入的资源的相对路径"%>
         特点：
         被引入的jsp文件和原有jsp文件被转译成一个java文件使用。
         注意：静态引入的相关jsp文件中不能声明同名变量。
         
     动态引入：
       <jsp:include page="static.jsp"></jsp:include>
       特点：  被引入的文件会被单独转译。原有jsp文件会调用被引入的jsp文件。
       注意：动态引入的相关jsp文件中可以声明同名变量。
      --%>
      <html>
      <head></head>
      <body>
      <h3>我是静态引入和动态引入学习</h3>
      <hr>
      <%--<i>&copy;网站声明，手机号：778899900，网站备案号</i> --%>
      <!-- 静态引入 -->
     <%--  <%@include file="static.jsp" %> --%>
     <!-- 动态引入 -->
     <jsp:include page="static.jsp"></jsp:include>
      </body>
      </html>

View Code

<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<% int b=3;%>
<i>&copy;网站声明，手机号：77888999100,网站备案号等</i><%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<% int b=3;%>
<i>&copy;网站声明，手机号：77888999100,网站备案号等</i>

View Code

forward

<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<%--jsp之间的资源转发：
问题： 
     不同的jsp在处理请求时，有可能会将当前的请求转发给另外的jsp进行处理。
     
 解决： 使用forword动作指令
 使用：
     <jsp:forword page="要转发的jsp的相对路径"></jsp:forword>
     特点：
       从当前jsp跳转到另外一个jsp页面
    注意：
      forward标签中除了<jsp:parm value="" name=""/>子标签以外不能出现其他内容，否则会报错
     df
     --%>
<html>
<head>

</head>     
<body>
<h3>forward转发标签学习</h3>
<%
 int a=1;
if(a>2){
%>
  <b>欢迎登录本网页</b>
  <%
}else{
  %>
  <!-- 转发其他jsp页面 -->
  <jsp:forward page="common.jsp">
   <jsp:param value="zhangsan" name="uname"/>
  </jsp:forward>
<% }
  %>
</body>     
</html>

View Code

<%@ 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 'common.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>
  <%
  String uname=request.getParameter("uname");
  System.out.println(uname);
  %>
  <body>
     <b>这为客官你的请求被屏蔽了，请及时续费</b> <br>
  </body>
</html>

View Code

object

<%@ page language="java" import="java.util.*" pageEncoding="UTF-8" isErrorPage="true"%>
<%--
      jsp的内置对象学习：
                       内置对象：
                       jsp在转译成其对应的java文件(也就是Servlt)时，
                                                 会默认在_jspService方法中创建几个对象
              特点：
                        我们可以在jsp页面中声明java局部代码块，在代码块中直接使用内置对象。
              对象：
             pageContext：页面上下文，此对象封存了另外八个对象。
                                          注意：一个jsp页面一个pageContext对象。pageContext对象每次请求都会重新创建。
             request:封存了请求相关数据，由服务器创建
             session：解决了同一个不同请求之间的数据共享问题
             application：ServvletContext对象，解决了不同用户之间的数据共享问题
             out:响应数据的对象，交于response对象，out对象底层使用了缓冲区。out对象的效率高于rsponse
             response：响应对象，设置编码
             page：代表当前被执行的jsp转译的java文件的对象。
             config：ServletConfig对象，使用了此对象完成资源的初始化
             exception:jsp页面的异常信息
            注意：
             对象的名字必须是转译好的java文件中声明的对象名。
   ff                                              
--%>        
<%
//获取请求数据
 String uname=request.getParameter("uname");
System.out.println(uname);

int a=3;
session.setAttribute("str", "我是sesssion");
%>

View Code

源码：

/*
 * Generated by the Jasper component of Apache Tomcat
 * Version: Apache Tomcat/8.5.34
 * Generated at: 2019-03-14 11:38:42 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 java_jsp extends org.apache.jasper.runtime.HttpJspBase
    implements org.apache.jasper.runtime.JspSourceDependent,
                 org.apache.jasper.runtime.JspSourceImports {


int b=456;
public void test(){
    System.out.print("全局代码块声明");
}

  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');
      out.write('\r');
      out.write('\n');
      out.write(' ');

 int a=123;
System.out.println(a);
test();
 
      out.write("\r\n");
      out.write(" \r\n");
      out.write("\r\n");
      out.write("\r\n");
      out.write("\r\n");
      out.write("\r\n");
      out.write("\r\n");
      out.write("\r\n");
      out.write("<i>");
      out.print(a );
      out.write("</i>\r\n");
      out.write("\r\n");
out.write(a+""); 
      out.write("\r\n");
      out.write("\r\n");
      out.write("\r\n");
      out.write("\r\n");
      out.write("<html>\r\n");
      out.write("<head>\r\n");
      out.write("   <style type=\"text/css\">\r\n");
      out.write("   /*我是css注释*/\r\n");
      out.write("   </style>\r\n");
      out.write("   <script type=\"text/javascript\">\r\n");
      out.write("   //我是js注释\r\n");
      out.write("   </script>\r\n");
      out.write("</head>\r\n");

//int i=3;


      out.write("\r\n");
      out.write("<body>\r\n");
      out.write("<!-- 我是html注释 -->\r\n");
      out.write("<b>HTML注释</b>\r\n");
      out.write("\r\n");
      out.write("</body>\r\n");
      out.write("\r\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 {
            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);
    }
  }
}

View Code

jsp负责页面展现，servlet负责业务逻辑处理。

资源路径总结：

相对路径：../../资源

绝对路径：/虚拟项目名/资源路径

相对路径：
* Servlet重定向jsp
* resp.sendRedirect("jsp的相对路径/servlet的别名");//重定向
* Servlet请求转发jsp
* req.getRequstDispatcher("jsp的相对路径/servlet的别名").forward(req,resp);//请求转发到jsp
* 注意：
* 以上两种写法其实都是相对路径，相对路径指的是从当前请求路径查找jsp所经过的路径。
*
* 服务器根目录：服务器的webapps目录路径 localhost:8080/
* 项目根目录：服务器的webbapps目录下项目路径 localhost:8080/jsp/
*
* 请求转发和重定向的绝对路径写法
* 重定向：
* 在重定向的路径中的第一个/表示服务器根目录
* 示例：resp.sendRectirect("/虚拟项目名/资源路径");//重定向jsp页面
* 请求转发：
* 在请求转发中第一个/表示项目根目录
* 实例：
* req.getRequestDispatcher("/资源路径").forward(req,resp);//请求转发到jsp页面。

package wq.servlet;

import java.io.IOException;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
/**
 * 相对路径：
 * Servlet重定向jsp
 *              resp.sendRedirect("jsp的相对路径/servlet的别名");//重定向
 *  Servlet请求转发jsp
 *             req.getRequstDispatcher("jsp的相对路径/servlet的别名").forward(req,resp);//请求转发到jsp
 *  注意：
 *      以上两种写法其实都是相对路径，相对路径指的是从当前请求路径查找jsp所经过的路径。
 *      
 *  服务器根目录：  服务器的webapps目录路径  localhost:8080/
 *  项目根目录：  服务器的webbapps目录下项目路径    localhost:8080/jsp/
 *  
 *  请求转发和重定向的绝对路径写法
 *  重定向：
 *           在重定向的路径中的第一个/表示服务器根目录
 *           示例：resp.sendRectirect("/虚拟项目名/资源路径");//重定向jsp页面
 *   请求转发：
 *          在请求转发中第一个/表示项目根目录
 *          实例：
 *              req.getRequestDispatcher("/资源路径").forward(req,resp);//请求转发到jsp页面。
 * @author Administrator
 *  http://localhost:8080/jsp/my
 *  http://localhost:8080/jsp/user/main.jsp
 */
public class MyServlet extends HttpServlet {
          @Override
        protected void service(HttpServletRequest req, HttpServletResponse resp)
                throws ServletException, IOException {
              //设置请求编码
              req.setCharacterEncoding("utf-8");
              //设置响应编码
              resp.setContentType("text/html;charset=utf-8");
              //获取请求信息
              String choice = req.getParameter("choice");
              //处理请求信息
              if("main".equals(choice)){
                  //resp.sendRedirect("/jsp/main.jsp");第一个/表示服务器根目录   绝对路径
                 req.getRequestDispatcher("main.jsp").forward(req, resp);
              }
              //响应处理数据
        }
}

View Code

问题：在jsp页面中进行资源之间的跳转，如果书写的是相对路径
这样会造成如果当前文件的路径发生变更，从当前路径查找资源的相对路径
都要重新进行书写。
解决：
将相对路径编程绝对路径
使用：
在jsp中路径编程绝对路径
实例：
<a href="/虚拟项目名/资源路径">访问名</a>
<a href="a/a.jsp">a.jsp</a>
注意：在Myeclipse中创建的jsp页面会自动生成路径处理代码basepath
而basepath的值为当前项目根目录，并且在head标签中使用了<base href="<%%>"basepath放入>
相当于将当前页面的资源全部默认定位从项目根目录开始查找。

注意：basePath方式和添加/方式只能二选一。
-->

  <base href="<%=basePath%>">

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

<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>


<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<!-- 
问题 ：在jsp页面中进行资源之间的跳转，如果书写的是相对路径
     这样会造成如果当前文件的路径发生变更，从当前路径查找资源的相对路径
    都要重新进行书写。
解决：
    将相对路径编程绝对路径
  使用：
      在jsp中路径编程绝对路径
  实例：
             <a href="/虚拟项目名/资源路径">访问名</a>
          <a href="a/a.jsp">a.jsp</a>
    注意：在Myeclipse中创建的jsp页面会自动生成路径处理代码basepath
           而basepath的值为当前项目根目录，并且在head标签中使用了<base href="<%%>"basepath放入>
            相当于将当前页面的资源全部默认定位从项目根目录开始 查找。
        
        注意：basePath方式和添加/方式只能二选一。
 -->
<html>
  <head>
    
    
    <title>My JSP 'path.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>
    <a href="a/a.jsp">a.jsp</a>
  </body>
</html>

View Code

<%@ 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 'a.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>
     <a href="/jsp/a/b/b.jsp">a.jsp</a>
     <a href="a/b/b.jsp">a.jsp</a>
  </body>
</html>

View Code

<%@ 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 'b.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>
    <a href="/jsp/path.jsp">path.jsp</a>
  </body>
</html>

View Code

jsp的内置对象的学习

特点：

我们可以在jsp页面中声明java局部代码块，在代码块中直接使用内置对象。

对象：

pageContext:页面上下文对象，此对象封存了另外八个对象。

注意：一个jsp页面一个pageContext对象。pageContext对象每次都会重新创建。

request:封存了请求相关数据。由服务器创建

session:解决了同一个不同请求之间的数据共享问题。

application：servletContext对象，解决了不同用户之间的数据共享问题。

out:响应数据的对象，交于response对象，out对象底层使用了缓冲区。out对象的效率高于response

response:响应对象，设置编码格式

page：代表当前被执行的jsp转译的java文件对象

config：servletconfig对象，使用此对象完成资源的初始化。

exception：jsp页面的异常对象，封存了异常信息。

注意：

对象的名字必须是转译好的java文件中声明的对象名。

posted @ 2019-03-14 08:10 wq9 阅读(345) 评论(0) 编辑收藏举报

刷新页面返回顶部

wq9

jsp

公告