HTTP协议：
HTTP 就是一个很好的无状态协议的示例，它建立在客户机-服务器请求和响应的基础之上。在 HTTP 中，不会为下一次请求维护这次请求中客户机-服务器间交互的信息。每次请求
都是独立的，可以这么说,每次单击就是一次请求，在HTTP/1.1中，允许用户发送一个请求之后，在服务器未响应这个请求之前，又可以发送一个请求到这个服务器，这次请求与上
一次的那次请求是独立的，在服务器响应请求时，会根据发送的请求顺序依次响应请求，
请求：
一次http请求：客户端请求与服务器建立连接，连接建立之后，客户端发送请求到服务器端，服务器端响应信息给客户端，响应完毕之后，服务器与客户端的连接关闭
url：用来定位客户端要访问的服务器端的资源，比如：http://www.hao123.com/index.jsp就表示客户端要访问www.hao123.com服务器上index.jsp这个资源
使用GET和post方式传递参数：
GET方式：
GET /servlet/ParamsServlet?username=zhanghua&status=1 HTTP/1.1 //请求行
Host： //请求头
Content-Type:application/x-www-form-urlencoded //请求头
Content_length:28 //请求头
GET方式传递参数是以查询字符串的形式传递的，不需要传输请求消息实体本身(参数紧跟浏览器地址栏的URL后面)
请求头(关于请求和客户端自己的额外信息，提供了服务器在处理请求的过程中可能需要的附加信息)
GET方式特点：传送的数据量是有限的，一般限制在1KB以下；通常，如果你在浏览器的地址栏中键入了一个url，或者单击了一个超级链接，那么你的请求将作为一个GET请求发送
给服务器
POST方式：参数信息是以请求消息的实体内容传递的
POST /servlet/ParamsServlet HTTP/1.1 //请求行
Host： //请求头
Content-Type:application/x-www-form-urlencoded //请求头
Content_length:28 //请求头
空行
param1=xyz¶m2=abc //请求消息实体
POST方式特点：数据量没有限制
应答：
http/1.0 200 ok //应答行
last_Modified: Mon, 20 Dec 2001 23:26:42 GMT //应答头
Date:Tue,11 Jan 2002 20:52:40 GMT //应答头
status:200 //应答头
Content-Type:text/html //应答头
Servlet-Engine:Tomcat Web Server/4.0.1 //应答头
Content-Length:59 //应答头
空行 //空行
<html>
<body>Hello World!</body> //应答消息实体
</html>
---------------------------------------------------------------------------------------------------------
一个web应用中必须包含一个WEB-INF目录(这个里面的文件是用户无法访问的，是给Tomcat用的)并且在这个目录下，应该有一个web.xml文件(web应用的描述文件)和classes目录和
lib目录；对于一个WEB应用来说，我的类文件放在哪里，服务器才能够找到它们了?如果类文件被打包成JAR文件，就把JAR文件放在Lib目录下，否则存储在classes目录下(各个子
目录对应类的包结构)，服务器通常会去这两个目录下去寻找JAVA类文件；还有，如果你的web应用发布之后，你可以将所有使用到的第三方jar包拷贝到%tomcat_home%/common/lib
目录下
tomcat:
bin:存放启动和关闭Tomcat的命令的路径
common：存放所有的web应用都需要的类库
conf：存放tomcat的配置，所有的tomcat配置都在该路径下设置
log：该路径用于保存tomcat每次运行后产生的日志文件
server：存放tomcat运行所需要的基础类库，该路径是tomcat运行的基础。该路径下包含一个webapps目录，并存放tomcat两个控制台
shared：用于系统共享的类库，该路径下包含classes和lib两个路径
temp：保存web应用运行时生成的临时文件
webapps：该路径用于部署web应用，将web应用复制到该路径下，tomcat会将该应用自动部署在web容器中
work：保存web应用运行过程中编译生成的class文件。当用户手动删除该目录后，每次web应用启动时会自动建立该路径
tomcat的运行需要一个环境变量：java_home(即jdk的安装目录)
验证tomcat的安装：启动tomcat服务器之后，打开浏览器，在地址栏输入http://localhost:8080,如果看到Apache Tomcat的欢迎页面，表示tomcat服务器安装ok
tomcat的基本配置：tomcat作为一个web服务器，默认的端口号是8080，但是该端口号完全可以由用户自己控制。
修改tomcat的端口号：打开tomcat安装目录下的conf目录会看到一个server.xml文件，该文件描述了tomcat服务器的一些配置信息。用记事本打开server.xml文件，找到
<Connector port="8080" .... />,用户可以自行修改该端口号，但是为了避免与公共端口号冲突，建议使用1024以上的端口号
tomcat的控制台：
在apache tomcat的欢迎页面会看到tomcat administrator和tomcat manager两个超级链接，这两个超级链接分别是：
administrator控制台：需要admin角色才可以登陆
manager控制台：需要manager角色才可以登陆
在tomcat安装目录下的conf目录会看到一个tomcat-users.xml文件，该文件配置了tomcat用户和角色，系统的配置文件中默认提供了3个用户，但是这3个用户没有一个是admin角色
，也没有一个属于manager角色，用户可以自行添加manager和admin用户，配置相应的控制台登陆了用户名和密码
在administrator控制台中，用户可以通过该控制台配置数据源，邮件session以及tomcat用户，在manager控制台中，用户可以看到部署在该服务器下的所有web应用
部署web应用：
1.使用控制台部署：进入manager控制台，配置相应的Context 元素的信息
2.利用tomcat的自动部署：在tomcat安装目录下的webapps目录下新建一个web应用目录，在该目录下包含一个web-inf文件，并且在web-inf目录下建立一个web.xml文件，或者直
接将现有的web应用复制到webapps目录下，tomcat会自动部署
3.修改server.xml文件进行部署：在servlet.xml文件中<host></host>标签以内，配置一个<Context />元素，比如：<Context path="/test" docBase="d:/firstapp">,其中path
属性是指映射到服务器上的路径，docBase属性是指本地磁盘上的路径(其中，firstapp是一个web应用工程)
4.增加用户的web部署文件：用户可以自行建立一个context.xml文件，然后在server.xml文件中引用
tomcat的数据源配置：
全局数据源的配置和局部数据源的配置:
无论哪一种数据源都必须提供数据源实现的jar文件，还有数据库驱动。将以上所需的jar文件复制到tomcat安装目录下的common/lib目录下
局部数据源的配置：无需修改系统的配置文件，而是增加用户自己的配置文件。并且它只与特定的web应用相关。因此只能在特定的web应用的配置文件中配置。为一个特定的web
应用增加局部数据源，修改tomcat的conf/Catalina/localhost路径下的web配置文件即可，完整的配置如下：
<? xml version="1.0" encoding="gb2312" ?>
<!-- 配置一个web应用 -->
<Context path="/test" docBase="e:/firstapp" debug="0" privileged="true">
<!-- 配置一个资源，资源的名称为jdbc/book,类型为DataSource数据源-->
<Resource name="jdbc/book" auth="Container" type="javax.sql.DataSource">
<!--定义资源的参数name属性指定定义那个资源的参数-->
<ResourceParams name="jdbc/book">
<!--定义数据源工厂-->
<parameter>
<name>factory</name>
<value>org.apache.commons.dbcp.BasicDataSourceFactory</value>
</parameter>
<!--定义数据源的最大活动连接数-->
<parameter>
<name>maxActive</name>
<value>100</value>
</parameter>
<!--定义数据源的超时时长，超过该时间，数据源自动断开链接-->
<parameter>
<name>removeAbandonedTimeout</name>
<value>60</value>
</parameter>
<!--定义数据源的最大空闲连接数，一旦容器中空闲的连接数超过该数，系统将自动销毁一些链接-->
<parameter>
<name>maxIdle</name>
<value>30</value>
</parameter>
<!--定义数据源的最大等待数-->
<parameter>
<name>maxWait</name>
<value>1000</value>
</parameter>
<!--定义连接数据源的用户名-->
<parameter>
<name>username</name>
<value>admin</value>
</parameter>
<!--定义连接数据源的密码-->
<parameter>
<name>password</name>
<value>admin</value>
</parameter>
<!--指定连接数据源所使用的数据库驱动-->
<parameter>
<name>driverClassName</name>
<value>com.microsoft.jdbc.sqlserver.SQLServerDriver</value>
</parameter>
<!--指定连接数据库的URL-->
<parameter>
<name>url</name>
<value>jdbc:microsoft:sqlserver://localhost:1433;databaseName=book</value>
</parameter>
</ResourceParams>
</Context>
再次启动tomcat，该web应用就可以通过jndi访问和测试数据源：
//初始化Context，使用InitialContext初始化Contex
Context ctx=new InitialContext();
//通过jndi查找数据源，该jndi分成两个部分，java:comp/env是tomcat固定的，tomcat提供的jndi绑定都必须加该前缀，jdbc/book是定义数据源时的数据源名
DataSource ds=(DataSource)ctx.lookup("java:comp/env/jdbc/book");
Connection con=ds.getConnection();
System.out.println(con);
全局数据源的配置：可以通过Administrtor控制台或者修改server.xml配置文件来实现，而通过Administrtor控制台配置全绝数据源时，所做的修改最总依然会变成对server.xml
文件的修改。所以建议使用直接修改server.xml文件：只需要在server.xml配置文件中找到GlobalNamingResources元素，该元素负责配置所有的全局资源，因此只需要在该元素增
加数据源的配置即可。增加数据源配置的配置片段如下：
<GlobalNamingResources>
.....
<Resource name="jdbc/book" auth="Container" type="javax.sql.DataSource">
<!--定义资源的参数name属性指定定义那个资源的参数-->
<ResourceParams name="jdbc/book">
<!--定义数据源工厂-->
<parameter>
<name>factory</name>
<value>org.apache.commons.dbcp.BasicDataSourceFactory</value>
</parameter>
<!--定义数据源的最大活动连接数-->
<parameter>
<name>maxActive</name>
<value>100</value>
</parameter>
<!--定义数据源的超时时长，超过该时间，数据源自动断开链接-->
<parameter>
<name>removeAbandonedTimeout</name>
<value>60</value>
</parameter>
<!--定义数据源的最大空闲连接数，一旦容器中空闲的连接数超过该数，系统将自动销毁一些链接-->
<parameter>
<name>maxIdle</name>
<value>30</value>
</parameter>
<!--定义数据源的最大等待数-->
<parameter>
<name>maxWait</name>
<value>1000</value>
</parameter>
<!--定义连接数据源的用户名-->
<parameter>
<name>username</name>
<value>admin</value>
</parameter>
<!--定义连接数据源的密码-->
<parameter>
<name>password</name>
<value>admin</value>
</parameter>
<!--指定连接数据源所使用的数据库驱动-->
<parameter>
<name>driverClassName</name>
<value>com.microsoft.jdbc.sqlserver.SQLServerDriver</value>
</parameter>
<!--指定连接数据库的URL-->
<parameter>
<name>url</name>
<value>jdbc:microsoft:sqlserver://localhost:1433;databaseName=book</value>
</parameter>
</ResourceParams>
.....
<GlobalNamingResources>
注意:使用全局数据源容易破坏Tomcat原有的配置
tomcat数据源的配置，可以帮助我们获取数据库的连接，而不需要用JDBC获取连接
——————————————————————————————————————————————————————————————————————————————
jsp的技术原理：
jsp是servlet的扩展，在出现jsp技术之前，就已经出现了servlet技术，servlet是利用输出流动态生成HTML页面。当用户请求一个JSP页面时，服务器先执行JSP元素，并把结果同
网页中静态的部分结合，然后把动态合成的页面送回个浏览器
本质上，jsp是servlet的一种特别形式，每个jsp页面就是一个servlet实例。jsp页面有系统编译成servlet，servlet再负责处理用户请求。对于tomcat而言，每个jsp页面生成的
servlet放在tomcat/work目录对应的web应用下。jsp页面->xxx.java(servlet)->xxx.class文件->html，这个过程都是通过web容器负责的。
1.jsp文件必须在服务器上才能运行 2.jsp文件必须生成servlet才能执行 3.每个jsp页面第一次被访问时速度很慢，是因为必须等待该jsp页面编译成servlet。当jsp第一次被编
译成servlet后，以后后续的请求都将直接由编译后的servlet来处理(而不是每次请求该jsp页面时都要将该jsp页面编译成servlet)。但是，当jsp页面一旦被修改后，被修改后的
jsp页面会重新编译成最新的servlet。4.jsp页面的访问者无须安装任何客户端，甚至不需要可以运行java的运行环境，因为jsp页面输送到客户端的是标准的HTML页面。用户只需
要有个浏览器就万事ok，唯一存在的客户端就是浏览器。
jsp注释：不会输出到客户端(无法通过查看源代码查看到)
<%-- 要注释的内容--%>
HTML注释：会输出到客户端(可以通过查看源代码查看到)
<！-- 要注释的内容-->
jsp声明：jsp声明用于声明变量和方法
<%! 声明部分(变量和方法)%>：
1.如果是变量声明的话，实质上，该变量在jsp页面被编译后的servlet中就是一个实例变量。实例变量只在创建实例的时候才被初始化，而当jsp被编译成servlet之后，被编译后
的servlet实例会常驻内存，不会轻易被再次创建(除非修改jsp或者该servlet实例被销毁)，所以当多个用户请求该jsp页面时，会发现每个客户端上显示的变量时连续的(我们可以
通过这种方式来处理以下情况：监听该用户是第几个访问该jsp页面的用户)
2.如果是方法声明的话，实质上，该方法在jsp页面被编译后的servlet中就是一个实例方法。
jsp表达式：提供了一种输出表达式值的简单方法，格式如下：<%=表达式%>，该部分在jsp被编译成的servlet中是通过PrintWriter out=response.getWriter();out.println(表达
式)；的方式输出的
jsp脚本：就是将java代码嵌入到html代码中，格式如下：<% java代码 %>。页面上所有<% java代码 %>中的java代码部分 实际上是jsp被编译成servlet后的service()方法中的一
部分语句
jsp的3个编译指令：jsp的编译指令是通知jsp引擎的消息，它不直接生成输出。注意是编译期间的指令，就是jsp编译成servlet期间的指令
1.page指令：针对当前页面的指令
2.include指令：用于制定如何包含另一个页面
3.taglib：用于定义和访问自定义标签
编译指令的格式如下：<%@ 编译指令名称 属性名="属性值" ...%>
page指令下的各个属性:
1.language:声明当前jsp页面使用的脚本语言的种类，因为是jsp页面，通常都是java
2.extends：确定jsp程序编译时所称生的java类，需要继承的父类，或者需要实现的接口的全限定名称
3.import：用来导入包，下面几个包是默认导入的:java.lang.*;javax.servlet.*;javax.servlet.jsp.*;javax.servlet.http.*
4.session:设定这个jsp页面是否需要HTTP session，默认是true
5.buffer：制定输出缓冲区的大小，默认是8K的缓冲区，none表示不缓冲
6.autoFlush：当输出缓冲区即将溢出时，是否需要强制输出缓冲区的内容。
7.info：设置该jsp程序的信息，也可以看做说明。可以通过Servlet.getServletInfo()方法获取该值
8.errorPage:指定错误处理页面
9.isErrorPage：设置该jsp是否为错误页面
10.contentType：用于设定生成网页的文件格式和编码方式<@ page contentType="text/html;charset=gb2312">
include指令：使用include指令可以将一个外部文件包含到当前jsp文件中，这是一个静态的include语句。它将被包含的页面加入进来，生成一个完整的页面，include编译指令的
语法：<%@include file="文件路径"%>,这个过程处在jsp->servlet的翻译阶段。它是在编译期间包含，将文件原封不动的先包含到当前jsp页面中，然后对包含以后的整个jsp页面
进行编译
jsp中的7个主要动作指令：
1.jsp:forward：能够向目标组件传送参数和值。如果使用了<jsp:param/>标签的话，目标组件必须是一个动态的文件，能够处理参数。如果使用了非缓冲输出，那么使用
<jsp:forward>时就要小心；如果使用<jsp:forward>之前，JSP文件已经有了数据，那么文件运行将会出错。<jsp:forward>标签从一个JSP文件向另一个组件传递一个包含用户请求
的request对象，<jsp:forward>标签以下的代码将不能运行。服务器端跳转：地址栏的url不会改变
<jsp:forward page="xx.jsp">
<jsp:param name="username" value="admin">
<jsp:param name="password" value="admin"> //这里的参数可以在目标组件中通过request.getParameter("password")获取
</jsp:forward>
<jsp:include>动作指令：也是用于包含某个页面，它的包含会每次检查被包含页面的改变。这个过程处在xxx.java(servlet)->xxx.class文件这样一个请求处理阶段的
<jsp:include page="xxx.jsp" flush="true/false">
<jsp:param name="username" value="admin">
<jsp:param name="password" value="admin"> //这里的参数可以在目标组件中通过request.getParameter("password")获取
</jsp:include>
flush属性用于指定输出缓存是否转移到被包含文件中，如果为true，则包含在被包含文件中，如果为false，则包含在原文件中。
<%@ include file="xxx.jsp"%>与<jsp:include page="xxx.jsp">的区别：静态导入(前者)是将被包含页面完全插入到当前jsp页面中，然后编译成一个整体的servlet，该过程是
在jsp转换成Servlet时进行的。后者：而动态导入则在servlet中使用动态导入，运行时将页面引入。该过程是在Jsp运行时进行的，可以包含动态和静态页面
useBean指令:用于在jsp页面中初始化一个java实例，useBean的语法格式如下：<jsp:useBean id="javaBean实例名称" class="要实例化的javaBean(全限定名称，包含包名)"
scope="request|session|page|application">，eg：<jsp:useBean id="student" class="com.learningcenter.StudentBean" scope="request">等价于：
com.learningcenter.StudentBean student=new com.learningcenter.StudentBean();其中，scope属性指定了该javabean的作用范围，page:说明该javabean实例仅在该页面有效
，request：说明该javabean实例在本次请求范围内有效 session：说明该javabean实例在本次session范围内有效(直到客户端的浏览器关闭后) application：说明该javabean实
例在本应用内一直有效(直到服务器关闭)
setProperty指令：给javabean中的某个属性设置值，格式如下：<jsp:setProperty name="Beanname" property="propertyName" value="propertyValue">,name属性指定需要设定
javabean的实例名称，property属性指定需要设置的属性名，value属性指定需要设置的属性值
getProperty指令：获取javabean中的某个属性的值，格式如下：<jsp:getProperty name="Beanname" property="propertyName" >,name属性指定需要输出的javabean的实例名称
，property属性指定需要输出的属性名
jsp字符编码：
·request.setCharacterEncoding("gbk");
·new String(request.getParameter("name").getBytes("ISO8859-1"),"GBK");
plugin指令：用于下载服务器端的javaBean或Applet到客户端执行。由于程序在客户端执行，因此客户端必须安装虚拟机。plugin的语法格式如下：
<jsp:plugin type="bean|applet" //type指定执行的java程序的类型
code="classFileName" //code指定被执行的文件名，该属性值必须以.class扩展名结尾
codebase="classFileDiretoryName" //codebase指定被执行文件所在的目录
[ ......] //还有很多type="applet"时的属性，这里就不详细描述了
>
<jsp:params>
<jsp:param name="parameterName" value="parameterValue">// 传入一个参数
</jsp:params>
[<jsp:fallback>sometext</jsp:fallback>] // 当不能正确显示applet时，代替显示的提示信息
</jsp:plugin>
param指令：用于设置参数值，这个指令不能单独使用
jsp中的9个内置对象：
1.application:javax.servlet.ServletContext的实例，代表jsp所属的web应用本身，可用于jsp页面，或者jsp与Servlet之间交换信息。
2.config：javax.servlet.ServletConfig的实例，该实例代表该jsp的配置信息
3.exception：java.lang.Throwable的实例，该实例代表其他页面中的一场和错误，只有当页面为错误页面时该对象才可以使用
4.out：javax.servlet.jsp.JspWriter的实例，该实例代表jsp页面的输出流
5.page：代表页面本身，也就是编译形成的Servlet实例本身
6.pageContext：javax.servlet.jsp.PageContext的实例，该实例代表jsp页面上下文，使用该对象可以访问页面中的共享数据
7.request：javax.servlet.http.HttpServletRequest的实例，该对象封装了一次请求，客户端的请求参数(包含请求报头，属性(服务器名，端口号等)，请求参数(表单提交的参
数，地址栏传递的参数)，输入流，cookies)都被封装在该对象里。
8.response：javax.servlet.http.HttpServletResponse的实例，该对象代表服务器对客户端的响应。它常被用来重定向：response.sendRedirect("url");重定向就是客户端转向
，地址栏的url会发生改变，重定向会丢失所有的请求参数(除了重定向URL中带过来的参数，比如url?name=zhanghua&area=beijing)和请求属性，还可以通过response响应生成图
片，以及通过response对象向客户端机器添加cookies信息(
String username=request.getParameter("username");
String password=request.getParameter("password");
Cookie c1=new Cookie("username",username); //创建Cookie
cookie c2=new Cookie("password",password);
c1.setMaxAge(24*3600);//设置Cookie的生命期限，Cookie在生命期限内，将在客户端的硬盘上一直存在
c2.setMaxAge(24*3600);
response.addCookie(c1);//将Cookie通过response对象写到客户端机器上(cookie的内容只能是文本内容)，前提是：客户端的浏览器没有阻止Cookie
response.addCookie(c2);
//cookie通常用于网站记录客户的某些信息，比如客户的用户名及客户的喜好等，一旦用户下次登陆，网站可以根据客户的相关信息为客户提供更有好的服务 ；当服务器要向本地
获取cookie信息时，只能获取属于自己的cookie信息(比如sina向本地机器上保存的cookie信息只能被sina来访问)；cookie分为2种cookie，一种是存在于文件中的cookie(设置了
生命周期)，一种是存在于内存中的cookie(没有设置生命周期，当前窗口或当前窗口的子窗口一旦被关，这个cookie就不存在了)；一个servlet/JSP设置的cookies能够被同一个路
径下面或者其子路径下面的servlet/jsp读取到(也就是说一个servlet/jsp不能访问在该servlet/jsp所在路径的子路径当中另一个servlet/jsp所设置的cookies信息，下层目录中
servlet设置的cookies信息不能被上层目录中servlet访问)
9.session:javax.servlet.http.HttpSession的实例，该对象代表一次会话，从客户端的浏览器与站点建立连接起开始会话，直到关闭浏览器是结束会话(session通常用于跟踪用
户的会话信息，如判断用户是否登陆，或者在购物车应用中，跟踪用户的购买信息)
什么是session：当用户打开浏览器，访问某个站点时，服务器就会在服务器的内存为该浏览器分配一个独立的空间，该空间被这个浏览器独占，这个空间就是Session空间，该空
间中的数据的存在时间默认为30min，开发人员也可以修改(我们可以参HttpServletRequest下的setMaxInactiveInterval()方法)
session的理解：我们可以把session看做是一张内存表，这张表有两列，每行就是session的一个属性，每个属性包含有两个部分，一个是该属性的名字(String)，另一个就是它的
值(Object),session的存储结构使用了HashMap的存储方式，注意session是在服务器端的
当某个浏览器访问网站时，服务器会给浏览器分配一个唯一的SessionId，并以此来区分不同的浏览器
因为session的各个属性占用服务器的内存，因此一般在迫不得已的情况下才考虑使用
Session的两种实现方式：
*通过cookie来实现：把SessionId放在Cookie里面(存在没有设置有效时间的cookie里面即可，因为它只跟浏览器窗口有关系，浏览器窗口关了，SessionId就不需要了，而且浏览
器关了，永远不会再有人来访问你这个浏览器所对应的SessionId了)，如果浏览器没有阻止Cookie，创建Session时，会将跟这个浏览器有关的SessionId存到Cookie里面
*通过URL重写来实现：
response.encodeURL();//它有两个作用：1.转码 2.URL后面加入SessionId
Session不像Cookie一样有路径访问的问题,同一个web应用下的SERVLET/JSP可以共享同一个Session，前提是在同一个浏览器窗口
——————————————————————————————————————————————————————————————————————————————
Servlet介绍：Servlet技术是为了使用internet上的Http协议而实现的，Servlet技术是一种比JSP更早的动态网页编程技术，起初页面中的所有HTML标签，都是通过Servlet中的输
出流来输出的
Servlet的开发：Servlet是运行在服务器端的程序，用于处理及响应客户端的请求，servlet是个特殊的java类，这个java类必须继承javax.servlet.http.HttpServlet(因为我们
通常需要实现的是对HTTP协议上的请求做处理)。servlet提供了不同的方法用于响应客户端请求。通常用到的是doGet,doPost方法，doGet处理客户端的get请求，doPost处理客户
端的post请求。另外，javax.servlet.http.HttpServlet还有两个方法，init(ServletConfig config):创建Servlet实例时，调用的初始化方法。destory()：销毁Servlet实例时
，自动调用的资源回收方法，通常情况下，我们不需要去重写这两个方法，除非需要在初始化Servlet时，完成某些资源初始化的方法，才考虑重写init()方法，如果需要在销毁
Servlet之前，先完成某些资源的回收，比如关闭数据库连接，才需要重写destory()方法
Servlet的生命周期：
Servlet在容器中运行，其实例的创建和销毁都不是有开发人员决定的，而是有Servlet容器进行控制的。
Servlet的创建有两个选择：
1.客户端请求对应的Servlet时，创建Servlet实例，大部分的Servlet都是这种Servlet
2.在Web应用启动时，立即创建Servlet实例，即在web.xml文件中配置<servlet>元素时，在<servlet>元素配置一个<load-on-startup>，应用启动时就启动的Servlet通常用
于某些后台服务的Servlet，或者拦截很多请求的Servlet，这种Servlet通常作为应用的基础Servlet使用，提供重要的后台服务。<load-on-startup>元素是值越小，Servlet就优
先初始化
生命周期：
当一个用户请求映射到一个servlet时，Servlet容器会查看处理该用户请求的Servlet实例是否存在，如果不存在处理该用户请求的Servlet实例，Servlet容器会加载这个
Servlet类，并创建这个Servlet实例，并调用init()方法初始化这个Servlet实例(初始化完毕之后，会将该Servlet实例常驻内存，Servlet实例永远只有一个，所以说Servlet是线
程安全的。这样做可以大大的节省内存以便处理其他用户请求，并且init()方法只执行一次),然后针对具体的请求(get，post)调用doGet或者doPost方法处理用户请求;如果已经存
在处理该用户请求的Servlet实例，Servlet容器会为每个用户请求创建一个线程，由线程去调用那个已经存在的Servlet实例处理用户请求,最后，当Servlet容器要销毁该Servlet
实例调用destory()方法。
Servlet的配置：
配置Servelt需要配置两个部分：
1.配置Servlet的实现类：对应web.xml文件中的<servlet></servlet>元素
2.配置Servlet映射到服务器上的URL：对应web.xml文件中的<servlet-mapping></servlet-mapping>元素
eg: <servlet>
<servlet-name>servlet的名字</servlet-name>
<servlet-class>servlet的实现类(全限定名:即包含包名)</servlet-name>
<init-param>
<param-name>param1</param-name>
<param-value>param1Value</param-value>
<init-param>
//在这里可以配置多个初始化参数
</servlet>
<servlet-mapping>
<servlet-name>servlet的名字(与上面<servlet>元素中的一样)</servlet-name>
<url-pattern>servlet映射的URL地址(注意：这个url-pattern始终以"/"开头，这个"/"是相对于web应用程序的根路径,比如：http://localhost:8080/test)</url-
pattern>
</servlet-mapping>
在servlet中要访问配置的初始化参数：this.getInitParameter("配置文件中<servlet>元素下初始化参数的名字"); 在MVC中，servlet一般作为控制器，servlet会从用户请求中
获取信息，然后调用后台的javabean模型进行业务逻辑处理，最后进行转向控制，转向到其他组件
——————————————————————————————————————————————————————————————————————————————
自定义标签库：自定义标签库是一种非常优秀的组件技术，实现自定义标签库一般有如下几个步骤：
·开发自定义标签处理类：自定义标签库类都必须继承一个父类java.Servlet.jsp.tagext.TagSupport,除此之外，自定义标签类还有如下要求：1.如果标签类包含属性，每
个属性都有对应的getter和setter方法。2.重写doStartTag()或doEndTag，这两个方法生成页面内容。3.如果需要在销毁标签之前完成资源回收，则重写release()方法。
·建立一个*.tld文件( 标签库定义文件,其实，tld文件也就是一个xml文件，只是后缀名不一样)。每个*.tld文件对应一个标签库，每个标签库对应多个标签：标签库定义文
件的根元素是taglib，它可以有多个他给子元素，每个tag子元素都对应一个标签。下面是一个tld文件的描述：
<? xml version="1.0" encoding="gb2312">
<! DOCTYPE taglib PUBLIC "-//SUN Microsyatems,Inc.//DTD JSP Tag Library 1.2//EN" "http://java.sun.con/dtd/web-jsptaglibrary_1_2.dtd">
<taglib>
<!-- 定义标签库版本-->
<tlib-version>1.0</tlib-version>
<!-- 定义jsp版本-->
<jsp-version>1.2</jsp-version>
<!--定义标签库的简写-->
<shortname>fbframe</shortname>
<tag>
<name>自定义标签的名字</name>
<tag-class>自定义标签处理类(全限定名)</tag-class>
<!--确定标签的标签体，标签体为空-->
<bodu-content>empty</body-content>
<!--定义标签的属性，注意：如果标签有属性的话，每个属性都有对应的getter和setter方法-->
<attribute>
<!--属性名-->
<name>submitAction</name>
<!--标签的该属性是否必须-->
<required>true</required>
<!--true表示该自定义标签的某属性的值可以直接指定或者通过动态计算指定，false表示该自定义标签的某属性的值只能直接指定，rtexprvalue属性的全称为runtime
expression value -->
<rtexprvalue>true</rtexprvalue>
</attribute>
</tag>
</taglib>
·在web.xml文件中添加自定义标签的定义：建立*.tld文件之后，还必须在web.xml文件中添加标签库的定义，让web容器去加载标签库文件,在web.xml文件添加标签库的定义
如下：
<taglib>
<!--确定标签库的uri-->
<taglib-uri>/tags/test.tld</taglib-uri>
<!--确定标签库定义文件的位置-->
<taglib-location>/WEB-INF/test.tld</taglib-location>
</taglib>
·在jsp文件中使用自定义标签：1.导入标签库：使用taglib编译指令导入标签，eg：<@ taglib uri="tagliburi" prefix="tagprefix">,其中这里的uri属性与在web.xml文
件中<taglib>元素下的<taglib-uri>元素的值一样，prefix属性指定标签的前缀，及在jsp页面中使用自定义的标签时，用这个前缀就可以了。使用标签库：<tagprefix:tag />
开发带标签体的标签：就是允许在标签内嵌套其他标签，通常可用于完成一些逻辑运算，开发带标签体的标签来需要继承BodyTagSupport类，该类包含一个bodyContent属性，该属
性代表标签体。BodyTagSupport类有两个方法，doAfterBody()方法和doInitBody()方法，前者：每次处理完标签体后调用该方法，后者：在开始调用标签体是调用该方法，如果有
必要可以重写这两个方法。
——————————————————————————————————————————————————————————————————————————————
JSTL:这里先不做介绍，JSTL是SUN提供的一套标准标签库，该标签库的功能非常强大。另外，DisplayTag是Apache组织下的一套开源标签库，主要用于生成页面并显示效果，有机
会再做补充
——————————————————————————————————————————————————————————————————————————————
Filter(过滤器) ：Filter并不是一个标准的Servlet，它不能处理用户请求，也不能对客户端生成响应，主要用于在请求到达服务器之前，对request进行预处理；也可以在服务器
对用户请求的响应到达客户端之前对response进行处理。
Filter有如下几个用处：
·在请求到达服务器之前，拦截用户请求(request)
·根据需要检查用户请求，也可以修改用户请求(request)中的请求报头和信息
·在服务器对用户请求的响应到达客户端之前，拦截响应信息(response)
·根据需要检查服务器对用户请求的响应，也可以修改响应(response)中的响应报头和信息。
Filter一般有以下几种：
·用户授权的Filter：Filter负责检查用户请求，根据请求过滤用户的非法请求
·日志Filter：详细记录某些特殊的用户请求
·负责解码的Filter：包括对非标准编码的请求解码
·能改变XML内容的XSLT Filter等
一个Filter可以负责拦截多个请求或响应，一个请求或响应也可以被多个Filter拦截
创建一个Filter只需要两个步骤：
1.创建Filter处理类：创建Filter必须实现javax.servlet.Filter接口，该接口中定义了3个方法,init(FilterConfig config)用于完成Filter的初始化；destory()用于
Filter销毁前，完成某些资源的回收；doFilter(ServletRequest request,ServletResponse response,FilterChain chain)实现过滤功能，该方法就是对每个请求或响应增加的额
外处理
public class EncodeFilter implements Filter{
private FilterConfig config;
public void init(FilterConfig config){
this.config=config;
}
public void destory(){
this.config=null;
}
public void doFilter(ServletRequest request,ServletResponse response,FilterChain chain){
try{
String encoding=config.getInitParameter("encoding");// 获取web.xml文件中<filter>元素的初始化参数"encoding"的值
request.setCharaterEncoding(encoding);//设置请求编码
chain.doFilter(request,response);//当Filter对请求过滤后，依然将请求发送到目的组件
}catch(Exception e){
e.printStackTrace();
}
}
}
如果检查权限，可以在Filter中根据用户请求的session，判断用户权限是否足够，如果权限不够，则调用重定向即可，无须调用chain.doFilter(request,response)方法
2.在web.xml文件中配置Filter信息:配置Filter和配置Servlet非常相似，具体配置片段如下：
<filter>
<filter-name>setCharaterEncoding</filter-name>
<filter-class>EncodeFilter(全限定名)</filter-class>
<init-param>
<param-name>encoding</param-name>
<param-value>GB2312</param-value>
<init-param>
</filter>
<filter-mapping>
<filter-name>setCharaterEncoding(与上面<filter>元素中的一样)</filter-name>
<url-pattern>*</url-pattern> <!--*表示所有的请求或者响应都会被Filter拦截，我们可以配置多个Filter拦截模式-->
</filter-mapping>
——————————————————————————————————————————————————————————————————————————————
Listener(监听器):Listener的作用非常类似于Servlet中load-on-startup,用于在web启动时，启动某个后台程序，这些后台程序负责为系统运行提供支持，但是，Listener与
Servlet中load-on-startup还是有区别的：Listener的启动时刻比load-on-startup Servlet 更早，Listener时Servlet 2.3规范以后才出现的。
创建Listener只需要两个步骤：
1.创建Listener实现类：创建Listener类必须实现ServletContextListener接口，该接口包含两个方法，contextInitialized(ServletContextEvent sce)方法在启动web应用
时，系统调用该Filter的方法。contextDestoryed(ServletContextEvent sce)方法在关闭web应用的时候，系统调用Filter的方法。
2.在web.xml文件中配置Listener信息：Listener用于启动web应用的后台服务程序，但是不负责处理及响应用户请求，因此无须配置url，将Listener配置在web容器中(前提
：web容器要支持Listener)，则Listener将随web应用的启动而启动，下面是Listener在web.xml文件中的配置片段：
<listener>
<listener-class>Listener的实现类</listener-class>
</listener>
在配置Listener时，只需要配置Listener的实现类即可。此时容器将自动检测部署在容器中的Listener，并在应用启动时，自动加载所有在web.xml配置的Listener。
值得注意的是：在web应用启动时，web.xml文件就会被加载
——————————————————————————————————————————————————————————————————————————————
jsp2.0的新特性:这里就先不介绍了，等有机会补充
——————————————————————————————————————————————————————————————————————————————
MVC框架：即Model-View-Controller(模型视图控制器)，其核心思想是：将程序分成相对独立，而又能协同工作的三个部分，通过这个架构，可以降低模块之间的耦合度，提供应
用的可扩展性。MVC架构是所有面向对象程序都应该遵守的设计模式
Model1：jsp页面接受处理用户请求，对用户请求处理后直接做出响应，在这中间可以辅以JavaBean处理相关业务逻辑。这种模式实现比较简单，但是局限性非常明显，jsp页面充
当视图和控制器两种角色，导致代码的可重用性非常低。维护比较困难
Model2：在这种模式中，引入了servlet，servlet作为前端控制器，负责接受用户发送的请求，在servlet中对用户请求进行处理(一般需要接受用户请求，然后调用后台的
javabean来完成实际的逻辑处理)，最后，转发到相应的组件
——————————————————————————————————————————————————————————————————————————————
struts：struts是Apache软件基金组织Jakarta项目的一个子项目，Struts的前身是JSP Model2架构，Struts是基于Model 2之上的，而Model 2是经典的MVC（模型－视图－控制器
）模型的Web应用变体，这个改变主要是由于网络应用的特性--HTTP协议的无状态性引起的。
Struts的工作流程：
对于采用struts框架的web应用，在actionservlet初始化时回加载struts配置文件，把<action>元素的配置信息都封装到actionmapping对象中，<action>元素中可以包含多
个<forward>子元素，每个<forward>子元素的配置信息被封装到一个actionforward对象中，这些actionforward对象存放在actionmapping对象中的hasmap中(actionmapping.put
(String forward,ActionForward actionForward))
当actionservlet接收到一个客户请求时，将执行如下流程：
1.检索和用户请求的actionmapping实例，如果不存在，就返回用户请求路径无效的信息。(struts-config.xml文件中aciton元素的path属性)，(根据用户请求去匹配action
元素中的path属性创建一个具体的actionmapping对象)
2.如果acitonform实例不存在，就创建一个actionform对象，把客户提交的表单数据封装到actionform对象中(struts-config.xml文件中aciton元素的name属性)
3.根据配置信息决定是否需要表单验证，如果需要验证，就调用actionform中的validate()方法。此时，用户自定义的actionform必须继承验证表单类；并且覆盖基类中的
validate()方法。(struts-config.xml文件中aciton元素的validate属性)
4.如果actionform中的validate()方法返回null或者返回一个不包含actionmessage的actionerror对象，就表示表单验证成功。如果actionform中的validate()方法返回一个
包含一个或者多个actionmessage的actionerror对象，就表示表单验证失败，此时actionservlet将直接把请求转发给包含用户提交表单的jsp组件，并不会去创建action对象，更
加不会去调用action中的execute()方法。(struts-config.xml文件中aciton元素的input属性)
5.actionservlte根据actionmapping实例包含的映射信息决定将请求转发给哪个action，如果相应的aciton实例不存在，则先创建这个实例，然后调用action中的execute()
方法。并且将当前的actionmapping对象，actionformbean对象，request对象，response对象传递个execute()方法做为参数。
6.action中的execute()方法返回一个actionforward对象，actionservlet再把客户请求转发给actionforward对象指向的jsp组件。(struts-config.xml文件中aciton元素的
子节点forward)
7.actionforward对象指向的jsp组件生成动态网页，返回给客户端。
Struts的工作流程详细介绍：
·首先，控制器(ActionServlet)进行初始化工作，读取配置文件(struts-config.xml)，为不同的Struts模块初始化相应的ModuleConfig对象。比如配置文件中的Action映射定
义都保存在ActionConfig集合中。相应地有ControlConfig集合、FormBeanConfig集合、ForwardConfig集合和MessageResourcesConfig集合等。
·控制器接收HTTP请求，并从ActionConfig中找出对应于该请求的Action子类，如果没有对应的Action，控制器直接将请求转发给JSP或者静态页面。否则控制器将请求分发至具
体Action类进行处理。(由ActoionServlet来完成)
·在控制器调用具体Action的execute方法之前，ActionForm对象将利用HTTP请求中的参数来填充自己(可选步骤，需要在配置文件中指定)。具体的ActionForm对象应该是
ActionForm的子类对象，它其实就是一个JavaBean。注意：这个JavaBean中的属性名字和Jsp页面中表单输入域的名字相同，因为在填充ActionForm的时候是通过该FormBean中的
set()方法来为每个属性设置值的，另外，在通过该FormBean中的set()方法来为每个属性设置值之前会调用该FormBean中的reset()方法进行初始化，然后还可以在ActionForm类中
调用validate方法来检查请求参数的合法性（这取决于在struts-config.xml文件中<action>元素下的一个属性validate指定的值，如果设置为”true”,则需要验证，否则不验证
，默认为”false”)，并且可以返回一个包含所有错误信息的ActionErrors对象。如果执行成功，ActionForm自动将这些参数信息以JavaBean(一般称之为form bean)的方式保存在
Servlet Context中(当后续的请求到达后，会检查某个范围是否存在这个FormBean，如果存在则直接使用(拿来主义)，如果不存在，则新创建一个)，这样它们就可以被Action对象
或者JSP调用(在我们的Action类中的execute()方法中就引进了这个formbean)。
·Struts将这些ActionForm的配置信息都放在FormBeanConfig集合中，通过它们Struts能够知道针对某个客户请求是否需要创建相应的ActionForm实例。
Action很简单，一般只包含一个execute方法，它负责执行相应的业务逻辑，如果需要，它也进行相应的数据检查。执行完成之后，返回一个ActionForward对象，控制器通过该
ActionForward对象来进行转发工作。可以转发到jsp页面或者另外一个Action。(参考：IBM的Struts 1.1.doc)
——————————————————————————————————————————————————————————————
Action,ActionForm,ActionForward这三个对象构成了Struts的核心:
配置Actionservlet：
ActionServlet是一个标准的Servlet(它继承了HttpServlet)，在web.xml文件中配置，该Servlet用于拦截所有的HTTP请求，因此，建议将ActionServlet配置成自启动Servlet，也
就是为该Servlet配置load-on-startup属性；ActionServlet还有加载Struts配置文件的责任，但是我们我们通过什么方式告诉ActionServlet要加载哪些struts的配置文件呢?那么
我们可以通过为ActionServlet配置init-param元素来告诉ActionSerlvet要去加载并解析哪些Struts的配置文件；注意：<param-value>元素中指定的struts-config.xml这个文件
的名字并不是不可改变的，只要将 你要交给ActionServlet去加载并解析的Struts配置文件的路径指明清楚就可以了，让ActionServlet知道它要去加载并解析在哪的一个Struts配
置文件(通常，这个Struts配置文件要遵循一定的DTD格式)就可以了。可是，<param-name>元素指定的config通常情况下是固定的
并且，Struts支持使用多个配置文件，当有多个配置文件时，应将不同的配置文件配置成不同的模块，并指定不同的URI
比如：
<servlet>
<servlet-name>acitonServlet</servlet-name>
<servlet-class>org.apache.struts.action.ActionServlet</servlet-class>
<!--配置要加载并解析的第1个struts配置文件-->
<init-param>
<param-name>config</param-name>
<param-value>/WEB-INF/struts-config1.xml</param-value>
</init-param>
<!--配置要加载并解析的第2个struts配置文件-->
<init-param>
<param-name>config/wawa</param-name>
<param-value>/WEB-INF/struts-config2.xml</param-value>
</init-param>
<!--这里还可以配置要加载并解析的多个Struts配置文件-->
........
<!--将ActionSerlvet配置成自启动Servlet-->
<load-on-startup>2</load-on-startup>
</servlet>
上面的配置片段中指定了两个配置文件：struts-config1.xml和struts-config2.xml文件。这两个配置文件分别被配置到config和config/wawa的路径下，表明将struts-
config1.xml中的Action映射到应用的跟路径下，而struts-config2.xml文件中的Action则被映射到应用的wawa子路径下，也就是说wawa将作为系统的一个模块使用(参考IBM的
Struts 1.1.doc)
——————————————————————————————————————————————————————————————————
配置ActionForm：
配置ActionForm，必须包含ActionForm类才行，Struts要求FormBean必须继承：org.apache.struts.action.ActionForm基类。其实FormBean的实现就是一个普通的JavaBean，只
要为每个属性提供对应的setter和getter方法就可以了。ActionForm是用于封装用户的请求参数的，那么它是如何封装用户请求参数的呢?是通过FormBean中的setter方法对
FormBean中的属性设置值的(这个设置值就是表单中每个域的输入值)
在struts的配置文件中，我们需要配置FormBean的信息：
<form-beans>
<!--name属性指定这个formbean的唯一标识名，type指定FormBean的实现类(全限定名)-->
<form-bean name="loginForm" type="com.learningcenter.LoginForm"/>
<!--配置更多的ActionForm信息-->
......
</form-beans>
——————————————————————————————————————————————————————————————————
配置Action：
实现自己的Action:继承org.apache.struts.action.Action基类，然后重写Action基类中的execute()方法，这个方法有四个参数
(ActionMapping,ActionForm,HttpServletRequest,HttpServletResponse);Action主要负责业务逻辑控制
在struts的配置文件中，我们需要配置Action的信息：
<action-mappings >
<action path="" name="" type="" scope="" validate="" input="">
<forward name="" path="">
...
<action>
</action-mappings>
其中：
path:指定用户请求路径(是ActionMapping的唯一标识)
name：指定formBean的名字
type：指定处理用户请求的Action类的全限定名
scope：指定fromBean存在的属性范围
validate：指定表单是否需要验证
input：指定产生错误信息后应该将控制发送到哪里
——————————————————————————————————————————————————————————————————
Struts国际化：
在资源属性文件名中加上"_语言_国家(eg:_en_US,_zh_CN)",当用户在使用当前国家的浏览器的时候会自动找到响应的语言属性文件
在进行编码的批处理文件temp.bat 中写入： " native2ascii encoding 编码方式 要进行编码的属性文件 进行编码后的文件 "
如果有多个语言属性文件，在配置的时候只需要配置一个语言属性文件。(会根据浏览器的不同，显示的语言也不同，因为所有显示的内容都在资源属性文件中配置了
在struts_config.xml文件中配置了<message-resources parameter="com.learningcenter.struts.ApplicationResources" />,注意这里的ApplicationResources是所有语言属性
文件名的前缀，在这个前缀后面加上_语言_国家(eg:_en_US,_zh_CN)后，当用户在使用当前国家的浏览器的时候会自动找到响应的语言属性文件
资源文件的加载通过Struts的配置文件来配置，在家资源文件应从Web应用的WEB-INF/classes路径开始加载，因此，资源文件必须放在WEB-INF/classes路径或者该路径的子路径下
。如果直接放在WEB-INF/classes下，在配置资源文件的时候，直接指定baseName就可以了，但是如果放在其子路径下，则必须以包的形式配置
注意：如果需要Struts实现程序国际化，必须将ActionServlet配置成load-on-startup的Servlet，只有这样才可以保证在启动应用的时候加载该资源文件
——————————————————————————————————————————————————
动态ActionForm:
所有的动态ActionForm的实现类都必须继承org.apache.struts.action.DynaActionForm类或者其子类(比如动态验证Form)
使用动态ActionForm的好处：可以完全不用书写ActionForm类，只需要在struts的配置文件中配置就可以了
使用动态ActionForm与前面使用普通的ActionForm不同的是：因为系统不清楚动态ActionForm的属性，所以必须在配置文件中配置对应的属性，那么我们可以使用<form-bean>元素
下的<form-property>元素来配置动态ActionForm的属性
比如：
<form-beans>
<form-bean name="loginForm" type="org.apache.struts.action.DynaActionForm">
<!--name指定属性的名字，必须与JSP页面的表单域的名字相同；type指定属性的类型(可以是对象引用类型哦)-->
<form-property name="username" type="java.lang.String"/>
<form-property name="password" type="java.lang.String"/>
</form-bean>
<!--配置更多的ActionForm信息-->
......
</form-beans>
使用动态ActionForm时，请求参数必须使用DynaActionForm的getter()方法获取，eg：DynaActionForm loginForm=(DynaActionForm)form;Stirng username=loginForm.getXxx("
在<form-property>元素中配置的属性名");
————————————————————————————————————————————————————
struts的标签库：
HTML标签库：用于生成HTML的基本标签
bean：一个操作javaBean的标签库
logic：用于完成流程控制的标签
————————————————————————————————————————————————————————
Struts的数据校验：
struts的数据校验大致有如下几种方式:
·ActionForm的代码校验(一般用来做格式校验)
值得注意的是：1.重写的是validate(ActionMapping mapping,HttpServletRequest request)方法，第2个参数的类型是HttpServletRequest，而不是ServletRequest；2.使用
ActionForm的输入验证时，应为对应的action元素增加input属性配置，该属性指定当验证没有通过之后应该返回到的页面 3.应为对应的action元素增加validate属性，并指定它
的值为true(告诉服务器表单需要验证)
·Action里的代码校验(一般用来做简单的业务逻辑校验)
·验证框架
重点掌握验证框架：
使用struts的验证框架，不但可以完成服务器端的验证，同时还可以完成客户端的验证。
使用struts的验证框架时，有如下几个通用配置：
·增加验证资源
·利用validatorPlugIn加载验证资源
·ActionForm使用ValidatorForm
使用验证框架的具体步骤：
1.Struts的ActionForm必须是ValidatorForm的子类
2.编写表单域时必须满足验证规则，验证规则文件有2个：validator-rules.xml文件(通用文件)和validation.xml文件(本次项目的验证文件)
3. 指定如果不满足验证规则时，系统将返回哪个页面，可通过指定struts配置文件中的<action>元素中的input属性就可以了，同时，如果表单需要验证必须指定<action>元素
中的validate属性为true
4.加载验证规则文件，在struts配置文件中定义一个插件元素(我们可以利用myeclise中的新建一个Plug-in来图形化配置这里)
<plug-in className="org.apache.struts.validator.ValidatorPlugIn">
<set-property property="pathnames" value="/WEB-INF/validator-rules.xml,/WEB-INF/validation.xml" />
</plug-in>
5.增加验证所需的国际化资源文件(包括编辑和加载,加载需要在struts配置文件中配置一个<message-resources>元素)
----------------------------------------------------------------------------------------------------------------------------------------------
使用DynaValidatorForm的校验：
即使不书写ActionForm，也可以利用struts的验证框架，我们继承DynaValidatorForm
弹出客户端JavaScript提示：
如果需要在客户端弹出JavaScript校验，我们无须修改其它配置文件，只需要修改相应的JSP页面的两个地方：
·为form元素增加οnsubmit="return validateXxxForm(this);"属性，其中XxxForm就是需要校验的form名称，与struts配置文件中配置的form-bean的name属性一致，也与
validation.xml文件中需要校验的form的name属性一致
·增加<html:javascript formName="xxxForm">,其中xxxForm是需要校验的form名
提示：即使使用了客户端校验规则，也不要删除页面的html:message标签，应为该标签会在客户端校验通过，而在服务器端校验未通过时弹出提示
使用DispatchAction控制器
1)使用DispatchAction控制器。可以让一个控制器执行几个相同或相似的操作，而不用写多个控制器
2)比如：一个注册表单同时有两个提交按钮。一个提交按钮用来检查用户名是否存在,一个提交按钮用来执行注册功能，一般情况下会用两个控制器。但是可以通过
DispatchAction来实现只用一个控制器
3)实现DispatchAction的步骤：
1)创建一个Action此Action一定要继承自org.apache.struts.actions.DispatchAction
2)删除里面的Excute方法(一定要删除)
3)在里面加上若干个方法。其参数形式与Excute一样，只不过名字不一样
public ActionForward check(ActionMapping mapping, ActionForm form,
HttpServletRequest request, HttpServletResponse response)
{
在此执行check方法
}
public ActionForward register(ActionMapping mapping, ActionForm form,
HttpServletRequest request, HttpServletResponse response)
{
在此执行register方法
}
4)在struts-config.xml文件中。配置Action通过参数来决定执行那些方法
<action path="/MyDispatchAction" type="MyDispatchAction" parameter="method"/>
上面配置了一个parameter="method"表明Action会通过该参数的值调用对应的方法。也就是
此Action会根据method的值来决定调用那个方法。如果method的值是"check"则调用check方法
如果method的值是"register"则调用register方法
5)然后在jsp页面中增加method参数值
A)如果是post提交，则可以使用隐藏域来实现
<html:form action="MyDispatchAction.do">
<input type="hidden" name="method" value="register"/>
<html:text property="uid"/><html:submit οnclick="method.value='check'"/>
<html:text property="pwd"/><br>
<html:submit οnclick="method.value='register'">提交</html:submit>
</html:form>
上面用了两个提交按钮，用了一个隐藏域。然后由提交按钮的单击事件中动态改变隐藏
域的值
B:如果是get提交。则可以使用形如：
<a href="MyDispatchAction.do?action=check&uid=chen">检查</a>
<a href="MyDispatchAction.do?method=register&uid=chen">注册</a>
注意get提交千万不能带有空格
<a href="MyDispatchAction.do?action=check & uid=chen">检查</a>(错误错误)
应用举例：
1)添加与修改(添加与修改经常会共用一个表单，所以可以使用DispatchAction
2)检查用户名是否存在与注册
3)一个按钮用于根据工号查询，一个按钮用于把查询之后的结果进行修改
4)一个页面放入四个按钮。实现加减乘除
-----------------------------------------------------------------------------------------------------------------------------------------
使用ForwardAction控制器：
如果需要从一个页面或资源转到另一个资源时，直接使用超级连接并不是好的做法，这样会使得控制器没有机会处理相关的请求。使用ForwardAction可以完成请求的转发，当控
制器调用ForwardAction的execute()方法时，它会使用属性parameter所设定的路径进行forward的动作，eg:
<action-mappings>
<action path="/welcome" type="org.apache.struts.actions.ForwardAction" parameter="/welcome.jsp" />
</action-mappings>
页面控制转发的代码： <a href="/welcome.do">转入</a>
记得：ForwardAction仅仅完成请求转发
-----------------------------------------------------------------------------------------------------------------------------------------
使用IncludeAction控制器：
举例：
在struts-config.xml中配置：
<action-mappings>
<action path="/welcome" type="org.apache.struts.actions.IncludeAction" parameter="/welcome.jsp" />
</action-mappings>
在页面中加载该action所导入资源的代码：
<jsp:include page="/welcome.do" />
-----------------------------------------------------------------------------------------------------------------------------------------
使用SwitchAction控制器：
SwitchAction主要用于模块之间的切换，当一个应用中存在多个模块时，使用SwitchAction在不同模块之间的acion之间切换
使用举例：
如果在web.xml文件中加载了2个配置文件，其中一个作为系统的一个模块
<servlet>
<servlet-name>action</servlet>
<servlet>class>org.apache.struts.action.ActionServlet</servlet-class>
<init-param>
<param-name>config</param-name>
<param-value>/WEB-INF/struts-config.xml</param-value>
</init-param>
<init-param>
<param-name>config/wawa</param-name>
<param-value>/WEB-INF/struts-config1.xml</param-value>
</init-param>
<load-on-startup>2</load-on-startup>
</servlet>
首先，我们需要在struts-config1.xml文件中配置一个action，该action的配置如下：
<action-mappings>
<action path="/welcome" forward="/welcome.jsp" />
</action-mappings>
接下来我们需要在struts-config.xml文件中配置SwitchAction如下：
<action-mappings>
<action path="/moduleSwitch" type="org.apache.struts.actions.SwitchAction" /> </action-mappings>
在页面上的代码如下：
<a href="/moduleSwitch.do?prefix=/wawa&&page=/welcome.do">转到另一个模块</a>
在使用SwitchAction时，必须在请求中带2个参数：1.prefix：用来指定模块名称，2.page：用来指定相关模块中的资源路径。"/moduleSwitch.do?
prefix=/wawa&&page=/welcome.do"表示由SwitchActin来将请求交给wawa模块下的welcome.do来处理，并响应请求
------------------------------------------------------------
有机会研究下Struts的源代码
-----------------------------------------------------------
490
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
