JSON通用服务端处理

最近在学习JavaScript，发现不论是ext还是prototype都很推崇json这种通信协议的格式，但是这两个框架都是比较偏前端的，和dwr不同，dwr是一个一站式的ajax框架，不仅提供了客户端的工具方法，也包括服务端的配置和通信的处理。
而ext和prototype等仅仅设置好了json的接口并对ajax通信做了封装，相对而言是一种比较“纯粹”的AJAX实现，当然ext还包括了大量的图形组件，这又是题外话了。
为了解决ext们的通信问题，如果单纯的定义Servlet，实现起来比较原始，既复杂又不好管理。于是网上有好多人采用了dwr来管理通信，还有人用structs作为对接口Servlet的映射配置管理，这样一来不论是客户端还是服务端，都有很多功能被切割掉了，显得不够“干净”。于是我写了下面的两个响应的Servlet处理类来解决这个问题。
代码如下：

Java代码

1. JSONServlet.java:   
2. package com.digitalchina.dcscm.service;   
3.   
4. import java.io.*;   
5. import java.lang.reflect.Method;   
6. import java.util.Enumeration;   
7. import java.util.HashMap;   
8.   
9. import javax.servlet.ServletException;   
10. import javax.servlet.http.HttpServletRequest;   
11. import javax.servlet.http.HttpServletResponse;   
12. import org.json.*;   
13.   
14. /**  
15.  * 通用JSON服务端  
16.  *   
17.  * @author 杨一  
18.  */  
19.   
20. public class JSONServlet extends javax.servlet.http.HttpServlet implements  
21.         javax.servlet.Servlet {   
22.        
23.     public JSONServlet() {   
24.         super();   
25.            
26.     }   
27.   
28.     protected void doPost(HttpServletRequest request,   
29.             HttpServletResponse response) throws ServletException, IOException {   
30.         JSONObject jsonObject = null;   
31.         String responseText = null;   
32.         try {   
33.             //JSON对象，由参数json定义   
34.             jsonObject = new JSONObject(request.getParameter("json"));   
35.                
36.             //访问的类和方法，例如Object ExampleClass.exampleMethod()   
37.             String action = (String)request.getParameter("action");   
38.             int dotPos = action.lastIndexOf(".");   
39.                
40.             String beanName = action.substring(0, dotPos);   
41.             String methodName = action.substring(dotPos + 1);   
42.                
43.             //在当前线程环境中找当前作用类的实例   
44.             Object bean = findInstance(beanName);   
45.             //作用类的原型的引用   
46.             Class clazz;   
47.                
48.             //如果当前线程环境中有当前作用类的实例，获取其引用，否则实例化并返回引用,同时在线程中保存值   
49.             if(bean == null){   
50.                 clazz = Class.forName(beanName);   
51.                 bean = clazz.newInstance();   
52.                 storeInstance(beanName, bean);   
53.             } else{   
54.                 clazz = bean.getClass();   
55.             }   
56.   
57.             //设置JSON值   
58.             AbstractJsonAction aja = (AbstractJsonAction)bean;   
59.             aja.initJson(jsonObject);   
60.                
61.             //获得要执行的方法   
62.             Method m = clazz.getMethod(methodName);   
63.                
64.             //设置bean的其他参数   
65.             Enumeration e = request.getParameterNames();   
66.             Method setM;   
67.             while(e.hasMoreElements()){   
68.                 String str = (String)e.nextElement();   
69.                 if(str.equals("json") || str.equals("action")){   
70.                     continue;   
71.                 }   
72.                 StringBuffer sb = new StringBuffer();   
73.                 sb.append("set");   
74.                 sb.append(upperFirstChar(str));   
75.                 String tempMName = sb.toString();   
76.                 setM = clazz.getMethod(tempMName, new Class[]{String.class});   
77.                 setM.invoke(bean, (String)request.getParameter(str));   
78.             }   
79.                
80.             //执行方法   
81.             Object retObj = m.invoke(bean);   
82.                
83.             //此处的Object要进行重写toString方法，使其返回一个json串给客户端   
84.             responseText = retObj.toString();   
85.         } catch (Exception e) {   
86.             e.printStackTrace();   
87.         }    
88.         response.setCharacterEncoding("UTF-8");   
89.         response.setContentType("application/x-json");   
90.         response.getWriter().print(responseText);   
91.     }   
92.        
93.     private String upperFirstChar(String fieldName) {   
94.         char ch = fieldName.charAt(0);   
95.         ch = Character.toUpperCase(ch);   
96.         StringBuffer sb = new StringBuffer();   
97.         sb.append(ch);   
98.         sb.append(fieldName.substring(1));   
99.         fieldName = sb.toString();   
100.         return fieldName;   
101.     }   
102.        
103.     private Object findInstance(String beanName){   
104.         HashMap hm = (HashMap)tl.get();   
105.         return hm.get(beanName);   
106.     }   
107.        
108.     private void storeInstance(String beanName, Object bean){   
109.         HashMap hm = (HashMap)tl.get();   
110.         hm.put(beanName, bean);   
111.     }   
112.        
113.     private static ThreadLocal tl = new ThreadLocal(){   
114.         protected Object initialValue() {return new HashMap();};   
115.     };   
116. }  

JSONServlet.java:
package com.digitalchina.dcscm.service;

import java.io.*;
import java.lang.reflect.Method;
import java.util.Enumeration;
import java.util.HashMap;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.json.*;

/**
 * 通用JSON服务端
 * 
 * @author 杨一
 */

public class JSONServlet extends javax.servlet.http.HttpServlet implements
		javax.servlet.Servlet {
	
	public JSONServlet() {
		super();
		
	}

	protected void doPost(HttpServletRequest request,
			HttpServletResponse response) throws ServletException, IOException {
		JSONObject jsonObject = null;
		String responseText = null;
		try {
			//JSON对象，由参数json定义
			jsonObject = new JSONObject(request.getParameter("json"));
			
			//访问的类和方法，例如Object ExampleClass.exampleMethod()
			String action = (String)request.getParameter("action");
			int dotPos = action.lastIndexOf(".");
			
			String beanName = action.substring(0, dotPos);
			String methodName = action.substring(dotPos + 1);
			
			//在当前线程环境中找当前作用类的实例
			Object bean = findInstance(beanName);
			//作用类的原型的引用
			Class clazz;
			
			//如果当前线程环境中有当前作用类的实例，获取其引用，否则实例化并返回引用,同时在线程中保存值
			if(bean == null){
				clazz = Class.forName(beanName);
				bean = clazz.newInstance();
				storeInstance(beanName, bean);
			} else{
				clazz = bean.getClass();
			}

			//设置JSON值
			AbstractJsonAction aja = (AbstractJsonAction)bean;
			aja.initJson(jsonObject);
			
			//获得要执行的方法
			Method m = clazz.getMethod(methodName);
			
			//设置bean的其他参数
			Enumeration e = request.getParameterNames();
			Method setM;
			while(e.hasMoreElements()){
				String str = (String)e.nextElement();
				if(str.equals("json") || str.equals("action")){
					continue;
				}
				StringBuffer sb = new StringBuffer();
				sb.append("set");
				sb.append(upperFirstChar(str));
				String tempMName = sb.toString();
				setM = clazz.getMethod(tempMName, new Class[]{String.class});
				setM.invoke(bean, (String)request.getParameter(str));
			}
			
			//执行方法
			Object retObj = m.invoke(bean);
			
			//此处的Object要进行重写toString方法，使其返回一个json串给客户端
			responseText = retObj.toString();
		} catch (Exception e) {
			e.printStackTrace();
		} 
		response.setCharacterEncoding("UTF-8");
		response.setContentType("application/x-json");
		response.getWriter().print(responseText);
	}
	
    private String upperFirstChar(String fieldName) {
        char ch = fieldName.charAt(0);
        ch = Character.toUpperCase(ch);
        StringBuffer sb = new StringBuffer();
        sb.append(ch);
        sb.append(fieldName.substring(1));
        fieldName = sb.toString();
        return fieldName;
    }
    
    private Object findInstance(String beanName){
    	HashMap hm = (HashMap)tl.get();
    	return hm.get(beanName);
    }
    
    private void storeInstance(String beanName, Object bean){
    	HashMap hm = (HashMap)tl.get();
    	hm.put(beanName, bean);
    }
	
	private static ThreadLocal tl = new ThreadLocal(){
		protected Object initialValue() {return new HashMap();};
	};
}

 

Java代码

1. AbstractJsonAction.java:   
2.   
3. import org.json.JSONObject;   
4.   
5. /** *//**  
6.  * 抽象JSON Action类，负责处理各种业务，可以有自己的参数，数据结构采用JSON定义，业务方法名自己定义  
7.  * 可以通过继承定义具体业务  
8.  *   
9.  * @author 杨一  
10.  */  
11. public abstract class AbstractJsonAction {   
12.  public AbstractJsonAction(){}   
13.     
14.  public void initJson(JSONObject json){   
15.   this.json = json;   
16.  }   
17.     
18.  protected JSONObject json;    
19. }  

AbstractJsonAction.java:

import org.json.JSONObject;

/** *//**
 * 抽象JSON Action类，负责处理各种业务，可以有自己的参数，数据结构采用JSON定义，业务方法名自己定义
 * 可以通过继承定义具体业务
 * 
 * @author 杨一
 */
public abstract class AbstractJsonAction {
 public AbstractJsonAction(){}
 
 public void initJson(JSONObject json){
  this.json = json;
 }
 
 protected JSONObject json; 
}

仅仅是表述一种想法，欢迎大家批评，呵呵：）