action_actionbar - CSDN
  • Action标签的用法

    2018-07-27 23:32:07
    Action标签,顾名思义,是用来调用Action的标签,在JSP中页面中,可以具体指定某一命名空间中的某一Action。而标签的主体用于显示及渲染Actionr的处理结果。 action标签有如下几个属性: 1、id: 可选,作为该...

    Action标签,顾名思义,是用来调用Action的标签,在JSP中页面中,可以具体指定某一命名空间中的某一Action。而标签的主体用于显示及渲染Actionr的处理结果。

    action标签有如下几个属性:

    1、id:  可选,作为该action的引用ID

    2、name:  必填,调用action的名字

    3、namespace:  可选,action所在的nqmespace

    4、executeResult,可选,指定是否将action的处理结果页面包含到本页面。

    5、ignoreContextParame: 可选,指定该页面的请求参数是否需要传入action.

    1.actionTag.jsp

    <%@ page language="java" contentType="text/html; charset=UTF-8"
     pageEncoding="UTF-8"%>
    <%@ taglib prefix="s" uri="/struts-tags"%>
    <html>
     <head>
      <title>Insert title here</title>
     </head>
     <body> 
      <s:action name="actionTags">
       <h3>不包含结果页面</h3>
      </s:action>
       
      <s:action name="actionTags" executeResult="true" ignoreContextParams="true">
       <h3>包含结果页面</h3>
      </s:action>
      
      <s:action name="actionTags" executeResult="true" ignoreContextParams="false">
       <s:param name="name">"wangkecheng"</s:param>
       <h3>包含结果页面</h3>
      </s:action> 
     </body>
    </html>
    

    2.actionTagResult.jsp

    <%@ page language="java" contentType="text/html; charset=utf-8"%>
    <%@ taglib prefix="s" uri="/struts-tags"%>
    <html>
     <head>
     </head>
     <body>
      <h4>actionTag结果页面</h4>
      <s:property value="name"/>
     </body>
    </html>
    

    3.ActionTag.java

    public class ActionTags extends ActionSupport {
     private String name;
     public String getName() {
      return name;
     }
     public void setName(String name) {
      this.name = name;
     }
     public String execute() {
      return SUCCESS;
     }
    }
    

    4.struts.xml

    <action name="actionTags" class = "test1.ActionTags">
     <result name="success">/test1/actionTagResult.jsp</result>
    </action>

     

    展开全文
  • form表单的action属性

    2020-02-25 20:44:18
    在我们做开发的时候,看到前端页面,js的函数里面并没有写跳转路径,但是表单数据还是提交了,这是因为form表单的action属性在起作用。 在form表单中,有一个action属性,这个属性后面的值是表单提交时候要访问的...

    在我们做开发的时候,看到前端页面,js的函数里面并没有写跳转路径,但是表单数据还是提交了,这是因为form表单的action属性在起作用。

    在form表单中,有一个action属性,这个属性后面的值是表单提交时候要访问的路径,一般情况下这个东西是要有的,但是假如没有写这个action属性,那么会有默认的属性设置,即 当前路径。

     

     

    然后再给大家说个事情,最近博主在做一个软件推广,注册软件之后:可以在网购之前去搜索各种优惠券(淘宝、京东、拼多多等多平台),领取优惠券之后就可以低于原价买东西了!刚刚开始做推广,没经验,欢迎大佬赐教!

    扫描下侧二维码,用力搞。(软件是正经软件,博主也是正经人,哈哈)

    千万不要因为我是一朵娇花而怜惜我!

     

    展开全文
  • 动作Action详解

    2017-09-05 10:59:22
    Action是一个自描述的对象,一个Action对象知道如何修改一个Node的元素,包括对哪些属性作出修改,以及怎样对这些修改执行插值计算。定义好一个Action对象之后,它可以作用于任何Node元素。但是,Acti

    声明:本文内容是《我所理解的COCOS2D-X》以及《Cocos2d-x实战》的部分摘录与整合

    一个Action就是一个对象,它定义了一个修改,并把这个修改作用在一个Node元素上。Action是一个自描述的对象,一个Action对象知道如何修改一个Node的元素,包括对哪些属性作出修改,以及怎样对这些修改执行插值计算。定义好一个Action对象之后,它可以作用于任何Node元素。但是,Action只能作用于单个Node元素之上。

    动作action包括基本动作和基本动作的组合,基本动作包括有移动、缩放、跳跃、旋转等,而这些动作变化的速度也可以自己设定。Action有3个子类,FiniteTimeAction(受时间限制的动作)、Follow(一种允许精灵跟随另一个精灵的动作)、Speed(一个动作运行时改变其运动速率),其中FiniteTimeAction包括ActionInstant(封装了一种瞬时动作)和ActionInterval(封装了一种间隔动作)。 

    即时动画是指从动画开始执行到完成一帧之内的动画,例如RemoveSelf是一个即时动画,因为这个操作不能被拆分在多个时间段内执行。其他即时动画还包括Show、Hide、CallFunc、Place、FlipY、ToggleVisiblity等。这里需要注意的是,即时动画并不是在动画开始的时候执行的,实际上它也不是在当前帧完成的,而是在开始动画的下一帧完成的。因为这一操作是在Action::update中完成的。每个动画的每一次update的执行发生在游戏循环开始的时候。所以开始执行动画肯定晚于动画执行阶段,所以即时动画只能在下一帧去执行完成操作。

    间隔动画是该动画对属性的修改操作发生在一定的时间内,这个修改持续发生在该时间的每一帧,直到动画执行完成。大部分修改能够进行插值的动画都是间隔动画m例如MoveTo、RotateBy、SkewTo、BezierTo等。

    一个Action只能通过一个Node元素来执行,可以通过调用Node的runAction方法来执行。当一个动画执行完成后,动画系统会将它移除,默认情况下该Action实例会立即被销毁。

    runAction并不提供动画完成时的回调,如果需要在动画完成时得到通知,则需要使用CallFunc即时动画来提供一个回调函数。

    动作测试代码:

    #include "HelloWorldScene.h"
    #include "SimpleAudioEngine.h"
    
    USING_NS_CC;
    
    Scene* HelloWorld::createScene()
    {
        auto scene = Scene::create();
      
        auto layer = HelloWorld::create();
    
        scene->addChild(layer);
    
        return scene;
    }
    
    bool HelloWorld::init()
    {
       
        if ( !Layer::init() )
        {
            return false;
        }
        
        auto visibleSize = Director::getInstance()->getVisibleSize();
        //添加背景图片
        auto sp = Sprite::create("game_background_1.png");
        sp->setPosition(visibleSize/2.0f);
        this->addChild(sp);
        
        
        //创建三个人物精灵
        _grossini = Sprite::create("ge_boss_1.png");
        _tamara = Sprite::create("ge_boss_2.png");
        _kathia = Sprite::create("ge_boss_3.png");
    
        addChild(_grossini, 1);
        addChild(_tamara, 2);
        addChild(_kathia, 3);
        
        _grossini->setPosition(visibleSize.width/2.0f, visibleSize.height/3);
        _tamara->setPosition(visibleSize.width/2.0f, visibleSize.height*2/3);
        _kathia->setPosition(visibleSize.width/2.0f, visibleSize.height - 50);
       
        //移动动作
        //this->ActionMove();
        
        //3D移动
        //this->ActionMove3D();
        
        //缩放
        //this->ActionScale();
        
        //倾斜
        //this->ActionSkew();
        
        //旋转
        //this->ActionRotate();
        
        //3D旋转
        //this->ActionRotateBy3D();
        
        //跳跃
        //this->ActionJump();
        
        //闪烁
        //this->ActionBlink();
        
        //反动作
        //this->ActionReverse();
        
        //贝塞尔曲线
        //this->ActionBezier();
        
        //渐变
        //this->ActionFade();
        
        //改变颜色
        //this->ActionTint();
        
        //移除动作
        //this->ActionRemoveSelf();
        
        //放大动作
        //this->ActionFloatTest();
        
        //克隆
        //this->ActionClone();
        
        //序列动作
        //this->ActionSequence();
        
        //同时动作
        //this->ActionSpawn();
        
        //永久动作
        //this->ActionRepeatForever();
        
        //延时动作
        //this->ActionDelayTime();
        
        //摄像机动作
        //this->ActionOrbit();
        
        
        //跟随动作
        this->ActionFollow();
        
        //改变动作执行对象
        //this->ActionTargeted();
        
        //进度条动作
        //this->SpriteProgress();
        
        //基本缓冲动作
        //this->SpriteEase();
        
        //指数缓冲动作
        //this->SpriteEaseExponential();
        
        //塞因缓冲
        //this->SpriteEaseSine();
        
        //弹性缓冲
        //this->SpriteEaseElastic();
        
        //跳跃缓冲
        //this->SpriteEaseBounce();
        
        //回振缓冲
        //this->SpriteEaseBack();
        
        //不带参数的回调动作
        //this->ActionCallFunc();
        
        //带一个参数的回调动作
        //this->ActionCallFuncN();
        
        //显示隐藏动作
        //this->ActionShowAndHide();
        
        //可见切换动作
        //this->ActionToggleVisibility();
        
        
        //翻转动作(镜像对程)
        //this->ActionFlip();
        
        //放置动作
        //this->ActionPlace();
        
        //设置速度动作
        //this->ActionSpeed();
        
        //贴图的使用
        //this->AnimateTextureCache();
        
        //使用精灵帧缓存
        //this->AnimateSpriteFrameCache();
        
        //动画
        //this->addAnimate();
        
        //特效使用
        //this->EffectBaseTest();
        
        //3D震动
        //this->Shaky3DDemo();
        
        //3D波动
        //this->Waves3DDemo();
        
        //3D翻转
        //this->FlipX3DDemo();
        
        //凸透镜效果
        //this->LensDemo();
        
        //水波纹特效
        //this->Ripple3DDemo();
        
        //液体特效
        //this->LiquidDemo();
        
        //扭曲旋转特效
        //this->TwirlDemo();
        
        //破碎的3D瓷砖特效
        //this->ShatteredTiles3DDemo();
        
        //瓷砖洗牌特效
        //this->ShuffleTilesDemo();
        
        //部落格效果,从左下角到右上角
        //this->FadeOutTRTilesDemo();
        
        //部落格效果,从右上角到左下角
        //this->FadeOutBLTilesDemo();
        
        //折叠效果 从下到上
        //this->FadeOutUpTilesDemo();
        
        //折叠效果,从上到下
        //this->FadeOutDownTilesDemo();
        
        //跳动的方块特效
        //this->JumpTiles3DDemo();
        
        //分多行消失特效
        //this->plitColsDemo();
        
        //分多列消失特效
        //this->SplitRowsDemo();
        
        //3D翻页特效
        //this->PageTurn3DDemo();
        
        //暂停动作
        //this->PauseTest();
    
        
        return true;
    }
    
    //移动
    void HelloWorld::ActionMove()
    {
        //移动到(时间,位置)
        auto actionTo = MoveTo::create(2, Vec2(150, 100));
        //移动了(时间,相对移动的位置)
        auto actionBy = MoveBy::create(2, Vec2(80,80));
        
        //反动作(向相反的方向移动)
        auto actionByBack = actionBy->reverse();
        
        _tamara->runAction(actionTo);
        
        _grossini->runAction(actionBy);
        
        _kathia->runAction(actionByBack);
    }
    
    //3D移动
    void HelloWorld::ActionMove3D()
    {
        //获取屏幕的大小
        auto s = Director::getInstance()->getWinSize();
        //设置3d位置,参数分别是(x, y, z)
        _tamara->setPosition3D(Vec3(s.width-140, s.height-100, 0));
        _kathia->setPosition3D(Vec3(240, 240, 0));
        //创建3d移动动作,参数分别是(时间,移动到的位置)
        auto actionTo = MoveTo::create(2, Vec3(s.width/2.0f, s.height/2.0f, -100));
        //创建3d移动动作,参数分别是(时间,相对移动的位置)
        auto actionBy = MoveBy::create(2, Vec3(80, 80, -100));
        //反动作
        auto actionByBack = actionBy->reverse();
        _tamara->runAction(actionTo);
        _grossini->runAction(actionBy);
        _kathia->runAction(actionByBack);
    
    }
    
    //缩放
    void HelloWorld::ActionScale()
    {
        //缩放到,参数分别是(执行动作所消耗的时间, 缩放比例)
        auto actionTo = ScaleTo::create(2.0f, 0.5f);
        //缩放了,参数分别是(执行动作所消耗的时间,x方向缩放比例,y轴缩放比例)
        auto actionBy = ScaleBy::create(2.0f, 1.0f, 10.0f);
        auto actionBy2 = ScaleBy::create(2.0f, 5.0f, 1.0f);
        
        _grossini->runAction(actionTo);
        _tamara->runAction(actionBy);
        _kathia->runAction(actionBy2);
    }
    
    //倾斜
    void HelloWorld::ActionSkew()
    {
        //倾斜到,参数分别是:(执行动作需要的时间,x轴倾斜到的角度,y轴倾斜到的角度)
        auto actionTo = SkewTo::create(2, 37.2f, -37.2f);
        //倾斜了,参数分别是:(执行动作需要的时间,x轴倾斜le的角度,y轴倾斜le的角度)
        auto actionBy = SkewBy::create(2, 0.0f, -90.0f);
        auto actionBy2 = SkewBy::create(2, 45.0f, 45.0f);
        _tamara->runAction(actionTo);
        _grossini->runAction(actionBy);
        _kathia->runAction(actionBy2);
    }
    
    //旋转
    void HelloWorld::ActionRotate()
    {
        //旋转到,参数分辨是(执行动作所要的时间,x旋转到角度,y旋转到角度)
        auto actionTo = RotateTo::create(2, 180, 180);
        //旋转了,参数分辨是(执行动作所要的时间,x旋转了角度,y旋转了角度)
        auto actionBy = RotateBy::create(2, 0.0f, 360);
        auto actionBy2 = RotateBy::create(2, 360, 0);
        _tamara->runAction(actionTo);
        _grossini->runAction(actionBy);
        _kathia->runAction(actionBy2);
    }
    //3D旋转
    void HelloWorld::ActionRotateBy3D()
    {
        //旋转了,参数分别是(执行动作消耗的时间,旋转了角度(x, y, z))
        auto actionBy1 = RotateBy::create(4, Vec3(360, 0, 0));
        auto actionBy2 = RotateBy::create(4, Vec3(0, 360, 0));
        auto actionBy3 = RotateBy::create(4 ,Vec3(0, 0, 360));
        _tamara->runAction(actionBy1);
        _grossini->runAction(actionBy2);
        _kathia->runAction(actionBy3);
    
    }
    //跳跃
    void HelloWorld::ActionJump()
    {
        //跳跃到(执行动作需要的时间,跳跃到的位置,每次跳跃的高度,跳跃的次数)
        auto actionTo = JumpTo::create(2, Vec2(300,300), 50, 4);
        //跳跃了(执行动作需要的时间,跳跃了的位置,每次跳跃的高度,跳跃的次数)
        auto actionBy = JumpBy::create(2, Vec2(300,0), 50, 4);
        auto actionUp = JumpBy::create(2, Vec2(0,0), 80, 4);
        _tamara->runAction( actionTo);
        _grossini->runAction(actionBy);
        _kathia->runAction(actionUp);
    }
    //闪烁
    void HelloWorld::ActionBlink()
    {
        //闪烁,参数分别是(执行动作所需要的时间,闪烁的次数)
        auto bl = Blink::create(2.0, 10);
        _kathia->runAction(bl);
    }
    
    //反动作
    void HelloWorld::ActionReverse()
    {
        auto jump = JumpBy::create(2, Vec2(300,0), 50, 4);
        auto rev = jump->reverse();
        
        _grossini->runAction(rev);
    
    }
    
    //贝塞尔曲线
    void HelloWorld::ActionBezier()
    {
        auto s = Director::getInstance()->getWinSize();//获取屏幕的大小
        ccBezierConfig bezier;                         //声明一个配置对象
        bezier.controlPoint_1 = Vec2(0, s.height/2 - 100);//控制点1
        bezier.controlPoint_2 = Vec2(300, -s.height/2 + 100);//控制点2
        bezier.endPosition = Vec2(300,100);//最终位置
        auto bezierForward = BezierBy::create(3, bezier);//创建贝塞尔动作
        ccBezierConfig bezier2;
        bezier2.controlPoint_1 = Vec2(100, s.height/2 - 100);
        bezier2.controlPoint_2 = Vec2(200, -s.height/2 + 150);
        bezier2.endPosition = Vec2(240,160);
        auto bezierTo1 = BezierTo::create(2, bezier2);
        _grossini->runAction(bezierForward);
        _tamara->runAction(bezierTo1);
    }
    
    //渐变FadeOut和FadeIn
    void HelloWorld::ActionFade()
    {
        //设置精灵的透明度
        _tamara->setOpacity(0);
        //渐变显示,参数(执行动作需要的时间)
        auto action1 = FadeIn::create(1.0f);
        //渐变消失,参数(执行动作需要的时间)
        auto action2 = FadeOut::create(1.0f);
    
        _tamara->runAction(action1);
        _kathia->setOpacity(122);
        _kathia->runAction(action2);
    }
    
    //改变颜色
    void HelloWorld::ActionTint()
    {
        auto action1 = TintTo::create(2, 255, 0, 255);
        auto action2 = TintBy::create(2, -127, -255, -127);
        
        _tamara->runAction( action1);
        _kathia->runAction( action2);
    }
    
    //移除动作
    void HelloWorld::ActionRemoveSelf()
    {
        auto action = Sequence::create(
                                       MoveBy::create( 2, Vec2(240,0)),
                                       RotateBy::create( 2,  540),
                                       ScaleTo::create(1,0.1f),
                                       RemoveSelf::create(),
                                       nullptr);
        
        _grossini->runAction(action);
    }
    
    void HelloWorld::ActionFloatTest()
    {
        //将任何值在一定时间间隔内从指定的起始值改变为指定的最终值
        auto s = Director::getInstance()->getWinSize();
        //参数依次为(执行动作所需的时间,起始值,最终值,报告结果的回调函数)
        auto actionFloat = ActionFloat::create(2.f, 0, 3, [this](float value) {
            _tamara->setScale(value);
        });
        
        _tamara->runAction(actionFloat);
    }
    
    //序列动作
    void HelloWorld::ActionSequence()
    {
        auto action = Sequence::create(
                                       MoveBy::create( 2, Vec2(240,0)),
                                       RotateBy::create( 2,  540),
                                       nullptr);
        
        _grossini->runAction(action);
    }
    
    //同时动作
    void HelloWorld::ActionSpawn()
    {
        auto action = Spawn::create(
                                    JumpBy::create(2, Vec2(300,0), 50, 4),
                                    RotateBy::create( 2,  720),
                                    nullptr);
        
        _grossini->runAction(action);
    }
    
    //永久动作
    void HelloWorld::ActionRepeatForever()
    {
        auto repeat = RepeatForever::create( RotateBy::create(1.0f, 360) );
        
        _grossini->runAction(repeat);
    }
    
    //延时动作DelayTime
    void HelloWorld::ActionDelayTime()
    {
        auto move = MoveBy::create(1, Vec2(150,0));
        auto action = Sequence::create( move, DelayTime::create(2), move, nullptr);
        
        _grossini->runAction(action);
    }
    
    //摄像机动作
    void HelloWorld::ActionOrbit()
    {
        //设置工程为2d视角
        Director::getInstance()->setProjection(Director::Projection::_2D);
        //参数(执行动作花费的时间,起始半径、半径差、起始z角、旋转z角的差、起始x角、旋转x角的差)
        auto orbit1 = OrbitCamera::create(2,1, 0, 0, 180, 0, 0);
        auto action1 = Sequence::create(
                                        orbit1,
                                        orbit1->reverse(),
                                        nullptr);
        _kathia->runAction(RepeatForever::create(action1));
        
    }
    
    //克隆动作
    void HelloWorld::ActionClone()
    {
        auto move = MoveBy::create(1, Vec2(150,0));
        auto clone = move->clone();
        
        _grossini->runAction(move);
        _kathia->runAction(clone);
    }
    
    //跟随
    void HelloWorld::ActionFollow()
    {
        auto s = Director::getInstance()->getWinSize();
        
        DrawNode* drawNode = DrawNode::create();
        float x = s.width*2 - 100;
        float y = s.height;
        
        Vec2 vertices[] = { Vec2(5,5), Vec2(x-5,5), Vec2(x-5,y-5), Vec2(5,y-5) };
        drawNode->drawPoly(vertices, 4, true,  Color4F(CCRANDOM_0_1(), CCRANDOM_0_1(), CCRANDOM_0_1(), 1));
        
        this->addChild(drawNode);
        
        _grossini->setPosition(-200, s.height / 2);
        auto move = MoveBy::create(2, Vec2(s.width * 3, 0));
        auto move_back = move->reverse();
        auto seq = Sequence::create(move, move_back, nullptr);
        auto rep = RepeatForever::create(seq);
        
        _grossini->runAction(rep);
        
        //在创建Follow动作时,需要传入要跟踪的Node对象和跟踪的范围,范围是一个Rect类型的对象,当Node移动出这个范围后,会停止对其进行跟踪,并且当其再次回到范围中时,跟踪会再次启动。如果范围设置为Rect::ZERO,那么不管该对象移动到哪儿,Follow都会一直对其跟踪。
        this->runAction(Follow::create(_grossini, Rect(0, 0, s.width * 2 - 100, s.height)));
    }
    
    //改变动作执行目标
    void HelloWorld::ActionTargeted()
    {
        auto jump1 = JumpBy::create(2,Vec2::ZERO,100,3);
        auto jump2 = jump1->clone();
        auto rot1 = RotateBy::create(1, 360);
        auto rot2 = rot1->clone();
        
        //传入的参数分别是(目标,动作)
        auto t1 = TargetedAction::create(_kathia, jump2);
        auto t2 = TargetedAction::create(_kathia, rot2);
        
        auto seq = Sequence::create(jump1, t1, rot1, t2, nullptr);
        auto always = RepeatForever::create(seq);
        
        _tamara->runAction(always);
    }
    
    //进度条动作
    void HelloWorld::SpriteProgress()
    {
        //获取屏幕大小
        auto s = Director::getInstance()->getWinSize();
        //创建进度条动作,参数分别为(执行动作消耗的时间,百分比)
        auto to1 = ProgressTo::create(2, 100);
        //创建进度条
        auto left = ProgressTimer::create(Sprite::create("grossinis_sister1.png"));
        //设置进度条类型
        left->setType( ProgressTimer::Type::RADIAL );
        addChild(left);
        left->setPosition(100, s.height/2);
        left->runAction(to1);
        //是否执行反动作
        left->setReverseProgress(true);
    }
    
    //基本缓冲动作
    void HelloWorld::SpriteEase()
    {
        auto move = MoveBy::create(3, Vec2(130,0));
        //动作由慢变快,参数分别(动作,速率:即加速度)
        auto move_ease_in = EaseIn::create(move->clone(), 2.5f);
        //动作由快变慢,参数分别(动作,速率:即加速度)
        auto move_ease_out = EaseOut::create(move->clone(), 2.5f);
        //动作由慢变快再变慢,参数分别(动作,速率:即加速度)
        auto move_ease_in_out = EaseInOut::create(move->clone(), 2.5f);
        
        _grossini->runAction(move);
        _tamara->runAction(move_ease_in);
        _kathia->runAction(move_ease_out);
    }
    
     //指数缓冲动作
    void HelloWorld::SpriteEaseExponential(){
        
        auto move = MoveBy::create(3, Vec2(130,0));
        //动作由慢变极快
        auto move_ease_in = EaseExponentialIn::create(move->clone());
        //动作由极快变慢
        auto move_ease_out = EaseExponentialOut::create(move->clone());
        //动作由慢至极快再由极快边慢
        auto move_ease_in_out = EaseExponentialInOut::create(move->clone());
        
        _grossini->runAction(move);
        _tamara->runAction(move_ease_in);
        _kathia->runAction(move_ease_out);
    
    }
    
    //塞因缓冲动作
    void HelloWorld::SpriteEaseSine()
    {
        auto move = MoveBy::create(3, Vec2(130, 0));
        //动作由快变慢
        auto move_ease_in = EaseSineIn::create(move->clone());
        //动作由慢变快
        auto move_ease_out = EaseSineOut::create(move->clone());
        //精灵由慢至快再由快至慢
        auto move_ease_in_out = EaseSineInOut::create(move->clone());
        
        _grossini->runAction(move);
        _tamara->runAction(move_ease_in);
        _kathia->runAction(move_ease_out);
    
    }
    
    //弹性缓冲动作
    void HelloWorld::SpriteEaseElastic()
    {
        auto move = MoveBy::create(3, Vec2(130, 0));
        //让目标动作赋予弹性 ,且以目标动作起点位子赋予弹性
        auto move_ease_in = EaseElasticIn::create(move->clone());
        //让目标动作赋予弹性 ,且以目标动作终点位子赋予弹性
        auto move_ease_out = EaseElasticOut::create(move->clone());
        //让目标动作赋予弹性 ,且以目标动作起点和终点位子赋予弹性
        auto move_ease_in_out = EaseElasticInOut::create(move->clone());
        _grossini->runAction(move);
        _tamara->runAction(move_ease_in);
        _kathia->runAction(move_ease_out);
    
    }
    
    //跳跃缓冲动作
    void HelloWorld::SpriteEaseBounce()
    {
        auto move = MoveBy::create(3, Vec2(130, 0));
        //让目标动作缓慢开始
        auto move_ease_in = EaseBounceIn::create(move->clone());
        //让目标动作赋予反弹力,且以目标动作结束位子开始反弹
        auto move_ease_out = EaseBounceOut::create(move->clone());
        //让目标动作赋予反弹力,且以目标动作起始与结束位子开始反弹
        auto move_ease_in_out = EaseBounceInOut::create(move->clone());
       
        _grossini->runAction(move);
        _tamara->runAction(move_ease_in);
        _kathia->runAction(move_ease_out);
    
    }
    
    //回振缓冲动作
    void HelloWorld::SpriteEaseBack()
    {
        auto move = MoveBy::create(3, Vec2(130, 0));
        //让目标动作赋予回力 , 且以目标动作起点位置作为回力点
        auto move_ease_in = EaseBackIn::create(move->clone());
        //让目标动作赋予回力 , 且以目标动作终点位置作为回力点
        auto move_ease_out = EaseBackOut::create(move->clone());
        //让目标动作赋予回力 , 且以目标动作起点和终点位置作为回力点
        auto move_ease_in_out = EaseBackInOut::create(move->clone());
      
        _grossini->runAction(move);
        _tamara->runAction(move_ease_in);
        _kathia->runAction(move_ease_out);
    }
    
    void HelloWorld::ActionCallFunc()
    {
        //lambda表达式和std::bind函数,自行扩展
    //    auto action1 = Sequence::create(
    //                                    MoveBy::create(2, Vec2(200,0)),
    //                                    CallFunc::create( std::bind(&HelloWorld::callFuncCallBack, this) ),
    //                                    CallFunc::create(
    //                                                     // lambda
    //                                                     [&](){
    //                                                         auto s = Director::getInstance()->getWinSize();
    //                                                         auto label = Label::createWithTTF("called:lambda callback", "fonts/Marker Felt.ttf", 16.0f);
    //                                                         label->setPosition(s.width/4*1,s.height/2-40);
    //                                                         this->addChild(label);
    //                                                     }  ),
    //                                    nullptr);
    //    
    //    auto action2 = Sequence::create(
    //                                    ScaleBy::create(2 ,  2),
    //                                    FadeOut::create(2),
    //                                    CallFunc::create( std::bind(&HelloWorld::callFuncNCallBack, this, _tamara)),
    //                                    nullptr);
    //    
    //    auto action3 = Sequence::create(
    //                                    RotateBy::create(3 , 360),
    //                                    FadeOut::create(2),
    //                                    CallFunc::create(std::bind(&HelloWorld::callFuncNDCallBack, this, _kathia, 42)),
    //                                    nullptr);
    //    
    //    _grossini->runAction(action1);
    //    _tamara->runAction(action2);
    //    _kathia->runAction(action3);
        
        auto call = CallFunc::create(CC_CALLBACK_0(HelloWorld::callFuncCallBack, this));
        auto rb = RotateBy::create(1.0f, 90);
        auto seq = Sequence::create(rb, call, NULL);
        
        _kathia->runAction(seq);
    }
    
    void HelloWorld::ActionCallFuncN()
    {
        auto callN = CallFuncN::create(CC_CALLBACK_1(HelloWorld::callFuncNCallBack, this));
        auto rb = RotateBy::create(1.0f, 90);
        auto seq = Sequence::create(rb, callN, NULL);
        
        _tamara->runAction(seq);
    }
    
    void HelloWorld::callFuncCallBack()
    {
        auto s = Director::getInstance()->getWinSize();
        auto label = Label::createWithTTF("callback 1 called", "fonts/Marker Felt.ttf", 16.0f);
        label->setPosition(s.width/4*1,s.height/2);
        label->setColor(Color3B(255, 0, 0));
        
        addChild(label);
    }
    
    
    void HelloWorld::callFuncNCallBack(Node* sender)
    {
        auto s = Director::getInstance()->getWinSize();
        auto label = Label::createWithTTF("callback 2 called", "fonts/Marker Felt.ttf", 16.0f);
        label->setPosition(s.width/4*2,s.height/2);
        label->setColor(Color3B(255, 0, 0));
        
        addChild(label);
        
        CCLOG("sender is: %p", sender);
    }
    
    void HelloWorld::callFuncNDCallBack(Node* sender, long data)
    {
        auto s = Director::getInstance()->getWinSize();
        auto label = Label::createWithTTF("callback 3 called", "fonts/Marker Felt.ttf", 16.0f);
        label->setPosition(s.width/4*3,s.height/2);
        addChild(label);
        label->setColor(Color3B(255, 0, 0));
        
        CCLOG("target is: %p, data is: %ld", sender, data);
    }
    
    
    //显示隐藏动作
    void HelloWorld::ActionShowAndHide()
    {
        auto action = Sequence::create(
                                       Show::create(),
                                       MoveBy::create(1, Vec2(100,0)),
                                       Hide::create(),
                                       DelayTime::create(2),
                                       Show::create(),
                                       nullptr);
        
        _grossini->runAction(action);
    }
    
    //可见切换动作
    void HelloWorld::ActionToggleVisibility()
    {
        auto move1 = MoveBy::create(1, Vec2(250,0));
        auto move2 = MoveBy::create(1, Vec2(0,50));
        auto tog1 = ToggleVisibility::create();
        auto tog2 = ToggleVisibility::create();
        auto seq = Sequence::create( move1, tog1, move2, tog2, move1->reverse(), nullptr);
        auto action = Repeat::create(Sequence::create( seq, seq->reverse(), nullptr), 3);
        _tamara->runAction(action);
    }
    
    //翻转动作(镜像对程)
    void HelloWorld::ActionFlip()
    {
        //2d镜像对称,参数(是否翻转)
        auto flipX = FlipX::create(true);
        auto flipY = FlipY::create(true);
        
        _grossini->runAction(flipX);
        _tamara->runAction(flipY);
    }
    
    //放置动作
    void HelloWorld::ActionPlace()
    {
        //参数(放置为位置)
        auto place = Place::create(Vec2(200, 200));
        _grossini->runAction(place);
    }
    
    //设置速度
    void HelloWorld::ActionSpeed()
    {
        auto moveBy = MoveBy::create(2.0f, Vec2(100, 100));
        //参数分别为(动作,速度)
        auto sp = Speed::create(moveBy, 0.1);
        _grossini->runAction(sp);
    }
    
    
    //纹理和纹理缓存
    void HelloWorld::AnimateTextureCache()
    {
        //TextureCache利用addImage来加载图片到缓存中
        TextureCache* tc = Director::getInstance()->getTextureCache();
        //获取一张贴图
        Texture2D* tx = tc->addImage("HelloWorld.png");
        auto sp = Sprite::createWithTexture(tx);
        sp->setPosition(Vec2(100, 100));
        addChild(sp);
    }
    
    //精灵帧和精灵帧缓存
    void HelloWorld::AnimateSpriteFrameCache()
    {
        //使用SpriteFrameCache加载整张大图
        auto spc = SpriteFrameCache::getInstance();
        spc->addSpriteFramesWithFile("animate.plist", "animate.png");
        auto spf = spc->getSpriteFrameByName("blue_0.png");
        auto sp = Sprite::createWithSpriteFrame(spf);
        sp->setPosition(Vec2(200, 200));
        this->addChild(sp);
    }
    
    //动画
    void HelloWorld::addAnimate()
    {
        //获取精灵缓存帧
        auto cache = SpriteFrameCache::getInstance();
        //添加plist和png到精灵缓存帧中
        cache->addSpriteFramesWithFile("animate.plist", "animate.png");
        //用一个文件初始化一个字典
        auto dic = __Dictionary::createWithContentsOfFile("animate.plist");
        //通过键获取相应的值
        auto frameDic = (__Dictionary*)dic->objectForKey("frames");
        //获取字典下键的所有数量
        ssize_t num = frameDic->allKeys()->count();
        //声明一个容器
        Vector<SpriteFrame*> allFrames;
        for (int i = 0; i < num; i++) {
            char frame[32];
            sprintf(frame, "blue_%d.png", i);
            //通过名称获取spriteFrame
            auto frameName = SpriteFrameCache::getInstance()->spriteFrameByName(frame);
            //把spriteFrame添加容器内
            allFrames.pushBack(frameName);
        }
        //不为空为false, 为空是true
        bool test = allFrames.empty();
        //用存储spriteFrame的容器,创建一个动画
        auto animation = Animation::createWithSpriteFrames(allFrames, 0.1);
        //创建一个动画动作
        auto animate = Animate::create(animation);
        auto forever = RepeatForever::create(animate);
        //是读取plist文件的资源,不是本地资源
        auto sp = Sprite::createWithSpriteFrameName("blue_0.png");
        sp->setPosition(Vec2(300, 300));
        this->addChild(sp);
        sp->setScale(2);
        sp->runAction(forever);
    }
    
    //测试
    void HelloWorld::EffectBaseTest()
    {
        this->removeAllChildren();
        
        LayerColor *background = LayerColor::create( Color4B(32,128,32,255) );
        this->addChild(background,-20);
        
        Size visibleSize = Director::getInstance()->getVisibleSize();
        Rect gridRect = Rect(visibleSize.width * 0.2,
                                 visibleSize.height * 0.2,
                                 visibleSize.width * 0.6,
                                 visibleSize.height * 0.6);
        _gridNodeTarget = NodeGrid::create(gridRect);
        addChild(_gridNodeTarget, 0);
        
       
        _gridNodeTarget->addChild(_tamara, 1);
    
        _gridNodeTarget->addChild(_kathia, 1);
    }
    
    //3D震动
    void HelloWorld::Shaky3DDemo()
    {
        //3D瓷砖晃动特效
        //参数分别为(特效持续的时间,网格大小,晃动的范围,是否有z轴晃动)
        auto shakyTiles3D = ShakyTiles3D::create(5, Size(10, 10), 5, false);
        //参数分别为(执行动作消耗的时间,网格大小,震动的幅度,是否Z轴震动)
        auto shaky = Shaky3D::create(2.0f, Size(15,10), 5, true);
        _gridNodeTarget->runAction(shaky);
    }
    
    //3D波动
    void HelloWorld::Waves3DDemo()
    {
        //参数(特效持续时间, 网格大小, 振幅, 波动的速率,水平波动, 垂直波动)
       auto w = Waves::create(5, Size(10, 10), 10, 20, true, true);
        //参数分别是(执行动作消耗的时间,网格大小,振幅,波动速率)
       auto waves = Waves3D::create(5.0f, Size(15,10), 5, 40);
        _gridNodeTarget->runAction(waves);
    }
    
    //3D翻转
    void HelloWorld::FlipX3DDemo()
    {
        //X轴 3D反转特效,参数(执行动作所需要的时间)
        auto filpX = FlipX3D::create(5);
        _gridNodeTarget->runAction(filpX);
        //Y轴3D反转特效,参数:特效持续的时间
        auto filpY = FlipY3D::create(5);
        _gridNodeTarget->runAction(filpY);
    }
    
    //凸透镜
    void HelloWorld::LensDemo()
    {
        //凸透镜特效,参数分别为(网格持续时间,网格大小,凸镜中心点,凸镜半径 )
        auto lens = Lens3D::create(2, Size(10, 10),Vec2(240, 160), 40);
        _gridNodeTarget->runAction(lens);
    }
    
    //水波纹特效
    void HelloWorld::Ripple3DDemo()
    {
      //参数分别为(特效持续的时间,网格大小,起始位置,半径,速率,振幅 )
        auto ripple = Ripple3D::create(5, Size(10, 10), Vec2(240, 160), 240, 4, 160);
        _gridNodeTarget->runAction(ripple);
    }
    
    //液体特效
    void HelloWorld::LiquidDemo()
    {
        //参数为(特效持续时间,网格大小,速率, 振幅)
        auto liquid = Liquid::create(5, Size(10, 10), 4, 20);
        _gridNodeTarget->runAction(liquid);
    }
    
    //扭曲旋转特效
    void HelloWorld::TwirlDemo()
    {
        //参数分别为(特效持续时间, 网格大小, 扭曲旋转中心点, 扭曲旋转的次数, 振幅)
        auto twirl = Twirl::create(50, Size(10, 10), Vec2(240, 160), 2, 2.5);
        _gridNodeTarget->runAction(twirl);
    }
    
    //破碎的3D瓷砖特效
    void HelloWorld::ShatteredTiles3DDemo()
    {
        //参数分别是(特效持续的时间,网格大小,范围, 是否开启z轴)
        auto shatteredTiles = ShatteredTiles3D::create(15, Size(10, 10), 50, true);
        _gridNodeTarget->runAction(shatteredTiles);
    }
    
    //瓷砖洗牌特效
    void HelloWorld::ShuffleTilesDemo()
    {
        //参数分别是(特效持续的时间, 网格大小, 随机数)
        auto shuffle = ShuffleTiles::create(5, Size(50, 50), 50);
        _gridNodeTarget->runAction(shuffle);
    }
    
    //部落格效果,从左下角到右上角
    void HelloWorld::FadeOutTRTilesDemo()
    {
        //部落格效果,从左下角到右上角
        //参数分别为(特效持续的时间, 网格大小)
        auto fadeOutTRTiles = FadeOutTRTiles::create(5, Size(50, 50));
        _gridNodeTarget->runAction(fadeOutTRTiles);
    }
    
    //部落格效果,从右上角到左下角
    void HelloWorld::FadeOutBLTilesDemo()
    {
        //参数分别为(特效持续的时间,网格大小)
        auto fadeOutBLTiles  = FadeOutBLTiles::create(5, Size(50, 50));
        _gridNodeTarget->runAction(fadeOutBLTiles);
    }
    
    //折叠效果 从下到上
    void HelloWorld::FadeOutUpTilesDemo()
    {
        //参数分别为(特效持续的时间, 网格大小)
        auto fadeOutUpTiles = FadeOutUpTiles::create(5, Size(10, 10));
        _gridNodeTarget->runAction(fadeOutUpTiles);
        
    }
    
    //折叠效果,从上到下
    void HelloWorld::FadeOutDownTilesDemo()
    {
        //参数分别为(特效持续的时间,网格大小)
        auto fadeOutDownTiles = FadeOutDownTiles::create(4, Size(20, 50));
        _gridNodeTarget->runAction(fadeOutDownTiles);
    }
    
    //跳动的方块特效
    void HelloWorld::JumpTiles3DDemo()
    {
        //跳动的方块特效(特效持续的时间, 网格的大小, 跳动的次数,振幅)
        auto jumpTiles = JumpTiles3D::create(5, Size(20, 20), 5, 20);
        _gridNodeTarget->runAction(jumpTiles);
    }
    
    //分多行消失特效
    void HelloWorld::SplitColsDemo()
    {
        //参数(特效持续的时间, 列数)
        auto splitCols = SplitCols::create(5, 50);
        _gridNodeTarget->runAction(splitCols);
    }
    
    //分多列消失特效
    void HelloWorld::SplitRowsDemo()
    {
        //参数为(特效持续的时间, 行数)
        auto splitRows = SplitRows::create(5, 50);
        _gridNodeTarget->runAction(splitRows);
    }
    
    //3D翻页特效
    void HelloWorld::PageTurn3DDemo()
    {
        //参数(特效持续的时间,网格大小)
        auto pageTurn3D = PageTurn3D::create(4, Size(20, 20));
        _gridNodeTarget->runAction(pageTurn3D);
    }
    
    void HelloWorld::PauseTest()
    {
        auto action = MoveBy::create(1, Vec2(150,0));
        auto director = Director::getInstance();
        //给一个节点增加一个动作,运行动作,参数分别(动作,动作执行者,是否暂停)
        director->getActionManager()->addAction(action, _grossini, true);
        
         schedule( CC_SCHEDULE_SELECTOR(HelloWorld::unpause), 3);
    }
    
    void HelloWorld::unpause(float dt)
    {
        auto director = Director::getInstance();
        director->getActionManager()->resumeTarget(_grossini);
    }
    
    void HelloWorld::menuCloseCallback(Ref* pSender)
    {
        
    }
    


    展开全文
  • 首先这是现在最基本的分层方式,结合了SSH架构。model层就是对应的数据库表的实体...Action层:引用对应的Service层,在这里结合Struts的配置文件,跳转到指定的页面,当然也能接受页面传递的请求数据,也可以做些...
    
     

    首先这是现在最基本的分层方式,结合了SSH架构。model层就是对应的数据库表的实体类。Dao层是使用了Hibernate连接数据库、操作数据库(增删改查)。Service层:引用对应的Dao数据库操作,在这里可以编写自己需要的代码(比如简单的判断)。Action层:引用对应的Service层,在这里结合Struts的配置文件,跳转到指定的页面,当然也能接受页面传递的请求数据,也可以做些计算处理。以上的Hibernate,Struts,都需要注入到Spring的配置文件中,Spring把这些联系起来,成为一个整体。

     

    一般java都是三层架构 数据访问层(dao) 业务逻辑层(biz 或者services) 界面层(ui) action 是业务层的一部分,是一个管理器 (总开关)(作用是取掉转)(取出前台界面的数据,调用biz方法,转发到下一个action或者页面)  模型成(model)一般是实体对象(把现实的的事物变成java中的对象)作用是一暂时存储数据方便持久化(存入数据库或者写入文件)而是 作为一个包裹封装一些数据来在不同的层以及各种java对象中使用  dao是数据访问层 就是用来访问数据库实现数据的持久化(把内存中的数据永久保存到硬盘中)

     

    Dao主要做数据库的交互工作 Model 是模型 存放你的实体类 Service 做相应的业务逻辑处理 Action是一个控制器

    
     
    
     
    
     
    首先解释面上意思,service是业务层,dao是数据访问层。
    呵呵,这个问题我曾经也有过,记得以前刚学编程的时候,都是在service里直接调用dao,service里面就new一个dao类对象,调用,其他有意义的事没做,也不明白有这个有什么用,参加工作久了以后就会知道,业务才是工作中的重中之重。
    我们都知道,标准主流现在的编程方式都是采用MVC综合设计模式,MVC本身不属于设计模式的一种,它描述的是一种结构,最终目的达到解耦,解耦说的意思是你更改某一层代码,不会影响我其他层代码,如果你会像spring这样的框架,你会了解面向接口编程,表示层调用控制层,控制层调用业务层,业务层调用数据访问层。初期也许都是new对象去调用下一层,比如你在业务层new一个DAO类的对象,调用DAO类方法访问数据库,这样写是不对的,因为在业务层中是不应该含有具体对象,最多只能有引用,如果有具体对象存在,就耦合了。当那个对象不存在,我还要修改业务的代码,这不符合逻辑。好比主板上内存坏了,我换内存,没必要连主板一起换。我不用知道内存是哪家生产,不用知道多大容量,只要是内存都可以插上这个接口使用。这就是MVC的意义。
    接下来说你感觉service的意义,其实因为你现在做东西分层次不是那么严格,在一个你们做东西业务本身也少,举个最简单的例子,你做一个分页的功能,数据1000条,你20条在一个页,你可以把这个功能写成工具类封装起来,然后在业务层里调用这个封装的方法,这才是业务里真正干得事,只要没访问数据库的,都要在业务里写。 
    再有不明白的追问,这是经验问题,呵呵,其实以后你就会懂。只是刚开始写的代码都是有个请求,我就去数据库取,业务几乎没有。
    
     
    
     
    
     
    <span style="color:#333333">怎么说呢,我不是理论帝。所以我讲讲自己的理解
    比说你现在用的是SSH框架,做一个用户模块:
      1、假设现在你做这个功能会用到user表和权限表,那么你前台的页面访问action,action再去调用用户模块service,用户模块service判断你是操作user表还是权限表,如果你操作的是user表则service的实现类就去调用userDAO。如果是操作的是权限表则调用权限的DAO
      2、也就是说DAO一定是和数据库的每张表一一对应,而service则不是。明白的没?其实你一个项目一个service和一个DAO其实也一样可以操作数据库,只不过那要是表非常多,出问题了,那找起来多麻烦,而且太乱了
     3、好处就是你的整个项目非常系统化,和数据库的表能一致,而且功能模块化,这样以后维护或者改错比较容易,性能也高一些</span>
    <span style="color:#333333">
    </span>
    <span style="color:#333333">
    </span>
    <span style="color:#333333">
    </span>
    
     
    简单的说DAO层是跟数据库打交道的,service层是处理一些业务流程的, 至于你说的为什么要用service层封装,我认为:一般来说,某一个程序的有些业务流程需要连接数据库,有些不需要与数据库打交道而直接是一些业务处理,这样就需要我们整合起来到service中去,这样可以起到一个更好的开发与维护的作用,同时也是MVC设计模式中model层功能的体现
    
    
    
    
    
    

    最基本的分层方式,结合了SSH架构。modle层就是对应的数据库表的实体类(如User类)。Dao层,一般可以再分为***Dao接口和***DaoImpl实现类,如userDao接口和userDaoImpl实现类,接口负责定义数据库curd的操作方法,实现类负责具体的实现,即实现Dao接口定义的方法。Service层,引用对应的Dao层数据库操作,在这里可以编写自己需要的代码(比如简单的判断),也可以再细分为Service接口和ServiceImpl实现类。Action层:引用对应的Service层实现业务逻辑,在这里结合Struts的配置文件,跳转到指定的页面,当然也能接受页面传递的请求数据,也可以做些计算处理、前端输入合法性检验(前端可修改网页绕过前端合法性检验,需在后台加一层)。

         Action像是服务员,顾客点什么菜,菜上给几号桌,都是ta的职责;Service是厨师,action送来的菜单上的菜全是ta做的;Dao是厨房的小工,和原材料(通过hibernate操作数据库)打交道的事情全是ta管。

         对象的调用流程:JSP—Action—Service—DAO—Hibernate—数据库。

     

    展开全文
  • Action 详解

    2020-03-07 15:52:10
    Action 是用于处理请求操作的,它是由 StrutsPrepareAndExecuteFilter 分发过来的。 在 Struts2 框架中,Action 是框架的核心类,被称为业务逻辑控制器,主要用于实现对用户请求的处理。 一个 Action 类代表一次请求...

    回到首页☞

    Action 是用于处理请求操作的,它是由 StrutsPrepareAndExecuteFilter 分发过来的。

    在 Struts2 框架中,Action 是框架的核心类,被称为业务逻辑控制器,主要用于实现对用户请求的处理。

    一个 Action 类代表一次请求或调用,每个请求的动作都对应一个相应的 Action 类。也就是说,用户的每次请求,都会转到一个相应的 Action 类中,由这个 Action 类进行处理。

    简而言之,Action 就是用于处理一次用户请求的对象。

    与传统的MVC框架相比,可以实现struts2接口,也可以不实现struts2接口,传统MVC必须实现MVC接口,就和MVC框架严重耦合。
    创建一个Action 一般都会继承ActionSupport ,并且定义变量,覆盖execute方法。变量会被struts2通过setter方法自动赋值,execute方法中直接使用即可。
    当然也可以不继承,但是必须有 execute() 方法,当然也可以实现Action 接口。

    注意:action类的全路径(即包名)必须含有”action”的词汇。

    ActionSupport类

    ActionSupport 是 Action 接口的默认实现类,所以继承 ActionSupport 就相当于实现了 Action 接口。

    除 Action 接口以外,ActionSupport 类还实现了 Validateable、ValidationAware、TextProvider、LocaleProvider 和 Serializable 等接口,这为用户提供了更多的功能。

    ActionSupport 类中提供了许多默认方法,这些默认方法包括数据校验的方法、默认的处理用户请求的方法等。

    如果开发者的 Action 类继承 ActionSupport 类,会大大简化 Action 的开发

    public class HelloWorldAction extends ActionSupport {
      private Message msg;
    
      @Override
      public String execute() throws Exception {
        msg = new Message();
        return SUCCESS;
      }
    
      public Message getMsg() {
        return msg;
      }
    
      public void setMsg(Message msg) {
        this.msg = msg;
      }
    }
    

    Action 接口

    Action 接口位于 com.opensymphony.xwork2 包中,并且接口中只定义了五个字符串常量和一个 execute() 方法。

    其中,execute() 方法是 Action 类的默认请求处理方法,该方法返回一个字符串,而上面五个字符串常量的作用是统一 execute() 方法的返回值。

    import com.opensymphony.xwork2.Action;
    
    public class ImplAction implements Action {
    
        public String execute() throws Exception {
            System.out.println("ImplAction...run");
            return "defaultAction";
        }

    不继承任何类的Action

    如果Struts2发现Action类没有实现Action接口,会通过反射来调用execute方法。
    好处就是不予struts2耦合。

    public class DefaultAction {
    
        public String execute() throws Exception {
            System.out.println("DefaultAction...run");
            return "";
        }
    }
    

    回到首页☞

    展开全文
  • Action

    2019-10-22 15:09:30
    无参数 Action testAction = () => { Thread.Sleep(2000); TMSMessageBox.ShowError("test"); }; testA...
  • package com.ken.action2; import com.opensymphony.xwork2.ActionSupport; public class CustomerAction extends ActionSupport { private static final long serialVersionUID = -31598925835
  • Struts2系列(二)Action

    2018-07-16 17:28:29
    一.Action是Struts2的核心,所有用户请求都需要使用Action处理并返回数据。 二.Action测试代码 直接上代码,具体解释见代码注释 代码演示内容:创建ActionAction默认值,Action获取参数 HelloAction.java ...
  • 为什么Struts中.action的时候可以访问,是.do的时候不能访问呢?遇到这个问题的时候有点晕乎,在网上查了些资料,终于恍然大悟!下面把自己的经验说来给大家,希望对大家有所帮助。 其实问题发生在struts.properties...
  • Struts2的核心功能是action,对于开发人员来说,使用Struts2主要就是编写action,action类通常都要实现com.opensymphony.xwork2.Action接口,并实现该接口中的execute()方法。 该方法如下:  public String ...
  • 所以经常会从Jsp页面调用到后端Java中Action类,因此希望总结一下,下次遇到类似问题不用再翻代码去查看: 1. 最常见的form表单提交: 一般情况下,比如在登陆界面,因为主要只涉及到登陆的功能,我们会使用form...
  • QAction系列详解

    2018-08-16 11:39:14
     QAction类提供了抽象的用户界面action,这些action可以被放置在窗口部件中。  应用程序可以通过菜单,工具栏按钮以及键盘快捷键来调用通用的命令。由于用户期望每个命令都能以相同的方式执行,而不管命令所使用...
  • 在Struts2中,Action处理完用户请求后,将会返回一个字符串对象,这个字符串对象就是一个逻辑视图名。Struts 2通过配置逻辑视图名和物理视图之间的映射关系,一旦系统收到Action返回的某个逻辑视图名,系统就会把...
  • Action/Service/DAO简介: Action是管理业务(Service)调度和管理跳转的。 Service是管理具体的功能的。 Action只负责管理,而Service负责实施。 DAO只完成增删改查,虽然可以1-n,n-n,1-1关联,模糊、动态、子...
  • Struts2的核心功能是action,对于开发人员来说,使用Struts2主要就是编写action,action类通常都要实现com.opensymphony.xwork2.Action接口,并实现该接口中的execute()方法。 该方法如下:  public String ...
  • Action bar是一个标识应用程序和用户位置的窗口功能,并且给用户提供操作和导航模式。在大多数的情况下,当你需要突出展现用户行为或全局导航的activity中使用action bar,因为action bar能够使应用程序给用户提供...
  • 修改form表单action路径

    2020-05-11 16:10:14
    原因:form表单提交修改$("#xxxx").action="xxxx.action"是不可行的。 1、通常我们想到是使用$("#xxxx").action="xxxx.action";//但是这样不可用 我们应该采用attr()方法。该方法专门用于为属性赋值。 所以应该写...
  • 你是不是很多时候,想从弹出的电话本姓名列表中中查找到某个人... Itent.ACTION_PICK Intent.ACTION_GET_CONTENT 两者都可以完成类似的功能,让我们一起来看下例子: <br /> 第一:Intent.ACTION
  • 在提交form表单的时候,action 不填就默认为提交到当前的页面。今天遇到的当前页面是已经带了参数了,比如:www.xxx.com/index.php?id=1,按照action留空的方法来提交,就不能提交到这个带参数的url了,也不能到把...
  • There is no Action mapped for namespace [/] and action name [Login] associated with context path [/eprint] 错误 做如下检查: 1、确保struts.xml文件名大小写正确:struts.xml 2、确保struts.xml文件在src
1 2 3 4 5 ... 20
收藏数 1,461,681
精华内容 584,672
关键字:

action