语源科技BlogJava-

快速、方便、有效的Filter

Aidan — Thu, 10 Jun 2010 06:45:00 GMT

      当我们在做web应用的时候都会处理客户端提交到服务器的数据，如去除前后空格，一些非常字符，SQL注入类似的东西，在这里我主要说前后空格我是怎么来解决的，其它也都可以照此方法快速、方便、有效的解决，但是我一般对于非法字符，都是采用了标签来解决它的，并没有使用Filter转义掉(纯属个人解决办法)。
      去除前后空格看似非常简单的事，但是有许多人可能就是因为这一个小问题，折磨自己半天，客户端提交到所有的东西，都是以字符串形式提交的，我们不知道客户是怎么操作的，他可能把一个age属性对应的值，在输入时多加了一个空格，而服务器age对应的却是Integer类型，如果你使用servlet这事也好解决，但是如果你使用的是MVC框架，自动封装时就会得到一个类型转换异常，然而这个时候你是否有好的解决办法呢？
      这里我使用Filter来解决这一问题，这是最简单方便有效的解决方式，因为你不需要对每一个属性在封装前都去trim()，因为这是一件非常乏味的事情。大家都知道filter可以过滤我们想要它过滤的每一个请求，在这请求中有HttpServletRequest、HttpServletResponse。我们知道服务器取得客户端发送的参数都是通过HttpServletRequest来获取的，那我们可不可以在使用HttpServletRequest取值的时候就为每一个客户端提交的属性去除前后空格，或者其它的一些过滤操作。这肯定是可以的，那我们先来了解一下服务器是怎么取得客户端的值的。

1.getParameter(name)，返回单个值。
2.getParameterValues(name)，返回一个数组。
3.getParameterMap()，把客户端提交参数封装为一个Map返回。K：name，V：value。

当我们使用servlet的时候一般都是使用前两种，struts1使用的第2种，struts2(xwork)则使用的第3种，那么我们只要在这三个方法调用的时候处理前后空格，那么返回到服务器的参数就又减少了一分出bug的机会，看下面的实现。

public class RequestParameterFilter implements Filter {

    private static Log log = LogFactory.getLog(RequestParameterFilter.class);

    private List<String> excludeNames;

    public void destroy() {

    }

    public void doFilter(ServletRequest request, ServletResponse response,
            FilterChain chain) throws IOException, ServletException {
        //
        request = new HttpServletRequestWrapper2((HttpServletRequest) request);
        chain.doFilter(request, response);
    }

    public void init(FilterConfig config) throws ServletException {
        String exclude = config.getInitParameter("exclude");
        // not is null.
        if (exclude != null && exclude.length() > 0) {
            excludeNames = Arrays.asList(exclude.split(","));
            if (log.isDebugEnabled()) {
                log.debug("initialize arguments.");
            }
        }
    }

    /**
     * 该类继承之HttpServletRequestWrapper，并重写了对应取得客户端相当参数值的所有的方法。
     *

getParameter

getParameterValues

getParameterMap

     *
     * @version 1.0/2010-6-10 上午11:25:47
     * @author Aidan
     * @see HttpServletRequestWrapper
     */
    private class HttpServletRequestWrapper2 extends HttpServletRequestWrapper {

        private ParameterMap2 pm2;

        public HttpServletRequestWrapper2(HttpServletRequest request) {
            super(request);
        }

        public String getParameter(String name) {
            if (excludeNames != null && excludeNames.contains(name)) {
                return super.getParameter(name);
            }
            return trim(super.getParameter(name));
        }

        @SuppressWarnings("unchecked")
        public Map getParameterMap() {
            // xwork便使用此方法取值
            // 该方法返回一个Map，Map映射了客户端请求对应的键值(K,V)。
            if (pm2 == null) {
                pm2 = new ParameterMap2(super.getParameterMap());
            }
            return pm2;
        }

        public String[] getParameterValues(String name) {
            // Struts1使用此方法取得所有的参数值
            if (excludeNames != null && excludeNames.contains(name)) {
                return super.getParameterValues(name);
            }
            return (String[]) trim(super.getParameterValues(name));
        }
    }

    /**
     * 该此继承自HashMap。
     *
     * @version 1.0/2010-6-10 上午11:30:13
     * @author Aidan
     * @see HashMap
     */
    @SuppressWarnings( { "unchecked", "serial" })
    private class ParameterMap2 extends HashMap {

        private Set entrySet;

        /**
         * 若要构造此类对象，则需要传入一个map参数，该map对应的客户端请求的参数(K,V)。
         *
         * @param map
         *            映射客户端参数。
         */
        public ParameterMap2(Map map) {
            super(map);
        }

        public Set entrySet() {
            // xwork使用了此方法取值
            if (entrySet == null) {
                entrySet = new HashSet();
                Set temSet = super.entrySet();
                for (Iterator iterator = temSet.iterator(); iterator.hasNext();) {
                    Map.Entry me = (Map.Entry) iterator.next();
                    Entry2 entry = new Entry2(me);
                    entrySet.add(entry);
                }
            }
            return entrySet;
        }

        // 若直接从map使用key取得
        public Object get(Object key) {
            Object value = super.get(key);
            // 不过滤此对象
            if (excludeNames != null && excludeNames.contains(key)) {
                return value;
            }
            if (value != null) {
                return trim(value);
            }
            return null;
        }
    }

    @SuppressWarnings("unchecked")
    private class Entry2<K, V> implements Map.Entry<K, V> {
        private Map.Entry me;
        private boolean isTrim = true;

        public Entry2(Map.Entry me) {
            if (me == null) {
                throw new IllegalArgumentException(
                        "Map.Entiry argument not null.");
            }
            this.me = me;
            // 不过滤此对象
            if (excludeNames != null && excludeNames.contains(me.getKey())) {
                isTrim = false;
            }
        }

        public K getKey() {
            return (K) me.getKey();
        }

        public V getValue() {
            if (isTrim) {
                return (V) trim(me.getValue());
            }
            return (V) me.getValue();
        }

        public V setValue(V value) {
            return (V) me.setValue(value);
        }

    }

    /**
     * 去除一个Object类型对应的前后空格，因为客户端提交参数有两种，一种：String，另一种：String[]，此方法会自动判断调用哪个方法。
     *
     * @param value
     *            需要处理的参数。
     * @return 处理后的值。
     */
    protected Object trim(Object value) {
        if (value instanceof String[]) {
            return trim((String[]) value);
        }
        return trim(value.toString());
    }

    /**
     * 去除某个字符串的前后空格。
     *
     * @param value
     *            需要处理的参数。
     * @return 处理后的值。
     */
    protected String trim(String value) {
        if (value != null && value.length() > 0) {
            return value.trim();
        }
        return value;
    }

    /**
     * 去除某个数组中所有的值的前后空格。
     *
     * @param values
     *            需要处理的数组。
     * @return 处理后的值，当数组的length为1时，则返回一个String，反之返回一个数组。
     */
    protected Object trim(String[] values) {
        if (values != null && values.length > 0) {
            int len = values.length;
            for (int i = 0; i < len; i++) {
                values[i] = trim(values[i]);
            }
        }
        if (values.length == 1) {
            return values[0];
        }
        return values;
    }

    /**
     *
     * @return 不处理的对象。
     */
    public List<String> getExcludeNames() {
        return excludeNames;
    }

}

这个Filter实现原理非常简单，我会过滤所有的请求，HttpServletRequestWrapper2继承自HttpServletRequestWrapper，在构造函数中需要一个HttpServletRequest对象(这个request是web窗口创建的)，然后我重载了上面所说的3个方法，在方法内部每次会去过滤当前值，这是利用了Java多态特性。在使用getParameterMap时较为麻烦，原理一样。
当然我们有时候可能有些特殊情况不需要过滤前后空格或者其它一些规则，这里我们可以使用exclude属性来判断是否过滤此属性。
DEMO：

<form action="test!create.action" method="post">
            name:
            <input name="name" value=" My name is haha.. " />
            <br />

            age:
            <input name="age" value="   15  " />
            <br />
            email:
            <input name="email" value=" grasszring@gmail.com " />
            <br />
            email2:
            <input name="email" value=" grasszring@foxmail.com " />
            <br />
            <input type="submit" value=" submit " />
form>

web.xml

<filter>
        <filter-name>requestParameterfilter-name>
        <filter-class>com.onlyeffort.commons.web.filter.RequestParameterFilterfilter-class>
        <init-param>

            <param-name>excludeparam-name>
            <param-value>emailparam-value>
        init-param>
    filter>
    <filter-mapping>
        <filter-name>requestParameterfilter-name>
        <url-pattern>/*url-pattern>
filter-mapping>

action

@Action(params = { "actionName", "test" })
@Result(location = "http://www.google.com", type = "redirect")
@SuppressWarnings("serial")
public class TestController extends ActionSupport {

    private String name;
    private Integer age;
    private String[] email;
        //.. get set method.

    @Override
    public String create() throws CreateFailureException {
        System.out.println(name);
        System.out.println(age);
        for (String mail : email) {
            System.out.println(mail);
        }
        return SUCCESS;
    }
}

OK,如果大家有什么问题或有什么意见都尽管留言，感激不尽。

Aidan 2010-06-10 14:45 发表评论

Struts2-疑难杂症之Validator返回input视图

Aidan — Tue, 08 Jun 2010 12:13:00 GMT

      在这里我不说struts2的验证原理以及语法，我只讲一下关于struts2验证返回input视图的解决办法。
      当然如果你是使用一个方法对一个类，则不存在上面的问题，当然一个方法对应一个类，这种方式虽然可读性很高但是实际开发确实不可取，因为他会使类极具增加。如果你是使用一个类对应多个方法，你肯定碰到过这样一个问题，那就是验证时返回input视图，struts2默认验证失败返回input视图，但是我们在写程序中经常会有多个方法需要验证，打个比方如：create、update这两个操作一般情况下都会验证，但是我们把它写在一个类中，我们如果区分验证失败后，到底是create失败了还是update失败了呢？这个时候有没有怀疑过struts2，呵呵。
      当然struts2其时已经给了我们解决办法，如果你是一个细心的人读过struts2源码便过发现struts2是如何解决问题的，在这里我也简单的分析一下struts2的源码，大家请看下面这个类。

package com.opensymphony.xwork2.interceptor;

import com.opensymphony.xwork2.Action;
import com.opensymphony.xwork2.ActionInvocation;
import com.opensymphony.xwork2.ValidationAware;
import com.opensymphony.xwork2.interceptor.annotations.InputConfig;
import com.opensymphony.xwork2.util.logging.Logger;
import com.opensymphony.xwork2.util.logging.LoggerFactory;

import java.lang.reflect.Method;

public class DefaultWorkflowInterceptor extends MethodFilterInterceptor {

    private static final long serialVersionUID = 7563014655616490865L;

    private static final Logger LOG = LoggerFactory.getLogger(DefaultWorkflowInterceptor.class);

    private static final Class[] EMPTY_CLASS_ARRAY = new Class[0];

    //默认返回input视图，是在这里定义的
    private String inputResultName = Action.INPUT;

    //可以在这里更改，一般没有人会这么做
    public void setInputResultName(String inputResultName) {
        this.inputResultName = inputResultName;
    }

    @Override
    protected String doIntercept(ActionInvocation invocation) throws Exception {
        Object action = invocation.getAction();

        if (action instanceof ValidationAware) {
            ValidationAware validationAwareAction = (ValidationAware) action;

            if (validationAwareAction.hasErrors()) {
                if (LOG.isDebugEnabled()) {
                    LOG.debug("Errors on action " + validationAwareAction + ", returning result name 'input'");
                }
                //one
                String resultName = inputResultName;
                /*
                在这里大家读一下源码即可明白，当前处理的Action如果是一个ValidationWorkflowAware类型的，
                则调用他的getInputResultName作用返回值
                为了方便我直接把ValidationWorkflowAware放在下面的注释中，大家看他是一个接口，
                也就是说如果我们的Action实现了ValidationWorkflowAware接口
                他则会调用getInputResultName方法返回的值，而非input，而默认的ActionSupport没有实现这个接口，我们需要手动实现

                */
                //package com.opensymphony.xwork2.interceptor;
                //public interface ValidationWorkflowAware {
                    // String getInputResultName();
                //}

                if (action instanceof ValidationWorkflowAware) {
                    resultName = ((ValidationWorkflowAware) action).getInputResultName();
                }
                //这里不做讲述
                InputConfig annotation = action.getClass().getMethod(invocation.getProxy().getMethod(), EMPTY_CLASS_ARRAY).getAnnotation(InputConfig.class);
                if (annotation != null) {
                    if (!annotation.methodName().equals("")) {
                        Method method = action.getClass().getMethod(annotation.methodName());
                        resultName = (String) method.invoke(action);
                    } else {
                        resultName = annotation.resultName();
                    }
                }
                return resultName;
            }
        }

        return invocation.invoke();
    }

}

大家看到上面是不是已经恍然大悟了，呵呵，是的我们实现了ValidationWorkflowAware接口之后，只需要定义一个inputResultName属性生成了对应的get、set方法是不是就对应有了getInputResultName，而这个属性的值我们可以动态传入一个值进来，呵呵，大家看下面这个实例。

public abstract class ActionSupport extends
        com.opensymphony.xwork2.ActionSupport implements Result,
        ValidationWorkflowAware {

    private static final long serialVersionUID = 799075559195465128L;

    public static final int ERROR_MSG = -1;
    public static final int WARN_MSG = 0;
    public static final int SUCCESS_MSG = 1;

    public static long getSerialversionuid() {
        return serialVersionUID;
    }

    private ActionContext actionContext;
    private Object id;
    private Pagination pagn = new Pagination();
    private QueryResult results;
    private String inputResultName;

    /**
     * 初始化ActionContext对象
     */
    public ActionSupport() {
        actionContext = ActionContext.getContext();
    }

    /**
     *
     * @return ActionContext对象
     */
    public ActionContext getActionContext() {
        return actionContext;
    }

    /**
     *
     * @return Struts封装后的ServletContext对象。
     */
    public Map<String, Object> getApplication() {
        return actionContext.getApplication();
    }

    /**
     *
     * @return 取得标识。
     */
    public Object getId() {
        return id;
    }

    /**
     * 取得指定类型的标识。
     *
     * @param
     * @param c
     * @return
     */
    @SuppressWarnings("unchecked")
    public <E> E getId(Class<E> c) {
        return (E) id;
    }

    /**
     *
     * @return 输出对象。
     * @throws IOException
     */
    public PrintWriter getOut() throws IOException {
        return getResponse().getWriter();
    }

    /**
     *
     * @return 分页参数对象。
     */
    public Pagination getPagn() {
        return pagn;
    }

    /**
     *
     * @return HttpServletRequest对象。
     */
    public HttpServletRequest getRequest() {
        return ServletActionContext.getRequest();
    }

    /**
     *
     * @return HttpServletResponse对象。
     */
    public HttpServletResponse getResponse() {
        return ServletActionContext.getResponse();
    }

    /**
     *
     * @return 查询结果集。
     */
    public QueryResult getResults() {
        return results;
    }

    /**
     *
     * @return ServletContext对象。
     */
    public ServletContext getServletContext() {
        return (ServletContext) this.actionContext
                .get(StrutsStatics.SERVLET_CONTEXT);
    }

    /**
     *
     * @return Struts封装后的HttpSession对象。
     */
    public Map<String, Object> getSession() {
        return actionContext.getSession();
    }

    /**
     *
     * @return Struts的ValueStack对象。
     */
    public ValueStack getValueStack() {
        return ServletActionContext.getValueStack(getRequest());
    }

    /**
     * 向ActionContext中添加一个信息，此信息会保存到HttpServletRequest中。
     *
     * @param key
     *            键。
     * @param value
     *            值。
     */
    public void put(String key, Object value) {
        actionContext.put(key, value);
    }

    public void setActionContext(ActionContext actionContext) {
        this.actionContext = actionContext;
    }

    /**
     *
     * @param id
     *            设置标识。
     */
    public void setId(Object id) {
        this.id = id;
    }

    /**
     *
     * @param pagn
     *            设置分页参数对象。
     */
    public void setPagn(Pagination pagn) {
        this.pagn = pagn;
    }

    /**
     *
     * @param results
     *            设置返回的结果集。
     */
    protected void setResults(QueryResult results) {
        this.results = results;
    }

    public String getInputResultName() {
        return inputResultName;
    }

    public void setInputResultName(String inputResultName) {
        this.inputResultName = inputResultName;
    }

    public abstract String show() throws Exception;

    public abstract String edit() throws EditFailureException;

    public abstract String destroy() throws DestroyFailureException;

    public abstract String create() throws CreateFailureException;

    public abstract String deleteConfirm() throws DeleteFailureException;

    public abstract String index() throws Exception;

    public abstract String update() throws UpdateFailureException;

    public abstract String editNew() throws EditFailureException;
}

上面是我自定义一个ActionSupport类，该类实现了ValidationWorkflowAware，并重写了getInputResultName方法。然后我再定义一个Action继承了该类。

@Namespace(value = "/test")
@Action(params = { "actionName", "demo" })
@Results( {
        @Result(name = "xx", type = "redirect", location = "http://www.google.com"),
        @Result(name = "hello", type = "redirect", location = "http://www.baidu.com") })
@SuppressWarnings("serial")
public class DownloadController extends ActionSupport {

    public String index() {
        System.out.println("-------index-----------");
        return "xx";
    }

    public void validateIndex() {
        addFieldError("hell", ".my hello.");
        System.out.println("ok");
    }
    //..省略了其它无关方法
}

在上面我就只是做了一个简单了模拟验证然后跳转到指定的页面。这里你可以这样请求，测试一个最终struts2是否调用了getInputResultName方法并使用其返回值，作为返回视图的名称：http://地址:端口/project/test/demo!index.action?inputResultName=hello，大家测试如果跳转到了baidu就说明成功了。
至此，有问题可以留言。

Aidan 2010-06-08 20:13 发表评论

Java学习笔记(1)——Java编程思想(一切皆对象)

Aidan — Wed, 02 Jun 2010 07:24:00 GMT

Java编程思想是学习Java必读之书，此书的内容跟名字一样，主要是以思想为主，如果没有编程经验，此书确实有点不太适合你，如果你有C/C++编程经验那这书正适合你，因为作者在内容中是以C/C++与Java作对比来学习的。如果你是直接学习Java可以先选择Java核心技术来学习，这本书主要是以技术入门为主，虽然里面也同样与C/C++作对比，但是学习起来会比Java编程思想要简单的多。当你运用Java有一段时间后，一定要回过头来学习Java编程这本书，因为它会让你更进一步。
在此次我的blog计划中，会把Java编程思想每一张的笔记都记录在blog中，我在经常在网上看到有人说Java编程思想讲得有点啰嗦，确实我读此书也有这种想法，所以在我的blog中我会尽量减少，只会出现有关Java和内容，会把作者描述的C/C++对比方面省略掉，当然这只是做一个参考，建议大家一定要去学习完整的Java编程思想。

1.用引用操纵对象

Java中一切都视为对象，但实际操作对象是一个“引用”(reference)标识符。
这就如果，遥控器(引用)操作电视(对象)一样，我们拿着遥控器就能与电视机保持连接。如果想要调整音量大小或者更换频道时，我们实际上是操作的遥控器，再由控制器调控电视机。我们可以带着控制器在房间四处走动，同样也可以操作电视机。
控制器和电视机是同时可以单独存在的，没有电视机，遥控器也可单独存在。

String s;

在上面我们创建了一个String的引用，但它只是一样引用，并未与任何一个对象相关联，如果你尝试向s发送消息，则会得到一个运行时异常，所以一种安全的做法是，在我们创建一个引用同时便为进行初始化。

String s = "init";

上面的String是Java中的一种特殊类型，所以可以直接使用带引号的文本进行初始化，通常，必须对Java中的对象采用一种更通用的初始化方法。

2.必须由自己创建所有的对象

通常我们使用new操作符来创建一个对象。

String s = new String("init");

上面是创建一个String对象同时初始化并把该对象的引用赋值给s，此时s便是一个对象的引用(s并非是一个对象，只是一个引用)。

2.1.存储位置

       Java中有5个不同的数据存储区：
       1).寄存器：它位于处理器内部是最快的存储区。但寄存器极其有限，它是根据需求进行分配，我们不能直接操作也不能在程序中感觉到它的存在。
       2).堆栈：位于通用RAM(随机访问存储器)中通过堆栈指针可以处理器哪里操作堆栈。指针向下移动则分配新的内存；若向上移动则释放那些内存，速度公次于存储器，但Java必须知道存储在堆栈内所有项的确切生命周期，以便上下移动指针。这限制了程序的灵活性，所以只有某些Java数据存储于堆栈中(对象的引用)，Java对象并不存放于其中。
       3).堆：通用的内存池，用于存放所有的Java对象。存储在堆里的数据编译器不需要知道存活多长时间。当使用new创建一个对象时，会自动在堆里存储分配。为了这种灵活性也牺牲更多的时间。
       4).常量存储：常量通过直接存放于代码的内部，因为他们永远不会被改变。
       5).非RAM存储：该存储于程序之外，即使程序停止依然保持自己的状态如(流对象，持久化对象)。对象转化为字节流，发送给另一台机器，“持久化对象”即对象被存储于磁盘或者其他媒介上，在需要时可恢复常规对象。

2.2.基本数据类型

       在Java中经常用到这样一系列特殊对象的“基本类型”，new创建对象会存储在“堆”里，如果是一些特别小的、简单的类型，往往不是那么有效，在Java中提供一些不需要使用new创建变量，而是创建一个并非引用的“自动”变量。这个变量直接存储“值”并存放于堆栈中。
       Java中的所有基本类型所占的存储空间大小是固定的，不会因为硬件架构变化而变化。

3.第一个Java程序

package com.onlyeffort.java.concurrency;

// 可替换为：import java.util.*;
import java.util.Random;

//定义一个公共类名为：HelloWorld
public class HelloWorld {
    // main方法，程序的入口，结构不可变，主体可变
    public static void main(String[] args) {
        // body start..大括号开始
        // 创建一个对象
        HelloWorld hw = new HelloWorld();
        // 使用hw引用调用say方法
        System.out.println(hw.say());
        // body end..大括号结束
    }
    /**
     *
     * @return 返回一个字符串,并打出出值.
     */
    public String say() {
        Random rand = new Random();
        return "Hello,World!" + rand.nextInt();
    }
}

      第一行为包声明语句，包名全为小写，一般为域名的反转形式，防止出现冲突，因为域名在全球是唯一的。
      当我们需要使用其它公共的类组件时需要使用import语句引入类。但java编译器在每个Java文件编译时会自动引用java.lang.*;下面的所有类，只是lang包下面的所有，但并不包含lang下面的子包，如果我们需要使用java.lang.reflect.Array;时，还需要我们手动引用。
      main方法是Java运行时程序的入口，结构单一不可改变。在main方法中我们创建了一个HelloWorld对象，并把它赋值给hw，此时hw是一个HelloWorld对象的一个引用，hw并非是一个对象。在后面我们调用了HelloWorld的say方法，此方法返回一个字符串，在say方法中，我们创建了一个随机数，并把它与一个字符串相连接。rand.nextInt()方法会返回一个int类型的整数，这里Java编译器会执行类型转换，把int类型转换为String类型并执行字符串连接。在最后我们使用了return语句返回这个方法的返回值。
      return在Java程序中有两种作用，一：会结束当前方法(return;);二：返回某个方法的返回值(return value;)。
      在这个HelloWorld中出现了“//”、“/***/”这都是Java当中的注释。Java编译器编译时会忽略注释后面的所有内容。

Aidan 2010-06-02 15:24 发表评论