深入分析JavaWeb 44 -- Struts2开发核心之动作类Action

一、Action动作类(一般用**Action结尾)

struts2 的Action可以是POJO(Plain Old Java Object)

为了让用户开发的Action更加规范struts2提供了一个Action接口

通过method属性指定Action执行方法

没有指定method属性，默认执行execute方法

<action name="addCustomer" class="xgp.struts.actions.CustomerAction" />

通过method属性，指定调用Action相应方法处理请求

<action name="addCustomer" class="xgp.struts.actions.CustomerAction" method="add">

因为指定了method=”add”，所以HelloAction的ass方法会被调用.

1、编写动作类的三种方式

a、第一种方法是，动作类不实现、也不继承任何的接口和类。即动作类是一个非常普通的JavaBean。

public class HelloAction {
    public String sayHello(){
        System.out.println("动作类执行了，访问成功！");
        return "success";
    }
}

b、动作类实现com.opensymphony.xwork2.Action接口。可以使用常量

Action接口：

public static final String SUCCESS = "success"; //成功时转向的视图
public static final String NONE = "none";//执行成功后，不转向的任何视图。比如下载任务
public static final String ERROR = "error";//转向错误视图
public static final String INPUT = "input";//转向输入视图。（回显：验证与转换失败，转向原有页面）
public static final String LOGIN = "login";//登录视图（用户没有登录）
public String execute() throws Exception;// public 修饰符,String 返回值,无参数

c、继承com.opensymphony.xwork2.ActionSupport（开发中建议）

Struts2为Action接口提供了一个实现类 ActionSupport，定义了 表单域校验、错误信息设置和获得国际化信息相关一些方法

public class ActionSupport implements Action, Validateable, ValidationAware, TextProvider, LocaleProvider, Serializable {

    protected static Logger LOG = LoggerFactory.getLogger(ActionSupport.class);

    private final ValidationAwareSupport validationAware = new ValidationAwareSupport();

    private transient TextProvider textProvider;
    private Container container;

    public void setActionErrors(Collection<String> errorMessages) {
        validationAware.setActionErrors(errorMessages);
    }

    public Collection<String> getActionErrors() {
        return validationAware.getActionErrors();
    }

    public void setActionMessages(Collection<String> messages) {
        validationAware.setActionMessages(messages);
    }

    public Collection<String> getActionMessages() {
        return validationAware.getActionMessages();
    }

2、动作类中的动作方法

要求：

a、必须是public的

b、必须返回String类型的

c、必须没有参数

3.动作类的生命周期

动作类每次访问都会重新被实例化，是线程安全的。

public class HelloAction {

    public HelloAction() {
        System.out.println("执行构造函数HelloAction，实例化对象。");
    }

    public String sayHello(){
        System.out.println("动作方法sayHello执行了，访问成功！");
        return "success";
    }
}

测试结果：

二、动作类中动作方法的调用

动作方法：动作类中的定义的处理业务有关的方法

实例：模拟一个curd的动作类

工程目录如下：

1、新建一个 curd.jsp

  <body>
    <a href="${pageContext.request.contextPath}/customer/addCustomer.action">增加用户</a>
    <a href="${pageContext.request.contextPath}/customer/editCustomer.action">修改用户</a>
    <a href="${pageContext.request.contextPath}/customer/findCustomer.action">查询用户</a>
    <a href="${pageContext.request.contextPath}/customer/delCustomer.action">删除用户</a>
  </body>

2、在struts.xml中配置

如下图所示：

<struts>
    <constant name="struts.devMode" value="true" />
    <package name="p1" extends="struts-default" namespace="/customer">
        <action name="addCustomer" class="xgp.struts.actions.CustomerAction" method="add">
            <result name="success" type="dispatcher">/addCustomer.jsp</result>
            <result name="error" type="dispatcher">/error.jsp</result>
        </action>
        <action name="editCustomer" class="xgp.struts.actions.CustomerAction" method="edit">
            <result name="success" type="dispatcher">/editCustomer.jsp</result>
        </action>
        <action name="findCustomer" class="xgp.struts.actions.CustomerAction" method="find">
            <result name="success" type="dispatcher">/findCustomer.jsp</result>
        </action>
        <action name="delCustomer" class="xgp.struts.actions.CustomerAction" method="del">
            <result name="success" type="dispatcher">/delCustomer.jsp</result>
        </action>
    </package>
</struts>

3、建立动作处理类CustomerAction

package xgp.struts.actions;

import xgp.struts.service.BusinessService;
import xgp.struts.serviceImpl.BusinessServiceImpl;

import com.opensymphony.xwork2.ActionSupport;

public class CustomerAction extends ActionSupport{

    private BusinessService bs = new BusinessServiceImpl();
    public String add(){
        //调用Service添加方法
        try {
            bs.add();
            return SUCCESS;
        } catch (Exception e) {
            return ERROR;
        }
    }

    public String edit(){
        bs.edit();
        return SUCCESS;
    }

    public String find(){
        bs.find();
        return SUCCESS;
    }

    public String del(){
        bs.del();
        return SUCCESS;
    }
}

4、建立相应的业务接口BusinessService和实现类BusinessServiceImpl

BusinessService

package xgp.struts.service;

public interface BusinessService {
    public void add();
    public void edit();
    public void del();
    public Object find();

}

BusinessServiceImpl

package xgp.struts.serviceImpl;

import xgp.struts.service.BusinessService;

public class BusinessServiceImpl implements BusinessService{

    @Override
    public void add() {
        System.out.println("Serviece的add方法执行成功！");

    }

    @Override
    public void edit() {
        System.out.println("Serviece的edit方法执行成功！");

    }

    @Override
    public void del() {
        System.out.println("Serviece的del方法执行成功！");

    }

    @Override
    public Object find() {
        System.out.println("Serviece的find方法执行成功！");
        return null;
    }

}

结果如下：

1、使用通配符配置Action

在配置<action...>元素时，允许在指定name属性时，使用模式字符串（用"*"代表一个或多个任意字符）

在class、method属性及<result>子元素中通过 {N} 形式代表前面地N个* 匹配子串

例如上面的案例中struts.xml我们可以改写如下：


<!-- 使用通配符：*
         {2}:匹配第2个星花的内容
          -->
          <!-- http://localhost:8080/xgp.struts/customer/add_Customer.action
            第一个*： add
            第二个*：Customer
           -->
<action name="*_*" class="xgp.struts.actions.{2}Action" method="{1}">
    <result name="success" type="dispatcher">/{1}{2}.jsp</result>
</action>

2、使用Action的动态方法调用（官方不建议使用）

动态方法调用：DMI

http://localhost:8080/xgp.struts/customer/add_Customer!add

希望执行CustomerAction的add动作方法（动态方法调用）

动态方法调用：Struts2框架默认是禁止的。可以通过配置一个常量打开它：

<constant name="struts.enable.DynamicMethodInvocation" value="true"></constant>

通过url动态指定调用Action哪个方法而无需配置<action>的method属性, 通过 !方法名 指定调用Action哪个方法

<a href="${pageContext.request.contextPath}/customer/customer!add.action">添加用户</a><br/>
<a href="${pageContext.request.contextPath}/customer/customer!edit.action">修改用户</a><br/>
<a href="${pageContext.request.contextPath}/customer/customer!del.action">删除用户</a><br/>

3、配置默认Action和 配置Action默认处理类

用户可以为每个package定义一个默认的Action，如果访问路径在package没有匹配<action> 就会执行默认action

<default-action-ref name="defaultAction"></default-action-ref>
<action name="defaultAction">
    <result name="success" type="dispatcher">/whatareuwant.jsp</result>
</action>

如果配置<action> 没有指定class属性，就会执行Action的默认处理类，在struts-default.xml中.

指定默认的动作处理类

 <!-- 指定默认的动作：当用户访问的动作在本包中没有找到时执行的动作 -->
        <default-action-ref name="defaultAction"></default-action-ref>
        <!-- 指定默认的动作处理类 -->
         <default-class-ref class="xgp.struts.actions.DefaultAction"></default-class-ref>
        <action name="customer" class="xgp.struts.actions.CustomerAction">
            <result name="success" type="dispatcher">/success.jsp</result>
        </action>
        <action name="defaultAction">
            <result name="success" type="dispatcher">/whatareuwant.jsp</result>
        </action>

三、在动作类中访问ServletAPI

Struts2的Action没有与任何Servlet API耦合，便于测试.这是他的优点之一.

1、三大实现方法

1、ActionContext

  • getContext() 返回ActionContext实例对象
  • get(key) 相当于 HttpServletRequest的getAttribute(String name)方法
  • put(String,Object) 相当于HttpServletRequest的setAttribute方法
  • getApplication() 返回一个Map对象，存取ServletContext属性
  • getSession() 返回一个Map对象，存取HttpSession属性
  • getParameters() 类似调用HttpServletRequest的getParameterMap()方法
  • setApplication(Map) 将该Map实例里key-value保存为ServletContext的属性名、属性值
  • setSession(Map) 将该Map实例里key-value保持为HttpSession的属性名、属性值

2、方式二：（简单，推荐使用）使用ServletActionContext

static PageContext getPageContext()
static HttpServletRequest getRequest()
static HttpServletResponse getResponse()
static ServletContext getServletContext()

该方案可避免Action类实现XxxAware接口，但Action依然与Servlet API直接耦合

开发中优先使用ActionContext 这样可以避免耦合

package com.itheima.actions;

import javax.servlet.ServletContext;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.jsp.PageContext;

import org.apache.struts2.ServletActionContext;
import org.apache.struts2.interceptor.ServletRequestAware;

import com.opensymphony.xwork2.ActionSupport;

public class ServletAPIAction1 extends ActionSupport{

    //打印当前应用名称到控制台上
    //获取ServletAPI有关类的实例
    //方式一：
    public String execute() throws Exception {
        //实际上利用ThreadLocal这个类
        //ServletActionContext：记住
        HttpServletRequest request = ServletActionContext.getRequest();
        System.out.println(request.getContextPath());
        PageContext pc = ServletActionContext.getPageContext();
        HttpServletResponse response = ServletActionContext.getResponse();
        response.getWriter().write(request.getContextPath());//自己输出
        ServletContext sc = ServletActionContext.getServletContext();
        System.out.println(sc.getRealPath("/"));
        return NONE;
    }
}

3、方式三：（麻烦）实现接口，访问Action时完成注入

ServletContextAware
void setServletContext(javax.servlet.ServletContext context)

ServletRequestAware
void setServletRequest(javax.servlet.http.HttpServletRequest request)

ServletResponseAware
void setServletResponse(javax.servlet.http.HttpServletResponse response)

动作类实现特定的接口。就必须实现特定的方法，调用动作方法前，框架会把响应的对象给注入进来。

package com.itheima.actions;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.apache.struts2.interceptor.ServletRequestAware;
import org.apache.struts2.interceptor.ServletResponseAware;

import com.opensymphony.xwork2.ActionSupport;
//获取ServletAPI有关类实例的方式二
public class ServletAPIAction2 extends ActionSupport implements ServletRequestAware,ServletResponseAware{
    private HttpServletRequest request;
    private HttpServletResponse response;
    //该方法会在调用动作方法之前先执行：把当前的HttpServletRequest对象给你注入进来
    public void setServletRequest(HttpServletRequest request) {
        this.request = request;
    }

    public void setServletResponse(HttpServletResponse response) {
        this.response = response;
    }
    @Override
    public String execute() throws Exception{

        //要使用HttpServletRequest对象
        //System.out.println(request.getContextPath());
        response.getWriter().write(request.getContextPath());
        return NONE;
    }
}

原理：是一个拦截器给你注入进来的。struts-default.xml

<interceptor name="servletConfig" class="org.apache.struts2.interceptor.ServletConfigInterceptor"/>

一看源码便知。

配置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>
    <constant name="struts.devMode" value="true" />
    <package name="p1" extends="struts-default">
        <!-- 因为包继承了struts-default，默认使用struts-default.xml中定义的那个默认的拦截器栈：defaultStack
            在执行动作方法之前：defaultStack中的组员都会拦截你的动作调用
            包含：一个叫做servletConfig的拦截器。
         -->

        <!-- 演示在动作类中获取Servlet有关的类的实例：HttpServletRequest HttpServletResponse HttpSession ServletContext等
        Struts2已经将ServletAPI和动作类进行解耦，这是他的优点之一
         -->
        <action name="showContextPath1" class="com.itheima.actions.ServletAPIAction1">
            <result name="success" type="dispatcher">/success.jsp</result>
        </action>
        <action name="showContextPath2" class="com.itheima.actions.ServletAPIAction2" method="execute">
            <result name="success" type="dispatcher">/success.jsp</result>
        </action>
    </package>
</struts>

2、局部和全局结果视图

result元素：指定动作类的动作方法执行完后的结果视图.

属性：

- name：字符串，与动作方法返回的值一致。默认是success

- type：指定处理结果的结果类型的别名。（struts-default.xml有定义，共10个）。默认值是dispatcher

Action处理完用户请求后，将返回一个普通字符串整个普通字符串就是一个逻辑视图名，Struts2 根据逻辑视图名，决定响应哪个结果。

Struts2处理结果使用<result>元素配置

  • 局部结果：将<result>作为<action>子元素配置
  • 全局结果：将<result>作为<global-results>元素的子元素配置

配置<result>元素通常需要指定两个属性

  • name 该属性指定配置逻辑视图名
  • type 该属性指定结果类型

当多个action中都使用到了相同result，这时我们应该把result定义为全局结果。struts1中提供了全局forward，struts2中也提供了相似功能：

<package ....>
    <global-results>
        <result name="message">/message.jsp</result>
    </global-results>
</package>

注:局部的会覆盖全局

Struts1中应用范围内action的实例 action是单实例(执行时,现在缓存中查找实例,有用，没有创建新的实例)Struts2中 应用范围内action的实例,每个请求都会创建一个action实例Servlet属于单实例多线程的应用，实例只在初始化时被加载多实例比单实例的优点，不会产生并发问题，但执行速度不如单实例。

如下：

<struts>
    <constant name="struts.devMode" value="true" />

        <package name="mydefault" extends="struts-default" abstract="ture">
            <global-results>
                <result name="success" type="dispatcher">/success.jsp</result>
            </global-results>
        </package>

        <package name="p1" extends="mydefault">
        <action name="action1" class="xgp.struts.actions.Demo1Action">
            <!-- <result name="success" type="dispatcher">/success.jsp</result> -->
        </action>
        <action name="action2" class="xgp.struts.actions.Demo2Action">
            <!-- <result name="success" type="dispatcher">/success.jsp</result> -->
        </action>
    </package>

    <package name="p2" extends="mydefault">
            <action name="action3" class="xgp.struts.actions.Demo3Action">
                <!-- <result name="success" type="dispatcher">/success.jsp</result> -->
            </action>
    </package>

</struts>

3、Struts2提供的结果视图 （共10个）

<result-type name="dispatcher" class="org.apache.struts2.dispatcher.ServletDispatcherResult" default="true"/>
<result-type name="chain" class="com.opensymphony.xwork2.ActionChainResult"/>
<result-type name="freemarker" class="org.apache.struts2.views.freemarker.FreemarkerResult"/>
<result-type name="httpheader" class="org.apache.struts2.dispatcher.HttpHeaderResult"/>
<result-type name="redirect" class="org.apache.struts2.dispatcher.ServletRedirectResult"/>
<result-type name="redirectAction" class="org.apache.struts2.dispatcher.ServletActionRedirectResult"/>
<result-type name="stream" class="org.apache.struts2.dispatcher.StreamResult"/>
<result-type name="velocity" class="org.apache.struts2.dispatcher.VelocityResult"/>
<result-type name="xslt" class="org.apache.struts2.views.xslt.XSLTResult"/>
<result-type name="plainText" class="org.apache.struts2.dispatcher.PlainTextResult" />

1. chain：从一个动作转发到另外一个动作

同一个包内的动作转发

    <package name="p3" namespace="/result" extends="struts-default">
        <!--  action1的结果是另外一个Action的请求:一个动作转发到了另外一个动作
            演示：同包内的动作转发-->
        <action name="action1">
            <result name="success" type="chain">action2</result>
        </action>
        <action name="action2">
            <result>/success.jsp</result>
        </action>
    </package>

不同包之间的动作转发

    <package name="p3" namespace="/result" extends="struts-default">
         <action name="action1">
            <result name="success" type="chain">
                <param name="namespace">/user</param> 给chain的实际处理类注入参数
                <param name="actionName">action2</param>
            </result>
        </action>
    </package>

2. dispatcher：从一个动作转发到另外一个JSP

dispatcher 结果类型是最常用的结果类型, 也是 struts 框架默认的结果类型

该结果类型有一个 location 参数, 它是一个默认参数

dispatcher 结果类型将把控制权转发给应用程序里的某个资源

3. redirect：从一个动作重定向到一个JSP

最明显的是地址栏发生变化。

<action name="action2">
    <result type="redirect">/success.jsp</result>
</action>

4. redirectAction：从一个动作重定向到另外一个动作

action1先将动作重定向到action2，然后action2在转发到success.jsp,地址栏应该显示的是action2.

<action name="action1">
    <result name="success" type="redirectAction">action2</result>
</action>
<action name="action2">
    <result>/success.jsp</result>
</action>

5. plainText:以纯文本的形式显示JSP

<package name="p4" namespace="/user" extends="struts-default">
    <action name="action2">
        <result type="plainText">/success.jsp</result>
    </action>
</package>

6. stream：文件下载

<package name="p5" extends="struts-default">
        <action name="download" class="xgp.struts.actions.DownLoadAction" method="download">
            <result name="success" type="stream">
                <!-- 配置输入流 -->
                <param name="inputName">imageInputStream</param>
                <!-- 告知浏览器响应正文的MIME类型 -->
                <param name="contentType">application/octet-stream</param>
                <!-- 告知浏览器用下载的方式打开 -->
                <param name="contentDisposition">attachment;filename=26.jpg</param>
                <!-- 下载时使用的缓存大小 -->
                <param name="bufferSize">1024</param>
            </result>
        </action>
    </package>

DownLoadAction类

package com.itheima.actions;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.InputStream;

import javax.servlet.ServletContext;

import org.apache.struts2.ServletActionContext;

import com.opensymphony.xwork2.ActionSupport;
//文件下载;结果类型stream的使用
public class DownLoadAction extends ActionSupport {

    private InputStream imageInputStream;

    public InputStream getImageInputStream() {
        return imageInputStream;
    }

    public void setImageInputStream(InputStream imageInputStream) {
        this.imageInputStream = imageInputStream;
    }

    public String download() throws Exception{
        //得到文件的真实路径
        ServletContext sc = ServletActionContext.getServletContext();
        String filePath = sc.getRealPath("/WEB-INF/classes/26.jpg");
        //构建输入流
        imageInputStream = new FileInputStream(filePath);
        //用stream结果视图输出
        //返回逻辑视图
        return SUCCESS;
    }
}

结果显示

4、自定义结果视图

目标：用一个叫做image的视图，输入随机验证码图片 CAPTCHA，我们首先可以看dispatcher的声明；

public class org.apache.struts2.dispatcher.ServletDispatcherResult extends org.apache.struts2.dispatcher.StrutsResultSupport

public abstract class org.apache.struts2.dispatcher.StrutsResultSupport implements com.opensymphony.xwork2.Result

可以看到dispatch的实现类是继承StrutsResultSupport，而StrutsResultSupport又实现了Resul接口。多以我么可以

1、编写一个类实现com.opensymphony.xwork2.Result，或者继承org.apache.struts2.dispatcher.StrutsResultSupport，这里定义一个类，实现com.opensymphony.xwork2.Result接口

package xgp.struts.actions;

import java.awt.Color;
import java.awt.Font;
import java.awt.Graphics;
import java.awt.image.BufferedImage;
import java.util.Random;

import javax.imageio.ImageIO;
import javax.servlet.http.HttpServletResponse;

import org.apache.struts2.ServletActionContext;

import com.opensymphony.xwork2.ActionInvocation;
import com.opensymphony.xwork2.Result;

public class CaptchaResult implements Result {

    private int width;
    private int height;

    public int getWidth() {
        return width;
    }
    public void setWidth(int width) {
        this.width = width;
    }
    public int getHeight() {
        return height;
    }
    public void setHeight(int height) {
        this.height = height;
    }
    public void execute(ActionInvocation arg0) throws Exception {
        /*int width=120,height=25;*/
        //1.在内存生成一个图片
        BufferedImage img = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);
        //2.得到画笔
        Graphics g = img.getGraphics();
        //3.画一个矩形框
        g.setColor(Color.BLUE);
        g.drawRect(0, 0, width, height);
        //4.填充背景
        g.setColor(Color.YELLOW);
        g.fillRect(1, 1, width-1, height-1);
        //5.画一些干扰线条
        g.setColor(Color.GRAY);
        Random random = new Random();
        for(int i=1;i<=20;i++)
             g.drawLine(random.nextInt(width), random.nextInt(height), random.nextInt(width), random.nextInt(height));
        //6.画字符串随机的
        g.setColor(Color.RED);
        //设置字体
        g.setFont(new Font("宋体",Font.BOLD|Font.ITALIC,20));
        for(int i=1;i<=4;i++)
            g.drawString(random.nextInt(10)+"", i*20,20);

        //7.输出
        HttpServletResponse response = ServletActionContext.getResponse();
        response.setContentType("image/jpeg");
        ImageIO.write(img, "jpg", response.getOutputStream());

    }

}

2、自定义的结果视图，（必须先声明后才能使用）

<package name="p6" extends="struts-default">
    <result-types>
        <result-type name="captcha" class="xgp.struts.actions.CaptchaResult"></result-type>
    </result-types>
    <action name="genCaptcha">
        <result name="success" type="captcha">
            <param name="width">300</param>
            <param name="height">400</param>
        </result>
    </action>
</package>

3、就可以使用了，编写视图页面login.jsp

<body>
    <form action="">
        用户名：<input type="text" name="username"/><br />
        验证码：<input type="text" name="code" /><img alt="验证码" src="${pageContext.request.contextPath}/genCaptcha.action">
    </form>
  </body>

运行结果

如果想在多个包中用，可以将package声明为abstract ,然后别的包继承自这个包即可。

阶段性小结

时间： 2024-10-14 00:47:46

深入分析JavaWeb 44 -- Struts2开发核心之动作类Action的相关文章

深入分析JavaWeb 43 -- Struts2开发入门

一.Struts2概述 1.Struts2是什么? Struts2是一个M(模型-域–范围模型)V(View视图)C(控制器)框架(模型2).框架都是一个半成品.提高开发效率. Struts1是一个MVC框架,非常流行.有很大的缺点.此时一个webwork的框架设计超前,名气不是很大.Struts1+webworkd=struts2.用的是struts1的名字,但是与sruts1没啥关系,struts2的核心是webwork框架. 2.Struts2能干什么? web开发Strust2 核心功能

深入分析JavaWeb 47 -- Struts2拦截器与文件上传下载

一.struts2中的拦截器(框架功能核心) 1.过滤器VS拦截器 过滤器VS拦截器功能是一回事.过滤器是Servlet规范中的技术,可以对请求和响应进行过滤. 拦截器是Struts2框架中的技术,实现AOP(面向切面)的编程思想,是可插拔的, 可以对访问某个 Action 方法之前或之后实施拦截. 拦截器栈(Interceptor Stack): 将拦截器按一定的顺序联结成一条链. 在访问被拦截的方法时, Struts2拦截器链中的拦截器就会按其之前定义的顺序被依次调用 Struts2执行原理

深入分析JavaWeb Item47 -- Struts2拦截器与文件上传下载

一.struts2中的拦截器(框架功能核心) 1.过滤器VS拦截器 过滤器VS拦截器功能是一回事. 过滤器是Servlet规范中的技术,能够对请求和响应进行过滤. 拦截器是Struts2框架中的技术.实现AOP(面向切面)的编程思想.是可插拔的, 能够对訪问某个 Action 方法之前或之后实施拦截. 拦截器栈(Interceptor Stack): 将拦截器按一定的顺序联结成一条链. 在訪问被拦截的方法时, Struts2拦截器链中的拦截器就会按其之前定义的顺序被依次调用 Struts2运行原

深入分析JavaWeb Item46 -- Struts2数据校验与国际化

1.用户输入数据的校验 1.校验方式 a:客户端校验.(防君子防不了小人)在页面中写js脚本. 这样做的好处是: 输入错误的话提醒比较及时: 减轻服务器的压力 b.服务器端校验. 数据安全 ,整个应用阻止非法数据的最后防线 而在实际开发中通常选择:a+b 2.服务器端数据校验: 1.编程式校验:自己Action中编写一个校验代码(缺点:验证规则都写在了代码中) 前提:动作类继承ActionSupport,重写Validateable接口中的validate()方法 ,在该方法中完成验证. 步骤如

深入分析JavaWeb 46 -- Struts2数据校验与国际化

1.用户输入数据的校验 1.校验方式 a:客户端校验.(防君子防不了小人)在页面中写js脚本. 这样做的好处是: 输入错误的话提醒比较及时: 减轻服务器的压力 b.服务器端校验. 数据安全 ,整个应用阻止非法数据的最后防线 而在实际开发中通常选择:a+b 2.服务器端数据校验: 1.编程式校验:自己Action中编写一个校验代码(缺点:验证规则都写在了代码中) 前提:动作类继承ActionSupport,重写Validateable接口中的validate()方法 ,在该方法中完成验证. 步骤如

深入分析JavaWeb 48 -- Struts2中OGNL表达式与ValueStack

一.OGNL表达式 1.OGNL表达式介绍 OGNL是Object Graphic Navigation Language(对象图导航语言)的缩写,它是一个开源项目. Struts2框架使用OGNL作为默认的表达式语言. OGNL相对其它表达式语言具有下面几大优势: 1.支持对象方法调用,如xxx.doSomeSpecial(): 2.支持类静态的方法调用和值访问,表达式的格式: @[类全名(包括包路径)]@[方法名 | 值名],例如:@[email protected]('foo %s', '

深入分析JavaWeb 45 -- Struts2封装请求参数与类型转换

作为MVC框架,必须要负责解析HTTP请求参数,并将其封装到Model对象中,Struts2提供了非常强大的类型转换机制用于请求数据 到 model对象的封装. 1.Struts2 提供三种数据封装的方式 Action 本身作为model对象,通过成员setter封装 创建独立model对象,页面通过ognl表达式封装 使用ModelDriven接口,对请求数据进行封装 1. 方式一:在动作类中成员变量给予初始值. 在配置文件中struts.xml中 <package name="p1&q

深入分析JavaWeb Item5 -- Servlet开发

一.Servlet简介 Servlet是sun公司提供的一门用于开发动态web资源的技术. Sun公司在其API中提供了一个servlet接口,用户若想用发一个动态web资源(即开发一个Java程序向浏览器输出数据),需要完成以下2个步骤: 1.编写一个Java类,实现servlet接口. 2.把开发好的Java类部署到web服务器中. 按照一种约定俗成的称呼习惯,通常我们也把实现了servlet接口的java程序,称之为Servlet 二.Servlet的运行过程 Servlet程序是由WEB

深入分析JavaWeb Item49 -- Struts2中常用标签与主题

一.非UI标签 1.property标签 property标签用于输出指定值: * default:可选属性, 如果需要输出的属性值为null,则显示该属性指定的值 * escape:可选属性,指定是否格式化HTML代码. * value: 可选属性,指定需要输出的属性值,如果没有指定该属性,则默认输出ValueStack栈顶的值. 2.set标签 set标签用于将某个值放入指定范围. var:变量的名字,name,id和var表达的含义是一样的,name,id被var替代 scope:指定变量