struts2-总结篇

第一节

struts2框架应用在javaee三层中web层框架，是轻量级框架
struts2在struts1和webwork基础之上发展全新的框架
之前web阶段提交表单时候到servlet里面，现在开始不写servlet，使用struts2实现之前servlet的功能

struts2框架版本
（1）hibernate5.x
（2）struts2.3.24

解压文件之后，有目录结构

2 常见web层框架

1 struts1
2 webwork
3 springMVC（常用）

3.web层框架特点

1. 只要框架是应用在web层框架，这类框架共同特点：有前端控制器（过滤器）
2. 2 画图分析struts2解决问题：

4.Struts2框架入门案例

第一步 导入jar包
（1）到apps里面找到示例程序war包，使用压缩文件把war包打开，从示例程序里面复制struts2需要jar包

第二步 创建action

/**
 * action类
 * @author asus
 *
 */
public class HelloAction {
	/*
	 * serlvet
	 * (1) 继承HttpServlet，重写方法
	 * (2) 在web.xml配置servlet，访问servlet路径
	 * （3）访问servlet时候，servlet里面service方法执行
* action
	 * （1）action需要类似于servlet进行配置，配置访问路径
	 * （2）访问action时候，action里面方法默认执行 名称固定的 execute方法
	 * */
	/*
	 * action里面的方法不能有参数
	 * action的方法可以没有返回值 void，如果有返回值，必须是String
	 */
	public String execute() {
		return "ok";
	}
}

第三步 配置action访问路径
（1）之前配置servlet，在web.xml中进行配置

（2）配置action不是在web.xml配置，创建struts2核心配置文件完成action配置
（3）struts2核心配置文件名称和位置固定的

• 位置在src下面
  - 名称是固定 struts.xml
  
  （4）引入dtd约束，到示例程序里面复制dtd约束
  
  （5）配置action访问路径

<package name="demo" extends="struts-default" namespace="/">
		<action name="hello" class="cn.itcast.action.HelloAction">
			<result name="ok">/hello.jsp</result>
		</action>
	</package>

（6）访问action路径：http://localhost:8080/struts2_day01/hello

**（7）**上面代码访问之后，出现404问题，因为在struts2框架里面需要过滤器，所以需要配置struts2过滤器，是struts2提供的过滤器

在web.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>

效果：
访问action路径，跳转到页面中

4.Struts2开发流程分析

●struts2执行过程

● 配置没有提示
1 可以上网
2 把dtd约束配置到eclipse中

Struts2流程：
（1）是过滤器
（2）过滤器在服务器启动时候创建，过滤器创建执行init方法
做事情是 加载配置文件，加载配置文件分成两部分：
第一部分 自己创建配置文件
第二部分 struts2自带配置文件

（1）有加载顺序
Struts2自带配置文件
default.properties: 常量设置
struts-defaul.xml: struts2拦截器
struts-plugin.xml: 插件

（1）加载配置文件中，主要关心自己可以修改配置文件
struts.xml: 配置action路径
struts.properties: 配置常量
web.xml

5.Struts2的核心配置文件

1 struts2核心配置文件名称和位置固定

（1）位置在src下面，名称是struts.xml

2 有很多标签，每个标签里面有属性

（1）package标签
（2）action标签
（3）result标签

6.标签package

1 在配置文件中配置action访问路径，要求必须package标签
2 类似于代码中包
3 在一个配置文件中可以写多个package标签，name属性值不能相同的
4 extends属性：
（1）在extends里面写struts-default之后，配置action有struts2封装的功能
（2）因为struts2里面封装很多功能，在拦截器里面封装，使用struts2拦截器

5 namespace属性：
（1）namespace属性值和action标签name属性值构成访问地址

6 两个细节问题
（1）package里面extends写其他package的name属性值

（2）namespace值修改，访问路径写法

6.标签action

1 action标签写在package标签里面
2 action的name属性
（1）name属性值和package标签namespace属性值构成访问路径
3 action的class属性
（1）action类全路径
4 action的method属性
（1）配置action不是execute的方法执行
5 在一个package里面可以写多个action标签，name值不能相同

7.标签result

1 result标签写在action标签里面
2 result标签作用：根据action方法返回值，配置到不同的路径里面
3 result标签有name属性：和action方法返回值一样
4 result标签有type属性：如何到路径中（转发或者重定向）
（1）默认值做转发操作
5 在action标签可以有多个result标签，name值不能一样

8. Struts2常量配置

1 使用struts2是框架，在框架里面封装很多功能，
这些功能中其中一部分功能在常量封装的

2 struts2默认的常量位置（记住）

3 修改struts2默认常量值
有三种方式
（1）常用的方式
在struts.xml中进行常量配置

（2）第二种方式
在src下面创建名称是struts.properties

（3）第三种方式
在web.xml进行常量配置

4 加载顺序

（1）如果在三个配置文件中都修改同一个常量，最终以最后一次加载文件修改值为准

- 介绍最常用常量
（1）之前提交表单到servlet里面，现在提交表单到action里面，
提交中文数据，在servlet获取乱码问题，
解决：post设置编码方式，get做编码转换
（2）action获取post提交中文数据，乱码问题不需要自己解决，帮处理。
如果get提交还是有乱码的，自己处理](https://img-blog.csdnimg.cn/20201224195842738.png)

（1）访问action路径，添加扩展名称，可以添加.action，可以什么都不添加
（2）建议添加.action

（2）如果设置值true之后，修改struts.xml配置文件不需要重启动服务器

8.分模块开发配置

1 一般开发中，每个人自己写自己struts2配置文件，最终把每个配置文件引入到核心配置文件中

9.Action编写方式
1 action编写有三种方式
第一种 创建普通类，不继承任何类，不实现任何接口 pojo

第二种 创建类，让实现接口Action

（1）Action接口里面有常量

就是字符串success

如果在action方法有返回值，必须在result标签里面进行配置，如果不配置出现404问题，

但是如果返回值NONE，不需要在result标签配置


（1）字符串login

（1）错误页面配置

（1）比如在表单里面输入值 abc，在action使用int类型接收abc，返回input

第三种 创建类，继承类ActionSupport（建议）

10.访问action的方法

有三种方式实现
第一种 使用action标签method属性，在这个属性里面写执行的action的方法
第二种 使用通配符方式实现
第三种 动态访问实现（不用）

11. 使用method属性

<!-- 配置action的方法访问 -->
	<package name="" extends="struts-default" namespace="/">
		<!-- 第一种方式配置action的方法访问 -->
		<!-- 执行add方法 
			method：执行action方法名称
		-->
		<action name="ordersAdd" class="cn.itcast.method.OrdersAction" method="add"></action>
		
		<!-- 执行update方法 -->
		<action name="ordersUpdate" class="cn.itcast.method.OrdersAction" method="update"></action>
	</package>

1 方式有缺陷：action里面每个方法都需要配置action，如果有很多的方法，配置很多action

●使用通配符实现
使用通配符方式时候，需要在action标签name属性里面使用符号 *
（1）* 可以匹配任意内容
（2）比如ordersadd，使用可以匹配到
比如ordersupdate，使用可以匹配到

<!-- 使用通配符方式配置 -->
	<package name="demo" extends="struts-default" namespace="/">
		<!-- 
			在action标签name属性里面添加* 
			orders_执行的方法名称
			（1）orders_add，使用orders_*可以匹配到，*相当于办成 add
			    orders_update,使用orders_*可以匹配到，*相当于变成 update
			（2）add和update是方法名称
			（3）method里面写* 值
			（4）获取*值
			(5)访问地址里面添加执行方法名称
			
			*_* 获取第一个*值 {1}，获取第二个*值 {2}
		 -->
		<action name="orders_*" class="cn.itcast.method.OrdersAction" method="{1}"></action>
	</package>

2 访问action的方法还有一种方式是：
动态访问，实际开发一般不用，作为了解

（1）开启常量

（2）配置action，不需要method属性

（3）访问时候，写action的name属性值后面添加感叹号 ! ，后面添加执行方法名称

12.案例-客户列表

1 修改超链接路径

2 创建action
public class CustomerAction extends ActionSupport {

	//列表的方法
	public String list() {
		
		return "list";
	}
}

3 配置action
	<package name="demo" extends="struts-default" namespace="/">
		<action name="customer_*" class="cn.itcast.action.CustomerAction" method="{1}">
			<result name="list">/jsp/customer/list.jsp</result>
		</action>
	</package>

4 配置过滤器
     <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>

5 action实现
	//列表的方法
	public String list() {
		/**
		 * 作业：
		 * 查询数据库返回客户列表的list集合
		 * 使用hibernate实现
		 * （1）创建实体类
 * （2）配置映射关系
		 * （3）创建核心配置文件，引入映射文件
		 * （4）调用service，在service调用dao
		 * （5）在dao实现列表的操作（hibernate代码实现）
		 */
		List<Customer> list = new ArrayList<Customer>();
		Customer c1 = new Customer();
		c1.setCustName("百度");
		c1.setCustSource("web");
		c1.setCustPhone("111");
		c1.setCustMobile("222");
		
		Customer c2 = new Customer();
		c2.setCustName("阿里巴巴");
		c2.setCustSource("web");
		c2.setCustPhone("555");
		c2.setCustMobile("333");
		
		list.add(c1);
		list.add(c2);
		
		//servlet里面 放到域对象里面 request域里面
		HttpServletRequest request = ServletActionContext.getRequest();
		request.setAttribute("list", list);

		return "list";
	}

第二节

1.注意

项目中的默认hibernate和Struts的xml文件名注意是小写的

2.配置全局结果页面（在Struts.xml的package里面）

我们在action在配置的result标签，这个配置叫做局部结果页面。

3.result标签的type属性

1.result标签的作用：根据action的方法返回值进行配置，找到不同路劲里面
2.result标签里面name属性，和方法返回值对应
3.result标签的重要属性type
●表示如何到路劲中去（转发还是重定向）
●type属性默认值-----转发操作，dispatcher
●重定向操作：redirect
注意：之前在web阶段，写重定向的时候带项目名称，转发路劲不需要带项目名称
但是在structs2里面重定向不用写路劲不用带项目名。
4.上面两个值dispatcher和redire，两个值，一般都针对跳转到页面配置
那么action中的转发和重定向：
●chain：转发action
●redirectAction：重定向到action（这个比较常用）

4.Action获取表单数据

1.使用ActionContext类获取
2.使用ServletActionContext类获取
3.使用接口注入方式（了解）

●获取表单数据
使用ActionContext类得到request域对象来获取页面数据


●Action中对域对象的操作

使用ServletActionContext类获取

• ServletActionContext类里面提供很多静态的方法，调用方法获取request对象，调用request里面的方法得到表单数据
  

public class ServletActionContextDemo extends ActionSupport {

	public String execute() throws Exception {
		//1 获取request对象
		HttpServletRequest request = ServletActionContext.getRequest();
		//2 调用request里面的方法获取表单数据
		String username = request.getParameter("username");
		String password = request.getParameter("password");
		String address = request.getParameter("address");
		
		System.out.println(username+":"+password+":"+address);
		return NONE;
	}
}

5.Struts2提供的数据封装

(1)原始方式封装数据
(2)属性封装
1.使用属性封装，把表单提交数据封装到action的属性里面
2.底层实现：获取request对象，调用request的方法获取表单数据，设置到属性里面
3.具体实现

 3.1  在action中定义变量

3.2 生成action变量的set方法

(3)模型驱动封装（最常用的）
1.能把我们的数据封装到对象里面

2.实现步骤：
1)action实现接口ModeDriven

2)实现接口的方法

3)需要在action里面手动创建实体对象

●要求：实体类属性名称和表单里面name属性值一样

(4)表达式封装

(5)模型驱动封装和表达式封装数据的对比
●两个都可以封装数据到对象中
模型驱动封装：只能把数据封装到一个对象中
表达式封装：可以把数据封装到多个对象

5.向表单中封装集合

1.封装数据到list集合



2.封装数据到map集合
action中的步骤：
1）定义一个变量
2）生成get和set集合
3）在方法里面执行

表达式中的：

第三节：值栈和ognl

●Struts2的默认的表达式语言(类似jsp里面的el表达式)，主要和Struts2的标签一起用用来操作值栈。
OGNL本身不是Struts2一部分，只是它通常在Struts2中用来值栈。
使用ognl需要导入jar包，这个jar包在struts2框架提供出来

1.值栈

●什么是值栈：
1 之前在web阶段学习过域对象，可以使用域对象存值和取值
（1）在servlet里面把数据放到域对象里面
（2）在jsp页面中使用el表达式获取域对象里面值

2 现在使用action，在action操作域对象
（1）在action可以把数据放到域对象里面，在jsp页面使用el表达式获取到

3 struts2里面提供存储机制是值栈，类似于域对象，可以存值和取值
（1）在action可以把数据放到值栈中，在jsp页面通过struts2标签+ognl表达式获取值

3 Servlet和Action区别
（1）servlet默认在第一次访问时候创建，创建一次，单实例对象
（2）action在每次访问时候都会一个action对象，创建多次，多实例对象

2.获取值栈对象

1 值栈对象存值于每个action对象里面，所以在action获取到值栈对象
2 在action里面封装对象ActionContext，使用ActionContext可以获取值栈对象（常用）

3 验证每个action对象里面只有一个值栈对象

3.值栈的内部结构：(ctrl+shift+T查找方法)

第一部分–>root:
1）继承Arraylist：他是一个list集合
2）
第一部分–>context:
1）继承Map：他是一个map集合
2）在context里面主要储存对象的引用

1 值栈分为两部分：
（1）root是list集合，一般操作都是root里面内容
（2）context是map集合

2 struts2里面标签 s:debug，使用这个标签可以查看值栈结构和存储值
（1）通过action跳转到页面，在页面中使用struts2里面debug标签
(2）默认情况下，值栈中栈顶元素是action对象引用

值栈结构：
（1）每个action对象里面有一个值栈对象
（2）每个值栈对象里面有action对象引用

5.向值栈放数据

1 在action里面可以把数据放到值栈里面，在jsp页面中使用struts2标签+ognl表达式获取
2 向值栈放数据有三种方式
第一种 获取值栈对象，调用值栈对象里面set方法

第二种 获取值栈对象，调用值栈对象里面push方法

第三种（常用） 在action定义变量，生成变量get方法

/**

 * 第三种方式放数据

 * @author asus

 *

 */

public class ValueStackDemo2 extends ActionSupport {


//1 定义变量

private String username;

//2 get方法

public String getUsername() {

return username;

}

 

public String execute() throws Exception {

//3 向username设置值

username = "wwwbbccc";

return "demo2";

}

}

栈顶元素还是action对象引用，action里面有变量，不需要向值栈里面做压栈操作

验证每个action对象里面只有一个值栈对象
1 值栈对象存值于每个action对象里面，所以在action获取到值栈对象
2 在action里面封装对象ActionContext，使用ActionContext可以获取值栈对象（常用）

3 验证每个action对象里面只有一个值栈对象

6.获取字符串

9.2 获取对象

1 向值栈放字符串

//1 定义变量

private String username;

//2 get方法

public String getUsername() {

return username;

}

public String execute() throws Exception {

//3 向username设置值

username = "wwwbbccc";

return "demo2";

}

1 向值栈放对象

//1 定义user类型变量

private User user = new User();

//2 生成get方法

public User getUser() {

return user;

}

public String execute() throws Exception {

//3 向user对象里面设置值

user.setUsername("rose");

user.setPassword("250");


return "object";

}

2 在jsp页面中获取值栈对象值

9.3 获取list集合

//1 定义list集合类型变量

private List<User> list = new ArrayList<User>();

//2 get方法

public List<User> getList() {

return list;

}

 

public String execute() throws Exception {

//3 设置list集合值

User user1 = new User();

user1.setUsername("小金");

user1.setPassword("55555");


User user2 = new User();

user2.setUsername("小奥");

user2.setPassword("9999999");

list.add(user1);

list.add(user2);
return "list";
}

1 有三种方式获取
第一种（了解）

<!-- 第一种方式 -->

<s:property value="list[0].username"/>

<s:property value="list[0].password"/>

<br/>

<s:property value="list[1].username"/>

<s:property value="list[1].password"/>

（1）第二种和第三种方式，使用struts2里面标签实现
s:iterator标签，类似于jstl里面forEach标签
s:iterator标签在jsp页面中遍历值栈list集合数据

第二种

<!-- 第二种方式

<c:forEach items="${list}" var="user">

  ${user.username}

</c:forEach>

 -->

 <s:iterator value="list">

 	<!-- 遍历list集合，得到集合里面每个user对象

 	直接写user对象里面属性名称

 	 -->

 	<s:property value="username"/>

 	<s:property value="password"/>

 </s:iterator>

第三种

<s:iterator value=“list”>

<!-- 遍历list集合，得到集合里面每个user对象

直接写user对象里面属性名称

 -->

<s:property value="username"/>

<s:property value="password"/>

</s:iterator>

第三种
 <!-- 第三种方式
 	添加var之后，iterator标签里面做优化操作
 	（1）操作值栈list集合在值栈root里面
 	（2）遍历list集合从root里面把list集合获取到
 	（3）机制：
 	 添加var属性之后，每次遍历list集合得到user对象，
 	 把获取user对象放到context里面
 	 最终获取每次遍历user对象值，从context里面获取
 	 （4）从context里面获取值，写ognl表达式，表达式前面添加符号 
 	  	优化思想：
![在这里插入图片描述](https://img-blog.csdnimg.cn/20201224211034845.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQ2OTIyMjQ=,size_16,color_FFFFFF,t_70)

```java
<s:iterator value="list" var="user">

 	<s:property value="#user.username"/>

 	<s:property value="#user.password"/>

 	<br/>

 </s:iterator>

1 在jsp页面使用el表达式从值栈把值获取出来

2 为什么可以获取
（1）文字描述：
底层对request对象里面的getAttribute方法进行增强

• 首先从request域获取值，如果可以获取到直接返回
• 如果从request域获取不到值，到值栈把值获取到，把值放到域对象里面

（2）源代码：

• 调用request里面getAttribute方法获取域对象里面值
  
• 如果获取到，直接返回
• 如果获取不到
  
• 获取值栈对象，从值栈里面把值获取到，放到request域里面

1 #从context获取值
（1）在action向域对象里面放值，在jsp页面中使用ognl表达式获取

/**

 * 向request域里面放值

 * @author asus

 *

 */

public class ContextDemo extends ActionSupport {


@Override

public String execute() throws Exception {

ServletActionContext.getRequest().setAttribute("req", "reqValueValue");
return "context";

}

}

<!-- 值栈获取request里面值 -->

<s:property value="#request.req"/>

1 在struts2标签里面有表单标签

1）在struts2的表单标签里面使用ognl表达式，必须添加%，不能使用
（2）写%之后，让struts2表单标签value属性内容作为ognl执行

1 过滤链
（1）一个请求有多个过滤器进行过滤，每个过滤器只有放行操作，才能到下一个过滤器

第四节：拦截器

1 struts2是框架，在struts2框架里面封装很多功能，struts2里面功能在拦截器里面封装，
封装很多功能，每个封装的功能都会对应一个拦截器
比如 模型驱动，属性封装，这些都是在拦截器封装的功能
2 struts2里面封装了很多的功能，有很多的拦截器，这些拦截器不是都会执行，每次访问时候执行一些默认拦截器
3 struts2里面默认拦截器位置

4 拦截器在什么时候执行
（1）在action对象创建之后，action里面的方法执行之前执行拦截器

拦截器底层原理

1 拦截器底层使用两个原理
第一个 aop思想（动态代理）
（1）面向切面（方面）编程
（2）在基本功能之上，添加功能，不修改源代码实现，一般使用配置实现
（3）举例说明：

• 登录为例，有登录表单页面，输入用户名和密码，提交表单到servlet里面，在servlet获取用户名和密码，查询数据库判断
• 在登录基本功能添加角色判断，使用原始方式修改源代码实现，通过配置方式完成

第二个 责任链模式
（1）类似于之前过滤链
一个请求有多个过滤器进行过滤，每个过滤器只有放行，才能到下一个过滤器

（2）责任链模式：
责任链模式是java设计模式
比如一组操作，有添加，修改操作，
首先执行添加操作，添加操作执行之后做类似于放行操作，执行修改操作
每个功能执行之后，做类似于放行操作，执行下一个操作

2 aop思想和责任链模式如何应用到拦截器里面？
文字描述：
（1）拦截器在action对象创建之后，action的方法执行之前执行
（2）每次访问action时候，创建action对象，执行action方法之前，执行struts2里面默认拦截器，
（3）首先用到aop思想：在action里面没有直接调用拦截器方法，通过配置方式执行
（4）其次用到责任链模式：执行很多拦截器，假如有三个拦截器，这三个拦截器都会执行，
首先执行拦截器1，拦截器1执行之后做放行操作，执行拦截器2，拦截器2执行之后做放行，执行拦截器3，拦截器3执行之后做放行，执行action里面的方法

画图分析

3 查看源代码

（1）执行action

（2）创建action对象，使用动态代理方式

（3）执行action的方法

（4）执行很多的拦截器，遍历执行

类似于放行的操作的方法

4 struts2执行流程

（1）发送请求，到struts2过滤器，读取配置文件

（2）创建action代理对象

（3）执行action里面的方法，执行很多拦截器

（4）执行action的方法

（5）根据返回值做响应操作，执行这些拦截器，执行顺序

重要的概念

1 过滤器和拦截器区别
（1）过滤器可以过滤任意内容，比如jsp、html、servlet、图片路径
（2）拦截器只能拦截action

2 Servlet和action区别
（1）servlet单实例对象
（2）action多实例对象

自定义拦截器

1 在struts2里面有很多的拦截器，在实际开发中，有的功能在拦截器可能没有封装，可以自己写拦截器实现功能封装

2 拦截器结构
（1）通过源代码查看
继承类

继承类实现接口，有三个方法


2）开发中，建议使用另外一种方式
继承 MethodFilterInterceptor类实现
好处：通过配置方式让action某些方法不进行拦截

（3）自己写拦截器，需要配置方式让拦截器对action进行拦截

自定义登录拦截器

1 需求：在项目中有很多action超链接，只有登录状态点击超链接实现功能，如果不是登录状态，点击action超链接，跳转到登录页面

2 使用session域对象登录状态判断
（1）在登录成功之后，把登录信息放到session域对象里面
（2）判断是否登录，判断session是否有值

3 登录基本功能实现
（1）使用图片提交，和type=”submit”效果一样的

（2）action写登录的方法

/属性封装获取用户名和密码

private String username;

private String password;

public String getUsername() {

return username;

}

 

public void setUsername(String username) {

this.username = username;

}

 

public String getPassword() {

return password;

}

 

public void setPassword(String password) {

this.password = password;

}

 

//登录的方法

public String login() {

/*

 * 直接判断

 * admin  250

 * */

if("admin".equals(username) && "250".equals(password)) {

//成功

//使用session域对象

HttpSession session = ServletActionContext.getRequest().getSession();

session.setAttribute("username", username);

//	ActionContext context = ActionContext.getContext();

//	context.getSession().put("username", username);

return "loginsuccess";

} else {

//失败

return "login";

}

}

（3）使用session域对象登录状态

（4）在主页面里面显示当前登录用户名

4 自定义登录拦截器实现过程

第一步 创建类，继承MethodFilterInterceptor类

第二步 重写类里面拦截的方法，写拦截器逻辑

（1）判断是否是登录状态，判断session域里面是否有名称是username值

/**

 * 登录拦截器

 *

 */

public class LoginInterceptor extends MethodFilterInterceptor{

 

//做拦截的方法，写拦截器逻辑

protected String doIntercept(ActionInvocation invocation) throws Exception {

// 判断是否是登录状态，判断session域里面是否有名称是username值

HttpSession session = ServletActionContext.getRequest().getSession();

Object obj = session.getAttribute("username");

//判断

if(obj != null) {//登录

//做类似于放行操作

return invocation.invoke();

} else {//不是登录

//回到登录页面

return "login";

}

}

}

第三步 配置方式让自定义登录拦截器和action建立关系（注册拦截器）
aop思想体现
（1）在struts.xml中package标签里面声明（定义）拦截器

<!-- 1 声明拦截器 -->

<interceptors>

<interceptor name="loginintercept" class="cn.itcast.interceptor.LoginInterceptor"></interceptor>

</interceptors>

（2）在action标签里面使用声明的拦截器

• 对哪个action进行拦截，在那个action标签里面使用声明拦截器
  
  （3）特点：如果在action标签里面使用自定义拦截器，struts2里面默认的拦截器不会执行了，手动把默认拦截器在action标签里面配置一次

<!-- 3 让默认拦截器手动配置一次 -->

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

5 上面配置，对action里面所有方法进行拦截

（1）在action有登录的方法，登录的方法不需要拦截，登录方法拦截，永远不能登录
（2）继承MethodFilterInterceptor，使用配置方式让action里面某些方法不进行拦截
（3）可以让action里面login方法不进行拦截

<!-- 2 使用自定义拦截器 -->
<interceptor-ref name="loginintercept">
<!-- param标签，name属性值  excludeMethods ，标签里面写不进行拦截的方法名称
可以写多个方法  方法1,方法2

-->
<param name="excludeMethods">login</param>
</interceptor-ref>

6 最终测试：

（1）出现问题：页面套页面问题

（2）在form标签里面使用target设置打开位置

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE struts PUBLIC
	"-//Apache Software Foundation//DTD Struts Configuration 2.3//EN"
	"http://struts.apache.org/dtds/struts-2.3.dtd">
<struts>
	
	<package name="demo" extends="struts-default" namespace="/">
		<!-- 1 声明拦截器 -->
		<interceptors>
			<interceptor name="loginintercept" class="cn.itcast.interceptor.LoginInterceptor"></interceptor>
		</interceptors>
		
		<action name="customer_*" class="cn.itcast.action.CustomerAction" method="{1}">
			<!-- 2 使用自定义拦截器 -->
			<interceptor-ref name="loginintercept">
				<!-- param标签，name属性值  excludeMethods ，标签里面写不进行拦截的方法名称
					可以写多个方法  方法1,方法2
				-->
				<param name="excludeMethods">login</param>
			</interceptor-ref>
			
			<!-- 3 让默认拦截器手动配置一次 -->
			<interceptor-ref name="defaultStack"></interceptor-ref>
			
			<result name="list">/jsp/customer/list.jsp</result>
			<!--添加页面  -->
			<result name="toAddPage">/jsp/customer/add.jsp</result>
			<result name="addCustomer">/jsp/success.jsp</result>
			
			<!-- 登录 -->
			<result name="loginsuccess">/index.htm</result>
			<result name="login">/login.jsp</result>
		</action>
	</package>
</struts>