Struts2框架入门
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-blank\WEB-INF\src\java的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>
上一篇: java中的锁