设计模式之职责链模式

设计模式之职责链模式

设计模式之职责链 
 最近，在学习ajax的时候，发现了一个前后台传输数据的好东东：json，通过json字符串我们能很快的将java对象转换成javascript对象，至于json具体是什么东西，可以上他的官方网站去查看一下。这里简单的介绍一下： json用一对大括号来表示一个对象，并用冒号隔开属性和值，用逗号分隔多个属性。表示数组对象的时候json用一对中括号表示。如下:
   1：json代码来表示一个对象：   {"name":"杨川","sex":"男","age":26}.
     这就表示了一个人的对象。 它的属性name = 杨川，性别=男 。年纪 =26岁。
   2：json表示数组： [1,2,3,{"name":"sam","sex":"man"}].
     这个就是一个数组，  其实熟悉javascript的人，都应该能看出来 json非常相似于javascript的直接量。比如数组直接量，对象直接量。
   恩，到这里我简单介绍一下我要做的事情。是这样的,我们的javascript可以通过一个eval函数，将json字串转化成它自己的对象，比如上边的那个对象我们要穿换成 我们的 javascript对象就可以这样写
   jsonText = " {'name':'杨川','sex':'男','age':26}"
   var person = eval('('+jsonText+')');  //得到一个javascrip对象
   alert(person.name)  //提示: 杨川。
所以，我们只要在java服务端将pojo生成一个个的json字符串，在前台就可以 很简单的转换为js对象了。为前台的数据使用提供了很大的方便 。
  因此我尝试写了这么一个转换工具包，结果，在编写的时候，发现职责链模式到时很适合这个。就拿来用了。呵呵，当然我下边的 代码不一定是唯一的，完善的，如果各位看客有更好的 思路和方法。还请赐教啊。
      好了，言归正传了。
  我对职责链的理解是这样的，在处理某些业务的时候，我们可能会判断不同的情况去选择做不同的业务处理，这样就可能导致大量的if else语句组出来。导致程序的扩展维护相当困难，就比如我这里转换json的这个例子，我的一个tojson(Object object)函数。他里边就要判断这样一些情况，如果是一个pojo则返回的字符串首尾加上一对大括号，如果是数组则首尾加上一对中括号。在处理数组的时候还要考虑数组元素是pojo，数组，集合或其它等情况，当然pojo的属性对象，也得考虑它是否是一个基本数据类，pojo，数组或其它等情况。下边看看我的代码。

public class JSONArray{
@SuppressWarnings("unchecked")
 public static String toJson(Collection collection) {
  StringBuffer buffer = new StringBuffer();
  buffer.append("[");
  for (Object object : collection) {
   if (object instanceof Collection) {
    System.out.println(object.toString());
    JsonArray.toJson((Collection) object);
   } else {
    if (object.getClass().isArray()) {
     System.out.println(object.toString());
     JsonArray.toJson((Object[]) object);
    } else {
     if (buffer.length() > 1)
      buffer.append(",");
     buffer.append(JsonObject.toJson(object));
    }
   }
  }
  buffer.append("]");
  return buffer.toString();
 }

 @SuppressWarnings("unchecked")
 public static String toJson(Object[] collection) {

  StringBuffer buffer = new StringBuffer();
  buffer.append("[");
  for (Object object : collection) {
   if (object.getClass().isArray()) {
    System.out.println(object.toString());
    JsonArray.toJson((Object[]) object);
   } else {
    if (object instanceof Collection) {
     System.out.println(object.toString());
     JsonArray.toJson((Object[]) object);
    } else {
     if (buffer.length() > 1)
      buffer.append(",");
     buffer.append(JsonObject.toJson(object));
    }
   }

  }
  buffer.append("]");
  return buffer.toString();
 }

}
看看上边 这段代码，是不是很多if else语句，试想一下我如果再加入一个HashMap的处理方法进来，我
是不是要 到上边 每一个 方法都要加上这个类型的判断处理呢？哪以后再加 呢 ？？是不是很难维护了。
       所以，这个地方我们就应该采用 职责链模式来完成这个处理。职责链模式会将不同类型的处理提出来单独放在各自不同的类里去处理。当你传入的数据类型时，它会依次在这些处理类里传递，直到找到该类型的处理类为止。

    好 ，先定义一个接口。如下：

责任链接口
 1/**//*
 2* @(#)JSONChain.java
 3* createTime：Apr 21, 2008 9:08:24 PM
 4*/
 5package com.sam.jsontool.util;
 6/** *//**
 7 * @author sam E-mail:ashan8888@163.com
 8 * @version 1.0
 9 */
10public interface JSONChain {
11   void addChain(JSONChain chain);
12   String doChain(Object objects) throws JSONException;
13   JSONChain getChain();   
14}
15
16
17

这个例子我们需要把不同数据类型提出来做相应处理。简单的可以分为，纯 pojo对象的 处理，数组的处理，集合的处理：代码如下：

纯对象的处理
  1/**//*
  2 * @(#)JSONObject.java
  3 * createTime：Apr 22, 2008 11:08:27 AM
  4 */
  5package com.sam.jsontool.util;
  6
  7import java.beans.BeanInfo;
  8import java.beans.IntrospectionException;
  9import java.beans.Introspector;
 10import java.beans.PropertyDescriptor;
 11import java.lang.reflect.InvocationTargetException;
 12import java.lang.reflect.Method;
 13
 14/** *//**
 15 * @author sam E-mail:ashan8888@163.com
 16 * @version 1.0
 17 */
 18public class JSONObject implements JSONChain {
 19
 20    public void addChain(JSONChain chain) {
 21
 22    }
 23
 24    public String doChain(Object objects) {
 25
 26        return toJson(objects);
 27    }
 28
 29    public JSONChain getChain() {
 30        return null;
 31    }
 32
 33    /** *//**
 34     * This method handles a object to a jsonText
 35     * 
 36     * @param object
 37     *            which it will be convert a json text;
 38     * @return a json text
 39     * @throws IllegalArgumentException
 40     * @throws IllegalAccessException
 41     * @throws InvocationTargetException
 42     * @throws IntrospectionException
 43     */
 44    @SuppressWarnings("unchecked")
 45    public static String toJson(Object object) {
 46        if (null == object)
 47            return "null";
 48        if (object.getClass().getPackage().getName().equals("java.lang"))
 49            return object.toString();
 50        Object methodResult = null;
 51        BeanInfo beanInfo = getBeanInfo(object);
 52        PropertyDescriptor[] descriptors = beanInfo.getPropertyDescriptors();
 53        Method method = null;
 54        StringBuffer buffer = new StringBuffer();
 55        buffer.append("{");
 56        for (PropertyDescriptor descriptor : descriptors) {
 57            method = descriptor.getReadMethod();
 58            if (null != method) {
 59                methodResult = invokeMethod(object, method);
 60                if (null == methodResult)
 61                    methodResult = "null";
 62                if (buffer.indexOf(":") > 1)
 63                    buffer.append(",");
 64                buffer.append("\"" + descriptor.getName() + "\":");
 65
 66                if (!methodResult.getClass().getPackage().getName().equals(
 67                        "java.lang")) {
 68                    buffer.append(toJson(methodResult));
 69                } else {
 70                    buffer.append(quote( methodResult.toString() ));
 71                }
 72            }
 73        }
 74        buffer.append("}");
 75        return buffer.toString();
 76    }
 77
 78    /** *//**
 79     * This method is return a BeanInfo object and it without Object class's
 80     * infomation.
 81     * 
 82     * @param object
 83     * @return
 84     */
 85    private static BeanInfo getBeanInfo(Object object) {
 86        BeanInfo beanInfo = null;
 87        try {
 88            beanInfo = Introspector
 89                    .getBeanInfo(object.getClass(), Object.class);
 90        } catch (IntrospectionException e) {
 91            e.printStackTrace();
 92        }
 93        return beanInfo;
 94    }
 95
 96    /** *//**
 97     * this method is called when you want invoke a method via ref
 98     * 
 99     * @param object
100     * @param method
101     * @return if no method find "null" will be return.
102     */
103    private static Object invokeMethod(Object object, Method method) {
104        Object result = null;
105        try {
106            result = method.invoke(object, new Object[0]);
107        } catch (IllegalArgumentException e) {
108            e.printStackTrace();
109        } catch (IllegalAccessException e) {
110            e.printStackTrace();
111        } catch (InvocationTargetException e) {
112            e.printStackTrace();
113        }
114        return result;
115    }
116    
117     public static String quote(String string) {
118            if (string == null || string.length() == 0) {
119                return "\"\"";
120            }
121
122            char         b;
123            char         c = 0;
124            int          i;
125            int          len = string.length();
126            StringBuffer sb = new StringBuffer(len + 4);
127            String       t;
128
129            sb.append('"');
130            for (i = 0; i < len; i += 1) {
131                b = c;
132                c = string.charAt(i);
133                switch (c) {
134                case '\\':
135                case '"':
136                    sb.append('\\');
137                    sb.append(c);
138                    break;
139                case '/':
140                    if (b == '<') {
141                        sb.append('\\');
142                    }
143                    sb.append(c);
144                    break;
145                case '\b':
146                    sb.append("\\b");
147                    break;
148                case '\t':
149                    sb.append("\\t");
150                    break;
151                case '\n':
152                    sb.append("\\n");
153                    break;
154                case '\f':
155                    sb.append("\\f");
156                    break;
157                case '\r':
158                    sb.append("\\r");
159                    break;
160                default:
161                    if (c < ' ') {
162                        t = "000" + Integer.toHexString(c);
163                        sb.append("\\u" + t.substring(t.length() - 4));
164                    } else {
165                        sb.append(c);
166                    }
167                }
168            }
169            sb.append('"');
170            return sb.toString();
171        }
172
173}
174

利用反射，读出属性和对应方法，并按json的格式输出字符串，为了前台方便转换，这里注意了转义字符的处理。

2：处理集合类型：

集合类型的处理
 1/**//*
 2 * @(#)JSONCollection.java
 3 * createTime：Apr 22, 2008 7:31:54 PM
 4 */
 5package com.sam.jsontool.util;
 6
 7import java.util.Collection;
 8import java.util.Iterator;
 9
10/** *//**
11 * This class is handles Collection Object to a jsonText
12 * 
13 * @author sam E-mail:ashan8888@163.com
14 * @version 1.0
15 */
16public class JSONCollection implements JSONChain {
17
18    private JSONChain nextChain;
19
20    public void addChain(JSONChain chain) {
21        this.nextChain = chain;
22    }
23
24    @SuppressWarnings("unchecked")
25    public String doChain(Object objects) throws JSONException {
26        if ((null != objects) && (objects instanceof Collection)) {
27            StringBuffer buffer = new StringBuffer();
28            Iterator iterator = ((Collection) objects).iterator();
29            if (null == iterator) {
30                buffer.append("null");
31                return buffer.toString();
32            }
33            buffer.append("[");
34            while (iterator.hasNext()) {
35                if (buffer.length() > 1)
36                    buffer.append(",");
37                buffer.append(JSONTool.toJSON(iterator.next()));
38            }
39            buffer.append("]");
40            return buffer.toString();
41        } else {
42            if (nextChain != null)
43                return nextChain.doChain(objects);
44            else
45                throw new JSONException("处理对象null异常");
46        }
47    }
48
49    public JSONChain getChain() {
50        return nextChain;
51    }
52
53}
54

3：数组的处理：

数组的处理
 1/**//*
 2 * @(#)JSONObject.java
 3 * createTime：Apr 21, 2008 8:08:42 PM
 4 */
 5package com.sam.jsontool.util;
 6
 7/** *//**
 8 * @author sam E-mail:ashan8888@163.com
 9 * @version 1.0
10 */
11public class JSONArray implements JSONChain {
12
13    private JSONChain nextChain;
14
15    public void addChain(JSONChain chain) {
16        nextChain = chain;
17    }
18
19    public JSONChain getChain() {
20        return nextChain;
21    }
22
23    public String doChain(Object objects) throws JSONException {
24        if ((null!=objects)&& (objects.getClass().isArray())) {
25            StringBuffer buffer = new StringBuffer();
26            buffer.append("[");
27            for (Object obj : (Object[]) objects) {
28                if (buffer.length() > 1)
29                    buffer.append(",");
30                buffer.append(JSONTool.toJSON(obj));
31            }
32            buffer.append("]");
33            return buffer.toString();
34        } else {
35            if(nextChain != null)
36                 return nextChain.doChain(objects);
37                else throw new JSONException("处理对象null异常"); 
38        }
39
40    }
41
42}
43

4: 责任链的 组装

 1 /**/ /*
 2* @(#)JSONClient.java
 3* createTime：Apr 22, 2008 8:41:10 AM
 4*/
 5 package  com.sam.jsontool.util;
 6
 7
 8 /** */ /**
 9 * @author sam E-mail:ashan8888@163.com
10 * @version 1.0
11 */
12 public   class  JSONTool  {
13    
14    private static JSONArray array ; 
15    private static JSONCollection collection;
16    private static JSONObject obj;
17    static{
18        array= new JSONArray(); 
19        collection = new JSONCollection();
20        obj = new JSONObject();
21        collection.addChain(array);
22        array.addChain(obj);
23    }
24    
25    
26    public static String toJSON(Object object){        
27        String result = null;
28        try {
29            result = collection.doChain(object);
30        } catch (JSONException e) {
31            e.printStackTrace();        
32        }
33        return result;
34    }
35    
36    
37}
38

5：测认结果：

简单的单元测试
  1/**//*
  2* @(#)JSONArrayTest.java
  3* createTime：Apr 21, 2008 8:22:27 PM
  4*/
  5package com.sam.jsontool.utiltest;
  6
  7import java.util.ArrayList;
  8import java.util.HashSet;
  9import java.util.List;
 10
 11import com.sam.jsontool.util.JSONTool;
 12
 13import junit.framework.TestCase;
 14
 15/** *//**
 16 * @author sam E-mail:ashan8888@163.com
 17 * @version 1.0
 18 */
 19public class JSONArrayTest extends TestCase {
 20
 21/** *//**
 22 *  测试一个简单的javabean。
 23 * @throws Exception
 24 */
 25    public void testSimpleJB() throws Exception {
 26        Person person = new Person();
 27        person.setName("男");
 28        person.setAge(28);
 29        person.setSex(true);
 30        System.out.println(JSONTool.toJSON(person));
 31    }
 32    /** *//**
 33     * 测试一个简单的 数组。
 34     * @throws Exception
 35     */
 36    public void testSimpleArray() throws Exception {
 37        Object[] objects = new  Object[10];
 38        for(int i = 0;i<10;i++){
 39            Person person = new Person();
 40            person.setName("男");
 41            person.setAge(28+i);
 42            person.setSex(true);
 43            objects[i] = person;            
 44        }
 45        System.out.println(JSONTool.toJSON(objects));
 46    }
 47/** *//**
 48 * 测试一个简单的 list.
 49 * @throws Exception
 50 */
 51    @SuppressWarnings("unchecked")
 52    public void testSimpleList() throws Exception {
 53        List list = new  ArrayList();
 54        for(int i = 0;i<10;i++){
 55            Person person = new Person();
 56            person.setName("男");
 57            person.setAge(28+i);
 58            person.setSex(true);
 59            list.add(person);
 60        }
 61        System.out.println(JSONTool.toJSON(list));
 62    }
 63    /** *//**
 64     * 测试一个复合的 list
 65     * @throws Exception
 66     */
 67    @SuppressWarnings("unchecked")
 68    public void testcomList() throws Exception {
 69        Object[] objects = new  Object[3];
 70        for(int i = 0;i<2;i++){
 71            Person person = new Person();
 72            person.setName("男");
 73            person.setAge(28+i);
 74            person.setSex(true);
 75            objects[i] = person;            
 76        }
 77        List list = new  ArrayList();
 78        list.add(123);
 79        for(int i = 1;i<5;i++){
 80            Person person = new Person();
 81            person.setName("男");
 82            person.setAge(28+i);
 83            person.setSex(true);
 84            if (i==2) {
 85                list.add(objects);
 86            }else list.add(person);
 87        }
 88        System.out.println(JSONTool.toJSON(list));
 89    }
 90    
 91    /** *//**
 92     * 测试集合元素中某集合为空的情况
 93     * @throws Exception
 94     */
 95    public void testCollection() throws Exception {
 96        
 97        List list = new  ArrayList();
 98        list.add("sam\\tiger");
 99        
100        list.add(new HashSet());
101        Person person = new Person();
102        person.setName("男");
103        person.setAge(28);
104        person.setSex(true);
105        list.add(person);
106        System.out.println(list.toString());
107        System.out.println(JSONTool.toJSON(list));
108    }
109}
110

呵呵，现在要是加入HashMap的类型处理 是不是很简单了，只要加入一个类就可以了