zoukankan html css js c++ java

06、JavaEEJSP基本语法

JSP基本用法

JSP原理

JSP全称是Java Server Pages，和Servlet技术一样都用于开发动态Web资源的技术。

浏览器向服务器发送请求，其实都是在访问Servlet，服务器在执行JSP时，会把JSP翻译成Servlet。假设我们有如下代码：

index.jsp

<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<%
    String path = request.getContextPath();
    String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";
%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
    <base href="<%=basePath%>">
    <title>First Jsp</title>
</head>
<body>
<%
    out.print("Hello Jsp");
%>
</body>
</html>

当我们通过浏览器访问index.jsp时，服务器首先将index.jsp翻译成一个index_jsp.class，在Tomcat服务器的work\Catalina\localhost\项目名\org\apache\jsp

目录下可以看到index_jsp.class的源代码文件index_jsp.java：

public final class index_jsp extends org.apache.jasper.runtime.HttpJspBase
    implements org.apache.jasper.runtime.JspSourceDependent {
  private static final JspFactory _jspxFactory = JspFactory.getDefaultFactory();
  private static java.util.List _jspx_dependants;
  private javax.el.ExpressionFactory _el_expressionfactory;
  private org.apache.AnnotationProcessor _jsp_annotationprocessor;
  public Object getDependants() {
    return _jspx_dependants;
  }
  public void _jspInit() {
    _el_expressionfactory = _jspxFactory.getJspApplicationContext(getServletConfig().getServletContext()).getExpressionFactory();
    _jsp_annotationprocessor = (org.apache.AnnotationProcessor) getServletConfig().getServletContext().getAttribute(org.apache.AnnotationProcessor.class.getName());
  }
  public void _jspDestroy() {
  }
  public void _jspService(HttpServletRequest request, HttpServletResponse response)
        throws java.io.IOException, ServletException {
    PageContext pageContext = null;
    HttpSession session = null;
    ServletContext application = null;
    ServletConfig config = null;
    JspWriter out = null;
    Object page = this;
    JspWriter _jspx_out = null;
    PageContext _jspx_page_context = null;
    try {
      response.setContentType("text/html;charset=UTF-8");
      pageContext = _jspxFactory.getPageContext(this, request, response,
                  null, true, 8192, true);
      _jspx_page_context = pageContext;
      application = pageContext.getServletContext();
      config = pageContext.getServletConfig();
      session = pageContext.getSession();
      out = pageContext.getOut();
      _jspx_out = out;
      out.write('\r');
      out.write('\n');
String path = request.getContextPath();
String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";
      out.write("\r\n");
      out.write("\r\n");
      out.write("<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\">\r\n");
      out.write("<html>\r\n");
      out.write("  <head>\r\n");
      out.write("    <base href=\"");
      out.print(basePath);
      out.write("\">\r\n");
      out.write("    \r\n");
      out.write("    <title>First Jsp</title>\r\n");
      out.write("\t\r\n");
      out.write("  </head>\r\n");
      out.write("  \r\n");
      out.write("  <body>\r\n");
      out.write("    ");
        out.print("Hello Jsp");
      out.write("\r\n");
      out.write("  </body>\r\n");
      out.write("</html>\r\n");
    } catch (Throwable t) {
      if (!(t instanceof SkipPageException)){
        out = _jspx_out;
        if (out != null && out.getBufferSize() != 0)
          try { out.clearBuffer(); } catch (java.io.IOException e) {}
        if (_jspx_page_context != null) _jspx_page_context.handlePageException(t);
      }
    } finally {
      _jspxFactory.releasePageContext(_jspx_page_context);
    }
  }
}

index_jsp这个类是继承 org.apache.jasper.runtime.HttpJspBase这个类的，通过查看Tomcat服务器的源代码，可以知道在apache-tomcat-6.0.20-src\java\

org\apache\jasper\runtime目录下存HttpJspBase这个类的源代码文件，如下图所示：

我们可以看看HttpJsBase这个类的源代码，如下所示：

public abstract class HttpJspBase extends HttpServlet implements HttpJspPage { 
    protected HttpJspBase() {
    }
    public final void init(ServletConfig config) throws ServletException {
        super.init(config);
    jspInit();
        _jspInit();
    }
    
    public String getServletInfo() {
    return Localizer.getMessage("jsp.engine.info");
    }
    public final void destroy() {
        jspDestroy();
        _jspDestroy();
    }
    /**
     * Entry point into service.
     */
    public final void service(HttpServletRequest request, HttpServletResponse response) 
    throws ServletException, IOException {
        _jspService(request, response);
    }
    
    public void jspInit() {
    }
    public void _jspInit() {
    }
    public void jspDestroy() {
    }
    protected void _jspDestroy() {
    }
    public abstract void _jspService(HttpServletRequest request, 
                     HttpServletResponse response) 
    throws ServletException, IOException;
}

HttpJspBase类是继承HttpServlet的，所以HttpJspBase类是一个Servlet，而index_jsp又是继承自HttpJspBase类的，所以index_jsp类也是一个Servlet。

1、JSP中的HTML排版标签是如何发送给服务端的?

浏览器接收到的下面这些数据

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
  <head>
    <base href="http://localhost:8080/JavaWebDemo/">
    <title>First Jsp</title>  
  </head>
  
  <body>
    Hello Jsp
  </body>
</html>

都是在_jspService方法中使用如下的代码输出给浏览器的：

String path = request.getContextPath();
String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";
      out.write("\r\n");
      out.write("\r\n");
      out.write("<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\">\r\n");
      out.write("<html>\r\n");
      out.write("  <head>\r\n");
      out.write("    <base href=\"");
      out.print(basePath);
      out.write("\">\r\n");
      out.write("    \r\n");
      out.write("    <title>First Jsp</title>\r\n");
      out.write("\t\r\n");
      out.write("  </head>\r\n");
      out.write("  \r\n");
      out.write("  <body>\r\n");
      out.write("    ");
        out.print("Hello Jsp");
    
      out.write("\r\n");
      out.write("  </body>\r\n");
      out.write("</html>\r\n");

在jsp中编写的java和html代码都会被翻译到_jspService方法中去，而HTML代码则会翻译成out.write("<html标签>\r\n");的形式输出到浏览器。

2、Web服务器在调用JSP时，会给JSP提供什么java对象？

查看_jspService方法可以看到，Web服务器在调用jsp时，会给Jsp提供如下的8个java对象

PageContext pageContext;
HttpSession session;
ServletContext application;
ServletConfig config;
JspWriter out;
Object page = this;
HttpServletRequest request, 
HttpServletResponse response

其中page对象，request和response已经完成了实例化，而其它5个没有实例化的对象通过下面的方式实例化

pageContext = _jspxFactory.getPageContext(this, request, response,null, true, 8192, true);
application = pageContext.getServletContext();
config = pageContext.getServletConfig();
session = pageContext.getSession();
out = pageContext.getOut();

这8个java对象在Jsp页面中是可以直接使用的，如下所示：

<%
    session.setAttribute("name", "session对象");//使用session对象,设置session对象的属性
    out.print(session.getAttribute("name")+"<br/>");//获取session对象的属性
    pageContext.setAttribute("name", "pageContext对象");//使用pageContext对象,设置pageContext对象的属性
    out.print(pageContext.getAttribute("name")+"<br/>");//获取pageContext对象的属性
    application.setAttribute("name", "application对象");//使用application对象,设置application对象的属性
    out.print(application.getAttribute("name")+"<br/>");//获取application对象的属性
    out.print("Hello Jsp"+"<br/>");//使用out对象
    out.print("服务器调用index.jsp页面时翻译成的类的名字是："+page.getClass()+"<br/>");//使用page对象
    out.print("处理请求的Servlet的名字是："+config.getServletName()+"<br/>");//使用config对象
    out.print(response.getContentType()+"<br/>");//使用response对象
    out.print(request.getContextPath()+"<br/>");//使用request对象
%>

软件开发中，习惯把servlet作为web应用中的控制器组件，而把JSP技术作为数据显示模板。

JSP基础语法

JSP虽然是在JAVA上的一种应用，但是也有自身的扩充语法，而且在JSP中是可以运行所有JAVA语句的。

JSP页面中的HTML内容称之为JSP模板元素，JSP模板元素定义了网页的基本骨架，既定义了页面的结构和外观。

JSP表达式

JSP脚本表达式（expression）用于将程序数据输出到客户端:

<%= 变量或表达式 %>

JSP脚本表达式后面不允许有分号，JSP引擎在翻译脚本表达式时，会将程序数据转成字符串，然后在相应位置用out.print(…) 将数据输给客户端。

JSP脚本片段

JSP脚本片断(scriptlet)用于在JSP页面中编写多行Java代码。语法：

<%
多行java代码
%>
在<% %>中可以定义变量、编写语句，不能定义方法。

范例：在Scriptlet中定义变量、编写语句：

<%
    int sum=0;//声明变量
    /*编写语句*/
    for (int i=1; i<=100; i++){
        sum+=i;
    }
    out.println("<h1>Sum="+sum+"</h1>");
%>

注意事项：

JSP脚本片断中只能出现java代码，不能出现其它模板元素。
JSP脚本片断中的Java代码必须严格遵循Java语法。
在一个JSP页面中可以有多个脚本片断，在两个或多个脚本片断之间可以嵌入文本、HTML标记和其他JSP元素。

多个脚本片断中的代码可以相互访问，犹如将所有的代码放在一对<%%>之中的情况。如：out.println(x);单个脚本片断中的Java语句可以是不完整的，但是，

多个脚本片断组合后的结果必须是完整的Java语句，例如：

<%
    for (int i=1; i<5; i++) {
%>
      <H1>http://localhost:8080/JavaWebDemo/</H1>
<%
    }
%>

JSP声明

多个静态代码块、变量和函数可以定义在一个JSP声明中，也可以分别单独定义在多个JSP声明中。JSP隐式对象的作用范围仅限于Servlet的_jspService方法，

所以在JSP声明中不能使用这些隐式对象。

<%!
    static {
        System.out.println("loading Servlet!");
    }
    private int globalVar = 0;
    public void jspInit(){
        System.out.println("initializing jsp!");
    }
%>
<%!
    public void jspDestroy(){
        System.out.println("destroying jsp!");
    }
%>

JSP注释

在JSP中，注释有两大类：

显式注释：直接使用HTML风格的注释：<!- - 注释内容- ->
隐式注释：直接使用JAVA的注释：//、/……/
JSP自己的注释：<%- - 注释内容- -%>

三种注释的区别分别是：

<%
//JAVA中的单行注释
/*
JAVA中的多行注释
*/
%>
<%--JSP自己的注释--%>

HTML的注释在浏览器中查看源文件的时候是可以看得到的，而JAVA注释和JSP注释在浏览器中查看源文件时是看不到注释的内容的，这就是这三种注释的区别。

JSP指令

　JSP指令（directive）是为JSP引擎而设计的，它们并不直接产生任何可见输出，而只是告诉引擎如何处理JSP页面中的其余部分。

在JSP2.0规范中定义三个指令：

指令	描述
<%@ page ... %>	定义网页依赖属性，比如脚本语言、error页面、缓存需求等等。
<%@ include ... %>	包含其他文件
<%@ taglib ... %>	引入标签库的定义

JSP指令的基本语法格式：

语法：<%@ 指令 属性名="值" %>
例子：<%@ page contentType="text/html;charset=gb2312"%>

如果一个指令有多个属性，这多个属性可以写在一个指令中，也可以分开写。

<%@ page contentType="text/html;charset=gb2312"%>
<%@ page import="java.util.Date"%>

也可以写作：

<%@ page contentType="text/html;charset=gb2312" import="java.util.Date"%>

Page指令

page指令用于定义JSP页面的各种属性，无论page指令出现在JSP页面中的什么地方，它作用的都是整个JSP页面，为了保持程序的可

读性和遵循良好的编程习惯，page指令最好是放在整个JSP页面的起始位置。例如：

JSP 2.0规范中定义的page指令的完整语法：

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

page指令的import属性

在Jsp页面中，Jsp引擎会自动导入下面的包

java.lang.*
javax.servlet.*
javax.servlet.jsp.*
javax.servlet.http.*

可以在一条page指令的import属性中引入多个类或包，其中的每个包或类之间使用逗号(,)分隔

<%@ page import="java.util.*,java.io.*,java.sql.*"%>

上面的语句也可以改写为使用多条page指令的import属性来分别引入各个包或类

<%@ page import="java.util.Date"%>
<%@ page import="java.io." %>
<%@ page import="java.sql." %>

page指令的errorPage属性

errorPage属性的设置值必须使用相对路径，如果以“/”开头，表示相对于当前Web应用程序的根目录(注意不是站点根目录)，

否则，表示相对于当前页面，也可以在web.xml文件中使用<error-page>元素为整个Web应用程序设置错误处理页面。

其中<error-page>元素有3个子元素，<error-code>、<exception-type>、<location>

<error-code>子元素指定错误的状态码，例如：<error-code>404</error-code>
<exception-type>子元素指定异常类的完全限定名，例如：<exception-type>java.lang.ArithmeticException</exception-type>
<location>子元素指定以“/”开头的错误处理页面的路径，例如：<location>/ErrorPage/404Error.jsp</location>

如果设置了某个JSP页面的errorPage属性，那么在web.xml文件中设置的错误处理将不对该页面起作用。

（1）使用errorPage属性指明出错后要跳转的页面

比如Test.jsp页面有如下的代码：

<%@ page contentType="text/html;charset=UTF-8" language="java" errorPage="error.jsp" %>
<html>
<head>
    <title>测试page指令的errorPage属性</title>
</head>
    <body>
        <%
            // 运行出错代码
            int x = 1 / 0;
        %>
    </body>
</html>

代码运行出错后会跳转到error.jsp页面:

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>错误友好提示界面</title>
</head>
    <body>
        对不起，出问题啦，赶快联系程序员修改代码！
    </body>
</html>

（2）在web.xml中使用<error-page>标签配置全局错误处理

web.xml代码如下：

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="3.0" 
    xmlns="http://java.sun.com/xml/ns/javaee" 
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
    xsi:schemaLocation="http://java.sun.com/xml/ns/javaee 
    http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd">
  <display-name></display-name>    
  <welcome-file-list>
    <welcome-file>index.jsp</welcome-file>
  </welcome-file-list>
  
  <!-- 针对404错误的处理页面 -->
  <error-page>
      <error-code>404</error-code>
      <location>/ErrorPage/404Error.jsp</location>
  </error-page>
</web-app>

404Error.jsp代码如下：

<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<html>
  <head>
    <title>404错误友好提示页面</title>
    <!-- 3秒钟后自动跳转回首页 -->
    <meta http-equiv="refresh" content="3;url=${pageContext.request.contextPath}/index.jsp">
  </head>
  <body>
    <img alt="对不起，你要访问的页面没有找到，请联系管理员处理!" 
    src="${pageContext.request.contextPath}/img/404Error.png"/><br/>
    3秒钟后自动跳转回首页，如果没有跳转，请点击<a href="${pageContext.request.contextPath}/index.jsp">这里</a>
  </body>
</html>

当访问一个不存在的web资源时，就会跳转到在web.xml中配置的404错误处理页面404Error.jsp。

如果错误页面比较小的话，ie可能显示自己的错误页面，而火狐和google浏览器是不存在该问题。解决办法有两种：

a) 修改IE浏览器的设置（不推荐）
操作步骤：在IE【工具】->【Internet选项】->【高级】中勾掉【显示友好http错误提示】
b) 定制错误页面的大小
修改500Error.jsp，多添加一些内容，让页面的字节数大一些，修改后的500Error.jsp的代码如下：

示例代码如下所示：

<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<html>
  <head>
    <title>500(服务器错误)错误友好提示页面</title>
    <!-- 3秒钟后自动跳转回首页 -->
    <meta http-equiv="refresh" content="3;url=${pageContext.request.contextPath}/index.jsp">
  </head>
  <body>
    <img alt="对不起，服务器出错了，请联系管理员解决！" 
    src="${pageContext.request.contextPath}/img/500Error.png"/><br/>
    3秒钟后自动跳转回首页，如果没有跳转，请点击<a href="${pageContext.request.contextPath}/index.jsp">这里</a>
  </body>
</html>

经过测试，当定制的错误页面的size=617bytes时，在IE8下已经可以跳转到定制的错误页面。

（3）使用page指令的isErrorPage属性显示声明页面为错误页面

将error.jsp页面显示声明为错误处理页面

<%@ page language="java" import="java.util.*" pageEncoding="UTF-8" isErrorPage="true"%>
<html>
  <head>
    <title>错误信息友好提示页面</title>
  </head>
  <body>
           对不起，出错了，请联系管理员解决！
  </body>
</html>

Jsp有9大内置对象，而一般情况下exception对象在Jsp页面中是获取不到的，只有设置page指令的isErrorPage属性为"true"来显式声明Jsp页面

是一个错误处理页面之后才能够在Jsp页面中使用exception对象。

include指令

在JSP中对于包含有两种语句形式：

@include指令
<jsp:include>指令

@include指令

@include可以包含任意的文件，当然，只是把文件的内容包含进来。它用于引入其他JSP页面，而JSP引擎会将两个JSP翻译成Servlet，

所以这种方式称之为静态引入。

<%@ include file="relativeURL"%>，
其中的file属性用于指定被引入文件的路径。路径以“/”开头，表示代表当前web应用。

include指令细节注意事项：

被引入的文件必须遵循JSP语法。
被引入的文件可以使用任意的扩展名，JSP规范建议使用.jspf（JSP fragments(片段)）作为静态引入文件的扩展名。
由于使用include指令将会涉及到2个JSP页面，所以这2个JSP页面的指令不能冲突（除了pageEncoding和导包除外）。

范例：

新建head.jspf页面和foot.jspf页面，分别作为jsp页面的头部和尾部，存放于WebRoot下的jspfragments文件夹中，代码如下：

head.jspf和foot.jspf内容如下：

head.jspf：
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<h1 style="color: red;">网页头部</h1>
foot.jspf：
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<h1 style="color: blue">网页尾部</h1>

在WebRoot文件夹下创建一个IncludeTagTest.jsp页面，在IncludeTagTest.jsp页面中使用@include指令引入head.jspf页面和foot.jspf页面，代码如下：

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
    <head>
        <title>jsp的include指令测试</title>
    </head>
    <body>
        <%--使用include标签引入其他JSP页面--%>
        <%@include file="/jspfragment/head.jspf"%>
        <h1>网页主体部分</h1>
        <%@include file="/jspfragment/foot.jspf"%>
    </body>
</html>

最后总结一下使用方法：

使用@include可以包含任意的后缀名的文件内容，属于静态包含。
jsp:include页面是JSP，则先处理再将结果包含，称为动态包含，而如果是非*.jsp文件，则是把文件静态包含。

JSP九大内置对象

JSP引擎在调用JSP对应的_jspServlet时，会传递或创建9个与web开发相关的对象供_jspServlet使用。JSP技术的设计者为便于开发人员在编写

JSP页面时获得这些web对象的引用，特意定义了9个相应的变量，开发人员在JSP页面中通过这些变量就可以快速获得这9大对象的引用。

内置对象	类型
pageContext	javax.servlet.jsp.PageContext
request	javax.servlet.http.HttpServletRequest
response	javax.servlet.http.HttpServletResponse
session	javax.servlet.http.HttpSession
application	javax.servlet.ServletContext
config	javax.servlet.ServletConfig
out	javax.servlet.jsp.JspWriter
page	java.lang.Object
exception	java.lang.Throwable

内置对象使用

page对象

page对象表示当前JSP页面，可以理解为对象本身，了解即可。

out对象

out对象用于向客户发送文本数据，它通过调用pageContext.getOut()方法返回，其作用和用法和ServletReponse.getWriter()方法非常类似。

JSP页面中的out对象的类型为JspWriter，JspWriter相当于一种带缓存功能的PrintWriter，设置JSP页面的page指令的buffer属性可以调整它

的缓存大小，甚至关闭它的缓存。

　　只有向out对象中写入了内容，且满足如下任何一个条件时，out对象才去调用ServletResponse.getWriter方法，并通过该方法返回的Print

Writer对象将out对象的缓冲区中的内容真正写入到Servlet引擎提供的缓冲区中：

设置page指令的buffer属性关闭了out对象的缓存功能
out对象的缓冲区已满
整个JSP页面结束

out对象的工作原理图：

pageContext对象

pageContext对象是JSP技术中最重要的一个对象，它代表JSP页面的运行环境，这个对象不仅封装了对其它8大隐式对象的引用，它自身还是一个

域对象(容器)，可以用来保存数据。并且，这个对象还封装了web开发中经常涉及到的一些常用操作，例如引入和跳转其它资源、检索其它域对象中的属性等。

我们可以通过pageContext中的如下方法来获得其他隐式对象：

getException方法返回exception隐式对象
getPage方法返回page隐式对象
getRequest方法返回request隐式对象
getResponse方法返回response隐式对象
getServletConfig方法返回config隐式对象
getServletContext方法返回application隐式对象
getSession方法返回session隐式对象
getOut方法返回out隐式对象

除此之外，pageContext还可以作为容器来使用，可以将一些数据存储在pageContext对象中。

public void setAttribute(java.lang.String name,java.lang.Object value)
public java.lang.Object getAttribute(java.lang.String name)
public void removeAttribute(java.lang.String name)
public java.lang.Object findAttribute(java.lang.String name)

当要查找某个属性时，findAttribute方法按照查找顺序"page→request→session→application"在这四个对象中去查找，只要找到了就返回属性值，如果四

个对象都没有找到要查找的属性，则返回一个null。

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@page import="java.util.*"%>
<head>
    <title>pageContext的findAttribute方法查找属性值</title>
</head>
<%
    pageContext.setAttribute("name1", "legend");
    pageContext.setAttribute("name2", "vincent");
    pageContext.setAttribute("name3", "uding");
    application.setAttribute("name4", "kevin");
%>
<%
    // 使用pageContext的findAttribute方法查找属性
    String refName1 = (String) pageContext.findAttribute("name1");
    String refName2 = (String) pageContext.findAttribute("name2");
    String refName3 = (String) pageContext.findAttribute("name3");
    String refName4 = (String) pageContext.findAttribute("name4");
    // 查找一个不存在的属性
    String refName5 = (String) pageContext.findAttribute("name5");
%>
<h1>pageContext的findAttribute方法找到的属性值如下：</h1>
<h1>name1：<%=refName1%></h1>
<h1>name2：<%=refName2%></h1>
<h1>name3：<%=refName3%></h1>
<h1>name4：<%=refName4%></h1>
<h1>name5：<%=refName5%></h1>
<hr/>
<h1>使用EL表达式进行输出：</h1>
<h3>pageContext对象的name1属性：${name1}</h3>
<h3>request对象的name2属性：${name2}</h3>
<h3>session对象的name3属性：${name3}</h3>
<h3>application对象的name4属性：${name4}</h3>
<h3>不存在的name5属性：${name5}</h3>

EL表达式语句在执行时，会调用pageContext.findAttribute方法，用标识符为关键字，分别从page、request、 session、application四个域中查找相应的

对象，找到则返回相应对象，找不到则返回""（注意，不是null，而是空字符串）。

pageContext对象中封装了访问其它域的方法：

public java.lang.Object getAttribute(java.lang.String name,int scope)
public void setAttribute(java.lang.String name, java.lang.Object value,int scope)
public void removeAttribute(java.lang.String name,int scope)

代表各个域的常量：

PageContext.APPLICATION_SCOPE
PageContext.SESSION_SCOPE
PageContext.REQUEST_SCOPE
PageContext.PAGE_SCOPE

使用pageContext访问其他域：

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>pageContext访问其他域</title>
    <%
        // session中存放name属性
        pageContext.setAttribute("name", "legend", PageContext.SESSION_SCOPE);
    %>
    <%
        // 取得session对象属性,使用pageContext对象获得
        String name = (String) pageContext.getAttribute("name", PageContext.SESSION_SCOPE);
        // 直接获取属性
        String name1 = (String) session.getAttribute("name");
    %>
    <h1>取出存在session对象中的属性值</h1>
    <p>第一种方式：使用pageContext取出session对象中的值</p>
    <h3>姓名：<%=name%></h3>
    <p>第二种方式：使用session直接获取对象中的值</p>
    <h3>姓名：<%=name1%></h3>
</html>

PageContext引入和跳转到其他资源

PageContext类中定义了一个forward方法(用来跳转页面)和两个include方法(用来引入页面)来分别简化和替代RequestDispatcher.forward方法和include

方法。方法接收的资源如果以“/”开头， “/”代表当前web应用。

a) 使用PageContext的forward()跳转其他页面

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>使用PageContext的forward方法跳转页面</title>
</head>
    <%
        //方式一： 使用pageContext的forward()跳转到其他jsp页面
        pageContext.forward("/index.jsp");
        //方式二： 使用RequstDispatch的forward()方法实现跳转
        pageContext.getRequest().getRequestDispatcher("/index.jsp").forward(request,response);
    %>
</html>

在开发中，一般会使用<jsp:forward>标签来实现跳转，<jsp:forward>标签用于把请求转发给另外一个资源。

b) 使用pageContext的include方法引入资源

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
    <head>
        <h1>使用pageContext的include()方法引入资源</h1>
        <%
            pageContext.include("/jspfragment/head.jsp");
            pageContext.include("jspfragment/foot.jsp");
        %>
    
        <hr/>
    
        <h1>使用jsp的include方式引入资源</h1>
        <jsp:include page="/jspfragment/head.jsp"/>
        <jsp:include page="/jspfragment/foot.jsp"/>
    </head>
</html>

在实际开发中，使用pageContext的include方法引入页面这种做法也很少用，一般都使用jsp:include标签引入资源，因此这种做法了解一下即可。

JSP属性范围

JSP的属性范围就是当一个属性设置后，可以经过多少个其他页面后仍然可以访问的范围。它有四种属性范围，分别如下：

当前页：属性只能当前页面中取得，跳转到其他页面后无法使用。
服务请求：一个页面中设置的属性，只要经过服务器跳转，跳转之后的页面可以继续使用。
会话：一个用户设置的内容，只要是与与此用户相关的页面都可以访问。
上下文：在整个服务器上设置的属性，所有人都可以访问。

其中四种属性范围中都将包含如下的属性操作方法：

方法	描述
public void setAttribute(String name,Object value)	设置属性
public object getAttribute(String name)	取得属性
public void removeAttribute(String name)	删除属性

四种属性范围

Page属性范围(PageContext)

Page属性范围在一个页面设置的属性，跳转到其他页面则无法访问，它可以表示一个页面中的所有内容。

范例：演示在本页中存储属性和获取属性：

<%@ page import="java.util.Date" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%
    // pageContext设置的属性只能在当前页取得
    pageContext.setAttribute("name", "legend");
    pageContext.setAttribute("date", new Date());
%>
<%
    // 取得设置的属性
    String refName = (String) pageContext.getAttribute("name");
    Date refDate = (Date) pageContext.getAttribute("date");
%>
<h1>姓名：<%=refName%></h1>
<h1>日期：<%=refDate%></h1>

注意：pageContext存储的属性只能在当前页面中获取。

request属性范围

request属性范围表示在一次服务器跳转中有效，只要是服务器跳转，则设置request属性可以一直传递下去。

范例：演示request在一次跳转中获取属性：

pageContextSet.jsp

<%@ page import="java.util.Date" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%
    request.setAttribute("name", "legend");
    request.setAttribute("date", new Date());
%>
<jsp:forward page="/PageContextGet.jsp" />

pageContextGet.jsp

<%@ page import="java.util.Date" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%
    String refName = (String) request.getAttribute("name");
    Date refDate = (Date) request.getAttribute("date");
%>
<h1>姓名：<%=refName%></h1>
<h1>日期：<%=refDate%></h1>

运行结果：

姓名：legend
日期：Fri Jun 30 10:06:38 CST 2017

从运行结果来看，程序跳转了后，request对象还可以获取属性，如果现在有第三个页面，它也可以继续向后进行传递。

注意：request对象在多次跳转后依然可以获取属性值，如果使用超链接的形式跳转的话，则无法再获取属性。

session属性范围

session设置的属性不管如何跳转，都可以取得，但是只能针对一个用户来说。

范例：演示session的属性范围

sessionSet.jsp

<%@ page import="java.util.Date" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%
    // 此时设置的属性只能在本页相关的任意页面中获得
    session.setAttribute("name", "legend");
    session.setAttribute("date", new Date());
%>
<jsp:forward page="sessionGet.jsp"/>

sessionGet.jsp

<%@ page import="java.util.Date" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%
    String refName = (String) session.getAttribute("name");
    Date refDate = (Date) session.getAttribute("date");
%>
<h1>姓名：<%=refName%></h1>
<h1>日期：<%=refDate%></h1>
<%--使用超链接的方式跳转--%>
<h1><a href="${pageContext.request.contextPath}/sessionGet1.jsp">继续跳转</a></h1>

sessionGet1.jsp

<%@ page import="java.util.Date" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%
    String refName = (String) session.getAttribute("name");
    Date refDate = (Date) session.getAttribute("date");
%>
<h1>姓名：<%=refName%></h1>
<h1>日期：<%=refDate%></h1>

输出结果：

sessionGet1.jsp中获得：
姓名：legend
日期：Fri Jun 30 10:23:06 CST 2017

注意：session存储的属性不管如何跳转，只要跟当前页面有关的页面都能获取到，但是只针对某一个用户而言。

application属性范围

application属性范围是在服务器上设置的一个属性，所以一旦设置之后任何用户都可以浏览到此属性。

范例：演示观察application属性范围。

applicationSet.jsp

<%@ page import="java.util.Date" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%
    // 设置的属性任何用户都可以获取
    application.setAttribute("name", "legend");
    application.setAttribute("date", new Date());
%>
<h1><a href="${pageContext.request.contextPath}/applicationGet.jsp">跳转</a></h1>

applicationGet.jsp

<%@ page import="java.util.Date" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%
    String refName = (String) application.getAttribute("name");
    Date refDate = (Date) application.getAttribute("date");
%>
<h1>姓名：<%=refName%></h1>
<h1>日期：<%=refDate%></h1>

注意：application的属性可以供所有用户访问，除非关闭服务器。过多使用会影响服务器性能。

PageContext的Scope

上面所讲解的四种属性范围都是通过PageContext属性范围设置上的，PageContext类继承了JspContext类，在JspContext类中定义了setAttribute()方法，如下所示：

public abstract void setAttribute(String name,Object value,int scope)

范例：PageContext以REQUEST_SCOPE模式存储存储，然后用request对象获取属性。

PageContextSet.jsp

<%@ page import="java.util.Date" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%
    pageContext.setAttribute("name", "legend", PageContext.REQUEST_SCOPE);
    pageContext.setAttribute("date", new Date(), PageContext.REQUEST_SCOPE);
%>
<jsp:forward page="RequestGet.jsp"/>

RequestGet.jsp

<%@ page import="java.util.Date" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%
    String refName = (String) request.getAttribute("name");
    Date refDate = (Date) request.getAttribute("date");
%>
<h1>姓名：<%=refName%></h1>
<h1>日期：<%=refDate%></h1>

运行结果：

姓名：legend
日期：Fri Jun 30 13:28:16 CST 2017

四种属性的使用场景

request：如果客户向服务器发请求，产生的数据，用户看完就没用了，像这样的数据就存在request域,像新闻数据，属于用户看完就没用的。
session：如果客户向服务器发请求产生的数据，用户用完了等一会儿还有用，像这样的数据就存在session域中。
application(servletContext)：如果客户向服务器发请求产生的数据，用户用完了，还要给其它用户用，像这样的数据就存在application(servletContext)域中。

JSP动作标签

JSP标签也成为Jsp Action元素，它用于JSP页面中提供业务逻辑功能，避免在JSP页面中直接编写java代码而造成难以维护。

常用动作标签

JSP有如下标签，其中常用的是include、forward、param标签：

标签	描述
<jsp:include />	在页面被请求的时候引入一个文件。
<jsp:useBean />	寻找或者实例化一个JavaBean。
<jsp:setProperty />	设置JavaBean的属性。
<jsp:getProperty />	输出某个JavaBean的属性。
<jsp:forward />	把请求转到一个新的页面。
<jsp:plugin />	根据浏览器类型为Java插件生成OBJECT或EMBED标记。
<jsp:element />	定义动态XML元素
<jsp:attribute />	设置动态定义的XML元素属性。
<jsp:body />	设置动态定义的XML元素内容。
<jsp:text />	在JSP页面和文档中使用写入文本的模板

所有的动作要素都有两个属性：id属性和scope属性。

id属性：id属性是动作元素的唯一标识，可以在JSP页面中引用。动作元素创建的id值可以通过PageContext来调用。
scope属性：该属性用于识别动作元素的生命周期。 id属性和scope属性有直接关系，scope属性定义了相关联id对象的寿命。

<jsp:include>标签

<jsp:include>标签是把另外一个资源的内容插入到当前的JSP输出的页面之中，这种方式称之为动态引入。

jsp<jsp:include page="relativeURL | <%=expression%>" flush="true|false" />

其中page属性指定被引入资源的相对路径。flush属性指定在插入其他输出内容时，是否将当前已输出内容刷新到客户端。

范例：演示<jsp:include>标签引入资源

<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
    <title>jsp的jsp:include标签测试</title>
</head>
    <body>
        <%--引入其它JSP页面--%>
        <jsp:include page="/jspfragments/head.jsp"/>
        <h1>网页主体内容</h1>
        <jsp:include page="/jspfragments/foot.jsp"/>
    </body>
</html>

<jsp:include>和include指令区别

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

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

通过下面的例子来说明<jsp:include>标签与include指令的区别

<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
   <%!
        int i=1000;
   %>
<h1>demo.jsp中i的值为：<%=i%></h1>

分别使用include指令和<jsp:include>标签两种包含语句，包含以上的demo.jsp

a) 使用@include静态包含

<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
   <%!
       int i=10;
   %>
<h1>i的值为：<%=i%></h1>
<h1><%@include file="/jspfragments/demo.jsp"%></h1>

此时在编译jsp时就已经提示出错了，如下所示

因为静态包含是将全部内容包含进来之后，再进行处理，属于先包含后处理。

b) 使用动态包含

<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<h1>JspIncludeTagDemo02.jsp</h1>
<%!
    int i=10;
%>
<h1>i的值为：<%=i%></h1>
<h1><jsp:include page="/jspfragments/demo.jsp" /></h1>

发现结果已经可以正确地显示，而且不会互相影响，这是因为使用jsp:include属于动态包含，动态包含就是指先将各个页面分别处理，处理完之后再将处理后的

结果包含进来。

*.jspf在jsp:include、@include和c:import中的区别

JSP规范建议使用.jspf（JSP fragments）作为静态引入文件的扩展名。正常情况下只有@include指令才行正常解析jspf文件，而使用jsp:include和JSTL的

c:import都无法解析jspf文件，会把其当成纯文本文件处理。

解决方式有两种，他们分别如下:

a) 第一种方式：修改web.xml文件，添加对扩展名为*.jspf文件的映射

<servlet-mapping>
    <servlet-name>jsp</servlet-name>
    <url-pattern>*.jsp</url-pattern>
    <!-- 让jspf扩展名同样成为JSP Servlet处理的文件。-->
    <url-pattern>*.jspf</url-pattern>
</servlet-mapping>

b)第二种方式：修改Tomcat服务器的web.xml文件，添加对*.jspf的映射

<!-- The mappings for the JSP servlet -->
<servlet-mapping>
    <servlet-name>jsp</servlet-name>
    <url-pattern>*.jsp</url-pattern>
    <url-pattern>*.jspx</url-pattern>
</servlet-mapping>

添加如上两种配置信息后，此时tomcat服务器就可以正常解析执行*.jspf文件了。

<jsp:forward>标签

<jsp:forward>标签用于把请求转发给另外一个资源。

<jsp:forward page="relativeURL | <%=expression%>" />

page属性用于指定请求转发到的资源的相对路径，它也可以通过执行一个表达式来获得。

范例：演示使用<jsp:forwar>标签跳转页面

forwardDemo01.jsp

<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<%--使用<jsp:forward>标签跳转到forwarddemo02.jsp--%>
<jsp:forward page="/forwardDemo02.jsp"/>

forwardDemo02.jsp

<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<h1>跳转之后的页面！！</h1>

<jsp:include>跳转后页面改变，而地址栏不会改变，因此它的跳转属于服务器端的跳转。

<jsp:param>标签

当使用<jsp:include>和<jsp:forward>标签引入或将请求转发给其它资源时，可以使用<jsp:param>标签向这个资源传递参数。

语法1：
    <jsp:include page="relativeURL | <%=expression%>">
        <jsp:param name="parameterName" value="parameterValue|<%= expression %>" />
    </jsp:include>
语法2：
    <jsp:forward page="relativeURL | <%=expression%>">
        <jsp:param name="parameterName" value="parameterValue|<%= expression %>" />
    </jsp:include>

<jsp:param>标签的name属性用于指定参数名，value属性用于指定参数值。在<jsp:include>和<jsp:forward>标签中可以使用多个<jsp:param>标签来传递多个参数。
范例：使用<jsp:param>标签向被包含的页面传递参数。

JspIncludeDemo.jsp

<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<h1>JspIncludeTagDemo.jsp</h1>
<hr/>
<jsp:include page="/jspfragments/Inc.jsp">
    <jsp:param name="parm1" value="legend" />
    <jsp:param name="parm2" value="vincent" />
</jsp:include>

Inc.jsp

<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<h1>接收从JspIncludeDemo.jsp页面中传递过来的参数：</h1>
<h2><%=request.getParameter("parm1")%></h2>
<h2><%=request.getParameter("parm2")%></h2>

范例：使用<jsp:param>标签向跳转的页面传递参数。

forwardDemo01.jsp

<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<jsp:forward page="/forwarddemo01.jsp">
    <jsp:param name="ref1" value="legend" />
    <jsp:param name="ref2" value="vincent" />
</jsp:forward>

forwardDemo02.jsp

<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<h1>跳转之后的页面！！</h1>
<h1>接收从forwarddemo03.jsp传递过来的参数：</h1>
<h1>ref1：<%=request.getParameter("ref1")%></h1>
<h1>ref2：<%=request.getParameter("ref2")%></h1>

JavaBean

JavaBean是一个遵循特定写法的Java类，它通常具备如下特点：

这个Java类必须具有一个无参的构造函数
属性必须私有化。
私有化的属性必须通过public类型的方法暴露给其它程序，并且方法的命名也必须遵守一定的命名规范。

JavaBean的格式如下：

public class User {
    private String name;
    private int age;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
}

JavaBean在J2EE开发中，通常用于封装数据，对于遵循以上写法的JavaBean组件，其它程序可以通过反射技术实例化JavaBean对象，并且通过反射那些遵守命名规范的方法，

从而获知JavaBean的属性，进而调用其属性保存数据。

JSP中使用JavaBean

JSP技术提供了三个关于JavaBean组件的动作元素，即JSP标签，它们分别为：

<jsp:useBean>标签：用于在JSP页面中查找或实例化一个JavaBean组件。
<jsp:setProperty>标签：用于在JSP页面中设置一个JavaBean组件的属性。
<jsp:getProperty>标签：用于在JSP页面中获取一个JavaBean组件的属性。

<jsp:useBean>标签

<jsp:useBean>标签用于在指定的域范围内查找指定名称的JavaBean对象，如果存在则直接返回该JavaBean对象的引用，如果不存在则实例化一个新的JavaBean对象并将它

以指定的名称存储到指定的域范围中。

<jsp:useBean id="beanName" class="package.className" scope="page|request|session|application"/>
"id"属性用于指定JavaBean实例对象的引用名称和其存储在域范围中的名称。
"class"属性用于指定JavaBean的完整类名（即必须带有包名）。
"scope"属性用于指定JavaBean实例对象所存储的域范围，其取值只能是page、request、session和application的一个，默认值是page。

范例：演示JavaBean的使用。

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%--在jsp中使用jsp:useBean标签来实例化java对象--%>
<jsp:useBean id="user" class="com.legend.jsp.User" scope="page"/>
<%--给User对象进行赋值--%>
<%
    user.setName("legend");
    user.setAge(18);
%>
<html>
<head>
    <title>标签使用范例</title>
</head>
    <body>
        <h2>姓名：<%=person.getName()%></h2>
        <h2>年龄：<%=person.getAge()%></h2>
    </body>
</html>

运行结果：

姓名：legend
年龄：18

带标签体的<jsp:useBean>标签

语法如下所示：

<jsp:useBean ...>
Body
</jsp:useBean>

Body部分的内容只在<jsp:useBean>标签创建JavaBean的实例对象时才执行。这种做法用得不多，了解一下即可。

<jsp:setProperty>标签

<jsp:setProperty>标签用于设置和访问JavaBean对象的属性。

语法格式一：
　　<jsp:setProperty name="beanName" property="propertyName" value="string字符串"/>
语法格式二：
　　<jsp:setProperty name="beanName" property="propertyName" value="<%= expression %>" />
语法格式三：
　　<jsp:setProperty name="beanName" property="propertyName" param="parameterName"/>
语法格式四：
　　<jsp:setProperty name="beanName" property= "*" />

其中解释如下：

name属性用于指定JavaBean对象的名称。
property属性用于指定JavaBean实例对象的属性名。
value属性用于指定JavaBean对象的某个属性的值。
param属性用于将JavaBean实例对象的某个属性值设置为一个请求参数值。

范例一：演示使用jsp:setProperty标签设置User对象的属性值

<%@ page import="java.util.Date" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<jsp:useBean id="user" class="com.legend.jsp.User" scope="page"/>
<jsp:setProperty name="user" property="name" value="legend"/>
<jsp:setProperty name="user" property="age" value="18"/>
<%--birthday属性是Date类型，属于复合数据类型，无法转换成字符串--%>
<jsp:setProperty name="user" property="birthday" value="<%=new Date()%>"/>
<html>
<head>
    <title>jsp:setProperty标签使用</title>
</head>
    <body>
        <h2>姓名：<%=user.getName()%></h2>
        <h2>年龄：<%=user.getAge()%></h2>
        <h2>生日：<%=user.getBirthday()%></h2>
    </body>
</html>

运行结果：

姓名：legend
年龄：18
生日：Sat Jul 01 19:45:19 CST 2017

范例二：使用请求参数为bean属性赋值

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<jsp:useBean id="usr" class="com.legend.jsp.User" scope="page"/>
<jsp:setProperty name="usr" property="name" param="param_name"/>
<html>
<head>
    <title>jsp:setProperty标签使用</title>
</head>
    <body>
        <h2>姓名：<%=usr.getName()%></h2>
    </body>
</html>

在浏览器中需要拼接param_name参数，输出结果如下：

http://localhost:8080/javaBean03.jsp?param_name=legend
姓名：legend

范例三：用所有的请求参数为bean属性赋值

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<jsp:useBean id="user" class="com.legend.jsp.User" scope="page"/>
<%--*代表bean的所有属性--%>
<jsp:setProperty name="user" property="*"/>
<html>
<head>
    <title>jsp:setProperty标签使用</title>
</head>
    <body>
        <h2>姓名：<%=user.getName()%></h2>
        <h2>年龄：<%=user.getAge()%></h2>
    </body>
</html>

输出结果：

http://localhost:8080/javaBean04.jsp?name=legend&age=18
姓名：legend
年龄：18

<jsp:getProperty>标签

<jsp:getProperty>标签用于读取JavaBean对象的属性，也就是调用JavaBean对象的getter方法，然后将读取的属性值转换成字符串后插入进输出的响应正文中。

<jsp:getProperty name="beanInstanceName" property="PropertyName" />
　　　name属性用于指定JavaBean实例对象的名称，其值应与<jsp:useBean>标签的id属性值相同。
　　　property属性用于指定JavaBean实例对象的属性名。

如果一个JavaBean实例对象的某个属性的值为null，那么，使用<jsp:getProperty>标签输出该属性的结果将是一个内容为“null”的字符串。

范例：演示jsp:getProperty获取bean对象的属性值

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<jsp:useBean id="user" class="com.legend.jsp.User" scope="page"/>
<%--设置属性值--%>
<jsp:setProperty name="user" property="name" value="legend"/>
<jsp:setProperty name="user" property="age" value="18"/>
<html>
    <head>
        <title>jsp:getProperty标签使用范例</title>
    </head>
    <body>
        <%--获取属性值--%>
        <h2><jsp:getProperty name="user" property="name"/></h2>
        <h2><jsp:getProperty name="user" property="age"/></h2>
    </body>
</html>

输出结果：

legend
18

查看全文

相关阅读:
php趣题小记
 git常用语法
 Go 使用小记
 小程序显示对话框确定-取消
 小程序后退一页
 Vue脚手架使用步骤 2.9.6版本
 小程序后台返回的对象数组（每个数组添加一个新的属性值）
小程序添加对象
 小程序图表wx-chart
微信小程序之自定义select下拉选项框组件

原文地址：https://www.cnblogs.com/pengjingya/p/14410143.html