JSP&Servlet学习笔记(二)
2017-03-11 11:20
567 查看
一、Servlet
JSP的本质就是Servlet,而Web容器会将JSP编译成对应的Servlet。自MVC规范出现后,Servlet的责任开始明确下来,仅仅作为控制器使用,不再需要生成页面标签,也不再作为视图层角色使用。1.1 Servlet的开发
Servlet是运行在服务器端的程序,用于处理及响应客户端的请求。Servlet是个特殊的Java类必须继承HttpServlet,每个Servlet可以响应客户端的请求。Servlet提供不同的方法用于响应客户端请求:doGet:用于响应客户端的GET请求
doPost:用于响应客户端的POST请求
doPut&doDelete:基本不用
事实上,客户端的请求通常只有GET和POST两种,Servlet为了响应这两种请求,必须重写doGet()和doPost()两个方法。
大部分时候,Servlet对于所有请求的响应都是完全一样的。此时,可以采用重写一个方法来替代上面的几个方法:只需重写service()方法即可响应客户端的所有请求。
另外,HttpServlet还包含两个方法:
init(ServletConfig config):创建Servlet实例时,调用该方法的初始化Servlet资源
destroy():销毁Servlet实例时,自动调用该方法的回收资源。
通常无须重写上面的两个方法,除非需要在初始化Servlet时,完成某些资源初始化的方法,才考虑冲洗init方法。如果需要在销毁Servlet之前,先完成某些资源的回收,比如关闭数据库连接等,才需要重写destroy方法。
注意:如果重写init()方法,则应该在重写该方法的第一行调用super.init(config)。
Servlet和JSP的区别在于:
Servlet中没有内置对象,原来JSP的内置对象都必须有程序显示创建
对于静态的HTML标签,Servlet都必须使用页面输出流逐行输出
1.2 Servlet的配置
编辑好的Servlet源文件并不能响应用户请求, 还必须将其编译成class文件,如果需要直接使用javac命令编译Servlet类,则必须将Servlet API接口和类添加到系统的CLASSPATH环境变量里。也就是将Tomcat安装目录下的servlet-api.jar和jsp-api.jar添加到CLASSPATH环境变量中,当然使用IDE这些都会自动完成了。为了让Servlet能响应用户请求,还必须将Servlet配置在Web应用中。配置Servlet时需要修改web.xml文件。
从Servlet3.0开始,配置Servlet有两种方式:
在Servlet类中使用@WebServlet注解进行配置
通过在web.xml文件中进行配置
开发Servlet类时使用了@WebServlet注解修饰该Servlet,其有如下常用的属性(全都是可选的):
name:指定该Servlet的名称
urlPatterns / value:这两个属性的作用完全相同,都是指定该Servlet处理的URL
asyncSupported:指定该Servlet是否支持异步操作模式
display:指定该Servlet的显示名
initParams:用于为该Servlet配置参数
loadOnStartup:用于将该Servlet配置成load-on-startup的Servlet
如果打算使用注解来配置Servlet,有两点需要指出:
不要在web.xml文件的根元素(<web-app../>)中指定metadata-complete=“true”
不要在web.xml文件中配置该Servlet
如果打算使用web.xml文件来配置Servlet,则需要配置如下两个部分:
配置Servlet的名字:对应web.xml文件中的<servlet/>元素
配置Servlet的URL:对应web.xml文件中的<servlet-mapping/>元素。这一步是可选的,但如果没有为是Servlet配置URL,则该Servlet不能响应用户请求
<!-- 配置Servlet的名字 --> <servlet> <!-- 指定Servlet的名字, 相当于指定@WebServlet的name属性 --> <servlet-name>firstServlet</servlet-name> <!-- 指定Servlet的实现类 --> <servlet-class>lee.FirstServlet</servlet-class> </servlet> <!-- 配置Servlet的URL --> <servlet-mapping> <!-- 指定Servlet的名字 --> <servlet-name>firstServlet</servlet-name> <!-- 指定Servlet映射的URL地址, 相当于指定@WebServlet的urlPatterns属性 --> <url-pattern>/aa</url-pattern> </servlet-mapping>
1.3 JSP/Servlet的声明周期
JSP本质是Servlet,JSP页面将有Web容器编译成对应的Servlet,当Servlet容器中运行时,其实例的创建及销毁等都不是由程序员决定的,而是有Web容器进行控制的。创建Servlet实例有两个时机:
客户端第一次请求某个Servlet时,系统创建该Servlet的实例:大部分的Servlet都是这种Servlet
Web应用启动时立即创建Servlet实例,即load-on-startup Servlet
1.4 load-on-startup Servlet
这总方式的Servlet在Web应用启动时立即创建Servlet实例,通常是用于某些后台服务的Servlet,或者需要拦截很多请求的Servlet;这种Servlet通常作为应用的基础Servlet使用,提供重要的后台服务。配置load-on-startup的Servlet有两种方式:
在web.xml文件中通过<servlet../>元素的<load-on-startup../>子元素进行配置
通过@WebServlet注解的loadOnStartup属性指定
<load-on-startup../>元素或loadOnStartUp属性都只接收一个整型值,这个整型值越小,Servlet就越优先实例化。
示例:
<servlet> <!-- Servlet名 --> <servlet-name>timerServlet</servlet-name> <!-- Servlet的实现类 --> <servlet-class>lee.TimerServlet</servlet-class> <!-- 配置应用启动时,创建Servlet实例 ,相当于指定@WebServlet的loadOnStartup属性 --> <load-on-startup>1</load-on-startup> </servlet>
1.5 访问Servlet的配置参数
配置Servlet时,还可以增加额外的配置参数。通过使用配置参数,可以实现提供更好的可移植性,避免将参数以硬编码方式写在程序代码中。为Servlet配置参数有两种方式:
通过@WebServlet的initParams属性来指定
通过在web.xml文件的<servlet.../>元素中添加<init-param.../>子元素来指定
示例:
@WebServlet(name = "testServlet", urlPatterns = { "/testServlet" }, initParams = { @WebInitParam(name = "driver", value = "com.mysql.jdbc.Driver"), @WebInitParam(name = "url", value = "jdbc:mysql://localhost:3306/javaee"), @WebInitParam(name = "user", value = "root"), @WebInitParam(name = "pass", value = "32147") })访问Servlet配置参数通过ServletConfig独享完成,ServletConfig提供getInitParameter()来获取初始化参数,如下:
// 获取ServletConfig对象 ServletConfig config = getServletConfig(); // 通过ServletConfig对象获取配置参数:dirver String driver = config.getInitParameter("driver"); // 通过ServletConfig对象获取配置参数:url String url = config.getInitParameter("url"); // 通过ServletConfig对象获取配置参数:user String user = config.getInitParameter("user"); // 通过ServletConfig对象获取配置参数:pass String pass = config.getInitParameter("pass");ServletConfig获取配置参数的方法和ServletContext获取配置参数的方法完全一样,只是ServletConfig是获得当前Servlet的配置参数,而ServletContext是获取整个Web应用的配置参数。
在web.xml中为Servlet配置参数(与上面的功能相同):
<servlet> <!-- 配置Servlet名 --> <servlet-name>testServlet</servlet-name> <!-- 指定Servlet的实现类 --> <servlet-class>lee.TestServlet</servlet-class> <!-- 配置Servlet的初始化参数:driver --> <init-param> <param-name>driver</param-name> <param-value>com.mysql.jdbc.Driver</param-value> </init-param> <!-- 配置Servlet的初始化参数:url --> <init-param> <param-name>url</param-name> <param-value>jdbc:mysql://localhost:3306/javaee</param-value> </init-param> <!-- 配置Servlet的初始化参数:user --> <init-param> <param-name>user</param-name> <param-value>root</param-value> </init-param> <!-- 配置Servlet的初始化参数:pass --> <init-param> <param-name>pass</param-name> <param-value>32147</param-value> </init-param> </servlet>
1.6 使用Servlet作为控制器
使用Servlet作为表现层有如下三个劣势:开发效率低,所有的HTML标签都需使用页面输出流完成
不利于团队协作开发,美工人员无法参与Servlet界面的开发
程序可维护性差,即使修改一个按钮的标题,都必须重新编辑Java代码,并重新编译
在标准的MVC模式中,Servlet仅作为控制器使用。Java EE应用框架正式遵循MVC模式的,对于遵循MVC模式的Java EE应用而言,JSP仅作为表现层(View)技术,其作用有两点:
负责收集用户请求参数
将应用的处理结果、状态数据呈现给用户
Servlet则仅充当控制器(Controller)角色,它的作用类似于调度员:所有用户请求都发送给Servlet,Servlet调用Model来处理用户请求,并调用JSP来呈现处理结果;或者Servlet直接调用JSP将应用的状态数据呈现给用户。
二、JSP2的自定义标签
JSP2规范简化了标签的开发,在JSP2中开发标签库只需要如下几个步骤:开发自定义标签处理类
建立一个*.tld文件,每个*.tld文件对应一个标签库,每个标签库可包含多个标签
在JSP文件中使用自定义标签
标签库是非常重要的技术,通常来说,初学者、普通开发人员都不会编写自己的标签库,因为像MVC框架,如Struts2、SpringMVC、JSF等都提供了丰富的自定义标签。
2.1 开发自定义标签类
自定义标签类应该继承一个父类:javax.servlet.jsp.tagext.SimpleTagSupport,除此之外,JSP自定义标签类还有如下要求:如果标签类包含属性,每个属性都有对应的getter和setter方法
重写doTag()方法,这个方法负责生成页面内容
public class HelloWorldTag extends SimpleTagSupport { // 重写doTag()方法,该方法为标签生成页面内容 public void doTag() throws JspException, IOException { // 获取页面输出流,并输出字符串 getJspContext().getOut().write("Hello World " + new java.util.Date()); } }
2.2 建立TLD文件
TLD是Tag Library Definition的缩写,即标签库定义,文件的后缀是tld,每个TLD文件对应一个标签库,一个标签库中可包含多个标签。TLD文件也称为标签库定义文件。标签库定义文件的根元素是taglib,他可以包含多个tag子元素,每个tag子元素都定义了一个标签。通常可以到Web容器下复制一个标签库定义文件,在其基础上进行修改即可。例如Tomcat中,在webapps\examples\WEB-INF\jsp2路径下包含了一个示例文件。我们可以将tld文件复制到Web应用的WEB-INF路径下(可以是任意子路径下)。
注意:Tomcat 8 所带的示例的TLD文件的根元素所采用的的是标签库2.0规范。
标签库2.0根元素:
<taglib xmlns="http://java.sun.com/xml/ns/j2ee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-jsptaglibrary_2_0.xsd" version="2.0">
标签库2.1根元素:
<taglib xmlns="http://xmlns.jcp.org/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-jsptaglibrary_2_1.xsd" version="2.1">taglib下有如下三个子元素:
tlib-version:指定该标签库实现的版本,这是一个作为标识的内部版本号,对程序没有太大的作用
short-name:该标签库的默认短名,该名称通常也没有太大的用处
uri:这个属性非常重要,它指定该标签库的URI,相当于指定该标签库的唯一标识。JSP页面中使用标签库时就是根据该URI属性来定位标签库的
taglib元素下可以包含多个tag元素,每个tag元素定义一个标签,tag元素下允许出现如下常用子元素:
name:该标签的名称,这个子元素很重要,JSP页面中就是根据该名称来使用此标签的
tag-class:指定标签的处理类
body-content:这个子元素也很重要,它指定标签体内容。其值可以为:
tagdependent:指定标签处理类自己负责处理标签体
empty:指定该标签只能作用空标签使用
scriptless:指定该标签的标签体可以是静态HTML元素、表达式语言,但不允许出现JSP脚步
JSP:指定该标签的标签体可以使用JSP脚本
注:JSP2规范中body-content元素的值不可以是JSP。
注:标签库文件放在Web应用的WEB-INF路径或任意子路径下,Java Web规范会自动加载该文件,则该文件定义的标签库也将生效。
2.3 使用标签库
在JSP页面中确定指定的标签需要两点:标签库URI:确定使用哪个标签库
标签名:确定使用哪个标签
使用标签库分成以下两个步骤:
导入标签库:使用taglib编译指令导入标签库,就是将标签库和指定前缀关联起来
使用标签:在JSP页面中使用标签
2.3.1 导入标签库
导入时的语法格式如下:<%@ taglib uri="tagLibUri" prefix="tagPrefix"%>其中uri属性指定标签库的URI,这个URI可以确定一个标签库,这个URI就是TLD文件中定义的uri属性对应。而prefix属性指定标签库前缀,即所有使用该前缀的标签将由此标签库处理。
2.3.2 使用标签库
使用标签的语法格式如下:<tagprefix:tagName tagAttribute="tagValue"...> <tagBody /> </tagprefix:tagName>如果该标签没有标签体,则可以使用如下语法格式:
<tagprefix:tagName tagAttribute="tagValue".../>注:tagprefix其实就是上面定义的prefix属性所定义的值。
示例:
标签库类定义在上面,在tld中定义如下:
<taglib xmlns="http://java.sun.com/xml/ns/j2ee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-jsptaglibrary_2_0.xsd" version="2.0">JSP中导入标签库:
<tlib-version>1.0</tlib-version>
<short-name>mytaglib</short-name>
<!-- 定义该标签库的URI -->
<uri>http://www.crazyit.org/mytaglib</uri>
<!-- 定义一个标签 -->
<tag>
<!-- 定义标签名 -->
<name>helloWorld</name>
<!-- 定义标签处理类 -->
<tag-class>lee.HelloWorldTag</tag-class>
<!-- 定义标签体为空 -->
<body-content>empty</body-content>
</tag>
</taglib>
<!-- 导入标签库,指定mytag前缀的标签, 由URI为http://www.crazyit.org/mytaglib的标签库处理 --> <%@ taglib uri="http://www.crazyit.org/mytaglib" prefix="mytag"%>JSP中使用标签:
<mytag:helloWorld/>
2.4 带属性的标签
前面的简单标签既没有属性,也没有标签体,用法和功能比较简单。需要注意的是带属性标签必须为每个属性提供对应的setter和getter方法,而带属性标签的配置方法与简单标签也略有差别。示例如下:自定义带属性的标签类:
public class QueryTag extends SimpleTagSupport { // 定义成员变量来代表标签的属性 private String driver; private String url; private String user; private String pass; private String sql; // 执行数据库访问的对象 private Connection conn = null; private Statement stmt = null; private ResultSet rs = null; private ResultSetMetaData rsmd = null; //省略各成员变量的setter和getter方法 ... public void doTag() throws JspException, IOException { try { // 注册驱动 Class.forName(driver); // 获取数据库连接 conn = DriverManager.getConnection(url, user, pass); // 创建Statement对象 stmt = conn.createStatement(); // 执行查询 rs = stmt.executeQuery(sql); rsmd = rs.getMetaData(); // 获取列数目 int columnCount = rsmd.getColumnCount(); // 获取页面输出流 Writer out = getJspContext().getOut(); // 在页面输出表格 out.write("<table border='1' bgColor='#9999cc' width='400'>"); // 遍历结果集 while (rs.next()) { out.write("<tr>"); // 逐列输出查询到的数据 for (int i = 1; i <= columnCount; i++) { out.write("<td>"); out.write(rs.getString(i)); out.write("</td>"); } out.write("</tr>"); } } catch (ClassNotFoundException cnfe) { cnfe.printStackTrace(); throw new JspException("自定义标签错误" + cnfe.getMessage()); } catch (SQLException ex) { ex.printStackTrace(); throw new JspException("自定义标签错误" + ex.getMessage()); } finally { // 关闭结果集 try { if (rs != null) rs.close(); if (stmt != null) stmt.close(); if (conn != null) conn.close(); } catch (SQLException sqle) { sqle.printStackTrace(); } } } }该标签类包含了5个属性,而为标签处理类定义成员变量即可代表标签的属性,而且程序需要为这5个属性提供setter()和getter()方法。该标签输出的内容依然由doTag()方法决定,该方法会根据SQL语句查询数据库,并将查询结果显示在当前页面中。
对于有属性的标签,需要在tld中为<tag../>元素增加<attribute../>子元素,每个<attribute../>定义一个标签属性。<attribute../> 子元素通常还需要指定如下几个子元素:
name:设置属性名,子元素的值是字符串内容
required:设置该属性是否为必须属性,该子元素的值时true或false
fragment:设置该属性是否支持JSP脚本、表达式等动态内容,子元素的值true或false
为了配置上面的QueryTag标签,需要在tld文件中增加如下配置片段:
<tag> <!-- 定义标签名 --> <name>query</name> <!-- 定义标签处理类 --> <tag-class>lee.QueryTag</tag-class> <!-- 定义标签体为空 --> <body-content>empty</body-content> <!-- 配置标签属性:driver --> <attribute> <name>driver</name> <required>true</required> <fragment>true</fragment> </attribute> <!-- 配置标签属性:url --> <attribute> <name>url</name> <required>true</required> <fragment>true</fragment> </attribute> <!-- 配置标签属性:user --> <attribute> <name>user</name> <required>true</required> <fragment>true</fragment> </attribute> <!-- 配置标签属性:pass --> <attribute> <name>pass</name> <required>true</required> <fragment>true</fragment> </attribute> <!-- 配置标签属性:sql --> <attribute> <name>sql</name> <required>true</required> <fragment>true</fragment> </attribute> </tag>配置完毕后,就可在页面中使用标签了,先导入标签库,然后使用标签,代码如下:
<%@ taglib uri="http://www.crazyit.org/mytaglib" prefix="mytag"%> <!-- 使用标签 ,其中mytag是标签前缀,根据taglib的编译指令, mytag前缀将由http://www.crazyit.org/mytaglib的标签库处理 --> ...... <mytag:query driver="com.mysql.jdbc.Driver" url="jdbc:mysql://localhost:3306/javaee" user="root" pass="32147" sql="select * from news_inf"/>
2.5 带标签体的标签(重点)
带标签体的标签,可以在标签内嵌入其他内容(包括静态的HTML内容和动态的JSP内容),通常用于完成一些逻辑运算。示例如下:标签处理类:
public class IteratorTag extends SimpleTagSupport { // 标签属性,用于指定需要被迭代的集合 private String collection; // 标签属性,指定迭代集合元素,为集合元素指定的名称 private String item;
// 省略get与set...
// 标签的处理方法,标签处理类只需要重写doTag()方法 public void doTag() throws JspException, IOException { // 从page scope中获取名为collection的集合 Collection<?> itemList = (Collection<?>) getJspContext().getAttribute(collection); // 遍历集合 for (Object s : itemList) { // 将集合的元素设置到page范围内 getJspContext().setAttribute(item, s); // 输出标签体 getJspBody().invoke(null); } } }
该标签处理类的doTag()方法首先从page范围内获取了指定名称的Collection对象,然后遍历Collection对象的元素,每次遍历都调用getJspBody()方法,该方法返回该标签所包含的标签体:JSPFragment对象,执行该对象的invoke()方法,即可输出标签体内容。该标签的作用是:遍历指定集合,每遍历一个集合元素,技术处标签体一次。
因为该标签的标签体不为空,配置该标签时指定body-content为scriptless,该标签的配置代码如下:
<tag> <!-- 定义标签名 --> <name>iterator</name> <!-- 定义标签处理类 --> <tag-class>lee.IteratorTag</tag-class> <!-- 定义标签体不允许出现JSP脚本 --> <body-content>scriptless</body-content> <!-- 配置标签属性:collection --> <attribute> <name>collection</name> <required>true</required> <fragment>true</fragment> </attribute> <!-- 配置标签属性:item --> <attribute> <name>item</name> <required>true</required> <fragment>true</fragment> </attribute> </tag>上面的配置指定该标签的标签体可以是静态HTML内容,也可以是表达式语言,但不允许出现JSP脚本。下面是测试代码:(导入代码省略)
<body> <h2>带标签体的标签-迭代器标签</h2> <hr /> <% //创建一个List对象 List<String> a = new ArrayList<String>(); a.add("疯狂Java"); a.add("www.crazyit.org"); a.add("www.fkit.org"); //将List对象放入page范围内 pageContext.setAttribute("a", a); %> <table border="1" bgcolor="#aaaadd" width="300"> <!-- 使用迭代器标签,对a集合进行迭代 --> <mytag:iterator collection="a" item="item"> <tr> <td>${pageScope.item}</td> </tr> </mytag:iterator> </table> </body>测试结果如下:
从输出结果看,使用iterator标签遍历集合元素比使用JSP脚本遍历集合元素要优雅得多,这就是自定义标签的魅力。实际上JSTL标签库提供了一套功能强大的标签,如果有现成的轮子就没必要再造轮子了。
可能你有所疑惑,这个JSP页面自己先把多个字符串添加到ArrayList,然后再使用这个iterator标签进行迭代输出,好像没有意义。实际上这个标签的用处非常大,在严格的MVC规范下,JSP页面只负责显示数据——而数据通常由控制器(Servlet)放入request范围内,而JSP页面就通过iterator标签迭代出输出request范围内的数据。
2.6 以页面片段作为属性的标签(暂不理解)
JSP2规范的自定义标签还允许直接将一段“页面片段”作为属性,这种方式给自定义标签提供了更大的灵活性。以“页面片段”为属性的标签与与普通标签区别并不大,只有两个简单的改变:标签处理类中定义类型为JSPFragment的属性,该属性代表了“页面片段”
使用标签库,通过<jsp:attribute.../>动作指令为标签的属性指定值
示例:
定义一个标签处理类:
public class FragmentTag extends SimpleTagSupport { private JspFragment fragment; //省略fragment的setter和getter方法 @Override public void doTag() throws JspException, IOException { JspWriter out = getJspContext().getOut(); out.println("<div style='padding:10px;border:1px solid black;" + ";border-radius:20px'>"); out.println("<h3>下面是动态传入的JSP片段</h3>"); // 调用、输出“页面片段” fragment.invoke(null); out.println("</div"); } }上面的程序中定义了fragment成员变量,该成员变量代表了使用该标签时的“页面片段”,配置该标签与配置普通标签并无任何区别,增加如下配置片段即可。
<tag> <!-- 定义标签名 --> <name>fragment</name> <!-- 定义标签处理类 --> <tag-class>lee.FragmentTag</tag-class> <!-- 指定该标签不支持标签体 --> <body-content>empty</body-content> <!-- 定义标签属性:fragment --> <attribute> <name>fragment</name> <required>true</required> <fragment>true</fragment> </attribute> </tag>这个自定义标签并没有任何特别之处,就是一个普通的带属性标签,该标签的标签体为空。由于该标签需要一个fragment属性,该属性的类型为JspFragment,因此使用该标签时需要使用<jsp:attribute../>动作指令来设置属性值,如下所示:
<!-- 导入标签库,指定mytag前缀的标签, 由http://www.crazyit.org/mytaglib的标签库处理 --> <%@ taglib uri="http://www.crazyit.org/mytaglib" prefix="mytag"%> ..... <mytag:fragment> <jsp:attribute name="fragment"> <%-- 使用jsp:attribute标签传入fragment参数(该注释不能放在fragment内) --> <%-- 下面是动态的JSP页面片段 --%> <mytag:helloWorld /> </jsp:attribute> </mytag:fragment> <br /> <mytag:fragment> <jsp:attribute name="fragment"> <%-- 下面是动态的JSP页面片段 --%> ${pageContext.request.remoteAddr} </jsp:attribute> </mytag:fragment>注意:由于程序指定了fragment标签的标签体为empty,因此程序中fragment开始标签和fragment结束标签之间只能使用<jsp:attribute.../>子元素,不允许出现其他内容,甚至连注释都不允许。
2.7 动态属性的标签(终点)
前面的标签的属性个数是确定的,绝大部分情况下这种带属性的标签能处理得很好,但在某些特殊情况下,需要传入自定义标签的属性个数是不确定的,属性名也不确定,这就需要借助于动态属性的标签了。动态属性标签比普通标签多了两个额外需求:
标签处理类还需要实现DynamicAttributes接口
配置标签时通过<dynamic-attributes.../>子元素指定该标签支持动态属性
示例:
动态属性标签的处理类:
public class DynaAttributesTag extends SimpleTagSupport implements DynamicAttributes { // 保存每个属性名的集合 private ArrayList<String> keys = new ArrayList<String>(); // 保存每个属性值的集合 private ArrayList<Object> values = new ArrayList<Object>(); @Override public void doTag() throws JspException, IOException { JspWriter out = getJspContext().getOut(); // 此处只是简单地输出每个属性 out.println("<ol>"); for (int i = 0; i < keys.size(); i++) { String key = keys.get(i); Object value = values.get(i); out.println("<li>" + key + " = " + value + "</li>"); } out.println("</ol>"); } @Override public void setDynamicAttribute(String uri, String localName, Object value) throws JspException { // 添加属性名 keys.add(localName); // 添加属性值 values.add(value); } }上面的标签处理类实现了DynamicAttributes接口,就是动态属性标签处理类必须实现的接口,实现该接口必须实现setDynamicAttribute()方法,该方法用于为该标签处理类动态地添加属性名和属性值。标签处理类使用ArrayList<String>类型的Keys属性来保存标签的所有属性名,使用ArrayList<Object>类型的values属性来保存标签的所有属性值。
配置该标签时需要额外地指定<dynamic-attributes.../>子元素,表明该标签时带动态属性的标签,如下:
<!-- 定义接受动态属性的标签 --> <tag> <name>dynaAttr</name> <tag-class>lee.DynaAttributesTag</tag-class> <body-content>empty</body-content> <!-- 指定支持动态属性 --> <dynamic-attributes>true</dynamic-attributes> </tag>一旦定义了动态属性的标签,接下来在页面中使用该标签时将十分灵活,完全可以为该标签设置任意的属性,如下:
<!-- 导入标签库,指定mytag前缀的标签, 由http://www.crazyit.org/mytaglib的标签库处理 --> <%@ taglib uri="http://www.crazyit.org/mytaglib" prefix="mytag"%> ... <h2>下面显示的是自定义标签中的内容</h2> <h4>指定两个属性</h4> <mytag:dynaAttr name="crazyit" url="crazyit.org" /> <br /> <h4>指定四个属性</h4> <mytag:dynaAttr 书名="疯狂Java讲义" 价格="99.0" 出版时间="2008年" 描述="Java图书" />
三、Filter
Filter主要用于对用户请求进行预处理,也可对HttpServletResponse进行后处理,是个典型的处理链。Filter也可以对用户请求生成响应,这一点与Servlet相同,但实际上很少会使用Filter向用户请求生成响应。使用Filter完整的流程是:Filter对用户请求进行预处理,接着将请求交给Servlet进行处理并生成响应,最后Filter再对服务器响应进行后处理。Filter有如下几个用处:
在HttpServletRequest到达Servlet之前,拦截客户的HttpServletResponse
根据需要检查HttpServletRequest,也可以修改HttpServletRequest头和数据
在HttpServletResponse到达客户端之前,拦截HttpServletResponse
根据需要检查HttpServletResponse,也可以修改HttpServletResponse头和数据
Filter有如下几个种类:
用户授权的Filter:Filter负责检查用户请求,根据请求过滤用户非法请求
日志Filter:详细记录某些特殊的用户请求
负责解码的Filter:包括对非标准编码的请求解码
能改变XML内容的XSLT Filter等
Filter可负责拦截多个请求或相应:一个请求或相应也可被多个Filter拦截
创建一个Filter只需要两个步骤:
创建Filter处理类
web.xml文件中配置Filter
3.1 创建Filter类
创建Filter必须实现javax.Servlet.Filter接口,在该接口中定义了如下三个方法:void init(FilterConfig config):用于完成Filter的初始化
void destroy():用于Filter销毁前,完成某些资源的回收
void doFilter(ServletRequest request , ServletResponse response , FilterChain chain):实现过滤功能,该方法就是对每个请求及响应增加的额外处理
终点在doFilter方法,实现该方法就可实现对用户请求进行预处理,也可实现对服务器响应进行后处理——它们的分界线为是否调用了chain.doFilter(request, response);方法,执行该方法之前,即对用户请求进行预处理;执行该方法之后,即对服务器响应进行后处理。
示例:(使用注解配置,详细介绍在下面)
@WebFilter(filterName = "log", urlPatterns = { "/*" }) public class LogFilter implements Filter { // FilterConfig可用于访问Filter的配置信息 private FilterConfig config; // 实现初始化方法 public void init(FilterConfig config) { this.config = config; } // 实现销毁方法 public void destroy() { this.config = null; } // 执行过滤的核心方法 public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException { // ---------下面代码用于对用户请求执行预处理--------- // 获取ServletContext对象,用于记录日志 ServletContext context = this.config.getServletContext(); long before = System.currentTimeMillis(); System.out.println("开始过滤..."); // 将请求转换成HttpServletRequest请求 HttpServletRequest hrequest = (HttpServletRequest) request; // 输出提示信息 System.out.println("Filter已经截获到用户的请求的地址: " + hrequest.getServletPath()); // Filter只是链式处理,请求依然放行到目的地址 chain.doFilter(request, response);//放行用户请求 // ---------下面代码用于对服务器响应执行后处理--------- long after = System.currentTimeMillis(); // 输出提示信息 System.out.println("过滤结束"); // 输出提示信息 System.out.println("请求被定位到" + hrequest.getRequestURI() + " 所花的时间为: " + (after - before)); } }这个Filter的作用是拦截所有的请求,然后输出请求地址,然后放行这个请求,然后,输出响应地址,并且输出整个响应过程所需要的时间。这只是个简单的拦截器,我们完全也可以在Filter中根据用户请求的HttpSession,判断用户权限是否足够。如果权限不够,直接调用重定向即可,无须调用chain.doFilter(request, response);方法。
3.2 配置Filter
Filter可以认为是Servlet的“增强版”,因此配置Filter与配置Servlet非常相似,都需要配置如下两个部分:配置Filter名
配置Filter拦截URL模式
区别在于:Servlet通常指配置一个URL,而Filter可以同时拦截多个请求的URL。因此,在配置Filter的URL模式时通常会使用模式字符串,使得Filter可以拦截多个请求。与配置Servlet相似的是,配置Filter同样有两种方式:
在Filter类中通过注解进行配置
在web.xml文件中通过配置文件进行配置
上面Filter类代码使用@WebFilter配置该Filter的名字为log,它会拦截向/*发送的所有请求。而用web.xml文件配置其作用相同,如下:
<!-- 定义Filter --> <filter> <!-- Filter的名字,相当于指定@WebFilter 的filterName属性 --> <filter-name>log</filter-name> <!-- Filter的实现类 --> <filter-class>lee.LogFilter</filter-class> </filter> <!-- 定义Filter拦截的URL地址 --> <filter-mapping> <!-- Filter的名字 --> <filter-name>log</filter-name> <!-- Filter负责拦截的URL,相当于指定@WebFilter 的urlPatterns属性 --> <url-pattern>/*</url-pattern> </filter-mapping>
3.2.1 @WebFilter注解常用属性(都是非必须)
filterName:指定该Filter的名称urlPatterns / value:这两个属性的作用完全相同。都指定该Filter所拦截的URL
initParams:用于为该Filter配置参数
servletNames:该属性值指定多个Servlet的名称,用于指定该Filter仅对这几个Servlet执行过滤
displayName:指定该Filter的显示名
asyncSupported:指定该Filter是否支持异步操作模式。
dispatcherTypes:指定该Filter仅对那种dispatcher模式的请求进行过滤。该属性支持ASYNC、ERROR、FORWARD、INCLUDE、REQUEST这5个值的任何组合。默认值为同时过滤5种模式的请求。
3.2.2 使用示例
假设系统有包含多个Servlet,这些Servlet都需要进行一些的通用处理:比如权限控制、记录日志等,这将导致在这些Servlet的service方法中有部分代码是相同的——为了解决这种代码重复的问题,可以考虑把这些通用处理提取到Filter中完成,这样各Servlet中剩下的只是特定请求相关的处理代码,而通过处理则交给Filter完成。由于Filter和Servlet如此相似,所以Filter和Servlet具有完全相同的生命周期行为,且Filter也可以通过<init-param.../>元素或@WebFilter的initParams属性来配置初始化参数,获取Filter的初始化参数则使用FilterConfig的getInitParameter()方法。
下面我们定一个较为实用的Filter,该Filter对用户请求进行过滤,Filter将通过doFilter方法来设置request编码的字符集,从而避免每个JSP、Servlet都需要设置;而且还会验证用户是否登录,如下:
Filter源码:
@WebFilter(filterName = "authority", urlPatterns = { "/*" }, initParams = { @WebInitParam(name = "encoding", value = "GBK"), @WebInitParam(name = "loginPage", value = "/login.jsp") }) public class AuthorityFilter implements Filter { // FilterConfig可用于访问Filter的配置信息 private FilterConfig config; // 实现初始化方法 public void init(FilterConfig config) { this.config = config; } // 实现销毁方法 public void destroy() { this.config = null; } // 执行过滤的核心方法 public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException { // 获取该Filter的配置参数 String encoding = config.getInitParameter("encoding"); String loginPage = config.getInitParameter("loginPage"); // 设置request编码用的字符集 request.setCharacterEncoding(encoding); HttpServletRequest requ = (HttpServletRequest) request; HttpSession session = requ.getSession(true); // 获取客户请求的页面 String requestPath = requ.getServletPath(); // 如果session范围的user为null,即表明没有登录 // 且用户请求的既不是登录页面,也不是处理登录的页面 if (session.getAttribute("user") == null && !requestPath.endsWith(loginPage)) { // forward到登录页面 request.setAttribute("tip", "您还没有登录"); request.getRequestDispatcher(loginPage).forward(request, response); } // "放行"请求 else { chain.doFilter(request, response); } } }当然也可以使用web.xml文件中配置该Filter,如下:
<!-- 定义Filter --> <filter> <!-- Filter的名字 --> <filter-name>authority</filter-name> <!-- Filter的实现类 --> <filter-class>lee.AuthorityFilter</filter-class> <!-- 下面两个init-param元素配置了两个参数 --> <init-param> <param-name>encoding</param-name> <param-value>GBK</param-value> </init-param> <init-param> <param-name>loginPage</param-name> <param-value>/login.jsp</param-value> </init-param> </filter> <!-- 定义Filter拦截的URL地址 --> <filter-mapping> <!-- Filter的名字 --> <filter-name>authority</filter-name> <!-- Filter负责拦截的URL --> <url-pattern>/*</url-pattern> </filter-mapping>login.jsp(可以写几个其它页面,以作测试)
<body> <h2>登录页面</h2> <% if (request.getAttribute("tip") != null) { out.println("<font color='red'>" + request.getAttribute("tip") + "</font>"); } %> <form method="post" action="proLogin.jsp"> 用户名:<input type="text" name="name" /><br /> <input type="submit" value="登录" /> </form> </body>实现的效果是,如果没有的登录,则只能访问/login.jsp,反之则可以自由访问其他页面。
四、使用URL Rewrite实现网站伪静态
大部分搜索引擎都会优先考虑收录静态的HTML页面,而不是这种动态的*.jsp、*.php页面。但实际上绝大多数网站都是动态的,不可能全部是静态的HTML页面,因此互联网上的大部分网站都会考虑使用伪静态——就是*.jsp、*.php这种动态URL伪装成静态的HTML页面。对于Java Web应用来说,要实现伪静态非常简单:可以通过Filter拦截所有发向*.html请求,然后按某种规则将请求forward到实际的*.jsp页面即可。现有的URL Rewrite开源项目为这种思路提供了实现,使用URL Rewrite实现网站伪静态也很简单。
4.1 利用URL Rewrite实现网站伪静态
<1> 下载URL Rewrite jar包<2> 添加urlrewritefilter-4.0.3.jar 到 WEB-INF/lib目录下,或者添加Maven依赖如下:
<dependency> <groupId>org.tuckey</groupId> <artifactId>urlrewritefilter</artifactId> <version>4.0.3</version> </dependency><3> 在web.xml文件中配置启用URL Rewrite Filter,在web.xml文件中添加如下配置:
<filter> <filter-name>UrlRewriteFilter</filter-name> <filter-class>org.tuckey.web.filters.urlrewrite.UrlRewriteFilter</filter-class> </filter> <filter-mapping> <filter-name>UrlRewriteFilter</filter-name> <url-pattern>/*</url-pattern> <dispatcher>REQUEST</dispatcher> <dispatcher>FORWARD</dispatcher> </filter-mapping>注意:需要在所有的servlet mappings的上面。
<4> 在应用的WEB-INF路径下增加urlrewrite.xml文件,该文件定义了伪静态映射规则,这份伪静态规则是基于正则表达式。
添加响应的urlrewrite.xml伪静态规则文件如下:
<?xml version="1.0" encoding="GBK"?> <!DOCTYPE urlrewrite PUBLIC "-//tuckey.org//DTD UrlRewrite 3.2//EN" "http://tuckey.org/res/dtds/urlrewrite3.2.dtd"> <urlrewrite> <rule> <!-- 所有配置如下正则表达式的请求 --> <from>/userinf-(\w*).html</from> <!-- 将被forward到如下JSP页面,其中$1代表 上面第一个正则表达式所匹配的字符串 --> <to type="forward">/userinf.jsp?username=$1</to> </rule> </urlrewrite>上面的规则文件中只定义了一个简单的规则:所有发向/userinf-(\w*).html的请求都将被forward到userinf.jsp,并将(\w*)正则表达式所匹配的内容作为username参数值。根据这个伪静态规则,需要为该应用提供了一个userinf.jsp页面,该页面只是一个模拟了一个显示用户信息的页面,页面代码如下:
<%@ page contentType="text/html; charset=GBK" language="java" errorPage=""%> <% // 获取请求参数 String user = request.getParameter("username"); %> <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html xmlns="http://www.w3.org/1999/xhtml"> <head> <title><%=user%>的个人信息</title> <meta name="website" content="http://www.crazyit.org" /> </head> <body> <% // 此处应该通过数据库读取该用户对应的信息 // 此处只是模拟,因此简单输出: out.println("现在时间是:" + new java.util.Date() + "<br/>"); out.println("用户名:" + user); %> </body> </html>
五、Listener介绍
Servlet API提供了大量监听器来监听Web项目的内部事件,从而允许当Web内部事件发生时回调事件监听器内的方法。使用Listener只需要两个步骤:定义Listener实现类
通过注解或web.xml文件中配置Listener
5.1 实现Listener类
常用的Web事件监听器接口有如下几个:ServletContextListener:用于监听Web应用的启动和关闭
ServletContextAttributeListener:用于监听ServletContext范围(application)内属性的改变
ServletRequestListener:用于监听用户请求
ServletRequestAttributeListener:用于监听ServletRequest范围(request)内属性的改变
HttpSessionListener:用于监听用户session的开始和结束
HttpSessionAttributeListener:用于监听HttpSession范围(session)内属性的改变
5.2 配置Listener
配置Listener只要向Web应用注册Listener实现类即可,无须配置参数之类的东西,因此十分简单。为Web应用配置Listener也有两种方式:使用@WebListener修饰Listener实现类即可
在web.xml文档中使用<listener../>元素进行配置
使用@WebListener时通常无须指定任何属性,只要使用该注解修饰Listener实现类即可向Web应用注册该监听器。在web.xml中使用<listener../>元素进行配置时只要配置如下子元素即可。
listener-class:指定Listener实现类
5.3 使用ServletContextListener
ServletContextListener 用于监听Web应用的启动和关闭,该接口包含如下两个方法:contextInitialized(ServletContextEvent sce):启动Web应用时,系统调用Listener的该方法
contextDestroyed(ServletContextEvent sce):关闭Web应用时,系统调用Listener的该方法
示例:
@WebListener public class GetConnListener implements ServletContextListener { // 应该启动时,该方法被调用。 public void contextInitialized(ServletContextEvent sce) { try { // 取得该应用的ServletContext实例 ServletContext application = sce.getServletContext(); // 从配置参数中获取驱动 String driver = application.getInitParameter("driver"); // 从配置参数中获取数据库url String url = application.getInitParameter("url"); // 从配置参数中获取用户名 String user = application.getInitParameter("user"); // 从配置参数中获取密码 String pass = application.getInitParameter("pass"); // 注册驱动 Class.forName(driver); // 获取数据库连接 Connection conn = DriverManager.getConnection(url, user, pass); // 将数据库连接设置成application范围内的属性 application.setAttribute("conn", conn); } catch (Exception ex) { System.out.println("Listener中获取数据库连接出现异常" + ex.getMessage()); } } // 应该关闭时,该方法被调用。 public void contextDestroyed(ServletContextEvent sce) { // 取得该应用的ServletContext实例 ServletContext application = sce.getServletContext(); Connection conn = (Connection) application.getAttribute("conn"); // 关闭数据库连接 if (conn != null) { try { conn.close(); } catch (SQLException ex) { ex.printStackTrace(); } } } }需要在web.xml文件中配置连接数据库的几个参数:
<!-- 配置第一个参数:driver --> <context-param> <param-name>driver</param-name> <param-value>com.mysql.jdbc.Driver</param-value> </context-param> <!-- 配置第二个参数:url --> <context-param> <param-name>url</param-name> <param-value>jdbc:mysql://localhost:3306/ceshi</param-value> </context-param> <!-- 配置第三个参数:user --> <context-param> <param-name>user</param-name> <param-value>root</param-value> </context-param> <!-- 配置第四个参数:pass --> <context-param> <param-name>pass</param-name> <param-value>root</param-value> </context-param> <listener> <!-- 指定Listener的实现类(配置注解就不需要了) --> <listener-class>lee.GetConnListener</listener-class> </listener>
5.4 使用ServletContextAttributeListener
ServletContextAttributeListener用于监听ServletContext(application)范围内属性的变化,实现该接口的监听器需要实现如下三个方法:attributeAdded(ServletContextAttributeEvent event):当程序把一个属性存入application范围时触发该方法
attributeRemoved(ServletContextAttributeEvent event):当程序把一个属性从application范围删除时触发该方法
attributeReplaced(ServletContextAttributeEvent event):当程序替换application范围内的属性时将触发该方法
示例:
@WebListener public class MyServletContextAttributeListener implements ServletContextAttributeListener { // 当程序向application范围添加属性时触发该方法 public void attributeAdded(ServletContextAttributeEvent event) { ServletContext application = event.getServletContext(); // 获取添加的属性名和属性值 String name = event.getName(); Object value = event.getValue(); System.out.println(application + "范围内添加了名为" + name + ",值为" + value + "的属性!"); } // 当程序从application范围删除属性时触发该方法 public void attributeRemoved(ServletContextAttributeEvent event) { ServletContext application = event.getServletContext(); // 获取被删除的属性名和属性值 String name = event.getName(); Object value = event.getValue(); System.out.println(application + "范围内名为" + name + ",值为" + value + "的属性被删除了!"); } // 当application范围的属性被替换时触发该方法 public void attributeReplaced(ServletContextAttributeEvent event) { ServletContext application = event.getServletContext(); // 获取被替换的属性名和属性值 String name = event.getName(); Object value = event.getValue(); System.out.println(application + "范围内名为" + name + ",值为" + value + "的属性被替换了!"); } }
5.5 使用ServletRequestListener和ServletRequestAttributeListener
ServletRequestListener用于监听用户请求的到达,实现该接口的监听器需要实现如下两个方法:requestInitialized(ServletRequestEvent sre):用户请求到达、被初始化时触发该方法
requestDestroyed(ServletRequestEvent sre):用户请求结束、被销毁时触发该方法
ServletRequestAttributeListener则用于监听ServletRequest(request)范围内属性的变化,实现该接口的监听器需要实现attributeAdded()、attributeRemoved()、attributeReplaced()三个方法。ServletRequestAttributeListener与ServletContextAttributeListener的作用相似,都用于监听属性的改变,只是ServletRequestAttributeListener监听request范围内属性的改变。
@WebListener public class RequestListener implements ServletRequestListener, ServletRequestAttributeListener { // 当用户请求到达、被初始化时触发该方法 public void requestInitialized(ServletRequestEvent sre) { HttpServletRequest request = (HttpServletRequest) sre.getServletRequest(); System.out.println("----发向" + request.getRequestURI() + "请求被初始化----"); } // 当用户请求结束、被销毁时触发该方法 public void requestDestroyed(ServletRequestEvent sre) { HttpServletRequest request = (HttpServletRequest) sre.getServletRequest(); System.out.println("----发向" + request.getRequestURI() + "请求被销毁----"); } // 当程序向request范围添加属性时触发该方法 public void attributeAdded(ServletRequestAttributeEvent event) { ServletRequest request = event.getServletRequest(); // 获取添加的属性名和属性值 String name = event.getName(); Object value = event.getValue(); System.out.println(request + "范围内添加了名为" + name + ",值为" + value + "的属性!"); } // 当程序从request范围删除属性时触发该方法 public void attributeRemoved(ServletRequestAttributeEvent event) { ServletRequest request = event.getServletRequest(); // 获取被删除的属性名和属性值 String name = event.getName(); Object value = event.getValue(); System.out.println(request + "范围内名为" + name + ",值为" + value + "的属性被删除了!"); } // 当request范围的属性被替换时触发该方法 public void attributeReplaced(ServletRequestAttributeEvent event) { ServletRequest request = event.getServletRequest(); // 获取被替换的属性名和属性值 String name = event.getName(); Object value = event.getValue(); System.out.println(request + "范围内名为" + name + ",值为" + value + "的属性被替换了!"); } }
5.6 使用HttpSessionListener 和HttpSessionAttributeListener
HttpSessionListener 用于监听用户session的创建和销毁,实现该接口的监听器需要实现如下两个方法:sessionCreated(HttpSessionEvent se)
sessionDestroyed(HttpSessionEvent se)
示例:
@WebListener public class OnlineListener implements HttpSessionListener { // 当用户与服务器之间开始session时触发该方法 public void sessionCreated(HttpSessionEvent se) { HttpSession session = se.getSession(); ServletContext application = session.getServletContext(); // 获取session ID String sessionId = session.getId(); // 如果是一次新的会话 if (session.isNew()) { String user = (String) session.getAttribute("user"); // 未登录用户当游客处理 user = (user == null) ? "游客" : user; Map<String, String> online = (Map<String, String>) application.getAttribute("online"); if (online == null) { online = new Hashtable<String, String>(); } // 将用户在线信息放入Map中 online.put(sessionId, user); application.setAttribute("online", online); } } // 当用户与服务器之间session断开时触发该方法 public void sessionDestroyed(HttpSessionEvent se) { HttpSession session = se.getSession(); ServletContext application = session.getServletContext(); String sessionId = session.getId(); Map<String, String> online = (Map<String, String>) application.getAttribute("online"); if (online != null) { // 删除该用户的在线信息 online.remove(sessionId); } application.setAttribute("online", online); } }
六、JSP2特性
JSP2主要增加了如下新特性:直接配置JSP属性
表达式语言
简化的自定义标签API
Tag文件语法
如果需要使用JSP2语法,其web.xml文件必须使用Servlet2.4以上版本的配置文件。Servlet2.4配置文件的根元素写法如下:
<web-app xmlns="http://java.sun.com/xml/ns/j2ee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd" version="2.4"> </web-app>我在写博客的时候常用的是Servlet3.1,其根元素写法可参考:web.xml部署描述符的例子
6.1 配置JSP属性
JSP属性定义使用<jsp-property-group/>元素配置,主要包括如下4个方面:是否允许使用表达式语言:使用<el-ignored/>元素确定,默认值为false,即允许使用表达式语言
是否允许使用JSP脚本:使用<scripting-invalid/>元素确定,默认值为false,即允许使用JSP脚本
声明JSP页面的编码:使用<page-encoding/>元素确定,配置该元素后,可以代替每个页面里page指令contentType属性的charset部分
使用隐士包含:使用<include-prelude/>和<include-coda/>元素确定,可以代替在每个页面里使用include编译指令来包含其他页面
注:此处隐式包含的作用与JSP提供的静态包含的作用相似。
6.2 表达式语言&Tag File
表达式语言:可参考《EL表达式—学习笔记》Tag File支持:可参考《标准标签库JSTL——学习笔记》
6.3 Servlet3.0新特性
6.3.1 Servlet3.0的注解
Servlet3.0规范在javax.servlet.annotation包下提供了如下注解:@WebServlet:用于修饰一个Servlet雷,用于部署Servlet类
@WebInitParam:用于与@WebServlet或@WebFilter一起使用,为Servlet、Filter配置参数
@WebListener:用于修饰Listener类,用于部署Listener类
@WebFilter:用于修饰Filter类,用于部署Filter类
@MultipartConfig:用于修饰Servlet,指定该Servlet将会负责处理multipart/form-data类型的请求(主要用于文件上传)
@ServletSecurity:这是一个与JAAS有关的注解,修饰Servlet指定该Servlet的安全与授权控制
@HttpConstraint:用于与@ServletSecurity一起使用,用于指定该Servlet的安全与授权控制
@HttpMethodConstraint:用于与@ServletSecurity一起使用,用于指定该Servlet的安全与授权控制
6.3.2 Servlet 3.0 的Web模块支持
Servlet 3.0为模块化开发提供了良好的支持,Servlet 3.0规范不再要求所有Web组件(如Servlet、Listener、Filter)都部署在web.xml文件中,而是允许采用“Web模块”来部署、管理它们。一个Web模块通常对应于一个JAR包,这个JAR包有如下文件结构:
从上面的文件结构可以看出,Web模块与普通JAR的最大区别在于需要在META-INF目录下添加一个Web-fragment.xml文件,这个文件也被称为Web模块部署描述符。
web-fragment.xml文件与web.xml文件的作用、文件结构都基本相似,因为它们都用于部署、管理各种Web组件。只是web-fragment.xml用于部署、管理Web模块而已,但web-fragment.xml可以指定多个下面的两个元素:
<name.../>:用于指定该模块的名称
<ordering.../>:用于指定加载该Web模块的相对顺序
Web应用除了可按web-fragment.xml文件中指定的加载顺序来加载Web模块之外,还可以通过web.xml文件指定个Web模块加载的绝对顺序。在web.xml文件中指定的加载顺序将会覆盖Web模块中web-fragment.xml文件所指定的加载顺序。
假如在Web应用的web.xml文件中增加如下配置片段:
<absolute-ordering> <!-- 指定Web模块按如下顺序加载 --> <name>moudle-name</name> <name>moudle-name</name> </absolute-ordering>Servlet 3.0的Web模块支持为模块化开发、框架使用提供了巨大的方便,例如需要在Web应用中使用Web框架,这就只要将该框架的JAR包复制到Web应用中即可。因为这个JAR包的META-INF目录下可以通过web-fragment.xml文件来配置该框架所需要的Servlet、Listener、Filter等,从而避免修改Web应用的web.xml文件。Web模块支持对于模块化开发也有很大的帮助,开发者可以将不同模块的Web组件部署在不同的web-fragment.xml文件中,从而避免所有模块的配置、部署信息都写在web.xml文件中,这对以后的升级、维护将更加方便。
6.3.3 Servlet3.0提供的异步处理
在之前的Servlet规范中,如果Servlet作为控制器调用一个耗时的业务方法,nameServlet必须等到业务方法完全返回之后才会生成响应,这将使得Servlet对业务方法的调用变成一种阻塞式的调用,因此效率比较低。Servlet 3.0规范引入了异步处理来解决这个问题,异步处理允许Servlet重新发起一条新线程去调用耗时的业务方法,这样就可避免等待。
Servlet 3.0的异步处理是通过AsyncContext类来处理的,Servlet可通过ServletRequest的如下连个方法开启异步调用、创建AsyncContext对象:
AsyncContext startAsync()
AsyncContext startAsync(ServletRequest,ServletResponse)
重复调用上面的方法将得到同一个AsyncContext对象,AsyncContext对象代表异步处理的上下文,它提供了一些工具方法,可完成设置异步调用的超时时长,dispatch用于请求、启动后台线程、获取request、response对象等功能。
示例:
创建异步处理的Servlet类:
@WebServlet(urlPatterns = "/async", asyncSupported = true) public class AsyncServlet extends HttpServlet { private static final long serialVersionUID = 1L; @Override public void doGet(HttpServletRequest request, HttpServletResponse response) throws IOException, ServletException { response.setContentType("text/html;charset=GBK"); PrintWriter out = response.getWriter(); out.println("<title>异步调用示例</title>"); out.println("进入Servlet的时间:" + new java.util.Date() + ".<br/>"); // 创建AsyncContext,开始异步调用 AsyncContext actx = request.startAsync(); // 设置异步调用的超时时长 actx.setTimeout(60 * 1000); // 启动异步调用的线程,该线程以异步方式执行 actx.start(new GetBooksTarget(actx)); out.println("结束Servlet的时间:" + new java.util.Date() + ".<br/>"); out.flush(); } }下面创建线程执行体代码:
public class GetBooksTarget implements Runnable { private AsyncContext actx = null; public GetBooksTarget(AsyncContext actx) { this.actx = actx; } public void run() { try { // 等待5秒钟,以模拟业务方法的执行 Thread.sleep(5 * 1000); ServletRequest request = actx.getRequest(); List<String> books = new ArrayList<String>(); books.add("疯狂Java讲义"); books.add("轻量级Java EE企业应用实战"); books.add("疯狂Ajax讲义"); request.setAttribute("books", books); actx.dispatch("/async.jsp"); } catch (Exception e) { e.printStackTrace(); } } }该线程体让线程暂停5秒来模拟调用耗时的业务方法,最后调用AsyncContext的dispatch方法把请求dispatch到指定JSP页面。
被异步请求dispatch的目标页面需要指定session=“false”,表明该页面不会重新创建session。下面是async.jsp页面代码:
<%@ page contentType="text/html; charset=GBK" language="java" session="false" isELIgnored="false"%> <%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%> <ul> <c:forEach items="${books}" var="book"> <li>${book}</li> </c:forEach> </ul> <% out.println("业务调用结束的时间:" + new java.util.Date()); if (request.isAsyncStarted()) { // 完成异步调用 request.getAsyncContext().complete(); } %>上面使用注解的方式已经配置好,如果要使用web.xml配置,则需要如下配置:
<servlet> <servlet-name>async</servlet-name> <servlet-class>lee.AsyncServlet</servlet-class> <async-supported>true</async-supported> </servlet> <servlet-mapping> <servlet-name>async</servlet-name> <url-pattern>/async</url-pattern> </servlet-mapping>对于支持异步调用的Servlet来说,当Servlet以异步方式启用新线程之后,该Servlet的执行不会被阻塞,该Servlet将可以向客户端浏览器生成响应——当新线程执行完成后,新线程生成的响应再次被送往客户端浏览器。
输出如下:
当Servlet启用异步调用的线程之后,该线程的执行过程对开发者是透明的。但在有些情况下,开发者需要了解该异步线程的执行细节,并针对特定的执行结果进行针对性处理,这可借助于Servlet3.0提供的异步监听器来实现。
异步监听器需要实现AsyncListener接口,实现该接口的监听器类需要实现如下4个方法:
onStartAsync(AsyncEvent event):当异步调用开始时触发该方法
onComplete(AsyncEvent event):当异步调用完成时触发该方法
onError(AsyncEvent event):当异步调用错误时触发该方法
onTimeout(AsyncEvent event):当异步调用超时时触发该方法
设计好异步监听器之后,需要通过AsyncContext来注册监听器,调用该对象的addListener()方法即可注册监听器。
Filter与Servlet具有很大的相似性,因此Servlet3.0规范支持在Filter中使用异步调用。在Filter中进行异步调用与在Servlet中进行异步调用的效果完全相似,因此不进行叙述。
6.3.4 改进的Servlet API
重大的改进包括:HttpServletRequest增加了对文件上传的支持
ServletContext允许通过编程的方式动态注册Servlet、Filter
HttpServletRequest提供了如下两个方法来处理文件上传:
Part getPart(String name):根据名称来获取文件上传域
Collection<Part> getParts():获取所有的文件上传域
上面两个方法的返回值都涉及一个API:Part,每个Part对象对应于一个文件上传域,该对象提供了大量方法来访问上传文件的文件类型、大小、输入流等,并提供了一个write(String file)方法将上传文件写入服务器磁盘。
为了向服务器上传文件,需要在表单里使用<input type="file" ../>文件域,这个文件域会在HTML页面上产生一个单行文本框和一个“浏览”按钮,浏览者可通过该按钮选择需要上传的文件。除此之外,上传文件一定要为表单域设置enctype属性。
表单的enctype属性指定的是表单数据的编码方式,该属性有如下三个值:
application/x-www-form-urlencoded:这是默认的编码,它只处理表单域里的value属性值,采用这种编码方式的表单会将表单域的值处理成URL编码方式
multipart/form-data:这种编码方式会以二进制流的方式来处理表单数据,这种编码方式会把文件域指定文件的内容封装到请求参数里
text/plain:这种编码方式当表单的action属性为mailto:URL的形式时比较方便,这种方式主要适用于直接通过表单发送邮件的形式
如果将enctype设置为application/x-www-form-urlencoded,或不设置enctype属性,提交表单时只会发送文件域的文本框里的字符串,也就是浏览者所选择文件的绝对路径,对服务器获取该文件在客户端上的绝对路径没有任何作用,因为服务器不可能访问客户机的文件系统。
示例如下:
创建上传页面upload.jsp
<form method="post" action="upload" enctype="multipart/form-data"> 文件名:<input type="text" id="name" name="name" /><br/> 选择文件:<input type="file" id="file" name="file" /><br/> <input type="submit" value="上传" /><br/> </form>上面的页面中的表单需要设置enctype=“multipart/form-data”,这表明该表单可用于上传文件。上面表单中定义了两个表单域:一个普通的文本框,它将生成普通请求参数;一个文件上传域,它用于上传文件。对于传统的文件上传需要借助于common-fileupload等工具,处理起来极为复杂,借助于Servlet 3.0的API,处理文件上传将变得十分简单。如下面的Servlet代码:
@WebServlet(name = "upload", urlPatterns = { "/upload" }) @MultipartConfig public class UploadServlet extends HttpServlet { private static final long serialVersionUID = 1L; public void service(HttpServletRequest request, HttpServletResponse response) throws IOException, ServletException { response.setContentType("text/html;charset=GBK"); PrintWriter out = response.getWriter(); request.setCharacterEncoding("GBK"); // 获取普通请求参数 String name = request.getParameter("name"); out.println("普通的name参数为:" + name + "<br/>"); // 获取文件上传域 Part part = request.getPart("file"); // 获取上传文件的文件类型 out.println("上传文件的的类型为:" + part.getContentType() + "<br/>"); // 获取上传文件的大小。 out.println("上传文件的的大小为:" + part.getSize() + "<br/>"); // 获取该文件上传域的Header Name Collection<String> headerNames = part.getHeaderNames(); // 遍历文件上传域的Header Name、Value for (String headerName : headerNames) { out.println(headerName + "--->" + part.getHeader(headerName) + "<br/>"); } // 获取包含原始文件名的字符串 String fileNameInfo = part.getHeader("content-disposition"); // 提取上传文件的原始文件名 String fileName = fileNameInfo.substring(fileNameInfo.indexOf("filename=\"") + 10, fileNameInfo.length() - 1); // 将上传的文件写入服务器 part.write(getServletContext().getRealPath("/uploadFiles") + "/" + fileName); // ① } }上面Servlet使用了@MultipartConfig修饰,处理文件上传的Servlet应该使用该注解修饰。接下来该Servlet中HttpServletRequest就可通过getPart(String name)方法来获取文件上传域——就像获取普通请求参数一样。
注:上面的Servlet中将会把上传的文件保存到Web应用的根路径下的uploadFiles目录下,因此我们还需要在该Web应用的根目录下创建uploadFiles目录。
上面Servlet上传时保存的文件名直接使用了上传文件的原始文件名,在实际项目中一般不会这么做,因为可能多个用户可能上传同名的文件,这样将导致后面用户上传的文件覆盖前面用户上传的文件。在实际项目中可借助于java.util.UUID工具类生成文件名。
ServletContext则提供了如下方法来动态地注册Servlet、Filter,并允许动态设置Web应用的初始化参数:
多个重载的addServlet()方法:动态地注册Servlet
多个重载的addFilter()方法:动态地注册Filter
多个重载的addListener():动态地注册Listener
setInitParameter(String name,String value)方法:为Web应用设置初始化参数
6.4 Servlet 3.1 新增的非阻塞式IO
Servlet 3.1提供的非阻塞IO进行输入、输出,可以更好地提升性能:ServletInputStream:Servlet用于读取数据的输入流
ServletOutputStream:Servlet用于输出数据的输出流
传统读取方式采用阻塞式IO——当Servlet读取浏览器提交的数据时,如果数据暂时不可用,或数据没有读取完成,Servlet当前所在线程将会被阻塞,无法继续向下执行。
从Servlet 3.1 开始,ServletInputStream新增了一个setReadListener(ReadListener readListener)方法,该方法允许以非阻塞IO读取数据,实现ReadListener监听器需要实现如下三个方法:
onAllDataRead():当所有数据读取完成时激发该方法
onDataAvailable():当有数据可用时激发该方法
onError(Throwable t):读取数据出现错误时激发该方法
类似地ServletOutputStream也提供了SetWriterListener()方法。
在Servlet中使用费阻塞IO非常简单,主要按如下步骤进行即可:
调用ServletRequest的startAsync()方法开启异步模式
通过ServletRequest获取ServletInputStream,并为ServletInputStream设置监听器(ReadListener实现类)
实现ReadListener接口来实现监听器,在该监听器的方法中以非阻塞方式读取数据。
示例如下:
创建Servlet类
@WebServlet(urlPatterns = "/async", asyncSupported = true) public class AsyncServlet extends HttpServlet { private static final long serialVersionUID = 1L; public void service(HttpServletRequest request, HttpServletResponse response) throws IOException, ServletException { response.setContentType("text/html;charset=GBK"); PrintWriter out = response.getWriter(); out.println("<title>非阻塞IO示例</title>"); out.println("进入Servlet的时间:" + new java.util.Date() + ".<br/>"); // 创建AsyncContext,开始异步调用 AsyncContext context = request.startAsync(); // 设置异步调用的超时时长 context.setTimeout(60 * 1000); ServletInputStream input = request.getInputStream(); // 为输入流注册监听器 input.setReadListener(new MyReadListener(input, context)); out.println("结束Servlet的时间:" + new java.util.Date() + ".<br/>"); out.flush(); } }创建实现ReadListener接口的类
public class MyReadListener implements ReadListener { private ServletInputStream input; private AsyncContext context; public MyReadListener(ServletInputStream input, AsyncContext context) { this.input = input; this.context = context; } @Override public void onDataAvailable() { System.out.println("数据可用!!"); try { // 暂停5秒,模拟读取数据是一个耗时操作。 Thread.sleep(5000); StringBuilder sb = new StringBuilder(); int len = -1; byte[] buff = new byte[1024]; // 采用原始IO方式读取浏览器向Servlet提交的数据 while (input.isReady() && (len = input.read(buff)) > 0) { String data = new String(buff, 0, len); sb.append(data); } System.out.println(sb); // 将数据设置为request范围的属性 context.getRequest().setAttribute("info", sb.toString()); // 转发到视图页面 context.dispatch("/async.jsp"); } catch (Exception ex) { ex.printStackTrace(); } } @Override public void onAllDataRead() { System.out.println("数据读取完成"); } @Override public void onError(Throwable t) { t.printStackTrace(); } }下面创建页面:
form.html
<form action="async" method="post"> 用户名:<input type="text" name="name"/><br/> 密码:<input type="text" name="pass"/><br/> <input type="submit" value="提交"> <input type="reset" value="重设"> </form>async.jsp
<%@ page contentType="text/html; charset=GBK" language="java" session="false"%> <div style="background-color: #ffffdd; height: 80px;"> 浏览器提交数据为:${info}<br /> <%=new java.util.Date()%> </div>
6.5 Tomcat 8的WebSock支持(暂未完成)
最后修改时间:2017年3月29日16:20:40
********************************************************************************结束语********************************************************************************************
我在写这篇博客的时候也是一名初学者,有任何疑问或问题请留言,或发邮件也可以,邮箱为:fanxiaobin.fxb@qq.com,我会尽早的进行更正及更改。
在我写过的博客中有两篇博客是对资源的整理,可能对大家都有帮助,大家有兴趣的话可以看看!!
下载资料整理——目录:http://blog.csdn.net/fanxiaobin577328725/article/details/51894331
这篇博客里面是我关于我见到的感觉不错的好资源的整理,里面包含了书籍及源代码以及个人搜索的一些资源,如果有兴趣的可以看看,我会一直对其进行更新和添加。
优秀的文章&优秀的学习网站之收集手册:http://blog.csdn.net/fanxiaobin577328725/article/details/52753638
这篇博客里面是我对于我读过的,并且感觉有意义的文章的收集整理,纯粹的个人爱好,大家感觉有兴趣的可以阅读一下,我也会时常的对其进行更新。
********************************************************************************感谢********************************************************************************************
相关文章推荐
- JSP&Servlet学习笔记-第六章:使用JSP
- Jsp&Servelet 学习笔记-对一个Servlet创建多个Mapping
- JSP&&SERVLET学习笔记(四):关于HttpServletRequest
- JSP&&SERVLET学习笔记(三):URL模式设置
- Servlet&JSP学习笔记--导航
- Jsp&Servelet 学习笔记- 在tomcat上部署一个单独的servlet的程序(Ant)
- JSP&&SERVLET学习笔记(七):Servlet处理上传的文件
- JSP&Servlet学习笔记(一)
- Servlet&JSP学习笔记:什么是Web容器
- [学习笔记]马士兵 Servlet & JSP(1.Servlet)
- Jsp&Servelet 学习笔记- 在Tomcat中的servlet.xml使用Context元素
- jsp&servlet学习笔记
- Jsp&Servelet 学习笔记-映射静态的内容到一个servlet中
- Head First Servlet&Jsp 学习笔记(一) 一些基础知识
- JSP&Servlet学习笔记-第三章:请求与响应
- Jsp&Servelet 学习笔记- 映射一个Servlet实名到web.xml中
- Jsp&Servelet 学习笔记-对一个Servlet创建多个Mapping
- JSP&&SERVLET学习笔记(一):HelloServlet
- Jsp&servlet学习笔记
- Servlet&JSP学习笔记:Web应用程序基础知识