DWR+Spring+Hibernate配置文件1217

Dwr.xml模板:
<?xml version="1.0" encoding="UTF-8"?><!-- 说明这是一个xml文档，1.0版本，文档采用UTF-8的编码格式 -->
<!DOCTYPE dwr PUBLIC "-//GetAhead Limited//DTD Direct Web Remoting 2.0//EN" "http://getahead.ltd.uk/dwr/dwr20.dtd">
<!-- 说明这个xml文档要遵循的格式是dwr配置文件的格式，格式要求要符合"http://getahead.ltd.uk/dwr/dwr20.dtd"的格式 -->
<dwr><!-- dwr标签内的内容将被dwr解析，而且dwr内的格式要严格遵循dwr的格式要求 -->
  <allow>  
   <!-- allow内，放置dwr要转化成js的class，以及每个class要用到的javabean 
   allow内主要的标签式：
   		create	:用于将后台class变成前台的js方法
   		convert :用于转换后台class方法用到的javabean对象。
   -->  
	<create creator="spring" javascript="LabelManageAction" scope="application">
		<param name="beanName" value="labelManageAction" />
	</create>
	<!-- create标签的作用和用法：
		作用：用于将后台class变成前台的js方法
		creator:指定采取哪种创建方式，主流的要两个：new 和 spring，new的方式是每次都通过new一个实例化对象，然后返回该实例，spring是采用spring的管理放置创建对象
		javascript：指定在前台调用的名称。根据经验，最好和后台的class是同名，便于使用开发工具快速查找。必填。
		scope:js方法的作用域。包括：page,request,session.application四个作用域。scope是可选属性，默认是page。
		creator标签的子标签param：该标签式用来定义creator标签的部分参数的。
		param标签的name属性：指定参数名称，通常情况下，如果创造器采用new,那么param的name属性通常是class，表示参数calss需要指定值，value属性指定哪个后台class
			如果采用spring的构造器，那么param的name属性通常是beanName，value属性指定是哪个spring的bean。
		createor标签的include子标签和exclude子标签：
			<include method="funName1,funName2,funName3"/> 显示定义前台可以访问的方法只有funName1,funName2和funName3三个方法，其他的方法在前台将访问不到。
			</exclude method="funName1,funName2,funName3"> 显示定义前台不可以访问的方法有funName1,funName2和funName3三个方法，其他的方法在前台可以访问到。
			默认情况下可以访问所有的后台方法。
	 -->
    <convert converter="bean" match="org.jasig.cas.bean.CasUser"/>
    <!-- convert转换器的作用和使用方法：
    	作用：将自定义的javabean对象映射成dwr可以解析的对象，(基本数据类型例如String，Integer等等dwr已经自己映射)
    	convert的converter属性和match属性都比较固定：converter="bean" match="your.full.package.beanName"
    	我们经常用到的就是bean转换器。该转换器可以将后台的标准的带有getter和setter方法的javabean对象转换成js对象
		然后用match属性指定匹配对象，指向后台javabean。
		简写：<convert converter="bean" match="your.full.package.*"> 这样将转换包内所有的javabean。  	
     -->
  </allow>
  <signatures>
    <![CDATA[ 
    import java.util.*;
  	import javax.servlet.http.HttpServletRequest;
  	
	]]>
</signatures>
    <!-- signatures 标签是用来让dwr明确集合中存放的数据类型的。
    例如：demo.class有一个test(List<User> list)方法，为让dwr明确test方法的List参数中存放的是什么类型的对象，
    我们会用到signatures标签。用法：
    <signatures>
    <![CDATA[ 
    import java.util.List;//或者 import java.util.*;
  	import com.demo;//引入class
  	import com.bean.User;//引入javabean
  	demo.test(List<User> list);//指定泛型的存储的类型是User对象。
	]]>
    </signatures>
    --!>
</dwr>



Spring配置hibernate数据连接.xml模板：

<?xml version="1.0" encoding="UTF-8"?>
<!-- 说明该文档是xml文档，1.0版本 采用UTF-8的字符编码格式。-->
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN/EN"
	"http://www.springframework.org/dtd/spring-beans.dtd">
<!-- 声明beans标签 beans标签严格按照spring-beans.dtd的格式定义 -->
<!--$Id: applicationContext-hibernate.xml,v 1.1 2009/11/10 03:51:09 zhangya Exp $-->
<beans>
<!-- beans内的标签，格式要严格遵循spring-beans.dtd的定义，对于正确定义的标签，
	spring都会按照既定定义的含义去进行解析。
	beans的主要子标签：	bean。beans标签中只有一个子标签：bean，而且该bean子标签严格按按照spring-beans.dtd的
	定义进行编辑。
	bean的主要属性：
		id：  该bean的id。
		class：和spring注入java类一样，需要制定该bean的class，只不过class是spring自身的java类。
	bean的主要子标签：
		property：每一个java类会有不同的属性property，初始化java类的时候需要初始化属性，spring-beans.dtd要求
			可以使用property子标签进行属性初始化，并使用property的子标签value进行赋值或者使用property的value属性
			进行赋值。
 -->
	<bean id="propertyConfigurer"
		class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
		<!-- 声明一个 配置文件地址文件夹配置器 类，该类主要有一个参数：location，location指定该类去哪里读取配置文件
		配置文件配置类就会对该property文件进行读取。
		-->
		<!-- 数据库信息文件 -->
		<property name="location">
			<value>WEB-INF/hibernate.properties</value>
		</property>
		<!-- 给配置文件配置器 的属性：location赋值，即制定让该类去读取这个property配置文件，然后会将配置文件爱你
		的内容载入缓存，随时可以提取使用。
		经过这样的配置，我们得到了本程序的主要配置信息，主要就是数据库配置信息。 -->
	</bean>
	
    <!-- 数据源 -->
	<bean id="dataSource"
		class="org.apache.commons.dbcp.BasicDataSource"
		destroy-method="close">
		<!-- 声明一个基础数据源对象，并指定当调用该类的close方法是，销毁该基础数据源对象。
		spring的基础数据源对象应该可以获得时下流行所有的主流数据库，可以建立和各个数据库的桥接。
		作为web应用的数据源，为web应用提供数据。 
		 -->
		<property name="driverClassName">
			<value>${driverClassName}</value>
		</property>
		<!-- 配置基础数据源的驱动类名称属性，该属性指明用哪种数据库驱动去连接数据库，也就指定了
		你用的是那种数据库，value来自原上边的配置文件配置器从配置文件hibernate.properties读取的内容。
		hibernate.properties以键值对的方式定义一些属性变量。 -->
		<property name="url">
			<value>${url}</value>
		</property>
		<!-- 配置基础数据源对象的url，url是数据库连接字符串 -->
		<property name="username">
			<value>${username}</value>
		</property>
		<!-- 配置基础数据源对象的用户名，也就是数据库的用户名 -->
		<property name="password">
			<value>${password}</value>
		</property>
		<!-- 配置基础数据库对象的密码，也就是数据库的密码。 -->
		<!-- 以上配置属性的值都来自于属性配置器，所以属性配置器对象的声明要在基础数据源对象之前。
		经过这样的配置，现在我们得到了数据源了，可以向web程序提供数据了。
		 -->
	</bean>
	
	<!-- 处理CLOB对象 -->
	<bean id="nativeJdbcExtractor" 	class="org.springframework.jdbc.support.nativejdbc.CommonsDbcpNativeJdbcExtractor"
		lazy-init="true" />
	<bean id="lobHandler" class="org.springframework.jdbc.support.lob.OracleLobHandler"
		lazy-init="true">
		<property name="nativeJdbcExtractor">
			<ref local="nativeJdbcExtractor" />
		</property>
	</bean>
	
	<!-- sessionFactory -->
	<bean id="sessionFactory" 
	    class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
	  <!-- 声明一个本地session会话工厂对象，用来创建会话对象：每一个会话对象可以看成一个数据库连接。 
	  会话对象主要的属性：
	  dataSource：指定会话对象的数据源对象。就是让应用和这个数据源会话，也就是从这个数据源取数据。
	  lobHandler：什么什么处理器？？？
	  mappingResources：映射的资源文件，主要是heibernate的hbm文件。 	每一个资源文件的作用就是说明：web应用中的javabean的class对应的是数据库中的哪个表table，所以，
	  		对应这个javabean的查询，添加，删除的操作就是对相应的表的操作。
	  hibernateProperties:heibernate的配置信息，主要配置在系统运行时hibernate的参数
	  -->
		<property name="dataSource">
			<ref local="dataSource" />
		</property>
	<!-- 会话对象需 -->
		
		<!-- 处理CLOB对象 -->
		<property name="lobHandler" ref="lobHandler" />
		<property name="mappingResources">
<list> <value>org/hdht/business/uim/config/Role.hbm.xml</value>       	<value>org/hdht/business/uim/config/RoleModule.hbm.xml</value>   	<value>org/hdht/business/uim/config/UserModule.hbm.xml</value>   
			</list>
		</property>
		<property name="hibernateProperties">
			<props>
				<prop key="hibernate.dialect">
					${hibernate.dialect}
				</prop>
				<prop key="hibernate.show_sql">
					${hibernate.show_sql}
				</prop>
				<prop key="hibernate.jdbc.batch_size">
					${hibernate.jdbc.batch_size}
				</prop>	
				<prop key="hibernate.cache.provider_class">
					${hibernate.cache.provider_class}
				</prop>
				<prop key="hibernate.hbm2ddl.auto">update</prop>
			</props>
		</property>
	</bean>	
	<!-- 通过这样设置，现在我们创建了session会话工厂对象，并将sesson工厂和基础数据源联系到一起。
		session工厂用来连接数据库，和数据库进行会话，通过对hibernate的资源的映射实现了系统java类和数据库
		的table的关联。并通过配置hibernate的属性来控制hibernate运行时的参数。
	 -->
	<!-- 配置事务管理器bean -->
    <bean id="transactionManager"
         class="org.springframework.orm.hibernate3.HibernateTransactionManager">
        <!-- 声明一个heberante的事务管理器对象，该对象主要用来管理hibernate的事务的。
        	事务管理器对象有一个属性：sessionFactory会话工厂。
        	这样配置后，就是说：和这个事务管理器绑定的session会化工厂里的方法都采取了事务处理。
        	至于怎么就采取了事务处理以及在哪里进行了事务处理，还不知道。
         -->
        <property name="sessionFactory" ref="sessionFactory"/>
    </bean>

</beans>


Spring配置bean文件
<?xml version="1.0" encoding="UTF-8"?>
<!-- 声明该文档时xml文档 1.0版本 文档采用UTF-8的编码格式。 -->
<beans xmlns="http://www.springframework.org/schema/beans"
		xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
		xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd">
  <!-- 定义beans标签 这种定义方式同<!DOCTYPE >的作用是一样的，要求该beans标签的内容和格式
  	严格按照spring-beans.dtd定义的格式。否则就出错。
  -->
	<bean id="operateLogDao"  class="org.hdht.commonweb.logger.operatelog.dao.OperateLogDAO" autowire="byName" />
	<!--beans的唯一子标签：bean。
		bean标签的作用是将制定的后台calss注入到IOC容器中。(IOC其实类似于一个Map)
		bean标签的主要属性：
			id：对象的唯一标示，id将会放到IOC容器中，作为键Key
			class：对象的java类所在的路径 spring需要根据class参数去初始化bean。
			autowire：spring自动装配对象属性的参数，默认是no，就是不自动装配属性。那样，如果这个bean的属性是其他的bean
				就需要你手动显示配置属性，通常是通过<property name="properName" ref="beanName">来实现的，
				如果该bean有很多属性，那么就要写很多<property/>标签，使用autowire就解决了这个问题。
				autowire="byName"：表示根据bean的id或者name自动装配对象的属性。spring会根据属性的名字在IOC容器中寻找id和该属性的name一致的bean，
				并将这个bean自动装配到目标对象的属性，
				例如：spring IOC容器中bean A有一个属性是自定义的java类：B，属性名称叫b，自定义java类B在IOC容器中的bean的id是B，
				那么spring就会在IOC容器中找id=B的bean，并将该bean注入给A的属性B。这就完成了属性自动装配。
	  -->
	<bean id="baseDao" class="org.hdht.commonweb.basedao.BaseHibernateDAO"  autowire="byName" />
</beans>


Spring的事务配置：
<?xml version="1.0" encoding="UTF-8"?>
<!-- 定义该文档是xml文档 该xml文档是1.0版本 该xml文档使用的是UTF-8的字符编码格式 -->
<beans 	xmlns="http://www.springframework.org/schema/beans" 
		xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
		xmlns:aop="http://www.springframework.org/schema/aop"
		xmlns:tx="http://www.springframework.org/schema/tx"
		xsi:schemaLocation="
		 http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd 
		 http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.0.xsd 
		 http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.0.xsd
		 ">
	  <!--定义beans标签，以及beans内部的自定义标签的格式标准，该文档主要是配置事务，所有重点讨论aop和tx两个标签。  -->   
    	<!-- 配置事务管理器bean -->
    <bean id="transactionManager"
         class="org.springframework.orm.hibernate3.HibernateTransactionManager">
        <property name="sessionFactory" ref="sessionFactory"/>
    </bean>
	<!-- 
		aop:config标签的作用是配置一个切面，和需要拦截的类和方法.经过上边的配置达到的效果是：
		org.hdth包下边的以"Logic"结尾的class里边的方法名称为任何名称的方法，将按照txAdvice通知的规则执行事务。
	-->
	<tx:advice id="txAdvice" transaction-manager="transactionManager">
	<!-- 
		tx:advice标签的作用是:定义事务的属性，或者可以说定义可以走事务方法的属性。更准且的说是定义：什么样的方法对应走什么样的事物。
		其中，<tx:attributes>定义了事务的属性，也就是定义了走事务方法的属性。已知的属性就是方法的名称一个属性。规则：
		定义方法的开始字符，并可以使用"*"号代替方法名称的其他部分。当切面中的方法符合这些方法名称的要求的时候，就会自动走事务处理。
		默认情况下，方法的只读属性应该是false(猜测的)，对于查询方法不需要起事务，为了节省资源，应该显示配置查询方法的只读事务属性为true。
		tx:advice的主要属性：
		id：通知对象的标示id
		transaction-manager:指定该事务通知由哪个事务处理器处理。事务处理器的定义有很多种。
	 -->
		<tx:attributes>
			<tx:method name="insert*"/>
			<tx:method name="update*"/>
			<tx:method name="save*"/>
			<tx:method name="add*"/>
			<tx:method name="remove*"/>
			<tx:method name="delete*"/>
			<tx:method name="modify*"/>
			<tx:method name="change*"/>	
			<tx:method name="reset*"/>
			<tx:method name="recycle*"/>
			<tx:method name="audit*"/>	
		<tx:method name="merger*"/>
					
			<!-- 查询方法的事务配置成只读的 -->
			<tx:method name="get*"/>
			<tx:method name="list*"/>
			<tx:method name="find*" read-only="true"/>
			<tx:method name="load*" read-only="true"/>
			<tx:method name="search*" read-only="true"/>
			<tx:method name="*" read-only="true"/>
		</tx:attributes>
	</tx:advice>
	<!-- 在此之前，应该先 配置事务管理器，这部分的内容在两外一个xml文件配置了大概如下：(实际有很多中配置事物的方法，此处仅是一种而已。)
	 配置事务管理器bean ：
    <bean id="transactionManager"
        class="org.springframework.orm.hibernate3.HibernateTransactionManager">
        <property name="sessionFactory" ref="sessionFactory"/>
    </bean>
    所以猜测：所有的spring配置文档内的东西都是通用的，spring会将所有的配置文档统一整理，就好比这些文档都写在一个配置文件中一样。
     -->
	<aop:config proxy-target-class="true">
		<aop:advisor pointcut="execution(* org.hdht..*Logic.*(..))" advice-ref="txAdvice"/>
		<!-- aop:advisor的作用是构造一个通知，通知的的切面有pointcut指定。
		aop:advisor的属性说明：
		pointcut:该属性用来构造切面，切面的概念就是指定某一些后台java类中的一些方法或者是映射后台一部分的java类的一些方法，总之，最后从后台
			单独映射出一些java方法(重点在是方法上)。\
			格式：execution(* your.full.package.*(..)) 也可以简化为：execution(* your..*pkname.*(..)) 
				说明：第一个*号不明白，似乎是必须有的，这个表达式中的两个"."号似乎就是省略号，意思是模糊路径。"*pkname"是说所有以"pkname"结尾的包。
				".*(..)"的意思是，该包内的所有的方法，”(..)“表示带有任意类型和个数的参数的方法。
		adviec-ref:该属性用来说明已经指定的切面(就是一部分java类的一些方法)根据什么"通知"规则使用spring的事务。实际应用过程中，主要是指定方法以什么字符开头。
		 -->
	</aop:config>
	<bean class="org.hdht.commonweb.ApplicationContextHolder" lazy-init="false"/>
</beans>



Web.xml

<?xml version="1.0" encoding="UTF-8"?>
<!-- 声明xml文档，版本和字符编码 -->
<web-app id="space" version="2.4"
		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">
<!-- 声明web-app标签 属性说明： 
	id：对象id
	version：该web-app的版本。
	xmlns：j2ee的标准。
	xmlns:xsi：实例化有关。
	xsi:schemaLocation：文档的概要，或者说文档的格式约束。类似于模板，文档内的内容必须遵循web-app_2_4.xsd的描述和规则
	通过上边web-app的配置：我们在该xml文档中声明一个web-app标签，该标签采取j2ee的标准。所以web-app内的信息将被当做web应用程序的配置信息。
 -->
	<context-param>
		<param-name>contextConfigLocation</param-name>
		<param-value>/WEB-INF/applicationContext-*.xml</param-value>
	</context-param>
	<!--context-param上下文参数标签:定义程序运行过程中用到的变量和变量的值。也就是初始化应用程序参数
		context-param的子标签：
		param-name：上下文参数的名称。(这些名称是将j2ee web应用固定的参数名称。不是谁随便写的。)
					contextConfigLocation 参数:用来定义上下文配置文件的路径。被指定的文件都会在应用启动的时候被解析。
 		param-value:上下文参数的值。
 					/WEB-INF/applicationContext-*.xml 表示WEB-INF目录下的名称以"application-*"开头的xml文件都将作为本web应用的配置文件。
 					系统会解析所有的xml文件。
 	通过上边context-param的配置：我们指定了本web应用的应用配置文件。文件的位置在WEB-INF下，名称以"application-*"开头的所有xml文件。
 	-->

	<session-config> 
		<session-timeout>30</session-timeout> 
	</session-config>
	<!-- session-config配置的是本web应用的会话失效时间(单位是分钟)，在该时间内，如果用户没有任何操作，本次会话将失效。 
		功过上边session-config的设置：我们规定了，本web应用的会话失效时间是30分钟。
	-->
	<!--filter过滤器的作用：配置指定格式的文件都要进过什么样式的处理，或者配置指定后缀的文件都要经过怎样的过滤。
		字符编码过滤器:由于会用到大量的中文字符，所以对应用的文件要进行中文编码的设置。第一步是在页面的设置，但是动态的返回值和信息可能也有
		中文，这样就要要求对动态的数据也进行中文编码过滤，于是就要用到中文编码过滤器。
		过滤器的使用是先声明name，然后通过mapping映射到指定后缀的文件。
	-->
	<filter>
		<filter-name>encodingFilter</filter-name>
		<!-- 声明过滤器的名称 -->
		<filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
		<!-- 过滤器的类 也可以自己写过滤器，但是spring已经给你写好了，直接用就可以了。
			spring的字符编码顾虑是可以动态配置的，所以在使用的时候需要初始化参数，这些参数是通过init-param注入的。
			init-param的使用：
				子标签param-name:指定初始化参数的名称
				子标签param-value：指定初始化参数的值。
		 -->
		<init-param>
			<param-name>encoding</param-name>
			<!-- 初始化参数名称：encoding 指定编码格式 -->
			<param-value>UTF-8</param-value>
			<!-- encoding字符编码的值：国际字符编码的标准编码格式，大概有UTF-8,gb3212,GBK等等 -->
		</init-param>
		<init-param>
			<param-name>forceEncoding</param-name>
			<!-- 初始化参数名臣：forceEncoding 强行转换 -->
			<param-value>true</param-value>
			<!-- forceEncoding到值：true或者false true采用强行转化字符编码，false不采用强行转换字符编码 -->
		</init-param>
	</filter>
		<!-- 通过上边filter的配置：我们声明了一个过滤器，该过滤器的实例化对象是spring的字符编码过滤器，所以这个过滤器是
		一个字符编码过滤器，通过对该过滤器的初始化参数encoding的配置，我们将这个过滤器的字符编码配置成UTF-8， 通过对参数forceEcoding的配置，
		采取使用强行字符转化-->
		
	<!--filter-mapping的作用：将一个已经存在的过滤器映射到指定格式的文件上。也就是指定什么后缀的文件将采用这个过滤器。 
		子标签说明：
		filter-name:指定过滤器的名称。过滤器名称的声明要求在filter-mapping之前
		filter-pattern：过滤器的映射路径。该路径内的指定格式的文件爱你或者所有文件将采用filter-name指定的过滤器。
				partter常用的格式：/dwr/*表示一个包内所有的文件，*.jsp,*.do表示以jsp和do结尾的文件。
	-->	
	<filter-mapping>
		<filter-name>encodingFilter</filter-name>
		<!-- 过滤器名称 -->
		<url-pattern>/dwr/*</url-pattern>
		<!-- 过滤器映射的文件路径：dwr下的所有文件。 -->
	</filter-mapping>
	<filter-mapping>
		<filter-name>encodingFilter</filter-name>
		<url-pattern>*.jsp</url-pattern>
		<!-- 过滤器映射的文件路径：所有jsp文件。 -->
	</filter-mapping>
	<filter-mapping>
		<filter-name>encodingFilter</filter-name>
		<url-pattern>*.do</url-pattern>
		<!-- 过滤器映射的文件路径：所有.do文件。 -->
	</filter-mapping>
	<!-- 通过三个filter-mapping的配置：我们指定了之前配置的字符编码过滤器的映射文件时：
		dwr包内所有的文件，所有的jsp文件和所有的.do文件。
	 -->
	
	<filter>
		<filter-name>headerFilter</filter-name>
		<!-- 声明一个过滤器 名字叫：headerFilter 顾名思义是用来过滤文件头部的 -->
		<filter-class>org.hdht.commonweb.filter.HeaderFilter</filter-class>
		<!-- 过滤器的实例化类是自定义的过滤器：关键代码：
public class HeaderFilter implements Filter {
	public void init(FilterConfig arg0) throws ServletException {
	}
	public void doFilter(ServletRequest req, ServletResponse res,
			FilterChain chain) throws IOException, ServletException {
		HttpServletRequest request = (HttpServletRequest) req;
		HttpServletResponse response = (HttpServletResponse) res;
		response.setHeader("Pragma", "no-cache");
		response.setHeader("Cache-Control", "no-store, no-cache, must-revalidate");
		response.setHeader("Expires", "-1");
		chain.doFilter(req, res);
	}
	public void destroy() {
	}
}		
	通过上边filter的配置：我们配置了一个自定义的过滤器，过滤器的名字是headerFilter，实例化类似自定义的类：HearderFilter，该过滤器的主要作用是
	对设置页面不采用缓存。
 -->
	</filter>
  	<filter-mapping>
		<filter-name>headerFilter</filter-name>
		<!-- 过滤器映射名称 -->
		<url-pattern>*.jsp</url-pattern>
		<!-- 过滤器映射文件：所有的jsp文件。 -->
	</filter-mapping>
	<!-- 通过上边的ffilter-mapping的配置： 我们将过滤器headerFilter映射到所有的jsp文件。这样所有的jsp文件的头部就都会设置
	不适用缓存处理页面。这个过滤器主要用于经常和数据库有交互的页面中。-->
	
	<!-- 权限过滤器：判断用户是否登录的过滤器 -->
	<filter>
	  <filter-name>uimfilter</filter-name>
	  <!--声明一个过滤器的：uimfilter 主要的作用是检测用户是否登录 -->
	  <filter-class>org.hdht.commonweb.filter.PermissionFilter</filter-class>
	  <!-- uimfilter过滤器的实例化类 是自定义的过滤器类
	  	java代码主要是对session进行判断，判断表示用户登录的session变量是否存在，如果不存在就重定向到登陆界面。
	  通过上边filter的配置：我们定义了一个名字叫做uimfilter的权限过滤器，这个过滤器的实例化类是自定义的java类，
	  主要对用户是否登录做出判断，并根据判断结果作相应的处理：继续操作还是重定向登录
	   -->
	</filter>
	<filter-mapping>
	  <filter-name>uimfilter</filter-name>
	  <url-pattern>*.jsp</url-pattern>
	  <!-- 将权限过滤器映射给所有的jsp文件 -->
	</filter-mapping>
	<filter-mapping>
	  <filter-name>uimfilter</filter-name>
	  <url-pattern>/dwr/*</url-pattern>
	  <!-- 将权限过滤器映射给dwr包内的所有文件 -->
	</filter-mapping>
	<filter-mapping>
	  <filter-name>uimfilter</filter-name>
	  <url-pattern>*.do</url-pattern>
	  <!-- 将权限过滤器映射给所有的.do文件 -->
	</filter-mapping>
	<!-- 通过上边filter-mapping的配置：我们将uimfilter过滤器映射给所有的jsp文件，dwr包内的所有文件爱你以及.do文件
	这样，当用户进入到jsp文件或者调用dwr或者有action的操作的时候，系统就会对用户是否登录进行判断。
	 -->
  	<!-- 耶鲁CAS-SSO客户端单点登陆过滤器
  	<filter>
		<filter-name>CASFilter</filter-name>
		<filter-class>edu.yale.its.tp.cas.client.filter.CASFilter</filter-class>
		<init-param>
			<param-name>edu.yale.its.tp.cas.client.filter.loginUrl</param-name>
			<param-value>https://computer:8443/casServer/login</param-value>
		</init-param>
		<init-param>
			<param-name>edu.yale.its.tp.cas.client.filter.validateUrl</param-name>
			<param-value>https://computer:8443/casServer/proxyValidate</param-value>
		</init-param>
		<init-param>
			<param-name>edu.yale.its.tp.cas.client.filter.serverName</param-name>
			<param-value>localhost:8080</param-value>
		</init-param>
    </filter>
    <filter-mapping>
        <filter-name>CASFilter</filter-name>
        <url-pattern>/manager/app/*</url-pattern>
    </filter-mapping> 
     -->
	<!-- 防止出现 Session关闭异常的 过滤器  -->
	<filter>
	   <filter-name>hibernateFilter</filter-name>
	   <filter-class>org.springframework.orm.hibernate3.support.OpenSessionInViewFilter</filter-class>
	</filter>
    <filter-mapping>
		<filter-name>hibernateFilter</filter-name>
		<url-pattern>/*</url-pattern>
	</filter-mapping>
	
    <!-- Strtus2.0 控制过滤器  -->
	<filter>
		<filter-name>struts</filter-name>
		<filter-class>org.apache.struts2.dispatcher.FilterDispatcher</filter-class>
	</filter>
	<filter-mapping>
		<filter-name>struts</filter-name>
		<url-pattern>/business/*</url-pattern>
		<url-pattern>/common/*</url-pattern>
		<url-pattern>/system/*</url-pattern>
		<url-pattern>/login.jsp</url-pattern>
		<url-pattern>/loginback.jsp</url-pattern>
		<url-pattern>/main.jsp</url-pattern>
		<url-pattern>/index.jsp</url-pattern>
		<url-pattern>*.do</url-pattern>
	</filter-mapping>
<!-- 监听器的配置：监听器配置完以后，应用系统在启动的时候就会开启这些监听器。
	监听器的理解：监听器好比一个卫兵，卫兵一直站在那里等待长官的命令，当卫兵收到长官的命令以后，立即执行
	之前已经协定好的事件。
	java中的监听器，监听应用的事件，具体有什么事件，以及对每个事件的处理方式都在类中定义了，
	所以，监听器不需要参数、不具有返回值只是一味的等待指令然后执行既定的名利，也就是执行相应的操作，
	也就是说，监听器一旦写完，只是拿过来用就可以，没有方法，没有get set，没有参数，只使用其他什么都没有。
	还是不大理解 以后再了解了解
 -->
	<listener>
		<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
		<!--使用spring的上下文加载监听器：可能的作用是：在web应用加载系统应用资源文件，也就是加载那些xml文件的时候，
		会建立一些监听器。譬如监听xml文件内容的变化
		  -->
	</listener>
	<listener>
		<listener-class>org.springframework.web.context.request.RequestContextListener</listener-class>
		<!-- 实例化一个spring的关于请求的上下文的监听器 -->
	</listener>
	<listener>
		<listener-class>org.hdht.commonweb.listener.MyServletContextListener</listener-class>
		<!-- 实例化一个自定义的监听器。监听器主要代码
public class MyServletContextListener implements ServletContextListener {
	public void contextDestroyed(ServletContextEvent arg0) {
	}
	public void contextInitialized(ServletContextEvent arg0) {
		try {
			// 初始化日志处理器
			AppLogService.init();//初始化系统用到的变量，主要是静态变量。
			System.out.println("INFO:数据初始化完毕");//djflag
			
		} catch (Exception e) {
			AppLogService.error("系统初始化错误！",e);
		}
	}
}
这是一个继承了服务器上下文监听器接口的监听器，这个监听器主要有两个必须实现的方法：
	contextInitialized：当web服务器启动时执行的方法，该方法主要用来初始化系统的变量，多半是静态变量。	
	contextDestroyed：当web服务器关闭的时候调用的方法，主要是销毁一些内存变量，释放资源。
		 -->
	</listener>
	<!-- Ajax调用 -->
	<servlet>
	  <servlet-name>datatransfer</servlet-name>
	  <servlet-class>org.hdht.commonweb.datatransfer.SimpleAJAX</servlet-class>
	  <load-on-startup>1</load-on-startup>
	</servlet>
	
	<servlet-mapping>
	  <servlet-name>datatransfer</servlet-name>
	  <url-pattern>*.data</url-pattern>
	</servlet-mapping>
	<!-- 验证码  -->
	<servlet>
	  <servlet-name>ImageCheckServlet</servlet-name>
	  <servlet-class>org.hdht.commonapp.imager.ImagerServlet</servlet-class>
	</servlet>
	
	<servlet-mapping>
	  <servlet-name>ImageCheckServlet</servlet-name>
	  <url-pattern>*.imager</url-pattern>
	</servlet-mapping>
	
	<!-- DWR servlet -->
	<servlet>
	  <servlet-name>dwr-invoker</servlet-name>
	  <servlet-class>org.directwebremoting.servlet.DwrServlet</servlet-class>
	  <init-param>
	    <param-name>debug</param-name>
	    <param-value>true</param-value>
	  </init-param>
	  <init-param>
	    <param-name>pollAndCometEnabled</param-name>
	    <param-value>true</param-value>
	  </init-param>
      <init-param>   
           <param-name>crossDomainSessionSecurity</param-name>   
           <param-value>false</param-value>   
      </init-param>
	  <load-on-startup>1</load-on-startup>
	</servlet>
	
	<servlet-mapping>
	  <servlet-name>dwr-invoker</servlet-name>
	  <url-pattern>/dwr/*</url-pattern>
	</servlet-mapping>
	  
	<!-- XFire servlet -->
	<servlet>
	  <servlet-name>XFireServlet</servlet-name>
	  <servlet-class>org.codehaus.xfire.transport.http.XFireConfigurableServlet</servlet-class>
	  <load-on-startup>0</load-on-startup>
	</servlet>

	<servlet-mapping>
	  <servlet-name>XFireServlet</servlet-name>
	  <url-pattern>/services/*</url-pattern>
	</servlet-mapping>

	<!-- ntong上传文件 -->
	<servlet>
		<description>Downloading and uploading attachment</description>
		<display-name>AttachmentServlet</display-name>
		<servlet-name>AttachmentServlet</servlet-name>
		<servlet-class>com.ntong.AttachmentServlet</servlet-class>
	</servlet>
	<servlet-mapping>
		<servlet-name>AttachmentServlet</servlet-name>
		<url-pattern>/ntong/attachment/*</url-pattern>
	</servlet-mapping>
<!-- 应用的欢迎页面  采用list的方式罗列欢迎页面，
系统会从第一个找到最后一个，找到了文件就不继续往下找了。优先显示前边的。
 -->
	<welcome-file-list>
		<welcome-file>index.jsp</welcome-file>
		<welcome-file>login.jsp</welcome-file>
		<welcome-file>index.html</welcome-file>
		<welcome-file>index.htm</welcome-file>
		<welcome-file>default.html</welcome-file>
		<welcome-file>default.htm</welcome-file>
		<welcome-file>default.jsp</welcome-file>
	</welcome-file-list>
	<!-- 通过上边welcome-file-lis的配置：我们的应用的欢迎界面或者叫默认界面就是index.jsp,如果index.jsp没找到的话
	就接着往下找：login.jsp,index.html.... -->
	
	<!-- 配置错误页面
		error-page标签用来配置档应用出现指定错误码的错误时候，有哪个页面来处理这个错误，而不是给用户
			显示系统的错误信息。子标签：
		error-code:系统错误码 
		location:应用系统中的处理错误页面。
	 -->
	<error-page>
		<error-code>404</error-code>
		<location>/common/404.html</location>
		<!-- 表示当系统发生404就是不存在请求地址的错误的时候，页面跳转到404.html页面。 -->
	</error-page>
	<error-page>
		<error-code>500</error-code>
		<location>/common/error.jsp</location>
		<!-- 表示当系统发生500也就是操作异常错误的时候，页面跳转到error.jsp页面。 -->
	</error-page>
	<error-page>
		<exception-type>java.lang.NullPointerException</exception-type>
		<location>/common/error.jsp</location>
		<!-- 表示当系统发生空指针异常错误的时候，页面跳转到error.html页面。 -->
	</error-page>
	<!-- 通过上边对error-apge的配置：当我们系统的系统发生404错误的时候，页面调准到404.html,
	当页面发生服务器错我或者空指针错误的时候，页面跳转到error.html -->
</web-app>



Srping配置
<!-- 指定spring配置文件位置 -->
<context-param>
   <param-name>contextConfigLocation</param-name>
   <param-value>
    <!--加载多个spring配置文件 -->
    /WEB-INF/applicationContext.xml, /WEB-INF/action-servlet.xml
   </param-value>
</context-param>
<!-- 定义SPRING监听器，加载spring -->
<listener>
   <listener-class>
    org.springframework.web.context.ContextLoaderListener
   </listener-class>
</listener>

<listener>
   <listener-class>
    org.springframework.web.context.request.RequestContextListener
   </listener-class>
</listener>



<context-param> 
        <param-name>contextConfigLocation</param-name> 
        <param-value> 
            classpath*:conf/spring/applicationContext_core*.xml, 
            classpath*:conf/spring/applicationContext_dict*.xml, 
            classpath*:conf/spring/applicationContext_hibernate.xml, 
            classpath*:conf/spring/applicationContext_staff*.xml, 
            classpath*:conf/spring/applicationContext_security.xml 
            classpath*:conf/spring/applicationContext_modules*.xml 
            classpath*:conf/spring/applicationContext_cti*.xml 
            classpath*:conf/spring/applicationContext_apm*.xml 
        </param-value> 
</context-param>