Struts2框架
一、什么是Struts2
Struts2是一个基于MVC设计模式的Web应用框架，它本质上相当于一个servlet，在MVC设计模式中，Struts2作为控制器(Controller)来建立模型与视图的数据交互。Struts 2是Struts的下一代产品，是在 struts 1和WebWork的技术基础上进行了合并的全新的Struts 2框架。其全新的Struts 2的体系结构与Struts 1的体系结构差别巨大。Struts 2以WebWork为核心，采用拦截器的机制来处理用户的请求，这样的设计也使得业务逻辑控制器能够与ServletAPI完全脱离开，所以Struts 2可以理解为WebWork的更新产品。虽然从Struts 1到Struts 2有着太大的变化，但是相对于WebWork，Struts 2的变化很小。
-------------百度百科
二、快速搭建环境
1、下载官方的jar包
官网：https://struts.apache.org/
2、将其中核心j包中app文件中的struts-blank后缀名改为zip，并进行解压其中的lib文件夹中的jar包为运行struts2的基本jar包
3、创建新工程，将基本jar包拷入新建工程中的lib文件夹
4、在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>
其中<filter-class>中过滤器名是根据StrutsPrepareAndExecuteFilter类所在路径来配置的
5、配置用于跳转的页面，此页面是用于跳转到Action中
<body>
<h3>快速入门</h3>
<a href="${pageContext.request.contextPath}/hello.action">跳转</a>
</body>
6、编写Action
package com.clj.action; /** * Struts框架都使用Action类处理用户的请求 * @author Administrator * */ public class HelloAction { /** * Action类中的方法签名有要求，必须这么做 * public 公共的 * 必须有返回值，必须String类型 * 方法名称可以是任意的，但是不能有参数列表 * 页面的跳转：1.return 字符串 2.需要在struts.xml配置文件中，配置跳转的页面 */ public String sayHello(){ //编写代码接收请求的参数 System.out.println("Hello Struts2!"); return "success"; } /** * 演示的method方法的默认值 * 当配置文件中没有配置指定的method方法，他会默认执行Action中的execute方法 * @return */ public String execute(){ System.out.println("method方法的默认值是execute"); return null; } }
7、设置Action配置文件
配置文件是一个xml文件，命名强制为struts2.xml,否则当服务器开启时无法识别不是该文件名的配置文件，该文件建立在src下
其中，其约束条件可以在struts2-blankWEB-INFsrcjava的struts2.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> <!-- 包结构 ，包名不能重复 --> <package name="default" namespace="/" extends="struts-default"> <!-- 配置Action --> <action name="hello" class="com.clj.action.HelloAction" method="sayHello"> <!-- 配置跳转的页面,路经的写法：在Struts2框架中，不管是转发还是重定向，都不需要加项目名 name表示结果页面逻辑视图名称 type 结果类型（转发类型，默认值是转发，也可以设置其他的值） --> <result name="success">/jsp/success.jsp</result> </action> </package> </struts>
8、此时访问跳转页面，即可执行execute方法
总结：这里当执行跳转页面时，会根据配置文件中的action 中的 name属性进行匹配，找到有name为hello 匹配到HelloAction类中的sayHello方法，通过方法反射等进行解析，根据方法的返回值“success”进行页面的跳转，过渡到success.jsp中。值得注意的是，其package包名不能重复！
三、struts2执行流程为：
从客户端发送请求过来 先经过前端控制器（核心过滤器StrutsPrepareAndExecuteFilter）过滤器中执行一组拦截器（一组拦截器 就会完成部分功能代码）执行目标Action，在Action中返回一个结果视图,根据Result的配置进行页面的跳转.
四、Action书写方式
方式一：POJO类
/** * 三种action书写方式之POJO类 * 没有任何继承和实现 * @author Administrator * */ public class Demo1Action { /** * execute是默认方法 * return null：他不会跳转 * @return */ public String execute(){ System.out.println("Demo1Action就是一个POJO类"); return null; } }
方式二：实现Action的接口
import com.opensymphony.xwork2.Action; /** * 三种action书写方式之实现Action的接口，Action是框架提供的接口 * @author Administrator * */ public class Demo2Action implements Action{ @Override public String execute() throws Exception { // TODO Auto-generated method stub System.out.println("Demo2Actions实现了Action的接口"); //Action接口中定义了 public static final String SUCCESS = "success"; return SUCCESS; } }
其中Action有自定义的字符串常量，实现Action的接口返回值就可调用它的常量
方式三：继承ActionSupport类
import com.opensymphony.xwork2.ActionSupport; /** * 三种action书写方式之编写ActionSupport类 * ActionSupport类已经实现了Action和一些其他接口 * @author Administrator * */ public class Demo3Action extends ActionSupport{ public String execute() throws Exception { System.out.println("Demo3Action继承了ActionSupport类。。"); //不跳转 return NONE; } }
五、struts2中常量的配置
1.这里先看看当框架执行时配置文件加载的顺序
查看StrutsPrepareAndExecuteFilter:(核心过滤器)两个功能 ：预处理 和 执行
在预处理功能中 init 方法中会有加载配置文件的代码:
dispatcher.init();
init_DefaultProperties(); // [1] ---- 加载org.apache.struts.default.properties.配置的是struts2的所有常量.
init_TraditionalXmlConfigurations(); // [2] ---- 加载struts-default.xml、struts-plugin.xml、struts.xml
init_LegacyStrutsProperties(); // [3] ---- 加载用户自定义struts.properties
init_CustomConfigurationProviders(); // [5] ---- 加载Struts2定义Bean.
init_FilterInitParameters() ; // [6] ---- 加载web.xml
init_AliasStandardObjects() ; // [7] ---- 用户自定义Bean
结论:
* 先加载default.properties文件，在org/apache/struts2/default.properties文件，都是常量。
* 又加载struts-default.xml配置文件，在核心的jar包最下方，struts2框架的核心功能都是在该配置文件中配置的。
* 再加载struts.xml的配置文件，在src的目录下，代表用户自己配置的配置文件
* 最后加载web.xml的配置文件
* 后加载的配置文件会覆盖掉之前加载的配置文件（在这些配置文件中可以配置常量）
因此： 后配置的常量 会 覆盖先配置的常量.
2、查看常量
3、修改常量
注意：修改常量不能在default.properties文件中修改，可以在struts.xml或者web.xml文件中
1）在struts.xml中
<!-- 编写常量 -->
<constant name="struts.action.extension" value="action,,"></constant>
struts2中访问action默认后缀为action或者不写，这个配置可以进行更改
2）在web.xml中
<filter>
<filter-name>struts2</filter-name>
<filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>
<!-- 编写常量 -->
<init-param>
<param-name>struts.action.extension</param-name>
<param-value>action,,</param-value>
</init-param>
</filter>
六、Action的访问方式
1、传统方式：配置method属性
1）Action类代码
import com.opensymphony.xwork2.ActionSupport; /** * 编写的客户的Action的类 * @author Administrator * */ public class CustomerAction extends ActionSupport { //保存客户 public String save(){ System.out.println("保存客户"); return NONE; } //删除客户 public String delete(){ System.out.println("删除客户"); return NONE; } }
2）配置文件配置
<!-- 演示Action的访问，传统方式 -->
<package name="demo2" namespace="/" extends="struts-default">
<action name="saveCust" class="com.clj.action2.CustomerAction" method="save"/>
<action name="delCust" class="com.clj.action2.CustomerAction" method="delete"/>
</package>
2、通配符的配置
1）Action类
import com.opensymphony.xwork2.ActionSupport; /** * 通配符的方式 * @author Administrator * */ public class LinkmanAction extends ActionSupport{ //保存客户 public String save(){ System.out.println("保存联系人。。"); return "saveOk"; } //删除客户 public String delete(){ System.out.println("删除联系人。。"); return "delOk"; } }
2）配置文件
<!-- 演示Action的访问，通配符方式 -->
<package name="demo3" namespace="/" extends="struts-default">
<!--这里的{1}代表统配第一个*;若name=”linkman_*_*...methd=”{1}”，{1}表示匹配第一个*，{2}表示通配第二个*,即数字表示*的位置，通过通配符调用指定方法-->
<action name="linkman_*" class="com.clj.action2.LinkmanAction" method="{1}"> <result name="saveOk">/jsp/success.jsp</result> <result name="delOk">/jsp/success.jsp</result> </action> </package>
3、动态方法访问
1）开启动态访问常量（注意：常量的配置都是定义在包外）
<!-- 开启动态方法访问 -->
<constant name="struts.enable.DynamicMethodInvocation" value="true"></constant>
2）Action类
import com.opensymphony.xwork2.ActionSupport; /** * 动态方法访问 * @author Administrator * */ public class UserAction extends ActionSupport{ //保存客户 public String save(){ System.out.println("保存用户。。"); return NONE; } //删除客户 public String delete(){ System.out.println("删除用户。。"); return NONE; } }
3）配置文件
<!-- 演示Action的访问，动态方法访问方式 -->
<package name="demo4" namespace="/" extends="struts-default">
<action name="user" class="com.clj.action2.UserAction"/>
</package>
4）域名书写方式
<h3>动态方法访问</h3>
<a href="${pageContext.request.contextPath}/user!save.action">保存联系人</a></br>
<a href="${pageContext.request.contextPath}/user!delete.action">删除联系人</a></br>
七、struts2中数据的之接收数据
struts2怎么传值呢，这里由两种种方式
1.定义一个jsp，利用表单进行数据传输
<form action="${pageContext.request.contextPath}/demo1Action.action" method="post">
姓名：<input type="text" name="username"/></br>
密码：<input type="password" name="psssword"/></br>
<input type="submit" value="注册"/>
</form></br>
2.编写Action
1）方式一：完全解耦合的方式
package com.clj.demo1; import java.util.Arrays; import java.util.Map; import java.util.Set; import com.opensymphony.xwork2.ActionContext; import com.opensymphony.xwork2.ActionSupport; /** * 完全解耦合的方式，使用Servlet的API * 通过操作ActionContexte类的方法来获取Servlet API * @author Administrator * */ public class demo1Action extends ActionSupport{ public String execute() throws Exception{ //完全解耦合的方式 ActionContext context=ActionContext.getContext(); //获取到请求的参数,获取到所有请求的参数 Map<String,Object> map=context.getParameters(); //遍历获取数据 Set<String> keys=map.keySet(); for(String key:keys){ //通过key获取到值 String[] values=(String[]) map.get(key); //默认情况下，struts已经将字符编码转成了UTF-8,无需考虑中文乱码 System.out.println(key+":"+Arrays.toString(values)); } //如果向request对象中存入值 context.put("msg","小东东"); //获取其他map集合 context.getSession().put("msg","小苍"); context.getApplication().put("msg","小泽"); return SUCCESS; } }
2）方式二：原生的Servlet API
package com.clj.demo1; import javax.servlet.http.HttpServletRequest; import org.apache.struts2.ServletActionContext; import com.opensymphony.xwork2.ActionSupport; /** * 原生的Servlet API * @author Administrator * */ public class demo2Action extends ActionSupport{ public String execute() throws Exception{ //获取到request对象 HttpServletRequest request=ServletActionContext.getRequest(); request.setAttribute("msg","小东东"); request.getSession().setAttribute("msg","美美"); ServletActionContext.getServletContext().setAttribute("msg", "小风"); return SUCCESS; } }
八、结果视图处理
1、关于全局页面
为什么要设置全局页面？因为在同一个包下，有时候多个action中所获得的结果视图是同一个，这要每个action配置会觉得冗余，此时可以配置个全局页面来共用
列子：假如当action中方法返回值是success，此时就可无需配置<result>标签，它会自动跳转到success.jsp中
<!-- 配置全局的结果页面，必须定义在当前包下 -->
<global-results>
<!-- type:转发类型
dispatcher:转发，默认值，Action->jsp
redirect: 重定向，Action->jsp
chain: 多个action之间跳转，Action->Action(转发)
redirectAction:多个action之间跳转，Action->Action(重定向)
stream：文件下载
-->
<result name="success" type="dispatcher">/jsp/success.jsp</result>
</global-results>
2.、结果页面的类型
* 结果页面使用<result>标签进行配置，包含两个属性
> name -- 逻辑视图的名称
> type -- 跳转的类型，值一些，需要掌握一些常用的类型。常见的结果类型去struts-default.xml中查找。
* dispatcher -- 转发.type的默认值.Action--->JSP
* redirect -- 重定向. Action--->JSP
* chain -- 多个action之间跳转.从一个Action转发到另一个Action. Action---Action
* redirectAction -- 多个action之间跳转.从一个Action重定向到另一个Action. Action---Action
* stream -- 文件下载时候使用的
演示重定向
action
package com.clj.demo1; import com.opensymphony.xwork2.ActionSupport; /** * 演示重定向 * @author Administrator * */ public class demo3Action extends ActionSupport{ public String save(){ System.out.println("保存"); return SUCCESS; } public String update(){ System.out.println("更新成功"); return NONE; } }
配置文件
<!-- 演示重定向到Action -->
<action name="demo3Action_*" class="com.clj.demo1.demo3Action" method="{1}">
<result name="success" type="redirectAction">demo3Action_update</result>
</action>
九、关于struts2框架数据的封装
封装数据是为了便于开发，降低维护成本，这里有两种方式进行数据的封装。
> 提供对应属性的set方法进行数据的封装。
* 表单的哪些属性需要封装数据，那么在对应的Action类中提供该属性的set方法即可。
* 表单中的数据提交，最终找到Action类中的setXxx的方法，最后赋值给全局变量。
1、方式一：属性驱动
1）属性驱动写法方式一：在action类中直接写从页面中提交的属性数据
jsp：
<h3>属性驱动的方式(直接在Action中编写属性)</h3>
<!-- aciton接收表单值时属性要提供set方法 -->
<form action="${pageContext.request.contextPath}/regist1.action" method="post">
姓名：<input type="text" name="username"/></br>
密码：<input type="password" name="password"/></br>
年龄：<input type="text" name="age"/></br>
<input type="submit" value="注册"/>
</form></br>
action:
package com.clj.demo2; import com.opensymphony.xwork2.ActionSupport; /** * 属性驱动 * 方式一：将Action当做JavaBean类 * @author Administrator * */ public class regist1 extends ActionSupport{ private String username; private String password; private Integer age; //传值，用set，不需要要用get 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 String execute() throws Exception{ System.out.println(username+" "+password+" "+age); return NONE; } }
2)属性驱动写法方式二：将提交的数据封装到一个类中
jsp
<h3>属性驱动的方式(把数据封装到javaBean中)</h3>
<!-- 注意：页面的编写风格为OGNL表达写法 -->
<form action="${pageContext.request.contextPath}/regist2.action" method="post">
<!-- 这里的"user"是根据Aciton中封装属性的类的名称属性而定（private User user;） -->
姓名：<input type="text" name="user.username"/></br>
密码：<input type="password" name="user.password"/></br>
年龄：<input type="text" name="user.age"/></br>
<input type="submit" value="注册"/>
</form></br>
javabean
package com.clj.demo2; public class User { private String username; private String password; private Integer age; 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 Integer getAge() { return age; } public void setAge(Integer age) { this.age = age; } @Override public String toString() { return "User [username=" + username + ", password=" + password + ", age=" + age + "]"; } }
action
package com.clj.demo2; import com.opensymphony.xwork2.ActionSupport; /** * 属性驱动的方式，将数据封装到javaBean中 * @author Administrator * */ public class regist2 extends ActionSupport{ //注意：属性驱动的方式,需要提供get和set方法 private User user; public User getUser() { return user; } public void setUser(User user) { this.user = user; } public String execute(){ System.out.println(user); return NONE; } }
* 注意：只提供一个set方法还不够，必须还需要提供user属性的get和set方法！！！
> 先调用get方法，判断一下是否有user对象的实例对象，如果没有，调用set方法把拦截器创建的对象注入进来，接下直接调用get方法获取传过来的参数
拓展:
1.将数据封装到list中
jsp
<h3>向List集合封装数据(默认情况下，采用属性驱动的方式)</h3>
<!-- 采用OGNL表达式 -->
<form action="${pageContext.request.contextPath}/regist4.action" method="post">
<!-- 这里的"user"是根据Aciton中封装属性的类的名称属性而定（private User user;） -->
姓名：<input type="text" name="list[0].username"/></br>
密码：<input type="password" name="list[0].password"/></br>
年龄：<input type="text" name="list[0].age"/></br>
姓名：<input type="text" name="list[1].username"/></br>
密码：<input type="password" name="list[1].password"/></br>
年龄：<input type="text" name="list[1].age"/></br>
<input type="submit" value="注册"/>
</form></br>
action
package com.clj.demo2; import java.util.List; import com.opensymphony.xwork2.ActionSupport; /** * 属性驱动的方式，把数据封装List集合中 * @author Administrator * */ public class regist4 extends ActionSupport{ private List<User> list; public List<User> getList() { return list; } public void setList(List<User> list) { this.list = list; } public String execute() throws Exception{ for(User user:list){ System.out.println(user); } return NONE; } }
2.将数据封装到Map集合中
jsp
<h3>向Map集合封装数据(默认情况下，采用属性驱动的方式)</h3>
<!-- 采用OGNL表达式 -->
<form action="${pageContext.request.contextPath}/regist5.action" method="post">
<!-- 这里的"user"是根据Aciton中封装属性的类的名称属性而定（private User user;） -->
姓名：<input type="text" name="map['one'].username"/></br>
密码：<input type="password" name="map['one'].password"/></br>
年龄：<input type="text" name="map['one'].age"/></br>
姓名：<input type="text" name="map['two'].username"/></br>
密码：<input type="password" name="map['two'].password"/></br>
年龄：<input type="text" name="map['two'].age"/></br>
<input type="submit" value="注册"/>
</form></br>
action
package com.clj.demo2; import java.util.HashMap; import java.util.List; import java.util.Map; import com.opensymphony.xwork2.ActionSupport; /** * 属性驱动的方式，把数据封装Map集合中 * @author Administrator * */ public class regist5 extends ActionSupport{ private Map<String,User> map=new HashMap<String,User>(); public Map<String, User> getMap() { return map; } public void setMap(Map<String, User> map) { this.map = map; } public String execute() throws Exception{ System.out.println(map); return NONE; } }
2、方式二：模型驱动
1)手动实例化javabean
private User user=new User();
2）实现ModelDriven<T>接口，实现getModel()的方法，在getModel()方法中返回javaBean
jsp
<h3>模型驱动</h3>
<form action="${pageContext.request.contextPath}/regist3.action" method="post">
<!-- 这里的"user"是根据Aciton中封装属性的类的名称属性而定（private User user;） -->
姓名：<input type="text" name="username"/></br>
密码：<input type="password" name="password"/></br>
年龄：<input type="text" name="age"/></br>
<input type="submit" value="注册"/>
</form></br>
action代码
package com.clj.demo2; import com.opensymphony.xwork2.ActionSupport; import com.opensymphony.xwork2.ModelDriven; /** * 模型驱动的方式 * 1.实现ModelDrivern接口 * 2.必须手动实列化对象（需要自己new好） * @author Administrator */ public class regist3 extends ActionSupport implements ModelDriven<User>{ //必须手动实例化 private User user=new User(); //获取模型对象 public User getModel() { // TODO Auto-generated method stub return user; } public String execute() throws Exception{ System.out.println(user); return NONE; } }
十、struts2之拦截器
1、什么是拦截器？
java里的拦截器是动态拦截Action调用的对象。它提供了一种机制可以使开发者可以定义在一个action执行的前后执行的代码，也可以在一个action执行前阻止其执行，同时也提供了一种可以提取action中可重用部分的方式。在AOP(Aspect-Oriented Programming)中拦截器用于在某个方法或字段被访问之前，进行拦截然后在之前或之后加入某些操作。
---------360百科
拦截器的利用是struts2框架的一个特点，即面向切面编程
2、编写一个拦截器
1）定义一个拦截器类
package com.itheima.interceptior; import com.google.common.collect.AbstractIterator; import com.opensymphony.xwork2.ActionInvocation; import com.opensymphony.xwork2.interceptor.AbstractInterceptor; /** * 编写简单的拦截器 * @author Administrator * */ public class DemoInterceptor extends AbstractInterceptor{ /** * intercept用来进行拦截的 */ public String intercept(ActionInvocation invocation) throws Exception { System.out.println("Action方法执行之前"); //执行下一个拦截器 String result=invocation.invoke(); System.out.println("Action方法执行之后"); return result; } }
2) 定义一个action
package com.clj.demo3; import com.opensymphony.xwork2.ActionSupport; public class UserAction extends ActionSupport{ public String execute() throws Exception{ System.out.println("我是Action,我正常执行了"); return NONE; } }
3) 配置文件配置
<package name="demo3" extends="struts-default" namespace="/"> <interceptors> <!-- 定义了拦截器 --> <interceptor name="DemoInterceptor" class="com.itheima.interceptior.DemoInterceptor"/> </interceptors> <action name="userAction" class="com.clj.demo3.UserAction"> <!-- 只要是引用自己的拦截器，默认栈的拦截器就不执行了 ，必须手动引入默认栈--> <interceptor-ref name="DemoInterceptor"/> <interceptor-ref name="defaultStack"/> </action> </package>
3、使用拦截器验证用户登录
1) 定义一个拦截器
package com.clj.interceptor; import org.apache.struts2.ServletActionContext; import com.heima.domain.User; import com.opensymphony.xwork2.ActionInvocation; import com.opensymphony.xwork2.interceptor.MethodFilterInterceptor; /** * 自动以拦截器，判断当前系统是否已经登录，如果登录，继续执行 * 如果没有登录，跳转到登录页面 * AbstractInterceptor会拦截所有方法 * MethodFilterInterceptor可以对指定的方法进行拦截 * @author Administrator * */ public class UserInterceptor extends MethodFilterInterceptor{ /** * 进行拦截的方法 */ protected String doIntercept(ActionInvocation invocation) throws Exception { //获得session对象 User user=(User) ServletActionContext.getRequest().getSession().getAttribute("existUser"); if(user==null){ //没有登录,返回字符串，后面就不会执行了 return "login"; } return invocation.invoke(); } }
2）action
package com.itheima.action; import java.lang.reflect.InvocationTargetException; import java.util.Map; import javax.servlet.http.HttpServletRequest; import org.apache.commons.beanutils.BeanUtils; import org.apache.struts2.ServletActionContext; import com.heima.domain.User; import com.itheima.service.UserService; import com.opensymphony.xwork2.ActionSupport; /** * 用户登录模块控制器 * @author Administrator * */ public class UserAction extends ActionSupport{ /** * 处理登录功能 * @return */ public String login(){ //这边没有学习功能，封装数据，现在还需要request对象 //怎么获取reqeust方式 HttpServletRequest request=ServletActionContext.getRequest(); //获取请求参数 Map<String,String[]> map=request.getParameterMap(); User user=new User(); try { BeanUtils.populate(user,map); //调用业务层 User existUser=new UserService().login(user); //判断 if(existUser==null){ //说明，用户名或者密码错误了 return LOGIN; }else{ //存入session中 request.getSession().setAttribute("existUser", existUser); return SUCCESS; } } catch (Exception e) { // TODO Auto-generated catch block e.printStackTrace(); } return NONE; } }
配置文件
<!-- 配置用户的模块 -->
<action name="user_*" class="com.itheima.action.UserAction" method="{1}">
<!--<result name="login">/login.jsp</result>-->
<result name="success">/index.jsp</result>
<interceptor-ref name="UserInterceptor">
<param name="excludeMethods">login</param>
</interceptor-ref>
<interceptor-ref name="defaultStack"/>
</action>
十一、OGNL
1、什么是OGNL
OGNL是Object-Graph Navigation Language的缩写，它是一种功能强大的表达式语言，通过它简单一致的表达式语法，可以存取对象的任意属性，调用对象的方法，遍历整个对象的结构图，实现字段类型转化等功能。它使用相同的表达式去存取对象的属性。
------------360百科
Struts2框架使用OGNL作为默认的表达式语言
2、演示OGNL表达式
package com.clj.demo1; import ognl.Ognl; import ognl.OgnlContext; import ognl.OgnlException; import org.junit.Test; /** * 演示OGNL表达式 * @author Administrator * */ public class OgnlDemo { /** * OGNL访问对象的方法 * @throws OgnlException */ @Test public void run1() throws OgnlException{ //上下文对象 OgnlContext context=new OgnlContext(); //获取到根对象(ognl都是从根对象进行取值) Object root=context.getRoot(); //存储数据 context.put("name","美美"); //获取值,表达式写法 Object obj=Ognl.getValue("#name",context,root); System.out.println(obj); } /** * OGNL表达式调用方法 * @throws OgnlException */ @Test public void run2() throws OgnlException{ //上下文对象 OgnlContext context=new OgnlContext(); //获取到根对象(ognl都是从根对象进行取值) Object root=context.getRoot(); //获取值,表达式写法(这里是让字符串调用他的方法) Object obj=Ognl.getValue("'haha'.length()",context,root); System.out.println(obj); } }
3、jsp中演示OGNL
1) 先引入Strust2标签库
<%@ taglib prefix="s" uri="/struts-tags" %>
2) 调用
<body>
<h3>条件：假如值栈中已经存入值了，在JSP页面上从值栈中获取值</h3>
<!--
1.先引入Struts框架中提供的标签库，s标签
2.可以使用提供的标签(很多，掌握重点的标签)
-->
<!-- 从值栈中获取值的value,中间编写就是OGNL表达式 -->
<s:property value="username"/>
<!-- 显示常量：加''号 -->
<s:property value="'username'"/>
<!-- 调用方法：加.加方法 -->
<s:property value="'username'.length()"/>
</body>
十二、Struts2之值栈
1、什么是值栈
* 值栈就相当于Struts2框架的数据的中转站，向值栈存入一些数据。从值栈中获取到数据。
* ValueStack 是 struts2 提供一个接口，实现类 OgnlValueStack ---- 值栈对象 （OGNL是从值栈中获取数据的 ）
* Action是多例的，有一起请求，创建Action实例，创建一个ActionContext对象，代表的是Action的上下文对象，还会创建一个ValueStack对象。
* 每个Action实例都有一个ValueStack对象 （一个请求 对应 一个ValueStack对象 ）
* 在其中保存当前Action 对象和其他相关对象
* Struts 框架把 ValueStack 对象保存在名为 “struts.valueStack” 的请求属性中,request中 （值栈对象 是 request一个属性）
* ValueStack vs = (ValueStack)request.getAttribute("struts.valueStack");
2、关于值栈的内部结构
* 值栈由两部分组成
> root -- Struts把动作和相关对象压入 ObjectStack 中--List（底层ArrayList）
> context -- Struts把各种各样的映射关系(一些 Map 类型的对象) 压入 ContextMap 中（底层Map,当讲Servlet的API时，完成接耦合方式ActionContext.getRequest()所返回的 Map集合就是此集合）
* Struts会默认把下面这些映射压入ContextMap（context）中
* 注意：request代表的是Map集合的key值(字符串名)，value的值其实也是一个Map集合。
> parameters: 该 Map 中包含当前请求的请求参数 ?name=xxx&password=123
> request: 该 Map 中包含当前 request 对象中的所有属性
> session: 该 Map 中包含当前 session 对象中的所有属性
> application:该 Map 中包含当前 application 对象中的所有属性
> attr: 该 Map 按如下顺序来检索某个属性: request, session, application
* ValueStack中 存在root属性 (CompoundRoot) 、 context 属性 （OgnlContext ）
> CompoundRoot 就是ArrayList
> OgnlContext 就是 Map
* context 对应Map 引入 root对象
> context中还存在 request、 session、application、 attr、 parameters 对象引用
> OGNL表达式访问值栈中的数据
* 访问root中数据时 不需要 #
* 访问 request、 session、application、 attr、 parameters 对象数据 必须写 #
> 操作值栈 默认指 操作 root 元素（至于context是框架自动将请求参数或者其他数据封装到conttext中）
3、在jsp中查看值栈
<!-- 在JSP页面上，查看值栈的内部结构 -->
<s:debug/>
4、关于值栈中压值
1）压字符串之push方法
/** * 演示值栈对象的目录结构 * 想栈中压元素，先进先出 * push：压入的对象 * set：压入集合(先判断压入的对象是否是集合，不是则强转为集合，再创建键值对；是则在原有集合中压入元素) * @author Administrator * */ public String execute() throws Exception{ /*//使用获取值栈对象 HttpServletRequest request=ServletActionContext.getRequest(); ValueStack vs=(ValueStack) request.getAttribute("struts.valueStack"); System.out.println(vs);*/ //获取值栈对象，先获取到ActionContext对象 ValueStack vs=ActionContext.getContext().getValueStack(); System.out.println(vs); //栈顶压的是字符串 vs.push("
美美
");return NONE; }
取值
<h3>从值栈中获取值</h3>
<!--值栈中获取的对象，当存入字符串时，栈顶第一个位置为对象，第二位置为Action,第三位置为封转栈的信息
栈的默认索引是从0开始：[0]表示获取栈顶的封装对象的一些列信息，[0].top获取对象值
//vs.push("美美");-->
<s:property value="[0]"/>
<s:property value="[0].top"/>
2）压字符串之set方法
ValueStack vs=ActionContext.getContext().getValueStack(); //栈顶压的是集合 vs.set("msg","金在中");
取值
<!-- 从栈顶获取字符串 ，方法为set，值栈中存的是Map集合>
//vs.set("msg","金在中");-->
<s:property value="[0].top.msg"/>
3）栈顶放的是User对象,用push方法
ValueStack vs=ActionContext.getContext().getValueStack(); //创建User对象 User user=new User(); user.setUsername("美美"); user.setPassword("123"); //压栈 vs.push(user);
取值
<!--栈顶放的是User对象,用push方法 //[0].top关键字可以省略，值栈中提供getValue方法，从结果中找指定属性 /* User user=new User(); user.setUsername("美美"); user.setPassword("123"); //压栈 vs.push(user);*/--> <s:property value="[0].top.username"/> <s:property value="[0].top.password"/> <s:property value="password"/>
4）栈顶放的是User对象,用set方法
ValueStack vs=ActionContext.getContext().getValueStack(); //创建User对象 User user=new User(); user.setUsername("美美"); user.setPassword("123"); //压栈 vs.set("user",user);
取值
<!--栈顶放的是User对象,用set方法 // vs.set("user",user);--> <s:property value="[0].top.user.username"/> <s:property value="[0].top.user.password"/> <s:property value="user.password"/>
5）在action中配置成员属性，并提供set/get方法，jsp同样可以来接收
private User user=new User("小泽","456"); //提供set/get方法
取值
<!-- 在ValueStack1Action提供了成员属性 //private User user=new User("小泽","456"); //提供set/get方法 //vs.push(user); 从栈顶开始查找，找user的属性，显示名称，返回的小泽 [1].top获取到ValueStack1Action,而该Action封装了user属性 [0].top.user返回的是user对象--> <s:property value="user.username"/>
6）获取值栈中（root）集合中的值push
List<User> list=new ArrayList<User>(); list.add(new User("熊大","123")); list.add(new User("熊二","456")); list.add(new User("熊三","789")); //把集合压栈 vs.push(list);
取值
<!-- 获取list集合 //vs.push(list);--> <s:property value="[0].top[0].username"/> <s:property value="[0].top[1].username"/>
7）获取值栈中（root）集合中的值set
List<User> list=new ArrayList<User>(); list.add(new User("熊大","123")); list.add(new User("熊二","456")); list.add(new User("熊三","789")); //把集合压栈 vs.set("list",list);
取值
<!-- 获取list集合 //vs.set("list",list); --> <s:property value="list[0].username"/>
8）利用迭代标签取值
ValueStack vs=ActionContext.getContext().getValueStack(); List<User> list=new ArrayList<User>(); list.add(new User("熊大","123")); list.add(new User("熊二","456")); list.add(new User("熊三","789")); //把集合压栈 vs.set("list",list);
取值
<!-- 迭代标签 属性： * value 要迭代的集合，需要从值栈中获取 * var 迭代过程中，遍历的对象 * var编写上，会把迭代产生的对象默认压入到context栈中 * var不编写上，默认吧迭代长生的对象压入到root栈中 --> <!-- 编写var:value="[0].top"等同于value="list" --> <s:iterator value="list" var="u"> <!--此时是压入context，取值要加#号--> <s:property value="#u.username"/> <s:property value="#u.password"/> </s:iterator>
<!-- 没有编写var关键字-->
<s:iterator value="list">
<s:property value="[0].top.username"/>
<s:property value="password"/>
</s:iterator>
9) 从context栈中获取值
ValueStack vs=ActionContext.getContext().getValueStack(); //从context栈中获取值(注意：以上push与set默认都是操纵的root栈) //context底层已经封装request session对象，操作的都是map集合 HttpServletRequest request=ServletActionContext.getRequest(); request.setAttribute("msg","美美"); request.getSession().setAttribute("msg", "小风");
取值
<!-- 从context栈中获取值，加#号-->
<s:property value="#request.msg"/>
<s:property value="#session.msg"/>
10）针对域名传过来的值，怎么接收
加入域名为http://localhost:8080/xx/xx.action?id=5
<!-- 针对于域名传过来的参数（参数名为id),框架会自动封装 -->
<s:property value="#parameters.id"/>
11) 利用EL表达式接收数据
引入jstl标签库
<%@taglib prefix="c" uri="http://java.sun.com/jstl/core_rt" %>
取值
<!-- 在JSP页面上可以使用EL和JSTL标签库来取值 使用装饰者模式，连接池全栈编码 getAttribute()增强了 --> <c:forEach items="${list }" var="user"> ${user.username}--${user.passwords} </c:forEach>