zoukankan      html  css  js  c++  java
  • JSP 知识基本

    from:http://blog.csdn.net/caipeichao2/article/details/38589293

    more:http://www.2cto.com/kf/web/jsp/4.html


    JSP的全称是Java Server Pages。它的本质其实就是Servlet,在运行的过程中会编译成Servlet代码。在JSP中可以访问数据库,记录用户的选择信息,访问JavaBean组件。

    JSP与CGI的差别。一、性能更加优越,JSP可以直接在HTML网页中嵌入动态的元素,而不需要单独引用CGI文件。二、JSP是已经编译好的,持续运行的程序,一次载入可以服务多次请求,而CGI每次都要载入程序再执行,执行完成之后程序就退出了。三、Java是拥有强大的企业级Java API,包括JDBC,JNDI,EJB,JAXP等。四、JSP页面可以和servlet一起使用。

    JSP处理流程。

    1. 首先是服务器收到一个请求。服务器判断这个请求是JSP请求,因此将JSP传递给JSP引擎。
    2. JSP引擎从磁盘中读取JSP文件并将其转换成Servlet类。这种转换只是简单的把文本替换成println语句,将所有的JSP元素转换成Java代码。
    3. JSP引擎将Servlet类编译成字节码,然后将原始请求传递给Servlet引擎。
    4. Web服务器中的某个组件会调用Servlet引擎,然后载入并执行Servlet类。一个Servlet对象可以服务多次请求。
    5. 在执行的过程中,Servlet产生HTML格式的文本输出并将其存放在HTTP response中上交给服务器。
    6. Web服务器以静态的HTML网页形式将HTTP response返回到浏览器中。

    JSP的生命周期和Servlet类似,只不过多了一个编译的过程。分为四个阶段:
    1. 编译阶段。Servlet容器将JSP编译成Servlet代码,再将Servlet编译成字节码。
    2. 初始化阶段。加载对应的Servlet类,调用jspInit()方法。
    3. 执行阶段。调用\_jspService()方法。
    4. 销毁阶段。调用jspDestroy()方法。

    基本语法

    JSP只是在html的基础上嵌入一些动态的元素。下面是HelloWorld代码:

    1. <html>  
    2. <%  
    3. out.println("hello world");  
    4. %>  
    5. </html>  

    以上代码中的<% %>就是动态元素。JSP中所有的特殊语法如下:
    <% %>:用于表示一段Java代码。这段代码在编译之后会放在_jspService()方法中。
    <%! %>:多了一个叹号,也用于表示一段Java代码,但是这段代码编译之后会放在JSP生成的Servlet类中,因此可以用它定义方法或者成员变量。
    <%@ %>:多了一个@符号,是JSP指令,用于对JSP文件进行设置。
    <%= %>:多了一个等号,相当于out.println()。
    <%-- --%>:这是注释。不会在返回结果中显示。

    JSP指令。可以设置的指令有三种:
    1. <%@ page %>  
    2. <%@ include %>  
    3. <%@ taglib %>  


    page指令可以设置的属性如下:

    • buffer 设置out对象缓冲区的大小。
    • autoFlush 控制out对象的缓冲区。
    • contentType 指定当前JSP页面的MIME类型和字符编码
    • errorPage 指定当JSP页面发生异常时要转向的页面
    • isErrorPage 指定当前JSP页面是否可以作为另外页面的错误页面。错误页面中可以直接使用exception隐含变量获取错误信息。
    • extends 指定Servlet从哪个类继承
    • import 导入要使用的包
    • info 定义JSP页面的描述信息
    • isThreadSafe 指定JSP页面是否线程安全
    • language 指定编程语言,默认为Java
    • session 指定JSP页面是否使用session
    • isELIgnored 指定是否指定EL表达式。
    • isScriptingEnabled 指定脚本元素是否能被使用。如果为false,那么JSP中如果出现<% %>就会发生错误。

    include指令用于包含一个文件。语法为<%@ include file="xxx"%>。在编译的时候起作用。

    taglib指令用于载入一个自定义标签库。语法为<%@ taglib uri="uri" prefix="xx" %>

    动作元素

    • <jsp:scriptlet> 和 <% %> 是等价的。
    • <jsp:expression> 和 <%= %> 是等价的。
    • <jsp:include> 包含文件,在执行的过程中起作用。
    • <jsp:useBean> 初始化一个 JavaBean 组件
    • <jsp:setProperty> 给 JavaBean 设置属性
    • <jsp:getProperty>
    • <jsp:forward> 向另外一个 JSP 文件传递请求。
    • <jsp:plugin> 在生成的页面中包含 Applet 和 JavaBean 对象。在执行的过程中会被替换成 embed 或者 object 标签。
    • <jsp:element> 动态创建 XML 元素。
    • <jsp:attribute> 定义动态创建的 XML 元素属性
    • <jsp:body> 动态创建 XML 元素的主体。
    • <jsp:text> 与 CDATA 连用,显示 CDATA 中的内容,但不执行 CDATA中的标签动作。比如以下代码:
    1. <jsp:text><![CDATA[ 
    2. <hello></hello> 
    3. <jsp:world/> 
    4. ]]></jsp:text>  


    最后输出的结果是:

    1. <hello></hello>  
    2. <jsp:world/>  

    里面的 <jsp:world/> 并没有被执行。


    所有的动作元素都是在执行 Servlet 代码的过程中被执行。因此需要注意的是 jsp:include 动作,它是在 Servlet 被执行的过程中才引入文件的。这与<%@ include file=""%>不同,后者是在编译的时候引入的。

    所有的动作元素都包含id和scope属性。id用于通过PageContext获取动作元素,scope用于定义对象的寿命。

    useBean、setProperty、getProperty的用法。useBean的作用是引入一个JavaBean,需要提供id和class两个参数。id就是变量的名称,class就是变量的类型。setProperty可以放在useBean的标签里面,表示初始化的时候调用。如果沿用现有的JavaBean,那么标签里面的语句是不会调用的。
    1. <jsp:useBean id="test" class="test.TestBean">  
    2.   <jsp:setProperty name="test" property="name" value="Value"/>  
    3. </jsp>  


    动态创建元素的代码如下:
    1. <jsp:element name="employee">  
    2.   <jsp:attribute name="name">张三</jsp:attribute>  
    3.   <jsp:body>张三是销售部经理</jsp:body>  
    4. </jsp:element>  


    该代码会产生:

    1. <employee name="张三">张三是销售部经理</employee>  

    所谓隐含对象就是已经被系统定义好的一些对象,可以直接使用。JSP中有以下几个隐含对象:

    1. request
    2. response
    3. out 可以使用out.flush来将缓冲区中的数据全都发送到客户端。
    4. session
    5. application 与整个应用的上下文有关。
    6. config
    7. pageContext 与JSP页面的上下文有关。
    8. page 在JSP页面中相当于this指针。
    9. exception 这个对象中包含了从先前页面中包含的异常信息。

    下面请看一个使用隐含对象的例子:
    1. <%  
    2. out.println("Hello world");  
    3. session.put("lastTime", System.currentTimeInMillis());  
    4. %>  

    request对象常用的方法如下:


    response对象常用的方法如下:


    EL表达式语言

    EL就是Expression Language,目的是简化JSP的语法。来看几个例子就明白了。


    1. ${test} 会翻译成<%=test%>  
    2. ${test.name} 会翻译成 <%=test.getName()%>  
    3. ${sessionScope.username}} 会翻译成 <%=session.getAttribute("username")%>  

    只有sessionScope、requestScope等才会翻译成getAttribute("xxx"),而其他的对象,会翻译成getXXX()。


    EL中还支持四则运算、逻辑运算,语法和Java中的一样。EL中有隐含对象:pageContext、pageScope、requestScope、sessionScope、applicationScope、param、paramValues、header、headerValues、cookie、initParam。param等价于request.getParameter,paramValues等价于request.getParameterValues,返回的是字符串数组。


    Java Bean

    JavaBean只是一种成熟的约定,很多框架依靠这个约定简化了很多数据。JavaBean和普通的类相比没什么特别之处,本质其实就是普通的Java类,也不需要特定的父类。只要符合下列规则的类就是JavaBean:
    • 有默认构造函数
    • 成员变量都是私有的,只能通过getXX和setXX来访问
    • 可序列化(implements Serializable。可选,在分布式系统中才有意义)

    Cookie


    Cookies就是保存在浏览器上的一小段文本,是一组键值对。Cookies中包含三个属性,过期时间、路径、域名,所以在HTTP应答中Cookie的样子如下:
    1. Set-Cookie: name=xyzexpires=Friday, 04-Feb-07 22:03:38 GMT; path=/; domain=example.com  
    当客户端后续发送请求的时候就会加上Cookie: name=xyz。

    Servlet中的Cookie类有以下方法:



    JSP中可以向应答中添加多个Cookie,每个Cookie对象是一个键值对,可以往HTTP应答中写入多个Cookie。以下是一个示例:
    1. Cookie cookie = new Cookie("key""value");  
    2. cookie.setMaxAge(86400);  
    3. response.addCookie(cookie);  

    读取Cookie可以通过request.getCookies获取一个Cookie数组。由于可能存在多个Cookie名字相同的情况,因此不能直接通过名称直接获得相应的Cookie。

    删除Cookie可以将maxAge设为0,然后调用response.addCookie加入到应答中。

    Session

    会话管理。HTTP是一个无状态的协议,所以服务器和浏览器需要一个方式来区分用户的身份。首先,浏览器向服务器发送一个请求,服务器检测Cookie中是否有会话ID。如果服务器“不认识”这个会话ID(或者找不到会话ID),那么服务器会创建一个新的唯一编号,放在Map中,Key就是这个新的会话ID,Value就是空的Session对象。浏览器记下Cookie,在后续的请求中都使用这个Cookie。如果服务器认识这个会话ID,那么服务器就会从Map中获取相应的Session对象。

    sessionid可以放在Cookie中,也可以放在post表单中,也可以放在url中,比如http://example.com/page;JSESSIONID=45678943。

    Session对象常用的方法如下:


    Session的过期时间可以在web.xml文件中配置,单位为分钟,Tomcat中默认的超时时间是30分钟。
    1. <session-config>  
    2.   <session-timeout>15</session-timeout>  
    3. </session-config>  

    Session和Cookie的区别。分析区别之前还是先弄清楚是什么导致了它们的不同。在HTTP刚发明的时候,还没有Session的概念,因此开发者只能将重要的数据保存在Cookie中。但是Cookie的数据是保存在浏览器中的,用户可以任意修改,非常不安全。因此有人提出了Session的概念,在Cookie中只保存一串随机生成的SessionID,服务器根据SessionID查找对应的数据,这样,重要的数据就保存在了服务器上,用户无法随意更改,因此比较安全。


    JSP过滤器

    过滤器的作用是给web请求增加额外的逻辑,每个页面可以被多个过滤器进行处理。过滤器需要在web.xml文件中进行定义,语法如下。过滤器的执行顺序与filter-mapping的定义顺序相同。
    1. <filter>  
    2.   <filter-name>FilterName</filter-name>  
    3.   <filter-class>TestFilter</filter-name>  
    4.   <init-param>  
    5.     <param-name>test-param</param-name>  
    6.     <param-value>test-value</param-name>  
    7.   </init-param>  
    8. </filter>  
    9.   
    10. <filter-mapping>  
    11.   <filter-name>TestFilter</filter-name>  
    12.   <url-pattern>/*</url-pattern>  
    13. </filter-mapping>  

    文件上传

    浏览器上传文件的时候,HTTP请求中的MIME类型必须为multipart/form-data。

    文件上传的处理需要使用commons-fileupload库和commons-io库。

    在服务端,为了获取文件列表,你需要一个ServletFileUpload对象,这样就可以调用它的parseRequest(request)方法来获得文件列表。为了创建ServletFileUpload,你需要一个DiskFileItemFactory,这个类的作用就是将文件保存到内存中,如果保存不下,就保存到磁盘中。因此需要设置内存的使用量和临时文件的存放路径,分别可以通过setSizeThreshold和setRepository方法。下面是完整的例子。

    1. DiskFileItemFactory factory = new DiskFileItemFactory();  
    2. // 设置内存中存储文件的最大值  
    3. factory.setSizeThreshold(maxMemSize);  
    4. // 本地存储的数据大于 maxMemSize.  
    5. factory.setRepository(new File("c:\temp"));  
    6.   
    7. // 创建一个新的文件上传处理程序  
    8. ServletFileUpload upload = new ServletFileUpload(factory);  
    9. // 设置最大上传的文件大小  
    10. upload.setSizeMax( maxFileSize );  
    11. // 解析上传的文件  
    12. List fileItems = upload.parseRequest(request);  

    JSTL

    在使用JSTL之前首先要下载jakarta-taglibs-standard-x.x.x.zip,并将压缩包中的standard.jar和jstl.jar加入到WEB-INF/lib下。

    JSTL的所有标签见下图:


    变量要用$符号括起来,$是EL表达式的写法,通过EL表达式转换成对应的字符串。下面这个例子展示了变量的用法。

    1. <fmt:formatNumber value="${balance}" type="currency"/>  

    JSTL函数的用法。下面这个例子中,将函数与if标签结合使用。

    1. <c:if test="${fn:contains(theString, 'test')}">  
    2.    <p>Found test string<p>  
    3. </c:if>  

    数据库操作

    下面的代码实现了JSP中数据库的连接,并且创建了一个名为snapshot的数据源。

    1. <sql:setDataSource var="snapshot" driver="com.mysql.jdbc.Driver" url="jdbc:mysql://localhost/test" user="root" password="123456"/>  

    下面的代码实现了数据库的请求。
    1. <sql:query dataSource="${snapshot}" var="result">  
    2.   SELECT * FROM users;  
    3. </sql:query>  

    下面的代码展示了参数替换的用法。
    1. <sql:query dataSource="${snapshot}" var="result">  
    2.   SELECT * FROM users WHERE id = ?;  
    3.   <sql:param value="${userId}"/>  
    4. </sql:query>  

    自定义标签

    自定义标签需要完成两件事,一件是定义标签的规则,有哪些属性,哪些属性是必填的,格式是怎样的,可以包含哪些子标签。另外一件事就是实现标签的功能。

    定义标签规则。新建一个tld文件,对于这个例子,文件的内容可以这样写:
    1. <taglib>  
    2.   <tlib-version>1.0</tlib-version>  
    3.   <jsp-version>2.0</jsp-version>  
    4.   <short-name>Test TLD</short-name>  
    5.   <tag>  
    6.     <name>hello</name>  
    7.     <tag-class>com.pc.HelloTag</tag-class>  
    8.     <body-content>empty</body-content>  
    9.   </tag>  
    10. </taglib>  

    实现标签的功能。这个例子里面就是简单地将标签替换成Hello World字符串。代码可以写成这样:
    1. public class HelloTag extends SimpleTagSupport {  
    2.     public void doTag() {  
    3.         JspWriter out = getJspContext().getOut();  
    4.         out.println("Hello world!");  
    5.     }  
    6. }  

    获取标签里面的内容。首先要修改TLD,使其允许在标签里面存放文本。其次是通过invoke函数获取标签里面的内容。
    1. <body-content>scriptless</body-content>  

    1. StringWriter writer = new StringWriter();  
    2. getJspBody().invoke(writer);  

    获取标签上的属性。首先要修改TLD,允许标签设置哪些属性。其次,JSP引擎会调用setXXX函数传递属性值。

    1. <tag>  
    2.   <attribute>  
    3.     <name>message</name>  
    4.   </attribute>  
    5. </tag>  

    1. // 由系统自动调用。  
    2. public void setMessage(String message) {  
    3.     this.message = message;  
    4. }  

  • 相关阅读:
    JUC高并发编程(三)之模拟接口压力测试
    JUC高并发编程(二)之多线程下载支付宝对账文件
    JUC高并发编程(一)之请求合并案例
    《Head First设计模式》读书笔记
    图文详解23种设计模式
    Laravel路由匹配
    深夜debug:一个不常遇到的HbuilderX自动化测试运行问题
    高德地图API中折线polyline不能跨越180度经度线的解决方案
    sublime配置java运行环境
    Docker技术入门
  • 原文地址:https://www.cnblogs.com/wanghang/p/6299051.html
Copyright © 2011-2022 走看看