Java-Jsp基础教程

淩亂°似流年 2023-10-02 18:58 15阅读 0赞

### 介绍 ###

学习JSP 基础教程前 必须会 java Servlet 或者SSM

**什么是Java Server Pages?**

JSP全称Java Server Pages，是一种动态网页开发技术。它使用JSP标签在HTML网页中插入Java代码。标签通常以<%开头以%>结束。

JSP是一种Java servlet，主要用于实现Java web应用程序的用户界面部分。网页开发者们通过结合HTML代码、XHTML代码、XML元素以及嵌入JSP操作和命令来编写JSP。

JSP通过网页表单获取用户输入数据、访问数据库及其他数据源，然后动态地创建网页。

JSP标签有多种功能，比如访问数据库、记录用户选择信息、访问JavaBeans组件等，还可以在不同的网页中传递控制信息和共享信息

**为什么使用JSP？**

JSP程序与CGI程序有着相似的功能，但和CGI程序相比，JSP程序有如下优势：

*  性能更加优越，因为JSP可以直接在HTML网页中动态嵌入元素而不需要单独引用CGI文件。
 *  服务器调用的是已经编译好的JSP文件，而不像CGI/Perl那样必须先载入解释器和目标脚本。
 *  JSP基于Java Servlets API，因此，JSP拥有各种强大的企业级Java API，包括JDBC，JNDI，EJB，JAXP等等。
 *  JSP页面可以与处理业务逻辑的servlets一起使用，这种模式被Java servlet 模板引擎所支持。

最后，JSP是Java EE不可或缺的一部分，是一个完整的企业级应用平台。这意味着JSP可以用最简单的方式来实现最复杂的应用。

**JSP的优势**

以下列出了使用JSP带来的其他好处：

*  与ASP相比：JSP有两大优势。首先，动态部分用Java编写，而不是VB或其他MS专用语言，所以更加强大与易用。第二点就是JSP易于移植到非MS平台上。
 *  与纯 Servlets相比：JSP可以很方便的编写或者修改HTML网页而不用去面对大量的println语句。
 *  与SSI相比：SSI无法使用表单数据、无法进行数据库链接。
 *  与JavaScript相比：虽然JavaScript可以在客户端动态生成HTML，但是很难与服务器交互，因此不能提供复杂的服务，比如访问数据库和图像处理等等。
 *  与静态HTML相比：静态HTML不包含动态信息。
    
    我们将会带您一步一步地来搭建JSP运行环境，这需要有一定的Java基础。

### JSP 开发环境搭建 ###

需要配置 java JDK

需要配置 Tomcat 来解析 JSP页面到到游览器

以上都配置过了 那么我们来使用IDEA可和Tomcat关联

以上不会可以在我博客里找对应的文章学

创建一个名字java\_Web 的 Maven Web的项目

进入java\_Web项目->点击Run—EDit Configurations…

![在这里插入图片描述][58bd10c4727a494f9a08a0d0eb27d566.png]

2.点击左侧“+”号，找到Tomcat Server—Local

![在这里插入图片描述][d4c8a392352f4b93b2a03106ef52e1ed.png]

![在这里插入图片描述][d206818bba2541b7a04b288be3945e0b.png]

![在这里插入图片描述][982ddd61ce4e4f1bb5a27d557c4678a7.png]

![在这里插入图片描述][3ef287993cd947e999d3b617fc908895.png]

![在这里插入图片描述][d31d951608d041ddac0e0d87f5ca8c5b.png]

![在这里插入图片描述][3facf3dde3bc47dbbf66226344381a6d.png]  
![在这里插入图片描述][2ec049d61e3249cabcb68717347d9d4e.png]

然后 apply -> ok

![在这里插入图片描述][2e17e05bb6cf45bc92c12482222a9dfa.png]

点击 绿色三角 运行Tomcat

![在这里插入图片描述][b3b6394b98f547079537f54b25224fe1.png]

如果发现 Tomcat 启动不了或者启动了 什么反应都没有 那么去 http://boke.huitoushian.cn/posts/55324.html 找为什么 基本上百分之95的问题都能解决 剩下百分之5就是你自己作死 乱改 出现的未知问题 这个 唯一办法卸载Tomcat 从新安装

### JSP处理过程 ###

以下步骤表明了Web服务器是如何使用JSP来创建网页的：

*  就像其他普通的网页一样，您的浏览器发送一个HTTP请求给服务器。
 *  Web服务器识别出这是一个对JSP网页的请求，并且将该请求传递给JSP引擎。通过使用URL或者.jsp文件来完成。
 *  JSP引擎从磁盘中载入JSP文件，然后将它们转化为servlet。这种转化只是简单地将所有模板文本改用println()语句，并且将所有的JSP元素转化成Java代码。
 *  JSP引擎将servlet编译成可执行类，并且将原始请求传递给servlet引擎。
 *  Web服务器的某组件将会调用servlet引擎，然后载入并执行servlet类。在执行过程中，servlet产生HTML格式的输出并将其内嵌于HTTP response中上交给Web服务器。
 *  Web服务器以静态HTML网页的形式将HTTP response返回到您的浏览器中。
 *  最终，Web浏览器处理HTTP response中动态产生的HTML网页，就好像在处理静态网页一样。

一般情况下，JSP引擎会检查JSP文件对应的servlet是否已经存在，并且检查JSP文件的修改日期是否早于servlet。如果JSP文件的修改日期早于对应的servlet，那么容器就可以确定JSP文件没有被修改过并且servlet有效。这使得整个流程与其他脚本语言（比如PHP）相比要高效快捷一些。

总的来说，JSP网页就是用另一种方式来编写servlet而不用成为Java编程高手。除了解释阶段外，JSP网页几乎可以被当成一个普通的servlet来对待。

### JSP 生命周期 ###

理解JSP底层功能的关键就是去理解它们所遵守的生命周期。

JSP生命周期就是从创建到销毁的整个过程，类似于servlet生命周期，区别在于JSP生命周期还包括将JSP文件编译成servlet。

以下是JSP生命周期中所走过的几个阶段：

*  **编译阶段：**

servlet容器编译servlet源文件，生成servlet类

*  初始化阶段：

加载与JSP对应的servlet类，创建其实例，并调用它的初始化方法

*  执行阶段：

调用与JSP对应的servlet实例的服务方法

*  销毁阶段：

调用与JSP对应的servlet实例的销毁方法，然后销毁servlet实例

很明显，JSP生命周期的四个主要阶段和servlet生命周期非常相似

#### JSP编译阶段 ####

当浏览器请求JSP页面时，JSP引擎会首先去检查是否需要编译这个文件。如果这个文件没有被编译过，或者在上次编译后被更改过，则编译这个JSP文件。

编译的过程包括三个步骤：

*  解析JSP文件。
 *  将JSP文件转为servlet。
 *  编译servlet。

#### JSP初始化阶段 ####

容器载入JSP文件后，它会在为请求提供任何服务前调用jspInit()方法。如果您需要执行自定义的JSP初始化任务，复写jspInit()方法就行了，就像下面这样：

public void jspInit(){
        
      // 初始化代码
    }

般来讲程序只初始化一次，servlet也是如此。通常情况下您可以在jspInit()方法中初始化数据库连接、打开文件和创建查询表。

#### JSP执行阶段 ####

这一阶段描述了JSP生命周期中一切与请求相关的交互行为，直到被销毁。

当JSP网页完成初始化后，JSP引擎将会调用\_jspService()方法。

\_jspService()方法需要一个HttpServletRequest对象和一个HttpServletResponse对象作为它的参数，就像下面这样：

void _jspService(HttpServletRequest request,HttpServletResponse response)
    {
        
       // 服务端处理代码
    }

\_jspService()方法在每个request中被调用一次并且负责产生与之相对应的response，并且它还负责产生所有7个HTTP方法的回应，比如GET、POST、DELETE等等。

#### JSP销毁阶段 ####

JSP生命周期的销毁阶段描述了当一个JSP网页从容器中被移除时所发生的一切。

jspDestroy()方法在JSP中等价于servlet中的销毁方法。当您需要执行任何清理工作时复写jspDestroy()方法，比如释放数据库连接或者关闭文件夹等等。

jspDestroy()方法的格式如下：

public void jspDestroy()
    {
        
       // 清理代码
    }

#### 案例 ####

创建一个index.jsp 将下面的 代码 复制到 jsp页面中 然后运行Tomcat

访问http://localhost:8081/java\_Web/index.jsp 看看 控制台打印效果 已经页面显示的内容

<%@ page language="java" contentType="text/html; charset=UTF-8"
        pageEncoding="UTF-8"%>
    <html>
    <head>
    <title>life.jsp</title>
    </head>
    <body>
    
    <%! 
      private int initVar=0;
      private int serviceVar=0;
      private int destroyVar=0;
    %>
      
    <%!
      public void jspInit(){
        initVar++;
        System.out.println("jspInit(): JSP被初始化了"+initVar+"次");
      }
      public void jspDestroy(){
        destroyVar++;
        System.out.println("jspDestroy(): JSP被销毁了"+destroyVar+"次");
      }
    %>
    
    <%
      serviceVar++;
      System.out.println("_jspService(): JSP共响应了"+serviceVar+"次请求");
    
      String content1="初始化次数 : "+initVar;
      String content2="响应客户请求次数 : "+serviceVar;
      String content3="销毁次数 : "+destroyVar;
    %>
    <h1>w3cschool教程 JSP 测试实例</h1>
    <p><%=content1 %></p>
    <p><%=content2 %></p>
    <p><%=content3 %></p>
    
    </body>
    </html>

页面显示

![在这里插入图片描述][813f43d7c57a412ab653760ec4605d74.png]

IDEA 控制台

> jspInit(): JSP被初始化了1次  
> \_jspService(): JSP共响应了1次请求

然后你在关闭Tomcat 试试

IDEA 控制台

> jspDestroy(): JSP被销毁了1次
> 
> Disconnected from server

不要去纠结 到底 怎么使用 这些都不重要 因为基本不会怎么使用这些 当然你想使用就使用当我没说

## JSP 语法 ##

一下只是讲解 jsp 中的 语法 而详细教程在 后面会慢慢道来

### 脚本程序 ###

脚本程序 可以包含任意量的Java语句、变量、方法或表达式，只要它们在脚本中是正确的代码。

就好比 java中的 public class className\{ 内容… \}

脚本程序的语法格式：

<% 代码片段 %>

任何文本、HTML标签、JSP元素必须写在脚本程序的外面。

下面给出一个示例

<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8" %>
    <html>
    <head>
        <title>hello</title>
    </head>
    <body>
    
    Hello World!<br/>
    <%
        out.println("你的 IP 地址 是 " + "<h1>" + request.getRemoteAddr() + "</h1>");
    %>
    
    
    </body>
    </html>

out.println 和 out.print 就是内容输出到页面中 会解析 HTML标签的 把他当成java中的System.out,println()就行了

这里顺带解决一个常见的问题 如果你将上面的代码复制到IDEA 中发现 代码都爆红

![在这里插入图片描述][eb11424defa443088ce1ef4a1f586f10.png]

出现这个原因是没有导入 Tomcat 到项目里

解决办法:

![在这里插入图片描述][05c1c83b569c4e458746debb3870eddf.png]

![在这里插入图片描述][742c03462b3e4b4a9f4d2eaae0aaa0f0.png]

![在这里插入图片描述][8ff545e60ee641c4b01bdd6ce5830eda.png]

然后apply -> 0k 保存就行 稍等一下 你就发现 不报错了 能找到这些代码了

然后我们运行 Tomcat 访问 http://localhost:8081/java\_Web/index.jsp

遇到了request.getRemoteAddr()获取的值为0:0:0:0:0:0:0:1，这是为什么呢，照道理讲，应该是127.0.0.1才对，为什么这个获取的值变成了ipv6了呢，而且我发现这种情况只有在服务器和客户端都在同一台电脑上才会出现 所以 不用管它 自己明白就行

### JSP声明 ###

一个声明语句可以声明一个或多个变量、方法，供后面的Java代码使用。在JSP文件中，您必须先声明这些变量和方法然后才能使用它们。

就好比 java中 类里声明成员变量

JSP声明的语法格式：

<%! 变量 %>

示例:

<%@ page import="javafx.scene.shape.Circle" %>
    <%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8" %>
    <html>
    <head>
        <title>hello</title>
    </head>
    <body>
    
    <%! int i = 1; %>
    <%! int a, b=2, c; %>
    <%! Circle cle = new Circle(2.0); %>
    <%
        out.println(i+"<br/>");
        out.println(a+"_"+b+"_"+c+"<br/>");
        out.println(cle);
    %>
    </body>
    </html>

### JSP表达式 ###

一个JSP表达式中包含的脚本语言表达式，先被转化成String，然后插入到表达式出现的地方。

由于表达式的值会被转化成String，所以您可以在一个文本行中使用表达式而不用去管它是否是HTML标签。

表达式元素中可以包含任何符合Java语言规范的表达式，但是不能使用分号来结束表达式。

也就相当于就一条java语句 但是必须有输出内容 就好比是java 中的 String a=123; 等号右边必须有内容

JSP表达式的语法格式：

<%= 表达式 %>

示例：

将当前时间戳 转换为时间字符串

Today's date: <%= (new java.util.Date()).toLocaleString()%>

页面显示

> Today’s date: 2020-11-17 22:54:08

### JSP注释 ###

JSP注释主要有两个作用：为代码作注释以及将某段代码注释掉。 该注释在网页中不会被显示-

JSP注释的语法格式：

<%-- 这里可以填写 JSP 注释 --%>

不同情况下使用注释的语法规则：

<table> 
 <thead> 
  <tr> 
   <th><strong>语法</strong></th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>&lt;%-- 注释 --%&gt;</td> 
   <td>JSP注释，注释内容不会被发送至浏览器甚至不会被编译</td> 
  </tr> 
  <tr> 
   <td>&lt;!-- 注释 --&gt;</td> 
   <td>HTML注释，通过浏览器查看网页源代码时可以看见注释内容</td> 
  </tr> 
 </tbody> 
</table>

### JSP指令 ###

JSP指令用来设置整个JSP页面相关的属性，如网页的编码方式和脚本语言。

JSP指令语法格式：

<%@ directive attribute="value" %>

指令可以有很多个属性，它们以键值对的形式存在，并用逗号隔开。

JSP中的三种指令标签：

<table> 
 <thead> 
  <tr> 
   <th><strong>指令</strong></th> 
   <th><strong>描述</strong></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>&lt;%@ page … %&gt;</td> 
   <td>定义网页依赖属性，比如脚本语言、error页面、缓存需求等等</td> 
  </tr> 
  <tr> 
   <td>&lt;%@ include … %&gt;</td> 
   <td>包含其他文件</td> 
  </tr> 
  <tr> 
   <td>&lt;%@ taglib … %&gt;</td> 
   <td>引入标签库的定义</td> 
  </tr> 
 </tbody> 
</table>

#### <%@ page %>指令 ####

Page指令为容器提供当前页面的使用说明。一个JSP页面可以包含多个page指令。

Page指令的语法格式：

<%@ page attribute="value" %>

**属性**

下表列出与Page指令相关的属性：

<table> 
 <thead> 
  <tr> 
   <th><strong>属性</strong></th> 
   <th><strong>描述</strong></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>buffer</td> 
   <td>指定out对象使用缓冲区的大小</td> 
  </tr> 
  <tr> 
   <td>autoFlush</td> 
   <td>控制out对象的 缓存区</td> 
  </tr> 
  <tr> 
   <td>contentType</td> 
   <td>指定当前JSP页面的MIME类型和字符编码</td> 
  </tr> 
  <tr> 
   <td>errorPage</td> 
   <td>指定当JSP页面发生异常时需要转向的错误处理页面</td> 
  </tr> 
  <tr> 
   <td>isErrorPage</td> 
   <td>指定当前页面是否可以作为另一个JSP页面的错误处理页面</td> 
  </tr> 
  <tr> 
   <td>extends</td> 
   <td>指定servlet从哪一个类继承</td> 
  </tr> 
  <tr> 
   <td>import</td> 
   <td>导入要使用的Java类</td> 
  </tr> 
  <tr> 
   <td>info</td> 
   <td>定义JSP页面的描述信息</td> 
  </tr> 
  <tr> 
   <td>isThreadSafe</td> 
   <td>指定对JSP页面的访问是否为线程安全</td> 
  </tr> 
  <tr> 
   <td>language</td> 
   <td>定义JSP页面所用的脚本语言，默认是Java</td> 
  </tr> 
  <tr> 
   <td>session</td> 
   <td>指定JSP页面是否使用session</td> 
  </tr> 
  <tr> 
   <td>isELIgnored</td> 
   <td>指定是否执行EL表达式 (默认true)</td> 
  </tr> 
  <tr> 
   <td>isScriptingEnabled</td> 
   <td>确定脚本元素能否被使用</td> 
  </tr> 
  <tr> 
   <td>pageEncoding</td> 
   <td>当前页面的编码格式</td> 
  </tr> 
 </tbody> 
</table>

列:

<%@ page language="java" contentType="text/html; charset=UTF-8"  isELIgnored="true" pageEncoding="UTF-8" %>

#### <%@ Include %>指令 ####

JSP可以通过include指令来包含其他文件。被包含的文件可以是JSP文件、HTML文件或文本文件。包含的文件就好像是该JSP文件的一部分，会被同时编译执行。最后会被整合 成一个 Servlet .class

注意: 使用 include 指令是以静态方式包含文件 简单来说就是合二为一 ,原封不动地附加到当前文件中 所以要避免重复的代码 和变量 等逻辑。

例如:里面不要包含<html> <body> … 这样的标签，因为是把源代码原封不动的附加过来，所以会与当前的jsp中的这样的标签重复导致出错。

但是也是有好处的 就是 js 和jsp … 变量方法等共享 你可以在 Include指令 后面修改包含页面内 变量的内容 从而改变包含页面的状态

为了避嫌 html 和jsp 中文乱码的情况 在项目的web.xml中添加

<jsp-config>
        <jsp-property-group>
          <url-pattern>*.html</url-pattern>
          <url-pattern>*.jsp</url-pattern>
          <page-encoding>UTF-8</page-encoding>
        </jsp-property-group>
      </jsp-config>

Include指令的语法格式如下：

<%@ include file="url" %>

创建一个index1.html

<h1>index1.html  O(∩_∩)O哈哈~</h1>

创建一个index1.jsp

<h1>index1.jsp  O(∩_∩)O哈哈~</h1>

创建一个index.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"  isELIgnored="true" pageEncoding="UTF-8" %>
    <html>
    <head>
        <title>index</title>
    </head>
    <body>
    <%@ include file="index1.html" %>
    <%@ include file="index1.jsp" %>
    <h1>index.jsp</h1>
    
    </body>
    </html>

页面显示

![在这里插入图片描述][8f3ea19ea8e240f0bdcf8a87307a4bef.png]

#### <%@ Taglib %>指令 ####

在JSP页面中使用第三方的标签库时，需要使用taglib指令来“导包”

Taglib指令的语法：

<%@ taglib uri="uri" prefix="prefixOfTag" %>

uri属性确定标签库的位置，prefix属性指定标签库的前缀。

比如引入JSTL标签库

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

然后我们就可以在当前页面使用JSTL语法了

### JSP行为 ###

JSP行为标签使用XML语法结构来控制servlet引擎。它能够动态插入一个文件，重用JavaBean组件，引导用户去另一个页面，为Java插件产生相关的HTML等等。

行为标签只有一种语法格式，它严格遵守XML标准：

<jsp:action_name attribute="value" />

行为标签基本上是一些预先就定义好的函数，下表罗列出了一些可用的JSP行为标签：

<table> 
 <thead> 
  <tr> 
   <th><strong>语法</strong></th> 
   <th><strong>描述</strong></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>jsp:include</td> 
   <td>用于在当前页面中包含静态或动态资源</td> 
  </tr> 
  <tr> 
   <td>jsp:useBean</td> 
   <td>寻找和初始化一个JavaBean组件</td> 
  </tr> 
  <tr> 
   <td>jsp:setProperty</td> 
   <td>设置 JavaBean组件的值 配合 jsp:useBean使用</td> 
  </tr> 
  <tr> 
   <td>jsp:getProperty</td> 
   <td>输出某个JavaBean的属性。 配合 jsp:useBean 使用</td> 
  </tr> 
  <tr> 
   <td>jsp:forward</td> 
   <td>把请求转到一个新的页面 (转发)</td> 
  </tr> 
 </tbody> 
</table>

至于其他的行为 就没什么卵用了 这里就不 在写了

#### <jsp:include>行为元素 ####

<jsp:include>行为元素用来包含静态和动态的文件。该行为把指定文件插入正在生成的页面。语法格式如下：

<jsp:include page="URL" flush="true" />

前面已经介绍过include指令，就相当于两个文件内容 合二为一 生成一个.class文件，

而这里的jsp:include动作不同， 相当于生成 二个.class文件 他们内容 互不相关 不会有 标签 变量…冲突问题 但是都会显示在同一个页面中 因为 当我们请求 原文jsp文件的时候 他内部就会请求 包含的jsp文件 也就是 插入文件的时间是在页面被请求的时候。

以下是include动作相关的属性列表。

<table> 
 <thead> 
  <tr> 
   <th>属性</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>page</td> 
   <td>包含在页面中的相对URL地址。</td> 
  </tr> 
  <tr> 
   <td>flush</td> 
   <td>布尔属性，定义在包含资源前是否刷新缓存区。</td> 
  </tr> 
 </tbody> 
</table>

列:

创建index1.html

<!DOCTYPE html>
    <html lang="en">
    <head>
        <meta charset="UTF-8">
        <title>Title</title>
    </head>
    <body>
    <h1>index1.html ^_^</h1>
    </body>
    </html>

创建index1.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
    <html>
    <head>
        <title>Title</title>
    </head>
    <body>
    <h1> index1.jsp  ^_^</h1>
    </body>
    </html>

创建index.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"  isELIgnored="true" pageEncoding="UTF-8" %>
    <html>
    <head>
        <title>index</title>
    </head>
    <body>
    
    
    <jsp:include page="index1.html" flush="true" />
    <jsp:include page="index1.jsp" flush="true" />
    
    <h1>index.jsp</h1>
    
    </body>
    </html>

页面显示:

![在这里插入图片描述][76e1932d25b74711a6d445981989c0b8.png]

#### <jsp:useBean>行为元素 ####

jsp:useBean动作用来装载一个将在JSP页面中使用的JavaBean。

这个功能非常有用，因为它使得我们既可以发挥Java组件重用的优势， 但是必须准守 JavaBean API 规范

必须是 无惨构造 有get set 方法 需要被序列化并且实现了 Serializable 接口

jsp:useBean动作最简单的语法为：

<jsp:useBean id="对象名称" class="类的包路径" />

至于其他属性 没什么卵用 就别浪费时间研究了

在类载入后 相当于new 对象 id就是对象的名称，我们既可以通过 jsp:setProperty 和 jsp:getProperty 动作来修改和获取bean的属性。

演示:

public class TestBean {
        
       private String message = "No message specified";
     
       public String getMessage() {
        
          return(message);
       }
       public void setMessage(String message) {
        
          this.message = message;
       }
    }

然后重启Tomcat 会自动编译 TestBean 成TestBean.class 之后我们在jsp页面才能使用,否则会报错

然后在index.jsp页面使用下面代码

<center>
        <h2>Using JavaBeans in JSP</h2>
    
        <jsp:useBean id="test" class="co.boke.test.TestBean"   />
    
    
        <jsp:getProperty name="test" property="message" /><br/>
    
        <jsp:setProperty name="test"   property="message"      value="Hello"/>
    
        <jsp:getProperty name="test" property="message" />
    
    </center>

#### <jsp:forward> 行为元素 ####

jsp:forward动作把请求转到另外的页面。jsp:forward标记只有一个属性page。语法格式如下所示：

<jsp:forward page="URL" />

page属性包含的是一个相对URL。page的值既可以直接给出，也可以在请求的时候动态计算，可以是一个JSP页面或者一个 Java Servlet.

比如:

创建index1.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
    <html>
    <head>
        <title>Title</title>
    </head>
    <body>
    
    <p>
        Today's date: <%= (new java.util.Date()).toLocaleString()%>
    </p>
    
    </body>
    </html>

创建index.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8" isELIgnored="true" pageEncoding="UTF-8" %>
    <html>
    <head>
        <title>index</title>
    </head>
    <body>
    
    <%! int num = 2; %>
    
    <% if (num == 2) {%>
    <jsp:forward page="index1.jsp"/>
    <% } %>
    
    </body>
    </html>

if 满足条件 转发请求 到 index1.jsp页面

####  ####

### JSP9大内置对象和4大作用域以及Cookie ###

JSP支持九个自动定义的变量，江湖人称隐含对象。这九个隐含对象的简介见下表：

<table> 
 <thead> 
  <tr> 
   <th><strong>对象</strong></th> 
   <th><strong>描述</strong></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>request(请求)</td> 
   <td>用于向客户端发送和获取数据 作用范围一次请求</td> 
  </tr> 
  <tr> 
   <td>response(响应)</td> 
   <td>用于响应客户端请求 比如设置 响应头 状态码 …</td> 
  </tr> 
  <tr> 
   <td>out(输出)</td> 
   <td>用于把结果输出至网页上 比如 out.println()</td> 
  </tr> 
  <tr> 
   <td>session(会话)</td> 
   <td>用于向客户端发送和获取数据 作用范围是一次会话</td> 
  </tr> 
  <tr> 
   <td>application(应用程序)</td> 
   <td>用于向客户端发送和获取数据 作用范围是将Tomcat服务关闭</td> 
  </tr> 
  <tr> 
   <td>config(配置对象)</td> 
   <td>代表当前<em>JSP</em> 配置信息, 但<em>JSP</em> 页面通常无须配置,因此也就不存在配置信息 很少使用</td> 
  </tr> 
  <tr> 
   <td>pageContext(页面上下文对象)</td> 
   <td>可以访问页面中所有作用域 以及一些页面属性 和设置</td> 
  </tr> 
  <tr> 
   <td>page(页面对象)</td> 
   <td>用于向客户端发送和获取数据 作用范围 类似于java的 this 表示当前页面</td> 
  </tr> 
  <tr> 
   <td>Exception(异常对象)</td> 
   <td>表示jsp页面运行时产生的异常和报错信息 该对象只有在错误页面&lt;%@ page 指令中设置isErrorPage 为true 的页面 中才能使用 很少使用</td> 
  </tr> 
  <tr> 
   <td>Cookie(小型文本文件)</td> 
   <td>这个就是将数据以键值对形式 保存在当前游览器的Cookie里 也就是本地电脑里 可以通过游览器查看到</td> 
  </tr> 
 </tbody> 
</table>

四大作用域是: page, request , session , application

和servlet 的9个内置对象 用法一样 我们就不啰嗦了

然后还有一个特殊对象Cookie 这个就不陌生把

接下来我们把 page , request , response , session , application , pageContext, Cookie 这7大常用的对象 详细讲一遍

至于其他的 反正我基本没怎么用过

这里注意: Servler 和jsp 都是一样的 可以互通 但是为了方便 我们 就使用2个 jsp页面来演示上面的方法

#### page(当前页) ####

四大作用域之一page

page 对象是为了执行当前页面应答请求而设置的 Servlet 类的实体，即显示 JSP 页面自身，与类的 this 指针类似，使用它来调用 Servlet 类中所定义的方法，只有在本页面内才是合法的。它是 java.lang.Object 类的实例，对于开发 JSP 比较有用。表 1 列出了 page 对象常用的方法。

<table> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>class getClass()</td> 
   <td>返回当前 Object 的类</td> 
  </tr> 
  <tr> 
   <td>int hashCode</td> 
   <td>返回 Object 的 hash 代码</td> 
  </tr> 
  <tr> 
   <td>String toString</td> 
   <td>把 Object 对象转换成 String 类的对象</td> 
  </tr> 
  <tr> 
   <td>boolean equals(Object obj)</td> 
   <td>比较对象和指定的对象是否相等</td> 
  </tr> 
  <tr> 
   <td>void copy (Object obj)</td> 
   <td>把对象拷贝到指定的对象中</td> 
  </tr> 
  <tr> 
   <td>Object clone()</td> 
   <td>复制对象(克隆对象)</td> 
  </tr> 
 </tbody> 
</table>

创建index.jsp

<%
        Object obj;
        obj=null;
    %>
    
    返回当前页面所在类：<%=page.getClass()%> <br>
    返回当前页面的 hash 代码：<%=page.hashCode()%> <br>
    转换成 String 类的对象：<%=page.toString()%> <br>
    比较1：<%=page.equals(obj) %> <br>
    比较2：<%=page.equals(this) %>

页面显示

返回当前页面所在类：class org.apache.jsp.index_jsp
    返回当前页面的 hash 代码：1772279684
    转换成 String 类的对象：org.apache.jsp.index_jsp@69a2d784
    比较1：false
    比较2：true

#### request (转发) ####

四大作用域之一request

客户端可通过 HTML 表单或在网页地址后面提供参数的方法提交数据，然后通过 request 对象的相关方法来获取这些数据。request 对象封装了客户端的请求信息，包括用户提交的信息以及客户端的一些信息，服务端通过 request 对象可以了解到客户端的需求，然后做出响应。

request 对象是 HttpServletRequest(接口)的实例。请求信息的内容包括请求的标题头(Header)信息(如浏览器的版本信息语言和编码方式等)，请求的方式(如 HTTP 的 GET 方法、POST 方法等)，请求的参数名称、参数值和客户端的主机名称等。

request 对象提供了一些方法，主要用来处理客户端浏览器提交的请求中的各项参数和选项。表 1 列出了 request 对象常用的方法。下面介绍 request 对象的应用。

什么是转发?

比如页面1 转发到页面2 那么页面2在转发到页面3 此时页面3 将不能获取到页面1 的内容

大部分的方法 都是获取信息 get

<table> 
 <thead> 
  <tr> 
   <th>常用方法</th> 
   <th>方法介绍</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>String getParameter(String name)</td> 
   <td>返回指定name的值 多个name 只能获取第一个</td> 
  </tr> 
  <tr> 
   <td>String[] getParameterValues(String name)</td> 
   <td>获取 获取一组name相同的数据 返回的是数组</td> 
  </tr> 
  <tr> 
   <td>Map&lt;String,String[]&gt; request.getParameterMap();</td> 
   <td>将前端传来的数据 封装到map中</td> 
  </tr> 
  <tr> 
   <td>Enumeration getParameterNames()</td> 
   <td>返回请求中所有参数的名称集合</td> 
  </tr> 
  <tr> 
   <td>void setAttribute(String,Object)</td> 
   <td>存储此请求中的属性</td> 
  </tr> 
  <tr> 
   <td>Object getAttribute(String name)</td> 
   <td>返回指定属性的属性值</td> 
  </tr> 
  <tr> 
   <td>Enumeration getAttributeNames()</td> 
   <td>返回request对象的所有属性名称的集合</td> 
  </tr> 
  <tr> 
   <td>void setCharacterEncoding(String charset)</td> 
   <td>设置请求的字符编码方式 可以用于解决中文乱码问题</td> 
  </tr> 
  <tr> 
   <td>String getRemoteAddr()</td> 
   <td>返回发送此请求的客户端IP地址</td> 
  </tr> 
  <tr> 
   <td>String getRequestURI()</td> 
   <td>返回发送此请求的URI</td> 
  </tr> 
  <tr> 
   <td>String getServletPath()</td> 
   <td>返回所请求的servlet路径</td> 
  </tr> 
  <tr> 
   <td>String request.getContextPath()</td> 
   <td>获取当前web(虚拟目录) 如果没有那么就空</td> 
  </tr> 
  <tr> 
   <td>Cookie[] getCookies()</td> 
   <td>返回客户端所有的Cookie的数组</td> 
  </tr> 
  <tr> 
   <td>String getMethod()</td> 
   <td>得到客户机请求方式 比如 GET,，POST，或PUT</td> 
  </tr> 
  <tr> 
   <td>String getRequestedSessionId()</td> 
   <td>返回request的session ID</td> 
  </tr> 
  <tr> 
   <td>boolean isSecure()</td> 
   <td>返回request是否使用了加密通道，比如HTTPS</td> 
  </tr> 
  <tr> 
   <td>voie request.getRequestDispatcher(path).forward(request,response);</td> 
   <td>将请求转发给指定页面</td> 
  </tr> 
  <tr> 
   <td>String request.getHeader(String key)</td> 
   <td>获取游览器的请求头信息</td> 
  </tr> 
 </tbody> 
</table>

还有很多方法这里 就不一 一列出来了 以上方法都够你吃一壶的了 而且常用的就几个下面我会演示的

出现请求的数据是 中文乱码的情况

比如: 页面1 给页面2 转发数据 页面2出现中文乱码了 那么在页面2开头位置加上下面代码

<%
        //设置请求的字符编码方式   utf-8
        request.setCharacterEncoding("utf-8");
    %>

##### 转发-参数获取和设置 #####

**演示下面方法的用法**

常用语 2个不同页面之间的传值

*  void request.setAttribute (String,Object)
 *  Object request.getAttribute (String,Object)
 *  Enumeration<String> getAttributeNames()
 *  void request.getRequestDispatcher(path).forward(request,response);

创建 index.jsp

<%
    request.setAttribute("Name","HuAnmin");   //设置request值
    request.setAttribute("Pass","123");
    request.getRequestDispatcher("index1.jsp").forward(request,response); // 将request 转发 
    %>

创建index1.jsp

<%
        //设置 请求 和响应 的格式都是 utf-8
        request.setCharacterEncoding("utf-8");
    %>
    
    <%-- 获取转发来的request内的值--%>
    
    姓名:<%=request.getAttribute("Name")%><br>   
    你的密码是:<%=request.getAttribute("Pass")%><br><br>
    
    所有的request里的key和value<br>
    <%
        Enumeration<String> attributeNames = request.getAttributeNames();
        while(attributeNames.hasMoreElements()){
            String name=attributeNames.nextElement();  //获取 name 名称
            if(name.contains("javax.servlet.forward")){   //过滤掉不用的信息
                continue;
            }
            String value=(String) request.getAttribute(name);   //通过name 获取值
            out.print(name + "=" + value+"<br/>");
        }
    
    %>

转发到 index1.jsp页面显示

姓名:HuAnmin
    你的密码是:123
    
    所有的request里的key和value  
    Pass=123
    Name=HuAnmin

##### url参数和表单name获取 #####

**演示下面方法的用法**

常用于 url参数 和 表单提交的数据

*  String getParameter(String name) 如果是多个name那么只获取第一个
 *  String\[\] getParameterValues(String name)
 *  Enumeration getParameterNames()

创建 index.jsp

<form action="index1.jsp" method="post">
        账户:<input type="text" name="UserName" value="HuAnmin" placeholder="请输入你的账户"><br>
        密码:<input type="text" name="PassWord" value="123" placeholder="请输入你的密码"><br>
        爱好:
        <input type="checkbox" name="AiHao" value="游泳" checked="checked">游泳
        <input type="checkbox" name="AiHao" value="跑步"  checked="checked">跑步
        <input type="checkbox" name="AiHao" value="跳远">跳远
        <br>
        <input type="submit" value="点击">
    </form>
    
    <a href="index1.jsp?UserName=ABC&&PassWord=123&&AiHao=上网&&AiHao=打代码">GET Parameter</a>

创建index1.jsp

<%-- 获取表单 或 url参数 的值--%>
    
    <%
        //设置 请求 和响应 的格式都是 utf-8
        request.setCharacterEncoding("utf-8");
    %>
    账户:<%=request.getParameter("UserName")%><br>
    密码:<%=request.getParameter("PassWord")%><br>
    爱好: <%= Arrays.toString(request.getParameterValues("AiHao"))%>
    <br><br>
    全部参数 <br>
    <%
        Enumeration<String> attributeNames = request.getParameterNames();
        while(attributeNames.hasMoreElements()){
            String name=attributeNames.nextElement();  //获取 name 名称
            String value=request.getParameter(name);   //通过name 获取值
            out.print(name + "=" + value+"<br/>");
        }
    
    %>

表单提交到 index1.jsp页面显示

账户:HuAnmin
    密码:123
    爱好: [游泳, 跑步]
    
    全部参数
    UserName=HuAnmin
    PassWord=123
    AiHao=游泳

点超链接 index1.jsp页面显示

账户:ABC
    密码:123
    爱好: [上网, 打代码]
    
    全部参数
    UserName=ABC
    PassWord=123
    AiHao=上网

##### url参数获取和表单name 之Map映射实体类 #####

**演示下面方法的用法**

url参数 和表单name 常用于 映射javaBean 因为如果表单太大的话 我们自己 手动映射实体类太慢了

要求必须 表单或者url 的key 的名称 和 实体类的 成员变量名一致 并且 实体类实现get set 方法

*  Map<String,String\[\]> request.getParameterMap();

需要的jar

链接：https://pan.baidu.com/s/18x2eJyr3qaBEgom1Uvpmcw  
提取码：1234  
复制这段内容后打开百度网盘手机App，操作更方便哦–来自百度网盘超级会员V4的分享

或者在pom.xml中添加Maven

<dependency>
          <groupId>commons-beanutils</groupId>
          <artifactId>commons-beanutils</artifactId>
          <version>1.9.3</version>
        </dependency>

二选一

创建一个MyUser 实体类

public class MyUser {
        
    
        private  String name;
        private  String pass;
        private  String aiHao;
    
    //  自己补充 get   set   toString
    
    }

创建index.jsp

创建index1.jsp

<%
        //设置 请求 和响应 的格式都是 utf-8
        request.setCharacterEncoding("utf-8");
    %>
    
    --------普通用法--------<br>
    <%
        Map<String,String[]> name1=request.getParameterMap();
        out.println("账户"+name1.get("name")[0]+"<br/>");
        out.println("密码"+name1.get("pass")[0]+"<br/>");
        out.println("爱好"+ Arrays.toString(name1.get("aiHao")) +"<br/>");
    
    %>
    
    
    -------------映射实体类-------------<br>
    <%
        Map<String, String[]> parameterMap = request.getParameterMap();
        MyUser user=new MyUser();
    //是这个包  import org.apache.commons.beanutils.BeanUtils;
        try {
            BeanUtils.populate(user,parameterMap); //将map对象中的值 按照key的名称和对象内的成员名称进行映射 (必须提供set 和get)
        } catch (IllegalAccessException | InvocationTargetException e) {
            e.printStackTrace();
        }
        out.println(user);  //打印实体类
    %>

表单提交到 index1.jsp页面显示

--------普通用法--------
    账户HuAnmin
    密码123
    爱好[游泳, 跑步]
    -------------映射实体类-------------
    MyUser{name='HuAnmin', pass='123', aiHao='游泳'}

##### 转发常用内置参数获取 #####

**演示下面方法的用法**

*  String request.getServletPath()
 *  String request.getRequestURI()
 *  String request. getRemoteAddr()
 *  String request.getContextPath()
 *  String request.getMethod()
 *  String request. isSecure()
 *  String getRequestedSessionId()

创建index.jsp

<%
    request.getRequestDispatcher("/index1.jsp").forward(request,response);
    %>

创建index1.jsp

<%
        //设置 请求 和响应 的格式都是 utf-8
        request.setCharacterEncoding("utf-8");
    %>
    
    <%
        out.println("请求的servlet路径"+request.getServletPath()+"<br>");
        out.println("请求的URI: "+request.getRequestURI()+"<br>");
        out.println("客户端IP地址:"+request.getRemoteAddr()+"<br>");
        out.println("虚拟路径:  "+request.getContextPath()+"<br>");
        out.println("请求方式:  "+request.getMethod()+"<br>");
        out.println("是否使用了加密通道(HTTPS):  "+request. isSecure()+"<br>");
        out.println("返回请求的session ID : "+request. getRequestedSessionId()+"<br>");
    %>

转发到 index1.jsp页面显示

请求的servlet路径/index1.jsp
    请求的URI: /java_Web/index1.jsp
    客户端IP地址:0:0:0:0:0:0:0:1
    虚拟路径: /java_Web
    请求方式: GET
    是否使用了加密通道(HTTPS): false
    返回请求的session ID : 71720FDE92375A2DDAD3BFC10D2A0DC7

##### 获取游览器的请求头信息 #####

**演示下面方法的用法**

用的不多 因为一般都是设置而不是获取

*  String request.getHeader(String key)

<table> 
 <thead> 
  <tr> 
   <th><strong>信息(key)</strong></th> 
   <th><strong>描述</strong></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>Accept</td> 
   <td>指定浏览器或其他客户端可以处理的MIME类型。它的值通常为 <strong>image/png</strong> 或 <strong>image/jpeg</strong></td> 
  </tr> 
  <tr> 
   <td>Accept-Charset</td> 
   <td>指定浏览器要使用的字符集。比如 ISO-8859-1</td> 
  </tr> 
  <tr> 
   <td>Accept-Encoding</td> 
   <td>指定编码类型。它的值通常为 <strong>gzip</strong> 或<strong>compress</strong></td> 
  </tr> 
  <tr> 
   <td>Accept-Language</td> 
   <td>指定客户端首选语言，servlet会优先返回以当前语言构成的结果集，如果servlet支持这种语言的话。比如 en，en-us，ru等等</td> 
  </tr> 
  <tr> 
   <td>Authorization</td> 
   <td>在访问受密码保护的网页时识别不同的用户</td> 
  </tr> 
  <tr> 
   <td>Connection</td> 
   <td>表明客户端是否可以处理HTTP持久连接。持久连接允许客户端或浏览器在一个请求中获取多个文件。<strong>Keep-Alive</strong> 表示启用持久连接</td> 
  </tr> 
  <tr> 
   <td>Content-Length</td> 
   <td>仅适用于POST请求，表示 POST 数据的字节数</td> 
  </tr> 
  <tr> 
   <td>Cookie</td> 
   <td>返回先前发送给浏览器的cookies</td> 
  </tr> 
  <tr> 
   <td>Host</td> 
   <td>指出原始URL中的主机名和端口号</td> 
  </tr> 
  <tr> 
   <td>If-Modified-Since</td> 
   <td>表明只有当网页在指定的日期被修改后客户端才需要这个网页。 服务器发送304码给客户端，表示没有更新的资源</td> 
  </tr> 
  <tr> 
   <td>If-Unmodified-Since</td> 
   <td>与If-Modified-Since相反， 只有文档在指定日期后仍未被修改过，操作才会成功</td> 
  </tr> 
  <tr> 
   <td>Referer</td> 
   <td>标志着所引用页面的URL。比如，如果你在页面1，然后点了个链接至页面2，那么页面1的URL就会包含在浏览器请求页面2的信息头中</td> 
  </tr> 
  <tr> 
   <td>User-Agent</td> 
   <td>用来区分不同浏览器或客户端发送的请求，并对不同类型的浏览器返回不同的内容</td> 
  </tr> 
 </tbody> 
</table>

创建index.jsp

Header:  <%=request.getHeader("Host")%><br>
    Header:  <%=request.getHeader("Accept")%><br>
    Header:  <%=request.getHeader("Cookie")%><br>

Header: localhost:8081
    Header: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8
    Header: JSESSIONID=71720FDE92375A2DDAD3BFC10D2A0DC7

#### response(请求) ####

Response响应对象主要将JSP容器处理后的结果传回到客户端。可以通过response变量设置HTTP的状态和向客户端发送数据，如Cookie、HTTP文件头信息等。

response对象的常用方法

<table> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><strong>String encodeRedirectURL(String url)</strong></td> 
   <td>对sendRedirect()方法使用的URL进行编码</td> 
  </tr> 
  <tr> 
   <td><strong>String encodeURL(String url)</strong></td> 
   <td>将URL编码，回传包含Session ID的URL</td> 
  </tr> 
  <tr> 
   <td><strong>boolean containsHeader(String name)</strong></td> 
   <td>返回指定的响应头是否存在</td> 
  </tr> 
  <tr> 
   <td><strong>boolean isCommitted()</strong></td> 
   <td>返回响应是否已经提交到客户端</td> 
  </tr> 
  <tr> 
   <td><strong>void addCookie(Cookie cookie)</strong></td> 
   <td>添加指定的cookie至响应中</td> 
  </tr> 
  <tr> 
   <td><strong>void addDateHeader(String name, long date)</strong></td> 
   <td>添加指定名称的响应头和日期值</td> 
  </tr> 
  <tr> 
   <td><strong>void addHeader(String name, String value)</strong></td> 
   <td>添加指定名称的响应头和值</td> 
  </tr> 
  <tr> 
   <td><strong>void addIntHeader(String name, int value)</strong></td> 
   <td>添加指定名称的响应头和int值</td> 
  </tr> 
  <tr> 
   <td><strong>void flushBuffer()</strong></td> 
   <td>将任何缓存中的内容写入客户端</td> 
  </tr> 
  <tr> 
   <td><strong>void reset()</strong></td> 
   <td>清除任何缓存中的任何数据，包括状态码和各种响应头</td> 
  </tr> 
  <tr> 
   <td><strong>void resetBuffer()</strong></td> 
   <td>清除基本的缓存数据，不包括响应头和状态码</td> 
  </tr> 
  <tr> 
   <td><strong>void sendError(int sc)</strong></td> 
   <td>使用指定的状态码向客户端发送一个出错响应，然后清除缓存</td> 
  </tr> 
  <tr> 
   <td><strong>void sendError(int sc, String msg)</strong></td> 
   <td>使用指定的状态码和消息向客户端发送一个出错响应</td> 
  </tr> 
  <tr> 
   <td><strong>void sendRedirect(String location)</strong></td> 
   <td>使用指定的URL向客户端发送一个临时的间接响应</td> 
  </tr> 
  <tr> 
   <td><strong>void setBufferSize(int size)</strong></td> 
   <td>设置响应体的缓存区大小</td> 
  </tr> 
  <tr> 
   <td><strong>void setCharacterEncoding(String charset)</strong></td> 
   <td>指定响应的编码集（MIME字符集），例如UTF-8</td> 
  </tr> 
  <tr> 
   <td><strong>void setContentLength(int len)</strong></td> 
   <td>指定HTTP servlets中响应的内容的长度，此方法用来设置 HTTP Content-Length 信息头</td> 
  </tr> 
  <tr> 
   <td><strong>void setContentType(String type)</strong></td> 
   <td>设置响应的内容的类型，如果响应还未被提交的话</td> 
  </tr> 
  <tr> 
   <td><strong>void setDateHeader(String name, long date)</strong></td> 
   <td>使用指定名称和值设置响应头的名称和内容</td> 
  </tr> 
  <tr> 
   <td><strong>void setHeader(String name, String value)</strong></td> 
   <td>使用指定名称和值设置响应头的名称和内容</td> 
  </tr> 
  <tr> 
   <td><strong>void setIntHeader(String name, int value)</strong></td> 
   <td>使用指定名称和值设置响应头的名称和内容</td> 
  </tr> 
  <tr> 
   <td><strong>void setLocale(Locale loc)</strong></td> 
   <td>设置响应的语言环境，如果响应尚未被提交的话</td> 
  </tr> 
  <tr> 
   <td><strong>void setStatus(int sc)</strong></td> 
   <td>设置响应的状态码</td> 
  </tr> 
 </tbody> 
</table>

##### 动态设置响应的类型 #####

利用 <%@ page %> 指令设置发送到客户端文档响应报头的 MIME 类型和字符编码，

如<%@ page contentType=“text/html;charset=utf-8”%>，它表示当用户访问该页面时，JSP 引擎将按照 contentType 的属性值即 text/html(网页)做出反应。

如果要动态改变这个属性值来响应客户，就需要使用 response 对象的 setContentType(String s) 方法。语法格式如下：

response.setContentType("MIME");

MIME 可以为 :

*  text/css :客户端浏览器按CSS格式进行解析文档
 *  text/xml :客户端浏览器按XML格式进行解析文档
 *  text/html : (网页)
 *  image/jpeg png jpg … 客户端浏览器按指定格式进行解析文档
 *  image/gif gif动画
 *  video/mp4 mp4 视频
 *  text/plain 文本
 *  application/zip 压缩
 *  application/pdf pdf 文档
 *  text/json json字符串
 *  application/x-msexcel(Excel 文件)
 *  application/msword(Word 文件)
 *  …

可能大家看不懂到底有什么样 我这样告诉你 用处大这呢

下面是一个 小 的案例将后台图片 显示在网页上 常用于二维码扫描

<%
        response.setCharacterEncoding("utf-8");
        response.setContentType("image/jpg");  //修改当前页面为
    
        long startTime = System.currentTimeMillis();
        ServletContext application1 = request.getServletContext();
        //填写 相对路径  
        String ap=application1.getRealPath("img/test.jpg");
    
        try (FileInputStream fis1=new FileInputStream(ap);
             BufferedInputStream fis=new  BufferedInputStream(fis1);
             ServletOutputStream outputStream = response.getOutputStream();
        ){
            byte[] data=new byte[4096];
            int len;
            while( (len=fis.read(data) )!= -1) {
                outputStream.write(data,0,len);//写入数据
            }
        } catch (IOException e) {
            e.printStackTrace();
            return;
        }
    
    
        long endTime = System.currentTimeMillis();
        System.out.println("缓冲字节流复制视频花费时间为：" + (endTime - startTime));
    %>

你在运行看看效果  
![在这里插入图片描述][94c0ece3013b40e1ae319b543a8707f9.png]

##### 重定向网页 #####

在某些情况下，当响应客户时，需要将客户引导至另一个页面，例如，当客户输入正确的登录信息时，就需要被引导到登录成功页面，否则被引导到错误显示页面。此时，可以使用 response 的 sendRedirect(URL) 方法将客户请求重定向到一个不同的页面。

这里注意: 是重定向 而不是转发 重定向后上一个页面的数据将丢失

效果等同于 html 中的 <a href=“” >标签

例如，将客户请求重定向到 login.jsp 页面的代码如下：

response.sendRedirect("login.jsp");

##### 错误状态 #####

<table> 
 <thead> 
  <tr> 
   <th><strong>状态码</strong></th> 
   <th><strong>消息</strong></th> 
   <th><strong>描述</strong></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>100</td> 
   <td>Continue</td> 
   <td>只有一部分请求被服务器接收，但只要没被服务器拒绝，客户端就会延续这个请求</td> 
  </tr> 
  <tr> 
   <td>101</td> 
   <td>Switching Protocols</td> 
   <td>服务器交换机协议</td> 
  </tr> 
  <tr> 
   <td>200</td> 
   <td>OK</td> 
   <td>请求被确认</td> 
  </tr> 
  <tr> 
   <td>201</td> 
   <td>Created</td> 
   <td>请求已完成，新的资源被创建</td> 
  </tr> 
  <tr> 
   <td>202</td> 
   <td>Accepted</td> 
   <td>请求被接受，但未处理完</td> 
  </tr> 
  <tr> 
   <td>203</td> 
   <td>Non-authoritative Information</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>204</td> 
   <td>No Content</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>205</td> 
   <td>Reset Content</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>206</td> 
   <td>Partial Content</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>300</td> 
   <td>Multiple Choices</td> 
   <td>一个超链接表，用户可以选择一个超链接并访问，最大支持5个超链接</td> 
  </tr> 
  <tr> 
   <td>301</td> 
   <td>Moved Permanently</td> 
   <td>被请求的页面已经移动到了新的URL下</td> 
  </tr> 
  <tr> 
   <td>302</td> 
   <td>Found</td> 
   <td>被请求的页面暂时性地移动到了新的URL下</td> 
  </tr> 
  <tr> 
   <td>303</td> 
   <td>See Other</td> 
   <td>被请求的页面可以在一个不同的URL下找到</td> 
  </tr> 
  <tr> 
   <td>304</td> 
   <td>Not Modified</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>305</td> 
   <td>Use Proxy</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>306</td> 
   <td><em>Unused</em></td> 
   <td>已经不再使用此状态码，但状态码被保留</td> 
  </tr> 
  <tr> 
   <td>307</td> 
   <td>Temporary Redirect</td> 
   <td>被请求的页面暂时性地移动到了新的URL下</td> 
  </tr> 
  <tr> 
   <td>400</td> 
   <td>Bad Request</td> 
   <td>服务器无法识别请求</td> 
  </tr> 
  <tr> 
   <td>401</td> 
   <td>Unauthorized</td> 
   <td>被请求的页面需要用户名和密码</td> 
  </tr> 
  <tr> 
   <td>402</td> 
   <td>Payment Required</td> 
   <td><em>目前还不能使用此状态码</em></td> 
  </tr> 
  <tr> 
   <td>403</td> 
   <td>Forbidden</td> 
   <td>禁止访问所请求的页面</td> 
  </tr> 
  <tr> 
   <td>404</td> 
   <td>Not Found</td> 
   <td>服务器无法找到所请求的页面</td> 
  </tr> 
  <tr> 
   <td>405</td> 
   <td>Method Not Allowed</td> 
   <td>请求中所指定的方法不被允许</td> 
  </tr> 
  <tr> 
   <td>406</td> 
   <td>Not Acceptable</td> 
   <td>服务器只能创建一个客户端无法接受的响应</td> 
  </tr> 
  <tr> 
   <td>407</td> 
   <td>Proxy Authentication Required</td> 
   <td>在请求被服务前必须认证一个代理服务器</td> 
  </tr> 
  <tr> 
   <td>408</td> 
   <td>Request Timeout</td> 
   <td>请求时间超过了服务器所能等待的时间，连接被断开</td> 
  </tr> 
  <tr> 
   <td>409</td> 
   <td>Conflict</td> 
   <td>请求有矛盾的地方</td> 
  </tr> 
  <tr> 
   <td>410</td> 
   <td>Gone</td> 
   <td>被请求的页面不再可用</td> 
  </tr> 
  <tr> 
   <td>411</td> 
   <td>Length Required</td> 
   <td>"Content-Length"没有被定义，服务器拒绝接受请求</td> 
  </tr> 
  <tr> 
   <td>412</td> 
   <td>Precondition Failed</td> 
   <td>请求的前提条件被服务器评估为false</td> 
  </tr> 
  <tr> 
   <td>413</td> 
   <td>Request Entity Too Large</td> 
   <td>因为请求的实体太大，服务器拒绝接受请求</td> 
  </tr> 
  <tr> 
   <td>414</td> 
   <td>Request-url Too Long</td> 
   <td>服务器拒绝接受请求，因为URL太长。多出现在把"POST"请求转换为"GET"请求时所附带的大量查询信息</td> 
  </tr> 
  <tr> 
   <td>415</td> 
   <td>Unsupported Media Type</td> 
   <td>服务器拒绝接受请求，因为媒体类型不被支持</td> 
  </tr> 
  <tr> 
   <td>417</td> 
   <td>Expectation Failed</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>500</td> 
   <td>Internal Server Error</td> 
   <td>请求不完整，服务器遇见了出乎意料的状况</td> 
  </tr> 
  <tr> 
   <td>501</td> 
   <td>Not Implemented</td> 
   <td>请求不完整，服务器不提供所需要的功能</td> 
  </tr> 
  <tr> 
   <td>502</td> 
   <td>Bad Gateway</td> 
   <td>请求不完整，服务器从上游服务器接受了一个无效的响应</td> 
  </tr> 
  <tr> 
   <td>503</td> 
   <td>Service Unavailable</td> 
   <td>请求不完整，服务器暂时重启或关闭</td> 
  </tr> 
  <tr> 
   <td>504</td> 
   <td>Gateway Timeout</td> 
   <td>网关超时</td> 
  </tr> 
  <tr> 
   <td>505</td> 
   <td>HTTP Version Not Supported</td> 
   <td>服务器不支持所指定的HTTP版本</td> 
  </tr> 
 </tbody> 
</table>

在 JSP 页面中，使用 response 对象中的 sendError() 方法指明一个错误状态。该方法接收一个错误以及一条可选的错误消息，该消息将内容主体返回给客户。

例如，代码 response.sendError(500"请求页面存在错误") 将客户请求重定向到一个在内容主体上包含出错消息的出错页面。

创建index.jsp

创建index1.jsp

<%
        request.setCharacterEncoding("utf-8");
        String user=request.getParameter("user");
        String pwd=request.getParameter("pwd");
        if(user.equals("admin")&&pwd.equals("123"))//判断账户密码
        {
            response.sendRedirect("jsp/ok.jsp");
        }
        else
        {
            response.sendError(500,"请输入正确的用户和密码!");
        }
    %>

创建/jsp/ok.jsp

当登录失败后

![在这里插入图片描述][d400531786ed4f6992970f5ea0cdb6c4.png]

##### 设置响应头 #####

常用的响应头:

<table> 
 <thead> 
  <tr> 
   <th><strong>响应头</strong></th> 
   <th><strong>描述</strong></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>Allow</td> 
   <td>指定服务器支持的request方法（GET，POST等等）</td> 
  </tr> 
  <tr> 
   <td>Cache-Control</td> 
   <td>指定响应文档能够被安全缓存的情况。通常取值为 <strong>public</strong>**，**<strong>private</strong> 或<strong>no-cache</strong> 等等。 Public意味着文档可缓存，Private意味着文档只为单用户服务并且只能使用私有缓存。No-cache 意味着文档不被缓存。</td> 
  </tr> 
  <tr> 
   <td>Connection</td> 
   <td>命令浏览器是否要使用持久的HTTP连接。<strong>close****值</strong> 命令浏览器不使用持久HTTP连接，而keep-alive 意味着使用持久化连接。</td> 
  </tr> 
  <tr> 
   <td>Content-Disposition</td> 
   <td>让浏览器要求用户将响应以给定的名称存储在磁盘中</td> 
  </tr> 
  <tr> 
   <td>Content-Encoding</td> 
   <td>指定传输时页面的编码规则</td> 
  </tr> 
  <tr> 
   <td>Content-Language</td> 
   <td>表述文档所使用的语言，比如en， en-us,，ru等等</td> 
  </tr> 
  <tr> 
   <td>Content-Length</td> 
   <td>表明响应的字节数。只有在浏览器使用持久化 (keep-alive) HTTP 连接时才有用</td> 
  </tr> 
  <tr> 
   <td>Content-Type</td> 
   <td>表明文档使用的MIME类型</td> 
  </tr> 
  <tr> 
   <td>Expires</td> 
   <td>指明啥时候过期并从缓存中移除</td> 
  </tr> 
  <tr> 
   <td>Last-Modified</td> 
   <td>指明文档最后修改时间。客户端可以 缓存文档并且在后续的请求中提供一个 <strong>If-Modified-Since</strong>请求头</td> 
  </tr> 
  <tr> 
   <td>Location</td> 
   <td>在300秒内，包含所有的有一个状态码的响应地址，浏览器会自动重连然后检索新文档</td> 
  </tr> 
  <tr> 
   <td>Refresh</td> 
   <td>指明浏览器每隔多久请求更新一次页面。</td> 
  </tr> 
  <tr> 
   <td>Retry-After</td> 
   <td>与503 (Service Unavailable)一起使用来告诉用户多久后请求将会得到响应</td> 
  </tr> 
  <tr> 
   <td>Set-Cookie</td> 
   <td>指明当前页面对应的cookie</td> 
  </tr> 
 </tbody> 
</table>

response 对象的 setHeader() 方法用于设置指定名字的 HTTP 文件头的值，如果该值已经存在，则新值会覆盖旧值。最常用的一个头信息是 refresh，用于设置刷新或者跳转。

实现页面一秒钟刷新一次，设置语句如下:

response.setHeader("refresh","1");

实现页面定时跳转，如 2 秒钟后自动跳转到URL所指的页面，设置语句如下

response.setHeader("refresh","3;jsp/ok.jsp") ;

例：用 response 对象自动刷新客户页面，实现秒表的功能，代码如下：

<h2> response 对象设置页面自动刷新</h2>
    <font size="5" color=blue> 数字时钟 </font> <br> <br>
    <font size="3" color=blue> 现在时刻：<br>
        <%
            response.setHeader("refresh","1");//每秒刷新一次页面
            int y,m,d,h,mm,s;
            Calendar c=Calendar.getInstance();
            y=c.get(Calendar.YEAR);    //年
            m=c.get(Calendar.MONTH)+1;    //月
            d=c.get(Calendar.DAY_OF_MONTH);    //日
            h=c.get(Calendar.HOUR);    //时（HOUR：十二小时制：HOUR_OF_DAY：十二四小时制）
            mm=c.get(Calendar.MINUTE);    //分
            s=c.get(Calendar.SECOND);    //分
            out.println(y+"年"+m+"月"+d+"日"+h+"时"+mm+"分"+s+"秒");
        %>
    </font>

![在这里插入图片描述][b136dd51da134808980d2262cb9a14a0.png]

##### 转发和重定向的区别 #####

**转发** 就是将页面a 的数据转发到页面b( 处理后发现我好像处理不了) 然后可以在次使用转发 将a页面数据 转发到页面c(进行处理)

url 不变 还是a页面的地址

(注意 转发 不能访问 项目之外 的资源 比如百度等等)

**重定向** 是将请求的url和状态码302返回给跳转前的页面然后让他进行重新跳转 url 变为 跳转的url

也就是说重定向一次就会发送两次请求

(重定向 可以访问 项目之外的 资源 比如: https://www.baidu.com/)

也就是将页面重请求新的页面 url地址更换 和a标签 一样

不能进行上一个页面数据的共享 因为url都变了 request作用域也就没有了 所以request里的数据也就没了

#### session(会话) ####

四大作用域之一session 数据是保存在服务端的

客户与服务器之间的通信是通过 HTTP 协议完成的。HTTP 是一种无状态的协议，当客户向服务器发出请求，服务器接收请求并返回响应后，该连接就被关闭了。此时，服务器端不保留连接的有关信息，要想记住客户的连接信息，可以使用 JSP 提供的 session 对象。

用户登录网站时，系统将为其生成一个独一无二的 session 对象，用以记录该用户的个人信息。一旦用户退出网站，那么，所对应的 session 对象将被注销。session 对象可以绑定若干个用户信息或者 JSP 对象，不同的 session 对象的同名变量是不会相互干扰的。

当用户首次访问服务器上的一个 JSP 页面时，JSP 引擎便产生一个 session 对象，同时分配一个 String 类型的 ID 号，JSP 引擎同时将这个 ID 号发送到客户端，存放在 Cookie 中，这样，session 对象和客户端之间就建立了一一对应的关系。

当用户再次访问该服务器的其他页面时，不再分配给用户新的 session 对象，直到用户关闭浏览器，或者在一定时间(系统默认在 30 分钟内，但可在编写程序时，修改这个时间限定值或者显式地结束一个会话)客户端不向服务器发出应答请求，服务器端就会取消该用户的 session 对象，与用户的会话对应关系消失。当用户重新打开浏览器，再次连接到该服务器时，服务器为该用户再创建一个新的 session 对象。

session 对象保存的是每个用户专用的私有信息，可以是与客户端有关的，也可以是一般信息，可以根据需要设定相应的内容，并且所保存的信息在当前 session 属性范围内是共享的。

简单来说:

session 的生命周期 就是本页面的处理结果 在所有页面关闭前都有效 也就是把游览器关了(超过有效期 和总时间) 也会失效

也就跟打电话一样 只要电话不断就一直有效 而电话就是游览器 但是会有时间限制默认30分钟 没有重定向 和 转发的限制

不同游览器之间数据不通用 因为每个会话的sessionid不同

session对象的常用方法:

<table> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>Object getAttribute(String name)</td> 
   <td>获取指定名字的属性</td> 
  </tr> 
  <tr> 
   <td>Enumeration getAttributeName()</td> 
   <td>获取 session 中全部属性的名字，一个枚举</td> 
  </tr> 
  <tr> 
   <td>long getCreationTime()</td> 
   <td>返回 session 的创建时间，单位：毫秒</td> 
  </tr> 
  <tr> 
   <td>public String getld()</td> 
   <td>返回创建 session 时 JSP 引擎为它设置的唯一 ID 号</td> 
  </tr> 
  <tr> 
   <td>long getLastAccessedTime()</td> 
   <td>返回此 session 中客户端最近一次请求的时间。由 1970-01-01算起，单位是毫秒。使用这个方法，可以判断某个用户在站点上一共停留了多长时间</td> 
  </tr> 
  <tr> 
   <td>int getMaxInactiveInterval()</td> 
   <td>返回两次请求间隔多长时间 session 被销毁(单位：秒)</td> 
  </tr> 
  <tr> 
   <td>void setMaxlnactivelnterval(int interval)</td> 
   <td>设置两次请求间隔多长时间 session 被销毁(单位：秒)</td> 
  </tr> 
  <tr> 
   <td>void invalidate()</td> 
   <td>销毁 session 对象</td> 
  </tr> 
  <tr> 
   <td>boolean isNew()</td> 
   <td>判断请求是否会产生新的 session 对象</td> 
  </tr> 
  <tr> 
   <td>void removeAttxibute(String name)</td> 
   <td>删除指定名字的属性</td> 
  </tr> 
  <tr> 
   <td>void setAttribute(String name,String value)</td> 
   <td>设定指定名字的属性值</td> 
  </tr> 
 </tbody> 
</table>

使用 session 对象在不同的 JSP 文件(整个客户会话过程，即 session scope)中保存属性信息，比如用户名、验证信息等，最为典型的应用是实现网上商店购物车的信息存储。下面重点介绍 session 对象的应用。

##### 创建及获取客户会话属性 #####

JSP 页面可以将任何对象作为属性来保存。使用 setAttribute() 方法设置指定名称的属性，并将其存储在 session 对象中，使用 getAttribute() 方法获取与指定名字 name 相联系的属性。语法格式如下：

session.setAttribute(String name,String value);    //参数name为属性名称，value为属性值
    session.getAttribute(String name);    //参数 name 为属性名称

例: 用 session 对象创建及获取会话属性。通过 session 对象的 setAttribute() 方法，将数据保存在 session 对象中，并通过 getAttribute() 方法取得数据的值，代码如下：

创建index.jsp

<body>
        session 的创建时间：<%=new Date(session.getCreationTime()).toLocaleString() %> <br>
        session 的 ID 号：<%=session.getId() %> <br> <hr>
        当前时间：<%=new Date().toLocaleString( ) %> <br>
        该 session 是新创建的吗？：<%=session.isNew()?"是":"否" %> <br> <hr>
        当前时间：<%=new Date().toLocaleString( ) %> <br>
        <% session.setAttribute("info","您好，我们正在使用 session 对象传递数据！"); %>
        已向 Session 中保存数据，请单击下面的链接将页面重定向到 idnex1.jsp
        <a href="index1.jsp"> 请按这里</a>
    </body>

创建index1.jsp

获取 session 中的数据为：<br>
    <%=session.getAttribute("info")%>

##### 从会话中移除指定的对象 #####

JSP 页面可以将任何已经保存的对象部分或者全部移除。使用 removeAttribute() 方法，将指定名称的对象移除，也就是说，从这个会话删除与指定名称绑定的对象。使用 invalidate() 方法，可以将会话中的全部内容删除。语法格式如下：

session.removeAttribute(String name);    //参数name为session对象的属性名，代表要移除的对象名
    session.invalidate();    //把保存的所有对象全部删除

在上面的案例中将index1.jsp改造

移除 session 中的数据后：<br>
    <%
        session.removeAttribute("info");
        if(session.getAttribute("info")==null)
        {
            out.println("session 对象 info 已经不存在");
        }
        else
        {
            out.println(session.getAttribute("info"));
        };
    
    %>

index1.jsp显示

移除 session 中的数据后：
    session 对象 info 已经不存在

##### 设置会话时限 #####

当某一客户与 Web 应用程序之间处于非活动状态时，并不以显式的方式通知服务器，所以，在 Servlet 程序或 JSP 文件中，做超时设置是确保客户会话终止的唯一方法。

Servlet 程序容器设置一个超时时长，当客户非活动的时间超出时长的大小时，JSP 容器将使 session 对象无效，并撤销所有属性的绑定，这样，就清除了客户申请的资源，从而实现了会话生命周期的管理。

session 用于管理会话生命周期的方法有 getLastAccessedTime()、getMaxInactiveInterval() 和 setMaxInactiveInterval(int interval)。

例: 为 session 对象设置会话时限。首先输出 session 对象默认的有效时间，然后设置为 5 分钟，并输出新设置的有效时间。代码如下：

<body>
        session 对象默认的有效时间：<%=session.getMaxInactiveInterval()%>秒<br>
        <%
        session.setMaxInactiveInterval(60*5);    //设置session的有效时间为5分钟
        %>
        已经将 session 有效时间修改为：<%=session.getMaxInactiveInterval()%>秒<br>
    </body>

页面显示

session 对象默认的有效时间：1800秒
    已经将 session 有效时间修改为：300秒

设置总默认会话时间

原本默认为30分钟 也就是 1800秒

在配置文件web.xml里 添加

<session-config>
    
      <session-timeout>60</session-timeout>
    
    </session-config>

然后使用下面的代码看看

session 对象默认的有效时间：<%=session.getMaxInactiveInterval()%>秒<br>

页面显示

session 对象默认的有效时间：3600秒

设置

#### application(应用程序) ####

四大作用域之一application 数据保存在服务器里

JSP application 对象用于保存应用程序的公用数据，服务器启动并自动创建 application 对象后，只要没有关闭服务器，application 对象就一直存在，所有用户共享 application 对象。

不同游览之间都能 获取 到application 内的值 因为值是保存在服务器上的 没有session那样的限制 需要sessionid

类似于系统的全局变量 也就是application里储存的值 是可以被多个页面同时调用的

application 对象的常用方法。

<table> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>getAttribute( String arg)</td> 
   <td>获取 application 对象中含有关键字的对象</td> 
  </tr> 
  <tr> 
   <td>getAttributeNames()</td> 
   <td>获取 application 对象的所有参数名字</td> 
  </tr> 
  <tr> 
   <td>getMajorVersion()</td> 
   <td>获取服务器支持 Servlet 的主版本号</td> 
  </tr> 
  <tr> 
   <td>getMinorVersion()</td> 
   <td>获取服务器支持 Servlet 的从版本号</td> 
  </tr> 
  <tr> 
   <td>removeAttribute(java.lang.String name)</td> 
   <td>根据名字删除 application 对象的参数</td> 
  </tr> 
  <tr> 
   <td>setAttribute(String key,Object obj)</td> 
   <td>将参数 Object 指定的对象 obj 添加到 application 对象中，并 为添加的对象指定一个索引关键字</td> 
  </tr> 
 </tbody> 
</table>

例: 利用 application 对象查找 Servlet 有关的属性信息，包括 Servlet 的引擎名、版本号、服务器支持的 Servlet API 的最大和最小版本号、指定资源的路径等。代码如下：

创建idnex.jsp

<body>
    JSP（SERVLET）引擎名及版本号:
    <%=application.getServerInfo()%><br>
    服务器支持的 Server API 的最大版本号:
    <%=application.getMajorVersion ()%><br>
    服务器支持的 Server API 的最小版本号:
    <%=application.getMinorVersion ()%><br>
    指定资源（文件及目录）的 URL 路径:
    <%=application.getResource("index.jsp")%><br>
    返回 index.jsp 虚拟路径的真实路径:<br>
    <%=application.getRealPath("index.jsp")%>
    </body>

页面显示

JSP（SERVLET）引擎名及版本号: Apache Tomcat/9.0.29
    服务器支持的 Server API 的最大版本号: 4
    服务器支持的 Server API 的最小版本号: 0
    指定资源（文件及目录）的 URL 路径: file:/C:/Users/12841/IdeaProjects/java-Web/target/java-Web/index.jsp
    返回 index.jsp 虚拟路径的真实路径:
    C:\Users\12841\IdeaProjects\java-Web\target\java-Web\index.jsp

**管理应用程序属性**

application 对象与 session 对象相同，都可以设置属性。但是，两个属性的有效范围是不同的。

在 session 对象中，设置的属性只在当前客户的会话范围(session scope)有效，客户超过预期时间不发送请求时，session 对象将被回收。

在 application 对象中设置的属性在整个应用程序范围(application scope)都有效。即使所有的用户都不发送请求，只要不关闭应用服务器，在其中设置的属性也是有效的。

列: 用 application 对象的 setAttribute() 和 getAttribute() 方法 实现网页计数器功能(记录网站的访问量)，代码如下：

<%
        int n=0;
        if(application.getAttribute("num")==null)
            n=1;
        else
        {
            String str=application.getAttribute("num").toString();
            //getAttribute("num")返回的是Object类型
            n=Integer.valueOf(str).intValue()+1;
        }
        application.setAttribute("num",n);
        out.println("您好,您是第"+application.getAttribute("num")+"位访问客户！");
    %>

然后你刷新页面看看效果

您好,您是第3位访问客户！

#### out对象(输出) ####

out 对象是一个输出流，用来向客户端输出数据，可以是各种数据类型的内容，同时，它还可以管理应用服务器上的输出缓冲区，缓冲区的默认值是 8KB，可以通过页面指令 page 来改变默认大小。

out 对象是一个继承自抽象类 javax.servlet.jsp.JspWriter 的实例，在实际应用中，out 对象会通过 JSP 容器变换为 java.io.PrintWriter 类的对象。

在使用 out 对象输出数据时，可以对数据缓冲区进行操作，及时清除缓冲区中的残余数据，为其他的输出让出缓冲空间。数据输出完毕后要及时关闭输出流。下面介绍 out 对象的应用。

out 对象常用的方法

<table> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>void print(各种数据类型)</td> 
   <td>将指定类型的数据输出到 HTTP 流，不换行</td> 
  </tr> 
  <tr> 
   <td>void println(各种数据类型)</td> 
   <td>将指定类型的数据输出到 HTTP 流，并输出一个换行符</td> 
  </tr> 
  <tr> 
   <td>void newline</td> 
   <td>输出换行字符</td> 
  </tr> 
 </tbody> 
</table>

##### 向客户端输出数据 #####

在使用 print() 或 println() 方法向客户端输出时，由于客户端是浏览器，因此可以使用 HTML 中的一些标记控制输出格式。例如：

<%
        out.println("<font color=red>Hello </font>");
    %>

##### 管理输出缓冲区 #####

默认情况下，服务端要输出到客户端的内容不直接写到客户端，而是先写到一个输出缓冲区中。使用 out 对象的 getBufferSize() 方法取得当前缓冲区的大小(单位是 KB)，用 getRemaining() 方法取得当前使用后还剩余的缓冲区的大小(单位是 KB)。

JSP 只有在下面三种情况下，才会把缓冲区的内容输出到客户端。

• 该 JSP 网页已完成信息的输出。

• 输出缓冲区己满

• JSP 中调用了 out.flush() 或 response.flushBuffer()。

另外，调用 out 对象的 clear() 方法，可以清除缓冲区的内容，类似于重置响应流，以便重新开始操作。如果响应已经提交，则会产生 IOException 异常。此外，另一种方法 clearBuffer() 可以清除缓冲区“当前”内容，而且即使内容已经提交给客户端，也能够访问该方法。

例: 用 out 对象管理输出缓冲区，代码如下：

<%out.println("使用out对象管理输出缓冲区:<br>");%> <br>
    缓冲大小：<%=out.getBufferSize()%> <br>
    剩余缓存大小：<%=out.getRemaining()%> <br>
    是否自动刷新：<%=out.isAutoFlush()%> <br>

通过改变println 来观察变化

#### pageContext对象(页面上下文对象) ####

pageContext 是页面上下文对象，这个特殊的对象提供了 JSP 程序执行时所需要用到的所有属性和方法，如 session、application、config、out 等对象的属性，也就是说，它可以访问本页所有的 session，也可以取本页所在的 application 的某一属性值，它相当于页面中所有其他对象功能的集合，可以用它访问本页中所有的其他对象。

pageContext 对象是 javax.servlet:jsp.pageContext 类的一个实例，它的创建和初始化都是由容器来完成的，JSP 页面里可以直接使用 pageContext 对象的句柄，pageContext 对象的 getXxx()、setXxx() 和 findXxx() 方法可以根据不同的对象范围实现对这些对象的管理。列出了 pageContext 对象的常用方法:

<table> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>void forward(String relativeUrlPath)</td> 
   <td>把页面转发到另一个页面或者 Servlet 组件上</td> 
  </tr> 
  <tr> 
   <td>Exception getException()</td> 
   <td>返回当前页的 Exception 对象</td> 
  </tr> 
  <tr> 
   <td>ServletRequest getRequest()</td> 
   <td>返回当前页的 request 对象</td> 
  </tr> 
  <tr> 
   <td>ServletResponse getResponse()</td> 
   <td>返回当前页的 response 对象</td> 
  </tr> 
  <tr> 
   <td>ServletConfig getServletConfig()</td> 
   <td>返回当前页的 ServletConfig 对象</td> 
  </tr> 
  <tr> 
   <td>HttpSession getSession()</td> 
   <td>返回当前页的 session 对象</td> 
  </tr> 
  <tr> 
   <td>Object getPage()</td> 
   <td>返回当前页的 page 对象</td> 
  </tr> 
  <tr> 
   <td>ServletContext getServletContext()</td> 
   <td>返回当前页的 application 对象</td> 
  </tr> 
  <tr> 
   <td>public Object getAttribute(String name)</td> 
   <td>获取属性值</td> 
  </tr> 
  <tr> 
   <td>Object getAttribute(String name,int scope)</td> 
   <td>在指定的范围内获取属性值</td> 
  </tr> 
  <tr> 
   <td>void setAttribute(String name,Object attribute)</td> 
   <td>设置属性及属性值</td> 
  </tr> 
  <tr> 
   <td>void setAttribute(String name,Object obj,int scope)</td> 
   <td>在指定范围内设置属性及属性值</td> 
  </tr> 
  <tr> 
   <td>void removeAttribute(String name)</td> 
   <td>删除某属性</td> 
  </tr> 
  <tr> 
   <td>void removeAttribute(String name,int scope)</td> 
   <td>在指定范围内删除某属性</td> 
  </tr> 
  <tr> 
   <td>void invalidate()</td> 
   <td>返回 servletContext 对象，全部销毁</td> 
  </tr> 
 </tbody> 
</table>

pageContext 对象的主要作用是提供一个单一界面，以管理各种公开对象(如 session、application、config、request、response 等)，提供一个单一的 API 来管理对象和属性。

通过 pageContext 对象取得不同范围的属性值，代码如下：

<body>
    <%
        request.setAttribute("info","value of request scope");
        session.setAttribute("info","value of request scope");
        application.setAttribute("info","value of application scope");
    %>
    利用 pageContext 取出以下范围内各值(方法一)：<br>
    request 设定的值：<%=pageContext.getRequest().getAttribute("info") %> <br>
    session 设定的值：<%=pageContext.getSession().getAttribute("info") %> <br>
    application 设的值：<%=pageContext.getServletContext().getAttribute("info") %> <hr>
    利用pageContext取出以下范围内各值(方法二)：<br>
    范围1(page)内的值：<%=pageContext.getAttribute("info",1) %> <br>
    范围2(request)内的值：<%=pageContext.getAttribute("info",2) %> <br>
    范围3(session)内的值：<%=pageContext.getAttribute("info",3) %> <br>
    范围4(application)内的值：<%=pageContext.getAttribute("info",4) %> <hr>
    利用 pageContext 修改或删除某个范围内的值：<br>
    修改 request 设定的值：
    <% pageContext.setAttribute("info","value of request scope is modified by pageContext",2); %> <br>
    修改后:<%=pageContext.getRequest().getAttribute("info") %> <br>
    删除: session 设定的值：<br>
    <% pageContext.removeAttribute("info"); %>
    删除后:<%=session.getAttribute("info") %>
    </body>

页面显示

利用 pageContext 取出以下范围内各值(方法一)：
    request 设定的值：value of request scope
    session 设定的值：value of request scope
    application 设的值：value of application scope 利用pageContext取出以下范围内各值(方法二)：
    范围1(page)内的值：null
    范围2(request)内的值：value of request scope
    范围3(session)内的值：value of request scope
    范围4(application)内的值：value of application scope 利用 pageContext 修改或删除某个范围内的值：
    修改 request 设定的值：
    修改后:value of request scope is modified by pageContext
    删除: session 设定的值：
    删除后:null

#### config对象(配置对象) ####

当一个 Servlet 初始化时，容器把某些信息通过此对象传递给这个 Servlet，这些信息包括 Servlet 初始化时所要用到的参数(通过属性名和属性值构成)以及服务器的有关信息，config 对象的应用范围是本页。

开发者可以在 web.xml 文件中为应用程序环境中的 Servlet 程序和 JSP 页面提供初始化参数

config对象的常用方法

<table> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>ServletContext getServletContext()</td> 
   <td>返回所执行的 Servlet 的环境对象</td> 
  </tr> 
  <tr> 
   <td>String getServletName()</td> 
   <td>返回所执行的 Servlet 的名字</td> 
  </tr> 
  <tr> 
   <td>String getInitParameter(String name)</td> 
   <td>返回指定名字的初始参数值</td> 
  </tr> 
  <tr> 
   <td>Enumeration getlnitParameterName()</td> 
   <td>返回该 JSP 中所有初始参数名，一个枚举</td> 
  </tr> 
 </tbody> 
</table>

列:

在web.xml中添加如下参数

<servlet>
        
        <servlet-name>config_index</servlet-name>
        
        <jsp-file>/index.jsp</jsp-file>
        
        <init-param>
          <param-name>name</param-name>
          <param-value>yeeku</param-value>
        </init-param>
        
        <init-param>
          <param-name>age</param-name>
          <param-value>30</param-value>
        </init-param>
      </servlet>
      <servlet-mapping>
        
        <servlet-name>config_index</servlet-name>
        <url-pattern>/index.jsp</url-pattern>
    
      </servlet-mapping>

创建/index.jsp

<%=config.getServletName()%><br>
    
    name配置参数的值：<%=config.getInitParameter("name")%><br/>
    
    age配置参数的值：<%=config.getInitParameter("age")%>

config_index
    name配置参数的值：yeeku
    age配置参数的值：30

#### exception(异常处理) ####

当编写JSP程序的时候，程序员可能会遗漏一些BUG，这些BUG可能会出现在程序的任何地方。JSP代码中通常有以下几类异常:

*  检查型异常:检查型异常就是一个典型的用户错误或者一个程序员无法预见的错误。举例来说，如果一个文件将要被打开，但是无法找到这个文件，则一个异常被抛出。这些异常不能在编译期被简单地忽略。
 *  运行时异常:一个运行时异常可能已经被程序员避免，这种异常在编译期将会被忽略。
 *  错误:错误不是异常，但问题是它超出了用户或者程序员的控制范围。错误通常会在代码中被忽略，您几乎不能拿它怎么样。举例来说，栈溢出错误。这些错误都会在编译期被忽略。

Throwable类中一些重要的方法:

<table> 
 <thead> 
  <tr> 
   <th>属性</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><strong>String getMessage()</strong></td> 
   <td>返回异常的信息</td> 
  </tr> 
  <tr> 
   <td><strong>String toString()</strong></td> 
   <td>返回类名+异常信息</td> 
  </tr> 
  <tr> 
   <td><strong>void printStackTrace()</strong></td> 
   <td>将异常栈轨迹输出至System.err 控制台里</td> 
  </tr> 
 </tbody> 
</table>

JSP提供了可选项来为每个JSP页面指定错误页面。无论何时页面抛出了异常，JSP容器都会自动地调用错误页面。

接下来的例子为index.jsp指定了一个发生错误的页面。使用<%@page errorPage=“XXXXX”%>指令指定一个错误页面。

创建index.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8" isELIgnored="true" pageEncoding="UTF-8" %>
    <%@ page errorPage="error.jsp" %>
    <html>
    <head>
        <title>index</title>
    </head>
    <body>
    <%
         int i=1/0;
        System.out.println(i);
    %>
    </body>
    </html>

创建error.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
    <%--指定当前页面为错误页面--%>
    <%@ page isErrorPage="true" %>
    <html>
    <head>
        <title>Title</title>
    </head>
    <body>
    <h1>发生错误了</h1>
    
    <%
        String message = exception.getMessage();
        out.println("异常消息::"+message);
    %>
    </body>
    </html>

当页面index.jsp发生错误自动跳转到error.jsp中

#### Cookies处理 ####

Cookies是存储在客户机的文本文件，它们保存了大量轨迹信息。在servlet技术基础上，JSP显然能够提供对HTTP cookies的支持。

通常有三个步骤来识别回头客：

● 服务器脚本发送一系列cookies至浏览器。比如名字，年龄，ID号码等等。

● 浏览器在本地机中存储这些信息，以备不时之需。

● 当下一次浏览器发送任何请求至服务器时，它会同时将这些cookies信息发送给服务器，然后服务器使用这些信息来识别用户或者干些其它事情。

**Cookie剖析**

Cookies通常在HTTP信息头中设置(虽然JavaScript能够直接在浏览器中设置cookies)。在JSP中，设置一个cookie需要发送如下的信息头给服务器

HTTP/1.1 200 OK
    Date: Fri, 04 Feb 2000 21:03:38 GMT
    Server: Apache/1.3.9 (UNIX) PHP/4.0b3
    Set-Cookie: name=xyz; expires=Friday, 04-Feb-07 22:03:38 GMT; 
                     path=/; domain=tutorialspoint.com
    Connection: close
    Content-Type: text/html

正如您所见，Set-Cookie信息头包含一个键值对，一个GMT(格林尼治标准)时间，一个路径，一个域名。键值对会被编码为URL。有效期域是个指令，告诉浏览器在什么时候之后就可以清除这个cookie。

如果浏览器被配置成可存储cookies，那么它将会保存这些信息直到过期。如果用户访问的任何页面匹配了cookie中的路径和域名，那么浏览器将会重新将这个cookie发回给服务器。浏览器端的信息头长得就像下面这样：

GET / HTTP/1.0
    Connection: Keep-Alive
    User-Agent: Mozilla/4.6 (X11; I; Linux 2.2.6-15apmac ppc)
    Host: zink.demon.co.uk:1126
    Accept: image/gif, */*
    Accept-Encoding: gzip
    Accept-Language: en
    Accept-Charset: iso-8859-1,*,utf-8
    Cookie: name=xyz

Cookie对象中常用的方法：

<table> 
 <thead> 
  <tr> 
   <th>序号</th> 
   <th>方法 &amp; 描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>public void setDomain(String pattern)</td> 
   <td>设置cookie的域名，比如w3cschool.cn</td> 
  </tr> 
  <tr> 
   <td>public String getDomain()</td> 
   <td>获取cookie的域名，比如w3cschool.cn</td> 
  </tr> 
  <tr> 
   <td>public void setMaxAge(int expiry)</td> 
   <td>设置cookie有效期，以秒为单位，默认有效期为当前session的存活时间</td> 
  </tr> 
  <tr> 
   <td>public int getMaxAge()</td> 
   <td>获取cookie有效期，以秒为单位，默认为-1 ，表明cookie会活到浏览器关闭为止</td> 
  </tr> 
  <tr> 
   <td>public String getName()</td> 
   <td>返回 cookie的名称，名称创建后将不能被修改</td> 
  </tr> 
  <tr> 
   <td>public void setValue(String newValue)</td> 
   <td>设置 cookie的值</td> 
  </tr> 
  <tr> 
   <td>public String getValue()</td> 
   <td>获取cookie的值</td> 
  </tr> 
  <tr> 
   <td>public void setPath(String uri)</td> 
   <td>设置cookie 的路径，默认为当前页面目录下的所有URL，还有此目录下的所有子目录</td> 
  </tr> 
  <tr> 
   <td>public String getPath()</td> 
   <td>获取cookie 的路径</td> 
  </tr> 
  <tr> 
   <td>public void setSecure(boolean flag)</td> 
   <td>指明cookie是否要加密传输</td> 
  </tr> 
  <tr> 
   <td>public void setComment(String purpose)</td> 
   <td>设置注释描述 cookie的目的。当浏览器将cookie展现给用户时，注释将会变得非常有用</td> 
  </tr> 
  <tr> 
   <td>public String getComment()</td> 
   <td>返回描述cookie目的的注释，若没有则返回null</td> 
  </tr> 
 </tbody> 
</table>

**使用JSP设置Cookies**

使用JSP设置cookie包含三个步骤：

(1)创建一个Cookie对象： 调用Cookie的构造函数，使用一个cookie名称和值做参数，它们都是字符串。

Cookie cookie = new Cookie("key","value");

请务必牢记，名称和值中都不能包含空格或者如这些的字符： `[ ] ( ) = , " / ? @ : ;`

(2)设置访问cookie的路径 一般都为/ (也就是当前项目下所有页面都能访问)

设置cookie访问路径 只有此路径下页面才能访问 如果不设置默认为当前调用cookie页面的路径

cookie.setPath("/");

(3) 设置有效期：调用setMaxAge()函数表明cookie在多长时间(以秒为单位)内有效。下面的操作将有效期设为了24小时=1天。

如果为 0 Cookie将被删除

cookie.setMaxAge(60*60*24);

(4) 将cookie发送至HTTP响应头中：调用response.addCookie()函数来向HTTP响应头中添加cookies。

response.addCookie(cookie);

**设置Cookie**

创建index.jsp

<%
        // 为 name 和 age设置cookie
        Cookie name = new Cookie("name", "huanmin");
        Cookie age = new Cookie("pass","123");
        name.setPath("/"); 
        age.setPath("/");
        // 设置cookie过期时间为24小时。
        name.setMaxAge(60*60*24);
        age.setMaxAge(60*60*24);
        // 在响应头部添加cookie
        response.addCookie( name );
        response.addCookie( age );
    %>

设置完我们可以打开火狐游览器 F12

![在这里插入图片描述][b212a462e34d4a4a9c07347fa4caa650.png]

**获取Cookie**

创建index1.jsp

<%
        Cookie cookie = null;
        Cookie[] cookies = null;
        // 获取cookies的数据,是一个数组
        cookies = request.getCookies();
        if( cookies != null ){
            for (int i = 0; i < cookies.length; i++){
                cookie = cookies[i];
    
                if (cookie.getName().equals("name")){
                    out.print("name : " + cookie.getName( ) + ", ");
                    out.print("Value: " + cookie.getValue( )+" <br/>");
                }
                if (cookie.getName().equals("pass")){
                    out.print("name : " + cookie.getName( ) + ", ");
                    out.print("Value: " + cookie.getValue( )+" <br/>");
                }
    
    
            }
        }else{
            out.println("<h2>No cookies founds</h2>");
        }
    %>

页面显示

name : name, Value: huanmin
    name : pass, Value: 123

**删除Cookies**

删除cookie原理就是让cookie内对象的有效期为0就会自动被删除

删除cookie内的全部数据

<%
        Cookie[] cookie1=request.getCookies();
    
        for(int i=0;i<cookie1.length;i++){
            cookie1[i].setMaxAge(0);
            cookie1[i].setPath("/");//必须加上否则删除失败
            response.addCookie(cookie1[i]);
        }
    %>

**删除指定Cookie**

<%
        //获取cookue对象
        Cookie[] cookie=request.getCookies();
        if(cookie!=null){   //判断对象是否有值
            for(int i=0;i<cookie.length;i++){
                //获取集合中 的对象 值
                if(cookie[i].getName().equals("name")){
                    cookie[i].setMaxAge(0);
                    cookie[i].setPath("/");
                    response.addCookie(cookie[i]);
    
                }
                if(cookie[i].getName().equals("pass")){
                    cookie[i].setMaxAge(0);
                    cookie[i].setPath("/");
                    response.addCookie(cookie[i]);
                }
                out.print(cookie[i].getValue());
            }
        }
    
    %>

#### cookie与session区别 ####

cookie 是保存在客户端可以长期保存(自定义) 而session是保存在服务器中 结束访问就会销毁数据

cookie保存的是String类型的 而session保存的是一个地址对象Object

cookie 一般保存不重要的信息 比如: 免登陆 ,验证令牌 等

因为是存储在用户电脑上可控制性不强 (可以加密)

session 是保存在服务器中 访问结束就会删除 访问信息 比较安全 无法被第三方 访问到

### 控制流语句 ###

JSP提供对Java语言的全面支持。您可以在JSP程序中使用Java API甚至建立Java代码块，包括判断语句和循环语句等等。

和java 语法一样 就是需要使用<% %> 将代码包裹起来才能使用

#### 判断语句 ####

If…else块，请看下面这个例子：

<%! int day = 3; %> 
    
    <% if (day == 1 | day == 7) { %>      
      <p> Today is weekend</p>
    <% } else { %>      
      <p> Today is not weekend</p>
    <% } %>

页面显示

> Today is not weekend

if else if 这个就不用说了吧 照葫芦画瓢 总会吧

<%! int day = 3; %>
    
    <% if (day == 1 | day == 7) { %>
    <p> Today is weekend</p>
    <% } else if(day==3){ %>
    <p> Today is not weekend</p>
    <% } else {%>
    <p> NO</p>
    <%} %>

现在来看看switch…case块，与if…else块有很大的不同，它使用out.println() 来输出到页面上，并且整个都装在脚本程序的标签中，就像下面这样：

<%! int day = 3; %>
    
    <%  
    switch(day) { 
    case 0:    
      out.println("It\'s Sunday.");    
      break; 
    case 1:    
      out.println("It\'s Monday.");    
      break; 
    case 2:    
      out.println("It\'s Tuesday.");    
      break; 
    case 3:    
      out.println("It\'s Wednesday.");    
      break; 
    case 4:    
      out.println("It\'s Thursday.");    
      break; 
    case 5:    
      out.println("It\'s Friday.");    
      break; 
    default:    
      out.println("It's Saturday."); 
    } 
    %>

页面显示

> It’s Wednesday.

#### 循环语句 ####

在JSP程序中可以使用Java的三个基本循环类型：for，while，和 do…while。

让我们来看看for循环的例子：

<%! int fontSize; %>
    
    <%for ( fontSize = 1; fontSize <= 3; fontSize++){ %>
    <font color="green" size="<%= fontSize %>">JSP Tutorial</font><br />
    <%}%>

![在这里插入图片描述][e859f14a45a84f558711050cefa8c39e.png]

将上例改用while循环来写：

<%! int fontSize; %>
    
    <%
        fontSize=1;
        while ( fontSize <= 3){
    %>
    <font color="green" size="<%= fontSize %>">
        JSP Tutorial
    </font><br />
    <%fontSize++;%>
    <%}%>

![在这里插入图片描述][1847eaea0c1a4232b0d996480db2cf60.png]

#### JSP运算符 ####

JSP支持所有Java逻辑和算术运算符。

下表罗列出了JSP常见运算符，优先级从高到底：

#### JSP常量 ####

与Java中的一样 使用final 关键字 不可以被修改

比如:

<%!  final int FONTSIZE=15; %>
    <%!  final String FINAL="常亮"; %>

### JSP开发模式 ###

必须明白java三层框架 然后在来看 jsp必须知道jsp的几种开发模式

JSP 程序开发模式包括 JSP 编程、JSP+JavaBean 编程、JSP+JavaBean+Servlet 编程、MVC 模式。

#### 单纯的JSP编程 ####

在 JSP 编程模式下，通过应用 JSP 中的脚本标志，可以直接在 JSP 页面中实现各种功能。虽然这种模式很容易实现，但是，其缺点也非常明显。因为将大部分的 Java 代码与 HTML 代码混淆在一起，会给程序的维护和调试带来很多困难，而且难以理清完整的程序结构。

这就好比规划管理一个大型企业，如果将负责不同任务的所有员工都安排在一起工作，势必会造成公司秩序混乱、不易管理等许多隐患。所以说，单纯的 JSP 页面编程模式是无法应用到大型、中型甚至小型的 JSP Web 应用程序开发中的。

#### JSP+JavaBean 编程 ####

JSP+JavaBean 编程模式是 JSP 程序开发经典设计模式之一，适合小型或中型网站的开发。利用 JavaBean 技术，可以很容易地完成一些业务逻辑上的操作，例如数据库的连接、用户登录与注销等。

JavaBean 是一个遵循了一定规则的 Java 类，在程序的开发中，将要进行的业务逻辑封装到这个类中，在 JSP 页面中，通过动作标签来调用这个类，从而执行这个业务逻辑。此时的 JSP 除了负责部分流程的控制外，主要用来进行页面的显示，而 JavaBean 则负责业务逻辑的处理。

可以看出，JSP+JavaBean 设计模式具有一个比较清晰的程序结构，在 JSP 技术的起步阶段，该模式曾被广泛应用。

如下:表示该模式对客户端的请求进行处理的过程，相关的说明如下。

![在这里插入图片描述][b11f31ae33cf442f97892601113967fc.png]

1.用户通过客户端浏览器请求服务器。

2.服务器接收用户请求后调用 JSP 页面。

3.在 JSP 页面中调用 JavaBean。

4.在 JavaBean 中连接及操作数据库，或实现其他业务逻辑。

5.JavaBean 将执行的结果返回 JSP+ 页面。

6.服务器读取 JSP 页面中的内容(将页面中的静态内容与动态内容相结合)。

7.服务器将最终的结果返回给客户端浏览器进行显示。

结构演示:

![在这里插入图片描述][be41c55bedb14b7a97626393a541cf7a.png]

明白的人自然就懂 不明白的永远都不明白

总结: jsp(既当爹又当妈) +javaBean(就只干数据访问层)

现在基本都没人用这模式 除非你是自己开发

#### JSP+JavaBean+Servlet 编程 ####

JSP+JavaBean 设计模式虽然已经对网站的业务逻辑和显示页面进行了分离，但这种模式下的 JSP 不但要控制程序中的大部分流程，而且还要负责页面的显示，所以仍然不是一种理想的设计模式。

在 JSP+JavaBean 设计模式的基础上加入 Servlet 来实现程序中的控制层，是一个很好的选择。在这种模式中，由 Servlet 来执行业务逻辑并负责程序的流程控制，JavaBean 组件实现业务逻辑，充当模型的角色，JSP 用于页面的显示。可以看出，这种模式使得程序中的层次关系更明显，各组件的分工也非常明确。下图表示该模式对客户端的请求进行处理的过程。

![在这里插入图片描述][ee2e103596f543479ce54dbf21568901.png]

各步骤的说明如下:

1.用户通过客户端浏览器请求服务器。

2.服务器接收用户请求后调用 Servlet。

3.Servlet 根据用户请求调用 JavaBean 处理业务。

4.在 JavaBean 中连接及操作数据库，或实现其他业务逻辑。

5.JavaBean 将结果返回 Servlet，在 Servlet 中将结果保存到请求对象中。

6.由 Servlet 转发请求到 JSP 页面。

7.服务器读取 JSP 页面中的内容(将页面中的静态内容与动态内容结合)。

8.服务器将最终的结果返回给客户端浏览器进行显示。

结构演示:

![在这里插入图片描述][a97e623d4ebe48f189c038332bba3c84.png]

总结:jsp(只负责显示数据) + JavaBean(数据访问处理) +Servlet(对要显示的数据进行整合 不用在jsp页面在处理了)

但 JSP+JavaBean+Servlet 模式同样也存在缺点。

因为一个请求(功能) 就要对应一个Servlet 如果100个请求呢1000个呢 那么又会出现多少个Servlet呢? 这就会造成逻辑混乱 类堆积 维护比较难

当然有解决办法 就是使用MVC模式

#### MVC 模式 ####

MVC(Model-View-Controller，模型-视图-控制器)是一种程序设计概念，它同时适用于简单的和复杂的程序。使用该模式，可将待开发的应用程序分解为三个独立的部分：模型、视图和控制器。

提出这种设计模式主要是因为应用程序中用来完成任务的代码(模型，也称为“业务逻辑”)通常是程序中相对稳定的部分，并且会被重复使用，而程序与用户进行交互的页面(视图)，却是经常改变的。

如果因需要更新页面而不得不对业务逻辑代码进行改动，或者要在不同的模块中应用相同的功能时重复地编写业务逻辑代码，不仅会降低整体程序开发的进程，而且会使程序变得难以维护。**因此将业务逻辑代码与外观呈现分离**，将会更容易地根据需求的改变来改进程序。MVC 模式的模型如图 所示。

![在这里插入图片描述][b2ee25c462da4ad9af58fa94078674d8.png]

Model(模型)：MVC 模式中的 Model(模型)指的是业务逻辑的代码，是应用程序中真正用来完成任务的部分。

View(视图)：视图实际上就是程序与用户进行交互的界面，用户可以看到它的存在。视图可以具备一定的功能，并应遵守对其所做的约束。在视图中，不应包含对数据处理的代码，即业务逻辑代码。

Controller(控制器)：控制器主要用于控制用户请求并做出响应。它根据用户的请求，选择模型或修改模型，并决定返回什么样的视图。

虽然用来实现 MVC 设计模式的技术可能都是相同的，但各公司都有自己的 MVC 架构。也就是说，这些公司用来实现自己的 MVC 架构所应用的技术可能都是 JSP、Servlet 与 JavaBean，但它们的流程及设计却是不同的，所以工程师需要花更多的时间去了解。

从项目开发的观点上来说，因为需要设计 MVC 各对象之间的数据交换格式与方法，所以在系统的设计上需要花费更多的时间。

但是现在市面上有很多成熟的MVC创建可以选择一个实现了 MVC 模式的现成的框架，在此框架的基础上进行开发，能够大大节省开发时间，会取得事半功倍的效果。目前，已有很多可以使用的现成的 MVC 框架，例如 Struts SSM 框架。

我这里给你展示一个我之前做的SSM项目结构图

![在这里插入图片描述][165445bc730a4bcbbd6ddc0e7f263aeb.png]

总结:jsp(只负责显示数据) + JavaBean(数据访问处理) +controller(对要显示的数据进行整合 不用在jsp页面在处理了)

controller 和servlet 感觉上是不是差不多 但是呢实际上 controller底层还是servlet

就是对servlet进行一层封装 过滤… 当访问 controller成功后 将结果给servlet 而已

只不过springmvc帮助你做好了url和method的映射了（注解实现），不需要你自己在web.xml一个servlet和一个method去配置了

### 国际化开发 ###

下表列举出了Locale对象中比较重要的方法，用于检测request对象的地区，语言，和区域。所有这些方法都会在浏览器中显示国家名称和语言名称：

<table> 
 <thead> 
  <tr> 
   <th>序号</th> 
   <th>方法 &amp; 描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>String getCountry()</td> 
   <td>返回国家/地区码的英文大写，或 ISO 3166 2-letter 格式的区域</td> 
  </tr> 
  <tr> 
   <td>String getDisplayCountry()</td> 
   <td>返回要显示给用户的国家名称</td> 
  </tr> 
  <tr> 
   <td>String getLanguage()</td> 
   <td>返回语言码的英文小写，或ISO 639 格式的区域</td> 
  </tr> 
  <tr> 
   <td>String getDisplayLanguage()</td> 
   <td>返回要给用户看的语言名称</td> 
  </tr> 
  <tr> 
   <td>String getISO3Country()</td> 
   <td>返回国家名称的3字母缩写</td> 
  </tr> 
  <tr> 
   <td>String getISO3Language()</td> 
   <td>返回语言名称的3字母缩写</td> 
  </tr> 
 </tbody> 
</table>

实例演示

这个例子告诉我们如何在JSP中显示语言和国家：

<body>
    <center>
        <h1>Detecting Locale</h1>
    </center>
    
    <%
        //获取客户端本地化信息
    Locale locale = request.getLocale(); //语言区域  比如 中文有中文简体(zh-CN)和繁体(zh-TW).. 
    String language = locale.getLanguage();//语言: 中文(zh) 英文(en) ...
    String country = locale.getCountry(); //国家
    %>
    
    <p align="center">
        <%     
       		 out.println("国家  : " + country   + "<br />");
        	out.println("语言 : " + language  + "<br />");
       		 out.println("语言区域 : " + locale  + "<br />");
        
            
        %>
    </p>
    
    </body>

**语言切换**

JSP可以使用西欧语言来输出一个页面，比如英语，西班牙语，德语，法语，意大利语等等。由此可见，设置Content-Language信息头来正确显示所有字符是很重要的。 如果不知道每个国家语言缩写 在百度上搜索 :各国语言缩写表

http://www.mamicode.com/info-detail-2692661.html 也可以参考这个网站

en 英语

zh 中文

自动识别切换语言案例:

<%@ page import="java.util.Locale" %>
    <%@ page language="java" contentType="text/html; charset=UTF-8" isELIgnored="true" pageEncoding="UTF-8" %>
    <html>
    <head>
        <title>index</title>
    </head>
    <body>
    
    <%
    
        String re_language = request.getParameter("Language");
    
        //获取客户端本地化信息
        Locale locale = request.getLocale();
        String langua = locale.getLanguage(); //自动识别获取你的语言
    
        if(re_language!=null){
            application.setAttribute("Language",re_language);  //设置页面语言
        }else{
            application.setAttribute("Language",langua);  //设置页面默认语言
        }
    
    
        // 设置请求头内的 Content-Language(当前页面的语言)
        response.setHeader("Content-Language", (String) application.getAttribute("Language"));
        //获取当前响应头里的 语言
        String language= response.getHeader("Content-Language");
    %>
    
    
    <label for="Language"></label>
    <select id="Language">
    
        <% if("en".equals(language )){ %>
        <option selected="selected" value="en">English</option>
        <%}else{%>
        <option  value="en">English</option>
        <%}%>
        <% if("zh".equals(language)){ %>
        <option selected="selected" value="zh">中文</option>
        <%}else{%>
        <option value="zh">中文</option>
        <%}%>
    
    </select>
    
    
    <center>
        <h1><%
            if("en".equals(language)){
                out.print("The current language is : English");
            }else if("zh".equals(language)){
                out.print("当前语言是: 中文");
            }
    
    
        %></h1>
    </center>
    <div align="center">
        <%if(language.equals("en")){%>
            Hello World!
        <%}%>
        <%if(language.equals("zh")){%>
            你好 世界!
        <%}%>
    </div>
    
    <script>
        //下拉框 变化 从而变化 页面语言
        var Language=document.getElementById("Language");
        Language.οnchange=function(){
            let value = Language.value;
            location.href="http://localhost:8081/java_Web/"+"?Language="+value;
        }
    </script>
    
    </body>
    </html>

![在这里插入图片描述][1a1ed5b128a1430da187423b6c514b23.png]

![在这里插入图片描述][11c8e39fcdd34a9a93c525c37031e9fa.png]

**自动识别并格式化时间为当前地区的时间字符串格式**

<%@ page import="java.text.DateFormat" %>
    <%@ page import="java.util.Date" %>
    <%@ page import="java.util.Locale" %>
    <%@ page language="java" contentType="text/html; charset=UTF-8" isELIgnored="true" pageEncoding="UTF-8" %>
    <html>
    <head>
        <title>index</title>
    </head>
    <body>
    <%
        //获取客户端本地化信息
        Locale locale = request.getLocale();  //获取你是哪个 语言_区域
        //设置 格式 时间为你国家的 时间字符串格式
        String date = DateFormat.getDateTimeInstance(DateFormat.FULL, DateFormat.SHORT,  locale).format(new Date( ));
     %>
    <div align="center">
        <p>Local Date: <%  out.print(date); %></p>
    </div>
    
    </body>
    </html>

**自动格式格式货币 为当前地区的货币格式**

<%@ page import="java.text.NumberFormat" %>
    <%@ page import="java.util.Locale" %>
    <%@ page language="java" contentType="text/html; charset=UTF-8" isELIgnored="true" pageEncoding="UTF-8" %>
    
    <%
    
     Locale locale = request.getLocale( );
     NumberFormat nft = NumberFormat.getCurrencyInstance(locale);  //自动格式格式 货币为当前地区的货币格式
     %>
    <html>
    <head>
        <title></title>
    </head>
    <body>
    
    <div align="center">
    
        <p>格式化的货币:
            <%
                String formattedCurr = nft.format(1000000);//格式化
                out.print(formattedCurr);
            %>
       </p>
    </div>
    </body>
    </html>

**自动格式百分比 为当前地区格式的百分比格式**

<%@ page import="java.text.NumberFormat" %>
    <%@ page import="java.util.Locale" %>
    <%@ page language="java" contentType="text/html; charset=UTF-8" isELIgnored="true" pageEncoding="UTF-8" %>
    
    <%
    Locale locale = request.getLocale( );
    NumberFormat nft = NumberFormat.getPercentInstance(locale);//自动格式百分比 为当前地区格式的百分比格式
    %>
    <html>
    <head>
        <title></title>
    </head>
    <body>
    <div align="center">
        <p>格式化的百分比:
        <%
            String formattedPerc = nft.format(0.51); //格式化
            out.print(formattedPerc);
        %></p>
    </div>
    </body>
    </html>

到这里 基本上所有JSP的 基础教程完事 但是jsp学习之旅并没有结束 我们还有如下知识没有掌握

EL , JSTL 使用 jsp连接数据库 ,jsp过滤器 xml数据处理,自定义jsp的标签

可以看出来这些内容 其实就是 让你开发jsp的时候更加方便

![在这里插入图片描述][e2af4607da624cff9e7bf546663eaa91.gif]

点赞 -收藏-关注-便于以后复习和收到最新内容有其他问题在评论区讨论-或者私信我-收到会在第一时间回复如有侵权，请私信联系我感谢,配合,希望我的努力对你有帮助^\_^

![ceaefc422a4745479fc1e8cfd2bdb74e.jpg][]

[58bd10c4727a494f9a08a0d0eb27d566.png]: https://img-blog.csdnimg.cn/58bd10c4727a494f9a08a0d0eb27d566.png
[d4c8a392352f4b93b2a03106ef52e1ed.png]: https://img-blog.csdnimg.cn/d4c8a392352f4b93b2a03106ef52e1ed.png
[d206818bba2541b7a04b288be3945e0b.png]: https://img-blog.csdnimg.cn/d206818bba2541b7a04b288be3945e0b.png
[982ddd61ce4e4f1bb5a27d557c4678a7.png]: https://img-blog.csdnimg.cn/982ddd61ce4e4f1bb5a27d557c4678a7.png
[3ef287993cd947e999d3b617fc908895.png]: https://img-blog.csdnimg.cn/3ef287993cd947e999d3b617fc908895.png
[d31d951608d041ddac0e0d87f5ca8c5b.png]: https://img-blog.csdnimg.cn/d31d951608d041ddac0e0d87f5ca8c5b.png
[3facf3dde3bc47dbbf66226344381a6d.png]: https://img-blog.csdnimg.cn/3facf3dde3bc47dbbf66226344381a6d.png
[2ec049d61e3249cabcb68717347d9d4e.png]: https://img-blog.csdnimg.cn/2ec049d61e3249cabcb68717347d9d4e.png
[2e17e05bb6cf45bc92c12482222a9dfa.png]: https://img-blog.csdnimg.cn/2e17e05bb6cf45bc92c12482222a9dfa.png
[b3b6394b98f547079537f54b25224fe1.png]: https://img-blog.csdnimg.cn/b3b6394b98f547079537f54b25224fe1.png
[813f43d7c57a412ab653760ec4605d74.png]: https://img-blog.csdnimg.cn/813f43d7c57a412ab653760ec4605d74.png
[eb11424defa443088ce1ef4a1f586f10.png]: https://img-blog.csdnimg.cn/eb11424defa443088ce1ef4a1f586f10.png
[05c1c83b569c4e458746debb3870eddf.png]: https://img-blog.csdnimg.cn/05c1c83b569c4e458746debb3870eddf.png
[742c03462b3e4b4a9f4d2eaae0aaa0f0.png]: https://img-blog.csdnimg.cn/742c03462b3e4b4a9f4d2eaae0aaa0f0.png
[8ff545e60ee641c4b01bdd6ce5830eda.png]: https://img-blog.csdnimg.cn/8ff545e60ee641c4b01bdd6ce5830eda.png
[8f3ea19ea8e240f0bdcf8a87307a4bef.png]: https://img-blog.csdnimg.cn/8f3ea19ea8e240f0bdcf8a87307a4bef.png
[76e1932d25b74711a6d445981989c0b8.png]: https://img-blog.csdnimg.cn/76e1932d25b74711a6d445981989c0b8.png
[94c0ece3013b40e1ae319b543a8707f9.png]: https://img-blog.csdnimg.cn/94c0ece3013b40e1ae319b543a8707f9.png
[d400531786ed4f6992970f5ea0cdb6c4.png]: https://img-blog.csdnimg.cn/d400531786ed4f6992970f5ea0cdb6c4.png
[b136dd51da134808980d2262cb9a14a0.png]: https://img-blog.csdnimg.cn/b136dd51da134808980d2262cb9a14a0.png
[b212a462e34d4a4a9c07347fa4caa650.png]: https://img-blog.csdnimg.cn/b212a462e34d4a4a9c07347fa4caa650.png
[e859f14a45a84f558711050cefa8c39e.png]: https://img-blog.csdnimg.cn/e859f14a45a84f558711050cefa8c39e.png
[1847eaea0c1a4232b0d996480db2cf60.png]: https://img-blog.csdnimg.cn/1847eaea0c1a4232b0d996480db2cf60.png
[b11f31ae33cf442f97892601113967fc.png]: https://img-blog.csdnimg.cn/b11f31ae33cf442f97892601113967fc.png
[be41c55bedb14b7a97626393a541cf7a.png]: https://img-blog.csdnimg.cn/be41c55bedb14b7a97626393a541cf7a.png
[ee2e103596f543479ce54dbf21568901.png]: https://img-blog.csdnimg.cn/ee2e103596f543479ce54dbf21568901.png
[a97e623d4ebe48f189c038332bba3c84.png]: https://img-blog.csdnimg.cn/a97e623d4ebe48f189c038332bba3c84.png
[b2ee25c462da4ad9af58fa94078674d8.png]: https://img-blog.csdnimg.cn/b2ee25c462da4ad9af58fa94078674d8.png
[165445bc730a4bcbbd6ddc0e7f263aeb.png]: https://img-blog.csdnimg.cn/165445bc730a4bcbbd6ddc0e7f263aeb.png
[1a1ed5b128a1430da187423b6c514b23.png]: https://img-blog.csdnimg.cn/1a1ed5b128a1430da187423b6c514b23.png
[11c8e39fcdd34a9a93c525c37031e9fa.png]: https://img-blog.csdnimg.cn/11c8e39fcdd34a9a93c525c37031e9fa.png
[e2af4607da624cff9e7bf546663eaa91.gif]: https://img-blog.csdnimg.cn/e2af4607da624cff9e7bf546663eaa91.gif
[ceaefc422a4745479fc1e8cfd2bdb74e.jpg]: https://img-blog.csdnimg.cn/ceaefc422a4745479fc1e8cfd2bdb74e.jpg