服务器温习笔记(四)服务器端页面温习

悠悠 2022-12-20 12:55 138阅读 0赞

## JSP ##

### 什么是JSP ###

JSP(Java Server Pages): java服务器端页面  
可理解为: 一个特殊的页面，其中即可以定义html标签，也可以定义java代码。  
JSP可用于简化书写。

### JSP原理 ###

原理图解:  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h1ZXNoYW5mZWl0aWFu_size_16_color_FFFFFF_t_70_pic_center]  
如何理解jsp是一个servlet呢?  
![在这里插入图片描述][20201113091625356.png_pic_center]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h1ZXNoYW5mZWl0aWFu_size_16_color_FFFFFF_t_70_pic_center 1]

public final class index_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("javax.servlet.http");
        _jspx_imports_packages.add("javax.servlet.jsp");
        _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("\n");
          out.write("\n");
          out.write("<html>\n");
          out.write(" <head>\n");
          out.write(" <title>$Title$</title>\n");
          out.write(" </head>\n");
          out.write(" <body>\n");
          out.write(" $END$\n");
          out.write(" </body>\n");
          out.write("</html>\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，并且该上述代码会重写`_jspService`方法，然后帮各位猿友生成一些页面代码输出代码**:

out.write("\n");
          out.write("\n");
          out.write("<html>\n");
          out.write(" <head>\n");
          out.write(" <title>$Title$</title>\n");
          out.write(" </head>\n");
          out.write(" <body>\n");
          out.write(" $END$\n");
          out.write(" </body>\n");
          out.write("</html>\n");

查看HttpJspBase时可以直接查看Tomcat源码:  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h1ZXNoYW5mZWl0aWFu_size_16_color_FFFFFF_t_70_pic_center 2]  
也可在idea中直接查看:  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h1ZXNoYW5mZWl0aWFu_size_16_color_FFFFFF_t_70_pic_center 3]  
源码如下:

public abstract class HttpJspBase 
    extends HttpServlet implements HttpJspPage { 
    
        private static final long serialVersionUID = 1L;
    
        protected HttpJspBase() { 
        }
        ......
    
        @Override
        public abstract void _jspService(HttpServletRequest request,
                                         HttpServletResponse response)
            throws ServletException, IOException;
    }

由源码可以看出HttpJspBase是继承自HttpServlet。

### jsp脚本 ###

三种脚本定义以及其运行方式:

1.  <% 代码 %>：定义的java代码，在service方法中。service方法中可以定义什么，该脚本中就可以定义什么。
2.  <%! 代码 %>：定义的java代码，在jsp转换后的java类的成员位置。  
    notes: 在servlet中需要尽量少定义成员变量，避免引发线程安全问题
3.  <%= 代码 %>：定义的java代码，会输出到页面上。输出语句中可以定义什么，该脚本中就可以定义什么。

### jsp原理 ###

#### 指令 ####

作用: 用于配置JSP页面，导入资源文件  
格式:  
<%@ 指令名称 属性名1=属性值1 属性名2=属性值2 … %>  
分类:

1.  page : 配置JSP页面  
    contentType：等同于response.setContentType()；  
    1)设置响应体的mime类型以及字符集  
    2)设置当前jsp页面的编码（只能是高级的IDE才能生效，如果使用低级工具，则需要设置pageEncoding属性设置当前页面的字符集）  
    import: 导包  
    errorPage: 当前页面发生异常后，会自动跳转到指定的错误页面  
    isErrorPage: 标识当前页面是否是错误页面，如果是错误页面可以打印基本错误信息。  
    true：是，可以使用内置对象exception。  
    false：否。默认值。不可以使用内置对象exception。  
    如下代码是一个典型的

<%@ page import="java.util.ArrayList" %>
    <%@ page import="java.util.List" %>
    <%@ page contentType="text/html;charset=UTF-8"  errorPage="500.jsp" 
             pageEncoding="GBK" language="java" buffer="8kb" %>

1.  include ： 页面包含的。导入页面的资源文件

<%@include file="top.jsp"%>

1.  taglib ： 导入资源

<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>

prefix：前缀，自定义的。

### 注释 ###

1.  html注释：  
    :只能注释html代码片段
2.  jsp注释：推荐使用  
    <%-- --%>：可以注释所有

### jsp内置对象 ###

在jsp页面中不需要获取和创建，可以直接使用的对象， jsp一共有9个内置对象。  
一共有9个：

变量名					真实类型						作用
    pageContext				PageContext					当前页面共享数据，还可以获取其他八个内置对象
    request					HttpServletRequest			一次请求访问的多个资源(转发)
    session					HttpSession					一次会话的多个请求间
    application				ServletContext				所有用户间共享数据
    response				HttpServletResponse			响应对象
    page					Object						当前页面(Servlet)的对象  this
    out						JspWriter					输出对象，数据输出到页面上
    config					ServletConfig				Servlet的配置对象
    exception				Throwable					异常对象

#### request ####

request 对象的作用与使用方法与请参考小猿的文章[服务器温习笔记(二)Tomcat之HttpServlet。][Tomcat_HttpServlet]

#### response ####

response对象的作用与使用方法与请参考小猿的文章[服务器温习笔记(二)Tomcat之HttpServlet。][Tomcat_HttpServlet]

#### out ####

字符输出流对象。可以将数据输出到页面上。和response.getWriter()类似  
response.getWriter()和out.write()的区别：  
在tomcat服务器真正给客户端做出响应之前，**会先找response缓冲区数据，再找out缓冲区数据**。  
\*\* response.getWriter()数据输出永远在out.write()之前\*\*。

#### 其他 ####

其他重点内置对象都在小猿的服务器温习系列中都有提到，具体的方法可参考小猿博客，若想进一步了解请参考其他网站。

## EL 表达式 ##

### 什么是 EL表达式 ###

Expression language 表达式语言  
EL是用于替换和简化jsp页面中的java

### EL语法 ###

${ 表达式}

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h1ZXNoYW5mZWl0aWFu_size_16_color_FFFFFF_t_70_pic_center 4]  
notes: jsp默认支持el表达式，如果要忽略el表达式，则需要需要失职jsp指令中: 配置

isELIgnored="true"

设置为上面的代码，则jsp页面中会忽略所有的el表达式。  
$\{表达式\} : 忽略当前这个el表达式。

## EL表达式使用 ##

### 运算 ###

运算符：  
1)算数运算符：+ - \* /(div) %(mod)  
2)比较运算符：> < >= <= == !=  
3)逻辑运算符：&&(and) ||(or) !(not)  
4)空运算符：empty  
功能：用于判断字符串、集合、数组对象是否为null或者长度是否为0  
$\{empty list\}:判断字符串、集合、数组对象是否为null或者长度为0  
$\{not empty str\}:表示判断字符串、集合、数组对象是否不为null 并且 长度>0。

### 获取值 ###

1)语法  
$\{域名称.键名\}：从指定域中获取指定键的值  
域名称：

pageScope		--> pageContext
    requestScope 	--> request
    sessionScope 	--> session
    applicationScope --> application（ServletContext）

举例：`在request域中存储了name=张三`  
获取：`${requestScope.name}`  
2) 键 名 ： 表 示 依 次 从 最 小 的 域 中 查 找 是 否 有 该 键 对 应 的 值 ， 直 到 找 到 为 止 。 3 ) . 获 取 对 象 、 L i s t 集 合 、 M a p 集 合 的 值 对 象 ： \{键名\}：表示依次从最小的域中查找是否有该键对应的值，直到找到为止。 3). 获取对象、List集合、Map集合的值 对象： 键名：表示依次从最小的域中查找是否有该键对应的值，直到找到为止。3).获取对象、List集合、Map集合的值对象：\{域名称.键名.属性名\}  
**本质上会去调用对象的getter方法**  
List集合：$\{域名称.键名\[索引\]\}  
Map集合:  
$\{域名称.键名.key名称\}  
$\{域名称.键名\[“key名称”\]\}

1.  隐式对象  
    el表达式中有11个隐式对象  
    pageContext：  
    获取jsp其他八个内置对象

${ pageContext.request.contextPath}：动态获取虚拟目录

## JSTL标签 ##

### 什么是JSTL ###

JavaServer Pages Tag Library JSP标准标签库，是由Apache组织提供的开源的免费的jsp标签 <标签>  
作用：用于简化和替换jsp页面上的java代码

### 常用的JSTL标签 ###

1.  if:相当于java代码的if语句  
    属性：  
    test 必须属性，接受boolean表达式  
    **如果表达式为true，则显示if标签体内容，如果为false，则不显示标签体内容**  
    一般情况下，test属性值会结合el表达式一起使用  
    注意：  
    c:if标签没有else情况，想要else情况，则可以在定义一个c:if标签
2.  choose:相当于java代码的switch语句  
    1)使用choose标签声明 相当于switch声明

1.  使用when标签做判断 相当于case
2.  使用otherwise标签做其他情况的声明 相当于default

1.  foreach:相当于java代码的for语句  
    如遍历数组 :

<%--
        foreach:相当于java代码的for语句
            1. 完成重复的操作
                for(int i = 0; i < 10; i ++){ 
    
                }
                * 属性：
                    begin：开始值
                    end：结束值
                    var：临时变量
                    step：步长
                    varStatus:循环状态对象
                        index:容器中元素的索引，从0开始
                        count:循环次数，从1开始
            2. 遍历容器
                List<User> list;
                for(User user : list){ 
    
                }
                * 属性：
                    items:容器对象
                    var:容器中元素的临时变量
                    varStatus:循环状态对象
                        index:容器中元素的索引，从0开始
                        count:循环次数，从1开始
    --%>
    
    <%
        ArrayList<User> users = new ArrayList<User>();
        users.add(new User("张三",18,new Date()));
        users.add(new User("李四",23,new Date()));
        users.add(new User("王五",38,new Date()));
        users.add(new User("周六",35,new Date()));
        request.setAttribute("users",users);
    %>
    <c:forEach begin="1" end="10"  var="i"  step="2" varStatus="s">
        ${ s.index} ${ s.count} ${ i} <br/>
    </c:forEach>
    
    <table border="2" width="500" align="center" >
        <tr>
            <th>编号</th>
            <th>姓名</th>
            <th>年龄</th>
            <th>生日</th>
        </tr>
        <c:forEach  items="${users}" var="user"  varStatus="s">
            <c:if test="${s.count%2 !=0}">
                <tr bgcolor="red">
                    <td>${ s.count}</td>
                    <td>${ user.username}</td>
                    <td>${ user.age}</td>
                    <td>${ user.birthDay}</td>
                </tr>
            </c:if>
    
            <c:if test="${s.count%2 == 0}">
                <tr bgcolor="green">
                    <td>${ s.count}</td>
                    <td>${ user.username}</td>
                    <td>${ user.age}</td>
                    <td>${ user.birthDay}</td>
                </tr>
            </c:if>
        </c:forEach>
    </table>

## MVC开发模式 ##

### jsp历史 ###

早期只有servlet ，只能使用response输出标签数据，非常麻烦。  
后来出现了jsp  
jsp优点 : 简化了Servlet的开发.  
jsp缺点 : 如果过度使用jsp，在jsp中即伴随大量的java代码和html代码，造成难于维护，难于分工协作。  
随着技术的发展，java的web开发借鉴mvc模式，使得程序的设计更加合理。

### 什么是MVC ###

MVC : Model View Controller 模型视图控制器。

1.  M：Model，模型。JavaBean  
    完成具体的业务操作，如：查询数据库，封装对象
2.  V：View，视图。JSP  
    展示数据
3.  C：Controller，控制器。Servlet  
    获取用户的输入  
    调用模型  
    将数据交给视图进行展示  
    优缺点：
4.  优点：  
    1) 耦合性低，方便维护，可以利于分工协作  
    2) 重用性高
5.  缺点：  
    使得项目架构变得复杂，对开发人员要求高

## 三层架构 ##

### 三层结构介绍 ###

三层架构是指的是软件设计架构。

1.  界面层(表示层):用户看的界面。用户可以通过界面上的组件和服务器践行交互。
2.  业务逻辑层：处理业务逻辑
3.  数据访问层：操作数据存储文件

### 图解三层架构 ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h1ZXNoYW5mZWl0aWFu_size_16_color_FFFFFF_t_70_pic_center 5]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h1ZXNoYW5mZWl0aWFu_size_16_color_FFFFFF_t_70_pic_center]: /images/20221120/a481a69395b84df5848909ba20962706.png
[20201113091625356.png_pic_center]: /images/20221120/d16a71751357412eb42b55b3e4cd5e41.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h1ZXNoYW5mZWl0aWFu_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221120/deb5dc333eb94fdca63d79b678335d5c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h1ZXNoYW5mZWl0aWFu_size_16_color_FFFFFF_t_70_pic_center 2]: /images/20221120/6845ac65d1194ba986bc5efe553c48c1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h1ZXNoYW5mZWl0aWFu_size_16_color_FFFFFF_t_70_pic_center 3]: /images/20221120/a99eba94b97b48a5a611609cfa651180.png
[Tomcat_HttpServlet]: https://blog.csdn.net/xueshanfeitian/article/details/109483799
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h1ZXNoYW5mZWl0aWFu_size_16_color_FFFFFF_t_70_pic_center 4]: /images/20221120/513163df1891430ca0af5d44a82cc563.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h1ZXNoYW5mZWl0aWFu_size_16_color_FFFFFF_t_70_pic_center 5]: /images/20221120/78705004bb1349c9844ab2933a492b26.png