SSH框架 | lightquant.com

web.xml配置

1. spring启动方式

三种方式：

本地文件
ApplicationContext ac = new FileSystemXmlApplicationContext (“applicationContext.xml”);
Classpath
ApplicationContext ctx = new ClassPathXmlApplicationContext (“ApplicationContext.xml”);
Web应用中依赖servlet或Listener
（1）利用Listener接口来实现
（2）利用Servlet接口来实现

（1）利用Listener接口来实现

<listener>

	<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
<context-param>

	<param-name>contextConfigLocation</param-name>
	<param-value>classpath:applicationContext.xml</param-value>
    <!--<param-value>/WEB-INF/spring-context.xml</param-value>  -->
</context-param>

（2）利用Servlet接口来实现

<context-param>

	<param-name>contextConfigLocation</param-name>
	<param-value>classpath:applicationContext.xml</param-value>
</context-param>
<Servlet>

	<servlet-name>context</servlet-name>
	<servlet-class>org.springframework.web.context.ContextLoaderServlet</servlet-class>
    <load-on-startup>1</load-on-startup>
</servlet>    
```    
### 2. struts2配置
```xml
<filter>

	<filter-name>struts2</filter-name>
		<filter-class>
			org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter
		</filter-class>
	</filter>
	<filter-mapping>
		<filter-name>struts2</filter-name>
		<url-pattern>/*</url-pattern>
	</filter-mapping>

配置文件

1. hibernate.cfg.xml配置

<hibernate-configuration>

	<session-factory>
		<!-- 数据库驱动程序类 -->
		<property name="connection.driver_class">oracle.jdbc.OracleDriver</property>
		<!-- 数据库连接字符串 -->
		<property name="connection.url">jdbc:oracle:thin:@192.168.1.249:1522:oracle</property>
		<!-- 数据库用户名 -->
		<property name="connection.username">sc160501</property>
		<!-- 数据库密码 -->
		<property name="connection.password">sc160501</property>
		<!-- Hibernate 使用数据方言 -->
		<property name="dialect">org.hibernate.dialect.OracleDialect</property>
		<!--
			是否创建数据库表 create 每次启动都创建 update 如果数据库没有表就创建 validate
			每次启动就校验数据库表和model是否匹配 create-drop 启动时创建，停止时删除
		-->
		<property name="hbm2ddl.auto">update</property>
		<!-- 是否显示SQL语句 -->
		<property name="show_sql">true</property>
		<!-- 是否格式化SQL语句 -->
		<property name="format_sql">true</property>
		
		<mapping resource="com/gjd/model/User.hbm.xml"/>
	</session-factory>
</hibernate-configuration>

hbm.xml映射文件

<hibernate-mapping package="com.hzcl.model">

	<class name="User" table="t_user">
		<id name="id" column="id" type="integer">
			<generator class="sequence">
				<param name="sequence">
					seq_t_user
				</param>
			</generator>
		</id>
		<property name="name" column="user_name" type="string" />
		<property name="pwd" column="pwd" type="string" />
		<property name="createDate" column="create_date" type="date"
			not-null="false" />
		<property name="sex" column="sex" length="2"  type="string" not-null="false" />
		<property name="imgSrc" column="img_src" type="string"
			not-null="false" />
		<property name="loginTime" column="loginTime" type="date" />
        <!-- 一对多
        <set name="comm" table="t_com" cascade="all" lazy="false">
			<key column="tid"></key>
			<one-to-many class="Comment"/>
		</set>
        -->
        <!-- 多对一
        <many-to-one name="user" class="User" column="tid" lazy="false"></many-to-one>
        -->
        <!-- 多对多
         <set name="projects" table="PROEMP">
         <key column="RPROID"></key>
         <many-to-many class="Project" column="REMPID">
         </many-to-many>
        </set>
        -->
        
	</class>
</hibernate-mapping>

User.hbm.xml常用配置

<hibernate-mapping
schema="schemaName" //模式的名字
catalog="catalogName" //目录的名称
default-cascade="cassade_style" //级联风格 @
default-access="field/property/CalssName" //访问策略 @
default-lazy="true/false" //加载策略 @
package="packagename" //默认包名
/>
<class
name="ClassName" //对应映射的类
table="tableName" //对应映射数据库的表
batch-size="N" //抓取策略，一次抓取多少记录
where="condition" //条件 eg:抓取条件
entity-name="EntiyName" //如果需要映射多张表
/>
<id //表的主键
name="propertyName" //对应的属性
type="typeName" //对应类型
column="column_nam" //映射数据库中表当中字段名的名称
length="length" //指定长度
<generator class="generatorClass"/> //主键生成策略 @
/>

关联操作

关联查询

1）延迟加载
对于关联属性，Hibernate默认采用延迟记载的机制。
lazy=”true”：采用延迟记载（默认）
lazy=”false”：不采用延迟加载
2）采用连接查询
fetch=”select”
不采用连接查询（默认）
fetch=”join”
采用连接查询，此时lazy属性失效
级联操作
1）什么叫级联操作

在Hibernate里，在对一方进行增、删、改时要自动的对另一方也进行增、删、改，这样的行为称之为级联操作。
2）如何实现级联添加、修改、删除
在要操作的对象的映射关系文件中，在关联
属性上追加cascade属性，用这个属性的值
来指定级联方式：
cascade=”none”
不支持级联（默认）
cascade=”save-update”
支持级联添加、修改
cascade=”delete”
支持级联删除
cascade=”all”
支持级联添加、修改、删除
//级联删除时，需要在配置文件的关联属性上追加inverse=”true”。

单一主键
（1）assigned 由java应用程序负责生成（手工赋值）
（2）native 由底层数据库自动生成标示符，如果是MySQL就是increment，如果是Oracle就是sequence，等等

2. applicationContext.xml配置

<!-- 引入资源文件 -->

	<context:property-placeholder location="classpath:jdbc.properties" />
	<!-- 配置druid连接池 -->
	<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"
		init-method="init" destroy-method="close">
		<!-- 数据库基本信息配置 -->
		<property name="url" value="${jdbc.url}" />
		<property name="username" value="${jdbc.username}" />
		<property name="password" value="${jdbc.password}" />
		<property name="driverClassName" value="${jdbc.driverClass}" />
		<!-- 配置初始化大小、最小、最大 -->
		<property name="initialSize" value="1" />
		<property name="minIdle" value="1" />
		<property name="maxActive" value="10" />
		
	</bean>


	<!-- 配置Hibernate的相关属性 -->
	<bean id="sessionFactory"
		class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">
		<property name="dataSource" ref="dataSource" />
		<property name="hibernateProperties">
			<props>
				<prop key="hibernate.dialect">org.hibernate.dialect.OracleDialect</prop>
				<prop key="hibernate.hbm2ddl.auto">create</prop>
				<prop key="hibernate.show_sql">true</prop>
				<prop key="hibernate.format_sql">true</prop>
			</props>
		</property>
		<property name="mappingResources">
			<list>
				<value>com/model/User.hbm.xml</value>
				<value>com/model/News.hbm.xml</value>
				<value>com/model/Comment.hbm.xml</value>
			</list>
		</property>
	</bean>

	<!-- 配置事务管理器： -->
	<bean id="transactionManager"
		class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
		<property name="dataSource" ref="dataSource" />
	</bean>
	<!-- 开启事务注解 -->
	<tx:annotation-driven transaction-manager="transactionManager" />

	<!-- 注入 dao -->
	<bean id="userDao" class="com.dao.UserDaoImpl">
		<property name="sessionFactory" ref="sessionFactory"></property>
	</bean>
	<!-- 注入 service -->
	<bean id="userService" class="com.service.UserServiceImpl">
		<property name="userDao" ref="userDao"></property>
	</bean>
	<!-- 注入 action -->
	<bean id="userAction" class="com.action.UserAction">
		<property name="userService" ref="userService"></property>
	</bean>

3. struts.xml配置详解

<struts>
	
	<!-- 让Spring 来创建Action对象 -->
	<constant name="struts.objectFactory" value="spring"/>
	<constant name="struts.action.extension" value="html,"></constant>
	<constant name="struts.custom.i18n.resources" value="message"></constant>
	<package name="user" extends="struts-default" namespace="/">
		<interceptors>
			<interceptor name="login" class="com.interceptor.LoginInterceptor"/>
			<interceptor-stack name="myStack">
				<interceptor-ref name="login"></interceptor-ref>
				<interceptor-ref name="defaultStack"></interceptor-ref>
			</interceptor-stack>
		</interceptors>
		
		<default-interceptor-ref name="myStack"></default-interceptor-ref>
		<global-results>
			<result name="error" type="redirect">/login.jsp</result>
		</global-results>
		<action name="user_*" class="userAction" method="{1}">
			<result type="redirectAction">news_list</result>
			<result name="login">/login.jsp</result>
			<result name="info">/userInfo.jsp</result>
			<result name="logout">/login.jsp</result>
			<result name="input">/register.jsp</result>
			<result name="lang">/register.jsp</result>
		</action>
		<action name="news_*" class="newsAction" method="{1}">
			<result name="del" type="redirectAction">news_list</result>
			<result>/news.jsp</result>
			<result name="modify">/addnews.jsp</result>
			<result name="new">/new.jsp</result>
		</action>
		<action name="comm_*" class="commentAction" method="{1}">
			<result name="newComm" type="chain">news_newCom</result>
		</action> 
		<action name="file" class="fileAction">
			<result>/login.jsp</result>
		</action>
	</package>
</struts>

struts.xml中包含的内容：

1、全局属性
2、用户请求和相应Action之间的对应关系
3、Action可能会用到的参数和返回结果
4、各种拦截器的配置

配置详解

package提供了将多个Action组织成为一个模块的方式
package的名字必须是唯一的，可以在这个包上加一些拓展的包

为拦截器
可以为拦截器定义name(名称)和class（类路径）

拦截器栈

定义默认的拦截器，每个Action都会自动引用

包含其他配置文件

注意：
1.被include的标签一定要符合struts的dtd规范。也就是说被include的xml文件的内部格式要符合struts的xml文件规范。
2.xml文件的编码格式要相同，如果是utf-8，那么都是utf-8。
配置编码：

工作原理：

用户的请求HttpServletRequest—>过滤器filter—>ActionMapper(.action)请求—->过滤器—->ActionProxy—->
通过ConfigurationManager读取struts.xml中的ActionInvocation具体的Action类—->
通过ActionProxy创建Action反向实例—->拦截器—>action,返回result(字符串对象)对应的视图—->
拦截器—->HttpServletResponse返回请求

action搜索顺序

例子：
localhost:8080/product_one/hellowworld.jsp可以进入result.jsp页面
localhost:8080/product_one/aaa/ddd/ccc/
hellowworld.jsp也可以进入result.jsp页面
Action搜索顺序：
localhost:8080/struts2/path1/path2/path3/
student.action
第一步：判断package是否存在，如：path1/path2/path3/

如果package存在
第二步：则判断该package中action是否存在，如果不存在则去默认namespace的package里面寻找action
第三步：如果没有，则报错

如果package不存在：
第二步：检查上一级路径的package是否存在（直到默认namespace），重复第一步
第三步：如果没有则报错

如果请求为/login.action，系统会根据根命名空间（”/“）中查找名为login的Action，如果在根命名空间中找到了名为login的Action，则该Action处理用户的请求；否则系统将转为在默认命名空间中寻找名为login的Action，如果默认的命名空间中有名为login的Action，则由该Action处理用户的请求。如果两个命名空间中都找不到名为login的Action，那么系统将出现错误。

注意：命名空间只有一个级别。如果请求的URL是/bookservice/search/get.action系统将先在/bookservice/search的命名空间下查找名为get的Action，如果在该系统命名空间内找到名为get的Action，则由该Action处理该用户的请求；如果在该命名空间中没有找到名为get的Action，系统将直接进入默认的命名空间中查找名为get的Action，而不会在bookservice的命名空间下查找名为get的Action。
可以多个包使用同一个命名空间，但是相同的命名空间相当于同一个模块，也就是同一个包。
一个包中可以有name值相同的action，但是后面的action会把前面同名的action覆盖掉

动态方法调用：

动态方法调用是为了解决一个Action对应多个请求的处理，以免Action太多。
三种方式：指定method属性、感叹号方式、通配符方式（这种方式较方便）

method属性

感叹号

<constant name="struts.enable.DynamicMethodInvocation" value="true"></constant>
<action name="hellowword" class="com.Action.hellowAction">
<result >/result.jsp</result>
<result name="add">/add.jsp</result>
<result name="update">/update.jsp</result>
</action>

localhost:8080/struts_hellowworld/
aaa/hellowworld!.action

通配符

<action name="*_*" method="{2}" class="com.Action.{1}Action">
<result >/{2}.jsp</result>
<result name="add">/{2}.jsp</result>
<result name="update">/{2}.jsp</result>
</action>

localhost:8080/struts_hellowworld
/aaa/hellow_add.action

默认的action

<default-action-ref name="index"></default-action-ref>

<action name="index">
<result>/error.jsp</result><br>
</action>

结果类型input的效果

1.当参数类型转换错误时，如age输入框中的类型是字母等情况，方法自动返回input
2.当action中存在addFiledError时：
1）addFileError放在一般执行方法，addFieldError(“”, “”);语句后面有返回input的语句
2）addFileError放在validate()中
*3.FileError的表现形式：
在jsp页面中使用标签，该标签name属性为addFieldError方法中的参数fieldName，在jsp页面中使用struts标签，
需要导入标签库语句：<%@ taglib prefix=”s” uri=”/struts-tags” %>

【Structs2处理流程】

用户请求Structs框架控制器(Action)Structs框架视图资源
返回String，提供代码复用性，有利于框架分离。
【Action中五种内置属性(com.opensymphony.xwork2.Action)】
(1) SUCCESS Action正确的执行完成，返回相应的视图，success是name属性的默认值。
(2) NONE 表示Action正确的执行完成，但并不返回任何事视图。
(3) ERROR 表示Action执行失效，返回错误处理视图。
(4) LOGIN Action因为用户没有登录的原因没有正确执行，将返回该登录视图，要求用户进行登录验证
(5) INPUT Action的执行，需要从前端界面获取参数，INPUT就是代表这个参数输入界面，一般在应用中，会对这些参数进行验证，如果验证没有通过，将自动返回该视图。
返回

1.在result里面最重要的属性是type类型，type的默认值为dispatcher（转发），这个类型支持JSP视图技术。
2.Struts2支持多种视图技术，例如JSP、Valocity（模板引擎）、FreeMaker（模板引擎）等。
3.常用三个：chain，redirect，plaintext。
1）、chain：将action和另外一个action链接起来，必须是一个action不能是jsp页面。
2）、redirect：重定向（会丢失请求参数）。
3）、plaintext：返回网页源代码。
4）、stream：返回inputstream用于文件下载。
5）、默认”dispatcher” jsp传值请求转发

客户端通过httpservletrequest向servlet容器,也就是tomcat提交一个请求,这个请求会经过一些列的过滤器,如ActionContentClearUp过滤器,最终被struts核心过滤器过滤,也就是FilterDispatcher.从struts2.1.3版本以后struts的核心控制器发生了变化,变成了PrepqreAndExecuteFiletr,核心过滤器过滤以后,调用访问ActionMapping,决定是否调用某一action,如果用户请求的是jsp页面或者是其他资源,不会调用某一action,如果决定调用某一action,ActionMapping会将控制权委派给ActionProxy,也叫action代理,此时action代理会通过一个Configuration Manager也就是配置管理器对象加载struts核心配置文件,也就是struts.xml.如果在struts.xml找到需要创建的action,ActionProxy会创建一个Action Invocation实例,action Invocation包括一些列的拦截器和action,先顺序执行一些列的拦截器,然后执行action处理,返回一个结果,通过result返回一个视图或者调用另外某个action.当返回这个视图以后,将之前执行过的拦截器反向执行一遍,然后通过response响应客户端的请求.

<!-- 注册拦截器 -->

    	<interceptors>
    		<interceptor name="auth" class="com.imooc.interceptor.AuthInterceptor">
	</interceptor>
<!-- 引用拦截器 -->

			<interceptor-ref name="mytimer"></interceptor-ref>

默认拦截器栈

在struts-default.xml中定义一个defaulStack拦截器栈,并将其指定为默认拦截器.
只要在定义包的过程中继承struts-default包,那么defaultStack将是默认的拦截器.
当为包中的某个action显式指定了某个拦截器,则默认拦截器不会起作用.
拦截器栈中的各个拦截器的顺序很重要.

引用默认的拦截器栈
<interceptor-ref name="defaultStack"></interceptor-ref>
在引用拦截器的时候一般先引用默认的拦截器。
WEB-INF里的文件默认情况下是不允许被外部直接访问的，可以通过action间接来访问
如果action的class不写，则默认是ActionSupport这个类

struts.xml 定义顺序

result-types
interceptors
interceptor-stack
default-interceptor-ref 默认拦截器
default-action-ref 默认action
default-class-ref Action默认处理的类
global-results 全局返回
global-exception-mappings 全局异常
action

核心代码编写

1. hibernate

一级缓存

什么是一级缓存
Hibernate在创建Session时，会给每一个Session
分配一块内存空间，用于缓存Session查询到的
对象数据，这块内存空间称之为一级缓存。由于
该空间是给Session使用的，也称Session级缓存。
重点：
–一级缓存又称Session级缓存
–一级缓存是Session独享的
为什么用一级缓存
1）作用：
一级缓存可以降低数据库访问次数，提高
代码执行效率。
2）步骤：
–Session取值时会优先向它的一级缓存取值
–如果缓存中没有数据，它会向数据库取值，
并将取到的值放入一级缓存，然后Session
从缓存中取出数据
–当再次查询相同的数据时，由于一级缓存中
已经存在了该数据，则直接返回，不需要重新
访问数据库

如何使用一级缓存
1）一级缓存是默认开启的，自动使用。
2）规则：

 --一级缓存是Session独享的，即一个Session
 不能访问另一个Session缓存的数据。
 --每次查询，Session仅仅是把本次查询结果
 放到一级缓存中
 --如果查询的结果是多条数据，Session会将
 这些数据拆开，以单个对象的形式存入一级缓存。
 --在执行save、update、delete时，会自动触发
 缓存的更新。
3）一级缓存是给Session使用的，并且是由Session
     负责管理，Session管理一级缓存的方式如下：
     a、session.evict(obj);
         evict可以将obj对象从当前session的缓存区
         移除。
     b、session.clear();
         clear可以将当前session的缓存区清空。
     c、session.close();
         session关闭时，它会释放自己的缓存区域，
         从而缓存数据也释放了。

二、对象持久性
1、Hibernate下，可以把对象看做具有3种状态，分别
为临时态、持久态、游离态，对象持久性是值对象
在这三种状态之间的转换规则。
2、3种状态的转换及规则
1）临时态
a、转换
–new出来的对象是临时态的
–delete持久态的对象，它将转变为临时态
b、规则
–临时态的对象可以被垃圾回收
–临时态的对象没有被持久化过，
并且没有与session建立关联。
2）持久态（）
a、转换
–通过save/update操作过的对象，
是持久态的。
–经过get/load/list/iterate方法查询得到的
对象是持久态的。
b、规则
–持久态的对象不能被垃圾回收
–持久态的对象被持久化了，并且与
session建立起了关联。
–（）持久态的对象存在于一级缓存中。
–（*）持久态的对象可以自动与数据库同步，
同步的时机是在调用session.flush()时，
实际上事务提交时也可以同步，原因是
ts.comit() = session.flush() + commit;
3）游离态
a、转换
–通过evict/clear/close操作过的对象，
是游离态的。
b、规则
–游离态的对象可以被垃圾回收
–游离态的对象被持久化过，
但是已经与session解除了关联。
3、问题
当大批量插入数据时，每次插入都会导致对象存在
于一级缓存中，如果数据量太大，可能导致缓存
溢出，如何解决？


        public void batchDdd(List<Emp> emps) {
			if(emps == null
					|| emps.size() == 0) {
					return;
			}
			Session session = HibernateUtil.getSession();
			Transaction ts = session.beginTransaction();
			try {
				for(int i=0;i<emps.size();i++) {
					//循环添加Emp
					session.save(emps.get(i));
					//每100批次，要同步并清理缓存
					if(i%100 == 0) {
						//每隔100次触发同步，但不提交事务
						session.flush();
						//清理缓存
						session.clear();
					}
				}
				//统一的提交事务
				ts.commit();
			} catch(HibernateException e) {
				ts.rollback();
			}
		}
```        
**三、延迟加载**
	1、什么是延迟加载
		Hibernate中存在一些查询方法，在查询时并没有
		立刻访问数据库查询数据，而是返回了空对象（
		对象并不是null，而是经过new的对象，但对象中
		除ID外其他属性都为null），当程序使用此对象
		时，Hibernate才真正去查询数据库，将数据填充
		到返回的对象中。这种将查询推迟到使用对象时的
		机制，称之为延迟加载。
	2、为什么用延迟加载
		1）推迟的时间内，由于数据没有加载，可以节约
			内存空间，可以提升内存使用率。
		2）如果有对象查询后并没有使用，那么在延迟加载
			的方法中实际上没有访问数据库，可以减少一定
			数量的数据库访问次数。
	3、如何使用延迟加载
		1）有一些方法本身自动支持延迟加载，只要调用
			这些方法就可以使用延迟加载。
		2）具有延迟加载的方法如下
			a、session.load()
			b、query.iterate()
			c、关联映射中的关联属性加载
**四、二级缓存**
1、什么是二级缓存，二级缓存就是SessionFactory缓存
  比Session作用范围更广
2、先查一级缓存，如果查询不到再查二级缓存，如果二级缓存也查询不到，就直接查数据库
 	查询到数据以后保持到一级缓存和二级缓存中
 	如果一级缓存查询不到数据 就从二级缓存中查询
 	
一级缓存和二级缓存的区别
	1、作用范围不一样一个属于session的一个属于sessionFactory
	2、一级缓存默认开启 二级缓存必须手动开启
	3、一级缓存数据缓存在内存中 二级缓存数据缓存在磁盘中
	
 使用二级缓存步骤
 1、导入ehcache.jar
 2、编写ehcache.xml缓存配置文件
 3、在hibernate.cfg.xml中开启二级缓存的支持
 ```xml
 <!-- 开启二级缓存 -->
 <property name="cache.use_second_level_cache">
	true
</property>
<!-- 配置二级缓存驱动类 -->
<property name="cache.provider_class">
org.hibernate.cache.EhCacheProvider
</property>
<!-- 开启查询缓存 -->
<property name="cache.use_query_cache">
true
</property>

4、开启二级缓存
持久化对象映射文件添加

持久层增删改查
dao层继承该类：HibernateDaoSupport
this.getHibernateTemplate().save(); //增删改查

2. struts

获取request、response
采用耦合IOC方式注入属性
三个接口
ServletRequestAware
ServletresponseAware
ServletContextAware
ServletSessionAware
ActionContext struts2自己封装了Servlet的方法
ServletActionContext 可以获取原生态的Servlet的方法
表单验证方法
validate() //支持表单验证的方法

国际化

国际化：
第一步：struts.xml中加入
<constant name="struts.custom.i18n.resources" value="message"></constant>
第二步：在与struts.xml文件同目录下创建一下两个文件.

	message_en_US.properties(配置英文信息）
	message_zh_CN.properties(配置中文信息）
切换：
<a href="changeLanguage.action?request_locale=zh_CN" >中文</a>
<a href = "changeLanguage.action?request_locale=en_US">英文</a>
jsp中使用：(必须用ognl标签)
	<s:text name="m_name"/>

新建拦截器的步骤

1 建立一个拦截器类继承自Abstractlnertceptor类，并实现inertcept方法。invocation.invoke()方法调用下一个拦截器，如果已经是最后一个拦截器，则执行目标action

public String intercept(ActionInvocation invoaction) throws Exception {

		//1.执行action之前
		long start = System.currentTimeMillis();
		//2.执行下一个拦截器，如果已经是最后一个拦截器，则执行目标Action
		String result = invoaction.invoke();
		//3.执行action之后
		long end = System.currentTimeMillis();
		System.out.println(end-start);
		return result;
	}

自定义拦截器：

方法一：实现Interceptor接口
-void init():初始化拦截器所需资源
-void destroy() :释放在init（）中分配的资源
-String intercept(ActionInvocation ai)throws Exception 实现拦截器功能，利用ActionInvocation参数获取Action状态，返回result字符串作为逻辑视图。
方式二：继承AbstractInterceptor类
-提供了init()和destroy() 方法的空实现
-只需要实现intercept方法即可

实际开发当中一般会去继承AbstractInterceptor这个父类

2 在strut的配置文件的package中注册拦截器，注册拦截器在action调用之前，在相应的action配置中个，通过intercepor-ref标签中来引用拦截器

接收参数

1，使用Action的属性接受参数，在Action中定义需要接受的属性，并写它的set/get方法。
2，使用DomainModel接受参数，创建实体类定义需要接受的属性，并set/get方法，在Action中创建实体类名属性。并在界面进行指定。
3，使用ModelDriver接受参数，在Action中实现ModelDriver<实体类名>接口，并实现方法返回当前需要转换的对象，删除set/get方法，并对对象进行实例化，并取消指定。
4，request
5，获取List集合中的参数。获取多个参数。

字段驱动方式
第一种接收参数的方法：直接在action类中创建相应的属性和getter和setter，和前端的name名字相同。eg:前端的username，在action类中就要建立一个private String username; Struts会自动映射为这个属性赋值

模型驱动方式
第二种接受参数的方法：使用DomainModel，将username 和password两个属性封装为一个类User（必须是标准的JavaBean），在action中声明这个属性：private User user; 同时为user设置getter和setter；在前端中的name需要设置为user.name和user.password,才能映射成功

第三种接收参数的方法：使用ModelDriven接口，这个action必须实现这个接口的public T getModel()方法。此时声明的属性必须实例化，eg: private User user = new User(); 同时不需要getter和setter。前端的name也只需要写username和password就可以，不需要再加域了。这种方法时最推荐的方法，因为可以减少前后端的耦合