struts2学习记录

struts.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>
    <!-- i18n:国际化. 解决post提交乱码 -->
    <constant name="struts.i18n.encoding" value="UTF-8"></constant>
    <!-- 指定反问action时的后缀名 
        http://localhost:8080/struts2_day01/hello/HelloAction.do
    -->
    <constant name="struts.action.extension" value="action,,do"></constant>
    <!-- 指定struts2是否以开发模式运行
            1.热加载主配置.(不需要重启即可生效)
            2.提供更多错误信息输出,方便开发时的调试
     -->
    <constant name="struts.devMode" value="true"></constant>

    <!-- package:将Action配置封装.就是可以在Package中配置很多action.
            name属性: 给包起个名字,起到标识作用.随便起.不能其他包名重复.
            namespace属性:给action的访问路径中定义一个命名空间
            extends属性: 继承一个 指定包
            abstract属性:包是否为抽象的; 标识性属性.标识该包不能独立运行.专门被继承
      -->
    <package name="hello" namespace="/hello" extends="struts-default" >
        <!-- action元素:配置action类
                name属性: 决定了Action访问资源名.
                class属性: action的完整类名
                method属性: 指定调用Action中的哪个方法来处理请求
         -->
        <action name="HelloAction" class="cn.example.a_hello.HelloAction" method="hello" >
            <!-- result元素:结果配置 
                    name属性: 标识结果处理的名称.与action方法的返回值对应.
                    type属性: 指定调用哪一个result类来处理结果,默认使用转发.
                    标签体:填写页面的相对路径
            -->
            <result name="success" type="dispatcher" >/hello.jsp</result>
        </action>
    </package>
    <!-- 引入其他struts配置文件 -->
    <include file="cn/example/b_dynamic/struts.xml"></include>
(<!-- 配置动态方法调用是否开启常量
                默认是关闭的,需要开启 (了解 action名加!方法名)
         -->
    <constant name="struts.enable.DynamicMethodInvocation" value="false"></constant>

        <package name="dynamic" namespace="/dynamic" extends="struts-default" >
            <!-- 动态方法调用方式2:通配符方式
                 使用{1} 取出第一个星号通配的内容
              -->
            <action name="Demo1Action_*" class="cn.example.b_dynamic.Demo1Action" method="{1}" >
                <result name="success" >/hello.jsp</result>
            </action>)
    <include file="cn/example/c_default/struts.xml"></include>
(<package name="default" namespace="/default" extends="struts-default" >
            <!-- 找不到包下的action,会使用Demo2Action作为默认action处理请求 -->
            <default-action-ref name="Demo2Action"></default-action-ref>
            <!-- method属性:execute  -->
            <!-- result的name属性:success  -->
            <!-- result的type属性:dispatcher 转发  -->
            <!-- class属性:com.opensymphony.xwork2.ActionSupport -->
            <action name="Demo2Action"   >
                <result  >/hello.jsp</result>
            </action>
        </package>)
</struts>
<!--  转发 -->
        <action name="Demo1Action" class="cn.example.a_result.Demo1Action" method="execute" >
            <result name="success" type="dispatcher" >/hello.jsp</result>
        </action>
    <!-- 重定向 -->
        <action name="Demo2Action" class="cn.example.a_result.Demo2Action" method="execute" >
            <result name="success" type="redirect" >/hello.jsp</result>
        </action>
    <!-- 转发到Action -->
        <action name="Demo3Action" class="cn.example.a_result.Demo3Action" method="execute" >
             <result name="success" type="chain">
                    <!-- action的名字 -->
                 <param name="actionName">Demo1Action</param>
                    <!-- action所在的命名空间 -->
                 <param name="namespace">/</param>
             </result>
        </action>
        <!-- 重定向到Action -->
        <action name="Demo4Action" class="cn.example.a_result.Demo4Action" method="execute" >
            <result  name="success"  type="redirectAction">
                 <!-- action的名字 -->
                 <param name="actionName">Demo1Action</param>
                 <!-- action所在的命名空间 -->
                 <param name="namespace">/</param>
            </result>
        </action>
        <action name="Demo3Action" class="cn.example.d_config.Demo3Action" method="execute" >
            <result name="success" type="redirectAction" >
                <param name="actionName">Demo1Action</param>
                <param name="namespace">/</param>
                <!-- 如果添加的参数struts"看不懂".就会作为参数附加重定向的路径之后.
                     如果参数是动态的.可以使用${}包裹ognl表达式.动态取值
                 -->
                <param name="name">${name}</param>
            </result>
        </action>

拦截器,生命周期:随项目的启动而创建,随项目关闭而销毁

implements Interceptor(了解);AbstractInterceptor(了解)
//继承:MethodFilterInterceptor 方法过滤拦截器
//功能: 定制拦截器拦截的方法.
//  定制哪些方法需要拦截.
//  定制哪些方法不需要拦截
public class MyInterceptor3 extends MethodFilterInterceptor{

    @Override
    protected String doIntercept(ActionInvocation invocation) throws Exception {
    if
        //前处理
        System.out.println("MyInterceptor3 的前处理!");
        //放行
        String result = invocation.invoke();
        //后处理
        System.out.println("MyInterceptor3 的后处理!");
    else
        return result;
    }

}

    <package name="inter" namespace="/" extends="struts-default" >
    <interceptors>
    <!-- 1.注册拦截器 -->
        <interceptor name="myInter3" class="cn.itcast.a_interceptor.MyInterceptor3"></interceptor>
    <!-- 2.注册拦截器栈 -->
        <interceptor-stack name="myStack">
            <!-- 自定义拦截器引入(建议放在20个拦截器之前) -->
            <interceptor-ref name="myInter3">
                <!-- 指定哪些方法不拦截
                 <param name="excludeMethods">add,delete</param> -->
                 <!-- 指定哪些方法需要拦截 -->
                 <param name="includeMethods">add,delete</param>
            </interceptor-ref>
            <!-- 引用默认的拦截器栈(20个) -->
            <interceptor-ref name="defaultStack"></interceptor-ref>
        </interceptor-stack>    
    </interceptors>
    <!-- 3.指定包中的默认拦截器栈 -->
        <default-interceptor-ref name="myStack"></default-interceptor-ref>
        <action name="Demo1Action_*" class="cn.itcast.a_interceptor.Demo1Action" method="{1}" >
            <!-- 为Action单独指定走哪个拦截器(栈) 
            <interceptor-ref name="myStack"></interceptor-ref>-->
            <result name="success" type="dispatcher" >/index.jsp</result>
        </action>
    </package>

web.xml

 <!-- struts2核心过滤器 -->
  <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>

ActionContext数据中心
含有:原生request,原生response,原生servletContext,request 域,session域,application域,param参数,attr域,valueStack值栈

//request域=> map (struts2并不推荐使用原生request域)
//不推荐
Map<String, Object> requestScope = (Map<String, Object>) ActionContext.getContext().get("request");
//推荐
ActionContext.getContext().put("name", "requestTom");
//session域 => map
Map<String, Object> sessionScope =ActionContext.getContext().getSession();
sessionScope.put("name", "sessionTom");
//application域=>map
Map<String, Object> applicationScope = ActionContext.getContext().getApplication();
applicationScope.put("name", "applicationTom");
//原生request
HttpServletRequest request = ServletActionContext.getRequest();
//原生session
HttpSession session = request.getSession();
//原生response
HttpServletResponse response = ServletActionContext.getResponse();
//原生servletContext
ServletContext servletContext=ServletActionContext.getServletContext();

//-接口方式 *Aware
//如何在action中获得原生ServletAPI
public class Demo7Action extends ActionSupport implements ServletRequestAware {

1属性驱动获得参数
action与jsp里名字对应<input type=”text” name=”name” />

public class Action extends ActionSupport {
//准备与参数键名称相同的属性
private String name;
//自动类型转换 只能转换8大基本数据类型以及对应包装类
private Integer age;
//支持特定类型字符串转换为Date ,例如 yyyy-MM-dd
private Date   birthday;

2对象驱动<input type=”text” ame=”user.name”/>

public class Action extends ActionSupport 
//准备user对象
    private User user;

3模型驱动

public class Action extends ActionSupport implements ModelDriven&lt;User> {
    //准备user 成员变量
    private User user =new User();
封装集合类型参数
public class Demo11Action extends ActionSupport  {
    //list
    private List<String> list;
    //Map
    private Map<String,String> map;
    jsp:
        list:<input type="text" name="list" /><br>
        list:<input type="text" name="list[3]" /><br>(索引跳跃,中间为NULL)
        map:<input type="text" name="map['haha']" /><br>

.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<%@ taglib prefix="s" uri="/struts-tags" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
</head>
<body>
    <form action="${pageContext.request.contextPath}/Demo2Action">
        用户名:<input type="text" name="name" /><br>
        <input type="submit" value="提交" />
    </form>
<!-- 调试标签 -->
<s:debug></s:debug>
(
    Root默认情况下,栈中放置当前访问的Action对象
    Context部分就是ActionContext数据中心
)
</body>
</html>

Struts标签

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
   <%@ taglib prefix="s" uri="/struts-tags" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
</head>
<body>
<!-- 遍历标签 iterator -->
<!-- ------------------------------------- -->
<s:iterator value="#list" >
    <s:property /><br>  输出:1\n 2\n 3\n 
</s:iterator>
<!-- ------------------------------------- --><hr>
<s:iterator value="#list" var="name" >   第二种遍历方式,名name然后取出
    <s:property value="#name" /><br>
</s:iterator>
<!-- ------------------------------------- --><hr>
<s:iterator begin="1" end="100" step="1"  >
    <s:property />|  输出:1-100 步进为1
</s:iterator>
<!-- ------------------if else elseif------------------- --><hr>

<s:if test="#list.size()==4">
    list长度为4!
</s:if>
<s:elseif test="#list.size()==3">
    list长度为3!
</s:elseif>
<s:else>
    list不3不4!
</s:else>

<!-- ------------------property 配合ognl表达式页面取值 ------------------- --><hr>

<s:property value="#list.size()" />
<s:property value="#session.user.name" />


<!-- struts2表单标签 ****一般不用****-->
    <!-- 好处1: 内置了一套样式.  -->
    <!-- 好处2: 自动回显,根据栈中的属性  -->
    <!-- theme:指定表单的主题
            xhtml:默认
            simple:没有主题
     -->
    <s:form action="Demo3Action" namespace="/" theme="xhtml" >
        <s:textfield name="name" label="用户名"  ></s:textfield>
        <s:password name="password" label="密码" ></s:password>
        <s:radio list="{'男','女'}" name="gender" label="性别" ></s:radio>
        <s:radio list="#{1:'男',0:'女'}" name="gender" label="性别" ></s:radio>
        <s:checkboxlist list="#{2:'抽烟',1:'喝酒',0:'烫头'}" name="habits" label="爱好" ></s:checkboxlist>
        <s:select list="#{2:'大专',1:'本科',0:'硕士'}" headerKey="" headerValue="---请选择---" name="edu" label="学历" >
        </s:select>
        <s:file name="photo" label="近照" ></s:file>
        <s:textarea name="desc" label="个人简介" ></s:textarea>
        <s:submit value="提交" ></s:submit>
    </s:form>

    <s:actionerror/>
</body>
</html>
html el
    request: ${requestScope.name}<br>
    session:${sessionScope.name}<br>
    application:${applicationScope.name}<br>
OGNL:对象视图导航语言.  ${user.addr.name} 这种写法就叫对象视图导航.
OGNL不仅仅可以视图导航.支持比EL表达式更加丰富的功能.
        //准备ONGLContext
        //准备Root
        User rootUser = new User("tom",18);
        //准备Context
        Map<String,User> context = new HashMap<String,User>();
        context.put("user1", new User("jack",18));
        context.put("user2", new User("rose",22));
        OgnlContext oc = new OgnlContext();
        //将rootUser作为root部分
        oc.setRoot(rootUser);
        //将context这个Map作为Context部分
        oc.setValues(context);
//取出root中的属性值
        //取出root中user对象的name属性
        String name = (String) Ognl.getValue("name", oc, oc.getRoot());
        //对root中的user对象的name属性赋值
        Ognl.getValue("name='jerry'", oc, oc.getRoot());
//取出context中的属性值
        //取出context中键为user1对象的name属性
        String name = (String) Ognl.getValue("#user1.name", oc, oc.getRoot());
        //对context中的user1对象的name属性赋值
        String name2 = (String) Ognl.getValue("#user1.name='勇',#user1.name", oc, oc.getRoot());
//调用root中user对象的setName,getName方法
        Ognl.getValue("setName('lilei')", oc, oc.getRoot());
        String name = (String) Ognl.getValue("getName()", oc, oc.getRoot());
//调用context中user对象的setName,getName方法
        String name2 = (String) Ognl.getValue("#user1.setName('lucy'),#user1.getName()", oc, oc.getRoot());
//调用静态方法@类全名@方法名
        String name = (String) Ognl.getValue("@cn.itheima.a_ognl.HahaUtils@echo('hello !')", oc, oc.getRoot());
        @变量名
        //Double pi = (Double) Ognl.getValue("@java.lang.Math@PI", oc, oc.getRoot());
        Double pi = (Double) Ognl.getValue("@@PI", oc, oc.getRoot());
//创建list对象
        Integer size = (Integer) Ognl.getValue("{'tom','jerry','jack','rose'}.size()", oc, oc.getRoot());
        String name = (String) Ognl.getValue("{'tom','jerry','jack','rose'}[0]", oc, oc.getRoot());
        String name2 = (String) Ognl.getValue("{'tom','jerry','jack','rose'}.get(1)", oc, oc.getRoot());

//创建Map对象
        Integer size2 = (Integer) Ognl.getValue("#{'name':'tom','age':18}.size()", oc, oc.getRoot());
        String name3  = (String) Ognl.getValue("#{'name':'tom','age':18}['name']", oc, oc.getRoot());
        Integer age  = (Integer) Ognl.getValue("#{'name':'tom','age':18}.get('age')", oc, oc.getRoot());
prepare,ModelDriven接口里
                //1获得值栈
                ValueStack vs = ActionContext.getContext().getValueStack();
                //2将u压入栈顶
                vs.push(u);

JAVA 四大域对象总结(ServletContext,HttpSession ,ServletRequest,PageContext):https://www.cnblogs.com/skjsg/p/4707032.html

Action生命周期
- 1.每次请求到来时,都会创建一个新的Action实例
- 2.Action是线程安全的.可以使用成员变量接收参数

struts2使用优势
- 自动封装参数
- 参数校验
- 结果的处理(转发|重定向)
- 国际化
- 显示等待页面
- 表单的防止重复提交
- struts2具有更加先进的架构以及思想

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值