JSP

 JSP、EL表达式的入门（要用）

Servlet的缺点

开发人员要十分熟悉JAVA

不便于页面调试和维护、修改、重新编译

很难利用网页设计工具进行页面设计  • HTML 内容导入到 servlet 中、 • 用 PrintWriter 的对象进行输出

JavaWeb早期：applet + servlet

JavaWeb早期：servlet，在servlet中需要写大量的response.getWriter().println(“”);

JavaWeb后期：JSP，只需要在html中直接添加动态信息，即java代码片段就可以了。服务器会把所有的语句转换成response.getWriter().println(“”);

--response.getWriter().println(“”);

  -- response.getWriter().println(“”);

-- response.getWriter().println(“”);

1.What is JSP

JSP(JavaServerPages )是由Sun公司倡导、许多别的公司参与一起建立的一种新动态网页

技术标准，类似其他技术标准，如ASP、PHP或是ColdFusion，等等。

在传统的网页HTML文件(*.htm,*.html)中加入Java程序片段(Scriptlet)和JSP标签，构成了JSP网页(*.jsp)。Servlet/JSPContainer 收到客户端发出的请求时，首先执行其中的程序片段，然后将执行结果以HTML格式响应给客户端。其中程序片段可以是：操作数据库、重新定向网页以及发送E-Mail等等，这些都是建立动态网站所需要的功能。所有程序操作都在服务器端执行，网络上传送给客户端的仅是得到的结果，与客户端的浏览器无关，因此，JSP称为Server-SideLanguage。

2.Microsoft和 Sun都提供它们各自品牌的服务器页面。Sun提供JavaServerPages (JSP)而Microsoft提供 ActiveServer Pages(ASP)。JSP和 ASP都设计成使开发者能够从后端系统产生动态页面。

虽然表面看起来相似，ASP和JSP仍有一些不同之处：

JSP是平台独立性的，一次编写，随处运行；

开发者通过Java Community Process(JCP)指引方向；

JSP开发者可以通过定制标签扩展JSP标签库；

JavaBeans和 Enterprise JavaBeans (EJB) 可以和JSP一起使用，增强可重用性和减小维护。

JSP可以存取其他一些Java库，包括Java数据库连接(JDBC)，JavaMail，JavaMessage 

     Service(JMS)，以及JNDI。

JSP编译成二进制类文件，不需要在每次请求时进行解释；

JSP有广泛的支持，包括工具，容器和服务器。

*  Servlet/JSP 是两种动态的WEB资源的两种技术。
* 使用Servlet生成HTML的页面
response.getWriter("

");
response.getWriter("");
*  JSP简介
*  java server pages java服务器端的网页们，是在 服务器端执行。
* JSP不仅可以写HTML+java代码+JSP自己的代码

* JSP的运行原理（*****）：JSP -- 翻译成Servlet -- 编译 -- 访问

JSP 的执行过程：

(1) 客户端发出Request(请求)；

(2)JSP Container 将JSP翻译成Servlet的源代码；

(3) 将产生的Servlet的源代码经过编译后，加载到内存执行；

(4) 把结果Response(响应)发送至客户端。

JSP和Servlet的执行效率相差不大，只是第一次执行JSP页面时需要进行编译。

一般人都会以为JSP 的执行性能会和Servlet相差很多，其实执行性能上的差别只在第一次的执行。因为JSP在执行第一次后，会被编译成Servlet的类文件，即为XXX.class，当再重复调用执行时，就直接执行第一次所产生的Servlet，而不用再重新把JSP编译成Servlet。因此，除了第一次的编译会花较久的时间之外，之后JSP和Servlet的执行速度就几乎相同了。

在执行JSP 网页时，通常可分为两个时期：转译时期(TranslationTime)和请求时期(Request  Time) 。

1.JSP文件先要被服务器翻译成Java文件（Servlet），在tomcat中翻译后的Java文件在tomcat下的 work/Catalina/localhost 中相应名字的应用目录里。

2. 编译成Java(Servlet)文件

3. 运行.class文件

Tomcat的全局配置文件$CATALINA_HOME/conf/web.xml

在Tomcat下的conf目录中的web.xml是服务器全局的配置文件，其中要想关闭列表显示叫要把

   <init-param>

        <param-name>listingsparam-name>

        <param-value>falseparam-value>

   init-param>

修改为true

* JSP的脚本元素（JSP的页面可以编写java代码）
<%!  %> ：定义类、定义变量、定义方法（不常用） 成员变量。
<%=  %> ：输出语句（输出到页面，不能有分号）

<%   %> ：定义变量、语句

<%
for(int i=1;i<=10;i++){
%>

<%
for(int j=1;j<=10;j++){
%>
1
<%
}
%>

<%
}
%>

html + java代码 + JSP动态标签 = jsp

JSP是Servlet，JSP与我们编写的Servlet有什么不同呢？通常我们编写的Servlet就不需要输出HTML代码了，而是转发到JSP页面。

即Servlet不再负责显示页面，而由JSP来完成！而Servlet专注与控制层内容！

Declaration(声明)

声明的格式：<%! 声明1；[声明2]；……%>

声明的作用范围是整个JSP页面，同时它只在一个JSP页面有效

声明的类型包括：变量，方法，类

每一个声明仅在一个页面中有效，如果每个页面都用到一些声明，最好把它们写成一个单

独的JSP 网页，然后用<%@include %>或<jsp:include>元素包含进来。

使用<%!%>方式所声明的变量为成员变量，即表示：若同时n个用户在执行此JSP网页时，

将会共享此变量。强烈建议不要使用<%!%>来声明变量。

若要声明变量时，请直接在<%%>之中声明使用即可。

统计用户访问量程序代码

<%@page language="java" contentType="text/html;charset=utf-8"

    pageEncoding="utf-8"%>

<%!

int count = 0 ;

%>

equiv="Content-Type"content="text/html; charset=utf-8">

你是第<%=++count%>个访问本网站的用户！

JSP脚本表达式中的变量或表达式后面不能有分号（;）

代码块： <%  java code %>

在一个代码块中声明的变量是 JSP 页面的局部变量，只在当前页面有效

JSP语法
* JSP的设置
* 设置JSP文件的打开方式：window -- 选项 -- General -- Editors -- 文件关联 -- *.jsp -- 选择MyEclipse JSP Editor -- default
* 设置JSP文件的编码：window -- 搜索JSP -- 找到JSP -- 选择UTF-8 -- OK
* 脚本元素
<%! %> 成员方法、成员变量
<%= %> 输出内容
<%  %> 局部变量，语句
* JSP页面的注释
* HTML的注释 JSP文件的阶段存在，在翻译成java文件也存在， 在页面存在
* JAVA的注释 JSP文件的阶段存在，在翻译成java文件也存在， 在页面不存在
<%
// 单行
/**/ 多行
/**
* 文档
*/
%>

* JSP的注释 <%-- JSP的注释 --%> 之后存在JSP文件的阶段

JSP注释：<%-- … --%>，转化阶段消失，只能被开发人员看到

JAVA 注释： // 、 /**/ 、 /***/ ，编译阶段消失

HTML 注释： , 不会消失，在页面中也能看到

其中JSP只有一种注释：<%-- … --%>，注释中的内容会被JSP编译系统忽略！

HTML的注释：，因为最终向客户端响应的内容还是HTML，所以在HTML注释中的内容还是看不内的。

但是可以通过在浏览器中右键à查看源代码，查看中的内容。 

<%-- <%=String.format("%tF % --%>

二者的区别！

：Tomcat不把它当注释，和其他东西一样，会发送到客户端。但浏览器不会去显示它，因为浏览器知道它是注释；

<%----%>：Tomcat在生成“真身”时，就会忽略它，因为Tomcat认识它，知道它是注释。所以在“真身”中就没有它，也不会发现到客户端。也就是说，客户端永远看不到它！

什么是隐藏对象

隐藏对象是在JSP页面中无需创建就可以直接使用的变量。在JSP中一共有9个这样的对象！它们分别是：

  out（JspWriter）；

  config（ServletConfig）；

  page（当前JSP的真身类型）；

  pageContext（PageContext）；

exception（Throwable）；

  request（HttpServletRequest）；

  response（HttpServletResponse）；

  application（ServletContext）；

  Session     （HttpSession）。

隐藏对象概述

  out：最为常用的方法是print()，向页面输出！它与response.getWriter()基本相同！

  config：在页面中基本没有什么用，但如果JSP在web.xml中存在配置，而且存在初始化参数，那么可以使用config来获取；config对象的功能是：getServletContext()、getServletName()、getInitParameter()，这三个方法在JSP中都没什么用。所以config就没什么用了。JSP也可以在web.xml中配置，但我们没有配置它的必要！

  page：基本没用！表示当前JSP页面的当前实例！在页面中使用this和使用page是相同的；也没什么用。

  request：与Servlet中的request一样，没有区别；

  response：与Servlet中的response一样，没有区别；

  application：就是ServletContext对象；

  session：就是HttpSession对象；

  exception：虽然名字叫exception，但类型为Throwable。它只能在错误页中可以使用！

  pageContext：很有用的东西，下面会讲解。你以后可能不会经常直接使用它，但一定间接使用它

 在JSP的隐藏对象中，常用的有：out、request、response、session、application、pageContext，以及exception。

* JSP的内置对象（9个）直接使用
request response session application out pageContext page config exception
内置对象 真实的对象 方法
request HttpServletRequest setAttribute() getAttribute()
response HttpServletResponse addCookie() getWriter()
session HttpSession setAttribute() getAttribute()
application ServletContext setAttribute() getAttribute()
config ServletConfig getInitParameter() getInitParameterNames()
exception Throwable getMessage()
page Object （不使用对象）
out JspWriter write() print()
pageContext PageContext setAttribute() getAttribute()

* exception

* 和异常有关的
* 前提条件：isErrorPage="true"，才能使用exception对象。
* page
* 当前页面的对象。
* out对象
JspWriter   PrintWriter  response.getWriter()
<%= "HELLO" %>
<% out.print("AAAA"); %>
<% response.getWriter().print("BBBB"); %>
<% out.print("CCCC"); %>
* 输出结果：

* pageContext对象
* 域对象
* 自己存取值
* 向其他的域存取值。
* setAttribute(String name, Object value, int scope) 
* getAttribute(String name, int scope) 
* findAttribute(String name) 
* 可以获取其他8个对象。
* 编写框架或者通用性较高代码。
* 在JSP的时候（4个域对象）
ServletContext 整个web应用
session 一次会话
request 一次请求

pageContext 当前页面

4　JSP四个域对象

pageContext 对象是PageContext类型，它不只是域对象，而且还可以操作所有域对象，还可以获取其他隐藏对象。

  本身是域对象：pageContext是JSP中的域对象，而在Servlet中不能使用它！它表示的当前页面中可以使用，是最小的范围！

void setAttribute(String name, Object value)；

  Object getAttrbiute(String name, Object value)；

void removeAttribute(String name, Object value)；

  操作所有域（四个域）：可以使用pageContext对象操作所有域对象，在getAttribute()、setAttribute()、removeAttribute()三个方法中多添加一个参数，int scope来指定范围。在PageContext类中包含四个int类型的常量表示四个范围：

  PAGE_SCOPE：pageContext范围；

  REQUEST_SCOPE：request范围；

  SESSION_SCOPE：session范围；

  APPLICATION_SCOPE：application范围；

  void setAttribute(String name, Object value, int scope)：设置数据到指定的范围中，例如：pageContext.setAttribute(“hello”, “hello world”,PageContext.REQUEST)，这个方法调用等同与：request.setAttribute(“hello”,“hello world”)；

  Object getAttribute(String name, int scope)：获取指定范围的数据；

  void removeAttribute(String name, int scope)：移除指定范围的数据；

  Object findAttribute(String name)：在所有范围内查找数据，依次为page、request、session、application。如果在前一个范围内查找到数据，那么就返回，而不会在到下一个范围中去查找！

  获取其他隐藏对象：可以使用pageContext获取其他隐藏对象。

  JspWriter getOut()：获取out隐藏对象；

  ServletConfig getServletConfig()：获取config隐藏对象；

  Object getPage()：获取page隐藏对象；

  ServletRequest() getRequest()：获取request隐藏对象；

  ServletResponse() getResponse：获取response隐藏对象；

  HttpSession getSession()：获取session隐藏对象；

  ServletContext getServletContext()：获取application隐藏对象；

  JspException getException()：获取exception隐藏对象转换后的JspException对象。 

• Servlet 中有三个域，而 JSP 有四个域。

• JSP 中多了 pageContext 的域范围，代表当前页面范围。

5　out和response（了解）

　　在JSP页面中就不要再去使用response.getWriter()这个流了！

out对象是JspWriter类型，它与response.getWriter()返回的PrintWriter都是底层响应流的包装。用来向客户端响应字符数据。

但是，在页面中不应该使用response.getWriter()来响应，而是使用隐藏对象out。因为Tomcat总是会先把response.getWriter()中的数据输出给我响应端，然后才是隐藏对象out输出的数据！这会导致使用response.getWriter()输出的数据出现在之前！

如果你想看到错误的结果，那么你可以在JSP中使用response.getWriter()，以及out穿插输出。然后使用HttpWatch来查看响应结果！！！

6　config和page（了解）

page对象，它只是表示当前JSP“真身”的当前实例，即this。

config是ServletConfig类型，在JSP中一般不会在web.xml文件中配置，但也是可以配置的！就像是配置Servlet配置一样的方法！

<servlet>     <servlet-name>eservlet-name>     <jsp-file>/e.jspjsp-file>     <init-param>         <param-name>testparam-name>         <param-value>jsp test valueparam-value>     init-param>   servlet>   <servlet-mapping>     <servlet-name>eservlet-name>     <url-pattern>/e.jspurl-pattern>   servlet-mapping>

<%=config.getInitParameter("test")%>

7　exception

　　exception对象不是所有页面都可以使用的，只能在错误页中可以使用！在下面介绍page指令时一同讲解exception对象的使用。

* JSP的指令元素

什么是JSP指令

JSP指令的格式：<%@指令名 attr1=”” attr2=””%>，一般都会把JSP指令放到JSP文件的最上方，但这不是必须的。

JSP中有三大指令：page、include、taglib，最为常用，也最为复杂的就是page指令了。

Tomcat编译系统会根据JSP的指令信息来编译JSP，生成Java文件。

在生成的Java文件中，不存在指令信息！
* 语法：<%@ 指令元素 属性名=属性值  %>
* page ：设置JSP的属性
* 注意：import属性可以出现多次，其他属性只能出现一次。
* 属性：
* language ：JSP文件允许嵌入的语言。 只支持一种JAVA语言。（不需要改变）
* extends ：JSP翻译翻译Servlet文件，servlet继承的类。（不需要改变）
* session ：默认值是true，可以直接使用session。设置false，不能直接使用。
* import ：引入java的jar包（使用多次）
* buffer ：设置缓冲区的大小 默认8kb
* aotoFlush ：设置默认刷新缓冲区（不要修改）
* errorPage ：指定错误页面
* isErrorPage ：设置值，可以是exception对象，设置true，使用exception，设置不能使用exception对象
* contentType ：服务器端输出所有内容采用编码。
* pageEncoding ：JSP翻译成Servlet文件时采用的编码。
* isELIgnored ：是否忽略EL表达式（false，不忽略，true，忽略）
* 重点：
* session import contentType pageEncoding isELIgnored
* include ：包含页面（页面布局）
* 语法：<%@ include file="要包含文件的地址（静态包含）" %>
* <%@ include file="/include/head.jsp" %>
* taglib ：引入标签库文件
* 语法：<%taglib  %>
* 属性:
* uri ：引入标签库文件的名称
* prefix ：标签库的前缀名

page 属性包含在“ <%@ page ” 和“ %>” 之间。

这些属性可以单独使用，也可以几个或多个同时使用

page 指令用来定义 JSP 文件的全局属性

在 JSP 页面中，只有 import 可以出现多次，其它属性都只能出现一次

page指令的errorPage和isErrorPage，以及JavaWeb异常处理

我们知道，在一个JSP页面出错后，Tomcat会响应给我用户错误信息！如果你不希望Tomcat给用户输出错误信息，那么可以使用page指令的errorPage来指定错误页！例如：

<%@pageerrorPage=”xxx.jsp”%>

这时，在当前JSP页面出现错误时，会转发到xxx.jsp页面。

a.jsp

<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%> <%@ page  errorPage="b.jsp" [涛1] %>     <%     if(true)         thrownew Exception("哈哈~");    %>

---

当a.jsp页面出了异常后，会转发到b.jsp页面。

虽然转发到了b.jsp，但b.jsp并没有设置为错误页，所以Tomcat设置的状态码还是200。

b.jsp

<%@ page pageEncoding="UTF-8"%> <html>   <body>    <h1>出错啦！h1>

　　如果希望在b.jsp页面中获得异常对象，那么就需要把b.jsp标记为错误页！这需要设置page指令的isErrorPage属性为true。

<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%> <%@ page  isErrorPage="true"[涛1]  %> <html>   <body>    <h1>出错啦！h1>     <%=exception.getMessage() %>

---

设置b.jsp页面为错误页，在错误页中就可以使用exception隐藏对象了。

注意：一旦转发到错误页，那么Tomcat会把状态码设置为500，而不在是200了。

IE会在状态码为500时，并且响应正文的长度小于等于512B时不给予显示！而是显示“网站无法显示该页面”字样。

<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%> <%@ page  isErrorPage="true" %> <%     for (int i = 0; i < 506[涛1] ; i++) {         out.print("a");     } %>

---

查看“真身”，你会发现在for循环前面有两组“\r\n”，在for循环后面会有一组“\r\n”，所以响应正文的字节数是512，因为不大于512，IE就不会显示！

还可以在web.xml文件中配置错误页面，在出现某种错误时跳转到对应的页面处理。

<error-page>     <error-code>404error-code>     <location>/error404.jsplocation>   error-page>   <error-page>     <error-code>500error-code>     <location>/error500.jsplocation>   error-page>   <error-page>     <exception-type>java.lang.Exceptionexception-type>     <location>/error.jsplocation>   error-page>

当出现404时，会跳转到error404.jsp页面；

当出现Exception异常时，会跳转到error.jsp页面；

当出现非Exception的异常时，例如出现Error时，会跳转到error500.jsp页面。

还可以配置更多，更细致的异常类型。

page指令的pageEncoding和contentType （*****）

pageEncoding指定的是当前JSP页面的编码！Tomcat编译系统会使用这个编码把JSP编译成Java文件。所以这个编译只需要与真实的页面编译一致即可！

contentType指定的是响应给我客户端时使用的编码，即对应response.setConteType()方法的参数值！例如：<%@ contentType=”text/html;charset=utf-8”%>，这时无法页面中的中文使用的是什么编译，Tomcat都会把响应正文转换成UTF-8编译，然后发送给我客户端，并且会在响应头中设置Content-Type头信息为text/html;charset=utf-8，这样浏览器就知道使用服务器发送过来的正文使用了什么编码。

无论是page指令的pageEncoding还是contentType，它们的默认值都是ISO-8859-1，我们知道ISO-8859-1是无法显示中文的，所以JSP页面中存在中文的话，一定要设置这两个属性。

其实pageEncoding和contentType这两个属性的关系很暧昧：

  当设置了pageEncoding，而没设置contentType时：表示contentType的取值为pageEncoding的值；

  当设置了contentType，而没设置pageEncoding时：表示pageEncoding的取值与contentType的值； 

也就是说，当pageEncoding和contentType只出现一个时，那么另一个的值与出现的值相同。如果两个都不出现，那么两个属性的值都是ISO-8859-1。

 处理乱码的方案：

  把JSP页面的编码设置为UTF-8；

把contentType和pageEncoding都设置为UTF-8。

include 指令的语法格式如下

• <%@ include file=“filename”%>

l include 指令的作用是在 JSP 页面中 静态包含 一个文件，同时由 JSP 解析包含的文件内容

静态包含的含义

•file不能为一变量

• <% String url ="index.html" ; %>

• <%@ include file = "<%= url %>" %>

•不可以在file 所指定的文件后接任何参数

• <%@ include file = " jw.jsp?nm =browser" %>

是变量：翻译的时候代码没有执行  带变量  变量没有具体值

带参数：没有解释执行  所以你的参数毫无意义

静态包含举例

包含的是目标文件的源码；包含过来，一起翻译

main.jsp

<%

    String s = “abc”;

%>

<%include file=“part.jsp” %>

part.jsp

<%=s %> 没有定义变量s

尽管 part.jsp 本身会有错误

但是运行 main.jsp 就可以正确引入 part.jsp

a.jsp，通常这个扩展名表示被包含的页面的扩展名！

include指令表示静态包含！

include指令只有一个属性：file，指定要包含的页面，例如：<%@includefile=”b.jsp”%>。

静态包含：当hel.jsp页面包含了lo.jsp页面后，在编译hel.jsp页面时，需要把hel.jsp和lo.jsp页面合并成一个文件，然后再编译成Servlet（Java文件）。

在上面代码中，lo.jsp中没有定义username变量，所以lo.jsp不能处理请求，只有hel.jsp才能处理请求！当访问hel.jsp时，hel.jsp会包含lo.jsp，所以两个会合并成一个文件后再编译成Java文件。在合并之后，因为在hel.jsp中定义了username变量，所以lo.jsp中也就不会出现错误了。

Taglib 指令用于在 JSP 页面中导入标签库

常用标签库 JSTL

l 常用属性

• uri   标签文件的 URI 地址

prefix  标签组的命名空间前缀

taglib指令

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

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

其中prefix表示标签的前缀，这个名称可以随便起。uri是由第三方标签库定义的，所以你需要知道第三方定义的uri

* 配置全局的错误页面

* 在web.xml中进行配置。

404
/404.jsp
 
 
 
500
/500.jsp

 

JSP动态标签是JSP自己的标签，不是由第三方提供的，所以使用JSP动态标签时无需使用taglib指令“导包”。

JSP动态标签的格式为：

* JSP的标签（JSP的动作）
：转发
属性：page 要转发的页面
：传递参数
属性：name：参数名称 value：参数值
  ：页面的包含（动态包含）
属性：page 要包含的页面
include动态标签

include标签是动态包含，与include指令不同，include标签与RequestDispatcher.include()方法的功能是相同的。

hel.jsp

<body>     <h1>hel.jsph1>     <jsp:include page="lo.jsp" />   body>

lo.jsp

<%     out.println(" lo.jsp "); %>

动态包含是会为两个JSP页面都生成“真身”，然后hel.jsp的“真身”中会调用lo.jsp的“真身”的_jspService()方法而已。

forward动态标签

forward标签的作用是请求转发！forward标签的作用与RequestDispatcher#forward()方法相同。

hel.jsp

lo.jsp

<%     out.println("<h1>lo.jsp"); %>

　注意，显示结果中没有

hel.jsp

，即hel.jsp中的所有输出都会被清除！

useBean、SetProperty、getProperty动态标签

useBean

先说一下与JavaBean相关的动态标签在JSPModel2中已经很少使用了。在JSP Model1中，JSP页面直接使用JavaBean，那里使用这些标签是很有用的！但是，这里还是要介绍一下。

在开始测试JavaBean动态标签之前，我们需要先创建一个javaBean类：cn.itcast.domain.Person类。

因为useBean标签有点小复杂，所以我们把useBean标签的作用直接翻译成Java代码！

<jsp:useBean id="p1" class="cn.itcast.domain.Person" scope="session"/>[涛1] 指定存储bean的范围，如果不指定，默认范围是pageContext

<%     Person p1 = (Person)pageContext.getAttribute("p1");     if(p1 == null) {         p1 = new Person();         pageContext.setAttribute("p1", p1);     } %>

---

当使用useBean标签之后，会出现变量p1，而且在pageContext范围内存在名为p1的数据。

当然useBean会先去查看pageContext范围内原来是否存在名为p1的值，如果存在，就不会创建，而是直接使用。

setProperty

setProperty标签的作用是给Bean设置属性值。当然，你必须保证Bean已经存在的前提下才能设置属性值。

<jsp:useBean id="p1" class="cn.itcast.domain.Person" /> <jsp:setProperty property="sex"[涛1]  value="male"[涛2]  name="p1"[涛3] />

<%     Person p = (Person)pageContext.getAttribute("p1");     if(p == null) {         thrownew NullPointerException();     }     p.setSex("male"); %>

---

property指定bean的属性名

value指定bean的属性值

name指定bean名称

getProperty：

getProperty标签的作用是获取Bean的属性值。

<jsp:useBean id="p1" class="cn.itcast.domain.Person" /> <jsp:setProperty property="sex" value="male" name="p1"/> <jsp:getProperty property="sex" name="p1" />[涛1]

---

获取p1的sex属性值

setProperty的自省机制：

 form.jsp

<form action="bean.jsp" [涛1] method="post">     姓名：<input type="text" name="name"/><br/>     年龄：<input type="text" name="age"/><br/>     性别：<input type="text" name="sex"/><br/>     <input type="submit" value="提交"/>     form>

---

提交到bean.jsp，这可以保存在request中存在名字为name、age、sex的三个参数。

bean.jsp

<jsp:useBean id="p1" class="cn.itcast.domain.Person" /> <jsp:setProperty property="*"[涛1]  name="p1"/> <%=p1 %>

---

给bean的所有属性赋值，使用request.getParameter()方法来获取与属性同时的参数。

也就是说在给name属性赋值时，需要request.getParameter(“name”)的值。给bean的sex属性赋值时需要request.getParameter(“sex”)的值。

< jsp:useBean >

• 使用一个 ID 和一个给定作用范围和同一 ID 的 JavaBean 相关联

< jsp:setProperty >

• 设置 JavaBean 的属性值

< jsp:getProperty >

• 取得 JavaBean 的属性值

< jsp:include > 

• 文件包含（服务器端路径，没有项目名称）

< jsp:forward >

• 在 JSP 的页面中完成转发（服务器端路径，没有项目名称）

< jsp:param >

需要写在<jsp:forward>的中间

<jsp:include>与include指令的比较

< jsp:include > 标签是动态引入， < jsp:include > 标签涉及到的 2 个 JSP 页面会被翻译成 2 个 servlet ，这 2 个 servlet 的内容在 执行时 进行合并。

而 include 指令是静态引入，涉及到的 2 个 JSP 页面会被翻译成一个 servlet ，其内容是在 源文件 级别进行合并。

不管是 < jsp:include > 标签，还是 include 指令，它们都会把两个 JSP 页面内容合并输出，所以这两个页面不要出现重复的 HTML 全局架构标签，否则输出给客户端的内容将会是一个格式混乱的 HTML 文档。

两种include用法的区别

include 两种用法的区别
主要有两个方面的不同：
一、执行时间上：

<%@ include file=“relativeURI”%> 是在翻译阶段执行；
<jsp:include page=“relativeURI” flush=“true” /> 在请求处理阶段执行。
二、引入内容的不同：
<%@ include file=“relativeURI”%>引入静态文本(html,jsp)，在JSP页面被转化成servlet之前和它融和到一起。
<jsp:include page=“relativeURI” flush=“true” />引入执行页面或servlet所生成的应答文本。

另外在两种用法中file和page属性都被解释为一个相对的URI。如果它以斜杠开头，那么它就是一个环境相关的路径，将根据赋给应用程序的URI的前缀进行解释；如果它不是以斜杠开头，那么就是页面相关的路径，就根据引入这个文件的页面所在的路径进行解释。 

在Servlet中如果使用request.getRequestDispatcher.forward进行页面跳转，那么该语句以后的代码会执行：

request.getRequestDispatcher.forward(“XXX”);

System.out.println(“Itcan execute…”);

但是JSP中后面的代码不会执行，因为翻译的时候，Serlvet容器自动为后面添加了return语句

<%

  String s=request.getRemoteAddr();

  if(s.startsWith("10.28.176.",0)){

%>

    <jsp:forwardpage="index_inner.jsp"/>

    <%}else{%>

    <jsp:forwardpage="index_outter.jsp"/>

<%

  }

%>