一、Struts2的执行流程
当用户访问某一个Action的时候，先经过核心过滤器，在核心过滤器中执行一组拦截器（这组拦截器实现部分功能），执行目标Action，根据Action的返回值，进行页面跳转。
二、Action的编写方式
1:Action是一个POJO的类
public class ActionDemo1 {
public String execute(){
System.out.println("ActionDemo1执行了...........");
return null;
}
}
2:实现一个Action的接口
public class ActionDemo2 implements Action {
@Override
public String execute() throws Exception {
System.out.println("ActionDemo2执行了...........");
return null;
}
}
3:Action的编写方式三：Action类继承ActionSupport类
(推荐使用继承ActionSupport方式，ActionSupport中提供了数据校验、国际化等一系列操作的方法。)
public class ActionDemo3 extends ActionSupport{
@Override
public String execute() throws Exception{
System.out.println("ActionDemo3执行了......");
return NONE;
}
}
XML配置方式
<?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>
<!-- Struts2为了管理Action的配置，通过包进行管理。 -->
<!-- 配置Struts2的包 ================ -->
<package name="demo" extends="struts-default" namespace="/">
<!-- 配置Action================ -->
<action name="actionDemo1" class="demo/ActionDemo1"></action>
<action name="actionDemo2" class="demo/ActionDemo2"></action>
<action name="actionDemo3" class="demo/ActionDemo3"></action>
</package>
</struts>
三、Action的访问方式
1、通过method方式访问Action
public class UserAction extends ActionSupport {
public String Find(){
System.out.println("查询用户....................");
return NONE;
}
public String Update(){
System.out.println("更新用户....................");
return NONE;
}
public String Delete(){
System.out.println("删除用户....................");
return NONE;
}
public String Save(){
System.out.println("保存用户....................");
return NONE;
}
}
<struts>
<package name="demo1" extends="struts-default" namespace="/">
<!--通过method方式访问Action -->
<action name="userFind" class="demo1.UserAction" method="Find"></action>
<action name="userUpdate" class="demo1.UserAction" method="Update"></action>
<action name="userDelete" class="demo1.UserAction" method="Delete"></action>
<action name="userSave" class="demo1.UserAction" method="Save"></action>
</package>
</struts>
**在JSP中的编写**
<h3>通过method方式</h3>
<a href="${ pageContext.request.contextPath }/userFind.action">查询用户</a>
<br />
<a href="${ pageContext.request.contextPath }/userUpdate.action">更新用户</a>
<br />
<a href="${ pageContext.request.contextPath }/userDelete.action">删除用户</a>
<br />
<a href="${ pageContext.request.contextPath }/userSave.action">保存用户</a>
<br />
2、通过通配符的方法访问Action
public class ProductAction extends ActionSupport {
public String find() {
System.out.println("查询商品.................");
return NONE;
}
public String update() {
System.out.println("更新商品.................");
return NONE;
}
public String delete() {
System.out.println("删除商品.................");
return NONE;
}
public String save() {
System.out.println("保存商品.................");
return NONE;
}
}
<struts>
<package name="demo1" extends="struts-default" namespace="/">
<!--通过通配符的方式访问Action -->
<action name="product_*" class="demo1.ProductAction" method="{1}"></action>
</package>
</struts>
**在JSP中的编写**
<h3>通过通配符的方式</h3>
<a href="${ pageContext.request.contextPath }/product_find.action">查询商品</a>
<br />
<a href="${ pageContext.request.contextPath }/product_update.action">更新商品</a>
<br />
<a href="${ pageContext.request.contextPath }/product_delete.action">删除商品</a>
<br />
<a href="${ pageContext.request.contextPath }/product_save.action">保存商品</a>
<br />
3、通过动态方法访问的方式
public class CustomerAction extends ActionSupport {
public String find() {
System.out.println("查询客户................");
return NONE;
}
public String update() {
System.out.println("更新客户................");
return NONE;
}
public String delete() {
System.out.println("更新客户................");
return NONE;
}
public String save() {
System.out.println("保存客户................");
return NONE;
}
}
<struts>
<!--配置动态方法的常量：开启动态方法访问 -->
<constant name="struts.enable.DynamicMethodInvocation" value="true"></constant>
<!--通过动态方法的方式访问Action -->
<action name="customer" class="demo1.CustomerAction"></action>
</package>
</struts>
**在JSP中的编写**
<h3>通过动态方法访问的方式</h3>
<a href="${ pageContext.request.contextPath }/customer!find.action">查询客户</a>
<br />
<a href="${ pageContext.request.contextPath }/customer!update.action">更新客户</a>
<br />
<a href="${ pageContext.request.contextPath }/customer!delete.action">删除客户</a>
<br />
<a href="${ pageContext.request.contextPath }/customer!save.action">保存客户</a>
<br />
总结：第二种方式最常用，第三种方式记得开启动态方法访问，配置其常量。
四、Struts2对Servlet的API的访问
1、完全解耦合的方式
public class RequestDemo1 extends ActionSupport {
@Override
public String execute() throws Exception {
// 一、接收参数：
// 利用Struts2中的对象ActionContext对象
ActionContext context = ActionContext.getContext();
// 调用ActionContext中的方法
// 类似于Map<String,String[]>request.getParameterMap();
Map<String,Object> map=context.getParameters();
for(String key:map.keySet()){
String[] values=(String[]) map.get(key);
System.out.println(key+" ： "+Arrays.toString(values));
}
//二、向域对象中存入数据
context.put("reqName", "reqValue");//相当于request.setAttribute();
context.getSession().put("sessName", "sessValue");//相当于session.setAttribute();
context.getApplication().put("appName", "appValue");//相当于application.setAttribute();
return SUCCESS;
}
}
<struts>
<package name="demo1" extends="struts-default" namespace="/">
<action name="requestDemo1" class="demo1.RequestDemo1">
<!--局部结果页面 -->
<result name="success">/demo1/demo2.jsp</result>
</action>
</package>
</struts>
**在JSP中的编写**
demo1.jsp
<h3>方式一：完全解耦合的方式</h3>
<form action="${ pageContext.request.contextPath }/requestDemo1.action" method="post">
姓名：<input type="text" name="name"/><br/>
密码：<input type="password" name="password"><br/>
<input type="submit" value="提交">
</form>
demo2.jsp
<h1>显示数据</h1>
${reqName }
${sessName }
${appName }
2、使用Servlet的API的原生方式
public class RequestDemo2 extends ActionSupport{
@Override
public String execute()throws Exception{
//一、接收数据
//直接获得request对象，通过ServletActionContext
HttpServletRequest request=ServletActionContext.getRequest();
Map<String,String[]> map=request.getParameterMap();
for(String key:map.keySet()){
String[] values=map.get(key);
System.out.println(key+"："+Arrays.toString(values));
}
//二、向域对象中保存数据
//向request中保存数据
request.setAttribute("reqName", "reqValue");
//向session中保存数据
request.getSession().setAttribute("sessName", "sessValue");
//向application中保存数据
ServletActionContext.getServletContext().setAttribute("appName", "appValue");
return SUCCESS;
}
}
<struts>
<package name="demo1" extends="struts-default" namespace="/">
<action name="requestDemo3" class="demo1.RequestDemo3"></action>
</package>
</struts>
**在JSP中的编写**
demo1.jsp
<h3>方式二：使用原生的方式访问</h3>
<form action="${ pageContext.request.contextPath }/requestDemo2.action" method="post">
姓名：<input type="text" name="name"/><br/>
密码：<input type="password" name="password"><br/>
<input type="submit" value="提交">
</form>
demo2.jsp
<h1>显示数据</h1>
${reqName }
${sessName }
${appName }
3、接口注入的方式
public class RequestDemo3 extends ActionSupport implements ServletRequestAware,ServletContextAware {
private HttpServletRequest request;
private ServletContext context;
@Override
public String execute() throws Exception {
// 一、接收参数
// 通过接口注入的方式获得request对象
Map<String, String[]> map = request.getParameterMap();
for (String key : map.keySet()) {
String[] values = map.get(key);
System.out.println(key + " " + Arrays.toString(values));
}
// 二、向域对象中保存数据
// 向request中保存数据
request.setAttribute("reqName", "reqValue");
// 向session中保存数据
request.getSession().setAttribute("sessName", "sessValue");
// 向application中保存数据
context.setAttribute("appName", "appValue");
return SUCCESS;
}
@Override
public void setServletRequest(HttpServletRequest request) {
this.request = request;
}
@Override
public void setServletContext(ServletContext context) {
// TODO Auto-generated method stub
this.context=context;
}
}
<struts>
<package name="demo1" extends="struts-default" namespace="/">
<!--全局结果页面 -->
<global-results>
<result name="success">/demo1/demo2.jsp</result>
</global-results>
<action name="requestDemo3" class="demo1.RequestDemo3"></action>
</package>
</struts>
**在JSP中的编写**
demo1.jsp
<h3>方式三：接口注入的方式</h3>
<form action="${ pageContext.request.contextPath }/requestDemo3.action" method="post">
姓名：<input type="text" name="name"/><br/>
密码：<input type="password" name="password"><br/>
<input type="submit" value="提交">
</form>
demo2.jsp
<h1>显示数据</h1>
${reqName }
${sessName }
${appName }
总结：第一种方式只能获得代表request、session、application的数据的Map集合，不能操作这些对象的本身的方法；第二种方式可以操作域对象的数据，同时也可以获得对象的方法；第三种方式中的Servlet是单例的，多个程序访问同一个Servlet只会创建一个Servlet的实例;Action是多例的，一次请求创建一个Action的实例（不会出现线程安全的问题）。
五、结果页面的配置
1、全局结果页面：全局结果页面指的是，在包中配置一次，其他的在这个包中的所有的action只要返回了这个值，都可以跳转到这个页面。
针对这个包下的所有的action的配置都有效。
2、局部结果页面：局部结果页面指的是，只能在当前的action中的配置有效。
针对当前的action的配置有效。
六、result标签的配置
result标签用于配置页面的跳转，在result标签上有两个属性：
name属性：逻辑视图的名称。默认值：success
type属性：页面跳转的类型。
dispatcher：默认值，请求转发（Action转发Jsp）
redirect：重定向（Action重定向Jsp）
chain：转发（Action转发Action）
redirectAction：重定向（Action重定向Action）
stream：Struts2中提供文件下载的功能
注：dispatcher和redirect比较重要。
七、Struts2的数据封装
1、属性驱动，数据封装方式一：提供属性的set方法的方式（不常用）
public class UserAction1 extends ActionSupport{
private String username;
private String password;
private Integer age;
private Date birthday;
private Double salary;
public void setUsername(String username) {
this.username = username;
}
public void setPassword(String password) {
this.password = password;
}
public void setAge(Integer age) {
this.age = age;
}
public void setBirthday(Date birthday) {
this.birthday = birthday;
}
public void setSalary(Double salary) {
this.salary = salary;
}
public String execute() throws Exception{
System.out.println(username);
System.out.println(password);
System.out.println(age);
System.out.println(birthday);
System.out.println(salary);
return NONE;
}
}
<struts>
<package name="demo2" extends="struts-default" namespace="/">
<action name="userAction1" class="demo2.UserAction1"></action>
</package>
</struts>
JSP的编写：
<h3>方式一：属性驱动-提供属性的set方法的方式</h3>
<s:fielderror/>
<form action="${ pageContext.request.contextPath }/userAction1.action"
method="post">
<table border="1px">
<tr align="center">
<td>用户名：</td>
<td><input type="text" name="username"></td>
</tr>
<tr align="center">
<td>密码：</td>
<td><input type="password" name="password"></td>
</tr>
<tr align="center">
<td>年龄：</td>
<td><input type="text" name="age"></td>
</tr>
<tr align="center">
<td>生日：</td>
<td><input type="text" name="birthday"></td>
</tr>
<tr align="center">
<td>工资：</td>
<td><input type="text" name="salary"></td>
</tr>
<tr align="left">
<td colspan="2"><input type="submit" value="提交" /></td>
</tr>
</table>
</form>
2、属性驱动，数据封装方式二：在页面中提供表达式方式
public class UserAction2 extends ActionSupport {
// 提供User对象
private User user;
// 提供user的set和get方法：一定要提供get方法
// 因为拦截器完成数据封装，需要创建User对象将其赋给“private User user;”中的user，
// 对属性赋值的时候会判断有没有user的实例，如何获取user，通过get方法，没有get方法，就获取不到user
// 每一次对属性进行赋值的时候，如果没有user就会new一个，User有5个属性，如果没有get方法，new了五次对象
public User getUser() {
return user;
}
public void setUser(User user) {
this.user = user;
}
@Override
public String execute() throws Exception {
System.out.println(user);
return NONE;
}
}
<struts>
<package name="demo2" extends="struts-default" namespace="/">
<action name="userAction2" class="demo2.UserAction2"></action>
</package>
</struts>
在JSP中的编写：
<h3>方式二：属性驱动-在页面中提供表达式方式</h3>
<form action="${ pageContext.request.contextPath }/userAction2.action"
method="post">
<table border="1px">
<tr align="center">
<td>用户名：</td>
<td><input type="text" name="user.username"></td>
</tr>
<tr align="center">
<td>密码：</td>
<td><input type="password" name="user.password"></td>
</tr>
<tr align="center">
<td>年龄：</td>
<td><input type="text" name="user.age"></td>
</tr>
<tr align="center">
<td>生日：</td>
<td><input type="text" name="user.birthday"></td>
</tr>
<tr align="center">
<td>工资：</td>
<td><input type="text" name="user.salary"></td>
</tr>
<tr align="left">
<td colspan="2"><input type="submit" value="提交" /></td>
</tr>
</table>
</form>
3、模型驱动-模型驱动方式
public class UserAction3 extends ActionSupport implements ModelDriven<User> {
// 模型驱动使用的对象：前期必须手动提供对象的
private User user = new User();//手动实例化User
@Override
public User getModel() {
// 模型驱动需要使用的方法：
return user;
}
@Override
public String execute() throws Exception {
System.out.println(user);
return NONE;
}
}
<struts>
<package name="demo2" extends="struts-default" namespace="/">
<action name="userAction3" class="demo2.UserAction3"></action>
</package>
</struts>
在JSP中编写：
<h3>方式三：模型驱动-模型驱动方式</h3>
<form action="${ pageContext.request.contextPath }/userAction3.action"
method="post">
<table border="1px">
<tr align="center">
<td>用户名：</td>
<td><input type="text" name="username"></td>
</tr>
<tr align="center">
<td>密码：</td>
<td><input type="password" name="password"></td>
</tr>
<tr align="center">
<td>年龄：</td>
<td><input type="text" name="age"></td>
</tr>
<tr align="center">
<td>生日：</td>
<td><input type="text" name="birthday"></td>
</tr>
<tr align="center">
<td>工资：</td>
<td><input type="text" name="salary"></td>
</tr>
<tr align="left">
<td colspan="2"><input type="submit" value="提交" /></td>
</tr>
</table>
</form>
总结：模型驱动方式是最常用的方式：
缺点：只能同时向一个对象中封装数据，而使用第二种方式可以向多个对象中同时封装数据。
八、关于INPUT逻辑视图
INPUT的逻辑视图的配置：
Action接口中提供了五个逻辑视图的名称：
SUCCESS
ERROR
LOGIN
INPUT —input在某些拦截器中会使用
NONE
拦截器会检查错误区域中是否有错误信息：
如果没有：直接到目标Action
如果有：跳转到INPUT逻辑视图
九、Struts2的复杂类型的数据封装
1、封装数据到List集合中
public class ProductAction1 extends ActionSupport{
private List<Product> products;
//提供集合的get、set方法
public List<Product> getProducts() {
return products;
}
public void setProducts(List<Product> products) {
this.products = products;
}
@Override
public String execute(){
for(Product product:products){
System.out.println(product);
}
return NONE;
}
}
<struts>
<package name="demo3" extends="struts-default" namespace="/">
<action name="productAction1" class="demo3.ProductAction1"></action>
</package>
</struts>
在Jsp中的编写：
<h3>封装到List集合中：批量插入商品</h3>
<form action="${ pageContext.request.contextPath }/productAction1.action" method="post">
商品名称：<input type="text" name="products[0].name"><br/>
商品价格：<input type="text" name="products[0].price"><br/>
商品名称：<input type="text" name="products[1].name"><br/>
商品价格：<input type="text" name="products[1].price"><br/>
商品名称：<input type="text" name="products[2].name"><br/>
商品价格：<input type="text" name="products[2].price"><br/>
<input type="submit" value="提交">
</form>
2、封装数据到Map集合中
public class ProductAction2 extends ActionSupport {
private Map<String, Product> map;
public Map<String, Product> getMap() {
return map;
}
public void setMap(Map<String, Product> map) {
this.map = map;
}
@Override
public String execute() {
for(String key:map.keySet()){
Product product=map.get(key);
System.out.println(key+" "+product);
}
return NONE;
}
}
<struts>
<package name="demo3" extends="struts-default" namespace="/">
<action name="productAction2" class="demo3.ProductAction2"></action>
</package>
</struts>
在Jsp中的编写：
<h3>封装到Map集合中：批量插入商品</h3>
<form action="${ pageContext.request.contextPath }/productAction2.action" method="post">
商品名称：<input type="text" name="map['one'].name"><br/>
商品价格：<input type="text" name="map['one'].price"><br/>
商品名称：<input type="text" name="map['two'].name"><br/>
商品价格：<input type="text" name="map['two'].price"><br/>
商品名称：<input type="text" name="map['three'].name"><br/>
商品价格：<input type="text" name="map['three'].price"><br/>
<input type="submit" value="提交">
</form>
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
