方式：在类中手动连接：
?? ? ?? ApplicationContext ac = new ClassPathXmlApplicationContext(“applicationContext.xml”);
??? ??? ManageInf mi = (ManageInf) ac.getBean( “manageInf” );
??? ??? mi.update();
这样一与配置文件相接触，IOC, AOP之类就会自动完成注入与关联！
而与Struts整合因在web.xml中配置了listener，故一切都是自动完成，无需手动创建bean.
1, Spring 在web.xml中配置Spring listener
<listener>
<listener-class>
org.springframework.web.context.ContextLoaderListener
</listener-class>
</listener>
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>/WEB-INF/classes/applicationContext.xml</param-value>
</context-param>
2, Strutx 配置
1.x, 在struts-config.xml中为action的type指定为 org.springframework.web.struts.DelegatingActionProxy
2.x? 在struts.xml中为action的class指定为具体类(只注入属性),或bean id
3, Spring在 applicationContext.xml中配置bean id
1.x 全部配置,bean id与action的path相同
2.0? 按action的class做相应配置,
???? 若是属性注入, bean id 要与action类中的属性名相同
???? 若是全部注入, bean id 要与action在配置文件中中指定的class相同
1，添加struts1.x, Spring能力
2, 在struts1.x的配置文件struts-config.xml中配置与Spring的联系
<action-mappings >
<action
attribute=”loginForm”
input=”/login.jsp”
name=”loginForm”
path=”/login”?? //在Spring的applicationContext.xml中要用此path当做bean id
scope=”request”
type=”org.springframework.web.struts.DelegatingActionProxy” >
?? //交由Spring来生成action,而不是在此就指定具体的类
<forward name=”success” path=”/success.jsp” />
</action>
</action-mappings>
<message-resources parameter=”com.yourcompany.struts.ApplicationResources” />
<!– 集成Spring插件 –>
<plug-in className=”org.springframework.web.struts.ContextLoaderPlugIn”>
<set-property property=”contextConfigLocation” value=”/WEB-INF/classes/applicationContext.xml”/>
</plug-in>
? // struts添加Spring插件
注:也可不用插件, 利用如struts 2.0 的方式在web.xml中配置Spring监听器 即:
<listener>
<listener-class>
org.springframework.web.context.ContextLoaderListener
</listener-class>
</listener>
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>/WEB-INF/classes/applicationContext.xml</param-value>
</context-param>
3，在Spring中添加action的生成
<bean name=”/login” scope=”prototype” >
<property name=”myService”>
??? <ref bean=”myService”/>
</property>
</bean>
ps: struts 1.x , struts2.0与Spring整合的区别：
（1）1.x 是整个action注入，生成由Spring负责，而2.0让spring负责属性的注入，也可负责action的创建。
（2）1.x与Spring的联系是在其配置文件struts-config.xml中通过插件机制完成，也可在web.xml中配置Spring过滤器完成.都市而2.0是在 web.xml中通过配置过滤器来完成这种联系。
(3)?? 1.x 是全部注入:struts-config.xml中要配置每个action与spring的联系???????????? type=”org.springframework.web.struts.DelegatingActionProxy” >
然后在spring的applicationContext.xml中配置对应的bean
??? 2.0不仅有全部注入,还有属性注入.
???? 2.0 属性注入，在struts2.0的struts.xml中无须配置每个action与Spring的联系，只须在action类中指定一个属性名，此属性名与application.context.xml中某一bean id相同即可。
???? 2.0 所有注入:托管action的所有生命周期,要在struts.xml中为action的class指定为Spring的applicationContext.xml中的一个bean id,这样就可完成所有托管.
无论是1.x,还是2.0，若想让spring注入属性，必须在类中为此属性指定set,get方法，而不论此属性是private,还是public
1,? 利用myeclipse，会少中一个jar包，需要手动加入 commons-pool-1.3.jar
http://mirrors.ibiblio.org/pub/mirrors/maven2/commons-pool/commons-pool/1.3/commons-pool-1.3.jar
或查找myeclipse安装目录， 在如下位置
myeclipse\eclipse\plugins\com.genuitec.org.hibernate.eclipse_6.0.1.zmyeclipse601200710\lib\springhibernate
2, 添加Spring后加hibernate时，hibernate最好都选中所有类库，之后选择Spring的applicationContext.xml，
这样就会用getHibernateTemplate().save(transientInstance)之类代替session进行托管,这是Spring与Hibernate整合的最大好处。
hibernate 的hbm.xml文件要在applicationContext.xml中引入：即
<bean id=”sessionFactory”
class=”org.springframework.orm.hibernate3.LocalSessionFactoryBean”>
…
<property name=”mappingResources”>
??? <list>
??????? <value>com/lvjian/model/News.hbm.xml</value>??????
??? </list>
</bean>
对DAO注入：sessionFactory
<bean id=”consultingDao”
parent=”dao”>
<property name=”sessionFactory” ref=”sessionFactory” />?
????????? //sessionFactory当指定Spring接管hibernate时自动配置， DAO类要实现HibernateSurrort类
</bean>
3, 在应用中，最好对生成的dao进行包装，用一个接口来定义dao方法，在action中利用这些接口提供的方法进行操作
而在applicationContext.xml 对接口id注入impl类！
即：在表层上只留接口，实现由applicationContext.xml配置完成
方法主要可以有：
???????????? 1, 查询? getAdmin（id） ，getAdmins 得到所有, findByProperty(String propertyName, Object value)
???????????? 2, 插入 insertAdmin(Admin obj)
???????????? 3,更新? updateAdmin(Admin obj)
???????????? 4 删除?? deleteAdmin(Integer obj_id)
注：DAO类要实现HibernateSurrort类
com.yourcompany.dao.inf
com.yourcompany.dao.impl
String 2.0 Core Libraries
String 2.0 Persistence JDBC Libraries
String 2.0 Web Libraries
定制功能 ；其自带显示的功能很多，可定制显示几个按纽
ewebeditor.htm 下 myParam_Init()方法
myParam.StyleName = (URLParams[“style”]) ? URLParams[“style”] : “coolblue”;
coolblue就是指定按纽的地方，在style文件夹下找到 coolblue.js, 改config.Toolbars即可。
htmlparser是一个纯的java写的html解析的库，它不依赖于其它的java库文件，主要用于改造或
提取html。它能超高速解析html，而且不会出错。
毫不夸张地说，htmlparser就是目前最好的html解析和分析的工具。
无论你是想抓取网页数据还是改造html的内容，用了htmlparser绝对会忍不住称赞。
htmlparser基本功能
1． 信息提取
? 文本信息抽取，例如对HTML进行有效信息搜索
? 链接提取，用于自动给页面的链接文本加上链接的标签
? 资源提取，例如对一些图片、声音的资源的处理
? 链接检查，用于检查HTML中的链接是否有效
? 页面内容的监控
2． 信息转换
? 链接重写，用于修改页面中的所有超链接
? 网页内容拷贝，用于将网页内容保存到本地
? 内容检验，可以用来过滤网页上一些令人不愉快的字词
? HTML信息清洗，把本来乱七八糟的HTML信息格式化
? 转成XML格式数据
htmlparser常用代码
取得一段html代码里面所有的链接C#版本，java版本类似：
string htmlcode = “<HTML><HEAD><TITLE>AAA</TITLE></HEAD><BODY>” + …… + “</BODY></HTML>”;
Parser parser = Parser.CreateParser(htmlcode, “GBK”);
HtmlPage page = new HtmlPage(parser);
try
{ parser.VisitAllNodesWith(page);}
catch (ParserException e1)
{ e1 = null;}
NodeList nodelist = page.Body;
NodeFilter filter = new TagNameFilter(“A”);
nodelist = nodelist.ExtractAllNodesThatMatch(filter, true);
for (int i = 0; i < nodelist.Size(); i++)
{
LinkTag link=(LinkTag) nodelist.ElementAt(i);
System.Console.Write(link.GetAttribute(“href”) + “\n”);
}
1）java.util.Timer 这个方法应该是最常用的，不过这个方法需要手工启动你的任务： Timer timer=new Timer(); timer.schedule(new ListByDayTimerTask(),10000,86400000); 这里的ListByDayTimerTask类必须extends TimerTask里面的run()方法。
2）ServletContextListener 这个方法在web容器环境比较方便，这样，在web server启动后就可以自动运行该任务，不需要手工操作。将ListByDayListener implements ServletContextListener接口，在 contextInitialized方法中加入启动Timer的代码，在contextDestroyed 方法中加入cancel该Timer的代码；然后在web.xml中，加入listener:
3)org.springframework.scheduling.timer.ScheduledTimerTask 如果你用spring，那么你不需要写Timer类了，在schedulingContext-timer .xml中加入下面的内容就可以了：
1 老是弹出Quick update error 、关闭myeclipse的Quick Update自动更新功能
这个问题的解决办法是关闭自动更新
Windows > Preferences > MyEclipse Enterprise Workbench > Community Essentials,
把选项 “Search for new features on startup”的前勾去掉即可。
2 关闭updating indexes
Window > Preferences > Myeclipse Enterprise Workbench > Maven4Myeclipse > Maven>禁用Download repository index updates on startup 。
3 关闭MyEclipse的自动validation
validation有一堆，什么xml、jsp、jsf、js等等，我们没有必要全部都去自动校验一下，只是需要的时候才会手工校验一下，速度立马提升好几个档次
windows > perferences > myeclipse > validation
将Build下全部勾取消
如果你需要验证某个文件的时候，我们可以单独去验证它。方法是，在需要验证的文件上( 右键 -> MyEclipse -> Run Validation 。
4 启动优化，关闭不需要使用的模块
一个系统20%的功能往往能够满足80%的需求，MyEclipse也不例外，我们在大多数时候只需要20%的系统功能，所以可以将一些不使用的模块禁止 加载启动。
Window > Preferences > General > Startup andy Shutdown 在这里列出的是MyEclipse启动时加载的模块 我这里只让它加载tomcat5 勾选 MyEclipse EASIE Tomcat 5 。
怎样才能知道哪些启动项有用呢？我现在把我知道的启动项用处说一下，还有很多不懂的，希望大家懂的回复在下面啊：
WTP ：一个跟myeclipse差不多的东西，主要差别是 WTP 是免费的，如果使用myeclipse，这个可以取消
Mylyn：组队任务管理工具，类似于 CVS ，以任务为单位管理项目进度，没用到的可以取消
Derby：一种保存成 jar 形式的数据库，我没用到，取消
一大排以 MyEclipse EASIE 打头的启动项：myeclipse 支持的服务器，只选自己用的，其他取消，比如我只选了tomcat 。
5 去掉MyEclipse的拼写检查（如果你觉的有用可以不去）
拼写检查会给我们带来不少的麻烦，我们的方法命名都会是单词的缩写，他也会提示有错，所以最好去掉，没有多大的用处
Window > perferences > General > Editors > Text Editors > Spelling > 将Enable spell checking复选框的勾选去掉。
6 去掉MyEclipse繁杂的自带插件自动加载项
Window > perferences > General > Startup and Shutdown > 将Plug-ins activated on startup 中的复选框有选择性的勾选去掉。
7 修改MyEclipse编辑JSP页面时的编辑工具
Window > perferences > General > Editors > File Associations >
在File types 中选择 *.jsp > 在Associated editors 中将”MyEclipse JSP Editor”设置为默认。
8 修改MyEclipse安装目录的eclipse.ini文件，加大JVM的非堆内存
具体内容如下：
-clean
-showsplash
com.genuitec.myeclipse.product.ide
–launcher.XXMaxPermSize
256m
-vmargs
-Xms128m
-Xmx512m
-Duser.language=en
-XX:PermSize=128M
-XX:MaxPermSize=256M
把下面的那个 -XX:MaxPermSize 调大，比如 -XX:MaxPermSize=512M，再把 -XX:PermSize 调成跟 -XX:MaxPermSize一样大
Struts跟Tomcat、Turbine等诸多Apache项目一样，是开源软件，这是它的一大优点。使开发者能更深入的了解其内部实现机制。 Struts开放源码框架的创建是为了使开发者在构建基于Java Servlet和JavaServer Pages（JSP）技术的Web应用时更加容易。Struts框架为开放者提供了一个统一的标准框架，通过使用Struts作为基础，开发者能够更专注于应用程序的商业逻辑。Struts框架本身是使用Java Servlet和JavaServer Pages技术的一种Model-View-Controller（MVC）实现.
具体来讲,Struts的优点有:
??? 1. 实现MVC模式，结构清晰,使开发者只关注业务逻辑的实现.
??? 2. 有丰富的tag可以用 ,Struts的标记库(Taglib)，如能灵活动用，则能大大提高开发效率。另外，就目前国内的JSP开发者而言，除了使用JSP自带的常用标记外，很少开发自己的标记，或许Struts是一个很好的起点。
??? 3. 页面导航.页面导航将是今后的一个发展方向，事实上，这样做，使系统的脉络更加清晰。通过一个配置文件，即可把握整个系统各部分之间的联系，这对于后期的维护有着莫大的好处。尤其是当另一批开发者接手这个项目时，这种优势体现得更加明显。
??? 4. 提供Exception处理机制 .
??? 5. 数据库链接池管理
??? 6. 支持I18N
??? 缺点:
??? 一、转到展示层时，需要配置forward，每一次转到展示层，相信大多数都是直接转到jsp，而涉及到转向，需要配置forward，如果有十个展示层的 jsp，需要配置十次struts，而且还不包括有时候目录、文件变更，需要重新修改forward，注意，每次修改配置之后，要求重新部署整个项目，而 tomcate这样的服务器，还必须重新启动服务器，如果业务变更复杂频繁的系统，这样的操作简单不可想象。现在就是这样，几十上百个人同时在线使用我们的系统，大家可以想象一下，我的烦恼有多大。
??? 二、 Struts 的Action必需是thread－safe方式，它仅仅允许一个实例去处理所有的请求。所以action用到的所有的资源都必需统一同步，这个就引起了线程安全的问题。
??? 三、 测试不方便. Struts的每个Action都同Web层耦合在一起，这样它的测试依赖于Web容器，单元测试也很难实现。不过有一个Junit的扩展工具Struts TestCase可以实现它的单元测试。
??? 四、 类型的转换. Struts的FormBean把所有的数据都作为String类型，它可以使用工具Commons-Beanutils进行类型转化。但它的转化都是在 Class级别，而且转化的类型是不可配置的。类型转化时的错误信息返回给用户也是非常困难的。
??? 五、 对Servlet的依赖性过强. Struts处理Action时必需要依赖ServletRequest 和ServletResponse，所有它摆脱不了Servlet容器。
??? 六、 前端表达式语言方面.Struts集成了JSTL，所以它主要使用JSTL的表达式语言来获取数据。可是JSTL的表达式语言在Collection和索引属性方面处理显得很弱。
??? 七、 对Action执行的控制困难. Struts创建一个Action，如果想控制它的执行顺序将会非常困难。甚至你要重新去写Servlet来实现你的这个功能需求。
??? 八、 对Action 执行前和后的处理. Struts处理Action的时候是基于class的hierarchies，很难在action处理前和后进行操作。
??? 九、 对事件支持不够. 在struts中，实际是一个表单Form对应一个Action类(或DispatchAction)，换一句话说：在Struts中实际是一个表单只能对应一个事件，struts这种事件方式称为application event，application event和component event相比是一种粗粒度的事件。
????
??? Struts重要的表单对象ActionForm是一种对象，它代表了一种应用，这个对象中至少包含几个字段，这些字段是Jsp页面表单中的input字段，因为一个表单对应一个事件，所以，当我们需要将事件粒度细化到表单中这些字段时，也就是说，一个字段对应一个事件时，单纯使用Struts就不太可能，当然通过结合JavaScript也是可以转弯实现的。
2．Hibernate
Hibernate是一个开放源代码的对象关系映射框架，它对JDBC进行了非常轻量级的对象封装，使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库。
Hibernate可以应用在任何使用JDBC的场合，既可以在Java的客户端程序实用，也可以在Servlet/JSP的Web应用中使用，最具革命意义的是，Hibernate可以在应用EJB的J2EE架构中取代CMP，完成数据持久化的重任。
大多数开发机构经常采取创建各自独立的数据持久层。一旦底层的数据结构发生改变，那么修改应用的其余部分使之适应这种改变的代价将是十分巨大的。 Hibernate适时的填补了这一空白，它为Java应用提供了一个易用的、高效率的对象关系映射框架。hibernate是个轻量级的持久性框架，功能却非常丰富。
优点：
a.??????? Hibernate 使用 Java 反射机制 而不是字节码增强程序来实现透明性。
b.??????? ?Hibernate 的性能非常好，因为它是个轻量级框架。 映射的灵活性很出色。
c.??????? 它支持各种关系数据库，从一对一到多对多的各种复杂关系。
缺点：它限制您所使用的对象模型。(例如，一个持久性类不能映射到多个表)其独有的界面和可怜的市场份额也让人不安，尽管如此，Hibernate 还是以其强大的发展动力减轻了这些风险。其他的开源持久性框架也有一些，不过都没有 Hibernate 这样有市场冲击力。
上面回贴情绪有点激动，希望谅解，我不是因为有人批评Hibernate而感到不快，而是因为帖子里面的观点实在让我觉得荒谬。不管觉得Hibernate 好也吧，不好也吧，我唯一觉得遗憾的是，在中文论坛里面找不到一个对Hibernate的真正高水平的评价。在TSS上有一个关于Hibernate的 hot thread，跟了几百贴，其中包括Hibernate作者Gavin和LiDO JDO的CTO，对于JDO和Hibernate有过一些激烈的争论，我曾经耐心的看了一遍，仍然没有发现针对Hibernate真正有力的攻击，那些所谓的攻击无非针对Hibernate没有一个GUI的配置工具，没有商业公司支持，没有标准化等等这些站不住脚的理由。
补充几点我的意见：
一、 Hibernate是JDBC的轻量级的对象封装，它是一个独立的对象持久层框架，和App Server，和EJB没有什么必然的联系。Hibernate可以用在任何JDBC可以使用的场合，例如Java应用程序的数据库访问代码，DAO接口的实现类，甚至可以是BMP里面的访问数据库的代码。从这个意义上来说，Hibernate和EB不是一个范畴的东西，也不存在非此即彼的关系。
二、Hibernate是一个和JDBC密切关联的框架，所以Hibernate的兼容性和JDBC驱动，和数据库都有一定的关系，但是和使用它的Java程序，和App Server没有任何关系，也不存在兼容性问题。
三、 Hibernate不能用来直接和Entity Bean做对比，只有放在整个J2EE项目的框架中才能比较。并且即使是放在软件整体框架中来看，Hibernate也是做为JDBC的替代者出现的，而不是Entity Bean的替代者出现的，让我再列一次我已经列n次的框架结构：
传统的架构：
1) Session Bean <-> Entity Bean <-> DB
为了解决性能障碍的替代架构：
2) Session Bean <-> DAO <-> JDBC <-> DB
使用Hibernate来提高上面架构的开发效率的架构：
3) Session Bean <-> DAO <-> Hibernate <-> DB
就上面3个架构来分析：
1、内存消耗：采用JDBC的架构2无疑是最省内存的，Hibernate的架构3次之，EB的架构1最差。
2、运行效率：如果JDBC的代码写的非常优化，那么JDBC架构运行效率最高，但是实际项目中，这一点几乎做不到，这需要程序员非常精通JDBC，运用 Batch语句，调整PreapredStatement的Batch Size和Fetch Size等参数，以及在必要的情况下采用结果集cache等等。而一般情况下程序员是做不到这一点的。因此Hibernate架构表现出最快的运行效率。 EB的架构效率会差的很远。
3、开发效率：在有JBuilder的支持下以及简单的项目，EB架构开发效率最高，JDBC次之，Hibernate最差。但是在大的项目，特别是持久层关系映射很复杂的情况下，Hibernate效率高的惊人，JDBC次之，而EB架构很可能会失败。
4、分布式，安全检查，集群，负载均衡的支持
由于有SB做为Facade，3个架构没有区别。
四、EB和Hibernate学习难度在哪里？
EB 的难度在哪里？不在复杂的XML配置文件上，而在于EB运用稍微不慎，就有严重的性能障碍。所以难在你需要学习很多EJB设计模式来避开性能问题，需要学习App Server和EB的配置来优化EB的运行效率。做EB的开发工作，程序员的大部分精力都被放到了EB的性能问题上了，反而没有更多的精力关注本身就主要投入精力去考虑的对象持久层的设计上来。
Hibernate难在哪里？不在Hibernate本身的复杂，实际上Hibernate非常的简单，难在Hibernate太灵活了。
当你用EB来实现持久层的时候，你会发现EB实在是太笨拙了，笨拙到你根本没有什么可以选择的余地，所以你根本就不用花费精力去设计方案，去平衡方案的好坏，去费脑筋考虑选择哪个方案，因为只有唯一的方案摆在你面前，你只能这么做，没得选择。
Hibernate 相反，它太灵活了，相同的问题，你至少可以设计出十几种方案来解决，所以特别的犯难，究竟用这个，还是用那个呢？这些方案之间到底有什么区别呢？他们的运行原理有什么不同？运行效率哪个比较好？光是主键生成，就有七八种方案供你选择，你为难不为难？集合属性可以用Set，可以用List，还可以用Bag，到底哪个效率高，你为难不为难？查询可以用iterator，可以用list，哪个好，有什么区别？你为难不为难？复合主键你可以直接在hbm里面配置，也可以自定义CustomerType，哪种比较好些？你为难不为难？对于一个表，你可以选择单一映射一个对象，也可以映射成父子对象，还可以映射成两个 1:1的对象，在什么情况下用哪种方案比较好，你为难不为难？
这个列表可以一直开列下去，直到你不想再看下去为止。当你面前摆着无数的眼花缭乱的方案的时候，你会觉得幸福呢？还是悲哀呢？如果你是一个负责的程序员，那么你一定会仔细研究每种方案的区别，每种方案的效率，每种方案的适用场合，你会觉得你已经陷入进去拔不出来了。如果是用EB，你第一秒种就已经做出了决定，根本没得选择，比如说集合属性，你只能用Collection，如果是Hibernate，你会在Bag，List和Set之间来回犹豫不决，甚至搞不清楚的话，程序都没有办法写。
3． Spring
它是一个开源的项目，而且目前非常活跃；它基于IoC（Inversion of Control，反向控制）和AOP的构架多层j2ee系统的框架，但它不强迫你必须在每一层中必须使用Spring，因为它模块化的很好，允许你根据自己的需要选择使用它的某一个模块；它实现了很优雅的MVC，对不同的数据访问技术提供了统一的接口，采用IoC使得可以很容易的实现bean的装配，提供了简洁的AOP并据此实现Transcation Managment，等等
优点
a. Spring能有效地组织你的中间层对象，不管你是否选择使用了EJB。如果你仅仅使用了Struts或其他为J2EE的 API特制的framework，Spring致力于解决剩下的问题。
b. Spring能消除在许多工程中常见的对Singleton的过多使用。根据我的经验，这是一个很大的问题，它降低了系统的可测试性和面向对象的程度。
c. 通过一种在不同应用程序和项目间一致的方法来处理配置文件，Spring能消除各种各样自定义格式的属性文件的需要。曾经对某个类要寻找的是哪个方法的哪个的属性项或系统属性感到不解，为此不得不去读Javadoc甚至源编码？有了Spring，你仅仅需要看看类的JavaBean属性。 Inversion of Control的使用（在下面讨论）帮助完成了这种简化。
d. 通过把对接口编程而不是对类编程的代价几乎减少到没有，Spring能够促进养成好的编程习惯。
e. Spring被设计为让使用它创建的应用尽可能少的依赖于他的APIs。在Spring应用中的大多数业务对象没有依赖于Spring。
f. 使用Spring构建的应用程序易于单元测试。
g. Spring能使EJB的使用成为一个实现选择,而不是应用架构的必然选择。你能选择用POJOs或local EJBs来实现业务接口，却不会影响调用代码。
h. Spring帮助你解决许多问题而无需使用EJB。Spring能提供一种EJB的替换物，它们适用于许多web应用。例如，Spring能使用AOP提供声明性事务管理而不通过EJB容器，如果你仅仅需要与单个数据库打交道，甚至不需要一个JTA实现。
?? i. ?Spring为数据存取提供了一个一致的框架,不论是使用的是JDBC还是O/R mapping产品（如Hibernate）。
Spring确实使你能通过最简单可行的解决办法来解决你的问题。而这是有有很大价值的。
?缺点：使用人数不多、jsp中要写很多代码、控制器过于灵活，缺少一个公用控制器
代码部分分三层：
?? ?1， 表示层，直接客户层即：操作界面的部分，在java中相当于action,在.net中相当于每个界面对应的.cs类,在此层中主要接受页面传来的数据，采用的方法是：产生一个实体，利用oop的封装性将页面传来的数据进行封装，之后action对其进行操作，调用下面的业务处理层进行对实体类的操作。
?? ?2， 业务处理层( BusinessLogicLayer) :数据处理的处理位置，在action中进行调用，此层接受直接客户层传来的请求，组合使用数据处理层进行实体类的操作。在此层中不出现与数据库交互的部分，功能通过调用数据处理层进行。
?? ?3， 数据访问层（BusinessLogicLayer）：直接操作数据，与数据库打交道，相当于java中的dao.
注：直接客户层只能出现业务处理层，实体类，数据处理层只能在业务处理层中出现，实现类的松散性。
1，导入入log4j-1.2.8.jar
2，建立log4j.properties文件
log4j.rootLogger=warn, myConsole, myFile
//appender为输出的目地地，控制台或文件
log4j.appender.myConsole=org.apache.log4j.ConsoleAppender
log4j.appender.myConsole.layout=org.apache.log4j.PatternLayout
# Pattern to output the caller’s file name and line number.
log4j.appender.myConsole.layout.ConversionPattern= [QC] %p [%t] %C.%M(%L) | %m%n
log4j.appender.myFile=org.apache.log4j.RollingFileAppender
log4j.appender.myFile.File=E:\\log\\JavaApp.log
log4j.appender.myFile.MaxFileSize= 1KB
# Keep one backup file
log4j.appender.myFile.MaxBackupIndex=1
log4j.appender.myFile.layout=org.apache.log4j.PatternLayout
log4j.appender.myFiles.layout.ConversionPattern= [QC] %p [%t] %C.%M(%L) | %m%n
#指定com.neusoft包下的所有类的等级为DEBUG。
log4j.logger.com. neusoft =DEBUG
解释：
①、配置根Logger??????? log4j.rootLogger
Logger 负责处理日志记录的大部分操作。
其语法为：
log4j.rootLogger = [ level ] , appenderName, appenderName, …
其中，level 是日志记录的优先级，分为OFF、FATAL、ERROR、WARN、INFO、DEBUG、ALL或者自定义的级别。Log4j建议只使用四个级别，优先级从高到低分别是ERROR、WARN、INFO、DEBUG。通过在这里定义的级别，您可以控制到应用程序中相应级别的日志信息的开关。比如在这里定义了INFO级别，只有等于及高于这个级别的才进行处理，则应用程序中所有DEBUG级别的日志信息将不被打印出来。ALL:打印所有的日志，OFF：关闭所有的日志输出。 appenderName就是指定日志信息输出到哪个地方。可同时指定多个输出目的地。
②、配置日志信息输出目的地 Appender
Appender 负责控制日志记录操作的输出。
其语法为：
log4j.appender.appenderName =org.apache.log4j.ConsoleAppender
这里的appenderName为在①里定义的，可任意起名。
其中，Log4j提供的appender有以下几种：
org.apache.log4j.ConsoleAppender（控制台），
org.apache.log4j.FileAppender（文件），
org.apache.log4j.DailyRollingFileAppender（每天产生一个日志文件），
org.apache.log4j.RollingFileAppender（文件大小到达指定尺寸的时候产生一个新的文件），可通过log4j.appender.R.MaxFileSize=100KB设置文件大小，还可通过 log4j.appender.R.MaxBackupIndex=1设置为保存一个备份文件。
org.apache.log4j.WriterAppender（将日志信息以流格式发送到任意指定的地方）
例如：log4j.appender.stdout=org.apache.log4j.ConsoleAppender
定义一个名为stdout的输出目的地，ConsoleAppender为控制台。
③、配置日志信息的格式（布局）Layout
Layout 负责格式化Appender的输出。
其语法为：
log4j.appender.myConsole.layout=org.apache.log4j.PatternLayout
其中，Log4j提供的layout有以下几种：
org.apache.log4j.HTMLLayout（以HTML表格形式布局），
org.apache.log4j.PatternLayout（可以灵活地指定布局模式），
org.apache.log4j.SimpleLayout（包含日志信息的级别和信息字符串），
org.apache.log4j.TTCCLayout（包含日志产生的时间、线程、类别等等信息）
格式化日志信息（当布局为PatternLayout时才可格式化日志信息）
log4j.appender.myConsole.layout.ConversionPattern= [QC] %p [%t] %C.%M(%L) | %m%n
Log4J采用类似C语言中的printf函数的打印格式格式化日志信息，打印参数如下：
%m 输出代码中指定的消息? （m:message）
%p 输出优先级，即DEBUG，INFO，WARN，ERROR，FATAL?? （p: perioty）
%r 输出自应用启动到输出该log信息耗费的毫秒数（r:run）
%c 输出所属的类目，通常就是所在类的全名（c:class）
%t 输出产生该日志事件的线程名，,通常是执行的方法名（t:thread）
%n 输出一个回车换行符，Windows平台为“rn”，Unix平台为“n” （n:enter）
%d 输出日志时间点的日期或时间，默认格式为ISO8601，也可以在其后指定格式，比如：%d{yyyy MMM dd HH:mm:ss,SSS}，输出类似：2002年10月18日 22：10：28，921（d:daytime）
%l 输出日志事件的发生位置，包括类目名、发生的线程，以及在代码中的行数。（l:location）
3. 在程序中使用
//LogTest:当前类，此句是用来给Log提供当前操作的类的相关信息。
Logger logger = Logger.getLogger(LogTest.class.getName());?
PropertyConfigurator.configure ( “E:\\log\\log4j.properties”);
//输出信息，会自动输出到properties文件指定的appender中
logger.debug(“Debug …”);
logger.info(“Info …”);
logger.warn(“Warndsf …”);
logger.error(“Errordsfsd …”);
System.out.println( “*********” );
方法1：打开工程下的.mymetadata文件，将红字部分改成现在的工程名
<project-module
? type=”WEB”
? name=”Copy (2) of lj”
? id=”myeclipse.1240289330453″
? context-root=”/Copy (2) of lj”
? j2ee-spec=”5.0″
? archive=”Copy (2) of lj.war”>
注：id要生成一新的ID，即建立一新的工程，获得其ID (此工程最好没有被deploy过)
?????? copy工程时最好在myeclipse上面进行copy.
?????? 若是在目录下直接copy,那就别忘记了改.project文件的<projectDescription>name
?
简单方法：改完name,context-root, archive后，关闭工程，再重新打开即可!!!!!(i不用再建立新工程生成id)
方法2：
步骤：
（1）. 对工程重命名（选择工程，右键Refactor -> Rename）
（2）. 修改Web路径（选择工程，右键Properties -> MyEclipse -> web,修改Web Context-root的值）
（3）. 修改工程代码（修改替换源程序中涉及到原工程名的地方，通常只在有链接到.do的地方有原工程名。除非你总是习惯写绝对路径）
GET：当客户端要从服务器中读取文档时，使用GET方法。GET方法要求服务器将URL定位的资源放在响应报文的数据部分，回送给客户端。使用GET方法时，请求参数和对应的值附加在URL后面，利用一个问号（“?”）代表URL的结尾与请求参数的开始，传递参数长度受限制。例如，/index.jsp?id=100&op=bind。?
POST：当客户端给服务器提供信息较多时可以使用POST方法。POST方法将请求参数封装在HTTP请求数据中，以名称/值的形式出现，可以传输大量数据。?
对于get,一些浏览器最多只能够处理512KB以内的查询字符串信息。对于POST请求而言，则可以发送2GB的信息，能够很好地满足绝大多数的应用
Servlet三个要素:
1.必须继承自HttpServlet
2.必须实现doGet()或者doPost()
3.必须在web.xml中配置Servlet
<servlet>
<servlet-name> </servlet-name>
<servlet-class> </servlet-class>
</servlet>
<servlet-mapping>
<servlet-name> </servlet-name>
<url-pattern> </url-pattern>
</servelt-mapping>
HttpServeltRrequest:请求对象
getParameter():获得表单元素的值
getAttribute():获得request范围中的属性值
setAttribute():设置reqeust范围中的属性值
setCharacterEncoding():设置字符编码
HttpSerletResponse:相应对象
sendRedirect():外部跳转
getWriter():获得输出流对象
setContentType(“text/html; charset=utf-8”):设置相应内容格式和编码
四种会话跟踪方式:
1.Session
HttpSession session = request.getSession();
session.setAttribute(“name”, “zhangsan”);
session.setAttribute(“pwd”, “aaa”);
String name = (String) session.getAttribute(“name”);
2.cookie:
//创建Cookie
Cookie cookie = new Cookie(“name”, “zhangsan”);
//设置Cookie的超时时间
cookie.setMaxAge(24 * 60 * 60 *60);
//把Cookie发送到客户端
response.addCookie(cookie);
//得到客户端发送的Cookie
Cookie [] cookies = request.getCookies();
for(int i=0; i <cookies.length; i++) {
Cookie temp = cookies[i];
String key = temp.getName();
String value = temp.getValue();
}
3.隐藏表单域
<input type=”hidden” name=”name” value=”zhangsan” />
request.getParameter(“name”);
4.Url重写
问号传参
LoginServlet?username=zhangsan&pwd=123
String name = request.getParameter(“username”);
String pwd =request.getPareameter(“pwd”);
内部跳转:
LoginServlet
request.getRequestDispatcher(“index.jsp”).forward(request, resposne);
外部跳转:
response.sendRedirect(“index.jsp”);
内部跳转是一次请求和一次响应
外部跳转是两次请求和两次响应
ServletContext:Servlet上下文对象
它是一个公共区域,可以被所有的客户端共享
setAttribute():向公共区域里放入数据
getAttribute():从公共区域里取数据
二:
三:三个标准范围:request, session, ServletContext
共同点:都有setAttribute(), getAttribute()
区别:范围不同,request < session < servletContext
四:四种会话跟踪方式
五:服务器上的五大对象
request, response, servlet, session, servletContext
Jsp:Java Server Page
页面构成:7种元素
1.静态内容:html
2.指令:page, include, taglib:
<%@ 指令名 属性1=”属性值1″ 属性2=”属性值2″ %>
3.表达式: <%=表达式 %>
4.Scriptlet <% Java代码 %>
5.声明: <%! %>:变量和方法
6.动作: <jsp:动作名 属性=”属性值”> </jsp:动作名>
7.注释:
客户端看不到的: <%– –%>
客户端可以看到的: <!– –>
Jsp的执行过程:
1.转译:Jsp—>Servlet
2.编译:Servlet—->.class
3.执行:.class
第一次访问jsp的时候响应速度较慢,后面请求时响应速度快
脚本:
表达式: <%= %>
Scriptlet: <% %>
声明: <%! %>
指令:
page:language, import, errorPage, isErrorpage
include:file
taglib:uri:指定标签库描述符的路径 prefix:指定标签的前缀
隐式对象:
分类:
1.输入和输出对象:request(HttpServletRequest),
??????? response(HttpServletResponse),
??????? out(JspWriter), servlet中的out是PrintWriter
2.作用域通信对象:pageContext, request,
??????? session(HttpSession),
??????? application(ServletContext)
3.Servlet对象:page(this), config
4.错误对象:exception
JavaBean:
一个标准的JavaBean有三个条件
1.共有的类
2.具有不带参数的公共的构造方法
3.具有set()和get()方法
4.私有属性
Jsp中的标准动作:
1.useBean:创建JavaBean的一个实例
<jsp:useBean id=”stu” scope=”page/session/application/request” />
2.setProperty:给JavaBean的属性赋值
<jsp:setProperty name=”stu” property=”stuName” value=”zhangsan” />
<jsp:setProperty name=”stu” property=”stuName” param=”txtName” />
value和param不能同时使用
偷懒的方法: <jsp:setProperty name=”stu” property=”*” />
这个时候需要注意的是,表单元素的名字必须和JavaBean的属性值
一模一样
3.getProperty:获得JvaBean的属性值
<jsp:getProperty name=”stu” property=”stuName” />
4.forward:内部跳转,相当于request.getRequestDispatcher().forward(request, response);
<jsp:forward page=”index.jsp” />
5.include:包含
<jsp:include page=”header.jsp” flush=”true” />
表达式语言:
EL: Expression Language
语法格式: ${表达式 }
表示式 = 运算符 + 操作数
运算符:跟Java比较,多了一个empty, 少了一个赋值运算符
${empty “”} : true
${empty null} :true
操作数:
–>常量:布尔型(true/false), 整型, 浮点型, 字符串(可以用”, 还可以用””), Null
–>变量:
1.指的是放在四个标准范围里的属性(page, request, session, application)
2.在编准范围内的搜索顺序:page–>request—>session—>application
3.怎么取得变量值:点运算符., 还以用[]
<%
request.setAttribute(“name”, “lisi”);
%>
${requestScope.name}
或者
${requestScope[“name”]}
–>隐式对象
1.pageContext:通过它可以访问request, session, servletContext
2.跟范围由关的:pageScope, requestScope, sessionScope, applicationScope
3.跟输入有关的:param, paramValues
4.其他的:header, cookie, headervalues,
EL表达式适用的场合:
1.可以在静态文本中使用
2.与自定义标签结合使用
3.和JavaBean结合使用
<jsp:userBean id=”stu” scope=”session” />
<jsp:setProperty name=”stu” property=”stuName” value=”hello” />
${stu.stuName}
自定义标签:
1.标签处理程序实现
—>实现:继承自BodyTagSupport或者TagSupport
? 一般会重写doStartTag(), doEndTag(), doAfterBody()
—>描述:在标签库描述符文件中描述(.tld)
<taglib>
<tlib-version>1.0 </tlib-version>
<jsp-version>2.0 </jsp-version>
<short-name>simpletag </short-name>
<tag>
<name>showbody </name>
<tag-class>com.westaccp.test.ShowBodyTag </tag-class>
<body-content>empty/jsp </body-content>
<attribute>
<name>color </name>
</attribute>
</tag>
</taglib>
—>使用: <%@ taglib uri=”WEB-INF/mytag.tld” prefix=”my” %>
? <my:showbody />
2.标签文件
—>实现和描述
在.tag文件中实现
设置主体内容: <%@ body-content=”empty/scriptless” %>
设置属性: <%@ attribute name=”name” required=”true” rtexprvalue=”true” %>
有主体内容: <jsp:doBody scope=”session” var=”theBody” />
<%
String body = (String) session.getAttribute(“theBody”);
%>
—>使用
WEB-INF/tags/sayhello.tag
<%@ taglib tagdir=”/WEB-INF/tags/” prefix=”you” %>
<you:sayhello />
标准标签库:
1.核心标签库
–>通用:
set: <c:set var=”” value=”” scope=”” />
out: <c:out value=”” />
remove: <c:remove var=”” scope=”” />
–>条件:
if: <c:if test=””>….. </c:if>
choose: <c:choose>
??? <c:when test=””>… </c:when>
??? <c:when test=””>… </c:when>
??? <c:when test=””>… </c:when>
??????? …..
??????? <c:otherwise>… </otherwise>?????????
??? </c:choose>
–>迭代:
forEach: <forEach var=”” items=”” varStatus=”” begin=”” end=””>
foTokens: <foTodens var=”” items=”” delim=”,;|”> </foTodens>
Java,C#;SQL|C
2.I18N与格式化标签库
–>setLocale:设置本地区域
–>bundle:设置资源包
–>setBundle:设置资源包
–>message:输出消息
3.SQL标签库
–>setDataSource:设置数据源,用于获得与数据库的连接
–>query:执行查询
–>update:执行增,删,改
–>transaction:事务
–>param:参数
4.XML标签库
过滤器:
生命周期:
1.实例华:
2.初始化:init()
3.过滤:doFilter()
4.销毁:destroy()
5.不可用
配置:
<filter>
<filter-name> </filter-name>
<filter-class> </filter-class>
</filter>
<filter-mapping>
<filter-name> </filter-name>
<url-pattern> </url-pattern>
</filter-mapping>
几个重要的接口:
1.Filter:init(), doFilter(), destroy()
2.FilterChain: doFilter(request, response)
3.FilterConfig:getFilterName(), getInitParameter(),
过滤器链:—>1—>2—>3—>Servlet 请求
<—-1 <—2 <—3 <—??????? 响应
MvC设计模式
1.ModelI:jsp+JavaBean
2.ModelII:jsp+Servlet+JavaBean
? jsp—view
? servlet—control
? javabean—model
MVC:
M–Model:模型:访问后台数据库
V–view:视图:展示
C–control:控制器:控制程序流程
ModelII和MVC的关系:
MVC是一种设计模式,ModelII它是MVC的一种具体的实现
***********************************************************************
****************
Servlet过滤器是在Java Servlet规范2.3中定义的，它能够对Servlet容器的请求
和响应对象进行检查和修改。
Servlet 过滤器本身并不产生请求和响应对象，它只能提供过滤作用。Servlet过
期能够在Servlet被调用之前检查Request对象，修改 Request Header和Request
内容；在Servlet被调用之后检查Response对象，修改Response Header和
Response内容。
Servlet过期负责过滤的Web组件可以是Servlet、JSP或者HTML文件。
***********************************************************************
****************
二、Servlet过滤器的特点：
***********************************************************************
****************
A．Servlet过滤器可以检查和修改ServletRequest和ServletResponse对象
B．Servlet过滤器可以被指定和特定的URL关联，只有当客户请求访问该URL时，
才会触发过滤器
C．Servlet过滤器可以被串联在一起，形成管道效应，协同修改请求和响应对象
***********************************************************************
****************
三、Servlet过滤器的作用：
***********************************************************************
****************
A．查询请求并作出相应的行动。
B．阻塞请求-响应对，使其不能进一步传递。
C．修改请求的头部和数据。用户可以提供自定义的请求。
D．修改响应的头部和数据。用户可以通过提供定制的响应版本实现。
E．与外部资源进行交互。
***********************************************************************
****************
四、Servlet过滤器的适用场合：
***********************************************************************
****************
A．认证过滤
B．登录和审核过滤
C．图像转换过滤
D．数据压缩过滤
E．加密过滤
F．令牌过滤
G．资源访问触发事件过滤
H．XSL/T过滤
I．Mime-type过滤
***********************************************************************
****************
五、Servlet过滤器接口的构成：
***********************************************************************
****************
所有的Servlet过滤器类都必须实现javax.servlet.Filter接口。这个接口含有3
个过滤器类必须实现的方法：
A.init(FilterConfig)：
这是Servlet过滤器的初始化方法，Servlet容器创建Servlet过滤器实例后将调用
这个方法。在这个方法中可以读取web.xml文件中Servlet过滤器的初始化参数
B.doFilter(ServletRequest,ServletResponse,FilterChain)：
这个方法完成实际的过滤操作，当客户请求访问于过滤器关联的URL时，Servlet
容器将先调用过滤器的doFilter方法。FilterChain参数用于访问后续过滤器
B.destroy()：
Servlet容器在销毁过滤器实例前调用该方法，这个方法中可以释放Servlet过滤
器占用的资源
***********************************************************************
****************
六、Servlet过滤器的创建步骤：
***********************************************************************
****************
A．实现javax.servlet.Filter接口
B．实现init方法，读取过滤器的初始化函数
C．实现doFilter方法，完成对请求或过滤的响应
D．调用FilterChain接口对象的doFilter方法，向后续的过滤器传递请求或响应
E．销毁过滤器
***********************************************************************
****************
七、Servlet过滤器对请求的过滤：
***********************************************************************
****************
A．Servlet容器创建一个过滤器实例
B．过滤器实例调用init方法，读取过滤器的初始化参数
C．过滤器实例调用doFilter方法，根据初始化参数的值判断该请求是否合法
D．如果该请求不合法则阻塞该请求
E．如果该请求合法则调用chain.doFilter方法将该请求向后续传递
***********************************************************************
****************
八、Servlet过滤器对响应的过滤：
***********************************************************************
****************
A．过滤器截获客户端的请求
B．重新封装ServletResponse，在封装后的ServletResponse中提供用户自定义的
输出流
C．将请求向后续传递
D．Web组件产生响应
E．从封装后的ServletResponse中获取用户自定义的输出流
F．将响应内容通过用户自定义的输出流写入到缓冲流中
G．在缓冲流中修改响应的内容后清空缓冲流，输出响应内容
***********************************************************************
****************
九、Servlet过滤器的发布：
***********************************************************************
****************
A．发布Servlet过滤器时，必须在web.xml文件中加入<filter>元素和<filter-
mapping>元素。
B．<filter>元素用来定义一个过滤器：
属性?????????????????? 含义
filter-name??? 指定过滤器的名字
filter-class??? 指定过滤器的类名
init-param??? 为过滤器实例提供初始化参数，可以有多个
C．<filter-mapping>元素用于将过滤器和URL关联：
属性???????????????????? 含义
filter-name??? 指定过滤器的名字
url-pattern??? 指定和过滤器关联的URL，为”/*”表示所有URL
***********************************************************************
****************
十一、Servlet过滤器使用的注意事项
***********************************************************************
****************
A．由于Filter、FilterConfig、FilterChain都是位于javax.servlet包下，并非
HTTP包所特有的，所以其中所用到的请求、响应对象ServletRequest、
ServletResponse在使用前都必须先转换成HttpServletRequest、
HttpServletResponse再进行下一步操作。
B．在web.xml中配置Servlet和Servlet过滤器，应该先声明过滤器元素，再声明
Servlet元素
C．如果要在Servlet中观察过滤器生成的日志，应该确保在server.xml的
localhost对应的<host>元素中配置如下<logger>元素：
<Logger className = “org.apache.catalina.logger.FileLogger”
directory = “logs”prefix = “localhost_log.”suffix=”.txt”
timestamp = “true”/>
***********************************************************************
****************
<welcome-file-list>
<welcome-file>welcome.jsp</welcome-file>
<welcome-file>index.jsp</welcome-file>
</welcome-file-list>
在输入\时发挥作用,无论是根目录还是子目录！
（1）http://192.168.1.66:8080/ 在这种不指定文件的情况下就去访问welcom-file：welcome.jsp若存在，就显示出来，若没有，就接着向下找index.jsp，若都未找到，则显示空页面。
（2） 上面http://192.168.1.66:8080/ 是根目录，其实在子目录下也是如此，如在http://192.168.1.66:8080/news/
它就会去找news下的welcome.jsp, index.jsp文件，并显示。
ps: struts2.0 的一个技巧：让面对”\”时执行*.action,而不是页面
方法：
<welcome-file-list>
<welcome-file>index.action</welcome-file>
<welcome-file>index.jsp</welcome-file>
</welcome-file-list>
(1)? 因在遇到”\’ 时读取 <welcome-file>，它必须已文件存在，故要在目录下建立一个名为index.action的空文件
（2）那么当遇到“\”时,因index.action存在，路径由：”\” 变化了 “\index.action” ,此时在此目录下对应的命名空间下
建立index.action即可。?
要点：在web.xml指定index.action为welcome-file , 在想让执行index.action的目录下建立一空的index.action文件
配置struts.xml,建立index.action
1、Content-Type和Content-Language (显示字符集的设定)
说明：设定页面使用的字符集，用以说明主页制作所使用的文字已经语言，浏览器会根据此来调用相应的字符集显示page内容。
用法：<Meta http-equiv=”Content-Type” Content=”text/html; Charset=gb2312″>
<Meta http-equiv=”Content-Language” Content=”zh-CN”>
注意：该META标签定义了HTML页面所使用的字符集为GB2132，就是国标汉字码。如果将其中的“charset=GB2312”替换成 “BIG5”，则该页面所用的字符集就是繁体中文Big5码。当你浏览一些国外的站点时，IE浏览器会提示你要正确显示该页面需要下载xx语支持。这个功能就是通过读取HTML页面META标签的Content-Type属性而得知需要使用哪种字符集显示该页面的。如果系统里没有装相应的字符集，则 IE就提示下载。其他的语言也对应不同的charset，比如日文的字符集是“iso-2022-jp ”，韩文的是“ks_c_5601”。
Content-Type的Content还可以是：text/xml等文档类型；
Charset选项：ISO-8859-1、BIG5、UTF-8、SHIFT-Jis、Euc、Koi8-2、us-ascii,??
x-mac-roman, iso-8859-2, x-mac-ce, iso-2022-jp, x-sjis, x-euc-jp,
euc-kr, iso-2022-kr, gb2312, gb_2312-80, x-euc-tw, x-cns113-1, x-cns113-2等字符集；
Content-Language的Content还可以是：EN、FR等语言代码。
2、Refresh (刷新)
说明：让网页多长时间（秒）刷新自己，或在多长时间后让网页自动链接到其它网页。
用法：<Meta http-equiv=”Refresh” Content=”30″>
<Meta http-equiv=”Refresh” Content=”5; Url=http://www.xia8.net“>
注意：其中的5是指停留5秒钟后自动刷新到URL网址。
3、Expires (期限)
说明：指定网页在缓存中的过期时间，一旦网页过期，必须到服务器上重新调阅。
用法：<Meta http-equiv=”Expires” Content=”0″>
<Meta http-equiv=”Expires” Content=”Wed, 26 Feb 1997 08:21:57 GMT”>
注意：必须使用GMT的时间格式，或直接设为0(数字表示多少时间后过期)。
4、Pragma (cach模式)
说明：禁止浏览器从本地机的缓存中调阅页面内容。
用法：<Meta http-equiv=”Pragma” Content=”No-cach”>
注意：这样设定，访问者将无法脱机浏览。
5、Set-Cookie (cookie设定)
说明：浏览器访问某个页面时会将它存在缓存中，下次再次访问时就可从缓存中读取，以提高速度。当你希望访问者每次都刷新你广告的图标，或每次都刷新你的计数器，就要禁用缓存了。通常HTML文件没有必要禁用缓存，对于ASP等页面，就可以使用禁用缓存，因为每次看到的页面都是在服务器动态生成的，缓存就失去意义。如果网页过期，那么存盘的cookie将被删除。
用法：<Meta http-equiv=”Set-Cookie” Content=”cookievalue=xxx; expires=Wednesday, 21-Oct-98 16:14:21 GMT; path=/”>
注意：必须使用GMT的时间格式。
6、Window-target (显示窗口的设定)
说明：强制页面在当前窗口以独立页面显示。
用法：<Meta http-equiv=”Widow-target” Content=”_top”>
注意：这个属性是用来防止别人在框架里调用你的页面。Content选项：_blank、_top、_self、_parent。
7、Pics-label (网页RSAC等级评定)
说明：在IE的Internet选项中有一项内容设置，可以防止浏览一些受限制的网站，而网站的限制级别就是通过该参数来设置的。
用法：<META http-equiv=”Pics-label” Contect=”(PICS－1.1′http://www.rsac.org/ratingsv01.html‘
I gen comment ‘RSACi North America Sever’ by ‘inet@microsoft.com‘ for ‘http://www. microsoft.com‘ on ‘1997.06.30T14:21－0500’ r(n0 s0 v0 l0))”>
注意：不要将级别设置的太高。RSAC的评估系统提供了一种用来评价Web站点内容的标准。用户可以设置Microsoft Internet Explorer（IE3.0以上）来排除包含有色情和暴力内容的站点。上面这个例子中的HTML取自Microsoft的主页。代码中的（n 0 s 0 v 0 l 0）表示该站点不包含不健康内容。级别的评定是由RSAC，即美国娱乐委员会的评级机构评定的，如果你想进一步了解RSAC评估系统的等级内容，或者你需要评价自己的网站，可以访问RSAC的站点：http://www.rsac.org/。?
??????????????
8、Page-Enter、Page-Exit (进入与退出)
说明：这个是页面被载入和调出时的一些特效。
用法：<Meta http-equiv=”Page-Enter” Content=”blendTrans(Duration=0.5)”>
<Meta http-equiv=”Page-Exit” Content=”blendTrans(Duration=0.5)”>
注意：blendTrans是动态滤镜的一种，产生渐隐效果。另一种动态滤镜RevealTrans也可以用于页面进入与退出效果:
? ?? ?? ?? ???
<Meta http-equiv=”Page-Enter” Content=”revealTrans(duration=x, transition=y)”>
<Meta http-equiv=”Page-Exit” Content=”revealTrans(duration=x, transition=y)”>
Duration 表示滤镜特效的持续时间(单位：秒)
Transition 滤镜类型。表示使用哪种特效，取值为0-23。
? ?? ?? ?? ???
0 矩形缩小
1 矩形扩大
2 圆形缩小
3 圆形扩大
4 下到上刷新
5 上到下刷新
6 左到右刷新
7 右到左刷新
8 竖百叶窗
9 横百叶窗
10 错位横百叶窗
11 错位竖百叶窗
12 点扩散
13 左右到中间刷新
14 中间到左右刷新
15 中间到上下
16 上下到中间
17 右下到左上
18 右上到左下
19 左上到右下
20 左下到右上
21 横条
22 竖条
23 以上22种随机选择一种
9、MSThemeCompatible (XP主题)
说明：是否在IE中关闭 xp 的主题
用法：<Meta http-equiv=”MSThemeCompatible” Content=”Yes”>
注意：关闭 xp 的蓝色立体按钮系统显示样式，从而和win2k 很象。
10、IE6 (页面生成器)
说明：页面生成器generator，是ie6
用法：<Meta http-equiv=”IE6″ Content=”Generator”>
注意：用什么东西做的，类似商品出厂厂商。
11、Content-Script-Type (脚本相关)
说明：这是近来W3C的规范，指明页面中脚本的类型。
用法：<Meta http-equiv=”Content-Script-Type” Content=”text/javascript”>
Servlet和Filter的url匹配以及url-pattern
一，servlet容器对url的匹配过程：
当一个请求发送到servlet容器的时候，容器先会将请求的url减去当前应用上下文的路径作为servlet的映射url，比如我访问的是http://localhost/test/aaa.html，我的应用上下文是test，容器会将http://localhost/test去掉，剩下的/aaa.html部分拿来做servlet的映射匹配。这个映射匹配过程是有顺序的，而且当有一个servlet匹配成功以后，就不会去理会剩下的servlet了（filter不同，后文会提到）。其匹配规则和顺序如下：
1.???? 精确路径匹配。例子：比如servletA 的url-pattern为 /test，servletB的url-pattern为 /* ，这个时候，如果我访问的url为http://localhost/test ，这个时候容器就会先 进行精确路径匹配，发现/test正好被servletA精确匹配，那么就去调用servletA，也不会去理会其他的servlet了。
2.???? 最长路径匹配。例子：servletA的url-pattern为/test/*，而servletB的url-pattern为/test/a/*，此时访问http://localhost/test/a时，容器会选择路径最长的servlet来匹配，也就是这里的servletB。
3.???? 扩展匹配，如果url最后一段包含扩展，容器将会根据扩展选择合适的servlet。例子：servletA的url-pattern：*.action
4.???? 如果前面三条规则都没有找到一个servlet，容器会根据url选择对应的请求资源。如果应用定义了一个default servlet，则容器会将请求丢给default servlet（什么是default servlet？后面会讲）。
根据这个规则表，就能很清楚的知道servlet的匹配过程，所以定义servlet的时候也要考虑url-pattern的写法，以免出错。
对于filter，不会像servlet那样只匹配一个servlet，因为filter的集合是一个链，所以只会有处理的顺序不同，而不会出现只选择一个filter。Filter的处理顺序和filter-mapping在web.xml中定义的顺序相同。
二，url-pattern详解
?在web.xml文件中，以下语法用于定义映射：
l? 以”/’开头和以”/*”结尾的是用来做路径映射的。
l? 以前缀”*.”开头的是用来做扩展映射的。
l? “/” 是用来定义default servlet映射的。
l? 剩下的都是用来定义详细映射的。比如： /aa/bb/cc.action
所以，为什么定义”/*.action”这样一个看起来很正常的匹配会错？因为这个匹配即属于路径映射，也属于扩展映射，导致容器无法判断。
四种共同点：
对一类url,或所有url进行业务处理
对各种url之类进行匹配，查找，执行相应操作，与action相比较而言，action只能针对某一特定的url进行匹配，进行操作 如: